python常用功能代码

此贴会应该会经常更新，旨在收集一些python常用功能代码片段。博客会以一个个小demo形式展开，简洁明了。

一.numpy篇

demo1: 创建一个二维数组

demo2: 直接修改数组的dtype类型，会使得数组长度变长，增加（修改前的数据位数表示/修改后的数据位数表示）个倍数，比如原来的是float64, 转换成uint8后，长度会增加64/8倍（一般此效果不是我们想要的）

demo3: 验证直接==赋值是一种浅拷贝，一个变量值发生变化会影响到另一个变量值，copy方式是深拷贝

demo4:从原来数组中截取一部分数据为最新数组，最新数组值发生变化后，原来数组中的值也会发生变化

demo5: 通过astype方式进行类型转化（推荐）

demo6: 从一个numpy数组去构造另一个，来使得数组类型发生变化（推荐）

demo7: 将一个含有负数的float数组，通过numpy astype方式转化为uint8，数据并没有呈现线性拉伸到0~255范围内；这里手动实现了一个线性拉伸到uint8的代码片段

如下是7个demo的代码：

import numpy as np
import cv2
import torch

print("demo1:创建一个二维数组")
src = np.array([[-0.5,0.5,1.5],[-1,0.8,1.2],[1,1.6,2]])
src_copy = src.copy()
original = src.copy()
print(src)
print(src.shape)
print(src.dtype)
print(" ")

print("demo2:直接更改类型")
src1 = src
src1.dtype = np.uint8
print(src1)
print(src1.shape)
print(src1.dtype)
print(" ")

print("demo3:验证直接=赋值是浅拷贝，内存地址一样，一个变量值变了，另一个变量值不变;前面copy方式则是深拷贝，各有各的值，互不影响")
src2 = src
#src2.astype(np.uint8)
print(src2)
print(src2.dtype)
print(src_copy)
print(" ")

print("demo4:截取一部分数据")
src3 = src_copy[0:2,0:2]
print(src3)
print(src3.dtype)
src4 = src3.copy()
src4.dtype = np.uint8  #如果这里直接进行sr3.dtype = np.uint8，则会报错
print(src4)
src3[0,0] = -0.3
print(src3)
#可以看到即使是截取获取数据，也是浅拷贝，src_copy的值也变化了
print(src_copy)
print(" ")

print("demo5:astype方式转变")
original1 = original.copy();
original1.astype(np.uint8)
print(original1)
print(original1.dtype)
#需要进行一下赋值操作给到a,此时a的类型就变化了
a=original1.astype(np.uint8)
print(a)
print(a.dtype)
print(" ")

print("demo6:从一个numpy数组去构造另一个")
original2 = original.copy()
b = np.array(original2, dtype=np.uint8)
print(b)
print(" ")


print("demo7:numpy数组减去一个常数")
original3 = original.copy()
#获取最大最小值
max = np.max(original3)
print(max)

min = np.min(original3)
print(min)

#数组减去最小值
print(original3)
sub = original3 - min
print(sub)

#压缩到0~1范围
ratio = sub/(max -min)
print(ratio)

#扩展到0~255范围内
expand = ratio * 255
print(expand)

final = expand.astype(np.uint8)
print(final)
print(" ")

print("demo7: format")
image = cv2.imread("2008_002682.jpg")
print(image.shape)
print(image.dtype)

image1 = torch.from_numpy(image) #pytorch -> numpy
print(image1.shape)

image2 = image1.numpy() #numpy -> pytorch
print(image2.shape)

image3 = image2.transpose(2,1,0) # 2轴变为了第一个维度，0轴变成了最后
print(image3.shape)

 如下是执行后的结果：

/home/sxhlvye/anaconda3/envs/pytorch-yolo/bin/python /home/sxhlvye/Trial/yolov3-9.5.0/test_numpy.py
demo1:创建一个二维数组
[[-0.5  0.5  1.5]
 [-1.   0.8  1.2]
 [ 1.   1.6  2. ]]
(3, 3)
float64
 
