Python内置函数大全

您所在的位置：网站首页 › 电脑版微信更改字体大小 › Python内置函数大全

Python内置函数大全

2023-06-13 12:29| 来源: 网络整理| 查看: 265

1. 帮助类

help_查看模块/函数的帮助手册

dir_查看模块内的所有属性、方法

2. 数据类型

int_整型

float_浮点数

str_字符串

list_列表

tuple_元组

dict_字典

set_可变集合

frozenset_不可变集合

3 数字类

abs_绝对值

range_迭代整数

sorted_排序

4. 算术类

divmod_除法运算

pow_幂运算

round_四舍五入

5. 转换类

reversed_元素反转

zip_合并多个对象

ascii_转换ascii码

chr_转换为整数的ascii字符

bin_十进制转换为二进制

oct_十进制转换为八进制

hex_十进制转换为十六进制

hash_转换为hash值

bytearray_转换为字节组成的可变序列

6. 删除类

delattr_删除类属性

7. 统计类

len_统计长度

sum_求和

max_统计最大值

min_统计最小值

8. 判断类

isinstance_判断类型是否正确

all_判断元素True

any_判断元素False

bool_返回布尔值

callable_判断对象是否能够调用

hasattr_判断类中是否存在某个方法/属性

issubclass_判断子类与类的关系

9. 条件过滤

filter_函数条件过滤

iter_标记一个可迭代对象

10. 迭代类

map_迭代计算（速度快）

next_迭代中依次取值

enumerate_输出序号

11. 类与函数

super_子类调用父类

setattr_改变属性值

getattr_类方法中获取另一个方法

12. 装饰符

@classmethod

@staticmethod

13. 输出类

print_输出字符串

format_格式化输出

type_输出类型

eval

vars_输出类属性/本地属性

globals_获取全局对象

locals_输出局部变量

id_输出对象的唯一标识符

14. 交互类

input_界面交互

15. 文件类

open_打开文件

1. 帮助类 help_查看模块/函数的帮助手册

语法

help([模块|函数])

用于查看某个模块或函数的用法

查看内置函数list帮助 print(help(list)) 查看模块time帮助 print(help(time))

注意：查看某个模块帮助时需要导入该模块，如果不导入需要使用字符串方法查看

导入模块 import time print(help(time)) 不导入模块 print(help('time'))

dir_查看模块内的所有属性、方法 >>> import time >>> print(dir(time)) ['_STRUCT_TM_ITEMS', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'altzone', 'asctime', 'ctime', 'daylight', 'get_clock_info', 'gmtime', 'localtime', 'mktime', 'monotonic', 'monotonic_ns', 'perf_counter', 'perf_counter_ns', 'process_time', 'process_time_ns', 'sleep', 'strftime', 'strptime', 'struct_time', 'thread_time', 'thread_time_ns', 'time', 'time_ns', 'timezone', 'tzname']

2. 数据类型 int_整型

语法

int([数字|字符串])

将字符串或数字转换为整型

>>> print(int('100')) >>> print(int(1.2)) >>> print(int(1.9)) 100 1 1 字符串类必须是数字数字可以是浮点数，转换后相当于去除小数点

float_浮点数

语法

float([字符]) -这个字符可以是：数字、字符串 -作用是将对象转换为浮点数，但必须是数字类型 #转换整型为浮点数 >>> print(float(2)) 2 #转换字符串为浮点数 >>> print(float('1.2')) 1.2 >>> print(float('-1.2')) -1.2 >>> print(float('+1.2')) 1.2 >>> print(float('a')) ValueError: could not convert string to float: 'a'

str_字符串

语法

str([对象])

创建一个字符串

S = str() S = 'abc'

将其他对象转换为字符串

#转换数字 >>> print(str(1)) >>> print(type(str(1))) 1 #转换列表 >>> L = [1, 2, 'a', 'b'] >>> print(str(L)) [1, 2, 'a', 'b'] >>> print(type(str(L))) #转换元组 >>> T = (3, 4, 'c', 'd') >>> print(str(T)) (3, 4, 'c', 'd') >>> print(type(str(T))) #转换字典 >>> D = {'name':'小明', 'age':18} >>> print(str(D)) {'name': '小明', 'age': 18} >>> print(type(str(D))) #转换集合 >>> S = {5, 6, 'e', 'f'} >>> print(str(S)) {'f', 5, 'e', 6} >>> print(type(str(S)))

