from pandas import Series
ser1 = Series([1,2,3,4]) # 直接用 list 生成，index 默认从 0 开始
​
ser1 = Series([1,2,3,4], index=[0,1,2,3]) # 指定 index，values 值不支持 关键字参数
​
sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000} # 用字典生成，key 作为 index，value 作为 value，采用此种生成方式，比较耗费内存
ser3 = Series(sdata)

series_demo[0]
series["name"]
​
# DataFrame Demo
for index, row in pd_data.iterrows():
    print row[0] # 按照位置查找
    print row["name"] # 按照标签查找
​
# 对 Series 的 index 重新赋值
pd_series.index = ["1","2", "3", "4"]

pd_demo = pd.Series([1,2,3,4,5,5,2,3])
pd_demo.value_counts() # 返回一个 pandas.Series 对象，index为value 集合，value 为每一个index的频数，按照降序排列

# 计算分位数
pd_series.quantile(0.5) # 将 pd_series 中的数先排序，然后获取 0.9 分位的数

# unique 方法，获取去重后的值，其功能等价于 set()
pd_series = pd_series.unique()

import pandas as pd
​
# 第一种：dict in list
my_list = [{"name1":"wanshuo","age":"11"}, {"name1":"wangyanan","age":"13"}]
pd_data = pd.DataFrame(my_list) # 传入一个 list 
​
# 第二种：tuple in list + column
my_list = [("wansho", 11), ("wandongxin", 12)]
pd_data = pd.DataFrame(my_list, columns=["name", "age"])
​
# 第三种：dict
data = {'name' : ['万朔', '王雅楠'], 'age' : [12,13]}
pd_data = pd.DataFrame(data)
​
# 第四种：传入一个 DataFrame
pd.DataFrame(dataframe)
​
# 构建空的 DataFrame，但是有 columns，有 index
pd_result = pd.DataFrame(index=["index1", "index2"], columns=["timelist", "type", "name", "refer"]) # pd_result 仍然是空的 pd_result.empty

# empty 判空
pandas_data = pd.DataFrame()
if pandas_data.empty:
    continue

# replace 替换方法
pd_data.replace([100, 101], 1) # 把所有的 100 和 101 替换成 1
pd_data.replace([100, 101], [1, 2]) # 把 100 替换成 1，101 替换成 2

pd_hour_statistics.loc[run_id_period, cid] += 1 # loc 的第一个值为 index，第二个值就是 column 的名字

# 遍历 DataFrame 每行
for index, row in pandas_data_deployed.iterrows():
    deploy_plat = row['deploy_plat'] # 直接传入
    source = row['source']
    module = row['module']
​
# 上面的代码可以用这个代替
data['rows'] = pandas_data.T.to_dict().values()

# 纵向的连接，相当于给表中加入更多的元组
pd_deployed = [pd_863, pd_noah, pd_beehive, pd_dfp]
pd_deployed = pd.concat(pd_deployed).fillna("") # 连接并且填充空值为 ""
​
# 横线连接
pd.concat([pd1, pd2], axis=1)

subset: 
    column label or sequence of labels, optional 
    用来指定特定的列，默认所有列
keep: 
    {‘first’, ‘last’, False}, default ‘first’ 
    删除重复项并保留第一次出现的项
inplace: 
    boolean, default False 
    是直接在原来数据上修改还是保留一个副本

DataFrame.drop_duplicates(["", "", ""], keep='first', inplace=True) # 对 DataFrame 格式的数据，去除特定列的重复行，重复数据保留第一次出现的数据，就地去重
​
import pandas as pd
data = pd.DataFrame({'A' : [1,2,3,4], 'B' : ['a', 'b', 'a', 'b']}) 
data.drop_duplicates('B',  keep='first', inplace = True)
"""
print data
结果
 A B
 0 1 a
 1 2 b
"""

