python数据分析之pandas数据选取：df[] df.loc[] df.iloc[] df.ix[] df.at[] df.iat[]
千次阅读

2020-11-28 13:39:56

1 引言

Pandas是作为Python数据分析著名的工具包，提供了多种数据选取的方法，方便实用。本文主要介绍Pandas的几种数据选取的方法。

Pandas中，数据主要保存为Dataframe和Series是数据结构，这两种数据结构数据选取的方式基本一致，本文主要以Dataframe为例进行介绍。

在Dataframe中选取数据大抵包括3中情况：

1）行（列）选取（单维度选取）：df[]。这种情况一次只能选取行或者列，即一次选取中，只能为行或者列设置筛选条件（只能为一个维度设置筛选条件）。

2）区域选取（多维选取）：df.loc[]，df.iloc[]，df.ix[]。这种方式可以同时为多个维度设置筛选条件。

3）单元格选取（点选取）：df.at[]，df.iat[]。准确定位一个单元格。

接下来，我们以下面的数据为例，分别通过实例介绍这三种情况。

>>> importpandas as pd

>>> importnumpy as np

>>> data = {'name': ['Joe', 'Mike', 'Jack', 'Rose', 'David', 'Marry', 'Wansi', 'Sidy', 'Jason', 'Even'],

'age': [25, 32, 18, np.nan, 15, 20, 41, np.nan, 37, 32],

'gender': [1, 0, 1, 1, 0, 1, 0, 0, 1, 0],

'isMarried': ['yes', 'yes', 'no', 'yes', 'no', 'no', 'no', 'yes', 'no', 'no']}

>>> labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

>>> df = pd.DataFrame(data, index=labels)

>>>df

name age gender isMarried

a Joe 25.0 1yes

b Mike 32.00 yes

c Jack 18.0 1no

d Rose NaN 1yes

e David 15.00 no

f Marry 20.0 1no

g Wansi 41.00 no

h Sidy NaN 0 yes

i Jason 37.0 1no

j Even 32.0 0 no

2 行（列）选取：df[]

行（列）选取是在单一维度上进行数据的选取，即以行为单位进行选取或者以列为单位进行选取。Dataframe对象的行有索引（index），默认情况下是[0,1,2，……]的整数序列，也可以自定义添加另外的索引，例如上面的labels，（为区分默认索引和自定义的索引，在本文中将默认索引称为整数索引，自定义索引称为标签索引）。Dataframe对象的每一列都有列名，可以通过列名实现对列的选取。

1）选取行

选取行的方式包括三种：整数索引切片、标签索引切片和布尔数组。

a）整数索引切片：前闭后开

选取第一行：

>>> df[0:1]

name age gender isMarried

a Joe 25.0 1 yes

选取前两行：

>>> df[0:2]

name age gender isMarried

a Joe 25.0 1yes

b Mike 32.0 0 yes

b）标签索引切片：前闭后闭

选取第一行：

>>> df[:'a']

name age gender isMarried

a Joe 25.0 1 yes

选取前两行：

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

name age gender isMarried

a Joe 25.0 1yes

b Mike 32.0 0 yes

注意：整数索引切片是前闭后开，标签索引切片是前闭后闭，这点尤其要注意。

c）布尔数组

选取前三行

>>>df[[True,True,True,False,False,False,False,False,False,False]]

name age gender isMarried

a Joe 25.0 1yes

b Mike 32.00 yes

c Jack 18.0 1 no

选取所有age大于30的行

>>> df[[each>30 for each in df['age']]]

name age gender isMarried

b Mike 32.00 yes

g Wansi 41.00 no

i Jason 37.0 1no

j Even 32.0 0 no

通过布尔数组的方式，又可以衍生出下面的选取方式：

选取所有age大于30的行

>>> df[df['age']>30]

name age gender isMarried

b Mike 32.00 yes

g Wansi 41.00 no

i Jason 37.0 1no

j Even 32.0 0 no

选取出所有age大于30，且isMarried为no的行

>>> df[(df['age']>30) & (df['isMarried']=='no')]

name age gender isMarried

g Wansi 41.00 no

i Jason 37.0 1no

j Even 32.0 0 no

选取出所有age为20或32的行

>>> df[(df['age']==20) | (df['age']==32)]

name age gender isMarried

b Mike 32.00 yes

f Marry 20.0 1no

j Even 32.0 0 no

注意：像上面这种通过多个布尔条件判断的情况，多个条件最好（一定）用括号括起来，否则非常容易出错。

2）列选取

列选取方式也有三种：标签索引、标签列表、Callable对象

a）标签索引：选取单个列

选取name列所有数据

>>> df['name']

a Joe

b Mike

c Jack

d Rose

e David

f Marry

g Wansi

h Sidy

i Jason

j Even

Name: name, dtype: object

b）标签列表：选取多个列

选取name和age两列数据

>>> df[['name','age']]

name age

a Joe 25.0b Mike 32.0c Jack 18.0d Rose NaN

e David 15.0f Marry 20.0g Wansi 41.0h Sidy NaN

i Jason 37.0j Even 32.0

c）callable对象

选取第一列

>>> df[lambdadf: df.columns[0]]

a Joe

b Mike

c Jack

d Rose

e David

f Marry

g Wansi

h Sidy

i Jason

j Even

Name: name, dtype: object

3 区域选取

区域选取可以从多个维度（行和列）对数据进行筛选，可以通过df.loc[]，df.iloc[]，df.ix[]三种方法实现。采用df.loc[]，df.iloc[]，df.ix[]这三种方法进行数据选取时，方括号内必须有两个参数，第一个参数是对行的筛选条件，第二个参数是对列的筛选条件，两个参数用逗号隔开。df.loc[]，df.iloc[]，df.ix[]的区别如下：

df.loc[]只能使用标签索引，不能使用整数索引，通过便签索引切边进行筛选时，前闭后闭。

df.iloc[]只能使用整数索引，不能使用标签索引，通过整数索引切边进行筛选时，前闭后开。；

df.ix[]既可以使用标签索引，也可以使用整数索引。

下面分别通过实例演示这三种方法。

3.1 df.loc[]

1）对行进行选取

选取索引为‘a’的行：

>>> df.loc['a', :]

name Joe

age 25gender 1isMarried yes

Name: a, dtype: object

选取索引为‘a’或‘b’或‘c’的行

>>> df.loc[['a','b','c'], :]

name age gender isMarried

a Joe 25.0 1yes

b Mike 32.00 yes

c Jack 18.0 1 no

选取从‘a’到‘d’的所有行（包括‘d’行）

>>> df.loc['a':'d', :]

name age gender isMarried

a Joe 25.0 1yes

b Mike 32.00 yes

c Jack 18.0 1no

d Rose NaN 1 yes

用布尔数组选取前3行

>>>df.loc[[True,True,True,False,False,False], :]

name age gender isMarried

a Joe 25.0 1yes

