快速了解Python面向对象编程

1、类——继承

# pyhton 中类可以继承一个或者多个父类
class ParentClass1:
    pass

class ParentClass2:
    pass

class SubClass1(ParentClass1): # 单继承
    pass

class SubClass2(ParentClass1,ParentClass2): # 多继承，逗号分割
    pass

# 查看继承
# _base_ 只查看从左到右继承的第一个子类
# _bases_ 查看所有继承的父类
print(ParentClass1.__base__,type(ParentClass1.__base__))
print(SubClass1.__base__,type(SubClass1.__base__))

print(SubClass2.__bases__) # 数据结构为元组

# python2中有经典类和新式类  python3中只有新式类
# python3中如果没有指定基类，都会默认继承object类，object类是所有python类中的基类


# 继承与抽象
# 抽象：通过抽象得到类
# 继承：基于抽象的结果，通过编程语言实现，先抽象，再经过继承表达
class Hero:
    def __init__(self,name,value,aggress):
        self.name = name
        self.value = value
        self.aggress = aggress
    def attack(self,enemy):
        self.value -= self.aggress
class Garen(Hero):
    pass
class Riven(Hero):
    pass
g1 = Garen('绿巨人',80,20)
# __dict__:类的静态函数、类函数、普通函数、全局变量以及一些内置的属性都是放在类__dict__里
print(g1.__dict__)

r1 = Riven('钢铁侠',200,34)
print(g1.value)
r1.attack(g1) # 疑惑区
print(g1.value)


# 属性查找
class Foo:
    def f1(self):
        print("Foo.f1")
    def f2(self):
        print("Foo.f2")
class Bar(Foo):
    def f2(self):
        print("Bar.f2")
b = Bar()
print("0",b.__dict__)
print("1",b.f1()) # 调用父类中的
print("2",b.f2())  # 调用自己的

# 派生
# 父类和子类都有的方法叫做方法的重写
# 父类里没有子类有的方法叫派生方法
class Riven(Hero):
    camp='Noxus'
    def __init__(self,nickname,aggressivity,life_value,skin):
        Hero.__init__(self,nickname,aggressivity,life_value) #调用父类功能
        self.skin=skin #新属性
    def attack(self,enemy): #在自己这里定义新的attack,不再使用父类的attack,且不会影响父类
        Hero.attack(self,enemy) #调用功能
        print('from riven')
    def fly(self): #在自己这里定义新的
        print('%s is flying' %self.nickname)

r1=Riven('锐雯雯',57,200,'皮皮')
r1.fly()
print(r1.skin)

不同文件夹下调用模块

# 同文件夹下
import Newpy
s = Newpy.Student("Tom","12","male")
s.learn()

# 不同文件夹下
import sys
sys.path.append(r'路径名')
from  Newpy import Student
s = Student("Tom","12","male")
s.learn()

继承原理

class A(object):
    def test(self):
        print('from A')

class B(A):
    def test(self):
        print('from B')

class C(A):
    def test(self):
        print('from C')

class D(B):
    def test(self):
        print('from D')

class E(C):
    def test(self):
        print('from E')

class F(D,E):
    # def test(self):
    #     print('from F')
    pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性

组合

# 组合：在一个类中以另外一个列的对象作为数据属性（一个类的属性是另一个类的对象）
class Equip:
    def fire(self):
        print("Fire")
class Riven:
    camp='Noxus'
    def __init__(self,name):
        self.name = name
        self.equip = Equip() # 用Equip类产生一个装备，赋值给equip属性

r1 = Riven('公孙离')
r1.equip.fire()

# 继承：建立派生类与基类之间的关系，是一种‘是’的关系
# 组合：建立类与组合之间的关系，是一种‘有’的关系

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

class Course:
    def __init__(self,name,period,price):
        self.name=name
        self.period=period
        self.price=price
    def tell_info(self):
        print('<%s %s %s>' %(self.name,self.period,self.price))

class Teacher(People):
    def __init__(self,name,age,sex,job_title):
        People.__init__(self,name,age,sex)
        self.job_title=job_title
        self.course=[]
        self.students=[]


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

Ton = Teacher('Ton',18,'male','猎头老师')
s1 = Student('jery',18,'female')

python = Course('python','3min',300)
linux = Course('linus','8min','300.0')
# 为老师和学生添加课程
Ton.course.append(python)
Ton.course.append(linux)
s1.course.append(python)

# 为老师添加学生
Ton.students.append(s1)

for obj in Ton.course:
    obj.tell_info()