内置函数、匿名函数

一、内置函数

作用域相关：locals()、globals()，点击查看

其他：eval、exec、dir、input、print、hash、open、__import__、compile

• eval和exec都可以执行字符串类型的代码
• eval有返回值：适合有结果的计算
• exec没有返回值：适合流程控制

eval("print(1+2)")    # 3
exec("print(1+2)")    # 3
print(eval("1+2"))    # 3
print(exec("1+2"))    # None

dir()：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。

# 查看使用方法
print(dir())
print(dir([]))
print(dir(str))

input()：函数接受一个标准输入数据，返回为string(字符串)类型。

print()：打印

print(*args, sep = " ", end = "
", file = sys.stdout, flush = False)
# 将对象打印到文本流文件，以sep分隔，然后结束。sep，end，file和flush（如果存在）必须作为关键字参数给出。
　　sep：  打印多个值之间的分隔符，默认为空格
　　end：  每一次打印的结尾，默认为换行符
　　file： 默认是输出到屏幕，如果设置为文件句柄，输出到文件
　　flush：立即把内容输出到流文件，不作缓存

print("AB", "CD", sep="|")    #AB|CD

print(11, end="")
print(22)    #1122

print(11, end=" ")
print(22)    #11 22

with open("1.txt", "w", encoding="utf-8") as f:
    print(11, 22, sep="-", file=f, flush=True) # 文件里写入了11-22

# 打印进度条
import time

for i in range(0, 101, 2):
    time.sleep(0.1)
    symbol_num = i // 2
    progress_str = "
{}%  {}
".format(i, "#"*symbol_num) if i == 100 else "
{}%  {}".format(i, "#"*symbol_num)
    print(progress_str, end=" ")
    # 100%  ##################################################

hash(object)：返回object的哈希值（如果有的话）

print(hash(123))        # 123
print(hash("pd"))       # 1092457194709355922
print(hash(True))       # 1
print(hash(False))      # 0
print(hash((1, 2, 3)))  # 2528502973977326415
# print(hash([1, 2, 3]))# 不可哈希，报错

 open()：打开文件并返回相应的文件对象，比如返回给句柄f。

 compile()：compile(source，filename，mode)

source
　　# 字符串或者AST（Abstract Syntax Trees）对象
filename
　　# 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可
model
　　# 指定编译代码的种类，可以指定为'eval','exec','single'；当source中只包含一个简单的求值表达式，model应指定为'eval'；当source中包含流程语句时，model应指定为'exec'；当source中包含了交互式命令语句，model应指定为'single'

# 简单求值用eval
s = "1 + 2"
c = compile(s, "", "eval")
print(eval(c))  # 3

# 流程语句使用exec
s= "for i in range(1, 6):print(i)"
c = compile(s, "", "exec")
print(eval(c))

# 交互语句用single
c = "name = input('please input your name：')"
c = compile(c, "", "single")
# print(name)  # exec(c)执行前，name变量还没被定义，报错
exec(c)        # 执行时显示交互命令，提示输入
print(name)    # exec(c)执行后，name变量有值

迭代器、生成器：range、next、iter

range()：创建一个整数对象，一般用在 for 循环中

iter(iterable)：将可迭代对象转化为迭代器

from collections import Iterable
from collections import Iterator

lis1 = [1,2,3]
print(isinstance(lis1,Iterable))  # True
print(isinstance(lis1,Iterator))  # False

lis2 = iter(lis1)
print(isinstance(lis2,Iterable))  # True
print(isinstance(lis2,Iterator))  # True

next()：从迭代器中一个一个地取值

ret = iter([1, 2, 3])
print(next(ret))  # 1
print(next(ret))  # 2

基础数据类型：有一些未记录

float()：用于将整数和字符串转换成浮点数

complex()：用于创建一个值为 real + imag*j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数

print(complex(1, 2)) # (1+2j)
print(complex(1))    # (1+0j)
print(complex("1"))  # (1+0j)

 二进制(bin)、八进制(oct)、十六进制(hex)

print(bin(10), type(bin(10)))  # 0b1010 <class 'str'>
print(oct(10), type(oct(10)))  # 0o12 <class 'str'>
print(hex(10), type(hex(10)))  # 0xa <class 'str'>

abs()：求绝对值

print(abs(-5))  # 5

divmod()：除余

print(divmod(7,2)) --> 7除以2，得3余1
print(divmod(9,5)) --> 9除以5，得1余4
#(3, 1)
#(1, 4)

pow()：幂运算

print(pow(2, 3))     # 幂运算，2的3次方
print(pow(2, 3, 3))  # 幂运算之后再取余数，即2*2*2/3余2
#8
#2

round()：小数精确度

print(round(3.1415, 2))  # 3.14
print(round(3.1415, 3))  # 3.142  
print(round(3.1414, 3))  # 3.141

sum()：对可迭代对象进行求和计算（可设置初始值）

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

min()：返回可迭代对象的最小值（参数key为函数名，通过函数的规则，返回最小值）

max()：返回可迭代对象的最大值（参数key为函数名，通过函数的规则，返回最大值）

print(min([1, 2, 3]))
print(min([-1, 4, 6], key=abs))  # key=abs 按绝对值比较大小，然后返回本来的值
# 1
# -1

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

print(list((1, 2, 3)))          # [1, 2, 3]
print(list({"k1": 1, "k2": 2})) # ['k2', 'k1']

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

print(tuple((1, 2, 3)))          # (1, 2, 3)
print(tuple({"k1": 1, "k2": 2})) # ('k1', 'k2')

reversed()：返回反向迭代器

lis1 = [1, 2, 3, 4, 5]
lis2 = reversed(lis1)

print(lis2)  # <list_reverseiterator object at 0x0000000000B7B2B0>

for i in lis2:
    print(i)

slice()：返回表示由指定的索引集的切片对象

l = (1,2,3,4,5,6,7)
s = slice(1, 5, 2)
print(l[s])     # (2, 4)
print(l[1:5:2]) # (2, 4)

format()：将值转换为“格式化”表示

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

bytes()：返回一个新的"bytes"对象

print(bytes("你好", encoding="GBK"))     # unicode转换成GBK的bytes
print(bytes("你好", encoding="utf-8"))   # unicode转换成utf-8的bytes

memoryview()：返回从给定参数创建的"内存视图"对象

ret = memoryview(bytes("你好", encoding="utf-8"))
print(len(ret))                         # 6
print(bytes(ret[:3]))                   # b'xe4xbdxa0'
print(bytes(ret[:3]).decode("utf-8"))   # 你

ord()：字符按unicode转数字
chr()：数字按unicode转字符

print(chr(48))   # 0
print(chr(49))   # 1

print(ord("A"))  # 65
print(ord("a"))  # 97

print(chr(65))   # A
print(chr(97))   # a

repr()：返回包含对象的可打印表示的字符串

s = "xxx"
print("%r" % s)                     # 'xxx'
print(repr("1"), type(repr("1")))   # '1' <class 'str'>
print(repr(1), type(repr(1)))       # 1 <class 'str'>

frozenset()：让集合变成不可变类型

s = frozenset("abcd")
print(s, type(s))  # frozenset({'c', 'a', 'd', 'b'}) <class 'frozenset'>

enumerate(iterable，start = 0)：返回一个枚举对象（从start开始，默认为0）

lis = ["my", "name", "is", "pd"]
for i, item in enumerate(lis):
    print(i, item)
# 0 my
# 1 name
# 2 is
# 3 pd

for i, item in enumerate(lis, 1):
    print(i, item)
# 1 my
# 2 name
# 3 is
# 4 pd

all()：可迭代对象中，有一个False就是False
any()：可迭代对象中，有一个True就是True

print(all([0, 1])) # False
print(any([0, 1])) # True

zip()：函数用于将可迭代的对象作为参数，将对象与对象之间对应的元素打包成一个元组。如果各个对象的元素个数不一致，则返回元祖的长度与最短的对象相同。

lis1 = [1, 2, 3]
lis2 = ["a", "b", "c"]
lis3 = {"k1": 11, "k2": 22}
for i in zip(lis1, lis2, lis3):
    print(i)
# (1, 'a', 'k1')
# (2, 'b', 'k2')

filter(function, iterable)：过滤、返回一个迭代器

def func(x):
    return x % 2 == 1
ret = filter(func, [1, 2, 3, 4, 5, 6])  # 删除偶数，保留奇数
for i in ret:
    print(i)
# 相当于print([i for i in [1, 2, 3, 4, 5, 6] if i % 2 == 1])

# 利用filter()删除None和空字符串
def func(s):
    return s and len(s.strip()) > 0
ret = filter(func, ["a", None, "", "1"])
for i in ret:
    print(i)

# 求100以内的开平方
import math
def func(x):
    return math.sqrt(x) % 1 == 0
ret = filter(func, range(1, 101))
for i in ret:
    print(i)

map(function, iterable)：返回一个迭代器

ret = map(abs, [1, -4, 6, -8])
for i in ret:
    print(i)
# 1
# 4
# 6
# 8

filter()：执行了filter之后的结果集合  <=  执行之前的个数
　　　  filter只管筛选，不会改变原来的值

map()：执行前后元素个数不变，值可能发生改变

sorted(iterable, key=None,  reverse=False)：临时排序，sort()为永久排序

# 参数key：传入一个函数名，函数的参数是可迭代类型中的每一项，根据函数的返回值大小排序
lis = [1, -3, 4, -6, 5, -2]
print(sorted(lis, key=abs, reverse=True))  # 取绝对值，再反向排序
print(lis)  # 证明sorted()为临时排序
# [-6, 5, 4, -3, -2, 1]
# [1, -3, 4, -6, 5, -2]

二、匿名函数

lambda：为了解决那些功能很简单的需求而设计的一句话函数

 格式：函数名 = lambda 参数：返回值

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

def add(x, y):
    return x + y
print(add(1, 2))  # 3
# 换成匿名函数
add = lambda x, y: x + y
print(add(1, 2))  # 3

# 求字典中最大值对应的键
dic = {"k1": 10, "k2": 20, "k3": 30}
def func(k):
    return dic[k]
ret = max(dic, key=func)
print(ret)  # k3

# 换成匿名函数
print(max(dic, key=lambda k:dic[k]))  # k3

现有两个元组(("a"), ("b")),(("c"), ("d"))，使用匿名函数生成列表[{"a": "c"}, {"b": "d"}]

ret1 = zip((("a"),("b")),(("c"),("d")))

def func(tup):
    return {tup[0],tup[1]}
ret2 = map(func, ret1)
print(list(ret2))  # [{'c', 'a'}, {'d', 'b'}]

ret3 = map(lambda tup:{tup[0]:tup[1]}, ret1)
print(list(ret3))  # []