常用函数（一）

函数type()

• 内置函数type()用来查看变量类型

>>> x=3
>>> type(x)

<class 'int'>

函数isinstance()

• 内置函数isinstance()用来测试变量是否为指定类型

>>> isinstance(x,int)
True

数字

• 在Python中，内置的数字类型有整数、实数和复数。

实数

• 对于实数运算可能会有一定的误差，应尽量避免在实数之间直接进行相等性测试，而是应该以两者之差的绝对值是否足够小作为两个实数是否相等的依据。
• 在数字的算术运算表达式求值时，会进行隐式类型的转换，如果存在复数则都变成复数，如果没有复数但是有实数就都会变成实数，如果都是整数则不进行类型转换。

>>> 0.4-0.1
0.30000000000000004
>>> 0.4-0.1==0.3
False
>>> abs(0.4-0.1-0.3)<1e-6 #表示10的-6次方
True

复数

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

>>> x=3+4j #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对象支持分数运算
• 还提供了计算最大公约数的gcd()函数和高精度Decimal

>>> 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)
>>> x-y
Fraction(6, 35)
>>> x*y
Fraction(9, 35)
>>> x/y
Fraction(7, 5)
>>> x*2
Fraction(6, 5)
>>> Fraction(3.5) #将实数转换为分数
Fraction(7, 2)
>>> 

高精度实数

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

>>> from fractions import Decimal
>>> 1/9
0.1111111111111111
>>> Decimal(1/9)
Decimal('0.111111111111111104943205418749130330979824066162109375')

encode()与decode()

• 对str类型的字符串调用encode()方法进行编码得到bytes字节串
• 对bytes字节串调用decode()方法并指定正确的编码格式则得到str字符串

>>> type('hello world') #默认字符串类型为str
<class 'str'>
>>> type(b'hello world') #在界定符前加b表示字节串
<class 'bytes'>
>>> 'hello world'.encode('utf-8') #使用UTF-8编码格式进行编码
b'hello world'
>>> 'hello world'.encode('gbk') #使用gbk编码格式进行编码
b'hello world'
>>> '张三'.encode('utf-8') #对中文进行编码
b'\xe5\xbc\xa0\xe4\xb8\x89'
>>> _.decode('utf-8') #一个下划线表示最后一次正确输出结果
'张三'
>>> 

类型转换

• 内置函数bin()、oct()、hex()用来将整数转换为二进制、八进制、十六进制

>>> bin(555)
'0b1000101011'
>>> oct(555)
'0o1053'
>>> hex(555)
'0x22b'

• complex()函数用来生成复数

>>> complex(3,5)
(3+5j)

• ord()和chr()函数
• ord()函数用来返回单个字符的unicode码
• chr()函数用来返回unicode编码对应的字符

>>> ord('a')
97
>>> chr(55)
'7'
>>> ord('张') #仅适用于Python3.x
24352
>>> chr(ord('张')+1) #支持中文
'弡'
>>> 

• 内置类ascii可以把对象转换为ASCII码表示形式

>>> ascii('张三')
"'\\u5f20\\u4e09'"

max（）与min（），sum（）

• max()与min()函数支持default参数和key参数
• default参数用来指定可迭代对象为空时默认返回的最大值或最小值
• key 参数用来指定比较大小的依据或规则，可以是函数或lambda表达式
• sum()函数还支持start参数，用来控制求和的初始值

>>> max(['2','111'],key=len) #指定返回最长字符串
'111'
>>> print(max([],default=None)) #对空列表求最大值，返回空值
None
>>> from random import randint
>>> lst=[[randint(1,50)for i in range(5)] for j in range(30)] #生成包含30个字列表的列表
>>> max(lst,key=lambda x:x[1]) #所有子列表中第二个元素最大的子列表
[6, 50, 19, 22, 50]
>>> sum(range(1,11),5) #指定start参数为5
60

排序与逆序

• sorted()对列表、元组、字典、集合或其他可迭代对象进行排序返回新列表
• reversed()对对象进行翻转

