函数基础篇 Zeus

1.1函数简介

 1.1.1什么是函数

    函数就是具有某个具体功能的工具

1.1.2为什么要用函数

    提供开发效率
    减少代码冗余
    提高程序的扩展性

1.1.11定义一个函数

    def是定义函数的关键字
    函数名:函数名的命名规则与变量名一致
        1.不能以关键字(******)
        2.函数也应该做到见名知意

    函数在定义的时候只检测函数体语法 不执行函数体代码

    def func():
        print('hello')

1.1.12调用函数的固定格式

    函数名+括号
    函数名只要遇到括号会立即执行函数体代码
    代码中遇到函数名加括号 优先级最高
    先去执行函数 再看下面的代码

1.2函数的返回值

　　函数内要想返回给调用者值 必须用关键字return
　　1.不写return
　　2.只写return
　　3.写return None
　　4.写return返回一个值
　　5.写return返回多个值

# 不写return:函数默认返回None
def func():
    print('hahaha')
res = func()
print(res)


# 只写return:return除了可以返回值之外 还可以直接结束整个函数的运行
# 只写return 返回的也是None(None就表示什么都没有)
def func():
    l = ['jason','egon','tank']
    while True:
        for i in l:
            if i == 'egon':  # 当i为egon的时候 直接结束函数运行
                # break
                return
                # print('asdasdkljlsjadl')  # 这一行代码拥有都不会运行
            print(i)
res = func()
print(res)


# 写return None:跟上面的只写return是一样的
def func():
    return None
res = func()
print(res)


# 写return返回一个值:这个值可以是python任意数据类型
def func():
    return '123'
def func1():
    return [1,2,3]
def func2():
    return {'name':'jason'}
def func3():
    return (1,)
def func4():
    return {1,2,3,4,5}
def func5():
    return True
print(func(),func1(),func2(),func3(),func4(),func5())


# 写return返回多个值:return会自动将多个值以元组的形式返回给调用者
"""
1.为什么组织成元祖返回
    函数不希望自己处理的结果被修改
#2.如何不返回元祖
  #  
#"""
def func():
    return 1,2,3,4  # 返回的是(1, 2, 3, 4)
# res = func()
# print(res)

def func1():
    return 'a','b','c'  # ('a', 'b', 'c')
res = func1()
print(res)


def func2():
    return [1,2,3],[1,2,3],[1,2,3]  # ([1, 2, 3], [1, 2, 3], [1, 2, 3])
res1 = func2()
print(res1)


def func3():
    return {'name':'jason'},{'username':'tank'},{'user_name':'egon'}  # ({'name': 'jason'}, {'username': 'tank'}, {'user_name': 'egon'})
res2 = func3()
print(res2)

# 返回多个值 并且不想让return帮你做处理  自己手动加上你想返回的数据类型符号
def func4():
    return [[1,2,3,4],[1,2,3,4],[1,2,34]]
res = func4()
print(res)

　　ps:

　　1.所有的函数都有返回值,无论你写不写return
    python中所有的函数都有返回值 不写的情况下默认返回None
　　2.光写return 或者return None并不是为了考虑返回值 而是为了结束函数的运行

1.3函数的参数

1.3.1函数参数的两大类型

 形参:在函数的定义阶段 括号内写的变量名 叫做该函数的形式参数 简称 形参
 实参:在函数的调用阶段 括号内实际传入的值 叫做实际参数 简称 实参
    
 形参与实参的关系
    形参就相当于变量名,而实参就相当于变量的值
    函数调用传参的过程 就是给形参变量名赋值的过程
    
 ps:形参和实参的绑定关系只在函数的调用阶段有效,函数运行结束关系自动解除
 只在函数内部有效 函数外部无任何影响

 1.3.2函数的注释

def func(x,y):
    """
    该函数的作用
    :param x: 对形参x的解释
    :param y: 对形参y的解释
    :return: 对函数返回值的解释
    """
    print('hahaha')
    return 'heihei'

print(help(func))
print(help(len))

1.3.3位置参数

# 位置参数:在函数定义阶段按照位置从左往右依次书写的变量名 叫做函数位置形参
# 位置形参在调用的时候 必须为其传值
def my_max(x,y):
    print(x,y)
    if x > y:
        return x
    else:
        return y
# res = my_max(1)  # 在调用函数的时候 少一个实参不行
# res = my_max(1,2,3)  # 在调用函数的时候 多一个实参也不行

res = my_max(20,10)

# 位置实参:在函数的调用阶段 传入的参数会按照位置一一对应给形参
print(res)


# 第一种直接按照位置传  一一对应

# 第二种指名道姓的传  >>>:关键字传参
my_max(y=20,x=10)
my_max(10,y=20)  # 位置和关键字混合使用
my_max(20,y=40)
#my_max(20,y=40,x=30)  # 位置参数已经赋值给x了 后面的关键字参数就不能再赋值了

 ps:在函数的调用阶段 位置参数和关键字参数可以混合使用
　　但是必须保证
    1.位置参数必须在关键字参数的前面(越短的越靠前,越长的越复杂的越靠后)
    2.同一个形参不能被多次赋值

