整数是python的数据类型吗_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为基准，格式如下：    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}