基本概念

POP vs OOP

面向过程程序设计（Procedure Oriented Programming）POP：
把计算机程序视为一系列命令集合。一组函数按照事先设定的顺序依次执行。函数是程序的基本单元。
C、python等

面向对象程序设计（Object Oriented Programming）OOP：
新的程序设计思想和方法
把计算机程序视为一组对象（Object）的集合，每个对象可以接受其他对象发送的消息，并处理这些消息。
对象是程序的基本单元，一个对象包含数据和操作数据的方法。
C++、C#、Java、Python等
更加灵活，支持代码和设计复用，更好的可读性和扩展性，主流

procedure：过程
oriented：以···为方向
programming：编程

OOP

OOP基本思想：将数据以及对数据的操作封装在一起，组成一个相互依存、不可分割的整体，即对象。
对想同类型的对象进行分类、抽象后，得出共同特征而形成类。
OOP关键：如何合理地定义和组织这些类及类之间的关系
OOP基本概念：对象、类、消息、封装、继承、多态等
封装、继承、多态是OOP的最重要的三个特征

（1）对象（Object），要研究的任何事物
事：无形、抽象（规划、计划、事件）
物：沙、叶、书、屋
对象由数据（描述事物的特征）和数据操作（体现事物的行为）构成一个独立整体

（2）类（Class）
对一组具有相同特征和想通操作对象的定义
一个类所包含的数据和方法描述一组对象的共同特征和行为
不同类之间可以有继承、关联、依赖等关系，构成类的组织和层次结构
类A，内容包括a,b,c，抽取a,c组成类B，B继承自A，B叫A的派生类或子类
类是对象之上的抽象，是对象的模版；对象则是类的具体化，是类的实例
类A：学生，对象a：学生a

（3）消息（Message）
消息是一个对象要求另一个对象实施某项操作的请求
一个系统由若干个对象组成，各个对象之间通过消息相互联系、相互作用

（4）封装（Encapsulation）
封装把对象的数据和加工该数据的方法封装为一个整体，以实现独立性很强的模块
封装的目的在于把对象的设计者和使用者分开
使用者不能知晓对象实现的细节，只能使用设计者提供的外部接口来访问该对象，保证了程序中数据的合法性和安全性

（5）继承（Inheritance）
派生类或子类即可以继承父类的特征和行为，又可以增加派生类独有的特征和行为，还可以对父类的特征和行为进行改造，使之具有自己的特点

（6）多态（Polymorphism）
多态指同名的操作作用于多种类型的对象上并获得不同的结果
叫：猫：“喵”；狗：“汪”；鼠：“吱”
多态允许每个对象以适合自身的方式去响应共同的消息，增强了软件的灵活性和重要性

综上，OOP是基于对象概念，以对象为中心，以类和继承为构造机制，来认识、理解、刻画客观世界，设计、构建相应软件系统的过程

Python中的OOP

与其他编程语言相比，Python不仅支持POP,更是一种面向对象、高级的动态编程语言，完全支持OOP的各项功能，如封装、继承、多态及对类方法的覆盖或重写等。

Python中对象的概念很广泛，一切内容都可以看成对象，如数字、字符串、列表、元组、字典、集合等都是对象，函数、类也是对象

类与对象

类的定义

类是一种类型，对象是该类型的一个变量。
类是抽象的，一般不占用内存空间
对象是具体的，创建一个对象时要为其特征分配相应的内存空间

在Python中，使用class关键字定义一个新类。定义类的一般格式为：

class 类名:
	"""类说明"""
	类体

（1）组成：类的定义主要由类头和类体两部分组成
（2）类头：由关键字class开头，后面是类的名称，冒号。（书中建议以首字母大写的符合标示符规则的命名）
（3）类体：类体重包含类的实现细节
①数据成员：用来存储特征的值，简称成员
②成员方法：用来对成员进行操作，简称方法
（4）类说明：可以选择性添加文档字符串，对类的功能等进行说明

#定义类
class Student:
	name="Tim"				#定义一个成员
	def getName(self):		#定义一个方法
		return self.name

当定义一个类后，可以使用如下两种方式访问类中的成员和方法
（1）引用：通过类对象调用类中的成员和方法，格式为“类名.成员”,“类名.方法()”
（2）实例化：先创建一个类的实例，即对象；再通过对象调用其中的成员和方法

对象创建和使用

要使用类中定义的成员和方法，必须对类实例化，即创建类的对象。
在Python中，使用赋值的方式创建类的对象：
对象名=类名([参数列表])
对象创建后，可以使用“对象.成员”,“对象.方法()”调用该类的成员和方法

#定义类
class Car:
    #定义构造方法
    def __init__(self,name):
        self.name=name
    #定义方法
    def getName(self):
        return self.name
