• Python_初级函数


    函数

    函数: 1、定义了之后,可以在任何需要它的地方调用

                2、没有返回长度,只是单纯的打印

    具体到函数表达字符长度与 len()的区别:  

    1、len() 不能变,只能计算 s字符串的长度

    2、只是输出了结果

    return  返回值       return 是一个关键字

    返回值的3种情况

      1、没有返回值——返回 None

        1)、不写 return

        2)、只写 return :结束一个函数的继续

        3)、return  None  —— 不常用

      2、返回 1 个值

        1)、可以返回任何数据类型

        2)、只要返回就可以接收到

        3)、如果在一个程序中有多个 return,那么只执行第一个

      3、返回多个值

        1)、用多个变量接收:有多少返回值就用多少变量接收

        2)、用一个变量接收:得到的是一个元组

    def func2():
        return 1, 2, 3  #return 1,2,3
    r = func2()
    print(r)
    (r1, r2, r3)= func2()
    print(r1, r2, r3)
    
    (1, 2, 3)
    1 2 3

    集体介绍:

    s = ['a', 's', 'qw']   # 列表 s 与下面的my_len(s)没有关系,是两个单独的个体,只 
                                #是碰巧它俩命名一样而已
    def my_len(s):  #自定义函数只需要0个参数,接收参数,形式参数,形参
        i = []
        for k in s:      #这句中 s 与 my_len(s)中 s 是同一个 s
            i.append(k)
        return i  #返回值
    
    ret = my_len('小护士')   #传递参数:传参,实际参数,实参,'小护士'实际就是
                                       #my_len  (s)
    # ret = my_len([1, 2, 3, 4, 5])  #传递参数:传参, [1, 2, 3, 4, 5] 实际就是
                                                   #my_len  (s)
    
    print(ret)

    参数
      没有参数

        定义函数和调用函数时括号里都不写内容

      有一个参数

        传什么就是什么

      有多个参数

        位置参数

    def my_sum(a, b, c):
        res = a+b+c
        return res
    ret = my_sum(1, 2, 3)  # 1 对应 a ,2 对应 b ,3 对应 c ,一一对应
    print(ret)

    站在实参的角度上:
      按照位置传参

      按照关键字传参

      混合用可以,但是必须先按照位置传参,再按照关键字传参数。(不能给同一个变量传多个

                                                                                                                    值)

    站在形参的角度上

      位置参数:必须传,且有几个参数就传几个值

      默认参数:可以不传,如果不传就是用默认的参数,如果传了就用传的

    def classmate(name, sex='未知'):
        print('%s : %s' %(name,sex))
    classmate('小明')
    classmate('小张', sex='')
    
    小明 : 未知
    小张 : 女

    只有调用函数的时候
      按照位置传: 直接写参数值

      按照关键字: 关键字 = 值

    定义函数的时候:

      位置参数: 直接定义参数

      默认参数,关键字参数:参数名 = ‘默认的值’

      动态参数:可以接受任意多个参数

            参数名之前加*,习惯参数名 args ,形成元组

            参数名之前加**,习惯参数名kwargs,形成字典

      顺序: 位置参数,*args,默认参数,**kwargs

    def sum(*args):
        n = 0
        for i in args:
            n += 1
        return n
    print(sum(1, 2))
    print(sum(1, 2, 3))
    print(sum(1, 2, 3, 4))
    
    2
    3
    4
    def func(**kwargs):
        print(kwargs)
    
    func(a=1, b=2, c=3)
    func(a=1, b=2)
    func(a=1)
    
    {'b': 2, 'c': 3, 'a': 1}
    {'b': 2, 'a': 1}
    {'a': 1}

    动态参数有两种:可以接收任意参数
      *args  : 接收的是按照位置传参的值,组织成一个元组

      **kwargs  : 接收的是按照关键字传参的值,组织成一个字典

      args 必须在 kwargs之前   *args 、default(默认值)、**kwargs

    def func(*args, default = 1, **kwargs):
        print(args, kwargs)
    
    func(1, 2, 3, a='aaaa', b='bbbb',)
    
    (1, 2, 3) {'a': 'aaaa', 'b': 'bbbb'}

    动态参数的另一种传参方式
    def func(*args):  #站在形参的角度上,给变量加上*,就是组合所有传来的值。

      print(args)

    func(1,2,3,4,5)
    l = [1,2,3,4,5]
    func(*l)  #站在实参的角度上,给一个序列加上*,就是将这个序列按照顺序打散
    def func(**kwargs):
        print(kwargs)
    
    func(a=1, b=2)
    d = {'a': 1, 'b': 2} #定义一个字典d
    func(**d)

    函数的注释

    def func():
        '''
        这个函数实现了什么功能
        参数1:
        参数2:
        :return: 是字符串或者列表的长度
        '''
        pass

    文件的修改

    函数

    1、函数的定义 def

    2、函数的调用

    3、函数的返回值  return

    4、函数的参数

      形参:

        位置参数 : 必须传

        *args : 可以接收任意多个位置参数

        默认参数 : 可以不传

        **kwargs : 可以接收多个关键字参数

      实参 :

        按照位置传参,按照关键字传参

    参数陷阱:默认参数是一个可变数据类型

    def defult_param(a,l = []):
        l.append(a)
        print(l)
    
    defult_param('alex')
    defult_param('egon') 
    
    ['alex']
    ['alex', 'egon']
  • 相关阅读:
    Jisa's Notebook
    前端常见跨域解决方案
    串口
    logging的使用
    Hexo
    优美的二维树状数组
    数据结构之树的基本概念
    js 监听ios手机键盘弹起和收起的事件
    jquery.qrcode.js生成二维码(前端生成二维码)
    js产生一个随机的字符串数字组合
  • 原文地址:https://www.cnblogs.com/Chong-Yang/p/8119517.html
Copyright © 2020-2023  润新知