python核心-面向对象-方法相关-补充

已于 2023-07-27 11:19:31 修改
阅读量47 收藏
点赞数
分类专栏： python基础学习 文章标签： python 开发语言
于 2023-07-26 11:26:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47626556/article/details/131918280
版权 

class Person:
    __age = 18

    def __run(self):
        print("pao")

    def _Person__run(self):
        print("xxx")

p = Person
# p._Person__run()

print(Person.__dict__)

 内置特殊方法

信息格式化操作

# class Person:
#     def __init__(self, n, a):
#         self.name = n
#         self.age = a
#
#     def __str__(self):
#         return "姓名:%s，年龄:%s" % (self.name, self.age)
#
# p1 = Person("sz", 18)
# # print(p1.name)
# # print(p1.age)
# print(p1)
#
# p2 = Person("zhangsan", 19)
# # print(p2.name)
# # print(p2.age)
# print(p2)
#
# s = str(p1)
# print(s, type(s))
# class Person:
#     def __init__(self, n, a):
#         self.name = n
#         self.age = a
#
#     def __str__(self):
#         return "姓名:%s，年龄:%s" % (self.name, self.age)
#
#     def __repr__(self):
#         return "reprxxxxxx"
#
# p1 = Person("sz", 18)
# # print(p1.name)
# # print(p1.age)
# print(p1)
#
# p2 = Person("zhangsan", 19)
# # print(p2.name)
# # print(p2.age)
# print(p2)
#
# # s = str(p1)
# # print(s, type(s))
#
# print(repr(p1))
import datetime
t = datetime.datetime.now()
print(t)
print(repr(t))

tmp = repr(t)

result =eval(tmp)
print(result)

调用操作 

# class Person:
#     def __call__(self, *args, **kwargs):
#         print("xxxx", args, kwargs)
#     pass
#
# p = Person()
#
# p(123,456, name = "sz")


# 创建很多个画笔，画笔的类型（钢笔，铅笔），画笔的类型（红橙黄绿青蓝紫）
#
# print("创建了一个%s这个类型的画笔，他是%s颜色的画笔" % ("钢笔"， "红色"))
# print("创建了一个%s这个类型的画笔，他是%s颜色的画笔" % ("钢笔"， "红色"))
# print("创建了一个%s这个类型的画笔，他是%s颜色的画笔" % ("钢笔"， "红色"))
# print("创建了一个%s这个类型的画笔，他是%s颜色的画笔" % ("钢笔"， "红色"))


# def creatPen(p_color,p_type):
#     print("创建了一个%s这个类型的画笔，他是%s颜色的画笔" % (p_type,p_color))
# # creatPen("", "")
# # creatPen("", "")
# # creatPen("", "")
#
# import functools
# gangbiFunc = functools.partial(creatPen,p_type = "钢笔")
#
# gangbiFunc("红色")
# gangbiFunc("黄色")
# gangbiFunc("蓝色")

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("绿色")

索引操作 

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["name"])

切片操作

# ---------------------------切片操作--------------------------------
# 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, 9]
    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] = value
        # 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]
# del p[0: 5: 2]

比较操作

# ------------------比较操作---------------------------------

class Person:
    # ==  !=  >  >=  <  <=
    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("xxx")
    def __gt__(self, other):
        pass
    def __ge__(self, other):
        pass
    def __lt__(self, other):
        print("lt")
        pass
    def __le__(self, other):
        pass

p1 = Person(18, 180)
p2 = Person(18, 190)

print(p1 == p2)
print(p1 != p2)
print(p1<p2)

 注意事项 

class Person:
    # ==  !=  >  >=  <  <=
    def __init__(self, age, height):
        self.age = age
        self.height = height


    def __lt__(self, other):
        # print("lt")
        print(self.age)
        print(other.age)
        return self.age < other.age

p1 = Person(18, 180)
p2 = Person(19, 190)

print(p1 < p2)
print(p1 > p2)

不支持叠加操作 

class Person:
    def __lt__(self, other):
        pass
    def __eq__(self, other):
        pass

p1 = Person()
p2 = Person()
p1 <= p2  # 错的

装饰器反向组合 

import functools
@functools.total_ordering
class Person:
    def __lt__(self, other):
        print("lt")
        return False
        pass
    def __eq__(self, other):
        print("eq")
        pass

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

print(Person.__dict__)

上下文环境的bool值


class Person:
    def __init__(self):
        self.age = 20
    def __bool__(self):
        return self.age >= 18
    pass

p = Person()

if p:
    print("xxx")

遍历操作

# -----------------------------遍历操作-----------------------------

# class Person:
#     def __init__(self):
#         self.result = 1
#
#     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)


# 方式2
class Person:
    def __init__(self):
        self.result = 1

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

    def __iter__(self):
        print("iter")
        # return iter([1, 2, 3, 4, 5])
        return self
    def __next__(self):
        #     print("getitem")
        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))

