Pandas入门学习总结

最新推荐文章于 2025-07-07 21:22:12 发布
最新推荐文章于 2025-07-07 21:22:12 发布
阅读量1k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Pandas python入门学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_30138291/article/details/76544512


# 1. pandas

import pandas as pd

import numpy as np
# Pandas中的数据结构
# Series：一维数组，与Numpy中的一维array类似。二者与Python基本的数据结构List也很相近，
# 其区别是：List中的元素可以是不同的数据类型，而Array和Series中则只允许存储相同的数据类型，
# 这样可以更有效的使用内存，提高运算效率。
# Time- Series：以时间为索引的Series
# DataFrame：二维的表格型数据结构,可以将DataFrame理解为Series的容器

# 2. pd.Series

s = pd.Series([1,3,5,np.nan,6,8])#NAN表明不是个数

print(s)

0    1.0
1    3.0
2    5.0
3    NaN
4    6.0
5    8.0
dtype: float64

# DataFrame
#  DataFrame是二维的数据结构，其本质是Series的容器，
#  因此，DataFrame可以包含一个索引以及与这些索引联合在一起的Series，
#  由于一个Series中的数据类型是相同的，而不同Series的数据结构可以不同。
#  因此对于DataFrame来说，每一列的数据结构都是相同的，而不同的列之间则可以是不同的数据结构。
#  或者以数据库进行类比，DataFrame中的每一行是一个记录，名称为Index的一个元素，
#  而每一列则为一个字段，是这个记录的一个属性

# 3 创建DataFrame

# 模式1:
# dict = {'col1': ts1, 'col2': ts2} # tsx可以是列表、字典、元组、或者pd.series()
# df = pd.DataFrame(data=data, index=index) # index也可以是pd.date_range等其他类型
# 模式2:
# df = pd.DataFrame(data=data,index = index,columns = columns)
# 模式3:
# dict = {'column1_name':pd.Series(),'column2_name':pd.Series(),...,'columnn_name':pd.Series()}
# df = pd.DataFrame(dict,index = index ) #没有index则默认从np.arange(n)从0到(n-1)

# 3.1 以Series的字典的结构构建DataFrame.列的顺序随机

# 这时候的最外面字典对应的是DataFrame的列，
# 内嵌的字典及Series则是其中每个值
# 可以看到d是一个字典，其中one的值为Series有3个值，而two为Series有4个值。
# 由d构建的为一个4行2列的DataFrame。其中one只有3个值，因此d行one列为NaN（Not a Number）
# --Pandas默认的缺失值标记
d = {'one' : pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
     'two' : pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])}

df = pd.DataFrame(d)

    one two
a  1.0  1.0
b  2.0  2.0
c  3.0  3.0
d  NaN  4.0

改变两个列的名字，其他不变

d = {'two' : pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
     'one' : pd.Series([1., 2., 3., 4.], index=['a', 'b', 'g', 'h'])}
df = pd.DataFrame(d)
print('----------\n',df)

 one  two
a  1.0  1.0
b  2.0  2.0
c  NaN  3.0
g  3.0  NaN
h  4.0  NaN
结果不发生改变，说明是按照列的名字排序的
d = {'one' : pd.Series([1., 2., 3.], index=['a', 'b', 'c']),

     'two' : pd.Series([1., 2., 3., 4.], index=['a', 'b', 'g', 'h'])}
df = pd.DataFrame(d)

print('----------\n',df)

----------
    one  two
a  1.0  1.0
b  2.0  2.0
c  3.0  NaN
g  NaN  3.0
h  NaN  4.0

# 3.2 从字典的列表构建DataFrame，其中每个字典代表的是每条记录（DataFrame中的一行）

