Series

基本介绍

  • Series是一种类似于一维数组的对象，由一组数据（各种Numpy数据类型）以及一组与之对应的索引（数据标签）组成

  • 由数据和索引组成，索引(index)在左，数据(values)在右，索引是自动创建的

    创建Series

  • 语法格式：pandas.Series( data, index, dtype, name, copy)

  • 参数说明
    • data：一组数据(ndarray类型)
    • index：索引标签，如果不指定，默认从0开始
    • dtype：数据类型，默认会自己判断
    • name：设置名称
    • copy：拷贝数据，默认为False

      通过列表创建

      ```python var1 = pd.Series(range(100, 103), name=’hhhh’) print(var1.head(2)) ‘’’ 0 100 1 101 Name: hhhh, dtype: int64 ‘’’ print(var1[0]) # 100 print(var1.index) # RangeIndex(start=0, stop=3, step=1) print(var1.values) # [100 101 102]

var2 = pd.Series([‘Alan’, ‘Bob’, ‘Cindy’], index=[‘x’, ‘y’, ‘z’]) print(var2) ‘’’ x Alan y Bob z Cindy dtype: object ‘’’ print(var2[‘x’]) # Alan

  1. <a name="rcV9o"></a>
  2. #### 通过字典创建
  3. ```python
  4. var1 = pd.Series({'x': "Google", 'y': "Runoob", 'z': "Wiki"})
  5. print(var1)
  6. '''
  7. x    Google
  8. y    Runoob
  9. z      Wiki
  10. dtype: object
  11. '''
  12. ---------------------------------------------------------
  13. var2 = pd.Series({'x': "Google", 'y': "Runoob", 'z': "Wiki"}, index=['x', 'z'])
  14. print(var2)
  15. '''
  16. x    Google
  17. z      Wiki
  18. dtype: object
  19. '''

DataFrame

基本介绍

DataFrame是一个表格型的数据结构，它含有一组有序的列，每列可以是不同类型的值。DataFrame既有行索引也有列索引，它可以看做是由Series组成的字典（共用同一个索引），数据是以二维结构存放的
image.png

