Python的魔法方法及*args**kwargs详解_python karwgs

Python的魔法方法及*args**kwargs详解

魔法方法

1、__getitem__ 和 __len__

其中只要实现了__getitem__和 len__方法就会被认为是序列。
首先len的作用及写法就很常见了，主要用于使对象可用通过len（）方法返回长度。
如果在类中定义了__getitem()方法，那么它的实例对象（假设为P）就可以以P[key]形式取值

两种方法经常一起用在深度学习的数据处理部分，如下列代码所示： 代码自定义的一个遥感图像类，继承于Dataset。建好后就可以根据自己具体的项目进行使用啦。

import torch
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image

class RemoteSensingDataset(Dataset):
    def __init__(self, img_paths, labels, img_size=256):
        self.img_paths = img_paths
        self.labels = labels
        self.img_size = img_size
        self.transforms = transforms.Compose([
            transforms.Resize((img_size, img_size)),
            transforms.ToTensor()
        ])
    
    def __len__(self):
        return len(self.img_paths)
    
    def __getitem__(self, idx):
        img_path = self.img_paths[idx]
        label = self.labels[idx]
        img = Image.open(img_path).convert('RGB')
        img = self.transforms(img)
        return img, label

# 假设你已经有了图像路径列表和对应的标签列表
img_paths = ['path/to/image1.jpg', 'path/to/image2.jpg', 'path/to/image3.jpg']
labels = [0, 1, 0]

# 创建数据集对象
dataset = RemoteSensingDataset(img_paths, labels)

# 创建数据加载器
dataloader = DataLoader(dataset, batch_size=2, shuffle=True)

# 遍历数据加载器，获取数据
for batch_idx, (images, labels) in enumerate(dataloader):
    print('Batch Index:', batch_idx)
    print('Images shape:', images.shape)
    print('Labels:', labels)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

2、__dict__

__dict__是用来存储对象属性的一个字典，其键为属性名，值为属性的值。
用一个例子来展示dict的使用吧：
如下代码所示，给对象赋值时会非常麻烦

class A():
    def __init__(self,dicts):
        self.name=dicts["name"]
        self.age=dicts["age"]
        self.sex=dicts["sex"]
        self.hobby=dicts["hobby"]
if __name__ == '__main__':
     dicts={"name":"lisa","age":23,"sex":"women","hobby":"hardstyle"}
     a=A(dicts)
1
2
3
4
5
6
7
8
9

利用__dict__方法即可简洁的做到，代码如下所示：

class A():
    def __init__(self, dicts):
        self.__dict__.update(dicts)
        print(self.__dict__)


dicts = {"name": "lisa", "age": 23, "sex": "women", "hobby": "hardstyle"}
a = A(dicts)
print(a.name)
1
2
3
4
5
6
7
8
9

3、__getattr__

使用.获取属性的时候，如果该属性存在就输出其值，如果不存在则会去找__getatrr__。如下代码所示：

class A(object):
    def __init__(self, value):
        self.value = value
 
    def __getattr__(self, item):
        print "into __getattr__"
        return  "can not find"
 
a = A(10)
print a.value
# 10
print a.name
# into __getattr__
1
2
3
4
5
6
7
8
9
10
11
12
13
14

参数：self 指对象本身，item 是一个字符串，代表欲访问属性的名字。

*args**kwargs详解

其实关键在于* 和 ** ，args和kwargs都只是名称而已，你把他换成a和b也行。

**args 表示任何多个无名参数， 他本质上是一个 tuple
** kwargs 表示关键字参数， 它本质上是一个 dict

定义函数时：

**kwargs

简而言之就是定义函数时可以通过** kwargs手机关键字参数，然后本身成为一个dict。

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=25, city="Beijing")
1
2
3
4
5

输出：

name: Alice
age: 25
city: Beijing
1
2
3

*args

一个*的情况就是接收参数，成为一个元组。

def print_func(*args):
    print(type(args))
    print(args)
print_func(1,2,[])

# <class 'tuple'>
# (1, 2, [])
1
2
3
4
5
6
7

调用函数时

*的情况

即传入元组

def test_args_kwargs(arg1,arg2):
    print("arg1:",arg1)
    print("arg2:",arg2)
 args = ("two",3,5)
test_args_kwargs(*args)

#-------- 得到输出结果如下所示：----------------------
# arg1: two
# arg2: 3
# ---------------------------------------------------
1
2
3
4
5
6
7
8
9
10

**的情况

即传入字典

kwargs = {"arg2":"two","arg1":5}
test_args_kwargs(**kwargs)

#-------- 得到输出结果如下所示：----------------------
# arg1: 5
# arg2: two
# ---------------------------------------------------
1
2
3
4
5
6
7