zoukankan      html  css  js  c++  java
  • 函数

    函      数

    一、定义函数
    格式:
    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	uple(元组)
    umber
    
    def func1(num1):
        num = 10
    temp = 20
    func1(temp)
    print(temp)
    
    引用传递:传递的是可变类型  listdictset是可变的
    
    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

     

     

     

  • 相关阅读:
    python主成分分析
    matplotlib绘图pie
    cpu监控:mpstat命令
    cpu监控:dstat
    MongoDB--安装部署
    Linux-网络管理
    Apache 虚拟主机配置
    Apache 访问控制
    Apache 域名跳转配置
    Apache 日志管理
  • 原文地址:https://www.cnblogs.com/xieyi-newlife/p/8924217.html
Copyright © 2011-2022 走看看