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 = 110def num011():
global num001
num001 = 100
return num001
print(num011())
print(num001)
print("*" * 30)

# 在函数内部加global修饰的全局变量
num002 = 110def 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"）