python-图像处理-计算机视觉基础-numpy-pandas-PIL

一、numpy库

1.数组创建

可以使用array函数从常规Python列表或元组中创建数组。得到的数组的类型是从Python列表中元素的类型推导出来的。

创建数组最简单的办法就是使用array函数。它接受一切序列型的对象（包括其他数组），然后产生一个新的含有传入数据的numpy数组。其中，嵌套序列（比如由一组等长列表组成的列表）将会被转换为一个多维数组

import numpy as np

#将列表转换为数组
array = np.array([[1,2,3],[4,5,6]])
#将列表转换为数组
array = np.array(((1,2,3),(4,5,6)))

通常，数组的元素最初是未知的，但它的大小是已知的。因此，NumPy提供了几个函数来创建具有初始占位符内容的数组。

zeros():可以创建指定长度或者形状的全0数组

ones():可以创建指定长度或者形状的全1数组，默认数据类型为float

empty():创建一个数组，其初始内容是随机的,取决于内存的状态

full(): 根据给定形状和数据类型生成指定数值的数组
以上四个函数可以根据所给的数组生成一个形状一样的数组函数为 ~-like()

eye():生成一个N×N特征矩阵（对角线是1，其他是0）

array = np.arange():默认步长为1;该函数返回数组而不是列表。

numpy. linspace():生成一个指定大小，指定数据区间的均匀分布序列

numpy. logspace():用于创建一个于等比数列

zero_array = np.zeros((2,3))

one_array = np.ones((3,4),dtype='int64')

empty_array = np.empty((3,4))

full_array = np.full((3,4),6)

eye_array = np.eye((3))

array = np.arange( 10, 31, 5 )
# 结果为[10 15 20 25 30]

# 生成默认参数num为50的均匀分布的数组
print(np.linspace(1, 10))
 
# 生成[1,10]之间元素个数为10的序列,说明参数endpoint默认为true,参数retstep默认为false
print(np.linspace(1, 10, 10))
 
# 生成[1,10)之间元素个数为10的序列,设置参数retstep为true
print(np.linspace(1, 10, 10, endpoint=False))
 
# 生成[1,10)之间元素个数为10的整数序列
print(np.linspace(1, 10, 10, dtype=int))

# 生成默认底数为10的1次方到10的二次方之间的等比数列的数组
print(np.logspace(0,9,10,base=2))

# 生成底数是2的0次方到2的9次方之间等比数列的数组
print(np.logspace(0,9,10,base=2))

输出数组的一些信息，如维度、形状、元素个数、元素类型等

array = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
print(array)
# 数组维度
print(array.ndim)
# 数组形状
print(array.shape)
# 数组元素个数
print(array.size)
# 数组元素类型
print(array.dtype)

重新定义数字的形状

array1 = np.arange(6).reshape([2,3])
print(array1)
# 结果为[[0 1 2]
         [3 4 5]]
array2 = np.array([[1,2,3],[4,5,6]],dtype=np.int64).reshape([3,2])
print(array2)
# 结果为[[1 2]
         [3 4]
         [5 6]]

2.数据的计算

数组很重要，因为它可以使我们不用编写循环即可对数据执行批量运算。这通常叫做矢量化
大小相等的数组之间的任何算术运算都会将运算应用到元素级。同样，数组与标量的算术运算也会将那个标量值传播到各个元素.
矩阵的基础运算：

arr1 = np.array([[1,2,3],[4,5,6]])
arr2 = np.ones([2,3],dtype=np.int64)

# 矩阵对应元素计算
print(arr1 + arr2)
print(arr1 - arr2)
print(arr1 * arr2)
print(arr1 / arr2)
print(arr1 ** 2)

# 矩阵乘法
arr3 = np.array([[1,2,3],[4,5,6]])
arr4 = np.ones([3,2],dtype=np.int64)
print(np.dot(arr3,arr4))

