• Python基础-函数初识


    一 函数的作用

    1. 解决代码复用的问题

    2. 提高代码的可维护性

    3. 程序的组织结构更清晰,提高程序的可读性

    1.1 函数的定义与调用

    # 定义函数:
    def my_len():
        '''计算s1的长度'''
        s1 = 'fdsgdfkjlgdfgrewioj'
        count = 0
        for i in s1:
            count += 1
        # print(count)
    
    my_len()  # 函数名+()  执行函数 #函数的调用
    定义:
        def  关键词开头,空格之后接函数名称和圆括号(),最后还有一个':'。
        def  是固定的,不能变  它是定义函数的关键字
        空格: 为了将def与函数名分开,必须空!
        函数名: 函数名的定义与变量一致,只能包含字符串、下划线和数字,且不能以数字开头。要求函数名尽量简短,并且能表达函数功能
        括号: 必须添加
        
        注释:每一个函数都应该对功能和参数进行相应的说明,应该写在定义函数的下一行,一增强代码的可读性。
        调用: 就是 函数名()   要记得加上括号
    

    1.2 函数的返回值 return

    '''
        1,遇到return,结束函数。
        def func1():
            print(111)
            return
            print(222)
        func1()  #只打印111 
        2,给函数的调用者(执行者)返回值。
            无 return 返回None
            return 不写 或者 None 返回None
            return 返回单个数.
            return 返回多个数,将多个数放在元组中返回。
    '''
    s1 = 'fdsgdfkjlgdfgrewioj'
    
    ##函数返回值是str类型
    def my_len():
        count = 0
        for i in s1:
            count += 1
        return 666  ##将666返回给函数执行结果
    print(my_len(),type(my_len())   
    
    ## 返回多个值的时候,会将多个值放在元组中
    def my_len():
        count = 0
        for i in s1:
            count += 1
        return 666,222,count,'老男孩'
    print(my_len(),type(my_len()))
    #在元组中分别赋值:
    def my_len():
        count = 0
        for i in s1:
            count += 1
        return 666,222,count
    ret1,ret2,ret3 = my_len()  # (666, 222, 19,)
    print(ret1)
    print(ret2)
    print(ret3)

    1.3 函数的传参

    1.3.1 参数的定义

    li = [1, 2, 3, 43, 'fdsa', 'alex']
    s1 = 'fdsgdfkjlgdfgrewioj'
    def my_len(a):    # 函数的定义 ()里放的是形式参数,形参
        count = 0
        for i in a:
            count += 1
        return count
    ret = my_len(li)  # 函数的执行() 实际参数,实参
    print(ret)
    print(len(s1))
    
    # 从实参角度
        #1,位置参数。 必须一一对应,按顺序
    def func1(x,y):
        print(x,y)
    func1(1, 2)
        #2,关键字参数。必须一一对应,不分顺序。
    def func1(x,y,z):
        print(x,y,z)
    func1(y=2,x=1,z=5,)
    
    # 参数练习
    def max(a,b):
        if a > b:
            return a
        else:
            return b
    print(max(100,102))
    
    #简写形式
    def max(a,b):return a if a > b else b
    print(max(100,102))
    
    参数的定义
    参数的定义

    1. 形参:在函数名后面的()中的参数,为形式参数,称为形参

    2. 实参:在调用函数时写入()的参数,为实际参数,称为实参。

    3. 从实参角度,又分为:

      1) 位置参数:按实际位置、顺序一一对应的参数

      2)关键字参数:a=b,必须一一对应,但不分顺序

      3)混合参数: 一一对应,切关键字参数必须在位置参数后面

    # 混合参数。 关键字参数必须在位置参数后面
    def func2(argv1,argv2,argv3):
        print(argv1)
        print(argv2)
        print(argv3)
    func2(1,2,argv3=4)

    4.从形参角度:

      1)位置参数,必须一一对应,按顺序

      2)默认参数,必须在位置参数后面

    def register(name,sex=''):
        with open('register',encoding='utf-8',mode='a') as f1:
            f1.write('{} {}
    '.format(name,sex))
    
    while True:
        username = input('请输入姓名:/q 或者 Q 退出')
        if username.upper() == 'Q':break
        if 'a' in username:
            sex = input('请输入性别:')
            register(username,sex)
        else:
            register(username)

      3)动态参数 *args *kwargs   万能参数

    # args 与 kwargs接收的内容
    def func2(*args,**kwargs):
        print(args)  # 元组(所有位置参数)
        print(kwargs)  # 字典,所有关键字参数
    func2(1,2,3,4,5,6,7,11,'alex','老男孩',a='ww',b='qq',c='222')
    
    混合参数中,arte与kwargs的位置
    # 位置参数,*args, 默认参数
    def func3(a,b,*args,sex=''):
        print(a)
        print(b)
        print(sex)
        print(args)
    func3(1,2,'老男孩','alex','wusir',sex='')
    # 位置参数,*args, 默认参数, **kwargs
    def func3(a,b,*args,sex='',**kwargs):
        print(a)
        print(b)
        print(sex)
        print(args)
        print(kwargs)
    func3(1,2,'老男孩','alex','wusir',name='alex',age=46)

    args与kwargs的使用

    def func1(*args,**kwargs):  # 函数的定义 * 聚合。
        print(args)
        print(kwargs)
    l1 = [1,2,3,4]
    l11 = (1,2,3,4)
    l2 = ['alex','wusir',4]
    # func1(l1,l2,l11)  。
    # func1(*l1,*l2,*l11)  # 函数的执行:* 打散功能。
    # func1(1,2,3,4,'alex','wusir',4,1,2,3,4)
    dic1 = {'name1':'alex'}
    dic2 = {'name2':'laonanhai'}
    func1(**dic1,**dic2)  # * 打散功能

    1.4 命名关键字参数

    # 命名关键字参数:在*后面定义的形参称为命名关键字参数,必须是被以关键字实参的形式传参。

    # 命名关键字参数:在*后面定义的形参称为命名关键字参数,必须是被以关键字实参的形式传参。
    def foo(name,age,*,sex='male',group):
        print(name)
        print(age)
        print(sex)
        print(group)
    
    foo('wph',18,group='ops')  ##因为在形参的*后面,sex和group必须以关键字的方式传参
  • 相关阅读:
    Frameset 框架
    FHS 文件层次标准
    history 命令
    QT基础走起
    Android中导入jar包v4的错误
    Android工具Eclipse点击卡死或者无响应情况
    让程序飞起来
    Android中报错
    【2019.9.23】NOIP2017 practice exam
    【技巧】时间复杂度
  • 原文地址:https://www.cnblogs.com/wangph/p/8858140.html
Copyright © 2020-2023  润新知