python 内置函数

内置函数

什么是内置函数？内置就是Python给你提供的，拿来直接用的函数，比如print，input等等。

以下介绍几个重要的内置函数以及使用方法：

min，max函数

内置函数min:返回可迭代对象的最小值(可加key,key为函数名，通过函数的规则，返回最小值)。

l1 = [(1,1000),(2,18),(3,500)]
def func(x):
    return x[1]
print(min(l1, key=func))   # (2, 18)

从上面的例子可以看出：
1 min函数会将iterable里面的每个元素自动提取出来
2 min函数会将返回值作为比较大小的具体条件
3 min函数将遍历的元素返回回来
同理：内置函数max则是返回可迭代对象的最大值(可以加key，key为函数名，通过函数的规则，返回最大值)

与数据结构相关的内置函数

列表与元组

list: 将一个可迭代对象转化为列表(如果是字典，默认将key作为列表的元素)

tuple: 将一个可迭代对象转化为元组(如果是字典，默认将key作为元组的元素)

reversed()

reversed:将一个序列翻转，并返回次翻转序列的迭代器。

# 列表
l1 = [1,3,4,2,6]
for i in reversed(l1):
    print(i)
# 字符串
s1 = 'assdfdgf'
for i in reversed(s1):
    print(i)
# 字典
dic = {'name':'colin','age':27,'hobby':'meimei'}
for i in reversed(dic):
    print(i)     # TypeError: 'dict' object is not reversible

slice: 构造一个切片对象，用于列表的切片。

# 切片取值
l1 = [i for i in range(10)]
l2 = l1[:5:2]
# slice取值
l3 = [i for i in range(10,20)]
sli_obj = slice(0,5,2)
print(l3[sli_obj])   # [10, 12, 14]
# slice取值
l4 = ['a','b','c','d','e','f','g']
sli_obj = slice(0,5,2)
print(l4[sli_obj])   # ['a', 'c', 'e']

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

print(format('test','<20'))   # test                 # 总共20个字符长度，test左对齐
print(format('test','>20'))   #                 test # 总共20个字符长度，test右对齐
print(format('test','^20'))   #         test         # 总共20个字符长度，test居中

bytes: 主要是将unicode类型转化为bytes类型。

a1 = '太白'
b1 = bytes(a1,encoding='utf-8')
print(b1)  # b'xe5xa4xaaxe7x99xbd'

a1 = '太白'
print(a1.encode('utf-8'))  # b'xe5xa4xaaxe7x99xbd'
print(a1.encode('utf-8').decode())   # 太白

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

print('colin')          # colin
print(repr('colin'))    # 'colin'
print(repr("colin"))    # 'colin'
print(repr("{'colin':'haoren'}"))   # "{'colin':'haoren'}"

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

l1 = [2,3,4,5,8,1,3,4,7]
l1.sort()
print(l1)  # [1, 2, 3, 3, 4, 4, 5, 7, 8]
print(sorted(l1))  # [1, 2, 3, 3, 4, 4, 5, 7, 8]   形成了一个新列表
print(l1)          # [2, 3, 4, 5, 8, 1, 3, 4, 7]   原列表不变

l2 = [(1,1000),(2,18),(4,250),(3,500)]
print(sorted(l2))    # 默认按照第一个值排序

def func1(x):
    return x[1]
print(sorted(l2,key=func1,reverse=True))  # 通过key 自定制函数选择第二个值

zip():拉链方法 将多个iter 纵向组成一个个元组。

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

l1 = [1,2,3,5,6,7]
tu1 = ('alex','太白', 'wusir', '女神')
dic = {'name': '日天', 'age':28, 'hobby': 'tea', 'weight':100}
print(zip(l1,tu1,dic))
for i in zip(l1,tu1,dic):
    print(i)

filter: 过滤，迭代器

l1 = [i for i in range(10)]
def func1(x):
    return x % 2 == 0
print(list(filter(func1,l1)))

map:会根据提供的函数对指定序列做映射。 循环模式.

l1 = [1,2,3,4]
# print([i**2 for i in l1])
def func(x): return x**2
print(list(map(func,l1)))

匿名函数 (lambda表达式)

func2 = lambda x: x*2

def func2(x):
    return x**2

func2 = lambda x : x**2
print(func2(6))

func2 = lambda x,y: x+y
print(func2(1,2))
# 匿名函数 不单独使用，多与内置函数结合。

l2 = [(1,1000),(2,18),(4,250),(3,500)]
print(sorted(l2,key=lambda x:x[1]))

例题：

dic={'k1':10,'k2':100,'k3':30}
#1,利用内置函数匿名函数将dic按照值进行排序。
print(sorted(dic,key=lambda x:dic[x]))
#2,利用内置函数匿名函数将dic按照键值对进行排序。
print(sorted(dic.items(),key=lambda x:x[1]))
# 利用内置函数匿名函数 计算列表的每个数的2倍。
# [1,5,7,4,8]
print(list(map(lambda x:x*2,[1,5,7,4,8])))
# 利用内置函数匿名函数，将值大于10的留下来。
# [5,8,11,9,15]
print(list(filter(lambda x: x>10,[5,8,11,9,15])))