# numpy计算规则
np.arange(3)+5
np.ones((3,3))+ np.arange(3)   # ones()默认类型为float
np.arange(3).reshape((3,1))+ np.arange(3)
# 输出结果分别为
[5 6 7]		[[1. 2. 3.]		[[0 1 2]	
			 [1. 2. 3.]      [1 2 3]
			 [1. 2. 3.]]     [2 3 4]]

3.数据的索引与切片

arr5 = np.arange(0,6).reshape([2,3])
print(arr5)
print(arr5[1])
print(arr5[1][2])
print(arr5[1,2])  # 输出 5 即第二行第三个
print(arr5[1,:])
print(arr5[:,1])
print(arr5[1,0:2])

4.Numpy随机数模块

numpy.random模块填补了Python内建的random模块的不足，可以高效生成随机数组。同时也可以引用
random模块

np.random.random():无约束条件下生成随机数

np.random.seed():可以按顺序产生一组固定的数组，如果使用相同的seed()值，则每次生成的随机数都相同，如果不设置这个值，那么每次生成的随机数不同。但是，只在调用的时候seed()一下并不能使生成的随机数相同，需要每次调用都seed()一下，表示种子相同，从而生成的随机数相同。

np.random.shuffle():在原数组上进行，改变自身序列，无返回值。

np.random.permutation()：不在原数组上进行，返回新的数组，不改变自身数组。

# 生成大小为5的一维随机数组
print(np.random.random(5))

# 生成一个3×3的二维随机数组
print(np.random.random((3,3)))

# 随机选择2-9之间的数生成2×3的随机数组
print(np.random.randint(2,10,(2,3)))

arr1=np.array([5, 1, 2, 4, 3])
np.random.shuffle(arr1)
# 输出[4 1 3 2 5]

5.Numpy数据的读写

np.save(“…/tmp/save_arr”,arr):以二进制的格式保存数据

np.load(“…/tmp/save_arr.npy”):从二进制的文件中读取数据

np.savez(‘…/tmp/savez_arr’,arr1,arr2):将多个数组保存到一个文件中

二、pandas库

pandas基于numpy实现，常与numpy和matplotlib一同使用

1.Series

Series是一种类似于一维数组的对象，它由一维数组（各种numpy数据类型）以及一组与之相关的数据标签（即索引）组成.

可理解为带标签的一维数组，可存储整数、浮点数、字符串、Python 对象等类型的数据。

import pandas as pd
import numpy as np

s = pd.Series(['a','b','c','d','e'])
# 输出
0    a
1    b
2    c
3    d
4    e
dtype: object

# Seris中可以使用index设置索引列表，与字典不同的是：Series允许索引重复
s = pd.Series(['a','b','c','d','e'],index=[100,200,100,400,500])

# 可以通过Series的values和index属性获取其数组表示形式和索引对象，返回类型为列表
value=s.values
index=s.index

#与普通numpy数组相比，可以通过索引的方式选取Series中的单个或一组值
print(s[100])  #如数据库一般选择索引为100的一组值
100    a
100    c
dtype: object

print(s[[400, 500]])
400    d
500    e
dtype: object

# Series可以用字典实例化
d = {'b': 1, 'a': 0, 'c': 2}
pd.Series(d)
# 输出
b    1
a    0
c    2
dtype: int64

# 利用ndarray创建Series
X=np.arange(6,9)
X1=pd.Series(X)
print(X1,type(X1),type(X))
# 输出
0    6
1    7
2    8

s = pd.Series(np.array([1,2,3,4,5]), index=['a', 'b', 'c', 'd', 'e'])
print(s)

#对应元素求和
print(s+s)

#对应元素乘
print(s*3)

Series中最重要的一个功能是：它会在算术运算中自动对齐不同索引的数据

Series 和多维数组的主要区别在于， Series 之间的操作会自动基于标签对齐数据。因此，不用顾及执行计算操作的 Series 是否有相同的标签。

