目录
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
<class 'str'>
#转换列表
>>> L = [1, 2, 'a', 'b']
>>> print(str(L))
[1, 2, 'a', 'b']
>>> print(type(str(L)))
<class 'str'>
#转换元组
>>> T = (3, 4, 'c', 'd')
>>> print(str(T))
(3, 4, 'c', 'd')
>>> print(type(str(T)))
<class 'str'>
#转换字典
>>> D = {'name':'小明', 'age':18}
>>> print(str(D))
{'name': '小明', 'age': 18}
>>> print(type(str(D)))
<class 'str'>
#转换集合
>>> S = {5, 6, 'e', 'f'}
>>> print(str(S))
{'f', 5, 'e', 6}
>>> print(type(str(S)))
<class 'str'>
list_列表
语法
list([对象])
定义一个空列表
>>> L = list()
>>> print(type(L))
<class 'list'>
定义一个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)))
<zip object at 0x000001C7521ACA00>
[(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])))
<class 'str'>
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)))
<class 'str'>
#查看转换结果
>>> 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, 1):
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))
<class 'str'>
>>> x = ('a',)
>>> print(type(x))
<class 'tuple'>
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()