2019年Python入门到精通_个人代码及笔记_03

最新推荐文章于 2024-04-23 21:08:23 发布

丶小早

最新推荐文章于 2024-04-23 21:08:23 发布

阅读量216

点赞数

分类专栏：笔记文章标签： python

本文链接：https://blog.csdn.net/weixin_45553439/article/details/104883681

版权

笔记专栏收录该内容

95 篇文章 3 订阅

订阅专栏

面向对象
继承
多态
异常
模块与包
面向对象应用

1. 面向对象

#封装：将属性和方法写到类达里面的操作 / 可以为属性和方法添加私有属性
#1)类和对象：用类去创建一个对象/用类实例化对象
print('类和对象：')
#1.定义类
class Washer():
    def wash(self):
        #self指的是调用该函数的对象
        print('能洗衣服')
        print(self) #<__main__.Washer object at 内存地址>

    def print_info(self):
        '''self.属性名'''
        #3.2)在类的内部添加对象属性/实例属性
        print(f'类的内部：洗衣机的宽度是：{self.width}，洗衣机的高度是：{self.height}')

#2.创建对象
haier1 = Washer()
print(haier1) #<__main__.Washer object at 内存地址>同self
#3.使用对象
haier1.wash() #实例方法/对象方法

#2)用一个类去创建多个对象
haier2 = Washer()
print(haier2) #用一个类创建多个对象时，self地址不相同
haier2.wash()

#3.1)在类的外部添加对象属性
haier1.width = 400
haier1.height = 500
print(f'类的外部：洗衣机的宽度是：{haier1.width}，洗衣机的高度是：{haier1.height}')
#3.2)在类的内部添加对象属性
haier1.print_info() #__main__已经添加实例属性

#4)魔法方法
print('\n魔法方法：')
#1.__init__() #初始化对象
print('1.__init__()：',end='')
class Firer():
    def __init__(self):
        #添加实例属性
        self.width = 300
        self.height = 200
    
    def print_info1(self):
        #类里面调用实例属性
        print(f'微波炉机的宽度是：{self.width}，微波炉的高度是：{self.height}')

xiaomi1 = Firer()
xiaomi1.print_info1()

#2.带参数的__init__()
print('2.带参数的__init__()：',end='')
class Firer2():
    def __init__(self,width,height):
        self.width = width
        self.height = height

    def print_info2(self):
        print(f'微波炉机的宽度是：{self.width}，微波炉的高度是：{self.height}')

xiaomi2 = Firer2(20,30)
xiaomi2.print_info2()

#3.__str__() #解释说明
print('3.__str__()：',end='')
class Firer3():
    def __init__(self):
        self.width = 300

    def __str__(self):
        return '解释说明：类的说明或对象状态的说明'

xiaomi3 = Firer3()
print(xiaomi3) #默认打印对象的内存地址，如果类定义了__str__方法，则打印该方法的return数据

#4.__del__() #删除对象时调用
print('4.__del__()：',end='')
class Firer4():
    def __init__(self):
        self.width = 300

    def __del__(self):
        print('对象已经删除')

xiaomi4 = Firer4()
del xiaomi4

#5)综合应用
#1.烤地瓜
print('\n烤地瓜：')
class SweetPotato():
    def __init__(self):
        #被烤的时间
        self.cook_time = 0
        #烤的状态
        self.cook_state = '生的'
        #调料列表
        self.condiments = []

    def cook(self,time):
        """烤地瓜的方法"""
        self.cook_time += time #烤地瓜整体烤过的时间
        if (0 <= self.cook_time < 3):
            self.cook_state = '生的'
        if (3 <= self.cook_time < 5):
            self.cook_state = '半生不熟'
        if (5 <= self.cook_time < 8):
            self.cook_state = '熟了'
        elif(self.cook_time >= 8):
            self.cook_state = '糊了'

    def add_condiments(self,condiment):
        """添加的调料"""
        self.condiments.append(condiment)

    def __str__(self):
        """输出对象状态"""
        return (f'这个地瓜被烤的时间是：{self.cook_time}，状态是：{self.cook_state}，调料有{self.condiments}')

