澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站:数字类型,python数据类型

2019-08-24 作者:www.8455.com   |   浏览(62)

1.概念介绍

详解python的数字类型变量与其方法,详解python

前言

python数据类型是不允许改变的,这就意味着如果改变 Number 数据类型的值,将重新分配内存空间。下面话不多说,来看看详细的介绍吧。

以下实例在变量赋值时 Number 对象将被创建:

var1 = 1
var2 = 10

您也可以使用del语句删除一些 Number 对象引用。

您可以通过使用del语句删除单个或多个对象,例如:

del var
del var_a, var_b

Python 支持四种不同的数值类型:

整型(Int)               - 通常被称为是整型或整数,是正或负整数,不带小数点。

长整型(long)        - 无限大小的整数,整数最后是一个大写或小写的L,如:51924361L  。

浮点型(float)        - 浮点型由整数部分与小数部分组成,浮点型也可以使用科学计数法表示
                           (2.5e2 = 2.5 x 10^2 = 250)

复数(complex )   - 复数由实数部分和虚数部分构成,可以用a bj,或者complex(a,b)表示, 
                             复数的实部a和虚部b都是浮点型。

Python Number 类型转换:

int(x [,base ])     将x转换为一个整数

long(x [,base ])    将x转换为一个长整数

float(x )        将x转换到一个浮点数

complex(real [,imag ]) 创建一个复数

str(x )         将对象 x 转换为字符串

repr(x )        将对象 x 转换为表达式字符串

eval(str )       用来计算在字符串中的有效Python表达式,并返回一个对象

tuple(s )        将序列 s 转换为一个元组

list(s )        将序列 s 转换为一个列表

chr(x )         将一个整数转换为一个字符

unichr(x )       将一个整数转换为Unicode字符

ord(x )         将一个字符转换为它的整数值

hex(x )         将一个整数转换为一个十六进制字符串

oct(x )         将一个整数转换为一个八进制字符串

Python数学函数:

函数           返回值 ( 描述 )

abs(x)     返回数字的绝对值,如abs(-10) 返回 10

ceil(x)    返回数字的上入整数,如math.ceil(4.1) 返回 5

cmp(x, y)  如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1

exp(x)     返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045

fabs(x)    返回数字的绝对值,如math.fabs(-10) 返回10.0

floor(x)   返回数字的下舍整数,如math.floor(4.9)返回 4

log(x)     如math.log(math.e)返回1.0,math.log(100,10)返回2.0

log10(x)   返回以10为基数的x的对数,如math.log10(100)返回 2.0

max(x1, x2,...)  返回给定参数的最大值,参数可以为序列。

min(x1, x2,...)  返回给定参数的最小值,参数可以为序列。

modf(x)    返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。

pow(x, y)  x**y 运算后的值。

round(x [,n])   返回浮点数x的四舍五入值,如给出n值,则代表舍入到小数点后的位数。

sqrt(x)    返回数字x的平方根,数字可以为负数,返回类型为实数,如math.sqrt(4)返回 2 0j

注意:

1、python的数学函数很多不能直接访问的,需要导入 math 模块,通过静态对象调用该方法。
由于不确定哪个方法需要,所以以后在用python数学函数时最好引入 math 模块。

2、可以直接访问的数学函数:

abs(x)  返回数字的绝对值,如abs(-10) 返回 10
cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
max(x1, x2,...) 返回给定参数的最大值,参数可以为序列。
min(x1, x2,...) 返回给定参数的最小值,参数可以为序列。
round(x [,n]) 返回浮点数x的四舍五入值,如给出n值,则代表舍入到小数点后的位数。

实例:

#!/usr/bin/python
#coding:uft-8
import math # 导入 math 模块

print "max(80, 100, 1000) : ", max(80, 100, 1000)
print "min(80, 100, 1000) : ", min(80, 100, 1000)
print "round(80.23456, 2) : ", round(80.23456, 2)
print "math.exp(-45.17) : ", math.exp(-45.17)
print "math.pow(100, 2) : ", math.pow(100, 2)

Python随机数函数:

函数  描述

choice(seq)    从序列的元素中随机挑选一个元素,比如random.choice(range(10)),从0到9中随机挑选一个整数。

randrange ([start,] stop [,step])   从指定范围内,按指定基数递增的集合中获取一个随机数,基数缺省值为1

random()       随机生成下一个实数,它在[0,1)范围内。

seed([x])      改变随机数生成器的种子seed。

shuffle(lst)   将序列的所有元素随机排序

uniform(x, y)  随机生成下一个实数,它在[x,y]范围内。

注意:

1、python的随机数函数是不能直接访问的,需要导入 random 模块,然后通过 random 静态对象调用该方法。

实例:

#!/usr/bin/python
# -*- coding: UTF-8 -*-
import random

print "choice([1, 2, 3, 5, 9]) : ", random.choice([1, 2, 3, 5, 9])
# 输出 100 <= number < 1000 间的偶数
print "randrange(100, 1000, 2) : ", random.randrange(100, 1000, 2)
# 生成第一个随机数
print "random() : ", random.random()
# 生成同一个随机数
random.seed( 10 )
print "Random number with seed 10 : ", random.random()
list = [20, 16, 10, 5];
random.shuffle(list)
print "随机排序列表 : ", list
print "uniform(5, 10) 的随机数为 : ", random.uniform(5, 10)

