27_python笔记-pandas

最新推荐文章于 2023-08-31 20:07:03 发布

mycpen

最新推荐文章于 2023-08-31 20:07:03 发布

阅读量708

点赞数

分类专栏： Python笔记文章标签： python pandas

本文链接：https://blog.csdn.net/cPen_web/article/details/110826545

版权

Python笔记专栏收录该内容

29 篇文章 1 订阅

订阅专栏

Python pandas

个人博客
https://blog.csdn.net/cPen_web

示例：仅有数据列表即可产生最简单的Series

>>> import pandas as pd
>>> import numpy as np
>>> s1 = pd.Series([1,'a',5.2,"x"])
>>> s1
# 左侧为索引，右侧是数据
0      1
1      a
2    5.2
3      x
dtype: object
>>> dir(s1)
#注：很多属性
#注：获取索引
>>> s1.index
RangeIndex(start=0, stop=4, step=1)
#注：获取数据
>>> s1.values
array([1, 'a', 5.2, 'x'], dtype=object)

示例：创建一个具有标签索引的Series

>>> s2 = pd.Series([1, 'a', 5.2, 'x'], index=["d","b","c","aaa"])
>>> s2
d        1
b        a
c      5.2
aaa      x
dtype: object
#注：Series里面有不同输出格式，对象就是object
>>> s2.index
Index(['d', 'b', 'c', 'aaa'], dtype='object')

示例：使用Python字典创建Series

>>> sdata = {"a":2000,"b":1500,"c":3000,"d":1200}
>>> s3 = pd.Series(sdata)
>>> s3
a    2000
b    1500
c    3000
d    1200
dtype: int64
>>> s3["a"]
2000

示例：根据标签索引查询数据

#示例：获取值
>>> s2
d        1
b        a
c      5.2
aaa      x
dtype: object
>>> type(s2["c"])
<class 'float'>
>>> type(s2["d"])
<class 'int'>
>>> type(s2["b"])
<class 'str'>
>>> s2[["c","b"]]			#注：获取多个值
c    5.2
b      a
dtype: object

示例：根据多个字典序列创建dataframe

>>> data = {
...         'state':['Ohio','Ohio','Ohio','Nevada','Nevada'],
...         'year':[2000,2001,2002,2001,2002],
...         'pop':[1.5,1.7,3.6,2.4,2.9]
... }
>>> df = pd.DataFrame(data)
>>> df
    state  year  pop			#注：state  year  pop列索引； 0 1 2 3 4行索引
0    Ohio  2000  1.5
1    Ohio  2001  1.7
2    Ohio  2002  3.6
3  Nevada  2001  2.4
4  Nevada  2002  2.9
>>> df.dtypes
state     object
year       int64
pop      float64
dtype: object						#注：有str，都是object
>>> df.columns					#注：列索引
Index(['state', 'year', 'pop'], dtype='object')
>>> df.index						#注：行索引
RangeIndex(start=0, stop=5, step=1)
>>> df["year"]					#注：提取某列
0    2000
1    2001
2    2002
3    2001
4    2002
Name: year, dtype: int64
>>> type(df["year"])				#注：列类型 series
<class 'pandas.core.series.Series'>
>>> df[["year","state"]]			#注：提取多列
   year   state
0  2000    Ohio
1  2001    Ohio
2  2002    Ohio
3  2001  Nevada
4  2002  Nevada

示例：有str，是object；整型、浮点型，全部强制转成float

>>> s4 = pd.Series([1,2,3,4,5.5])
>>> s4
0    1.0
1    2.0
2    3.0
3    4.0
4    5.5
dtype: float64
>>> s4 = pd.Series([1,2,3,4,5.5,"aa"])
>>> s4
0      1
1      2
2      3
3      4
4    5.5
5     aa
dtype: object

#注：csv文件：轻量级表格形式，默认逗号分割。第1列数据 标题头

示例：根据从文件、mysql中读取创建dataframe

>>> import pandas as pd
>>> df = pd.read_csv("./read_test.csv")					#注：读取csv文件
>>> df
          date   prov    isp    pv    uv
0   2020-04-26  hunan  cmnet  2000  1000
1   2020-04-26  hunan  cmnet  3000  1500
2   2020-04-26  hunan   cmcc  4000  1000
3   2020-04-26  hubei    ctc  2500  1000
4   2020-04-26  hubei   cmcc  2000  1000
5   2020-04-26  hubei    ctc  2100  1600
6   2020-04-27  hunan  cmnet  4000  1700
7   2020-04-27  hunan  cmnet  3200  1500
8   2020-04-27  hunan   cmcc  2800  1600
9   2020-04-27  hubei    ctc  2600  1400
10  2020-04-27  hubei   cmcc  3800  1900
11  2020-04-27  hubei    ctc  2400  1900

>>> df2 = pd.read_excel("./互联网公司股票.xlsx")			#注：读取Excel文件
>>> df2
            日期    公司      收盘      开盘       高       低    交易量   涨跌幅
0   2019-10-03  BIDU  104.32  102.35  104.73  101.15   2.24  0.02
1   2019-10-02  BIDU  102.62  100.85  103.24   99.50   2.69  0.01
2   2019-10-01  BIDU  102.00  102.80  103.26  101.00   1.78 -0.01
3   2019-10-03  BABA  169.48  166.65  170.18  165.00  10.39  0.02
4   2019-10-02  BABA  165.77  162.82  166.88  161.90  11.60  0.00
5   2019-10-01  BABA  165.15  168.01  168.23  163.64  14.19 -0.01
6   2019-10-03    IQ   16.06   15.71   16.38   15.32  10.08  0.02
7   2019-10-02    IQ   15.72   15.85   15.87   15.12   8.10 -0.01
8   2019-10-01    IQ   15.92   16.14   16.22   15.50  11.65 -0.01
9   2019-10-03    JD   28.80   28.11   28.97   27.82   8.77  0.03
10  2019-10-02    JD   28.06   28.00   28.22   27.53   9.53  0.00
11  2019-10-01    JD   28.19   28.22   28.57   27.97  10.64  0.00

示例：从网页中拉取table数据

>>> import pandas as pd
>>> text_html = pd.read_html('http://ranking.promisingedu.com/qs')[0]
>>> text_html
     Ranking                       University English Name  Country/Region  ...  Citations per Faculty  Overall Score  Free
0          1   Massachusetts Institute of Technology (MIT)   United States  ...                   99.1          100.0  免费评估
1          2                           Stanford University   United States  ...                   98.1           98.4  免费评估
2          3                            Harvard University   United States  ...                   99.1           97.9  免费评估
3          4  California Institute of Technology (Caltech)   United States  ...                   99.9           97.0  免费评估
4          5                      牛津大学University of Oxford  United Kingdom  ...                   81.3           96.7  免费评估
..       ...                                           ...             ...  ...                    ...            ...   ...
496      493                                         UNESP          Brazil  ...                   16.2           24.2  免费评估
497      498                      Universidad de La Habana            Cuba  ...                    2.4           24.1  免费评估
498      499                       Oregon State University   United States  ...                   35.0           23.9  免费评估
499      499                         Universidad de Alcalá           Spain  ...                   10.6           23.9  免费评估
500      499                 University of Eastern Finland         Finland  ...                   33.5           23.9  免费评估

[501 rows x 11 columns]

示例：从数据库拉取

[root@cPen_A ~]# pip3 install pymysql
#注：mysql环境下
root@(none) 11:14  mysql>create database pd;
root@(none) 11:19  mysql>show databases;
root@(none) 11:20  mysql>use pd;
root@pd 11:20  mysql>create table Student(
    -> id int not null,
    -> name varchar(64) not null,
    -> sex varchar(64),
    -> age int);
root@pd 11:22  mysql>show tables;
+--------------+
| Tables_in_pd |
+--------------+
| Student      |
+--------------+
1 row in set (0.00 sec)

root@pd 11:23  mysql>desc Student;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int(11)     | NO   |     | NULL    |       |
| name  | varchar(64) | NO   |     | NULL    |       |
| sex   | varchar(64) | YES  |     | NULL    |       |
| age   | int(11)     | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+
4 rows in set (0.18 sec)

root@pd 11:23  mysql>insert into Student values(1,'cp','m','18');
root@pd 11:24  mysql>insert into Student values(2,'cp2','m','18');
root@pd 11:25  mysql>select * from Student;
+----+------+------+------+
| id | name | sex  | age  |
+----+------+------+------+
|  1 | cp   | m    |   18 |
|  2 | cp2  | m    |   18 |
+----+------+------+------+
2 rows in set (0.00 sec)
#注：Python3环境下
>>> import pandas as pd
>>> import pymysql
>>> conn = pymysql.connect(
...        host = "127.0.0.1",
...        user = "root",
...        passwd = "Sanchuang123#",
...        database = "pd",
...        charset = "utf8")
>>> mysql_df = pd.read_sql("select * from Student", con=conn)
>>> mysql_df
   id name sex  age
