文件读写追加函数入门装饰器

Posted 2020-10-31

                           文件读写追加、函数、入门装饰器

 

 

1、文件操作

 1、文件名称

 2、字符编码

 3、动作mode、读写等。。。

 

 

 f1,文件句柄，file 或者f_handle,f_obj

 open 打开的指令，windows的指令，windows编码方式默认gbk；linux；utf-8

 

1）打开文件，产生文件句柄

2）操作文件，操作文件句柄

3）关闭文件

 

 

 r全读  rb非文字类  r+ r+b

w  wb  w+ w+b

a  ab  a+ a+b

 

 

绝对路径的

f1 = open(r'E:\sss.txt',encoding='gbk')
cot = f1.read()
print(cot)
f1.close()

 

相对路径

f = open('opg',encoding='gbk')
cot = f.read()
print(cot)
f.close()

 

 

 

1全读

read

 

一行行读

2readline

 

f = open(r'opg',encoding='utf-8')
print(f.readline())
print(f.readline())
print(f.readline())
f.close()

 

 

3Readlins：将每一行作为列表的一个元素并返回这个列表

f = open(r'opg',encoding='utf-8')
print(f.readlines())
f.close()

 

 

以上都不好\

 

4、好的for循环，内存占的小

f = open(r'opg',encoding='utf-8')
for i in f:
    print(i)
f.close()

 

 

 

Read(n)安照字符去读的5个指定读取几个字符

f = open(r'opg',encoding='utf-8')
content = f.read(5)
print(content)

 

 

#按照非字符的方式去读用于网络
f.close()

f = open(r'opg',mode='rb')
content = f.read(5)
print(content)
f.close()

 

 

rb模式去读 字节去读取  都用于网路这一块，非文字的操作

f = open(r'opg',mode='rb')
cot = f.read()
print(cot)
f.close()

往回转换用decode

f = open(r'opg',mode='rb')
content = f.read(5)
print(content.decode('utf-8')) #转换回去
f.close()

 

R+ 可读写功能

 

内容：

 

 

如果现写后读和光标位置有关，光标按照字节运转

 

调光标位置seek

跳到最后seek(0,2)

 

 

 

 

 

重点：

Unicde----> bytes   encode（）

返回用decode（）

 

 

 

 

试一个

s1 = '中国'
s2 = s1.encode('gbk')
print(s2)

s3 = b'\xd6\xd0\xb9\xfa'
s4 = s3.decode('gbk')
s5 = s4.encode('utf-8')
print(s5)

 

 

简单方式：

s3 = b'\xd6\xd0\xb9\xfa'.decode('gbk').encode('utf-8')
print(s3)

 

 

 

 

再试一个联系：

s1 = '中国'
s2 = s1.encode('gbk')
# s2 = b'\xd6\xd0\xb9\xfa'
s3 = s2.decode('gbk')
s4 = s3.encode('utf-8')
s5 = s4.decode('utf-8')
print(s5,s1)


s1 = '中国'.encode('gbk').decode('gbk').encode('utf-8').decode('utf-8')
print(s1)

 

 

写

Write

没有文件自动创建

有文件将源文件内容清空，写入新内容

 

Wb:

 

 

 

W+ 现写后读

 

没啥用，但是想要这样要调光标

 

 

 

a 追加  ab

 

 

 

a+追加读用的不多

没用

 

 

 

 

Readable:writeable:判断可读写

Seek：调整光标

Tell：告诉指针位置

 

 

Seek(参数)0，2调制最后按照字节调整光标

 

 

 

 

Wich open() as: 文件句柄

with open('opg',encoding='utf-8') as f1:
    print(f1.read())

 

 

可以套接

with open('opg',encoding='utf-8') as f1,\
        open('log2',encoding='utf-8',mode='w') as f2:
    print(f1.read())
    f2.write('777')

 

 

 

 

文件的改：【步骤】

1、打开元文件，产生句柄

2、创建新文件，产生句柄

3、读取源文件，进行修改，写入新文件

4、将原文件删除

5、新文件重命名元文件

 

#需要os模块
import os
with open('log2',encoding='utf-8')as f1,\
    open('log2.bak',encoding='utf-8',mode='w')as f2:
    old = f1.read()
    new = old.replace('xxx','777')
    f2.write(new)
os.remove('log2')
os.rename('log2.bak','log2')

 

 

不太好：

这个好哦：一行一行执行，不占内存

import os
with open('log2',encoding='utf-8')as f1,\
    open('log2.bak',encoding='utf-8',mode='w')as f2:
    for line in f1:
        new_line = line.replace('777','utf-8')
        f2.write(new_line)
os.remove('log2')
os.rename('log2.bak','log2')

 

 

函数：
li = [1,2,3,4,5,'sdf']
count = 0
for i in li:
    count+=1