b Mike 32.00 yes

c Jack 18.0 1 no

选取所有age大于30的行

>>> df.loc[df['age']>30,:]

name age gender isMarried

b Mike 32.00 yes

g Wansi 41.00 no

i Jason 37.0 1no

j Even 32.0 0 no

也可以使用下面两方法：

>>> df.loc[df.loc[:,'age']>30, :]

name age gender isMarried

b Mike 32.00 yes

g Wansi 41.00 no

i Jason 37.0 1no

j Even 32.00 no

>>> df.loc[df.iloc[:,1]>30, :]

name age gender isMarried

b Mike 32.00 yes

g Wansi 41.00 no

i Jason 37.0 1no

j Even 32.0 0 no

用callable对象选取age大于30的所有行

>>> df.loc[lambda df:df['age'] > 30, :]

name age gender isMarried

b Mike 32.00 yes

g Wansi 41.00 no

i Jason 37.0 1no

j Even 32.0 0 no

2）对列选取

输出所有人的姓名（选取name列）

>>> df.loc[:, 'name']

a Joe

b Mike

c Jack

d Rose

e David

f Marry

g Wansi

h Sidy

i Jason

j Even

Name: name, dtype: object

输出所有人的姓名和年龄（选取name和age列）

>>> df.loc[:, 'name':'age']

name age

a Joe 25.0b Mike 32.0c Jack 18.0d Rose NaN

e David 15.0f Marry 20.0g Wansi 41.0h Sidy NaN

i Jason 37.0j Even 32.0

输出所有人的姓名、年龄、婚否（选取name、age、isMarried列）

>>> df.loc[:, ['name','age','isMarried']]

name age isMarried

a Joe 25.0yes

b Mike 32.0yes

c Jack 18.0no

d Rose NaN yes

e David 15.0no

f Marry 20.0no

g Wansi 41.0no

h Sidy NaN yes

i Jason 37.0no

j Even 32.0 no

用布尔数组的方式选取前3列

>>>df.loc[:, [True,True,True,False]]

name age gender

a Joe 25.0 1b Mike 32.00

c Jack 18.0 1d Rose NaN 1e David 15.00

f Marry 20.0 1g Wansi 41.00

h Sidy NaN 0

i Jason 37.0 1j Even 32.0 0

3）同时对行和列进行筛选

输出年龄大于30的人的姓名和年龄

>>> df.loc[df['age']>30,['name','age']]

name age

b Mike 32.0g Wansi 41.0i Jason 37.0j Even 32.0

输出行名为‘Mike’或‘Marry’的姓名和年龄

>>> df.loc[(df['name']=='Mike') |(df['name']=='Marry'),['name','age']]

name age

b Mike 32.0f Marry 20.0

3.2 df.iloc[]

1）行选取

选取第2行

>>> df.iloc[1, :]

name Mike

age 32gender 0

isMarried yes

Name: b, dtype: object

选取前3行

>>> df.iloc[:3, :]

name age gender isMarried

a Joe 25.0 1yes

b Mike 32.00 yes

c Jack 18.0 1 no

选取第2行、第4行、第6行

>>> df.iloc[[1,3,5],:]

name age gender isMarried

b Mike 32.00 yes

d Rose NaN 1yes

f Marry 20.0 1 no

通过布尔数组选取前3行

>>>df.iloc[[True,True,True,False,False,False], :]

name age gender isMarried

a Joe 25.0 1yes

b Mike 32.00 yes

c Jack 18.0 1 no

2）列选取

选取第2列

>>> df.iloc[:, 1]

a 25.0b 32.0c 18.0d NaN

e 15.0f 20.0g 41.0h NaN

i 37.0j 32.0Name: age, dtype: float64

选取前3列

>>> df.iloc[:, 0:3]

name age gender

a Joe 25.0 1b Mike 32.00

c Jack 18.0 1d Rose NaN 1e David 15.00

f Marry 20.0 1g Wansi 41.00

h Sidy NaN 0

i Jason 37.0 1j Even 32.00

l 选取第1列、第3列、第4列

选取第1列、第3列和第4列

>>> df.iloc[:, [0,2,3]]

name gender isMarried

a Joe 1yes

b Mike 0 yes

c Jack 1no

d Rose 1yes

e David 0 no

f Marry 1no

g Wansi 0 no

h Sidy 0 yes

i Jason 1no

j Even 0 no

通过布尔数组选取前3列

>>>df.iloc[:,[True,True,True,False]]

name age gender

a Joe 25.0 1b Mike 32.00

c Jack 18.0 1d Rose NaN 1e David 15.00

f Marry 20.0 1g Wansi 41.00

h Sidy NaN 0

i Jason 37.0 1j Even 32.0 0

3）同时选取行和列

选取第2行的第1列、第3列、第4列

>>> df.iloc[1, [0,2,3]]

name Mike

gender 0

isMarried yes

Name: b, dtype: object

选取前3行的前3列

>>> df.iloc[:3, :3]

name age gender

a Joe 25.0 1b Mike 32.00

c Jack 18.0 1

3.3 df.ix[]

df.ix[]既可以通过整数索引进行数据选取，也可以通过标签索引进行数据选取，换句话说，df.ix[]是df.loc[]和df.iloc[]的功能集合，且在同义词选取中，可以同时使用整数索引和标签索引。

选取第3行的name数据

>>> df.ix[2,'name']

'Jack'

选取a行、c行的第1列，第2列和第4列数据

>>> df.ix[['a','c'], [0,1,3]]

name age isMarried

a Joe 25.0yes

c Jack 18.0 no

选取所有未婚者的姓名和年龄

>>> df.ix[df['isMarried']=='no',['name','age']]

name age

c Jack 18.0e David 15.0f Marry 20.0g Wansi 41.0i Jason 37.0j Even 32.0

4 单元格选取

单元格选取包括df.at[]和df.iat[]两种方法。df.at[]和df.iat[]使用时必须输入两个参数，即行索引和列索引，其中df.at[]只能使用标签索引，df.iat[]只能使用整数索引。df.at[]和df.iat[]选取的都是单个单元格（单行单列），所以返回值都为基本数据类型。

4.1 df.at[]

选取b行的name列

>>> df.at['b','name']

'Mike'

4.2 df.iat[]

选取第2行第1列

>>> df.iat[1,0]

'Mike'

5 拓展与总结

1）选取某一整行（多个整行）或某一整列（多个整列）数据时，可以用df[]、df.loc[]、df.iloc[]，此时df[]的方法书写要简单一些。

2）进行区域选取时，如果只能用标签索引，则使用df.loc[]或df.ix[]，如果只能用整数索引，则用df.iloc[]或df.ix[]。不过我看到有资料说，不建议使用df.ix[],因为df.loc[]和df.iloc[]更精确（有吗？我没理解精确在哪，望告知）。

3）如果选取单元格，则df.at[]、df.iat[]、df.loc[]、df.iloc[]都可以，不过要注意参数。