list_列表

语法

list([对象]) 定义一个空列表 >>> L = list() >>> print(type(L)) 定义一个0-9的整数列表 >>> S = [i for i in range(10)] >>> print(S) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 定义一个0-9的偶数列表 >>> S = [i for i in range(10) if i%2==0] >>> print(S) [0, 2, 4, 6, 8] 定义一个0-9的奇数列表 >>> S = [i for i in range(10) if i%2!=0] >>> print(S) [1, 3, 5, 7, 9] 将字符串转换为列表 >>> S = 'abc' >>> L = list(S) >>> print(L) ['a', 'b', 'c'] 将元组转换为列表 >>> T = ('a', 'b', 'c') >>> L = list(T) >>> print(L) ['a', 'b', 'c'] 将集合转换为列表(无序转换) >>> S = {'a', 'b', 'c'} >>> L = list(S) >>> print(L) ['b', 'c', 'a'] 将字典转换为列表(仅有键，没有值) >>> D = {'a':1, 'b':2} >>> L = list(D) >>> print(L) ['a', 'b']

tuple_元组

创建一个元组

T = tuple() T = (1, ) #必须有逗号，否则只识别为int或str

转换其他对象为元组

#转换列表 >>> L = [1, 2, 'a', 'b'] >>> print(tuple(L)) (1, 2, 'a', 'b') #转换字典（只取键） >>> D = {'name':'小明', 'age':18} >>> print(tuple(D)) ('name', 'age') #转换集合 >>> S = {5, 6, 'e', 'f'} >>> print(tuple(S)) (5, 'e', 'f', 6)

dict_字典

创建一个字典

D1 = dict() D2 = {'姓名':'小李' , '年龄':18}

将列表转换为字典

>>> L1 = ['姓名', '年龄'] >>> L2 = ['小王', 10] >>> D = dict(zip(L1, L2)) >>> print(D) {'姓名': '小王', '年龄': 10}

set_可变集合

创建一个新集合

S = set() #空的集合 S = {'a', 'b', 'c'}

去重（去掉列表的重复值，并以集合返回）

>>> L = [1, 1, 2, 2] >>> print(set(L)) {1, 2}

两个集合之间的操作

>>> S1 = {'a', 'b', 'c'} >>> S2 = {'c', 'd', 'e'} #S1 交 S2（取相同的值） >>> print(S1 & S2) {'c'} #S1 并 S2（取全部值，并去重） >>> print(S1 | S2) {'b', 'd', 'e', 'c', 'a'} #S1 - S2 求差集（保留S1且不包含S2的值） >>> print(S1 - S2) {'a', 'b'}

frozenset_不可变集合

创建一个不可变集合

>>> L = [1, 2, 3] >>> S = frozenset(L) >>> S.add(4) AttributeError: 'frozenset' object has no attribute 'add'

可变集合需要使用set

>>> L = [1, 2, 3] >>> S = set(L) >>> S.add(4) >>> print(S) {1, 2, 3, 4}

3 数字类 abs_绝对值

语法

abs( [数字] )

返回数字绝对值

>>> print(abs(1)) 1 >>> print(abs(-1)) 1 >>> print(abs(-1.1)) 1.1 >>> print(abs(1.1)) 1.1

range_迭代整数

语法

range([结束大小]) #默认开始大小为0 range([开始大小] , [结束大小]) range([开始大小] , [结束大小] , [步长]) -不输出结束大小值

开始大小使用默认值（从0开始，不包含结束值）

>>> for i in range(3): print(i) 0 1 2 >>> for i in range(-3): print(i) 空

指定开始与结束

>>> for i in range(1, 3): print(i) 1 2 >>> for i in range(-3, -1): print(i) -3 -2

指定步长

