函数的命名空间,函数散文

把列表中多个值传入函数,调用时 +*

def func(*args):
    print(args)

l = [1,2,3,4,5,6,7,8,9]
func(*l)

传入dict中多个值,调用时+**

def func2(**kwargs):
    print(kwargs)

dic = {'k1':1,'k2':2}
func2(**dic)

1,参数陷阱

如果暗许参数的只是五个可变数据类型,那么每五回调用的时候,如若不传值就共用这几个数据类型的能源。

1,参数陷阱

一经暗中认同参数的只是壹个可变数据类型,那么每三遍调用的时候,若是不传值就共用那些数据类型的财富。

一丶动态参数

 函数的参数:

2,三元运算

c=a if a>b else b#如果a》b返回a,否则,返回b

变量 =条件再次回到True的结果 if 条件 else 条件重回False的结果

非得要有结果

无法不要有if和else

只可以是简简单单的情形

def func(a,b):

    a if a>b else b

print(func(5,1))

2,安慕希运算

c=a if a>b else b#如果a》b返回a,否则,返回b

变量 =条件再次来到True的结果 if 条件 else 条件重返False的结果

总得要有结果

无法不要有if和else

只好是大致的情形

def func(a,b):

    a if a>b else b

print(func(5,1))

  1.*args 地点参数,动态传参

def func(*food):
    print(food)

print(func("米饭","馒头","福建人","犹太人"))

  形参: 地点参数,*args,私行认同参数,**kwargs

3,命名空间与效率域

3.1命名空间的花色

    命名空间有三种

    内置、全局与一些

 

3.1.1#放到命名空间—–python解释器

    #不畏python解释器一运转就可以运用的名字存储在停放命名空间中

    #置于的名字在起步解释器的时候被加载进内存里

 

3.1.2#全局命名空间—-大家写的代码但不是函数中的代码

    #是在先后从上到下被实践的进程中一遍被执行进内存的

    #放置了笔者们设置的富有变量名和函数名

3.1.3#部分命名空间—-函数

     #就是函数内部定义的名字(定义在函数里的名字)

   
 #当调用函数的时候在会发出那一个称号空间,随着函数执行的完工,那几个命名空间就又没有了。

  #在部分:可以动用全局、也得以采用内置命名空间中的名字

 
#在全局:可以利用内置命名空间中的名字,但无法利用部分命名空间中的名字

  #在放权:不能够动用一些和大局的名字的

 3.1.4停放命名空间、全局命名空间与部分命名空间的涉嫌:

澳门葡京备用网址 1

3,命名空间与成效域

3.1命名空间的项目

    命名空间有二种

    内置、全局与部分

 

3.1.1#内置命名空间—–python解释器

    #即使python解释器一运维就足以使用的名字存储在松开命名空间中

    #函数的命名空间,函数散文。松手的名字在运转解释器的时候被加载进内存里

 

3.1.2#全局命名空间—-大家写的代码但不是函数中的代码

    #是在先后从上到下被执行的经过中两回被实施进内存的

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

3.1.3#一部分命名空间—-函数

     #就是函数内部定义的名字(定义在函数里的名字)

   
 #当调用函数的时候在会时有暴发这么些称谓空间,随着函数执行的扫尾,这一个命名空间就又没有了。

  #在一些:可以选拔全局、也可以运用内置命名空间中的名字

 
#在大局:可以选择内置命名空间中的名字,但不可以采用部分命名空间中的名字

  #在放手:不可能利用一些和全局的名字的

 3.1.4放权命名空间、全局命名空间与一些命名空间的涉嫌:

澳门葡京备用网址 2

  将全数的岗位参数都赋给*food

  实参: 依照职位传入/依据重点字传入

依傍倒置原则:上层模块应该借助下层模块,不可以反向依靠

在正规情况下,间接动用内置的名字。

当咱们在大局定义了和停放名字空间中同名的名字时,会拔取全局的名字。

当唯有的时候,就不会找上一级要

假使自身从没就找上超级要

假定上一级没有,就再升华顶尖要

三个函数拥有七个独立的一部鲜明明空间,不互相共享

def input():
    print('in input now')
def func():
    input()

func()

依傍倒置原则:上层模块应该依靠下层模块,无法反向依靠

在正规状态下,直接使用内置的名字。

