python笔记(11)--闭包、高阶函数和高阶内置函数

内容目录

函数中高级（闭包/高阶函数）
内置函数（不常用，但是面试中经常出现）
高阶内置函数（map / filter / reduce）
内置模块（.py文件）

内容回顾

函数基础概念

函数的基本结构
参数
- 写函数时
  - def func(a1,a2):pass
  - def func(a1,a2=None):pass
  - def func(*args,**kwargs):pass
- 执行函数时
  - 位置参数在前 / 关键字参数在后
返回值
- 默认None
- return

函数小高级

函数可以做变量

def func():
    pass
v1 = func
v1()

v2 = [func,func,func]
v2[0]()

函数可以做参数

def func(arg):
    v2 = arg()

def show():
    pass

v1 = func(show)
#注意返回值

python中以函数为作用域

#第一题
for item in range(10):
    pass
print(item)		#结果为9

#第二题
item = 10
def func():
    for item in range(10):
    	pass
	print(item)
func()			#结果为9

#第三题
item = 10
def func():
    item = 2
    def inner():
        print(item)
    for item in range(10):
    	pass
	inner()		#此函数中item = 9
func()			#打印9

#第四题
def func():
    for num in range(10):
        pass
    v4 = [lambda :num+10,lambda :num+100,lambda :num+100,]
    result1 = v4[1]()
    num = 73
    result2 = v4[2]()
    print(result1,result2)
func()		#输出109,173

lambda表达式

内置函数（补充）

pow：指数

v = pow(2,3)
print(v)		#2**3,结果为8

round：保留小数点后多少位（四舍五入）

v = round(1.325,2)	#2代表保留小数点多少位，默认取整
print(v)		#1.32

进制
- bin
- oct
- int
- hex
其他（内置函数重点）
- len
- range
- id
- type
- open

补充：

数据类型中的方法到底有没有返回值
- 无返回值
```
v = [11,22,33]
v.append(99)	#无返回值
```
- 仅有返回值
```
v = 'alec'
result = v.split('l')

v = {'k1':'v2'}
result1 = v.get('k1')
result2 = v.keys()
```
- 有返回+修改数据
```
v = [11,22,33]
result = v.pop()
```
- 常用需要记住：
  - str
    - strip，返回字符串
    - split，返回列表
    - replace，返回字符串
    - upper / lower，返回字符串
    - join，返回字符串
  - list
    - append，无
    - insert，无
    - pop，返回要删除的数据
    - remove，无
    - find / index，返回索引位置
  - dict
    - get
    - keys
    - values
    - items
如果多个函数同时执行时，内部的数据是否会混乱：
- 函数每次运行时都会在内存中开辟一块空间，函数执行完会自动回收内存
- 函数和函数之间调用的时候是互不影响的
- 函数自动回收内存（符合以下条件）
  - 函数内部元素无人使用
  - 函数执行完毕

内容详细

1.函数中高级（闭包/高阶函数）

1.1 函数可以做返回值

def func():
    print("1,2,3")

def bar():
    return func

v = bar()
v()			#结果为1,2,3

#函数体内没有，往父级里找变量
name = "alec"
def func():
    print(name)

def bar():
    return func

v = bar()
v()			#结果为alec
#################################################
name = "oldboy"
def bar():
    name = "alec"
    def inner():
        print(name)
    return inner

v = bar()
v()         # 结果为alec

1.2 闭包：

为函数创建一块区域（内部变量供自己使用），为他以后执行提供数据

name = "oldboy"
def bar(name):
    def inner():
        print(name)
    return inner

v1 = bar("alec")    #{ name=alec,return inner}	#闭包
v2 = bar("eric")    #{ name=eric,return inner}	#闭包
v1()         # 结果为alec，执行后回收该块内存
v2()         # 结果为eric，执行后回收该块内存

练习题：

#第一题
name = "oldboy"
def bar():
    print(name)

def func():
    name = "alec"
    bar()
func()

#第二题
name = "oldboy"
def func():
    name = "alec"
    def bar():
    	print(name)
    bar()
func()

#第三题
name = "oldboy"
def func():
    name = "alec"
    def base():
    	print(name)
    return base		#return返回的是base()函数地址
base = func()		#调用func()函数，拿到return值
base()				#return值调用函数，print输出为alec

面试题：

函数在何时被谁创建的

info = []
def func():
    print(item)
for item in range(10):
    info.append(func)
info[0]()

info = []

def func(i):
    def inner():
        print(i)
    return inner

for item in range(10):
    info.append(func(item))
    
info[0]()		#结果为0
info[1]()		#结果为1
info[4]()		#结果为4

1.3 高阶函数

把函数当做参数传递
把函数当做返回值

注意：对函数进行赋值

1.4 总结

函数执行的流程分析（函数到底是谁创建的）
闭包概念：为函数创建一块区域并为其维护自己数据，以后执行时方便调用【应用场景：装饰器/SQL Alchemy源码】
- 上面闭包的面试题搞清楚

2.内置函数

编码相关：

chr，将十进制数字转换成Unicode编码表中对应的字符串

ord，根据字符在Unicode编码中找到其对应的十进制

#将十进制数字转换成Unicode编码表中对应的字符串
v = chr(90)
print(v)		#结果为 Z

#将字符串循环输出每个字符，进行Unicode转换成十进制，然后输出二进制
v = "中国"
for item in v:
    item = ord(item)
    print(bin(item))

高级的内置函数(map / filter / reduce)

