文章很长,差几百到3w字,每个方法都包括进去了,建议使用电脑阅读,点击方法名即可跳转至对应位置。
说实话有些几乎用不到的方法小编也忘了,为了写好这篇blog,专门去翻了Python官方的英文文档,相当于让自己再巩固巩固基础知识吧,同时也希望能帮助到某些小伙伴。
Python3中69个内置方法:
从上往下,从左到右,按字母顺序排序。
1、abs(x) 方法
作用:返回一个数字的绝对值。参数可以是整数或浮点数,如果参数是复数,则返回ITSMAGNUDE。正数的绝对值等于本身,负数的绝对值等于其相反数,0的绝对值是0。
# abs() Sample
a = 1 # 给变量a赋值1
b = -1 # 给变量b赋值-1
print(a) # 打印出变量a的值
print(b) # 打印出变量b的值
m = abs(a) # 用abs()方法求变量a的绝对值,并将绝对值赋给变量m
n = abs(b) # 用abs()方法求变量b的绝对值,并将绝对值赋给变量n
print(m) # 打印出变量m的值
print(n) # 打印出变量n的值
2、all(iterable) 方法
作用:如果参数中所有可迭代的元素为真(或者如果迭代为空),则返回True,否则返回False。
注意:数字0不为真,所以如果迭代元素中包含了数字0那么结果为False。all()方法传入的参数必须是可迭代对象(iterable),可迭代对象是指可以直接作用于for循环的对象。可以直接作用于for循环的数据类型有以下几种:一类是集合数据类型,如list、tuple、dict、set、str等;一类是生成器(generator):包括生成器和带yield的生成器函数(generator function)。可以使用isinstance()判断一个对象是否是Iterable对象。
# all() Sample
print(all('')) # 参数是空字符串,返回True
print(all('这是字符串类型')) # 参数是字符串,是可迭代对象,且都为真,返回True
print(all(())) # 参数是空元组,返回True
print(all((1, 2, 3))) # 参数是元组,返回True
print(all((0, 1, 2, 3))) # 参数是包含0元素的元组,返回False
print(all([])) # 参数是空列表,返回True
print(all([1, 2, 3])) # 参数是列表,返回True
print(all([0, 1, 2, 3])) # 参数是包含0元素的列表,返回False
3、any(iterable) 方法
作用:参数中只要有任何一个可迭代的元素为真,就返回True。如果迭代是空的(空字符串,空元组,空列表等),则返回False。
# any() Sample
print(any('')) # 参数是空字符串,返回False
print(any('这是字符串类型')) # 参数是非空字符串,返回True
print(any(())) # 参数是空元组,返回False
print(any((1, 2, 3))) # 参数是元组,且迭代元素都为真,返回True
print(any((0, 1, 2, 3))) # 参数是元组,且包含为真的元素(非0),返回True
print(any([])) # 参数是空列表,返回False
print(any([1, 2, 3])) # 参数是列表,且迭代元素都为真,返回True
print(any([0, 1, 2, 3])) # 参数是包含0元素的列表,且包含为真的元素(非0),返回True
4、ascii() 方法
作用:像repr()方法一样,返回对象的可打印的字符串的形式,但在返回非ascci码字符(比如汉字)时会通过repr()方法使用 \x ,\u 或 \U 进行转换。生成的字符串类似于Python 2中的repr()方法。
# ascii() Sample
# 传入参数对象是一个列表,ascii将返回他的字符串表示
a = ascii(['Python520,我爱 Python']) # 包含中文,是非ascii字符,所以会使用\x ,\u或\U进行转换
print(type(a)) # 打印列表通过ascii()方法转换后的数据类型,变为字符串类型
print(a) # 打印通过ascii()方法返回的字符串
5、bin(x) 方法
作用:
将整数转换为以“0b”为前缀的二进制字符串,说简单点就是将数据转换成二进制。结果是一个有效的Python表达式。如果传入的参数x不是Python整型对象,它会定义一个返回整数的__index__()方法。
如果不希望转换结果中包含‘0b’前缀,可以用format()方法,下面代码有示例。
# bin(int_number) Sample
t = bin(3) # 将3转换成二进制并赋给变量t
print(t) # 打印3的二进制:0b11
print(bin(-20)) # 打印-20的二进制:-0b10100
print(bin(520)) # 打印520的二进制:0b1000001000
# 二进制其它转换方式,可以选择是否保留'0b'前缀
m1 = format(520, '#b') # 结果与bin()一样,有'0b'前缀
print(m1) # 打印结果:0b1000001000
m2 = format(520, 'b') # 结果无'0b'前缀,纯01序列
print(m2) # 打印结果:1000001000
n1 = f'{520:#b}' # 结果与bin()一样,有'0b'前缀
print(n1) # 打印结果:0b1000001000
n2 = f'{520:b}' # 结果无'0b'前缀,纯01序列
print(n2) # 打印结果:1000001000
6、bool(x) 方法
作用:返回布尔值,即True或Flase 。 如果x为假或空类型,则返回False,否则返回True。
这个bool类是int型的一个子类,不能再细分( 详见Numeric Types — int, float, complex)。它的唯一实例是False和True(详见Bool-Value)。
# bool() Sample
print(bool(0)) # 0的布尔值,False
print(bool(1)) # 1的布尔值,True
print(bool('')) # 空字符串的布尔值,False
print(bool('我爱Python')) # 非空字符串的布尔值,True
print(bool(())) # 空元组的布尔值,False
print(bool((1,'IlovePython'))) # 非空元组的布尔值,True
print(bool([])) # 空列表的布尔值,False
print(bool([1,'1','Python'])) # 非空列表的布尔值,True
7、breakpoint(*args,**kwargs) 方法
作用:breakpoint() 是 Python 3.7 中新增加的内置函数。在未设置 PythonBREAKPOINT 的情况下,breakpoint() 会中断当前程序并进入 pdb 调试器。
# breakpoint() Sample,In builtins
def breakpoint(*args, **kws):
import sys
missing = object()
# 设置钩子函数
hook = getattr(sys, 'breakpointhook', missing)
if hook is missing:
raise RuntimeError('lost sys.breakpointhook')
# 返回钩子函数的调用
return hook(*args, **kws)
# 可见breakpoint的工作仅是设置并调用hook函数,这里只需要注意以下几点:
# breakpoint 中的 hook 变量将引用 sys.breakpointhook 函数对象;
# breakpoint 会将自己所有的实参都传递给 sys.breakpointhook();
# 如果 sys.breakpointhook 缺失,则会抛出 RuntimeError
关于breakpoint()更详细的解析请参考:breakpoint() <Python 内置函数>
8、bytearray() 方法
作用:返回一个新的字节数组(可变的字节序列),这个数组里的元素是可变的,可以进行增删改操作,并且每个元素的值范围: 0 <= x < 256。参数如果是字符串你必须声明编码方式(如endcoding=‘utf-8’)。
bytearry(source,encoding=’’,errors) 参数说明
如果 source 为整数,则返回一个长度为 source 的初始化数组;
如果 source 为字符串,则按照指定的 encoding 将字符串转换为字节序列;
如果 source 为可迭代类型,则元素必须为[0 ,255] 中的整数;
如果 source 为与 buffer 接口一致的对象,则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数,默认就是初始化数组为0个元素。
众所周知,字符串定义后是不可修改的,但可以利用bytearry()方法将字符串返回成字节数组,然后通过索引下标以ascii码的方式修改。
bytearray为可变序列,因此可以进行可变序列的增删改操作:
appende(int) :增加操作,提供一个int型常量,根据ASCII码转换为对应的bytes。
insert(index,int):插入操作,与append一样,提供int。
extend(iterable_of_ints):追加iterable,iterable内部为int。
pop(index=-1):通过索引删除。
remove(value)通过值删除。
clear():清空。
reverse():转置 。
# bytearry() Sample
a = 'abcdABCD'
b = bytearray(a, encoding='utf-8') # 用bytearry()将字符串a返回给b
print(b) # 打印b:bytearray(b'abcdABCD')
for i in b:
print(i) # 遍历输出发现,输出的是每个字符的ascii编码
b[0]=65 # 通过索引,用ascii码修改b,65对应字母A
b[1]=66 # 通过索引,用ascii码修改b,65对应字母B
print(b) # 打印修改后的b:bytearray(b'ABcdABCD')
参考:
bytes()和bytearray()的用法详解
python bytes和bytearray、编码和解码
9、bytes() 方法
作用:它是 bytearray 的不可变版本。bytes()返回不可变的字节序列 ,是不可变的二进制格式字节数据,(注意,是字节不是字符),以 0 <= x < 256 区间内的整数方式表示。例如对于ascii范围内的字符"a",它存储为97。
用法:
bytes()定义一个空bytes,一般情况下没有什么用
bytes(int)指定字节的bytes,被0填充。定义长度
bytes(iterable of ints)定义内容,如bytes(range(5))iterable为整型序列,否则报错
bytes(bytes or buffer)将bytes或buffer转换为bytes
bytes(string,encoding[,errors])要指定encoding,如:
bytes(‘abc’,‘utf-8’)encoding为utf-8
或者:bytes(b’abc’)b默认encoding为utf-8
操作:
bytes()的操作和str(字符串)相似,区别是bytes方法输入输出都是bytes(字节):
(1)replace替换
b’abcdef’.replace(b’f’,b’k’)将f替换成k,返回一个bytes
(2)find查找
b’abc’.find(b’b’)查找b,返回位置索引
(3)类方法:bytes.fromhex(string)
string为2个字符的16进制形式,如’6162 6a 6b00’空格被自动删除
(4)hex()返回16进制表示的字符串
‘abc’.encode().hex() => ’\x61\x62\x63’
# bytes() Sample
a = bytes([1,2,3,4])
print(a) # 打印结果:b'\x01\x02\x03\x04'
10、callable() 方法
作用:判断对象是否可调用,并返回布尔值,可调用为True,不可调用为False。比如定义了一个函数,函数是可调用的,而一个列表是不可调用的。
小技巧:想要使用一个对象时,如果它后面需要加 ‘()’ 则它是可调用的,比如调用一个函数,函数名后面是带有括号的;想引用一个列表,直接使用存储该列表的变量名就可以了,列表变量名后面是没有括号的。
# callable() Sample
a = [1,2,3] # a是一个列表
def sumb(m,n): # sumb是一个函数
return m+n
print(callable(sum)) # 判断sumb是否是可调用的,结果为True
print(callable(a)) # 判断a是否是可调用的,结果为False
11、chr() 方法
作用:返回Unicode编码中为整数或特殊符号的字符串。传入的参数为整数。
例如,chr(97)返回字符串“A”,chr(98)返回字符串“B”,chr(65)返回字符串“a”,chr(8364)返回字符串“€”(欧元符号)。
chr() 方法作用与 ord() 方法是相反的。
对ascii、Unicode、utf-8等编码有疑问的可以参考:
ASCII、GB2312、GBK、GB18030、Unicode、UTF-8、BIG5 编码分析详解(全网最全)
# chr() Sample
print(chr(65)) # 打印出字母A
print(chr(90)) # 打印出字母Z
print(chr(97)) # 打印出字母a
print(chr(98)) # 打印出字母b
print(chr(8364)) # 打印出欧元符号€
for i in range(255):
print(chr(i)) # 循环打印前256(0-255)个Unicode码表示的字符
12、classmethod() 方法
作用:classmethod 修饰符对应的函数不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数,可以来调用类的属性,类的方法,实例化对象等。
# classmethod() Sample
class sumb(object):
bar = 1
def func1(self):
print ('i am fun1')
@classmethod
def func2(cls):
print ('i am func2')
print (cls.bar)
cls().func1() # 调用 func1 方法
sumb.func2() # 不需要实例化
13、compile() 方法
作用:将一个字符串编译为字节代码。
compile(source,fliename,mode,flags) 方法参数说明
source – 字符串或者AST(Abstract Syntax Trees)对象。。
filename – 代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。
mode – 指定编译代码的种类。可以指定为 exec, eval, single。
flags – 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。。
flags和dont_inherit是用来控制编译源码时的标志
# compie() Sample
a = "for i in range(1,100): print(i)" # 将代码定义为字符串
# 用compile()对字符串中的代码进行编译,mode为exec(可执行)
b = compile(a,'','exec')
print(b) # 打印编译后的文件内容
print(exec(b)) # 执行编译过的程序
14、complex(real,img) 方法
作用:用于创建一个复数,第一个参数real为实部,第二个参数img为虚部;也可以转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数。
# complex() Sample
print(complex(1)) # 实部传入一个整数参数1,转换为复数(1+0j)
print(complex(1,2)) # 实部参数1,虚部参数2,转换为复数(1+2j)
print(complex(1.1)) # 实部传入一个浮点数参数1。1,转换为复数(1.1+0j)
print(complex('1')) # 实部传入一个字符串'1',转换为复数(1+0j)
print(complex('1+2j')) # 实部传入一个字符串'1+2j',转换为复数(1+2j)
15、delattr() 方法
作用:删除某个对象的属性。
delattr(obj,name) 参数说明
obj,对象的名字
name,对象中要删除的属性名
# delattr() Sample
class test:
x = 1
y = 2
z = 3
print('x = ', test.x) # 程序正常
print('y = ', test.y) # 程序正常
print('z = ', test.z) # 程序正常
delattr(test, 'z') # 用delattr()方法删除test中的'z'属性
print('x = ', test.x) # 程序正常
print('y = ', test.y) # 程序正常
print('z = ', test.z) # 触发错误,因为'z'属性已经被删除
# AttributeError: type object 'test' has no attribute 'z'
16、dict() 方法
作用:创建一个字典。一共有三种方式。
# dict() Sample
a = dict() # 创建空字典
print(a) # {}
# 方式1:通过传入键值对创建字典:
b = dict(小明='男',小红='女')
print(b) # {'小明': '男', '小红': '女'}
# 方式2:通过iterate可迭代对象创建字典:
c = dict([('小明','男'),('小红','女'),('我爱','Python')])
print(c) # {'小明': '男', '小红': '女', '我爱': 'Python'}
# 方式3:通过zip()函数映射创建字典:
d = dict(zip(['小明','小红','大家都爱'],['男','女','Python']))
print(d) # {'小明': '男', '小红': '女', '大家都爱': 'Python'}
17、dir() 方法
作用:返回属性、方法名、变量名等。分带参数和不带参数两种情况。
# dir() Sample
print(dir()) # 无参数,打印当前模块中的变量名、方法命
string = '我爱Py' # 定义一个字符串
print(dir(string)) # 有参数,打印字符串下可使用的内部方法
list = [1,2] # 定义一个列表
print(dir(list)) # 有参数,打印列表下可使用的方法
18、divmod() 方法
作用:传输两个参数:被除数和除数,返回一个包含两个数据(分别是商和余数)的元组。参数可以是整数或浮点数,不能是复数。
# divmod() Sample
a = divmod(4, 2) # 被除数4,除数2
print(a) # 打印结果:(2, 0) 商为2,余数为0
b = divmod(1, 3) # 被除数1,除数3
print(b) # 打印结果:(0, 1) 商为0,余数为1
c = divmod(3.0, 2) # 被除数3.0 ,除数2
print(c) # 打印结果:(1.0, 1.0) 商为1.0 ,余数为1.0
d = divmod(3, 2.0) # 被除数3 ,除数2.0
print(d) # 打印结果:(1.0, 1.0) 商为1.0,余数为1.0
e = divmod(3, 1.2) # 被除数3,除数 1.2
print(e) # 打印结果:(2.0, 0.6000000000000001) 商为2.0,余数为0.6000000000000001)
19、enumerate() 方法
作用:给可迭代对象添加索引序列,默认序列默认从0开始,初始值也可以指定,一般用于for循环。也可利用其统计文件行数。
# enumerate Sample
a = ['小明', '小红', '小曹'] # 定义a为一个列表
# 用法1: 默认序列号
for i in enumerate(a):
print(i)
"""
打印结果为:
(0, '小明')
(1, '小红')
(2, '小曹')
"""
# 用法2:指定序列初始值
for j in enumerate(a, 666): # 指定序列开始值为666
print(j)
"""
打印结果为:
(666, '小明')
(667, '小红')
(668, '小曹')
"""
# 用法3:迭代输出enumerate中的内容
for index,values in enumerate(a, 1):
print(index,values)
"""
打印结果为:
1 小明
2 小红
3 小曹
"""
# 用法4:统计某文件行数,filepath为文件路径
count = 0
for index, line in enumerate(open(filepath,'r')):
count += 1
print(count)
20、eval() 方法
作用:执行一个字符串格式的表达式或函数,并返回值。
# eval() Sample
# 用法1:直接计算表达式
a = eval('3+2')
print(a) # 结果:5
# 用法2:执行函数
def test2():
for i in range(5):
print('eval()的用法2')
b = eval('test2()')
print(b) # 结果:打印了5行'eval()的用法2'
21、exec() 方法
作用:与eval()相似,还可以执行字符串形式的Python语句包括文件中的代码语句。
# exec() Sample
# 执行字符串形式的Python语句:
exec('print("exec的使用")')
# 结果:打印出了'exec的使用'
exec('for i in range(10):print("exec%d" %i)')
# 结果:打印出exec0、exec1、....、exec9
# 执行字符串格式的函数:
def add1(): # 定义一个函数
a = 520
b = 1314
print(a+b)
exec('add1()') # 结果:打印出1834
22、fliter(function,inter) 方法
作用:用于过滤掉一组数据中不符合条件的数据,然后返回一个迭代器对象,可以用list()转化为列表。它需要接收两个参数,一个是判断条件的函数,一个是一组可迭代的数据。
# fliter() Sample
def abs1(n):
return abs(n) >= 5 # 返回绝对值大于等于5的数
filter1 = filter(abs1,range(-10,10)) # 过滤-10-10中绝对值小于5的数
list1 = list(filter1)
print(list1) # 结果:[-10, -9, -8, -7, -6, -5, 5, 6, 7, 8, 9]
23、float() 方法
作用:可以将整数或字符串形式的数转换成浮点数。
# float() Sample
# 转换整数:
print(float(520)) # 结果:520.0
# 转换字符串数:
print(float('1314')) # 结果:1314.0
24、format() 方法
作用:format可以对字符串或数字进行格式化操作。主要通过‘{ }’和‘ : ’来控制,它可以接受多个参数,且参数位置可以不按顺序。可以用大括号来转义大括号。
# format() Sample 对字符串格式化
# 大括号为空,不指定位置:
sample = "{}{}".format('你好','世界')
print(sample) # 结果:你好世界
# 大括号中通过索引序号指定位置:
sample = "{0}{1}".format('你好', '世界') # '你好'索引为0,'世界'索引为1
print(sample) # 结果:你好世界
sample = "{1}{0}".format('你好','世界')
print(sample) # 结果:世界你好
sample = "{1}{0}{0}{1}{1}{0}".format('你好','世界')
print(sample) # 结果:世界你好你好世界世界你好
# format带参数
# format直接带参数:
sample = "姓名:{name},爱好1:{lover}".format(name='小曹',lover='亚亚')
print(sample) # 结果:姓名:小曹,爱好1:亚亚
# 通过字典设置参数:
dic1 = {'name': '小曹', 'lover': '学Python'}
sample = '姓名:{name}, 爱好2:{lover}'.format(**dic1)
print(sample) # 结果:姓名:小曹, 爱好2:学Python
# 通过列表设置参数:
list1 = ['小曹', '写blog']
sample = "姓名:{0[0]},爱好3:{0[1]}".format(list1) # 列表索引前必须加'0'
print(sample) # 结果:姓名:小曹,爱好3:写blog
# format() Sample 对数字格式化
a = 13.14520
b = 666
c = 1234567890
# 保留后两位(四舍五入):
print("{:.2f}".format(a)) # 结果:3.15
# 带符号位且保留后两位:
print("{:+.2f}".format(a)) # 结果:+3.15
print("{:+.2f}".format(-a)) # 结果:-3.15
# 保留整数:
print("{:.0f}".format(a)) # 结果:13
# 数字宽度为10,用0左填充:
print("{:0>10d}".format(b)) # 结果:0000000666
# 数字宽度为10,用1右填充:
print("{:1<10d}".format(b)) # 结果:6661111111
# 千分计数法,逗号分隔:
print("{:,}".format(c)) # 结果:1,234,567,890
# 百分比格式:
print("{:.3%}".format(a)) # 结果:1314.520%
# 指数e计数法:
print("{:.2e}".format(b)) # 结果:6.66e+02
# 数字宽度为10,左对齐:
print("{:<10d}".format(b)) # 结果:666(后面7个空格)
# 数字宽度为10,右对齐:
print("{:>10d}".format(b)) # 结果: 666(最前面7个空格)
# 数字宽度为10,中间对齐:
print("{:^10d}".format(b)) # 结果: 666 (前面3个空,后面4个空)
# 输出二进制格式:
print("{:b}".format(b)) # 结果:1010011010
# 输出为八进制:
print("{:o}".format(b)) # 结果:1232
# 16进制:
print("{:x}".format(b)) # 结果:29a
# 带‘0xb’前缀的16进制:
print("{:#x}".format(b)) # 结果:0x29a
# 带‘0XB’前缀的16进制:
print("{:#X}".format(b)) # 结果:0X29A
总结:
‘^’, ‘<’, ‘>’ 分别代表居中、左对齐、右对齐,后面带宽度,‘:’号后面带填充的字符,只能是一个字符,不指定则默认是用空格填充。
‘+’ 表示在正数前显示 ‘+’,负数前显示’-’ ;(空格)表示在正数前加空格。
b、d、o、x 分别代表2进制、十进制、8进制、16进制。
25、frozenset() 方法
作用:冻结一个可迭代对象并返回新的集合,如果参数为空则会生成一个空集合,被冻结的集合的元素不能再进行增删操作。
# frozenset() Sample
a = range(5)
b = '小曹爱python'
print(frozenset(a)) # 结果:frozenset({0, 1, 2, 3, 4})
print(frozenset(b)) # 结果:frozenset({'p', '曹', 'h', 'n', '小', 'y', 't', '爱', 'o'})
26、getattr() 方法
作用:获取对象的属性值,且可以直接使用该返回值。该方法有3个参数,第一个参数是对象名,第二个参数是要获取的属性名,第三个参数是defaul返回默认值,如果没有传入该参数且没有找到对应的属性时会报错AtttibuteError。
# getattr() Sample
class A:
attr1 = '你好世界'
attr2 = 'hello word'
# 返回attr1这个属性的值:
print(getattr(A,'attr1')) # 结果:你好世界
# 返回attr2这个属性的值:
print(getattr(A,'attr2')) # 结果:hello word
# 返回attr3这个不存在的属性的值,没加默认参数,会报错
print(getattr(A,'attr3')) #报错:AttributeError: type object 'A' has no attribute 'attr3'
# 返回attr3这个不存在的属性的值,加上默认返回值
print(getattr(A,'attr3','该属性不存在123')) # 结果:该属性不存在123
27、globals() 方法
作用:以字典的形式返回当前位置下的全部全局变量,包括所有导入的变量。
a = 1
global b
print(globals())
# 结果:
"""
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__':
<_frozen_importlib_external.SourceFileLoader object at 0x0000023FDCE38470>,
'__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>,
'__file__': 'E:/Sound_detect_byCaoTangyi/Built-in-Functions.py',
'__cached__': None, 'sample': '姓名:小曹,爱好3:写blog',
'dic1': {'name': '小曹', 'lover': '学Python'}, 'list1': ['小曹', '写blog'], 'a': 1}
"""
28、hasattr() 方法
作用:判断一个对象是否有某属性,有返回True,无则返回Flase。需要两个参数,一个时对象名,一个是字符串格式的属性名。
# hasattr() Sample
class B:
at1 = 1
at2 = '2'
b = B()
print(hasattr(b, 'at1')) # True
print(hasattr(b, 'at2')) # True
print(hasattr(b,'at3')) # Flase
29、hash() 方法
作用:获取某个对象的哈希值。
# hash() Sample
# 获取数字的哈希值:
print(hash(123))
#获取字符串的哈希值:
print(hash('hello word'))
print(hash(str([1, 'python'])))
30、help() 方法
作用:查看某模块的帮助信息。
# help() Sample
import time
print(help(time)) #time模块的使用帮助
31、hex() 方法
作用:将数据转换成16进制。
# hex() Sample
a = 15
b = 16
c = 255
d = -1
print(hex(a)) # 0xf
print(hex(b)) # 0x10
print(hex(c)) # 0xff
print(hex(d)) # -0x1
32、id() 方法
作用:获取某个对象的内存地址。
# id() Sample
a = 1223
b = '134'
print(id(a)) # 2735369637616
print(id(b)) # 2735371328400
33、input() 方法
作用:该方法会接受以给用户输入,并返回输入的字符串格式。
# input() Sample
a = input("请输入123456:")
print(a)
print(type(a))
截图:
34、int() 方法
作用:将字符串或数字转换成十进制整数。有两个参数,第一个是需要转换的数据,第二个是原数据的进制数,其中第二个参数如果省略,默认原数据
为10进制数据;如果带有第二个参数,原数据需要以字符串形式传入。当int()参数为空时,默认返回0。
# int() Sample
print(int()) # 参数为空,默认返回0
# 将小数转换成整数:
print(int(12.2)) # 12
# 将16进制的'0xa'转换成10进制整数:
print(int('0xa', 16)) # 10
# 将8进制的'10'转换成10进制整数:
print(int('10', 8)) # 8
35、isinstance() 方法
作用:与type()方法相似,返回一个对象的类型。与type()的区别是,type()不会考虑继承关系。而isinstance()则会考虑继承关系,认为子类是父类类型。可以传递两个参数,一个参数是对象名,第二个参数是类型名,也可以是一个包含几个类型名的元组。如果判断段为真,返回True,否则返回Flase。
# isinstance() Sample
a = '213' # 定义a为一个字符串
print(isinstance(a,int)) # 判断a是否是int整型,结果为Flase
print(isinstance(a,str)) # 判断a是否是str字符串类型,结果为True
# 判断a是否是整型、浮点型、列表型中的一个,结果为Flase:
print(isinstance(a,(int,float,list)))
36、issubclass() 方法
作用:判断某个类是否是某个类的子类,结果为真返回True,否则返回Flase。
# issubclass() Sample
class Sample:
a = 1
b = 2
c = a + b
class B(Sample): # 定义B是Sample类的子类
pass
# 判断B是否为Sample的子类:
print(issubclass(B,Sample)) # 结果为True
37、iter() 方法
作用:用来生成一个迭代器。可以传入两个参数,第一个参数是可迭代的对象的集合,。如果要传递第二个参数,则参数 object 必须是一个可调用的对象(比如函数),此时iter 创建了一个迭代器对象,每次调用这个迭代器对象的__next__()方法时,都会调用 object。
# iter() Sample
a = 'hello'
for i in iter(a):
print(i)
# 打印结果:
"""
h
e
l
l
o
"""
38、len() 方法
作用:返回项目的长度或数据项数。
# len() Sample()
a = "I like Yaya"
print(len(a)) # 结果:11
b = [1,2,3,4,5,6,]
print(len(b)) # 结果:6
39、list() 方法
作用:将元组或字符串转换从列表。
# list() Sample
a = '123Ilike'
print(list(a)) # ['1', '2', '3', 'I', 'l', 'i', 'k', 'e']
b = (1,2,3,4,5,6)
print(list(b)) # [1, 2, 3, 4, 5, 6]
40、locals() 方法
作用:以字典格式返回当前位置的所有局部变量,变量名为键名,key为变量所对应的值。
# locals() Sample
def test():
a = 1
b = 2
print(locals())
test() # 结果:{'a': 1, 'b': 2}
41、map() 方法
作用:将一个迭代序列中的元素一一映射给一个指定的函数方法进行处理。需要传入两个参数,第一个是指定的函数方法,也可以是lambda匿名函数;第二个参数是一个可迭代序列,也可以是多个序列。
注意:
在Python2.x中,map()返回的是一个列表,可直接print。
而在Python3中,map()返回的是一个迭代器,需要配合for循环取值。
# map() Sample
# 定义一个自己相加的函数add:
def add(a):
return a+a
# 将range(5)中的数一次传递给函数add:
for i in map(add, range(5)):
print(i, end=' ') # 0 2 4 6 8
# 两数相乘的匿名函数,传递两个列表:
for i in map(lambda x, y: x*y, [0,1,2,3,4], [5,6,7,8,9]):
print(i, end=' ') # 0 6 14 24 36
42、max() 方法
作用:返回一组元素中的最大值,参数可以是几个数据,也可以是一组序列。
# max() Sample
a = [-10, 1314, 520, 999]
print(max(a)) # 结果:1314
print(max(0, 1, 10, 666)) # 结果:666
43、memoryview() 方法
作用:允许Python代码访问内存中支持缓冲区协议的数据,即内存查看对象。在Python2和Python3中使用法有一定的区别。该方法返回的是一个元组列表。
# memoryview() Sample
# Python2中的用法:
a = 'helloword'
b = memoryview(a)
print(b[1]) # py2中会打印出'e',py3会报错TypeError: memoryview: a bytes-like object is required, not 'str'
# Python3中用法:
a = 'HELLOWORLD'
b = memoryview(bytes(a, 'utf-8'))
for i in b:
print(i, end=' ') # 打印出:72 69 76 76 79 87 79 82 76 68 ,分析可知这些是字母对应的ascii编码
# 转换格式
print(b[:-1].tobytes(), end='') # 打印出:b'HELLOWORL'
44、min() 方法
作用:与max()相对,返回一组数据中的最小值。
# min() Sample
a = [-10, 1314, 520, 999]
print(min(a)) # 结果:-10
print(min(0, 1, 10, 666)) # 结果:0
45、next() 方法
作用:Python3中等同于__next__()方法。适用于迭代器,返回迭代器的下一个值。可以给定两个参数,第二个参数用于返回默认值。如果迭代器数据取完就会返回默认值,如果没有给定第二个参数,迭代超过数据上限则会报抛出异常:StopItration。
# next() Sample
a = [6, 2, 3, 4, 5, 6]
long = len(a)
b = iter(a) # 生成一个迭代器
for i in range(long):
x = next(b) # 也可写成 x = b.__next__()
print(x, end=' ') #打印出6 2 3 4 5 6
46、object()
作用:Python类对象。返回一个新的无特征对象。对象是所有类的基。它拥有所有Python类实例通用的方法。此函数不接受任何参数。
注意:
对象没有“dict”,因此不能将任意属性分配给对象类的实例。
无法示例!
47、oct() 方法
作用:将一个整型数据转换成二进制字符串形式。参数必须是整型。
# oct() Sample
print(oct(5)) # 0o5
print(oct(-1)) # -0o1
print(oct(8)) # 0o10
print(type(oct(0))) # <class 'str'>
48、open() 方法
作用:打开一个文件,并返回文件对象,想对文件进行操作时需要用到这个方法,对文件操作结束后,要记得用close关闭文件。
参数说明:
open()可以传递的参数很多,可以有8个参数:方法原型是open(file, mode=‘r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None),其中常用的是mode文件打开模式选择和encoding编码选择,其中mode模式又有近20种选择。
参数:
file: 必需,文件路径(相对或者绝对路径)。
mode: 可选,文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
mode模式选择:(参考于菜鸟教程)
t :文本模式 (默认)。
x :写模式,新建一个文件,如果该文件已存在则会报错。
b :二进制模式。
+ :打开一个文件进行更新(可读可写)。
U: 通用换行模式(不推荐)。
r :以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb :以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+ :打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ :以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w :打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
wb :以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。
w+ :打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。
wb+ :以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。
a :打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
ab :以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。
a+ :打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。
ab+ :以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。其中,默认为文本模式,如果要以二进制模式打开,加上 b 。
# open() Sample
# 假设同目录下有个叫test.txt的文件,想查看它的内容:
f = open('test.txt', mode='r', encoding='utf-8')
f.read()
f.close()
49、ord() 方法
作用:返回Unicode字符或ASCII字符对应的编号数字。与 chr() 方法相对。
# ord() Sample
print(ord('A')) # 打印出字母A的编码65
print(ord('Z')) # 打印出字母Z的编码90
print(ord('a')) # 打印出字母a的编码97
print(ord('b')) # 打印出字母b的编码98
print(ord('€')) # 打印出欧元符号€的编码8364
for i in range(256):
print(ord(chr(i))) # 循环打印前256个Unicode码表示的字符的编码0-255
50、pow(x,y) 方法
作用:返回 xy(即x的y次方)的值。
注意:
Python中除了内置的pow()方法外,math模块中也有一个pow()方法。两个方法都可以用来计算 xy,但还是有两点区别:第一是内置pow()方法计算后返回的是int型数据,math.pow()方法计算后返回的是float型数据;第二点区别是math中的pow()方法可以传3个参数,其中第三个参数用来取余,列式子表示就是:math.pow(x, y ,z) == pow(x, y)%z == xy%z
# pow() Sample
# 内置函数求2的10次方:
print(pow(2, 10)) # 1024
# math模块在的方法求2的10次方:
import math
print(math.pow(2, 10)) # 1024.0
51、print() 方法
作用:一般我们学习Python使用的第一个方法就是print()函数,用于打印输出自定义内容。比如第一个Python程序:print(‘Hello Python’)。
参数说明:
print()方法包括1个不定长参数和4个默认参数,函数原型是:print(*content, sep = ’ ', end = ‘\n’, file = ‘sys.stdout’, flush = Flase)。content是自定义要输出的内容,可以是多个对象,每个对象用逗号分隔;sep参数是默认是一个空格符,用于间隔多个对象;end参数默认是一个换行符,作用于输出对象的结尾处;flush参数以布尔值表示,默认是False,利用flush参数可以实现进度条动态加载效果。
# print() Sample
print('Hello Python')
# 输出多个对象:
print('你好', '派森')
# 修改默认参数sep间隔符为hello:
print('你好','派森', 'Python', sep='hello') # 你好hello派森helloPython
# 修改默认参数end为空:
print('P', end='')
print('y', end='')
print('t', end='')
print('h', end='')
print('o', end='')
print('n', end='')
# 上面6行print输出:Python
# 设置flush参数实现动态加载效果:
import time
print("正在加载中", end='')
for i in range(20):
print("...", end='', flush=True)
print(str((i+1)*5)+'%',end='')
time.sleep(0.5)
print('\n加载完成!')
52、property() 方法
作用:返回新式类的属性值。也可以用作装饰器来创建只读属性。类有经典类和新式类,其中当前类或其基类继承了object类的类称为新式类,如果当前类或其基类没有继承object类称作经典类。
# property() Sample
# 定义类A继承了object类,所以是新式类:
class A(object):
def __init__(self):
self._x = None
@property # 装饰器
def x(self):
"""I'm the 'x' property."""
return self._x
@x.setter
def x(self, value):
self._x = value
@x.deleter
def x(self):
del self._x
53、range() 方法
作用:在python2中返回一个列表。在python3中返回的是可迭代对象,所以不能打印出列表,但可以用list()方法转换。
参数:
可以传递1-3个参数,传递1个参数时返回的迭代对象起始值默认为0,如range(3)返回(0,1,2);传递2个参数则第1个为起始值,到第2个值结束,如range(2,5)返回(2,3,4);传递3个参数时第3个参数为步长,步长为1时结果与传递两个参数的结果相同。
# range() Sample
for i in range(5): # 传递一个参数
print(i,end=' ') # 0 1 2 3 4
print('\n')
for j in range(2,10): # 传递两个参数
print(j,end=' ') # 2 3 4 5 6 7 8 9
print('\n')
for m in range(2,10,1): # 传递3个参数,步长为1
print(m,end=' ') # 2 3 4 5 6 7 8 9
print('\n')
for n in range(1,10,2): # 传递3个参数,步长为2
print(n,end=' ') # 1 3 5 7 9
# 用list()转换:
print(list(range(5))) # [0, 1, 2, 3, 4]
54、repr() 方法
作用:将变量或常量装换为字符串,输出会带有引号。与str()方法相似但也有一些区别:str() 的输出结果我们能很好地知道 now 实例的内容,但是却丢失了 now 实例的数据类型信息;而通过 repr() 的输出结果我们不仅能获得 now 实例的内容,还能知道 now 是 datetime.datetime 对象的实例。
对比:
str() 的输出追求可读性,输出格式要便于理解,适合用于输出内容到用户终端。
repr() 的输出追求明确性,除了对象内容,还需要展示出对象的数据类型信息,适合开发和调试阶段使用。
# repr() 、str() Sample
print(repr(123)) # 123
print(str(123)) #123
print(type(repr(123)), type(str(123))) # <class 'str'> <class 'str'>
print(repr('hellopython')) # 'hellopython'
print(str('hellopython')) # hellopython
import datetime
print(str(datetime.datetime.now())) # 2020-02-23 16:38:02.758207
print(repr(datetime.datetime.now())) # datetime.datetime(2020, 2, 23, 16, 38, 2, 758207)
55、reversed() 方法
作用:反转元组、列字符串、range等序列,返回的是一个迭代器。经常配合list()或for使用。
# reversed() Sample
# 反转字符串
print(list((reversed('123456')))) # ['6', '5', '4', '3', '2', '1']
# 反转元组
print(list(reversed(('d','l','r','o','w')))) # ['w', 'o', 'r', 'l', 'd']
# 反转 range对象
print(list(reversed(range(5)))) # [4, 3, 2, 1, 0]
56、round() 方法
作用:返回浮点数的四舍五入值,能传递两个参数,第二个参数可以设置数据保留的从小数点位数,默认为0。当只传递1个参数是返回的值是整型,第2个参数不为0时,返回的值是浮点型。
# round() Sample
print(round(5.1)) # 5
print(round(5.5)) # 6
print(round(5.654321, 1)) # 5.7
print(round(5.654321, 2)) # 5.65
print(round(5.654321, 3)) # 5.654
print(round(5.654321, 4)) # 5.6543
# 注意:第二个参数是保留从小数点位数,不同于保留到小数点后几位:
print(round(5.000012, 1)) # 5.0
print(round(5.000012, 2)) # 5.0
print(round(5.000012, 3)) # 5.0
print(round(5.000012, 4)) # 5.0
print(round(5.000012, 5)) # 5.00001
57、set() 方法
作用:创建一个无序的没有重复值的元素集,可以用来进行关系测试,删除重复数据,计算交集、差集、并集等。
# set() Sample
a = 'hello'
b = 'world'
# 打印a、b集合,重复值被自动删除,且无序排列:
print(set(a)) # {'l', 'h', 'o', 'e'}
print(set(b)) # {'l', 'o', 'w', 'r', 'd'}
# 计算交集:
print(set(a) & set(b)) # {'l', 'o'}
# 计算并集:
print(set(a) | set(b)) # {'l', 'o', 'w', 'h', 'e', 'r', 'd'}
# 计算差集:
print(set(a) - set(b)) # {'h', 'e'}
58、setattr() 方法
作用:对属性赋值,如果该属性不存在,则会新建一个对象属性并进行赋值。
# setattr() Spamle
class A():
attr1=1
a = A()
print(a.attr1) # 1
setattr(a,'attrl',15)
print(getattr(a,'attr1'))
# 尝试给一个不存在的属性附值:
setattr(a, 'attr2', 20)
print(a.attr2) # 20
59、slice() 方法
作用:用于切片操作,返回一个切片对象。不过小编想不通它存在的意义是什么,用它切片似乎比数据类型的内置方式切片更麻烦。
# slice() Sample
qiepian = slice(5) # 切5个元素
# 对range(10)进行切片:
print(range(10)[qiepian]) # range(0, 5)
# 打印切片后的数据:
for i in range(10)[qiepian]:
print(i,end=' ') # 0 1 2 3 4
60、sorted() 方法
作用:对可迭代对象进行排序,默认升序,可以通过reverse参数设置排序方式。它返回的是一个新的列表而不会修改原列表。list中的内置sort()方法只能对已经存在的列表进行操作且会修改原列表。
# sorted() Sample
a = [5,1,6,9,7,3,2,1]
# 升序
print(sorted(a)) # [1, 1, 2, 3, 5, 6, 7, 9]
# 降序
print(sorted(a,reverse=True)) # [9, 7, 6, 5, 3, 2, 1, 1]
61、staticmethod() 方法
作用:声明一个静态方法。静态方法的优点在于不需要实例化。参数为一个方法名,亦可以不传参数。
# staticmethod Sample
class A(object):
@staticmethod # 声明静态方法
def a():
print('hello python')
# 静态方法无需实例化 :
A.a() # hello python
# 也可以实例化后调用 :
b = A()
b.a() # hello python
62、str() 方法
作用:str() 的输出结果我们能很好地知道 now 实例的内容,但是却丢失了 now 实例的数据类型信息;而通过 repr() 的输出结果我们不仅能获得 now 实例的内容,还能知道 now 是 datetime.datetime 对象的实例。
对比:
str() 的输出追求可读性,输出格式要便于理解,适合用于输出内容到用户终端。
repr() 的输出追求明确性,除了对象内容,还需要展示出对象的数据类型信息,适合开发和调试阶段使用。
# repr() 、str() Sample
print(repr(123)) # 123
print(str(123)) #123
print(type(repr(123)), type(str(123))) # <class 'str'> <class 'str'>
print(repr('hellopython')) # 'hellopython'
print(str('hellopython')) # hellopython
import datetime
print(str(datetime.datetime.now())) # 2020-02-23 16:38:02.758207
print(repr(datetime.datetime.now())) # datetime.datetime(2020, 2, 23, 16, 38, 2, 758207)
63、sum() 方法
作用:求和计算,第1个参数是可迭代对象如列表集合元组等,第2个参数是对前一个参数求和后再指定相加的数。
# sum() Sample
# 对列表元素求和:
print(sum([1,3,5,7,9])) # 25
# 对列表元素求和后再加1:
print(sum([2,4,6,8,10],1)) # 31
64、super() 方法
作用:用来解决多重继承问题。直接用类名调用父类方法在使用单继承的时候不会出现问题,但是如果使用多继承,会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。MRO 是类的方法解析顺序表, 其实就是继承父类方法时的顺序表。super() 函数用于调用父类(基类)。
class A:
def add(self, x):
y = x+1
print(y)
class B(A):
def add(self, x):
super().add(x)
b = B()
b.add(2) # 3
65、tuple() 方法
作用:将可迭代对象转换为元组。
# tuple() Sample
a = [1,2,3,4,5]
print(tuple(a)) # (1, 2, 3, 4, 5)
66、type() 方法
作用:返回对象的类型。与isinstance()相似,区别是:type() 不会认为子类是一种父类类型,不考虑继承关系。isinstance() 会认为子类是一种父类类型,考虑继承关系。因此如果要判断两个类型是否相同推荐使用 isinstance()。
# type() Sample
a = 1
b = (1,)
c = [1,2]
class A:
pass
def d():
pass
print(type(a),type(b),type(c),type(A),type(d),sep='|')
# 结果:<class 'int'>|<class 'tuple'>|<class 'list'>|<class 'type'>|<class 'function'>
67、vars() 方法
作用:返回对象object的属性和属性值的字典对象。如果没有参数,就打印当前调用位置的属性和属性值。与 locals()相似。
# vars() Sample
print(vars())
class A:
def a(self,m):
reversed(m)
pass
print(vars(A))
68、zip() 方法
作用:用于节约内存,将可迭代对象打包成一个元组,并返回由元组组成的对象,一般用list将返回的对象进行转换。如果各个迭代器的元素个数不一致,则返回列表的长度与最短的对象长度相同,利用 * 号操作符(即zip(*)),可以将元组解包为原列表。
# zip Sample
a = [1,2,3,4,5]
b = [0,6,7,8,9,10]
print(list(zip(a,b))) # 打包
# [(1, 0), (2, 6), (3, 7), (4, 8), (5, 9)]
print(list(zip(*zip(a,b)))) # 解包
# [(1, 2, 3, 4, 5), (0, 6, 7, 8, 9)]
a1, b1 = zip(*zip(a,b))
print(a1, b1,sep='\n')
"""
(1, 2, 3, 4, 5)
(0, 6, 7, 8, 9)
"""
69、__import__() 方法
作用:用于动态加载类和函数 。如果一个模块经常变化就可以用它来动态载入。
# 假设存在一个模块为:test.py,想用__import__导入:
import os # 导入 os
import sys # 导入 sys
__import__'test' # 导入 test
啊))) )) ) ) 磨磨蹭蹭,终于写完了。
看到了这儿的小伙伴先别走,留个赞呀❤️
最后
推荐阅读:
Python内置方法解析官方文档(英文)【打开有点慢,需耐心等待】
https://docs.python.org/3/library/functions.html?highlight=built