day6 函数

函数

程序而言：函数就是对程序逻辑进行结构化或者过程化的一种编程方法。

built-in function 内置函数→BIF

函数的定义

说明如下：

​ 1.函数代码块以 def 关键词开头，后接函数标识符名称和小括号 ()。

​ 2.任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。

​ 3.函数的第一行语句可以选择性地使用文档字符串----用于存放函数说明。

​ 4.函数内容以冒号起始，并且缩进。

​ 5.return [表达式] 结束函数，选择性的返回一个值给调用方。不带表达式的return相当于返回 None。

其中参数列表和返回值不是必须的,return后也可以不跟返回值,甚至连 return也没有。

对于return后没有返回值的和没有return语句的函数都会返回None值

有些函数可能既不需要传递参数,也没有返回值。

没有参数时,包含参数的圆括号也必须写上,圆括号后也必须有“:”。

格式：

def function_name(arg1,arg2,...,argn):
    func_statements
    return Value

函数调用

def test():
    print("调用函数")
test()

#引用函数

函数文档说明

返回函数说明：

def  add(a,b):
    '''求和'''
    return a+b
print(add.__doc__)

#求和

函数参数

• 不传参数

def test(a):
    print("传入参数",a )
test("asd")

#传入参数 asd

• 参数函数
  • 顺序

def test(a,b):
    print("传入参数",a ,b)
test("asd",'123')

#传入参数 asd 123

函数返回值

有return时返回return后的数据，没有return返回值为none

def test(b):      #有return返回值
    b+=b
    return b
print(test("asd"))

#asdasd

def test(b):
    b+=b
print(test("asd"))

#None

函数参数种类

形参和实参

• 形参
  • 只有在调用时才分配内存单元。调用结束后，会释放所分配的内存单元，所以形参只在函数内部有效，函数调用结束返回主函数时则不能再使用该形参变量。
• 实参
  • 实参是一个确定的值，能够传递给形参。
    • 作为位置参数或者关键字参数传递
• 位置参数
  • 按照顺序传参

def test(a,b,c):
    print(a,b,c)
test(1,2,3)

#1 2 3

• 默认参数
  • 如果传参则覆盖，如果不传则为默认值
  • 必须在位置参数之后

def test(a,b,c=3):
    print(a,b,c)
test(1,2)
test(1,2,2)

#1 2 3
#1 2 2

• 关键字参数
  • 必须在位置参数之后

def test(a,b,c):
    print(a,b,c)
test(1,2,c=3)
test(1,c=3,b=2)

#1 2 3
#1 2 3
#positional argument follows keyword argument

• 不定参数
  • 在python中主要是指 *args 和 **kwargs 两个魔法变量
    • *args用于接收不定长的非key_value对的参数并返回元组
    • **kwargs用于接收不定长的key_value对并返回字典
  • 主要用于函数定义，我们可以将不定数量的参数传递给一个函数

def  test(a,*args):
    print("位置参数:",a)
    print("不定参数:",args)
    print(type(args))
test(1,2,3,4,5,6,7)
test([1,2,3],4,5,6,7)

#位置参数: 1
#不定参数: (2, 3, 4, 5, 6, 7)
#<class 'tuple'>
#位置参数: [1, 2, 3]
#不定参数: (4, 5, 6, 7)
#<class 'tuple'>

def test(**kwargs):
    print(kwargs)
    print(type(kwargs))
test(a=1,b=2,c=3)

#{'a': 1, 'b': 2, 'c': 3}
#<class 'dict'>

多种参数：

def test(x,y,*args,**kwargs):
    print(x,y,args)
    print(kwargs)
test(1,2,3,'s',a=1,b=2,c=3)

#1 2 (3, 's')
#{'a': 1, 'b': 2, 'c': 3}

函数属性

函数属性是python中另外一个使用了句点属性标识并拥有名字空间的领域 ,可以根据句点直接访问函数的属性

def a():
    print('123')
def b():
    print('asd')
print(a.__code__)
print(b.__code__)

内嵌函数

bar()整个函数都处于外部函数foo()的作用域里（foo()是我们可以从外部访问的一个对象区域）。除了在foo()内部，其他地方无法对bar()进行调用。

def func_one(a):
    a+=4
    print(a)
    def func_two(a):
        a-=4
        print(a)
    func_two(a)
func_one(4)

#8
#4

变量作用域(即命名空间)

就作用域而言，Python与C有着很大的区别，在Python中并不是所有的语句块中都会产生作用域。只有当变量在Module(模块)、Class(类)、def(函数)中定义的时候，才会有作用域的概念。

def foo():
    a='foo'
    print(a)
foo()
print(a)

#foo
#name 'a' is not defined

在作用域中定义的变量一般只有在作用域中才能被调用，在if-else，for-else，while-else，等关键字语句块中不会产生作用域。

作用域的类型

python中，使用一个变量时并不需要预先声明它。但在真正使用的时候，他必须绑定到某个内存对象（被定义，赋值）。这种变量名的绑定将在当前作用域引入新的比那辆，同时，屏蔽外层作用域中的同名变量。

• 局部作用域(locale–L)
  • 局部变量：包含在def关键字定义的语句块中，即在函数中定义的变量。每当函数被调用时都会创建一个新的局部作用域。Python中也有递归，即自己调用自己，每次调用都会创建一个新的局部命名空间。在函数内部的变量声明，除非特别的声明为全局变量，否则均默认为局部变量。有些情况需要在函数内部定义全局变量，这时可以使用global关键字来声明变量的作用域为全局。局部变量域就像一个 栈，仅仅是暂时的存在，依赖创建该局部作用域的函数是否处于活动的状态。所以，一般建议尽量少定义全局变量，因为全局变量在模块文件运行的过程中会一直存在，占用内存空间。
    注意：如果需要在函数内部对全局变量赋值，需要在函数内部通过global语句声明该变量为全局变量。
• 嵌套作用域(Enclosing–E)
  • E也包含在def关键字中，E和L是相对的，E相对于更上层的函数而言也是L。与L的区别在于，对于一个函数而言，L是定义在此函数内部的局部作用域
  • 主要为了实现python的闭包，而增加的实现
• 全局作用域(Global–G)
  • 即在模块层次中定义的变量，模块顶层申明的变量具有全局作用域。从外部来看，模块的全局变量就是一个模块对象的属性。
• 内置作用域(Built-in --B)
  • 系统固定模块中定义的变量

搜索变量名的优先级：局部作用域>嵌套作用域>全局作用域>内置作用域 (优先搜索优先级高的作用域，如果搜索到了但是定义在调用之后则报错而不调用下一级优先级的变量。)

a="1"      #正常顺序
def test():
    a="2"
    def test2():
        a='3'
        print(a)
    test2()
    print(a)
print(a)
test()

#1
#3
#2


a="1"         #内嵌中先调用再定义
def test():
    a="2"
    def test2():
        print(a)
        a='3'
    test2()
    print(a)
print(a)
test()

#UnboundLocalError: local variable 'a' referenced before assignment

全局变量和局部变量

gbl_a="asd"
def test():
    loc_a="123"
    print(loc_a)
print(gbl_a)
test()
print(loc_a)

#asd
#123
#NameError: name 'loc_a' is not defined