1.3.4默认参数

# 默认值参数:在函数的定义阶段,形参(变量名)就已经被赋值了
# 在调用的时候可以不为默认值形参传值,默认使用定义阶段就已经绑定的值
# 在调用的时候如果可以给默认值形参传值 传了那么就使用你传的值
# 在定义阶段 默认值形参必须放在位置形参的后面

def my_max(x,y=100):
    if x > y:
        return x
    return y
# res = my_max(200)
res1 = my_max(200,1000)
res2 = my_max(y=200,x=1000)
print(res2)

def register(username,age,gender='male'):
    print(username,age,gender)
register('jason',18)
register('tank',28)
register('egon',84)
register('kevin',58)
register('xiaohou',17,'female')


# 默认值参数的应用场景
# 当形参接收的到值比较单一的情况下 通常可以考虑用默认值形参


def info(username,hobby,l=None):
    if l == None:
        l = []
    l.append(hobby)
    print('%s 的爱好是 %s'%(username,l))
info('jason','study')
info('tank','生蚝')
info('kevin','喝腰子汤')
info('egon','女教练')

# 解决方法1
info('jason','study',[])
info('tank','生蚝',[])
info('kevin','喝腰子汤',[])
info('egon','女教练',[])

# 解决方法2
info('jason','study')
info('tank','生蚝')
info('kevin','喝腰子汤')
info('egon','女教练')


m = 100
def my_max(x,y=m):
    print(x,y)
m = 222  # m = 222  并没有为函数传参
my_max(111)  # 结果为: 111 100



def func(x,y=100):
    print(x,y)

ps:函数在定义阶段 内部所使用的变量都已经初始化完毕了
　　不会因为调用的位置的变化 而影响到内部的值(暂时可忽略)

　　函数无论在什么地方被调用
　　都会跑到函数定义阶段去执行代码
　　形参中用到的值都是往函数定义阶段代码往上找

1.3.5可变长参数

 可变长参数
 站在调用函数传递实参的角度  实参的个数不固定的情况
 也就意味形参也不固定
 站在形参的角度 可以用*和**来接收多余的(溢出的)位置参数和关键字参数

1.3.51站在形参的角度 看 *

 形参中的*会将多余的(溢出的)位置实参 统一用元组的形式处理 传递给*后面的形参名

 def func(x,y,*z):
     print(x,y,z)  # z = (3, 4, 5, 6, 7, 8, 54, 43, 4, 5, 6, 6, 7, 8)
 func(1,2,3,4,5,6,7,8,54,43,4,5,6,6,7,8,)

1.3.52站在实参的角度 看 *

def func(x,y,z):
    print(x,y,z)
# l = [1,2,3]
# a,b,c = l
# func(a,b,c)
# func(*[1,2,3,4,5,6])  # *会将列表打散成位置实参一一传入等价于func(1,2,3,4,5,6)
func(*(1,2,3))  # 等价于func(1,2,3)
def func(x,*z):
    print(x,z)
func(1,*{1,2,3})  # *在形参中只能接收多余的位置实参 不能接收关键字实参
*只能将列表 元组 集合 字符串
*的内部你可以看成是for

1.3.53站在形参的角度 看 **

 def func(x,y,**z):
     print(x,y,z)  # z = {'z': 1, 'a': 1, 'b': 2, 'c': 3}
 func(x=1,y=2,z=1,a=1,b=2,c=3)
 **会接收所有多余的关键字参数 并将关键字参数 转换成字典的形式 字典的key就是关键字的名字
 字典的value就是关键字的名字指向的值  将字典交给**后面的变量名

1.3.54站在实参的角度 看 **

def func(x,y,z):
    print(x,y,z)
 func(12,3,4)
 func(x=1,y=2,z=3)
 d = {'x':1,'y':2,'z':333}
 func(x=1,y=2,z=3)
 func(**d)  # 等价于func(x=1,y=2,z=333)
 **会将字典拆封成 key = value的形式

总结 * 与 **
    *在形参中能够接受多余的位置参数 组织成一个元祖赋值给*后面的变量名
    **在形参中能够接受多余的关键字参数 组织成一个字典赋值给**后面的变量名
    
    
    *:在实参中 *能够将列表 元祖 集合 字符串 打散成位置实参的形式传递给函数
        (*就看成是for循环取值)
    **:在实参中 能将字典打散成key = value的形式 按照关键字参数传递给函数

# 需求 你写的函数 无论调用者按照正确传参的方式无论怎么传 你的函数都能够正常执行
# def func1(*x,**y):
#     print(x,y)
# func1(1,2,3,4,5,6,x=1,y=2,z = 3)

"""
注意python推荐形参*和**通用的写法
"""
def func2(*args,**kwargs):
    print(args,kwargs)
func2(1,2,3,4,5,6,x=1,y=2,z = 3)

 

1.4 函数的对象

1.4.1 函数是第一类对象：指的是函数可以当做数据传递

1.4.11  可以被引用 x=1,y=x

def func(x,y):

    print(x,y)

f=func

f(1,2)

1.4.12  可当做函数的参数传入

def foo():

    print('from foo')