当大家在大局定义了和放手名字空间中同名的名字时,会采用全局的名字。

当只有的时候,就不会找上一级要

尽管本人从来不就找上一流要

一旦上超级没有,就再提升一级要

五个函数拥有多少个单身的片段明明空间,不相互共享

def input():
    print('in input now')
def func():
    input()

func()

  2.**kwargs 关键字参数,动态传参

# 关键字的动态传参
def eat(**food):
    print(food)
print(eat(广东人= "福建人",goodeat = "饼干",我的天="飞天"))

 

4,功用域有三种

  全局作用域与局地效用域

  #全局意义域—>功用在大局—-内置和全局名字空间中的名字都属于全局意义域–globals()

     
 #有的作用域—>作用在部分—-函数(局部名字空间中的名字属于某些作用域—–locals()

a =1
def func():
    global a
    a+=1
func()
print(a)

#对此不可变数据类型在一部分可以查阅全局成效域中的变量,可是不能一向改动

#要是想要修改要求在程序的一方始添加global声明

#倘诺在2个部分内(函数)内评释了三个global变量,那些变量在有些的持有操作将对全局变量有效

# a = 1
# b = 2
# def func():
#     x = 'aaa'
#     y = 'bbb'
#     print(locals())
#     print(globals())
#
# func()
# print(globals())
# print(locals())  #本地的--->在函数体的外部使用locals,作用与globals是相同的

 

#globals 永远打印全局的名字

#locals输出什么 依照locals所以在的地方

a =1
b =2
print(globals())
print(locals())

4,成效域有二种

  全局功能域与局部成效域

  #全局意义域—>效用在大局—-内置和全局名字空间中的名字都属于全局意义域–globals()

     
 #一部分效用域—>成效在部分—-函数(局地名字空间中的名字属于某些功效域—–locals()

a =1
def func():
    global a
    a+=1
func()
print(a)

#对此不可变数据类型在一部分可以查阅全局功用域中的变量,不过无法平昔改动

#如若想要修改必要在程序的一开头添加global讲明

#要是在二个片段内(函数)内申明了2个global变量,那么些变量在某个的保有操作将对全局变量有效

# a = 1
# b = 2
# def func():
#     x = 'aaa'
#     y = 'bbb'
#     print(locals())
#     print(globals())
#
# func()
# print(globals())
# print(locals())  #本地的--->在函数体的外部使用locals,作用与globals是相同的

 

#globals 永远打印全局的名字

#locals输出什么 依据locals所以在的任务

a =1
b =2
print(globals())
print(locals())

  将根本字参数,以字典的样式赋给**food

取名空间:

5,函数的嵌套调用

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))

在三个函数的函数体内调用另三个函数叫做函数的嵌套调用

5,函数的嵌套调用

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))

在二个函数的函数体内调用另一个函数叫做函数的嵌套调用

  3.暗许参数与动态参数的涉及

澳门葡京备用网址 ,  澳门葡京备用网址 3

  (1) 内置命名空间:python中放置

6,函数的嵌套定义

个中函数可以选取外部函数的变量叫做函数的嵌套

def outer():
    def inner():
        print('inner')
        def inner2():
            a+=1 #不可变数据类型的修改
            print(a,b)
            print('inner2')
        inner2()
    inner()
outer()

澳门葡京备用网址 4

 

def outer():
    a =1
    def inner():
        b =2
        print(a)
        print('inner')
        def inner2():
            a+=1
            print('inner2')
        inner2()
    inner()
    print('**a**:',a)
outer()

6.1nonlocal a #评释了三个上边第叁层部分变量

a =1
def outer():
    a=1
    def inner():
        b=2
        print(a)
        print('inner')
        def inner2():
            nonlocal a
            a+=1
        inner2()
    inner()
    print('**a**:',a)
outer()
print('全局:',a)

#nonlocal 只可以用来局地变量,找上层中离当前函数目前一层的局地变量

#生命了nonlocal的里边函数的变量修改会潜移默化到离当下函数目前一层的部分变量

对全局无效

对一部分也只对如今的一层有震慑

6,函数的嵌套定义

个中函数可以应用外部函数的变量叫做函数的嵌套

def outer():
    def inner():
        print('inner')
        def inner2():
            a+=1 #不可变数据类型的修改
            print(a,b)
            print('inner2')
        inner2()
    inner()
