Pandas杂记(一)

最新推荐文章于 2023-03-23 11:08:07 发布
最新推荐文章于 2023-03-23 11:08:07 发布
阅读量178 收藏
点赞数
分类专栏： python pandas 文章标签： python pandas
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_xuanshuang/article/details/108567929
版权

目录

1.创建

从字典创建

从列表创建

从numpy数组创建 

 从python原生列表创建

2.按列按行取值

返回值类型

取单列

取单行

取多列

取多行

取行列操作是否返回副本

取单列

取单行

取多列

取多行

3.values 属性

4.布尔索引

5.index

reindex

关于index

 

 

1.创建

从字典创建

字典的键是列名，字典的长度即是数据的长度，有广播机制，所以每个键下值的长度除了一样，还可以长度为1，通过广播机制不足。但长度不能是其他值。

In [9]: df2 = pd.DataFrame({'A': 1.,
   ...:                     'B': pd.Timestamp('20130102'),
   ...:                     'C': pd.Series(1, index=list(range(4)), dtype='float32'),
   ...:                     'D': np.array([3] * 4, dtype='int32'),
   ...:                     'E': pd.Categorical(["test", "train", "test", "train"]),
   ...:                     'F': 'foo'})
   ...: 

In [10]: df2
Out[10]: 
     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

从列表创建

列表的长度即是记录的长度，列表中的一个元素（这边的字典）就是一条记录，其中字典的键是列名。相同的键对应的值组成一列。

from pandas import DataFrame
d = [{"f1": 1, "f2": 2, "f3": 3},
     {"f2": 12, "f1": 14, "f3": 16},
     {"f3": 25, "f2": 24, "f1": 26},
     {"f1": 35, "f2": 34, "f3": 36}]
df = DataFrame(d)
print(df)

 输出

   f1  f2  f3
0   1   2   3
1  14  12  16
2  26  24  25
3  35  34  36

从numpy数组创建 

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

 输出

          A         B         C         D
0  0.039461  0.774348 -0.007067  0.738565
1 -0.142427 -0.287318  0.743472 -0.609328
2 -0.731498  0.095589 -0.664986  0.078787
3  0.583649  0.036846  0.050926  0.911483
4 -0.822104  0.260254  1.887518 -1.561972
5  0.391799 -0.392966  0.681349 -1.643266

 从python原生列表创建

d = [[1, 2, 3, 4],
     [11, 12, 13, 14],
     [21, 22, 23, 24]]
dates = pd.date_range('20130101', periods=3)
df = DataFrame(d, columns=list('ABCD'))
print(df)

输出：

    A   B   C   D
0   1   2   3   4
1  11  12  13  14
2  21  22  23  24

 

2.按列按行取值

  • 若取多行或多列(切片 or 中括号枚举,这种方式下哪怕取一行一列特性和多行多列一样)
    • 取多行多列均返回DataFrame 类
    • 切片再套一层中括号会报错,中括号里面只能一一枚举.(例如:origin_df.iloc[:, [1,2,3]],而不能写成origin_df.iloc[:, [1:3]]) ,索引即行操作同
    • 注意用字段名或索引名切片的时候,左闭右闭,均能取到.
    • 注意用下标切片取多行多列时,左闭右开,最右边取不到.
    • values 属性返回二维矩阵,类型是numpy.ndarray
  • 若取单行或单列所得类型得看取值方式
    • 所取行或列外面再套一层中括号,得到 DataFrame类型(例如origin_df[['A']]), values 属性返回二维矩阵
    • 否则 Series 类型(例如origin_df['A']), .values 属性返回一维矩阵,类型是numpy.ndarray

是否返回副本

  • 凡是多套一层中括号的均是返回副本(切片无法套中括号),副本的修改值的操作不会影响到源. 
  • 否则不返回副本,修改会影响到源,枚举必须套括号.

drop操作都不会影响源

返回值类型

取单列

origin_df = DataFrame(np.arange(24).reshape(6, 4), 
                      columns=list('ABCD'), index=list('abcdef'))