>>> for i in range(-10, -1, 2): print(i) -10 -8 -6 -4 -2 >>> for i in range(1, 10, 2): print(i) 1 3 5 7 9

sorted_排序

语法

sorted([可迭代对象] , key=None, reverse=False)

升序

>>> L = [2, 5, 1, 4] >>> L.sort() >>> print(L) [1, 2, 4, 5] >>> L = [2, 5, 1, 4] >>> print(sorted(L)) [1, 2, 4, 5] >>> L = [2, 5, 1, 4] >>> print(sorted(L, reverse=False)) [1, 2, 4, 5]

降序

>>> L = [2, 5, 1, 4] >>> print(sorted(L, reverse=True)) [5, 4, 2, 1]

4. 算术类 divmod_除法运算

语法

divmod([被除数] , [除数])

除法运算，返回结果和余数

>>> print(divmod(10,6)) (1, 4) >>> print(divmod(10,5)) (2, 0) >>> print(divmod(10,4)) (2, 2)

pow_幂运算

语法

pow([数字] , [前数字的n次方]) pow([数字] , [前数字的n次方] , [n次方后取余])

取数字的n次方

>>> print(pow(2, 2)) 4 >>> print(pow(2.1, 2)) 4.41

取数字的n次方之后，再求余

>>> print(pow(3, 2, 2)) # 3² % 2 = 1 1 >>> print(pow(3, 2, 3)) # 3² % 3 = 0 0

round_四舍五入

语法

round([数字]) round([数字] , [精确位])

四舍五入到整数

>>> print(round(1.501)) 2

指定精确后的位数

>>> print(round(1.51323, 1)) >>> print(round(1.51323, 2)) 1.5 1.51

5. 转换类 reversed_元素反转

反转列表、元组

>>> L = [1, 2, 3] >>> print(list(reversed(L))) [3, 2, 1] >>> T = (4, 5, 6) >>> print(tuple(reversed(T))) (6, 5, 4)

反转整数、字符串（需要用for循环去迭代）

>>> for i in reversed(range(3)): print(i) 2 1 0 >>> for i in reversed('abc'): print(i) c b a

zip_合并多个对象

语法

zip([可迭代对象]) zip([可迭代对象1] , [可迭代对象2] , [可迭代对象3] ...) zip([可迭代对象] , [strict=False]) #默认 zip([可迭代对象] , [strict=True]) #多个迭代对象的长度不一，直接报错 zip对象产生长度为n的元组，其中n是作为位置参数传递给zip()的可迭代对象的数量。每个元组中的第i个元素来自zip()的第i个可迭代参数。这种情况一直持续到最短的论证被用尽为止。 >>> a = [1, 2, 3] >>> b = ['a', 'b', 'c'] >>> c = ['x', 'y', 'z'] >>> print(zip(a,b)) >>> print(list(zip(a,b))) >>> print(list(zip(a,b,c))) [(1, 'a'), (2, 'b'), (3, 'c')] [(1, 'a', 'x'), (2, 'b', 'y'), (3, 'c', 'z')] >>> a = [1, 2, 3] >>> b = ['a', 'b', 'c'] >>> c = ['x', 'y', 'z'] >>> for i in zip(a,b,c): print(i) (1, 'a', 'x') (2, 'b', 'y') (3, 'c', 'z')

如果迭代对象的长度不一，那么去最短

>>> a = [1, 2, 3, 4, 5] >>> b = ['a', 'b', 'c', 'd'] >>> c = ['x', 'y', 'z'] >>> print(list(zip(a,b,c))) [(1, 'a', 'x'), (2, 'b', 'y'), (3, 'c', 'z')]

指定 strict = True，多个迭代长度不一直接报错

>>> a = [1, 2, 3, 4, 5] >>> b = ['a', 'b', 'c', 'd'] >>> c = ['x', 'y', 'z'] >>> print(list(zip(a,b,c, strict=True))) ValueError: zip() argument 3 is shorter than arguments 1-2

ascii_转换ascii码

返回字符串

>>> print(type(ascii([1, 2])))

chr_转换为整数的ascii字符

语法

chr([整数])

返回整数的ascii字符

