Python20-Day03

##########文件操作相关##########

一、文件操作

　　文件就是操作系统提供给应用程序来操作硬盘虚拟概念，用户或应用程序通过操作文件，可以将自己的数据永久保存下来。

　　文件操作的流程：

　　　　* 打开文件，得到文件句柄并赋值给一个变量

　　　　* 通过句柄对文件进行操作

　　　　* 关闭文件

　　python中的文件操作：

　　　　1. 打开文件，得到文件句柄并赋值给一个变量

　　　　　　f = open('a.txt','r',encoding='utf-8') #默认打开模式就为r

　　　　2. 通过文件句柄对文件进行操作

　　　　　　data = f.read()

　　　　3. 关闭文件

　　　　　　f.close()

　　python的资源回收

　　　　打开一个文件包含两部分资源：操作系统级打开的文件+应用程序的变量。在操作完毕一个文件时，必须把与该文件的这两部分资源一个不落地回收，回收方法为：

　　　　1、f.close() #回收操作系统级打开的文件
　　　　2、del f #回收应用程序级的变量

　　　　操作完毕文件后，一定要f.close()

　　

　　with关键字来帮助管理上下文：

　　with open('a.txt','r',encoding='utf-8') as f:

　　　　pass

　　

二、打开文件的模式

　　文件句柄 = open('文件路径','模式')

　　模式可以是以下方式以及他们之间的组合：

Character	Meaning
‘r'	open for reading (default)
‘w'	open for writing, truncating the file first
‘a'	open for writing, appending to the end of the file if it exists
‘b'	binary mode
‘t'	text mode (default)
‘+'	open a disk file for updating (reading and writing)
‘U'	universal newline mode (for backwards compatibility; should not be used in new code)

　　1. 打开文件的模式（默认为文本模式）

　　r，只读模式 默认模式 文件必须存在，不存在抛出异常

　　w，只写模式，不可读，不存在创建，存在则清空内容

　　a，追加模式 不可读，不存在则创建，存在只增加内容

　　2. 对于非文本文件，只能使用b模式，"b"表示以字节的方式操作，所有文件都是以字节的形式存储的，使用这种模式无序考虑文本文件的字符编码，

　　　　rb wb ab

三、操作文件的方法：

　　

#掌握
f.read() #读取所有内容,光标移动到文件末尾
f.readline() #读取一行内容,光标移动到第二行首部
f.readlines() #读取每一行内容,存放于列表中

f.write('1111\n222\n') #针对文本模式的写,需要自己写换行符
f.write('1111\n222\n'.encode('utf-8')) #针对b模式的写,需要自己写换行符
f.writelines(['333\n','444\n']) #文件模式
f.writelines([bytes('333\n',encoding='utf-8'),'444\n'.encode('utf-8')]) #b模式

#了解
f.readable() #文件是否可读
f.writable() #文件是否可读
f.closed #文件是否关闭
f.encoding #如果文件打开模式为b,则没有该属性
f.flush() #立刻将文件内容从内存刷到硬盘
f.name

练习，利用b模式，编写一个cp工具，要求如下：

　　1. 既可以拷贝文本又可以拷贝视频，图片等文件

　　2. 用户一旦参数错误，打印命令的正确使用方法，如usage: cp source_file target_file

　　提示：可以用import sys，然后用sys.argv获取脚本后面跟的参数

import sys

if len(sys.argv) != 3:
    print('usage: cp source_file target_file')
# source_file,target_file = sys.argv[1],sys.argv[2]
_,source_file,target_file = sys.argv
with open(source_file,'rb') as read_f,open(target_file,'wb') as write_f:
    for line in read_f:
        write_f.write(line)

四、文件修改

　　方式一：将硬盘存放的该文件的内容全部加载到内存，在内存中是可以修改的，修改完毕后，再由内存覆盖到硬盘（word，vim，nodpad++等编辑器）

import os
with open('a.txt','r') as read_f,open('.a.txt.swap','w') as write_f:
    data = read_f.read()
    data = data.replace('','zhaoliying')
    write_f.write(data)
