Python基础（二）——常用内置函数

1. 常用内置函数

（1）isinstance(object, classinfo)

　　用于判断一个对象是否为某一类型。

• object  是实例对象
• classinfo 是基本类型如 int, float 或者是类名或者是由它们组成的元组。

print(isinstance(1, (int, str, float))) #True。实例 + 元组
print(isinstance('', dict))    #Flase  实例 + 基本类型

（2）type()

• 　　type(Class) 输出<class 'type'>。type(实例) 输出 <class '类名'>

（3）map(function, iterable)

　　map(function, iterable) 产生一个将function应用于迭代对象中的所有元素并返回结果的迭代器。

 from collections.abc import Iterator,Iterable

 def test(x):
     return x * 2

 L = map(test, [1,2,3])

 print(L)  #<map object at 0x0000020C55F14390>
 print(isinstance(L, Iterator)) #true
 print(list(L))  #[2, 4, 6].list(iterable) list是一个构造器，其中的项与 iterable 中的项相同。

 print(list(map(str, [1,2,3,3]))) #['1', '2', '3', '3']

　　如上文所说，将 test() 函数应用于元素 1 * 2 = 2.....。其中第12行同第10行一致，注意通过list()函数将map()迭代器内容输出。

（4）reduce(function,iterable)

　　官网给了个例子：reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) 等价于 ((((1+2)+3)+4)+5) 。这里划线部分其实就是个函数，这个函数是实现 x + y，将改函数应用于右边的 iterable,但是和map的区别就是，这个reduce有一个累加效果，也就是将上一步计算的结果当作下一步计算的参数，如下：

 from functools import reduce
 def sum(x, y):
     return  x + y

 L = [1, 2, 3]
 R = reduce(sum, L)
 print(R) #

　　即第六行sum函数需要两个参数，参数从L中取为1，2。送入sum计算得到3，然后3当作x，L中的3当作y，继续送入sum函数计算，得到3 + 3 = 6

　　再看一个例子：

 # 将字符串转成数字
 from functools import reduce
 dict = {'': 0, '': 1, '': 2, '': 3, '': 4, '': 5, '': 6, '': 7, '': 8, '': 9}

 #'124' -> ((0*10+1)*10+2)*10+4
 def char2numb(c):
     return dict[c]

 def calculate(x, y):
     return x * 10 + y

  def str2numb(s):
     return reduce(calculate, list(map(char2numb, s))) #结合使用map很关键，char2numb函数应用到字符串上
 print(str2numb(''))

（5）匿名函数

　　匿名函数关键字是lambda，且函数不需要定义名称，比如：

 def cube(y):
     return y * y * y;

 g = lambda x: x * x * x # 将匿名函数赋值给一个变量g，再利用变量来调用该函数
 print(g(7))

 print(cube(5))

　　cube函数同g是相似的。lambda冒号前的是参数，可以多个，用逗号隔开，冒号右边是返回值。

　　lambda函数解和map和reduce一起使用：

 li = [5, 7, 22, 97, 54, 62, 77, 23, 73, 61]
 final_list = list(map(lambda x: x*2 , li))
 print(final_list)  #[10, 14, 44, 194, 108, 124, 154, 46, 146, 122]

 from functools import reduce
 li = [1, 2, 3]
 sum = reduce((lambda x, y: x * y), li)
 print (sum) # 6

　　（个人觉得，也不是非lambda不可，是鸡肋吗？先在这埋下伏笔）

　　lambda 在闭包中的使用，看详看第六点。

（6）闭包（点击查看）

（7）filter(function,iterable)

　　用iterable中函数function返回真的那些元素，构建一个新的迭代器。官网上有两句话：①当function为None，则item for item in iterable if item。②当function不是None，item foritem in iterable if function(item)。

 #①
 print(list(filter(None,[0, 1, 33, False, None]))) # [1, 33]

 #②
 def test(x):
     return x % 2 == 0
 print(list(filter(test, [1,2,3,4]))) # [2, 4]

 #又如
 def not_empty(s):
     return s and s.strip()
 print(list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))) # ['A', 'B', 'C']

