Day08_Python偏函数、回调函数、递归函数
08.01_Python语言基础(偏函数)(熟练）
08.02_Python语言基础(回调函数)(掌握）
08.03_Python语言基础变量(Python变量)(重点重点重点掌握)
08.04_Python语言基础(递归函数)(重点)
08.05_Python语言基础(栈模拟递归遍历目录)(熟练)
08.06_Python语言基础(队列模拟遍历目录)(熟练)
08.01_Python语言基础(偏函数)(熟练）
定义：
* 函数在执行时，要带上所有必须的参数进行调用，但是有时参数可以在函数被调用之前提前获知
* 好处： 一个函数或者多个函数的参数预先就能用上,一边函数能用更少的参数进行调用
from functools import partial
def add(a, b):
return a + b
add(3, 5) # 8
add(4, 7) # 11
puls = partial(add, 100)
result = puls(10)
print(result)
运行输出结果:
110
# 进制转换
import functools
# 案例：
print(int("1010", base=2), "--> base表示进制")
# 偏函数
def int2(str, base=2): # int(x,base)x-->字符串或者数字 base---》进制数 默认是十进制
return int(str, base)
print(int2("1011"))
int3 = functools.partial(int, base=2)
print(int3("111"))
总结：
在这里偏函数表达式的意思就是：
* 在函数add的调用时，我们已经知道里面其中一个参数，我们通过这个参数，
* 重新绑定一个函数partial(add,100),然后再去调用
08.02_Python语言基础(回调函数)(掌握）
回调函数的定义
- 回调函数：
- 就是通过函数指针调用函数，如果你把函数的指针（地址）作为参数传递给另外一个函数，当这个指针被用来调用其所指向的函数时，------回调函数，
- 回调函数不是由该函数的实现方直接调用，而是在特定的事件或者条件发生时由另外一方调用，用于对该时间或者条件进行响应
回调函数使用案例
第一个案例（回调函数无返回值）：
def clear1(times):
"""
模拟宾馆扫地
:param times:
:return: None
"""
print("完成扫地的次数", str(times))
def clear2(times):
"""
模拟宾馆洒水
:param times:
:return: None
"""
print("洒水的次数", str(times))
def call_clear(times, function_name):
"""
相当于控制器，控制方法的调用，实现回调函数的核心
:param times: 调用函数次数
:param function_name: 回调函数名称
:return: 调用函数的结果
"""
return function_name(times)
call_clear(10, clear1)
第二个案例（回调函数有返回值）：
"""
回调函数
1.编写生成一个2 * K形式偶数的函数
2.编写一个数字字符串转换为数字(base=2)形式的函数
"""
def double_2k(x):
return x * 2
def str2int02(x):
return int(x, base=2)
def get_result(func, num):
return func(num)
print(get_result(str2int02, "1001"))
print(get_result(double_2k, 23))
08.03_Python语言基础变量(Python变量)(重点重点重点掌握)
变量的分类
* 局部变量
* 成员变量（全局变量）
局部变量
#局部变量
def test1():
a = 10
b = 10
def test2():
a = 10
b = 20
# 以上函数中的变量----》局部变量
总结：
局部变量：
就是在函数内部定义的变量
不同的函数，可以定义相同名字的局部变量，各个变量之间不会发生干涉不会影响
局部变量的作用：为了临时保存数据需要在函数中定义变量来进行保存
全局变量
#全局变量
定义：
如果一个变量，既能在一个函数中使用，
也能在另外一个函数中使用---》全局变量
"""
#定义一个全局变量
a = 100
def test3():
print(a)
def test4():
print(a)
test3()
test4()
全局变量和局部变量名字相同的问题
"""
全局变量和局部变量名字相同的问题
"""
s = 100
def test5():
s = 200
print(s)
s = 300
print(s)
def test6():
print(s)
test5()
修改全局变量
* global 关键字 修改全局变量
* 格式：global 需要修改变量名
# 没有加global修饰的全局变量
num = 11
def num01():
num = 12
return num
print(num01())
print(num)
print("*" * 30)
# 在外部加global修饰的全局变量
global num001
num001 = 110
def num011():
global num001
num001 = 100
return num001
print(num011())
print(num001)
print("*" * 30)
# 在函数内部加global修饰的全局变量
num002 = 110
def num012():
global num002
num002 = 100
return num002
print(num012())
print(num002)
print("*" * 30)
再来一个案例
print("*" * 30)
wendu = 0
def get_wendu():
# 想一下wendu=33不加注释的运行结果
# wendu = 33
global wendu
wendu = 34
def print_wendu():
print(wendu)
get_wendu()
print_wendu()
局部变量和全局变量的区别
1.在函数外面定义的变量称为：全局变量
2.全局变量能够在所有的函数中被访问
3.如果在函数中修改全局变量，那么需要使用global关键字进行声明，否则出错
4.如果出现同名的现象，先到局部找---》全局-----》报错，这个被称为：就近原则
他们的本质的区别：
在于作用域
局部变量和全局变量区别案例
#案例：
def get_wendu():
wendu = 33
return wendu
def print_wendu(wendu):
print(wendu)
result = get_wendu()
print_wendu(result)
wendu = 0
def get_wendu1():
wendu = 34
# global wendu
wendu = 33
def print_wendu1():
print(wendu)
可变类型的全局变量
- 可变类型值: 列表 字典 集合
- 不可变类型: 引用 元祖 数字 字符串
当不可变的数据类型作为全局变量： 需要用global声明，进行修改
当可变的数据类型作为全局变量： 不一定需要global声明
可变类型的全局变量案例：
#案例：
test = []
def d():
test.append(2)
print(test)
d()
test1 = []
def e():
test1 = [1,2]
# global test1
test1 = [3,4]
# print(test1)
e()
print(test1)
test2 = [1,2]
def f(a):
a += a
print(a)
f(test2)
print(test2)
再来一个案例
# 没有加global修饰的全局变量--可变类型
list01 = [1, 2, 3, 4]
def list001():
list01.append(5)
return list01
print(list001())
print(list01)
print("*" * 30)
# 加global修饰的全局变量--可变类型
global list02
list02 = [6, 1, 2, 3, 4]
def list002():
global list02
list02.append(5)
return list02
print(list002())
print(list02)
不可变类型的全局变量案例：
#不可变
a = 1
def g():
a = 2
a += 1
print(a)
# global a
a = 4
g()
print(a)
08.04_Python语言基础(递归函数)(重点)
递归函数的定义
定义：
在函数中不调用其他函数，而是调用自己------》递归函数（自己玩自己）
凡是循环能做的事，递归都能做
递归函数的作用
def show():
print("我叫王二小")
show()
show()
"""
例如：
计算一个阶乘n!
n! = 1*2*3*4...*n
1! = 1
2! = 2*1 2*1!
3! = 3*2*1 3*2!
4! = 4*3*2*1 4*3!
n! = n*(n-1)!
参数
要 1个
返回值
要 结果
#方法1
def calnum(num):
# for temp in range(1,num+1):
i = 1
result = 1
while i <= num:
# result = result * i
result *= i
i += 1
return result
ret = calnum(3)
print(ret)
#方法2：
def calnum(num):
if num >=1:
result = num*calnum(num-1)
else:
result = 1
return result
ret = calnum(3)
print(ret)
注意：防止死循环（递归）
递归遍历目录
import os
def getAllDirRE(path,sp = ""):
#得到当前目录下的所有的文件
filesList = os.listdir(path)
#处理每一个文件
sp += " "
for fileName in filesList:
#判断是否是路径（用绝对路径）
fileAbsPath = os.path.join(path,fileName)
if os.path.isdir(fileAbsPath):
print(sp+"目录：",fileName)
#递归函数
getAllDirRE(fileAbsPath,sp)
else:
print(sp + "普通文件",fileName)
getAllDirRE(r"G:\1806")
08.05_Python语言基础(栈模拟递归遍历目录)(熟练)
- 模拟栈存储方式获取指定路径下所有文件
栈定义：
又名堆栈，
import os
"""
栈：
先进后出
装子弹
"""
#模拟栈结构
#入栈
stack = []
stack.append("A")
print(stack)
stack.append("B")
print(stack)
stack.append("C")
print(stack)
#出栈
res1 = stack.pop()
print("res1=",res1)
print(stack)
res2 = stack.pop()
print("res1=",res2)
print(stack)
def getAllDirRE(path):
stack = []
stack.append(path)
#处理栈，当栈为空的时候结束当前动作
while len(stack) != 0:
#从栈中取数据
dirPath = stack.pop()
filesList = os.listdir(dirPath)
#得到的数据，如果是普通的文件，直接打印，如果，是目录继续压栈
for fileName in filesList:
fileAbsPath = os.path.join(dirPath,fileName)
if os.path.isdir(fileAbsPath):
print("目录"+fileName)
#压栈
stack.append(fileAbsPath)
else:
print("普通"+fileName)
getAllDirRE(r"G:\1806")
08.06_Python语言基础(队列模拟遍历目录)(熟练)
- 模拟队列获取指定路径下所有文件
"""
先进先出 排队
collections
append:添加
queue：获取队列
len:获取长度
popleft:出队
listdir:获取当前目录的所有文件
isdir :判断是否是文件
"""
import os
import collections
def getAllDirQu(path):
#创建一个队列
queue = collections.deque()
#进队
queue.append(path)
while len(queue) != 0:
#出队
dirPath = queue.popleft()
#获取当前路径下的所有的文件
filesList = os.listdir(dirPath)
for fileName in filesList:
#绝对路径
fileAbsPath = os.path.join(dirPath,fileName)
#判断是否是目录（文件夹），如果是进队，不是直接打印
if os.path.isdir(fileAbsPath):
print("目录："+fileName)
queue.append(fileAbsPath)
else:
print("普通文件"+fileName)
getAllDirQu(r"G:\1806"）