0   1   cp   m   18
1   2  cp2   m   18
>>> mysql_df.values
array([[1, 'cp', 'm', 18],				#注：返回二维数组形式
       [2, 'cp2', 'm', 18]], dtype=object)

示例：二维数组形式返回

>>> import pandas as pd
>>> df = pd.read_csv("read_test.csv")
>>> df.values						#注：二维数组形式
array([['2020-04-26', 'hunan', 'cmnet', 2000, 1000],
       ['2020-04-26', 'hunan', 'cmnet', 3000, 1500],
       ['2020-04-26', 'hunan', 'cmcc', 4000, 1000],
       ['2020-04-26', 'hubei', 'ctc', 2500, 1000],
       ['2020-04-26', 'hubei', 'cmcc', 2000, 1000],
       ['2020-04-26', 'hubei', 'ctc', 2100, 1600],
       ['2020-04-27', 'hunan', 'cmnet', 4000, 1700],
       ['2020-04-27', 'hunan', 'cmnet', 3200, 1500],
       ['2020-04-27', 'hunan', 'cmcc', 2800, 1600],
       ['2020-04-27', 'hubei', 'ctc', 2600, 1400],
       ['2020-04-27', 'hubei', 'cmcc', 3800, 1900],
       ['2020-04-27', 'hubei', 'ctc', 2400, 1900]], dtype=object)

示例：返回行列数

>>> df.shape						#注：返回行列数
(12, 5)

示例：返回行索引

>>> df.index						#注：返回行索引
RangeIndex(start=0, stop=12, step=1)

示例：指定索引列

>>> df.set_index('date')			#注：指定索引列
             prov    isp    pv    uv
date                                
2020-04-26  hunan  cmnet  2000  1000
2020-04-26  hunan  cmnet  3000  1500
2020-04-26  hunan   cmcc  4000  1000
2020-04-26  hubei    ctc  2500  1000
2020-04-26  hubei   cmcc  2000  1000
2020-04-26  hubei    ctc  2100  1600
2020-04-27  hunan  cmnet  4000  1700
2020-04-27  hunan  cmnet  3200  1500
2020-04-27  hunan   cmcc  2800  1600
2020-04-27  hubei    ctc  2600  1400
2020-04-27  hubei   cmcc  3800  1900
2020-04-27  hubei    ctc  2400  1900

示例：重置索引

>>> df2.reset_index()						#注：重置索引
          date   prov    isp    pv    uv
0   2020-04-26  hunan  cmnet  2000  1000
1   2020-04-26  hunan  cmnet  3000  1500
2   2020-04-26  hunan   cmcc  4000  1000
3   2020-04-26  hubei    ctc  2500  1000
4   2020-04-26  hubei   cmcc  2000  1000
5   2020-04-26  hubei    ctc  2100  1600
6   2020-04-27  hunan  cmnet  4000  1700
7   2020-04-27  hunan  cmnet  3200  1500
8   2020-04-27  hunan   cmcc  2800  1600
9   2020-04-27  hubei    ctc  2600  1400
10  2020-04-27  hubei   cmcc  3800  1900
11  2020-04-27  hubei    ctc  2400  1900

示例：drop 丢弃老索引，默认false

>>> df2.reset_index(drop=True)			#注：drop 丢弃老索引，默认false
     prov    isp    pv    uv
0   hunan  cmnet  2000  1000
1   hunan  cmnet  3000  1500
2   hunan   cmcc  4000  1000
3   hubei    ctc  2500  1000
4   hubei   cmcc  2000  1000
5   hubei    ctc  2100  1600
6   hunan  cmnet  4000  1700
7   hunan  cmnet  3200  1500
8   hunan   cmcc  2800  1600
9   hubei    ctc  2600  1400
10  hubei   cmcc  3800  1900
11  hubei    ctc  2400  1900

示例：inplace 原地改变df2，默认false

>>> df2.reset_index(drop=True,inplace=True)	#注：inplace 原地改变df2，默认false
>>> df2
     prov    isp    pv    uv
0   hunan  cmnet  2000  1000
1   hunan  cmnet  3000  1500
2   hunan   cmcc  4000  1000
3   hubei    ctc  2500  1000
4   hubei   cmcc  2000  1000
5   hubei    ctc  2100  1600
6   hunan  cmnet  4000  1700
7   hunan  cmnet  3200  1500
8   hunan   cmcc  2800  1600
9   hubei    ctc  2600  1400
10  hubei   cmcc  3800  1900
11  hubei    ctc  2400  1900

示例：获取列索引

>>> df.columns						#注：获取列索引
Index(['date', 'prov', 'isp', 'pv', 'uv'], dtype='object')

示例：重新设置列表名

>>> df2 = df
>>> df2.columns=['a','b','c','d','e']		#注：重新设置列表名
>>> df2
             a      b      c     d     e
0   2020-04-26  hunan  cmnet  2000  1000
1   2020-04-26  hunan  cmnet  3000  1500
2   2020-04-26  hunan   cmcc  4000  1000
3   2020-04-26  hubei    ctc  2500  1000
4   2020-04-26  hubei   cmcc  2000  1000
5   2020-04-26  hubei    ctc  2100  1600
6   2020-04-27  hunan  cmnet  4000  1700
7   2020-04-27  hunan  cmnet  3200  1500
8   2020-04-27  hunan   cmcc  2800  1600
9   2020-04-27  hubei    ctc  2600  1400
10  2020-04-27  hubei   cmcc  3800  1900
11  2020-04-27  hubei    ctc  2400  1900

示例：重新设置列表名（不需要改的可以不写）

#重新设置列表名（不需要改的可以不写）
>>> df2.rename(columns = {'a':'日期','b':'省份','c':'运营商','d':'pv','e':'uv'}, inplace = True)

示例：查看行、列索引

>>> df.axes		#注：查看行、列索引
[RangeIndex(start=0, stop=12, step=1), Index(['a', 'b', 'c', 'd', 'e'], dtype='object')]

示例：行列对调

>>> df.T			#注：行列对调。倒过来，行变列，列变行
           0           1           2           3           4   ...          7           8           9           10          11
a  2020-04-26  2020-04-26  2020-04-26  2020-04-26  2020-04-26  ...  2020-04-27  2020-04-27  2020-04-27  2020-04-27  2020-04-27
b       hunan       hunan       hunan       hubei       hubei  ...       hunan       hunan       hubei       hubei       hubei
c       cmnet       cmnet        cmcc         ctc        cmcc  ...       cmnet        cmcc         ctc        cmcc         ctc
d        2000        3000        4000        2500        2000  ...        3200        2800        2600        3800        2400
e        1000        1500        1000        1000        1000  ...        1500        1600        1400        1900        1900

[5 rows x 12 columns]

示例：前10行，默认前5行

>>> df.head(10)						#注：前10行，默认前5行
            a      b      c     d     e
0  2020-04-26  hunan  cmnet  2000  1000
1  2020-04-26  hunan  cmnet  3000  1500
2  2020-04-26  hunan   cmcc  4000  1000
3  2020-04-26  hubei    ctc  2500  1000
4  2020-04-26  hubei   cmcc  2000  1000
5  2020-04-26  hubei    ctc  2100  1600
6  2020-04-27  hunan  cmnet  4000  1700
7  2020-04-27  hunan  cmnet  3200  1500
8  2020-04-27  hunan   cmcc  2800  1600
9  2020-04-27  hubei    ctc  2600  1400

示例：后5行

>>> df.tail()						#注：后5行
             a      b      c     d     e
7   2020-04-27  hunan  cmnet  3200  1500
8   2020-04-27  hunan   cmcc  2800  1600
9   2020-04-27  hubei    ctc  2600  1400
10  2020-04-27  hubei   cmcc  3800  1900
11  2020-04-27  hubei    ctc  2400  1900

示例：描述信息

>>> df.describe()				#注：描述信息
                 d            e
count    12.000000    12.000000
mean   2866.666667  1425.000000	#注：平均值
std     743.863787   346.738046	#注：标准差
min    2000.000000  1000.000000	#注：最小值
25%    2325.000000  1000.000000
50%    2700.000000  1500.000000
75%    3350.000000  1625.000000
max    4000.000000  1900.000000	#注：最大值

示例：判断是否为空

>>> df.empty		#注：判断是否为空
False

示例：最大值索引

>>> df3
                b      c     d     e
a                                   
2020-04-26  hunan  cmnet  2000  1000
2020-04-26  hunan  cmnet  3000  1500
2020-04-26  hunan   cmcc  4000  1000
2020-04-26  hubei    ctc  2500  1000
2020-04-26  hubei   cmcc  2000  1000
2020-04-26  hubei    ctc  2100  1600
2020-04-27  hunan  cmnet  4000  1700
2020-04-27  hunan  cmnet  3200  1500
2020-04-27  hunan   cmcc  2800  1600
2020-04-27  hubei    ctc  2600  1400
2020-04-27  hubei   cmcc  3800  1900
2020-04-27  hubei    ctc  2400  1900
>>> df3["d"].argmax()		#注：返回最大值所在的自动索引位置
2						#注：2位2020-04-26首位