4）选取数据时，返回值存在以下情况：

如果返回值包括单行多列或多行单列时，返回值为Series对象；

如果返回值包括多行多列时，返回值为DataFrame对象；

如果返回值仅为一个单元格（单行单列）时，返回值为基本数据类型，例如str，int等。

5）df[]的方式只能选取行和列数据，不能精确到单元格，所以df[]的返回值一定DataFrame或Series对象。

6）当使用DataFrame的默认索引（整数索引）时，整数索引即为标签索引。例如，使用上面的data实例化一个DataFrame对象：

>>> df2 =pd.DataFrame(data)

>>> df2.loc[1,'name']

'Mike'

>>> df2.iloc[1,0]

'Mike'

更多相关内容

df的索引

千次阅读 2020-05-16 00:31:21

df 的索引 df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]], index=[4, 5, 6], columns=['A', 'B', 'C']) A B C 4 0 2 3 5 0 4 1 6 10 20 30 # 获取某些列——用列名得到的还是df df['A'] 4 0 5 0 6 10 ...

通过df 的索引提取数据

在使用DataFrame时我们经常涉及到行和列的获取，下面将介绍基础版的通过行和列的索引名或者位置来提取DataFrame中的信息。
目前Python 3.7中涉及到的行和列的索引主要有四个.at .iat .loc .iloc 其中只要加上了i就表示是使用行列的索引位置，即0开始的数据进行索引.
进一步分类at[x,y]是提取某一个具体的值，同时需要行索引和列索引的信息x 是行，y 是列；loc则是提取行和列，loc[x,y]，x表示行信息，y表示列信息；x单独存在时就表示提取行。x和y可以是列表，单个行和列时可以是字符串，也可以使用 a:b。提取列还可以则直接使用df[col_name],但是不能提取连续的列，所以还得使用loc.
此外还可以使用布尔值进行提取。
综上，提取列可以使用
df.col_name,
df[col_name],
df[[col_name1,col_name2]],
df[col_name1,col_name2],
df.loc[:,col_name] ,
df.iloc[:,col_x]
提取行使用
df.loc[row_name],
df.loc[[row_name1,row_name2]],
df.iloc[row_x] ,
df.iloc[[row_x1,row_x2]] ,
df.loc[row_name,:] ,
df.iloc[row_x,:]
提取某个位置的元素使用 df.at[row_name,col_name],df.iat[row_x,col_x],df.loc[row_name,col_name],df.iloc[row_x,col_x]
提取一块则使用
df.loc[[row_name1,row_name2],[col_name1,col_name2],
df.loc[row_name1:row_name2,col_name1:col_name2]
df.iloc[[row_x1,row_x2],[col_x1,col_x2]],
df.iloc[row_x1:row_x2,col_x1:col_x2]
df.loc[:,[col_name1,col_name2]]
df.loc[ row_name1:row_name2,:]

提取某个具体的位置

df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],
                  index=[4, 5, 6], columns=['A', 'B', 'C'])
    A   B   C
4   0   2   3
5   0   4   1
6  10  20  30
df2 = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],
                   columns=['A', 'B', 'C'])
# at+行名称和列名称 行名 列名可以是默认的位置索引,但是已经有行名和列名的情况下，就不能使用默认的位置索引
df.at[4, 'B'] #必须使用行名称或者列名称
2
df.at[2, 'B'] #报错
df.iat[1, 2] #必须使用行和列的位置索引
1
df.loc[0].iat[1] # 先选取行，再选取列的位置
2
df.loc[5].at['B'] # 先选取行，再选取列的名称
4
df.loc['cobra', 'shield'] # 行和列名
df2.loc[2,'A'] 
2
df.iloc[1,2]

提取列

df = pd.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],
                  index=[4, 5, 6], columns=['A', 'B', 'C'])
    A   B   C
4   0   2   3
5   0   4   1
6  10  20  30

# 获取一列——用列名 得到数据类型是Series
df['A']
4     0
5     0
6    10
print(type(df['A']))
<class 'pandas.core.series.Series'>
df.A
4     0
5     0
6    10
Name: A, dtype: int64
print(type(df.A))
<class 'pandas.core.series.Series'>
# 获取一列---数据类型是Dataframe
df[['A']]
    A
4   0
5   0
6  10
print(type(df[['A']]))
<class 'pandas.core.frame.DataFrame'>
df.iloc[:,0] 3获取第 一列

df.iloc[:,0] # 获取第一列 
print(type(df.iloc[:,0]))
<class 'pandas.core.series.Series'>
df.iloc[:,-1] #最后  一列
# 获取某些列——用列名 得到数据类型是Dataframe
df[['A','B']]
    A   B
4   0   2
5   0   4
6  10  20
print(type(df[['A','B']]))
<class 'pandas.core.frame.DataFrame'>

# 获取多列
df[['A','B']] # 直接使用列名
    A   B
4   0   2
5   0   4
6  10  20

'''使用loc+列名'''
df.loc[:, 'A'] # 第一类列 .loc 是按索引名来
print(type(df.loc[:, 'A']))
<class 'pandas.core.series.Series'>
df.loc[:, ['A','B']] #DataFrame
df.loc[:, 'A':'B'] # 从A列到B列

'''使用iloc+位置索引'''
df.iloc[:, 0] # 第一类列 是按排序索引来 
df.iloc[:, [0,1]] #前两列
df.iloc[:, 0:1] #前1列 左闭右开
    A
4   0
5   0
6  10

提取行


df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
     index=['cobra', 'viper', 'sidewinder'],
     columns=['max_speed', 'shield'])
     			max_speed  shield
cobra               1       2
viper               4       5
sidewinder          7       8
'''loc+行名'''
df.loc['viper'] #行的列表，使用索引名称
max_speed    4
shield       5
print(type(df.loc['viper']))
<class 'pandas.core.series.Series'>
df.loc[0] #报错 说明已经有行名的情况下，不能使用位置索引
df.loc[['viper', 'sidewinder']] # 多行
max_speed  shield
viper               4       5
sidewinder          7       8
df.loc['viper':'sidewinder']
            max_speed  shield
viper               4       5
sidewinder          7       8
'''iloc + 位置索引'''
df.iloc[0] #第一行，用位置索引
max_speed    1
shield       2
Name: cobra, dtype: int64
df.iloc[[0]]#第一行使用位置索引
max_speed  shield
cobra          1       2
df.iloc[[0, 1]]# 前两行 等价于 df.iloc[0, 1]
       max_speed  shield
cobra          1       2
viper          4       5
df.iloc[1:3] # 第2行到第3行
    A   B   C
5   0   4   1
6  10  20  30
df.iloc[:3] #前3行
            max_speed  shield
cobra               1       2
viper               4       5
sidewinder          7       8

df.iloc[[True, False, True]] #第1行和第3行
max_speed  shield
cobra               1       2
sidewinder          7       8

