• 016-python函数和常用模块-函数定义和使用


    函数式编程最重要的是增强代码的重用性和可读性

    一、定义

    1 def 函数名(参数):
    2        
    3     ...
    4     函数体
    5     ...
    6     返回值

    函数的定义主要有如下要点:

    • def:表示函数的关键字
    • 函数名:函数的名称,日后根据函数名调用函数
    • 函数体:函数中进行一系列的逻辑计算,如:发送邮件、计算出 [11,22,38,888,2]中的最大数等...
    • 参数:为函数体提供数据
    • 返回值:当函数执行完毕后,可以给调用者返回数据。
     1 def sendmail():
     2     try:
     3         #邮件方式命令语句    
     4     except:
     5         return "失败"
     6     else:
     7         return  "cc"
     8 
     9 ret = sendmail()
    10 if ret == "cc":
    11     print("发送成功")
    12 else:
    13     print("发送失败")

    二、返回值

    函数是一个功能块,该功能到底执行成功与否,需要通过返回值来告知调用者。

    默认返回值:

    1 def f2():
    2     print(123)
    3 r = f2()
    4 print(r)
    5 
    6 # 输出
    7 123
    8 None       #不指定return,默认返回none
    def f1():
        print(123)
        # 在函数中,一旦执行return,函数执行过程立即终止
        return "111"
        print(456)         # 该语句将不执行
    r = f1()
    print(r)
    # 输出
    123
    111

    三、参数

    函数的有三中不同的参数:

    • 普通参数
    • 默认参数
    • 动态参数
    # 1、普通参数(严格按照顺序,将实际参数赋值给形式参数)
    # 2、默认参数(必须放置在参数列表的最后)
    # 3、指定参数(将实际参数赋值给制定的形式参数)
    # 4、动态参数:
    # * 默认将传入的参数,全部放置在元组中, f1(*[11,22,33,44])
    # ** 默认将传入的参数,全部放置在字典中 f1(**{"kl":"v1", "k2":"v2"})
    # 5、万能参数, *args,**kwargs

    普通参数:

    1 # ######### 定义函数 ######### 
    2 
    3 # name 叫做函数func的形式参数,简称:形参
    4 def func(name):
    5     print name
    6 
    7 # ######### 执行函数 ######### 
    8 #  'wupeiqi' 叫做函数func的实际参数,简称:实参
    9 func('wupeiqi')

    默认参数:

    def func(name, age = 18):      # 18就是age这个形参的默认值
        
        print "%s:%s" %(name,age)
    
    # 指定参数
    func('wupeiqi', 19)
    # 使用默认参数
    func('alex')
    
    注:默认参数需要放在参数列表最后

     动态参数1(*):

     1 def f1(*args):
     2     print(args,type(args))
     3 
     4 # 执行方式一
     5 f1(11,22,33,44)
     6 # 输出
     7 (11, 22, 33, 44) <class 'tuple'>      #每个参数作为args元组中的参数分别放入。
     8 
     9 # 执行方式二
    10 ll = [11,22,33,44]
    11 f1(ll)
    12 # 输出
    13 ([11, 22, 33, 44],) <class 'tuple'>  #列表ll作为args元组的1个参数被放入。
    14 
    15 # 执行方式三
    16 ll = [11,22,33,44]
    17 f1(*ll)
    18 # 输出
    19 (11, 22, 33, 44) <class 'tuple'>  #列表ll中的每一个元素被分别放入args元组中。相当于执行了一次for循环

      动态参数2(**):

    1 def func(**kwargs):
    2     print(kwargs)
    3 
    4 # 执行方式一
    5 func(name="hello",age=18)
    6 
    7 # 执行方式二
    8 li = {'name':'wupeiqi', "age":18, 'gender':'male'}
    9 func(**li)

       动态参数3(万能):

     1 def f2(*args,**kwargs):     # **kwargs需要放在后面
     2     print(args)
     3     print(kwargs)
     4 
     5 dic = {"key1":"alex","key2":"alex2"}
     6 f2(1,2,3,4,**dic)
     7 
     8 # 输出
     9 (1, 2, 3, 4)
    10 {'key2': 'alex2', 'key1': 'alex'}

     内置函数str.format()  (动态参数的应用)

      str类中format()方法的说明

    1     def format(self, *args, **kwargs): # known special case of str.format
    2         """
    3         S.format(*args, **kwargs) -> str
    4         
    5         Return a formatted version of S, using substitutions from args and kwargs.
    6         The substitutions are identified by braces ('{' and '}').
    7         """
    8         pass

       str类中format()方法的例子

     1 # str.format()
     2 # str format格式化输出
     3 
     4 # 通过*args传递参数
     5 s1 = "i am {0}, age {1}".format("alex", 18)
     6 print(s1)
     7 s2 = "i am {0}, age {1}".format(*["alex", 18])
     8 print(s2)
     9 
    10 # 通过**kwargs传递参数
    11 s1 = "i am {name}, age {age}".format(name='alex', age=18)
    12 print(s1)
    13 dic = {'name': 'alex', "age": 18}
    14 s2 = "i am {name}, age {age}".format(**dic)
    15 print(s2)

     四、内容补充:

      a. 相同函数名的创建

     1 def f1(a1, a2):         #上下两个函数相同,执行下面这个
     2     return a1 + a2
     3 
     4 def f1(a1, a2):
     5     return a1 * a2
     6 
     7 ret = f1(8, 8)
     8 print(ret)
     9 
    10 # 输出
    11 64
    12 
    13 # name = "alex"     #原理与变量的赋值类似,print(name)的时候打印“eric”
    14 # name = "eric"
    15 # print(name)

      b、函数传递参数的时候,传递的是“引用”

     1 def f1(a1):
     2    a1.append("chh")
     3 
     4 li = [11,22,33,44]
     5 f1(li)            # 如果传参数的时候,是拷贝一份的话,print(li)应该仍旧是 [11,22,33,44]
     6 
     7 print(li)
     8 
     9 # 输出    
    10 [11, 22, 33, 44, 'chh']     

      b、全局变量在函数中的使用

      全局变量,所有作用域都可读;

      对全局变量进行重新赋值,需要global;

      特殊:字典、列表,可修改,不可重新赋值;(在不定义global的情况下)

      全局变量,约定俗成使用大写。

      b1函数体内设置的变量,特性如下:

    # 函数体内设置的变量,作用域为函数体自身内有效。
    def f1():
        name = "alex"
        print(name)
    
    def f2():
        print(name)
    
    f1()
    f2()
    
    # 输出
     File "路径/s2.py", line 157, in f2
        print(name)
    NameError: name 'name' is not defined   # 提示f2函数体的name没有定义

      b2全局变量,所有作用域都可读,特性如下:

    name = "alex"    # name为全局变量
    def f1():
        age = 18
        print(age, name)
    def f2():
        age = 19
        print(age, name)
    f1()
    f2()
    # 输出
    18 alex
    19 alex

      b3全局变量和函数中的私有变量,如下:

    name = "alex"
    def f1():
        age = 18
        name = "chh"           # 私有变量和全局变量相同时,优先选择私有变量
        print(age, name)
    def f2():
        age = 19
        print(age, name)
    f1()
    f2()
    
    #输出
    18 chh
    19 alex

      b4全局变量在函数中的运用,global声明,如下:

    name = "alex"
    def f1():
        age = 18
        global name           # 表示函数中使用的name是全局变量,重新赋值
        name = "chh"
        print(age, name)
    def f2():
        age = 19
        print(age, name)
    f1()
    f2()
    
    #输出
    18 chh
    19 chh

      b5 特殊:字典、列表,可修改,不可重新赋值;(在不定义global的情况下),如下:

    name = [11,22,33,44]
    def f1():
        age = 18
        # global name
        name.append(55)
        print(age, name)
    def f2():
        age = 19
        print(age, name)
    f1()
    f2()
    
    # 输出
    18 [11, 22, 33, 44, 55]
    19 [11, 22, 33, 44, 55]
    name = [11,22,33,44]
    def f1():
        age = 18
        # global name
        name = 888          #当作私有变量处理
        print(age, name)
    def f2():
        age = 19
        print(age, name)
    f1()
    f2()
    
    # 输出
    18 888
    19 [11, 22, 33, 44]

      b6 全局变量,约定俗成使用大写,如下:

    NAME = "CHH"               # 全局变量大写
    def f1():
        age = 18
        global NAME               # 并在函数体中进行global声明
        NAME = "ALEX"
        print(age, NAME)
    def f2():
        age = 19
        print(age, NAME)
    f1()
    f2()
    
    #输出
    18 ALEX
    19 ALEX
  • 相关阅读:
    位运算
    Netty粘包&半包支持&Protobuf
    pythonelasticsearch
    SpringMybatis
    angular请求头部加XSRFTOKEN
    Requests库的开发者接口
    Css Selector常用定位方式总结
    selenium 浏览器常用设置
    syntax error near unexpected token `$’do\r”报错问题
    MySQL知识解答
  • 原文地址:https://www.cnblogs.com/chhphjcpy/p/6070319.html
Copyright © 2020-2023  润新知