# l = [1, 2, 3]
# iter(l)
# ---------------------------恢复迭代器初始值------------------------------

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 >= 6:
            raise StopIteration("stop")

        return self.age

p = Person()

for i in p:
    print(i)

for i in p:
    print(i)

# import collections
# print(isinstance(p, collections.Iterator))
# --------------------------------iter函数的使用---------------------------------


class Person:
    def __init__(self):
        self.age = 1

    # def __getitem__(self, item):
    #     print("getitem")
    #     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 >= 6:
    #         raise StopIteration("stop")
    #     return self.age

    def __call__(self, *args, **kwargs):
        self.age += 1
        if self.age >= 6:
            raise StopIteration("stop")
        return self.age

p = Person()
# pt = iter(p)
# pt = iter(p.__next__, 4)
pt = iter(p, 4)

print(pt)

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

# l = [1, 2, 3]
# lt = iter(l)
# print(lt)

描述器 

# ---------------------- 描述器 - 定义方法1---------------------------------
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()
# p.age = 19
# print(p.age)
# del p.age
# print(p.age)


# p.set_age(-10)
# print(p.get_age())
# p.del_age()

# help(Person)


# 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):
#         print("del age")
#         del self.__age
#
# p = Person()
# print(p.age)
# ------------------------描述器-定义方式2-----------------------------------

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):
    #     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):
    #     print("del age")
    #     del self.__age

p = Person()
p.age = 10
print(p.age)
del p.age

 

# -----------------------描述器-调用细节-----------------------------

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 = 10
print(p.age)
del p.age

# print(Person.age)
# Person.age = 19
# del Person.age


# -------------------------描述器-和实例属性同名时，操作优先级------------------------
# 资料描述器 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):
        self.age = 10


p = Person()
p.age = 10
print(p.age)
# del p.age

print(p.__dict__)

# -------------------------描述器 - 值的存储问题
# 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()
# p.age = 19
# print(p.age)
# del p.age

class Age:
    def __get__(self, instance, owner):
        print("get")
        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()

# 通过实例操作这个描述器，而不是通过这个类
p = Person()
p.age = 10
print(p.age)
# del p.age

p2 = Person()
p2.age = 11
print(p2.age)
print(p.age)

# ------------------------使用类，实现装饰器----------------------------------

# 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 = check(fashuoshuo)

fashuoshuo()

