Python基础知识-pycharm版-07

方法没有重载

在python中严禁使用重名的方法。python中没有重载。如果重复定义，只有最后一个有效。

私有属性和私有方法（实现封装）

1.通常我们约定，两个下划线开头的属性是私有的（private）；
2.类内部可以访问私有属性（方法）；
3.类外部不能直接访问私有属性（方法）；
4.类外部可以通过“__类名__私有属性（方法）名”访问私有属性（方法）。
方法的本质也是属性，上面的四条中属性的地方也可以换成方法
例子：
这是普通的属性

在age前加了__使它变成了私有属性。这样外部就无法调用。

如果想访问需要改变输入方法。

在类内部调用时则不用写_temmie。
面向对象的三个特征。

面向对象的三大特征介绍

封装：隐藏对象的细节，只展示相关调用方法。
继承：可以让子类具有父类的特性，提高代码的重用性。
多态：同一方法调用由于对象不同会产生不同的行为。

继承

父类也称为基类；子类也称为派生类。
继承的语法格式：

class 子类类名(父类1，父类2...):
	类体

一个子类可以继承多个父类。如果在类定义中没有指定父类则默认它的父类是object类，这里面定义了一些所有类共有的默认实现方法。
整活

class TemmieSay:
	def __init__(self,message):
		self.message=list(message)
	def say_again(self):
		ad=self.message[::-1]
		print('back noisy:',''.join(list(ad)))
class TemmieCopy(TemmieSay):
	pass
a=TemmieCopy(input("temmie say:"))
a.say_again()

可以看到，我在尾部嗲用的是TemmieCopy这个类，类中没有say_again这个方法，但是它继承了TemmieSay这个类，所以可以调用TemmieSay的方法。
如果你想在子类中引用父类的对象，可以这样写：

class TemmieSay:
	def __init__(self,message):
		self.message=list(message)
	def say_again(self):
		ad=self.message[::-1]
		print('back noisy:',''.join(list(ad)))
class TemmieCopy(TemmieSay):
	def __init__(self,message,tp):
		TemmieSay.__init__(self,message)
		self.tp=tp
	def say_tp(self):
		print('{0}'.format('wang!wang!wang!'if self.tp=='dog' else '???'))
	pass
a=TemmieCopy('i am temmie','dog')
a.say_again()
a.say_tp()

类成员的继承与重写

1.成员继承：子类继承了父类除构造方法之外的所有成员。
2.方法重写：子类可以重新定义父类的方法，这样就会覆盖父类的方法，也称重写。
这个重写和之前提到的一样，如果写了同名的，默认执行最后写入的。上面 的会被覆盖掉。

object类

mro方法

通过类的方法 mro()或者类的属性__mro__可以输出这个类的继承层次结构。
还是用刚才的例子：可以看到TemmieCopy>TemmieSay>object这样一个层次。

如果子对象包含多个父对象，且父对象中有相同名称的方法，例如class a（b,c）就意味着a是b和c的子对象，如果b有acc这个方法，c也有acc这个方法的话，调用a的acc方法会按照a(b,c)括号的顺序安排优先级，即按照b的acc方法运行。

dir()查看对象属性

class TemmieSay:
	def __init__(self,message):
		self.message=list(message)
	def say_again(self):
		ad=self.message[::-1]
		print('back noisy:',''.join(list(ad)))
class TemmieCopy(TemmieSay):
	def __init__(self,message,tp):
		TemmieSay.__init__(self,message)
		self.tp=tp
	def say_tp(self):
		print('{0}'.format('wang!wang!wang!'if self.tp=='dog' else '???'))
	pass
a=TemmieCopy('i am temmie!','dog')
print(dir(object()))
print(dir(a))

用dir查看object和TemmieCopy的属性，可以看到object的属性在TemmieCopy中都有

