初始函数

初始函数

一、定义函数

s="太白金鑫老师"
def my_len():     #def定义函数关键字    my_len()函数名
    i=0
    for k in s:
        i+=1
    print(i)
my_len()          #调用函数

函数特点：

1、定义了之后，可以在任何需要他的地方调用 

2、没有返回长度，只是单纯的打印

len()

1、不能变，只能计算s字符串的长度

2、只是输出了结果

自定义函数：

s="太白金鑫老师"
def my_len():    #自定义函数
    i=0
    for k in s:
        i+=1
    return i     #返回值

length=my_len()
print(length)

二、返回值的三个情况：

没有返回值 —— 返回None
    不写return
    只写return:结束一个函数的继续
    return None  —— 不常用
返回1个值
    可以返回任何数据类型
    只要返回就可以接收到
    如果在一个程序中有多个return，那么只执行第一个
返回多个值
    用多个变量接收：有多少返回值就用多少变量接收
    用一个变量接收: 得到的是一个元组

def func():
    l = ['金老板','二哥']
    for i in l:
        print(i)
        if i=='金老板':
            return None
    print('='*10)
ret = func()
print(ret)

三、参数

def my_len(s):  #自定义函数只需要0个参数，接收参数,形式参数，形参
    i = 0
    for k in s:
        i += 1
    return i  #返回值

ret = my_len('金老板小护士')  #传递参数：传参，实际参数，实参
ret = my_len([1,2,3,4,5])  #传递参数：传参
print(ret)

参数三种情况

没有参数
        定义函数和调用函数时括号里都不写内容
有一个参数
        传什么就是什么
有多个参数
        位置参数

def my_sum(a,b):
    print(a,b)
    res = a+b  #result
    return res

ret = my_sum(1,2)
print(ret)

站在实参的角度上：
    按照位置传参
    按照关键字传参
    混着用可以:但是 必须先按照位置传参，再按照关键字传参数
             不能给同一个变量传多个值

站在形参的角度上：
    位置参数：必须传,且有几个参数就传几个值
    默认参数: 可以不传，如果不传就是用默认的参数，如果传了就用传的

#默认参数
def classmate(name,sex='男'):
    print('%s : %s'%(name,sex))

classmate('二哥')
classmate('小孟')
classmate('大猛')
classmate('朗哥','女')

调用函数的时候
    按照位置传 ： 直接写参数的值
    按照关键字： 关键字 = 值

定义函数的时候：
    位置参数 ： 直接定义参数
    默认参数，关键字参数 ：参数名 = '默认的值'
    动态参数 : 可以接受任意多个参数
                参数名之前加*，习惯参数名args，
                参数名之前加**，习惯参数名kwargs
    顺序：位置参数，*args,默认参数,**kwargs

#关键字传参
def classmate(name,sex):
    print('%s : %s'%(name,sex))

classmate('二哥','男')
classmate(sex='男',name = '二哥')

注意：使用关键字传参，位置随意放

#默认值传参
def classmate(name,sex='男'):     #默认性别为男
    print('%s : %s'%(name,sex))

classmate('二哥')       #使用默认值
classmate('朗哥',sex= '女')     #使用实参女

注意：没有特意强调就用默认值，提供实参就用传递的值

动态参数有两种：可以接受任意个参数
    *args   ： 接收的是按照位置传参的值，组织成一个元组
    **kwargs： 接受的是按照关键字传参的值，组织成一个字典
    args必须在kwargs之前

#添加无数多个值都行
def sum(*args):
    n = 0
    for i in args:
        n+=i
    return n

print(sum(1,2))        #3
print(sum(1,2,3))      #6
print(sum(1,2,3,4))    #10

注意：*args ： 接收的是按照位置传参的值，组织成一个元组

def func(**kwargs):
    print(kwargs)

func(a = 1,b = 2,c =3)   #{'a': 1, 'c': 3, 'b': 2}
func(a = 1,b = 2)        #{'a': 1, 'b': 2}
func(a = 1)             #{'a': 1}

注意：**kwargs： 接受的是按照关键字传参的值，组织成一个字典

def func(*args,default = 1,**kwargs):
    print(args,kwargs)

