十个你必须知道的Python内置函数

lsekfe

自从把精力投入到次幂数据(www.cimidata.com) 这个产品后，貌似很久很久没有写过原创文章了，人一旦懒起来也会形成习惯，反之亦然。一个目标之所以难以坚持，很大可能是太大了。
　　在我们的一个跑步群里，每周5公里这件事，我们已经坚持了100天。如果欢成每天5公里，我相信你很快会放弃的。而每周5公里，7天内任意一天完成就算达成目标，所以一直坚持着，甚至还能超额完成。
　　1. reduce()
　　reduce() 是 functools 模块下面的一个函数，接收两个参数，一个是函数对象，一个是可迭代对象（比如list）， reduce每次会把迭代对象中的下一个元素作用在函数上做累积计算，最后得到一个值。
　　来看个例子你就明白：

1. # 创建函数  
   
2. 　　def add(a, b):  
   
3. 　　    result = a + b  
   
4. 　　    print(f"{a} + {b} = {result}")  
   
5. 　　    return result  
   
6. 　　from functools import reduce  
   
7. 　　result = reduce(add, [1, 2, 3, 4])  
   
8. 　　print("结果：", result)

复制代码

输出

1. 1 + 2 = 3  
   
2. 　　3 + 3 = 6  
   
3. 　　6 + 4 = 10  
   
4. 　　结果： 10

复制代码

　执行过程：第一次将列表中的前两个数取出来作为函数add的参数，第二次将上一次函数add的返回值与列表的第3个数作为参数，依此类推，最后得到一个值。这就是reduce的作用。有点像万物归一的感觉。
　　当然，如果只是计算列表中的元素之和，大可不必绕这么大弯子用reduce来处理，直接用 sum 函数就可以解决。

1. result = sum([1, 2, 3, 4])

复制代码

如果是计算列表中元素的乘积，python并没有内置的函数直接计算，这时候我们可以借用reduce来处理。

1. 　def mul(a, b):  
   
2. 　　    return a * b  
   
3. 　　result = reduce(mul, [1, 2, 3, 4])  
   
4. 　　print("结果：", result)

复制代码

输出

1. 结果： 24

复制代码

或者使用 lambda 匿名函数：

1. 　result = reduce(lambda a, b: a * b, [1, 2, 3, 4])

复制代码

　甚至可以直接使用operator模块下的乘法操作符函数。

1. from operator import mul  
   
2. 　　result = reduce(mul, [1, 2, 3, 4])
   
3. 　　print("结果：", result)

复制代码

　最后你会发现解法其实很多种，不过我们应该记住python之禅里面那句话：
　　There should be one-- and preferably only one --obvious way to do it.
　　用最合适的方式去做一件事
　　2. split()
　　split 接收一个参数，用于将字符串切割成列表，比如一段英文字符串按照空格切割就可以统计出单词的个数。

1. words = "python is the best programming language"  
   
2. 　　wordswords = words.split(" ")  
   
3. 　　print(words)

复制代码

输出：

1. 　['column1', 'column2', 'column3']

复制代码

3. enumerate()
　　enumerate 函数用于迭代列表等可迭代对象，它的使用场景一般出现在你需要获取列表的下标位置时，我们知道直接用for循环去迭代列表时，是拿不到元素下标位置的，而 enumerate 就可以获取，否则你还得自己去定义一个索引变量。

1. words = ['python', 'is', 'the', 'best', 'programming', 'language']  
   
2. 　　index = 0  
   
3. 　　for w in words:  
   
4. 　　    print(index, w)  
   
5. 　　    index += 1  
   
6. 　　0 python  
   
7. 　　1 is  
   
8. 　　2 the  
   
9. 　　3 best  
   
10. 　　4 programming  
    
11. 　　5 language

复制代码

使用 enumerate 函数，处理起来就更优雅了。

1. for index, w in enumerate(words):  
   
2. 　　    print(index, w)  
   
3. 　　0 python  
   
4. 　　1 is  
   
5. 　　2 the  
   
6. 　　3 best  
   
7. 　　4 programming  
   
8. 　　5 language  

复制代码

　4. map()
　　map是一个与reduce函数对应的函数，Google的map/reduce框架的思想其实就是从这两个函数借鉴而来的。map函数用于把一个列表通过函数处理，映射成一个新的列表。例如给列表的每个元素做平方，将列表元素转换成字符串，得到一个新的列表。

1. 　result = map(lambda x: str(x), [1, 2, 3, 4])  
   
2. 　　print(list(result))  
   
3. 　　result = map(lambda x: x * x, [1, 2, 3, 4]))  
   
4. 　　print(list(result))

复制代码

　输出：

1. ['1', '2', '3', '4']  
   
2. 　　[1, 4, 9, 16]

复制代码

此外，map 函数还可以接受多个列表参数，使得多个列表合并为一个列表成为可能，例如，将两个列表相同位置的元素相加得到一个新的列表

1. 　def merge(x, y):  
   
2. 　　    return x + y  
   
3. 　　result = map(merge, [1, 2, 3], [3, 2, 1])  
   
4. 　　print(list(result))

