python匿名函数、内置函数以及各类高阶函数等

【一】匿名函数

【1】函数的分类

# 【1】正规函数
def login():
    ...
login()

# 【2】匿名函数(无名函数)
# 语法: lambda 参数: 表达式
# lambda: 匿名函数的关键字
# 参数可以放位置参数以及关键字参数...
# 表达式：其实本质上是返回值

【2】定义匿名函数

• Python 使用 lambda 关键词来创建匿名函数，而非 def 关键词

lambda argument_list: expression

• lambda:定义匿名函数的关键词。
• argument_list:函数参数，它们可以是位置参数、默认参数、关键字参数，和正规函数里的参数类型一样。
• expression:只是一个表达式，输入函数参数，输出一些值。

#正规函数
def add(x):
    return x + x


print(add(1)) # 2

#匿名函数
add = lambda x: x + x
print(add(1)) # 2

#正常写法
print([i+i for i in range(10)]) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

#匿名函数
add = lambda x:x+x
print([add(i) for i in range(10)]) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

• 匿名函数可以配合高阶函数使用

# filter 过滤后面的参数 如果返回的结果为True，保留。否则删掉
templist = filter(lambda x: x % 2 == 1, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(templist)) # [1, 3, 5, 7, 9]

【二】内置函数

• 内置函数就是python开发者当时开发python解释器的时候内置的函数

【1】数据类型强制转换（8）

# 【1】str()
# 【2】int()
# 【3】float()
# 【4】list()
# 【5】tuple()
# 【6】bool()
# 【7】set()
# 【8】dict()

【2】数学中的进制转换--（3）

# 【1】bin 十进制转二进制
# print(bin(999)) # 0b 1111100111 (只有0和1的就是二进制)
# 【2】oct 十进制转八进制
# print(oct(999)) # 0o 1747 (有7的就是八进制)
# 【3】hex 十进制转十六进制
# print(hex(999)) # 0x 3e7 (有e字符的就是十六进制)

【3】数学运算--（8）

（1）获取绝对值（abs）

• abs() 返回绝对值

number = -1

# 获取当前整数的绝对值
number_abs = abs(number)

print(number_abs)
# 1

（2）获取商和余数（divmod）

• divmod() 返回商和余数

number_start = 9
number_end = 4
# 获取商和余数 (被除数，除数)
result = divmod(number_start, number_end)
print(result)  # (2, 1)

# number_discuss : 商
# number_remainder : 余数
number_discuss, number_remainder = divmod(number_start, number_end)
print(number_discuss) # 2
print(number_remainder) # 1

（3）四舍五入（round）

• 给定数字的四舍五入版本，有指定的小数位数。
• 默认情况下，小数点的数量是0。

# 可以看到，对 4.51 的值为 5
print(round(4.51))
# 可以看到，对 4.50 的值为 4
print(round(4.50))
# 可以看到，对 4.49 的值为 4
print(round(4.49))

# 这里把浮点数作为第一个参数，把 1 作为第二个参数。
# 可以看到，对 4.051 的值为 4.1
print(round(4.051, 1))
# 可以看到，对 4.050 的值为 4.0
print(round(4.050, 1))
# 可以看到，对 4.049 的值为 4.0
print(round(4.049, 1))

# 这里把浮点数作为第一个参数，把 2 作为第二个参数。
# 可以看到，对 4.0051 的值为 4.01
print(round(4.0051, 2))
# 可以看到，对 4.0050 的值为 4.0
print(round(4.0050, 2))
# 可以看到，对 4.0049 的值为 4.0
print(round(4.0049, 2))

（4）a 的 b 次幂（pow）

• pow(a,b) 求a的b次幂，如果有三个参数，则求完次幂后对第三个数取余

'''
参数介绍：
    x — 数值表达式(整数或者浮点数)；
    y — 数值表达式(整数或者浮点数)；
    z — 数值表达式(整数或者浮点数)，默认不设置z值；

返回值：返回 xy(x的y次方)的值；如果设置了z值,则再对结果进行取模,其结果等效于pow(x,y) %z；
'''

pow(x, y[, z])

• pow 函数常规使用

print(pow(2,5)) # 等价 2**5 = 32
print(pow(2,3)) # 等价 2*2*2 = 8
print(pow(2,3,5)) # 等价 2*2*2%5 = 8 % 5 = 3
print(2*2*2%5)  # 等价 pow(2,3,5) = 3

• 若 x,y 有一个浮点数，则结果将转换为浮点数

print(pow(2,3.2))
print(pow(2,3.0))

'''
输出结果：

9.18958683997628
8.0
'''

