python3 day04 大纲

上节课内容回顾:
    1. 小数据池
        存储数据. 共享小数据池
        int,str, bool

        == 和 is区别:
            == 判断的是两边的值
            is 左右两端的内存地址


    2. 深浅拷贝
        1. = 没有创建新对象, 是一个内存指向的转换
        2. 浅拷贝. 只会拷贝第一层内容, [:],  copy()
        3. 深拷贝. 全部拷贝一份
            import copy
            copy.deepcopy()
    3. 文件操作
        open(路径, mode="模式", encoding="编码") 打开一个文件, 获取到文件句柄

        路径:
            绝对路径
                从磁盘跟目录寻找

            相对路径
                当前程序所在的文件夹
                ../day01

        模式:
            r, w, a, r+, w+, a+, rb, wb, ab,


        read()
        readline() 读一行
        readLines()  全部读取, 返回列表

        for i in f:

        with open() as f: 不用关闭连接

    4. 函数
        含义:对功能或者动作的封装.

        声明:
            def func(形参):
                函数体-> return

        调用:
            ret = func(实参)


        形参: 函数声明的时候, 写的变量.
            1. 位置
            2. 默认值
            3. 动态传参
                *  : 位置参数的动态传参
                **  : 关键字参数的动态传参
                def func(*args, **kwarg):
                    pass

            顺序:
                位置 > *args > 默认值 > **kwargs

        实参: 函数调用的时候, 给函数传递的具体的值
            1. 位置参数
            2. 关键字参数
            3. 混合(位置, 关键字)

            *, ** : 把列表或者元组, 字典, 打散


        返回值:
            return: 会终止一个函数的执行.
            1. 不写return. 返回None
            2. 写了return 没值. None
            3. return 值. 返回一个值
            4. return 值1, 值2, 值3....

        名称空间和作用域:
            名称空间:
                1. 内置
                2. 全局
                3. 局部名称空间

            作用域:
                1. 内置+全局 => 全局作用域   globals()
                2. 局部 => 局部作用域        locals()

            global  把全局变量引入到局部
            nonlocal 在局部, 把上一层函数的变量引入到内层函数

        函数名:
            函数名就是变量名


1. 迭代器
    list, dict, str, tuple, set, open   ->__iter__
    int, bool  -> 没有__iter__

    dir() 查看我们数据类型可以执行的操作

    让不同的数据类型有相同的遍历方式.

    特点:
        1. 省内存
        2. 只能向前. 不能反复
        3. 惰性机制

    如何判断一个变量是否是迭代器, 可迭代对象
    list

    使用代码如何判定
    Iterator, Iterable


2. 生成器
    本质上就是一个迭代器
     节省内存

     def func():
        yield
     生成器函数  -> 执行的时候. 不会立即把函数全部执行完. 创建一个生成器返回给你

    省内存
    __next__() 可以拿到数据
    send() 可以拿到数据, 可以给生成器传递消息

    生成器函数: yield

    列表推导式:
        [结果 for循环 if语句]
    字典推导式:
        {key:value for if}
    集合推导式
        {key for if}

        没有元组推导式!!!!!!!

    生成器表达式:
        (结果 for if)

3. 内置函数
    匿名函数
    lambda 参数: 返回值


4. 装饰器
    大型闭包
    在不改变原来的代码的基础上给代码增加新的功能

    开闭原则:
        开放: 可以对软件添加新的功能
        封闭: 不可以修改源代码

    通用装饰器:
        def wrapper(fn): # fn是目标函数
            def inner(*args, **kwargs):
                '''执行之前'''
                ret = fn(*args, **kwargs) # 执行目标函数
                '''执行之后'''
                return ret
            return inner

        @wrapper
        def func():
            pass

        func()  # inner()

    主要内容:模块