Python基础--数据类型_python 数据类型定义

数据类型

将一组具有相同性质的数据的集合统称为一种数据类型，在Pyhton中定义了很多种数据类型，每种数据类型以一个类（class）来定义，在类中定义每种数据类型的属性和方法。

我们可以使用内置函数type()来返回一个变量的数据类型，或者使用内置函数isinstance()来判断变量的数据类型，如下图

那这里为什么bool类型的变量，用isinstance()函数判断为int类型呢？我们按住ctrl键，点击int跳转到数据类型定义模块文件中，搜索bool类，可以看到bool类继承了int类，也就是说bool类是int类的子类，所以bool类型的数据也是int类型

数据操作

几乎所有数据类型的对象都能进行真值测试，布尔运算和比较运算，这几个操作最终返回的都是布尔值，也就是返回真True或者假False

真值测试（逻辑值测试）

任何对象都可以进行真值测试，一个对象在默认情况下被视为真值，除非当该对象被调用时其所属类定义了 __bool__方法且返回 False 或是定义了 __len__方法且返回零才会被视为假值。会被视为假值的内置对象如下：

• 被定义为假值的常量：None和False
• 任何数值类型的0：0、0.0、0j、Decimal(0)、Fraction(0, 1)
• 空的序列和多项集：‘’、[]、()、{}、set()、range(0)

假设我们自定义了一个类，这个类的实例对象可以进行真值测试，那什么情况下这个对象进行真值测试会返回False呢？
第一种情况是在这个类中定义了__bool__方法且该方法return False，那么真值测试会返回False；
第二种情况是在这个类中定义了__len__方法且该方法return 0，那么真值测试会返回False。
如果一个类中即定义了__bool__方法，又定义了__len__方法，那么会先查看__bool__方法的返回值，如果返回值为False，那么直接是False，如果返回值是True，那么接着看__len__方法的返回值，返回值为0，那么就是False，返回值是非0，那么就是True
除上面两种情况之外，任何对象进行真值测试都默认返回True

布尔运算（and、or、not）

任何对象在进行真值测试之后，都能作为布尔运算的操作数，布尔运算的运算规则如下：

• x and y：当x为假时，直接返回False；当x为真时，再对y求值，如果y为假则返回False，y为真则返回True
• x or y：当x为真时，直接返回true；当x为假时，再对y求值，如果y为假则返回False，y为真则返回True
• not x：当x为真时，返回False；当x为假时，返回True

比较运算

在Python中有八种比较运算符，他们的优先级相等（比布尔运算符的优先级高）。比较运算可以任意串联，比如：x<y<=z等价于x<y and y<=z，这两种方式相同点在于当x<y为假时，z不会被求值直接返回False；不同点在于前者y只需要做一次求值，而后者y需要做两次求值。包含的比较运算符有：

is和is not属于身份运算符，跟其他运算符不同的是，其他运算符比较的是对象的值，而身份运算符比较的是对象的内存地址。身份运算符两边都应该是一个对象的标识符，而不应该是一个具体的对象

标准数据类型

在Python 3中定义了以下八种标准的数据类型：

• 不可变数据类型：Numbers(数字)、Boolean(布尔)、String(字符串)、Tuple(元组)、bytes(字节串)
• 可变数据类型：List(列表)、Dictionary(字典)、Set(集合)

不可变和可变指的是这种数据类型的变量值是否能被改变

其余数据类型还有：

• NoneType(空值)：空值是Python中一个特殊的值，使用None表示，空值不是0，他仅仅代表这块内存区域存在，但他里面没有存储值

其中字符串、元组、字节串、列表又被称为序列类型，这些数据类型都有的共同特征是都存在索引，都可以做切片操作，以及其他序列类型操作等

其中字符串、字节串、元组、列表、字典、集合又被称为迭代器类型，这些数据类型都能通过调用iter()函数返回一个迭代器，并通过迭代器调用next()函数进行迭代操作

其中字典又被称为映射类型，是Python中唯一一种标准的映射类型

Numbers(数字)

Python 3的数字类型包括：

• 有符号整型int
• 浮点型float
• 复数complex

有符号整型int