示例：最大值所在的自定义索引位置

>>> df3["d"].idxmax()		#注：返回最大值所在的自定义索引位置
'2020-04-26'

>>> df = pd.DataFrame(np.random.rand(25).reshape([5, 5]), index=['A', 'B', 'C', 'D', 'E'], columns=['c1', 'c2', 'c3', 'c4', 'c5'])
>>> df
         c1        c2        c3        c4        c5
A  0.590029  0.403311  0.950695  0.960199  0.165499
B  0.237958  0.765573  0.661291  0.247272  0.593731
C  0.334942  0.699981  0.722061  0.399049  0.938837
D  0.667942  0.250859  0.240425  0.617833  0.603176
E  0.159057  0.456562  0.779481  0.766096  0.103392
>>> df["c1"]
A    0.590029
B    0.237958
C    0.334942
D    0.667942
E    0.159057
Name: c1, dtype: float64
>>> df[["c1","c2"]]
         c1        c2
A  0.590029  0.403311
B  0.237958  0.765573
C  0.334942  0.699981
D  0.667942  0.250859
E  0.159057  0.456562
>>> df.c1
A    0.590029
B    0.237958
C    0.334942
D    0.667942
E    0.159057
Name: c1, dtype: float64
>>> df.c2
A    0.403311
B    0.765573
C    0.699981
D    0.250859
E    0.456562
Name: c2, dtype: float64

示例：获取行

>>> df["A":"A"]								#注：获取行
         c1        c2        c3        c4        c5
A  0.590029  0.403311  0.950695  0.960199  0.165499

示例：获取2行

>>> df["A":"B"]								#注：获取2行
         c1        c2        c3        c4        c5
A  0.590029  0.403311  0.950695  0.960199  0.165499
B  0.237958  0.765573  0.661291  0.247272  0.593731

示例：从行首到A

>>> df[:"A"]									#注：从行首到A
         c1        c2        c3        c4        c5
A  0.590029  0.403311  0.950695  0.960199  0.165499

示例：获取2-3行数据

>>> df[1:3]									#注：获取2-3行数据
         c1        c2        c3        c4        c5
B  0.237958  0.765573  0.661291  0.247272  0.593731
C  0.334942  0.699981  0.722061  0.399049  0.938837

示例：获取指定行、列数据

>>> df[:1][["c2","c5"]]							#注：获取指定行、列数据
         c2        c5
A  0.403311  0.165499

示例：把最后2列放到前面

>>> df[["c4","c5","c1","c2","c3"]]				#注：把最后2列放到前面
         c4        c5        c1        c2        c3
A  0.960199  0.165499  0.590029  0.403311  0.950695
B  0.247272  0.593731  0.237958  0.765573  0.661291
C  0.399049  0.938837  0.334942  0.699981  0.722061
D  0.617833  0.603176  0.667942  0.250859  0.240425
E  0.766096  0.103392  0.159057  0.456562  0.779481

示例：行切片 + 列切片

>>> df.loc['A':'D',"c1":"c3"]				#注：行切片 + 列切片 ；取A-D的行，c1-c3的列
         c1        c2        c3
A  0.590029  0.403311  0.950695
B  0.237958  0.765573  0.661291
C  0.334942  0.699981  0.722061
D  0.667942  0.250859  0.240425

示例：获取单个值查询

>>> df.loc["A","c4"]						#注：获取单个值查询
0.9601993392653275

示例：使用列表批量查询

>>> df.loc[["A","B","D"],["c1","c3"]]			#注：使用列表批量查询
         c1        c3
A  0.590029  0.950695
B  0.237958  0.661291
D  0.667942  0.240425

示例：查找c2里大于0.5的行

>>> df.loc[df['c2']>0.5,:]					#注：查找c2里 大于0.5的行
         c1        c2        c3        c4        c5
B  0.237958  0.765573  0.661291  0.247272  0.593731
C  0.334942  0.699981  0.722061  0.399049  0.938837

示例：输出c3、c4

>>> df.loc[df['c2']>0.5,["c3","c4"]]			#注：输出c3、c4
         c3        c4
B  0.661291  0.247272
C  0.722061  0.399049

示例：查询c2里大于0.2且c3里小于0.8的行

>>> df.loc[(df["c2"]>0.2) & (df["c3"]<0.8)]	#注：查询c2里大于0.2且c3里小于0.8的行
         c1        c2        c3        c4        c5
B  0.237958  0.765573  0.661291  0.247272  0.593731
C  0.334942  0.699981  0.722061  0.399049  0.938837
D  0.667942  0.250859  0.240425  0.617833  0.603176
E  0.159057  0.456562  0.779481  0.766096  0.103392
>>> df[(df["c2"]>0.2) & (df["c3"]<0.8)]
         c1        c2        c3        c4        c5
B  0.237958  0.765573  0.661291  0.247272  0.593731
C  0.334942  0.699981  0.722061  0.399049  0.938837
D  0.667942  0.250859  0.240425  0.617833  0.603176
E  0.159057  0.456562  0.779481  0.766096  0.103392

示例：取c4最大值时,c2的值

>>> df.loc[df["c4"].idxmax,"c2"]				#注：取c4最大值时,c2的值
0.4033107277948891							#注：先获取索引

示例：使用函数查询

>>> def query_my_data(df):					#注：使用函数查询
...     return ((df['c3']>0.2) & (df["c4"]<0.8))
...

示例：c3大于平均值时c1的值

>>> df.loc[df["c3"]>df["c3"].mean(),"c1"]		#注：c3大于平均值时c1的值
A    0.590029
C    0.334942
E    0.159057
Name: c1, dtype: float64

示例：map映射

>>> df = pd.read_csv("./read_test.csv")
>>> df
          date   prov    isp    pv    uv
0   2020-04-26  hunan  cmnet  2000  1000
1   2020-04-26  hunan  cmnet  3000  1500
2   2020-04-26  hunan   cmcc  4000  1000
3   2020-04-26  hubei    ctc  2500  1000
4   2020-04-26  hubei   cmcc  2000  1000
5   2020-04-26  hubei    ctc  2100  1600
6   2020-04-27  hunan  cmnet  4000  1700
7   2020-04-27  hunan  cmnet  3200  1500
8   2020-04-27  hunan   cmcc  2800  1600
9   2020-04-27  hubei    ctc  2600  1400
10  2020-04-27  hubei   cmcc  3800  1900
11  2020-04-27  hubei    ctc  2400  1900
>>> dict_isp_names = {
...     'cmnet':'中国移动',
...     'cmcc':'中国联通',
...     'ctc':'中国电信'}
>>> df['isp1'] = df['isp'].map(dict_isp_names)				#注：map映射
>>> df
          date   prov    isp    pv    uv  isp1
0   2020-04-26  hunan  cmnet  2000  1000  中国移动
1   2020-04-26  hunan  cmnet  3000  1500  中国移动
2   2020-04-26  hunan   cmcc  4000  1000  中国联通
3   2020-04-26  hubei    ctc  2500  1000  中国电信
4   2020-04-26  hubei   cmcc  2000  1000  中国联通
5   2020-04-26  hubei    ctc  2100  1600  中国电信
6   2020-04-27  hunan  cmnet  4000  1700  中国移动
7   2020-04-27  hunan  cmnet  3200  1500  中国移动
8   2020-04-27  hunan   cmcc  2800  1600  中国联通
9   2020-04-27  hubei    ctc  2600  1400  中国电信
10  2020-04-27  hubei   cmcc  3800  1900  中国联通
11  2020-04-27  hubei    ctc  2400  1900  中国电信

示例：新增列

>>> df['float1'] = 5.6458								#注：新增列
>>> df
          date   prov    isp    pv    uv  isp1  float1
0   2020-04-26  hunan  cmnet  2000  1000  中国移动  5.6458
1   2020-04-26  hunan  cmnet  3000  1500  中国移动  5.6458
2   2020-04-26  hunan   cmcc  4000  1000  中国联通  5.6458
3   2020-04-26  hubei    ctc  2500  1000  中国电信  5.6458
4   2020-04-26  hubei   cmcc  2000  1000  中国联通  5.6458
5   2020-04-26  hubei    ctc  2100  1600  中国电信  5.6458
6   2020-04-27  hunan  cmnet  4000  1700  中国移动  5.6458
7   2020-04-27  hunan  cmnet  3200  1500  中国移动  5.6458
8   2020-04-27  hunan   cmcc  2800  1600  中国联通  5.6458
9   2020-04-27  hubei    ctc  2600  1400  中国电信  5.6458
10  2020-04-27  hubei   cmcc  3800  1900  中国联通  5.6458
11  2020-04-27  hubei    ctc  2400  1900  中国电信  5.6458

示例：保留2位小数输出是string类型

>>> df['float1']=df['float1'].map(lambda x:"%.2f"%x)	#注：保留2位小数 输出是string类型
>>> df.dtypes
date      object
prov      object
isp       object
pv         int64
uv         int64
isp1      object
float1    object
dtype: object
>>> df
          date   prov    isp    pv    uv  isp1 float1
