大家好,又见面了,我是你们的朋友全栈君。
一、python文件操作
文件操作基本流程:
计算机系统分为:计算机硬件,操作系统,应用程序三部分。
我们用python或其他语言编写的应用程序若想要把数据永久保存下来,必须要保存于硬盘中,这就涉及到应用程序要操作硬件,众所周知,应用程序是无法直接操作硬件的,这就用到了操作系统。操作系统把复杂的硬件操作封装成简单的接口给用户/应用程序使用,其中文件就是操作系统提供给应用程序来操作硬盘虚拟概念,用户或应用程序通过操作文件,可以将自己的数据永久保存下来。
有了文件的概念,我们无需再去考虑操作硬盘的细节,只需要关注操作文件的流程:
方法一: #打开文件,得到文件句柄并赋值给一个变量 f = open('D:\code\\1.txt',encoding='utf-8',mode='r') #指定打开文件的自己,默认是以读模式打开 file = f.read() #通过句柄对文件进行操作 f.close() #关闭文件,使用该方法打开的文件,操作完成一定要进行关闭,不然会有内存溢出的风险 方法二: #次方法的优点不需要担心关闭文件,只要在with语句下的代码执行完毕后,该方法会自动帮你将文件关闭 with open('D:\code\st.txt','w') as f: f.write("hello") #绝对路径
文件打开方式:
#1. 打开文件的模式有(默认为文本模式): r ,只读模式【默认模式,文件必须存在,不存在则抛出异常】 w,只写模式【不可读;不存在则创建;存在则清空内容】 a, 只追加写模式【不可读;不存在则创建;存在则只追加内容】 注:正常工作中使用r、w、a这三种模式就完全够用了,不建议使用r+、w+等模式 #2. 对于非文本文件,我们只能使用b模式,"b"表示以字节的方式操作(而所有文件也都是以字节的形式存储的,使用这种模式无需考虑文本文件的字符编码、图片文件的jgp格式、视频文件的avi格式) rb wb ab 注:以b方式打开时,读取到的内容是字节类型,写入时也需要提供字节类型,不能指定编码 #3,‘+’模式(就是增加了一个功能) r+, 读写【可读,可写】 w+,写读【可写,可读】 a+, 写读【可写,可读】 #4,以bytes类型操作的读写,写读,写读模式 r+b, 读写【可读,可写】 w+b,写读【可写,可读】 a+b, 写读【可写,可读】
常用的文件操作方法:
f1 = open('空姐护士老师主妇.txt', encoding='utf-8', mode='r') content = f1.read() print(content) f1.close() # read 全部读出,强烈不建议使用该方法,因为该方法会将全部文件都加载到内存中,如果文件过大的话会撑爆内存 f1 = open('log1', encoding='utf-8') content = f1.read() # print(content) f1.close() #read(n) f1 = open('log1', encoding='utf-8') content = f1.read(5) # r 模式 按照字符读取。 print(content) f1.close() f1 = open('log1', mode='rb') content = f1.read(3) # rb模式 按照字节读取。 print(content.decode('utf-8')) f1.close() #readline()按行读取 f1 = open('log1', encoding='utf-8') print(f1.readline()) print(f1.readline()) print(f1.readline()) print(f1.readline()) f1.close() #readlines() 将每一行作为列表的一个元素并返回这个列表 f1 = open('log1', encoding='utf-8') print(f1.readlines()) f1.close() #for循环 f1 = open('log1', encoding='utf-8') for i in f1: print(i) f1.close() #我们在工作建议使用for循环的方法 #编码的补充: s1 = b'\xd6\xd0\xb9\xfa' s2 = s1.decode('gbk') s3 = s2.encode('utf-8') #将gbk编码转换为utf-8 print(s3) # b'\xe4\xb8\xad\xe5\x9b\xbd' s1 = b'\xd6\xd0\xb9\xfa'.decode('gbk').encode('utf-8') print(s1)
文件修改:
1,打开原文件,产生文件句柄。
2,创建新文件,产生文件句柄。
3,读取原文件,进行修改,写入新文件。
4,将原文件删除。
5,新文件重命名原文件。
#文件的数据是存放于硬盘上的,因而只存在覆盖、不存在修改这么一说,我们平时看到的修改文件,都是模拟出来的效果,具体的说有两种实现方式: 方式一:将硬盘存放的该文件的内容全部加载到内存,在内存中是可以修改的,修改完毕后,再由内存覆盖到硬盘(word,vim,nodpad++等编辑器) import os # 调用系统模块 with open('a.txt') as read_f,open('.a.txt.swap','w') as write_f: data=read_f.read() #全部读入内存,如果文件很大,会很卡 data=data.replace('Tom','jerry') #在内存中完成修改 write_f.write(data) #一次性写入新文件 os.remove('a.txt') #删除原文件 os.rename('.a.txt.swap','a.txt') #将新建的文件重命名为原文件 方法二:将硬盘存放的该文件的内容一行一行地读入内存,修改完毕就写入新文件,最后用新文件覆盖源文件 import os with open('a.txt') as read_f,open('.a.txt.swap','w') as write_f: for line in read_f: line=line.replace('Tom','jerry') write_f.write(line) os.remove('a.txt') os.rename('.a.txt.swap','a.txt')
二、函数
函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段。
函数能提高应用的模块性,和代码的重复利用率。你已经知道Python提供了许多内建函数,比如print(),len()等。但你也可以自己创建函数,这被叫做用户自定义函数。
#函数定义 def mylen(): """计算s1的长度""" s1 = "hello world" length = 0 for i in s1: length = length+1 print(length) #函数调用 mylen() #函数名+() 执行函数 #函数的返回值 return ''' 1,遇到return,结束函数。 def func1(): print(11) print(22) return print(333) print(444) func1() 2,给函数的调用者(执行者)返回值。 无 return 返回None return 不写 或者 None 返回None return 返回单个数. return 返回多个数,将多个数放在元组中返回。 '''
函数参数:
#函数定义 def mylen(s1): """计算s1的长度""" length = 0 for i in s1: length = length+1 return length #函数调用 str_len = mylen("hello world") print('str_len : %s'%str_len)
我们告诉mylen函数要计算的字符串是谁,这个过程就叫做 传递参数,简称传参,我们调用函数时传递的这个“hello world”和定义函数时的s1就是参数。
实参与形参
参数还有分别:
我们调用函数时传递的这个“hello world”被称为实际参数,因为这个是实际的要交给函数的内容,简称实参。
定义函数时的s1,只是一个变量的名字,被称为形式参数,因为在定义函数的时候它只是一个形式,表示这里有一个参数,简称形参。
传递多个参数
参数可以传递多个,多个参数之间用逗号分割。
def mymax(x,y): the_max = x if x > y else y return the_max ma = mymax(10,20) print(ma)
动态参数 *args,**kwargs 万能参数
三、命名空间和作用域
我们回忆一下python代码运行的时候遇到函数是怎么做的。
从python解释器开始执行之后,就在内存中开辟了一个空间
每当遇到一个变量的时候,就把变量名和值之间的对应关系记录下来。
但是当遇到函数定义的时候解释器只是象征性的将函数名读入内存,表示知道这个函数的存在了,至于函数内部的变量和逻辑解释器根本不关心。
等执行到函数调用的时候,python解释器会再开辟一块内存来存储这个函数里的内容,这个时候,才关注函数里面有哪些变量,而函数中的变量会存储在新开辟出来的内存中。函数中的变量只能在函数的内部使用,并且会随着函数执行完毕,这块内存中的所有内容也会被清空。
注:我们给这个“存放名字与值的关系”的空间起了一个名字——叫做命名空间
代码在运行伊始,创建的存储“变量名与值的关系”的空间叫做全局命名空间,在函数的运行中开辟的临时的空间叫做局部命名空间
命名空间与作用域:
命名空间一共分为三种:
全局命名空间
局部命名空间
内置命名空间
*内置命名空间中存放了python解释器为我们提供的名字:input,print,str,list,tuple…它们都是我们熟悉的,拿过来就可以用的方法。
三种命名空间之间的加载与取值顺序:
加载顺序:内置命名空间(程序运行前加载)->全局命名空间(程序运行中:从上到下加载)->局部命名空间(程序运行中:调用时才加载)
取值:
在局部调用:局部命名空间->全局命名空间->内置命名空间
作用域
作用域就是作用范围,按照生效范围可以分为全局作用域和局部作用域。
全局作用域:包含内置名称空间、全局名称空间,在整个文件的任意位置都能被引用、全局有效
局部作用域:局部名称空间,只能在局部范围内生效
globals和locals方法
def func(): a = 12 b = 20 print(locals()) print(globals()) func()
输出:
{‘b’: 20, ‘a’: 12}
{‘__name__’: ‘__main__’, ‘__doc__’: None, ‘__package__’: None, ‘__loader__’: <_frozen_importlib_external.SourceFileLoader object at 0x0578A590>, ‘__spec__’: None, ‘__annotations__’: {}, ‘__builtins__’: <module ‘builtins’ (built-in)>, ‘__file__’: ‘D:/Python/day4/练习.py’, ‘__cached__’: None, ‘func’: <function func at 0x0582B8E8>}
闭包
def func(): name = 'eva' def inner(): print(name)
闭包函数:
内部函数包含对外部作用域而非全剧作用域名字的引用,该内部函数称为闭包函数
#函数内部定义的函数称为内部函数
判断闭包函数的方法__closure__
#输出的__closure__有cell元素 :是闭包函数 def func(): name = 'eva' def inner(): print(name) print(inner.__closure__) return inner f = func() f() #输出的__closure__为None :不是闭包函数 name = 'egon' def func2(): def inner(): print(name) print(inner.__closure__) return inner f2 = func2() f2()
总结:
命名空间:
一共有三种命名空间从大范围到小范围的顺序:内置命名空间、全局命名空间、局部命名空间
作用域(包括函数的作用域链):
小范围的可以用大范围的
但是大范围的不能用小范围的
范围从大到小(图)
在小范围内,如果要用一个变量,是当前这个小范围有的,就用自己的
如果在小范围内没有,就用上一级的,上一级没有就用上上一级的,以此类推。
如果都没有,报错
函数的嵌套:
嵌套调用
嵌套定义:定义在内部的函数无法直接在全局被调用
函数名的本质:
就是一个变量,保存了函数所在的内存地址
闭包:
内部函数包含对外部作用域而非全剧作用域名字的引用,该内部函数称为闭包函数
转载于:https://www.cnblogs.com/watchslowly/p/8934381.html
发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/107560.html原文链接:https://javaforall.cn
【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛
【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...