day17-1 面向对象

面向对象介绍

编程范式：编程是程序员用特定语法+数据结构、+算法 的代码来告诉计算机如何执行任务的过程。实现一个任务有许多方式，对这些不同的方式特点进行归纳总结的出来的编程方式类别称为编程范式。大多数语言只支持一种编程范式，有些语言支持多种

面向过程和面向对象是两种最重要的编程范式

面向过程 ：一个procedures，一个producer包含一组被进行运算的步骤。面向过程就是程序从上到下一步步执行。但是如果这样做，问题比较明显。假如在第一步有一个方法，后面都要依赖这个方法。如果中途修改这个方法，其他步骤也得修改

所以这样维护难度，成本会比较大

面向对象  oop 编程

是通过“类”和·对象来创建各种模型实现对真实世界的描述，使用面向对象编程的原因是因为它可以使编程的维护和扩展变得更简单，并且可以大幅度提高程序开发效率。同时面向对象可以使人们更加容易理解你的代码逻辑，使团队开发更加容易

 

世界万物，皆可分类。世界万物，皆为对象。只要是对象，就属于某种类。只要是对象，就会有某种属性

 

 

特性

class 类

一个类即是对一类具有相同属性对象的抽象，蓝图，原型。在类中定义了这些对象都具备的属性（variables（data）），共同的方法

object 对象

一个对象即是一个类实例化后的实例。一个类可以实例化多个对象，每个对象也可以有不同的属性。

封装（Encapsulation）

在类中对数据进行赋值，内部调用对外部用户是透明的，（外部用户看不见）。这使得类容器，里面包含着·数据和方法

继承（Inheritance）

一个类可以派生出子类，在这个父类里定义的属性，方法自动被子类继承

多态（Polymorphism）

一个借口，多种实现。指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时对父类方法又做了不同的实现

 

函数编程与oop的主要区别就是oop可以使程序更加容易更改和扩展

 

类的初识：

class Role(object):   # 类的定义
    def __init__(self , name , role , weapon , life_value = 100 , money = 15000):
        # 构造函数
        #在实例化时做一些类的初始化工作
        #开辟一个内存，把这些东西存入实例化对象中，比如
        #r1 = Role("Richell", "police", "AK47")
        #把Richell存入r1.name 可以在外部直接r1.name调用
        #所以是吧变量赋值给了实例
        self.name = name   # 实例变量（静态属性）的作用域就是实例本身
        self.roel = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

    def shut(self):  #类的方法，功能，（动态属性）
        print("shutting.....")

    def got_shot(self):
        print("%s say 'ah.....,I got shut...terrible'" %self.name)

    def buy_gun(self,gun_name):
        print("%s just bought %s" %(self.name,gun_name))

r1 = Role("Richell","police","AK47")  # 实例化（初始化一个类，造了一个对象），生成一个角色存入r1

r2 = Role("yang","terroist","B22")  # 

r1.buy_gun("加特林")
r1.shut()
r2.got_shot()

# Richell just bought 加特林
# shutting.....
# yang say 'ah.....,I got shut...terrible'

在没有实例化的时候，类已经存在了，就和函数一样，在没有调用的时候 函数体存在内存中，函数名指向函数体。

 

语法

 

属性

 

方法

# 类初识加强

class Role(object):   # 类的定义
    n = 123  #类的变量，可以直接打印，也可以通过实例打印
    list = []
    print(n)
    name = '我是类name'
    def __init__(self , name , role , weapon , life_value = 100 , money = 15000):
        # 构造函数
        #在实例化时做一些类的初始化工作
        #开辟一个内存，把这些东西存入实例化对象中，比如
        #r1 = Role("Richell", "police", "AK47")
        #把Richell存入r1.name 可以在外部直接r1.name调用
        self.name = name
        self.roel = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

    def shut(self):
        print("shutting.....")

    def got_shot(self):
        print("%s say 'ah.....,I got shut...terrible'" %self.name)

    def buy_gun(self,gun_name):
        print("%s just bought %s" %(self.name,gun_name))

r1 = Role("Richell","police","AK47")  # 实例化（初始化一个类，造了一个对象），生成一个角色存入r1

r2 = Role("yang","terroist","B22")

r1.buy_gun("加特林")
r1.shut()
r2.got_shot()
print(Role.n,r1.name,Role.name)
#添加新的的属性
r1.bullet_prove = True   # 单独给r1 添加属性  ，就像加外挂
print(r1.bullet_prove)

