009-Python-面向对象

1.面向对象：

1.1什么是类？
类：把一类事物的相同的特征和动作整合到一起就是类，类是一个抽象的概念；

1.2什么是对象？
对象：就是基于类而创建的一个具体事物（具体存在的）也是特征和动作整合到一起的；

类属性包含：数据属性，函数属性；

属性分为两种：数据属性和函数属性

实例没有函数属性；

2.类属性的增删改查；

1类的查询，传参

class school:
    def __init__(self,name,addr,type):

        self.mingzi = name
        self.dizhi = addr
        self.leixing = type
    def kao_shi(self):
        print("%s 学校要考试！！" % self.mingzi)

    def zhao_sheng(self):
        print("%s%s%s 正在招生" % (self.country, self.leixing, self.dizhi))

# 传参
s1 = school("清华","清华园","国营")

# 从类中取出数据属性；
print("国家：", s1.country)
print("校名：", s1.mingzi)

# 从类中查看函数属性；
s1.kao_shi()
s1.zhao_sheng()

输出：

国家： China
校名： 清华
清华 学校要考试！！
China国营清华园 正在招生

2.2向类中增加，数据属性：

class School:
    def __init__(self,name,addr,type):

        self.mingzi = name
        self.dizhi = addr
        self.leixing = type
    def kao_shi(self):
        print("%s 学校要考试！！" % self.mingzi)

    def zhao_sheng(self):
        print("%s%s%s 正在招生" % (self.country, self.leixing, self.dizhi))

# 增加
School.tuan = "共青团"
print(School.tuan)

输出：

共青团

2.3向类修改，数据属性：

class School:
    def __init__(self,name,addr,type):

        self.mingzi = name
        self.dizhi = addr
        self.leixing = type
    def kao_shi(self):
        print("%s 学校要考试！！" % self.mingzi)

    def zhao_sheng(self):
        print("%s%s%s 正在招生" % (self.country, self.leixing, self.dizhi))
# 修改
School.country="日本"
print(School.country)

输出：

日本

2.4向类删除，数据属性：

class School:
    def __init__(self,name,addr,type):

        self.mingzi = name
        self.dizhi = addr
        self.leixing = type
    def kao_shi(self):
        print("%s 学校要考试！！" % self.mingzi)

    def zhao_sheng(self):
        print("%s%s%s 正在招生" % (self.country, self.leixing, self.dizhi))

# 删除
del School.country
print(School.country)

输出：

ERROR:AttributeError: type object 'School' has no attribute 'country'

3.函数属性的增删改查；

3.1函数属性的增加

class School:
    country = "China"

    def __init__(self,name,addr,type):

        self.mingzi = name
        self.dizhi = addr
        self.leixing = type
        
    def kao_shi(self):
        print("%s 学校要考试！！" % self.mingzi)

    def zhao_sheng(self):
        print("%s%s%s 正在招生" % (self.country, self.leixing, self.dizhi))

s1 = School("清华", "清华园", "国营")

# 增加函数属性，并调用增加的函数属性
def eat_food(self, food):
    print("%s 正在吃 %s" % (self.mingzi, food))

School.eat = eat_food
s1.eat("水果")
School.eat(s1, "水果")

输出：

清华 正在吃 水果
清华 正在吃 芒果

3.2函数属性的修改（重新定义一个，覆盖即可）

class School:
    country = "China"

    def __init__(self,name,addr,type):

        self.mingzi = name
        self.dizhi = addr
        self.leixing = type
        
    def kao_shi(self):
        print("%s 学校要考试！！" % self.mingzi)

    def zhao_sheng(self):
        print("%s%s%s 正在招生" % (self.country, self.leixing, self.dizhi))

s1 = School("清华", "清华园", "国营")

# 修改
def test(self):
    print("test %s 不愿意考试！！" % self.mingzi)

School.kao_shi = test

# 调用kao_shi()
s1.kao_shi()

输出：

test 清华 不愿意考试！！

4.实例属性的增删改查（就是对象）

4.1实例属性的生成和查看

