python修炼第三天

今天主要讲了文件操作，函数与装饰器，装饰器比较烧脑，需要多做练习，逐步分解来进行理解！    加油！

一 文件操作

操作系统 提供文件的概念
可以操作磁盘。

文件的只读模式：  注意如果是windows  前面要加个r：open(r"C:\a.txt") . 或者分隔符是 /
f = open("D:/python21期/L002-老男孩教育-Python20期VIP视频-mp4/b.txt","r",encoding="utf-8")
data = f.read()
print(data)
f.close()       # 文件关闭，回收操作系统的资源
print(f)         这个f变量还是存在的因为是python的变量。 python变量是在程序结束后自动释放
f.read()         这个文件已经被操作系统关闭了，所以就无法read读取了。

另一种方法： with open
with open("a.txt","r",encoding="utf-8")
    pass
这个是可以帮你自动关闭文件

其他读方法
1 f.readline()   只读取一行
    print(f.readline(),end="")
    print(f.readline(),end="")
    print(f.readline(),end="")

2 readlines()  吧文件都读出来，并全部放在一个列表list里面。
注意：如果文件过大，比如1T文件 就无法进行操作，这个只适用于小文件

文件的只写模式：  默认是wt文本写，如果文件不存在就创建文件，如果存在文件就清空原来的文件！！
f = open("b.txt","w",encoding="utf-8")
f.write(1111\n)
f.write(222222\n)
f.close()

其他写方法：
1 f.write("11111\n")

2 f.writelines 可以通过列表的形式 或元祖的形式   吧多行内容写到文件。
    f.writelines(["name\n","age\n","hobbie"])
    结果是
        name
        age
        hobbie
########## 注意 如果是wt文本格式打开的那么就只能写字符串格式

1 文件处理
补充
    print(f.writable())  看一下是否是可写的  可写返回True  不可写False
新的写模式：
a 追加模式， 整个文件末尾追加写
    f = open("b.txt","a",encoding="utf-8")   文件不存在就新建一个，如果存在就打开文件吧光标移动到文件末尾追加写，原文件内容不影响

读取多行的话 可以使用for
whit open("a.txt","r",encoding="utf-8") as f:
    for line in f:
        print(line)

