Python内置函数大全

目录

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 <= n < 256）

>>> 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('{:0<3d}'.format(1))
100

左右对其，整数用d，字符串用s
-整数类
#左对齐，宽度为10
>>> print('{:>10d}'.format(20))
        20
#右对齐，宽度为10
>>> print('{:<10d}'.format(20))
20
#居中对齐，宽度为10
>>> print('{:^10d}'.format(20))
    20

-字符串类
#左对齐，宽度为10
>>> print('{:>10s}'.format('aaa'))
       aaa
#右对齐，宽度为10
>>> print('{:<10s}'.format('aaa'))
aaa       
#居中对齐，宽度为10
>>> print('{:^10s}'.format('aaa'))
   aaa    

type_输出类型

语法

type([对象])

查看对象的类型

>>> x = ('a')
>>> print(type(x))


>>> x = ('a',)
>>> print(type(x))

eval

语法

eval(source, globals=None, locals=None, /)
    -source：可以是表示Python表达式的字符串，也可以是compile()返回的代码对象。
    -globals：必须是一个字典，local可以是任何映射
    -locals：默认为当前的全局变量和局部变量。

a = '这是'
b = '方形蛋糕'
c = eval('a + b')
d = eval('1 + 1')
print(c)
print(d)

vars_输出类属性/本地属性

语法

vars()
vars([类])

查看本地属性，以字典方式返回

>>> a = 1
>>> b = 2
>>> print(vars())
{'__name__': '__main__', '__doc__': None, 'a': 1, 'b': 2  ......}

查看某个类的属性

>>> class MyClass():
        x = 1
        y = 2
>>> print(vars(MyClass))
{'__module__': '__main__', 'x': 1, 'y': 2,  ......}

globals_获取全局对象

返回全局对象

>>> import Locust.tmp2
>>> a = 1
>>> def func1():
        b = 2
>>> def func2():
        c = 3

>>> L = [ i for i in globals() if not i.endswith('__')]
>>> print(L)
['Locust', 'a', 'func1', 'func2']

locals_输出局部变量

以字典形式返回当前作用域的局部变量

>>> a = 1
>>> print(locals())
{'__name__': '__main__', '__doc__': None, 'a': 1, ......}

>>> def func1(a):
        b = 1
        print(locals())
>>> func1('AAA')
{'a': 'AAA', 'b': 1}

id_输出对象的唯一标识符

id([转换对象])
    -转换对象可以是：整数、字符串

返回对象的唯一标识符

>>> print(id('a'))
1598362050800
>>> print(id(1))
2647179067632

需要注意的是：唯一标识符在当前程序中的一样的，但每个执行这个脚本时标识符都会不一样

tmp.py文件内容
print(id('a'))
print(id('a'))

执行该脚本第1次
C:\PycharmProjects\pythonProject\Locust\Test>python tmp.py
2273263708912
2273263708912

执行该脚本第2次
C:\PycharmProjects\pythonProject\Locust\Test>python tmp.py
1678741695216
1678741695216

---

14. 交互类

input_界面交互

语法

input([提示符])

交互获取变量

-代码：
def func1():
    num = int(input('务必输入1-100数字：'))
    if (num < 1 or num > 100):
        func1()
    else:
        print('输入正确:', num)
func1()

-交互界面
务必输入1-100数字：0
务必输入1-100数字：101
务必输入1-100数字：100
输入正确: 100

---

15. 文件类

open_打开文件

语法

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
    -打开文件并返回一个流。失败时抛出OSError。

一般步骤如下：
open      #打开文件
    操作文件(读/写)
colse     #关闭文件

简单读取一个文件

#导入os模块
import os

#获取文件描述符
o = os.open(r'D:\tmp_file.txt', os.O_RDONLY)

#打开文件
file = open(o, 'r')

#读取文件内容
print(file.read())

#关闭文件
file.close()