python类(二)

其他 2018-09-17 03:09:32 阅读次数: 0

构造方法与析构方法

构造方法: def _ init _(self) 在实例化对象时自动执行。
析构方法： def _ def _(self) 当删除对象时，自动调用的方法。
eg：

class People(object):
    # 实例化对象时自动执行
    def __init__(self, name, age):
        # 把属性和对象名绑定在一起， 便于访问对象的属性.
        self.name = name
        self.age = age
        print("创建对象成功.......")
    #  析构函数, 当你删除对象时， 自动调用的方法。
    #   del 对象名或者程序执行结束之后
    def __del__(self):
        print("删除对象成功.......")
if __name__ == '__main__':
    # 创建对象
    p1 = People('cooffee', 12)
    #del p1

这里写图片描述

对象str与reper方法

str和repr都是对对象的字符串显示， 使用场景不同.
如果没有str的时候， 自动调用repr方法的内容.
eg：

class People(object):
    # 实例化对象时自动执行
    def __init__(self, name, age):
        # 把属性和对象名绑定在一起， 便于访问对象的属性.
        self.name = name
        self.age = age
        print("创建对象成功.......")
    #  析构函数, 当你删除对象时， 自动调用的方法。
    #   del 对象名或者程序执行结束之后
    def __del__(self):
        print("删除对象成功.......")
    #  __str__和__repr__都是对对象的字符串显示， 使用场景不同.
    # 如果没有__str__的时候， 自动调用__repr__方法的内容.
    def __str__(self):
        return  'People(%s, %d)' %(self.name, self.age)
    def __repr__(self):
        return  "People(%s)" %(self.name)
    def __hello(self):
        print("hello")
    def world(self):
        self.__hello()
if __name__ == '__main__':
    # 创建对象
    p1 = People('cooffee', 12)
    print(p1)
    print(p1.__str__())
    p1.world()
    print(str(p1))
    print(repr(p1))

这里写图片描述

_format魔术方法

字符串的format方法
  • 通过位置填充字符串
print("name:{0}, age:{1}, scores:{2}".format('westos', 10, [100, 100, 100]))
print("name:{0}, age:{1}, scores:{0}".format('westos', 10))
print("name:{0}, id:{1:.3f}, scores:{0}".format('westos', 19.2332435))

这里写图片描述

  • 通过key值填充字符串
d = {'max': 100, 'min': 10}
print("MAX: {max}, MIN:{min}".format(max=100, min=10))
print("MAX: {max}, MIN:{min}".format(**d))

这里写图片描述

  • 通过下标或者索引值填充
point = (3,4)
print("x:{0[0]}, y:{0[1]}".format(point))

这里写图片描述

_format魔法方法

format方法: format(对象名)时自动调用

formats = {
    'ymd':"{d.year}-{d.month}-{d.day}",
    'mdy':"{d.month}/{d.day}/{d.year}",
}
class Date(object):
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day
    # format方法: format(对象名)时自动调用
    def __format__(self, format_spec=None):
        if not format_spec:
            format_spec = 'ymd'
        fmt = formats[format_spec] # "{d.year}-{d.month}-{d.day}".format(d=d)
        return  fmt.format(d=self)

d = Date(2019, 8, 25)
print(format(d))
print(format(d, 'mdy'))

这里写图片描述

类的内部装饰器

@property：将类方法变成类属性，使调用类中的方法像引用类中的字段属性一样。被修饰的特性方法，内部可以实现处理逻辑，但对外提供统一的调用方式。遵循了统一访问的原则。

class Book(object):
    def __init__(self, name, author, state, bookIndex):
        self.name = name
        self.author = author
        # 0：'已借出' 1:'未借出'
        self.__state = state
        self.bookIndex = bookIndex

    # 将类方法变成类属性
    # 使用时, 没有装饰器b.state()
    # 使用时, 有装饰器b.state
    @property
    def state(self):
        if self.__state == 0:
            return  '已借出'
        elif self.__state == 1:
            return  '未借出'
        else:
            return  "状态异常"
    # 当修改属性state时, 自动执行下面的方法; b.state = 10
    @state.setter
    def state(self, value):
        # if value == 0 or value == 1:
        if value in (0,1):
            # 更新书籍的状态
            self.__state = value

    @state.deleter
    def state(self):
        print("is deleteing......")

    def __str__(self):
        return  'Book(%s, %d)' %(self.name, self.__state)
b = Book('python', 'guido', 1, 'chddf')
b.state = 10
print(b.state)
b.state = 0
print(b.state)
del  b.state

