python学习——内置函数

Posted 2021-01-20 lcs-llh

　　　　在之前的博客中，我们已经知道函数的相关问题，本次随笔将对python的内置函数进行整理，首先来看下面这张图片。??

一、内置函数

　　接下来，我们就一起来看看python里的内置函数。截止到python版本3.7.0，现在python一共为我们提供了68个内置函数。它们就是python提供给你直接可以拿来使用的所有函数。这些函数有些我们已经用过了，有些我们还没用到过。那今天我们就一起来认识一下python的内置函数。这么多函数，我们该从何学起呢？上面就是内置函数的表，68个函数都在这儿了。这个表的顺序是按照首字母的排列顺序来的，你会发现都混乱的堆在一起。比如，oct和bin和hex都是做进制换算的，但是却被写在了三个地方。。。这样非常不利于大家归纳和学习。那我把这些函数分成了6大类。你看下面这张图 。有关面向对象的函数有13个，在以后再加进来??

二、作用域相关

locals和globals这两个函数都是基于字典来查看函数的相关变量的。globals()——获取全局变量的字典。locals()——获取执行本方法所在命名空间内的局部变量的字典??

 1 a = 1
 2 def func():
 3     b = 2
 4     print(‘in func now‘)
 5     def inner():
 6         c = 3
 7         print(a,b)
 8         def qqxing():
 9             print(a,b,c)
10             print(globals())
11             print(locals())
12         qqxing()
13     inner()
14 
15 func()
16 print(globals())
17 print(locals())
18 
19 #输出：
20 in func now
21 1 2
22 1 2 3
23 {‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘__package__‘: None, ‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x00000287C98F60B8>, ‘__spec__‘: None, ‘__annotations__‘: {}, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__file__‘: ‘D:/Python文件/python学习/re模块.py‘, ‘__cached__‘: None, ‘a‘: 1, ‘func‘: <function func at 0x00000287C9BD3378>}
24 {‘b‘: 2, ‘c‘: 3}
25 {‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘__package__‘: None, ‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x00000287C98F60B8>, ‘__spec__‘: None, ‘__annotations__‘: {}, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__file__‘: ‘D:/Python文件/python学习/re模块.py‘, ‘__cached__‘: None, ‘a‘: 1, ‘func‘: <function func at 0x00000287C9BD3378>}
26 {‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘__package__‘: None, ‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x00000287C98F60B8>, ‘__spec__‘: None, ‘__annotations__‘: {}, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__file__‘: ‘D:/Python文件/python学习/re模块.py‘, ‘__cached__‘: None, ‘a‘: 1, ‘func‘: <function func at 0x00000287C9BD3378>}

globals()和locals()方法

　　所以globals()和locals()这两个函数就是查看函数中的所有全局变量和局部变量的。需要注意的是当在全局打印globals()和locals()时你会发现输出的字典是一摸一样的。

三、其他

　　1.字符串类型的相关函数

 1 # 1 eval()
 2 print(eval(‘1+2+3+4+5‘))
 3 
 4 #输出：15
 5 # 2 exec()
 6 print(exec("1+2+3+4+5"))
 7 exec("print(‘hello python‘)")
 8 
 9 #输出：
10 None
11 hello python
12 
13 code = ‘‘‘
14 import os 
15 print(os.path.abspath(‘.‘))
16 ‘‘‘
17 code = ‘‘‘
18 print(123)
19 a = 20
20 print(a)
21 ‘‘‘
22 a = 10
23 exec(code,{‘print‘:print},)
24 print(a)
25 
26 #输出：
27 123
28 20
29 10

　　compile()  将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。

　　参数说明：　　　

　　　　1. 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。　　

　　　　2. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。　　

　　　　3. 参数model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为‘single‘。

 1 # 流程语句使用exec
 2 code1 = ‘for i in range(3): print (i)‘
 3 compile1 = compile(code1,‘‘,‘exec‘)
 4 exec(compile1)
 5 #输出：
 6 0
 7 1
 8 2
 9 
