面向对象三大特性

复习
命名空间
类和对象之间的关系
类是不能直接找到对象的
对象可以直接找到类 对象(类对象指针)指向类
在对象试用名字的时候,如果对象有自己的,自己没有就用类的
对象对于类中的变量不能重新赋值,如果重新赋值,对象就会在自己的内存中创建一个重名的
新变量
静态变量
是所有的对象共享的值
使用的时候,最好全部用类名调用

组合
一个类中的对象作为另一个类对象的属性
什么有什么的关系

class A:pass
a=A()
a.n=1 A和int之间的关系
a.l=[]
a.l.append
之所以用到组合 是希望能使用a对象去操作另外一个类对象中的方法

面向对象三大特性
继承:创建类的方式,在python中,新建的类可以继承一个或多个父类,父类又可以称为基类或超类,新建的类
称为派生类或子类
多态:
封装:

继承
class parentclass1:pass 父类, 超类,基类
class parentclass2:pass
class childdclass(parentclass1):pass 子类 派生类
class childdc2ass(parentclass1,parentclass2):pass

print(ChildClass1.__base__) 会显示该类的一个父类
print(ChildClass2.__base__)
print(ChildClass2.__bases__) 会显示所有父类
print(parentclass1.__base__) object类 继承
object 在python3中所有的子类都继承自object 个人理解object是所有类的爸爸,爷爷类
所有类都默认继承object 里面有个__init__方法

继承与抽象
抽象:实例/对象抽象为类再把类与类之间相似的特此抽象出来,就形成了基类.
继承:父级

猫类:吃 喝 睡 爬树
狗类:吃 喝 睡 看家

写两个类来描述猫和狗

首先创建一个person对象
初始化:找init方法,自己调用自己的.
class father_dog_people:
def__init__(self,name,sex,hp,aggr,skill)
class father_dog_people:
def__init__(self,*args)
self.name=name

Animal.__init__(self) 等于self.__init__

派生属性:父类没有的在子类派生出来了
父类和子类有同名时候,子类只会使用子类的方法,不会使用父类的,如果子类想要使用父类的
那么需要子类强制调用父类的名字.
需要语法:父类名字.方法名(self,其他参数)
派生方法:

练习

class Foo: #创建一个类
def __init__(self): #创建一个inin()
self.func()
def func(self): #创建一个func()
print("in foo")
class Son(Foo): #创建一个类
def func(self):
print("in son")
son() #调用son()
f=Foo()
#一个对象调用方法时.先找子类的,后找父类的.

super()关键字:单继承中 super会寻找父类的方法 且在使用spuer
调用父类方法的时候不需要再传self参数.
py3中才有的关键字
例子:
super(Person,self).__init__(name,aggr,hp)

#再看看单继承

#object -->A--> B--> C--> D

class A:
def wahaha(self):print("in A")
class B(A):
def wahaha(self):print("in B")
class C(B):
def wahaha(self):print("in C")
class D(C):
def wahaha(self):print("in D")
d=D()
d.wahaha()

多继承

A B C
| /
D

class A:
def wahaha(self):print("in A")
class B:
def wahaha(self):print("in B")
class C:
def wahaha(self):print("in C")
class D(A,B,C):
def wahaha(self):print("in D")
d=D()
d.wahaha()
多继承为按照传参顺序来继承.

钻石继承()面试容易考到

A
/
B C
D /

B C 继承A
D继承B C
class A:
def wahaha(self):print("in A")
class B(A):
def wahaha(self):print("in B")
class C(A):
def wahaha(self):print("in C")
class D(B,C):
def wahaha(self):print("in D")

d=D()
d.wahaha()

顺序为:
B 到D
C到 D
A到 C
A到 B
横着为广度
竖着为深度
py3中符合广度优先算法

 

乌龟问题
A
B C

D E
F
class A:
def wahaha(self):print("in A")
class B(A):
def wahaha(self):print("in B")
class C(A):
def wahaha(self):print("in C")
class D(B):
def wahaha(self):print("in D")
class E(C):
def wahaha(self):print("in E")
class F(D,E):
def wahaha(self):print("in F")
f=F()
f,wangwang()
先找F
找D
找B
找E
找C
找A

