一。 面向对象三大特性：
多态
多种类型 参数可以是python的任意一种类型
def func(arg)
print(arg)
obj = func(int)
obj = func(str)
obj = func(dict)
封装
继承
二。面向对象中 成员
字段
class Foo：
#字段(静态字段) 存放在类里面 静态字段减少内存使用，多个对象公用一份
CC = 123
def _init__(self):
#name字段 为普通字段 存放在对象里面
self.name = ‘wyx‘
class Provice:
country = ‘中国‘
def __init__(self,name):
self.name = name
#一般情况下：自己访问自己的字段
hn = Provice(‘河南‘)
hb = Provice(‘河北‘)
hn.name 只可以访问自己的name字段
hb.name 只可以访问自己的name字段
#规则:
普通字段只能对象去访问
静态字段用类访问(万不得以的时候可以使用可以用对象去访问)
PS:静态字段代码加载的时候，已经创建
方法
所有地方法属于类
1.普通方法：至少有一个self,对象执行
2.静态方法：任意参数， 类执行
3.类方法 ：至少一个cls, 类执行
class Provice:
country = ‘中国‘
def __init__(self,name):
self.name = name
def show(self):
print(self.name)
#普通方法，由对象去调用执行(方法属于类)
obj = Provice(‘河南‘)
obj.show()
#静态方法,由类去调用执行(方法属于类),静态方法可以没有参数或者有多个参数
@staticmethod
def f1(arg):
print(arg)
Provice.f1(1111111)
#类方法：静态方法的特殊方式,类方法至少有一个参数cls，cls自动传值
@classmethod
def f2(cls):
#cls为类名, cls()为创建对象
print(cls)
Provice.f2() #会输出类名
属性 对象调用执行
不伦不类的东西
具有方法的写作形式，具有字段的访问形式
class Pager:
def __init__(self,all_account):
self.all_account = all_account
@property #设置成具有字段属性的类型
def all_pager(self):
a1,a2 = divmod(self.all_account,10)
if a2 == 0:
return a1
else:
return a1 + 1
p = Pager(101)
ret = p.all_pager
#属性可以不用括号来调用
print(ret)
@all_pager.setter #设置成可以传参数的属性
def all_pager(self,value):
a1,a2 = divmod(value,10)
if a2 == 0:
return a1
else:
return a1 + 1
p = Pager
p.all_pager = 1111
@all_pager.deleter #设置成可以删除的属性 (del all_pager)
def all_pager(self):
del Pager.all_pagerggg
p = Pager
del p.all_pager
class Pager:
def __init__(self,all_account):
self.all_account = all_account
def f1(self):
return 123
def f2(self,value):
print(value)
def f3(self):
pass
foo = property(f1,f2,f3)
p = Pager(101)
#print(p.foo)
p.foo = 456
print(p.foo)
del p.foo
三。成员修饰符
公有：
class Foo:
def __init__(self,name):
self.name = name
def f1(self):
print(self.name)
obj = Foo(‘wyx‘)
print(obj.name)
obj.f1() #在类的内部和外部均可以调用为公共的
私有：
如果想要从外部访问私有的： _Foo__cc
class Foo:
def __init__(self,name):
self.__name = name
__cc = ‘123‘
def f1(self):
print(Foo.__cc)
obj = Foo(‘123‘)
print(obj._Foo__cc)
只能类自己本身内部成员可以访问
class Foo:
def __init__(self,name):
self.__name = name
__cc = ‘123‘
def f1(self):
print(Foo.__cc)
obj = Foo(‘123‘)
obj.f1()
四。特殊成员
class Foo:
#构造方法
def __init__(self,name,age):
self.name = name
self.age = age
#析构方法
def __del__(self):
pass
def __call___(self):
print(‘hahaha 调用我呀‘)
def __str__(self):
return ‘%s - %d‘ % (self.name,self.age)
# obj = Foo()
# obj() #__call__方法 对象后面加括号
obj1 = Foo(‘alex‘,99)
obj2 = Foo(‘wyx‘,18)
ret = obj1
print(ret) #__str__ print 对象名字调用__str__方法
__dict__ #获取对象中封装的数据
ret = obj1.__dict__
print(ret)
def __getitem__(self, item):
print(item)
def __setitem__(self, key, value):
print(‘set key value‘)
def __delitem__(self, key):
print(‘del key‘)
obj = Foo()
#以jian
obj[‘k1‘] #使用中括号调用__getitem__
obj[‘k1‘] = 1 #__setitem__调用方法
del obj[‘k1‘] #__delitem__ 调用方法
class Foo:
def __getitem__(self, item): #item为slince 类型 里面包括 起始，终止，步长 如果为切片方式访问
print(item.start)
print(item.stop)
print(item.step)
def __setitem__(self, key, value): #其中key为slince类型 value为list类型
print(‘set key value‘)
print(key.start)
print(key.stop)
print(key.step)
def __delitem__(self, key): #其中key为slince类型
print(‘del key‘)
print(key.start)
print(key.stop)
print(key.step)
obj = Foo()
obj[1:4:2] #自动执行__getitem__ [1:4:2]为item
obj[1:4:2] = [11,23,43,4554,33] #其中[1,,4,2] 为key 后面的列表为value
del obj[1:4] #其中[1,4] 为key
class Foo: #__iter__ 可以被for循环
def __iter__(self):
yield 1
yield 2
obj = Foo()
for item in obj:
print(item)
五。对象对象其他
- isinstance
对象是不是由这个类创建的
- issubclass
一个类是不是另一个类的子类 issubclass(bar,foo) bar是不是foo的子类
class c1:
def f1(self):
print(‘c1.f1‘)
return 123
class c2(c1):
def f1(self):
ret = super(c2,self).f1()
print(‘c2.f2‘)
return ret
obj = c2()
obj.f1() #使用super方法，c2找到自己父类c1的f1方法和self.f1自己的方法，输出c1和c2的f1方法
- 应用：
自定义类型，对字典进行补充，有序字典
class Mydic(dict):
def __init__(self):
self.li = []
super(Mydic,self).__init__()
def __setitem__(self, key, value):
self.li.append(key)
super(Mydic,self).__setitem__(key,value)
def __str__(self):
tem_list = []
for key in self.li:
value = self.get(key)
tem_list.append(‘%s:%s‘ % (key,value,))
temp_str = ‘{‘ + ‘,‘.join(tem_list)+‘}‘
return temp_str
obj = Mydic()
obj[‘k1‘] = 123
obj[‘k2‘] = 456
print(obj)
六。异常处理
七。设计模式之单例模式，创建方法
类方法
class Foo:
instance = None
def __init__(self,name):
self.name = name
@classmethod
def get_instance(cls):
if cls.instance:
return cls.instance
else:
obj = cls(‘wyx‘)
cls.instance = obj
return obj
obj1 = Foo.get_instance()
print(obj1)
obj2 = Foo.get_instance()
print(obj2)