Python - 函数|异常|模块|包|类和对象|封装|继承

1. 函数

1. 函数的多返回值

# 函数的多返回值：使用多个变量接收多个返回值
def test_return():
    return 1, "hello", True


x, y, z = test_return()
print(x)
print(y)
print(z)
1
2
3
4
5
6
7
8
9

1
hello
True

2. 函数的传参方式

# 函数的传参方式
# 1. 位置参数：调用函数时根据函数定义的参数位置来传递参数
def user_info(name, age, gender):
    print(f"你的名字为：{name}，你的年龄为：{age},你的性别为：{gender}")


user_info("zhangsan", 18, "男")


# 2. 关键字参数：函数调用时通过 '键=值' 的方式传入参数
def user_info(name, age, gender):
    print(f"你的名字为：{name}，你的年龄为：{age},你的性别为：{gender}")


user_info(name="zhangsan", age=18, gender="男")
user_info(age=18, name="chahua", gender="女")  # 关键字传参可以不按顺序传参
user_info("chahua", age=18, gender="女")  # 可以位置参数混用，但是位置参数需要放在前面


# 3. 缺省参数：为参数提供默认值，调用函数时可以不传改参数的值(默认值参数必须放在最后面)
def user_info(name, age, gender="女"):
    print(f"你的名字为：{name}，你的年龄为：{age},你的性别为：{gender}")


user_info(name="nini", age=18)
user_info(age=18, name="zhangsan", gender="男")


# 4. 可变参数：参数的个数不确定，分为位置参数的不定长和关键字参数的不定长
# 位置参数的不定长，会根据传进参数的位置合并为一个元祖，args是元祖类型
def user_info(*args):
    print(args)


user_info("a", "b", "c")
user_info("a", 18)


# 关键字参数的不定长,参数'键=值'形式的情况下，会根据'键=值'形成字典
def user_info(**kwargs):
    print(kwargs)


user_info(name='nini', age=18)
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

你的名字为：zhangsan，你的年龄为：18,你的性别为：男
你的名字为：zhangsan，你的年龄为：18,你的性别为：男
你的名字为：chahua，你的年龄为：18,你的性别为：女
你的名字为：chahua，你的年龄为：18,你的性别为：女
你的名字为：nini，你的年龄为：18,你的性别为：女
你的名字为：zhangsan，你的年龄为：18,你的性别为：男
(‘a’, ‘b’, ‘c’)
(‘a’, 18)
{‘name’: ‘nini’, ‘age’: 18}

3. 函数作为参数传递

# 函数作为参数传递
def test_fun(add):
    # 在这个函数中调用另一个函数
    result = add(1, 2)
    print(result)


def add(x, y):
    return x + y


test_fun(add)

# 也可以直接使用匿名函数
test_fun(lambda x, y: x + y)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2. 异常

# 捕获异常
try:
    # 可能发生错误的代码
    # 以r模式通过open打开一个不存在的文件，如果不存在，以w模式打开
    open("D:\\a.txt", "r")
except:
    # 如果发生错误执行的代码
    open("D:\\a.txt", "w")

# 捕获指定的异常
try:
    print(name)
except NameError as e:
    print("出现了变量未定义的异常")
    print(e)

# 捕获多个异常
try:
    1 / 0
except (NameError, ZeroDivisionError) as e:
    print("出现了变量未定义或者除0异常")

# 捕获所有异常，顶级异常
try:
    1 / 0
except Exception as e:
    print("出现了异常")

# else :没有异常时做的事情
try:
    1 / 0
except Exception as e:
    print("出现了异常")
else:
    print("没有异常时做的事情")

# finally : 无论如何都会执行的代码
try:
    1 / 0
except Exception as e:
    print("出现了异常")
finally:
    print("没有异常时做的事情")


# 异常的传递性：当所有函数都没哟捕获异常的时候，就会报错
def func_1():
    print("func_1开始")
    1 / 0
    print("func_1结束")


def func_2():
    print("func_2开始")
    func_1()
    print("func_2结束")


