Python类与对象--基础

## 类
　　- 具体事物的抽象和总结，是事物的共性，由属性和方法两个部分构成，比如一个Person类，有是身高、体重、肤色等属性，也有吃饭、睡觉、观察、等方法

## 对象
　　- 具体的事物，单一、个体、特性，是一个类的具体实现，比如一个Person类的对象，此对象同样拥有身高、体重、肤色等属性，也有吃饭、睡觉、观察、等方法，但各个Person对象身高、体重、肤色的值并不相同，吃的东西，睡的床，看的电影都不一样

## 定义类

 # 定义一个空的Person类
 class Person(object):
     pass

 # 类的实例化
 someone = Person()

　　- 对象初始化方法（构造方法），在实例化后立即调用

 class Person(object):
     def __init__(self):
         print("初始化。。。")

 someone = Person()  # 输出：初始化。。。

　　- 给类添加属性
　　- 这里的self指的是对象本身

 class Person(object):
     def __init__(self, name, age):
         self.name = name
         self.age = age

 someone = Person("Stanley", 22)  # 实例化时传入此对象的相关属性
 print(someone.name)              # 输出：Stanley
 print(someone.age)               # 输出：22        

　　- 给类添加方法
　　　　- 在参数位置上的self表示当前对象本身（本质上来说是一个形式参数），如果通过对象调用一个方法，那么该对象会自动传入当前方法的第一个参数中
　　　　- self并不是关键字，只是用于接收对象的普通参数，理论上可以用任何一个普通变量名代替

 class Person(object):
     def __init__(self, name, age):
         self.name = name
         self.age = age

     def eat(self, food):
         print("I'm eating %s." % food)

 someone = Person("Stanley", 22)
 someone.eat("instant noodle")    # 输出：I'm eating instant noodle.

## 代码重用与拓展 -- 继承
　　- 继承就是从已经有的类中衍生出新的类，并在新的类中添加或修改部分功能
　　- 使用继承的新类会自动获得父类中的所有方法

 class Person(object):
     def __init__(self, name, age):
         self.name = name
         self.age = age

     def eat(self, food):
         print("I'm eating %s." % food)

 class Student(Person):
     pass

 stu = Student("Stanley", 22)    # Student类什么都没做，但还是拥有__init__和eat()方法
 stu.eat("instant noodle")       # 输出：I'm eating instant noodle.

　　- 可以使用isinstance()函数判断是否是某类的实例

　　- 子类的实例一定是父类的实例，父类的实例只是父类的实例，在这个例子中，一个学生一定是一个人，但不是所有人都是学生

 print(isinstance(stu, Person))  # 输出：True
 print(isinstance(stu, Student)) # 输出：True

## 覆盖父类中的方法
　　- 在子类中定义和父类中某方法名相同的方法，即可用新方法覆盖父类中的方法，包括__init__方法
　　- 方法覆盖后，子类对象无法在调用父类中的该方法，而父类对象并不受影响

 class Person(object):
     def __init__(self, name, age):
         self.name = name
         self.age = age

     def eat(self, food):
         print("I'm eating %s." % food)

 class Student(Person):
     def eat(self, food):
         print("I'm a student, I eat %s" % food)

 per1 = Person("Lily", 22)
 stu = Student("Stanley", 22)
 per1.eat("instant noodle")        # 输出：I'm eating instant noodle.
 stu.eat("apple")                  # 输出：I'm a student, I eat apple.

　　- 给子类添加新方法
　　- 子类中的新方法父类实例并不能调用

 class Person(object):
     def __init__(self, name, age):
         self.name = name
         self.age = age

     def eat(self, food):
         print("I'm eating %s." % food)

 class Student(Person):
     def eat(self, food):
         print("I'm a student, I eat %s." % food)

     def do_homework(self):
         print("I'm a student, I have to do homework.")

 per1 = Person("Lily", 22)
 stu = Student("Stanley", 22)
 stu.do_homework()       # 输出：I'm a student, I have to do homework.
 per1.do_homework()      # AttributeError: 'Person' object has no attribute 'do_homework'

　　- 在子类中使用父类中的方法 -- super()
　　- 若在子类中定义__init__方法，则会覆盖掉父类中的__init__方法，所以需要在子类中__init__方法中明确的先调用父类的__init__方法，并传入需要的初始化参数

 class Person(object):
     def __init__(self, name, age):
         self.name = name
         self.age = age

     def eat(self, food):
         print("I'm eating %s." % food)

 class Student(Person):
     def __init__(self, name, age, grade):
         super().__init__(name, age)
         self.grade = grade

     def eat(self, food):
         print("I'm a student, I eat %s." % food)

     def do_homework(self):
         print("I'm a student, I have to do homework.")

 per1 = Person("Lily", 22)
 stu = Student("Stanley", 22, "Junior")

## 对类进行访问限制 -- 封装
　　- 封装就是对对象成员进行访问限制
　　　　- 私有
　　　　　　- 私有成员是最高级别的封装，只能在当前类或者对象中使用
　　　　　　- 在成员前面添加两个下划线即可表示该属性是私有属性
　　　　　　- Python的私有并不是真的私有，是一种称为mangling的改名策略，可以使用对象._classname_attrbutename访问

 class Student:
     __name = "Stanley"
     __age = 18

 stu = Student()
 print(stu.__name)
 # 私有属性无法直接访问
 # 输出：AttributeError: 'Student' object has no attribute '__name'
 print(stu._Student__name)
 # 私有属性可以通过特殊方式访问
 # 输出：Stanley

本文参考：

　　[美]Bill Lubanovic 《Python语言及其应用》