Python面向对象编程（2）

已于 2024-05-13 13:26:13 修改
阅读量938 收藏 22
点赞数 27
文章标签： python 开发语言
于 2024-05-13 13:14:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55266011/article/details/138798861
版权

Python面向对象编程（2）

一、理解面向对象

面向对象是一种抽象化的编程思想

面向对象就是将编程当成是一个事物，对于外界来说，事物是直接可以使用的，不用去管他的内部的情况。而编程就是设置事物能够做什么事。

二、类和对象

类和对象的关系：用类去创建一个对象/用类实例化一个对象

类

类是对一系列具有相同特征和行为的事物的统称，是一个抽象的概念，不是真实存在的事物

  • 特征即是属性
  • 行为即是方法

类比如是制造洗衣机时要用的图纸，也就是说类是用来创建对象

对象

对象是类创建出来的真实存在的事物

注意：开发中，先有类，再有对象

面向对象实现方法

定义类

  • 语法：

    class 类名():
    代码
    ......

    注意：类名要满足标识符命名规则，同时遵循大驼峰命名习惯

创建对象

  • 语法：

  • 对象名 = 类名()
体验
# 需求： 洗衣机，功能：能洗衣服
# 1. 定义洗衣机类
class Washer():
    def wash(self):
        print('能洗衣服')


# 2. 创建对象
haier = Washer()
# 3. 验证成果
# 打印haier对象
print(haier)
# 使用wash功能  实例方法/对象方法  对象名.Wash()
haier.wash()
self

self指的是调用该函数的对象

# 1. 定义洗衣机类
class Washer():
    def wash(self):
        print('我会洗衣服')
        # <__main__.Washer object at 0x0000021F4AED8948>
        print(self)


# 2. 创建对象
haier = Washer()
# <__main__.Washer object at 0x0000021F4AED8948>
print(haier)
haier.wash()
一个类创建多个对象
# 1. 定义洗衣机类
class Washer():
    def wash(self):
        print('我会洗衣服')
        # <__main__.Washer object at 0x0000021F4AED8948>
        print(self)


# 2. 创建对象
haier1 = Washer()
haier2 = Washer()

haier1.wash()
haier2.wash()

# 我会洗衣服
# <__main__.Washer object at 0x0000012AFB2BA788>
# 我会洗衣服
# <__main__.Washer object at 0x0000012AFE70CBC8>

三、添加和获取对象属性

对象属性既可以在外面添加和获取，也能在类里面添加和获取

类外面添加对象属性

  • 语法：

    对象名.属性名 = 值

  • 体验

    haier1.width = 500
haier1.height = 800

类外面获取对象属性

  • 语法：

    对象名.属性名

  • 体验

    print(f'haier1的宽度是{harer1.width}')
print(f'haier1的宽度是{harer1.height}')

类里面获取对象属性

  • 语法：

  • self.属性名

  • 体验

    class Washer():
    def wash(self):
        print('洗衣服')

    def print_info(self):
        print(f'宽度{self.width}')
        print(f'高度{self.height}')


# 2. 创建对象
haier1 = Washer()

haier1.width = 500
haier1.height = 800

# 对象调用实例方法
haier1.print_info()
# 宽度500
# 高度800

四、魔法方法

在Python中，____xx()的函数叫做魔法方法，指的是具有特殊功能的函数

____init() 方法的作用：初始化对象

class Washer():

    # 定义__init__，添加实例属性
    def __init__(self):
        self.width = 500
        self.height = 800

    def print_info(self):
        print(f'{self.height},{self.width}')


haier1 = Washer()
haier1.print_info()
# 800,500

注意：

  • ____init()方法，在创建一个对象时默认被调用，不需要手动调用
  • ____init(self)中的self，不需要开发中传递，Python解释器会自动吧当前的对象引用传递过去

带参数的______init__()

一个类可以创建多个对象，如何对不同的对象设置不同的初始化属性：传参数

class Washer():

    # 定义__init__，添加实例属性
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def print_info(self):
        print(f'{self.width},{self.height}')


haier1 = Washer(10, 20)
haier1.print_info()
# 10,20


haier2 = Washer(30, 40)
haier2.print_info()
# 30,40

____str()

当使用print输出对象的时候，默认打印对象的内存地址。如果类定义了______str__()方法，那么就会打印从在这个方法中return的数据。

class Washer():

    # 定义__init__，添加实例属性
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def __str__(self):
        return '这是说明书'

    def print_info(self):
        print(f'{self.width},{self.height}')


haier1 = Washer(10, 20)
haier1.print_info()
print(haier1)
# 10,20
# 这是说明书

____del()

