python笔记 - day8

参考:

大纲

面向对象三大特性之多态

类成员之静态字段和普通字段

类成员之普通方法和静态方法以及类方法

类成员之属性

类成员之成员修饰符

类成员之特殊成员

其他之isinstance和issubclass

其他之super的应用

实例之自定义有序字典

单例模式

基本异常处理

异常类型

主动触发异常

自定义异常和断言

JAVA和C#不支持多态(几种编程语言多态形式对比)。

字段:

普通字段保存在对象里面,静态字段保存在类里面。

访问普通字段,静态字段规则,方法:
  一般情况,自己访问自己字段
规则:
  普通字段只能用对象访问
  静态字段用类访问(万不得已可以使用对象访问)

class Province:
country = "中国"
#静态字段 def __init__(self,name):
self.name = name
#普通字段 hn = Province("河南")
hb = Province("河北")
sd = Province("山东")
db = Province("黑龙江")
print(hn.name)
class Province:
country = "中国" def __init__(self,name):
self.name = "alex" hn = Province("河南")
print(hn.name) #通过类访问静态字段,推荐
print(Province.country) #通过对象访问静态字段,不推荐
print(hn.country)
class Provice:
country = "中国" def __init__(self,name):
self.name = "alex" print(Province.country)
#静态字段,在代码加载时,已经创建;
 
class Province:
country = "中国" def __init__(self,name):
self.name = name
#普通方法,由对象去调用执行(方法属于类) def show(self):
#print(self.name)
print(123) @staticmethod
def f1(arg1,arg2):
#静态方法,由类直接调用执行
print(arg1,arg2) @classmethod
def f2(cls):
cls #类名,加()创建对象
print(cls) Province.f1(1,2) #静态方法,由类直接调用执行
Province.f2() #不用传值,自动传值 所有方法属于类:
1.普通方法:至少一个self, 对象执行
2.静态方法:任意参数, 类来执行(也可以对象执行,不推荐)
3.类方法:至少一个cls 类执行(也可以对象执行,不推荐)
分页:不使用属性;

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)
#不使用人妖,属性
#p.all_count #字段
result = p.all_pager()#方法
print(result)
使用属性,人妖,@property,:
使用属性实现的效果功能是:通过对象执行方法,不用加括号了。
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")
#通过@property执行方法,不用加括号了;
p = Pager(101)
ret = p.all_pager
print(ret) # #给属性重新赋值,加变量
res = p.all_pager = 111
print(res) # #删除属性
del p.all_pager
属性定义:
1.不伦不类的东西
2.具有方法的写作形式,具有字段的访问方式;
3.属性只是提供的是访问方法,具体做什么靠自己定义。
属性存在的第二种方式:
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 p.foo") foo = property(fget=f1,fset=f2,fdel=f3) p = Pager(101) result = p.foo
print(result) p.foo = "alex" del p.foo
 

属性一:

属性二:

属性存在的第二种方式:

成员修饰符:
私有: 只能类自己本身成员内部可以访问
公有:

class Foo:
def __init__(self,name):
self.__name = name def f1(self):
print(self.__name) class Bar(Foo):
def f2(self):
print(self.__name) obj = Bar("alex")
# obj.f2()
obj.f1() 上面这个例子:不能通过f2调用私有方法,只能通过本身f1调用私有方法,结论:私有方法只能通过内部调用;
class Fzz:
__cc = "123" def __init__(self,name):
self.__name = name def f1(self):
print(self.__name) # def f3(self):
# print(Fzz.__cc) #通过静态字段方法来执行
@staticmethod
def f3():
print(Fzz.__cc) # print(Fzz.__cc) #调用不到cc方法 obj = Fzz('dddd')
obj.f3()
#能够调用到cc的方法 Fzz.f3()
#通过静态字段方法来执行
 

内置方法:

class Foo:
def __init__(self,name,age):
self.name = name
self.age = age def __del__(self):
pass def __call__(self, *args, **kwargs):
print("call") def __str__(self):
return "%s - %d"%(self.name,self.age)
obj = Foo('alex',18)
obj() #对象,执行call方法
Foo('alex',18)() #执行类方法并且执行call方法;(这么写)
#类加括号执行__init__方法
#对象加括号执行call方法 #这里应用的__str__方法,不用__str__方法,输出的是内存地址
obj1 = Foo('alex',73)
obj2 = Foo('eric',84)
print(obj1)
print(obj2)
class Foo:
def __init__(self,name,age):
self.name = name
self.age = age def __str__(self):
return "%s - %d"%(self.name,self.age) def __getitem__(self, item):
return 123 def __setitem__(self, key, value):
print("setitem") def __delitem__(self, key):
print('del item') obj1 = Foo('alex',73)
#获取对象中封装的数据,获取数据类型是字典
ret = obj1.__dict__
print(ret,type(ret)) #执行__getitem__
ret = obj1['test']
print(ret) #执行__setitem__
res = obj1['k1'] = 111
print(res) #执行__delitem__
del obj1['k1']
class Foo:
def __init__(self,name,age):
self.name = name
self.age = age def __str__(self):
return "%s - %d"%(self.name,self.age) def __getitem__(self, item):
print(type(item))
print(item.start)
print(item.stop)
print(item.step)
return 123 def __setitem__(self, key, value):
print(type(key),type(value))
print(key.start)
print(key.stop)
print(key.step) def __delitem__(self, key):
print(type(key)) #执行__str__
obj1 = Foo('alex',73)
print(obj1) #执行__getitem__
ret2 = obj1[1:3:2]
print(ret2) #执行__setitem__
ret3=obj1[1:4] = [11,22,33,44,66]
print(ret3) #执行__delitem__
del obj1[1:4]
class Foo:
def __iter__(self):
yield 1
yield 2
obj = Foo()
for item in obj:
print(item)
#原理:把iter的值,返回给obj

类和类,类和对象之前的关系检测

class Bar:
pass class Foo(Bar):
pass obj = Foo()
ret = isinstance(obj,Foo)
res = isinstance(obj,Bar)#因为Foo继承了Bar,这里也为true
print(ret)
print(res)
#isinstance:判断这个类,是否属于这个对象 ret1=issubclass(Foo,Bar)
print(ret1)
#issubclass:判断Foo是否是Bar的子类;

super()