#二进制 print(chr(0b1010)) #八进制 print(chr(0o765)) #十进制 print(chr(123)) #十六进制 print(chr(0xa12)) 二进制以 0b 开头八进制以 0o 开头十进制不允许以0开头十六进制以 0x 开头

bin_十进制转换为二进制

语法

bin([整数]) -整数的范围：-2147483648~2147483647

返回该整数的二进位

>>> print(bin(1)) 0b1 >>> print(bin(10)) 0b1010 >>> print(bin(100)) 0b1100100 ob 表示二进制的类型

oct_十进制转换为八进制

语法

oct([整数])

将十进制整数转换为八进制的字符串

#查看类型 >>> print(type(oct(10))) #查看转换结果 >>> print(oct(10)) 0o12 以 0o 开头表示八进制

hex_十进制转换为十六进制

语法

hex([10进制整数])

将10进制整数转换为16进制

>>> print(hex(10)) 0xa >>> print(hex(16)) 0x10 >>> print(hex(17)) 0x11

hash_转换为hash值 hash([转换对象]) -转换对象可以是：整数、字符串

转换为hash值

>>> print(hash(1)) >>> print(hash('a')) 1 3869121393747474575

值得注意的是：在脚本内转换的同一个字符串的hash值是相同的，但是运行2次不同的脚本却是不同的值

同一个脚本内打印2次a的hash值 >>> print(hash('a')) 3869121393747474575 >>> print(hash('a')) 3869121393747474575 运行2次脚本，产出不同的hash值 C:\PycharmProjects\pythonProject\Locust\Test>python tmp.py 6160486946406353165 6160486946406353165 C:\PycharmProjects\pythonProject\Locust\Test>python tmp.py -8317089465969170010 -8317089465969170010

bytearray_转换为字节组成的可变序列

语法

bytearray([整数]) bytearray([字符串] , [编码])

字节组成的有序的可变序列（可变数组每个元素的值范围: 0 >> print(bytearray(1)) bytearray(b'\x00') >>> print(bytearray(2)) bytearray(b'\x00\x00') >>> print(bytearray(3)) bytearray(b'\x00\x00\x00') >>> print(bytearray('a', 'UTF-8')) bytearray(b'a') >>> print(bytearray('aa', 'UTF-8')) bytearray(b'aa') >>> print(bytearray('aaa', 'UTF-8')) bytearray(b'aaa') >>> for i in bytearray('abc', 'UTF-8'): print(i) 97 98 99

bytes()

bytes与bytearry类似，只不过bytes是字节组成的有序不可变序列，bytearry是字节组成的有序可变序列

6. 删除类 delattr_删除类属性

语法

delattr([对象] , [属性名])

删除一个类属性

class MyClass: a = 1 b = 2 C = MyClass print(C.a) delattr(C, 'a') print(C.a)

结果

1 AttributeError: type object 'MyClass' has no attribute 'a'

7. 统计类 len_统计长度

语法

len([对象]) -对象可以是：字符串、列表、元组、字典、集合

返回长度

>>> print(len('abc')) #字符串 3 >>> print(len('a, b, c')) #字符串 7 >>> print(len([1, 2, 3])) #列表 3 >>> print(len((1, 2, 3))) #元组 3 >>> print(len({'a':1, 'b':2})) #字典 2 >>> print(len({1, 2, 3})) #集合 3

sum_求和

语法

sum([对象]) sum([对象] , [数字]) #对象相加的和+数字

求和的参数必须是一个对象（列表、元组、字典、集合）

>>> L = [1, 2, 3] >>> print(sum(L)) 6 >>> T = [4, 5, 6] >>> print(sum(T)) 15 >>> D = {1:'小明', 2:'小王'} >>> print(sum(D)) 3 >>> S = {7, 8, 9} >>> print(sum(S)) 24

对象求和后再加n

>>> L = [1, 2, 3] >>> print(sum(L, 4.4)) 10.4

但是对象不能加对象

>>> L = [1, 2, 3] >>> print(sum(L, L)) TypeError: can only concatenate list (not "int") to list

可以通过numpy库求和

