python函数基本介绍

2018-06-18 03:08:01来源:未知 阅读 ()

新老客户大回馈,云服务器低至5折

函数

1.函数结构
   def 是函数的定义关键字,my_len是函数名。()传参用,冒号下面都是函数体。
   执行函数方法:函数名加括号来执行函数。My_len()

    举例:
    # s = 'lkfjsjulkjdgjdsf'
    # def my_len():
    # count = 0
    # for i in s:
    # count += 1
    #
    # print(my_len())

2.函数的封装
  

  一个函数就是为了实现一个功能

3.Return 在函数中的作用,是给函数的执行者返回值

  return作用:

    1.终止函数
    2.给函数的执行者返回值

  retun后接值说明:

    Return后面不加任何东西,反悔结果是none
    Return,对于单个值来说,后面加什么反回的就是什么,是字符串就反回字符串,是数字就反回数字。
    Return 对于多个反回值时,会将多个值放到一个元组中,反回给函数的执行者。

      举例:
        #def func1():
        # print(111)
        # print(222)
        # return
        # print(333)
        # print(func1()) ###终止函数反回默认值none
      结果:
        111
        222
        None

      举例:
        #def func1():
        # print(111)
        # print(222)
        # return 666 ####反回666
        # return 'alex' ####反回'alex'
        # return 'alex', 666, [1, 2, 3] ###反回一个元组('alex', 666, [1, 2, 3])



4.函数的传参
  函数传参分为两个方向:
    1. 实参角度
      ——实参就是在执行函数过程中向函数内传入的参数。(函数执行里面放的参数)
    2. 行参角度
      ——行参就是准备被赋值的名字,即在运行函数时准备接收行参的字符。(在函数定义的时里面放的参数)

  注意:行参是不可以被改变得,而实参是可以改变的。

    举例:
      # def my_len(argv): # argv是形式参数 ,形参
      #
      # count = 0
      # for i in argv:
      # count += 1
      # return count
      # s = 'lkfjsjulkjdgjdsf'
      # l1 = [1, 2, 3, 4, 5]
      # print(my_len(l1)) #l1是实际参数, 实参
    结果:
      5

  实参的类型:
    1.位置参数
    2.关键字参数
    3.混合参数

    (1)位置参数
        行参的参数要与实参位置按顺序一一对应,也就是说在改行参传参数的值,要与预先定义的行参位置一一对应,行参会第一个字符会对应接收实参的第一个字符,                              依次类推。

    (2)关键词参数
        关键字参数不关心传入参数放的顺序位置,传入参数要与行参关键字一致即可。

    (3)混合参数
        位置参数和关键字参数同时存在
        注:关键字参数,必须要在位置参数的后面

          举例:
            # 位置参数 按照顺序一一对应
            # def func1(a, b, c):
            # print(a, b, c)
            # func1(1, 2, 'alex') ###1,2,'alex'分别对应a,b,c

            # def max(a, b): return a if a > b else b
            # ret = 1 if 2 > 1 else 6
            # print(ret)
            # print(max(10, 2)) ###10,2,分别对应a,b

            # 关键字传参 一一对应。
            # def func2(a, b):
            # print(a, b)
            # func2(b=2, a=3) ###关键字a=3 对应行参里面的a,b=2对应行参里面的b

            混合参数。(位置参数,关键字参数) 关键字参数必须在位置参数后面。
            # def func3(a, b, c, d):
            # print(a, b, c, d)
            # func3(1,2,d=3,c=5) ###关键字必须在位置参数后
    行参的类型:
      1.位置参数
      2.默认参数
      3.动态参数 (*args 、 **kwargs )

      (1)位置参数
          位置参数就是保证要与实参的位置参数保持一致

      (2)默认参数
          默认参数用的比较多,默认就是在不传入参数的时候使用的参数即为默认参数,即在实参不输入参数时,程序运行会使用预先定义好的默认参数,但手动输入                                      后悔替换默认参数输入。
          注意,默认参数要在位置参数的后面添加

      (3)动态参数(万能参数)
          对参数的个数不固定的时候使用动态参数(万能参数),即在执行函数时,实参传入多少参数接收多少参数。

          (*args 、 **kwargs )动态参数有两种:
          动态参数分为两种(万能参数)
            *args 接收所有的位置参数,所有的位置参数都放在一个元祖中。
            **kwargs 接收所有关键字参数,所有接收到的关键字都放在一个字典中。

              举例:

                #默认参数:
                # def login(name,sex='男'): ###默认参数要在位置参数后面
                # # with open('register', encoding='utf-8', mode='a') as f1:
                # # f1.write('{},{}\n'.format(name,sex))
                # #
                # #
                # # while True:
                # # name = input('请输入姓名:').strip()
                # # if '1' in name:
                # # login(name)
                # # else:
                # # sex = input('请输入性别:').strip()
                # # login(name,sex)

                #万能参数:
                # def func3(*args, **kwargs): #函数的定义的时候 * 代表聚合。
                # print(args)
                # print(kwargs)
                # # func3(1, 2, 3, 'alex', c=6, name='wusir', age='21') ###结果:(1, 2, 3, 'alex') {'c': 6, 'name': 'wusir', 'age': '21'}


    形参的排列顺序:
      位置参数--> *args-->默认参数-->**kwargs

        举例:
          # def func5(a,b,*args,sex='男',**kwargs):
          # print(a,b,)
          # print(args)
          # print(sex)
          # print(kwargs)

5.函数中星号的定义:
  (1)在函数定义的时候,*代表聚合
  (2)函数的执行时候,*代表打散 注意:字典打散时用**两个星号

    举例:
      # def func3(*args, **kwargs): #函数的定义的时候 * 代表聚合。
      # print(args)
      # print(kwargs)
      # func3(*[1, 2, 3],*(22, 33)) #函数的执行的时候 * 代表打散。 ###结果:(1, 2, 3, 22, 33) {}
      # func3(**{'name':"alex"},**{'age':23}) #函数的执行的时候 * 代表打散。 ###结果:() {'name': 'alex', 'age': 23}
      # func3(1, 2, 3, 22, 33) #函数的执行的时候 * 代表打散。 ###结果:(1, 2, 3, 22, 33) {}

 

6.函数的嵌套:(记住两个关键点)
  代码顺序执行,当见到函数名加括号,就是执行函数。
  函数在没有执行完是不会执行下面的内容的。

  注:
  执行一个函数就会开辟一个临时空间进行存储,即每个函数都会单独开辟一个临时空间使用存放函数体内容。

 


    举例:
      # def func1():
      # print(666)
      #
      # def func2():
      # func1()
      # print(333)
      #
      # def func3():
      # func2()
      # print(222)
      # print(111)
      # func3()
      # print(555)

 

      # def func1():
      # name = 'susi'
      # print(name)
      # def func2():
      # name1 = 'git'
      # print(333)
      # print(444)
      # func2()
      # func1()

 

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:正则表达式

下一篇:匿名函数