• Python3数据科学包系列(一):数据分析实战



    Python3中类的高级语法及实战

    Python3(基础|高级)语法实战(|多线程|多进程|线程池|进程池技术)|多线程安全问题解决方案

    Python3数据科学包系列(一):数据分析实战

    Python3数据科学包系列(二):数据分析实战



    认识下数据科学中数据处理基础包:

    (1)NumPy


    1. 俗话说: 要学会跑需先学会走
    2. (1)数据分析基础认知:
    3. NumPy是,Numerical Python的简称,它是目前Python数值计算中最为重要的基础包,大多数计算包提供了基于NumPy的科学函数功能;
    4. 将NumPy的数值对象作为数据交换的通用语
    5. NumPy通常用于处理如下场景数据的处理:
    6. ndarray,是一种高效多维数组,提供了基于数组的便捷算术操作以及灵活的广播功能;
    7. 对所有数据进行快速的计算,而无需编写循环程序
    8. 对硬盘数据进行读写的工具,并对内存映射文件进行操作
    9. 线性代数,随机数生成以及傅里叶变换功能
    10. 用于连接NumPy到C,C++代码库封装,并为这些代码提供动态,易用的接口
    11. 在大数据领域,通常更关注的内容如下 :
    12. 在数据处理,数据清洗,构造子集,过滤,变换以及其他计算中进行快速的向量化计算
    13. 常见的数组算法,比如sort,unique以及set操作
    14. 高效的描述性统计和聚合,概述数据
    15. 数据排序和相关数据操作,例如对异构数据进行merge和join
    16. 使用数组表达式来表明条件逻辑,代替if-elif-else条件分支的循环
    17. 分组数据的操作(聚合,变换,函数式操作)
    18. (2)NumPy两大亮点
    19. NumPy在内部将数据存储在连续的内存地址上,这与其他的Python内建数据结构时不同的。
    20. NumPy的算法库时C语言编写的,所以在操作数据内存时,不需要任何类型检查或者其他管理操作。
    21. NumPy数据使用的内存量也小于其他Python内建序列。
    22. NumPy可以针对全量数值进行复杂计算而不需要编写Python循环

    一: 数据分析高级语法:序列(Series) 

    1. # -*- coding:utf-8 -*-
    2. from pandas import Series
    3. import pandas as pd
    4. print('-------------------------------------序列Series定义与取值-------------------------------------------')
    5. print("""
    6. Series序列可以省略,此时索引号默认从0开始;
    7. 索引可以使指定的字母,或者字符串
    8. Series序列也可以任务是一维列表
    9. """)
    10. X = pd.Series(["a", 2, "螃蟹"], index=[1, 2, 3])
    11. print("Series数据类型: ", type(X))
    12. print()
    13. print(X)
    14. print()
    15. A = pd.Series([1, 2, 3, 22, 140, 23, 123, 2132131, 232222222222])
    16. print(A)
    17. print()
    18. print("序列A的第二个值: ", A[1])
    19. print()
    20. B = pd.Series([11, 23, 33, 44, 55, 56], index=['A', 'B', 'C', 'D', 'E', 'F'])
    21. print()
    22. print("序列B: ")
    23. print(B)
    24. print()
    25. print(B.__dict__.keys())
    26. print('访问序列的A的值:', B['A'])
    27. print('访问序列的B的值:', B['B'])
    28. print('-------------------------------------------------------------------------------------------------')
    29. print()
    30. AA = pd.Series([14, 24, 53, 33], index=['First', 'Second', 'Three', 'Four'])
    31. print("序列AA")
    32. print(AA)
    33. print()
    34. print("序列AA['Second']的取值: ", AA['Second'])
    35. print("序列AA[1]的取值: ", AA[1])
    36. print()
    37. try:
    38. print(AA[5])
    39. except IndexError as err:
    40. print("序列AA索引越界异常: ", err)
    41. N = pd.Series([2], index=['Hello'])
    42. # 给序列追加单个元素,会报错;但可用追加序列
    43. # AA.append(N)
    44. try:
    45. pd.concat(N)
    46. except TypeError as err:
    47. print("序列AA追加单个元素异常: ", err)
    48. x = ['上海', '北京', '深圳', '广州', '重庆']
    49. y = ['上海', '北京', '深圳', '广州', '天津']
    50. z = ['天津', '苏州', '成都', '武汉', '杭州']
    51. gdp1 = pd.Series([32679, 30320, 24691, 23000, 20363], index=x)
    52. gdp2 = pd.Series([30133, 28000, 22286, 21500, 18595], index=y)
    53. gdp3 = pd.Series([18809, 18597, 15342, 14847, 13500], index=z)
    54. result = [gdp1, gdp3]
    55. gdp4 = pd.concat(result)
    56. print(gdp4)

    运行效果:


    D:\program_file_worker\anaconda\python.exe D:\program_file_worker\python_source_work\SSO\grammar\dataanalysis\DataAnalysisExecutorSerias.py 

         俗话说: 要学会跑需先学会走
         (1)数据分析基础认知:
            NumPy是,Numerical Python的简称,它是目前Python数值计算中最为重要的基础包,大多数计算包提供了基于NumPy的科学函数功能;
            将NumPy的数值对象作为数据交换的通用语
         NumPy通常用于处理如下场景数据的处理:
            ndarray,是一种高效多维数组,提供了基于数组的便捷算术操作以及灵活的广播功能;
            对所有数据进行快速的计算,而无需编写循环程序
            对硬盘数据进行读写的工具,并对内存映射文件进行操作
            线性代数,随机数生成以及傅里叶变换功能
            用于连接NumPy到C,C++代码库封装,并为这些代码提供动态,易用的接口
         在大数据领域,通常更关注的内容如下 :
            在数据处理,数据清洗,构造子集,过滤,变换以及其他计算中进行快速的向量化计算
            常见的数组算法,比如sort,unique以及set操作
            高效的描述性统计和聚合,概述数据
            数据排序和相关数据操作,例如对异构数据进行merge和join
            使用数组表达式来表明条件逻辑,代替if-elif-else条件分支的循环
            分组数据的操作(聚合,变换,函数式操作)
         (2)NumPy两大亮点
            NumPy在内部将数据存储在连续的内存地址上,这与其他的Python内建数据结构时不同的。
            NumPy的算法库时C语言编写的,所以在操作数据内存时,不需要任何类型检查或者其他管理操作。
            NumPy数据使用的内存量也小于其他Python内建序列。
            
            NumPy可以针对全量数值进行复杂计算而不需要编写Python循环
            
            
            

    -------------------------------------序列Series定义与取值-------------------------------------------

       Series序列可以省略,此时索引号默认从0开始;
       索引可以使指定的字母,或者字符串
       Series序列也可以任务是一维列表
       
    Series数据类型:  

    1     a
    2     2
    3    螃蟹
    dtype: object

    0               1
    1               2
    2               3
    3              22
    4             140
    5              23
    6             123
    7         2132131
    8    232222222222
    dtype: int64

    序列A的第二个值:  2


    序列B: 
    A    11
    B    23
    C    33
    D    44
    E    55
    F    56
    dtype: int64

    dict_keys(['_is_copy', '_mgr', '_item_cache', '_attrs', '_flags', '_name'])
    访问序列的A的值: 11
    访问序列的B的值: 23
    -------------------------------------------------------------------------------------------------

    序列AA
    First     14
    Second    24
    Three     53
    Four      33
    dtype: int64

    序列AA['Second']的取值:  24
    序列AA[1]的取值:  24

    序列AA索引越界异常:  index 5 is out of bounds for axis 0 with size 4
    序列AA追加单个元素异常:  first argument must be an iterable of pandas objects, you passed an object of type "Series"
    上海    32679
    北京    30320
    深圳    24691
    广州    23000
    重庆    20363
    天津    18809
    苏州    18597
    成都    15342
    武汉    14847
    杭州    13500
    dtype: int64

    Process finished with exit code 0
     

    二:NumPy包的多维数组对象 

    1. 首先来看看使用NumPy生成一千万个数据与list列表生成同样多数据耗时情况
    2. # -*- coding:utf-8 -*-
    3. import numpy as np
    4. import time
    5. import datetime
    6. # 获取当前时间
    7. current_time = datetime.datetime.now()
    8. # 格式化输出带有毫秒的当前时间字符串
    9. start_current_time_str = current_time.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
    10. print(start_current_time_str)
    11. my_arr = np.arange(10000000)
    12. print("NumPy生成一千万数据: ", my_arr)
    13. # 获取当前时间
    14. current_time = datetime.datetime.now()
    15. # 格式化输出带有毫秒的当前时间字符串
    16. end_current_time_str = current_time.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
    17. print(end_current_time_str)
    18. start_time = time.time()
    19. my_list = list(range(10000000))
    20. # print("生成一千万个数据: ", my_list)
    21. end_time = time.time()
    22. print("列表生成1千万个数据耗时: %d 秒" % (end_time - start_time))
    23. print()
    24. print("""
    25. NumPy核心特质之一就是N-维数值对象---ndarray;
    26. ndarray是Python中一个快速灵活的大型数据集容器。数值允许你使用类似于标量的操作语法在整块数据上进行数学计算
    27. """)
    28. data = np.random.randn(2, 3)
    29. print("data二维数组: ", data)
    30. dataArray = data * 2
    31. print("dataArray计算结果: ", dataArray)
    32. andData = data + data
    33. print("两个二维data数组相加: ", andData)
    34. print("""
    35. 一个ndarray时一个通用的多维同步数据容器,也就是说,它包含的每一个元素均为
    36. 相同的数据类型。每一个数组都有一个shape属性,用来表征数组每一维度的数量,每一个数组都有一个
    37. dtype属性,用来描述数组的数据类型
    38. """)
    39. print()
    40. print(data.shape)
    41. print(data.dtype)
    42. print(
    43. "生成ndarray对象: 通常使用array函数,函数接收任意的序列型对象,当然也包括其他数组;生成一个新的包含传递数据的NumPy数组")
    44. data1 = [7, 2.5, 4, 44, 5, 0.1, 3354]
    45. arrayData = np.array(data1)
    46. print("arrayData: ", type(arrayData))
    47. print(arrayData.dtype)
    48. data2 = [[1, 2, 3, 4, 5], [7, 8, 9, 10, 11]]
    49. array2 = np.array(data2)
    50. print(array2)
    51. print(array2.ndim)
    52. print(array2.shape)
    53. print(array2.dtype)
    54. print("""
    55. 给定长度和形状后,zeros函数会生成全部包含0的数组
    56. """)
    57. zeroArray = np.zeros(10)
    58. print()
    59. print(zeroArray)
    60. zeroArray1 = np.zeros((3, 6))
    61. print(zeroArray1)
    62. print('--------------------------------------------')
    63. zeroArray2 = np.empty((2, 3, 2))
    64. print(zeroArray2)
    65. rangeArray = np.arange(15)
    66. print(rangeArray)
    67. print(type(rangeArray))
    68. print("""
    69. ndarray的数据类型
    70. """)
    71. array001 = np.array([1, 2, 3], dtype=np.float64)
    72. array002 = np.array([1, 2, 3], dtype=np.int32)
    73. print(array001.dtype)
    74. print(array002.dtype)
    75. print("""
    76. NumPy数组算术运算
    77. """)
    78. arr = np.array([[1., 2., 3.], [4., 5., 6.]])
    79. print(arr)
    80. print()
    81. arr1 = arr * arr
    82. print(arr1)
    83. print()
    84. arr2 = arr - arr
    85. print(arr2)
    86. print()
    87. arr3 = arr + arr
    88. print(arr3)
    89. arr4 = 1 / arr
    90. print()
    91. print(arr4)
    92. print()
    93. arr5 = arr ** 0.5
    94. print(arr5)
    95. print()
    96. arr22 = np.array([[0., 4., 1.], [7., 2., 12.]])
    97. print(arr22)
    98. arr33 = arr22 > arr
    99. print()
    100. print(arr33)

      运行效果: NumPy比list列表块近1000倍


    D:\program_file_worker\anaconda\python.exe D:\program_file_worker\python_source_work\SSO\grammar\dataanalysis\DataAnalysisExecutorNumPy.py 
    2023-10-01 13:18:17.923
    NumPy生成一千万数据:  [      0       1       2 ... 9999997 9999998 9999999]
    2023-10-01 13:18:17.939
    .(939-923)=16 毫秒

    .

    .

    .

    列表生成1千万个数据耗时: 3 秒

    NumPy核心特质之一就是N-维数值对象---ndarray;
        ndarray是Python中一个快速灵活的大型数据集容器。数值允许你使用类似于标量的操作语法在整块数据上进行数学计算

    data二维数组:  [[ 0.60773878 -0.67998347 -1.13246668]
     [-0.50485897 -1.38068128 -0.09343696]]
    dataArray计算结果:  [[ 1.21547755 -1.35996695 -2.26493337]
     [-1.00971795 -2.76136255 -0.18687392]]
    两个二维data数组相加:  [[ 1.21547755 -1.35996695 -2.26493337]
     [-1.00971795 -2.76136255 -0.18687392]]

        一个ndarray时一个通用的多维同步数据容器,也就是说,它包含的每一个元素均为
        相同的数据类型。每一个数组都有一个shape属性,用来表征数组每一维度的数量,每一个数组都有一个
        dtype属性,用来描述数组的数据类型


    (2, 3)
    float64
    生成ndarray对象: 通常使用array函数,函数接收任意的序列型对象,当然也包括其他数组;生成一个新的包含传递数据的NumPy数组
    arrayData:  
    float64
    [[ 1  2  3  4  5]
     [ 7  8  9 10 11]]
    2
    (2, 5)
    int32

       给定长度和形状后,zeros函数会生成全部包含0的数组


    [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
    [[0. 0. 0. 0. 0. 0.]
     [0. 0. 0. 0. 0. 0.]
     [0. 0. 0. 0. 0. 0.]]
    --------------------------------------------
    [[[6.23042070e-307 1.42417221e-306]
      [1.60219306e-306 9.79097008e-307]
      [6.89807188e-307 1.20161730e-306]]

     [[7.56587585e-307 1.37961302e-306]
      [6.23053614e-307 6.23053954e-307]
      [1.37961302e-306 1.42410974e-306]]]
    [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]

        ndarray的数据类型

    float64
    int32

       NumPy数组算术运算

    [[1. 2. 3.]
     [4. 5. 6.]]

    [[ 1.  4.  9.]
     [16. 25. 36.]]

    [[0. 0. 0.]
     [0. 0. 0.]]

    [[ 2.  4.  6.]
     [ 8. 10. 12.]]

    [[1.         0.5        0.33333333]
     [0.25       0.2        0.16666667]]

    [[1.         1.41421356 1.73205081]
     [2.         2.23606798 2.44948974]]

    [[ 0.  4.  1.]
     [ 7.  2. 12.]]

    [[False  True False]
     [ True False  True]]

    Process finished with exit code 0
     

    三: 数据分析高级语法: 数据框(DataFrame)


    DataFrame表示的是矩阵数据表,它包含已经排序的集合;每一列可以是不同的值类型(数值,字符串,布尔值等)DataFrame既有行索引和列索引,它被视为一个共享相同索引的Series的字典,可以看作是序列Series的容器;在DataFrame中,数据被存储为一个以上的二维块,而不是列表,字典或者其他一维数值的集合;
    可以使用分层索引在DataFrame中展示更高维度的数据
    
    

    1. # -*- coding:utf-8 -*-
    2. import pandas as pd
    3. print("""
    4. DataFrame表示的是矩阵数据表,它包含已经排序的集合;
    5. 每一列可以是不同的值类型(数值,字符串,布尔值等)
    6. DataFrame既有行索引和列索引,它被视为一个共享相同索引的Series的字典,可以看作是序列Series的容器;
    7. 在DataFrame中,数据被存储为一个以上的二维块,而不是列表,字典或者其他一维数值的集合;
    8. 可以使用分层索引在DataFrame中展示更高维度的数据
    9. """)
    10. data = {'state': ['python', 'java', 'C', 'C++', 'C#', 'go'],
    11. 'year': [2000, 2001, 2003, 2004, 2005, 2006],
    12. 'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
    13. frame = pd.DataFrame(data)
    14. print("frame: ", frame)
    15. print("默认展示前5行: ", frame.head())
    16. print("当然可以指定展示几行: ", frame.head(2))
    17. print("指定排序顺序,DataFrame的列将会按照指定的顺序排序:")
    18. sortFrame = pd.DataFrame(data, columns=['year', 'state', 'pop'])
    19. print("sortFrame: ", sortFrame)
    20. print("如果指定排序的类不存在,此时的数据结构如下: ")
    21. sortNotNullFrame = pd.DataFrame(data, columns=['year', 'state', 'popt'])
    22. print()
    23. print("指定排序顺序的二维数据结构: ", sortNotNullFrame)
    24. print("""
    25. DataFrame中的一列,可以按照字典标记或属性那样检索为Series序列
    26. """)
    27. frameData = pd.DataFrame(data, columns=['year', 'state', 'pop'])
    28. frameSeries = frameData['state']
    29. print("frameSeries: ", frameSeries)
    30. frameSeries = frameData['year']
    31. print("frameSeries: ", frameSeries)
    32. data = pd.DataFrame(np.random.randn(1000, 4))
    33. print("data: ", data.describe())
    34. print("""
    35. DataFrame数据框是用于存储多行多列的数据集合,是Series;
    36. 类似于Excel二维表格,对应DataFrame的操作无外乎"增,删,改,查"
    37. """)
    38. dataFrameSeries = pd.DataFrame({'age': Series([26, 29, 24]), 'name': Series(['Ken', 'Jerry', 'Ben'])})
    39. print("dataFrameSeries: ", dataFrameSeries)
    40. print()
    41. A = dataFrameSeries['age']
    42. print(A)
    43. print()
    44. print("""
    45. 获取索引号是第一行的值(其实是第二行,从0开始)
    46. """)
    47. B = dataFrameSeries[1:2]
    48. print(B)
    49. print("-------------------------------------------------------")
    50. print("""
    51. 获取第0行到第二行(不包括)与第0列到第2列(不包括2行)的数据块
    52. """)
    53. C = dataFrameSeries.iloc[0:2, 0:2]
    54. print(C)
    55. print()
    56. D = dataFrameSeries.at[0, 'name'] # 获取第0行与name列的交叉值
    57. print(D)
    58. print()
    59. print("""
    60. 访问某一行的时候,不能仅用行的index来访问,如要访问dataFrameSeries的index = 1的行,
    61. 不能写成dataFrameSeries[1],而要写成dataFrameSeries[1:2] ; DataFrame的index可以使任意的,
    62. 不会像Series那样报错,但会显示"Empty DataFrame",并列出Columns:[列名],执行下面的代码看看结果
    63. """)
    64. dataFrameDo = pd.DataFrame(data={'age': [26, 29, 24], 'name': ['KEN', 'John', 'JIMI']},
    65. index=['first', 'second', 'third'])
    66. # 访问行 0-99
    67. varData = dataFrameDo[1:100]
    68. print(varData)
    69. print()
    70. print(varData[2:2]) # 显示空
    71. print()
    72. print(varData[2:1]) # 显示空
    73. print('----------------------------------------------------------------')
    74. print()
    75. print("访问列")
    76. print(varData['age']) # 按照列名访问
    77. print()
    78. print(varData[varData.columns[0:1]]) # 按索引号访问
    79. print()
    80. print("访问数据块")
    81. print(varData.iloc[0:1, 0:1]) # 按行列索引访问
    82. print('---------------------------------------------------------------')
    83. # 访问位置
    84. print(dataFrameSeries.at[1, 'name']) # 这里的1是索引
    85. print(varData.at['second', 'name'])
    86. try:
    87. print(varData.at[1, 'name'])
    88. except KeyError as err:
    89. print("如果这里用索引号就会报错,当有索引名时,不能用索引号,异常信息: ", err)
    90. print()
    91. print("修改列名")
    92. dataFrameSeries.columns = ['name1', 'name2']
    93. print(dataFrameSeries[0:1])
    94. print("修改行的索引")
    95. dataFrameSeries.index = range(1, 4)
    96. print(dataFrameSeries)
    97. print("根据行索引删除")
    98. dataFrameSeries.drop(1, axis=0) # axis =0 是表示行轴,也可以省略
    99. print("根据列名进行删除")
    100. dataFrameSeries.drop('name1', axis=1) # axis =1 是表示列轴,不可以省略
    101. print(dataFrameSeries)
    运行效果:

    D:\program_file_worker\anaconda\python.exe D:\program_file_worker\python_source_work\SSO\grammar\dataanalysis\DataAnalysisExecutorPandas.py 

         DataFrame表示的是矩阵数据表,它包含已经排序的集合;
         每一列可以是不同的值类型(数值,字符串,布尔值等)
         DataFrame既有行索引和列索引,它被视为一个共享相同索引的Series的字典,可以看作是序列Series的容器;
         在DataFrame中,数据被存储为一个以上的二维块,而不是列表,字典或者其他一维数值的集合;
         可以使用分层索引在DataFrame中展示更高维度的数据

    frame:      state  year  pop
    0  python  2000  1.5
    1    java  2001  1.7
    2       C  2003  3.6
    3     C++  2004  2.4
    4      C#  2005  2.9
    5      go  2006  3.2
    默认展示前5行:      state  year  pop
    0  python  2000  1.5
    1    java  2001  1.7
    2       C  2003  3.6
    3     C++  2004  2.4
    4      C#  2005  2.9
    当然可以指定展示几行:      state  year  pop
    0  python  2000  1.5
    1    java  2001  1.7
    指定排序顺序,DataFrame的列将会按照指定的顺序排序:
    sortFrame:     year   state  pop
    0  2000  python  1.5
    1  2001    java  1.7
    2  2003       C  3.6
    3  2004     C++  2.4
    4  2005      C#  2.9
    5  2006      go  3.2
    如果指定排序的类不存在,此时的数据结构如下: 

    指定排序顺序的二维数据结构:     year   state popt
    0  2000  python  NaN
    1  2001    java  NaN
    2  2003       C  NaN
    3  2004     C++  NaN
    4  2005      C#  NaN
    5  2006      go  NaN

     DataFrame中的一列,可以按照字典标记或属性那样检索为Series序列

    frameSeries:  0    python
    1      java
    2         C
    3       C++
    4        C#
    5        go
    Name: state, dtype: object
    frameSeries:  0    2000
    1    2001
    2    2003
    3    2004
    4    2005
    5    2006
    Name: year, dtype: int64
    data:                   0            1            2            3
    count  1000.000000  1000.000000  1000.000000  1000.000000
    mean     -0.078736     0.017925    -0.012978     0.000483
    std       1.029096     0.976971     0.979431     0.980950
    min      -3.586244    -2.816405    -3.242575    -2.875089
    25%      -0.756937    -0.680205    -0.661406    -0.720338
    50%      -0.060153     0.056706     0.005630     0.014671
    75%       0.583656     0.716136     0.618660     0.650299
    max       2.954882     2.742432     3.512564     2.935388


    DataFrame数据框是用于存储多行多列的数据集合,是Series;
       类似于Excel二维表格,对应DataFrame的操作无外乎"增,删,改,查"

    dataFrameSeries:     age   name
    0   26    Ken
    1   29  Jerry
    2   24    Ben

    0    26
    1    29
    2    24
    Name: age, dtype: int64


       获取索引号是第一行的值(其实是第二行,从0开始)

       age   name
    1   29  Jerry
    -------------------------------------------------------

       获取第0行到第二行(不包括)与第0列到第2列(不包括2行)的数据块

       age   name
    0   26    Ken
    1   29  Jerry

    Ken


      访问某一行的时候,不能仅用行的index来访问,如要访问dataFrameSeries的index = 1的行,
      不能写成dataFrameSeries[1],而要写成dataFrameSeries[1:2] ; DataFrame的index可以使任意的,
      不会像Series那样报错,但会显示"Empty DataFrame",并列出Columns:[列名],执行下面的代码看看结果

            age  name
    second   29  John
    third    24  JIMI

    Empty DataFrame
    Columns: [age, name]
    Index: []

    Empty DataFrame
    Columns: [age, name]
    Index: []
    ----------------------------------------------------------------

    访问列
    second    29
    third     24
    Name: age, dtype: int64

            age
    second   29
    third    24

    访问数据块
            age
    second   29
    ---------------------------------------------------------------
    Jerry
    John
    如果这里用索引号就会报错,当有索引名时,不能用索引号,异常信息:  1

    修改列名
       name1 name2
    0     26   Ken
    修改行的索引
       name1  name2
    1     26    Ken
    2     29  Jerry
    3     24    Ben
    根据行索引删除
    根据列名进行删除
       name1  name2
    1     26    Ken
    2     29  Jerry
    3     24    Ben

    Process finished with exit code 0
     

  • 相关阅读:
    常见网络攻击及防御方法总结(XSS、SQL注入、CSRF攻击)
    计算机网络
    文件管理命令
    相控阵天线(四):阵列天线波束赋形(遗传算法、粒子群算法、进化差分算法)
    【Python】自定义pip安装路径
    flask-sqlalchemy库
    Django笔记十四之统计总数、最新纪录和空值判断等功能
    软件外包开发文档
    基于自监督学习的多模态推荐算法
    浅谈一下:Java当中的类和对象
  • 原文地址:https://blog.csdn.net/u014635374/article/details/133445044