Python的数据类型、运算操作及类型转换（整数、浮点数、复数等） 总

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)：用于取反表达式的，真变假，假变真

                使用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 <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
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 <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'>