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

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())

原文地址:http://blog.51cto.com/xiaorenwutest/2104378

时间: 2024-10-13 10:23:20

文件读写追加、函数、入门装饰器的相关文章

Python入门之函数的装饰器

本章目录: 装饰器: 一.为什么要用装饰器 二.什么是装饰器 三.无参装饰器 四.装饰器语法糖 五.认证装饰器实现 六.叠加多个装饰器 七.带参装饰器 =========================================================== 一.开放封闭原则 引子--为什么要用装饰器 软件一旦上线后,对修改源代码是封闭的,对功能扩展是开放的. 也就是说我们必须找到一种解决方案: 能够在不修改一个功能源代码以及调用方式的前提下,为其加上新功能 总结,原则如下: 1.不

第二模块·函数编程-第1章 函数、装饰器、迭代器、内置方法

01-鸡汤之人丑就要多读书 02-三元运算 03-文件处理 04-文件处理-二进制模式 05-文件处理-智能检测编码的工具 06-文件处理-写模式操作文件 07-文件处理-追加模式操作文件 08-文件处理-混合操作文件 09-文件操作其他功能 10-文件处理-文件修改功能 11-函数-基本介绍 12-函数-默认参数 13-函数-关键参数 14-函数-非固定参数 15-函数-非固定参数2 16-函数-返回值 17-函数-局部变量 18-函数-在函数里修改全局变量 19-函数-在函数里修改列表数据

python day4笔记 常用内置函数与装饰器

1.常用的python函数 abs             求绝对值 all               判断迭代器中所有的数据是否为真或者可迭代数据为空,返回真,否则返回假 any             判断迭代器中的数据是否有一个为真,有返回真,可迭代数据为空或者没有真,返回假 bin             转换整数为二进制字符串 hex            转换整数为十六进制字符串 oct             转换整数为八进制字符串 bool           转换数据为布尔值

python函数、装饰器、迭代器、生成器

5月21日,请假结婚,然后性格惰性来了,不怎么想看视频和笔记,性格中的弱点开始出现,开始做的不错,渐渐开始松懈,直至放弃--- 函数补充进阶 函数对象 函数的嵌套 名称空间与作用域 闭包函数 函数之装饰器 函数之迭代器 函数之生成器 内置函数 一.函数补充进阶 1.函数对象:  函数是第一类对象,即函数可以当作数据传递,它的应用形式也被称为高阶函数,函数的特性如下: a. 可以被引用 1 # def foo(): 2 # print('from foo') 3 # 4 # func = foo

函数3—装饰器

1 为什么要用装饰器 开放封闭原则 :游戏上线后,尽量避免更改源代码和调用方式,但是出于需求必须为代码增加扩展性 2 什么是装饰器: 本质是一种函数 ,没有改动函数源代码和调用方式的情况下,给函数增加一种新的功能 利用了闭包的原理,闭包的作用就是可以在外部调用这个内部闭包函数,不用关心作用域的问题 3 装饰器的作用原理:将被装饰函数放入装饰器函数内部的一个闭包函数内,再在外部调用闭包函数 函数嵌套------->闭包---------->装饰器 #无参装饰器(被装饰函数无参)import ti

五、python函数、装饰器、内置函数、json及模块

一.递归调用 1.一个函数自己调用自己就是递归调用,最多一个函数递归调用自己999次,超过就会出错2.递归必须有一个明确的结束条件3.每次进入更深一层递归时,问题规模相比上次递归都应有所减少4.递归效率不高,少用递归 eg:def test1(): num = int(input('please enter a number:')) if num%2==0:#判断输入的数字是不是偶数 return True #如果是偶数的话,程序就退出了,返回true print('不是偶数请重新输入!') r

函数和装饰器

函数定义空函数函数作用域块级作用域局部作用域作用域链终极版作用域函数参数定义:默认参数可变参数关键字参数组合参数小结高阶函数与函数返回值高阶函数函数返回值lambda与匿名函数mapfilterreducelambda小结装饰器格式装饰器原理带参数的装饰器装饰器应用装饰器小结开放封闭原则闭包概念闭包的作用 函数定义 在Python中,定义一个函数要使用def语句,依次写出函数名.括号.括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用return语句返回. 我们以自定义一个求绝对值

python3命名空间与作用域,闭包函数,装饰器

一.命名空间与作用域 命名空间是名字和对象的映射,就像是字典,key是变量名,value是变量的值 1.命名空间 name='egon' #定义变量 def func(): #定义函数 pass class Foo: #定义类 pass 2.命名空间的分类 (1)内置名称空间: 随着python解释器的启动而产生,包括异常类型.内建函数和特殊方法,可以代码中任意地方调用 print(sum) print(max) print(min) print(max([1,2,3])) import bui

Python函数之装饰器

装饰器 一.装饰器的意义 比如:以下函数是供我们调用的,但是我们需要在每个函数中都添加同一个功能,该如何做到呢? 对于函数开放封闭原则,我们一般不允许修改.所以我们引入了装饰器: def outer(func): def inner(): print("添加在原函数之前") r = func() #保留原函数的返回值 print('添加在原函数之后') return r #将保留的返回值返回回去 return inner @outer #等价于f1 = outer(f1) def f1

Python函数加工厂-装饰器

引言: 函数和装饰器好比程序界的加工厂: 1.函数一般可用来加工一种或者多种数据类型的数据:字符串.数字.列表.字典等 举一个简单例子:已知半径求面积 def s(r): s = 3.14 * r * r return s 调用s函数:输入4,输出半径为4的圆的面积.a相当于面积的容器 a = s(4) print(a) 2.装饰器是用来装饰函数的函数.其需要输入的原材料为某个函数 以下是装饰器的固定格式: 1 def timer(func): 2 def inner(*args,**kwarg