数据类型、运算符

最基本内置数据类型和运算符

每个对象都有类型，python 中最基本的内置数据类型：

1. 整型
   整数，2345,10,50
2. 浮点型
   小数，3.14 或者科学计数法 314e-2
3. 布尔型
   表示真假，仅包含：True、False
4. 字符串型
   由字符组成的序列。 “abc”,LiMing”,“教授”,”程序员”

数字和基本运算符

Python 支持整数(如：50,520)和浮点数(如：3.14,10.0, 1.23e2)，我们可以对数字做如下运算。

运算符	说明	示例	结果
+	加法	3+2	5
-	减法	30-5	25
*	乘法	3*6	18
/	浮点数除法	8/2	4.0
//	整数除法	7//2	3
%	模（取余）	7%4	3
**	幂	2**3	8

【操作】 基本运算符的使用

>>> a = 7/2
>>> a
3.5
>>> a = 7//2
>>> a
3
>>> a = 7%2
>>> a
1
>>> 7%4
3
>>> 2**3
8
>>> divmod(10,5)
(2, 0)
>>> divmod(10,3)
(3, 1)

除数为 0，会产生异常：

>>> 3/0
Traceback (most recent call last):
	File "<pyshell#31>", line 1, in <module>
		3/0
ZeroDivisionError: division by zero

使用 divmod()函数同时得到商和余数：

>>> divmod(13,3)
(4, 1)

divmod() 是一个函数，返回的是一个元组。

整数

Python 中，除 10 进制，还有其他三种进制：

简写	进制
0b 或 0B	二进制	0,1
0o 或 0O	八进制	0,1,2,3,4,5,6,7
0x 或 0X	十六进制	0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f

这三种进制可以非常方便的进行“位运算”操作。

【操作】 测试不同进制

>>> 12
12
>>> 0b101
5
>>> 0o19
SyntaxError: invalid syntax
>>> 0o10
8
>>> 0xff
255
>>> 0xf
15
>>> 0x10
16

使用 int()实现类型转换：

1. 浮点数直接舍去小数部分。如：int(9.9)结果是：9
2. 布尔值 True 转为 1，False 转为 0。 如：int(True)结果是 1
3. 字符串符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错。

>>> int("456")
456
>>> int("456abc")
Traceback (most recent call last):
	File "<pyshell#41>", line 1, in <module>
		int("456abc")
ValueError: invalid literal for int() with base 10: '456abc' 

>>> int("456.78")
Traceback (most recent call last):
	File "<pyshell#42>", line 1, in <module>
		int("456.78")
ValueError: invalid literal for int() with base 10: '456.78’

自动转型：
　　整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如：2+8.0 的结果是 10.0。

整数可以有多大？
　　Python2 中，int 是 32 位，可以存储从-2147483648 到 2147483647 的整数（约±21 亿）。Long 类型是 64 位，可以存储：-2^63–263-1 之间的数值。
Python3 中，int 可以存储任意大小的整数，long 被取消。我们甚至可以存储下面的值：

>>> googol = 10**100
>>> googol
1000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000
000

Googol 也是 Google 最初的名字，这也是 Google 最初的含义。
Python3 中可以做超大数的计算，而不会造成“整数溢出”，这也是 Python 特别适合科学运算的特点。

浮点数

浮点数，称为 float。
浮点数用 形式的科学计数法表示。比如：3.14，表示成：314E-2 或者 314e-2。
这些数字在内存中也是按照科学计数法存储。

布尔值

Python2 中没有布尔值，直接用数字 0 表示 False,用数字 1 表示 True。
Python3 中，把 True 和 False 定义成了关键字，但他们的本质还是 1 和 0，甚至可以和数字相加。

>>> a = True
>>> b = 3
>>> a+b
4

类型转换和四舍五入

1. 类似于 int()，我们也可以使用 float()将其他类型转化成浮点数。
2. 整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如：2+8.0 的结果是 10.0
3. round(value)可以返回四舍五入的值
   注：但不会改变原有值，而是产生新的值

其他重要的运算符

运算符	说明
and , or , not	布尔与、布尔或、布尔非
is , is not	同一性判断，判断是否为同一个对象
<,<=,>,>=,!=,==	比较值是否相当，可以连用
^ &	按位或，按位异或、按位与
<<, >>	移位
~	按位翻转
+,-,*,/,//,%	加，减，乘，浮点除、整数除、取余
**	幂运算

1. 比较运算符可以连用，并且含义和我们日常使用完全一致。

>>> a = 4
>>> 3<a<10 #关系运算符可以连用
True

2. 位操作