demo2:直接更改类型
[[  0   0   0   0   0   0 224 191   0   0   0   0   0   0 224  63   0   0
    0   0   0   0 248  63]
 [  0   0   0   0   0   0 240 191 154 153 153 153 153 153 233  63  51  51
   51  51  51  51 243  63]
 [  0   0   0   0   0   0 240  63 154 153 153 153 153 153 249  63   0   0
    0   0   0   0   0  64]]
(3, 24)
uint8
 
demo3:验证直接=赋值是浅拷贝，内存地址一样，一个变量值变了，另一个变量值不变;前面copy方式则是深拷贝，各有各的值，互不影响
[[  0   0   0   0   0   0 224 191   0   0   0   0   0   0 224  63   0   0
    0   0   0   0 248  63]
 [  0   0   0   0   0   0 240 191 154 153 153 153 153 153 233  63  51  51
   51  51  51  51 243  63]
 [  0   0   0   0   0   0 240  63 154 153 153 153 153 153 249  63   0   0
    0   0   0   0   0  64]]
uint8
[[-0.5  0.5  1.5]
 [-1.   0.8  1.2]
 [ 1.   1.6  2. ]]
 
demo4:截取一部分数据
[[-0.5  0.5]
 [-1.   0.8]]
float64
[[  0   0   0   0   0   0 224 191   0   0   0   0   0   0 224  63]
 [  0   0   0   0   0   0 240 191 154 153 153 153 153 153 233  63]]
[[-0.3  0.5]
 [-1.   0.8]]
[[-0.3  0.5  1.5]
 [-1.   0.8  1.2]
 [ 1.   1.6  2. ]]
 
demo5:astype方式转变
[[-0.5  0.5  1.5]
 [-1.   0.8  1.2]
 [ 1.   1.6  2. ]]
float64
[[  0   0   1]
 [255   0   1]
 [  1   1   2]]
uint8
 
demo6:从一个numpy数组去构造另一个
[[  0   0   1]
 [255   0   1]
 [  1   1   2]]
 
demo7:numpy数组减去一个常数
2.0
-1.0
[[-0.5  0.5  1.5]
 [-1.   0.8  1.2]
 [ 1.   1.6  2. ]]
[[0.5 1.5 2.5]
 [0.  1.8 2.2]
 [2.  2.6 3. ]]
[[0.16666667 0.5        0.83333333]
 [0.         0.6        0.73333333]
 [0.66666667 0.86666667 1.        ]]
[[ 42.5 127.5 212.5]
 [  0.  153.  187. ]
 [170.  221.  255. ]]
[[ 42 127 212]
 [  0 153 187]
 [170 221 255]]
 
demo7: format
(500, 375, 3)
uint8
torch.Size([500, 375, 3])
(500, 375, 3)
(3, 375, 500)

Process finished with exit code 0

继续实验，demo图片的HWC和CHW两种表示方法

import numpy as np

#array = np.array([1,2,3,4,5,6,7,8,9,10,11,12])
array = np.arange(24).reshape((4,2,3))
print(array.shape)
print(array)

array1 = array.transpose(2,0,1)
print(array1.shape)
print(array1)

执行结果：

/home/sxhlvye/anaconda3/envs/testOpenVINO/bin/python3.6 /home/sxhlvye/trial4/test_numpy.py
(4, 2, 3)
[[[ 0  1  2]
  [ 3  4  5]]

 [[ 6  7  8]
  [ 9 10 11]]

 [[12 13 14]
  [15 16 17]]

 [[18 19 20]
  [21 22 23]]]
(3, 4, 2)
[[[ 0  3]
  [ 6  9]
  [12 15]
  [18 21]]

 [[ 1  4]
  [ 7 10]
  [13 16]
  [19 22]]

 [[ 2  5]
  [ 8 11]
  [14 17]
  [20 23]]]

Process finished with exit code 0

 

 二. 图像篇

拿下面的图片做实验