# 字典中每个值对应的是这条记录的相关属性
d = [{'one' : 1,'two':1},{'one' : 2,'two' : 2},{'one' : 3,'two' : 3},{'two' : 4}]
df = pd.DataFrame(d,index=['a','b','c','d']

print('----------\n',df)

    one  two
a  1.0    1
b  2.0    2
c  3.0    3
d  NaN    4

# 以上的语句与以Series的字典形式创建的DataFrame相同，只是思路略有不同，一个是以列为单位构建，
# 将所有记录的不同属性转化为多个Series，行标签冗余，另一个是以行为单位构建，
# 将每条记录转化为一个字典，列标签冗余。使用这种方式，如果不通过columns指定列的顺序，
# 那么列的顺序会是随机即3.1的。

# 3.3 使用传递的numpy数组创建数据帧,并使用日期索引和标记列

dates = pd.date_range('20130101',periods=6)#共6天

df = pd.DataFrame(np.random.randn(6,4),index=dates,columns=list('ABCD'))

#list(str)可以将字符串 打散 输出出来

print(df)

                   A         B         C         D
2013-01-01  0.550842 -0.344767 -1.159734 -0.738592
2013-01-02 -1.122310 -0.058075 -0.912459 -0.233126
2013-01-03 -0.147547  0.552087 -0.592051  1.361595
2013-01-04 -1.152434  0.423264 -0.954811  0.562591
2013-01-05 -0.064692  0.121858 -0.741079  0.408168
2013-01-06  0.797960  0.291905  0.071038  0.509477

pd.date_range(start,end,periods,freq,normalize)

start：开始日期

end：结束日期

periods：日期范围内日期的个数，periods*freq 等于日期范围的长度

freq：每多少天或其他明确时间频率的方式，默认为D，即1天

normalize：把日期规范化到午夜时间戳，即把时间规范化为 00:00:00

 #3.4使用传递的可转换序列的字典对象创建数据帧

df2 = pd.DataFrame({ 'A' : 1.,
                    'B' : pd.Timestamp('20130102'),#pd.Timestamp(日期) 数字生成日期格式
                    'C' : pd.Series(1,index=list(range(4)),dtype='float32'),#list(range(4) 即[0, 1, 2, 3]

                    'D' : np.array([3] * 4,dtype='int32'),#np.array([3] * 4,dtype='int32') 即 [3 3 3 3]

                    #np.array([元素] * k) 即 [元素 元素 元素 元素.....元素 元素] 一共k个

                    'E' : pd.Categorical(["test","train","test","train"]),
                    'F' : 'foo' })

print('df2\n',df2)

df2
      A          B    C  D      E    F
0  1.0 2013-01-02  1.0  3   test  foo
1  1.0 2013-01-02  1.0  3  train  foo
2  1.0 2013-01-02  1.0  3   test  foo
3  1.0 2013-01-02  1.0  3  train  foo

# head和tail方法可以显示DataFrame前N条和后N条记录，N为对应的参数，默认值为5。

print('head')
print(df2.head(2))
print('tail')

print(df2.tail(2))

head
     A          B    C  D      E    F
0  1.0 2013-01-02  1.0  3   test  foo
1  1.0 2013-01-02  1.0  3  train  foo
tail
     A          B    C  D      E    F
2  1.0 2013-01-02  1.0  3   test  foo
3  1.0 2013-01-02  1.0  3  train  foo

# 显示索引,列,和底层numpy数据
d = {'one' : pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
     'two' : pd.Series([1., 2., 3., 4.], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)
print('df.index\n',df.index)
print('df.columns\n',df.columns)
print('df.values\n',df.values)

print(df.describe())

df.index
 Index(['a', 'b', 'c', 'd'], dtype='object')
df.columns
 Index(['one', 'two'], dtype='object')
df.values
 [[  1.   1.]
 [  2.   2.]
 [  3.   3.]
 [ nan   4.]]
       one       two
count  3.0  4.000000
mean   2.0  2.500000
std    1.0  1.290994
min    1.0  1.000000
25%    1.5  1.750000
50%    2.0  2.500000
75%    2.5  3.250000
max    3.0  4.000000

# 转置

print(df.T)

       a    b    c    d
one  1.0  2.0  3.0  NaN
two  1.0  2.0  3.0  4.0

# 4. DataFrame排序

# 4.1按轴标签(行名、列名)进行排序

d = {'one' : pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
     'two' : pd.Series([5., -1., 3., -2.], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)

print('原始df\n',df)

原始df
    one  two
a  1.0  5.0
b  2.0 -1.0
c  3.0  3.0
d  NaN -2.0

x = df.sort_index(axis=1, ascending=False) #ascending=False降序排列,ascending=True升序排列

axis = 0 按行名称 axis = 1 按列名称 

print('按轴标签排序\n',x)

按轴标签排序
    two  one
a  5.0  1.0
b -1.0  2.0
c  3.0  3.0
d -2.0  NaN

# 4.2按值排序进行排序

d = {'one' : pd.Series([1., 2., 3.], index=['a', 'b', 'c']),
     'two' : pd.Series([5., -1., 3., -2.], index=['a', 'b', 'c', 'd'])}
df = pd.DataFrame(d)

print(df)

   one  two
a  1.0  5.0
b  2.0 -1.0
c  3.0  3.0
d  NaN -2.0

x =df.sort_values(['a','b'],axis=1,ascending=False)

或者

#x = df.sort_values(axis=1,by =['a','b'] ,ascending=False)

先按照第'a'行的值排序 如果有重复 按照'b'行排序

这里的axis可以省略，因为 名字可以唯一确定 某一列或某一行

#sort(columns = 'two', ascending=False) #注意ascending仅是参数名字,True对应降序排列，False对应升序排列

print('排序\n',x)

排序
    two  one
a  5.0  1.0
b -1.0  2.0
c  3.0  3.0
d -2.0  NaN

# 5. 内容检索 

# 5.1 整列或整行检索

dates = pd.date_range('1/1/2000', periods=5)
df = pd.DataFrame(np.random.randn(5, 4), index=dates, 
                  columns=['A', 'B', 'C', 'D'])
print('df\n',df)

print("列'A':\n",df['A'])

df
                    A         B         C         D
2000-01-01  1.293043 -1.333675  0.480421  0.751432
2000-01-02 -0.234011 -1.275571 -1.312495  0.200552
2000-01-03  0.203873  2.104864  0.223676  0.100973
2000-01-04  0.227849 -1.345697  1.799077 -1.784205
2000-01-05 -0.326033  0.610245 -1.575445  0.870782
列'A':
 2000-01-01    1.293043
2000-01-02   -0.234011
2000-01-03    0.203873
2000-01-04    0.227849
2000-01-05   -0.326033
Freq: D, Name: A, dtype: float64

s = df['A']
print('s[0:3]\n',s[0:3])

print('\n原来df:\n',df)

s[0:3]
 2000-01-01    1.293043
2000-01-02   -0.234011
2000-01-03    0.203873
Freq: D, Name: A, dtype: float64

原来df:
                    A         B         C         D
2000-01-01  1.293043 -1.333675  0.480421  0.751432
2000-01-02 -0.234011 -1.275571 -1.312495  0.200552
2000-01-03  0.203873  2.104864  0.223676  0.100973
2000-01-04  0.227849 -1.345697  1.799077 -1.784205
2000-01-05 -0.326033  0.610245 -1.575445  0.870782

df[['B', 'A']] = df[['A', 'B']]
print("\n'A'列与'B'列互换后的df:\n",df)
print('df的前三行\n',df[:3])
print('\ndf:\n',df)

print('\n反向输出df\n',df[::-1])

'A'列与'B'列互换后的df:
                    A         B         C         D
2000-01-01 -1.333675  1.293043  0.480421  0.751432
2000-01-02 -1.275571 -0.234011 -1.312495  0.200552
2000-01-03  2.104864  0.203873  0.223676  0.100973
2000-01-04 -1.345697  0.227849  1.799077 -1.784205
2000-01-05  0.610245 -0.326033 -1.575445  0.870782
df的前三行
                    A         B         C         D
2000-01-01 -1.333675  1.293043  0.480421  0.751432
2000-01-02 -1.275571 -0.234011 -1.312495  0.200552
2000-01-03  2.104864  0.203873  0.223676  0.100973

df:
                    A         B         C         D
2000-01-01 -1.333675  1.293043  0.480421  0.751432
2000-01-02 -1.275571 -0.234011 -1.312495  0.200552
2000-01-03  2.104864  0.203873  0.223676  0.100973
2000-01-04 -1.345697  0.227849  1.799077 -1.784205
2000-01-05  0.610245 -0.326033 -1.575445  0.870782

反向输出df
                    A         B         C         D
2000-01-05  0.610245 -0.326033 -1.575445  0.870782
2000-01-04 -1.345697  0.227849  1.799077 -1.784205
2000-01-03  2.104864  0.203873  0.223676  0.100973
2000-01-02 -1.275571 -0.234011 -1.312495  0.200552
2000-01-01 -1.333675  1.293043  0.480421  0.751432

df = pd.DataFrame(np.random.randn(5,4), columns=list('ABCD'), 
                   index=pd.date_range('20130101',periods=5))
# 这是错误的，无法进行slices
# dfl.loc[2:3]
#这是可以的

print(df.loc['20130102':'20130104'])

                   A         B         C         D
2013-01-02  0.619954  0.899184  1.550459  0.057953
2013-01-03  0.247558  0.672721 -0.188366  0.443095
2013-01-04 -2.458783  0.798642  0.064322  0.310493
s = df['A']

print('单列切片是可以的但是要用loc函数\n',s.loc['20130102':'20130104'])

单列切片是可以的但是要用loc函数
 2013-01-02    0.619954
2013-01-03    0.247558
2013-01-04   -2.458783
Freq: D, Name: A, dtype: float64

df1 = pd.DataFrame(np.random.randn(6,4),index=list('abcdef'), 
                   columns=list('ABCD'))
print(df1)

print("df1.loc[['a', 'b', 'd'], :]\n",df1.loc[['a', 'b', 'd'], :])

          A         B         C         D
a  0.305018  0.554215  2.143252  1.918004
b -0.346651 -0.411049 -1.442780  0.500032
c -0.249730  1.973843 -0.155139 -0.295213
d  0.129608  0.059382 -0.829285 -0.986293
e -2.577511  1.313742  0.207580  0.243185
f  1.266195 -0.031532  0.571188 -1.308195
df1.loc[['a', 'b', 'd'], :]
           A         B         C         D
a  0.305018  0.554215  2.143252  1.918004
b -0.346651 -0.411049 -1.442780  0.500032
d  0.129608  0.059382 -0.829285 -0.986293

print("终于找到了一种dataframe切片的方式了:df1.loc['d':, 'A':'C']\n",df1.loc['d':, 'A':'C'])

# 5.2boolean操作

df1.loc(['a'] > 0)

# 6. 排名(ranking)

# 跟排序关系密切，且它会增设一个排名值（从1开始，一直到数组中有 效数据的数量）。
# 它跟numpy.argsort产生的间接排序索引差不多，只不过它可以根据某种规则破坏平级关系。
# Series和DataFrame的rank方法:默认情况下，rank是通过“为各组分配一个平均排名”的方式破坏平级关系的

# 6.1 Series排名

# 排名时用于破坏平级关系的method选项
# Method                           说明
# ‘average’         默认：在相等分组中，为各个值分配平均排名
# ‘min’             使用整个分组的最小排名
# ‘max’             使用整个分组的最大排名
# ‘first’           按值在原始数据中的出现顺序分配排名 
obj = pd.Series([7,-5,7,4,2,0,4])
print("\nOriginal obj:\n",obj) 

Original obj:
0    7
1   -5
2    7
3    4
4    2
5    0
6    4
dtype: int64
print("\nDefault mode of ranking (average ranking):\n",obj.rank()) #默认是平均排名 

Default mode of ranking (average ranking):
0    6.5
1    1.0
2    6.5
3    4.5
4    3.0
5    2.0
6    4.5
dtype: float64
print("\nFirst mode of ranking (group by the ordering of presentation):\n",obj.rank(method='first'))  #根据值在原数据中出现的顺序给出排名 

First mode of ranking (group by the ordering of presentation):
0    6.0
1    1.0
2    7.0
3    4.0
4    3.0
5    2.0
6    5.0
dtype: float64
print("\n按降序使用分组的最大排名:\n",obj.rank(ascending=False, method='max')) 

按降序使用分组的最大排名:
0    2.0
1    7.0
2    2.0
3    4.0
4    5.0
5    6.0
6    4.0
dtype: float64
print("\n按降序使用分组的最小排名:\n",obj.rank(ascending=False, method='min'))#符合人们习惯的排名 

按降序使用分组的最小排名:
0    1.0
1    7.0
2    1.0
3    3.0
4    5.0
5    6.0
6    3.0
dtype: float64

# 6.2 DataFrame在行或列上计算排名

类似于 numpy.argsort(ascending = True)
# DataFrame的排序接近与人们的直观印象
dict = {'a':pd.Series([0,1,0,1],index = [1,2,3,4]),
        'b':[4.3, 7, -3, 2],
        'c':[-2, 5, 8, -2.5]}
df3 = pd.DataFrame(dict)
print("\noriginal df3:\n",df3)
print("\ndf3按行升序排序:\n",df3.rank(axis=1)) # df.rank()返回的都是类似于argsort()返回的索引值
print("\ndf3按列升序排序:\n",df3.rank(axis=0))

original df3:
    a    b    c
1  0  4.3 -2.0
2  1  7.0  5.0
3  0 -3.0  8.0
4  1  2.0 -2.5

df3按行升序排序:
      a    b    c
1  2.0  3.0  1.0
2  1.0  3.0  2.0
3  2.0  1.0  3.0
4  2.0  3.0  1.0

df3按列升序排序:
      a    b    c
1  1.5  3.0  2.0
2  3.5  4.0  3.0
3  1.5  1.0  4.0
4  3.5  2.0  1.0

# 7. Pandas的索引和选择

data = np.random.randn(6,4)
dates_index = pd.date_range('20170802',periods = 6)
labeled_columns = list('ABCD')
df = pd.DataFrame(data,index = dates_index,columns = labeled_columns)
#可以使用一些方法通过位置num或名字label来检索，例如 ix索引成员(field)

# 7.1. 属性.ix[行选:行选,列选:列选]

.ix既可以输入行名、列名，也可以输入整数索引和slice切片
print("\noriginal df:\n",df)
print("\ndf.ix['20170802']\n",df.ix['20170802'])
print("\ndf.ix[:,'A']\n",df.ix[:,'A'])
print("\ndf.ix[:,'A']\n",df.ix[:,['A','B']])
print("\ndf.ix[:,'A':'C']\n",df.ix[:,'A':'C'])
print("\ndf.ix[0:3,0:3]\n",df.ix[0:3,0:3])

original df:
                    A         B         C         D
2017-08-02  0.087691  0.219709 -1.415308 -0.904164
2017-08-03 -1.093569  0.416883  0.198400  1.045094
2017-08-04  0.427113  0.306400 -0.340359 -0.819978
2017-08-05  0.030368  0.852479 -1.733437  1.355039
2017-08-06 -1.257529  0.142805 -1.545963  1.265029
2017-08-07  0.148612  0.289964  0.661178  1.134609

df.ix['20170802']
A    0.087691
B    0.219709
C   -1.415308
D   -0.904164
Name: 2017-08-02 00:00:00, dtype: float64

df.ix[:,'A']
2017-08-02    0.087691
2017-08-03   -1.093569
2017-08-04    0.427113
2017-08-05    0.030368
2017-08-06   -1.257529
2017-08-07    0.148612
Freq: D, Name: A, dtype: float64

df.ix[:,'A']
                    A         B
2017-08-02  0.087691  0.219709
2017-08-03 -1.093569  0.416883
2017-08-04  0.427113  0.306400
2017-08-05  0.030368  0.852479
2017-08-06 -1.257529  0.142805
2017-08-07  0.148612  0.289964

df.ix[:,'A':'C']
                    A         B         C
2017-08-02  0.087691  0.219709 -1.415308
2017-08-03 -1.093569  0.416883  0.198400
2017-08-04  0.427113  0.306400 -0.340359
2017-08-05  0.030368  0.852479 -1.733437
2017-08-06 -1.257529  0.142805 -1.545963
2017-08-07  0.148612  0.289964  0.661178

df.ix[0:3,0:3]
                    A         B         C
2017-08-02  0.087691  0.219709 -1.415308
2017-08-03 -1.093569  0.416883  0.198400
2017-08-04  0.427113  0.306400 -0.340359

# 7.2. 属性.iloc[:,:] 纯粹的整数索引

print("\noriginal df:\n",df)
print("\ndf.iloc[0,:]\n",df.iloc[0,:])
print("\ndf.iloc[:,0]\n",df.iloc[:,0])
print("\ndf.iloc[0:3,0:3]\n",df.iloc[0:3,0:3])
original df:
                    A         B         C         D
2017-08-02 -0.385499 -0.306875  0.315595 -1.896589
2017-08-03 -1.245150  1.637986  0.902566 -0.369912
2017-08-04 -1.238186  0.181560  0.214879 -1.114181
2017-08-05 -0.440366 -1.993538 -0.688619  2.331878
2017-08-06 -0.011589 -1.807583 -1.482700  2.105531
2017-08-07 -1.348804 -0.044709  2.163649 -0.174644

df.iloc[0,:]
A   -0.385499
B   -0.306875
C    0.315595
D   -1.896589
Name: 2017-08-02 00:00:00, dtype: float64

df.iloc[:,0]
2017-08-02   -0.385499
2017-08-03   -1.245150
2017-08-04   -1.238186
2017-08-05   -0.440366
2017-08-06   -0.011589
2017-08-07   -1.348804
Freq: D, Name: A, dtype: float64

df.iloc[0:3,0:3]
                    A         B         C
2017-08-02 -0.385499 -0.306875  0.315595
2017-08-03 -1.245150  1.637986  0.902566
2017-08-04 -1.238186  0.181560  0.214879

# 7.3 选择行df.loc[行:行,列:列]

print("\noriginal df:\n",df)
print("\n第一行df.loc[dates_index[0],:]\n",df.loc[dates_index[0],:])
print("\n0-1行A到C列df.loc[dates_index[0:2],'A':'C']\n",df.loc[dates_index[0:2],'A':'C'])
print("\从第二行到下面所有行ndf.loc[dates_index[2:],:]\n",df.loc[dates_index[2:],:])
original df:
                    A         B         C         D
2017-08-02  0.852031 -0.361794 -0.131658  1.293972
2017-08-03  0.042461 -0.405303  0.424170  0.207510
2017-08-04 -0.105956 -1.225223  0.545878 -0.256659
2017-08-05 -0.048689 -0.184247  1.389649 -0.209020
2017-08-06 -0.355166 -1.208937 -1.588495 -0.442820
2017-08-07  1.676568  1.037785  1.682274 -0.012409

第一行df.loc[dates_index[0],:]
A    0.852031
B   -0.361794
C   -0.131658
D    1.293972
Name: 2017-08-02 00:00:00, dtype: float64

0-1行A到C列df.loc[dates_index[0:2],'A':'C']
                    A         B         C
2017-08-02  0.852031 -0.361794 -0.131658
2017-08-03  0.042461 -0.405303  0.424170

从第二行到下面所有行df.loc[dates_index[2:],:]
                    A         B         C         D
2017-08-04 -0.105956 -1.225223  0.545878 -0.256659
2017-08-05 -0.048689 -0.184247  1.389649 -0.209020
2017-08-06 -0.355166 -1.208937 -1.588495 -0.442820
2017-08-07  1.676568  1.037785  1.682274 -0.012409

# 7.3 布尔索引

print("\noriginal df:\n",df)
print("\ndf.A>0.5:\n",df.A>0.5)#注意这里可以用df.A来引用df的'A'列,等价与df['A']>0.5
print("\ndf[df.A>0.5]\n",df[df.A>0.5])
print("\ndf[df['A']>0.5]\n",df[df['A']>0.5])
original df:
                    A         B         C         D
2017-08-02  1.174908  0.294394  1.458811 -0.229504
2017-08-03  1.543965 -0.822035  0.019391 -0.236707
2017-08-04 -0.073200  0.614149 -0.385161  1.383675
2017-08-05 -0.125898 -0.264261 -0.237433  1.522009
2017-08-06  1.391828 -1.292755  0.779818  0.184977
2017-08-07  0.393325  1.358546 -1.131494 -0.036899

df.A>0.5:
 2017-08-02     True
2017-08-03     True
2017-08-04    False
2017-08-05    False
2017-08-06     True
2017-08-07    False
Freq: D, Name: A, dtype: bool

df[df.A>0.5]
                    A         B         C         D
2017-08-02  1.174908  0.294394  1.458811 -0.229504
2017-08-03  1.543965 -0.822035  0.019391 -0.236707
2017-08-06  1.391828 -1.292755  0.779818  0.184977

df[df['A']>0.5]
                    A         B         C         D
2017-08-02  1.174908  0.294394  1.458811 -0.229504
2017-08-03  1.543965 -0.822035  0.019391 -0.236707
2017-08-06  1.391828 -1.292755  0.779818  0.184977

# 8. 列columns和行index的名字及数据值的查看values

data = np.random.randn(6,4)
dates_index = pd.date_range('20170802',periods = 6)
labeled_columns = list('ABCD')
df = pd.DataFrame(data,index = dates_index,columns = labeled_columns)

print('df.index:\n',df.index) #虽然自动弹出项没有该项，但是可以正常输出
print("df.columns\n",df.columns)
print("\nvalues:\n",df.values)

df.index:
 DatetimeIndex(['2017-08-02', '2017-08-03', '2017-08-04', '2017-08-05',
               '2017-08-06', '2017-08-07'],
              dtype='datetime64[ns]', freq='D')
df.columns
 Index(['A', 'B', 'C', 'D'], dtype='object')

values:
 [[-2.02446357 -0.714604    1.3423228  -1.6556258 ]
 [ 0.12293179 -0.18787551 -0.4763062   0.04510573]
 [ 0.92268382  0.86067222  0.14025608 -0.39711331]
 [-0.38946469 -0.95570081  0.05857063 -0.1566773 ]
 [ 1.39358622 -0.22103091  1.14675195 -0.90141337]
 [-1.64881973  1.26254782  1.11880424 -0.42361963]]

# 9. dataframe数据遍历和迭代iteration

# 9.1 df.iterrow()

对DataFrame的每一行进行迭代，返回一个Tuple (index, Series)
print("\n循环遍历df,原始df如下:\n",df)
print("\n&&&&&&&&&&&&&&&&&&&&\n")
for idx,row in df.iterrows():
    print('\nidx\n',idx)
    print(row)

循环遍历df,原始df如下:
                    A         B         C         D
2017-08-02 -2.024464 -0.714604  1.342323 -1.655626
2017-08-03  0.122932 -0.187876 -0.476306  0.045106
2017-08-04  0.922684  0.860672  0.140256 -0.397113
2017-08-05 -0.389465 -0.955701  0.058571 -0.156677
2017-08-06  1.393586 -0.221031  1.146752 -0.901413
2017-08-07 -1.648820  1.262548  1.118804 -0.423620

&&&&&&&&&&&&&&&&&&&&

idx
 2017-08-02 00:00:00
A   -2.024464
B   -0.714604
C    1.342323
D   -1.655626
Name: 2017-08-02 00:00:00, dtype: float64

idx
 2017-08-03 00:00:00
A    0.122932
B   -0.187876
C   -0.476306
D    0.045106
Name: 2017-08-03 00:00:00, dtype: float64

idx
 2017-08-04 00:00:00
A    0.922684
B    0.860672
C    0.140256
D   -0.397113
Name: 2017-08-04 00:00:00, dtype: float64

idx
 2017-08-05 00:00:00
A   -0.389465
B   -0.955701
C    0.058571
D   -0.156677
Name: 2017-08-05 00:00:00, dtype: float64

idx
 2017-08-06 00:00:00
A    1.393586
B   -0.221031
C    1.146752
D   -0.901413
Name: 2017-08-06 00:00:00, dtype: float64

idx
 2017-08-07 00:00:00
A   -1.648820
B    1.262548
C    1.118804
D   -0.423620
Name: 2017-08-07 00:00:00, dtype: float64

# 9.2 df.itertuples()

也是一行一行地迭代，返回的是一个namedtuple，通常比iterrow快，
# 因为不需要做转换
print("\n@@@@@@@@@@@@@@@@@@@@\n")
for row in df.itertuples():
    print (row)

@@@@@@@@@@@@@@@@@@@@

Pandas(Index=Timestamp('2017-08-02 00:00:00', freq='D'), A=-2.0244635731150744, B=-0.71460400319097506, C=1.342322802457689, D=-1.6556258003597193)
Pandas(Index=Timestamp('2017-08-03 00:00:00', freq='D'), A=0.12293179203239156, B=-0.18787551355369914, C=-0.47630620483341407, D=0.045105732709614245)
Pandas(Index=Timestamp('2017-08-04 00:00:00', freq='D'), A=0.92268382357994816, B=0.86067222202020854, C=0.14025607716961588, D=-0.39711330744921625)
Pandas(Index=Timestamp('2017-08-05 00:00:00', freq='D'), A=-0.389464692996358, B=-0.95570081033916021, C=0.058570629560594063, D=-0.15667729517068432)
Pandas(Index=Timestamp('2017-08-06 00:00:00', freq='D'), A=1.393586215688051, B=-0.22103091191411234, C=1.1467519519104892, D=-0.90141336789197646)
Pandas(Index=Timestamp('2017-08-07 00:00:00', freq='D'), A=-1.6488197318775826, B=1.2625478230114269, C=1.118804243889175, D=-0.42361962564746392)

# 9.3 iteriems()

对DataFrame相当于对列迭代
print("\n^^^^^^^^^^^^^^^^\n")
for c, col in df.iteritems():
    print (c)
    print(col)

^^^^^^^^^^^^^^^^

A
2017-08-02   -2.024464
2017-08-03    0.122932
2017-08-04    0.922684
2017-08-05   -0.389465
2017-08-06    1.393586
2017-08-07   -1.648820
Freq: D, Name: A, dtype: float64
B
2017-08-02   -0.714604
2017-08-03   -0.187876
2017-08-04    0.860672
2017-08-05   -0.955701
2017-08-06   -0.221031
2017-08-07    1.262548
Freq: D, Name: B, dtype: float64
C
2017-08-02    1.342323
2017-08-03   -0.476306
2017-08-04    0.140256
2017-08-05    0.058571
2017-08-06    1.146752
2017-08-07    1.118804
Freq: D, Name: C, dtype: float64
D
2017-08-02   -1.655626
2017-08-03    0.045106
2017-08-04   -0.397113
2017-08-05   -0.156677
2017-08-06   -0.901413
2017-08-07   -0.423620
Freq: D, Name: D, dtype: float64

# 10. 行数和类型

print("\ndf的行数:",df.shape[0])
print("\ndf的数据类型:\n",df.dtypes)
df的行数: 6

df的数据类型:
A    float64
B    float64
C    float64
D    float64
dtype: object


Python pandas学习总结
Alden_Wei的博客
04-02 2544
Python pandas学习总结 　　pandas是做数据分析非常重要的一个模块，它使得数据分析的工作变得更快更简单。由于现实世界中数据源的格式非常多，但是pandas也支持了不同数据格式的导入方法，所以学习pandas非常有必要。 要是想看所有的方法详解可以去官网，要想学习Pandas建议先看下面2个网站。 　　官网地址如下：https://pandas.pydata.org/ 　　官网教程如...
史上最强Pandas入门教程
weixin_49329177的博客
04-23 1211
Pandas是一个开源的Python库，它提供了快速、灵活和富有表现力的数据结构，使得关系或标记数据的操作既简单又直观。Pandas最初被设计用于金融数据分析和数据清洗任务，但现在已被广泛应用于各种数据分析和数据处理场景，包括学术、金融、统计学等各个领域。本文主要讲述Pandas的基础操作，教会新手如何快速入门Pandas的应用。分别从Series和Dataframe两个讲述他们的操作命令。
pandas学习总结一
loveweni的博客
04-23 302
下载Anaconda Anaconda是一个包含180+的科学包及其依赖项的发行版本；里面内置了很多工具，不用单独安装，因为做了优化也免去了单独安装带来的一些麻烦； 个人版：下载地址https://www.anaconda.com/distribution/； 环境处理可百度解决；再次不做解释； 开始使用： 选择适合自己的编辑工具敲python代码： 一： #引入所需依赖包： import num...
Pandas库的学习总结
最新发布
Alfie的博客
07-07 795
觉得难、卡壳的点，可以是一个语法、一个设计、或一处易错逻辑。实际用这个技术做了什么：Demo、练手项目或脚本开发。
Pandas学习总结（一）
qq_45802081的博客
09-05 1152
1、Pandas简介 pandas是python的核心数据支持库，提供了快速、灵活、明确的数据结构，旨在简单、直观的出路关系型、标记型数据。 1.1Pandas处理的数据类型 与SQL或Excel表类似的，含异构列的表格数据； 有序和无序（非固定频率）的时间序列数据； 带行列标签的矩阵数据，包括异构或同构型数据； 任意其他形式的观测、统计数据集，数据转入Pandas。 Pandas处理浮点与非浮点数据里的缺失数据，表示为NaN。 Pandas 的主要数据结构是 Series（一维数据）与 DataFrame
pandas学习心得
zyf2695421695的博客
07-02 4580
Pandas是基于Numpy的专业数据分析工具，可以灵活高效地处理各种数据集，包含两种类型的数据结构：DataFrame（表）和Series（列） 。 pandas：字典+列表 df = pd.DataFrame({'姓名':['张三','李四'],'年龄':['11','22']},index = ['分类1','分类2']) 可以通过改变columns,index和values的值来控制数据。不指定索引时，从0开始的数字索引。 1.内容预览：df.head() 默认前5行 df.tail(...
聊聊我的 Pandas 学习经历及动手实践
Python学习与数据挖掘
03-05 1579
想入门人工智能或者数据分析，要重视可以快速上手的学习技能： 掌握一些基本概念，建立一个知识框架，然后就去实战，在实战中学习新知识，来填充这个框架。 我根据之前整理的一些pandas知识，总结了一个pandas的快速入门的知识框架。有了这些知识，然后去通过项目实战，然后再补充。希望能帮助大家快速上手。喜欢本文记得收藏、点赞、关注。我将这些资料整理成PDF版本，需要的可以问题找我获取。 推荐文章 李宏毅《机器学习》国语课程(2022)来了 有人把吴恩达老师的机器学习和深度学习做成了中文版 上瘾了，
pandas库学习报告.docx
04-11
### pandas库学习报告 #### 一、pandas简介 pandas 是一个强大的 Python 库，专为数据分析设计。它建立在 NumPy 基础之上，提供了一系列高级数据结构和数据分析工具，使得处理数据变得更加简单高效。pandas 的核心...
基础Python教程之pandas使用总结.pdf
10-30
在Python的世界里，数据分析是一项核心任务，而Pandas库正是这个领域的王者。Pandas提供了高效的数据处理工具，使得数据清洗、分析和...因此，对于从事数据分析或机器学习的人员来说，深入理解和应用Pandas至关重要。
Pandas系列学习教程
lzylzy66的博客
03-10 696
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了Pandas学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
Pandas学习笔记1-Pandas基础
12-21
在Pandas学习中，了解和掌握基础操作是至关重要的。Pandas是一个强大的Python数据分析工具，提供了高效的数据处理和分析功能。本篇笔记将探讨Pandas的基础知识，包括数据的读取与写入、Series和DataFrame的基本操作...
Pandas学习 – 基础
12-21
写在前面 这个系列是跟着 Datawhale 的第二次学习，算是系统的学习一下 pandas 基础，然后会跟着教材梳理一下知识点。 # 导入所需模块 import pandas as pd import numpy as np 这里说明一下查看模块版本的语句，一般来说大部分模块有这个方法 pandas.__version__ 因为群里有同学遇到了 0.xx 版本的遗留问题，所以这里将 pandas 模块进行升级，在 prompt 里的语句如下，然后就顺利升级到了 1.0.3 ！ python -m pip install --upgrade pandas 一、文件读取与写入 1. 读取
Pandas学习总结-基础篇
酬勤的博客
04-20 388
这里写自定义目录标题新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 \ 此前断断续续看过《利用Python进行...
【pandas】总结
Good_77的博客
09-30 473
pandas学习总结
pandas学习总结
ShaoDu的博客
08-12 796
在pandas中： string属于object类型 integer属于int类型 boolean属于bool类型 还存在着float、datatime等类型 read_csv()方法只能读取不带中文的文件目录和文件名。若是存在中文需要open()方法打开，在进行读取，否则回报错 import pandas f=open("H:\\机器学习\\机器学习...
pandas基础总结
qq_39022311的博客
04-03 201
近期想学习下数据分析，里边有用到pandas库，在书上网上找了些知识点想把它写下来便于以后自己的温习与分享。 pandas库主要有Series和DataFrame两个数据结构 Series 是一个类数组的数据结构，有索引index 可以理解为序列 DataFrame 按列存储的数据结构,所有的数据都是按列存放的 每列都是Series序列的结构 下面是关于pandas基础用法的实现 #导入...
Pandas学习总结
CJZ19870212的博客
08-14 485
pandas数据类型   https://www.jb51.net/article/139630.htm 文件路径有中文或者文件里面 有中文字 mydata = pd.read_csv(u"例子.csv",encoding = "gbk")# gb2312 or gb18030 Pandas中进行数据类型转换有三种基本方法： 使用astype()函数进行强制类型转换 自定义函数进...
Pandas学习总结梳理【Pandas学习记录】
m0_38052500的博客
06-19 656
参考课程：Numpy & Pandas (莫烦 Python 数据处理教程) 和 Python数据分析和数据可视化 Pandas基本介绍 Pandas像是字典形式的Numpy，它给Numpy的不同行和列都进行了命名。 Pandas数据结构及其创建 数据结构有两种：Series和DataFrame Series对象的创建：pd.Series(list) 和 pd.date_range(‘20160101’,periods =6) ---- 时间序列的创建。 DatetimeIndex(['20
pandas学习小结
xxy_yang的博客
07-09 209
Series Series创建一维数组 """ Series是一种一维的数组型对象，它包含了一个值序列（与NumPy中的类型相似），并且包含了数据标签，称为索引（index） """ # Series数组， 默认索引[0-N] obj = pd.Series([1, 2, 3, 4, 5]) # 设置索引 obj2 = pd.Series([4, 7, -7, 3], index=['a', 'b', 'c', 'e']) Series数组读取， 更新数据 """ Series 数据读取 """ ob
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值