os.remove('a.txt')
os.rename('.a.txt.swap','a.txt')

　　方式二：将硬盘存放的该文件的内容一行一行地读入内存，修改完毕就写入新文件，最后用新文件覆盖源文件

　　

import os
with open('a.txt','r') as read_f,open('.a.txt.swap','w') as write_f:
    data = read_f.read()
    data = data.replace('','zhaoliying')
    write_f.write(data)
os.remove('a.txt')
os.rename('.a.txt.swap','a.txt')

练习题：

1. 文件a.txt内容：每一行内容分别为商品名字，价钱，个数，求出本次购物花费的总钱数
apple 10 3
tesla 100000 1
mac 3000 2
lenovo 30000 3
chicken 10 3

goods_price_all = 0
with open('a.txt','r') as f:
    for line in f:
        line_list = line.split()
        price = int(line_list[1])
        goods_num = int(line_list[2])
        goods_price = price * goods_num
        goods_price_all+=goods_price
print('',goods_price_all)

##########函数相关##########

一、函数基础

　　1、函数分类

　　　　（1）内置函数：如len(),max(),sum()

　　　　（2）自定义函数

　　2、定义函数

　　　　自定义函数的语法　　

#语法
def 函数名(参数1,参数2,参数3,...):
    '''注释'''
    函数体
    return 返回的值

#函数名要能反映其意义

　　　　函数使用的原则：先定义，再调用

#测试一
def foo():
    print('from foo')
    bar()
foo() #报错

#测试二
def bar():
    print('from bar')
def foo():
    print('from foo')
    bar()
foo() #正常

#测试三
def foo():
    print('from foo')
    bar()

def bar():
    print('from bar')
foo() #会报错吗?

#结论:函数的使用,必须遵循原则:先定义,后调用
#我们在使用函数时,一定要明确地区分定义阶段和调用阶段

#定义阶段
def foo():
    print('from foo')
    bar()
def bar():
    print('from bar')
#调用阶段
foo()

　　　　函数在定义阶段都做了什么？

　　　　只检查语法，不执行代码，也就是说，语法错误在函数定义阶段就会检测出来，而代码的逻辑只有在执行时才会知道

　　　　2、 定义函数的3中形式

　　　　　　1. 无参 ：应用场景仅仅只是执行一些操作，比如用户交互，打印

　　　　　　2. 有参： 需要根据外部传来的参数，才能执行相应的逻辑，比如统计长度，求最大值最小值

　　　　　　3. 空函数： 涉及代码结构

#定义阶段
def tell_tag(tag,n): #有参数
    print(tag*n)

def tell_msg(): #无参数
    print('hello world')

#调用阶段
tell_tag('*',12)
tell_msg()
tell_tag('*',12)

'''
************
hello world
************
'''

#结论：
#1、定义时无参，意味着调用时也无需传入参数
#2、定义时有参，意味着调用时则必须传入参数

　　　　3、调用函数

　　　　　　1. 调用函数

　　　　　　　　函数名加括号

　　　　　　　　1 先找到名字

　　　　　　　　2 根据名字调用代码

　　　　　　2. 函数返回值

　　　　　　　　无 return --> None

　　　　　　　　return 1个值 -> 返回1个值

　　　　　　　　return 逗号分隔多个值，元组

　　　　　　　　什么时候该有返回值？

　　　　　　　　　　调用函数，经过一系列的操作，最后要拿到一个明确的结果，则必须要有返回值，通常有参函数需要有返回值，输入参数，经过计算，得到一个最终结果。

　　　　　　　　什么时候不需要有返回值？

　　　　　　　　　　调用函数，仅仅只是执行一系列的操作，最后不需要得到什么结果，则无需又返回值。通常无参函数不需要有返回值

　　　　　　3. 函数调用的三种形式

　　　　　　　　1 语句形式：foo()

　　　　　　　　2 表达式形式： 3*len('hello')

　　　　　　　　3 当中另外一个函数的参数：range(len('hello'))

　　　　　　4. 函数的参数

　　　　　　　　1 形参与实参

