# 1.函数:
# 函数的定义
# 函数的参数
# 位置参数
# 关键字参数
# 混合参数
#
# 形参的位置上(默认参数)
# 实参的位置上(关键字参数)
# 位置参数 > 默认参数
# 三元运算符:
# c = a if a>b else b
# 函数的返回值:
# 1.没有写return 返回的是None
# 2.写了return 没写返回值也是None
# 3.写了一个值是它本身,多个返回的是一个元组
# 4.return 下面的代码不执行 #4,5再函数中
# 5.当函数执行到return就结束这个函数
# 返回值返回给调用者?? 函数名+() 就是调用者
# 传参: 将实参传递给形参的过程
# 函数执行流程:
# 1.定义函数
# 2.开辟内存
# 3.调用函数
# 4.执行函数体
# 5.销毁函数开辟的内存
# li = [1,23]
# def func(li):
# print(li) #'啊啊啊'
#
# func('啊啊啊')
# def func(argv):
# argv = 123
# print(argv)
# pass
#
# func(123)
# 作业讲解:
'''7.写函数，检查传入字典的每一个value的长度,如果大于2，
那么仅保留前两个长度的内容，并将新内容返回给调用者。
dic = {"k1": "v1v1", "k2": [11,22,33,44]}
PS:字典中的value只能是字符串或列表'''
# dic={"k1": "v1v1", "k2": [11, 22, 33, 44]}
# def aaa(d):
# for k,v in d.items():
# if len(v) > 2:
# d[k] = v[0:2]
# return d
# ret = aaa(dic)
# print(ret)
# print(dic)
import os
'''
9.写函数，函数接收四个参数分别是：姓名，性别，年龄，学历。
用户通过输入这四个内容，然后将这四个内容传入到函数中，
此函数接收到这四个内容，将内容追加到一个student_msg文件中。
'''
# def s(name,sex,age,level): # 形参 接受
# with open('student_msg','a',encoding='utf-8')as f:
# f.write(f'{name},{sex},{age},{level}
')
# name = input('name:')
# sex = input('sex:')
# age = input('age:')
# level = input('level:')
# s(name,sex,age,level) # 实参 传入
# 3种:
# %
# fromat
# f
# name = '粉葛'
# a = f'{name},你好'
# %s
# s = '请输入内容:'
# def s(name,sex,age,level): # 形参 接受
# sex='男' if sex == '' else sex
# with open('student_msg','a',encoding='utf-8')as f:
# f.write(f'{name},{sex},{age},{level}
')
#
#
# def q(name): # 名字,性别,年龄
# if name.upper() == 'Q':
# exit()
#
#
# flag = True
# while flag:
# name = input('name(Q/退出):')
# q(name)
# sex = input('sex(Q/退出)[男性直接回车]:')
# q(sex)
# age = input('age(Q/退出):')
# q(age)
# level = input('level(Q/退出):')
# q(level)
# s(name,sex,age,level) # 实参 传入
'''
11.写函数，用户传入修改的文件名，
与要修改的内容，执行函数，完成整个文件的批量修改操作（升级题）。
'''
# def func(file_name,old,new):
#
# with open(file_name,'r',encoding='utf-8')as f,
# open(f'new_{file_name}','w',encoding='utf-8')as f1:
# for line in f:
# line = line.replace(old,new)
# f1.write(line)
# os.remove(file_name)
# os.rename(f'new_{file_name}',file_name,)
#
# func('student_msg','sb','alex')
# alt + 回车
动态参数：
def func(): # 形参
pass
func() # 实参
def func(a,b,c,*args): # 在形参位置*叫做聚合
print(a,b,c)
print(args) # 元组形式
func(1,2,3,4,5,9,6,7,8)
位置参数 > 动态的位置参数
def func(**kwargs): # 动态默认参数 #形参的时候**聚合
print(kwargs) # 字典
func(a=1,b=2,c=3) # 关键字的形式传参
def func(a,b,c,*args,x=1,y=1,z=1,**kwargs):
print(a,b,c)
print(args,kwargs)
print(x, y, z)
# 1 2 3
# (1,2,3,4,5)
# 1 1 1
# {'a': 1, 'b': 1, 'c': 1}
func(1,2,3,4,e=1,f=2,g=3)
def func(a,b,c,*args,x=1,y=1,z=1,**kwargs):
print(a,b,c) # 123
print(args,kwargs) # () {}
print(x, y, z) #1 1 1
# 1 2 3
# (1,2,3,4,5)
# 1 1 1
# {'a': 1, 'b': 1, 'c': 1}
func(1,2,3,4,a=1,b=2,c=3)
def func(*args,**kwargs):
print(args,kwargs) # args = () kwargs = {}
func(1,2,3,a=4,b=5)
def func(*args,**kwargs):
print(args,kwargs) # args = () kwargs = {'a':4,'b':5}
func(a=4,b=5)
def func(*args,**kwargs):
print(args,kwargs) # args = (1,2,3) kwargs = {}
func(1,2,3)
def func(*args,**kwargs): # * 聚合
print(*args) # args = () *args = 1 2 3 *打散
print(*kwargs) # args = () **kwargs = 1 2 3 *打散 字典的键
func(1,2,3,a=4,b=5)
li = [1,2,3,5,4]
def func(*args): # 聚合 (1,2,3,5,4)
print(args)
print(*args) # 打散 1,2,3,5,4
func(*li) # 1,2,3,5,4
def func(*args,**kwargs): # 聚合 (1,2,3,5,4)
print(args,*kwargs) # print('a','b')
func(**dic) # 1,2,3,5,4
dic = {'a':1,'b':2}
def func(*args,**kwargs): # 聚合 (1,2,3,5,4)
print(args,*kwargs) # a=1,b=2 #####特别特别注意
func(*[1,2,3],dic) # func(a=1,b=2)
print('a','b')
print(a=1,b=2)
li = [1,2,3,4]
args和 kwargs 是可以更换的,但是程序员约定都用它
用途:在不明确接受参数,数量时使用*args和**kwargs
动态位置参数 > 动态关键字参数
形参: 位置 > 动态位置 > 默认参数 > 动态默认参数
实参: 位置 > 关键字参数
在实参调用的时候 *将可迭代的对象打散,字典是将键取出
在形参处出现*就是在聚合
在实参调用的时候 **将字典打散成 关键字参数(键=值)
在形参处出现**就是将关键字参数聚合成一个字典
def func(a,**kwargs):
print(a)
# **kwargs # a=1,b=2
b = **kwargs
func(**{'a':1}) # func(a=1)
函数注释:
def aaa(user,pwd):
"""
登录函数
:param user: 用户名
:param pwd: 密码
:return: 校验后的账号和密码
"""
print(111)
print(aaa.__doc__)
简单了解
print(aaa.__name__) # 反射
名称空间：
1.内置空间中所有代码 -- 内置空间
2.自己写的py文件 -- 全局空间
3.函数中的代码 -- 局部空间
a = 10
def func():
print(a)
func()
# 加载顺序:
'''
1.内置空间
2.全局空间
3.局部空间
'''
# 取值顺序:
'''
1.局部空间
2.全局空间
3.内置空间
4.找不到就报错
'''
作用域:
'''
1.全局作用域 内置+全局 = 全局作用域
2.局部作用域 函数内的就是局部作用域
'''
a = 10
def func():
global a # (声明)我要修改a 找到要a
a+=1 # 修改
func()
print(a)
def func():
global a #(声明我要修改a,找不到a的时候在全局创建一个 a=0)
a = 1 # a = 1
func()
print(a)
函数的嵌套:
第一种函数嵌套 在函数func内
def func():
print(3)
def f():
print(1)
print(2)
f()
func()
第二种函数嵌套 多个函数嵌套调用
def func2():
print(1)
log()
def func1():
print(3)
def log():
func1()
print(6)
def fun():
print(7)
def func():
a = 1
def log():
a = 5
def info():
a = 10
print(a)
print(a)
print(a)
func()
def func():
a = 1
def log():
a = 5 # a = 15
def info():
nonlocal a # 声明修改log函数下边的变量a
a += 10 # a = a + 10 a = 15
print(a) # 15
info()
print(a) # 15
log()
print(a) # 1
func()
在一个局部空间内,nonlocal会修改离他最近的那个变量,如果上一层
没有就继续向上找,直到走到局部空间头部
def f():
def a1():
def l():
nonlocal a
a = 8
print(a)
l()
print(a1())
f()
global : 在局部修改全部变量,如果没有就创建一个新的
nonlocal : 在局部空间内,修改离自己最近的变量,如果上一层没有就继续向上找,
直到找到局部变量的顶层,局部空间内没有可以修改的变量,就报错