2019-03-14-day010-函数进阶

昨日回顾

1.函数:

函数的定义

函数的参数

• 位置参数
• 关键字参数
• 混合参数
• 形参的位置上(默认参数)
• 实参的位置上(关键字参数)
• 位置参数 > 默认参数

三元运算符:

c = a if a>b else b

函数的返回值:

1. 没有写return 返回的是None
2. 写了return 没写返回值也是None
3. 写了一个值是它本身,多个返回的是一个元组
4. return 下面的代码不执行
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}\n')

 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}\n')

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])                # 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内
```python
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 : 在局部空间内,修改离自己最近的变量,如果上一层没有就继续向上找,

直到找到局部变量的顶层,局部空间内没有可以修改的变量,就报错

今日总结

函数的进阶:

1.1 动态参数
位置参数 > 动态位置参数 > 默认参数 > 动态(关键字)默认参数
1.2 ,*
在实参位置是打散
在形参位置是聚合
1.3 args,*kwargs 可以修改,但是不建议修改
1.4 将(列表,元组,字符串,字典,集合)打散传入

2.1 函数的注释:
""" """ 官方推荐
查看注释: func名.__doc__
查看注释: func名.__name__

3.1 名称空间
加载顺序:
1.内置空间
2.全局空间
3.局部空间
取值顺序:
1.局部空间
2.全局空间
3.内置空间

作用域;

  全局作用域  内置 + 全局
  局部作用域  局部

  global : 在局部修改全部变量,如果没有就创建一个新的
  nonlocal : 在局部空间内,修改离自己最近的变量,如果上一层没有就继续向上找,
  直到找到局部变量的顶层,局部空间内没有可以修改的变量,就报错

4.1 函数的嵌套
函数的嵌套-》一个套一个，两个套三个

4.2:函数嵌套内,从最里层返回一个任意字符串,在外部接受打印