>>> import numpy >>> L = [1, 2, 3] >>> print(numpy.sum([L, L])) 12 单个数值相加 >>> print(numpy.sum([L, L], axis=0)) [2 4 6] >>> for i in numpy.sum([L, L], axis=0): print(i) 2 4 6 求连个列表各自的和 >>> print(numpy.sum([L, L], axis=1)) [6 6]

max_统计最大值

语法

max([可迭代对象] , *[[默认值]|[key]]) -可迭代对象可以是：列表、元组、字典、集合 -对于单个可迭代参数，返回其最大项。 -如果可迭代对象为空，则默认的使用[默认值]指定的值。 max([变量1] , [变量2] , [变量3]) -如果有两个或多个参数，则返回最大的参数。 #直接比较 >>> print(max([20, -30, 10])) 20 #多个迭代对象比较id值 >>> L1 = [3, 6, 7] >>> L2 = [4, 5, 6] >>> print('L1(id):{}, L2(id):{}'.format(id(L1), id(L2))) >>> print(max(L1, L2)) L1(id):2584700482944, L2(id):2584703308672 [4, 5, 6] #比较字典 >>> D = {'小李':18, '小王':20} >>> print(max(D)) 小王 #使用key >>> L = [1, -4, 3, 2] >>> print(max(L, key=lambda n: abs(n))) -4 #使用default >>> print(max([], default=1)) 1 min_统计最小值

语法

min([可迭代对象] , *[[默认值]|[key]]) -可迭代对象可以是：列表、元组、字典、集合 -对于单个可迭代参数，返回其最小项。 -如果可迭代对象为空，则默认的使用[默认值]指定的值。 min([变量1] , [变量2] , [变量3]) -如果有两个或多个参数，则返回最小的参数。 #直接比较 >>> print(min([20, -30, 10])) -30 #比较多个迭代对象，按id值比较 >>> L1 = [3, 6, 7] >>> L2 = [4, 5, 6] >>> print('L1(id):{}, L2(id):{}'.format(id(L1), id(L2))) >>> print(min(L1, L2)) L1(id):1920421623168, L2(id):1920424448896 [3, 6, 7] #比较字典 >>> D = {'小李':18, '小王':20} >>> print(min(D)) 小李 #使用key >>> L = [1, -4, 3, 2] >>> print(min(L, key=lambda n: abs(n))) 1 #使用default >>> print(min([], default=1)) 1

8. 判断类 isinstance_判断类型是否正确

语法

isinstance([判断对象] , [判断类型])

判断某个对象的类型（返回True和False）

>>> print(isinstance(123, int)) >>> print(isinstance('abc',str)) >>> print(isinstance([1,2], list)) >>> print(isinstance((1,2), tuple)) >>> print(isinstance({'a':1}, dict)) >>> print(isinstance({1,2}, set)) True True True True True True

判断某个对象是多个类型

判断这个对象是int或者str类型 >>> print(isinstance(1, (int, str))) True >>> print(isinstance([1,2], (int, str))) False

all_判断元素True

语法

all( [判断类型] ) -判断类型可以是列表或元组 -判断元素是否为True，如果存在 False、0、None、空值，则返回False

只要存在一个False，那么都是False。否则True

>>> print(all([1, 2, 3])) True >>> print(all(['a', 'b', 'c'])) True >>> print(all([1, 2, 'a', 'b'])) True >>> print(all([0, 1, 2])) False >>> print(all(['', 'b', 'c'])) False >>> print(all([None, 'b', 'c'])) False >>> print(all([False, 'b', 'c'])) False

any_判断元素False

语法

any( [判断类型] ) -判断类型可以是列表或元组 -判断元素是否为False，如果全部为 False、0、None、空值，则返回False，否则返回True

必须全部为False，才返回False。否则True

>>> print(any([1, 2, 'a', 'b'])) True >>> print(any([0, 2, 'a', 'b'])) True >>> print(any([0, None, ' '])) True >>> print(any([0])) False >>> print(any([0, None])) False >>> print(any([0, None, ''])) False >>> print(any([0, None, '', False])) False