（5）求和（sum）

print(sum([1,2,3,4,5,6,7,8,9,10]))  

# 求和:55

（6）最小值（min）、最大值（max）

print(min(5,3,9,12,7,2))  

# 求最小值:2

print(max(7,3,15,9,4,13))  

# 求最大值:15

（7）复数转换（complex）

# complex(re, im) : 具有实部 re、虚部 im 的复数。im 默认为零。

start = complex(3, 4)
print(start)  # (3+4j)

second = complex(5, 9)
print(second)  # (5+9j)

res = start + second
print(res) # (8+13j)

• 参考链接：https://blog.csdn.net/koulongxin123/article/details/121301172

【4】数据结构相关（5）

（1）翻转 reversed

• reversed() 将一个序列翻转, 返回翻转序列的迭代器

lst = "你好啊"

# 不会改变原列表. 返回一个迭代器, 设计上的一个规则
it = reversed(lst)   

print(list(it))  
# ['啊', '好', '你']

（2）切片（slice）

• 列表的切片

lst = [1, 2, 3, 4, 5, 6, 7]

print(lst[1:3:1])  
# [2,3]

s = slice(1, 3, 1)  
#  切片用的
print(lst[s])  
# [2,3]

（3）计算长度（len）

list_num = [i for i in range(10)]
print(len(list_num))  # 10

（4）排序（sorted）

• 语法：sorted(Iterable, key=函数(排序规则), reverse=False)
  • Iterable: 可迭代对象
  • key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
  • reverse: 是否是倒叙. True: 倒叙, False: 正序

lst = [5, 7, 6, 12, 1, 13, 9, 18, 5]

# sort是list里面的一个方法, sort 方法没有返回值
lst.sort()
print(lst)
# [1, 5, 5, 6, 7, 9, 12, 13, 18]

# 内置函数. 返回给你一个新列表  新列表是被排序的
ll = sorted(lst)
print(ll)
# [1, 5, 5, 6, 7, 9, 12, 13, 18]

# 倒序
l2 = sorted(lst, reverse=True)
print(l2)
# [18, 13, 12, 9, 7, 6, 5, 5, 1]

# 根据字符串长度给列表排序
lst = ['one', 'two', 'three', 'four', 'five', 'six']


def f(s):
    return len(s)


l1 = sorted(lst, key=f)
print(l1)  # ['one', 'two', 'six', 'four', 'five', 'three']

（5）枚举（enumerate）

lst = ['one', 'two', 'three', 'four', 'five']
# 把索引和元素一起获取,索引默认从0开始. 可以更改
# 下面更改默认索引从 0 开始
for index, el in enumerate(lst, 1):  
    print(index)
    print(el)

# 1
# one
# 2
# two
# 3
# three
# 4
# four
# 5
# five

【5】字符相关 -- 4

（1）格式化输出（format）

• 对齐方式

s = "hello world!"
print(format(s, "^20"))  # 居  中
#     hello world!
print(format(s, "<20"))  # 左对齐
# hello world!
print(format(s, ">20"))  # 右对齐
#         hello world!

• 进制转换

print(format(3, 'b'))  # 二进制:11
print(format(97, 'c'))  # 转换成unicode字符:a
print(format(11, 'd'))  # ⼗进制:11
print(format(11, 'o'))  # 八进制:13
print(format(11, 'x'))  # 十六进制(⼩写字母):b
print(format(11, 'X'))  # 十六进制(大写字母):B
print(format(11, 'n'))  # 和d⼀样:11
print(format(11))  # 和d⼀样:11

• 科学计数法

print(format(123456789, 'e'))  # 科学计数法. 默认保留6位小数:1.234568e+08
print(format(123456789, '0.2e'))  # 科学计数法. 保留2位小数(小写):1.23e+08
print(format(123456789, '0.2E'))  # 科学计数法. 保留2位小数(大写):1.23E+08
print(format(1.23456789, 'f'))  # 小数点计数法. 保留6位小数:1.234568
print(format(1.23456789, '0.2f'))  # 小数点计数法. 保留2位小数:1.23
print(format(1.23456789, '0.10f'))  # 小数点计数法. 保留10位小数:1.2345678900
print(format(1.23456789e+3, 'F'))  # 小数点计数法. 很大的时候输出INF:1234.567890

（2）字符串转bytes（bytes）

bs = bytes("今天吃饭了吗", encoding="utf-8")

print(bs) 
# b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\x90\x83\xe9\xa5\xad\xe4\xba\x86\xe5\x90\x97'

（3）获取字节数组（bytearray）

