python学习之面向对象学习

Posted 2020-09-22

一、什么事面向对象，以及面向对象的优点？
面向过程优缺点:
我们知道面向过程是流水线式的编程，过程就是解决问题的步骤，把大的问题化解成小的模块
面向过程优点: 极大的降低了程序的复杂度
面向过程缺点: 牵一发而动全身, 所以完成一个模块很少改动，否则改动的地方比较多

面向对象优缺点:
面向对象编程的核心是对象，由属性和函数构成
面向对象优点: 解决程序的扩展性，对某个类的修改能反映到整个体系中

类的语法结构:
class 类名:
    类体
    
例子:
class People:
    language = ‘Chinese‘
    def func(self):    #self把对象自身传进去
        pass

p1 = People
p2 = People
print(p1.language)
print(p2.language)
p1.language = ‘english‘
print(p1.language)    #输出english
print(p2.language)    #输出english

注: 所有对象共用类的属性，所以p2也输出english

初始化类__init__
例子:
class Garen:
    camp=‘Demacia‘
    def __init__(self,nickname, aggressivity=58,life_value=456):
        self.nickname = nickname
        self.aggressivity = aggressivity
        self.life_value = life_value
        
    def attack(self,enemy):
        enemy.life_value -= self.aggressivity
hero = Garen(‘garen‘, 100, 600)    #加括号初始化类对象
print(isinstance(hero, Garen))    #isinstance判断hero是否是类Garen的实例,是则返回True，否则返回False
print(Garen.__name__)   #类的名称
print(Garen.__doc__)    #类的文档字符串
print(Garen.__base__)   #类的第一个父类
print(Garen.__bases__)  #类的所有父类构成的元组
print(Garen.__dict__)   #类的字典属性
print(Garen.__module__) #类定义所在的模块
print(Garen.__class__)  #实例对应的类

将函数绑定到对象上叫做对象的方法，并且会把自身传递给函数作为第一个参数

对象的交互:
class Riven:
    camp = ‘Noxus‘
    def __init__(self, nickname, aggressivity=54,life_value=300):
        self.nickname = nickname
        self.aggressivity = aggressivity
        self.life_value = life_value

    def attack(self,enemy):
        enemy.life_value -= self.aggressivity

r1 = Riven(‘瑞问问‘)

print(hero.life_value)
r1.attack(hero)
print(hero.life_value)
print(id(r1.attack))    #id打印函数位置
print(id(Riven.attack))

类有两种属性:数据属性和函数属性，数据属性共享给所有对象。
方法是绑定到所有对象上的，并且对象会传递给函数
创建对象就是创建了一个命名空间，对象会先找自己的命名空间，再找类的命名空间



二、继承
继承是一种创建新类的方式
继承的好处，减少代码冗余，
子类覆盖父类的方法叫做派生

例子:
class ParentClass1:
    pass

class ParentClass2:
    pass

class SubClass1(ParentClass1):
    pass
class SubClass2(ParentClass1,ParentClass2):
    pass

print(SubClass1.__bases__)    #打印父类
print(SubClass2.__bases__)    #打印父类


继承关系如图:

F->A->E-B->D->C

F->D->B-E->C->H->A

派生类
例子:
class Animal:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self):
        print(‘eating‘)

    def talk(self):
        print(‘%s 正在叫‘ %self.name)

class People(Animal):
    def __init__(self,name,age,sex,education):
        Animal.__init__(self,name,age,sex)
        self.education = education

    def talk(self):
        Animal.talk(self)
        print(‘%s say hello‘ %self.name)

class Pig(Animal):
    pass

class Dog(Animal):
    pass

peo1 = People(‘hyh‘,20,‘male‘,‘小学毕业‘)
pig1 = Pig(‘zhangsan‘, 16, ‘male‘)
dog1 = Dog(‘lisi‘, 16, ‘female‘)
peo1.talk()
pig1.talk()
dog1.talk()
print(isinstance(peo1, People))    #判断peo1是否是People类，返回True或False
print(isinstance(pig1, Pig))        #继承反映的什么是什么的关系
print(isinstance(dog1, Dog))
通过__dict__获取属性
class Sub:
    def __init__(self):
        self.bar = 123
    def bar(self):
        print(‘Sub.bar‘)