def func_3():
    try:
        func_2()
    except Exception as e:
        print(e)


func_3()
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

3. 模块

1. 模块的使用

"""
模块：就是java中我们要使用的包
导入模块： [from 模块名] import [模块 | 类 | 函数 | 变量 | * ] [as 别名]

import 模块名
from 模块名 import 类，变量，方法等
from 模块名 import *
from 模块名 as 别名
from 模块名 import 功能名 as 别名
"""
import time

print("你好")
time.sleep(2)
print("你好")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 从模块time只导入sleep方法
from time import sleep

print("你好")
time.sleep(2)
print("你好")
1
2
3
4
5
6

2. 自定义模块并使用

① 自定义模块：test_self_module.py

# 定义函数
def say_hi():
    print("我是一个程序员")

# 定义函数
def check():
    print("请出示健康码")

# 定义函数并传入参数
def add(num1, num2):
    result = num1 + num2
    print(f"{num1}+{num2}的值为：{result}")
1
2
3
4
5
6
7
8
9
10
11
12

② 使用自定义模块：

import test_self_module

test_self_module.add(1,3)
test_self_module.say_hi()
test_self_module.check()
1
2
3
4
5

1+3的值为：4
我是一个程序员
请出示健康码

3. 导入不同模块的同名功能

① 自定义模块：test_self_module1.py

# 定义函数并传入参数
def add(num1, num2):
    result = num1 - num2
    print(f"{num1}-{num2}的值为：{result}")
1
2
3
4

② 自定义模块：test_self_module.py

# 定义函数并传入参数
def add(num1, num2):
    result = num1 + num2
    print(f"{num1}+{num2}的值为：{result}")
1
2
3
4

③ 使用自定义模块：

from test_self_module1 import add
from test_self_module import add

add(1,2)
1
2
3
4

会使用后面导入的add方法，把前面导入的add方法覆盖了

1+2的值为：3

4. mian 变量

① 自定义模块：test_self_module.py

# 定义函数
def say_hi():
    print("我是一个程序员")

# main变量：不会在模块导入的地方运行该方法，只在该模块中运行该方法
if __name__ == '__main__':
    say_hi()
1
2
3
4
5
6
7

from test_self_module import say_hi

say_hi()
1
2
3

5. all 变量

# 定义函数
def say_hi():
    print("我是一个程序员")

# 定义函数
def check():
    print("请出示健康码")

# 定义函数并传入参数
def add(num1, num2):
    result = num1 + num2
    print(f"{num1}+{num2}的值为：{result}")

# 如果一个模块文件中有all变量，当使用from xxx import * 导入时，只能导入这个列表中的元素
__all__=['say_hi','check']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

from test_self_module import *

say_hi()
check()
# 无法导入add
1
2
3
4
5

4. 包

① 自定义包并使用

包就是一个文件夹，该文件夹下包含了一个__init__.py文件，该文件夹可用于抱哈多个模块文件，从逻辑上看，包的本质依然是模块。当创建一个包时，自动会在该包下生成一个__init__.py文件。

#导入learn包下面的test_self_module模块
from learn.test_self_module import say_hi
 
say_hi()
1
2
3
4

② 安装第三方包

C:\Users\User>pip install numpy
1

5. 类和对象

1. 类的成员属性

# 设计一个类
class Student:
    name = None
    gender = None
    nationality = None
    native_place = None
    age = None


# 创建一个对象
stu_1 = Student()

# 对对象进行赋值
stu_1.name = "妮妮"
stu_1.age = 18
stu_1.nationality = "中国"
stu_1.gender = "女"
stu_1.native_place = "南京"

# 获取对象中记录的信息
print(stu_1.name)
print(stu_1.nationality)
print(stu_1.gender)
print(stu_1.native_place)
print(stu_1.age)
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

2. 类和成员方法

在类中定义的变量为成员变量，在类中定义的方法为成员方法，成员方法和函数基本一致，但是仍有区别：

"""
def 方法名(self，形参1，形参2，，，)：
    方法体
"""


