首页 > 编程语言 >python面向对象-学习笔记（六、方法相关的补充）

python面向对象-学习笔记（六、方法相关的补充）

时间：2023-10-29 22:25:45浏览次数：42  
标签：__ Person python self 笔记 面向对象 print age def

私有化方法

私有方法 
class Person:
    __age = 18

    # 私有方法
    def __run(self):
        print("run")

    # def _Person__run(self):
    #     print("Person run")


p = Person()
# p.__run()
# p._Person__run()

print(Person.__dict__)

image

内置特殊方法

信息格式化操作__str__方法 
class Person:
    def __init__(self, n, a):
        self.name = n
        self.age = a
    # 信息格式化
    def __str__(self):
        # s = "name=" + self.name + ";" + "age=" + str(self.age)
        s1 = f"name={self.name};age={self.age}"
        return s1


p1 = Person("sz", 18)
# print(p1.name)
# print(p1.age)
print(p1, type(p1))

p2 = Person("zhangsan", 19)
# print(p2.name)
# print(p2.age)
print(p2)

s = str(p1)
print(s, type(s))

image

信息格式化操作__repr__方法 
class Person:
    def __init__(self, n, a):
        self.name = n
        self.age = a

    # def __str__(self):
    #     # s = "name=" + self.name + ";" + "age=" + str(self.age)
    #     s1 = f"name={self.name};age={self.age}"
    #     return s1

    def __repr__(self):
        return "reprxxxxx"


p1 = Person("sz", 18)
# 首先找类内部的__str__方法的返回；没有则找__repr__方法的返回
print(p1, type(p1))

p2 = Person("zhangsan", 19)
print(p2)

print(repr(p1))

image

__str__方法和__repr__方法的区别&联系 
import datetime

t = datetime.datetime.now()
print(t)
print(repr(t))

tmp = repr(t)
result = eval(tmp)

print(result)

image

对象像函数一样调用__call__方法 
class PenFactory:
    def __init__(self, p_type):
        self.p_type = p_type

    def __call__(self, p_color):
        print("创建了一个%s这个类型的画笔,它是%s颜色" % (self.p_type, p_color))


gangbiF = PenFactory("钢笔")
gangbiF("黄色")
gangbiF("绿色")
gangbiF("蓝色")

qianbiF = PenFactory("铅笔")
qianbiF("黑色")
qianbiF("白色")

image

对象的索引操作__setitem__、__getitem__、__delitem__方法 
class Person:
    def __init__(self):
        self.cache = {}

    def __setitem__(self, key, value):
        print("setitem", key, value)
        self.cache[key] = value

    def __getitem__(self, item):
        print("getitem", item)
        return self.cache[item]

    def __delitem__(self, key):
        print("delitem", key)
        del self.cache[key]


p = Person()

p["name"] = "sz"

print(p["name"])

del p["name"]

print(p.cache)
print(p.__dict__)

image

对象的切片操作__setitem__、__getitem__、__delitem__ 
l = [1, 2, 3, 4, 5]
print(l[3])
print(l[1:4:2])


class Person:

    def __init__(self):
        self.items = [1, 2, 3, 4, 5, 6, 7, 8]

    def __setitem__(self, key, value):
        # print(key, value)
        # print(key.start)
        # print(key.stop)
        # print(key.step)
        # print(value)
        if isinstance(key, slice):
            self.items[key.start:key.stop:key.step] = value

    def __getitem__(self, item):
        print("getitem", item)

    def __delitem__(self, key):
        print("delitem", key)


p = Person()

p[0:4:2] = ["a", "b"]
print(p.items)
p[0:5:2]

image

对象的比较操作__eq__、__ne__、__ge__、__le__、__gt__、__lt__方法 
class A:
    def __init__(self, age, height):
        self.age = age
        self.height = height

    # 等于
    def __eq__(self, other):
        # print(other)
        return self.age == other.age

    # 不等于
    def __ne__(self, other):
        print("not equal")

    # # 大于等于
    # def __ge__(self, other):
    #     pass

    # # 大于
    # def __gt__(self, other):
    #     pass

    # # 小于等于
    # def __le__(self, other):
    #     print("__le__")
    #     pass

    # 小于(如果没有__gt__，大于也使用这个方法)
    def __lt__(self, other):
        print("__lt__")
        return self.age < other.age

    pass