print("单列:{}\n单列套中括号: {}\nloc取单列: {}\nloc取单列套中括号: {}\n\
iloc取单列: {}\niloc取单列套中括号: {}".format(
    type(origin_df['B']), type(origin_df[['B']]), 
    type(origin_df.loc[:, 'B']), type(origin_df.loc[:, ['B']]),
    type(origin_df.iloc[:, 1]), type(origin_df.iloc[:, [1]])
    ))
print("="* 20)
try:
    print(origin_df.loc['B']) # 报错
except KeyError as ex:
    print(repr(ex))
单列:<class 'pandas.core.series.Series'>
单列套中括号: <class 'pandas.core.frame.DataFrame'>
loc取单列: <class 'pandas.core.series.Series'>
loc取单列套中括号: <class 'pandas.core.frame.DataFrame'>
iloc取单列: <class 'pandas.core.series.Series'>
iloc取单列套中括号: <class 'pandas.core.frame.DataFrame'>
====================
KeyError('B')

取单行

origin_df = DataFrame(np.arange(24).reshape(6, 4), 
                      columns=list('ABCD'), index=list('abcdef'))
print("loc取单行: {}\nloc取单行套中括号: {}\niloc取单行: {}\niloc取单行套中括号: {}".format(
    type(origin_df.loc['a']), type(origin_df.loc[['d'], :]),
    type(origin_df.iloc[0, :]), type(origin_df.iloc[[1], :])
    ))
print(origin_df.loc['b']) #简版
print(origin_df.iloc[0]) #简版
print("="* 20)
try:
    print(origin_df['b']) # 报错
except KeyError as ex:
    print(repr(ex))
loc取单行: <class 'pandas.core.series.Series'>
loc取单行套中括号: <class 'pandas.core.frame.DataFrame'>
iloc取单行: <class 'pandas.core.series.Series'>
iloc取单行套中括号: <class 'pandas.core.frame.DataFrame'>
A    4
B    5
C    6
D    7
Name: b, dtype: int64
A    0
B    1
C    2
D    3
Name: a, dtype: int64
====================
KeyError('b')

取多列

origin_df = DataFrame(np.arange(24).reshape(6, 4), 
                      columns=list('ABCD'), index=list('abcdef'))
print("多列:{}\n多列套中括号: {}\nloc取多列: {}\nloc取多列套中括号: {}\n\
iloc取多列: {}\niloc取多列套中括号: {}".format(
    type(origin_df['B':'C']), type(origin_df[['B',"D"]]), 
    type(origin_df.loc[:, 'B':"D"]), type(origin_df.loc[:, ['B',"D"]]),
    type(origin_df.iloc[:, 1:3]), type(origin_df.iloc[:, [1,3]])
    ))

print(origin_df.loc[:, 'B':"D"])
print("="* 20)
try:
    print(origin_df.loc['B':"C"]) # 报错
except KeyError as ex:
    print(repr(ex))
多列:<class 'pandas.core.frame.DataFrame'>
多列套中括号: <class 'pandas.core.frame.DataFrame'>
loc取多列: <class 'pandas.core.frame.DataFrame'>
loc取多列套中括号: <class 'pandas.core.frame.DataFrame'>
iloc取多列: <class 'pandas.core.frame.DataFrame'>
iloc取多列套中括号: <class 'pandas.core.frame.DataFrame'>
    B   C   D
a   1   2   3
b   5   6   7
c   9  10  11
d  13  14  15
e  17  18  19
f  21  22  23
====================
Empty DataFrame
Columns: [A, B, C, D]
Index: []

取多行

origin_df = DataFrame(np.arange(24).reshape(6, 4), 
                      columns=list('ABCD'), index=list('abcdef'))
print("loc取多行: {}\nloc取多行套中括号: {}\niloc取多行: {}\niloc取多行套中括号: {}".format(
    type(origin_df.loc['a':'b', :]), type(origin_df.loc[['d','e'], :]),
    type(origin_df.iloc[0:1, :]), type(origin_df.iloc[[1,3], :])
    ))
