Python学习笔记（第三天，文件操作、函数）

一、文件处理

　　1、文件打开模式

　　　打开文本的模式，默认添加t，需根据写入或读取编码情况添加encoding参数。

　　　r   只读模式，默认模式，文件必须存在，不能存在则报异常。

　　　w  只写模式，若文件不存在则创建，若文件已存在则清空内容，不可以读文件。

　　　a   追加模式，文件不存在则创建，若文件已存在则在文件末尾追加，不可以读文件。

　　   打开非文本的模式，使用“b”表示读取和写入需使用字节，不可指定编码。主要有rb、wb、ab三种模式。

　　2、操作文件方法

　　　读取文件

with open(‘test.txt‘,‘r‘,encoding="UTF-8") as f:
    print(f.read())          #读取文件全部内容
with open(‘test.txt‘, ‘r‘, encoding="UTF-8") as f:
    print(f.readlines())  # 读取文件每行内容，存入列表
with open(‘test.txt‘, ‘r‘, encoding="UTF-8") as f:
    print(f.readline())  # 读取文件一行内容
with open(‘test.txt‘,‘rb‘) as f:
    print(f.read())          #字节读取模式读取文件全部内容

　　　文件写入

with open(‘test1.txt‘,‘w‘,encoding="UTF-8") as f:
    f.write("hello world!\n")  #文本模式，需添加换行符
with open(‘test1.txt‘,‘w‘,encoding="UTF-8") as f:
    f.writelines(["hello\n","world\n"])  #文本模式，需添加换行符
with open(‘test1.txt‘,‘wb‘) as f:
    f.write("hello world".encode("utf-8"))  #b模式需对字符先编码
with open("test1.txt",‘wb‘) as f:
    f.writelines(["hello\n".encode("utf-8"),"world\n".encode("utf-8")]) #b模式需对字符串手动编码

　　其他操作

import time
f = open("test1.txt",‘w‘,encoding="UTF-8") #b模式没有encoding
print(f.writable())   #文件是否看可写
print(f.readable())   #文件是否可读
f.write("aa")
f.flush()    #立刻将文件内容从内容刷入硬盘
time.sleep(5)
f.close()       #文件关闭，无flush时，关闭文件内容才刷入硬盘

　　3.文件内光标的移动

　　1.read(3)

　　文件打开方式为文本时，代表读取三个字符。

　　文件打开方式为b时，代表读取三个字节。

　　2.除read外，其他文件光标移动均以字节为单位，入seek，tell，truncate

with open("test.txt",‘r‘,encoding="UTF-8") as f:
    f.seek(4,0)   #第一个参数表示移动的相对位置，第二个参数为0表示移动到文件开头，1表示就在当前位置，2表示移动到文件末尾
    print(f.read())
    print(f.tell())  #返回光标当前位置，执行为read()后为文件末尾
#truncate为截断文件，文件必须可写，不可使用w或w+模式，会清空文件，建议使用r+或者a或a+模式
with open("test.txt",‘r+‘,encoding="UTF-8") as f:
    f.truncate(7)    #截取前7个字节的内容。

　　4.文件的修改

　　方式一，将文件从硬盘读入内存，内存中修改完后，写入新文件后替换原文件。文件过大读入内存时会卡死。

import os
with open("test.txt",‘r‘) as read_f,open(".test.txt.swap",‘w‘) as write_f:
    data = read_f.read()
    data = data.replace("xxx","eee")   #字符不可变，需重新赋值给data
    write_f.write(data)
os.remove("test.txt")
os.rename(".test.txt.swap","test.txt")

　　方式二，将文件每行读入内存，按行修改，修改完后写入新文件，完成后替换原文件。

import os
with open("test.txt",‘r‘) as read_f,open(".test.txt.swap",‘w‘) as write_f:
    for line in read_f:
        if "xxx" in line:
            line = line.replace("xxx","eee")
        write_f.write(line)
os.remove("test.txt")
os.rename(".test.txt.swap","test.txt")

二、函数基础

　　使用函数的目的：解决代码组织结构不清晰、可读性差的问题；减少代码冗余；降低维护难度，提高可扩展性。

