(2) python--pandas

import pandas as pd
import numpy as np

# 创建的Series几种方式
s1 = pd.Series(range(4))
s2 = pd.Series([0, 1, 2, 3])
s3 = pd.Series(np.arange(4))
print(s1)
'''
0    0
1    1
2    2
3    3
dtype: int64
'''
print(s2)
'''
0    0
1    1
2    2
3    3
dtype: int64
'''
print(s3)
'''
0    0
1    1
2    2
3    3
dtype: int32
'''

# 之前在numpy中说过Series相当于给array加上了index。如果不定义index那么默认为0,1,2····
s4 = pd.Series(["satori", "mashiro", "nagisa", "sora"], index=["东方地灵殿", "樱花庄的宠物女孩", "clannad", "缘之空"])
print(s4)
'''
东方地灵殿        satori
樱花庄的宠物女孩    mashiro
clannad      nagisa
缘之空            sora
dtype: object
'''
# 并且索引还可以重复
s5 = pd.Series(["satori", "tomoyo", "mashiro", "nagisa", "sora"], index=["东方地灵殿", "clannad", "樱花庄的宠物女孩", "clannad", "缘之空"])
print(s5)
'''
东方地灵殿        satori
clannad      tomoyo
樱花庄的宠物女孩    mashiro
clannad      nagisa
缘之空            sora
dtype: object
'''
print(s5["clannad"])
'''
clannad    tomoyo
clannad    nagisa
dtype: object
'''

# 即便定义了index仍然可以通过索引来获取
print(s5[0])  # satori
print(s5[1])  # tomoyo
print(s5[2])  # mashiro
print(s5[3])  # nagisa
print(s5[4])  # sora

　　

import pandas as pd
import numpy as np

# DataFrame相当于二维的Series,行索引为0,1,2····，列索引如果不指定也为0,1,2····
df = pd.DataFrame(np.arange(12).reshape(3, 4))
print(df)
'''
   0  1   2   3
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
'''
# head,接收一个整型,表示打印前多少行的数据
# tail,接收一个整型,表示打印后多少行的数据
print(df.head(2))
'''
   0  1  2  3
0  0  1  2  3
1  4  5  6  7
'''
print(df.tail(2))
'''
   0  1   2   3
1  4  5   6   7
2  8  9  10  11
'''

# -------------------------------
df = pd.DataFrame(np.arange(12).reshape(3, 4), columns=["A", "B", "C", "D"])
print(df)
'''
   A  B   C   D
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
'''

# 通过索引或者切片获取元素
# 如果直接使用df的话，那么不能通过df[,]的方式，只能df[][]，df[]找到对应的列(注意是列)，df[][]再找到当前列的某个值
print(df["A"][1])  # 4
# 如果我一定要通过df[,]的方式呢？
# 有以下几种方式
# iloc，一定要传入索引。行就不必说了，列虽然我们指定了名字，但仍然可以通过索引来传值。A的索引是0，B的索引是1·····，当然这里还是按照行和列的顺序的
print(df.iloc[0, 1])  # 1
# iloc是通过索引传的，如果我想用值传呢？使用loc，而且loc只能传值。行的索引和值都相同，但列必须穿指定的index
print(df.loc[0, "B"])  # 1
# at，同样需要传入值
print(df.at[0, "B"])  # 1
# ix,既可以传值，又可以传索引。但是貌似要被移除了，提示使用iloc或者loc。
print(df.ix[0, "B"], df.ix[0, 1])  # 1 1

# 数据的形状
print(df.shape)  # (3, 4)

# 数据的类型
print(df.dtypes)
'''
A    int32
B    int32
C    int32
D    int32
dtype: object
'''

# 数组的维度
print(df.ndim)  # 2,表明两行四列，维度是2

# 数组元素的个数
print(df.size)  # 12

# 数组的索引
print(df.index)  # RangeIndex(start=0, stop=3, step=1)

# 数组的列名
print(df.columns)  # Index(['A', 'B', 'C', 'D'], dtype='object')

# 数组的值，打印的是一个array
print(df.values)
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
'''

# 整体信息描述
print(df.describe())
'''
         A    B     C     D