print(origin_df.loc['b':'d']) #简版
print(origin_df.iloc[0:2]) #简版
print("="* 20)

print(origin_df['b': 'd']) # 可以取到,注意与单行的区别
loc取多行: <class 'pandas.core.frame.DataFrame'>
loc取多行套中括号: <class 'pandas.core.frame.DataFrame'>
iloc取多行: <class 'pandas.core.frame.DataFrame'>
iloc取多行套中括号: <class 'pandas.core.frame.DataFrame'>
    A   B   C   D
b   4   5   6   7
c   8   9  10  11
d  12  13  14  15
   A  B  C  D
a  0  1  2  3
b  4  5  6  7
====================
    A   B   C   D
b   4   5   6   7
c   8   9  10  11
d  12  13  14  15

取行列操作是否返回副本

origin_df = DataFrame([[c + str(i) for i in range(6)]
                       for c in ("ABCDEF")], 
                      columns=list("ABCDEF"), index=list("uvwxyz"))
print(origin_df)
    A   B   C   D   E   F
u  A0  B0  C0  D0  E0  F0
v  A1  B1  C1  D1  E1  F1
w  A2  B2  C2  D2  E2  F2
x  A3  B3  C3  D3  E3  F3
y  A4  B4  C4  D4  E4  F4
z  A5  B5  C5  D5  E5  F5

取单列

origin_df = DataFrame([[c + str(i) for c in ("ABCDEF")]
                       for i in range(6)], 
                      columns=list("ABCDEF"), index=list("uvwxyz"))

col_1 = origin_df['A']
col_1[0] = "单列"
col_2 = origin_df[['B']]
col_2.iloc[0, 0] = "单列套中括号"

col_3 = origin_df.loc[:, "C"]
col_3.iloc[0] = "loc取单列"
col_4 = origin_df.loc[:, ["D"]]
col_4.iloc[0,0] = "loc取单列套中括号"

col_5 = origin_df.iloc[:, 4]
col_5.iloc[0] = "iloc取单列"
col_6 = origin_df.iloc[:, [5]]
col_6.iloc[0,0] = "iloc取单列套中括号"
print(origin_df)
    A   B       C   D        E   F
u  单列  B0  loc取单列  D0  iloc取单列  F0
v  A1  B1      C1  D1       E1  F1
w  A2  B2      C2  D2       E2  F2
x  A3  B3      C3  D3       E3  F3
y  A4  B4      C4  D4       E4  F4
z  A5  B5      C5  D5       E5  F5

取单行

origin_df = DataFrame([[c + str(i) for c in ("ABCDEF")]
                       for i in range(6)], 
                      columns=list("ABCDEF"), index=list("uvwxyz"))

row_3 = origin_df.loc['w', :]
row_3.iloc[0] = "loc取单行"
row_4 = origin_df.loc[['x'], :]
row_4.iloc[0,0] = "loc取单行套中括号"

row_5 = origin_df.iloc[4, :]
row_5.iloc[0] = "iloc取单行"
row_6 = origin_df.iloc[[5], :]
row_6.iloc[0,0] = "loc取单行套中括号"
print(origin_df)
         A   B   C   D   E   F
u       A0  B0  C0  D0  E0  F0
v       A1  B1  C1  D1  E1  F1
w   loc取单行  B2  C2  D2  E2  F2
x       A3  B3  C3  D3  E3  F3
y  iloc取单行  B4  C4  D4  E4  F4
z       A5  B5  C5  D5  E5  F5

取多列

origin_df = DataFrame([[c + str(i) for c in ("ABCDEF")]
                       for i in range(6)], 
                      columns=list("ABCDEF"), index=list("uvwxyz"))

# 取不到Empty DataFrame,Columns: [A, B, C, D, E, F],Index: []
# col_1 = origin_df['A':'B'] 
col_2 = origin_df[['A',"B"]]
col_2.iloc[1, 0] = "多列套中括号"