1. 定义整型变量

#定义单个变量
a = 11
#连续定义多个变量
a = b = c = 22
#交互式赋值定义变量
a,b,c = 1,2,3
print(a,b,c)  #1 2 3
print(type(a))  #<class 'int'>

1
2
3
4
5
6
7
8
9

2. 内置函数int()
   int()是Python的内置函数，用于生成一个整数0，或将一个字符串或数字转换为整型

函数定义：class int(x,base=10)

• x–字符串或数字，当参数为空时会生成0
• base–进制数，不写默认就是10，有效的base是0和2-36

使用int()函数转换时要注意以下几点：

• base=10，参数x可以是有符号整数，浮点数，以及字符串，字符串中只能带有数字字符，不能有其他无用字符（也可以在字符最前面加正号或负号，但正负号和数字之间不能有空格，其他地方可以有空格）

#使用int()生成整型变量
a = int()
print(a,type(a)) #0 <class 'int'>
#将字符串转换为整型
b = int('-11')
print(b,type(b)) #-11 <class 'int'>
b = int('00001010')
print(b,type(b)) #1010 <class 'int'>
#将浮点数转换为整型，会直接去掉小数点后面的数
c = int(0.52)
print(c,type(c)) #0 <class 'int'>
d = int(-32)
print(d,type(d)) #-32 <class 'int'>
1
2
3
4
5
6
7
8
9
10
11
12
13

由于bool类属于int类的子类，所以bool值也相当于一个整数

#将bool类型转换为整型
f1 = int(False)
print(f1,type(f1)) #0 <class 'int'>
f2 = int(True)
print(f2,type(f2)) #1 <class 'int'>
1
2
3
4
5

• base=0，参数x必须是字符串，且该字符串只能是“有符号整数”，这种情况相当于把这个字符串看作一个整数

bb = int('-111',0)
print(bb,type(bb)) #-111 <class 'int'>
bb = int('+41',0)
print(bb,type(bb)) #41 <class 'int'>
bb = int('101',0)
print(bb,type(bb)) #101 <class 'int'>
#不能是不合法的有符号整数
bb = int('012',0)
print(bb,type(bb)) #ValueError: invalid literal for int() with base 0: '012'
1
2
3
4
5
6
7
8
9

• 2<=base<=36&base!=10，参数x可以是字符串、字节、字节数组，参数x要在给定的进制中合法

aa = int('15',8)
print(aa,type(aa)) #13 <class 'int'>
bb = int('0101',2)
print(bb,type(bb)) #5 <class 'int'>
cc = int('a',16)
print(cc,type(cc)) #10 <class 'int'>
1
2
3
4
5
6

整数的按位运算

按位运算只对整数有意义，将两个整数先转换为二进制数，然后依次按位运算，得到的结果再转换为整数输出，包含的位运算有：

• x | y：x和y按位或，对应的两个二进制数有一个为1则结果为1，两个都为0则结果为0
• x ^ y：x和y按位异或，对应的两个二进制数相同则结果为1，不同则结果为0
• x & y：x和y按位与，对应的两个二进制数有一个为0则结果为0，两个都为1则结果为1
• x << n：x左移n位，将x的八位二进制数全体向左边移动n位（去掉左边的n位，右边补0凑够八位）
• x >> n：x右移n位，将x的八位二进制数全体向右移动n位（去掉右边的n位，左边补0凑够八位）
• ~x：x逐位取反，将x的八位二进制数逐位取反，1变成0，0变成1（取反运算得到的是补码）

x = 1 #001
y = 3 #011
z = x & y
print(z,type(z)) #1 <class 'int'>
print(x|y) #3
print(x^y) #2
print(x<<2) #4
print(y>>2) #0
print(~y) #-4

1
2
3
4
5
6
7
8
9
10