count  3.0  3.0   3.0   3.0
mean   4.0  5.0   6.0   7.0
std    4.0  4.0   4.0   4.0
min    0.0  1.0   2.0   3.0
25%    2.0  3.0   4.0   5.0
50%    4.0  5.0   6.0   7.0
75%    6.0  7.0   8.0   9.0
max    8.0  9.0  10.0  11.0
'''

　　

import pandas as pd

# 关于pandas如何读取文件
# pd.read_sql(sql, conn)
    # 读取数据库里的文件,sql为查询的函数，conn则为数据库驱动的connect，或者SQLAlchemy的create_engine()创建的一个引擎
# pd.read_csv()，用来处理CSV文件
    # 这里面的参数非常多，介绍几个常用的
    # 第一个参数：一定要传文件路径或者buf。后面的参数，传入的时候最好加上参数名
    # 第二个参数：sep,表示用什么分割，不指定的话默认用空格
    # 第三个参数：usecols,如果csv文件中有很多列，而我们只需要某几个，这个时候就可以使用usecols，将需要筛选的列作为列表传给usecols
    # 第四个参数：nrows，有的时候我们不一样要全部读到内存中，所有nrows指定读取的行数
    # 第五个参数：index_col,将内容读到DataFrame的时候，选择哪一列作为索引。
    # 第六个参数：encoding，选择编码，除了文件路径
# pd.read_excel()，用来处理Excel文件
    # 参数依旧有很多，想介绍的和read_csv()差不多
    # 第一个参数：文件名路径
    # 第二个参数：sheetname
    # 后面的参数和read_csv()类似
# pd.read_table()，用来处理TXT文件
    # 参数有很多，和read_csv()传参一样，

# 这里介绍处理CSV，其实主要还是把内容读成DataFrame之后的操作，从这个角度来说，读取什么文件不重要，重要的是在读取之后如何进行操作
df = pd.read_csv(r"C:\Users\Administrator\Desktop\satori.csv", encoding="gbk")
print(df)
# 可以看到文件全部读进来了
'''
     姓名  年龄      登场作品 性别  发色
0  古明地觉  16     东方地灵殿  女  紫红
1  椎名真白  17  樱花庄的宠物女孩  女  金色
2   宫园薰  16   四月是你的谎言  女  金色
3  春日野穹  15       缘之空  女  银白
4   古河渚  18   clannad  女  棕色
5  坂上智代  17   clannad  女  银白
6  雨宫优子  16      悠久之翼  女  黑色
7  四方茉莉  17      sola  女  黑色
'''

# ---------------------------
'''
# 测试nrows
df = pd.read_csv(r"C:\\Users\Administrator\Desktop\satori.csv", encoding="gbk", nrows=3)
print(df)
# 可以看到我们只读了三行
     姓名  年龄      登场作品 性别  发色
0  古明地觉  16     东方地灵殿  女  紫红
1  椎名真白  17  樱花庄的宠物女孩  女  金色
2   宫园薰  16   四月是你的谎言  女  金色

'''

# ------
'''
# 测试usecols，注意这里的usecols还可以用对应的索引代替，从零开始慢慢数。
df = pd.read_csv(r"C:\\Users\Administrator\Desktop\satori.csv", encoding="gbk", nrows=3, usecols=["姓名", "发色"])
print(df)
# 可以看到在读取了三行的基础上，只读了两列
     姓名  发色
0  古明地觉  紫红
1  椎名真白  金色
2   宫园薰  金色
'''

# --------
# 现在df长这个样子
print(df)
'''
     姓名  年龄      登场作品 性别  发色
0  古明地觉  16     东方地灵殿  女  紫红
1  椎名真白  17  樱花庄的宠物女孩  女  金色
2   宫园薰  16   四月是你的谎言  女  金色
3  春日野穹  15       缘之空  女  银白
4   古河渚  18   clannad  女  棕色
5  坂上智代  17   clannad  女  银白
6  雨宫优子  16      悠久之翼  女  黑色
7  四方茉莉  17      sola  女  黑色

'''

# 筛选出年龄大于16的
print(df[df["年龄"] > 16])
'''
     姓名  年龄      登场作品 性别  发色
1  椎名真白  17  樱花庄的宠物女孩  女  金色
4   古河渚  18   clannad  女  棕色
5  坂上智代  17   clannad  女  银白
7  四方茉莉  17      sola  女  黑色
'''

# 将每个人的年龄减去一
df["年龄"] = df["年龄"].apply(lambda x: x-1)
print(df)
'''
     姓名  年龄      登场作品 性别  发色