col_3 = origin_df.loc[:, "C":"D"]
col_3.iloc[2, 0] = "loc取多列"
print("列名切片col_3\n {}".format(col_3))
col_4 = origin_df.loc[:, ["C","D"]]
col_4.iloc[3, 0] = "loc取多列套中括号"

col_5 = origin_df.iloc[:, 4:5]
col_5.iloc[4, 0] = "iloc取多列"
print("=" * 20)
print("下标切片col_5\n {}".format(col_5))
col_6 = origin_df.iloc[:, [4,5]]
col_6.iloc[5,0] = "iloc取多列套中括号"
print("=" * 20)
print(origin_df)
列名切片col_3
         C   D
u      C0  D0
v      C1  D1
w  loc取多列  D2
x      C3  D3
y      C4  D4
z      C5  D5
====================
下标切片col_5
          E
u       E0
v       E1
w       E2
x       E3
y  iloc取多列
z       E5
====================
    A   B       C   D        E   F
u  A0  B0      C0  D0       E0  F0
v  A1  B1      C1  D1       E1  F1
w  A2  B2  loc取多列  D2       E2  F2
x  A3  B3      C3  D3       E3  F3
y  A4  B4      C4  D4  iloc取多列  F4
z  A5  B5      C5  D5       E5  F5

取多行

origin_df = DataFrame([[c + str(i) for c in ("ABCDEF")]
                       for i in range(6)], 
                      columns=list("ABCDEF"), index=list("uvwxyz"))

row_3 = origin_df.loc['w':'x', :]
row_3.iloc[1, 2] = "loc取多行"
print("索引名切片row_3\n {}".format(row_3))
row_4 = origin_df.loc[['w', 'x'], :]
row_4.iloc[1, 3] = "loc取多行套中括号"

row_5 = origin_df.iloc[4:5, :]
row_5.iloc[0, 4] = "iloc取多行"
print("=" * 20)
print("下标切片row_5\n {}".format(row_5))
row_6 = origin_df.iloc[[4,5], :]
row_6.iloc[1,5] = "loc取多行套中括号"
print("=" * 20)
print(origin_df)
索引名切片row_3
     A   B       C   D   E   F
w  A2  B2      C2  D2  E2  F2
x  A3  B3  loc取多行  D3  E3  F3
====================
下标切片row_5
     A   B   C   D        E   F
y  A4  B4  C4  D4  iloc取多行  F4
====================
    A   B       C   D        E   F
u  A0  B0      C0  D0       E0  F0
v  A1  B1      C1  D1       E1  F1
w  A2  B2      C2  D2       E2  F2
x  A3  B3  loc取多行  D3       E3  F3
y  A4  B4      C4  D4  iloc取多行  F4
z  A5  B5      C5  D5       E5  F5

3.values 属性

  • 若取多行或多列(切片 or 中括号枚举,这种方式下哪怕取一行一列特性和多行多列一样)
    • values 属性返回二维矩阵,类型是numpy.ndarray
  • 若取单行或单列所得类型得看取值方式
    • 所取行或列外面再套一层中括号(例如origin_df[['A']]), values 属性返回二维矩阵
    • 否则 values 属性返回一维矩阵,类型是numpy.ndarray

  • 是否返回副本

    • 凡是多套一层中括号的均是返回副本(切片无法套中括号)，副本的修改值的操作不会影响到源. 

    • 否则不返回副本,修改会影响到源,枚举必须套括号.

col_1 = origin_df['A']
print("col_1\n{}".format(col_1.values))
col_2 = origin_df[['B']]
print("col_2\n{}".format(col_2.values))

row_3 = origin_df.loc['w', :]
print("row_3\n{}".format(row_3.values))
row_4 = origin_df.loc[['x'], :]
print("row_4\n{}".format(row_4.values))

col_2 = origin_df[['A',"B"]]
print("col_2\n{}".format(col_2.values))