potato1 = SweetPotato()
print(potato1) #__init__()：cook_time = 0
potato1.cook(2) #cook_time = 2
potato1.add_condiments('胡椒') #condiments['胡椒']
print(potato1) 
potato1.cook(2) #cook_time = 4
potato1.add_condiments('花生油') #condiments['胡椒','花生油']
print(potato1) 

#2.搬家具
print('\n搬家具：')
class Furniture():
    def __init__(self,name,area):
        #家具名字
        self.name = name
        #家具占地面积
        self.area = area

class House():
    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,furniture): #item是Furniture类的对象
        """容纳家具"""
         #如果家具占地面积 <= 房屋剩余面积： 可以搬入
        if (furniture.area <= self.free_area):
            self.furniture.append(furniture.name) #添加家具
            self.free_area -= furniture.area #房屋剩余面积 = 房屋面积 - 家具面积
        else:
            print(f'{furniture.name}占地面积太大，房屋无法容纳')


#家具
bed = Furniture('双人床',6)
sofa = Furniture('沙发',10)
piano = Furniture('钢琴',100)

#房子
house = House('深圳',100)
print(house)

#添加家具
house.add_furniture(bed)
print(house)
house.add_furniture(sofa)
print(house)
house.add_furniture(piano)
print(house)

#扩展：__dict__
print('\n扩展：__dict__')
#1.定义类
class A(object):
    a = 0

    def __init__(self):
        self.b = 1
#2.创建对象
aa = A()
#3.调用__dict__
print('1.类：')
print(A.__dict__) #返回类内部所有属性和方法对应的字典
print('2.实例：') 
print(aa.__dict__) #返回实例属性和值组成的字典

输出结果：
在这里插入图片描述

2. 继承

#继承：子类默认继承父类的所有属性和方法 / 子类可以重写父类属性和方法
#经典类：class 类名 / 新式类：class 类名(object)
#父类A
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，说明B继承了A

#1)单继承
print('1)单继承：')
#师父类
class Master1(object):
    def __init__(self):
        self.kungfu = '[咏春]'

    def fight(self):
        print(f'在下{self.kungfu}，请赐教')

#徒弟类
class Student1(Master1):
    pass

Bruce = Student1()
print(Bruce.kungfu) #[咏春]
Bruce.fight() #在下[咏春]，请赐教

#2)多继承
print('\n2)多继承：')
#师父类
class Master2(object):
    def __init__(self):
        self.kungfu = '[咏春]'

    def fight(self):
        print(f'在下{self.kungfu}，请赐教')

#学校类
class School2(object):
    def __init__(self):
        self.kungfu = '[扫地]'

    def fight(self):
        print(f'在下{self.kungfu}，请赐教')

#徒弟类
class Student2(School2,Master2):
    pass

Lee = Student2()
print(Lee.kungfu) #一个类继承多个父类时，默认使用第一个父类的同名属性和方法
Lee.fight()

#3)子类重写父类同名方法和属性
print('\n3)子类重写父类同名方法和属性：')
#师父类
class Master3(object):
    def __init__(self):
        self.kungfu = '[咏春]'

    def fight(self):
        print(f'在下{self.kungfu}，请赐教')

#学校类
class School3(object):
    def __init__(self):
        self.kungfu = '[扫地]'

    def fight(self):
        print(f'在下{self.kungfu}，请赐教')

#徒弟类
class Student3(School3,Master3):
    def __init__(self):
        self.kungfu = '[自学]'

    def fight(self):
        print(f'在下{self.kungfu}，请赐教')

Bruce_Lee = Student3()
print(Bruce_Lee.kungfu) #子类重写父类同名方法和属性，优先调用子类的同名方法和属性
Bruce_Lee.fight()

#4)mro顺序
print('\n4)mro顺序：') #查看继承关系、顺序
print(Student3.__mro__) #(<class '__main__.Student3'>, <class '__main__.School3'>, <class '__main__.Master3'>, <class 'object'>)

#5)子类调用父类的同名方法和属性
print('\n5)子类调用父类的同名方法和属性：') 
#师父类
class Master5(object):
    def __init__(self):
        self.kungfu = '[咏春]'

    def fight(self):
        print(f'在下{self.kungfu}，请赐教')

