pandas模块的DataFrame基本介绍

「爱情、让人受尽委屈。」 2022-05-31 00:50 810阅读 0赞

import numpy as np  
import pandas as pd  
  
**ser = pd.Series(np.arange(3.))**  
  
**data=pd.DataFrame(np.arange(16).reshape(4,4),index=list('abcd'),columns=list('wxyz'))**    
  
print ser  
  
0    0.0  
1    1.0  
2    2.0  
dtype: float64  
  
print data  
  
    w   x   y   z  
a   0   1   2   3  
b   4   5   6   7  
c   8   9  10  11  
d  12  13  14  15  
  
  
import pandas as pd  
  
**df = pd.DataFrame(\[\[1,2,3\],\[4,5,6\]\])**  
  
print df  
  
   0  1  2  
0  1  2  3  
1  4  5  6  
  
**没有指定列名和索引。 这时列名就自动为 0,1,2 ；索引自动为数值0,1.**  
  
  
**df = pd.DataFrame(\[\[1,2,3\],\[4,5,6\]\],index=\['row1','row2'\],columns=\['c1','c2','c3'\])**  
  
print df  
  
      c1  c2  c3  
row1   1   2   3  
row2   4   5   6  
  
import numpy as np  
  
**dates = pd.date\_range('20121001',periods=6)**  
**df = pd.DataFrame(np.random.randn(6,4) , index = dates,columns=list('abcd'))**  
  
print df  
  
  
                   a         b         c         d  
2012-10-01 -0.236220  0.586985  0.784953 -0.507129  
2012-10-02 -1.020807 -1.316997 -0.747997  1.909333  
2012-10-03  0.085208 -0.281736  1.112287  1.572577  
2012-10-04  0.008708 -0.925711 -0.615752 -1.183397  
2012-10-05  1.158198 -1.393678  0.586624  0.202499  
2012-10-06  1.149878 -2.383863  1.646403  1.647935  
  
上面代码创建的dates是个时间索引， **np.random.randn 方法创建一个6行4列的随机数矩阵** 。  
  
