## 复习
```python
'''
utf-8 | ASCII：ord() chr()
1. 模式：
主模式：
r：读，目标文件必须存在，不存在报错
w：写，目标文件不存在创建，存在清空
a：写，目标文件不存在创建，将游标移至末尾
x：写，必须自己创建文件，否则报错
从模式：
t：文本操作模式(默认)，要规定文本的编码格式utf-8
b：二进制操作模式，不需要规定文件的编码格式
+：可读可写模式
rt|rb|rt+|rb+ | w | a
seek(偏移量, 偏移起始位置)：要在b模式下操作，因为偏移量是按字节进行偏移
偏移量：正为右偏移，负为左偏移
偏移起始位置：0为文件开始 2为文件末尾 1为当期位置
flush(): 将内存中的数据刷新到硬盘中
close(): 1.将内存中剩余的数据刷新到硬盘中，2.释放文件资源
readable(): 可读
writable()：可写
'''
脚本执行：
python3 file_path argvs
# 自身创建文件操作流，可以清晰知道文件操作的模式
# 如果文件流是从外界获取来的
with open('temp.txt', 'r+', encoding='utf-8') as f:
print(f.readable())
print(f.writable())
pass
import sys
sys.argv => [file_path, argvs]
import sys
# 存放当前文件作为脚本文件执行的参数们：['当前文件的绝对路径', 手动传入的参数们]
# 脚本文件执行：直接用python解释器运行该文件
print(sys.argv)
# D:fullstack_s4day09代码 .复习.py
length = len(sys.argv)
if length > 1:
print("有指令传入")
cmd = sys.argv[1]
if cmd == '1':
print("新建文件")
# f = open('cmd.txt', 'w', encoding='utf-8')
# f.close()
with open(r'D:fullstack_s4day09代码cmd.txt', 'w', encoding='utf-8') as f:
pass
elif cmd == '2':
print("书写文件")
with open(r'D:fullstack_s4day09代码cmd.txt', 'w', encoding='utf-8') as f:
f.write("写入内容")
else:
print("指令有误")
else:
print("没有指令传入")
```
## 今日内容
```python
'''
函数四个组成部分
函数名：
函数体：
函数返回值：
函数参数：
1、函数的概念
2、函数的定义
3、从函数的组成部分来详解介绍
重点：定义函数的思想
'''
```
## 函数
```python
函数：
>>> 重复利用的工具
>>> 可以完成特定功能的代码块，函数就是存放代码块的容器
有点：
1. 避免代码的冗余
2. 让程序代码结构更加清晰
3. 让代码具有复用性，便于维护
```
## 定义函数的语法
- 函数四部分
```python
'''
1. 函数名：使用该函数的依据
2. 函数体：完成功能的代码块
3. 返回值：功能完成的反馈结果
4. 参数：完成功能需要的条件信息
'''
a = 10
ls = [1, 2, 3, 4, 5]
print(a)
# def fn:
# print('函数的一行代码')
# print('函数的二行代码')
# def: 声明函数的关键词
# fn: 函数(变量)名
# (): 参数列表，参数个数可以为0~n个，但()一定不能丢
# 函数体: 实现功能的具体代码
# return: 函数的返回值
def fn(money):
print('你付了%s元钱' % money)
print('函数的一行代码')
print('函数的二行代码')
return '冰红茶'
# fn直接打印，只能看到函数存放代码的地址
print(fn, id(fn))
print('--------------------------------------')
# 使用函数: 函数名()
fn(10)
print("把水喝了")
# 函数的返回值也称之为函数值，就是函数执行结束后的结果
# 可以用变量接受 | 可以直接打印 | 可以直接使用
msg = fn(10)
print(msg)
print('>>>>', fn(10) + '好喝')
# 函数执行的本质：执行函数体，得到函数返回值
```
- 用def关键词来声明函数
```python
def 函数名(参数们):
函数体
return '返回值'
```
## 如何使用函数
```python
'''
函数名：拿到函数的地址
函数名(): 拿到函数的地址，并执行函数中存放的代码块(函数体) *****
函数名(参数)：执行函数并传入参数
函数名(): 执行完毕后，会得到函数的返回值，返回值就跟普通变量一样，可以直接打印、使用、运算
'''
def fn(num):
print("传入的num值：%s" % num)
return '收到了'
res = fn(10)
# 控制台会打印：传入的num值：10
# res的值为：'收到了'
# 注：函数一定要先定义在调用
```
## 函数的分类
##### 根据参数列表划分
- 无参函数：不需外界资源
```python
def start():
print('系统启动')
start()
```
- 有参函数：需要外键资源
```python
def login(usr, pwd):
if usr == 'owen' and pwd == '123':
print('登录通过')
else:
print('登录失败')
login('owen', '123')
```
##### 根据返回值划分：return是用来结束函数的
- 空返回：返回None
```python
def demo(x, y):
print( x + y )
def demo(x, y):
print( x + y )
return # 用来强行结束函数的（像break结束循环一样）
# def fn1():
# print('fn1 run！！！')
#
# res = fn1()
# print('没有return关键字的返回值：%s' % res) # None
# def fn2():
# print('fn2 run！！！')
# # return
# # return None
# res = fn2()
# print('空return关键字的返回值：%s' % res) # None
# 无return函数与空return函数的区别
# 空return：可以根据具体情况主动退出函数（像break结束循环一样）
# def fn3(msg):
# print('fn3 第一行逻辑')
#
# # msg信息不正常：'' | None
# if msg == '' or msg is None:
# # 结束函数
# return
#
# print('msg信息正常: %s' % msg)
#
# msg = input('msg: ')
# fn3(msg)
```
- 一值返回
```python
def demo(x, y):
return x + y
def add_num(n1, n2):
return n1 + n2
print(add_num(10, 15))
def computed(n1, n2):
# 返回四则运算的结果
r1 = n1 + n2
r2 = n1 - n2
r3 = n1 / n2
r4 = n1 * n2
return [r1, r2, r3, r4]
a, b, c, d = computed(50, 25)
print(a, b, c, d)
```
- 多值返回
```python
def demo(x, y):
return x + y, x - y, x * y, x / y # 本质就是返回装有多个值的元组
def computed_sup(n1, n2):
# 返回四则运算的结果
r1 = n1 + n2
r2 = n1 - n2
r3 = n1 // n2
r4 = n1 ** n2
return r1, r2, r3, r4
a, b, c, d = computed_sup(50, 25)
print(a, b, c, d)
res = computed_sup(50, 25) # 得到的是装有所有结果的元组
print(res)
```
#### 从函数整体进行划分
```python
# 重点：先定义后使用
# computed()
# 计算
# 空函数：项目之初，知道项目有哪些功能，但还没有明确功能体，可以用pass进行函数体填充（罗列功能）
def computed():
pass
# 非空函数：用函数体（正常可以完成某项功能）
def add_num(n1, n2):
''' 函数的注释
:param n1: 第一个数
:param n2: 第二个数
:return: 两个数之和
'''
return n1 + n2
# print(a)
# a = 10
computed()
res = add_num(10, 20)
print(res)
a = 50
b = 100
print(add_num(a, b))
```
## 函数的嵌套调用
```python
# 求两个数最大值
def max_2(n1, n2):
if n1 > n2:
return n1
return n2
# 求三个
def max_3(n1, n2, n3):
m2 = max_2(n1, n2)
return max_2(m2, n3)
# 求四个
def max_4(n1, n2, n3, n4):
m2 = max_2(n1, n2)
return max_3(m2, n3, n4)
# 循环调用：在一个函数的内部调用另一个函数
# 函数的嵌套调用：在一个函数体重调用另一个函数
# 在解释过程中，不执行函数体，在函数被调用时，函数体才被执行
def fn1():
print('fn1 run')
fn2()
def fn2():
print('fn2 run')
fn3()
def fn3():
print('fn3 run')
# 注：在fn1中调用了fn2，所以调用fn1的逻辑应该在fn2定义之后
fn1()
# 案例：用函数实现获取两个数的最大值
def max_2(n1, n2):
if n1 > n2:
return n1
return n2
print(max_2(200, 30))
# 获取三个数的最大值
# def max_3(n1, n2, n3):
# if n1 > n2 and n1 > n3:
# return n1
# if n2 > n1 and n2 > n3:
# return n2
# return n3
def max_3(n1, n2, n3):
m2 = max_2(n1, n2)
return max_2(m2, n3)
print(max_3(300, 30, 30))
# 四个数呢？
def max_4(n1, n2, n3, n4):
m2 = max_2(n1, n2)
return max_3(m2, n3, n4)
print(max_4(10,30,20,0))
```
## 函数实现的登录注册
```python
'''
1.可以循环登录注册，输入1代表选择登录功能，输入2代表注册功能，输入0代表退出，其他输入代表输入有误，重输
2.用户的账号密码信息存放在usr.txt文件中，保证用户注册成功后，重启系统，用户信息仍然保存
3.登录在账号验证通过才输入密码验证登录，账号验证三次失败自动进入注册功能，登录三次验证失败自动退出系统
4.第一次注册，文件写入 账号:密码 信息，再次注册追加写入 |账号:密码 信息
'''
# 获取文件中用户信息
def get_usr_map():
pass
# 注册
def register():
print('注册页面')
pass
# 登录
def login():
print('登录页面')
pass
# 启动系统
def start():
print("系统启动！")
while True:
tag = input("""请输入操作指令：
0：退出
1：登录
2：注册
>>>: """)
if tag.isdigit():
tag = int(tag)
if tag == 0:
break
elif tag == 1:
login()
elif tag == 2:
register()
else:
print("输入有误，请重新输入")
# 启动系统
start()
```
## 指定文件名的文件复制
```python
# with open('001.jpg', 'rb') as r, open('100.jpg', 'wb') as w:
# for line in r:
# w.write(line)
#
# with open('001.jpg', 'rb') as r, open('200.jpg', 'wb') as w:
# for line in r:
# w.write(line)
def copy_img(target_img):
with open('001.jpg', 'rb') as r, open(target_img, 'wb') as w:
for line in r:
w.write(line)
copy_img('888.jpg')
copy_img('999.jpg')
def copy_file(source, target):
'''
:param source: 被复制的文件
:param target: 复制得到的文件
:return:
'''
with open(source, 'rb') as r, open(target, 'wb') as w:
for line in r:
w.write(line)
copy_file('cmd.txt', 'aaa.txt')
copy_file('temp.txt', 'ttt.txt')
```