洪宇建设集团公司网站,北京建设网站公司,网站建设费用要摊销嘛,建设网站怎么添加端口映射文章目录 Pandas的数据结构Series --- 由数据和索引组成#xff08;索引#xff08;index#xff09;在左#xff0c;数据#xff08;values#xff09;在右#xff09;DataFrame --- 索引包括行索引和列索引#xff0c;每列数据可以是不同的类型 Pandas的索引操作 ---… 文章目录 Pandas的数据结构Series --- 由数据和索引组成索引index在左数据values在右DataFrame --- 索引包括行索引和列索引每列数据可以是不同的类型 Pandas的索引操作 --- 索引对象indexSeriesDataFrame Pandas的对齐运算SeriesDataFrame Pandas的函数应用层级索引Pandas的统计和计算Pandas分组与聚合分组聚合 时间序列分组和连接数据合并 Pandas的数据结构
Series — 由数据和索引组成索引index在左数据values在右 import pandas as pd# 生成一个series
ser_obj pd.Series(range(10, 20))
print(ser_obj)
print(-- * 20)# 获取数据
print(ser_obj.values)print(-- * 20)# 获取索引
print(ser_obj.index)print(-- * 20)# 下面对ser_obj的计算都不改变ser_obj的实际值# 所有的值 * 2 注索引不变
print(ser_obj * 2)
print(-- * 20)# 值满足条件的为True 不满足为False 注索引不变
print(ser_obj 15)
print(-- * 20)# 通过索引下标访问值 索引下标不存在报错
print(ser_obj[1]) # 11 上面的运算 并没有 改变ser_obj的值
# ser_obj[10] # KeyError: 10
print(---------------- 通过字典变series --------------------)# 字典变为series
year_data {2001: 1, 2013: 13, 2016: 16, 2019: 19, 2023: 23}
ser_obj2 pd.Series(year_data)
print(ser_obj2)
print(-- * 20)
print(ser_obj2.index)
print(-- * 20)
print(ser_obj2.values)
print(-- * 20)
print(type(ser_obj2.values)) # class numpy.ndarray
print(type(ser_obj2.index)) # class pandas.core.indexes.base.Index
print(-- * 20)
print(ser_obj2[2023]) # 23print(*** * 14)# index.name 索引列的名字 name 整个Series的名字
# head 所有的名字 值 类型
print(ser_obj2.name)
ser_obj2.name temp
print(ser_obj2.index.name)
ser_obj2.index.name year1
print(-- * 20)
print(ser_obj2.head())
# print(ser_obj2.head(n)) # 打印前n行的信息但是索引列的名字和 series的名字都会显示 还有dtypeDataFrame — 索引包括行索引和列索引每列数据可以是不同的类型 import pandas as pd
import numpy as np# 通过 ndarray 构建 DataFrame
arr np.arange(18).reshape((3, 6))
print(pd.DataFrame(arr))
print(--- * 20)# 通过 dict 构建 DataFrame
d [{name: xiaohong, age: 23, tel: 10086},{name: xiaogang, tel: 10087},{name: xiaowang, age: 22, tel: 10088}]
df pd.DataFrame(d)
print(df)
print(--- * 20)# 列 要不相等 要不为1
dict_data {A: 1,B: pd.Timestamp(20190926),C: pd.Series(1.5, indexlist(range(4))),D: np.array([3] * 4, dtypeint32),E: [python, c, c, java],F: wangdao}
df_obj pd.DataFrame(dict_data)
print(df_obj)
print(-- * 20)
print(df_obj.columns) # Index([A, B, C, D, E, F], dtypeobject)
print(-- * 20)# 感受日期 date_range
# random.randn(x,y) 生成 x行 y列 随机数
dates pd.date_range(20130101, periods6)
df1 pd.DataFrame(np.random.randn(6, 4), indexdates, columnslist(ABCD))
print(df1)
print(-- * 20)# 把df的某一列取出来是Series 且 名字是 series的名字
print(df_obj[B])
print(type(df_obj[B]))
print(-- * 20)# 增加列数据 列名 自定义
df_obj[G] df_obj[D] 4
print(df_obj)# 删除列
del (df_obj[G])
print(-- * 20)
print(df_obj)Pandas的索引操作 — 索引对象index Series
import pandas as pd# Series 索引# Series(值索引)
# ser_obj pd.Series(range(5), index[a, b, c, d, e]) # 和下面这句功能一样
ser_obj pd.Series(range(5), indexlist(abcde))
print(ser_obj)# 行索引 可以用索引名 也可以用0123默认都有 即使取了别名
print(按索引名索引为)
print(ser_obj[a])
print(按0123索引为)
print(ser_obj[1])
print(-- * 20)# 切片索引
print(ser_obj[1:3]) # 按0123索引 左闭右开
print(ser_obj[a:c]) # 按索引名 左右都闭---因为你不知道c前面是谁 所以不知道到哪停止
print(-- * 20)# 不连续索引 [[]]
print(ser_obj[[0, 2, 4]])
print(ser_obj[[a, e]])
print(-- * 20)# 布尔索引
ser_bool ser_obj 2
print(ser_bool)
# 下面两个结果一样
print(ser_obj[ser_bool])
# print(ser_obj[ser_obj 2])DataFrame
import numpy as np
import pandas as pd# DataFrame索引 index行 columns列
df_obj pd.DataFrame(np.random.randn(5, 4),index[a, b, c, d, e],columns[a, b, c, d])
print(df_obj)
print(-- * 20)# 列索引
print(df_obj[a]) # []返回Series类型
print(-- * 20)
print(df_obj[[a]]) # [[]]返回DataFrame类型
print(-- * 20)# 标签索引 loc 索引---名 [] 左右都是闭区间 名只能用名字 不能用0123
# Series
print(df_obj.loc[a]) # 推荐 取---行
# print(df_obj[a]) # 建议不用 取---列
print(-- * 20)
# 第一个参数是行第二个参数是列
print(df_obj.loc[a:c, b])
print(-- * 20)# iloc ---(位置) 索引 是 前闭后开 [) 位置只能用 数字0123
print(df_obj.iloc[0:2, 1:2])
print(type(df_obj.iloc[0:2, 1:2]))Pandas的对齐运算
Series
import pandas as pd# 对齐运算 缺失数据 默认是nan 注只有float类型才有nan和inf
# Series
s1 pd.Series(range(10, 20), indexrange(10))
s2 pd.Series(range(25, 30), indexrange(5))
s3 s1 s2
print(s3) # 缺失数据 默认是nan
print(-- * 20)
# 未对齐的数据nan 和 填充值fill_value ---做 ---运算
# 注不是---计算完 ---以后 在把nan填充成fill_value
print(s1.add(s2, fill_value0))DataFrame
import pandas as pd# np.ones(x,y) 用 1. 填充x行y列
df1 pd.DataFrame(np.ones((2, 2)), columnslist(ab))
df2 pd.DataFrame(np.ones((3, 3)), columns[a, b, c])
print(df1 - df2)
print(-- * 20)
print(df1.sub(df2, fill_value2.)) # nan 的位置用 2. 来计算 (写成2也行)Pandas的函数应用
import pandas as pd
import numpy as np# 函数应用 Series
df pd.DataFrame(np.random.randn(5, 4) - 1)
print(df)
print(绝对值如下np.abs():)
print(np.abs(df)) # 绝对值
print(-- * 20)# apply 作用在 列上 axis 默认为0
print(df.apply(lambda x: x.max()))
print(-- * 20)# apply 作用在 行上
print(df.apply(lambda x: x.max(), axis1))
print(-- * 20)# applymap 作用到 每个数据
print(df.applymap(lambda x: %.2f % x)) # 保留两位小数
# print(df.dtypes)
print(-- * 20)s pd.Series(range(10, 15), indexnp.random.randint(5, size5)) # 必须加size5
print(s)
print(-- * 20)# 索引排序(sort_index)
print(s.sort_index())
print(-- * 20)# DataFrame
df pd.DataFrame(np.random.randn(5, 5),indexnp.random.randint(5, size5),columnsnp.random.randint(5, size5))
print(df)
print(-- * 20)
# 轴0是行索引排序
# sort_index 默认是升序排序 ascendingFalse 为降序排序
df_rSort df.sort_index(axis0, ascendingFalse)
print(df_rSort)
print(-- * 20)
# 轴1是列索引排序
df_cSort df.sort_index(axis1, ascendingFalse)
print(df_cSort)
print(-- * 20)# 按值排序(sort_values) by后是column的值
import randoml [random.randint(0, 100) for i in range(24)]
df2 pd.DataFrame(np.array(l).reshape(6, 4))
print(df2)
print(-- * 20)
# 按轴0排序 by后是列名 ---结果以 行的形式展示
df2_cSort df2.sort_values(by3, axis0, ascendingFalse)
print(df2_cSort)
print(-- * 20)
# 按轴1排序 by后是行名 ---结果以 列的形式展示
df2_rSort df2.sort_values(by3, axis1, ascendingFalse)
print(df2_rSort)# 处理缺失数据
df pd.DataFrame([np.random.randn(3), [1., 2., np.nan], [np.nan, 4., np.nan], [1., 2., 3.]])
print(df.head())# df.isnull() nan 为True 其他为 False
print(df.isnull())
print(-- * 20)# df.dropna() 默认是删除行 ---加axis1 就是删除列一般不用
print(df.dropna())
print(-- * 20)# fillna 把nan填成某值
print(df.fillna(-100.))
print(-- * 20)层级索引
index1 pd.MultiIndex.from_arrays([[a, a, a, b, b, b, c, c, c], [0, 1, 2, 0, 1, 2, 0, 1, 2]],names[cloth, size])
ser_obj pd.Series(np.random.randn(9), indexindex1)print(ser_obj)
print(-- * 20)
print(ser_obj.index)
# [[a, b, c], [0, 1, 2]]
print(ser_obj.index.levels)
print(-- * 20)# 层级索引如何获取数据
print(ser_obj[c]) # 外层索引
print(-- * 20)
print(ser_obj[c, 1]) # 内层索引
print(-- * 20)
print(ser_obj[:, 2])
print(-- * 20)# 交换层级 swaplevel()
print(ser_obj.swaplevel())
print(-- * 20)
print(ser_obj)
print(-- * 20)
# 层级索引按那个索引级别排序
print(ser_obj.sort_index(level1))# unstack 可以放索引名 或者索引位置
print(-- * 20)
df_obj ser_obj.unstack(1) # 把1层索引 放到上面 变成dataframe
print(df_obj)
print(-- * 20)# stack 把行、列索引进行堆叠 变成Series
print(df_obj.stack())Pandas的统计和计算
import numpy as np
import pandas as pd# pandas统计和计算
# axis 1 统计每一行 axis 0 统计每一列
df_obj pd.DataFrame(np.random.randn(5, 4), columnslist(abcd))
print(df_obj)
df_obj.loc[1, b] np.nan
print(df_obj)
print(-- * 20)
# skipna 是否跳过nan 默认是True axis1 表示每一行的最小值 axis0表示每一列的最小值
print(df_obj.min(axis1, skipnaFalse))
print(-- * 20)
# describe() 最大值 最小值 数值的个数 方差 等等都有
print(df_obj.describe())
print(-- * 20)# 计算最大值或者最小值的 位置
# argmin 和 argmax 只能是Series 不能是 DataFrame
print(type(df_obj.loc[:, c])) # Series
print(df_obj.loc[:, c].argmin())
print(-- * 20)# 计算最大值或者最小值的 索引 idxmax idxmin
print(df_obj.idxmax(axis0)) # axis0 表示每一 列Pandas分组与聚合
分组
import numpy as np
import pandas as pd# 分组 都是按 轴1分组 因为每一列代表一种类型
# 字典默认作为列名
dict_obj {key1: [a, b, a, b, a, b, a, a],key2: [one, one, two, three, two, two, one, three],data1: np.random.randn(8),data2: np.random.randn(8)}
df_obj pd.DataFrame(dict_obj)
print(df_obj)
print(-- * 20)# dataframe根据key1进行分组分组后的对象类型
print(df_obj.groupby(key1))
print(type(df_obj.groupby(key1)))
print(-- * 20)
print(df_obj[data1])
# dataframe 的 data1 列 根据key1 进行分组
print(type(df_obj[data1].groupby(df_obj[key1])))
print(-- * 20)# 分组运算
grouped2 df_obj[data1].groupby(df_obj[key1])
print(grouped2.mean())
print(-- * 20)# 按自定义的key分组
self_def_key [0, 1, 2, 3, 3, 4, 4, 7]
print(df_obj.groupby(self_def_key).size()) # 等于mysql的count
print(df_obj.groupby(self_def_key).sum())
print(-- * 20)# 按自定义key分组多层列表
print(df_obj.groupby([df_obj[key1], df_obj[key2]]).size())
print(-- * 20)# 按多个列 多层分组
grouped3 df_obj.groupby([key1, key2])
print(grouped3.size())
print(-- * 20)# 多层分组 按key的顺序进行
grouped4 df_obj.groupby([key2, key1])
print(grouped4.size())
print(grouped4.mean())
print(-- * 20)# unstack 可以将多层索引的结果换成单层的dataframe
print(grouped4.mean().index)
print(type(grouped4.mean().unstack()))
print(grouped4.mean().unstack())
print(grouped4.mean().unstack().columns)
print(-- * 20)# 多层分组根据key1 和 key2
for group_name, group_data in grouped4:print(group_name)print(group_data)print(type(group_data))
print(-- * 20)# 按类型分组
print(df_obj.dtypes)
# 一列数据类型必须一致对应现实生活的一个特征
df_obj[data3] df_obj[data2] 1
print(df_obj)
print(-- * 20)
print(df_obj.groupby(df_obj.dtypes, axis1).size()) # 按轴0没有意义
print(df_obj.groupby(df_obj.dtypes, axis1).sum())
self_column_key [1, 2, 3, 3, 4]
print(df_obj.groupby(self_column_key, axis1).sum()) # 通过自定义索引去让不同列相加
print(-- * 20)# 通过字典分组 randint(1, 10, (5, 5)) 1-10之间 5行5列
df_obj2 pd.DataFrame(np.random.randint(1, 10, (5, 5)), columnslist(abcde), indexlist(ABCDE))
print(df_obj2)
# 给指定某个部分的数据重新赋值为np.NaN
df_obj2.loc[B, b:d] np.nan
print(df_obj2)
print(** * 20)# 通过字典分组
mapping_dict {a: python, b: python, c: java, d: c, e: java}print(df_obj2.groupby(mapping_dict, axis1).size()) # 值 对应的个数 c -- 1 java -- 2 python -- 2
print(df_obj2.groupby(mapping_dict, axis1).count()) # 非nan的个数
print(df_obj2.groupby(mapping_dict, axis1).sum()) # 求和不记录nan nan当作0了
print(-- * 20)# 通过函数分组
df_obj3 pd.DataFrame(np.random.randint(1, 10, (5, 5)), columnslist(abcde),index[AA, BBBB, CCC, D, EEE])
print(df_obj3)def group_key(idx):return len(idx) # 默认传的是行索引 因为列索引都是1print(df_obj3.groupby(group_key).size()) # axis 默认是0
# 上面自定义函数等价于
print(df_obj3.groupby(len).size())
print(-- * 20)# 通过索引级别分组
columns pd.MultiIndex.from_arrays([[python, java, python, java, c], [A, A, C, B, B]],names[language, index1])
df_obj4 pd.DataFrame(np.random.randint(1, 10, (5, 5)), columnscolumns)
print(df_obj4)
print(-- * 20)# 根据language进行分组
print(df_obj4.groupby(levellanguage, axis1).sum())
print(-- * 20)# 根据index进行分组
print(df_obj4.groupby(levelindex1, axis1).sum())聚合 import numpy as np
import pandas as pd# 聚合
# 字典默认作为列名
dict_obj {key1: [a, b, a, b, a, b, a, a],key2: [one, one, two, three, two, two, one, three],data1: np.random.randn(8),data2: np.random.randn(8)}
df_obj pd.DataFrame(dict_obj)
print(df_obj)# 自定义聚合函数
def peak_range(df):df 参数是 groupby后的groupby对象:param df::return:return df.max() - df.min()df_obj2 df_obj.loc[:, [key1, data1, data2]]
print(df_obj2.groupby(key1).agg(peak_range))
print(df_obj2.groupby(key1).agg(lambda df: df.max() - df.min()))
print(-- * 20)# 同时应用多个聚合函数
print(df_obj2.groupby(key1).agg([mean, std, count, peak_range]))
print(-- * 20)# 每列作用不同的聚合函数
dict_mapping {data1: mean,data2: count
}
print(df_obj2.groupby(key1).agg(dict_mapping))时间序列 import numpy as np
import pandas as pd# 设置索引
# 索引中单项不可以改变但是整体可以换掉
a pd.DataFrame({a: range(7), b: range(7, 0, -1),c: [one, one, two, one, two, two, two],d: list(hjklmno)})
print(a)
c a.copy()
a.index list(abcdefg)
print(c的索引没变)
print(c)
print(a) # a的索引变了
print(-- * 20)
b c.reindex(list(abcdefg)) # 返回一个新的dfb没有值c的索引不变
print(b)
print(-- * 20)# 让某些列变为索引
print(a)
print(a.set_index([c, d])) # a没变返回修改后的df
print(a没变)
print(a)
print(-- * 20)# 时间序列 date_range 注意是 date e
pd.date_range(start20190101, end20190924)# periods 长度 B 工作日 M 每月最后一天 W 每周周日
pd.date_range(start20190101, periods10, freqB)
pd.date_range(start20190819, periods8, freqM)
pd.date_range(start20230819, periods8, freqW)分组和连接
import numpy as np
import pandas as pd# 分组和连接
dict_obj {key1: [a, b, a, b, a, b, a, a],data1: np.random.randn(8),data2: np.random.randn(8)}
df_obj pd.DataFrame(dict_obj)
print(df_obj)
print(-- * 20)
# add_prefix 增加前缀
key1_sum df_obj.groupby(key1).sum().add_prefix(sum_)
print(key1_sum)
print(-- * 20)# 两个df之间进行连接
# 和mysql的join是一致的 on 连接条件
# 左边以key1为关键词进行连接右边选True
key1_sum_merge pd.merge(df_obj, key1_sum, left_onkey1, right_indexTrue)
print(key1_sum_merge)
print(-- * 20)# 方法二 使用transform 把分组后的结果放到原处
key1_sum_tf df_obj.groupby(key1).transform(np.sum).add_prefix(sum_)
print(key1_sum_tf)
print(-- * 20)# 算自己比平均值高多少 或者少多少
def diff_mean(s):return s - s.mean()print(df_obj.groupby(key1).transform(diff_mean))# 星际争霸
dataset_path starcraft.csv
df_data pd.read_csv(dataset_path, usecols[LeagueIndex, Age, HoursPerWeek, TotalHours, APM])
print(df_data)
print(-- * 20)def top_n(df, n3, columnAPM):返回每个分组按 column 的 top n 数据return df.sort_values(bycolumn, ascendingFalse)[:n]# apply 可以用自定义函数
print(df_data.groupby(LeagueIndex).apply(top_n))
# group_keys 为 False后groupby的列不会变为索引
print(df_data.groupby(LeagueIndex, group_keysFalse).apply(top_n))
# 可以自己传参
print(df_data.groupby(LeagueIndex).apply(top_n, n4, columnAge))
print(--- * 20)# 连接两个dataframe
df_obj1 pd.DataFrame({key: list(bbacaab),data1: np.random.randint(0, 10, 7)})
df_obj2 pd.DataFrame({key: list(abd),data2: np.random.randint(0, 10, 3)})
print(df_obj1)
print(df_obj2)
print(-- * 20)# 1 默认使用相同的列命进行连接连接方式是内连接
print(pd.merge(df_obj1, df_obj2))# 2 左表索引和右表索引进行连接 _index 索引连接
print(pd.merge(df_obj1, df_obj2, left_indexTrue, right_indexTrue))# 3 使用相同的列命进行连接,连接方式是内连接 和 1 一样
pd.merge(df_obj1, df_obj2, onkey)
print(-- * 20)# 4 左右只能出现一次但是连接方式可以任意
df_obj1 df_obj1.rename(columns{key: key1})
df_obj2 df_obj2.rename(columns{key: key2})print(pd.merge(df_obj1, df_obj2, left_onkey1, right_onkey2))
print(-- * 20)# 全外连接
print(pd.merge(df_obj1, df_obj2, left_onkey1, right_onkey2, howouter))
print(-- * 20)# left join 等价于 left outer join 左表为主
print(pd.merge(df_obj1, df_obj2, left_onkey1, right_onkey2, howleft))
print(-- * 20)# right 等价于 right outer join 右表为主
print(pd.merge(df_obj1, df_obj2, left_onkey1, right_onkey2, howright))
print(-- * 20)# 处理重复列命
df_obj3 pd.DataFrame({key: list(bbacaab),data: np.random.randint(0, 10, 7)})
df_obj4 pd.DataFrame({key: list(abd),data: np.random.randint(0, 10, 3)})
# 给相同的数据列添加后缀 on列
print(pd.merge(df_obj3, df_obj4, onkey, suffixes(_left, _right)))数据合并
import numpy as np
import pandas as pd# 数据合并
# numpy 里面的合并
arr1 np.random.randint(0, 10, (3, 4))
arr2 np.random.randint(0, 10, (3, 4))
print(arr1)
print(arr2)
print(-- * 20)# 默认按轴0合并
print(np.concatenate([arr1, arr2]))
print(np.concatenate([arr1, arr2], axis1))
print(-- * 20)# pandas 合并
# index 没有重复的情况
ser_obj1 pd.Series(np.random.randint(0, 10, 5), indexrange(0, 5))
ser_obj2 pd.Series(np.random.randint(0, 10, 5), indexrange(5, 10))
ser_obj3 pd.Series(np.random.randint(0, 10, 5), indexrange(10, 15))
print(ser_obj1)
print(ser_obj2)
print(ser_obj3)
print(-- * 20)print(pd.concat([ser_obj1, ser_obj2, ser_obj3]))
print(pd.concat([ser_obj1, ser_obj2, ser_obj3], axis1))
print(--- * 20)# index 有重复的情况
ser_obj1 pd.Series(np.random.randint(0, 10, 5), indexrange(0, 5))
ser_obj2 pd.Series(np.random.randint(0, 10, 5), indexrange(3, 8))
ser_obj3 pd.Series(np.random.randint(0, 10, 5), indexrange(6, 11))
print(-- * 20)print(pd.concat([ser_obj1, ser_obj2, ser_obj3]))
print(-- * 20)
print(pd.concat([ser_obj1, ser_obj2, ser_obj3], axis1, joininner)) # 内连接 没有nan
print(pd.concat([ser_obj1, ser_obj2, ser_obj3], axis1, joinouter)) # 全外连接 有 nan
print(pd.concat([ser_obj1, ser_obj2, ser_obj3], axis1)) # 默认外连接 有nan
print(-- * 20)# 数据重构
df_obj pd.DataFrame(np.random.randint(0, 10, (5, 2)), columns[data1, data2])
print(df_obj)# 对df进行stack,就会变成mutiindex的series
stacked df_obj.stack() # stack 内部带的参数是 level 选择哪一个 column 变为 index
print(stacked)
print(stacked.unstack()) # 又回去了
print(-- * 20)
print(stacked.unstack(level0))
print(-- * 20)# 处理重复数据
df_obj pd.DataFrame({data1: [a] * 4 [b] * 4, data2: np.random.randint(0, 4, 8)})
print(df_obj)
print(df_obj.duplicated()) # 把从上到下重复的变为True
df_obj[~df_obj.duplicated()] # 取出不重复行# 按某列去重
print(df_obj.duplicated(data2))
print(-- * 20)df_obj1 pd.DataFrame({data1: [np.nan] * 4,data2: list(1234)})
print(df_obj1)
print(df_obj1.duplicated(data1)) # 空值认为相等 实际上 np.nan ! np.nan 为True
print(df_obj1.drop_duplicates(data1)) # 去除重复行
print(-- * 20)# series 替换值
ser_obj pd.Series(np.arange(10))
print(ser_obj)
# 单个值替换成单个值
print(ser_obj.replace(1, -100))# 多个值替换成单个值
print(ser_obj.replace(range(6, 9), -100))# 多个值替换成多个值
print(ser_obj.replace([4, 6], [-100, -200]))
print(-- * 20)# dataframe 替换值
df pd.DataFrame({A: [0, 1, 2, 3],B: [4, 5, 6, 7],C: list(abcd)})
print(df)
# regexTrue 正则表达式 前面用了正则 就需要变为True
print(df.replace(to_replacer^a, value100, regexTrue))
print(df.dtypes) # C列变为object类了