这里写图片描述

类方法与静态方法

@staticmethod：将类中的方法装饰为静态方法，即类不需要创建实例的情况下，可以通过类名直接引用。到达将函数功能与实例解绑的效果。
@classmethod：类方法的第一个参数是一个类，是将类本身作为操作的方法。类方法被哪个类调用，就传入哪个类作为第一个参数进行操作。
eg：

class Date(object):
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day =  day
    # echo普通方法, 默认情况下会传递对象给echo
    def echo(self):
        return  "%s %s %s" %(self.year, self.month, self.day)
    # 默认传递类本身给这个方法;
    @classmethod
    def as_string(cls, s):
        print(cls)
        month, day, year = s.split('/')
        d = cls(year, month, day)
        return d
    #  默认python解释器不会传递任何参数
    @staticmethod
    def is_vaild(s):
        # 批量将年月日转换成整形(列表生成式， map)
        # month, day, year = s.split('/')
        # month, day, year = [int(i) for i in s.split('/')]
        month, day, year = map(int, s.split('/'))
        return 0 < month <= 12 and 0 < day <= 31 and 1 < year < 9999
s = '10/10/2018'
print(Date.is_vaild(s))
d=Date.as_string(s)
print(d.year)
print(d.is_vaild('13/10/2019'))

这里写图片描述

类的切片、索引、重复、连接与成员操作符

类的索引与切片

_ getitem_: li[0]
_ setitem __: li[0] = 10
_ delitem _: del li[0]

class Student(object):
    def __init__(self, name, scores):
        self.name = name
        self.scores = scores
    # 支持索引; s[index]
    def __getitem__(self, index):
        # print("获取索引对应的value值")
        return  self.scores[index]
    # s[索引] = 修改的值
    def __setitem__(self, index, value):
        self.scores[index] = value
    # del s[索引]
    def __delitem__(self, index):
        del self.scores[index]
s = Student('cooffee', [87, 92, 78])
print(s[0])
print(s[-1])
s[1]=88
print(s[1])
print(s[:])
print(s[:-1])
#**************************key获取value值***********************
# 可以获取所有的属性为key值, 以及对应的value值, 并封装为一个字典返回.
print(s.__dict__)

这里写图片描述

class Student(object):
    def __init__(self, name, scores):
        self.name = name
        self.scores = scores
    # 支持索引; s[index]
    def __getitem__(self, index):
        # print("获取索引对应的value值")
        return  self.__dict__[index]
    # s[索引] = 修改的值
    def __setitem__(self, index, value):
        self.__dict__[index]=value
    # del s[索引]
    def __delitem__(self, index):
        del self.__dict__[index]
s = Student('cooffee', [87, 92, 78])
#**************************key获取value值***********************
# 可以获取所有的属性为key值, 以及对应的value值, 并封装为一个字典返回.
print(s.__dict__)
print(s['scores'])
s['name']='floating'
print(s['name'])
print(s.__dict__)

这里写图片描述

重复、连接与成员操作符
from collections import Iterable
class Student(object):
    def __init__(self, name, scores):
        self.name = name
        self.scores = scores
        self.power=100
        self.astr='a'
    # obj1 + obj2
    def __add__(self, other):
        # 更新self对象的power属性值；
        self.power=  self.power+ other.power
        self.astr= self.astr+other.astr
        return  self
    # obj1 * 3
    def __mul__(self, other):
        # *的效果是， 能量*power
        return  self.scores * other
    # 成员操作符； item in obj1
    def __contains__(self, item):
        return  item in self.scores
    # 可以for循环迭代
    def __iter__(self):
        """
        iter([1,2,3,4,5])
        <list_iterator object at 0x7f6e1f51ffd0>
        iter({1,2,3,4,5})
        <set_iterator object at 0x7f6e1f567318>
        """
        # 迭代返回的是成绩
        return  iter(self.scores)
    def __repr__(self):
        return  "Student:%s %s %s" %(self.name,self.power,self.astr)
s1 = Student('cooffee1', [101,100,100])
s2 = Student('cooffee2', [100,100,100])
s3 = Student('cooffee3', [100,100,100])
# 连接的实现;
print(s1 + s2 + s3)
# 重复:
print(s1*3)
# 成员操作符
print(200 in s1)
print(100 in s1)
print(200 not in s1)
print(100 not in s1)
# for循环迭代
for i in s1:
    print(i)
print(isinstance(s1, Iterable))

这里写图片描述

