面向对象笔记

Posted 2020-08-20 My deram

类的特性:

a.封装  

　　　　1.防止数据被随意修改  2.使外部程序不需要关注对象内部的构造，只需要通过对象，对外提供的接口进行直接访问即可

b.继承 

　　　1.子类通过继承父类的方式，以最小代码量的方式，实现不同角色的共同点，和不同点

　　　2.多继承时，继承顺序的区别  其中python2 就是深度查询,python3就是广度查询

　　　　

C.多态

　　　pass

什么是类？

　　其实类就是一个函数的集合即

class 类：

　　　def 函数1()：

　　　　　pass

　　　def 函数2()：

　　　　　pass
对象=类()                    #这就是实例化的过程
对象.函数1()                 #这就是实力

所以说对象就是一个类的实例化后实例

属性：

　　1.公有属性:在类里直接定义的属性，即是公有属性

　　2.私有属性:只能在内部访问，外部不能访问

注:如果外部需要访问的需求，就需要在内部在定义一个关注 这个属性的函数

def get_heart(self):
    return self._heart


如果需要强制访问
r1._Role__heart    

类的写法:

这里就要提新式类和旧式类的对比了，在python3中 采用新式类的方法

经典类 VS 新式类

　用法：   经典类写法:    Persion.__int__(self,name,age)                                #其中Persion 是父类

　　　　　　新式类写法:　 super(Teacger，self).__init__(slef,name,age)       #其中Teacger是子类

言归正传 类如何写:

类的命名规范class Persion(object):                            # Persion 是类的名称 ，首字母必须大写 object后面再提

如果要给类传参数，就必须要使用__init__方法:

__init__是啥？ 

　　　　__init__：传参数必须用__init__ 是在类中独特的构造函数，在类被调用时，这个方法会自动执行,进行一些初始化的动作，所以这里可以设置很多属性，

slef是啥？　

　　　　其实self,就是实例本身！你实例化时python会自动把这个实例本身通过self参数传进去

光记录没意思，贴代码吧

 

class Persion(object):
    def __init__(self,name,age,sex):  #构造函数，这里面定义了一些属性，在生成一个角色时要初始化的一些属性就填写在这里
        self.NAME = name
        self.AGE = age
        self.SEX = sex
