内置函数（二）

数学运算（7）：

• abs：函数返回数字的绝对值。
• divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。
• round：保留浮点数的小数位数，默认保留整数。
• pow：求x**y次幂。（三个参数为x**y的结果对z取余）

print(abs(-5))  # 5

print(divmod(7,2))  # (3, 1)

print(round(7/3,2))  # 2.33
print(round(7/3))  # 2
print(round(3.32567,3))  # 3.326

print(pow(2,3))  # 两个参数为2**3次幂
print(pow(2,3,3))  # 三个参数为2**3次幂，对3取余。

• sum：对可迭代对象进行求和计算（可设置初始值）。
• min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。
• max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。

print(sum([1,2,3]))
#6
print(sum((1,2,3),100))
#106
print(sum([1,2,3],100))
#106
print(min([1,2,-5,],key=abs))
#1
dic = {'a':3,'b':2,'c':1}
print(min(dic,key=lambda x:dic[x]))
#c
print(max([1,2,3],key=abs))
#3
print(max([1,2,-6],key=abs))
#-6
dic = {'a':3,'b':2,'c':1}
print(max(dic,key=lambda x:dic[x]))
#a

 列表和元祖（2）

• list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。
• tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。

l = list((4,5,6))
print(l)
# [4, 5, 6]
l = list({4,5,6})
print(l)
# [4, 5, 6]
l = list({'a1':456,'a2':789})
print(l)
# ['a2', 'a1']
t = tuple((4,5,6))
print(t)
# (4, 5, 6)
t = tuple({4,5,6})
print(t)
# (4, 5, 6)
t = tuple({'a1':456,'a2':789})
print(t)
# ('a2', 'a1')

相关内置函数（2）

• reversed：将一个序列翻转，并返回此翻转序列的迭代器。（重要）
• slice：构造一个切片对象，用于列表的切片。

r = reversed(['a',2,3,'c',4,2])
print(r)
#<list_reverseiterator object at 0x00000000010AB860>
for i in r:
    print(i)
# 2
# 4
# c
# 3
# 2
# a
s = slice(7,8,9)
print(s)
# slice(7, 8, 9)

bytes：用于不同编码之间的转化。

b = '哈哈'
bs = b.encode('utf-8')
print(bs)
# b'xe5x93x88xe5x93x88'
bs = bs.decode('utf-8')
print(bs)
# 哈哈

repr:返回一个对象的string形式（原形毕露）。

name = 'xiaoyuer'
print('我是%s' % name)
# 我是xiaoyuer
print(repr('xiaoyuer'))
'xiaoyuer'

enumerate:枚举，返回一个枚举对象。

l = [1,2,3,4,5,6,7,8,9]
print(len(l))
# 9
for i in enumerate(l):
    print(i)
# (0, 1)
# (1, 2)
# (2, 3)
# (3, 4)
# (4, 5)
# (5, 6)
# (6, 7)
# (7, 8)
# (8, 9)
for k,i in enumerate(l):
    # print(k,i)
    print(k+1,i)
# 1 1
# 2 2
# 3 3
# 4 4
# 5 5
# 6 6
# 7 7
# 8 8
# 9 9

format:与具体数据相关，用于计算各种小数，精算等。

http://www.cnblogs.com/Eva-J/articles/7266245.html

print(format('test', '<20'))
print(format('test', '>20'))
print(format('test', '^20'))
# test                
#                 test
#         test    

zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。

l1 = [1,2,3]
l2 = [4,5,6]
print(zip(l1,l2))
# <zip object at 0x0000000000BB7B48>
print(list(zip(l1,l2)))
# [(1, 4), (2, 5), (3, 6)]
for i in zip(l1,l2):
    print(i)
# (1, 4)
# (2, 5)
# (3, 6)

filter

filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

def func(x):return x%2 == 0
ret = filter(func,[1,2,3,4,5,6,7])
print(ret)
for i in ret:
    print(i)
# <filter object at 0x00000000010D43C8>
# 2
# 4
# 6

map

python中的map函数应用于每一个可迭代的项，返回的是一个结果list。如果有其他的可迭代参数传进来，map函数则会把每一个参数都以相应的处理函数进行迭代处理。map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。

我们要将f(x)=x^2作用于这个list上，那么我们可以使用map函数处理。

[i**2 for i in range(10)]
def func(num):
    return num ** 2
for i in map(func,range(10)):print(i)
# 0
# 1
# 4
# 9
# 16
# 25
# 36
# 49
# 64
# 81

sorted：对所有可迭代的对象进行排序操作。

L = [('a', 1), ('c', 3), ('d', 4),('b', 2), ]
sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
 
 
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2])            # 按年龄排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
 
sorted(students, key=lambda s: s[2], reverse=True)    # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]