Python的面向对象高级编程

其他 2018-09-09 14:49:17 阅读次数: 0

一.构造函数与析构函数

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


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


if __name__ == '__main__':
    # 创建对象
    cat = Animal('tom', 78)
    #删除对象
    del cat
    print(cat)

这里写图片描述
这里写图片描述

二.__str__、__repr__

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

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):
        # print(对象名)   print(str(对象名))
        # print('People(%s, %d)' %(self.name, self.age))
        return  'People(%s, %d)' %(self.name, self.age)

    def __repr__(self):
        # print(repr(对象名))  或者交互式环境中直接： 对象名
        return  "People(%s)" %(self.name)

if __name__ == '__main__':
    # 创建对象
    p1 = People('messi', 31)
    print(p1)
    print(str(p1))
    print(repr(p1))

这里写图片描述

三.字符串的format方法

1. 通过位置填充字符串

# 通过位置填充字符串
print("name:{0}, age:{1}, scores:{2}".format('villa', 10, [99, 100, 101]))
print("name:{0}, age:{1}, scores:{0}".format('villa', 10))
print("name:{0}, id:{1:.4f}, scores:{0}".format('villa', 3.14159265354))

这里写图片描述
2.通过key值填充字符串

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

这里写图片描述
3.通过下标或者索引值填充

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

这里写图片描述
4.面向对象中的使用

# 面向对象操作
class Book(object):
    def __init__(self, name, author, state, bookIndex):
        self.name = name
        self.author = author
        # 0：'已借出' 1:'未借出'
        self.state = state
        self.bookIndex = bookIndex

    def __str__(self):
        return  'Book(%s, %d)' %(self.name, self.state)
book1 = Book('python', 'guido', 1, 'IND444')
book2 = Book('java', 'Sun', 1, 'IND445')
print("name:{b.name}, state:{b.state}, bookIndex:{b.bookIndex}".format(b=book1))
print("name:{0.name}, state:{0.state}, author:{1.author}".format(book1,book2))

这里写图片描述

四.__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):
        # return "这是显示format的内容"
        # if format_spec:
        #     format_spec = format_spec
        # else:
        #     format_spec = 'ymd'
        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)

这里写图片描述

简化版本

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:
            return  "%s-%s-%s" %(self.year, self.month, self.day)
        else:
            if format_spec == 'ymd':
                return  "%s-%s-%s" %(self.year, self.month, self.day)
            elif format_spec == 'dmy':
                return   "%s/%s/%s" %(self.day, self.month, self.year)
            else:
                return  "error format"
d = Date(2019, 8, 25)
print(format(d))
print(format(d, 'ymd'))
print(format(d, 'dmy'))

这里写图片描述

五.类内部装饰器@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
    #setter实现了通过属性x来对私有变量_x进行操作
    @state.setter
    def state(self, value):
        # if value == 0 or value == 1:
        if value in (0,1):
            # 更新书籍的状态
            self.__state = value
#deleter实现了通过属性x来对私有变量_x进行操作
    @state.deleter
    def state(self):
        print("is deleteing......")

    def __str__(self):
        return  'Book(%s, %d)' %(self.name, self.__state)


b = Book('Gaopin', 'ZhangSW', 1, 'WES523')
# print(b.state)
#
# # 1). 书籍的状态可以人以改变， 并不能限制只能为0或者1；
#   2). 书籍状态如何友好的显示?
# b.state = 10
# print(b.state)

# 3). 问题解决, 但是调用比较复杂, 可读性不高.
# print(b.get_state())
# print(b.set_state(10))
# print(b.get_state())


# 4).
print(b.state)
b.state = 0
print(b.state)

del  b.state

这里写图片描述

六.类的切片与索引

class Student(object):
    def __init__(self, name, scores):
        self.name = name
        self.scores = scores

    # 支持索引、切片; s[key]
    def __getitem__(self, key):
        # print("获取索引对应的value值")
        return  self.__dict__[key]


    # s[key] = 修改的值
    def __setitem__(self, key, value):
        self.__dict__[key] = value

    # del s[key]   根据索引删除某个值
    def __delitem__(self, key):
        del self.__dict__[key]


    def hello(self):
        return  "hello"