0   2020-04-26  hunan  cmnet  2000  1000  中国移动   5.65
1   2020-04-26  hunan  cmnet  3000  1500  中国移动   5.65
2   2020-04-26  hunan   cmcc  4000  1000  中国联通   5.65
3   2020-04-26  hubei    ctc  2500  1000  中国电信   5.65
4   2020-04-26  hubei   cmcc  2000  1000  中国联通   5.65
5   2020-04-26  hubei    ctc  2100  1600  中国电信   5.65
6   2020-04-27  hunan  cmnet  4000  1700  中国移动   5.65
7   2020-04-27  hunan  cmnet  3200  1500  中国移动   5.65
8   2020-04-27  hunan   cmcc  2800  1600  中国联通   5.65
9   2020-04-27  hubei    ctc  2600  1400  中国电信   5.65
10  2020-04-27  hubei   cmcc  3800  1900  中国联通   5.65
11  2020-04-27  hubei    ctc  2400  1900  中国电信   5.65

示例：保留2位小数保留float类型

>>> df['float1'] = 5.6458
>>> df['float1']=df['float1'].map(lambda x:round(x,2))		#注：保留2位小数 保留float类型
>>> df.dtypes
date       object
prov       object
isp        object
pv          int64
uv          int64
isp1       object
float1    float64
dtype: object

示例：将hunan、hubei映射成湖南、湖北

>>> df
          date   prov    isp    pv    uv  isp1  float1
0   2020-04-26  hunan  cmnet  2000  1000  中国移动    5.65
1   2020-04-26  hunan  cmnet  3000  1500  中国移动    5.65
2   2020-04-26  hunan   cmcc  4000  1000  中国联通    5.65
3   2020-04-26  hubei    ctc  2500  1000  中国电信    5.65
4   2020-04-26  hubei   cmcc  2000  1000  中国联通    5.65
5   2020-04-26  hubei    ctc  2100  1600  中国电信    5.65
6   2020-04-27  hunan  cmnet  4000  1700  中国移动    5.65
7   2020-04-27  hunan  cmnet  3200  1500  中国移动    5.65
8   2020-04-27  hunan   cmcc  2800  1600  中国联通    5.65
9   2020-04-27  hubei    ctc  2600  1400  中国电信    5.65
10  2020-04-27  hubei   cmcc  3800  1900  中国联通    5.65
11  2020-04-27  hubei    ctc  2400  1900  中国电信    5.65

>>> dict_prov_names={								#注：将hunan、hubei映射成湖南、湖北
... "hunan":"湖南",
... "hubei":"湖北"}
>>> df['prov']=df['prov'].apply(lambda x :dict_prov_names[x])
>>> df
          date prov    isp    pv    uv  isp1  float1
0   2020-04-26   湖南  cmnet  2000  1000  中国移动    5.65
1   2020-04-26   湖南  cmnet  3000  1500  中国移动    5.65
2   2020-04-26   湖南   cmcc  4000  1000  中国联通    5.65
3   2020-04-26   湖北    ctc  2500  1000  中国电信    5.65
4   2020-04-26   湖北   cmcc  2000  1000  中国联通    5.65
5   2020-04-26   湖北    ctc  2100  1600  中国电信    5.65
6   2020-04-27   湖南  cmnet  4000  1700  中国移动    5.65
7   2020-04-27   湖南  cmnet  3200  1500  中国移动    5.65
8   2020-04-27   湖南   cmcc  2800  1600  中国联通    5.65
9   2020-04-27   湖北    ctc  2600  1400  中国电信    5.65
10  2020-04-27   湖北   cmcc  3800  1900  中国联通    5.65
11  2020-04-27   湖北    ctc  2400  1900  中国电信    5.65

示例：跨列相加

>>> df['total'] = df[['pv','uv']].apply(lambda x: x.sum(), axis=1)	#注：跨列相加，axis=1
>>> df												#注：axis=1 跨列；axis=0 跨行
          date prov    isp    pv    uv  isp1  float1  total
0   2020-04-26   湖南  cmnet  2000  1000  中国移动    5.65   3000
1   2020-04-26   湖南  cmnet  3000  1500  中国移动    5.65   4500
2   2020-04-26   湖南   cmcc  4000  1000  中国联通    5.65   5000
3   2020-04-26   湖北    ctc  2500  1000  中国电信    5.65   3500
4   2020-04-26   湖北   cmcc  2000  1000  中国联通    5.65   3000
5   2020-04-26   湖北    ctc  2100  1600  中国电信    5.65   3700
6   2020-04-27   湖南  cmnet  4000  1700  中国移动    5.65   5700
7   2020-04-27   湖南  cmnet  3200  1500  中国移动    5.65   4700
8   2020-04-27   湖南   cmcc  2800  1600  中国联通    5.65   4400
9   2020-04-27   湖北    ctc  2600  1400  中国电信    5.65   4000
10  2020-04-27   湖北   cmcc  3800  1900  中国联通    5.65   5700
11  2020-04-27   湖北    ctc  2400  1900  中国电信    5.65   4300

示例：跨行相加

>>> df.loc['total'] = df[['pv','uv']].apply(lambda x:x.sum(), axis=0)	#注：跨行相加，axis=0
>>> df
             date prov    isp       pv       uv  isp1  float1   total
0      2020-04-26   湖南  cmnet   2000.0   1000.0  中国移动    5.65  3000.0
1      2020-04-26   湖南  cmnet   3000.0   1500.0  中国移动    5.65  4500.0
2      2020-04-26   湖南   cmcc   4000.0   1000.0  中国联通    5.65  5000.0
3      2020-04-26   湖北    ctc   2500.0   1000.0  中国电信    5.65  3500.0
4      2020-04-26   湖北   cmcc   2000.0   1000.0  中国联通    5.65  3000.0
5      2020-04-26   湖北    ctc   2100.0   1600.0  中国电信    5.65  3700.0
6      2020-04-27   湖南  cmnet   4000.0   1700.0  中国移动    5.65  5700.0
7      2020-04-27   湖南  cmnet   3200.0   1500.0  中国移动    5.65  4700.0
8      2020-04-27   湖南   cmcc   2800.0   1600.0  中国联通    5.65  4400.0
9      2020-04-27   湖北    ctc   2600.0   1400.0  中国电信    5.65  4000.0
10     2020-04-27   湖北   cmcc   3800.0   1900.0  中国联通    5.65  5700.0
11     2020-04-27   湖北    ctc   2400.0   1900.0  中国电信    5.65  4300.0
total         NaN  NaN    NaN  34400.0  17100.0   NaN     NaN     NaN
#注：NaN表示空

示例：数字取整

>>> df[['pv','uv']].applymap(lambda x: int(x))		#注：将这些数字取整数
          pv     uv
0       2000   1000
1       3000   1500
2       4000   1000
3       2500   1000
4       2000   1000
5       2100   1600
6       4000   1700
7       3200   1500
8       2800   1600
9       2600   1400
10      3800   1900
11      2400   1900
total  68800  34200

示例：读取文件

>>> import pandas as pd
>>> df = pd.read_csv("beijing_tianqi_2018.csv")		#注：读取文件
>>> df
            ymd bWendu yWendu tianqi fengxiang fengli  aqi aqiInfo  aqiLevel
0    2018-01-01     3℃    -6℃   晴~多云       东北风   1-2级   59       良         2
1    2018-01-02     2℃    -5℃   阴~多云       东北风   1-2级   49       优         1
2    2018-01-03     2℃    -5℃     多云        北风   1-2级   28       优         1
3    2018-01-04     0℃    -8℃      阴       东北风   1-2级   28       优         1
4    2018-01-05     3℃    -6℃   多云~晴       西北风   1-2级   50       优         1
..          ...    ...    ...    ...       ...    ...  ...     ...       ...
360  2018-12-27    -5℃   -12℃   多云~晴       西北风     3级   48       优         1
361  2018-12-28    -3℃   -11℃      晴       西北风     3级   40       优         1
362  2018-12-29    -3℃   -12℃      晴       西北风     2级   29       优         1
363  2018-12-30    -2℃   -11℃   晴~多云       东北风     1级   31       优         1
364  2018-12-31    -2℃   -10℃     多云       东北风     1级   56       良         2

[365 rows x 9 columns]

示例：转换成整型

>>> df["bWendu"] = df["bWendu"].str.replace("℃","").astype("int32")	#注：转换成整型
>>> df
            ymd  bWendu yWendu tianqi fengxiang fengli  aqi aqiInfo  aqiLevel