截取某一块

df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
     index=['cobra', 'viper', 'sidewinder'],
     columns=['max_speed', 'shield'])
     			max_speed  shield
cobra               1       2
viper               4       5
sidewinder          7       8

'''loc +行列名'''
df.loc['cobra':'viper', 'max_speed']# 'cobra'到'viper'行，'max_speed'列
cobra    1
viper    4
Name: max_speed, dtype: int64

df.loc['cobra':'viper', ['max_speed','shield']]
       max_speed  shield
cobra          1       2
viper          4       5

'''iloc +行列位置'''
df.iloc[1:3, 0:3] #行和列 左闭右开
            max_speed  shield
viper               4       5
sidewinder          7       8

# 使用逻辑值
df.iloc[:, [True, False]] #第一列
            max_speed
cobra               1
viper               4
sidewinder          7

收起

展开全文

python

用Jupyter出现了name 'df' is not defined的问题
2021-06-19 21:49:01

data(): df = loadmat('C:/Users/fiq/Desktop/ex5data1.mat')#载入数据 return df['X'],df['y'],df['Xval'],df['yval'],df['Xtest'],df['ytest'] X,y,Xval,yval,Xtest,ytest = load_data() def computeCost (X,y,...

收起

有问必答 python jupyter

pd.DataFrame 数据的保存和读取((df.to_csv、df.to_json、df.to_html、df.to_excel))

千次阅读 2020-08-28 16:28:19

df.to_csv写入到csv文件 pd.read_csv读取csv文件 df.to_json写入到json文件 pd.read_json读取json文件 df.to_html写入到html文件 pd.read_html读取 html文件 df.to_excel 写入到 excel 文件 pd.read_excel ...

DataFrame 数据的保存和读取

df.to_csv 写入到 csv 文件
pd.read_csv 读取 csv 文件
df.to_json 写入到 json 文件
pd.read_json 读取 json 文件
df.to_html 写入到 html 文件
pd.read_html 读取 html 文件
df.to_excel 写入到 excel 文件
pd.read_excel 读取 excel 文件

pandas.DataFrame.to_csv

将 DataFrame 写入到 csv 文件

https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.to_csv.html

DataFrame.to_csv(path_or_buf=None, sep=', ', na_rep='', float_format=None, columns=None, header=True, index=True,
                 index_label=None, mode='w', encoding=None, compression=None, quoting=None, quotechar='"',
                 line_terminator='\n', chunksize=None, tupleize_cols=None, date_format=None, doublequote=True,
                 escapechar=None, decimal='.')

参数：

path_or_buf : 文件路径，如果没有指定则将会直接返回字符串的 json
sep : 输出文件的字段分隔符，默认为 “,”
na_rep : 用于替换空数据的字符串，默认为''
float_format : 设置浮点数的格式（几位小数点）
columns : 要写的列
header : 是否保存列名，默认为 True ，保存
index : 是否保存索引，默认为 True ，保存
index_label : 索引的列标签名

# -*- coding:utf-8 -*-
 
import numpy as np
import pandas as pd
 
list_l = [[11, 12, 13, 14, 15], [21, 22, 23, 24, 25], [31, 32, 33, 34, 35]]
date_range = pd.date_range(start="20180701", periods=3)
df = pd.DataFrame(list_l, index=date_range,
                  columns=['a', 'b', 'c', 'd', 'e'])
print(df)
"""
             a   b   c   d   e
2018-07-01  11  12  13  14  15
2018-07-02  21  22  23  24  25
2018-07-03  31  32  33  34  35
"""
 
df.to_csv("tzzs_data.csv")
"""
csv 文件内容：
,a,b,c,d,e
2018-07-01,11,12,13,14,15
2018-07-02,21,22,23,24,25
2018-07-03,31,32,33,34,35
"""
read_csv = pd.read_csv("tzzs_data.csv")
print(read_csv)
"""
   Unnamed: 0   a   b   c   d   e
0  2018-07-01  11  12  13  14  15
1  2018-07-02  21  22  23  24  25
2  2018-07-03  31  32  33  34  35
"""
 
df.to_csv("tzzs_data2.csv", index_label="index_label")
"""
csv 文件内容：
index_label,a,b,c,d,e
2018-07-01,11,12,13,14,15
2018-07-02,21,22,23,24,25
2018-07-03,31,32,33,34,35
"""
 
read_csv2 = pd.read_csv("tzzs_data2.csv")
print(read_csv2)
"""
  index_label   a   b   c   d   e
0  2018-07-01  11  12  13  14  15
1  2018-07-02  21  22  23  24  25
2  2018-07-03  31  32  33  34  35
"""

1.首先查询当前的工作路径：

import os
os.getcwd() #获取当前工作路径

2.to_csv()是DataFrame类的方法，read_csv()是pandas的方法

dt.to_csv() #默认dt是DataFrame的一个实例，参数解释如下

路径 path_or_buf: A string path to the file to write or a StringIO

dt.to_csv('Result.csv') #相对位置，保存在getwcd()获得的路径下
dt.to_csv('C:/Users/think/Desktop/Result.csv') #绝对位置

分隔符 sep : Field delimiter for the output file (default ”,”)

dt.to_csv('C:/Users/think/Desktop/Result.csv',sep='?')#使用?分隔需要保存的数据，如果不写，默认是,

替换空值 na_rep: A string representation of a missing value (default ‘’)

dt.to_csv('C:/Users/think/Desktop/Result1.csv',na_rep='NA') #确实值保存为NA，如果不写，默认是空

格式 float_format: Format string for floating point numbers

dt.to_csv('C:/Users/think/Desktop/Result1.csv',float_format='%.2f') #保留两位小数

是否保留某列数据 cols: Columns to write (default None)

dt.to_csv('C:/Users/think/Desktop/Result.csv',columns=['name']) #保存索引列和name列

是否保留列名 header: Whether to write out the column names (default True)

dt.to_csv('C:/Users/think/Desktop/Result.csv',header=0) #不保存列名

是否保留行索引 index: whether to write row (index) names (default True)

dt.to_csv('C:/Users/think/Desktop/Result1.csv',index=0) #不保存行索引

pandas.DataFrame.to_json

将 Dataframe 写入到 json 文件

https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.to_json.html

DataFrame.to_json(path_or_buf=None, orient=None, date_format=None, double_precision=10, force_ascii=True,
                  date_unit='ms', default_handler=None, lines=False, compression=None, index=True)

参数：

path_or_buf : 文件路径，如果没有指定则将会直接返回字符串的 json。

代码：

df.to_json("tzzs_data.json")
 
read_json = pd.read_json("tzzs_data.json")
print(read_json)
"""
             a   b   c   d   e
2018-07-01  11  12  13  14  15
2018-07-02  21  22  23  24  25
2018-07-03  31  32  33  34  35
"""

json：

