• 【python笔记】第八节 函数基础


    💕💕💕 博主昵称:摆烂阳💕💕💕

    🥰博主主页跳转链接
    👩‍💻博主研究方向:web渗透测试 、python编程
    📃 博主寄语:希望本篇文章能给大家带来帮助,有不足的地方,希望友友们给予指导

    ————————————————

    在这里插入图片描述

    一、函数简介

    函数(function):可以用来保存代码,在需要时,对这些代码进行重复的调用

    总结函数的优点:

    1. 遇到重复功能的时候,直接调用即可,减少代码量
    2. 提升代码,项目的结构性,分工明确,提高代码可读性
    3. 遇到扩展功能时,修改比较方便

    二、函数定义

    定义函数

    def 函数名(形参1,形参2....,形参n):
        代码块
    
    • 1
    • 2

    函数的命名规则和变量的命名规则一样

    1. 由数字,字母,下划线组成
    2. 不能数字开头
    3. 不能用关键字
    def fn():
        print("这是我的第一个函数")
    
    • 1
    • 2

    三、函数调用

    语法
    	函数名() 
    
    • 1
    • 2

    函数必须遵守先定义再调用

    def fn():  # 函数名 : fn
        print("这是我的第一个函数")
        print("hello")
        print("睡了吗")
    
    
    fn()
    fn()
    fn()
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    fn是什么

    函数对象=》表示存代码的位置=》内存地址 本体

    fn() 是什么

    调用函数

    print 是什么

    函数对象

    print() 是什么

    调用函数

    小练习
    定义一个login函数 功能是 输入用户名和密码,验证是否正确

    
    def login():
        username = input("请输入用户名:")
        password = input("请输入密码:")
        if username == 'root' and password == '123456':
            print("登录成功")
        else:
            print("用户名或密码错误,登录失败")
            
    login()
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    四、函数的参数

    1、形参和实参

    定义一个函数,可以用来求任意两个数的和

    # - 定义一个函数,可以用来求任意两个数的和
    # def sum(a, b):
    #     print(f"{a} + {b} = {a+b}")
    
    • 1
    • 2
    • 3

    函数的参数:在定义函数时,可以在函数名后()中定义数量不等的形参,多个形参之间使用 , 隔开

    形参(形式参数):定义形参就相当于在函数内部声明了变量,但是变量没有值

    实参(实际参数):在调用时候也必须传递实参,实参会赋值给对应位置的形参。

    # 定义函数时指定形参
    def fn(a, b):
        print("a =", a)
        print("b =", b)
    
    
    # 调用户数时,来传递实参
    fn(10, 20)
    
    fn(666, 333)
    
    
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    总结:定义函数时的参数叫形参,调用的时候的参数叫实参
    定义了多少个形参就必须传递多少个实参

    2、默认值参数

    # 定义形参的时候可以为形参指定默认值
    def fn(a, b, c=10):
        print("a =", a)
        print("b =", b)
        print("c =", c)
    
    fn(1, 2) # 如果不传递c,则采用默认值
    fn(1, 2,3) # 如果传递了。优先使用用户传的实参
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    3、实参的传递方式

    3.1位置参数

    就是将对应位置的实参赋值给对应位置的形参

    位置参数缺点:需要记忆形参的位置的意思

    3.2关键字参数

    关键字参数:可以不按照形参定义的顺序来传递,而是根据参数名来传递参数

    def fn(a,b,c):
        print("a =", a)
        print("b =", b)
        print("c =", c)
    
    fn(b=1,c=3,a=2) # 根据名字传参
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    位置参数和关键字参数可以混合使用

    def fn(a, b, c):
        print("a =", a)
        print("b =", b)
        print("c =", c)
    fn(1,2,c=20)
    
    • 1
    • 2
    • 3
    • 4
    • 5

    注意:可以混着,但是必须把位置参数写 关键字参数前面

    def fn(a, b, c):
        print("a =", a)
        print("b =", b)
        print("c =", c)
    fn(c=20,1,2)
    
    • 1
    • 2
    • 3
    • 4
    • 5

    4、实参的类型

    实参在传递的时候有没有类型的限制?

    函数调用不会限制你的类型,实参可以传递任意类型

    实参是可以任意一个数据类型,什么都行,啥都行

    5、可变参数

    5.1 args

    形参的前面加一个 * 号的参数就是可变参数,可以接收任意的位置参数,并且将所有的实参装到一个元组当中。

    def f(*a):
        print("a =", a)
        print(type(a))
    
    f(10,20,30,40,50,60,70,80,90,100)
    
    def new_sum(*a):  # *a 可以接收一切位置参数,并装包成一个元组
        print(sum(a))  # a就是元组
    
    new_sum(1, 2, 3, 4, 5)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    无论传入几个参数,都会统一保存到一个元组当中,这个操作也可以称之为装包

    1.带 * 号的形参 只能有一个,因为你写多了就没法分

    2.带 * 号的形参可以和其他参数配合使用,但是得写在后面

    def fn(*a, b, c):
        print("a =", a)
        print("b =", b)
        print("c =", c)
    
    fn(1, 2, 3, 4, 5, 6,7,8,9,10,20,30,b=4,c=3)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    注意,平时取带*参数的名字的时候 一般是取args

    5.2 kwargs

    形参可以接收任意的 关键字参数,会将这些 参数统一保存到字典里,字典的键就是参数的名字,字典的值就是参数的值。

    注意:形参也是只能一个,并且必须写在所有参数最后。
    命名潜规则:kwargs

    def fn(**kwargs):
        print("kwargs =",kwargs) 
        print(type(kwargs)) # 字典
    
    fn(a=1,b=2,c=3)
    
    • 1
    • 2
    • 3
    • 4
    • 5

    6、参数解包

    def fn(a, b, c, d):
        print("a =", a)
        print("b =", b)
        print("c =", c)
        print("d =", d)
    
    t = [1, 2, 3 ,4]
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    fn(*t) # 传递实参时,可以在序列类型添加 * 号

    def fn(a, b, c):
        print("a =", a)
        print("b =", b)
        print("c =", c)
    
    t = (10,20,30)
    d = {"b": 10, "a": 20, "c": 30}
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    fn(*t) # 传递实参时,可以在序列类型添加 * 号
    fn(**d) # 传递实参时,可以在序列类型添加 * 号

    五、函数返回值

    返回值:函数执行以后返回一个结果

    例如 f(x) = 2x + 1
    f(2)的值是5

    def f(x):
        return 2*x+1
    print(f(2)) # 5
    
    • 1
    • 2
    • 3

    python 可以通过 return 来指定函数的返回值,return 后是什么 函数返回值就是什么

    f(2)两个意思

    1.函数调用,会执行函数里面的代码
    2.本体还表示函数的返回值

    返回值可以是任意类型,包括函数

    None 代表空值 (N必须要大写)

    注意None千万不可以理解为0
    如果函数没有写reutrn, 返回None,表示空值

    总结:如果仅仅写一个reutrn 或者 不写return ,等价于 return

    None是python的特别的空值,用来代表空的
    在函数中 return 代表函数执行结束,后面代码不会执行。

    break:退出整个循环
    return : 结束函数

    def f(x):
        print(x) # print(6)
        return x + 1
        print(x + 1)
    
    
    print(f(6)) # print(7)
    
    
    
    def f(x):
        print(x) 
        return x+1
        return x+2
    
    print(f(5))
    
    
    def sum2(*args):
        result = 0
        for i in args:
            result += i
        return result
    
    
    r = sum2(1, 2, 3, 4, 5)
    print(r)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    fn 和 fn()

    print(fn) # 函数对象,打印fn就是打印函数对象地址 print(fn()) #
    调用函数,打印fn()其实就是在打印fn里面的返回值

    六、作用域

    1、作用域简介

    作用域直白来说就是产生作用的区域

    程序中就是:指的是变量生效的区域

    y = 2
    def fn():
        x = 1
        print("函数内部y =", y)
    fn()
    print("函数外部y =", y)
    print("函数外部x =", x)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    在Python作用域一共有2种

    1.全局作用域
    2.函数作用域

    2、全局作用域

    全局作用域:全局都有效

    全局作用域的生命周期:全局作用域在程序执行时创建了,在程序执行结束时候销毁

    所有函数以外的都是全局作用域

    在全局作用域中定义的变量,都属于全局变量,全局变量可以在程序的任意位置被访问

    y = 2  # 全局变量
    def fn():
        print("函数内部y =", y)
    
    fn()
    print("函数外部y =", y)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    3、函数作用域

    函数作用域就是在函数内部

    函数作用域生命周期:函数作用域在函数调用时创建,在调用结束时销毁

    
    
    def fn():
        a = 10
        print("a =",a)
    
    fn()
    fn()
    fn()
    # 程序执行过程中创建了3次 函数作用域
    
    
    函数中定义的变量,只能在函数内部访问
    def fn():
        a = 10
        print("内部a =",a)
    fn()
    print("外部a =",a)
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    变量的使用规则:变量可以由内往外看,不能由外往里看

    d

    ef fn1():
        a = 30
        def fn2():
            print(a)
        fn2()
        
        
    def fn1():
        def fn2():
            a = 10
        print(a) # 不能由内往里看
    
     
    def fn1():
        a = 20
        def fn2():
            a = 10
            print(a)  
        fn2()
    fn1() # 输出10
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    使用变量的时候,会优先在当前作用域中寻找该变量,如果找到就使用,没有则继续往上一级作用域寻找。如果全局作用域都没有,则报错

    如果希望在函数中去修改全局变量
    可以使用 global 关键字来声明变量

    a = 1
    def fn1():
        global a  # 声明在函数内部使用的a 是全局变量
        a = 2 # 修改了全局中的a
    
    fn1()
    print(a)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    总结:

    1.变量里面能看外面的,但是外面不能看里面的
    2.如果局部修改全局变量可以加上一个global关键字

    七、命名空间

    1、介绍

    命名空间是指变量存储的位置,每个变量都需要存储到指定的命名空间中。

    2、分类:

    1、局部命名空间(local):函数或类的方法的命名空间,它记录了函数的变量,包括函数的参数和局部定义的变量。
    2、闭包命名空间(enclosing function):闭包函数 的名称空间(Python 3 引入)。
    3、全局命名空间(global): 每个模块自己的命名空间,它记录了模块的变量,包括函数、类、其它导入的模块、模块级的变量和常量。
    4、内置命名空间(builtin):任何模块均可访问它,它存放着内置的函数和异常。

    3、查找顺序

    当一行代码要使用变量 x 的值时,Python 会到所有可用的名字空间去查找变量,按照如下顺序:

    局部命名空间:

    特指当前函数或类的方法。如果函数定义了一个局部变量 x,或一个参数 x,Python 将使用它,然后停止搜索。

    全局命名空间:

    特指当前的模块。如果模块定义了一个名为 x 的变量,函数或类,Python 将使用它然后停止搜索。

    内置命名空间:

    对每个模块都是全局的。作为最后的尝试,Python 将假设 x 是内置函数或变量。

    如果 Python 在这些名字空间找不到 x,它将放弃查找并引发一个 NameError 异常,如,NameError: name ‘aa’ is not defined。

    4、命名空间的生命周期

    不同的命名空间在不同的时刻创建,有不同的生存期。

    1、内置命名空间在 Python 解释器启动时创建,会一直保留,不被删除。

    2、模块的全局命名空间在模块定义被读入时创建,通常模块命名空间也会一直保存到解释器退出。

    3、当函数被调用时创建一个局部命名空间,当函数返回结果 或抛出异常时,被删除。每一个递归调用的函数都拥有自己的命名空间。

    本章小结

    本文是本人以前笔记,博主主页跳转链接如果有哪里不对的话欢迎各位大佬指出问题,本人也是初学python,希望可以和各位朋友一起学习进步。

    点击跳转到博主python专栏:
    如果有喜欢web安全的朋友,请在web渗透专栏中进行查看,点击跳转到博主web渗透专栏

  • 相关阅读:
    python解释器安装手把手指南
    FP7195做大功率钓鱼灯应用方案,0.1%深度无极无频闪调光调色应用,调光曲线顺滑无突兀
    Java程序设计——JDBC基础(JDBC编程)
    GSAman | 我「玩着游戏」就把「科研做了」
    Hadoop 集群相关知识点
    为什么我配置好了环境变量还是会报错
    leetcode 64. 最小路径和
    20 多元正态分布
    Android——一个简单的音乐APP(二)
    【笔者感悟】笔者的工作感悟【三】
  • 原文地址:https://blog.csdn.net/qinshuoyang1/article/details/126465547