0  古明地觉  15     东方地灵殿  女  紫红
1  椎名真白  16  樱花庄的宠物女孩  女  金色
2   宫园薰  15   四月是你的谎言  女  金色
3  春日野穹  14       缘之空  女  银白
4   古河渚  17   clannad  女  棕色
5  坂上智代  16   clannad  女  银白
6  雨宫优子  15      悠久之翼  女  黑色
7  四方茉莉  16      sola  女  黑色
'''

# ---------------
'''
# 假设df当中存在名为"时间"的时间戳，怎么转化为我们看着舒服的日期呢？
df["时间"] = pd.to_datetime(df["时间"], format="%Y-%d-%m", errors="coerce")
'''

# 查找姓名中包含宫的
print(df[df["姓名"].str.contains("宫")])
'''
     姓名  年龄     登场作品 性别  发色
2   宫园薰  15  四月是你的谎言  女  金色
6  雨宫优子  15     悠久之翼  女  黑色
'''

# 查找年龄为14或者16的
print(df[df["年龄"].isin([14, 16])])
'''
     姓名  年龄      登场作品 性别  发色
1  椎名真白  16  樱花庄的宠物女孩  女  金色
3  春日野穹  14       缘之空  女  银白
5  坂上智代  16   clannad  女  银白
7  四方茉莉  16      sola  女  黑色
'''

# 将DataFrame按照年龄排序，如果按照多个列排序，那么将多个列组成一个列表传进去
# 参数里面还有一个ascending=True，表示正序排，inplace=False，表示不在原来的DataFrame上操作，而是返回一个新的DataFrame
print(df.sort_values(by="年龄"))
'''
     姓名  年龄      登场作品 性别  发色
3  春日野穹  14       缘之空  女  银白
0  古明地觉  15     东方地灵殿  女  紫红
2   宫园薰  15   四月是你的谎言  女  金色
6  雨宫优子  15      悠久之翼  女  黑色
1  椎名真白  16  樱花庄的宠物女孩  女  金色
5  坂上智代  16   clannad  女  银白
7  四方茉莉  16      sola  女  黑色
4   古河渚  17   clannad  女  棕色
'''

# 计算不同年龄的出现的次数
print(df["年龄"].value_counts())
'''
15    3
16    3
14    1
17    1
Name: 年龄, dtype: int64
'''
print(type(df["年龄"].value_counts()))  # <class 'pandas.core.series.Series'>

# groupby汇总,如果按照多列汇总，那么将多列组合成一个列表传进去
# 里面的as_index,默认为True，说明汇总之后，传给by的列名要作为索引，如果多个列，那么共同作为索引
# 里面的sort=True,表示汇总之后自动排序
# 按照发色汇总，count表示每一种发色总共对应多少个name
print(df[["姓名", "发色"]].groupby(by="发色").count())
'''
    姓名
发色
棕色   1
紫红   1
金色   2
银白   2
黑色   2
'''
# 除了count还有sum，比方我想按照"发色"汇总年龄，把发色相同的人的年龄加在一起
print(df[["年龄", "发色"]].groupby(by="发色").sum())
'''
    年龄
发色
棕色  17
紫红  15
金色  31
银白  30
黑色  31
'''

# 我想把年龄相同的过滤掉
# inplace=False,默认不在原表上进行操作，而是返回新的列表。keep="first",表示去重的时候保留第一个，也可以指定为last
# 按照多个值过滤，组个列表传进去
print(df.drop_duplicates("年龄"))
'''
     姓名  年龄      登场作品 性别  发色
0  古明地觉  15     东方地灵殿  女  紫红
1  椎名真白  16  樱花庄的宠物女孩  女  金色
3  春日野穹  14       缘之空  女  银白
4   古河渚  17   clannad  女  棕色
'''

# 数据的合并
# 首先是concat,默认是上下合并,里面接受一个列表，列表可以存放很多个df，默认是axis=0，上下合并
print(pd.concat([df, df]))
'''
0  古明地觉  15     东方地灵殿  女  紫红
1  椎名真白  16  樱花庄的宠物女孩  女  金色
2   宫园薰  15   四月是你的谎言  女  金色
3  春日野穹  14       缘之空  女  银白
4   古河渚  17   clannad  女  棕色
5  坂上智代  16   clannad  女  银白
6  雨宫优子  15      悠久之翼  女  黑色
7  四方茉莉  16      sola  女  黑色
'''
# 左右合并
print(pd.concat([df, df], axis=1))
'''
     姓名  年龄      登场作品 性别  发色    姓名  年龄      登场作品 性别  发色