#创建对象
c1=Car("马自达")
print("这辆汽车的品牌：",c1.getName())
###
这辆汽车的品牌：马自达

话说我很懵，我不知道__init__、self都是什么意思！
Python类中的__init__() 和 self 的解析
看完这篇文章后，我总结下：

def __init__(self,name,gender,age):
	self.name=name
	self.gender=gender
	self.gender=age

_init_ 在很多地方看到过，这里是第一次必须用到
init：初始化（initialization）
这里算是调用该类生成对象时，是依据这个方法给对象赋值的
self也是值赋值在该类中，总之这两个东西都是约定俗成的东西，然后写几遍变成一种习惯就是了

def __init__(self,brand)
	self.brand=brand

之后的就好解释了，然后利用文档告诉使用者该怎么做！
但是我使用help的话，他出现了过多的信息，并非那么隐秘

Help on class Car in module __main__:

class Car(builtins.object)
 |  Car(name, gender=None, age=None)
 |  
 |  这是文档
 |  
 |  Methods defined here:
 |  
 |  __init__(self, name, gender=None, age=None)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  getName(self)
 |      #定义方法
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

#定义类
class Car:
    def __init__(self,name,gender=None,age=None):
        import datetime
        self.name=name
        self.gender=gender
        self.age=datetime.datetime.now().year-int(age)
    def getName(self):
        return self.name
    def getF(self):
        return self.gender
    def getA(self):
        return self.age
#创建对象
c1=Car("奔驰","Karl Friedrich Benz","1926")
print("这辆汽车的品牌：%s\n品牌创始人：%s\n品牌时长：%s"%(c1.getName(),c1.getF(),c1.getA()))

这里，self代表类的对象，而并非本身

类的成员

成员类型

按照能否在类的外面直接访问，类的成员可分为如下两种
（1）公有成员：公有成员不以下划线开头，在类的内部可以访问，在类的外面也可以访问
（2）私有成员：以单下划线或双下划线开头，在类的外面不能直接访问，只能在类的内部访问或在类的外面通过对象的公有方法访问

在形式上，以单下划线或双下划线开头的是私有成员
（1）_xxx：一个以下划线开头的成员。类和派生类可以访问这些成员，在类的外面一般不建议直接访问
（2）__xxx：以两个或更多下划线开头但不能以两个或更多下划线结束的成员。对该成员，只有类自己可以访问，派生类也不能访问

class 类:
    def __init__(self,a,b,c):
        self.公有成员=a
        self._派生类可以访问=b
        self.__只能类自己访问=c
lei=类(1,2,3)
print(lei.公有成员)
print(lei._派生类可以访问)
print(lei.__只能类自己访问)
###
1
2
AttributeError: '类' object has no attribute '__只能类自己访问'

按照归属于类还是对象，类的成员可分为如下两类
（1）类成员：定义在类体中且在所有方法外的成员为类成员。类成员属于类本身，一般通过类名调用，不建议使用对象名调用
（2）实例成员：在类的方法中定义的成员为实例成员。实例成员只能被对象调用。实例成员一般在构造方法__init__()中创建，也可以在其他方法中创建

class TestClass(object):
    val1 = 100

    def __init__(self):
        self.val2 = 200

    def fcn(self,val = 400):
        val3 = 300
        self.val4 = val
        self.val5 = 500
if __name__ == '__main__':
    inst = TestClass()

    print(TestClass.val1)
    print(inst.val1)
    print(inst.val2)
    print(inst.val3)
    print(inst.val4) 

书中最后一句话，我无法验证，尝试去写无法写出，无法被调用！
自己写的有点乱，就用网上现有的一段
Python中的类变量和成员变量
于是书中的最后一句我们仍无法验证！

对类的成员访问可以总结如下
（1）公有的类成员：在类的方法中通过“类名.类成员”或“self.类成员”访问，在类的外面通过“类名.类成员”或“对象名.类成员”访问
（2）公有的实例成员：在类的方法中通过“self.实例成员”访问，在类的外面通过“对象名.实例成员”访问
（3）私有的类成员：在类的方法中通过“类名.类成员”或“self.类成员”访问，在类的外面不能直接访问
（4）私有的实力成员：在类的方法中通过“self.实例成员”访问，在类的外面不能直接访问

class 类:
    公有的类成员="公有的类成员"
    _私有的类成员="_私有的类成员"
    __私有的类成员="__私有的类成员"
    def __init__(self):
        self.公有的实例成员="self.公有的实例成员"
        self._私有的实例成员="self._私有的实例成员"
        self.__私有的实例成员="self.__私有的实例成员"
    def 私有(self):
        print(