当删除对象时，python解释器也会默认调用______del__()方法。

class Washer():
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def __del__(self):
        print(f'{self}对象已经被删除')


haier1 = Washer(10, 20)

# <__main__.Washer object at 0x0000026118223278>对象已经被删除
del haier1

五、应用-烤地瓜


# 定义类：
# 地瓜的属性： 备考的时间，地瓜的状态，添加的调料
# 地瓜的方法： 备考  用户根据意愿设定每次烤地瓜的时间  判断地瓜被烤的总时间是在哪个区间，修改地瓜状态
#            添加调料   用户根据意愿设定添加的调料   将用户添加的调料存储
# 显示对象信息

# 1.定义类： 初始化属性、被烤和添加调料的方法、显示对象信息的str
class SweetPotato():
    def __init__(self):
        self.cook_time = 0
        self.cook_static = '生的'
        self.condiments = []

    def cook(self, time):
        self.cook_time += time
        if 0 <= self.cook_time < 3:
            self.cook_static = '生的'
        elif 3 <= self.cook_time < 5:
            self.cook_static = '半生不熟'
        elif 5 <= self.cook_time < 8:
            self.cook_static = '熟了'
        elif self.cook_time >= 8:
            self.cook_static = '烤糊了'

    def add_condiments(self, x):
        self.condiments.append(x)

    def __str__(self):
        return f"这个地瓜烤了{self.cook_time}分钟，状态是{self.cook_static},添加的调料有:{' '.join(self.condiments)}"


digua1 = SweetPotato()
print(digua1)
digua1.cook(2)
digua1.add_condiments('辣椒')
digua1.cook(5)
print(digua1)


# 这个地瓜烤了0分钟，状态是生的,添加的调料有:
# 这个地瓜烤了7分钟，状态是熟了,添加的调料有:辣椒

六、应用-搬家具

# 将小于房子剩余面积的家具摆放到房子中
# 需求涉及两个事物： 房子和家具，故被案例涉及两个类： 房子类和家具类
# 房子类： 实例属性：房子地理位置，房子占地面积，房子剩余面积，房子内家具列表    实例方法：容纳家具    显示房屋信息
# 家具类： 家具名称，家具占地面积

class Furniture():
    def __init__(self, name, area):
        self.name = name
        self.area = area


class Home():
    def __init__(self, address, area):
        self.address = address
        self.area = area
        self.free_area = area
        self.furniture = []

    def __str__(self):
        return f'房子地理位置在{self.address},房屋面积是{self.area}, 剩余面积{self.free_area}, 家具有{self.furniture}'

    def add_furniture(self, item):
        if self.free_area >= item.area:
            self.free_area -= item.area
            self.furniture.append(item.name)
        else:
            print('家具太大，剩余面积不足，无法容纳')


bed = Furniture('板凳', 20)
sofa = Furniture('沙发', 100)

jia = Home('天水', 1000)
print(jia)
jia.add_furniture(bed)
print(jia)
jia.add_furniture(sofa)
print(jia)

# 房子地理位置在天水,房屋面积是1000, 剩余面积1000, 家具有[]
# 房子地理位置在天水,房屋面积是1000, 剩余面积980, 家具有['板凳']
# 房子地理位置在天水,房屋面积是1000, 剩余面积880, 家具有['板凳', '沙发']

七、继承

  • 拓展1：经典类或旧式类

    不由任意内置类型派生出的类，称之为经典类

    class 类名：
	代码
    ......

  • 拓展2：新式类

    class 类名(object):
    代码

继承的概念

Python面向对象的继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法

# 父类
class A(object):
    def __init__(self):
        self.num = 1
        
    def info_print(self):
        print(self.num)
        
# 子类B
class B(A):
    pass


result = B()
result.info_print()
# 1

单继承

class Master(object):
    def __init__(self):
        self.kongfu = '古法煎饼果子配方'
        
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
        
      
class Prentice(Master):
    pass


daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

多继承

多继承就是一个类同时继承了多个父类

class Master(object):
    def __init__(self):
        self.kongfu = '古法煎饼果子配方'
        
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
        
        
        
#创建学校类
class School(object):
    def __init__(self):
        self.kongfu = '私有煎饼果子配方'
        
    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
        
        
class Prentice(School, Master):
    pass


daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

# 私有煎饼果子配方
# 运用私有煎饼果子配方制作煎饼果子

子类重写父类的同名属性和方法

class Master(object):
    def __init__(self):
        self.kongfu = '古法煎饼果子配方'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 创建学校类
class School(object):
    def __init__(self):
        self.kongfu = '私有煎饼果子配方'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '独创煎饼果子配方'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()

