<jupyter_start><jupyter_text>1.创建对象 `np.nan 是非数字`  `这里通过传递一个list对象类创建一个Series，同时pandas默认创建整型索引`<jupyter_code>s = pd.Series([1, 3, 5, np.nan, 6, 8])
s<jupyter_output><empty_output><jupyter_text>`显示Series的形状`<jupyter_code>s.shape
# 创建一个DataFrame 创建一个以时间序列为类型的索引对象
dates = pd.date_range('20130101', periods=6)
print(type(dates))
dates<jupyter_output><class 'pandas.core.indexes.datetimes.DatetimeIndex'><jupyter_text>`定义一个DataFrame 参数为：二维对象/日期索引/列名称`<jupyter_code>lis = np.random.randn(6, 4)
print(lis)
print(type(lis))
df = pd.DataFrame(lis, index=dates, columns=list('ABCD'))
# 定义DataFrame时，使用index给行索引赋值，columns给列索引赋值
df
print('---Timestamp对象---')
b = pd.Timestamp('20130102')
print(b)
print(type(b))
print('-' * 20)
# this 1 -> [1, 1, 1, 1]
print('---Series对象 dtype指定类型---')
c = pd.Series(1, index=list(range(4)), dtype='float32')
print(c)
print(type(c))
print('-' * 20)
# [3]*4 -> [3, 3, 3, 3]
print('---ndarray类型---')
d = np.array([3]*4, dtype='int32')
print(d)
print(type(d))
print('-' * 20)
print('---Categorical类型---')
e = pd.Categorical(['test', 'train', 'test', 'train'])
print(e)
print(type(e))
print('-' * 20)
# 给 DataFrame 列的值可以为 list，Timestamp，Series，ndarray，Categorical 类型
dic = {  # 字典key为列名称，value为列元素(内容)
    'A': 1.,   # 默认表示为一维矩阵
    'B': b,    # Timestamp可以表示为一维矩阵
    'C': c,    # 使用Series作为列元素
    'D': d,    # 使用ndarray作为列元素
    'E': e,    # Categorical序列作为列元素
    'F': 'foo' # 字符串默认表示为列元素
}
df2 = pd.DataFrame(dic)
print(df2)
# 查看每一列的数据类型
df2.dtypes
df<jupyter_output><empty_output><jupyter_text>2.查看数据<jupyter_code># 查看头部指定几行数据（不填参数默认为5行）
df.head(2)
# 查看尾部指定几行数据（不填参数默认为5行）
df.tail(3)
# 查看DataFrame索引对象，类型为 datetime64
df.index
# 查看列信息
df.columns
# 查看快速统计
df.describe()
# 转置
df.T
# 对轴进行排序 axis 影响列索引 ascending 影响行索引 正序倒序
df.sort_index(axis=1, ascending=False)
# 按值进行排序
df.sort_values(by=['B'])<jupyter_output><empty_output><jupyter_text>3.选择<jupyter_code># 选中单独的列
df['A']
# 通过[]进行选择，会对行进行切片
df[0:3]
df['20130102':'20130104']
df
# 获得日期第一行
df.loc[dates[0]]
# loc通过标签进行选择
# 先选择所有行，再选择指定列
df.loc[:,['A','B']]
# 选择指定行和列的交叉区域
df.loc['20130102':'20130105', ['A','B']]
# 选择指定列的指定行的数据 维度缩减
df.loc['20130102',['A','B']]
# 获得一个标量
df.loc[dates[0], 'A']
# 快速访问一个标量
df.at[dates[0], 'A']
a = df.loc['20130102':'20130105', ['A','B']]
print("-->df.loc['20130102':'20130105', ['A','B']]")
print(type(a), "\n")

b = df.loc['20130102',['A','B']]
print("-->df.loc['20130102',['A','B']]")
print(type(b), "\n")