{
    "a": {
        "1530403200000": 11,
        "1530489600000": 21,
        "1530576000000": 31
    },
    "b": {
        "1530403200000": 12,
        "1530489600000": 22,
        "1530576000000": 32
    },
    "c": {
        "1530403200000": 13,
        "1530489600000": 23,
        "1530576000000": 33
    },
    "d": {
        "1530403200000": 14,
        "1530489600000": 24,
        "1530576000000": 34
    },
    "e": {
        "1530403200000": 15,
        "1530489600000": 25,
        "1530576000000": 35
    }
}

pandas.DataFrame.to_html

将 Dataframe 写入到 html 文件

http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.to_html.html

DataFrame.to_html(buf=None, columns=None, col_space=None, header=True, index=True, na_rep='NaN', formatters=None,
                  float_format=None, sparsify=None, index_names=True, justify=None, bold_rows=True, classes=None,
                  escape=True, max_rows=None, max_cols=None, show_dimensions=False, notebook=False, decimal='.',
                  border=None, table_id=None)

df.to_html("tzzs_data.html")
 
read_html = pd.read_html("tzzs_data.html")
print(read_html)
"""
[   Unnamed: 0   a   b   c   d   e
0  2018-07-01  11  12  13  14  15
1  2018-07-02  21  22  23  24  25
2  2018-07-03  31  32  33  34  35]
"""
 
#
print(read_html[0])
"""
   Unnamed: 0   a   b   c   d   e
0  2018-07-01  11  12  13  14  15
1  2018-07-02  21  22  23  24  25
2  2018-07-03  31  32  33  34  35
"""

HTML：

<table border="1" class="dataframe">
  <thead>
    <tr style="text-align: right;">
      <th></th>
      <th>a</th>
      <th>b</th>
      <th>c</th>
      <th>d</th>
      <th>e</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <th>2018-07-01</th>
      <td>11</td>
      <td>12</td>
      <td>13</td>
      <td>14</td>
      <td>15</td>
    </tr>
    <tr>
      <th>2018-07-02</th>
      <td>21</td>
      <td>22</td>
      <td>23</td>
      <td>24</td>
      <td>25</td>
    </tr>
    <tr>
      <th>2018-07-03</th>
      <td>31</td>
      <td>32</td>
      <td>33</td>
      <td>34</td>
      <td>35</td>
    </tr>
  </tbody>
</table>

在浏览器中打开：

df.to_html 生成的是一个 html 格式的 table 表，我们可以在前后加入其他标签，丰富页面。ps：如果有中文字符，需要在 head 中设置编码格式。

参考：Pandas Dataframes to_html: Highlighting table rows

# -*- coding: utf-8 -*-
"""
@author: tz_zs
"""
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
 
index = ["2018-07-01", "2018-07-02", "2018-07-03", "2018-07-04"]
df = pd.DataFrame(index=index)
df["一"] = [11, 12, 13, 14]
df["二"] = [21, 22, 23, 24]
print(df)
"""
             一   二
2018-07-01  11  21
2018-07-02  12  22
2018-07-03  13  23
2018-07-04  14  24
"""
 
axes_subplot = df.plot()
# print(type(axes_subplot)) #<class 'matplotlib.axes._subplots.AxesSubplot'>
plt.xlabel("time")
plt.ylabel("num")
plt.legend(loc="best")
plt.grid(True)
plt.savefig("test.png")
 
HEADER = '''
    <html>
        <head>
            <meta charset="UTF-8">
        </head>
        <body>
    '''
FOOTER = '''
        <img src="%s" alt="" width="1200" height="600">
        </body>
    </html>
    ''' % ("test.png")
with open("test.html", 'w') as f:
    f.write(HEADER)
    f.write(df.to_html(classes='df'))
    f.write(FOOTER)

pandas.DataFrame.to_excel

将 DataFrame 写入 excel 文件

pandas.DataFrame.to_excel

DataFrame.to_excel(excel_writer, sheet_name='Sheet1', na_rep='', float_format=None, columns=None, 
                   header=True, index=True, index_label=None, startrow=0, startcol=0, engine=None,
                   merge_cells=True, encoding=None, inf_rep='inf', verbose=True, freeze_panes=None)

#!/usr/bin/python2.7
# -*- coding:utf-8 -*-
 
"""
@author:    tz_zs
"""
 
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
 
list_l = [[1, 3, 3, 5, 4], [11, 7, 15, 13, 9], [4, 2, 7, 9, 3], [15, 11, 12, 6, 11]]
index = ["2018-07-01", "2018-07-02", "2018-07-03", "2018-07-04"]
df = pd.DataFrame(list_l, index=index, columns=['a', 'b', 'c', 'd', 'e'])
print(df)
"""
             a   b   c   d   e
2018-07-01   1   3   3   5   4
2018-07-02  11   7  15  13   9
2018-07-03   4   2   7   9   3
2018-07-04  15  11  12   6  11
"""
 
df.to_excel("test.xls")

pandas.read_excel

读取 excel

可能遇到的报错：ImportError: Missing optional dependency 'xlrd'. Install xlrd >= 1.0.0 for Excel support Use pip or conda to install xlrd.

解决方法：安装 xlrd 包。

stackoverflow 讨论：Python: Pandas pd.read_excel giving ImportError: Install xlrd >= 0.9.0 for Excel support

其他文章：

http://www.dcharm.com/?p=584

https://blog.csdn.net/sinat_29957455/article/details/79059436

https://www.cnblogs.com/pengsixiong/p/5050833.html

收起

展开全文

python df遍历的N种方式

万次阅读 2019-10-03 20:48:58

#df = df.assign(signal = 0) #可采用assign新增一列 for i in np . arange ( 0 , df . shape [ 0 ] ) : df . iloc [ i , df . columns . get_loc ( 'signal' ) ] = np . sign ( df . iloc [ i ] [ '...

for…in 迭代循环

首先介绍Python中最常用的for…in循环遍历的方式。for…in循环结构用于遍历列表、元组、字典、字符串、集合、文件等。其实for和in是两个独立的语法，for语句是Python内置的迭代器工具，用于从可迭代容器对象（如列表、元组、字典、字符串、集合、文件等）中逐个读取元素，直到容器中没有更多元素为止，工具和对象之间只要遵循可迭代协议即可进行迭代操作。in的存在使得python在操作可迭代对象时变得简单得多，用于配合for使用逐个取可迭代对象的元素。

for语句参与的具体迭代的过程为：可迭代对象通过iter方法返回迭代器，迭代器具有next方法，for循环不断地调用next方法，每次按序返回迭代器中的一个值，直到迭代到最后，没有更多元素时抛出异常StopIteration（Python会自动处理异常）。模拟迭代的过程如下所示：

