PythonCentral 博客中文翻译（十六）

原文：PythonCentral

协议：CC BY-NC-SA 4.0

想学 Python？以下是开始的方法

原文：https://www.pythoncentral.io/want-to-learn-python-heres-how-to-start/

Python 是一种功能强大的编程语言，如今被广泛应用于许多行业。如果你想学习 Python，你来对地方了！在这篇博文中，我们将讨论如何开始学习 Python，并为您提供一些有助于您学习这门语言的资源。我们开始吧！

Python 是什么？

Python 是由吉多·范·罗苏姆在 20 世纪 80 年代创造的一种编程语言。如今，它是一种被广泛使用的语言，它的许多特性使它成为对初学者有吸引力的选择。Python 易于读写，它有一个大型的标准库，可用于数据分析和机器学习等任务。Python 也是一种流行的 web 开发语言，可以用来创建服务器端应用程序。

如果你对学习 Python 感兴趣，网上有很多资源。你可以找到教程、书籍和视频来帮助你开始学习这门语言。你也可以加入一个 兼职编程训练营 来学习更多的编程语言和其他编程技能。对于那些想学习编码的人来说，Python 是一个很好的选择，它可以用于各种任务。所以花时间去学习更多的相关知识绝对是值得的。

为什么要学 Python？

Python 是一种通用语言，你可以在 web 应用程序的后端、前端或整个堆栈上使用。Python 对于 数据科学 和人工智能应用也很棒。此外，Python 相对于其他编程语言来说，相对容易学习。这就是为什么许多初学者在学习编码时会从 Python 开始。

如何入门 Python

首先，你需要下载并安装 Python。可以从 Python 官方网站(python.org)获取 Python 的最新版本。我们推荐使用 Python 的 Anaconda 发行版，它附带了许多对数据科学和机器学习有用的包。一旦安装了 Anaconda，就可以通过打开 Anaconda Navigator 并选择“Environments”选项卡来创建 Python 环境。从这里，您可以创建一个新的 Python 环境，并使用 conda 包管理器安装包。

帮助你学习 Python 的资源

我们建议查看官方的 Python 文档，其中包含了一个优秀的初学者教程。您还可以在网上找到许多学习 Python 的资源，包括书籍、视频和课程。我们最喜欢的资源之一是 Jake VanderPlas 的 Python 数据科学手册。这本书涵盖了数据科学和机器学习的广泛主题，如果你对这些领域感兴趣，这是学习 Python 的好方法。如果你想更深入地研究 Python，我们推荐你看看你最喜欢的 Python 包的源代码。这是了解有经验的 Python 程序员如何编写代码的一个很好的方式，它可以为您的项目提供一些思路。

原来如此！关于如何开始学习 Python 的一些提示。希望这有所帮助，给你一点方向。记住一次专注于一项任务，把事情分成可管理的小块。很快，你就会像专业人士一样编写 Python 代码了！

在 Python 2.x 中为您的图像添加水印

原文：https://www.pythoncentral.io/watermark-images-python-2x/

The module we use in this recipe to resize an image with Python is PIL. At the time of writing, it is only available for Python 2.x. Also, if you wish to do other things with images, checkout our article on how to resize an image with Python.

当您拍摄照片并将其发布到互联网上时，添加水印来防止和阻止未经授权的复制或图像盗窃通常是很方便的。

下面是一个简单的 Python 脚本，它使用PIL模块给你的图像添加水印。它使用系统字体给图像添加可见的文本水印。

from PIL import Image, ImageDraw, ImageFont, ImageEnhance

import os, sys
FONT = 'Arial.ttf' 

我们从导入PIL模块开始，加载 Truetype 字体‘arial . TTF’。默认情况下，它会在同一个文件夹中搜索字体，然后查看你的字体目录(例如 C:/Windows/Fonts)

def add_watermark(in_file, text, out_file='watermark.jpg', angle=23, opacity=0.25):

我们定义了一个函数add_watermark并声明了一些默认参数。

• in_file–输入文件名。
• text–水印文本。
• out_file–输出文件名(默认:watermark.jpg)。
• angle–水印的角度(默认:23 度)。
• opacity–不透明度(默认值:0.25)

img = Image.open(in_file).convert('RGB')

watermark = Image.new('RGBA', img.size, (0,0,0,0))

首先，我们打开输入文件并创建一个相似尺寸的水印图像。两个文件都需要处于RGB模式，因为我们正在使用阿尔法通道。

size = 2

n_font = ImageFont.truetype(FONT, size)

n_width, n_height = n_font.getsize(text)

从字体大小 2 开始，我们创建文本并获得文本的宽度和高度。

while (n_width+n_height < watermark.size[0]):

    size += 2

    n_font = ImageFont.truetype(FONT, size)

    n_width, n_height = n_font.getsize(text)

通过增加字体大小，我们搜索不超过图像尺寸(宽度)的文本长度。

draw = ImageDraw.Draw(watermark, 'RGBA')

draw.text(((watermark.size[0] - n_width) / 2,

          (watermark.size[1] - n_height) / 2),

          text, font=n_font)

使用正确的字体大小，我们使用 header 部分中声明的系统字体将文本绘制到水印图像的中心。

watermark = watermark.rotate(angle, Image.BICUBIC)

然后我们使用Image.BICUBIC(算法)近似旋转图像(默认为 23 度)。

alpha = watermark.split()[3]

alpha = ImageEnhance.Brightness(alpha).enhance(opacity)

watermark.putalpha(alpha)

在 alpha 通道上，我们通过默认值 0.25 来降低水印的不透明度(例如:降低亮度和对比度)。(注意:值 1 返回原始图像)。

Image.composite(watermark, img, watermark).save(out_file, 'JPEG')

最后，我们将水印重新合并到原始图像中，并保存为一个新的 JPEG 文件。

整个代码如下:

from PIL import Image, ImageDraw, ImageFont, ImageEnhance

import os, sys
字体= 'Arial.ttf '
def add_watermark(in_file，text，out_file='watermark.jpg '，angle=23，opacity = 0.25):
img = image . open(in _ file)。convert(' RGB ')
watermark = image . new(' RGBA '，img.size，(0，0，0，0))
size = 2
n _ FONT = image FONT . truetype(FONT，size) 
 n_width，n _ height = n _ FONT . getsize(text)
while n _ width+n _ height<watermark . size[0]:
size+= 2
n _ FONT = image FONT . truetype(FONT，size)
n _ nDraw(水印，' RGBA ')
draw . text(((watermark . size[0]-n _ width)/2，
(watermark . size[1]-n _ height)/2)，
 text，font = n _ font)