　　　　　　　　　　形参即变量名，实参即变量值，函数调用时，将值绑定到变量名上，函数调用结束，解除绑定。

　　　　　　　　2 具体应用

#1、位置参数：按照从左到右的顺序定义的参数
        位置形参：必选参数
        位置实参：按照位置给形参传值

#2、关键字参数：按照key=value的形式定义的实参
        无需按照位置为形参传值
        注意的问题：
                1. 关键字实参必须在位置实参右面
                2. 对同一个形参不能重复传值

#3、默认参数：形参在定义时就已经为其赋值
        可以传值也可以不传值，经常需要变得参数定义成位置形参，变化较小的参数定义成默认参数（形参）
        注意的问题：
                1. 只在定义时赋值一次
                2. 默认参数的定义应该在位置形参右面
                3. 默认参数通常应该定义成不可变类型

#4、可变长参数：
        可变长指的是实参值的个数不固定
        而实参有按位置和按关键字两种形式定义，针对这两种形式的可变长，形参对应有两种解决方案来完整地存放它们，分别是*args，**kwargs

        ===========*args===========
        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,3,4,5)

        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,*[3,4,5])

        def foo(x,y,z):
            print(x,y,z)
        foo(*[1,2,3])

        ===========**kwargs===========
        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,a=1,b=2,c=3)

        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,**{'a':1,'b':2,'c':3})

        def foo(x,y,z):
            print(x,y,z)
        foo(**{'z':1,'x':2,'y':3})

        ===========*args+**kwargs===========

        def foo(x,y):
            print(x,y)

        def wrapper(*args,**kwargs):
            print('====>')
            foo(*args,**kwargs)

#5、命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递
可以保证，传入的参数中一定包含某些关键字
        def foo(x,y,*args,a=1,b,**kwargs):
            print(x,y)
            print(args)
            print(a)
            print(b)
            print(kwargs)

        foo(1,2,3,4,5,b=3,c=4,d=5)
        结果：
            1
            2
            (3, 4, 5)
            1
            3
            {'c': 4, 'd': 5}

　　#1、写函数，，用户传入修改的文件名，与要修改的内容，执行函数，完成批了修改操作
　　

import sys
import os
if len(sys.argv) != 4:
    print('Uasge: 函数 文件名 修改前 修改后')

# change_file = sys.argv[1]
# before_content = sys.argv[2]
# after_content = sys.argv[3]
change_file,before_content,after_content=sys.argv[1],sys.argv[2],sys.argv[3]

def change(change_file,before_content,after_content):
    with open(change_file,'r') as read_f,open('%s.swap' % change_file,'w') as write_f:
        for line in read_f:
            if before_content in line:
                line = line.replace(before_content,after_content)
            write_f.write(line)
change(change_file,before_content,after_content)

os.remove(change_file)
os.rename('%s.swap' %change_file,change_file)

　　#2、写函数，计算传入字符串中【数字】、【字母】、【空格】 以及 【其他】的个数

def calc_num(calc_str):
    digit_num = 0
    space_num = 0
    zimu_num = 0
    other_num = 0
    for item in calc_str:
        if item.isdigit():
            digit_num=digit_num+1
        elif item.isspace():
            space_num=space_num+1
        elif item.isalpha():
            zimu_num=zimu_num+1
        else:
            other_num=other_num+1
    print(digit_num,zimu_num,space_num,other_num)
calc_num('helloworld123123132   321312    %%%%%% 321213 fadsfasf 4123412 ')

　　#3、写函数，判断用户传入的对象（字符串、列表、元组）长度是否大于5

def object_len(object_user):
    if len(object_user) > 5:
        print('%s is 大于5' % object_user)
    else:
        print('其他')
# object_len('zhaoliying')
# object_len((11,111,22))

　　#4、写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

def list_len(in_list):
    if not isinstance(in_list,list):
        print('%s is not list' % (in_list))
    else:
        # print('%s is list' % in_list)
        if len(in_list) > 2:
            in_list = in_list[0:2]
    return in_list
