字段

class Foo:
#静态字段（保存在类中）
CC = 123
def __init__(self):
#普通字段（保存在对象中）
self.name = 'alex'
def show(self):
print(self.name)

静态字段的应用：

class Province:
def __init__(self,name):
self.name = name
country = "中国"
hn = Province('河南')
hb = Province('河北')
sd = Province('山东')
hlj = Province('黑龙江')

节省内存空间：

class Province:
country = "中国"
def __init__(self,name):
self.name = name
hn = Province('河南')
hb = Province('河北')
sd = Province('山东')
hlj = Province('黑龙江')

一般情况：自己访问自己的字段

规则：普通字段只能用对象访问，静态字段用类访问（可以使用对象访问）。

静态字段在代码加载时已经创建。

print(hn.name)
print(Province.country)

普通方法、静态方法、类方法

class Province:
country = "中国"
def __init__(self,name):
self.name = name
#普通方法，由对象调用执行（方法属于类）
def show(self):
# print(self.name)
print("河北")
#静态方法，由类调用执行（当方法内部不需要对象中封装的对象）
@staticmethod
def f1(arg1,arg2):
print(arg1,arg2)
#类方法（静态方法的一种，至少一个参数，自动传递类名），由类调用执行
@classmethod
def f2(cls):
print(cls)
Province.f1(111,222)
Province.f2()
obj = Province("河南")
obj.show()
输出：
111 222
<class '__main__.Province'>
河北

单例模式：类方法。

所有的方法属于类：

1、普通方法，至少一个self，对象执行。

2、静态方法，任意参数，类执行（可以对象执行）。

3、类方法，至少一个cls，类执行（可以对象执行）。

类成员属性

class Pager:
def __init__(self,all_count):
self.all_count = all_count
def all_pager(self):
a1,a2 = divmod(self.all_count,10)
if a2 == 0:
return a1
else:
return a1 + 1
p = Pager(101)
ret = p.all_pager() #方法
print(ret)

class Pager:
def __init__(self,all_count):
self.all_count = all_count
@property
def all_pager(self):
a1,a2 = divmod(self.all_count,10)
if a2 == 0:
return a1
else:
return a1 + 1
p = Pager(101)
ret = p.all_pager
print(ret)

class Pager:
def __init__(self,all_count):
self.all_count = all_count
#获取
@property
def all_pager(self):
a1,a2 = divmod(self.all_count,10)
if a2 == 0:
return a1
else:
return a1 + 1
#设置
@all_pager.setter
def all_pager(self,value):
print(value)
#删除
@all_pager.deleter
def all_pager(self):
print("del all_pager")
p = Pager(101)
ret = p.all_pager
print(ret)
p.all_pager = 111
del p.all_pager
输出：
11
111
del all_pager

属性：具有方法的写作形式，具有字段访问形式。

class Pager:
def __init__(self,all_count):
self.all_count = all_count
def f1(self):
return 123
def f2(self,value):
print(value)
def f3(self):
print("del")
foo = property(fget=f1,fset=f2,fdel=f3)
p = Pager(101)
ret = p.foo
print(ret)
p.foo = "alex"
del p.foo
输出：
123
alex
del

成员修饰符

class Foo:
#__cc私有静态字段
__cc = 123
def __init__(self,name,age):
self.name = name
#__age私有普通字段
self.__age = age
def f1(self):
print("f1:"+self.name)
print(self.__age)
def f3(self):
print(Foo.__cc)
@staticmethod
def f4():
print("staticmethod:",Foo.__cc)
class Bar(Foo):
def f2(self):
print(self.name)
#私有普通字段不能访问
# print(self.__age)
obj = Foo('alex',19)
print(obj.name)
# print(obj.age) 不能外部调用
# print(Foo.__cc) 不能外部调用
obj.f1()
obj.f3()
Foo.f4()
obj1 = Bar("tom",20)
obj1.f2()
obj1.f1()

私有：只有类本身成员内部可以访问。

注意：特殊访问私有字段的方法（_类名__xxx）。

print(obj._Foo__age)

特殊成员

class Foo:
#构造方法
def __init__(self):
print("init")
#析构方法
def __del__(self):
print("del")
def __call__(*args,**kwargs):
print("call")
p = Foo()
#获取类名
print(p.__class__)
#执行call方法
p()
#执行call方法
Foo()()
输出：
init
<class '__main__.Foo'>
call
init
call
del
del

class Foo:
#构造方法
def __init__(self,name,age):
self.name = name
self.age = age
#析构方法
def __del__(self):
pass
def __call__(*args,**kwargs):
print("call")
def __str__(self):
return "%s----%d" %(self.name,self.age)
obj = Foo("alex",34)
print(obj)
obj2 = Foo("eric",23)
print(obj2)
输出：
alex----34
eric----23

