02 python初识数据类型和数据运算符
1、初识数据类型
1.1、数字
1、整数
- Python2中有int和long，但能自动转换。
- Python3中只有int。
(1)int（整型）
- 在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647。
- 在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807。
(2)long（长整型）
- 跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
- 注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。
2、浮点数(float)
- 浮点数用来处理实数，即带有小数的数字。类似于C语言中的double类型，占8个字节（64位），其中52位表示底，11位表示指数，剩下的一位表示符号。
3、Bytes类型
- Python2不区分二进制字节和字符串，二者可以拼接
- Python3区分二进制字节和字符串，二者不可以拼接
转换：
string--(encode(‘string的编码’))-->bytes
bytes--(decode(‘string的编码’))-->string
4、复数(complex)
- 复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。
5、十六进制数、八进制数、二进制数和十进制
- 十六进制：0x。十六机制转二进制，一位变四位。
- 八进制：0o。八机制转二进制，一位变三位。
- 二进制：0b。二进制转八进制，三位变一位；二进制转十六进制，四位变一位。
- 负十进制数转二进制数（以-5为例）
(1)正十进制转二进制 #5 --> 0000 0101
(2)按位取反 #0000 0101 --> 1111 1010
(3)末位加一 #1111 1010 + 0000 0001 --> 1111 1011
>>> print(int(0b1111)) #二进制转十进制 15 >>> print(int(0o1111)) #八进制转十进制 585 >>> print(int(0x1111)) #十六进制转十进制 4369 >>> print(int(1111)) #十进制 1111
1.2、布尔值
- 被解释器视为假的值：False、None、0、""、()、[]、{}。即标准值False和None、各种类型（包括浮点数、复数等）的数值0、空序列（如空字符串、空元组和空列表）以及空映射（如空字典）都被视为假。
- 被解释器视为真的值：其他非假的值（非假即真），包括特殊值True。
- True和False是0和1的别名，虽然看起来不同，但作用是相同的。
>>> True True >>> False False >>> True == 1 True >>> False == 0 True >>> True + False + 42 43
- 布尔值True和False属于类型bool
>>> bool('I think, therefore I am')
True
>>> bool(42)
True
>>> bool('')
False
>>> bool(0)
False
1.3、序列和字典
容器：
- 序列：（如列表和元组）在序列中，每个元素都有编号
- 列表：可以修改的序列
- 元组: 不可以修改的序列
- 字符串：不可以修改的序列
- 映射：（如字典）在映射中，每个元素都有名称（也叫键）
Python中三种最重要的数据类型：列表、字符串和字典。
2、数据运算符
2.1、算术运算符
1、算数运算符
- 加法运算(+)
>>> a = 9
>>> b = 2
>>> print(a + b) #加号两边是int型，python解释器进行算数运算。
11
>>> a_str = 'mai'
>>> b_str = 'heng'
>>> print(a_str + b_str) #加号两边是str型，python进行字符串拼接。
maiheng
>>> print(a + a_str) #加号两边的数据类型要一致，否则返回异常
Traceback (most recent call last):
File "<pyshell#17>", line 1, in <module>
print(a + a_str)
TypeError: unsupported operand type(s) for +: 'int' and 'str'
- 减法运算
>>> print(a - b) 7
- 乘法运算
>>> print(a * b) 18
- 除法运算
>>> print(a / b) 4.5
2、扩展的算术运算符
- 乘方（求幂）运算符
>>> print(a ** b) #请注意，乘方运算符的优先级比求负（单目减）高 81
- 整除运算符
>>> print(a // b) #对于整除运算，需要明白的一个重点是它向下圆整结果 4
- %:求余（求模）运算符
>>> print(a % b) 1
2.2、赋值运算符
- 赋值运算符
>>> a = 9
>>> print('a = {}\ta_id:{}'.format(a,id(a)))
a = 9 a_id:140709872994224
>>> b = a #变量赋值变量，是两个变量使用同一个内存引用，即使用同一个内存地址
>>> print('a = {}\ta_id:{}\nb = {}\tb_id:{}'.format(a,id(a),b,id(b)))
a = 9 a_id:140709872994224
b = 9 b_id:140709872994224
>>> a = 4 #重新赋不同的值，将使用新的内存空间
>>> print('a = {}\ta_id:{}\nb = {}\tb_id:{}'.format(a,id(a),b,id(b)))
a = 4 a_id:140709872994064
b = 9 b_id:140709872994224
- 其他赋值运算符
>>> a_str='mai' >>> a_str += 'heng' #相当于a_str = a_str + 'heng'，只有+=支持字符串拼接 >>> print(a_str) maiheng >>> num = 9 >>> num += 2 #相当于num = num + 2 >>> print(num) 11 >>> num = 9 >>> num -= 2 #相当于num = num - 2 >>> print(num) 7 >>> num = 9 >>> num *= 2 #相当于num = num * 2 >>> print(num) 18 >>> num = 9 >>> num /= 2 #相当于num = num / 2 >>> print(num) 4.5 >>> num = 9 >>> num **= 2 #相当于num = num ** 2 >>> print(num) 81 >>> num = 9 >>> num %= 2 #相当于num = num % 2 >>> print(num) 1 >>> num = 9 >>> num //= 2 #相当于num = num // 2 >>> print(num) 4
2.3、比较运算符
- 比较运算符比较的是两个对象的值
>>> m1 = 'hello' >>> m2 = 'hello' >>> result = m1 == m2 #这里使用的是字符串作比较，当然数字也没问题 >>> print(result) True >>> result = m1 != m2 >>> print(result) False >>> result = m1 > m2 >>> print(result) False >>> result = m1 < m2 >>> print(result) False >>> result = m1 >= m2 >>> print(result) True >>> result = m1 <= m2 >>> print(result) True
2.4、身份运算符
- 身份运算符比较的是两个对象的引用，即内存地址。
- ==用来检查两个对象的值是否相等，而is用来检查两个对象是否相同（是同一个对象）。
- 不要将is用于数和字符串等不可变的基本值。鉴于Python在内部处理这些对象的方式，这样做的结果是不可预测的。
>>> x = y = [1, 2, 3]
>>> z = [1, 2, 3]
>>> print('x == y：%s, x_id：%s, y_id：%s' %(x == y,id(x),id(y)))
x == y：True, x_id：2193461117568, y_id：2193461117568
>>> print('x == z：%s, x_id：%s, z_id：%s' %(x == z,id(x),id(z)))
x == z：True, x_id：2193461117568, z_id：2193479884352
>>> print('x is y：%s, x_id：%s, y_id：%s' %(x is y,id(x),id(y)))
x is y：True, x_id：2193461117568, y_id：2193461117568
>>> print('x is z：%s, x_id：%s, z_id：%s' %(x is z,id(x),id(z)))
x is z：False, x_id：2193461117568, z_id：2193479884352
- 字符串和序列的比较
- 不要将is用于数和字符串等不可变的基本值
>>> "alpha" < "beta" #字符串是根据字符的字母排列顺序进行比较的，先转换为数字在比较
True
>>> ord('a') #字符转换为ASCII码
97
>>> chr(97) #ASCII码转换为字符
'a'
>>> [2, [1, 4]] < [2, [1, 5]] #序列也是按顺序比较的
True
1、python的小整数对象池
(1)小整数对象池- 整数在程序中的使用非常广泛，Python为了优化速度，使用了小整数对象池，避免为整数频繁申请和销毁内存空间。
- Python对小整数的定义是[-5, 256]。这些整数对象是提前建立好的，不会被垃圾回收。在一个Python的程序中，无论这些整数处于LEGB中的哪个位置使用的都是同一个对象。
>>> a1 = 256
>>> b1 = 256
>>> print('a1 is b1是{},\ta1={},\tb1={},\ta1_id是{},\tb1_id是{}'.format(a1 is b1,a1,b1,id(a1),id(b1))) #结果是True
a1 is b1是True, a1=256, b1=256, a1_id是140709980939920, b1_id是140709980939920
>>> a2 = 257
>>> b2 = 257
>>> print('a2 is b2是{},\ta2={},\tb2={},\ta2_id是{},\tb2_id是{}'.format(a2 is b2,a2,b2,id(a2),id(b2))) #结果是False
a2 is b2是False, a2=257, b2=257, a2_id是2512877094768, b2_id是2512877094608
(2)LEGB
- Python 由很多名字空间，而 LEGB 则是名字空间的一种查找规则。
- LEGB 代表名字查找顺序: locals --> enclosing function --> globals --> __builtins__
locals 是函数内的名字空间，包括局部变量和形参
enclosing 外部嵌套函数的名字空间（闭包中常见）
globals 全局变量，函数定义所在模块的名字空间
builtins 内置模块的名字空间
2、python的大整数对象池。
- python shell是每次执行一次，所以每次的大整数都重新创建，即开辟新的内存空间。
- 在pycharm(即在.py文件)中，每次运行是所有代码都加载都内存中，属于一个整体，所以这个时候会有一个大整数对象池，即处于一个代码块的大整数是同一个对象。
a1 = 256 #在Pycharm中
b1 = 256
print('a1 is b1是{},\ta1={},\tb1={},\ta1_id是{},\tb1_id是{}'.format(a1 is b1,a1,b1,id(a1),id(b1))) #结果是True
a2 = 257
b2 = 257
print('a2 is b2是{},\ta2={},\tb2={},\ta2_id是{},\tb2_id是{}'.format(a2 is b2,a2,b2,id(a2),id(b2))) #结果是True
<<<
a1 is b1是True, a1=256, b1=256, a1_id是140709980939920, b1_id是140709980939920
a2 is b2是True, a2=257, b2=257, a2_id是2170728401904, b2_id是2170728401904
3、python中字符串的intern机制
- 在python shell中，仅仅包括下划线、数字、字母的字符串才会采用intern机制。
- 在早期的python中，字符串且不能超过20个字符。因为如果超过20个字符，解释器认为这个字符串不常用，不用放入字符串池中。
>>> a1 = 'a'
>>> b1 = 'b'
>>> print('a1 is b1是{},\ta1={},\tb1={},\ta1_id是{},\tb1_id是{}'.format(a1 is b1,a1,b1,id(a1),id(b1)))
a1 is b1是False, a1=a, b1=b, a1_id是2038762110456, b1_id是2038762108776
>>> a2 = 'a' * 20
>>> b2 = 'a' * 20
>>> print('a2 is b2是{},\ta2={},\tb2={},\ta2_id是{},\tb2_id是{}'.format(a2 is b2,a2,b2,id(a2),id(b2)))
a2 is b2是True, a2=aaaaaaaaaaaaaaaaaaaa, b2=aaaaaaaaaaaaaaaaaaaa, a2_id是2038771554536, b2_id是2038771554536
###Python 2.7.18 Shell
>>> a3 = 'a' * 21
>>> b3 = 'a' * 21
>>> print('a3 is b3是{},\ta3={},\tb3={},\ta3_id是{},\tb3_id是{}'.format(a3 is b3,a3,b3,id(a3),id(b3)))
a3 is b3是False, a3=aaaaaaaaaaaaaaaaaaaaa, b3=aaaaaaaaaaaaaaaaaaaaa, a3_id是56246896, b3_id是64983536
###Python 3.6.5 Shell
>>> a3 = 'a' * 21
>>> b3 = 'a' * 21
>>> print('a3 is b3是{},\ta3={},\tb3={},\ta3_id是{},\tb3_id是{}'.format(a3 is b3,a3,b3,id(a3),id(b3)))
a3 is b3是False, a3=aaaaaaaaaaaaaaaaaaaaa, b3=aaaaaaaaaaaaaaaaaaaaa, a3_id是2038771554752, b3_id是2038771554536
###Python 3.7.7 Shell
>>> a3 = 'a' * 21
>>> b3 = 'a' * 21
>>> print('a3 is b3是{},\ta3={},\tb3={},\ta3_id是{},\tb3_id是{}'.format(a3 is b3,a3,b3,id(a3),id(b3)))
a3 is b3是True, a3=aaaaaaaaaaaaaaaaaaaaa, b3=aaaaaaaaaaaaaaaaaaaaa, a3_id是2462280528480, b3_id是2462280528480
###Python 3.8.7 Shell
>>> a3 = 'a' * 21
>>> b3 = 'a' * 21
>>> print('a3 is b3是{},\ta3={},\tb3={},\ta3_id是{},\tb3_id是{}'.format(a3 is b3,a3,b3,id(a3),id(b3)))
a3 is b3是True, a3=aaaaaaaaaaaaaaaaaaaaa, b3=aaaaaaaaaaaaaaaaaaaaa, a3_id是2304345552096, b3_id是2304345552096
2.5、成员运算符
name = input('What is your name?')
if 's' in name:
print('Your name contains the letter "s".')
else:
print('Your name does not contain the letter "s".')
2.6、逻辑运算符
- 短路逻辑：
- 在表达式x and y中，仅当x和y都为真时表达式才为真。因此如果x为假，表达式立即返回假（即返回x），而不关心y。
- 在表达式x or y中，一真则真。因此如果x为真，就返回x，否则返回y。
-
and要碰假，返回第一个假，否则返回最后一个真（遇假则停）
or 要碰真，返回第一个真，否则返回最后一个假（遇真则停）
>>> print(1 < 2 and 2 < 3) #逻辑运算符and，一假即假 True >>> print(1 > 2 and 2 < 3) False >>> print(1 < 2 and 2 > 3) False >>> print(1 > 2 and 2 > 3) False >>> print(1 < 2 or 2 < 3) #逻辑运算符or，一真即真 True >>> print(1 > 2 or 2 < 3) True >>> print(1 < 2 or 2 > 3) True >>> print(1 > 2 or 2 > 3) False >>> print(1 > 2) #逻辑运算符not False >>> print(not 1 > 2) True
2.7、位运算符
>>> print('60 & 13：{}, 60的二进制：{}, 13的二进制：{}'.format(60 & 13,bin(60),bin(13))) #按位与，双一为一
60 & 13：12, 60的二进制：0b111100, 13的二进制：0b1101
>>> print('60 | 13：{}, 60的二进制：{}, 13的二进制：{}'.format(60 | 13,bin(60),bin(13))) #按位或，有一为一
60 | 13：61, 60的二进制：0b111100, 13的二进制：0b1101
>>> print('60 ^ 13：{}, 60的二进制：{}, 13的二进制：{}'.format(60 ^ 13,bin(60),bin(13))) #按位异或，不同为一
60 ^ 13：49, 60的二进制：0b111100, 13的二进制：0b1101
>>> print('60 << 2：{}, 60的二进制：{}, 60左移2为后的二进制：{}'.format(60 << 2,bin(60),bin(60 << 2))) #按位左移，n << m结果是n*(2**m)
60 << 2：240, 60的二进制：0b111100, 60左移2为后的二进制：0b11110000
>>> print('60 >> 2：{}, 60的二进制：{}, 60右移2为后的二进制：{}'.format(60 >> 2,bin(60),bin(60 >> 2))) #按位右移，n >> m结果是n//(2**m)
60 >> 2：15, 60的二进制：0b111100, 60右移2为后的二进制：0b1111
3、运算符优先级
以下表格列出了从最高到最低优先级的所有运算符
浙公网安备 33010602011771号