Python三角函数:

 函数            描述

acos(x)     返回x的反余弦弧度值。

asin(x)     返回x的反正弦弧度值。

atan(x)     返回x的反正切弧度值。

atan2(y, x) 返回给定的 X 及 Y 坐标值的反正切值。

cos(x)      返回x的弧度的余弦值。

hypot(x, y) 返回欧几里德范数 sqrt(x*x y*y)。

sin(x)      返回的x弧度的正弦值。

tan(x)      返回x弧度的正切值。

degrees(x)  将弧度转换为角度,如degrees(math.pi/2) , 返回90.0

radians(x)  将角度转换为弧度

注意:

1、Python三角函数是不能直接访问的,需要导入 math 模块,然后通过 math 静态对象调用该方法。

实例:

#!/usr/bin/python
#coding: UTF-8
import math

print "degrees(3) : ", math.degrees(3)
print "radians(-3) : ", math.radians(-3)
print "sin(3) : ", math.sin(3)
print "cos(3) : ", math.cos(3)
print "tan(3) : ", math.tan(3)
print "acos(0.64) : ", math.acos(0.64)
print "asin(0.64) : ", math.asin(0.64)
print "atan(0.64) : ", math.atan(0.64)
print "atan2(-0.50,-0.50) : ", math.atan2(-0.50,-0.50)
print "hypot(0, 2) : ", math.hypot(0, 2)

Python数学常量:

常量              描述
 pi      数学常量 pi(圆周率,一般以π来表示)
 e       数学常量 e,e即自然常数(自然常数)。

注意:

1、Python数学常量也是不能直接访问的,需要导入 math 模块,然后通过 math 静态对象访问。

实例:

#!/usr/bin/python
#coding: UTF-8
import math

print math.pi
print math.e

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家学习或者使用python能有所帮助,如果有疑问大家可以留言交流。

前言 python数据类型是不允许改变的,这就意味着如果改变 Number 数据类型的值,将重新分配内...

Python内置数据类型总结(数字类型),python数据类型

  python是近年来使用最广泛的一种编程语言,不管是做web开发,还是网络爬虫,亦或是数据分析等,大家都在选择python来完成这些任务;我想最重要一点就是python学起来很简单,另一个点就是python用的地方非常多,综合起来就是性价比非常高。这节看看基本数据类型中的整数和浮点数。

Python内置数据类型总结(数字类型)

  数据类型是一种值的集合以及定义在这种值上的一组操作。一切语言的基础都是数据结构,所以打好基础对于后面的学习会有百利而无一害的作用。
  python内置的常用数据类型有:数字、字符串、Bytes、列表、元组、字典、集合、布尔等

  想想设置这么多类型的原因是什么?

  1、在数据组织上方便统一管理,提供同样的方法去调用。区分数据类型,也和人们日常对事物的分类认识一致,便于人们从具体的对象抽象出统一的模式去处理数据。方便同样的数据用同样的方式去处理,限制非法操作的行为,便于数据的控制。
  2、对于数据在内存和磁盘上的存储来说,节约了空间。假如不区分数据类型,所有的数据对象都必须按长度最大的数据对象去占用存储空间,浪费严重。有了数据类型,就按照类型预先定义的空间大小去组织存储,对于每种数据类型去合理分配大小,能提高空间使用率,以及存取速度和运行效率。

  python的数据类型以是否可变,可分为可变类型和不可变类型,对于可变类型来说,操作一般涉及增、删、改、查,对于不可变类型,一般的操作只有查。

   不可变类型:数字、字符串、bytes、元组

   可变类型:列表、字典、集合

 

Python分为2.x版本和3.x版本,3.x版本规范了代码,但不向下兼容。

Python内置数据类型总结(数字类型)

  数据类型是一种值的集合以及定义在这种值上的一组操作。一切语言的基础都是数据结构,所以打好基础对于后面的学习会有百利而无一害的作用。
  python内置的常用数据类型有:数字、字符串、Bytes、列表、元组、字典、集合、布尔等

  想想设置这么多类型的原因是什么?

  1、在数据组织上方便统一管理,提供同样的方法去调用。区分数据类型,也和人们日常对事物的分类认识一致,便于人们从具体的对象抽象出统一的模式去处理数据。方便同样的数据用同样的方式去处理,限制非法操作的行为,便于数据的控制。
  2、对于数据在内存和磁盘上的存储来说,节约了空间。假如不区分数据类型,所有的数据对象都必须按长度最大的数据对象去占用存储空间,浪费严重。有了数据类型,就按照类型预先定义的空间大小去组织存储,对于每种数据类型去合理分配大小,能提高空间使用率,以及存取速度和运行效率。

  python的数据类型以是否可变,可分为可变类型和不可变类型,对于可变类型来说,操作一般涉及增、删、改、查,对于不可变类型,一般的操作只有查。

   不可变类型:数字、字符串、bytes、元组

   可变类型:列表、字典、集合

 

  

