总结day7 ---- 函数的内容 ,初识,返回值,进阶(一)

内容大纲:

　　一:　　函数识别

　　二:　　函数的结构

　　三:　　函数的返回值,

　　四:　　函数的参数

　　五:　　动态参数

　　六:　　形参的顺序

　　七:　　名称空间

　　八:　　作用域

　　九:　　加载顺序和取值顺序

　　十:　　内置函数

　　十一:　　关键字使用,global ,nonlocal

　　十二:　　函数的嵌套初识

一:函数的初识别

　　函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()，len()等。但你也可以自己创建函数，这被叫做用户自定义函数。

 

二:函数的结构

　

#函数定义
def mylen():
    """计算s1的长度"""
    s1 = "hello world"
    length = 0
    for i in s1:
        length = length+1
    print(length)

#函数调用
mylen()

上面就是咱们写了一个函数，并且成功的调用了它。

定义：def 关键词开头，空格之后接函数名称和圆括号()，最后还有一个":"。

　　　def 是固定的，不能变，他就是定义函数的关键字。

　　　空格 为了将def关键字和函数名分开，必须空(四声)，当然你可以空2格、3格或者你想空多少都行，但正常人还是空1格。

　　　函数名：函数名只能包含字符串、下划线和数字且不能以数字开头。虽然函数名可以随便起，但我们给函数起名字还是要尽量简短，并能表达函数功能

　　　括号：是必须加的，先别问为啥要有括号，总之加上括号就对了！

注释：每一个函数都应该对功能和参数进行相应的说明，应该写在函数下面第一行。以增强代码的可读性。

调用：就是 函数名() 要记得加上括号。

　三:函数的返回值

咱们用len()方法时，得到的结果会赋值给一个变量，然后得到结果：

str_len = len('hello,world')
print(str_len)

但是咱们写的这个函数，并不会得到这样的结果，如何让他和len函数一样，有返回值呢？

那就是在函数的最后加上一个return，return 后面写你需要的返回值就可以了。

return返回值

下面咱们重点研究return关键字的作用：

return关键字的作用

　　return 是一个关键字，这个词翻译过来就是“返回”，所以我们管写在return后面的值叫“返回值”。

要研究返回值，我们还要知道返回值有几种情况：分别是没有返回值、返回一个值、返回多个值

没有返回值

　　不写return的情况下，会默认返回一个None：我们写的第一个函数，就没有写return，这就是没有返回值的一种情况。　

没有return

　　只写return，后面不写其他内容，也会返回None，有的同学会奇怪，既然没有要返回的值，完全可以不写return，为什么还要写个return呢？这里我们要说一下return的其他用法，就是一旦遇到return，结束整个函数。

只写return

　　return None:和上面情况一样，我们一般不这么写。

返回一个值

刚刚我们已经写过一个返回一个值的情况，只需在return后面写上要返回的内容即可。　　

return返回一个值

返回多个值

　　可以返回任意多个、任意数据类型的值

return返回多个值

　　返回的多个值会被组织成元组被返回，也可以用多个值来接收

多个值接收

小结：

　　return 只有两个作用：

　　1，结束整个函数。

　　2，给函数的执行者（调用者）返回值。

四:函数的参数:

　　　>1 形参:

　　　　>>1:位置参数:按照位置参数, 与实参角度的位置重左至右,一一对应.

　　　　>>2:默认参数:给形参一个默认值,通常是比较常用的数值,但是可以改变,#注意形参一定要在位置的最后面.

　　　　默认参数陷阱:

 def func1 (a,l=[]):
     l.append(a)
     return l
 print(func1(22))
 print(func1(66))
 print(func1(33))
 print(func1(44,[]))
 >>>>
 [22]
 [22, 66]
 [22, 66, 33]
 [44]

　　　　>>3:万能参数*arg, **kwarg

　　　　　　可以接受所有的位置参数,关键字参数, 

　　　　　　可以接受字典

　　　　

　　　>2 实参: :

