面向对象编程

之前写的程序就是面向过程的，需要用哪个模块的话，需要单独的拿过来，才能用，自己是一个执行者，如买车、上保险、验车、选牌依次执行，需要跑到好多地方，一步一步操作；
面向对象的话，会把原来分散的功能放到一个整体里面，自己是一个指挥者，指挥买车对象去做什么，如买车对象可以：买车、上保险、验车、选牌、交钱、上牌功能都有，把用到的东西都封装到一个类

面向对象：
    类：同一类事物，相当于一个模型，一个模板，如买车就是一个类，操作、流程、功能是固定的，就是有固定的几个函数，只是参数不一样
    对象：指实际做的东西、实例，比如如买车就一个类，可是不能直接用，对象就是通过这个类、模板造出来的东西
    实例化：初始化一个类，造了一个对象。把一个类变成一个具体的对象的过程，叫做实例化。
  　属性：就是对象的一些特点，实际就是一个变量---比如汽车的颜色、牌子、排量--不能变的
    功能：在程序里面就是一个函数---比如汽车的：导航、听歌、看电影、跑功能

一.写一个类
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...