每天学一点q
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python基础-面向对象
Last_G的博客
07-30 692
文章目录面向对象1.编程的分类：1.1面向过程1.2 面向对象2.面向对象的编程2.1类的定义2.2创建一个空类2.3类中的概念2.4数据封装2.5类命名空间与对象，实例的空间2.6类三大特性：2.6.1继承2.6.2多态2.6.3封装3类属性的补充内容3.1特殊的类属性3.2对象之间的交互：3.3私有属性3.4鸭子类型 面向对象 1.编程的分类： 面向过程 函数式编程 面向对象 ...
python编写圆的面积面向对象_Python--面向对象编程(1)
weixin_30009115的博客
01-14 965
面向对象编程--基础部分一.什么是面向对象的程序以及为什么要有面向对象面向过程的程序设计:核心是过程二字,过程指的是解决问题的步骤,即先干什么,再干什么....面向过程的设计就像是一种流水线,是一种机械式的思维方式优点是：复杂度的问题流程化，进而简单化(一个复杂的问题，分成一个个小的步骤去实现，实现小的步骤将会非常简单)缺点是：一套流水线或者流程就是用来解决一个问题，生产汽水的流水线无法生产汽车，...
python核心-面向对象-类的补充
weixin_47626556的博客
07-24 36
【代码】python核心-面向对象-类的补充。
python核心课程-面向对象-方法相关
心支柱的博客
06-12 100
1.方法相关2.补充：
python核心课程-面向对象-补充-元类
心支柱的博客
06-16 125
1.补充：2.补充：
python核心课程-面向对象-只读属性
心支柱的博客
06-20 1215
只读属性1.概念：一个属性（一般指实例属性），只能读取，不能写入。2.应用场景：有些属性，只限在内部根据不同场景进行修改，而对外界来说，不能修改，只能读取。    比如：电脑类的网速属性，网络状态属性3.方式1：方案：全部隐藏（私有化，既不能读，也不能写。），部分公开（公开读的操作）              具体实现：私有化（通过“属性前置双下划线”实现。）部分公开：（通过公开的方法）class...
Python知识点13---面向对象的编程
别人笑我太疯癫，我笑他人看不穿。
06-01 759
Python是一个完全面向对象开发的语言，它的一切都以对象的方式操作 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。 数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。 局部变量：
Python-面向对象
Star___J的博客
12-03 150
类和对象是面向对象的两大核心 类 类定义 类是对一群具有相同特征和行为的事物的统称，是抽象的 特征被称为属性，行为被称为方 语法 类型要符合大驼峰命名 classs 类名(object): def 方法名(self,参数)： 代码块 def 方法名(self,参数)： 代码块 对象 对象的定义 对象是由类创建的具体存在，在程序中现有类才有对象 比如制作飞机，要先有图纸再有飞机这个实 语法 创建对象的语法 对象名 = 类...
python继承的3个特点_Python-----面向对象三大特性之继承
weixin_39575054的博客
12-12 410
1.面向对象之三大特性之继承面向对象之三大特性: 封装,多态,继承比较官方的说法就是：继承(英语：inheritance)是面向对象软件技术当中的一个概念。如果一个类别A“继承自”另一个类别B，就把这个A称为“B的子类别”，而把B称为“A的父类别”也可以称“B是A的超类”。继承可以使得子类别具有父类别的各种属性和方法，而不需要再次编写相同的代码。在令子类别继承父类别的同时，可以重新定义某些属性，并...
Python学习之路---面向对象
chengyinman0078的博客
03-23 105
初识面向对象 面向对象： 面向对象的程序设计的核心是对象（相当于你要处于创造者的思维来建立一个新的东西，如你要实现什么东西，需要干什么才能创造出来），要理解对象为何物。面向对象的程序设计好比作者写小说，作者要解决的问题就是使主角从一个屌丝升级到大神的故事，作者觉得要让主角成为大神，会给主角铺垫从弱到强的大纲，主角很弱时和逐渐变强的时候都有不同的特征，如刚开始只是一个学生，接着职员，接着创业（这...
征服Python--语言基础与典型应用 以及光盘
06-21
此外，还将讲解面向对象编程的概念，包括类的定义、对象的创建和继承、多态等核心概念。 在典型应用部分，作者会引导读者探索Python在Web开发（如Django和Flask框架）、数据分析（如Pandas和NumPy库）、网络编程、...
Python简明教程-沈洁元.docx
06-12
"开始，逐步讲解基本数据类型、序列、运算、控制结构（如缩进和选择）、循环、函数、面向对象编程等核心概念。每个主题都通过实例来演示和解释，鼓励读者亲自实践，通过编写和运行代码来加深理解。此外，教程还建议...
python-tutorial-files:EuroScipy 2015上的Python入门教程的补充材料
05-01
Python完全支持面向对象编程（OOP），包括类的定义、继承、封装和多态。通过创建类，开发者可以构建复杂的数据结构和行为。 8. **文件操作** Python提供了一系列的内建函数和模块，如open()、read()、write()，...
Learning-Python-5th:“学习Python第5版”一书
03-17
此外，还深入讲解了面向对象编程，包括类、对象、继承、封装和多态等概念。 本书不仅涵盖了基本的编程知识，还涉及了更高级的主题，如异常处理、文件操作、正则表达式、网络编程、并发和多线程、数据库交互、Web...
Python库 | tea-django-0.0.6.tar.gz
03-11
这个库主要面向Python开发者，特别是那些专注于后端开发的人员。在Python的世界里，Django是一个广受欢迎的开源Web应用框架，它遵循模型-模板-视图（MTV）架构模式，以高效、简洁的方式支持Web应用程序的开发。 ...
使用Python的Turtle库绘制动态风车
爱写代码的小朋友
07-20 398
python绘制风车
随机数种子的作用
最新发布
帆的博客
07-23 606
设置随机数种子（random seed）的目的是为了确保随机数生成器在每次运行时产生相同的随机数序列，从而保证实验结果的一致性。随机数种子通过初始化随机数生成器的内部状态，使得在相同的种子值下，随机数生成器每次调用时生成的序列是相同的。
【Python如何将字符串连接在一起并使用`join()`方法】
qq_36253366的博客
07-19 450
方法是字符串对象的方法，而不是列表或元组等序列类型的方法。因此，你需要先指定一个用作分隔符的字符串，然后调用这个字符串的。方法将字符串连接在一起，你需要首先确保这些字符串被存储在一个序列类型中（如列表或元组），然后调用这个序列的。方法是一个字符串方法，它用于将序列（如列表、元组等）中的元素以指定的字符连接生成一个新的字符串。列表中的所有字符串元素使用空格作为分隔符连接成一个新的字符串。方法，并将你想要作为分隔符的字符串作为参数传递给。方法，并将包含要连接字符串的序列作为参数传递。
【Python 中的内存管理有哪些优缺点】
qq_36253366的博客
07-19 445
Python中的内存管理是一个复杂而高效的系统，它通过自动化和抽象化的方式极大地简化了程序员的内存管理负担，但同时也存在一些潜在的缺点。
Python核心编程：权威指南与实战推荐
通过阅读和实践书中的例子，读者能够逐渐掌握Python语言的最佳实践，包括异常处理、模块化编程、面向对象编程、网络编程等，这些都是Python开发者必备的技能。 此外，书中对Python语言的设计哲学和编程风格也有所...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值