col_3 = origin_df.loc[:, "C":"C"]
print(" 哪怕切片仅取一列性质依旧通多列col_3\n{}".format(col_3.values))

row_5 = origin_df.iloc[4:5, :]
print("row_5\n {}".format(row_5.values))
row_6 = origin_df.iloc[[4,5], :]
print("row_6\n {}".format(row_6.values))
col_1
['A0' 'A1' 'A2' 'A3' 'A4' 'A5']
col_2
[['B0']
 ['B1']
 ['B2']
 ['B3']
 ['B4']
 ['B5']]
row_3
['A2' 'B2' 'C2' 'D2' 'E2' 'F2']
row_4
[['A3' 'B3' 'C3' 'D3' 'E3' 'F3']]
col_2
[['A0' 'B0']
 ['A1' 'B1']
 ['A2' 'B2']
 ['A3' 'B3']
 ['A4' 'B4']
 ['A5' 'B5']]
 哪怕切片仅取一列性质依旧通多列col_3
[['C0']
 ['C1']
 ['C2']
 ['C3']
 ['C4']
 ['C5']]
[['C0' 'D0']
 ['C1' 'D1']
 ['C2' 'D2']
 ['C3' 'D3']
 ['C4' 'D4']
 ['C5' 'D5']]
row_5
 [['A4' 'B4' 'C4' 'D4' 'E4' 'F4']]
row_6
 [['A4' 'B4' 'C4' 'D4' 'E4' 'F4']
 ['A5' 'B5' 'C5' 'D5' 'E5' 'F5']]

4.布尔索引

dates = pd.date_range('20130101', periods=6)
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD'))
print(df)
                   A         B         C         D
2013-01-01  0.161101  0.364128  1.735634 -0.835255
2013-01-02  1.164170  0.384188  0.302318 -0.293224
2013-01-03  1.116850  1.469352  0.867080 -0.420124
2013-01-04  0.952359  1.056309 -2.857191  0.668887
2013-01-05 -0.097658 -0.794298  1.387195 -0.897870
2013-01-06 -0.270472 -1.841921  2.008927  1.140431

排序：返回副本

df.sort_values(by='B')
 ABCD
2013-01-06-0.270472-1.8419212.0089271.140431
2013-01-05-0.097658-0.7942981.387195-0.897870
2013-01-010.1611010.3641281.735634-0.835255
2013-01-021.1641700.3841880.302318-0.293224
2013-01-040.9523591.056309-2.8571910.668887
2013-01-031.1168501.4693520.867080-0.420124
print(df[df['A'] > 0])
                   A         B         C         D
2013-01-01  0.161101  0.364128  1.735634 -0.835255
2013-01-02  1.164170  0.384188  0.302318 -0.293224
2013-01-03  1.116850  1.469352  0.867080 -0.420124
2013-01-04  0.952359  1.056309 -2.857191  0.668887
print(df[df > 0])
                   A         B         C         D
2013-01-01  0.161101  0.364128  1.735634       NaN
2013-01-02  1.164170  0.384188  0.302318       NaN
2013-01-03  1.116850  1.469352  0.867080       NaN
2013-01-04  0.952359  1.056309       NaN  0.668887
2013-01-05       NaN       NaN  1.387195       NaN
2013-01-06       NaN       NaN  2.008927  1.140431
df2 = df.copy()
df2['E'] = ['one', 'one', 'two', 'three', 'four', 'three']
print(df2)
print(df2[df2['E'].isin(['two', 'four'])])
                   A         B         C         D      E
2013-01-01  0.161101  0.364128  1.735634 -0.835255    one
2013-01-02  1.164170  0.384188  0.302318 -0.293224    one
2013-01-03  1.116850  1.469352  0.867080 -0.420124    two
2013-01-04  0.952359  1.056309 -2.857191  0.668887  three
2013-01-05 -0.097658 -0.794298  1.387195 -0.897870   four
2013-01-06 -0.270472 -1.841921  2.008927  1.140431  three
                   A         B         C         D     E