s = Student('westos', [101, 100, 100])
print(s[0])
print(s[1])
print(s[2])

# 0, 200
s[0] = 200
print(s[0])
print(s.scores)
del s[0]
print(s.scores)
print(s[1:3])
s[1:3] = [0,0]
print(s[:])
del s[:-1]
print(s[:])
print(s[0])

这里写图片描述

七.类的重复与连接的实现

from collections import Iterable


class Student(object):
    def __init__(self, name, scores):
        self.name = name
        self.scores = scores
        self.power = 100
    # obj1 + obj2
    def __add__(self, other):
        # 更新self对象的power属性值；
        self.power =  self.power + other.power
        return  self
    # obj1 * 3
    def __mul__(self, other):
        # *的效果是， 能量*power
        return  self.power * 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" %(self.name, self.power)

s1 = Student('westos1', [101,100,100])
s2 = Student('westos2', [100,100,100])
s3 = Student('westos3', [100,100,100])

# 连接的实现;
print(s1 + s2 + s3)

# 重复:
a = 3; print(a*3)
s = 'a'; print(s*3)
li = [1,2,3]; print(li*3)
print(s1*3)


# 成员操作符
print(s1.scores)
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)
print(s1 > s2 > s3)
print(s1>=s2)
print(s1<s2)
print(s1 == s2)
print(s1 != s2)
print(len(s1))

这里写图片描述

九.类方法与静态方法

1.类方法@classmethod
默认传递类本身给这个方法;
如果使用原本的方法传递给类，是只能传递一个一个数，无法传递一个整体
所以调用classmethod，将传入值进行处理后，把返回值传入__init__进行数值初始化.

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
s = '10/10/2018'
print(Date.as_string(s).echo())

这里写图片描述
2.静态方法

默认python解释器不会传递任何参数

class Date(object):
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day =  day
    #  默认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))

这里写图片描述

十.，面向对象的反射机制

1.显示对象所拥有的方法和属性

print(dir(str))
f = open('hello.txt')
print(dir(f))

这里写图片描述
2.判断对象所属的类

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("fentiao", 10)
print(type(s1))
print(isinstance(s1, Student))
print(isinstance('hello', Student))

这里写图片描述
3. 跟据对象可以获取的内容

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("villa", 35)
print(s1.__class__)
print(s1.__dict__)
print(s1.__doc__)

这里写图片描述
4. hasattr, getattr, setattr, delattr

# hasattr: 判断对象是否包含对应的属性或者方法名;
print(hasattr(s1, 'name'))
print(hasattr(s1, '__age'))  # 私有属性， 私有方法， 是不能判断的；
print(hasattr(s1, 'score'))

print(hasattr(s1, 'get_score'))
print(hasattr(s1, 'set_score'))


# getattr: 用于返回对象的属性值或者方法名对应的方法体;
print(getattr(s1, 'name'))
print(getattr(s1, '__age', 'no attr'))
print(getattr(s1, 'get_score', 'no method'))  # 获取方法名， 如果要执行方法， 直接调用即可
print(getattr(s1, 'set_score', 'no method'))  # 获取方法名， 如果要执行方法， 直接调用即可



# setattr:
# 修改某个属性的值
setattr(s1, 'name', 'westos')
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'))

print(hasattr(s1, 'set_score'))
delattr(s1, 'set_score')
print(hasattr(s1, 'set_score'))

猜你喜欢

转载自blog.csdn.net/weixin_41179709/article/details/82355804
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
Java基础复习_day13_Collection集合
2018.11.16 c语言学习经验
且看Java内置四大核心函数式接口
小程序云开发中数据库的数据分段和显示图片
python的函数
Web-JS进阶
【干货】C++常用代码积累笔记大全
Spring的ioc操作 与 IOC底层原理
构建之法20191121-11 Scrum立会报告+燃尽图 07
Spring boot之Hello World访问404
每日归档
更多
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022