函数

函　　　　　　数

一、定义函数
格式：
def 函数名(参数列表)：
　　语句
　　return 表达式

def :函数代码块以def关键字开始
函数名：遵循标识符规则
():参数列表的开始与结束
参数列表(参数1，参数2，……，参数n):任何传入函数的参数和变量
必须放在圆括号中间，用逗号分隔。函数从函数调用者哪里获取的信息
冒号：函数内容（封装的功能）以冒号开始，并且缩进
语句：函数封装的功能
return:一般用于结束函数，并返回信息给函数的调用者
表达式：即为返回给函数调用者的信息。

注意：最后的return表达式，可以不写，相当于return None

#最简单的函数，无参数，无返回值的函数
def MyPrint():
    print("sunck is a goog man")
    print("sunck is a handsome man")
    print("sunck is a nice man ")

二、函数的调用
格式：函数名(参数列表)

函数名：是要使用的功能的函数函数名
参数列表：函数的调用者给函数传递的信息,如果没有参数，下括号也不能省略

函数调用的本质：实参给形参赋值

MyPrint()
MyPrint()

三、函数的参数

# 函数的参数
#需求：编写一个函数，给函数一个字符串和一个年龄，在函数内部打印出来

# 形参(形式参数)：定义函数时小括号中的变量，本质是变量
# 参数必须按顺序传递，个数目前要对应
def Myprint(str, age):
    print(str, age)

#实参(实际参数)：调用函数时给函数传递的数据，本质是值
Myprint("xunck is a good man",16)

def my (a, b):
    c = max(a,b)
    print(c)
my(1,3)

# 函数的返回值
# 编写函数，实现功能，返回这两个数的和
def mySum(num1, num2):  
    sum = num1 + num2
    #执行完return语句后，该函数就结束
    return sum   #将结果返回给函数的调用者
    print("*****") #不会执行
res = mySum(1, 2)
print(res)

# 传递参数

值传递:传递的是不可变类型　　str\tuple(元组)\number

def func1(num1):
    num = 10
temp = 20
func1(temp)
print(temp)

引用传递：传递的是可变类型　　list\dict\set是可变的

def func2(lis):
    lis[0] = 100
li = [1, 3, 2, 3 ]
func2(li)
print(li)

#关键字参数
概念：允许函数调用时给函数的顺序与定义是不一致

def myprint(str, age):
    print(str, age)
myprint(18,  "sunck is a goog man")


#默认参数
概念：调用函数时，如果没有传递参数，则使用默认参数

# 以后要用默认参数，最好将默认参数放到最后
def myprint(str, age = 18):
    print(str, age)
myprint("sunck is a goog man")


#不定长参数
概念：能处理比定义时更多的参数

#加了*号的变量存储所有未命名的变量，如果在函数调用时没有
#指定参数，能处理比定义时更多的参数
def func(name, *arr):
    print(name)
    for x in arr:
        print(x)
    return x
func("sunck","good","nices","handsom")

def func2(name, *args):
    print(name)
    print(type(args))
    for x in range():
        pritn(x)

四、匿名参数

概念：不适用def这样的语句定义函数，使用lambda来创建匿名函数
特点：
lambda 只是一个表达式，函数体比def简单
lambda 主体是一个表达式，而不是代码块，仅仅只能在lambda表达式
中封装简单的逻辑
lambda 函数有自己的命令空间,并且不能访问自由参数列表之外的或
全局命名空间的参数
虽然lambda是一个表达式且看起来只能写一行，与c和c++内联函数不同

 

格式：lambda 参数1， 参数2，……，参数n:expression

sum = lambda num1, num2:num1 + num2
print(sum(1,2))

>>>3

 名片

#名片


def display_menu():
    print("-"*30)
    print("      名片管理系统    V8.0")
    print("1.添加名片")
    print("2.删除名片")
    print("3.修改名片")
    print("4.查询名片")
    print("5.获取所有名片信息")
    print("6.退出系统")
    print("-"*30)