# 设置 index 或 columns 的 name
frame.index.name = xxx # 可以在 reset_index 的时候用到，给 index 起一个名字，然后就可以把 index 变成一个 column
frame.columns.name = yyy

frame.reindex(columns = [...], index=[...])
# 如果没有指定 index 和 column，那么默认修改 index
frame.reindex(['a', 'b', 'c'], fill_value=0) # 如果 'c' 无对应的值，则为 Nan

index_list = pd_data.index.tolist()
column_list = pd_data.column.tolist()

# 修改 column
pd_whitelist = pd_whitelist.rename(columns = {"deploy_module": "module", "monitor_whitelist": "idc" }, inplace=True)

pd_data = pd_data.reset_index().drop("index", axis=1) # index 为 index name
​
# reset_index() 用于将 index 转成 column，然后 index 重新设置为 0,1,2,3

# 将某几列转成行索引
pd_frame = pd_frame.set_index(["column1", "column2"])

# 获取字段对应的列的所有值，转成 list
name = pd_data['姓名'] # 这里返回了 姓名 的Series
name = pd_data.姓名.tolist()
name_list = pd_data['姓名'].tolist()

pd_size = len(pd_data)

pandas_data = pandas_data.sort_values(by = ["created_time", "age"], ascending = [False,True], axis=1)

# 添加 行，
pd_result = pd.concat([pd_result, pd_new_data], ignore_index=True, axis=1)
​
# 添加列
pd_result = pd.concat([pd_result, pd_new_data], ignore_index=True, axis=1)

# append 只能用来添加元组，并返回一个新的对象
pd_vote_tor_train.append(pd_vote_for_test, ignore_index=True)

# 删除两列
pd_data = pd_data.drop(["vote_result", "score"], axis=1)
​
# 删除行数据，
frame.drop([index1, index2]) # 默认 drop 删除行数据 axis = 0 就是行

# 矩阵和图标的转置
pd_demo = pd_demo.T

# isnull, notnull 检测缺失值
pd.isnull(obj)
pd.notnull(obj)

# 引入 numpy 的科学计算函数
import numpy as np
np.log2(pd_data)
np.log10(pd_data)
np.exp(pd_data)
​
# 求最大值最小值
pd_demo.max()
# 如果 pd_demo 是 DataFrame，则默认对列进行操作，获取每列的最大值，形成一个 series
# 如果 pd_demo 是 Series，则返回最大值
​
# Series 可以直接进行算术运算
(pd_statistics_daycount * pd_sum_statistics).sort_values(ascending=False)
# Series 在进行算术运算时可以自动对齐不同索引的数据，而笛卡尔积式的索引
​
# apply
pd_data["meddle_time"] = (pd_data["meddle_end"].apply(
            lambda x: datetime.datetime.strptime(str(x), "%Y-%m-%d %H:%M:%S")) - \
                            pd_data["meddle_start"].apply(
            lambda x: datetime.datetime.strptime(str(x), "%Y-%m-%d %H:%M:%S")))

pd_frame["animal"] = data["food"].map(str.lower).map(food_to_animal_dict)

# 对 Series 进行排序
pd_statistics_daycount = pd.Series(statistics_daycount_dict).sort_values(ascending=False) # 按值进行排序
pd_statistics_daycount = pd.Series(statistics_daycount_dict).sort_index(ascending=False) # 按索引进行排序

append 连接另一个index对象，返回一个新的index
​
diff 计算差集
intersection 计算交集
union 计算并集

pd_demo_copy= pd.DataFrame(pd_demo) # pd_demo_copy 其实是 pd_demo 的一个浅拷贝，对 pd_demo_copy 的任何操作，当相当于直接对 pd_demo_copy 进行操作
pd_demo_copy = pd_demo.copy(deep=True) # 这才是深拷贝

obj.index # 返回 RangeIndex类型的可迭代的对象
obj.values # 返回 numpy.ndarray 类型的可迭代的对象