数字类型

  用于存储数学上的值,比如整数、浮点数、复数等。数字类型在python中是不可变类型,意思是一个变量被赋予了一个不一样的数值之后就不再是原来的内存指向了,python是基于值得内存管理机制。

为什么要使用Python这门语言?1.软件质量高    2.开发效率高   3.可移植性好   4.标准库的支持    

数字类型

  用于存储数学上的值,比如整数、浮点数、复数等。数字类型在python中是不可变类型,意思是一个变量被赋予了一个不一样的数值之后就不再是原来的内存指向了,python是基于值得内存管理机制。

一、目录
1、字符串
2、布尔类型
3、整数
4、浮点数
5、数字
6、列表
7、元组
8、字典
9、日期

  1.整数(Int)

  通常称为整型,包括正数和负数,python3不在长度上区分整数的类型了,就是不再有长整型。
  数字也有八进制和十六进制表示法:
  十六进制:前缀0x和0-9,a-f表示,例如:0xff00
  八进制:前缀0o和0-7表示,例如:0o17
  Python的整数长度为32位,通常是连续分配的内存空间。Python初始化时会自动建立一个小整数对象池,-5到256之间,方便调用,避免后期重复生成。
除了小整数对象池,Python还有整数缓冲区,就是刚被删除的整数,不会立即被删除回收,而是在后台缓冲一段时间,等待下次可能的调用.

  例如:   a = 3453453
  print(id(a))---->内存编号33402576
  del a      #已经删除
  b = 3453453 #将3453453赋值给b
  print(id(b))----->内存编号33402576

Python优点很多,缺点是速度不够快    

  1.整数(Int)

  通常称为整型,包括正数和负数,python3不在长度上区分整数的类型了,就是不再有长整型。
  数字也有八进制和十六进制表示法:
  十六进制:前缀0x和0-9,a-f表示,例如:0xff00
  八进制:前缀0o和0-7表示,例如:0o17
  Python的整数长度为32位,通常是连续分配的内存空间。Python初始化时会自动建立一个小整数对象池,-5到256之间,方便调用,避免后期重复生成。
除了小整数对象池,Python还有整数缓冲区,就是刚被删除的整数,不会立即被删除回收,而是在后台缓冲一段时间,等待下次可能的调用.

  例如:   a = 3453453
  print(id(a))---->内存编号33402576
  del a      #已经删除
  b = 3453453 #将3453453赋值给b
  print(id(b))----->内存编号33402576

