python3 面向对象学习 (第六周)

前言：

为什么要学习python3?

原因：

1、学习一门语言能力

2、通过该语言能力完成测试自动化以及独立完成自测框架知识

那么我要做什么呢？

1、3天内学习完第六章

要在什么地方做呢？

广州

那到底要怎么做呢？

完成基本的python3的基础知识，从而再学习测试框架

总结：

1、初步了解了面向对象和面向过程的内容

遗留问题：遗留作业未写

 

面向过程&面向对象

面向过程
面向过程：以事物流程为中心，核心是“过程”步骤,即,先干什么,后干什么.
优点:负责的问题流程化,编写相对简单
缺点:可扩展性差


面向对象 
定义：
面向对象：一切以对象为中心，万事万物皆是对象(object)
优点: 可扩展性强
缺点: 编程的复杂度高于面向过程

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

语法：

#object
#一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同

class Dog(object):
    print("hello,I am a dog!")

d = Dog()  # 实例化这个类，
# 此时的d就是类Dog的实例化对象
# 实例化，其实就是以Dog类为模版，在内存里开辟一块空间，存上数据，赋值成一个变量名

Encapsulation 封装
在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法

Inheritance 继承
定义：
#一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继
#面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
案例：

#class People: #经典类
class People(object):  # 新式类的标准语法
    def __init__(self,name,age):
        self.name = name
        self.age = age
        self.friends = []

    def eat(self):
        print("%s is age:%s eating...."%(self.name,self.age))

    def talk(self):
        print("%s is talking..."% self.name)

    def sleep(self):
        print("%s is sleeping..." % self.name)

class Relation(object):
    def make_friends(self,obj):
        print("%s is making friends with %s" %(self.name,obj.name))
        self.friends.append(obj)
class man(People,Relation):
    def __init__(self,name,age,money): #对函数进行重构，新增功能
        People.__init__(self,name,age) # 必须先调用父类的方法
        #super(man,self).__init__(name,age) #注：super是新式类的标准写法
        self.money = money  #增加新的功能
        print("%s一出生 %s就有%s块" %(self.name,self.age,self.money))
    def piao(self):
        print("%s 你好呀,%s" % (self.name,self.age))
    def sleep(self):
        print("man is sleeping...")
class Woman(People,Relation):
    def get_birth(self,obj):
        print("%s is bron a baby....." % self.name)

#m1 = People("yao",12)
# m1.eat()
# m1.talk()
# m1.sleep()
#
m2 = man("yao22",20,1000)
# m2.eat() #父类的方法
# m2.piao() #自己的方法
w1 = Woman("Zhangs",50)

m2.make_friends(w1)
w1.name = "张大炮" #和原来的name值没关系
print(m2.friends[0].name)  #遗留问题如何打印列表的值？

w1.name = "张三炮"
print(m2.friends[0])

 

Polymorphism 多态

定义：
多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。
这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定
py2 经典类是按深度优先来继承的，新式类是按广度优先来继承的
py3 经典类和新式类都是统一按广度优先继承的
一种接口，多种形态

class Animal(object):
    def __init__(self, name):  # Constructor of the class
        self.name = name

    def talk(self):  # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        print('%s: 喵喵喵!' % self.name)

class Dog(Animal):
    def talk(self):
        print('%s: 汪！汪！汪！' % self.name)


def func(obj):  # 一个接口，多种形态
    obj.talk()

c1 = Cat('小晴')
d1 = Dog('李磊')

func(c1)
func(d1)

 

类的实例化以及类变量和实例变量

定义：

实例化：类名加括号就是实例化，会自动触发__init__函数的运行,可用它来为每个实例定制自己的特征
self：在实例化时自动将对象/实例本身传给__init__的第一个参数.
总结:类与对象的关系:类是对事物的总结.抽象的概念.类用来描述对象.对象是类的实例化的结果.对象能执行哪些方法.都由类来决定.类中定义了什么.对象就拥有什么

案例：

class Role:   #构建类
    n=123    
    name = "我是类的变量name:yao"  #注意：类的变量
     # 构造方法 __init__(self) 在创建对象时自动访问这个方法 设置一些初始化的属性信息
    def __init__(self,name,role,weapon,life_value=100,money=15000):
         #初始化构造函数实
         #在实例化时，做一些实例化的工作
        self.name = name #注：实例变量（静态属性），作用域就是实例本身
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

# 调用下面的方法
    def shot(self):   #类的方法，功能（动态属性）
        print("shooting...")

    def got_shot(self):
        print("%s:ah...,I got shot..."% self.name)

    def buy_gun(self,gun_name):   # 定义方法可以新添参数
        print("just bought %s" %gun_name)


r1 = Role('Alex','police','AK47') #生成一个角色
r2 = Role('Jack','terrorist','B22')  #生成一个角色


r1.shot()
r1.got_shot() #Role.got_shot(r1)   结果一致
r1.buy_gun("buhaoya")

#类变量和实例变量的区别，先找自己实例变量，再找类变量
print(r1.name,r1.n)   #先找实例的变量，再找类的变量

 

构造函数和析构函数
常用内置函数：
 __init__:构造函数， 主要用来创建对象时初始化对象(为成员变量赋值)
 __del__:析构函数，主要在销毁对象时调用(例如数据库连接)

class Role:

    # 构造函数
    def __init__(self, name, role, weapon, life_value=100, money=15000):
        self.name = name
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money

    # 类的方法（动态属性）
    def buy_gun(self, gun_name):
        print("%s just bought %s" % (self.name, gun_name))

    def got_shot(self):
        print("ah...I got shot...")

    # 析构函数：在实例对象释放、销毁的时候自动执行
    def __del__(self):
        print("%s:彻底死了。。。" % self.name)


r1 = Role("Alex", "Policeman", "AK47")
r1.buy_gun("AK47")
r1.got_shot()
del r1 #删除实例r1

r2 = Role("Jack", "terrorist", "B22")
r2.buy_gun("B22")
r2.got_shot()