python高级属性

最新推荐文章于 2024-09-04 10:31:20 发布
最新推荐文章于 2024-09-04 10:31:20 发布
阅读量264 收藏
点赞数
分类专栏： python 文章标签： python numpy 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YS_Ghibli/article/details/126755404
版权

1.迭代器和生成器

1.1可迭代对象的判断

使用for循环遍历取值的对象叫做可迭代对象

# 元组，列表，字典，字符串，集合，range都是可迭代对象
from collections import Iterable

# 判断对象是否是指定类型
result = isinstance((3, 5), Iterable)
print("元组是否是可迭代对象:", result)

result = isinstance([3, 5], Iterable)
print("列表是否是可迭代对象:", result)

result = isinstance({"name": "张三"}, Iterable)
print("字典是否是可迭代对象:", result)

result = isinstance("hello", Iterable)
print("字符串是否是可迭代对象:", result)

result = isinstance({3, 5}, Iterable)
print("集合是否是可迭代对象:", result)

result = isinstance(range(5), Iterable)
print("range是否是可迭代对象:", result)

result = isinstance(5, Iterable)
print("整数是否是可迭代对象:", result)

1.2 自定义可迭代对象

自定义可迭代对象: 在类里面定义__iter__方法创建的对象就是可迭代对象。

from collections import Iterable

# 自定义可迭代对象: 在类里面定义__iter__方法创建的对象就是可迭代对象
class MyList(object):

    def __init__(self):
        self.my_list = list()

    # 添加指定元素
    def append_item(self, item):
        self.my_list.append(item)

    def __iter__(self):
        # 可迭代对象的本质：遍历可迭代对象的时候其实获取的是可迭代对象的迭代器， 然后通过迭代器获取对象中的数据
        pass

my_list = MyList()
my_list.append_item(1)
my_list.append_item(2)
result = isinstance(my_list, Iterable)

print(result)

1.3 自定义迭代器对象

自定义迭代器对象: 在类里面定义__iter__和__next__方法创建的对象就是迭代器对象

iter函数: 获取可迭代对象的迭代器，会调用可迭代对象身上的__iter__方法
next函数: 获取迭代器中下一个值，会调用迭代器对象身上的__next__方法

from collections import Iterable

# 自定义可迭代对象: 在类里面定义__iter__方法创建的对象就是可迭代对象
class MyList(object):

    def __init__(self):
        self.my_list = list()

    # 添加指定元素
    def append_item(self, item):
        self.my_list.append(item)

    def __iter__(self):
        # 可迭代对象的本质：遍历可迭代对象的时候其实获取的是可迭代对象的迭代器， 然后通过迭代器获取对象中的数据
        my_iterator = MyIterator(self.my_list)
        return my_iterator


# 自定义迭代器对象: 在类里面定义__iter__和__next__方法创建的对象就是迭代器对象
class MyIterator(object):

    def __init__(self, my_list):
        self.my_list = my_list

        # 记录当前获取数据的下标
        self.current_index = 0

        # 判断当前对象是否是迭代器
        result = isinstance(self, Iterator)
        print("MyIterator创建的对象是否是迭代器:", result)

    def __iter__(self):
        return self

    # 获取迭代器中下一个值
    def __next__(self):
        if self.current_index < len(self.my_list):
            self.current_index += 1
            return self.my_list[self.current_index - 1]
        else:
            # 数据取完了，需要抛出一个停止迭代的异常
            raise StopIteration


my_list = MyList()
my_list.append_item(1)
my_list.append_item(2)
result = isinstance(my_list, Iterable)
print(result)

for value in my_list:
    print(value)

1.4 生成器的概念

生成器是一类特殊的迭代器,它不需要再像上面的类一样写__iter__()和__next__()方法了, 使用更加方便。

创建生成器方法一，只要把一个列表生成式的 [ ] 改成 ( )

my_list = [i * 2 for i in range(5)]
print(my_list)

# 创建生成器
my_generator = (i * 2 for i in range(5))
print(my_generator)