0  古明地觉  15     东方地灵殿  女  紫红  古明地觉  15     东方地灵殿  女  紫红
1  椎名真白  16  樱花庄的宠物女孩  女  金色  椎名真白  16  樱花庄的宠物女孩  女  金色
2   宫园薰  15   四月是你的谎言  女  金色   宫园薰  15   四月是你的谎言  女  金色
3  春日野穹  14       缘之空  女  银白  春日野穹  14       缘之空  女  银白
4   古河渚  17   clannad  女  棕色   古河渚  17   clannad  女  棕色
5  坂上智代  16   clannad  女  银白  坂上智代  16   clannad  女  银白
6  雨宫优子  15      悠久之翼  女  黑色  雨宫优子  15      悠久之翼  女  黑色
7  四方茉莉  16      sola  女  黑色  四方茉莉  16      sola  女  黑色
'''

# 采用merge方式合并
# merge里面只接收两个df，然后是合并方式，how="left",按照左边的df合并，如果左边的df中没有就丢弃，同理right类似。how="inner"，两个df相当于做交集。how="outer",两个df相当于做补集
# on = "",表示按照哪个字段合并，如果多个字段作为列表传进去
print(pd.merge(df, df, how="outer", on="姓名"))
'''
     姓名  年龄_x    登场作品_x 性别_x 发色_x  年龄_y    登场作品_y 性别_y 发色_y
0  古明地觉    15     东方地灵殿    女   紫红    15     东方地灵殿    女   紫红
1  椎名真白    16  樱花庄的宠物女孩    女   金色    16  樱花庄的宠物女孩    女   金色
2   宫园薰    15   四月是你的谎言    女   金色    15   四月是你的谎言    女   金色
3  春日野穹    14       缘之空    女   银白    14       缘之空    女   银白
4   古河渚    17   clannad    女   棕色    17   clannad    女   棕色
5  坂上智代    16   clannad    女   银白    16   clannad    女   银白
6  雨宫优子    15      悠久之翼    女   黑色    15      悠久之翼    女   黑色
7  四方茉莉    16      sola    女   黑色    16      sola    女   黑色
'''

　　

'''
df[pd.isnull(df.title)],选出title为空的所有行
df[df.title.contains("aaa", na=False)], 选出title包含aaa的所有行，不包括空值

    a
0   10
1   30
2   50
3   70
4   90
5   100

labels = ["10到20", "20到40","40到60","60到80", "80到95", "100"]
bins = [20, 40, 60, 80, 95, 100]
pd.cut(df.a, bins, right=True, labels=None)

>>>
    a
0   (1, 20]
1   (20, 40]
2   (40,60]
3   (60, 80]
4   (80, 95]
5   (95, 100]

pd.cut(df.a, bins, right=True, labels=labels)

>>>
    a
0   10到20
1   20到40
2   40到60
3   60到80
4   80到95
5   100

字符串专程日期格式
df.to_datetime(df.time, format="")

日期抽取
df["time"].dt.year
df["time"].dt.month
df["time"].dt.day
df["time"].dt.hour
df["time"].dt.minute
df["time"].dt.second
df["time"].dt.weekday
'''

　　

df = pd.DataFrame({"a": [4,3,4,5],
                   "b": [5,2,7,7],
                   "c": [4,4,8,9]})

print(df.div(100))
'''
      a     b     c
0  0.04  0.05  0.04
1  0.03  0.02  0.04
2  0.04  0.07  0.08
3  0.05  0.07  0.09
'''
# 表示先对每一行进行求和，让列元素分别去除
print(df.div(df.sum(axis=1), axis=0))
# 会发现每一行相加等于一
'''
          a         b         c
0  0.307692  0.384615  0.307692
1  0.333333  0.222222  0.444444
2  0.210526  0.368421  0.421053
3  0.238095  0.333333  0.428571
'''
# 表示先对每一列进行求和，让行元素分别去除
# 会发现每一列相加等于一
print(df.div(df.sum(axis=0), axis=1))
'''
        a         b     c
0  0.2500  0.238095  0.16
1  0.1875  0.095238  0.16
2  0.2500  0.333333  0.32
3  0.3125  0.333333  0.36
'''
# 查看相关性
'''
df["a"].corr(df["b"]), 查看a和b之间的相关性
df["a", "b", "c"].corr(df["a", "b"]), 查看a,b,c和a,b之间的相关性，a、b和a、b之间肯定高度相关
df["a", "b", "c"].corr(),corr不加参数默认和前面的df保持一致，即查看a、b、c和a、b、c之间的相关性
'''

　　

pd.set_option("expand_frame_repr", False)  # 列太多时不换行
pd.set_option("max_colwidth", 8)  # 有的列太长，我们可以进行设置，比如设置最大列宽等于8

　

'''
    alpha
