文件读写

文件的作用

就是把一些存储存放起来，可以让程序下一次执行的时候直接使用，而不必重新制作一份，省时省力。

文件的基础操作

打开文件：Python内置了一个open()方法，用于对文件进行读写操作。使用open()方法操作文件就像把大象塞进冰箱一 样，可以分三步走，一是打开文件，二是操作文件，三是关闭文件。 open()方法的返回值是一个file对象，可以将它赋值给一个变量（文件句柄）。

点击获取全套Python零基础入门资料

其基本语法格式为：

f = open(filename, mode)

filename 文件名称

mode 打开模式

打开模式常用的有 r(读模式,文件必须存在) w(写模式)，当然还有一些其他方式:

文件的关闭

f.close()

编码问题

要读取非UTF-8编码的文件，需要给open()函数传入encoding参数，例如，读取GBK编码的文件：

>>> f = open('gbk.txt', 'r', encoding='gbk') 
>>> f.read() 
'GBK'

遇到有些编码不规范的文件，可能会抛出 UnicodeDecodeError 异常，这表示在文件中可能夹杂了一些非法 编码的字符。遇到这种情况，可以提供errors参数，表示如果遇到编码错误后如何处理。

f = open('gbk.txt', 'r', encoding='gbk', errors='ignore')

文件对象操作

每当我们用open方法打开一个文件时，将返回一个文件对象。这个对象内置了很多操作方法。下面假设，已经打 开了一个f文件对象。

f.read(size)

读取一定大小的数据, 然后作为字符串或字节对象返回。size是一个可选的数字类型的参数，用于指定读取的数据 量。当size被忽略了或者为负值，那么该文件的所有内容都将被读取并且返回。

f = open("1.txt", "r") 
str = f.read() 
print(str) 

str = f.read() 
print(str) 

str = f.read(1) 
print(str) 

f.close()

f.readline()

从文件中读取一行n内容。换行符为’\n’。如果返回一个空字符串，说明已经已经读取到最后一行。这种方法，通 常是读一行，处理一行，并且不能回头，只能前进，读过的行不能再读了。

f = open("1.txt", "r") 
str = f.readline()
print(str) 
f.close()

f.readlines()

将文件中所有的行，一行一行全部读入一个列表内，按顺序一个一个作为列表的元素，并返回这个列表。 readlines方法会一次性将文件全部读入内存，所以也存在一定的风险。但是它有个好处，每行都保存在列表里， 可以随意存取。

f = open("1.txt", "r") 
a = f.readlines() 
print(a) 
f.close()

f.write()

将字符串或bytes类型的数据写入文件内。write()动作可以多次重复进行，其实都是在内存中的操作，并不会立 刻写回硬盘，直到执行close()方法后，才会将所有的写入操作反映到硬盘上。

# 打开一个文件 
f = open("foo.txt", "w") 
f.write("人生苦短我用Python!\n") 
# 关闭打开的文件 
f.close()

练习

创建两个文件，一个文件中放入'人生苦短 我用Python',一个文件读取刚才创建的文件内容。

读取大文件的处理方式。
比如一个文件很大，比如5G，怎么把文件的数据读取到内存然后进行处理呢？

while True: 
    content = filename.read(1024)       每次读取1024个字节 
    if len(content)==0:                 如果读取内容长度等于0，意味着文件读取完毕 
    break

文件的定位读写- f.seek()

f = open(filename) 
第一个参数 开始的偏移量，也就是代表需要移动偏移的字节数 
第二个参数   0 从文件开始读取   1 从当前位置去读    2 从文件末尾开始读取
f.seek(2,0) 
cont = f.readline() 打印出来的结果是从filename第二个字节开始的 
print(cont) 
con = f.read() 
print(con) 打印的剩下的所有内容

f.tell()

返回文件读写指针当前所处的位置,它是从文件开头开始算起的字节数。一定要注意了，是字节数，不是字符数。

f.close()

关闭文件对象。当处理完一个文件后，调用f.close()来关闭文件并释放系统的资源。文件关闭后，如果尝试再次 调用该文件对象，则会抛出异常。

点击获取全套Python零基础入门资料

with关键字

with关键字用于Python的上下文管理器机制。为了防止诸如open这一类文件打开方法在操作过程出现异常或错 误，或者最后忘了执行close方法，文件非正常关闭等可能导致文件泄露、破坏的问题 。Python提供了with这个 上下文管理器机制，保证文件会被正常关闭。在它的管理下，不需要再写close语句。注意缩进。

with open('test.txt', 'w') as f: 
    f.write('Hello, world!') 
with支持同时打开多个文件： 
with open('log1') as obj1, open('log2','w') as obj2: 
    s=obj1.read() 
    obj2.write(s)

文件的相关操作

修改文件名称 
import os 
os.rename(filename,newfilename) 
删除文件 
os.remove(filename) 
创建文件夹 
os.mkdir(dirname) 
获取当前目录 
os.getcwd() 
改变默认路径 
os.chdir("../") 
删除文件夹 
os.rmdir(dirname) 
列出当前目录下的文件 
os.listdir()

案例： 制作文件的备份

思路：
     获取要复制的文件名 
     打开这个文件 
     新建一个文件 
     读取旧文件 
     往新文件写 
     关闭两个文件 
filename = input("请输入要复制的文件名称:") 
f = open(filename,'r') 
content = f.read() 
position = filename.rfind(".") 
newfile = filename[:position]+ '(复件)' + filename[position:] 
r = open(newfile,'w') 
r.write(content) 
f.close() 
r.close()

案例： 批量重命名文件名称

import os 
# 获取重命名的文件夹 名称 
dir_name = input("请输入要重命名的文件夹:") 
# 获取文件夹中的所有文件名称 
filenames = os.listdir(dir_name) 
# 切换目录 如果不切换目录要在下面连接 
os.chdir(dir_name) 
for name in filenames: 
    # os.rename(dir_name+'/'+name,dir_name+'/'+"[芸芸]"+name) 
    os.rename(name,"[芸芸]"+name)

面向对象编程

面向对象编程：Object Oriented Programming，简称OOP，是一种程序设计方法。

面向对象面向过程区别

完成自我介绍功能，面向过程完成功能
stu_a = { 
    "name":"A" 
    "age":18, 
    "hometown":"东北"
}
stu_b = { 
    "name":"B" 
    "age":19, 
    "hometown":"山东" 
}
stu_c = { 
    "name":"C" 
    "age":20, 
    "hometown":"河北"
}
def stu_info(stu): 
    # 自我介绍 
    for key,value in stu.items(): 
        print("key=%s,value=%d"%(key,value))

stu_info(stu_a) 
stu_info(stu_b) 
stu_info(stu_c)

接下来我们用面向对象的思想来完成功能

stu_a = Student(个人信息)
stu_b = Student(个人信息) 
stu_c = Student(个人信息) 
stu_a.info() 
stu_b.info() 
stu_c.info()

文件读写 
f = open(path,'r') 
f.read() 
f.close()

面向过程：根据业务逻辑从上到下写代码,要面面俱到都要思考到
面向对象：将数据与函数绑定到一起，进行封装。
减少重复代码的重写过程,找一个能完成这个功能的哥们来完成 面向对象和面向过程都是解决问题的一种思路而已。

概念及术语

类(Class): 用来描述具有相同属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。其 中的对象被称作类的实例。

实例：也称对象。通过类定义的初始化方法，赋予具体的值，成为一个"有血有肉的实体"。

实例化：创建类的实例的过程或操作。

实例变量：定义在实例中的变量，只作用于当前实例。

类变量：类变量是所有实例公有的变量。类变量定义在类中，但在方法体之外。

数据成员：类变量、实例变量、方法、类方法、静态方法和属性等的统称。

方法：类中定义的函数。

静态方法：不需要实例化就可以由类执行的方法

类方法：类方法是将类本身作为对象进行操作的方法。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对父类的方法进行改写，这个过程也称 override。

封装：将内部实现包裹起来，对外透明，提供api接口进行调用的机制

继承：即一个派生类（derived class）继承父类（base class）的变量和方法。

多态：根据对象类型的不同以不同的方式进行处理。

类和实例

类

类是抽象的模板，用来描述具有相同属性和方法的对象的集合，比如Animal类。 类名通常采用驼峰式命名方 式，尽量让字面意思体现出类的作用。 Python使用class关键字来定义类，其基本结构如下：

class 类名(父类列表): 
    pass

类名通常采用驼峰式命名方式，尽量让字面意思体现出类的作用。Python采用多继承机制，一个类可以同时继承 多个父类（也叫基类、超类），继承的基类有先后顺序，写在类名后的圆括号里。继承的父类列表可以为空，此 时的圆括号可以省略。但在Python3中，即使你采用类似 class Student:pass 的方法没有显式继承任何父 类的定义了一个类，它也默认继承 object 类。因为， object 是Python3中所有类的基类。

class Student: 
    room = '102' 
    address = 'changsha' 

    def __init__(self, name, age): 
        self.name = name 
        self.age = age 

     def print_age(self): 
         print('%s: %s' % (self.name, self.age))

可以通过调用类的实例化方法（有的语言中也叫初始化方法或构造函数）来创建一个类的实例。默认情况下，使 用类似 obj=Student() 的方式就可以生成一个类的实例。但是，通常每个类的实例都会有自己的实例变量， 例如这里的name和age，为了在实例化的时候体现实例的不同，Python提供了一个 def init(self): 的实例化机制。任何一个类中，名字为 init 的方法就是类的实例化方法，具有 init 方法的类在实例化的时候，会自动调用该方法，并传递对应的参数。比如：

li = Student("juran", 24) 
zhang = Student("tony", 23)

实例变量和类变量

实例变量：

实例变量指的是实例本身拥有的变量。每个实例的变量在内存中都不一样。Student类中 init 方法里的 name和age就是两个实例变量。通过实例名加圆点的方式调用实例变量。

类变量：

定义在类中，方法之外的变量，称作类变量。类变量是所有实例公有的变量，每一个实例都可以访问、修改类变 量。在Student类中，classroom和address两个变量就是类变量。可以通过类名或者实例名加圆点的方式访问类 变量，比如：

Student.room 
Student.address 
li.room 
zhang.address

在使用实例变量和类变量的时候一定要注意，使用类似zhang.name访问变量的时候，实例会先在自己的实例变 量列表里查找是否有这个实例变量，如果没有，那么它就会去类变量列表里找，如果还没有，弹出异常。

类的方法：

Python的类中包含实例方法、静态方法和类方法三种方法。这些方法无论是在代码编排中还是内存中都归属于 类，区别在于传入的参数和调用方式不同。在类的内部，使用 def 关键字来定义一个方法。

实例方法

类的实例方法由实例调用，至少包含一个self参数，且为第一个参数。执行实例方法时，会自动将调用该方法的 实例赋值给self。 self 代表的是类的实例，而非类本身。 self 不是关键字，而是Python约定成俗的命 名，你完全可以取别的名字，但不建议这么做。

def print_age(self): 
        print('%s: %s' % (self.name, self.age)) 

# 调用方法 
li.print_age() 
zhang.print_age()

静态方法

静态方法由类调用，无默认参数。将实例方法参数中的self去掉，然后在方法定义上方加上@staticmethod，就 成为静态方法。它属于类，和实例无关。建议只使用类名.静态方法的调用方式。（虽然也可以使用实例名.静态方 法的方式调用）

class Foo: 
    
     @staticmethod 
     def static_method(): 
         pass 

#调用方法 
Foo.static_method()

类方法

类方法由类调用，采用@classmethod装饰，至少传入一个cls（代指类本身，类似self）参数。执行类方法时， 自动将调用该方法的类赋值给cls。建议只使用类名.类方法的调用方式。（虽然也可以使用实例名.类方法的方式 调用）

class Foo: 
  
    @classmethod 
    def class_method(cls): 
        pass 

Foo.class_method()