Python之面向对象、封装继承多态

一、类

类：把一类事物的相同的特征和相同的动作整合到一起

二、对象

对象：特征与动作的结合由这个类产生的，具体的存在

三、面向对象设计

面向对象只是一个思想 基于函数

#!/usr/bin/env python
# -*- coding:utf-8 -*-


def dog(name, gender, category):  # 有狗这个类的思想
    def init(name, gender, category):
        dog1 = {
            "name": name,
            "gender": gender,
            "category": category,
            "jiao": jiao,
            "chi_shi": chi_shi
        }
        return dog1

    def jiao(dog):
        print('一条狗【%s】正在汪汪汪的叫唤' % name)

    def chi_shi(dog):
        print('一条狗【%s】正在吃屎' % name)

    return init(name, gender, category)


d1 = dog("eric", "雄性", "藏獒")  # 有对象思想
print(d1)
d1["jiao"](d1)
d1["chi_shi"](d1)

面向对象只是一个思想 基于类

#!/usr/bin/env python
# -*- coding:utf-8 -*-


class Dog:
    def __init__(self, name, gender, category):
        self.name = name
        self.gender = gender
        self.category = category

    def jiao(self):
        print('一条狗【%s】正在汪汪汪的叫唤' % self.name)

    def chi_shi(self):
        print('一条狗【%s】正在吃屎' % self.name)


d1 = Dog('eric', '雄性', '藏獒')
print(dir(Dog))
print(d1.__dict__)
d2 = Dog('alex', '雄性', '京巴')
d1.jiao()
d2.jiao()

 四、类相关（类的数据属性和函数属性）

#!/usr/bin/env python
# -*- coding:utf-8 -*-


class Chinese(object):
    """中国人类"""
    # 数据属性
    governb = "NB"

    # 函数属性

    def sui_di_tu_tan(self):
        print("随地吐痰")

    def cha_dui(self):
        print("插队")


print(Chinese.governb)
Chinese.sui_di_tu_tan("eric")
Chinese.cha_dui("yuanhao")
print(dir(Chinese))  # 查看这个类系统及全部的属性
print(Chinese.__dict__)  # 查看类属性字典
Chinese.__dict__['sui_di_tu_tan']("eric")
print(Chinese.__module__)
print(Chinese.__bases__)
"""
#python为类内置的特殊属性
类名.__name__# 类的名字(字符串)
类名.__doc__# 类的文档字符串
类名.__base__# 类的第一个父类
类名.__bases__# 类所有父类构成的元组
类名.__dict__# 类的字典属性
类名.__module__# 类定义所在的模块
类名.__class__# 实例对应的类

"""

五、对象相关以及类增删改查

#!/usr/bin/env python
# -*- coding:utf-8 -*-


class Chinese:
    """这是一个中国人的类"""
    country = "china"

    def __init__(self, name, age, gender):
        """
        函数默认返回的是None
        自动为self封装数据返回字典形式
        {'name': 'eric', 'age': 18, 'gender': '女'}
        :param name:
        :param age:
        :param gender:
        """
        self.name = name
        self.age = age
        self.gender = gender

    def sui_di_tu_tan(self):
        print("[%s]吐痰" % self.name)

    def cha_dui(self):
        print("[%s]插队" % self.name)

    def eat_food(self, food):
        print("[%s]正在吃【%s】" % (self.name, food))


p1 = Chinese("eric", 18, "男")  # 实例化就是执行初始化函数__init__方法  self就是实例化的这个对象即p1
print(dir(p1))
print(p1.__dict__)
print(p1.__dict__['gender'])
print(p1.gender)
print(p1.country)
Chinese.sui_di_tu_tan(p1)
# p1.sui_di_tu_tan()=Chinese.sui_di_tu_tan(p1)  实例一定能访问类的函数属性 实例其实没有函数属性它是调用的类的函数属性
p1.sui_di_tu_tan()
p1.cha_dui()
p1.eat_food("屎")

# 类属性增删改查(数据属性函数属性都是相同道理)
# 查看
print(Chinese.country)

# 修改
Chinese.country = "Shanghai"
print(Chinese.country)

# 增加
Chinese.sichuan = "Chengdu"
print(Chinese.sichuan)


# 删除
del(Chinese.sichuan)
print(Chinese.__dict__)

# 增加函数属性


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


Chinese.play = play_ball
p1.play('篮')
print(dir(Chinese))  # 列表形式
print(Chinese.__dict__)  # 字典形式

六、实例相关增删改查

#!/usr/bin/env python
# -*- coding:utf-8 -*-

china = "中国"


class People:

    def __init__(self, name):
        self.name = name
        print('------>', china)

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


p1 = People("eric")  # 这里要打印中国哈  print('------>', china)跟类没任何关系  只有通过字典People.china p1.china调用才报错
print(p1.__dict__)
# 实例的增删改查

# 查看
print(p1.name)
print(p1.play_ball)  # <bound method People.play_ball of <__main__.People object at 0x000001F04B708198>> 
# 从这里看出来其实 实例本身没有函数属性，它是调用的类的函数属性

# 增加
p1.age = 18
print(p1.__dict__)


