函数(二)美高梅4858官方网站

作者:编程技术

2.命名空间

  1.置于名称空间

  2.全局名称空间

  3.部分名称空间

1 a = 10#全局名称空间    
2 def fun():#fn也在全局名称空间
3     b = 20#局部名称空间
4     print(a)
5 fun()

 

globals(卡塔尔(英语:State of Qatar)能够查阅全局成效域中的内容

locals(卡塔尔国能够查看当前效用域中的内容

动态传参 * **形参*args在形参地方, *代表不定参数--采纳的是岗位参数 选拔到的任务参数的动态传参: 都以元组形参的生龙活虎黄金时代:地方 *args默认值 **kwargs 以往写参数,可以率性的开展搭配def chi(zhushi, cai, fushi, tang, tiandian卡塔尔:print(zhushi,cai,fushi,tang,tiandian卡塔尔chi("大碗香米饭", "热销包菜", "粉蒸肉", "洋茄牛滑汤", "烤沙葛"卡塔尔(英语:State of Qatar)chi("小碗香米饭", "火爆莲花牛心菜"卡塔尔(英语:State of Qatar) # 参数远远不够形参的后生可畏意气风发:地点*args默认值**kwargs以后写参数. 可以轻巧的进展搭配, 不过, 顺序不可能串**kwargs在形参表示动态传参--关键字参数,关键字动态传参接受到的是字典**在形参表示动态传参-关键字参数关键字动态传参选拔到的是字典def func:# 也是聚合. ** 聚合成字典print# func(1,2,3,4,5,6,7) # 地点参数. 报错func(a=1, b=2, c=3, haha="呵呵", good="not bad"卡塔尔国实参*在实参的是克制,把列表,元组,字符串打散成职分参数实行传递**在形参表示动态传参--关键字参数;打垮,制伏成首要字关于*和** 形参: 聚合 地点参数* ->元组 关键字** -> 字典 实参: 打散 列表,字符串,元素 -> * 字典 ->**无敌传参def func(*args, **kwargs卡塔尔: arguments参数keyword-arguments关键字参数pass效用域和名称空间名称空间:用来寄存在名字(变量,函数名,类名,引进的模块卡塔尔国的1.全局名称空间:大家在py文件中友好写的变量, 函数.....2.置于名称空间;大家python解释器提供好的有的放到内容 (print,input..........卡塔尔国3.局地名称空间:在大家执行函数的时候,会产生二个部分名称空间.放的是:函数内部的内容名称空间或然会有成都百货上千个,对于有些名称空间.相对是单身的,经常互不郁闷效用域:1.全局功能域: 内置 全局2.局地功效域: 局地从大局找局地->找不到从局地找全局->能够找到怎么查看全局或一些中的内容: globals 全局功能域:内置 全局名称空间 locals 查看当前成效域的故事情节def chi(卡塔尔国:a = 20b = 30print # 查看当前效用域中的内容print卡塔尔国 # alex,老男孩儿, 武sir, 全局功能域中的内容chi(卡塔尔国print # 全局print) # 全局函数的嵌套nonlocal和global 关键字global 表示从全局把一个变量引进局地,前边使用的都以全局变量nonlocal 在有些,寻觅离他近期的外围的八个变量若无global和nonlocal ,查找的次第:自个儿,上黄金时代层,上意气风发层,上豆蔻年华层函数的相互作用调用def func1(卡塔尔(قطر‎:print("作者是神器的func1"卡塔尔def func2(卡塔尔国:func1(卡塔尔(قطر‎print("小编是神器的func2"卡塔尔def func3(卡塔尔(قطر‎:print("作者是神器的func3"卡塔尔# func5(卡塔尔国def func4(卡塔尔(قطر‎:func3(卡塔尔(قطر‎print("作者是神器的func4"卡塔尔(قطر‎def func5(卡塔尔:func2(卡塔尔国func3(卡塔尔print("作者是神器的func5"卡塔尔(قطر‎def func6(卡塔尔:func5(卡塔尔(قطر‎print("笔者是神器的func6"卡塔尔(قطر‎func3(卡塔尔(قطر‎func1(卡塔尔(英语:State of Qatar)func6(卡塔尔国def outer(卡塔尔(英语:State of Qatar):def inner(卡塔尔国:printprint("仍然是能够那样写???"卡塔尔国inner(卡塔尔(قطر‎outer(卡塔尔(قطر‎inner(卡塔尔(قطر‎ # 在全局不可能找到局地的源委def func1(卡塔尔(英语:State of Qatar):printdef func2(卡塔尔国:printdef func3(卡塔尔:printprintfunc3(卡塔尔printprintfunc2(卡塔尔国printfunc1(卡塔尔国全局变量平时是无法随随意便的更动的a = 10def func(卡塔尔国:# 慎用.global a# global 代表从大局把四个变量引入到一些, 后边使用的a都是全局变量a = 10 # ?? a = a 10 # 未来的a是大局的, 你将来视图改全局变量print("里面包车型地铁打字与印刷",a卡塔尔(قطر‎func(卡塔尔(قطر‎print("外面包车型大巴打字与印刷", a卡塔尔(قطر‎a = 10def func(卡塔尔国:def inner(卡塔尔:# 慎用.global a# global 代表从大局把多少个变量引进到部分, 前面使用的a都以全局变量a = 10 # ?? a = a 10 # 今后的a是大局的, 你以往视图改全局变量print("里面包车型客车打字与印刷",a卡塔尔inner(卡塔尔(قطر‎func(卡塔尔(英语:State of Qatar)print("外面包车型大巴打印", a卡塔尔国nonlocal在部分, 寻觅离他近年来的外层的二个变量a = 50def func1(卡塔尔(英语:State of Qatar):# a = 10 # 局部def func2():nonlocal a # 不找全局, global找全局a = 10 # a = a 10 python不让这么干print("func2", a卡塔尔(英语:State of Qatar)func2(卡塔尔(قطر‎printfunc1(卡塔尔print若无nonlocal和global 查找的次第: 本人, 上风华正茂层, 上意气风发层, 上生龙活虎层def func0(卡塔尔:a = 50def func1(卡塔尔(قطر‎:a = 10 # 局部def func2():nonlocal a # 不找全局, global找全局a = 10 # a = a 10 python不让这么干print("func2", a卡塔尔(قطر‎func2(卡塔尔国printfunc1(卡塔尔(قطر‎printfunc0(卡塔尔(قطر‎a = 1def fun_1():a = 2def fun_2():nonlocal aa = 3def fun_3():a = 4printprintfun_3()printprintfun_2()printprintfun_1()printflag = Falsedef login():global flaguname = inputupwd = inputif uname == "alex" and upwd == "123":flag = Trueelse:flag = Falsedef fatie():if flag == True:printelse:printlogin()fatie()fatie()fatie()fatie()

动态参数了.

3.global和nonlocal

global:

1 a = 10#全局变量,本身不安全,不能随意修改
2 def fun():
3     global a#  1.可以把全局中的内容引入到函数内部,2.在全局创建一个变量
4     a = 20
5     a  = 10
6     print(a)
7 fun()

nonlocal:

1 a = 10
2 def outer():
3     def inner():  #在inner中改变a的值
4         nonlocal a  #寻找外层函数中离他最近的那个变量
5             a = 20
6     inner()
7 outer()

函数能够相互嵌套

 

def chi(quality_food, junk_food):

   print("我要吃", quality_food, junk_food)

chi("⼤⽶饭", "⼩⽶饭") # "⼤⽶饭"传递给quality_food "⼩⽶饭"传递给junk_food,按照位置传

1.函数的动态参数:

  1.*args   地方参数动态传参

    

1 def fun(a,b,c,d,e):
2     print(a,b,c,d,e)
3 fun(1,2,3,4,5)

结果:1 2 3 4 5

逐一:地点参数=>*args=>私下认可值参数

*在这里间代表选用地方参数的动态传参,选择到的是元组

 

1 def fun(a,*b,c=5): #参数名是b,*表示动态传参
2     print(a)
3     print(b)
4     print(c)
5 fun(1,2,3,4)

结果为:1

     2 3 4

     5

将首先个值赋值给a,后边的值都给b

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

    

1 def fun(a,**kwargs):
2     print(a)
3     print(args)
4 fun(1,b=2,c=3)

结果为:

    1

    {'b':1,'c':2}

**在此边表示的是吸纳关键字的动态传参,选拔到的是字典

各种:地点参数,*args,私下认可值参数,**kwargs

如上参数能够随意搭配使用

 

1  def fun(a, *args, c="哈哈",  **kwargs):
2      print(a, args, c, kwargs)
3  fun(1, 2, 3, 4,5, 6)

结果为:

    1,(2,3,4,5,6),哈哈,{}

单行注释#

多行注释'''  '''

1 def fun(a,b):
2     """
3     #这个函数是用来计算a和b的和
4     :param a:#第一个数据
5     :param b:#第二个数据
6     :return:#返回的是两个数的和
7     """
8     return a b
9 fun(1,2)

 

吸收接纳全部参数

def fun(*args,**kwargs):

  print(args,kwargs)

fun(1,2,3,a=4,b=5)

 

*在形参地方:聚合(地方参数)

1 def fun(*lst):
2     print(lst)
3 
4 lst = [1,2,3,4,5]
5 fun(lst)

结果为:([1,2,3,4,5])

 

 

*在实参地方:击溃

1 def fun(*lst):
2     print(lst)
3 
4 lst = [1,2,3,4,5]
5 fun(*lst)#把list,tuple,set,str进行迭代打散

结果为:(1,2,3,4,5)

 

**在形参地点(聚合成关键字参数)

 

1 def fun(**kwargs):
2     print(kwargs)
3 dic = {"name":"abc","age":18}
4 fun(**dic)#**在实参位置打散成关键字参数

结果为:

{"name":"abc","age":18}

 

 

 

 

认值是世代都⽣效的.

 作⽤域: 作⽤域正是作⽤范围, 依据⽣效范围来看分成 全局作⽤域和一些作⽤域

 在python解释器初阶执⾏之后, 就能够在内部存款和储蓄器中开荒⼀个空间, 每当遇上⼀个变量的时候, 就

 2. 大局命名空间

 在形参的职位上的* 表⽰把收到到的参数组合成⼀个元组

三. 函数的嵌套

 函数的笺注:

 ⾸先大家写这么⼀个代码, ⾸先在全局评释⼀个变量, 然后再有的调⽤那个变量, 并改造那

 2. 有的命名空间--> 在函数中扬言的变量会放在局地命名空间

def chi(food, drink):

   """

   这⾥是函数的注释, 先写⼀下当前这个函数是⼲什么的, ⽐如我这个函数就是⼀个吃

   :param :param food: 参数food是什么意思

   :param :param drink: 参数drink是什么意思

   :return :return: 返回的是什么东东

   """

   print(food, drink)

   return "very good"

 大家得以因此globals(卡塔尔国函数来查阅全局作⽤域中的内容, 也足以经过locals(卡塔尔来查看局地作

 

 2. 大局命名空间

def fun(**kwargs):

   print(kwargs)

dic = {'a':1, 'b':2}

fun(**dic)

 

 

 

 1. 大局作⽤域: 全局命名空间 内置命名空间

风姿浪漫.前几天重点内容

把变量名和值时期的涉及记录下来, 可是当遭逢函数定义的时候, 解释器只是把函数名读入内

下一场再⽤动态参数

 

 将来主题素材来了. 小编想吃自便的食物. 数量是随便的, 食物也是自由的. 那时我们就要⽤到

 

 早先大家说过了传参, 假若我们要求给⼀个函数字传送参, ⽽参数⼜是不明确的. 大概小编给⼀个

 

假定想接纳全部的参数:

 作⽤域命名空间:

四. 关键字global和nonlocal

 动态参数的另⼀种传参⽅式:

 

def func(**kwargs):

   print(kwargs)

func(a=1, b=2, c=3)

func(a=1, b=2)

结果:

{'a': 1, 'b': 2, 'c': 3}

{'a': 1, 'b': 2}

 那时程序运⾏会报错. 因为前⾯传递步向的有着地点参数都被*food选取了. a和b永世接纳

 

 3. 内置命名空间

 global表⽰. 不再使⽤局地作⽤域中的内容了. ⽽改⽤全局作⽤域中的变量

a = 100

def func():

     global a # 加了个global表示不再局部创建这个变量了. ⽽是直接使⽤全局的a

     a = 28

     print(a)

func()

print(a)

python_day_10

 取值顺序:

 ⾸先我们先想起⼀下地方参数, 地点参数, 遵照岗位进⾏传参

def chi(*food):

   print("我要吃", food)

chi("⼤⽶饭", "⼩⽶饭")

结果:

我要吃 ('⼤⽶饭', '⼩⽶饭') # 多个参数传递进去. 收到的内容是元组tuple

次第: 地方参数, 动态参数*, 默许值参数

 

  1. 动态参数
    职务参数的动态参数: *args
    首要字参数的动态参数 : **kwargs
    顺序:
    位置,*args,默认值,**kwargs
    在形参上*聚合, **聚合
    在实参上*打散, **打散
  2. 取名空间和功效域
    取名空间:
  3. 松开命名空间: python解释在这之中运营时的变量函数
  4. 大局命名空间: 大家在py文件中直接证明出来的变量,函数
  5. 后生可畏部分命名空间: 在函数内部宣称的变量和函数.
    作用域:
    1.全局功效域:内置 全局
    2.局地成效域:局部
    globals(卡塔尔(英语:State of Qatar) 查看全局作用域中的名字
    locals(卡塔尔国 查看当前作用域中的名字

    1. global和nonlocal
      global: 把全局变量获得部分来用.
      nonlocal: 把离她前不久的后生可畏层的变量拿过来.不会找全局

 动态接纳参数的时候要小心: 动态参数必需在职责参数后⾯

 3. 局地命名空间(函数被执⾏的时候卡塔尔

 

⽤域中的变量和函数音讯

 再看, 假若嵌套了许多层, 会是⼀种什么坚守:

 

def func(*args, **kwargs):

   print(args, kwargs)

func("麻花藤","⻢晕",wtf="胡辣汤")
a = 10

def func():

   a = 20

   print(a)

func() # 20

不到参数

 大家给寄放名字和值的关联的上空起⼀个名字叫: 命名空间. 大家的变量在蕴藏的时候就

10. 前⽅⾼能-函数的进级

 1. 大局命名空间--> 我们一贯在py⽂件中, 函数外证明的变量都归于全局命名空间

 1. 有的命名空间

 

 那暗中认可值参数呢?

本节关键内容:

 如若是⼀个字典, 那么也足以征服. 不过须要⽤八个*

def func(a, b, c, d):

   print(a, b, c, d)

# 关键字参数必须在位置参数后⾯, 否则参数会混乱

func(1, 2, c=3, 4)

是储存在这里片空间中的.

 动态参数分成三种:

 顺序的标题, 在函数调⽤的时候, 要是先付给关键字参数, 则整个参数列表会报错.

def fun(*args):

   print(args)

lst = [1, 4, 7]

fun(lst[0], lst[1], lst[2])

fun(*lst) # 可以使⽤*把⼀个列表按顺序打散

s = "⾂妾做不到"

fun(*s) # 字符串也可以打散, (可迭代对象)

 命名空间分类:

在python中使⽤**来选用动态关键字参数

⼆. 命名空间

 

 

  1. 若是遇⻅了(卡塔尔就是函数的调⽤. 若无(卡塔尔国就不是函数的调⽤

  2. 函数的执⾏顺序

如此的程序大器晚成旦能解析明⽩. 那么作⽤域, global, nonlocal就没难题了

作业:

 那时候大家开掘具有的暗中认可值都⽣效了. 那个时候借使不提交关键字传参. 那么您的默

def chi(*food, a, b):

   print("我要吃", food, a, b)

chi("⼤⽶饭", "⼩⽶饭", "⻩⽠", "茄⼦")

置命名空间

 当时a和b就有值了, 不过这么写吗地点参数就不能够⽤了. 所以. 大家要先写地方参数,

 2. 有些作⽤域: 局部命名空间

 全局作⽤域: 满含内置命名空间和大局命名空间. 在总体⽂件的别之处都能够使⽤(遵守

其间宣称的变量来进⾏开垦变量的里边空间. 随着函数执⾏达成, 那个函数内部变量占⽤的空

 

在参数地方编写*表⽰选拔大肆内容

 此时选用的是⼀个dict

def chi(*food, a, b):

   print("我要吃", food, a, b)

chi("⼤⽶饭", "⼩⽶饭", a="⻩⽠", b="茄⼦") # 必须⽤关键字参数来指定

函数字传送超多参数, 作者的形参将要写比相当多, 很⿇烦, 咋做呢. 大家得以思忖使⽤动态参数.

 

美高梅4858官方网站 1

 



=============================7.20更新 =============================

 

 

 

 

 地方参数 > *args > 私下认可值参数 > **kwargs

 

间也会趁机函数执⾏实现⽽被清空.

 

 在python中得以动态的地点参数, 可是*这种情景只好抽取地方参数⽆法选取关键字参数.

 所以关键字参数必得在职位参数后⾯. 由于实参是以此顺序. 所以形参采取的时候也是那

def chi(a, b, *food, c="娃哈哈"):

   print(a, b, food, c)
  
chi("⾹蕉", "菠萝") # ⾹蕉 菠萝 () 娃哈哈 默认值⽣效

chi("⾹蕉", "菠萝", "葫芦娃") # ⾹蕉 菠萝 ('葫芦娃',) 娃哈哈 默认值⽣效

chi("⾹蕉", "菠萝", "葫芦娃", "⼝罩") # ⾹蕉 菠萝 ('葫芦娃', '⼝罩') 娃哈哈 默

认值⽣效

 最终顺序(*):

 大家开掘默许值参数写在动态参数前⾯. 默许值独有⼀种景况恐怕会⽣效.

 3. 内置命名空间--> 寄存python解释器为大家提供的名字, list, tuple, str, int那几个都以内

⼀. 函数参数--动态传参

二,写函数,接收n个数字,求这些参数数字的和。(动态传参)

def s(*num):
    sum = 0
    for i in num:
        sum  = i
    return sum
print(s(1,2,3,4,5))

三,读代码,回答:代码中,打印出来的值a,b,c分别是什么?为什么?

a=10
b=20
def test5(a,b):
    print(a,b)
c = test5(b,a)
print(c)

a =20
b =10
c =None

四,读代码,回答:代码中,打印出来的值a,b,c分别是什么?为什么?

a=10
b=20
def test5(a,b):
    a=3
    b=5
print(a,b)
c = test5(b,a)
print(c)

a = 10
b = 20
c = None

五.写函数,传入函数中多个实参(均为可迭代对象如字符串,列表,元祖,集合等),
将每个实参的每个元素依次添加到函数的动态参数args里面.
例如 传入函数两个参数[1,2,3] (22,33)最终args为(1,2,3,22,33)

def func(*args):
    return args

a = [1,2,3]
b = (22,33)
print(func(*a,*b))

六,写函数,传入函数中多个实参(实参均为字典),将每个实参的键值对依次添加到函数的动态参数kwargs里面.
例如 传入函数两个参数{‘name’:’alex’} {‘age’:1000}最终kwargs为{‘name’:’alex’ ,‘age’:1000}

def func(**kwargs):
    return kwargs

a = {'name':'alex'}
b = {'age':1000}
print(func(**a,**b))

7, 下面代码成立么?如果不成立为什么报错?怎么解决?

#7.1
    a = 2
    def wrapper():
            print(a)
    wrapper()
#成立

# 7.2
a = 2
def wrapper():
    a  = 1
    print(a)
wrapper()
#不成立,在赋值前引用全局变量a

# 7.3
def wrapper():
    a = 1
    def inner():
        print(a)
    inner()
wrapper()
#成立

# 7.4
def wrapper():
    a = 1
    def inner():
        a  = 1
        print(a)
    inner()
wrapper()
# 不成立,在赋值前引用局部变量a

八,写函数,接收两个数字参数,将较小的数字返回.

def func(a,b):
    if a < b:
        return a
    else:
        return b
x = func(12,23)
print(x)

九,写函数,接收一个参数(此参数类型必须是可迭代对象),将可迭代对象的每个元素
以’_’相连接,形成新的字符串,并返回.
例如 传入的可迭代对象为[1,'老男孩','武sir']返回的结果为’1_老男孩_武sir’

def func(lst):
    s = ""
    for i in lst:
        s  = str(i)   "_"
    print(s.strip("_"),end="")
lst = [1,'老男孩','武sir']
func(lst)

十,写函数,传入n个数,返回字典{‘max’:最大值,’min’:最小值}
例如:min_max(2,5,7,8,4) 返回:{‘max’:8,’min’:2}(此题用到max(),min()内置函数)

def func(*num):
    dic = {}
    dic["max"] = max(num)
    dic["min"] = min(num)
    return dic
a = func(1,23,3,4,44,4,5,)
print(a)

11.,写函数,传入一个参数n,返回n的阶乘
例如:cal(7)  计算7*6*5*4*3*2*1

def func(n):
    if n == 0:
        return True
    return n * func(n - 1)
a = func(3)
print(a)

12.写函数,返回一个扑克牌列表,里面有52项,每一项是一个元组
例如:[(‘红心’,2),(‘草花’,2), …(‘黑桃’,‘A’)]

def func():
    l = ['红心','黑桃','方片','梅花']
    l1 = ["A",2,3,4,5,6,7,8,9,10,'J','Q','K']
    l2 = []
    for i in l:
        for j in l1:
            l2.append((i,j))
    return  l2

print(func())

13 有如下函数:
def wrapper():
       def inner():
           print(666)
   wrapper()

你可以任意添加代码,用两种或以上的方法,执行inner函数.

# 第一种:
def wrapper():
    def inner():
        print(666)
    inner()
wrapper()
#第二种:
def wrapper():
    def inner():
        print(666)
    return inner
wrapper()()

14相关面试题(先从纸上写好答案,然后在运行):
1,有函数定义如下:
def calc(a,b,c,d=1,e=2):
    return (a b)*(c-d) e
请分别写出下列标号代码的输出结果,如果出错请写出Error。

print(calc(1,2,3,4,5))#__2___
print(calc(1,2))#__Error__
print(calc(e=4,c=5,a=2,b=3))#_24__
print(calc(1,2,3))#__8___
print(calc(1,2,3,e=4))#__10__
print(calc(1,2,3,d=5,4))#__Error___

2,(此题有坑)下面代码打印的结果分别是____[10,'a]_____,____[123]____,___[10'a_']____.

def extendList(val,list=[]):
    list.append(val)
    return list
list1 = extendList(10)
list2 = extendList(123,[])
list3 = extendList('a')

print('list1=%s'%list1)
print('list2=%s'%list2)
print('list3=%s'%list3)

3, 写代码完成99乘法表.(升级题)

1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
......
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81

def func(a):
    for i in range(1,a 1):
        for j in range(1,i 1):
            r = i * j
            print("%s * %s = %s" % (i,j,r),'    ',end="")
        print(end = "n")
#
func(9)
Traceback (most recent call last):

 File "/Users/sylar/PycharmProjects/oldboy/fun.py", line 95, in <module>

 chi("⼤⽶饭", "⼩⽶饭", "⻩⽠", "茄⼦")

TypeError: chi() missing 2 required keyword-only arguments: 'a' and 'b'

 

个顺序. 约等于说地方参数必得在关键字参数前⾯. 动态接收关键字参数也要在后⾯

个变量的值

  1. 动态选取关键字参数

 在实参地点上给⼀个体系,列表,可迭代对象前⾯加个*表⽰把那一个队列按梯次征服. 

 这二种参数能够任意的进⾏使⽤.

def chi(a, b, *food):

   print("我要吃", a, b, food)

chi("⼤⽶饭", "⼩⽶饭", "馒头", "⾯条") # 前两个参数⽤位置参数来接收, 后⾯的参数⽤

动态参数接收
a = 10

def func():

   a = 40

   b = 20

   def abc():

     print("哈哈")

   print(a, b) # 这⾥使⽤的是局部作⽤域

   print(globals()) # 打印全局作⽤域中的内容

   print(locals()) # 打印局部作⽤域中的内容

func()

 

lst = ["麻花藤", "刘嘉玲", "詹姆斯"]

def func():

     lst.append("⻢云云") # 对于可变数据类型可以直接进⾏访问. 但是不能改地址. 说⽩

了. 不能赋值

     print(lst)

func()

print(lst)

 形参的第三种: 动态参数

def fun():

   a = 10

   print(a)

fun()

print(a) # a不存在了已经..

2018-07-20  16:04:08

 1. 松开命名空间

def chi(a, b, c='馒头', *food):

   print(a, b, c, food)

chi("⾹蕉", "菠萝") # ⾹蕉 菠萝 馒头 (). 默认值⽣效

chi("⾹蕉", "菠萝", "葫芦娃") # ⾹蕉 菠萝 葫芦娃 () 默认值不⽣效

chi("⾹蕉", "菠萝", "葫芦娃", "⼝罩") # ⾹蕉 菠萝 葫芦娃 ('⼝罩',) 默认值不⽣效

 所以必得改写成以下代码:

  1. 动态选用地方参数

的时候函数只是加载进来, 仅此⽽已, 独有当函数被调⽤和会见的时候, 解释器才会基于函数

从上到下逐⾏执⾏卡塔尔(قطر‎. 局地作⽤域: 在函数内部可以使⽤.

 加载顺序:

存, 表⽰那些函数存在了, ⾄于函数内部的变量和逻辑, 解释器是不关⼼的. 也正是说⼀起先

 

  1. 函数参数--动态传参
  2. 名称空间, 局地名称空间, 全局名称空间, 作⽤域, 加载顺序.
  3. 函数的嵌套
  4. gloabal, nonlocal关键字

nonlocal 表⽰在一些作⽤域中, 调⽤⽗级命名空间中的变量.

本文由分分快三计划发布,转载请注明来源

关键词: 进阶 函数 day