Python 数据分析与可视化:开启数据洞察之旅(5/10)

06-01 1792阅读

一、Python 数据分析与可视化简介

Python 数据分析与可视化:开启数据洞察之旅(5/10)

在当今数字化时代,数据就像一座蕴藏无限价值的宝藏,等待着我们去挖掘和探索。而 Python,作为数据科学领域的明星语言,凭借其丰富的库和强大的功能,成为了开启这座宝藏的关键钥匙,在数据分析和可视化领域占据着举足轻重的地位。

(一)Python 在数据分析领域的重要性

Python 之所以备受青睐,主要有以下几个原因:

  • 简单易学:Python 以其简洁、易读的语法闻名,它采用了人类自然语言的思维方式,使得代码就像一段段清晰的指令,降低了编程的门槛。对于初学者而言,无论是刚踏入编程世界的新手,还是其他领域想要转行从事数据分析的人员,都能轻松上手,快速掌握基本的编程技能。例如,使用 Python 进行简单的数学运算,代码直观易懂,就像在纸上书写数学公式一样。
    • 丰富的库和工具:Python 拥有庞大的开源社区,这使得它积累了数量众多、功能各异的库,这些库就像是一个个强大的工具包,涵盖了数据处理、分析、建模、可视化等数据分析的各个环节。无论你是需要进行复杂的数据清洗,还是构建高级的机器学习模型,亦或是创建精美的数据可视化图表,都能在 Python 的库中找到合适的工具。比如,Pandas 库提供了高效的数据处理和分析工具,NumPy 库则为数值计算提供了坚实的基础。
      • 强大的数据处理能力:Python 具备高效的数据处理能力,能够轻松应对大规模数据集。通过合理使用 Pandas、NumPy 等库,我们可以实现数据的快速读取、清洗、转换和分析。这些库在底层进行了高度优化,利用了先进的数据结构和算法,大大提高了数据处理的效率。例如,使用 Pandas 读取和处理包含数百万条记录的 CSV 文件,速度快且占用内存少。
        • 广泛的应用领域:Python 在金融、医疗、电商、科研等众多领域都得到了广泛的应用。在金融领域,它被用于风险评估、投资分析和量化交易;在医疗领域,可用于疾病预测、药物研发和医疗数据分析;在电商领域,能帮助进行用户行为分析、销售预测和精准营销;在科研领域,可助力实验数据处理、模型构建和结果可视化。Python 的通用性使其成为各个领域数据分析师和科学家的首选工具。

          (二)常用的 Python 数据分析与可视化库

          Python 数据分析与可视化:开启数据洞察之旅(5/10)

          在 Python 的数据分析与可视化生态系统中,有许多优秀的库,它们各自发挥着独特的作用,相互配合,为我们提供了强大的数据分析和可视化能力。下面为大家介绍几个常用的库:

          • Pandas:Pandas 是 Python 数据分析的核心库,就像是数据处理的瑞士军刀,提供了快速、灵活、明确的数据结构,旨在简单、直观地处理关系型、标记型数据。它的主要数据结构是 Series(一维带标签数组)和 DataFrame(二维带标签表格),这两种数据结构足以应对金融、统计、社会科学、工程等领域里的大多数典型数据处理任务。Pandas 不仅擅长数据的读取、清洗、转换和合并,还内置了基本的绘图功能,能够快速生成简单的图表,使数据分析流程更加连贯和高效。例如,使用 Pandas 可以轻松地从 CSV 文件中读取数据,对数据进行去重、缺失值处理等操作,还能通过几行代码创建数据透视表,对数据进行多维度分析。
            • NumPy:NumPy 是 Python 的基础科学计算库,为 Python 提供了快速的数组处理能力,是 Python 数据分析的基石。它支持大量的维度数组与矩阵运算,并且内置了许多数学函数库,如三角函数、指数函数、对数函数等,能够高效地进行各种数值计算。NumPy 的数组操作比 Python 原生的列表操作更加高效,因为它在底层使用了 C 语言实现,减少了 Python 的循环开销。例如,在进行大规模矩阵运算时,使用 NumPy 可以显著提高计算速度,节省计算时间。此外,NumPy 还为其他科学计算库(如 SciPy、Pandas 等)提供了基础支持,许多库都依赖于 NumPy 进行数组操作。
              • Matplotlib:Matplotlib 是 Python 中最常用的 2D 绘图库,它就像是一位多才多艺的画师,能够以多种硬拷贝格式和跨平台的交互式环境生成高质量的图形。Matplotlib 提供了广泛的函数和方法,可以轻松绘制各种类型的图表,如折线图、散点图、柱状图、饼图、直方图等,满足不同的数据可视化需求。同时,Matplotlib 还支持对图表的细节进行高度自定义,包括线条颜色、宽度、标记类型、图例、标题、坐标轴标签、刻度等,让我们能够根据具体的需求创建出个性化的图表。例如,通过 Matplotlib 可以精确地控制图表的每一个元素,调整图表的布局和样式,使其更加美观和专业。
                • Seaborn:Seaborn 是基于 Matplotlib 的高级绘图库,它在 Matplotlib 的基础上进行了更高层次的封装,提供了更美观、更现代的默认样式和更高级的绘图函数,使得绘制的图表更具吸引力和表现力。Seaborn 专注于统计数据可视化,提供了许多用于展示数据分布、关系和统计特性的函数,如分布图(distplot)、关系图(relplot)、分类图(catplot)、热力图(heatmap)等。这些函数能够帮助我们更直观地理解数据的内在结构和规律,发现数据中的模式和趋势。例如,使用 Seaborn 的热力图可以清晰地展示数据之间的相关性,通过分布图可以快速了解数据的分布情况。而且,Seaborn 与 Pandas 数据结构无缝集成,使用起来非常方便。
                  • Plotly:Plotly 是一个用于创建交互式可视化的库,它为数据可视化带来了全新的体验。与传统的静态图表不同,Plotly 创建的图表具有交互性,用户可以通过鼠标悬停、缩放、点击等操作来探索数据,获取更多的细节信息。Plotly 支持多种图表类型,包括常见的折线图、柱状图、散点图,以及更高级的 3D 图表、地图、等高线图等,适用于各种数据展示场景。此外,Plotly 还可以将图表导出为 HTML 格式,方便在网页中嵌入和分享。例如,在创建数据仪表盘时,使用 Plotly 可以创建出动态、交互式的可视化界面,让用户能够更加直观地与数据进行交互,深入了解数据背后的信息。

                    这些库各有所长,在实际的数据分析与可视化项目中,我们通常会根据具体的需求和场景选择合适的库进行组合使用。例如,使用 Pandas 和 NumPy 进行数据处理和分析,然后使用 Matplotlib 或 Seaborn 进行静态图表绘制,当需要创建交互式图表时,则可以选择 Plotly。通过合理运用这些库,我们能够更加高效地完成数据分析与可视化任务,从数据中挖掘出有价值的信息,并以直观、清晰的方式展示给他人。

                    Python 数据分析与可视化:开启数据洞察之旅(5/10)

                    二、开发工具介绍

                    在进行 Python 数据分析与可视化的旅程中,选择合适的开发工具至关重要。它们就像是工匠手中的精良工具,能够极大地提升我们的工作效率和开发体验。下面将为大家介绍两款在 Python 数据分析领域广泛使用的开发工具:Jupyter Notebook 和 VSCode。

                    2.1 Jupyter Notebook

                    Jupyter Notebook 是一款广受欢迎的开源交互式计算环境,它以网页的形式呈现,为用户提供了一个集成的工作空间,在这个空间里,用户可以创建和共享包含实时代码、数学方程、可视化内容以及说明文本的文档,这些文档被称为 “笔记本”,文件扩展名为.ipynb 。Jupyter Notebook 就像是一个功能强大的实验室工作台,让我们能够在一个地方完成数据分析的整个流程,从数据探索、清洗、分析到可视化展示,一应俱全。

                    特点和优势
                    • 交互式编程:这是 Jupyter Notebook 最为突出的特点之一。它允许用户逐行或逐块地执行代码,并立即查看结果,就像与代码进行实时对话一样。这种即时反馈的编程方式非常适合数据分析和探索性编程,我们可以快速迭代和调整代码,直至达到期望的结果。例如,在进行数据探索时,我们可以先读取一小部分数据,然后通过执行单行代码对数据进行简单的统计分析,如计算均值、最大值、最小值等,根据结果再决定下一步的操作。
                      • 即时查看结果:在 Jupyter Notebook 中,代码的运行结果会直接显示在代码块下方,无论是数据的统计信息、计算结果还是可视化图表,都能一目了然。这使得我们能够迅速验证代码的正确性,及时发现问题并进行调整。比如,当我们使用 Matplotlib 库绘制折线图时,执行代码后,折线图会立即呈现在代码块的下方,方便我们查看和分析数据的趋势。
                        • 多语言支持:虽然 Jupyter 最初是为 Python 设计的,但它已扩展支持多种编程语言,如 R、Julia 等。通过安装不同的内核(kernel),我们可以在同一个 Notebook 中使用不同的编程语言进行编程,这使得 Jupyter Notebook 成为一个功能强大的平台,可以满足不同编程语言用户的需求。例如,在进行数据分析项目时,我们可能需要使用 Python 进行数据处理,使用 R 进行统计建模,Jupyter Notebook 就能够轻松实现这一需求。
                          • 富文本展示:Jupyter Notebook 支持 Markdown 和 HTML 等富文本格式,我们可以在文档中插入文本、图片、数学公式、链接等,使得文档内容更加丰富和易于理解。此外,Jupyter Notebook 还支持多种输出格式,如图表、视频等,便于我们展示数据分析和模型训练的结果。比如,在撰写数据分析报告时,我们可以使用 Markdown 语法添加标题、段落、列表等,使报告结构清晰;同时,还可以插入数据可视化图表,增强报告的可视化效果。
                            • 易于分享:Jupyter Notebook 文档(.ipynb 文件)可以轻松地通过电子邮件、GitHub 等平台与他人分享。这些文件包含了数据处理、模型训练、结果分析的所有步骤,便于他人复现和验证工作。此外,Jupyter Notebook 还支持将文档导出为多种格式,如 HTML、PDF、Markdown 等,以适应不同的展示和分享需求。例如,我们可以将完成的数据分析项目以.ipynb 文件的形式分享给团队成员,他们可以直接打开文件并运行其中的代码,查看分析过程和结果;如果需要在会议上展示,我们可以将 Notebook 导出为 PDF 格式,方便演示。
                              • 模块化:代码可以分割成多个可执行的单元格,使得大型分析项目更易于管理和组织。我们可以将不同功能的代码放在不同的单元格中,每个单元格可以独立运行,也可以按照顺序依次运行。这样,我们可以更加清晰地组织代码结构,便于调试和维护。比如,在进行一个复杂的机器学习项目时,我们可以将数据读取、数据预处理、模型训练、模型评估等步骤分别放在不同的单元格中,每个单元格专注于一个特定的功能,使代码的逻辑更加清晰。
                                安装和基本使用方法
                                • 安装:安装 Jupyter Notebook 通常有两种方式,分别是使用 Anaconda 和 pip 命令。
                                    • 使用 Anaconda 安装:Anaconda 是一个流行的 Python 发行版,它包含了许多常用的数据科学库和工具,并且已经自动为我们安装了 Jupyter Notebook 及其他相关工具。我们可以从 Anaconda 官方网站(https://www.anaconda.com/products/individual)下载适合自己操作系统的安装包,然后按照安装向导的提示进行安装。安装完成后,我们可以在开始菜单(Windows 系统)或应用程序文件夹(Mac 系统)中找到 Anaconda Navigator,打开它,在其中可以直接启动 Jupyter Notebook。
                                        • 使用 pip 命令安装:如果我们已经安装了 Python,也可以使用 pip 命令来安装 Jupyter Notebook。首先,打开命令行终端(Windows 系统可以通过 “开始菜单” -> “运行”,输入 “cmd” 打开;Mac 系统可以通过 “应用程序” -> “实用工具” -> “终端” 打开),然后输入以下命令将 pip 升级到最新版本:
                                          pip install --upgrade pip

                                          升级完成后,再输入以下命令安装 Jupyter Notebook:

                                          pip install jupyter
                                          • 基本使用方法:
                                              • 启动 Jupyter Notebook:安装完成后,在命令行终端中输入以下命令启动 Jupyter Notebook:
                                                jupyter notebook

                                                执行该命令后,系统会自动打开默认的浏览器,并在浏览器中显示 Jupyter Notebook 的主界面。如果浏览器没有自动打开,我们可以复制命令行中显示的 URL 地址(通常是http://localhost:8888/ ),然后手动粘贴到浏览器的地址栏中打开。

                                                • 创建新的 Notebook:在 Jupyter Notebook 的主界面中,点击右上角的 “New” 按钮,在弹出的菜单中选择 “Python 3”(如果我们安装了其他内核,还可以选择其他编程语言),即可创建一个新的 Notebook。新创建的 Notebook 会自动打开,我们可以在其中进行代码编写和运行。
                                                  • 编写和运行代码:在 Notebook 中,我们可以看到一个一个的单元格,每个单元格可以输入代码或文本。默认情况下,单元格是代码类型,我们可以在其中输入 Python 代码。例如,输入以下代码:
                                                    print("Hello, World!")

                                                    然后按下 “Shift + Enter” 组合键,即可运行该单元格中的代码,运行结果会显示在单元格下方。“Shift + Enter” 组合键的作用是运行当前单元格,并自动跳转到下一个单元格;如果我们只想运行当前单元格,不跳转到下一个单元格,可以使用 “Ctrl + Enter” 组合键;如果我们想在当前单元格下方插入一个新的单元格并运行当前单元格,可以使用 “Alt + Enter” 组合键。

                                                    • 添加和删除单元格:如果我们需要添加新的单元格,可以点击菜单栏中的 “Insert” -> “Insert Cell Above”(在当前单元格上方插入)或 “Insert Cell Below”(在当前单元格下方插入);如果要删除某个单元格,可以先选中该单元格,然后点击菜单栏中的 “Edit” -> “Delete Cells”,或者使用快捷键 “D, D”(连续按两次 D 键)。
                                                      • 修改单元格类型:单元格的类型可以在代码、Markdown 和 Raw NBConvert 之间切换。如果我们想在单元格中输入文本说明,可以将单元格类型切换为 Markdown。选中单元格后,点击菜单栏中的 “Cell” -> “Cell Type”,在弹出的子菜单中选择 “Markdown” 即可。在 Markdown 类型的单元格中,我们可以使用 Markdown 语法编写文本,例如添加标题、段落、列表、链接、图片等。编写完成后,按下 “Shift + Enter” 组合键,即可将 Markdown 文本渲染成富文本格式显示。
                                                        • 保存和关闭 Notebook:在编写代码的过程中,我们需要及时保存 Notebook,以免数据丢失。可以点击菜单栏中的 “File” -> “Save and Checkpoint”,或者使用快捷键 “Ctrl + S”(Windows 和 Linux 系统)或 “Command + S”(Mac 系统)进行保存。当我们完成工作后,可以点击菜单栏中的 “File” -> “Close and Halt”,关闭当前 Notebook 并停止内核运行;如果我们只是暂时离开,可以点击浏览器的关闭按钮,下次打开时,Notebook 会恢复到上次保存的状态。

                                                          2.2 VSCode

                                                          VSCode(Visual Studio Code)是一款由微软开发的轻量级、跨平台的代码编辑器,虽然它本身并不直接支持 Python 数据分析和可视化,但通过安装丰富的插件,它可以成为一个功能强大的 Python 开发环境,在 Python 数据分析领域也得到了广泛的应用。VSCode 就像是一个高度可定制的工作间,我们可以根据自己的需求安装各种插件,打造出适合自己的开发工具。

                                                          作为 Python 开发编辑器的优势
                                                          • 丰富的插件生态:这是 VSCode 最为显著的优势之一。VSCode 拥有一个庞大的插件市场,其中包含了大量与 Python 开发相关的插件,这些插件可以满足我们在 Python 数据分析和可视化过程中的各种需求。例如,通过安装 “Python” 插件,我们可以获得 Python 语法高亮、智能提示、代码自动补全、代码调试等基本功能;安装 “Jupyter” 插件,我们可以在 VSCode 中直接打开和编辑 Jupyter Notebook 文件,实现与 Jupyter Notebook 类似的交互式编程体验;安装 “Pylance” 插件,可以提供更强大的代码分析和智能感知功能,帮助我们更快地编写高质量的 Python 代码。此外,还有许多其他插件,如代码格式化插件(如 “black”、“autopep8”)、版本控制插件(如 “GitLens”)、数据库管理插件(如 “SQLite”)等,可以进一步增强 VSCode 的功能。
                                                            • 轻量级和快速:相比于一些大型的集成开发环境(IDE),VSCode 是一款轻量级的编辑器,它启动速度快,占用系统资源少,这使得我们在编写 Python 代码时能够获得更加流畅的体验。尤其是在处理大型项目或同时打开多个文件时,VSCode 的性能优势更加明显,不会因为资源占用过多而导致系统卡顿。
                                                              • 良好的调试支持:VSCode 提供了强大的内置调试工具,支持设置断点、单步执行、变量观察等多种调试功能。在进行 Python 数据分析和可视化开发时,我们经常需要调试代码来查找错误和优化性能。通过 VSCode 的调试功能,我们可以方便地在代码中设置断点,当程序执行到断点处时会暂停,我们可以查看变量的值、跟踪程序的执行流程,从而快速定位和解决问题。例如,在调试一个数据处理脚本时,我们可以在关键代码行设置断点,观察数据在不同处理步骤后的变化情况,找出可能存在的问题。
                                                                • 便捷的 Git 集成:VSCode 内置了对 Git 版本控制系统的支持,这使得我们在开发过程中能够方便地进行代码版本管理和团队协作。我们可以直接在 VSCode 中进行 Git 操作,如提交代码、拉取代码、创建分支、合并分支等,无需频繁切换到命令行终端。同时,VSCode 还提供了直观的界面来显示代码的修改情况和版本历史,方便我们查看和管理代码的变更。例如,在一个多人协作的数据分析项目中,我们可以使用 VSCode 的 Git 集成功能,及时将自己的代码提交到远程仓库,并与团队成员的代码进行合并,确保项目的顺利进行。
                                                                  • 跨平台支持:VSCode 支持 Windows、macOS 和 Linux 等多种操作系统,无论我们使用哪种操作系统,都可以享受到 VSCode 带来的便利。这使得我们在不同的开发环境中都能够保持一致的开发体验,无需为适应不同的编辑器而花费额外的时间和精力。例如,我们可以在 Windows 系统上进行日常的开发工作,在 Mac 系统上进行项目展示和汇报,在 Linux 服务器上进行代码部署,而始终使用 VSCode 作为主要的开发工具。
                                                                    配置 VSCode 以进行 Python 数据分析开发

                                                                    要在 VSCode 中进行 Python 数据分析开发,我们需要进行以下配置:

                                                                    • 安装 VSCode:首先,从 VSCode 官方网站(Visual Studio Code - Code Editing. Redefined)下载适合自己操作系统的安装包,然后按照安装向导的提示进行安装。安装完成后,打开 VSCode。
                                                                      • 安装 Python 插件:打开 VSCode 后,点击左侧边栏的 “扩展” 图标(看起来像四个方块组成的正方形),在搜索框中输入 “Python”,然后在搜索结果中找到由 Microsoft 提供的 “Python” 插件,点击 “安装” 按钮进行安装。安装完成后,VSCode 将具备 Python 开发的基本支持,如语法高亮、智能提示等。
                                                                        • 配置 Python 解释器:安装完 Python 插件后,我们需要告诉 VSCode 使用哪个 Python 解释器来运行我们的代码。打开一个新的或现有的 Python 文件,然后点击 VSCode 窗口底部状态栏中的 Python 版本信息(例如 “Python 3.9.10 64-bit (venv)”),在弹出的列表中选择我们想要使用的 Python 解释器。如果列表中没有我们需要的解释器,可以点击 “Enter interpreter path...” 手动指定解释器的路径。例如,如果我们使用 Anaconda 管理 Python 环境,那么可以在 Anaconda 安装目录下的 “envs” 文件夹中找到对应的环境目录,在该目录下的 “Scripts” 文件夹(Windows 系统)或 “bin” 文件夹(Mac 和 Linux 系统)中找到 “python.exe”(Windows 系统)或 “python3”(Mac 和 Linux 系统)作为解释器路径。
                                                                          • 安装其他插件:根据我们的具体需求,还可以安装其他与 Python 数据分析和可视化相关的插件。例如,安装 “Jupyter” 插件,以便在 VSCode 中使用 Jupyter Notebook;安装 “Pylance” 插件,提升代码智能感知能力;安装 “Matplotlib Interactive” 插件,实现 Matplotlib 图表的交互式显示等。安装插件的方法与安装 Python 插件类似,在扩展搜索框中输入插件名称,然后点击 “安装” 按钮即可。
                                                                            • 创建 Python 项目:在 VSCode 中,我们可以通过创建项目文件夹来组织我们的 Python 代码。点击菜单栏中的 “文件” -> “新建文件夹”,选择一个目录来存放我们的 Python 项目。然后在该目录中,右键点击空白处,选择 “新建文件”,将文件保存为以.py 为扩展名的 Python 源文件。例如,我们可以创建一个名为 “data_analysis” 的项目文件夹,在其中创建一个名为 “main.py” 的 Python 文件,用于编写我们的数据分析代码。
                                                                              • 运行和调试 Python 代码:在编写完 Python 代码后,我们可以通过以下几种方式运行和调试代码:
                                                                                  • 运行代码:右键点击编辑器中的代码,选择 “在终端中运行 Python 文件”,VSCode 会在终端中执行我们的 Python 代码,并显示运行结果。也可以使用快捷键 “Ctrl + F5”(Windows 和 Linux 系统)或 “Command + F5”(Mac 系统)来运行代码。
                                                                                      • 调试代码:在我们想要设置断点的行号旁边点击,出现一个红点表示断点设置成功。然后点击侧边栏的 “调试” 图标(看起来像一个虫子),在弹出的调试配置列表中选择 “Python 文件”(如果没有该选项,可以点击 “创建配置” 按钮,选择 “Python 文件” 创建一个调试配置)。最后点击调试工具栏中的 “启动调试” 按钮(绿色三角形图标),或者使用快捷键 “F5” 来启动调试会话。在调试过程中,我们可以通过调试面板管理断点、查看变量值、单步执行代码等。例如,在调试一个数据处理函数时,我们可以在函数内部设置断点,然后通过单步执行观察函数的执行过程和变量的变化情况,找出可能存在的问题。

                                                                                        通过以上步骤,我们就可以将 VSCode 配置为一个功能强大的 Python 数据分析开发环境,利用其丰富的插件生态和强大的功能,高效地进行 Python 数据分析和可视化工作。

                                                                                        Python 数据分析与可视化:开启数据洞察之旅(5/10)

                                                                                        三、核心库基础

                                                                                        在 Python 数据分析与可视化的领域中,Pandas、NumPy、Matplotlib 和 Seaborn 这几个核心库犹如璀璨的明星,各自发挥着独特而关键的作用,是我们进行数据分析和可视化的得力工具。接下来,让我们深入探索这些库的基础用法,领略它们的强大魅力。

                                                                                        3.1 Pandas

                                                                                        Pandas 是 Python 数据分析的核心支撑,它为我们提供了快速、灵活、明确的数据结构,使我们能够高效地处理和分析各种类型的数据。无论是简单的表格数据,还是复杂的时间序列数据,Pandas 都能轻松应对。

                                                                                        3.1.1 Series 数据结构

                                                                                        Series 是 Pandas 中用于表示一维带标签数组的数据结构,它由一组数据和与之对应的索引组成。可以将其看作是一个列数据,索引则是每一行数据的标识,就像给每个数据点都贴上了独特的标签,方便我们进行数据的定位和操作。

                                                                                        创建 Series 对象非常简单,我们可以通过多种方式来实现。最常见的方式是从 Python 列表或 NumPy 数组创建:

                                                                                        import pandas as pd
                                                                                        import numpy as np
                                                                                        # 从列表创建Series
                                                                                        data = [10, 20, 30, 40, 50]
                                                                                        s1 = pd.Series(data)
                                                                                        print(s1)

                                                                                        上述代码中,我们首先导入了 Pandas 库并别名为 pd,然后定义了一个 Python 列表 data,接着使用 pd.Series () 函数将列表转换为 Series 对象 s1。运行代码后,我们可以看到输出的 Series 对象,它不仅包含了数据,还自动生成了从 0 开始的整数索引。

                                                                                        我们还可以从字典创建 Series,此时字典的键将作为索引,值作为数据:

                                                                                        # 从字典创建Series
                                                                                        data_dict = {'a': 100, 'b': 200, 'c': 300, 'd': 400}
                                                                                        s2 = pd.Series(data_dict)
                                                                                        print(s2)

                                                                                        在这段代码中,我们定义了一个字典 data_dict,然后将其传递给 pd.Series () 函数创建了 Series 对象 s2。输出结果中,索引为字典的键 'a'、'b'、'c'、'd',对应的数据分别为 100、200、300、400。

                                                                                        访问 Series 中的数据也很直观,我们可以通过索引来获取单个数据或多个数据:

                                                                                        # 访问单个数据
                                                                                        print(s2['b'])  
                                                                                        # 访问多个数据
                                                                                        print(s2[['a', 'c']])  

                                                                                        在第一行代码中,我们通过索引 'b' 获取了 s2 中对应的数据 200;第二行代码中,我们通过传递一个包含索引 'a' 和 'c' 的列表,获取了这两个索引对应的数据,输出结果是一个包含这两个数据的新 Series 对象。

                                                                                        此外,Series 还支持许多强大的操作方法,比如数学运算、数据过滤、缺失值处理等。例如,我们可以对 Series 进行简单的数学运算:

                                                                                        # Series数学运算
                                                                                        s3 = s2 * 2
                                                                                        print(s3)

                                                                                        这段代码将 s2 中的每个数据都乘以 2,生成了一个新的 Series 对象 s3,展示了 Series 在数学运算方面的便捷性。

                                                                                        3.1.2 DataFrame 数据结构

                                                                                        DataFrame 是 Pandas 中的二维表格型数据结构,它由多个 Series 组成,可以看作是一个由列组成的表格,每一列都是一个 Series,且所有列共享同一索引。DataFrame 的出现,使得我们能够更加方便地处理和分析结构化数据,是 Pandas 库中最为常用的数据结构之一。

                                                                                        创建 DataFrame 的方式同样丰富多样。我们可以从字典创建,字典的键将成为 DataFrame 的列名,值为对应列的数据:

                                                                                        # 从字典创建DataFrame
                                                                                        data = {
                                                                                            '姓名': ['张三', '李四', '王五', '赵六'],
                                                                                            '年龄': [25, 30, 35, 40],
                                                                                            '城市': ['北京', '上海', '广州', '深圳']
                                                                                        }
                                                                                        df = pd.DataFrame(data)
                                                                                        print(df)

                                                                                        在上述代码中,我们定义了一个包含 ' 姓名 '、' 年龄 '、' 城市 ' 三个键的字典 data,然后使用 pd.DataFrame () 函数将其转换为 DataFrame 对象 df。运行代码后,我们可以看到一个规整的表格,列名分别为字典的键,每列的数据对应字典中键的值。

                                                                                        也可以从二维列表创建 DataFrame,并通过 columns 参数指定列名:

                                                                                        # 从二维列表创建DataFrame
                                                                                        data_list = [
                                                                                            ['张三', 25, '北京'],
                                                                                            ['李四', 30, '上海'],
                                                                                            ['王五', 35, '广州'],
                                                                                            ['赵六', 40, '深圳']
                                                                                        ]
                                                                                        df2 = pd.DataFrame(data_list, columns=['姓名', '年龄', '城市'])
                                                                                        print(df2)

                                                                                        这里,我们定义了一个二维列表 data_list,然后使用 pd.DataFrame () 函数创建 DataFrame 对象 df2,并通过 columns 参数明确指定了列名。

                                                                                        对 DataFrame 进行索引、切片和筛选操作是数据分析中常见的任务。通过索引,我们可以获取指定行或列的数据:

                                                                                        # 获取列数据
                                                                                        age_column = df['年龄']
                                                                                        print(age_column)
                                                                                        # 获取行数据
                                                                                        row_data = df.loc[2]  
                                                                                        print(row_data)

                                                                                        在第一行代码中,我们通过列名 ' 年龄 ' 获取了 df 中的 ' 年龄 ' 列数据,返回的是一个 Series 对象;第二行代码中,我们使用 loc 索引器通过行索引 2 获取了第三行的数据,同样返回的是一个 Series 对象,其索引为列名,值为对应列的数据。

                                                                                        切片操作可以帮助我们获取指定范围的数据:

                                                                                        # 切片操作
                                                                                        subset_df = df.loc[1:3, ['姓名', '城市']]
                                                                                        print(subset_df)

                                                                                        这段代码中,我们使用 loc 索引器进行切片操作,获取了 df 中索引为 1、2、3 的行,以及 ' 姓名 ' 和' 城市 ' 两列的数据,返回的是一个新的 DataFrame 对象。

                                                                                        根据条件筛选数据也是 DataFrame 的重要功能之一,例如筛选出年龄大于 30 岁的行:

                                                                                        # 条件筛选
                                                                                        filtered_df = df[df['年龄'] > 30]
                                                                                        print(filtered_df)

                                                                                        在这段代码中,我们通过布尔索引 df [' 年龄 '] > 30 筛选出了 df 中年龄大于 30 岁的行,返回的是一个新的 DataFrame 对象,只包含满足条件的行数据。

                                                                                        3.1.3 数据读取与写入

                                                                                        在实际数据分析中,我们通常需要从外部文件读取数据,进行处理后再将结果保存到文件中。Pandas 提供了丰富的函数来读取和写入各种常见格式的数据文件,使得数据的输入输出操作变得简单高效。

                                                                                        读取 CSV 文件是数据分析中极为常见的操作,Pandas 的 read_csv () 函数可以轻松完成这一任务:

                                                                                        # 读取CSV文件
                                                                                        data = pd.read_csv('data.csv')
                                                                                        print(data.head())  

                                                                                        上述代码中,我们使用 pd.read_csv () 函数读取了名为 'data.csv' 的 CSV 文件,并将其存储为一个 DataFrame 对象 data。通过调用 head () 方法,我们可以查看 DataFrame 的前 5 行数据,以快速了解数据的结构和内容。

                                                                                        读取 Excel 文件也同样便捷,借助 read_excel () 函数即可实现:

                                                                                        # 读取Excel文件
                                                                                        data_excel = pd.read_excel('data.xlsx')
                                                                                        print(data_excel.head())

                                                                                        这里,我们使用 pd.read_excel () 函数读取了名为 'data.xlsx' 的 Excel 文件,并将其转换为 DataFrame 对象 data_excel,同样通过 head () 方法查看前 5 行数据。

                                                                                        当我们完成数据处理后,需要将结果保存到文件中。Pandas 提供了 to_csv () 和 to_excel () 函数来实现数据的保存:

                                                                                        # 将DataFrame保存为CSV文件
                                                                                        data.to_csv('new_data.csv', index=False)  
                                                                                        # 将DataFrame保存为Excel文件
                                                                                        data_excel.to_excel('new_data.xlsx', index=False)  

                                                                                        在第一行代码中,我们使用 to_csv () 函数将 data 保存为名为 'new_data.csv' 的 CSV 文件,并通过 index=False 参数指定不保存行索引;第二行代码中,使用 to_excel () 函数将 data_excel 保存为名为 'new_data.xlsx' 的 Excel 文件,同样不保存行索引。这样,我们就可以方便地将处理后的数据保存下来,以便后续使用或分享。通过这些数据读取与写入的操作,Pandas 为我们搭建了一座连接外部数据和数据分析流程的桥梁,使得数据的获取和保存变得轻松自如。

                                                                                        3.2 NumPy

                                                                                        NumPy 是 Python 科学计算的基础库,它提供了高效的多维数组对象以及丰富的数组操作函数,为 Python 在数据分析、机器学习、科学计算等领域的广泛应用奠定了坚实的基础。NumPy 的数组操作速度极快,这得益于其底层使用 C 语言实现,大大减少了 Python 循环带来的开销,使得我们能够快速处理大规模的数值数据。

                                                                                        3.2.1 数组创建

                                                                                        在 NumPy 中,创建数组是进行后续操作的基础。我们可以通过多种方式创建数组,以满足不同的需求。最直接的方式是从 Python 列表或元组转换:

                                                                                        import numpy as np
                                                                                        # 从列表创建一维数组
                                                                                        arr1 = np.array([1, 2, 3, 4, 5])
                                                                                        print(arr1)
                                                                                        # 从嵌套列表创建二维数组
                                                                                        arr2 = np.array([[1, 2, 3], [4, 5, 6]])
                                                                                        print(arr2)

                                                                                        在上述代码中,我们首先导入了 NumPy 库并别名为 np。然后,使用 np.array () 函数从 Python 列表创建了一维数组 arr1,从嵌套列表创建了二维数组 arr2。运行代码后,可以看到输出的数组,它们的数据类型会根据输入数据自动推断。

                                                                                        除了从已有数据结构创建数组,NumPy 还提供了许多函数来创建具有特定特征的数组。例如,使用 arange () 函数创建等差数列数组:

                                                                                        # 使用arange创建等差数列数组
                                                                                        arr3 = np.arange(0, 10, 2)
                                                                                        print(arr3)

                                                                                        这段代码中,np.arange (0, 10, 2) 表示创建一个从 0 开始,到 10 结束(不包含 10),步长为 2 的等差数列数组,运行结果为 [0 2 4 6 8]。

                                                                                        使用 zeros () 和 ones () 函数可以创建全零或全一的数组:

                                                                                        # 创建全零数组
                                                                                        arr4 = np.zeros((3, 4))
                                                                                        print(arr4)
                                                                                        # 创建全一数组
                                                                                        arr5 = np.ones((2, 3))
                                                                                        print(arr5)

                                                                                        在第一行代码中,np.zeros ((3, 4)) 创建了一个形状为 (3, 4) 的全零数组,即 3 行 4 列,每个元素都是 0;第二行代码中,np.ones ((2, 3)) 创建了一个 2 行 3 列的全一数组。

                                                                                        另外,使用 random 模块可以创建随机数数组,为数据分析和模拟实验提供了便利:

                                                                                        # 创建随机数数组
                                                                                        arr6 = np.random.rand(2, 3)
                                                                                        print(arr6)

                                                                                        这里,np.random.rand (2, 3) 创建了一个 2 行 3 列的数组,数组中的元素是在 0 到 1 之间均匀分布的随机数。

                                                                                        3.2.2 数组操作

                                                                                        NumPy 数组支持丰富多样的操作,这些操作是进行数据分析和科学计算的核心。基本运算如加法、减法、乘法、除法等可以直接对数组进行,而且是元素级别的运算:

                                                                                        # 数组基本运算
                                                                                        a = np.array([1, 2, 3])
                                                                                        b = np.array([4, 5, 6])
                                                                                        c = a + b
                                                                                        print(c)

                                                                                        上述代码中,我们定义了两个一维数组 a 和 b,然后进行加法运算 a + b,得到的结果 c 是一个新的数组,其每个元素是 a 和 b 对应元素之和。

                                                                                        索引和切片操作与 Python 列表类似,但在多维数组中更加灵活:

                                                                                        # 数组索引和切片
                                                                                        arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
                                                                                        print(arr[1, 2])  
                                                                                        print(arr[0:2, 1:3])  

                                                                                        在第一行代码中,arr [1, 2] 表示获取二维数组 arr 中第二行(索引从 0 开始)第三列的元素,结果为 6;第二行代码中,arr [0:2, 1:3] 表示获取 arr 中前两行(索引 0 和 1),第二列和第三列(索引 1 和 2)的子数组,返回的是一个形状为 (2, 2) 的二维数组。

                                                                                        广播机制是 NumPy 的一大特色,它允许不同形状的数组进行运算,在满足一定条件下,较小的数组会自动扩展以匹配较大数组的形状:

                                                                                        # 广播机制
                                                                                        a = np.array([[1, 2, 3], [4, 5, 6]])
                                                                                        b = np.array([10, 20, 30])
                                                                                        c = a + b
                                                                                        print(c)

                                                                                        这里,数组 b 的形状为 (3,),数组 a 的形状为 (2, 3),在进行加法运算 a + b 时,由于 b 的形状可以通过广播扩展为 (2, 3),因此可以顺利进行运算,结果 c 是一个形状为 (2, 3) 的数组,其元素是 a 和 b 对应元素之和。广播机制极大地简化了数组运算,提高了代码的简洁性和效率,是 NumPy 强大功能的重要体现。

                                                                                        3.3 Matplotlib

                                                                                        Matplotlib 是 Python 最常用的绘图库之一,它提供了一套简洁、直观的 API,使得我们能够轻松创建各种类型的高质量图表,将数据以可视化的形式呈现出来,帮助我们更好地理解数据背后的信息和趋势。无论是简单的折线图、散点图,还是复杂的多子图组合,Matplotlib 都能胜任。

                                                                                        Python 数据分析与可视化:开启数据洞察之旅(5/10)

                                                                                        ​​​​​​​

                                                                                        3.3.1 基本绘图

                                                                                        Matplotlib 的基本绘图函数非常简单易用,通过几行代码就能创建出常见的图表类型。以绘制折线图为例:

                                                                                        import matplotlib.pyplot as plt
                                                                                        import numpy as np
                                                                                        # 生成数据
                                                                                        x = np.arange(0, 10, 0.1)
                                                                                        y = np.sin(x)
                                                                                        # 绘制折线图
                                                                                        plt.plot(x, y)
                                                                                        plt.show()

                                                                                        在上述代码中,我们首先导入了 Matplotlib 的 pyplot 模块并别名为 plt,以及 NumPy 库。然后,使用 np.arange () 函数生成了一组 x 数据,范围是从 0 到 10(不包含 10),步长为 0.1,接着计算出对应的 y 数据(这里是正弦值)。最后,使用 plt.plot () 函数绘制折线图,将 x 和 y 数据作为参数传入,再调用 plt.show () 函数显示图表。运行代码后,我们可以看到一个展示正弦函数曲线的折线图。

                                                                                        绘制散点图同样简单,使用 scatter () 函数即可:

                                                                                        # 生成数据
                                                                                        x = np.random.rand(50)
                                                                                        y = np.random.rand(50)
                                                                                        # 绘制散点图
                                                                                        plt.scatter(x, y)
                                                                                        plt.show()

                                                                                        这段代码中,我们使用 np.random.rand () 函数生成了两组随机数作为 x 和 y 数据,然后使用 plt.scatter () 函数绘制散点图,展示了这些随机点的分布情况。

                                                                                        柱状图可以使用 bar () 函数绘制,用于比较不同类别或组的数据:

                                                                                        # 数据
                                                                                        categories = ['A', 'B', 'C', 'D']
                                                                                        values = [25, 40, 15, 30]
                                                                                        # 绘制柱状图
                                                                                        plt.bar(categories, values)
                                                                                        plt.show()

                                                                                        在这段代码中,我们定义了类别列表 categories 和对应的值列表 values,然后使用 plt.bar () 函数绘制柱状图,每个类别对应一个柱子,柱子的高度表示对应的值。运行代码后,我们可以直观地比较不同类别数据的大小。

                                                                                        Matplotlib 还支持对图表的外观进行设置,如颜色、标记、线型等,使图表更加美观和富有表现力:

                                                                                        # 生成数据
                                                                                        x = np.arange(0, 10, 0.1)
                                                                                        y1 = np.sin(x)
                                                                                        y2 = np.cos(x)
                                                                                        # 绘制折线图并设置颜色、标记和线型
                                                                                        plt.plot(x, y1, color='red', marker='o', linestyle='--', label='Sin')
                                                                                        plt.plot(x, y2, color='blue', marker='s', linestyle='-.', label='Cos')
                                                                                        plt.legend()
                                                                                        plt.show()

                                                                                        在这段代码中,我们分别绘制了正弦函数 y1 和余弦函数 y2 的折线图,并通过参数设置了颜色(color)、标记(marker)和线型(linestyle)。同时,使用 label 参数为每条曲线添加了标签,最后调用 plt.legend () 函数显示图例,以便区分不同的曲线。这样,我们就创建了一个更加丰富和易读的图表。

                                                                                        Python 数据分析与可视化:开启数据洞察之旅(5/10)

                                                                                        3.3.2 图表定制

                                                                                        为了使图表更加清晰和易于理解,我们可以对图表进行各种定制,包括添加标题、轴标签、刻度、图例等。添加标题可以使用 title () 函数,轴标签可以通过 xlabel () 和 ylabel () 函数添加:

                                                                                        # 生成数据
                                                                                        x = np.arange(0, 10, 0.1)
                                                                                        y = np.sin(x)
                                                                                        # 绘制折线图
                                                                                        plt.plot(x, y)
                                                                                        # 添加标题和轴标签
                                                                                        plt.title('Sine Function')
                                                                                        plt.xlabel('X')
                                                                                        plt.ylabel('Sin(X)')
                                                                                        plt.show()

                                                                                        Python 数据分析与可视化:开启数据洞察之旅(5/10)

                                                                                        四、数据获取

                                                                                        在 Python 数据分析与可视化的旅程中,数据获取是第一步,也是至关重要的一步。就像厨师需要新鲜的食材才能烹饪出美味佳肴一样,我们需要获取高质量的数据,才能进行有效的分析和可视化展示。数据的来源多种多样,下面将介绍从文件、数据库和网络中获取数据的常见方法。

                                                                                        4.1 从文件读取数据

                                                                                        在数据分析中,我们经常会遇到各种格式的文件,如 CSV、Excel、JSON 等,Pandas 库为我们提供了便捷的函数来读取这些文件中的数据。

                                                                                        CSV 文件:CSV(Comma-Separated Values)是一种常见的文本文件格式,以逗号分隔字段,常用于存储表格数据。使用 Pandas 的 read_csv () 函数可以轻松读取 CSV 文件,将其转换为 DataFrame 对象,方便后续处理。

                                                                                        import pandas as pd
                                                                                        # 读取CSV文件
                                                                                        data_csv = pd.read_csv('data.csv')
                                                                                        print(data_csv.head())  # 查看前5行数据

                                                                                        上述代码中,我们使用 pd.read_csv () 函数读取了名为 'data.csv' 的文件,并将其存储为 DataFrame 对象 data_csv。通过调用 head () 方法,我们可以快速查看数据的前 5 行,了解数据的结构和内容。read_csv () 函数还有许多参数可以设置,以满足不同的读取需求。例如,sep 参数可以指定字段分隔符,header 参数可以指定作为列名的行,index_col 参数可以指定作为行索引的列等。如果 CSV 文件使用分号作为分隔符,我们可以这样设置参数:

                                                                                        data_csv = pd.read_csv('data.csv', sep=';')

                                                                                        Excel 文件:Excel 文件是另一种常见的数据存储格式,它具有丰富的格式设置和数据处理功能。Pandas 的 read_excel () 函数可以读取 Excel 文件中的数据。在使用该函数之前,需要确保安装了 openpyxl 或 xlrd 库,分别用于处理.xlsx 和.xls 格式的文件。

                                                                                        # 读取Excel文件(.xlsx格式)
                                                                                        data_excel = pd.read_excel('data.xlsx', engine='openpyxl')
                                                                                        print(data_excel.head())
                                                                                        # 读取特定工作表(假设工作表名为'Sheet2')
                                                                                        data_sheet2 = pd.read_excel('data.xlsx', sheet_name='Sheet2', engine='openpyxl')
                                                                                        print(data_sheet2.head())

                                                                                        在上述代码中,我们首先使用 read_excel () 函数读取了名为 'data.xlsx' 的文件,并通过 engine='openpyxl' 指定使用 openpyxl 库来处理。然后,通过 sheet_name 参数指定读取名为 'Sheet2' 的工作表。如果想查看所有工作表的名字,可以使用以下代码:

                                                                                        with pd.ExcelFile('data.xlsx') as xls:
                                                                                            print(xls.sheet_names)

                                                                                        JSON 文件:JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,常用于在不同的应用程序之间传输数据。Pandas 的 read_json () 函数可以将 JSON 数据读取为 DataFrame 对象。

                                                                                        # 读取JSON文件
                                                                                        data_json = pd.read_json('data.json')
                                                                                        print(data_json.head())

                                                                                        上述代码中,我们使用 read_json () 函数读取了名为 'data.json' 的文件,并将其转换为 DataFrame 对象 data_json。read_json () 函数支持从 JSON 文件、JSON 字符串或 JSON 网址中加载数据,并且可以通过 orient 参数指定 JSON 数据的结构方式,常见的值有'split'、'records'、'index'、'columns'、'values' 等。例如,从 JSON 字符串加载数据并指定 orient 为 'records':

                                                                                        import pandas as pd
                                                                                        # JSON字符串
                                                                                        json_data = '''[
                                                                                            {"Name": "Alice", "Age": 25, "City": "New York"},
                                                                                            {"Name": "Bob", "Age": 30, "City": "Los Angeles"},
                                                                                            {"Name": "Charlie", "Age": 35, "City": "Chicago"}
                                                                                        ]'''
                                                                                        # 从JSON字符串读取数据,指定orient='records'
                                                                                        df = pd.read_json(json_data, orient='records')
                                                                                        print(df)

                                                                                        Python 数据分析与可视化:开启数据洞察之旅(5/10)

                                                                                        4.2 从数据库获取数据

                                                                                        数据库是存储和管理大量数据的重要工具,在实际应用中,我们经常需要从数据库中获取数据进行分析。Python 提供了多种库来连接和操作常见的数据库,如 MySQL、SQLite 等。

                                                                                        MySQL 数据库:MySQL 是一种广泛使用的关系型数据库,使用 Python 连接 MySQL 数据库并获取数据,通常可以使用 pymysql 库。在使用之前,需要先安装该库,可以使用 pip 命令进行安装:

                                                                                        pip install pymysql

                                                                                        安装完成后,以下是一个连接 MySQL 数据库并查询数据的示例:

                                                                                        import pymysql
                                                                                        # 建立数据库连接
                                                                                        try:
                                                                                            connection = pymysql.connect(
                                                                                                host="localhost",  # 主机地址
                                                                                                port=3306,  # 端口号
                                                                                                user="your_username",  # 用户名
                                                                                                password="your_password",  # 密码
                                                                                                database="your_database",  # 数据库名称
                                                                                                charset="utf8"  # 编码
                                                                                            )
                                                                                            if connection.open:
                                                                                                print("成功连接到MySQL数据库")
                                                                                                # 创建游标对象
                                                                                                with connection.cursor() as cursor:
                                                                                                    # 执行查询操作
                                                                                                    select_query = "SELECT * FROM your_table"
                                                                                                    cursor.execute(select_query)
                                                                                                    # 获取所有查询结果
                                                                                                    results = cursor.fetchall()
                                                                                                    # 打印查询结果
                                                                                                    print("查询结果:")
                                                                                                    for row in results:
                                                                                                        print(row)
                                                                                        except pymysql.Error as e:
                                                                                            print(f"连接数据库时出错: {e}")
                                                                                        finally:
                                                                                            if connection.open:
                                                                                                connection.close()
                                                                                                print("数据库连接已关闭")
                                                                                        

                                                                                        在上述代码中,我们首先使用 pymysql.connect () 方法建立与 MySQL 数据库的连接,需要提供主机地址、端口号、用户名、密码、数据库名称和编码等信息。然后,通过 connection.cursor () 创建一个游标对象,用于执行 SQL 语句。接着,执行 SELECT 语句查询指定表中的所有数据,并使用 fetchall () 方法获取所有查询结果。最后,在操作完成后,关闭数据库连接。

                                                                                        SQLite 数据库:SQLite 是一种轻量级的嵌入式数据库,它不需要独立的服务器进程,非常适合小型应用程序和快速开发。Python 内置了 sqlite3 模块,用于连接和操作 SQLite 数据库。

                                                                                        import sqlite3
                                                                                        # 连接到SQLite数据库(如果数据库不存在,将创建一个新数据库)
                                                                                        conn = sqlite3.connect('example.db')
                                                                                        # 创建一个游标对象
                                                                                        cursor = conn.cursor()
                                                                                        # 执行SQL查询
                                                                                        cursor.execute("SELECT * FROM your_table")
                                                                                        # 获取所有记录
                                                                                        rows = cursor.fetchall()
                                                                                        # 遍历并打印记录
                                                                                        for row in rows:
                                                                                            print(row)
                                                                                        # 关闭游标和连接
                                                                                        cursor.close()
                                                                                        conn.close()
                                                                                        

                                                                                        在上述代码中,我们使用 sqlite3.connect () 方法连接到名为 'example.db' 的 SQLite 数据库,如果数据库不存在,将创建一个新的数据库。然后,创建游标对象并执行 SQL 查询,使用 fetchall () 方法获取所有查询结果,最后关闭游标和数据库连接。

                                                                                        4.3 网络数据获取

                                                                                        随着互联网的发展,网络成为了丰富的数据来源。我们可以通过网络获取各种类型的数据,如网页内容、API 数据等。下面将介绍使用 requests 库获取网页数据以及网页爬虫的基础知识。

                                                                                        4.3.1 使用 requests 库

                                                                                        requests 库是 Python 中用于发送 HTTP 请求的常用库,它提供了简单易用的 API,使得我们能够轻松地与网页进行交互,获取网页数据。

                                                                                        发送 HTTP GET 请求是最常见的操作之一,通过 requests.get () 函数可以实现。例如,获取百度首页的内容:

                                                                                        import requests
                                                                                        # 发送GET请求
                                                                                        response = requests.get('https://www.baidu.com')
                                                                                        # 检查响应状态码
                                                                                        if response.status_code == 200:
                                                                                            print("请求成功")
                                                                                            print(response.text)  # 打印网页内容
                                                                                        else:
                                                                                            print(f"请求失败,状态码: {response.status_code}")
                                                                                        

                                                                                        在上述代码中,我们使用 requests.get () 函数向'百度一下,你就知道' 发送 GET 请求,并将响应结果存储在 response 变量中。通过检查 response.status_code 属性,可以判断请求是否成功,如果状态码为 200,表示请求成功,此时可以通过 response.text 属性获取网页的文本内容。

                                                                                        有时,我们需要在请求中传递参数。例如,在百度搜索框中搜索关键词,可以通过 params 参数传递搜索关键词:

                                                                                        import requests
                                                                                        # 搜索关键词
                                                                                        keyword = "Python数据分析"
                                                                                        # 发送GET请求并传递参数
                                                                                        response = requests.get('https://www.baidu.com/s', params={'wd': keyword})
                                                                                        # 检查响应状态码
                                                                                        if response.status_code == 200:
                                                                                            print("请求成功")
                                                                                            print(response.url)  # 打印请求的URL
                                                                                        else:
                                                                                            print(f"请求失败,状态码: {response.status_code}")
                                                                                        

                                                                                        在上述代码中,我们通过 params 参数传递了一个字典 {'wd': keyword},其中 'wd' 是百度搜索的参数名,keyword 是搜索关键词。发送请求后,通过 response.url 可以查看实际请求的 URL,其中包含了我们传递的参数。

                                                                                        Python 数据分析与可视化:开启数据洞察之旅(5/10)

                                                                                        4.3.2 网页爬虫基础

                                                                                        网页爬虫是一种自动获取网页内容的程序,它通过模拟浏览器行为,按照一定的规则遍历网页,提取所需的数据。网页爬虫在数据采集、搜索引擎优化、市场调研等领域有着广泛的应用。

                                                                                        网页爬虫的基本原理是通过发送 HTTP 请求获取网页的 HTML 内容,然后使用解析库(如 BeautifulSoup、lxml 等)对 HTML 进行解析,提取出我们需要的数据。下面是一个使用 requests 和 BeautifulSoup 库编写的简单爬虫示例,用于获取豆瓣电影 Top250 的电影名称和评分:

                                                                                        import requests
                                                                                        from bs4 import BeautifulSoup
                                                                                        # 发送GET请求获取网页内容
                                                                                        url = 'https://movie.douban.com/top250'
                                                                                        response = requests.get(url)
                                                                                        # 检查响应状态码
                                                                                        if response.status_code == 200:
                                                                                            # 使用BeautifulSoup解析HTML
                                                                                            soup = BeautifulSoup(response.text, 'html.parser')
                                                                                            # 找到所有电影条目
                                                                                            movie_items = soup.find_all('div', class_='item')
                                                                                            # 遍历电影条目,提取电影名称和评分
                                                                                            for item in movie_items:
                                                                                                title = item.find('span', class_='title').text
                                                                                                rating = item.find('span', class_='rating_num').text
                                                                                                print(f"电影名称: {title}, 评分: {rating}")
                                                                                        else:
                                                                                            print(f"请求失败,状态码: {response.status_code}")
                                                                                        

                                                                                        在上述代码中,我们首先使用 requests.get () 函数获取豆瓣电影 Top250 页面的内容。然后,使用 BeautifulSoup 库对获取到的 HTML 内容进行解析,通过 find_all () 方法找到所有包含电影信息的 div 标签,其 class 属性为 'item'。接着,在每个电影条目中,使用 find () 方法找到电影名称和评分对应的 span 标签,并提取其文本内容。最后,打印出电影名称和评分。

                                                                                        需要注意的是,在进行网页爬虫时,要遵守网站的使用规则和法律法规,不要对网站造成过大的负担,避免侵犯他人的权益。同时,一些网站可能会采取反爬虫措施,如限制访问频率、检测爬虫行为等,我们需要根据实际情况进行相应的处理,如设置合理的请求头、添加随机延迟等,以确保爬虫的正常运行。

                                                                                        Python 数据分析与可视化:开启数据洞察之旅(5/10)

                                                                                        五、数据清洗与预处理

                                                                                        在数据分析的过程中,原始数据往往存在各种各样的问题,如缺失值、异常值、重复值等,这些问题会严重影响数据分析的准确性和可靠性。因此,在进行数据分析之前,我们需要对数据进行清洗和预处理,将原始数据转换为干净、整齐、可用的数据。下面将详细介绍数据清洗与预处理的常见方法和操作。

                                                                                        5.1 缺失值处理

                                                                                        缺失值是指数据集中某些数据点的数值缺失或未被记录。缺失值的存在可能会导致数据分析结果的偏差,因此需要对其进行处理。

                                                                                        5.1.1 检测缺失值

                                                                                        在 Pandas 中,我们可以使用 isnull () 或 isna () 方法来检测数据集中的缺失值,这两个方法的功能相同,只是名称不同。它们会返回一个布尔值的 DataFrame 或 Series,表示每个元素是否为缺失值。

                                                                                        import pandas as pd
                                                                                        # 创建一个包含缺失值的DataFrame
                                                                                        data = {'A': [1, 2, None, 4],
                                                                                                'B': [5, None, None, 8],
                                                                                                'C': [9, 10, 11, 12]}
                                                                                        df = pd.DataFrame(data)
                                                                                        # 检测缺失值
                                                                                        print(df.isnull())

                                                                                        运行上述代码,输出结果如下:

                                                                                               A      B      C
                                                                                        0  False  False  False
                                                                                        1  False   True  False
                                                                                        2   True   True  False
                                                                                        3  False  False  False

                                                                                        可以看到,对于每个元素,如果是缺失值则返回 True,否则返回 False。

                                                                                        为了统计每列的缺失值数量,可以使用 sum () 方法:

                                                                                        print(df.isnull().sum())

                                                                                        输出结果为:

                                                                                        A    1
                                                                                        B    2
                                                                                        C    0
                                                                                        dtype: int64

                                                                                        这样我们就可以清楚地知道每列中缺失值的个数。

                                                                                        5.1.2 删除缺失值

                                                                                        当数据集中缺失值较少时,我们可以选择直接删除含有缺失值的行或列。在 Pandas 中,使用 dropna () 方法来实现这一操作。

                                                                                        # 删除包含缺失值的行
                                                                                        df_drop_rows = df.dropna()
                                                                                        print(df_drop_rows)
                                                                                        # 删除包含缺失值的列
                                                                                        df_drop_cols = df.dropna(axis=1)
                                                                                        print(df_drop_cols)

                                                                                        在上述代码中,dropna () 方法默认删除含有缺失值的行(axis=0),通过设置 axis=1 可以删除含有缺失值的列。运行代码后,我们可以看到删除缺失值后的 DataFrame。

                                                                                        dropna () 方法还有其他参数可以设置,例如:

                                                                                        • how='any':只要有一个缺失值就删除(默认)。
                                                                                          • how='all':只有当所有值都是缺失值时才删除。
                                                                                            • thresh=n:至少有 n 个非缺失值才保留。
                                                                                              5.1.3 填充缺失值

                                                                                              除了删除缺失值,我们还可以使用指定值、统计量(如均值、中位数)等方法来填充缺失值,以保留数据集中的信息。在 Pandas 中,使用 fillna () 方法进行填充。

                                                                                              # 用指定的值填充缺失值
                                                                                              df_fill_value = df.fillna(0)
                                                                                              print(df_fill_value)
                                                                                              # 用均值填充缺失值
                                                                                              df_fill_mean = df.fillna(df.mean())
                                                                                              print(df_fill_mean)
                                                                                              # 用前一个非缺失值填充(前向填充)
                                                                                              df_ffill = df.fillna(method='ffill')
                                                                                              print(df_ffill)
                                                                                              # 用后一个非缺失值填充(后向填充)
                                                                                              df_bfill = df.fillna(method='bfill')
                                                                                              print(df_bfill)

                                                                                              在上述代码中,首先使用 fillna (0) 将缺失值填充为 0;然后使用 df.mean () 计算每列的均值,并将缺失值填充为均值;接着使用 method='ffill' 进行前向填充,即使用前一个非缺失值填充当前缺失值;最后使用 method='bfill' 进行后向填充,即使用后一个非缺失值填充当前缺失值。运行代码后,可以看到不同填充方法得到的结果。

                                                                                              5.2 异常值处理

                                                                                              异常值是指数据集中与其他数据点显著不同的数据点,它们可能是由于数据录入错误、测量误差或其他原因导致的。异常值的存在可能会对数据分析和模型训练产生较大的影响,因此需要对其进行处理。

                                                                                              5.2.1 检测异常值

                                                                                              检测异常值的方法有很多种,下面介绍两种常用的统计方法:箱线图和 Z-Score。

                                                                                              • 箱线图:箱线图是一种基于统计的图形化方法,通过可视化数据的分布情况来识别异常值。它展示了数据的最小值、第一四分位数(Q1)、中位数(Q2)、第三四分位数(Q3)和最大值。异常值通常定义为超出 1.5 倍 IQR(四分位距,IQR = Q3 - Q1)范围的数据点。
                                                                                                import matplotlib.pyplot as plt
                                                                                                import seaborn as sns
                                                                                                import pandas as pd
                                                                                                import numpy as np
                                                                                                # 生成示例数据
                                                                                                data = np.random.normal(100, 10, 100)
                                                                                                data = np.append(data, [150, 160, 200])  # 添加几个异常值
                                                                                                df = pd.DataFrame({'data': data})
                                                                                                # 绘制箱线图
                                                                                                plt.figure(figsize=(10, 6))
                                                                                                sns.boxplot(data=df['data'])
                                                                                                plt.title('Boxplot for Outlier Detection')
                                                                                                plt.show()

                                                                                                运行上述代码,会生成一个箱线图,超出上下边界的数据点即为异常值,通过观察箱线图,我们可以直观地识别出异常值。

                                                                                                • Z-Score:Z-Score 是一种基于标准差的异常值检测方法。它通过计算每个数据点与均值的标准差偏离程度来判断是否为异常值。Z-Score 的计算公式为:Z = (X - μ) / σ,其中 X 是数据点,μ 是均值,σ 是标准差。通常情况下,Z-Score 的绝对值大于 3 的数据点被视为异常值。
                                                                                                  import numpy as np
                                                                                                  import pandas as pd
                                                                                                  # 示例数据
                                                                                                  data = np.array([10, 12, 12, 13, 12, 13, 14, 14, 14, 15, 16, 18, 19, 20, 30])
                                                                                                  df = pd.DataFrame({'data': data})
                                                                                                  # 计算均值和标准差
                                                                                                  mean = df['data'].mean()
                                                                                                  std_dev = df['data'].std()
                                                                                                  # 计算Z-Score
                                                                                                  df['z_score'] = (df['data'] - mean) / std_dev
                                                                                                  # 识别异常值
                                                                                                  threshold = 3
                                                                                                  outliers = df[df['z_score'].abs() > threshold]
                                                                                                  print(outliers)

                                                                                                  在上述代码中,首先计算数据的均值和标准差,然后计算每个数据点的 Z-Score,最后通过设置阈值(这里为 3)来识别异常值。运行代码后,会输出检测到的异常值。

                                                                                                  5.2.2 处理异常值

                                                                                                  对于检测到的异常值,可以采取以下几种处理方式:

                                                                                                  • 修正异常值:如果异常值是由于数据录入错误等原因导致的,可以根据实际情况进行修正。例如,将一个明显错误的年龄值(如 200 岁)修正为合理的值。
                                                                                                    • 删除异常值:当异常值对分析结果影响较大且无法修正时,可以选择删除异常值。使用 drop () 方法可以删除 DataFrame 中指定的行。
                                                                                                      # 删除异常值
                                                                                                      df = df[df['z_score'].abs() 
免责声明:我们致力于保护作者版权,注重分享,被刊用文章因无法核实真实出处,未能及时与作者取得联系,或有版权异议的,请联系管理员,我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明:本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度,360,搜狗等多加搜索引擎自动关键词搜索配图,如有侵权的图片,请第一时间联系我们。

相关阅读

目录[+]

取消
微信二维码
微信二维码
支付宝二维码