print(count)


s1 = 'dsfaewadsfdsa'
count1 =0
for i in s1:
    count1 += 1
print(count1)
#代码重复可执行差

 

 

 

 

简单方法：

 

sl = 'sdfsadgfgrewfgsav'
def my_len():
    count1 = 0
    for i in sl:
        count1 += 1
    print(count1)
my_len()

'''
def 关键字 函数名设定与变量相同：
     函数体
'''

 

 

 

函数的返回值 ：

  return遇到结束函数

def func():
    print(11)
    print(22)
    return
    print(33)
func()

 

给函数的的调用者

s1 = 'sdfqweafadsfads'
def my_len():
    count = 0
    for i in s1:
        count +=  1
    return count
print(my_len())

 

无return 返回none

s1 = 'sdfqweafadsfads'
def my_len():
    count = 0
    for i in s1:
        count +=  1
    # return count
print(my_len())

 

Return不写或者None

 

 

s1 = 'sdfqweafadsfads'
def my_len():
    count = 0
    for i in s1:
        count +=  1
    return
print(my_len())

 

s1 = 'sdfqweafadsfads'
def my_len():
    count = 0
    for i in s1:
        count +=  1
    return None
print(my_len())

 

如果return返回单个数：

s1 = 'sdfqweafadsfads'
def my_len():
    count = 0
    for i in s1:
        count +=  1
    return 'sss'
print(my_len(),type(my_len()))

 

 

 

Return如果返回多个数值，将放在一个元祖中返回
s1 = 'sdfqweafadsfads'
def my_len():
    count = 0
    for i in s1:
        count +=  1
    return 666,333,'sss','lll'
print(my_len(),type(my_len()))

 

 

 

分别赋值

s1 = 'sdfqweafadsfads'
def my_len():
    count = 0
    for i in s1:
        count +=  1
    return 666,333,count
ret1,ret2,ret3 = my_len()
print(my_len(),type(my_len()))

 

 

函数（）定义的是行参

s1 = 'sdfqweafadsfads'
li = [1,2,3,4,5,'sdfa']

def my_len(a):
    count = 0
    for i in a:
        count+=1
    return count
ret =my_len(s1)
print(ret)

 

函数（）执行的是实参

 

 

从实参角度：

1）、位置参数，一一对应，按照顺序

def func1(x,y):
    print(x,y)
func1(1,2)

 

 

def func1(x,y,z):
    print(x,y,z)
func1(1,2,z=8)

 

2）

2）、关键字参数，这个不分顺序，必须一一对应def func1(x,y,z):
    print(x,y,z)
func1(y=1,z=9,x=7)

 

 

小练习：
def func1(x,y):
    if x >y:
        return x
    else:
        return y
print(func1(100,200))

 

也可以这样

 

3）混合参数：--------------关键字参数要在位置参数后面

def func1 (argv1,argv2,argv3):
    print(argv1)
    print(argv2)
    print(argv3)
func1(1,2,argv3=5) # 赋值的参数要放在最后

 

 

 

#从形参角度

1）位置参数

2）默认参数：-----------------默认参数必须在位置参数后面

def register(name,sex):
    with open('register',encoding='utf-8',mode='a') as f1:
        f1.write('{}{}\n.'.format(name,sex))
while True:
    name = input('请输入姓名')
    sex = input('请输入性别')
    register(name,sex)

def register(name,sex):
    with open('register',encoding='utf-8',mode='a') as f1:
        f1.write('{}{}\n.'.format(name,sex))
while True:
    name = input('请输入姓名: /q ro Q exit')
    if name.upper() == 'Q':break
    sex = input('请输入性别')
    register(name,sex)

 

 

def register(name,sex='男'):
    with open('register',encoding='utf-8',mode='a') as f1:
        f1.write('{}{}\n.'.format(name,sex))
while True:
    name = input('请输入姓名')
    if name.upper() =='Q':break
    if 'a' in name:
        sex = input('请输入性别')
        register(name,sex)
    else:
        register(name)

 

 

 

 

 

3）动态参数*args  **kwargs

def func2(*args,**kwargs): #万能参数
    print(args)  #元祖：接受所有位置参数
    print(kwargs) # 字典：关键字
func2(1,2,3,4,5,6,'sdf','oosd',a='www',b='sss')

 

  

这个下面在函数执行*交打散，形参加*交聚合

 

如果是**就会把这个位置参数 放到字典当中

 

名称空间与内存的关系：【全局名称空间】

 

 

临时名称空间：临时名称空间，【局部名称空间】，存入函数里面的变量与值得关系

随着函数执行的结束，临时名称空间结束

 

【内置名称空间】

len
ss=len('dsfdsagafsdg')
print(ss)  # 内置名称空间

 

 