def bar(func):

    # print(func)

    func()

bar(foo)

1.4.13  可以当做函数的返回值

def foo():
    print('from foo')

def bar():
    return foo

f=bar()
f()

1.4.14  可以当做容器类型的元素

def foo():
    print('from foo')

def bar():
    return foo

l=[foo,bar]
print(l)
l[0]()

def get():

    print('get')

 

def put():

    print('put')

 

def ls():

    print('ls')

 

cmd=input('>>: ').strip()

if cmd == 'get':

    get()

elif cmd == 'put':

    put()

elif cmd == 'ls':

    ls()

 

 

def get():

    print('get')

 

def put():

    print('put')

 

def ls():

    print('ls')

 

def auth():

    print('auth')

 

func_dic={

    'get':get,

    'put':put,

    'ls':ls,

    'auth':auth

}

# func_dic['put']()

cmd = input('>>: ').strip()

if cmd in func_dic:

    func_dic[cmd]()

1.5 函数的嵌套

1.5.1 函数的嵌套调用

def my_max(x,y):
    if x >= y:
        return x
    else:
        return y

def my_max4(a,b,c,d):
    res1=my_max(a,b)
    res2=my_max(res1,c)
    res3=my_max(res2,d)
    return res3 

1.5.2 函数的嵌套定义

def f1():
    def f2():
        print('from f2')
        def f3():
            print('from f3')
        f3()
    # print(f2)
    f2()
f1()

1.6 名称空间

名称空间指的是：存放名字与值绑定关系的地方，

1.6.1 内置与全局名称空间

内置名称空间（python解释器启动就有）：python解释器内置的名字，max，len，print

全局名称空间（执行python文件时生效）：文件级别定义的名字

x=1

def func():pass

import time

if x == 1:

    y=2
 

#局部名称空间（函数调用时生效，调用结束失效）:函数内部定义的名字

func()

1.6.2 加载与访问顺序

加载顺序：内置---》全局----》局部名称空间

访问名字的顺序：局部名称空间===》全局----》内置

x=1
print(x)

#print(max)
max=2

def func():
    # max=1
    print(max)

func()

x='gobal'
def f1():
    # x=1
    def f2():
       # x=2
       def f3():
           # x=3
           print(x)
       f3()
    f2()
 
f1()

1.6.3 全局与局部作用域

全局作用域（全局范围）：内置名称空间与全局名称空间的名字，全局存活，全局有效，globals()

局部作用域（局部范围）：局部名称空间的名字,临时存活，局部有效,locals()

#xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=111111111111111111111

print(globals())

print(dir(globals()['__builtins__']))

print(locals() is globals())

def func():

  #  yyyyyyyyyyyyyyyyyyyyyyyy=22222222

    print(globals())
    print(locals())

func()

x=100

def func():
    global x
    x=1

func()
print(x)

x='global'

def f1():
    # x=1
    def f2():
        nonlocal x
        x=0
    f2()
    print('===f1 innter--->',x)

f1()
print(x)

1.6.4 强调两点：

1.6.41  打破函数层级限制来调用函数

def outter():
    def inner():
        print('inner')
    return inner

f=outter()

# print(f)

def bar():
    f()
bar()

1.6.42  函数的作用域关系是在函数定义阶段就已经固定了，与调用位置无关

x=1
def outter():
    # x=2
    def inner():
        print('inner',x)
    return inner
f=outter()
# print(f)
# x=1111111111111111111111111111111111111111111111111111111111111111111111111111111111

def bar():
    x=3
    f()
# x=11111111111111111111111111111111111111111111111111111111111111111111111111111111

bar()

x=1111111111111111111111111111111111111111111111111111111111111111111111111111111111 

1.7 闭包函数

闭包函数：

1 定义在函数内部的函数

2 该函数的函数体代码包含对外部作用域（而不是全局作用域）名字的引用

3 通常将闭包函数用return返回，然后可以在任意使用

z=1
def outer():
    x=1
    y=2
    def inner():
        print(x,y)
        # print(z)
    return inner

f=outer()
print(f.__closure__[0].cell_contents)
print(f.__closure__[1].cell_contents)
print(f.__closure__)

def bar():
    x=111121
    y=2222
    f()

bar()

def foo(x,y):
    print(x+y)

foo(1,2)

def outter():
    x=1
    y=2
    def foo():
        print(x+y)
    return foo

f=outter() 
f()

1.7.1 闭包的意义：

返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域

1.7.2 应用领域：

延迟计算（原来我们是传参，现在我们是包起来）

1.7.3 爬页面:闭包函数为我们提供了一种新的为函数传参的方式

import requests #pip3 install requests

def get(url):
    response=requests.get(url)
    if response.status_code == 200:
        print(len(response.text))

get('https://www.baidu.com')
get('https://www.baidu.com')
get('https://www.baidu.com')

def outter(url):
    # url = 'https://www.baidu.com'
    def get():
        response=requests.get(url)
        if response.status_code == 200:
            print(len(response.text))
    return get

baidu=outter('https://www.baidu.com')
python=outter('https://www.python.org')
# baidu()
# baidu()
# baidu()