常用内置方法
在Python中有许许多多的内置方法,就是一些Python内置的函数,它们是我们日常中经常可以使用的到的一些基础的工具,可以方便我们的工作。
查看所有的内置类和内置方法
1
2
3
4
5
6
|
# 方法一 built_list = dir (__builtins__) # 方法二 import builtins built_list = dir (builtins) |
其中,以Error
或者Warning
等是Python中的异常类(关于异常可以参考后面的异常学习),以__
开头和结尾的是内置的一些魔术方法(关于魔术方法可以参考面向对象的学习)、剩余的就是一些常用的内置类和方法。
标准输入输出
print -- 打印内容(标准输出)
打印(输出)指定的内容,可以打印多内容(多个参数)
语法:print(*args)
参数 | 说明 |
---|---|
*args | 输出的内容,数量任意,任何内容都可以; |
sep | 指定输出内容之间的间隔符,必须是字符串,默认为一个空格; |
end | 最后追加的内容,使用print之后最后追加的内容,必须是字符串,默认是一个换行符 \n; |
file | 将输出的内容写入指定的文件对象中。 |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
# 常规用法 print ( 1 ) # 1 print ( 1 , 2 , 3 ) # 1 2 3 # sep参数 print ( 1 , 2 , 3 ) # 1 2 3 print ( 1 , 2 , 3 , sep = ' MSR ' ) # 1 MSR 2 MSR 3 # end参数 print ( 1 , 2 ) print ( 3 , 4 ) ''' 1 2 3 4 ''' print ( 1 , 2 , end = '') print ( 3 , 4 ) ''' 1 23 4 ''' # file参数 fp = open ( 'test.txt' , 'w' , encoding = 'UTF-8' ) print ( 'Hello Word.' , file = fp) |
input -- 输入
返回输入的结果,返回的结果为字符串类型;输入时,接收到enter(回车)时将输入内容返回;
1
2
3
4
5
|
input_content = input () # 输入 -- Hello MSR. print (input_content) # Hello MSR. # 可以在input中输入内容,作为交互信息(就是一个标准输出) input ( '请输入你的银行卡密码:' ) |
数学
abs -- 绝对值
返回数字的绝对值,唯一参数必须说是数字类型,即:int float bool complex
1
2
3
4
5
|
res = abs ( - 100 ) print (res) # 100 res = abs ( True ) print (res) # 1 |
round -- 四舍五入
返回一个十进制数字四舍五入后的结果
参数 | 说明 |
---|---|
number | 四舍五入的数字 |
ndigits | 保留的小数位数,默认为None,即不保留小数 |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
# 不保留小数 res = round ( 10.6 ) print (res) # 11 # 保留小数,保留的最小位四舍五入 res = round ( 10.567 , 2 ) print (res) # 10.57 # !!! # 如果数字为n.5的时候,n为奇数才会5入,否则后面还要更多的小数位才能是我们理解当中的样子,也就是必须实际的大于.5这个临界值,可以使用标准库decimal处理掉这个问题。 res = round ( 4.5 ) print (res) # 4 res = round ( 3.5 ) print (res) # 4 res = round ( 4.51 ) print (res) # 5 res = round ( 3.51 ) print (res) # 4 # 多位小数情况正好相反,只有偶数才会5入 res = round ( 4.35 , 1 ) print (res) # 4.3 res = round ( 4.45 , 1 ) print (res) # 4.5 res = round ( 4.555 , 2 ) print (res) # 4.55 res = round ( 4.665 , 2 ) print (res) # 4.67 |
pow -- 幂运算
计算一个数值的N次幂
语法:pow(parameter1,parameter2,[parameter3])
参数一表示运算数,参数二表示幂次方数,参数三表示被除数,计算幂运算结果除法余数;
1
2
3
4
5
6
7
8
9
10
|
# 还记得python的幂运算符嘛? res = pow ( 2 , 3 ) print (res) # 8 print ( 2 * 2 * 2 ) # 8 print ( 2 * * 3 ) # 8 # 除法求余数 res = pow ( 2 , 3 , 3 ) print (res) # 2 print ( 8 % 3 ) # 2 |
序列
sum -- 序列和
计算一个容器(字符串除外)中的数字之和,容器中的数据必须都是数字类型
1
2
3
|
lst = [ 1 , 2 , 3 , 4 ] res = sum (lst) print (res) # 10 |
max & min -- 获取序列中的最大值和最小值
max获取序列中的最大值,min获取序列中的最小值,max&min属于高阶函数;
语法:max(parameter1,[parameter2, parameter3, ...],key=None)
参数 | 说明 |
---|---|
parameter1 | 指定的序列,容器类型数据(包括字符串) |
parameter2... | 多个值,可以是多个参数一,这些值可以是数值或者是序列 |
key | 函数名,容器中的值的计算方式,按照此计算方式返回值,默认为None,即单纯的比数字大小; |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
# 不指定key lst = [ 0 , 1 , 2 , 3 , 4 ] res = max (lst) # 4 res = min (lst) # 0 # 多参数 # 1、参数可以不只一个,但是多个参数必须相同的数据类型,比较参数中的第一个参数返回数据,但是众序列中的第一个参数都必须是相同的数据类型,如果是字符串,比如ABC之间的比较是根据ASCII码进行的。 lst1 = [ 0 , 100 ] lst2 = [ 2 , 10 ] print ( max (lst1, lst2)) # [2, 10] print ( min (lst1, lst2)) # [0, 100] # 2、参数可以不是容器类型数据,可以直接比较多个数字(其实也就是元组了) print ( max ( 1 , 2 , 3 )) # 3 print ( min ( 1 , 2 , 3 )) # 1 # 指定key,经过key指定的函数处理,比较返回的结果,然后返回对应的数据 lst = [ 0 , 1 , 2 , 3 , 4 ] def func(num): return num * - 1 res = max (lst, key = func) # 0 print (res) res = min (lst, key = func) # 4 print (res) |
sorted -- 序列排序
对一个序列中的值进行排序,默认按照升序(从小到大)排列;数字按照大小排序,ASCII字符串按照编码顺序排序,其余字符的排序规律不清,可能是按照某个指定的编码的先后进行排序。
语法:sorted(parameter1, key=None, reverse=False)
参数 | 说明 |
---|---|
parameter1 | 指定排序的序列数据 |
key | 指定排序的方法,使用方法和max等一众高阶函数的方法是一样的; |
reverse | 排序方式,默认为False, 即为升序,True为降序; |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
# 使用list为例 lst = [ 2 , 0 , 1 , 3 , 4 ] # 默认为升序 new_lst = sorted (lst) print (new_lst) # [0, 1, 2, 3, 4] # 降序 new_lst = sorted (lst, reverse = True ) print (new_lst) # [4, 3, 2, 1, 0] # 注意和list内置方法的区别,list.sort方法在原数据上重新排序,sorted方法返回一个新的数据; lst1 = [ 1 , 0 , 3 ] lst1.sort() print (lst1) # [0, 1, 3] lst2 = [ 1 , 0 , 3 ] new_lst2 = sorted (lst2) print (lst2) # [1, 0, 3] print (new_lst2) # [0, 1, 3] |
zip -- 多序列同索引组合
enumerate -- 枚举
zip & enmerate 见推导式。
进制数转换
还记得如何直接表示一个非十进制数字吗?
- 0b 开头表示二进制数;
- 0o 开头表示八进制数;
- 0h 开头表示十六进制数;
bin -- 将其它进制的数转成二进制数
1
2
3
4
5
6
7
8
9
10
11
|
# 十进制数 转 二进制 res = bin ( 255 ) print (res) # 0b11111111 # 八进制 转 二进制 res = bin ( 0o377 ) print (res) # 0b11111111 # 十六进制 转 二进制 res = bin ( 0xff ) print (res) # 0b11111111 |
oct -- 将数转为八进制数
hex -- 将数转为十六进制数
ASCII字符编码转换
还记得ASCII编码吗?下面的函数可以将ASCII编码中包含的字符在字符和序号之间转换
chr -- 将ASCII序号转成字符
1
2
3
|
# 返回 97 号字符 res = chr ( 97 ) print (res) # a |
ord -- 将字符转回ASCII序号
1
2
|
res = ord ( 'A' ) print (res) # 65 |
其它
dir -- 返回指定位置的类、函数、变量
默认返回当前位置的类、函数、变量。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
# 定义函数 def func(): pass # 定义类 class Class: pass # 定义变量 var = 1 # 返回属于当前位置(文件)的类、函数、变量 res = dir () print (res) # ['Class', '__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'func', 'var'] def func1(): inner_var = 1 # 内置变量(属于函数func1) print ( dir ()) # 返回输入当前位置(函数func1)的类、函数、变量 func1() # ['inner_var'] |
range -- 生成指定范围整数的可迭代对象
range本身不是一个函数,而是一个类,但是在日常的使用过程中经常被作为一个函数使用;
接下的讲解主要当作是一个函数使用去讲解;
语法:range(value, [stop_value,] [step_value])
参数 | 说明 |
---|---|
value | 意义为返回的起点数值;但是如果单独使用话本身的含义为0,原本指定的值成为stop_value的值; |
stop_value | 意义为返回数的最大范围,但是终点数不是其本身,如果stop_value是0或者正数,就是stop_value减一,如果stop_value是负数,就是stop_value加一; |
step_value | 步长,每个返回值之间的间隔数,默认为1; |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
# 在实际的使用过程中往往配合for循环使用 for i in range ( 10 ): print (i) # 但是此例中因为便于查看不使用for循环演示,而是改用list强转演示; # 一个参数:表示返回 0 ~ N-1 的数值 lst = list ( range ( 10 )) print (lst) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # 两个参数表示返回 N ~ M-1 的数值 lst = list ( range ( 3 , 10 )) print (lst) # [3, 4, 5, 6, 7, 8, 9] # 三个参数表示返回 N ~ M-1 的数值,但是每个数间隔F lst = list ( range ( 3 , 10 , 2 )) print (lst) # [3, 5, 7, 9] # 倒序: 只要让步长变为负数即可,但是也要注意 N 和 M 的数值确保范围准确 lst = list ( range ( 10 , - 10 , - 4 )) print (lst) # [10, 6, 2, -2, -6] |
eval 和 exec -- 字符串编译成py代码执行
上面的方法可以将字符串编译为python代码执行,eval只能适用于简单的代码;exec可以将更加复杂的代码执行;
1
2
3
4
5
6
7
8
9
|
# eval 只能编译简单的代码 char = 'print("Hello MSR.")' eval (char) # Hello MSR. # 定义变量(eval不能编译,但是exec可以) char = 'new_char = "My motherland is China."' # eval(char) # SyntaxError exec (char) print (new_char) # My motherland is China. |
repr -- 原型化输出字符串
将字符串中的转义字符失效,还记得字符串前缀r
吗?他们的效果是一样的,但是repr会将两边的引号也显示出来。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
# 转义 char = 'Hello\nChina.' print (char) ''' Hello China. ''' # 原型化 char = repr (char) print (char) # 'Hello\nChina.' # repr 和 字符串前缀 r 的不同:显示出两边的引号 print (r 'MSR' ) # MSR print ( repr ( 'MSR' )) # 'MSR' |
hash -- 生成哈希值
将指定数据经过哈希运算法则生成的哈希值返回,相同的两个数据同时经过哈希运算法则得出的结果一定相同,所以一般哈希运算用于文件校验和密码加密等场景;
1
2
3
4
5
6
7
8
9
|
# 每次的结果不一定相同,但是相同数据同时运算结果一定相同 hash1 = hash ( 'abs' ) hash2 = hash ( 'abs' ) print (hash1) print (hash2) ''' -4611394003149070947 -4611394003149070947 ''' |
再上述使用hash()方法的时候,我们发现相同数据在多次运算的时候,结果不一定相同,这是因为控制hash的环境变量PYTHONHASHSEED
所作用的,如果在启动python的时候,设定该环境变量,则可以复现hash值,也就是每次的hash值都是相同的。
1
2
3
4
5
6
|
# 示例 # 不指定PYTHONUNBUFFERED,hash每次都是随机的 python main.py # 指定PYTHONUNBUFFERED,hash是固定复现的 PYTHONUNBUFFERED = 11 python main.py |
help -- 帮助文档
查看各种函数、类的帮助文档,还记得如何给自定义函数和类注释帮助文档吗?
类似的功能还有函数的内置方法 __doc__()
可以实现;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
# 查看print方法的帮助文档 print_help = help ( print ) print (print_help) """ Help on built-in function print in module builtins: print(...) print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False) Prints the values to a stream, or to sys.stdout by default. Optional keyword arguments: file: a file-like object (stream); defaults to the current sys.stdout. sep: string inserted between values, default a space. end: string appended after the last value, default a newline. flush: whether to forcibly flush the stream. None """ |
数据之间的强制转换
四个数字类型方法和五个容器类型方法,主要用作数据的生成和数据之间的强转;
详情请参见六大数据类型和数据之间的强制转换;
id -- 返回数据的内存地址
返回一个数据的内存地址,这个地址是唯一的,这个东西关系到了一个程序占据资源空间的大小,也是评判一个程序是否优劣的标准之一,还记得我们之前讲过的Python的缓存机制吗?
1
2
3
|
char = 'Hello MSR.' char_id = id (char) print (char_id) # 2884357927408 |
len -- 查看容器类型数据的长度
查看一个容器类型数据的长度,也就是一级元素的个数;
1
2
3
4
5
6
7
8
9
10
11
12
|
lst = [ 1 , 2 , 3 ] lst_length = len (lst) print (lst_length) # 3 # 列表类型数据还有内置方法 __len__ 也可以查看 lst_length = lst.__len__() print (lst_length) # 一般配合range 遍历容器使用 lst = [ 1 , 2 , 3 ] for i in range ( len (lst)): print (lst[i]) |
type -- 返回数据的类型
type是Python的一个内置类,作用是返回一个数据的类型
1
2
3
4
5
6
7
8
9
10
11
|
char = 123 char_type_obj = type (char) print (char_type_obj) # <class 'int'> char_type = char_type_obj.__name__ print (char_type) # int # 判断数据类型 if char_type = = 'str' : print (char) else : print (char_type) |
isinstance -- 判断数据类型
用于判断数据的类型,返回布尔值;
语法:isinstance(x, A_tuple)
参数 | 说明 |
---|---|
x | 要判断的数据 |
A_tuple | 要判断的数据类型,如果x是该数据类型返回真,反之为假;也可以是一个元组中包含多个数据类型,如果x的数据类型是元组中的其中之一就返回真,反之返回假; |
1
2
3
4
5
6
7
8
9
|
res = isinstance ( 100 , int ) print (res) # True res = isinstance ( False , ( str , float , tuple )) print (res) # False # 注意:Python中的 布尔型 和 整型 在使用isinstance判断的时候是相同的 res = isinstance ( False , ( str , int , tuple )) print (res) # True |
issubclass -- 判断类的子父关系
用法和isinstance
一模一样,用于判断指定类和类之间是否存在子父关系,isinstance
和issubclass
的详细用法见面向对象(类的继承)。
open -- 文件IO操作
详情请见IO文件管理;
locals 和 globals -- 局部和全局空间
用于输出所有的全局变量和局部变量,详情请见函数进阶(全局空间和局部空间)。
quit 和 exit
用于退出程序,结束程序;
1
2
|
quit() exit() |
常用关键字
1
2
3
4
|
# 引导出系统中所有的关键字 import keyword print (keyword.kwlist) |
关键字 | 作用 |
---|---|
pass | 过,占位符;是空语句,本身没有作用,个别情况为了保持程序结构的完整性二占据一些必要的位置; |
NotImplemented | 同“None”; |
Ellipsis | 省略号; |
... | 同“Ellipsis” |
break | 终止循环; |
continue | 跳过当前循环; |
if...elif..else... | if语句; |
for...in...else... | for循环; |
while...else... | while循环; |
del | 删除变量,释放空间; |
None | 基础数据类型,表示空; |
global | 声明全局变量; |
nonlocal | 声明局部变量; |
def | 定义函数; |
class | 定义类; |
as | 别名; |
还有许许多多的关键字不在列举;
常见内置属性
1
2
3
4
|
print (__name__) # 当前模块 print (__file__) # 当前文件路径 print (__doc__) # 文档注释 print (__package__) # 位置 |
以上就是Python常用内置函数和关键字使用详解的详细内容,更多关于Python内置函数 关键字的资料请关注服务器之家其它相关文章!
原文链接:https://www.cnblogs.com/msr20666/p/16265393.html