Python函数进阶

2022-11-02

python基础3

一.函数进阶闭包&装饰器

今晚记住两个关键词《直接》和《间接》

demo：

我的电脑硬盘内存不足了， 现在有什么解决办法？
 
 1.加装一块硬盘      直接升级  
 2.插u盘            间接升级

def test():
    # 外部函数
    a = 10 
    def test1():  # 闭---->嵌套函数
        # 内部函数
        print(a)  # 包 --->用到了外部函数中的变量
    return test1 # 最后得把这个内部函数return 出去
    # return test1() # 把这个内部函数-----调用后的结果 return 出去     # 10

闭包函数

到底是个什么
是个函数
闭：封闭 >> 嵌套该函数是个内部函数在外部的函数体里面定义的函数
包：内部函数包含外部函数作用域中的变量的使用 (不是指全局作用域)

总结：
1. 它必须是个函数
2. 并且它必须是嵌套函数
3. 内部函数必须使用了外部函数的作用域中的变量
4. 还得把内部函数 return 出去

包：空间 >> 局部名称空间 >> 局部作用域

def fun():
    a = 1
    
    def fun1():   # 闭：嵌套
    	print(a)  # 包：使用 外部作用域中的a

    return fun1   # 函数对象

rest = fun()   # rest就是fun1     <function fun.<locals>.fun1 at 0x000001F6D22AEA60>
print(rest)    #  把内部函数return出去
print(rest())  # 1   None(内部函数的返回值)
# rest()相当于外层函数返回fun1()  即：把这个内部函数----调用后的结果 return 出去


1. 函数的嵌套 	         -------->    闭 
2. 作用域                 -------->   包
3. 用不了这个函数（必须返回才能使用）------>   函数对象


def outer():
    # 局部作用域
    a = 12

    def iner():
        print(a)  # 12

    return iner  # iner ----> 返回函数对象


rest = outer()   # <function outer.<locals>.iner at 0x000002CB5E27EA60>
print(rest)   
print(type(rest))   # <class 'function'>
rest()  # iner()   12


# 升级 2.0 版本
# 实现变化传参

def outer(num):
    #  局部作用域
    # 外部作用域
    def iner(num):  # 直接传参
        # 内部作用域
        num += 1
        print(num)  # 12

    return iner   # iner  ---> 返回函数对象

rest = outer(11)  # # outer函数调用后  把返回值(指向iner) 赋值给rest变量
rest(11) # iner  相当于传值了两遍   如果任意一个不传会报错----> iner() missing 1 required positional argument: 'num'



def outer():
    #  局部作用域
    # 外部作用域
    def iner(num):
        # 内部作用域
        num += 1
        print(num)  # 12

    return iner   # iner  ---> 返回函数对象

rest = outer()  # # outer函数调用后  把返回值(指向iner) 赋值给rest变量
rest(11) # iner  相当于传值了两遍   如果任意一个不传会报错----> iner() missing 1 required positional argument: 'num'
#这就是间接传参 ---> 也就是使用闭包把inner隐藏起来  直接调用外部函数  并进行传参


# 简便的方法
def outer(num):
    def iner():   # 变化1
        nonlocal num  # 把一个变量从全局转化为私有的，就可以修改了
        num += 1
        print(num)  # 12

    return iner  # iner ---> 返回函数对象

rest = outer(11) # outer函数调用后  把返回值(指向iner) 赋值给rest变量
rest()   # 12  # 变化2  或者直接返回iner(num)


# 只要在函数外 属于 全局

# 反之 只要在函数内 属于局部

小结：

闭包：

1
2
3

1. 首先得是个嵌套函数
2. 内部函数用了外部函数的变量
3. return了 内部函数

闭包掌握了一个技能

1
2
3

给函数传参
1. 直接传参
2. 利用闭包传参 间接传参

装饰器

主要涉及的就是
1.闭包
2. 函数对象把函数作为参数来传递
用处 ——–> 在不修改我们的源码和调用方式的情况下，给函数添加功能


   def test():
   	 print("test 函数")
   	 print("Python函数进阶")  # 添加函数功能
   test()

"""
test 函数
Python函数进阶
"""


# 使用装饰器的方法  func1 就是装饰器

def func1(f):  #f 相当于test
    def func2():
        f()  # 相当于test()传到了这里  也就是调用了test
        # 添加新功能
        print("Python函数进阶")
    return func2()

@func1   # 使用装饰器的第二种方法
def test():
    print("test 函数")

#  使用装饰器的第一种方法    即 以下两行相当于@func1 
# rest = func1(test)
# rest()

'''
test 函数
Python函数进阶
'''

直接 >> 追女孩
间接 >> 你能做我的女朋友

直接修改 ——> 整容
间接修改 ——> 化妆

开发潜规则：
代码扩展 –>> 开放 —>可添加功能
源码修改 –>> 封闭 —> 不能够修改源码

为什么不能够修改源码？？？
如果修改了之后，改出了一堆bug很麻烦
要拓展功能，但是要通过别的函数来实现 “ 间接修改”

函数的使用分为两个阶段：
1.定义(装饰器)函数
2.调用(装饰器)函数

装饰器：在’不修改函数源码’ ,和 ‘函数调用方式的情况‘ 给函数添加功能

普通：写好了一个装饰器，要给函数添加功能

函数 = 装饰器(函数) # rest = func1(test) 给函数增加新功能，并且重新赋值

函数() # rest() 现在再调用函数就是已经增加了新功能

简便语法：直接给函数添加新功能，这样调用时，就是默认把装饰器上的功能加上
语法糖
@装饰器名 ——> @func1
def 函数名()——>def test()

demo：


def laoganm():  # 老干妈炒饭
    print("我是老干妈炒饭")


def dalumian(*args,**kwargs):  # 打卤面        有参数需求
    print("我是打卤面")


# 装饰器 必须是闭包
def jia_liao(f):           # 加料  f相当于我们要加的食材
    def jia_zhuti(*args, **kwargs):     # 当定义的函数有参数需求时 需要添加到内部函数  并且把拿到的参数返回出去
        rest = f(*args, **kwargs)               # 先把食材拿过来
        
        
        print(args,"------args")            # 功能1
        print(kwargs,"=====kwargs")		    # 功能2
        print("添加猪蹄 ")  # 加个 猪蹄		 # 功能3
        
        return rest       # 返回参数

    return jia_zhuti       # 原来的食材 + 猪蹄