obj1 = Foo('alex',23)
obj2 = Foo('eric',21)
#获取对象中封装的数据
ret = obj1.__dict__
print(ret)
输出：
{'age': 23, 'name': 'alex'}

class Foo:
#构造方法
def __init__(self,name,age):
self.name = name
self.age = age
#析构方法
def __del__(self):
pass
def __call__(*args,**kwargs):
print("call")
def __str__(self):
return "%s----%d" %(self.name,self.age)
def __getitem__(self,item):
print("getitem")
def __setitem__(self, key, value):
print("setitem")
def __delitem__(self, key):
print("delitem")
obj = Foo('alex',18)
#call方法
obj()
obj["abc"] = 111
del obj['abc']
输出：
call
setitem
delitem

class Foo:
#构造方法
def __init__(self,name,age):
self.name = name
self.age = age
def __getitem__(self,item):
print(type(item))
if type(item) == str:
pass
else:
print(item.start)
print(item.stop)
print(item.step)
print("getitem")
def __setitem__(self, key, value):
print(type(key),type(value))
print("setitem")
def __delitem__(self, key):
print(type(key))
print("delitem")
obj = Foo('alex',14)
#getitem
ret1 = obj[1:4:2]
#getitem
ret2 = obj['abc']
obj[1:3] = [11,22,33]
del obj[1:5]
输出：
<class 'slice'>
1
4
2
getitem
<class 'str'>
getitem
<class 'slice'> <class 'list'>
setitem
<class 'slice'>
delitem

class Foo:
"""
def __iter__(self):
print("iter")
return iter([11,22,333])
"""
def __iter__(self):
yield 1
yield 2
obj = Foo()
for item in obj:
print(item)
输出：
"""
iter
11
22
333
"""
1
2

class Bar:
pass
class Foo():
pass
obj = Foo()
#查看某个对象是不是由某个类创建
ret = isinstance(obj,Foo)
ret2 = isinstance(obj,Bar)
print(ret)
print(ret2)
输出：
True
False

isinstance和issubclass

class Bar:
pass
class Foo(Bar):
pass
obj = Foo()
#查看某个对象是不是由某个类创建
ret = isinstance(obj,Foo)
ret2 = isinstance(obj,Bar) #obj类型和obj类型的父类
print(ret)
print(ret2)
#查看某个类是不是另一个类的子类
ret3 = issubclass(Bar,Foo)
ret4 = issubclass(Foo,Bar)
print(ret3)
print(ret4)
输出：
True
True
False
True

继承super

class C2(C1):
def f1(self):
#执行C1中的f1
super(C2,self).f1() #C1.f1(self)
print('c2.f1')
obj = C2()
#默认执行C2中的f1
obj.f1()
输出：
c1.f1
c2.f1

有序字典

class MyDict(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):
temp_list = []
for key in self.li:
value = self.get(key)
temp_list.append("'%s':%s"%(key,value))
temp_list = "{" + ",".join(temp_list) + "}"
return temp_list
obj = MyDict()
obj['k1'] = 123
obj['k2'] = 456
print(obj)

单例模式

单例模式用来创建单个实例。

class Foo:
instance = None
def __init__(self,name):
self.name = name
@classmethod
def get_instance(cls):
#cls类名
if cls.instance:
print("已经创建对象")
return cls.instance
else:
#创建对象
obj = cls('alex')
print("新创建对象")
cls.instance = obj
return obj
obj = Foo.get_instance()
obj1 = Foo.get_instance()
print(id(obj),id(obj1))
输出：
新创建对象
已经创建对象
7225864 7225864

异常处理

while True:
num1 = input("num1:")
num2 = input("num2:")
try:
num1 = int(num1)
num2 = int(num2)
result = num1 + num2
except Exception as ex: #捕获所有错误
print(ex)

except ValueError as ve: #捕获ValueError
print(ve)
except IndexError as ie: #捕获IndexError
print(ie)
except Exception as ex: #捕获所有错误
print(ex)

try:
pass
except ValueError as ve:
print(ve)
except Exception as ex:
print(ex)
finally: #不管有无错误都执行finally
pass

try:
raise ValueError('主动触发错误')
pass
except ValueError as ve:
print("ValueError",ve)
except Exception as ex:
print(ex)
finally: #不管有无错误都执行finally
pass
输出：
ValueError 主动触发错误

断言

assert 1 == 1
#报错
assert 1 == 2

Python开发【第七篇】：面向对象二的更多相关文章