0   a
1   b
2   c
3   d
4   e

df["new_alpha"] = df["alpha"].shift(1)
那么df["new_data"]会在df["alpha"]的基础上上移1位,超出的部分为NaN,里面的可以为任意数字。如果为负数，那么在原来的基础上下移

    alpha new_alpha
0   a     NaN
1   b     a
2   c     b
3   d     c
4   e     d
'''

　　

'''
    收盘价
0   10
1   12
2   9
3   11
4   13

df["涨跌] = df["收盘价"].diff(-1),求本行数据和上行数据相减的结果。为1，则是上行数据和本行数据相减的结果。如果-2，则是本上数据和上两行数据相减的结果

    收盘价  涨跌
0   10      2 -->12-10
1   12      -3-->9-12
2   9       2 -->11-9
3   11      2 -->13-11
4   13      NaN -->NaN-13
'''

　　

'''
    收盘价
0   10
1   12
2   9
3   11
4   13

df["涨跌] = df["收盘价"].pct_change(-1), 类似于diff，但求的是增加或者减少的比例

    收盘价  涨跌
0   10      (12-10)/2
1   12      (9-12)/12
2   9       (11-9)/9
3   11      (13-11)/11
4   13      NaN
'''

　　

'''
    收盘价
0   10
1   12
2   9
3   11
4   13

df["收盘价_cum"] = df["收盘价"].cumsum() ,累加

    收盘价  收盘价_cum
0   10      10
1   12      12+10
2   9       9+12+10
3   11      11+9+12+10
4   13      13+11+9+12+10

还有cumprod表示累乘
'''

　　

'''
    收盘价
0   10
1   12
2   9
3   11
4   13

df["收盘价排序"] = df["收盘价"].rank(ascending=True, pct=False)

    收盘价 收盘价排序
0   10      2 从小到大排名第2
1   12      4 从小到大排名第4
2   9       1 从小到大排名第1
3   11      3 从小到大排名第3
4   13      5 从小到大排名第5

ascending：升序，为True表示从小到大，为False从大到小
pct：percent，为False表示排名，为True表示排名的百分比
'''

　　

'''
df.dropna(how="any")，只要有空值就删
df.dropna(how="all")，必须全为空值才删

df.drop(subset=["column1", "column2"], how="all"),其他列不管，只要column1、columns2全为空值就删除这一行。
'''

　　

'''
    收盘价 利润
0   10     20
1   12     15
2   9      NaN
3   11     13
4   13     NaN

df["利润"] = df["利润"].fillna(value=10)
    收盘价 利润
0   10     20
1   12     15
2   9      10
3   11     13
4   13     10

df["利润"] = df["利润"].fillna(value=df["收盘价"])
    收盘价 利润
0   10     20
1   12     15
2   9      9
3   11     13
4   13     13

df["利润"] = df["利润"].fillna(method="ffill")，向上寻找最近的一个非空值进行填充
    收盘价 利润
0   10     20
1   12     15
2   9      15
3   11     13
4   13     13

同理method="bfill",表示向下寻找一个最近的非空值进行填充

    收盘价 利润
0   10     20
1   12     15
2   9      NaN
3   11     13
4   13     NaN
df.notnull(),判断是不是不空值，不空为True， 空为False
df.isnull(),判断是不是空值，空为True， 不空为False

df[df["利润"].isnull()]
    收盘价 利润
2   9      NaN
4   13     NaN

df[df["利润"].notnull()]
    收盘价 利润
0   10     20
1   12     15
3   11     13
'''

　　

import pandas as pd

df = pd.DataFrame({"a": [0, 1, 2, 3, 4], "b": [5, 6, 7, 8, 9]})
print(df)
'''
   a  b
0  0  5
1  1  6
2  2  7
3  3  8
4  4  9
'''
print(df.rolling(3).mean())
'''
     a    b
0  NaN  NaN
1  NaN  NaN
2  1.0  6.0
3  2.0  7.0
4  3.0  8.0
'''
print(df.rolling(3, min_periods=1).mean())
'''
     a    b
0  0.0  5.0
1  0.5  5.5
2  1.0  6.0
3  2.0  7.0
4  3.0  8.0
'''
print(df.expanding().mean())
'''
     a    b
0  0.0  5.0
1  0.5  5.5
2  1.0  6.0
3  1.5  6.5
4  2.0  7.0
前n行的平均数
'''