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 开动了

巴特西

009-Python-面向对象

1.面向对象：

2.类属性的增删改查；

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

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

5.容易误导的地方：

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

7.组合

8.继承

8.1什么时候用继承

8.2接口继承

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

最新文章

热门文章

巴特西

009-Python-面向对象

1.面向对象：

2.类属性的增删改查；

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

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

5.容易误导的地方：

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

7.组合

8.继承

8.1什么时候用继承

8.2接口继承

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

最新文章

热门文章

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