# print(list_len([1,2,3,4,5]))
# a = list_len([1,2,3,4,5])
# list_len([1,2,3,4,5])

　　#5、写函数，检查获取传入列表或元组对象的所有奇数位索引对应的元素，并将其作为新列表返回给调用者　

new_list = ['a','b','c','d','e','f','g','h','i',]
print(new_list[1::2])

def user_list(in_list):
    if not isinstance(in_list, list):
        print('%s is not list.' %in_list)
    else:
        print('%s is list.' %in_list)
        new_list=in_list[1::2]
    return new_list
a = user_list(['a','b','c','d','e','f','g','h','i',])
print(a)

　　#6、写函数，检查字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

#dic = {"k1": "v1v1", "k2": [11,22,33,44]}
#PS:字典中的value只能是字符串或列表
def user_dic(in_dic):
    d = {}
    if not isinstance(in_dic,dict):
        print('%s is not dic.' % in_dic)
    else:
        for key in in_dic:
            if len(in_dic[key]) > 2:
                d[key] = in_dic[key][0:2]
                # val_dic = in_dic[key]
                # res_dic = val_dic[0:2]
    return d
# a = user_dic({'hello':['zhaoliying','liying','wangxiaochen']})
a = user_dic({'hello':'zhaoliying'})
print(a)

##########函数对象、函数嵌套、名称空间与作用域、装饰器##########

一、函数对象

　　函数是第一类对象，即函数可以当做数据传递

　　　　#可以被引用

　　　　#可以当做参数传递

　　　　#返回值可以是函数

　　　　#可以当做容器类型的元素

　　利用这个特性，可以优雅的取代多分支的if

def foo():
    print('From foo')
def bar():
    print('From bar')

dic = {
    'foo' : foo,
    'bar' : bar,
}

while True:
    choice = input('Input your choice:>').strip()
    if choice in dic:
        dic[choice]()

二、函数嵌套

　　函数嵌套调用

　　函数的嵌套定义

三、名称空间与作用域

　　什么是名称空间？

　　　　名称空间：存放名字x与1绑定关系的地方

　　名称空间的加载顺序

　　　　python test.py

　　　　#python解释器先启动，首先加载：内置名称空间

　　　　#执行test.py文件，加载全局名称空间

　　　　#执行文件的过程中，如果调用函数，则临时产生局部名称空间

　　名字的查找顺序

　　　　局部名称空间--->全局名称空间--->内置名称空间

　　　　#在全局无法查看局部的，在局部可以查看全局的

　　　

四、作用域

　　作用域即范围，

　　　　---全局范围：全局存活，全局有效

　　　　---局部范围：临时存活，局部有效

　　作用域关系在函数定义阶段就已经固定，与函数调用位置无关

　　

五、闭包函数

　　#闭包函数包含对外部作用域而非全局作用域的引用

　　闭包的意义与应用

　　　　闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域

　　　　应用领域： 延迟计算

六、装饰器

　　为何要用装饰器？

　　　　开放封闭原则：对修改封闭，对扩展开放

　　装饰器的原则：

　　　　不修改被装饰对象的源代码

　　　　不修改被装饰对象的调用方式

　　装饰器的目的：

　　　　在遵循1和2的前提下，为被装饰对象添加上新功能

　　　　#无参装饰器

import time
def timmer(func):
    def wrapper(*args,**kwargs):
        start_time=time.time()
        res=func(*args,**kwargs)
        stop_time=time.time()
        print('run time is %s' %(stop_time-start_time))
        return res
    return wrapper

@timmer
def foo():
    time.sleep(3)
    print('from foo')
foo()

　　　　有参装饰器：

def auth(driver='file'):
    def auth2(func):
        def wrapper(*args,**kwargs):
            name=input("user: ")
            pwd=input("pwd: ")

            if driver == 'file':
                if name == 'egon' and pwd == '':
                    print('login successful')
                    res=func(*args,**kwargs)
                    return res
            elif driver == 'ldap':
                print('ldap')
        return wrapper
    return auth2

@auth(driver='file')
def foo(name):
    print(name)

foo('egon')