class Chinese:
    country = "China"
    def __init__(self,name):
        self.mingzi = name

    def play_ball(self,ball):
        print("%s 正在打 %s" %(self.mingzi, ball))
        
# 生成一个实例
p1 = Chinese("李雷") 
# 查看实例的实例属性
print(p1.__dict__)
print(p1.mingzi)

输出：

{'mingzi': '李雷'}
李雷

4.2实例数据 属性的增加和查看

class Chinese:
    country = "China"
    def __init__(self,name):
        self.mingzi = name

    def play_ball(self,ball):
        print("%s 正在打 %s" %(self.mingzi, ball))

p1 = Chinese("李雷")
print(p1.__dict__)

# 增加'age': 18
p1.age = 18

print(p1.__dict__)
print(p1.age)

输出：

{'mingzi': '李雷'}
{'age': 18, 'mingzi': '李雷'}
18

4.3实例数据 属性的修改

class Chinese:
    country = "China"
    def __init__(self,name):
        self.mingzi = name

    def play_ball(self,ball):
        print("%s 正在打 %s" %(self.mingzi, ball))

p1 = Chinese("李雷")
print(p1.__dict__)
# 修改'age': 19,直接覆盖
p1.age = 18
p1.age = 19

print(p1.__dict__)
print(p1.age)

输出

{'age': 19, 'mingzi': '李雷'}
19

4.4实例数据 属性的删除

class Chinese:
    country = "China"
    def __init__(self,name):
        self.mingzi = name

    def play_ball(self,ball):
        print("%s 正在打 %s" %(self.mingzi, ball))

p1 = Chinese("李雷")
print(p1.__dict__)
p1.age = 19

# 删除age
del p1.age
print(p1.__dict__)

输出：

{'mingzi': '李雷'}

5.容易误导的地方：

**5.1在修改p1.country = "日本"的时候，其实是在给实例赋值；在__init__中定义一个字典，并不会影响类的country值；**

class Chinese:
    country = "China"
    def __init__(self,name):
        self.mingzi = name

    def play_ball(self,ball):
        print("%s 正在打 %s" %(self.mingzi,ball))

p1 = Chinese("李雷")

print(p1.country)

# 在p1实例字典中 __init__ 添加country = "日本" 和 类中的country没有关系
p1.country = "日本"
print(p1.__dict__)

print(Chinese.country)
print(p1.country)   

输出：

China
{'mingzi': '李雷', 'country': '日本'}
类里的country: China
实例的country: 日本

5.2当在类中定义了列表，向列表中添加值

class Chinese:
    country = "China"
    l = ["a", "b"]

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

    def play_ball(self,ball):
        print("%s 正在打 %s" % (self.mingzi, ball))

p1 = Chinese("李雷")

print(p1.l)

# 添加“c”到列表中：
p1.l.append("c")
print(p1.__dict__)
print(Chinese.l)

输出：

['a', 'b']
{'mingzi': '李雷'}
['a', 'b', 'c']

6.静态属性、类方法、静态方法：

1.静态属性，在一个函数前面加上property，把函数封装成数据属性的形式，在外部调用时看不出内部的逻辑关系；
静态属性特点：静态属性既可以访问实例属性，又可以访问类的属性；

2.类方法：在一个函数前面加上classmethod，这个函数的参数默认被写为cls，cls代表类
类的数据属性，类的函数属性，不能访问实例的属性；

3.静态方法：在一个函数前面加上staticmethod，这个函数可以有参数，但是不能访问类属性，也不能访问实例属性，属于自己；叫做类的工具包

6.1通过@property 装饰器功能将，函数属性隐藏为数据属性的调用；

class Room:
    def __init__(self, name, zhuren, kuan, chang, gao):
        self.name = name
        self.zhuren = zhuren
        self.kuan = kuan
        self.chang = chang
        self.gao = gao

    # def jisuan(self):
    @property
    def jisuan(self):
        return "%s 住在 %s 房间面积是:%s" % (self.zhuren, self.name, self.kuan * self.chang)
        # 将函数内的数据return返回给jisuan