a1 = A(18, 180)
a2 = A(19, 190)

print(a1 == a2)
print(a1 != a2)
# print(a1 <= a2)

print(a1 > a2)

image

对象的比较操作补充-装饰器@functools.total_ordering 
import functools


# 这个装饰器，可以补全比较操作
@functools.total_ordering
class Person:
    def __lt__(self, other):
        print("lt")
        return False

    def __eq__(self, other):
        print("eq")
        return True


p1 = Person()
p2 = Person()
print(p1 <= p2)
print(Person.__dict__)

image

上下文环境的布尔值 __bool__方法 
class Person:
    def __init__(self):
        self.age = 20

    # 可以控制实例真假
    # 如果成年了就打印
    def __bool__(self):
        return self.age >= 18

    pass


p = Person()

# 非空即真
if p:
    print("我成年啦!!!")

image

对象的遍历操作__getitem__方法 
class Person:

    def __init__(self):
        self.result = 0

    def __getitem__(self, item):
        self.result += 1
        if self.result >= 6:
            raise StopIteration("停止遍历")
        return self.result

    pass


p = Person()

for i in p:
    print(i)

image

对象的遍历操作__iter__、__next__方法（迭代器对象） 
# 实现__iter__方法，可迭代对象
# 同时实现__iter__和__next__方法，迭代器对象
class Person:

    def __init__(self):
        self.items = [1, 2, 3, 4, 5, 6, 7, 8]
        # self.result = 0

    # def __getitem__(self, item):
    #     print("getitem")
    #     self.result += 1
    #     if self.result >= 6:
    #         raise StopIteration("停止遍历")
    #     return self.result

    # 优先级比__getitem__要高
    def __iter__(self):
        print("iter")
        # iter 返回迭代数据
        # return iter(self.items)
        # 需要实现__next__方法才可以
        return self

    def __next__(self):

        if len(self.items) > 0:

            item = self.items.pop()
        else:
            item = None

        if item is None:
            raise StopIteration("已经完成遍历")

        return item
        # self.result += 1
        # if self.result >= 6:
        #     raise StopIteration("停止遍历")
        # return self.result

    pass


p = Person()

# 遍历
for i in p:
    print(i)
# 获取下一个元素
# print(next(p))
# print(next(p))
# print(next(p))
# print(next(p))
# print(next(p))
# print(next(p))
# print(next(p))

image

迭代器对象 
class Person:

    def __init__(self):
        self.age = 1

    def __iter__(self):
        # 恢复迭代器初始值
        self.age = 1
        return self

    def __next__(self):
        self.age += 1

        if self.age >= 3:
            raise StopIteration("stop")

        return self.age


p = Person()

for i in p:
    print(i)
print(p.age)

# 判断实例是否是迭代器
# 类需要实现__iter__和__next__两个方法才能使得类的实例为迭代器
import collections.abc

print(isinstance(p, collections.abc.Iterator))
print(isinstance(p, collections.abc.Iterable))

image

Iter函数的使用 

class Person:

    def __init__(self):
        self.age = 1

    def __getitem__(self, item):
        self.age += 1
        if self.age >= 6:
            raise StopIteration("停止遍历")
        return self.age

    def __iter__(self):
        self.age = 1
        return self

    def __next__(self):
        self.age += 1

        if self.age >= 4:
            raise StopIteration("stop")

        return self.age

    def __call__(self, *args, **kwargs):
        print('call')
        self.age += 1

        if self.age >= 6:
            raise StopIteration("stop")

        return self.age


p = Person()

# for i in p:
#     print(i)
#
# print(f"当前的p.age值: {p.age}")