# 独创煎饼果子配方
# 运用独创煎饼果子配方制作煎饼果子
  • 拓展 ____mro 查看继承关系
类名.__mro__

# (<class '__main__.Prentice'>, <class '__main__.School'>, <class '__main__.Master'>, 
#<class 'object'>)

子类调用父类的同名属性和方法

class Master(object):
    def __init__(self):
        self.kongfu = '古法煎饼果子配方'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 创建学校类
class School(object):
    def __init__(self):
        self.kongfu = '私有煎饼果子配方'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '独创煎饼果子配方'

    def make_cake(self):
        # 如果是先调用了父类的属性和方法，父类属性会覆盖子类属性，故在调用属性前，先调用自己子类的初始化
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    #调用父类方法，但是为保证调用到的也是父类的属性，必须在调用父类的初始化
    def make_master_cake(self):
        Master.__init__(self)
        Master.__init__(self)
        
    def make_school_cake(self):
        School.__init__(self)
        School.__init__(self)
        
        

daqiu = Prentice()
daqiu.make_cake()
daqiu.make_master_cake()
daqiu.make_school_cake()
daqiu.make_cake()

# 运用独创煎饼果子配方制作煎饼果子
# 运用古法煎饼果子配方制作煎饼果子
# 运用私有煎饼果子配方制作煎饼果子
# 运用独创煎饼果子配方制作煎饼果子

多层继承

class Master(object):
    def __init__(self):
        self.kongfu = '古法煎饼果子配方'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 创建学校类
class School(object):
    def __init__(self):
        self.kongfu = '私有煎饼果子配方'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


class Prentice(School, Master):
    def __init__(self):
        self.kongfu = '独创煎饼果子配方'

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)



class Tusun(Prentice):
    pass


xiaoqiu = Tusun()
xiaoqiu.make_cake()
xiaoqiu.make_master_cake()
xiaoqiu.make_school_cake()

# 运用独创煎饼果子配方制作煎饼果子
# 运用古法煎饼果子配方制作煎饼果子
# 运用私有煎饼果子配方制作煎饼果子

super()

  • super(当前类名， self).函数()

  • super().函数()

class Master(object):
    def __init__(self):
        self.kongfu = '古法煎饼果子配方'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 创建学校类
class School(Master):
    def __init__(self):
        self.kongfu = '私有煎饼果子配方'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
        # 有参数
        # super(School, self).__init__()
        # super(School, self).make_cake()
        # 无参数
        super().__init__()
        super().make_cake()


class Prentice(School):
    def __init__(self):
        self.kongfu = '独创煎饼果子配方'

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)

    def make_old_cake(self):
        # 方法一：如果定义的类名修改，这里也要修改， 代码量庞大，冗余
        # School.__init__(self)
        # School.make_cake(self)
        # Master.__init__(self)
        # Master.make_cake(self)
        # 方法二：super()
        # 方法2.1 super(当前类名， self).函数()
        # super(Prentice, self).__init__()
        # super(Prentice, self).make_cake()
        # 方法2.2: super().函数()
        super().__init__()
        super().make_cake()


daqiu = Prentice()
daqiu.make_old_cake()

# 运用私有煎饼果子配方制作煎饼果子
# 运用古法煎饼果子配方制作煎饼果子

私有属性和私有方法

在Python中，可以为实例属性设置私有权限，即设置某个实例属性或实例方法不继承给子类

定义私有属性和方法

设置私有权限的方法：在属性名和方法名 前面 加上两个下划线__

class Master(object):
    def __init__(self):
        self.kongfu = '古法煎饼果子配方'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 创建学校类
class School(Master):
    def __init__(self):
        self.kongfu = '私有煎饼果子配方'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
        # 有参数
        # super(School, self).__init__()
        # super(School, self).make_cake()
        # 无参数
        super().__init__()
        super().make_cake()


class Prentice(School):
    def __init__(self):
        self.kongfu = '独创煎饼果子配方'
        # 定义私有属性
        self.__money = 200000

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)

    def make_old_cake(self):
        # 方法一：如果定义的类名修改，这里也要修改， 代码量庞大，冗余
        # School.__init__(self)
        # School.make_cake(self)
        # Master.__init__(self)
        # Master.make_cake(self)
        # 方法二：super()
        # 方法2.1 super(当前类名， self).函数()
        # super(Prentice, self).__init__()
        # super(Prentice, self).make_cake()
        # 方法2.2: super().函数()
        super().__init__()
        super().make_cake()

    # 定义私有方法
    def __info_print(self):
        print('这是私有方法')


class Tusun(Prentice):
    pass


xiaoqiu = Tusun()
xiaoqiu.make_old_cake()
获取和修改私有属性值

