数学运算
- abs：求数值的绝对值
1 >>> abs(-2) 2 2
- divmod：返回两个数值的商和余数
1 >>> divmod(5,2) 2 (2, 1) 3 >> divmod(5.5,2) 4 (2.0, 1.5)
- max：返回可迭代对象中的元素中的最大值或者所有参数的最大值
1 >>> max(1,2,3) # 传入3个参数 取3个中较大者 2 3 3 >>> max('1234') # 传入1个可迭代对象，取其最大元素值 4 '4' 5 6 >>> max(-1,0) # 数值默认去数值较大者 7 0 8 >>> max(-1,0,key = abs) # 传入了求绝对值函数，则参数都会进行求绝对值后再取较大者 9 -1
- min：返回可迭代对象中的元素中的最小值或者所有参数的最小值
1 >>> min(1,2,3) # 传入3个参数 取3个中较小者 2 1 3 >>> min('1234') # 传入1个可迭代对象，取其最小元素值 4 '1' 5 6 >>> min(-1,-2) # 数值默认去数值较小者 7 -2 8 >>> min(-1,-2,key = abs) # 传入了求绝对值函数，则参数都会进行求绝对值后再取较小者 9 -1
- pow：返回两个数值的幂运算值或其与指定整数的模值
1 >>> pow(2,3) 2 >>> 2**3 3 8 4 >>> pow(2,3,5) 5 >>> pow(2,3)%5
6 3 - round：对浮点数进行四舍五入求值
1 >>> round(1.1314926,1) 2 1.1 3 >>> round(1.1314926,5) 4 1.13149
- sum：对元素类型是数值的可迭代对象中的每个元素求和
-
1 # 传入可迭代对象 2 >>> sum((1,2,3,4)) 3 10 4 # 元素类型必须是数值型 5 >>> sum((1.5,2.5,3.5,4.5)) 6 12.0 7 >>> sum((1,2,3,4),-10) 8 0
类型转换
- bool：根据传入的参数的逻辑值创建一个新的布尔值
1 >>> bool() #未传入参数 2 False 3 >>> bool(0) #数值0、空序列等值为False 4 False 5 >>> bool(1) 6 True
- int：根据传入的参数创建一个新的整数
1 >>> int() #不传入参数时，得到结果0。 2 0 3 >>> int(3) 4 3 5 >>> int(3.6) 6 3
- float：根据传入的参数创建一个新的浮点数
1 >>> float() #不提供参数的时候，返回0.0 2 0.0 3 >>> float(3) 4 3.0 5 >>> float('3') 6 3.0
- complex：根据传入参数创建一个新的复数
1 >>> complex() #当两个参数都不提供时，返回复数 0j。 2 0j 3 >>> complex('1+2j') #传入字符串创建复数 4 (1+2j) 5 >>> complex(1,2) #传入数值创建复数 6 (1+2j)
- str：返回一个对象的字符串表现形式(给用户)
1 >>> str() 2 '' 3 >>> str(None) 4 'None' 5 >>> str('abc') 6 'abc' 7 >>> str(123) 8 '123'
- bytearray：根据传入的参数创建一个新的字节数组
1 >>> bytearray('中文','utf-8') 2 bytearray(b'xe4xb8xadxe6x96x87')
- bytes：根据传入的参数创建一个新的不可变字节数组
1 >>> bytes('中文','utf-8') 2 b'xe4xb8xadxe6x96x87'
- memoryview：根据传入的参数创建一个新的内存查看对象
1 >>> v = memoryview(b'abcefg') 2 >>> v[1] 3 98 4 >>> v[-1] 5 103
- ord：返回Unicode字符对应的整数
1 >>> ord('a') 2 97
- chr：返回整数所对应的Unicode字符
1 >>> chr(97) #参数类型为整数 2 'a'
- bin：将整数转换成2进制字符串
1 >>> bin(3) 2 '0b11'
- oct：将整数转化成8进制数字符串
1 >>> oct(10) 2 '0o12'
- hex：将整数转换成16进制字符串
1 >>> hex(15) 2 '0xf'
- tuple：根据传入的参数创建一个新的元组
1 >>> tuple() #不传入参数，创建空元组 2 () 3 >>> tuple('121') #传入可迭代对象。使用其元素创建新的元组 4 ('1', '2', '1')
- list：根据传入的参数创建一个新的列表
1 >>>list() # 不传入参数，创建空列表 2 [] 3 >>> list('abcd') # 传入可迭代对象，使用其元素创建新的列表 4 ['a', 'b', 'c', 'd']
- dict：根据传入的参数创建一个新的字典
1 >>> dict() # 不传入任何参数时，返回空字典。 2 {} 3 >>> dict(a = 1,b = 2) # 可以传入键值对创建字典。 4 {'b': 2, 'a': 1} 5 >>> dict(zip(['a','b'],[1,2])) # 可以传入映射函数创建字典。 6 {'b': 2, 'a': 1} 7 >>> dict((('a',1),('b',2))) # 可以传入可迭代对象创建字典。 8 {'b': 2, 'a': 1}
- set：根据传入的参数创建一个新的集合
1 >>>set() # 不传入参数，创建空集合 2 set() 3 >>> a = set(range(10)) # 传入可迭代对象，创建集合 4 >>> a 5 {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
- frozenset：根据传入的参数创建一个新的不可变集合
1 >>> a = frozenset(range(10)) 2 >>> a 3 frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
- enumerate：根据可迭代对象创建枚举对象
1 >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter'] 2 >>> list(enumerate(seasons)) 3 [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')] 4 >>> list(enumerate(seasons, start=1)) #指定起始值 5 [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
- range：根据传入的参数创建一个新的range对象
1 >>> a = range(10) 2 >>> b = range(1,10) 3 >>> c = range(1,10,3) 4 >>> a,b,c # 分别输出a,b,c 5 (range(0, 10), range(1, 10), range(1, 10, 3)) 6 >>> list(a),list(b),list(c) # 分别输出a,b,c的元素 7 ([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 4, 7])
- iter：根据传入的参数创建一个新的可迭代对象
1 >>> a = iter('abcd') #字符串序列 2 >>> a 3 <str_iterator object at 0x03FB4FB0> 4 >>> next(a) 5 'a' 6 >>> next(a) 7 'b' 8 >>> next(a) 9 'c' 10 >>> next(a) 11 'd' 12 >>> next(a) 13 Traceback (most recent call last): 14 File "<pyshell#29>", line 1, in <module> 15 next(a) 16 StopIteration
- slice：根据传入的参数创建一个新的切片对象
1 >>> c1 = slice(5) # 定义c1 2 >>> c1 3 slice(None, 5, None) 4 >>> c2 = slice(2,5) # 定义c2 5 >>> c2 6 slice(2, 5, None) 7 >>> c3 = slice(1,10,3) # 定义c3 8 >>> c3 9 slice(1, 10, 3)
#使用方式
s=slice(1,5,2) #一次定义多次可用
list1=[1,2,3,4,5,6,7,8,9]
print(list1[s]) - super：根据传入的参数创建一个新的子类和父类关系的代理对象
1 #定义父类A 2 >>> class A(object): 3 def __init__(self): 4 print('A.__init__') 5 6 #定义子类B，继承A 7 >>> class B(A): 8 def __init__(self): 9 print('B.__init__') 10 super().__init__() #super调用不需要放在首行 11 12 #super调用父类方法 13 >>> b = B() 14 B.__init__ 15 A.__init__
- object：创建一个新的object对象
1 >>> a = object() 2 >>> a.name = 'kim' # 不能设置属性 3 Traceback (most recent call last): 4 File "<pyshell#9>", line 1, in <module> 5 a.name = 'kim' 6 AttributeError: 'object' object has no attribute 'name'
序列操作
- all：判断可迭代对象的每个元素是否都为True值
1 >>> all([1,2]) #列表中每个元素逻辑值均为True，返回True 2 True 3 >>> all([0,1,2]) #列表中0的逻辑值为False，返回False 4 False 5 >>> all(()) #空元组 6 True 7 >>> all({}) #空字典 8 True
- any：判断可迭代对象的元素是否有为True值的元素
1 >>> any([0,1,2]) #列表元素有一个为True，则返回True 2 True 3 >>> any([0,0]) #列表元素全部为False，则返回False 4 False 5 >>> any([]) #空列表 6 False 7 >>> any({}) #空字典 8 False
- f ilter：使用指定方法过滤可迭代对象的元素
1 >>> a = list(range(1,10)) #定义序列 2 >>> a 3 [1, 2, 3, 4, 5, 6, 7, 8, 9] 4 >>> def if_odd(x): #定义奇数判断函数 5 return x%2==1 6 7 >>> list(filter(if_odd,a)) #筛选序列中的奇数 8 [1, 3, 5, 7, 9]
- map：使用指定方法去作用传入的每个可迭代对象的元素，生成新的可迭代对象
1 >>> a = map(ord,'abcd') 2 >>> a 3 <map object at 0x03994E50> 4 >>> list(a) 5 [97, 98, 99, 100]
- next：返回可迭代对象中的下一个元素值
1 >>> a = iter('abcd') 2 >>> next(a) 3 'a' 4 >>> next(a) 5 'b' 6 >>> next(a) 7 'c' 8 >>> next(a) 9 'd' 10 >>> next(a) 11 Traceback (most recent call last): 12 File "<pyshell#18>", line 1, in <module> 13 next(a) 14 StopIteration 15 16 #传入default参数后，如果可迭代对象还有元素没有返回，则依次返回其元素值，如果所有元素已经返回，则返回default指定的默认值而不抛出StopIteration 异常 17 >>> next(a,'e') 18 'e' 19 >>> next(a,'e') 20 'e'
- reversed：反转序列生成新的可迭代对象
1 >>> a = reversed(range(10)) # 传入range对象 2 >>> a # 类型变成迭代器 3 <range_iterator object at 0x035634E8> 4 >>> list(a) 5 [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
- sorted：对可迭代对象进行排序，返回一个新的列表
1 >>> a = ['a','b','d','c','B','A'] 2 >>> a 3 ['a', 'b', 'd', 'c', 'B', 'A'] 4 5 >>> sorted(a) # 默认按字符ascii码排序 6 ['A', 'B', 'a', 'b', 'c', 'd'] 7 8 >>> sorted(a,key = str.lower) # 转换成小写后再排序，'a'和'A'值一样，'b'和'B'值一样 9 ['a', 'A', 'b', 'B', 'c', 'd']
- zip：聚合传入的每个迭代器中相同位置的元素，返回一个新的元组类型迭代器
1 >>> x = [1,2,3] #长度3 2 >>> y = [4,5,6,7,8] #长度5 3 >>> list(zip(x,y)) # 取最小长度3 4 [(1, 4), (2, 5), (3, 6)]
对象操作
- help：返回对象的帮助信息
-
1 >>> help(str) 2 Help on class str in module builtins: 3 4 class str(object) 5 | str(object='') -> str 6 | str(bytes_or_buffer[, encoding[, errors]]) -> str 7 | 8 | Create a new string object from the given object. If encoding or 9 | errors is specified, then the object must expose a data buffer 10 | that will be decoded using the given encoding and error handler. 11 | Otherwise, returns the result of object.__str__() (if defined) 12 | or repr(object). 13 | encoding defaults to sys.getdefaultencoding(). 14 | errors defaults to 'strict'. 15 | 16 | Methods defined here: 17 | 18 | __add__(self, value, /) 19 | Return self+value. 20 | 21 ***************************
- dir：返回对象或者当前作用域内的属性列表
1 >>> import math 2 >>> math 3 <module 'math' (built-in)> 4 >>> dir(math) 5 ['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']
- id：返回对象的唯一标识符
1 >>> a = 'some text' 2 >>> id(a) 3 69228568
- hash：获取对象的哈希值
1 >>> hash('good good study') 2 1032709256
- type：返回对象的类型，或者根据传入的参数创建一个新的类型
1 >>> type(1) # 返回对象的类型 2 <class 'int'> 3 4 #使用type函数创建类型D，含有属性InfoD 5 >>> D = type('D',(A,B),dict(InfoD='some thing defined in D')) 6 >>> d = D() 7 >>> d.InfoD 8 'some thing defined in D'
- len：返回对象的长度
1 >>> len('abcd') # 字符串 2 >>> len(bytes('abcd','utf-8')) # 字节数组 3 >>> len((1,2,3,4)) # 元组 4 >>> len([1,2,3,4]) # 列表 5 >>> len(range(1,5)) # range对象 6 >>> len({'a':1,'b':2,'c':3,'d':4}) # 字典 7 >>> len({'a','b','c','d'}) # 集合 8 >>> len(frozenset('abcd')) #不可变集合
- ascii：返回对象的可打印表字符串表现方式
1 >>> ascii(1) 2 '1' 3 >>> ascii('&') 4 "'&'" 5 >>> ascii(9000000) 6 '9000000' 7 >>> ascii('中文') #非ascii字符 8 "'\u4e2d\u6587'"
- format：格式化显示值
1 #字符串可以提供的参数 's' None 2 >>> format('some string','s') 3 'some string' 4 >>> format('some string') 5 'some string' 6 7 #整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None 8 >>> format(3,'b') #转换成二进制 9 '11' 10 >>> format(97,'c') #转换unicode成字符 11 'a' 12 >>> format(11,'d') #转换成10进制 13 '11' 14 >>> format(11,'o') #转换成8进制 15 '13' 16 >>> format(11,'x') #转换成16进制 小写字母表示 17 'b' 18 >>> format(11,'X') #转换成16进制 大写字母表示 19 'B' 20 >>> format(11,'n') #和d一样 21 '11' 22 >>> format(11) #默认和d一样 23 '11' 24 25 #浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None 26 >>> format(314159267,'e') #科学计数法，默认保留6位小数 27 '3.141593e+08' 28 >>> format(314159267,'0.2e') #科学计数法，指定保留2位小数 29 '3.14e+08' 30 >>> format(314159267,'0.2E') #科学计数法，指定保留2位小数，采用大写E表示 31 '3.14E+08' 32 >>> format(314159267,'f') #小数点计数法，默认保留6位小数 33 '314159267.000000' 34 >>> format(3.14159267000,'f') #小数点计数法，默认保留6位小数 35 '3.141593' 36 >>> format(3.14159267000,'0.8f') #小数点计数法，指定保留8位小数 37 '3.14159267' 38 >>> format(3.14159267000,'0.10f') #小数点计数法，指定保留10位小数 39 '3.1415926700' 40 >>> format(3.14e+1000000,'F') #小数点计数法，无穷大转换成大小字母 41 'INF' 42 43 #g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数 44 >>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点 45 '3e-05' 46 >>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点 47 '3.1e-05' 48 >>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点 49 '3.14e-05' 50 >>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写 51 '3.14E-05' 52 >>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点 53 '3' 54 >>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点 55 '3.1' 56 >>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点 57 '3.14' 58 >>> format(0.00003141566,'.1n') #和g相同 59 '3e-05' 60 >>> format(0.00003141566,'.3n') #和g相同 61 '3.14e-05' 62 >>> format(0.00003141566) #和g相同 63 '3.141566e-05'
- vars：返回当前作用域内的局部变量和其值组成的字典，或者返回对象的属性列表
1 #作用于类实例 2 >>> class A(object): 3 pass 4 5 >>> a.__dict__ 6 {} 7 >>> vars(a) 8 {} 9 >>> a.name = 'Kim' 10 >>> a.__dict__ 11 {'name': 'Kim'} 12 >>> vars(a) 13 {'name': 'Kim'}
反射操作
- __import__：动态导入模块
1 index = __import__('index') 2 index.sayHello()
- isinstance：判断对象是否是类或者类型元组中任意类元素的实例
1 >>> isinstance(1,int) 2 True 3 >>> isinstance(1,str) 4 False 5 >>> isinstance(1,(int,str)) 6 True
- issubclass：判断类是否是另外一个类或者类型元组中任意类元素的子类
1 >>> issubclass(bool,int) 2 True 3 >>> issubclass(bool,str) 4 False 5 6 >>> issubclass(bool,(str,int)) 7 True
- hasattr：检查对象是否含有属性
1 #定义类A 2 >>> class Student: 3 def __init__(self,name): 4 self.name = name 5 6 7 >>> s = Student('Aim') 8 >>> hasattr(s,'name') #a含有name属性 9 True 10 >>> hasattr(s,'age') #a不含有age属性 11 False
- getattr：获取对象的属性值
1 #定义类Student 2 >>> class Student: 3 def __init__(self,name): 4 self.name = name 5 6 >>> getattr(s,'name') #存在属性name 7 'Aim' 8 9 >>> getattr(s,'age',6) #不存在属性age，但提供了默认值，返回默认值 10 11 >>> getattr(s,'age') #不存在属性age，未提供默认值，调用报错 12 Traceback (most recent call last): 13 File "<pyshell#17>", line 1, in <module> 14 getattr(s,'age') 15 AttributeError: 'Stduent' object has no attribute 'age'
- setattr：设置对象的属性值
1 >>> class Student: 2 def __init__(self,name): 3 self.name = name 4 5 6 >>> a = Student('Kim') 7 >>> a.name 8 'Kim' 9 >>> setattr(a,'name','Bob') 10 >>> a.name 11 'Bob'
- delattr：删除对象的属性
1 #定义类A 2 >>> class A: 3 def __init__(self,name): 4 self.name = name 5 def sayHello(self): 6 print('hello',self.name) 7 8 #测试属性和方法 9 >>> a.name 10 '小麦' 11 >>> a.sayHello() 12 hello 小麦 13 14 #删除属性 15 >>> delattr(a,'name') 16 >>> a.name 17 Traceback (most recent call last): 18 File "<pyshell#47>", line 1, in <module> 19 a.name 20 AttributeError: 'A' object has no attribute 'name'
- callable：检测对象是否可被调用
1 >>> class B: #定义类B 2 def __call__(self): 3 print('instances are callable now.') 4 5 6 >>> callable(B) #类B是可调用对象 7 True 8 >>> b = B() #调用类B 9 >>> callable(b) #实例b是可调用对象 10 True 11 >>> b() #调用实例b成功 12 instances are callable now.
变量操作
- globals：返回当前作用域内的全局变量和其值组成的字典
1 >>> globals() 2 {'__spec__': None, '__package__': None, '__builtins__': <module 'builtins' (built-in)>, '__name__': '__main__', '__doc__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>} 3 >>> a = 1 4 >>> globals() #多了一个a 5 {'__spec__': None, '__package__': None, '__builtins__': <module 'builtins' (built-in)>, 'a': 1, '__name__': '__main__', '__doc__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>}
- locals：返回当前作用域内的局部变量和其值组成的字典
1 >>> def f(): 2 print('before define a ') 3 print(locals()) #作用域内无变量 4 a = 1 5 print('after define a') 6 print(locals()) #作用域内有一个a变量，值为1 7 8 9 >>> f 10 <function f at 0x03D40588> 11 >>> f() 12 before define a 13 {} 14 after define a 15 {'a': 1}
交互操作
- print：向标准输出对象打印输出
1 >>> print(1,2,3) 2 1 2 3 3 >>> print(1,2,3,sep = '+') 4 1+2+3 5 >>> print(1,2,3,sep = '+',end = '=?') 6 1+2+3=?
- input：读取用户输入值
1 >>> s = input('please input your name:') 2 please input your name:Ain 3 >>> s 4 'Ain'
文件操作
- open：使用指定的模式和编码打开文件，返回文件读写对象
1 # t为文本读写，b为二进制读写 2 >>> a = open('test.txt','rt') 3 >>> a.read() 4 'some text' 5 >>> a.close()
编译执行
- compile：将字符串编译为代码或者AST对象，使之能够通过exec语句来执行或者eval进行求值
1 >>> #流程语句使用exec 2 >>> code1 = 'for i in range(0,10): print (i)' 3 >>> compile1 = compile(code1,'','exec') 4 >>> exec (compile1) 5 0 6 1 7 2 8 3 9 4 10 5 11 6 12 7 13 8 14 9 15 16 17 >>> #简单求值表达式用eval 18 >>> code2 = '1 + 2 + 3 + 4' 19 >>> compile2 = compile(code2,'','eval') 20 >>> eval(compile2) 21 10
- eval：执行动态表达式求值
1 >>> eval('1+2+3+4') 2 10
- exec：执行动态语句块
-
1 >>> exec('a=1+2') #执行语句 2 >>> a 3 3
- repr：返回一个对象的字符串表现形式(给解释器)
1 >>> a = 'some text' 2 >>> str(a) 3 'some text' 4 >>> repr(a) 5 "'some text'"
装饰器
- property：标示属性的装饰器
1 >>> class C: 2 def __init__(self): 3 self._name = '' 4 @property 5 def name(self): 6 """i'm the 'name' property.""" 7 return self._name 8 @name.setter 9 def name(self,value): 10 if value is None: 11 raise RuntimeError('name can not be None') 12 else: 13 self._name = value 14 15 16 >>> c = C() 17 18 >>> c.name # 访问属性 19 '' 20 >>> c.name = None # 设置属性时进行验证 21 Traceback (most recent call last): 22 File "<pyshell#84>", line 1, in <module> 23 c.name = None 24 File "<pyshell#81>", line 11, in name 25 raise RuntimeError('name can not be None') 26 RuntimeError: name can not be None 27 28 >>> c.name = 'Kim' # 设置属性 29 >>> c.name # 访问属性 30 'Kim' 31 32 >>> del c.name # 删除属性，不提供deleter则不能删除 33 Traceback (most recent call last): 34 File "<pyshell#87>", line 1, in <module> 35 del c.name 36 AttributeError: can't delete attribute 37 >>> c.name 38 'Kim'
- classmethod：标示方法为类方法的装饰器
1 >>> class C: 2 @classmethod 3 def f(cls,arg1): 4 print(cls) 5 print(arg1) 6 7 8 >>> C.f('类对象调用类方法') 9 <class '__main__.C'> 10 类对象调用类方法 11 12 >>> c = C() 13 >>> c.f('类实例对象调用类方法') 14 <class '__main__.C'> 15 类实例对象调用类方法
- staticmethod：标示方法为静态方法的装饰器
1 # 使用装饰器定义静态方法 2 >>> class Student(object): 3 def __init__(self,name): 4 self.name = name 5 @staticmethod 6 def sayHello(lang): 7 print(lang) 8 if lang == 'en': 9 print('Welcome!') 10 else: 11 print('你好！') 12 13 14 >>> Student.sayHello('en') #类调用,'en'传给了lang参数 15 en 16 Welcome! 17 18 >>> b = Student('Kim') 19 >>> b.sayHello('zh') #类实例对象调用,'zh'传给了lang参数 20 zh 21 你好