内置函数

截止到python版本3.6.2，python一共为我们提供了68个内置函数。

作用域相关

• locals ：函数会以字典的类型返回当前位置的全部局部变量。
• globals：函数以字典的类型返回全部全局变量。

a = 1
b = 2

print(locals())
print(globals())

# 这两个一样，因为是在全局执行的

def func(argv):
    c = 2
    print(locals())
    print(globals())

func(3)

字符串类型代码执行

eval()

计算指定表达式的值，并返回最终结果

ret = eval('2 + 2')
print(ret)

n = 20
ret = eval('n + 23')
print(ret)

eval('print("Hello world")')

exec()

执行字符串类型的代码

s = '''
for i in range(5):
    print(i)
'''

exec(s)

# Output:
0
1
2
3
4

compile()

用于将源代码编译成字节码，从而可以在后续执行中使用。这个函数的主要作用是将字符串形式的代码转换为可以通过 exec() 或 eval() 执行的代码对象。

语法

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

参数

• source：要编译的源代码，可以是字符串或 AST（抽象语法树）对象。

• filename：表示代码的文件名（通常为字符串），用于错误消息的显示。可以是任意字符串。

• mode

  ：指定编译模式，可以是以下三种之一：

  • 'exec'：用于编译多条语句（如模块或函数）。
  • 'eval'：用于编译单个表达式。
  • 'single'：用于编译单个交互式语句。

返回值

返回一个代码对象，可以使用 exec() 或 eval() 执行

示例

# 流程语句使用exec
code1 = 'for i in range(5): print(i)'
compile1 = compile(code1,'','exec')

exec(compile1)

# 简单求值表达式用eval
code2 = '1 + 2 + 3'
compile2 = compile(code2,'','eval')
eval(compile2)

# 交互语句用single
code3 = 'name = input("please input you name: ")'
compile3 = compile(code3,'','single')

exec(compile3)
print(name)

有返回值的字符串形式的代码用eval，没有返回值的字符串形式的代码用exec，一般不用compile。

输入/输出相关

