精华内容
下载资源
问答
  • 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
    
    展开全文
  • 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,...
  • 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.首先查询当前的工作路径:

    1. import os

    2. 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
     
    1. dt.to_csv('Result.csv') #相对位置,保存在getwcd()获得的路径下

    2. 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命令用于显示磁盘分区上的可使用的磁盘空间。默认显示单位为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) ...
  • 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要评估的查询字符串。你可以在环境中引用变量,在它们....
  • PCB Dk、Df和介质损耗

    千次阅读 2022-02-11 08:53:53
    Dk、Df
  • 数据类型转换.astype: df.index.astype('int64') # 索引类型转换 df.astype('int64') # 所有数据转换为 int64 df.astype('int64', copy=False) # 不与原数据关联 td_link_data.astype({'管理域': 'int32'}) # 指定...
  • 将min_df和max_df指定给CountVectorizer实例时,min / max文档频率的确切含义是什么?它是特定文本文件中单词的频率,还是整个语料库中单词的频率(5个txt文件)?当min_df和max_df以整数或浮点数形式提供时,它有何不同...
  • 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 ...
  • 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(...
  • df -i 和 df -h 的不同之处简述

    万次阅读 2018-08-02 18:57:05
    df命令的用法:df 命令:linux中df命令的功能是用来检查linux服务器的文件系统的磁盘空间占用情况。可以利用该命令来获取硬盘被占用了多少空间,目前还剩下多少空间等信息。 1.命令格式:df [选项] [文件] 2.命令...
  • 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(),则...
  • 文章目录思维导图一、df.loc[]与df.iloc[]区别二、df.loc[]详解df.loc[] 允许输入三、df.iloc[]详解df.iloc[] 允许输入df.loc[]与df.iloc[]例子对比1.创建数据集2.整数索引3.列表索引切片索引4.布尔索引函数/条件...
  • df命令 - Linux命令大全 | linux教程

    千次阅读 2021-05-09 08:42:57
    df命令的英文全称即“Disk Free”,顾名思义功能是用于显示系统上可使用的磁盘空间。默认显示单位为KB,建议使用“df -h”的参数组合,根据磁盘容量自动变换合适的单位,更利于阅读。日常普遍用该命令可以查看磁盘被...
  • 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 文件 ...
  • 默认为 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...
  • df 命令: linux中df命令的功能是用来检查linux服务器的文件系统的磁盘空间占用情况。可以利用该命令来获取硬盘被占用了多少空间,目前还剩下多少空间等信息。 1.df -hT 和df -ih的区别如下 df -TH 查看磁盘大小...
  • 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...
  • 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介绍
  • df.replace无法修改数据

    万次阅读 2021-11-20 14:23:06
    数据和代码: 问题:想要修改申购状态这一列,把“开放申购”全部改为1,把“封闭期”改为0,但是使用replace没反应 ...df[‘申购状态’].replace(to_replace=dict_open_subscription, inplace=True) ...
  • linux命令详解之df命令

    万次阅读 多人点赞 2017-04-18 08:11:41
    df命令概述df命令作用是列出文件系统的整体磁盘空间使用情况。可以用来查看磁盘已被使用多少空间和还剩余多少空间。 df命令显示系统中包含每个文件名参数的磁盘使用情况,如果没有文件名参数,则显示所有当前已挂载...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 781,755
精华内容 312,702
关键字:

df

友情链接: SmartCar.zip