函数进阶

以你之姓@ 2023-06-25 02:30 31阅读 0赞

# 一、函数参数类型 #

不可变类型参数：整数、字符串、元组。 fun（a）内部修改 a的值，只是修改另一个复制的对象，不会影响 a 本身。 可变类型：列表，字典。如 fun（la）， 则是将 la 真正的传过去，修改后fun外部的la也会受影响  
1、传递不可变类型参数，不会影响参数本身  
2、传递可变类型参数，会影响参数本身

# 二、命名空间 #

命名空间指的是保存程序中的变量名和值的地方。命名空间的本质是一个字典， 用来记录变量名称和值。字典的key是变量的名称，字典的value对于的是变量的值  
命名空间一共分为三种：

#### 局部命名空间 ####

每个函数都有自己的命名空间，叫做局部空间，它记录了函数的变量，包括函数 的参数 和局部定义的变量

#### 全局命名空间 ####

每个模块拥有它自已的命名空间，叫做全局命名空间，它记录了模块的变量，包 括函数、 类、其它导入的模块。

#### 内置命名空间 ####

任何模块均可访问它，它存放着内置的函数和异常。

## 1. 命名空间的访问 ##

局部名称空间使用 locals() 函数来访问  
全局命名空间的访问使用globals()函数访问。

a=10
    def func(name,age):
         num=10
         ret=locals()
         print(ret)
    func("fxx",18)
    ret=globals()
    print(ret)

结果

{
        'num': 10, 'age': 18, 'name': 'fxx'}
    {
        '__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00000211FE3CB1D0>, '__spec__': None, '__annotations__': {
        }, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/work/2019.12.11/32165465.py', '__cached__': None, 'a': 10, 'func': <function func at 0x00000211FE491840>, 'ret': {
        ...}}

## 2. 命名空间加载顺序 ##

内置命名空间(程序运行前加载)>全局命名空间(当程序运行的时候加载全局命名 空间)>局部命名空间(程序运行中：函数被调用时才加载)当函数返回结果 或 抛 出异常时，被删除。每一个递归调用的函数都拥有自己的命名空间。

print('fxx')
    #print函数直接能调用，因为已经加载到了内置命名空间中
    a=10
    b=20
    def func():
        name='fxx'
        age=19
        print(name,age)
    #当程序执行的时候a，b，func变量被加载到全局命名空间中
    #当调用func（）函数的时候，name，age变量被加载到了局部命名空间中
    func()

fxx
    fxx 19

## 3. 命名空间查找顺序 ##

当使用某个变量的时候，先从局部命名空间中找，如果能找到则停止搜索，如果 找不到在去全局名称空间中查找，如果找到则停止搜索，如果找不到则到内置名 称空间中查找，如果找不到则报错。  
嵌套函数的情况：  
1、先在当前 (嵌套的或 lambda) 函数的命名空间中搜索  
2、然后是在父函数的命名空间中搜索  
3、接着是模块命名空间中搜索  
4、最后在内置命名空间中搜索

id=10
    def outter():
        id=11
        def inner():
            id=12
            print(id)
        inner()
    outter()

# 三、作用域 #

作用域指的是变量在程序中的可应用范围。  
作用域按照变量的定义位置可以划分为4类即  
LEGB： Local(函数内部)局部作用域。  
Enclosing（嵌套函数的外层函数内部）嵌套作用域（闭包）。  
Global（模块全局）全局作用域。  
Builtin（内建）内建作用域。(指的是builtins.py模块)

a=100#全局变量
    def outter():
        b=200
        def inner():
            c=300
            print(c)#local
            print(b)#enclosing
            print(a)#globa
            print(max)#Built—in
        inner()
    outter()

300
    200
    100
    <built-in function max>

Python内层作用域访问外层作用域时的顺序: Python搜索４个作用域\[本地作用域(L)之后是上一层结构中def或者lambda的本 地作用域(E),之后是全局作用域(G)最后是内置作用域(B)（即python的内置类和 函数等）］ 并且在第一处能够找到这个变量名的地方停下来。如果变量名在整个的搜索过程 中都没有找到，Python就会报错。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pPS0VSMTAwNg_size_16_color_FFFFFF_t_70]  
注意： 在python中，模块（module），类（class）、函数（def、lambda）会产生新 的作用域，其他代码块是不会产生作用域的，也就是说，类似条件判断 （if……else）、循环语句（for x in data）、异常捕捉（try…catch）等的变量是 可以全局使用的。

