内置函数
python一共为我们提供了69个内置函数
-
abs(x)
返回数字的绝对值。参数可以是整数或浮点数。如果参数为复数,则返回其大小。
-
all(iterable)
如果 iterable 的所有元素为真(或迭代器为空),返回
True
。检查 iterable 中是否含有空字符,只要有一个空字符就返回False
# 等价于 def all(iterable): for element in iterable: if not element: return False return True
-
any(iterable)
如果 iterable 的任一元素为真则返回
True
。 如果迭代器为空,返回False
。# 等价于 def any(iterable): for element in iterable: if element: return True return False
-
ascii(object)
返回一个对象可打印的 ASCII 编码的字符,生成的字符串和 Python 2 的
repr()
返回的结果相似。 -
bin(x)
将一个整数转变为一个前缀为“0b”的二进制字符串。结果是一个合法的 Python 表达式。如果 x 不是 Python 的
int
对象,那它需要定义__index__()
方法返回一个整数。 -
bool([x])
返回一个布尔值,
True
或者False
。如果 x 是假的或者被省略,返回False
;其他情况返回True
。 -
breakpoint
(*args, **kwargs)此函数会在调用时将你陷入调试器中。具体来说,它调用
sys.breakpointhook()
,直接传递args
和kws
。默认情况下,sys.breakpointhook()
调用pdb.set_trace()
且没有参数。在这种情况下,它纯粹是一个便利函数,因此您不必显式导入pdb
且键入尽可能少的代码即可进入调试器。但是,sys.breakpointhook()
可以设置为其他一些函数并被breakpoint()
自动调用,以允许进入你想用的调试器。3.7 新版功能. -
class
bytearray
([source[, encoding[, errors]]])返回一个新的 bytes 数组。
bytearray
类是一个可变序列,包含范围为 0 <= x < 256 的整数。它有可变序列大部分常见的方法,见 可变序列类型 的描述;同时有bytes
类型的大部分方法,参见 bytes 和 bytearray 操作。可选形参 source 可以用不同的方式来初始化数组:
- 如果是一个 string,您必须提供 encoding 参数(errors 参数仍是可选的);
bytearray()
会使用str.encode()
方法来将 string 转变成 bytes。 - 如果是一个 integer,会初始化大小为该数字的数组,并使用 null 字节填充。如果是一个符合 buffer 接口的对象,该对象的只读 buffer 会用来初始化字节数组。
- 如果是一个 iterable 可迭代对象,它的元素的范围必须是
0 <= x < 256
的整数,它会被用作数组的初始内容。 - 如果没有实参,则创建大小为 0 的数组。
- 如果是一个 string,您必须提供 encoding 参数(errors 参数仍是可选的);
-
class
bytes
([source[, encoding[, errors]]])返回一个新的“bytes”对象, 是一个不可变序列,包含范围为
0 <= x < 256
的整数。bytes
是bytearray
的不可变版本 - 它有其中不改变序列的方法和相同的索引、切片操作。因此,构造函数的实参和
bytearray()
相同。字节对象还可以用字面值创建 -
callable(object)
如果实参 object 是可调用的,返回
True
,否则返回False
。如果返回真,调用仍可能会失败;但如果返回假,则调用 object 肯定会失败。 -
chr(i)
返回 Unicode 码位为整数 i 的字符的字符串格式。
例如,
chr(97)
返回字符串'a'
,chr(8364)
返回字符串'€'
。这是ord()
的逆函数。实参的合法范围是 0 到 1,114,111(16 进制表示是 0x10FFFF)。如果 i 超过这个范围,会触发
ValueError
异常。 -
@classmethod
把一个方法封装成类方法。
一个类方法把类自己作为第一个实参,就像一个实例方法把实例自己作为第一个实参。
# 用以下习惯来声明类方法 class C: @classmethod def f(cls, arg1, arg2, ...): ...
类方法的调用可以在类上进行 (例如
C.f()
) 也可以在实例上进行 (例如C().f()
)。 -
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
将 source编译成代码或 AST 对象。代码对象可以被
exec()
或eval()
执行。- source 可以是常规的字符串、字节字符串,或者 AST 对象。
- filename 实参需要是代码读取的文件名;如果代码不需要从文件中读取,可以传入一些可辨识的值(经常会使用
'<string>'
)。 - mode 实参指定了编译代码必须用的模式。如果 source 是语句序列,可以是
'exec'
;如果是单一表达式,可以是'eval'
;如果是单个交互式语句,可以是'single'
。 - 可选参数 flags 和 dont_inherit 控制在编译 source 时要用到哪个 future 语句。如果两者都未提供(或都为零)则会使用调用
compile()
的代码中有效的 future 语句来编译代码。 如果给出了 flags 参数但没有 dont_inherit (或是为零) 则 flags 参数所指定的 以及那些无论如何都有效的 future 语句会被使用。 如果 dont_inherit 为一个非零整数,则只使用 flags 参数 – 在调用外围有效的 future 语句将被忽略。 - optimize 实参指定编译器的优化级别;默认值
-1
选择与解释器的-O
选项相同的优化级别。显式级别为0
(没有优化;__debug__
为真)、1
(断言被删除,__debug__
为假)或2
(文档字符串也被删除)。
-
class
complex
([real[, imag]])返回值为
real+ imag*1j
的复数,或将字符串或数字转换为复数。如果第一个形参是字符串,则它被解释为一个复数,并且函数调用时必须没有第二个形参。第二个形参不能是字符串。每个实参都可以是任意的数值类型(包括复数)。如果省略了 imag,则默认值为零,构造函数会像int
和float
一样进行数值转换。如果两个实参都省略,则返回0j
。 -
delattr(object,name)
setattr()
相关的函数。实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许,该函数将删除指定的属性。 -
class
dict
(**kwargs)class
dict
(mapping, **kwarg)class
dict
(iterable, **kwarg)创建一个新的字典。
dict
对象是一个字典类。 -
dir([object])
如果没有实参,则返回当前本地作用域模块中的属性列表。如果有实参,它会尝试返回该对象的有效属性列表。
# 返回的列表按字母表排序 import struct dir() # 获得当前模块的属性列表 >>> ['__builtins__', '__name__', 'struct'] dir(struct) # show the names in the struct module >>> ['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__initializing__', '__loader__', '__name__', '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into', 'unpack', 'unpack_from'] dir([ ]) # 查看列表的方法 >>> ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
-
divmod(a, b)
它将两个(非复数)数字作为实参,并在执行整数除法时返回一对商和余数。
对于混合操作数类型,适用双目算术运算符的规则。对于整数,结果和
(a // b, a % b)
一致。对于浮点数,结果是
(q, a % b)
,q 通常是math.floor(a / b)
但可能会比 1 小。 -
enumerate(iterable, start=0)
返回一个枚举对象。
enumerate()
返回一个元组,里面包含一个计数值(从 start 开始,默认为 0)和通过迭代 iterable 获得的值。iterable 必须是一个序列,或 迭代器,或其他支持迭代的对象。
# 等价于: def enumerate(sequence, start=0): n = start for elem in sequence: yield n, elem n += 1
例子:
>>> 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')]
-
eval(expression[, globals[, locals]])
eval() 函数用来执行一个字符串表达式,并返回表达式的值。
expression – 表达式。
globals – 变量作用域,全局命名空间,如果被提供,则必须是一个字典对象。
locals – 变量作用域,局部命名空间,如果被提供,可以是任何映射对象。
>>>x = 7 >>> eval( '3 * x' ) 21 >>> eval('pow(2,2)') 4 >>> eval('2 + 2') 4 >>> n=81 >>> eval("n + 4") 85
-
exec(object[, globals[, locals]])
exec 执行储存在字符串或文件中的 Python 语句,相比于 eval,exec可以执行更复杂的 Python 代码
exec 返回值永远为 None。
- object:必选参数,表示需要被指定的Python代码。它必须是字符串或code对象。如果object是一个字符串,该字符串会先被解析为一组Python语句,然后在执行(除非发生语法错误)。如果object是一个code对象,那么它只是被简单的执行。
- globals:可选参数,表示全局命名空间(存放全局变量),如果被提供,则必须是一个字典对象。
- locals:可选参数,表示当前局部命名空间(存放局部变量),如果被提供,可以是任何映射对象。如果该参数被忽略,那么它将会取与globals相同的值。
>>>exec('print("Hello World")') Hello World # 单行语句字符串 >>> exec("print ('runoob.com')") runoob.com # 多行语句字符串 >>> 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
-
filter(function, iterable)
filter() 函数用于过滤序列,过滤掉不符合条件的元素,返回一个迭代器对象,如果要转换为列表,可以使用 list() 来转换。
- 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]
-
class
float([x])
返回从数字或字符串 x 生成的浮点数。
>>> float('+1.23') 1.23 >>> float(' -12345\n') -12345.0 >>> float('1e-003') 0.001 >>> float('+1E6') 1000000.0 >>> float('-Infinity') -inf
-
format(value[, format_spec])
一种格式化字符串的函数 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}, 地址 {addr}".format(name="工大", addr="杭州")) # 通过字典设置参数 site = {"name": "工大", "addr": "杭州"} print("学校名:{name}, 地址 {addr}".format(**site)) # 通过列表索引设置参数 my_list = ['工大', '杭州'] print("学校名:{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的 # 三个输出都是 学校名:工大,地址:杭州
-
class
frozenset([iterable])
返回一个新的
frozenset
对象,它包含可选参数 iterable 中的元素。frozenset
是一个内置的类。有关此类的文档,请参阅frozenset
和 集合类型 — set, frozenset。请参阅内建的set
、list
、tuple
和dict
类,以及collections
模块来了解其它的容器。 -
getattr(object, name[, default])
返回对象命名属性的值。
name 必须是字符串。
如果该字符串是对象的属性之一,则返回该属性的值。
例如,
getattr(x, 'foobar')
等同于x.foobar
。如果指定的属性不存在,且提供了 default 值,则返回它,否则触发AttributeError
。 -
globals()
返回表示当前全局变量表的字典。
-
hasattr(object, name)
该实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称,则返回
True
,否则返回False
。(此功能是通过调用getattr(object, name)
看是否有AttributeError
异常来实现的。) -
hash(object)
返回该对象的哈希值(如果它有的话)。哈希值是整数。
它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值(即使它们类型不同,如 1 和 1.0)。
-
help([object])
启动内置的帮助系统(此函数主要在交互式中使用)。
如果没有实参,解释器控制台里会启动交互式帮助系统。
如果实参是一个字符串,则在模块、函数、类、方法、关键字或文档主题中搜索该字符串,并在控制台上打印帮助信息。
如果实参是其他任意对象,则会生成该对象的帮助页。
-
hex(x)
将整数转换为以“0x”为前缀的小写十六进制字符串。如果 x 不是 Python
int
对象,则必须定义返回整数的__index__()
方法。>>> hex(255) '0xff' >>> hex(-42) '-0x2a'
如果要将整数转换为大写或小写的十六进制字符串,并可选择有无“0x”前缀,
>>> '%#x' % 255, '%x' % 255, '%X' % 255 ('0xff', 'ff', 'FF') >>> format(255, '#x'), format(255, 'x'), format(255, 'X') ('0xff', 'ff', 'FF') >>> f'{255:#x}', f'{255:x}', f'{255:X}' ('0xff', 'ff', 'FF')
-
id(object)
返回对象的“标识值”。该值是一个整数,在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的
id()
值。 -
input([prompt])
如果存在 prompt 实参,则将其写入标准输出,末尾不带换行符。接下来,该函数从输入中读取一行,将其转换为字符串(除了末尾的换行符)并返回。
-
class
int
([x])返回一个使用数字或字符串 x 生成的整数对象,或者没有实参的时候返回 0 。
-
isinstance(object, classinfo)
判断object对象是不是classinfo类
如果 object 实参是 classinfo 实参的实例,或者是(直接、间接或 虚拟)子类的实例,则返回 true。
如果 object 不是给定类型的对象,函数始终返回 false。
如果 classinfo 是对象类型(或多个递归元组)的元组,如果 object 是其中的任何一个的实例则返回 true。
如果 classinfo 既不是类型,也不是类型元组或类型的递归元组,那么会触发
TypeError
异常。 -
issubclass(class, classinfo)
判断class是否是classinfo的子类
如果 class 是 classinfo 的子类(直接、间接或 虚拟 的),则返回 true。classinfo 可以是类对象的元组,此时 classinfo 中的每个元素都会被检查。其他情况,会触发
TypeError
异常。 -
iter(object[, sentinel])
返回一个 iterator 对象。
迭代器 = iter(可迭代) 等于 迭代器 = 可迭代的.
__iter__()
根据是否存在第二个实参,第一个实参的解释是非常不同的。
如果没有第二个实参,object 必须是支持迭代协议(有
__iter__()
方法)的集合对象,或必须支持序列协议(有__getitem__()
方法,且数字参数从0
开始)。如果它不支持这些协议,会触发TypeError
。如果有第二个实参 sentinel,那么 object 必须是可调用的对象。这种情况下生成的迭代器,每次迭代调用它的
__next__()
方法时都会不带实参地调用 object;如果返回的结果是 sentinel 则触发StopIteration
,否则返回调用结果。 -
len(s)
返回对象的长度(元素个数)。
实参可以是序列(如 string、bytes、tuple、list 或 range 等)或集合(如 dictionary、set 或 frozen set 等)。
-
class
list([iterable])
将iterable转换成列表,虽然被称为函数,
list
实际上是一种可变序列类型 -
locals()
获取执行本方法所在命名空间内的局部变量的字典。
在函数代码块但不是类代码块中调用
locals()
时将返回自由变量。 请注意在模块层级上,locals()
和globals()
是同一个字典。 -
map(function, iterable, ...)
map() 会根据提供的函数对指定序列做映射。
返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器。
>>>def square(x) : # 计算平方数 return x ** 2 >>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方 [1, 4, 9, 16, 25] >>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数 [1, 4, 9, 16, 25] # 提供了两个列表,对相同位置的列表数据进行相加 >>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) [3, 7, 11, 15, 19]
-
max
(iterable, ***[, key, default])max
(arg1, arg2, *args[, key])返回可迭代对象中最大的元素,或者返回两个及以上实参中最大的。
-
memoryview(obj)
返回由给定实参创建的“内存视图”对象。
-
min
(iterable, ***[, key, default])min
(arg1, arg2, *args[, key])返回可迭代对象中最小的元素,或者返回两个及以上实参中最小的。
-
next(iterator[, default])
通过调用 iterator 的
__next__()
方法获取下一个元素。如果迭代器耗尽,则返回给定的 default,如果没有默认值则触发StopIteration
。 -
class
object
返回一个没有特征的新对象。
object
是所有类的基类。它具有所有 Python 类实例的通用方法。这个函数不接受任何实参。注解 由于object
没有__dict__
,因此无法将任意属性赋给object
的实例。 -
oct(x)
将一个整数转变为一个前缀为“0o”的八进制字符串。结果是一个合法的 Python 表达式。
-
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
open() 函数用于打开一个文件,创建一个 file 对象,相关的方法才可以调用它进行读写。
file对象方法
- file.read([size]):size 未指定则返回整个文件,如果文件大小 >2 倍内存则有问题,f.read()读到文件尾时返回""(空字串)。
- file.readline():返回一行。
- file.readlines([size]) :返回包含size行的列表, size 未指定则返回全部行。
- for line in f: print line :通过迭代器访问。
- f.write(“hello\n”):如果要写入字符串以外的数据,先将他转换为字符串。
- f.tell():返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)。
- f.seek(偏移量,[起始位置]):用来移动文件指针。
- 偏移量: 单位为比特,可正可负
- 起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾
- f.close() 关闭文件
-
ord(c)
对表示单个 Unicode 字符的字符串,返回代表它 Unicode 码点的整数。
例如
ord('a')
返回整数97
,ord('€')
(欧元符号)返回8364
。这是chr()
的逆函数。 -
pow(x, y[, z])
返回 x 的 y 次幂;如果 z 存在,则对 z 取余(比直接
pow(x, y) % z
计算更高效)。两个参数形式的pow(x,y)
等价于幂运算符:x**y
。 -
print(objects, sep=' ', end='\n', file=sys.stdout, flush=False)
将 objects 打印到 file 指定的文本流,以 sep 分隔并在末尾加上 end。
sep, end, file 和 flush 如果存在,它们必须以关键字参数的形式给出。
所有非关键字参数都会被转换为字符串,就像是执行了
str()
一样,并会被写入到流,以 sep 且在末尾加上 end。 sep 和 end 都必须为字符串;它们也可以为None
,这意味着使用默认值。如果没有给出 objects,则
print()
将只写入 end。 -
class
property(fget=None, fset=None, fdel=None, doc=None)
返回 property 属性。
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 的实例化,
c.x 将触发 getter,
c.x = value 将触发 setter ,
del c.x 触发 deleter。
-
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
实际上是一个不可变的序列类型 -
-
repr(object)
repr() 函数将对象转化为供解释器读取的形式。
返回一个对象的 string 格式。
>>>s = 'RUNOOB' >>> repr(s) "'RUNOOB'" >>> dict = {'runoob': 'runoob.com', 'google': 'google.com'}; >>> repr(dict) "{'google': 'google.com', 'runoob': 'runoob.com'}"
-
reversed(seq)
返回一个反向的 iterator。 seq 必须是一个具有
__reversed__()
方法的对象或者是支持该序列协议(具有从0
开始的整数类型参数的__len__()
方法和__getitem__()
方法)。 -
round(number[, ndigits])
返回 number 舍入到小数点后 ndigits 位精度的值。
-
class
set
([iterable])返回一个新的
set
对象,可以选择带有从 iterable 获取的元素。set
是一个内置类型。 -
setattr
(object, name, value)此函数与
getattr()
两相对应。 其参数为一个对象、一个字符串和一个任意值。 字符串指定一个现有属性或者新增属性。 函数会将值赋给该属性,只要对象允许这种操作。例如,
setattr(x, 'foobar', 123)
等价于x.foobar = 123
。 -
class
slice
(stop)class
slice
(start, stop[, step])slice() 函数实现切片对象,主要用在切片操作函数里的参数传递。
返回一个表示由
range(start, stop, step)
所指定索引集的 slice 对象。 其中 start 和 step 参数默认为None
。 切片对象具有仅会返回对应参数值(或其默认值)的只读数据属性start
,stop
和step
。 它们没有其他的显式功能;不过它们会被 NumPy 以及其他第三方扩展所使用。 切片对象也会在使用扩展索引语法时被生成。例如:
a[start:stop:step]
或a[start:stop, i]
。>>>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]
-
*
sorted
(iterable, , key=None, reverse=False)根据 iterable 中的项返回一个新的已排序列表。具有两个可选参数,它们都必须指定为关键字参数。key 指定带有单个参数的函数,用于从 iterable 的每个元素中提取用于比较的键 (例如
key=str.lower
)。 默认值为None
(直接比较元素)。reverse 为一个布尔值。 如果设为True
,则每个列表元素将按反向顺序比较进行排序。 -
@staticmethod
将方法转换为静态方法。静态方法不会接收隐式的第一个参数。要声明一个静态方法,请使用此语法
class C: @staticmethod def f(arg1, arg2, ...): ...
静态方法的调用可以在类上进行 (例如
C.f()
) 也可以在实例上进行 (例如C().f()
)。 -
class
str
(object=’’)class
str
(object=b’’, encoding=‘utf-8’, errors=‘strict’) -
sum
(iterable[, start])从 start 开始自左向右对 iterable 中的项求和并返回总计值。 start 默认为
0
。 iterable 的项通常为数字,开始值则不允许为字符串。 -
super
([type[, object-or-type]])返回一个代理对象,它会将方法调用委托给 type 指定的父类或兄弟类。 这对于访问已在类中被重载的继承方法很有用。 搜索顺序与
getattr()
所使用的相同,只是 type 指定的类型本身会被跳过。 -
tuple
([iterable])返回一个元组
虽然被称为函数,但
tuple
实际上是一个不可变的序列类型 -
class
type
(object)class
type
(name, bases, dict)传入一个参数时,返回 object 的类型。 返回值是一个 type 对象,通常与
object.__class__
所返回的对象相同。推荐使用
isinstance()
内置函数来检测对象的类型,因为它会考虑子类的情况。传入三个参数时,返回一个新的 type 对象。 -
vars
([object]) -
*
zip
(iterables)zip() 函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,我们可以使用 list() 转换来输出列表。
如果各个迭代器的元素个数不一致,则返回列表长度与最短的对象相同,利用 * 号操作符,可以将元组解压为列表。
>>>a = [1,2,3] >>> b = [4,5,6] >>> c = [4,5,6,7,8] >>> zipped = zip(a,b) # 返回一个对象 >>> zipped <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]
-
__import__
(name, globals=None, locals=None, fromlist=(), level=0)此函数会由
import
语句发起调用。 它可以被替换 (通过导入builtins
模块并赋值给builtins.__import__
) 以便修改import
语句的语义,但是 强烈 不建议这样做。
内置函数分类
作用域相关
基于字典的形式获取局部变量和全局变量
globals()——获取全局变量的字典
locals()——获取执行本方法所在命名空间内的局部变量的字典
迭代器/生成器相关
next(迭代器) 等于 迭代器.__next__()
迭代器 = iter(可迭代) 等于 迭代器 = 可迭代的.__iter__()
range()
其他
查看参数所属类型的所有内置方法
dir() 默认查看全局空间内的属性,也接受一个参数,查看这个参数内的方法或变量
print(dir(list)) #查看列表的内置方法
print(dir(int)) #查看整数的内置方法
和调用相关
callable(o),o是参数,看这个变量是不是可调用。
如果o是一个函数名,就会返回True
def func():pass
print(callable(func)) #参数是函数名,可调用,返回True
print(callable(123)) #参数是数字,不可调用,返回False
帮助方法
在控制台执行**help()**进入帮助模式。可以随意输入变量或者变量的类型。输入q退出
或者直接执行help(o),o是参数,查看和变量o有关的操作。。。
模块操作相关
__import__
导入一个模块
import time
os = __import__('os')
print(os.path.abspath('.'))
文件操作相关
open() 打开一个文件,返回一个文件操作符(文件句柄)
操作文件的模式有r,w,a,r+,w+,a+ 共6种,每一种方式都可以用二进制的形式操作(rb,wb,ab,rb+,wb+,ab+)
可以用encoding指定编码.
内存相关:
id(o) o是参数,返回一个变量的内存地址
hash(o) o是参数,返回一个可hash变量的哈希值,不可hash的变量被hash之后会报错。
t = (1,2,3)
l = [1,2,3]
print(hash(t)) #可hash
print(hash(l)) #会报错
'''
结果:
TypeError: unhashable type: 'list'
'''
hash函数会根据一个内部的算法对当前可hash变量进行处理,返回一个int数字。
*每一次执行程序,内容相同的变量hash值在这一次执行过程中不会发生改变。
数据类型相关:
type(o) 返回变量o的数据类型
输入输出相关:
input() 输入
s = input("请输入内容 : ") #输入的内容赋值给s变量
print(s) #输入什么打印什么。数据类型是str
print() 输出
def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
"""
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
file: 默认是输出到屏幕,如果设置为文件句柄,输出到文件
sep: 打印多个值之间的分隔符,默认为空格
end: 每一次打印的结尾,默认为换行符
flush: 立即把内容输出到流文件,不作缓存
"""
f = open('tmp_file','w')
print(123,456,sep=',',file = f,flush=True)
# 进度条打印
import time
for i in range(0,101,2):
time.sleep(0.1)
char_num = i//2 #打印多少个'*'
per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s'%(i,'*'*char_num)
print(per_str,end='', flush=True)
#小越越 : \r 可以把光标移动到行首但不换行
字符串类型代码的执行
eval() 将字符串类型的代码执行并返回结果
print(eval('1+2+3+4'))
>>> 10
exec()将自字符串类型的代码执行
print(exec("1+2+3+4"))
exec("print('hello,world')")
>>> None
>>> hello,world
code = '''
import os
print(os.path.abspath('.'))
'''
code = '''
print(123)
a = 20
print(a)
'''
a = 10
exec(code,{'print':print},)
print(a)
>>> 123
>>> 20
>>> 10
compile 将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。
参数说明:
- 参数source:字符串或者AST(Abstract Syntax Trees)对象。即需要动态执行的代码段。
- 参数 filename:代码文件名称,如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时,filename参数传入空字符即可。
- 参数model:指定编译代码的种类,可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时,model应指定为‘exec’;当source中只包含一个简单的求值表达式,model应指定为‘eval’;当source中包含了交互式命令语句,model应指定为’single’。
>>> #流程语句使用exec
>>> code1 = 'for i in range(0,10): print (i)'
>>> compile1 = compile(code1,'','exec')
>>> exec (compile1)
1
3
5
7
9
>>> #简单求值表达式用eval
>>> code2 = '1 + 2 + 3 + 4'
>>> compile2 = compile(code2,'','eval')
>>> eval(compile2)
>>> #交互语句用single
>>> code3 = 'name = input("please input your name:")'
>>> compile3 = compile(code3,'','single')
>>> name #执行前name变量不存在
Traceback (most recent call last):
File "<pyshell#29>", line 1, in <module>
name
NameError: name 'name' is not defined
>>> exec(compile3) #执行时显示交互命令,提示输入
please input your name:'pythoner'
>>> name #执行后name变量有值
"'pythoner'"
和数字相关
数字——数据类型相关:bool,int,float,complex
数字——进制转换相关:bin,oct,hex
数字——数学运算:abs,divmod,min,max,sum,round,pow
和数据结构相关
序列——列表和元组相关的:list和tuple
序列——字符串相关的:str,format,bytes,bytearry,memoryview,ord,chr,ascii,repr
序列:reversed,slice
数据集合——字典和集合:dict,set,frozenset
数据集合:len,sorted,enumerate,all,any,zip,filter,map
all() # 检查一个序列中是否含有空字符,只要有一个空字符就返回False
any() # 检查一个序列中是否含有空字符,只要有一个不是空字符就返回True
import math
def is_sqr(x):
return math.sqrt(x) % 1 == 0
newlist = filter(is_sqr, range(1, 101))
print(newlist)