Python一些常见的技巧及语句！！

题记：关于遇到的一些python代码或者不清楚用法的函数、类别等我会在这里记录下来，方便日后学习和交流。之后研究生三年我会持续更新学习，可能得记录几千个吧。

1. copy.copy()和copy.deepcopy()

深拷贝和浅拷贝的关系

确实好用

import copy
a = [1,2,3]
b = [4,5,6]
c = copy.copy(a)
print(c)

2.

e = np.arange(4) #[0,1,2,3]
f = e.reshape((2,2)) #重新规划为2×2
#print(f)
g = np.transpose(f)
print(g) #求转置
print(type(g)) #<class 'numpy.ndarray'>
h = g.tolist() #转化为列表的形式
print(h)
print(type(h)) #<class 'list'>

d = np.array(
    [
     [1,2,3],
     [4,5,6],
     [7,8,9]
    ]
)
#print(d)

3.class里面class

下面这种用法，我发现有好多人都喜欢这么写代码，学习一下，第一次见过

class A:
    def __init__(self):
        print("a")
    class b:
        def __init__(self):
            print("b")
    class c:
        def __init__(self):
            print("c")
        class d:
            def __init__(self):
                print("d")
        class e:
            def __init__(self):
                print("e")

class B(A):
    def __init__(self):
        super().__init__()

class C:
    pass
a = A()
b = a.b()
c = a.c()

d = c.d()
e = c.e()

4. torch里面的random的一般用法

import torch

a = torch.rand(3,4,6,6)

# 生成一个形状为(3, 4)的张量，元素值在[0, 1)之间
b = torch.rand((3,4))

# 生成一个形状为(3, 4)的张量，元素值服从标准正态分布
c = torch.randn((3,4))

d = torch.randint(1,10,(3,4))

# 生成一个长度为20的随机整数排列
e = torch.randperm(20)
print(c)
print(e)

5

如果在调用函数时，和**都是分配参数用的

调用函数时，一个的情况：

例如print函数

def myprint(x,y):
    print(x)
    print(y)

运行运行

这下形参有两个了，但是我能不能只传入一个形参？

对，“调用函数时分配参数”跟“定义函数时收集参数”，反过来了！

假设你还有一个元组：

params=(1,2)

可以通过如下方式调用myprint函数：

myprint(*params)

就可以输出：

1
2

调用函数时，两个**的情况：

和上面3.1.2很像，是分配字典的。

这回params是一个字典了：

params={'x':1,'y':2}

可以通过如下方式调用myprint函数：

myprint(**params)

就可以输出：

1
2

6 reset代码实现

from torch.nn import functional as F
import torch
import torch.nn as nn
#定义残差网络
class Residual(nn.Module):
    def __init__(self,input_channels,output_channels,use_1x1conv=False,strides=1):
        super().__init__()
        self.conv1 = nn.Conv2d(
            input_channels,output_channels,kernel_size=3,padding=1,stride=strides
        )
        self.conv2 = nn.Conv2d(
            output_channels, output_channels, kernel_size=3, padding=1, stride=strides
        )
        if use_1x1conv:
            self.conv3 = nn.Conv2d(
                input_channels, output_channels, kernel_size=1, stride=strides
            )
        else:
            self.conv3 = None

        self.bn1 = nn.BatchNorm2d(output_channels)
        self.bn2 = nn.BatchNorm2d(output_channels)
        self.relu = nn.ReLU(inplace=True)
    "前向传播"
    def forward(self,X):
        Y = self.relu(self.bn1(self.conv1(X)))
        Y = self.bn2(self.conv2(Y))
        if self.conv3:
            X = self.conv3(X)
        Y += X
        return self.relu(Y)

b1 = nn.Sequential(nn.Conv2d(1,64,kernel_size=7,stride=2,padding=1),
                   nn.BatchNorm2d(64),
                   nn.ReLU(),
                   nn.MaxPool2d(kernel_size=3,stride=2,padding=1))

"这里包含了很多个残差快"
def resnet_block(input_channels,output_channels,num_residual,first_block=False):
    blk=[]
    for i in range(num_residual):
        if i == 0 and not first_block:
            blk.append(
                Residual(input_channels,output_channels,use_1x1conv=True,strides=2)
            )
        else:
            blk.append(
                Residual(input_channels,output_channels)
            )
    return blk

b2 = nn.Sequential(*resnet_block(64,64,2 ,first_block=True))
b3 = nn.Sequential(*resnet_block(64,128,2))
b4 = nn.Sequential(*resnet_block(128,256,2))
b5 = nn.Sequential(*resnet_block(256,512,2))

net = nn.Sequential(b1,b2,b3,b4,b5,nn.AdaptiveAvgPool2d((1,1)),nn.Flatten(),nn.Linear(512,10))

"-----------------------------------------------------------"
X = torch.rand(size=(1,1,224,224))
for layer in net:
    X = layer(X)
    print(layer.__class__.__name__, '输出的维数： ', X.shape)