#学校类
class School5(object):
    def __init__(self):
        self.kungfu = '[扫地]'

    def fight(self):
        print(f'在下{self.kungfu}，请赐教')

#徒弟类
class Student5(School5,Master5):
    def __init__(self):
        self.kungfu = '[自学]'

    def fight(self):
        #如果先调用了父类的属性和方法，父类属性会覆盖子类属性，所以在调用属性前，先调用自己子类的初始化
        self.__init__() 
        print(f'在下{self.kungfu}，请赐教')

    def master_fight(self):
        #调用父类方法，为了保证调用到的是父类的属性，必须在调用方法前调用父类的初始化
        Master5.__init__(self)
        Master5.fight(self)

    def school_fight(self):
        School5.__init__(self)
        School5.fight(self)

Lee_Bruce = Student5()
Lee_Bruce.fight() #自学
Lee_Bruce.school_fight() #调用School的同名方法和属性
Lee_Bruce.master_fight() #调用Master的同名方法和属性
Lee_Bruce.fight() #自学，120行的作用

#6)多层继承
print('\n6)多层继承：') 
#徒孙类
class LittleStudent6(Student5):
    pass

Ye = LittleStudent6()
Ye.fight()
Ye.master_fight()

#7)super()调用父类方法
print('\n7)super()调用父类方法：') 
#徒弟类
class Student7(School5,Master5):
    def __init__(self):
        self.kungfu = '[自学]'

    def fight(self):
        self.__init__() 
        print(f'在下{self.kungfu}，请赐教')

    def master_fight(self):
        Master5.__init__(self)
        Master5.fight(self)

    def school_fight(self):
        School5.__init__(self)
        School5.fight(self)

    #一次性调用父类School5和Master5的方法
    #方法1：代码量大，冗余
    def complex_fight1(self):
        School5.__init__(self)
        School5.fight(self)
        Master5.__init__(self)
        Master5.fight(self)

    #方法2：super(当前类名,self).函数()
    def complex_fight2(self):
        super(Student7,self).__init__() #调用父类方法，优先调用第一个父类的方法
        super(Student7,self).fight()
    
    #方法3：无参数super().函数()
    def complex_fight3(self):
        super().__init__() #调用父类方法，优先调用第一个父类的方法
        super().fight()

Wen = Student7()
print('方法1：')
Wen.complex_fight1()
print('方法2：')
Wen.complex_fight2()
print('方法3：')
Wen.complex_fight3()

#8)私有权限
print('\n8)私有权限：')  #__前缀
#徒弟类
class Student8(School5,Master5):
    def __init__(self):
        self.kungfu = '[自学]'
        self.__money = 88888888 #私有属性

    def __info_print(self): #私有方法
        print('这是独门秘籍')

    def fight(self):
        self.__init__() 
        print(f'在下{self.kungfu}，请赐教')
    
    def master_fight(self):
        Master5.__init__(self)
        Master5.fight(self)

    def school_fight(self):
        School5.__init__(self)
        School5.fight(self)

#徒孙类
class Little_Student8(Student8):
    pass

Lee_Dragon = Student8()
Dragon_Lee = Little_Student8()
#print(Lee_Dragon.__money)
#print(Dragon_Lee.__money)
print('私有属性和私有方法只能在自己的类内部使用')

#9)获取和修改私有属性值
print('\n9)获取和修改私有属性值：')
#徒弟类
class Student9(School5,Master5):
    def __init__(self):
        self.kungfu = '[自学]'
        self.__money = 88888888 #私有属性

    #获取私有属性
    def get_money(self):
        return self.__money

    #修改私有属性
    def set_money(self):
        self.__money = 666666

    def __info_print(self): #私有方法
        print('这是独门秘籍')

    def fight(self):
        self.__init__() 
        print(f'在下{self.kungfu}，请赐教')
    
    def master_fight(self):
        Master5.__init__(self)
        Master5.fight(self)

    def school_fight(self):
        School5.__init__(self)
        School5.fight(self)

#徒孙类
class Little_Student9(Student9):
    pass

Little_Dragon = Little_Student9()
print(Little_Dragon.get_money()) #88888888
Little_Dragon.set_money() #__money -> 666666
print(Little_Dragon.get_money()) #666666