def test(self):
    print("我是实例的函数属性", self)


p1.test_ball = test
print(p1.__dict__)
p1.test_ball(p1)   # 这里必须加上p1参数 
# 因为类只有实例的时候才传入self参数，不传入就会报错  但是没什么卵用 基本没这么玩啊

# 修改
p1.age = 19
print(p1.__dict__)

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

七、静态属性、类方法、静态方法

#!/usr/bin/env python
# -*- coding:utf-8 -*-


class Room:
    tag = 1

    def __init__(self, owner, name, length, width, height):
        self.owner = owner
        self.name = name
        self.length = length
        self.width = width
        self.height = height

    @property  # 静态属性  外部不能分辨出调用的是函数属性或数据属性
    def cal_area(self):
        return self.length * self.width

    @classmethod  # 类调用自己的方法   类能访问类的数据属性和类的函数属性
    def tell_info(cls, x):
        print(cls)
        print("--->", cls.tag, x)

    @staticmethod  # 静态方法  是类的工具包 类和实例都可以调用
    def wash_body():
        print('正在洗澡澡')

    # def test(x, y):
    #     print(x, y)   不加@staticmethod实例不能调用啊,没有self,这么定义毫无意义，就是一个一般的函数


# 静态属性
r1 = Room("eric", '厕所', 5, 6, 8)
Room.wash_body()
r1.wash_body()

# 类方法
print(Room.tag)
Room.tell_info(10)

# 静态属性
r1 = Room("eric", '厕所', 5, 6, 8)
r2 = Room("藏獒", '厕所', 4, 5, 8)
print(r1.cal_area)
print(r2.cal_area)
# 看起来都是调用的数据属性 其实上边是调用的类的函数属性  下面才是调用的数据属性
print(r1.name)
print(r2.owner)

八、继承以及继承顺序

#!/usr/bin/env python
# -*- coding:utf-8 -*-
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 Cdrom(All_file):
    def read(self):
        print('cdrom read')

    def write(self):
        print('cdrom write')


d1 = Disk()
d1.read()


# 深度优先：最左边优先 就是一条线走通找不到，回来再找别的路线
# 广度优先：最左边优先 就是一条路一直走（不包括最上面的一层），走到最后一层又回来找别的

九、子类调用父类的方法

#!/usr/bin/env python
# -*- coding:utf-8 -*-


class Vehicle:
    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(Vehicle):
    """
    super() -> same as super(__class__, <first argument>)
    super(type) -> unbound super object
    super(type, obj) -> bound super object; requires isinstance(obj, type)
    super(type, type2) -> bound super object; requires issubclass(type2, type)
    """
    def __init__(self, name, speed, load, power, line):
        # Vehicle.__init__(self, name, speed, load, power)
        # super(Subway, self).__init__(name, speed, load, power)
        super().__init__(name, speed, load, power)
        self.line = line

    def run(self):
        # Vehicle.run(self)
        super().run()
        print('%s %s号线,开动啦........'%(self.name, self.line))


line1 = Subway('成都地铁', '350m/s', 100000000000, '电', 1)
print(dir(Subway))
print(line1.__class__)  # <class '__main__.Subway'>
line1.run()

十、多态

#!/usr/bin/env python
# -*- coding:utf-8 -*-


# 工厂就是面向对象中的类

# 工厂函数
str1 = str('sss')
print(str1)
l = list('abc')  # list类加括号实例化
print(l)

print(len(l))  # 本质上就是调用print(l.__len__()) Python本身就是多态


# 多态：就是多个对象调用父类的相同的方法但结果不一样  强调的是执行相同的功能的时候 多态就是继承的一种表现形式


class H2O:
    def __init__(self, name, t):
        self.name = name
        self.t = t

    def turn_ice(self):
        if self.t < 0:
            print('【%s】温度太低结成冰' % self.name)
        elif self.t > 0 and self.t < 100:
            print('【%s】液化变成水了' % self.name)
        elif self.t > 100:
            print('【%s】气化变成水蒸汽了' % self.name)


class Water(H2O):
    pass


class Ice(H2O):
    pass


class Steam(H2O):
    pass


w1 = Water('水', 25)
i1 = Ice('冰', -10)
s = Steam('蒸汽', 120)
w1.turn_ice()
i1.turn_ice()
s.turn_ice()

十一、封装 更新中

1.封就是把数据隐藏起来
2.类定义私有的 只在类的内部使用无法访问 这是一种Python约定并不是真正的无法访问
3.真正的封装是：明确区分内外

class People:
    # __star = 'earth'
    _star = 'earth'
    # star = 'earth'

    def __init__(self, id, name, age, salary):
        # print('----->', self.__star)  # 内部使用
        self.id = id
        self.name = name
        self.age = age
        self.salary = salary

    def get_id(self):
        print('这是获取id的函数')


p1 = People('1', 'eric', 18, 10000)
# print(p1.star)
# print(p1._star)
# print(p1.__star)   # 报错 说没有这属性  外部不能使用
# print(People.__dict__)
# print(p1._People__star)  # 外部这样使用

from encapsulation import People
# test.py文件
p1 = People('1', 'eric', 18, 10000)
print(p1._star)