作用域：
全局作用域：包括全局名称空间，内置名称空间

局部作用域：局部名称空间

 

加载顺序：

内置名称空间------------全局名称空间-------------局部名称空间（函数执行时）

取值顺序：局部名称空间-----------全局名称空间-----------内置名称空间

 

Globals和locals内置函数

Globals：全局名称空间的变更量放到字典

Locals：局部名称空间的变量与值放到字典

 

关键字：

Global   nonlocal

 

Global：

声明一个全局变量

 

 

内部名称空间的可以应用外部的，但是不能改变，不然会报错

 

Global作用： 申明一个全局变量，   更改一个全局变量

name = 'lxf'
def func():
    global name
    name = '777'
    return
func()
print(name)

 

 

 

Nonlocal：引用局部变量

 

 

函数名：

1、可以互相赋值

def func():
    print(666)
f1 = func
f1()

 

2、可以当成函数参数

def func1():
    print(666)

def func2(argv):
    argv()
    print(777)
func2(func1)

 

 

3、可以当成容器类数据类型的参数
def f1():

    print('f1')

 

def f2():

    print('f2')

 

def f3():

    print('f3')

 

l = [f1,f2,f3]

d = {'f1':f1,'f2':f2,'f3':f3}#调用l[0]()

d['f2']()

 

5、函数名可以当成函数返回值

def func1():
    print(666)

def func2(argv):
    print(777)
    return argv
ret = func2(func1)
ret()

 

 

 

闭包函数：内层函数对外层函数非全局变量的应用交闭包：

 

 

def wrapp():
    name = 'lxf'
    def inner():
        print(name)
    inner()
wrapp()

不是闭包：

name = 'sdf'
def wrapp():

    def inner():
        print(name)
    inner()
wrapp()

 

判断是不是闭包：

是闭包

def warapper():
    name = 'lxf'
    def inner():
        print(name)
    inner()
    print(inner.__closure__)#cell是闭包
warapper()

 

def warapper(argv):
    def inner():
        print(argv)
    inner()
    print(inner.__closure__)#cell是闭包
name = 'lxf'
warapper(name)

 

 

闭包的好处：防止占内存过大饱满

如果python检测闭包，他又一个机制，你的局部作用域不会随着函数的结束而结束
from urllib.request import urlopen

def index():

    url = "http://www.xiaohua100.cn/index.html"

    def get():

        return urlopen(url).read()

    return get

 

xiaohua = index()

content = xiaohua()

print(content)

 

 

装饰器：
在不改变元函数及原函数的的调用情况下，为原函数增加额外功能，如打印日志，执行时间、登陆时间
举个列子：

import time
def func1():
    print('晚上回去吃烧烤')
    time.sleep(0.3)
def func2():
    print('晚上回去喝啤酒')
    time.sleep(0.3)
def timer(f1):
    start_time = time.time()
    f1()
    end_time = time.time()
    print('执行效率是%s'%(end_time - start_time))
timer(func1)
timer(func2)

这个不好改变了源代码的执行方式。。。。。。。

进行修改在试试：

import time
def func1():
    print('晚上回去吃烧烤')
    time.sleep(0.3)
def func2():
    print('晚上回去喝啤酒')
    time.sleep(0.3)
def timer(f1):
    start_time = time.time()
    f1()
    end_time = time.time()
    print('执行效率是%s'%(end_time - start_time))
f =func1
func1 = timer
func1(f)

换是不太好比之前强一点点。。。。。

import time
def func1():
    print('晚上回去吃烧烤')
    time.sleep(0.3)

def timer(f1):
    def inner():
        start_time = time.time()
        f1()
        end_time = time.time()
        print('执行效率是%s'%(end_time - start_time))
        return inner
func1 = timer(func1)
func1()

最简单版装饰器

 

接下来语法堂：

import time
def timer(f1):
    def inner():
        start_time = time.time()
        f1()
        end_time = time.time()
        print('执行效率是%s'%(end_time - start_time))
        return inner
@timer
def func1():
    print('晚上回去吃烧烤')
    time.sleep(0.3)
func1()
@timer
def func2():
    print('晚上回去喝啤酒')
    time.sleep(0.3)
func2()

 

带参数的装饰器：

import time
def timer(f1):
    def inner(*args,**kwargs):
        start_time = time.time()
        f1(*args,**kwargs)
        end_time = time.time()
        print('执行效率是%s'%(end_time - start_time))
        return inner
@timer
def func(a,b):
    print(a,b)
    print('晚上回去吃烧烤')
    time.sleep(0.3)
func(111,222)

最终版本的装饰器：

 

def wrapper(f1):
    def inner(*args,**kwargs):
        ret = f1(*args,**kwargs)
        return ret
    return f1
@wrapper
def func1():
    print(222)
    return 333
print(func1())