学习Python基础--------6面向对象

面对对象介绍

特性
class（类）
object（对象）

封装
续承
多态

语法
属性
方法
构造函数
析构函数
私有方法，私有属性

类变量
实例变量

 

编程范式

编程用特定的语法+数据结构+算法组成的代码告诉计算机如何执行任务，一个程序要为了得到一个任务结果的集合，有很多的方式来完成，对这些编程的方式的特点总结得出来的编程方式类别不同的编程范式本质上代表各种类型的任务采取的不同的解决思路大多数语言只支持一种编程范式当然也有些语言支持多种语言两种重要得的编程范式分别是面对过程编程和面对对象编程（还有函数式编程）

面对对象编程

就是程序从上到下一步一步执行，从都到尾的解决问题，基本思路就是程序一开始着手解决一个大问题，然后以个大问题分解为很多小问题或过程，分解到足够简单到可以一小步解决就是如果你要对程序进行改写，对你修改部分的依赖各部分你也要跟着修改所以写一些简单的脚本，去做一些一次性的任务，用面对过程式可以的，但如果你要处理任务是复杂的，且不需要递代和维护用面对对象比较方便

OOP编程是利用“类”和“对象”来创建各种模型来实现对真实世界的描述，使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

面向对象的几个核心特性如下

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

 

 

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

Encapsulation 封装
在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法，通过类造出来一个类不能访问他的属性只能访问者个类

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

Polymorphism 多态
多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，指一个基类中派生出了不同的子类，且每个子类在继承了同样的方法名的同时又对父类的方法做了不同的实现，这就是同一种事物表现出的多种形态。（一个统一的接口指挥）

面对对象编程介绍

# Author:Zhiyu Su

class Dog:
    def __init__(self,name):
        self.name= name

    def bulk(self):
        print('%s:wangwangwang'%self.name)

#类可以避免重复建立相同的对象
d1 = Dog('alex')
d2 = Dog('goob')
d3 = Dog('dog1')

d1.bulk()
d2.bulk()
d3.bulk()
#输出结果
#alex:wangwangwang
#goob:wangwangwang
#dog1:wangwangwang

 

无论用什么形式来编程，我们都要明确记住以下原则：

1. 写重复代码是非常不好的低级行为
2. 你写的代码需要经常变更 

开发正规的程序跟那种写个运行一次就扔了的小脚本一个很大不同就是，你的代码总是需要不断的更改，不是修改bug就是添加新功能等，所以为了日后方便程序的修改及扩展，你写的代码一定要遵循易读、易改的原则（专业数据叫可读性好、易扩展）。其实OOP编程的主要作用也是使你的代码修改和扩展变的更容易

# Author:Zhiyu Su

class Role(object):
    n = 123           #存储在类的内存里（类变量）
    name = '我是类的name'       #如果实例上没有name就会调用类的name
    #实例换传参数只能通过__init__
    def __init__(self,name,role,wepon,life_value=100,money=15000):
        #构造函数
        #在实例换是做一些类的初始化工作
        #实例化的同时把r1自动传入（r1=self ），变量的重复使用和全局调用
        # self.name = name
        self.role = role    #实例变量（静态属性），作用域就是实例本身
        self.wepon = wepon    #r2.wepon = wepon
        self.life_value = life_value
        self.money = money

    def shout(self):           #类本身也存在内存里 函数（公用的）也放在内存哪里
        print('shooting..')


    def got_shout(self):       #类的方法，功能（动态属性）
        print('%sah....,Igot shout...'%self.name)

    def buy_gun(self,gun_nae):
        print('%sjust ought %s'%(self.name,gun_nae))

#实例化（初始化一个类，造了一个对象）
#把一个类变成一个具体对象的过程叫实例化
r1 = Role('Alex','police','AK47')   #实例化将这些变量存在r1内存里（让r1在内存里长期存在持续调用）
r1.name = '321'    #这里改变变量是在r1内存里

r1.n = '改类变量'
print('r1:',r1.wepon,r1.n)
#r1改变n变量，是自己内存创建一个新的n（查找顺序先找实例再找类变量）
#如果n是列表    r1改变n也会改变r2的 因为r1r2都是公用list的地址




# print(r1.wepon)
# del r1.wepon     #删除白变量
# print(r1.wepon)
# # Role('Alex','police','AK47').got_shout()  #也可以运行调但用完之后直接销毁
# r1.got_shout()
# r1.buy_gun('b51')

r2 = Role('jack','terrorist','B22')  #生成角色
r2.name = 'ihi'
print(r2.n,r2.name)
print('r1:',r2.wepon,r2.n)



# r2.got_shout()  #Role.got_shout(r2)



print(Role.n)

 

语法

调用函数 ---》执行---》返回结果#你以为这样

r1 = Role.__init__()return#或者这样

r1 = Role(r1,'Alex','Police','15000')    #但却是这样

r1.name='Alex'