输出结果：
在这里插入图片描述

3. 多态

#继承：子类默认继承父类的所有属性和方法 / 子类可以重写父类属性和方法
#经典类：class 类名 / 新式类：class 类名(object)
#父类A
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，说明B继承了A

#1)单继承
print('1)单继承：')
#师父类
class Master1(object):
    def __init__(self):
        self.kungfu = '[咏春]'

    def fight(self):
        print(f'在下{self.kungfu}，请赐教')

#徒弟类
class Student1(Master1):
    pass

Bruce = Student1()
print(Bruce.kungfu) #[咏春]
Bruce.fight() #在下[咏春]，请赐教

#2)多继承
print('\n2)多继承：')
#师父类
class Master2(object):
    def __init__(self):
        self.kungfu = '[咏春]'

    def fight(self):
        print(f'在下{self.kungfu}，请赐教')

#学校类
class School2(object):
    def __init__(self):
        self.kungfu = '[扫地]'

    def fight(self):
        print(f'在下{self.kungfu}，请赐教')

#徒弟类
class Student2(School2,Master2):
    pass

Lee = Student2()
print(Lee.kungfu) #一个类继承多个父类时，默认使用第一个父类的同名属性和方法
Lee.fight()

#3)子类重写父类同名方法和属性
print('\n3)子类重写父类同名方法和属性：')
#师父类
class Master3(object):
    def __init__(self):
        self.kungfu = '[咏春]'

    def fight(self):
        print(f'在下{self.kungfu}，请赐教')

#学校类
class School3(object):
    def __init__(self):
        self.kungfu = '[扫地]'

    def fight(self):
        print(f'在下{self.kungfu}，请赐教')

#徒弟类
class Student3(School3,Master3):
    def __init__(self):
        self.kungfu = '[自学]'

    def fight(self):
        print(f'在下{self.kungfu}，请赐教')

Bruce_Lee = Student3()
print(Bruce_Lee.kungfu) #子类重写父类同名方法和属性，优先调用子类的同名方法和属性
Bruce_Lee.fight()

#4)mro顺序
print('\n4)mro顺序：') #查看继承关系、顺序
print(Student3.__mro__) #(<class '__main__.Student3'>, <class '__main__.School3'>, <class '__main__.Master3'>, <class 'object'>)

#5)子类调用父类的同名方法和属性
print('\n5)子类调用父类的同名方法和属性：') 
#师父类
class Master5(object):
    def __init__(self):
        self.kungfu = '[咏春]'

    def fight(self):
        print(f'在下{self.kungfu}，请赐教')

#学校类
class School5(object):
    def __init__(self):
        self.kungfu = '[扫地]'

    def fight(self):
        print(f'在下{self.kungfu}，请赐教')

#徒弟类
class Student5(School5,Master5):
    def __init__(self):
        self.kungfu = '[自学]'

    def fight(self):
        #如果先调用了父类的属性和方法，父类属性会覆盖子类属性，所以在调用属性前，先调用自己子类的初始化
        self.__init__() 
        print(f'在下{self.kungfu}，请赐教')

    def master_fight(self):
        #调用父类方法，为了保证调用到的是父类的属性，必须在调用方法前调用父类的初始化
        Master5.__init__(self)
        Master5.fight(self)

    def school_fight(self):
        School5.__init__(self)
        School5.fight(self)

Lee_Bruce = Student5()
Lee_Bruce.fight() #自学
Lee_Bruce.school_fight() #调用School的同名方法和属性
Lee_Bruce.master_fight() #调用Master的同名方法和属性
Lee_Bruce.fight() #自学，120行的作用

#6)多层继承
print('\n6)多层继承：') 
#徒孙类
class LittleStudent6(Student5):
    pass

Ye = LittleStudent6()
Ye.fight()
Ye.master_fight()