1、字符串
1.1、如何在Python中使用字符串
a、使用单引号(')
用单引号括起来表示字符串,例如:
str='this is string';
print str;

  2.浮点数(float)

  浮点数就是小数,例如1.23,1.0等,一般很大或很小的浮点数,用科学计数法表示,把10用e表示,例如:1.23*10^9可以表示为1.23e10.

Python使用场景有:*系统编程,如编写系统管理工具,自动化工具   *编写用户图形接口,开发GUI程序   *Internet脚本的编写    *数据库编程,通过接口来实现    *快速原型      *数值计算和科学计算编程、游戏、人工智能、机器人等

  2.浮点数(float)

  浮点数就是小数,例如1.23,1.0等,一般很大或很小的浮点数,用科学计数法表示,把10用e表示,例如:1.23*10^9可以表示为1.23e10.

b、使用双引号(")
双引号中的字符串与单引号中的字符串用法完全相同,例如:
str="this is string";
print str;

   3.复数(complex)

  复数由实数部分和虚数部分构成,例如a bj,或者complex(a,b)。很少用到。

官方网站:www.Python.org

   3.复数(complex)

  复数由实数部分和虚数部分构成,例如a bj,或者complex(a,b)。很少用到。

c、使用三引号(''')
利用三引号,表示多行的字符串,可以在三引号中自由的使用单引号和双引号,例如:
str='''this is string
this is pythod string
this is string'''
print str;

  4.数字类型转换:

  int(x):将x转换为整数,如果x是浮点数,保留整数部分,int()中默认使用十进制,可以指定进制,将指定进制的数转化为十进制数。例如常用的2/8/16这三种进制,例如:int("0b10", 2)将二进数0吧0转化为十进制数输出,结果为2。
  float(x):将x转化为浮点数
  complex(x)或complex(x, y):很少用到

Python是解释性语言

  4.数字类型转换:

  int(x):将x转换为整数,如果x是浮点数,保留整数部分,int()中默认使用十进制,可以指定进制,将指定进制的数转化为十进制数。例如常用的2/8/16这三种进制,例如:int("0b10", 2)将二进数0吧0转化为十进制数输出,结果为2。
  float(x):将x转化为浮点数
  complex(x)或complex(x, y):很少用到

2、布尔类型
bool=False;
print bool;
bool=True;
print bool;

  5.计算

  除过 、-、*、/、**、//、%运算符之外,python还提供科学计算等库,例如math,导入math库后,常用的函数有:
  abs(x):返回x的绝对值,类型随x
  fabs(x):返回x的绝对值,类型是浮点数
澳门新萄京官方网站:数字类型,python数据类型高阶。  ceil(x):取x的上入整数,如math.ceil(4.1)返回5
  floor(x):取x的下入整数,如math.floor(4.9)返回4
  round(x [,n]):默认返回浮点数x的四舍五入值,如给出n值,则代表舍入到小数点后的n位。例如round(1.23456, 3)返回1.235
  exp(x):返回e的x次幂,e是自然常数
  sqrt(x):返回x的平方根,返回值是float类型
  modf(x):返回x的整数部分和小数部分,两部分的符号与x相同,整数部分以浮点型表示。例如math.modf(4.333),返回元组(0.3330000000000002, 4.0)
  log10(x):返回以10为基数的x的对数,返回值类型是浮点数
  log(x,y):返回以y为基数的x的对数,返回值类型是浮点数
  pow(x, y):返回x的y次幂,即x**y
  max(n1, n2, ...):返回最大值
  min(n1, n2, ...):返回最小值

Python跟Java类似,都是用虚拟机PVM执行字节码(跟c  Java不一样)文件

  5.计算

  除过 、-、*、/、**、//、%运算符之外,python还提供科学计算等库,例如math,导入math库后,常用的函数有:
  abs(x):返回x的绝对值,类型随x
  fabs(x):返回x的绝对值,类型是浮点数
  ceil(x):取x的上入整数,如math.ceil(4.1)返回5
  floor(x):取x的下入整数,如math.floor(4.9)返回4
  round(x [,n]):默认返回浮点数x的四舍五入值,如给出n值,则代表舍入到小数点后的n位。例如round(1.23456, 3)返回1.235
  exp(x):返回e的x次幂,e是自然常数
  sqrt(x):返回x的平方根,返回值是float类型
  modf(x):返回x的整数部分和小数部分,两部分的符号与x相同,整数部分以浮点型表示。例如math.modf(4.333),返回元组(0.3330000000000002, 4.0)
  log10(x):返回以10为基数的x的对数,返回值类型是浮点数
  log(x,y):返回以y为基数的x的对数,返回值类型是浮点数
  pow(x, y):返回x的y次幂,即x**y
  max(n1, n2, ...):返回最大值
  min(n1, n2, ...):返回最小值

Python内置数据类型总结(数字类型) 数据类型是一种值的集合以及定义在这种值上的...

3、整数
int=20;
print int;

在正确配置参数后“Python”命令就能进入交互模式,此时提示符变成“<<<”

4、浮点数
float=2.3;
print float;

交互模式下比起文本模式,会有如下特点:

5、数字
包括整数、浮点数。
5.1、删除数字对象引用,例如:
a=1;
b=2;
c=3;
del a;
del b, c;
#print a; #删除a变量后,再调用a变量会报错

1. 文本前面不能有空格,否则报错。

5.2、数字类型转换

2. 复合语句中第二行开始提示符会变成“…”

int(x [,base]) 将x转换为一个整数 
float(x ) 将x转换到一个浮点数 
complex(real [,imag]) 创建一个复数 
str(x) 将对象x转换为字符串 
repr(x) 将对象x转换为表达式字符串 
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象 
tuple(s) 将序列s转换为一个元组 
list(s) 将序列s转换为一个列表 
chr(x) 将一个整数转换为一个字符 
unichr(x) 将一个整数转换为Unicode字符 
ord(x) 将一个字符转换为它的整数值 
hex(x) 将一个整数转换为一个十六进制字符串 
oct(x) 将一个整数转换为一个八进制字符串

3. 用第一个空行表示语句结束。

5.3、数学函数 math.abs()

基础语法

abs(x) 返回数字的绝对值,如abs(-10) 返回 10
ceil(x) 返回数字的上入整数,如math.ceil(4.1) 返回 5
cmp(x, y) 如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1
exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x) 返回数字的绝对值,如math.fabs(-10) 返回10.0
澳门新萄京官方网站:数字类型,python数据类型高阶。floor(x) 返回数字的下舍整数,如math.floor(4.9)返回 4
log(x) 如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x) 返回以10为基数的x的对数,如math.log10(100)返回 2.0
max(x1, x2,...) 返回给定参数的最大值,参数可以为序列。
min(x1, x2,...) 返回给定参数的最小值,参数可以为序列。
modf(x) 返回x的整数部分与小数部分,两部分的数值符号与x相同,整数部分以浮点型表示。
pow(x, y) x**y 运算后的值。
round(x [,n]) 返回浮点数x的四舍五入值,如给出n值,则代表舍入到小数点后的位数。
sqrt(x) 返回数字x的平方根,数字可以为负数,返回类型为实数,如math.sqrt(4)返回 2 0j

  标识符:标识符有字母、数字、下划线组成,但不能以数字开头

6、列表
6.1、初始化列表,例如:
list=['physics', 'chemistry', 1997, 2000];
nums=[1, 3, 5, 7, 8, 13, 20];

  行和紧缩:Python不使用{}来表示语句的开始和结束,所以紧缩很重要

6.2、访问列表中的值,例如:

  引号:单双引号都一样,三引号”””可以使用段落

澳门新萄京官方网站 1

  注释:可以使用#来进行注释

'''nums[0]: 1'''
print "nums[0]:", nums[0]
'''nums[2:5]: [5, 7, 8] 从下标为2的元素切割到下标为5的元素,但不包含下标为5的元素'''
print "nums[2:5]:", nums[2:5]
'''nums[1:]: [3, 5, 7, 8, 13, 20] 从下标为1切割到最后一个元素'''
print "nums[1:]:", nums[1:]
'''nums[:-3]: [1, 3, 5, 7] 从最开始的元素一直切割到倒数第3个元素,但不包含倒数第三个元素'''
print "nums[:-3]:", nums[:-3]
'''nums[:]: [1, 3, 5, 7, 8, 13, 20] 返回所有元素'''
print "nums[:]:", nums[:]

 

澳门新萄京官方网站 2

 

6.3、更新列表,例如:

2.Python的类型与运算---数字

nums[0]="ljq";
print nums[0];

Python3.x整数只有一个类型

6.4、删除列表元素

最大数2**63

del nums[0];
'''nums[:]: [3, 5, 7, 8, 13, 20]'''
print "nums[:]:", nums[:];

负数的范围比正数多一个

6.5、列表脚本操作符
列表对 和*的操作符与字符串相似。 号用于组合列表,*号用于重复列表,例如:

Python提供2进制到36进制数的输入

print len([1, 2, 3]); #3
print [1, 2, 3]   [4, 5, 6]; #[1, 2, 3, 4, 5, 6]
print ['Hi!'] * 4; #['Hi!', 'Hi!', 'Hi!', 'Hi!']
print 3 in [1, 2, 3] #True
for x in [1, 2, 3]: print x, #1 2 3

复数格式:i换成j或J

6.6、列表截取

除法中Python3.x会自动转换格式  3/6=0.5

L=['spam', 'Spam', 'SPAM!'];
print L[2]; #'SPAM!'
print L[-2]; #'Spam'
print L[1:]; #['Spam', 'SPAM!']

位运算符只能对整数进行

6.7、列表函数&方法

逻辑运算符:and or not

澳门新萄京官方网站 3

成员运算符:in,not in

list.append(obj) 在列表末尾添加新的对象
list.count(obj) 统计某个元素在列表中出现的次数
list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list.index(obj) 从列表中找出某个值第一个匹配项的索引位置,索引从0开始
list.insert(index, obj) 将对象插入列表
list.pop(obj=list[-1]) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
list.remove(obj) 移除列表中某个值的第一个匹配项
list.reverse() 反向列表中元素,倒转
list.sort([func]) 对原列表进行排序

身份运算符:is,is not

澳门新萄京官方网站 4

当数字相and的时候,有一个为0则结果为0,否则就是第二个数字

7、元组(tuple)

Or的时候相反

Python的元组与列表类似,不同之处在于元组的元素不能修改;元组使用小括号(),列表使用方括号[];元组创建很简单,只需要在括号中添加元素,并使用逗号(,)隔开即可,例如:

not只有0是true

tup1 = ('physics', 'chemistry', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";

and前面

 

 

创建空元组,例如:tup = ();

 

元组中只有一个元素时,需要在元素后面添加逗号,例如:tup1 = (50,);

  1. Python的类型与运算---数字(二)  函数

元组与字符串类似,下标索引从0开始,可以进行截取,组合等。

bin,oct,hex 进制转换函数

7.1、访问元组

pow:幂函数-------pow(2,3)    8

tup1 = ('physics', 'chemistry', 1997, 2000);
#tup1[0]: physics
print "tup1[0]: ", tup1[0]
#tup1[1:5]: ('chemistry', 1997)
print "tup1[1:5]: ", tup1[1:3]

sqrt:平方根,开出来是浮点数

7.2、修改元组
元组中的元素值是不允许修改的,但我们可以对元组进行连接组合,例如:
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');

max,min最值

# 以下修改元组元素操作是非法的。
# tup1[0] = 100;

abs与fabs:取绝对值   区别:fabs函数取出来是浮点数,abs可以保持原有的数字类型

# 创建一个新的元组

round:四舍五入   在2.x和3.x上有点区别

tup3 = tup1   tup2;
print tup3; #(12, 34.56, 'abc', 'xyz')

   在2里是四舍五入,3里是靠近整数偶数的形式取整

7.3、删除元组
元组中的元素值是不允许删除的,可以使用del语句来删除整个元组,例如:

(3.x)例如a=2.5,b=3.5   round(a)   2  round(b)   4

tup = ('physics', 'chemistry', 1997, 2000);
print tup;
del tup;

ceil: 取最小的大于该值的最大整数

7.4、元组运算符
与字符串一样,元组之间可以使用 号和*号进行运算。这就意味着他们可以组合和复制,运算后会生成一个新的元组。
澳门新萄京官方网站 5

floor:去最大的小于该值的最小整数

7.5、元组索引&截取

cmp:比较函数,但python3.x舍弃了这个函数

L = ('spam', 'Spam', 'SPAM!');
print L[2]; #'SPAM!'
print L[-2]; #'Spam'
print L[1:]; #['Spam', 'SPAM!']

random:随机数模块   random.random是取0-1之间的小数

7.6、元组内置函数

取随机数是random.choice/sample   sample((总数),要取几个)

cmp(tuple1, tuple2) 比较两个元组元素。
len(tuple) 计算元组元素个数。
max(tuple) 返回元组中元素最大值。
min(tuple) 返回元组中元素最小值。
tuple(seq) 将列表转换为元组。

 打乱顺序是shuffle,获取N位随机数是getrandbits(比特值)

8、字典

modf:把浮点数的整数位和小数位单都取出来   math.modf(2.5)   (0.5,2.0)

8.1、字典简介
字典(dictionary)是除列表之外python中最灵活的内置数据结构类型。列表是有序的对象结合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。

log:指数函数,默认e为底数,结果为浮点数。log10以10为底数,可以自定义底数

字典由键和对应的值组成。字典也被称作关联数组或哈希表。基本语法如下:

math.log(3) 默认底数e      math.log(4,2)  以2为底数的4的对数

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'};

math.log10(100)  以10为底数

也可如此创建字典:

Decimal模块:解决精度问题 常用于金融行业

dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };

a=2.1   b=4.2   a b   6.30000001

每个键与值必须用冒号隔开(:),每对用逗号分割,整体放在花括号中({})。键必须独一无二,但值则不必;值可以取任何数据类型,但必须是不可变的,如字符串,数或元组。

        a=Decimal(‘2.1’)   b=Decimal(‘4.2’)   a b   Decimal(‘6.3’)

8.2、访问字典里的值

格式化输出------format

#!/usr/bin/python
dict = {'name': 'Zara', 'age': 7, 'class': 'First'};
print "dict['name']: ", dict['name'];
print "dict['age']: ", dict['age'];

使用bin(),oct(),hex()的时候会发现前面会加0b,0o,0x,当不想要前缀的时候用format函数来解决问题

8.3、修改字典
向字典添加新内容的方法是增加新的键/值对,修改或删除已有键/值对如下实例:

          a=13  bin(a)    ‘0b1101’

#!/usr/bin/python
dict = {'name': 'Zara', 'age': 7, 'class': 'First'};
dict["age"]=27; #修改已有键的值
dict["school"]="wutong"; #增加新的键/值对
print "dict['age']: ", dict['age'];
print "dict['school']: ", dict['school'];

  format(a,’b’)    1101

8.4、删除字典
del dict['name']; # 删除键是'name'的条目
dict.clear(); # 清空词典所有条目
del dict ; # 删除词典
例如:

 

#!/usr/bin/python
dict = {'name': 'Zara', 'age': 7, 'class': 'First'};
del dict['name'];
#dict {'age': 7, 'class': 'First'}
print "dict", dict;

4.python的类型与运算—动态类型

注意:字典不存在,del会引发一个异常

·变量没有类型,当第一次复制给一个变量的时候,它就自动被创建了

8.5、字典内置函数&方法

·当变量被表达式使用时马上被其引用的对象所取代。

澳门新萄京官方网站 6

a=3      #这里3是整数     a=”three”    #在这里”Three”是字符串

cmp(dict1, dict2) 比较两个字典元素。
len(dict) 计算字典元素个数,即键的总数。
str(dict) 输出字典可打印的字符串表示。
type(variable) 返回输入的变量类型,如果变量是字典就返回字典类型。
radiansdict.clear() 删除字典内所有元素
radiansdict.copy() 返回一个字典的浅复制
radiansdict.fromkeys() 创建一个新字典,以序列seq中元素做字典的键,val为字典所有键对应的初始值
radiansdict.get(key, default=None) 返回指定键的值,如果值不在字典中返回default值
radiansdict.has_key(key) 如果键在字典dict里返回true,否则返回false
radiansdict.items() 以列表返回可遍历的(键, 值) 元组数组
radiansdict.keys() 以列表返回一个字典所有的键
radiansdict.setdefault(key, default=None) 和get()类似, 但如果键不已经存在于字典中,将会添加键并将值设为default
radiansdict.update(dict2) 把字典dict2的键/值对更新到dict里
radiansdict.values() 以列表返回字典中的所有值

·变量里存储的是一个对象的指针

二、数字类型进阶

·引用:自动形成的从变量到对象的指针

需要说明的是python的数字类型长度是不固定的,可以表现无限大的数据。如下

·变量是存放指针的,因此变量没有类型

12赋值给a,使用函数type()可以查看a的数据类型为int;使用bit_length()方法可以发现a的位数是4,将a重新赋值为12345,发现a的位数变为14。如图所示

·对象是存放数据的,所以对象是有类型的

澳门新萄京官方网站 7

·第二次引用(赋值)时,当别的变量引用对象3的话,3就会回收

python的整数可以任意大(也就是说基本上不用担心计算机位数不够导致无法显示的情况)。例如,计算123456789的8次方,然后用bit_length()方法查看下位数,发现竟然有216位(二进制),如图

 

澳门新萄京官方网站 8

共享引用:两个变量共享一个对象,都指向对象,而不是指向变量

 三、整数的加减乘除和求余运算。

a=3

分别计算2和6的加减乘除和求余,同时用type()函数查看数据类型,如图所示

b=a

澳门新萄京官方网站 9

·当a被赋另一个值了,就会创建一个对象,若不是改变对象

浮点数的加法。

当a=’three’时,b还等于3

例如0.55 0.3显示结果为0.8500000000000001,并不是我们想象中的0.85,这是因为浮点数内部是二进制表示,在形式上是一个无限系列。

·当引用列表时,可以先把列表里的值复制到新的列表,再更改列表里的值

澳门新萄京官方网站 10

·在python里,多个变量引用同一整数、字符串时,会引用同一对象

浮点数运算方法探秘。

但是在其他时候,在python里给两个变量赋予同样值的对象,其对象是不共用的

首先使用as_integer_ratio()方法查看浮点数的分数表示形式。

 

例如,0.25可以表示为1/4,是因为可以用有限的二进制表示出来,从而显示为(1,4);而0.55实际上是11/20,是不能用有限的二进制表示出来的,从而显示为(2476979795053773,4503599627370496),并不是11和20,所以出现了所看并非所想的情况,如图

·学习资料推荐>>>..简单学Python

澳门新萄京官方网站 11

澳门新萄京官方网站 12

 

 

 三、decimal——定点数和浮点数的数学运算

 作用:使用定点数和浮点数的小数运算。
        Python 版本:2.4 及以后版本
        decimal 模块实现了定点和浮点算术运算符,使用的是大多数人所熟悉的模型,而不是程序员熟悉的模型,即大多数计算机硬件实现的 IEEE 浮点数运算。Decimal 实例可以准确地表示任何数,对其上取整或下取整,还可以对有效数字个数加以限制。
1.Decimal
        小数值表示为 Decimal 类的实例。构造函数取一个整数或字符串作为参数。使用浮点数创建 Decimal 之前,可以先将浮点数转换为一个字符串,使调用者能够显式地处理值得位数,倘若使用硬件浮点数表示则无法准确地表述。另外,利用类方法 from_float() 可以转换为精确的小数表示。

import decimal

fmt='{0:<25}{1:<25}'
print fmt.format('Input','Output')
print fmt.format('-'*25,'-'*25)

print fmt.format(5,decimal.Decimal(5))

print fmt.format('3.14',decimal.Decimal(3.14))

f=0.1
print fmt.format(repr(f),decimal.Decimal(str(f)))
print fmt.format('%.23g' %f, str(decimal.Decimal.from_float(f))[:25])

浮点数值 0.1 并不表示为一个精确的二进制值,所以 float 的表示与 Decimal 值不同。在这个输出中它被截断为 25 个字符。
        Decimal 还可以由元组创建,其中包含一个符号标志(0 表示正,1 表示负)、数字 tuple 以及一个整数指数。

# Tuple  
t = (1, (1, 1), -2)  
print 'Input  :', t  
print 'Decimal:', decimal.Decimal(t)  

      基于元组的表示创建时不太方便,不过它提供了一种可移植的方式,可以导出小数值而不会损失精度。tuple 形式可以在网络上传输,或者在不支持精确小数值得数据库中存储,以后再转回回 Decimal 实例。

2.算术运算
        Decimal 重载了简单的算术运算符,所以可以采用内置数值类型同样的方式处理 Decimal 实例。

 

import  decimal
import  math

a=decimal.Decimal('5.1')
b=decimal.Decimal('3.14')
aa=5.1
c=4
d=3.14
print 'a       =',repr(a)
print 'b       =',repr(b)
print 'c       =',repr(c)
print 'd       =',repr(d)
print

print 'a b     =',a b
print 'a-b     =',a-b
print 'a*b     =',a*b
print 'a/b     =',a/b
print

print 'a c     =',a c
print 'a-c     =',a-c
print 'a*c     =',a*c
print 'a/c     =',a/c
print

print 'aa d     =',aa d
print 'aa-d     =',aa-d
print 'aa*d     =',aa*d
print 'aa/d     =',aa/d
print

print 'a   c =',
try:
    print a   c
except TypeError, e:
    print e

print decimal.Decimal(math.log10(100))

 Decimal 运算符还接受整数参数,不过浮点数值必须转换为 Decimal 实例。
        除了基本算术运算,Decimal 还包括一些方法来查找以 10 为底的对数和自然对数。log10() 和 ln() 返回的值都是 Decimal 实例,所以可以与其他值一样直接在公式中使用。

 3.特殊值
        除了期望的数字值,Decimal 还可以表示很多特殊值,包括正负无穷大值、“不是一个数”(NaN)和 0。

for value in ['Infinity','NaN','0']:
    print decimal.Decimal(value),decimal.Decimal('-' value)
print

# Math with infinity
print 'Infinity   1:', (decimal.Decimal('Infinity')   1)
print '-Infinity   1:', (decimal.Decimal('-Infinity')   1)

# Print comparing NaN
print decimal.Decimal('NaN') == decimal.Decimal('Infinity')
print decimal.Decimal('NaN') != decimal.Decimal(1)

  与无穷大值相加会返回另一个无穷大值。与 NaN 比较相等性总会返回 false,而比较不等性总会返回 true。与 NaN 比较大小来确定排序顺序没有明确定义,这会导致一个错误。

4.Decimal 的上下文

    到目前为止,前面的例子使用的都是 decimal 模块的默认行为。还可以使用一个上下文(context)覆盖某些设置,如保持精度、如何完成取整、错误处理等等。上下文可以应用于一个线程中的所有 Decimal 实例,或者局部应用于一个小代码区。
        1. 当前上下文
        要获取当前全局上下文,可以使用 getcontext()。

import decimal
import  pprint

context=decimal.getcontext()

print 'Emax       =',context.Emax
print 'Emin       =',context.Emin
print 'capitals   =',context.capitals
print 'prec       =',context.prec
print 'rounding   =',context.rounding
print 'flags      ='
pprint.pprint(context.flags)
print 'traps      ='
pprint.pprint(context.traps)



#上下文的 prec 属性控制着作为算术运算结果所创建的新值的精度。字面量值会按这个属性保持精度。

d=decimal.Decimal('0.123456')
for i in range(4):
    decimal.getcontext().prec=i
    print i,':',d,d*1

 3. 取整
        取整有多种选择,以保证值在所需精度范围内。

  • ROUND_CEILING 总是趋向于无穷大向上取整。
  • ROUND_DOWN 总是趋向 0 取整。
  • ROUND_FLOOR 总是趋向负无穷大向下取整。
  • ROUND_HALF_DOWN 如果最后一个有效数字大于或等于 5 则朝 0 反方向取整;否则,趋向 0 取整。
  • ROUND_HALF_EVEN 类似于 ROUND_HALF_DOWN,不过,如果最后一个有效数字值为 5,则会检查前一位。偶数值会导致结果向下取整,奇数值导致结果向上取整。
  • ROUND_HALF_UP 类似于 ROUND_HALF_DOWN,不过如果最后一位有效数字为 5,值会朝 0 的反方向取整。
  • ROUND_UP 朝 0 的反方向取整。
  • ROUND_澳门新萄京官方网站,05UP 如果最后一位是 0 或 5,则朝 0 的反方向取整;否则向 0 取整。

 

import decimal

context=decimal.getcontext()

ROUNDING_MODES=[
    'ROUND_CEILING',
    'ROUND_DOWN',
    'ROUND_FLOOR',
    'ROUND_HALF_DOWN',
    'ROUND_HALF_EVEN',
    'ROUND_HALF_UP',
    'ROUND_UP',
    'ROUND_05UP',
]

header_fmt = '{:10} '   ' '.join(['{:^8}'] * 6)

print header_fmt.format('',
                        '1/8(1)','-1/8(1)',
                        '1/8(2)','-1/8(2)',
                        '1/8(3)', '-1/8(3)')

for rounding_mode in ROUNDING_MODES:
    print '{0:10}'.format(rounding_mode.partition('_')[2]),
    for precision in [1,2,3]:
        context.prec=precision
        context.rounding=getattr(decimal,rounding_mode)
        value=decimal.Decimal(1)/decimal.Decimal(8)
        print '{0:^8}'.format(value),
        value=decimal.Decimal(-1)/decimal.Decimal(8)
        print '{0:^8}'.format(value),
    print

  4. 局部上下文
        使用 Python 2.5 或以后版本时,可以使用 with 语句对一个代码块应用上下文。

import  decimal

with decimal.localcontext() as c:
    c.prec=2
    print 'Local precision:',c.prec
    print '3.14/3=',(decimal.Decimal('3.14')/3)
print
print 'Default precision:',decimal.getcontext().prec
print '3.14/3=',(decimal.Decimal('3.14')/3)

# Set up a context with limited precision
c = decimal.getcontext().copy()
c.prec = 3

# Create our constant
pi = c.create_decimal('3.1415')

# The constant value is rounded off
print 'PI    :', pi

# The result of using the constant uses the global context
print 'RESULT:', decimal.Decimal('2.01') * pi
  1. 线程
            “全局”上下文实际上是线程本地上下文,所以完全可以使用不同的值分别配置各个线程。

    import decimal import threading from Queue import PriorityQueue

    class Multiplier(threading.Thread):

     def __init__(self,a,b,prec,q):
         self.a=a
         self.b=b
         self.prec=prec
         self.q=q
         threading.Thread.__init__(self)
     def run(self):
         c=decimal.getcontext().copy()
         c.prec=self.prec
         decimal.setcontext(c)
         self.q.put((self.prec,a * b))
         return
    

    a=decimal.Decimal('3.14') b=decimal.Decimal('1.234') q=PriorityQueue() threads=[Multiplier(a,b,i,q) for i in range(1,6)] for t in threads:

     t.start()
    

    for t in threads:

     t.join()
    

    for i in range(5):

     prec,value=q.get()
     print prec,'t',value
    

 

本文由澳门新萄京官方网站发布于www.8455.com,转载请注明出处:澳门新萄京官方网站:数字类型,python数据类型

关键词: