Python入门基础知识点(文本操作)

文件操作基本流程

计算机系统分为：计算机硬件，操作系统，应用程序三部分。

我们用python或其他语言编写的应用程序若想要把数据永久保存下来，必须要保存于硬盘中，这就涉及到应用程序要操作硬件，众所周知，应用程序是无法直接操作硬件的，这就用到了操作系统。操作系统把复杂的硬件操作封装成简单的接口给用户/应用程序使用，其中文件就是操作系统提供给应用程序来操作硬盘虚拟概念，用户或应用程序通过操作文件，可以将自己的数据永久保存下来。

有了文件的概念，我们无需再去考虑操作硬盘的细节，只需要关注操作文件的流程：

#1. 打开文件，得到文件句柄并赋值给一个变量
f=open('a.txt','r',encoding='utf-8') #默认打开模式就为r

#2. 通过句柄对文件进行操作
data=f.read()

#3. 关闭文件
f.close()

f = open("D:\美女护士教师主妇联系方式.txt",encoding='utf-8',mode='r')
print(f.read())
f.close()
"""
f 变量: f,f1,file,file_handler,fh,f_h..... 文件句柄.
open() python的内置函数,python提供的一个功能,
底层调用的是操作系统的调用文件命令,接口.
windows: 编码:gbk.
linux,ms: 编码是utf-8.

操作文件的流程:
    1,打开文件,产生一个文件句柄.
    2, 对文件句柄进行相应的操作.
    3,关闭文件句柄.

 

很多人会忘记f.close(),，另一种操作方式：使用with关键字来帮我们管理上下文
with open('a.txt','w') as f:
    pass
 
with open('a.txt','r') as read_f,open('b.txt','w') as write_f:
    data=read_f.read()
    write_f.write(data)

文件的打开模式

#1. 打开文件的模式有(默认为文本模式)：
r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】
w，只写模式【不可读；不存在则创建；存在则清空内容】
a， 只追加写模式【不可读；不存在则创建；存在则只追加内容】

#2. 对于非文本文件，我们只能使用b模式，"b"表示以字节的方式操作（而所有文件也都是以字节的形式存储的，使用这种模式无需考虑文本文件的字符编码、图片文件的jgp格式、视频文件的avi格式）
rb 
wb
ab
注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码

#3,‘+’模式（就是增加了一个功能）
r+， 读写【可读，可写】
w+，写读【可写，可读】
a+， 写读【可写，可读】

#4，以bytes类型操作的读写，写读，写读模式
r+b， 读写【可读，可写】
w+b，写读【可写，可读】
a+b， 写读【可写，可读】

 

文件的追加
# a ab a+ a+b
# a 没有文件,创建文件,写入内容
# f = open('a模式',encoding='utf-8',mode='a')
# f.write('很多让人很有成就感的事情')
# f.write('很多让人很有成就感的事情')
# f.write('很多让人很有成就感的事情')
# f.close()

# f = open('a模式',encoding='utf-8',mode='a')
# f.write('666')
# f.close()

# read() readline readlines write close

 

文件的其他操作
# f1 = open('r模式',encoding='utf-8')
# # print(f1.read())
# # print(f1.fileno())  # 用不到
# f1.close()

# f1 = open('其他操作方法',encoding='utf-8',mode='w')
# f1.write('jfkdlsfjdsafkds')
# f1.flush()  # 强制保存
# f1.close()


#  readable writeable

# f1 = open('其他操作方法',encoding='utf-8')
# # print(f1.readable())  # True
# # f1.write('fdsafs')
# print(f1.writable())  # False
# if f1.writable():
#     f1.write('fhdsklafjds')
# f1.close()

# seek  tell
# 网络编程: FTP的作业,断点续传的功能. seek tell
# f1 = open('其他操作方法',encoding='utf-8')
# # f1.seek(9)  # 按照字节调整光标位置
# print(f1.tell())  # 获取光标的位置
# print(f1.read())
# print(f1.tell())
# f1.close()

# truncate  # 对原文件进行截取
# 他必须在可写情况下使用.

# f = open('其他操作方法',encoding='utf-8',mode='r+')
# f.seek(3)  # 调整光标对truncate不管用
# f.truncate(9)  # truncate都是从文件的开始进行截取,以字节为单位.
# f.close()

# 总结:
# 最常用的几个方法 read   seek  tell   flush  readable writeable



# 打开文件的第二种方式:

# 优点:
# 1,省去了写f.close()
# with open('其他操作方法',encoding='utf-8') as f1:
#     print(f1.read())

# 2,一个with语句可以操作多个文件句柄.

# with open('其他操作方法',encoding='utf-8') as f1,\
#         open('r模式',encoding='utf-8',mode='w') as f2:
#     print(f1.read())
#     f2.write('5435435')
#     f2.write('dhfjkdshjfdskhf')

# 缺点:

# IOError
with open('其他操作方法', encoding='utf-8') as f1:
    print(f1.read())
    # ******各种逻辑******
    f1.close()
    with open('其他操作方法', encoding='utf-8', mode='w') as f2:
        pass

 

文件的改
# 1,以读的模式打开原文件.
# 2,以写的模式创建一个新文件.
# import os
# with open('alex自述',encoding='utf-8') as f1,\
#     open('alex自述.bak',encoding='utf-8',mode='w') as f2:
# # 3,将原文件内容读取出来,按照你的要求改成新内容,写入新文件.
#     old_content = f1.read()
#     new_content = old_content.replace('alex','sb')
#     f2.write(new_content)
# # 4,删除原文件.
# os.remove('alex自述')
# # 5,将新文件重命名成原文件.
# os.rename('alex自述.bak','alex自述')

# 高大上版
#
# 1,以读的模式打开原文件.
# 2,以写的模式创建一个新文件.
# import os
# with open('alex自述',encoding='utf-8') as f1,\
#     open('alex自述.bak',encoding='utf-8',mode='w') as f2:
# # 3,将原文件内容读取出来,按照你的要求改成新内容,写入新文件.
#     for old_line in f1:
#         new_line = old_line.replace('alex','sb')
#         f2.write(new_line)
#
# # 4,删除原文件.
# os.remove('alex自述')
# # 5,将新文件重命名成原文件.
# os.rename('alex自述.bak','alex自述')

# ret = 'alex dfjaslkdf'
# print(ret.replace('太白','男神'))

深浅copy

# 赋值运算 变量指向的是同一个.
# l1 = [1, 2, 3, [11, 22]]
# l2 = l1
# # l2.append(666)
# l2[-1].append(666)
# # print(l1)
# # print(l2)
# print(l1)
# print(l2)


# 浅copy 列表举例
# dict set
# copy 复制, 浅浅的复制一份.
l1 = [1, 2, 3, [11, 22]]
l2 = l1.copy()

# print(l2)  # [1, 2, 3, [11, 22]]
# print(id(l1))
# print(id(l2))
# print(id(l1[0]))
# print(id(l2[0]))
# print(id(l1[-1]))
# print(id(l2[-1]))
# 给l1添加一个元素,l2 不变
# l1.append(666)
# l1[-1].append(666)
# print(l1)
# print(l2)

# l1 = [1, 2, 3, [11, 22]]
# l2 = l1.copy()
# l1[0] = 5
# print(l1)
# print(l2)
# 浅copy: 无论是同一个代码块,不同代码块下:
# 复制一个外壳(列表),但是列表里面的所有元素,都共用一个.


# 深copy : 深深的复制一下.
import copy
l1 = [1, 2, 3, [11, 22]]
l2 = copy.deepcopy(l1)
# print(l1)
# print(l2)
# print(id(l1),id(l2))
# 不可变数据类型  # 共用一份
# print(id(l1[0]))  # 1868196880
# print(id(l2[0]))  # 1868196880

# 可变的数据类型  重新创建一份
# print(id(l1[-1]))  # 2158525445320
# print(id(l2[-1]))  # 2158525446792

# l1[-1].append(666)
# print(l1)
# print(l2)


# 深copy: 论是同一个代码块,不同代码块下:
# 不仅创建一个新外壳(列表),外壳里面的可变的数据类型也创建一份新的,但是不可变的数据类型共用一个.


# 面试题
# l1 = [1, 2, [11,]]
# l2 = l1[:]  # 全切: 浅copy
# l1[-1].append(666)
# print(l2)


# l1 = [1, 2, [11,]]
# l2 = l1.copy()
# l1[-1].append(666)
# print(l2)

对于深copy来说，列表是在内存中重新创建的，列表中可变的数据类型是重新创建的，列表中的不可变的数据类型是公用的。