# 迭代的过程
x = [1,2,3]
its = x.__iter__() #列表是可迭代对象，否则会提示不是迭代对象
print(its)
# 打印结果：
<list_iterator object at 0x100f32198>
print(next(its)) # its包含此方法，说明its是迭代器
# 打印结果：
1
print(next(its)) 
# 打印结果：
2
print(next(its)) 
# 打印结果：
3
print(next(its)) 
# 打印结果：
Traceback (most recent call last):
 	File "<stdin>", line 1, in <module>
StopIteration

迭代的优点是无需把所有元素一次加载到内存中，可以在调用next方法时逐个返回元素，避免出现内存空间不够的情况。

使用for…in循环方式实现单均线突破策略。遍历全部交易日的收盘价数值和Ma20数值，将收盘价数值减去Ma20数值，并使用np.sign()取差值符号，当收盘价在Ma20上方时差值为正，收盘价在Ma20上下方时差值为负，由负转正对应为买点，由正转负对应为卖点。如下所示

def forin_looping(df):
    df['signal'] = 0 #df = df.assign(signal = 0)  #可采用assign新增一列
    for i in np.arange(0,df.shape[0]):
        df.iloc[i,df.columns.get_loc('signal')] = np.sign(df.iloc[i]['Close'] - df.iloc[i]['Ma20'])
    return df
print(forin_looping(df_stockload)[0:5])
"""
              High     Low    Open   Close  Volume  Adj Close    Ma20  signal
Date                                                                         
2018-01-29  3587.0  3510.3  3563.6  3523.0  236000     3523.0  3454.3     1.0
2018-01-30  3523.1  3484.7  3511.5  3488.0  186400     3488.0  3461.3     1.0
2018-01-31  3495.5  3454.7  3470.5  3480.8  207300     3480.8  3466.8     1.0
2018-02-01  3495.1  3424.4  3478.7  3447.0  260500     3447.0  3469.9    -1.0
2018-02-02  3463.2  3388.9  3419.2  3462.1  208100     3462.1  3473.4    -1.0
"""

iterrows()生成器方式

另一种Python中常用的遍历方式为iterrows()生成器方式。所谓生成器其实是一种特殊的迭代器，内部支持了迭代器协议。Python中提供生成器函数和生成器表达式两种方式实现生成器，每次请求返回一个结果，不需要一次性构建一个结果列表，节省了内存空间。

在Python 3中可使用range返回一个迭代器，用来一次一个值地遍历一个范围.

# 生成器函数方式实现生成器
def gensquares(N):
	for i in range(N):
		yield i**2 
        
print(gensquares(5))
#打印结果：
<generator object gensquares at 0x11a35cf48>

for i in gensquares(5):
	print(i) 
# 打印结果：
0
1
4
9
16

其实yield就相当于一个return，只是return返回的是值，但是yield返回的是生成器，除了这点其他都一样，所以return也好yield也好都只能用在函数中。

生成器表达式方式实现生成器就是类似列表解析，按需产生结果的一个对象，例程代码如下所示：

# 生成器表达式方式实现生成器
print(x**2 for x in range(5))
# 打印结果：
<generator object <genexpr> at 0xb3d31fa4>

print(list(x**2 for x in range(5)))
# 打印结果：
[0, 1, 4, 9, 16]

通过iterrows()遍历方式计算股票每个交易日收盘价与Ma20差值，此处iterrows是对dataframe格式数据行进行迭代的一个生成器，它返回每行的索引及包含行本身的对象，代码如下所示：

#iterrows()遍历方式
def iterrows_loopiter(df):
    df['signal'] = 0 #df = df.assign(signal = 0)  #可采用assign新增一列
    for index,row in df.iterrows():
        df.loc[index, 'signal'] = np.sign(row['Close']-row['Ma20'])
    return df
print(iterrows_loopiter(df_stockload)[0:5])

"""
              High     Low    Open   Close  Volume  Adj Close    Ma20  signal
Date                                                                         
2018-01-29  3587.0  3510.3  3563.6  3523.0  236000     3523.0  3454.3     1.0
2018-01-30  3523.1  3484.7  3511.5  3488.0  186400     3488.0  3461.3     1.0
2018-01-31  3495.5  3454.7  3470.5  3480.8  207300     3480.8  3466.8     1.0
2018-02-01  3495.1  3424.4  3478.7  3447.0  260500     3447.0  3469.9    -1.0
2018-02-02  3463.2  3388.9  3419.2  3462.1  208100     3462.1  3473.4    -1.0
"""

apply()循环方式

apply()方法可将函数应用于dataframe特定行或列。函数由lambda方式在代码中内嵌实现，lambda 为匿名函数，可以省去定义函数的过程，让代码更加精简。lambda函数的末尾包含axis参数，用来告知Pandas将函数运用于行（axis = 1）或者列（axis = 0）。apply()方法循环方式实现的代码如下所示：

df_stockload['signal'] = df_stockload.apply(lambda row: (np.sign(row['Close']-row['Ma20'])), axis = 1)
print(df_stockload.head())
"""
              High     Low    Open   Close  Volume  Adj Close    Ma20  signal
Date                                                                         
2018-01-29  3587.0  3510.3  3563.6  3523.0  236000     3523.0  3454.3     1.0
2018-01-30  3523.1  3484.7  3511.5  3488.0  186400     3488.0  3461.3     1.0
2018-01-31  3495.5  3454.7  3470.5  3480.8  207300     3480.8  3466.8     1.0
2018-02-01  3495.1  3424.4  3478.7  3447.0  260500     3447.0  3469.9    -1.0
2018-02-02  3463.2  3388.9  3419.2  3462.1  208100     3462.1  3473.4    -1.0

矢量化遍历方式

此处我们主要处理一维数组之间的计算，那么矢量化方式可使用Pandas series 的矢量化方式和Numpy arrays的矢量化方式两种。
先来看下Pandas series 的矢量化方式。
Pandas的DataFrame、series基础单元数据结构基于链表，因此可将函数在整个链表上进行矢量化操作，而不用按顺序执行每个值。

Pandas包括了非常丰富的矢量化函数库，我们可把整个series（列）作为参数传递，对整个链表进行计算。Pandas series 的矢量化方式实现代码如下：

#Pandas series 的矢量化方式
df_stockload['signal'] = np.sign(df_stockload['Close']-df_stockload['Ma20'])
print(df_stockload.head())
"""
              High     Low    Open   Close  Volume  Adj Close    Ma20  signal
Date                                                                         
2018-01-29  3587.0  3510.3  3563.6  3523.0  236000     3523.0  3454.3     1.0
2018-01-30  3523.1  3484.7  3511.5  3488.0  186400     3488.0  3461.3     1.0
2018-01-31  3495.5  3454.7  3470.5  3480.8  207300     3480.8  3466.8     1.0
2018-02-01  3495.1  3424.4  3478.7  3447.0  260500     3447.0  3469.9    -1.0
2018-02-02  3463.2  3388.9  3419.2  3462.1  208100     3462.1  3473.4    -1.0
"""

对于Numpy arrays的矢量化方式，由于本例的矢量化运算中只使用了series的数值，无需使用索引等信息，因此可将series转换为array类型，节省操作过程中的很多开销。
我们可使用values 方法将链表从Pandas series转换为NumPy arrays，把NumPy array作为参数传递，对整个链表进行计算。Numpy arrays的矢量化方式实现代码如下：

#Numpy arrays的矢量化方式
df_stockload['signal'] = np.sign(df_stockload['Close'].values-df_stockload['Ma20'].values)
print(df_stockload.head())
"""
              High     Low    Open   Close  Volume  Adj Close    Ma20  signal