obj1 = pd.Series({"Ohio": 35000, "Oregon": 16000, "Texas": 71000, "Utah": 5000})
obj2 = pd.Series({"California": np.nan, "Ohio": 35000, "Oregon": 16000, "Texas": 71000})
print(obj1 + obj2)
# 输出
California         NaN
Ohio           70000.0
Oregon         32000.0
Texas         142000.0
Utah               NaN
dtype: float64

2.DataFrame

DataFrame是一个表格型的数据结构，类似于Excel或sql表，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔值等）DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（共用同一个索引）

# 利用Series 字典或字典生成 DataFrame
d = {'one': pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
     'two': pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])}
print(pd.DataFrame(d))
# 输出
   one  two
a  1.0  1.0
b  2.0  2.0
c  3.0  3.0
d  NaN  4.0

# 利用ndarray生成DataFrame
data = np.array([['2019/08/02', 'zhansan', 1], ['2019/08/03', 'lisi', 2], ['2019/08/04', 'wangwu', 3]])
df = pd.DataFrame(data)
print(df)
# 输出
            0        1  2
0  2019/08/02  zhansan  1
1  2019/08/03     lisi  2
2  2019/08/04   wangwu  3

pd.DataFrame(np.arange(12).reshape(3,4))
# 输出
   0  1   2   3
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11

