Numpy
# numpy基础知识
import numpy as np
# python使用numpy创建数组并指定数据类型
array1 = np.array([1, 2, 3, 4], dtype="float32")
print(array1)
print(type(array1[0]))
print(array1.shape)
# numpy创建二维数组
array2 = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
print(array2)
print(array2.shape)
# 从头创建数组
# 创建值都为0的数组 numpy.zeros(n, dtype = type)
array3 = np.zeros(5, dtype=int)
print(array3)
# 创建n*m的数组,值都为k numpy.full((n, m), k)
array10 = np.full((3, 5), 9)
print(array10)
# 创建多维数组 numpy.ones((n*m), dtype = type) 值都为1
array4 = np.ones((2, 4), dtype=int)
print(array4)
# 创建单位n阶矩阵 numpy.eye(n)
array5 = np.eye(3)
print(array5)
# 创建线性序列数组， 从n开始到m结束，步长为k numpy.array(n, m, k)
array6 = np.arange(1, 15, 2)
print(array6)
# 创建一个n元素的数组，将k个数均匀分配到n-m numpy.linspace(n, m, k)
array7 = np.linspace(0, 1, 4)
print(array7)
# 创建一个n个元素的数组，组成1-n^9的等比数列
array8 = np.logspace(0, 9, 10)
print(array8)
# 创建一个n*m的，在0~1之间均匀分布的随机数构成的矩阵
array9 = np.random.random((3, 3))
print(array9)
# 创建一个n*m的,均值为k,标准差为l的正态分布随机数构成的数组
array11 = np.random.normal(0, 1, (3, 3)) # 均值为0,标准差为1
print(array11)
# 创建一个n*m的,在[k, l)之间随机整数构成的数组 numpy.random.randint(k, l, (n, m))
array12 = np.random.randint(0, 10, (3, 3))
print(array12)
# 随机重排列 不会改变原有的x 但是shuffle会
x = np.array([1, 2, 3, 4])
print(np.random.permutation(x))
np.random.shuffle(x)
print(x)
# 随机采样
y = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
# 1.按指定形状采样 size = (n, m) n行m列
y1 = np.random.choice(y, size=(4, 3))
print(y1)
# 2.按概率采样
y2 = np.random.choice(y, size=(4, 3), p=y / np.sum(y))
print(y2)
# 数组的属性
# 1.数组的形状 x.shape
# 2.数组的维度 x.ndim
# 3.数组的大小 x.size
# 4.数组的数据类型 x.dtype
# 获取副本 x.copy()
# 数组的变形 x.reshape(n, m) n*m == 原来数组中元素的个数
# 一维向量转行向量
x1 = np.arange(12)
print(x1)
x2 = x1.reshape(1, x1.shape[0]) # 转行
x3 = x1[np.newaxis, :] # 转行
print(x2)
print(x3)
x4 = x1.reshape(x1.shape[0], 1) # 转列
x5 = x1[:, np.newaxis] # 转列
print(x4, x5)
# 多维向量转一维向量
x6 = np.random.randint(0, 10, (3, 4))
x7 = x6.flatten() # 返回的是副本
x8 = x6.ravel() # 返回的是视图
x9 = x6.reshape(-1) # 返回的是视图
print(x6)
print(x7)
print(x8)
print(x9)
# 数组的拼接
# 1.水平拼接 要求行数相同
z1 = np.array([[1, 2, 3],
[4, 5, 6]])
z2 = np.array([[7, 8, 9],
[0, 1, 2]])
z3 = np.hstack([z1, z2]) # 水平拼接 副本 要求行相等
print(z3)
# 2.垂直拼接 要求列数相同
z4 = np.vstack([z1, z2]) # 非视图
z5 = np.r_[z1, z2]
print(z4)
print(z5)
# 数组的分裂
# 1.split
z6 = np.arange(10)
z7, z8, z9 = np.split(z6, [2, 7]) # 表示从2，7位置分裂
print(z7, z8, z9)
# 2.hsplit 分列
q1 = np.arange(1, 26).reshape(5, 5)
left, middle, right = np.hsplit(q1, [2, 4])
print(left) # 0-1列
print(middle) # 2-3列
print(right) # 4列
# 3.vsplit 分行
upper, middle1, lower = np.vsplit(q1, [2, 4])
print(upper) # 0-1行
print(middle1) # 2-3行
print(lower) # 4行
# numpy 四大运算
import numpy as np
# 向量化运算
# 1.与数字的加减乘除
x1 = np.arange(1, 6)
print(x1)
print(x1+5)
print(x1-5)
print(x1*5)
print(x1/5)
# 乘方 取余 负数 整除也是各位置分别操作
print(-x1)
print(x1**2)
print(x1//2)
print(x1%2)
# 2.绝对值、三角函数、指数、对数
x2 = np.array([1, -1, -2, 2, 3])
# 绝对值
print(abs(x2))
print(np.abs(x2))
# 三角函数
theta = np.linspace(0, np.pi, 3)
print(theta)
print(np.sin(theta)) # 也支持反三角函数
print(np.cos(theta))
print(np.tan(theta))
# 指数运算
x = np.arange(3)
print(np.exp(x))
# 对数运算
x1 = np.array([1, 2, 4, 8, 10])
print(np.log(x1))
print(np.log2(x1))
print(np.log10(x1))
# 两个数组的运算 各位置之间的对应操作
y1 = np.arange(1, 6)
y2 = np.arange(6, 11)
print(y1 + y2)
print(y1 - y2)
print(y1 * y2)
print(y1 / y2)
# 矩阵运算
a1 = np.arange(9).reshape(3, 3)
print(a1)
# 矩阵的转置
a2 = a1.T
print(a2)
# 矩阵的乘法
a3 = np.array([[1, 0],
[1, 1]])
a4 = np.array([[0, 1],
[1, 1]])
print(a3.dot(a4))
print(np.dot(a3, a4))
print(a4.dot(a3))
# 广播运算
# 广播的规则: 如果两个数组的形状在维度上不匹配,那么数组的形式会沿着维度为1的维度进行扩展以匹配另一个数组的形状
a5 = np.arange(3).reshape(3, 1)
a6 = np.arange(3).reshape(1, 3)
print(a5)
print(a6)
print(a5+a6)
# 比较操作和掩码
a7 = np.random.randint(10, size=(3, 4))
print(a7>5) # 会形成布尔数组
# 布尔数组的操作
print(np.sum(a7 > 5)) # true为1 false为0
print(np.all(a7 > 0)) # 判断是否后面的数组元素都满足条件
print(np.any(a7 == 6)) # 判断数组中是否存在元素满足条件
print(np.all(a7 > 0, axis=1)) # 按行判断
# 将布尔数组作为掩码
print(a7[a7 > 3]) # 只会输出满足后方条件的元素
# 花哨的索引
# 一维数组
y = np.random.randint(100, size=10)
ind = [2, 6, 9] # 输出结果与索引形状相同
print(y[ind])
ind = np.array([[1, 0],
[2, 3]])
print(y[ind])
# 多维数组
y1 = np.arange(12).reshape(3, 4)
row = np.array([0, 1, 2])
col = np.array([1, 3, 0])
print(y1[row, col]) # 将行、列合成(row, col)去寻找相应元素
# numpy 通用函数
import numpy as np
x = np.random.randint(20, 50, size=10)
print(x)
# 数值排序
print(np.sort(x)) # np.sort()不会替换原始数组 但是 x.sort()会修改原数组
# 获取排序索引
i = np.argsort(x)
print(i)
# 获取最值及其下标
print(np.max(x))
print(np.min(x))
print(np.argmax(x))
# 数组求和、求积
print(np.sum(x)) # 求和
print(x.sum())
print(np.sum(x, axis=1)) # 按行求和
print(np.sum(x, axis=0)) # 按列求和
print(np.prod(x)) # 求积
print(x.prod())
# 中位数、均值、方差、标准差
np.median(x) # 中位数
np.mean(x) # 均值
x.mean()
x.var() # 方差
np.var(x)
Pandas
import numpy as np
import pandas as pd
# Series对象的创建 一维
# pd.Series(data, index=index,dtype=dtype)
# data:数据,可以是列表,字典或numpy数组
# index:索引,为可选参数; dtype:数据类型,为可选参数
# 创建
# data = pd.Series([1, 2, 3, 4, 5])
# 添加index
data = pd.Series([1, 2, 3, 4, 5], index=["a", "b", "c", "d", "e"])
print(data)
# DataFrame对象的创建 多维
# pd.DataFrame(data,index=index,columns=columns)
# data:数据,可以是列表,字典或者numpy数组
# index:索引,为可选参数
# columns:列标签,为可选参数
# 1.通过series对象创建
population_dict = {
"beijing": 111,
"shanghai": 222,
"shenzhen": 333,
"hangzhou": 444
}
population = pd.Series(population_dict)
print(pd.DataFrame(population, columns=["number"]))
# 2.通过Series对象字典创建
GDP_dict = {
"beijing": 33000,
"shanghai": 22200,
"shenzhen": 22110,
"hangzhou": 14440
}
GDP = pd.Series(GDP_dict)
# 数量不够的会自动补齐
Data_1 = pd.DataFrame({"population": population,
"GDP": GDP,
"country": "China"})
print(Data_1)
# 3.通过字典列表对象创建
# 字典索引作为index,字典键作为columns
# 不存在的键,会默认值为NaN
data1 = [{"a": i, "b": 2*i} for i in range(3)]
Data_2 = pd.DataFrame(data1)
print(Data_2)
# 4.通过numpy二维数组创建
data2 = np.random.randint(10, size=(3, 2))
Data_3 = pd.DataFrame(data2,columns=["foo", "bar"], index={"a", "b", "c"})
print(Data_3)
# DataFrame的属性
# 1.df.values返回numpy数组表示的数据
print(Data_1.values)
# 2.df.index返回行索引
print(Data_1.index)
# 3.df.columns返回列索引
print(Data_1.columns)
# 4.df.shape形状
print(Data_1.shape)
# 5.df.size大小
print(Data_1.size)
# 6.pd.dtypes返回每列数据类型
print(Data_1.dtypes)
# DataFrame的索引
# 1.获取列
# 字典式
print(Data_1["population"])
# 对象属性式
print(Data_1.GDP)
# 2.获取行
print("\n")
# 绝对索引 df.loc
print(Data_1.loc["beijing"])
# 相对索引 df.iloc
print(Data_1.iloc[0])
# 3.获取标量
print(Data_1.loc["beijing", "GDP"])
# 4.Series对象的索引
print(GDP["beijing"])
# DataFrame的切片
dates = pd.date_range(start='2019-01-01', periods=6)
print(dates)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=["A", "B", "C", "D"])
print(df)
# 1.行切片
print(df["2019-01-01": "2019-01-03"])
print(df.loc["2019-01-01": "2019-01-03"])
print(df.iloc[0: 3])
# 2.列切片
print(df.loc[:, "A": "C"])
print(df.iloc[:, 0: 3])
# 3.多种多样的取值
# 行、列同时切片
print(df.loc["2019-01-02": "2019-01-04", "C": "D"])
print(df.iloc[1: 3, 2:])
# 行切片,列分散取值
print(df.loc["2019-01-02": "2019-01-04",["A", "C"]])
print(df.iloc[3: ,[0, 2]])
# 行分散取值,列切片同理
# 行、列均分散取值 只能用 df.iloc
# 4.布尔索引
# 通过比较操作获得布尔矩阵
print(df > 0)
# isin()方法
df2 = df.copy()
df2['E'] = ['one', 'two', 'three', 'four', 'two', 'five']
ind = df2['E'].isin(["two", "four"])
print("isin方法")
print(df2[ind])
# 赋值
# DataFrame 增加新列
s1 = pd.Series([1, 2, 3, 4, 5, 6], index=pd.date_range('20190101', periods=6))
df["E"] = s1
print(s1)
print(df)
# 修改索引
df.loc['2019-01-01', 'A'] = 0
print(df)
df.iloc[0, 2] = 1
print(df)
# 对一行或者一列
df['D'] = np.array([5]*len(df))
print(df)
# 修改index和columns
df.index = [i for i in range(len(df))]
print(df)
df.columns = [i for i in range(df.shape[1])] # 返回列数df.shape[1] 返回行数df.shape[0] 或者len(df)
print(df)
import pandas as pd
import numpy as np
# 数值运算及统计分析
# 1.数据的查看
dates = pd.date_range(start='2019-01-01', periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=['A', 'B', 'C', 'D'])
# 查看前面的行
print(df.head()) # 默认5行
# 查看后面的行 # 默认5行
print(df.tail())
# 查看总体信息
df.iloc[0, 3] = np.nan
print(df.info())
# numpy通用函数同样适用于pandas
# 向量化运算
x = pd.DataFrame(np.arange(4).reshape(1, 4))
print(x)
y = pd.DataFrame(np.arange(4, 8).reshape(1, 4))
# 矩阵化运算
a = pd.DataFrame(np.random.randint(10, size=(30, 30)))
b = pd.DataFrame(np.random.randint(10, size=(30, 30)))
print(a.dot(b))
# 广播运算
c = pd.DataFrame(np.random.randint(10, size=(3, 3)), columns=list('ABC'))
print(c)
print(c.div(c.A, axis=0)) # 按列广播声明轴为0 即axis=0
# 索引新的用法
# 索引对齐
A = pd.DataFrame(np.random.randint(0, 20, size=(2, 2)), columns=list("AB"))
print(A)
B = pd.DataFrame(np.random.randint(0, 10, size=(3, 3)), columns=list("ABC"))
print(B)
print(A + B) # 也会进行广播式的操作 但是非交集为NaN
# 缺省值也可以用fill_value来填充
print(A.add(B, fill_value=0)) # 四则运算同理
# 统计相关的操作
# 数据种类统计
d = np.random.randint(3, size=20)
d1 = pd.DataFrame(d, columns=['A'])
print(d1)
print(d1['A'].value_counts())
# 排序
# 升序排列 df.sort_value(by="列名")
# 降序排列 df.sort_value(by="列名", ascending=False)
# 行排序 data.sort_index()
# 列排序 data.sort_index(axis=1)
# data.sort_index(axis=num, ascending=False/True)
# 统计方法
datas = pd.DataFrame(np.random.normal(2, 4, size=(6, 4)), columns=list("ABCD"))
print(datas)
# 非空个数
datas.count()
# 求和
datas.sum() # 默认axis=0
# 最值
datas.min()
datas.max()
# 最值坐标
datas.idxmax()
datas.idxmin()
# 均值
datas.mean()
# 方差
datas.var()
# 标准差
datas.std()
# 中位数
datas.median()
# 众数
datas.mode()
# 百分比分位数 datas.quantile(num)
datas.quantile(0.75)
# 总体面貌
datas.describe()
# 相关性系数和协方差
datas.corr() # 相关性系数
datas.corrwith(datas["A"]) # 与某一列的相关性系数
# 自定义输出
# apply(method)的用法:使用method方法默认对每一列进行相应的操作
datas.apply(np.cumsum) # np.cumsum是累加操作
# 缺失值处理
data1 = pd.DataFrame(np.array([[1, np.nan, 2],
[np.nan, 3, 4],
[5, 6, None]]), columns=list("ABC"))
# 有None、字符串等,数据类型全部变为object,它比int和float更消耗资源
# 1.发现缺失值
data1.isnull() # 返回布尔矩阵
data1.notnull() # 返回布尔矩阵
data2 = pd.DataFrame(np.array([[1, 2, np.nan],
[2, 5, 6],
[np.nan, 6, 9]]), columns=list("ABC"))
# 2.删除缺失值
# 删除整行
data2.dropna() # 将含有缺失值的行全部删除
data2["C"] = np.nan
data2.dropna(axis=1, how="all") # 设置axis=1之后删除为列,how="all"表示删除全部缺失的行/列
# 3.填充缺失值
data2.fillna(value=5) # 使用df.fillna(value=num) 表示用num填充缺失值
# df.stack().mean() 表示全部数据的平均值
# 合并数据
# 构造一个生产DataFrame的函数
def make_df(cols, ind):
data = {c: [str(c) + str(i) for i in ind] for c in cols}
return pd.DataFrame(data, ind)
# 垂直合并
df_1 = make_df("AB", [1, 2])
df_2 = make_df("AB", [3, 4])
print(pd.concat([df_1, df_2]))
# 水平合并
print(pd.concat([df_1, df_2], axis=1, ignore_index=True))
# 对齐合并merge()
df_9 = make_df("AB", [1, 2])
df_10 = make_df("BC", [1, 2])
print(pd.merge(df_9, df_10))
# pd.merge(df1, df2, how="outer") 返回并集
# 分组和数据透视表
df_3 = pd.DataFrame({"key": ["A", "B", "C", "C", "B", "A"],
"data1": range(6),
"data2": np.random.randint(0, 10, size=6)})
# 分组
# 延迟计算
df_3.groupby("key")
print(df_3.groupby("key").sum())
print(df_3.groupby("key").mean())
# 按列取值
df_3.groupby("key")["data2"].sum()
# 调用方法
print(df_3.groupby("key")["data2"].describe())
# 支持更复杂的操作
print(df_3.groupby("key").aggregate(["min", "max", "median"]))
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