复制代码

输出：

1. 　[4, 4, 4]

复制代码

5. getattr()
　　getattr() 返回对象属性对应的值，接受两个参数，第一个是对象，第二个是属性名，这个函数通常用户动态或者某个对象下面的某些属性的值，看例子：

1. class Foo:  
   
2. 　　    def __init__(self):  
   
3. 　　        self.a = 10  
   
4. 　　foo = Foo()  
   
5. 　　a = getattr(foo, "a")  
   
6. 　　print(a)

复制代码

输出：

1. 10

复制代码

你可能会问，我直接 foo.a 不就可以获取a属性的值了吗？正常情况是这样没错，如果是你在不知道什么情况下要获取什么属性的值时，这时候getattr就可以派上用场了。初学者可能还体验不到，当你尝试去写些框架级的代码时，你要想起来有这样的函数可以使用就行。
　　6. slice
　　slice 是一个切片函数，切片操作你可能使用过，通过切片来获取列表的子集， 例如：

1. 　s = [1,2,3,4]
   
2. 　　
   
3. 　　>>> s[1:3]  # 获取列表s中第1到第3之间的元素组成的子列表

复制代码

"1:3" 其就是 就是 slice(1:3) 函数的缩写方式，前者就像是语法糖。

1. s = [1, 2, 3, 4]  
   
2. 　　print(s[slice(1, 3)])

复制代码

通常实际应用过程中，直接用语法糖的写法就可以，没必要用slice函数进行切片，但是你至少应该知道slice是怎么用的。
　　7. sorted()
　　sorted 函数应该日常代码中，算是一个高频函数了，用于将列表等可迭代对象进行排序，它不会改变原列表的顺序，而是返回一个新的列表。默认按照升序排列

1. nums = [4, 5, 6, 3, 1]  
   
2. 　　print(sorted(nums))

复制代码

输出：

1. 　　[1, 3, 4, 5, 6]

复制代码

如果想要降序排列，则需要指定第二个参数：reverse=True

1. nums = [4, 5, 6, 3, 1]  
   
2. 　　print(sorted(nums, reverse=True))  # [6, 5, 4, 3, 1]

复制代码

sorted 函数的强大之处远不止如此，因为你还可以自定义排序规则，比如参与比较是一个自定义的类Student， 我需要按照Student里面的年龄age进行排序，这时候我们需要自定义排序因子函数。

1. 　def my_sort_key(s):  
   
2. 　　    return s.age  
   
3. 　　class Student:  
   
4. 　　    def __init__(self, age):  
   
5. 　　        self.age = age  
   
6. 　　    def __str__(self):
   
7. 　　        return f"Student({self.age})"  
   
8. 　　s1 = Student(12)  
   
9. 　　s2 = Student(2)  
   
10. 　　s3 = Student(30)  
    
11. 　　new_list = (sorted([s1, s2, s3], key=my_sort_key))  
    
12. 　　for i in new_list:  
    
13. 　　    print(i)

复制代码

输出：
　　Student(2)  
　　Student(12)  
　　Student(30)


　　8. format
　　format 函数曾经字符串格式化最常用的函数，使用也是非常简单，但自从f字符串出现之后，format 的功能逐渐被取代，但是3.6之前还是可以常见到该函数的应用场景。
　　s = "{} is first name"  
　　print(s.format("liu"))


　　如果需要占位符比较多搞不清次序的话，可以给每个占位符一个名字，这样就不拍对不上位置了。
　　s = "{first_name} is first name"  
　　print(s.format(first_name="liu"))


　　9. join()
　　join 也是比较常用的一个内置函数，它可以将列表对象用指定的字符作为元素之间的连接，转换为字符串。
　　words = ['python', 'is', 'the', 'best', 'programming', 'language']  
　　print(" ".join(words)) # 用空格连接 python is the best programming language


　　10. type
　　type 我认为是python最难理解的一个内置函数了，新手可能以为type就是一个用来查看某个对象的类型是什么，例如：
　　print(type(10)) # <class 'int'>  
　　print(type([])) # <class 'list'>  
　　print(type("s"))#  <class 'str'>


　　它的另一个作用是可以用type来创建类，一般情况下，我们都用关键字 class 来定义一个类，而type也可以用来创建类。
　　>>> Person = type("Person", (), {"live":True})  
　　>>> Person  
　　<class '__main__.Person'>


　　第一个参数 Person是类的名字， 第二个参数用来指定父类是谁， 第三个参数是这个类的类属性有哪些。上面这段代码等价于：
　　>>> class Person:  
　　...     live = True  
　　...  
　　>>> Person  
　　<class '__main__.Person'>


　　创建Person这类的type函数其实是一个叫“元类”的东西。而关于元类甚至可以话一整篇文章来讲解了，好在我在之前的文章中有介绍过，感兴趣的可以查看一下之前写的一篇叫什么是 Python 元类这篇文章。元类在写一些框架时用的较多，比如你去按sqlalchemy的源码的时候，你会发现有大量使用元类的场景。

可乐2008

微习惯的力量，每天一个微小行为，生成巨大的力量.