# dalumian = jia_liao(dalumian)  # 打卤面 去给老板 加料
# dalumian(12,name="yanmomo")

"""
我是打卤面
(12,) ------args
{'name': 'yanmomo'} =====kwargs
添加猪蹄 

"""
# laoganm = jia_liao(laoganm)  # 老干妈炒饭 去给老板 加料
# laoganm()
"""
我是老干妈炒饭
() ------args
{} =====kwargs
添加猪蹄 
"""



# # 语法糖
@jia_liao  #相当于 rest = jia_liao(chaomiao)   rest()
def chaomian(name):
    print("我是啥",name)
    return name
rest = chaomian("ke")
print(rest)
"""
我是啥 ke
('ke',) ------args
{} =====kwargs
添加猪蹄 
ke

"""




# 完整版装饰器
# 具体情况 具体分析
def warpper(f):
    def inter(*args,**kwargs):
        # 逻辑判断  比如 账号是否登录
        # 新功能
        return f(*args,**kwargs)
    #    rest= return f(*args,**kwargs)
      # 这两种情况都可以返回 返回值 
   # return test	
    return inter

总结:

什么情况下会用到装饰器: 一个功能很多时候都会使用,就可以把这个功能写成装饰器,给需要的函数添加
比如: 认证登录,输入验证码相当于生活中的化妆 –> 在不改变你脸的情况下让你更好看在不修改源代码的情况下,给函数添加功能

作业

请实现一个装饰器，把函数的返回值+100然后返回

请实现一个装饰器，通过一次调用使函数重复执行5次


# 请实现一个装饰器，把函数的返回值+100然后返回
def outer(f):
    def inner(*args,**kwargs):
        rest = f(*args,**kwargs)
        rest = rest+100
        print(rest,"这里是实现的功能")
        return rest #120

    return inner

@outer
def test(num):

    print("test")
    return int(num)
m=test(20)
print(m)



def fun(f):
    def fun1(*args,**kwargs):
        if type(args[0]) == int and type(args[1]) == int:
            print(args,kwargs)
            num = f(*args,**kwargs)
            return num+100
        else:
            print("传入数据错误！")
    return fun1

@fun
def add(a,b):
    print("我是add函数")
    return a+b

num = add(1200,10)
print(num)
print("-----------")


# 请实现一个装饰器，通过一次调用使函数重复执行5次

def wapper(f):
    def innner(*args,**kwargs):
        count=0
        while count<5:
            print("f的函数名")
            print("f的函数的文档字符串",)
            f(*args,**kwargs)
            count+=1
            print(count,"\n"*3)

        for i in range(5):
            print("f的函数名")
            print("f的函数的文档字符串", )
            f(*args, **kwargs)
            count += 1
            print(count, "\n" * 3)

    return innner

@wapper
def func():
    """
    add是计算两个变量的和
    :return:
    """
func()

巩固拓展博客:

装饰器拓展 https://www.cnblogs.com/huxi/archive/2011/03/01/1967600.html

