文章目录
一、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值