c = df.loc[dates[0], 'A']
print("-->df.loc[dates[0], 'A']")
print(type(c), "\n")
# 选择一行
df.iloc[3]
# 先选行，再选列 类似切片
df.iloc[3:5, 0:2]
# 通过一个二维数组切片
df.iloc[[1,2,4],[0,2]]
df.iloc[1:3, :]
df.iloc[:, 1:3]
# 获取特定的值
df.iloc[1, 1]
# 获取特定的值
df.iat[1, 2]<jupyter_output><empty_output><jupyter_text>布尔索引<jupyter_code># 选择符合条件的行出来 这里是选择列A的值大于0的行
df[df.A>0]
newdf = df[df>0]
print(type(newdf))
print(newdf)
df3 = df.copy()
# 设置了一个新的列
df3['E'] = ['o','o','t','t','p','t']
df3
# isin方法过滤 很好用
df3[df3['E'].isin(['t','f'])]<jupyter_output><empty_output><jupyter_text>设置<jupyter_code>s1 = pd.Series([1,2,3,4,5,6], index=pd.date_range('20130102', periods=6))
s1
df['F'] = s1
df
# 通过标签设置新的值
df.at[dates[0], 'A'] = 0
df
# 通过位置设置新的值
df.iat[0, 0] = 10
# 长度是指行数
print(len(df))
print(df)
# 设置一列的数据
df.loc[:, 'D'] = np.array([5]*len(df))
df
df3
df4 = df.copy()
# 大于0的部分都设置为负数
df4[df4>0] = -df4
df4<jupyter_output><empty_output><jupyter_text>缺失值处理<jupyter_code>df
#  reindex()方法可以对指定轴上的索引进行改变/增加/删除操作，这将返回原始数据的一个拷贝
df1 = df.reindex(index=dates[0:4], columns=list(df.columns) + ['E'])
df1
df1.loc[dates[0]:dates[1], 'E'] = 1
df1
# 去掉包含缺失值的行
df1.dropna(how="any")
# 对缺失值进行填充
df1.fillna(value=100000)
# 对数据进行布尔填充 nan都将变为True，其余的变为True
pd.isnull(df1)<jupyter_output><empty_output><jupyter_text>相关操作<jupyter_code>df
# 平均值
df.mean()
# 在其他轴上进行相同的操作
df.mean(1)
dates
s = pd.Series([1,3,4,np.nan,6,8], index=dates).shift(2)  # 向下偏移，空值补充nan
s
df
df.sub(s, axis='index')  # df的每一列都整体去跟s相减
df.apply(np.cumsum)
df.apply(lambda x: x.max()-x.min())
# 直方图
s = pd.Series(np.random.randint(0,7,size=10))
s
s.value_counts()
s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'])
s
s.str.lower()  # upper len
s.str.len()<jupyter_output><empty_output><jupyter_text>6.合并Pandas提供了大量的方法能够轻松的对Series，DataFrame和Panel对象进行各种符合各种逻辑关系的合并操作。<jupyter_code>df = pd.DataFrame(np.random.randn(10, 4))
df
pieces = [df[:3], df[3:7], df[7:]]
pieces
# 合并
pd.concat(pieces)
left = pd.DataFrame({'key': ['a','a'], 'lval': [1, 2]})
left
right = pd.DataFrame({'key': ['a','a'], 'lval': [4, 5]})
right
pd.merge(left, right, on="key")
df5 = pd.DataFrame(np.random.randn(8, 4), columns=['A','B','C','D'])
df5
s = df5.iloc[3]
s
df5.append(s, ignore_index=True)  # ignore_index=False时会将这行之前的Name附带到DataFrame里面<jupyter_output><empty_output><jupyter_text>7.分组对于”group by”操作，我们通常是指以下一个或多个操作步骤：- （Splitting）按照一些规则将数据分为不同的组；- （Applying）对于每组数据分别执行一个函数；- （Combining）将结果组合到一个数据结构中；<jupyter_code>df = pd.DataFrame({
                   'A' : ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
                   'B' : ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
                   'C' : np.random.randn(8),
                   'D' : np.random.randn(8)
})
df
# 把A列的字段聚合
df.groupby('A').sum()
df.groupby(['A','B']).sum()<jupyter_output><empty_output><jupyter_text>8.Reshaping<jupyter_code>arrays = [['bar', 'bar', 'baz', 'baz', 'foo', 'foo', 'qux', 'qux'],
           ['one', 'two', 'one', 'two', 'one', 'two', 'one', 'two']]
tuples = list(zip(*arrays))
tuples
# 多行索引
index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])
index
# 两个行索引以及行索引的名称
df6 = pd.DataFrame(np.random.randn(8, 2), index=index, columns=['A', 'B'])
df6
stacked = df6.stack()
stacked
# 多个行索引的Series
print(type(stacked))
print(stacked.shape)
print(stacked.dtypes)
# 多个行索引的Series解压为DataFrame
stacked.unstack()
dfstack = stacked.unstack(1)
dfstack
# 在不同的方向解包
stacked.unstack(0)
import datetime
dfpivot = pd.DataFrame({'A': ['one', 'one', 'two', 'three'] * 6,
                  'B': ['x', 'y', 'z'] * 8,
                  'C': ['foo', 'foo', 'foo', 'bar', 'bar', 'bar'] * 4,
                  'D': np.random.randn(24),
                  'E': np.random.randn(24),
                  'F': [datetime.datetime(2013, i, 1) for i in range(1, 13)] +
                     [datetime.datetime(2013, i, 15) for i in range(1, 13)]})