rename
drop_duplicates

df_one_column = df_one_column.drop_duplicates("weibo")
# 改成
df_one_column.drop_duplicates("weibo", inplace=True) # 返回 None

# 添加新列
pd_data["flag"] = "defaut_value"
df.two = [4, 5, 6] # 会报 UserWarning

df1[lambda df: df.columns[0]] # 选取第一列

df[:3] # 对前三行进行 slice
df[::-1] # 按行逆置

# 对 Series 进行切片
s1 = pd.Series(np.random.randn(6), index=list('abcdef'))
"""
a    1.431256
b    1.340309
c   -1.170299
d   -0.226169
e    0.410835
f    0.813850
dtype: float64
"""
s1.loc['c':] # 从 c slice 到最后
s1.loc['b'] # 获取 index 为 b 对应的值
s1.loc['c':] = 0 # slice 后统一赋值
​
# slice slice 是对 3 到 5 之间的元素进行 slice，并不是 对 3，4，5进行 slice，slice 是按照 index 顺序的
s = pd.Series(list('abcde'), index=[0, 3, 2, 5, 4])
s.loc[3:5] # 3,2,5
s.sort_index() # 对数据按照 index 进行排序

df1 = pd.DataFrame(np.random.randn(6, 4),
                     index=list('abcdef'),
                     columns=list('ABCD'))
df1.loc[['a', 'b', 'd'], :] # sample index 为 a,b,d 的 dataframe
df1.loc['d':, 'A':'C'] # sample index 为 d, column 为 ABC 的 dataframe
df1.loc['a'] # sample index 为 a 的 series
df1.loc['a', 'A'] # get a value in df1["a"]["A"]
​
dfi.loc[:, 'C'] = dfi.loc[:, 'A'] # 新建 C 列，并将 A 列的数据赋值给 C 列

s1 = pd.Series(np.random.randn(5), index=list(range(0, 10, 2)))
s1.iloc[:3] # 获取前三个数据
s1.iloc[3] # 获取第四个数据
s1.iloc[:3] = 0 # 对前三个数据进行赋值

df1 = pd.DataFrame(np.random.randn(6, 4),
                       index=list(range(0, 12, 2)),
                       columns=list(range(0, 8, 2)))
df1.iloc[:3] # 获取前三行的 df
df1.iloc[1:5, 2:4] # 获取第二行到第五行，第三列到第四列的 df
df1.iloc[[1, 3, 5], [1, 3]] # 获取第 2，4，6 行，第2，4列的 df
df1.iloc[1:3, :]
df1.iloc[1] # 获取第二行的 series
​
# assign a dict to a row of a DataFrame
x = pd.DataFrame({'x': [1, 2, 3], 'y': [3, 4, 5]})
x.iloc[1] = {'x': 9, 'y': 99}

df1 = pd.DataFrame(np.random.randn(6, 4),
                       index=list('abcdef'),
                       columns=list('ABCD'))
"""
     A         B         C         D
a -0.023688  2.410179  1.450520  0.206053
b -0.251905 -2.213588  1.063327  1.266143
c  0.299368 -0.863838  0.408204 -1.048089
d -0.025747 -0.988387  0.094055  1.262731
e  1.289997  0.082423 -0.055758  0.536580
f -0.489682  0.369374 -0.034571 -2.484478
"""
df1.loc[lambda df: df.A > 0, :] # 对 row 进行 select，条件为 列 A 的值 > 0
"""
     A         B         C         D
c  0.299368 -0.863838  0.408204 -1.048089
e  1.289997  0.082423 -0.055758  0.536580
"""
df1.loc[:, lambda df: ['A', 'B']] # 选取 A，B 列
df1.iloc[:, lambda df: [0, 1]] # 选取第一列和第二列
df1[lambda df: df.columns[0]] # 选取第一列
df1.A.loc[lambda s: s > 0] # 选取第一列中大于0的元素
​
# 两列进行比较
pd_candidate[pd_candidate.label != pd_candidate.predicted_label]

