Python 面向对象编程

一，类和实例

1，类是创建实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都互相独立，互不影响；

class Student(object):
    pass

定义类：定义类是通过class关键字，class后面紧接着是类名，即Student，类名通常是大写开头的单词，紧接着是(object)，

表示该类是从哪个类继承下来的，通常，如果没有合适的继承类，就使用object类，这是所有类最终都会继承的类。

定义好了Student类，就可以根据Student类创建出Student的实例，创建实例是通过类名+()实现的：

bart = Student()

2,方法就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据；

   方法就是类的功能，也就是定义在类里面的函数，它实现了某个功能

   通过在实例上调用方法，我们就直接操作了对象内部的数据，但无需知道方法内部的实现细节。

   和静态语言不同，Python允许对实例变量绑定任何数据，也就是说，对于两个实例变量，虽然它们都是同一个类的不同实例，但拥有的变量名称都可能不同

由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把name，score等属性绑上去：

class Student(object):
    def __init__(self, name, score):#构造函数：就是类在实例化的时候做的某些初始化操作
  
         self.name = name 

        self.score = score

   def __del__(self):#析构函数：析构函数就是这个实例在销毁的时候做的一些操作。
       self.cur.close()
       self.coon.close()

注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。

有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去：

bart = Student('Bart Simpson', 59)
print(bart.name)
print(bart.score)
和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量self，并且，调用时，不用传递该参数。
除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认参数、可变参数、关键字参数和命名关键字参数。

实例：

import pymysql
class OpMySql1:  #经典类
   pass

class OpMySql(object):#新式类
   def __init__(self,host,user,password,db,port=3306,charset='utf8'):#构造函数，就是类在实例化的时候做的某些初始化操作
      schema = {
         'user':user,
         'host':host,
         'password':password,
         'db':db,
         'port':port,
         'charset':charset
      }
      try:
         self.coon = pymysql.connect(**schema)
      except Exception as e:
         print('数据库连接异常！%s'%e)
         quit('数据库连接异常！%s'%e)
      else:#没有出异常的情况下，建立游标
         self.cur = self.coon.cursor(cursor=pymysql.cursors.DictCursor)

   def execute(self,sql):#类的方法
      try:
         self.cur.execute(sql)
      except Exception as e:
         print('sql有错误%s'%e)
         return e
      if sql[:6].upper()=='SELECT':
         return self.cur.fetchall()
      else:#其他sql语句的话
         self.coon.commit()
         return 'ok'

   def __del__(self):#析构函数：析构函数就是这个实例在销毁的时候做的一些操作。
      self.cur.close()
      self.coon.close()

res = OpMySql('211.149.218.16','jxz','123456',db='jxz')  #实例化
print(res.execute('select * from stu;'))
print(res.execute('select * from stu;'))
print(res.execute('select * from stu;'))

二，数据封装
把一些功能的实现细节不对外暴露，类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法。

class Student(object):

    def __init__(self, name, score):
        self.name = name
        self.score = score

    def print_score(self):#类的方法
        print('%s: %s' % (self.name, self.score))

要定义一个方法，除了第一个参数是self外，其他和普通函数一样。要调用一个方法，只需要在实例变量上直接调用，除了self不用传递，其他参数正常传入：

print(bart.print_score())

这样一来，我们从外部看Student类，就只需要知道，创建实例需要给出name和score，而如何打印，都是在Student类的内部定义的，这些数据和逻辑被“封装”起来了，调用很容易，但却不用知道内部实现的细节。

封装的另一个好处是可以给Student类增加新的方法，比如get_grade：

class Student(object):
    ...

    def get_grade(self):
        if self.score >= 90:
            return 'A'
        elif self.score >= 60:
            return 'B'
        else:
            return 'C'
三，实例属性与类属性（实例变量与类变量）

由于Python是动态语言，根据类创建的实例可以任意绑定属性。

给实例绑定属性的方法是通过实例变量，或者通过self变量：

class Student(object):
    def __init__(self, name):
        self.name = name#实例变量，必须实例化之后才能用，成员变量

s = Student('Bob') s.score = 90
但是，如果Student类本身需要绑定一个属性呢？可以直接在class中定义属性，这种属性是类属性，归Student类所有：

class Student(object):
    name = 'Student'#类变量
当我们定义了一个类属性后，这个属性虽然归类所有，但类的所有实例都可以访问到

class Student(object):
    name = 'Student'