2013-01-03  1.116850  1.469352  0.867080 -0.420124   two
2013-01-05 -0.097658 -0.794298  1.387195 -0.897870  four
print(df2[~df2['E'].isin(['two', 'four'])])
                  A         B         C         D      E
2013-01-01  0.161101  0.364128  1.735634 -0.835255    one
2013-01-02  1.164170  0.384188  0.302318 -0.293224    one
2013-01-04  0.952359  1.056309 -2.857191  0.668887  three
2013-01-06 -0.270472 -1.841921  2.008927  1.140431  three

5.index

reindex

Create a new index and reindex the dataframe. By default values in the new index that do not have corresponding records in the dataframe are assigned ``NaN``.

重新设置df的索引，并且df的顺序是新索引的定义顺序，记录的位置可能发生变化，如果新的索引在原先的df存在，该索引的记录就是原纪录，否则，该记录填默认值NaN。

df = pd.DataFrame(np.random.randn(10, 4), columns=list("ABCD"))
print(df)
          A         B         C         D
0  0.903525 -0.664247 -0.645762 -0.762519
1  0.981854 -1.070156 -1.164206 -0.908125
2  0.309620 -0.786684 -0.960699  1.606932
3 -1.488677  0.281483  0.856681  0.613150
4  0.772205  0.601886  0.344716 -1.800654
5  0.769349  0.875296  0.074671 -0.333205
6  0.721913 -0.148773 -0.825000 -0.903127
7 -0.886161  0.625793  0.102159  0.264182
8 -0.225532 -0.221453  1.164743  1.037622
9 -0.046355 -1.238612  0.042434 -0.473256
df1 = df.reindex(list(range(15, 5, -1)))
print(df1)
           A         B         C         D
15       NaN       NaN       NaN       NaN
14       NaN       NaN       NaN       NaN
13       NaN       NaN       NaN       NaN
12       NaN       NaN       NaN       NaN
11       NaN       NaN       NaN       NaN
10       NaN       NaN       NaN       NaN
9  -0.046355 -1.238612  0.042434 -0.473256
8  -0.225532 -0.221453  1.164743  1.037622
7  -0.886161  0.625793  0.102159  0.264182
6   0.721913 -0.148773 -0.825000 -0.903127

关于index

重新设置索引，相当于仅将df的索引改变一下，记录还是在原先的位置。

df1 = df.copy()
df1.index = range(15, 5, -1)
print(df1)
           A         B         C         D
15  0.903525 -0.664247 -0.645762 -0.762519
14  0.981854 -1.070156 -1.164206 -0.908125
13  0.309620 -0.786684 -0.960699  1.606932
12 -1.488677  0.281483  0.856681  0.613150
11  0.772205  0.601886  0.344716 -1.800654
10  0.769349  0.875296  0.074671 -0.333205
9   0.721913 -0.148773 -0.825000 -0.903127
8  -0.886161  0.625793  0.102159  0.264182
7  -0.225532 -0.221453  1.164743  1.037622
6  -0.046355 -1.238612  0.042434 -0.473256

 

 