10 # 简单求值表达式用eval
11 code2 = ‘1 + 2 + 3 + 4‘
12 compile2 = compile(code2,‘‘,‘eval‘)
13 print(eval(compile2))
14 #输出： 10
15 
16 # 交互语句用single
17 code3 = ‘name = input("please input your name:")‘
18 compile3 = compile(code3,‘‘,‘single‘)
19 print(compile3)
20 #输出： <code object <module> at 0x0000025D0CA58F60, file "", line 1>
21 
22 print(exec(compile3)) #执行时显示交互命令，提示输入
23 print(name)
24 
25 #输出：
26 None
27 python

compile()和eval()和exec()

　　2.输入输出相关

　　　　input()

1 s = input("请输入内容 ： ")  #输入的内容赋值给s变量
2 print(s)  #输入什么打印什么。数据类型是str

　　　　print()

 1 def print(self, *args, sep=‘ ‘, end=‘
‘, file=None): # known special case of print
 2     """
 3     print(value, ..., sep=‘ ‘, end=‘
‘, file=sys.stdout, flush=False)
 4     file:  默认是输出到屏幕，如果设置为文件句柄，输出到文件
 5     sep:   打印多个值之间的分隔符，默认为空格
 6     end:   每一次打印的结尾，默认为换行符
 7     flush: 立即把内容输出到流文件，不作缓存
 8     """
 9 f = open(‘filename‘,‘w‘)
10 print(123,456,sep=‘,‘,file = f,flush=True)

　　　　打印进度条

1 import time
2 for i in range(0,101,2):
3      time.sleep(0.1)
4      char_num = i//2      #打印多少个‘*‘
5      per_str = ‘
%s%% : %s
‘ % (i, ‘*‘ * char_num) if i == 100 else ‘
%s%% : %s‘%(i,‘*‘*char_num)
6      print(per_str,end=‘‘, flush=True)
7 # 
可以把光标移动到行首但不换行

打印进度条

　　3.数据类型相关

　　　　type()

 1 a = 1
 2 type(a)
 3 Out[3]: int
 4 b = ‘python‘
 5 type(b)
 6 Out[5]: str
 7 c = [1,2,3]
 8 type(c)
 9 Out[7]: list
10 d = {1,2,5,3}
11 type(d)
12 Out[9]: set
13 e = (‘a‘,‘b‘,‘c‘)
14 type(e)
15 Out[11]: tuple

　　　　type()是判断某个变量是什么数据类型的函数

　　4.内存相关

　　　　id(o) o是参数，返回一个变量的内存地址

　　　　hash(o) o是参数，返回一个可hash变量的哈希值，不可hash的变量被hash之后会报错。

 1 t = (1,2,3)
 2 l = [1,2,3]
 3 print(hash(t))  #可hash
 4 print(hash(l))  #会报错
 5 
 6 ‘‘‘
 7 结果：
 8 2528502973977326415
 9 TypeError: unhashable type: ‘list‘
10 ‘‘‘

hash()

　　hash函数会根据一个内部的算法对当前可hash变量进行处理，返回一个int数字。每一次执行程序，内容相同的变量hash值在这一次执行过程中不会发生改变。

　　5.文件操作相关

　　　　open()  打开一个文件，返回一个文件操作符(文件句柄)，操作文件的模式有r,w,a,r+,w+,a+ 共6种，每一种方式都可以用二进制的形式操作(rb,wb,ab,rb+,wb+,ab+)，可以用encoding指定编码.

　　6.模块导入__import__

1 import time
2 from time import time.localtime,sleep
3 
4 os = __import__(‘os‘)
5 print(os.path.abspath(‘.‘))

__import__和import

　　7.帮助函数help()

　　在控制台执行help()进入帮助模式。可以随意输入变量或者变量的类型。输入q退出，或者直接执行help(o)，o是参数，查看和变量o有关的操作。。。

