Python复习(三)-函数

函数

  • 代码的一种组织形式
  • 一个函数一般完成一项特定的功能
  • 函数使用

    • 函数需要先定义
    • 使用函数,俗称调用
# 定义一个函数
# 只是定义的话不会执行
# 1. def关键字,后跟一个空格
# 2. 函数名,自己定义,起名需要遵循便令命名规则
# 3. 后面括号和冒号不能省,括号内可以由参数
# 4. 函数内所有代码缩进
def func():
    print("我是一个函数")
func() # 调用函数
我是一个函数

函数的参数和返回值

  • 参数: 负责给函数传递一些必要的数据或者信息

    • 形参(形式参数): 在函数定义的时候用到的参数没有具体值,只是一个占位的符号,成为形参
    • 实参(实际参数): 在调用函数的时候输入的值
  • 返回值: 函数的执行结果

    • 使用return关键字
    • 如果没有return,默认返回一个None
    • 函数一旦执行return语句,则无条件返回,即结束函数的执行
def hello(Persion):
    print("{}, 你好呀!".format(Persion))
Name = 'Taoy'
print(Name)  # Name 实参
Taoy
# return
def hello(Persion):
    return "%s, 你好呀!" % Persion
Name = 'Taoy'
Greeting = hello(Name)
print(Greeting)
Taoy, 你好呀!

参数详解

  • 参数分类

    • 普通参数
    • 默认参数
    • 关键字参数
    • 收集参数
  • 普通参数

    • 参见上例
    • 定义的时候直接定义变量名
    • 调用的时候直接把变量或者值放入指定位置

      def 函数名(参数1, 参数2,....):

      函数体
      

      调用

      函数名(value1, value2,.......)

      调用的时候,具体值参考的是位置,按位置赋值

  • 默认参数

    • 形参带有默认值
    • 调用的时候,如果没有对相应形参赋值,则使用默认值

      def func_name(p1=v1, p2=v2..........):

      func_block
      

      调用1

      func_name()

      调用2

      value1= 100
      value2=200
      func_name(value1,value2)

# 默认参数
def pet(pet_name, animal_type = 'dog'):
    print("I have a " + animal_type)
    print("My {0} name is {1}".format(animal_type, pet_name))
pet("cool")
print("- " * 20)
pet("Cool", "cat")
I have a dog
My dog name is cool
- - - - - - - - - - - - - - - - - - - - 
I have a cat
My cat name is Cool

关键字参数开始

  • 语法

    def func(p1=v1, p2=v2.....):
        func_body
        
    调用函数:
    func(p1=value1, p2=value2.......)
  • 比较麻烦,但也有好处:

    • 不容易混淆, 一般实参和形参只是按照位置一一对应即可,容易出错
    • 使用关键字参数,可以不考虑参数位置
# 关键词参数
def stu(name, age):
    print("My name is {0}, I'm {1} years old".format(name, age))
stu("cool",'19')
My name is cool, I'm 19 years old

收集参数

  • 把没有位置,不能和定义时的参数位置相对应的参数,放入一个特定的数据结构中
  • 语法

    def func(*args):

    func_body
    按照list使用方式访问args得到传入的参数
    

    调用:
    func(p1, p2, p3, .....)

  • 参数名args不是必须这么写,但是,我们推荐直接用args,约定俗成
  • 参数名args前需要由星号
  • 收集参数可以和其他参数共存
def Info( *args):
    print(type(args))
    for i in args:
        print(i)
        
Info("My", "Name", "is", "Taoy")
<class 'tuple'>
My
Name
is
Taoy