>>> x=list(range(11))
>>> import random
>>> random.shuffle(x) #打乱顺序
>>> x
[2, 9, 10, 4, 7, 3, 1, 5, 0, 6, 8]
>>> sorted(x) #以默认规则排序
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> sorted(x,key=lambda item:len(str(item)),reverse=True) #按转换成字符串以后的长度降序排列
[10, 2, 9, 4, 7, 3, 1, 5, 0, 6, 8]
>>> reversed(x) #逆序 返回reversed对象
<list_reverseiterator object at 0x00000041E0E47B00>
>>> list(reversed(x)) #reversed对象是可以迭代的
[8, 6, 0, 5, 1, 3, 7, 4, 10, 9, 2]
>>> 

枚举

• enumerate()函数用来枚举可迭代对象中的元素，返回课迭代的enumerate对象，其中每个元素都是包含索引和值的元组
• 内置函数enumerate()支持start参数，用来指定枚举时的索引起始值

>>> list(enumerate('abcd')) #枚举字符串中的元素
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
>>> list(enumerate({'a':97,'b':98}.items())) #枚举字典中的元素
[(0, ('a', 97)), (1, ('b', 98))]

>>> for item in enumerate(range(5),6): #索引从6 开始
	print(item,end=',')

	
(6, 0),(7, 1),(8, 2),(9, 3),(10, 4),

map()函数

• 内置map()函数把一个函数func 依次映射到序列或迭代器对象的每个元素上，并返回一个可迭代的map对象作为结果
• map对象中每个元素是原序列中元素经过函数func 处理后的结果
• map()函数不对原序列或迭代器对象做任何修改

>>> 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]
>>> 

>>> list(map(lambda x,y:x+y,range(5),range(5,10))) #使用lambda 函数
[5, 7, 9, 11, 13]

reduce()函数

• 标准库functools中的函数reduce()可以将一个接收两个参数的函数以迭代累积的方式从左到右依次作用到一个序列或迭代器对象的所有元素上，并且允许指定一个初始值。

>>> from functools import reduce
>>> reduce(lambda x,y:x+y,[1,2,3,4,5])
15

• 计算过程
  
• 计算过程为（（（（1+2）+3）+4）+5）

filter()函数

• 内置函数filter()将一个单参数函数作用到一个序列上，返回该序列中使得该函数返回值为TRUE的那些元素组成的filter对象
• 如果指定函数为None，则返回序列中等价于True的元素

>>> seq=['foo','x41','!?',',','***']
>>> def func(x):
	return x.isalnum() #测试是否为字母或数字

>>> filter(func,seq)
<filter object at 0x0000001E21C57BE0> #返回filter对象
>>> list(filter(func,seq))
['foo', 'x41'] #将filter对象转换为列表
>>> 

• 指定函数为None

>>> list(filter(None,[1,2,3,0,0,4,5]))
[1, 2, 3, 4, 5]

range()函数

• 该函数返回具有惰性求值特点的range对象
• 包含左闭右开区间[start,end)内以step为步长的整数。
• 参数start默认为0，step默认为1
• 有三种表达方式：range(stop)、range（start,stop）、range(start,stop,step)

>>> range(5) #参数start默认为0，step默认为1
range(0, 5)
>>> list(_)
[0, 1, 2, 3, 4]
>>> list(range(1,10,2)) #指定起始值和步长
[1, 3, 5, 7, 9]
>>> list(range(9,0,-2)) #步长为负数时，起始值应比结束值大
[9, 7, 5, 3, 1]

zip ()函数

• zip()函数用来把多个可迭代对象中的元素压缩到一起，返回一个可迭代的zip对象
• 其中每个元素都是包含原来的多个可迭代对象对应位置上元素的元组
• 最终结果中包含的元素个数取决于所有参数序列或可迭代对象中最短的那个。

>>> list(zip('abcd',[1,2,3])) #压缩字符串和列表
[('a', 1), ('b', 2), ('c', 3)]

>>> list(zip('abcd')) #对1个序列也可以压缩
[('a',), ('b',), ('c',), ('d',)]

>>> list(zip('123','abc',',.')) #按最短的元素进行压缩
[('1', 'a', ','), ('2', 'b', '.')]

eval()函数

• 内置函数eval()用来计算字符串的值
• 在有些场合也可以用来实现类型转换功能

>>> eval(b'3+5') #实现字符串值的计算
8

>>> eval('9') #把数字字符串转换为数字
9
>>> type(_)
<class 'int'>

>>> eval('09') #抛出异常，不允许以0开头的数字
Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>
    eval('09')
  File "<string>", line 1
    09
     ^
SyntaxError: invalid token