一、对象（object）

1、什么是对象？

对象是内存中专门用来存储数据的一块区域。对象中可以存放各种数据（比如：数字、布尔值、代码等）。

• 对象由三部分组成：

  ①对象的标识（id）
  ②对象的类型（type）
  ③对象的值（value）

2、编程思想

Python是一门面向对象的编程语言。

• 面向过程：面向过程指将我们的程序的逻辑分解为一个一个的步骤，先干嘛后干嘛
• 面向对象：面向对象指将我们的程序分配给对象来进行操作，你干嘛他干嘛

二、类（class）

（一）类的定义

1、什么是类？

定义一个类也就是定义这一类对象的模板，定义它的属性和方法。类也是对象。

2、类的属性和方法

• 变量会成为该类实例的属性，所有的该类实例都可以通过 对象.属性名 的形式访问属性
• 函数会成为该类实例的方法，所有该类实例都可以通过 对象.方法名() 的形式调用方法

（二）创建一个类

1、类的基本结构

class 类名([父类]) :#class关键字来声明一个类

    公共的属性...

    # 对象的初始化方法，类的构造方法
    def __init__(self,...):
        ...

    # 其他的方法    
    def method_1(self,...):
        ...

    def method_2(self,...):
        ...

2、类的构造方法（魔术方法）_init_

3、类的方法中的self

• 方法每次被调用时，解析器都会自动传递第一个实参，第一个参数，就是调用类的实例对象本身，所以方法中至少要定义一个形参，一般我们都会将这个参数命名为self。

• self只有在类的方法中才会有，独立的函数是不必带有self的。self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

• 可以把对象的各种属性绑定到self。self.val = val，表示将外部传来的参数val的值赋值给Myclass类当前实例对象自己的实例属性val。

• self不是python的关键字，也可以用其他名称命名，但是为了规范和便于读者理解，推荐使用self。

• 如果不加self，表示是类的一个属性(可以通过"类名.变量名"的方式引用)，加了self表示是类的实例的一个属性(可以通过"实例名.变量名"的方式引用)。

class Person:
    def say_hello(a):#方法每次被调用时，解析器都会自动传递第一个实参
        print('a参数：'.rjust(9,' '),a)#第一个参数，就是调用方法的对象本身，也就是类的实例本身

p1 = Person()#创建实例p1
print('实例对象p1：',p1)
p1.say_hello()

print('*'*100)
p2 = Person()#创建实例p2
print('实例对象p2：',p2)
p2.say_hello()

class Human():
    val = '哈哈哈'#类的属性，公共的属性
    def __init__(self,val = '我是人类'):#类的初始化方法，注意：构造方法的返回值必须是"None"
        self.val = val #通过self向类实例中初始化属性

    def yellow_people(self,val = '我是黄种人'):#类的方法（函数）
        self.val = val 
        self.val1 = '我自豪'
        return self.val,self.val1#多个返回值

    def white_people(self,val = '我是白种人'):
        self.val = val 
        return self.val

print(Human.val)#Human是一个类，通过Human.val（类名.变量名）可以引用类的属性，输出：哈哈哈
print(Human().val)#Human()创建了一个类的实例，val变量加了self，表示类的实例Human()的一个属性，通过Human().val（实例名.变量名）引用，输出：我是人类
print(Human().yellow_people())

python中的self的理解

三、封装、继承、多态

面向对象的三大特征：
封装：确保对象中的数据安全
继承： 保证了对象的可扩展性
多态： 保证了程序的灵活性

（一）封装（Encapsulation）

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。
对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。

（二）继承（Inheritance）

在一个类的基础上制定一个新类，这个类不仅可以继承原来类的属性和方法，还可以添加新的属性和方法。原来的类叫父类，新的类叫子类。

# 定义一个类 Animal（动物），这个类中需要三个方法：run() sleep() bark()
class Animal:
    def run(self):
        print('动物会跑~~~')

    def sleep(self):
        print('动物睡觉~~~')

    def bark(self):
        print('动物嚎叫~~~')

# 有一个类，能够实现我们需要的大部分功能，但是不能实现全部功能
# 如何能让这个类来实现全部的功能呢？
#   ① 直接修改这个类，在这个类中添加我们需要的功能
#       - 修改起来会比较麻烦，并且会违反OCP原则
#   ② 直接创建一个新的类
#       - 创建一个新的类比较麻烦，并且需要大量的进行复制粘贴，会出现大量的重复性代码
#   ③ 直接从Animal类中来继承它的属性和方法
#       - 继承是面向对象三大特性之一
#       - 通过继承我们可以使一个类获取到其他类中的属性和方法
#       - 在定义类时，可以在类名后的括号中指定当前类的父类（超类、基类、super）
#           子类（衍生类）可以直接继承父类中的所有的属性和方法
#
#  通过继承可以直接让子类获取到父类的方法或属性，避免编写重复性的代码，并且也符合OCP原则
#   所以我们经常需要通过继承来对一个类进行扩展
class Dog(Animal):
    def bark(self):
        print('汪汪汪~~~')

    def run(self):
        print('狗跑~~~~')

class Hashiqi(Dog):
    def fan_sha(self):
        print('我是一只傻傻的哈士奇')

d = Dog()
h = Hashiqi()

d.run()#多态
d.sleep()#继承
d.bark()#多态
h.fan_sha()

（三）多态（Polymorphism）

当子类和父类存在相同的方法时，子类的方法会覆盖父类的方法，这样的代码在运行时总是会调用子类的方法，这就是多态。

四、面向对象的各种方法

（一）静态方法 ( @staticmethod )

（二）类方法 ( @classmethod)

（三）属性方法 ( @property)

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

    # property装饰器，用来将一个get方法，转换为对象的属性
    # 添加为property装饰器以后，我们就可以像调用属性一样使用get方法
    # 使用property装饰的方法，必须和属性名是一样的
    @property    
    def name(self):
        print('get方法执行了~~~')
        return self._name

    # setter方法的装饰器：@属性名.setter
    @name.setter    
    def name(self , name):
        print('setter方法调用了')
        self._name = name        

    @property
    def age(self):
        return self._age

    @age.setter    
    def age(self , age):
        self._age = age   

        

p = Person('猪八戒',18)

p.name = '孙悟空'
p.age = 28

print(p.name,p.age)

五、高级面向对象

六、模块与包

参考资料：
1、Python（四）之面向对象
2、python 面向对象全面详解