【python】零基础从入门到精通(六）

admin管理员组

文章数量:1530048

day13-文件操作与迭代器生成器

知识回顾

闭包:在一个嵌套函数中,用内层函数修改/操作外层函数的数据
装饰器:给一个函数间接的,不修改源代码的前提下增加功能
    
装饰器:
    1.接受的参数是一个函数--要加功能的函数
    2.返回出去的也是一个函数-->装饰器的内层函数
    3.装饰器的内层函数做了什么:1.调用传进来的函数,确保原来的功能可以使用 2.添加新的功能 此时内层函数==原函数+功能
    4.用此时的内层函数给原函数赋值,就是做到了没有修改源代码,并添加了功能
def talk(a):
    def talk1(*args,**kwargs):
        a(*args,**kwargs)
        print('我是学生')
        print('我已经学这么多了了,我觉得我很棒')
    return talk1

@talk
def fun():
    print('我是相公')

fun()
@talk
def fun1(age):
    print(f'我是陌上,我今年{age}岁了')

fun1(18)
@talk
def fun2(age):
    print(f'我是精神小伙,我今年{age}岁了')

fun2(18)

初识迭代器(iter)

迭代:一代一代的更新

迭代的特点:每一次迭代得到的结果都是下一次迭代的初始值,比如python版本,手机系统

可迭代对象:字符串,列表,元组,集合,字典

可迭代对象的表现形式为:内置了iter方法的数据 ,都属于可迭代对象

a='1234' #这只是一个元素
a1='1','2','3'
b=[1,2,3]
c=(1,2,3)
d={1,2,3}
y={'name':'陌上'}
v=123
print(a1.__iter__())
print(b.__iter__())
print(c.__iter__())
print(d.__iter__())
print(y.__iter__())
# print(v.__iter___()) #pycharm会给你补全这个方法 就是一个可迭代对象 硬打就不是

可迭代对象转变成迭代器

声明迭代器:
    语法1:
        变量名=可迭代对象.__iter__()
    语法2:
        变量名=iter(可迭代对象)
        
变为迭代器后,就可以用next方法把里面的数据一个个取出来使用

迭代器的表现形式为:
    内置了__next__方法的数据就是迭代器
    
next方法是对迭代器进行取值:
    #语法一
    迭代器名称.__next__()
    
    #语法二:
    next(迭代器名称)
    
num=[1,2,3,4]
res=num.__iter__() # 也可以这样写iter(num)
print(res.__next__()) #也可以这样写next(res)
print(res.__next__())
print(res.__next__())
print(res.__next__())
# print(res.__next__()) #报错 超出取值范围

for 循环的原理,也就是把数据转成一个迭代器,然后把里面的数据一个个的取出来使用

初识生成器(yield)

生成器:可以理解为自定义迭代器,当一个函数内有yield这个关键字的话,那么这个函数就是生成器

生成器的返回的是迭代数据,需要使用迭代取值的方式获取,数据生成是边生成边迭代

yield–这个可以返回数据,但是返回之后不会停止函数的执行而是进入暂停状态,等待下一次的调用取值就会继续往后面执行

# def m():
#     for i in range(1,11):
#         print(f'这是第{i}碗')
# m()

#生成器函数
def fun():
    for i in range(1,11):
        yield f'这是第{i}碗'
        print('好好吃')
f=fun() #把生成器对象 赋值给一个变量
print(type(f)) #generator 生成器
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
print(f.__next__())
# print(f.__next__()) #报错 超出取值范围

#用生成器表达式
	名称=(返回值 for 变量 in 可迭代对象)
    
noddle=(f'这是第{i}碗' for i in range(1,6))
print(noddle) #生成器的内存地址
print(type(noddle)) #类型是生成器
print(next(noddle))
print(next(noddle))
print(next(noddle))
print(next(noddle))
print(next(noddle))

#生成器了解即可 目前不用写  目前阶段用不上 后面学习爬虫的时候会用到生成器表达式
了解原理 1.指定规则 2.生成数据  就可以了
#代码实现目前知道即可,不理解完全OK 理解的了最好
#具体使用不用太纠结  先知道这个东西 到时候学爬虫的时候 会具体用到

绝对路径和相对路径

文件路径  --> 文件存储的位置
	绝对路径=完整的路径,可以从盘符开始找到文件(c:--盘符)
    	生活中:陕西省宝鸡市扶风县**栋**楼**门牌号
        电脑中:C:\Users\hp\Desktop\文件操作与迭代器生成器.md
                
    相对路径=简短路径,有参考对象,默认从当前文件夹开始
    	生活中:扶风县**栋**楼**门牌号
        电脑中: 文件在同一个文件夹时,直接写文件名
            
        相对路径:
            ./ --表示当前文件夹(可以省略不写)
            ./文件操作与迭代器生成器.md == 文件操作与迭代器生成器.md
            
            ../ -- 表示返回到上一层文件夹
            	../文件操作与迭代器生成器.md --返回这个文件的上层文件夹 Desktop
                
             ../../文件操作与迭代器生成器.md  --返回的上上层文件夹 hp

文件操作

用python代码来操作电脑里的文件(txt,exe,md,py,mp3,doc)--文本/图片/音频...

文件的数据类型:
	t:text 文本数据 文件操作默认就是文本数据
	b:byte 以字节码的方式来操作数据--目前还不需要使用 后面学到网络编程/爬虫的时候会用
		wb:以字节码的方式写入数据
		wt:以文本的方式写入数据
		rb:以字节码的方式读取数据

文件操作的三要素:

1.打开文件

2.操作文件

3.关闭文件

文件操作语法格式1:

文件名=open(文件路径\文件名,操作模式,encoding='utf-8') #如果不写文件路径 默认就会在当前文件夹
f.操作模式()
f.close()

该语法格式在操作结束时,必须每次对文件进行关闭,否则会引起内存泄漏
f 是作为文件对象  名字是不固定的,但是一般都叫f

文件操作模式:

w:write 写入数据,如果文件里有数据 会被覆盖 如果没有这个文件就会新建
a:append 追加数据,如果文件里有数据,不覆盖而是追加到后面
r:read 读取数据
f.read():读取所有数据,也可以在括号里面放参数,指定读取的数据
f.readline():读取一行数据,也可以在括号里面放参数,指定读取的数据,但是超出一行的内容,也是只会读取一行    

f.closed --> 判断文件是否已经关闭 True关闭 False没关闭
f.writable() --> 判断文件是否可写 True可写 False不可写
f.readable() --> 判断文件是否可读 True可读 False不可读
#wrtie没有这个文件会写入数据
f=open('伊诺.txt','w',encoding='utf-8')
f.write('伊诺真好')
# print(f.writable()) #判断文件是否可写
f.close()
# print(f.closed) #判断文件是够关闭

#wrtie有这个文件是会覆盖之前 的数据
# f=open('伊诺.txt','w',encoding='utf-8')
# f.write('伊诺真美\n')
# f.close()

#append 不会覆盖 是添加新内容 也是用f.write()写入数据
# f=open('伊诺.txt','a',encoding='utf-8')
# f.write('你们真帅')
# f.close()

#read
f=open('伊诺.txt','r',encoding='utf-8')
print(f.read()) # 默认读完
# print(f.readable()) #判断文件是否可读
f.close()

f=open('伊诺.txt','r',encoding='utf-8')
print(f.read(3)) #也可以指定数据读
f.close()

#f.readline()
f=open('伊诺.txt','r',encoding='utf-8')
print(f.readline())  #读取一行数据
f.close()

#绝对路径 在我这里可以用 但是你的电脑用不了
f=open(r'C:\Users\hp\Desktop\陌上.txt','w',encoding='utf-8')
f.write('回家哈哈哈哈')
f.close()

#相对路径 推荐用相对路径
f=open('../嘿嘿.txt','w',encoding='utf-8')
f.write('嘿嘿嘿嘿')
f.close()

文件操作语法格式2:为了避免文件操作没有关闭导致内存泄漏,有种更推荐的写法,叫 with open.这个写法会文件操作结束后自动关闭文件

with open(文件路径\文件名,操作模式,encoding='utf-8') as 名字:
    名字.操作模式()
    #该模式会对文件自动关闭
# with open('first.txt','w',encoding='utf-8') as f:
#     f.write('陌上\n周茹华\n地狱￥管家\n张杰\n梁凡\n')


# with open('陌上.txt','a',encoding='utf-8') as f:
#     f.write('祝你们都优秀\n吃饭嘎嘎香')
#     f.write('身体健康,学业有成,万事如意')

with open('陌上.txt','r',encoding='utf-8') as f:
    res=f.read()
print(res[3:])


with open('陌上.txt','r',encoding='utf-8') as f:
    res1=f.readline() #读一行 不能指定读取某一行的内容


# print(res1)
print(res1[1])
print(res1[0])


# with open('陌上.txt','r',encoding='utf-8') as f:
#     res2=f.readline(1) #也可以指定数据读取 超出一行的内容,也是默认读完这一行
# print(res2)

拓展博客

http://c.biancheng/python/file
本节课文件操作内容需要拓展可以翻这个帖子

复习博客

复习博客 http://c.biancheng.net/view/5419.html

迭代器 http://c.biancheng.net/view/2393.html

生成器 http://c.biancheng.net/view/2270.html

day14-模块与包

上节回顾

迭代器--把一个有很多数据的容器整理好,把里面的数据一个个的取出来使用

生成器--自定义的迭代器,主要作用是用来制定规则,生成数据
一个函数里有哪个关键字 他就是生成器?--yeild

文件操作--用python来读/写电脑里的文件
	1.打开文件
    2.操作文件
    3.关闭文件
    
操作模式:
    r:read 读取文件
    w:write 写入文件--如果源文件有数据 会覆盖
    a:append 追加文件--如果源文件有数据 不会覆盖而是追加
    
上下文管理器:会根据代码上下文,自动进行操作 文件操作中 会运行后自动的关闭文件
    with open('文件路径+文件名','操作模式',encoding='utf-8') as f:
       f.write('写入数据') 
   		f.read() #读取数据
        
with open('复习.txt','w',encoding='utf-8') as f:
    f.write('复习一下') #写入模式为w
    
with open('复习.txt','a',encoding='utf-8') as f:
    f.write('今天是个好日子')

with open('复习.txt','r',encoding='utf-8') as f:
    print(f.read()) #读取 操作模式改为r

一、初识模块

什么是模块:
    模块本质就是一个python文件(.py文件)
    当python文件作为一个模块是,文件名就是模块名
    demo.py(模块) --demo是模块名
    
使用模块的作用:
    可以通过导入模块的方式,直接调用他模块里的代码,功能,可以更灵活的实现和使用,添加各种效果
    
变量=存储一个/多个数据
函数=存储多段代码
模块=所有东西都可以进行存放(变量,函数),本质就是一个python文件

当我们导入了一个模块后,就可以使用这个模块里的所有代码:里面的变量和函数

1.1模块分类

1.1.1内置模块(标准库)

python自带的 不需要提前下载 直接导入使用

import time #时间模块
import random #随机数模块
import os #系统模块

1.1.2第三方模块

不是python自带的,而是其他开发者写好上传的,使用之前需要先下载再导入使用
	pywin32--windows编程
    pygame--游戏开发
    requests-->爬虫
    
pip-->python 自带的下载器
python默认下载库就是使用pip,如果python环境没配置好,pip就使用不了 -->修复/重装

#如何下载第三方模块
在cmd中输入下面代码:
    pip install 你要下载的库名
    pip install pygame
    
#升级pip 有时候pip的版本太低 新的库下载不了
(注意:不要动不动就更新pip,有时候过新pip也是无法下载的,所以如果能下载的话,就不要更新)
python -m pip install --upgrade pip -i https://pypi.doubanio.com/simple
    
因为模块基本都是部署在国外,国内下载访问就会比较慢
就可以通过镜像代理,加速下载
阿里云：http://mirrors.aliyun.com/pypi/simple/
中国科技大学：https://pypi.mirrors.ustc.edu.cn/simple/ 
清华大学：https://pypi.tuna.tsinghua.edu.cn/simple/
豆瓣镜像地址：https://pypi.douban.com/simple/
    
例:
#通过镜像代理加速,下载第三方模块:
pip install 你要下载的库名 -i 镜像代理的位置
pip install pygame -i https://pypi.douban.com/simple/
    
#如果下载会超时的话导致下载不成功 可以这样写 直接复制以下代码
pip install 你要下载的模块名 --default-timeout=100 -i https://pypi.tuna.tsinghua.edu.cn/simple
    
pip install pygame --default-timeout=100 -i https://pypi.tuna.tsinghua.edu.cn/simple  
    
卸载第三方模块
在cmd中输入下面代码:
    pip uninstall 模块名
    pip uninstall pygame

1.1.3自定义模块

开发者自己定义自己写的模块

如果想要把一个python文件作为一个模块进行使用的话,尽量遵守命名规则
模块名规范:
    1.见名知意
    2.纯小写+下划线
    3.一定不要用中文命名,在导入模块的时候,就很容易出现问题
    
    例:
        user_longin #用户登录模块
        user_register #用户注册模块        

1.2使用模块

模块使用流程:

1.导入模块

2.调用/使用模块

模块的使用顺序:

1.导入模块中的单个功能

2.调用模块中的内容

3.优先自己的功能

4.调用模块里面的

导入模块:
    import 模块名
    import time
    import demo
    
import 导入的意思

使用模块:
    import 模块名
    print(模块名.变量名) #调用模块里的变量
    模块名.函数名() #调用模块里的函数
    
    import test
    print(test.a)
    test.fun()
    print(test.talk()) #打印返回值所以需要print
    
导入模块的单个函数或者变量:
    from 模块名 import 函数名
    from 模块名 import 变量名
    
    print(b) #直接写变量名 不需要写模块名
	student() #调用函数 直接写就好,不需要写模块名
    优点:避免不必要的内存资源开销 减少代码量
    缺点:可能会出现同名覆盖的情况(容易出现名字混淆) 优先自己模块的内容
        
如果模块名过长或不好记,通过as关键字 可以给它取别名
	import 模块名 as 别名
    import user_register as register #以后这个模块名就叫做register

1.3模块进阶使用

python导入模块的时候,解释器会把模块中的内容先读取一遍:
    1.读取模块中的全部内容
    2.会生成对应的名称空间,这个名称空间的名字会跟模块名一致(会把模块中的变量,函数存进去)
    3.等待程序的调用-->模块名.变量名/函数名
    
python中的__name__属性:
    如果当前文件作为一个执行程序的来操作的话,那么__name__的返回值为__main__
    如果当前文件作为一个模块来操作的话,那么__name__的返回值为模块名(文件名)
    
    #在pycharm里面,输入main按下回车键/tab,就会自动帮你补全代码
    if __name__ == '__main__':
        代码 #这里面的代码,当文件作为一个执行程序的时候,才会执行
    例子:有些人就只会窝里横,在家里老子就是天,在外面就畏畏缩缩
        当返回值为__main__,表示在家里,老子想怎么样就怎么样(想输出就输出)
        当返回值为模块名时,表示在外面,畏畏缩缩的,什么也不敢干
        
python通过main和name可以获取程序的状态:
    1.python的main和其他语言的main不一样,不是作为程序的入口
    2.一个python文件,如果他的__name__为__main__,那他就是启动文件,否则他是一个模块
    3.基于这个特性,可以把一些非必要执行的代码,放到main判断中,只有文件是以程序身份来执行的时候,才会运行里面的代码
导入规范:
     不推荐一行导入多个模块(太长,不方便查看)
        import time,random,os
     推荐多行导入
    	import time
        import random
        import os
        
     导入顺序:
        1.最先导入内置模块
        2.然后导入第三方模块
        3.最后导入自定义模块
        
     例:
        import time
        import random
        
        import pygame
        import requests
        
        import demo
#无论你自己看 还是别人  看这个导入模块 就比较清晰

二、包

模块=文件
包=文件夹

包的概念:
    包就是一个特殊的文件夹,管理模块使用的,把一些功能相同的模块放在一起,方便我们的维护与管理
    验证登录 --8
    数据 --10
    基础设置 --2
    
包的创建方式:
    在pycharm中--右键项目文件夹--new--python package
    
创建好包之后,会自动生成一个名为__init__.py的文件,这个文件就是一个负责管理包的模块 init-->初始化

__init__在导入包的时候会自动执行里面的内容
在__init__文件中可以写入包中模块的使用说明.配置信息

包的导入使用:
    from 包名 import 模块名
    from login import qq
    
    print(qq.name)
	qq.fun()
    
    
导入包内模块的单个功能
	from 包名.模块名 import 变量名/函数名
    from login.qq import fun
    from login.qq import name
    
    fun()
    print(name)    

day15-常用模块

模块的本质-->一个python文件
	模块名-->文件名(不带后缀)
    text.py-->模块名是text
    
导入使用模块
	import 模块名
    import time
    #使用模块中的变量
    模块名.变量名
    #使用模块中的函数
    模块名.函数名
    
模块分为三类:
    1.内置模块:python自带的
	2.第三方模块:>其他开发人员写的,要使用的时候需要进行下载(pip)
    	1.打开cmd,2,pip install 模块名 -i 镜像代理位置
    3.自定义模块:开发者自己写的模块
        如果说你自己写的一个python文件想要作为一个模块来使用,那么要遵循模块的命名规范
        
给模块取别名 -- as
	import 模块名 as 别名
    
__name__属性:判断当前的文件是以模块使用还是执行程序来使用
    当返回值__main__,这个文件是作为执行程序来使用
    当返回值模块名,这个文件是作为模块来使用
    
    if __name__ == '__main__':
    	代码 #里面的内容只有当前文件是执行程序才会运行
        
包的本质-->一个特殊的文件夹
	包在在创建时会自动生成一个名为__init__.py文件
    init文件主要是管理包中的各个模块,这个文件在导包的时候会自动执行里面的内容
    包是可以统一管理各个模块,方便后续的维护操作
    from 包名 import 模块名  

一、time

#导入时间模块
import time

#获取1970.1.1距离现在过去了多少秒
print(time.time())

#可以计算程序执行的时间长短
start=time.time()

def fun():
    print('我模拟的是一个程序的运行')
fun()

#让程序休眠,里面的参数是一个数值类型(整型,浮点型)的数据
# time.sleep(3)

end=time.time()
print(end-start)

'''
def fun():
    print('我这是一个很牛的功能')
    time.sleep(3) 会员就慢 那你开了 就可以给你加速
    print('我是一个很牛的功能,但是我运行的好像有点慢,说不定你充点钱就变快了')
    写了一个功能,人为的加了sleep命令,让程序运行时间拉长
    形成了一种很慢的现象,以此要求对方.得加钱/优化项目的时候,再过给你点时间,时间变得更快    
'''

#3.获取格式化时间
#获取年月日
print(time.strftime('%Y-%m-%d'))
#获取年月日 星期几
print(time.strftime('%Y-%m-%d %A'))

#获取时分秒
print(time.strftime('%H:%M:%S'))
#获取时分秒 上午还是下午
print(time.strftime('%H:%M:%S %p'))

#以斜杠分割 月份日期年份
print(time.strftime('%x %X'))
print(time.strftime('%X %x'))

#将当前时间以结构化的方式进行展示
print(time.localtime())

二、random

#导入随机数模块
import random

#在0-1之间的随机小数
print(random.random())

#在指定整数范围内的随机整数  random.randint(起点,终点) 包含终点的值
print(random.randint(1,3))

#在指定范围内的随机小数
print(random.uniform(1.5,4.5))
res=random.uniform(1.5,4.5)
print('%.2f'%res)

game=['剪刀','石头','布']
#随机在列表/元组中输出一个元素
print(random.choice(game))

#随机打乱列表 只能打乱列表
num=[1,2,3,4,5,6,7,8,9]
print(num)
random.shuffle(num)
print(num)

#通过随机模块,可以做一些小项目-->猜拳 ,斗地主,验证码,抽奖

#生成一个四位字母验证码
def fun():
    #声明一个空的字符串,用来保存获取到的每个字母,进行拼接
    msg=''
    for i in range(4):
        # 65-90:大写A到Z之间的所有字母对应的ascii码的序号
        msg+=chr(random.randint(65,90)) #生成一个65-90之间数字,并转为字符
    return msg

print(fun())

三、os

#os模块,操作系统模块,主要操作当前项目的文件
import os
# os.system 打开cmd
# os.system('start cmd') #打开cmd
# os.system('start calc') #打开计算器
# os.system('start osk') #打开屏幕键盘
# os.system('start mspaint') #打开画图工具
# for i in range(5):
#     os.system('start cmd')

#获取到当前文件所在的位置
print(os.getcwd())

#在当前文件中新建文件夹 os.mkdir(文件夹名)
# os.mkdir('classmate')

#删除文件夹,只能删除空白的文件夹,如果文件夹中有内容,就不能删除
# os.rmdir('classmate')

#切换当前位置,切换程序的执行程序
# os.chdir('classmate')
# print(os.getcwd())
#删除文件
# os.remove('a.py')

#给文件重命名 os.
# os.rename('a.py','b.py')
# os.rename('b.py','c.txt') #一般不会重命名的时候去改后缀 改了后缀的话会发生文件异常 不建议强制改文件类型

#判断文件或者文件夹是否存在
print(os.path.exists('os_demo.py'))

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

四、sys

#系统模块 system -->深入的功能目前不需要使用
import sys

#获取你的python环境变量 -->python安装位置+项目位置
print(sys.path)

#获取你的程序位置
print(sys.argv)

#获取python版本的信息
print(sys.version)

#win32不是你的操作系统位数 获取操作系统架构信息
print(sys.platform)

五、json

'''
json模块
json是一种文件的存储格式,主要作用就是在保留原来类型的情况下,保存数据
    一个数据用json可以确保 存之前是什么类型 取出来还是什么类型

json就是一种让你的文件可以保留原来类型的文件格式
'''
import json
#普通存入一个文本的话 数据类型必须为字符串
# stu=['张杰','薛之谦','周深','范丞丞','邓紫棋','周杰伦','林俊杰']
# with open('陌上.txt','w',encoding='utf-8') as f:
#     f.write(str(stu))
#
# with open('陌上.txt','r',encoding='utf-8') as f:
#     res=f.read()
#     print(res)
#     print(res[0])
#     print(res[1])
#     print(res[2])
#     print(res[3])

#用json存
info={'name':'陌上','age':18,'money':95.53}

#json.dumps(info) 把数据转为json格式
# json_data=json.dumps(info)
# print(json_data)

#读取json格式数据
# data=json.loads(json_data)
# print(data)
# print(type(data))

#将数据写入到json文件中
with open('msg.json','w',encoding='utf-8') as f:
    json.dump(info,f) #把info这个字典传进去,有两个参数,第一个是你想要存的数据,第二个参数是文件

with open('msg.json','r',encoding='utf-8') as f:
    find=json.load(f) #读取msg.json文件

print(find['name'])
print(type(find))
print(find)

stu=['张杰','薛之谦','周深','范丞丞','邓紫棋','周杰伦','林俊杰']
with open('msg2.json','w',encoding='utf-8') as f:
    json.dump(stu,f)

with open('msg2.json','r',encoding='utf-8') as f:
    find1=json.load(f)

print(find1[0])
print(find1[1])

拓展分享

mvc开发模式-->开发时的一种设计理念
	Modle--模块层-->主要处理数据相关的东西(数据库,json)
	View--视图层-->主要处理用户体验,给用户看的东西
	Controller--控制器层-->主要处理后台功能,实现各种功能
	
以前开发一个项目的时候并没有一样具体的分工,导致有的时候就很乱,出现了bug各种甩锅,所以有前辈总结了MVC的开发模式

就是在开发项目时为M,v.C三层,每层都有自己的任务,互有联系,但互不干涉,开发人员只需要专注好自己负责的部分就好

出现了问题,也更好的找到问题所在

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

day-16 复习与项目搭建

第11-15节课复习

函数对象--把函数当成一个普通的容器来使用
	1.用函数来赋值
    	1.1.把函数本身复制给一个变量,变量就相当于函数的分身
        	a=print #把print函数的功能复制了一份给了a,a以后也可以用来输出
        1.2.把函数的返回值赋值给一个数据
        	def fun():
                return 666
            res=fun()
            print(res)
            
    2.可以把函数放到一个数据容器里(列表,元组,字典,函数)
    	def fun():
            return 666 
        li=[1,2,fun]
        demo={1:fun}
    
    3.可以用函数作为返回值(闭包)
    4.可以函数作为参数 3+4 -->装饰器
    	def add_food(a):
            def beer(*args,**kwargs):
                a(*args,**kwargs) #调用传进来的函数
                print('夏天到了要来打啤酒')
            return beer

        @add_food
        def eat():
            print('今天吃小龙虾')
        eat()

        @add_food
        def eat_1():
            print('今天吃小火锅')
        eat_1()
        
名称空间:在python中一块专门来存储名字的区域,默认情况下有三块名称空间
    内建名称空间:存储python的内置函数,内置变量,他会随着python程序启动而生成
    全局名称空间:存储用户定义外层的名字(变量名,函数名) 它会随着python程序启动而生成
    局部名称空间:存储用户在函数内的名字(变量,形参,函数),它会随着函数的调用而生成
        
作用域:一个数据能够被使用的范围
        全局-->整个程序里都可以使用
        局部-->程序里的部分位置才能使用(函数内)
        global -->提权 把一个数据从局部变为全局
        nonlocal-->私有化,把一个数据降权 局部变量再度局部化
        
闭包:在一个嵌套函数中,用内层函数操作外层函数得到的数据,属于间接修改
        def 外函数名(参数):
            def 内函数名():
                操作
            return 内函数
        单纯写闭包其实是没啥意义 闭包一般是为了实现装饰器来使用
        
装饰器:在不修改源代码/调用方式的情况下,给一个函数间接添加好功能
        实现原理就是通过闭包,把要添加的功能的函数传递进来 在内层函数中调用, 并在内层函数里新增新功能代码,最后把内层函数返回出去-->得到了被添加好功能的函数
        写好的装饰器可以通过@语法糖 放到要添加功能的函数名上,就可以实现功能追加
        
迭代器iter:
            对一堆数据进行更新迭代的操作:
                说人话:把很多的数据,有序的取出来使用
                    for循环的原理:把一个有很多的数据的对象转换成迭代器,再把里面的数据一个个的取出来使用
生成器yield:
            是一个自定义的迭代器,在函数里有个关键字yield
           	生成一个自定义的迭代器 自己指定规则,生成指定数据
            生成器一般是直接用生成器表达式来创建
            
文件操作:
    用python代码来操作电脑文件
    文件操作三要素:
        打开文件 操作文件 关闭文件
        为了避免忘记关闭为晚间 一般用with上下文管理器来写代码
        with open
        操作模式:
            w:写入 #如果有数据会覆盖
            a:追加 #如果有数据不覆盖
            r:读取  #查看数据
                
        with open('路径+文件名','操作模式',encoding='utf-8') as f:
            f.wirte(写入数据) #w
            f.read() #r 读取数据
            
       模块:所谓的模块,指的其实就是一个python文件
        模块的好处就是避免重复-->有的功能别人已经给你写好了,你就不用写,拿来用就好
        
模块分为三种:
            内置模块-->random,time.os,sys,json->python自带的不需要提前下载
            第三方模块-->requests,pygame-->别人写好的 要先下载才能使用
            自定义模块-->用户自己写的模块
            
            下载第三方模块使用pip工具-->在cmd中输入 pip install 库名
            pip install requests
            
模块的基本使用:
    1.导入模块-->import
    	import 模块名
        import time
        
        import 模块名 as 别名
        import win32con as con
        
    2.使用模块
    	模块名.变量名 #使用模块中的变量
        模块名,函数名 #使用模块中的函数
        
    当你导入模块发生的事:
        1.先把模块文件运行一遍,确保没有问题
        2.生成一个名称空间,把模块里的名字存进去,名称空间就是模块的名字
        3.让当前运行程序连接名称空间,后续就可以通过 模块名. 的方式使用里面的数据
        
        如何区分一个python文件是模块还是执行程序
        通过__name__
        python有一个内置变量叫__name__,他只有两种结果
        	1.该文件作为模块运行时.__name__的结果是模块名
            2.该文件作为执行程序时.__name__的结果是__main__
            
         因此可以把一些测试代码 放到这个main判断中,当文件是执行程序的时候才会运行
        if __name__ == '__main__':
    		代码 
            
包:文件夹,把一些功能统一的模块放到一起,更好管理,里面会生成名为__init__.py的文件
    当导入这个包里的模块时,init的代码也会自动执行,所以可以把一些配置信息.使用说明 写到init里
    常用模块:
        time:时间模块
        random:随机模块
        sys:系统模块,python解释器在打交道
        os:操作系统模块,.文件所在的操作系统打交道
        json:序列化文件模块 更好的保存数据的一种文件格式
强调:一定不要把python文件名命名为内置模块名!!!   
          

本文标签： 入门基础Python