Pandas 数据分析-第二章(Pandas数据结构Dataframe)

Pandas 数据分析-第二章(Pandas入门:数据结构Dataframe)

第一章:Pandas数据结构Series
上面附上了一篇Series的文章,在看Dataframe之前必须先明白什么是Series。

DataFrame

DataFrame是一个表格型的数据结构(表格嘛你懂的)。每列可以诗不同的值类型(数值,字符串,布尔值)也可以理解为由Series组成的字典,回顾一下Series,Series是一个一维数组,带有索引的一维数组。DataFrame可以理解为Series组成的‘字典’。其实呢DataFrame中的数据是以一个或多个二维块存放的(并非列表字典),当然了具体是啥这里讨论毫无意义,最重要的是DataFrame是怎么使用的,再多说一句DataFrame是真的非常好用,非常好用,非常!好用!这么干巴巴说了半天,具体的例子看一下你就明白了。

构建DataFrame的方法有很多,最常用的就是传入一个字典(列表也可以)

In [34]: data = {'location':['beijing','hebei','tianjin','shandong'],'year':[2011,2013,2019,1998],'num':[1.4,1.8,-2.1,3.6]}                                                                                  

In [35]: data                                                                                                                                                                                                
Out[35]: 
{'location': ['beijing', 'hebei', 'tianjin', 'shandong'],
 'year': [2011, 2013, 2019, 1998],
 'num': [1.4, 1.8, -2.1, 3.6]}

In [36]: df = pd.DataFrame(data)                                                                                                                                                                             

In [37]: df                                                                                                                                                                                                  
Out[37]: 
   location  year  num
0   beijing  2011  1.4
1     hebei  2013  1.8
2   tianjin  2019 -2.1
3  shandong  1998  3.6

传入的字典也有限制,所有字典的‘值’必须是等长的列表或Series。
字典的键生成columns,当然我们也可以自己设置index和columns。

In [50]: data = {'location':['beijing','hebei','tianjin','shandong'],'year':[2011,2013,2019,1998],'num':[1.4,1.8,-2.1,3.6]}                                                                                  

In [51]: df = pd.DataFrame(data,index=['a','b','c','d'],columns=['year','num','location','shit'])                                                                                                            

In [52]: df                                                                                                                                                                                                  
Out[52]: 
   year  num  location shit
a  2011  1.4   beijing  NaN
b  2013  1.8     hebei  NaN
c  2019 -2.1   tianjin  NaN
d  1998  3.6  shandong  NaN

通过修改columns的顺序可以控制列的顺序,如果传入的列在数据中找不到,就会产生NA值。

通过字典的方法可以将DataFrame的列获取为一个Series。

In [53]: df['year']                                                                                                                                                                                          
Out[53]: 
a    2011
b    2013
c    2019
d    1998
Name: year, dtype: int64

In [54]: df.location                                                                                                                                                                                         
Out[54]: 
a     beijing
b       hebei
c     tianjin
d    shandong
Name: location, dtype: object

那么你会问取一行怎么取呢

In [55]: df.ix['a']                                                                                                                                                                                          
/Users/gn/anaconda3/bin/ipython:1: DeprecationWarning: 
.ix is deprecated. Please use
.loc for label based indexing or
.iloc for positional indexing

See the documentation here:
http://pandas.pydata.org/pandas-docs/stable/indexing.html#ix-indexer-is-deprecated
  #!/Users/gn/anaconda3/bin/python
Out[55]: 
year           2011
num             1.4
location    beijing
shit            NaN
Name: a, dtype: object

虽然这个ix方法还可以使用,不过已经推荐我们使用.loc 和.iloc了,看一下这两个方法

In [56]: df.loc['a']                                                                                                                                                                                         
Out[56]: 
year           2011
num             1.4
location    beijing
shit            NaN
Name: a, dtype: object

这个和上面的ix是一样的,以索引名取值,取出来的Series的索引也已经设置好了,是不是很方便?

再看一下上面推荐的.iloc

In [57]: df.iloc[1]                                                                                                                                                                                          
Out[57]: 
year         2013
num           1.8
location    hebei
shit          NaN
Name: b, dtype: object

In [58]: df.iloc[:2]                                                                                                                                                                                         
Out[58]: 
   year  num location shit
