python学习第三天-文件的操作和函数
python的文件操作
open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True)
'r' open for reading (default)
'w' open for writing, truncating the file first
'x' create a new file and open it for writing
'a' open for writing, appending to the end of the file if it exists
'b' binary mode
't' text mode (default)
'+' open a disk file for updating (reading and writing)
'U' universal newline mode (deprecated)
The default mode is 'rt' (open for reading text). For binary random access, the mode 'w+b' opens and truncates the file to 0 bytes, while 'r+b' opens the file without truncation. The 'x' mode implies 'w' and raises an `FileExistsError` if the file already exists.
默认模式是“rt”(打开阅读文本)。二进制随机访问的模式“w + b”打开,文件截断为0字节,而“r + b”打开文件没有截断。“x”模式意味着“w”,提出了一个“FileExistsError”如果文件已经存在。
r模式打开文件：
f = open('a.txt',mode='r',encoding='utf-8')
print(type(f))
data = f.read()
f.close()
print(data)
输出：
<class '_io.TextIOWrapper'>
dsdsdsds
sdsdsd
jjjjjj
222222
fdsdsd\n333434343
w模式打开文件
f = open('b.txt',mode='w',encoding='utf-8')
data = f.write('hehehhe\n天气真好\t晴\n')
f.close()
with open('b.txt',mode='r',encoding='utf-8') as f:
print(f.read())
输出：
hehehhe
天气真好 晴
x模式打开文件（当文件存在时）
f = open('b.txt',mode='x',encoding='utf-8')
data = f.write('hehehhe\n天气真好\t晴')
f.close()
print(data)
输出：
Traceback (most recent call last):
File "E:/PycharmProjects/s17/day03/test.py", line 16, in <module>
f = open('b.txt',mode='x',encoding='utf-8')
FileExistsError: [Errno 17] File exists: 'b.txt'
x模式打开文件（文件不存在）
f = open('c.txt',mode='x',encoding='utf-8')
data = f.write('hehehhe\n天气真好\t晴')
f.close()
f = open('c.txt',mode='r',encoding='utf-8')
data = f.read()
f.close()
print(data)
输出：
hehehhe
天气真好 晴
a模块打开文件
f = open('b.txt',mode='r',encoding='utf-8')
data = f.read()
f.close()
print(data)
f = open('b.txt',mode='a',encoding='utf-8')
data = f.write('etstetd')
f.close()
print(data)
f = open('b.txt',mode='r',encoding='utf-8')
data = f.read()
f.close()
print(data)
输出：
hehehhe
天气真好
7
hehehhe
天气真好etstetd
以b模式打开
f = open('b.txt',mode='r',encoding='utf-8')
data = f.read()
f.close()
print(data)
f = open('b.txt',mode='r+b')
data = f.read()
f.close()
print(data)
输出：
哈罗
b'\xe5\x93\x88\xe7\xbd\x97'
以r+模式打开
f = open('b.txt',mode='r+',encoding='utf-8')
data = f.read()
print(data)
f.seek(0)
data = f.write('测试')
f.close()
f = open('b.txt',mode='r',encoding='utf-8')
data = f.read()
f.close()
print(data)
输出：
哈罗
测试
文件的替换操作：
f1 = open('a.txt',mode='r',encoding='utf-8')
f2 = open('a.swap',mode='w',encoding='utf-8')
data = f1.readlines()
print(data)
i = 0
while i< len(data):
if data[i].startswith('1111'):
data[i] = '222222\n'
i += 1
print(data)
f2.writelines(data)
f1.close()
f2.close()
import os
os.remove('a.txt')
os.rename('a.swap','a.txt')
输出：
['dsdsdsds\n', 'sdsdsd\n', 'jjjjjj\n', '111111111\n', 'fdsdsd\\n333434343']
['dsdsdsds\n', 'sdsdsd\n', 'jjjjjj\n', '222222\n', 'fdsdsd\\n333434343']
#思路二
import os
read_f=open('b.txt','r')
write_f=open('.b.txt.swap','w')
for line in read_f.readlines():
if line.startswith('1111'):
line='2222222222\n'
write_f.write(line)
read_f.close()
write_f.close()
os.remove('b.txt')
os.rename('.b.txt.swap','b.txt')
Python 函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
定义一个函数
你可以定义一个由自己想要功能的函数，以下是简单的规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
函数的结构
def functionname( parameters ):
"函数_文档字符串"
function_suite
return [expression]
#定义函数的三种形式
一：无参数函数：如果函数的功能仅仅只是执行一些操作而已，就定义成无参函数，无参函数通常都有返回值
def print_star():
print('#'*6)
二：定义有参函数:函数的功能的执行依赖于外部传入的参数，有参函数通常都有返回值
def my_max(x,y):
res=x if x >y else y return res
#三元表达式
x=10
y=2
if x > y:
print(x)
else:
print(y)
res=x if x > y else y print(res)
函数调用
定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
如下实例
def print_star(num):
i = j = k = 1
for i in range(0, num):
for k in range(0, num - i):
print("*",end='')
k += 1
i += 1
print('')
print_star(3)
输出：
***
**
*
def foo():
print('from foo')
def bar(name):
print('bar===>',name)
#按照有参和无参可以将函数调用分两种
foo() #定义时无参，调用时也无需传入参数
bar('egon') #定义时有参，调用时也必须有参数
#按照函数的调用形式和出现的位置，分三种
foo() #调用函数的语句形式
def my_max(x,y):
res=x if x >y else y
return res
res=my_max(1,2)*10000000 #调用函数的表达式形式
print(res)
def my_max(x,y):
res=x if x >y else y
return res
res=my_max(my_max(10,20),30) #把函数调用当中另外一个函数的参数
print(res)
返回值
def foo():
print('from foo')
return None
res=foo()
print(res)
以三种情况返回值都为None：
没有return
return 什么都不写
return None
def foo():
print('from foo')
x=1
return 1,[2,3],(4,5),{}
print(foo())
输出：
from foo
(1, [2, 3], (4, 5), {})
参数
以下是调用函数时可使用的正式参数类型：
必备参数
关键字参数
默认参数
不定长参数
必备参数
必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用printme()函数，你必须传入一个参数，不然会出现语法错误：
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名：
缺省参数
调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：
不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下：
匿名函数
python 使用 lambda 来创建匿名函数。
lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
例子：
def foo(x,y,z):
print('from foo',x,y,z)
def wrapper(*args,**kwargs):
print(args)
print(kwargs)
wrapper(1,2,3,a=1,b=2)
输出：
(1, 2, 3)
{'a': 1, 'b': 2}
def foo(x,y,z):
print('from foo',x,y,z)
def wrapper(*args,**kwargs):
print(args) #args=(1,2,3)
print(kwargs) #kwargs={'a':1,'b':2}
foo(*args,**kwargs) #foo(*(1,2,3),**{'a':1,'b':2}) #foo(1,2,3,b=2,a=1)
wrapper(1,z=2,y=3)
def foo(x,y,z):
print('from foo',x,y,z)
def wrapper(*args,**kwargs):
# print(args) #args=(1,)
# print(kwargs) #kwargs={'y':3,'z':2}
foo(*args,**kwargs) #foo(*(1,),**{'y':3,'z':2}) #foo(1,z=2,y=3)
# wrapper(1,2,3,a=1,b=2)
wrapper(1,z=2,y=3)
浙公网安备 33010602011771号