0    2018-01-01       3    -6℃   晴~多云       东北风   1-2级   59       良         2
1    2018-01-02       2    -5℃   阴~多云       东北风   1-2级   49       优         1
2    2018-01-03       2    -5℃     多云        北风   1-2级   28       优         1
3    2018-01-04       0    -8℃      阴       东北风   1-2级   28       优         1
4    2018-01-05       3    -6℃   多云~晴       西北风   1-2级   50       优         1
..          ...     ...    ...    ...       ...    ...  ...     ...       ...
360  2018-12-27      -5   -12℃   多云~晴       西北风     3级   48       优         1
361  2018-12-28      -3   -11℃      晴       西北风     3级   40       优         1
362  2018-12-29      -3   -12℃      晴       西北风     2级   29       优         1
363  2018-12-30      -2   -11℃   晴~多云       东北风     1级   31       优         1
364  2018-12-31      -2   -10℃     多云       东北风     1级   56       良         2

[365 rows x 9 columns]

示例：计算温差

>>> df["yWendu"] = df["yWendu"].str.replace("℃", "").astype('int32')
>>> df["wencha"] = df["bWendu"] - df["yWendu"]			#注：计算温差
>>> df
            ymd  bWendu  yWendu tianqi fengxiang fengli  aqi aqiInfo  aqiLevel  wencha
0    2018-01-01       3      -6   晴~多云       东北风   1-2级   59       良         2       9
1    2018-01-02       2      -5   阴~多云       东北风   1-2级   49       优         1       7
2    2018-01-03       2      -5     多云        北风   1-2级   28       优         1       7
3    2018-01-04       0      -8      阴       东北风   1-2级   28       优         1       8
4    2018-01-05       3      -6   多云~晴       西北风   1-2级   50       优         1       9
..          ...     ...     ...    ...       ...    ...  ...     ...       ...     ...
360  2018-12-27      -5     -12   多云~晴       西北风     3级   48       优         1       7
361  2018-12-28      -3     -11      晴       西北风     3级   40       优         1       8
362  2018-12-29      -3     -12      晴       西北风     2级   29       优         1       9
363  2018-12-30      -2     -11   晴~多云       东北风     1级   31       优         1       9
364  2018-12-31      -2     -10     多云       东北风     1级   56       良         2       8

[365 rows x 10 columns]

>>> def get_wendu_type(x):
...     if x["bWendu"] > 33:
...         return "高温"
...     if x["yWendu"] < -10:
...         return "低温"
...     return "常温"
... 
>>> df["wendu_type"] = df.apply(get_wendu_type, axis = 1)
>>> df
            ymd  bWendu  yWendu tianqi fengxiang fengli  aqi aqiInfo  aqiLevel  wencha wendu_type
0    2018-01-01       3      -6   晴~多云       东北风   1-2级   59       良         2       9         常温
1    2018-01-02       2      -5   阴~多云       东北风   1-2级   49       优         1       7         常温
2    2018-01-03       2      -5     多云        北风   1-2级   28       优         1       7         常温
3    2018-01-04       0      -8      阴       东北风   1-2级   28       优         1       8         常温
4    2018-01-05       3      -6   多云~晴       西北风   1-2级   50       优         1       9         常温
..          ...     ...     ...    ...       ...    ...  ...     ...       ...     ...        ...
360  2018-12-27      -5     -12   多云~晴       西北风     3级   48       优         1       7         低温
361  2018-12-28      -3     -11      晴       西北风     3级   40       优         1       8         低温
362  2018-12-29      -3     -12      晴       西北风     2级   29       优         1       9         低温
363  2018-12-30      -2     -11   晴~多云       东北风     1级   31       优         1       9         低温
364  2018-12-31      -2     -10     多云       东北风     1级   56       良         2       8         常温

[365 rows x 11 columns]
>>> df.head()
          ymd  bWendu  yWendu tianqi fengxiang fengli  aqi aqiInfo  aqiLevel  wencha wendu_type
0  2018-01-01       3      -6   晴~多云       东北风   1-2级   59       良         2       9         常温
1  2018-01-02       2      -5   阴~多云       东北风   1-2级   49       优         1       7         常温
2  2018-01-03       2      -5     多云        北风   1-2级   28       优         1       7         常温
3  2018-01-04       0      -8      阴       东北风   1-2级   28       优         1       8         常温
4  2018-01-05       3      -6   多云~晴       西北风   1-2级   50       优         1       9         常温

>>> df["wendu_type"].value_counts()
常温    328
高温     29
低温      8
Name: wendu_type, dtype: int64
>>> df2 = df["wendu_type"].value_counts()
>>> for k,v in df2.iteritems():
...     print(k,v)
... 
常温 328
高温 29
低温 8

示例：获取天气质量信息

>>> df["aqiInfo"].unique()					#注：获取天气质量信息
array(['良', '优', '轻度污染', '中度污染', '重度污染', '严重污染'], dtype=object)
>>> list(df["aqiInfo"].unique())				#注：捞取数据
['良', '优', '轻度污染', '中度污染', '重度污染', '严重污染']

>>> df["wencha_type"] = ""
>>> df.loc[df["bWendu"]-df["yWendu"]>10,"wencha_type"]="温差大"
>>> df.loc[df["bWendu"]-df["yWendu"]<=10,"wencha_type"]="温差正常"
>>> df.head()
          ymd  bWendu  yWendu tianqi fengxiang fengli  aqi aqiInfo  aqiLevel  wencha wendu_type wencha_type
0  2018-01-01       3      -6   晴~多云       东北风   1-2级   59       良         2       9         常温        温差正常
1  2018-01-02       2      -5   阴~多云       东北风   1-2级   49       优         1       7         常温        温差正常
2  2018-01-03       2      -5     多云        北风   1-2级   28       优         1       7         常温        温差正常
3  2018-01-04       0      -8      阴       东北风   1-2级   28       优         1       8         常温        温差正常
4  2018-01-05       3      -6   多云~晴       西北风   1-2级   50       优         1       9         常温        温差正常

示例：Pandas对缺失值的处理

>>> import pandas as pd
>>> df = pd.read_excel("student_excel.xlsx")
>>> df
    Unnamed: 0 Unnamed: 1 Unnamed: 2 Unnamed: 3
0          NaN        NaN        NaN        NaN
1          NaN         姓名         科目         分数
2          NaN         小明         语文         85
3          NaN        NaN         数学         80
4          NaN        NaN         英语         90
5          NaN        NaN        NaN        NaN
6          NaN         小王         语文         85
7          NaN        NaN         数学        NaN
8          NaN        NaN         英语         90
9          NaN        NaN        NaN        NaN
10         NaN         小刚         语文         85
11         NaN        NaN         数学         80
12         NaN        NaN         英语         90

示例：读取excel的时候，忽略前几个空行

>>> df = pd.read_excel("student_excel.xlsx",skiprows = 2)	#注：默认把第一行作为列索引名
>>> df
    Unnamed: 0   姓名   科目    分数
0          NaN   小明   语文  85.0
1          NaN  NaN   数学  80.0
2          NaN  NaN   英语  90.0
3          NaN  NaN  NaN   NaN
4          NaN   小王   语文  85.0
5          NaN  NaN   数学   NaN
6          NaN  NaN   英语  90.0
7          NaN  NaN  NaN   NaN
8          NaN   小刚   语文  85.0
9          NaN  NaN   数学  80.0
10         NaN  NaN   英语  90.0

示例：检测空值

>>> df.isnull()
    Unnamed: 0     姓名     科目     分数
0         True  False  False  False
1         True   True  False  False
2         True   True  False  False
3         True   True   True   True
4         True  False  False  False
5         True   True  False   True
6         True   True  False  False
7         True   True   True   True
8         True  False  False  False
9         True   True  False  False
10        True   True  False  False

>>> df.notnull()
    Unnamed: 0     姓名     科目     分数
0        False   True   True   True
1        False  False   True   True
2        False  False   True   True
3        False  False  False  False
4        False   True   True   True
5        False  False   True  False
6        False  False   True   True
7        False  False  False  False
8        False   True   True   True
9        False  False   True   True
10       False  False   True   True

>>> df["分数"].isnull()
0     False
1     False
2     False
3      True
4     False
5      True
6     False
7      True
8     False
9     False
10    False
Name: 分数, dtype: bool

示例：筛选没有空分数的所有行

>>> df.loc[df["分数"].notnull(), :]
    Unnamed: 0   姓名  科目    分数
0          NaN   小明  语文  85.0
1          NaN  NaN  数学  80.0
2          NaN  NaN  英语  90.0
4          NaN   小王  语文  85.0
6          NaN  NaN  英语  90.0
8          NaN   小刚  语文  85.0
9          NaN  NaN  数学  80.0
10         NaN  NaN  英语  90.0

>>> df.loc[df["分数"].notnull()]
    Unnamed: 0   姓名  科目    分数
0          NaN   小明  语文  85.0
1          NaN  NaN  数学  80.0
2          NaN  NaN  英语  90.0
4          NaN   小王  语文  85.0
6          NaN  NaN  英语  90.0
8          NaN   小刚  语文  85.0
9          NaN  NaN  数学  80.0
10         NaN  NaN  英语  90.0

示例：how --> all 全部为空，就删除列

>>> df.dropna(axis="columns", how="all")
     姓名   科目    分数