广度优先原则
子类能和父类联系
先走一条路走完了 然后再走另外一条 这样可以少走很多重复的路
f=F()
f.wahaha()
print(F.mro())#新式类中广度优先
python3中所有的类,都继承object
如果一个类继承了object,这个类就被称为新式类
如果这个类没有继承object类,就被称为经典类.

经典类中
会深度优先,一条路走到黑然后再走另外一条路

遍历算法:深度优先,广度优先
把这个图中的所有的项全走一遍.且不会重复走
经典类 ,深度优先当中没有mro这和方法 py2中才会有
新式类遵循 广度优先算法 有mro方法 py3中py2中都会存在
py3中使用super方法找到单继承的父类
在单继承中 super就是找父类
再多继承中 super找的轨迹是根据mro顺序的.广度优先顺序

下午:
复习今天上午学的内容
默写人狗大战继承问题
面向对象作业 校园管理系统 下周一交
1.题目周所有的类都抽象出来
2.每一个类都有哪些属性和方法
3.思考这个管理系统的使用方式
这些类之间有什么关系
4.写完类和类中的属性
5方法名例出来就可以了
四点半到五点来将作业
六点半到七点半

"""
查找基类
class father1:
    pass
class father2:
    pass
class child1(father1):pass
class child2(father1,father2):pass
print(child2.__base__,child2.__base__)
print(child2.__bases__)
     
猫类:吃 喝 睡 爬树
狗类:吃 喝 睡 看家

写两个类来描述猫和狗

class dog:
    def __init__(self,name,kind,food)
        self.name=name
        self.kind=kind
        self.food=food
    def eat
        print("%s在吃%"%(self.name,self.food))
    def drink
    def sleep
    def watch
    
    
class cat:
    def __init__(self,name,kind,food)
        self.name=name
        self.kind=kind
        self.food=food
    def eat
    def drink
    def sleep
    def clmb

tom=cat()子类使用名字(方法和静态变量),如果在子类没有的话,就去父类去查找
hei=eat()

继承
class pet:
    def __init__(self,name,kind,food)
        self.name=name
        self.kind=kind
        self.food=food
    def eat
        print("%s在吃%"%(self.name,self.food))
    def drink
    def sleep


cat这个类
创建一个空对象
执行__iit__方法,子类没有用父类的

人狗大战相似的地方,就可以用继承来节省代码.更加可读 创建人狗大战父类

class father_dog_people:
    def__init__(self,name,sex,hp,aggr,skill)
    def name():
        self.name=name
        self.sex=sex
        self.hp=hp
        self.aggr=aggr
        self.skill=skill
    def sex():
        
    def hp():
        
    def skill():

首先创建一个person对象
初始化:找init方法,自己调用自己的.
class father_dog_people:
    def__init__(self,name,sex,hp,aggr,skill)
class father_dog_people:
    def__init__(self,*args)
        self.name=name


Animal.__init__(self)  等于self.__init__




class Dog(Ainmal):
    def bite(self,person):
alex=person("")

class foo1:
    def __init__(self,name)
class foo2:
    def __init__(self,name)

派生属性



class A:pass
a=A()

练习

class Foo:                     #创建一个类
    def __init__(self):        #创建一个inin()                                  
        self.func()
    def func(self):            #创建一个func()
        print("in foo")
class Son(Foo):                #创建一个类
    def func(self):
        print("in son")
son()                           #调用son()
f=Foo()
#一个对象调用方法时.先找子类的,后找父类的.


class Animal:
    def __init__(self,name,aggr,hp):
        self.name=name
        self.aggr=aggr
        self.hp=hp
    def eat(self):
        print("in Animal eat")

class Person(Animal):
    def __init__(self,name,sex,aggr,hp):
        self.sex=sex  #派生属性
        #Anmal__init__(self,name,aggr,hp)
        super().__init__(name,aggr,hp)
        #单继承中super会寻找父类
        #且在使用super时调用父类方法时不需要再传入self参数
    def eat(self):
        print("in Person eat")
alex=Person("alex","不详",1,250)
print(alex.__dict__)


#固定模板
#调用父级的两种方式
#直接调用
#super调用
"""
#再看看单继承
#object  -->A-->  B-->  C-->  D

class A:
    def wahaha(self):print("in A")
class B(A):
    def wahaha(self):print("in B")
class C(B):
    def wahaha(self):print("in C")
class D(C):
    def wahaha(self):print("in D")
d=D()
d.wahaha()


多继承
A B C
 | /
  D