• 返回一个新字节数组. 这个数字的元素是可变的, 并且每个元素的值的范围是[0,256)

ret = bytearray("chosen", encoding='utf-8')

print(ret[0])
# 99

print(ret)
# bytearray(b'chosen')

ret[0] = 65
# 把65的位置A赋值给ret[0]

print(str(ret))
# bytearray(b'Ahosen')

（4）返回对象的字符格式（repr）

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

word = "今天\n吃了%s顿\t饭" % 3
print(word)
# 今天
# 吃了3顿	饭

# 原样输出,过滤掉转义字符 \n \t \r 不管百分号%
print(repr(word))
# '今天\n吃了3顿\t饭'

【6】字符编码相关--(3)

（1）字符编码找数字(ord)

• ord() 根据字符编码找数字 ---> 去ASCII码表中查数据

  解释print(ord('a'))  
  # 字母a在编码表中的码位:97
  
  print(ord('中'))  
  # '中'字在编码表中的位置:20013
  

（2）数字找字符编码(chr)

• chr() 根据数字找字符编码 ---》 去ASCII码表中查数据

  解释print(chr(65))  
  # 已知码位,求字符是什么:A
  
  print(chr(19999))  
  # 丟
  

（3）数字找ASCII码(ascii)

• ascii() 是ascii码中的返回该值 不是就返回u

  for i in range(65536):  #打印出0到65535的字符
      print(chr(i), end=" ")
  
  print(ascii("@"))  #'@'
  

【补充】数据集合

• 创建一个冻结的集合(frozenset)
• frozenset() 创建一个冻结的集合，冻结的集合不能进行添加和删除操作。
• 注释: frozenset() 函数返回一个不可变的 frozenset 对象，适用于作为字典的键或集合的元素。

frozen_set = frozenset([1, 2, 3, 4, 5])
print(frozen_set)
# 输出：frozenset({1, 2, 3, 4, 5})

【补充】判断条件（2）

（1）所有为真（all）

• all() 可迭代对象中全部是True, 结果才是True

print(all([1,'hello',True,9]))  #True

（2）任意为真（any）

• any() 可迭代对象中有一个是True, 结果就是True

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

【三】高阶函数

【1】打包（zip）

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

lst1 = [1, 2, 3, 4, 5, 6]
lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生', '辩护人', '被嫌弃的松子的一生']
lst3 = ['美国', '中国', '法国', '意大利', '韩国', '日本']
print(zip(lst1, lst2, lst3))  # <zip object at 0x0000022F28B4AF00>
print(list(zip(lst1, lst2, lst3)))
# [(1, '醉乡民谣', '美国'), (2, '驴得水', '中国'), (3, '放牛班的春天', '法国'), (4, '美丽人生', '意大利'), (5, '辩护人', '韩国'), (6, '被嫌弃的松子的一生', '日本')]

# 按照最少的长度的可迭代类型总和
lst1 = [1, 2, 3, 4, 5]
lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生', '辩护人', '被嫌弃的松子的一生']
lst3 = ['美国', '中国', '法国', '意大利', '韩国', '日本']
print(list(zip(lst1, lst3)))
# [(1, '美国'), (2, '中国'), (3, '法国'), (4, '意大利'), (5, '韩国')]

【2】过滤（filter）

• 语法：filter(function. Iterable)
  • function: 用来筛选的函数.
    • 在filter中会自动的把iterable中的元素传递给function.
    • 然后根据function返回的True或者False来判断是否保留留此项数据
  • Iterable: 可迭代对象
• filter() 过滤 (lamda)

def func(i):  # 判断奇数
    return i % 2 == 1


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

# l1是迭代器
print(filter(func, lst))  # <filter object at 0x000001CE3CA98AC8>
print(list(filter(func, lst)))
# [1, 3, 5, 7, 9]

【3】映射（map）

• 语法 : map(function, iterable)
  • 可以对可迭代对象中的每一个元素进行映射. 分别去执行 function
• map() 会根据提供的函数对指定序列列做映射(lamda)

def f(i):
    return i


lst = [1, 2, 3, 4, 5, 6, 7, ]
# 把可迭代对象中的每一个元素传递给前面的函数进行处理.
# 处理的结果会返回成迭代器print(list(it))

it = map(f, lst)
print(it)  # <map object at 0x000001EEDDE997B0>

# 如果要查看 map 的结果需要用 list 强转
print(list(it))
# [1, 2, 3, 4, 5, 6, 7]

【四】作用域

• locals() 返回当前作用域中的名字
• globals() 返回全局作用域中的名字