• input:函数接受一个标准输入数据，返回为 string 类型。
• 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: 立即把内容输出到流文件，不作缓存
    """
'''

print(11,22,33,sep='*')

print(11,22,33,end='')
print(44,55)

with open('log','w',encoding='utf-8') as f:
    print('写入文件',file=f,flush=True)

内存相关

hash

获取一个对象（可哈希对象：int，str，bool，tuple）的哈希值。

print(hash(12322))
print(hash('123'))
print(hash('arg'))
print(hash('aaron'))
print(hash(True))
print(hash(False))
print(hash((1,2,3)))

# Output:
12322
3301683310855814603
-5446340200358907515
-7288871457537009866
1
0
529344067295497451

id

用于获取对象的内存地址

print(id('abc'))
print(id('123'))

# Output:
1912719664944
1912719753584

文件操作相关

• open()：用于打开一个文件，创建一个 file 对象
• read()：通过文件对象调用，读取文件的内容
• write()：文件文件对象调用，往文件里下入内容

.......

帮助文档

• help：函数用于查看函数或模块用途的详细说明。

print(help(print))

#结果
print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

调用相关

• callable函数：用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回-False，调用对象ojbect绝对不会成功。

print(callable(0))
print(callable('hello'))

# 自定义函数
def demo1(a, b):
    return a + b
print(callable(demo1))

# 自定义类
class Demo2:
    def test1(self):
        return 0

print(callable(Demo2))

# 实例化对象
a = Demo2()
print(callable(a))

# Output:
False
False
True
True
False

查看内置属性

• dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。

import time
print(dir(time))        # 查看某个模块的属性和方法

print(dir([]))          # 查看列表的属性和方法

迭代器生成器相关

• range：函数可创建一个整数对象，一般用在 for 循环中。
• next：内部实际使用了__next__方法，返回迭代器的下一个项目。

# 首先获得Iterator对象:
it = iter([1,2,3,4,5,6])
# 循环
while True:
    try:
        # 获得下一个值
        x = next(it)
        print(x)
    except StopIteration: # 遇到StopIteration就退出循环
        break

• iter：函数用来生成迭代器（通过一个可迭代对象生成迭代器）。

from collections import Iterable
from collections import Iterator

l = [1,2,3,4]   # 可迭代对象，但不是迭代器
print(isinstance(l,Iterable))
print(isinstance(l,Iterator))

l1 = iter(l)    # 从一个可迭代对象生成迭代器
print(isinstance(l1,Iterable))
print(isinstance(l1,Iterator))

基础数据类型相关

数字相关

数据类型（4个）：

• bool ：用于将给定参数转换为布尔类型，如果没有参数，返回 False。
• int：函数用于将一个字符串或数字转换为整型。

print(int())
print(int('12'))
print(int(3.6))
print(int('0100',base=2))  # 将2进制的 0100 转化成十进制。结果为 4

# Output:
0
12
3
4

• float：函数用于将整数和字符串转换成浮点数。
• complex：用于创建复数（complex numbers）。复数是由实部和虚部组成的，通常写作 a + bj 的形式，其中 a 是实部，b 是虚部，j 是虚数单位。

z1 = complex(2, 3)  # 实部为 2，虚部为 3
print(z1)  # 输出: (2+3j)

进制转换（3个）：

• bin：将十进制转换成二进制并返回。
• oct：将十进制转化成八进制字符串并返回。
• hex：将十进制转化成十六进制字符串并返回。

print(bin(10),type(bin(10)))
print(oct(10),type(oct(10)))
print(hex(10),type(hex(10)))

数学运算（7）：

• abs：函数返回数字的绝对值。
• divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。
• round：保留浮点数的小数位数，默认保留整数。
• pow：函数是计算x的y次方，如果z在存在，则再对结果进行取模，其结果等效于pow(x,y) %z）

print(abs(-5))  # 5

print(divmod(7,2))  # (3, 1)

print(round(7/3,2))  # 2.33
print(round(7/3))  # 2
print(round(3.32567,3))  # 3.326

print(pow(2,3))  # 8
print(pow(2,3,3))  # 2

• sum：对可迭代对象进行求和计算（可设置初始值）。
• min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。
• max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。

print(sum([1,2,3]))
print(sum([1,2,3],100))

print(min([1,2,3]))

ret = min([1,2,3,-10],key=abs)
print(ret)

print(max([1,2,3]))

ret = max([1,2,3,-10],key=abs)
print(ret)

# Output:
6
106
1
1
3
-10

数据结构相关

列表和元祖（2个）

• list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。
• tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。

l = list((1,2,3))
print(l)
l = list({1,2,3})
print(l)
l = list({'k1':1,'k2':2})
print(l)

tu = tuple((1,2,3))
print(tu)
tu = tuple([1,2,3])
print(tu)
tu = tuple({'k1':1,'k2':2})
print(tu)

相关内置函数（2个）

• reversed：将一个序列翻转，并返回此翻转序列的迭代器。
• slice：构造一个切片对象，用于列表的切片。

ite = reversed(['a',2,4,'f',12,6])
for i in ite:
    print(i)

l = ['a','b','c','d','e','f','g']
sli = slice(3)
print(l[sli])

sli = slice(0,7,2)        # 也可以加上步长
print(l[sli])

字符串相关（9）

• str：将数据转化成字符串。
• format:与具体数据相关，用于计算各种小数，精算等。

# 字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
print(format('test','<20'))
print(format('test','>20'))
print(format('test','^20'))

# 整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None
print(format(192,'b'))  # 转换为二进制
print(format(97,'c'))   # 转换unicode成字符
print(format(11,'d'))   # 转换成10进制
print(format(11,'o'))   # 转换为8进制
print(format(11,'x'))   # 转换为16进制，小写字母表示
print(format(11,'X'))   # 转换为16进制，大写字母表示
print(format(11,'n'))   # 和d一样
print(format(11))       # 和d一样

# 浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None
print(format(314159265,'e'))    # 科学计数法，默认保留6位小数
print(format(314159265,'0.2e')) # 科学计数法，保留2位小数
print(format(314159265,'0.2E')) # 科学计数法，保留2位小数,大写E
print(format(3.14159265,'f'))   # 小数点计数法，默认保留6位小数
print(format(3.14159265,'0.10f'))    # 小数点计数法，保留10位小数
print(format(3.14e+10000,'F'))    # 小数点计数法，无穷大转换成大小字母

# g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数
print(format(0.00003141566,'.1g'))
# p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点
print(format(0.00003141566,'.2g'))
# p=2,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点

print(format(3.1415926777,'.1g'))
# p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点
print(format(3.1415926777,'.2g'))
# p=2,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点
print(format(3141.5926777,'.2g'))
# p=2,exp=3 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点

print(format(0.00003141566,'.1n'))  # 和g相同
print(format(0.00003141566))        # 和g相同

• repr:返回一个对象的string形式

name = 'aaron'
print('Hello %r'%name)

str1 = '{"name":"aaron"}'
print(repr(str1))
print(str1)

数据集合（3个）

• dict：创建一个字典。
• set：创建一个集合。
• frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

相关内置函数（8个）

• len:返回一个对象中元素的个数。
• sorted：对所有可迭代的对象进行排序操作。

numbers = [5, 2, 9, 1, 5, 6]        # 升序
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 输出: [1, 2, 5, 5, 6, 9]

numbers = [5, 2, 9, 1, 5, 6]        # 降序
sorted_numbers_desc = sorted(numbers, reverse=True)
print(sorted_numbers_desc)  # 输出: [9, 6, 5, 5, 2, 1]

# 可以使用 key 参数指定一个函数，用于从元素中提取用于排序的比较键
words = ['banana', 'apple', 'cherry']
sorted_words = sorted(words, key=len)
print(sorted_words)  # 输出: ['apple', 'banana', 'cherry']

• enumerate: 用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

print(enumerate([1,2,3]))

for i in enumerate([1,2,3]):
    print(i)

for i in enumerate([1,2,3],100):
    print(i)

• all：可迭代对象中，全都是True才是True
• any：可迭代对象中，有一个True 就是True

print(all([1,2,True,0]))
print(any([1,'',0]))

• zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]

zipped = zip(names, ages)
print(list(zipped))  # 输出: [('Alice', 25), ('Bob', 30), ('Charlie', 35)]

# 不同长度的可迭代对象
x = [1, 2]
y = ['a', 'b', 'c']

zipped = zip(x, y)
print(list(zipped))  # 输出: [(1, 'a'), (2, 'b')]

filter：用于过滤序列，过滤掉不符合条件的元素，返回由符合元素组成的新的迭代器

def func(x):
    return x%2 == 0
ret = filter(func,[1,2,3,4,5,6,7,8,9,10])
print(ret)
for i in ret:
    print(i)

使用 filter() 过滤出大于 5 的数字：

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
filtered_numbers = filter(lambda x: x > 5, numbers)
print(list(filtered_numbers))  # 输出: [6, 7, 8, 9]

• map:用于将指定函数应用于可迭代对象中的每个元素，并返回一个迭代器。这个函数非常有用，可以简化对数据的转换和处理。

def square(x):
    return x**2

list1 = [1,2,3,4,5,6,7,8]

ret = map(square,list1)
print(ret)

for i in ret:
    print(i)

匿名函数

在 Python 中，匿名函数是指没有名称的函数，通常使用 lambda 关键字定义。匿名函数可以用于需要函数作为参数的场合，比如在 map()、filter() 和 sorted() 等函数中。

也可以理解为，为了解决那些功能很简单的需求而设计的一句话函数。

语法

lambda 参数: 表达式

• 参数可以有多个，用逗号隔开
• 匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
• 返回值和正常的函数一样可以是任意数据类型

示例：

# 自定义函数的方法
def func1(n):
    return n ** n

print(func1(10))

# 换成匿名函数
func2 = lambda n: n ** n
print(func2(10))

案例

1. 计算两个数的和

add = lambda x, y: x + y
print(add(2, 3))  # 输出: 5

1. 配合map()使用

list1 = [1,2,3,4,5,6,7,8]

ret = map(lambda x: x ** 2,list1)
print(ret)

for i in ret:
    print(i)

1. 配合filter()使用

ret = filter(lambda x: x % 2 == 0,[1,2,3,4,5,6,7,8,9,10])
print(ret)
for i in ret:
    print(i)