bool_返回布尔值

语法

bool([条件]) -根据条件返回True或False

返回一个条件的真假（0、None、空、False为假）

>>> print(bool(1)) True >>> print(bool('a')) True >>> print(bool(' ')) True >>> print(bool(3>2)) True >>> print(bool(1>2)) False >>> print(bool(0)) False >>> print(bool(None)) False >>> print(bool('')) False >>> print(bool(False)) False

callable_判断对象是否能够调用

语法

callable([对象])

判断这个对象是否可调用（对象可以是函数、类）

#列表不可调用，返回False >>> L = [1, 2, 3] >>> print(callable(L)) False #函数，可调用 >>> def func1(): return True >>> print(callable(func1)) True #函数返回False，仍然可调用 >>> def func1(): return False >>> print(callable(func1)) True 如果返回False，该对象无法调用；如果返回True，该对象可以调用，但也可能无法调用

hasattr_判断类中是否存在某个方法/属性

语法

hasattr([实例对象] , [方法|属性])

判断是否存在某个属性名或方法

class MyClass(): a = 1 #True def __init__(self): self.b = 2 #True c = 3 #False def func1(self): d = 4 #False def func2(self): self.e = 5 #False >>> print(hasattr(MyClass(), 'a')) True >>> print(hasattr(MyClass(), 'b')) True >>> print(hasattr(MyClass(), 'c')) False >>> print(hasattr(MyClass(), 'd')) False >>> print(hasattr(MyClass(), 'e')) False >>> print(hasattr(MyClass(), 'func1')) True >>> print(hasattr(MyClass().func1(), 'd')) False >>> print(hasattr(MyClass().func2(), 'e')) False

issubclass_判断子类与类的关系

语法

issubclass([子类] , [类])

判断一个类是不是另一个类的子类

>>> class A(): pass >>> class B(A): pass >>> print(issubclass(B, A)) True >>> print(issubclass(A, B)) False 类的本身也是它的子类 >>> print(issubclass(A, A)) True

9. 条件过滤 filter_函数条件过滤

语法

filter([函数] , [可迭代对象])

过滤出满足条件的值

