6.python基础（三）

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 继承和组合的应用场合

继承和组合说到底都是为了解决关于代码重复的问题。
每个人的代码风格不同，这里仅代表一点建议：

• 不惜一切避免多重继承。
• 如果一些代码会在不同位置和场合用到，建议用组合。
• 只有在代码的可复用部分之间有明确清楚的联系的时候，可以通过一个单独的共性联系起来的时候，才用继承。