Date                                                                         
2018-01-29  3587.0  3510.3  3563.6  3523.0  236000     3523.0  3454.3     1.0
2018-01-30  3523.1  3484.7  3511.5  3488.0  186400     3488.0  3461.3     1.0
2018-01-31  3495.5  3454.7  3470.5  3480.8  207300     3480.8  3466.8     1.0
2018-02-01  3495.1  3424.4  3478.7  3447.0  260500     3447.0  3469.9    -1.0
2018-02-02  3463.2  3388.9  3419.2  3462.1  208100     3462.1  3473.4    -1.0
"""

执行效率对比

#使用timeit方法对比方法参考例程如下，需要import timeit模块：
from timeit import timeit
def test1():
    forin_looping(df_stockload)
def test2():
    iterrows_loopiter(df_stockload)
def test3():
    df_stockload['signal'] = df_stockload.apply(lambda row: (np.sign(row['Close'] - row['Ma20'])), axis=1)
def test4():
    df_stockload['signal'] = np.sign(df_stockload['Close']-df_stockload['Ma20'])
def test5():
    df_stockload['signal'] = np.sign(df_stockload['Close'].values - df_stockload['Ma20'].values)

#for..in循环迭代方式
t1 = timeit('test1()', 'from __main__ import test1', number=100)
#iterrows()遍历方式
t2 = timeit('test2()', 'from __main__ import test2', number=100)
#apply()方法循环方式
t3 = timeit('test3()', 'from __main__ import test3', number=100)
#Pandas series 的矢量化方式
t4 = timeit('test4()', 'from __main__ import test4', number=100)
#Numpy arrays的矢量化方式：
t5 = timeit('test5()', 'from __main__ import test5', number=100)

print(t1,t2,t3,t4,t5)
#14.943237108999998 8.827773373 0.5511996379999999 0.02215727200000117 0.012933490000001768

总结

可以看出循环执行的速度是最慢的，iterrows()针对Pandas的dataframe进行了优化，相比直接循环有显著提升。apply()方法也是在行之间进行循环，但由于利用了类似Cython的迭代器的一系列全局优化，其效率要比iterrows高很多。
NumPy arrays的矢量化运行速度最快，其次是Pandas series矢量化。

由于矢量化是同时作用于整个序列的，可以节省更多的时间，相比使用标量操作更好，NumPy使用预编译的C代码在底层进行优化，同时也避免了Pandas series操作过程中的很多开销，例如索引、数据类型等等，因此，NumPy arrays的操作要比Pandas series快得多。

收起

展开全文

df命令_Linux df 命令用法详解：显示磁盘的相关信息
千次阅读 2021-05-09 08:44:02

df命令用于显示磁盘分区上的可使用的磁盘空间。默认显示单位为KB。可以利用该命令来获取硬盘被占用了多少空间，目前还剩下多少空间等信息。语法df(选项)(参数)选项-a或--all：包含全部的文件系统；--block-size=：以...

收起
Python之---【pandas】pd.concat(df)、df.append(df)
万次阅读 多人点赞 2019-03-17 17:31:22

参数 ignore_index 默认为 False ，当设为 ignore_index=True 时，新 df 将不会使用拼接成员 df 的 index，而是重新生成一个从 0 开始的 index 值 df5 = pd.concat([df1, df2, df3], axis=0,ignore_index=True) ...

收起

Python 数据合并
python – df [x],df [[x]],df [‘x’],df [[‘x’]]和df.x之间的差异
千次阅读 2021-02-11 05:42:27

df [x] – 使用变量x索引列.返回pd.Series> df [[x]] – 使用变量x索引/切片单列DataFrame.返回pd.DataFrame> df [‘x’] – 索引名为“x”的列.返回pd.Series> df [[‘x’]] – 索引/切片只有一列名为“x...

收起
Pandas query 的用法， df.query
万次阅读 多人点赞 2019-03-28 18:03:54

df.query 今天看到了query的用法，被这个函数的简洁所折服… df.query（expr，inplace = False，** kwargs ）# 使用布尔表达式查询帧的列参数： # expr：str要评估的查询字符串。你可以在环境中引用变量，在它们....

收起

python query
PCB Dk、Df和介质损耗
千次阅读 2022-02-11 08:53:53

Dk、Df

收起
Pandas数据类型转换df.astype()、数据类型查看df.dtypes
千次阅读 2021-06-10 11:24:21

数据类型转换.astype： df.index.astype('int64') # 索引类型转换 df.astype('int64') # 所有数据转换为 int64 df.astype('int64', copy=False) # 不与原数据关联 td_link_data.astype({'管理域': 'int32'}) # 指定...

收起

python
python – 了解scikit CountVectorizer中的min_df和max_df
千次阅读 2020-12-01 09:06:47

将min_df和max_df指定给CountVectorizer实例时,min / max文档频率的确切含义是什么？它是特定文本文件中单词的频率,还是整个语料库中单词的频率(5个txt文件)？当min_df和max_df以整数或浮点数形式提供时,它有何不同...

收起
Python3 df.loc和df.iloc函数用法及提取指定行列位置处数值
千次阅读 2020-11-29 12:44:32

df.loc和df.iloc函数用法的df由pandas.read_csv()函数读取而来。 1. DataFrame.loc Access a group of rows and columns by label(s) or a boolean array. .loc[] is primarily label based, but may also be used ...

收起

csv读取 dataframe
Pandas查询数据df.query
千次阅读 2021-01-17 18:50:26

Pandas查询数据的简便方法df.query pandas中数据查询query函数方法对比: 使用df[(df[“a”] > 3) & (df[“b”]<5)]的方式；使用df.query(“a>3 & b<5”)的方式； df = pd.read_csv(...

收起

python 字符串
df -i 和 df -h 的不同之处简述
万次阅读 2018-08-02 18:57:05

df命令的用法:df 命令:linux中df命令的功能是用来检查linux服务器的文件系统的磁盘空间占用情况。可以利用该命令来获取硬盘被占用了多少空间,目前还剩下多少空间等信息。 1.命令格式:df [选项] [文件] 2.命令...

收起

linux 运维
【Python中pandas库查看df开头和结尾数据】【df.head()和df.tail()方法】
千次阅读 2022-01-31 12:11:34

A df.head(2) df.tail(2) B df.tail(2) df.head(2) C df.head(3) df.tail(3) D df.tail(3) df.head(3) ● 问题解析 1.df.head(n):该方法用于查看dataframe数据表中开头n行的数据，若参数n未设置，即df.head()，则...

收起

python
❤️pandas df.loc[] 与 df.iloc[] 详解及其区别，建议收藏❤️
千次阅读 2021-09-12 10:21:45

文章目录思维导图一、df.loc[]与df.iloc[]区别二、df.loc[]详解df.loc[] 允许输入三、df.iloc[]详解df.iloc[] 允许输入df.loc[]与df.iloc[]例子对比1.创建数据集2.整数索引3.列表索引切片索引4.布尔索引函数/条件...

收起

python
df命令 - Linux命令大全 | linux教程
千次阅读 2021-05-09 08:42:57

df命令的英文全称即“Disk Free”，顾名思义功能是用于显示系统上可使用的磁盘空间。默认显示单位为KB，建议使用“df -h”的参数组合，根据磁盘容量自动变换合适的单位，更利于阅读。日常普遍用该命令可以查看磁盘被...

收起
【pandas】之 DataFrame 保存为文件 (df.to_csv、df.to_json、df.to_html、df.to_excel)
万次阅读 多人点赞 2018-07-21 05:18:50

df.to_csv写入到csv文件 pd.read_csv读取csv文件 df.to_json写入到json文件 pd.read_json读取json文件 df.to_html写入到html文件 pd.read_html读取 html文件 df.to_excel 写入到 excel 文件 ...

收起

DataFrame
【pandas】之 Series、DataFrame 的拼接 —— pd.concat、df.append(df)
万次阅读 2018-07-27 18:23:24

默认为 False ，当设为 ignore_index=True 时，新 df 将不会使用拼接成员 df 的 index，而是重新生成一个从 0 开始的 index 值。 df5 = pd.concat([df, df2, df3], axis=1,ignore_index=True) print df5 """ ...

