快速掌握 Python 内置函数用法、按用途分类记忆

Posted on by hackdl

转载于海外博客「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
# 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 工具，提供三种命令：

  1. 命令’p’：输出某个对象的值。
  2. 命令’n’：进入到下一行代码执行。
  3. 命令’c’：执行程序直到遇到下一个breakpoint()。

比如下面这个例子，进入 pdb 调试过程后，键入 ‘p lst’ 可以将 lst 的当前值打出来，或者用命令’n’进入下一行代码：

# breakpoint
lst = []
for i in range(10):
    lst.append(i)
    if i == 5:
        breakpoint()

输入&输出流

print()

print() 函数将指定的「内容」打印到标准输出设备，内容可以是字符串，也可以是任何其他对象，该对象在打印之前会被转换为字符串。

给出两种进阶操作：

  1. 间隔符号
print("log", "param", sep=" --- ")

# 输出
# log --- param
  1. 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”：创建 – 创建指定的文件，如果文件存在则返回错误。

另外，您可以指定文件应以二进制还是文本模式处理
– “t”：文本 – 默认值。文字模式。
– “b”：二进制 – 二进制模式（例如图像）。

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() 函数返回指定的可迭代对象的排序列表:

  1. 可以指定升序或降序。
  2. 字符串按字母顺序排序，数字按大小排序。
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:  'u6d4bu8bd5'
# 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__': , '__weakref__': , '__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: 
# type: 
# type:

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

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net

服务器托管，北京服务器托管，服务器租用，机房机柜带宽租用

服务器托管

咨询：董先生

电话13051898268 QQ/微信93663045！

上一篇:
下一篇: