python内置函数
内置函数
abs()
**abs(x)**x可以为整数,浮点数,复数.
返回一个数的绝对值。 参数可以是一个整数或浮点数或复数。
- 整数或浮点数返回绝对值
- 如果参数是一个复数，则返回它的模。
- 如果 x 定义了 abs()，则 abs(x) 将返回 x.abs()。
print ("整数 abs(-40) : ", abs(-40))
print ("浮点数 abs(100.10) : ", abs(100.10))
print("复数 abs(3+4j):",abs(3+4j))
all()
all(iterable) 传入可迭代对象iterable
如果 iterable 的所有元素均为真值（或可迭代对象为空）则返回 True 。
等价于:
def all(iterable): for element in iterable: if not element: return False return True
print(all(['a', 'b', 'c', 'd'])) # 列表list，元素都不为空或0
#True
print(all(['a', 'b', '', 'd'])) # 列表list，存在一个为空的元素
#False
print(all([0, 1,2, 3])) # 列表list，存在一个为0的元素
#False
print(all([])) #空列表
#Ture
any()
any(iterable) 传入可迭代对象iterable.
如果 iterable 的任一元素为真值则返回 True。 如果可迭代对象为空，返回 False.
等价于:
def any(iterable): for element in iterable: if element: return True return False
print(any(['a', 'b', 'c', 'd'])) # 列表list，元素都不为空或0
#True
print(any(['a', 'b', '', 'd'])) # 列表list，存在一个为空的元素
#True
print(any([0, 1,2, 3])) # 列表list，存在一个为0的元素
#True
print(any([0,0,0]))
# False
print(any([])) #空列表
#False
ascii
ascii(object)
ascii() 函数类似 repr() 函数, 返回一个表示对象的字符串, 但是对于字符串中的非 ASCII 字符则返回通过 repr() 函数使用 \x, \u 或 \U 编码的字符。
- \u：unicode 码一般其后跟 4 个 16 进制数
- \x: 是 16 进制的意思，后边跟两位，则表示单字节编码
生成的字符串和 Python 2 的 repr() 返回的结果相似。
print("aaa:",ascii("aaa"))
print("中国:",ascii("中国"))
print("a中国:",ascii("a中国"))
aaa: 'aaa'
中国: '\u4e2d\u56fd'
a中国: 'a\u4e2d\u56fd'
'aaa'
bin()
bin(x) x为int类型,或者定义了 index()方法返回整数的对象
将一个整数转变为一个前缀为“0b”的二进制字符串。结果是一个合法的 Python 表达式。如果 x 不是 Python 的 int 对象，那它需要定义 index() 方法返回一个整数。
print(bin(3))
print(bin(-3))
0b11
-0b11
print(format(3,"b")) # 转为二进制没有0b
print(format(3,"#b")) #转为二进制有0b
11
0b11
bool()
bool(x) x可以为int,float,list,str等类型
- list,tuple,dict 等类型如果为空则为false,如果有数据则为False
- “”(str), 0(int), 0.0(float) 为False
- 注意的是**bool(“False”)的结果为True
print(1,bool("False"))
print(2,bool(0))
print(3,bool(1))
print(4,bool(0.0))
print(5,bool(""))
1 True
2 False
3 True
4 False
5 False
breakpoint()
todo
bytearray()
todo
bytes()
todo
callable()
callable(object)
如果参数 object 是可调用的就返回 True，否则返回 False。 如果返回 True，调用仍可能失败，但如果返回 False，则调用 object 将肯定不会成功。 请注意类是可调用的（调用类将返回一个新的实例）；如果实例所属的类有 call() 则它就是可调用的。
object.call(self[, args…])¶
此方法会在实例作为一个函数被“调用”时被调用；如果定义了此方法，则 x(arg1, arg2, …) 就相当于 x.call(arg1, arg2, …) 的快捷方式。
print(callable(0))
# False
print(callable("runoob"))
# False
def add(a, b):
return a + b
print(callable(add)) # 函数返回 True
# True
class A: # 类
def method(self):
return 0
print(callable(A)) # 类返回 True
# True
a = A()
print(callable(a)) # 没有实现 __call__, 返回 False
# False
class B:
def __call__(self):
return 0
print(callable(B))
# True
b = B()
print(callable(b)) # 实现 __call__, 返回 True
# True
False
False
True
True
False
True
True
chr()
chr(i)
- 返回 Unicode 码位为整数 i 的字符的字符串格式
- i – 可以是 10 进制也可以是 16 进制的形式的数字，数字范围为 0 到 1,114,111 (16 进制为0x10FFFF),如果 i 超过这个范围，会触发 ValueError 异常。
- 是ord()的逆函数
print(chr(99))
print(chr(8364))
print(chr(0x30)) #0x30为16进制数
print(ord("€")) #ord()的逆函数,后面有ord()介绍
c
€
0
8364
classmethod()
**@classmethod**
* 类函数中做为装饰器使用,一个类方法把类自己作为第一个实参(一般使用cls)，就像一个实例方法把实例自己作为第一个实参。
* 这样不用实例化类,就可以调用函数
class A(object):
bar = 1
def func1(self):
print ('foo')
@classmethod
def func2(cls):
print ('func2')
print (cls.bar)
cls().func1() # 调用 foo 方法
def func3(self):
print ('func2')
print (self.bar)
self().func1() # 调用 foo 方法
A.func2() # 不需要实例化
print("****")
# todo验证
A.func3(A) # 猜测classmethod实现了,类似的原理,未验证,
func2
1
foo
func2
1
foo
compile()
todo
complex()
创建复数
- 当从字符串转换时，字符串在 + 或 - 的周围必须不能有空格。例如 complex(‘1+2j’) 是合法的，但 complex(‘1 + 2j’) 会触发 ValueError 异常。
print(complex(1,2))
print(complex(1.1,2))
print(complex("1+2j"))
(1+2j)
(1.1+2j)
(1+2j)
complex_a = complex(1,2)
print(complex_a.real) # 实数部分
print(complex_a.imag) # 虚数部分
1.0
2.0
delattr()
delattr(object,name)
object:对象，name:对象的属性名称
delattr(x, ‘foobar’) 相等于 del x.foobar。
# todo 判断属性是否有self的区别
class Coordinate:
x = 10
y = -5
z = 0
point1 = Coordinate()
print('x = ',point1.x)
print('y = ',point1.y)
print('z = ',point1.z)
delattr(Coordinate, 'z')
print('--删除 z 属性后--')
print('x = ',point1.x)
print('y = ',point1.y)
# 删除z后，使用ｚ触发错误
print('z = ',point1.z)
x = 10
y = -5
z = 0
--删除 z 属性后--
x = 10
y = -5
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
in
18
19 # 删除z后，使用ｚ触发错误
---> 20 print('z = ',point1.z)
AttributeError: 'Coordinate' object has no attribute 'z'
dict()
创建字典对象，详见字典模块
dir()
dir([object]) object 对象名称
- 如果没有实参，则返回当前本地作用域中的名称列表。例:dir()
- 如果有实参，它会尝试返回该对象的有效属性列表。例：dir(object1)或dir([object1])
有实参的情况
- 如果对象是模块对象，则列表包含模块的属性名称。
- 如果对象是类型或类对象，则列表包含它们的属性名称，并且递归查找所有基类的属性。
- 否则，列表包含对象的属性名称，它的类属性名称，并且递归查找它的类的所有基类的属性。
如果对象有一个名为 dir() 的方法，那么该方法将被调用，并且必须返回一个属性列表
abbbbbb = 2
dir() #返回当前本地作用域中的名称列表
['A',
'B',
'Coordinate',
'In',
'Out',
'Shape',
'Test',
'_',
'_10',
'_100',
'_11',
'_110',
'_12',
'_137',
'_14',
'_151',
'_152',
'_153',
'_154',
'_155',
'_156',
'_159',
'_16',
'_161',
'_17',
'_18',
'_19',
'_23',
'_28',
'_29',
'_30',
'_31',
'_32',
'_33',
'_34',
'_37',
'_87',
'_9',
'_90',
'_91',
'_92',
'_93',
'_94',
'_96',
'_97',
'_98',
'_99',
'__',
'___',
'__builtin__',
'__builtins__',
'__doc__',
'__loader__',
'__name__',
'__package__',
'__spec__',
'_dh',
'_i',
'_i1',
'_i10',
'_i100',
'_i101',
'_i102',
'_i103',
'_i104',
'_i105',
'_i106',
'_i107',
'_i108',
'_i109',
'_i11',
'_i110',
'_i111',
'_i112',
'_i113',
'_i114',
'_i115',
'_i116',
'_i117',
'_i118',
'_i119',
'_i12',
'_i120',
'_i121',
'_i122',
'_i123',
'_i124',
'_i125',
'_i126',
'_i127',
'_i128',
'_i129',
'_i13',
'_i130',
'_i131',
'_i132',
'_i133',
'_i134',
'_i135',
'_i136',
'_i137',
'_i138',
'_i139',
'_i14',
'_i140',
'_i141',
'_i142',
'_i143',
'_i144',
'_i145',
'_i146',
'_i147',
'_i148',
'_i149',
'_i15',
'_i150',
'_i151',
'_i152',
'_i153',
'_i154',
'_i155',
'_i156',
'_i157',
'_i158',
'_i159',
'_i16',
'_i160',
'_i161',
'_i162',
'_i17',
'_i18',
'_i19',
'_i2',
'_i20',
'_i21',
'_i22',
'_i23',
'_i24',
'_i25',
'_i26',
'_i27',
'_i28',
'_i29',
'_i3',
'_i30',
'_i31',
'_i32',
'_i33',
'_i34',
'_i35',
'_i36',
'_i37',
'_i38',
'_i39',
'_i4',
'_i40',
'_i41',
'_i42',
'_i43',
'_i44',
'_i45',
'_i46',
'_i47',
'_i48',
'_i49',
'_i5',
'_i50',
'_i51',
'_i52',
'_i53',
'_i54',
'_i55',
'_i56',
'_i57',
'_i58',
'_i59',
'_i6',
'_i60',
'_i61',
'_i62',
'_i63',
'_i64',
'_i65',
'_i66',
'_i67',
'_i68',
'_i69',
'_i7',
'_i70',
'_i71',
'_i72',
'_i73',
'_i74',
'_i75',
'_i76',
'_i77',
'_i78',
'_i79',
'_i8',
'_i80',
'_i81',
'_i82',
'_i83',
'_i84',
'_i85',
'_i86',
'_i87',
'_i88',
'_i89',
'_i9',
'_i90',
'_i91',
'_i92',
'_i93',
'_i94',
'_i95',
'_i96',
'_i97',
'_i98',
'_i99',
'_ih',
'_ii',
'_iii',
'_oh',
'a',
'abbbbbb',
'add',
'b',
'complex_a',
'exit',
'get_ipython',
'int_a',
'point1',
'quit',
's']
import struct
dir([[],struct]) #查看列表,和struct的所有属性名称
['__add__',
'__class__',
'__contains__',
'__delattr__',
'__delitem__',
'__dir__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__getitem__',
'__gt__',
'__hash__',
'__iadd__',
'__imul__',
'__init__',
'__init_subclass__',
'__iter__',
'__le__',
'__len__',
'__lt__',
'__mul__',
'__ne__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__reversed__',
'__rmul__',
'__setattr__',
'__setitem__',
'__sizeof__',
'__str__',
'__subclasshook__',
'append',
'clear',
'copy',
'count',
'extend',
'index',
'insert',
'pop',
'remove',
'reverse',
'sort']
class Shape:
def __dir__(self):
return ['area', 'perimeter', 'location']
s = Shape()
dir(s)
['area', 'location', 'perimeter']
divmod()
divmod(a,b)
- a: 数字，非复数。
- b: 数字，非复数。
结果
- 对于整数，结果和 (a // b, a % b) 一致。
- 对于浮点数，结果是 (q, a % b) ，q 通常是 math.floor(a / b) 但可能会比 1 小。
- 在任何情况下， q * b + a % b 和 a 基本相等；如果 a % b 非零，它的符号和 b 一样，并且 0 <= abs(a % b) < abs(b)
print(divmod(7, 2))
print(divmod(8, 2))
print(divmod(8, -2))
print(divmod(7, 2.1))
print(divmod(7.7, 3))
(3, 1)
(4, 0)
(-4, 0)
(3.0, 0.6999999999999997)
(2.0, 1.7000000000000002)
enumerate()
enumerate(iterable, start=0)
- iterable，输入为一个迭代器
- start 开始位置参数，默认为0
返回一个枚举对象
todo 什么是枚举对象
enumerate() 返回的迭代器的 next() 方法返回一个元组，里面包含一个计数值（从 start 开始，默认为 0）和通过迭代 iterable 获得的值。
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
for i in enumerate(seasons,start=9):
print(i)
(9, 'Spring')
(10, 'Summer')
(11, 'Fall')
(12, 'Winter')
cc = {"a":1,"b":22} # 如果是字典的话就会迭代输出计数值和key的元组
for i in enumerate(cc):
print(i)
(0, 'a')
(1, 'b')
eval()
todo relationship compile
eval(str)
- str是一个代码字符串，执行
globals：可选参数，默认为globals()的值,(表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象locals：可选参数，默认为locals()的值,表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。- 经过测试，在eval中：globals和locals不可使用eval("",globals={})这种方式进行传入，只能传入字典类型，如有相同变量会进行覆盖．
函数用来执行一个字符串表达式，并返回表达式的值。
结果
- 返回执行结果
x = 1
print(eval("x+1"))
2
def a():
c = 4
# 通过字典传入如有相同变量会覆盖globals()和locals(),
# 传入两个字典后面的字典会覆盖前面的字典，
print(eval("c+1",{"c":55}, {"c":66}))
print(eval("c+1",{"c":99},locals()))
a()
67
5
eval 与 exec 的区别
- eval 执行后有返回值,而exec执行后返回None
- eval 只能执行单个运算表达式(和lambda表达式类似),而exec可执行复杂代码
- 如:下面代码(较复杂为两行),exec可执行,而eval不可执行
b= """
print("aaa")
print("bbb")
"""
exec(b)
print("*****************")
eval(b)
aaa
bbb
*****************
Traceback (most recent call last):
File "/home/zhangmeng/anaconda3/envs/package_learn/lib/python3.8/site-packages/IPython/core/interactiveshell.py", line 3343, in run_code
exec(code_obj, self.user_global_ns, self.user_ns)
File "", line 7, in
eval(b)
File "", line 3
print("bbb")
^
SyntaxError: invalid syntax
exec()
- 执行复杂代码
- 相减上面的eval()
exec(str)
- str是一个代码字符串，执行
globals：可选参数，默认为globals()的值,(表示全局命名空间（存放全局变量），如果被提供，则必须是一个字典对象locals：可选参数，默认为locals()的值,表示当前局部命名空间（存放局部变量），如果被提供，可以是任何映射对象。- 经过测试，在exec中：globals和locals不可使用eval("",globals={})这种方式进行传入，只能传入字典类型，如有相同变量会进行覆盖．
函数用来执行一个字符串表达式,没有返回值
结果
- 返回None
b= """
print("aaa")
print("bbb")
"""
print(exec(b))
aaa
bbb
None
filter()
filter(function, iterable)
- 输入
- function 判断函数，对迭代器中元素进行判断如果可以就返回True,不可以就返回False
- iterable 可迭代对象
- 作用
- 过滤掉不符合规则的迭代器中的元素
- 当 function 不是 None 的时相当于(item for item in iterable if function(item))
- function 是 None 的时相当于 (item for item in iterable if item) 。
def is_odd(n):
return n % 2 == 1
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)
[1, 3, 5, 7, 9]
float()
float(x)
- 简介
- 返回从数字或字符串 x 生成的浮点数
- 输入
- x 整数或字符串
- 返回
- 返回浮点数
print(float(1))
print(float(-1))
print(float(-1.65))
print(float("-1.25"))
# 字母大小写都可以，例如，“inf”、“Inf”、“INFINITY”、“iNfINity” 都可以表示正无穷大
if float("inf")>100000000:
print("PP")
1.0
-1.0
-1.65
-1.25
PP
format()
‘#’ 选项可以让“替代形式”被用于转换。 替代形式可针对不同类型分别定义。 此选项仅对整数、浮点、复数和 Decimal 类型有效。 对于整数类型，当使用二进制、八进制或十六进制输出时，此选项会为输出值添加相应的 ‘0b’, ‘0o’ 或 ‘0x’ 前缀。 对于浮点数、复数和 Decimal 类型，替代形式会使得转换结果总是包含小数点符号，即使其不带小数。 通常只有在带有小数的情况下，此类转换的结果中才会出现小数点符号。 此外，对于 ‘g’ 和 ‘G’ 转换，末尾的零不会从结果中被移除。
- ‘,’ 选项表示使用逗号作为千位分隔符。 对于感应区域设置的分隔符，请改用 ‘n’ 整数表示类型。
- 在 3.1 版更改添加新功能:可在，前面添加数字表示长度
- ‘_’ 选项表示对浮点表示类型和整数表示类型 ‘d’ 使用下划线作为千位分隔符。 对于整数表示类型 ‘b’, ‘o’, ‘x’ 和 ‘X’，将为每 4 个数位插入一个下划线。 对于其他表示类型指定此选项则将导致错误
print(format(12345,"20_.3f")) #设置保存长度为20,如果设置的长度小于数字的长度,则使用使用数字的长度,如果大于则使用空格补全.
#使用"_"做为千位分隔符,".3f"使用设置保留3位小数
12_345.000
整数类型可用
| 类型 | 含义 |
|---|---|
| ‘b’ | 二进制格式。 输出以 2 为基数的数字。 |
| ‘c’ | 字符。在打印之前将整数转换为相应的unicode字符。 |
| ‘d’ | 十进制整数。 输出以 10 为基数的数字。 |
| ‘o’ | 八进制格式。 输出以 8 为基数的数字。 |
| ‘x’ | 十六进制格式。 输出以 16 为基数的数字，使用小写字母表示 9 以上的数码。 |
| ‘X’ | 十六进制格式。 输出以 16 为基数的数字，使用大写字母表示 9 以上的数码。 |
| ‘n’ | 数字。 这与 ‘d’ 相似，不同之处在于它会使用当前区域设置来插入适当的数字分隔字符。 |
| None | 和 ‘d’ 相同。 |
int_a = 123456789
print(format(int_a,"b")) # 二进制
print(format(int_a,"#b")) # 二进制,前面带有ob,表示二进制类型
# print(format(int_a,"c")) # Unicode代码
print(format(int_a,"o")) # 8进制
print(format(int_a,"22,.1f"))
111010110111100110100010101
0b111010110111100110100010101
726746425
123,456,789.0
字符串类型
| 类型 | 含义 |
|---|
's’｜字符串格式。这是字符串的默认类型，可以省略。
None｜和 ‘s’ 一样。
float类型
| 类型 | 含义 |
|---|---|
| ‘e’ | 指数表示。 以使用字母 ‘e’ 来标示指数的科学计数法打印数字。 默认的精度为 6。 |
| ‘E’ | 指数表示。 与 ‘e’ 相似，不同之处在于它使用大写字母 ‘E’ 作为分隔字符。 |
| ‘f’ | 定点表示。 将数字显示为一个定点数。 默认的精确度为 6。 |
| ‘F’ | 定点表示。 与 ‘f’ 相似，但会将 nan 转为 NAN 并将 inf 转为 INF。 |
| ‘g’ | 常规格式。 对于给定的精度 p >= 1，这会将数值舍入到 p 位有效数字，再将结果以定点格式或科学计数法进行格式化，具体取决于其值的大小。 准确的规则如下：假设使用表示类型 ‘e’ 和精度 p-1 进行格式化的结果具有指数值 exp。 那么如果 m <= exp < p，其中 m 以 -4 表示浮点值而以 -6 表示 Decimal 值，该数字将使用类型 ‘f’ 和精度 p-1-exp 进行格式化。 否则的话，该数字将使用表示类型 ‘e’ 和精度 p-1 进行格式化。 在两种情况下，都会从有效数字中移除无意义的末尾零，如果小数点之后没有余下数字则小数点也会被移除，除非使用了 ‘#’ 选项。 正负无穷，正负零和 nan 会分别被格式化为 inf, -inf, 0, -0 和 nan，无论精度如何设定。 精度 0 会被视为等同于精度 1。 默认精度为 6。" |
| ‘G’ | 常规格式。 类似于 ‘g’，不同之处在于当数值非常大时会切换为 ‘E’。 无穷与 NaN 也会表示为大写形式。 |
| ‘n’ | 数字。 这与 ‘g’ 相似，不同之处在于它会使用当前区域设置来插入适当的数字分隔字符。 |
| ‘%’ | 百分比。 将数字乘以 100 并显示为定点 (‘f’) 格式，后面带一个百分号。 |
| None | 类似于 ‘g’，不同之处在于当使用定点表示法时，小数点后将至少显示一位。 默认精度与表示给定值所需的精度一样。 整体效果为与其他格式修饰符所调整的 str() 输出保持一致。 |
format(1.1,".3%") #使用百分号表示转百分比,保留三位有效数字
'110.000%'
frozenset()
frozenset([iterable])
- 简介
- 返回一个新的 frozenset 对象,frozenset 是一个内置的类（frozenset是一种冻结的集合，不能再添加或删除任何元素）
- 输入
- iterable – 可迭代的对象，比如列表、字典、元组等等
- 返回
- 返回一个frozenset 对象
a = set([1,2,3])
b = frozenset(a)
a.remove(1)
print(a)
print("＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊")
b.remove(1) # frozenset对象不能进行删除，和添加.等操作
File "", line 6
b.remove(1) # frozenset对象不能进行删除，和添加.等操作
^
SyntaxError: invalid character in identifier
getattr()
getattr(object, name, default)
- 简介
- 获取对象的属性值
- 输入
- object 要获取属性的对象
- name 要获取的属性的名称
- default 可选参数，如果对象没有要获取的属性，则返回默认值．如果对象没有查询的属性且没有默认值会报错
- 输出
*返回获取到的值
class getattr_A(object):
a = 1
getattr_a = getattr_A()
print(getattr(getattr_a,"a",111))
print(getattr(getattr_a,"b",111))
1
111
globals()
函数会以字典类型返回当前位置模块的全部全局变量。
globals()返回的是当前模块的字典（在函数或方法中，不是调用它的模块，而是定义它的模块）。
def a():
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq=2
print(locals())
for i in globals(): #和在函数内外无关，都会返回整个模块的全局变量
print(i)
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz=3
print(enumerate(globals()))
a()
{'qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq': 2}
__name__
__doc__
__package__
__loader__
__spec__
__builtin__
__builtins__
_ih
_oh
_dh
In
Out
get_ipython
exit
quit
_
__
___
_i
_ii
_iii
_i1
a
_i2
_i3
hasattr()
hasattr(object, name)
- 简介
- 判断对象是否包含对应的属性。
- 输入
- object 要获取属性的对象
- name 要获取的属性的名称
- 输出
- 有该属性返回 True，否则返回 False
class Coordinate:
x = 10
y = -5
z = 0
point1 = Coordinate()
print(hasattr(point1, 'x'))
print(hasattr(point1, 'y'))
print(hasattr(point1, 'z'))
print(hasattr(point1, 'no')) # 没有该属性
True
True
True
False
hash()
hash(object)
- 简介
- 用于获取取一个对象（字符串或者数值等）的哈希值
- 返回该对象的哈希值（如果它有的话）。
- 哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0）。
- 输入
- 对象
- 输出
- hash 值(为整数)
- 相同数字和整数的hash值相同
print(hash(165))
print(hash(165.0))
print(hash("name"))
print(hash("name1"))
print(hash(str([1,2,3])))
print(hash(str([3,2,1])))
print(hash(str(set([1,2,3]))))
print(hash(str(set([3,2,1]))))
165
165
1720662549452878971
-4294476845180715838
-6572221934557873766
-5932172304762146794
1572098986052697636
1572098986052697636
class Student:
def __init__(self, age, name):
self.age = age
self.name = name
def __eq__(self, other):
return self.age == other.age and self.name == other.name
def __hash__(self):
return hash((self.age, self.name))
student = Student(23, 'Shubham')
print("The hash is: %d" % hash(student))
The hash is: -489814130248900144
help()
**help(object)**
1. 简介
* 函数用于查看函数或模块用途的详细说明。
2. 输入
*ogject 对象
help()
Welcome to Python 3.8's help utility!
If this is your first time using Python, you should definitely check out
the tutorial on the Internet at https://docs.python.org/3.8/tutorial/.
Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules. To quit this help utility and
return to the interpreter, just type "quit".
To get a list of available modules, keywords, symbols, or topics, type
"modules", "keywords", "symbols", or "topics". Each module also comes
with a one-line summary of what it does; to list the modules whose name
or summary contain a given string such as "spam", type "modules spam".
help([])
Help on list object:
class list(object)
| list(iterable=(), /)
|
| Built-in mutable sequence.
|
| If no argument is given, the constructor creates a new empty list.
| The argument must be an iterable if specified.
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return key in self.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __gt__(self, value, /)
| Return self>value.
|
| __iadd__(self, value, /)
| Implement self+=value.
|
| __imul__(self, value, /)
| Implement self*=value.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return selfhelp("list")
Help on class list in module builtins:
class list(object)
| list(iterable=(), /)
|
| Built-in mutable sequence.
|
| If no argument is given, the constructor creates a new empty list.
| The argument must be an iterable if specified.
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return key in self.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __gt__(self, value, /)
| Return self>value.
|
| __iadd__(self, value, /)
| Implement self+=value.
|
| __imul__(self, value, /)
| Implement self*=value.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return selfhex()
hex(x)
- 简介
- 将整数转换成16进制，以字符串形式表示
- 输入
- x 十进制数
- 如果 x 不是 Python int 对象，则必须定义返回整数的 index() 方法.
- 输出
- 对应的16进制字符串
print(hex(255))
print(hex(-25))
0xff
-0x19
# 使用format转16进制.可去掉前缀0x
print(format(255,"#x"))
print(format(255,"x"))
print(format(255,"X"))
print('%#x' % 255, '%x' % 255, '%X' % 255)
0xff
ff
FF
0xff ff FF
id()
id(object)
- 简介
- 函数返回对象的唯一标识符，标识符是一个整数。
- CPython 中 id() 函数用于获取对象的内存地址。
- 在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id() 值。
- 输入
- object 对象
- 输出
- 对象的唯一标示
a = "123" # 字符串
print(id(a)) #
print(id("123"))
# 相同字符串 整数的id相同
print("**********************")
b = [1,2,3] # 列表
print(id(b)) #
print(id([1,2,3]))
print("**********************")
c = {'num1':1,'num2':2,'num3':3} # 字典
print(id(c)) #
print(id({'num1':1,'num2':2,'num3':3} ))
139923729362480
139923729362480
**********************
139923737483712
139923737501248
**********************
139923737165952
139923737166016
id(1)
94838230424896
input()
input(prompt)
- 简介
- 函数接受一个标准输入数据，返回为 string 类型
- 输入
- prompt : 提示信息
- 返回
- 返回输入的字符串(python3所有输入都看做字符串)()
- python2 中 input() 相等于 eval(raw_input(prompt)
input_a = input("test")
print(type(input_a))
test123
int()
class int(x, base=10)
-
简介
- 将一个字符串或数字转换为整型。
- 如果 x 定义了 int()，int(x) 将返回 x.int()。
如果 x 定义了 index()，它将返回 x.index()。
如果 x 定义了 trunc()，它将返回 x.trunc()。 对于浮点数，它将向零舍入。
-
输入
- x – 字符串或数字。
- base – 进制数，默认十进制。指定进制数x需要为字符串类型或bytes
-
返回
- 整数类型
print(int()) # 不传入参数时，得到结果0
print(int(0.5)) # 去掉小数部分，得到结果0
print(int(3)) # 得到结果3
print(int('0xa',16)) # 十六进制数“0xa”转换成十进制整数，得到结果10
print(int('00010',2)) # 二进制数“00010”转换成十进制整数，得到结果2
0
0
3
10
2
class int_A:
def __int__(self):
return "11"
int_a = int_A()
int(int_a)
3
isinstance()
isinstance(object, classinfo)
-
简介
- 判断一个对象是否是一个已知的类型，类似 type()
- 如果参数 object 是参数 classinfo 的实例或者是其 (直接、间接或 虚拟) 子类则返回 True。
- 如果 object 不是给定类型的对象，函数将总是返回 False。
- 如果 classinfo 是类型对象元组（或由其他此类元组递归组成的元组），
- 那么如果 object 是其中任何一个类型的实例就返回 True。
- 判断一个对象是否是一个已知的类型，类似 type()
-
输入
- object 实例对象
- classinfo 直接或间接类名、基本类型或者由它们组成的元组
-
返回值
- True或False
-
isinstance() 与 type() 区别：
- type() 不会认为子类是一种父类类型，不考虑继承关系。
- isinstance() 会认为子类是一种父类类型，考虑继承关系。
a = 2
print(isinstance(a,int)) # True
print(isinstance(a,str)) # False
print(isinstance(a,(str,tuple,dict))) # False
print(isinstance(a,(str,tuple,int))) # 是元组其中的一个则返回True
True
False
False
True
class A:
pass
class B(A):
pass
print(isinstance(A(),A)) # True
print( type(A()) == A ) # True
print(isinstance(B(),A)) # True
print( type(B()) == A ) # False --type()不考虑继承关系
True
True
True
False
issubclass()
issubclass(class, classinfo)
-
简介
判断参数 class 是否是类型参数 classinfo 的子类(或者是相同类)
-
输入
- 如果 class 是 classinfo 的 (直接、间接或 虚拟) 子类则返回 True。
- 类会被视作其自身的子类。 classinfo 也以是类对象的元组
-
返回
True或False
class a:
pass
class b(a): # b继承了a，即b是a的子类
pass
class c:
pass
print(issubclass(a,b)) # 判断 a 是 b 的子类？
# False
print(issubclass(b,a)) # 判断 b 是 a 的子类？
# True
print(issubclass(a,a))
#True
print(issubclass(b,(a,c))) # classinfo为元组
False
True
True
True
iter()
iter(object, sentinel)
1. 简介
用来生成迭代器
- 输入
- object – 支持迭代的集合对象。
- sentinel – 如果传递了第二个参数，则参数 object 必须是一个可调用的对象（如，函数），此时，iter 创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用 object。
- 当第二个参数不存在， 第一个参数必须是支持迭代协议的容器类型对象，例如字典等， 或者是支持序列协议的序列类型对象，例如列表等，如果都不支持则报错。
- 当第二个参数存在， 即哨兵参数存在，则第一个参数必须是可调用对象，即函数等，以此种方式创建的迭代器对象将会调用object，可调用对象参数调用时不需要参数，如果可调用对象调用后返回值与哨兵对象值相同， 则结束调用。
- 返回
- 迭代器
详见迭代器篇
it = [1,2,3]
it_list = iter(it)
print(next(it_list))
# 1
print(next(it_list))
# 2
print(next(it_list))
# 3
print(next(it_list))
# StopIteration
1
2
3
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
in
8 print(next(it_list))
9 # 3
---> 10 print(next(it_list))
11 # StopIteration
StopIteration:
# 等到迭代器,运行到STOP后停止
import random as rd
def test():
choices = ['haha','man','good','NLP','STOP','doggie']
x = rd.choice(choices)
print("see what wee choose:【%s】"%x)
return x
for n in iter(test, 'STOP'):
print(n)
see what wee choose:【good】
good
see what wee choose:【STOP】
len()
len(s)
-
简介
对象（字符、列表、元组等）长度或项目个数
-
输入
s 实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等） -
返回
对象的长度
# len()方法返回对象（字符、列表、元组等）长度或元素个数。
print(len('1234')) # 字符串，返回字符长度4
print(len(['1234','asd',1])) # 列表，返回元素个数3
print(len((1,2,3,4,50))) # 元组，返回元素个数5
print(len(12)) # 注意：整数类型不适用，否则报错
# TypeError: object of type 'int' has no len()
4
3
5
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in
4 print(len((1,2,3,4,50))) # 元组，返回元素个数5
5
----> 6 print(len(12)) # 注意：整数类型不适用，否则报错
7 # TypeError: object of type 'int' has no len()
TypeError: object of type 'int' has no len()
list()
list(iterable)
-
解释
生成列表类型
-
输入
- iterable 可迭代对象
-
返回
- 列表
print(list({"a":1}))
c = (1,2,3)
print(list(c))
['a']
[1, 2, 3]
locals()
- 更新并返回表示当前本地符号表的字典。
- 在函数代码块但不是类代码块中调用 locals() 时将返回自由变量。
- 请注意在模块层级上，locals() 和 globals() 是同一个字典。
- (locals 在函数中则返回在locals()前面定义的函数,globals()在函数中返回全局变量,在模块级则都返回的是全局变量)
def locals_a():
local_aaaa = 111
print(locals())
local_bbbb = 222
locals_a()
{'local_aaaa': 111}
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
in
----> 1 long()
NameError: name 'long' is not defined
map()
map(function, iterable,…)
-
解释
返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器
-
输入
- function 函数
- iterable 一个或多个迭代器(多个迭代器时,函数要和迭代器对应)
-
返回
- python3.x 返回迭代器
- python2.x 返回列表
map_a = [1,2,3]
map_b = [4,5,6]
def square(x):
return x**2
map_c = map(square,map_a)
for i in map_c:
print(i)
1
4
9
map_a = [1,2,3]
map_b = [4,5,6]
def square(x,y):
return x*y
map_c = map(square,map_a,map_b)
for i in map_c:
print(i)
4
10
18
max()
max(iterable,key,default)
-
简介
返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。
* 如果有多个最大元素，则此函数将返回第一个找到的 -
输入
- iterable 迭代器
- key (可选参数)其为一个函数，用来指定取最大值的方法
- default (可选参数)迭代对象为空时，必须指定参数default，用来返回默认值
-
返回
- 最大值参数
print(max([1,3],[2,5]))
max_a = max([1,2,3])
print(max_a)
max_b = [{"name":"first","age":23,"height":170},{"name":"second","age":33,"height":165},{"name":"third","age":15,"height":170}]
print(max(max_b, key=lambda x:x["height"]))
[2, 5]
3
{'name': 'first', 'age': 23, 'height': 170}
print(max((),default=1))# 3、传入可迭代对象为空时，必须指定参数default，用来返回默认值
print(max(()))#报错
1
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
in
1 print(max((),default=1))# 3、传入可迭代对象为空时，必须指定参数default，用来返回默认值
----> 2 print(max(()))#报错
ValueError: max() arg is an empty sequence
min()
min(iterable,key,default)
-
简介
返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。
* 如果有多个最小元素，则此函数将返回第一个找到的 -
输入
- iterable 迭代器
- key (可选参数)其为一个函数，用来指定取最小值的方法
- default (可选参数)迭代对象为空时，必须指定参数default，用来返回默认值
-
返回
- 最小值参数
print(min([1,3],[2,5]))
min_a = min([1,2,3])
print(min_a)
min_b = [{"name":"first","age":23,"height":170},{"name":"second","age":33,"height":165},{"name":"third","age":15,"height":170}]
print(min(min_b, key=lambda x:x["height"]))
[1, 3]
1
{'name': 'second', 'age': 33, 'height': 165}
print(min((),default=1))# 3、传入可迭代对象为空时，必须指定参数default，用来返回默认值
print(min(()))#报错
1
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
in
1 print(min((),default=1))# 3、传入可迭代对象为空时，必须指定参数default，用来返回默认值
----> 2 print(min(()))#报错
ValueError: min() arg is an empty sequence
next()
*next(iterable,default)
-
简介
返回迭代器的下一个项目
-
输入
- iterable 可迭代对象
- default 可选参数，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
-
输出
- 迭代器的下一个项目
# 首先获得Iterator对象:
it = iter([1,2,3,4,5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
print(x)
except StopIteration:
break
# 遇到StopIteration就退出循环
1
2
3
4
5
iter2 = iter([1,2])
print(next(iter2,"默认值"))
print(next(iter2,"默认值"))
print(next(iter2,"默认值"))
print(next(iter2,"默认值"))
1
2
默认值
默认值
object
返回一个没有特征的新对象。object 是所有类的基类。
它具有所有 Python 类实例的通用方法。这个函数不接受任何实参。
注解 由于 object 没有 dict，因此无法将任意属性赋给 object 的实例。
oct()
oct(x)
- 简介
- 将整数转换成8进制，以字符串形式表示
- 输入
- x 十进制数
- 如果 x 不是 Python int 对象，则必须定义返回整数的 index() 方法.
- 输出
- 对应的8进制字符串
print(oct(255))
print(oct(-25))
0o377
-0o31
# 使用format转8进制.可去掉前缀0o
print(format(255,"#o"))
print(format(255,"o"))
print('%#o' % 255, '%o' % 255)
0o377
377
0o377 377
open()
open(name, mode, buffering)
- 简介
读写文件使用
# todo 分数文件读写模块
ord()
ord(x)
-
简介
对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。
* 是chr()的逆函数 -
输入
- x: 单个 Unicode 字符
-
返回
- Unicode 字符对应的十进制整数
ord("€")
8364
pow()
pow(base,exp,mod)
-
简介
返回 base 的 exp 次幂；如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余
- 两参数形式 pow(base, exp) 等价于乘方运算符: base**exp
- pow(base, exp) % mod 更高效）
-
输入
- base:数值表达式
- exp:数值表达式
- mod:数值表达式
-
返回
结果
pow(38, -1, mod=97)
23
print()
*print(objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
- 简介
输出打印 - 输入
- objects : 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
- sep : 用来间隔多个对象，默认值是一个空格。
- end : 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
- file : 要写入的文件对象。
- flush : 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新
- 返回
无
print("www","baidu","com",sep=".",end="********end**\n")
print("hello")
www.baidu.com********end**
hello
file_print = open("print_file_test.txt","w")
import time
for i in range(20):
# 如果没有flush为True,则会把输出先放到缓存，输出完后才会写到文件
# 把file 重定向到file
print("print test%s"%(i),file=file_print,flush=True)
print(i)
time.sleep(1)
file_print.close()
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 重定向修改输出
import sys
sys_stdout = sys.stdout # 保存输出管道
file_print = open("print_file_test.txt","w")
sys.stdout = file_print # 输出重定向
print("输出重定向")
sys.stdout = sys_stdout #还原 原来的输出通道
file_print.close()
property()
todo
property(fget=None, fset=None, fdel=None, doc=None)
class C(object):
def __init__(self):
self._x = None
def getx(self):
return self._x
def setx(self, value):
self._x = value
def delx(self):
del self._x
x = property(getx, setx, delx, "I'm the 'x' property.")
range()
from collections import Iterable
isinstance(range(2),Iterable)
/home/zhangmeng/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:1: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated, and in 3.8 it will stop working
"""Entry point for launching an IPython kernel.
True
range(start, stop[, step])
- 简介
返回一个range对象（可迭代对象）,一般和for连用
*start包括，但是不包括stop - 输入
- start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
- stop: 计数到 stop 结束(可选参数)，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
- step：步长（可选参数），默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
- 返回
返回一个range对象
for i in range(1,6,2):
print(i)
1
3
5
repr()
repr(object)
-
简介
返回包含一个对象的可打印表示形式的字符串。
* 类可以通过定义 repr() 方法来控制此函数为它的实例所返回的内容。 -
输入
- object 对象
-
返回
- 对象的 string 格式
repr_dict = {'runoob': 'runoob.com', 'google': 'google.com'}
print(repr(repr_dict))
{'runoob': 'runoob.com', 'google': 'google.com'}
reversed()
reversed(seq)
-
简介
返回一个反向的 iterator
-
输入
- seq tuple, string, list ，range 或其它对象
- seq 必须是一个具有 reversed() 方法的对象或者是支持该序列协议
- 具有从 0 开始的整数类型参数的 len() 方法和 getitem() 方法。
- seq tuple, string, list ，range 或其它对象
-
返回
反向可迭代对象
str1 = "abcd"
# 字符串
print(list(reversed(str1)))
seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(seqTuple)))
# range
seqRange = range(5, 9)
print(list(reversed(seqRange)))
# 列表
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))
['d', 'c', 'b', 'a']
['b', 'o', 'o', 'n', 'u', 'R']
[8, 7, 6, 5]
[5, 3, 4, 2, 1]
rount()
round( x [, n] )
-
简介
浮点数x的四舍六入值（5看奇偶数），需要 高进度最好不要 使用
* 对于支持 round() 的内置类型，值会被舍入到最接近的 10 的负 ndigits 次幂的倍数；
* 如果与两个倍数的距离相等，则选择偶数
* 因此，round(0.5) 和 round(-0.5) 均为 0
* 而 round(1.5) 为 2。 -
输入
- x:浮点数
- n: (可选参数)默认为0，表示保留的小数点位数
-
返回
print ("round(70.23456) : ", round(70.23456))
print ("round(56.659,1) : ", round(56.659,1))
print ("round(80.264, 2) : ", round(80.264, 2))
print ("round(100.000056, 3) : ", round(100.000056, 3))
print ("round(-100.000056, 3) : ", round(-100.000056, 3))
# 保留时出现5，看奇偶
print("round(0.5,0)",round(0.5,0))
print("round(1.5,0)",round(1.5,0))
round(70.23456) : 70
round(56.659,1) : 56.7
round(80.264, 2) : 80.26
round(100.000056, 3) : 100.0
round(-100.000056, 3) : -100.0
round(0.5,0) 0.0
round(1.5,0) 2.0
set()
set([iterable])
-
简介
创建一个无序不重复元素集
* 可进行关系测试。
* 删除重复数据。
* 计算交集、差集、并集等 -
输入
- iterable：可迭代对象(如string,list,tuple等)
-
返回
新的集合对象
print(set("abca"))
print(set([1,2,3,2]))
print(set({"a":1,"b":2}))
{'a', 'c', 'b'}
{1, 2, 3}
{'a', 'b'}
setattr()
setattr(object, name, value)
-
简介
获取对象的属性值
* 例如，setattr(x, ‘foobar’, 123) 等价于 x.foobar = 123 -
输入
- object 要添加属性的对象
- name 要添加的属性的名称
- value 要添加的属性的值
-
输出
无
class A(object):
bar = 1
setattr_a =A()
print("setattr前",getattr(setattr_a,"bar"))
setattr(setattr_a,"bar",100)
print("setattr后",getattr(setattr_a,"bar"))
setattr前 1
setattr后 100
slice()
slice(start, stop[, step])
- 简介
返回一个range对象（可迭代对象）
*start包括，但是不包括stop - 输入
- start: 计数从 start 开始。默认是从 0 开始。
- stop: 计数到 stop 结束(可选参数)，但不包括 stop。
- step：步长（可选参数），默认为1。
- 返回
返回一个slice对象
a = slice(2)
print("a",a)
b = [1,2,3,4]
print("b[a]",b[a])
c = slice(0,-1,2)
print("b[c]",b[c])
a slice(None, 2, None)
b[a] [1, 2]
b[c] [1, 3]
sorted()
sorted(iterable, key=None, reverse=False)
-
简介
返回可迭代对象的排序的列表
-
输入
- iterable 迭代器
- key (可选参数)其为一个函数，用来指定排序的方法
- reverse (可选参数) 如果设为 True，则每个列表元素将按反向顺序比较进行排序,默认为False
-
返回
- 排序后的列表
print(sorted([1,2,3]))
print(sorted([1,2,3],reverse=False))
print(sorted([1,2,3],reverse=True))
[1, 2, 3]
[1, 2, 3]
[3, 2, 1]
sort_b = [{"name":"first","age":23,"height":170},{"name":"second","age":33,"height":165},{"name":"third","age":15,"height":170}]
print("按照age排序××××××××××××××××")
sort_c = sorted(sort_b, key=lambda x:x["height"])
for i in sort_c:
print(i)
print("按照height排序××××××××××××××××")
sort_d = sorted(sort_b, key=lambda x:x["age"])
for i in sort_d:
print(i)
按照age排序××××××××××××××××
{'name': 'second', 'age': 33, 'height': 165}
{'name': 'first', 'age': 23, 'height': 170}
{'name': 'third', 'age': 15, 'height': 170}
按照height排序××××××××××××××××
{'name': 'third', 'age': 15, 'height': 170}
{'name': 'first', 'age': 23, 'height': 170}
{'name': 'second', 'age': 33, 'height': 165}
staticmethod()
@staticmethod*
- 简介
将方法转换为静态方法。静态方法不会接收隐式的第一个参数。
class C(object):
@staticmethod
def f():
print('runoob');
def g():
print("i'm g")
C.f(); # 静态方法无需实例化，不添加 @staticmethod可调用
cobj = C()
cobj.f() # 也可以实例化后调用，不添加 @staticmethod实例对象不可调用
C.g()
cobj.g() #会报错
runoob
runoob
i'm g
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in
11
12 C.g()
---> 13 cobj.g() #会报错
TypeError: g() takes 0 positional arguments but 1 was given
str()
str(object=b’’, encoding=‘utf-8’, errors=‘strict’)
-
简介
将对象转为str类型
* 如果 encoding 或 errors 均未给出，str(object) 返回 object.str()，这是 object 的“非正式”或格式良好的字符串表示。
* 对于字符串对象，这是该字符串本身。 如果 object 没有 str() 方法，则 str() 将回退为返回 repr(object)。如果 encoding 或 errors 至少给出其中之一，
* 则 object 应该是一个 bytes-like object (例如 bytes 或 bytearray)。 在此情况下，如果 object 是一个 bytes (或 bytearray) 对象，则 str(bytes, encoding, errors) 等价于 bytes.decode(encoding, errors)。
* 否则的话，会在调用 bytes.decode() 之前获取缓冲区对象下层的 bytes 对象。 -
输入
- object : 对象
- encoding : 编码格式
- errors : 设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeError。 其他可能得值有 ‘ignore’, ‘replace’, ‘xmlcharrefreplace’, ‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值。
-
返回
str 对象
sum()
sum(iterable[, start])
- 简介
对iterable求和运算 - 输入参数
- iterable:求和迭代器
- start 可选参数，(默认为0)前面迭代器求和后，加上start
- 返回
- 求和结果
print(sum([1,2,3,4,5],10))
print(sum([1,2]))
25
3
super()
todo
tuple()
tuple(iterable)
-
简介
将可迭代系列（如列表）转换为元组,元组为不可变类型
-
输入
iterable 可迭代对象 -
返回
- 元组
list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1=tuple(list1)
print(tuple1)
('Google', 'Taobao', 'Runoob', 'Baidu')
typle()
type(object)
1. 简介
* 传入一个参数时，返回 object 的类型。
2. 输入
* object:对象
3. 返回返回值是一个 type 对象，通常与 object.__class__ 所返回的对象相同。
type(name, bases, dict)
1. 简介
* 返回新的类型对象
传入三个参数时，返回一个新的 type 对象。 这在本质上是 class 语句的一种动态形式。 name 字符串即类名并且会成为 __name__ 属性；bases 元组列出基类并且会成为 __bases__ 属性；而 dict 字典为包含类主体定义的命名空间并且会被复制到一个标准字典成为 __dict__ 属性
2. 输入
name ： 类的名称。
bases ： 基类的元组。
dict ： 字典，类内定义的命名空间变量。
3.返回
创建的新的类
type(1)
int
class X:
a = 1
X = type('X', (object,), dict(a=1,b=3)) # 产生一个新的类型 X
aa =X()
aa.b
3
vars()
vars(object)
1. 简介
对象object的属性和属性值的字典对象。
* 模块和实例这样的对象具有可更新的 dict 属性；但是，其它对象的 dict 属性可能会设为限制写入（例如，类会使用 types.MappingProxyType 来防止直接更新字典）。
* 不带参数时，vars() 的行为类似 locals()。 请注意，locals 字典仅对于读取起作用，因为对 locals 字典的更新会被忽略
2. 输入
* object 如果object 为空,返回 类似locals()
3. 返回
* 对象object的属性和属性值的字典对象。
class vars_test(object):
A=2
vars_a = vars_test()
vars(vars_test)
mappingproxy({'__module__': '__main__',
'A': 2,
'__dict__': ,
'__weakref__': ,
'__doc__': None})
zip()
*zip(iterables)
-
简介
创建一个聚合了来自每个可迭代对象中的元素的迭代器。
-
输入 一个 或多个迭代器
- *iterables 一个 或多个迭代器
-
返回
- 迭代器
# 相当于实现了如下代码的功能
def zip(*iterables):
# zip('ABCD', 'xy') --> Ax By
sentinel = object()
iterators = [iter(it) for it in iterables]
while iterators:
result = []
for it in iterators:
elem = next(it, sentinel)
if elem is sentinel:
return
result.append(elem)
yield tuple(result)
# 组合
list(zip(['a', 'b', 'c',"d"], [1, 2, 3]))
[('a', 1), ('b', 2), ('c', 3)]
# 拆分为多个元祖
some_list = [('a', 1), ('b', 2), ('c', 3)]
letters, nums = zip(*some_list)
print(letters)
print(nums)
#结果
# letters: ('a', 'b', 'c')
# nums: (1, 2, 3)
('a', 'b', 'c')
(1, 2, 3)
# 将 data 从 4x3 矩阵转置成 3x4 矩阵。
data = ((0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11))
data_transpose = zip(*data)
# 结果:
[(0, 3, 6, 9), (1, 4, 7, 10), (2, 5, 8, 11)]
[(0, 3, 6, 9), (1, 4, 7, 10), (2, 5, 8, 11)]
import()
import(name[, globals[, locals[, fromlist[, level]]]])
-
简介
函数用于动态加载类和函数
-
输入
- name:模块名
-
返回
*元祖列表
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
in
----> 1 __import__()
TypeError: __import__() missing required argument 'name' (pos 1)