收起
df查询命令用法区别。df -ih与df -lh
千次阅读 2019-08-26 09:47:26

今天磁盘显示没有可用空间了，google后记录一下。...截图如下： ...经过对比发现假如执行df -lh命令发现磁盘还有空间，但是运行启动程序显示磁盘空间已满，如： 2019-08-26 09:21:01 CST ERROR - Can't cre...

收起

mysql
linux命令df 中df -hT和df -ih的区别及磁盘爆满的解决方法
千次阅读 2020-08-20 13:44:53

df 命令： linux中df命令的功能是用来检查linux服务器的文件系统的磁盘空间占用情况。可以利用该命令来获取硬盘被占用了多少空间，目前还剩下多少空间等信息。 1.df -hT 和df -ih的区别如下 df -TH 查看磁盘大小...

收起

运维 linux
Linux命令du df查看文件和文件夹大小
千次阅读 2021-05-10 04:16:25

当磁盘大小超过标准时会有报警提示，这时如果掌握df和du命令是非常明智的选择。df可以查看一级文件夹大小、使用比例、档案系统及其挂入点，但对文件却无能为力。du可以查看文件及文件夹的大小。两者配合使用，非常...

收起
df.plot
千次阅读 多人点赞 2020-04-24 16:09:55

一、介绍使用DataFrame的plot方法绘制图像会按照数据的每一列绘制一条曲线，默认按照列columns的名称在适当的位置...二、df.plot() DataFrame.plot(x=None, y=None, kind=‘line’, ax=None, subplots=False, sha...

收起
pandas之DataFrame取行列（df.loc(),df.iloc()）以及索引
千次阅读 2021-01-28 11:08:45

import pandas as pdimport numpy as npdf = pd.DataFrame(np.arange(24).reshape(6,4),index=list("ABCDEF"),columns=list("WXYZ"))# df 输出的结果为：W X Y ZA 0 1 2 3B 4 5 6 7C 8 9 10 11...

收起
[Pandas] 数据形状df.shape
千次阅读 2022-02-10 14:56:36

Pandas 数据形状df.shape介绍

收起

python
df.replace无法修改数据
万次阅读 2021-11-20 14:23:06

数据和代码：问题：想要修改申购状态这一列，把“开放申购”全部改为1，把“封闭期”改为0，但是使用replace没反应 ...df[‘申购状态’].replace(to_replace=dict_open_subscription, inplace=True) ...

收起

python 开发语言后端
linux命令详解之df命令
万次阅读 多人点赞 2017-04-18 08:11:41

df命令概述df命令作用是列出文件系统的整体磁盘空间使用情况。可以用来查看磁盘已被使用多少空间和还剩余多少空间。 df命令显示系统中包含每个文件名参数的磁盘使用情况，如果没有文件名参数，则显示所有当前已挂载...

收起

linux

df的索引

通过df 的索引提取数据

提取某个具体的位置

提取列

提取行

截取某一块

用Jupyter出现了name 'df' is not defined的问题

pd.DataFrame 数据的保存和读取((df.to_csv、df.to_json、df.to_html、df.to_excel))

pandas.DataFrame.to_csv

pandas.DataFrame.to_json

pandas.DataFrame.to_html

pandas.DataFrame.to_excel

pandas.read_excel

python df遍历的N种方式

for…in 迭代循环

iterrows()生成器方式

apply()循环方式

矢量化遍历方式

执行效率对比

df命令_Linux df 命令用法详解：显示磁盘的相关信息

Python之---【pandas】pd.concat(df)、df.append(df)

python – df [x],df [[x]],df [‘x’],df [[‘x’]]和df.x之间的差异

Pandas query 的用法， df.query

PCB Dk、Df和介质损耗

Pandas数据类型转换df.astype()、数据类型查看df.dtypes

python – 了解scikit CountVectorizer中的min_df和max_df

Python3 df.loc和df.iloc函数用法及提取指定行列位置处数值

Pandas查询数据df.query

df -i 和 df -h 的不同之处简述

【Python中pandas库查看df开头和结尾数据】【df.head()和df.tail()方法】

❤️pandas df.loc[] 与 df.iloc[] 详解及其区别，建议收藏❤️

df命令 - Linux命令大全 | linux教程

【pandas】 之 DataFrame 保存为文件 (df.to_csv、df.to_json、df.to_html、df.to_excel)

【pandas】 之 Series、DataFrame 的拼接 —— pd.concat、df.append(df)

df查询命令用法区别。df -ih与df -lh

linux命令df 中df -hT和df -ih的区别及磁盘爆满的解决方法

Linux命令du df查看文件和文件夹大小

df.plot

pandas之DataFrame取行列（df.loc(),df.iloc()）以及索引

[Pandas] 数据形状df.shape

df.replace无法修改数据

linux命令详解之df命令

df

【pandas】之 DataFrame 保存为文件 (df.to_csv、df.to_json、df.to_html、df.to_excel)

【pandas】之 Series、DataFrame 的拼接 —— pd.concat、df.append(df)