0    小明   语文  85.0
1   NaN   数学  80.0
2   NaN   英语  90.0
3   NaN  NaN   NaN
4    小王   语文  85.0
5   NaN   数学   NaN
6   NaN   英语  90.0
7   NaN  NaN   NaN
8    小刚   语文  85.0
9   NaN   数学  80.0
10  NaN   英语  90.0

>>> df.dropna(axis="columns", how="all", inplace=True)	#注：原地修改
>>> df
     姓名   科目    分数
0    小明   语文  85.0
1   NaN   数学  80.0
2   NaN   英语  90.0
3   NaN  NaN   NaN
4    小王   语文  85.0
5   NaN   数学   NaN
6   NaN   英语  90.0
7   NaN  NaN   NaN
8    小刚   语文  85.0
9   NaN   数学  80.0
10  NaN   英语  90.0

示例：how --> any 只要包含，就删除列

>>> df.dropna(axis="columns", how="any")
Empty DataFrame
Columns: []
Index: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

示例：删除掉全是空值的行

>>> df.dropna(axis="index", how="all", inplace=True)
>>> df
     姓名  科目    分数
0    小明  语文  85.0
1   NaN  数学  80.0
2   NaN  英语  90.0
4    小王  语文  85.0
5   NaN  数学   NaN
6   NaN  英语  90.0
8    小刚  语文  85.0
9   NaN  数学  80.0
10  NaN  英语  90.0

>>> df2 = df
>>> df.fillna(0)
    姓名  科目    分数
0   小明  语文  85.0
1    0  数学  80.0
2    0  英语  90.0
4   小王  语文  85.0
5    0  数学   0.0
6    0  英语  90.0
8   小刚  语文  85.0
9    0  数学  80.0
10   0  英语  90.0

>>> df["分数"].fillna(0)		#注：返回的是series
0     85.0
1     80.0
2     90.0
4     85.0
5      0.0
6     90.0
8     85.0
9     80.0
10    90.0
Name: 分数, dtype: float64

示例：将分数列为空的填充为0分

>>> df.fillna({"分数":0},inplace=True)
>>> df
     姓名  科目    分数
0    小明  语文  85.0
1   NaN  数学  80.0
2   NaN  英语  90.0
4    小王  语文  85.0
5   NaN  数学   0.0
6   NaN  英语  90.0
8    小刚  语文  85.0
9   NaN  数学  80.0
10  NaN  英语  90.0

示例：使用前面的有效值填充，用ffill：forward fill 向后填充，用bfill向前填充

>>> df["姓名"].fillna(method="ffill")
0     小明
1     小明
2     小明
4     小王
5     小王
6     小王
8     小刚
9     小刚
10    小刚
Name: 姓名, dtype: object
>>> df["姓名"].fillna(method="bfill")
0      小明
1      小王
2      小王
4      小王
5      小刚
6      小刚
8      小刚
9     NaN
10    NaN

>>> df["姓名"] = df["姓名"].fillna(method="ffill")
>>> df
    姓名  科目    分数
0   小明  语文  85.0
1   小明  数学  80.0
2   小明  英语  90.0
4   小王  语文  85.0
5   小王  数学   0.0
6   小王  英语  90.0
8   小刚  语文  85.0
9   小刚  数学  80.0
10  小刚  英语  90.0

示例：将清洗好的excel保存

>>> df.to_excel("student_test.xlsx",index=False)
姓名	科目	分数
小明	语文	85
小明	数学	80
小明	英语	90
小王	语文	85
小王	数学	0
小王	英语	90
小刚	语文	85
小刚	数学	80
小刚	英语	90
>>> df.to_excel("student_test2.xlsx")
	姓名	科目	分数
0	小明	语文	85
1	小明	数学	80
2	小明	英语	90
4	小王	语文	85
5	小王	数学	0
6	小王	英语	90
8	小刚	语文	85
9	小刚	数学	80
10	小刚	英语	90

示例：Pandas数据排序

>>> df = pd.read_csv("beijing_tianqi_2018.csv")		#注：读取csv文件
>>> df["bWendu"] = df["bWendu"].str.replace("℃","").astype("int") #注：℃替换为空，转整型
>>> df["yWendu"] = df["bWendu"].str.replace("℃","").astype("int")
>>> df["bWendu"].sort_values()
360    -5
23     -4
340    -4
22     -4
362    -3
       ..
177    37
179    37
185    37
180    37
155    38
Name: bWendu, Length: 365, dtype: int64

示例：Series的排序

>>> df["yWendu"].sort_values()
362   -12
360   -12
22    -12
361   -11
359   -11
       ..
204    26
215    27
199    27
212    27
200    27
Name: yWendu, Length: 365, dtype: int64

>>> df["yWendu"].sort_values(ascending=False)		#注：ascending=False 降序
200    27
212    27
199    27
215    27
204    26
       ..
359   -11
361   -11
22    -12
360   -12
362   -12
Name: yWendu, Length: 365, dtype: int64

示例：中文排序

>>> df["tianqi"].sort_values()
225     中雨~小雨
230     中雨~小雨
197    中雨~雷阵雨
196    中雨~雷阵雨
112        多云
        ...  
191    雷阵雨~大雨
219     雷阵雨~阴
335      雾~多云
353         霾
348         霾
Name: tianqi, Length: 365, dtype: object

示例：DataFrame的排序

>>> df.sort_values(by="aqi")		#注：单列排序
            ymd  bWendu  yWendu tianqi fengxiang fengli  aqi aqiInfo  aqiLevel
271  2018-09-29      22      11      晴        北风   3-4级   21       优         1
281  2018-10-09      15       4   多云~晴       西北风   4-5级   21       优         1
249  2018-09-07      27      16      晴       西北风   3-4级   22       优         1
272  2018-09-30      19      13     多云       西北风   4-5级   22       优         1
301  2018-10-29      15       3      晴        北风   3-4级   22       优         1
..          ...     ...     ...    ...       ...    ...  ...     ...       ...
317  2018-11-14      13       5     多云        南风   1-2级  266    重度污染         5
71   2018-03-13      17       5   晴~多云        南风   1-2级  287    重度污染         5
91   2018-04-02      26      11     多云        北风   1-2级  287    重度污染         5
72   2018-03-14      15       6   多云~阴       东北风   1-2级  293    重度污染         5
86   2018-03-28      25       9   多云~晴        东风   1-2级  387    严重污染         6

[365 rows x 9 columns]

>>> df.sort_values(by="aqi", ascending=False)			#注：ascending=False 降序
            ymd  bWendu  yWendu tianqi fengxiang fengli  aqi aqiInfo  aqiLevel
86   2018-03-28      25       9   多云~晴        东风   1-2级  387    严重污染         6
72   2018-03-14      15       6   多云~阴       东北风   1-2级  293    重度污染         5
71   2018-03-13      17       5   晴~多云        南风   1-2级  287    重度污染         5
91   2018-04-02      26      11     多云        北风   1-2级  287    重度污染         5
317  2018-11-14      13       5     多云        南风   1-2级  266    重度污染         5
..          ...     ...     ...    ...       ...    ...  ...     ...       ...
249  2018-09-07      27      16      晴       西北风   3-4级   22       优         1
301  2018-10-29      15       3      晴        北风   3-4级   22       优         1
272  2018-09-30      19      13     多云       西北风   4-5级   22       优         1
271  2018-09-29      22      11      晴        北风   3-4级   21       优         1
281  2018-10-09      15       4   多云~晴       西北风   4-5级   21       优         1

[365 rows x 9 columns]

示例：多列排序

>>> df.sort_values(by=["aqiLevel", "bWendu"])
#注：按空气质量等级、最高温度排序，默认升序
            ymd  bWendu  yWendu tianqi fengxiang fengli  aqi aqiInfo  aqiLevel
360  2018-12-27      -5     -12   多云~晴       西北风     3级   48       优         1
22   2018-01-23      -4     -12      晴       西北风   3-4级   31       优         1
23   2018-01-24      -4     -11      晴       西南风   1-2级   34       优         1
340  2018-12-07      -4     -10      晴       西北风     3级   33       优         1
21   2018-01-22      -3     -10  小雪~多云        东风   1-2级   47       优         1
..          ...     ...     ...    ...       ...    ...  ...     ...       ...
71   2018-03-13      17       5   晴~多云        南风   1-2级  287    重度污染         5
90   2018-04-01      25      11   晴~多云        南风   1-2级  218    重度污染         5
91   2018-04-02      26      11     多云        北风   1-2级  287    重度污染         5
85   2018-03-27      27      11      晴        南风   1-2级  243    重度污染         5
86   2018-03-28      25       9   多云~晴        东风   1-2级  387    严重污染         6

[365 rows x 9 columns]

示例：降序

>>> df.sort_values(by=["aqiLevel", "bWendu"],ascending=False).head(10)
#注：两个字段都是降序
            ymd  bWendu  yWendu tianqi fengxiang fengli  aqi aqiInfo  aqiLevel