df_sample = df1.sample(n=5) # 随机采样 5 个元素
df.head(n=10) # 选取头几个元素

df1 = pd.DataFrame({'A':list("avb")})
df1.iat[0,0] # 返回 a
df1.iat[0,0] = "s" # 赋值

# series
s = pd.Series(range(-3, 4))
s[s > 0] # 返回大于 0 的 series
s[(s < -1) | (s > 0.5)] # 返回一定范围的 series
​
# dataframe
df[df['A'] > 0] 
df2 = pd.DataFrame({'a': ['one', 'one', 'two', 'three', 'two', 'one', 'six'],
                       'b': ['x', 'y', 'y', 'x', 'y', 'x', 'x'],
                       'c': np.random.randn(7)})
criterion = df2['a'].map(lambda x: x.startswith('t'))
df2[criterion]
"""
       a  b         c
2    two  y  0.041290
3  three  x  0.361719
4    two  y -0.238075
"""
df2[criterion & (df2['b'] == 'x')] # 多个条件
"""
     a        b       c
3  three  x  0.361719
"""
df2.loc[criterion & (df2['b'] == 'x'), 'b':'c'] # 多多个条件
"""
     b         c
3  x  0.361719
"""
​
pandas_selected = pandas_data[(pandas_data.status == 'fail') \
                            & ((pandas_data.reason == 'online') \
                               | (pandas_data.reason == 'known_online') \
                               | (pandas_data.reason == 'deploy')
                              )]
​
# 否定的使用
pandas_selected = pandas_data[~(pandas_data.status == 'fail')]

s = pd.Series(np.arange(5), index=np.arange(5)[::-1], dtype='int64')
s.isin([2, 4, 6])
"""
4    False
3    False
2     True
1    False
0     True
dtype: bool
"""
s[s.isin([2, 4, 6])]
"""
2    2
0    4
dtype: int64
"""
s[s.index.isin([2, 4, 6])] # 判断 index isin
​
# df
pd_vote_for_test = pd_training_data[pd_training_data.hash_id.isin(test_hash_id)]
​
# not in 
pd_vote_for_test = pd_training_data[~(pd_training_data.hash_id.isin(test_hash_id))]

s.where(s > 0)
"""
4    NaN
3    1.0
2    2.0
1    3.0
0    4.0
dtype: float64
"""

df[(df.a < df.b) & (df.b < df.c)] # 等价于
df.query('(a < b) & (b < c)') # 等价于
df.query('a < b & b < c') # 等价于
df.query('a < b and b < c')
​
df.query('a in b') # 等价于
df[df.a.isin(df.b)]
​
df.query('a not in b') # 等价于
df[~df.a.isin(df.b)] 
​
df.query('a in b and c < d')
​
df.query('b == ["a", "b", "c"]') # simlilar to in ，等价于
df[df.b.isin(["a", "b", "c"])]
​
df.query('[1, 2] in c')
df.query('[1, 2] not in c')

dfmi = pd.DataFrame([list('abcd'),
                      list('efgh'),
                      list('ijkl'),
                      list('mnop')],
                      columns=pd.MultiIndex.from_product([['one', 'two'],
                                                        ['first', 'second']]))
"""
    one          two       
  first second first second
0     a      b     c      d
1     e      f     g      h
2     i      j     k      l
3     m      n     o      p
"""
​
dfmi.loc[:, ('one', 'second')] = value 
# 等价于
dfmi.loc.__setitem__((slice(None), ('one', 'second')), value) # 一步到位
​
dfmi['one']['second'] = value 
# 等价于
dfmi.__getitem__('one').__setitem__('second', value) # 由于不确定 getitem 返回的对象是原对象还是新 copy 的对象，所以才会抛出 SettingWithCopy 的警告