### 收集参数之关键字收集参数

    • 把关键字参数按字典格式存入收集参数
    • 语法:

      def func( **kwargs):

      func_body
      

      调用:

      func(p1=v1, p2=v2, p3=v3........)

    • kwargs一般约定俗成
    • 调用的时候,把多余的关键字参数放入kwargs
    • 访问kwargs需要按字典格式访问
    def Info(**kwargs):
        print(type(kwargs))
        for k, v in kwargs.items():
            print(k, "-----", v)
    Info(name='Taoy', age = 19)
    <class 'dict'>
    name ----- Taoy
    age ----- 19
    

    收集参数的解包问题

    • 把参数放入list或者字典中,直接把list/dict中的值放入收集参数中
    def num(*args):
        for i in args:
            print(i)
    l = [1, 2, 3]
    num(*l)
    1
    2
    3
    

    同理,dict类型收集参数一样可以解包,但是

    • 对dict类型进行解包
    • 需要用两个星号进行解包

    返回值

    • 函数和过程的区别

      • 有无返回值
    • 需要用return显示返回内容,
    • 如果没有返回,则默认返回None
    • 推荐写法,无论有无返回值,最后都要以return 结束
    def func_1():
        print("have return.")
        return 1
    
    def func_2():
        print("None return.")
    f1 = func_1()
    f2 = func_2()
    print(f1)
    print(f2)
    have return.
    None return.
    1
    None
    

    函数文档

    • 函数的文档的作用是对当前函数提供使用相关的参考信息
    • 文档的写法:

      • 在函数内部开始的第一行使用三引号字符串定义符
      • 一般具有特定格式
    • 文档查看

      • 使用help函数,形如 help(func)
      • 使用__doc__
    def Info(Name, Age):
        '''
        :param Name: 表示学生的名字
        :param Age: 表示学生的年龄
        :return 此函数没有返回值
        '''
        pass
    
    print(help(Info))
    
    print("- " * 30)
    print(Info.__doc__)
    Help on function Info in module __main__:
    
    Info(Name, Age)
        :param Name: 表示学生的名字
        :param Age: 表示学生的年龄
        :return 此函数没有返回值
    
    None
    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
    
        :param Name: 表示学生的名字
        :param Age: 表示学生的年龄
        :return 此函数没有返回值
    

    变量作用域

    • 变量由作用范围限制
    • 分类:按照作用域分类

      • 全局(global): 在函数外部定义
      • 局部(local):在函数内部定义
    • 变量的作用范围:

      • 全局变量:在整个全局范围都有效
      • 全局变量在局部可以使用(即函数内部可以方位函数外部定义的变量)
      • 局部变量在局部范围可以使用
      • 局部变量在全局范围无法使用
    • LEGB原则

      • L(Local)局部作用域
      • E(Enclosing function locale)外部嵌套函数作用域
      • G(Global module)函数定义所在模块作用域
      • B(Buildin): python内置魔抗的作用域
    a = 33 # a是全局变量
    def func():
        print(a)
        b = 66
        print(b) # b 的作用范围是函数func
    print(a)
    func()
    print(b)
    33
    33
    66
    
    ---------------------------------------------------------------------------
    
    NameError                                 Traceback (most recent call last)
    
    <ipython-input-30-bc6c5d76dbc7> in <module>
          6 print(a)
          7 func()
    ----> 8 print(b)
    
    NameError: name 'b' is not defined
    

    提升局部变量为全局变量

    • 使用global
    def func():
        global b # 局部变量声明为全局变量
        b = 10
        print(b)
    func()
    print(b)
    10
    10
    

    globals, locals函数

    • 可以通过globals和locals显示出局部变量和全局变量
    a = 1
    b = 2
    def func(a, b):
        c = 3
        print("Locals = {0}".format(locals()))
        print("Globals = {0}".format(globals()))
    # func(100,200)

    eval()函数

    • 把一个字符串当成一个表达式来执行, 返回表达式执行后的结果
    • 语法: val(string_code, globals=None, locals=None)

    exec()函数

    • 跟eval功能类似, 但是,不返回结果
    • 语法:exec(string_code, globals=None, locals=None)
    # eval 实例
    a = 100
    b = 200
    c = "a + b"
    d = eval(c)
    print(c)
    print(eval(c))
    print(d)
    a + b
    300
    300
    
    # exec 实例
    a = 100
    b = 200
    c = "a + b"
    exec("print('a + b:', a+b)")
    d = exec(c)
    print(d)
    a + b: 300
    None
    

    递归函数

    • 含税直接或者间接调用自身
    • 优点:简洁,理解容易
    • 缺点:对递归深度有限制,消耗资源大
    • python对递归深度有限制,超过限制报错
    • 在写递归程序的时候,一定注意结束条件
    a = 0
    def fun():
        global a
        a += 1
        print(a)
        if a == 10:
            return # End...
        fun()
    fun()
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    
    # 斐波那契额数列
    # 一列数字,第一个值是1, 第二个也是1, 从第三个开始,每一个数字的值等于前两个数字出现的值的和
    # 数学公式为: f(1) = 1, f(2) = 1, f(n) = f(n-1) + f(n-2)
    # 例如: 1, 1, 2, 3, 5, 8....
    def fib(n):
        if n == 1:
            return 1
        if n == 2:
            return 1
        return fib(n-1) + fib(n - 2)
    print(fib(3))
    print(fib(9))
    2
    34
    

    本文链接:

    https://www.betao.cn/archives/python-review03.html
    1 + 9 =
    快来做第一个评论的人吧~