Python常用内置对象
对象是python语言中最基本的概念，在python中处理的一切都是对象。
python中有许多内置对象可供编程者使用，内置对象可直接使用，如数字、字符串、列表等。
非内置对象需要导入模块才能使用，如正弦函数sin(x)，随机数产生函数random( )等。
常量与变量
赋值语句的执行过程是：首先把等号右侧表达式的值计算出来，然后在内存中寻找一个位置把值存放进去，最后创建变量并指向这个内存地址。
- Python中的变量并不直接存储值，而是存储了值的内存地址或者引用，这也是变量类型随时可以改变的原因。
Python采用的是基于值的内存管理方式，如果为不同变量赋值为相同值（仅适用于-5至256的整数和短字符串），这个值在内存中只有一份，多个变量指向同一块内存地址。
>>> x = 3
>>> id(x)
>>> x = 3
>>> id(x) ## id()函数用来查看对象的内存地址
10417624
>>> y = 3
>>> id(y)
10417624
>>> x = [1, 1, 1, 1]
>>> id(x[0]) == id(x[1])
True
10417624
>>> y = 3
>>> id(y)
10417624
>>> x = [1, 1, 1, 1]
>>> id(x[0]) == id(x[1])
True
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
数字
复数
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)
分数
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)
标准库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')
字符串与字节串
字符串
>>> 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'
字节串
对str类型的字符串调用其encode()方法进行编码得到bytes字节串，对bytes字节串调用其decode()方法并指定正确的编码格式则得到str字符串。
>>> type('Hello world') #默认字符串类型为str
<class 'str'>
>>> type(b'Hello world') #在定界符前加上字母b表示字节串
<class 'bytes'>
>>> 'Hello world'.encode('utf8') #使用utf8编码格式进行编码
b'Hello world'
>>> 'Hello world'.encode('gbk') #使用gbk编码格式进行编码
b'Hello world'
>>> '董付国'.encode('utf8') #对中文进行编码
b'\xe8\x91\xa3\xe4\xbb\x98\xe5\x9b\xbd'
>>> _.decode('utf8') #一个下划线表示最后一次正确输出结果
'董付国'
>>> '董付国'.encode('gbk')
b'\xb6\xad\xb8\xb6\xb9\xfa'
>>> _.decode('gbk') #对bytes字节串进行解码
'董付国'
列表、元组、字典、集合
>>> 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
运算符与表达式
运算符优先级遵循的规则为：算术运算符优先级最高，其次是位运算符、成员测试运算符、关系运算符、逻辑运算符等，算术运算符遵循“先乘除，后加减”的基本运算原则。
算术运算符
（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)
关系运算符
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
成员测试运算符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
位运算符与集合运算符
位运算符只能用于整数，其内部执行过程为：首先将整数转换为二进制数，然后右对齐，必要的时候左侧补0，按位进行运算，最后再把计算结果转换为十进制数字返回。
位与运算规则为 1&1=1、1&0=0&1=0&0=0，
位或运算规则为 1|1=1|0=0|1=1、0|0=0，
位异或运算规则为 1^1=0^0=0、1^0=0^1=1
左移位时右侧补0，每左移一位相当于乘2；
右移位时左侧补0，每右移一位相当于除2。
Python关键字简要说明
Python关键字只允许用来表达特定的语义，不允许通过任何方式改变它们的含义，也不能用来做变量名、函数名或类名等标识符。
在Python开发环境中导入模块keyword之后，可以使用print(keyword.kwlist)查看所有关键字。
Python常用内置函数用法精要
内置函数（BIF，built-in functions）是Python内置对象类型之一，不需要额外导入任何模块即可直接使用，这些内置对象都封装在内置模块__builtins__之中，用C语言实现并且进行了大量优化，具有非常快的运行速度，推荐优先使用。使用内置函数dir()可以查看所有内置函数和内置对象：
>>> dir(__builtins__)
使用help(函数名)可以查看某个函数的用法。
>>> help(sum)
类型转换与类型判断
内置函数bin()、oct()、hex()用来将整数转换为二进制、八进制和十六进制形式，这三个函数都要求参数必须为整数。
>>> bin(555) #把数字转换为二进制串
'0b1000101011'
>>> oct(555) #转换为八进制串
'0o1053'
>>> hex(555) #转换为十六进制串
'0x22b'
内置函数int()用来将其他形式的数字转换为整数，参数可以为整数、实数、分数或合法的数字字符串。当参数为数字字符串时，还允许指定第二个参数base用来说明数字字符串的进制，base的取值应为0或2-36之间的整数，其中0表示按数字字符串隐含的进制进行转换。
>>> int(-3.2) #把实数转换为整数
-3
>>> from fractions import Fraction, Decimal
>>> x = Fraction(7, 3)
>>> x
Fraction(7, 3)
>>> int(x) #把分数转换为整数
2
>>> x = Decimal(10/3)
>>> x
Decimal('3.333333333333333481363069950020872056484222412109375')
>>> int(x) #把高精度实数转换为整数
3
>>> int('0x22b', 16) #把十六进制数转换为十进制数
555
>>> int('22b', 16) #与上一行代码等价
555
>>> int(bin(54321), 2) #二进制与十进制之间的转换
54321
>>> int('0b111') #非十进制字符串进，必须指定第二个参数
ValueError: invalid literal for int() with base 10: '0b111'
>>> int('0b111', 0) #第二个参数0表示使用字符串隐含的进制
7
>>> int('0b111', 6) #第二个参数应与隐含的进制一致
ValueError: invalid literal for int() with base 6: '0b111'
>>> int('0b111', 2)
7
>>> int('111', 6) #字符串没有隐含进制
#第二个参数可以为2-36之间的数字
43
float() complex()
内置函数float()用来将其他类型数据转换为实数，complex()可以用来生成复数。
>>> float(3) #把整数转换为实数
3.0
>>> float('3.5') #把数字字符串转换为实数
3.5
>>> float('inf') #无穷大，其中inf不区分大小写
inf
>>> complex(3) #指定实部
(3+0j)
>>> complex(3, 5) #指定实部和虚部
(3+5j)
>>> complex('inf') #无穷大
(inf+0j)
ord()和chr()
ord()和chr()是一对功能相反的函数，ord()用来返回单个字符的Unicode码，而chr()则用来返回Unicode编码对应的字符，str()则直接将其任意类型参数转换为字符串。
>>> ord('a') #查看指定字符的Unicode编码
97
>>> chr(65) #返回数字65对应的字符
'A'
>>> chr(ord('A')+1) #Python不允许字符串和数字之间的加法操作
'B'
>>> chr(ord('国')+1) #支持中文
'图'
>>> ord('董') #这个用法仅适用于Python 3.x
33891
>>> ord('付')
20184
>>> ord('国')
22269
例如
>>> ''.join(map(chr, (33891, 20184, 22269)))
'董付国'
>>> str(1234) #直接变成字符串
'1234'
>>> str([1,2,3])
'[1, 2, 3]'
>>> str((1,2,3))
'(1, 2, 3)'
>>> str({
1,2,3})
'{1, 2, 3}'
内置类ascii可以把对象转换为ASCII码表示形式，必要的时候使用转义字符来表示特定的字符。
>>> ascii('a')
"'a'"
>>> ascii('董付国')
"'\\u8463\\u4ed8\\u56fd'"
>>> eval(_) #对字符串进行求值
'董付国'
内置类bytes用来生成字节串，或者把指定对象转换为特定编码的字节串。
>>> bytes() #生成空字节串
b''
>>> bytes(3) #生成长度为3的字节串
b'\x00\x00\x00'
>>> bytes('董付国','utf8') #把字符串转换为字节串
b'\xe8\x91\xa3\xe4\xbb\x98\xe5\x9b\xbd'
>>> bytes('董付国','gbk') #可以指定不同的编码格式
b'\xb6\xad\xb8\xb6\xb9\xfa'
>>> str(_, 'gbk') #使用同样的编码格式进行解码
'董付国'
>>> '董付国'.encode('gbk') #等价于使用bytes()进行转换
list()、tuple()、dict()、set()、frozenset()
list()、tuple()、dict()、set()、frozenset()用来把其他类型的数据转换成为列表、元组、字典、可变集合和不可变集合，或者创建空列表、空元组、空字典和空集合。
>>> list(range(5)) #把range对象转换为列表
[0, 1, 2, 3, 4]
>>> tuple(_) #一个下划线表示上一次正确的输出结果
(0, 1, 2, 3, 4)
>>> dict(zip('1234', 'abcde')) #创建字典
{
'4': 'd', '2': 'b', '3': 'c', '1': 'a'}
>>> set('1112234') #创建可变集合，自动去除重复
{
'4', '2', '3', '1'}
>>> _.add('5')
>>> _
{
'2', '1', '3', '4', '5'}
>>> frozenset('1112234') #创建不可变集合，自动去除重复
frozenset({
'2', '1', '3', '4'})
>>> _.add('5') #不可变集合frozenset不支持元素添加与删除
AttributeError: 'frozenset' object has no attribute 'add'
type()和isinstance()
内置函数type()和isinstance()可以用来判断数据类型，常用来对函数参数进行检查，可以避免错误的参数类型导致函数崩溃或返回意料之外的结果。
>>> type(3) #查看3的类型
<class 'int'>
>>> type([3]) #查看[3]的类型
<class 'list'>
>>> type({
3}) in (list, tuple, dict) #判断{3}是否为list,tuple或dict类型的实例
False
>>> type({
3}) in (list, tuple, dict, set) #判断{3}是否为list,tuple,dict或set的实例
True
>>> isinstance(3, int) #判断3是否为int类型的实例
True
>>> isinstance(3j, int)
False
>>> isinstance(3j, (int, float, complex)) #判断3是否为int,float或complex类型
True
最值与求和
max()、min()、sum()这三个内置函数分别用于计算列表、元组或其他包含有限个元素的可迭代对象中所有元素最大值、最小值以及所有元素之和。
sum()默认（可以通过start参数来改变）支持包含数值型元素的序列或可迭代对象，max()和min()则要求序列或可迭代对象中的元素之间可比较大小。
>>> from random import randint
>>> a = [randint(1,100) for i in range(10)] #包含10个[1,100]之间随机数的列表
>>> print(max(a), min(a), sum(a)) #最大值、最小值、所有元素之和
>>> sum(a) / len(a) #平均值
枚举与迭代
enumerate()函数用来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值的元组。
>>> list(enumerate('abcd')) #枚举字符串中的元素
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
>>> list(enumerate(['Python', 'Great'])) #枚举列表中的元素
[(0, 'Python'), (1, 'Great')]
>>> list(enumerate({
'a':97, 'b':98, 'c':99}.items())) #枚举字典中的元素
[(0, ('c', 99)), (1, ('a', 97)), (2, ('b', 98))]
>>> for index, value in enumerate(range(10, 15)): #枚举range对象中的元素
print((index, value), end=' ')
(0, 10) (1, 11) (2, 12) (3, 13) (4, 14)
map()、reduce()、filter()
内置函数map()把一个函数func依次映射到序列或迭代器对象的每个元素上，并返回一个可迭代的map对象作为结果，map对象中每个元素是原序列中元素经过函数func处理后的结果。
>>> list(map(str, range(5))) #把列表中元素转换为字符串
['0', '1', '2', '3', '4']
>>> def add5(v): #单参数函数
return v+5
>>> list(map(add5, range(10)))#把单参数函数映射到一个序列的所有元素
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>> def add(x, y): #可以接收2个参数的函数
return x+y
>>> list(map(add, range(5), range(5,10)))
#把双参数函数映射到两个序列上
[5, 7, 9, 11, 13]
案例解析
- 任意输入三个英文单词，按字典顺序输出。
s = input('x,y,z=')
x, y, z = sorted(s.split(','))
print(x, y, z)