运算符、表达式与内置对象（一）

1. Python常用内置对象

• 对象是python语言中最基本的概念，在python中处理的一切都是对象。
• python中有许多内置对象可供编程者使用，内置对象可直接使用，如数字、字符串、列表等。
• 非内置对象需要导入模块才能使用，如正弦函数sin(x)，随机数产生函数random( )等。

对象类型	类型名称	示例	简要说明
数字	int float complex	1234 3.14, 1.3e5 3+4j	数字大小没有限制，内置支持复数及其运算
字符串	str	‘swfu’, “I’m student”, ‘’‘Python ‘’’, r’abc’, R’bcd’	使用单引号、双引号、三引号作为定界符，以字母r或R引导的表示原始字符串
字节串	bytes	b’hello world’ 以字母b引导，可以使用单引号、双引号、三引号作为定界符
列表	list	[1, 2, 3] [‘a’, ‘b’, [‘c’, 2]]	所有元素放在一对方括号中，元素之间使用逗号分隔，其中的元素可以是任意类型
字典	dict	{1:‘food’ ,2:‘taste’, 3:‘import’}	所有元素放在一对大括号中，元素之间使用逗号分隔，元素形式为“键:值”
元组	tuple	(2, -5, 6) (3,)	不可变，所有元素放在一对圆括号中，元素之间使用逗号分隔，如果元组中只有一个元素的话，后面的逗号不能省略
集合	set frozenset	{‘a’, ‘b’, ‘c’}	所有元素放在一对大括号中，元素之间使用逗号分隔，元素不允许重复;另外，set是可变的，而frozenset是不可变的
布尔型	bool	True, False	逻辑值，关系运算符、成员测试运算符、同一性测试运算符组成的表达式的值一般为True或False
空类型	NoneType	None	空值
异常	Exception ValueError TypeError		Python内置大量异常类，分别对应不同类型的异常
文件		f = open(‘data.dat’, ‘rb’)	open是Python内置函数，使用指定的模式打开文件，返回文件对象
其他可迭代对象		生成器对象、range对象、zip对象、enumerate对象、map对象、filter对象等等	具有惰性求值的特点，除range对象之外，其他对象中的元素只能看一次
编程单元		函数（使用def定义）类（使用class定义）模块（类型为module）	类和函数都属于可调用对象，模块用来集中存放函数、类、常量或其他对象

1.1 常量与变量

• 1.1.1 在Python中，不需要事先声明变量名及其类型，直接赋值即可创建各种类型的对象变量。这一点适用于Python任意类型的对象。

#例如语句
>>> x = 3  #凭空出现一个整型变量x

#创建了整型变量x，并赋值为3，再例如语句
>>> x = 'Hello world.'   #新的字符串变量，再也不是原来的x了

#创建了字符串变量x，并赋值为'Hello world.'。

• 1.1.2 赋值语句的执行过程是：首先把等号右侧表达式的值计算出来，然后在内存中寻找一个位置把值存放进去，最后创建变量并指向这个内存地址。

x = 3

• 1.1.3 Python中的变量并不直接存储值，而是存储了值的内存地址或者引用，这也是变量类型随时可以改变的原因。

  在Python中，允许多个变量指向同一个值，例如：

>>> x = 3
>>> id(x)
1786684560
>>> y = x
>>> id(y)
1786684560

#接着上面的代码再继续执行下面的代码
>>> x += 6
>>> id(x)
1786684752
>>> y
3
>>> id(y)
1786684560

• 1.1.4 Python采用的是基于值的内存管理方式，如果为不同变量赋值为相同值（仅适用于-5至256的整数和短字符串），这个值在内存中只有一份，多个变量指向同一块内存地址。

>>> x = 3
>>> id(x)
10417624
>>> y = 3
>>> id(y)  #id()函数用来查看对象的内存地址
10417624
>>> x = [1, 1, 1, 1]
>>> id(x[0]) == id(x[1])
True

• 1.1.5 Python属于强类型编程语言，Python解释器会根据赋值或运算来自动推断变量类型。Python还是一种动态类型语言，变量的类型也是可以随时变化的。

>>> x = 3
>>> print(type(x))
<class 'int'>
>>> x = 'Hello world.'
>>> print(type(x))                 #查看变量类型
<class 'str'>
>>> x = [1,2,3]
>>> print(type(x))
<class 'list'>
>>> isinstance(3, int)             #测试对象是否是某个类型的实例
True
>>> isinstance('Hello world', str)
True