# 定义一个类
class Student:
    name: None
    age: None

    # self必须出现在参数列表中，定义方法时python自动传入self
    # 在方法内部，想要访问类的成员变量，必须使用self（可以理解为java的this）
    def say_hi(self):
        print(f"哈喽，大家好，我是{self.name}，今年{self.age}")

    def say_hi_1(self, name, age):
        print(f"哈喽，大家好，我是{name}，今年{age}")


# 创建类对象
student = Student()

# 类的成员变量
student.name = "nini"
student.age = 18

# 类的成员方法
# 尽管self在参数列表中，但是传参的时候可以忽略它
student.say_hi()
student.say_hi_1("lisi", 28)

# 创建对象2
student_1 = Student()
student_1.name = "zhangsan"
student_1.age = 29

student_1.say_hi()
student_1.say_hi_1("lisi", 19)
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
28
29
30
31
32
33
34
35
36
37
38
39

哈喽，大家好，我是nini，今年18
哈喽，大家好，我是lisi，今年28
哈喽，大家好，我是zhangsan，今年29
哈喽，大家好，我是lisi，今年19

3. 类和构造方法

# 创建类
class Student:
    name = None
    age = None
    gender = None

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
        print("创建一个类对象")


# 使用构造方法创建对象
student = Student("nini", 18, "女")
print(student.name)
print(student.age)
print(student.gender)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

创建一个类对象
nini
18
女

4.内置方法

"""
__init__：构造方法是内置方法，除了改方法，还有其他内置方法

__str__:字符串方法（类似于java中的toString）
__lt__:小于符号比较方法
__le__:小于等于符号比较方法
__eq__:等于符号比较方法
"""


# 创建类
class Student:
    name = None
    age = None
    gender = None

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
        print("创建一个类对象")

    # 内置方法，自动执行
    def __str__(self):
        return f"Student类对象，name {self.name},age:{self.age}"

    def __lt__(self, other):
        return self.age < other.age

    def __le__(self, other):
        return self.age <= other.age

    def __eq__(self, other):
        return self.age == other.age


student_1 = Student("nini", 18, "女")
print(student_1)
print(str(student_1))

student_2 = Student("haha", 20, "男")
print(student_1 < student_2)
print(student_1 > student_2)

print(student_1 <= student_2)
print(student_1 >= student_2)

print(student_1 == student_2)
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

6. 封装

"""
私有成员变量：变量以__开头
私有成员方法：方法以__开头

私有方法不能直接被类对象使用
私有变量无法赋值，也无法获取值
"""


class Student:
    name = None
    __age = 19
    __gender = "男"

    def __say_hi(self):
        print("say hi")

    def upgrade(self):
        if self.__age > 18:
            print("你可以毕业了")


student = Student()
student.upgrade()

# 对象无法调用私有成员变量
# print(student.age)
# 对象无法调用私有成员方法
# student.say_hi
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
28
29

7. 继承

"""
单继承: class 类名(父类)
多继承：class 类名(父类1，父类2，父类3,....)
"""


class Phone:
    imei = None
    producer = "huawei"

    def call_by_4g(self):
        print("4g通话")


class Phone2022(Phone):
    face_id = 1001
    # 重写父类的成员属性
    imei = "8090eqeu"

    # 重写父类的成员方法
    def call_by_4g(self):
        print("4g通话升级了")

    def call_by_5g(self):
        print("2022年新功能，5g通话")
        # 调用父类的成员变量
        print(super().producer)
        print(Phone.imei)
        # 调用父类的成员方法
        Phone.call_by_4g(self)
        super().call_by_4g()


phone = Phone2022()

phone.call_by_4g()
phone.call_by_5g()
Phone2022.call_by_4g(self=Phone2022)

print(phone.face_id)
print(phone.imei)
print(phone.producer)


# 调用父类的成员
print(Phone.imei)
print(Phone.producer)

# 调用父类的方法
Phone.call_by_4g(self=Phone)
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

4g通话升级了
2022年新功能，5g通话
huawei
None
4g通话
4g通话
4g通话升级了
1001
8090eqeu
huawei
None
huawei
4g通话