outer()

澳门葡京备用网址 5

 

def outer():
    a =1
    def inner():
        b =2
        print(a)
        print('inner')
        def inner2():
            a+=1
            print('inner2')
        inner2()
    inner()
    print('**a**:',a)
outer()

6.1nonlocal a #宣称了3个地点第壹层部分变量

a =1
def outer():
    a=1
    def inner():
        b=2
        print(a)
        print('inner')
        def inner2():
            nonlocal a
            a+=1
        inner2()
    inner()
    print('**a**:',a)
outer()
print('全局:',a)

#nonlocal 只可以用来局地变量,找上层中离当前函数近日一层的部分变量

#生命了nonlocal的其中函数的变量修改会潜移默化到离当下函数如今一层的一对变量

对全局无效

对有些也只对目前的一层有影响

  即使以职分参数,关键字参数,暗中同意参数排列会报错,大家改一下专断认同参数的岗位,发现唯有在岗位参数前边,关键字参数后边,默许参数才不会报错

def func(*name,gender="男",**hobby):
    print(name,hobby,gender)
print(func("周杰伦","谢霆锋","吴京",hobby1="看电影",hobby2="唱歌"))

澳门葡京备用网址 6

 

  (2) 全局命名空间:自个儿取名,从上到下依次加载进内存.

7,功效域链

在其间函数适用变量的时候,是从小片段到大一部分到全局到内置名字的经过,顶级超级往上找,找到近年来的1个就采纳各种成效域链

a =0
def outer():
    def inner():
        def inner2():
            print(a)
        inner2()
    inner()
outer()

函数名的真面目——–第1类对象

7.1函数名可以赋值

def func():
  print(123)
func2 =func
func2()

 

7.2数名可以看做容器类型的要素

def func():
    print(123)
func()  #函数名就是内存地址
func2 = func  #函数名可以赋值
func2()
l = [func,func2] #函数名可以作为容器类型的元素
print(l)
for i in l:
     i()

7.3函数名可以作为函数的参数和再次回到值:

def func():
    print(123)
def wahaha(f)
    f()
wahaha(func)

 

7.4函数名可以当做函数的再次来到值

def func():
    print(123)
def wahaha(f)
    f()
    return f
qqxing =wahaha(func)
qqxing()

7,作用域链

在其间函数适用变量的时候,是从小片段到大一部分到全局到内置名字的长河,拔尖拔尖往上找,找到方今的七个就采取各种效用域链

a =0
def outer():
    def inner():
        def inner2():
            print(a)
        inner2()
    inner()
outer()

函数名的原形——–第壹类对象

7.1函数名可以赋值

def func():
  print(123)
func2 =func
func2()

 

7.2数名可以当做容器类型的因素

def func():
    print(123)
func()  #函数名就是内存地址
func2 = func  #函数名可以赋值
func2()
l = [func,func2] #函数名可以作为容器类型的元素
print(l)
for i in l:
     i()

7.3函数名可以看作函数的参数和重临值:

def func():
    print(123)
def wahaha(f)
    f()
wahaha(func)

 

7.4函数名可以视作函数的重回值

def func():
    print(123)
def wahaha(f)
    f()
    return f
qqxing =wahaha(func)
qqxing()

   计算一下种种:

  (3)
局地命名空间:函数内部定义的,当调用函数是才会起成效,随着函数的收尾而甘休.

8,闭包:嵌套函数,且其中函数要调用外部函数的变量

def outer():
    a =1
    def inner():#--->inner是一个闭包
        print(a)
    print(inner._closure_)
outer

大规模的闭包函数情势

def outer():
    a =1
    def inner():#--->inner是一个闭包
        print(a)
    return inner
outer
inn =outer()
inn()

 

在一个函数的表面调用内部的函数

 

闭包函数应用:

def get_url(): 
   urlopen('http://www.xiaohua100.cn/index.html').read() 
   def inner():
        ret = urlopen(url)
        print(ret)
    return inner
get_func =get_url()
get_func()

 

8,闭包:嵌套函数,且其中函数要调用外部函数的变量

def outer():
    a =1
    def inner():#--->inner是一个闭包
        print(a)
    print(inner._closure_)
outer

大面积的闭包函数格局

def outer():
    a =1
    def inner():#--->inner是一个闭包
        print(a)
    return inner