86   2018-03-28      25       9   多云~晴        东风   1-2级  387    严重污染         6
85   2018-03-27      27      11      晴        南风   1-2级  243    重度污染         5
91   2018-04-02      26      11     多云        北风   1-2级  287    重度污染         5
90   2018-04-01      25      11   晴~多云        南风   1-2级  218    重度污染         5
71   2018-03-13      17       5   晴~多云        南风   1-2级  287    重度污染         5
306  2018-11-03      16       6     多云        南风   1-2级  206    重度污染         5
72   2018-03-14      15       6   多云~阴       东北风   1-2级  293    重度污染         5
61   2018-03-03      13       3   多云~阴        北风   1-2级  214    重度污染         5
316  2018-11-13      13       5     多云       东南风   1-2级  219    重度污染         5
317  2018-11-14      13       5     多云        南风   1-2级  266    重度污染         5

示例：前面升序，后面降序

>>> df.sort_values(by=["aqiLevel", "bWendu"],ascending=[True,False]).head(10)
#注：分别指定升序和降序
            ymd  bWendu  yWendu  tianqi fengxiang fengli  aqi aqiInfo  aqiLevel
178  2018-06-28      35      24    多云~晴        北风   1-2级   33       优         1
149  2018-05-30      33      18       晴        西风   1-2级   46       优         1
206  2018-07-26      33      25  多云~雷阵雨       东北风   1-2级   40       优         1
158  2018-06-08      32      19  多云~雷阵雨       西南风   1-2级   43       优         1
205  2018-07-25      32      25      多云        北风   1-2级   28       优         1
226  2018-08-15      32      24      多云       东北风   3-4级   33       优         1
231  2018-08-20      32      23    多云~晴        北风   1-2级   41       优         1
232  2018-08-21      32      22      多云        北风   1-2级   38       优         1
148  2018-05-29      31      16      多云       西北风   1-2级   41       优         1
196  2018-07-16      31      24  中雨~雷阵雨        南风   1-2级   43       优         1

示例：实现DataFrame的Merge

>>> left = pd.DataFrame({'A': ['a0', 'a1', 'a2', 'a3'],
...                      'B': ['b0', 'b1', 'b2', 'b3'],
...                      'k1': ['x', 'x', 'y', 'y']})
>>> right = pd.DataFrame({'C': ['c1', 'c2', 'c3', 'c4'],
...                       'D': ['d1', 'd2', 'd3', 'd4'],
...                       'k1': ['y', 'y', 'z', 'z']})
>>> left
    A   B k1
0  a0  b0  x
1  a1  b1  x
2  a2  b2  y
3  a3  b3  y
>>> right
    C   D k1
0  c1  d1  y
1  c2  d2  y
2  c3  d3  z
3  c4  d4  z

示例：合并

>>> pd.merge(left,right)		#注：合并
    A   B k1   C   D			#注：没有接on（不指定），默认找列名相同的列
0  a2  b2  y  c1  d1
1  a2  b2  y  c2  d2
2  a3  b3  y  c1  d1
3  a3  b3  y  c2  d2

>>> pd.merge(left,right, on = "k1")	#注：按k1进行合并
#注：可以用于数据库 分库分表 用索引连接（2张数据表 联合 做数据查询）
    A   B k1   C   D
0  a2  b2  y  c1  d1
1  a2  b2  y  c2  d2
2  a3  b3  y  c1  d1
3  a3  b3  y  c2  d2

示例：指定左、右

>>> pd.merge(left,right, left_on = "A", right_on = "C")
Empty DataFrame
Columns: [A, B, k1_x, C, D, k1_y]
Index: []

示例：one-to-one 一对一关系的merge

>>> left = pd.DataFrame({'sno': [11, 12, 13, 14],
...                       'name': ['name_a', 'name_b', 'name_c', 'name_d']
...                     })
>>> right = pd.DataFrame({'sno': [11, 12, 13, 14],
...                       'age': ['21', '22', '23', '24']
...                     })
>>> pd.merge(left,right,on="sno")
#注：一对一关系，结果中有4条
   sno    name age				#注：数据没有膨胀
0   11  name_a  21
1   12  name_b  22
2   13  name_c  23
3   14  name_d  24

示例：one-to-many 一对多关系的merge

>>> left = pd.DataFrame({'sno': [11, 12, 13, 14],
...                       'name': ['name_a', 'name_b', 'name_c', 'name_d']
...                     })
>>> right = pd.DataFrame({'sno': [11, 11, 11, 12, 12, 13],
...                        'grade': ['语文88', '数学90', '英语75','语文66', '数学55', '英语29']
...                      })
>>> pd.merge(left, right, on='sno')
#注：数目以多的一边为准
   sno    name grade				#注：name数据膨胀
0   11  name_a  语文88
1   11  name_a  数学90
2   11  name_a  英语75
3   12  name_b  语文66
4   12  name_b  数学55
5   13  name_c  英语29

示例：many-to-many 多对多关系的merge

>>> left = pd.DataFrame({'sno': [11, 11, 12, 12,12],
...                       '爱好': ['篮球', '羽毛球', '乒乓球', '篮球', "足球"]
...                     })
>>> right = pd.DataFrame({'sno': [11, 11, 11, 12, 12, 13],
...                        'grade': ['语文88', '数学90', '英语75','语文66', '数学55', '英语29']
...                      })
>>> pd.merge(left, right, on='sno')
    sno   爱好 grade
0    11   篮球  语文88
1    11   篮球  数学90
2    11   篮球  英语75
3    11  羽毛球  语文88
4    11  羽毛球  数学90
5    11  羽毛球  英语75
6    12  乒乓球  语文66
7    12  乒乓球  数学55
8    12   篮球  语文66
9    12   篮球  数学55
10   12   足球  语文66
11   12   足球  数学55

示例：left join、right join、inner join、outer join的区别

>>> left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
...                       'A': ['A0', 'A1', 'A2', 'A3'],
...                       'B': ['B0', 'B1', 'B2', 'B3']})
>>> 
>>> right = pd.DataFrame({'key': ['K0', 'K1', 'K4', 'K5'],
...                       'C': ['C0', 'C1', 'C4', 'C5'],
...                       'D': ['D0', 'D1', 'D4', 'D5']})
>>> left
  key   A   B
0  K0  A0  B0
1  K1  A1  B1
2  K2  A2  B2
3  K3  A3  B3
>>> right
  key   C   D
0  K0  C0  D0
1  K1  C1  D1
2  K4  C4  D4
3  K5  C5  D5

示例：连表查询
示例：取交集

>>> pd.merge(left, right, how="inner")
#注：inner join，默认  inner取交集
  key   A   B   C   D
0  K0  A0  B0  C0  D0
1  K1  A1  B1  C1  D1
>>> pd.merge(left,right)
#注：inner join，默认
  key   A   B   C   D
0  K0  A0  B0  C0  D0
1  K1  A1  B1  C1  D1

示例：以左边为基准

>>> pd.merge(left, right, how="left")
#注：左边的都会出现在结果里，右边的如果无法匹配则为Null
  key   A   B    C    D
0  K0  A0  B0   C0   D0
1  K1  A1  B1   C1   D1
2  K2  A2  B2  NaN  NaN
3  K3  A3  B3  NaN  NaN

示例：以右边为基准

>>> pd.merge(left, right, how="right")
#注：右边的都会出现在结果里，左边的如果无法匹配则为Null
  key    A    B   C   D
0  K0   A0   B0  C0  D0
1  K1   A1   B1  C1  D1
2  K4  NaN  NaN  C4  D4
3  K5  NaN  NaN  C5  D5

示例：取并集

>>> pd.merge(left, right, how="outer")
#注：左边、右边的都会出现在结果里，如果无法匹配则为Null
  key    A    B    C    D
0  K0   A0   B0   C0   D0
1  K1   A1   B1   C1   D1
2  K2   A2   B2  NaN  NaN
3  K3   A3   B3  NaN  NaN
4  K4  NaN  NaN   C4   D4
5  K5  NaN  NaN   C5   D5

示例：如果出现非Key的字段重名怎么办

>>> left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
...                       'A': ['A0', 'A1', 'A2', 'A3'],
...                       'B': ['B0', 'B1', 'B2', 'B3']})
>>> 
>>> right = pd.DataFrame({'key': ['K0', 'K1', 'K4', 'K5'],
...                       'A': ['A10', 'A11', 'A12', 'A13'],
...                       'D': ['D0', 'D1', 'D4', 'D5']})
>>> left
  key   A   B
0  K0  A0  B0
1  K1  A1  B1
2  K2  A2  B2
3  K3  A3  B3
>>> right
  key    A   D
0  K0  A10  D0
1  K1  A11  D1
2  K4  A12  D4
3  K5  A13  D5

示例：不指定，以key、A为准，取交集

>>> pd.merge(left,right)
Empty DataFrame
Columns: [key, A, B, D]
Index: []

示例：outer 取并集

>>> pd.merge(left,right,how="outer")
  key    A    B    D
0  K0   A0   B0  NaN
1  K1   A1   B1  NaN
2  K2   A2   B2  NaN
3  K3   A3   B3  NaN
4  K0  A10  NaN   D0
5  K1  A11  NaN   D1
6  K4  A12  NaN   D4
7  K5  A13  NaN   D5