func(1,2,3,4,5,default=2,a = 'aaaa',b = 'bbbb',)   #*args 位置传参的值，组织成一个元组；**kwargs：关键字传参的值，组织成一个字典
#调用结果：(1, 2, 3, 4, 5) {'a': 'aaaa', 'b': 'bbbb'}

注意：args必须在kwargs之前

动态参数的另一种传参方式：

def func(*args):#站在形参的角度上，给变量加上*，就是组合所有传来的值。
    print(args)

func(1,2,3,4,5)
l = [1,2,3,4,5]
func(*l)  #站在实参的角度上，给一个序列加上*，就是将这个序列按照顺序打散

四、函数的注释：

def func():
    '''
    这个函数实现了什么功能
    参数1：
    参数2：
    :return: 是字符串或者列表的长度
    '''
    pass

 五、三元运算

 变量=条件返回True的结果   if条件   else  条件返回False的结果

#返回最大值
def func(a,b):
    c=a if a>b else b
    return c
print(func(1,5))

注意点：

1)、必须要有结果

2)、必须要有if 和else

3)、只能是简单的情况

六、命名空间

1、内置命名空间-------python解释器

        #就是python解释器一启动，就可以使用的名字存储在内置命名空间中。

        #内置的名字启动解释器的时候被加载进内存里

2、全局命名空间-------我们写的代码但不是函数中的代码

       #是在程序从上至下被执行的过程中依次加载在内存的

      #放置了我们设置的所有变量名和函数

3、局部命名空间-------函数

      #就是函数内部定义的名字

     #当调用这个函数的时候，才会产生这个名称空间，随着函数执行的结束，这个命名空间有有消失啦。

注意：

在局部，可以使用全局，内置命名空间中的名字；

在全局，可以使用内置命名空间中的名字，但是不能用局部中使用

在内置，不能使用全局和局部的名字的

def max(l):
    print('in max func')
print(max([1,2,3]))          #in max func
                              #None

注意：

#在正常情况下，直接使用内置的名字
#当我们在全局定义了和内置名字空间中同名的名字时，会使用全局的名字
#当我自己有的时候 我就不找我的上级要了
#如果自己没有 就找上一级要 上一级没有再找上一级 如果内置的名字空间都没有 就报错
# 多个函数应该拥有多个独立的局部名字空间，不互相共享

func  --> 函数的内存地址
#函数名() 函数的调用
#函数的内存地址() 函数的调用

七、作用域

 作用域两种
 全局作用域 —— 作用在全局 —— 内置和全局名字空间中的名字都属于全局作用域  ——globals()
 局部作用域 —— 作用在局部 —— 函数（局部名字空间中的名字属于局部作用域） ——locals()

a = 1
def func():
    global a
    a = 2
func()
print(a)     #2

注意点：

1）、对于不可变数据类型 在局部可以查看全局作用域中的变量，但是不能直接修改

2）、如果想要修改，需要在程序的一开始添加global声明
3）、如果在一个局部（函数）内声明了一个global变量，那么这个变量在局部的所有操作将对全局的变量有效

globals： 永远打印全局的名字

locals： 输出什么 根据locals所在的位置

八、函数的嵌套和作用域链

函数的嵌套定义：内部函数可以使用外部函数的变量

def max(a,b):
    return a if a>b else b

def the_max(x,y,z):  #函数的嵌套调用
    c = max(x,y)
    return max(c,z)

print(the_max(1,2,3))

a = 1
def outer():
    a = 1
    def inner():
        a = 2
        def inner2():
            nonlocal a  #声明了一个上面第一层局部变量
            a += 1   #不可变数据类型的修改
        inner2()
        print('##a## : ', a)
    inner()
    print('**a** : ',a)

outer()
print('全局 ：',a)

nonlocal：
1)、只能用于局部变量，找上层中离当前函数最近一层的局部变量
2)、声明了nonlocal的内部函数的变量修改会影响到 离当前函数最近一层的局部变量
3)、对全局无效
4)、对局部 也只是对 最近的 一层 有影响

函数名的用法：

 1)、函数名就是内存地址

 2)、函数名可以赋值

 3)、函数名可以作为容器类型的元素

 4)、函数名可以作为函数的返回值

 5)、函数名可以作为函数的参数

九、闭包        

闭包：嵌套函数，内部函数调用外部函数的变量

def outer():
    a = 1
    def inner():
        print(a)
    return inner
inn = outer()
inn()      #1