函数

• 函数的作用
• 函数的使用原则
• 函数的三种形式
• 函数的返回值
• 函数的参数
• 固定参数
• 非固定参数
• 高阶函数
• 匿名函数
• 作用域
• 递归
• 全局变量与局部变量

为什么要用函数？

#1、代码的组织结构不清晰，可读性差
#2、遇到重复的功能只能重复编写实现代码，代码冗余
#3、功能需要扩展时，需要找出所有实现该功能的地方修改之，无法统一管理且维护难度极大 

函数的使用原则：先定义，后调用。

函数即“变量”，“变量”必须先定义后引用。未定义而直接引用函数，就相当于在引用一个不存在的变量名

#测试一
def foo():
    print('from foo')
    bar()
foo() #报错

#测试二
def bar():
    print('from bar')
def foo():
    print('from foo')
    bar()
foo() #正常

#测试三
def foo():
    print('from foo')
    bar()
    
def bar():
    print('from bar')
foo() #会报错吗?不会


#结论:函数的使用,必须遵循原则:先定义,后调用
#我们在使用函数时,一定要明确地区分定义阶段和调用阶段

#定义阶段，只检测语法，不执行代码
def foo():
    print('from foo')
    bar()
def bar():
    print('from bar')
#调用阶段
foo()

定义函数的三种形式

#1、无参：应用场景仅仅只是执行一些操作，比如与用户交互，打印
#2、有参：需要根据外部传进来的参数，才能执行相应的逻辑，比如统计长度，求最大值最小值
#3、空函数：设计代码结构

def func1(name):  # 有参数
    print(name)
    
def func2():  # 无参数
    print("hello word")
    
    
def func3():  # 空函数
    """void funcation"""
    pass
    

函数返回值(return)

python返回值三种形式

返回值数=0；返回none

返回值数=1；返回object

返回值数>1;返回tuple

示例代码

name = "jack"


def func1():
    print(name)
    # 返回None


def func2():
    x = [1, 2, 3]
    y = {"name": "alex", "age": 56}
    return x, y, 1
    # 返回 ([1, 2, 3], {'name': 'alex', 'age': 56}, 1)

def func3():
    print(name)
    return 666
    # 返回 666

a = func1()
b = func2()
c = func3()
print(a, b, c)

函数参数

函数参数传递概念：对象作为输入发送给函数的方式

1、参数的传递是通过自动将对象赋值给本地变量名来实现的

2、在函数内部的参数名赋值不会影响调用者。因为函数头部的参数名是在函数本地的作用域的。

3、改变函数的可变对象参数的值也许对调用者有影响

不可变参数“通过值”进行传递。像整数和字符串这样的对象是通过对象引用而不是拷贝进行传递的。因为对象不可变，实际效果像拷贝一样

可变对象是通过“指针”进行传递的。列表和字典等可变对象能够在函数内部进行原处的改变，所以在函数退出后仍然有效。

def change(a, b):
    a = 2
    b[0] = "spam"
  
    
x = 1
y = [1,2]

change(x, y)

print(x, y) # 1 ['spam', 2]

形参变量

只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变

实参

可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

def calc(x, y):  # x, y 是形参
    print(x,y)
    
a, b = 1, 2
c = (a, b)  # a,b 是实参

关键参数&默认参数

关键字参数通过变量名进行匹配，使用name=value这种语法。

默认参数，在调用中没有传递，函数头部name=value就是默认参数

默认参数必须放在位置参数之后
小结：在调用时代表关键字参数，在函数头部代表默认参数

def func(a, b=2, c=3):  # b=2,c=3为 默认参数
    print(a, b, c)  # 1 4 3
    
    
func(1, b=4)  # b=4是关键字参数

非固定参数

*args

对于调用者来说，以name传递的所有对象，并作为独立的基于位置的参数

def foo(x, y, *args):
    print(x, y)  # 1 2
    print(args)  # (3, 4, 5)
    
    
foo(1, 2, 3, 4, 5) 


def foo(x, y, *args):
    print(x, y)  # 1, 2
    print(args)  # (3, 4, 5)


foo(1, 2, *[3, 4, 5])


def foo(x, y, z):
    print(x, y, z)  # 1 2 3


foo(*[1, 2, 3])

**kwargs

以name成对的传递所有的关键字，并作为独立关键字参数

def foo(x, y, **kwargs):
    print(x, y)
    print(kwargs)  # {'a': 1, 'b': 2, 'c': 3}


foo(1, y=2, a=1, b=2, c=3)