#7)super()调用父类方法
print('\n7)super()调用父类方法：') 
#徒弟类
class Student7(School5,Master5):
    def __init__(self):
        self.kungfu = '[自学]'

    def fight(self):
        self.__init__() 
        print(f'在下{self.kungfu}，请赐教')

    def master_fight(self):
        Master5.__init__(self)
        Master5.fight(self)

    def school_fight(self):
        School5.__init__(self)
        School5.fight(self)

    #一次性调用父类School5和Master5的方法
    #方法1：代码量大，冗余
    def complex_fight1(self):
        School5.__init__(self)
        School5.fight(self)
        Master5.__init__(self)
        Master5.fight(self)

    #方法2：super(当前类名,self).函数()
    def complex_fight2(self):
        super(Student7,self).__init__() #调用父类方法，优先调用第一个父类的方法
        super(Student7,self).fight()
    
    #方法3：无参数super().函数()
    def complex_fight3(self):
        super().__init__() #调用父类方法，优先调用第一个父类的方法
        super().fight()

Wen = Student7()
print('方法1：')
Wen.complex_fight1()
print('方法2：')
Wen.complex_fight2()
print('方法3：')
Wen.complex_fight3()

#8)私有权限
print('\n8)私有权限：')  #__前缀
#徒弟类
class Student8(School5,Master5):
    def __init__(self):
        self.kungfu = '[自学]'
        self.__money = 88888888 #私有属性

    def __info_print(self): #私有方法
        print('这是独门秘籍')

    def fight(self):
        self.__init__() 
        print(f'在下{self.kungfu}，请赐教')
    
    def master_fight(self):
        Master5.__init__(self)
        Master5.fight(self)

    def school_fight(self):
        School5.__init__(self)
        School5.fight(self)

#徒孙类
class Little_Student8(Student8):
    pass

Lee_Dragon = Student8()
Dragon_Lee = Little_Student8()
#print(Lee_Dragon.__money)
#print(Dragon_Lee.__money)
print('私有属性和私有方法只能在自己的类内部使用')

#9)获取和修改私有属性值
print('\n9)获取和修改私有属性值：')
#徒弟类
class Student9(School5,Master5):
    def __init__(self):
        self.kungfu = '[自学]'
        self.__money = 88888888 #私有属性

    #获取私有属性
    def get_money(self):
        return self.__money

    #修改私有属性
    def set_money(self):
        self.__money = 666666

    def __info_print(self): #私有方法
        print('这是独门秘籍')

    def fight(self):
        self.__init__() 
        print(f'在下{self.kungfu}，请赐教')
    
    def master_fight(self):
        Master5.__init__(self)
        Master5.fight(self)

    def school_fight(self):
        School5.__init__(self)
        School5.fight(self)

#徒孙类
class Little_Student9(Student9):
    pass

Little_Dragon = Little_Student9()
print(Little_Dragon.get_money()) #88888888
Little_Dragon.set_money() #__money -> 666666
print(Little_Dragon.get_money()) #666666

输出结果：
在这里插入图片描述

4. 异常

import time

#1)捕获异常
print('1)捕获异常：')
#1.1捕获指定异常类型
print('1.1捕获指定异常类型：',end='')
try:
    print(num)      #可能发生错误的代码
except NameError:   #异常类型
    print('有错误') #如果捕获到该异常类型执行的代码
#1.2捕获多个指定异常类型
print('1.2捕获多个指定异常类型：',end='')
try:
    print(1/0)
except (NameError,ZeroDivisionError): #元组
    print('有错误')

#2.1捕获异常描述信息
print('2.1捕获异常描述信息：',end='')
try:
    print(1/0)
except (NameError,ZeroDivisionError) as result:
    print(result)
#2.2捕获所有异常
print('2.2捕获所有异常：',end='')
try:
    print(num)
except Exception as result: #Exceptio是所有程序异常类的父类
    print(result)

#2)异常的else
print('\n2)异常的else：')
try:
    print(1)
except Exception as result:
    print(result)
else: #如果没有异常要执行的代码
    print('我是else，当没有异常的时候执行的代码')

#3)异常finally
print('\n3)异常finally：')
try:
    print(num) #可能发生错误的代码
except Exception as error:
    print(f'try程序错误，错误信息是：{error}')
else:
    print('try程序没有错误')
finally:
    print('try程序有错没错我都要执行')