• 1.1.6 在定义变量名的时候，需要注意以下问题：
  • 变量名必须以字母或下划线开头，但以下划线开头的变量在Python中有特殊含义；
  • 变量名中不能有空格以及标点符号（括号、引号、逗号、斜线、反斜线、冒号、句号、问号等等）；
  • 不能使用关键字作变量名，可以导入keyword模块后使用print(keyword.kwlist)查看所有Python关键字；
  • 变量名对英文字母的大小写敏感，例如student和Student是不同的变量。
  • 不建议使用系统内置的模块名、类型名或函数名以及已导入的模块名及其成员名作变量名，这将会改变其类型和含义，可以通过dir(builtins)查看所有内置模块、类型和函数；

>>> id(3)
1667343520
>>> id = '3724....'
>>> id(3)
TypeError: 'str' object is not callable

1.2 数字

• 1.2.1 Python支持任意大的数字，具体可以大到什么程度仅受内存大小的限制。
• 1.2.2 由于精度的问题，对于实数运算可能会有一定的误差，应尽量避免在实数之间直接进行相等性测试，而是应该以二者之差的绝对值是否足够小作为两个实数是否相等的依据。
• 1.2.3 在数字的算术运算表达式求值时会进行隐式的类型转换，如果存在复数则都变成复数，如果没有复数但是有实数就都变成实数，如果都是整数则不进行类型转换。

>>> 9999 ** 99                   #这里**是幂乘运算符，等价于内置函数pow()
990148353526723487602263124753282625570559528895791057324326529121794
837894053513464422176826916433932586924386677766244032001623756821400
432975051208820204980098735552703841362304669970510691243800218202840
374329378800694920309791954185117798434329591212159106298699938669908
067573374724331208942425544893910910073205049031656789220889560732962
926226305865706593594917896276756396848514900989999
>>> 0.3 + 0.2                    #实数相加
0.5
>>> 0.4 - 0.1                    #实数相减，结果稍微有点偏差
0.30000000000000004
>>> 0.4 - 0.1 == 0.3             #应尽量避免直接比较两个实数是否相等
False
>>> abs(0.4-0.1 - 0.3) < 1e-6    #这里1e-6表示10的-6次方
True

• 1.2.4 Python内置支持复数类型及其运算，并且形式与数学上的复数完全一致。

>>> x = 3 + 4j                 #使用j或J表示复数虚部
>>> y = 5 + 6j
>>> x + y                      #支持复数之间的加、减、乘、除以及幂乘等运算
(8+10j)
>>> x * y
(-9+38j)
>>> abs(x)                     #内置函数abs()可用来计算复数的模
5.0
>>> x.imag                     #虚部
4.0
>>> x.real                     #实部
3.0
>>> x.conjugate()              #共轭复数
(3-4j)

• 1.2.5 Python 3.6.x支持在数字中间位置使用单个下划线作为分隔来提高数字的可读性，类似于数学上使用逗号作为千位分隔符。
• 1.2.6 在Python数字中单个下划线可以出现在中间任意位置，但不能出现开头和结尾位置，也不能使用多个连续的下划线。

>>> 1_000_000
1000000
>>> 1_2_3_4
1234
>>> 1_2 + 3_4j
(12+34j)
>>> 1_2.3_45
12.345

• 1.2.7 Python标准库fractions中的Fraction对象支持分数及其运算。

>>> from fractions import Fraction
>>> x = Fraction(3, 5)     #创建分数对象
>>> y = Fraction(3, 7)
>>> x
Fraction(3, 5)
>>> x ** 2                 #幂运算
Fraction(9, 25)
>>> x.numerator            #查看分子
3
>>> x.denominator          #查看分母
5
>>> x + y                  #支持分数之间的四则运算，自动进行通分
Fraction(36, 35)

• 1.2.8 标准库fractions和decimal中提供的Decimal类实现了更高精度实数的运算。

>>> from fractions import Decimal
>>> 1 / 9                  #内置的实数类型
0.1111111111111111
>>> Decimal(1/9)           #高精度实数
Decimal('0.111111111111111104943205418749130330979824066162109375')
>>> 1 / 3
0.3333333333333333
>>> Decimal(1/3)
Decimal('0.333333333333333314829616256247390992939472198486328125')
>>> Decimal(1/9) + Decimal(1/3)
Decimal('0.4444444444444444197728216750')