　　函数主要分为内置函数和自定义函数。

　　1.函数定义和调用

　　　定义函数

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

#函数名要能反映其意义

　　函数使用的原则为：先定义后使用

　　函数在定义阶段只检测语法，不执行代码，无法发现代码中的逻辑错误。

　　2.函数的参数

　　　位置参数：按照从左到右顺序定义的参数。

位置形参：必选参数

　　　 位置实参：按照位置给形参传值

　　     关键字参数：按照键值对形式定义的参数。

　　　  实参和形参位置不必一一对应

　　　　关键字实参必须在位置实参的右侧

　　　　对同一个形参不能重复传值

　　　　默认参数：形参在定义时已进行赋值

　　　　可已传值也可以不传，经常需要变的参数定义为位置形参，变化小的定义为默认形参

　　　　只在定义时赋值一次，且为不可变类型

　　　　默认参数定义在位置形参右侧

　　　　可变长参数：实参值个数不固定

　　　　使用*args接收位置实参，使用**kwargs接收关键字实参，*后的参数必须被传值，必须按照关键字实参的形式传递。

def func(*args,**kwargs):
    print(args,kwargs)
func(3,4,5,66,a=33,b="asf",c=222)   #前面的位置实参被args以元组方式接收，后面的关键字实参被kwargs以字典方式接收
def func(x,y,*args,a=1,b,**kwargs):
    print(x,y)
    print(args)
    print(a)
    print(b)
    print(kwargs)
func(1,2,3,4,5,b=3,c=4,d=5)

　

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

　 1.函数对象的特点：

　　可以被引用

　　可以当做参数传递

　　返回值可以是函数

　　可以当做容器类型的元素

def func1():
    print("from func1")
    return func2      #返回func2
def func2():
    print("from func2")
list = []
list.append(func1())  #返回func2作为列表元素
list[0]()         #执行func2

　　2.函数的嵌套

def func1():
    print("from func1")
    def func2():
        print("from func2")
        def func3():
            print("from func3")
        func3()
    func2()
func1()

　　3.名称空间和作用域

　　名称空间为内存中存放名字和值绑定关系的地方，如变量名和变量值的地址的对应关系。主要分为内置名称空间、全局名称空间和局部名称空间。

　　名称空间加载顺序为：

  • 　python解释器先启动时加载内置名称空间
  • 　执行py文件时，加载全局名称空间，程序结束运行后释放空间
  • 　执行文件过程中如果调用函数，临时产生局部名称空间，函数调用结束后释放空间

　　名字的查找顺序和加载顺序相反，为先局部名称空间，再全局名称空间，最后内置名称空间。全局无法查看局部，局部可以查看全局。

#优先在func()局部名称空间中找max，如果没有在全局找，如果还没有在返回内置名称空间中的max
max = 3
def func():
    max = 1
    print(max)
func()

　　全局作用域：包括内置名称和全局名称空间的名字，全局存活，全局有效,globals()

　　局部作用域：局部名称空间的名字，临时存活，局部有效，locals()

xxx=2222
yyy="dsfsf"
print(globals())
print(locals())   #全局作用域中调用locals()相当于调用globals()
def func():
    zzzzz=[1,2,3,4]
    print(locals())
print(globals())   #仅比前面的globals多了func函数名字，无func函数中定义的变量名字
func()

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

xxx = "abc"
def outter():
    def innner():
        print("inner",xxx)
    return innner
f = outter()
def bar():
    x=123456
    f()     #f()实际上就是inner(),调用时局部作用域中无xxx，则去全局作用域中找，无法调用bar()中的xxx
bar()

　　4.闭包函数

　　　闭包函数为定义在函数内部的函数，函数体代码保护对外部作用域（不是全局作用域）名字的引用，包在外面的函数通常将闭包函数用return返回，然后可以在任意使用。

z =1
def outter():
    x = 1
    y = 2
    def inner():
        print(x,y)
    return inner
f =outter()
print(f.__closure__[0].cell_contents)   #返回闭包函数中第一个引用外部名字的值

　　闭包函数主要作为用向函数传值。因为返回的函数对象包裹了一层作用域，无论在何处调用，优先使用自己外层的作用域。