#4)异常的传递
print('\n4)异常的传递：')
try:
    f = open('python.txt')
    try:
        while True:
            content = f.readline() #逐行读'python.py'文件
            if (len(content) == 0):
                break
            time.sleep(1) #间隔1秒钟
            print(content)
    except:
        #如果在读取文件的过程中，产生了异常，那么就会捕获到
        #比如按下了 Ctrl + C
        print('意外地终止了读取数据')
    finally:
        f.close()
        print('关闭文件')
except:
    print('没有这个文件')

#5)自定义异常
print('\n5)自定义异常：') #raise 异常类对象
#自定义异常类，继承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}个字符') #result

def main():
    try:
        content = input('请输入密码，长度不小于3：')
        if len(content) < 3: #如果密码长度小于3
            raise ShortInputError(len(content),3)
    except Exception as result:
        print(f'错误信息是：{result}') #__str__
    else:
        print('密码输入完成')

main()

输出结果：
在这里插入图片描述

5. 模块与包

#模块Module是一个Python文件，以.py结尾，包含了Python对象定义和Python语句
#1)导入模块
print('1)导入模块：')
#1.import 模块名
print('1.方法①：',end ='')
import math 
print(math.sqrt(9)) #开方3.0

#2.from 模块名 import 功能1,功能2,功能3...
print('2.方法②：',end ='')
from math import ceil
print(ceil(2.4)) #向上取整3

#3.from 模块名 import *
print('3.方法③：',end ='')
from math import *
print(floor(2.6)) #向下取整2

#4.import 模块名 as 别名
print('4.模块别名：',end ='')
import time as tt
tt.sleep(2) #等待2秒钟
print('hello wor1d')
#print(time.sleep(2)) #模块名time失效
#print('hello wor2d')

#5.from 模块名 import 功能名 as 别名
print('5.功能别名：',end ='')
from random import randint as other
print(other(0,2))
#print(randint(0,2)) #功能名randint失效

#2)制作模块
print('\n2)制作模块：')
import python23_mymodule1 #导入自定义模块
python23_mymodule1.add_num(2,2) #4
#模块定位顺序：
#自己的文件名不要和已有的模块名重复，否则导致模块功能无法使用
#使用'from 模块名 import 功能'时，如果功能名重复，调用到的是 最后定义或导入的功能

#3)__all__
print('\n3)__all__：')
#如果一个模块文件 有__all__变量，当使用'from xxx import *'导入时，只能导入这个列表中的元素
from python23_mymodule2 import *
testA() #在__all__列表，正常使用
#testB() #不在__all__列表，无法使用

#4)包的使用方法
print('\n4)包的使用方法：') #有联系的模块(文件夹)
#[New]-[Python Package]-输入包名-[OK]-新建功能模块(有联系的模块)
#新建包后，包内部会自动创建__init__.py文件，这个文件控制着包的导入行为
print('1.方法①：')
import python23_mypackage.my_module1
python23_mypackage.my_module1.info_print1() #'my_module1'
print('2.方法②：')
#必须在'__init__.py'文件中添加'__all__ = []'，控制允许导入的模块列表
from python23_mypackage import *
my_module1.info_print1() #'my_module1'，正常使用
#my_module2.info_print2() #不在'__init__.py'文件中__all__列表里，无法使用

python23_mymodule1.py文件：

#2)制作模块
#定义功能
def add_num(a,b):
    print(a+b)

#测试功能
#__name__是系统变量，是模块的标识符：
#本py模块文件运行时，__name__ == __main__
#在其他py文件运行时，__name__ == '本py模块文件名' 
if (__name__ == '__main__'): #在本py模块文件运行下才执行
    add_num(1,1)

python23_mymodule2.py文件：

#3)__all__
__all__ = ['testA']

def testA():
    print('testA')

def testB():
    print('testB')

python23_mypackage包：

init.py文件

__all__ = ['my_module1']

my_module1.py文件：

print(1)

def info_print1():
    print('my_module1')

my_module2.py文件：

print(2)

def info_print2():
    print('my_module2')

输出结果：
在这里插入图片描述

6. 面向对象应用

main.py文件：

#导入StudentSystem模块
from StudentSystem import *
#启动学生管理系统
if __name__ == '__main__':
    os.chdir('python24_面向对象应用') #改变目录路径：'python24_面向对象应用'文件夹
    teacher = StudentSystem()
    teacher.run()

