文章目录
- 1. 字典增删
- 2. 模块、类、对象
- 2.1 一个类的例子
- 3.继承和组合
- 3.1 什么是继承
- 3.1.1 隐式继承
- 3.1.2 显式覆盖
- 3.1.3 在运行前或运行后替换
- 3.1.4 三种方式组合使用
- 3.2 组合
- 3.3 继承和组合的应用场合
1. 字典增删
stuff
=
{
"name"
:
"jack"
,
"age"
:
"18"
,
"height"
:
"180"
}
stuff
[
"city"
]
=
"beijing"
print
(
stuff
)
del
stuff
[
"city"
]
print
(
stuff
)
2. 模块、类、对象
- 模块通过import调用，调用之后就可以使用模块里面的函数、变量等。就比如，import sklearn。
- 类、实例化、对象
class
mystuff
(
)
:
# 对象初始化
def
__init__
(
self
)
:
self
.
tangerine
=
"hhhhhhhhhh"
def
apple
(
self
)
:
print
(
"i am superman"
)
thing
=
mystuff
(
)
# 实例化，得到thing这个对象。
thing
.
apple
(
)
print
(
thing
.
tangerine
)
将类实例化就会得到对象，可以对对象调用函数等操作。
2.1 一个类的例子
class
Song
(
object
)
:
def
__init__
(
self
,
lyrics
)
:
self
.
lyrics
=
lyrics
def
sing_me_a_song
(
self
)
:
for
line
in
self
.
lyrics
:
print
(
line
)
happy_baby
=
Song
(
[
"happy birthday to you"
,
"happy new year"
]
)
happy_baby
.
sing_me_a_song
(
)
3.继承和组合
大部分使用继承的场合都可以使用组合取代或简化，而多重继承则需要不惜一切地避免。
3.1 什么是继承
继承就是指一个类地大部分或全部功能是从一个父类中获得的，父类和字类有三种交互方式：
- 子类上的动作完全等同于父类上的动作
- 子类上的动作完全覆盖父类上的动作
- 子类上的动作部分替换了父类上的动作
3.1.1 隐式继承
# 隐式继承
class
parent
(
object
)
:
def
implicit
(
self
)
:
print
(
"parent implicit()"
)
class
child
(
parent
)
:
pass
dad
=
parent
(
)
.
implicit
(
)
child
=
child
(
)
.
implicit
(
)
结果如图：
3.1.2 显式覆盖
class
parent
(
object
)
:
def
override
(
self
)
:
print
(
"parent override()"
)
class
child
(
parent
)
:
def
override
(
self
)
:
print
(
"child override()"
)
dad
=
parent
(
)
.
override
(
)
child
=
child
(
)
.
override
(
)
结果如图：
3.1.3 在运行前或运行后替换
class
parent
(
object
)
:
def
altered
(
self
)
:
print
(
"parent altered()"
)
class
child
(
parent
)
:
def
altered
(
self
)
:
print
(
"child, before parent altered()"
)
super
(
child
,
self
)
.
altered
(
)
print
(
"child,after parent altered()"
)
parent
(
)
.
altered
(
)
child
(
)
.
altered
(
)
super(child,self)还保留着继承关系，因此通过继承父类之后，通过.altered()调用了父类的altered函数。
结果如图：
3.1.4 三种方式组合使用
class
parent
(
)
:
def
override
(
self
)
:
print
(
"parent override()"
)
def
implicit
(
self
)
:
print
(
"parent implicit()"
)
def
altered
(
self
)
:
print
(
"parent altered()"
)
class
child
(
parent
)
:
def
override
(
self
)
:
print
(
"child override()"
)
def
altered
(
self
)
:
print
(
"child, before parent altered()"
)
super
(
child
,
self
)
.
altered
(
)
print
(
"child,after parent altered()"
)
dad
=
parent
(
)
son
=
child
(
)
dad
.
implicit
(
)
son
.
implicit
(
)
dad
.
override
(
)
son
.
override
(
)
dad
.
altered
(
)
son
.
altered
(
)
结果如下：
3.2 组合
class
other
(
object
)
:
def
override
(
self
)
:
print
(
"other override()"
)
def
implicit
(
self
)
:
print
(
"other implicit()"
)
def
altered
(
self
)
:
print
(
"other altered()"
)
class
child
(
object
)
:
def
__init__
(
self
)
:
self
.
other
=
other
(
)
def
implicit
(
self
)
:
self
.
other
.
implicit
(
)
def
override
(
self
)
:
print
(
"child override()"
)
def
altered
(
self
)
:
print
(
"child, before parent altered()"
)
self
.
other
.
altered
(
)
print
(
"child,after parent altered()"
)
son
=
child
(
)
son
.
implicit
(
)
son
.
override
(
)
son
.
altered
(
)
这里不是使用了继承的方法，而是，child里面有一个other()用来实现继承的功能。
结果如下：
3.3 继承和组合的应用场合
继承和组合说到底都是为了解决关于代码重复的问题。
每个人的代码风格不同，这里仅代表一点建议：
- 不惜一切避免多重继承。
- 如果一些代码会在不同位置和场合用到，建议用组合。
- 只有在代码的可复用部分之间有明确清楚的联系的时候，可以通过一个单独的共性联系起来的时候，才用继承。