def foo(x, y, **kwargs):
    print(x, y)
    print(kwargs)  # {'a': 1, 'b': 2, 'c': 3}


foo(1, y=2, **{'a': 1, 'b': 2, 'c': 3})


def foo(x, y, z):
    print(x, y, z)  # 2 3 1


foo(**{'z': 1, 'x': 2, 'y': 3})

*args+**kwargs

def foo(x,y):
            print(x,y)

def wrapper(*args,**kwargs):
    print('====>')
    foo(*args,**kwargs)

命名关键字参数：*后定义的参数，必须被传值（有默认值的除外），且必须按照关键字实参的形式传递

 def foo(x,y,*args,a=1,b,**kwargs):
            print(x,y)  # 1，2
            print(args) # (3, 4, 5)
            print(a)  # 1
            print(b)  # 3
            print(kwargs)  # {'c': 4, 'd': 5}

foo(1,2,3,4,5,b=3,c=4,d=5)

参数总结：

语法	位置	解释
func(value)	调用者	常规参数：通过位置匹配
func(name=value)	调用者	关键字参数：通过变量名匹配
func(*sequence)	调用者	以name传递所有的对象，并作为其独立的给予位置的参数。
func(**dict)	调用者	以name成对的传递所有的关键字/值，并作为独立的关键字参数
def func(name)	函数	常规参数：通过位置或者变量名进行匹配
def func(name=value)	函数	默认参数值，如果没有在调用中传递的话
def func(*name)	函数	匹配并收集（在元组中）所有包含位置的参数
def func(**name)	函数	匹配并收集（在字典中）所有包含位置的参数
def func(*args, name)	函数	参数必须在调用中按照关键字传递
def func(*, name=value)	函数	python3.0+中，跟在 * name或一个单独的 * 之后的任何正式的默认的参数都是keyword-only参数，必须按照关键字传递

全局变量与局部变量

1、在子程序中定义的变量称为局部变量,在程序的一开始定义的变量称为全局变量。

2、全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。

3、当全局变量和局部变量同名时；在局部变量的子程序内，局部变量起作用；在其他地方全局变量起作用。

name = "Alex Li"

def change_name(name):
    print("before change:",name)
    name = "金角大王,一个有Tesla的男人"
    print("after change", name)


change_name(name)

print("在外面看看name改了么?",name)

输出

before change: Alex Li
after change 金角大王,一个有Tesla的男人
在外面看看name改了么? Alex Li

作用域

作用域的定义：在代码中变量名被赋值的位置决定了变量能否被访问的范围，这个范围就是作用域。函数定义了本地作用域，模块定义了全局作用域。

LEGB原则

L:Local
E:Enclosing function locals
G:Gobal(module)
B:Built-in(python)

首先是本地然后是函数内，之后是全局，最后是pyonth内置函数。

作用域法则

1、内嵌模块是全局作用域

2、每次对函数的调用都创建一个新的作用域

3、赋值的变量名除非声明为全局变量或非本地变量，否则均为本地变量

4、所有其他的变量名都可以归纳为本地
全局或者内置的。

作用域实例

age = 18
def func1()
    age = 73
    def func2():
        print(age)
    return 666
    
val = func1()
print(val)  # 73

思考？下面代码会输出什么？

def extend_list(val, list=[]):
	# print("in func", list)
	list.append(val)
	return list


list1 = extend_list(10)
list2 = extend_list(13, [])
list3 = extend_list('a')

print("list1",list1)
print("list2",list2)
print("list3",list3)

输出>>>

list1 [10, 'a']
list2 [13]
list3 [10, 'a']

list1和list3共享一个内空间， list2传入参数'[]',会开辟新的内存空间。

递归

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就叫递归函数

1.必须有一个明确的结束条件

2.每次进入更深一层递归时，问题的规模相比上次递归都应有所减少

3.递归效率不高，递归层次过多会导致栈溢出

def calc(n, count):
    print(n, count)
    if count < 5:
        return calc(n/2, count+1)
    else:
        return n

    
res = calc(188, 1)
print("res", res)

高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数.

def add(x,y,f):
    return f(x) + f(y)


res = add(3,-6,abs)
print(res)

只需满足以下任意一个条件，即是高阶函数

1、接受一个或多个函数作为输入
2、return 返回另外一个函数

匿名函数

匿名函数就是不需要显式的指定函数名

calc = lambda x,y:x**y
print(calc(2,5)

匿名函数往往搭配其他函数使用

res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
    print(i)

内置方法

http://www.cnblogs.com/Jason-lin/p/8186513.html