• Python的Pandas库（一）基础使用

    Python开发实用教程

    Pandas 是基于NumPy 的一种工具，该工具是为解决数据分析任务而创建的。与NumPy十分类似的一点是，NumPy的核心是提供了数组结构，而Pandas 的核心是提供了两种数据结构： Series（一维数据）与 DataFrame（二维数据），特别是DataFrame，可以让开发人员可以像Excel一样灵活、方便的操作二维表格数据。

    基本数据结构

    Series

    Series 是带标签的一维数组，可存储整数、浮点数、字符串、Python 对象等类型的数据。轴标签统称为索引。它与此前学习的命名元组（collections.namedtuple）十分的相似。

    Series的创建

    调用 pd.Series 函数即可创建 Series：

    import pandas as pd

    s=pd.Series( data, index, dtype, copy)

    data 支持以下数据类型：

    • 列表
    • Python 字典
    • 多维数组
    • 标量值（如，5）

    index 是轴标签列表。不同数据可分为以下几种情况：

    • data 是多维数组时，index 长度必须与 data 长度一致。没有指定 index 参数时，创建数值型索引，即 [0, ..., len(data) - 1]。
    • data 为字典，且未设置 index 参数时，如果 Python 版本 >= 3.6 且 Pandas 版本 >= 0.23，Series 按字典的插入顺序排序索引；Python < 3.6 或 Pandas < 0.23，且未设置 index 参数时，Series 按字母顺序排序字典的键（key）列表。如果设置了 index 参数，则按索引标签提取 data 里对应的值。
    • data 是标量值时，必须提供索引。Series 按索引长度重复该标量值。

    dtype表示数据类型，如果没有提供，则会自动判断得出。

    copy表示对 data 进行拷贝，默认为 False。

    1. import numpy as np
    2. import pandas as pd
    3.  
    4. s = pd.Series([10,20,30])
    5. print(s)
    6. ‘’'
    7. 0    10
    8. 1    20
    9. 2    30
    10. dtype: int64
    11. ‘’'
    12.  
    13. s = pd.Series({'Name':'John', 'Age':10, 'Score':98})
    14. print(s)
    15. ‘’'
    16. Name     John
    17. Age        10
    18. Score      98
    19. dtype: object
    20. ‘''
    22. s = pd.Series(5, index=['First', 'Second', 'Third'])
    23. print(s)
    24. ‘’'
    25. First     5
    26. Second    5
    27. Third     5
    28. dtype: int64
    29. ‘''
    30.  
    31. s = pd.Series(np.asarray(5), index=['a', 'b', 'c', 'd', 'e'])
    32. print(s)
    33.  
    34. ‘’'
    35. a    5
    36. b    5
    37. c    5
    38. d    5
    39. e    5
    40. dtype: int64
    41. ‘’'
    42.  
    43. print(s.array)
    44. ‘’'
    46. [5, 5, 5, 5, 5]
    47. Length: 5, dtype: int64
    48. ‘’'
    49.

    从上面的输出可以看出，Series也是支持dtype的，实际也可以通过属性array访问到Series的数组，Pandas使用的是基于NumPy类型的扩展数组。

    访问Series的数据

    Series的数据可以通过两种方式访问：位置索引访问、索引标签访问。

    1. s = pd.Series([1,2,3,4,5], index=['a', 'b', 'c', 'd', 'e'])
    2. print(s[0]) #1
    3. print(s[-1])#5
    4. print(s['b']) #2

    上面的例子如果使用位置索引时会有警告：FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`

    如果不指定index就可以直接使用位置索引。

    Series也支持负数索引，与NumPy的数组是一样的。

    Series也支持切片：

    1. s = pd.Series([1,2,3,4,5])
    2. print(s[0]) #1
    3. print(s[2:3]) #2 3
    4. print(s[::2]) #1 3 5
    5.  
    6. ‘’'
    7. 1
    8. 2    3
    9. dtype: int64
    10. 0    1
    11. 2    3
    12. 4    5
    13. dtype: int64
    14. ‘''

    使用索引标签访问多个元素值，需要把标签放在二位数组里：

    1. s = pd.Series([1,2,3,4,5], index=['a', 'b', 'c', 'd', 'e'])
    2. print(s[['b', 'c', 'a']])
    3.  
    4. ‘’'
    5. b    2
    6. c    3
    7. a    1
    8. dtype: int64
    9. ‘''

    Series常用属性

    名称属性
    axes以列表的形式返回所有行索引标签。
    dtype返回对象的数据类型。
    empty返回一个布尔值，用于判断数据对象是否为空。
    ndim查看序列的维数。根据定义，Series 是一维数据结构，因此它始终返回 1。
    size返回输入数据的元素数量。
    values以 ndarray 的形式返回 Series 对象。
    array返回NumPy的数组对象
    index返回一个RangeIndex对象，用来描述索引的取值范围。
    iloc[...]下标访问元素

    hasnans

    		返回是否有空元素（NaN）
    is_unique返回s中的值是不是都是唯一的，如果是返回True
    is_monotonic_increasing如果s中的值是单调增长的，返回True
    is_monotonic_decreasing如果s中的值是单调递减的，返回True
    1. s = pd.Series([1,2,3,4,5], index=['a', 'b', 'c', 'd', 'e'])
    2. print(f'{s.axes=},{s.dtype=},{s.ndim=},{s.empty=}, {s.size=}')
    3. print(f'{s.values=}')
    4. print(f'{s.array=}')
    5. print(f'{s.index=}')
    6. print(f'{s.shape=}’)
    7. print(f'{s.hasnans=}')
    9. ‘’'
    10. s.axes=[Index(['a', 'b', 'c', 'd', 'e'], dtype='object')],s.dtype=dtype('int64'),s.ndim=1,s.empty=False, s.size=5
    11. s.values=array([1, 2, 3, 4, 5])
    12. s.array=
    13. [1, 2, 3, 4, 5]
    14. Length: 5, dtype: int64
    15. s.index=Index(['a', 'b', 'c', 'd', 'e'], dtype='object')
    16. s.shape=(5,)
    17. s.hasnans=False
    18. ‘''
    1. s = pd.Series([1,2,3,4,5], index=['a', 'b', 'c', 'd', 'e'])
    2. print(s.iloc[0]) #1
    3. print(s.iloc[2:])
    4. print(s.iloc[::-1])
    5.  
    6. ‘’'
    7. 1
    8. c    3
    9. d    4
    10. e    5
    11. dtype: int64
    12. e    5
    13. d    4
    14. c    3
    15. b    2
    16. a    1
    17. dtype: int64
    18. ‘''
    1. #s中的值全部是唯一的
    2. >>>s = pd.Series([1, 2, 3])
    3. >>>s.is_unique
    4. True
    5.  
    6. >>>s = pd.Series([1, 2, 3, 1])
    7. >>>s.is_unique
    8. False
    9.  
    10. #s中的值是否为单调增长
    11. >>>s = pd.Series([1, 2, 2])
    12. >>>s.is_monotonic_increasing
    13. True
    14.  
    15. >>>s = pd.Series([3, 2, 1])
    16. >>>s.is_monotonic_increasing
    17. False
    18.  
    19. #s中的值是否为单调减少
    20. >>>s = pd.Series([3, 2, 2, 1])
    21. >>>s.is_monotonic_decreasing
    22. True
    23.  
    24. >>>s = pd.Series([1, 2, 3])
    25. >>>s.is_monotonic_decreasing
    26. False

    Series支持的运算

    运算说明
    s.add(other[, level, fill_value, axis])s+other
    s.sub(other[, level, fill_value, axis])s-other
    s.mul(other[, level, fill_value, axis])s*other
    s.div(other[, level, fill_value, axis])s/other
    s.truediv(other[, level, fill_value, axis])s/other
    s.floordiv(other[, level, fill_value, axis])s//other
    s.mod(other[, level, fill_value, axis])s%other
    s.pow(other[, level, fill_value, axis])s**other
    s.radd(other[, level, fill_value, axis])s+other
    s.rsub(other[, level, fill_value, axis])s-other
    s.rmul(other[, level, fill_value, axis])s*other
    s.rdiv(other[, level, fill_value, axis])s/other
    s.rtruediv(other[, level, fill_value, axis])s/other
    s.rfloordiv(other[, level, fill_value, axis])s//other
    s.rmod(other[, level, fill_value, axis])s%other
    s.rpow(other[, level, fill_value, axis])s**other
    s.combine(other, func[, fill_value])分别对s、other的每对元素调用func，返回的结果为func返回的结果得到的Series。
    s.combine_first(other])使用other填充s对应的空值
    s.round(decimals=0, *args, **kwargs)每个元素四舍五入
    s.lt(other[, level, fill_value, axis])s
    s.gt(other[, level, fill_value, axis])s>other
    s.le(other[, level, fill_value, axis])s<=other
    s.ge(other[, level, fill_value, axis])s>=other
    s.ne(other[, level, fill_value, axis])s!=other
    s.eq(other[, level, fill_value, axis])s==other
    s.product(axis=None, skipna=True, numeric_only=False, min_count=0, **kwargs）

    所有元素的乘积

    skipna：是否跳过空值;numeric_only仅数字;min_count最少几个数

    s.dot(other)两个Series求笛卡尔积
    s.abs()对每个元素求绝对值
    简单运算符举例 
    1. import pandas as pd
    2.  
    3. s1 = pd.Series([1,2,3,4,5])
    4. s2 = pd.Series([10,20,30,40,50])
    5. s3 = s2 - s1
    6. print(f's3=s2 - s1,s3:\n', s3)
    7. s4 = s2.sub(s1) #sub和-实际是等效果的
    8. print(f's4=s2.sub(s1),s4:\n',s4)
    9. print(f's3 == s4 :\n', s3 == s4)
    10.  
    11. ‘’'
    12. s3=s2 - s1,s3:
    13.  0     9
    14. 1    18
    15. 2    27
    16. 3    36
    17. 4    45
    18. dtype: int64
    19. s4=s2.sub(s1),s4:
    20.  0     9
    21. 1    18
    22. 2    27
    23. 3    36
    24. 4    45
    25. dtype: int64
    26. s3 == s4 :
    27.  0    True
    28. 1    True
    29. 2    True
    30. 3    True
    31. 4    True
    32. dtype: bool
    33. ‘''
    组合调用函数combine
    1. import numpy as np
    2. import pandas as pd
    3. import operator
    4.  
    5. s1 = pd.Series([11,12,33,24,51])
    6. s2 = pd.Series([10,20,30,40,50])
    7. s5 = s1.combine(s2, max)
    8. print('s5 = s1.combine(s2, max)\n', s5)
    9.  
    10. s6 = s1.combine(s2, operator.add) #func接受两个参数
    11. print('s6 = s1.combine(s2, operator.add)\n', s6)
    12.  
    13. #测试fill_value
    14. s3 = pd.Series([10,20,30,None,50])
    15. print('s3:\n', s3)
    16. s4 = s1.combine(s3, max) #有没有fill_value=0，max都可以处理
    17. print('s4 = s1.combine(s3, max):\n', s4)
    18. s4 = s1.combine(s3, max, fill_value=0)
    19. print('s4 = s1.combine(s3, max, fill_value=0):\n', s4)
    20.  
    21. s7 = s1.combine(s3, operator.add, fill_value=0) #add处理不了
    22. print('s7 = s1.combine(s3,operator.add, fill_value=0)\n', s7)
    23.  
    24. def foo(*args):
    25.     print(f'foo {args=}')
    26.     return 0
    27. s7 = s1.combine(s3,foo, fill_value=0) #可以看到传入func的参数None并未被替换为0
    28. print('s7 = s1.combine(s3,foo, fill_value=0)\n', s7)
    29.  
    30.  
    31. ‘’'
    32. s5 = s1.combine(s2, max)
    33.  0    11
    34. 1    20
    35. 2    33
    36. 3    40
    37. 4    51
    38. dtype: int64
    39. s6 = s1.combine(s2, operator.add)
    40.  0     21
    41. 1     32
    42. 2     63
    43. 3     64
    44. 4    101
    45. dtype: int64
    46. s3:
    47.  0    10.0
    48. 1    20.0
    49. 2    30.0
    50. 3     NaN
    51. 4    50.0
    52. dtype: float64
    53. s4 = s1.combine(s3, max):
    54.  0    11
    55. 1    20
    56. 2    33
    57. 3    24
    58. 4    51
    59. dtype: int64
    60. s4 = s1.combine(s3, max, fill_value=0):
    61.  0    11
    62. 1    20
    63. 2    33
    64. 3    24
    65. 4    51
    66. dtype: int64
    67. s7 = s1.combine(s3,operator.add, fill_value=0)
    68.  0     21.0
    69. 1     32.0
    70. 2     63.0
    71. 3      NaN
    72. 4    101.0
    73. dtype: float64
    74. foo args=(11, 10.0)
    75. foo args=(12, 20.0)
    76. foo args=(33, 30.0)
    77. foo args=(24, nan)
    78. foo args=(51, 50.0)
    79. s7 = s1.combine(s3,foo, fill_value=0)
    80.  0    0
    81. 1    0
    82. 2    0
    83. 3    0
    84. 4    0
    85. dtype: int64
    87. ‘''
    填充空值combine_first
    1. import pandas as pd
    2.  
    3. s1 = pd.Series([10,None,30,None,50])
    4. s2 = pd.Series([1,2,None,4,5])
    5. s3 = s1.combine_first(s2)
    6. print(s3)
    7.  
    8. ’’’
    9. 0    10.0
    10. 1     2.0
    11. 2    30.0
    12. 3     4.0
    13. 4    50.0
    14. dtype: float64
    15. ‘’‘
    连乘product
    1. import pandas as pd
    2.  
    3.  
    4. s1 = pd.Series([1,2,3,4,5])
    5. print(s1.product()) #120
    6. s2 = pd.Series([1,2,3,None,5])
    7. print(s2.product()) #15
    8. print(s2.product(skipna=False)) #nan
    9. print(s2.product(skipna=False, min_count=1)) #nan

    Series支持的其他方法

    运算说明
    s.abs()
    s.all([axis, bool_only, skipna])
    s.any(*[, axis, bool_only, skipna])
    s.autocorr([lag])
    s.between(left, right[, inclusive])
    s.clip([lower, upper, axis, inplace])
    s.corr(other[, method, min_periods])
    s.count()
    s.cov(other[, min_periods, ddof])
    s.cummax([axis, skipna])
    s.cummin([axis, skipna])
    s.cumprod([axis, skipna])
    s.cumsum([axis, skipna])
    s.describe([percentiles, include, exclude])
    s.diff([periods])
    s.factorize([sort, use_na_sentinel])
    s.kurt([axis, skipna, numeric_only])
    s.max([axis, skipna, numeric_only])
    s.mean([axis, skipna, numeric_only])
    s.median([axis, skipna, numeric_only])
    s.min([axis, skipna, numeric_only])
    s.mode([dropna])
    s.nlargest([n, keep])
    s.pct_change([periods, fill_method, ...])
    s.prod([axis, skipna, numeric_only, ...])
    s.quantile([q, interpolation])
    s.rank([axis, method, numeric_only, ...])
    s.sem([axis, skipna, ddof, numeric_only])
    s.skew([axis, skipna, numeric_only])
    s.std([axis, skipna, ddof, numeric_only])
    s.sum([axis, skipna, numeric_only, ...])
    s.var([axis, skipna, ddof, numeric_only])
    s.kurtosis([axis, skipna, numeric_only])
    s.unique()
    s.nunique([dropna])
    s.value_counts([normalize, sort, ...])

    Series常用方法

    Series提供的方法非常多，这里列举了一些常见的方法

    元素查询方法
    方法名说明
    s.head(n)返回前 n 行数据，默认返回前 5 行数据
    s.tail(n)返回后 n 行数据，默认返回后 5 行数据
    pd.isnull(s)检测 Series 中的缺失值，如果有值不存在或缺失（NaN），返回True
    pd.notnull(s)检测 Series 中的缺失值，如果有值不存在或缺失（NaN），返回False
    s.get(key[,default])通过索引获取值
    s.at[index]通过索引访问值
    s.iat[iloc]通过整数索引访问值
    s.loc[index]通过索引访问值
    s.iloc[iloc]通过整数索引访问值
    s.__iter__()返回元素的迭代器
    s.items()返回(index,value)的zip对象，可以通过list转化为列表
    s.keys()返回index对象
    s.isin(values)逐个检查s中的元素，看是否在values中，得到一个新的bool的Series
    s.where(cond[, other, inplace, axis, level])按条件查询，如果条件为假，可以使用other取代
    s.mask(cond[, other, inplace, axis, level])按条件查询，如果条件为真，可以使用other取代
    s.filter([items, like, regex, axis])按索引过滤

    1. import pandas as pd
    2.  
    3. s1 = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])
    4. print(s1.get('b')) #2
    5. print(s1.at['c']) #3
    6. print(s1.iat[4]) #5
    7. print(s1.iat[-2]) #4
    8. print(s1.loc['a']) #1
    9. print(s1.iloc[3]) #4
    10. print(list(s1.items())) #[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]
    11. print(s1.keys()) #Index(['a', 'b', 'c', 'd', 'e'], dtype='object')
    12. bv = s1.pop('b')
    13. print(f's1.pop(b)后的s1:{bv=}\n', s1)
    14.  
    15.  
    16. ‘’'
    17. 2
    18. 3
    19. 5
    20. 4
    21. 1
    22. 4
    23. [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]
    24. Index(['a', 'b', 'c', 'd', 'e'], dtype='object')
    25. s1.pop(b)后的s1:bv=2
    26.  a    1
    27. c    3
    28. d    4
    29. e    5
    30. dtype: int64
    31. ‘''

    1. import pandas as pd
    2.  
    3. s1 = pd.Series([10,20,30,40,50], index=['A', 'B', 'C', 'D', 'E'])
    4. print("s1>30:\n", s1.where(s1>30))
    5.  
    6. ’’’
    7. s1>30:
    8.  A     NaN
    9. B     NaN
    10. C     NaN
    11. D    40.0
    12. E    50.0
    13. dtype: float64
    14. ‘’‘
    1. import pandas as pd
    2.  
    3. s1 = pd.Series([10,20,30,40,50], index=['A', 'B', 'C', 'D', 'E'])
    4.  
    5. print("s1>30:\n", s1.where(s1>30))
    6. print("s1>30,other=[1]:\n", s1.where(s1>30, other=[1]))
    7. print("s1>30,other=[1]:\n", s1.mask(s1>30, other=[1]))
    8.  
    9. print("s1.filter(items=['A', 'B']):\n", s1.filter(items=['A', 'B']))
    10. print("s1.filter(regex=['ABC']:\n", s1.filter(regex="['ABC']”))
    12. ‘’'
    13. s1>30:
    14.  A     NaN
    15. B     NaN
    16. C     NaN
    17. D    40.0
    18. E    50.0
    19. dtype: float64
    20. s1>30,other=[1]:
    21.  A     1
    22. B     1
    23. C     1
    24. D    40
    25. E    50
    26. dtype: int64
    27. s1>30,other=[1]:
    28.  A    10
    29. B    20
    30. C    30
    31. D     1
    32. E     1
    33. dtype: int64
    34. s1.filter(items=['A', 'B']):
    35.  A    10
    36. B    20
    37. dtype: int64
    38. s1.filter(regex=['ABC']:
    39.  A    10
    40. B    20
    41. C    30
    42. dtype: int64
    43. ‘''

    复制和类型变换
    方法名说明
    s.copy(deep=True)深拷贝，返回一个复制的Series，如果deep=False将得到一个浅拷贝
    s.to_list()将Series转换为list结构返回
    s.apply(func[, convert_dtype, args, by_row])对Series的每个值调用func函数
    s.astype(dtype, copy=None, errors='raise')将s元素的类型进行变换为dtype指定的类型
    s.to_numpy(dtype=None, copy=False, na_value=_NoDefault.no_default, **kwargs)将s转化为NumPy数组
    s.__array__(dtype=None)返回s底层的NumPy数组，如果改变了NumPy数组，s的元素值也会变化
    s.to_pickle(path[, compression, ...])将s序列化写入文件
    s.to_csv([path_or_buf, sep, na_rep, ...])将s写入csv文件
    s.to_dict([into])将s转为dict
    s.to_excel(excel_writer[, sheet_name, ...])将s写入excel文件
    s.to_frame([name])将s转换为DataFrame
    s.to_xarray()将s转换为xarray对象
    s.to_hdf(path_or_buf, key[, mode, ...])将s写入为HDFS文件
    s.to_sql(name, con, *[, schema, ...])将s转为为sql语句
    s.to_json([path_or_buf, orient, ...])将s转化为json对象
    s.to_string([buf, na_rep, ...])将s转化为string对象
    s.to_clipboard([excel, sep])拷贝s对象到系统剪切板
    s.to_latex([buf, columns, header, ...])转换s为LaTeX
    s.to_markdown([buf, mode, index, ...])转换s为MarkDown

    1. import pandas as pd
    2.  
    3. s1 = pd.Series([1, 2], dtype='int32')
    4. print('s1:\n', s1)
    5. s2 = s1.astype('float32')
    6. print('s2:\n',s2)
    7. s3 = s1.astype('int16', copy=False)
    8. print('s3:\n',s3)
    9. s3[0] = 10
    10. print('修改s3后的s1:\n',s1)
    11.  
    12. ‘’'
    13. s1:
    14.  0    1
    15. 1    2
    16. dtype: int32
    17. s2:
    18.  0    1.0
    19. 1    2.0
    20. dtype: float32
    21. s3:
    22.  0    1
    23. 1    2
    24. dtype: int16
    25. 修改s3后的s1:
    26.  0    1
    27. 1    2
    28. dtype: int32
    29. ‘''
    1. import pandas as pd
    2.  
    3. s1 = pd.Series([1, 2, 3, 4, 5])
    4. a = s1.to_numpy()
    5. print(f'{type(a)=}',a)
    6.  
    7. a2 = s1.__array__()
    8. a2[1] = 10
    9. print(s1)
    10.  
    11. ‘’'
    12. type(a)=numpy.ndarray'> [1 2 3 4 5]
    14. 0     1
    15. 1    10
    16. 2     3
    17. 3     4
    18. 4     5
    19. dtype: int64
    20. ‘''
    1. s1 = pd.Series([None, None, 3, 4, None], index=['A', 'B', 'C', 'D', 'E'])
    2. print(s1.to_dict())
    3.  
    4. #{'A': nan, 'B': nan, 'C': 3.0, 'D': 4.0, 'E': nan}

    排序
    方法名说明
    s.argsort([axis, kind, order])返回排序的整数下标，一个新的Series
    s.argmin([axis, skipna])返回最小值的下标位置，多个只返回第一个
    s.argmax([axis, skipna])返回最大值的下标位置，多个只返回第一个
    s.sort_values(*[, axis, ascending, ...])按值进行排序，将得到一个新的Series
    s.sort_index(*[, axis, level, ...])按索引排序，将得到一个新的Series
    s.reorder_levels(order)s有多个索引的情况，重组索引的排列顺序，order是重新组织的索引序号的排列
    s.swaplevel([i, j, copy])s有多个索引的情况，交换索引，i，j是索引的序号
    s.unstack([level, fill_value, sort])s有多个索引的情况，将s转换为DataFrame，level指定的是索引序号
    s.explode([ignore_index])把有复杂元素的Series拉平成一维的Series
    s.searchsorted(value[, side, sorter])在已排序的Series中插入value，返回value应该插入的下标位置，如果Series不是已经排序好的，可能会找到第一个认为合适的位置
    s.ravel([order])返回底层数组
    s.repeat(repeats[, axis])循环复制s的元素repeats次，得到一个新的Series
    s.view([dtype])创建一个s的视图
    1. import pandas as pd
    2.  
    3. s1 = pd.Series([5,4,3,2,1], index=['A','B','C','D','E'])
    4. s2 = s1.argsort()
    5. print('s2 = s1.argsort():\n', s2)
    6.  
    7. s1 = pd.Series([5,5,3,1,1], index=['A','B','C','D','E'])
    8. print(f'{s1.argmin()=}')
    9. print(f'{s1.argmax()=}')
    10.  
    11. s1 = pd.Series([5,5,3,1,1], index=['A','B','A','B','A'])
    12. print('s1.sort_values():\n', s1.sort_values())
    13. print('s1.sort_index():\n', s1.sort_index())
    14.  
    15. s2 = pd.Series([5,5,3,1,1], index=[['A','B','A','B','A'],['S5','S2','S4','S3','S1'],['C1','C2','C3','C4','C5']])
    16. print('s2.reorder_levels([1,0,2]:\n', s2.reorder_levels([1,0,2]))
    17. print('s2.swaplevel(0):\n', s2.swaplevel(0))
    18. print('s2.swaplevel(1,2):\n', s2.swaplevel(1,2))
    19. print('s2.unstack(level=1,fill_value=0):\n', s2.unstack(level=1,fill_value=0))
    20.  
    21. s3 = pd.Series([[1,2,3], 'foo', [], [5,6]])
    22. print(f's3:\n{s3}')
    23. print('s3.explode():\n', s3.explode())
    24.  
    25. s1 = pd.Series([1,2,3,4,5],index=['A','B','A','B','A'])
    26. print(f'{s1.searchsorted(4)=}')
    27. s1 = pd.Series([3,4,5,2,1],index=['A','B','A','B','A'])
    28. print(f'{s1.searchsorted(4)=}')
    29. print('s1.repeat(2):\n', s1.repeat(2))
    30. s2 = s1.view('int64')
    31. s2['A'] = 1234567890
    32. print(f'{s1=}')
    33.  
    34. ‘’’
    35. s2 = s1.argsort():
    36.  A    4
    37. B    3
    38. C    2
    39. D    1
    40. E    0
    41. dtype: int64
    42. s1.argmin()=3
    43. s1.argmax()=0
    44. s1.sort_values():
    45.  B    1
    46. A    1
    47. A    3
    48. A    5
    49. B    5
    50. dtype: int64
    51. s1.sort_index():
    52.  A    5
    53. A    3
    54. A    1
    55. B    5
    56. B    1
    57. dtype: int64
    58. s2.reorder_levels([1,0,2]:
    59.  S5  A  C1    5
    60. S2  B  C2    5
    61. S4  A  C3    3
    62. S3  B  C4    1
    63. S1  A  C5    1
    64. dtype: int64
    65. s2.swaplevel(0):
    66.  C1  S5  A    5
    67. C2  S2  B    5
    68. C3  S4  A    3
    69. C4  S3  B    1
    70. C5  S1  A    1
    71. dtype: int64
    72. s2.swaplevel(1,2):
    73.  A  C1  S5    5
    74. B  C2  S2    5
    75. A  C3  S4    3
    76. B  C4  S3    1
    77. A  C5  S1    1
    78. dtype: int64
    79. s2.unstack(level=1,fill_value=0):
    80.        S1  S2  S3  S4  S5
    81. A C1   0   0   0   0   5
    82.   C3   0   0   0   3   0
    83.   C5   1   0   0   0   0
    84. B C2   0   5   0   0   0
    85.   C4   0   0   1   0   0
    86. s3:
    87. 0    [1, 2, 3]
    88. 1          foo
    89. 2           []
    90. 3       [5, 6]
    91. dtype: object
    92. s3.explode():
    93.  0      1
    94. 0      2
    95. 0      3
    96. 1    foo
    97. 2    NaN
    98. 3      5
    99. 3      6
    100. dtype: object
    101. s1.searchsorted(4)=3
    102. s1.searchsorted(4)=1
    103. s1.repeat(2):
    104.  A    3
    105. A    3
    106. B    4
    107. B    4
    108. A    5
    109. A    5
    110. B    2
    111. B    2
    112. A    1
    113. A    1
    114. dtype: int64
    115. s1=A    1234567890
    116. B             4
    117. A    1234567890
    118. B             2
    119. A    1234567890
    120. dtype: int64
    121.  
    122. ‘''

    操作单个元素
    方法名说明
    s.drop([labels, axis, index, columns, ...])返回删除指定索引的元素的一个新Series，s没有影响
    s.drop_duplicates(*[, keep, inplace, ...])返回删除重复元素的一个新Series，s没有影响
    s.duplicated([keep])逐个元素判断是否是重复元素，得到一个新的bool值的Series
    s.pop(index)获取index指定的元素，并将该元素从s中删除
    批量操作元素
    方法名说明
    s.all([axis, bool_only, skipna])检查是否所有元素都为True
    s.any(*[, axis, bool_only, skipna])检查是否任意一元素为True
    s.between(left, right[, inclusive])检查元素是否在left和right之间（含边界值），返回bool的Series序列，NaN被认为是False
    s.count()统计Series中非空值的个数
    s.cov(other[, min_periods, ddof])计算s和other的协方差，s和other不要求有相同的长度
    s.cummax([axis, skipna])计算s的累计最大值，就是按顺序比较，如果当前值比当前为止的最大值大，就将当前值作为最大值，始终用最大值填充当前的位置
    s.cummin([axis, skipna])计算s的累计最小值
    s.cumprod([axis, skipna])

    计算s的累计乘积，将得到一个新的Series，命名为ns：

    ns的第0个元素等于s的第0个元素

    ns的第1个元素等于ns的第0个元素与s第1个元素的乘积

    ns的第2个元素等于ns的第1个元素与s第2个元素的乘积

    ...（以此类推）

    s.cumsum([axis, skipna])计算s的累计和
    s.describe([percentiles, include, exclude])得到s的统计信息，对于数字数据，包括count, mean, std, min, max等函数的饿值
    s.diff([periods])

    计算s的两个元素之间的差值：

    第0个差值为NaN

    第1个差值为：第0个与第1个

    第2个差值为：第1个与第2个

    ...

    periods指定起始的位置，如果为-1，就是从最后一个往前算

    s.max([axis, skipna, numeric_only])返回s的最大元素
    s.min([axis, skipna, numeric_only])返回s的最小元素
    s.mean([axis, skipna, numeric_only])返回s的算术平均数
    s.median([axis, skipna, numeric_only])返回s的元素的中位数（不是平均值，大小在中间的那个）
    s.mode([dropna])返回重复次数最多的数，如果有最多的重复数是多个，则返回多个
    s.nlargest([n, keep])返回最大的n个元素
    s.nsmallest([n, keep])返回最小的n个元素
    s.pct_change([periods, fill_method, ...])计算变化的比例：(当前元素-前一个元素)/前一个元素
    s.prod([axis, skipna, numeric_only, ...])返回所有元素的乘积
    s.std([axis, skipna, ddof, numeric_only])求s所有元素的标准差
    s.sum([axis, skipna, numeric_only, ...])求s所有元素的和
    s.var([axis, skipna, ddof, numeric_only])求s所有元素的无偏方差
    s.unique()返回s元素的唯一元素（去重）
    s.nunique([dropna])返回s中唯一元素的个数
    s.equals(other)检查s和other包含的元素是否一致，要求顺序和索引也是一致的
    s.truncate([before, after, axis, copy])截断before前和after后的元素，生成一个新的Series
    s.replace([to_replace, value, inplace, ...])值替换，to_replace指定要替换的值，value替换后的值
    s.compare(other[, align_axis, ...])比较s、other的元素，将有差异的元素生成DataFrame
    s.update(other)用other去更新s
    1. import pandas as pd
    2.  
    3. s1 = pd.Series([10,20,30,40,50])
    4. s2 = s1.between(20,40) #检查 20<=元素<=40
    5. print(s2)
    6.  
    7. s1 = pd.Series([10,20,30,None,50])
    8. print(f'{s1.count()=}')
    9.  
    10. s2 = pd.Series([10,20,60,50,70,66])
    11. print('s2.cummax():\n', s2.cummax())
    12.  
    13. s1 = pd.Series([1,2,3,4,5])
    14. print('s1.cumprod():\n', s1.cumprod())
    15. print('s1.cumsum():\n', s1.cumsum())
    16. print('s1.describe():\n', s1.describe())
    17. print('s1.diff():\n', s1.diff())
    18. print('s1.diff(periods=0):\n', s1.diff(periods=0))
    19. print('s1.diff(periods=-1):\n', s1.diff(periods=-1))
    20. print(f'{s1.max()=}')
    21. print(f'{s1.min()=}')
    22. print(f'{s1.mean()=}')
    23. s2 = pd.Series([1,2,3,40,50])
    24. print(f'{s2.median()=}')
    25. print(f'{s2.mode()=}')
    26. s3 = pd.Series([2,4,2,4,3,2,5])
    27. print(f'{s3.mode()=}')
    28. print(f'{s1.nlargest(2)=}')
    29. print(f'{s1.nsmallest(2)=}')
    30. print(f'{s1.pct_change()=}')
    31. print(f'{s1.prod()=}')
    32. print(f'{s1.std()=}')
    33. print(f'{s1.var()=}')
    34. print(f'{s3.unique()=}')
    35. print(f'{s1.nunique()=}')
    36.  
    37. ’’’
    38. 0    False
    39. 1     True
    40. 2     True
    41. 3     True
    42. 4    False
    43. dtype: bool
    44. s1.count()=4
    45. s2.cummax():
    46.  0    10
    47. 1    20
    48. 2    60
    49. 3    60
    50. 4    70
    51. 5    70
    52. dtype: int64
    53. s1.cumprod():
    54.  0      1
    55. 1      2
    56. 2      6
    57. 3     24
    58. 4    120
    59. dtype: int64
    60. s1.cumsum():
    61.  0     1
    62. 1     3
    63. 2     6
    64. 3    10
    65. 4    15
    66. dtype: int64
    67. s1.describe():
    68.  count    5.000000
    69. mean     3.000000
    70. std      1.581139
    71. min      1.000000
    72. 25%      2.000000
    73. 50%      3.000000
    74. 75%      4.000000
    75. max      5.000000
    76. dtype: float64
    77. s1.diff():
    78.  0    NaN
    79. 1    1.0
    80. 2    1.0
    81. 3    1.0
    82. 4    1.0
    83. dtype: float64
    84. s1.diff(periods=0):
    85.  0    0.0
    86. 1    0.0
    87. 2    0.0
    88. 3    0.0
    89. 4    0.0
    90. dtype: float64
    91. s1.diff(periods=-1):
    92.  0   -1.0
    93. 1   -1.0
    94. 2   -1.0
    95. 3   -1.0
    96. 4    NaN
    97. dtype: float64
    98. s1.max()=5
    99. s1.min()=1
    100. s1.mean()=3.0
    101. s2.median()=3.0
    102. s2.mode()=0     1
    103. 1     2
    104. 2     3
    105. 3    40
    106. 4    50
    107. dtype: int64
    108. s3.mode()=0    2
    109. dtype: int64
    110. s1.nlargest(2)=4    5
    111. 3    4
    112. dtype: int64
    113. s1.nsmallest(2)=0    1
    114. 1    2
    115. dtype: int64
    116. s1.pct_change()=0         NaN
    117. 1    1.000000
    118. 2    0.500000
    119. 3    0.333333
    120. 4    0.250000
    121. dtype: float64
    122. s1.prod()=120
    123. s1.std()=1.5811388300841898
    124. s1.var()=2.5
    125. s3.unique()=array([2, 4, 3, 5])
    126. s1.nunique()=5
    127. ‘’‘
    1. s7 = pd.Series([20,20,30,30,20])
    2. s8 = s7.replace(20, 100)
    3. print('s8 = s7.replace(1, 100):\n', s8)
    4.  
    5. ’’’
    6. s8 = s7.replace(1, 100):
    7.  0    100
    8. 1    100
    9. 2     30
    10. 3     30
    11. 4    100
    12. dtype: int64
    13. ‘’‘

     处理空值
    方法名说明

    s.backfill(*[, axis, inplace, limit, ...])

    		使用后面非空的值填充空值，得到一个新的Series
    s.bfill(*[, axis, inplace, limit, downcast])使用后面非空的值填充空值，得到一个新的Series
    s.dropna(*[, axis, inplace, how, ...])删除空值，得到一个新的Series

    s.ffill(*[, axis, inplace, limit, downcast])

    s.pad(*[, axis, inplace, limit, downcast])

    		使用紧接着的前面值填充空值，得到一个新的Series
    s.fillna([value, method, axis, ...])使用值value或方法method去填充空值。如果value是一个标量值，所有的控制都填充为value；如果value是一个字典dict，key指定的是s的index，将对应的用字典的值去替换key对应的index位置的空值进行替换；如果是method方法，指定的是前面的bfill、backfill、ffill等方法，得到一个新的Series
    s.interpolate([method, axis, limit, ...])使用插值法填充空值，得到一个新的Series

    s.isna()

    s.isnull()

    		检测控制，得到一个新的bool类型的Series，对应的元素如果是空值为True，否则为False

    s.notna()

    s.notnull()

    		与isna()一样，只是如果是空值则为False
    s.first_valid_index()返回第一个非空值的索引
    s.last_valid_index()返回最后一个非空值的索引

    1. s1 = pd.Series([None, None, 3, 4, None], index=['A', 'B', 'C', 'D', 'E'])
    2. print(s1.first_valid_index()) #C
    高阶函数 
    方法名说明
    s.apply(func[, convert_dtype, args, by_row])对Series的每个值调用func函数，func接收一个参数，当args指定n个参数时，就接收n+1个参数，第一个参数始终是每个元素的值
    s.agg([func, axis])对Series使用聚合函数，func必须聚合函数名的字符串
    s.aggregate([func, axis])对Series使用聚合函数，func必须聚合函数名的字符串
    s.transform(func[, axis])对每一个元素调用func，func只接收一个参数（每个元素轮一遍），结果组成一个新的Series
    s.map(arg[, na_action])如果arg是一个字典dic，就查找dic的key对应的s中的值，如果找不到就填充为NaN，找到就填充为s中的值，生成一个新的Series，如果arg是一个函数，与transform一样
    s.groupby([by, axis, level, as_index, ...])按给定的标识去分组，by作为分组的标识
    s.rolling(window[, min_periods, ...])滑动窗口计算，windows是指计算的元素有几个
    s.expanding([min_periods, axis, method])扩展窗口计算
    s.ewm([com, span, halflife, alpha, ...])指数加权计算

    1. s1 = pd.Series([2,30,4,31,32], index=['A','B','C','D','E'])
    2. sg = s1.groupby(['1','2','1','2','2']) #把5个数按'1'，'2'进行分组
    3. print(sg.groups) #打印两个分组的索引
    4. #{'1': ['A', 'C'], '2': ['B', 'D', 'E']}
    5. print(sg.mean()) #分组求平均
    6. # 1     3.0
    7. # 2    31.0
    8. # dtype: float64
    1. s1 = pd.Series([1,2,3,4,5,6])
    2. print(s1.rolling(2).sum())
    3.  
    4. ‘’’
    5. 0     NaN
    6. 1     3.0
    7. 2     5.0
    8. 3     7.0
    9. 4     9.0
    10. 5    11.0
    11. dtype: float64
    12. ’’’
    13.  
    14. print(s1.expanding(2).sum())
    15. ‘’’
    16. 0     NaN
    17. 1     3.0
    18. 2     6.0
    19. 3    10.0
    20. 4    15.0
    21. 5    21.0
    22. dtype: float64
    23. ’‘’

    DataFrame

    DataFrame 一个表格型的数据结构，类似于 Excel 、SQL 表，既有行标签（index），又有列标签（columns），它也被称异构数据表，所谓异构，指的是表格中每列的数据类型可以不同，比如可以是字符串、整型或者浮点型等。

    DataFrame 的每一行数据都可以看成一个 Series 结构，只不过，DataFrame 为这些行中每个数据值增加了一个列标签。因此 DataFrame 其实是从 Series 的基础上演变而来。在数据分析任务中 DataFrame 的应用非常广泛，因为它描述数据的更为清晰、直观。

    DataFrame 数据结构的特点做简单地总结，如下所示：

    • DataFrame 每一列的标签值允许使用不同的数据类型；
    • DataFrame 是表格型的数据结构，具有行和列；
    • DataFrame 中的每个数据值都可以被修改。
    • DataFrame 结构的行数、列数允许增加或者删除；
    • DataFrame 有两个方向的标签轴，分别是行标签和列标签；
    • DataFrame 可以对行和列执行算术运算。

    DataFrame对象定义

    pd.DataFrame( data, index, columns, dtype, copy)

    参数说明：

    • data：输入的数据，可以是 ndarray，series，list，dict，标量以及一个 DataFrame。
    • index：行标签，如果没有传递 index 值，则默认行标签是 np.arange(n)，n 代表 data 的元素个数。
    • columns：列标签，如果没有传递 columns 值，则默认列标签是 np.arange(n)。
    • dtype：dtype表示每一列的数据类型。
    • copy：默认为 False，表示复制数据 data。

    创建一个空的DataFrame：

    1. import pandas as pd
    2. df = pd.DataFrame()
    3. print(df)
    4. ‘’’
    5. Empty DataFrame
    6. Columns: []
    7. Index: []
    8. ’‘’
    通过list创建DataFrame

    可以通过list创建一个简单的只有一列的DataFrame，如：

    1. import pandas as pd
    2.  
    3. df = pd.DataFrame([1,2,3,4,5,6])
    4. print(df)
    5. ‘’’
    6.    0
    7. 0  1
    8. 1  2
    9. 2  3
    10. 3  4
    11. 4  5
    12. 5  6
    13. ’‘’
    14.  
    15. df = pd.DataFrame([1,2,3,4,5,6], columns=['No']) #指定列名
    16. print(df)
    17. ‘’’
    18.    No
    19. 0   1
    20. 1   2
    21. 2   3
    22. 3   4
    23. 4   5
    24. 5   6
    25. ’‘’

    也可以通过嵌套列，创建多列的DataFrame：

    1. df = pd.DataFrame([['Alex', 10], ['John', 13], ['Rose', 8]], columns=['Name', 'Age'])
    2. print(df)
    3.  
    4. ‘’'
    5.    Name  Age
    6. 0  Alex   10
    7. 1  John   13
    8. 2  Rose    8
    9. ‘''
    通过dict创建DataFrame

    通过dict创建DataFrame，每个key都是一列，value是具体的列值（一般为list），要求value的list是等长的。

    1. import pandas as pd
    2. data = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
    3. df = pd.DataFrame(data)
    4. print(df)
    5.  
    6. ’’’
    7.       Age      Name
    8. 0     28        Tom
    9. 1     34       Jack
    10. 2     29      Steve
    11. 3     42      Ricky
    12. ‘’‘

    也可以通过列表中嵌套字典的方式，列表的每个元素都是一行，而嵌套的字典的key是列名，要求字典的key是一样的。

    1. df = pd.DataFrame([{'Name':'Alex', 'Age':10}, {'Name':'John', 'Age':13}, {'Name': 'Rose', 'Age': 8}])
    2. print(df)
    3.  
    4. ‘’'
    5.    Name  Age
    6. 0  Alex   10
    7. 1  John   13
    8. 2  Rose    8
    9. ‘''
    通过Series创建DataFrame

    可以传递一个字典形式的 Series，从而创建一个 DataFrame 对象，其输出结果的行索引是所有 index 的并集

    1. df = pd.DataFrame({'Name':pd.Series(['Tom', 'Jack', 'Steve', 'Ricky','Bob'], index=['A', 'B', 'C', 'D', 'E']),
    2.                                     'Age':pd.Series([28,34,29,42], index=['A', 'B', 'C', 'D'])})
    3. print(df)
    4.  
    5. ‘’'
    6.     Name   Age
    7. A    Tom  28.0
    8. B   Jack  34.0
    9. C  Steve  29.0
    10. D  Ricky  42.0
    11. E    Bob   NaN
    12. ‘''

    注意：两个Series的索引一定要一样或大致一样，生成的DataFrame的行是两个Series的索引的并集，只有索引一样的对应的元素才会被整合在一行。

    1. df = pd.DataFrame({'Name':pd.Series(['Tom', 'Jack', 'Steve', 'Ricky','Bob'], index=['A', 'B', 'C', 'D', 'E']),
    2.                                     'Age':pd.Series([28,34,29,42])})
    3.     Name   Age
    4. A    Tom   NaN
    5. B   Jack   NaN
    6. C  Steve   NaN
    7. D  Ricky   NaN
    8. E    Bob   NaN
    9. 0    NaN  28.0
    10. 1    NaN  34.0
    11. 2    NaN  29.0
    12. 3    NaN  42.0
    其他构建器
    函数和方法名说明
    DataFrame.from_dict(dict)接收字典组成的字典或数组序列字典，并生成 DataFrame
    DataFrame.from_records支持元组列表或结构数据类型（dtype）的多维数组

    列索引操作

    选取数据列

    可以直接通过列索引下标获取列：

    1. df = pd.DataFrame({'Name':pd.Series(['Tom', 'Jack', 'Steve', 'Ricky','Bob'], index=['A', 'B', 'C', 'D', 'E']),
    2.                                     'Age':pd.Series([28,34,29,42], index=['A', 'B', 'C', 'D'])})
    3. print('df:\n', df)
    4. print('df["Name"]:\n', df["Name"])
    5. print('df["Age"]:\n', df["Age”])
    7. ‘’'
    8. df:
    9.      Name   Age
    10. A    Tom  28.0
    11. B   Jack  34.0
    12. C  Steve  29.0
    13. D  Ricky  42.0
    14. E    Bob   NaN
    15. df["Name"]:
    16.  A      Tom
    17. B     Jack
    18. C    Steve
    19. D    Ricky
    20. E      Bob
    21. Name: Name, dtype: object
    22. df["Age"]:
    23.  A    28.0
    24. B    34.0
    25. C    29.0
    26. D    42.0
    27. E     NaN
    28. Name: Age, dtype: float64
    29. ‘''
    增加数据列

    也可以直接通过列索引增加数据列，主要注意的是新增的列，索引一定要匹配，否则会增加一个全部为NaN值的列：

    1. df = pd.DataFrame({'Name':pd.Series(['Tom', 'Jack', 'Steve', 'Ricky','Bob'], index=['A', 'B', 'C', 'D', 'E']),
    2.                                     'Age':pd.Series([28,34,29,42], index=['A', 'B', 'C', 'D'])})
    3. df['Score'] = pd.Series([90, 58, 99, 100, 48], index=['A', 'B', 'C', 'D', 'E'])
    4. print(df)
    5.  
    6. ’’’
    7.     Name   Age  Score
    8. A    Tom  28.0     90
    9. B   Jack  34.0     58
    10. C  Steve  29.0     99
    11. D  Ricky  42.0    100
    12. E    Bob   NaN     48
    13. ‘''
    14.  
    15. df['English'] = pd.Series([100, 100, 80, 100, 70])
    16. print(df)
    17. ‘’'
    18.     Name   Age  Score  English
    19. A    Tom  28.0     90      NaN
    20. B   Jack  34.0     58      NaN
    21. C  Steve  29.0     99      NaN
    22. D  Ricky  42.0    100      NaN
    23. E    Bob   NaN     48      NaN
    24. ‘''

    也可以直接引用DataFrame的列进行运算，增加计算列：

    1. df = pd.DataFrame({'Name':pd.Series(['Tom', 'Jack', 'Steve', 'Ricky','Bob'], index=['A', 'B', 'C', 'D', 'E']),
    2.                                     'Age':pd.Series([28,34,29,42], index=['A', 'B', 'C', 'D'])})
    3. df['Math'] = pd.Series([90, 58, 99, 100, 48], index=['A', 'B', 'C', 'D', 'E'])
    4. df['English'] = pd.Series([100, 100, 80, 100, 70], index=['A', 'B', 'C', 'D', 'E'])
    5. df['Total'] = df['Math'] + df['English']
    6. print(df)
    7.  
    8. ‘’'
    9.     Name   Age  Math  English  Total
    10. A    Tom  28.0    90      100    190
    11. B   Jack  34.0    58      100    158
    12. C  Steve  29.0    99       80    179
    13. D  Ricky  42.0   100      100    200
    14. E    Bob   NaN    48       70    118
    15. ‘''
    插入数据列

    通过insert方法可以插入一列：

    DataFrame.insert(loc, column, value, allow_duplicates=_NoDefault.no_default)

    参数说明：

    • loc：插入索引的位置，必须是0 <= loc <= len(columns).
    • column：要插入的列名
    • value：插入的列的值，一般是Series或者可以转换为Series的类型
    • allow_duplicates：是否允许重复
    1. df = pd.DataFrame({'Name':pd.Series(['Tom', 'Jack', 'Steve', 'Ricky','Bob'], index=['A', 'B', 'C', 'D', 'E']),
    2.                                     'Age':pd.Series([28,34,29,42], index=['A', 'B', 'C', 'D'])})
    3. df['Math'] = pd.Series([90, 58, 99, 100, 48], index=['A', 'B', 'C', 'D', 'E'])
    4. df['English'] = pd.Series([100, 100, 80, 100, 70], index=['A', 'B', 'C', 'D', 'E'])
    5. df.insert(2, 'Chinese', [100,99,98,96,90])
    6. print(df)
    7.  
    8. ’’’
    9.    Name   Age  Chinese  Math  English
    10. A    Tom  28.0      100    90      100
    11. B   Jack  34.0       99    58      100
    12. C  Steve  29.0       98    99       80
    13. D  Ricky  42.0       96   100      100
    14. E    Bob   NaN       90    48       70
    15. ‘’‘
    删除数据列

    通过 del 和 pop() 都能够删除 DataFrame 中的数据列。

    1. df = pd.DataFrame({'Name':pd.Series(['Tom', 'Jack', 'Steve', 'Ricky','Bob'], index=['A', 'B', 'C', 'D', 'E']),
    2.                                     'Age':pd.Series([28,34,29,42], index=['A', 'B', 'C', 'D'])})
    3. df['Math'] = pd.Series([90, 58, 99, 100, 48], index=['A', 'B', 'C', 'D', 'E'])
    4. df['English'] = pd.Series([100, 100, 80, 100, 70], index=['A', 'B', 'C', 'D', 'E'])
    5. del df['Age']
    6. print(df)
    7.  
    8. ‘’'
    9.    Name  Math  English
    10. A    Tom    90      100
    11. B   Jack    58      100
    12. C  Steve    99       80
    13. D  Ricky   100      100
    14. E    Bob    48       70
    15. ‘''

    pop()方法的定义如下：

    DataFrame.pop(item)

    参数说明：

    • item:列名
    1. df = pd.DataFrame({'Name':pd.Series(['Tom', 'Jack', 'Steve', 'Ricky','Bob'], index=['A', 'B', 'C', 'D', 'E']),
    2.                                     'Age':pd.Series([28,34,29,42], index=['A', 'B', 'C', 'D'])})
    3. df['Math'] = pd.Series([90, 58, 99, 100, 48], index=['A', 'B', 'C', 'D', 'E'])
    4. df['English'] = pd.Series([100, 100, 80, 100, 70], index=['A', 'B', 'C', 'D', 'E'])
    5. df.pop('Age')
    6. print(df)
    7.  
    8. ‘’'
    9.     Name  Math  English
    10. A    Tom    90      100
    11. B   Jack    58      100
    12. C  Steve    99       80
    13. D  Ricky   100      100
    14. E    Bob    48       70
    15. ‘''

    行索引操作

    选取数据行

    行索引操作，需要使用loc属性，使用中括号引用行，中括号内是行索引标识：

    1. df = pd.DataFrame({'Name':pd.Series(['Tom', 'Jack', 'Steve', 'Ricky','Bob'], index=['A', 'B', 'C', 'D', 'E']),
    2.                                     'Age':pd.Series([28,34,29,42], index=['A', 'B', 'C', 'D'])})
    3. df['Math'] = pd.Series([90, 58, 99, 100, 48], index=['A', 'B', 'C', 'D', 'E'])
    4. df['English'] = pd.Series([100, 100, 80, 100, 70], index=['A', 'B', 'C', 'D', 'E'])
    5. print(df.loc['B’])
    7. ’’’
    8. Name       Jack
    9. Age        34.0
    10. Math         58
    11. English     100
    12. Name: B, dtype: object
    13. ‘’‘

    loc属性的中括号中也可以指定两个参数，第一个是行的索引标识，第二个是列名：

    1. df = pd.DataFrame({'Name':pd.Series(['Tom', 'Jack', 'Steve', 'Ricky','Bob'], index=['A', 'B', 'C', 'D', 'E']),
    2.                                     'Age':pd.Series([28,34,29,42], index=['A', 'B', 'C', 'D'])})
    3. df['Math'] = pd.Series([90, 58, 99, 100, 48], index=['A', 'B', 'C', 'D', 'E'])
    4. df['English'] = pd.Series([100, 100, 80, 100, 70], index=['A', 'B', 'C', 'D', 'E'])
    5.  
    6. print(df.loc['B', 'Age’]) #34.0
    8. print(df.loc['B':'D’])
    9. ‘’'
    10.     Name   Age  Math  English
    11. B   Jack  34.0    58      100
    12. C  Steve  29.0    99       80
    13. D  Ricky  42.0   100      100
    14. ‘''

    也可以使用切片，如上例。

    也支持整数下标索引，需要使用iloc属性：

    1. df = pd.DataFrame({'Name':pd.Series(['Tom', 'Jack', 'Steve', 'Ricky','Bob'], index=['A', 'B', 'C', 'D', 'E']),
    2.                                     'Age':pd.Series([28,34,29,42], index=['A', 'B', 'C', 'D'])})
    3. df['Math'] = pd.Series([90, 58, 99, 100, 48], index=['A', 'B', 'C', 'D', 'E'])
    4. df['English'] = pd.Series([100, 100, 80, 100, 70], index=['A', 'B', 'C', 'D', 'E'])
    5. print(df.iloc[1])
    6. ‘’’
    7. Name       Jack
    8. Age        34.0
    9. Math         58
    10. English     100
    11. Name: B, dtype: object
    12. ’’’
    13.  
    14. print(df.iloc[1:3])
    15. ‘’’
    16.     Name   Age  Math  English
    17. B   Jack  34.0    58      100
    18. C  Steve  29.0    99       80
    19. ’’’
    20.  
    21. print(df.iloc[1, 2]) #58
    增加数据行

    可以像增加列一样，直接对loc进行行增加：

    1. df = pd.DataFrame({'Name':pd.Series(['Tom', 'Jack', 'Steve', 'Ricky','Bob'], index=['A', 'B', 'C', 'D', 'E']),
    2.                                     'Age':pd.Series([28,34,29,42], index=['A', 'B', 'C', 'D'])})
    3. df['Math'] = pd.Series([90, 58, 99, 100, 48], index=['A', 'B', 'C', 'D', 'E'])
    4. df['English'] = pd.Series([100, 100, 80, 100, 70], index=['A', 'B', 'C', 'D', 'E'])
    5.  
    6. df.loc['F'] = ['John', 51, 88, 89]
    7. print(df)
    8.  
    9. ‘’’
    10.    Name   Age  Math  English
    11. A    Tom  28.0    90      100
    12. B   Jack  34.0    58      100
    13. C  Steve  29.0    99       80
    14. D  Ricky  42.0   100      100
    15. E    Bob   NaN    48       70
    16. F   John  51.0    88       89
    17. ’‘’

    但是不能使用iloc增加，会提示IndexError: iloc cannot enlarge its target object

    删除数据行

    DataFrame.drop(labels=None, *, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')

    这个方法可以删除行，也可以删除列，如果未设置inplace，将得到删除数据后的一个新的DataFrame，原数据没有改变。

    参数说明：

    • labels：行、列的标签名，默认是行，和后面的axis配合使用
    • axis：默认是行，如果axis=1，则labels是列标签
    • index：直接指定行标签
    • columns：直接指定列标签
    1. import pandas as pd
    2.  
    3. df = pd.DataFrame({'Name':pd.Series(['Tom', 'Jack', 'Steve', 'Ricky','Bob'], index=['A', 'B', 'C', 'D', 'E']),
    4.                                     'Age':pd.Series([28,34,29,42], index=['A', 'B', 'C', 'D'])})
    5. df['Math'] = pd.Series([90, 58, 99, 100, 48], index=['A', 'B', 'C', 'D', 'E'])
    6. df['English'] = pd.Series([100, 100, 80, 100, 70], index=['A', 'B', 'C', 'D', 'E'])
    7.  
    8. df2 = df.drop(['B','C'], axis=0)
    9. print('df:\n', df, '\ndf2:\n', df2)
    10. ‘’’
    11. df:
    12.      Name   Age  Math  English
    13. A    Tom  28.0    90      100
    14. B   Jack  34.0    58      100
    15. C  Steve  29.0    99       80
    16. D  Ricky  42.0   100      100
    17. E    Bob   NaN    48       70 
    18. df2:
    19.      Name   Age  Math  English
    20. A    Tom  28.0    90      100
    21. D  Ricky  42.0   100      100
    22. E    Bob   NaN    48       70
    23. ’‘’
    24.  
    25. print("df.drop(index=['A', 'D']):\n", df.drop(index=['A', 'D']))
    26. ‘’’
    27. df.drop(index=['A', 'D']):
    28.      Name   Age  Math  English
    29. B   Jack  34.0    58      100
    30. C  Steve  29.0    99       80
    31. E    Bob   NaN    48       70
    32. ’‘’
    33.

    其他常见方法

    方法名属性&方法描述
    T行和列转置。
    axes返回一个仅以行轴标签和列轴标签为成员的列表。
    dtypes返回每列数据的数据类型。
    emptyDataFrame中没有数据或者任意坐标轴的长度为0，则返回True。
    ndim轴的数量，也指数组的维数。
    shape返回一个元组，表示了 DataFrame 维度。
    sizeDataFrame中的元素数量。
    values使用 numpy 数组表示 DataFrame 中的元素值。
    head()返回前 n 行数据。
    tail()返回后 n 行数据。
    shift()将行或列移动指定的步幅长度

  • 相关阅读:
    分析性质+排列置换环+最小割：1024T4
    微信小程序抓包-夜神模拟器结合BurpSuite抓包(可用于现在最新版本微信)
    【ECMAScript6】模块化
    Vue.js(2)： 组件与路由基础指南
    Guitar Pro 8win10最新版吉他学习 / 打谱 / 创作
    函数指针、函数指针数组、计算器+转移表等归纳总结
    无法启动此程序win10玩游戏找不到d3dx9_43.dll缺失的五种常用有效解决方法
    Vc - Qt - “扩张“的窗口
    计算机操作系统-并发控制
    MySQL索引、事务、事务与存储引擎
  • 原文地址：https://blog.csdn.net/spiritx/article/details/133618378