python基础--面向对象

什么是面向对象编程

　　OOP编程是利用“类”和对象来创建各种模型来实现对真实世界的描述。

　　OOP具有可维护性和可扩展性

二：面向对象有那些特性

　　1）CLASS类：一个类是对拥有相同属性的对象的抽象。类拥有类的属性和类的方法。

　　2）OBJECT对象：一个对象即是一个类的实例化的实例。这个过程就实例化。

　　3）Encapsulation封装：在类中对数据的赋值，内部调用对外部是透明。

　　4）Inheritance继承：一个类可以派生成子类，在这个父类的定义的属性和方法自动被子类继承

　　5）Polymorphism多态：是指一个基类中派生出了不同的子类，多态允许将子类的对象当作父类的对象使用，

　　　某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。

　　　这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定。

三：类的定义示例

# -*- coding:utf-8 -*-
__author__ = 'shisanjun'

class Person(object):        #类的定义，定义一个类， class是定义类的语法，Person是类名，(object)是新式类的写法
    def __init__(self,name): #构造函数，构造方法，初始方法,在生成一个角色时要初始化的一些属性就填写在这里
        self.NAME=name       #类的成员或者类的属性

    def sayhi(self):          #类的方法
        print("in the person" ,self.NAME)

d=Person("shi")#实例化产生的对象，称为实例 d就是实例化的对象
d.sayhi()
实例化，就是Person类为模版，在内存里开一块空间和赋值成一个变量名

　　注：self就是实例本身，实例化时会自动把实例本身通过self参数传进去。　　

1. 在内存中开辟一块空间指向d这个变量名
2. Person中的__init__(self,name)相当于__init__(d,name)这name个值跟刚开辟的d关联起来，， 因为关联起来后，你就可以直接rd.name这样来调用

　　3.self 过程

　　总结：

1. 上面的这个d = Dog('Lichang’)动作，叫做类的“实例化”， 就是把一个虚拟的抽象的类，通过这个动作，变成了一个具体的对象了， 这个对象就叫做实例
2. 刚才定义的这个类体现了面向对象的第一个基本特性，封装，其实就是使用构造方法将内容封装到某个具体对象中，然后通过对象直接或者self间接获取被封装的内容

四：类的三大特性

　　1）封装：也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏

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

　　2）继承:承创建的新类称为“子类”或“派生类”,被继承的类称为“基类”、“父类.

　　　　继承的过程，就是从一般到特殊的过程.要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现

　　　　继承概念的实现方式主要有2类：实现继承、接口继承.

　　　　实现继承是指使用基类的属性和方法而无需额外编码的能力

　　　　接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力(子类重构爹类方法)

　　3)多态：多态是通过父类调用子类的接口

　　4）继承示例代码

　　

# -*- coding:utf-8 -*-
__author__ = 'shisanjun'

class SchoolMember(object):

    menber=0 #公有属性
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
        self.enrool() #每个子类都运行

    def enrool(self):
        print('%s has enroll' %self.name)
        SchoolMember.menber+=1 #累计增加，不能写self.menber+=menber这样写只会在子类调用的时候加1，没有传到父类

    def tell(self): #打印所有用户信息，实现如下
        print("-----info %s-----" %self.name)
        for v,k in self.__dict__.items(): #返回子类的 所有成员属性的字典
            print("%s:\t%s" %(v,k))

    def __del__(self):
        print("%s has del" %self.name)
        SchoolMember.menber-=1

class Teacher(SchoolMember):

    def __init__(self,name,age,sex,salary,course):
        #SchoolMember.__init__(self,name,age,sex) #经典类写法==SchoolMember.__init__(self,name,age,sex)
        super(Teacher,self).__init__(name,age,sex ) #新类式类写法
        self.salary=salary
        self.course=course

    def teach(self):
        print("the teacher course",self.course)

class Student(SchoolMember):

    def __init__(self,name,age,sex,tuition,course):
        SchoolMember.__init__(self,name,age,sex)
        self.tuition=tuition
        self.course=course

    def pay_tuition(self):
        print("the student pay ",self.tuition)

t=Teacher("shi",23,"F",15000,"python")
s=Student("san",26,'M',3000,"python")

t.tell()
s.tell()

"""
C:\Python36\python.exe F:/python运维开发/day7/类的继承2.py
shi has enroll
san has enroll
-----info shi-----
name:    shi
age:    23
sex:    F
salary:    15000
course:    python
-----info san-----
name:    san
age:    26
sex:    M
tuition:    3000
course:    python
shi has del
san has del

Process finished with exit code 0

"""

　

# -*- coding:utf-8 -*-
__author__ = 'shisanjun'

class Role(object):
    nationality="China" #公有属性
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        self.name=name
        self.role=role
        self.weapon=weapon
        self.life_value=life_value
        self.money=money
        self.__heart="normal" #私有属性

    def shot(self):#公有方法
        print("%s is shooting..." %self.name)

    def got_shot(self):
        print("ah ..i got shot")
        self.__heart="die"

    def get_heart(self): #对象提供私有属性访问接口
        return self.__heart #

    def __del__(self):
        print("person in del")
# def shot2(self):
#     print("shot2 is shooting...")
# """
# #如果访问直接的私有方法,在外面定义个方法
# d=Role("si",'police','ak47')
# d.shot=shot2
# d.shot(d)
# """
# d=Role("si",'police','ak47')
# d2=Role('san','t',"B22")
#
# d2.got_shot()
# print(d2.get_heart())
# print(d.nationality) #公有属性访问
#
# print(d.nationality)
# print(d2.nationality+"111111111")
#
#  #这里只改了自己的公有属性值
# Role.nationality="US" ##更改类的公有属性，细雨修改所有实例的公有属性值
# print(d.nationality) #这里只改了自己的公有属性值
# print(d2.nationality)
#
# d.nationality="Taiload"
# print(d.nationality)

d=Role("si",'police','ak47')
print("")
del d

　

总结：

类--》实例化--》实例对象
__init__构造函数

self.name=name 属性，成员变量
def sayhi()方法，动态属性

公有属性
私有属性
self.__heart="Normal" 这个就是私有属性，对外不可见，对内可见

外面可以看见私有属性，但不能修改
def get_heart(self): #对外提供可读属性
　　return self.__heart

强制访问类的私有属性
r1._role__heart

公有属性:所有属于我这个类的对象都可以访问的属性
在类里直接定义的属性就为公有属性

析构方法：
def __del__(self)
1）在实例销毁的时候使用
2）什么时候__del__实例销毁的时候，或者说是引用被销毁
3）实例了一个实例，在实例的时候已在内存中存在了，实例化就已使用了
4）
　　r1=Role("HaiTao","police","B22")
　　程序后面虽然没有使用，但程序相当于调用 了del r1
　　所以调用了析构方法
　　del r1 只相当于删除门牌号，内存中没有销毁。

五：经典类VS新式类区别

新式类
1）写法
　　新式类
　　class Person(object)：#new style
　　经典类
　　class Persion: #classical style

2)调用父类
　　新式写法用super
　　经典类直接写父类类名
3）多继承时继承顺序python3使用的是广度查询，所以两个都一样。经典类python2是深度查询。所以经典类python2多继承是有BUG class D(B,C) D--》B--》A--C