['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'message', 'say_again', 'say_tp', 'tp']

重写__str__()方法

object 有一个__str__()方法，用于返回一个对于“对象的描述”，对应于内置函数 str()经常用于 print()方法，帮助我们查看对象的信息。str()可以重写。
我的理解：

正常使用类创建对象后，如果打印这个对象，它会返回给你上面这一串。
这一串是默认的__str__()方法下代码实现的。现在我们可以重写来让它输出不同的内容。
例如：

而且似乎可以在不同类多次重写。

多重继承

python支持多重继承，一个子类可以由多个直接父类。这样就具备了多个父类的特点。但这样类的整体层次会很复杂，要尽量避免使用。

super()获得父类定义

在子类中直接获得父类的定义（不是对象）。
感觉意义不是很大。就是这个样子：

class A:
	def aa(self):
		print('这是A')
class B(A):
	def bb(self):
		A.aa(self)
		super().aa()
		print('这是B')
B().bb()

多态

是指同一个方法调用由于对象不同可能会产生不同的行为。
注意：多态是方法的多态，属性没有多态；多态存在的两个必要条件：继承、方法重写。

特殊属性

Python 对象中包含了很多双下划线开始和结束的属性，这些是特殊属性，有特殊用法。使用时直接 对象.下面的内容

特殊方法	含义
obj.dict	对象的属性字典
obj.class	对象所属的类
class.bases	类的基类元组（多继承）
class.base	类的基类
class.mro	类层次结构
class.subclasses()	子类列表

组合

课上讲的很形象，这里直接搬过来：is-a”关系，我们可以使用“继承”。从而实现子类拥有的父类的方法和属性。“is-a”关系指的是类似这样的关系：狗是动物，dog is animal。狗类就应该继承动物类。
“has-a”关系，我们可以使用“组合”，也能实现一个类拥有另一个类的方法和属性。”has-a”关系指的是这样的关系：手机拥有 CPU。

#这是继承关系
class A1:
	def say_a1(self):
		print('a1,a2,a3')
class B1(A1):
	pass
B1().say_a1()
#这是组合关系
class A2:
	def say_b2(self):
		print('b1,b2,b3')
class B2:
	def __init__(self,a):
		self.a=a
B2(A2()).a.say_b2()
#其实下面这句话就是上面一句推一步就能得到
A2().say_b2()

设计模式：工厂模式与单例模式

工厂模式实现了创建者和调用者的分离。
单例模式的核心作用是确保一个类只有一个实例，并且提供一个访问该实例的全局访问点。
这是一种使用类创建结构程序的方法，是可以套用的东西。
工厂模式

class Factory:
	def creat_type(self,typ):
		if typ=='类型1':
			return type01()
		elif typ=='类型2':
			return  type02()
		#新的类型在此处通过elif添加
		else:
			return '未定义'
class type01:
	print('类型1')
	#此处添加需要的代码块
class type02:
	print('类型2')
	# 此处添加需要的代码块
#新的类在此处添加

#调用
c1=Factory().creat_type('类型1')#创建何种类型，只需要修改括号中内容
print(c1)

最下面那行就是结果。
那么，前面的类型1和类型2是哪里来的呢？询问过后找到了一个答案：因为类初始化，所以会输出所有print，也就是class type1的print和class type2的print和判断的print。如果想调整，就将type1和type2改为方法，让if判断去调用方法，并且在创建类时尽量不要这样写。
单例模式

class CarFactory:
	__obj = None #类属性
	__init_flag = True
	def __new__(cls, *args, **kwargs):
		if cls.__obj ==None:
			cls.__obj = object.__new__(cls)
			return cls.__obj
	def __init__(self):
		if CarFactory.__init_flag:
			print("init CarFactory....")
			CarFactory.__init_flag = False
factory = CarFactory()
factory2 = CarFactory()
print(factory)
print(factory2)

这里面确实进行了一个初始化，并只创建了一个对象，但问题是我何时赋值呢？