watermark = watermark . rotate(角度，图像。双三次)
alpha = watermark . split()【3】
alpha = image enhance。亮度(alpha)。enhance(不透明度)
watermark . put alpha(alpha)
image . composite(水印，img，水印)。保存(输出文件，“JPEG”)
if _ _ name _ _ = ' _ _ main _ _ ':
if len(sys . argv)<3:
sys . exit('用法:% s<input-image><text><output-image>' \
'<angle><opacity>' % OS . path . basename(sys . argv[0])
add _ watermark(* sys . argv[1:])【T4

快速有效地学习 Python 的方法

原文：https://www.pythoncentral.io/ways-to-learn-python-fast-efficiently/

Python 是二十一世纪流行的编程语言。了解 Python 可以帮助你在计算机工程专业上取得进步。

然而，作为开始，我们经常在选择最佳教育旅程时遇到问题，我们通常会浪费大量时间试图找出哪种资源是最好的。当大多数开发人员开始发现新事物时，他们经常会在他们的计算机或 USB 驱动器上积累各种课程，这不是一个好习惯。

我们将讨论快速学习 Python 的各种方法。

• First, understand the jargon.

在我们学习它之前，我们必须先掌握如何或在哪里使用这个句法。Python 在多种领域实现，包括网站开发、数据研究、机器学习、系统工程。因为很难一次了解所有的主题，所以我们必须专注于我们需要掌握的关键原则，并适当地继续下去。

• covers the following basic knowledge of python.

最起码，你和你的导游必须掌握基本知识。如果你不理解它们，你将很难处理复杂的挑战、计划或使用实例。

• Set a learning goal for yourself.

在开始学习 Python 之前，为自己制定一个学习目标。当你牢记自己的目标时，你开始学习时遇到的问题就会更容易克服。此外，你会意识到为了达到你的目标，应该集中精力或浏览哪些学习材料。例如，如果您希望学习 Python 进行数据处理，您需要执行任务、构建函数并理解有助于数据分析的 Python 模块。

• [ Anaconda accelerates the configuration of Python.

您可以从 Python Software Foundation 网页安装 Python 安装文件，然后获取和检索增加的库，或者您可以下载 Anaconda 软件包，其中也包括您需要的几个软件包，特别是如果您打算使用 Python 进行数据处理或预测分析。

• Virtual learning Python with the help of Python teacher.

在线 Python 导师 可以辅助你学习基本的 Python 编程原理，以及更复杂的 Python 编程主题。导师可以提供广泛的学科和水平，让你选择一个完全适合你的需求。

大多数导师会与您建立免费视频通话，讨论您的要求，并了解您的独特要求。Python 实际上正在成为一门流行的在线辅导课程，非常适合在在线课堂上讲授。

学生现在可以在一个共享的代码编辑器中实时展示他们的进度，让教育工作者有机会同时提供帮助。此外，学习者可以更轻松地在屏幕上完成他们的编码挑战，因为他们可以考虑一切，而不必担心有人在背后监视。这使个人感觉更舒服，从而提高理解和记忆。

• With your discovery, put it into practice.

Python 也不例外，学习某样东西最简单的方法就是将其付诸实践。如果你通过在线课程或教科书理解它，你应该接触它。

打开你的笔记本电脑，配置你的编码设置，然后开始编码。例如，如果你已经学习了条件循环，用它们来创建一个数字乐透。

为了获得更好的结果，你也可以用 if-else 表达式来调整它。如果你正在采用一个新的 Python 库，你可以把它变成一个小小的冒险，这将极大地增强你对这个想法的理解。

• Consider picking up a Python library.

掌握一个或多个补充 Python 的 Python 库很有帮助。库是充当“催化剂”的专用功能集如果没有自定义代码，您就必须构建自定义代码来完成特定的工作。举例来说，Pandas 是一个著名的用于修改表中数据的库。Numpy 是一个 Python 库，帮助在数组上执行算术和科学运算。

• Make a timetable for learning Python and stick to it.

大多数人跳过这一步，导致困难或停工。现在需要做的就是制定一个时间表。建立至少两周的时间来展开你的学习，并保证你有足够的机会来反思 Python 的基础， 在 IDE 中练习编码，并调试代码。

排除错误是学习 Python 或任何计算机程序的困难和乐趣的一部分。在最初的两周之后，你会惊讶于自己的进步。你将有足够的经验去学习你选择的供应商提供的更复杂的东西。

• Associate with people who are eager to learn.

虽然编程看起来是一项孤独的工作，但在团队中完成时会更有效。在 Python 中创建项目时，将自己与同样在实践的其他人联系起来是至关重要的。你将能够提供你在旅途中学到的技巧和技术。

结论

虽然 Python 是一门简单易懂的语言，但即使对于业余爱好者 T2 来说，掌握这门语言的所有基本思想也需要一些时间。

利用上述方法，你可以快速理解 Python 的基本原理和特定领域的信息。

标准的 Python 手册也是一个极好的信息来源。关键的重点应该是把你学到的东西付诸实践；没有快速改善的方法。

你能用 python 做什么:使用指南

原文：https://www.pythoncentral.io/what-can-you-do-with-python-usage-guide/

先决条件

你应该知道 python 的基本语法。你应该在你的机器上安装 Python。在本文中，我们将了解更多关于

• 你能用 python 做什么？
• 如何学习 Python？
• 什么时候学 Python
• python 程序员挣多少钱

你能用 Python 做什么？

Python 是一种通用语言。您可以在任何类型的应用程序中使用它。您可以将它作为一种脚本语言来解决一些日常问题。

使用 Python 编写脚本

我们举个例子。如果你喜欢摄影，你可能有一个图像命名的问题。在漫长的一天拍摄后，你回到了你的工作室。您过滤了图像并将选定的图像放入一个目录中。该目录包含不同名称的不同图像。您需要通过用特定的格式命名所有图像来简化您的工作。假设图像名称将由地名和序列号组成。这使您可以轻松搜索图像。通过使用 Python，您可以创建一个简单的脚本，该脚本将遍历该文件夹中所有 JPEG 类型的文件，并对其进行重命名。

未排序的图像

让我们看一个例子:

import os 

def main():
    path = input("Enter folder path: ")
    folder = os.chdir(path)

	for count, filename in enumerate(os.listdir()): 
		dst ="NewYork" + str(count) + ".jpeg"
		os.rename(src, dst) 

if __name__ == '__main__':
	main()

正如你所看到的，Python 是一个高效的自动化工具。这有助于将你的注意力集中到重要的事情上。

用 Python 还能做什么？你可以用 python 做一个 FTP 服务器。使用命令

python3 -m http.server 8000

您可以运行 python 服务器。您可以通过本地网络访问该服务器。您可以从不同的设备打开浏览器。键入您的network ip : 8000。您可以访问该文件夹中的所有文件。您可以使用它从同一网络中的不同设备传输文件。

Python 在日常生活中如此简单的用法会让它变得更简单。谈论引导我们走向

Python 在基于 web 的应用程序中的使用

Python 在 web 开发中非常流行，有 Flask 和 Django 这样的框架。如果你想建立自己的电子商务商店。你可以使用 Django 框架。安装后，您将有一个现成的项目结构来构建您的网站。让我们看看安装 Django 有多容易。

# checking django version 
$ python -m django --version

# if you don't have django installed you can install it using pip
$ python -m pip install Django

注意:如果没有安装 pip，您应该按照我们的文章安装它。

安装 Django 后，现在你可以创建你的项目了。

$ django-admin startproject my-eCommerce-Website

您将拥有如下所示的项目结构

my-eCommerce-Website/
    manage.py
    my-eCommerce-Website/
        __init__.py
        settings.py
        urls.py
        asgi.py
        wsgi.py

继续姜戈项目。您应该安装您的项目应用程序

$ python manage.py startapp store

在您的 Django 项目中，您将拥有所有的应用程序。每个应用程序都有不同的文件夹。

my-eCommerce-Website/
    manage.py
    my-eCommerce-Website/
        __init__.py
        settings.py
        urls.py
        asgi.py
        wsgi.py

你可以在 Django 的官方文档中了解更多关于他们的信息。您会发现，开始使用 Python 进行 web 开发非常容易。

Python 在数据科学、游戏和移动开发等不同领域有不同的用途。我们在上一篇里详细讲过。

如何学习 Python？

学习 Python 是一个持续的过程。有些人喜欢课程，有些人喜欢实践经验。你从哪里学习真的不重要。您将需要应用您所学的知识来构建有用的 Python 应用程序。我们在上一篇文章中谈到了学习它的各种资源。在这里检查一下。如果你已经知道它的基本语法。你现在的重点应该是学习如何构建 python 的应用程序。

这取决于您想要构建的应用程序的类型。如果您正在寻找构建一个基于 web 的应用程序。推荐弗拉斯克和姜戈。

你在哪里可以学习烧瓶？

• 烧瓶文件有一个获取说明部分。学习 Flask 的基础知识很有帮助。
• Coursera 刚刚发布了学习 Flask 的新课程。它会引导你了解所有烧瓶的细节。
• 教程点有条不紊烧瓶教程。

在上述所有资源中，您将构建一个 Flask 应用程序。这将给你带来使用 Flask 的实践经验。

你什么时候能学会姜戈？

• Django 文档是学习 Django 的详细资源。用它的启动导轨。
• Django 是最流行的 Python 框架。Coursera 创建了一个全专精来学习它。
• 教程点创建了一个有组织的学习 Django 的资源。叫做姜戈教程。

同样，来源是什么并不重要。你需要自己试着写代码，构建一个项目。这会帮助你建立你的投资组合。

如果你正在寻找建立机器学习项目。Udacity 和 Coursera 是学习它的绝佳资源。

在哪里可以学习机器学习？

• Udacity 有一门关于机器学习的入门课程。它会引导你通过机器学习和人工智能。
• 斯坦福大学在 Coursera 上也有一个很棒的课程来学习机器学习。由吴恩达主持。他是机器学习和人工智能领域的顶尖人物之一。
• 如果你喜欢阅读。教程点有一个关于机器学习的教程。它会给你所需的知识来了解更多关于机器学习的知识。

什么时候学习 Python

学习 Python 作为基础不会花很多时间。可能需要两到四周的时间才能适应。学习 Python 之上的其他框架可能需要时间。这取决于领域和框架的难度。学习如何用 Flask 或 Django 构建应用程序可能需要 4 到 6 周的时间。对于机器学习来说，可能需要更长的时间。机器学习是一个更复杂的领域。需要更多的时间去学习。请注意，根据您的学习过程，时间可能会有所不同。请记住，像机器学习或数据科学这样的领域需要数学背景。这可能需要更长的学习时间。

Python 程序员挣多少钱？

Python 应用于不同的行业。这样用它找工作就容易了。就你的工资而言，很多因素会控制这一点。

• 你的经历
• 你的国家
• 公司业务规模
• 您正在构建的应用程序类型

这就是为什么你对它了解得越多越好。以获得与你的经验相符的期望薪资的准确数字。你应该检查一下玻璃门。这将帮助你了解你所在地区基于技能的平均人数。

结论

Python 有很多有用的用法。它基于您想要构建的应用程序的类型。学习 Python 是一个持续的过程。您对 python 了解得越多，您可以构建的应用程序就越多。会帮你更快找到工作，增加工资。

Python 从 C++中学到了什么:编程语言是如何被创造出来的？

原文：https://www.pythoncentral.io/what-did-python-learn-from-c-how-was-the-programming-language-created/

被高薪和无限的职业发展机会所吸引，许多人对开始他们的编程生涯感到兴奋。最艰难的选择来了:学什么编程语言。许多人从最常用的编程语言中进行选择，如 Python 语言 、Java、JavaScript 等等。在本文中，我们将重点关注 Python 的历史和这种语言的细节。

Python 语言需求量很大

如果你问“Python 是一门好的第一语言吗？”答案是肯定的。根据统计数据，因为流行增加了相关性，更多的公司可能会使用 Python。最终，这将增加对 Python 专业知识的需求。如果您对编码感兴趣，可以从 Python 开始。

如果你想知道一些开发者关于如何增强你的在线隐私的秘密，试着下载用于 PC 的 VPN，这将是最安全的选择。我们建议您查看不同提供商的服务，并选择一家可靠的提供商，如【VeePN】服务提供商，该提供商为您的不同类型的设备提供应用和扩展。现在是时候深入了解 Python 及其特性了。

即使你不是程序员，学习 Python 在很多情况下都会对你有好处。在蓬勃发展的科技行业，如大数据、机器学习和数据安全，Python 已经是王者。Python 在高校也有使用。所有这些领域都大量使用 Python。他们甚至使用自己的一套库，这些库作为代码扩展运行，可以添加这些代码来创建功能。

Python 简史

20 世纪 80 年代末，第一次概念化了 Python。它最初是作为 ABC 编程语言的模拟语言创建的，这种语言在荷兰也很流行。Python 的异常处理和对 Amoeba 操作系统的关注是它相对于 ABC 语言的两个主要优势。“Python”这个词不是指蛇。它以英国电视节目《巨蟒剧团》的名字命名。

Python 2.0 于 2000 年问世。在这个迭代中，它主要是一个开源项目。列表理解、完整的垃圾收集器和 Unicode 支持都是这个 Python 版本的特性。

Python 的关键特征

• 高层。Python 是为那些喜欢将自己写的代码转换成低级编程语言的程序员设计的，因为它是高级的。为了让 Python 具有可移植性——并且在各种类型的计算机上几乎不需要修改就能运行——它还需要在执行前进行处理。
• 面向对象。Python 使用强大的面向对象的方法来组织代码，这使得可以从对象和类的角度考虑问题。Python 也支持过程化方法。可以被其他开发人员重用的编码模式可以减少开发工作中的重复。
• 解读。Python 不需要在执行前编译程序。因此，您不需要使用编译器来将输入数据转换为已编译的类文件。而是执行 a.py 文件。Python 字节码的编译也是自动的，完全隐式的。
• 通用。Python 可以用于构建几乎任何应用程序，包括各种活动的几乎任何领域。Python 既可以用于短期任务，如测试过程，也可以用于长期任务，如长期产品开发和路线图规划。

正因为如此，除了软件开发人员之外，计算机语言在包括物理、数学、系统工程、数据处理和数学在内的各种学科的专家中也很有名。此外，Python 是一种对初学者来说用户友好的脚本语言。

Python 真的那么好学吗？

对于新手来说，最伟大的编程语言之一就是 Python。它的语法与英语相当，阅读和理解起来相当简单。即使您以前从未键入过一行代码，您也可以花一点时间和精力来学习如何编写 Python。

编程涉及大量数学是一个普遍的想法。Python 并不要求你是一个数学家专家才能使用它。有数学基础知识是有益的。通过将问题分成更小的部分来创造性地解决问题比编写 Python 更重要。

学习 Python 需要多少时间

学习 Python 的基础通常需要两到六个月的时间。然而，你可以很快获得足够的知识来创建你的第一个简短程序。学习如何使用 Python 的大量库可能需要几个月甚至几年的时间。

为了完成你的预定任务，你对 Python 的了解程度将决定你需要花多长时间来学习 Python。例如，如果你的目标是自动化工作中的某项任务，而不是为了成为一名数据分析师而学习 Python，你可能会更快地学习 Python。

学习 Python 的最终想法

学习 Python 是成为程序员最快也是最简单的方法之一。这种语言是最简单也是最需要的语言之一，因为它允许在各种行业中创建不同类型的应用程序。不要忘记在编码时使用 VPN 应用程序，因为它们对增强你的在线安全性非常有帮助。

什么是单点登录，它是如何工作的？

原文：https://www.pythoncentral.io/what-is-a-single-sign-on-and-how-does-it-work/

创造一个安全可靠的工作环境对现代企业来说非常重要。由于远程和混合工作模式将长期存在，公司需要比以前更加重视网络安全。尽管“网络安全”一词可能会让一些人联想到复杂性，但大多数解决方案都比想象的要简单。相反，这些网络安全解决方案大多旨在降低复杂性并为公司提供增强的安全性。除了这些好处之外，它们还有很多好处。

提到网络安全，首先想到的是密码。密码管理对企业至关重要。然而，这可能是一个困难的过程。跟踪员工、客户和同事使用的所有密码可能非常耗时。此外，如果密码被泄露，恶意行为者可能会访问组织存储的敏感和机密数据。因此，密码、身份和访问控制对于拥有远程员工的企业至关重要。

虽然密码管理似乎是一个困难的过程，但有一些替代方法，如单点登录，可以在提高效率的同时最大限度地降低复杂性。本文将讨论单点登录服务及其与身份管理的关系。

什么是单点登录？

单点登录 是一项技术和服务，它使个人能够通过单一的凭证组合来利用各种应用和服务。该识别系统将许多登录屏幕合并成一个统一的屏幕。用户只需输入一次验证数据即可使用所有网络功能。利用单点登录技术的用户在一台服务器上注册，然后立即登录到其他功能，而不管他们使用的是什么服务、软件或域。

这个识别系统在消费者访问该公司的软件和应用程序时为他们提供了一致的界面。个人只需提供一次验证数据就可以使用公司的全部网络功能，而不是为每个产品或软件记住几个密码组合。Sing Sign-On 将个人重定向到一个验证面板，当他们试图使用需要授权的功能时，可能需要提供登录凭据。如果用户以前执行过此步骤，系统不会要求他们提供任何进一步的身份验证凭据来利用网络功能、应用程序和他们希望的其他功能。

它是如何工作的？

单点登录以共享 id 的概念为中心，这是指在可信任的自动化技术之间交换个人特征。如果一个平台授权给一个人，他们会立即被允许加入其他与该平台有公认联系的项目。这是 CAS 和 OAuth 等协议支持的后续 SSO 服务的基础。

如果个人使用其单点登录应用程序加入系统功能，则会生成一个身份验证令牌并保存在他们的设备或单点登录软件中。个人访问的任何后续功能都将通过单点登录服务进行验证，然后单点登录服务将路由个人的令牌来验证他们的 id 并授予他们访问权限。由于它在某种程度上规范了个人 id，SSO 被认为是 身份管理最佳实践 的基本步骤之一。

单点登录协议类型

SSO 是更广泛的联合身份管理概念的一个组成部分。这一概念表明在两个或多个结构域或 IM 系统之间形成了公认的键。单点登录在这种方法的架构中很常见。有几种单点登录协议，包括:

1-安全访问标记语言— SAML

SAML 是一种既定的标准，它允许各方(尤其是 IdP 和 SAML SP)共享验证和登录信息。SAML 允许 SP 在不进行身份验证的情况下运行，而是将识别信息传递给内部和外部消费者。它允许跨系统(通常是应用程序或服务)与 SP 共享访问详细信息。SAML 允许在公共云和其他支持 SAML 的系统之间进行安全的跨域通信，以及在本地或另一个云中的各种替代身份管理解决方案。

2-开放授权— OAuth

OAuth 是一种开放访问授权标准，被互联网用户广泛用于向企业或网络提供对他们在其他网站上的数据的访问，而不会泄露他们的凭证。个人可以利用开放许可来允许应用程序在另一个服务中使用他们的信息，而不必明确验证他们的有效性。OAuth 规定了分离的服务器和服务如何在不暴露原始的、关联的、单一登录凭证的情况下，授权对它们的资产进行验证。在验证行话中，这被称为安全、第三方、用户代理、委托验证。

3- OpenID 连接— OIDC

建立在 OAuth 2.0 框架上的 OIDC 是一个自由开放的验证系统。该框架面向消费者，允许他们使用单点登录(SSO)来利用使用 OpenID 提供商(OPs)来确认其 ID 的第三方网站，如电子邮件提供商或社交网络。OpenID 是为联合验证开发的，这意味着它允许第三方使用现有帐户代表客户验证客户。

4-基于 Kerberos 的单点登录

Kerberos 是一种提供相互认证的协议，在这种协议中，个人和服务器在不安全的连接上验证对方的合法性。它通过利用令牌授予服务来控制验证和软件程序，如电子邮件客户端和服务器。消费者通过首先与密钥分发中心(KDC)验证来连接服务，之后他们从 KDC 接收他们希望使用的特定服务的安全服务票。

遗言

随着远程和混合工作安排的日益流行，安全连接到公司服务器变得越来越重要。虽然密码、验证和授权管理可能看起来是困难的过程，但是诸如单点登录之类的服务可以帮助企业降低复杂性，并使其员工的访问过程更加容易。

此外，由于个人只需要一个密码，单点登录使他们更容易开发、记忆和使用更强的密码。此外，通过集中密码输入，单点登录允许公司和企业成功地管理密码安全程序。

Python 中的元组是什么

原文：https://www.pythoncentral.io/what-is-a-tuple-in-python/

学习 Python 中的内置函数和数据类型是在你被认为精通这门语言之前你需要取得的更重要的知识飞跃之一。

元组是 Python 中四种内置数据类型之一，理解它的工作原理应该不会太难。

下面是元组的分类，它们是如何工作的，以及它们与列表和字典有何不同。

Python 中的 Tuple 是什么？

如上所述，元组是 Python 内置的四种数据类型之一。另外三种数据类型分别是列表、 集合、 和字典。每种数据类型都有其特点，在使用时也有其独特的缺点。

Python 元组的特征有:

1. 元组是有序的、索引的数据集合。与字符串索引类似，元组中的第一个值的索引为[0]，第二个值的索引为[1]，依此类推。
2. 元组可以存储重复值。
3. 一旦数据被分配给一个元组，其值就不能改变。
4. 元组允许你在一个变量中存储多个数据项。您可以选择在一个元组中只存储一种数据，也可以根据需要混合存储。

如何创建和使用元组？

在 Python 中，元组是通过将数据的值或“元素”放在圆括号“()”内来分配的必须用逗号分隔这些项目。

Python 官方文档 声明，在圆括号内放置项目是可选的，程序员可以声明元组而不使用它们。然而，在声明元组时使用圆括号被认为是最佳实践，因为它使代码更容易理解。

一个元组可以有任意数量的值，并且这些值可以是任意类型。

下面是一些声明元组的例子:

tuple1 = (1, 3, 5, 7, 9);
tuple2 = "W", "X", "c", "d";
tuple3 = ('bread', 'cheese', 1999, 2019);

你也可以通过在括号之间不放值来创建一个空的元组，就像这样:

tuple1 = ();

创建一个只有一个值的元组在语法上有点棘手。当声明一个只有一个值的元组时，在结束括号之前必须包含一个输入值的逗号。

tuple1 = (1,);

这是为了让 Python 明白，你是在试图创建一个元组，而不是一个整数或字符串值。

访问元组项

在 Python 中，你可以通过各种方式访问元组。你要记住的重要一点是 Python 元组索引就像 Python 字符串索引——它们都是从 0 开始索引的。

因此，就像字符串索引一样，元组可以被连接、切片等等。Python 中访问元组的三种主要方式是索引、负索引和切片。

方法#1:步进

访问元组时，索引操作符就派上了用场。要访问元组中的特定元组，可以使用“[]”运算符。请记住，索引是从 0 而不是 1 开始的。

换句话说，一个有五个值的元组将有从 0 到 4 的索引。如果试图访问元组现有范围之外的索引，将会引发“IndexError”

此外，在索引操作符中使用浮点类型或其他类型来访问元组中的数据会引发“类型错误”

这里有一个使用索引访问元组的例子:

tuple1 = (1, 3, 5, 7, 9);
print(tuple1[0])
*# Output: 1* 

你也可以把元组放在元组里面。这被称为嵌套元组。要访问一个元组中另一个元组的值，必须链接索引操作符，就像这样:

tuple1 = ((1, 3), (5, 7));
print(tuple1[0][1])
print(tuple1[1][0])
*# Output: 
# 3
# 5* 

方法#2:负步进

有些语言不允许负索引，但 Python 不是其中之一。

换句话说，元组中的索引“-1”指的是列表中的最后一项，索引“-2”指的是倒数第二项，依此类推。

下面是如何在 Python 中使用负索引来访问元组元素:

tuple1 = (1, 3, 5, 7);
print(tuple1[-1])
print(tuple1[-2])
*# Output: 
# 7
# 5* 

方法#3:切片

通过切片访问元组值意味着使用切片操作符访问元素，切片操作符是冒号(“:”)。

切片是这样工作的:

tuple1 = ('p','y','t','h','o','n');

*# To print second to fourth elements*
print(tuple1[1:4])
*# Output: ('y','t','h')*

*# To print elements from the beginning to the second value*
print(tuple1[:-4])
*# Output: ('p','y')*

*# To print elements from the fourth element to the end*
print(tuple1[3:])
*# Output: ('h','o','n')*

*# To print all elements from the beginning of the tuple to the end* print(tuple1[:])
*# Output: ('p','y','t','h','o','n')* 

切片是访问元组中值的有效方法。如下所示，可视化元组中的元素可以使您更容易理解范围并在代码中编写适当的逻辑。

改变元组

虽然 Python 列表是可变的，但元组不是。这是元组的主要特征之一——一旦元组元素被声明，它们就不能被更改。

这里有一个例子:

tuple1 = (1,2,3,4,5)

tuple1[0] = 7

*# Output: TypeError: 'tuple' object does not support item assignment* 

然而，元组可以在其中存储可变元素，比如列表。如果存储的元素是可变的，您可以更改嵌套在元素中的值。下面举个例子来演示:

tuple1 = (1,2,3,[4,5])

tuple1[3][0] = 7

print(tuple1) 

*# Output: (1,2,3,[7,5])* 

虽然元素的值一旦分配就不能更改，但是元组可以完全重新分配。

tuple1 = (1,2,3,[4,5])

tuple1 = ('p','y','t','h','o','n');

print(tuple1) 

*# Output: ('p','y','t','h','o','n')* 

改变元组的唯一方式是通过连接。串联是组合两个或多个元组的过程。可以使用+和*运算符连接元组。

*# Concatenation using + operator* 
tuple1 = (('p','y','t')+('h','o','n'));

print(tuple1) 

*# Output: ('p','y','t','h','o','n')* 
*# Concatenation using * operator* 
tuple2 = (("Repeat",)* 3)

print(tuple2)

*# Output: ('Repeat', 'Repeat', 'Repeat')* 

删除元组

Python 不允许程序员改变元组中的元素。这意味着您不能删除元组中的单个项。

然而，使用关键字“del”可以完全删除一个元组

tuple1 = ('p','y','t','h','o','n')

del tuple1[2]

*# Output: TypeError: 'tuple' object doesn't support item deletion* 
del tuple1

print(tuple1)

*# Output: NameError: name 'my_tuple' is not defined* 

可用于元组的方法

使用元组时，有两种方法可以提供额外的功能。这两种方法是计数法和指数法。

这里有一个例子，演示了如何使用这两种方法:

tuple1 = ('p','y','t','h','o','n')

print(tuple1.count('y'))

*# Output: 1
# Since there is only one 'y' in the tuple*

print(tuple1.index('y'))

*# Output: 1
# Since the index of 'y' is 1* 

元组操作

元组的工作方式很像字符串，并响应您可以对它们执行的所有常规操作。但是，当对它们执行操作时，结果是元组而不是字符串。

除了连接和重复，程序员还可以对元组执行其他一些操作。

例如，你可以检查一个元组的长度:

tuple1 = ('p','y','t','h','o','n')

print(len(tuple1))

还可以比较元组的元素，提取元组中的最大值和最小值:

tuple1 = (1,2,3,4,5)

tuple2 = (5,6,7,8,9)

tuple1[4] == tuple2[0]

*# Output: True* 
print(max(tuple1))

*# Output: 5* 
print(min(tuple1))

*# Output: 1* 

您也可以使用“成员测试”来检查一个条目是否存在于一个元组中下面是一个成员资格测试的例子:

tuple1 = (1,2,3,4,5)

1 in tuple1

*# Output: True* 
'1' in tuple1

*# Output: False* 
7 in tuple1

*# Output: False* 

您可以使用 for 循环来遍历元组中的项。例如:

for name in ('Kathy', 'Jimmy'):
   print('Hello', name)

Python 中列表和元组的相似性

元组和列表在一些不同的方面是相似的，我们已经在这一节讨论了如何相似。

存储

元组和列表相似的一个主要原因是你可以在两者的一个变量中存储多个条目。此外，元组和列表都可以为空。

这两者之间的主要区别是语法上的:你必须用圆括号来声明一个元组，用方括号来声明一个列表。

通过键入变量名并在末尾添加括号，可以创建一个空元组。或者，您可以使用 tuple()构造函数来创建元组。

重要的是要记住，如果你使用构造函数创建一个元组，你将需要使用双括号来正确地向 Python 表明你的意图。

此外，如果你用一个条目创建一个元组，你需要在条目后添加一个逗号。如果您忘记添加逗号，Python 不会将代码识别为元组。

列表也以类似的方式工作。您可以通过键入所需的列表名称并在其末尾添加方括号来创建列表。或者，您可以使用 list()构造函数来创建列表。

虽然你可能认为你需要在列表中添加一个项目后添加一个逗号，但事实并非如此。Python 会识别出它是一个列表，而不需要你添加一个尾随逗号。

通常，存储在列表和元组中的项目本质上是相似的，并且倾向于以某种方式彼此相关。

如果你正在创建一个包含字符串、整数或布尔值序列的列表或元组，你需要做的就是用逗号将它们分开。但这并不是说不能创建包含不同数据类型的列表和元组。

只需确保在添加字符串时使用撇号，在添加布尔值时将 T 和 F 的 True 和 False 大写。另外，请注意，您可以在列表和元组中添加重复项。

开箱

元组和列表的另一个相似之处是它们都支持解包。当您创建一个列表或元组时，Python 会将许多值“打包”到一个变量中。

解包的思想是 Python 使你能够给单个变量分配单个值。

然而，不管你是使用列表还是元组，你必须确保你创建的变量数量与列表或元组中的值数量相同。如果不这样做，Python 会抛出一个错误。

索引

列表和元组之间的最后一个相似之处是，它们都是项目的有序集合。换句话说，数据的存储顺序一旦设定就不可改变。

元组和列表中的值都可以通过引用数据的索引值来访问。在 Python 和大多数其他编程语言中，索引从零开始。因此，列表或元组中的第一个值的索引为 0，第二个值的索引为 1，依此类推。

列表和元组之间的差异

元组和列表具有相同的功能——它们使你能够在其中存储不同种类的数据。然而，两者之间有一些主要的区别。

从语法上来说，元组在圆括号内有值。但是，如果您想用 Python 表示一个列表，您必须将值放在方括号(“[]”)中。

另一个关键的区别是，虽然你可以在赋值后改变列表中的元素，但是元组中的值不能改变。

元组被分配给一个内存块，而列表使用两个内存块。因此，在元组上迭代比在列表上迭代更快。

如何在元组和列表之间选择

由于在元组上迭代更快，如果你正在构建一个需要更快迭代的解决方案，选择使用元组而不是列表是一个好主意。

此外，如果你正在解决的问题不需要改变元素，使用元组是理想的。但是，如果项目需要更改，您将需要使用列表。

你可以在我们关于 Python 列表 的 指南中学习使用 Python 中的列表。

辞书:第三种收藏类型

字典是另一种数据类型，也作为一个集合。然而，与列表和元组不同，字典是键值对的哈希表。

其他数据类型和字典的另一个关键区别是字典是无序的。此外，字典是可变的，这意味着您可以添加、更改或删除其中的元素。要声明 dictionary 对象，必须使用花括号(“{}”)。

要学习创建和使用字典对象，请查看我们的 如何用 Python 创建字典的帖子。

结论

元组是方便的数据类型，可以作为解决复杂问题的强大工具。现在，您已经阅读了本指南，了解了它们是什么以及它们是如何工作的。

为了巩固您对这个强大的内置 Python 函数的了解，您只需编写一些包含元组的代码。

什么是 Python 游戏编程？

原文：https://www.pythoncentral.io/what-is-python-game-programming/

介绍

Python 已经成为娱乐部门制作视频游戏的一个有竞争力的选择。这不仅仅是因为 Python 在其他技术领域的广泛使用，或者是因为它是开源的，可以免费下载。

Python 是一种用于视频游戏制作的编程语言，因为它是一种高度灵活和强大的工具。它使游戏创作中最常见的活动变得快速而简单。有几个资源像计算机编程课程可以帮助你学习如何成功地使用它，这可能会帮助你知道如何有效地使用它。

强烈建议使用 Python 创建游戏，原因有几个，包括以下几点。

为什么 Python 是游戏创作的最佳编程语言？

清晰语法

Python 的流行可能部分归因于该语言相对简单的语法。由于代码易于阅读和理解，这种编程语言是构建视频游戏的绝佳选择。当试图设计一个游戏时，代码不仅易于理解，而且易于编写，这是有益的，因为它减少了在这个过程中花费的时间和精力。

它有一个简单的语法，这有助于概念或逻辑的无缝执行，调试变得更容易访问，并且容易添加功能的能力使它成为开发游戏的一个好选择。

灵活的对象定向

灵活的对象定向是赋予一类或一类对象特征或特性的过程。此后，这些特征被传递给从它们生成的任何附加类别。因此，如果一个程序员想要创建一个动物类型的类，他们将首先建立某些标准特性，比如 eat()和 sleep()。那么，来自不同地方的任何其他特征可能具有相似的属性。

Python 的许多美妙之处之一是该语言在面向对象方面的高度适应性。因此，程序员可以构建新对象并编辑现有对象，而无需编写太多代码。因为游戏创作者经常需要创造新的东西，改变现有的东西，所以 Python 是游戏开发的绝佳选择。

代码可重用性

Python 重用大部分代码的能力是用这种编程语言构建游戏的另一个主要好处。

Python 是一种面向对象的编程语言，这意味着它可以获取一段准备好的代码，并在任何需要的地方使用它。这种灵活性让 Python 受益匪浅。这是一个巨大的好处，最终会导致游戏中代码行数的显著减少。如果代码行更少，那么在整个项目中重写相同原则所花费的时间就会更少，开发整个软件所花费的时间也会更少。

更重要的是，通过允许您使用 Python 广泛的代码库生态系统，它使您能够利用其他开发人员产生的代码。这些库可以用来访问其他开发者发布的代码。面向对象编程可以在各种编程语言中找到。

另一方面，Python 库的丰富性和广度意味着，对于您试图解决的任何问题，很有可能其他人已经创建了可以处理它的代码。这是因为 Python 是一种流行的编程语言。这是非常好的，不仅减少了游戏中的总工作量，也提高了处理各种问题的技能。

基于游戏的库和框架

Python 是最流行的游戏编程语言之一，因为它在用于游戏创作时通常支持 2D 和 3D 视觉效果。这使得 Python 成为最流行的游戏编程语言之一。它提供了对各种库和框架的访问，这使得游戏创作成为一个简单的过程。

Kivy、Pyglet、Pymunk、PySDL2、PyOpenGL、Pygame、PyODE 和许多其他库在视频游戏制作中经常使用。此外，有大量的教程可以帮助新手通过开始阶段。

动态打字

Python 的动态类型能力使它比其他编程语言更有竞争力。正因为如此，开发人员不需要提前定义变量，这样既节省了时间，又免去了麻烦。当涉及到游戏创作时，动态类型是有益的，因为它使开发和测试游戏更快。

Python 不需要类型声明，由于这种语言的灵活性，一想到某个想法就尝试一下是可行的。例如，如果你在半夜醒来，有了一个想法，你可以马上测试它。因为每个数据类型都是在运行时动态决定的。Python 程序员在使用变量之前从来不需要进行强制转换。

广泛的社区支持

当谈到创建视频游戏时，拥有一个鼓励和帮助的社区是你所能拥有的最基本的东西之一。关于围绕计算机语言建立的社区，Python 拥有最大和最活跃的用户群之一。如果你在寻找一个问题的解决方案时遇到了困难，那么很有可能社区中的其他人已经遇到并克服了同样的挑战。

由于 Python 社区的规模和范围，寻找和雇佣 Python 开发人员既简单又划算。此外，这些资源包括大量开源教程和其他教学材料。即使你不打算雇佣开发人员，你仍然可以立即开始你的项目。

能够整合人工智能

人工智能在游戏业务中的应用变得更加关键。如果你想改进你的游戏，你应该做什么？你可以利用深度学习和其他类型的机器学习的能力。Python 已经被证明是创造人工智能的一个有价值的工具。许多库，如 TensorFlow、Keras 和 Theano，都是由希望在游戏中包含基于人工智能的元素的程序员开发的。

此外，开发人员可以跨不同平台使用 Python。因此，你的游戏可以建立在一个单一的平台上，可以很容易地移植到其他平台上。此外，Python 是一种节省成本的编程语言，因为它是免费和开源的。

稳定可靠的性能

导入模块是 Python 中一个常见且重要的功能，它允许开发人员从其他来源获取数据，并在他们的项目中重用这些数据。这种方法使开发人员能够重用数据。因为只有必要的模块从不同的源导入并与原始文件集成，所以模块导入功能也节省了空间。这是因为一个单独的项目不需要拥有它工作所必需的所有数据。

Python 以其可靠高效的性能而闻名。因此，即使很多事情同时发生，你的游戏速度也不会受到影响。当设计基于动作的视频游戏时，拥有一个可以同时处理信息而不会滞后或冻结的系统是很有帮助的。一个值得注意的例子是任天堂著名的马里奥赛车 8 豪华版视频游戏系列。这款游戏在全球售出了 4500 多万份，这一事实证明了这种编程语言的能力。

易于故障排除

Python 使得游戏开发调试过程更加简单，这也是支持使用 python 的最有说服力的理由之一。搜索和纠正代码中出现的问题的行为被称为“调试”

Python 已经是最容易理解和编写的编程语言之一，所以它比其他语言更容易调试是有道理的。然而，这并不是它比其他语言更容易调试的唯一原因。

Python 是一种被称为解释语言的编程语言。这表明代码在运行前没有编译。相反，它会立即运行，而无需事先收集。它有优点也有缺点，但最重要的优点之一是，如果代码中有错误，代码的执行将会暂停。将显示一条错误消息。

专注于一个特定的问题，解决它，然后继续前进，这对于保持对调试过程的控制有很大的帮助。

易于扩展

除此之外，扩展 Python 也很简单。Python 可以在未来的任何时候为你的游戏添加新的特性或关卡。因为代码易于理解和编写，所以它有助于开发新的更新。它使开发人员能够专注于工作，而不是纠结于语言。

例如，如果一个项目包括来自游戏玩家和玩家的持续输入，它必须是可伸缩的。这是因为随着用户数量的增长，开发人员必须更加努力才能满足需求。

此外，当一大群人一起处理同一个项目时，使用 Python 有几个好处。它提供了一个标准化的设置，所有开发团队成员都可以通过阅读和创建相同的代码来轻松协作。

结论

使用 Pygame 的 Python 已经被用于构造几个知名的游戏，包括 Frets on Fire。Pygame 再次成为使用 Python 编程语言制作游戏的最广泛使用的库之一。业余程序员和游戏开发行业的专业人员都使用它来创建游戏。

类似地，编程语言 Python 被用来开发坦克的游戏世界。即时动作游戏，四名玩家对抗四名其他玩家的团队战斗，以及拥有超过 100 辆精彩模拟坦克的强大推进系统是游戏的一些亮点。

这些游戏清楚地展示了通过使用 Python 计算机编程可以带来的巨大体验。由于代码与 Windows、Mac OS X 和 Linux 兼容，专门从事 Python web 开发的企业可以为消费者提供通过 web 交付的引人入胜的游戏体验。

什么是 Python:安装指南

原文：https://www.pythoncentral.io/what-is-python-installation-guide/

先决条件

如果你是 Python 新手，请务必阅读我们的前一篇文章。它兼容所有不同的操作系统。这很容易设置，事实上，如果你使用的是 Linux 系统，你会预装 python。在这篇文章中，你会知道:

• 如何检查 python 版本？
• 如何下载 Python？
• Python 版本 2.x 和 3.x 的区别
• 如何建立一个现成的 python 环境。

如何检查 Python 版本？

一些操作系统预装了 Python，比如 macOS 或 T2 Ubuntu。其他操作系统如 Windows 没有开箱即用的安装。

为了检查 Python 是否安装在中，请在 macOS 或 Linux 中打开终端。编写以下命令:

python --version

输出:

Python 3.7.2

如果你用的是 windows。打开 CMD 并写下:

python -v

检查 Python 版本的另一种方法是编写python。它应该打开 Python 外壳或者引发一个错误。

如果你的操作系统没有安装 Python。

如何下载 Python？

Python 最好的特性之一是它的兼容性。它可以很容易地安装在任何操作系统。您可以通过命令行或 GUI 安装它。

在基于 Linux 的操作系统中安装 Python 非常容易。在这种情况下，我们将检查 Ubuntu 的安装。在其他 Linux 发行版中也差不多。

1. 安装依赖项。

   $ sudo apt-get install software-properties-common
   $ sudo add-apt-repository ppa:deadsnakes/ppa
   

2. 更新操作系统软件包管理器

   sudo apt-get update
   

3. 安装最新版本

   $ sudo apt-get install python3.8
   

请注意，python 的版本将取决于您的发行版。比如在 Fedora 25 上安装一个Python36的包来获得 Python 3.6。

如何在 windows 中安装它:

1. 访问官网。
2. 导航到下载>窗口。
3. 选择您的版本。
4. 打开。exe 文件。
5. 单击立即安装。
6. 继续下一步。
7. 完成安装，然后单击关闭。

为 windows 设置 python

windows 安装的最后一步。

如何在 macOS 中安装 Python:

1. 执行上述步骤
2. 从下载部分选择 MacOS X
3. 点击 macOS 安装程序。
4. 打开下载的文件。
5. 单击以继续使用推荐的设置。
6. 完成后，你就可以安装了。

macOS 中的安装过程

Python2.x 和 3.x 有什么区别？

如果你试图开始学习 Python，你会发现有两个版本。2.x 和 3.x 有什么区别？

Python 就像任何其他有版本的语言一样。版本控制的目标是跟踪更新。每个版本都有自己的特色。为什么我们要对任何语言的更新进行版本控制？

目标是能够跟踪更新。在软件行业，更新语言会有副作用。该更新可能包含不推荐使用的功能或语法更改。自动更新会导致项目失败。版本控制帮助我们指定我们的项目将运行的版本。这导致了更少的错误，并增加了项目的生命周期。版本号由两部分组成。像这样(2.7 或者 3.8)。第一个数字指的是一个重大变化。可能导致不赞成某些功能或语法更改的更改。第二个数字是指一个小的更新或修复。每次更新都有一个变更日志。有了这个 changelog，开发人员可以跟踪变更以更新他们的项目。总是建议使用该语言的最新版本。

在 Python 中，有 2.x 和 3.x 两个版本，区别是主要的。将 2.x 项目更新为 3.x 将导致语法错误。2.x 和 3.x 有什么区别？你应该学哪一个？

整数除法:

用 2.x 除两个整数不会有浮点值。

# Python 2.x
print 5 / 2

output:
# 2

# Python 3.x
print(5 / 2)

output:
# 2.5

打印功能:

3.x 括号中的打印功能是强制性的。Python2.x 括号中的打印函数是可选的。

# Python 2.x
print "Hi weclome to python 2.x"

output:
# Hi weclome to python 2.x

# Python 3.x
print("Hi weclome to python 3.x")

output:
# Hi weclome to python 3.x

Unicode:

在 2.x 中，隐式字符串类型是 ASCII。但是在 3.x 中是 UNICODE。

print('sample word')
print(b'sample word')

# Python 2.x 
output:
# <type 'str'>
# <type 'str'>

# Python 3.x
output:
# <class 'str'>
# <class 'bytes'>

在 2.x 中两者是同一类型。但是在 3.x 中它们是不同的类型。这并不意味着 Python2.x 不支持 Unicode。它支持不同语法的 Unicode】。

范围和 xrange:

Python3.x 中不赞成使用语句xrange，你可以查看我们关于范围函数的完整文章。

# Python 2.x
for x in xrange(1, 5):
    print(x)

output:
# 1 2 3 4

# Python 3.x
for x in xrange(1, 5):
    print(x)

output:
Traceback (most recent call last):     
  File "<stdin>", line 1, in <module>  
NameError: name 'xrange' is not defined

It should be
for x in range(1, 5):
    print(x)

output:
# 1 2 3 4

错误处理:

Python3.x 中的错误异常处理要用as来定义。

# Python 2.x
try
    variable_name
except NameError, err:
    print err, 'ops defined before assign.'

# output:
(NameError("name 'variable_name' is not defined",), 'ops defined before assign.')

# Python 3.x
try:
    variable_name
except NameError, err:
    print err, 'ops defined before assign.'

output:
 File "<ipython-input-1-942e89fbf9ab>", line 3
    except NameError, err:
    ^
SyntaxError: invalid syntax

It should be:
try:
    variable_name
except NameError as err:
    print(err, 'ops defined before assign.')

注意:Python2.7 支持结束。如果你是 python 新手，建议从 Python3.x 开始。

如何设置一个现成的 python 环境？

python 的不同版本使得为所有项目设置一个单一的设置是不现实的。如果你有一个 python2.x 项目，它不能在你的 python3.x 环境中工作。您需要将每个项目与其包隔离开来。这个概念被称为虚拟环境。这是一个独立的环境，有一个特定的版本来运行您的项目。使用虚拟环境将有助于您轻松处理不同的项目。你需要它来激活环境。

如何搭建虚拟环境？

安装虚拟环境 ubuntu

1. 确保您已经安装了它。

2. 更新您的软件包管理器

   sudo apt update
   

3. 安装 pip 软件包管理器。

   $ sudo apt install -y python3-pip
   

4. 安装基本工具。

   $ sudo apt install -y build-essential libssl-dev libffi-dev python3-dev
   

5. 安装虚拟环境。

   $ sudo apt install -y python3-venv
   

6. 创建一个虚拟环境。

   $ python3 -m venv <env_name>
   

7. 激活虚拟环境。

   $ source <env_name>/bin/activate
   

现在你有一个孤立的操场。任何已安装的包都将在这个虚拟环境中。如果你完成了，你可以简单地写deactivate去激活环境。

结论

您可以在任何操作系统上轻松安装 python。通过其版本控制系统，您可以为您的项目选择正确的版本。总是建议使用最新版本。你应该知道版本之间的区别。更新项目取决于您使用的版本。建议每个项目都使用虚拟环境。它帮助你在同一台机器上运行多个项目。

Python 编程是用来做什么的？Python 为企业带来的好处

原文：https://www.pythoncentral.io/what-is-python-programming-used-for-benefits-of-python-for-business/

编程语言使我们能够开发有用的程序和产品，以及高效的数字解决方案。许多企业使用编程来自动化他们的业务流程、评估他们的绩效、分析客户数据以及许多其他事情。而且，尽管今天使用了许多不同的编程语言，Python 仍然是最简单和最有益的语言之一。在本文中，我们将讨论 Python 编程的用途以及如何在您的业务中使用它。除了开发基于 web 的应用程序和提高项目效率，Python 的优势还包括创建交互式用户界面、网络安全程序以及各种分析工具和数据集等。继续阅读，了解 Python 编程如何帮助您的企业。

Python 编程的主要用途

Python 是最流行的编程语言之一，这要归功于它的简单性和灵活性。由于其广泛的库、框架和其他工具，它可以用于任何类型的项目。这种编程语言的主要目的是开发简单高效的应用程序，可用于任何类型的业务。Python 在各个领域的使用导致了许多框架和库的产生，这些框架和库非常易于使用。由于大量用于数据分析、机器学习、web 开发和其他领域的库，这种编程语言的用户数量在不断增长。

Python 为企业带来的宝贵优势

安全系统

出于安全目的使用 Python 在乌克兰的开发者中变得越来越流行。网络安全和渗透测试咨询专家经常使用它来编写脚本或编写恶意软件。这是基于这样一个事实，即 Python 的简单语法允许网络罪犯更容易地进行他们的活动，这为企业带来了一系列全新的安全风险。幸运的是，在同一种编程语言中，创建了高级安全解决方案，可以基于行为分析和异常检测来识别可疑活动。

Web 开发

Python 被领先的互联网巨头使用，如 YouTube、网飞、Reddit、Quora、Dropbox 等。内容管理系统(CMS)网站 Django 是最受欢迎的网站之一，Instagram 和 Pinterest 等公司都在使用它。你也可以使用 Python 来开发电子商务商店或购物车。这种语言非常通用，也适合开发移动应用程序。例如，优步在移动设备上使用 Python 实现其后端功能。

数据分析

Python 中有很多工具可以用于数据分析。其中有熊猫、NumPy、Numpy、SciPy、Matplotlib、Scikit-Learn、Seaborn、Statsmodels 等。这有助于您比使用 R 或 Excel 更快地处理数据。

数据可视化

数据可视化在商业领域变得越来越重要，因为它可以帮助企业更好地理解他们的行为模式，改善他们与客户的关系。而且，由于 Python 很好地支持数据可视化，许多公司将它作为营销策略中的一种工具。

数据科学和机器学习

随着数据成为全球业务流程中越来越重要的一部分，公司正在寻找将数据整合成有意义的信息的方法，以帮助他们提高绩效并获得超越竞争对手的优势。这就是机器学习的用武之地。Python 已经成为该领域的领先技术之一，因为它可以用于训练算法和创建神经网络。使用这种编程语言也很容易从数据中获得洞察力，并将它们应用到现实世界的业务问题中。

在商业中使用 Python 编程的其他优势

除了上面列出的五个领域， Python 在商业中还有许多其他用途，例如:

• 文本处理。它使人们能够解析文本文件，甚至使用正则表达式在其中进行搜索。
• 数据压缩。Python 允许你比 ZIP 更好地压缩数据。
• 网络编程。你可以使用 Python 来编写像 CGI 脚本这样的网络程序，以及创建像代理服务器、代理、防火墙等网络工具。
• 多亏了 Pygame 库，你可以使用 Python 创建动画图像或视频。Pygame 对游戏开发特别有用。
• 桌面应用程序。使用 Tkinter 库，您可以用 Python 创建功能齐全的桌面应用程序。
• 你可以用 Python 开发视频游戏，创建自动交易系统，以及许多其他事情。

最后

正如您所看到的，在 Python 的帮助下，您可以为您的业务创建许多有用的工具，包括仪表板、交互式用户界面和许多其他东西。此外，您可以使用这种编程语言来开发在各种设备上工作的定制软件，包括移动设备。除此之外，Python 使您能够创建能够更准确地识别可疑活动的安全系统。在它的帮助下，您还可以更有效地分析数据，并创建对客户更有吸引力的可视化效果。总而言之，如果您正在寻找提高工作效率和自动化工作流程的方法，Python 可能是您企业的一个有价值的选择。

python 有什么用途:python 初学者指南

原文：https://www.pythoncentral.io/what-is-python-used-for/

先决条件

如果你期待学习 python，你可能会发现这篇文章非常有用。在这里，您将了解 Python。它是用来做什么的？在哪学的？

要更多地了解任何一种语言，你需要了解一点它的历史。通过了解它的历史，你会对语言的主要焦点和发展方向有更多的了解。

根据 StackOverflow 2019 年的调查，Python 是最受欢迎的编程语言之一。在本文中，我们将了解更多关于

• python 的历史
• 学习需要多长时间
• python 的主要用法
• 去哪里免费学 python

编程语言流行度图表根据stack overflow2019调查

python 的历史

Python 是一种 解释为高级通用 编程语言 。由 吉多·范·罗苏姆创作并于 1991 年首次公映。Guido 的 python 目标是成为开源的交互式编程语言。他想鼓励其他开发者使用它。Python 基于 C 语言，在性能上对 python 有帮助。CPython 的目标是将 Python 脚本翻译成 C 语言，并对解释器进行直接的 C 级 API 调用。Python 的代码可读性使其对长期项目非常有用。对于不同的公司都是不错的选择。除了在大型商业项目中使用 python 之外，开发人员开始将 python 用于辅助项目。现在你知道 python 的主要目标了。Python 注重可读性和性能。Python 支持不同的操作系统。让我们开始看看它的主要用法。

python 的主要用法

面向对象和函数式编程等多种编程范式的支持，以及背后庞大的社区，正在帮助语言适应不同的开发领域。再来说说 Python 的流行用法。

网页开发

在 Web 开发中，有许多编程语言可供选择。Python 在 web 开发中被广泛采用，有 Django、Flask 和 Pyramid 等框架。或者使用 scrappy、BeautifulSoup4 等从不同网站获取数据的废弃工具。

Django 是最大的 python web 框架。这是一个鼓励快速开发的 MVC(模型-视图-控制器)框架。它提供了具有标准架构的结构良好的文件。Django 给你开箱项目:

• 具有大量定制的可扩展架构。
• 包含项目配置的设置模块。
• ORM(对象关系映射器)将你的 python 代码转换成 SQL。
• 带有用户管理系统的管理门户。
• HTML 渲染的模板引擎。
• 内置表单验证。
• 漏洞防范，如 SQL 注入、跨站点脚本、点击劫持和密码管理

你可以在我们对 Django 的介绍中了解更多关于 Django 的信息。

Flask 是一个微框架，之所以这么叫是因为它不需要安装特定的工具或库。它没有默认的数据库或表单验证，您可以完全控制项目架构。您可以根据需要添加工具。Flask 是大型项目或基于微服务的项目的快速解决方案。这并不意味着 Flask 不是可伸缩项目的好选择。烧瓶是一个简单的选择

• 需要详细定制的项目
• 微服务系统。
• 用最少的配置快速创建 web 应用程序。

**注:**我们在之前的文章中对 Django 和其他框架做了充分的比较。Python 的用途不仅仅是构建 web 应用程序，还包括机器学习和数据科学等其他领域。

机器学习和数据科学

Python 非常擅长资源管理(RAM、CPU 和 GPU)。数据科学家和机器学习工程师正在将它与如下库一起使用:

• 张量流，机器学习的端到端 python 平台。它处理复杂的计算。它用于自然语言处理、语音识别，具有开箱即用的用户友好响应。
• **Pytorch，**一个生产就绪的机器学习库。它利用机器 CPU 和 GPU 来支持应用程序加速计算
• NumPy， Python 最流行的复杂数学运算库。它有很多线性代数方程，比如傅立叶变换。

数据科学和机器学习最近在学术研究和公司中被大量使用。你需要一个好的数学背景，并且你已经准备好开始学习它了。

自动化脚本

开发人员和安全工程师正在使用它来编写自动化脚本，以帮助他们的日常工作。查看我们关于使用 python 和 boto 访问 AWS 服务的文章

除了不擅长的移动和游戏之外，你可以在几乎所有的应用程序中使用它。

学习需要多长时间？

显然，学习一门新语言的时间并不是对每个人都是固定的。它被设计成像英语一样可读。我们可以说，学习它的基础知识并开始使用它可能需要大约 2 周的时间。

下面是 python 语法的一个例子

# define variables
language = "english"

# check type the type
type(language)  # str

# python boolean
is_readable = True

# List Data structure
numbers = [1, 2, 3, 4, 5]

# conditional statment
If language == "english":
   print("Welcome to english language")
else:
   print("Invalid language")

# iteration and for loop
for num in numbers:
    print("current number is : ", num)

# we can use ptyhon funtions to isolate logic
def get_number_type(number):
    if number % 2 == 0:
       return "Even number"
    else:
       return "Odd number"

# calling function

number_type = get_number_type(2)
print(number_type)
# Output : Even number

number_type = get_number_type(3)
print(number_type)
# Output : Odd number

上面的代码是一个易于阅读的 Python 代码的例子。这就是 Python 易学的原因。查看干净 python 代码的技巧。

去哪里免费学 python？

有大量的资源可以免费学习，我们将列出最好的学习资源。

• 文档 文档教程
• Udacity 课程python 编程入门
• Coursera 专精 Python 为大家带来
• Tutorialspoint 教程
• W3Schools 教程
• Sololearn 课程

结论

从上面的解释来看，很明显你可以在不同的应用中使用 python。python 在不同的行业和领域有着广泛的用途。它兼容所有的操作系统。如果你想以编程开始你的职业生涯，这是一个好的开始。对于在日常工作中需要几个脚本的数学家来说，Python 是一个非常有用的工具。如果您正在寻找可伸缩的 web 应用程序，python 也是一个不错的选择。

Python 中 str 和 repr 有什么区别

原文：https://www.pythoncentral.io/what-is-the-difference-between-str-and-repr-in-python/

Python 中 str 和 repr 的用途

在我们深入讨论之前，让我们来看看 Python 的官方文档中关于这两个函数的内容:

object.__repr__(self):由repr()内置函数和字符串转换(反引号)调用，计算对象的“正式”字符串表示。
object.__str__(self):由str()内置函数和 print 语句调用，计算对象的“非正式”字符串表示。

引用自 Python 的数据模型

从官方文档中，我们知道__repr__和__str__都是用来“表示”一个对象的。__repr__应该是“正式”代表，而__str__是“非正式”代表。

那么，Python 默认的任何对象的__repr__和__str__实现是什么样子的呢？

例如，假设我们有一个int x和一个str y，我们想知道这两个对象的__repr__和__str__的返回值:

>>> x = 1

>>> repr(x)

'1'

>>> str(x)

'1'

>>> y = 'a string'

>>> repr(y)

"'a string'"

>>> str(y)

'a string'

虽然int x的repr()和str()的返回值是相同的，但是您应该注意到str y的返回值之间的差异。认识到str对象的默认实现__repr__可以作为eval的参数调用，返回值将是有效的str对象，这一点很重要:

>>> repr(y)

"'a string'"

>>> y2 = eval(repr(y))

>>> y == y2

True

而__str__的返回值甚至不是一个可以被 eval 执行的有效语句:

>>> str(y)

'a string'

>>> eval(str(y))

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

File "<string>", line 1

a string

^

SyntaxError: unexpected EOF while parsing

因此，如果可能的话，对象的“正式”表示应该可以被 eval() 调用并返回相同的对象。如果不可能的话，比如对象的成员引用自己，导致无限循环引用，那么__repr__应该是明确的，包含尽可能多的信息。

>>> class ClassA(object):

...   def __init__(self, b=None):

...     self.b = b

...

...   def __repr__(self):

...     return '%s(%r)' % (self.__class__, self.b)

...

>>>

>>> class ClassB(object):

...   def __init__(self, a=None):

...     self.a = a

...

...   def __repr__(self):

...     return "%s(%r)" % (self.__class__, self.a)

...

>>> a = ClassA()

>>> b = ClassB(a=a)

>>> a.b = b

>>> repr(b)

RuntimeError: maximum recursion depth exceeded while calling a Python object

你可以用不同的方式定义ClassB.__repr__,而不是完全遵循__repr__对ClassB的要求，这将导致无限递归问题，其中a.__repr__调用b.__repr__,而b.__repr__调用a.__repr__,后者调用b.__repr__,,如此循环往复。尽可能多地显示对象信息的方法与有效的 eval-constrained__repr__一样好。

>>> class ClassB(object):

...   def __init__(self, a=None):

...     self.a = a

...

...   def __repr__(self):

...     return '%s(a=a)' % (self.__class__)

...
> > > a = class a()
>>>b = class b(a = a)
>>>a . b = b
>>>repr(a)
<class ' _ _ main _ _。主要的，主要的。class '>(a = a))"
>>>repr(b)
"<class ' _ _ main _ _。>(a = a)

因为__repr__是对象的官方表示，所以您总是希望调用"repr(an_object)"来获得关于对象的最全面的信息。然而，有时__str__也是有用的。因为__repr__可能太复杂而无法检查所讨论的对象是否复杂(想象一个对象有十几个属性)，__str__有助于快速概述复杂的对象。例如，假设您想要检查一个冗长日志文件中间的datetime对象，以找出用户照片的datetime不正确的原因:

>>> from datetime import datetime

>>> now = datetime.now()

>>> repr(now)

'datetime.datetime(2013, 2, 5, 4, 43, 11, 673075)'

>>> str(now)

'2013-02-05 04:43:11.673075'

现在的__str__表示看起来比从__repr__生成的正式表示更清晰、更易读。有时候，能够快速理解对象中存储的内容对于理解复杂程序的“大”图景是很有价值的。

Python 中 str 和 repr 之间的问题

需要记住的一个重要问题是，容器的__str__使用包含的对象的__repr__。

>>> from datetime import datetime

>>> from decimal import Decimal

>>> print((Decimal('42'), datetime.now()))

(Decimal('42'), datetime.datetime(2013, 2, 5, 4, 53, 32, 646185))

>>> str((Decimal('42'), datetime.now()))

"(Decimal('42'), datetime.datetime(2013, 2, 5, 4, 57, 2, 459596))"

因为 Python 更喜欢明确性而不是可读性，所以元组的__str__调用调用包含的对象的__repr__，即对象的“正式”表示。虽然正式表示比非正式表示更难阅读，但它是明确的，并且对错误更健壮。

Python 中 str 和 repr 之间的提示和建议

• 为你实现的每个类实现__repr__。不应该有任何借口。
• 对于你认为可读性对不模糊性更重要的类，实现__str__。

Python 中的字符串是什么

原文：https://www.pythoncentral.io/what-is-the-string-in-python/

字符串是 Python 数据类型。在本文中，我们将了解什么是 python 中的字符串，如何在 Python 中反转、连接和比较字符串。为了从本文中获得最大收益，您需要具备 Python 的基础知识。如果你不点击查看我们的python 介绍。先说 python 中的字符串是什么。

Python 中的字符串是什么？

Python 字符串是一种数据类型。Python 没有字符数据类型。这就是为什么它有一个字符串，一个 Unicode 表示的字符列表。Python 将字符串作为字符数组来处理。

这意味着您也可以将所有列表函数应用于 string。声明一个 python 字符串非常简单，只需在单引号或双引号之间添加单词。这将告诉 Python 在内存中创建一个字符串长度的列表。让我们看一个定义 Python 字符串的例子。

text = 'Hello'
message = "Python string"

print(text)
print(message)

# output
'Hello'
"Python string"

上面的例子展示了如何在 python 中用单引号或双引号定义一个字符串。Python 字符串有一些利用字符串的函数。假设用户用他们的电子邮件注册了您的应用程序。您需要验证电子邮件字符串是小写的。以避免用户数据的重复。Python 提供了一个内置函数lower()，可以将字符串转换成小写。

email = "Email@Mail.com"

print(email)
# output
'Email@Mail.com'

print(email.lower())

# output
'email@mail.com'

我们提到字符串是一个列表，我们可以对它执行一些列表函数。这包括列表所具有的反向功能。

如何在 Python 中反转一个字符串

要在 python 中反转一个字符串，你需要理解 python 将字符串作为一个字符列表读取。相反的功能非常简单。首先，遍历字符串。从原始字符串的末尾开始创建一个新字符串。举个例子你就明白了。

text = 'Hello world'
new_text = ''

index = len(text)
while index > 0:
  new_text += text[index -1]
  index -= 1

print(text)
print(new_text)

# output
Hellow world
dlrow olleH

在上面的代码中，我们用字符串的长度创建了一个索引。使用循环从后向前遍历文本中的每一项。最后一部分是将字符添加到新字符串中，并减少计数器。这就解决了我们反串的问题。Python 支持更有效的方法来反转字符串。

text = 'Hello world'
new_text = text[::-1]

print(new_text)

# output
dlrow olleH

文本[::-1]代码做了什么？它对字符串进行切片，使其以字符串的长度开始，以零索引结束。这会反转字符串，并将其存储在 new_text 字符串中。您可能已经注意到，在前面的例子中，我们创建了一个空字符串，并开始向其中添加内容。这就引出了一个问题，如何连接 Python 的字符串？

在 Python 中连接字符串

串联 Python 的字符串是将字符串合并在一起。更简单的解释，如果你有 text_1 =“你好”，text_2 =“世界”。将它们串联起来就是我将它们合并，形成“Hello world”。在 Python 中有很多种连接字符串的方法。最简单的方法是使用加号。

text_1 = "Hello"
text_2 = "World"

print(text_1 + " " + text_2)

# output
Hello World

你的代码库越大，你就越需要定制连接。Python 提供了几个函数来帮助您以一种更优雅、更易读的方式连接字符串。第一种方法是 format()函数。

username = "John"

welcome_message = "Welcome {username} this is a test text".format(username=username)

print(welcome_message)

# output
Welcome John this is a test text

如果您需要添加空格，并且您有多个变量要添加到文本中，format 函数在大型测试中非常方便。你需要做的就是把变量名放在花括号里。Python 将从传递给 format 函数的参数中获取该变量的值。

第二种方法是使用 join 函数。如果您有一个列表，并且想要将列表数据连接成一个字符串，那么 join 函数非常有用。我们举个例子来了解一下。

full_name_parts = ['John', 'Jack', 'Watson']
full_name = "-"

full_name.join(full_name_parts)

print(full_name)

# output
John-Jack-Watson

您可以看到 join 函数遍历了列表，并将项目添加到 full_name 字符串中。它添加了中间带有-的项目。

第三种方法仅在 Python 3.6 及更高版本中可用。这是 f 弦法。这是 format 函数的一个更好的版本。

name = "Jack"
age = 72

f"Hi, {name}. You is {age}."

# output
'Hello, Eric. You are 74.'

f-string 方法允许您直接获取字符串中的变量值。如果你在字符串的开头添加了一个字符。

比较两个 Python 字符串

让我们假设您有一个存储用户名的应用程序。您希望每个用户的用户名都是唯一的。这意味着您需要验证这个名称不匹配任何其他注册的用户名。Python 提供了比较字符串的能力。一个基本的例子是:

name = input('Enter Your Name:')

saved_name = 'Jack'

if name == saved_name:
  print('Sorry the name you entered is taken')
else:
  print('Welcome {name}'.format(name=name))

# output
Sorry the name you entered is taken

# output
Welcome John

Python 将这两个字符串作为文本进行比较。这意味着如果用户输入小写的插孔名称，该条件将无效。这一点非常重要。你要知道 Python 是不做自动验证的。您需要手动实现所需的验证。这是一个非常简单的例子，在一个更现实的例子中，您将有一个数据库来确保名称是唯一的。

结论

Python 的字符串使用起来非常方便和有用。它有明确的形成和污染方法。您可以将它作为一个列表来使用。它支持不同的大多数 Python 列表内置的函数。要反转一个 Python 的字符串，你可以把它切片，以索引 0 结束。Python 中的连接字符串提供了不同的连接方法，可以根据您的需要进行选择。在 python 中比较字符串类似于比较两个整数。你可以在官方文档中了解更多关于 Python 字符串的知识。你可以在这里得到更多关于字符串函数的细节。

我的笔记本电脑需要什么规格来进行高效的 Python 编码？

原文：https://www.pythoncentral.io/what-specs-does-my-laptop-need-for-efficient-python-coding/

学习如何用 Python 编程是你做过的最好的决定之一。你会学到很多技能，这些技能会让你在职业生涯中走得更远。即使你不打算在你的职业生涯中使用编码，它也可以成为一个真正令人兴奋的爱好，给你的创造力一个完美的出口。

然而，一旦你决定开始编码，你需要确保你有合适的设备。不是任何设备都可以，即使你可以使用相对便宜的笔记本电脑。

当你买笔记本电脑时，别忘了给它上保险。如果您的设备被盗，笔记本电脑保险将为您承保。当你迫切需要更换日常编码用的笔记本电脑时，它可以帮你省下很多经济上的麻烦。

现在，让我们来了解一下您的笔记本电脑为获得出色的 Python 编码体验所需的规格。

随机存取存储

Python 需要多大的 RAM？虽然您可以使用 4GB 内存的笔记本电脑，但至少 8GB 内存的笔记本电脑才是最好的。4GB 将允许您完成工作，但是当您试图运行像 PyCharm 或 Visual Studio 代码这样的代码编辑器时，您将面临令人沮丧的延迟。

同样值得一提的是，你将能够运行任何使用大量系统内存的应用程序。你不希望你的内存不足扼杀你的创造力。

中央处理器

你需要一个合适的笔记本电脑 CPU 来进行 Python 编程。与 RAM 一样，您可以使用不太强大的 CPU，但是您会不断发现您的系统过载，浪费您大量的时间。

选择多核 CPU。英特尔酷睿 i5 应该是您的最低配置，尽管 i7 或第八代机型将最适合您。装有苹果 M1 和 M2 芯片的 Macbooks 也是不错的选择。

显示器(屏幕)

屏幕有多重要？比你想象的要多，因此你可能要比你计划的花费更多。在笔记本电脑的小屏幕上编码会对眼睛造成很大的伤害。选择至少 14 英寸、分辨率至少为全高清的屏幕。

你不一定要去买一个大的笔记本电脑，但是如果你有一个更小的设备，用一个外部显示器来补充它。这样，当你在家或在办公室时，你可以轻松地编写代码，当你外出时，仍然可以设法完成一些编程工作。

国家政治保卫局。参见 OGPU

从技术上来说，你不需要一个特别好的 GPU 来编码。使用集成的 GPU 绝对可以应付，尤其是在高端笔记本电脑上。然而，如果你计划在某个时候编写高质量的游戏，一个好的 GPU 最终将是必要的。即使在移动应用的开发中也是如此。

如果可以的话，请使用至少 4GB 的外部 GPU。像 GeForce 和 Quadro 这样的 NVIDIA 卡是理想的。

储存；储备

你当然可以用硬盘驱动器编码。但是在 2022 年，你真的没有理由吝啬你的硬盘。一个基本的固态硬盘应该是最低限度的，即使你不编码或使用你的笔记本电脑游戏。

并非所有 SSD 驱动器都生而平等。新的驱动器通常配备带有 NVMe 接口的 M.2 磁盘。你可以使用一个基本的固态硬盘驱动器，但你最好选择更强大的选项。你应该有至少 240GB 的存储容量。

键盘

你需要一个像样的键盘来编码，但任何选中以上所有选项的笔记本电脑都会附带一个足够好的键盘。如果你是从零开始构建你的笔记本电脑，不要在这方面吝啬。

操作系统（Operating System）

你的操作系统当然非常重要。然而，你可以使用任何主流操作系统的最新版本，这主要取决于个人偏好。如果你是 Linux 的粉丝，可以尝试使用 Ubuntu 发行版。

任何具备上述规格的笔记本电脑都非常适合用 Python 编码。如前所述，您可以设法用劣质设备编码。然而，考虑到编码在你的生活中变得多么重要，投资一个强大的设备是值得的。

用 Django 可以有效地解决什么类型的问题？

原文：https://www.pythoncentral.io/what-type-of-problem-can-be-effectively-solved-with-django/

Django 是编写 web 应用程序时使用的框架工具。开始时，你会注意到它的简单，这有助于事情进展得更快。

随着您添加现实世界的约束，数据模型变得更加复杂。你会发现你最初的策略不再有效。

随着您对问题了解的越来越多，请调整您的代码。Django 可能很快，但有时你最终会写出很慢的代码。

可能很难知道从哪里开始，尤其是当你的专业项目非常广泛的时候。在这种情况下，这是与 Django 发展公司合作的最佳时机，以获得你所要求的最好的专业结果。

请继续阅读本文，了解通过坚持不懈的努力、关注和一些调整，可以解决哪些常见的 Django 问题。学习阅读代码错误并找到它们的解决方案需要时间和练习。

Django 安装和使用中的常见问题

处理数据时，从数据位置开始调试，然后转到数据存储的界面，最后是视图和报告。

大多数性能问题都是由于试图访问数据库造成的。幸运的是，Django 详细总结了如何优化数据库。您只需从一开始就应用一个好的策略来高效地构建您的代码。

在寻求优化时，您的代码可能会变得不清晰。当面临清晰代码和性能提升之间的选择时，你能理解的代码应该放在第一位。你需要练习才能明白要改变什么。

工具

要解决问题，首先要识别它。有几件事你可以做。首先，理解 Django.db.connection，在当前连接中您有哪些查询。进入 shell 并使用命令 shell_plus 和标志–print-SQLon。

您的调试环境应该在后台运行中间件。它记录查询并引起对重复的注意。你可以在 Django-debug-toolbar 上找到这些信息。

意外查询

例如，在检查作者的 id 时，您本能地想要使用 author 字段。如果不需要 author 对象，可能就白做了一次额外的查询。万一以后用了作者值，也没关系。

通过使用列名称属性，使事情变得简单明了。

大小和存在命令

理解何时使用存在和 c 计数需要时间。当使用 Django 的 queryset 中的数据时，使用 Python 操作。当不使用数据时，请改用 queryset 方法。

在寻找 queryset 的大小时，做同样的事情。当你需要尺寸时使用计数，当你使用查询设置时使用长度。

如何得到你需要的东西

Django 固有地请求表中的所有列，并在 Python 项目中填充这些列。当您只需要表中列的子集时，使用值或值列表。通过这样做，您不必创建复杂的 python 对象。相反，您可以使用字典、值或元组。

如何处理多行

Django 捕捉在计算 querysets 时获得的值。如果您多次重复 queryset，它就可以工作，但是如果您只循环一次，它就不能很好地运行。

Django 将书籍加载到内存中，并遍历每一本书。您希望它保持一个 SQL 连接打开并读取每一行，然后在转到下一行之前调用 do_stuff 。在这种情况下，迭代器可以帮助您。迭代器允许你写线性数据。它很棒，因为当与值和值列表结合使用时，它在内存中保留的信息量最少。

迭代器在迁移信息并且必须改变表中的行时也很有帮助。它节省时间，避免了停机时间。

关系问题

Django 让您可以自然地与关系数据库交互。您可以随意使用精确且语义清晰的代码。因为 Django 使用延迟加载，所以它只在您需要时才加载作者。虽然这是一个积极的方面，但它可能会导致大量的查询。

Django 认识到了这个问题。它提供了两种解决方案:预取 _ 相关和选择 _ 相关。当用 Django 编写应用程序时，了解和使用它们是必不可少的。

当不使用时选择 _ 相关

一直使用 select_related 很有诱惑力，但有时并不合适。这可能意味着更多的工作不值得做。该命令为查询的每一行创建新的实例，这会消耗内存。当您查询 select_related 的相同值时，使用 querysets。另一种方法是翻转您的查询，使用预取相关的。

请记住，使用查询集时，您的更改会传播到查询集中的其他行。而 select_related 就不是这样了。

结论

Django 中出现的每个问题都至少有一个解决方案。您应该关注的是清晰的代码，以便以后进行优化。当你继续开发你的应用程序时，保持良好的卫生习惯，使用干净清晰的代码。

在 Python 文件中使用 Django 时，通过尝试遵循文档来避免错误。从养成使用资源的好习惯开始你的旅程，因为你以后会享受到好处。

初学者在哪里练习 Python 编程

原文：https://www.pythoncentral.io/where-to-practice-python-programming-for-beginners/

你知道如今编程是就业市场的热门趋势吗？有很多初学者和初级学习者想练习 Python。如果你是这个领域的新手，并且想学习如何成为一名更流利的 Python 开发者，你应该寻找更多的机会。为什么 Python 现在很重要？还有什么其他选择，为什么它们没有那么有效？让我们来看看使用 Python 的优势。

Python 简单来说是什么？有许多复杂的定义来帮助用户解释 Python 是什么。让我们抛开复杂的意思，用简单的英语来描述这种语言。所以，三言两语， Python 编程帮助 是指一种主要针对软件开发、网站建设、数据可视化、任务自动化而设计的编程语言。

Python 对新手的优势

为什么需要使用 Python？如果你试着用谷歌搜索今天开发人员最常用的语言和工具，你肯定会发现 Python 在列表的最上面。为什么这种语言如此流行？开发人员倾向于深入学习 Python 有几个原因。我们一起想办法。

1。新手很容易上手

如果你只是刚刚开始你的编程生涯的，你将需要一些容易获得并且不需要花费太多时间的东西。很多大三学生想从 C++开始，或者一次尝试几个选项。但不会带来好结果。如果你需要在一门语言上有好的和高质量的专业知识，那肯定是 Python。

2。你可以毫不费力地找到工作

为什么编程语言的选择会影响求职？问题是有些工具的需求比其他的少。所以，如果你正在积极地找工作，你会把它钉在一家公司的空缺上。问题是 Python 是一个广泛使用的工具。它可以在广泛的项目中实施。因此，公司，无论是软件公司还是其他类型的企业，都在急切地寻找新的人才。

3。Python 提供了很多机会

Python 被用于许多不同的项目和应用。如果你想成为市场的抢手货，并且知道如何在职业上提升自己，那么肯定有大量的机会可以做到这一点。使用 Python，你将能够开发软件和创建网站。有什么能比创建一个网站更赚钱呢？您还可以负责任务自动化或数据分析和可视化。

去哪里练习 Python 编程

如果你决定要获得更多关于这门语言的知识，并对自己进行测试，你应该小心现有的选择。让我们来看看你可以去实践编程经验的主要途径。

• 首先可以查一下自己的理论知识。平台为每个编程爱好者提供交互式问题和测验。你可以去网站上看看，自己测试一下。当你至少已经掌握了一些这门语言的专业知识时，最好还是这样做。
• 你可以查看一些实际的任务。网上有很多。如果你寻找一个技术性的任务生成工具，你会发现有很多种选择。这些是 选项，帮助你训练 你的技能，既实用又理论。
• 哪里可以练习 Python 专业知识？参加一个真实的项目怎么样？如果你在一个真实的项目中尝试自己，并敢于按计划做每件事，你会发现一个宝贵的机会。

你想让你的练习最完整、最有成效吗？那么你也许应该看看这些选项。它们非常适合所有年龄段的用户。不管你已经练习 Python 多久了，看看这些选项都是值得的。编程语言的专业性和专业知识始于定期和深入的实践。只有这样才是成功之路。

外卖

许多初学者想知道他们是否可以开始使用 Python 编程语言。对许多人来说这是一个很好的选择。在本文中，我们描述了选择 Python 作为编程任务的主要语言的三大原因。你想成为市场上收入高、要求高的专家吗？如果你学习 Python，你可以获得大量的工作机会，并获得适当的报酬。

为什么选择 Python 作为您在 Linux 上的第一种编程语言

原文：https://www.pythoncentral.io/why-choose-python-as-your-first-programming-language-on-linux/

由于 Windows 的使用在减少，Linux 正在迅速发展并变得越来越流行。许多程序员正致力于 Linux 的推广，他们为台式机开发新的程序，这些程序将等同于甚至优于 Windows 和 Mac OS X 应用程序。

用于 Linux 的编程语言有很多，而且每年都有新的出现。但并不是所有的都是程序员用的。几乎每一个现代 Linux 发行版中都有 Python，所以那些准备在 Linux 中编写第一个 Python 程序的人不需要安装任何额外的程序。要在 Linux 中编写您的第一个 Python 程序，请启动您最喜欢的 Linux 程序，并遵循本文的步骤。

具有简单语法和语义的可靠编程语言将确保快速学习，并有助于开发算法思维。第一语言应该是高水平和灵活的，这样学生就可以尝试解决问题的替代方案。同样重要的是，它应该支持现代设计方法，包括抽象、封装和面向对象的方法。我们来试着了解一下 Python 是否真的适合新手程序员。重要的是要记住编程语言可能因公司而异。但是如果你想做一名自由职业者，为 论文写作服务 或任何其他公司创建网站，从学习 Python 开始吧。

值得理解的是，第一门编程语言的选择并不总是决定一个学生未来的职业生涯，但它可以影响职业发展的方向，有利于未来的自主学习。

编程通常被视为开发思维的工具，并且能够影响人们解决问题的方式。这里可以与口语的 Sepir-Worf 假说相提并论，该假说认为语言决定思维。

选择第一编程语言的标准还可以包括:

• 范围和流行程度；
• 范式——面向对象或函数式编程；
• 句法简洁；
• 思想的优雅；
• 程序员群体的规模；
• 培训材料的可用性。

尽管对理想的第一语言缺乏共识，Python 符合大部分标准，可以被推荐为这样的选择。在这种情况下，值得考虑未来程序员所面临的任务，以及他或她所选择的整体学习策略。

Python 的范围

最近，脚本语言越来越受欢迎。用它们编写的软件比用传统的系统语言要多。Python 可用于所有主流平台:Windows、OS X、Linux、Unix、BeOS、Java。它广泛应用于科学计算、机器学习、web 开发、游戏和视觉效果创建、服务器管理以及其他一些领域。

Python 可以做许多开箱即用的有用的事情，并提供专业人员期望从核心编程语言中获得的所有基本工具和特性。有关如何使用 Python 来启发您学习它的更多示例，请查看本文。

社区和文档

Python 有一个来自世界各地的大型程序员社区，致力于学习、使用和开发它。有许多专门讨论 Python 的会议、聚会和黑客马拉松，这种语言有一个庞大且研究充分的 文档库 来帮助新手熟悉它并找到大多数问题的答案。Python 有大量适用于各种场合的标准库，甚至还有更多开源库供您在工作中使用。

Python 的简单性——语法和语义

得益于简单的正则语法，Python 程序通常可读性极强，易于理解。操作符在行尾结束，块结构缩进，程序看起来像可执行的伪代码。

Python 最不寻常的特性之一是使用缩进来表示代码块。解释器有助于确保正确的格式，这使得编写不可读的代码更加困难。在其他语言中，缩进是一门艺术。在 Python 中，它是语法的重要部分。作为一个例子，这里有一个 Python 的线性搜索版本:

例如，如果将代表 的 行向左移动几个空格，就会导致语法错误。还要注意， : 用于表示代码块的开始。

除了基本的数字类型，Python 还提供了三种内置的数据结构:字符串、列表和字典。字符串和列表支持灵活的切片表示法，可以提取任何子串或子列表。

简单的程序真的很简单。比如 Python 中的 Hello World 是这样的:

语义上，Python 很简单。它是动态类型的，所以不需要变量声明。这减少了代码量，也消除了由于误解声明、定义和用法中的细微差别而导致的常见错误。Python 代码易于阅读，因为它在许多方面类似于日常英语。

Python 有一套最小但完整的简单控制结构:一个 if-elif-else 选择结构，一个确定的 for 循环，一个不确定的 while 循环。

Python 中的 为 循环就是例证。它允许控制变量取连续的值。它可用于枚举任何序列，如列表或字符串。列表项可以打印如下:

for 简单又安全，让你很早就可以进入，不用担心无尽的循环。

Python 的优缺点

我们已经在上面提到了 Python 的一些优点，我们建议将它们与缺点进行比较，以客观地评估作为第一个学习者的语言。

优势

• 简单易学。
• 简洁。
• 易于使用的语法和简单的语义。
• 可解释性。
• 广泛的可用性。
• 动态打字。
• 广泛的库支持。
• 大量文档和培训材料。
• 它是多平台的。

缺点

程序运行速度低:使用动态类型的语言逐行执行代码使得开发高性能的应用程序变得困难，但这通常可以通过提高开发人员的工作效率来弥补。

Python 程序使用大量内存:在创建优化的应用程序时，这可能是一个缺点。有关此问题的更多信息，请参见“Python 中的内存工作原理”。

编译时缺乏检查有时会导致运行时错误。这对于在运行或发布之前测试应用程序提出了更高的要求。

对比优缺点，Python 在弱硬件上对代码的速度有一定的限制。由于新手程序员通常不会编写高性能的应用程序，所以他们的产品没有如此严重的运行时限制。同时，Python 比编译的编程语言快好几倍，而可读性和语法、语义的简单性否定了可能的错误。

总结

Python 是一种简单、通用、有前途的编程语言。虽然它有一些缺点，但好处在很大程度上大于它们，尤其是对于新手程序员来说。脚本语言作为基本软件开发工具的流行是计算机编程中潜在的革命性变化。Python 是学习基础知识和开始职业生涯的理想工具。

为什么选择 Python

原文：https://www.pythoncentral.io/why-python/

Python 已经在 IEEE Spectrum 的年度编程语言排名榜 之上好几年了。

它也是美国大学教授的最流行的入门编程语言。

如果你还没有开始学习 Python，那么理解它为什么会在全球开发者中流行是一个挑战。

因此，在这篇文章中，我列出了你应该考虑学习和使用 Python 的五大理由。

为什么是 Python？

Python 受欢迎背后最大的原因是它的。阅读和理解 Python 程序比用其他编程语言编写的程序要容易得多。

由于没有令人困惑的语法规则，程序员不必花太多精力编写代码。这使得像程序员一样思考变得容易多了。

对于程序员来说，用任何语言编写一个“Hello World”程序作为他们的第一个程序都是惯例。在 Java 中，基本程序的代码是这样的:

另一方面，Python 中的“Hello World”程序看起来是这样的:

这两种语言复杂程度的对比是惊人的。

此外，有了 Python，你不必担心让你的代码工作。

设置 Python 很容易——你所要做的就是访问 Python 官方网站，并在你的电脑上安装软件包。虽然如果你喜欢有一个好的界面来写代码，你可以得到一个 IDE，但是你不一定要这样做。您可以在 Windows 上使用命令提示符，或者在 macOS 和 Linux 上使用终端来运行您的程序。

Python 到底有多大用处？

Python 看起来很简单，但它远不是一种不灵活的语言。它用途广泛，在几个行业都有应用。大型科技公司，包括谷歌、Dropbox 和 Spotify，都使用 Python 开发各种应用程序。下面是不同公司的使用方法:

Dropbox

让用户管理云数据的 Dropbox 桌面客户端完全是用 Python 编写的，你会感到惊讶。服务器端代码也是用 Python 编写的，这使得它成为该公司使用的最重要的语言。这证明了 Python 的强大和出色的跨平台能力。

谷歌

谷歌已经成长为向大众提供的不仅仅是一个强大的搜索引擎，因此，该公司使用多种语言。除了 C++和 Go 之外，Python 是该公司使用最多的语言之一。

尽可能使用 Python 是谷歌的早期决定，并不难理解其中的原因。它支持快速实现功能，并且易于维护。

然而，由于 Python 没有那么快，谷歌软件栈中需要低延迟操作的部分是用 C++编写的。

Spotify

虽然该公司严重依赖 Java，但 Python 用于构建 web API 和交互式 API 控制台。交互式控制台使开发人员能够探索端点，而无需经历导航复杂界面的麻烦。

该语言在公司内部的其他应用包括:

• 数据分析
• 支付系统
• 内容管理系统
• DNS 服务器恢复系统

如你所见，这种语言在不同的公司有着广泛的应用。虽然 Python 可能没有 C++这样的低级语言快，但它是快速构建原型和实现特性的完美工具。

它还具有明显的多功能性。学习 Python 将使你能够创建几乎任何你想要的东西。

为什么要学习 Python？

易用性和多功能性是选择 Python 的两大原因。然而，学习 Python 是个好主意还有许多其他原因。

#1 一个积极支持的社区

Python 自 1991 年就出现了。它是有据可查的，并且被世界上一些最大的公司所使用。如果你碰巧遇到了这种语言的问题，很可能这个问题以前就已经解决了——仅仅是因为使用这种语言的开发人员数量太多。

简单的谷歌搜索通常足以回答你的任何问题。如果您在那里没有找到您的答案，您可以求助于详细的文档来获得解决方案。您也可以向 Stack Overflow 上的大型 Python 开发人员社区寻求帮助。

#2 多种编程范例

Python 提供的最大优势之一是它支持多种编程范式。它对面向对象、结构化、函数式和面向方面编程的支持使它非常灵活。

此外，这种编程语言以动态类型系统为特色，并拥有自动内存管理功能。这些特性使您能够使用 Python 构建大型、复杂的应用程序，而不必太担心约束。

#3 大数据应用

过去十年，数据科学和云计算的应用呈指数级增长。Python 对这些应用程序的支持帮助它一飞冲天。

Python 现在是处理大数据最常用的语言，仅次于 R，R 也用于创建人工智能系统。

Python 使得分析和组织数据变得非常容易。它的易维护性和可伸缩性帮助它把 R 推到了开发者偏好的第二位。

大数据库

该语言有几个软件包，如 NumPy 和 Pandas，使用户能够以不同的方式分析和使用数据，而无需从头开始编写程序。

由谷歌开发的 Tensorflow 是迄今为止最受欢迎的 Python 包，它能够构建机器学习算法。用户可以使用 pyspark 调用 spark 框架并处理大型数据集。

像这样的库使日常开发人员能够分析数据趋势，而不需要学习像 r 这样复杂的语言。

#4 庞大的套库

Tensorflow 和 Pandas 并不是 Python 自带的唯一的库。这种语言拥有大量的库，可以在开发的各个领域提供帮助。一些最著名的库包括:

• NumPy 和 SciPy: 为 web 开发的科学计算提供帮助。
• Scikit-Learn: 用于机器学习应用和自然语言处理。
• Keras: 它使得与神经网络一起工作变得更容易。

也有类似库的工具使 Python 能够与其他语言一起工作，并扩展其跨平台支持。

Python 的另一个优势是，你可以通过阅读 Python 标准库文档来了解几个库。

#5 几种开源框架和工具

Python 是开源的，这大大降低了开发成本。活跃的开发人员社区和缺乏严格的许可要求导致了一些强大的开源 Python 框架的开发。

任何开发人员都可以使用几十种强大的 Python 工具中的一种来满足他们确切的开发需求，而不会增加开发成本。

这些工具的可用性也有助于减少开发时间，因为团队不必编写代码来解决框架和工具为他们解决的问题。

Django、Flash 和 Bottle 是 web 应用程序开发人员可以用来简化和加速开发的许多工具中的一部分。另一方面，像 PyQT、PyGUI 和 Kivy 这样的框架有助于加速 GUI 应用程序的开发。

这些框架并不缺乏，而且很有可能你会找到一个框架来帮助你解决一个复杂的问题，而不需要写很多代码。

结论:2021 年 Python 值得学吗？

Python 是大学里最受欢迎的入门编程语言——现在你明白为什么了。

它很容易学习、阅读和使用，而且由于它是免费下载的，所以也很容易访问。对于一个发展中的开发者来说，这是一个完美的起点。

这种编程语言有着广泛的应用，可以用来做任何事情，从制作视频游戏到评估营销决策。活跃的社区和几个可用的库有助于加速软件开发。

但也许最重要的是，Python 在大型科技领域被广泛使用，这意味着学好它将带来几个经济上有回报的就业机会。

另外，学习编写 Python 程序将教会你一些细节，足以让你更轻松地掌握其他编程语言。

如果你正在寻找一门可以学习的编程语言，Python 是最好的选择。

好奇用 Python 可以做什么？下面就为 详细用法指南 提供帮助。

为您的第一个 Django 应用程序编写自动化测试

原文：https://www.pythoncentral.io/writing-automated-tests-for-your-first-django-application/

测试，测试和更多的测试

作为一名软件程序员，你经常听到别人谈论测试是任何项目中最重要的组成部分之一。当有适当的测试覆盖时，软件项目通常会成功。而当很少或没有时，它经常失败。你可能想知道:到底什么是测试？为什么大家都在不断强调它的重要性？

测试是检查代码正确性和完整性的简单程序或迷你程序。一些测试检查软件项目的微小细节- 当一个 POST 方法被调用时，一个特定的 Django 模型会被更新吗？，而其他人检查软件的整体运行——代码是否正确执行了我关于客户订单提交的业务逻辑？。不管多小，每个测试都很重要，因为它告诉你你的代码是否有问题。尽管对你的代码进行 100%的测试覆盖是相当困难的，并且需要付出大量的努力，但是你应该总是尽可能地用测试覆盖你的代码。

总体而言，测试:

• 节省您的时间，因为它们允许您测试应用程序，而无需一直手动运行代码。
• 帮助您验证和阐明软件需求，因为它们迫使您思考手头的问题，并编写适当的测试来证明解决方案可行。
• 让你的代码更健壮，对其他人更有吸引力因为他们能让任何读者看到你的代码在测试中被证明是正确运行的。
• 帮助团队一起工作,因为他们允许队友通过编写代码测试来验证彼此的代码。

编写您的第一个自动化 Django 测试

在我们现有的应用程序 myblog 的索引视图中，我们将返回用户在不到两天后发布的最新帖子。索引视图的代码附在下面:

def index(request):

    two_days_ago = datetime.utcnow() - timedelta(days=2)

    recent_posts = m.Post.objects.filter(created_at__gt=two_days_ago).all()

    context = Context({

        'post_list': recent_posts

    })

    return render(request, 'index.html', context)

这个视图中有一个小 bug。你能找到它吗？

似乎我们假设我们网站中的所有帖子都是过去“发布”的，即Post.created_at比timezone.now()早。然而，很有可能用户提前准备了一篇文章，并希望在未来的某个日期发布它。显然，当前代码也将返回那些未来的帖子。这可以在下面的代码片段中得到验证:

>>> m.Post.objects.all().delete()

>>> import datetime

>>> from django.utils import timezone

>>> from myblog import models as m

>>> future_post = m.Post(content='Future Post',

>>>                      created_at=timezone.now() + datetime.timedelta(days=10))

>>> future_post.save()

>>> two_days_ago = datetime.datetime.utcnow() - datetime.timedelta(days=2)

>>> recent_posts = m.Post.objects.filter(created_at__gt=two_days_ago).all()

# recent_posts contain future_post, which is wrong.

>>> recent_posts[0].content

u'Future Post'

在我们继续修复视图中的 bug 之前，让我们暂停一下，写一个测试来暴露这个 bug。首先，我们将一个新方法recent_posts()添加到模型Post中，这样我们就可以从视图中提取不正确的代码:

import datetime
从 django.db 导入模型作为 m 
从 django.utils 导入时区
类 Post(m . Model):
content = m . CharField(max _ length = 256)
created _ at = m . datetime field(' datetime created ')
@ class method
def recent _ posts(cls):
two _ days _ ago = time zone . now()-datetime . time delta(days = 2)
return post . objects . filter(created _ at _ _ gt = two _ days _ ago)

然后，我们修改索引视图的代码，以使用来自模型Post的recent_posts()方法:

def index(request):

    recent_posts = m.Post.recent_posts()

    context = Context({

        'post_list': recent_posts

    })

    return render(request, 'index.html', context)

现在我们将下面的代码添加到myblog/tests.py中，这样我们可以运行它来测试我们代码的行为:

import datetime
从 django.utils 导入时区
从 django.test 导入测试用例
从我的博客导入模型作为 m
类 PostModelTests(test case):
def setUp(self):
' ' '从未来创建帖子‘
超级(PostModelTests，self)。setUp()
self . Future _ Post = m . Post(
content = ' Future Post '，created _ at = time zone . now()+datetime . time delta(days = 10))
self . Future _ Post . save()
def tearDown(self): 
' ' '从未来删除帖子。''
超级(PostModelTests，self)。tear down()
m . Post . objects . get(content = ' Future Post ')。删除()
def test _ recent _ posts _ not _ including _ future _ posts(self):
' ' ' m . post . recent _ posts()不应该返回未来的帖子。''
recent _ posts = m . post . recent _ posts()
self . assert notin(self . future _ post，recent_posts) 

在这个测试用例中，我们想要验证未来的帖子不包含在从m.Post.recent_posts()返回的帖子列表中。现在，您可以通过以下方式运行测试:

$ python manage.py test

Creating test database for alias 'default'...

....................................................

======================================================================

FAIL: test_recent_posts_not_including_future_posts (myblog.tests.PostModelTests)

m.Post.recent_posts() should not return posts from the future.

----------------------------------------------------------------------

Traceback (most recent call last):

  File "/Users/user/python2-workspace/pythoncentral/django_series/article7/myblog/myblog/tests.py", line 23, in test_recent_posts_not_including_future_posts

    self.assertNotIn(self.future_post, recent_posts)

AssertionError:  unexpectedly found in []
- 
在 11.877 秒内进行了 483 次测试
失败(失败=1，跳过=1，预期失败=1) 
销毁别名“默认”的测试数据库...

由于来自未来的帖子在从recent_posts()返回的列表中，并且我们的测试抱怨了它，我们肯定知道在我们的代码中有一个 bug。

修复我们的测试用例错误

我们可以通过确保在recent_posts()的查询中m.Post.created_at早于timezone.now()来轻松修复这个错误:

class Post(m.Model):

    content = m.CharField(max_length=256)

    created_at = m.DateTimeField('datetime created')
@ class method
def recent _ posts(cls):
now = time zone . now()
two _ days _ ago = now-datetime . time delta(days = 2)
return post . objects . \
filter(created _ at _ _ gt = two _ days _ ago)。\ 
过滤器(created_at__lt=now) 

现在，您可以重新运行测试，它应该会在没有警告的情况下通过:

$ python manage.py test

Creating test database for alias 'default'...

.................................................................................................................................................s.....................................................................................................................................x...........................................................................................................................................................................................................

----------------------------------------------------------------------

Ran 483 tests in 12.725s
OK (skipped=1，expected failures=1) 
销毁别名“default”的测试数据库...

自动化测试案例总结和提示

在本文中，我们学习了如何为我们的第一个 Django 应用程序编写自动化测试。因为编写测试是最好的软件工程实践之一，它总是有回报的。这可能看起来违背直觉，因为您必须编写更多的代码来实现相同的功能，但是测试将在将来节省您的大量时间。

当编写 Django 应用程序时，我们将测试代码放入tests.py中，并通过运行$ python manage.py test来运行它们。如果有任何测试没有通过，Django 会将错误报告给我们，这样我们就可以相应地修复任何 bug。如果所有测试都通过了，那么 Django 显示没有错误，我们可以非常自信地说我们的代码工作正常。因此，对代码进行适当的测试覆盖是编写高质量软件的最佳方式之一。

为您的第一个 Python Django 应用程序编写模型

原文：https://www.pythoncentral.io/writing-models-for-your-first-python-django-application/

上一篇文章编写您的第一个 Python Django 应用程序是如何从头开始编写一个简单的 Django 应用程序的分步指南。在本文中，您将学习如何为新的 Django 应用程序编写模型。

软件架构模式

在我们深入代码之前，让我们回顾一下两个最流行的服务器端软件架构设计模式:模型-视图-控制器和表示-抽象-控制。

模型-视图-控制器

模型-视图-控制器 ( MVC )设计模式是一种软件架构模式，它将数据的表示与处理用户交互的逻辑分离开来。一个模型指定了存储什么样的数据。一个视图从一个模型中请求数据并从中生成输出。一个控制器提供逻辑来改变视图的显示或更新模型的数据。

呈现-抽象-控制

与 MVC ，表示-抽象-控制 ( PAC )是另一种流行的软件架构模式。PAC 将系统分成组件层。在每一层中，表示组件从输入数据生成输出；抽象组件检索并处理数据；而控制组件是表示和抽象之间的中间人，负责管理这些组件之间的信息流和通信。不像 MVC 中的视图直接与模型对话， PAC 的表示和抽象从不直接相互对话，它们之间的通信是通过控件进行的。与遵循 MVC 模式的 Django 不同，流行的内容管理系统 Drupal 遵循 PAC 模式。

姜戈的 MVC

虽然 Django 采用了 MVC 模式，但它与标准定义有点不同。即，

• 在 Django 中，模型描述了什么样的数据被存储在服务器上。因此，它类似于标准 MVC 模式的模型。
• 在 Django 中，视图描述了将哪些数据返回给用户。而标准的 MVC 视图描述了如何呈现数据。
• 在 Django 中，模板描述了如何将数据呈现给用户。因此，它类似于标准 MVC 模式的视图。
• 在 Django 中，控制器定义了框架提供的机制:将传入请求路由到适当视图的代码。因此，它类似于标准 MVC 模式的控制器。

总的来说，Django 偏离了标准的 MVC 模式，因为它建议视图应该包括业务逻辑，而不是像标准的 MVC 那样只包括表示逻辑，并且模板应该负责大部分的表示逻辑，而标准的 MVC 根本不包括模板组件。由于 Django 的设计与标准的 MVC 相比的这些差异，我们通常称 Django 的设计为模型-模板-视图+控制器，其中控制器经常被省略，因为它是框架的一部分。所以大部分时候 Django 的设计模式都叫 MTV 。

尽管理解 Django 的 MTV 模式的设计哲学是有帮助的，但最终唯一重要的事情是完成工作，Django 的生态系统提供了一切面向编程效率的东西。

创建模型

由于新的 Django 应用程序是一个博客，我们将编写两个模型，Post和Comment。一个Post有一个content字段和一个created_at字段。一个Comment具有一个message字段和一个created_at字段。每个Comment都与一个Post相关联。

from django.db import models as m
类 Post(m . Model):
content = m . CharField(max _ length = 256)
created _ at = m . Datetime field(' Datetime created ')
class Comment(m . Model):
Post = m . foreign key(Post)
message = m . TextField()
created _ at = m . Datetime field(' Datetime created ')

接下来，修改myblog/settings.py中的INSTALLED_APP元组，将myblog添加为已安装的应用。

INSTALLED_APPS = (

'django.contrib.auth',

'django.contrib.contenttypes',

'django.contrib.sessions',

'django.contrib.sites',

'django.contrib.messages',

'django.contrib.staticfiles',

# Uncomment the next line to enable the admin:

# 'django.contrib.admin',

# Uncomment the next line to enable admin documentation:

# 'django.contrib.admindocs',

'myblog', # Add this line

)

现在，您应该能够执行下面的命令来查看当您运行syncdb时将执行哪种原始 SQL。命令syncdb为INSTALLED_APPS中尚未创建表的所有应用程序创建数据库表。在后台，syncdb将原始 SQL 语句输出到后端数据库管理系统(在我们的例子中是 MySQL 或 PostgreSQL)。

$ python manage.py sql myblog

[/shell]

• MySQL 的实现

[shell]
BEGIN;
CREATE TABLE myblog_post (
id integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
content varchar(256) NOT NULL,
created_at datetime NOT NULL
)
;
CREATE TABLE myblog_comment (
id integer AUTO_INCREMENT NOT NULL PRIMARY KEY,
post_id integer NOT NULL,
message longtext NOT NULL,
created_at datetime NOT NULL
)
;
ALTER TABLE myblog_comment ADD CONSTRAINT post_id_refs_id_648c7748 FOREIGN KEY (post_id) REFERENCES myblog_post (id);

提交；
[/shell]

• PostgreSQL

[shell]
BEGIN;
CREATE TABLE “myblog_post” (
“id” serial NOT NULL PRIMARY KEY,
“content” varchar(256) NOT NULL,
“created_at” timestamp with time zone NOT NULL
)
;
CREATE TABLE “myblog_comment” (
“id” serial NOT NULL PRIMARY KEY,
“post_id” integer NOT NULL REFERENCES “myblog_post” (“id”) DEFERRABLE INITIALLY DEFERRED,
“message” text NOT NULL,
“created_at” timestamp with time zone NOT NULL
)
;

提交；
[/shell]

SQL 转储看起来不错！现在，您可以通过执行以下命令在数据库中创建表。

$ python manage.py syncdb

Creating tables ...

Creating table myblog_post

Creating table myblog_comment

Installing custom SQL ...

Installing indexes ...

Installed 0 object(s) from 0 fixture(s)

注意，在前一个命令中创建了两个表myblog_post和myblog_comment。

与新模型玩得开心

现在，让我们深入 Django shell，享受我们全新的模型。要以交互模式运行我们的 Django 应用程序，请键入以下命令:

$ python manage.py shell

Python 2.7.2 (default, Oct 11 2012, 20:14:37)

Type "help", "copyright", "credits" or "license" for more information.

(InteractiveConsole)

>>>

前面的命令打开的交互式 shell 是一个普通的 Python 解释器 shell，您可以在其中针对我们的 Django 应用程序自由地执行语句。

>>> from myblog import models as m

>>> # No post in the database yet

>>> m.Post.objects.all()

[]

>>> # No comment in the database yet

>>> m.Comment.objects.all()

[]

>>> # Django's default settings support storing datetime objects with tzinfo in the database.

>>> # So we use django.utils.timezone to put a datetime with time zone information into the database.

>>> from django.utils import timezone

>>> p = m.Post(content='Django is awesome.', created_at=timezone.now())

>>> p

<Post: Post object>

>>> p.created_at

datetime.datetime(2013, 3, 26, 17, 6, 39, 329040, tzinfo=<UTC>)

>>> # Save / commit the new post object into the database.

>>> p.save()

>>> # Once a post is saved into the database, it has an id attribute which is the primary key of the underlying database record.

>>> p.id

1

>>> # Now we create another post object without saving it into the database.

>>> p2 = m.Post(content='Pythoncentral is also awesome.', created_at=timezone.now())

>>> p2

<Post: Post object>

>>> # Notice p2.id is None, which means p2 is not committed into the database yet.

>>> p2.id is None

True

>>> # Now we retrieve all the posts from the database and inspect them just like a normal python list

>>> m.Post.objects.all()

[<Post: Post object>]

>>> m.Post.objects.all()[0]

<Post: Post object>

>>> # Since p2 is not saved into the database yet, there's only one post whose id is the same as p.id

>>> m.Post.objects.all()[0].id == p.id

True

>>> # Now we save / commit p2 into the database and re-run the query again

>>> p2.save()

>>> m.Post.objects.all()

[<Post: Post object>, <Post: Post object>]

>>> m.Post.objects.all()[1].id == p2.id

True

现在我们已经熟悉了新的Post型号，将它与新的Comment一起使用怎么样？一个Post可以有多个Comment，而一个Comment只能有一个Post。

>>> c = m.Comment(message='This is a comment for p', created_at=timezone.now())

>>> c.post = p

>>> c.post

<Post: Post object>

>>> c.post.id == p.id

True

>>> # Since c is not saved yet, p.comment_set.all() does not include it.

>>> p.comment_set.all()

[]

>>> c.save()

>>> # Once c is saved into the database, p.comment_set.all() will have it.

>>> p.comment_set.all()

[<Comment: Comment object>]

>>> p.comment_set.all()[0].id == c.id

True

>>> c2 = m.Comment(message='This is another comment for p.', created_at=timezone.now())

>>> # If c2.post is not specified, then Django will raise a DoseNotExist exception.

>>> c2.post

Traceback (most recent call last):

File "<console>", line 1, in <module>

File "/Users/xiaonuogantan/python2-workspace/lib/python2.7/site-packages/django/db/models/fields/related.py", line 389, in __get__

raise self.field.rel.to.DoesNotExist

DoesNotExist

>>> # Assign Post p to c2.

>>> c2.post = p

>>> c2.save()

>>> p.comment_set.all()

[<Comment: Comment object>, <Comment: Comment object>]

>>> # Order the comment_set according Comment.created_at

>>> p.comment_set.order_by('created_at')

[<Comment: Comment object>, <Comment: Comment object>]

到目前为止，我们知道了如何使用每个模型的现有属性来创建、保存和检索Post和Comment。查询数据库找到我们想要的帖子和评论怎么样？原来 Django 为查询提供了一种稍微有点奇怪的语法。基本上，filter()函数接受符合“[字段]_ [字段属性] _[关系]=[值]”形式的参数。举个例子，

>>> # Retrieve a list of comments from p.comment_set whose created_at.year is 2013

>>> p.comment_set.filter(created_at__year=2013)

[<Comment: Comment object>, <Comment: Comment object>]

>>> # Retrieve a list of comments from p.comment_set whose created_at is later than timezone.now()

>>> p.comment_set.filter(created_at__gt=timezone.now())

[]

>>> # Retrieve a list of comments from p.comment_set whose created_at is earlier than timezone.now()

>>> p.comment_set.filter(created_at__lt=timezone.now())

[<Comment: Comment object>, <Comment: Comment object>]

>>> # Retrieve a list of comments from p.comment_set whose message startswith 'This is a '

>>> p.comment_set.filter(message__startswith='This is a')

[<Comment: Comment object>, <Comment: Comment object>]

>>> # Retrieve a list of comments from p.comment_set whose message startswith 'This is another'

>>> p.comment_set.filter(message__startswith='This is another')

[<Comment: Comment object>]

>>> # Retrieve a list of posts whose content startswith 'Pythoncentral'

>>> m.Post.objects.filter(content__startswith='Pythoncentral')

[<Post: Post object>]

>>> # Retrieve a list of posts which satisfies the query that any comment in its comment_set has a message that startswith 'This is a'

>>> m.Post.objects.filter(comment__message__startswith='This is a')

[<Post: Post object>, <Post: Post object>]

>>> # Retrieve a list of posts which satisfies the query that any comment in its comment_set has a message that startswith 'This is a' and a created_at that is less than / earlier than timezone.now()

>>> m.Post.objects.filter(comment__message__startswith='This is a', comment__created_at__lt=timezone.now())

[<Post: Post object>, <Post: Post object>]

您是否注意到最后两个查询有些奇怪？m.Post.objects.filter(comment__message__startswith='This is a')和m.Post.objects.filter(comment__message__startswith='This is a', comment__created_at__lt=timezone.now())返回两个Post而不是一个不奇怪吗？我们来核实一下有哪些帖子被退回来了。

>>> posts = m.Post.objects.filter(comment__message__startswith='This is a')

>>> posts[0].id

1

>>> posts[1].id

1

啊哈！posts[0]和posts[1]是同一个岗位！那是怎么发生的？因为原始查询是Post和Comment的连接查询，并且有两个Comment满足该查询，所以返回两个Post对象。那么，我们如何让它只返回一个Post？很简单，只需在filter()的末尾追加一个distinct():

>>> m.Post.objects.filter(comment__message__startswith='This is a').distinct()

[<Post: Post object>]

>>> m.Post.objects.filter(comment__message__startswith='This is a', comment__created_at__lt=timezone.now()).distinct()

[<Post: Post object>]

总结和建议

在本文中，我们为我们的博客网站编写了两个简单的模型Post和Comment。Django 没有编写原始的 SQL，而是提供了一个强大且易于使用的 ORM，允许我们编写简洁且易于维护的数据库操作代码。您应该深入代码并运行python manage.py shell来与现有的 Django 模型进行交互，而不是停留在这里。很好玩啊！