# 删除新的属性
del r2.weapon
print(r1.weapon)
#print(r2.weapon)   # 出错

# 改类变量
r1.n = 456
print(r1.n,r2.n)
print('----asdaasdas----')
Role.n = 'gai'
print(Role.n,r1.n,r2.n)  # 预测结果 gai 456 gai  结果正确

# 类变量是list数据类型
r2.list.append('from r2')
r1.list.append('from r1')
print(r1.list)                           
print(Role.list)
print(r2.list)
# 结果
# ['from r2', 'from r1']
# ['from r2', 'from r1']
# ['from r2', 'from r1']



# Richell just bought 加特林
# shutting.....
# yang say 'ah.....,I got shut...terrible'

 

 

构造函数

 

析构函数：在实例释放，销毁的时候执行，通常用于一般的收尾工作，如关闭一些数据库链接打开的临时文件

    # 析构函数
    def __del__(self):
        
    

class Role(object):   # 类的定义

    def __init__(self , name , role , weapon , life_value = 100 , money = 15000):
        # 构造函数
        #在实例化时做一些类的初始化工作
        #开辟一个内存，把这些东西存入实例化对象中，比如
        #r1 = Role("Richell", "police", "AK47")
        #把Richell存入r1.name 可以在外部直接r1.name调用
        self.name = name
        self.roel = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
    # 析构函数
    def __del__(self):
        print("%s 彻底死去。。。。" %self.name)

    def shut(self):
        print("%s shuting......" % self.name)


    def got_shot(self):
        print("%s say 'ah.....,I got shut...terrible'" %self.name)

    def buy_gun(self,gun_name):
        print("%s just bought %s" %(self.name,gun_name))

r1 = Role("Richell","police","AK47")  # 实例化（初始化一个类，造了一个对象），生成一个角色存入r1
r2 = Role("yang","terroist","B22")
r1.buy_gun("加特林")
r1.shut()
del r2
print(r1.name)

# 在整个程序结束的时候实例化的类会自动销毁，因此会自动执行析构函数。记住这里是程序结束，python是从上到下解释的语句。所以一直不会销毁。除非在程序里面删除变量名

#r2.got_shot()  # 出错，r2被消除，同时析构函数会在程序结束时执行，或者使用del 的时候

# 
# Richell just bought 加特林
# Richell shuting......
# yang 彻底死去。。。。
# Richell
# Richell 彻底死去。。。。

 

 

私有方法，私有属性（封装）：

class Role(object):   # 类的定义

    def __init__(self , name , role , weapon , life_value = 100 , money = 15000):
        # 构造函数
        #在实例化时做一些类的初始化工作
        #开辟一个内存，把这些东西存入实例化对象中，比如
        #r1 = Role("Richell", "police", "AK47")
        #把Richell存入r1.name 可以在外部直接r1.name调用
        self.name = name
        self.roel = role
        self.weapon = weapon
        self.__life_value = life_value  # 私有属性 不能被外界访问。如果非要访问，也是可以的
        self.money = money

    def get_life(self):
        print("%s life_value is %d" %(self.name,self.__life_value))
    def __shut(self):  # 私有方法
        print("%s shuting......" % self.name)


    def got_shot(self):
        print("%s say 'ah.....,I got shut...terrible'" %self.name)

    def buy_gun(self,gun_name):
        print("%s just bought %s" %(self.name,gun_name))
    def get_fun(self):
        self.__shut()

r1 = Role("Richell","police","AK47")  # 实例化（初始化一个类，造了一个对象），生成一个角色存入r1
r2 = Role("yang","terroist","B22")
r1.buy_gun("加特林")
#r1.__shut()  # 直接访问私有方法报错
#  print(r1.__life_value)  # 报错

# 访问私有属性的两种正确方法
r1.get_life()  #访问私有属性
print(r1._Role__life_value)  # 不能在外部访问私有属性的原因是因为python解释器把私有属性的名字改变了。名字格式是 '实例化名'+'.'+'_类名'+'私有属性名'
# 访问私有变量
r1.get_fun()   #通过内部方法
r1._Role__shut()

#私有属性和私有方法都是在函数名前面加两个 _ .但python不会完全禁止你访问

 

 

类变量：大家共用的数据或者属性。作用与实例变量中的默认变量差不多。但是如果是大规模的实例额，对于大家公用的属性使用类变量会节省开销

 

实例变量：描述具体实例的属性