　　8.调用相关函数callable()

　　　　callable(o)，o是参数，看这个变量是不是可调用。如果o是一个函数名，就会返回True

1 def func():
2     pass
3 print(callable(func))  #参数是函数名，可调用，返回True
4 print(callable(123))   #参数是数字，不可调用，返回False

callable()

　　9.查看参数所有所属类型的内置函数dir()

　　　　dir() 默认查看全局空间内的属性，也接受一个参数，查看这个参数内的方法或变量

1 print(dir(list))  #查看列表的内置方法
2 print(dir(int))  #查看整数的内置方法

四.和数字相关

　　数字——数据类型相关：bool，int，float，complex

 1 a = 1
 2 b = 1.0
 3 print(bool(a))     #输出：True(返回某个变量的布尔值)
 4 print(int(b))      #输出：1(把某个数据类型转换成整型数字)
 5 print(float(a))    #输出：1.0 (把某个数据类型转换成浮点型数字)
 6 a = 3
 7 b = 4
 8 c = complex(a,b)
 9 print(c)                    #输出：(3+4j) c是一个复数，其中a是复数的实部，b是复数的虚部
10 print(c.real,c.imag)        #输出：3.0 4.0 注意：在解释器中复数的实部和虚部都是浮点数类型
11 print(c.conjugate())        #输出：(3-4j) 返回复数的共轭复数（共轭复数：实部相等，虚部互为相反数）

　　数字——进制转换相关：bin，oct，hex

1 a = 1
2 print(bin(a))
3 print(oct(a))
4 print(hex(a))
5 # 输出：
6 0b1
7 0o1
8 0x1

　　数字——数学运算：abs，divmod，min，max，sum，round，pow

 1 a = -3
 2 print(abs(a))               # 输出: 3         (返回某个数的绝对值)
 3 print(divmod(67,13))        # 输出: (5,2)     (返回(除,余) 注意:主要用于抽屉)
 4 lst = [1,2,3,4,5,6]         
 5 print(min(lst))             # 输出: 1         (返回最小值)
 6 print(max(lst))             # 输出: 6         (返回最大值)
 7 print(sum(lst))             # 输出: 21        (求和)
 8 b = 3.1415926               
 9 print(round(b,4))           # 输出: 3.1416    (保留几位有效数字(四舍五入))
10 print(pow(2,3))             # 输出: 8         (2**3)

 

五、和数据结构相关

　　序列——列表和元组相关的：list和tuple

　　　　列表和元组请看python学习——基本数据类型

　　序列——字符串相关的：str，format，bytes，bytearry，memoryview，ord，chr，ascii，repr

a = 1
print(str(a))       # 把某个数据变成字符串
print(bytes(5))     # 把某个数据变成字节码
print(ord(‘a‘))     # 返回对应的ASCII码
print(chr(97))      # 返回ASCII码对应的符号

　　format()

　　1. 函数功能将一个数值进行格式化显示。

　　2. 如果参数format_spec未提供，则和调用str(value)效果相同，转换成字符串格式化。

1 >>> format(3.1415936)
2 ‘3.1415936‘
3 >>> str(3.1415926)
4 ‘3.1415926‘

　　3. 对于不同的类型，参数format_spec可提供的值都不一样

 1 #字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
 2 print(format(‘test‘, ‘<20‘))
 3 print(format(‘test‘, ‘>20‘))
 4 print(format(‘test‘, ‘^20‘))
 5 
 6 #整形数值可以提供的参数有 ‘b‘ ‘c‘ ‘d‘ ‘o‘ ‘x‘ ‘X‘ ‘n‘ None
 7 >>> format(3,‘b‘) #转换成二进制
 8 ‘11‘
 9 >>> format(97,‘c‘) #转换unicode成字符