给定一个函数，判断一个对象（判断类型根据实际业务编写） >>> L = [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> def judge(n): return n % 2 == 0 >>> print(list(filter(judge, L))) [2, 4, 6, 8] 直接给定判断条件 >>> L = [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> print(list(filter(lambda i: i%2==0, L))) [2, 4, 6, 8] 仅返回某个列表为真的值（使用None或bool） >>> L = [1, 2, 3, '', None, 'a'] >>> print(list(filter(None, L))) [1, 2, 3, 'a'] >>> print(list(filter(bool, L))) [1, 2, 3, 'a']

iter_标记一个可迭代对象

语法

iter([可迭代对象]) #实参必须提供自己的迭代器，或者是一个序列 iter([可调用对象] , [标记]) #调用可调用对象直到它返回标记

仅传入一个参数（该参数必须是可迭代对象）

正确示例 >>> L = [1, 2, 3, 4, 5] >>> for i in iter(L): print(i) 1 2 3 4 5 错误示例 >>> L = 1 >>> for i in iter(L): print(i) TypeError: 'int' object is not iterable

传入2个参数（ [迭代对象] , [标记停止迭代] ）

正确示例 >>> import random >>> def func1(): return random.randint(1,5) >>> for i in iter(func1, 2): #迭代对象func1返回一个随机值，标记为2。只要没有出现2就会一直迭代 print('func1的值为:{}，持续迭代'.format(i)) func1的值为:3，持续迭代 func1的值为:4，持续迭代 func1的值为:4，持续迭代错误示例 >>> L = [1, 2, 3, 4, 5] >>> for i in iter(L, 2): print(i) TypeError: iter(v, w): v must be callable

10. 迭代类 map_迭代计算（速度快）创建一个迭代器，使用来自每个可迭代对象的参数计算函数。当最短可迭代对象耗尽时停止（速度比for循环更快）

语法

map([函数], *[可迭代对象])

举个for循环迭代的例子

>>> L1 = [1, 2, 3] >>> L2 = [i*2 for i in L1] >>> print(L2) [2, 4, 6]

使用map通过函数来迭代

#例1： >>> L1 = [1, 2, 3] >>> def func1(n): return n * 2 >>> L2 = list(map(func1, L1)) >>> print(L2) [2, 4, 6] #例2 >>> L1 = [1, 2, 3] >>> L2 = list(map((lambda n: n*2), L1)) >>> print(L2) [2, 4, 6]

传入多个参数（最短迭代耗尽即停止）

#例1: >>> L1 = [1, 2, 3] >>> L2 = [1, 2, 3] >>> L3 = [1, 2, 3] >>> def func1(a, b, c): return a + b + c >>> L = list(map(func1,L1,L2,L3)) >>> print(L) [3, 6, 9] #例2: >>> L1 = [1, 2, 3] >>> L2 = [1, 2, 3] >>> L3 = [1, 2] >>> def func1(a, b, c): return a + b + c >>> L = list(map(func1,L1,L2,L3)) >>> print(L) [3, 6]

也可以迭代转换类型

列表中整数转换为字符串类型 >>> L1 = [1, 2, 3] >>> L2 = list(map(str, L1)) >>> print(L2) ['1', '2', '3'] 列表中整数转换为浮点数类型 >>> L1 = [1, 2, 3] >>> L2 = list(map(float, L1)) >>> print(L2) [1.0, 2.0, 3.0]

next_迭代中依次取值

语法

next([可迭代对象]) next([可迭代对象] , [默认值]) 从迭代器返回下一项。如果给出了default，迭代器耗尽，则返回它而不是引发StopIteration。

每个抽取一个迭代对象的值

>>> S = iter('abc') >>> print(next(S)) >>> print(next(S)) >>> print(next(S)) >>> print(next(S)) a b c 异常：StopIteration 由于每次只抽取一个值，for循环也只能循环一个值 >>> S = iter('abc') >>> for i in next(S): print(i) a

使用默认值

>>> S = iter('ab') >>> print(next(S,1)) >>> print(next(S,1)) >>> print(next(S,1)) >>> print(next(S,1)) a b 1 1

enumerate_输出序号

语法

enumerate([对象] , [起始值]) -起始值默认0

遍历列表，序列从0开始

>>> L = ['a', 'b', 'c', 'd'] >>> for i in enumerate(L): print(i) (0, 'a') (1, 'b') (2, 'c') (3, 'd')

遍历列表，序列从1开始

>>> L = ['a', 'b', 'c', 'd'] >>> for i in enumerate(L): print(i) (1, 'a') (2, 'b') (3, 'c') (4, 'd')

序列与值分开赋值

>>> L = ['a', 'b', 'c', 'd'] >>> for i,j in enumerate(L): print(i) 0 1 2 3 >>> L = ['a', 'b', 'c', 'd'] >>> for i,j in enumerate(L): print(j) a b c d

11. 类与函数 super_子类调用父类 >>> class MyClass1(): def func1(self): print('111') >>> class Myclass2(MyClass1): def func2(self): super().func1() >>> Myclass2().func2() 111

setattr_改变属性值

语法

setattr([对象名] , [属性名] , [值])

改变属性值

>>> class MyClass: a = 'abc' >>> setattr(MyClass, 'a', 'cba') >>> print(MyClass.a) cba

当某个属性不存在时，增加一个属性

>>> class MyClass: a = 'abc' >>> setattr(MyClass, 'b', 'BBB') >>> print(MyClass.b) BBB

getattr_类方法中获取另一个方法

从对象获取命名属性

class MyClass: a = 1 def func1(self): print('这是一个函数') def func2(self): f = getattr(self, 'func1') f() 获取对象属性 >>> print(getattr(MyClass, 'a')) 1 调用func2，函数中使用getattr获取func1 >>> MyClass().func2() 这是一个函数

12. 装饰符 @classmethod

语法

@classmethod [定义函数] ......

修饰符的函数不用实例化，也不需要self参数。第一个参数需要表示自身类（cls），可以来调用类的属性、方法、实例化对象。

class S(object): num = 10 #直接定义变量 def func1(self): print('func1:', self.num) #未使用修饰器需要self调用 @classmethod def func2(cls): print('func2:', cls.num) #使用修饰器使用cls调用 cls().func1() #使用修饰器使用cls调用 S().func2()

@staticmethod 将函数转换为静态方法，不接受隐式的第一个参数。

不使用静态装饰器（调用方法需要实例化）

>>> class MyClass(): def func1(self, n): print(n) >>> MyClass().func1(1) 1

使用静态装饰器后（不需要第一个参数为self，也不需要实例化对象）

>>> class MyClass(): @staticmethod def func1(n): print(n) >>> MyClass.func1(1) 1

定义了一个静态的方法后，它属于一个独立的函数，无法调用其他属性，其他方法也不能调用该静态函数

#错误示例1 >>> class MyClass(): def __init__(self): n = 10 @staticmethod def func1(): print(self.n) >>> MyClass.func1() NameError: name 'self' is not defined #错误示例2 >>> class MyClass(): def __init__(self): n = 10 @staticmethod def func1(): #此时的n是独立的，在调用func1时传入一个参数 print(n) >>> MyClass.func1() NameError: name 'n' is not defined #错误示例3 >>> class MyClass(): n = 10 @staticmethod def func1(): #此时的n是独立的，在调用func1时传入一个参数 print(n) >>> MyClass.func1() NameError: name 'n' is not defined

13. 输出类 print_输出字符串

语法

print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False) 可选说明 -sep:值之间插入的字符串，默认为空格。 -end:附加在最后一个值之后的字符串，默认为换行符。 -file:类文件对象(流);默认为sys.stdout。 -flush:是否强制冲洗流。

常见使用方法

>>> print('abc') >>> print('a' 'b' 'c') >>> print('a','b','c') abc abc a b c

指定值之间的间隔符（默认空格）

>>> print('a','b','c') >>> print('a','b','c',sep='+') a b c a+b+c

指定最后一个字符后面的符号（默认换行）

>>> for i in range(1,6): print(i, end=',') 1,2,3,4,5,

等待n秒，每秒动态打印一个字符

import time def Loading(wait, interval): print("等待{}s".format(wait), end = "") for i in range(int(wait / interval)): print(".", end = '', flush = True) time.sleep(interval) print('\n等待结束') Loading(10,2) #总等待10s，每隔2s动态输出一个字符

format_格式化输出

格式化字符串

#按顺序格式化字符串 >>> print('1+1={}, 1*1={}'.format('a', 'b')) 1+1=a, 1*1=b #按索引格式化字符串 >>> print('1+1={1}, 1*1={0}'.format('a', 'b')) 1+1=b, 1*1=a #按命名指定格式化字符串 >>> print('1+1={A}, 1*1={B}'.format(A=2, B=1)) 1+1=2, 1*1=1 #可变长列表添加字符串（包括元组） >>> L = ['a', 'b', 'c'] >>> print('1:{}, 2:{}, 3:{}'.format(*L)) 1:a, 2:b, 3:c #指定某个列表中的索引 >>> L = ['a', 'b', 'c'] >>> print('1:{[2]}, 2:{[1]}, 3:{[0]}'.format(L,L,L)) 1:c, 2:b, 3:a #截取字符串长度（指定2位） print('{:.2}'.format('abcde')) #截取浮点数长度（指定3位） >>> print('{:.3f}'.format(2.01023)) 2.010 #小数转换百分号（指定2位小数） >>> print('{:.2%}'.format(0.321353)) 32.14% #用0补齐左边为三位数，对象必须是整数（0可以为任意字符串，位数可以指定） >>> print('{:0>3d}'.format(1)) 001 #用0补齐右边为三位数，对象必须是整数（0可以为任意字符串，位数可以指定） >>> print('{:010d}'.format(20)) 20 #右对齐，宽度为10 >>> print('{:10s}'.format('aaa')) aaa #右对齐，宽度为10 >>> print('{:

【本文地址】

Python内置函数大全

Python内置函数大全

今日新闻

推荐新闻