#普通的调用方法，每次执行时需传入参数。
import requests
def get(url):
    response = requests.get(url)
    if response.status_code == 200:
        print(len(response.text))
get("https://www.baidu.com")
#使用闭包函数后，参数由外部函数传入，方便执行
import requests
def outter(url)
    def get():
        response = requests.get(url)
        if response.status_code == 200:
            print(len(response.text))
        return get
baidu = outter("https://www.baidu.com")
baidu()

　　5.装饰器

　　　装饰器可以是任意调用对象，被装饰者可以是任意可调用函数。

　　　装饰器原则为：不修改被装饰对象的源代码；不修改被装饰对象的调用方式。（即对修改封闭，对扩展开放）

　　　装饰器目标为在满足原则的条件下，为被装饰对象添加新功能。主要通过外层函数为内层函数传递被装饰函数，然后在内层函数中执行被装饰函数。

　　　无参数的装饰器：

import time
def index():
    time.sleep(3)
    print("welcome to index")

def outter(func):
    def inner():
        start = time.time()
        func()
        stop = time.time()
        print("run time is %s"%(stop-start))
    return inner

index = outter(index)
index()

　被修饰函数有参数的情况

import time
def index(name):
    time.sleep(3)
    print("welcome %s to index" % name)
def outter(func):
    def inner(*args,**kwargs):
        start = time.time()
        func(*args,**kwargs)
        stop = time.time()
        print("run time is %s" %(stop-start))
    return inner
index = outter(index)
index("xxx")

　　有参数装饰器，装饰器外层做多只需要两层，最内层传入被装饰函数的参数。外一层传入被装饰函数名，返回内层函数。最外层传入内层函数需要引入的其他参数，返回中间层的函数名。

def auth(driver=‘file‘):
    def auth2(func):
        def wrapper(*args,**kwargs):
            name = input("input user:")
            password = input("input password")
            if driver == "file":
                if name=="xxx" and password=="123":
                    print("login success")
                    return func(*args,**kwargs)
            elif driver == "ldap":
                print("ldap")
        return wrapper
    return auth2

@auth(driver="file")
def foo(name):
    print("welcome "+name)
foo("xxx")

　　装饰器语法

import time
def outter(func):
    def inner(*args,**kwargs):
        start = time.time()
        func(*args,**kwargs)
        stop = time.time()
        print("run time is %s" %(stop-start))
    return inner
@outter           #相当于index=outter(index),装饰器函数必须在被修饰函数上方定义
def index(name):
    time.sleep(3)
    print("welcome %s to index" % name)

#index = outter(index)
index("xxx")

　　装饰器补充：wraps

from functools import wraps

def deco(func):
    @wraps(func) #将传入被装饰函数的信息赋给内层函数，入帮助文档等。
    def wrapper(*args,**kwargs):
        return(func(*args,**kwargs))
    return wrapper
@deco
def index():
    "原始index的帮助文档"
    print("from index")
print(index.__doc__)

　　　　　

时间： 2024-10-08 02:05:31

Python学习笔记（第三天，文件操作、函数）的相关文章

python学习笔记——（三）文件操作

·集合操作及其相应的操作符表示集合中没有插入,只有添加,因为毕竟无序 #!/usr/bin/env python # -*- coding:utf-8 -*- # Author:Vergil Zhang list_1 = [1, 4, 5, 7, 3, 6, 7, 9] list_1 = set(list_1) print(list_1, type(list_1)) list_2 = set([2, 6, 0, 66, 22, 8]) print(list_1,list_2) #交集 print

python 学习笔记day02-python循环、文件、函数、模块

循环语句 while 循环 while 循环语法结构 当需要语句不断的重复执行时,可以使用 while 循环 while expression: while_sutie 语句 while_suite 会被连续不断的循环执行,直到表达式的值变成 0 或 False         #!/usr/bin/env python         # -- coding: utf-8 --         sum100 = 0         counter = 1         while count

Python学习笔记3：简单文件操作

