Python学习7——函数

转载 原文Python学习之路day3-函数：https://www.cnblogs.com/linupython/p/6609217.html

1、函数定义

def test(x):        # def定义函数关键字，test函数名，x参数
    "description"   # 函数描述
    x += 1          # 代码块
    return(x)       # 返回值，返回函数中全部逻辑的执行结果并结束函数的执行
# 函数调用方法：函数名（传入的参数）
# 举例说明
def func0(a):
    "func0"
    a+=1
    print("this is func0")     # 没有显示定义返回值，返回none

def func1(b):
    "func1"
    b+=1
    return(b)

def func2():
    "func2"
    return "Hello World!",("Java","C++"),[1,2,3],func0(2)

print(func0(0))
print(func1(1))
print(func2())

# 使用函数的好处
# 提高代码重用性，减少冗余
# 保持一致性，相同等待过程执行相同的逻辑
# 可扩展性好，函数中的代码块可根据需要灵活扩展
# 可维护性高，一旦需要改变逻辑时只需要修改函数中的代码块，一改全改

2、函数的参数及传入方法

# 形参：形式参数，在定义函数时引入的参数
# 只有在函数被调用时才会存在并为其分配内存空间
# 实参：调用函数时实际传入的参数，即执行函数定义的罗偶极时给定的输入，占用内存空间
# 调用函数时实参的值会根据一定的规则传递给形参来执行函数中定义的逻辑过程

# 位置参数传入
# 传入是实参与形参的相对位置一对一对应
def get_list(x,y):     # 定义两个形参
    "biubiu"
    return [x,y]
z=get_list(1,2)        # 调用函数并传入两个实参
print(z)
# 对应位置形参实参传给形参，对应个数严格一致，不能多或少

# 关键字参数传入
# 在调用函数传入参数时，直接使用形参的名字对其进行赋值
# 传入实参的顺序与形参定义的顺序可以不一致，传入时通过参数的名字对号入座
def get_list(x,y):
    "wow"
    return [x,y]
z=get_list(y="python",x="C++")
print(z)

# 位置参数和关键字参数混用
def get_list(x,y):
    "hah"
    return [x,y]
z=get_list("a",y=2)
print(z)

# 位置参数不能放在关键字后面
def get_list(x,y):
    "fad"
    return [x,y]
z=get_list(x=1,2)
print(z)                # 会报错positional argument follows keyword argument

# 默认参数传入
def get_list(x=1,y=2):
    "argument"
    return [x,y]
z=get_list()
print(z)
u=get_list(3,4)
print(u)

# 参数组参数传入
# *字符串，实参转换为元组,位置参数传入，关键字参数传入报错
def get_list(*var):
    "*"
    return [var]
z=get_list(1,2,3)
print(z)

# **字符串，实参转换为字典，关键字参数传入，位置参数传入报错
def display(**args):
    "**"
    return args
u=display(a=1,b=2,c=3)
print(u)

# 混合使用1
def display(x,*args):
    return args
u=display(0,1,2,3)
print(u)

# 混合使用2
def display(x,**args):
    return args
u=display(3,a=1,b=2,c=3)
print(u)

# 混合参数传入举例
def display(x,y,**args):
    print(x)
    print(y)
    return args
print(display(3,a=0,b=1,y=2))

3、函数的作用域

# 作用域是指对某一变量和方法具有访问权限的代码空间
# 全局变量：在函数外部定义，全局范围有效，作用域是程序全局
# 局部变量：在函数内部定义，函数内部有效，作用域是函数内部
# 除非在函数内部定义局部变量时加上global关键字

# 函数内部调用全局变量并对其重新定义
# 函数内部定义局部变量时，可通过global关键字将变量的作用域提升扩大到全局范围
# 字符串、整数数据类型在函数内部修改（重新赋值）不覆盖全局变量的值
# 除此之外复杂的数据类型局部（如列表、字典、集合）变量的修改会覆盖全局变量的值
#!/usr/bin/env python
# -*- coding:utf-8 -*-
flag=0                     # ?一脸懵逼,突然想起我之前也写过flag，原来就是flag
name="Tom"
list1=["a","b","c"]
dict1={1:"a",2:"b",3:"c"}
set1={'a','b','c'}
tuple1=('a','b','c')
print('before executing function')
print(flag)
print(name)
print(list1)
print(dict1)
print(set1)
print(tuple1)
print('============break line=============')

def display():
    flag=1
    name='Jack'
    list1=['d','e','f']
    dict1={4:"d",5:"e",6:"f"}
    set1={'d','e','f'}
    tuple1=('d','e','f')
    print(flag)
    print(name)
    print(list1)
    print(dict1)
    print(set1)
    print(set1)
    print(tuple1)
print('executing function:')
print(display())
print('=====break line=======')
print('after executing function:')
print(flag)
print(name)
print(list1)
print(dict1)
print(set1)
print(tuple1)
# 结论：函数内部定义全局变量对全局变量没有影响

flag=0
name='Tom'
def display():
    flag +=1
    name=name[:1]
    print(flag)
    print(name)
print(display())
print('======break line======')
print(flag)
print(name)
# 对字符串或int型全局变量在函数内部直接修改值会报错
# 除字符串和int型以外的可以修改的复杂数据类型（如列表、字典、元组）的全局变量
# 可直接在函数内部修改，并且是修改后全局生效

# !! 内部重定义函数变量对全局变量没有影响（名字相同而已）
# !! 内部直接修改数字或字符全局变量报错，其他可以修改，作用于全局变量

4、递归函数

# python最大递归深度为999
# 递归函数特性
# 必须有明确的结束条件
# 每递归循环一次，递归问题规模较小
# 如果递归效率不高，递归层数过多会导致栈溢出（函数调用通过栈stack实现）
def enlarge(n):
    if n<10:
        print(n)
        return enlarge(n+1)
enlarge(1)
# 类似于for循环
for i in range(20):  # i默认为0
    if i<10:
        print(i)
        i+=1

5、函数式编程

传统过程编程
var a=1+2;
var b=a*3;
var c=b-4;
函数式编程
var result = subtract(multiply(add(1,2), 3), 4);
改进
add(1,2).multiply(3).subtract(4)
merge([1,2],[3,4]).sort().search("2")

6、高阶函数

# 一个函数定义为另一函数的参数，将函数作为参数的函数成为高阶函数
def func1(a,b,f):
    return f(a)+f(b)
print(func2('c','d',str))