name = "chosen"


def func():
    a = 10
    # 当前作用域中的内容
    print(f"这是当前作用域中的内容 :>>>> {locals()}")
    # 全局作用域中的内容
    print(f"这是全局作用域中的内容 :>>>> {globals()}")

    print("我是函数func内部")


func()
# 这是当前作用域中的内容 :>>>> {'a': 10}

# 这是全局作用域中的内容 :>>>> {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000002687A368910>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:\\PythonProjects\\09Python的内置函数\\01start.py', '__cached__': None, 'name': 'dream', 'func': <function func at 0x000002687A3D35B0>}

# 我是函数func内部

【五】迭代器生成器（3）

【1】循环生成数据（range）

print(range(1, 10))
# range(1, 10)

print([i for i in range(1, 10)])
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

【2】获取迭代器（iter）

• 获取迭代器, 内部实际使用的是__ iter__()方法来获取迭代器

lst = [1, 2, 3, 4, 5]

# __iter__()获得迭代器
it = iter(lst)
print(it)
# <list_iterator object at 0x0000016162EC97B0>

【3】向下执行（next）

• 迭代器向下执行一次, 内部实际使用了__ next__()方法返回迭代器的下一个项目

lst = [1, 2, 3, 4, 5]

# __iter__()获得迭代器
it = iter(lst)
print(it)
# <list_iterator object at 0x0000016162EC97B0>
print(next(it))
# 1
print(next(it))
# 2
print(next(it))
# 3
print(next(it))
# 4
print(next(it))
# 5

【六】字符串类型代码的执行（3）

【1】指定指令并返回结果（eval）

• eval() 执行字符串类型的代码. 并返回最终结果
• 函数和类执行不了

s1 = 'input("请输入a:").strip()'
res = eval(s1)
# 输入:4

# 可以动态的执行代码. 代码必须有返回值
print(res)
# 4

code_str = "[i for i in range(10)]"
print(eval(code_str))
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

【2】指定指令不返回结果（exec）

• exec() 执行字符串类型的代码

s2 = "for i in range(5): print(i)"
# exec 执行代码不返回任何内容
a = exec(s2)
# 0
# 1
# 2
# 3
# 4
print(a)  # None

# 动态执行代码
exec("""
def func():
    print(" 我是周杰伦")
""")
func()  # 我是周杰伦


code_str ='''
def add(x, y):
    print(x + y)
    
add(1,5)
'''
print(exec(code_str)) 
# 6
# None

【3】编码指令

• compile() 将字符串类型的代码编码. 代码对象能够通过exec语句来执行或者eval()进行求值
• compile 并不会执行你的代码，只是编译

code_str = '''
def add(x, y):
    print(x + y)
    
add(1,5)
'''
code = compile(code_str, '', mode='exec')
print(exec(code))
# 6
# None

code2 = "5+6+7"
com2 = compile(code2, "", mode="eval")
print(eval(com2))
# 18

code_str_one = 'print([i for i in range(10) if i %2 == 0])'
code = compile(code_str_one, '', mode='eval')
print(eval(code))
# [0, 2, 4, 6, 8]
# None

【七】输入输出函数

# 输入：input()
# 输出：print()

【八】算法

• hash() :
  • 获取到对象的哈希值(int, str, bool, tuple).
• 列表不允许hash

s = 'chosen'
print(hash(s))  
# 5405132401319935146

# 哈希的目的就是为了唯一性
# 字典的内部原理 --> 字典的键的内部原理就是哈希

• hash算法：
  • (1) 目的是唯一性
  • (2) dict 查找效率非常高
• hash表：
  • 用空间换的时间 比较耗费内存

【九】文件操作

f = open('file',mode='r',encoding='utf-8')
f.read()
f.close()

【十】导入模块

# import

【十一】帮助

• help() : 函数用于查看函数或模块用途的详细说明

# 查看字符串的用途
print(help(str))  

【十二】调度函数

• callable() : 用于检查一个对象是否是可调用的
  • 如果返回True, object有可能调用失败
  • 但如果返回False. 那调用绝对不会成功

a = 10
# 变量a不能被调用

print(callable(a))
# False  

def f():
    print("hello")

# 函数是可以被调用的
print(callable(f))
# True

【十三】查看内置属性

• dir():
  • 查看对象的内置属性
  • 访问的是对象中的 __dir__() 方法

# 查看元组的方法
print(dir(tuple))

#查看变量名的属性
print(dir(ad))

【十四】调试器（breakpoint）

• Debug

【十五】判断内存空间地址（id）

print(id('chosen'))
# 1469392953904