Python面向对象

1. 面向过程与面向对象简介

1.1. 面向过程

定义：分析出解决问题的步骤，然后逐步实现。

案例：

dict_bjlz = {
 "name": "八角笼中", "type": "剧情", "index": 690761
}
dict_fs = {
 "name": "封神第一部", "type": "奇幻", "index": 532622
}
print("%s电影类型是%s,指数%s." %(dict_bjlz["name"],dict_bjlz["type"],dict_bjlz["index"]))
print("%s电影类型是%s,指数%s." %(dict_fs["name"],dict_fs["type"],dict_fs["index"]))

优点：简单直观，适合顺序按步骤执行的任务
缺点：所有字典都要重复定义，数据与算法分离不易扩展

1.2.面向对象

定义：可以使用类将变量与函数组合成新的数据类型
案例：

class Movie:
	
	def __init__(self, name, type, index):
		self.name = name
		self.type = type
		self.index = index
		
	def display(self):
		print("%s电影的类型是%s,指数是%s." % (self.name, self.type, self.index))


bjlz = Movie("八角笼中","剧情",690761)
fs = Movie("封神第一部","奇幻",532622)
bjlz.display()
fs.display()

优点：将每个字典相同的键统一定义在类中，将数据与对应的操作组合在一起扩展性强
缺点：学习曲线陡峭

2. 类和对象

2.1.语法

2.1.1.定义类

代码：

class 类名:
	"""
		文档说明
	"""
	def __init__(self,参数):
		self.实例变量 = 参数

	def 实例方法(self,参数):
		pass

说明：

• 类名所有单词首字母大写.
• init 也叫构造函数，创建对象时被调用，也可以省略。
• self 变量绑定的是被创建的对象，名称可以随意。

2.1.2.实例化对象

代码：

对象名 = 类名(参数)

说明：

• 对象名存储的是实例化后的对象地址
• 类名后面的参数按照构造函数的形参传递

练习：创建疫情信息类，实例化两个对象并调用其函数。
数据：地区名称、新增人数、现有人数
行为：在终端中显示

class EpidemicInfo:
    """
    疫情信息类
    """
    def __init__(self, areaName, addNum, curNum):
        self.areaName = areaName
        self.addNum = addNum
        self.curNum = curNum
        
    def printInfo(self):
        print("%s地区疫情，当前人数%d，增长人数%d"%(self.areaName, self.curNum, self.addNum))


e1 = EpidemicInfo("北京", 10, 100)
e1.printInfo()
e2 = EpidemicInfo("南京", 5, 75)
e2.printInfo()

2.2.实例成员

2.2.1.实例变量

语法：
a. 定义：对象.变量名
b. 调用：对象.变量名
说明：
a. 首次通过对象赋值为创建，再次赋值为修改.

class Movie:

	pass

movie = Movie()
movie.name = "八角笼中"
movie.name = "封神第一部"

b. 通常在构造函数 ( init ) 中创建

class Movie:
	def __init__(self, name, type, index):
		self.name = name

movie = Movie("八角笼中")
print(movie.name)

每个对象存储一份，通过对象地址访问。
作用：描述某个对象的数据。
dict：对象的属性，用于存储自身实例变量的字典。

2.2.2.实例方法

定义

def 方法名称(self, 参数):
	方法体

调用：对象.方法名称(参数)
不建议通过类名访问实例方法

说明：

• 至少有一个形参，第一个参数绑定调用这个方法的对象,一般命名为self。
• 无论创建多少对象，方法只有一份，并且被所有对象共享。

作用：表示对象行为。

练习：
创建图书类，实例化两个对象并调用其函数
数据：书名、单价、出版社名称
行为：在终端中显示

class Book:
    """
    	图书类
    """
    def __init__(self, bookName, price, pressName):
        self.bookName = bookName
        self.price = price
        self.pressName = pressName
    
    def printInfo(self):
        print("《%s》%s出版，单价%d"%(self.bookName, self.pressName, self.price, ))


e1 = Book("笑傲江湖", 35, "北京出版社")
e1.printInfo()
e2 = Book("红楼梦", 26, "上海出版社")
e2.printInfo()

2.2.3.跨类调用

# 写法1：直接创建对象
# 语义：老张每次创建一辆新车去
class Person:

	def __init__(self, name=""):
		self.name = name

	def go_to(self,position):
		print("去",position)


car = Car()
car.run()

class Car:

	def run(self):
		print("跑喽～")


lz = Person("老张")
lz.go_to("东北")