　　　　　　>>1位置参数:必须与形参一直,从左至右一一对应.

　　　  >>2 关键字参数:一一对应即可,不需要对应位置

　　　  >>3 混合参数:两个同时存在

　　　  >>4 三元运算

　　　　　　>>>1

if 2 >1:
    print('ok')
else:
    print('no')
print('ok') if 2>1 else print('no')

以上两个式子相等

　　　A1 if 条件 else A2

五:动态参数

def fun(*args,**kwargs):
    print(args)
    print(kwargs)
fun(1,2,3,4,'','',[123],sex='nan')
fun({'name':23,'age':'hehe'},eat='chi')
>>>
(1, 2, 3, 4, '', '', [123])
{'sex': 'nan'}
({'name': 23, 'age': 'hehe'},)
{'eat': 'chi'}

　　　>*arg , **kwarg的魔性用法

　　　　>>

　　　　　　# * 的魔性用法。
　　　　　　# 在函数的定义时，* ** 代表聚合。
　　　　　　# 函数的执行（调用）时，* ** 代表打散。

def fun(*args,**kwargs):
    print(args)
    print(kwargs)
fun(*(1,2,3),*['a','b','c'],**{'name':'wangzi'},**{'age':36})
# 写一个函数：可以传多个列表，把列表里面的所有元素一个一个的添加到args里面。

def func(*args, **kwargs):  # 在函数的定义时，* 代表聚合。
    print(args)  #(1,2,3,4,5,6,1,2,3)

func(*[1,2,3],*(1,2,3),*'fdsaf') # 函数的执行（调用）时，*  打散。

六:形参的顺序问题

　　# 位置参数> *args> 默认参数> **kwargs

七:名称空间　

　　　　# 全局名称空间：存放的是py文件中变量与值的对应关系
　　　　# 局部名称空间：临时存放的是函数体里面的变量与值的对应关系。
　　　　# 内置名称空间：内置函数，关键字等等。 print() input()

八:作用域

　　# 作用域：
　　　　# 全局作用域：内置名称空间，全局名称空间
　　　　# 局部作用域：局部名称空间

　　

　　

九:顺序问题

　　# 加载顺序：加载到内存的顺序
　　　　# 内置名称空间 ---> 全局名称空间 ---> （当函数执行时）局部名称空间　　

　　# 取值顺序(就近原则)
　　　　# LEGB 原则
　　# 局部名称空间 ---> 全局名称空间 ---> 内置名称空间

十:内置函数

　　# print(globals()) # 返回一个字典:包含全局作用域所有的内容
　　# print(locals()) # 返回一个字典:当前作用域的所有内容

十一:关键字的使用

　　

# 关键字：global nonlocal

# global : 可以局部声明一个全局变量
# age = 46
# name = 'xxx'
# def func():
# global name
# name = 'alex'
# name = 'barry'
# func()
# print(name)

# 局部作用域不能对全局作用域的变量进行修改，只能引用。
count = 1
def func():
global count
count += 1
func()
print(count)

# 总结：
# global :
# 可以局部作用域声明一个全局变量
# 局部作用域不能对全局作用域的变量进行修改，只能引用，通过设置global可以修改。

# nonlocal : 只在python3x中 存在。
# 1，不能操控全局变量。
# name = 'alex'
# def func():
# nonlocal name
# print(name)
# func()

# 内层函数不能对外层函数的变量进行修改，只能引用。
# 在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，
# 并且引用的哪层，从那层及以下此变量全部发生改变。

def wrapper():
    name = 'alex'
    def inner():
        nonlocal name     #加上之后可以引用函数父级的变量
        name += 'b'
        # print(name)
    print('', name)
    inner()
    print('', name)
wrapper()
>>>>>

1 alex
2 alexb

十二:　　函数的嵌套初识

　　

def func1():
    print(1)
    def inner():
        print(2)
        def inner2():
            print(3)
    print(4)
    inner()
    print(5)
func1()
>>>>

1
4
2
5