一、面向对象的编程思想：
**面向对象编程：**类 class 和 对象 object
函数的调用过程：
其实就是面向过程，第一步该怎么做（fun1）、第二步干啥（fun2）…,通常用一个或者多个函数封装来解决问题，对于大型的开发需要程序开发者对开发流程十分熟悉，这也是面向过程的不友好的地方
面向对象编程：
把一切的事物看作、抽象成一个对象，对象就是现实中的实物
而事物的行为属性看作是类的的方法，变量等，把具有相同属性的对象划分为一组，就叫做类类就是“产品的说明”，是用来描述对象的，最后生产出来的对象有什么属性，能有什么属性，由类来决定。
类就是对事物的抽象概述，或者是“产品的规格说明”
对象就是根据“说明”实例化出来的真正的可以看得到‘可以用的产品
可以说面向对象的编程思想是所有大型项目开发的必备思想。
面向对象生活中的实例：
车（类） ------> 比亚迪、宝马、奔驰…(对象)
狗（类）-------> 京巴、二哈、萨摩、藏獒…(对象)
“人以群分，物以类聚”
int (类) --------> 100 2000 0 -100 …（对象）
二、类的创建语法
class 类名（继承列表）:
"""""类文档的字符串"""
#实例方法（类的函数method）的定义
#类变量（class variable）的定义
#类方法（@classmethod）定义
#静态方法(@staticmethod)定义
类的作用：
可以用类创建一个或多个此类的对象
类内的变量和方法能被此类所创建的所有实例所共同拥有
说明：
类名必须是标识符（与变量名命名规则相同，建议首字母大写）
类名实质上就是变量，它绑定一个类实例
类的定义最后要加个空格以告诉解释执行器，类的定义已经结束
构造函数：构造函数的调用表达式
class Dog: #定义一个类
pass
dog1 = Dog() #用类来实例化一个对象并用变量dog2绑定
print(id(dog1))
dog2 = Dog()
print(id(dog2))
print(dog1 is dog2)
执行结果：
3128052628000
3128052628056
False
实例说明：
实例有自己的作用域或名字空间，可以为该实例添加实例变量（属性）
实例可以调用类的方法
实例可以访问类中的类变量
1.实例变量： 属性 attribute，在c++叫成员变量
每个实例可以有自己的变量，称为实例变量（属性）
属性的使用语法：
实例.属性名
属性的赋值规则：与变量规则相同
1.首次为属性赋值则创建此属性
2.再次为属性赋值则改变属性的绑定关系
实例：拿空类来说
class Dog:
pass
dog1 = Dog()
dog1.kinds = "二哈" #给dog1这个对象添加kinds这个属性
dog1.color = "白色" #添加color属性
print(dog1.kinds,dog1.color)
dog1.color = '黄色' #再次赋值表示改变该属性
print(dog1.color)
执行结果：
二哈 白色
黄色
练习：写一个Student类，类的属性有name,age,score,用来保存这些学生的姓名，年龄和成绩
1）写一个函数 input_student读入n个学生的信息，用对象保存这些信息，并返回对象的列表
2）写一个函数ouput_student 打印这些学生信息
def input_student(n):
i = 0
L = []
while i < n:
s = Student()
s.name = input("请输入学生姓名： ")
s.age = int(input("请输入学生的年龄： "))
s.score = int(input("请输入学生的成绩： "))
L.append(s)
i += 1
return L
def output_student(L):
for x in L:
print(x.name, x.age, x.score)
def main():
n = int(input("请输入学生个数"))
L = input_student(n)
output_student(L)
main()
执行结果：
请输入学生个数3
请输入学生姓名： xx
请输入学生的年龄： 2
请输入学生的成绩： 3
请输入学生姓名： xxx
请输入学生的年龄： 44
请输入学生的成绩： 45
请输入学生姓名： fff
请输入学生的年龄： 3
请输入学生的成绩： 4
xx 2 3
xxx 44 45
fff 3 4
#input_student函数调用完后，虽然L变量不见了，但是L还在，只不过用main中的L重新绑定了
python中的外部函数居然可以这么随意的访问对象的内部的属性，很诧异！！！
删除属性： del 语句
语法：
del 对象.属性名
示例：以上面的Student类为例
s = Student()
s.name = "xx"
s.age = 10
print(s.name)
del s.name #删除对象s的name属性
print(s.name)
执行结果：
xx
AttributeError: 'Student' object has no attribute 'name'
#del在python中的常见用法
删除变量名
删除列表元素
删除字典键
删除对象的属性
2.实例的方法： method
语法：
class 类名(继承列表):
def 实例方法名(self,参数1，参数2...):
语句块
作用：用于描述一个对象的行为，让此类型的全部对象都拥有相同的行为
说明：
实例方法的实质是函数，是定义在类内的函数
实例方法的第一个参数代表调用这个方法的实例，一般命名为self
（学过c++的都知道，其实这个是this指针，谁调用该方法，this就是谁）
实例方法的调用语法：
实例.实例方法名(调用参数)
或者
类名.实例方法(实例，调用参数)
示例：
class Cat:
def Bark(self,food) :#第一个参数永远都是self
print("小猫吃了",food,"开心的汪汪汪？？？")
def Sleep(self):
print("Zzzzzzzzzzz")
c1 = Cat()
c2 = Cat()
c1.Bark("火腿肠")
Cat.Sleep(c2) #这里演示两种调用对象方法的写法
执行结果：
小猫吃了 火腿肠 开心的汪汪汪？？？
Zzzzzzzzzzz
示例：引出类的属性
class Cat:
def Bark(self,food):#第一个参数永远都是self
print("小猫吃了",food,"开心的汪汪汪？？？")
def food_info(self):
""""能否得到小狗吃了什么食物汪汪汪叫"""
#不可以，方法只描述实例的行为，不记录任何信息
#一般我们用属性来记录对象（实例）的信息
示例：我们可以在类的方法中直接添加属性
class Cat:
def Bark(self,food):#第一个参数永远都是self
print("小猫吃了",food,"开心的汪汪汪？？？")
self.food = food #在方法中给小狗赋予属性
def food_info(self):
""""能否得到小猫吃了什么食物汪汪汪叫"""
print("小猫上次吃了",self.food)
c1 = Cat()
c2 = Cat()
c1.Bark("火腿肠")
c1.food_info()
执行结果：
小猫吃了 火腿肠 开心的汪汪汪？？？
小猫上次吃了 火腿肠
3.初始化方法
作用：对新创建的对象添加属性等必要资源
语法形式：
class 类名：
def _init_(self,[,参数列表])：
语句块
#[]代表其中内容可以省略
说明：
初始化方法名必须为_init_不可改变
初始化方法会在构造函数创建对象后自动调用，且将实例自身通过第参数self出入_init_方法中
构造函数的实参通过_ init_方法的参数列表传到_ init _方法中
初始化方法内如果需要return语句返回，则必须返回None
示例：
class Car:
def __init__(self,c,b,m):
self.color = c #颜色
self.brand = b #品牌
self.model =m #型号
def run(self,speed = 99):
print(self.color,'的',self.brand,self.model,'正以',speed,'km/h的速度行驶')
c = Car("绿色","奥迪","A6") #位置传参
#这里会先创建一个空的对象，什么属性都没有，然后通过构造函数再去调用_init_方法对对象进行初始化
c.run(100)
执行结果：
绿色 的 奥迪 A6 正以 100 km/h的速度行驶
接下来图解一下_init_这个执行的过程，分析对象是什么时候产生的：
其实这个过程和c++一样，但是c++的初始化函数是与类名同名的构造函数
python是用 类名（参数列表) 的形式实际上调用了_init_函数完成对象的初始化工作
说一下体现的思想：
在多人合作的项目中，A写一个类描述一个类B来用,B写一个类其他人用，是这样合作的
而在面向对象中，是相互借用接口来达到合作完成的目的
类：创造者
对象：这种类型产品的体验者
使用者不需要知道对象是怎么实现的，能用就行 -_-
示例：添加修改属性的函数
class Car:
def __init__(self,c,b,m):
self.color = c #颜色
self.brand = b #品牌
self.model =m #型号
def run(self,speed = 99):
print(self.color,'的',self.brand,self.model,'正以',speed,'km/h的速度行驶')
def change_color(self,c):
self.color = c
c = Car("绿色","奥迪","A6")
c.run(100)
c.change_color("红色")
c.run()
执行结果：
红色 的 奥迪 A6 正以 99 km/h的速度行驶
示例：
class Student:
def _init_(self,n,a,s):
self.name = n
self.age = a
self.score = s
s1 = Student("胡","99","100
4.析构函数
语法形式：
class 类名：
def _del_(self):
语句块
作用：在对象被销毁之前（没有变量引用）被调用，主要负责清理对象所占用的资源
说明：python建议尽可能少在析构方法内做事情，因为销毁时间难以确定
示例：这里演示关闭文件的清理资源的操作
class FileManage:
""""这是一个文件管理员类"""
def _init_(self,file = "path"):
self.file = open(file ,'w')
def writeline(self,string):
self.file.write(string)
self.file.write('\n')
def _del_(self):
""""析构函数会在对象销毁前自动调用"""
self.file.close()
print("文件已经关闭")
fm = FileManage()
fm.writeline("helloworld")
fm.write("hellopython")
三、预置的实例属性
_dict_属性：用于绑定一个存储此实例自身变量的字典
_class_属性：用于绑定创建此实例的类
示例：
对象是用字典来存储属性的
class Dog:
pass
dog1 = Dog()
print(dog1.__dict__)
dog1.color = "绿色"
print(dog1.__dict__)
print(dog1.__class__)
dog1.name = "二哈"
print(dog1.__dict__)
执行结果：
{}
{'color': '绿色'}
<class '__main__.Dog'>
{'name': '二哈', 'color': '绿色'}
从上面我们可以看到，对象的属性都是用字典来存储的
其实我们也可以直接用字典来修改对象的属性
示例如下：
class Dog:
pass
dog1 = Dog()
print(dog1.__dict__)
dog1.color = "绿色"
print(dog1.__dict__)
print(dog1.__class__)
dog1.name = "二哈"
print(dog1.__dict__)
dog1.__dict__['age'] = 100 #可以通过这种方式来添加对象的属性
print(dog1.__dict__)
dog1.__dict__['name'] = "藏獒" #可以这样来修改对象的属性
print(dog1.__dict__)
执行结果：
{}
{'color': '绿色'}
<class '__main__.Dog'>
{'color': '绿色', 'name': '二哈'}
{'age': 100, 'color': '绿色', 'name': '二哈'}
{'age': 100, 'color': '绿色', 'name': '藏獒'}
四、用于类的函数：
isinstance(obj,class_or_tuple):
返回这个对象obj是否是某个类的对象 或者某些类中的一个类的对象，如果是则返回True
type(obj):返回对象的类
示例：
class Dog:
pass
class A:
pass
dog1 = Dog()
print(isinstance(dog1,Dog)) #判断dog1这个对象是不是Dog类型的
print(isinstance(dog1,A)) #判断dog1这个对象是不是A类型的
print(isinstance(dog1,(A,Dog,int,str))) #判断dog1这个对象是不是A,Dog,int,str类型中的一个
print(type(dog1))
a = A()
print(type(a)))
执行结果：
True
False
True
<class '__main__.Dog'>
<class '__main__.A'>
六、简单总结：
对象 = 属性 + 行为
属性：对象拥有的名词，用实例变量来存储
行为：对象拥有的动作, 用方法来表示
而行为一般又是对属性进行操作
python的属性和c++不同：
c++直接在类内直接指定属性，而python是在初始化函数中进行指定属性