# next获取生成器下一个值
# value = next(my_generator)
#
# print(value)
for value in my_generator:
    print(value)

创建生成器方法二，在def函数里面看到有yield关键字那么就是生成器

def fibonacci(num):
    a = 0
    b = 1
    # 记录生成fibonacci数字的下标
    current_index = 0
    print("--11---")
    while current_index < num:
        result = a
        a, b = b, a + b
        current_index += 1
        print("--22---")
        # 代码执行到yield会暂停，然后把结果返回出去，下次启动生成器会在暂停的位置继续往下执行
        yield result
        print("--33---")
        return "嘻嘻"

fib = fibonacci(5)
value = next(fib)
print(value)

# return 和 yield的区别
# yield: 每次启动生成器都会返回一个值，多次启动可以返回多个值，也就是yield可以返回多个值
# return: 只能返回一次值，代码执行到return语句就停止迭代

2闭包和装饰器

2.1 闭包

外层函数返回内层函数的引用

# 定义一个函数
def test(number):
    def test_in(number_in):
        print("in test_in 函数, number_in is %d" % number_in)
        return number+number_in
    # 其实这里返回的就是闭包的结果
    return test_in


# 给test函数赋值，这个20就是给参数number
ret = test(20)

# 注意这里的100其实给参数number_in
print(ret(100))
#注 意这里的200其实给参数number_in
print(ret(200))

2.2 装饰器

是给函数添加额外的功能

# ##################无参,无返回##################################
# 装饰器作用在不改变原函数代码的情况下添加<<额外的功能>>
# 装饰前的test(就是原先定义的那个test函数),是由func指向
# 装饰后的test,其实调用的是call_fun


# 1.闭包
# 2.装饰器

# 1.闭包
def deco(func):
	def warpper():
		print("添加额外的功能")
 		func()

 	return warpper

 @deco
 def test():
 	print("test")

 test()
 
########################2.无参,有返回###################################
# 1.闭包
def deco(func):
 	def warpper():
 		print("添加功能")
 		return func()  # 返回原先函数的值

 	return warpper

# 2.装饰器
 @deco  # @deco ===> test = deco(test)
 def test():
 	print("test")
 	return 1000

 print(test())  # warpper

######################3.有参,无返回#####################
# 1.闭包
def deco(func):
	def warpper(args):
		print("添加功能")
 		func(args)  # 调用test

	return warpper


# 2.装饰器
@deco
def test(args):
	print(args)

 test(123)  # call_fun

######################4.有参,有返回############################

# 1.闭包
 def deco(func):
 	def warpper(args):
 		print("添加功能")
 		return func(args)

	return warpper

# 2.装饰器
 @deco
 def test(args):
 	return args

 print(test(1000))  # call_fun

####################5.不定长参数,返回###################################

# 1.闭包
def deco(func):
	def warpper(*args, **kwargs):
		print("call_funn", args)
		print("call_fun", kwargs)
		return func(*args, **kwargs)  # 拆包

	return warpper


# 2.装饰器
@deco
def test(*args, **kwargs):
	print(args)
	print(kwargs)
	return 100


print(test(1, a=2))  # 调用warpper

def deco1(func1):
   def warpper1(*args, **kwargs):
      print("添加功能--1")
      return func1(*args, **kwargs)

   return warpper1


def deco2(func2):
   def warpper2(*args, **kwargs):
      print("添加功能--2")
      return func2(*args, **kwargs)

   return warpper2


@deco2  test = deco2(warpper1)
@deco1  warpper1 = deco1(test)
def test():
   print("功能test")
test()

添加功能--2
添加功能--1
功能test

类装饰器

# 使用类装饰器

class SetFun(object):
   def __init__(self, func):
      self.func = func  # 把传入的函数引用保存

   def __call__(self, *args, **kwargs):
      # 添加的功能
      print("添加的功能", self.value)

      # 把以前的功能执行一下
      self.func()

   @classmethod
   def set_value(cls, value):
      print(value)
      # return SetFun
      # 类属性
      cls.value = value
      return cls


