Pandas基础：核心数据结构及基础运算

一、Pandas基础

1.核心数据结构

#%%
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
#%%
x = np.linspace(0,2*np.pi, num=100)
print(x)
y = np.sin(x)
print(y)
#%%
plt.plot(x,y)
#%%
s = pd.Series([1,3,5,np.NaN,8,4])
s
#%%
dates = pd.date_range("20200823", periods=6)
dates
#%%
data = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list("ABCD"))
data.head(3)
#%%
data.shape
#%%
data.values
#%%
df = pd.DataFrame({"A":1, "B":pd.Timestamp("2020-8-23 00:00:00"), "C":range(4), "D":np.arange(4)})
df
#%%
df["A"]
#%%
# 查看头部数据
df.head(3)
#%%
# 查看尾部数据
df.tail(3)
#%%
# 转置
df.T
#%%
# 排序
data.sort_index(axis=1, ascending=False)
#%%
data.loc[:,["B","C"]]
#%%
# 访问数据
data.loc["2020-08-24","B"]
#%%
# 效率更高，需要传入原生数据结构
data.at[pd.Timestamp("2020-08-24"), "B"]
#%%
%timeit df.iat[1,1]
#%%
%timeit data.iat[1,1]
#%%
data[data>0]
#%%
data2 = data.copy()
#%%
tag = ["a"]*2 + ["b"]*2 + ["c"]*2
#%%
data2["TAG"]=tag
data2
#%%
# 通过使用isin函数对数据进行过滤
data2[data2.TAG.isin(["a","c"])]
#%%
# 直接修改某个元素
data.iat[0,0]=100
data
#%%
# 直接修改一列
data["A"] = range(6)
data
#%%
data.B = 100
data
#%%
data.iloc[:,2:5]=1000
data

#%%
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
#%%
dates = pd.date_range("20200823", periods=6)
df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list("ABCD"))
df
#%%
df1 = df.reindex(index=dates[0:4], columns=list(df.columns) + ["E"])
df1
#%%
df1.loc[dates[1:3],"E"]=2
df1
#%%
# 不对原DataFrame进行修改
df1.dropna()
#%%
# 不对原DataFrame进行修改
df1.fillna(value=5)
#%%
# 代表有空数据
pd.isnull(df1).any().any()
#%%
df1.mean()
#%%
df
#%%
# cumsum：求累加值
df.apply(np.cumsum)
#%%
# 求每一列最大值与最小值的差
df.apply(lambda x: x.max() - x.min())
#%%
# x为每一列的Series
def _sum(x):
    print(type(x))
    return x.sum()
df.apply(_sum)
#%%
# 在10-20之间生成20个随机数
s = pd.Series(np.random.randint(10,20,size=20))
s
#%%
s.value_counts()
#%%
# mode:显示频次最高的数
s.mode()
#%%
df2 = pd.DataFrame(np.random.randn(10,4), columns=list("ABCD"))
df2
#%%
df2.iloc[:3]
#%%
df2.iloc[3:7]
#%%
df2.iloc[7:]
#%%
df3 = pd.concat([df2.iloc[:3],df2.iloc[3:7],df2.iloc[7:]])
#%%
(df2 == df3).all().all()

#%%
# 设置为inline风格
%matplotlib inline
# 包导入
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
#%%
axb = list(zip(*[['bar', 'bar', 'baz', 'baz',
                     'foo', 'foo', 'qux', 'qux'],
                    ['one', 'two', 'one', 'two',
                     'one', 'two', 'one', 'two']]))
