Python面向对象--理论学习

面向对象OOP:object oriented programming

Python 是动态语言，解释执行，运行速度慢；

文件名可以是同名不同包
包/模块/ 比如：p1/util.py p2/util.py
包下面必须有__init__.py 这样才能把包当成目录处理

Python的网络服务器有TCPServer、UDPServer、UnixStreamServer、UnixDatagramServer，而服务器运行模式有 多进程ForkingMixin 和 多线程ThreadingMixin两种。
Python学习OOP

一．基本介绍

OOP基本思想：类和实例
1.类：程序员 (一个群体)
对象：你，我。。
属性：姓名，性别，年龄。。
功能：写代码，修电脑。。(隐藏实现细节–封装)
实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的。
实例的属性优先级高于类属性的优先级
2.oop:继承封装和多态
3.继承：python可以实现多继承
程序员：
前端程序员
后端程序员：python程序员，Java程序员
球迷python程序员：python程序员+足球迷

二．Python定义类

类组成：属性+功能

class ClassName(object):
    #class statement
Pass
//构造函数  设置类的属性
def __init__(self):
    pass
//析构函数： 销毁对象的时候调用的，即垃圾回收的时候被调用
def __del__(self):
    pass
两个内建函数：
dir()//返回对象的属性
type()//获取对象的类型
新式类和旧式类的区别：
class OldStyle:
    def __init__(self,name,description):
        self.name=name
        self.description=description

class NewStyle(object):
    def __init__(self,name,description):
        self.name=name
        self.description=description

if __name__=='__main__':
    old=OldStyle('old','Old style class')
    print old
    print type(old)
    print dir(old)
    print '-------------'

    new=NewStyle('new','New style class')
    print new
    print type(new)
    print dir(new)
输出：
<__main__.OldStyle instance at 0x7f1242ae7488>

['__doc__', '__init__', '__module__', 'description', 'name']
-------------
<__main__.NewStyle object at 0x7f1242adeb90>