# @SetFun.set_value("添加功能!")
# 第一步SetFun.set_value("添加功能!"),返回类引用
# 第二步@类引用===> @SetFun ===> test = SetFun(test)

@SetFun.set_value("添加功能!")
def test():
   print("test")

3.拷贝

3.1 浅拷贝

浅拷贝是对一个对象的顶层数据的拷贝

import copy 
<<< a = [11,22,33]
<<< b = copy.copy(a)
<<< id(a)
<<< 59275144
<<< id(b)
<<< 59525600
<<< a.append(44)
<<< a
<<< [11, 22, 33, 44]
<<< b
<<< [11, 22, 33]

<<< a = [11,22]
<<< b = [22,33]
<<< id(a)
<<< 58890680
<<< id(b)
<<< 53652634
<<< c = [a,b]
<<< d = copy.copy(c)
<<< id(c)
<<< 52390123
<<< id(d)
<<< 53590678
<<< a.append(44)
<<< c
<<< [[11,22,44],[22,33]]
<<< d
<<< [[11,22,44],[22,33]]
<<< id(d[0])
<<< 58890680
<<< id(d[1])
<<< 53652634

3.2 深拷贝

深拷贝是对于一个对象所有层次的拷贝(递归)

import copy 
<<< a = [11,22,33]
<<< b = copy.deepcopy(a)
<<< id(a)
<<< 59275144
<<< id(b)
<<< 59525600
<<< a.append(44)
<<< a
<<< [11, 22, 33, 44]
<<< b
<<< [11, 22, 33]

<<< a = [11,22]
<<< b = [22,33]
<<< id(a)
<<< 58890680
<<< id(b)
<<< 53652634
<<< c = [a,b]
<<< d = copy.deepcopy(c)
<<< id(c)
<<< 52390123
<<< id(d)
<<< 53590678
<<< a.append(44)
<<< c
<<< [[11,22,44],[22,33]]
<<< d
<<< [[11,22],[22,33]]
<<< id(d[0])
<<< 58634589
<<< id(d[1])
<<< 56523852

注意 ：

  1. copy.copy对于可变类型，会进行浅拷贝
  2. copy.copy和copy.deepcopy对于不可变类型没有意义，全部等价于对象之间的赋值操作。
  3. copy.copy和copy.deepcopy对于一维的数据一样的。

4.property属性

一种用起来像是使用的实例属性一样的特殊属性，可以对应于某个方法。

# ############### 定义 ###############
class Foo:
    def func(self):
        pass

    # 定义property属性
    @property
    def prop(self):
        pass

# ############### 调用 ###############
foo_obj = Foo()
foo_obj.func()  # 调用实例方法
foo_obj.prop  # 调用property属性

#coding=utf-8
# ############### 定义 ###############
class Goods:
    """python3中默认继承object类
        以python2、3执行此程序的结果不同，因为只有在python3中才有@xxx.setter  @xxx.deleter
    """
    @property
    def price(self):
        print('@property')

    @price.setter
    def price(self, value):
        print('@price.setter')

    @price.deleter
    def price(self):
        print('@price.deleter')

# ############### 调用 ###############
obj = Goods()
obj.price          # 自动执行 @property 修饰的 price 方法，并获取方法的返回值
obj.price = 123    # 自动执行 @price.setter 修饰的 price 方法，并将  123 赋值给方法的参数
del obj.price      # 自动执行 @price.deleter 修饰的 price 方法

property对象的类属性

class Foo:
    def func(self):
        return "test"

    BAR = property(func)

obj = Foo()
reuslt = obj.BAR  # 自动调用get_bar方法，并获取方法的返回值
print(reuslt)

property方法中有个四个参数 
第一个参数是方法名，调用 对象.属性 时自动触发执行方法
第二个参数是方法名，调用 对象.属性 ＝ XXX 时自动触发执行方法
第三个参数是方法名，调用 del 对象.属性 时自动触发执行方法
第四个参数是字符串，调用 对象.属性.__doc__ ，此参数是该属性的描述信息
#coding=utf-8
class Foo(object):
    def get_price(self):
        print("getter...")
        return '100'

    def set_price(self, value): 
        """必须两个参数"""
        print("setter...")
        return 'set value' + value

    def del_price(self):
        print("deleter...")
        return '100'

    BAR = property(get_price, set_price, del_price, "description...")

