之前写的程序就是面向过程的，需要用哪个模块的话，需要单独的拿过来，才能用，自己是一个执行者，如买车、上保险、验车、选牌依次执行，需要跑到好多地方，一步一步操作；
面向对象的话，会把原来分散的功能放到一个整体里面，自己是一个指挥者，指挥买车对象去做什么，如买车对象可以：买车、上保险、验车、选牌、交钱、上牌功能都有，把用到的东西都封装到一个类
面向对象：
类：同一类事物，相当于一个模型，一个模板，如买车就是一个类，操作、流程、功能是固定的，就是有固定的几个函数，只是参数不一样
对象：指实际做的东西、实例，比如如买车就一个类，可是不能直接用，对象就是通过这个类、模板造出来的东西
实例化：初始化一个类，造了一个对象。把一个类变成一个具体的对象的过程，叫做实例化。
属性：就是对象的一些特点，实际就是一个变量---比如汽车的颜色、牌子、排量--不能变的
功能：在程序里面就是一个函数---比如汽车的：导航、听歌、看电影、跑功能
一.写一个类
1、类的定义：在py3里下面两种类的定义是没有任何区别，常用的是经典类
1）新式类
class Person(object): # 定义类，这个是新式类
nationality = 'China' # 类属性
def __init__(self, name, sex): # 构造函数
self.name = name # 实例属性
self.sex = sex
def __del__(self): # 析构函数
print('这个是析构函数')
def info(self): # 方法
print('name is %s sex is %s ' % (self.name, self.sex))
niuniu = Person('牛牛', '男') # 实例化，因为在上面的构造函数里面指定了必须传name和sex，所以在实例化的时候要把name和sex传进去
niuniu.info() # 调用实例方法
2）经典类
class Person1: # 定义类，这个是经典类
nationality = 'China' # 类属性
def __init__(self, name, sex): # 构造函数
self.name = name # 实例属性
self.sex = sex
def info(self): # 方法
print('name is %s sex is %s ' % (self.name, self.sex))
niuniu = Person1('牛牛', '男') # 实例化，因为在上面的构造函数里面指定了必须传name和sex，所以在实例化的时候要把name和sex传进去
niuniu.info() # 调用实例方法
2、类的实例化：类是不可以直接用的，需要实例化才能用
class BuyCar(object): #类名最好大写--新式类
def sale(self): #在类里面的函数必须要写self，不写会报错
print('卖车')
return 100
def insurance(self):
print('买保险')
def check(self):
print('验车')
def card(self):
print('选牌')
def pay(self):
print('付款')
def done(self):
print('上牌完成')
me=BuyCar() #实例化，就跟调用函数差不多，如果函数名加括号的话，调用函数，如是类名加括号，就是实例化对象
r=me.sale() #用类下面的方法就可以
print(r)
me.insurance()
me.check()
me.card()
返回结果：
卖车
100
买保险
验车
选牌
注意：类中写的object叫做基础类，就是类怎么创建，实例化的，是内置写好的直接用就行
3、类的参数以及构造函数：
1）构造方法与普通方法的区别：是类在实例化对象做的操作，如果你想在类初始化的时候给它传一些参数，那么久要再构造方法里面写参数,在实例化类的时候，要传构造函数中的
class Car:
def __init__(self,clor,pl,pz='BMW'): #构造方法
self.color=clor #给实例化的对象添加属性，如YWN、YWB，颜色
self.pl=pl #排量
self.pz=pz #牌子
def run(self):
print('run')
print('汽车的颜色是：',self.color) #对象以及有的属性，就可以直接在其他方法里用
def driver(self):
print('driver')
def movie(self):
print('movie')
YWN=Car('red','5.0','BMW')
YWN.run()
YWB=Car('blus','5.0','BYD')
YWB.run()
返回的结果：
run
汽车的颜色是： red
run
汽车的颜色是： blus
注意：在类里面的函数必须要写self，不写会报错，为什么呢？
每一个类是有属性(颜色、牌子、排量)和功能(导航、听歌、看电影)的,可是每个车的属性都不一样的，实例化之后，可以建造处理n多个对象，比如黑色、BMW、1.0排量；红色、BYD、1.0排量，功能都是一样的，如果要是每一次都调用属性和功能就会特别占用内存，self就是代表实例化之后的这个对象,如YWN、YWB就是代表本类对象，在调用的时候，可以不传，需要哪个功能就调用哪个功能对应的函数就可以了
2）构造方法与普通方法的区别：是类在实例化对象做的操作，如果你想在类初始化的时候给它传一些参数，那么就要在构造方法里面写参数，在实例化的时候，不过调用不调用构造方法，都会返回构造方法里的内容
构造函数：什么是构造函数，就是类在实例化的时候做的某些初始化操作，比如说人，你造一个汽车的时候，它得有颜色、型号等等。
class Car(object):
def __init__(self,):
print('我是构造方法')
def cry(self):
print('我是普通的方法')
des=Car() #构造方法实例化这个类的时候就会执行
des.cry()
des.__init__()
# 返回结果：
# 我是构造方法
# 这是啥
# 我是构造方法
4、析构方法:析构函数就是这个实例在销毁的时候做的一些操作
实例一：直接用del的话，是不可以删除实例化类的，会报错
class Car:
def __init__(self, clor, pl, pz='BMW'):
self.color = clor # 给实例化的对象添加属性，如YWN、YWB
self.pl = pl
self.pz = pz
def run(self):
print('run')
print('汽车的颜色是：', self.color) # 对象以及有的属性，就可以直接在其他方法里用
def driver(self):
print('driver')
def movie(self):
print('movie')
YWN = Car('red', '5.0', 'BMW')
del YWN
YWN.run()
# 返回结果：
# Traceback (most recent call last):
# File "I:/77777/第9周/面向对象编程.py", line 118, in <module>
# YWN.run()
# NameError: name 'YWN' is not defined
实例二：使用析构方法__del__，在执行过类里的其他方法之后，执行析构方法里的内容，执行完再删除也是会报错
class Car:
def __init__(self,clor,pl,pz='BMW'):
self.color=clor #给实例化的对象添加属性，如YWN、YWB
self.pl=pl
self.pz=pz
def __del__(self): #析构方法
print('over...')
def run(self):
print('run')
print('汽车的颜色是：',self.color) #对象以及有的属性，就可以直接在其他方法里用
def driver(self):
print('driver')
def movie(self):
print('movie')
YWN=Car('red','5.0','BMW')
del YWN
YWN.run()
# # 返回结果：
# over...
# Traceback (most recent call last):
# File "I:/77777/第9周/面向对象编程.py", line 116, in <module>
# YWN.run()
# NameError: name 'YWN' is not defined
注意：链接数据库，自动关链接的时候，可以用析构函数
实例三：析构函数的使用
程序运行完了之后，类在内存的东西就释放了，实例也就被销毁了，所以就是两种情况执行析构方法手动del 一个实例之后，或者整个程序执行完之后，实例也不在了的时候，就会调用析构函数
class Car:
def __init__(self,clor,pl,pz='BMW'):
self.color=clor #给实例化的对象添加属性，如YWN、YWB
self.pl=pl
self.pz=pz
def __del__(self): #析构方法
print('over...') #实例被销毁了执行
def run(self):
print('run')
print('汽车的颜色是：',self.color) #对象以及有的属性，就可以直接在其他方法里用
def driver(self):
print('driver')
def movie(self):
print('movie')
YWN=Car('red','5.0','BMW')
YWN.run()
# 返回结果：
# run
# 汽车的颜色是： red
# over...
5、类变量：所有的实例都可以直接使用，是一些共同的属性，如：一个车有4个车轮
实例变量：给实例化的对象添加属性
属性：属性就是类里面的一个变量，有类变量和实例变量，类变量是类在定义的时候就有的，实例变量是在实例化的时候才产生的变量。这个可以理解为，人是一个类，他的名字、年龄、性别就是它的属性。
class Car:
wheel =4 #类变量
def __init__(self,clor,pl,pz='BMW'):
self.color=clor #给实例化的对象添加属性，如YWN、YWB
self.pl=pl #实例变量
self.pz=pz
def __del__(self): #析构方法
print('over...') #实例被销毁了执行
def run(self):
print('run')
print('汽车的颜色是：',self.color) #对象以及有的属性，就可以直接在其他方法里用
print(self.wheel) #类变量可以直接这么调用
def driver(self):
print('driver')
def movie(self):
print('movie')
def p(self):
self.wheel=8 #实例变量，只是在p方法中可以用
print(self.wheel)
YWN=Car('red','5.0','BMW')
YWN.p() #将类变量值更改之后调用
YWB=Car('red','5.0','BMW')
print(YWB.wheel) #直接调用类变量，即使其他实例有改也不影响
# 返回结果：
# 8
# 4
# over...
# over...