python 函数 与 open打开文件的三种模式：r读、w写、a追加、_python open 追加

函数

# 条件判断 if elif else
# 循环语句：循环启动条件、循环结束条件
# while循环
# for循环  生成器 range()
# 终止循环，并且跳出整个循环 break
# 终止当前循环，跳出该次循环，执行下一次循环 continue
# 什么都不做 pass  是空语句，是为了保持程序结构的完整性
# 嵌套 循环-判断
# 导入模块

# 以上略过

# 函数

# 全局变量，在函数内的变量叫 局部变量
g = 11

# 注意位置顺序：不定长参数2 必须倒数第一，默认参数 必须倒数第二，其他无需考虑。
# a必需参数, *b不定长参数1, c关键字参数输入, d关键字参数， e默认参数, **f不定长参数2
def fun1(a, *b,  c, d: 0, e=0, **f):
    # 引用全局变量
    global g
    print(g)
    return a, b, c, d, e, f


a1 = fun1(1, [1, 2, 3], c=4, d=0, f=(1, 2, 3))
# print(a1)
# 必需参数
# 不定长参数1：定义参数时前面加一个*，表示这个参数是可变的，可以接受任意多个参数，这些参数构成一个元组，只能通过位置参数传递
# 不定长参数2：定义参数时，在前面加**，表示这个参数可变，可以接受任意多个参数，这些参数构成一个字典，只能通过关键字参数传递

# 特例：
# 参数随便输入
def fun(*args, **kwargs):
    return args, kwargs
s = fun("a", 1, None, a=1, b="2", c=3, d=0)
# 顺序输入为元组，关键字输入为字典
# (('a', 1, None), {'a': 1, 'b': '2', 'c': 3, 'd': 0})
print(s)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

使用open打开文件

# r只读，w写入，a追加

# 写入模式 w : 如果存在就原文件清空内容, 否则新建文件
fo = open("110.txt", "w", encoding="utf-8")  # 默认GBK编码 编码一定要一致

print("文件名: ", fo.name)
print("是否已关闭 : ", fo.closed)
print("访问模式 : ", fo.mode)
print("输出编码格式", fo.encoding)

# 写入
fo.write("a"*10)

# 关闭打开的文件
fo.close()
# 当我们写文件时，操作系统往往不会立刻把数据写入磁盘，而是放到内存缓存起来，空闲的时候再慢慢写入。
# 只有调用close()方法时，操作系统才保证把没有写入的数据全部写入磁盘同时释放资源。
# 忘记调用close()的后果是数据可能只写了一部分到磁盘，剩下的丢失了。

# 只读模式 r : 不能写入，会报错
fo = open("110.txt", "r", encoding="utf-8")
# 默认读取全部，输入数字可设定读取字符串长度
fo.read()
# 读取一行
fo.readline()
# 读取所有，返回列表
fo.readlines()

# 追加模式 a+ :打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。
# 文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
fo = open("110.txt", "a+", encoding="utf-8")
fo.write("2")


# 案例1：由于一次性读取大型文件时，非常占用内存，所以采用读取固定字节
fo = open("110.txt", "r")

while True:
    chunk = fo.read(10)
    print(chunk)
    if not chunk:
        break
# 关闭文件
fo.close()

# 案例2：由于一次性写入大型文件时，非常占用内存，所以需要立即写入，刷新缓冲
fo = open("110.txt", "a", encoding="utf-8")
txt1 = len("大型文件长度")
c = 0
while txt1 >= c:
    chunk = fo.write("大型文件拆分后的一部分\n")
    # 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
    fo.flush()
    c += 1
# 关闭文件
fo.close()


# 字符串需要转二进制：编码(.encode())、解码(.decode())
# 使用二进制进行写入
fo = open("111.txt", "wb")
# 编码
fo.write("文".encode())
fo.close()

# 使用二进制进行读取
fo = open("111.txt", "rb")
chunk = fo.read()
print(chunk.decode())
fo.close()

# ab 追加也差不多
fo = open("111.txt", "ab")
fo.write("文".encode())
fo.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

去除换行符与分割字符串

.strip("\n")
.split("根据什么分割")
1
2