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为基准，格式如下： <a>e<b> 表示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)：用于取反表达式的，真变假，假变真
经常伴随着隐式类型转换
# 逻辑运算
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
0b101015、数字类型的关系
类型间可进行混合运算，生成结果为“最宽”类型
-三种类型存在一种逐渐“扩展”或“变宽”的关系：整数->浮点数->复数
例：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 <class 'bool'>
None <class 'NoneType'>（3）列表（list）:通过[]进行定义，可以存储一系列的任意数据，是容器类型
# 列表
lt = [1, 'abc', 3.14]
print(lt, type(lt))
# 通过下标访问元素，下标从0开始
print(lt[0])
# 存在越界问题，会报IndexError的错误
# print(lt[3])
运行结果：
[1, 'abc', 3.14] <class 'list'>
1（4）元组(tuple)：通过()进行定义，可以存储一系列的任意数据，但是元素是不可修改的
# 元组
# tp = (1,2,3)
# tp = 1,2,3
#定义只有一个元素的元组，不要忘记添加一个逗号
tp(1,)
print(tp,type(tp))
#也是通过下标访问元素
print(tp[0])
运行结果：
(1,) <class 'tuple'>
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() <class '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} <class 'dict'>
ergou
None
80
2
59、类型转换
-隐式类型转换：混合运算、条件判断等
-强制类型转换：使用专门的转换函数
# 转换为整型
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 <class 'int'>
291
0
250.0 <class 'float'>
123 <class 'str'>
['h', 'e', 'l', 'l', 'o'] <class 'list'>
[1, 2, 3] <class 'list'>
[1, 2, 3] <class 'list'>
['name', 'age'] <class 'list'>
('w', 'o', 'r', 'l', 'd') <class 'tuple'>
(1, 2, 3) <class 'tuple'>
{1, 2, 3} <class 'set'>
{'name': 'dahua', 'age': 18} <class 'dict'>