在计算机中，一个数字或者一个字符占一个字节（byte），一个字节（byte）等于8比特（bit）也就是8位，每一位用一个二进制数（0或者1）来表示，所以1在计算机中被存储为00000001（最高位代表符号位，0代表正号，1代表负号）
按位取反运算得到的是一个补码，一个正数的原码、反码和补码是相等的，而一个负数的补码等于符号位不变，反码+1，反码又等于符号位不变，原码取反
所以当我们对一个数进行逐位取反时，一个正数会变成负数，一个负数会变成正数，那么取反之后的数该怎么计算呢？比如上面的对3逐位取反，首先3的二进制数是00000011，逐位取反得到11111100，得到的这个数是个补码，由于补码等于符号位不变，反码+1，那么这个数的反码等于1111100-1=1111011，那么这个数的原码等于0000100，加上符号位就是-4

通过规律我们可以发现

• 左移n位相当于乘以pow(2,n)，始终得到一个偶数
• 右移n位相当于除以pow(2,n)，再做向下取整
• 对整数x做~运算的结果等于-(x+1)

浮点型float

1. 定义浮点型变量

#定义浮点型变量
a = 1.23
a = b = c = 2.1314
a,b = 11.0000,22.0
print(a,type(a)) #11.0 <class 'int'>
1
2
3
4
5

2. 内置函数float()
   float()是Python的内置函数，用于生成一个浮点数0.0，或将一个字符串或数字转换为浮点型

函数定义：class float(x)

• x–字符串或数字，当参数为空时会生成0.0

使用float()函数转换时要注意以下几点：

• 参数x为字符串时，字符串中只能带有数字字符，和一个小数点，不能有其他无用字符（也可以在字符最前面加正号或负号，但正负号和数字之间不能有空格，数字和小数点之间不能有空格，其他地方可以有空格）

#使用float生成浮点型变量
a = float()
print(a,type(a)) #0.0 <class 'float'>
#将整型转换为浮点型
b = float(320)
print(b,type(b)) #320.0 <class 'float'>
#将字符串转换为浮点型
c = float('-0012.0')
print(c,type(c)) #-12.0 <class 'float'>
c = float('-.36')
print(c,type(c)) #-0.36 <class 'float'>
c = float('-5.')
print(c,type(c)) #-5.0 <class 'float'>
#此时inf表示一个正无穷大的浮点数
c = float('inf') #inf
print(c,type(c)) #inf <class 'float'>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#将bool类型转换为浮点型
f1 = float(False)
print(f1,type(f1)) #0.0 <class 'float'>
f2 = float(True)
print(f2,type(f2)) #1.0 <class 'float'>
1
2
3
4
5

3. 浮点数相加减
   两个浮点数相加减的结果可能会有误差

ff = 1.28+1.0
print(ff,type(ff)) #2.2800000000000002 <class 'float'>
ff = 1.6-1.0
print(ff,type(ff)) #0.6000000000000001 <class 'float'>
1
2
3
4

复数complex

复数是由一个实数和一个虚数组合构成的数，表示为x+yj或x+yJ，其中：

• x是实数部分，y是虚数部分，虚数部分后面必须带有j或J
• x和y都是浮点数，他们都必须存在
• 虚数不能单独存在，它们总是和一个值为 0.0 的实数部分一起构成一个复数
• 一个复数对象的real属性代表实数部分，imag属性代表虚数部分

1. 定义复数变量

#定义复数变量
a = 1.5+3.4j
print(a,type(a)) #(1.5+3.4j) <class 'complex'>
print(a.real,a.imag) #1.5 3.4
b = 1-2j
print(b,type(b)) #(1-2j) <class 'complex'>
print(b.real,b.imag) #1.0 -2.0
c = 4J #当实数部分为0时可以不写
print(c,type(c)) #4j <class 'complex'>
print(c.real,c.imag) #0.0 4.0
#j前面一定要有数字，也就是虚数部分一定要写出来
a = 1.5+j
print(a,type(a)) #NameError: name 'j' is not defined
1
2
3
4
5
6
7
8
9
10
11
12
13

2. 内置函数complex()
   complex()是Python的内置函数，用于生成一个0.0+0.0j的复数，或将一个字符串或数字转换为复数

函数定义：class complex(real[,imag])

• real–可以是字符串或数字，当参数为空时会生成0.0+0.0j
• imag–可以不写，但必须是整数或浮点数，且如果real是字符串的情况下imag不可以有

使用complex()函数转换时要注意以下几点：