demo1:简单展示opencv、matplotlib、PIL Image(opencv读到的数据是numpy数组表示的）

import torch
import torchvision
from PIL import Image
import matplotlib.pyplot as plt
import time
import numpy as np
import cv2

print("demo1:简单展示opencv、matplotlib、PIL Image")
#读图片
image = cv2.imread("2008_002682.jpg") #numpy数据结构
print(image.shape)
cv2.imshow("image",image)
cv2.waitKey(0)                        #opencv方式显示

plt.imshow(image)                     #matplotlib方式显示
plt.show()

x = Image.fromarray(image)       #numpy -> PIL
x.show()                              #通过PIL Image方式显示

img = Image.open("2008_002682.jpg")   #PIL Image读取图片
print(img.size)
print(type(img))

img2 = np.array(img)           #PIL -> numpy
print(type(img2))

执行后结果

/home/sxhlvye/anaconda3/envs/pytorch-yolo/bin/python /home/sxhlvye/Trial/yolov3-9.5.0/test_image.py
demo1:简单展示opencv、matplotlib、PIL Image
(500, 375, 3)
(375, 500)
<class 'PIL.JpegImagePlugin.JpegImageFile'>
<class 'numpy.ndarray'>

Process finished with exit code 0

 demo2: 显示下面博客中img_normalize图像，即标准化后的图片

使用Pytorch自带模型预测图片_jiugeshao的专栏-CSDN博客pytorch自带了大量内置模型，相关介绍可见如下博客pytorch 模型 .pt, .pth, .pkl的区别及模型保存方式_shuijinghua的博客-CSDN博客_pth和ptPytorch的内置模型_博客-CSDN博客_pytorch内置模型pytorch框架--网络方面--pytorch自带模型(增、改)_雪剑封心-CSDN博客pytorch 如何调用cuda_将Pytorch模型从CPU转换成GPU的实现方法_扎波罗热人的博客-CSDN博客Pytorch 高效使用GPU..https://blog.csdn.net/jiugeshao/article/details/123318715?spm=1001.2014.3001.5501基本过程就是拿到img_normalize后，先将一个维度，此时为CHW表示，转化为numpy后，再做一个通道转换成HWC表示，再线性拉伸到0~255范围内

import torch
import torchvision
from PIL import Image
from torchvision import transforms
import torchvision.models as models
import matplotlib.pyplot as plt
import numpy as np
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(), normalize]
)

img = Image.open("2008_002682.jpg")
print(img.size)

# 对图像进行归一化
img_p = transform(img)
print(img_p.shape)

# 增加一个维度
img_normalize = torch.unsqueeze(img_p, 0).cuda()
print("img_normalize shape:", img_normalize.shape)

img_normalize_reduce = img_normalize[0,:]
print("img_normalize_reduce shape:", img_normalize_reduce.shape)

#转化为numpy数据
img_normalize_np = img_normalize_reduce.cpu().data.numpy()
print(img_normalize_np.shape)
print(img_normalize_np.dtype)

#转化通道
img_normalize_convert = img_normalize_np.transpose(1,2,0)
print(img_normalize_convert.shape)

max = np.max(img_normalize_convert)
min = np.min(img_normalize_convert)
sub = img_normalize_convert - min
ratio = sub / (max - min)
expand = ratio * 255
final = expand.astype(np.uint8)
print(final.dtype)
print(np.median(final))
print(np.max(final))
print(np.mean(final))
print(np.min(final))

x = Image.fromarray(final)
x.show()
print(x.size)

执行后结果：

/home/sxhlvye/anaconda3/envs/pytorch-yolo/bin/python /home/sxhlvye/Trial/yolov3-9.5.0/test_vgg16.py
(375, 500)
torch.Size([3, 224, 224])
img_normalize shape: torch.Size([1, 3, 224, 224])
img_normalize_reduce shape: torch.Size([3, 224, 224])
(3, 224, 224)
float32
(224, 224, 3)
uint8
102.0
255
109.20800116921768
0
(224, 224)

Process finished with exit code 0

 可以看到其还能表示一只猫咪，图像大小变为224*224了