day09笔记

最新推荐文章于 2022-01-16 16:54:32 发布

zy13955413303

最新推荐文章于 2022-01-16 16:54:32 发布

阅读量151

点赞数

09.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),然后再去调用

09.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.生成一个4 * K形式的偶数
“”“

# 回调函数1
def double_2k(x):
    return 2 * x


# 回调函数2
def double_4k(x):
    return 4 * x


# 控制器
def get_number(k, get_even_number):
    """

    :param k: 传入的基数
    :param get_even_number:  回调函数名称
    :return:   回调返回值
    """
    return get_even_number(k) + 1


def main():
    k = 2
    i01 = get_number(k, double_2k)
    i02 = get_number(k, double_4k)
    i03 = get_number(k, lambda x: x * 8)
    print(i01)
    print(i02)
    print(i03)


main()

09.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)

09.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")

09.06_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”)

09.07_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”）

09.06_Python语言基础(数据结构)(了解)

数据结构概述

定义：
只是静态描述数据元素之间的关系

顺序结构

链表结构

zy13955413303

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day09笔记

09.01_Python语言基础(偏函数)(熟练）定义：* 函数在执行时，要带上所有必须的参数进行调用，但是有时参数可以在函数被调用之前提前获知* 好处：一个函数或者多个函数的参数预先就能用上,一边函数能用更少的参数进行调用 from functools import partialdef add(a, b): return a + badd(3,...
复制链接

扫一扫