Python 基础入门学习
五.面向对象
- 类是对一系列具有相同特征和行为的事物的统称，是一个抽象的概念，不是真实存在的事物。对象是由类创建出来的真实存在的事物。
#创建类
class 类名(): #类名要满足标识符命名规则，同时遵循大驼峰命名习惯
代码
......
def 函数名(self): #self指调用该函数的对象
代码
#创建对象
对象名 = 类名()- 类外面添加对象属性：
对象名.属性名 = 值类外面获取对象属性：
对象名.属性名类里面获取对象属性：
self.属性名综合实例：
class Washer():
def wash(self):
print('wash the clothes!')
def get_size(self):
print(f'此洗衣机的尺寸是{self.width} X {self.height}')
haier1 = Washer()
haier1.width = 500
haier1.height = 300
haier2 = Washer()
haier2.width = 600
haier2.height = 400
print(haier1.width)
haier1.get_size()
haier2.get_size()- 魔法方法： __init__() 、 __str__()、__del__()。
#1. __init__() 初始化对象。
#创建对象时默认被调用；不需开发者传递self参数，python解释器会自动把当前对象引用传递过去。
class washer():
def __init__(self,width,height):
self.width = width
self.height = height
def print_info(self):
print(f'{self.width} X {self.height}')
h = washer(500,800)
h.print_info()
#输出结果 500 X 800
#2. __str__() 使得用print输出对象时，输出该方法中return的数据,而不再输出对象的内存地址。
def __str__(self):
return "这是洗衣机对象！"
print(h)
#输出结果 这是洗衣机对象！
#3. __del__() 当删除对象时，python解释器会默认调用__del__()方法
def __del__(self):
print(f'{self}对象已经被删除！')
del h
#输出结果 <__main__.washer object at 0x000002531DF744F0>对象已经被删除！- 两个案例：
烤地瓜
#需求：1.被烤时间和地瓜状态相对应 2.用户可按意愿添加调料
class SweetPotato():
def __init__(self):
self.cook_time=0
self.cook_state='生的'
self.condiments=[]
def cook(self, time):
if time >=0:
self.cook_time += time
if 0<= self.cook_time < 3:
self.cook_state = '生的'
elif 3 <= self.cook_time < 5:
self.cook_state = '半生不熟'
elif 5 <= self.cook_time < 8:
self.cook_state = '熟了'
elif self.cook_time >= 8:
self.cook_state = '糊了!'
else:
print('时间刺客？！')
def add_condiment(self, con):
self.condiments.append(con)
def __str__(self):
return f'这个地瓜烤了{self.cook_time}分钟，状态是{self.cook_state}，添加的调料有{self.condiments}'
p = SweetPotato()
p.add_condiment('番茄酱')
print(p)
p.cook(8)
p.add_condiment('芥末')
print(p)
# 这个地瓜烤了0分钟，状态是生的，添加的调料有['番茄酱']
# 这个地瓜烤了8分钟，状态是糊了!，添加的调料有['番茄酱', '芥末']搬家具
#需求 将小于房子剩余面积的家具摆放到房子中
class Furniture():
def __init__(self,name,area):
self.name = name
self.area = area
class House():
def __init__(self,adress,area):
self.adress = adress
self.area = area
self.free_area = area
self.furniture = []
def add_furniture(self,item):
if self.free_area >= item.area:
self.furniture.append(item.name)
self.free_area -= item.area
else:
print('家具太大，剩余面积不足，无法容纳')
def __str__(self):
return f'这个房子的地址是{self.adress}，总面积是{self.area}，当前剩余面积是{self.free_area}，家具有{self.furniture}'
bed = Furniture('双人床',6)
sofa = Furniture('沙发',10)
court = Furniture('高尔夫球场',1000)
house = House('陆家嘴',200)
print(house)
house.add_furniture(bed)
house.add_furniture(sofa)
house.add_furniture(court)
print(house)
#这个房子的地址是陆家嘴，总面积是200，当前剩余面积是200，家具有[]
#家具太大，剩余面积不足，无法容纳
#这个房子的地址是陆家嘴，总面积是200，当前剩余面积是184，家具有['双人床', '沙发']- 继承： Python面向对象的继承指的是多个类之间的所属关系，即子类默认继承父类的所有属性和方法，具体如下：
#定义父类A
class A(object):
def __init__(self):
self.num = 1
def infor_print(self):
print(self.num)
#定义子类B，继承父类A
class B(A):
pass
#创建对象，验证对象继承
result = B()
result.info_print()在python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫派生类。
拓展：python2中的经典类 和 python3中的新式类
#经典类(不由任意内置类型派生出的类)
class 类名:
代码
......
#新式类
class 类名(object):
代码
......
#在今后的学习和运用中，统一使用新式类单继承：一个子类继承一个父类，这种单一的继承关系称为单继承。
多继承：一个子类同时继承多个父类。
class 子类(父类A,父类B,父类C)
#当两个父类中的属性和方法有同名时，优先继承第一个父类中的同名属性和方法，即继承A类。子类重写父类同名属性与方法：在子类中可以重写与父类中同名的属性和方法。子类创建的对象调用属性和方法时，会调用子类中重写的属性和方法。
拓展： **__mro__**顺序 方法查看类的继承层级顺序。
print(类名.__mro__)子类调用父类同名属性和方法：在子类中重写了父类中同名属性与方法的情况下，调用父类中的同名属性和方法。
class 子类B(父类A):
def 同名方法(self):
#如果之前调用了父类的属性和方法，则父类属性会覆盖子类属性，故在调用子类属性前，先调用子类自己的初始化
self.__init__(self)
代码
def 调用父类方法(self):
#调用父类方法，为保证调用到的属性也是父类的属性，必须在调用方法前调用父类的初始化
父类A.__init__(self)
父类A.同名方法(self)多层继承：一般指大于两层的继承关系。
class A(object):
...
class B(A):
...
class C(B): #多层继承
...super()调用父类方法：自动查找父类，直接调用父类的属性方法，调用顺序遵循__mro__类属性的顺序。
class A(object)
class B(A)
class C(B):
#方法一：原始方法
def useAB(self):
A.__init__(self)
A.同名方法(self)
B.__init__(self)
b.同名方法(self)
#方法二：super()方法
#方法2.1 super(当前类名,self).函数()
def useAB(self):
super(C,self).__init__()
super(C,self).同名方法()
#此时会调用父类B的方法;若想调用A类的方法，需要在B类的同名方法中添加同样的super方法代码来调用A类
#方法2.2 super().函数()
def useAB(self):
super().__init__(self)
super().同名方法()
#同样调用父类B的方法;无法直接调用父类的父类A的属性和方法- 私有权限
设置私有属性和方法：在属性名和方法名前面加上两个下划线。
私有属性和私有方法只能在类内访问和修改，即子类无法继承或直接访问父类的私有属性和方法。
class A(object):
def __init__(self):
self.name = 'A'
self.__money = 99999 #私有属性
def __CostMoney(self,money): #私有方法
self.__money -= money获取和修改私有属性值：可在类内定义公有函数来获取和修改 私有属性值，在类外调用该函数来实现获取和修改私有属性功能。
#一般在类内用函数名get_xx来获取私有属性，用set_xx来修改私有属性
class A(object):
def __init__(self):
self.__money = 99999
def get_money(self):
return self.__money
def set_money(self,new_money):
self.__money = new_money
class B(A):
pass
b = B()
b.get_money() #成功获取父类中的私有属性
b.set_money(0) #成功修改父类中的私有属性- 多态：一种使用对象的方式，子类重写父类方法，调用不同子类对象的相同父类方法，可以产生不同的执行结果。即传入不同的对象，产生不同的结果。
- 类属性和实例属性：类属性即类所拥有的属性，它为该类所有对象共有。类属性可以用 类对象 或 实例对象 访问。
类属性只能通过类对象修改。
#修改类属性
类名.属性 = 值- 类方法：需要用装饰器
@classmethod来标识其为类方法，类方法第一个参数必须是类对象，一般以cls作为第一个参数。
class A(object):
__num = 777
@classmethod
def get_num(cls):
return cls.__num
obj = A()
print(obj.get_num())- 静态方法：通过装饰器
@staticmethod进行修饰，静态方法即不需要传递类和对象的方法，有利于减少不必要的内存占用和性能消耗。
class A(object):
@staticmethod
def info_print():
print('这是A类')六.异常
- 异常的定义：解释器检测到错误时无法继续执行，并出现一些错误的提示，这就是所谓的异常。
异常的作用：使得解释器检测到错误时，转而执行另一句没错误的语句，使得程序不因一个错误而停止下来。 - 基本写法：
try:
可能发生错误的代码
except:
出现异常时执行的代码
else:
没有异常时执行的代码
finally:
无论是否异常都要执行的代码体验案例：
#需求：尝试以r模式打开文件，若文件不存在(发生错误)，则以w方式打开
try:
f = open('test.txt','r')
except:
f = open('test.txt','w')- 捕获指定异常：
try:
print(num)
except (NameError, ZeroDivisionError) as result:
print(result) #捕获的异常描述信息
num = 777
print(num)
#若尝试执行代码的异常类型和要捕获的异常类型不一致，则无法捕获异常
#一般try下方只放一行尝试执行的代码- 捕获所有异常：利用 Exception 类
#Exception是所有程序异常类的父类
try:
可能错误的代码
except Exception as result:
print(result)- 异常中的 else 和 finally:
try:
f = open('test.txt','r')
except Exception as result:
f = open('test.txt','w')
print(result)
else: # try 下方的代码无异常时执行的代码
print('代码没有异常和错误')
finally: #无论有无异常都要执行的代码，如关闭文件
f.close()- 异常的传递：
import time
try:
f = open('test.txt') #默认打开模式为只读
#尝试循环读取内容
try:
while True:
con = f.readline()
#无内容时退出循环
if len(con) == 0:
break
time.sleep(2)
print(con)
except:
#在命令提示符中按下 Ctrl+C 终止程序
print('程序被意外终止')
except:
print('文件不存在')- 自定义异常： 抛出自定义异常的语法为
raise 异常类对象
#自定义异常类，继承Exception
class ShortInputError(Exception):
def __init__(self,length,min_length):
self.length=length
self.min_length=min_length
#设置抛出异常的描述信息
def __str__(self):
return f'输入长度为{self.length},不能少于{self.min_length}个字符'
def main(): #封装代码
try:
con = input('请输入密码: ')
if len(con) < 6:
raise ShortInputError(len(con),6)
except Exception as result:
print(result)
else:
print('密码输入完成')
main()七.模块
- 了解模块：Python模块(Module)，是一个Python文件，包含了Python对象定义和语句。
- 导入和调用模块：
#导入及调用模块
#写法一
import 模块名 #导入模块中的所有代码
模块名.功能名()
#写法二
from 模块名 import 功能1,功能2... #单个调用某功能
功能名() #即不需要在功能前写 "模块名."
#写法三
from 模块名 import *
功能名()
#一般用第一种写法利用as定义别名：定义别名后，使用时要用定义的别名
#模块定义别名
import 模块名 as 别名
#功能定义别名
from 模块名 import 功能 as 别名- 制作模块：模块名字就是py文件的名字。自定义模块名必须要符合标识符命名规则。
#只会在当前文件中调用下列测试代码，其他导入的文件内不符合该条件，也就不会执行测试代码
# __name__ 是系统变量，是模块的标识符。如果在自身模块里，则其值为 '__main__';否则是所在模块的名字
if __name__ == '__main__':
测试模块功能代码- 模块定位顺序：当导入一个模块，Python解释器对模块位置的搜索顺序是：
当前目录 > 搜索在shell变量PYTHONPATH下的每个目录 > 操作系统的默认python路径
注意：
自己的文件名不要和已有模块名重复，否则模块功能无法使用。
使用from 模块名 import 功能时，若功能名字重复，则调用最后定义的或最后导入的功能。
当使用import 模块名的写法调用模块时，不需要担心功能名重复。 __all__列表：如果一个模块文件中有__all__变量列表，当使用from 模块名 import *导入该模块时，则只能导入__all__列表中的元素。- 包：包将有联系的模块组织在一起，放到同一个文件夹下，并且在这个文件夹内自动生成一个名字为
__init__.py的文件，这个文件控制着包的导入行为。
创建包：在Pycharm中 New -> Python Package -> 输入包名 - > [OK] 即可新建一个包。
导入包：
#方法一
import 包名.模块名
包名.模块名.功能
#方法二
#注意，必须在 __init__.py 文件中添加 __all__ = [] 来控制允许导入的模块列表
from 包名 import *
模块名.功能面向对象综合实例
#使用面向对象编程思想完成学员管理系统的开发
#为了方便维护代码，一般一个角色一个程序文件
#项目要有主程序入口，习惯为main.py
#系统要求：学员数据存储在文件中
#系统功能：添加学员、删除学员、修改学员信息、查询学员信息、显示所有学员信息、保存学员信息、退出系统等功能
#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}'
#mangerSystem.py
#存储数据的: student.data
#存储数据的形式: 列表存储学员对象
#系统功能: 添加、删除、修改、查询、显示、保存学员信息
#管理系统类
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_menu()
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.py模块
student = Student(name,gender,tel)
#3. 将对象添加到学员列表
self.student_list.append(student)
#2.3 删除学员
def del_student(self):
#1. 用户输入目标学员姓名
del_name = input('请输入要删除的学员姓名:')
#2. 如果用户输入的目标学员存在则删除，否则提示不存在
for i in self.student_list:
if i.name == del_name:
self.student_list.remove(i)
break
else:
print('查无此人!')
#2.4 修改学员信息
def modify_student(self):
#1. 用户输入目标学员姓名
modify_name = input('请输入要修改的学员姓名: ')
#2. 如果用户输入的目标学员存在，则修改信息，否则提示不存在
for i in self.student_list:
if i.name == modify_name:
i.name = input('请输入学员姓名: ')
i.gender = input('请输入学员性别: ')
i.tel = input('请输入学员手机号: ')
print('修改成功!')
break
else:
print('查无此人!')
#2.5 查询学员信息
def search_student(self):
#1. 用户输入目标学员姓名
search_name = input('请输入要查询的学员姓名: ')
#2. 若存在，打印学员信息，否则提示不存在
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('姓名\t性别\t手机号')
for i in self.student_list:
print(f'{i.name}\t{i.gender}\t{i.tel}')
#2.7 保存学员信息
def save_student(self):
# 拓展 __dict__方法，以字典方式返回类和对象内的属性
#1. 打开文件
f = open('student.data','w')
#2. 文件写入学员数据 - 先将学员对象数据转换成列表字典数据再做存储
new_list = [i.__dict__ for i in self.student_list]
# 文件内数据要求为字符串类型，故要先转换数据类型为字符串才能写入文件
f.write(str(new_list))
#3. 关闭文件
f.close()
#2.8 加载学员信息
def load_student(self):
#尝试以"r"模式打开数据文件，有异常则用"w"模式打开;存在则读取数据
try:
f = open('student.data','r')
except:
f = open('student.data','w')
else:
#1. 读取数据
data = f.read()
#2. 先将文件中的 字符串型字典数据 转换为 对象数据 后再存储到学员列表
new_list = eval（data)
self.student_list = [Student(i['name'],i['gender'],i['tel']) for i in new_list]
finally:
#3. 关闭文件
f.close()
#main.py
#导入模块
#from managerSystem import *
#启动管理系统
#if __name__ == '__main__':
student_manager = StudentManager()
student_manager.run()
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