outer
inn =outer()
inn()

 

在二个函数的外表调用内部的函数

 

闭包函数应用:

def get_url(): 
   urlopen('http://www.xiaohua100.cn/index.html').read() 
   def inner():
        ret = urlopen(url)
        print(ret)
    return inner
get_func =get_url()
get_func()

 

      地点参数>*args>暗中同意值参数>**kwargs

          (global)

  假若想吸收全部参数,可以用*arge 和 **kwargs组合

def trans_para(*args,**kwargs):
    print(args)
    print(kwargs)
trans_para("jinxin",12,[1,2,3,4],[3,4,],(1,4,7),{"a":"123","c":456},country="china")

澳门葡京备用网址 7

 

澳门葡京备用网址 8

 二丶命名空间

作用域:

  在python解释器开首执行之后,就会在内存中开辟壹个空间,每当遇上壹个变量的时候,就把变量名和值时期的涉及记录下来,但是当际遇函数定义的时候,解释器只是把函数名读入内存,表示那些函数存在了,至于函数内部的变量和逻辑,解释器是不尊敬的,相当于说一开端的时候函数只是加载进来,仅此而已,唯有当函数被调用和走访的时候,解释器才会基于函数内部宣称的变量来拓展开发变量的内部空间,随着函数执行已毕,那个函数内部变量占用的长空也会趁着函数的履行落成而被清空.

a = 10
def func():
    a = 20      #当函数运行完毕,函数里面的a=20所占空间自动释放,不存在了
func()
print(a)    #输出的是10

 

  全局效用域

   大家给存放名字和值的关联的空间起一个名字叫:命名空间,大家的变量在蕴藏的时候就是储存在那片空间中的.

  局部功效域:对于不可变的数据类型,在部分可以查阅全局效率域中的变量,不可以一直改动(通过global修改),

    命名空间分类:

        借使有的成效域表明了global变量,那那一个变量在全局有效

    1.全局命名空间:—>我们一向在py文件中,函数外申明的变量都属于全局命名空间

        locals() 查看有个别成效域中的变量

    2.局地命名空间—->在函数中宣示的变量会放在局地命名空间

 

    3.平放命名空间:—->存放在python解释器为大家提供的名字,list,tuple,str,int那个都以放到命名空间

    加载顺序:

      1.放权命名空间

      2.全局命名空间

      3.局地命名空间(函数被实施的时候)

    取值顺序:

      1.局部命名空间

      2.全局命名空间

      3.停放命名空间

a = 10
def func():
    a = 20     
    print(a)    #输出的是20
func()
print(a)    #输出的是10

  2.作用域

    效用域:功用域就是职能范围,依据生效范围来看分成 全局功效域和一些成效域 

    全局效率域:包蕴内置命名空间和全局命名空间,在一切文件的别样地方都可以采取(遵守从上到下逐行执行)

    局地成效域:在函数的内部可以使用.

    

    成效域命名空间:

      1.全局功用域:全局命名空间 + 内置命名空间

      2.局地功效域:局部命名空间

    大家得以经过globals()函数来查看全局成效域中的内容,也可以透过locals()来查看局地成效域中的变量和函数消息

a = 10
def func():
    a = 20
    b = 10
    def abc():
        print("哈哈")
    print(a,b)          #这里a,b都是使用的局部作用域
    print(globals())    #打印全局作用域中的内容
    print(locals())     #打印局部作用域中的内容
func()

 

 

 

三丶函数的嵌套

    1.如若遇到了()就是函数的调用,假若没有()就不是函数的调用

    2.函数的实践各类

#函数的嵌套
def fun2():
    print(222)
    def fun3():
        print(666)
    print(444)
    fun3()
    print(888)
print(333)
fun2()
print(555)

 

澳门葡京备用网址 9

 

 四丶关键字 global和nonlocal

  global代表不再行使一些成效域中的内容了,而改用全局效能域中的变量

a = 10
def func():
    global a
    a = 20
    print(a)
func()
print(a)

澳门葡京备用网址 10

 

   nonlocal表示在有个别效能域中,调用父级命名空间中的变量

a = 10
def func1():
    a = 20
    def func2():
        nonlocal a
        a = 30
        print(a)
    func2()
    print(a)
func1()

澳门葡京备用网址 11

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website