# p.age = 1
# pt = iter(p)
# pt = iter(p.__next__(), 4)

pt = iter(p, 4)

# print(pt is p)
#
for i in pt:
    print(i)

print(f"当前的p.age值: {p.age}")

image

描述器property方法 
class Person:
    def __init__(self):
        self.__age = 10

    def get_age(self):
        return self.__age

    def set_age(self, value):
        if value < 0:
            value = 0
        self.__age = value

    def del_age(self):
        del self.__age
    
    # 数据描述器
    age = property(get_age, set_age, del_age)


p = Person()
help(p)

image

描述器@property装饰器 
class Person:
    def __init__(self):
        self.__age = 10

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self, value):
        if value < 0:
            value = 0
        self.__age = value

    @age.deleter
    def age(self):
        del self.__age


p = Person()
help(p)

image

描述器__get__、__set__、__delete__方法 
# 描述器只在新式类中生效
class Age:
    def __get__(self, instance, owner):
        print("get")

    def __set__(self, instance, value):
        print("set")

    def __delete__(self, instance):
        print("delete")


class Person:
    age = Age()

# 描述器需要通过实例来操作，不能通过类来操作
p = Person()
p.age = 1
print(p.age)
del p.age

help(p)

image

描述器-调用细节

资料描述器&非资料描述器
覆盖默认的__getattribute__会导致怎么样的结果
实例属性的正常访问顺序

# 描述器只在新式类中生效
# 资料描述器 实现get&set方法
# 非资料描述器 仅仅实现get方法
# 优先级：资料描述器>实例属性>非资料描述器
class Age:
    def __get__(self, instance, owner):
        print("get")

    def __set__(self, instance, value):
        print("set")


    def __delete__(self, instance):
        print("delete")


class Person:
    age = Age()

    def __init__(self):
        # 实例属性的正常访问顺序
        # 1.实例对象自身的__dict__字典
        # 2.对应类的__dict__字典
        # 3.如果有父类，会再往上层的__dict__字典
        # 4.如果没有找到，又定义了__getattr__方法，就会调用这个方法
        self.age = 10

    # 系统默认实现这个方法，则会检测描述器是否实现了__get__方法，如果有就直接调用
    # 如果没有就按照实例属性的正常访问顺序查找
    # def __getattribute__(self, item):
    #     print("getattribute")


p = Person()
# p.age = 1
print(p.age)
print(p.__dict__)

资料描述器>实例属性
image

实例属性>非资料描述器
image

描述器-值的存储问题 
# 值需要存储在instance实例中
class Age:
    def __get__(self, instance, owner):
        print("get", self, instance, owner)
        return instance.v

    def __set__(self, instance, value):
        print("set", self, instance, value)
        instance.v = value

    def __delete__(self, instance):
        print("delete")
        del instance.v


class Person:
    age = Age()


p1 = Person()
p1.age = 18
print(p1.__dict__)
# print(p.age)
# del p.age

p2 = Person()
p2.age = 20
print(p2.__dict__)

image

使用类-实现装饰器 
# # 装饰器
# def Check(func):
#     def inner():
#         print("登录验证")
#         func()
#
#     return inner


# 类-实现装饰器(功能等同于上面的装饰器)
class Check:
    def __init__(self, func):
        self.f = func

    def __call__(self, *args, **kwargs):
        print("登录验证")
        self.f()


@Check
def fashuoshuo():
    print("fashuoshuo")


# fashuoshuo()

# 可以用装饰器调用，也可以用这个方式调用
# fashuoshuo = Check(fashuoshuo)
fashuoshuo()

image

学习链接: 【Python】零基础入门 面向对象编程（强烈推荐）

标签：__,Person,python,self,笔记,面向对象,print,age,def
From： https://www.cnblogs.com/amanzhj/p/17556534.html