　　通过例子很好理解，不过多解释。

　　用filter筛选素数（廖雪峰网站）：　　

 def _odd_iter():
     n = 1
     while True:
         n = n + 2
         yield n

 def _not_divisible(n):
     return lambda x: x % n > 0

 def primes():
     yield 2
     it = _odd_iter() # 初始序列
     while True:
         n = next(it) # 返回序列的第一个数
         yield n
         it = filter(_not_divisible(n), it) # 构造新序列

 # 打印1000以内的素数:
 for n in primes():
     if n < 1000:
         print(n)
     else:
         break

　　因为这段代码比较复杂，尤其是第16行，所以在上文先铺垫了①匿名函数②闭包③生成器。

（8）sorted(iterable,*,key=None,reverse=False)

　　根据iterable中的项，将项按照key（带有单个参数的函数）处理，处理之后排序。

 print(sorted([-9, 0 ,89, 22])) # [-9, 0, 22, 89]

 print(sorted([-9, 0, 22, 89], key=abs)) # [0, -9, 22, 89]

 # 忽略大小写（因为阿斯克码）按首字母排序
 print(sorted("This is a test string from Andrew".split(), key=str.lower))
 #['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']

　　list.sort()的使用如[1, 2, 3, 1].sort()。但是效率没有sorted([1, 2, 3, 1])高。另一个区别是list.sort()只为列表定义，而sorted()可以用于任何迭代对象。

 DICT = {1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}
 print(sorted(DICT, reverse=True))  # [5, 4, 3, 2, 1]

（9）enumerate(sequence, [start=0])

　　此函数将一个可遍历对象组合成索引序列。一般用在 for 循环中

 s = [4, 6, 7, 1]
 for i in s:
     print(i,end=' ')

 print('\n', '=======')

 for i in enumerate(s):
     print(i, end='') # 输出 索引+值 的结构

 print('\n', '=======')

 for b,i in enumerate(s):
     print(b,i,end='|')

 print('\n', '=======')

 for b,i in enumerate(s, 99): # 99为自定义索引开始值
     print(b,i,end='|')

　　输出结果：

 4 6 7 1
  =======
 (0, 4)(1, 6)(2, 7)(3, 1)
  =======
 0 4| 1 6| 2 7| 3 1|
  =======
 99 4| 100 6| 101 7| 102 1| 

　　

2. 补充

（1） import VS from .... import

　　看了例子就能清晰： 　　

import sys
print('命令行参数为:')
for i in sys.argv:
    print(i)
print('\n python 路径为',sys.path)

from sys import argv, path
print('命令行参数为:')
for i in  argv:
    print(i)
print('\n python 路径为', path)

（2）函数可以被安插在“任何”地方（in Python everything is an object）

　　这个怎么说呢，就是 Python 中的 function 真的无所不能，被用的神乎其神（我都被秀晕了QAQ），并不像 C/Java 中被固定的死死的，只能返回返回值被调用。至少学到现在，我发现Python中的函数不单单就是个函数，比如：

 #函数嵌套函数
 #嵌套在函数内部函数不能被外界调用，只能内部使用
 def test(x, y):
     def calculate(x):
         return x * x
     return calculate(x) + y
 print(test(2, 2)) #

 #函数可以元组中的一项
 L = [test,  ''] #[<function test at 0x000001F196848A60>,  '11']
 print(L)
 print(L[0](2, 2)) #
 #最后一句就是取L的第一项[0],因为是test所以传入参数(2,2)

 #函数可以赋值给变量
 g = test
 print(g(2, 2)) # 6. g 现在也就是test()复制品

 #函数当作参数传入函数如上文map

 #  函数可以当返回值
 def test():
     def test2():
         print('')
     return test2  #注意不是写成 test2().加了括号就是调用test2()，然后此句return回test2()给的return了。可看后面的例子
 g = test()
 print(g)  # <function test.<locals>.test2 at 0x000002721DDB8AE8>

 #例子
 # def test():
 #     def test2():
 #         print('1111')  # 1111
 #     return test2()
 # print(test()) # None

以后遇到不断补充......