map()：循环每个元素（第二个参数），然后让每个元素执行函数（第一个参数），将每个函数执行的结果保存到新的列表中，并返回
- map中第一个参数必须是函数
- map中第二个参数必须是可迭代类型（可以被for循环的：例如list，dict，tuple，set之类的）
- 然后将函数的返回值添加到新列表中
  - py2:直接返回列表
  - py3:返回列表的对象，不占内存，需要用时用list强转一下
  - 有返回值，原列表不做任何修改
```
#修改列表中每个数据，每个数据加100
#传统方式：
v1 = [11,22,33]
for index in range(0,len(v1)):
    v1[index] += 100
print(v1)

#使用map方式：
v1 = [11,22,33]

def func(arg):
    return arg + 100

result = map(func,v1) #将函数的返回值添加到列表中
print(list(result))

#使用map + lambda方式：
v1 = [11,22,33]
result = map(lambda arg:arg + 100,v1) #将函数的返回值添加到列表中
print(list(result))
```
- 示例图：

filter()：循环每个元素（第二个参数），然后让每个元素执行函数（第一个参数），判断每个函数执行的True / False ，将True或False的值保存到新的列表中，并返回

第一个参数必须是函数
第二个参数必须是可迭代类型（可以被for循环的：例如list，dict，tuple，set之类的）
然后将函数的返回值添加到新列表中
- py2:直接返回列表
- py3:返回列表的对象，不占内存，需要用时用list强转一下
- 有返回值，原列表不做任何修改

#过滤列表中所有的数字，输出结果
#filter方式
v1 = [11,22,33,'asdf','wqer']
def func(arg):
    if type(arg) == int:
        return True
    return False
result = filter(func,v1)
print(list(result))

#最终结果：
#第一个参数func的三元运算写法
def func(arg):
    return True if type(arg) == int else False

#第一个参数func的三元运算写法
def func(arg):
    return type(arg) == int

#filter + lambda + 三元运算
v1 = [11,22,33,'asdf','wqer']
result = filter(lambda arg:type(arg) == int,v1)
print(list(result))

示例图

reduce():

必须引用模块（import functools）
第一个参数必须是函数（函数内需要两个以上的参数）
第二个参数必须是可迭代类型（可以被for循环的：例如list，dict，tuple，set之类的）
然后将函数的返回值添加到新列表中
- 有返回值，原列表不做任何修改

#计算列表中每个数的和
#reduce方法
import functools
v1 = [1,2,3,4]
def func(x,y):
    return x + y

result = functools.reduce(func,v1)
#执行时，首次执行时x,y等于列表中前两个参数，每次循环执行完，x等于之前执行的结果，y等于下一个值
print(result)		#结果为10

#reduce + lambda方式：
import functools
v1 = [1,2,3,4]

result = functools.reduce(lambda x, y: x + y, v1)
print(result)

#将列表中每个字符串拼接起来
import functools

v1 = ["ni","hao","ma","alec"]

result = functools.reduce(lambda x, y: x + y, v1)
print(result)		#结果为nihaomaalec

示例图

面试题：
- 常用的内置函数有哪些？
- filter / map / reduce是什么意思
- 什么是匿名函数？（lambda表达式就是匿名函数）

3.模块

random模块（生成随机数）

应用场景：生成一个随机验证码的函数

import 导入一个模块

# 注意使用 chr() 方法和random.randint( min , max )，跟unicode编码对应
# random.randint( min , max )生成随机数字
import random

def get_random_code(length=6):
    data = []
    for item in range(length):
        item = random.randint(65, 90)
        data.append(chr(item))
    return "".join(data)

v = get_random_code()
print(v)

random.shuffle方法：列表打乱顺序

import random

li = [11,22,33,44,55,66]
random.shuffle(li)
print(li)			# 注意，打乱的是原列表。

md5加密：

使用hashlib模块

不可反解（但是在网上使用撞库(穷举法)可以破解：直接搜md5解密）

import hashlib	

obj = hashlib.md5()
obj.update("123".encode("utf-8"))
result = obj.hexdigest()
print(result)

#使用函数封装：
import hashlib

def get_md5(data):
    obj = hashlib.md5()
    obj.update(data.encode("utf-8"))
    result = obj.hexdigest()
    return result

user = get_md5("123")
print(user)

md5加密加严：

加密过程中使用自定义字符添加进加密算法中，无法被反解

import hashlib

def get_md5(data):
    obj = hashlib.md5("sdfjasd".encode("utf-8"))  #此md5中可自定义字符
    obj.update(data.encode("utf-8"))
    result = obj.hexdigest()
    return result

user = get_md5("123")
print(user)

md5应用：

用户登录

import hashlib

USER_LIST = []

def get_md5(data):
    obj = hashlib.md5("sdfjasd".encode("utf-8"))
    obj.update(data.encode("utf-8"))
    result = obj.hexdigest()
    return result

def register():
    print("*********用户注册*********：")
    while True:
        user = input('请创建用户名：')
        if user == "N":
            return
        pwd = input("请创建密码：")
        USER_LIST.append({"name":user,"password":get_md5(pwd)})

def login():
    print("*********用户登录*********：")
    user = input("请输入用户名：")
    pwd = input("请输入密码：")
    for item in USER_LIST:
        if item["name"] == user and item["password"] == get_md5(pwd):
            return True

register()
result = login()
if result:
    print("登录成功")
else:
    print("登录失败")

getpass模块（密码不显示）

（只能在终端运行）

import getpass					  #导入模块

v = getpass.getpass("请输入密码：")	#用户输入时不显示输入内容
if v == "456":
    print("登录成功")
else:
    print("登录失败")

总结

函数
- 基本函数结构（重点，以后98%都在用这个）
- 高级
  - 参数
  - 闭包
- 内置函数
- 模块
  - random
  - hashlib
  - getpass