['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'description', 'name']

三．定义类的属性

Python没有访问控制，没有提供私有属性功能；全靠自觉
class test:
gender=‘male’ #直接在类下面定义
def init(self,name,age,weight):#在构造函数中定义
self.name=name #这样直接定义
#加一个下划线，表示类的私有属性，但不是真正的私有属性
self._age=age
#加2个下划线，效果：类内可以访问，该类生成的对象再访问就不可以
self.__weight=weight

例子：

class Test(object):
    hobby='play game'
    def __init__(self,name,age,weight):
        self.name=name
        self._age=age
        self.__weight=weight

    def getWeight(self):
        return self.__weight

if __name__=='__main__':
    test=Test('Tom',25,100)
print test.__dict__  #查看构造函数中的属性
print test.getWeight()   # call attribute
print test._Test__weight  #change a way to call attribute
输出：
{'_age': 25, '_Test__weight': 100, 'name': 'Tom'}
100
100

四．定义类的方法

1.函数和方法区别：
函数：直接调用函数名来调用的
方法：是类的一部分，必修和对象结合使用
类的方法也是类的属性
2.常用的方法
定义：类似属性定义
class Test(object):
def add(self):#常用
pass
def _minus(self):
pass
def __multiply(self):
pass
下面这2个也可以成为装饰器
@classmethod 调用的时候用类名，而不是用某个对象调用
@property 像访问属性一样调用方法
例子：

class Test(object):
    hobby='play game'
    def __init__(self,name,age,weight):
        self.name=name
        self._age=age
        self.__weight=weight

    @classmethod
    def getHobby(cls):
        return cls.hobby

    @property
    def getWeight(self):
        return self.__weight

    def self_introduce(self):
        print 'My name is %s ,I am %s years old\n' %(self.name,self._age)

if __name__=='__main__':
    test=Test('Tom',24,120)  #创建对象
    print test.getWeight  #120
    print Test.getHobby() #类名调用
    test.self_introduce()  #普通方法，对象调用
 输出：
120
play game
My name is Tom ,I am 24 years old

五．继承

可以实现代码的复用
1.定义类的继承

class DerivedClassName(BaseClassName):
    statement

2.方法继承的关键字super
子类继承父类的属性和方法，也可以自己定义，覆盖父类的属性和方法

class Father(object):
    def method(self,arg):
        pass
class Son(Father):
    def method(self,arg):
        super(Son,self).method(arg)

3.子类类型的判断
isinstance() 判断父类
issubclass() 判断子类
4.多继承
class SonClass(FatherClass,MotherClass):
pass
例子：

class Father(object):
    hobby='play game'
    def __init__(self,name,age,weight):
        self.name=name
        self._age=age
        self.__weight=weight

    @classmethod
    def getHobby(cls):
        return cls.hobby

    @property
    def getWeight(self):
        return self.__weight

    def self_introduce(self):
        print 'My name is %s ,I am %s years old\n' %(self.name,self._age)

class Son(Father):
    def __init__(self,name,age,weight,language):
        super(Son,self).__init__(name,age,weight)
        self.language=language
if __name__=='__main__':
    son=Son('Tom',24,120,'python')
    print dir(son)
    print son.__dict__
    print type(son)
    print Son.getHobby()
    print isinstance(son,Father) #判断Father是否是son的父类

输出：
['_Father__weight', '__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_age', 'getHobby', 'getWeight', 'hobby', 'language', 'name', 'self_introduce']
{'_age': 24, '_Father__weight': 120, 'name': 'Tom', 'language': 'python'}

play game
True

六．多态

理解：解决同一问题的不同流程
多态的要素：继承，方法重写

class Father(object):
    def __init__(self,name,age):
        self.name=name
        self._age=age
    def self_introduce(self):
        print 'My name is %s ,I am %s years old.' %(self.name,self._age)
class Son(Father):
    def __init__(self,name,age,language):
        super(Son,self).__init__(name,age)
        self.language = language
    def self_introduce(self):
        print 'My name is %s,My favorite language is %s' %(self.name,self.language)
def introduce(obj):
    if isinstance(obj,Father):
        obj.self_introduce()

if __name__ == '__main__':
    father = Father('Tom',44)
    son = Son('Alpha',18,'python')
    introduce(father)  # False 父类的self_introduce()
    introduce(son)    # True 子类的self_introduce()
输出：
My name is Tom ,I am 44 years old.
My name is Alpha,My favorite language is python

七．Python magic method

7.1 Magic method魔术方法：
长什么样：方法名前后有两个下划线
比如：def init(self):
7.2 对象的初始化
class Person():
#创建类的对象，默认的
def new(cls, *args, **kwargs):
return 对象
#初始化对象
def init(self):
pass
#回收对象，默认的
def del(self):
pass

例子：

class Person(object):
    def __new__(cls, *args, **kwargs):
        print 'call __new__method'
        print args
        return super(Person,cls).__new__(cls, *args, **kwargs)

    def __init__(self,name,age):
        print 'call __init__method'
        self.name=name
        self.age=age
if __name__=='__main__':
    per=Person('Tom',31)
print per.__dict__ #打印构造函数中的属性
输出：
call __new__method
('Tom', 31)
call __init__method
{'age': 31, 'name': 'Tom'}

7.3 类与运算符

class Person(object):
#在类内使用的魔术方法--比较运算符
    def __cmp__(self, other): #比较两个对象所有
        pass
    def __eq__(self, other):#equal
        pass
    def __lt__(self, other):#less than
        pass
    def __gt__(self, other):#great than
        pass
#加减乘除运算符
    def __add__(self, other):
        pass
    def __sub__(self, other):
        pass
    def __mul__(self, other):
        pass
    def __div__(self, other):
        pass
    #逻辑运算符
    def __or__(self, other):
        pass
    def __and__(self, other):
        pass

例子：

class Person():
    def __init__(self,name,age):
        self.m_name = name
        if isinstance(age,int):
            self.m_age=age
        else:
            raise Exception('Age must be int')
    def __eq__(self, other):
        if isinstance(other,Person):
            if self.m_age == other.m_age:
                return True
            else:
                return False
        else:
            raise Exception('The type of object must be Person.')

    def __add__(self, other):
        if isinstance(self,Person):
            return self.m_age + other.m_age
        else:
            raise Exception('The type of object must be Person')
if __name__ == '__main__':
    p1=Person('Alapa',12)
    p2=Person('Beta',12)
    print p1 == p2  #False
    print p1 + p2   #25

7.4类的展现
#转换成适合人看的字符串
def str(self):
#转换成适合机器看的字符串
def repr(self):
def unicode(self):
#展现对象的属性
def dir(self):
7.5类的属性控制
设置对象属性：
def setattr(self, key, value):
self.dict[key]=value
查询对象属性：
def getattr(self, item): #访问属性默认没有查询到的情况下调用
pass
def getattribute(self, item): #每次访问属性一定调用到
pass
删除对象属性：
def delattr(self, item):
pass