#这个程序执行半天也不行,必须用python3执行
class C1: def f1(self):
print("c1.f1") class C2(C1): def f1(self):
#主动执行父类的f1方法
super(C2,self).f1()
print("c2.f1") #方法二:执行C1的f1,python2也可以(不建议用);
# C1.f1(self) obj = C2()
obj.f1() 结果:执行super(C2,self).f1()后,执行print("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_str = "{"+",".join(temp_list) +"}"
return temp_str 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:
return cls.instance
else:
obj = cls('alex')
cls.instance = obj
return obj obj1 = Foo.get_instance()
print(obj1)
obj2 = Foo.get_instance()
print(obj2)
#内存地址都是一样的

主动触发错误:

try:
raise ValueError('主动错误一下') #self.message = '主动错误一下'
print(123) except ValueError as ex:
print(ex) #str except Exception as ex:
print(ex) #__str__,return self.message
else:
pass

异常处理,异常类型:

while True:
num1 = input("num1:")
num2 = input("num2:")
try:
li = []
li[100]
num1 = int(num1)
num2 = int(num2)
result = num1 + num2
except Exception as ex:
print(ex) #输出的类型是str except ValueError as ex:
print(ex) except IndexError as ex:
print(ex)

finally(都会执行):

try:
li = []
li[100]
except IndexError as ex:
print(ex) #str except Exception as ex:
print(ex)
else:
pass
finally:
print("上面的条件成立,不成立,都执行finally")

python笔记 - day8的更多相关文章

  1. Python笔记之不可不练

    如果您已经有了一定的Python编程基础,那么本文就是为您的编程能力锦上添花,如果您刚刚开始对Python有一点点兴趣,不怕,Python的重点基础知识已经总结在博文<Python笔记之不可不知 ...

  2. boost.python笔记

    boost.python笔记 标签: boost.python,python, C++ 简介 Boost.python是什么? 它是boost库的一部分,随boost一起安装,用来实现C++和Pyth ...

  3. 20.Python笔记之SqlAlchemy使用

    Date:2016-03-27 Title:20.Python笔记之SqlAlchemy使用 Tags:python Category:Python 作者:刘耀 博客:www.liuyao.me 一. ...

  4. Python笔记——类定义

    Python笔记——类定义 一.类定义: class <类名>: <语句> 类实例化后,可以使用其属性,实际上,创建一个类之后,可以通过类名访问其属性 如果直接使用类名修改其属 ...

  5. 13.python笔记之pyyaml模块

    Date:2016-03-25 Title:13.Python笔记之Pyymal模块使用 Tags:Python Category:Python 博客地址:www.liuyao.me 作者:刘耀 YA ...

  6. 8.python笔记之面向对象基础

    title: 8.Python笔记之面向对象基础 date: 2016-02-21 15:10:35 tags: Python categories: Python --- 面向对象思维导图 (来自1 ...

  7. python笔记 - day7-1 之面向对象编程

    python笔记 - day7-1 之面向对象编程 什么时候用面向对象: 多个函数的参数相同: 当某一些函数具有相同参数时,可以使用面向对象的方式,将参数值一次性的封装到对象,以后去对象中取值即可: ...

  8. python笔记 - day7

    python笔记 - day7 参考: http://www.cnblogs.com/wupeiqi/articles/5501365.html 面向对象,初级篇: http://www.cnblog ...

  9. python笔记 - day6

    python笔记 - day6 参考: http://www.cnblogs.com/wupeiqi/articles/5501365.html 大纲: 利用递归,实现阶乘: Python反射 pyt ...

随机推荐

  1. LeetCode-Repeated DNA Sequences (位图算法减少内存)

    Repeated DNA Sequences All DNA is composed of a series of nucleotides abbreviated as A, C, G, and T, ...

  2. tomcat配置虚拟目录映射

    本文主要介绍web虚拟目录映射的两种常用方法及配置默认web应用的方法 一.在Server.xml中进行配置 在<Host>元素中添加子元素<Context path=" ...

  3. 【C语言】02-第一个C程序

    由于我们最终要学习的是iOS开发,因此就使用Mac平台下的Xcode搭建C语言开发环境,而不使用Windows系统 如果你是在Windows环境下,可以下载这个简单的C语言学习工具:C/C++程序设计 ...

  4. Linux Path文件夹内容

  5. 提取安卓手机的recovery

    一直都是从网上下载的recovery文件安装到手机.至于这个小小的recovery到底是什么全然不知.能不能自己做一个recovery呢?因为功能比较多的clockworkmod(简称cmw)的官网上 ...

  6. 彻底搞清楚字符编码: ASCII, ISO_8859, GB2312,UCS, Unicode, Utf-8

    彻底搞清楚字符编码: ASCII, ISO_8859, GB2312,UCS, Unicode, U 1.ASCII: 0-127(128-255未使用),美国标准 2.IS0-8859-1(lati ...

  7. Javascript 笔记与总结(2-14)事件

    常用事件: ● onclick 元素点击时 ● onfocus 元素获得焦点时 ● onblur 元素失去焦点时 ● onmouseover 鼠标经过时 ● onsubmit 表单提交时(<fo ...

  8. 数据库中MyISAM与InnoDB区别

    数据库中MyISAM与InnoDB区别 首页 » DIY技术区 » 数据库中MyISAM与InnoDB区别 09:57:40   MyISAM:这个是默认类型,它是基于传统的ISAM类型,ISAM是I ...

  9. Socket简介

    本文全部摘抄http://c.biancheng.net/cpp/html/3029.html 大多数项目是在Linux下开发服务器端,而在Windows下开发客户端,需要经常在两大平台之间进行切换, ...

  10. Latex公式换行、对齐

    http://blog.sina.com.cn/s/blog_64827e4c0100vnqu.html 换行后等式对齐 \begin{equation}\begin{aligned}R(S_2)&a ...