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 解包操作
1、
使用*a或者**a
进行解包，前者是对tuple类型进行解包，后者则是对字典进行解包，使用*a进行解包时，就是将原来的括号拆开，
def print_hello_world() -> list:
a = [1, 2,3,4,5]
b = [*a]
print(b)
输出：[1, 2,3,4,5]
2、
def task2():
a = {'a':1, 'b':2}
b = {'c':3, 'd':4}
c = {**a, **b}
return a,b,c
输出：
{'a': 1, 'b': 2}
{'c': 3, 'd': 4}
3、
如果在调用函数时，*和**都是分配参数用的
调用函数时，一个*的情况：
例如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、函数返回值的规范化
-> list 是函数的返回类型注解，表明该函数应当返回一个列表。这是一种类型提示，帮助开发者和工具更好地理解代码的意图。
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)
7、@torch.jit.script
装饰器，与模型导出有关
8. view语法
x = torch.randn(4, 4)
print(x)
print(x.size())
y = x.view(16)
print(y)
y2 = y.unsqueeze(1)
print(y2.size())
z = x.view(-1, 8) # -1表示该维度取决于其它维度大小，即（4*4）/ 8
print(z)
m = x.view(2, 2, -1) # 也可以变为更多维度
输出：
用法就是把一个tensor的尺寸改变，比如view(2,2,4)将原来的尺寸变为2X2X4的尺寸，最后一个可以是-1,表示这个部分可以让电脑自动生成。
9. m[...,0,:] & m[:,0,:]
都表示取前，不过前者表示的是取前面的所有的维度，而后者表示的是3维里面取前面的维度，这个需要区分好。。
浙公网安备 33010602011771号