1.3 字符串与字节串

• 在Python中，没有字符常量和变量的概念，只有字符串类型的常量和变量，单个字符也是字符串。使用单引号、双引号、三单引号、三双引号作为定界符（delimiter）来表示字符串，并且不同的定界符之间可以互相嵌套。
• Python 3.x全面支持中文，中文和英文字母都作为一个字符对待，甚至可以使用中文作为变量名。
• 除了支持使用加号运算符连接字符串以外，Python字符串还提供了大量的方法支持格式化、查找、替换、排版等操作。

>>> x = 'Hello world.'                  #使用单引号作为定界符
>>> x = "Python is a great language."   #使用双引号作为定界符
>>> x = '''Tom said, "Let's go."'''     #不同定界符之间可以互相嵌套
>>> print(x)
Tom said, "Let's go."
>>> x = 'good ' + 'morning'             #连接字符串
>>> x
'good morning'
>>> x = 'good ''morning'                #连接字符串，仅适用于字符串常量
>>> x
'good morning'
>>> x = 'good '
>>> x = x'morning'                      #不适用于字符串变量
SyntaxError: invalid syntax
>>> x = x + 'morning'                   #字符串变量之间的连接可以使用加号
>>> x
'good morning'

1.4 列表、元组、字典、集合

列表	元组	字典	集合
类型名称	list	tuple	dict
定界符	方括号[]	圆括号()	大括号{}
是否可变	是	否	是
是否有序	是	是	否
是否支持下标	是（使用序号作为下标）	是（使用序号作为下标）	是（使用“键”作为下标）
元素分隔符	逗号	逗号	逗号
对元素形式的要求	无	无	键:值
对元素值的要求	无	无	“键”必须可哈希
元素是否可重复	是	是	“键”不允许重复，“值”可以重复
元素查找速度	非常慢	很慢	非常快
新增和删除元素速度	尾部操作快 其他位置慢	不允许	快

>>> x_list = [1, 2, 3]                 #创建列表对象
>>> x_tuple = (1, 2, 3)                #创建元组对象
>>> x_dict = {'a':97, 'b':98, 'c':99}  #创建字典对象
>>> x_set = {1, 2, 3}                  #创建集合对象
>>> print(x_list[1])                   #使用下标访问指定位置的元素
2
>>> print(x_tuple[1])                  #元组也支持使用序号作为下标
2
>>> print(x_dict['a'])                 #字典对象的下标是“键”
97
>>> 3 in x_set                         #成员测试
True

2. Python运算符与表达式

• Python是面向对象的编程语言，在Python中一切都是对象。对象由数据和行为两部分组成，而行为主要通过方法来实现，通过一些特殊方法的重写，可以实现运算符重载。运算符也是表现对象行为的一种形式，不同类的对象支持的运算符有所不同，同一种运算符作用于不同的对象时也可能会表现出不同的行为，这正是“多态”的体现。
• 在Python中，单个常量或变量可以看作最简单的表达式，使用除赋值运算符之外的其他任意运算符和函数调用连接的式子也属于表达式。
• 运算符优先级遵循的规则为：算术运算符优先级最高，其次是位运算符、成员测试运算符、关系运算符、逻辑运算符等，算术运算符遵循“先乘除，后加减”的基本运算原则。
• 虽然Python运算符有一套严格的优先级规则，但是强烈建议在编写复杂表达式时使用圆括号来明确说明其中的逻辑来提高代码可读性。

运算符	功能说明
+	算术加法，列表、元组、字符串合并与连接，正号
-	算术减法，集合差集，相反数
*	算术乘法，序列重复
/	真除法
//	求整商，但如果操作数中有实数的话，结果为实数形式的整数
%	求余数，字符串格式化
**	幂运算
<、<=、>、>=、==、!=	（值）大小比较，集合的包含关系比较
or	逻辑或
and	逻辑与
not	逻辑非
in	成员测试
is	对象同一性测试，即测试是否为同一个对象或内存地址是否相同
^、&、<<、>>、~	位或、位异或、位与、左移位、右移位、位求反
&、^	集合交集、并集、对称差集
@	矩阵相乘运算符

2.1 算术运算符

（1）+运算符除了用于算术加法以外，还可以用于列表、元组、字符串的连接，但不支持不同类型的对象之间相加或连接。

