Python全栈之文件函数和函数参数

1. 文件相关函数

# ### 刷新缓冲区

"""

# 刷新缓冲区 flush

# 当文件关闭的时候自动刷新缓冲区

# 当整个程序运行结束的时候自动刷新缓冲区

# 当缓冲区写满了会自动刷新缓冲区

# 手动刷新缓冲区

"""

fp = open("ceshi1.txt",mode="a",encoding="utf-8")

fp.write("abc")

# 手动刷新缓冲区,直接把内容写入到文件

fp.flush()

while True:

pass

fp.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.函数基本格式

"""

# 定义一个函数

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)实参: 实际参数,在函数的调用处

形参的种类:

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 += 1

small_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 += 1

small_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) 普通收集形参: 专门用来收集那些多余的没人要的普通实参

收集之后,会把多余实参打包成一个元组

参数头上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) 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

小提示：

出现网络延迟堵塞的时候，自己用flush刷一下

strvar = alex Nb

# 注意：这里虽然说把首字母大写了，但是会把后面的大写字母变成小写

print(srvar.capitalize) #Alex nb

5. 小练习

练习问题：

#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的所有值列表}

练习答案：

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

# a

with open("a1.txt",mode="r",encoding="utf-8") as fp:

print(fp.read())

# b

with open("a1.txt",mode="a+",encoding="utf-8") as fp:

fp.write("\n\t信不信由你，反正我信了")

# c

with open("a1.txt",mode="a+",encoding="utf-8") as fp:

print(fp.read())

fp.write("\n\t信不信由你，反正我信了")

# d

strvar ="""

每天坚持一点，

每天努力一点，

每天多思考一点，

慢慢你会发现，

你的进步越来越大。

"""

with open("a1.txt",mode="w+",encoding="utf-8") as fp:

fp.write(strvar)

# e

with 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)

# #####################################

# a

with open("a4.txt",mode="r+",encoding="utf-8") as fp:

print(fp.readable())

print(fp.writable())

# b