示例：指定key作为合并项

>>> pd.merge(left,right,on="key")
  key A_x   B  A_y   D			#注：自动改名 A_x、A_y
0  K0  A0  B0  A10  D0
1  K1  A1  B1  A11  D1

示例：指定名字

>>> pd.merge(left,right,on="key",suffixes= ("_left","_right"))
  key A_left   B A_right   D
0  K0     A0  B0     A10  D0
1  K1     A1  B1     A11  D1

示例：使用pandas.concat合并数据

>>> df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
...                     'B': ['B0', 'B1', 'B2', 'B3'],
...                     'C': ['C0', 'C1', 'C2', 'C3'],
...                     'D': ['D0', 'D1', 'D2', 'D3'],
...                     'E': ['E0', 'E1', 'E2', 'E3']
...                    })
>>> df1
    A   B   C   D   E
0  A0  B0  C0  D0  E0
1  A1  B1  C1  D1  E1
2  A2  B2  C2  D2  E2
3  A3  B3  C3  D3  E3
>>> df2 = pd.DataFrame({ 'A': ['A4', 'A5', 'A6', 'A7'],
...                      'B': ['B4', 'B5', 'B6', 'B7'],
...                      'C': ['C4', 'C5', 'C6', 'C7'],
...                      'D': ['D4', 'D5', 'D6', 'D7'],
...                      'F': ['F4', 'F5', 'F6', 'F7']
...                    })

>>> pd.concat([df1,df2])
    A   B   C   D    E    F
0  A0  B0  C0  D0   E0  NaN
1  A1  B1  C1  D1   E1  NaN
2  A2  B2  C2  D2   E2  NaN
3  A3  B3  C3  D3   E3  NaN
0  A4  B4  C4  D4  NaN   F4
1  A5  B5  C5  D5  NaN   F5
2  A6  B6  C6  D6  NaN   F6
3  A7  B7  C7  D7  NaN   F7

示例

>>> pd.concat([df1,df2],join="inner")
    A   B   C   D
0  A0  B0  C0  D0
1  A1  B1  C1  D1
2  A2  B2  C2  D2
3  A3  B3  C3  D3
0  A4  B4  C4  D4
1  A5  B5  C5  D5
2  A6  B6  C6  D6
3  A7  B7  C7  D7

示例：使用axis=1相当于添加新列

>>> pd.concat([df1,df2],join="inner",axis=1)
    A   B   C   D   E   A   B   C   D   F
0  A0  B0  C0  D0  E0  A4  B4  C4  D4  F4
1  A1  B1  C1  D1  E1  A5  B5  C5  D5  F5
2  A2  B2  C2  D2  E2  A6  B6  C6  D6  F6
3  A3  B3  C3  D3  E3  A7  B7  C7  D7  F7

示例：实现groupby分组统计

>>> import numpy as np
>>> df = pd.DataFrame({'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
...                    'B': ['one', 'one', 'two', 'three', 'two', 'two', 'one', 'three'],
...                    'C': np.random.rand(8),
...                    'D': np.random.rand(8)})
>>> df
     A      B         C         D
0  foo    one  0.121901  0.287036
1  bar    one  0.948392  0.798273
2  foo    two  0.587470  0.518587
3  bar  three  0.276975  0.525895
4  foo    two  0.187134  0.861137
5  bar    two  0.172976  0.500381
6  foo    one  0.434220  0.927708
7  foo  three  0.888253  0.544456

示例：得到A列元素

>>> df["A"].unique()
array(['foo', 'bar'], dtype=object)
>>> df["B"].unique()
array(['one', 'two', 'three'], dtype=object)

示例：A这列的元素进行分组，然后进行数据统计

>>> df.groupby("A").sum()
            C         D
A                      
bar  1.398343  1.824549
foo  2.218979  3.138924
#注：用途，按学科进行分组，统计每门学科的情况

示例：分组统计，求最大值

>>> df.groupby("A").max()
       B         C         D
A                           
bar  two  0.948392  0.798273
foo  two  0.888253  0.927708

示例：多个列groupby，查询所有数据列的统计

>>> df.groupby(["A","B"]).mean()
                  C         D
A   B                        
bar one    0.948392  0.798273
    three  0.276975  0.525895
    two    0.172976  0.500381
foo one    0.278061  0.607372
    three  0.888253  0.544456
    two    0.387302  0.689862

示例：as_index=False 使A、B不作为索引

>>> df.groupby(["A","B"], as_index=False).mean()
     A      B         C         D
0  bar    one  0.948392  0.798273
1  bar  three  0.276975  0.525895
2  bar    two  0.172976  0.500381
3  foo    one  0.278061  0.607372
4  foo  three  0.888253  0.544456
5  foo    two  0.387302  0.689862

示例：同时查看多种数据统计

>>> df.groupby('A').agg([np.sum, np.mean, np.std])
#注：求 和、平均值、标准差
            C                             D                    
          sum      mean       std       sum      mean       std
A                                                              
bar  1.398343  0.466114  0.420890  1.824549  0.608183  0.165116
foo  2.218979  0.443796  0.311355  3.138924  0.627785  0.264284

示例：查看单列的结果数据统计

>>> df.groupby('A')['C'].agg([np.sum, np.mean, np.std])
          sum      mean       std
A                                
bar  1.398343  0.466114  0.420890
foo  2.218979  0.443796  0.311355

示例：不同列使用不同的聚合函数

>>> df.groupby('A').agg({"C":np.sum, "D":np.mean})
#注：C列求和、D列求平均
            C         D
A                      
bar  1.398343  0.608183
foo  2.218979  0.627785

示例：实例分组探索天气数据

>>> df = pd.read_csv("beijing_tianqi_2018.csv")

示例：替换掉温度的后缀℃

>>> df.loc[:, "bWendu"] = df["bWendu"].str.replace("℃", "").astype('int32')
>>> df.loc[:, "yWendu"] = df["yWendu"].str.replace("℃", "").astype('int32')
>>> df.head()
          ymd  bWendu  yWendu tianqi fengxiang fengli  aqi aqiInfo  aqiLevel
0  2018-01-01       3      -6   晴~多云       东北风   1-2级   59       良         2
1  2018-01-02       2      -5   阴~多云       东北风   1-2级   49       优         1
2  2018-01-03       2      -5     多云        北风   1-2级   28       优         1
3  2018-01-04       0      -8      阴       东北风   1-2级   28       优         1
4  2018-01-05       3      -6   多云~晴       西北风   1-2级   50       优         1

示例：新增一列为月份

>>> df['month'] = df['ymd'].str[:7]
>>> df.head()
          ymd  bWendu  yWendu tianqi fengxiang fengli  aqi aqiInfo  aqiLevel    month
0  2018-01-01       3      -6   晴~多云       东北风   1-2级   59       良         2  2018-01
1  2018-01-02       2      -5   阴~多云       东北风   1-2级   49       优         1  2018-01
2  2018-01-03       2      -5     多云        北风   1-2级   28       优         1  2018-01
3  2018-01-04       0      -8      阴       东北风   1-2级   28       优         1  2018-01
4  2018-01-05       3      -6   多云~晴       西北风   1-2级   50       优         1  2018-01

示例：查看每个月的最高温度

>>> data = df.groupby('month')['bWendu'].max()
>>> data
month
2018-01     7
2018-02    12
2018-03    27
2018-04    30
2018-05    35
2018-06    38
2018-07    37
2018-08    36
2018-09    31
2018-10    25
2018-11    18
2018-12    10
Name: bWendu, dtype: int32

示例：Pandas处理日期数据

>>> df.dtypes
ymd          object
bWendu        int32
yWendu        int32
tianqi       object
fengxiang    object
fengli       object
aqi           int64
aqiInfo      object
aqiLevel      int64
month        object
dtype: object
>>> pd.to_datetime(df["ymd"], format="%Y-%m-%d")
0     2018-01-01
1     2018-01-02
2     2018-01-03
3     2018-01-04
4     2018-01-05
         ...    
360   2018-12-27
361   2018-12-28
362   2018-12-29
363   2018-12-30
364   2018-12-31
Name: ymd, Length: 365, dtype: datetime64[ns]

示例：生成日期范围

>>> pd.date_range(start='201801010100',end='201801100100', freq='2D')
#注：2D表示2天
DatetimeIndex(['2018-01-01 01:00:00', '2018-01-03 01:00:00',
               '2018-01-05 01:00:00', '2018-01-07 01:00:00',
               '2018-01-09 01:00:00'],
              dtype='datetime64[ns]', freq='2D')

mycpen

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
27_python笔记-pandas

Python pandas个人博客https://blog.csdn.net/cPen_web示例：仅有数据列表即可产生最简单的Series>>> import pandas as pd>>> import numpy as np>>> s1 = pd.Series([1,'a',5.2,"x"])>>> s1# 左侧为索引，右侧是数据0 11 a2 5.23 xdtype:
复制链接

扫一扫