# 用多维数组字典、列表字典生成 DataFrame
data = {'state': ['Ohio','Ohio','Ohio','Nevada','Nevada'],    
		 'year': [2000, 2001, 2002, 2001, 2002], 
		 'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}
frame = pd.DataFrame(data)
# 输出
    state  year  pop
0    Ohio  2000  1.5
1    Ohio  2001  1.7
2    Ohio  2002  3.6
3  Nevada  2001  2.4
4  Nevada  2002  2.9

# 如果指定了列顺序，则DataFrame的列就会按照指定顺序进行排列
frame1 = pd.DataFrame(data, columns=['year', 'state', 'pop'])

# 跟原Series一样，如果传入的列在数据中找不到，就会产生NAN值
frame2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'], index=['one', 'two', 'three', 'four', 'five'])
print(frame2)

# 通过类似字典标记的方式或属性的方式，可以将DataFrame的列获取为一个Series,返回的Series拥有原DataFrame相同的索引
print(frame2['state'])

# 列可以通过赋值的方式进行修改,例如，给那个空的“delt”列赋上一个标量值或一组值
frame2['debt'] = 16.5
print(frame2)

print(frame2)
frame2['new'] = frame2['debt' ]* frame2['pop'] 

frame2['debt'] = np.arange(5.)
print(frame2)

3.DataFrame的切片操作

df = pd.DataFrame(np. arange(16).reshape(4,4),
                  index = [' ohio' , ' Colorado', ' Utah', ' New York'],
                  columns = ['one', 'two', 'three','four'])

# 取'two'列
print(df['two'])
print(df.two)
print(df.iloc[:,1])
print(type(df['two']))
 ohio         1
 Colorado     5
 Utah         9
 New York    13
Name: two, dtype: int32
<class 'pandas.core.series.Series'>

# 取某几列
print(df[['one','two']])
print(df.iloc[:,0:2])

# 取第二行
print(df[1:2])
print(df.iloc[2,:])

# 取前两行
print(df.iloc[:2,]

# 取某特定元素
print(df.iloc[2,3])

# 取前两行，前三列
print(df.iloc[:2,:3])
           one  two  three
 ohio        0    1      2
 Colorado    4    5      6

4.DataFrame层次化索引取数

首先构建一个层次化索引的DataFrame，依旧是刚刚构建的DataFrame，我们将索引改为两层索引如下：

print(df.index)
# 输出 Index([' ohio', ' Colorado', ' Utah', ' New York'], dtype='object')

df.index=[['a','a','b','b'],[1,2,1,2]]
print(df.index)
# 输出 MultiIndex(levels=[['a', 'b'], [1, 2]],
           		  labels=[[0, 0, 1, 1], [0, 1, 0, 1]])
           
print(df)   
     one  two  three  four
a 1    0    1      2     3
  2    4    5      6     7
b 1    8    9     10    11
  2   12   13     14    15
  
df.index.names=['A','B']
print(df)
      one  two  three  four
A B                       
a 1    0    1      2     3
  2    4    5      6     7
b 1    8    9     10    11
  2   12   13     14    15

# 取外层索引为'a'的元素
print(df.xs('a'))
    one  two  three  four
B                       
1    0    1      2     3
2    4    5      6     7

# 取外层索引为a,内层索引为1的元素
print((df.xs('a')).xs(1))
one      0
two      1
three    2
four     3
Name: 1, dtype: int32

# 去除层次化索引再取数
df.reset_index()

5.Series和DataFrame索引操作

DataFrame查看功能

函数	描述
DataFrame()	创建一个DataFrame对象
DataFrame.values	返回ndarray类型的对象
DataFrame.index	获取行索引
DataFrame.columns	获取列索引
DataFrame.axes	获取行及列索引
DataFrame.T	行与列对调
DataFrame. info()	打印DataFrame对象的信息
DataFrame.head(i)	显示前 i 行数据
DataFrame.tail(i)	显示后 i 行数据
DataFrame.describe()	查看数据按列的统计信息

Date_1=pd.DataFrame(np.random.rand(4,4), index=list('xyaw'), columns=list('一二三四'))
print((Date_1))
# 输出
         一           二	      三	     四
x	0.124587	0.819667	0.753738	0.958755
y	0.153189	0.453900	0.542732	0.325584
a	0.820690	0.821039	0.193243	0.546474
w	0.412408	0.868929	0.873998	0.31535

# 获取行及列索引
data1.axes
# 输出[Index(['a', 'b', 'a', 'd'], dtype='object'), Index(['城市', '环比', '同比', '定基'], dtype='object')]

# 修改行索引的内容
data1={
    '城市':['北京','上海','广州','深圳'],
    '环比':[101.5,102.2,101.3,102.0],
    '同比':[120.7,127.3,119.4,140.9],
    '定基':[121.4,127.8,120.0,145.5]
}
df1=pd.DataFrame(data,index=list('abad'))

# 判断'a'索引是否存在与df1的索引中,返回布尔值
'a' in df1.index 

# 将df2的索引对象粘贴到df1的索引后，产生一个新索引
df1.index.append(df2.index)

# 计算两个索引的差集\并集\交集
print('差集',df1.index.difference(Date_1.index))
print('并集',df1.index.union(Date_1.index))
print('交集',df1.index.intersection(Date_1.index))

# 输出
差集 Index(['b', 'd'], dtype='object')
并集 Index(['a', 'a', 'b', 'd', 'w', 'x', 'y'], dtype='object')
交集 Index(['a'], dtype='object')

# 计算表示每一个值是否在列表中的布尔数组
df1.index.isin(list('ab'))
[ True True True False]

# 将位置i的元素删除，并产生新的索引
df1.index.delete(0)

# 根据传入参数删除指定索引，并产生新的索引
df1.index.drop('a')

# 将位置i插入元素，并产生新的索引
df1.index.insert(0,'aa')

# 计算索引的唯一值序列
df1.index.unique()
# 输出为 Index(['a', 'b', 'd'], dtype='object')

方法	描述
in	判断索引是否存在
append	将额外的对象粘贴到原索引后，产生一个新索引
difference\union\intersection	计算两个索引的差集\并集\交集
isin	计算表示每一个值是否在传值容器的布尔数组
delete	将位置i的元素删除，并产生新的索引
drop	根据传入参数删除指定索引，并产生新的索引
insert	将位置i插入元素，并产生新的索引
unique	计算索引的唯一值序列

三、PIL库

PIL库是一个具有强大图像处理能力的第三方库。

图像的组成：由RGB三原色组成,RGB图像中，一种彩色由R、G、B三原色按照比例混合而成。0-255区分不同亮度的颜色。

图像的数组表示：图像是一个由像素组成的矩阵，每个元素是一个RGB值