文件处理+函数

文件处理

with open('a.txt',mode='r+t',encoding='utf-8') as f:
    print(f.writable())
    f.seek(7,0)
    f.write('SB')


with open('a.txt',mode='r+t',encoding='utf-8') as f:
    f.seek(3,0)
    f.write('h')

由上例得出结论：硬盘都是用新内容覆盖旧内容，没有修改的概念，但是内存是可以修改的
如何修改文件：
思路：把硬盘的内容先读入内存，然后在内存中修改完毕后，再覆盖会硬盘

方式一

1、先将硬盘中文件的内容全部读入内存，然后在内存中修改完毕得到一个修改好的结果

2、将修改的结果覆盖回原文件

优点: 不耗费硬盘
缺点：耗费内存

with open('a.txt',mode='rt',encoding='utf-8') as f1:
    data=f1.read()
    res=data.replace('lxx','SB')

with open('a.txt',mode='wt',encoding='utf-8') as f2:
    f2.write(res)

方式二

1、循环读取源文件内容，一行行修改一行行写入一个新的临时文件

2、删除源文件

3、将临时文件重命名为源文件名

优点：节省内存
缺点：耗费硬盘空间

import os
with open('a.txt',mode='rt',encoding='utf-8') as f1,\
        open('.a.txt.swp',mode='wt',encoding='utf-8') as f2:
    for line in f1:
        res=line.replace('SB','lxx')
        f2.write(res)

os.remove('a.txt')
os.rename('.a.txt.swp','a.txt')

函数

一、什么是函数

具备某一功能的工具===》函数

二、为何要有函数

1、程序的组织结构不清晰，可读性差

2、如果要用到重复的功能，只能拷贝功能的实现代码=》代码冗余

3、可扩展性差

三、如何用函数

1、定义函数

定义函数：申请内存空间把函数体代码保存下来，然后把内存地址绑定给函数名-》函数名=函数的内存地址

定义函数：
        def 函数名(参数1,参数2,参数3,...):
            """文档注释"""
            代码1
            代码2
            代码3
            ...
            return 返回值

1.无参函数
只返回值或者不返回值，不进行运算

def login():
    inp_name=input("your name: ").strip()
    inp_pwd=input("your pwd: ").strip()
    if inp_name == "egon" and inp_pwd == "123":
        print('login successful')
    else:
        print('login error')

login()


def sayhi():
    print('='*100)
    print('hello')
    print('='*100)

sayhi()

2.有参函数
函数里面有参数
参数就像工厂的流水线，可以定义无限个参数，我们根据函数的功能来决定是否调用参数

def sayhi(s,n):
    # s = '-'
    # n = 20
    print(s*n)
    print('hello')
    print(s*n)

sayhi('-',20)
sayhi('*',10)

def max2(x,y):
    # x=10
    # y=20
    if x > y:
        print(x)
    else:
        print(y)

max2(10,20)
max2(11,22)

3.空函数
通常在构建框架时使用

def func1():
	pass

2、调用函数

调用函数: 函数名()=> 函数的内存地址()，会触发函数体代码的运行

1、语句形式：单纯地调用一下函数就完了

def sayhi(s,n):
    # s = '-'
    # n = 20
    print(s*n)
    print('hello')
    print(s*n)

sayhi('*',30)

2、表达式形式
通过调用函数来对于函数返回的值进行后续的运算

def max2(x,y):
    if x > y:
        return x
    else:
        return y

res=max2(11,22) * 12
print(res)

3、可以把函数的调用当作值传给另外一个函数
相当于函数的嵌套（可以这样理解：函数和变量一样，总归是储存的一个值，可以当作一个变量来使用，只是一个可以内部运算然后返还值的变量）

print(max2(11,22))

总结

函数中参数的分类

参数：已经被赋值，或者还没有被赋值的变量名

一、形参

在定义函数时，括号内定义的变量名，称之为形式参数，简称形参=》变量名

位置形参

位置形参：在函数定义阶段按照从左到右的顺序依次定义形参（变量名），称之为位置形参
特点：必须被传值

二、实参

在调用函数时，括号内传入的值，称之为实际参数，简称实参=》变量值

1、位置实参数

位置实参：在函数调用阶段按照从左到右的顺序依次定义实参（传入的变量值），称之为位置实参
特点：按照位置传值，一一对应

2、关键字实参数

关键字实参：在函数调用阶段按照key=value的形式为指定的形参名传值，该形式称之为关键字实参
特点：在传值时可以完全打乱顺序，但是仍然能够指名道姓地为指定的形参传值

注意:可以混用位置实参与关键字实参,但是
1 位置实参必须放在关键字实参的前面
2 不能为同一个形参重复赋值

def func(name, age, salary):
    print(name)
    print(age)
    print(salary)


# func('egon',salary=3.1,age=18)
# func('egon',salary=3.1,18) # 错误
# func('egon', 18, salary=3.1)  # 错误

# func('egon',18,age=19,salary=3.3)

3、默认形参：在函数定义阶段就已经为某个形参赋值,该形参称之为有默认值的形参,简称默认形参
特点: 定义阶段就已经被赋值意味着在函数调用阶段可以不用为其赋值

注意:

1 默认形参应该放在位置形参的后面

def func(y=2,x): # 错误
    pass

2 默认形参的值通常应该是不可变类型

def func(name,hobby,hobbies=[]):
    hobbies.append(hobby)
    print("%s 的爱好是:%s" %(name,hobbies))

func("egon",'play')
func('lili','music')
func("jack",'read')

def func(name,hobby,hobbies=None):
    if hobbies is None:
        hobbies=[]
    hobbies.append(hobby)
    print("%s 的爱好是:%s" %(name,hobbies))

func("egon",'play')
func('lili','music')
func("jack",'read')

3 默认形参的值只在函数定义阶段被赋值一次,函数定义之后的改变对默认形参没有影响