在Python中，一般定义函数名get_xx用来获取私有属性，定义set_xx用来修改私有属性值

class Master(object):
    def __init__(self):
        self.kongfu = '古法煎饼果子配方'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')


# 创建学校类
class School(Master):
    def __init__(self):
        self.kongfu = '私有煎饼果子配方'

    def make_cake(self):
        print(f'运用{self.kongfu}制作煎饼果子')
        # 有参数
        # super(School, self).__init__()
        # super(School, self).make_cake()
        # 无参数
        super().__init__()
        super().make_cake()


class Prentice(School):
    def __init__(self):
        self.kongfu = '独创煎饼果子配方'
        # 定义私有属性
        self.__money = 200000

    def make_cake(self):
        self.__init__()
        print(f'运用{self.kongfu}制作煎饼果子')

    def make_master_cake(self):
        Master.__init__(self)
        Master.make_cake(self)

    def make_school_cake(self):
        School.__init__(self)
        School.make_cake(self)

    def make_old_cake(self):
        # 方法一：如果定义的类名修改，这里也要修改， 代码量庞大，冗余
        # School.__init__(self)
        # School.make_cake(self)
        # Master.__init__(self)
        # Master.make_cake(self)
        # 方法二：super()
        # 方法2.1 super(当前类名， self).函数()
        # super(Prentice, self).__init__()
        # super(Prentice, self).make_cake()
        # 方法2.2: super().函数()
        super().__init__()
        super().make_cake()

    # 定义私有方法
    def __info_print(self):
        print('这是私有方法')

    # 定义函数：获取私有属性值 get_xx
    def get_money(self):
        return self.__money

    # 定义函数： 修改私有属性值 set_xx
    def set_money(self):
        self.__money = 5000


class Tusun(Prentice):
    pass


xiaoqiu = Tusun()
print(xiaoqiu.get_money())
xiaoqiu.set_money()
print(xiaoqiu.get_money())


# 2000000
# 5000

八、多态 类方法 类属性

面向对象的三大特性

封装
  • 将属性和方法书写到类里面的操作即为封装
  • 封装可以为属性和方法添加私有权限
继承
  • 子类默认继承父类的所有属性和方法
  • 子类可以重写父类属性和方法
多态
  • 传入不同的对象，产生不同的结果

多态

了解多态

多态指的是一类事物有多种形态（一个抽象类有多个子类，因而多态的概念依赖于继承）

  • 定义：多态是一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果
  • 好处：调用灵活，有了多态，更容易编写出通用的代码，做出通用的编程，以适应需求的不断变化！
  • 实现步骤：
    1. 定义父类，并提供公共方法
    2. 定义子类，并重写父类的方法
    3. 传递子类对象给调用者，可以看到不同子类执行效果不同
体验多态
class Dog(object):
    def work(self):
        print('指哪打哪')


class ArmyDog(Dog):
    def work(self):
        print('追击敌人')


class DrugDog(Dog):
    def work(self):
        print('追查毒品')


class Person(object):
    def work_with_dog(self, dog):
        dog.work()


ad = ArmyDog()
dd = DrugDog()

daqiu = Person()
daqiu.work_with_dog(ad)
daqiu.work_with_dog(dd)

# 追击敌人
# 追查毒品

类属性和实例属性

设置和访问类属性
  • 类属性就是 类对象 所拥有的属性，他被 该类的所有实例对象 所共有
  • 类属性可以使用 类对象 或 实例对象 访问
class Dog(object):
    tooth = 10
    
wangcai = Dog()
xiaohei = Dog()
print(Dog.tooth)  # 10
print(wangcai.tooth)  # 10
print(xiaohei.tooth)  # 10

类属性的优点：

  • 记录的某项数据始终保持一致，则定义类属性
  • 实例属性 要求 每个对象 为其 单独开辟一份内存空间 来记录数据，而 类属性 为全类所共有，仅占一份内存，更加节省内存空间
修改类属性

类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了一个实例属性

class Dog(object):
    tooth = 10


wangcai = Dog()
xiaohei = Dog()
# 通过类修改类属性  类.类属性 = 值
Dog.tooth = 20
print(Dog.tooth)  # 20
print(wangcai.tooth)  # 20
print(xiaohei.tooth)  # 20
# 通过对象修改属性， 创建了一个实例属性
wangcai.tooth = 200
print(Dog.tooth)    # 10
print(wangcai.tooth)    # 200
print(xiaohei.tooth)    # 10

类方法和静态方法

类方法

  • 类方法的特点：

    需要用装饰器 @classmenthod 来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以 cls 作为第一个参数

  • 使用场景

    当类方法中 需要使用类对象（如访问私有类属性等）时，定义类方法

    类方法一般和类属性配合使用