s = Sub()
print(s.__dict__)
print(s.__dict__[‘bar‘])

组合: 在一个类中，以另外一个类的对象作为数据属性，称为类的组合，组合反映的是什么有什么的关系,
例子:
class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
class Date:
    def __init__(self,year,mon,day):
        self.year = year
        self.mon = mon
        self.day = day

    def tell(self):
        print(‘%s-%s-%s‘ %(self.year,self.mon,self.day))

class Teacher(People):
    def __init__(self,name,age,sex,salary,year,mon,day):
        self.name = name
        self.age = age
        self.sex = sex
        self.salary = salary
        self.birth = Date(year,mon,day)

class Student(People):
    def __init__(self,name,age,sex,year,mon,day):
        self.name=name
        self.age=age
        self.sex=sex
        self.birth=Date(year,mon,day)

t=Teacher(‘egon‘,18,‘male‘,3000,1995,12,31)
t.birth.tell()


定义类模拟接口
例子:
class File:
    def read(self):
        raise TypeError(‘类型错误‘)

    def write(self):
        raise TypeError(‘类型错误‘)

class Txt(File):
    def read(self):
        print(‘文本数据的读取方法‘)

    def write(self):
        print(‘文本数据的读取方法‘)

class Sata(File):
    def read(self):
        print(‘硬盘数据的读取方法‘)

    def wirte(self):
        print(‘硬盘数据的读取方法‘)

class Process(File):
    def read(self):
        print(‘进程数据的读取方法‘)

    def write(self):
        print(‘进程数据的读取方法‘)

p = Process()
p.read()
t = Txt()
d = Sata()
print(isinstance(p, Process))
print(isinstance(t, Txt))
print(isinstance(d, Sata))

注: File类定义功能函数，Txt,Sata,Process分别定义实现函数的方法

调用父类用super方法
例子:
class Foo1:
    def test(self):
        print("from foo1.test")

class Foo2:
    def test(self):
        print(‘from foo2.test‘)

class Bar(Foo1,Foo2):
    def test(self):
        super().test()
        print(‘Bar‘)
b = Bar()
b.test()

三、封装

封装：主要为了保护数据的隐私，而把数据隐藏起来，只能通过接口去访问
类中通过__双下划线来隐藏数据属性和函数属性，含有__x的属性都会变成_类名__x的形式：

Foo:
    __x = __test():   ()
(Foo.)

封装实例:
class People:
    __country = ‘China‘
    
def __init__(self,name,age,sex):
    self.__name = name  
#self._People__name = name
   self.__age = age
    self.__sex = sex
    
def tell_info(self):
    print(‘人的名字是：%s， 人的年龄是: %s, 人的性别是: %s‘ %(self.__name, self.__age, self.__sex))
p = People(‘alex‘, 29, ‘male‘)
print(p.__dict__)
p.tell_info()

注: 封装只在定义时检查语法
p.__x = 1
print(p.__x)    #打印1

修改属性接口
class People:
    def __init__(self,name,age):
        self.__name = name
        self.__age = age

    def tell_info(self):
        print(‘人的名字是: %s, 人的年龄是: %s‘ %(self.__name, self.__age))

    def set_info(self,x, y):
        if not isinstance(x, str):
            raise TypeError(‘名字必须是字符串‘)
        if not isinstance(y, int):
            raise TypeError(‘年龄必须是整数‘)

        self.__name = x
        self.__age = y

p = People(‘alex‘, 20)
p.tell_info()
p.set_info(‘hyh‘, 18)
p.tell_info()

四、类装饰器

本文出自 “linux技术” 博客，请务必保留此出处http://haoyonghui.blog.51cto.com/4278020/1934677