r1 = Room("天上人间", "李雷", 20, 30, 4.5)

print(r1.jisuan)
print(r1.name)

输出：

李雷 住在 天上人间 房间面积是:600
天上人间

6.2通过@classmethod装饰器，跟实例没有任何的关系，只是类级别的操作，类调用自己的方法
classmethod就是给类调用类属性用的；

class Room:
    tag = "tag_v1.0"
    def __init__(self, name, zhuren, kuan, chang, gao):
        self.name = name
        self.zhuren = zhuren
        self.kuan = kuan
        self.chang = chang
        self.gao = gao

    @classmethod
    def tell_info(cls, x):
        print(cls)
        print("=====>", cls.tag, x)

Room.tell_info("haha")

输出：

<class '__main__.Room'>
=====> tag_v1.0 haha

6.3静态方法：自己访问自己，属于类的工具包，不跟类绑定也不更具体的实例绑定；不能调用类的属性cls 和 实例属性self：

class Room:
    tag = "tag_v1.0"
    def __init__(self, name, zhuren, kuan, chang, gao):
        self.name = name
        self.zhuren = zhuren
        self.kuan = kuan
        self.chang = chang
        self.gao = gao

    @staticmethod  # 类的工具包，不跟类绑定，也不跟具体的实例绑定
    def wash_body(a, b, c):
        print("%s %s %s 正在洗澡" % (a, b, c))


r1 = Room("天上人间", "李雷", 20, 30, 4.5)

Room.wash_body("李雷", "韩梅梅", "小明")
r1.wash_body("李雷", "韩梅梅", "小明")

输出：

李雷 韩梅梅 小明 正在洗澡
李雷 韩梅梅 小明 正在洗澡

7.组合

定义一个人的类，人有头，躯干，手，脚等数据属性，这几个属性又可以是通过一个类实例化的对象，这就叫做组合；

用途：
1.做关联
2.小的组成大的
7.1 在两个不同的类中将学校和课程关联起来

class School:
    def __init__(self, name, addr):
        self.name = name
        self.addr = addr

    def zhao_sheng(self):
        print("%s 正在 %s 招生" % (self.name, self.addr))


class KeCheng:
    def __init__(self, name, xuefei, date_time, school):
        self.name = name
        self.xuefei = xuefei
        self.date_time = date_time
        self.school = school

s1 = School("oldboy", "北京")
s2 = School("oldboy", "南京")
s3 = School("oldboy", "东京")

# c1 = KeCheng("linux", 10000, "60day", s1)

msg = '''
1 天上人间 北京校区
2 天上人间 南京校区
3 天上人间 东京校区
'''

while True:
    print(msg)
    menu_dic = {
        "1": s1,
        "2": s2,
        "3": s3
    }

    choice = input("选择学校>>:")
    school_object = menu_dic[choice]

    name = input("你的课程>>:")
    xuefei = input("你的学费>>:")
    date_time = input("你的课时>>:")

    new_course = KeCheng(name, xuefei, date_time, school_object)
    print("课程【%s】属于【%s】学校" % (new_course.name, new_course.school.name))

7.2 组合：将课程对象，添加到学生对象和老师对象中

class QinghuaPeople:
    school = 'Qinghua'

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

    def eat(self):
        print('is eating')


class QinghuaStudent(QinghuaPeople):
    def __init__(self, name, age, sex):
        QinghuaPeople.__init__(self, name, age, sex)
        self.course = []

    def learn(self):
        print('%s is learning' % self.name)


class QinghuaTeacher(QinghuaPeople):
    def __init__(self, name, age, sex, salary, title):
        QinghuaPeople.__init__(self, name, age, sex)
        self.salary = salary
        self.title = title
        self.course = []

    def teach(self):
        print('%s is teaching' % self.name)


# 设置一个组合
class Course:
    def __init__(self, course_name, course_period, course_price):
        self.course_name = course_name
        self.course_period = course_period
        self.course_price = course_price

    def tell_info(self):
        print('<课程名:%s 周期：%s 价格：%s>' % (self.course_name, self.course_period, self.course_price))