class Dog(object):
    __tooth = 10

    @classmethod
    def get_tooth(cls):
        return cls.__tooth


wangcai = Dog()
result = wangcai.get_tooth()
print(result)   # 10
静态方法

  • 静态方法特点

    需要通过装饰器@staticmethod 来进行修饰，静态方法既不需要传递类对象也不需要传递实例对象（形参没有self/cls).

    静态方法 也能够通过 实例对象和类对象去访问

  • 使用场景

    当方法中 既不需要使用实例对象（如实例对象，实例属性），也不需要使用类对象（如类方法、类属性、创建实例等）时，定义静态方法

    取消不需要的参数传递，有利于减少不必要的内存占用和性能消耗

class Dog(object):
    @staticmethod
    def info_print():
        print('这是一个狗类，用于创建实例')


wangcai = Dog()
wangcai.info_print()
# 这是一个狗类，用于创建实例

九、异常

了解异常

当检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的“异常”

异常的写法
try:
    可能发生错误的代码
except:
    如果出现异常执行的代码

捕获异常

体验
try:
    print(num)
except:
    print("有错误")
捕获指定异常
try:
    可能发生错误的代码
except 异常类型:
    如果出现异常执行的代码

try:
    print(num)
except NameError:
    print("有错误")

如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常

一般try下放只放一行尝试执行的代码

捕获多个指定异常

当捕获多个异常时，可以把要捕获的异常类型的名字，放在except后，并使用元组的方式进行书写

try:
    print(1/0)
except (NameError, ZeroDivisionError):
    print("有错误")
捕获异常描述信息
try:
    print(1/0)
except (NameError, ZeroDivisionError) as result:
    print(result)
捕获所有异常
try:
    print(num)
except Exception as result:
    print(result)

异常的else

else 表示的是如果没有异常要执行的代码

try:
    print(1)
except Exception as result:
    print(result)
else:
    print('我是else，是没有异常的时候执行的代码')

异常finally

finally表示的是无论是否异常都要执行的代码，例如关闭文件

try:
    f = open('test.txt', 'r')
except Exception as result:
    f = open('text.txt', 'w')
else:
    print('没有异常，真开心')
finally:
    f.close()

异常的传递

体验异常传递

需求：

  1. 尝试只读方式打开test.txt文件，如果文件存在则读取文件的内容，文件不存在则提示用户即可
  2. 读取内容要求：尝试循环读取内容，读取过程中如果检测到用户意外终止程序，则except捕获异常并提示用户
try:
    f = open('test.txt', 'r')
    try:
        while True:
            content = f.readline()
            if len(content) == 0:
                break
            time.sleep(3)
            print(content)
    except:
        # 如果在读取文件过程中，产生了异常，那么就会捕获到
        # 比如 按下了 ctrl+c
        print('意外终止了读取数据')
    finally:
        f.close()
        print('关闭文件')
except:
    print('该文件不存在')

自定义异常

在Python中，抛出自定义异常的语法为raise异常类对象

需求：密码长度不足，则报异常（用户输入密码，如果输入的长度不足3位，则报错，即抛出自定义异常，并捕获该异常）

# 自定义异常类，继承Exception
class ShortInputError(Exception):
    def __init__(self, length, min_len):
        self.length = length
        self.min_len = min_len
        
    # 设置抛出异常的描述信息
    def __str__(self):
        return f'你输出的长度是{self.length}, 不能少于{self.min_len}个字符'
    
def main():
    try:
        con = input('请输入密码：')
        if len(con) < 3:
            raise ShortInputError(len(con), 3)
    except Except as result:
        print(result)
    else:
        print('密码已经输入完成')
        
main()

十、模块和包

了解模块

Python模块（Module），是一个Python文件，以.py结尾，包含了Python对象定义和Python语句。

模块能定义函数，类和变量，模块里也能包含可执行的代码

导入模块
  1. import 模块名
  2. from 模块名 import 功能名
  3. from 模块名 import *
  4. import 模块名 as 别名
  5. from 模块名 import 功能名 as 别名

导入模块

import
# 导入模块
import 模块名
import 模块名1，模块名2...

# 调用功能
模块名.功能名()
from … import…
from 模块名 import 功能1， 功能2， 功能3...
from … import *
from 模块名 import *
as定义别名
# 模块定义别名
import 模块名 as 别名

# 功能定义别名
from 模块名 import 功能 as 别名

制作模块

在Python中，每个Python文件都可以作为一个模快，模块的名字就是文件的名字。也就是自定义模块名必须要符合标识符命名规则