　　def sayhai(self):
　　　　 print(\'you name is %s \' %self.name)
r1 = Persion(\'zcq\'，\'23\',\'test\')      # 这里就是r1 就成了对应的self,   zcq 23 test 封装到了name,age,sex 中   
r1.sayhai()   

## 这里就是r1 就成了对应的self,             zcq 23 test 封装到了name,age,sex 中  ，

所以访问self.NAME 就是 r1.name的内容了.

r1.sayhai() :Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 zcq ；self.age 是 23

总结3点:

　　1.上面的r1 = Persion(\'zcq\'，\'23\',\'test\') 这个动作，叫做类的“实例化”

　　2.上面的r1.sayhai() 就是把一个虚拟的抽象的类，通过这个动作，变成一个具体的对象了，这个对象就叫做实例

　　3.刚才定义的这个类体现了面向对象的第一个基本特性，封装，其实就是使用构造方法将内容封装到某个具体对象中，然后通过对象直接或者self间接获取被封装的内容

贴实验代码分析最好了...

 

 

class Dog(object):
    member = 100                           #公有属性
    def __init__(self,name,age):      # 构造函数
        self.NAME =name                     #构造函数属性
        self.AGE = age
        self._heart = \'yes\'
    def sayhai(self):
        print(\'my name is %s , age is %s\' %(self.NAME,self.AGE))
        self._heart = \'no\'          #修改私有属性
        print(\'状态 %s\' %self._heart)
    def b_heart(self):
        return self._heart            #外部调用接口查询私有属性

    def eat(self,food):
        print(\'%s    is eating    状态%s    %s\' %(self.NAME,self._heart,food))
    def __del__(self):                #析构函数
        print(\'del..........\')


d=Dog(\'dahong\',\'5\')            #实例化
d2=Dog(\'xiaoming\',\'30\')      #实例化
print(\'访问__init__的name属性:\',d.NAME)
d.NAME=\'zcq\'                     #修改构造函数属性
print(\'查询修改构造函数的属性:\',d.NAME)
print(\'打印私有属性:\',d.b_heart())

d.sayhai()                            #实例
print(d.b_heart())
d2.sayhai()               　　　　　　　#实例 
d2.eat(\'banna\')                   #传入eat定义的food对应的值
print(d.member)                  # 打印公有属性
Dog.member = 20                #修改公有属性
print(\'第一个实例化的私有属性\',d.member)
print(\'弟二个实例化的私有属性\',d2.member)

>>输出

访问__init__的name属性: dahong
查询修改构造函数的属性: zcq
打印私有属性: yes
my name is zcq , age is 5
状态 no
no
my name is xiaoming , age is 30
状态 no
xiaoming is eating 状态no banna
100
第一个实例化的私有属性 20
弟二个实例化的私有属性 20
del..........
del..........

 

其中__del__析构函数:无论函数有没有被调用都会被执行，   因为 类在被实例化的时候，就已经在内存中开辟了一片空间，用来存放类，这个方法就是用来删除这个实例化的参数，

垃圾回收机制: python3内部会在规定的时间内去，检测内存里没有被变量命名的参数，如果没有就删除  

 

类的继承代码:

class Persion(object):
    def __init__(self,name,age):
        self.name =name
        self.age = age
        self.sex = \'noraml\'
    def talk(self):
        print(\'调用talk函数  person is talking ......\')

class BlackPerson(Persion):

    def __init__(self,name,age,strength): #先继承，在重构   继承父类的时候 ，如果父类有构造函数，子类也必须有 所以这里写了__init__
        self.strength = strength          # 继承父类后，子类也添加构造函数，如果新增功能，子类也必须在self.新方法
        Persion.__init__(self,name,age)
        print(self.name,self.age,self.sex,self.strength)
    def tal(self):
        print(\'调用父类中的talk函数\' )
        Persion.talk(self.name)           #父类.方法
    def walk(self):
        print(\'is walking......\')
b=BlackPerson(\'翟超群\',\'24\',\'good\')    #因为调用父类  父类中有构造函数，所以必须穿参
b.tal()
b.walk()
>>

翟超群 24 noraml good
调用父类中的talk函数
调用talk函数 person is talking ......
is walking......

加强版类的继承

 

class Persion(object):          #新式类写法
    \'\'\'学习成员属性父类\'\'\'
    member = 0
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
        self.enroll()          #这里也可以这样写，可以直接调用enroll函数

    def enroll(self):
        \'\'\'注册\'\'\'
        print(\'欢迎注册%s成功\' %self.name)
        Persion.member += 1
    def tell(self):
        print(\'------info----%s\' % self.name)
       # print(self.__dict__)
        for i,j in self.__dict__.items():
            print(i,j)
        print(\'------end----\')
class Techer(Persion):

    def __init__(self,name,age,sex,salary,course):      #先继承，在重构，这里加了salary,course 2个属性
        #Persion.__init__(self,name,age,sex)   旧式类写法
        super(Techer,self).__init__(name,age,sex)  #新式类写法
        self.salary = salary
        self.course = course
    def techering(self):
        print(\'注册老师为%s，讲解课程为%s\' %(self.name,self.course))

class Student(Persion):
    def __init__(self,name,age,sex,course,tutian):       #先继承，在重构，这里加了,course,tutian2个属性
        #Persion.__init__(self,name,age,sex) 旧式类的写法
        super(Student,self).__init__(name,age,sex)          #新式类的写法
        self.course = course
        self.tutian = tutian
    def studenting(self):
        print(\'注册学生%s,课程%s，学费%s\' %(self.name,self.tutian,self.course))
        Persion.member += 1


t1=Techer(\'alex\',\'25\',\'F\',\'1000000\',\'Python\')
t2=Student(\'翟超群\',\'24\',\'F\',\'Python\',\'10001\')
# ---------- 因为子类调用的父类 所以用父类中的tell 函数执行出结果
t1.tell()
t2.tell()

类中采用迭代器

 

class Persion(object):
    def __init__(self, value):
        self._value = value
        self._children = []

    def __repr__(self):
        return \'Node({!r})\'.format(self._value)

    def add_child(self, node):
        self._children.append(node)

    def __iter__(self):
        return iter(self._children)

# Example
if __name__ == \'__main__\':
    root = Node(0)
    child1 = Node(1)
    child2 = Node(2)
    root.add_child(child1)
    root.add_child(child2)
    # Outputs Node(1), Node(2)
    for ch in root:
        print(ch)

 

 

 

忘了一点，关于类多继承

class D(object):      #只列出新式类

    def bar(self):
        print \'D.bar\'


class C(D):

    def bar(self):
        print \'C.bar\'


class B(D):

    def bar(self):
        print \'B.bar\'


class A(B, C):

    def bar(self):
        print \'A.bar\'

a = A()
# 执行bar方法时
# 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 所以，查找顺序：A --> B --> C --> D
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
a.bar()

 

类的静态方法： (后续再总结)

class Person(object):
    @staticmethod
    def a1():
        print(\'yes\')
Person.a1()