类比较大小及计算长度
class Student(object):
    def __init__(self, name, scores, power):
        self.name = name
        self.scores = scores
        self.power = power
    def __add__(self, other):
        # 更新self对象的power属性值；
        self.power =  self.power + other.power
        return  self
    # obj1 > obj2
    def __gt__(self, other):
        return  self.power > other.power
    # obj >= obj2
    __ge__ = lambda  self, other: self.power >= other.power
    # obj1 ==  obj2
    def __eq__(self, other):
        return self.power ==  other.power
    def __ne__(self, other):
        return  self.power !=  other.power
        # return  not self.__eq__(other)
    def __repr__(self):
        return  "Student:%s,%s" %(self.name, self.power)
    def __len__(self):
        return  len(self.scores)
s1 = Student('westos1', [101,100,100], 100)
s2 = Student('westos2', [100,100,100], 101)
s3 = Student('westos3', [100,100,100], 80)
print(s1 > s2 > s3)
print(s1>=s2)
print(s1<s2)
print(s1 == s2)
print(s1 != s2)
print(len(s1))

这里写图片描述

_ cal l_实现一个单例模式

# 实现一个单例模式====
class Student(object):
    def __init__(self, name, scores, power):
        self.name = name
        self.scores = scores
        self.power = power
    def __call__(self, *args, **kwargs):
        return "对象被调用。。。"
    # class: 实例化对象之前执行
    def __new__(cls, *args, **kwargs):
        # 判断是否obj对象是否已经被创建, 如果没有被创建， 则创建，
        if not hasattr(cls, 'obj'):
            cls.obj = object.__new__(cls)
        # 如果已经创建成功，则返回创建好的对象
        return  cls.obj
s1 = Student('cooffee1', [101,100,100], 100)
s2 = Student('cooffee1', [101,100,100], 100)
s3=Student('floating',[12,23,44],33)
print(s1)
print(s2)
print(s3)
print(s2.name)
print(s1.name)
print(s3.name)

这里写图片描述

_with语句

上下文管理协议
1). 当with语句开始运行的时候，执行什么方法;
2). 当with语句执行结束之后出发某个方法的运行;
eg：

class MyOpen(object):
    def __init__(self, filename, mode='r'):
        self._name = filename
        self._mode = mode
    # 当with语句开始运行的时候，执行什么方法;
    def __enter__(self):
        self.f = open(self._name, self._mode)
        return  self.f
    # 当with语句执行结束之后出发某个方法的运行;
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()
    @property
    def name(self):
        return  self._name
    @property
    def mode(self):
        return  self._mode
with MyOpen('/mnt/passwd')   as f:
    print(f.closed)
    print(f.read(5))
print(f.closed)

这里写图片描述

面向对象的反射机制

反射: 让对象告诉我们相关信息(对象拥有的属性和方法， 对象所属的类等….)
1). 如何知道对象拥有的属性和方法
print(dir(对象))
2). 判断对象所属的类
print(type(对象))
print(isinstance(对象，类))**
3). 跟据对象可以获取的内容
print(对象._ class _)
print(对象._ dict _)
print(对象._ doc _)

class Student(object):
    """
    这是student类的帮助文档
    """
    def __init__(self, name, age):
        self.name = name
        self.__age = age
    def get_score(self):
        return  "score"
    def get_grade(self):
        return 'grade'
s1 = Student("cooffee", 10)
print(type(s1))
print(dir(s1))
print(isinstance(s1, Student))
print(isinstance('hello', Student))
print(s1.__class__)
print(s1.__dict__)
print(s1.__doc__)

