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

╰半橙微兮° 2021-10-29 08:52 437阅读 0赞

# 1. 常用内置函数 #

## （1）isinstance(object, classinfo) ##

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

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

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

## （2）type() ##

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

## （3）map(function, iterable) ##

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

1 from collections.abc import Iterator,Iterable
     2 
     3 def test(x):
     4     return x * 2
     5 
     6 L = map(test, [1,2,3])
     7 
     8 print(L)  #<map object at 0x0000020C55F14390>
     9 print(isinstance(L, Iterator)) #true
    10 print(list(L))  #[2, 4, 6].list(iterable) list是一个构造器，其中的项与 iterable 中的项相同。
    11 
    12 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有一个累加效果，也就是将上一步计算的结果当作下一步计算的参数，如下：

1 from functools import reduce
    2 def sum(x, y):
    3     return  x + y
    4 
    5 L = [1, 2, 3]
    6 R = reduce(sum, L)
    7 print(R) # 6

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

再看一个例子：

1 # 将字符串转成数字
     2 from functools import reduce
     3 dict = {
        '0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
     4 
     5 #'124' -> ((0*10+1)*10+2)*10+4
     6 def char2numb(c):
     7     return dict[c]
     8 
     9 def calculate(x, y):
    10     return x * 10 + y
    11 
    12 13 def str2numb(s):
    14     return reduce(calculate, list(map(char2numb, s))) #结合使用map很关键，char2numb函数应用到字符串上
    15 print(str2numb('2323'))

## （5）匿名函数 ##

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

1 def cube(y):
    2     return y * y * y;
    3 
    4 
    5 g = lambda x: x * x * x # 将匿名函数赋值给一个变量g，再利用变量来调用该函数
    6 print(g(7))
    7 
    8 print(cube(5))

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

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

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

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

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

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

## （6）[闭包（点击查看）][Link 1] ##

## （7）filter(function,iterable) ##

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

1 #①
     2 print(list(filter(None,[0, 1, 33, False, None]))) # [1, 33]
     3 
     4 #②
     5 def test(x):
     6     return x % 2 == 0
     7 print(list(filter(test, [1,2,3,4]))) # [2, 4]
     8 
     9 #又如
    10 def not_empty(s):
    11     return s and s.strip()
    12 print(list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))) # ['A', 'B', 'C']

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

用filter筛选素数（[廖雪峰网站][Link 2]）：

1 def _odd_iter():
     2     n = 1
     3     while True:
     4         n = n + 2
     5         yield n
     6 
     7 def _not_divisible(n):
     8     return lambda x: x % n > 0
     9 
    10 def primes():
    11     yield 2
    12     it = _odd_iter() # 初始序列
    13     while True:
    14         n = next(it) # 返回序列的第一个数
    15         yield n
    16         it = filter(_not_divisible(n), it) # 构造新序列
    17 
    18 # 打印1000以内的素数:
    19 for n in primes():
    20     if n < 1000:
    21         print(n)
    22     else:
    23         break

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

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

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

1 print(sorted([-9, 0 ,89, 22])) # [-9, 0, 22, 89]
    2 
    3 print(sorted([-9, 0, 22, 89], key=abs)) # [0, -9, 22, 89]
    4 
    5 # 忽略大小写（因为阿斯克码）按首字母排序
    6 print(sorted("This is a test string from Andrew".split(), key=str.lower))
    7 #['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']

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

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

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

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

1 s = [4, 6, 7, 1]
     2 for i in s:
     3     print(i,end=' ')
     4 
     5 print('\n', '=======')
     6 
     7 for i in enumerate(s):
     8     print(i, end='') # 输出 索引+值 的结构
     9 
    10 print('\n', '=======')
    11 
    12 for b,i in enumerate(s):
    13     print(b,i,end='|')
    14 
    15 print('\n', '=======')
    16 
    17 for b,i in enumerate(s, 99): # 99为自定义索引开始值
    18     print(b,i,end='|')

输出结果：

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

# 2. 补充 #

## （1） import **VS** from .... import ##

[看了例子就能清晰][Link 4]：

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中的函数不单单就是个函数，比如：

1 #函数嵌套函数
     2 #嵌套在函数内部函数不能被外界调用，只能内部使用
     3 def test(x, y):
     4     def calculate(x):
     5         return x * x
     6     return calculate(x) + y
     7 print(test(2, 2)) # 6
     8 
     9 
    10 #函数可以元组中的一项
    11 L = [test,  '11'] #[<function test at 0x000001F196848A60>,  '11']
    12 print(L)
    13 print(L[0](2, 2)) # 6
    14 #最后一句就是取L的第一项[0],因为是test所以传入参数(2,2)
    15 
    16 
    17 #函数可以赋值给变量
    18 g = test
    19 print(g(2, 2)) # 6. g 现在也就是test()复制品
    20 
    21 #函数当作参数传入函数如上文map

1 #  函数可以当返回值
     2 def test():
     3     def test2():
     4         print('1111')
     5     return test2  #注意不是写成 test2().加了括号就是调用test2()，然后此句return回test2()给的return了。可看后面的例子
     6 g = test()
     7 print(g)  # <function test.<locals>.test2 at 0x000002721DDB8AE8>
     8 
     9 
    10 #例子
    11 # def test():
    12 #     def test2():
    13 #         print('1111')  # 1111
    14 #     return test2()
    15 # print(test()) # None

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

转载于:https://www.cnblogs.com/KongHuZi/p/10873927.html

[Link 1]: https://www.cnblogs.com/KongHuZi/p/10889437.html%20
[Link 2]: https://www.liaoxuefeng.com/wiki/1016959663602400/1017404530360000
[Link 3]: https://www.cnblogs.com/KongHuZi/p/10878145.html
[Link 4]: https://www.runoob.com/python3/python3-basic-syntax.html