10 ‘a‘
11 >>> format(11,‘d‘) #转换成10进制
12 ‘11‘
13 >>> format(11,‘o‘) #转换成8进制
14 ‘13‘
15 >>> format(11,‘x‘) #转换成16进制 小写字母表示
16 ‘b‘
17 >>> format(11,‘X‘) #转换成16进制 大写字母表示
18 ‘B‘
19 >>> format(11,‘n‘) #和d一样
20 ‘11‘
21 >>> format(11) #默认和d一样
22 ‘11‘
23 
24 #浮点数可以提供的参数有 ‘e‘ ‘E‘ ‘f‘ ‘F‘ ‘g‘ ‘G‘ ‘n‘ ‘%‘ None
25 >>> format(314159267,‘e‘) #科学计数法，默认保留6位小数
26 ‘3.141593e+08‘
27 >>> format(314159267,‘0.2e‘) #科学计数法，指定保留2位小数
28 ‘3.14e+08‘
29 >>> format(314159267,‘0.2E‘) #科学计数法，指定保留2位小数，采用大写E表示
30 ‘3.14E+08‘
31 >>> format(314159267,‘f‘) #小数点计数法，默认保留6位小数
32 ‘314159267.000000‘
33 >>> format(3.14159267000,‘f‘) #小数点计数法，默认保留6位小数
34 ‘3.141593‘
35 >>> format(3.14159267000,‘0.8f‘) #小数点计数法，指定保留8位小数
36 ‘3.14159267‘
37 >>> format(3.14159267000,‘0.10f‘) #小数点计数法，指定保留10位小数
38 ‘3.1415926700‘
39 >>> format(3.14e+1000000,‘F‘)  #小数点计数法，无穷大转换成大小字母
40 ‘INF‘
41 
42 #g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数
43 >>> format(0.00003141566,‘.1g‘) #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点
44 ‘3e-05‘
45 >>> format(0.00003141566,‘.2g‘) #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点
46 ‘3.1e-05‘
47 >>> format(0.00003141566,‘.3g‘) #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点
48 ‘3.14e-05‘
49 >>> format(0.00003141566,‘.3G‘) #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写
50 ‘3.14E-05‘
51 >>> format(3.1415926777,‘.1g‘) #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点
52 ‘3‘
53 >>> format(3.1415926777,‘.2g‘) #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点
54 ‘3.1‘
55 >>> format(3.1415926777,‘.3g‘) #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点
56 ‘3.14‘
57 >>> format(0.00003141566,‘.1n‘) #和g相同
58 ‘3e-05‘
59 >>> format(0.00003141566,‘.3n‘) #和g相同
60 ‘3.14e-05‘
61 >>> format(0.00003141566) #和g相同
62 ‘3.141566e-05‘

 1 ret = bytearray(‘刘龙海‘,encoding=‘utf-8‘)
 2 print(id(ret))
 3 print(ret[0])
 4 ret[0] = 65
 5 print(ret)
 6 print(id(ret))
 7 
 8 ret = memoryview(bytes(‘刘龙海‘,encoding=‘utf-8‘))
 9 print(len(ret))
10 print(bytes(ret[:3]).decode(‘utf-8‘))
11 print(bytes(ret[3:]).decode(‘utf-8‘))
12 
13 # 输出：
14 2378379708768
15 229
16 bytearray(b‘Ax88x98xe9xbex99xe6xb5xb7‘)
17 2378379708768
18 9
19 刘
20 龙海

bytearry和memoryview

　　序列：reversed，slice

1 l = (1,2,23,213,5612,342,43)
2 print(l)
3 print(list(reversed(l)))  #逆序
4 sli = slice(1,5,2)          #切片
5 print(l[sli])    

reversed和slice

　　数据集合：字典（dict）集合（set，frozenset）其他（len，sorted，enumerate，all，any，zip，filter，map）

　　len():返回某个对象的长度

　　sorted：对列表进行排序，返回新列表

　　enumerate：枚举