>>> a = 0b11001
>>> b = 0b01000
>>> c = a|b
>>> bin(c) #bin()可以将数字转成二进制表示
'0b11001' 
>>> bin(c&b)
'0b1000' 
>>> bin(c^b)
'0b10001' 
>>> a = 3
>>> a<<2 #左移 1 位相当于乘以 2.左移 2 位，相当于乘以 4
12
>>> a = 8
>>> a>>1 #右移 1 位相当于除以 2. 
>>> 4
>>> a>>2
2

3. 加法操作
   (1) 数字相加
   　　3+2 => 5
   (2) 字符串拼接
   　　“3”+“2” => “32”
   (3) 列表、元组等合并
   　　 [10,20,30]+[5,10,100] =>[10,20,30,5,10,100]

4. 乘法操作
   (1) 数字相乘
   　　3*2 => 6
   (2) 字符串复制
   　　“sxt”*3 => ”sxtsxtsxt”
   (3) 列表、元组等复制
   　　 [10,20,30]*3 => [10,20,30,10,20,30,10,20,30]

增强型赋值运算符

运算符+、-、*，/、//、**和%和赋值符=结合可以构成“增强型赋值运算符”。
a = a + 1 等价于： a +=1

增强型赋值运算符

运算符	例子	等价
+=	a += 2	a = a + 2
-=	a -= 2	a = a-2
*=	a *= 2	a = a * 2
/=	a /= 2	a = a / 2
//=	a //= 2	a = a//2
**=	a **= 2	a = a**2
%=	a %= 2	a = a % 2

注意：“+=”中间不能加空格！

复合赋值运算符

复合赋值可以让程序更加精炼，提高效率。

运算符	描述	示例	等价于
+=	加法赋值 字符串拼接	sum += n a += “sxt”	sum = sum + n a = a + “sxt”
-=	减法赋值		num1 -= n
*=	乘法赋值	a *= b	a = a * b
/=	浮点除赋值	a/=b	a = a / b
//=	整数除赋值	a//=b	a = a//b
%=	取余赋值	a%=b	a = a % b
**=	幂运算赋值	a**=2	a = a**2
<<=	左移赋值	a<<=2	a = a<<2
>>=	右移赋值	a>>=2	a = a>>2
&=	按位与赋值	a&=b	a = a&b
=	按位或赋值	a|=b	a=a|b
^=	按位异或赋值	a^=b	a = a^b

注： 与 C 和 JAVA 不一样，Python 不支持自增(++)和自减(–)

比较运算符

所有比较运算符返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。
以下假设变量 a 为 15，变量 b 为 30：

运算符	描述	实例
==	等于 - 比较对象的值是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象的值是否不相等	(a != b) 返回 true.
>	大于 - 返回 x 是否大于 y 。	(a > b) 返回 False。
<	小于 - 返回 x 是否小于y。	(a < b) 返回 true。
>=	大于等于 - 返回 x 是否大于等于 y。	(a >= b) 返回 False。
<=	小于等于 - 返回 x 是否小于等于 y。	(a <= b) 返回 true。

逻辑运算符

运算符	格式	说明
or 逻辑或	x or y	x 为 true，则不计算 y，直接返回 true x 为 false，则返回 y
and 逻辑与	x and y	x 为 true，则返回 y 的值 x 为 false，则不计算 y，直接返回 false
not 逻辑非	not x	x 为 true，返回 false x 为 false，返回 true

同一运算符

同一运算符用于比较两个对象的存储单元，实际比较的是 对象的地址。

运算符	描述
is	is 是判断两个标识符是不是引用同一个对象
is not	is not 是判断两个标识符是不是引用不同对象

is 与 == 区别：
　　is 用于判断两个变量引用对象是否为同一个，即比较对象的地址。
　　== 用于判断引用变量引用对象的值是否相等，默认调用对象的 eq()方法。

整数缓存问题

Python 仅仅对比较小的整数对象进行缓存（范围为[-5, 256]）缓存起来，而并非是所有整数对象。需要注意的是，这仅仅是在命令行中执行，而在 Pycharm 或者保存为文件执行，结果是不一样的，这是因为解释器做了一部分优化(范围是[-5,任意正整数])。

·总结

1、is 比较两个对象的 id 值是否相等，是否指向同一个内存地址；
2、== 比较的是两个对象的内容是否相等，值是否相等；
3、小整数对象[-5,256]在全局解释器范围内被放入缓存供重复使用；
4、is 运算符比 == 效率高，在变量和 None 进行比较时，应该使用 is。
【操作】 同一运算符测试

>>> a = 1000
>>> b = 1000
>>> a == b
True
>>> a is b
False
>>> id(a)
46764560
>>> id(b)
46765216
>>> c = 10
>>> d = 10
>>> c is d
True
>>> id(c)
1388831648
>>> id(d)
1388831648