Python开发【第一篇】：目录
本系列博文包含 Python基础.前端开发.Web框架.缓存以及队列等,希望可以给正在学习编程的童鞋提供一点帮助!!! Python开发[第一篇]:目录 Python开发[第二篇]:初识Python ...
Python开发【第二篇】：初识Python
Python开发[第二篇]:初识Python Python简介 Python前世今生 python的创始人为吉多·范罗苏姆(Guido van Rossum).1989年的圣诞节期间,吉多·范罗苏 ...
Python开发【第一篇】:目录
本系列博文包含Python基础.前端开发.Web框架.缓存以及队列等,希望可以给正在学习Python编程的朋友们提供一点帮助! .Python开发[第一篇]:目录 .Python开发[第二篇]:初始P ...
Python开发【第一篇】基础题目二
1 列表题 l1 = [11, 22, 33] l2 = [22, 33, 44] # a. 获取l1 中有,l2中没有的元素 for i in l1: if i not in l2: # b. 获取 ...
Python开发【第一篇】：初识Python
初识python 一.python简介 python的创始人为吉多·范罗苏姆(Guido van Rossum).1989年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的脚本解 ...
跟着老男孩教育学Python开发【第一篇】：初识Python
Python简介 Python前世今生 Python的创始人为吉多·范罗苏姆(Guido van Rossum).1989年的圣诞节期间,吉多·范罗苏姆为了在阿姆斯特丹打发时间,决心开发一个新的脚本解 ...
七丶人生苦短，我用python【第七篇】
模块模块,用一砣代码实现了某个功能的代码集合. 类似于函数式编程和面向过程编程,函数式编程则完成一个功能,其他代码用来调用即可,提供了代码的重用性和代码间的耦合.而对于一个复杂的功能来,可能需要多个 ...
Python开发【第二篇】：初始Python
Python的前世今生 Python的创始人为吉多·范罗苏姆(Guido van Rossum).1989年的圣诞节期间,中国人称他为龟叔,他在圣诞节期间在阿姆斯特丹为了打发时间,决定开发一个新的脚本 ...
python学习第一天：window安装python开发环境完整篇
我是跟着廖雪峰老师的的博客来一步一步来进行学习和实践后记录下来的,讲的非常地详细,推荐大家一起学习https://www.liaoxuefeng.com/wiki/0014316089557264a6 ...
【python自动化第七篇：面向对象进阶】
知识点概览: 静态方法,类方法,属性方法类的特殊方法反射异常处理 socket开发基础一.静态方法:@staticmethod 只是名义上归类管理,实际上在静态方法里访问不了类或者实例中的任何 ...

随机推荐

全志A33 lichee lvds屏幕配置
开发平台 * 芯灵思SinlinxA33开发板淘宝店铺: https://sinlinx.taobao.com/ 嵌入式linux 开发板交流 QQ:641395230 芯灵思SinlinxA33开 ...
同一个windows server 部署多个tomcat
只需要修改tomcat目录下conf下的server.xml文件即可,修改地方有三个,把下面这几个端口修改了为不同的端口即可,例如我把这几个端口统一减1了 <Server port=" ...
Redis使用规范
突出强调部分 [强制]key名不要包含特殊字符,如空格.换行.单双引号以及其他转义字符 [强制]拒绝bigkey(防止网卡流量.慢查询) [强制]控制key的生命周期,redis不是垃圾桶 [强制]技 ...
用Redis存储Tomcat集群的Session实现session共享
一.存储前段时间,我花了不少时间来寻求一种方法,把新开发的代码推送到到生产系统中部署,生产系统要能够零宕机.对使用用户零影响. 我的设想是使用集群来搞定,通过通知负载均衡Nginx,取下集群中的To ...
day 12
一,什么是装饰器? 装饰器本质上就是一个python函数,他可以让其他函数在不需要做任何代码变动的前提下,增加额外的功能,装饰器的返回值也是一个函数对象. 装饰器的应用场景:比如插入日志,性能测试,事 ...
Hanlp1.7版本的新增功能一览
Hanlp1.7版本在去年下半年的时候就随大快的DKH1.6版本同时发布了,截至目前1.7大版本也更新到了1.7.1了.本篇分别就1.7.0和1.7.1中新增的功能做一个简单的汇总介绍. HanLP ...
JsonPath 使用
Map<String, String> map ----> $.store.bicycleString str = $.store.otherList<Map<Str ...
Lattice并购案&我国FPGA发展路径
FPGA作为通信.航天.军工等领域的关键核心器件,是保障国家战略安全的重要支撑基础.近年来,随着数字化.网络化和智能化的发展,FPGA的应用领域得到快速扩张.美国在FPGA领域拥有绝对的垄断优势,已成 ...
mysql大表设计以及优化
MYSQL千万级数据量的优化方法积累https://m.toutiao.com/group/6583260372269007374/?iid=6583260372269007374 MySQL 千万级 ...
[转][C#]压缩解压
{ internal static class Compressor { public static Stream Decompress(Stream source, bool bidiStream) ...

Python开发【第七篇】：面向对象二

字段