b 模式  可以理解为而二进制
rb  二进制读
with open("a.txt","rb') as f:
    print(f.read().decode("utf-8"))    ## 如果是文本内容也存为b二进制模式，可以使用decode解码查看文本

wb 二进制写
with open("a.txt","wb") as f:
    res = "添加".encode("utf-8")             二进制写需要进行一下编码编码为二进制写
    f.write(res)

ab 追加写
跟上面一样 就是需要encode("utf-8")

练习 ;  实现cp命令  可以拷贝任何类型的文件
import sys
_,src_file,dst_file = sys.argv    # sys.argv是获取运行的参数，第一个是cp.py程序文件 第二个是源文件，第三个是目标文件，
                                  # 所以第一个不用获取，_,就可以空出第一个参数，src_file是第二个参数源文件
                                  # dst_file 是第三个参数目标文件。
with open("src_file","rb") as read_f, open("dst_file","wb") as write_f:
    for line in read_f:
        write_f.write(line)
        # 注意内存的数据往硬盘中存建议设置个缓存区，积攒一定的大小猴在往磁盘中写入，减少IO压力
        # wirte_f.flush()   这个是告诉操作系统赶快写到磁盘中

文件的修改：
import os
with open("1.txt","r",encoding="utf-8") as read_f,open(".1.txt.swap","w",encoding="utf-8") as write_f:
    data = read_f.read()
    write_f.write(read_f.replace("alex","SB"))
os.remove("1.txt")
os.rename(".1,txt.swap","1.txt")
这样是吧整个文件都写入到内存中修改，如果文件过大，会导致卡顿，所以可以一行一行的改：
    for i in read_f:
         if "alex" in i:
            i = i.replace("alex","SB")
         write_f.write(i)

文件内光标移动
只有一种情况光标指的是以字符为单位移动
with open("c.txt","rt","")as f:
    f.read(3)
只有read方式才能以字符方式移动
    print(f.tell)  告诉光标在第几个字节。 注意 如果有中文的话 一个中文是3个字节。比如
        hello你好
        f.read(6)
        print(f.tell())
        这个结果就是8  因为一个英文是一个字节，中文是三个字节 所以读到第六个字符后，这个光标就在5+3=8的字节上

光标的移动
f.seek
    with open("a.txt","rt",encoding="utf-8") as f:
        f.read(6)
        print(f.tell())
        这个时候是光标已经移动到了第6个字符（第8个字节）
        f.seek(8,0)    # 第一个参数是移动几个字节，  第二个参数有三个模式：0,1,2. 0代表相对的位置参照物，参照文件的最开头开始移动
                       # seek(8,0) 就是从开头0开始移动 往后移动8个字节。
                       # 0模式在字符t模式与二进制b模式下都可以使用。另外的 1 2 模式需要在bytes模式才能使用。他们的移动单位都是字节
        print(f.read())
        结果是打印第8个字节后面的内容。

     1模式：
        从当前光标开始往后移动。
        f.read(6)    # 已经移动了6个
        f.seek(2,1)  # 从当前第6个光标继续往后移动2个
        print(f.read())
        结果是6+2个字节，也是打印第8个字节后面的内容。

     2模式：
        从文件最末尾为参考开始移动。倒着移动
        f.seek(-3,2)
        print(f.read())
        从文件最后往前移动3个字节，如果文件最后是一个中文，那就只打印这个中文

实现 tail -f access.log
    with open("access.log","rb") as f:
        f.seek()
        while True:
            line = f.readline()
            if line:
                print(line)
            else:
                time.sleep(0.5)
注意 二进制b模式不翻译\n换行符。 字符t模式翻译\n  如果文本内容有\n换行符，二进制b模式print(line.decode(),end="")
end="" 就是把print自带的空格取消。 如果文本内容中没有\n换行符，哪就直接使用print(line) 就可以了

截断文件
    截断模式只能是 a 模式下使用：
    with open("a.txt","a",encoding="utf-8") as f:
        f.truncate(3)   # 只有从文件开头为参照物。3代表截取3个字节
        #就是只截断前三个字符

2 函数

　　1函数基础
        为何要用函数？没有函数带来的困扰
            1 组织结构不清晰，可读性差
            2 代码冗余
            3 可扩展性差

        什么是函数？
            具备某一个功能的工具-->函数
            函数就是事先准备的工具
            工具准备好了 ，拿来就可以用。重复使用
                先定义，后调用。

        函数的分类？
            内置函数：
                help(函数名) 这个就是查看函数下面的注释信息 参考语法1
                len
                max
                mix
                count
            自定义函数：def 自定义函数
        定义函数
            语法：
                def 函数名(参数1，参数2):
                   """ 注释信息"""          #  可选
                    函数体，功能体
                    return 返回值
                （其实函数就是一个变量，只不过可以调用）
                所以执行函数分为两步，第一步是通过函数名找到这个函数变量，找到函数就可以用()来调用。
            定义阶段：
                 定义函数只检测语法是否问题，不定义代码。

            调用函数：
                  先定义后调用。
                  调用函数，如果函数中定义的变量等功能没有或其他问题就会报错。
                  列子：

                   def foo():
                        print('from foo")
                        bar()
                   foo()
                   第一次调用会出现问题，因为bar函数没有定义,所以需要再定义一个bar函数
                   def bar():
                        print("from bar")
                    foo()
                    这次就可以了。  注意先定义后调用原则。

        定义函数的三种形式：
            1：无参函数
                def foo()
                    print("我是无参数函数")
            2：有参函数
                def auth(u,p):
                    if u =="root" and p == "123":
                        print("login successfull")
                    else:
                        print("user or password err")
                def interactive()
                    name = input("请输入账号：").strip()
                    password = input("请输入密码：").strip()
                    auth(name,password)
            3：空函数
                def auth():
                    pass
                在写应用的时候，针对每个功能定义一个函数。空函数就是先一个框架。站个位置。

        函数的返回值:
            # 函数内可以有多个return 但是只能执行一个return。
            def foo(x,y)
                print("first")
                return 1
                print("second")
                return 2
                print("third")
                return 3
            res=foo()
            print(res)   结果是first   1 因为执行遇到return后就退出了。先运行程序，然后在输出返回值

            # 执行return函数就立刻结束，并且return后的值当做本次调用的结果返回。
            def foo(x,y):
                retrue x+y
            res = foo(1,2)

            可以返回函数:
                def bar();
                    print("from bar")
                def foo():
                    return bar()
                print(foo())

            没有return  没有return   返回的是 None   print(foo)是打印函数内存地址， print(foo())是返回执行结果
            返回一个值return         就返回值本身。
            return多个值             返回的是一个元祖格式。

            函数调用的三种形式：
                def my_mix(x,y):
                    if x >=y:
                        return x
                    else:
                        reture y
                第一种： 单独使用
                    res1 = my_max
                第二种： 把函数返回值的结果进行运算
                    res2 = my_max(1,2)*10
                第三种： 函数调用可以当作另外一个函数的参数
                    res3 = foo(my_max(1,2),aa)

        函数参数的使用
            1.参数种类：两种
                1 形参   def foo(x,y)  在定义阶段在括号内是形参，  形参在定义阶段是不占内存空间的
                2 实参   foo(1,2)      在调用阶段括号内传入的值叫实参， 相当于值
                                       在调用阶段，实参的值会绑定给形参，在调用结束后解除绑定  。
            2.位置参数
                按照从左到右的顺序依次定义的参数。
                1 位置形参：必须被传值，多一个少一个都不行。
                2 位置实参：与形参一一对应传值。
                    def foo(x,y)
                        print(x,y)
                    foo(y=1,x=1)
            3.关键字参数
                在函数调用时,按照key=value的形式定义的实参
                特点：指名道姓地给形参传值，不再依赖于位置
                注意：
                def foo(name,age,sex):
                    print(name,age,sex)
                注意： 1关键字实参必须在位置实参的后面。
                       2不能为同一个参数赋多次值。

            4.默认参数
               1 指的是在函数定义阶段，就已经为形参复制。
                def foo(x,y=1):
                    print(x,y)
                默认参数的好处就是可以不用传值，当然也可以传值来修改默认参数的值
               2 默认参数的值只在定义时被复制一次
                    res = 1
                    def foo(x,y=res):
                        print(x,y)
                    res = 10
                    foo("aaaa")
                结果是 "aaaa" 1
               3 默认参数的值通常应该是不可变类型。  要么是数字，要吗是元祖

            5.可变长参数*args, **kwargs
                在调用函数时，实参值得个数不固定
                实参的形式有：位置实参和关键字实参。
                就是实参两个形式的长度个数是不固定。
                形参的解决方案： * 和 **
                *   是位置实参解决方案
                **  是关键字key  value解决方案
                1 *args
                    位置的实参会保存为元祖的形式保存
                    def foo(x,y,*z):
                        print(x,y)
                        print(z)
                    foo(1,2,3,4,5,6)
                        结果是吧1给x 2给y  *接收后面的然后以元祖形式赋值给z3，4,5,6给z
                        1,2
                        ( 3,4,5,6 )
                    另一种
                    def foo(x,y):
                        print(x,y)
                    foo(*(1,2))
                        结果是1,2
                2 **kwargs
                    def foo(x,y,**kwargs):
                        print(x,y)
                    foo(x=1,y=2,i=3,l=4)
                        这种情况*会接收i=3,l=4 并赋值给kwargs 保存为字典    格式。
                    另一种
                    def foo(x,y,**kwargs)
                    foo(y=2,**{"c":5,"b":6,"x":2})
                3 应用场景
                    def bar(x,y,z):
                        print(x,y,z)
                    def wrapper(*args.**kwargs):
                        bar(*args,**kwargs)
                    wrapper(1,2,3,a=1,b=2,c=2)
                    这样就会报错，因为wrapper接收参数后,传给bar，然后bar 通过* 与**原封不动的解析回
                    一开始传给wrapper的参数，所以bar就会报错。无法赋值。

            6.命名关键字参数
                指的是定义在*后的参数，该参数必须被传值（除非他有默认值），而且必须按照key=value的形式传值。

三 函数进阶

(1)名称空间：
    1 名称空间
    2 局部名称空间
    3 内置名称空间

    1 名称空间，或命名空间
         运行时开辟出来，里面存的是变量与值内存地址的关系

    2 临时名称空间
        比如定义了一个函数
        def func():
            name = "wustr"
            age = 23
        函数名存放到内存空间中
        但是函数体中的变量没有管。
        当遇到函数执行的时候，他会通过函数名找到函数体里面的变量然后
        临时开辟出一个内存空间，就是临时命名空间，也叫局部名称空间，然后
        吧函数里面的变量与值得关系存入到临时命名空间里面
        然后随着函数的执行结束，临时名称空间的内存就消失。释放。

    3 内置名称空间
        只要创建了py文件 解释器就会吧内置名称空间加载到内存中了。内置函数就可以使用了
        比如：len()

(2)作用域：
    1 全局作用域：全局名称空间，内置名称空间
    2 局部作用域：局部名称空间

(3)加载顺序，取值顺序
    加载顺序：内置名称空间先加载到内存。然后是全局名称空间加载到内存，最后是局部名称空间（只有函数执行时才加载）
    取值顺序：
        函数先从局部作用域取值，如果没有在找全局作用域，如果还没有就找内置名称空间。也就是从内向外找。
        而且只是单向的，找到最后没有就没了

globals locals 内置函数
    globals 将全局命名空间打印出来
    locals 将局部命名空间打印出来

global  nonlocal 关键字
    global
        函数里面可以使用全局命名空间的变量。但是不能改变。如果要改变需要使用global关键字声明全局变量

    nonlocal        声明全局变量，如果存在就更改全局变量。
        引用并改变上一层的局部变量。上一层同层的变量都会改变。

(4)函数名：
    1 可以相互赋值
        def fun1():
            print(666)
        f1 = func1
        f1()

    2 可以当成函数的参数
        def func2():
            print(111)
        def func3(argv):
            argv()
            print(222)
        func3(func2)

    3 可以当成容器类数据类型的参数
        def func11():
            print(222)
        def func22():
            print(333)
        def func33():
            print(444)
        ll = ["func11","func22","func33"]
        for i in ll:
            i()

    4 可以当作函数的参数和返回值
        def func():
            print(666)
        def func1(argv)
            print(777)
            return argv
        res = func1(func)
        res()

(5)闭包：
    内层函数对外层函数非全局变量的引用
    def wrapper():
        name = "alex"
        def inner():
            print((name)
        inner()
     wrapper()

    判断是不是闭包  inner.__closure__
    如果是返回cell   不是返回 None
    好处是：如果python检测是闭包。有一个机制，你的局部作用域不会随着函数的结束而结束。
    比如爬虫，爬下来的数据，使用闭包可以吧爬下来的数据保存到内存中，下次再爬直接从内存中取
    import urlopen,url
    def index():
        url = "http://www.xiaohua100.com/index.html"
        def get():
            return urlopen(url).read()
        return get
     index()()

四 装饰器

    函数对象
        函数是第一类对象：指的是函数可以当作数据传递
        1 可以被引用 x=1,x=y
            def func(x,y):
                print(x,y)
            f=func
            f(1,2)

        2 可以当作函数的参数传入
            def foo():
                print("form foo")
            def bar(x):
                x():
            bar(foo)
        3 可以当作函数的返回值
        4 可以当作容器类型的元素

后续内容待补。。。