一杯敬朝阳一杯敬月光
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python与Pytorch系列(一) 本文(2万字) | 解析python中的pandas.read_csv() | pandas.read_json() | pandas.read_excel()
weixin_44302770的博客
12-25 1057
官方网站pandas是一个Python包，并且它提供快速，灵活和富有表现力的数据结构。这样当我们处理"关系"或"标记"的数据（一维和二维数据结构）时既容易又直观。pandas是我们运用Python进行实际、真实数据分析的基础，同时它是建立在NumPy之上的。pandas.csv() 函数将逗号分离的值 （csv） 文件读入数据框架。还支持可选地将文件读入块或将其分解。源文件。
流水账︱Elmo词向量中文训练过程杂记
素质云笔记
08-21 2万+
1 elmo是什么？ 参考：《文本嵌入的经典模型与最新进展》 人们已经提出了大量可能的词嵌入方法。最常用的模型是 word2vec 和 GloVe，它们都是基于分布假设的无监督学习方法（在相同上下文中的单词往往具有相似的含义）。 虽然有些人通过结合语义或句法知识的有监督来增强这些无监督的方法，但纯粹的无监督方法在 2017-2018 中发展非常有趣，最著名的是 FastText（word2v...
Pandas-Note1(from Mofan)
by壮壮的小仙女呀！
06-07 185
Numpy 和 Pandas 有什么不同 如果用 python 的列表和字典来作比较, 那么可以说 Numpy 是列表形式的，没有数值标签，而 Pandas 就是字典形式。Pandas是基于Numpy构建的，让Numpy为中心的应用变得更加简单。 要使用pandas，首先需要了解他主要两个数据结构：Series和DataFrame。 Series import pandas as pd...
十分钟搞定pandas
IAlexanderI的专栏
05-20 2285
原文出处： pandas.pydata.org   译文出处：石卓林    这是关于pandas的简短介绍，主要面向新用户。可以参阅Cookbook了解更复杂的使用方法。 习惯上,我们做以下导入 Python In [1]: import pandas as pd In [2]: import numpy as np In [3]: import matplotli
10分钟 to pandas
风---的专栏
10-22 1558
import pandas as pd import numpy as np import matplotlib.pyplot as pltx In [3]: dates = pd.date_range('20130101', periods=6) dates Out[3]: DatetimeIndex(['2013-01-01', '2013-01-02', '2013-01-...
pandas <十分钟掌握pandas常用操作>
Gpwner的博客
06-11 2044
panda version:’0.19.2’1.创建数据集In [58]: names=['Bob','Jessica','Mary','John','Mel']In [59]: births = [968, 155, 77, 578, 973]In [60]: BabyDataSet = list(zip(names,births)) ...: BabyDataSet Out[60]: [
Pandas的DataFrame的生产，DF数据查看
alike_u的博客
03-23 759
使用 Pandas 的 DataFrame，可以进行以下操作：加载和处理数据，包括 CSV、Excel、SQL 数据库等格式的数据进行数据清洗、重塑、切片和切块统计数据、计算聚合和汇总信息进行数据可视化将结果保存到各种格式的文件中将数据上传到数据库或在线应用程序、以其他格式输出数据，例如 HTML 表格。
机器学习笔记 - 杂记三
学以致用 知行合一
03-28 2104
1、sklearn中svm模型的保存与加载调用 2、panda中删除一列的方法 3、cannot import name joblib from sklearn.externals 4、sklearn中KFold与StratifiedKFold 5、pandas删除满足条件的行 6、pandas drop函数参数 7、使用Sklearn创建测试数据集 8、最小二乘法简述
机器学习笔记 - 杂记二
学以致用 知行合一
09-20 3362
1、检测gpu是否可用 2、Weka：Java 机器学习软件 3、IOU指标计算 4、BLAS 线性代数库简介 5、常用深度学习图像/视频数据标注工具
2021/12/27 杂记
qq_44458323的博客
12-27 1112
近期遇到的一些小问题Seaborn 新版本的 displotpandas.query 的一个报错displot Seaborn 新版本的 displot pandas.query 的一个报错 displot Seaborn 新版本下displot 功能被削减了 想要把 hist 和 kde 画在一起得用 histplot sns.histplot(df['总分'],kde=True)#histplot 画在同一张图上 ...
Python - pandas DataFrame数据的合并与拼接（merge、join、concat）
热门推荐
sc179的博客
08-22 17万+
目录1 Merge方法单列的内连接定义df1定义df2print(df1)print(df2)基于共同列alpha的内连接单列的外连接定义df1定义df2基于共同列alpha的内连接单列的左连接定义df1定义df2基于共同列alpha的左连接单列的右连接定义df1定义df2基于共同列alpha的右连接多列的内连接定义df1定义df2基于共同列alpha和beta的内连接多列的右连接定义df1定义df2基于共同列alpha和beta的右连接基于column和index的右连接定义df1定义df2基于df1的b
Python Pandas 官方教程1~50个知识点拍了拍你
程志伟的博客
08-02 319
关注微信公共号：小程在线 关注CSDN博客：程志伟的博客 纯属个人学习笔记 Python 3.7.6 (default, Jan 8 2020, 20:23:39) [MSC v.1916 64 bit (AMD64)] Type "copyright", "credits" or "license" for more information. IPython 7.12.0 -- An enhanced Interactive Python. #一、创建对象 #1、可以通过传...
Pandas基础教程
Melo
08-15 6806
Pandas基本介绍 Numpy 和 Pandas 有什么不同 如果用 python 的列表和字典来作比较, 那么可以说 Numpy 是列表形式的，没有数值标签，而 Pandas 就是字典形式。Pandas是基于Numpy构建的，让Numpy为中心的应用变得更加简单。 要使用pandas，首先需要了解他主要两个数据结构：Series和DataFrame。 Series import ...
pandas学习笔记1
hepiaopiao_wemedia的博客
12-02 395
pandas使用： 1、数据结构 2、创建对象 3、查看数据 4、选择数据 5、赋值数据 一、数据结构： pandas主要的两种数据结构： Dimensions name Descriptions 1 Series 1维标记同类型数组 2 DataFrame 通常是2维，大小可变的表格结构 pandas数据结构是低维数据的灵活组合。D...
机器学习数据科学包（二）——Pandas入门
DuBenBen的博客
02-07 460
目录 二、查看数据 三、选择 四、缺失值处理 五、相关操作 六、合并 七、分组 八、重塑（Reshaping） 九、时间序列 十、Categorical 十一、画图 十二、导入和保存数据 本文对十分钟入门Pandas进行翻译详见英文版https://pandas.pydata.org/pandas-docs/stable/getting_started/10min.html...
Pandas模块的操作
stevedish_xiaojia的博客
10-14 178
1 dateframe的创建 pandas其实就是一个带有行名字和列名字的矩阵，有点类似于表数据。有表行号，和列标号。 Dataframe的创建一般有两种方式：一种是通过给定一个numpy数组来创建，另一种是通过传入一个字典来创建 &gt;&gt;&gt; s = pd.Series([1,3,6,np.nan,44,1])  ##创建一个一维的pandas &gt;&gt;&gt; s 0   ...
一文带你斩杀Python之Numpy☀️Pandas全部操作【全网最详细】❗❗❗
迷茫与徘徊只会让你陷入绝境，欢迎私信博主，带你开始提升变现价值！
09-08 1万+
Numpy简介 Numpy专门针对ndarray的操作和运算进行了设计，所以数组的存储效率和输入输出性能远优于Python中的嵌套列表，数组越大，Numpy的优势就越明显。Numpy系统是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure)结构要高效的多（该结构也可以用来表示矩阵（matrix））。据说NumPy将Python相当于变成一种免费的更强大的MATLAB系统。 ...
利用Pandas操作DataFrame的列与行
lsxxx2011的专栏
10-10 843
介 绍 本章介绍DataFrame的许多基本操作。许多秘笈与第1章“Pandas基础”中的秘笈相似，只不过第1章主要讨论的是Series的操作。选择多个DataFrame列 可以通过将列名称传递给DataFrame的索引操作符来选择单个列。本书1.6节“选择列”对此已有介绍。一般来说，分析人员需要关注和处理的是当前工作数据集的一个子集，而这正是通过选择多个列来获得的。在此秘笈中，我们将从mo...
Pandas出现KeyError及其分析解决
wrncxcy的博客
02-26 2961
pandas出现keyerror
pandas创建一个series
最新发布
05-28
要创建一个 Pandas Series，你可以使用`pandas.Series()`函数。以下是一个示例代码，创建了一个包含三个元素的 Series，元素分别为 10、20 和 30： ```python import pandas as pd my_series = pd.Series([10, 20,...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值