python中常见的数据类型：整型、浮点、布尔、字符串、列表、元组、集合、字典、空(None)等

1、整数类型

与数学中整数的概念一致

-可正可负，没有取值范围限制。pow(x,y)函数：计算

，想算多大算多大

-4种进制表示形式

十进制：1010，99，-217

二进制：0b或0B开头，0B101,-0b101

八进制：以0o或0O开头，0o123，-0O456

十六进制：以0X或0x开头，0X9a,-0x89

2、浮点数类型

与数学中实数的概念一致

-带有小数点及小数的数字

-浮点数取值范围和小数精度都存在限制，但常规计算可忽略（通常可保留到

数量级）

-浮点数间运算存在不确定尾数，不是bug

-round(x,d)：对x四舍五入，d是小数截取位数。浮点数间运算及比较用round()函数辅助

不确定位数一般发生在

左右，round()十分有效

-浮点数可以采用科学计数法表示

使用字母e或E作为幂的符号，以10为基准，格式如下：    e表示a*

   例如：4.3e-3   值为0.0043

3、复数类型（complex）

与数学中复数的概念一致

例：z=1.23e-4+5.6+89j          z.real获得实部   z.imag获得虚部

# 整型
a = 250
print(a)
# type：获取变量的类型
print(type(a))
# 浮点
b = 3.14
print(b, type(b))
# 科学计数法
c = 3.1415e-3
print(c)
# 复数
d = 3 + 4j
print(d, type(d))
4、运算操作符
（1）数值运算符
操作符及使用
描述
x+y
加，和
x-y
减，差
x*y
乘，积
x/y
除，商（浮点数）
x//y
整数除，整数商
+x
x本身
-y
y的负值
x%y
余数，模运算   10%3结果是1
x**y
幂运算，x的y次幂，
当y是小数时，开方运算   10**0.5结果为
二元操作符有对应的增强赋值操作符
增强操作符及使用
描述
x op = y
即x=x op y，其中，op为二元操作符
x+=y     x-=y   x*=y   x/=y
x//=y     x%=y   x**=y
>>>x=3.1415
>>>x**= 3    #与x=x**3等价
31.003533398375005
例：
# = 就是赋值运算
a = 250
a = 200
print(5 / 2)
print(5 // 2)
# 同时得到的商和余数
print(divmod(10, 3))
a, b = divmod(10, 3)
print(a, b)
# 求余
print(10 % 3)
# 求幂
print(2 ** 3)
print(pow(2, 3))
# 复合运算
a = 2
a += 3 # 等价于 a = a + 3
print(a)
（2）关系运算符
>、>=、
关系表达式：由操作数和关系运算符构成的表达式
关系表达式是有值的：符合数学逻辑为真(True)，不符合数学逻辑为假(False)
# 关系运算
print(1 > 3)
print(1 < 3)
（3）逻辑运算符
与(and)：两边的表达式同时为真，结果才为真
或(or)：两边的表达式一个为真，结果就为真
非(not)：用于取反表达式的，真变假，假变真               使用not是为了简化书写
经常伴随着隐式类型转换
# 逻辑运算
print(1 < 3 and 3 > 2)
a = int(input('请输入一个整数:'))
# 通用写法
# print(a >= 0 and a <= 100)
# python特有写法
print(0 <= a <= 100)
# 同时被3和5整除
print(a % 3 == 0 and a % 5 == 0)
# 能被3或5整除
print(a % 3 == 0 or a % 5 == 0)
# 判断闰年
print((a % 4 == 0 and a % 100 != 0) or (a % 400 == 0))
# 取反表达式
print(not (a > 3))
（4）成员运算符
in、not in：判断一个值是否是另一个对象的成员
说明：通常用在字符串、列表、元组、集合、字典等的成员判断
# 成员运算
lt = [1, 2, 3]
print(1 in lt)
print(4 not in lt)
d = {'name': 'dahua'}
# 对于字典，判断的是键
print('name' in d)
（5）位运算符
&：按位与，对应的数据位同时为1，结果上对应的位才为1
|：按位或，对应的数据位一个为1，结果上对应的位就为1
^：按位异或，对应的数据位不同结果为1，相同结果为0
~：按位取反，数据的每一位，0变1，1变0
<<：按位左移，左移一位相当于乘以2
>>：按位右移，右移一位相当于除以2
a = 0b101010
b = 0b111011
print('0b{:b}'.format(a & b))
print('0b{:b}'.format(a | b))
print('0b{:b}'.format(a ^ b))
print('0b{:b}'.format(~1))
print('0b{:b}'.format(a << 1))
print('0b{:b}'.format(a >> 1))
运行结果：
0b101010
0b111011
0b10001
0b-10
0b1010100
0b10101
5、数字类型的关系
类型间可进行混合运算，生成结果为“最宽”类型
-三种类型存在一种逐渐“扩展”或“变宽”的关系：整数->浮点数->复数
例：123+4.0=127.0
6、数值运算函数
一些以函数形式提供的数值运算功能
函数及使用
描述
abs(x)
绝对值，x的绝对值
abs(-10.01)   结果为10.01
divmod(x,y)
商余，(x//y,x%y)，同时输出商和余数
divmod(10,3)   结果为（3,1）
pow(x,y[,z])
幂余，（x**y)%z，[..]表示参数z可省略
pow(3,pow(3,99),10000)   结果为4587
round(x[,d])
四舍五入，d是保留小数位数，默认值为0
round(-10.123,2)  结果为-10.12
max(x1,x2,...,xn)
最大值，返回x1,x2,...,xn中的最大值，n不限
max(1,9,5,4,3)结果为9
min(x1,x2,...,xn)
最小值，返回x1,x2,...,xn中的最小值，n不限
min(1,9,5,4,3)结果为1
int(x)
将x变成整数，舍弃小数部分
int(123.45)结果为123；int("123")结果为123
float(x)
将x变成浮点数，增加小数部分
float(12)结果为12.0；float("123")结果为123.0
complex(x)
将x变成复数，增加虚数部分
complex(4)   结果为4+0j
7、实例（天天向上的力量）
（1）向上、向下
#DayDayUp.py
dayfactor=0.005
dayup=pow(1+dayfactor,365)
daydown=pow(1-dayfactor,365)
print("向上：{:.2f},向下：{:.2f}".format(dayup,daydown))
结果：向上：6.17，向下：0.16
（2）工作日加，休息日减
#DayDayUp.py
dayup=1.0
dayfactor=0.01
for i in range(365):
if i%7 in [6,0]:
dayup=dayup*(1-dayfactor)
else:
dayup=dayup*(1+dayfactor)
print("工作日的力量：{:.2f}".format(dayup))
结果：4.63
（3）根据df参数计算工作日力量的函数     参数不同，这段代码可共用
def保留字用于定义函数
while保留字判断条件是否成立，条件成立时循环执行
def dayUP(df):
dayup = 1
for i in range(365):
if i % 7 in [6,0]:
dayup = dayup*(1-0.01)
else:
dayup = dayup*(1+df)
return dayup
dayfactor = 0.01
while dayUP(dayfactor) < 37.78:
dayfactor += 0.001
print("工作日的努力参数是：{:.3f}".format(dayfactor))
结果：工作日的努力参数是：0.019
8、其他数据类型
（1）布尔(bool)：对应生活中的真假逻辑，只有两个值True/False
（2）空(NoneType)：空类型，只有一个值None
# 布尔
# a = True
a = False
print(a, type(a))
# 空
b = None
print(b, type(b))
运行结果：
False None
（3）列表（list）:通过[]进行定义，可以存储一系列的任意数据，是容器类型
# 列表
lt = [1, 'abc', 3.14]
print(lt, type(lt))
# 通过下标访问元素，下标从0开始
print(lt[0])
# 存在越界问题，会报IndexError的错误
# print(lt[3])
运行结果：
[1, 'abc', 3.14] 1
（4）元组(tuple)：通过()进行定义，可以存储一系列的任意数据，但是元素是不可修改的
# 元组
# tp = (1,2,3)
# tp = 1,2,3
#定义只有一个元素的元组，不要忘记添加一个逗号
tp(1,)
print(tp,type(tp))
#也是通过下标访问元素
print(tp[0])
运行结果：
(1,) 1
（5）集合（set）：通过{}进行定义，也是容器对象，可以存储任意类型的数据，但是元素不能重复，无序
# 集合
s1 = {'小芳', '小敏', '小马', '小乔'}
s2 = {'小杜', '小敏', '小王'}
print(s1, type(s1))
# 交集
print(s1 & s2)
# 并集
print(s1 | s2)
# 差集
print(s1 - s2)
print(s2 - s1)
# 定义空集合不能使用{}，它是留给定义空字典使用的
# s3 = {}
# 这样可以定义空集合
s3 = set()
print(s3, type(s3))
运行结果：
{'小敏'}
{'小芳', '小敏', '小杜', '小乔', '小马', '小王'}
{'小芳', '小马', '小乔'}
{'小王', '小杜'}
set()
（6）字典（dict）：通过{}进行定义
-元素是由键值对构成的
-键和值之间通过‘：’连接
-键是唯一的，值是任意的，有键必须有值
-字典中的键值对是可以更改的
# 字典
d = {'name': 'ergou', 'age': 18}
print(d, type(d))
# 根据键获取值
print(d['name'])
# 当字典中没有对应的键，会报KeyError错
# print(d['height'])
# 键存在就返回对应的值，不存在返回None
print(d.get('height'))
# 不存在默认返回None，但是可以指定默认值
print(d.get('weight', 80))
# 统计字典元素个数，统计的是键值对的个数
print(len(d))
# 统计字符串长度
print(len('hello'))
运行结果：
{'name': 'ergou', 'age': 18} ergou
None
80
2
5
9、类型转换
-隐式类型转换：混合运算、条件判断等
-强制类型转换：使用专门的转换函数
# 转换为整型
a = int(3.14)
print(a, type(a))
# base：指明参数的进制类型
b = int('123', base=16)
print(b)
# bool类型也可以转换
print(int(False))
# 转换为浮点数
c = float(250)
print(c, type(c))
# 转换为字符串
d = str(123)
print(d, type(d))
# 转换为列表
e = list('hello')
e2 = list((1, 2, 3))
e3 = list({1, 2, 3})
# 字典也可以转换为列表，但是只保留了键
e4 = list({'name': 'dahua', 'age': 18})
print(e, type(e))
print(e2, type(e2))
print(e3, type(e3))
print(e4, type(e4))
# 转换为元组
f = tuple('world')
f2 = tuple([1, 2, 3])
print(f, type(f))
print(f2,type(f))
# 转换为集合
g = set([1, 2, 3, 1])
print(g, type(g))
# 转换为字典
lt = [('name', 'dahua'), ('age', 18)]
h = dict(lt)
print(h, type(h))
运行结果：
3 291
0
250.0 123 ['h', 'e', 'l', 'l', 'o'] [1, 2, 3] [1, 2, 3] ['name', 'age'] ('w', 'o', 'r', 'l', 'd') (1, 2, 3) {1, 2, 3} {'name': 'dahua', 'age': 18}