1. 文件相关函数
|
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
|
# ### 刷新缓冲区"""# 刷新缓冲区 flush # 当文件关闭的时候自动刷新缓冲区 # 当整个程序运行结束的时候自动刷新缓冲区 # 当缓冲区写满了 会自动刷新缓冲区 # 手动刷新缓冲区""""""fp = open("ceshi1.txt",mode="a",encoding="utf-8")fp.write("abc")# 手动刷新缓冲区,直接把内容写入到文件fp.flush()while True: passfp.close()"""# ### 文件相关的函数"""fp这个对象本身是迭代器,可以把文件中的内容按照换行一行一行遍历出来""""""fp = open("ceshi1.txt",mode="r",encoding="utf-8")#readable() 功能: 判断文件对象是否可读print(fp.readable())#writable() 功能: 判断文件对象是否可写print(fp.writable())# 遍历fp文件对象for i in fp: print(i)"""# 1.readline() 功能: 读取一行文件内容'''with open("ceshi1.txt",mode="r",encoding="utf-8") as fp: res = fp.readline() print(res) res = fp.readline() print(res) res = fp.readline() print(res) res = fp.readline() print(res)# (1)一次把所有内容都读取出来with open("ceshi1.txt",mode="r",encoding="utf-8") as fp: # 先读取一行 res = fp.readline() # 判断是不是空,不是空在循环 while res: print(res) # 在读取一行,放到循环中判断. res = fp.readline()# (2)注意点:readline(读取的字符数)print("<====================>")with open("ceshi1.txt",mode="r",encoding="utf-8") as fp: """ 读取的字符数量 > 实际当前行字符数量的时候 => 按照当前行读取 读取的字符数量 < 实际当前行字符数量的时候 => 按照实际数量来读 """ res = fp.readline(300) print(res)'''print("<====================>")# 2.readlines() 功能：将文件中的内容按照换行读取到列表当中lst_new = []with open("ceshi1.txt",mode="r+",encoding="utf-8") as fp: lst = fp.readlines() for i in lst: lst_new.append(i.strip())print(lst_new) # 3.writelines() 功能：将内容是字符串的可迭代性数据写入文件中 参数:内容为字符串类型的可迭代数据lst = ['床前明月光', '疑是地上霜', '举头望明月', '低头想家乡']with open("ceshi2.txt",mode="w+",encoding="utf-8") as fp: fp.writelines(lst)# ### 实现效果:加入换行效果,并且插入一句话:王文真帅呀 , 插在低头想家乡的前面lst_new = []# 先把内容插入到原列表中lst.insert(-1,"王文真帅呀")# 循环原列表,把每一个元素拼接\n , 放到新列表for i in lst: lst_new.append(i + "\n")print(lst_new)# 把新列表中的每行内容插入到文件中with open("ceshi2.txt",mode="w+",encoding="utf-8") as fp: fp.writelines(lst_new)# 注意点,内容必须是字符串,不能是整型"""lst = [1,2,3]with open("ceshi2.txt",mode="w+",encoding="utf-8") as fp: fp.writelines(lst)"""# 4.truncate() 功能: 把要截取的字符串提取出来,然后清空内容将提取的字符串重新写入文件中 (字节)with open("ceshi2.txt",mode="r+",encoding="utf-8") as fp: fp.truncate(3)"""seek(字节)truncate(字节)read(字符/字节)readline(字符/字节)""" |
2. 函数_函数的参数
2.1 函数
|
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
|
# ### 函数"""概念:功能 (包裹一部分代码 实现某一个功能 达成某一个目的)特点:可以反复调用,提高代码的复用性,提高开发效率,便于维护管理"""# 1.函数基本格式"""# 定义一个函数def 函数名(): code1 code # 调用函数函数名()"""# 定义函数def func(): print("我是一个函数 ... ")# 调用函数func()# 2.函数的命名"""字母数字下划线,首字符不能为数字严格区分大小写,且不能使用关键字函数命名有意义,且不能使用中文哦驼峰命名法: (1) 大驼峰命名法: 每个单词的首字符要大写 (类的命名) mycar => MyCar (2) 小驼峰命名法: 除了第一个单词首字符小写外,剩下单词首字符大写 (函数或者变量) mycar => myCar_命名法:可以将不同的单词用_拼接在一起 mycar => my_car symmetric_differencesymmetricDifference SymmetricDifference"""# 函数定义def cfb_99(): for i in range(1,10): for j in range(1,i+1): print("{:d}*{:d}={:2d} ".format(i,j,i*j) ,end="") print()# 调用函数for i in range(5): cfb_99() |
2.2 函数的参数
|
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
76
77
78
79
80
81
82
83
|
# ### 函数的参数"""参数: 函数运算时需要的值参数种类: (1)形参: 形式参数,在函数的定义处 (2)实参: 实际参数,在函数的调用处形参的种类: 1.普通形参(位置形参) 2.默认形参 3普通收集形参 4.命名关键字形参 5.关键字收集形参实参的种类: 1.普通实参 2.关键字实参原则: 形参和实参要一一的对应"""# 1.普通形参(位置形参)# 定义函数"""hang,lie普通形参,在函数定义处"""def small_star(hang,lie): i = 0 while i < hang: j = 0 while j < lie: print("*",end="") j +=1 print() i += 1# 调用函数"""10,10普通实参,在函数的调用处"""small_star(10,10)small_star(2,3)# 2.默认形参 """hang,lie默认形参,在函数定义处""""""如果给予实参,那么使用实参如果没有给予实参,那么使用参数身上的默认值"""def small_star(hang=10,lie=10): i = 0 while i < hang: j = 0 while j < lie: print("*",end="") j +=1 print() i += 1small_star(4,8)small_star(8)small_star()# 3.普通形参 + 默认形参"""普通形参必须写在默认形参的前面不能调换位置"""def small_star(hang,lie=10): i = 0 while i < hang: j = 0 while j < lie: print("*",end="") j +=1 print() i += 1small_star(5,7)# small_star(5)# small_star() error# 4.关键字实参print("<=============>")"""1.如果都是关键字实参,可以任意调整实参的顺序2.普通实参必须写在关键字实参的前面"""def small_star(hang,a,b,c,lie=10): i = 0 while i < hang: j = 0 while j < lie: print("*",end="") j +=1 print() i += 1# hang a ... lie 具体指定参数的值叫做关键字实参,在函数的调用处;# small_star(hang=3,a=4,b=5,c=6,lie=7)# small_star(b=5,c=6,lie=7,a=4,hang=3)small_star(3,4,b=5,c=6,lie=7)small_star(3,4,b=5,lie=7,c=6)# small_star(b=5,c=6,lie=7,3,4) error |
3. 收集参数
|
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
|
# ### 收集参数"""(1) 普通收集形参: 专门用来收集那些多余的没人要的普通实参 收集之后,会把多余实参打包成一个元组 参数头上1个星星 def func(*args): pass args => arguments"""def func(a,b,c,*args): print(a,b,c) # 1 2 3 print(args) # (4,5,6)func(1,2,3,4,5,6)# 任意个数值得累加和def mysum(*args): total = 0 for i in args: total += i print(total)mysum(1,2,3,4,4,45,10,100)"""(2) 关键字收集形参:专门用来收集那些多余的没人要的关键字实参 收集之后,会把多余关键字实参打包成一个字典 参数头上有2个星星 def func(**kwargs): pass kwargs => keyword arguments"""def func(a,b,c,**kwargs): print(a,b,c) print(kwargs) # {'f': 100, 'e': 200, 'z': 12}func(c=1,a=3,b=10,f=100,e=200,z=12)# 拼接任意个数值变成字符串"""班长: 赵万里班花: 马春陪划水群众: 赵沈阳,李虎凌,刘子涛"""def func(**kwargs): strvar1 = "" strvar2 = "" # 定义职位信息 dic = {"monitor":"班长","classflower":"班花"} print(kwargs) # 共5次循环 for k,v in kwargs.items(): if k in dic: # 将2次循环的结果通过+= 拼接在一起 strvar1 += dic[k] + ":" + v + "\n" else: # 将3次循环的结果通过+= 拼接在一起 strvar2 += v + " , " print(strvar1.strip()) print("划水群众:",strvar2.strip(" , ")) """ # print(k,v) k v monitor 赵万里 classflower 马春陪 water1 赵沈阳 water2 李虎凌 water3 刘子涛 {'monitor': '赵万里', 'classflower': '马春陪', 'water1': '赵沈阳', 'water2': '李虎凌', 'water3': '刘子涛'} """func(monitor="赵万里",classflower="马春陪",water1="赵沈阳",water2="李虎凌",water3="刘子涛") |
4. 命名关键字_总结
|
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
76
|
# ### 命名关键字参数"""(1) def func(a,b,*,c,d) 跟在*号后面的c和d是命名关键字参数(2) def func(*args,e,**kwargs) 加在*args和**kwargs之间的参数都是命名关键字参数命名关键字参数 : 在调用函数时,必须使用关键字实参的形式来进行调用;"""# 定义方法一def func(a,b,*,c,d): print(a,b) print(c,d)# 必须指定关键字实参,才能对命名关键字形参进行赋值func(1,2,c=3,d=4)# 定义方法二def func(*args,e,**kwargs): print(args) # (1, 2, 3, 4) print(e) # 3 print(kwargs) # {'a': 1, 'b': 2}func(1,2,3,4,a=1,b=2,e=3)# ### 星号的使用"""* 和 ** 如果在函数的定义处使用: * 把多余的普通实参打包成元组 ** 把多余的关键字实参打包成字典* 和 ** 如果在函数的调用处使用: * 把元组或者列表进行解包 ** 把字典进行解包"""def func(a,b,*,c,d): print(a,b) print(c,d)tup = (1,2)# 函数的调用处 *号用法func(*tup,c=3,d=4) # func(1,2,c=3,d=4)# 函数的调用处 **号用法dic={"c":3,"d":4}func(1,2,**dic) # func(1,2,c=3,d=4)# 综合写法# 函数的调用处tup = (1,2)dic={"c":3,"d":4}func(*tup,**dic)# 定义成如下形式,可以收集所有的实参def func(*args,**kwargs): pass# 总结: 当所有的形参都放在一起的时候,顺序原则:""" 普通形参 -> 默认形参 -> 普通收集形参 -> 命名关键字形参 -> 关键字收集形参"""def f1(a, b, c=0, *args, **kw): print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)def f2(a, b, c=0, *, d, **kw): print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)# 以上两个函数 打印结果#(一)f1(1, 2) # a =1 b=2 c=0 args=() kw={}f1(1, 2, c=3) # a=1,b=2,c=3,args=() kw={}f1(1, 2, 3, 'a', 'b') #a=1 b=2 c=3 args=(a,b) kw={}f1(1, 2, 3, 'a', 'b', x=99) # a=1 b=2 c=3 args=(a,b) kw={x:99}f2(1, 2, d=99, ext=None)#a=1 b=2 c=0 d=99 kw={ext:None}#(二)args = (1, 2, 3, 4)kw = {'d': 99, 'x': '#'}# f1(1,2,3,4,d=99,x=#)f1(*args, **kw) # a=1 b=2 c=3 args=(4,) kw={d:99,x:#}#(三)myargs = (1, 2, 3)mykw = {'d': 88, 'x': '#'}# f2(1,2,3,d=88,x=#)f2(*myargs, **mykw) # a=1,b=2,c=3 d=88 kw={x:#}#(四)def f1(a, b, c=0, *args,d,**kw): print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw) print(d)f1(1,2,3, 'a', 'b',d=67, x=99,y=77) # a=1 b=2 c=3 args=(a,b) kw={x:99,y:77} # d=67 |
小提示：
|
1
2
3
4
|
出现网络延迟堵塞的时候，自己用flush刷一下strvar = alex Nb# 注意：这里虽然说把首字母大写了，但是会把后面的大写字母变成小写print(srvar.capitalize) #Alex nb |
5. 小练习
练习问题：
|
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
|
#1.有如下文件，a1.txt，里面的内容为： 键盘敲烂, 月薪过万. 键盘落灰, 狗屎一堆.分别完成以下的功能：a:将原文件全部读出来并打印。b:在原文件后面追加一行内容：信不信由你，反正我信了。c:将原文件全部读出来，并在后面添加一行内容：信不信由你，反正我信了。d:将原文件全部清空，换成下面的内容: 每天坚持一点， 每天努力一点， 每天多思考一点， 慢慢你会发现， 你的进步越来越大。e:将原文件内容全部读取出来， 并在'键盘落灰'这一行的前面加一行，'年薪百万' 然后将更改之后的新内容，写入到一个新文件：a1.txt。#2.有如下文件，t1.txt,里面的内容为： 葫芦娃，葫芦娃， 一根藤上七个瓜 风吹雨打，都不怕， 啦啦啦啦。 上面的内容你肯定是心里默唱出来的,对不对分别完成下面的功能：a:以r+的模式打开原文件，判断原文件是否可读，是否可写。b:以r的模式打开原文件，利用for循环遍历文件对象。c:以r的模式打开原文件，以readlines()方法读取出来，并循环遍历 d:以r模式读取‘葫芦娃，'前四个字符。e:以r模式读取第一行内容，并去除此行前后的空格，制表符，换行符。f:以r模式打开文件，从‘风吹雨打.....'开始读取，一直读到最后。g:以a+模式打开文件，先追加一行：‘老男孩教育'然后在全部读取出来。h:截取原文件，截取内容：‘葫芦娃，葫芦娃，' #3.文件a.txt内容：每一行内容分别为商品名字，价钱，个数。 apple 10 3 tesla 100000 1 mac 3000 2 lenovo 30000 3 chicken 10 3变成如下数据格式,并计算出总价格[ {'name':'apple','price':10,'amount':3}, {'name':'tesla','price':1000000,'amount':1}] #4.定义函数:打印用户传入的容器类型数据长度#5.定义函数:参数为容器类型数据,打印所有奇数位索引对应的元素#6.定义函数:,接收一个参数(可迭代性数据),用_让元素相连成字符串,打印出来#7.输入字符串 "k:1|k1:2|k2:3|k3:4" 处理成字典 {'k':1,'k1':2....} 打印出来#8.输入列表li= [11,22,33,44,55,66,77,88,99,90] # 将大于 66 的值保存至字典的k1键中， # 将小于 66 的值保存至字典的k2键中。 # 打印字典 {'k1': 大于66的所有值列表, 'k2': 小于66的所有值列表} |
练习答案：
|
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
# awith open("a1.txt",mode="r",encoding="utf-8") as fp: print(fp.read())# bwith open("a1.txt",mode="a+",encoding="utf-8") as fp: fp.write("\n\t信不信由你，反正我信了")# cwith open("a1.txt",mode="a+",encoding="utf-8") as fp: print(fp.read()) fp.write("\n\t信不信由你，反正我信了")# dstrvar =""" 每天坚持一点， 每天努力一点， 每天多思考一点， 慢慢你会发现， 你的进步越来越大。"""with open("a1.txt",mode="w+",encoding="utf-8") as fp: fp.write(strvar)# ewith open("a2.txt",mode="r+",encoding="utf-8") as fp: lst = fp.readlines() print(lst) # ['\t键盘敲烂,\n', '\t月薪过万.\n', '\t键盘落灰,\n', '\t狗屎一堆.\n'] lst.insert(-2,"\t年薪百万\n")with open("a3.txt",mode="w+",encoding="utf-8") as fp: fp.writelines(lst)# ###################################### awith open("a4.txt",mode="r+",encoding="utf-8") as fp: print(fp.readable()) print(fp.writable())# bwith open("a4.txt",mode="r",encoding="utf-8") as fp: for i in fp: print(i)# cwith open("a4.txt",mode="r",encoding="utf-8") as fp: lst = fp.readlines() for i in lst: print(i)# dwith open("a4.txt",mode="r",encoding="utf-8") as fp: print(fp.read(4))# ewith open("a4.txt",mode="r",encoding="utf-8") as fp: print(fp.readline().strip())# fprint("<====>")with open("a4.txt",mode="r",encoding="utf-8") as fp: lst = fp.readlines() for i in lst[-2:]: print(i)# gwith open("a4.txt",mode="a+",encoding="utf-8") as fp: fp.write("\n老男孩教育") fp.seek(0) print(fp.read())# hwith open("a4.txt",mode="r+",encoding="utf-8") as fp: fp.truncate(24) # #####################################"""['\tapple 10 3\n', '\ttesla 100000 1\n', '\tmac 3000 2\n', '\tlenovo 30000 3\n', '\tchicken 10 3']"""print("><======================?")lst_new = []total = 0with open("a5.txt",mode="r+",encoding="utf-8") as fp: lst = fp.readlines() # print(lst) for i in lst: # 定义空字典 dic = {} # 取出字符串两边的空白 lst = i.strip().split() print(lst) # 拼装字典 dic["name"] = lst[0] dic["price"] = int(lst[1]) dic["amount"] = int(lst[2]) # 累计当前商品的价格总数 res = dic["price"] * dic["amount"] # 累计所有的商品价格总数 total += res # 把当前商品的信息字典追加到列表中 lst_new.append(dic)print(total)print(lst_new)"""[{'name': 'apple', 'price': 10, 'amount': 3}, {'name': 'tesla', 'price': 100000, 'amount': 1}, {'name': 'mac', 'price': 3000, 'amount': 2}, {'name': 'lenovo', 'price': 30000, 'amount': 3}, {'name': 'chicken', 'price': 10, 'amount': 3}]"""# 4.def func(container): return len(container)res = func((1,2,3,4))print(res)# 5.def func(container): # 方法一 # for i in range(1,len(container),2): # print(container[i]) # 方法二 for i in container[1::2]: print(i)func([11,22,33,44,55,666])# 6.def func(container): """ # 方法一 strvar = "" for i in container: strvar += str(i) + "_" return strvar.rstrip("_") """ # 方法二 lst_new = [] for i in container: lst_new.append(str(i)) return "_".join(lst_new)container = [1,2,3,4,5]res = func(container)print(res)# 7strvar = "k:1|k1:2|k2:3|k3:4"def func(strvar): ''' # 方法一 lst = strvar.split("|") print(lst) # ['k:1', 'k1:2', 'k2:3', 'k3:4'] dic = {} for i in lst: k,v = i.split(":") dic[k] = v """ ['k', '1'] ['k1', '2'] ['k2', '3'] ['k3', '4'] """ return dic ''' # 方法二 lst = strvar.split("|") lst_new = [] for i in lst: lst_new.append(i.split(":")) return dict(lst_new) print(func(strvar))# 8li= [11,22,33,44,55,66,77,88,99,90]lst1 = []lst2 = []dic = {"k1":None,"k2":None}def func(li): for i in li: if i > 66: lst1.append(i) elif i < 66: lst2.append(i) dic["k1"] = lst1 dic["k2"] = lst2 return dicres = func(li)print(res) |
总结
本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注服务器之家的更多内容!
原文链接：https://blog.csdn.net/weixin_46818279/article/details/121005991