这里写图片描述
4). hasattr, getattr, setattr, delattr
hasattr: 判断对象是否包含对应的属性或者方法名;
print（hasattr（对象，属性或方法）
getattr: 用于返回对象的属性值或者方法名对应的方法体;
print(getattr(对象,属性或方法)
eg：

class Student(object):
    """
    这是student类的帮助文档
    """
    def __init__(self, name, age):
        self.name = name
        self.__age = age
    def get_score(self):
        return  "score"
    def get_grade(self):
        return 'grade'
s1 = Student("cooffee", 10)
# 4). hasattr, getattr, setattr, delattr
# hasattr: 判断对象是否包含对应的属性或者方法名;
print(hasattr(s1, 'name'))
print(hasattr(s1, '__age'))  # 私有属性， 私有方法， 是不能判断的；
print(hasattr(s1, 'set_score'))
print(hasattr(s1, 'get_score'))
# # getattr: 用于返回对象的属性值或者方法名对应的方法体;
print(getattr(s1, 'name'))
print(getattr(s1, '__age', 'no attr'))
print(getattr(s1, 'get_score', 'no method'))  # 获取方法名， 如果要执行方法， 直接调用即可
print(getattr(s1, 'get_score', 'no method')())

这里写图片描述

class Student(object):
    """
    这是student类的帮助文档
    """
    def __init__(self, name, age):
        self.name = name
        self.__age = age
    def get_score(self):
        return  "score"
    def get_grade(self):
        return 'grade'
s1 = Student("cooffee", 10)
# setattr:
# 修改某个属性的值
setattr(s1, 'name', 'floating')
print(getattr(s1, 'name'))
# 添加某个属性及对应的值;
setattr(s1, 'score', 100)
print(getattr(s1, 'score'))
# 修改方法
def get_score1():
    return "这是修改的方法内容"
setattr(s1, 'get_score', get_score1)
print(getattr(s1, 'get_score')())
def set_score():
    return  "这是添加的方法"
# 添加方法
setattr(s1, 'set_score', set_score)
print(getattr(s1, 'set_score')())
# delattr
delattr(s1, 'name')
print(hasattr(s1, 'name'))

这里写图片描述

反射机制动态方法调用

https://www.csdn.net/nav/newarticles
https://www.csdn.net/nav/watchers
https://www.csdn.net/nav/news
https://www.csdn.net/nav/ai

class Web(object):
    def newarticles(self):
        return  "<h1>newarticles</h1>"

    def watchers(self):
        return  "<h1>watchers</h1>"

    def news(self):
        return "<h1>news</h1>"

    def ai(self):
        return "<h1>ai</h1>"
flask = Web()
def run():
    url = input("url:").split('/')[-1]
    if hasattr(flask, url):  # ai
        return getattr(flask, url)()
    else:
        return "<h1>404</h1>"
if __name__ == "__main__":
    while True:
        print(run())

这里写图片描述

反射机制之动态导入模块

动态导入模块
/bbs/login
/bbs/index
/blog/login
/blog/index

def run():
    # '/bbs/index'  ; modules='bbs', func=‘index’
    modules, func  = input("url:").split('/')[-2:]
    # 导入一个包含变量的模块名， 其中obj是模块的别名
    # 注意: __import__内置函数用于动态加载类和函数.
    # 如果一个模块经常变化， 就可以使用__import__实现动态导入.
    obj = __import__('lib.'+modules)
    # 判断模块中是否有指定的方法， 如果有， 则执行代码， 如果没有， 404报错;
    print(obj)
    if hasattr(obj, func):
        fun = getattr(obj, func)
        return  fun()
    else:
        return  "404： 页面找不到"
if __name__ == "__main__":
    while True:
        run()

这里写图片描述

猜你喜欢

转载自blog.csdn.net/weixin_42635252/article/details/82316390
今日推荐
手把手教你用 LangChain 实现大模型 Agent
外星人入侵（python）
超全的免费chatGPT列表【建议收藏】
52.2k star! 自己部署gpt4free, 免费使用各种GPT
2024年 （第十届）全国大学生统计建模大赛优秀论文解析——中国经济发展与碳排放库兹涅茨曲线的验证研究
【自动驾驶技术】自动驾驶汽车AI芯片汇总——NVIDIA篇
7个免费的ChatGPT网站，给大家送上
Angular v18 正式发布！
【VMware】 vCenter Converter standalone 6.6.0正式版下载
开源日报 | Angular v18；大模型价格战下的推理优化；Mistral AI以开源模型瞄准美国市场；硅谷有自己的鲁迅
数学建模Matlab之数据预处理方法
充电桩---ISO15118协议详细介绍
周排行
keepalived实现LB配置
数据库相关中间件收录集
Spring Boot 入门之 Web 篇（二） Spring Boot 入门之 Web 篇（二）
gitee 搭建个人网站
Java校招基础知识总结（横扫BAT,就业经验交流会演讲稿）
工程管理器
Delphi定位TDataSet数据集最后一条记录
cocos2dx笔记1:概述
Java实现 LeetCode 110 平衡二叉树
MacBook IDEA激活码
每日归档
更多
2024-05-30(4)
2024-05-29(65)
2024-05-28(2)
2024-05-27(56)
2024-05-26(6)
2024-05-25(68)
2024-05-24(65)
2024-05-23(9)
2024-05-22(41)
2024-05-21(8)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022