目录[-]
classification
属性相关:
14 delattr 删除属性
25 getattr 获取属性
27 hasattr 判断属性
57 setattr 设置属性
进制相关:
5 bin 二进制
30 hex 十六进制
46 oct 八进制
类修饰
11 classmethod 无需实例化即可调用属性
60 staticmethod 无需实例化可返回函数的静态方法
语句类
19 eval 简单语句,返回值,比如一些加减乘数的计算式
20 exec 复杂语句,执行代码
变量
26 globals 全局变量
39 locals 局部变量
1:abs
abs() 函数返回数字的绝对值。
abs(x) ##x -- 数值表达式,可以是整数,浮点数,复数
abs(-40) ##40
abs(100.10) ##100.1
2:all
all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 True,如果是返回 True,否则返回 False。
元素除了是 0、空、None、False 外都算 True。
空元组、空列表返回值为True。
all(iterable ) ##iterable -- 元组或列表
all(['a','b','c'])##列表list,元素都不为空或0 ##True
all(['a','b',''])##列表list,存在一个为空的元素 ##False
all([0,1,2,3])##列表list,存在一个为0的元素 ##False
all(('a','b','c'))##元组tuple,元素都不为空或0 ##True
all(('a','b',''))##元组tuple,存在一个为空的元素 ##False
all((0,1,2,3))##元组tuple,存在一个为0的元素 ##False
all([]) ##空列表True
all(()) ##空元组True
3:any
any() 函数用于判断给定的可迭代参数 iterable 是否有True,如果是,则返回 True,如果全部为False,则返回False。
元素除了是 0、空、FALSE 外都算 TRUE。
any(iterable) ##iterable -- 元组或列表
any(['a','b','c','d'])##列表list,元素都不为空或0 ##True
any(['a','b','','d'])##列表list,存在一个为空的元素 ##True
any([0,'',False])##列表list,元素全为0,'',false ##False
any(('a','b','c','d'))##元组tuple,元素都不为空或0 ##True
any(('a','b','','d'))##元组tuple,存在一个为空的元素 ##True
any((0,'',False))##元组tuple,元素全为0,'',false ##False
any([]) ##空列表False
any(())##空元组 False
4:ascii
该函数的返回值是一个字符串,该字符串中包含了ASCII编码的可打印字符,而非ASCII编码的字符将以转义字符的形式来显示。
ascii(object) ##object -- 对象
##参数是数值
ascii(123) ##123
ascii(12.3) ##12.3
ascii(0b1100) ##12
ascii(3.1 + 4.5j) ##(3.1+4.5j)
##参数是布尔值
ascii(True) ##True
ascii(n1<0) ##False
##参数是字符串
ascii("abc ABC") ##'abc ABC'
ascii("abc\nABC") ##'abc\nABC'
ascii("中国") ##'\u4e2d\u56fd'
5:bin
bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
bin(x) ##x -- int 或者 long int 数字
bin(0) ##0b0
bin(1) ##0b1
bin(5) ##0b101
6:bool
bool() 函数用于将给定参数转换为布尔类型,如果没有参数,返回 False。
bool 是 int 的子类。
bool(x) ##x -- 要进行转换的参数
bool() ##False
bool(0) ##False
bool(1) ##True
bool(2) ##True
bool('冯') ##True
issubclass(bool, int) ## True;bool 是 int 子类
7:bytearray
bytearray()方法返回一个新字节数组。这个数组里的元素是可变的,并且每个元素的值范围: 0 <= x < 256。
class bytearray([source[, encoding[, errors]]])
##如果 source 为整数,则返回一个长度为 source 的初始化数组;
##如果 source 为字符串,则按照指定的 encoding 将字符串转换为字节序列;
##如果 source 为可迭代类型,则元素必须为[0 ,255] 中的整数;
##如果 source 为与 buffer 接口一致的对象,则此对象也可以被用于初始化 bytearray。
##如果没有输入任何参数,默认就是初始化数组为0个元素。
array1=bytearray('12ab', 'utf-8')
print(array1) ##bytearray(b'12ab')
for value in array1:
print(value) ##49 50 97 98
array2=[1,2,3]
print(bytearray(array2)) ##bytearray(b'\x01\x02\x03')
for value in array2:
print(value) ##1 2 3
8:bytes
bytes 函数返回一个新的 bytes 对象,该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。
class bytes([source[, encoding[, errors]]])
##如果 source 为整数,则返回一个长度为 source 的初始化数组;
##如果 source 为字符串,则按照指定的 encoding 将字符串转换为字节序列;
##如果 source 为可迭代类型,则元素必须为[0 ,255] 中的整数;
##如果 source 为与 buffer 接口一致的对象,则此对象也可以被用于初始化 bytearray。
##如果没有输入任何参数,默认就是初始化数组为0个元素。
##当三个参数都不传时,返回长度为0的字节数组
print(bytes()) ##b''
print(len(bytes()))##求取长度 ##0
##当source参数为int时,返回该整数指定长度的空字节数组,int必须为正整数,否则有bug
print(bytes(2)) b'\x00\x00'
##当source参数为字符串时,必须提供encoding参数(指示编码方式即str.encode方式),然后将字符串以str.encode方式转化为字节数组 ##UTF代表通用转换格式;GB2312仅适用于简体中文编码
print(bytes('嘤嘤嘤','gbk')) ##b'\xe0\xd3\xe0\xd3\xe0\xd3'
print(bytes('嘤嘤嘤','utf-8')) ##b'\xe5\x98\xa4\xe5\x98\xa4\xe5\x98\xa4'
print(bytes('嘤嘤嘤','utf-16')) ##b'\xff\xfe$V$V$V'
print(bytes('嘤嘤嘤','gb2312')) ##b'\xe0\xd3\xe0\xd3\xe0\xd3'
print(bytes('yingyingying','ascii')) ##b'yingyingying'
print(bytes('yingyingying','gbk')) ##b'yingyingying'
print(bytes('yingyingying','utf-8')) ##b'yingyingying'
print(bytes('yingying','utf-16')) ##b'\xff\xfey\x00i\x00n\x00g\x00y\x00i\x00n\x00g\x00'
print(bytes('yingyingying','gb2312'))##b'yingyingying'
##当source参数为可迭代对象(元组、列表、字典等)时,其元素都必须在【0,255】区间内,就可以初始化到字节数组里
print(bytes([1,2,3])) ##b'\x01\x02\x03'
print(bytes([1,2,255])) ##b'\x01\x02\xff'
##返回后的数组无法进行修改
9:callable
callable() 函数用于检查一个对象是否是可调用的。如果返回 True,object 仍然可能调用失败;但如果返回 False,调用对象 object 绝对不会成功。
对于函数、方法、lambda 函式、 类以及实现了 call 方法的类实例, 它都返回 True。
callable(object) ##object -- 对象
callable(0) ##False
callable("runoob") ##False
def add(a,b):
return a+b
callable(add) ##True
class A:
defmethod(self):
return0
callable(A) ##True
a=A()
callable(a) ##False;没有实现__call__
class B:
def__call__(self):
return 0
callable(B) ##True
b=B()
callable(b) ##True;实现__call__
10:chr
chr() 用一个整数作参数,返回一个对应的字符。
chr(i) i -- 可以是10进制也可以是16进制的形式的数字,数字范围为0到1114111(16进制为0x10FFFF)。
ord('!') ##33
chr(33) ##!
11:classmethod
classmethod 修饰符对应的函数不需要实例化,不需要 self 参数,但第一个参数需要是表示自身类的 cls 参数,可以来调用类的属性,类的方法,实例化对象等。
classmethod ##无参数
class A(object):
bar = 1
def func1(self):
print ('foo')
@classmethod
def func2(cls):
print ('func2')
print (cls.bar)
cls().func1() ## 调用 foo 方法
A.func2() ## 不需要实例化
输出结果为:
func2
1
foo
12:compile
compile() 函数将一个字符串编译为字节代码。
compile(source, filename, mode[, flags[, dont_inherit]])
##source -- 字符串或者AST(Abstract Syntax Trees)对象。。
##filename -- 代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。
##mode -- 指定编译代码的种类。可以指定为 exec, eval, single。
##eval - 如果源是单个表达式
##exec - 如果源是语句块
##single - 如果源是单个交互式语句
##flags -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。
##flags和dont_inherit是用来控制编译源码时的标志。
str = "for i in range(0,5): print(i)"
c = compile(str,'','exec') ## 编译为字节代码对象
print(c) ##<code object <module> at 0x10141e0b0, file "", line 1>
exec(c) ##0 1 2 3 4
str = "3*4+5"
a = compile(str,'','eval')
eval(a) ##17
13:complex
complex() 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串,则不需要指定第二个参数。
class complex([real[, imag]])
##real -- int, long, float或字符串;
##imag -- int, long, float;
complex(1, 2) ##(1 + 2j)
complex(1) ## (1 + 0j)
complex("1") ##(1 + 0j)
## 注意:这个地方在"+"号两边不能有空格,也就是不能写成"1 + 2j",应该是"1+2j",否则会报错
complex("1+2j") ##(1 + 2j)
14:delattr
delattr 函数用于删除属性。
delattr(object, name)
##object -- 对象。
##name -- 必须是对象的属性。
class Coordinate:
x = 10
y = -5
z = 0
point1 = Coordinate()
print(point1.x) ##10
print(point1.y) ##-5
print(point1.z) ##0
delattr(Coordinate, 'z')
print(point1.x) ##10
print(point1.y) ##-5
print(point1.z) ## 触发错误AttributeError: Coordinate instance has no attribute 'z'
15:dict
dict() 函数用于创建一个字典。
class dict(**kwarg) ##**kwargs -- 关键字。
class dict(mapping, **kwarg) ##mapping -- 元素的容器,映射类型(Mapping Types)是一种关联式的容器类型,它存储了对象与对象之间的映射关系。
class dict(iterable, **kwarg) ##iterable -- 可迭代对象。
>>>dict() ## 创建空字典{}
>>> dict(a='a', b='b', t='t') ## 传入关键字{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3])) ## 映射函数方式来构造字典{'three': 3, 'two': 2, 'one': 1}
>>> dict([('one', 1), ('two', 2), ('three', 3)]) ## 可迭代对象方式来构造字典{'three': 3, 'two': 2, 'one': 1}
16:dir
dir() 函数不带参数时,返回当前范围内的变量、方法和定义的类型列表;带参数时,返回参数的属性、方法列表。如果参数包含方法__dir__(),该方法将被调用。如果参数不包含__dir__(),该方法将最大限度地收集参数信息。
dir([object]) ##object -- 对象、变量、类型。
dir() ##获得当前模块的属性列表
['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
dir([]) ##查看列表的方法
['__add__', '__class__', '__class_getitem__', '__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']
dir(math) ##查看模块的函数
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
17:divmod
Python divmod() 函数接收两个数字类型(非复数)参数,返回一个包含商和余数的元组(a // b, a % b)。
在 python 3.x 版本该函数不支持复数。
divmod(a, b) ##a: 数字,非复数。 b: 数字,非复数。
divmod(7, 2) ##(3, 1)
divmod(8, 2) ##(4, 0)
divmod(8, -2) ##(-4, 0)
divmod(3, 1.3) ##(2.0, 0.3999999999999999)
18:enumerate
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
enumerate(sequence, [start=0])
##sequence -- 一个序列、迭代器或其他支持迭代对象。
##start -- 下标起始位置。
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons)) ##[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
list(enumerate(seasons, start=1)) ##[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
print(i, element) ##0 one; 1 two; 2 three;
19:eval
eval() 函数用来执行一个字符串表达式,并返回表达式的计算值。如果是复杂语句块,返回值永远是None。eval 方法能使字符串本身的引号去掉,保留字符的原本属性。
eval(expression[, globals[, locals]])
##expression -- 表达式。
##globals -- 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
##locals -- 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。
x = 10
def func():
y = 20 ##局部变量y
a = eval("x+y")
print("a:",a) ##x没有就调用全局变量
b = eval("x+y",{"x":1,"y":2}) ##定义局部变量,优先调用
print("b:",b)
c = eval("x+y",{"x":1,"y":2},{"y":3,"z":4})
print("c:",c)
d = eval("print(x,y)")
print("d:",d) ##对于变量d,因为print()函数不是一个计算表达式,因此没有返回值
func()
输出结果:
a: 30
b: 3
c: 4
10,20 ##运行的print(x,y)
d: None
20:exec
exec 执行储存在字符串或文件中的 Python 语句,相比于 eval,exec可以执行更复杂的 Python 代码。
exec(object[, globals[, locals]])
##参数object:必选参数,表示需要被指定的 Python 代码。它必须是字符串或 code 对象。如果 object 是一个字符串,该字符串会先被解析为一组 Python 语句,然后
再执行(除非发生语法错误)。如果 object 是一个 code 对象,那么它只是被简单的执行。
##globals:可选参数,表示全局命名空间(存放全局变量),如果被提供,则必须是一个字典对象。
##locals:可选参数,表示当前局部命名空间(存放局部变量),如果被提供,可以是任何映射对象。如果该参数被忽略,那么它将会取与 globals 相同的值。
exec('print("Hello World")')
## 单行语句字符串
Hello World
exec ("""for i in range(5):print ("iter time: %d" % i)""")
## 多行语句字符串
iter time: 0
iter time: 1
iter time: 2
iter time: 3
iter time: 4
21:filter
filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回一个迭代器对象,如果要转换为列表,可以使用 list() 来转换。
该接收两个参数,第一个为函数,第二个为序列,序列的每个元素作为参数传递给函数进行判断,然后返回 True 或 False,最后将返回 True 的元素放到新列表中。
filter(function, iterable)
##function -- 判断函数。
##iterable -- 可迭代对象
##过滤出列表中的所有奇数:
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]
##过滤出1~100中平方根是整数的数:
import math
def is_sqr(x):
return math.sqrt(x) % 1 == 0
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist)
print(newlist) ##[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
22:float
float() 函数用于将整数和字符串转换成浮点数。
class float([x]) ##x -- 整数或字符串
float(1) ##1.0
float(112) ##112.0
float(-123.6) ##-123.6
float('123') ## 123.0
23:format
Python2.6 开始,新增了一种格式化字符串的函数 str.format(),它增强了字符串格式化的功能。
基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数,位置可以不按顺序。
## 不设置指定位置,按默认顺序
"{} {}".format("hello", "world") ##'hello world'
## 设置指定位置
"{0} {1}".format("hello", "world") ##'hello world'
"{1} {0} {1}".format("hello", "world") ##'world hello world'
## 通过字典设置参数
print("网站名:{name}, 地址 {url}".format(name="编程", url="python.org")) ##网站名:编程, 地址 python.org
site = {"name": "编程", "url": "python.org"}
print("网站名:{name}, 地址 {url}".format(**site)) ##网站名:编程, 地址 python.org
## 通过列表索引设置参数
my_list = ['编程', 'python.or']
print("网站名:{0[0]}, 地址 {0[1]}".format(my_list)) ## "0" 是必须的,网站名:编程, 地址 python.org
数字 | 格式 | 输出 | 描述 |
---|---|---|---|
3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
3.1415926 | {:+.2f} | 3.14 | 带符号保留小数点后两位 |
-1 | {:-.2f} | -1 | 带符号保留小数点后两位 |
2.71828 | {:.0f} | 3 | 不带小数 |
5 | {:0>2d} | 5 | 数字补零 (填充左边, 宽度为2) |
5 | {:x<4d} | 5xxx | 数字补x (填充右边, 宽度为4) |
10 | {:x<4d} | 10xx | 数字补x (填充右边, 宽度为4) |
1000000 | {:,} | 1,000,000 | 以逗号分隔的数字格式 |
0.25 | {:.2%} | 25.00% | 百分比格式 |
1000000000 | {:.2e} | 1.00E+09 | 指数记法 |
13 | {:>10d} | 13 | 右对齐 (默认, 宽度为10) |
13 | {:<10d} | 13 | 左对齐 (宽度为10) |
13 | {:^10d} | 13 | 中间对齐 (宽度为10) |
11 | '{:b}'.format(11) | 1011 | 进制 b、d、o、x 分别是二进制、十进制、八进制、十六进制。 |
'{:d}'.format(11) | 11 | ||
'{:o}'.format(11) | 13 | ||
'{:x}'.format(11) | b | ||
'{:##x}'.format(11) | 0xb | ||
'{:##X}'.format(11) | 0XB |
^, <, > 分别是居中、左对齐、右对齐,后面带宽度, : 号后面带填充的字符,只能是一个字符,不指定则默认是用空格填充。
+ 表示在正数前显示 +,负数前显示 -; (空格)表示在正数前加空格
此外我们可以使用大括号 {} 来转义大括号,如下实例:
print ("{} 对应的位置是 {{0}}".format("runoob")) ##runoob 对应的位置是 {0}
24:frozenset
frozenset() 返回一个冻结的集合,冻结后集合不能再添加或删除任何元素。
class frozenset([iterable]) ##iterable -- 可迭代的对象,比如列表、字典、元组等等。
a = frozenset(range(10)) ## 生成一个新的不可变集合frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
b = frozenset('runoob') ## 创建不可变集合frozenset(['b', 'r', 'u', 'o', 'n'])
25:getattr
getattr() 函数用于返回一个对象属性值。
getattr(object, name[, default])
##object -- 对象。
##name -- 字符串,对象属性。
##default -- 默认返回值,如果不提供该参数,在没有对应属性时,将触发 AttributeError。
class A(object):
bar = 1
a = A()
getattr(a, 'bar') ## 获取属性 bar 值1
getattr(a, 'bar2') ## 属性 bar2 不存在,触发异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'A' object has no attribute 'bar2'
getattr(a, 'bar2', 3) ## 属性 bar2 不存在,但设置了默认值3
26:globals
globals() 函数会以字典类型返回当前位置的全部全局变量。
globals() ##空代码显示为:{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000179F9E4C250>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': '文件绝对路径', '__cached__': None}
27:hasattr
hasattr() 函数用于判断对象是否包含对应的属性。
hasattr(object, name)
##object -- 对象。
##name -- 字符串,属性名。
class Coordinate:
x = 10
y = -5
z = 0
point1 = Coordinate()
print(hasattr(point1, 'x')) ##True
print(hasattr(point1, 'y')) ##True
print(hasattr(point1, 'z')) ##True
print(hasattr(point1, 'no')) ##False没有该属性
28:hash
hash() 用于获取取一个对象(字符串或者数值等)的哈希值。
hash(object) ##object -- 对象;
hash('test') ## 字符串 2314058222102390712
hash(1) ## 数字 1
hash(str([1,2,3])) ## 集合 1335416675971793195
hash(str(sorted({'1':1}))) ## 字典 7666464346782421378
29:help
help() 函数用于查看函数或模块用途的详细说明。
help([object]) ##object -- 对象;
help('hash') ##打印help括号里的对象的详细说明
30:hex
hex() 函数用于将一个指定数字转换为 16 进制数。
hex(x) ##x -- 一个整数
hex(255) ##'0xff'
hex(-42) ##'-0x2a'
hex(12) ##'0xc'
type(hex(12)) ##<class 'str'>
31:id
id() 函数返回对象的唯一标识符,标识符是一个整数。
CPython 中 id() 函数用于获取对象的内存地址。
a = 'runoob'
id(a) ##4531887632
b = 1
id(b) ##140588731085608
32:input
python3.x 中 input() 函数接受一个标准输入数据,返回为 string 类型。在 Python3.x 中 raw_input() 和 input() 进行了整合,去除了 raw_input( ),仅保留了input( )函数,其接收任意任性输入,将所有输入默认为字符串处理,并返回字符串类型。
input([prompt]) ##prompt: 提示信息
a = input("input:") ## 输入整数123
type(a) ##<class 'str'>
a,b,c = (input("请输入三角形三边的长:").split()) ##输入三个数字,用空格隔开
a= int(a)
b= int(b)
c= int(c)
33:int
int() 函数用于将一个字符串或数字转换为整型。
class int(x, base=10)
##x -- 字符串或数字。
##base -- 进制数,默认十进制。
int() ## 不传入参数时,得到结果0
int(3) ##3
int(3.6) ##3
int('12',16) ## 如果是带参数base的话,12要以字符串的形式进行输入,12 为 16进制,结果为18
int('0xa',16) ##10
int('10',8) ##8
34:isinstance
isinstance() 函数来判断一个对象是否是一个已知的类型,类似 type()。
isinstance() 与 type() 区别:
- type() 不会认为子类是一种父类类型,不考虑继承关系。
- isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
isinstance(object, classinfo)
##object -- 实例对象。
##classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组。
a = 2
isinstance (a,int) ##True
isinstance (a,str) ##False
isinstance (a,(str,int,list)) ##True
class A:
pass
class B(A):
pass
isinstance(A(), A) ## returns True
type(A()) == A ## returns True
isinstance(B(), A) ## returns True
type(B()) == A ## returns False
35:issubclass
issubclass() 方法用于判断参数 class 是否是类型参数 classinfo 的子类。
issubclass(class, classinfo)
##class -- 类。
##classinfo -- 类。
class A:
pass
class B(A):
pass
print(issubclass(B,A)) ## 返回 True
36:iter
iter() 函数用来生成迭代器。
iter(object[, sentinel])
##object -- 支持迭代的集合对象。
##sentinel -- 如果传递了第二个参数,则参数 object 必须是一个可调用的对象(如,函数),此时,iter 创建了一个迭代器对象,每次调用这个迭代器对象的__next__()方法时,都会调用 object。
lst = [1, 2, 3]
for i in iter(lst):
print(i)
1
2
3
37:len
Python len() 方法返回对象(字符、列表、元组等)长度或项目个数。
len( s ) ##s -- 对象。
str = "runoob"
len(str) ## 字符串长度6
l = [1,2,3,4,5]
len(l) ## 列表元素个数5
38:list
list() 方法用于将元组或字符串转换为列表。
注:元组与列表是非常类似的,区别在于元组的元素值不能修改,元组是放在括号中,列表是放于方括号中。
list( seq ) ##seq -- 要转换为列表的元组或字符串。
aTuple = (123, 'Google', 'Runoob', 'Taobao')
list1 = list(aTuple)
print (list1) ## [123, 'Google', 'Runoob', 'Taobao']
str="Hello World"
list2=list(str)
print (list2) ##['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']
39:locals
locals() 函数会以字典类型返回当前位置的全部局部变量。
对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。
locals() ##无参数
def runoob(arg): ## 两个局部变量:arg、z
z= 1
print (locals())
runoob(4) ##{'arg': 4, 'z': 1}
40:map
map() 函数会根据提供的函数对指定序列做映射。
第一个参数 function 以参数序列中的每一个元素调用 function 函数,返回包含每次 function 函数返回值的新列表。
map(function, iterable, ...)
##function -- 函数
##iterable -- 一个或多个序列
##返回一个迭代器。
def square(x) : ## 计算平方数
return x ** 2
map(square, [1,2,3,4,5]) ## 计算列表各个元素的平方
## 返回迭代器<map object at 0x100d3d550>
list(map(square, [1,2,3,4,5])) ## 使用 list() 转换为列表
##[1, 4, 9, 16, 25]
list(map(lambda x: x ** 2, [1, 2, 3, 4, 5])) ## 使用 lambda 匿名函数
##[1, 4, 9, 16, 25]
41:max
max() 方法返回给定参数的最大值,参数可以为序列。
max( x, y, z, .... )
##x -- 数值表达式。
##y -- 数值表达式。
##z -- 数值表达式。
print (max(80, 100, 1000)) ##1000
print (max(-20, 100, 400)) ##400
print (max(-80, -20, -10)) ##10
print (max(0, 100, -400)) $100
42:memoryview
memoryview() 函数返回给定参数的内存查看对象(memory view)。
所谓内存查看对象,是指对支持缓冲区协议的数据进行包装,在不需要复制对象基础上允许Python代码访问。
memoryview(obj) ##obj -- 对象
v = memoryview('abcefg')
v[1] ##'b'
v[-1] ##'g'
v[1:4] ##<memory at 0x77ab28>
v[1:4].tobytes() ##'bce'
v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1]) ##98
print(v[-1]) ##103
print(v[1:4]) ##<memory at 0x10f543a08>
print(v[1:4].tobytes()) ##b'bce'
43:min
min() 方法返回给定参数的最小值,参数可以为序列。
min( x, y, z, .... )
##x -- 数值表达式。
##y -- 数值表达式。
##z -- 数值表达式。
print ( min(80, 100, 1000)) ##80
print (min(-20, 100, 400)) ##-20
print (min(-80, -20, -10)) ##-80
print (min(0, 100, -400)) ##-400
44:next
next() 返回迭代器的下一个项目。
next() 函数要和生成迭代器的 iter() 函数一起使用。
next(iterable[, default])
##iterable -- 可迭代对象
##default -- 可选,用于设置在没有下一个元素时返回该默认值,如果不设置,又没有下一个元素则会触发 StopIteration 异常。
## 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
## 循环:
while True:
try:
## 获得下一个值:
x = next(it)
print(x)
except StopIteration:
## 遇到StopIteration就退出循环
break
结果为:
1
2
3
4
5
45:object
空
46:oct
oct() 函数将一个整数转换成 8 进制字符串,8 进制以 0o 作为前缀表示。
oct(x) ##x -- 整数。
oct(10) ##'0o12'
oct(20) ##'0o24'
oct(15) ##'0o17'
47:open
Python open() 函数用于打开一个文件,并返回文件对象,在对文件进行处理过程都需要使用到这个函数,如果该文件无法被打开,会抛出 OSError。
注意:使用 open() 函数一定要保证关闭文件对象,即调用 close() 函数。
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
##file: 必需,文件路径(相对或者绝对路径)。
##mode: 可选,文件打开模式
##buffering: 设置缓冲
##encoding: 一般使用utf8
##errors: 报错级别
##newline: 区分换行符
##closefd: 传入的file参数类型
##opener:
模式 | 描述 |
---|---|
t | 文本模式 (默认)。 |
x | 写模式,新建一个文件,如果该文件已存在则会报错。 |
b | 二进制模式。 |
+ | 打开一个文件进行更新(可读可写)。 |
U | 通用换行模式(不推荐)。 |
r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。 |
r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。 |
w | 打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。 |
wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。 |
w+ | 打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。 |
wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件,并从开头开始编辑,即原有内容会被删除。如果该文件不存在,创建新文件。一般用于非文本文件如图片等。 |
a | 打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。 |
ab | 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。也就是说,新的内容将会被写入到已有内容之后。如果该文件不存在,创建新文件进行写入。 |
a+ | 打开一个文件用于读写。如果该文件已存在,文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在,创建新文件用于读写。 |
ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在,文件指针将会放在文件的结尾。如果该文件不存在,创建新文件用于读写。 |
测试同目录下的文件 test.txt,内容如下:
123
456
789
f=open('test.txt')
a=f.read() ##str:123\n456\n789
b=f.readlines() ##list:['123\n', '456\n', '789']
48:ord
ord() 函数是 chr() 函数(对于 8 位的 ASCII 字符串)的配对函数,它以一个字符串(Unicode 字符)作为参数,返回对应的 ASCII 数值,或者 Unicode 数值。
ord(c) ##c -- 字符。
ord('a') ##97
ord('€') ##8364
49:powpython
pow() 方法返回x的y次方的值。pow() 通过内置的方法直接调用,内置方法会把参数作为整型,而 math 模块则会把参数转换为 float。
print (pow(100, 2)) ##10000
print (math.pow(100, 2)) ##10000.0
print (math.pow(100, -2)) ##0.0001
print (math.pow(2, 4)) ##16
print (math.pow(3, 0)) ##1.0
50:print
print() 方法用于打印输出,最常见的一个函数。
在 Python3.3 版增加了 flush 关键字参数。
print 在 Python3.x 是一个函数,但在 Python2.x 版本不是一个函数,只是一个关键字。
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
objects -- 复数,表示可以一次输出多个对象。输出多个对象时,需要用 , 分隔。
sep -- 用来间隔多个对象,默认值是一个空格。
end -- 用来设定以什么结尾。默认值是换行符 \n,我们可以换成其他字符串。
file -- 要写入的文件对象。
flush -- 输出是否被缓存通常决定于 file,但如果 flush 关键字参数为 True,流会被强制刷新。
>>>print(1)
1
>>> print("Hello World")
Hello World
>>> a = 1
>>> b = 'runoob'
>>> print(a,b)
1 runoob
>>> print("aaa""bbb")
aaabbb
>>> print("aaa","bbb")
aaa bbb
>>>
>>> print("www","runoob","com",sep=".") ## 设置间隔符
www.runoob.com
51:property
property() 函数的作用是在新式类中返回属性值。用 类对象.属性的方式访问类中定义的属性,这种做法是欠妥的,因为它破坏了类的封装原则,类包含的属性应该是隐藏的,只允许通过类提供的公有方法来间接实现对类属性的访问和操作。在 Python 中提供了 property() 函数,可以不破坏类的封装原则,还能让开发者依旧使用 类对象.属性的方式操作类中的属性。
class property([fget[, fset[, fdel[, doc]]]])
fget -- 获取属性值的函数
fset -- 设置属性值的函数
fdel -- 删除属性值函数
doc -- 属性描述信息
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.")
c=C() ##创建一个对象
print(c.x) ##None
c.x='feng'
print(c.x) ##feng
print(C.x.__doc__) ##I'm the 'x' property.
del c.x ##删除属性
52:range
Python3 range() 函数返回的是一个可迭代对象(类型是对象),而不是列表类型, 所以打印的时候不会打印列表。
Python3 list() 函数是对象迭代器,可以把range()返回的可迭代对象转为一个列表,返回的变量类型为列表。
range(stop)
range(start, stop[, step])
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(0,5) ##range(0, 5)
list(range(0,5)) ##[0, 1, 2, 3, 4]
for i in range(5):
print(i) ##0 1 2 3 4
list(range(0,30,5)) ##[0,5,10, 15, 20, 25]
list(range(0,-5,-1)) ##[0,-1,-2,-3,-4]
53:repr
repr() 函数将对象转化为供解释器读取的形式。
repr(object)
object -- 对象。
返回一个对象的 string 格式。
a=5 ##int
b=repe(5) ##str
##repr可以使转义字符等失效,打印出转义符号
c='我\n你'
print(c) ##我
##你
d=repr(c)
print(d) ##'我\n你'
54:reversed
reversed 函数返回一个反转的迭代器。
reversed(seq)
seq -- 要转换的序列,可以是 tuple, string, list 或 range。
返回一个反转的迭代器。
## 字符串
seqString = 'abc'
print(list(reversed(seqString))) ##['c', 'b', 'a']
## 元组
seqTuple = ('d', 'e', 'f')
print(list(reversed(seqTuple))) ##['f', 'e', 'd']
## range
seqRange = range(1, 4)
print(list(reversed(seqRange))) ##[3, 2, 1]
## 列表
seqList = [4,5,6] ##[6, 5, 4]
print(list(reversed(seqList)))
55:round
round() 方法返回浮点数 x 的四舍五入值,准确的说保留值将保留到离上一位更近的一端(四舍六入)。 精度要求高的,不建议使用该函数。
round( x [, n] )
x -- 数字表达式。
n -- 表示从小数点位数,其中 x 需要四舍五入,默认值为 0。
返回浮点数x的四舍五入值。
round(2.675, 2) ##2.67
##按我们的想法返回结果应该是 2.68,可结果却是 2.67,为什么?
##这跟浮点数的精度有关。我们知道在机器中浮点数不一定能精确表达,因为换算成一串 1 和 0 后可能是无限位数的,机器已经做出了截断处理。那么在机器中保存的2.675这个数字就比实际数字要小那么一点点。这一点点就导致了它离 2.67 要更近一点点,所以保留两位小数时就近似到了 2.67。
56:set
set() 函数创建一个无序不重复元素集,可进行关系测试,删除重复数据,还可以计算交集、差集、并集等。
class set([iterable])
iterable -- 可迭代对象对象;
返回新的集合对象。
a=set("abcd") ##{'d', 'c', 'b', 'a'}
b=set('cdef') ##{'d', 'c', 'f', 'e'}
##交集、并集、差集
print(a&b) ##{'c', 'd'}
print(a|b) ##{'b', 'd', 'a', 'c', 'f', 'e'}
print(a-b) ##{'b', 'a'}
57:setattr
setattr() 函数对应函数 getattr(),用于设置属性值,该属性不一定是存在的。
setattr(object, name, value)
object -- 对象。
name -- 字符串,对象属性。
value -- 属性值。
class A(object):
bar = 1
a = A()
getattr(a, 'bar') ## 获取属性 bar 值1
setattr(a, 'bar', 5) ## 设置属性 bar 值
a.bar ##5
class A():
name = "runoob"
a = A()
setattr(a, "age", 28) ##创建属性
print(a.age) ##28
58:slice
slice() 函数实现切片对象,主要用在切片操作函数里的参数传递。
class slice(stop)
class slice(start, stop[, step])
start -- 起始位置
stop -- 结束位置
step -- 间距
返回一个切片对象。
myslice = slice(5) ## 设置截取5个元素的切片
myslice ##slice(None, 5, None)
arr = range(10)
arr ##[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
arr[myslice] ## 截取 5 个元素[0, 1, 2, 3, 4]
59:sorted
sorted() 函数对所有可迭代的对象进行排序操作。
sort 与 sorted 区别:
sort 是应用在 list 上的方法,sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作,而内建函数 sorted 方法返回的是一个新的 list,而不是在原来的基础上进行的操作。
sorted(iterable, key=None, reverse=False)
iterable -- 可迭代对象。
key -- 主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则,reverse = True 降序 , reverse = False 升序(默认)。
返回重新排序的列表。
sorted([5, 2, 3, 1, 4]) ##[1, 2, 3, 4, 5] 默认为升序
a=[5,2,3,1,4]
a.sort() ##[1,2,3,4,5] list的用法
sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}) ##[1, 2, 3, 4, 5]
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
result_list = sorted(example_list, key=lambda x: x*-1)
print(result_list) ##[7, 6, 5, 4, 3, 2, 1, 0]
example_list = [5, 0, 6, 1, 2, 7, 3, 4]
sorted(example_list, reverse=True)
print(sorted) ##[7, 6, 5, 4, 3, 2, 1, 0]
60:staticmethod
python staticmethod 返回函数的静态方法。
staticmethod(function)
class C(object):
@staticmethod
def f():
print('runoob');
C.f(); ## 静态方法无需实例化 runoob
cobj = C()
cobj.f() ## 也可以实例化后调用 runoob
61:str
str() 函数将对象转化为适于人阅读的形式。
s = 'RUNOOB'
str(s) ##'RUNOOB'
dict = {'runoob': 'runoob.com', 'google': 'google.com'};
str(dict) ##"{'google': 'google.com', 'runoob': 'runoob.com'}"
62:sum
sum() 方法对序列进行求和计算。
sum(iterable[, start])
iterable -- 可迭代对象,如:列表、元组、集合。
start -- 指定相加的参数,如果没有设置这个值,默认为0。
sum([0,1,2]) ##3
sum((2, 3, 4), 1) ## 元组计算总和后再加1 10
sum([0,1,2,3,4], 2) ## 列表计算总和后再加 2 12
63:super
super() 函数是用于调用父类(超类)的一个方法。
super() 是用来解决多重继承问题的,直接用类名调用父类方法在使用单继承的时候没问题,但是如果使用多继承,会涉及到查找顺序(MRO)、重复调用(钻石继承)等种种问题。
MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。
super(type[, object-or-type])
type -- 类。
object-or-type -- 类,一般是 self
class A:
def add(self, x):
y = x+1
print(y)
class B(A):
def add(self, x):
super().add(x)
b = B()
b.add(2) ## 3
64:tuple
tuple 函数将可迭代系列(如列表)转换为元组。
tuple( iterable )
iterable -- 要转换为元组的可迭代序列。
list1= ['Google', 'Taobao', 'Runoob', 'Baidu']
tuple1=tuple(list1)
tuple1 ##('Google', 'Taobao', 'Runoob', 'Baidu')
65:type
type() 函数如果你只有第一个参数则返回对象的类型,三个参数返回新的类型对象。
isinstance() 与 type() 区别:
type() 不会认为子类是一种父类类型,不考虑继承关系。
isinstance() 会认为子类是一种父类类型,考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
ype(object)
type(name, bases, dict)
name -- 类的名称。
bases -- 基类的元组。
dict -- 字典,类内定义的命名空间变量。
>>> type(1)
<type 'int'>
>>> type('runoob')
<type 'str'>
>>> type([2])
<type 'list'>
>>> type({0:'zero'})
<type 'dict'>
>>> x = 1
>>> type( x ) == int ## 判断类型是否相等
True
class A:
pass
class B(A):
pass
isinstance(A(), A) ## returns True
type(A()) == A ## returns True
isinstance(B(), A) ## returns True
type(B()) == A ## returns False
66:vars
vars() 函数返回对象object的属性和属性值的字典对象。返回对象object的属性和属性值的字典对象,如果没有参数,就打印当前调用位置的属性和属性值 类似 locals()。
vars([object])
object -- 对象
>>>print(vars())
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__doc__': None, '__package__': None}
>>> class Runoob:
... a = 1
...
>>> print(vars(Runoob))
{'a': 1, '__module__': '__main__', '__doc__': None}
>>> runoob = Runoob()
>>> print(vars(runoob))
{}
67:zip
zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。
我们可以使用 list() 转换来输出列表。
如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。
zip([iterable, ...])
iterabl -- 一个或多个迭代器;
a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
zipped = zip(a,b) ## 返回一个对象<zip object at 0x103abc288>
list(zipped) ## list() 转换为列表[(1, 4), (2, 5), (3, 6)]
list(zip(a,c)) ## 元素个数与最短的列表一致[(1, 4), (2, 5), (3, 6)]
a1, a2 = zip(*zip(a,b)) ## 与 zip 相反,zip(*) 可理解为解压,返回二维矩阵式
list(a1) ##[1, 2, 3]
list(a2) ##[4, 5, 6]
68:import
import() 函数用于动态加载类和函数 。
如果一个模块经常变化就可以使用 import() 来动态载入。
69:reload
reload() 用于重新载入之前载入的模块。