- 内置函数
abs(x) #取绝对值
all(iterable) #如果iterable中元素都为真，则返回True
print(all([1,0,-1])) print(all([1,2,-1])) >>> False True
any(iterable) #如果iterable中有一个元素为真，则返回True
print(any([1,0,-1])) print(any([0,0,0])) print(any([])) >>> True False False
ascii(object) #
bin(x) #十进制转二进制（整数）
print(bin(1)) print(bin(2)) print(bin(3)) print(bin(4)) >>> 0b1 0b10 0b11 0b100
bool([source[, encoding[, errors]]]) #Ture or False
bytearry([source[, encoding[, errors]]]) #返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256
b=bytearray('abcde',encoding='utf-8') print(b[1]) b[1]=101 print(b) >>> 98 bytearray(b'aecde')
callable(object) #可调用时返回True
def sayhi(): pass print(callable(sayhi)) >>>True
chr(i) #将ASCII码转换为对应的字符
print(chr(97)) >>>a
ord(c) #将字符转换为对应的ASCII码
print(ord('a')) >>>97
classmethod
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)#转换为底层代码用于编译
complex([real[, imag]]) #复数
delattr(object,name)
dir([object]) #查看object 可调用的方法
divmod(a, b) #b除a得（商，余数）
print(divmod(5,3)) print(divmod(5,1)) >>> (1, 2) (5, 0)
enumerate(iterable, start=0)
#对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值
用法
a=['zero','one','two','three'] b=list(enumerate(a)) c=dict(enumerate(a)) print(b) print(c)
>>>
[(0, 'zero'), (1, 'one'), (2, 'two'), (3, 'three')]
{0: 'zero', 1: 'one', 2: 'two', 3: 'three'}
对一个列表，既要遍历索引又要遍历元素时，有如下写法:
for i in range(len(a)): print(i,a[i]) for i in a: print(a.index(i),i) for index,item in enumerate(a): print(index,item)
>>>
0 zero
1 one
2 two
3 three
enumerate还可以接收第二个参数，用于指定索引起始值:
for index,item in enumerate(a,2): print(index,item) >>> 2 zero 3 one 4 two 5 three
eval(expression, globals=None, locals=None) #将字符串对应的名字的变量转换成该变量对应的值
#字符串转换为list a="[1,'a',[1,'a']]" b=eval(a) print(type(b),b) #字符串转换为dict a="{'a':1,'b':2}" b=eval(a) print(type(b),b) #字符串转换为tuple a="(1,'a',[1,'a'])" b=eval(a) print(type(b),b)
>>>
<class 'list'> [1, 'a', [1, 'a']] <class 'dict'> {'a': 1, 'b': 2} <class 'tuple'> (1, 'a', [1, 'a'])
exec(object[, globals[, locals]]) #
filter(function, iterable) 过滤器
#用于过滤序列，过滤掉不符合条件的元素，接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判
- function -- 判断函数。
- iterable -- 可迭代对象。
Python 2.x 返回列表
Python 3.x 返回filter类
用法：
#过滤0-9大于5的值 def test(n): return n>5 res=filter(test,range(10)) print(res) #python2返回值为过滤后的列表，python3返回值为filter类 for i in res: print(i)
>>>
<filter object at 0x04DE83F0>
6
7
8
9
也可以结合匿名函数使用
res=filter(lambda n:n>5,[1,2,3,4,5,6,7,8,9]) for i in res: print(i)
>>>
6
7
8
9
map(function, iterable, ...)
#根据提供的function对指定序列做映射
#第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
- function -- 函数，有两个参数
- iterable -- 一个或多个序列
Python 2.x 返回列表
Python 3.x 返回迭代器
def square(x): return x**2 res=map(square,range(5)) print(res) for i in res: print(i) >>>
<map object at 0x055783F0> 0 1 4 9 16
当传入多个interable时,根据元素最少的interable进行
x_list=[1,2,3,4,5]
y_list=[1,1,1]
z_list=[0,0,0,1,1]
res=map(lambda x,y,z:x+y+z,x_list,y_list,z_list)
print(list(res))
>>>[2, 3, 4]
reduce(function, iterable) 非内置函数
#对iterable中元素按照func的映射关系进行累积
- function -- 判断函数。
- iterable -- 可迭代对象。
返回值为int
from functools import reduce
res=reduce(lambda x,y:x+y,[1,2,3,4,5]) print(res,type(res)) >>>15 <class 'int'>
class float()
format(value[, format_spec]) 格式化函数
用法：
print('name:{} ' 'age:{} ' 'sex:{}' .format('q1ang',26,'male')) print('name:{name} ' 'age:{age} ' 'sex:{sex}' .format(name='q1ang',age=26,sex='male')) print('name:{0} ' 'age:{1} ' 'sex:{2} ' 'name:{0}' .format('q1ang',26,'male'))
也可以从list和dict中设置参数
print('name:{name} ' 'age:{age} ' 'sex:{sex}' .format(**info_dict)) info_list=['q1ang',26,'male'] print('name:{0[0]} ' 'age:{0[1]} ' 'sex:{0[2]}' .format(info_list))
数字格式化
print('{:.2f}'.format(3.141592)) >>>3.14 print('{:*^20d}'.format(12345)) >>>*******12345******** print('{:b}'.format(123)) >>>1111011
^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制
| 数字 | 格式 | 输出 | 描述 |
|---|---|---|---|
| 3.1415926 | {:.2f} | 3.14 | 保留小数点后两位 |
| 3.1415926 | {:+.2f} | +3.14 | 带符号保留小数点后两位 |
| -1 | {:+.2f} | -1.00 | 带符号保留小数点后两位 |
| 2.71828 | {:.0f} | 3 | 不带小数 |
| 5 | {:0>2d} | 05 | 数字补零 (填充左边, 宽度为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)
'{:d}'.format(11)
'{:o}'.format(11)
'{:x}'.format(11)
'{:#x}'.format(11)
'{:#X}'.format(11)
|
1011
11
13
b
0xb
0XB
|
进制 |
使用大括号 {} 来转义大括号
print('{}的格式为{{key1:vale1,key2:valu2}}'.format('dict')) >>>dict的格式为{key1:vale1,key2:valu2}
frozenset([iterable]) 冻结的集合
#返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
- iterable -- 可迭代的对象
getattr(object, name[, default])
setattr(object, name, value)
globals()
#函数会以字典类型返回当前位置的全部全局变量
hasattr(object, name)
hash(object) 哈希
#用于获取一个对象（字符串或者数值等）的哈希值
- object -- 对象
返回对象的哈希值
a='q1ang' print(hash(a)) >>>1036837592
help([object])
hex(x) 十进制转十六进制（整型）
#将10进制整数转换成16进制，以字符串形式表示
- x -- 10进制整数
返回16进制数，以字符串形式表示
print(hex(17)) >>>0x11
id(object) 返回内存地址
#用于获取对象的内存地址
- object -- 对象
返回对象的内存地址
print(id('q1ang')) >>>64848768
class int()
isinstance(object, classinfo)
#来判断一个对象是否是一个已知的类型，类似 type()
- object -- 实例对象。
- classinfo -- 可以是直接或间接类名、基本类型或者由它们组成的元组
返回值：如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False
a='q1ang' print(isinstance(a,int)) print(isinstance(a,str)) print(isinstance(a,(int,str,list)))#是元组中的一个返回 True >>> False True True
isinstance() 与 type() 区别：
-
type() 不会认为子类是一种父类类型，不考虑继承关系。
-
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()
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
issubclass(class, classinfo)
len(s)
#返回对象（字符、列表、元组等）长度或项目个数
class list([iterable])
locals()
#以字典类型返回当前位置的全部局部变量
def test(x): a='q1ang' print(locals()) test(1) >>>{'a': 'q1ang', 'x': 1}
max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])
#返回给定参数的最大值，参数可以为序列
print(max(1,2,3,4,5))
min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])
#返回给定参数的最小值，参数可以为序列
print(min(1,2,3,4,5))
memoryview(obj)
next(iterator[, default])
#返回迭代器的下一个项目
- iterator -- 可迭代对象
- default -- 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
a = iter([1, 2, 3, 4, 5]) # 循环: while True: try: x = next(a) print(x) except StopIteration: # 遇到StopIteration就退出循环 break
class object
oct(x) 十进制转八进制（整型）
返回值：8进制字符串
print(oct(9)) >>>0o11
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
-
name : 一个包含了你要访问的文件名称的字符串值。
-
mode : mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。
-
buffering : 如果 buffering 的值被设为 0，就不会有寄存。如果 buffering 的值取 1，访问文件时会寄存行。如果将 buffering 的值设为大于 1 的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认
pow(x, y[, z])
#返回 xy（x的y次方） 的值,如果z在存在，则再对结果进行取模，即pow(x,y) %z
print(pow(2,3)) print(pow(2,3,5)) >>> 8 3
math 模块 pow() 方法的语法:
import math math.pow( x, y )
pow() 通过内置的方法直接调用，内置方法会把参数作为整型，而 math 模块则会把参数转换为 float
import math print(math.pow(2,3)) print(pow(2,3)) >>> 8.0 8
print(*objects, sep=' ', end=' ', file=sys.stdout, flush=False)
- objects -- 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
- sep -- 用来间隔多个对象，默认值是一个空格。
- end -- 用来设定以什么结尾。默认值是换行符 ，我们可以换成其他字符串。
- file -- 要写入的文件对象
print('a','b','c',sep='*') >>>a*b*c
class property(fget=None, fset=None, fdel=None, doc=None)
range(stop)
range(start, stop[, step])
Python3 range() 函数返回的是一个可迭代对象
Python3 list() 函数是对象迭代器，把range()返回的可迭代对象转为一个列表
Python2 range() 函数返回的是列表
- start: 计数从 start 开始，默认从 0 开始
- stop: 计数到 stop 结束，不包括 stop
- step：步长，默认为1
print(list(range(5))) print(list(range(1,5))) print(list(range(1,5,2))) >>> [0, 1, 2, 3, 4] [1, 2, 3, 4] [1, 3]
repr(object)
#将对象转化为供解释器读取的形式
reversed(seq)
#返回一个反转的迭代器
- seq -- 要转换的序列， tuple, string, list , range
返回值是迭代器
a=[1,2,3,4,5] print(reversed(a),list(reversed(a))) >>><list_reverseiterator object at 0x03058410> [5, 4, 3, 2, 1]
round(number[, ndigits])
#返回浮点数x的四舍五入值
- number -- 数值表达式
- ndigits -- 保留的位数
print(round(3.1415926)) print(round(3.1415926,2)) print(round(3.1415926,4)) >>> 3 3.14 3.1416
class set([iterable]) 集合
class slice(stop)
class slice(start, stop[, step])
#实现切片对象，主要用在切片操作函数里的参数传递
- start -- 起始位置
- stop -- 结束位置
- step -- 间距
slice_test1=slice(5) slice_test2=slice(1,5) slice_test3=slice(1,5,2) a=[1,2,3,4,5,6,7] print(a[slice_test1]) print(a[slice_test2]) print(a[slice_test3]) >>> [1, 2, 3, 4, 5] [2, 3, 4, 5] [2, 4]
sorted(iterable, *, key=None, reverse=False)
#对所有可迭代的对象进行排序操作
- iterable -- 可迭代对象。
- key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
- reverse -- 排序规则，reverse = True 降序 ， reverse = False 升序（默认）
a={5:6,4:7,3:8,2:9,1:10}
print(sorted(a.items()))
print(sorted(a.items(),reverse=True))
print(sorted(a.items(),key=lambda x:x[1]))
>>>
[(1, 10), (2, 9), (3, 8), (4, 7), (5, 6)]
[(5, 6), (4, 7), (3, 8), (2, 9), (1, 10)]
[(5, 6), (4, 7), (3, 8), (2, 9), (1, 10)]
@staticmethod
class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')
sum(iterable[, start])
#对序列进行求和计算
- iterable -- 可迭代对象，如列表。
- start -- 指定相加的参数，如果没有设置这个值，默认为0
print(sum([1,2,3])) print(sum([1,2,3],1)) #第一个参数计算完成后再与第二个参数求和
>>> 6 7
super([type[, object-or-type]])
tuple([iterable])
class type(object)
class type(name, bases, dict)
vars([object])
#返回对象object的属性和属性值的字典对象
zip(*iterables)
#用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
#如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
a=[1,2,3,4,5] b=['a','b','c','d'] c=zip(a,b) print(c,list(c)) >>><zip object at 0x05870508> [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')] d=zip(*c) #解压 print(list(d)) >>>[(1, 2, 3, 4), ('a', 'b', 'c', 'd')]
__import__(name, globals=None, locals=None, fromlist=(), level=0)