name_list = []
i= 0
while i < 1:
    # 打印菜单
    display_menu()
    key = get_choice()
    
    if key == 1:
        add_info()
    elif key == 2:
        pass
    elif key == 3:
        pass
    elif key == 4:
        pass
    elif key == 5:
        print_all_info(name_list)
    elif key == 6:
        pass
    else:
        print("输入有误，请重新输入。。。")
    

# 获取用户输入的信息
def get_choice():
    selected_key = input("输入要选择的序号：")
    return int(selected_key)

def add_info():
    new_name = input("输入姓名：")
    name_list.append(new_name)

def print_all_info(temp_list):
    print("="*30)
    for info in temp_list:
        print(info)
    print("="*30)

 递归

def func(number):
    if number == 1:
        result = 1
    else:
        result = func(number - 1)*number
    return result

number = int(input("输入一个正整数:"))
a = func(number)
print("%d!="%number, a)

 7.1　　闭包

闭包：有嵌套函数；内部函数对外部函数的变量进行引用；外部函数返回内部函数的函数名

def outer(start = 0):
    count = [start]

    def inner():
        count[0] += 1
        return count[0]

    return inner

quote = outer(5)
print(quote())

7.2　　装饰器

不改变原函数调用方式，给原函数增添功能

def wrap(func):
    print("正在装饰")
    def inner():
        print("正在验证权限")
        func()
    return inner

@wrap
def test():
    print("test")

test()

7.2.2　　多个装饰器（调用时顺序自上而下）

def wrap_one(func):
    def inner():
        print("==正在验证权限==")
        func()
    return inner

def wrap_two(func):
    def inner():
        print("==验证完成==")
        func()
    return inner     

@wrap_one
@wrap_two
def test():
    print("=====test====")

test()

7.2.3　　装饰器对有参数函数进行修饰

（2个参数）

def wrap(func):
    print("正在装饰")
    def inner(a, b):
        print("验证身份ing")
        func(a, b)
    return inner


@wrap
def test(a, b):
    # test = wrap(test(a, b))
    print("a = %d, b = %d"%(a, b))

test(1, 9)

（参数个数不定）

def wrap(func):
    print("正在装饰")
    def inner(*args, **kwargs):
        print("验证身份ing")
        func(*args, **kwargs)
    return inner


@wrap
def test(*args, **kwargs):
    # test = wrap(test(a, b))
    print("===test===")

test(1, 9, 10, 11)

7.2.4　　装饰器修饰带有返回值的函数

def wrap(func):
    print("装饰ing")
    def inner():
        print("验证身份ing")
        return func()
    return inner

@wrap
def test():
    return "itheima"

result = test()
result

7.2.5　　带参数的装饰器

（增加一层封装即可）

def wrap(args):
    def func(func_name):
        def inner():
            print("===验证身份======%s"%(args))
            func_name()
        return inner
    return func

@wrap('hanhan')
def test():
    print("=====test======")

test()

7.3　　内置函数

# map（）

func = lambda x : x+2
result = map(func, [1, 2, 3, 4])
# map()对指定序列做映射
print(list(result))

result = map(lambda x, y: x+y, [1, 2, 3], [2, 3, 4])
# 两个参数,需要传递两个列表
print(list(result))

# filter()
# 对指定序列做过滤,返回函数返回值为TRUE的值

func = lambda x: x % 2
result = filter(func, [1, 2, 3, 4, 5])
print(list(result))

# reduce()
# 对参数迭代器中的元素进行累积

from functools import reduce
func = lambda x, y: x + y
result = reduce(func, [1, 2, 3, 4, 5])
# 把每个元素取出，和上次调用后的结果作为参数再次调用函数func(),将最后结果返回给result
print(result)

result = reduce(lambda x, y: x + y, ['a', 'b'], 'c') # 'c'为默认参数
print(result) # 结果是cab