zoukankan      html  css  js  c++  java
  • Python_009(函数,命名空间)

    一.函数

    1.函数格式:

     1 #定义函数:
     2 
     3 def function():
     4 
     5   函数体
     6 
     7   return 返回值
     8 
     9 #调用函数:
    10 
    11 function()
    12 
    13 ret = function()
    14 
    15 这是得到返回值.

    这里是用关键字def定义函数,函数命名规则基本和变量一样;

    返回值问题:执行完函数之后,我们可以用return来返回结果,

    a:函数中若遇到return时,此函数结束,不在继续执行;

    b:return返回值可以有多个,但有几个需要注意的地方:

    1 def sum():
    2     return "","",""
    3 re = sum()
    4 print(re)
    5 a,b,c = sum()
    6 print(a,b,c)
    7 #输出结果:
    8 ('', '', '')
    9 小 大 中

    *从上述代码可以看出,return可以返回多个值,返回类型是元组,(元素,元素,元素)

    可以利用结构的办法拿出单个元素:

    c:如果return什么都不写,或者不写return,那么返回的就是None;

    2.函数的参数

    形参:写在函数声明的位置的变量叫形参,例:def function(count)里面的count就是形参;

    实参:在函数调用的时候给函数传递实际的参数值,例:function(9)里面的9就是实际传给count的值;

    传参:就是把实参的信息或数据传递给形参的一个过程;

    def yue(chat):    # chat  形参    
    print("拿出⼿手机")    
    print("打开"+chat)    
    print("找个漂亮的妹⼦子")    
    print("约不不约") 
    
    yue("陌陌")    # 实参 len("字符串串")    
    # "字符串串"在这⾥里里就是实参 
    
    print("麻花藤")    # "麻花藤"就是实参

    3.参数的分类

    a.位置参数

    如果有多个形参和实参进行传递的话:

    a:实参的位置参数必须和形参一一对应,在实参中的混合参数这一块,位置参数必须放在关键字参数前面;

    def function(count, sum,name = "",):#形参:函数定义时,给函数定义的变量值
        while count < 10:
            print("刘博文是条单身{xi}狗,{he}!".format(xi = name,he = sum))
            count += 1
    function(9, 666, name="马化腾")
    function(9, 555, "没毛")
    
    #这里的9和666是位置参数,系统默认把实参赋值给形参,必须一一对应
    #这里的name是关键字参数,若是单独使用,不用考虑位置问题,
    如果实参没有传递给形参的值,形参就会显示默认值,这里""字就是默认值
    ***注意,形参中必须要先声明位置参数,才能声明默认值参数!

     二.动态传参

    1.问题引入:位置参数是按照位置进行传参;如果想吃任意的食物,数量是任意的,食物也是任意的,

    两个都是不定量,所以就引入动态参数了.

    2.动态接收位置参数

    格式:def func(*food)#这里的*就是聚合多个位置参数的符号

        print("我要吃",food)

       func(任意量的值)所以调用函数的时候,得到的结果就是任意量的值;

    1 def func(name,age,*food,sex=""):
    2     print(name,age,sex,food)
    3 func("",12,2,3,1,4)
    4 #结果:周 12 男 (2, 3, 1, 4)

    这里的结果是以元组的形式显示的;

    注意:*args只是聚合多个位置参数,如果实参中只有一个对象(任意数据类型),直接按位置参数传入就可以;

    而*args是接收多个对象,例如接收多个列表或元组或一个列表和一个元组;

    b:还有一点,关于**kwargs的,代码如下

     1 def func(*args, **kwargs):
     2     args = (1,2,3)
     3     print(*args)  # print(*(1,2,3))
     4     print(**kwargs)  # print(**{'name':'alex', 'age':1000})
     5 func(1, 2, 3, name='alex', age=1000)
     6 #输出结果
     7 1 2 3
     8 Traceback (most recent call last):
     9   File "D:/Python/course/16.面向对象/课堂笔记/day16/02 函数总结 代码.py", line 7, in <module>
    10     func(1, 2, 3, name='alex', age=1000)
    11   File "D:/Python/course/16.面向对象/课堂笔记/day16/02 函数总结 代码.py", line 3, in func
    12     print(**kwargs)  # print(**{'name':'alex', 'age':1000})
    13 TypeError: 'name' is an invalid keyword argument for this function

    #这里第3行的print(*args)被正常执行了,但是第四行报错了,说明这里面**kwargs是不能直接在函数中打散的;

    2.动态接收关键字参数

    在Python中我们**来接收动态关键字参数;

    1 def func(**kwargs):    
    2     print(kwargs) 
    3 func(a=1, b=2, c=3) 
    4 func(a=1, b=2) 
    5 结果: {'a': 1, 'b': 2, 'c': 3} {'a': 1, 'b': 2}

    #这里输出是以字典的格式输出的,fun(a=1)a代表key值,1代表value值;

    4.参数位置总结:

    位置参数 >> *args >> 默认值参数 >> *kwargs这四种参数可任意的组合使用;

    5.如何把字典和列表传入参数

    注意:1.字典和列表都可以单独直接传入参数,只是*args可以接收多个列表,也就是位置参数,参数可以是任意数据类型,

    都会作为整体传进去;

    2.若是两个列表想要合成一体进行操作,可以在实参位置打散再在形参位置聚合元素;

    1 lst = ["a","b","c","d"]
    2 def func(*enter):  #聚合,把所以位置的参数,聚合成元组
    3     print(enter)
    4 func(*lst) #*表示打散元素
    5 #输出结果:('a', 'b', 'c', 'd')

    #在实参的位置加一个*号,表示把元素迭代添加到函数中;字符串可以被打散;

    b:如果是字典的话也可以被打散:

    1 def func(**enter):  #聚合,把关键字的参数,聚合成字典
    2     print(enter)
    3 dic = {"a":1,"b":2,"c":3,"d":4}
    4 func(**dic) #**表示打散字典
    5 #输出结果:{'a': 1, 'b': 2, 'c': 3, 'd': 4}

    6.函数注释

     1 def func(**enter):  #聚合,把关键字的参数,聚合成字典
     2     '''
     3     这个函数就是接收一个字典的参数
     4     :param enter: 把关键字的参数聚合成字典
     5     :return: 返回一个真
     6     data:2018-7-13
     7     author:ff
     8     '''
     9     print(enter)
    10     return True

    这里的''' ''' 中的就是函数体里的注释;

    *******Python中不是所有的函数都有返回值,退出函数中就什么都不返回!

    三.命名空间

    1. 全局命名空间-> 我们直接在py文件中, 函数外声明的变量都属于全局命名空间

    2. 局部命名空间-> 在函数中声明的变量会放在局部命名空间

    3. 内置命名空间-> 存放python解释器提供的关键字, list, tuple, str, int这些都是内置命名空间

     加载顺序:1.内置-->全局-->局部   取值顺序:2.局部-->全局-->内置

    四.作用域

    作⽤用域:作⽤用域就是作⽤用范围, 按照⽣生效范围来看分为 全局作⽤用域和局部作⽤用域   

    全局作⽤用域: 包含内置命名空间和全局命名空间. 在整个⽂文件的任何位置都可以使⽤用(遵循 从上到下逐⾏行行执⾏行行). 局部作⽤用域: 在函数内部可以使⽤用.             

    作⽤用域命名空间:         

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

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

    我们可以通过globals()函数来查看全局作⽤用域中的内容,也可以通过locals()来查看局部作 ⽤用域中的变量量和函数信息

     1 a = 10
     2 def func():
     3     a = 40
     4     b = 20
     5     def abc():
     6         print("哈哈")
     7     print(a,b)
     8     print(globals()) #打印全局作用域的内容
     9     print(locals())  #打印局部作用域的内容
    10 func()
    11 #结果:{'a': 10,}  a = 10是全局作用域
    12 { 'b': 20, 'a': 40}  而a=40,b=20在函数内部可以使用

    五.两个关键字global和nonlacal

    1.global

    a = 10    #全局变量
    def func():
        b = 20    #局部变量
       a = 10
       print(a) #这里面采用就近原则,如果内部找不到变量a,就会再向外扩展,找到a=10 print(b) def func1(): print(b) #局部变量 func() func1() #输出结果:20 第二个函数调用时报错,找不到b 所以,全局变量包含着局部变量,而局部变量不能互相穿插;

    global的使用:

     1 a = 10
     2 def func():
     3     global a
     4     a = 20
     5     print(a)
     6 func()
     7 print(a)
     8 #输出结果:
     9 20
    10 20

    这里用一个比喻:就是外面(全局变量)有个叫a的,他等于10,我用global把他拽过来,打死,那这个a

    就死了,因为他和局部变量已经是同一个a了.

    2.nonlocal

    a:大致和global一样,但是他调用的是最近一层的变量,不能调用全局变量;只能在函数体中;

     

     

  • 相关阅读:
    Ubuntu adb devices :???????????? no permissions (verify udev rules) 解决方法
    ubuntu 关闭显示器的命令
    ubuntu android studio kvm
    ubuntu 14.04版本更改文件夹背景色为草绿色
    ubuntu 创建桌面快捷方式
    Ubuntu 如何更改用户密码
    ubuntu 14.04 返回到经典桌面方法
    ubuntu 信使(iptux) 创建桌面快捷方式
    Eclipse failed to get the required ADT version number from the sdk
    Eclipse '<>' operator is not allowed for source level below 1.7
  • 原文地址:https://www.cnblogs.com/0627zhou/p/9298472.html
Copyright © 2011-2022 走看看