# 四、全局变量和局部变量 #

在函数中定义的变量称为局部变量，只在函数内部生效， 在程序一开始定义的变量称为全局变量，全局变量的作用域是整个程序。

# 五、global和nonlocal关键字 #

#### 1、global关键字可以将局部变量变成一个全局变量。 ####

格式: global 变量名称

#### 2. nonlocal关键字可以修改外层(非全局)变量。 ####

# 六、命名空间和作用域的关系 #

命名空间定义了在某个作用域内变量名和绑定值之间的对应关系，命名空间是键 值对的集合，变量名与值是一一对应关系。 作用域定义了命名空间中的变量能够在多大范围内起作用。

# 七、内置函数 #

1.  abs()函数 求数字的绝对值 ret = abs(21) print(ret)  
    2.max()函数 max(iterable, key, default) 求迭代器的最大值， 其中iterable 为迭代器，max会for i in … 遍历一遍这个迭代器，然后将迭代器的每一个返回值当做参数传给key=func 中的func(一般用lambda表 达式定义) ，然后将func的执行结果传给key，然后以key为标准进行大小的判 断。
2.  map() 函数 有两个参数，第一个参数是一个函数，第二个参数是可迭代的内容。 函数会依次作用在可迭代内容的每一个元素上进行计算，然后返回一个新的可迭 代内容。
3.  map() 函数 有两个参数，第一个参数是一个函数，第二个参数是可迭代的内容。 函数会依次作用在可迭代内容的每一个元素上进行计算，然后返回一个新的可迭 代内容。
4.  filter() 函数 filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成 的新列表。 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递 给函数进判， 然后返回 True 或 False，最后将返回 True 的元素放到新列表中。  
    5.zip()函数 zip函数接受任意多个可迭代对象作为参数,将对象中对应的元素打包成一个tuple, 然后返回一个可迭代的zip对象.这个可迭代对象可以使用循环的方式列出其元素 若多个可迭代对象的长度不一致,则所返回的列表与长度最短的可迭代对象相同。

#abc（）     求绝对值
    ret=abs(-123454)
    print(ret)
    #max（）求迭代器最大值
    ret =max(1,2,3)
    print(ret)
    #map()
    lst=[1,2,3]
    def pingfang(x):
        return x*x
    ret=map(pingfang, lst)
    for i in ret:
        print(i)
    #  filter() 函数   过滤出列表中的所有奇数
    lst = [1,2,3,4,5,6,7,8,9,10]
    def odd_number(num):
        if num % 2 == 1:
         return num
    ret = filter(odd_number, lst)
    print(list(ret))
    #zip()函数
    a=[1,2,3]
    b=['a','b','c']
    c=[3,4,5]
    ret=zip(a,b,c)
    for i in ret:
        print(i)

123454
    3
    1
    4
    9
    [1, 3, 5, 7, 9]
    (1, 'a', 3)
    (2, 'b', 4)
    (3, 'c', 5)

# 八、匿名函数 #

在定义函数的时候，不想给函数起一个名字。这个时候就可以用lambda来定义 一个匿名函数  
语法： 变量名= lambda 参数:表达式(block) 参数：可选，通常以逗号分隔的变量表达式形式，也就是位置参数 表达式：不能包含循环、return，可以包含if…else…  
提取奇数  
注意: 1.表达式中不能包含 循环，return  
2.可以包含 if…else…语句.  
3.表达式计算的结果直接返回

lst=[1,2,3,4,5,6,7,8,9,10]
    guolv=lambda a:a%2==1
    print(list(filter(guolv,lst)))

[1, 3, 5, 7, 9]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pPS0VSMTAwNg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191224194353960.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pPS0VSMTAwNg==,size_16,color_FFFFFF,t_70