Python魔术方法、属性和迭代器

Jerry_ww

已于 2023-07-26 21:12:26 修改

阅读量131

点赞数 2

分类专栏： python 文章标签： python 开发语言

于 2023-07-24 15:49:23 首次发布

本文链接：https://blog.csdn.net/Jerryqjr/article/details/131880510

版权

python 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

• 静态方法和类成员方法（区别是有无带参数）

1. 魔术方法

在Python中的面向对象中有很多魔术方法如：
• __init__: 构造函数，在生成对象时调用
• __del__: 析构函数，释放对象时使用
• __str__: 使用print(对象)或者str(对象)的时候触发
• __repr__: 在使用repr(对象)的时候触发
• __setitem__ : 按照索引赋值
• __getitem__: 按照索引获取值
• __len__: 获得长度
• __cmp__: 比较运算
• __call__: 函数调用
• __add__: 加运算
• __sub__: 减运算
• __mul__: 乘运算
• __div__: 除运算
• __mod__: 求余运算
• __pow__: 乘方

代码：

# 魔术方法实例


# __del__()析构方法
#
# class File:
#
# 	def __init__(self, name):
# 		self.name = name
# 		print("open file ", self.name)
#
# 	#read
# 	#
# 	#write
#
# 	def __del__(self):
# 		print("close file ", self.name)
#
#
# f1 = File("a.txt")
#
# f2 = File("b.txt")
#
# f3 = File("c.txt")
# del f3    #释放f3
# print("read...write...")


# __str__()使用
# class Stu:
# 	name = "Jerry"
# 	age = 20
#
# 	def __str__(self):
# 		return "name:%s;age:%d" % (self.name, self.age)
#
#
# s = Stu()
# print(s)


#__add__()
#
class Demo:
	def __init__(self,x,y):
		self.x = x
		self.y = y

	def __str__(self):
		return "Demo(%d,%d)" % (self.x, self.y)

	def __add__(self, other):
		return Demo(self.x+other.x, self.y+other.y)


d1 = Demo(5, 8)
d2 = Demo(9, -4)

print(d1+d2)

结果：

del()

str()

add()

2. 属性和方法

• property() 函数

property() 函数的作⽤是在新式类中返回属性值
class property([fget[, fset[, fdel[, doc]]]])
fget -- 获取属性值的函数
fset -- 设置属性值的函数(可选)
fdel -- 删除属性值函数（可选）
doc -- 属性描述信息（可选）

• 静态方法和类成员方法（区别是有无带参数）

“类方法”与“静态方法”都是从属于类对象的成员，这两者与实例方法的关键区别在于对它们的调用是在类对象上进行的而不是在在类的实例对象中进行的。
使⽤staticmethod()和classmethod()函数或使⽤@staticmethod和@classmethod装饰器

类对象、类的实例对象的区别

很好理解，我用如下代码说明。所以说“类方法”与“静态方法”都是类对象的成员而不需要实例化。


class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color

    def drive(self):
        print(f"The {self.color} {self.brand} is driving.")

# 类对象
print(Car)  # <class '__main__.Car'>

# 实例化对象
car1 = Car("BMW", "blue")
car2 = Car("Audi", "red")

# 实例对象
print(car1)  # <__main__.Car object at 0x000001>
print(car2)  # <__main__.Car object at 0x000002>

# 访问类属性
print(car1.brand)  # BMW
print(car2.color)  # red

# 调用类方法
car1.drive()  # The blue BMW is driving.
car2.drive()  # The red Audi is driving.

self 和 cls 区别用法

普通的方法，第一个参数需要是self，它表示一个具体的实例本身。
如果用了staticmethod，那么类方法就不需要这个self，而将这个方法当成一个普通的函数使用。
而对于classmethod，它的第一个参数不是self，是cls，它表示这个类本身。

• hasattr()函数

使⽤hasattr()函数判读对象中是否存在指定的非私有属性和方法

代码：

#proprety()
class Rectangle:
    def __init__(self):
        self.width = 0
        self.height = 0

    def setSize(self, size):
        self.width, self.height = size

    def getSize(self):
        return self.width, self.height

    size = property(getSize, setSize)


r = Rectangle()
#r.width = 100
#r.height=50
r.setSize((200, 100))
print(r.getSize())

r.size = 1000, 500
print(r.size)


# 静态方法和类成员方法

class A:
    def fun():
        print("aaaaaaaaaaaaa")
    fun = staticmethod(fun)	 #静态方法定义

    def demo(cls):
        print("bbbbbbbbbbbb")
    demo = classmethod(demo) 	#类成员方法定义


#a = A()
A.fun()
A.demo()


class A:
    # 使用装饰器定义静态和类成员方法
    @staticmethod 	#静态方法定义
    def fun():
        print("aaaaaaaaaaaaa")

    @classmethod  #类成员方法定义
    def demo(cls):
        print("bbbbbbbbbbbb")

#a = A()
A.fun()
A.demo()


class B:
    name = "zhangsan"
    __age = 20

    def fun1(self):
        print("aaaa")

    def __dd(self):
        print("ccc")


b = B()
print(hasattr(b, "name"))
print(hasattr(b, "__age"))
print(hasattr(b, "fun1"))
print(hasattr(b, "__dd"))

结果：

property()

静态方法和类成员方法

hasattr()

3. 迭代器

• 指定数据创建迭代器（使用iter()和next() ）
• 迭代对象：定义魔术方法：__next__()和__iter__()

代码：

#迭代器
#对数据的迭代

a = [10, 20, 30]
y = iter(a) 	#创建一个迭代器
print(next(y))
print(next(y))
print(next(y))
#print(next(y)) 	#第四次迭代会抛出异常StopIteration(停止迭代)


# 迭代对象
class A:
	def __init__(self):
		self.x = 0

	def __next__(self):
		self.x += 1
		if self.x > 10:
			raise StopIteration
		return self.x

	def __iter__(self):		#返回迭代器对象
		return self


a = A()
print(set(a))
# for i in a:
# 	print(i)