• python 初识函数


    1.函数的定义:封装一个功能,便于调取的一组程序模块。

      def 函数名():

        函数体

      1.函数有由来:

    s = 'jidjsoijofjdo'
    c = 0
    for i in s:
        c += 1
    print(c)
    
    l1= [1,2,3,4,'fdsaf','gfda','fc','sz']
    c = 0
    for j in l1:
        c += 1
    print(c)
    
    已上方法就是len()的功能,在编程中,可能重复使用,在每次使用的时候就编写一次没效率也占用内存。
    于是利用函数的模式,将程序封装起来,随用随取。
    


      函数就是封装一个功能.以功能为导向
      def my_len():
          def               关键字 定义一个函数
          my_name            函数名,函数名的书写规则与变量一样
          def               与函数名之间一个空格
          函数名():        加上冒号,将函数名和函数体隔开,便于阅读
          内容是函数体
          函数执行:在不调用的情况下,封装以后在内存中开辟一个空间储存函数,叫做局部命名空间
    2.函数的返回值:return

      return在函数中一般都出现在末尾用做返回值操作,注意事项如下:
         1.在函数中遇到return 就结束函数,后面不执行
         2.将值返回给函数的调用者:

      在使用return的过程中,可能出现一下几点问题,
              1.函数里面没有return,返回None
              2.return None,一般不多
              3.return一个值 则会返回该值。
              4.return多个值 则会将多个值放到一个元祖中,返回给调用者

    def func(a):
        return a
    
    print(func('wwww'))#wwww
    需要注意的是在函数中最好不要使用print,输出函数时如果利用print而且函数中还有一个print则会出现None。
    



    3.参数#重点

    def my_lenn(l):  #这里的 l 是形式参数,形参
        count = 0
        for i in l:
            count += 1
        return count
    
    print(my_lenn('ab'))  #函数中的参数为实际参数,实参
    

    函数分实参和形参
        从实参角度出发定义:
            1.位置传参.按顺序,需要与实参一一对应
            2,按关键字传参数,不按顺序,也与实参是一一对应.
            3.混合传参,关键字参数永远在最后面

    def fuck(a,b):  
        return a if a > b else b
    print(fuck(22,33))  #位置参数,与上方形参一一对应
    
    ################################
    def fuck(a,b):,
        return a if a > b else b
    print(fuck(b=22,a=33))#关键参数
    
    ###################################
    def func1(a,b,c,d,e):
         print(a)
         print(b)
         print(c)
         print(d)
         print(e)
    func1(1,2,d=4,c=3,e=5)
    func1(1,4,e=2,d=9,c=5)
    #混合参数:需要注意的是在使用混合参数的时候位置参数在关键参数的前面。
    

     
        形参角度:
            1.位置参数,安顺序一一对应,
            2.默认参数,传参则覆盖,不传则默认,默认参数永远在位置参数的后面。
            3.动态参数,1.当有大量的参数需要填入的时候需要用到动态参数使用*args

            2.当有多余关键字参数时候使用**kwarge

       在动态参数中的顺序是 1位置参数2*args3关键字参数4**kwargs

    函数形参:
        动态参数:当需要多个参数,利用*args的方法
     def funx(*args):
         print(*args)#增加*号则会直接输出所有实参,没有则会将实参聚合为一个元祖并且输出
     funx(1,2,3,4,5,6,7,8,9)
    
    def func(a,c,f,*args,d = 66,**wkargs):
         return a,c,f,d,
    print(func(2,3,5,2,1,4,3,12,3,5,3,12,3,4325,d = 4444))
    
    def func(a,c,f,*args,d = 66,**kwargs):
        print(args)  #*args将所有的没有定义的元素组合起来输出
        print(a)     #顺序是优先位置参数,然后*args再然后就是默认参数
        print(c)
        print(f)
        print(d)
        print(kwargs)
    print(func(2,3,5,2,1,4,3,12,3,5,3,h=12,m=3,n=4325,d=4444))
    
           动态传参:
    2.**kwargs:将关键字参数统合为字典类型输出,
    def func(**kwargs):
        print(kwargs)
    func(e = 3,r = 2)
    
    def func(*args):
        print(args)
    func(1,2,3,10,20,80)
    
    * 的作用!
    def func(*args):
        return args
    l1 = [3,4,5,6,7,3,1,]
    l2 = [2,3,4,2,1,4]
    print(func(*l1,*l2))
    print(func(*(l1+l2)))   #去列表
    
    **的作用
    def func(**kwargs):
        print(kwargs)
    func(a=1,c=2,v=3,y=7)  #将关键字转化为字典格式
    
    def func(**kwargs):
        return kwargs
    
    dic1 = {'name1':'alex','age1':46}##要注意的是调用的时候一定要加上函数名
    dic2 = {'name':'老男孩','age':56}
    
    print(func(**dic1,**dic2))
    
    def func(**kwargs):
        print(kwargs)
    
    dic1 = {'name1':'alex','age1':46}
    dic2 = {'name':'老男孩','age':56}
    func(**dic1,**dic2)
    
     利用*时候,要注意后面是可迭代对象,并且将其打散,组成元祖模式输出
     利用**时候,要注意的是对应的为关键字参数,会将其聚合起来,组成字典类型输出
    


      

  • 相关阅读:
    P3254 圆桌问题
    P4868 Preprefix sum
    2021sd省选游记
    P4145 上帝造题的七分钟2 / 花神游历各国
    P2801 教主的魔法
    P4147 玉蟾宫(悬线法)
    P1944 最长括号匹配
    CF1214D Treasure Island
    Loadrunner与kylinPET的能力对比测试--web动态请求
    Summer——从头开始写一个简易的Spring框架
  • 原文地址:https://www.cnblogs.com/wpcbk/p/8672749.html
Copyright © 2020-2023  润新知