python 所有异常类的父类是_哗啦啦Python之路 - Day 8 - 多态，类成员，单例模式，异常处理...

1. 多态(多种类型)

多态的体现如下：

deffunc(arg):print(arg)

func(1)

func("alex")

func([11,12,13])#func可以是任何东西

#但是对于C#,java都不是这样，参数必须要指定类型

多态的缺点：在缺少注释的情况下，不知道arg是什么类型，它有什么用处。比如说如果确定好是个list的话，那就可以append()。但是不确定的时候就不知道怎么用了。

2. 面向对象中的类成员

1) 字段

- 静态字段： 代码加载时已经创建，属于类

- 普通字段： 有对象才有这个，属于对象

classProvince:

country= "中国" #静态字段,保存在类里面

def __init__(self,name):

self.name= name #保存在对象里，这是普通字段，如果没有调用这个函数，那么这个就不在内存里

2) 方法(属于类)

- 普通方法： 定义必须有self,通过对象执行

- 静态方法： @staticmethod,去掉self,参数可有可无，由类执行

- 类方法： @classmethod，静态方法的一种特殊形式。自动传类参数，由类执行

classProvince:def __init__(self,name):

self.name=namedef show(self): #普通方法

print(self.name)

@staticmethod#静态方法，1.加这个，2.去掉self，3.参数可有可无

deff1(arg1):print(arg1)

@classmethod#类方法，必须要有参数

def f2(cls):#这个参数是自动传递的,是类名。静态方法的一种。

print(cls)deff3(self):return self.name[1]##方法是由对象调用的#obj = Province("河南")#obj.show()##普通方法由对象去调用执行(方法属于类)#Province.f1(111)#静态方法,只跟类有关，不需要对象，由类调用,跟函数一样的#Province.f2()#类方法，参数是类名#obj = Province("alex")#ret = obj.f3()#print(ret)

- 类方法使用举例，类既可以有方法的作用，又可以像字段一样被修改

#做个分页的类

classPager:def __init__(self,all_count):

self.all_count=all_countdefall_pager(self):

a1, a2= divmod(self.all_count,10) #商，余数

if a2 ==0:returna1else:return a1+1p= Pager(101)

result=p.all_pager()print(result)#这是用方法去写

#####用属性写一遍######

classPager:def __init__(self,all_count):

self.all_count=all_count

@propertydefall_pager(self):

a1, a2= divmod(self.all_count,10) #商，余数

if a2 ==0:returna1else:return a1+1@all_pager.setter#设置，可以赋值

defall_pager(self,value):print(value)

@all_pager.deleter#删除,其实可以自己定义，提供了一种关联方式而已

defall_pager(self):print("all_pager")

p= Pager(101)

result= p.all_pager#就不用括号了，跟用字段一样的

print(result)

- 属性也可以这样写

#属性也可以这样写

classPager:deff1(self):return 123

deff2(self):pass

deff3(self):passfoo= property(fget=f1,fset=f2,fdel=f3)

moo=property(f1,f2,f3)

p=Pager()

m=p.foo

n=p.mooprint(m,n)

3) 成员修饰符

- 可以选择是公有成员还是私有成员，私有成员的话前面加__,

########成员修饰符###########

classFoo:__cc = "123" #私有成员

def __init__(self,name,age):

self.name= name #公有成员

self.__age = age #私有成员

deff1(self):print(self.name)deff2(self):print(self.__age)deff3(self):print(Foo.__cc)

@staticmethoddeff4():print(Foo.__cc)def __f5(self):print("456")deff6(self):

Foo.__f5(self)

obj= Foo("alex",18)print(obj.name) #外部访问,age就访问不到

obj.f1() #内部访问#同时能内部和外部访问，就是公共的，公有成员#私有成员前面加两个__,只有内部能访问，即使继承也不行

obj.f2() #内部访问，私有成员age就被查到了

obj.f3() #内部访问，私有成员__cc就能，但是直接调__cc就不行了

Foo.f4() #这样就实现了不用对象就可以

obj.f6() #私有方法就这样被调出来了

- 一些特殊成员

#######特殊成员########

classFoo:def __init__(self): #构造方法,类后面加括号执行这个

self.name = "alex"

def __del__(self): #析构方法

pass

def __call__(self, *args, **kwargs):#对象后面加括号调用这个

print("call")def __str__(self):return "haha" #输出对象的时候输出的就是这个

p=Foo()print(p.__module__)print(p.__class__)

p()#调用的就是__call___

Foo()() #跟上面那个p()一样

obj =Foo()print(obj) #输出的就是__str__里面的东西

print(obj.__dict__) #这个能返回对象中封装的所有数据

print(Foo.__dict__) #这个能返回类中封装的所有数据

- 像处理字典一样处理类

#######像处理字典一样处理类#####

classFoo(object):def __getitem__(self, key):print("123")def __setitem__(self, key, value):print("456")def __delitem__(self, key):print("789")

obj=Foo()

result= obj['k1'] #自动触发执行 __getitem__

obj['k2'] = 'wupeiqi' #自动触发执行 __setitem__

del obj['k1'] #自动触发执行 __delitem__

- 类迭代

######类迭代########

列表迭代

m= [1,2,3,4]for item inm:print(item)#类迭代#1. 方法1

classFoo:def __iter__(self):return iter([11,22,33,44])

obj=Foo()for item inobj:print(item)

#2. 方法2

class Foo:

def __iter__(self):

yield 1#生成器

yield 2

obj = Foo()

for item in obj:#obj必须可迭代

print(item)

- super的用法 - 执行父类

#####执行父类的方法#######

classC1:deff1(self):print("c1f1")classC2(C1):deff1(self):

super(C2,self).f1()print("c2f1")

obj=C2()

obj.f1()#执行了父类和子类的f1

- 有序的字典

#######有序的字典#########

classMyDict(dict):def __init__(self):

self.li=[]

super(MyDict,self).__init__()def __setitem__(self, key, value): #使用字典那种方法

self.li.append(key)

super(MyDict, self).__setitem__(key,value)def __str__(self): #print对象时出来的结果

temp_list =[]for key inself.li:

value=self.get(key)

temp_list.append("'{}':{}".format(key,value))print(temp_list)

temp_str= "{" + ",".join(temp_list) + "}"

returntemp_str

obj=MyDict()

obj["k1"] = 123obj["k2"] = 456

print(obj,type(obj))

- 单例模式

##############单例模式###################

classFoo:

instance=Nonedef __init__(self,name):

self.name=name

@classmethoddefget_instance(cls):ifcls.instance:returncls.instanceelse:

obj= cls("alex")

cls.instance=objreturnobj

obj= Foo.get_instance()#第一次，没有instance，赋值

obj2 = Foo.get_instance()#第二次，有了，用上次赋值的那个instnce

4) 异常处理

##############异常处理##############

whileTrue:

num1= input("1")

num2= input("2")try:

result= int(num1)+int(num2)exceptException as ex:print(ex)else:pass

finally:pass

- 主动触发异常

try:raise Exception("主动错误")exceptException as Ex:print(Ex)

- 断言

assert 1 == 2