Python_009(函数,命名空间)

一.函数

1.函数格式:

 #定义函数:

 def function():

 　　函数体

 　　return 返回值

 #调用函数:

 function()

 ret = function()

 这是得到返回值.

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

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

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

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

 def sum():

     return "小","大","中"

 re = sum()

 print(re)

 a,b,c = sum()

 print(a,b,c)

 #输出结果:

 ('小', '大', '中')

 小 大 中

*从上述代码可以看出,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(任意量的值)所以调用函数的时候,得到的结果就是任意量的值;

 def func(name,age,*food,sex="男"):

     print(name,age,sex,food)

 func("周",12,2,3,1,4)

 #结果:周 12 男 (2, 3, 1, 4)

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

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

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

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

 def func(*args, **kwargs):

     args = (1,2,3)

     print(*args)  # print(*(1,2,3))

     print(**kwargs)  # print(**{'name':'alex', 'age':1000})

 func(1, 2, 3, name='alex', age=1000)

 #输出结果

 1 2 3

 Traceback (most recent call last):

   File "D:/Python/course/16.面向对象/课堂笔记/day16/02 函数总结 代码.py", line 7, in <module>

     func(1, 2, 3, name='alex', age=1000)

   File "D:/Python/course/16.面向对象/课堂笔记/day16/02 函数总结 代码.py", line 3, in func

     print(**kwargs)  # print(**{'name':'alex', 'age':1000})

 TypeError: 'name' is an invalid keyword argument for this function

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

2.动态接收关键字参数

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

 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}

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

4.参数位置总结:

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

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

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

都会作为整体传进去;

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

 lst = ["a","b","c","d"]

 def func(*enter):  #聚合,把所以位置的参数,聚合成元组

     print(enter)

 func(*lst) #*表示打散元素

 #输出结果:('a', 'b', 'c', 'd')

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

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

 def func(**enter):  #聚合,把关键字的参数,聚合成字典

     print(enter)

 dic = {"a":1,"b":2,"c":3,"d":4}

 func(**dic) #**表示打散字典

 #输出结果:{'a': 1, 'b': 2, 'c': 3, 'd': 4}

6.函数注释

 def func(**enter):  #聚合,把关键字的参数,聚合成字典

     '''

     这个函数就是接收一个字典的参数

     :param enter: 把关键字的参数聚合成字典

     :return: 返回一个真

     data:2018-7-13

     author:ff

     '''

     print(enter)

     return True

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

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

三.命名空间

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

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

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

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

四.作用域

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

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

作⽤用域命名空间:

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

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

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

 a = 10

 def func():

     a = 40

     b = 20

     def abc():

         print("哈哈")

     print(a,b)

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

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

 func()

 #结果:{'a': 10,}  a = 10是全局作用域

 { '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的使用:

 a = 10

 def func():

     global a

     a = 20

     print(a)

 func()

 print(a)

 #输出结果:

 20

 20

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

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

2.nonlocal

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