obj = Foo()

obj.BAR  # 自动调用第一个参数中定义的方法：get_price
obj.BAR = "200"  # 自动调用第二个参数中定义的方法：set_price方法，并将“200”当作参数传入
desc = Foo.BAR.__doc__  # 自动获取第四个参数中设置的值：description...
print(desc)
del obj.BAR  # 自动调用第三个参数中定义的方法：del_bar方法

5.魔法属性

5.1 doc

表示类的描述信息
在这里插入代码片

class Foo:
    """ 描述类信息，这是用于看片的神奇 """
    def func(self):
        pass

print(Foo.__doc__)
#输出：类的描述信息

5.2 module 和 class

  • module 表示当前操作的对象在那个模块
  • class 表示当前操作的对象的类是什么
# -*- coding:utf-8 -*-
--- test.py ---
class Person(object):
    def __init__(self):
        self.name = 'laowang'

--- main.py ---
from test import Person

obj = Person()
print(obj.__module__)  # 输出 test 即：输出模块
print(obj.__class__)  # 输出 test.Person 即：输出类

5.3 init

初始化方法，通过类创建对象时，自动触发执行

class Person:
    def __init__(self, name):
        self.name = name
        self.age = 18


obj = Person('zhangsan')  # 自动执行类中的 __init__ 方法

5.4 del

当对象在内存中被释放时，自动触发执行。
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，del的调用是由解释器在进行垃圾回收时自动触发执行的。

class Foo:
    def __del__(self):
        pass

5.5 call

  • 对象后面加括号，触发执行。
    注：init方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 call 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()
class Foo:
    def __init__(self):
        pass

    def __call__(self, *args, **kwargs):
        print('__call__')


obj = Foo()  # 执行 __init__
obj()  # 执行 __call__

5.6 dict

  • 类或对象中的所有属性
    类的实例属性属于对象；类中的类属性和方法等属于类，即：
class Province(object):
    country = 'China'

    def __init__(self, name, count):
        self.name = name
        self.count = count

    def func(self, *args, **kwargs):
        print('func')

# 获取类的属性，即：类属性、方法、
print(Province.__dict__)
# 输出：{'__dict__': <attribute '__dict__' of 'Province' objects>, '__module__': '__main__', 'country': 'China', '__doc__': None, '__weakref__': <attribute '__weakref__' of 'Province' objects>, 'func': <function Province.func at 0x101897950>, '__init__': <function Province.__init__ at 0x1018978c8>}

obj1 = Province('山东', 10000)
print(obj1.__dict__)
# 获取 对象obj1 的属性
# 输出：{'count': 10000, 'name': '山东'}

obj2 = Province('山西', 20000)
print(obj2.__dict__)
# 获取 对象obj1 的属性
# 输出：{'count': 20000, 'name': '山西'}

5.7 str

  • 如果一个类中定义了str方法，那么在打印 对象 时，默认输出该方法的返回值。
class Foo:
    def __str__(self):
        return 'test'


obj = Foo()
print(obj)
# 输出：test

21.8 getitem、setitem、delitem

  • 用于索引操作，如字典。以上分别表示获取、设置、删除数据
# -*- coding:utf-8 -*-

class Foo(object):

    def __getitem__(self, key):
        print('__getitem__', key)

    def __setitem__(self, key, value):
        print('__setitem__', key, value)

    def __delitem__(self, key):
        print('__delitem__', key)


obj = Foo()

