共计 8921 个字符,预计需要花费 23 分钟才能阅读完成。
转载于海内博客「Script Run」:疾速把握 Python 内置函数用法、按用处分类记忆
开篇词
Python 的内置函数提供了十分多实用的性能,这篇文章致力于 分类疾速记忆
各个内置函数的「大抵性能与用法」,毕竟咱们的脑子又不是硬盘,只有保障能疾速找到笔记在哪里就能够了~
我将 Python 的内置函数大略分成 9 类,并不是很谨严,仅为了疾速记忆,上面依照分组的形式简略介绍每个函数的「性能」,并提供一个简略的「例子」。
当然,把握函数用法最疾速的形式不是看我薄弱的文字,而是 copy 我的示例代码去跑两遍。
迭代
range()
range() 函数返回数字序列,默认从 0 开始,默认以 1 递增,并以指定的数字完结(不蕴含指定的数字)。
x = range(6)
for n in x:
print(n, end=' ')
# 输入
0 1 2 3 4 5
此外也能够指定数字范畴,语法:range(start, stop, step),比方创立一个从 0 到 6,增量为 2 的数字序列:
x = range(0, 6, 2)
for n in x:
print(n, end=' ')
# 输入
# 0 2 4
reversed()
reversed() 函数用于反向迭代:
alph = ["a", "b", "c", "d"]
ralph = reversed(alph)
for x in ralph:
print(x, end=' ')
# 输入
# d c b a
all()
如果迭代器中的所有元素都为真,则返回 True(如果可迭代对象为空,返回 True)。
iterable = [True, True]
print("all:", all(iterable))
iterable[1] = False
print("all:", all(iterable))
# 输入
# all: True
# all: False
any()
如果可迭代对象的任何一个元素为真,则返回 True(如果可迭代对象为空,返回 False)。
iterable = [False, False]
print("any:", any(iterable))
iterable[1] = True
print("any:", any(iterable))
# 输入
# any: False
# any: True
iter()
iter() 返回迭代器对象。
x = iter(["apple", "banana", "cherry"])
print("iter", next(x))
print("iter", next(x))
print("iter", next(x))
# 输入
# iter apple
# iter banana
# iter cherry
next()
next() 函数返回下一个可迭代对象,示例见上文。
filter()
filter() 函数通过一个函数对「数据结构」进行过滤。
ages = [5, 16, 19, 22, 26, 39, 45]
def myFunc(x):
if x < 22:
return False
else:
return True
adults = filter(myFunc, ages)
print("filter:", adults)
for x in adults:
print("filter:", x)
# 输入
# filter: <filter object at 0x102a7f4f0>
# filter: 22
# filter: 26
# filter: 39
# filter: 45
map()
map() 函数为每一个可迭代对象执行指定的函数。
def myfunc(a, b):
return a + b
res = map(myfunc, ('apple', 'banana', 'cherry'), ('orange', 'lemon', 'pineapple'))
for i in(res):
print("map:", i, end=" ")
# 输入
# map: appleorange map: bananalemon map: cherrypineapple max: Steve
map() 函数容易与其余语言的数据结构 map 混同,要牢记 Python 中的“map”是 dict。
len()
len() 函数返回数据结构中元素的数量。
当对象是字符串时,len() 函数返回字符串中的字符数。
print("len:", len("abc"))
# 输入
# len: 3
数学运算
abs()
abs() 被用来「求绝对值」。
print("abs:", abs(-1))
# 输入
# abs: 1
sum()
sum() 被用来做「求和运算」。
a = (1, 2, 3, 4, 5)
x = sum(a)
此外,也能够提供第二个参数(b):
sum(a, b) == sum(a) + b
pow()
pow(x, y) 函数代表幂运算:$x^y$
print("pow:", pow(5, 3))
# 输入
# pow: 125
如果提供第三个参数,则返回 x 的 y 次幂后,取余 z。
print("pow:", pow(5, 3, 4))
# 输入
# pow: 1
max()
max() 被用来「取最大值」。
print("max:", max(2,3,1))
# 输入
# max: 3
如果值是字符串,则按字母程序进行比拟。
print("max:", max("Bill", "Steve", "Elon"))
# 输入
# max: Steve
min()
min() 被用来「取最小值」,与 max() 是孪生兄弟。
divmod()
divmod() 函数用于除法,返回商和余数,divmod(a, b) == a 除以 b
。
print("divmod:", divmod(5, 2))
# 输入
# divmod: (2, 1)
complex()
complex() 函数通过指定实数和虚数来创立一个「复数」。
print("complex:", complex(7, 8))
print("complex:", complex('7+8j'))
# 输入
# complex: (7+8j)
# complex: (7+8j)
round()
round()用于指定「小数位数」,并做四舍五入。默认四舍五入为「整数」,意味着小数位数为 0。
print("round", round(3.1415926, 2))
# 输入
# round 3.14
Debug
breakpoint()
breakpoint() 是一款 debug 工具,提供三种命令:
- 命令 ’p’:输入某个对象的值。
- 命令 ’n’:进入到下一行代码执行。
- 命令 ’c’:执行程序直到遇到下一个 breakpoint()。
比方上面这个例子,进入 pdb 调试过程后,键入 ‘p lst’ 能够将 lst 的以后值打进去,或者用命令 ’n’ 进入下一行代码:
# breakpoint
lst = []
for i in range(10):
lst.append(i)
if i == 5:
breakpoint()
输出 & 输入流
print()
print() 函数将指定的「内容」打印到规范输出设备,内容能够是字符串,也能够是任何其余对象,该对象在打印之前会被转换为字符串。
给出两种进阶操作:
- 距离符号
print("log", "param", sep="---")
# 输入
# log --- param
- for 循环调用 print() 打印成一行
x = range(6)
for n in x:
print(n, end=' ')
# 输入
# 0 1 2 3 4 5
语法:print(object(s), separator=separator, end=end, file=file, flush=flush)
参数 | 形容 |
---|---|
object(s) | 任何对象,以及任意数量。打印前将转换为字符串。 |
sep=’_separator_’ | 可选。指定如何分隔对象,如果存在多个对象。默认值为 ‘ ‘。 |
end=’_end_’ | 可选。可选的。指定要在开端打印的内容。默认值为 ‘\n’(换行符)。 |
file | 可选。有写入办法的对象。默认为 sys.stdout。 |
flush | 可选的。布尔值,指定输入是刷新(True)还是缓冲(False)。默认为 False。 |
open()
open() 函数关上一个文件,并将其作为文件对象返回。
语法:open(file, mode)
参数 | 形容 |
---|---|
file | 文件的门路或名称。 |
mode | 字符串,定义您要在哪种模式下关上文件: – “r”:读取 – 默认值。关上文件进行读取,如果文件不存在,则产生谬误。 – “a”:追加 – 关上文件进行追加,如果不存在则创立文件。 – “w”:写入 – 关上文件进行写入,如果不存在则创立文件。 – “x”:创立 – 创立指定的文件,如果文件存在则返回谬误。 另外,您能够指定文件应以二进制还是文本模式解决 |
input()
input() 函数容许用户输出。
print('Enter your name:')
x = input()
print('Hello,' + x)
创立
set()
set() 函数用于创立「汇合对象」。
x = set(('apple', 'banana', 'cherry'))
slice()
slice() 函数创立「切片对象」。
a = ("a", "b", "c", "d", "e", "f", "g", "h")
x = slice(3, 5)
print("slice", a[x])
# 输入
# slice ('d', 'e')
zip()
zip() 函数用于创立「zip 对象」。
zip 对象是元组的迭代器,它将迭代器的每一项交融在一起:
a = ("Bill", "Steve", "Elon")
b = ("Gates", "Jobs", "Musk", "Richard")
x = zip(a, b)
for i in(x):
print("zip:", i)
# 输入
# zip: ('Bill', 'Gates')
# zip: ('Steve', 'Jobs')
# zip: ('Elon', 'Musk')
如果传递的迭代用具有不同的长度,则项目数起码的迭代器将决定新迭代器的长度。
tuple()
tuple() 函数用于创立「元组对象」。
x = tuple(('apple', 'banana', 'cherry'))
list()
list() 函数用于创立「列表对象」。
x = list(('apple', 'banana', 'cherry'))
dict()
dict() 函数用于「创立字典」。
x = dict(name = "Bill", age = 63, country = "USA")
bytearray()
bytearray 返回字节数组,比方返回 5 个字节的数组:
x = bytearray(5)
语法:bytearray(x, encoding, error)
参数 | 形容 |
---|---|
x | 创立 bytearray 对象时应用的资源 – 如果是整数,则会创立指定大小的空 bytearray 对象。 – 如果是字符串,请确保规定了资源的编码。 |
encoding | 字符串的编码 |
error | 规定若编码失败要做什么。 |
bytes()
bytes() 和 bytearray() 之间的区别在于,bytes() 返回一个不能批改的对象,而 bytearray() 返回一个能够批改的对象。
memoryview()
memoryview() 函数从指定对象返回内存视图对象,这里内容很多,当前独自聊一聊。
frozenset()
frozenset() 函数返回一个不可更改的 Frozenset 对象(相似于 set 对象,但不可更改)。
mylist = ['apple', 'banana', 'cherry']
x = frozenset(mylist)
# 如果你执行上面的语句,Python 会报错。# x[1] = "strawberry"
排序
sorted()
sorted() 函数返回指定的可迭代对象的排序列表:
- 能够指定升序或降序。
- 字符串按字母程序排序,数字按大小排序。
a = ("h", "b", "a", "c", "f", "d", "g", "e")
print("sorted", sorted(a))
print("sorted", sorted(a, reverse=True))
# 输入
# sorted ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
# sorted ['h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']
sorted() 无奈对同时蕴含字符串值和数字值的列表进行排序。
类型转换
str()
str() 函数将指定的值转换为字符串。
ascii()
ASCII 编码,非 ASCII 编码的字符将应用以 反斜杠 \
模式的转义字符示意。
a = "测试"
print("ascii:", ascii(a))
a = "a1"
print("ascii:", ascii(a))
# 输入
# ascii: '\u6d4b\u8bd5'
# ascii: 'a1'
bin()
将整数转换为前缀为 0b
的二进制字符串。
print("bin:", bin(3))
# 输入
# bin: 0b11
bool()
bool() 函数用于将给定参数转换为布尔类型,如果没有参数则返回 False。
print("bool", bool(0))
print("bool", bool(1))
print("bool", bool(2))
# 输入
# bool False
# bool True
# bool True
oct()
oct() 函数把整数转换为八进制字符串。
print("oct:", oct(15))
# 输入
# oct: 0o17
Python 中的八进制字符串以 0o 为前缀。
ord()
ord() 函数返回示意指定字符 unicode 编码的数字。
print("ord:", ord("A"))
# 输入
# ord: 65
chr(i)
chr() 函数返回代表指定 unicode 的字符。
print(chr(78))
# 输入
# N
float()
float() 把指定值转换为浮点数。
enumerate()
将元组转换为可枚举对象:
enumerate()函数将数据结构转换为枚举对象,并且为每个枚举对象增加一个整数索引:
x = ('apple', 'banana', 'cherry')
y = enumerate(x)
for i in(y):
print("enumerate", i)
# 输入
enumerate (0, 'apple')
enumerate (1, 'banana')
enumerate (2, 'cherry')
int()
int() 函数把指定值转换为整数。
isinstance()
如果指定的对象领有指定的类型,则 isinstance() 函数返回 True,否则返回 False。
print("isinstance:", isinstance(10, int))
# 输入
# isinstance: True
hex()
hex() 函数将指定的数字转换为十六进制值(以前缀 0x 结尾)。
print("hex:", hex(255))
# 输入
# hex: 0xff
面向对象
vars()
vars() 函数返回对象的 dic 属性(__dict__ 属性是蕴含对象的可变属性的字典)。
class Person:
name = "Bill"
age = 19
country = "USA"
print("vars:", vars(Person))
# 输入
# vars: {'__module__': '__main__', 'name': 'Bill', 'age': 19, 'country': 'USA', '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>, '__doc__': None}
super()
super() 函数返回代表父类的对象。
用法示例:创立一个子类,子类从父类继承所有办法和属性:
class Parent:
def __init__(self, txt):
self.message
def printmessage(self):
print(self.message)
class Child(Parent):
def __init__(self, txt):
super().__init__(txt)
x = Child("Hello, and welcome!")
x.printmessage()
type()
type() 函数用户获取「对象的类型」。
a = ('apple', 'banana', 'cherry')
b = "Hello World"
c = 55
print("type:", type(a))
print("type:", type(b))
print("type:", type(c))
# 输入
# type: <class 'tuple'>
# type: <class 'str'>
# type: <class 'int'>
object()
object() 函数返回一个空对象:
x = object()
这个对象不能被增加新的属性或办法。
这个对象是所有类的根底,它领有所有类默认的内置属性和办法。
dir()
dir() 函数返回指定对象的所有属性(包含内置属性)和办法,不带值。
class Person:
name = "Bill"
age = 63
country = "USA"
print("dir:", dir(Person))
# 输入
# dir: ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'country', 'name']
hash()
获取指定对象的「Hash 值」,比方对下面例子中的 Person 对象做哈希:
print("hash:", hash(Person))
# 输入
# hash: 344004709
issubclass()
issubclass() 用于判断是否是子类。
class myAge:
age = 63
class myObj(myAge):
name = "Bill"
age = myAge
print("issubclass:", issubclass(myObj, myAge))
# 输入
# issubclass: True
setattr()
setattr() 函数用于设置对象的「属性的值」。
class Person:
name = "John"
age = 36
country = "Norway"
setattr(Person, 'age', 40)
print("setattr:", Person.age)
# 输入
# setattr: 40
getattr()
getattr() 函数从指定的对象获取「属性的值。
class Person:
name = "Bill"
age = 63
country = "USA"
print("getattr:", getattr(Person, 'age'))
print("getattr:", getattr(Person, 'page', 'my message'))
# 输入
# getattr: 63
# getattr: my message
hasattr()
如果指定的对象领有指定的属性,则 hasattr() 函数将返回 True,否则返回 False。
class Person:
name = "Bill"
age = 63
country = "USA"
print("hasattr:", hasattr(Person, 'age'))
# 输入
# hasattr: True
callable()
如果指定的对象是可调用的,则 callable(object) 函数返回 True,否则返回 False。
id()
id() 函数用户获取对象的「惟一 id」。
Python 中的所有对象都有其本人的惟一 id,并且在创立时就已被调配,id 是对象的内存地址,并且在每次运行程序时都不同。(除了某些具备恒定惟一 id 的对象,比方 -5 到 256 之间的整数)。
x = ('apple', 'banana', 'cherry')
print("id:", id(x))
# 输入
# id: 4308973376
编译与执行
不太罕用,理解即可。
eval()
eval() 函数计算指定的表达式,如果该表达式是非法的 Python 语句,它会被执行。
eval('print(78)')
# 输入
# 78
语法:eval(expression, globals, locals)
参数 | 形容 |
---|---|
expression | 字符串,会被评估为 Python 代码。 |
globals | 可选。蕴含全局参数的字典。 |
locals | 可选。蕴含局部参数的字典。 |
exec()
exec() 函数执行指定的 Python 代码。
exec() 函数承受大量代码块,这与 eval() 函数仅承受单个表达式不同。
exec('name ="Bill"\nprint(name)')
# 输入
# Bill
语法与 eval(expression, globals, locals) 相似
compile()
compile() 函数将指定的源作为代码对象返回,并筹备执行。
x = compile('print(78)', 'test', 'eval')
exec(x)
# 输入
# 78
语法:compile(source, filename, mode, flag, dont_inherit, optimize)
参数 | 形容 |
---|---|
source | 必须。要编译的资源,能够是字符串、字节或 AST 对象。 |
filename | 必须。源所来自的文件的名称。如果源不是来自文件,则能够编写任何内容。 |
mode | 必须。非法值: – eval: 如果源是单个表达式 – exec: 如果源是语句块 – single: 如果源是单个交互式语句 |
flags | 可选。如何对源进行编译。默认为 0。 |
dont-inherit | 可选。如何对源进行编译。默认为 False。 |
optimize | 可选。定义编译器的优化级别。默认为 -1。 |
globals()
globals() 函数将全局符号表作为字典返回。
符号表蕴含无关以后程序的必要信息。
x = globals()
print("globals:", x["__file__"])
# 输入
# globals: /Users/xxx/code/python-demo/basic/built_in.py