r1.role = "police"

r1.money = 15000

r1.buy_gun()  #Role.buy_gun(r1)

 

类变量的用途？ 大家公用的属性，节省开消

 

析构函数：在释放，销毁的时候执行的，通常用于做一些收尾工作，关闭一些数据,关闭一些临时文件

    def __del__(self):
        print('%s你死了。。。。'%self.name)
#123 ihi

#123
#321你死了。。。。运行结束 后调用__del__
#ihi你死了。。。。

私有方法，私有属性

class Role(object):
   
    def__init__(self,name,role,wepon,life_value=100,money=15000):
        #构造函数
       
        # self.name = name
        self.role = role    
        self.wepon = wepon    
        self.__life_value = life_value   #私有属性
        self.money = money
    def shot(self):
　　　　　print('shootinfg...')def show_status(self):           
        print('name:%s weapon%s  life_value%s'%(self.name,self.wepon,self.__life_value))
　　　　　#函数内部可以调用私有属性
r1 = Role('Alex','police','AK47')
r1.__file_value#外部调用无法使用
r1.show_status()#内部函数调用可以
r1.shot()#外部也无法调用私有方法

继承

# Author:Zhiyu Su

# class People:经典类
class People(object):#新式类的写法

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def eat(self):
        print(('%s is eating ...'%self.name))

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

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

class Relation(object):
    def make_frinds(self,obj):
        print('%s is making friends with %s'%(self.name,obj.name))
class Man(People,Relation):
    #构造函数父类都要重写一遍
    def __init__(self,name,age,money):
        # People.__init__(self,name,age)
        super(Man, self).__init__(name,age)
        self.money = money
        print('%s 一出生就有%s'%(self.name,self.money))
    def chi(self):
        print('%s is chi....'%self.name)

    def sleep(self):
        People.sleep(self)
        print(' Man is sleeping...' )
class Woman(People,Relation):
    def get_birth(self):
        print('%s is born a baby...'%self.name)

m1 = Man('张二',22,10)
# m1.eat()
# m1.chi()
# m1.sleep()  #张二 is sleeping... Man is sleeping...


w1 = Woman('网墨子',26)
# w1.get_birth()

m1.make_frinds(w1)

续承实例

__author__ = "Alex Li"

class School(object):
    def __init__(self,name,addr):
        self.name = name
        self.addr = addr
        self.students =[]
        self.staffs =[]
    def enroll(self,stu_obj):
        print("为学员%s 办理注册手续"%stu_obj.name )
        self.students.append(stu_obj)
    def hire(self,staff_obj):
        self.staffs.append(staff_obj)
        print("雇佣新员工%s" % staff_obj.name)

class SchoolMember(object):
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def tell(self):
        pass

class Teacher(SchoolMember):
    def __init__(self,name,age,sex,salary,course):
        super(Teacher,self).__init__(name,age,sex)
        self.salary = salary
        self.course = course
    def tell(self):
        print('''
        ---- info of Teacher:%s ----
        Name:%s
        Age:%s
        Sex:%s
        Salary:%s
        Course:%s
        '''%(self.name,self.name,self.age,self.sex,self.salary,self.course))

    def teach(self):
        print("%s is teaching course [%s]" %(self.name,self.course))

class Student(SchoolMember):
    def __init__(self,name,age,sex,stu_id,grade):
        super(Student,self).__init__(name,age,sex)
        self.stu_id = stu_id
        self.grade = grade
    def tell(self):
        print('''
        ---- info of Student:%s ----
        Name:%s
        Age:%s
        Sex:%s
        Stu_id:%s
        Grade:%s
        ''' % (self.name, self.name, self.age, self.sex, self.stu_id, self.grade))
    def pay_tuition(self,amount):
        print("%s has paid tution for $%s"% (self.name,amount) )


school = School("老男孩IT","沙河")

t1 = Teacher("Oldboy",56,"MF",200000,"Linux")
t2 = Teacher("Alex",22,"M",3000,"PythonDevOps")

s1 = Student("ChenRonghua",36,"MF",1001,"PythonDevOps")
s2 = Student("徐良伟",19,"M",1002,"Linux")


t1.tell()
s1.tell()
school.hire(t1)
school.enroll(s1)
school.enroll(s2)

print(school.students)
print(school.staffs)
school.staffs[0].teach()

for stu in school.students:
    stu.pay_tuition(5000)

多态

一种借口，多种实现

__author__ = "Alex Li"


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

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

    @staticmethod
    def animal_talk(obj):
        obj.talk()

class Cat(Animal):
    def talk(self):
        print('Meow!')


class Dog(Animal):
    def talk(self):
        print('Woof! Woof!')


d = Dog("陈荣华")
#d.talk()

c = Cat("徐良伟")
#c.talk()
#
# def animal_talk(obj):
#     obj.talk()

Animal.animal_talk(c)
Animal.animal_talk(d)