axb
#%%
"""
MultiIndex.from_tuple函数：是将元组变为多层索引
它有三个参数：pandas.MultiIndex. from_tuples(tuples, sortorder=None, names=None)

tuples：元组
sortorder：排序顺序，可选参数。
名称：设置多层索引名称，可选。
"""
index = pd.MultiIndex.from_tuples(axb, names=['first', 'second'])
index
#%%
df = pd.DataFrame(np.random.randn(8,2), index=index, columns=["A", "B"])
df
#%%
# 将A,B变为行索引
stacked = df.stack()
stacked
#%%
stacked.index
#%%
# 将A,B恢复为列标签
stacked.unstack().unstack()
#%%
# 数据透视
df = pd.DataFrame({
    "A":["one", "one", "two", "three"]*3,
    "B":["A", "B", "C"]*4,
    "C":["foo", "foo", "foo", "bar", "bar", "bar"]*2,
    "D":np.random.randn(12),
    "E":np.random.randn(12)
})
df
#%%
# 以A、B做行索引，以C做列索引，查询D列的数据
df.pivot_table(values="D", index=["A", "B"], columns=["C"])
#%%
# 以C列分组，查看A列=one的值的平均
df[df["A"]=="one"].groupby("C").mean()
#%%
# pivot_table
# data数据集是火箭队当家球星James Harden某一赛季比赛数据作为数据集进行讲解
data = pd.read_csv("D:\Tools\PythonProject\MyTest\pandas_basic\James_Harden.csv")
data.head()
#%%
# 查看哈登对阵每个队伍的得分
data.pivot_table(index=["对手"])
#%%
# 查看哈登阵同一对手在不同主客场下的数据
data.pivot_table(index=["对手", "主客场"])
#%%
# 查看哈登在主客场和不同胜负情况下的得分、篮板与助攻三项数据
data.pivot_table(values=["得分", "篮板", "助攻"], index=["主客场", "胜负"])
#%%
# 查看哈登在主客场和不同胜负情况下的总得分、总篮板、总助攻
data.pivot_table(values=["得分", "篮板", "助攻"], index=["主客场", "胜负"], aggfunc=[np.mean,np.sum])
#%%
# fill_value填充空值
data.pivot_table(values="得分", index="主客场", columns="对手", aggfunc=[np.sum],fill_value="0")
#%%
# pd中的时间序列
# 创建600个以秒为单位的时间序列
rng = pd.date_range("20160301", periods=600, freq="s")
rng
#%%
# 创建一个值与时间序列对应
s = pd.Series(np.random.randint(0,500,len(rng)), index=rng)
s
#%%
# 通过resample对数据进行重新采样
# 2分钟，以求和的方式采样
s.resample("2Min").sum()
#%%
rng = pd.period_range("2000Q1","2016Q1", freq="Q")
rng
#%%
# 转化为日期格式
rng.to_timestamp()
#%%
# 计算日期之间相差的天数
pd.Timestamp("20160301") - pd.Timestamp("20160201")
#%%
# 计算日期+几天
pd.Timestamp("20160301") + pd.Timedelta(days=5)
#%%
df = pd.DataFrame({"id":[1,2,3,4,5,6], "raw_grade":["a","b","b","a","a","d"]})
df
#%%
# 通过category增加新的一列
df["grade"]=df.raw_grade.astype("category")
df
#%%
# grade的dtype: category
df.grade
#%%
# 给grade列重新赋值
df.grade.cat.categories = ["very good", "good", "bad"]
df
#%%
# 排序的时候是按raw_grade进行排序
df.sort_values(by="grade", ascending=False)
#%%
s = pd.Series(np.random.randn(1000), index=pd.date_range("20000101", periods=1000))
s
#%%
# 对数据累加值进行求和
s = s.cumsum
#%%
s.plot()

2.练习：moviesLens电影数据分析

#%%
import pandas as pd
import numpy as np
#%%
fpath = r"D:\WinterIsComing\python\New_Wave\pandas_basic\pandas-learn-code\datas\movielens-1m\users.dat"
users = pd.read_csv(fpath,
                 header=None,
                 engine="python",
                 sep="::",
                 names=["user_id", "gender", "age", "occupation", "zip"]
                 )
#%%
print(len(users))
users.head(5)
#%%
rating_names = ['user_id', 'movie_id', 'rating', 'timestamp']
fpath = r"D:\WinterIsComing\python\New_Wave\pandas_basic\pandas-learn-code\datas\movielens-1m\ratings.dat"
ratings = pd.read_table(fpath, sep='::', header=None, names=rating_names, engine='python')
#%%
movie_names = ['movie_id', 'title', 'genres']
fpath = r"D:\WinterIsComing\python\New_Wave\pandas_basic\pandas-learn-code\datas\movielens-1m\movies.dat"
movies = pd.read_table(fpath, sep='::', header=None, names=movie_names, engine='python')
#%%
print(len(ratings))
ratings.head(5)
#%%
print(len(movies))
movies.head(5)
#%%
# 合并数据
data = pd.merge(pd.merge(users,ratings),movies)
#%%
print(len(data))
data.head(10)
#%%
# 查看用户id为1的用户的相关数据
data[data.user_id==1]

#%%
# 计算每一部电影按照性别的平均得分
ratings_by_gender = data.pivot_table(values="rating", index="title", columns="gender", aggfunc=[np.mean])
ratings_by_gender.head(10)
#%%
data.user_id
#%%
print(type(ratings_by_gender),"\n",type(data))
#%%

3.pandas核心数据结构

#%%
import pandas as pd
import numpy as np
#%%
s1 = pd.Series(np.random.randn(3), index=["a", "c", "e"])
s2 = pd.Series(np.random.randn(3), index=["a", "d", "e"])
print(f'{s1}\n\n{s2}')
#%%
# 自动标签对齐属性，由于仅有a与e相互对应，所以a与e的值相加，c与d的值为空值
s1 + s2
#%%
# 通过字典创建DataFrame，该字典是由Series组成，Series中元素个数可以是不相同的
# 一个是1，2，3，一个是1，2，3，4
df = pd.DataFrame({
    "one": pd.Series([1,2,3], index=["a", "b", "c"]),
    "two": pd.Series([1,2,3,4], index=["a", "b", "c", "d"])
})
df
#%%
c = {
    "one": pd.Series([1,2,3], index=["a", "b", "c"]),
    "two": pd.Series([1,2,3,4], index=["a", "b", "c", "d"])
}
df = pd.DataFrame(c, index=["d", "b", "a"])
df
#%%
# 指定列索引
df = pd.DataFrame(c, columns=["two", "three"])
df
#%%
# 如果是由list构成的字典数据，列表中的元素个数必须一致
d = {"one": [1,2,3,4],
     "two": [21,22,23,24]}