　　all和any：只有全为真时all才返回True，而any则只要其中一个为真则返回True

　　zip：可以对多个对象通过拉链的方式连接起来，注意：若多个对象不一样，则选择最少的那个来连接

　　而 min() max() filter() map() reduce() sorted()请看匿名函数的内容。

 

六、匿名函数

　　匿名函数：为了解决那些功能很简单的需求而设计的一句话函数 ??

1 #这段代码
2 def calc(n):
3     return n**n
4 print(calc(10))
5  
6 #换成匿名函数
7 calc = lambda n:n**n
8 print(calc(10))

上面是我们对calc这个匿名函数的分析，下面给出了一个关于匿名函数格式的说明 ??

1 函数名 = lambda 参数 ：返回值
2 
3 #参数可以有多个，用逗号隔开
4 #匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
5 #返回值和正常的函数一样可以是任意数据类型

　　我们可以看出，匿名函数并不是真的不能有名字。匿名函数的调用和正常的调用也没有什么分别。 就是 函数名(参数) 就可以了～～～

　　上面是匿名函数的函数用法。除此之外，匿名函数也不是浪得虚名，它真的可以匿名。在和其他功能函数合作的时候

l = [-100000, 3, 2, 100, 999, 213, 1111, 31121, 333]
print(max(l,key=lambda x:abs(x))) # 输出 -100000（关键字以绝对值进行求最大值）
print(min(l,key=lambda x:abs(x)))     # 输出：2  （关键字以绝对值进行求最大值）

dic={‘k1‘: 10, ‘k2‘: 100, ‘k3‘: 30}

print(max(dic))                               # 输出：k3   （默认对‘键’求最大值）
print(dic[max(dic,key=lambda k:dic[k])])     # 输出：100   （对字典的‘值’求最大值）
print(dic[min(dic,key=lambda k:dic[k])])     # 输出：10   （对字典的‘值’求最小值）

min()和max()

1 lst = [1,2,3,4,5,6]
2 print(list(map(lambda i:i*i,lst)))
3 
4 # 输出：
5 [1, 4, 9, 16, 25, 36]

1 lst = [1,-2,3,-4,5,-6]
2 print(list(filter(lambda x:x>0,lst)))
3 print(list(filter(lambda x:x<0,lst)))
4 
5 # 输出：
6 [1, 3, 5]
7 [-2, -4, -6]

 1 from random import randint
 2 from functools import reduce
 3 
 4 lst = [randint(20,50) for i in range(20)]
 5 print(lst)
 6 print(reduce(lambda x,y:x+y,lst))
 7 
 8 # 输出：
 9 [20, 35, 31, 50, 47, 26, 21, 26, 26, 50, 38, 38, 20, 37, 32, 43, 46, 43, 26, 27]
10 682

 1 from random import randint
 2 
 3 lst1 = [randint(-10,10) for i in range(20)]
 4 print(lst1)
 5 lst1.sort(reverse=True)
 6 print(lst1)
 7 lst2 = sorted(lst1,key=lambda x:abs(x),reverse=True)
 8 print(lst2)
 9 print(lst1)
10 
11 # 输出：
12 [-8, -3, 8, 7, -4, -6, -8, -1, 1, -8, -4, 8, 5, -10, -6, 10, 7, 8, 1, 3]
13 [10, 8, 8, 8, 7, 7, 5, 3, 1, 1, -1, -3, -4, -4, -6, -6, -8, -8, -8, -10]
14 [10, -10, 8, 8, 8, -8, -8, -8, 7, 7, -6, -6, 5, -4, -4, 3, -3, 1, 1, -1]
15 [10, 8, 8, 8, 7, 7, 5, 3, 1, 1, -1, -3, -4, -4, -6, -6, -8, -8, -8, -10]

sort()和sorted()的区别

　　sort是原地排序，会改变原来的列表，而sorted不会改变原来的列表，返回一个新列表。ok