python面向对象编程基本规则

Agenda

面向对象思想

类的定义

属性

　　属性修饰器

方法

　　操作符重载

继承和多态

　　封装、继承、多态

 

面向过程、面向对象、面向函数

 

面向对象的思想，用类和对象对现实世界进行抽象

类：对事物的抽象

对象：是类的一个实例

 

类的组成：有变量和函数组成（属性、方法）

变量：属性、成员属性、是对数据的封装

函数：方法、成员方法、是对行为的封装

 

对象的组成：对象是由类实例化后得到的，所以也由属性和方法组成

 

面向对象的3大特点

　　封装、继承、多态

 

类的定义

　　class关键字定义类，类的首字母大写，习惯问题

　　类内有属性和方法

　　class Dog():

　　　　属性定义

　　　　方法定义

　　调用类型　　变量名=类名()

class Dog():
    pass
wangcai=Dog()
print wangcai

类

　　经典类

　　　　类型

　　新式类

　　　　__new__

　　　　super

　　　　__slot__

　　

　　区分方式：type(calss name)

　　　　新式类：type

　　　　经典类：classobj

class Dog:
    pass
class DognNew(object):
    pass
print type(Dog),type(DognNew)
class hebei(Dog):
    pass
class jinmao(DognNew):
    pass
print type(hebei),type(jinmao)

 

定义类

　　属性：数据封装

　　　　类属性

　　　　　　类共同拥有的属性，类中定义

　　　　　　放到类中记录

　　　　实例属性

　　　　　　类中def定义

　　　　　　放到实例中记录

　　　　属性的可见性

　　　　　　公有属性

　　　　　　内置属性

　　　　　　私有属性

　　　　　　　　dir(实例名)

　　方法：对类的行为的封装

　　　　实例方法：self关键字，通过self访问实例属性，调用实例方法

　　　　特殊方法：编译器自动添加的方法，self关键字

　　　　静态方法：@staticmethod

　　　　类方法：@classmethod

　　#Chinese继承自Person

　　clss Chinese(Person):

　　　　nation='china'

　　　　def __init__(self,name):

　　　　　　self.__name__=name

　　　　def msg(self):

　　　　　　print self.name

# !/usr/bin/python
# encoding:utf8



class Person():
    pass
class Chinese(Person):
    """
    author:tester
    """
    native='China'
    def __init__(self,name,age,sex):
        self.name=name
        self._age=age
        self.__sex=sex
    def __updatemethod(self):
        self.name +='updated'
        self._Chinese__sex +='updated'
        return self

zhang=Chinese('zhangname','zhangage','zhangsex')
print dir(Chinese)
print dir(zhang)
print zhang.name,zhang._age,zhang._Chinese__sex

print zhang._Chinese__updatemethod()
# 直接更新实例zhang的所有数据
print zhang.name,zhang._age,zhang._Chinese__sex

访问属性

　　直接访问

　　自定义get、set方法

　　通过属性修饰器

　　　　@property

　　　　@***.setter

　　　　@***.deleter

　　描述符

　　　　代码重用

 

class Person():
    pass
class Chinese(Person):
    """
    author:tester
    """
    native='China'
    def __init__(self,name,age,sex):
        self.name=name
        self._age=age
        self.__sex=sex
    def __updatemethod(self):
        self.name +='updated'
        self._Chinese__sex +='updated'
        return self
    def getname(self):
        return self.name
    def setname(self,name):
        self.name=name
    @property
    def Age(self):
        return self._age
    @Age.setter
    def Age(self,age):
        self._age=age
    @Age.deleter
#這里的代码有问题，还需要处理
    def Age(self):
        print '屌丝……年轮是可以删除的吗？！'
        # del self._age

zhang1=Chinese('zhang1name','zhang1age','zhang1sex')
print zhang1.getname()
zhang1.setname('zhang1')
# print zhang1.getname()
# print zhang1.Age
# zhang1.Age=30
# print zhang1.Age
print zhang1.Age
# print dir(zhang1)
#這里的代码有问题，还需要处理
# del zhang1._age
print zhang1.Age
# print zhang1.name,zhang1._age,zhang1._Chinese__sex

 

方法

　　实例方法：self做第一个参数，被绑定到对象本身，self指向对象本身的指针

　　　　分公有和私有

　　特殊方法（内置方法）：__init__\__str__\__cmp__

　　类方法：用@classmethod装饰器修饰，第一个参数是cls，被绑定到类，单例模式

　　静态方法：用@staticmethod装饰器修饰，无self或者cls参数，没有绑定，相当于普通函数

 

# !/usr/bin/python
# encoding:utf8



class Person():
    pass
class Chinese(Person):
    native='China'
    def __init__(self,id,name,address,age,city):
        self.name=name
        self.id=id
        self.age=age
        self.address=address
        self.city=city
    @classmethod
    def getPeoplebyParent(cls,sibling):
        if sibling==1:
            return cls(1,'huang','address',12,'city')
        else:
            print '无对应关系'
    @classmethod
    def getPeoplebysSibling(cls,sibling):
        if sibling ==None:
            print 'shangdi'
        else:
            return cls(1,'huang2','address',12,'city')
    @staticmethod
    def someone():
        pass
zhang=Chinese.getPeoplebyParent(1)
try :
    print zhang.name
except AttributeError:
    print '无对应关系,shib'

huang=Chinese.getPeoplebysSibling('')
try :
    print huang.name
except AttributeError:
    print '无对应关系,shib'

运算符重载

　　构造函数、析构函数

　　　　__new__\__init__\__del__

　　四则运算：+-*/

　　　　__add__\__sub__\__mul__\__div__

　　比较运算

　　　　__lt__\__gt__\__cmp__

　　其他

　　　　__str__\__repr__\__contains__\__bool__

 

 

继承和多态

继承

　　根据已有的类，定义新的类

　　继承的目的：代码重用、多态

　　调用父类的方法：父类.方法名(self);super(子类名,self).方法名()

多重继承

菱形继承问题

　　经典类：深度优先

　　新式类：广度优先

　　super.(子类名.self)

 

实现向量的加乘

　　加常量

　　两个向量相加

　　乘常量

　　两个向量相乘

　　两个向量的点集