df = pd.DataFrame(d)
df
#%%
# 通过列表创建DataFrame
data = [(1,2.2,"Hello"), (2,3.,"world")]
df = pd.DataFrame(data, index=["one", "two"], columns=list("ABC"))
df
#%%
df = pd.DataFrame(np.random.randn(6,4), columns=['one', 'two', 'three', 'four'])
df
#%%
df["three"] = df["one"] + df["two"]
df
#%%
# 删除three列
del df["three"]
df
#%%
# 增加新的一列
df["flag"] = df["one"] > 0.2
df
#%%
df["five"] = 5
df
#%%
s = df.pop('four')
s
#%%
df
#%%
# insert 指定位置插入数据，制作对原df进行修改
df.insert(1,'bar', df['one'] + df['two'])
df
#%%
# assign做的是复制，不对原df进行修改
df.assign(Ratio = df["one"]/ df["two"])
#%%
# assign可以直接传入一个函数
df.assign(Ratio = lambda x: x.one - x.two)
#%%
# 调用两次assign创建一个新的DataFrame
df.assign(ABRatio = df.one / df.two).assign(BarValue = lambda x: x.ABRatio * x.bar)
#%%
data = {"Item1": pd.DataFrame(np.random.randn(4,3)),
        "Item2": pd.DataFrame(np.random.randn(4,2))}
print(pd.Panel(data))

4.pandas基础运算

#%%
import pandas as pd
import numpy as np
#%%
s = pd.Series([1,3,5,6,8], index=list("acefh"))
s
#%%
s.index
#%%
s = s.reindex(list("abcdefgh"))
s
#%%
# 为空值填充数据
s.fillna(0, inplace=True)
s
#%%
# 为空值填充数据
s.reindex(list("abcdefghijk"), fill_value=10)
#%%
s = pd.Series([1,3,5,7,9], index=list("acegi"))
s
#%%
s.reindex(list("abcdefghi"))
#%%
# 为空值填充上一个非空值的数据,method仅对行数据有效
s.reindex(list("abcdefghi"),method="ffill")
#%%
# 创建一个DataFrame
df = pd.DataFrame(np.random.randn(4,6), index=["A","D", "F", "H"], columns=["one", "two", "three", "four", "five", "six"])
df
# 重新添加行索引
df2 = df.reindex(index=list("ABCDEFGH"))
df2
#%%
df2.fillna(0, inplace=True)
df2
#%%
df.reindex(columns=["one", "three", "five", "seven"])
#%%
df.reindex(columns=["one", "three", "five", "seven"], fill_value=0)
#%%
# 再次强调method只能作用于行,bfill从后面的非空数据取值填充
df.reindex(index=list("ABCDEFGH"), method="bfill")
#%%
# drop删除行列：不对原df进行修改
df.drop("A")
#%%
df.drop(["two", "four"], axis=1)
df
#%%
# apply于applymap:把一个二维数组按行或者按列进行运算
df = pd.DataFrame(np.arange(12).reshape(4,3), index=["one", "two", "three", "four"], columns=list("ABC"))
df
#%%
# x是默认按列进行运算
df.apply(lambda x: x.max() - x.min())
# axis=1,表示按列进行运算
df.apply(lambda x: x.max() - x.min(),axis=1)
#%%
# 查看apply官方文档
df.apply?
#%%
def min_max(x):
    return pd.Series([x.min(), x.max()], index=["min", "max"])
df.apply(min_max, axis=1)
#%%
# applymap:把DataFrame里面的每个元素作为一个参数，传递给处理函数
df = pd.DataFrame(np.random.randn(4,3), index=["one", "two", "three", "four"], columns=list("ABC"))
df
#%%
# 将表格内所有元素的小数点只保留后三位
formater = lambda x: round(x,3)
df.apply(formater)
#%%
# 排序
df = pd.DataFrame(np.random.randn(4,3), index=list("ABCD"), columns=["one", "two", "three"])
df.sort_values(by="one",ascending=False)
#%%
# 排名
s = pd.Series([3,6,2,6,4])
s
#%%
s.rank(method="first")
#%%
s.rank(method="average")
#%%
df.rank(method="first")
#%%
# 唯一性
s = pd.Series(list("abbcdabacad"))
s
#%%
s.value_counts()
#%%
# 返回数据中不重复的值
s.unique()
#%%
s.isin(['a', "c", "d"])