s = Student() #创建实例 s
print(s.name)  #打印name属性，因为实例并没有name属性，所有会继续查找class的name属性，输出结果：Student
print(Student.name)  #打印类的name 属性，输出结果：Student
s.name = 'Michael'  #给实例绑定name 属性
print(s.name)  #由于实例属性优先级比类属性高，因此它会屏蔽掉类属性，输出结果：Michael
print(Student.name)  #但是类属性并未消失，用Student.name仍然可以访问，输出结果：Student
del s.name  #如果删除实例的name属性
print(s.name)  #再次调用s.name 由于实例的name 属性没有找到，类的name属性就显示出来，输出结果：Student
从上面的例子可以看出，在编写程序的时候，千万不要对实例属性和类属性使用相同的名字，因为相同名称的实例属性将屏蔽掉类属性，但是当你删除实例属性后，再使用相同的名称，访问到的将是类属性。
四，访问限制（私有变量）
如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问

class Student(object):

    def __init__(self, name, score):
        self.__name = name
        self.__score = score

    def print_score(self):
        print('%s: %s' % (self.__name, self.__score))

改完后，对于外部代码来说，没什么变动，但是已经无法从外部访问实例变量.__name和实例变量.__score了

bart = Student('Bart Simpson', 59)
print(bart.__name)
输出结果：
AttributeError: 'Student' object has no attribute '__name'
五，继承和多态（python 不支持多态）
继承可以把父类的所有功能都直接拿过来，这样就不必重零做起，子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖重写

当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）

class Animal(object):
    def run(self):
        print('Animal is running...')

class Dog(Animal):#对于Dog来说，Animal就是它的父类，对于Animal来说，Dog就是它的子类 
   pass

 class Cat(Animal): 
   pass
继承有最大的好处是子类获得了父类的全部功能。由于Animial实现了run()方法，因此，Dog和Cat作为它的子类，什么事也没干，就自动拥有了run()方法

dog = Dog()
dog.run()

cat = Cat()
cat.run()
输出结果：

Animal is running...
Animal is running...

class Animal(object):#父类
    def run(self):
        print('Animal is running...')

class Dog(Animal):#子类也可以将父类不适合的方法覆盖重写
    def run(self):
        print('Dog is running...')#修改

class Cat(Animal):
    def run(self):
        print('Cat is running...')
六，使用@property（属性方法）
在绑定属性时，如果我们直接把属性暴露出去，虽然写起来很简单，但是，没办法检查参数，导致可以把成绩随便改：

s = Student()
s.score = 9999

这显然不合逻辑。为了限制score的范围，可以通过一个set_score()方法来设置成绩，再通过一个get_score()来获取成绩，这样，在set_score()方法里，就可以检查参数：

class Student(object):

    def get_score(self):
         return self._score

    def set_score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value

s = Student()
s.set_score(60)
print(s.get_score())#输出结果  60
s.set_score(9999)
print(s.get_score()) #输出结果： ValueError: score must between 0 ~ 100!
但是，上面的调用方法又略显复杂，没有直接用属性这么直接简单。
有没有既能检查参数，又可以用类似属性这样简单的方式来访问类的变量呢？
还记得装饰器（decorator）可以给函数动态加上功能吗？对于类的方法，装饰器一样起作用。Python内置的@property装饰器就是负责把一个方法变成属性调用的：

class Student(object):

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not isinstance(value, int):
            raise ValueError('score must be an integer!')
        if value < 0 or value > 100:
            raise ValueError('score must between 0 ~ 100!')
        self._score = value
@property的实现比较复杂，我们先考察如何使用。把一个getter方法变成属性，只需要加上@property就可以了，
此时，@property本身又创建了另一个装饰器@score.setter，负责把一个setter方法变成属性赋值，于是，我们就拥有一个可控的属性操作：

s = Student()
s.score = 60
print(s.score) #输出结果：60
s.score = 9999
print(s.score)  #输出结果：ValueError: score must between 0 ~ 100!

注意到这个神奇的@property，我们在对实例属性操作的时候，就知道该属性很可能不是直接暴露的，而是通过getter和setter方法来实现的。

还可以定义只读属性，只定义getter方法，不定义setter方法就是一个只读属性：

class Student(object):

    @property
    def birth(self):
        return self._birth

    @birth.setter
    def birth(self, value):
        self._birth = value

    @property
    def age(self):
        return 2015 - self._birth

上面的birth是可读写属性，而age就是一个只读属性，因为age可以根据birth和当前时间计算出来

小结

@property广泛应用在类的定义中，可以让调用者写出简短的代码，同时保证对参数进行必要的检查，这样，程序运行时就减少了出错的可能性。

七，静态方法和类方法

@staticmethod #静态方法
def other():
   print('我是other')
@classmethod#类方法，也不需要实例化，直接就能用。它静态方法高级一点
#它可以使用类变量和类方法。
def class_fun(cls):
   print(cls.xiaohei)
   cls.class_fun2()
@classmethod
def class_fun2(cls):
   print('我是类方法2')

静态方法
   不需要实例化就能直接用的，其实和类没有什么关系，就是一个普通的函数
   写在了类里面而已,也用不了self的那些东西，也调用不类里面的其他函数。