定义模块

新建一个Python文件，命名为my_model.py，并定义testA函数

def testA(a, b):
    print(a + b)
测试模块

在实际开发中，当一个开发人员编写完一个模块后，为了让模块能够在项目中达到想要的效果，这个开发人员会自行在py文件中添加一些测试信息，例如，在my_model.py文件中添加测试代码

def testA(a, b):
    print(a + b)
        
# 只有当前文件中调用该函数，其他导入的文件内不符合该条件，则不执行testA函数调用
if __name__ == '__main__':
    testA(1,1)
调用模块
import my_model
模块的定位顺序

当导入一个模块，Python解释器对模块位置的搜索顺序是：

  1. 当前目录
  2. 如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录
  3. 如果都找不到，Python会查看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/

模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录

注意：

  • 自己的文件名不要和已有模块名重复，否则导致模块功能无法使用
  • 使用from 模块名 import 功能 的时候，如果功能名字重复，调用到的是最后定义或导入的功能
名字重复

import time 模块名 ，功能名字重复问题，在Python中数据是通过引用传递的

____all

如果一个模块文件中有______all__变量，当使用 form xxx import * 导入时，只能导入这个列表中的元素

my_model模块代码
__all__ = ['testA']

def testA():
    print('testA')
    

def testB():
    print('testB')
导入模块的文件代码
from my_model import *

testA()
testB()	# 会报错，因为__all__列表中没有testB

包的使用方法

包将有联系的模块组织在一起，即放在用一个文件夹下，并且文件夹创建一个名字为______init__.py文件，那么这个文件夹就成为包

制作包

【New】 – 【Python Package】 – 输入包名 – 【OK】 – 新建功能模块（有联系的模块）

注意：新建包后，包内部会自动创建______init__.py 文件，这个文件控制着包的导入行为

导入包

import 包名.模块名

from 包名 import * 模块名.目标 （必须要在______init__.py 中加入功能名）

拓展：____dict

class A(object):
    a = 0

    def __init__(self):
        self.b = 1


aa = A()
# 返回类内部所有属性和方法对应的字典
print(A.__dict__)
# 返回实例属性和值组成的字典
print(aa.__dict__)

十一、案例面向对象版学员管理系统

student.py

class Student(object):
    def __init__(self, name, gender, tel):
        self.name = name
        self.gender = gender
        self.tel = tel

    def __str__(self):
        return f'{self.name}, {self.gender}, {self.tel}'

managerSystem.py

from student import *


class StudentManager(object):
    def __init__(self):
        self.student_list = []

    # 一、程序入口函数，启动程序后执行的函数
    def run(self):
        # 1.加载学员信息
        self.load_student()
        while True:
            # 2.显示菜单功能
            self.show_menu()
            # 3.用户输入功能序号
            menu_num = int(input('请输入您需要的功能序号：'))
            # 4.根据用户输入的功能序号执行不同的功能
            if menu_num == 1:
                # 添加学员
                self.add_student()
            elif menu_num == 2:
                # 删除学员
                self.del_student()
            elif menu_num == 3:
                # 修改学员信息
                self.modify_student()
            elif menu_num == 4:
                # 查询学员信息
                self.search_student()
            elif menu_num == 5:
                # 显示所有学员信息
                self.show_student()
            elif menu_num == 6:
                # 保存学员信息
                self.save_student()
            elif menu_num == 7:
                # 退出系统
                break

    # 二、系统功能函数
    # 2.1 显示功能菜单 -- 打印序号的功能对应关系  --静态方法
    @staticmethod
    def show_menu():
        print("请选择如下功能：")
        print("1.添加学员")
        print("2.删除学员")
        print("3.修改学员信息")
        print("4.查询学员信息")
        print("5.显示所有学员信息")
        print("6.保存学员信息")
        print("7.退出系统")

    # 2.2 添加学员
    def add_student(self):
        # 1. 让用户输入姓名、性别、手机号
        name = input("请输入您的姓名：")
        gender = input("请输入您的性别：")
        tel = input("请输入您的电话号码：")
        # 2. 创建学员对象
        student = Student(name, gender, tel)
        # 3. 将该对象添加到学员列表
        self.student_list.append(student)
        print(self.student_list)
        print(student)

    # 2.3 删除学员
    def del_student(self):
        def_name = input("请输入要删除的学员姓名：")
        for i in self.student_list:
            if i.name == def_name:
                self.student_list.remove(i)
                break
        else:
            print("查无此人")
        print(self.student_list)

    # 2.4 修改学员信息
    def modify_student(self):
        modify_name = input("请输入要修改的学员姓名：")
        for i in self.student_list:
            if i.name == modify_name:
                i.name = input("请输入学员姓名：")
                i.gender = input("请输入学员性别：")
                i.tel = input("请输入学员手机号：")
                print(f"修改学员信息成功，姓名：{i.name}，性别：{i.gender}，电话号码：{i.tel}")
                break
        else:
            print("查无此人！")

    # 2.5 查询学员信息
    def search_student(self):
        search_name = input("请输入要查询学员的姓名：")
        for i in self.student_list:
            if i.name == search_name:
                print(f"该学员信息查找成功，姓名：{i.name}，性别：{i.gender}，电话号码：{i.tel}")
                break
        else:
            print("查无此人！")

    # 2.6 显示所有学员信息
    def show_student(self):
        print("所有学员信息\n姓名\t\t性别\t\t电话号码")
        for i in self.student_list:
            print(f"{i.name}\t{i.gender}\t{i.tel}")

    # 2.7 保存学员信息
    def save_student(self):
        f = open('student.data', 'w')
        new_list = [i.__dict__ for i in self.student_list]
        print(new_list)
        f.write(str(new_list))
        f.close()

    # 2.8 加载学员信息
    def load_student(self):
        try:
            f = open('student.data', 'r')
        except:
            f = open('student.data', 'w')
        else:
            data = f.read()
            new_list = eval(data)
            self.student_list = [Student(i['name'], i['gender'], i['tel']) for i in new_list]
        finally:
            f.close()