• 参数为整数（或bool值）时，会将整数先转换为浮点数，然后将这个浮点数作为复数的实数部分，虚数部分就为0.0j
• 参数为浮点数时，直接将这个浮点数作为复数的实数部分，虚数部分为0.0j
• 参数为复数时，直接输出这个复数
• 参数为字符串时，字符串是“整数或浮点数”就按整数和浮点数处理，字符串是“复数”就按复数处理，字符串是其他形式就抛出异常（字符串中数字前面或者后面的可以有空格）

#使用complex()生成一个复数
a = complex()
print(a,type(a)) #0j <class 'complex'>
print(a.real,a.imag) #0.0 0.0
#将整型转换为复数
b = complex(-241)
print(b,type(b)) #(-241+0j) <class 'complex'>
print(b.real,b.imag) #-241.0 0.0
b = complex(-2,1)
print(b,type(b)) #(-2+1j) <class 'complex'>
print(b.real,b.imag) #-2.0 1.0
#将浮点型转换为复数
c = complex(1.)
print(c,type(c)) #(1+0j) <class 'complex'>
print(c.real,c.imag) #1.0 0.0
b = complex(-2.6,)
print(b,type(b)) #(-2.6+0j) <class 'complex'>
print(b.real,b.imag) #-2.6 0.0
#将复数转换为复数
com = complex(3+2j)
print(com,type(com)) #(3+2j) <class 'complex'>
print(com.real,com.imag) #3.0 2.0
b = complex(-2+6j,1)
print(b,type(b)) #(-2+7j) <class 'complex'>
print(b.real,b.imag) #-2.0 7.0
#将字符串转换为复数
d = complex('1')
print(d,type(d)) #(1+0j) <class 'complex'>
print(d.real,d.imag) #1.0 0.0
#比较特殊的是定义复数时虚数部分必须写，但字符串转复数时，这个“复数”字符串的虚部不要求必须写
d = complex('1.3+j')
print(d,type(d)) #(1.3+1j) <class 'complex'>
print(d.real,d.imag) #1.3 1.0
#将bool值转换为复数
a = complex(True)
print(a,type(a)) #(1+0j) <class 'complex'>
print(a.real,a.imag) #1.0 0.0
b = complex(False)
print(b,type(b)) #0j <class 'complex'>
print(b.real,b.imag) #0.0 0.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

数字类型的算法

数字运算

所有的数字类型（除复数之外）都支持下列运算:

x = 12.3
y = 5
print(abs(x)) #12.3
print(divmod(x,y),type(divmod(x,y))) #(2.0, 2.3000000000000007) <class 'tuple'>
print(pow(y,5,8)) #5
#round(x,n)  n=None和n=0的结果是不一样的，n=0始终要保留一位小数0
print(round(x,0)) #12.0
print(round(8.502,0)) #9.0
print(round(8.502)) #9
1
2
3
4
5
6
7
8
9

数学函数math

math是Python内置的数学类函数库，这个库只适用于整数和浮点数，不适用于复数。math模块在使用之前必须先import导入，下图可以看到math模块包含了很多属性，下面我们来逐一介绍

math常量

math里的常量表示的是数学常数，比如数学里面的π，所有常量如下

数论与表示函数

import math
a = math.fsum([1.0,1.2,2,3])
print(a,type(a)) #7.2 <class 'float'>
a1 = math.gcd()
print(a1,type(a1)) #0 <class 'int'>
a2 = math.lcm(12,8)
print(a2,type(a2)) #24 <class 'int'>
a3 = math.modf(8.52)
print(a3,type(a3)) #(0.5199999999999996, 8.0) <class 'tuple'>
a4 = math.ceil(-5.2)
print(a4,type(a4)) #-5 <class 'int'>
a5 = math.floor(-6.4)
print(a5,type(a5)) #-7 <class 'int'>
a6 = math.comb(5,2)
print(a6,type(a6)) #10 <class 'int'>
a7 = math.perm(5,2)
print(a7,type(a7)) #20 <class 'int'>
a8 = math.copysign(5.6,-0)
print(a8,type(a8)) #5.6 <class 'float'>
a9 = math.fmod
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19