创建DataFrame

  • 语法格式：pandas.DataFrame( data, index, columns, dtype, copy)
  • 参数说明
    • data：一组数据(ndarray、series、map、list、dict等类型)
    • index：索引值，也可以称为行标签，默认为RangeIndex(0, 1, 2, …, n)
    • columns：列标签，默认为RangeIndex(0, 1, 2, …, n)
    • dtype：数据类型
    • copy：拷贝数据，默认为False

      通过列表创建

      ```python print(pd.DataFrame(np.arange(6).reshape(2, 3))) ‘’’ 0 1 2 0 0 1 2 1 3 4 5 ‘’’

data = [[‘Google’], [‘Runoob’, 12], [‘Wiki’, 13]] print(pd.DataFrame(data, columns=[‘Site’, ‘Age’], dtype=float))

按行创建，没有对应部分的数据为NaN

‘’’ Site Age 0 Google NaN 1 Runoob 12.0 2 Wiki 13.0 ‘’’

  1. <a name="spm7c"></a>
  2. #### 通过字典创建
  3. ```python
  4. data = [{'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20}]
  5. print(pd.DataFrame(data))
  6. # 按行创建，没有对应部分的数据为NaN
  7. '''
  8.    a   b     c
  9. 0  1   2   NaN
  10. 1  5  10  20.0
  11. '''

通过ndarray创建

按列创建，每列的长度必须相同

  1. data = {
  2.     'calories': [420, 380, 390],
  3.     'duration': [50, 40, 45]
  4. }
  5. print(pd.DataFrame(data, index=['day1', 'day2', 'day3']))
  6. '''
  7.       calories  duration
  8. day1       420        50
  9. day2       380        40
  10. day3       390        45
  11. '''
  12. ---------------------------------------------------------
  13. data = {'A': 1,
  14.         'B': pd.Timestamp('20220709'),
  15.         'C': pd.Series(1, index=list(range(4)), dtype='float32'),
  16.         'D': np.array([1, 2, 3, 4], dtype='int32'),
  17.         'E': ["Python", "Java", "C++", "C"],
  18.         'F': 'program'}
  19. print(pd.DataFrame(data))
  20. '''
  21.    A          B    C  D       E        F
  22. 0  1 2022-07-09  1.0  1  Python  program
  23. 1  1 2022-07-09  1.0  2    Java  program
  24. 2  1 2022-07-09  1.0  3     C++  program
  25. 3  1 2022-07-09  1.0  4       C  program
  26. '''

关于整列的简单操作

  1. data = {
  2.     'calories': [420, 380, 390],
  3.     'duration': [50, 40, 45]
  4. }
  5. df = pd.DataFrame(data, index=['day1', 'day2', 'day3'])
  6. print(df)
  7. '''
  8.       calories  duration
  9. day1       420        50
  10. day2       380        40
  11. day3       390        45
  12. '''
  13. ---------------------------------------------------------
  14. # 操作一：通过列索引获取整列数据
  15. print(df['calories'])  # 等价于print(df.calories)
  16. '''
  17. day1    420
  18. day2    380
  19. day3    390
  20. Name: calories, dtype: int64
  21. '''
  22. print(type(df['calories']))  # <class 'pandas.core.series.Series'>
  23. ---------------------------------------------------------
  24. # 操作二：增加整列数据
  25. df['A'] = df['calories'] + 100
  26. print(df)
  27. '''
  28.       calories  duration    A
  29. day1       420        50  520
  30. day2       380        40  480
  31. day3       390        45  490
  32. '''
  33. ---------------------------------------------------------
  34. # 操作三：删除整列
  35. del(df['A'])
  36. print(df)
  37. '''
  38.       calories  duration
  39. day1       420        50
  40. day2       380        40
  41. day3       390        45
  42. '''

索引

基本介绍

  • 首先需要明确的是：Series和DataFrame中的索引都是Index对象

image.png
image.png

  • 索引对象不可变，保证了数据的安全
  • 常见的索引类型
    • Int64Index：整数索引
    • MultiIndex：层级索引
    • DatetimeIndex：时间戳索引

      Series的索引操作

      注意：loc是基于标签名的索引，iloc是基于索引编号的索引 ```python import pandas as pd

ser = pd.Series(range(5), index=[‘a’, ‘b’, ‘c’, ‘d’, ‘e’]) print(ser) ‘’’ a 0 b 1 c 2 d 3 e 4 dtype: int64

‘’’

方式一：行索引

print(ser[0]) # 0，可以使用ser.iloc[0]

print(ser[‘a’]) # 0，可以使用ser.loc[‘a’]

方式二：切片索引

print(ser[1:3]) # 可以使用ser.iloc[1:3] ‘’’ b 1 c 2 dtype: int64 ‘’’ print(ser[‘b’:’d’]) # 可以使用ser.loc[‘b’:’d’] ‘’’ b 1 c 2 d 3 dtype: int64

‘’’

方式三：不连续索引

print(ser[[0, 2, 4]]) # 可以使用ser.iloc[[0, 2, 4]] ‘’’ a 0 c 2 e 4 dtype: int64 ‘’’ print(ser[[‘a’, ‘e’]]) # 可以使用ser.loc[[‘a’, ‘e’]] ‘’’ a 0 e 4 dtype: int64

‘’’

方式四：布尔索引

print(ser > 2) ‘’’ a False b False c False d True e True dtype: bool ‘’’ print(ser[ser > 2]) ‘’’ d 3 e 4 dtype: int64 ‘’’

  1. <a name="qiPHd"></a>
  2. ### DataFrame的索引操作
  3. 注意：loc是基于标签名的索引，iloc是基于索引编号的索引
  4. ```python
  5. import pandas as pd
  6. import numpy as np
  8. df = pd.DataFrame(np.arange(12).reshape(3, 4), index=['a', 'b', 'c'], columns=['A', 'B', 'C', 'D'])
  9. print(df)
  10. '''
  11.    A  B   C   D
  12. a  0  1   2   3
  13. b  4  5   6   7
  14. c  8  9  10  11
  15. '''
  16. ---------------------------------------------------------
  17. # 方式一：列索引，没有行索引
  18. print(df['A'])  # 不能使用df[0]
  19. '''
  20. a    0
  21. b    4
  22. c    8
  23. Name: A, dtype: int32
  24. '''
  25. print(type(df['A']))  # <class 'pandas.core.series.Series'>
  26. --------------------
  27. print(df[['A']])  # 不能使用df[[0]]
  28. '''
  29.    A
  30. a  0
  31. b  4
  32. c  8
  33. '''
  34. print(type(df[['A']]))  # <class 'pandas.core.frame.DataFrame'>
  35. ---------------------------------------------------------
  36. # 方式二：切片索引，只能用于行索引，不能用于列索引
  37. print(df['a':'a'])  # # df['a':'a']等价于df[0:1]
  38. '''
  39.    A  B  C  D
  40. a  0  1  2  3
  41. '''
  42. --------------------
  43. print(df['a':'b'])  # df['a':'b']等价于df[0:2]
  44. '''
  45.    A  B  C  D
  46. a  0  1  2  3
  47. b  4  5  6  7
  48. '''
  49. print(type(df['a':'b']))  # <class 'pandas.core.frame.DataFrame'>
  50. ---------------------------------------------------------
  51. # 方式三：不连续索引，只能用于列索引，不能用于行索引
  52. print(df[['A', 'C']])  # 不能使用df[[0, 2]]
  53. # 
  54. '''
  55.    A   C
  56. a  0   2
  57. b  4   6
  58. c  8  10
  59. '''
  60. print(type(df[['A', 'C']]))  # <class 'pandas.core.frame.DataFrame'>

loc和iloc的高级使用

对于DataFrame，loc和iloc是等价的，因此以iloc为例

  1. import pandas as pd
  2. import numpy as np
  4. df = pd.DataFrame(np.arange(12).reshape(3, 4), index=['a', 'b', 'c'], columns=['A', 'B', 'C', 'D'])
  5. print(df)
  6. '''
  7.    A  B   C   D
  8. a  0  1   2   3
  9. b  4  5   6   7
  10. c  8  9  10  11
  11. '''
  13. print(df.iloc[[0, 1], 0:3])
  14. '''
  15.    A  B  C
  16. a  0  1  2
  17. b  4  5  6
  18. '''
  20. print(df.iloc[0:2, 0:3])
  21. '''
  22.    A  B  C
  23. a  0  1  2
  24. b  4  5  6
  25. '''
  27. print(df.iloc[[0, 2]])
  28. '''
  29.    A  B   C   D
  30. a  0  1   2   3
  31. c  8  9  10  11
  32. '''
  34. print(df.iloc[:, 0:1])
  35. '''
  36.    A
  37. a  0
  38. b  4
  39. c  8
  40. '''
  42. print(df.iloc[:, 0])
  43. '''
  44. a    0
  45. b    4
  46. c    8
  47. Name: A, dtype: int32
  48. '''
  50. print(df.iloc[0])
  51. '''
  52. A    0
  53. B    1
  54. C    2
  55. D    3
  56. Name: a, dtype: int32
  57. '''
  59. print(df.iloc[0, 0:2])
  60. '''
  61. A    0
  62. B    1
  63. Name: a, dtype: int32
  64. '''

对齐运算

Series的对齐运算

  1. import pandas as pd
  2. import numpy as np
  4. s1 = pd.Series(range(0, 3), index=range(3))
  5. s2 = pd.Series(range(10, 15), index=range(5))
  7. print(s1)
  8. '''
  9. 0    0
  10. 1    1
  11. 2    2
  12. dtype: int64
  13. '''
  15. print(s2)
  16. '''
  17. 0    10
  18. 1    11
  19. 2    12
  20. 3    13
  21. 4    14
  22. dtype: int64
  23. '''
  25. print(s1 + s2)
  26. '''
  27. 0    10.0
  28. 1    12.0
  29. 2    14.0
  30. 3     NaN
  31. 4     NaN
  32. dtype: float64
  33. '''
  35. print(s1.add(s2, fill_value=0))
  36. '''
  37. 0    10.0
  38. 1    12.0
  39. 2    14.0
  40. 3    13.0
  41. 4    14.0
  42. dtype: float64
  43. '''

DataFrame的对齐运算

  1. import pandas as pd
  2. import numpy as np
  4. df1 = pd.DataFrame(np.ones((2, 2)), columns=['a', 'b'])
  5. df2 = pd.DataFrame(np.ones((3, 3)), columns=['a', 'b', 'c'])
  7. print(df1)
  8. '''
  9.      a    b
  10. 0  1.0  1.0
  11. 1  1.0  1.0
  12. '''
  14. print(df2)
  15. '''
  16.      a    b    c
  17. 0  1.0  1.0  1.0
  18. 1  1.0  1.0  1.0
  19. 2  1.0  1.0  1.0
  20. '''
  22. print(df1 + df2)
  23. '''
  24.      a    b   c
  25. 0  2.0  2.0 NaN
  26. 1  2.0  2.0 NaN
  27. 2  NaN  NaN NaN
  28. '''
  30. print(df1.add(df2, fill_value=0))
  31. '''
  32.      a    b    c
  33. 0  2.0  2.0  1.0
  34. 1  2.0  2.0  1.0
  35. 2  1.0  1.0  1.0
  36. '''

使用函数

对于Series的操作和DataFrame基本类似，所以以DataFrame为例

可直接使用numpy的函数

  1. import pandas as pd
  2. import numpy as np
  4. df = pd.DataFrame(np.random.randn(2, 3) - 1)
  5. print(df)
  6. '''
  7.           0         1         2
  8. 0 -1.249877  1.732052 -2.438650
  9. 1 -1.240503 -0.739373 -1.734294
  10. '''
  12. print(np.abs(df))
  13. '''
  14.           0         1         2
  15. 0  1.249877  1.732052  2.438650
  16. 1  1.240503  0.739373  1.734294
  17. '''

通过apply将函数应用到行或列上

  1. import pandas as pd
  2. import numpy as np
  4. df = pd.DataFrame(np.random.randn(2, 3) - 1)
  5. print(df)
  6. '''
  7.           0         1         2
  8. 0 -0.961372 -1.083071 -0.950709
  9. 1  0.259989  1.168447  0.265873
  10. '''
  12. print(df.apply(lambda x: x.max()))  # 默认是轴0，即自上而下
  13. '''
  14. 0    0.259989
  15. 1    1.168447
  16. 2    0.265873
  17. dtype: float64
  18. '''
  20. print(df.apply(lambda x: x.max(), axis=1))  # 指定为轴1，即自左而右
  21. '''
  22. 0   -0.950709
  23. 1    1.168447
  24. dtype: float64
  25. '''

通过applymap将函数应用到每个数据上

  1. import pandas as pd
  2. import numpy as np
  4. df = pd.DataFrame(np.random.randn(2, 3) - 1)
  5. print(df)
  6. '''
  7.           0         1         2
  8. 0 -0.171078 -0.951804 -2.561237
  9. 1 -0.944916 -2.440723 -1.218804
  10. '''
  12. print(df.applymap(lambda x: '%.2f' % x))
  13. '''
  14.        0      1      2
  15. 0  -0.17  -0.95  -2.56
  16. 1  -0.94  -2.44  -1.22
  17. '''
  19. print(df.applymap(lambda x: np.abs(x)))
  20. '''
  21.           0         1         2
  22. 0  0.171078  0.951804  2.561237
  23. 1  0.944916  2.440723  1.218804
  24. '''

排序操作

按索引进行排序

通过函数sort_index()，默认使用升序、按轴0进行排序，ascending=False为降序排序

  1. import pandas as pd
  2. import numpy as np
  4. df = pd.DataFrame(np.random.randn(3, 3),
  5.                    index=np.random.randint(3, size=3),
  6.                    columns=np.random.randint(3, size=3))
  8. print(df)
  9. '''
  10.           1         2         0
  11. 2  0.497309 -2.689734 -0.653441
  12. 0  1.245357 -0.563550  0.057072
  13. 2 -0.954434 -1.055197 -0.875219
  14. '''
  16. print(df.sort_index())
  17. '''
  18.           1         2         0
  19. 0  1.245357 -0.563550  0.057072
  20. 2  0.497309 -2.689734 -0.653441
  21. 2 -0.954434 -1.055197 -0.875219
  22. '''
  24. print(df.sort_index(axis=1, ascending=False))
  25. '''
  26.           2         1         0
  27. 2 -2.689734  0.497309 -0.653441
  28. 0 -0.563550  1.245357  0.057072
  29. 2 -1.055197 -0.954434 -0.875219
  30. '''

按值进行排序

通过函数sort_values()，需要通过by指定轴的名字；默认是按轴0进行排序，可以通过axis=1指定按轴1进行排序；默认是升序排序，可以通过ascending=False指定降序排序

  1. import pandas as pd
  2. import numpy as np
  4. df = pd.DataFrame(np.random.randn(3, 3), columns=['A', 'B', 'C'])
  6. print(df)
  7. '''
  8.           A         B         C
  9. 0 -0.042903 -0.862099  1.253066
  10. 1  0.372508  0.492648 -0.416308
  11. 2  0.222194 -1.288317 -0.340111
  12. '''
  14. print(df.sort_values(by='A'))
  15. '''
  16.           A         B         C
  17. 0 -0.042903 -0.862099  1.253066
  18. 2  0.222194 -1.288317 -0.340111
  19. 1  0.372508  0.492648 -0.416308
  20. '''
  22. print(df.sort_values(by=2, axis=1, ascending=False))
  23. '''
  24.           A         C         B
  25. 0 -0.042903  1.253066 -0.862099
  26. 1  0.372508 -0.416308  0.492648
  27. 2  0.222194 -0.340111 -1.288317
  28. '''

处理缺失数据

  • is_null()：判断是否为NaN
  • dropna(axis=0)：丢弃包含NaN的行或列
  • fillna(num)：用num替换其中的NaN ```python import pandas as pd import numpy as np

df = pd.DataFrame([np.random.randn(3), [1, 2, np.nan], [np.nan, 4, np.nan]])

print(df) ‘’’ 0 1 2 0 -1.628242 -0.226639 1.508853 1 1.000000 2.000000 NaN 2 NaN 4.000000 NaN ‘’’

print(df.isnull()) ‘’’ 0 1 2 0 False False False 1 False False True 2 True False True ‘’’

print(df.dropna()) ‘’’ 0 1 2 0 -1.628242 -0.226639 1.508853 ‘’’

print(df.dropna(axis=1)) ‘’’ 1 0 -0.226639 1 2.000000 2 4.000000 ‘’’

print(df.fillna(100)) ‘’’ 0 1 2 0 -1.628242 -0.226639 1.508853 1 1.000000 2.000000 100.000000 2 100.000000 4.000000 100.000000 ‘’’ ```