关于python:快速掌握-Python-内置函数用法按用途分类记忆

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

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

2. 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)

open()

open() 函数关上一个文件，并将其作为文件对象返回。

语法：open(file, mode)

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)

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:  '\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)

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)

globals()

globals() 函数将全局符号表作为字典返回。

符号表蕴含无关以后程序的必要信息。

x = globals()
print("globals:", x["__file__"])

# 输入
# globals: /Users/xxx/code/python-demo/basic/built_in.py