Python 数据可视化工具
Python 星期五:挑战#6
I wish I knew how to make this graph.
利用数据寻找相关性是一项很有价值的技能。但是能够将这些发现传达给其他不熟悉数据集的人也是非常有价值的。了解到这一点，我决定做一些谷歌搜索来找出我应该学习什么工具来展示我的数据项目。
我很快找到了这篇关于 Python 数据可视化库的博文，有几条引起了我的注意。
我想尝试的可视化工具列表
- Seaborn
- 散景
- 臀的
- geoplotlib
- 闪光
- missingno【这个我不能不演示，是口袋妖怪参考！]
我怎么能只选择其中一个呢？我不想只选择一个，但我认为 Seaborn 是一个给定的，因为它是基于 matplotlib 的，并且我已经学习了相当多的相关知识(感谢 Dataquest！).
我喜欢 geoplotlib 的想法，因为热图。我肯定会在未来的某个时候构建一个热图。我根本不在乎这是什么。我只想建立一个热图，并知道我做到了。
但是现在，它将会是 Seaborn 。
挑战:3 个问题
使用我一直在用的数据集
- 车重和 MPG 有关系吗？
- 气缸数量与 MPG 相关吗？
- 总马力和 MPG 有关系吗？
这些问题似乎是显而易见的，但我从未真正看到任何数据来支持这些概念。这就是它的乐趣所在。用数据支持一个想法，和一开始就有想法一样重要。
看看我的图表！
这里的是生成下图的代码的 github repo。line1.py、line2.py 和 line3.py 是图表，按它们在这里出现的顺序排列。
MPG 与重量
MPG vs Weight
汽车的重量和每加仑行驶的英里数之间有着非常紧密的联系。理所应当！移动更多的重量需要更多的能量！
MPG 与气缸数量的关系
MPG vs. Number of Cylinders
另一个真正可靠的关联！虽然有奇怪的异常在 38 分钟的标记。我想这可能是因为有一个不完整的数据集，或者是一个主要是 4 缸发动机的不平衡的数据集…但我还没有制作一个图表来检查这一点😄
MPG 与马力
MPG vs. Horsepower
这是我所期望的图表，但是这个图表在几个方面被搞乱了。趋势看起来是对的，但是我的 x-tick 标签顺序不对。我不确定为什么会这样，因为它用来制图的数据是正确排序的。这可能是因为 seaborn 在绘制线条时内置了一些“平均”功能。
我将不得不做更多的调查，但今晚我没有时间了。
我的一些“问题”
- 进口 Seaborn 有困难。首先，我将我在 seaborn.py 上工作的文件命名为😞哇，你不能进口那种东西。我认为问题出在我的 linter 上，因为它仍然显示无法导入 seaborn，但它仍然在运行。
- 我想皮林特是因为海伯恩被安装了蟒蛇而生气吧？我不知道，我重启了机器，它在终端中运行，但 VSCode 仍然在抱怨无法导入“seaborn ”,尽管它肯定是在终端中导入和执行的。
- 我不知道如何在睡觉前把我的 x 轴刻度按正确的顺序排列，也不知道如何避免马力的平均值。
外卖
我已经认识到，我不擅长挑选最能有效传达相关性的东西。此外，我还有很多关于组织和清理数据的知识要学，以便为制图做好准备。
感谢阅读！💚
Windows 10 上深度学习的 Python 环境设置
TensorFlow 2.0 logo design
关于如何开始深度学习的详细介绍，从在 Microsoft Windows 10 上启用适合它的环境开始。要安装的框架将是 Keras API，使用 Google 的 TensorFlow GPU 版本作为后端引擎。
这个指南是我在自己的深度学习项目中使用的相同程序，它对我很有帮助。本指南的目的是在一个地方积累所有必要的和更新的信息，而不是在整个谷歌搜索。
让我们开始吧。
本指南已更新至 TensorFlow 2.1 版本
目录
- 什么是深度学习？
- PC 硬件设置
- PC 软件设置
- Python 解释器
- Python IDE
什么是深度学习？
深度学习是机器学习的一个子集，它利用多层人工神经网络在对象检测、语音识别、语言翻译等任务中提供最先进的准确性。
深度学习不同于传统的机器学习技术，它们可以从图像、视频或文本等数据中自动学习表示，而不需要引入手工编码的规则或人类领域知识。它们高度灵活的架构可以直接从原始数据中学习，当提供更多数据时，可以提高它们的预测准确性。
电脑硬件设置
为了在任何数据集上执行深度学习，软件/程序需要足够强大的计算机系统来处理必要的计算能力。因此，需要以下最低规格:
1)中央处理器(CPU) —英特尔酷睿 i5 第六代处理器或更高。AMD 同等处理器也是最佳选择。
2) RAM —最低 8 GB，建议 16 GB 或更高。
3)图形处理单元(GPU) — NVIDIA GeForce GTX 940 或更高。AMD GPUs 无论如何都无法进行深度学习。
4)操作系统 —微软 Windows 10(建议 64 位)Pro 或 Home。我建议在继续之前将 Windows 10 更新到最新版本。
注:对于笔记本电脑，理想的选择是从任何合适的供应商处购买游戏笔记本电脑，如华硕、联想军团、宏碁掠夺者、外星人等。
电脑软件设置
现在，为了执行深度学习，我们将使用一种称为 GPU 计算的方法，该方法将复杂的数学计算导向 GPU，而不是 CPU，从而显著减少整体计算时间。为此，我们按以下顺序安装几个组件:
Microsoft Visual Studio IDE
Visual Studio 对于接下来两个组件的安装至关重要。我推荐 Visual Studio 2019(因为我正在使用它),因为它的性能超越了它的所有前辈，安装也从未像现在这样简单快捷。但是有一个范围，你可以使用 2012 年到 2019 年的任何 VS 版本。
如果您安装了 Visual Studio 2019，则必须将其更新到 16.4 或更高版本。VS 2019 的新安装默认更新。
安装 Visual Studio 2019(或 2017，因为它与 2019 相似)后，请确保“使用 C++进行桌面开发”工作负载与以下组件一起安装:
- MSVC v 142-VS 2019 c++ x64/x86 构建工具(v14.24)
- Windows 10 SDK(任何版本)
NVIDIA GeForce 体验
该工具旨在更新您的 NVIDIA GPU 驱动程序，这样做要容易得多，如果您有 NVIDIA GPU，强烈建议安装该工具
安装它，你需要创建一个帐户才能使用它。您应该会看到这样的屏幕
NVIDIA GeForce Experience Drivers page
在红色框中，您可以看到一个标记为“检查更新”的按钮。自动更新功能不可靠，因此在继续下载下一个软件之前，请手动检查更新。
如果你的驱动程序更新了，那么很好，你可以继续前进。如果没有，请更新它，虽然 CUDA 工具包附带驱动程序，但建议从这里开始更新，因为它们在发布时只包含最低驱动程序要求(因为您可能在发布日期后的某个时间使用它)。
NVIDIA CUDA 工具包
该软件组件是使 GPU 能够进行 GPU 计算所必需的。我们将下载版本 10.0，因为这是与我们将要安装的框架兼容的版本。
注意:TensorFlow 2.1 仅兼容 CUDA Toolkit 10.1。
接下来，您需要进入 CUDA 安装中的 samples 文件夹，如果您在安装过程中选择了默认路径，它位于:
C:\ProgramData\NVIDIA Corporation\CUDA Samples\v10.1\1_Utilities\deviceQuery
并选择适合您系统上安装的 VS 版本的 VS 解决方案，并在您安装的 Visual Studio 版本上运行它。如果您有 Visual Studio 2017，请运行 VS 2017 的 Visual Studio 解决方案。在运行解决方案的结果中，您应该已经获得
The result of deviceQuery CUDA Sample tested on CUDA 10.0 using VS2017 (Code compiles similarly across other CUDA versions).
安装通过验证后，您需要将 CUDA Toolkit 添加到 Path 环境中，这可以通过以下方法完成:
第一步
Right click on the ‘This PC’ shortcut and select Properties
第二步
Then select Advanced System Settings (left upper corner)
第三步
Select Environment Variables
步骤#4
Go to the bottom scroll-able window and select the Path variable by double clicking on it
第 5 步
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.1\bin
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.1\lib\x64
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.1\include
Add the CUDA 9.0 paths in the variable
英伟达 cuDNN
你需要注册一个 NVIDIA 开发者帐户来下载它，这是免费的，没有那么麻烦。为 CUDA 10.1 下载 cuDNN 7.6.X。
下载后，解压它，你将有 3 个文件，然后做:
a) Copy <installpath>\cuda\bin\cudnn64_7.dll to C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.1\bin.
b) Copy <installpath>\cuda\ include\cudnn.h to C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.1\include.
c) Copy <installpath>\cuda\lib\x64\cudnn.lib to C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v10.1\lib\x64.
一旦完成，你的 GPU 现在准备执行 GPU 计算。
Python 解释器
现在我们已经配置好了 GPU，是时候安装我们的 python 解释器了，我们将在 Anaconda 中使用它。它被认为比传统的 python 安装要好用得多，而且运行起来也更好。
我们可以安装这种解释器的两种变体，称为 Anaconda 和 Miniconda。要选择搭配哪个，请参考以下指南(摘自官方文档):
如果您符合以下条件，请选择 Anaconda:
- 对 conda 或 Python 来说是新的
- 比如一下子自动安装 Python 和 150 多个科学软件包的便利
- 有时间和磁盘空间(几分钟和 5 GB)，和/或
- 不想安装你想单独使用的每个软件包。
如果您符合以下条件，请选择 Miniconda:
- 不要介意单独安装您想要使用的每个软件包。
- 没有时间或磁盘空间一次安装超过 150 个软件包，和/或
- 只是想快速访问 Python 和 conda 命令，并希望以后整理其他程序。
我自己用 Miniconda。蟒蛇很臃肿。许多软件包从未使用过，如果需要的话，仍然可以很容易地安装。
注意:建议(但不是必须)下载您选择的解释器的 Python 3 版本，因为 Python 2 即将寿终正寝。
一旦你安装了你选择的解释器，就该安装需要的软件包了。打开 Anaconda 提示符并键入命令:
conda update conda
对于只支持 Anaconda 的用户，在您键入上面的命令之后，接下来键入:
conda update anaconda
暂时不要关闭 Anaconda 提示符。
注:TensorFlow 在 Windows 10 上支持 Python 3.5、3.6、3.7。虽然 TensorFlow 2.1 将是 TensorFlow 最终支持 Python 2 的版本(不考虑 OS)。
现在是时候创建我们的环境了，我们可以通过 Anaconda 提示符轻松地完成这项工作(在这种情况下，我们将创建一个名为 TensorFlow-GPU 的 Python 3.7 环境):
conda create -n TensorFlow-GPU python=3.7
我们成功地创造了新的环境。
暂时不要关闭 Anaconda 提示符。
张量流
现在，我们开始安装 tensorflow GPU 版本，为此，我们首先激活我们新创建的环境。只需输入:
conda activate TensorFlow-GPU
接下来我们安装 TensorFlow 2.1(基础包 tensorflow 已经包含对 CPU 和 GPU 的支持，并将根据系统 ) :
pip install tensorflow
pip 版本是官方支持的，而 conda 版本是社区支持的。谷歌建议安装 pip 版本。
TensorFlow 1.13 版及更高版本预装了 Keras，并与 tensor flow 一起构建，因此用户无需安装单独的 Keras 包。
现在要测试环境，调用命令:
python
然后键入:
>>import tensorflow as tf
如果这是您得到的结果:
>>import tensorflow as tf
>>
则意味着安装成功。现在我们转到 IDE。您可以关闭提示。
python IDE/文本编辑器
以下两者在调试、林挺和智能自动完成 Python 代码方面都非常出色，速度和精度都快得惊人。
- Visual Studio 代码安装了这些必要的 扩展。
- PyCharm:面向专业开发人员的 Python IDE。
这样你就可以开始你的机器学习之旅了。
结束了
Connect with the Raven team on Telegram
Python 探索性数据分析教程
最初发布于https://www . data camp . com/community/tutorials/explorative-data-analysis-python
正如您现在所知道的，Python 数据操作库 Pandas 用于数据操作；对于那些刚刚起步的人来说，这可能意味着这个包只能在预处理数据时方便使用，但事实并非如此:Pandas 还可以很好地探索您的数据，并在您完成数据预处理后存储它。
此外，对于那些一直在关注 DataCamp 的 Python 教程或已经了解了 SciPy、NumPy、Matplotlib 和 Pandas 基础知识的人来说，重温一下您已经积累的一些知识可能是个好主意。
今天的教程实际上将向您介绍一些使用上述所有包高效浏览数据的方法，以便您可以开始对数据进行建模:
- 您将首先学习如何导入数据，这是您在开始分析之前需要成功完成的第一步。
- 如果你不确定探索性数据分析(EDA) 是什么，EDA 和数据挖掘的确切区别是什么，本节将在你开始教程之前为你解释！
- 然后，你会得到你的数据的一个基本描述。您将专注于获取一些描述性统计数据，检查数据帧的第一行和最后一行，从数据中检索样本，等等。你会发现这是一个很好的方式来获得对数据的初步感觉，并且可能已经对它有了更好的理解！
- 在收集了一些关于数据的信息后，通过查询或索引数据来更深入地查看它可能也是一个好主意。您可以使用这种技术来测试您对数据的一些基本假设。
- 现在您已经检查了您的数据，您可能已经看到了您的分析可能感兴趣的一些特性:您将看到哪些特性可以通过特性工程和特性选择对您的分析产生积极的影响。
- 接下来，您将看到初步探索是好的，但您还需要了解您的数据可能带来的挑战，例如缺失值或异常值，当然，还有您如何应对这些挑战
- 最后，您还将学习如何发现数据中的模式，方法是使用 Python 数据可视化包 Matplotlib 和 Bokeh 轻松快速地可视化数据，或者使用特定函数计算属性之间的相关性。
阅读全文 [这里](http://As you will know by now, the Python data manipulation library Pandas is used for data manipulation; For those who are just starting out, this might imply that this package can only be handy when preprocessing data, but much less is true: Pandas is also great to explore your data and to store it after you’re done preprocessing the data. Additionally, for those who have been following DataCamp’s Python tutorials or that have already been introduced to the basics of SciPy, NumPy, Matplotlib and Pandas, it might be a good idea to recap some of the knowledge that you have built up. Today’s tutorial will actually introduce you to some ways to explore your data efficiently with all the above packages so that you can start modeling your data: You’ll first learn how to import data, which is the first step that you need to complete successfully before you can start your analysis. If you’re not sure what Exploratory Data Analysis (EDA) is and what the exact difference between EDA and Data Mining is, this section will explain it for you before you start the tutorial! Then, you’ll get a basic description of your data. You’ll focus on getting some descriptive statistics, checking out the first and last rows of your DataFrame, retrieving samples from your data, etc. You’ll see that this is a great way to get an initial feeling with your data and maybe understand it a bit better already! After gathering some information on your data, it might also be a good idea to also take a deeper look at it by querying or indexing the data. You can use this technique to test some of the basic hypotheses that you might have about the data. Now that you have inspected your data, you’ll probably already see that there are some features that can be of interest to your analysis: you’ll see which ones can influence your analysis positively with feature engineering and feature selection. Next, you’ll see that an initial exploration is good, but you will also need to have an idea of the challenges that your data can pose, such as missing values or outliers, and, of course, how you can handle those challenges, and Lastly, you’ll also learn how to discover patterns in your data, by either visualizing your data easily and quickly with the Python data visualization packages Matplotlib and Bokeh, or by using specific functions to compute the correlation between attributes.) 。
导入数据
要开始探索您的数据，您需要从实际加载数据开始。你可能已经知道了这一点，但是多亏了 Pandas 库，这变成了一个简单的任务:你按照惯例以pd的形式导入包，然后使用read_csv()函数，向它传递可以找到数据的 URL 和一个header参数。最后一个参数可以用来确保数据被正确读入:数据的第一行不会被解释为数据帧的列名。
或者，您还可以指定其他参数来确保数据被正确读入:您可以指定与sep或delimiter参数一起使用的分隔符，与names一起使用的列名，或者与index_col一起用作结果数据帧的行标签的列。
但是这些并不是您可以添加到read_csv()函数中的所有参数。在文档中详细阅读该函数及其参数。
注意，在这种情况下，您使用了read_csv()，因为数据碰巧是逗号分隔的格式。如果您的文件有另一个分隔符，您也可以考虑使用其他函数加载您的数据，如read_table()、read_excel()、read_fwf()和read_clipboard，分别读入一般分隔文件、Excel 文件、固定宽度格式数据和复制到剪贴板的数据。
此外，您会发现read_sql()是将 SQL 查询或数据库表读入数据帧的选项之一。对于更多的输入功能，请考虑 Pandas 文档的本节。
什么是探索性数据分析(EDA)？
探索性数据分析(EDA)一方面用于回答问题、测试业务假设、为进一步分析生成假设。另一方面，也可以用它来为建模准备数据。这两者的共同点可能是对您的数据有很好的了解，以获得您需要的答案，或者开发一种直觉来解释未来建模的结果。
有很多方法可以达到这些目标:你可以获得数据的基本描述，可视化它，识别其中的模式，识别使用数据的挑战，等等。
在阅读有关 EDA 的内容时，您会经常看到的一件事情是数据分析。数据概要分析通过描述性统计对数据集进行汇总。您希望使用各种测量方法来更好地了解数据集。数据概要分析的目标是对您的数据有一个坚实的理解，以便您以后可以开始以各种方式查询和可视化您的数据。然而，这并不意味着您不需要迭代:正是因为数据概要分析与汇总您的数据集有关，所以它经常用于评估数据质量。根据数据分析的结果，您可能会决定更正、丢弃或以不同方式处理您的数据。
在下一篇文章中，您将了解更多关于数据分析的内容。
EDA 和数据挖掘
EDA 不同于数据挖掘，尽管两者密切相关，因为许多 EDA 技术已经被用于数据挖掘。这两者的目标也非常相似:EDA 确实确保您以一种有趣的特性和特性之间的关系将变得更加清晰的方式探索数据。在 EDA 中，您通常会使用各种技术探索和比较许多不同的变量，以搜索和找到系统模式。另一方面，数据挖掘关注的是从数据中提取模式。这些模式提供了对变量之间关系的洞察，可以用来改进业务决策。同样，在这两种情况下，你都没有关于变量之间关系的先验期望或不完整的期望。
但是，一般来说，数据挖掘可以说是更面向应用，而 EDA 关注的是底层现象的基本性质。换句话说，数据挖掘相对不太关心识别所涉及变量之间的特定关系。因此，数据挖掘接受“黑盒”方法来进行数据探索，不仅使用 EDA 中也使用的技术，还使用神经网络等技术来生成有效的预测，但不识别预测所基于的变量之间关系的特定性质。
数据的基本描述
就像你在上面读到的，EDA 就是要了解你的数据。要做到这一点，最基本的步骤之一是获得数据的基本描述。对数据的基本描述确实是一个非常宽泛的术语:您可以将其解释为获取数据信息的一种快速而简单的方式，获取数据信息的一种简单、易于理解的方式，对数据的一种基本感觉，等等。
本节不会对这些解释进行区分:它确实会向您介绍一些可以快速收集数据框架信息的方法，这些方法很容易理解。
例如，您可以使用describe()函数获得排除 NaN 值的各种汇总统计信息。考虑这个代码示例。
您会看到该函数返回数据的计数、平均值、标准差、最小值和最大值以及分位数。当然，请注意，Python 中有许多包可以提供这些统计数据，包括 Pandas 本身。使用该功能只是获取这些信息的方法之一。
还要注意，如果您还没有这样做，您肯定需要花时间深入研究描述性统计数据。您可以使用这些描述性统计数据来开始评估数据的质量。然后，你将能够决定你是否需要纠正，丢弃或以另一种方式处理数据。这通常是数据分析步骤。EDA 中的这一步旨在更好地理解数据元素及其异常，并了解数据一方面如何与文档相匹配，另一方面如何适应业务需求。
请注意在您进行探索性数据分析时，您将回到数据分析步骤，因为您将经历的步骤会影响数据的质量。
既然您已经对数据集有了大致的了解，那么更仔细地查看数据本身也是一个好主意。借助熊猫图书馆的head()和tail()功能，你可以很容易地分别检查出你的数据帧的第一行和最后一行。
使用下面 DataCamp 轻量块中的head()和tail()功能检查手写数字数据的第一行和最后五行。你可以在这个 DataCamp Light 代码块里试试。
当你不熟悉这类数据时，你会发现head()和tail()函数的结果并不能说明什么。
你可能只会看到一堆带有数字值的行和列。如果您还没有阅读过数据集描述的话，请考虑阅读一下，这将为您提供关于数据是如何收集的相关信息，还会说明属性和行数，这可以方便地检查您是否正确导入了数据。
此外，回到最初的发现:行中的数值。乍一看，您可能不认为有问题，因为整数值看起来是正确的，并且当您第一次查看它时没有出现任何标志。
但是，如果您已经在您面前的另一个数据集上完成了所有这些操作，并且该数据集可能具有例如日期时间信息，那么快速浏览这些代码行的结果可能会提出以下问题:“我的数据是作为日期时间读入的吗？”，“这个怎么查？”以及“我如何改变数据类型？”。
这些是您通常会在数据分析步骤中解决的更深层次的问题，将在下一篇文章中解决。
如果您有一个大型数据集，您可以考虑对数据进行采样，作为快速了解数据的一种简单方法。作为第一个简单的方法，你可以使用 Pandas 中的sample()函数，就像你在这里看到的。
另一种可能更复杂的方法是创建一个随机索引，然后从数据帧中获取随机行。你会看到下面的代码使用了random包，它有一个模块sample，可以让你结合range()和len()对数据进行采样。请注意，您还可以利用ix来选择您想要包含在样本中的数据帧的确切行。
如果你不知道为什么在这种情况下使用ix, data camp 更具体的教程会有所帮助！它详细介绍了这些更一般的主题。点击上面的链接去看看吧！
现在，让我们练习一下 Python 技巧吧！从这里开始练习。
现在，您已经收集了一些关于数据的基本信息，最好是稍微深入一点，了解数据可能带来的挑战。如果您已经完成了数据分析步骤，您将意识到丢失的值，您将知道哪些值可能是异常值，等等。
最初发表于【www.datacamp.com】。
Python for Android:开始构建 Kivy 跨平台应用程序
本教程介绍了使用 Linux Ubuntu 发行版使用 Kivy 跨平台 Python 框架创建 Android 应用程序所需的步骤。在开始安装 Kivy 并启动和运行它之前，需要安装它的依赖项。大部分时间用于通过安装运行所需的库来准备 Kivy 环境。在本教程中，Kivy 本身将安装在一个虚拟环境中。
本教程中使用的平台是带有 Python 3.6.5 的 Linux Ubuntu 18.04。在其他平台上运行 Kivy 会存在一些差异。为了能够安装库、浏览操作系统的目录、复制/删除/提取文件、运行 Python 脚本，读者应该对 Linux 终端命令和 Python 有一个基本的了解。
本教程包含以下几个部分:
- 介绍
- 安装 Kivy 依赖项
- 为安装 Kivy 创建虚拟环境
- 安装 Cython
- 安装 Kivy
- 进口基维
- 创建简单的 Kivy 应用
- 安装 Buildozer
- 正在创建 buildozer.spec 文件
- 使用 Buildozer 构建 Android 应用程序
- 参考
1.介绍
Kivy 用于创建自然的用户界面，具有抽象和模块化的优点。它将开发人员从不必要的复杂细节中分离出来，只给出简单的 API 来完成复杂的任务。因此，您应该确定 Kivy 将使用什么样的后端库来完成它的任务。我们将使用 SDL ( 简单直接媒体层)跨平台库，通过 OpenGL 对图形硬件进行低级访问。除了 SDL，GStreamer 等其他库也用于处理音频和视频。因为这样的库是用 C 写的，所以需要 Cython。
2.安装 Kivy 依赖项
根据 Kivy Linux 安装说明(【https://kivy.org/docs/installation/installation-linux.html】T2)，下面是获得 SDL2 和 GStreamer 需要安装的库。注意，您可以选择在 Kivy 中使用哪个 Python 版本，对于 Python 2 使用 python 和 python-dev ，或者对于 python3 使用 python3 和 python3-dev 。Pip 安装在下面，供以后准备 Kivy 虚拟环境时使用。
**ahmed-gad@ubuntu:~$ sudo apt install -y \****python-pip \****build-essential \****git \****python3 \****python3-dev \****ffmpeg \****libsdl2-dev \****libsdl2-image-dev \****libsdl2-mixer-dev \****libsdl2-ttf-dev \****libportmidi-dev \****libswscale-dev \****libavformat-dev \****libavcodec-dev \****zlib1g-dev \****libgstreamer1.0 \****gstreamer1.0-plugins-base \****gstreamer1.0-plugins-good**
3.为安装 Kivy 创建虚拟环境
准备好 Kivy 依赖项后，我们可以通过创建虚拟环境来开始安装 Kivy。不要求使用虚拟环境来运行 Kivy，但建议将 Kivy 与其他现有项目分开。
在开始创建虚拟环境之前，我们应该确保创建虚拟环境所需的工具已经安装并更新。以下命令确保 virtualenv 和 setuptools 工具已经存在并更新。
**ahmed-gad@ubuntu:~$ sudo pip install --upgrade pip virtualenv setuptools**
virtualenv 用于创建隔离的 Python 环境。有关虚拟环境优势的更多信息，您可以访问本页https://virtualenv.pypa.io/en/stable/。 setuptools 用于打包 Python 项目。
之后，我们准备创建 Kivy 虚拟环境。以下命令创建了一个名为 mykivyinstall 的环境。
**ahmed-gad@ubuntu:~$ virtualenv --no-site-packages mykivyinstall**
— no-site-packages 参数用于将环境与主 Python 安装隔离开来。这是在不影响任何其他项目的情况下，在那个项目上自由地工作。
发出该命令后，预计会在当前目录中获得一个根据虚拟环境名称命名的新文件夹，如图 1 所示。
Figure 1. Creating Kivy virtual environment.
前面的命令将在环境中使用默认的 Python 解释器。它可能是 Python 2，我们希望与 Python 3 合作。因此，我们可以使用下面的命令中的 -p 选项来明确指定使用哪个 Python 解释器:
**ahmed-gad@ubuntu:~$ virtualenv --no-site-packages -p /usr/bin/python3 mykivyinstall**
创建虚拟环境后，我们可以激活它来开始安装 Kivy。可以基于以下命令激活它。
**ahmed-gad@ubuntu:~$ . mykivyinstall/bin/activate**
点号()。)是一个内置命令，执行作为参数传递的文件内容。它是命令源的同义词。因此，前面的命令与此命令相同:
**ahmed-gad@ubuntu:~$ *source* mykivyinstall/bin/activate**
激活虚拟环境后，命令提示符应更改如下:
**(mykivyinstall) ahmed-gad@ubuntu:~$**
4.安装 Cython
在安装 Kivy 之前，根据以下命令将 Cython 安装在这样的环境中:
**(mykivyinstall) ahmed-gad@ubuntu:~$ pip install cython=0.25.2**
请注意，Cython 的版本取决于要安装的 Kivy 的版本。在当前日期，最新的 Kivy 版本是 1.10.0 ，它需要 Cython 0.25.2 ，这就是为什么在上面的命令中使用它。之后，我们准备安装 Kivy。
5.安装 Kivy
可以根据以下命令使用 pip 安装 Kivy:
**(mykivyinstall) ahmed-gad@ubuntu:~$ pip install kivy**
在这个命令之后，Kivy 会自动下载并安装。但是请注意，Kivy 的安装是最难的部分，因为有许多依赖项是基于机器、平台以及您已经拥有和缺少的库而变化的。这个过程并不简单，您应该寻找其他方法来解决安装错误。例如，Kivy 可以通过使用 wheel 文件或根据以下命令克隆其 github 项目来安装:
**(mykivyinstall) ahmed-gad@ubuntu:~$ pip install git+https://github.com/kivy/kivy.git@master**
6.进口基维
达到 is 阶段后，预计 Kivy 会成功安装并运行在您的机器上。我们可以通过导入 Kivy 来测试这个环境，如图 2 所示。虚拟环境被激活，Python 被激活，Kivy 被成功导入。
Figure 2. Testing the virtual environment.
在确保 Kivy 运行良好之后，我们准备创建我们的第一个 Kivy 应用程序。
7.创建简单的 Kivy 应用
Kivy 应用程序只是一个保存 Kivy 代码的简单 Python 文件。我们的应用程序中的文件将被命名为“ main.py ”。原因是在构建移动应用的时候，必须有一个名为“ main.py 的文件，这是应用的入口。要创建的应用程序将有三个 Kivy 小部件，分别是文本输入、标签、和按钮。这些小部件使用方框布局垂直显示在一个窗口中。它们将按照添加到框布局的顺序出现。换句话说，文本输入将是第一个小部件，其次是标签，最后是底部的按钮。当点击按钮时，在文本输入中输入的文本将显示在标签上。下面是应用程序的 Kivy 代码。
1\. **import** kivy.app
- 导入 kivy.uix.boxlayout
- 导入 kivy.uix.textinput
- 导入 kivy.uix.label
- 导入 kivy.uix.button
- 类简单应用程序(kivy.app.App):
- def build(自我):
- self . textinput = kivy . uix . textinput . textinput()
- self . label = kivy . uix . label . label(text = “您的消息。”)
- self . button = kivy . uix . button . button(text = “点击我。”)
- self . button . bind(on _ press = self . display message)
- self . box layout = kivy . uix . box layout . box layout(orientation = " vertical ")
- self . box layout . add _ widget(self . textinput)
- self . box layout . add _ widget(self . label)
- self . box layout . add _ widget(self . button)
- 返回 self.boxLayout
- def 显示消息(self，btn):
- self . label . text = self . textinput . text
- 如果 name == "main ":
- simpleApp = SimpleApp()
- simpleApp.run()
build 方法是应用程序运行后调用的方法，因此它用于初始化 Kivy GUI 窗口。这三个小部件被创建，然后被添加到框布局中。bind 方法将一个回调方法附加到单击时要执行的按钮上。回调方法名为“ displayMessage ”，它将标签文本设置为文本输入小部件中输入的文本。只有通过确保 if 语句中的**“_ _ name _ ”变量具有值“ _ main _ _”**来执行 main.py 文件，应用程序才会运行。做那件事是好习惯。为了运行该应用程序，需要两个步骤。首先是激活先前创建的名为" mykivyinstall "的 Kivy 虚拟环境。第二个是在导航到应用程序文件所在的文件夹后，运行应用程序文件“ main.py ”。这些步骤如图 3 所示。
Figure 3. Activating the virtual environment.
图 4 显示了带有之前创建的三个小部件的窗口。请注意，窗口高度在它的三个小部件之间平均分配，因此每个小部件只有窗口高度的三分之一。在本例中，在文本输入中输入了“ Hello Kivy ”消息。当按钮被点击时，信息将出现在标签上。
Figure 4. Simple Kivy application.
至此，成功创建了一个 Kivy 桌面应用程序。我们现在可以开始将这个项目打包成一个 Android 应用程序。
8.安装 Buildozer
Buildozer 工具用于将项目打包成 Android 应用。一旦安装完毕， Buildozer 就会自动完成构建 Android 应用的过程。为了安装 Buildozer ，有一些依赖关系。除了之前安装的 Cython 和 git，还有一些其他的库需要安装。根据http://buildozer.readthedocs.io/en/latest/installation.html中的安装说明，可以使用以下 Ubuntu 命令下载并安装所有依赖项:
**ahmed-gad@ubuntu:~$ sudo dpkg --add-architecture i386****ahmed-gad@ubuntu:~$ sudo get install build-essential ccache libncurses5:i386 libstdc++6:i386 libgtk2.0-0:i386 libpangox-1.0-0:i386 libpangoxft-1.0-0:i386 libidn11:i386 python2.7 python2.7-dev openjdk-8-jdk unzip zlib1g-dev zlib1g:i386**
可以使用这个命令安装 Buildozer。该命令确保 Buildozer 已安装并升级。
**ahmed-gad@ubuntu:~$ sudo install –upgrade buildozer**
成功安装 Buildozer 后，让我们准备好所有需要的文件，以便成功构建 android 应用程序。
9.正在创建 buildozer.spec 文件
我们的项目结构如图 5 所示。有一个名为 simpleapp 的文件夹，里面放着之前创建的 main.py 文件。Kivy 的美妙之处在于，同样的 Python 文件将在 Android 应用程序中不加修改地使用。但是还有另一个名为 buildozer.spec 的文件，这是构建这个应用程序所必需的。这个文件包含了 Android 应用程序的信息，比如标题和版本。如何创建该文件？
Figure 5. Project structure.
可以使用 buildozer 工具生成 buildozer.spec 文件。将当前工作目录设为应用程序 main.py 文件所在的目录后，发出以下命令:
**ahmed-gad@ubuntu:~/Desktop/simpleapp$ buildozer init**
将会出现一条消息，表明 buildozer.spec 文件已经创建，如图 6 所示。
Figure 6. Generating the buildozer.spec file.
buildozer.spec 文件中 Android 应用的一些重要属性如下:
**[app]****title = Simple Application****package.name = simpleapp****package.domain = org.simpleapp****source.dir = .****source.include_exts = py,png,jpg,kv,atlas****version = 0.1****requirements = kivy****orientation = portrait****osx.python_version = 3****osx.kivy_version = 1.9.1****fullscreen = 0**
例如，title 保存应用程序的标题，source directory 引用应用程序的目录，在这种情况下设置为当前目录、app 版本、Python 和 Kivy 版本等。这些字段位于规范文件的**【app】**部分。你可以在这个链接http://buildozer . readthedocs . io/en/latest/specifications . html查看 app 规范。您还可以编辑规范文件，以更改您认为值得修改的任何字段。
准备好构建 Android 应用程序所需的所有文件后，让我们开始构建它。
10.使用 Buildozer 构建 Android 应用程序
Buildozer 是构建 Android 应用程序的好工具，因为它根据所有需求准备环境，以便成功构建应用程序。这些需求比如 python-for-android 、Android SDK 、 NDK 等等。在 app 目录中，可以使用以下命令构建它:
**ahmed-gad@ubuntu:~/Desktop/simpleapp$ buildozer android release**
图 7 显示了输入命令时的响应。当第一次构建应用程序时，Buildozer 必须下载所有这些依赖项。下载和安装它们需要时间。耐心点。
Figure 7. Building the Kivy project.
该命令执行后，APK 文件将位于项目目录 /simpleapp/下的这个位置。buildozer/Android/platform/build/dists/simple app/bin。APK 的文件可以转移到安卓设备上运行。此外，还可以将 Android 设备连接到机器，使用一个命令构建、部署和运行应用程序，如下所示:
**ahmed-gad@ubuntu:~/Desktop/simpleapp$ buildozer android release deploy run**
图 8 显示了 Android 应用程序的运行。
Figure 8. Running the Android application.
11.参考
小菲，风尘仆仆。使用 Python 在 Kivy: Mobile 中创建应用程序。“奥莱利媒体公司”，2014 年。
https://kivy.org/docs/installation/installation-linux.html
【https://virtualenv.pypa.io/en/stable/
https://kivy.org/docs/guide/architecture.html
https://github.com/kivy/kivy/blob/master/kivy/
http://buildozer.readthedocs.io/en/latest/installation.html
https://buildozer.readthedocs.io/en/stable/quickstart.html
原文可在 LinkedIn 本页面查看:https://www . LinkedIn . com/pulse/python-Android-start-building-kivy-cross-platform-applications-gad
联系作者:
电子邮件:ahmed.f.gad@gmail.com
领英:https://linkedin.com/in/ahmedfgad
用于数据科学的 Python:你可能已经忘记的 8 个概念
掌握 Python、NumPy 和 Pandas 中的小东西
Source: Unsplash
问题是
如果你曾经发现自己在编程时一遍又一遍地查找相同的问题、概念或语法，你并不孤单。
我发现自己经常这样做。
虽然在 StackOverflow 或其他资源上查找东西并不是不自然的，但它确实会使您的速度变慢，并对您是否完全理解这门语言提出质疑。
我们生活在这样一个世界里，似乎随时都有无限量的可访问的免费资源，只需一次搜索就能找到。然而，这可能是福也可能是祸。如果没有得到有效的管理，过度依赖这些资源会养成不良的习惯，这会让你长期落后。
Source: xkcd
就我个人而言，我发现自己多次从类似的讨论线索中提取代码，而不是花时间学习和巩固概念，以便下次我可以自己复制代码。
这种方法是懒惰的，虽然它可能是短期内阻力最小的方法，但它最终会伤害你的成长、生产力和回忆语法的能力。
目标
最近，我一直在 Udemy 上学习一门名为 Python 的在线数据科学课程(哦，天哪，我听起来像 Youtube 上的那家伙)。在本系列的早期讲座中，我想起了在 Python 中执行数据分析时经常忽略的一些概念和语法。
为了一劳永逸地巩固我对这些概念的理解，并为你们节省一些 StackOverflow 搜索，这里有一些我在使用 Python、NumPy 和 Pandas 时经常忘记的东西。
我已经为每个概念提供了一个简短的描述和示例，但是为了您的利益，我还将提供视频和其他资源的链接，以便更深入地探索每个概念。
单行列表理解
每次需要定义某种列表时都要编写一个 for 循环，这很繁琐，幸运的是 Python 有一个内置的方法，只用一行代码就可以解决这个问题。语法可能有点难理解，但是一旦你熟悉了这种技术，你就会经常使用它。
Source: Trey Hunner
看看上面和下面的例子，看看你通常是如何用 for 循环理解列表，而不是用一行简单的代码创建列表，而不需要循环。
x = [1,2,3,4]
out = []
for item in x:
out.append(item**2)
print(out)**[1, 4, 9, 16]**# vs.x = [1,2,3,4]
out = [item**2 for item in x]
print(out)**[1, 4, 9, 16]**
λ函数
是否厌倦了为有限的用例创建一个又一个函数？兰姆达功能来拯救！Lambda 函数用于在 Python 中创建小型、一次性和匿名的函数对象。基本上，他们让你创建一个函数，而不创建函数。
lambda 函数的基本语法是:
lambda arguments: expression
请注意，lambda 函数可以做常规函数能做的一切，只要只有一个表达式。查看下面的简单示例和即将播放的视频，更好地感受 lambda 函数的强大功能:
double = lambda x: x * 2
print(double(5))**10**
贴图和滤镜
一旦掌握了 lambda 函数，学习将它们与 map 和 filter 函数配对会是一个强大的工具。
具体来说，map 接受一个列表，并通过对每个元素执行某种操作将其转换为一个新列表。在这个例子中，它遍历每个元素并将自身乘以 2 的结果映射到一个新的列表。请注意，list 函数只是将输出转换为列表类型。
# Map
seq = [1, 2, 3, 4, 5]
result = list(map(lambda var: var*2, seq))
print(result)**[2, 4, 6, 8, 10]**
filter 函数接受一个列表和一个规则，很像 map，但是它通过将每个元素与布尔过滤规则进行比较来返回原始列表的子集。
# Filter
seq = [1, 2, 3, 4, 5]
result = list(filter(lambda x: x > 2, seq))
print(result)**[3, 4, 5]**
Arange 和 Linspace
要创建快速简单的 Numpy 数组，只需看看 arange 和 linspace 函数就行了。每一种都有其特定的用途，但这里的吸引力(而不是使用范围)是它们输出 NumPy 数组，这通常更容易用于数据科学。
Arange 返回给定间隔内间隔均匀的值。除了起点和终点，如果需要，还可以定义步长或数据类型。请注意，停止点是一个“截止”值，因此它不会包含在数组输出中。
# np.arange(start, stop, step)
np.arange(3, 7, 2)**array([3, 5])**
Linspace 非常相似，但略有不同。Linspace 返回指定间隔内间隔均匀的数字。因此，给定一个起点和终点，以及一些值，linspace 将在一个 NumPy 数组中为您平均分配它们。这对于数据可视化和绘图时声明轴特别有帮助。
# np.linspace(start, stop, num)
np.linspace(2.0, 3.0, num=5)**array([ 2.0, 2.25, 2.5, 2.75, 3.0])**
轴的真正含义是什么
您可能在删除 Pandas 中的列或对 NumPy 矩阵中的值求和时遇到过这种情况。如果没有，那么在某个时候你肯定会的。现在让我们以删除一列为例:
df.drop('Row A', axis=0)
df.drop('Column A', axis=1)
我不知道我写了多少遍这行代码，才知道为什么要声明 axis 是什么。正如您可能从上面推导出的那样，如果您想要处理列，请将 axis 设置为 1，如果您想要行，请将其设置为 0。但这是为什么呢？我最喜欢的推理，或者至少我记得是这样的:
df.shape**(# of Rows, # of Columns)**
从 Pandas dataframe 调用 shape 属性会返回一个元组，第一个值表示行数，第二个值表示列数。如果你想一想这在 Python 中是如何索引的，行是 0，列是 1，就像我们如何声明轴值一样。很疯狂，对吧？
串联，合并，并连接
如果您熟悉 SQL，那么这些概念对您来说可能会容易得多。总之，这些函数本质上只是以特定方式组合数据帧的方法。很难跟踪哪一个在哪个时间使用是最好的，所以让我们来回顾一下。
Concat 允许用户将一个或多个数据帧附加到彼此的下方或旁边(取决于您如何定义轴)。
Merge 将用作主键的特定公共列上的多个数据帧组合在一起。
Join 与 merge 非常相似，它组合了两个数据帧。但是，它基于索引而不是某个指定的列来联接它们。
查看优秀的熊猫文档，了解具体的语法和更具体的例子，以及您可能遇到的一些特殊情况。
熊猫申请
把 apply 想象成一个地图函数，但是是为熊猫数据帧或者更具体地说，为系列制作的。如果您不太熟悉，Series 在很大程度上与 NumPy 数组非常相似。
Apply 根据您的指定将函数发送到列或行中的每个元素。您可能会想象这有多有用，特别是对于格式化和操作整个 DataFrame 列的值，而根本不需要循环。
数据透视表
最后但肯定不是最不重要的是数据透视表。如果您熟悉 Microsoft Excel，那么您可能在某些方面听说过数据透视表。Pandas 内置的 pivot_table 函数创建一个电子表格样式的数据透视表作为数据帧。请注意，数据透视表中的级别存储在结果数据帧的索引和列的 MultiIndex 对象中。
包扎
暂时就这样了。我希望这些概述能够有效地唤起您对使用 Python 进行数据科学时经常遇到的重要但有些棘手的方法、函数和概念的记忆。就我个人而言，我知道即使是写下这些并试图用简单的术语解释它们的行为也帮了我很多。
感谢阅读！请随意查看我下面的一些类似文章，并订阅我的时事通讯中的 和 以获得有趣的链接和新内容。
你可以在 Medium 上关注我更多类似的帖子，也可以在 Twitter 上找到我。想了解更多关于我和我在做什么，请查看我的网站。
用于数据科学和机器学习的 Python 训练营回顾
热门在线课程的思考和收获
Python for Data Science and Machine Learning Bootcamp
介绍
我今年夏天来到这里，最初的目标是回顾与使用 Python 进行数据科学相关的基本概念。我认为实现这一目标的最佳方式是通过在线课程和独立的并行项目。根据我的经验，我发现这种设置给了我适当的结构和灵活性来最有效地学习。
幸运的是，许多数据科学家已经承担了分析各种在线课程利弊的任务，所以我所要做的就是查看信息，并决定哪一个最适合我。最值得注意的是， David Venturi 在下面链接了几个非常好的帖子，就是为了做这个而设计的。
[## 我根据数千个数据点，对互联网上的每一门数据科学导论课程进行了排名
一年前，我退出了加拿大最好的计算机科学项目之一。我开始创建自己的数据…
medium.freecodecamp.org](https://medium.freecodecamp.org/i-ranked-all-the-best-data-science-intro-courses-based-on-thousands-of-data-points-db5dc7e3eb8e) [## 互联网上最好的数据科学课程，根据您的评论排名
一年半前，我退出了加拿大最好的计算机科学项目之一。我开始创造我自己的…
medium.freecodecamp.org](https://medium.freecodecamp.org/the-best-data-science-courses-on-the-internet-ranked-by-your-reviews-6dc5b910ea40)
经过一些思考和更多的研究，我终于能够将我的选择缩小到 Udemy 上的一门热门课程，名为Python for Data Science and Machine Learning boot camp。本课程分为几个小部分，涉及从数据分析到实现机器学习算法，再到开始使用 Spark 和 TensorFlow 的方方面面。下面你会发现一个更令人兴奋的正式摘录，摘自课程概述:
您准备好开始成为数据科学家的道路了吗！
本综合课程将指导您学习如何使用 Python 的强大功能来分析数据，创建漂亮的可视化效果，以及使用强大的机器学习算法！
这一综合课程可与通常花费数千美元的其他数据科学训练营相媲美，但现在您只需花费一小部分成本就可以了解所有信息！拥有超过 100 场高清视频讲座和每场讲座的详细代码笔记本这是 Udemy 上最全面的数据科学和机器学习课程之一！
我们将教你如何用 Python 编程，如何创建令人惊叹的数据可视化，以及如何用 Python 使用机器学习！
平均来说，在过去的几个星期里，我每天都要完成一个部分，我会在接下来的几天内完成。虽然这种经历在我脑海中仍然记忆犹新，但我想我应该为那些关注 Python 数据科学课程的人写一篇关于这门课程的全面评论。如果你想了解课程本身，请点击下面的链接:
了解如何使用 NumPy、Pandas、Seaborn、Matplotlib、Plotly、Scikit-Learn、机器学习、Tensorflow 等等！
www.udemy.com](https://www.udemy.com/python-for-data-science-and-machine-learning-bootcamp/learn/v4/overview)
好人
首先也是最重要的一点，我喜欢整个课程中的讲座。它们大概是完美的长度，通常相当简洁，尽管我建议以至少 1.25 倍的速度观看，因为有时事情会移动得有点慢。这些概念得到了很好的解释，尤其是在早期关于 NumPy 和 Pandas 的数据分析讲座中。道具交给教官，荷西给那个。
我还认为课程的结构非常好。从理论转向观察其他人将概念应用到实践中，并最终进行回顾和修正，这似乎是一条可行之路。
涵盖的主题的广度也令人印象深刻，尤其是针对初级和中级数据科学家的课程。该课程在某种程度上触及了你能想象到的一切，从 Python 基础到 NLP 再到深度学习。
Overview of topics covered
最后，课程中包含的 Jupyter 笔记本和解决方案概述是我最喜欢的部分。我发现很难有动力去完成通过网络课程布置的作业，但这里的情况并非如此。我喜欢解决练习题，并渴望事后查看解答笔记本和复习讲座。
坏事
尽管如此，我还是对这门课有一些批评。我发现，尽管花了一半的时间在机器学习算法上，但内容并不深入。公平地说，我认为这很大程度上是因为这个课程是针对初学者的——这一点在概述中有明确说明。
然而，我发现在第三或第四个 ML 部分之后，用最小理论应用不同的算法变得重复。就我的目的而言，我希望看到一些相同的旧的 scikit-learn 调用被更基本的 ML 理论和概念所取代。
最后，值得一提的是，这门课程的费用约为 10 美元。这是非常合理的，我没有问题咳出多余的零钱。话虽如此，我也相信你可以从内容创作者那里免费找到同等质量甚至更好的在线内容，比如像 Siraj 和sendex等。
丑陋的
这与这门特定的课程没有任何关系，但是可能值得一提。在过去几年中，Udemy 作为一个组织受到了一些抵制。几个帖子和视频已经进入了这个话题，像这个来自平台上的一位前讲师，最近，下面链接的视频来自 Youtube 上一个受欢迎的内容提供商。
就我个人而言，这是我在 Udemy 上的第一次体验，我对这个平台没有任何问题，但有一些有趣的观点值得你下次注册课程时考虑。
最终外卖
总的来说，这门课做得非常好。尽管有付费墙，还是有超过 100，000 名学生注册了这门课程。对于数据科学的初学者来说，它是一个很好的起点，对于更有经验的从业者来说，它是一个有效的快速回顾。
然而，如果你真的想要一个强大的机器学习基础，我建议将这门课程与一门更理论化的课程配对，比如吴恩达在 Coursera 上广受好评的机器学习课程。
最后，关于付费墙，我非常有信心，如果你足够努力的话，在网上可以免费获得同等的，甚至更好的资料。当您选择参加本课程时，您实际上是在为购买在线课程所带来的结构和责任付费。对我来说，这个选择是有意义的，最终，这个课程证明是时间和金钱的可靠投资。
最终评分:4/5 星
感谢阅读！如果你喜欢这篇文章，请继续向鼓掌按钮展示你的爱。对更多的帖子感兴趣吗？请务必关注我并订阅下面的我的简讯以接收任何新内容。想了解更多关于我和我在做什么，请查看我的网站。
用于数据科学的 Python:第 1 部分
Python 有许多应用——web 开发、桌面 GUI、软件开发、商业应用和科学/数字计算。在本系列中，我们将重点关注如何在数据科学中使用 Python 中的数值计算。
在本模块中，我们将了解 Python 的以下基本功能:
1.Python 函数
2.数据类型和序列
3.日期和时间
4.希腊字母的第 11 个
5.地图
6.过滤器
7.减少
8.活力
9.For 循环
10.列表理解
1。Python 函数
函数是一段代码，只有被调用时才会运行。您可以将数据(称为参数)传递给函数。让我们写一个函数将两个数相乘。
*#multiply two numbers using a python function* **def** multiply(x,y):
z = x*y
**return** z#call the function to multiply the numbers 2 and 3
multiply(2,3)
输出:6
2。Python 数据类型和序列
Python 有内置的数据类型来存储数字和字符数据。让我们来看看几种常见的类型。
type(' My name is Rohan')
输出:str
type(1)
输出:int
type(1.0)
输出:浮点
type(**None**) #None signifies 'no value' or 'empty value'
输出:NoneType
type(multiply) #multiply is a function we created previously
输出:功能
现在，让我们看看如何存储数字和字符的列表，以及如何执行一些基本的操作。
i .元组:它们是不可变的数据结构，不像列表那样不能被改变
a = (1,2,3,4)
type(a)
输出:元组
二。列表:它们是可变对象
b = [1,2,3,4]
type(b)
输出:列表
让我们给上面创建的列表 b 添加一个数字。
b.append(2.2) *#append to list using this function*
print(b)
输出:[1，2，3，4，2.2]
遍历列表并打印数字
**for** number **in** b: *#looping through list*
print(number)
输出:
1
2
3
4
2.2
现在，让我们连接两个列表
[1,2,3] + [1,'abc','de'] *#concatenate lists*
输出:[1，2，3，1，’ abc ‘，’ de’]
创建包含重复数字的列表。
[1,2]*3 *#repeat lists*
输出:[1，2，1，2，1，2]
检查您正在搜索的对象是否在列表中。
3 **in** b *#in operator to check if required object is in list*
输出:真
将列表解包到单独的变量中。
a,b = ('abc','def')
print(a)
print(b)
输出:abc
def
iii。字符串:字符串存储角色对象
x = 'My name is Rohan'
从字符串中访问字符:
x[0] *#Access first letter*
输出:‘M’
x[0:2] *#Accesses two letters*
输出:“我的”
x[:-1] *#Accesses everything except last letter*
输出:‘我叫 Roha’
x[10:] *#returns all the characters from 10th position till end*
输出:“罗汉”
现在，让我们连接两个字符串。
first = 'Rohan'
last = 'Joseph'
Name = first + ' ' + last *#string concatenation* print(Name)
输出:罗汉约瑟夫
使用“拆分”功能拆分前一个字符串中的单词。
Name.split(' ') *#split the words in a string using split function*
输出:[‘罗汉’，‘约瑟’]
只显示第一个单词。
Name.split(' ')[0] *#Show the first word*
输出:“罗汉”
现在，只显示字符串中的第二个单词
Name.split(' ')[1] *#Show the second word*
输出:“约瑟夫”
要将数字数据连接为字符串，请先将数字转换为字符串
*#for concatenation convert objects to strings*
'Rohan' + str(2)
输出:罗汉 2
四。字典:字典是一个集合，它不是有序的，而是有索引的——它们有键和值。
c = {"Name" : "Rohan", "Height" : 176}
type(c)
输出:字典
打印包含在字典中的数据
print(c)
输出: { ‘姓名’:‘罗汉’，‘身高’:176}
基于关键字访问字典值
c['Name'] *#Access Name*
输出:《罗汉》
c['Height']
输出:176
打印字典中的所有关键字
*#print all the keys*
**for** i **in** c:
print(i)
输出:名称
高度
打印字典中的所有值
**for** i **in** c.values():
print(i)
输出:罗汉
176
遍历字典中的所有条目
**for** name, height **in** c.items():
print(name)
print(height)
输出:名称
罗汉
高度
176
3.Python 日期和时间
以下模块帮助我们以简单的方式操作日期和时间变量。
**import** **datetime** **as** **dt**
**import** **time** **as** **tm**
以秒为单位打印当前时间(从 1970 年 1 月 1 日开始)
tm.time() *#print current time in seconds from January 1, 1970*
输出:1532483980.5827992
*#convert timestamp to datetime* dtnow = dt.datetime.fromtimestamp(tm.time())
dtnow.year
输出:2018
获取今天的日期
today = dt.date.today()
today
输出:datetime.date(2018，7，30)
从今天的日期中减去 100 天
delta = dt.timedelta(days=100)
today - delta
输出:datetime.date(2018，4，21)
4.地图功能
Map function 将给定函数应用于给定序列的每一项后，返回结果列表。例如，让我们找出两对列表之间的最小值。
a = [1,2,3,10]
b = [5,6,2,9]
c = map(min,a,b) *#Find the minimum between two pairs of lists***for** item **in** c:
print(item) *#print the minimum of the pairs*
输出:1
2
2
9
5.λ函数
Lambda 函数用于在 Python 中创建小型、一次性和匿名的函数对象。
function = **lambda** a,b,c : a+b+c *#function to add three numbers* function(2,2,3) *#call the function*
输出:7
6.滤波函数
Filter 提供了一种简单的方法来过滤掉列表中的所有元素。Filter(语法:filter(function，list))需要一个函数作为它的第一个参数，为此可以使用 lambda 。例如，让我们从列表中只过滤掉大于 5 的数字
x = [1,2,3,4,5,6,7,8,9] #create a list
x2 = filter(lambda a : a>5, x) #filter using filter functionprint(list(x2))
输出:[6，7，8，9]
7.减少功能
Reduce 是一个在列表上执行一些计算并返回结果的函数。它对列表中的连续值对应用滚动计算。举个例子，让我们计算一个列表中所有数字的乘积。
from functools import reduce #import reduce function
y = [1,2,3,4,5] #create list
reduce(lambda a,b : a*b,y) #use reduce
输出:120
8。压缩功能
Zip 函数返回一个元组列表，其中第 i 个元组包含来自每个序列的第 i 个元素。让我们看一个例子。
a = [1,2,3,4] #create two lists
b = [5,6,7,8]c = zip(a,b) #Use the zip function
print(list(c))
输出:[(1，5)，(2，6)，(3，7)，(4，8)]
如果 zip 函数中使用的序列不相等，则返回的列表的长度将被截断为最短序列的长度。
a = [1,2] *#create two lists*
b = [5,6,7,8]c = zip(a,b) *#Use the zip function*
print(c)
输出:[(1，5)，(2，6)]
9.For 循环
当您有一个代码块需要重复固定次数时，通常使用 For 循环。
让我们使用 for 循环来打印从 1 到 100 的偶数列表。
*#return even numbers from 1 to 100*
even=[]
**for** i **in** range(100):
**if** i%2 ==0:
even.append(i)
**else**:
**None**print(even) #print the list
输出:【0，2，4，6，8，10，12，14，16，18，20，22，24，26，28，30，32，34，36，38，40，42，44，46，48，50，52，54，56，58，60，62，64，66，68，70，72，74，76，78，80
10.列表理解
列表理解提供了一种更简单的创建列表的方法。继续同一个例子，让我们使用列表理解创建一个从 1 到 100 的偶数列表。
even = [i for i in range(100) if i%2==0]
print(even)
输出:【0，2，4，6，8，10，12，14，16，18，20，22，24，26，28，30，32，34，36，38，40，42，44，46，48，50，52，54，56，58，60，62，64，66，68，70，72，74，76，78，80
我们看到的特性有助于理解用于数值计算的 Python 的基本特性。除了这些内置函数，还有其他库，如 Numpy 和 Pandas(我们将在 即将发布的文章 ) 中查看)，它们在数据科学中被广泛使用。
资源:
在 LinkedIn 上连接，并查看 Github(如下)以获得完整的笔记本。
[## rohanjoseph 93/用于数据科学的 Python
Python-for-data-science -用 Python 学习数据科学
github.com](https://github.com/rohanjoseph93/Python-for-data-science/blob/master/Python%20for%20Data%20Science%20-%20Part%201.ipynb)
用于数据科学的 Python:第 2 部分
在 Python for data science 系列的第 1 部分中，我们看了 Python 中数值计算的基本内置函数。在这一部分，我们将看看 Numpy 库。
Numpy 是 Python 中科学计算的基础包。它提供了对大型多维数组的支持，也提供了对这些数组进行操作的高级数学函数。
很好，让我们看看如何使用 Numpy 库进行基本的数组操作。
Numpy 图书馆
首先，我们需要在 Python 中导入 numpy。
import numpy as np
让我们创建一个 numpy 数组。
np.array([1,2,3])
输出:数组([1，2，3])
现在，让我们创建一个多维数组。
a = np.array([[1,2,3],[4,5,6]])
a
输出:数组([[1，2，3]，
[4，5，6])
检查形状(数组的行和列)。
a.shape
输出:(2，3)
在 1 到 30 之间创建一个间距均匀的数组，差值为 2。
b = np.arange(1,30,2)
b
输出:数组([ 1，3，5，7，9，11，13，15，17，19，21，23，25，27，29])
将上面的数组重新塑造成想要的形状。
b.reshape(5,3)
输出:数组([[ 1，3，5]，
，【7，9，11】，
，【13，15，17】，
，【19，21，23】，
，【25，27，29】)，
在区间 1 和 5 之间生成一个等间距列表。(在这里花一分钟来理解‘Lin space’和‘arange’之间的区别)
c = np.linspace(1,5,20)
c
输出:数组(【1。，1.21052632，1.42105263，1.63157895，1.84210526，
2.05263158，2.26315789，2.4736848，2.684842，2.6843，2.89473684，
3.105266，3.])
现在，就地改变数组的形状(“resize”功能就地改变数组的形状，不同于“reshape”)
c.resize(5,4)
c
输出:数组([[ 1。，1.21052632，1.42105263，1.63157895]，
，【1.84210526，2.05263158，2.26315789，2.47368421】，
，【2.68421053，2.89473684，3.10526316，3.37】。]])
创建一个所有元素都为 1 的数组。
d = np.ones((2,2))
d
输出:数组([[ 1。, 1.]，
【1。, 1.]])
创建一个用零填充的数组。
e = np.zeros((3,3))
e
输出:数组([[ 0。, 0., 0.]，
【0。, 0., 0.]，
【0。, 0., 0.]])
创建对角线值= 1 的对角矩阵
f = np.eye(2)
f
输出:数组([[ 1。, 0.]，
【0。, 1.]])
仅从数组中提取对角线值。
np.diag(f)
输出:数组(【1。, 1.])
创建由重复列表组成的数组
g = np.array([1,2,3]*5)
g
输出:数组(【1，2，3，1，2，3，1，2，3，1，2，3，1，2，3，1，2，3】)
现在，使用 repeat 函数将数组中的每个元素重复 n 次。
np.repeat([1,2,3],3)
输出:数组([1，1，1，2，2，2，3，3，3])
生成两个所需形状的数组，用 0 到 1 之间的随机值填充。
g = np.random.rand(2,3)
print(g)
h = np.random.rand(2,3)
print(h)
输出:
[[0.61631842 0.28352987 0.56174714]
【0.54302204 0.47257786 0.21923943]]
[[0.57233679 0.22981962 0.15870184]
【0.52548056 0.81495971 0.22014512]]
垂直堆叠上面创建的两个数组
i = np.vstack([h,g])
i
输出:
数组([[ 0.57233679，0.22981962，0.15870184]，
【0.52548056，0.81495971，0.22014512】，
，【0.61631842，0.28352987，0.56174714]，【T30
现在，让我们把它们水平堆叠起来。
j = np.hstack([h,g])
j
输出:
数组([[ 0.57233679，0.22981962，0.15870184，0.61631842，0.28352987，
0.56174714]，
[ 0.52548056，0.81495971，0.22014512，0.544512
很好，现在让我们执行一些数组操作。首先让我们创建两个随机数组
k = np.random.rand(2,2)
l = np.random.rand(2,2)
print(k)
print(l)
输出:
[[0.02430146 0.14448542]
【0.54428337 0.40332494]]
[[0.77574886 0.08747577]
【0.51484157 0.92319888]]
让我们做元素加法。
m = k + l
m
输出:数组([[ 0.80005032，0.23196118]，
，【1.05912494，1.32652381])，
元素减法。
n = k-l
n
输出:数组([[-0.75144739，0.05700965]，
，【0.02944179，-0.51987394])
让我们对每个元素进行 2 次幂运算。
p = k**2
p
输出:数组([[ 0.00059056，0.02087604]，
，【0.29624438，0.162671 ]])
现在，让我们执行两个数组 k 和 l 的点积，而不是元素运算。
q = k.dot(l)
q
输出:数组([[ 0.09323893，0.13551456]，
，【0.62987564，0.41996073]])
让我们创建一个新的数组并转置它。
a = np.array([[1,2],[3,4]])
a
输出:
数组([[1，2]，
，[3，4])
a.T
输出:
数组([[1，3]，
，[2，4])
现在，检查数组中元素的数据类型。
a.dtype
输出:dtype(‘int32’)
更改数组的数据类型。
b = a.astype('f')
b.dtype
输出:dtype(‘float32’)
现在，让我们看看数组中的一些数学函数，从数组的 sum 开始。
c = np.array([1,2,3,4,5])
c.sum()
输出:15
数组元素的最大值。
c.max()
输出:5
数组元素的平均值
c.mean()
输出:3
现在，让我们检索数组最大值的索引。
c.argmax()
输出:4
c.argmin()
输出:0
创建一个由前十个整数的平方组成的数组。
d = np.arange(10)**2
d
输出:数组([ 0，1，4，9，16，25，36，49，64，81]，dtype=int32)
使用 index 访问上述数组中的值。
d[2]
输出:4
d[1:5]
输出:数组([ 1，4，9，16]，dtype=int32)
使用负号反向访问变量。
d[-1:]
输出:数组([81]，dtype=int32)
现在，根据步长访问数组的某些元素。
d[1:10:2] *#d[start:stop:stepsize]*
输出:数组([ 1，9，25，49，81]，dtype=int32)
创建多维数组
e = np.arange(36)
e.resize(6,6)
e
输出:数组([[ 0，1，2，3，4，5]，
，
，【12，13，14，15，16，17】，
，【18，19，20，21，22，23】，
，【24，25，26，27，28，29】，
，【30，30
访问第二行和第三列
e[1,2]
输出:8
访问第二行和第 3 至 7 列。请注意，行和列的编号从 0 开始。
e[1, 2:6]
输出:数组([ 8，9，10，11])
选择第 2 行之前的所有行以及除最后一列之外的所有列
e[:2,:-1]
输出:数组([[ 0，1，2，3，4]，
[ 6，7，8，9，10])
从数组中选择大于 20 的值。
e[e>20]
输出:数组(【21，22，23，24，25，26，27，28，29，30，31，32，33，34，35】)
如果元素值大于 20，则将数组元素的值赋为 20。
e[e>20] = 20
e
输出:数组([[ 0，1，2，3，4，5]，
，【6，7，8，9，10，11】，
，【12，13，14，15，16，17】，
，【18，19，20，20，20】，
，【20，20，20，20】，
要将一个数组复制到另一个变量上，请始终使用 copy 函数。
f = e.copy()
f
输出:数组([[ 0，1，2，3，4，5]，
，【6，7，8，9，10，11】，
，【12，13，14，15，16，17】，
，【18，19，20，20，20】，
，【20，20，20，20】，
用一组 1 到 10 之间的随机整数创建一个数组。将数组指定为 4*4 的形状
g = np.random.randin(1,10,(4,4))
g
输出:数组([[9，7，1，4]，
[1，4，3，6]，
[2，5，5，1]，
[2，2，9，9])
很好，我们已经了解了在 Numpy 中创建、访问和操作数组。在系列的下一部分，我们将会看到一个建立在 Numpy 图书馆基础上的图书馆——熊猫图书馆。Pandas 是一个库，它使得 Python 中的数据操作和分析更加容易。它为数字表和时间序列提供数据结构和操作。
在 LinkedIn 上连接，并查看 Github(如下)以获得完整的笔记本。
[## rohanjoseph 93/用于数据科学的 Python
Python-for-data-science -用 Python 学习数据科学
github.com](https://github.com/rohanjoseph93/Python-for-data-science/blob/master/Python%20for%20Data%20Science%20-%20Part%202.ipynb)
用于数据科学的 Python:第 3 部分
在“Python 用于数据科学”系列的前几部分中，我们研究了:
第 1 部分:Python 中的基本内置特性，如函数、数据类型、日期/时间、映射、归约、过滤、lambda 函数等。
第 2 部分:用于创建、访问和操作数组的 Numpy 库
在本文中，我们将关注最广泛使用的数据分析库——Pandas。它的名字是怎么来的？熊猫这个名字来源于潘埃尔达塔。面板数据由对相同个体的多个时间段的观察组成。
Pandas 提供易于使用的数据结构和数据分析工具来创建和操作数据集。我们将会看到熊猫的以下特征:
- 系列和数据框架
- 查询系列
- 读写文件
- 索引
- 合并
- 聚集
- 过滤
和往常一样，第一步是导入库。让我们导入熊猫和 numpy 库。
import pandas as pd
import numpy as np
1.熊猫系列
系列是一维数据结构，可以保存任何数据类型，如整数和字符串。它类似于 Python 中的列表。
首先，让我们创建一个列表
name = ['Rohan','Joseph','Rohit']
name
输出:[‘罗汉’，‘约瑟夫’，‘罗希特’]
现在，让我们将同一个列表转换成熊猫系列。
name = pd.Series(name)
name
输出:
0 罗汉
1 约瑟夫
2 罗希特
dtype:object
我们可以观察到熊猫系列显示了指数以及每个位置的值。同样，让我们创建一个字典，并将其转换为熊猫系列。
sport = {'cricket' : 'India',
'soccer' : 'UK',
'Football' : 'USA'}sport = pd.Series(sport)
sport
输出:
板球印度
足球英国
足球美国
d 类型:对象
字典的“键”成为序列中的索引，字典的“值”保持为序列的值。让我们通过查询一个熊猫系列来进一步理解这一点。
2.查询熊猫系列
让我们继续上面创建的同一个系列“运动”。让我们访问系列中的第三个值
sport.iloc[2]
输出:“美国”
“iloc”用于根据值的整数位置选择值。现在，让我们使用值的索引来访问同一个值。
sport.loc['Football']
输出:“美国”
太好了，让我们把一系列的值加起来
a = pd.Series([1,2,3])
np.sum(a) #np sum function is a faster than the in-built function
输出:6
向现有系列添加数据。
a = pd.Series([1,2,3])
a.loc[‘City’] = ‘Delhi’
输出:
**0 1
1 2
2 3
城市德里
d 类型:对象 **
让我们创建一个具有相同索引的多个值的序列。
b = pd.Series([‘a’,’b’,’c’,’d’],index=[‘e’,’e’,’e’,’e’])
b
输出:
e a
e b
e c
e d
d type:object
3.熊猫数据框
Dataframe 是具有不同数据类型(字符串、整数、日期等)的列的二维数据结构。).
让我们在熊猫中创建一个数据框架。我们正在创建一个包含三列的数据集——姓名、职业和年龄。
df1 = pd.DataFrame([{'Name' : 'John', 'Occupation' : 'Data Scientist', 'Age' : 25},{'Name' : 'David', 'Occupation' : 'Analyst', 'Age' : 28},{'Name' : 'Mark', 'Occupation' : 'Teacher', 'Age' : 30}],index=['1','2','3'] )df1
输出:
现在，让我们通过追加两个系列来创建一个数据帧。
s1 = pd.Series({'Name' : 'Rohan',
'Age':'25'})
s2 = pd.Series({'Name' : 'Rohit',
'Age' : 28})]
df1 = pd.DataFrame([s1,s2],index=['1','2'])
df1
输出:
4.读写文件
让我们看看如何读取 csv 文件。
iris = pd.read_csv('C:\\Users\\rohan\\Documents\\Analytics\\Data\\iris.csv')
让我们看看文件的前 5 行。
iris.head()
输出:
将文件保存回本地目录。
iris.to_csv('iris2.csv')
5.索引数据帧
检查上一步导入的 iris 数据集的索引。
iris.index.values
输出:
现在，将索引改为物种名称。“名称”列将显示为索引，并替换先前的索引。
b = iris.set_index('Name')
b.head()
输出:
要恢复到以前的索引，只需按如下方式重置索引。
c = b.reset_index()
c.index.values
输出:
6.合并数据帧
让我们再次导入虹膜数据，并将其与另一个数据集合并。
df1 = pd.read_csv('iris.csv')
df1.head()
输出:
创建一个新的 dataframe 以与此合并。
df2 = pd.DataFrame([{'Name' : 'setosa', 'Species' : 'Species 1'},
{'Name':'versicolor','Species':'Species 2'},
{'Name':'virginica','Species':'Species 3'}])
df2
输出:
通过执行一个内部连接，在名称列上合并上述两个数据集**。**
df3 = pd.merge(df1,df2,how='inner',left_on='Name',right_on='Name')
df3.head()
输出:
7.聚合函数
让我们聚集 iris 数据集中的几列。首先，让我们找出每个物种的平均萼片长度。
df1.groupby('Name')['SepalLength'].mean()
输出:
现在，让我们按物种找出所有数字列的平均值。
df1.groupby('Name')[['SepalLength','SepalWidth','PetalLength','PetalWidth']].mean()
输出:输出:
而不是找到所有列的平均值；让我们对一列(萼片长度)取平均值，对另一列(萼片宽度)求和
a=df1.groupby('Name').agg({'SepalLength':'mean','SepalWidth':'sum'})
a
输出:输出:
让我们重命名这些列。
a.rename(columns={'SepalLength':'Avg_SepalLength','SepalWidth':'Sum_SepalWidth'})
输出:
8.过滤数据帧
让我们再一次导入 iris 数据集，并执行操作来划分数据集的子集。首先，让我们对萼片长度大于 7 厘米的数据进行分组。
iris = pd.read_csv(‘iris.csv’) #import file
a = iris[(iris.SepalLength>7)]
a.head()
输出:
现在，让我们根据两个条件对数据进行子集划分。
b = iris[(iris.SepalLength>5) & (iris.PetalLength>6)]
b.head()
输出:
通过对“名称”列进行筛选来对数据进行子集划分。
c = iris[iris['Name']=='versicolor']
c.head()
再次过滤姓名列，但过滤两个姓名。
d = iris[iris['Name'].isin(['virginica','versicolor'])]
d.head()
输出:
我们在这篇文章中看到的是在数据科学中使用的 Pandas 中最常用的功能，尽管还有更多功能值得了解，如广播、数据透视表、多索引和可视化。在本系列的下一部分中，我们将继续我们的旅程，看看我们如何将 Pandas 与其他功能结合起来操作数据。
在 LinkedIn 上连接，并查看 Github(如下)以获得完整的笔记本。
[## rohanjoseph 93/用于数据科学的 Python
Python-for-data-science -用 Python 学习数据科学
github.com](https://github.com/rohanjoseph93/Python-for-data-science/blob/master/Python%20for%20Data%20Science%20-%20Part%203.ipynb)
用于数据科学的 Python:第 4 部分
在 Python for data science 系列文章的第 3 部分中，我们查看了 pandas 库及其最常用的功能——读写文件、索引、合并、聚合、过滤等。在这一部分中，我们将继续深入研究 Pandas 库，看看它如何与其他 Python 函数一起用于查询数据帧。
让我们从导入所有必需的库开始。
import pandas as pd
import os
import numpy as np
现在，设置工作目录并导入 iris 数据集。
os.chdir('C:\\Users\\rohan\\Documents\\Analytics\\Data')
a = pd.read_csv('iris.csv')
a.head()
输出:
1。数字列的描述性统计
总结(平均值、标准偏差、最小值、最大值等。)使用 describe 函数的数据集的数字列。
a.describe()
输出:
2。基于条件创建列
让我们创建一个名为’ SepalLength_Size’ 的新列，如果萼片长度≥ 5，则包含“高”，如果萼片长度< 5，则包含“低”。
有许多方法可以执行上述任务。让我们来看看四种不同的方法。
- 首先，让我们通过使用 np.where 函数来执行这个任务。
a['SepalLength_Size'] = np.where(a['SepalLength']>=5,'High','Low')
a.head()
输出:
2.现在，使用列表理解(如果你忘了那是什么，在第一部分中检查一下)来完成同样的任务。此外，列表理解通常比所有其他方法更快。
a['SepalLength_Size'] = ['High' if x >= 5 else 'Low' for x in a['SepalLength'] ]
输出:
3.现在，让我们使用 pandas dataframe 中的**‘assign’**函数创建列。
def size(row_number):
if row_number["SepalLength"] >=5:
return 'High'
else:
return 'Low'a = a.assign(SepalLength_Size=a.apply(size, axis=1))a.head()
输出:
4.最后，让我们使用 lambda 函数。
a['SepalLength_Size'] = a['SepalLength'].map( lambda x: 'High' if x >= 5 else 'Low')
输出:
3.列的唯一值
a['Name'].unique()
输出:
仅获取“名称”列的唯一值的数量。
a['Name'].nunique()
输出: 3
4。十字页签(类似 Excel 中的透视表)
此函数用于查找两个或多个因子的简单交叉列表。让我们使用列“Name”和“SepalLength_Size”(我们创建的新列)，看看它是如何工作的。
pd.crosstab(a['Name'],a['SepalLength_Size'])
输出:输出:
上面的十字标签提供了每种组合的行数，例如，有 30 个具有高萼片长度的刚毛藻种。
让我们再做一次交叉制表，找出每个桶中萼片的平均长度。
pd.crosstab(a['Name'],a['SepalLength_Size'],values=a['SepalLength'],aggfunc=np.mean)
5.排序值
让我们按“萼片长度”对数据进行分类。
a.sort_values('SepalLength')
输出:输出:
首先按“名称”排序(升序)，然后按“萼片长度”排序(降序)。
a.sort_values(['Name','SepalLength'],ascending=[True,False])
输出:
检查所有列的数据类型
6。检查列数据类型
a.dtypes
输出:
7.宁滨数字列
在 iris 数据集中创建一个新列来存储“萼片长度”。我们可以使用“剪切”功能来执行此操作。
bins = [0, 1, 2, 3, 4, 5,6,7]
a[‘bins’] = pd.cut(a[‘SepalLength’], bins)
输出:
现在，使用“value_counts”函数计算每个存储桶下有多少行。
输出:
这涵盖了在数据科学中经常使用的大部分熊猫函数。在接下来的部分中，我们将会看到 Python 中的可视化和假设检验。
在 LinkedIn 上连接，并查看 Github(如下)以获得完整的笔记本。
[## rohanjoseph 93/用于数据科学的 Python
Python-for-data-science -用 Python 学习数据科学
github.com](https://github.com/rohanjoseph93/Python-for-data-science/blob/master/Python%20for%20data%20science%20-%20Part%204.ipynb)
面向金融的 python:Dash by Plotly
在 Dash by Plotly 中使用交互式图表扩展 Jupyter 笔记本股票投资组合分析。
By Carlos Muza on Unsplash.
利用 Python 进行股票投资组合分析的第 2 部分。
在 Jupyter notebook 中构建这个初始过程的过程中，我学到了很多东西，我还发现写一篇文章非常有帮助，这篇文章浏览了笔记本，解释了代码，并讲述了我在每个可视化背后的想法。这篇后续文章将比前一篇更短，目的也更直接。虽然我不断发现我创建的笔记本有助于跟踪我的股票投资组合，但我一直打算学习并整合一个用于构建分析仪表板/网络应用程序的Python框架。对我来说，最重要的用例之一是能够选择特定的位置和时间框架，然后动态地评估每个位置的相对性能。将来，我很可能会将此评估案例扩展到我不拥有但正在考虑收购的职位。在今年剩下的时间里，我希望通过学习Flask，使用Heroku部署应用程序，以及理想情况下开发某种类型的数据管道来自动提取和加载最终 web 应用程序的新数据，来进一步加深我对构建 web 应用程序的理解。虽然我仍然处于这个过程的早期，在这篇文章中，我将讨论我上次讨论的笔记本的扩展，以及我使用Dash by Plotly，又名Dash的初始开发。
阴谋地破折号。
如果你已经阅读或参考了第 1 部分，你会发现一旦你创建了主数据框架，你就使用Plotly来生成评估相对于标准普尔 500 指数的投资组合表现的可视化。Plotly 是一个非常丰富的库，相对于其他 Python 可视化库如Seaborn和Matplotlib，我更喜欢使用Plotly来创建可视化。在此基础上，我的最终目标是为我的投资组合分析提供一个交互式仪表板/ web 应用程序。我正在继续寻找这个问题的最佳解决方案，同时我已经开始探索Dash的使用。Plotly 将 Dash 定义为构建 web 应用程序的 Python 框架，其额外的好处是不需要 JavaScript。正如我链接到的登录页面上所示，它构建在 Plotly.js、React 和 Flask 之上。
到目前为止，我所看到的最初好处是，一旦您熟悉并熟悉了Plotly，Dash就是仪表板开发的自然延伸。比起简单地把你的可视化内容放在你进行分析的Jupyter笔记本里，我确实看到了创建一个独立的交互式网络应用的价值。Dash通过“下拉菜单、滑块和图表等现代 UI 元素”提供增强的交互性和操纵数据的能力。该功能直接支持我的股票投资组合分析的最终目标，包括进行“假设分析”的能力，以及交互式研究潜在机会和快速了解关键驱动因素和情景的能力。考虑到所有这些，至少对我来说，与Dash的学习曲线不是无关紧要的。
何塞·波尔蒂利亚的“使用 Plotly 和 Dash 的交互式 Python 仪表盘”
为了缩短我通读 Dash 文档并对其进行全面故障诊断的时间，我报名参加了 Udemy 网站上何塞·波尔蒂利亚的课程。该课程详细页面可以在这里找到。我学过 Jose 的一些课程，目前正在学他的Flask课程。我认为他是一个非常可靠和有帮助的讲师——虽然他通常不认为丰富的编程经验是他的课程的先决条件，但在这个Dash课程中，他建议至少要非常熟悉Python。特别是，强烈建议您充分理解可视化的Plotly's语法，包括使用pandas。学完课程后，你仍将对你能用Dash构建的东西略知一二。然而，我发现这个课程是一个非常有帮助的开端，特别是因为 Jose 使用了datareader和财务数据和例子，包括动态绘制股票价格图表。
从 Jupyter 笔记本移植数据，以便在 Dash 中与之交互。
入门指南
类似于第 1 部分，我在 GitHub 上创建了另一个 repo，其中包含创建最终Dash仪表板所需的所有文件和代码。
下面总结了包括的内容以及如何开始:
- 投资组合 Python Notebook _ Dash _ blog _ example . ipynb—这与第 1 部分的 Jupyter 笔记本非常相似；新增内容包括最后两个部分:一个是“股票回报比较”部分，这是我在使用
Dash之前作为概念验证而构建的，还有一个是“数据输出”，在这里我为分析生成的数据创建 csv 文件；这些用作Dash仪表板中使用的数据源。 - 样本股票收购日期 _ 成本. xlsx —这是玩具投资组合文件，您将使用或修改该文件进行投资组合评估。
- requirements.txt —这里应该有你需要的所有库。我建议在 Anaconda 中创建一个虚拟环境，下面会进一步讨论。
- Mock _ Portfolio _ dash . py—这是
Dash仪表板的代码，我们将在下面介绍。
根据我的报告的自述文件，我建议使用 Anaconda 创建一个虚拟环境。下面是关于 Anaconda 虚拟环境的快速解释和更多细节的链接:
我推荐 Python 3.6 或更高版本，这样您就可以使用提供的 csv 文件在本地运行Dash仪表板。这里的是关于如何在Anaconda中建立虚拟环境的非常详尽的解释。
最后，正如在第 1 部分中提到的，一旦您的环境设置好了，除了需求文件中的库之外，如果您想要 Yahoo Finance datareader 在笔记本中运行，您还需要在您的虚拟环境中运行pip install fix-yahoo-finance。
使用 Dash
如果您已经使用 Python 3.6 建立了一个虚拟环境，并且已经安装了必要的库，那么您应该能够使用 Dash dashboard 代码运行Python文件。
对于那些不太熟悉的人:一旦进入您的虚拟环境，您需要将目录 cd 更改为保存回购文件的位置。举个简单的例子，如果您打开 Anaconda 提示符，并且在 Documents 文件夹中，文件保存在您的桌面上，您可以执行以下操作:
cd **..** *# This will take you up one folder in the directory.*cd Desktop *# this will take you to your Desktop.*dir *# This is the windows command to display all files in the directory. You should see the Mock_Portfolio_Dash.py file listed.*python Mock_Portfolio_Dash**.**py *# this will run the Dash file*
*# You will then go to your browser and input the URL where Python says your dashboard is running on localhost.*
如果您想了解 Jupyter 笔记本和生成投资组合数据集的完整解释，请参考第 1 部分。在 Jupyter 笔记本的末尾，您会在“数据输出”部分看到以下代码。这些小的添加会将 CSV 文件发送到您的本地目录。第一个是完整的投资组合数据集，您可以从中生成所有的可视化效果，第二个提供了您将在第一个新股票图表的下拉选择中使用的报价器列表。
*# Generate the base file that will be used for Dash dashboard.*merged_portfolio_sp_latest_YTD_sp_closing_high**.**to_csv('analyzed_portfolio.csv')
我将强调 Mock Portfolio Python 文件的一些关键方面，并分享如何在本地运行仪表板。
以供参考。py 文件，下面是运行这个Dash仪表板时应该看到的前三个图表的屏幕截图。
First three charts in Dash Stock Portfolio Analyses dashboard.
在开始的时候。py 文件中，您导入包含在 requirements.txt 文件中的库，然后编写
app **=** dash**.**Dash()
为了实例化 Dash 应用程序。然后创建两个 dataframe 对象，tickers和data。ticker 将用于图表下拉列表中的股票 ticker，而data数据框是用于所有可视化评估的最终数据集。
您将整个仪表板包装在一个 Div 中，然后开始在这个主 Div 中添加图表组件。中的第 35–72 行。py 文件生成“相对收益比较”图表，包括股票代码下拉列表、开始/结束日期范围、提交按钮和图表输出。为了简洁起见，我将在。py 文件。
html**.**H1('Relative Returns Comparison'),
html**.**Div([html**.**H3('Enter a stock symbol:', style**=**{'paddingRight': '30px'}),
dcc**.**Dropdown(
id**=**'my_ticker_symbol',
options **=** options,
value **=** ['SPY'],
multi **=** True
*# style={'fontSize': 24, 'width': 75}*
) ]
如上所述，使用Dash意味着您不需要在应用程序中添加 JavaScript。在上面的代码块中，我们用 H1 标签标记输出，创建另一个 Div，然后使用 dash_core_components 库中的下拉菜单。您将 id 设置为“my_ticker_symbol ”,我们稍后将回顾它在何处发挥作用，从选项列表(从 tickers dataframe 生成)中设置默认值“SPY ”,然后将多选设置为真。这里有一点学习曲线，至少对我来说是这样，何塞·波尔蒂利亚的课程可以通过提供总结Dash文档的切实例子来缩短你的学习时间——何塞实际上在他的课程中使用了一个类似于股票列表下拉列表和日期范围选择器的例子。
在这下面的第 75–93 行，您将看到仪表板左下方图表的代码。该图表与第 1 部分中 Jupyter 笔记本中提供的相同，但是我发现在仪表板布局中使用Dash来显示所有这些输出比在 Jupyter 笔记本中更好的用户体验，也更容易使用(与我迄今为止使用的其他任何东西相比，我仍然更喜欢使用笔记本来进行分析)。
*# YTD Returns versus S&P 500 section*
html**.**H1('YTD and Total Position Returns versus S&P 500'),
dcc**.**Graph(id**=**'ytd1',
figure **=** {'data':[
go**.**Bar(
x **=** data['Ticker'][0:20],
y **=** data['Share YTD'][0:20],
name **=** 'Ticker YTD'),
go**.**Scatter(
x **=** data['Ticker'][0:20],
y **=** data['SP 500 YTD'][0:20],
name **=** 'SP500 YTD')
],
'layout':go**.**Layout(title**=**'YTD Return vs S&P 500 YTD',
barmode**=**'group',
xaxis **=** {'title':'Ticker'},
yaxis **=** {'title':'Returns', 'tickformat':".2%"}
)}, style**=**{'width': '50%', 'display':'inline-block'}
)
对于那些习惯使用Plotly的人来说，在创建绘制Plotly图形所需的数据和布局对象方面，语法应该是熟悉的。上面包含的语法不同于笔记本中图表使用的语法，因为我更喜欢创建跟踪，基于这些跟踪生成数据对象，并在布局对象中使用dict语法。在学习 Jose 的课程和回顾Dash文档时，我发现在Dash中更容易遵循这种语法——在解决结束标记、括号、花括号等问题时，有时会变得难以处理，所以我专注于习惯这种结构。
@app.callback(Output('my_graph', 'figure'),
[Input('submit-button', 'n_clicks')],
[State('my_ticker_symbol', 'value'),
State('my_date_picker', 'start_date'),
State('my_date_picker', 'end_date') ])
**def** **update_graph**(n_clicks, stock_ticker, start_date, end_date):
start **=** datetime**.**strptime(start_date[:10], '%Y-%m-%d')
end **=** datetime**.**strptime(end_date[:10], '%Y-%m-%d') traces **=** []
**for** tic **in** stock_ticker:
df **=** web**.**DataReader(tic, 'iex', start, end)
traces**.**append({'x':df**.**index, 'y':(df['close']**/**df['close']**.**iloc[0])**-**1, 'name': tic})
fig **=** {
'data': traces,
'layout': {'title':stock_ticker}
}
**return** fig**if** __name__ **==** '__main__':
app**.**run_server()
第 229-252 行(如上所述)驱动了第一个“相对收益比较”图表的交互性。下面是这段代码的简要概述:
- 为了创建交互式图表，
Dash使用了一个回调装饰器:“我们的应用程序接口的“输入”和“输出”是通过app.callback装饰器以声明方式描述的。” - 在应用程序回调中，我们输出 dcc。先前指定的标识为“my_graph”的图形。
- 您使用 Submit 按钮作为输入，我们有三个默认状态，“my_ticker_symbol”和在 dcc 中声明的默认“SPY”值。之前讨论过的下拉列表，以及 2018 年 1 月 1 日的默认开始日期和今天的结束日期。
- 回调下面是回调装饰器包装的函数。如
Dash文档所述，当输入属性改变时，装饰器包装的函数会被自动调用。“Dash 向函数提供输入属性的新值作为输入参数，Dash 使用函数返回的任何内容更新输出组件的属性。” - 在 for 循环中，对于 y 值，我将任意给定日期
df['close']的收盘价除以由所提供的日期范围(df['close'].iloc[0])生成的序列中的第一个收盘价。 - 我这样做是为了观察指数为 0(日期范围的起点)的两只或多只股票的相对表现。鉴于股价的巨大差异，这使得比较一只交易价格超过 1800 美元的股票(如 AMZN)与另一只交易价格低于 100 美元的股票(如 WMT)的相对表现容易得多。
- 我会很快提到，有时会有一种误解，即如果一只股票以较低的价格交易，它就是“便宜的”，如果它以 AMZN 目前的价格交易，它就是“昂贵的”。鉴于这种误解，公司有时会拆分股票，以使股价看起来更能让小投资者承受，即使公司的价值/市值保持不变。
- 不管怎样，这个图表的好处是，它允许你使用动态的日期范围，快速发现一只股票相对于标准普尔 500 的超/差表现。这提供了关于对你整个投资组合的价值贡献的有用信息，也提供了何时该考虑减持表现不佳的股票的有用信息。
结论和未来的考虑。
这就结束了我对Dash进行股票投资组合分析的初步回顾。像以前一样，您有一个可扩展的 Jupyter 笔记本和投资组合数据集，现在您可以将其作为 csv 文件读出，并在交互式Dash仪表板中查看。正如之前在第一部分中所讨论的，这种方法仍然有一些需要改进的地方，包括需要将股息作为股东总回报的一部分，以及需要能够评估活跃和所有(包括撤资)头寸。
我发现这种方法的最大好处包括额外的交互性，以及我对所有图表的仪表板布局的偏好，而不是 Jupyter notebook 中单独的单元格。未来，我计划加入更强的互动性，包括更多的“假设分析”来评估个股对整体表现的贡献。
我目前考虑使用数据管道交付端到端 web 应用程序的其他选项包括:
- 使用 Google BigQuery 进行模式分析: 我在之前已经写过，我是多么喜欢在以前的公司使用模式分析。Mode 的好处包括它已经支持丰富的可视化(不需要编码)，包括一个内置的 Python 笔记本。然而，我不相信 Mode 有办法从金融 API 中提取数据，包括雅虎金融和 IEX。来自这些 API 源的数据可以读入一个私有数据库，例如使用 Google BigQuery，您可以连接到 Mode。然而，目前这似乎是一个限制，因为我相信我未来的更多图表和用例将需要从 API 中提取数据(而不是存储在数据库中)。
- **Heroku with Postgres and Pipeline:**作为 Jose 课程的一部分，他向您展示了如何将
Dash应用部署到Heroku(他的课程的另一个好处)。截至目前，我认为利用 Heroku 的应用程序功能是一个潜在的长期解决方案。这是我选择何塞的Flask课程的另一个原因；我从未构建过 web 应用程序，他展示了如何使用 SQLAlchemy 作为 Flask 应用程序的数据库。为了加深我对在 Heroku 上部署带有数据库的应用程序的理解，我的重点将是确定在一个交互式 web 应用程序中获取要分析的 finance-API 数据的最佳方式，我可以按照指定的时间表用新数据刷新该应用程序。
对我来说，长期的解决方案需要更多的学习，但这绝对是我想在今年剩下的时间里接受的挑战。我希望这篇文章对你有用，我欢迎评论中的任何反馈，包括我没有提到的，你认为更适合这个应用及其分析的其他选项。
如果你喜欢这篇文章，如果你能点击“拍手”图标让我知道并帮助增加我的作品的发行量，那将是非常棒的。
也可以在 twitter 上联系我， @kevinboller ，我的个人博客可以在这里找到。感谢阅读！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
