pandas基础(1)_Series和DataFrame

1：pandas简介

Python Data Analysis Library 或 pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和方法。你很快就会发现，它是使Python成为强大而高效的数据分析环境的重要因素之一。

2：Series和DataFrame（）

1：Series:是一种类似于一维数组的对象，由下面两个部分组成：

Values:一组数据值（ndarray）类型

Index：相关的数据索引标签、

2：Series的创建方法

（1）由列表和numpy数组创建

>>> s=Series([1,3,4,5])

>>> s

0 1

1 3

2 4

3 5

dtype: int64

>>> #会自动将索引打印出来

>>> s.index=list('abcd')

>>> s

a 1

b 3

c 4

d 5

dtype: int64

>>> #使索引变成了字母abcd

>>> s = Series([1,2,3,4],index=['mike','sana','luna','la'])

>>> s

mike 1

sana 2

luna 3

la 4

dtype: int64

>>> #Series里面的数据是一维的

（2）由字典创建

>>> #Series里面的数据是一维的

>>> s1=Series({'a':1,'b':2})

>>> s1

a 1

b 2

dtype: int64

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

3：Series的索引

（1）显示索引

>>> s=Series(np.random.random(10),index=list('abcdefghig'))

>>> s

a 0.370897

b 0.993346

c 0.148304

d 0.456316

e 0.365877

f 0.424124

g 0.685219

h 0.694954

i 0.563674

g 0.982072

dtype: float64

>>> s['a']#使用index作为索引值

0.37089735452082695

>>> s.loc['a']#使用,loc方法显示获取索引

0.37089735452082695

>>> s[0]

0.37089735452082695

>>> s.loc[0]#因为是显示索引会报错

Traceback (most recent call last):

File "<pyshell#59>", line 1, in <module>

s.loc[0]#因为是显示索引会报错

>>> s.iloc[0]

0.37089735452082695

>>> #因为此时是隐式索引所以不会报错，，隐式索引默认为0,1，2.......

>>> s.loc['a':'e']

a 0.370897

b 0.993346

c 0.148304

d 0.456316

e 0.365877

dtype: float64

>>> #切片处理

>>>

Series的基本概念

可以把Series看成一个定长的有序字典

可以通过shape，size，index，values,,等得到series的属性

>>> s.shape

(10L,)

>>> s.size

>>> s.index

Index([u'a', u'b', u'c', u'd', u'e', u'f', u'g', u'h', u'i', u'g'], dtype='object')

>>> s.values

array([0.37089735, 0.99334641, 0.14830394, 0.45631575, 0.36587742,

0.42412389, 0.68521869, 0.69495357, 0.56367448, 0.98207233])

>>> #Series，values，就是一个ndrray包含关系，升级的关系，有了索引更方便

>>> s.shape

(10L,)

>>> s.head

<bound method Series.head of a 0.370897

b 0.993346

c 0.148304

d 0.456316

e 0.365877

f 0.424124

g 0.685219

h 0.694954

i 0.563674

g 0.982072

dtype: float64>

>>> s.tail

<bound method Series.tail of a 0.370897

b 0.993346

c 0.148304

d 0.456316

e 0.365877

f 0.424124

g 0.685219

h 0.694954

i 0.563674

g 0.982072

dtype: float64>

>>> #Series对象本身实例有一个name属性

>>> s.name="列名"

>>> s

a 0.370897

b 0.993346

c 0.148304

d 0.456316

e 0.365877

f 0.424124

g 0.685219

h 0.694954

i 0.563674

g 0.982072

Name: ????, dtype: float64

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、’

4：Series的运算

>>> s.add(10,fill_value=0)#在进行算数运算时，如果包含nan ，那么fill_value默认设置为fill_value值

a 10.370897

b 10.993346

c 10.148304

d 10.456316

e 10.365877

f 10.424124

g 10.685219

h 10.694954

i 10.563674

g 10.982072

Name: ????, dtype: float64

>>> #Series之间的运算

>>> s1=Series([2,4,7,9],index=[0,1,2,3])

>>> s2=Series([1,2,3,4],index=[2,3,4,5])

>>> s1+s2#Series索引值，进行相加时，就是索引值进行相加

0 NaN

1 NaN

2 8.0

3 11.0

4 NaN

5 NaN

dtype: float64

>>> #要保留所有的index，必须使用.add()函数

>>> s1.add(s2,fill_value=0)

0 2.0

1 4.0

2 8.0

3 11.0

4 3.0

5 4.0

dtype: float64

>>> s1.add(s2)

0 NaN

1 NaN

2 8.0

3 11.0

4 NaN

5 NaN

dtype: float64

>>> #因为不同的Series存在不同的索引值，所以当对应另一个Series不存在该索引时要把fill_value定义为0

>>> s=Series([1,2,None])

>>> nd=np.array([1,2,None])

>>> s.sum()

3.0

>>> nd.sum()#会报错，因为有非数字，没办法进行计算

Traceback (most recent call last):

File "<pyshell#89>", line 1, in <module>

nd.sum()#会报错，因为有非数字

File "E:\Python\lib\site-packages\numpy\core\_methods.py", line 32, in _sum

return umr_sum(a, axis, dtype, out, keepdims)

TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

>>> #ndarray中如果有nan,没有办法进行计算，而Series可以

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

5：DataFrame的定义

DataFrame是一个【表格型】的数据结构，可以看做是【由Series组成的字典】公用一个索引。DataFrame由按一定顺序排列的多列数据。设计初衷是将Series的使用场景从一维扩展到多维，DataFrame既有行索引，也有列索引

行索引：index

列索引：column

值：values（numpy的二维数组）

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

6：DataFrame的创建：

最常用的方法是由一个字典来创建，DataFrame以字典的建作为每一{列}的名称。以字典的值作为每一列

此外，dataframe和Series一样会自动为每一行加索引，相应值为nan

>>> df= DataFrame({'height':[175,180,169,188],'age':np.random.randint(18,25,size=4),'sex':['boy','girl','boy','girl']})

>>> df

age height sex

0 22 175 boy

1 20 180 girl

2 22 169 boy

3 20 188 girl

>>> df= DataFrame({'height':[175,180,169,188],'age':np.random.randint(18,25,size=4),'sex':['boy','girl','boy','girl']},index=list('ABCD'),columns=['height','age','sex','weight'])

>>> df

height age sex weight #weight默认为nan

A 175 19 boy NaN

B 180 23 girl NaN

C 169 21 boy NaN

D 188 18 girl NaN

>>> df.shape

(4, 4)

>>> df.values

array([[175L, 19, 'boy', nan],

[180L, 23, 'girl', nan],

[169L, 21, 'boy', nan],

[188L, 18, 'girl', nan]], dtype=object)

>>> df.columns

Index([u'height', u'age', u'sex', u'weight'], dtype='object')

>>> df.index

Index([u'A', u'B', u'C', u'D'], dtype='object')

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

7：DataFrame的索引

（1）对列进行索引

。通过类似字典的方式

。通过属性的方式

>>> df['age']

A 19

B 23

C 21

D 18

Name: age, dtype: int32

>>> #检索列返回值是Series

>>>

>>> df.age

A 19

B 23

C 21

D 18

Name: age, dtype: int32

>>> #对于DataFrame,列名，就相当于属性，

>>> #DataFrame是统计数据时，用的表格，某一个事物属性，每个属性对应Dataframe列名

>>> df['A']#该方法无法检索行，会报错

>>> #使用.loc[]加index来进行索引

>>> #使用.ix[]来进行索引，（过时）

>>> #使用iloc[]加整数来进行索引

>>> #对于行进行索引，返回值也是Series

>>> df.loc[['A','B']]

height age sex weight

A 175 19 boy NaN

B 180 23 girl NaN

>>> #!!!['A','B'],如果检索多行，返回的数据就是DataFrame

>>> df.loc['A':'C']

height age sex weight

A 175 19 boy NaN

B 180 23 girl NaN

C 169 21 boy NaN

>>> #从A到C左闭右闭

>>> df['height':'age']#对列是不可以进行切片的

Empty DataFrame

Columns: [height, age, sex, weight]

Index: []

>>> df.iloc[1:3]#隐式索引

height age sex weight

B 180 23 girl NaN

C 169 21 boy NaN

>>> #左开右闭

#！！！，DataFrame自身有bug，索引是汉字，有时无法检索

>>> df['sex']#直接用中括号时，索引表示的是列索引，切片表示的是行切片

A boy

B girl

C boy

D girl

Name: sex, dtype: object

>>> df['sex']['A':'B']

A boy

B girl

Name: sex, dtype: object

>>> df['sex']['A':'B']=['男','女']

>>> df

height age sex weight

A 175 19 ?? NaN

B 180 23 ? NaN

C 169 21 boy NaN

D 188 18 girl NaN

>>> df.loc['C','height']

169

>>> #检索行的时候，参数可以是多个

>>> #但是列无法完成该类型的操作

>>> df.values[0,2]

'\xc4\xd0'

>>> '\xc5\xae'#通过坐标进行检索

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

8：DataFrame的计算

de1=DataFrame(np.random.randint(0,150,size=(5,4)),index=['A','B','C','D','E'],columns=['a','b','c','e'])

>>> de1

a b c e

A 113 143 22 28

B 102 120 80 144

C 37 36 120 80

D 134 82 65 96

E 49 51 46 23

>>> de2=DataFrame(np.random.randint(0,150,size=(4,4)),index=['A','B','C','D'],columns=['a','b','c','e'])

>>> de2

a b c e

A 35 13 90 11

B 58 63 59 38

C 18 56 49 111

D 142 24 29 33

>>> de2.add(de1)

a b c e

A 148.0 156.0 112.0 39.0

B 160.0 183.0 139.0 182.0

C 55.0 92.0 169.0 191.0

D 276.0 106.0 94.0 129.0

E NaN NaN NaN NaN

>>> de2.add(de1,fill_value=0)

a b c e

A 148.0 156.0 112.0 39.0

B 160.0 183.0 139.0 182.0

C 55.0 92.0 169.0 191.0

D 276.0 106.0 94.0 129.0

E 49.0 51.0 46.0 23.0

>>> #fillvalue=0可以避免出现nan的情况

>>> de1+de2

a b c e

A 148.0 156.0 112.0 39.0

B 160.0 183.0 139.0 182.0

C 55.0 92.0 169.0 191.0

D 276.0 106.0 94.0 129.0

E NaN NaN NaN NaN

>>> de1=DataFrame(np.random.randint(0,150,size=(3,3)),index=['A','B','C'],columns=['a','b','c'])

>>> de1

a b c

A 140 4 101

B 120 101 127

C 127 71 91

>>> de2

a b c e

A 35 13 90 11

B 58 63 59 38

C 18 56 49 111

D 142 24 29 33

>>> de1.add(de2)

a b c e

A 175.0 17.0 191.0 NaN

B 178.0 164.0 186.0 NaN

C 145.0 127.0 140.0 NaN

D NaN NaN NaN NaN

>>> #无论是行索引还是列索引缺少了都要加NaN

>>> de1['a'].loc['A']=100

>>> de1

a b c

A 100 4 101

B 120 101 127

C 127 71 91

>>> de1['a']

A 100

B 120

C 127

Name: a, dtype: int32

>>> s1=de1['a']

>>> s1+de1

A B C a b c

A NaN NaN NaN NaN NaN NaN

B NaN NaN NaN NaN NaN NaN

C NaN NaN NaN NaN NaN NaN

>>> #对s1因为是Series索引是A,B,C，对于de1索引是a,b,c

>>> s2=de1.loc['A']

>>> s2

a 100

b 4

c 101

Name: A, dtype: int32

>>> s2+de1

a b c

A 200 8 202

B 220 105 228

C 227 75 192

>>> #列索引相同所以可以相加

>>> s2.index

Index([u'a', u'b', u'c'], dtype='object')

>>> de1.columns

Index([u'a', u'b', u'c'], dtype='object')

>>>

Python提供的函数：

+ add()

- sub(),或者multily()

* mul(),multiply()

/ truediv(),div(),divide()

// floordiv()

% mod()

** pow()

>>> ss=de1['a']

>>> ss

A 100

B 120

C 127

Name: a, dtype: int32

>>> de1.add(ss)

A B C a b c

A NaN NaN NaN NaN NaN NaN

B NaN NaN NaN NaN NaN NaN

C NaN NaN NaN NaN NaN NaN

>>> de1.add(ss,axis='index')#ss的索引变成a,b,c

a b c

A 200 104 201

B 240 221 247

C 254 198 218

>>> de1.add(ss,axis=0)

a b c

A 200 104 201

B 240 221 247

C 254 198 218

>>> de1.add(ss,axis=1)

A B C a b c

A NaN NaN NaN NaN NaN NaN

B NaN NaN NaN NaN NaN NaN

C NaN NaN NaN NaN NaN NaN

>>> #如果axis是零，则行是索引，所有列都有效

>>> #以列为单位进行操作，对所有列都有效，同理axis=1相反

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

9:DataFrame丢失数据的处理

处理丢失数据

有两种丢失数据 1 none 2 np.nan(NaN)

np.arange(0,10000)

#相同的计算，int运算的时间少于float，更少与object

Pandas中None与NaN都被视为np.nan

df = DataFrame({'age':[20,21,23,19,22],'salary':[10000,20000,11001,10101,21000]},index=['a','b','c','d','e'],columns=['age','salary','work'])

>>> df

age salary work

a 20 10000 NaN

b 21 20000 NaN

c 23 11001 NaN

d 19 10101 NaN

e 22 21000 NaN

>>> df.work['a':'b']

a NaN

b NaN

Name: work, dtype: object

>>> df.work['a':'b']='python'

>>> df

age salary work

a 20 10000 python

b 21 20000 python

c 23 11001 NaN

d 19 10101 NaN

e 22 21000 NaN

>>> >>> df.isnull()

age salary work

a False False False

b False False False

c False False True

d False False True

e False False True

>>> df.notnull()

age salary work

a True True True

b True True True

c True True False

d True True False

e True True False

>>> #根据获得的数据去除数据的空数据

>>> df.dropna()#去除含有空数据的行

age salary work

a 20 10000 python

b 21 20000 python

>>> #默认为行

>>> df.dropna(how='all')#去除全部为nan的行

age salary work

a 20 10000 python

b 21 20000 python

c 23 11001 NaN

d 19 10101 NaN

e 22 21000 NaN

>>> #所有都为null的才删除

>>> df.fillna(value='java')

age salary work

a 20 10000 python

b 21 20000 python

c 23 11001 java

d 19 10101 java

e 22 21000 java

>>> #使空数据修改为value值

#backfill,bfill,是向后填充ffill,pad是向前填充

>>> df

age salary work

a 20 10000 python

b 21 20000 python

c 23 11001 NaN

d 19 10101 NaN

e 22 21000 NaN

>>> df.fillna(method='backfill')#向后填充，实质是后面一行填充前面一行

age salary work

a 20 10000 python

b 21 20000 python

c 23 11001 NaN

d 19 10101 NaN

e 22 21000 NaN

>>> df.fillna(method='ffill')#向前填充

age salary work

a 20 10000 python

b 21 20000 python

c 23 11001 python

d 19 10101 python

e 22 21000 python

>>> df.fillna(method='ffill',inplace=True)#

>>> df

age salary work

a 20 10000 python

b 21 20000 python

c 23 11001 python

d 19 10101 python

e 22 21000 python

>>> obj=pd.Series(['blue','pure','yellow'],index=[0,2,4])

>>> obj

0 blue

2 pure

4 yellow

dtype: object

>>> obj.reindex(range(6),method='bfill')

0 blue

1 pure

2 pure

3 yellow

4 yellow

5 NaN

dtype: object

>>> #这是向后填充

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

3：总结

pandas的Series和DataFrame是构成表结构的两个重要的库，也是学习pandas的基础。

巴特西

pandas基础(1)_Series和DataFrame

最新文章

热门文章