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一样,但是他调用的是最近一层的变量,不能调用全局变量;只能在函数体中;