# 定义的课程 Course 对象
python = Course('Python', '6mons', 3000)
linux = Course('Lnux', '3mons', 2000)
bigdata = Course('BigData', '1mons', 1000)

# 定义 Teacher 对象
egen1 = QinghuaTeacher("egen", 18, "nv", 300, "军师")

# 将课程追加到 Teacher 对象的 course 数据属性[]列表中
egen1.course.append(python)
egen1.course.append(linux)

# 查看列表中包含哪些 内容
for i in egen1.course:
    # 通过 调用 tell_info() 函数属性 打印出来
    i.tell_info()


# 定义 Student 属性
xiaoming = QinghuaStudent("xiaoming",19,"nan")

# 将课程追加到 Student 对象的 course 数据属性[] 列表中
xiaoming.course.append(python)
xiaoming.course.append(bigdata)

# 学生的课程信息
for i in xiaoming.course:
    i.tell_info()

输出：

<课程名:Python 周期：6mons 价格：3000>
<课程名:Lnux 周期：3mons 价格：2000>
<课程名:Python 周期：6mons 价格：3000>
<课程名:BigData 周期：1mons 价格：1000>

8.继承

1.什么是继承
继承就像是，子类继承父类的特性；
2.单继承于多继承
单继承将一个父类的继承，多继承将多个父类继承到自身；

8.1什么时候用继承

当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好！

class Animal:
    def eat(self):
        print("%s 吃" % self.name)

    def drink(self):
        print("%s 喝" % self.name)

    def shit(self):
        print("%s 拉" % self.name)

    def pee(self):
        print("%s 撒" % self.name)

class Cat(Animal):

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

    def cry(self):
        print("喵喵叫")

class Dog(Animal):

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

    def cry(self):
        print("汪汪叫")

c1 = Cat("小白家的小黑猫")
c1.eat()

c2 = Cat("小黑家的小白猫")
c2.drink()

d1 = Dog("胖子家的小瘦狗")
d1.shit()

输出：

小白家的小黑猫 吃
小黑家的小白猫 喝
胖子家的小瘦狗 拉

8.2接口继承

1.什么是接口
接口就是一个函数，接口继承的含义就是定义一个基类，基类中将自己的方法定义成接口函数，利用@abc.abstractmethod，这样只要来一个之类就必须 实现这个方法否则无法实例化；
用于定义接口函数，定义一个基类，如若将自己的方法定义@abc.abstractmethod 接口函数
2.如例子：
将All_file定义为一个基类，将函数read和write定义为接口函数；
其子类继承基类，必须实现read和write函数的功能，才能实例化；
基类用于规范，可以不用实例化，用子类的实现功能。

import abc

class All_file(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def read(self):
        pass
    @abc.abstractmethod
    def write(self):
        pass

class Disk(All_file):
    def read(self):
        print("Disk read")

    def write(self):
        print("Disk write")

class Mem(All_file):
    def read(self):
        print("Mem read")

    def write(self):
        print("Mem write")

m1 = Mem()

m1.read()
m1.write()

8.3子类调用 父类的方法，派生super()：

1.子类继承了父类的方法，然后想基于原有的基础上修改，那么就需要在子类中调用父类的方法;使用super()指定父类的方法：

class Vehichle:
    Country = "China"

    def __init__(self, name, speed, load, power):
        self.name = name
        self.speed = speed
        self.load = load
        self.power = power

    def run(self):
        print("地铁开动了")


class Subway(Vehichle):
    def __init__(self, name, speed, load, power, line):
        super().__init__(name, speed, load, power)
        self.line = line

    def run(self):
        super().run()
        print("%s %s 开动了" % (self.name, self.line))

s1 = Subway("北京地铁", "80迈", "10000人", "电", 2)
s1.run()

输出：

地铁开动了
北京地铁 2 开动了

来源：https://www.cnblogs.com/baolin2200/p/6495803.html