python 继承与组合
一、组合
#老师 课程 生日
class Course:
def __init__(self,name,period,price):
self.name = name
self.period = period
self.price = price class Birth:
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day class Teacher:
def __init__(self,name,salary,boy_friend,python):
self.name = name
self.salary = salary
self.bf = boy_friend
self.course = python python = Course('python','6 months',20000) egg = Teacher('egon',200,'yuan',python)
print(egg.bf)
print(egg.name)
print(egg.course.name) egg_birth = Birth(1965,2,2)
print(egg_birth.year)
egg.birth = egg_birth
print('***',egg.birth.year)
二、继承(什么是什么的关系)
什么是继承
继承是一种创建新类的方式,在python中,新建的类可以继承一个或多个父类,父类又可称为基类或超类,新建的类称为派生类或子类
python中类的继承分为:单继承和多继承
class ParentClass1: #定义父类
pass class ParentClass2: #定义父类
pass class SubClass1(ParentClass1): #单继承,基类是ParentClass1,派生类是SubClass
pass class SubClass2(ParentClass1,ParentClass2): #python支持多继承,用逗号分隔开多个继承的类
pass
查看继承
>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类,__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)
提示:如果没有指定基类,python的类会默认继承object类,object是所有python类的基类,它提供了一些常见方法(如__str__)的实现。
>>> ParentClass1.__bases__
(<class 'object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)
继承与抽象(先抽象再继承)
抽象即抽取类似或者说比较像的部分。
抽象分成两个层次:
1.将奥巴马和梅西这俩对象比较像的部分抽取成类;
2.将人,猪,狗这三个类比较像的部分抽取成父类。
抽象最主要的作用是划分类别(可以隔离关注点,降低复杂度)
继承:是基于抽象的结果,通过编程语言去实现它,肯定是先经历抽象这个过程,才能通过继承的方式去表达出抽象的结构。
抽象只是分析和设计的过程中,一个动作或者说一种技巧,通过抽象可以得到类
继承与重用性
==========================第一部分
例如 猫可以:喵喵叫、吃、喝、拉、撒 狗可以:汪汪叫、吃、喝、拉、撒 如果我们要分别为猫和狗创建一个类,那么就需要为 猫 和 狗 实现他们所有的功能,伪代码如下: #猫和狗有大量相同的内容
class 猫: def 喵喵叫(self):
print '喵喵叫' def 吃(self):
# do something def 喝(self):
# do something def 拉(self):
# do something def 撒(self):
# do something class 狗: def 汪汪叫(self):
print '汪汪叫' def 吃(self):
# do something def 喝(self):
# do something def 拉(self):
# do something def 撒(self):
# do something ==========================第二部分
上述代码不难看出,吃、喝、拉、撒是猫和狗都具有的功能,而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想,如下实现: 动物:吃、喝、拉、撒 猫:喵喵叫(猫继承动物的功能) 狗:汪汪叫(狗继承动物的功能) 伪代码如下:
class 动物: def 吃(self):
# do something def 喝(self):
# do something def 拉(self):
# do something def 撒(self):
# do something # 在类后面括号中写入另外一个类名,表示当前类继承另外一个类
class 猫(动物): def 喵喵叫(self):
print '喵喵叫' # 在类后面括号中写入另外一个类名,表示当前类继承另外一个类
class 狗(动物): def 汪汪叫(self):
print '汪汪叫' ==========================第三部分
#继承的代码实现
class Animal: def eat(self):
print("%s 吃 " %self.name) def drink(self):
print ("%s 喝 " %self.name) def shit(self):
print ("%s 拉 " %self.name) def pee(self):
print ("%s 撒 " %self.name) class Cat(Animal): def __init__(self, name):
self.name = name
self.breed = '猫' def cry(self):
print('喵喵叫') class Dog(Animal): def __init__(self, name):
self.name = name
self.breed='狗' def cry(self):
print('汪汪叫') # ######### 执行 ######### c1 = Cat('小白家的小黑猫')
c1.eat() c2 = Cat('小黑的小白猫')
c2.drink() d1 = Dog('胖子家的小瘦狗')
d1.eat() 使用继承来重用代码比较好的例子 使用继承来解决代码重用的例子
在开发程序的过程中,如果我们定义了一个类A,然后又想新建立另外一个类B,但是类B的大部分内容与类A的相同时
我们不可能从头开始写一个类B,这就用到了类的继承的概念。
通过继承的方式新建类B,让B继承A,B会‘遗传’A的所有属性(数据属性和函数属性),实现代码重用
在开发程序的过程中,如果我们定义了一个类A,然后又想新建立另外一个类B,但是类B的大部分内容与类A的相同时
我们不可能从头开始写一个类B,这就用到了类的继承的概念。
通过继承的方式新建类B,让B继承A,B会‘遗传’A的所有属性(数据属性和函数属性),实现代码重用
c
'''__bases__查看继承(什么是什么的关系)的父类'''
# class Parent1:
# pass
# class Parent2:
# pass
# class Subclass1(Parent1, Parent2): # 继承
# pass
# print(Subclass1.__bases__)
'''父类'''
# class Hero:
# camp = 'dename'
# def __init__(self, nickname, life_value, aggresivity):
# self.nickname = nickname
# self.life_value = life_value
# self.aggresivity = aggresivity
# def attack(self, one):
# one.life_value -= self.aggresivity
# class Jie(Hero):
# pass
# class Mangsheng(Hero):
# pass
# j1 = Jie('lihao', 100, 20)
# print(j1.__dict__)
'''属性查找'''
# class Foo:
# def f1(self):
# print('Foo.f1')
#
# def f2(self):
# print('Foo.f2')
# self.f1()
# class Bar(Foo):
# def f1(self):
# print('Bar.f1')
# b = Bar()
# b.f2()
提示:用已经有的类建立一个新的类,这样就重用了已经有的软件中的一部分设置大部分,大大生了编程工作量,这就是常说的软件重用,不仅可以重用自己的类,也可以继承别人的,比如标准库,来定制新的数据类型,这样就是大大缩短了软件开发周期,对大型软件开发来说,意义重大.
派生
当然子类也可以添加自己新的属性或者在自己这里重新定义这些属性(不会影响到父类),需要注意的是,一旦重新定义了自己的属性且与父类重名,那么调用新增的属性时,就以自己为准了。
class Animal:
'''
人和狗都是动物,所以创造一个Animal基类
'''
def __init__(self, name, aggressivity, life_value):
self.name = name # 人和狗都有自己的昵称;
self.aggressivity = aggressivity # 人和狗都有自己的攻击力;
self.life_value = life_value # 人和狗都有自己的生命值; def eat(self):
print('%s is eating'%self.name) class Dog(Animal):
'''
狗类,继承Animal类
'''
def bite(self, people):
'''
派生:狗有咬人的技能
:param people:
'''
people.life_value -= self.aggressivity class Person(Animal):
'''
人类,继承Animal
'''
def attack(self, dog):
'''
派生:人有攻击的技能
:param dog:
'''
dog.life_value -= self.aggressivity egg = Person('egon',10,1000)
ha2 = Dog('二愣子',50,1000)
print(ha2.life_value)
print(egg.attack(ha2))
print(ha2.life_value)
注意:像ha2.life_value之类的属性引用,会先从实例中找life_value然后去类中找,然后再去父类中找...直到最顶级的父类。
在子类中,新建的重名的函数属性,在编辑函数内功能的时候,有可能需要重用父类中重名的那个函数功能,应该是用调用普通函数的方式,即:类名.func(),此时就与调用普通函数无异了,因此即便是self参数也要为其传值.
在python3中,子类执行父类的方法也可以直接用super方法.
'''派生'''
# class Hero:
# def __init__(self, nickname, life_value, aggresivity):
# self.nickname = nickname
# self.life_value = life_value
# self.aggresivity = aggresivity
# def attack(self, one):
# one.life_value -= self.aggresivity
# class Jie(Hero):
# camp = 'huoyingjie' # 派生,自己有的,不继承,方法也一样
# class Mangsheng(Hero):
# camp = 'xiazi'
#
# j1 = Jie('lihao', 100, 20)
# print(j1.__dict__)
'''派生中重用父类的属性
1.直接指名道姓(不依赖于继承)'''
# class Hero:
# def __init__(self, nickname, life_value, aggresivity):
# self.nickname = nickname
# self.life_value = life_value
# self.aggresivity = aggresivity
# def attack(self, one):
# one.life_value -= self.aggresivity
# class Jie(Hero):
# camp = 'huoyingjie' # 派生,自己有的,不继承,方法也一样
# def __init__(self, nickname, life_value, aggresivity, wapen):
# Hero.__init__(nickname, life_value, aggresivity)
# self.wapen = wapen
# def attack(self, one):
# Hero.attack(self, one)
# print('from Jie class')
# class Mangsheng(Hero):
# camp = 'xiazi'
# j1 = Jie('qwe', 100, 20, '双刀')
# m1 = Mangsheng('li', 120, 50)
# j1.attack(m1)
# print(j1.__dict__)
# print(m1.__dict__)
'''2.super() (依赖于继承)(按照mro列表查找)'''
# class Hero:
# def __init__(self, nickname, life_value, aggresivity):
# self.nickname = nickname
# self.life_value = life_value
# self.aggresivity = aggresivity
# def attack(self, one):
# one.life_value -= self.aggresivity
# class Jie(Hero):
# camp = 'huoyingjie'
# def __init__(self, nickname, life_value, aggresivity, wapen):
# super(Jie, self).__init__(nickname, life_value, aggresivity) # 依赖继承,按mro列表查找
# # super().__init__(nickname, life_value, aggresivity) # 简写
# self.wapen = wapen
# def attack(self, one):
# super(Jie, self).attack(one) # 依赖继承
# print('from Jie class')
# class Mangsheng(Hero):
# camp = 'xiazi'
# j1 = Jie('qwe', 100, 20, '双刀')
# m1 = Mangsheng('asd', 120, 50)
# j1.attack(m1)
# print(m1.__dict__)
# print(j1.__dict__)
'''A没有继承B,但是A内super会基于C.mro()继续往后找'''
# class A:
# def test(self):
# print('from A')
# super().test()
# class B:
# def test(self):
# print('from B')
# class C(A,B):
# pass
#
# c=C()
# c.test() #打印结果:from B
#
# print(C.mro())
# #[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
通过继承建立了派生类与基类之间的关系,它是一种'是'的关系,比如白马是马,人是动物。
当类之间有很多相同的功能,提取这些共同的功能做成基类,用继承比较好,比如教授是老师
>>> class Teacher:
... def __init__(self,name,gender):
... self.name=name
... self.gender=gender
... def teach(self):
... print('teaching')
...
>>>
>>> class Professor(Teacher):
... pass
...
>>> p1=Professor('egon','male')
>>> p1.teach()
teaching
# class Animal: #父类 基类 超类
# def __init__(self,name,life_value,aggr):
# self.name = name
# self.life_value = life_value
# self.aggr = aggr
#
#
# class Person(Animal): #子类 派生类
# pass
#
# class Dog(Animal): #子类 派生类
# pass # egg = Person('egon',1000,50)
# print(egg.name)
# print(egg.aggr) # class Dad:pass
#
# class Ma:pass
#
# class Son1(Dad,Ma):pass
#
# class Son2(Dad):pass # print(Son1.__bases__)
# print(Son2.__bases__)
print(Dad.__bases__)
#python2
#class Dad: #经典类
#class Dag(object) #新式类 #python3
#class Dad == class Dag(object) #新式类 #抽象 : 范围越来越大,共性越来越少
#属性
#方法
#提取一类事物的特点
#外国人 --> 毛多
#人 --> sex,name #继承
# class Pet:
# def eat(self):
# pass
# def sleep(self):
# pass
# def drink(self):
# pass
#
# class Cat(Pet): #Pet类的一个派生类,也叫子类
# def catch(self): #Pet类的一个派生方法
# pass
#
# class Dog(Pet):
# def watch_door(self):pass
#
# 中华气死猫 = Cat()
# 中华气死猫.catch()
# 中华气死猫.eat() class Animal: #父类 基类 超类
def __init__(self,name,life_value,aggr):
self.name = name
self.life_value = life_value
self.aggr = aggr #攻击力
def eat(self):
self.life_value += 10 class Person(Animal): #子类 派生类
def __init__(self,money,name,life_value,aggr):
super().__init__(name,life_value,aggr)
self.money = money #派生属性 def attack(self,enemy): #人的派生方法
enemy.life_value -= self.aggr class Dog(Animal): #子类 派生类
def __init__(self,breed,name,life_value,aggr):
#Animal.__init__(self,name,life_value,aggr) #让子类执行父类的方法,就是父类名.方法名(参数),连self也得传
super().__init__(name,life_value,aggr) #super关键字——新式类
#super(Dog,self).__init__(name,life_value,aggr) #super关键字关键字——新式类
self.breed = breed
def bite(self,person): #狗的派生方法
person.life_value -= self.aggr def eat(self): # 父类方法的重写
super().eat()
print('dog is eating~~~ ') ha2 = Dog('牛头梗','旺财',20000,100)
print(ha2.life_value)
ha2.eat()
print(ha2.life_value)
# super(Dog,ha2).eat() #调用父类的
print(ha2.life_value) #egon老师的生日 是不是birth类的一个实例
#egon.birth = Birth() #组合 #在继承中
#继承的语法:
# class 类名(父类名):
# 想在子类中实现调用父类的方法
#在类内 ——super(子类名,self).方法名()
#在类外面 ——super(子类名,对象名).方法名()
#如果不指定继承的父类,默认继承object
#子类可以使用父类的所有属性和方法
#如果子类有自己的方法就执行自己的的
#如果是子类没有的方法就执行父类的
#如果子类父类都没有这个方法就报错 #继承、抽象、派生
#继承 是从大范围到小范围
#抽象 小范围到大范围
#派生 就是在父类的基础上又产生子类——派生类
#父类里没有的 但子类有的 ——派生方法
#派生属性
#方法的重写
#父类里有的方法,在子类里重新实现
'''组合
用组合的方式建立了类与组合的类之间的关系,它是一种‘有’的关系,比如教授有生日,教授教python课程'''
# class BirthDate:
# def __init__(self,year,month,day):
# self.year=year
# self.month=month
# self.day=day
#
# class Couse:
# def __init__(self,name,price,period):
# self.name=name
# self.price=price
# self.period=period
#
# class Teacher:
# def __init__(self,name,gender):
# self.name=name
# self.gender=gender
# def teach(self):
# print('teaching')
#
# class Professor(Teacher):
# def __init__(self, name, gender, birth, course):
# Teacher.__init__(self, name, gender)
# self.birth = birth
# self.course = course
#
# p1=Professor('egon','male',
# BirthDate('1995','1','27'),
# Couse('python','28000','4 months'))
#
# print(p1.birth.year,p1.birth.month,p1.birth.day)
# print(p1.course.name,p1.course.price,p1.course.period)
'''当类之间有显著不同,并且较小的类是较大的类所需要的组件时,用组合比较好'''
python 继承与组合的更多相关文章
- Python 继承和组合 接口
#解决代码重用的问题,减少代码冗余 #继承是一种什么'是'什么的关系 class People: def __init__(self, name, age): # print('People.__in ...
- 【Python基础】lpthw - Exercise 44 继承与组合
一.继承 原则:大部分使用继承的场合都可以用组合取代或者简化,而多重继承则需要不惜一切的避免. 1. 什么是继承 继承:用于指明一个类的大部分或者全部功能都是从一个父类获得的.此时,父类的实例的所有动 ...
- Python面向对象的三大特性之继承和组合
继承和组合 一.组合 组合:组合指的是,在一个类中以另外一个类的对象(也就是实例)作为数据属性,称为类的组合 也就是说:一个类的属性是另一个类的对象,就是组合 例子: 圆环是由两个圆组成的,圆环的面积 ...
- Python 入门基础20 --面向对象_继承、组合
今日内容 组合:自定义类的对象作为类的属性 继承:父类与子类.多继承 1.组合 将自定义类的对象作为类的属性 class Teacher: def __init__(self, name): self ...
- 7 python 类的组合
1.组合与重用性 软件重用的重要方式除了继承之外还有另外一种方式,即:组合 组合指的是,在一个类中以另外一个类的对象作为 1.一个类的属性可以是一个类对象,通常情况下在一个类里面很少定义一个对象就是它 ...
- 关于Java中的继承和组合的一个错误使用的例子
[TOC] 关于Java中的继承和组合的一个错误使用的例子 相信绝大多数人都比较熟悉Java中的「继承」和「组合」这两个东西,本篇文章就主要就这两个话题谈论一下.如果我某些地方写的不对,或者比较幼稚, ...
- Java继承与组合
Java继承与组合 继承 java 中使用extends关键字表示继承关系,当创建一个类时,如果没有明确指出要继承的类,则是隐式地从根类Object进行继承. 子类继承父类的成员变量 子类能够继承父类 ...
- [Think In Java]基础拾遗1 - 对象初始化、垃圾回收器、继承、组合、代理、接口、抽象类
目录 第一章 对象导论第二章 一切都是对象第三章 操作符第四章 控制执行流程第五章 初始化与清理第六章 访问权限控制第七章 复用类第九章 接口 第一章 对象导论 1. 对象的数据位于何处? 有两种方式 ...
- python 继承中的super
python继承中子类访问父类的方法(包括__init__)主要有两种方法,一种是调用父类的未绑定方法,另一种是使用super(仅仅对于新式类),看下面的两个例子: #coding:utf-8 cla ...
随机推荐
- JMS 之 Active MQ 的spring整合
一.与spring整合实现ptp的同步接收消息 pom.xml: <!-- https://mvnrepository.com/artifact/org.springframework/spri ...
- 4.4.6 数组也能无锁:AtomicIntegerArray
数组也可以实现cas操作,有以下几个类以及用法如下: public class AtomicTntegerArrayTest { public static void main(String[] ar ...
- [GO]使用bufio的文件读取方式
package main import ( "os" "fmt" "bufio" "io" ) func ReadFil ...
- 如何使用office2016发布CSDN博客
目前大部分的博客作者在用Word写博客这件事情上都会遇到以下3个痛点: 1.所有博客平台关闭了文档发布接口,用户无法使用Word,Windows Live Writer等工具来发布博客.使用Word写 ...
- 《html5 从入门到精通》读书笔记(二)
接着上面继续记录笔记,这次要记的知识点比较多...记录下我认为比较重要的东西. 一.表单属性 1.autocomplete属性 该属性规定form或input域应该拥有自动完成功能. <form ...
- Nutch2.2.1,window,eclipse,安装
教程:https://app.yinxiang.com/shard/s12/sh/36b8e911-2d0e-4ee4-b34f-a426c6dc99c2/9543f94cd8abf12b4b9857 ...
- python版本selenium定位方式(不止八种哦)
除了大家熟知的8种定位方式之外 1.id定位:find_element_by_id(self, id_)2.name定位:find_element_by_name(self, name)3.class ...
- win7 64 VC++ ado方式连接access 连接字符串
运行环境:win7 64 vc++6.0 office 2007 32位(access 2007) 我用的是ado方式连接access数据库,(现在的Win7系统中安装的一般 ...
- tomcat异常 Socket bind failed: [730048]
tomcat从官网站点下载时须注意版本信息: zip格式为window压缩版. tar.gz为linux安装板. installer为window安装板. 解压后的各文件功能与作用: bin:用于放置 ...
- SDOI2013 淘金
题目链接:戳我 昨天做的题了,今天补一发题解. 是一个比较奇怪的数位DP.详细的我还是写代码注释里好了,感觉直接说不好描述. 代码如下: #include<iostream> #inclu ...