内置函数
abs()
delattr()
hash()
memoryview()
set()
all()
dict()
help()
min()
setattr()
any()
dir()
hex()
next()
slice()
ascii()
divmod()
id()
object()
sorted()
bin()
enumerate()
input()
oct()
staticmethod()
bool()
eval()
int()
open()
str()
breakpoint()
exec()
isinstance()
ord()
sum()
bytearray()
filter()
pow()
pow()
super()
bytes()
float()
iter()
print()
tuple()
callable()
format()l
en()
property()
type()
chr()
frozenset()
list()
range()
vars()
classmethod()
getattr()
locals()
repr()
zip()
compile()
globals()
map()
reversed()
__import__()
complex()
hasattr()
max()
round()
1.数学运算类函数
abs，divmod，max，min，pow，round，sum
1)计算数值的绝对值：abs()
1 print(abs(-15))2
3 -----输出结果----
4 15
2)返回两个数的商和余数：divmod()
1 print(divmod(13,5))2
3 ------输出结果------
4 (2,3)
3)返回所有参数中元素的最大值或者返回可迭代对象中元素的最大值：max()
1 print(max(1,2,3)) #取三个数中的最大者2
3 print(max('123')) #取可迭代对象中的最大者4
5 print(max(-2,-1,0,key=abs)) #把-2，-1，0依次传给abs的参数，然后把abs的结果返回给key，max依次比较key的大小6
7 -------输出结果-------
8 -2
4)返回所有参数中元素的最小值或者返回可迭代对象中元素的最小值：min()
1 print(min(1,2,3)) #取三个数中的最小者2
3 print(min('123')) #取可迭代对象中的最小者4
5 print(min(-2,-1,0,key=abs)) #把-2，-1，0依次传给abs的参数，然后把abs的结果返回给key，max依次比较key的大小6
7 -------输出结果-----
8 1
9 1
10 0
5)返回两个数值的幂运算值或者其与指定值的余数：pow()
1 print(pow(2,4)) #2的4次幂2
3 print(pow(2,4,3)) #2的4次幂，然后除以3的余数 1
4
5 ------输出结果-----
6 16
7 1
6)对浮点数进行四舍五入：round()
1 print(round(2.563,1)) #2.563四舍五入，精度为12
3 print(round(2.561654132,5)) #2.561654132四舍五入，精度为54
5 --------输出结果------
6 2.6
7 2.56165
7)对参数类型为数值的可迭代对象中的每个元素求和：sum()
1 print(sum((1,2,3,4,5,6))) #对可迭代对象进行求和2
3 print(sum((1,2,3,4,5,6),16)) #可迭代对象的和与'start'的和4
5 --------输出结果-----
6 21
7 37
2.类型转换类函数
bool，int，float，complex，str，bytearray，bytes，memoryview，ord，chr，bin，oct，hex，tuple，list，dict，set，frozenset，enumerate，range，slice，super，object。
1)根据传入的参数的值返回布尔值：bool()
1 print(bool()) #不传递参数，返回False2 print(bool(0))3 print(bool(''))4 print(bool(())) # 0,'',()等为值的布尔值为False5
6 print(bool(2))7
8 ------输出结果------
9 False10 False11 False12 False13 True
2)根据传入的参数值创建一个新的整数值：int()
1 print(int()) #不传递参数时，结果为02
3 print(int(1.8)) #向下取整4
5 print(int('12')) #根据字符串类型创建整型6
7 -------输出结果------
8 0
9 1
10 12
3)根据传入的参数值创建一个新的浮点数值：float()
1 print(float()) #不传递参数时，结果为0.0
2
3 print(float(1))4
5 print(float('12')) #根据字符串类型创建浮点值6
7 -------输出结果------
8 0.0
9 1.0
10 12.0
4)根据传入的参数值创建一个新的复数值：complex()
1 print(complex()) #不传递参数时，结果为0j2
3 print(complex(1))4
5 print(complex(1,3)) #1为实数部分，3为虚数部分6
7 print(complex('12')) #根据字符串类型创建复数8
9 print(complex('1+2j'))10
11 ------输出结果-----
12 0j13 (1+0j)14 (1+3j)15 (12+0j)16 (1+2j)
5)返回一个对象的字符串表示形式，这个主要是给用户看：str()
1 >>>str(None)2 'None'
3 >>> str('123')4 '123'
5 >>> str(1234)6 '1234'
7 >>>str()8 ''
9 >>>
6)根据传入的参数创建一个字节数组(可变)：bytearray()
1 print(bytearray('博小园','utf-8'))2
3 ------输出结果-----
4 bytearray(b'\xe5\x8d\x9a\xe5\xb0\x8f\xe5\x9b\xad')
7)根据传入的参数创建一个不变字节数组：bytes()
1 print(bytes('博小园','utf-8'))2
3 ------输出结果-----
4 b'\xe5\x8d\x9a\xe5\xb0\x8f\xe5\x9b\xad'
8)根据传入的参数创建一个内存查看对象：memoryview()
1 memview=memoryview(b'abcdef')2
3 print(memview[0])4 print(memview[-1])5
6 --------输出结果--------
7 97
8 102
9)根据传入的参数返回对应的整数：ord()
1 print(ord('a'))2
3 -------输出结果------
4 97
10)根据传入的参数的整数值返回对应的字符：chr()
1 print(chr(97))2
3 -------输出结果------
4 a
11)根据传入的参数的值返回对应的二进制字符串：bin()
1 print(bin(12))2
3 -------输出结果------
4 0b1100
12)根据传入的参数的值返回对应的八进制字符串：oct()
1 print(oct(12))2
3 -------输出结果------
4 0o14
13)根据传入的参数的值返回对应的十六进制字符串：hex()
1 print(hex(12))2
3 ------输出结果-----
4 0xc
14)根据传入的参数创建一个tuple元组：tuple()
1 print(tuple()) #不传递参数，创建空元组 ()2 print(tuple('12345')) #根据可迭代参数，创建元组3
4 ------输出结果-----
5 ()6 ('1', '2', '3', '4', '5')
15)根据传入的参数创建一个新列表：list()
1 print(list()) #不传递参数，创建空列表 ()2 print(list('12345')) #根据可迭代参数，创建列表3
4 -------输出结果-------
5 []6 ['1', '2', '3', '4', '5']
16)根据传入的参数创建一个新的字典：dict()
1 print(dict()) #不传递参数，创建一个空的字典2
3 print(dict(x=2,y=7)) #传递键值对创建字典4
5 print(dict((('x',1),('y',3)))) #传入可迭代对象创建新的字典6
7 print(dict([('x',1),('y',7)]))8 print(dict(zip(['x','y'],[2,3]))) #传入映射函数创建新的字典9
10 ---------输出结果-----
11 {}12 {'x': 2, 'y': 7}13 {'x': 1, 'y': 3}14 {'x': 1, 'y': 7}15 {'x': 2, 'y': 3}
17)根据传入的参数创建一个新的集合：set()
1 print(set()) #传入的参数为空，返回空集合2
3 print(set(range(7))) #传入一个可迭代对象，创建集合4
5 -------输出结果-----
6 set()7 {0, 1, 2, 3, 4, 5, 6}
18)根据传入的参数创建一个新的不可变集合：frozenset()
1 print(frozenset(range(8)))2
3 -------输出结果------
4 frozenset({0, 1, 2, 3, 4, 5, 6, 7})
19)根据可迭代对象创建枚举对象：enumerate()
1 names=['zhangsan','lisi','wangwu','boxiaoyuan']2
3 print(list(enumerate(names)))4
5 print(list(enumerate(names,1)))6
7 -------输出结果-----
8 [(0, 'zhangsan'), (1, 'lisi'), (2, 'wangwu'), (3, 'boxiaoyuan')]9 [(1, 'zhangsan'), (2, 'lisi'), (3, 'wangwu'), (4, 'boxiaoyuan')]
20)根据传入的参数创建一个新的range对象：range()
1 x=range(9) #0至82
3 y=range(1,9) #1至8 步长为14
5 z=range(1,9,2) #1至8 步长为26
7 print(list(x))8 print(list(y))9 print(list(z))10
11 -------输出结果--------
12 [0, 1, 2, 3, 4, 5, 6, 7, 8]13 [1, 2, 3, 4, 5, 6, 7, 8]14 [1, 3, 5, 7]
21)根据传入的参数创建一个新的可迭代对象：iter()
1 x=iter('1234')2 print(x)3
4 print(next(x))5 print(next(x))6 print(next(x))7 print(next(x))8 print(next(x))9
10 -------输出结果-------
11
12 1
13 2
14 3
15 4
16 Traceback (most recent call last):17 File "E:/pythontest/test06.py", line 8, in
18 print(next(x))19 StopIteration
22)根据传入的对象创建一个新的切片对象：slice()
切片函数主要对序列对象进行切去对应元素。
1 a=[0,1,2,3,4,5,6,7,8,9]2
3 s=slice(0,9,2) #从start:0到stop:9，步长为step:2
4 print(a[s])5
6 -------输出结果------
7 [0, 2, 4, 6, 8]
23)根据传入的参数创建一个新的子类和父类关系的代理对象：super()
1 classA:2 def __init__(self):3 print("A.__init__")4
5 classB(A):6 def __init__(self):7 print("B.__init__")8 super().__init__()9
10 b=B()11
12 -------输出结果------
13 B.__init__14 A.__init__
24)创建一个新的object对象：object()
1 a=object()2 a.name='boxiaoyuan'#不能设置属性，object没有该属性3
4 --------输出结果-------
5 Traceback (most recent call last):6 File "E:/pythontest/test06.py", line 2, in
7 a.name='boxiaoyuan'
8 AttributeError: 'object' object has no attribute 'name'
3.序列操作类函数
all，any，filter，map，next，reversed，sorted，zip
1)判断每个可迭代对象的每个元素的值是否都是True，都是Ture，则返回True：all()
1 print(all([1,2,3,4,6])) #列表中的每个元素的值都为True，则返回True2
3 print(all([0,2,3,4,5,6]))4
5 print(all({})) #空字典返回True6
7 print(all(())) #空元组返回True8
9 ------输出结果------
10 True11 False12 True13 True
2)判断可迭代对象的每个元素的值是否存在为True，存在则返回True：any()
1 print(any([1,2,3,4,6])) #列表中的存在一个为True，则返回True2
3 print(any([0,0]))4
5 print(any({})) #空字典返回False6
7 print(any(())) #空元组返回False8
9 -------输出结果------
10 True11 False12 False13 False
3)使用指定方法过滤可迭代对象的元素：filter()
1 lists=[0,1,2,3,4,5,6,7,8,9]2
3 def is_odd(x):4 if x%2==1:5 returnx6
7 print(list(filter(is_odd,lists)))8
9 -------输出结果-------
10 [1, 3, 5, 7, 9]
4)使用指定方法作用传入的每个可迭代对象的元素，生成新的可迭代对象：map()
1 x=map(ord,'12345')2
3 print(x)4
5 print(list(x))6
7 -------输出结果-----
8
9 [49, 50, 51, 52, 53]
5)返回可迭代对象的下一个对象：next()
a=[0,1,2]
it=a.__iter__()
print(next(it))
print(next(it))
print(next(it))
print(next(it,3)) #传入default，当还有元素值没有迭代完，则继续迭代，如果已经迭代完，则返回默认值
-------输出结果--------
0
1
2
3
6)反转序列生成的可迭代对象：reversed()
1 a=range(10)2 print(a) #可迭代对象3 print(list(reversed(a)))4
5 -------输出结果------
6 range(0, 10)7 [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
7)对可迭代对象进行排序：sorted()
1 a=[0,2,1,9,5,7,4]2
3 print(list(sorted(a)))4
5 b=['a','c','d','A','C','D']6
7 print(list(sorted(b,key=str.lower)))8
9 -------输出结果-----
10 [0, 1, 2, 4, 5, 7, 9]11 ['a', 'A', 'c', 'C', 'd', 'D']
8)聚合传入的每个迭代器的相同位置的元素值，然后染回元组类型迭代器：zip()
1 x=[1,2,3]2 y=[4,5,6,7,8]3
4 print(list(zip(x,y)))5
6 -------输出结果------
7 [(1, 4), (2, 5), (3, 6)]
4.对象操作类函数
help，dir，id，hash，type，len，ascii，format，vars
1)获取对象的帮助信息：help()
1 help(list)2
3 -------输出结果------
4 Help on class list inmodule builtins:5
6 class list(object)7 | list() -> newempty list8 | list(iterable) -> new list initialized from iterable's items
9 |
10 |Methods defined here:11 |
12 | __add__(self, value, /)13 | Return self+value.14 |
15 | __contains__(self, key, /)16 | Return key inself.17 |
18 | __delitem__(self, key, /)19 |Delete self[key].20 |
21 | __eq__(self, value, /)22 | Return self==value.23 |
24 | __ge__(self, value, /)25 | Return self>=value.26 |
27 | __getattribute__(self, name, /)28 |Return getattr(self, name).29 |
30 |__getitem__(...)31 | x.__getitem__(y) <==>x[y]32 |
33 | __gt__(self, value, /)34 | Return self>value.35 |
36 | __iadd__(self, value, /)37 | Implement self+=value.38 |
39 | __imul__(self, value, /)40 | Implement self*=value.41 |
42 | __init__(self, /, *args, **kwargs)43 | Initialize self. See help(type(self)) foraccurate signature.44 |
45 | __iter__(self, /)46 |Implement iter(self).47 |
48 | __le__(self, value, /)49 | Return self<=value.50 |
51 | __len__(self, /)52 |Return len(self).53 |
54 | __lt__(self, value, /)55 | Return self
57 | __mul__(self, value, /)58 | Return self*value.n59 |
60 | __ne__(self, value, /)61 | Return self!=value.62 |
63 | __new__(*args, **kwargs) frombuiltins.type64 | Create and return a new object. See help(type) foraccurate signature.65 |
66 | __repr__(self, /)67 |Return repr(self).68 |
69 |__reversed__(...)70 | L.__reversed__() -- returna reverse iterator over the list71 |
72 | __rmul__(self, value, /)73 | Return self*value.74 |
75 | __setitem__(self, key, value, /)76 |Set self[key] to value.77 |
78 |__sizeof__(...)79 | L.__sizeof__() -- size of L in memory, inbytes80 |
81 |append(...)82 | L.append(object) -> None -- append objectto end83 |
84 |clear(...)85 | L.clear() -> None -- remove all items fromL86 |
87 |copy(...)88 | L.copy() -> list --a shallow copy of L89 |
90 |count(...)91 | L.count(value) -> integer -- returnnumber of occurrences of value92 |
93 |extend(...)94 | L.extend(iterable) -> None -- extend list by appending elements fromthe iterable95 |
96 |index(...)97 | L.index(value, [start, [stop]]) -> integer -- returnfirst index of value.98 | Raises ValueError if the value isnot present.99 |
100 |insert(...)101 | L.insert(index, object) -- insert objectbefore index102 |
103 |pop(...)104 | L.pop([index]) -> item -- remove and return item at index (defaultlast).105 | Raises IndexError if list is empty or index is outof range.106 |
107 |remove(...)108 | L.remove(value) -> None --remove first occurrence of value.109 | Raises ValueError if the value isnot present.110 |
111 |reverse(...)112 | L.reverse() -- reverse *IN PLACE*
113 |
114 |sort(...)115 | L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
116 |
117 | ----------------------------------------------------------------------
118 |Data and other attributes defined here:119 |
120 | __hash__ = None
2)获取对象和当前作用域的属性列表：dir()
1 import math2
3 print(dir(math))4
5 -----输出结果-----
6 ['__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']
3)返回对象的唯一标识符：id()
1 name='boxiaoyuan'
2
3 print(id(name))4
5 ------输出结果------
6 2125819230512
4)获取对象的hash码：hash()
1 name='boxiaoyuan'
2
3 print(hash(name))4
5 -------输出结果------
6 1195266938384538974
5)根据参数返回参数的类型或者返回创建的新的对象：type()
1 print(type(1))2 class A(object):3 name='zhangsan'
4
5 class B(object):6 name='lisi'
7
8 cObject=type('C',(A,B),{'name':'boxiaoyuan'}) #第一个参数是一个新的对象的名称，第二个参数是基类，第三个参数是属性9 print(cObject.name)10
11 -------输出结果-----
12
13 boxiaoyuan
6)查看对象的长度：len()
1 print(len('abcde'))2
3 print(len({'a':1}))4
5 print(len((1,2,3,4)))6
7 ------输出结果------
8 5
9 1
10 4
7)调用对象的__repr__，获取该方法的返回值：ascii()
1 # -*- coding:utf-8 -*-
2
3
4 classPerson:5
6 def __repr__(self):7 return "hello world"
8
9
10 if __name__ == '__main__':11 person =Person()12 print(ascii(person))
8)返回对象的格式化值：format()
1 #1.通过位置2 x='a={} b={} c={}'.format('zhangsan','lisi','boxiaoyuan') #{} 不带参数3 print(x)4 y='a={1} b={0} c={2}'.format('zhangsan','lisi','boxiaoyuan') #{} 带参数5 print(y)6 #2.通过关键字参数7 z='my English name is {name},my age is {age}'.format(name='boxiaoyuan',age='3')8 print(z)9 #3.通过对象属性10 classPerson:11 def __init__(self,name,age):12 self.name=name13 self.age=age14
15 p=Person('boxiaoyuan',3)16 print('name={p.name},age={p.age}'.format(p=p))17 #4.通过下标18 a1=[1,2,3,4]19 a2=['a','b','c']20
21 print('{0[0]},{1[1]}'.format(a1,a2))22 #5.格式化输出23 print('左对齐定长10位 [{:<10}]'.format(13)) #对齐与填充24 print('右对齐定长10位 [{:>10}]'.format(13))25 print('右对齐定长10位，以0填充 [{:0>10}]'.format(13))26
27 print('[{:.2f}]'.format(13.123456)) #小数点输出28 print('[{:,}]'.format(12345.1234567))#以逗号分割金额29
30 print('10转换为2进制：{:b}'.format(10)) #进制转换31
32 -------输出结果------
33 a=zhangsan b=lisi c=boxiaoyuan34 a=lisi b=zhangsan c=boxiaoyuan35 my English name is boxiaoyuan,my age is 3
36 name=boxiaoyuan,age=3
37 1,b38 左对齐定长10位 [13]39 右对齐定长10位 [ 13]40 右对齐定长10位，以0填充 [0000000013]41 [13.12]42 [12,345.1234567]43 10转换为2进制：1010
9)返回当前作用域的局部变量和对象的属性列表和值：vars()
1 name='zhangsan'
2 print(vars()) #不传入参数时和locals等效，3 print(locals())4 class A(object):5 name='boxiaoyaun'
6
7
8 print(vars(A))9
10 -------输出结果------
11 {'name': 'zhangsan', '__cached__': None, '__doc__': None, '__builtins__': , '__file__': 'E:/pythontest/test06.py', '__name__': '__main__', '__package__': None, '__spec__': None, '__loader__': <_frozen_importlib_external.sourcefileloader object at>}12 {'name': 'zhangsan', '__cached__': None, '__doc__': None, '__builtins__': , '__file__': 'E:/pythontest/test06.py', '__name__': '__main__', '__package__': None, '__spec__': None, '__loader__': <_frozen_importlib_external.sourcefileloader object at>}13 {'name': 'boxiaoyaun', '__module__': '__main__', '__doc__': None, '__dict__': , '__weakref__': }
5.交互类函数
input，print
1)键盘输入：input()
1 password = input("请输入您的银行卡密码：")2 print(password)3
4 -----输出结果-----
5 请输入您的银行卡密码：123456
6 123456
2)输出到控制台：print()
%被称为格式化操作符，专门用于处理字符串中的格式。
格式化输出：
格式
解释
备注
%d
整数
%06d，表示显示如果显示的数字不够6位前面用0填充
%f
浮点数
%.2f表示小数点后只显示两位
%s
字符串
%%
输出百分号
1 name = "小明"
2 print("hello %s" %name)3 age = 18
4 print("小明， 你的学号是：%06d" % 45)5 price = 2.56
6 weight = 12
7 total = price *weight8 print("小明，苹果的单价是%.2f，你买了%.2f斤，共%.2f元" %(price,weight,total))9
10 --------输出结果------
11 hello 小明12 小明， 你的学号是：000045
13 小明，苹果的单价是2.56，你买了12.00斤，共30.72元
在默认情况下，print函数输出内容之后，会自动在内容末尾增加换行，如果不希望末尾添加换行，可以在print函数输出内容的后面增加,end=""，其中""中间可以指定print函数输出内容之后，继续希望显示的内容。
语法格式如下：
1 # 向控制台输出内容结束之后，不会换行2 print("*",end="")3
4 # 单纯的换行5 print("")
6.编译执行类函数
eval，exec，repr，compile
1)将字符串当成有效的表达式来求值并返回计算结果：eval()
eval剥去字符串的外衣运算里面的代码。
1 print(eval('1 + 1'))
在开发时不要使用eval直接转换input的结果，因为这样可以使用户任意执行操作系统命令，不安全
2)执行动态语句块：exec()
exec()与eval几乎一样，执行代码流
1 # -*- coding:utf-8 -*-
2
3
4 exec('x = 3+6')5 print(x)
3)返回对象的字符串表现形式给解释器：repr()
1 In [1]: a = 'test text'
2
3 In [2]: str(a)4 Out[2]: 'test text'
5
6 In [3]: repr(a)7 Out[3]: "'test text'"
8
9 In [4]:
4)将字符串编译为可以通过exec进行执行或者eval进行求值：complie()
1 # -*- coding:utf-8 -*-
2
3
4 code = 'for a in range(1, 7): print(a)'
5
6 comp = compile(code, '', 'exec') # 流程的语句使用exec7
8 exec(comp)9
10 code1 = '1 + 2 + 3 + 4'
11
12 comp1 = compile(code1, '', 'eval') # 求值使用eval13
14 print(eval(comp1))
7.文件操作类函数
open，globals，locals
1)打开文件，并返回文件对象：open()
1 # -*- coding:utf-8 -*-
2
3
4 with open("d:test.txt", "r") asfile:5 for line infile:6 print(line, end="")
8.变量操作类函数
1)获取当前作用域的全局变量和值的字典：globals()
>>>globals()
{'__doc__': None, '__package__': None, '__loader__': , '__name__': '__main__', '__spec__': None, '__builtins__': }>>> a = 4
>>>globals()
{'__doc__': None, '__package__': None, '__loader__': , '__name__': '__main__', '__spec__': None, '__builtins__': , 'a': 4}
2)获取当前作用域的局部变量和值的字典：locals()
1 >>>def func():2 ... print('before a')3 ... print(locals())4 ... a = 2
5 ... print('after a')6 ... print(locals())7 ...8 >>>func()9 before a10 {}11 after a12 {'a': 2}13 >>>
9.反射操作类函数
__import__，isinstance，issubclass，hasattr，getattr，setattr，delattr，callable
1)动态导入模块：__import__()
1 # -*- coding:utf-8 -*-
2
3 time = __import__("time")4 now =time.localtime()5 print(time.strftime("%Y-%m-%d %H:%M:%S", now))
2)判断对象是否是给定类的实例：isinstance()
1 In [1]: isinstance(1, int)2 Out[1]: True3
4 In [2]: isinstance('2', (int, str))5 Out[2]: True
3)判断类是否为给定类的子类：issubclass()
1 In [1]: issubclass(bool, int)2 Out[1]: True3
4 In [2]: issubclass(bool, (int, str))5 Out[2]: True6
7 In [3]:
4)判断对象是有含有给定属性：hasattr();获取对象的属性值：getattr();设置对象的属性值：setattr();删除对象的属性值：delattr()
1 In [1]: classPerson:2 ...: def __init__(self, name):3 ...: self.name =name4 ...:5
6 In [2]: p = Person('zhangsan')7
8 In [3]: hasattr(p,'name')9 Out[3]: True10
11 In [4]: getattr(p, 'name')12 Out[4]: 'zhangsan'
13
14 In [5]: setattr(p, 'name','lisi')15
16 In [6]: getattr(p, 'name')17 Out[6]: 'lisi'
18
19 In [7]: delattr(p, 'name')20
21 In [8]: getattr(p, 'name')22 ---------------------------------------------------------------------------
23 AttributeError Traceback (most recent call last)24 in
25 ----> 1 getattr(p, 'name')26
27 AttributeError: 'Person' object has no attribute 'name'
5)检查对象是否可被调用：callable()
s1 = 'asdfg'def func():
pass
print(callable(s1)) # False
print(callable(func)) # True
扫一扫
599
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