dfpivot
# 数据透视图
pd.pivot_table(dfpivot, values='D', index=['A', 'B'], columns=['C'])
rng = pd.date_range('1/1/2012', periods=120, freq='S')  # 生成时间索引序列，以每秒为单位，共100个时间点
ts = pd.Series(np.random.randint(0, 500, len(rng)), index=rng)
ts
ts.resample('1Min').sum()
rng = pd.date_range('3/6/2012 00:00', periods=5, freq='D')
rng
ts = pd.Series(np.random.randn(len(rng)), index=rng)
ts
ts_utc = ts.tz_localize('UTC')
ts_utc
ts_utc.tz_convert('Asia/Shanghai')
rng = pd.date_range('1/10/2012', periods=5, freq='M')
rng
ts = pd.Series(np.random.randn(len(rng)), index=rng)
ts
ps = ts.to_period()
ps
ps.to_timestamp()
prng = pd.period_range('1990Q1', '2000Q4', freq='Q-NOV')
prng
ts = pd.Series(np.random.randn(len(prng)), prng)
ts
ts.index = (prng.asfreq('M', 'e') + 1).asfreq('H', 's') + 9
ts<jupyter_output><empty_output><jupyter_text>10.Categorical<jupyter_code>df = pd.DataFrame({"id": [1,2,3,4,5,6], "raw_grade": ['a', 'f', 'g', 'g', 'f', 'a']})
df
df['raw_grade']
# raw_grade列的object类型转为category类型
df['grade'] = df['raw_grade'].astype("category")
df['grade']
df
# 显示grade categories的详细信息
a = df["grade"].cat.categories
print(a)
print(type(a))
# grade categories的详细信息 赋值 ['a', 'f', 'g'] -> [very good, good, very bad]
df["grade"].cat.categories = ["very good", "good", "very bad"]
df["grade"]
df["grade"].cat.categories
# 增加两个类别（补缺）
df["grade"] = df["grade"].cat.set_categories(["very bad","bad","medium","good","very good"])
df["grade"].cat.categories
df["grade"]
# 按照类别排序 可以根据抽象的好坏来排序
df.sort_values("grade")
# 存在空的类别会显示0
df.groupby("grade").size()
# 使用Series作图，Series的索引是时间类型
ts = pd.Series(np.random.randn(10), index=pd.date_range('1/1/2000', periods=10))
ts
# 累加
sts = ts.cumsum()
sts
import matplotlib.pyplot as plt
sts.plot()
plt.show()
df = pd.DataFrame(np.random.randn(10, 4), index=pd.date_range('20120101',periods=10), columns=['A','B','C','D'])
df
# 使用DataFrame作图，DataFrame的索引是时间类型
plt.figure()
df.plot()
plt.legend(loc="best")
plt.show()
# df.to_csv('xxx')  写入csv文件
# pd.read_hdf('foo.h5', 'df')  从HDF5中读取
# pd.to_excel('foo.xlsx', sheet_name=''Sheet)  写入Excel文件
# pd.read_excel('foo.xlsx', 'Sheet1', index_col=None, na_values=['NA'])  从Excel读
df = pd.read_csv("/home/nick/Desktop/DA/speedFile/count.csv", index_col=None, names=["total"], 
                 parse_dates=True, dtype={"total": np.int64}, encoding="utf-8")
increment = df['total'].diff()
# 按照原始数据显示
df.plot()
plt.show()
# 降低采样频率 显示总数
a = df.loc[:"2018-01-12 00:00:00"]
a = a.resample('60Min').mean()
a.plot()
plt.show()
# 降低采样频率 显示采集速度
s = pd.Series(increment, index=df.index, name='total')
sa = s.loc[:"2018-01-12 00:00:00"]
sa = sa.resample('1H').sum()
sa.plot()
plt.show()
# 降低采样频率 显示每天抓取的量
b = df.loc["2018-01-02 00:00:00":"2018-01-12 00:00:00"]
b = b.resample('24H').mean()
di = b['total'].diff()
dif = pd.Series(di, index=b.index, dtype=np.int64).iloc[1:]
dif = dif.resample('1D').mean()
dif.plot(kind='bar')
plt.show()
# 降低采样频率 显示每天抓取的量
b = df.loc["2018-01-02 00:00:00":"2018-01-12 00:00:00"]
b = b.resample('24H').mean()
di = b['total'].diff()
dif = pd.Series(di, index=b.index, dtype=np.int64).iloc[1:]
dif = dif.resample('1D').mean()
dif.plot(kind='bar')
plt.show()
# 降低采样频率 显示采集速度的集中频率
# s = pd.DataFrame({'crawlSpeed': increment}, index=df.index)
s = pd.DataFrame(increment, index=df.index, columns=['total'])
sa = s.loc[:"2018-01-12 00:00:00"]
sa.plot.hist(alpha=0.5, bins=100, stacked=True)
plt.show()
# 箱体图
color = dict(boxes='DarkGreen', whiskers='DarkOrange', medians='DarkBlue', caps='Gray')
s = pd.DataFrame(increment, index=df.index, columns=['total'])
sa = s.loc[:"2018-01-12 00:00:00"]
sa.plot.box(color=color, sym='r+')
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.23032745591939546, 'fraction_numerical': 0.05239294710327456, 'mean_word_length': 5.635026737967914, 'pattern_counts': {'":': 5, '<': 53, '<?xml version=': 0, '>': 62, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '13', 'dir': 'jupyter-structured-clean-dedup', 'id': '408518', 'license': 'MIT', 'n_tokens_mistral': 5321, 'n_tokens_neox': 5255, 'n_words': 709, 'path': 'KnowledgeMapping/MatplotlibExp/1-code/studyMix/tenMinutesToPandas.ipynb', 'repo_name': 'nickliqian/ralph_doc_to_chinese', 'size': '9925'}