class A:
    def wahaha(self):print("in A")
class B:
    def wahaha(self):print("in B")
class C:
    def wahaha(self):print("in C")
class D(A,B,C):
    def wahaha(self):print("in D")
d=D()
d.wahaha()
多继承为按照传参顺序来继承.

钻石继承()面试容易考到

     A
   /   
B         C
     D  /
B C 继承A
D继承B C
class A:
    def wahaha(self):print("in A")
class B(A):
    def wahaha(self):print("in B")
class C(A):
    def wahaha(self):print("in C")
class D(B,C):
    def wahaha(self):print("in D")

d=D()
d.wahaha()

顺序为:
B 到D
C到 D
A到 C
A到 B
横着为广度
竖着为深度
py3中符合广度优先算法




乌龟问题
     A
B         C

D         E
     F
class A:
    def wahaha(self):print("in A")
class B(A):
    def wahaha(self):print("in B")
class C(A):
    def wahaha(self):print("in C")
class D(B):
    def wahaha(self):print("in D")
class E(C):
    def wahaha(self):print("in E")
class F(D,E):
    def wahaha(self):print("in F")
f=F()
f,wangwang()
先找F
找D
找B
找E
找C
找A

广度优先原则
子类能和父类联系
先走一条路走完了 然后再走另外一条 这样可以少走很多重复的路
f=F()
f.wahaha()
print(F.mro())#新式类中广度优先
python3中所有的类,都继承object
如果一个类继承了object,这个类就被称为新式类
如果这个类没有继承object类,就被称为经典类.

经典类中
会深度优先,一条路走到黑然后再走另外一条路

遍历算法:深度优先,广度优先
把这个图中的所有的项全走一遍.且不会重复走
经典类 ,深度优先当中没有mro这和方法   py2中才会有
新式类遵循 广度优先算法 有mro方法      py3中py2中都会存在
py3中使用super方法找到单继承的父类
在单继承中 super就是找父类
再多继承中   super找的轨迹是根据mro顺序的.广度优先顺序




下午:
复习今天上午学的内容
默写人狗大战继承问题
面向对象作业 校园管理系统 下周一交
1.题目周所有的类都抽象出来
2.每一个类都有哪些属性和方法
3.思考这个管理系统的使用方式
这些类之间有什么关系
4.写完类和类中的属性
5方法名例出来就可以了
四点半到五点来将作业
六点半到七点半
计算器
员工信息表
附加:个人思考一个自制的学习程序.
#开发原则
#不要发生循环继承的关系,就像是不要短路一样
#依赖倒置原则:高层模块不能依赖低层模块,二者都应该依赖其抽象;
#抽象不应该依赖具体细节底层模块不能依赖

"""
查找基类
class father1:
    pass
class father2:
    pass
class child1(father1):pass
class child2(father1,father2):pass
print(child2.__base__,child2.__base__)
print(child2.__bases__)
     
猫类:吃 喝 睡 爬树
狗类:吃 喝 睡 看家

写两个类来描述猫和狗

class dog:
    def __init__(self,name,kind,food)
        self.name=name
        self.kind=kind
        self.food=food
    def eat
        print("%s在吃%"%(self.name,self.food))
    def drink
    def sleep
    def watch
    
    
class cat:
    def __init__(self,name,kind,food)
        self.name=name
        self.kind=kind
        self.food=food
    def eat
    def drink
    def sleep
    def clmb

tom=cat()子类使用名字(方法和静态变量),如果在子类没有的话,就去父类去查找
hei=eat()

继承
class pet:
    def __init__(self,name,kind,food)
        self.name=name
        self.kind=kind
        self.food=food
    def eat
        print("%s在吃%"%(self.name,self.food))
    def drink
    def sleep


cat这个类
创建一个空对象
执行__iit__方法,子类没有用父类的

人狗大战相似的地方,就可以用继承来节省代码.更加可读 创建人狗大战父类

class father_dog_people:
    def__init__(self,name,sex,hp,aggr,skill)
    def name():
        self.name=name
        self.sex=sex
        self.hp=hp
        self.aggr=aggr
        self.skill=skill
    def sex():
        
    def hp():
        
    def skill():

首先创建一个person对象
初始化:找init方法,自己调用自己的.
class father_dog_people:
    def__init__(self,name,sex,hp,aggr,skill)
class father_dog_people:
    def__init__(self,*args)
        self.name=name


Animal.__init__(self)  等于self.__init__




class Dog(Ainmal):
    def bite(self,person):
alex=person("")

class foo1:
    def __init__(self,name)
class foo2:
    def __init__(self,name)

派生属性



class A:pass
a=A()

练习

class Foo:                     #创建一个类
    def __init__(self):        #创建一个inin()                                  
        self.func()
    def func(self):            #创建一个func()
        print("in foo")
class Son(Foo):                #创建一个类
    def func(self):
        print("in son")
son()                           #调用son()
f=Foo()
#一个对象调用方法时.先找子类的,后找父类的.


class Animal:
    def __init__(self,name,aggr,hp):
        self.name=name
        self.aggr=aggr
        self.hp=hp
    def eat(self):
        print("in Animal eat")

class Person(Animal):
    def __init__(self,name,sex,aggr,hp):
        self.sex=sex  #派生属性
        #Anmal__init__(self,name,aggr,hp)
        super().__init__(name,aggr,hp)
        #单继承中super会寻找父类
        #且在使用super时调用父类方法时不需要再传入self参数
    def eat(self):
        print("in Person eat")
alex=Person("alex","不详",1,250)
print(alex.__dict__)


#固定模板
#调用父级的两种方式
#直接调用
#super调用
"""
#再看看单继承
#object  -->A-->  B-->  C-->  D