相关文章

  • 第四章学习笔记
    并发编程本章论述了并发编程，介绍了并行计算的概念，指出了并行计算的重要性，比较了顺序算法与并行算法，以及并行性与并发性，解释了线程的原理及相对于进程的优势。通过示例介绍了Pthread中的线程操作，句括线程管理函数。互斥量、连接、条件变量和屏障等线程同步工具;通过具体示例演......
  • MySQL技术内幕InnoDB存储引擎学习笔记
    1、MYSQL体系结构: 2、INNODB存储引擎:支持事务，其设计目的主要是面向在线事务处理的应用。特点：行锁设计，支持外键，并支持类似oracle的非锁定读，同时设计用来最有效的利用使用内存和CPU；5.5.8开始默认使用innodb存储引擎使用多版本并发控制来获得高并发性，并实现了sql的4种隔离级......
  • django基础到高手知识笔记总结 共4大模块50页md文档 第2章：django视图和模板的使用
    当你考虑开发现代化、高效且可扩展的网站和Web应用时，Django是一个强大的选择。Django是一个流行的开源PythonWeb框架，它提供了一个坚实的基础，帮助开发者快速构建功能丰富且高度定制的Web应用完整版笔记直接地址：请移步这里共10章，31子模块，总计18647字工程搭建学习目标......
  • stm32 uboot调试1--Apple的学习笔记
    一，前言openocd+stlink的vscode远程gdb调试环境搭建完成了，那么用吧，串口也不连接了。用自带的configs/stm32f429-discovery_defconfig进行的编译，然后就直接调试了。二，问题记录问题1：board_init_f进入fdt初始化就进入hang。答：因为fdt是分离的但是我并没有下载到某个地址，于是先配置为嵌......
  • python pandas安装失败的解决方法之一
    从https://www.lfd.uci.edu/~gohlke/pythonlibs/中下载对应的whl文件例:pandas‑1.4.3‑cp39‑cp39‑win32.whl,39指python3.9用下好放到python目录下的Scripts文件夹中，例我的是C:\Users\Administrator\AppData\Local\Programs\Python\Python39-32\Scripts再在路径栏全选输入cmd（......
  • 学习笔记7——并发编程与线程同步
    学习笔记7——并发编程与线程同步本文将深入探讨并发编程的概念，介绍了并行计算的重要性，比较了顺序算法与并行算法，解释了线程的原理和相对于进程的优势，并通过示例介绍了在Pthread中进行线程操作。我们还将讨论线程同步工具，如互斥量、信号量和屏障，以及如何避免并发程序中的死锁问题......
  • 在Python中手动引发（抛出）异常
    内容来自DOChttps://q.houxu6.top/?s=在Python中手动引发（抛出）异常如何在Python中引发异常，以便稍后可以通过except块捕获？在Python中，可以使用raise语句来引发异常。要通过except块捕获异常，需要使用适当的异常类型并提供一个错误消息。以下是一个示例：try:#这里是可能引......
  • python进阶14大模块200页知识体系md笔记，第3篇：linux命令进阶
    本完整笔记从14大模块展示了python高级用的应用。分别有Linux命令，多任务编程、网络编程、Http协议和静态Web编程、html+css、JavaScript、jQuery、MySql数据库的各种用法、python的闭包和装饰器、mini-web框架、正则表达式等相关文章的详细讲述。完整版笔记直接地址：请移步这里......
  • 2023-2024-1 20211211 第四章读书笔记
    第四章读书笔记一、知识点归纳（思维导图）二、收获总结并行线程的主要挑战有：线程同步、死锁、资源竞争、上下文切换开销等问题。线程级别的并行是指在多核处理器上同时执行多个线程，每个线程独立执行不同的任务。指令级别的并行是指在单个核心的处理器上同时执行多条指令。并发......
  • 《需求分析与系统设计》阅读笔记2
    需求规格说明涉及对客户需求在需求确定期间进行详细建模，特别关注系统预期提供的服务。软件体系结构定义了系统内软件组件和子系统之间的相互作用方式以及它们的结构和组织形式。模型-视图-控制器（MVC）框架是许多现代体系结构框架和相关设计模式的支持者。模型对象代表了数据对象，即......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99