精华内容
下载资源
问答
  • 一:全局参数与局部参数的典型举例 ①:在函数外定义name并在函数内定义name >>> name='louis' >>> def fun(): name='wedi' print(name) >>> fun() wedi >>> print...

    一:全局参数与局部参数的典型举例

    ①:在函数外定义name并在函数内定义name

    >>> name='louis'
    >>> def fun():
        name='wedi'
        print(name)
    >>> fun()
    wedi
    >>> print(name)
    louis
    >>> 

    ②:在函数外定义name并在函数内直接引用

    >>> name='louis'
    >>> def fun():
        print(name)
    >>> fun()
    louis
    >>> print(name)
    louis

    由上第一个例子可知,函数虽然对name重新赋值,但并没有覆盖函数前已经定义了的name,故函数内的name为局部参数,由第二个例子可知全局参数可被函数直接引用。综上可知,函数调用的过程为,先查询局部内是否定义,如有则直接使用,否则向上一级查找。直至找到为止,且局部重新赋值后,该值只能在函数内使用,并不影响全局参数。

    二:就要局部修改,同时全局也跟着变

    >>> name='louis'
    >>> def fun():
        global name
        name='wedi'
        print(name)
    >>> fun()
    wedi
    >>> print(name)
    wedi

    由上可知,只需要加global关键字,name就是全局变量。同时需要注意的是,name='wedi',不可在global关键字前。

    三:在函数内对全局可变变量追加与删除

    >>> name=['louis','james']
    >>> def fun():
        name.append('barry')
        print(name)
    >>> fun()
    ['louis', 'james', 'barry']
    >>> print(name)
    ['louis', 'james', 'barry']

    其实变量就是内存的一个地址的指向名称,当该内存地址内的内容为可变时,局部变量就可修改,但内存指向任然不变;当内存地址指向的内容为不可变时,局部变量的赋值,就是在内存里重新开拓内存块存储值,但函数执行完毕,变量的内存指向将重新指向全局变量的内存地址。

     

    转载于:https://www.cnblogs.com/louis181214/p/10172734.html

    展开全文
  • global语句的作用 ...在python的函数使用时,经常会碰到参数定义的问题。如果不声明全局变量,会报错 count = 1 def cc(): count = count+1 cc() Traceback (most recent call last): File "<ipython>", line 1
  • '''我定义参数的时候用已经存在的变量去作为默认参数的默认值 ''' a = '全局变量a' def f(arg1 = a): print(a) f() a= '全局变量a已被修改(1)' f() a=a+'已被修改(2)' f() def fJY(): print('# 此时进入...

    会被当成常量,不会随着同名标识符内容改变而改变。

    '''我定义参数的时候用已经存在的变量去作为默认参数的默认值
    
    '''
    
    a = '全局变量a'
    def f(arg1 = a):
        print(a)
    
    f()
    a= '全局变量a已被修改(1)'
    f()
    a=a+'已被修改(2)'
    f()
    
    def fJY():
        print('# 此时进入函数内部,再次调用<f>的输出:')
        a = '局域变量a'
        f()
        a = '局域变量a已修改(1)'
        f()
        a = a+'已修改(2)'
        f()
    
    fJY()
    
    # 重定义了<f>
    print('# 重定义了<f>,变成了内部函数,arg1的默认值变成了一个局域变量')
    def fJY():
        a = '局域变量a'
        def f(arg1 = a):
            print(a)
        f()
        a = '局域变量a已修改(1)'
        f()
        a = a + '已修改(2)'
        f()
        print('# 此时<del a>')
        del a
        f()
    
    fJY()
    

    最终输出是:

    全局变量a
    全局变量a
    全局变量a
    # 此时进入函数内部,再次调用<f>的输出:
    全局变量a
    全局变量a
    全局变量a
    # 重定义了<f>,变成了内部函数,arg1的默认值变成了一个局域变量
    局域变量a
    局域变量a
    局域变量a
    # 此时<del a>
    局域变量a
    
    展开全文
  • Python语言的设计思想认为全局变量通常是不好的实践并且应该避免使用全局变量,更好的方式是利用参数把一个值传入函数,返回值以获取结果。在 一个函数内部定义的变量 默认是局部变量。这意味着,在函数内部对这个...

    Python 处理全局变量和局部变量的方式其实是相当另类的。在大多数编程语言中,一个未被声明的变量会被当作全局变量,而Python正好相反。在Python中,没有被声明的变量会被当作局部变量。Python语言的设计思想认为全局变量通常是不好的实践并且应该避免使用全局变量,更好的方式是利用参数把一个值传入函数,返回值以获取结果。

    一个函数内部定义的变量 默认是局部变量。这意味着,在函数内部对这个变量做的所有改变对函数外部的变量都不会有影响,即使它们同名,也就是说函数体就是变量的作用域。当然,这里所说的 在函数内部定义的变量 不包括函数参数,这是因为Python认为类型有mutable和immutable之分,对函数参数的处理有所不同,这里其实可以另开一个话题,不在今天的讨论范围之内。

    这里说得更明白点:在Python中,并不需要像C、Java那样显式声明变量。在Python中定义变量时就隐式声明了它,也就是说,当你第一次给一个变量赋值时,变量就被声明了并且自动地获得了指派的值的类型。

    先看一个例子,

    def f(): 
        print(s) 
    s = "I love Paris in the summer!"
    f()

    因为f()内部没有s变量,所以全局变量将会被使用,输出结果:I love Paris in the summer!

    接下来的问题是如果我们在函数内部改变s的值,那么它是否会影响到全局变量呢?

    def f(): 
        s = "I love London!"
        print(s) 
    
    s = "I love Paris!" 
    f()
    print(s)

    输出结果:

    I love London!
    I love Paris!

    上面的例子其实蛮好理解的,前面说过,给一个变量第一次赋值意味着创建一个局部变量,所以其实我们有一个全局变量s和一个局部变量s。Python不允许有二义性,这里我们再看一个例子。

    def f(): 
        print(s)
        s = "I love London!"
        print(s) 
    
    s = "I love Paris!" 
    f()

    输出结果:

    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "<stdin>", line 2, in f
    UnboundLocalError: local variable 's' referenced before assignment

    一个变量在函数内不能既是全局变量又是局部变量。因为在f()内部有对s的赋值,所以Python会认为我们需要的是一个局部变量,所以在定义s之前的打印语句会引起UnboundLocalError。

    为了使用全局变量,我们需要显式说明,使用关键字global

    def f():
        global s
        print(s)
        s = "Only in spring, but London is great as well!"
        print(s)
    
    s = "I am looking for a course in Paris!" 
    f()
    print(s)

    输出结果:

    I am looking for a course in Paris!
    Only in spring, but London is great as well!
    Only in spring, but London is great as well!

    最后一个例子是对全局变量和局部变量的一些特性展示的结合:

    def foo(x, y):
        global a
        a = 42
        x,y = y,x
        b = 33
        b = 17
        c = 100
        print(a,b,x,y)
    
    a,b,x,y = 1,15,3,4
    foo(17,4)
    print(a,b,x,y)

    输出结果:

    42 17 4 17
    42 15 3 4
    展开全文
  • 在函数定义中,经常会碰到*args 和**kwargs作为参数。 事实上在函数中,*和**才是必要的,args和kwargs可以用其他名称代替 *args 是指不定数量的非键值对参数。 **kwargs是指不定数量的键值对参数。 *args 作为...

    一、不定长参数

    在函数定义中,经常会碰到*args 和**kwargs作为参数。

    事实上在函数中,*和**才是必要的,args和kwargs可以用其他名称代替

    *args 是指不定数量的非键值对参数。 

    **kwargs是指不定数量的键值对参数。

    *args 作为作为元组匹配没有指定参数名的参数。

    **kwargs作为字典,匹配指定了参数名的参数。

    *args 必须位于**kwargs 之前。

    1、可变参数、参数组,*args    
       # 1、不是必填参数;
    # 2、不限制参数的个数:
    # 3、传入多个参数的时候,他把参数放到一个元组里面
    def send_report(*args): #可变参数、参数组
        print('发邮件')
        print(args)
        # for a in args:
        #     print(a)
    
    send_report()#不传 打印结果为发邮件 ()
    send_report(1)#传一个  打印结果为 发邮件 (1,)
    send_report(1,2,3,4,5)#传多个  打印结果为  发邮件 (1,2,3,4,5)
    2、关键字参数,**kwargs
    # 1、不是必填参数;
    # 2、不限制参数的个数:
    # 3、传入多个参数的时候,他把参数放到一个字典里面
    # 4、必须得使用关键字调用,k=v,k1=v1
    def send_report2(**kwargs): #关键字参数
        print('发邮件')
        print(kwargs)
    
    send_report2()#不传 打印结果为 发邮件 {}
    #send_report2(1)#会报错
    send_report2(name='xiaohei',age=18)#字典   打印结果为  发邮件 {'name':'xiaohei','age':18}
    3、调用函数的时候:
    关键字参数后面不能再写位置参数了。
    *args 调用不能传k=v格式的
    **kwargs 调用必须写k=v格式的
    def myfunc(name,addr,phone,qq,email):
        print(name,addr,phone,qq,email)
    
    myfunc(phone=110,addr='beijing',qq='5345355',email='134@163.com',name='xxx')#使用关键字调用
    myfunc('hanmin',phone=110,addr='beijing',qq='5345355',email='134@163.com')#第一个用的位置参数,剩下的是关键字参数
    #myfunc('哈哈哈',addr='beijing','qqq',email='134@163.com',name='xxx')#此种方法错误,关键字参数后面不能再用位置参数
    
    def myfunc1(name,addr='beijing',*args):
        # print(name,addr,args)
        print('name:',name)
        print('addr:',addr)
        print('args:',args)
    
    myfunc1('xiaohei','xiaobai')#xiaobai给了addr args为()
    # myfunc1('xiaohei',addr='shanghai',args=(1,2,3))#错误,使用关键字调用,args无法传值
    myfunc1('xiaohei','shanghai','hhh','bbb')#args:('hhh', 'bbb')
    
    def myfunc2(name,addr='beijing',**kwargs):
        print('name',name)
        print('addr',addr)
        print('kwargs',kwargs)
    
    myfunc2(name='xiaobai',addr='shanghai',age=18,sex='nv')#kwargs: {'age': 18, 'sex': 'nv'}
    
    
    def myfunc3(name,addr='beijing',*args,**kwargs):
        print('name:',name)
        print('addr:',addr)
        print('args:',args)
        print('kwargs:',kwargs)
    
    myfunc3(name='xiaohei',addr='shanghai',age=18,sex='nv')#k=v形式的会传给kwargs   args: ()   kwargs: {'age': 18, 'sex': 'nv'}
    myfunc3('xiaohei','chengdu','chongqing',country='china')#chongqing传给args;country='china'传给kwargs   args: ('chongqing',) kwargs: {'country': 'china'}

    二、全局变量、局部变量 

    1、全局变量:
    大家都可以用的变量就是全局变量
    不可变的数据类型是全局变量的话,必须得加global:
    int(整型) str(字符串) tuple(元组)
    可变的数据类型是全局变量的话,不需要加global:
    dict(字典) list(列表) set(集合)
      全局变量一般定义在最上面,尽量少用全局变量,会占内存,不安全

    2、局部变量: 函数里面定义的变量都是局部变量,出了函数后无法使用
    language = 'Python'#全局变量
    
    
    def hello():
        language='Java'#局部变量,作用域在函数里面
        print(language)
    
    hello() #结果取局部变量Java
    
    def xiaobai():
        print(language)
    xiaobai() # 结果仍取全局变量Python
    
    def change():
        global language #修改全局变量
        language = 'C#'
        print(language)
    
    change() #结果取修改后的全局变量 C#

    (1)参数传递一个正确的例子:

    money=500
    def test(consume):
        return money - consume
    
    
    def test1(money):
        return test(money) + money
    
    money = test1(money)
    print(money)#结果为500

    (2)参数传递一个错误的例子:

    def test():
        global a
        a = 5
    
    def test1():
        c = a + 5
        return c
    # 若想执行正确则在此处加test()
    res = test1()
    print(res)

    函数需要先调用才能执行

     

    转载于:https://www.cnblogs.com/candysalty/p/11050863.html

    展开全文
  • 一般情况下,使用global 关键字来定义全局变量,但是发现 global 关键字在涉及多个文件时,好像存在问题。 比如,单个文件下用global定义使用全局变量的情况 ,看下面的代码 # -*-coding: utf-8 -*- #from data_def ...
  • # 局部变量:在函数中定义的变量和参数。 # 全局变量:在函数外面,全局范围内定义的变量。 name1 = 'Alice' # 全局变量 name2 = 'Bob' name3 = 'Charlie' def test(name1): name2 = 'Zhang San' # 局部变量,...
  • 1.局部变量和全局变量  1.1局部变量  局部变量是在函数内部定义的变量,只能在定义函数的内部使用  函数执行结束后,函数内部的局部变量会被系统收回  不同函数可以定义相同名字的局部变量,但是各用个的...
  • python中的变量不用声明数据类型,定义函数同理,不用定义函数的数据类型来确定返回的数据 与在其他语言中一样,函数必须先定义再调用,碰到第一个return时结束函数,该return后面的不再执行,用一个return返回多...
  • Day_07 Python学习之路 就在刚刚一瞬间,突然发现时间过的还是真快,从我下定决心学习Python以来,时间如流水般逝去,不知不觉...定义可变参数,参数可变,可以有个或任意多个 例1:累加 def add(*args): ...
  • 全局变量不符合参数传递的精神,所以,平时我很少使用,除非定义常量。今天有同事问一个关于全局变量的问题,才发现其中原来还有门道。 程序大致是这样的: CONSTANT = 0 def modifyConstant() : print CONSTANT ...
  • 全局变量不符合参数传递的精神,所以,平时我很少使用,除非定义常量。今天有同事问一个关于全局变量的问题,才发现其中原来还有门道。 程序大致是这样的: CONSTANT = 0 def modifyConstant() : print CONSTANT ...
  • (1)在定义函数的时候,指定形参的数据类型,提示输入的参数类型(传参错误仍旧执行,只会进行判断) def max(num1:int,num2:int) ->int: ##提示输入者参数类型 ''' 求两数最大值 ##函数功能的介绍,利用help...
  • python定义py文件里面的变量就是全局变量 特点: 代码运行的时候,变量是始终有效的 局部变量: 定义在函数的内部的变量称为局部变量 局部变量的作用域只在函数内有效 函数的内部是可以访问全局变量,但是不能...
  • python全局变量

    2013-06-13 11:59:00
    全局变量不符合参数传递的精神,所以,平时我很少使用,除非定义常量。今天有同事问一个关于全局变量的问题,才发现其中原来还有门道。 程序大致是这样的: CONSTANT = 0def modifyConstant() : print CONSTANT...
  • 如果在函数中出现global 全局变量的名字那么这个函数中即使出现和全局变量名相同的变量名 = 数据也理解为对全局变量进行修改,而不是定义局部变量,gloal a,b return return除了能够将数据返回之外,还有一个隐藏...
  • 一、函数的定义 二、自定义函数: 1.自定义函数 2.main()函数 三、函数的参数传递 1.函数可以没有参数,但必须保留括号: 2.必选参数与可选参数: 3.可变数量参数: 四、函数的返回值 五、局部变量与全局...
  • python中函数的参数传递和返回值都是靠引用传递的 数据保存再内存中的某个位置,变量中存放的时数据再内存中的地址 引用是指变量中记录数据的地址 可以使用id() 函数查看变量中保存数据所在的内存地址 局部变量...
  • python全局变量和局部变量是我们在调用函数时,会很容易混淆的点。首先讲一下局部变量,通常,我们在函数内定义的变量即为局部变量(不加global 参数)。函数中的局部变量无法影响函数外的命名空间中的变量,即使...
  • #自定义函数参数需将未给定值的变量放在前面,给定变量的值放在后面 def func(b,a='red'): c = a + b print (c) print("a:",a, "b:",b, "c:",c) a = 'yell' b = 'ow' func(a,b)#3 zbx@zbxpc:~$ /us...
  • 全局变量:在模块.py中只要我们定义的变量,后面都可以使用。 局部变量:模块.函数中定义的变量,只能在函数中使用,出了函数不再能用 如果不是特殊要求,优先定义“局部变量”,函数在使用后会清除,不会占用过多的...
  • 全局变量和局部变量 全局变量: 1.在函数体和类定义之外声明的变量。作用域为定义的模块,从定义位置开始到直到模块...在函数体内声明的变量,包含形式参数。 2.局部变量的引用比全局变量的快,优先考虑使用。 .
  • 引用全局函数next()则无异常效果同上 注意:写resdlines()方法占用内存大,当数据量大时不适用,而迭代方法占用内存少 2.迭代工具 for…、推导…、map… for…推导…map之所以能够遍历对象,是因为程序在目标上...
  • 全局变量和局部变量 定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。  局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。调用函数时,所有在函数内声明的...
  • 定义在函数内部的变量,函数的参数变量都是局部变量;局部变量的有限范围只能说是该函数的内部;用以下代码来解释局部变量:第5行代码是错误的。 原因:ret是 func 函数内部的局部变量,有效范围是 func 函数内部...
  • Python函数定义与使用

    2020-04-13 15:06:23
    Python函数定义与使用一、函数的定义1.1 函数是一段代码的表示1.2 函数的定义格式1.3 函数IPO二、函数的使用及调用过程2.1 调用是函数运行代码的方式三、 函数参数传递3.1 必选参数&可选参数3.2 可变参数四、...
  • 定义在函数内部的变量(包括函数的参数全局变量: 定义在函数外部,模块内部的变量 python的作用域 作用域也叫命名空间,是访问变量时查找变量名的范围空间 python的四个作用域LEGB 作用域 英文解释 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 901
精华内容 360
热门标签
关键字:

python定义全局参数

python 订阅