最后的df使用 dates作为索引，使用np.random.randn 方法创建的矩阵作为内容， **使用 list('abcd'）作为列名。 **  
  
  
3、显示数据  
  
  
**df.head(\[n\])  \# 获取df中的前n行数据，n不指定，则默认为5**  
  
  
**df.tail(\[n\])  \# 获取df中的后n行数据，n不指定，则默认为5**  
  
dates = pd.date\_range('20121001',periods=100)  
df = pd.DataFrame(np.random.randn(100,4) , index = dates,columns=list('abcd' ))    
df.head()  
  
                   a         b         c         d  
2012-10-01 -1.010746  0.176277 -0.838870  0.742626  
2012-10-02  0.111174  0.182840  0.193215  1.517350  
2012-10-03 -0.757385  1.137521 -0.247181  0.659187  
2012-10-04 -1.157838  1.464957 -2.106226  1.160796  
2012-10-05  0.141747  0.032917  0.647210 -0.861413  
  
\[5 rows x 4 columns\]  
  
**df.tail()**  
                   a         b         c         d  
2013-01-04 -0.225416 -1.436526 -0.349813 -0.130948  
2013-01-05 -1.544653 -0.214760  1.455662  0.050591  
2013-01-06  0.582737 -0.646163 -1.763772 -1.463706  
2013-01-07 -0.694467  0.710954 -2.227337 -0.257376  
2013-01-08  0.282839 -1.100346  1.526374  1.658781  
  
**注意，head 和 tail 返回的是一个新的dataframe，与原来的无关**    
  
 4、按照索引排序  
  
**newdf = df.sort\_index(ascending=False,inplace=True)**  
  
  
**ascending=False 参数指定按照索引值的以降序方式排序，默认是以升序排序** 。  
  
  
**inplace=True 指定为True时，表示会直接对df中的数据进行排序，函数返回值为None，newdf的值为None；**  
  
  
如果不设置为True（默认为false），则不会对df中数据进行修改， **会返回一个新的df，这时newdf就有内容，是一个新的排序后的df。**  
  
  
5、添加数据(append方法)  
  
  
  **append方法可以添加数据到一个dataframe中，注意append方法不会影响原来的dataframe，会返回一个新的dataframe。**  
  
语法：  
  
**DataFrame.append(otherData, ignore\_index=False, verify\_integrity=False)**  
  
 其中otherData参数是要添加的新数据，支持多种格式。  
  
**ignore\_index 参数默认值为False，如果为True，会对新生成的dataframe使用新的索引（自动产生），忽略原来数据的索引。**  
  
**verify\_integrity参数默认值为False，如果为True，当ignore\_index为False时，会检查添加的数据索引是否冲突，如果冲突，则会添加失败。**  
  
  
dates = pd.date\_range('20121001',periods=10)  
  
df = pd.DataFrame(np.random.randn(10,4) , index = dates,columns=list('abcd'))   
  
dates1 = pd.date\_range('20121001',periods=2)  
  
df1 = pd.DataFrame(np.random.randn(2,4) , index = dates1,columns=list('abcd'))   
  
  
df.append(df1) \# df1中的2行数据会加到df中，且新产生的df的各行的索引就是原来数据的索引  
  
**df.append(df1,ignore\_index=True) \# df1中的2行数据会加到df中，且新产生的df的索引会重新自动建立**  
  
df.append(df1,verify\_integrity=True) \#会报错，因为df1的索引和df2的索引冲突了  
  
**说明，df1的列名必须和df一致，否则不是简单的添加行。而是会添加列，再添加行。**  
  
df.append(\{'a':10,'b':11,'c':12,'d':13\},ignore\_index=True)  
   
            a          b          c          d  
0   -0.471061  -0.937725  -1.444073   0.640439  
1   -0.732039  -1.617755   0.281875   1.179076  
2    1.115559   0.136407  -2.225551   0.119433  
3    0.695137   0.380088  -0.318689  -0.048248  
4    1.483151  -0.124202  -0.722126   0.035601  
5    0.326048  -0.139576  -0.172726   0.931670  
6    0.858305   0.857661  -0.279078   0.583740  
7   -0.041902   0.408085  -1.019313   0.005968  
8    0.626730   0.143332  -0.404894   0.377950  
9   -1.850168   0.430794  -0.534981  -0.738701  
**10  10.000000  11.000000  12.000000  13.000000**  
  
上面代码是新产生的df会添加一行。这种操作， **ignore\_index参数值必须设置为True** ，否则会报错。  
  
df.append(\{'e':10\},ignore\_index=True)  
           a         b         c         d   e  
0  -0.471061 -0.937725 -1.444073  0.640439 NaN  
1  -0.732039 -1.617755  0.281875  1.179076 NaN  
2   1.115559  0.136407 -2.225551  0.119433 NaN  
3   0.695137  0.380088 -0.318689 -0.048248 NaN  
4   1.483151 -0.124202 -0.722126  0.035601 NaN  
5   0.326048 -0.139576 -0.172726  0.931670 NaN  
6   0.858305  0.857661 -0.279078  0.583740 NaN  
7  -0.041902  0.408085 -1.019313  0.005968 NaN  
8   0.626730  0.143332 -0.404894  0.377950 NaN  
9  -1.850168  0.430794 -0.534981 -0.738701 NaN  
10       NaN       NaN       NaN       NaN  10   
  
可以看出， **如果插入的数据，指定的列名不存在，新产生的df不仅会增加行，还会增加列** 。  
  
6、遍历数据  
  
**for index,row in df.iterrows():**  
  
    print index \#获取行的索引  
  
    print row.a \#根据列名获取字段  
  
    print row\[0\]\#根据列的序号（从0开始）获取字段   
  
7、查找数据  
  
dates = pd.date\_range('20121001',periods=10)  
  
df = pd.DataFrame(np.random.randn(10,4) , index = dates,columns=list('abcd'))  
  
可以有各种方式获取df中的全部或部分数据  
  
**df\['a'\]  \#按照列名获取指定的列，返回的是一个Series，其中key是索引，value是该列对应的字段值**  
  
**df\[:2\] \#获取前2行数据，效果等同 df\[0:2\]，返回的是一个新的dataframe**  
  
**df\[2:5\] \#获取第3行~5行 这3条记录，返回的是一个新的dataframe**  
  
**df.loc\['20121009'\] \#获取指定索引的行，等同于  df.loc\['2012-10-09'\]，返回的是一个Series，其中key是列名，value是该列对应的字段值**  
  
**df.iloc\[3\]  \#获取指定序号的行，这里是第4行**  
  
8、删除数据  
  
**del df\['a'\]  \#删除dataframe中指定的列，这个是直接影响当前的dataframe** ，注意 del不是函数，是python中的内置语句，没有返回值  
  
**df.drop(\['a'\],axis=1)  \#删除指定的列，与上面的区别是不会影响原来的dataframe，dop方法会返回一个删除了指定列的新的dataframe**  
  
  
说明，dop方法既可以删除列，也可以删除行，但上面创建的df无法被删除行（?），下面这个例子可以删除行  
  
  
**data = pd.DataFrame(np.arange(16).reshape((4, 4)),index=\['Ohio', 'Colorado', 'Utah', 'New York'\],columns=\['one', 'two', 'three', 'four'\])**  
  
  
**data.drop(\['Colorado', 'Ohio'\])**  
  
上面代码中的dop方法删除了指定索引的两行，注意同删除列一样，drop方法不会影响原来的dataframe，会返回一个删除后的新的dataframe  
  
  
9、增加列  
  
dates = pd.date\_range('20121001',periods=10)  
df = pd.DataFrame(np.random.randn(10,3) , index = dates,columns=list('abc'))   
  
**df\['d'\] = pd.Series(np.random.randn(10),index=df.index)**  
****  
上面代码先是创建了一个dataframe，然后通过df\['d'\] 插入了一个新的列。如果指定的列名存在，会修改列的内容。  
  
  
10、修改指定行或单元格数据  
  
**df.values\[i\]\[j\]= xxx  \#其中i是行号，j是列号，都是从0开始**  
  
**df.values\[1\]=12  \# 会把一行中的所有列中的数据设置为同一个值** ，这里的参数1是序号，这里为第2行数据  
  
  
**df\['a'\] = 12  \#这样会把指定列的所有数据都设置为同一个值** ，如这里的12。 **注意，如果指定的列名不存在，会新增列**  
  
  
11、插入行  
  
前面介绍的append方法是产生一个新的 dataframe，不会改变原来的dataframe。  
  
那有没有办法直接在当前的frame中插入一行数据呢？  上面介绍的 df\[列名\] = xxx 是用来插入或修改列的信息。  
  
  
pd.DataFrame()   
  
参数：   
1、二维array；   
2、Series 列表；   
3、value为Series的字典；  
  
a.1、二维array  
  
import pandas as pd  
import numpy as np  
  
  
s1=np.array(\[1,2,3,4\])  
s2=np.array(\[5,6,7,8\])  
  
**df=pd.DataFrame(\[s1,s2\])**  
  
print df  
![dataFrame二维数组create][dataFrame_create]  
   
dataFrame二维数组create  
  
a.2、Series列表（效果与二维array相同）  
  
import pandas as pd  
import numpy as np  
  
s1=pd.Series(np.array(\[1,2,3,4\]))  
s2=pd.Series(np.array(\[5,6,7,8\]))  
  
**df=pd.DataFrame(\[s1,s2\])**  
  
print df  
![Series列表][Series]   
  
a.3、value为Series的字典结构；  
  
  
import pandas as pd  
import numpy as np  
  
  
s1=pd.Series(np.array(\[1,2,3,4\]))  
s2=pd.Series(np.array(\[5,6,7,8\]))  
  
**df=pd.DataFrame(\{"a":s1,"b":s2\});**  
  
print df  
![value为Series的字典结构][value_Series]   
  
value为Series的字典结构   
注：若创建使用的参数中，array、Series长度不一样时，对应index的value值若不存在则为NaN  
  
b.属性  
  
b.1 .columns :每个columns对应的keys  
  
b.2 .shape:形状，（a，b）,index长度为a,columns数为b  
  
b.3 .index;.values:返回index列表；返回value二维array  
  
b.4 .head();.tail();  
  
c.if-then 操作  
  
c.1使用.ix\[\]  
  
df=pd.DataFrame(\{"A":\[1,2,3,4\],"B":\[5,6,7,8\],"C":\[1,1,1,1\]\})  
  
**df.ix\[df.A>1,'B'\]= -1**  
  
print df  
  
![pandas11][]    
  
**df.ix\[条件，then操作区域\]**  
  
  
df=pd.DataFrame(\{"A":\[1,2,3,4\],"B":\[5,6,7,8\],"C":\[1,1,1,1\]\})  
  
**df\["then"\]=np.where(df.A<3,1,0)**  
  
print df  
  
  
![pandas12][]  
   
np.where(条件，then，else)  
  
  
d.根据条件选择取DataFrame  
  
  
d.1 直接取值df.\[\]  
  
df=pd.DataFrame(\{"A":\[1,2,3,4\],"B":\[5,6,7,8\],"C":\[1,1,1,1\]\})  
**df=df\[df.A>=2\]**  
print df  
![pandas13][]   
d.2 使用.loc\[\]  
  
df=pd.DataFrame(\{"A":\[1,2,3,4\],"B":\[5,6,7,8\],"C":\[1,1,1,1\]\})  
**df=df.loc\[df.A>2\]**  
print df  
  
  
  
**e.1groupby 形成group**  
  
  
df = pd.DataFrame(\{'animal': 'cat dog cat fish dog cat cat'.split(),  
                  'size': list('SSMMMLL'),  
                  'weight': \[8, 10, 11, 1, 20, 12, 12\],  
                  'adult' : \[False\] \* 5 + \[True\] \* 2\});  
\#列出动物中weight最大的对应size  
  
**group=df.groupby("animal").apply(lambda subf: subf\['size'\]\[subf\['weight'\].idxmax()\])**  
  
print group  
![grouping][]   
  
grouping   
  
**e.2 使用get\_group 取出其中一分组**  
  
  
df = pd.DataFrame(\{'animal': 'cat dog cat fish dog cat cat'.split(),  
                  'size': list('SSMMMLL'),  
                  'weight': \[8, 10, 11, 1, 20, 12, 12\],  
                  'adult' : \[False\] \* 5 + \[True\] \* 2\});  
  
  
**group=df.groupby("animal")  
**  
**cat=group.get\_group("cat")**  
  
print cat  
  
![get\_group][get_group]   
  
data\['w'\]  \#选择表格中的'w'列，使用类字典属性,返回的是Series类型  
  
data.w    \#选择表格中的'w'列，使用点属性,返回的是Series类型  
  
**data\[\['w'\]\]  \#选择表格中的'w'列，返回的是DataFrame类型**  
  
**data\[\['w','z'\]\]  \#选择表格中的'w'、'z'列**  
  
data\[0:2\]  \#返回第1行到第2行的所有行，前闭后开，包括前不包括后  
  
data\[1:2\]  \#返回第2行，从0计，返回的是单行，通过有前后值的索引形式，  
       \#如果采用data\[1\]则报错  
  
**data.ix\[1:2\] \#返回第2行的第三种方法，返回的是DataFrame，跟data\[1:2\]同**  
  
data\['a':'b'\]  \#利用index值进行切片，返回的是\*\*前闭后闭\*\*的DataFrame,   
        \#即末端是包含的    
  
  
**data.irow(0)   \#取data的第一行**  
  
  
**data.icol(0)   \#取data的第一列**  
  
  
data.head()  \#返回data的前几行数据，默认为前五行，需要前十行则data.head(10)  
  
data.tail()  \#返回data的后几行数据，默认为后五行，需要后十行则data.tail(10)  
  
  
**ser.iget\_value(0)  \#选取ser序列中的第一个**  
  
  
**ser.iget\_value(-1) \#选取ser序列中的最后一个** ，这种轴索引包含索引器的series不能采用ser\[-1\]去获取最后一个，这会引起歧义。  
  
  
**data.iloc\[-1\]   \#选取DataFrame最后一行，返回的是Series**  
  
**data.iloc\[-1:\]   \#选取DataFrame最后一行，返回的是DataFrame**  
  
  
**data.loc\['a',\['w','x'\]\]   \#返回‘a’行'w'、'x'列，这种用于选取行索引列索引已知**  
  
  
**data.iat\[1,1\]   \#选取第二行第二列，用于已知行、列位置的选取。 **  
  
  
  
在pandas中创建一个空DataFrame的方法，类似于创建了一个空字典（dict）。  
  
  
例如：empty = pandas.DataFrame(\{"name":"","age":"","sex":""\})?  
  
  
想要向empty中插入一行数据，可以用同样的方法?。  
  
  
（1）首先，要创建一个DataFrame。要注意，在这里需加入index属性，  
  
 **new = pandas.DataFrame(\{"name":"","age":"","sex":""\},index=\["0"\])。**  
  
（2）然后，开始插值。ignore\_index=True,可以帮助忽略index，自动递增。  
  
  
**empty.append(new,ignore\_index=True)**  
  
  
（3）最重要的，赋值给empty.  
  
  
empty = empty.append(new,ignore\_index=True)  
  
  
否则，数据始终没有写入。  
  
  
1.查看DataFrame前xx行或后xx行  
  
a=DataFrame(data);  
  
a.head(6)表示显示前6行数据，若head()中不带参数则会显示全部数据。  
a.tail(6)表示显示后6行数据，若tail()中不带参数则也会显示全部数据。  
  
  
2.查看DataFrame的index，columns以及values  
  
**a.index ; a.columns ; a.values 即可**  
  
  
3.describe()函数对于数据的快速统计汇总  
  
**a.describe()对每一列数据进行统计，包括计数，均值，std，各个分位数等。**  
  
  
4.对数据的转置  
  
**a.T**  
  
5.对轴进行排序  
  
**a.sort\_index(axis=1,ascending=False)；**  
  
**其中axis=1表示对所有的columns进行排序，下面的数也跟着发生移动** 。  
  
 后面的ascending=False表示按降序排列，参数缺失时默认升序。  
  
  
6.对DataFrame中的值排序  
  
**a.sort(columns='x')**  
  
**即对a中的x这一列，从小到大进行排序** 。注意仅仅是x这一列，而上面的按轴进行排序时会对所有的columns进行操作。  
  
  
二、选择对象  
  
  
1.选择特定列和行的数据  
  
**a\['x'\] 那么将会返回columns为x的列，注意这种方式一次只能返回一个列。a.x与a\['x'\]意思一样** 。  
  
  
取行数据，通过切片\[\]来选择  
  
如： **a\[0:3\] 则会返回前三行的数据** 。  
  
  
2.loc是通过标签来选择数据  
  
**a.loc\['one'\]则会默认表示选取行为'one'的行；**  
  
  
**a.loc\[:,\['a','b'\] \] 表示选取所有的行以及columns为a,b的列；**  
  
  
**a.loc\[\['one','two'\],\['a','b'\]\] 表示选取'one'和'two'这两行以及columns为a,b的列；**  
  
  
a.loc\['one','a'\]与a.loc\[\['one'\],\['a'\]\]作用是一样的，不过前者只显示对应的值，而后者会显示对应的行和列标签。  
  
  
3.iloc则是直接通过位置来选择数据  
这与通过标签选择类似  
  
**a.iloc\[1:2,1:2\] 则会显示第一行第一列的数据;(切片后面的值取不到)**  
  
  
a.iloc\[1:2\] 即后面表示列的值没有时，默认选取行位置为1的数据;  
  
  
a.iloc\[\[0,2\],\[1,2\]\] 即可以自由选取行位置，和列位置对应的数据。  
  
  
4.使用条件来选择  
使用单独的列来选择数据  
  
**a\[a.c>0\] 表示选择c列中大于0的数据**  
  
  
使用where来选择数据  
  
**a\[a>0\] 表直接选择a中所有大于0的数据**  
  
  
使用isin()选出特定列中包含特定值的行  
  
a1=a.copy()  
  
**a1\[a1\['one'\].isin(\['2','3'\])\] 表显示满足条件：列one中的值包含'2','3'的所有行。**  
  
  
三、设置值（赋值）  
  
  
赋值操作在上述选择操作的基础上直接赋值即可。  
  
例  
  
**** **a.loc\[:,\['a','c'\]\]=9 即将a和c列的所有行中的值设置为9**  
  
a.iloc\[:,\[1,3\]\]=9 也表示将a和c列的所有行中的值设置为9  
  
  
同时也依然可以用条件来直接赋值  
  
**a\[a>0\]=-a 表示将a中所有大于0的数转化为负值**  
  
  
四、缺失值处理  
  
  
**在pandas中，使用np.nan来代替缺失值，这些值将默认不会包含在计算中。**  
  
1.reindex()方法  
  
用来对指定轴上的索引进行改变/增加/删除操作，这将返回原始数据的一个拷贝。  
  
a.reindex(index=list(a.index)+\['five'\],columns=list(a.columns)+\['d'\])  
  
a.reindex(index=\['one','five'\],columns=list(a.columns)+\['d'\])  
  
**即用index=\[\]表示对index进行操作，columns表对列进行操作。**  
  
  
2.对缺失值进行填充  
  
**a.fillna(value=x)**  
  
表示用值为x的数来对缺失值进行填充  
  
  
3.去掉包含缺失值的行  
**a.dropna(how='any')  
**  
表示去掉所有包含缺失值的行  
  
  
五、合并  
  
1.contact  
contact(a1,axis=0/1，keys=\['xx','xx','xx',...\])，  
  
 其中a1表示要进行连接的列表数据, **axis=1时表横着对数据进行连接** 。  
  
 **axis=0或不指定时，表将数据竖着进行连接。**  
  
 a1中要连接的数据有几个则对应几个keys，设置keys是为了在数据连接以后区分每一个原始a1中的数据。  
  
  
例：a1=\[b\['a'\],b\['c'\]\]  
  
result=pd.concat(a1,axis=1，keys=\['1','2'\])  
  
  
2.Append 将一行或多行数据连接到一个DataFrame上  
  
a.append(a\[2:\],ignore\_index=True)  
  
表示将a中的第三行以后的数据全部添加到a中，若不指定ignore\_index参数，则会把添加的数据的index保留下来，  
  
**** **若ignore\_index=Ture则会对所有的行重新自动建立索引。**  
  
  
  
3.merge类似于SQL中的join  
  
设a1,a2为两个dataframe,二者中存在相同的键值，两个对象连接的方式有下面几种：  
  
(1)内连接，pd.merge(a1, a2, on='key')  
(2)左连接，pd.merge(a1, a2, on='key', how='left')  
(3)右连接，pd.merge(a1, a2, on='key', how='right')  
(4)外连接， pd.merge(a1, a2, on='key', how='outer')  
至于四者的具体差别，具体学习参考sql中相应的语法。  
  
  
六、分组（groupby）  
  
  
**用pd.date\_range函数生成连续指定天数的的日期**  
  
pd.date\_range('20000101',periods=10)   
  
  
八、相关操作  
  
描述性统计：  
  
1. **a.mean() 默认对每一列的数据求平均值；若加上参数a.mean(1)则对每一行求平均值；**  
  
  
2. **统计某一列x中各个值出现的次数：a\['x'\].value\_counts()；**  
  
  
3.对数据应用函数  
  
**a.apply(lambda x:x.max()-x.min())    ** 表示返回所有列中最大值-最小值的差。  
  
  
4.字符串相关操作  
**a\['gender1'\].str.lower() 将gender1中所有的英文大写转化为小写，注意dataframe没有str属性，只有series有，所以要选取a中的gender1字段。**  
  
  
九、时间序列  
  
在六中用pd.date\_range('xxxx',periods=xx,freq='D/M/Y....')函数生成连续指定天数的的日期列表。  
例如pd.date\_range('20000101',periods=10),其中periods表示持续频数；  
pd.date\_range('20000201','20000210',freq='D')也可以不指定频数，只指定起始日期。  
  
  
import pandas as pd    
import re    
import math    
  
  
dframe1 = pd.read\_excel("window regulator分析报告数据对比源.xlsx", sheetname="Sheet1") \#读取数据    
  
dframe2 = pd.read\_excel("window regulator分析报告数据对比源.xlsx", sheetname="Sheet2")\#    
  
  
**dframe1\["sku"\] ="\#" \#添加一列数据，初始化为\#  **  
    
df = pd.DataFrame(columns = \["ebayno", "p\_sku", "sale", "sku"\]) \#创建一个空的dataframe    
  
  
\# print(df)    
  
  
sku = dframe2.sku.values    
  
  
p\_skus = dframe2.p\_sku.values    
  
  
\# print(p\_skus)    
  
  
i = 0    
for ps in p\_skus :    
    dframe1.loc\[dframe1.p\_sku == ps,"sku"\] = sku\[i\]    
    
    \# print(dframe1.loc\[dframe1.p\_sku == ps\])    
  
  
     **df = df.append(dframe1.loc\[dframe1.p\_sku == ps\], ignore\_index=True)  \#忽略索引,往dataframe中插入一行数据  **  
  
  
    \# print(df)    
    i = i + 1    
  
  
\# print(dframe1)    
\# print(sku.values) \#将series变成数组    
  
  
print(df)    
df = df\[\["sku","ebayno","sale"\]\] \#选取指定的列    
df.to\_csv("std.csv",encoding="gbk",index=False ) \#写入到csv时，不要将索引写入index = False

[dataFrame_create]: /images/20220531/68c0e272b5e24ab88a0dce17622c1bb3.png
[Series]: /images/20220531/bd276412a81b4341881db46b40961e92.png
[value_Series]: /images/20220531/7c7e0a1b7c0847ab9d8fc4d881a9fe4d.png
[pandas11]: /images/20220531/b83ca736e9584ff8b3d9237c2224f5d6.png
[pandas12]: /images/20220531/e4d8102b4a0d4380857b3e9c5d5894b5.png
[pandas13]: /images/20220531/f0b5cab48cbe4e4a93ee6bd282e6d12a.png
[grouping]: /images/20220531/61e2726679b3419a8e9e423b30843218.png
[get_group]: /images/20220531/900d142aaf1c4e5b81a461352c9bcece.png