函数名和闭包

• 函数名就是一个变量名

• 闭包：内层函数对外层函数的变量的引用

优点

• 保护变量不被侵害

• 可以让一个变量常驻内存 -> 装饰器

迭代器

• 可以迭代对象：对象内部有iter()

• 迭代器：对象内部有iter(),next()

• 通过dir函数可以查看XX可以执行的方法

作用让不同的数据类型有了相同的遍历方式
lst = (1,2,3,4)
for item in lst: #for循环内部，获取迭代器

特性

• 1.节省内存

• 2.惰性机制

• 3.只能向前不可折返

生成器(generator)

本质上也迭代器，生成器使用和迭代器一样区别生成器对应函数，迭代对象

• 生成器函数(yield)

def func():
    yield 1
func()  # 此时函数并没有执行，而是创建了新的生成器
g = func()
func().__next__()
func().__next()

不仅有__next__()
还有一个send()给上一个yield位置传值

• 生成器表达式：(结果for循环 if判断) -> 列表推倒式 [结果 for循环 if判断]

内置函数

• eval() -> 执行字符串类型的代码，有返回值

• exec() -> 执行字符串类型的代码，没有返回值

• compile() -> 预编译

• zip() 拉链函数

• sorted(可迭代对象，key=func,erverse) 排序 -> key是排序规则，流程把可迭代对象中的每一个数据传递给函数运行，根据函数返回结果进行排序

• filter(函数，可以迭代对象) 筛选和过滤

• map(函数，可以迭代对象) 映射

装饰器

通用装饰器：
    def wrapper(fn):
        def inner(*args,**kwargs)
            '''之前'''
            ret = fn(*args,**kwargs)
            '''之后'''
            return ret
        return inner
    @wrapper    # func = wrapper(func)
    def func():
        pass
    print(func.__name__)    # 输出函数名为inner，不是func了

保证函数名不变:
    from functools import wraps
    def wrapper(fn):
        @wraps(fn)  #可以改变你的inner函数为fn
        def inner(*args,**kwargs)
            '''之前'''
            ret = fn(*args,**kwargs)
            '''之后'''
            return ret
        return inner
    @wrapper    # func = wrapper(func)
    def func():
        pass
    print(func.__name__)    # 输出函数名为func
    作用：在不改动原来代码的基础上给函数添加新的功能,开辟原则

time模块

import time
# 获取当前的系统时间
print(time.time())  # 时间戳:1970-01-01 00:00:00 为python的原点
# 格式化时间
print(time.strftime("%Y-%m-%d %H:%M:%S"))
# python真的的时间 -> 结构化时间
print(time.localtime())
# 把一个数字装换成格式化时间(重点)
n = 1400000000
# 1.把时间戳转换成结构化时间
struct_time = time.localtime(n)
print(struct_time)
# 2.把结构化时间转换成格式化时间
s = time.strftime("%Y-%m-%d %H:%M:%S --> %z",struct_time)
print(s)
# 时间戳 -> 结构化 -> 格式化

# 3.把人能看懂的事件 -> 时间戳(重点)
s = input("请输入一个时间(yyyy-MM-dd):")
# 将格式化时间转化成结构化时间
struct_time = time.strptime(s,"%Y-%m-%d")   #parse:转化
print(struct_time)
# 4.吧结构化时间转化成时间戳
n = time.mktime(struct_time)
print(n)
# 总结：格式化时间 -> 结构化时间 -> 时间戳

# 时间差的计算 -> 针对小时来计算
# 1.先获取两个时间
s1 = input("开始的时间(yyyy-mm-dd HH:MM:SS)：")
s2 = input("开始的时间(yyyy-mm-dd HH:MM:SS)：")
# 2.将两个时间转化成时间戳
n1 = time.mktime(time.strptime(s1,"%Y-%m-%d %H:%M:%S"))
n2 = time.mktime(time.strptime(s2,"%Y-%m-%d %H:%M:%S"))
# 3.计算时间差
diff_n = abs(n2 - n1)   #秒级别的时间差
# 4.把秒转化成分钟
diff_min = diff_n // 60
# 5.把秒转化成小时
diff_hour = diff_min // 60
diff_hour_main = diff_min % 60
print(diff_hour,"小时",diff_min,"分钟")