>>> [1, 2, 3] + [4, 5, 6]          #连接两个列表
[1, 2, 3, 4, 5, 6]
>>> (1, 2, 3) + (4,)               #连接两个元组
(1, 2, 3, 4)
>>> 'abcd' + '1234'                #连接两个字符串
'abcd1234'
>>> 'A' + 1                        #不支持字符与数字相加，抛出异常
TypeError: Can't convert 'int' object to str implicitly
>>> True + 3                       #Python内部把True当作1处理
4
>>> False + 3                      #把False当作0处理
3

（2） *运算符除了表示算术乘法，还可用于列表、元组、字符串这几个序列类型与整数的乘法，表示序列元素的重复，生成新的序列对象。字典和集合不支持与整数的相乘，因为其中的元素是不允许重复的。

>>> True * 3
3
>>> False * 3
0
>>> [1, 2, 3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> (1, 2, 3) * 3
(1, 2, 3, 1, 2, 3, 1, 2, 3)
>>> 'abc' * 3
'abcabcabc'

(3） 运算符/和//在Python中分别表示算术除法和算术求整商（floor division）。

>>> 3 / 2                    #数学意义上的除法
1.5
>>> 15 // 4                  #如果两个操作数都是整数，结果为整数
3
>>> 15.0 // 4                #如果操作数中有实数，结果为实数形式的整数值
3.0
>>> -15//4                   #向下取整
-4

(4）%运算符可以用于整数或实数的求余数运算，还可以用于字符串格式化，但是这种用法并不推荐。

>>> 789 % 23                       #余数
7
>>> 123.45 % 3.2                 #可以对实数进行余数运算，注意精度问题
1.849999999999996
>>> '%c, %d' % (65, 65)       #把65分别格式化为字符和整数
'A, 65'
>>> '%f,%s' % (65, 65)         #把65分别格式化为实数和字符串
'65.000000,65'

（5）**运算符表示幂乘：

>>> 3 ** 2                    #3的2次方，等价于pow(3, 2)
9
>>> pow(3, 2, 8)              #等价于(3**2) % 8
1
>>> 9 ** 0.5                  #9的0.5次方，平方根
3.0
>>> (-9) ** 0.5               #可以计算负数的平方根
(1.8369701987210297e-16+3j)

2.2关系运算符

• Python关系运算符最大的特点是可以连用，其含义与我们日常的理解完全一致。使用关系运算符的一个最重要的前提是，操作数之间必须可比较大小。例如把一个字符串和一个数字进行大小比较是毫无意义的，所以Python也不支持这样的运算。

>>> 1 < 3 < 5                    #等价于1 < 3 and 3 < 5
True
>>> 3 < 5 > 2
True
>>> 1 > 6 < 8
False
>>> 1 > 6 < math.sqrt(9)         #具有惰性求值或者逻辑短路的特点
False
>>> 1 < 6 < math.sqrt(9)         #还没有导入math模块，抛出异常
NameError: name 'math' is not defined
>>> import math
>>> 1 < 6 < math.sqrt(9)
False

>>> 'Hello' > 'world'              #比较字符串大小
False
>>> [1, 2, 3] < [1, 2, 4]          #比较列表大小
True
>>> 'Hello' > 3                    #字符串和数字不能比较
TypeError: unorderable types: str() > int()
>>> {1, 2, 3} < {1, 2, 3, 4}       #测试是否子集
True
>>> {1, 2, 3} == {3, 2, 1}         #测试两个集合是否相等
True
>>> {1, 2, 4} > {1, 2, 3}          #集合之间的包含测试
False
>>> {1, 2, 4} < {1, 2, 3}
False
>>> {1, 2, 4} == {1, 2, 3}
False

2.3 成员测试运算符in与同一性测试运算符is

• 成员测试运算符in用于成员测试，即测试一个对象是否为另一个对象的元素。

>>> 3 in [1, 2, 3]                #测试3是否存在于列表[1, 2, 3]中
True
>>> 5 in range(1, 10, 1)          #range()是用来生成指定范围数字的内置函数
True
>>> 'abc' in 'abcdefg'            #子字符串测试
True
>>> for i in (3, 5, 7):           #循环，成员遍历
    print(i, end='\t')
3	5	7	

• 同一性测试运算符is用来测试两个对象是否是同一个，如果是则返回True，否则返回False。如果两个对象是同一个，二者具有相同的内存地址。

>>> 3 is 3
True
>>> x = [300, 300, 300]
>>> x[0] is x[1]                #基于值的内存管理，同一个值在内存中只有一份
True
>>> x = [1, 2, 3]
>>> y = [1, 2, 3]
>>> x is y                      #上面形式创建的x和y不是同一个列表对象
False
>>> x[0] is y[0]
True

2.4 位运算符与集合运算符

• 位运算符只能用于整数，其内部执行过程为：首先将整数转换为二进制数，然后右对齐，必要的时候左侧补0，按位进行运算，最后再把计算结果转换为十进制数字返回。
• 位与运算规则为1&1=1、1&0=0&1=0&0=0，位或运算规则为1|1=1|0=0|1=1、0|0=0，位异或运算规则为1¹⁼⁰0=0、1⁰⁼⁰1=1。
• 左移位时右侧补0，每左移一位相当于乘以2；右移位时左侧补0，每右移一位相当于整除以2。

>>> 3 << 2                   #把3左移2位
12
>>> 3 & 7                    #位与运算
3
>>> 3 | 8                    #位或运算
11
>>> 3 ^ 5                    #位异或运算
6

• 集合的交集、并集、对称差集等运算借助于位运算符来实现，而差集则使用减号运算符实现（注意，并集运算符不是加号）。

>>> {1, 2, 3} | {3, 4, 5}          #并集，自动去除重复元素
{1, 2, 3, 4, 5}
>>> {1, 2, 3} & {3, 4, 5}          #交集
{3}
>>> {1, 2, 3} ^ {3, 4, 5}          #对称差集
{1, 2, 4, 5}
>>> {1, 2, 3} - {3, 4, 5}          #差集
{1, 2}

2.5 逻辑运算符

• 逻辑运算符and、or、not常用来连接条件表达式构成更加复杂的条件表达式，并且and和or具有惰性求值或逻辑短路的特点，当连接多个表达式时只计算必须要计算的值。
• 例如表达式“exp1 and exp2”等价于“exp1 if not exp1 else exp2”，而表达式“exp1 or exp2”则等价于“exp1 if exp1 else exp2”。
• 在编写复杂条件表达式时充分利用这个特点，合理安排不同条件的先后顺序，在一定程度上可以提高代码运行速度。
• 另外要注意的是，运算符and和or并不一定会返回True或False，而是得到最后一个被计算的表达式的值，但是运算符not一定会返回True或False。

>>> 3>5 and a>3              #注意，此时并没有定义变量a
False
>>> 3>5 or a>3               #3>5的值为False，所以需要计算后面表达式
NameError: name 'a' is not defined
>>> 3<5 or a>3               #3<5的值为True，不需要计算后面表达式
True
>>> 3 and 5                  #最后一个计算的表达式的值作为整个表达式的值
5
>>> 3 and 5>2
True
>>> 3 not in [1, 2, 3]       #逻辑非运算not
False
>>> 3 is not 5               #not的计算结果只能是True或False之一
True
>>> not 3
False
>>> not 0
True

2.6 矩阵乘法运算符@

• 从Python 3.5开始增加了一个新的矩阵相乘运算符@，不过由于Python没有内置的矩阵类型，所以该运算符常与扩展库numpy一起使用。另外，@符号还可以用来表示修饰器的用法。

>>> import numpy             #numpy是用于科学计算的Python扩展库
>>> x = numpy.ones(3)        #ones()函数用于生成全1矩阵，参数表示矩阵大小
>>> m = numpy.eye(3)*3       #eye()函数用于生成单位矩阵
>>> m[0,2] = 5               #设置矩阵指定位置上元素的值
>>> m[2, 0] =3
>>> x @ m                    #矩阵相乘
array([ 6.,  3.,  8.])

2.7 补充说明

• Python还有赋值运算符=和+=、-=、*=、/=、//=、**=、|=、^=等大量复合赋值运算符。例如，x += 3在语法上等价（注意，在功能的细节上可能会稍有区别）于x = x + 3。
• Python不支持++和–运算符，虽然在形式上有时候似乎可以这样用，但实际上是另外的含义，要注意和其他语言的区别。

>>> i = 3
>>> ++i                            #正正得正
3
>>> +(+3)                          #与++i等价
3
>>> i++                            #Python不支持++运算符，语法错误
SyntaxError: invalid syntax
>>> --i                            #负负得正，等价于-(-i)
3
>>> ---i                           #等价于-(-(-i))
-3
>>> i--                            #Python不支持--运算符，语法错误
SyntaxError: invalid syntax