# -*- coding: cp936 -*- # 1 打开文件 # open(fileName, mode) # 參数:fileName文件名称 # mode打开方式 # w     以写方式打开. # a     以追加模式打开 (从 EOF 開始, 必要时创建新文件) # r+     以读写模式打开 # w+     以读写模式打开 # a+     以读写模式打开 # rb     以二进制读模式打开 # wb     以二进制写模式打开 # ab     以二进制追加模式打开 # r

Python学习系列（五）(文件操作及其字典)

Python学习系列(五)(文件操作及其字典) Python学习系列(四)(列表及其函数) 一.文件操作 1,读文件 在以'r'读模式打开文件以后可以调用read函数一次性将文件内容全部读出,也可以指定每次read读多少字节,例如: 1 #coding:utf-8 2 fn='test1.py' 3 fp=open(fn,'r') #以读的方式打开文件,文件必须首先存在和,.文件在同一目录下py 4 print 'reading pos:',fp.tell() 5 r=fp.read(20) #

python学习列表字符串字典集合文件操作字符串编码与转换

一.列表 1 names = "ZhangYang GuYun XiangPeng XuLiangchen" 2 names = ["ZhangYang", "GuYun", "XiangPeng", "ChengRongHua","XuLiangchen"] 3 names.append("LeiHaiDong") #在列表最后追加一个元素 4 names.inse

Go语言学习笔记（五）文件操作

加 Golang学习 QQ群共同学习进步成家立业工作 ^-^ 群号:96933959 文件读取 os.File 封装了文件相关操作 type File File代表一个打开的文件对象. func Create(name string) (file *File, err error) Create采用模式0666(任何人都可读写,不可执行)创建一个名为name的文件,如果文件已存在会截断它(为空文件).如果成功,返回的文件对象可用于I/O:对应的文件描述符具有O_RDWR模式.如果出错,错误底层类

python学习点滴记录-Day02补充-文件操作

字符编码: 把人类的字符翻译成计算机能认识的数字 字符编码表 存放着人类字符和计算机数字的对应关系表 ascii.gbk.utf-8.unicode unicode>encode(utf8)>bytes bytes>decode(utf8)>unicode 文件处理补充: 字符以什么格式编码的,就要以什么格式解码 文件的打开模式 文件句柄 = open('文件路径', '模式') 打开文件时,需要指定文件路径和以何等方式打开文件,打开后,即可获取该文件句柄,日后通过此文件句柄对该文

PYTHON 之路 （二） 文件操作/函数/面向对象编程

文件操作 打开文件,得到文件句柄并赋值给一个变量 通过句柄对文件进行操作 关闭文件 打开文件的模式有: r,只读模式(默认). w,只写模式.[不可读:不存在则创建:存在则删除内容:] a,追加模式.[可读:   不存在则创建:存在则只追加内容:] "+" 表示可以同时读写某个文件 r+,可读写文件.[可读:可写:可追加] w+,写读 a+,同a "U"表示在读取时,可以将 \r \n \r\n自动转换成 \n (与 r 或 r+ 模式同使用) rU r+U &qu

C++ Primer学习笔记（三） C++中函数是一种类型！！！

C++中函数是一种类型!C++中函数是一种类型!C++中函数是一种类型! 函数名就是变量!函数名就是变量!函数名就是变量! 重要的事情要说三遍... 接 C++ Primer学习笔记(二) 类的构造函数 与类同名,且无返回类型. 同类的成员函数一样,也可以在类中声明,在类外定义. 格式: 类名(): 成员1(成员1初始化值), 成员2(成员2初始化值) { } 以上,冒号至大括号中间的部分,称为构造函数的初始化列表,用于调用类成员的构造函数来初始化. 没有在初始化列表中显式指定初始化的成员,将会

Python学习笔记__4.1章 高阶函数

# 这是学习廖雪峰老师python教程的学习笔记 1.概览 我们知道Python内置的求绝对值的函数是abs() # 调用abs()函数可以获得一个值 >>> abs(-10) 10 # 那么,只写abs本身呢 >>> abs <built-in function abs> 可见,abs(-10)是函数调用,而abs是函数本身 1.1.将函数赋给变量 将函数赋给变量只有两种情况: 把函数计算得到的 结果 赋给变量 f=abs(-10) 把 函数本身 赋给变量