os模块

import os

# os.makedirs("/大头儿子/小头爸爸/一对好朋友快乐父子两")    # 创建文件夹目录，创建多级目录
# os.mkdir("/大头儿子/789")   # 创建文件夹，但是上级目录必须存在
# os .removedirs("/大头儿子/小头爸爸/一对好朋友快乐父子两")    # 从内向外删除，如果删了一层之后判断上层是否为空，为空继续删除
# os.rmdir("/大头儿子/小头爸爸/一对好朋友快乐父子两")   # 只是删除最后一层目录
# print(os.stat("牛逼"))  # 查看文件夹的属性
# os.system("dir")   # 运行shell命令，直接显示
# print(os.popen("dir").read())   # 运行shell命令获取执行结果
# print(os.getcwd())  # 获取当前的工作目录，即当前的python脚本工作的路径
# os.chdir("")    # 切换工作的目录，后面的文件查找就从这个地方查找的
# os.chdir("dirname")   # 改变当前脚本的工作目录，相当于shell的CD

# def read_dir(s,n):
#     lst = os.listdir(s)
#     for el in  lst:
#         real_path = os.path.join(s,el)
#         print("===="*n,el)
#         if os.path.isdir(real_path):
#             read_dir(real_path,n+1)
# read_dir(r"e:\\",0)

# print(os.path.abspath("哄哄"))    # 返回一个相对路径的绝对路径
print(os.path.split("C:\python-first\哄哄"))  # ('C:\\python-first', '哄哄') 拆分成元祖
print(os.path.dirname("C:\python-first\哄哄"))    # 拿到文件或文件夹的上级目录
print(os.path.basename("C:\python-first\哄哄"))   # 拿到文件或文件夹的名字
print(os.path.exists("牛逼"))     # 判断是否存在
print(os.path.isfile("哄哄"))     # 判断是否是文件
print(os.path.isdir("牛逼"))      # 判断是否是目录
print(os.path.join("c:/牛逼","哄哄"))   # 文件路径的拼接

sys模块

import sys


if sys.argv[1] == "ddy" and sys.argv[2] == "yes" :
    print("登入成功")
else:
    print("登入失败"

# sys.exit(0)   # 适用于表示程序是否正常运行后退出，主要和操作系统沟通
# print(sys.version)    # 查看当前的python版本
# print(sys.platform)   # 查看操作系统的32/64
# print(sys.path)   # 搜索模块的路径

小练习

import os

def Copy(a,b):
    p_name = os.path.dirname(b)
    if not os.path.exists(p_name):
        os.mkdir(p_name)

    file = open(a,mode="rb")
    file1 = open(b,mode="wb")
    for line in file:
        file1.write(line)
    file.close()
    file1.flush()
    file1.close()

Copy("C:\python-first\牛逼.txt","C:\python-first\装逼\装逼成功.txt")

序列化

json模块是把python的数据转化成前端使用的json对象，json：JavaScript和python的dic是一样的数据格式，但是基本的数据类型表示方式不一样

• json.dump : 把数据序列化写入到文件

• json.load : 把文件反序列化成人的数据

• json.dumps：序列化

• json.loads：反序列化

import json

b = {"nsmr":"131",
     "key":"asd",
     "wife": {
         "name": "牛逼",
         "外号": "吊大",
     },
     "children": ("asd","a"),
     "asd":["asd",1,"as",{"asd":5}]
}
s = json.dumps(b,ensure_ascii=False) # 字典转化json，默认情况下中文是不显示的,所以处理下
print(s)

a = '{"nsmr": "131", "key": "asd", "wife": {"name": "牛逼", "外号": "吊大"}, "children": ["asd", "a"], "asd": ["asd", 1, "as", {"asd": 5}]}'

obj = json.loads(a) # Json转化为python对象
print(obj)

# 将json写入到文件中去

lst = ["招商","牛",{"揍你":"好的老弟"},None,False]
json.dump(lst,open("ok.json",mode="w",encoding="utf-8"),ensure_ascii=False)
# 打开Json文件
ss = json.load(open("ok.json",mode="r",encoding="utf-8"))
print(ss)