class A:
    def wahaha(self):print("in A")
class B(A):
    def wahaha(self):print("in B")
class C(B):
    def wahaha(self):print("in C")
class D(C):
    def wahaha(self):print("in D")
d=D()
d.wahaha()


多继承
A B C
 | /
  D

class A:
    def wahaha(self):print("in A")
class B:
    def wahaha(self):print("in B")
class C:
    def wahaha(self):print("in C")
class D(A,B,C):
    def wahaha(self):print("in D")
d=D()
d.wahaha()
多继承为按照传参顺序来继承.

钻石继承()面试容易考到

     A
   /   
B         C
     D  /
B C 继承A
D继承B C
class A:
    def wahaha(self):print("in A")
class B(A):
    def wahaha(self):print("in B")
class C(A):
    def wahaha(self):print("in C")
class D(B,C):
    def wahaha(self):print("in D")

d=D()
d.wahaha()

顺序为:
B 到D
C到 D
A到 C
A到 B
横着为广度
竖着为深度
py3中符合广度优先算法




乌龟问题
     A
B         C

D         E
     F
class A:
    def wahaha(self):print("in A")
class B(A):
    def wahaha(self):print("in B")
class C(A):
    def wahaha(self):print("in C")
class D(B):
    def wahaha(self):print("in D")
class E(C):
    def wahaha(self):print("in E")
class F(D,E):
    def wahaha(self):print("in F")
f=F()
f,wangwang()
先找F
找D
找B
找E
找C
找A

广度优先原则
子类能和父类联系
先走一条路走完了 然后再走另外一条 这样可以少走很多重复的路
f=F()
f.wahaha()
print(F.mro())#新式类中广度优先
python3中所有的类,都继承object
如果一个类继承了object,这个类就被称为新式类
如果这个类没有继承object类,就被称为经典类.

经典类中
会深度优先,一条路走到黑然后再走另外一条路

遍历算法:深度优先,广度优先
把这个图中的所有的项全走一遍.且不会重复走
经典类 ,深度优先当中没有mro这和方法   py2中才会有
新式类遵循 广度优先算法 有mro方法      py3中py2中都会存在
py3中使用super方法找到单继承的父类
在单继承中 super就是找父类
再多继承中   super找的轨迹是根据mro顺序的.广度优先顺序




下午:
复习今天上午学的内容
默写人狗大战继承问题
面向对象作业 校园管理系统 下周一交
1.题目周所有的类都抽象出来
2.每一个类都有哪些属性和方法
3.思考这个管理系统的使用方式
这些类之间有什么关系
4.写完类和类中的属性
5方法名例出来就可以了
四点半到五点来将作业
六点半到七点半
计算器
员工信息表
附加:个人思考一个自制的学习程序.
#开发原则
#不要发生循环继承的关系,就像是不要短路一样
#依赖倒置原则:高层模块不能依赖低层模块,二者都应该依赖其抽象;
#抽象不应该依赖具体细节底层模块不能依赖