Python函数学习

Python函数学习

1.函数定义

在函数定义阶段只检查函数的语法问题

2.实参形参

​​​​总结：
（1）位置参数就是经常用的按照位置顺序给出实参的值；
（2）关键字实参形式：key=123；放在所有位置参数后；
（3）默认形参是直接在函数括号中指定某数的值，若传实参时给出具体值则按照具体值来，若没给则按默认值处理；
​**（4）**形参中的*会将溢出的位置实参全部接收，然后存储元组的形式，然后把元组赋值给后的参数。需要注意的是：*后的参数名约定俗成为args。表示为：
def func(*args)
**（5）**形参中的**会将溢出的关键字实参*全部接收，然后存储字典的形式，然后把字典赋值给后的参数。需要注意的是：**后的参数名约定俗成为kwargs。表示为：def func(**kwargs)

3.函数是对象，可以被当做数据进行处理

4.global和nonlocal关键字

第一，两者的功能不同。global关键字修饰变量后标识该变量是全局变量，对该变量进行修改就是修改全局变量，而nonlocal关键字修饰变量后标识该变量是上一级函数中的局部变量，如果上一级函数中不存在该局部变量，nonlocal位置会发生错误（最上层的函数使用nonlocal修饰变量必定会报错）。
第二，两者使用的范围不同。global关键字可以用在任何地方，包括最上层函数中和嵌套函数中，即使之前未定义该变量，global修饰后也可以直接使用，而nonlocal关键字只能用于嵌套函数中，并且外层函数中定义了相应的局部变量，否则会发生错误（见第一）
【注：这两段引用知乎作者的内容，侵权删】

global x
nonlocal x

（1）在局部想要修改全局的可变类型，不需要任何声明，可以直接修改。
（2）在局部如果想要修改全局的不可变类型，需要借助global声明，声明为全局的变量，即可直接修改。

---

函数进阶

1.闭包函数和装饰器

装饰器就是闭包的一种应用，下面的代码是装饰器模板：

def deco(func):
    def wrapper(*args,**kwargs):
        res = func(*args,**kwargs)
        return res
    return wrapper

装饰器在大段程序中的使用方法（装饰器语法糖——即让装饰器用起来更方便简洁的东西）：直接在要使用装饰器的函数上方@装饰器，例：

def deco(func):
    def wrapper(*args, **kwargs):
        res = func(*args, **kwargs)
        return res

    return wrapper


@deco  # home =deco(home)
def home(name, pwd, tag=1):
    print(f"welcome {name} to home page")
    return name

应用场景：
如果我们已经上线了一个项目，我们需要修改某一个方法，但是我们不想修改方法的使用方法，这个时候可以使用装饰器。因为软件的维护应该遵循开放封闭原则，即软件一旦上线运行后，软件的维护对修改源代码是封闭的，对扩展功能指的是开放的
应用实例：

import time

current_user = {'username': None}

def login(func):
    # func = 最原始的index
    def wrapper(*args, **kwargs):

        if current_user['username']:
            res = func(*args, **kwargs)

            return res

        user = input('username: ').strip()
        pwd = input('password: ').strip()
        
        engine = 'file'

        if engine == 'file':
            print('base of file')
            if user == 'nick' and pwd == '123':
                print('login successful')
                current_uesr['usre'] = user
                res = func(*args, **kwargs)

                return res
            else:
                print('user or password error')
        elif engine == 'mysql':
            print('base of mysql')
        elif engine == 'mongodb':
            print('base of mongodb')
        else:
            print('default')

    return wrapper


@login	#home=login(home)这样做的好处的可以减少登录的次数，只需每次判断是否已登录，而不需要重复写登录的代码。即给home()和index()都增加了登录的功能
def home(name):
    print(f"welcome {name} to home page")
    time.sleep(1)


@login	#index=login(index)
def index():
    print('welcome to index')
    time.sleep(1)

res = index()

2.迭代器和生成器

（1）实际上生成器是迭代器的一种，只是生成器是自己写的迭代器；

---

迭代器
几个概念：
**可迭代的对象：**Python内置str、list、tuple、dict、set、file都是可迭代对象
（Python中内置有__iter__方法的都叫可迭代的对象）
（2）迭代器定义：
一个类如果实现了「迭代器协议」，就可以称之为「迭代器」。
什么是「迭代器协议」呢？
在 Python 中，实现迭代器协议就是实现以下 2 个方法：
__iter__：这个方法返回对象本身，即 self
__next__：这个方法每次返回迭代的值，在没有可迭代元素时，抛出 StopIteration 异常

#迭代器应用实例
s = 'hello'
iter_s = s.__iter__()

while True:
    try:
        print(iter_s.__next__())
    except StopIteration:
        break
#输出结果为:
#h
#e
#l
#l
#o		 

(3)for循环又称作迭代器循环，in的后面必须是可迭代对象

lis = [1, 2, 3]
for i in lis:
    print(i)

---

生成器
（1）yield关键字：函数中但凡出现yield关键字，再调用函数，就不会继续执行函数体代码，而是会返回一个值
（2）yield和return的区别：
yield 接收一个值并继续执行后续代码（未指定默认接收None），而return直接接收一个值并直接结束函数，不再执行其后的代码；

def func():
    print('from func 1')
    yield 'a'
    print('from func 2')
    yield 'b'


g = func()	
print(F"g.__iter__ == g: {g.__iter__() == g}")	#迭代器执行_iter_的结果是它本身，这也证明了生成器就是迭代器

res1 = g.__next__()				#from func 1
print(f"res1: {res1}")			#a

res2 = next(g)					#from func 2
print(f"res2: {res2}")			#b

for i in g:
    print(i)
#for循环的结果：(a,b没有拿变量来接收，打印不出来)
#from func 1
#a
#from func 2
#b

再来看一个直观的生成器例子：

def i_wanna_return():
    yield 'a'
    yield 'b'
	yield 'c'

for i in i_wanna_return():
    print(i)
#结果：
#a
#b
#c