main.py

from managerSystem import *

if __name__ == '__main__':
    student_manager = StudentManager()

    student_manager.run()
_Pomelo
关注
Python面向对象编程指南
06-19
本套视频教程致力于深入讲解Python语言的面向对象编程思想，通过丰富、强大的代码示例为学员循序渐进地讲解如何编写高质量的Python代码。通过实际的例子对Python中面向对象编程的理念进行介绍。针对所有可用于和...
Python 面向对象编程指南 new
01-01
《Python面向对象编程指南》这本书，由Steven F. Lott编写，提供了一个全面深入的视角来理解和应用Python的OOP特性。 面向对象编程的核心概念包括类（Class）、对象（Object）、继承（Inheritance）、封装...
如何理解python面向对象编程
12-17
Python 是一种支持多种编程范式的语言，包括面向对象编程。在Python中，理解和掌握面向对象编程的基本概念对于编写高效、可维护的代码至关重要。 类（Class）是面向对象编程的核心，它是描述对象（Object）特性的...
面向对象编程基础_python面向对象_python教程_
09-29
以上就是Python面向对象编程的基本概念和特性。掌握这些基础知识，能帮助你更好地理解和编写Python程序，尤其在处理复杂逻辑和大型项目时，面向对象编程的优势会更加明显。在实际应用中，不断实践和探索，才能真正...
Tcl lnit error: Can’t find a usable init.tcl in the following directories 问题解决
梦想闹钟
09-15 465
实际研究后发现，其实py2exe已经把打包需要的lib放在dist文件夹下了，但是打包后的程序运行后却没有去lib下找，而是去找系统自带的环境变量里找，所以找不到。这个问题出现在我用py2exe打包了一个包含tkinter的图形化界面，在当前电脑上运行无问题，在移动到新电脑上后提示报错、getcwd用于获取当前工作目录绝对路径，在设置环境的变量的时候它用的是绝对路径-所以也导致了在当前电脑上能用而移动后不能用。解决方法是在你的程序里重新设置下环境变量，而且是用相对路径的形式。
Python世界：力扣29题两数相除算法实践
来知晓的博客
09-13 433
除法运算本质是减法，从理解原理到真正实现还是有距离，建议初步理解后，不参考任何代码，完全自己复现一遍，体会更深。注意提示：目的就是提醒越界问题：-2^31/-1=2&31，超过了整数表达范围。本问题来自于力扣29题，在做完大数相乘后，顺带也看下两数相除。将两数相除，要求不使用乘法、除法和 mod 运算符。给定两个整数，被除数。
[Python数据可视化]Plotly Express: 地图数据可视化的魅力
最新发布
William数据分析的博客
09-17 476
在数据分析和可视化的世界中，地图数据可视化是一个强大而直观的工具，它可以帮助我们更好地理解和解释地理数据。Python 的 Plotly Express 库提供了一个简单而强大的方式来创建各种地图。本文将通过一个简单的示例，展示如何使用 Plotly Express 来创建一个交互式的地图，并探讨其在地图数据可视化方面的应用。
JUC从实战到源码：中断机制与API实现
qq_43843951的博客
09-12 1168
在Java中，线程中断是一种机制，用于通知线程应该停止当前正在执行的任务。中断通常用于协同线程之间的合作，以便让线程在适当的时候终止其工作，尤其是在长时间运行的任务或阻塞操作中。通过学了多线程以及synchronized的相关知识，接下来就到了学习线程中断知识。
opencv学习：calcHist 函数绘制图像直方图及代码实现
mohanyelong的博客
09-13 1498
opencv学习：calcHist 函数绘制图像直方图及代码实现
面试真题 | web自动化关闭浏览器，quit()和close()的区别
NHB234567的博客
09-13 402
关闭所有的浏览器窗口，销毁driver操作，则需要使用的是quit方法；当打开了多个窗口，只想要关闭非最后一个窗口的时候，使用的是close方法。这些资料，对于【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴上万个测试工程师们走过最艰难的路程，希望也能帮助到你！close():只关闭当前的浏览器标签页，如果当前浏览器标签页剩下最后一个，则所有标签页面退出。是否编写过对应浏览器退出的测试用例。quit():所有的浏览器窗口退出。关闭当前的标签页，其他窗口不退出。退出当前所有的窗口；
Python——俄罗斯方块
2302_81225694的博客
09-14 1491
这段代码使用了Pygame库来实现游戏的图形界面，通过键盘控制方块的移动和旋转。游戏循环不断更新方块的位置和网格状态，并绘制在屏幕上。在方块达到底部或无法继续移动时，判断是否有满行，并清除满行的方块。游戏会根据方块的状态和移动情况不断更新，直到无法继续下落为止，游戏结束。俄罗斯方块游戏是一款经典的益智游戏，通常使用编程语言Python来实现。请注意，这只是一个简单的示例，可能还有一些功能和优化方面的改进。您可以根据自己的需求进行修改和扩展。
文档内容识别系统源码分享
xuehaishijue的博客
09-17 1413
数据集信息展示在当今信息爆炸的时代，文档内容识别系统的有效性和准确性愈发重要。为了提升YOLOv8在文档内容识别任务中的表现，我们采用了名为“FULL 2”的数据集进行训练和评估。该数据集专为文档图像的多样性和复杂性而设计，涵盖了多种类别的文本元素，使其成为优化深度学习模型的理想选择。
Django-Celery-Flower实现异步和定时爬虫及其监控邮件告警
weixin_50556117的博客
09-11 1148
【代码】Django-Celery-Flower实现异步和定时爬虫及其监控邮件告警。
【Go】-Context库的使用
knoci的博客
09-13 853
当截止日过期时，当调用返回的cancel函数时，或者当父上下文的Done通道关闭时，返回上下文的Done通道将被关闭，以最先发生的情况为准。取消此上下文将释放与其相关的资源，因此代码应该在此上下文中运行的操作完成后立即调用cancel，通常用于数据库或者网络连接的超时控制。用来处理一个请求的 goroutine 通常需要访问一些与请求特定的数据，比如终端用户的身份认证信息、验证相关的token、请求的截止时间。取消此上下文将释放与其关联的资源，因此代码应该在此上下文中运行的操作完成后立即调用cancel。
基于python+django+vue的旅游网站系统
计算机学姐的博客
09-17 1693
【2025最新】基于协同过滤+python+django+vue+MySQL的旅游网站系统，前后端分离。
python tkinter
Waller_的博客
09-16 558
GUI编程就是编写一个个组件，界面由组件组成，组件内又可以创建组件，这种组件即为容器。基于tkinter创建 GUI基本四步：窗口->组件->布局->事件。通过与组件绑定，获取组件所触发的事件。管理组件的大小位置样式。
nvdia和cuda的区别与联系
weixin_42795092的博客
09-12 308
NVIDIA的GPU设计用于处理图形渲染等任务，但随着技术的发展，GPU的计算能力不再局限于图形处理，而是扩展到更广泛的领域，如科学计算、深度学习、数据挖掘等。）是由NVIDIA推出的一种并行计算架构和编程模型。简单来说，NVIDIA是硬件制造商，而CUDA是NVIDIA提供的一种软件架构和工具，用于充分发挥其GPU的计算潜力。NVIDIA通过其GPU硬件提供了强大的计算能力，而CUDA作为一种并行计算架构和编程模型，使得开发者能够更加高效地利用这些计算能力，加速各种计算密集型任务的处理速度。
旋转链表问题（python3）
weixin_51924589的博客
09-16 373
直接考虑链表的分离与合并，从给定的移动位置出发，找出分割结点的位置，断开链表，最后将分割出来的另一个链表的尾结点连接到原链表的头结点，完成链表的旋转。给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。输入：head = [1,2,3,4,5], k = 2。输出：[4,5,1,2,3]
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值