# 写法2：在构造函数中创建对象
# 语义：老张开自己的车去
class Person:
	def __init__(self, name=""):
		self.name = name
		self.car = Car()

	def go_to(self, position):
		print("去",position)
		self.car.run()

class Car:
	def run(self):
		print("跑喽～")


lz = Person("老张")
lz.go_to("东北")

```python
# 方式3：通过参数传递
# 语义：老张用交通工具去
class Person:

	def __init__(self, name=""):
		self.name = name

	def go_to(self, vehicle, position):
		print("去",position)
		vehicle.run()

class Car:
	def run(self):
		print("跑喽～")


lz = Person("老张")
benz = Car()
lz.go_to(benz,"东北")

练习1：以面向对象思想,描述下列情景.：小明请保洁打扫卫生

class Person:

    def __init__(self, name):
        self.name = name

    def invite(self, cleaner):
        print(f"{self.name}邀请{cleaner.role}打扫卫生")

class CleanStaff:
    def __init__(self, role):
        self.role = role

    def sweep(self):
        print("保洁员打扫卫生")


xiaoming = Person("小明")
cleaner = CleanStaff("保洁员")
xiaoming.invite(cleaner)

练习2：以面向对象思想,描述下列情景.：玩家攻击敌人,敌人受伤(头顶爆字).

class Player:
    
    def __init__(self, name):
        self.name = name

    def attack(self, enemy):
        print(f"{self.name}攻击{enemy.role}")


class Enemy:
   
    def __init__(self, role):
        self.role = role

    def hurt(self):
        print(f"{self.role}受伤（头顶爆字）")

player = Player("玩家")
enemy = Enemy("敌人")
player.attack(enemy)
enemy.hurt()

练习3：以面向对象思想,描述下列情景.
张无忌教赵敏九阳神功
赵敏教张无忌玉女心经
张无忌工作挣了5000元
赵敏工作挣了10000元

class Person:

    def __init__(self, name):
        self.name = name

    def teache(self, person, gongfu):
        print(f"{self.name}教{person.name}{gongfu}")

    def work(self, salay):
        print(f"{self.name}工作挣了{salay}元")


p1 = Person("张无忌")
p2 = Person("赵敏")
p1.teache(p2,"九阳神功")
p2.teache(p1, "玉女心经")
p1.work(5000)
p2.work(10000)

3.三大特征

3.1.封装

3.1.1.数据角度

定义：将一些基本数据类型复合成一个自定义类型。
优势：

• 将数据与对数据的操作相关联。
• 代码可读性更高（类是对象的模板）。

3.1.2.行为角度

定义：向类外提供必要的功能，隐藏实现的细节。
优势：简化编程，使用者不必了解具体的实现细节，只需要调用对外提供的功能。
私有成员：

• 作用：无需向类外提供的成员，可以通过私有化进行屏蔽。
• 做法：命名使用双下划线开头。
• 本质：障眼法，实际也可以访问。（ _类名__成员名 ）

如要访问私有成员可以为：_类名__成员名（不建议使用），可以通过__dict__属性查看。

class MyClass:
    
    def __init__(self, data):
        self.__data = data
        
    def __func01(self):
        print("func01执行了")


m01 = MyClass(10)
# print(m01.__data) # 无法访问
print(m01._MyClass__data)
print(m01.__dict__)  # {'_MyClass__data': 10}
# m01.__func01() # 无法访问
m01._MyClass__func01() #func01执行了

3.1.3.案例:信息管理系统

3.1.3.1.需求

实现对用户信息的增加、删除、修改和查询。

3.1.3.2.分析

界面可能使用控制台，也可能使用Web等等。
(1) 识别对象：界面视图类、逻辑控制类、数据模型类
(2) 分配职责：

• 界面视图类：负责处理界面逻辑，比如显示菜单，获取输入，显示结果等。
• 逻辑控制类：负责存储用户信息，处理业务逻辑。比如添加、删除等
• 数据模型类：定义需要处理的数据类型。比如用户信息。

(3)建立交互：

• 界面视图对象 <----> 数据模型对象 <----> 逻辑控制对象

3.1.3.3.设计

(1) 数据模型类：UserModel

• 数据：编号 id,姓名 name,年龄 age , 登录ID login_id,密码 pwd

(2) 逻辑控制类：UserController

• 数据：用户列表 list_user
• 行为：添加用户 add_user，删除用户remove_user，修改用户update_user

(3) 界面视图类：UserView

• 数据：逻辑控制对象controller
• 行为：显示菜单__display_menu，选择菜单项__select_menu，入口逻辑main，
  输入用户__input_users，输出用户__display_user，删除用户__delete_user，
  修改用户信息__modify_user

代码：
①用户实体类 UserModel

class UserModel:
    """
        数据模型类
    """
    def __init__(self, id, name, age):
        self.id = id
        self.name = name
        self.age = age

    def __str__(self):
        return f"ID: {self.id}, 姓名: {self.name}, 年龄: {self.age}"

②逻辑控制类 UserController

class UserController:
    """
        逻辑控制类
    """
    def __init__(self):
        self.list_user = []

    def add_user(self, user):
        self.list_user.append(user)
        print(f"用户 {user.name} 添加成功.")

    def update_user(self, user_id, new_user):
        for user in self.list_user:
            if user.id == user_id:
                user.__dict__.update(new_user)  # 假设new_data是一个包含新属性的字典
                print(f"用户ID {user_id} 修改成功.")
                return
        print(f"用户ID {user_id} 未找到.")

    def remove_user(self, user_id):
        for user in self.list_user[:]:  # 使用[:]创建列表的副本，避免在迭代时修改列表
            if user.id == user_id:
                self.list_user.remove(user)
                print(f"用户ID {user_id} 删除成功.")
                return
        print(f"用户ID {user_id} 未找到.")

    def list_users(self):
        if len(self.list_user) == 0:
            print("系统用户为空")
        for user in self.list_user:
            print(user)

③界面视图类 UserView

import sys

from higher.user_management.UserModel import UserModel


class UserView:
    """
        界面视图类
    """

    def __init__(self, user_manager):
        self.user_manager = user_manager

    def __display_menu(self):
        print("================== 欢迎使用用户管理系统 ==================")
        print("==================     1.用户查询     ==================")
        print("==================     2.用户录入     ==================")
        print("==================     3.用户修改     ==================")
        print("==================     4.用户删除     ==================")
        print("==================     5.退出系统     ==================")
        print("=======================================================")

    def __select_menu(self):
        choice = int(input("请输入序号: "))
        return choice

    def main(self):
        while True:
            self.__display_menu()
            choice = self.__select_menu()
            if choice == 1:
                self.user_manager.list_users()
            elif choice == 2:
                user = self.__input_user()
                self.user_manager.add_user(user)
            elif choice == 3:
                self.__modify_user()
            elif choice == 4:
                self.__delete_user()
            elif choice == 5:
                print("您已退出系统，欢迎下次使用！")
                sys.exit(0)
                break
            else:
                print("输入有误，请重新输入！")

    def __input_user(self):
        id = input("请输入ID: ")
        name = input("请输入姓名: ")
        age = input("请输入年龄: ")
        return UserModel(id, name, int(age))

    def __display_user(self, user):
        print(user)

    def __delete_user(self):
        user_id = input("请输入需删除的ID: ")
        self.user_manager.remove_user(user_id)

    def __modify_user(self):
        user_id = input("请输入需修改的ID: ")
        new_name = input("请输入新的姓名: ")
        new_age = input("请输入新的年龄: ")
        new_data = {"name": new_name, "age": int(new_age)}
        self.user_manager.update_user(user_id, new_data)

④主程序入口

from higher.user_management.UserController import UserController
from higher.user_management.UserView import UserView

if __name__ == "__main__":
    User_controller = UserController()
    user_view = UserView(User_controller)
    user_view.main()

3.2.继承

3.2.1.定义

概念：重用现有类的功能，并在此基础上进行扩展。
说明：子类直接具有父类的成员（共性），还可以扩展新功能。
相关知识：

• 父类（基类、超类）、子类（派生类）。
• 父类相对于子类更抽象，范围更宽泛；子类相对于父类更具体，范围更狭小。
• 单继承：父类只有一个（例如 Java，C#）。
• 多继承：父类有多个（例如C++，Python）。
• Object类：任何类都直接或间接继承自 object 类。

3.2.2.继承方法

语法:

class 父类:
	def 父类方法(self):
		方法体

class 子类(父类)：
	def 子类方法(self):
		方法体

儿子 = 子类()
儿子.子类方法()
儿子.父类方法()

说明：子类直接拥有父类的方法
案例：

class Person:
	def say(self):
		print("说话")

class Teacher(Person):
	def teach(self):
		self.say()
		print("教学")

class Student(Person):
	def study(self):
	self.say()
	print("学习")


qtx = Teacher()
qtx.say()
qtx.teach()

xm = Student()
xm.say()
xm.study()

3.2.3.内置函数

isinstance(对象, 类型)：对象是否为一种类型
type(类型) == 类型：对象的类型是否是一种类型
演示：

# 对象 是一种 类型： isinstance(对象,类型)
# 老师对象 是一种 老师类型
print(isinstance(qtx, Teacher)) # True
# 老师对象 是一种 人类型
print(isinstance(qtx, Person)) # True
# 老师对象 是一种 学生类型
print(isinstance(qtx, Student)) # False
# 人对象 是一种 学生类型
print(isinstance(p, Student)) # False

# 是的关系
# 老师对象的类型 是 老师类型
print(type(qtx) == Teacher) # True
# 老师对象的类型 是 人类型
print(type(qtx) == Person) # False

练习：
创建子类：狗(跑)，鸟类(飞)
创建父类：动物(吃)
体会子类复用父类方法
体会 isinstance 与 type 的作用.

class Animal:
    """
        动物类
    """
    def __init__(self):
        pass

    def eat(self):
        print(f"动物正在吃...")


class Dog(Animal):
    """
        狗
    """
    def __init__(self):
        pass

    def eat(self):
        print(f"狗正在吃...")


class Bird(Animal):
    """
        鸟
    """
    def __init__(self):
        pass

    def eat(self):
        print(f"鸟正在吃...")


dog = Dog()
dog.eat()

bird = Bird()
bird.eat()

4.3.2.4.继承数据
语法：

class 子类(父类):
	def __init__(self,父类参数,子类参数):
		super().__init__(参数) # 调用父类构造函数
		self.实例变量 = 参数

说明：
子类如果没有构造函数，将自动执行父类的，但如果有构造函数将覆盖父类的。此时必须通过super()函数调用父类的构造函数，以确保父类实例变量被正常创建。
演示

class Person:
	
	def __init__(self, name="", age=0):
		self.name = name
		self.age = age

# 子类有构造函数,不会使用继承而来的父类构造函数[子覆盖了父方法,好像它不存在]
class Student(Person):
	# 子类构造函数：父类构造函数参数,子类构造函数参数
	def __init__(self, name, age, score):
		# 调用父类构造函数
		super().__init__(name, age)
		self.score = score


ts = Person("唐僧",22)
print(ts.name)
kw = Student("悟空", 23, 100)
print(wk.name)
print(wk.score)

练习：
创建父类：车(品牌，速度)
创建子类：电动车(电池容量,充电功率)
创建子类对象。

class Car:
    """
        车辆类
    """

    def __init__(self, brand, speed):
        self.brand = brand
        self.speed = speed


class EleCar(Car):
    """
        电动车类
    """

    def __init__(self, brand, speed, cap, power):
        super.__init__(brand, speed)
        self.cap = cap
        self.power = power

3.3.多态

3.3.1.定义

字面意思，对于一种行为有不同表现形态。
概念：对于父类的一个方法，在不同的子类上有不同体现。
说明：编码时调用父类方法，运行时传递子类对象执行子类方法。

3.3.2.重写

定义：在子类定义与父类相同的方法。
作用：改变父类行为，体现子类个性。

3.3.3.重写内置函数

定义：Python中，以双下划线开头、双下划线结尾的是系统定义的成员。我们可以在自定义类中进行重写，从而改变其行为。
str 函数：将对象转换为字符串(对人友好的)
演示：

class Movie:

    def __init__(self, name, type, index):
        self.name = name
        self.type = type
        self.index = index

    def __str__(self):
        return "%s电影的类型是%s,指数是%s." % (self.name, self.type, self.index)


bjlz = Movie("八角笼中", "剧情", 690761)
fs = Movie("封神第一部", "奇幻", 532622)
print(bjlz)
print(fs)

练习：
直接打印疫情对象

class EpidemicInfo:
    """
    疫情信息类
    """
    def __init__(self, areaName, addNum, curNum):
        self.areaName = areaName
        self.addNum = addNum
        self.curNum = curNum

    def __str__(self):
        return "%s地区疫情，当前人数%d，增长人数%d" % (self.areaName, self.curNum, self.addNum)


e1 = EpidemicInfo("北京", 10, 100)
print(e1)
e2 = EpidemicInfo("南京", 5, 75)
print(e2)

直接打印图书对象

class Book:
    """
        图书类
    """

    def __init__(self, bookName, price, pressName):
        self.bookName = bookName
        self.price = price
        self.pressName = pressName

    def __str__(self):
        return "《%s》%s出版，单价%d" % (self.bookName, self.pressName, self.price,)


e1 = Book("笑傲江湖", 35, "北京出版社")
print(e1)
e2 = Book("红楼梦", 26, "上海出版社")
print(e2)

算数运算符：

复合运算符重载：

比较运算重载：