[装饰器拓展2](https://www.cnblogs.com/Jerry-Chou/archive/2012/05/23/python-decorator-explain.html https://www.cnblogs.com/cotyb/p/5243252.html) https://www.cnblogs.com/Jerry-Chou/archive/2012/05/23/python-decorator-explain.html https://www.cnblogs.com/cotyb/p/5243252.html

装饰器拓展3 https://www.cnblogs.com/rhcad/archive/2011/12/21/2295507.html

记得预习生成器 &迭代器

c语言中文网

菜鸟教程

二.递归&生成器&迭代器

上节回顾

闭包:
    1. 在一个嵌套函数中,
    2. 内层函数用到了外层函数的数据!!!
    3. 返回的是内层函数对象  
        --> 间接修改数据
 	
    装饰器: 在不改变源代码和调用方式的前提下给函数添加功能
 
    装饰器的语法糖 -->在要添加功能的函数上面写上
    @装饰器名  --> 就可以实现添加功能
    装饰器 --> wrapper
  
    @wrapper
    def fun():
        
        
        
def my_decorator(func):          #  add
    def wrapper(*args, **kwargs): #  接收传递给 add 的实参
        """
        decorator
        """
        return func(*args, **kwargs)  # add(*args, **kwargs)
    return wrapper    # 返回函数对象

@my_decorator
def add(a,b):
    """
    add 是个计算两个变量的和
    """
    return a+b

print(add.__name__, add.__doc__)

递归

递归也是一种函数，在这个函数中不断的重复调用自己完成一些操作，但是这个调用它可以结束，

也就是，在一个函数中，自己调用了自己那就是递归

递归写起来方便，但是性能不是很好，对资源消耗很大，在正式开发，算法比赛不推荐的

def test(num):
    if num == 1:  # 作为结束 条件
        return 1
    else:
        return num * test(num -1)  # 5 * 4 * 3 * 2 * 1

print(test(5))   # 120

迭代器

迭代，更新换代？

这是指对数据的一些操作，更新，输出，升级

比如软件的版本1，版本2，版本3

华为手机 p30 p40 p50 等等

迭代器

iter —–> 可迭代对象能够被循环的对象就是可迭代对象（面试题）

但是可迭代对象并不一定是被循环的对象

iter     ----->  可迭代对象   能够被循环的对象就是可迭代对象（面试题）
iterator >>  迭代器   

迭代：操作一堆数据，数据之间都是有关联的


可迭代对象：
	内置了__iter__方法的数据，都属于可迭代对象
    	a = "123"
        b = [1,2,3]
        c = (1, 2, 3)
        d = {1, 2, 3}
        e = 123    # int没有可迭代对象
        a.__iter__()
        b.__iter__()
        c.__iter__()
        d.__iter__()


 迭代器对象:
        可迭代对象在调用了__iter__方法之后，就返回一个迭代器对象
        但凡内置有__iter__方法,__next__的都称之为迭代器对象
        换言之，可迭代对象就是可以转换成迭代器的对象
        # 格式
        变量名 = 可迭代对象.__iter__()
        变量名 = iter(可迭代对象)
        来得到可迭代对象
        

   	    # next(迭代器)   返回迭代器对象的下一个的结果   


# for  循环的实现原理
# 1.  自动调用 iter() 转变成迭代器对象
# 2.  再调用迭代器下面的next()  取到下一个  赋值  给变量x
# 3.  循环
# 4.  没有值了  StopIteration 异常  自动停了

a = "123"
rest = a.__iter__()  # 迭代器对象 rest
rest1 = iter(a)      # 迭代器对象 rest
print(next(rest))  # 1
print(next(rest))  # 2
print(next(rest))  # 3
print(next(rest))  # 报错 StopIteration

for x in rest1:
    print(x)
"""
1
2
3
"""


 


d = {'a': 1, 'b': 2}  # 可迭代的对象
d_iter = iter(d)      # 迭代器对象
count = 0
while count < len(d):
    print(next(d_iter))
    count += 1

    
for x in iter(d):
    print(x)
    
结果都是：    
"""
a
b
"""
    
总结：
	优点：
    	为序列和非序列类型提供了一种统一的迭代取值方式
    缺点：
    	它只能一直往后取，不能回头，取完就over了
         不能确认长度,在输出完之前,程序是不知道这个迭代器里面有几个数据
    一句话总结:
        把一堆的数据,进行有规律的输出/使用

生成器

本质: 自定义的迭代器(迭代器的变体)
 
    生成器的作用:
        制定一个规则,基于规则,生成一些数据
 
    有个变量,里面有1314个值,你手动声明就很麻烦
    如果变量里的数据都是有规律,那就可以写一个生成器,制定规则,来生成变量 --> 省事
 
    正常定义一个可迭代对象数据:
        a = [1,2,3,4,5]
    # 1.一般得先把数据存储进去才能使用
    # 2.生成器可以边生成边迭代使用
 
    生成器的表现形式:
        一个函数中,有yield关键字,就属于生成器
 
    def fun():
        yield 1314
 
    如果函数内,包含了yield,在调用时,是不会运行里面的代码.并且这个函数的返回值,就是生成器对象
 
    函数中代码遇到yield后,并不是结束,而是进入'暂停状态' --> 如果以后遇到yield的时候,来开启.
    
    return 是结束
	yield  是暂停
    两者都是返回数据 
    
    
    # 生成器 也是迭代器
def fun():
    print("》》》》》1234")
    num = 10
    num1 = yield 1314  # 函数遇到 yield 就暂停了
   # input("等待")
    for i in range(5):
        print(11111)
        print(num) # 10

rest33 = fun()
# print(rest33)  # <generator object fun at 0x000002C49BF6E5C8>

# 生成器 是 迭代器的变异体

rest333 = next(rest33)
print(rest333, "yield 返回的值")
rest2 = next(rest33)
print(rest2, "yield 返回值  rest2")

for rest in rest33:
    print(rest, "yield 返回的值")



def test1():
    n = 1
    yield n
    n +=1
    yield n
    n +=1
    yield n
    n +=1

for i in test1():
    print(i)
    input("等待")

三元表达式

#   三元表达式是python为我们提供的一种简化代码的解决方案
def my_max(x,y):
    if x > y:
        return x
    else:
        return y
res = my_max(1,2)


x = 1
y = 2
res = x if x > y else y # 三元表达式
如果if后面的条件成立  则 返回前面的  否则 返回后面的

列表表达式

列表生成式
    列表生成式是python为我们提供的一种简化代码的解决方案，用来快速生成列表
egg_list=[]
for i in range(10):
    if i % 2 == 0:
        egg_list.append('鸡蛋%s' %i)
print(egg_list)   # ['鸡蛋0', '鸡蛋2', '鸡蛋4', '鸡蛋6', '鸡蛋8']


# 列表生成式  节省内存 ，提高 代码效率
egg_list = ['鸡蛋%s' % i for i in range(10) if i%2 == 0]

print(egg_list)  # ['鸡蛋0', '鸡蛋2', '鸡蛋4', '鸡蛋6', '鸡蛋8']

生成器表达式

生成器表达式
    创建一个生成器对象有两种方式，一种是调用带yield关键字的函数，
    另一种就是生成器表达式，与列表生成式的语法格式相同，只需要将[]换成()


# 生成器表达式
egg_list = ('鸡蛋%s' % i for i in range(10) if i % 2 == 0)
print(egg_list)         # 得到生成器对象  <generator object <genexpr> at 0x0000015AC2A52CC8>
print(list(egg_list))  #  ['鸡蛋0', '鸡蛋2', '鸡蛋4', '鸡蛋6', '鸡蛋8']

作业

# 编写一个生成器，将一个二维的列表elist 转化为一维的列表。
# elist = [[1,2,3], [4,5,6],[7,8,9]]  # 二维列表  二维矩阵
# [123,1,2,3,4,5,] # 一维 列表

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

def fun1():
    for i in elist:
        print(i,"第一层循环")
        for x in i:
            print(x,"第二层循环")
            yield x   # 暂停  且返回数据

# 普通方法
# for x in fun1():  # 调用fun1  得到生成器
#     new_list .append(x)
#
# print("新的列表", new_list)

#第二种  列表表达式
print([item for item in fun1()])  # 列表表达式
"""
[1, 2, 3] 第一层循环
1 第二层循环
2 第二层循环
3 第二层循环
[4, 5, 6] 第一层循环
4 第二层循环
5 第二层循环
6 第二层循环
[7, 8, 9] 第一层循环
7 第二层循环
8 第二层循环
9 第二层循环
新的列表 [1, 2, 3, 4, 5, 6, 7, 8, 9]

"""

# 方法二
elist = [[1,2,3],[4,5,6],[7,8,9]]
print(list(x for i in elist for x in i))  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

复习博客

http://c.biancheng.net/view/5419.html –> 迭代器
http://c.biancheng.net/view/2393.html –> 生成器
http://c.biancheng.net/view/2270.html –> 装饰器
https://blog.csdn.net/zhengyajun_email/article/details/86715467 –> 装饰器嵌套

提前预习文件操作

三.文件处理与内存管理

上节回顾

递归
	在一个函数里调用了自己，但是 有截止点 

迭代器
	可迭代对象  可以被循环就是可迭代对象， （字符串，列表，元组 ）
    		  内置了__iter__()
    内置了__iter__(), __next__() 那就是迭代器
    # 获取迭代器
    变量 = iter(可迭代对象)
    变量 = 变量.__iter__()
    
    # 我们通过什么获取到迭代器数据？
    for 循环
    next()    # next 多次调用 程序 出现 报错 StopIteration 异常  自动停了
    
生成器
	本质是一个自定义的迭代器
    按照我们的规则自动在边使用，边生成数据
    
    # 好处
    Python的内存 占用不会那么大  也就是节省资源
    
    # 
    def fun1():
        yield 数据
    	
    yield   暂停   （这种函数还活着，）
    return  结束   （这种函数已经 死亡）
    yield 和 return 共同点 返回数据
    
列表表达式
rest1 = [i for i in range(12)]

三元表达式
a,b =1,2
c = a if a < b else b

生成器表达式
rest3 = (i for i in range(12))

高阶函数 map reduce filter

# 情景一  对列表中的数据进行平方处理

li1 = [1, 2, 3, 4, 5]
def data_op(arr):
    new_li = []
    for i in arr:
        new_li.append(i ** 2)
    return new_li

print(data_op(li1))  # [1, 4, 9, 16, 25]

# 方法二map
li2 = [1, 2, 3, 4, 5]
def my_square(x):
    return x**2

ew = map(my_square,li2)
print(ew)  # <map object at 0x000001D36241D188>
print(list(ew))  # [1, 4, 9, 16, 25]


# 方法三  升级   匿名函数 lambda
li3 = [1, 2, 3, 4, 5]
ew = map(lambda x: x**2, li3)
 #map函数把li3这个参数放入到x中进行操作
print(ew)  # <map object at 0x00000230EDC9F2E0>
print(list(ew)) # [1, 4, 9, 16, 25]


reduce 函数  有两个参数  参数1是函数，参数2 是 序列  参数3 是 默认值
# 作用：将序列中每一个数据 放入函数中进行 操作  但是结果是累积计算的

from functools import reduce  # reduce需要导包
#一
def my_square(x, y):  # 这儿只能两个参数
    print(f"x={x},  y={y}")
    return x + y

li = [1, 2, 3, 4, 5]
ew = reduce(my_square,li)      # 1 有函数， 有序列 ，
print(ew)  # 没有默认值时默认把列表中第一个值给x,
"""
x=1,  y=2
x=3,  y=3
x=6,  y=4
x=10,  y=5
15
"""

#二
ew1 = reduce(lambda x,y: x+y ,li, 100) # 1 有函数， 有序列 ，有默认值
print(ew1)  # 有默认值时默认值返回给了x
"""
x=1,  y=2
x=3,  y=3
x=6,  y=4
x=10,  y=5
15
115
"""



# filter 函数  有两个参数  参数1是函数，参数2 是序列  
# 作用：将序列中每一个数据 放入函数中进行 过滤 判断 根据表达式 返回的bool值 

li = [1, 2, 3, 4, 5]
rest = filter(lambda x: x>3, li)  # x>3的返回  x<3的不要了
print(rest)  # <filter object at 0x00000227EE3CD048>
print(list(rest))  # [4, 5]

print(1 > 3) # False

与运行程序相关的三大核心硬件

我们编写的程序 一定要运行在计算机硬件之上，而站在硬件的角度，与运行程序有关的三大核心

cpu，内存，硬盘（硬盘就是c，d，f，g，）

程序最先是存放于硬盘，把代码加载到内存中，然后cpu从内存中读取指令运行
硬盘  >> 内存 >> cpu

文件操作

用Python来操作文件（doc, bat, exe, py, mp3, jpg, html）

一般都是操作文本 居多
txt，word，Excel，csv，json

龙族.txt

文件操作的三点
- 打开文件
- 操作数据
- 关闭文件

操作模式:
w: write
写入数据, 如果文件里面有数据, 会被覆盖   如果文件不存在，它会自动创建
a: append
追加数据, 如果文件里有数据, 会追加在后面  如果文件不存在，它会自动创建
r: read
读取数据


数据类型:

b: byte
以字节码的方式来操作数据 --> 目前还用不上, 以后讲爬虫, 网络编程的时候再细讲
t: text
文档, 文件操作默认就是文档模式

wb: 以字节码的方式写入数据
rb: 以字节码的方式读取数据


基本语法:
打开文件:(r取消转义字符)
open(文件路径\文件名, 操作模式, 字符编码)  # 如果没写文件路径,默认在当前文件夹

f = open('demo/xiaobao.txt', 'w', encoding='utf-8')

写入文件:
f = open('demo/xiaobao.txt', 'w', encoding='utf-8')  # 打开文件
f.write('人生苦短，我用Python')  # 操作文件
f.close()  # 关闭文件,如果不关闭会造成内存泄露.

查看文件:
f = open('longZu.txt', 'r', encoding='utf-8')  #
print(f.read())
f.close()

f = open('lala.txt', 'r', encoding='utf-8')  #
# print(f.read())
# print(f.readlines()) # 以列表形式读取所有行
# ['Python 我爱你222222222222 \n', 'Python 我爱你222222222222 \n', 'Python 我爱你222222222222 \n', 'Python 我爱你222222222222 \n', 'Python 我爱你222222222222 \n']
print(f.readline(4)) # Pyth 写数字为x,则读取x个字符 如果输入的数字超过文本字符，则只输出一行
print(f.readline(1000000)) # Python 我爱你222222222222
f.close()


追加文件:
f = open('longZu.txt', 'a', encoding='utf-8')  #
f.write('小怪兽 》》》》》')
f.close()



为了避免忘记加close导致的翻车, 有个更推荐的写法.上下文管理器
with open
    with open(文件路径\文件名, 操作模式, 字符编码) as 别名:

with open('demo/xiaobao.txt', 'w', encoding='utf-8') as f:
    f.write('但愿人长久千里共婵娟')

with open会自动帮我们关闭文件操作
    as --> 取个别名, 小名

print(f.writable())  # 判断该文件是否可写
print(f.readable())  # 判断该文件是否可读
print(f.closed)  # 判断该文件是否已经关闭


# with open  上下文管理器
#           路径 + 文件名        a 追加   encoding='utf-8'
with open(r'lala.txt', 'r+', encoding='utf-8') as f:
    # a+  可以进行追加和其他的操作 并且把指针放到了最后面
    # r+  可以进行读和其他的操作   并且把指针放到了最前面  但是写完之后指针又回到了最后面
    # f.seek(0)  # 操作文件指针 可以将指针移动到指定的的位置
    rest = f.read()
    print(rest)
    # f.append(123123123213123123123122312321312)
    f.write('\n但愿人长久千里共婵娟')
    print("====")
    # rest = f.readlines()
    # print(rest)  # []

    f.seek(0)
    rest = f.readlines()
    print(rest)  # 非空

绝对路径和相对路径

``文件路径 = 文件存储的位置
``绝对路径 = 完整的路径,可以从头开始找到文件 -- 从电脑的盘符开发
``相对路径 = 相对简短的路径,默认从当前文件夹出发,可以方便使用
1.当前文件夹 2.内1层文件夹 3.外1层文件夹  的数据

1 2	``绝对路径: 广东广州市天河区车陂大岗路2号联合社区西区1C栋2楼全层 ``相对路径: 我家楼下

1
2
3

``计算机中的路径: 
``绝对路径: D:\software\BaiduNetdisk\api-ms-win-core-datetime-l1-1-0.dll
``相对路径: 1.jpg

拓展博客

四.模块与包

上节回顾

li = [123,343,52]
map  
# 把序列中的每一个数据放到函数中进行 操作 并且返回
# 返回的map对象
new_li = map(lambda x: x+2, li)  # 参数1 函数 参数2 序列
print(list(new_li))

reduce 
from functools import reduce
# 把序列里的数据 放到函数 进行计算 ，但是结果是累积
# 返回的是  一个累积的结果  # 参数1 函数 参数2 序列 参数3 默认值
new_li = reduce(lambda y,x: x+y, li)
print(new_li)

filter
# 
# 把序列里的数据 放到函数 进行 判断 满足 条件 返回，不满足 则不返回
# 返回的是  filter 对象
new_li = filter(lambda x: x>100, li)
print(list(new_li))

文件操作
步骤：
	1.打开文件
    2.操作数据
    3.关闭文件

    文件模式
    	r：read  读数据
        w：write 写数据
        a: append 追加  
        r+   可读可写
        w+   可读可写
        a+   可读可写
        wb   二进制方式写入数据
        rb   二进制方式读取数据
       
   # 推荐使用 上下文管理器 来操作文件
   with open("文件名字", "操作模式", encoding="utf-8") as f:
    	f.read()
        f.write()

初识模块

官方模块官网

什么是模块???
    一个python文件,就是一个模块
    模块名就是文件名. 不带.py后缀
        test.py --> 模块名是test
 
    作用是什么???
        调用其他python文件里的代码,功能.可以更灵活的实现,使用,添加各种效果
 
    变量 = 存储一个/多个数据
    函数 = 存储一句/多句代码
    模块 = 我全都要,我就是一个python文件
 
    当我们导入了一个模块后,就可以使用这个模块里的所有代码: 里面的变量,里面的函数
 
    模块分为三种:
        1.内置模块 --> python自带的,在使用之前需要进行导入工具/类似于人类随身携带的工具
            --> time random math
 
        2.第三方模块 --> 不是python自带的,是别人写好的东西,自己下载来使用/类似于超市的商品,需要先购买再使用
            pywin32  --> windows开发
            requests --> 爬虫模块,发送请求命令
            pygame   --> 做游戏
            TensorFlow --> 人工智能
 		   opencv    -->  视觉处理库
            yolo5      -->  视觉训练库
            qt         -->  图形库
            
            
        3.自定义模块:
            自己写的py文件.就属于自定义模块
     
		官方模块官网 https://pypi.org/
 
    查看导入模块的代码--> 选中模块 --> ctrl + b

pip Python包管理工具

  pip --> python自带的下载工具
  python默认下载库就是通过pip.如果py环境没装好,pip可能就使用不了 --> 修复/重装
 
  如何下载第三方模块:
      在cmd中输入以下代码
  pip install 库名
  pip install pygame -i 加速源
 
  升级pip下载器(有时pip版本太低,下不了最新的库)
  python -m pip install --upgrade pip -i https://pypi.doubanio.com/simple
# 如果下载模块没有问题， 就不需要更新
  通过代理加速,下载第三方库
  pip install 库名 --default-timeout=100 -i https://pypi.tuna.tsinghua.edu.cn/simple
  pip install pywin32 --default-timeout=100 -i https://pypi.tuna.tsinghua.edu.cn/simple
 
  卸载模块
  在cmd中输入
  pip uninstall 模块名
  pip uninstall pywin32

模块的使用

##模块的使用
    模块的使用流程:
        1.导入模块
        2.使用模块
 
    导入模块
        import 模块名
        import requests
        import test
    import 导入的意思,准备作案工具.
 
    使用模块
    import 模块名
    print(模块名.变量名) # 输出模块里的变量
    模块名.函数名()      # 调用模块里的函数
 
    import test # 导入模块test
    print(test.name) # 输出test里面的变量name
    test.fun() # 调用test里面的函数fun
 
    当模块名过长不好记,可以通过as,给它取个别名
        as : 取个别名
    import 模块名 as 别名
    import numpy as np
    
 # demo
import datetime  # 时间模块
print(datetime.datetime.now())

from datetime import datetime 
print(datetime.now())

import datetime as dt
print(dt.datetime.now())

模块进阶使用

##模块进阶使用
    模块的潜规则:
        1.命名规范
            1.如果py文件是作为启动程序,那么命名比较宽松 
            2.如果py文件是作为模块来使用,最好采取全小写+下划线
                user_login    # 用户登录模块
                user_register # 用户注册模块
                user_upload   # 用户上传模块
               
 
        2.导入规范
            不推荐一行导入多个模块
        例:import time,random,win32api # 不推荐
         
        荐:
            import time
            import random
            import win32api
 
        3.导入的顺序规范,中间空行
            1.首先导入内置模块
            2.然后导入第三方模块
            3.最后导入自定义模块
 
        例:
            import time
            import random
            import pygame
            import test
 
    python导入模块后发生的事情:
        1.运行这个模块里的所有代码,确保没有报错
        2.生成一个名称空间,这个名称空间和模块名同名.把模块里的变量名,函数名都存进去
        3.让当前的运行程序连接上名称空间.然后就可以通过  模块名.   的方式来使用模块里的数据
 
    如何导入模块的单独功能:
        一个模块有100个功能.我只想调用里面的功能.这个时候就可以把模块里的函数/变量.单独取出来,节省资源
    from 模块名 import 函数名
    from 模块名 import 变量名
 
    from test import fun # 导入来自test模块里的函数fun.
 
    优点: 避免不必要的内存资源开销.  减少代码量
    缺点: 可能会出现同名覆盖的情况
 
    有的女孩子,在家里面,一大桶水.随便抬???
    出了门,在喜欢的人面前.一瓶水都拧不开???
 
    python中有个__name__方法.它能够获取.py文件的执行模块
        如果是以程序身份执行,__name__的值为__main__
        如果是以模块身份执行,__name__的值为模块名
 
    python中通过main来判断文件是属于程序还是模块.
        1.有别的语言基础的同学,不要把python的__main__和别的语言的main搞混.性质不一样
        2.一个python文件,它的__name__为__main__那它就是作为启动程序,否则它是一个模块
        3.可以把一些非必要代码,只作为程序运行时才会使用.放到main判断
 
    if __name__ == '__main__':
        代码块 # 里面的内容只有文件是以启动程序运行时才会运行
    在pycharm中,输入main按下tab/回车就会自动生成
 
    __file__ 获取文件所在的位置
    print(__main__)
    print(__file__)

模块与包

包是模块的一种变异体,本质上也是模块的一种

模块 --> 文件
包 --> 文件夹
 
    包的概念:
        把一些功能相同的模块,放到同一个文件夹里面.进行统一的管理.文件夹里有个有个配置文件叫__init__.py
 
    包的表现形式:
        一个文件夹里面,有个叫__init__.py的文件
 
    包的创建方式:
        pycharm中 --> 右键项目文件夹 --> new --> python package
 
    包的核心作用:
        把一些功能相同/类似的模块放到同一个文件夹里进行统一管理,里面有个叫__init__.py的文件
        在导入这个包里的模块时,__init__.py的代码会自动执行
        可以利用这个机制.把__init__当成是一个配置文件/使用说明
  
    跨文件夹导入模块的操作:
        from 文件夹名 import 模块名
        from login import qq_login 
        
    # 全局导入
    from login import * 
    
    # * 匹配所有  也就是导入所有的变量，函数名，
    # 除了 _xxx 保护变量  __xxx  私有变量   我们开发人员自己 定下的规矩   

    from login import *  # python开发人员全靠自觉
    
    
    # 为了维护包的干净  防止全局导入 
    __init__.py 写入 __all__ = []
    
    # 写入允许全局导出的东西
    __all__ = ["user_login", ]

拓展博客


# 装饰器

def warpper(f)  #  warpper外层函数   f 传进来的函数 
	def iner(*args, **kwargs)  #  iner 内层函数   *args, **kwargs 是不是传递给 f 的参数
		f(*args, **kwargs)    # 调用 传进来的f函数
		
	return iner  # 返回 内层函数

五.常用模块

上节回顾

周末 —》复习 —》明天也是我们复习课

过老师的课件，把知识点梳理
根据自己的不足，在进行代码实操，拿作业看看是否现在有根会更好的解决方式

模块的本质其实就是一个Python文件
	hello.py   >>> 模块名就是hello
模块的作用就是可以帮住我们更灵活的调用一些已经写好的功能/ 变量 ，在做项目的时候可以把功能写成模块，导入即可使用

使用一个模块需要先进入导入操作:
        import 模块名
        import win32con
 
    如果一个模块名很长或不好理解,可以通过as关键字给它取个别名
        import 模块名 as 别名
        import numpy as  np
    from 模块 import 具体xxx as 
    from 模块  import *    # 不建议 全局导入
    	 局限性
        	__all__ = ["模块名", "变量名"] # 允许全局导入
            _下划线
            _变量名  保护变量
            __变量名  私有变量
            很容易重名，冲突
 	
    
    模块分为三类:
        1.内置模块 --> python自带的  
        2.第三方模块 --> 不是py自带的,是别人写好的python模块,使用之前需要下载.
        3.自定义模块 --> 自己写的python文件
 
    当import导入一个模块后,发生:
        1.运行这个模块的所有代码,确保没有报错
        2.生成一个名称空间,该名称空间与模块名同名  
        3.在当前运行程序里,连接上名称空间.然后就可以使用模块里的数据
 
    __main__作用:确保代码是以程序身份来执行的
    python内置了一个方法,叫__name__:
        如果py文件是以程序身份来运行,__name__为__main__       
        如果py文件是以模块身份来运行,__name__为模块名
    if __name__ == "__main__":
        # 测试的代码
        
    包 --> 模块的一种变体,文件夹
        包的表现形式为一个文件夹,里面还有一个名为__init__.py 的文件
        特性: 当导入这个文件夹里的模块时,__init__会自动执行
        所以可以基于这个特性,把__init__当成是一个说明文档或配置文件
    把一些功能统一的模块放到一个文件夹里进行管理
 
    跨文件夹导模块的方式:
        from 文件夹名 import 模块名
        from 文件夹名.文件夹名 import 模块名
 
        from utils import test

time – 时间模块

# 时间模块的学习
import time 

# 1.time.time() 获取时间戳， 1970.1.1 距离现在过去了多少秒
# print(time.time())

# 2.time.sleep(s) 让程序休眠s秒
# time.sleep(2)


# def fun1():
# 	print("程序开始运行了 ")
# 	# 这里埋了 bug , 用户充钱了 就把睡眠注释了
# 	# time.sleep(3)
# 	print('牛逼的程序运行完了,但是有点慢.说不定你充点钱,可以变快哦')
#
#     # 以后做项目的时候,经常会有要求做项目优化,提升运行速度,减少占用内存
#     # 有人写完程序,就写个sleep让程序延时执行.伪装成这个程序运行没问题但是慢
#     # 以此来谈条件,价钱. 或者老板让你优化,直接修改sleep就可以了
# fun1()


# 3.格式化输出时间 time.strftime()

# from datetime import datetime
#
# print(datetime.strptime(r"2011-1-12", "%Y-%m-%d"))
#
# print(time.strftime('%Y - %m - %d')) # 获取年 月 日
# print(time.strftime('%Y - %m - %d %X')) #获取年月日 时分秒
# print(time.strftime('%x  %X'))
#
# 4.以结构化的方式获取当前时间,后续可以通过re正则表达式取出想要的数据
# print(time.localtime())

random – 随机数模块

import random

# 1. random.random() 随机生成 0-1之间的随机数
# rest = random.random()
# print(rest)

#
# 2.random.randint(起点,终点) 根据指定的范围生成 随机整数
# rest1 = random.randint(1,10)
# print(rest1)
#
# 3.random.uniform(起点,终点) 根据指定的范围生成 随机小数
# c = random.uniform(13,14)
# print(c)
#
# random.choice(列表/元组)  随机生成容器中的元素
# rest2 = random.choice(["剪刀","石头","布"])
# print(rest2)

#
 # random.shuffle(列表)  打乱一个列表里的排序
# li = ["同学们","大家好",1314,520,True]
# random.shuffle(li)
# print(li)
#

# def vif_code(num):
#     """
#     随机生成验证码
#     :param num:
#     :return:
#     """
#     code = ''
#     for i in range(num):
#         code += chr(random.randint(97,122))  # 随机生成 a-z 的字符
#     return code
#
# print(vif_code(4))
#
# print(chr(97))   #  "a"
# print(ord("a"))  #  97

sys – 系统模块


# 系统模块   ---> 目前只需要了解就好
import sys

# 1. sys.path 获取Python的环境变量： 你的项目文件夹位置 + Python环境位置
# print(sys.path)

# 2. sys.argv 获取当前文件所在的位置
# print(sys.argv)
#
# # 3. sys.version  获取当前Python的版本信息
# print(sys.version)
#
# # 4. sys.platform 获取当前操作系统的架构
# print(sys.platform)

OS – 操作系统模块

# 操作系统模块 os
import os

# os.getcwd() 获取当前文件所在的文件夹位置
# print(os.getcwd())  E:\zhongZhiTong\zzt课件\16常用模块
# print(__file__)  # E:/zhongZhiTong/zzt课件/16常用模块/os_demo.py

# os.mkdir('文件夹名') 新建文件夹,
# os.mkdir('test12/test')

# os.rmdir('文件夹名') 删除文件夹,里面如果有文件,不能删除
# os.rmdir('test12/test')

# os.rename(原名,新名) 重命名
# os.rename('a.txt','longzu.txt')

# os.remove('文件名') 删除文件
# os.remove('longzu.txt')

# 切换程序的执行位置
# os.chdir('a')  # os.chdir(相对路径/绝对路径) 切换程序的执行位置
# os.mkdir('test')  # os.mkdir() 创建文件夹

# os.listdir()  输出当前文件夹里的所有文件名
# print(os.listdir())

# 获取上一级的目录

# print(os.path.dirname(__file__))  # os.getcwd()
# print(os.path.dirname(os.path.dirname(__file__)))  # E:/zhongZhiTong/zzt课件
#
#
#
# os.rmdir("a/test")
# os.rmdir("a")
# print(os.path.exists("a.txt")) #  存在返回True， 不存在返回False

# os.path.join() # 拼接路径

# rest = os.path.join("a", "test", "b")
# print(rest)


# if os.path.exists(rest):  # a\test\b
#     # 如果存在 进行操作
#     print("存在此路径了,不需要创建")
# else:
#     # os.mkdir()       # 这个方法 只能创建一层路径
#     os.makedirs(rest)  # 这个方法可以创建多层文件夹
#     print(f"创建此路径{rest}")

# os.system(cmd指令) 运行cmd指令
# os.system('shutdown -s -t 10086')
# os.system('shutdown -a')

# for i in range(3):
#     os.system('start cmd')

json – 序列化模块

"""
json模块
json是一种文件的存储格式,主要作用就是用来存数据
它的优点是可以被大部分编程语言识别,操作. 并保留原来的类型
 
json的优点 --> 跨语言/跨平台 --> 和多个编程语言,操作系统都有较好的兼容性
 
序列化/反序列:
    序列数据 --> 机器码(计算机最底层的0和1) --> 文件在传输/存储的时候是用的序列数据.
    反序列数据 --> 程序员写的代码 --> 文件在编辑的时候,使用反序列数据
"""
import json

# 这样写会丢失原有的数据类型.最后都是str字符串
# a = [1,2,3]
# b = {'姓名':'韦小宝','爱好':'游戏'}
# #
# with open('a.txt','w',encoding='utf-8') as f:
#     f.write(str(a))
#     f.write(str(b))
#
# 序列号数据,把数据变成机器码

# with open("a.txt", "r", encoding="utf-8") as f:
#     rest = f.read()
#     print(rest)
#     print(type(rest))

names = {'姓名': '韦小宝', '爱好': '游戏'}
#
# # json.dumps(数据) 把数据反序列化
# json_data = json.dumps(names)
# print(json_data)
# #
# # # 序列化,读取数据  json.loads(反序列化数据)
# data = json.loads(json_data)
# print(data)
# print(data.keys())

# 将反序列化数据写入文件
# with open('a.json','w',encoding='utf-8') as f:
#     json.dump(names,f) #写入数据


# with open('a.json','r',encoding='utf-8') as f:
#     # print(f)
#     stu_dict = json.load(f)
#     print(stu_dict.keys())
#     print(type(stu_dict))
#
# json的本质 --> 在不丢失数据类型特性的情况下保存数据,以及操作使用数据
# 就不会让所有的数据都变成str

hashlib – 哈希模块

'''
哈希模块 hash
哈希是一种规则,可以接受一个值,来生成一个哈希数据. 作用主要用来加密数据
 
    就像是算命一样,你跟算命先生说一句话.他给说一堆
 
    哈希的本质是算法,规则.用的比较多的也是体现在数据加密上
 
    特点:
        1.传入的内容是一样的,hash的值也是一样的
           你去算命和别人去算命,说得好一样.得到的结果也一样
        2.hash值正常来说,破解难度较大.
          算命的过程比较玄学,很难理解
        3.不管传的数据或文件有多少,多大.最后得到的哈希值长度都是32位
          不管你和算命先生说什么,最后他只解答32个字
 
    注册登录账号的原理流程:
        注册: 1.输入密码 2.加盐+哈希加密 3.得到加密值 4.保存
        登录: 1.输入密码 2.加盐+哈希加密 3.得到加密值 4.匹配

    加油: 在要生成的哈希值的基础上.添加一串指令
        原密码 --> tstxtdwsd --> + a123456
        tstxtdwsda123456 --> 拿他去加密   为什么要这么做??? 安全性
 
    md5 = md5是目前一个比较主流的加密方式.用hash5来基于md5算法进行数据加密
 
    很多所谓的wifi破解 暴力破解
    在网上收集一个常见wifi密码合集. 用个模块,尝试链接wifi
    把密码合集里的 ,密码一个个来试一个个来撞
 
    hash代码不需要各位马上理解.知道有这个东西即可
'''

# import hashlib
#
# # # 通过md5加密生成一个哈希对象. a就是一个哈希的对象
# a = hashlib.md5('大家很棒'.encode())
# print(a) # 输出a的内存地址
# print(type(a))
#
# # # # 把哈希值赋值给b
# b = a.hexdigest() # 7a7c88b1c4731447959b8bdecf4ecdcb
# print(b)
# print(len(b))

re模块

资料


# 资料 https://www.cnblogs.com/tina-python/p/5508402.html

import re
# re模块  只针对 字符串
# rest = int(input("输入数字"))  #  python
#

# 
# - compile：编译正则表达式
# - findall：查找所有满足条件的

# print(re.findall(r'\d+','one1two2three3four4'))
# ['1', '2', '3', '4']
# print(r"\n123")

# kk = re.compile(r'\d+')
# print(re.findall(kk,"one123"))
# # #['123']
# # print(re.findall(r'\d+',"one123"))


# - match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None

# content = 'Hello 123 4567 god is python'
# result = re.match(r'Hello\s\d\d\d\s\d{4}\s\w{3}.*python$',content)
# print(result)

# \s匹配任意的空白字符的，\d可以匹配任意的数字的
# 后面有4567，写4个\d太麻烦了，\d{4}
# \w匹配字母或者下划线
# 后面一长串字符不想写了。直接用.来全部代替,匹配任意字符
# * 匹配0个或多个表达式
# 也就是.*可以匹配任意的字符除了换行符
# 用python$制定正则表达式的结尾


# print(result.group(0),">>>>>>>>>>>")
# print(len(content))

# shift + 4
# - search，浏览整个字符串去匹配第一个，未匹配成功返回None
# content = 'Hello 123 4567 god is python'
# result = re.search(r'\d{4}\s\w{3}.*python$',content)
#
# print(result.group())
# print(len(content))

# - sub：根据规则替换其他字符串
# import re
# text = "Python is a good Python website"
# print(re.sub(r'\s+', '-', text))  # \s 匹配 空格 换行符， 回车符
# #
# print("replace>>>>>>>")
# print(text.replace(" ","-"))

# # - split：根据规则分割字符串
# text = "Python is a good Python website"
# print(re.split(r'a', text))
# #
# print("字符串方法 split")
# print(text.split('a'))

pathlib模块

from pathlib import Path  # Python3.7 之后推荐的，他比os模块更好
#
# # 获取当前工作目录
# print(Path.cwd())
#
# # 获取上一级目录  os.path.dirname()
# print(Path(r"D:\17938\Documents\zzt课件\16常用模块\a.json").parent)
#
# # 如果你只想得到字符串表示，不想要 WindowsPath 对象，可以用 str() 转化：
# print(str(Path.cwd()))
# #
# # # 获取当前文件路径
# print(Path(__file__).resolve())  # 绝对路径
# #
# # # 获取绝对路径
# print(Path("a.txt").resolve())
#
#
# 获取文件属性比如文件大小，创建时间，修改时间等等。
# file = Path('a.json')
# print(file.stat())
# print(file.stat().st_size)
# print(file.stat().st_atime)
# print(file.stat().st_ctime)
# print(file.stat().st_mtime)

# # 是否为文件
# print(Path("a.json").is_file())  # True
#
# # 是否为文件夹
# print(Path("demo.txt").is_dir())  # False
# #
# # # 判断是否存在
# print(Path("demo.txt").exists())
# #
# #
# # # 删除文件夹
# print(Path(r"a\test").rmdir())  # None
#
# # 删除文件 path.unlink, 危险操作。
# # Path(r'a.json').unlink()
# print()


# p

拓展分享

MVC开发模式 --> 开发时的一种设计理念
		Model --> 模块层 --> 主要处理数据相关的东西(数据库,json)
		View --> 视图层 --> 主要处理用户体验,给用户看的东西
		Controller --> 控制器层 --> 主要处理后台功能.实现各种功能
	以前开发一个项目的时候并没有具体的分工,导致有的时候就很乱,出现了bug各种甩锅.所以有前辈总结了MVC开发模式
	就是在开发项目时分为M,V,C三层.每层都有自己的任务,互有联系,但互不干涉. 开发人员只需要专注好自己负责的部分就好
	出现了问题,也更好找到问题所在.


Django web框架 的开发模式也是 MVT  也是借鉴了MVC设计的
	model  >>>> 模型层  主要处理数据相关的东西 (数据库)
	view   >>>> 视图层  主要处理后台功能，实现各种功能
	template  >>>>>  模板层   主要是处理用户体验，给用户看的东西
	

这次做项目的时候. 用的知识点都是以前学过的
但是这次的开发标准正式
	区分好几个文件夹.每个文件夹有不同的功能
	文件夹里的文件名,变量名,函数名都会更加讲究规范


留一道题,你们留给我的 --> 你们可以把学习过程中出现的一些问题,疑虑都留言发给我. 我看到会尽我所能的解答

python基础3

一.函数进阶 闭包&装饰器

闭包函数

装饰器

总结:

作业

巩固拓展博客:

二.递归&生成器&迭代器

上节回顾

递归

迭代器

生成器

三元表达式

列表表达式

生成器表达式

作业

复习博客

三.文件处理与内存管理

上节回顾

高阶函数 map reduce filter

与运行程序相关的三大核心硬件

文件操作

绝对路径和相对路径

拓展博客

四.模块与包

上节回顾

初识模块

pip Python包管理工具

模块的使用

模块进阶使用

模块与包

拓展博客

五.常用模块

上节回顾

time – 时间模块

random – 随机数模块

sys – 系统模块

OS – 操作系统模块

json – 序列化模块

hashlib – 哈希模块

re模块

pathlib模块

拓展分享

一.函数进阶闭包&装饰器