result = obj['k1']      # 自动触发执行 __getitem__
obj['k2'] = 'test'    # 自动触发执行 __setitem__
del obj['k1']           # 自动触发执行 __delitem__
追光的牧羊人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Python高级property属性用法实例分析
01-02
本文实例讲述了Python高级property属性用法。分享给大家供大家参考，具体如下： property属性 1.property属性： 是一个提高开发者用户体验度的属性，可以将一个函数改造的像属性一样。 例： # 定义的时候像是一个函数 使用的时候和属性的方式是以样的 class Foo(object): @property def money(self): return 100 # f = Foo() # m = f.money() # print(m) f = Foo() print(f.money) 执行结果： 2.property简单应用： 例：根据当前页数
python 高级属性
魔法学徒de专栏
08-27 649
__setattr__、__getattr__、__delattr__、__setitem__、__getitem__、__delitem__方法作用
Python常用的高级属性
jfxu
09-08 361
@property @property的作用:  保护私有变量,使私有变量像普通变量一样调用 @property的使用：把一个getter方法变成属性，只需要加上@property就可以了，                               此时，@property本身又创建了另一个装饰器@xxx.setter，负责把一个setter方法变成属性赋值，              ...
Python中的5个高阶概念属性的知识点！你要了解明白哦！
y4544159的博客
09-30 352
在现代编程世界中，面向对象编程(OOP)语言在改变软件开发中的设计和实现模式方面发挥了进化作用。作为OOP家族的重要成员，Python在过去10年左右逐渐流行起来。与其他OOP语言一样，Python围绕大量不同的对象操作其数据，包括模块、类和函数。 如果您有任何OOP语言的编程经验，您应该知道所有对象都有其内部特征数据，称为字段、属性或属性。在Python中，这些对象绑定的特征数据通常称为属性。在本文中，我将特别在自定义类的上下文中讨论它们。 1. 类属性 为了更好地管理项目中的数据，我们经常需要
python高级特性
hongyucai的博客
06-11 494
一、一切皆对象 二、可变对象和不可变对象 三、隐藏的方法和属性 四、迭代器、生成器、装饰器 五、异步编程：多线程、多进程、协程 六、并发编程：asyncio、threading 七，cpython、GIL
python高级编程总结
漫漫行程路
02-14 2414
Python中一切皆对象 一切皆对象得含义就是每一个都有自己得属性，每一个都有自己得继承关系，你看到没有继承得，其实它隐式继承了object或者type。关于type可以看看元类。是对象意味着它可以随时随地得使用，比如赋值给一个变量，添加到列表中，作为参数出传递，做返回值 Python语言特性 Python是动态强类型语言 动态还是静态指的是编译期还是运行期确定类型 比如定义了一个变量 a = 11 这个时候你并没有运行，但是python已经确定了他的类型是Int 这个时候你的int就是int，不会变成fl
Python3高级教程_python3_高级教程_电子版_
09-29
Python3是一种广泛应用于数据分析、机器学习、Web开发和自动化任务的高级编程语言。随着Python3的普及，越来越多的开发者和爱好者希望通过深入学习Python3的高级特性来提升自己的技能。本教程旨在帮助那些已经掌握...
Python高级编程
11-08
"Python高级编程"涵盖了Python语言的深入理解和高级用法，这包括但不限于元编程、装饰器、生成器、协程、多线程与多进程、高级数据结构、错误处理、模块化编程、性能优化以及Python在大型项目中的应用。 1. **元...
Python高级用法（GIL锁，深拷贝，浅拷贝，私有属性，魔法属性，上下文管理器）
12-21
Python是一种高级编程语言，以其简洁明了的语法和强大的功能深受开发者喜爱。在Python的世界里，有一些高级用法对于编写高效、健壮的代码至关重要。本文将深入探讨几个关键概念，包括GIL锁、对象拷贝、私有属性、...
python笔记 - 高级属性(20160411)
hereyang5的博客
04-11 357
**切片 迭代** 如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）。 当我们使用for循环时，只要作用于一个可迭代对象，for循环就可以正常运行，而我们不太关心该对象究竟是list还是其他数据类型。那么，如何判断一个对象是可迭代对象呢？方法是通过collections模块的Iterable类型判断：
Python 高级特性汇总
m0_72418211的博客
03-02 909
点击名片关注阿尘blog，一起学习，一起成长本文主要分享一些Python高级特性如：迭代器、生成器、装饰器、元类、闭包等等1 装饰器装饰器（Decorator）定义：装饰器是一个接受函数作为参数的高阶函数，并返回一个新的函数对象。它主要用于修改或增强原始函数的行为，而不需要修改其源代码。装饰器在Python中是通过@符号来应用的。作用：修改函数行为：装饰器可以在不修改原始函数代码的情况下，增加额...
python高级属性_python高级特性简介
weixin_39724793的博客
01-30 78
切片就相当于其他语言中的截断函数，取部分指定元素用的。L = list(range(100))#利用切片取部分元素print(L[0:10]) #取从索引从0到9的前10个元素print(L[-10:]) #取最后10个元素print(L[10:20])#取从索引10到19的10个元素print(L[:10:2])#从前10个元素中每两个取一个元素print(L[::10]) #所有元素中每10个...
python学习10-python高级特性
qq_51204045的博客
10-28 814
python高级特性：装饰器迭代器包和模块深浅拷贝……
python十大高级特性_Python高级特性
weixin_34732699的博客
01-29 2016
减少代码，提高效率1.切片取一个序列的部分元素L [ start : end : step ] 含头不含尾1 #!/usr/bin/python32 #-*- coding:utf-8 -*-34 L = [ 1, 3, 6, 9, 45, 66]56 print ( L[:4] ) #等同于L[0:4]切片下标为 0 ~ 37 print ( L[-2:] ) #倒数切片 从倒数第2开始...
Python基础 5 - 类、对象、注解
最新发布
云端梦留白的博客
09-04 1127
面向对象（Object-Oriented, OOP）是一种编程范式，它使用“对象”来设计软件，这些对象包含数据（通常称为属性或字段）和代码（通常称为方法或函数），以模拟现实世界实体的属性和行为。面向对象是一种编程方法，通过创建包含数据和行为的对象来模拟现实世界，提高代码的组织性、重用性和灵活性。在 Pyhon 中，想要使用类，必须先创建对象。class 类名称 : # class 关键字，表示定义了一个类，类首字符大写为标准。
mongodb在Java中条件分组聚合查询并且分页(时间戳，按日期分组，年月日...)
简单发点工作中用到的，或者记录下小知识点
09-03 1610
按时间 年月日条件分组，筛选数据，统计数据，聚合查询 打印出mongo的SQL语句
Transiting from CUDA to HIP （二）
weixin_44500921的博客
09-03 1237
为了解决这个问题，HIP（Heterogeneous-compute Interface for Portability）提供了一套宏定义，使得开发者可以编写可移植的代码，这些代码可以在 NVIDIA 的 CUDA 平台和 AMD 的 ROCm 平台上运行。是一个预定义的宏，用于指示当前编译的代码所针对的 NVIDIA GPU 的计算能力（Compute Capability）。为了正确编译包含 HIP 代码的文件，您需要确保编译器能够找到 HIP 的头文件，并且定义了正确的宏。
CSS解析:定位和层叠上下文
晓风残月淡的博客
08-31 2104
许多开发人员对定位的理解很粗略，如果不完全了解定位，就很容易给自己挖坑。有时候可能会把错误的元素放在其他元素前面，要解决这个问题却没有那么简单。一般的布局方法是用各种操作来控制文档流的行为。定位则不同：它将元素彻底从文档流中移走。它允许你将元素放在屏幕的任意位置。还可以将一个元素放在另一个元素的前面或后面，彼此重叠。
【hot100篇-python刷题记录】【数据流的中位数】
m0_73629042的博客
09-04 300
精简的代码总是难以琢磨。
Python高级属性与方法详解：动态__dict__探索
本篇教程深入讲解了Python中的属性（Attributes）和方法（Methods），针对的是已经有一定Python基础的读者，特别是那些熟悉Python类型和对象的高级开发者。教程特别强调，它主要讨论的是Python 2.2版本引入的新式...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值