a  2011  1.4  beijing  NaN
b  2013  1.8    hebei  NaN

原来这个.iloc类似于列表的切片,.iloc取值并非根据索引名,而是通过给其顺序来切片完成的取值。这两个方法这里只是简单的介绍一下,后面还会自己说。

之前,我们的DataFrame有一列所有的值都是NA,我们可以给这列赋值,

In [61]: df['shit']=10.1                                                                                                                                                                                     

In [62]: df                                                                                                                                                                                                  
Out[62]: 
   year  num  location  shit
a  2011  1.4   beijing  10.1
b  2013  1.8     hebei  10.1
c  2019 -2.1   tianjin  10.1
d  1998  3.6  shandong  10.1

也可以这样,直接将Series传入

In [64]: df['shit'] = np.arange(4)                                                                                                                                                                           

In [65]: df                                                                                                                                                                                                  
Out[65]: 
   year  num  location  shit
a  2011  1.4   beijing     0
b  2013  1.8     hebei     1
c  2019 -2.1   tianjin     2
d  1998  3.6  shandong     3

也可以传入一个列表

In [66]: df['shit'] = [3,2,1,1]                                                                                                                                                                              

In [67]: df                                                                                                                                                                                                  
Out[67]: 
   year  num  location  shit
a  2011  1.4   beijing     3
b  2013  1.8     hebei     2
c  2019 -2.1   tianjin     1
d  1998  3.6  shandong     1

传入的值是Series时,是按照index来匹配的

In [68]: df['shit'] = pd.Series([1,2,3,4],index=['d','c','b','a',])                                                                                                                                          

In [69]: df                                                                                                                                                                                                  
Out[69]: 
   year  num  location  shit
a  2011  1.4   beijing     4
b  2013  1.8     hebei     3
c  2019 -2.1   tianjin     2
d  1998  3.6  shandong     1

那你你会问直接传字典行不行呢?

In [70]: df['shit'] = {'a':1.1,'b':2.2,'c':3.3,'d':4.4}                                                                                                                                                      

In [71]: df                                                                                                                                                                                                  
Out[71]: 
   year  num  location shit
a  2011  1.4   beijing    a
b  2013  1.8     hebei    b
c  2019 -2.1   tianjin    c
d  1998  3.6  shandong    d

emm,看来不行 大家可以自行尝试但是有一些前提
1.长度必须跟DataFrame的长度匹配(多了就报错少了可以)
2.列表可以 字典却只能把键赋值过去
3.如果是赋值的Series长度少于DataFrame的化,缺少的值就是NA。

我们看一下Series长度少于DataFrame的情况

In [74]: df                                                                                                                                                                                                  
Out[74]: 
   year  num  location  shit
a  2011  1.4   beijing   NaN
b  2013  1.8     hebei   3.0
c  2019 -2.1   tianjin   2.0
d  1998  3.6  shandong   1.0

总体来说给DataFrame赋值还是比较方便的。

为了拓宽一下视野,这个给DataFrame赋值我还可以这样用

In [75]: df['new'] = df['year'] > 2000                                                                                                                                                                       

In [76]: df                                                                                                                                                                                                  
Out[76]: 
   year  num  location  shit    new
a  2011  1.4   beijing   NaN   True
b  2013  1.8     hebei   3.0   True
c  2019 -2.1   tianjin   2.0   True
d  1998  3.6  shandong   1.0  False

意思是我创建了名为‘new’的新列,这列的数据是df[‘year’] >2000,很显然后面这个是一个布尔值(DataFrame当然可以存放布尔值啦),意义是year是否大于2000,大于返回True,小于等于返回False。
那我们筛选一下看看

In [77]: df[df['new'] == True]                                                                                                                                                                               
Out[77]: 
   year  num location  shit   new
a  2011  1.4  beijing   NaN  True
b  2013  1.8    hebei   3.0  True
c  2019 -2.1  tianjin   2.0  True

关于DataFrame的修改其实还是有挺多正确和错误的用法
详细的信息:DataFrame赋值
英语不好也不影响,毕竟看代码就可以了。。
这一节主要讲的诗如何创建DataFrame,如何修改它,顺便简单学了学切片和取值。之后的是DataFrame的索引对象,知识点很多也很杂。总之加油吧

你可能感兴趣的:(Pandas,DataFrame,Pandas,Python)