python类的应用补充

python字体颜色显示

实现过程：
终端的字符颜色是用转义序列控制的，是文本模式下的系统显示功能，和具体的语言无关。
转义序列是以ESC开头,即用\033来完成（ESC的ASCII码用十进制表示是27，用八进制表示就是033）。
书写格式：
开头部分：\033[显示方式;前景色;背景色m + 结尾部分：\033[0m
注意：开头部分的三个参数：显示方式，前景色，背景色是可选参数，可以只写其中的某一个；另
外由于表示三个参数不同含义的数值都是唯一的没有重复的，所以三个参数的书写先后顺序没有固定要>求，系统都能识别；但是，建议按照默认的格式规范书写。
对于结尾部分，其实也可以省略，但是为了书写规范，建议\033[***开头，\033[0m结尾。

数值表示的参数含义：
显示方式: 0（默认值）、1（高亮）、22（非粗体）、4（下划线）、24（非下划线）、 5（闪烁）、25（非闪烁）、7（反显）、27（非反显）
前景色: 30（黑色）、31（红色）、32（绿色）、 33（黄色）、34（蓝色）、35（洋 红）、36（青色>）、37（白色）
背景色: 40（黑色）、41（红色）、42（绿色）、 43（黄色）、44（蓝色）、45（洋 红）、46（青色>）、47（白色）

成功: 绿色字体
失败: 红色字体
警告: 黄色字体

example:

class FontColor(object):

OKGREEN = “\033[32m”
ERRRED = “\033[31m”
WARNYELLOW = “\033[33m”

if name == “main”:

f = FontColor()
print(f.OKGREEN + “成功”)
print(f.ERRRED + “成功”)
print(f.WARNYELLOW + “成功”)
print(OKGREEN + ‘HELLO’)

实验结果截图：

类的切片以及索引

python中一切皆对象
那么如何给类实现切片和索引功能呢？
需要几个魔术方法来实现
example:

class Student(object):

def init(self,name.scores):

self.name=name
self.scores=scores

def getitem(self,index) #实现获取索引值

return self.scores[index]

def setitem(self,key,value) #实现索引值的赋值

return self.scores[key]=value

def delitem(self,key) #删除索引值

del self.scores[key]

def mul(self,other) #实现*的效果，具体返回什么取决于代码的业务需求

return [i*other for i in self.scores]

def add(self, other): # 5). 连接的时候必须是同一种数据；类型

#将两个学生的成绩拼接起来
return self.scores + other.scores

def contains(self, item): # 6). 判断某个元素是否存在于这个对象中?

return item in self.scores

def iter(self): # 7). 迭代， 使得该对象可以实现for循环

#将列表转换为迭代的类型， 可以for循环, 一定要返回iter类型的数据；
return iter(self.scores)

def lt(self, other): # 8). 比较两个对象的大小；

return (sum(self.scores)/3) < (sum(other.scores)/3)

property属性

1). Python内置的@property装饰器就是负责把一个方法变成属性调用的;
2). @property本身又创建了另一个装饰器@state.setter，负责把一个
setter方法变成属性赋值，于是，我们就拥有一个可控的属性操作.
3). @property广泛应用在类的定义中，可以让调用者写出简短的代码，
同时保证对参数进行必要的检查，这样，程序运行时就减少了出错的可能性。

from datetime import date
from datetime import time
import time
from colorFont import *
class Book(object):

def init(self, name, kind, state):

self.name = name
self.kind = kind
#0： 借出 1： “未借出”
#书的状态只能是0或者1， 如果是其他， 应该报错；
#查看书状态， 希望是汉字形式， 有实际意义的；
self.__state = 0

@property # 将这个方法转换为类的属性; print(book.state)
def state(self):

if self.__state == 0:

return ERRRED + “借出”

elif self.__state == 1:

return OKGREEN + “未借出”

@state.setter # book.state = 0
def state(self, value):

if value in (0,1):

#更新书状态
self.__state = value
else:
print(ERRRED + “更新错误， 必须是0或者1”)

@state.deleter # del book.state
def state(self):

del self.__state
print(OKGREEN + “删除书状态成功!”)

类方法与静态方法

Python中至少有三种比较常见的方法类型，即实例方法，类方法、静态方法。它们是如何定义的呢？
如何调用的呢？它们又有何区别和作用呢？

首先，这三种方法都定义在类中。
实例方法
定义：第一个参数必须是实例对象，该参数名一般约定为“self”，通过它来传递实例的属性和方法（也可以传类的属性和方法）；
调用：只能由实例对象调用。

类方法
定义：使用装饰器@classmethod。第一个参数必须是当前类对象，该参数名一般约定为“cls”，
通过它来传递类的属性和方法（不能传实例的属性和方法）；
调用：实例对象和类对象都可以调用。

静态方法
定义：使用装饰器@staticmethod。参数随意，没有“self”和“cls”参数，但是方法体中不能使用类或实例的任何属性和方法；
调用：实例对象和类对象都可以调用。

from datetime import date
class Date(object):

def init(self, year, month, day):

self.__year = year
self.__month = month
self.__day = day

#实例方法
def echo(self):

print("%s %s %s" % (self.__year, self.__month, self.__day))
#默认情况下， 需要将所有相关日期的操作封装到Date类中；
#如果不做任何改变， s实质上时实例化的对象本身， 不是我们想要的字符串；

@classmethod # 类方法
def as_string(cls, s): # “2019-10-10”

year, month, day = s.split(’-’)
return cls(year, month, day) # cls实质上就是Date

@staticmethod
def is_valid(s):

year, month, day = map(int, s.split(’-’))
return year > 0 and 0 < month <= 12 and 1 <= day <= 31

if name == “main”:

#实例化日期类
d = Date(2019, 10, 2)
s = “2019-10-10”
#Date.as_string(s).echo()
print(Date.is_valid(s))

with语句的安全上下文管理

class Myopen(object):

def init(self, name, mode=‘r’):

self.name = name
self.mode = mode

def enter(self):
#当with语句进入并开始执行时， 执行的内容, 需要返回一个对象， 在执行结束之后用来关闭或者其他操作；;

self.f = open(self.name, self.mode)
print(“正在打开文件%s…” %(self.name))
return self.f

def exit(self, exc_type, exc_val, exc_tb):
#当with语句执行结束后， 做什么操作

self.f.close()
print(“文件正在关闭…”)

with Myopen(’/tmp/passwd’) as f:

print(f.read())

python的反射机制

反射机制: 让对象告诉我们它的相关信息(对象拥有的属性和方法， 对象所属的类， 这个类是否有某个属性或者方法等等)

1. 判断对象所属的类?

a = [1,2,3,4]
print(type(a))
print(type(turtle))
from datetime import date
d = date(2018, 1,1)
print(type(d))
print(isinstance(1, str))
print(isinstance(turtle, Turtle))

2. 根据魔术方法来获取

print(turtle.class)
print(turtle.dict)
print(turtle.doc)

3. hasattr， getattr, setattr, delattr

print(hasattr(turtle, ‘x’))
print(hasattr(turtle, ‘x1’))
print(getattr(turtle, ‘x’))
#print(getattr(turtle, ‘x1’))
setattr(turtle, ‘x’, ‘100’)
print(getattr(turtle, ‘x’))
delattr(turtle, ‘x’)
print(hasattr(turtle, ‘x’))