Student.py文件：

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

    def __str__(self): #查看学生信息
        return (f'姓名是：{self.name}，性别是：{self.sex}，手机号码是：{self.tel}')

#测试
if (__name__ == '__main__'):
    aa = Student('Tom','male','12345678900')
    print(aa)

StudentSystem.py文件

import os
from Student import *

#1.存储数据的文件(student.data) #加载文件数据 / #修改数据后保存到文件
#2.存储数据的形式：列表存储学员对象
#3.系统功能：#添加学生 #删除学生 #修改学生 #查询学生信息 #显示所有学生信息 #保存学生信息 #退出系统
class StudentSystem(object):
    def __init__(self):
        #存储数据所用的列表
        self.student_list = []

    #程序入口函数，启动程序后执行的函数
    def run(self):
        #1.加载学生信息
        self.load_student() #加载'student.txt'文件

        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

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

    #2.添加学生 
    def add_student(self):
        print('添加学生：')
        name = input('请输入姓名：')
        sex = input('请输入性别：')
        tel = input('请输入手机号：')

        student = Student(name,sex,tel)

        self.student_list.append(student)
        #print(f'所有学生信息：{self.student_list}')
        print(f'添加的学生信息是：{student}')

    #3.删除学生 
    def del_student(self):
        print('删除学生：')
        del_name = input('请输入要删除的学生姓名：')

        for i in self.student_list:
            if (i.name == del_name):
                self.student_list.remove(i)
                print(f'删除成功，删除的学生{i}')
                break
        else:
            print('该学生不存在！')
        #print(f'所有学生信息：{self.student_list}')

    #4.修改学生
    def modify_student(self):
        print('修改学生信息：')
        modify_name = input('请输入你要修改学生信息的姓名：')

        for i in self.student_list:
            if (i.name == modify_name):
                i.sex = input('输入新的性别：')
                i.tel = input('输入新的手机号：')
                print(f'修改学生信息成功，姓名是：{i.name}，性别是：{i.sex}，手机号码是：{i.tel}')
                break
        else:
            print('该学生不存在！')
        #print(f'所有学生信息：{self.student_list}')

    #5.查询学生信息
    def search_student(self):
        print('查询学生信息：')
        search_name = input('请输入要查询的学生姓名：')
        for i in self.student_list:
            if (i.name == search_name):
                print(f'学生{i}')
                break
        else:
            print('查无此人！')

    #6.显示所有学生信息 
    def show_student(self):
        print('显示所有学生信息：')
        print('姓名\t性别\t手机号码')
        for i in self.student_list:
            print(f'{i.name}\t{i.sex}\t{i.tel}')

    #7.保存学生信息 
    def save_student(self):
        print('保存学生信息：')
        #7.1打开文件
        f = open('student.txt','w')
        #7.2文件写入学生信息
        #7.21[学生对象]转换成[字典]
        new_list = [i.__dict__ for i in self.student_list] #推导式
        #7.22文件写入 字符串数据
        f.write(str(new_list))
        #7.3关闭文件
        f.close()
        print('保存成功！')

    #8.加载学生信息
    def load_student(self):
        print('加载学生信息：')
        try:
            f = open('student.txt','r')
        except:
            f = open('student.txt','w')
        else:
            #1.读取数据
            data = f.read() #字符串(字典)
            #2.文件中读取的数据是字符串，而且字符串内部为字典数据，所以需要转换数据类型
            new_list = eval(data) #字符串(字典) 转换为 列表(字典)
            #转换字典为对象后存储到学生列表
            self.student_list = [Student(i['name'],i['sex'],i['tel']) for i in new_list] #推导式
        finally:
            #3.关闭文件
            f.close()

输出结果：
在这里插入图片描述

目录下出现新的student.txt文件：

丶小早

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2019年Python入门到精通_个人代码及笔记_03

目录：面向对象继承多态异常模块与包面向对象应用1. 面向对象#封装：将属性和方法写到类达里面的操作 / 可以为属性和方法添加私有属性#1)类和对象：用类去创建一个对象/用类实例化对象print('类和对象：')#1.定义类class Washer(): def wash(self): #self指的是调用该函数的对象 print(...
复制链接

扫一扫