python初学者_终极Python初学者手册

最新推荐文章于 2024-07-12 16:16:27 发布

cumi7754

最新推荐文章于 2024-07-12 16:16:27 发布

阅读量416

点赞数

文章标签：编程语言 python java 人工智能大数据

原文链接：https://www.freecodecamp.org/news/the-python-guide-for-beginners/

版权

python初学者

Python has become one of the fastest-growing programming languages over the past few years.

在过去的几年中，Python已成为增长最快的编程语言之一。

Not only it is widely used, it is also an awesome language to tackle if you want to get into the world of programming.

如果您想进入编程世界，它不仅被广泛使用，而且还是一种很棒的语言。

This Python Guide for Beginners allows you to learn the core of the language in a matter of hours instead of weeks.

这份Python初学者指南可让您在数小时而不是数周的时间内学习该语言的核心。

Quick info: You can download a PDF version of this Python Guide for Beginners.

快速信息：您可以下载此Python初学者指南的PDF版本。

Ready to dive in?

准备潜水了吗？

目录 (Table of contents)

Python简介 (Introduction to Python)

Python was created in 1990 by Guido van Rossum in Holland.

Python由荷兰的Guido van Rossum于1990年创建。

One of the objectives of the language was to be accessible to non-programmers.

该语言的目标之一是非程序员可以使用。

Python was also designed to be a second language for programmers to learn due to its low learning curve and ease of use.

由于Python的学习曲线较低且易于使用，因此它也被设计为程序员学习的第二语言。

Python runs on Mac, Linux, Windows, and many other platforms.

Python可在Mac，Linux，Windows和许多其他平台上运行。

Python is:

Python是：

Interpreted: it can execute at runtime, and changes in a program are instantly perceptible. To be very technical, Python has a compiler. The difference when compared to Java or C++ is how transparent and automatic it is. With Python, we don't have to worry about the compilation step as it's done in real-time. The tradeoff is that interpreted languages are usually slower than compiled ones.

解释：它可以在运行时执行，并且程序中的更改立即可见。从技术上讲，Python有一个编译器。与Java或C ++相比，区别在于它的透明性和自动性。使用Python，我们不必担心编译步骤，因为它是实时完成的。折衷是解释型语言通常比编译型语言慢。
Semantically Dynamic: you don't have to specify types for variables and there is nothing that makes you do it.

语义动态：您不必为变量指定类型，也没有什么可以使您做到这一点。
Object-Oriented: everything in Python is an object. But you can choose to write code in an object-oriented, procedural, or even functional way.

面向对象：Python中的一切都是对象。但是您可以选择以面向对象，过程甚至功能的方式编写代码。
High level: you don't have to deal with low-level machine details.

高级别：您不必处理低级别的计算机详细信息。

Python has been growing a lot recently partly because of its many uses in the following areas:

Python最近得到了长足的发展，部分原因是它在以下领域的许多用途：

System scripting: it's a great tool to automate everyday repetitive tasks.

系统脚本：这是自动化日常重复任务的好工具。
Data Analysis: it is a great language to experiment with and has tons of libraries and tools to handle data, create models, visualize results and even deploy solutions. This is used in areas like Finance, E-commerce, and Research.

数据分析：这是一种很棒的语言，可以进行试验，并拥有大量的库和工具来处理数据，创建模型，可视化结果甚至部署解决方案。它用于金融，电子商务和研究等领域。
Web Development: frameworks like Django and Flask allow the development of web applications, API's, and websites.

Web开发：Django和Flask之类的框架允许开发Web应用程序，API和网站。
Machine Learning: Tensorflow and Pytorch are some of the libraries that allow scientists and the industry to develop and deploy Artificial Intelligence solutions in Image Recognition, Health, Self-driving cars, and many other fields.

机器学习：Tensorflow和Pytorch是一些库，可让科学家和业界在图像识别，健康，自动驾驶汽车和许多其他领域中开发和部署人工智能解决方案。

You can easily organize your code in modules and reuse them or share them with others.

您可以轻松地在模块中组织代码，然后重复使用或与他人共享。

Finally, we have to keep in mind that Python had breaking changes between versions 2 and 3. And since Python 2 support ended in 2020, this article is solely based on Python 3.

最后，我们必须记住，Python在版本2和版本3之间进行了重大更改。由于Python 2支持在2020年结束，因此本文仅基于Python 3。

So let's get started.

因此，让我们开始吧。

安装Python 3 (Installing Python 3)

If you use a Mac or Linux you already have Python installed. But Windows doesn't come with Python installed by default.

如果您使用Mac或Linux，则已经安装了Python。但是Windows默认没有安装Python。

You also might have Python 2, and we are going to use Python 3. So you should check to see if you have Python 3 first.

您可能还拥有Python 2，我们将使用Python3。因此，您应该检查一下是否首先拥有Python 3。

Type the following in your terminal.

在终端中键入以下内容。

python3 -V

Notice the uppercase V.

注意大写的V

If your result is something similar to 'Python 3.x.y', for instance, Python 3.8.1, then you are ready to go.

如果您的结果类似于“ Python 3.x.y”(例如Python 3.8.1 ，则可以开始使用了。

If not, follow the next instructions according to your Operating System.

如果不是，请根据您的操作系统按照以下说明进行操作。

在Windows上安装Python 3 (Installing Python 3 on Windows)

Go to https://www.python.org/downloads/.

前往https://www.python.org/downloads/ 。

Download the latest version.

下载最新版本。

After the download, double-click the installer.

下载后，双击安装程序。

On the first screen, check the box indicating to "Add Python 3.x to PATH" and then click on "Install Now".

在第一个屏幕上，选中指示“将Python 3.x添加到PATH”的框，然后单击“立即安装”。

Wait for the installation process to finish until the next screen with the message "Setup was successful".

等待安装过程完成，直到出现下一个屏幕，提示“安装成功”。

Click on "Close".

点击“关闭”。

在Mac上安装Python 3 (Installing Python 3 on Mac)

Install XCode from the App Store.

从App Store安装XCode 。

Install the command line tools by running the following in your terminal.

通过在终端中运行以下命令来安装命令行工具。

xcode-select --install

I recommend using Homebrew. Go to https://brew.sh/ and follow the instructions on the first page to install it.

我建议使用自制软件。转到https://brew.sh/并按照第一页上的说明进行安装。

After installing Homebrew, run the following brew commands to install Python 3.

安装Homebrew后，运行以下brew命令以安装Python 3。

brew update
brew install python3

Homebrew already adds Python 3 to the PATH, so you don't have to do anything else.

Homebrew已经将Python 3添加到PATH中，因此您无需执行其他任何操作。

在Linux上安装Python 3 (Installing Python 3 on Linux)

To install using apt, available in Ubuntu and Debian, enter the following:

要使用Ubuntu和Debian中可用的apt安装，请输入以下内容：

sudo apt install python3

To install using yum, available in RedHat and CentOS, enter the following:

要使用RedHat和CentOS中可用的yum安装，请输入以下内容：

sudo yum install python3

运行代码 (Running Code)

You can run Python code directly in the terminal as commands or you can save the code in a file with the .py extension and run the Python file.

您可以直接在终端中将Python代码作为命令运行，也可以将代码保存在扩展名为.py的文件中并运行Python文件。

终奌站 (Terminal)

Running commands directly in the terminal is recommended when you want to run something simple.

如果要运行简单的命令，建议直接在终端中运行命令。

Open the command line and type python3

打开命令行并输入python3

renan@mypc:~$ python3

You should see something like this in your terminal indicating the version (in my case, Python 3.6.9), the operating system (I'm using Linux), and some basic commands to help you.

您应该在终端上看到类似这样的信息，其中指出了版本(在我的情况下为Python 3.6.9)，操作系统(我正在使用Linux)以及一些基本命令可以为您提供帮助。

The >>> tells us we are in the Python console.

>>>告诉我们我们在Python控制台中。

Python 3.6.9 (default, Nov  7 2019, 10:44:02) 
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Let's test it by running our first program to perform basic math and add two numbers.

让我们通过运行第一个程序执行基本数学运算并加两个数字来对其进行测试。

>>> 2 + 2

The output is:

输出为：

To exit the Python console simply type exit().

要退出Python控制台，只需键入exit() 。

>>> exit()

运行`.py`文件 (Running `.py` files)

If you have a complex program, with many lines of code, the Python console isn't the best option.

如果您有一个复杂的程序且包含许多代码行，那么Python控制台不是最佳选择。

The alternative is simply to open a text editor, type the code, and save the file with a .py extension.

另一种方法是简单地打开文本编辑器，键入代码，然后以.py扩展名保存文件。

Let's do that, create a file called second_program.py with the following content.

为此，创建一个包含以下内容的文件second_program.py 。

print('Second Program')

The print() function prints a message on the screen.

print()函数在屏幕上打印一条消息。

The message goes inside the parentheses with either single quotes or double quotes, both work the same.

该消息用单引号或双引号括在括号内，二者的作用相同。

To run the program, on your terminal do the following:

要运行该程序，请在您的终端上执行以下操作：

renan@mypc:~$ python3 second_program.py

The output is:

输出为：

Second Program

句法 (Syntax)

Python is known for its clean syntax.

Python以其干净的语法而闻名。

The language avoids using unnecessary characters to indicate some specificity.

该语言避免使用不必要的字符来表示某些特定性。

分号 (Semicolons)

Python doesn't use semicolons to finish lines. A new line is enough to tell the interpreter that a new command is beginning.

Python不使用分号来结束行。换行足以告知解释器新命令正在开始。

The print() method will display something.

print()方法将显示某些内容。

In this example, we have two commands that will display the messages inside the single quotes.

在此示例中，我们有两个命令将在单引号内显示消息。

print('First command')
print('Second command')

Output:

输出：

First command
Second command

But the following is wrong due to the semicolons in the end:

但是由于最后的分号，以下是错误的：

print('First command');
print('Second command');

缩进 (Indentation)

Many languages use curly-brackets to define scope.

许多语言使用花括号来定义范围。

Python's interpreter uses only indentation to define when a scope ends and another one starts.

Python的解释器仅使用缩进来定义范围的结束时间和另一个范围的开始时间。

This means you have to be aware of white spaces at the beginning of each line -- they have meaning and might break your code if misplaced.

这意味着您必须注意每行开头的空格-它们具有含义，如果放错位置，可能会破坏您的代码。

This definition of a function works:

这个函数的定义起作用：

def my_function():
    print('First command')

This doesn't work because the indentation of the second line is missing and will throw an error:

这不起作用，因为缺少第二行的缩进，将引发错误：

def my_function():
print('First command')

区分大小写和变量 (Case sensitivity and variables)

Python is case sensitive. So the variables name and Name are not the same thing and store different values.

Python区分大小写。因此，变量name和Name不是同一件事，并且存储不同的值。

name = 'Renan'
Name = 'Moura'

As you can see, variables are easily created by just assigning values to them using the = symbol.

如您所见，只需使用=符号为变量赋值即可轻松创建变量。

This means name stores 'Renan' and Name stores 'Moura'.

这意味着name存储“ Renan”和Name存储“ Moura”。

注释 (Comments)

Finally, to comment something in your code, use the hash mark #.

最后，要在代码中添加注释，请使用井号# 。

The commented part does not influence the program flow.

注释的部分不会影响程序流程。

# this function prints something
def my_function():
    print('First command')

This was just an overview. The details of each of these will become clearer in the next chapters with examples and broader explanations.

这只是一个概述。在下面的章节中，将通过示例和更广泛的解释使这些内容的细节变得更加清晰。

注释 (Comments)

The purpose of comments is to explain what is happening in the code.

注释的目的是解释代码中正在发生的事情。

Comments are written along with your code but do not influence your program flow.

注释与您的代码一起编写，但不会影响您的程序流程。

When you work by yourself, maybe comments don't feel like something you should write. After all, at the moment, you know the whys of every single line of code.

当您自己工作时，注释可能不适合您编写。毕竟，您现在知道每一行代码的原因。

But what if new people come on board your project after a year and the project has 3 modules, each with 10,000 lines of code?

但是，如果一年后有新人加入您的项目，并且该项目有3个模块，每个模块有10,000行代码，该怎么办？

Think about people who don't know a thing about your app and who are suddenly having to maintain it, fix it, or add new features.

考虑一下那些对您的应用一无所知的人，而这些人突然不得不维护，修复或添加新功能。

Remember, there is no single solution for a given problem. Your way of solving things is yours and yours only. If you ask 10 people to solve the same problem, they will come up with 10 different solutions.

请记住，对于给定的问题，没有单一的解决方案。您解决问题的方式仅属于您自己。如果您要求10个人解决同一问题，他们将提出10种不同的解决方案。

If you want others to fully understand your reasoning, good code design is mandatory, but comments are an integral part of any codebase.

如果您希望其他人完全理解您的推理，则必须进行良好的代码设计，但是注释是任何代码库的组成部分。

如何用Python编写注释 (How to Write Comments in Python)

The syntax of comments in Python is rather easy: just use the hash mark # symbol in front of the text you want to be a comment.

Python中注释的语法非常简单：只需在要注释的文本前面使用井号#符号即可。

#This is a comment and it won't influence my program flow

You can use a comment to explain what some piece of code does.

您可以使用注释来解释某些代码的作用。

#calculates the sum of any given two numbers
a + b

多行注释 (Multiline Comments)

Maybe you want to comment on something very complex or describe how some process works in your code.

也许您想评论一些非常复杂的东西，或者描述某些过程在代码中的工作方式。

In these cases, you can use multiline comments.

在这些情况下，您可以使用多行注释。

To do that, just use a single hash mark # for each line.

为此，只需为每行使用一个井号# 。

#Everything after the hash mark # is a comment
#This is a comment and it won't influence my program flow

#Calculates the cost of the project given variables a and b
#a is the time in months it will take until the project is finished
#b is how much money it will cost per month
a + b * 10

变数 (Variables)

In any program, you need to store and manipulate data to create a flow or some specific logic.

在任何程序中，都需要存储和操作数据以创建流或某些特定逻辑。

That's what variables are for.

这就是变量的用途。

You can have a variable to store a name, another one to store the age of a person, or even use a more complex type to store all of this at once like a dictionary.

您可以使用一个变量来存储名称，使用另一个变量来存储人的年龄，甚至可以使用更复杂的类型像字典一样一次存储所有这些变量。

创建，也称为声明 (Creating, also known as Declaring)

Declaring a variable is a basic and straightforward operation in Python

声明变量是Python中基本而直接的操作

Just pick a name and attribute a value to it using the = symbol.

只需选择一个名称，然后使用=符号为其赋予一个值。

name='Bob'

age=32

You can use the print() function to show the value of a variable.

您可以使用print()函数显示变量的值。

print(name)

print(age)

Bob

32

Notice that in Python there is no special word to declare a variable.

请注意，在Python中，没有特殊的词来声明变量。

The moment you assign a value, the variable is created in memory.

分配值后，将在内存中创建变量。

Python also has dynamic typing, which means you don't have to tell it if your variable is a text or a number, for instance.

Python还具有动态类型，这意味着您不必告诉它变量是文本还是数字。

The interpreter infers the typing based on the value assigned.

解释器根据分配的值推断类型。

If you need it, you can also re-declare a variable just by changing its value.

如果需要，也可以仅通过更改其值来重新声明该变量。

#declaring name as a string
name='Bob'
#re-declaring name as an int
name = 32

Keep in my mind, though, that this is not recommended since variables must have meaning and context.

但是请记住，不建议这样做，因为变量必须具有含义和上下文。

If I have a variable called name I don't expect it to have a number stored in it.

如果我有一个名为name的变量，我不希望它中存储有数字。

命名约定 (Naming Conventions)

Let's continue from the last section when I talked about meaning and context.

让我们从上一节继续讲起意义和上下文。

Don't use random variable names like x or y.

不要使用x或y这样的随机变量名。

Say you want to store the time of a party, just call it party_time.

假设您要存储聚会的时间，只需将其party_time 。

Oh, did you notice the underscore _?

哦，您注意到下划线_吗？

By convention, if you want to use a variable name that is composed of two or more words, you separate them by underscores. This is called Snake Case.

按照惯例，如果要使用由两个或多个单词组成的变量名，请用下划线将它们分开。这就是所谓的蛇案。

Another option would be using CamelCase as in partyTime. This is very common in other languages, but not the convention in Python as stated before.

另一种选择是在partyTime使用CamelCase。这在其他语言中非常常见，但不是前面提到的Python中的约定。

Variables are case sensitive, so party_time and Party_time are not the same. Also, keep in mind that the convention tells us to always use lower case.

变量区分大小写，因此party_time和Party_time不相同。另外，请记住，约定告诉我们始终使用小写字母。

Remember, use names that you can recall inside your program easily. Bad naming can cost you a lot of time and cause annoying bugs.

请记住，使用可以在程序中轻松调用的名称。不好的命名会花费您很多时间，并导致令人讨厌的错误。

In summary, variable names:

总之，变量名：

Are Case sensitive: time and TIME are not the same
区分大小写： time和TIME不同
Have to start with an underscore _ or a letter (DO NOT start with a number)
必须以下划线_或字母开头(请勿以数字开头)
Are allowed to have only numbers, letters and underscores. No special characters like: #, $, &, @, etc.
只能包含数字，字母和下划线。没有特殊字符，例如＃，$，＆，@等。

This, for instance, is not allowed: party#time, 10partytime.

这一点，例如，是不允许的： party#time ， 10partytime 。

种类 (Types)

To store data in Python you need to use a variable. And every variable has its type depending on the value of the data stored.

要在Python中存储数据，您需要使用一个变量。每个变量的类型取决于存储的数据的值。

Python has dynamic typing, which means you don't have to explicitly declare the type of your variable -- but if you want to, you can.

Python具有动态类型，这意味着您不必显式声明变量的类型-但如果愿意，可以。

Lists, Tuples, Sets, and Dictionaries are all data types and have dedicated sections later on with more details, but we'll look at them briefly here.

列表，元组，集合和字典都是数据类型，稍后将在专用部分中提供更多详细信息，但我们将在此处对其进行简要介绍。

This way I can show you the most important aspects and operations of each one in their own section while keeping this section more concise and focused on giving you a broad view of the main data types in Python.

这样，我可以在各自的部分中向您展示每个部分的最重要方面和操作，同时使本部分更加简洁，并专注于为您提供Python主要数据类型的广泛视图。

确定类型 (Determining the Type)

First of all, let's learn how to determine the data type.

首先，让我们学习如何确定数据类型。

Just use the type() function and pass the variable of your choice as an argument, like the example below.

只需使用type()函数并将您选择的变量作为参数传递，就像下面的示例一样。

print(type(my_variable))

布尔型 (Boolean)

The boolean type is one of the most basic types of programming.

布尔类型是最基本的编程类型之一。

A boolean type variable can only represent either True or False.

布尔类型变量只能表示True或False 。

my_bool = True
print(type(my_bool))

my_bool = bool(1024)
print(type(my_bool))

<class 'bool'>
<class 'bool'>

号码 (Numbers)

There are three types of numeric types: int, float, and complex.

共有三种类型的数字类型：int，float和complex。

整数 (Integer)

my_int = 32
print(type(my_int))

my_int = int(32)
print(type(my_int))

<class 'int'>
<class 'int'>

浮动 (Float)

my_float = 32.85
print(type(my_float))

my_float = float(32.85)
print(type(my_float))

<class 'float'>
<class 'float'>

复杂 (Complex)

my_complex_number = 32+4j
print(type(my_complex_number))

my_complex_number = complex(32+4j)
print(type(my_complex_number))

<class 'complex'>
<class 'complex'>

串 (String)

The text type is one of the most commons types out there and is often called string or, in Python, just str.

文本类型是最常见的类型之一，通常称为字符串，或者在Python中仅称为str 。

my_city = "New York"
print(type(my_city))

#Single quotes have exactly
#the same use as double quotes
my_city = 'New York'
print(type(my_city))

#Setting the variable type explicitly
my_city = str("New York")
print(type(my_city))

<class 'str'>
<class 'str'>
<class 'str'>

You can use the + operator to concatenate strings.

您可以使用+运算符来连接字符串。

Concatenation is when you have two or more strings and you want to join them into one.

串联是指当您有两个或多个字符串并且想要将它们连接成一个字符串时。

word1 = 'New '
word2 = 'York'

print(word1 + word2)

New York

The string type has many built-in methods that let us manipulate them. I will demonstrate how some of these methods work.

字符串类型具有许多内置方法，可让我们对其进行操作。我将演示其中一些方法的工作原理。

The len() function returns the length of a string.

len()函数返回字符串的长度。

print(len('New York'))

The replace() method replaces a part of the string with another. As an example, let's replace 'New' for 'Old'.

replace()方法将字符串的一部分替换为另一部分。例如，让我们用“旧”替换“新”。

print('New York'.replace('New', 'Old'))

Old York

The upper() method will return all characters as uppercase.

upper()方法将以大写形式返回所有字符。

print('New York'.upper())

NEW YORK

The lower() method does the opposite, and returns all characters as lowercase.

lower()方法执行相反的操作，并以小写形式返回所有字符。

print('New York'.lower())

new york

清单 (Lists)

A list has its items ordered and you can add the same item as many times as you want. An important detail is that lists are mutable.

列表中的项目已排序，您可以根据需要添加相同的项目多次。一个重要的细节是列表是可变的。

Mutability means you can change a list after its creation by adding items, removing them, or even just changing their values. These operations will be demonstrated later in the section dedicated to Lists.

可变性意味着您可以在列表创建后通过添加项目，删除它们甚至更改其值来更改列表。这些操作将在后面的“列表”部分中进行演示。

my_list = ["bmw", "ferrari", "maclaren"]
print(type(my_list))

my_list = list(("bmw", "ferrari", "maclaren"))
print(type(my_list))

<class 'list'>
<class 'list'>

元组 (Tuples)

A tuple is just like a list: ordered, and allows repetition of items.

元组就像一个列表：有序，并且允许重复项。

There is just one difference: a tuple is immutable.

只有一个区别：元组是不可变的。

Immutability means you can't change a tuple after its creation. If you try to add an item or update one, for instance, the Python intepreter will show you an error. I will show that these errors occur later in the section dedicated to Tuples.

不变性意味着创建元组后不能更改它。例如，如果您尝试添加一项或更新一项，Python解释器将向您显示错误。我将在后面有关元组的部分中说明这些错误。

my_tuple = ("bmw", "ferrari", "maclaren")
print(type(my_tuple))

my_tuple = tuple(("bmw", "ferrari", "maclaren"))
print(type(my_tuple))

<class 'tuple'>
<class 'tuple'>

套装 (Sets)

Sets don't guarantee the order of the items and are not indexed.

集合不保证项目的顺序，也不会建立索引。

A key point when using sets: they don't allow repetition of an item.

使用集合时的关键点：它们不允许重复项。

my_set = {"bmw", "ferrari", "maclaren"}
print(type(my_set))


my_set = set(("bmw", "ferrari", "maclaren"))
print(type(my_set))

<class 'set'>
<class 'set'>

辞典 (Dictionaries)

A dictionary doesn't guarantee the order of the elements and is mutable.

字典不能保证元素的顺序，并且是可变的。

One important characteristic in dictionaries is that you can set your own access keys for each element.

字典的一个重要特征是您可以为每个元素设置自己的访问键。

my_dict = {"country" : "France", "worldcups" : 2}
print(type(my_dict))

my_dict = dict(country="France", worldcups=2)
print(type(my_dict))

<class 'dict'>
<class 'dict'>

类型转换 (Typecasting)

Typecasting allows you to convert between different types.

类型转换使您可以在不同类型之间进行转换。

This way you can have an int turned into a str, or a float turned into an int, for instance.

这样，您可以将int转换为str ，或者将float转换为int 。

显式转换 (Explicit conversion)

To cast a variable to a string just use the str() function.

要将变量转换为字符串，只需使用str()函数。

# this is just a regular explicit intialization
my_str = str('32') 
print(my_str)

# int to str
my_str = str(32) 
print(my_str)

# float to str
my_str = str(32.0)
print(my_str)

32
32
32.0

To cast a variable to an integer just use the int() function.

要将变量转换为整数，只需使用int()函数。

# this is just a regular explicit intialization
my_int = int(32) 
print(my_int)

# float to int: rounds down to 3
my_int = int(3.2) 
print(my_int)

# str to int
my_int = int('32') 
print(my_int)

32
3
32

To cast a variable to a float just use the float() function.

要将变量强制转换为浮点数，只需使用float()函数。

# this is an explicit intialization
my_float = float(3.2)   
print(my_float)

# int to float
my_float = float(32)     
print(my_float)

# str to float
my_float = float('32')  
print(my_float)

3.2
32.0
32.0

What I did above is called an explicit type conversion.

我在上面所做的称为显式类型转换。

In some cases you don't need to do the conversion explicitly, since Python can do it by itself.

在某些情况下，您不需要显式进行转换，因为Python可以自己进行转换。

隐式转换 (Implicit conversion)

The example below shows implicit conversion when adding an int and a float.

下面的示例显示了添加int和float时的隐式转换。

Notice that my_sum is float. Python uses float to avoid data loss since the int type can not represent the decimal digits.

注意my_sum是float 。 Python使用float来避免数据丢失，因为int类型不能表示十进制数字。

my_int = 32
my_float = 3.2

my_sum = my_int + my_float

print(my_sum)

print(type(my_sum))

35.2
<class 'float'>

On the other hand, in this example, when you add an int and a str, Python will not be able to make the implicit conversion, and the explicit type conversion is necessary.

另一方面，在此示例中，当添加int和str ，Python将无法进行隐式转换，因此显式类型转换是必需的。

my_int = 32
my_str = '32'

# explicit conversion works
my_sum = my_int + int(my_str)
print(my_sum)

#implicit conversion throws an error
my_sum = my_int + my_str

64

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'

The same error is thrown when trying to add float and str types without making an explicit conversion.

尝试添加float和str类型而不进行显式转换时，将引发相同的错误。

my_float = 3.2
my_str = '32'

# explicit conversion works
my_sum = my_float + float(my_str)
print(my_sum)

#implicit conversion throws an error
my_sum = my_float + my_str

35.2

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'float' and 'str'

用户输入 (User Input)

If you need to interact with a user when running your program in the command line (for example, to ask for a piece of information), you can use the input() function.

如果在命令行中运行程序时需要与用户进行交互(例如，要求提供一条信息)，则可以使用input()函数。

country = input("What is your country? ") #user enters 'Brazil'

print(country)

Brazil

The captured value is always string. Just remember that you might need to convert it using typecasting.

捕获的值始终为string 。请记住，您可能需要使用类型转换对其进行转换。

age = input("How old are you? ") #user enters '29'

print(age)

print(type(age))

age = int(age)

print(type(age))

The output for each print() is:

每个print()的输出是：

29

<class 'str'>

<class 'int'>

Notice the age 29 is captured as string and then converted explicitly to int.

请注意，年龄29被捕获为string ，然后显式转换为int 。

经营者 (Operators)

In a programming language, operators are special symbols that you can apply to your variables and values in order to perform operations such as arithmetic/mathematical and comparison.

在编程语言中，运算符是特殊符号，可以将其应用于变量和值，以执行算术/数学和比较等操作。

Python has lots of operators that you can apply to your variables and I will demonstrate the most used ones.

Python有很多运算符，您可以将它们应用于变量，我将演示最常用的运算符。

算术运算符 (Arithmetic Operators)

Arithmetic operators are the most common type of operators and also the most recognizable ones.

算术运算符是最常见的运算符，也是最易识别的运算符。

They allow you to perform simple mathematical operations.

它们使您可以执行简单的数学运算。

They are:

他们是：

+: Addition
+ ：加法
-: Subtraction
- ：减法
*: Multiplication
* ：乘法
/: Division
/ ：部门
**: Exponentiation
** ：求幂
//: Floor Division, rounds down the result of a division
// ：底数除法，将四舍五入的结果取整
%: Modulus, gives you the remainder of a division
% ：模数，给你除法的余数

Let's see a program that shows how each of them is used.

让我们来看一个显示如何使用它们的程序。

print('Addition:', 5 + 2)
print('Subtraction:', 5 - 2)
print('Multiplication:', 5 * 2)
print('Division:', 5 / 2)
print('Floor Division:', 5 // 2)
print('Exponentiation:', 5 ** 2)
print('Modulus:', 5 % 2)

Addition: 7

Subtraction: 3

Multiplication: 10

Division: 2.5

Floor Division: 2

Exponentiation: 25

Modulus: 1

级联 (Concatenation)

Concatenation is when you have two or more strings and you want to join them into one.

串联是指当您有两个或多个字符串并且想要将它们连接成一个字符串时。

This useful when you have information in multiple variables and want to combine them.

当您有多个变量中的信息并希望将它们组合在一起时，此功能很有用。

For instance, in this next example I combine two variables that contain my first name and my last name respectively to have my full name.

例如，在下一个示例中，我组合了两个变量，分别包含我的名字和我的姓氏以拥有我的全名。

The + operator is also used to concatenate.

+运算符还用于连接。

first_name = 'Renan '
last_name = 'Moura'

print(first_name + last_name)

Renan Moura

Since concatenation is applied to strings, to concatenate strings with other types, you have to do an explicit typecast using str().

由于将串联应用于字符串，因此要将字符串与其他类型串联，您必须使用str()进行显式类型转换。

I have to typecast the int value 30 to string with str() to concatenate it with the rest of the string.

我必须使用str()将int值30转换为字符串，以将其与其余字符串连接起来。

age = 'I have ' + str(30) + ' years old'

print(age)

I have 30 years old

比较运算符 (Comparison Operators)

Use comparison operators to compare two values.

使用比较运算符比较两个值。

These operators return either True or False.

这些运算符返回True或False 。

They are:

他们是：

==: Equal
== ：等于
!=: Not equal
!= ：不相等
>: Greater than
> ：大于
<: Less than
< ：小于
>=: Greater than or equal to
>= ：大于或等于
<=: Less than or equal to
<= ：小于或等于

Let's see a program that shows how each of them is used.

让我们来看一个显示如何使用它们的程序。

print('Equal:', 5 == 2)
print('Not equal:', 5 != 2)
print('Greater than:', 5 > 2)
print('Less than:', 5 < 2)
print('Greater than or equal to:', 5 >= 2)
print('Less than or equal to:', 5 <= 2)

Equal: False

Not equal: True

Greater than: True

Less than: False

Greater than or equal to: True

Less than or equal to: False

赋值运算符 (Assignment Operators)

As the name implies, these operators are used to assign values to variables.

顾名思义，这些运算符用于为变量分配值。

x = 7 in the first example is a direct assignment storing the number 7 in the variable x.

第一个示例中的x = 7是将数字7存储在变量x的直接赋值。

The assignment operation takes the value on the right and assigns it to the variable on the left.

赋值操作将右边的值分配给左边的变量。

The other operators are simple shorthands for the Arithmetic Operators.

其他运算符是算术运算符的简单简写。

In the second example x starts with 7 and x += 2 is just another way to write x = x + 2. This means the previous value of x is added by 2 and reassigned to x that is now equal to 9.

在第二个示例中， x以7开头， x += 2是写x = x + 2另一种方式。这意味着x的先前值被2并重新分配给x ，现在等于9 。

=: simple assignment
= ：简单分配

x = 7
print(x)

+=: addition and assignment
+= ：加法和赋值

x = 7
x += 2
print(x)

-=: subtraction and assignment
-= ：减法和赋值

x = 7
x -= 2
print(x)

*=: multiplication and assignment
*= ：乘法和赋值

x = 7
x *= 2
print(x)

/=: division and assignment
/= ：除法和赋值

x = 7
x /= 2
print(x)

3.5

%=: modulus and assignment
%= ：模数和赋值

x = 7
x %= 2
print(x)

//=: floor division and assignment
//= ：楼层划分和分配

x = 7
x //= 2
print(x)

**=: exponentiation and assignment
**= ：求幂和赋值

x = 7
x **= 2
print(x)

逻辑运算符 (Logical Operators)

Logical operators are used to combine statements applying boolean algebra.

逻辑运算符用于组合使用布尔代数的语句。

They are:

他们是：

and: True only when both statements are true
and ： True只有当两个陈述是真实的
or: False only when both x and y are false
or ： False只有当X和Y都是假的
not: The not operator simply inverts the input, True becomes False and vice versa.
not ： not运算符会简单地反转输入， True变为False ，反之亦然。

Let's see a program that shows how each one is used.

让我们看一个显示如何使用每个程序的程序。

x = 5
y = 2

print(x == 5 and y > 3) 
  
print(x == 5 or y > 3) 
  
print(not (x == 5))

False

True

False

会员运营商 (Membership Operators)

These operators provide an easy way to check if a certain object is present in a sequence: string, list, tuple, set, and dictionary.

这些运算符提供了一种简便的方法来检查序列中是否存在某个对象： string ， list ， tuple ， set和dictionary 。

They are:

他们是：

in: returns True if the object is present
in ：如果存在对象，则返回True
not in: returns True if the object is not present
not in ：如果不存在该对象，则返回True

Let's see a program that shows how each one is used.

让我们看一个显示如何使用每个程序的程序。

number_list = [1, 2, 4, 5, 6]

print( 1 in number_list)

print( 5 not in number_list)

print( 3 not in number_list)

True

False

True

有条件的 (Conditionals)

Conditionals are one of the cornerstones of any programming language.

条件是任何编程语言的基石之一。

They allow you to control the program flow according to specific conditions you can check.

它们使您可以根据可以检查的特定条件控制程序流程。

`if`语句 (The `if` statement)

The way you implement a conditional is through the if statement.

实现条件的方式是通过if语句。

The general form of an if statement is:

if语句的一般形式为：

if expression:
    statement

The expression contains some logic that returns a boolean, and the statement is executed only if the return is True.

该expression包含一些返回布尔值的逻辑，并且仅在返回值为True时才执行该statement 。

A simple example:

一个简单的例子：

bob_age = 32
sarah_age = 29

if bob_age > sarah_age:
    print('Bob is older than Sarah')

Bob is older than Sarah

We have two variables indicating the ages of Bob and Sarah. The condition in plain English says "if Bob's age is greater than Sarah's age, then print the phrase 'Bob is older than Sarah'".

我们有两个变量指示鲍勃和莎拉的年龄。普通英语的条件是“如果Bob的年龄大于Sarah的年龄，则打印短语'Bob比Sarah大”。

Since the condition returns True, the phrase will be printed on the console.

由于条件返回True ，因此该短语将被打印在控制台上。

`if else`和`elif`语句 (The `if else` and `elif` statements)

In our last example, the program only does something if the condition returns True.

在我们的最后一个示例中，仅当条件返回True ，程序才会执行某些操作。

But we also want it to do something if it returns False or even check a second or third condition if the first one wasn't met.

但是，我们也希望它在返回False执行某些操作，或者甚至在不满足第一个条件时检查第二个或第三个条件。

In this example, we swapped Bob's and Sarah's age. The first condition will return False since Sarah is older now, and then the program will print the phrase after the else instead.

在此示例中，我们交换了鲍勃和莎拉的年龄。由于Sarah现在年龄较大，第一个条件将返回False ，然后程序将在else后面打印该短语。

bob_age = 29
sarah_age = 32

if bob_age > sarah_age:
    print('Bob is older than Sarah')
else:
    print('Bob is younger than Sarah')

Bob is younger than Sarah

Now, consider the example below with the elif.

现在，考虑下面带有elif的示例。

bob_age = 32
sarah_age = 32

if bob_age > sarah_age:
    print('Bob is older than Sarah')
elif bob_age == sarah_age:
    print('Bob and Sarah have the same age')
else:
    print('Bob is younger than Sarah')

Bob and Sarah have the same age

The purpose of the elif is to provide a new condition to be checked before the else is executed.

elif的目的是提供一个在执行else之前要检查的新条件。

Once again we changed their ages and now both are 32 years old.

我们再次改变了他们的年龄，现在他们都已经32岁了。

As such, the condition in the elif is met. Since both have the same age the program will print "Bob and Sarah have the same age".

这样，满足了elif的条件。由于两者的年龄相同，程序将打印“ Bob和Sarah具有相同的年龄”。

Notice you can have as many elifs as you want, just put them in sequence.

请注意，您可以根据需要设置任意多个elif ，只需将它们依次放置即可。

bob_age = 32
sarah_age = 32

if bob_age > sarah_age:
    print('Bob is older than Sarah')
elif bob_age < sarah_age:
    print('Bob is younger than Sarah')
elif bob_age == sarah_age:
    print('Bob and Sarah have the same age')
else:
    print('This one is never executed')

Bob and Sarah have the same age

In this example, the else is never executed because all the possibilities are covered in the previous conditions and thus could be removed.

在此示例中，永远不会执行else因为所有可能性在先前条件中均已涵盖，因此可以删除。

嵌套条件 (Nested conditionals)

You might need to check more than one conditional for something to happen.

您可能需要检查多个条件才能发生某些事情。

In this case, you can nest your if statements.

在这种情况下，您可以嵌套if语句。

For instance, the second phrase "Bob is the oldest" is printed only if both ifs pass.

例如，只有if s和b都通过时，才会打印第二个短语“鲍勃是最老的”。

bob_age = 32
sarah_age = 28
mary_age = 25

if bob_age > sarah_age:
    print('Bob is older than Sarah')
    if bob_age > mary_age:
        print('Bob is the oldest')

Bob is older than Sarah
Bob is the oldest

Or, depending on the logic, make it simpler with Boolean Algebra.

或者，根据逻辑，使用布尔代数使其更简单。

This way, your code is smaller, more readable and easier to maintain.

这样，您的代码更小，更易读且更易于维护。

bob_age = 32
sarah_age = 28
mary_age = 25

if bob_age > sarah_age and bob_age > mary_age:
    print('Bob is the oldest')

Bob is the oldest

三元运算符 (Ternary Operators)

The ternary operator is a one-line if statement.

三元运算符是单行if语句。

It's very handy for simple conditions.

对于简单的条件，它非常方便。

This is how it looks:

看起来是这样的：

<expression> if <condition> else <expression>

Consider the following Python code:

考虑以下Python代码：

a = 25
b = 50
x = 0
y = 1

result = x if a > b else y

print(result)

Here we use four variables, a and b are for the condition, while x and y represent the expressions.

这里我们使用四个变量， a和b表示条件，而x和y表示表达式。

a and b are the values we are checking against each other to evaluate some condition. In this case, we are checking if a is greater than b.

a和b是我们为了确定某种条件而相互检查的值。在这种情况下，我们正在检查a是否大于b 。

If the expression holds true, i.e., a is greater than b, then the value of x will be attributed to result which will be equal to 0.

如果表达式为真，即a大于b ，则x的值将归因于result ，该值等于0。

However, if a is less than b, then we have the value of y assigned to result, and result will hold the value 1.

但是，如果a小于b ，那么我们将y的值分配给result ，并且result将保持值1 。

Since a is less than b, 25 < 50, result will have 1 as final value from y.

由于a小于b ，25 <50， result将具有1从最终值y 。

The easy way to remember how the condition is evaluated is to read it in plain English.

记住条件评估方式的简单方法是用简单的英语阅读。

Our example would read: result will be x if a is greater than b otherwise y.

我们的示例将显示为：如果a大于b则result为x ，否则为y 。

清单 (Lists)

As promised in the Types section, this section and the next three about Tuples, Sets, and Dictionaries will have more in depth explanations of each of them since they are very important and broadly used structures in Python to organize and deal with data.

正如“ 类型”部分中所承诺的那样，本部分以及有关元组，集合和字典的下三部分将对它们中的每一个进行更深入的说明，因为它们是非常重要的，并且在Python中被广泛使用以组织和处理数据。

A list has its items ordered and you can add the same item as many times as you want.

列表中的项目已排序，您可以根据需要添加相同的项目多次。

An important detail is that lists are mutable.

一个重要的细节是列表是可变的。

Mutability means you can change a list after its creation by adding items, removing them, or even just changing their values.

可变性意味着您可以在列表创建后通过添加项目，删除它们甚至更改其值来更改列表。

初始化 (Initialization)

空清单 (Empty List)

people = []

列出初始值 (List with initial values)

people = ['Bob', 'Mary']

新增清单 (Adding in a List)

To add an item in the end of a list, use append().

要在列表末尾添加项目，请使用append() 。

people = ['Bob', 'Mary']
people.append('Sarah')

print(people)

['Bob', 'Mary', 'Sarah']

To specify the position for the new item, use the insert() method.

要指定新项目的位置，请使用insert()方法。

people = ['Bob', 'Mary']
people.insert(0, 'Sarah')

print(people)

['Sarah', 'Bob', 'Mary']

更新清单 (Updating in a List)

Specify the position of the item to update and set the new value

指定要更新的项目的位置并设置新值

people = ['Bob', 'Mary']
people[1] = 'Sarah'
print(people)

['Bob', 'Sarah']

删除列表 (Deleting in a List)

Use the remove() method to delete the item given as an argument.

使用remove()方法删除作为参数给出的项目。

people = ['Bob', 'Mary']
people.remove('Bob')
print(people)

['Mary']

To delete everybody, use the clear() method:

要删除所有人，请使用clear()方法：

people = ['Bob', 'Mary']
people.clear()

检索列表 (Retrieving in a List)

Use the index to reference the item.

使用索引来引用项目。

Remember that the index starts at 0.

请记住，索引从0开始。

So to access the second item use the index 1.

因此，要访问第二项，请使用索引1。

people = ['Bob', 'Mary']
print(people[1])

Mary

检查列表中是否已存在给定项目 (Check if a given item already exists in a List)

people = ['Bob', 'Mary']

if 'Bob' in people:
  print('Bob exists!')
else:
  print('There is no Bob!')

元组 (Tuples)

A tuple is similar to a list: it's ordered, and allows repetition of items.

元组类似于列表：它是有序的，并且允许重复项。

There is just one difference: a tuple is immutable.

只有一个区别：元组是不可变的。

Immutability, if you remember, means you can't change a tuple after its creation. If you try to add an item or update one, for instance, the Python interpreter will show you an error.

如果您还记得，不变性意味着在创建元组之后就不能更改它。例如，如果您尝试添加一项或更新一项，Python解释器将向您显示错误。

初始化 (Initialization)

空元组 (Empty Tuple)

people = ()

具有初始值的元组 (Tuple with initial values)

people = ('Bob', 'Mary')

添加一个元组 (Adding in a Tuple)

Tuples are immutable. This means that if you try to add an item, you will see an error.

元组是不可变的。这意味着，如果您尝试添加项目，将看到错误。

people = ('Bob', 'Mary')
people[2] = 'Sarah'

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

在元组中更新 (Updating in a Tuple)

Updating an item will also return an error.

更新项目也会返回错误。

But there is a trick: you can convert into a list, change the item, and then convert it back to a tuple.

但是有一个窍门：您可以转换为列表，更改项目，然后将其转换回元组。

people = ('Bob', 'Mary')
people_list = list(people)
people_list[1] = 'Sarah'
people = tuple(people_list)
print(people)

('Bob', 'Sarah')

在元组中删除 (Deleting in a Tuple)

For the same reason you can't add an item, you also can't delete an item, since they are immutable.

出于相同的原因，您不能添加项目，也不能删除项目，因为它们是不可变的。

在元组中检索 (Retrieving in a Tuple)

Use the index to reference the item.

使用索引来引用项目。

people = ('Bob', 'Mary')
print(people[1])

Mary

检查给定项目在元组中是否已经存在 (Check if a given item already exists in a Tuple)

people = ('Bob', 'Mary')

if 'Bob' in people:
  print('Bob exists!')
else:
  print('There is no Bob!')

套装 (Sets)

Sets don't guarantee the order of items and are not indexed.

集合不保证项目的顺序，也不会建立索引。

A key point when using sets: they don't allow repetition of an item.

使用集合时的关键点：它们不允许重复项。

初始化 (Initialization)

空集 (Empty Set)

people = set()

设置初始值 (Set with initial values)

people = {'Bob', 'Mary'}

集合中 (Adding in a Set)

Use the add() method to add one item.

使用add()方法添加一项。

people.add('Sarah')

Use the update() method to add multiple items at once.

使用update()方法一次添加多个项目。

people.update(['Carol', 'Susan'])

Remember, Sets do not allow repetition, so if you add 'Mary' again, nothing changes.

请记住，集合不允许重复，因此如果再次添加“ Mary”，则不会发生任何变化。

people = {'Bob', 'Mary'}

people.add('Mary')

print(people)

{'Bob', 'Mary'}

一组更新 (Updating in a Set)

Items in a set are not mutable. You have to either add or delete an item.

集合中的项目是不可变的。您必须添加或删除项目。

删除集合 (Deleting in a Set)

To remove Bob from the dictionary:

要从字典中删除Bob：

people = {'Bob', 'Mary'}
people.remove('Bob')
print(people)

{'Mary'}

To delete everybody:

要删除所有人：

people.clear()

检查给定项目是否已存在于集合中 (Check if a given item already exists in a set)

people = {'Bob', 'Mary'}

if 'Bob' in people:
  print('Bob exists!')
else:
  print('There is no Bob!')

辞典 (Dictionaries)

The dictionary doesn't guarantee the order of the elements and it is mutable.

字典不保证元素的顺序，并且是可变的。

One important characteristic of dictionaries is that you can set your customized access keys for each element.

词典的一个重要特征是可以为每个元素设置自定义的访问键。

字典的初始化 (Initialization of a Dictionary)

空字典 (Empty Dictionary)

people = {}

具有初始值的字典 (Dictionary with initial values)

people = {'Bob':30, 'Mary':25}

添加字典 (Adding in a Dictionary)

If the key doesn't exist yet, it is appended to the dictionary.

如果该键尚不存在，则将其附加到字典中。

people['Sarah']=32

更新字典 (Updating a Dictionary)

If the key already exists, the value is just updated.

如果键已经存在，则仅更新值。

#Bob's age is 28 now
people['Bob']=28

Notice that the code is pretty much the same.

注意，代码几乎相同。

删除字典 (Deleting in a Dictionary)

To remove Bob from the dictionary:

要从字典中删除Bob：

people.pop('Bob')

To delete everybody:

要删除所有人：

people.clear()

检索字典 (Retrieving in a Dictionary)

bob_age = people['Bob']
print(bob_age)

检查字典中是否已存在给定键 (Check if a given key already exists in a Dictionary)

if 'Bob' in people:
  print('Bob exists!')
else:
  print('There is no Bob!')

`while`循环 (`while` Loops)

Loops are used when you need to repeat a block of code a certain number of times or apply the same logic over each item in a collection.

当您需要重复一段代码或对集合中的每个项目应用相同的逻辑时，可以使用循环。

There are two types of loops: for and while.

循环有两种类型： for和while 。

You will learn about for loops in the next section.

您将在下一部分中了解for循环。

基本语法 (Basic Syntax)

The basic syntax of a while loop is as below.

while循环的基本语法如下。

while condition:
    statement

The loop will continue while the condition is True.

条件为True 时，循环将继续。

一个数字的平方是 (The square of a number is)

The example below takes each value of number and calculates its squared value.

下面的例子中采用的每个值number并计算其平方值。

number = 1
while number <= 5:
    print(number, 'squared is', number**2)
    number = number + 1

1 squared is 1
2 squared is 4
3 squared is 9
4 squared is 16
5 squared is 25

You can use any variable name, but I chose number because it makes sense in the context. A common generic choice would be simply i.

您可以使用任何变量名，但是我选择了number因为它在上下文中很有意义。常见的通用选择就是i 。

The loop will go on until number (initialized with 1) is less than or equal to 5.

循环将继续进行，直到number (用1初始化)小于或等于5。

Notice that after the print() command, the variable number is incremented by 1 to take the next value.

注意，在print()命令之后，变量number增加1以获取下一个值。

If you don't do the incrementation you will have an infinite loop since number will never reach a value greater than 5. This is a very important detail!

如果不进行递增，则将有无限循环，因为number永远不会达到大于5的值。这是非常重要的细节！

`else`阻止 (`else` block)

When the condition returns False, the else block will be called.

当条件返回False ，将调用else块。

number = 1
while number <= 5:
    print(number, 'squared is', number**2)
    number = number + 1
else:
    print('No numbers left!')

1 squared is 1
2 squared is 4
3 squared is 9
4 squared is 16
5 squared is 25
No numbers left!

Notice the phrase 'No numbers left!' is printed after the loop ends, that is after the condition number <= 5 evaluates to False.

注意短语“没有数字了！” 在循环结束之后(即条件number <= 5计算为False之后)打印。

如何在Python中打破`while`循环 (How to break out of a `while` loop in Python)

Simply use the break keyword, and the loop will stop its execution.

只需使用break关键字，循环就会停止执行。

number = 1
while number <= 5:
    print(number, 'squared is', number**2)
    number = number + 1
    if number == 4:
        break

1 squared is 1
2 squared is 4
3 squared is 9

The loop runs normally, and when number reaches 4 the if statement evaluates to True and the break command is called. This finishes the loop before the squared value of the numbers 4 and 5 are calculated.

循环正常运行，当number达到4时， if语句的值为True并调用break命令。这样就完成了循环，然后计算出数字4和5的平方值。

如何在`while`循环中跳过项目 (How to skip an item in a `while` loop)

The continue will do that for you.

continue将为您做到这一点。

I had to invert the order of the if statement and the print() to show how it works properly.

我必须反转if语句和print()的顺序，以显示其如何正常工作。

number = 0
while number < 5:
    number = number + 1
    if number == 4:
        continue
    print(number, 'squared is', number**2)

1 squared is 1
2 squared is 4
3 squared is 9
5 squared is 25

The program always checks if 4 is the current value of number. If it is, the square of 4 won't be calculated and the continue will skip to the next iteration when the value of number is 5. *

程序将始终检查4是否为number的当前值。如果是，则不会计算4的平方，并且当number值为5时， continue将跳至下一个迭代。

`for`循环 (`for` Loops)

for loops are similar to while loops in the sense that they are used to repeat blocks of code.

for循环与while循环在某种意义上类似，因为它们被用来重复代码块。

The most important difference is that you can easily iterate over sequential types.

最重要的区别是您可以轻松地迭代顺序类型。

基本语法 (Basic Syntax)

The basic syntax of a for loop is as below.

for循环的基本语法如下。

for item in collection:
    statement

遍历列表 (Loop over a list)

To loop over a list or any other collection, just proceed as shown in the example below.

要遍历列表或任何其他集合，只需执行下面的示例所示。

cars = ['BMW', 'Ferrari', 'McLaren']
for car in cars:
    print(car)

BMW
Ferrari
McLaren

The list of cars contains three items. The for loop will iterate over the list and store each item in the car variable, and then execute a statement, in this case print(car), to print each car in the console.

cars列表包含三个项目。 for循环将遍历列表并将每个项目存储在car变量中，然后执行一条语句(在本例中为print(car)在控制台中打印每个car。

`range()`函数 (`range()` function)

The range function is widely used in for loops because it gives you a simple way to list numbers.

范围函数在for循环中得到广泛使用，因为它为您提供了列出数字的简单方法。

This code will loop through the numbers 0 to 5 and print each of them.

该代码将循环显示数字0到5，并打印每个数字。

for number in range(5):
    print(number)

In contrast, without the range() function, we would do something like this.

相反，如果没有range()函数，我们将执行以下操作。

numbers = [0, 1, 2, 3, 4]
for number in numbers:
    print(number)

You can also define a start and stop using range().

您还可以使用range()定义start和stop 。

Here we are starting in 5 and a stoping in 10. The number you set to stop is not included.

在这里，我们从5开始，在10中停止。不包含您设置为停止的数字。

for number in range(5, 10):
    print(number)

Finally, it is also possible to set a step.

最后，也可以设置一个步骤。

Here we starting in 10 and incrementing by 2 until 20, since 20 is the stop, it is not included.

在这里，我们从10开始，再增加2直到20，因为20是stop ，所以不包括在内。

for number in range(10, 20, 2):
    print(number)

`else`阻止 (`else` block)

When the items in the list are over, the else block will be called.

当列表中的项目结束时，将调用else块。

cars = ['BMW', 'Ferrari', 'McLaren']
for car in cars:
    print(car)
else:
    print('No cars left!')

BMW
Ferrari
McLaren
No cars left!

如何在Python中突破for循环 (How to break out of a for loop in Python)

Simply use the break keyword, and the loop will stop its execution.

只需使用break关键字，循环就会停止执行。

cars = ['BMW', 'Ferrari', 'McLaren']
for car in cars:
    print(car)
    if car == 'Ferrari':
        break

BMW
Ferrari

The loop will iterate through the list and print each car.

该循环将遍历列表并打印每辆车。

In this case, after the loop reaches 'Ferrari', the break is called and 'McLaren' won't be printed.

在这种情况下，循环到达“ Ferrari”后，将调用该break ，并且不会打印“ McLaren”。

如何跳过for循环中的项目 (How to skip an item in a for loop)

In this section, we'll learn how continue can do this for you.

在本节中，我们将学习continue如何为您完成此操作。

I had to invert the order of the if statement and the continue to show how it works properly.

我不得不反转if语句的顺序，并continue显示它如何正常工作。

Notice that I always check if 'Ferrari' is the current item. If it is, 'Ferrari' won't be printed, and the continue will skip to the next item 'McLaren'.

请注意，我始终检查“ Ferrari”是否为当前项目。如果是，则不会打印“法拉利”， continue将跳至下一个“迈凯轮”。

cars = ['BMW', 'Ferrari', 'McLaren']
for car in cars:
    if car == 'Ferrari':
        continue
    print(car)

BMW
McLaren

循环循环：嵌套循环 (Loop over a Loop: Nested Loops)

Sometimes you have more complex collections, like a list of lists.

有时您有更复杂的集合，例如列表列表。

To iterate over these lists, you need nested for loops.

要遍历这些列表，您需要嵌套for循环。

In this case, I have three lists: one of BMW models, another on Ferrari models, and finally one with McLaren models.

在这种情况下，我有三个列表：一个是宝马模型，另一个是法拉利模型，最后一个是迈凯轮模型。

The first loop iterates over each brand's list, and the second will iterate over the models of each brand.

第一个循环遍历每个品牌的列表，第二个循环遍历每个品牌的模型。

car_models = [ 
['BMW I8', 'BMW X3', 
'BMW X1'], 
['Ferrari 812', 'Ferrari F8', 
'Ferrari GTC4'], 
['McLaren 570S', 'McLaren 570GT', 
'McLaren 720S']
]

for brand in car_models:
    for model in brand:
        print(model)

BMW I8
BMW X3
BMW X1
Ferrari 812
Ferrari F8
Ferrari GTC4
McLaren 570S
McLaren 570GT
McLaren 720S

遍历其他数据结构 (Loop over other Data Structures)

The same logic that applies for loops over a list can be extended to the other data structures: tuple, set, and dictionary.

适用for list循环的相同逻辑可以扩展到其他数据结构： tuple ， set和dictionary 。

I will briefly demonstrate how to make a basic loop over each one of them.

我将简要演示如何对它们每个进行基本循环。

遍历元组 (Loop over a Tuple)

people = ('Bob', 'Mary')

for person in people:
  print(person)

Bob
Mary

遍历一组 (Loop over a Set)

people = {'Bob', 'Mary'}

for person in people:
  print(person)

Bob
Mary

循环字典 (Loop over a Dictionary)

To print the keys:

要打印密钥：

people = {'Bob':30, 'Mary':25}

for person in people:
  print(person)

Bob
Mary

To print the values:

要打印值：

people = {'Bob':30, 'Mary':25}

for person in people:
  print(people[person])

30
25

功能 (Functions)

As the code grows the complexity also grows. And functions help organize the code.

随着代码的增长，复杂性也随之增长。功能有助于组织代码。

Functions are a handy way to create blocks of code that you can reuse.

函数是创建可重复使用的代码块的便捷方法。

定义和调用 (Definition and Calling)

In Python use the def keyword to define a function.

在Python中，使用def关键字定义一个函数。

Give it a name and use parentheses to inform 0 or more arguments.

给它起一个名字，并用括号告知0个或多个参数。

In the line after the declaration starts, remember to indent the block of code.

在声明开始后的行中，请记住缩进代码块。

Here is an example of a function called print_first_function() that only prints a phrase 'My first function!'.

这是一个名为print_first_function()的函数的示例，该函数仅输出短语“我的第一个函数！”。

To call the function just use its name as defined.

要调用该函数，只需使用其定义的名称即可。

def print_first_function():
    print('My first function!')

print_first_function()

My first function!

`return`值 (`return` a value)

Use the return keyword to return a value from the function.

使用return关键字从函数返回值。

In this example the function second_function() returns the string 'My second function!'.

在此示例中，函数second_function()返回字符串“我的第二个函数！”。

Notice that print() is a built-in function and our function is called from inside it.

注意， print()是一个内置函数，我们的函数是从内部调用的。

The string returned by second_function() is passed as an argument to the print() function.

second_function()返回的字符串作为参数传递给print()函数。

def second_function():
    return 'My second function!'

print(second_function())

My second function!

`return`多个值 (`return` multiple values)

Functions can also return multiple values at once.

函数也可以一次返回多个值。

return_numbers() returns two values simultaneously.

return_numbers()同时返回两个值。

def return_numbers():
    return 10, 2

print(return_numbers())

(10, 2)

争论 (Arguments)

You can define parameters between the parentheses.

您可以在括号之间定义参数。

When calling a function with parameters you have to pass arguments according to the parameters defined.

使用参数调用函数时，必须根据定义的参数传递参数。

The past examples had no parameters, so there was no need for arguments. The parentheses remained empty when the functions were called.

过去的示例没有参数，因此不需要参数。调用函数时，括号保持空白。

一个论点 (One Argument)

To specify one parameter, just define it inside the parentheses.

要指定一个参数，只需在括号内定义它。

In this example, the function my_number expects one number as argument defined by the parameter num.

在此示例中，函数my_number期望一个数字作为参数num定义的参数。

The value of the argument is then accessible inside the function to be used.

然后可以在要使用的函数内部访问参数的值。

def my_number(num):
    return 'My number is: ' + str(num)

print(my_number(10))

My number is: 10

两个或多个参数 (Two or more Arguments)

To define more parameters, just use a comma to separate them.

要定义更多参数，只需使用逗号将它们分开。

Here we have a function that adds two numbers called add. It expects two arguments defined by first_num and second_num.

在这里，我们有一个函数，将两个数字相加，称为add 。它期望由first_num和second_num定义的两个参数。

The arguments are added by the + operator and the result is then returned by the return.

参数由+运算符添加，然后由return 。

def add(first_num, second_num):
    return first_num + second_num

print(add(10,2))

This example is very similar to the last one. The only difference is that we have 3 parameters instead of 2.

这个例子与上一个非常相似。唯一的区别是我们有3个参数，而不是2个。

def add(first_num, second_num, third_num):
    return first_num + second_num + third_num

print(add(10,2,3))

This logic of defining parameters and passing arguments is the same for any number of parameters.

定义参数和传递参数的逻辑对于任意数量的参数都是相同的。

It is important to point out that the arguments have to be passed in the same order that the parameters are defined.

重要的是要指出，必须按照定义参数的顺序传递参数。

默认值。 (Default value.)

You can set a default value for a parameter if no argument is given using the = operator and a value of choice.

如果未使用=运算符和选择值给出参数，则可以为参数设置默认值。

In this function, if no argument is given, the number 30 is assumed as the expected value by default.

在此函数中，如果未提供任何参数，则默认情况下将数字30假定为期望值。

def my_number(my_number = 30):
    return 'My number is: ' + str(my_number)

print(my_number(10))
print(my_number())

My number is: 10
My number is: 30

关键字或命名参数 (Keyword or Named Arguments)

When calling a function, the order of the arguments have to match the order of the parameters.

调用函数时，参数的顺序必须与参数的顺序匹配。

The alternative is if you use keyword or named arguments.

替代方法是使用关键字或命名参数。

Set the arguments to their respective parameters directly using the name of the parameters and the = operators.

直接使用参数名称和=运算符将参数设置为其各自的参数。

This example flips the arguments, but the function works as expected because I tell it which value goes to which parameter by name.

此示例翻转了参数，但是该函数按预期工作，因为我告诉它名称将哪个值分配给了哪个参数。

def my_numbers(first_number, second_number):
    return 'The numbers are: ' + str(first_number) + ' and ' + str(second_number)

print(my_numbers(second_number=30, first_number=10))

The numbers are: 10 and 30

任意数量的参数： `args` (Any number of arguments: `args`)

If you don't want to specify the number of parameters, just use the * before the parameter name. Then the function will take as many arguments as necessary.

如果不想指定参数数量，只需在参数名称前使用* 。然后，该函数将接受尽可能多的参数。

The parameter name could be anything like *numbers, but there is a convention in Python to use *args for this definition of a variable number of arguments.

参数名称可以是*numbers类的东西，但是Python中有一个约定，可以使用*args来定义可变数量的参数。

def my_numbers(*args):
    for arg in args:
        print(number)

my_numbers(10,2,3)

10
2
3

任意数量的关键字/命名参数： `kwargs` (Any number of Keyword/Named arguments: `kwargs`)

Similar to *args, we can use **kwargs to pass as many keyword arguments as we want, as long as we use **.

类似*args ，我们可以使用**kwargs传递尽可能多的关键字参数，因为我们希望，只要我们使用** 。

Again, the name could be anything like **numbers, but **kwargs is a convention.

Again, the name could be anything like **numbers , but **kwargs is a convention.

def my_numbers(**kwargs):
    for key, value in kwargs.items():
        print(key)
        print(value)

my_numbers(first_number=30, second_number=10)

first_number
30
second_number
10

Other types as arguments (Other types as arguments)

The past examples used mainly numbers, but you can pass any type as argument and they will be treated as such inside the function.

This example takes strings as arguments.

def my_sport(sport):
    print('I like ' + sport)

my_sport('football')
my_sport('swimming')

I like football
I like swimming

This function takes a list as argument.

def my_numbers(numbers):
    for number in numbers:
        print(number)

my_numbers([30, 10, 64, 92, 105])

范围 (Scope)

The place where a variable is created defines its availability to be accessed and manipulated by the rest of the code. This is known as scope.

The place where a variable is created defines its availability to be accessed and manipulated by the rest of the code. This is known as scope .

There are two types of scope: local and global.

Global Scope (Global Scope)

A global scope allows you to use the variable anywhere in your program.

If your variable is outside a function, it has global scope by default.

name = 'Bob'

def print_name():
  print('My name is ' + name)

print_name()

My name is Bob

Notice that the function could use the variable name and print My name is Bob.

Notice that the function could use the variable name and print My name is Bob .

Local Scope (Local Scope)

When you declare a variable inside a function, it only exists inside that function and can't be accessed from the outside.

def print_name():
	name = "Bob"
	print('My name is ' + name)

print_name()

My name is Bob

The variable name was declared inside the function, so the output is the same as before.

But this will throw an error:

def print_name():
	name = 'Bob'
	print('My name is ' + name)

print(name)

The output of the code above is:

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

I tried to print the variable name from outside the function, but the scope of the variable was local and could not be found in a global scope.

Mixing Scopes (Mixing Scopes)

If you use the same name for variables inside and outside a function, the function will use the one inside its scope.

So when you call print_name(), the name='Bob' is used to print the phrase.

So when you call print_name() , the name='Bob' is used to print the phrase.

On the other hand, when calling print() outside the function scope, name="Sarah" is used because of its global scope.

name = "Sarah"

def print_name():
	name = 'Bob'
	print('My name is ' + name)

print_name()

print(name)

The output of the code above is:

My name is Bob

Sarah

List Comprehensions (List Comprehensions)

Sometimes we want to perform some very simple operations over the items of a list.

List comprehensions give us a succinct way to work on lists as an alternative to other methods of iteration, such as for loops.

Basic syntax (Basic syntax)

To use a list comprehension to replace a regular for loop, we can make:

[expression for item in list]

Which is the same as doing:

for item in list:
    expression

If we want some conditional to apply the expression, we have:

[expression for item in list if conditional ]

Which is the same as doing:

for item in list:
    if conditional:
        expression

Example 1: calculating the cube of a number (Example 1: calculating the cube of a number)

Regular way

numbers = [1, 2, 3, 4, 5]
new_list = []

for n in numbers:
    new_list.append(n**3)

print(new_list)

[1, 8, 27, 64, 125]

Using list comprehensions

numbers = [1, 2, 3, 4, 5]
new_list = []

new_list = [n**3 for n in numbers]

print(new_list)

[1, 8, 27, 64, 125]

Example 2: calculating the cube of a number only if it is greater than 3 (Example 2: calculating the cube of a number only if it is greater than 3)

Using the conditional, we can filter only the values we want the expression to be applied to.

Regular way

numbers = [1, 2, 3, 4, 5]
new_list = []

for n in numbers:
    if(n > 3):
        new_list.append(n**3)

print(new_list)

[64, 125]

Using list comprehensions

numbers = [1, 2, 3, 4, 5]
new_list = []

new_list = [n**3 for n in numbers if n > 3]

print(new_list)

[64, 125]

Example 3: calling functions with list comprehensions (Example 3: calling functions with list comprehensions)

We can also call functions using the list comprehension syntax:

numbers = [1, 2, 3, 4, 5]
new_list = []

def cube(number):
    return number**3

new_list = [cube(n) for n in numbers if n > 3]

print(new_list)

[64, 125]

Lambda Functions (Lambda Functions)

A Python lambda function can only have one expression and can't have multiple lines.

It is supposed to make it easier to create some small logic in one line instead of a whole function as is usually done.

Lambda functions are also anonymous, which means there is no need to name them.

Basic Syntax (Basic Syntax)

The basic syntax is very simple: just use the lambda keyword, define the parameters needed, and use ":" to separate the parameters from the expression.

The general forms is:

lambda arguments : expression

One parameter example (One parameter example)

Look at this example using only one parameter

cubic = lambda number : number**3
print(cubic(2))

Multiple parameter example (Multiple parameter example)

If you want, you can also have multiple parameters.

exponential = lambda multiplier, number, exponent : multiplier * number**exponent
print(exponential(2, 2, 3))

Calling the Lambda Function directly (Calling the Lambda Function directly)

You don't need to use a variable as we did before. Instead you can make use of parenthesis around the lambda function and another pair of parenthesis around the arguments.

The declaration of the function and the execution will happen in the same line.

(lambda multiplier, number, exponent : multiplier * number**exponent)(2, 2, 3)

Examples using lambda functions with other built-in functions (Examples using lambda functions with other built-in functions)

地图 (Map)

The Map function applies the expression to each item in a list.

Let's calculate the cubic of each number in the list.

numbers = [2, 5, 10]
cubics = list(map(lambda number : number**3, numbers))
print(cubics)

[8, 125, 1000]

过滤 (Filter)

The Filter function will filter the list based on the expression.

Let's filter to have only the numbers greater than 5.

numbers = [2, 5, 10]
filtered_list = list(filter(lambda number : number > 5, numbers))
print(filtered_list)

[10]

模组 (Modules)

After some time your code starts to get more complex with lots of functions and variables.

To make it easier to organize the code we use Modules.

A well-designed Module also has the advantage of being reusable, so you write code once and reuse it everywhere.

You can write a module with all the mathematical operations and other people can use it.

And, if you need, you can use someone else's modules to simplify your code, speeding up your project.

In other programming languages, these are also referred to as libraries.

Using a Module (Using a Module)

To use a module we use the import keyword.

As the name implies we have to tell our program what module to import.

After that, we can use any function available in that module.

Let's see an example using the math module.

First, let's see how to have access to a constant, Euler's number.

import math

math.e

2.718281828459045

In this second example, we are going to use a function that calculates the square root of a number.

It is also possible to use the as keyword to create an alias.

import math as m

m.sqrt(121)

m.sqrt(729)

11
27

Finally, using the from keyword, we can specify exactly what to import instead of the whole module and use the function directly without the module's name.

This example uses the floor() function that returns the largest integer less than or equal to a given number.

from math import floor

floor(9.8923)

Creating a Module (Creating a Module)

Now that we know how to use modules, let's see how to create one.

It is going to be a module with the basic math operations add, subtract, multiply, divide and it is gonna be called basic_operations.

It is going to be a module with the basic math operations add , subtract , multiply , divide and it is gonna be called basic_operations .

Create the basic_operations.py file with the four functions.

def add(first_num, second_num):
    return first_num + second_num

def subtract(first_num, second_num):
    return first_num - second_num

def multiply(first_num, second_num):
    return first_num * second_num

def divide(first_num, second_num):
    return first_num / second_num

Then, just import the basic_operations module and use the functions.

import basic_operations

basic_operations.add(10,2)
basic_operations.subtract(10,2)
basic_operations.multiply(10,2)
basic_operations.divide(10,2)

`if name == 'main'` (`if name == 'main'`)

You are in the process of building a module with the basic math operations add, subtract, multiply, and divide called basic_operations saved in the basic_operations.py file.

You are in the process of building a module with the basic math operations add , subtract , multiply , and divide called basic_operations saved in the basic_operations.py file.

To guarantee everything is fine, you can run some tests.

def add(first_num, second_num):
    return first_num + second_num

def subtract(first_num, second_num):
    return first_num - second_num

def multiply(first_num, second_num):
    return first_num * second_num

def divide(first_num, second_num):
    return first_num / second_num

print(add(10, 2)) 
print(subtract(10,2))
print(multiply(10,2))
print(divide(10,2))

After running the code:

renan@pro-home:~$ python3 basic_operations.py

The output is:

输出为：

The output for those tests are what we expected.

Our code is right and ready to share.

Let's import the new module run it in the Python console.

Python 3.6.9 (default, Nov  7 2019, 10:44:02) 
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import basic_operations
12
8
20
5.0
>>>

When the module is imported our tests are displayed on the screen even though we didn't do anything besides importing basic_operations.

When the module is imported our tests are displayed on the screen even though we didn't do anything besides importing basic_operations .

To fix that we use if __name__ == '__main__' in the basic_operations.py file like this:

def add(first_num, second_num):
    return first_num + second_num

def subtract(first_num, second_num):
    return first_num - second_num

def multiply(first_num, second_num):
    return first_num * second_num

def divide(first_num, second_num):
    return first_num / second_num

if __name__ == '__main__':
    print(add(10, 2)) 
    print(subtract(10,2))
    print(multiply(10,2))
    print(divide(10,2))

Running the code directly on the terminal will continue to display the tests. But when you import it like a module, the tests won't show and you can use the functions the way you intended.

Python 3.6.9 (default, Nov  7 2019, 10:44:02) 
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import basic_operations
>>> basic_operations.multiply(10,2)
20
>>>

Now that you know how to use the if __name__ == '__main__', let's understand how it works.

Now that you know how to use the if __name__ == '__main__' , let's understand how it works.

The condition tells when the interpreter is treating the code as a module or as a program itself being executed directly.

Python has this native variable called __name__.

Python has this native variable called __name__ .

This variable represents the name of the module which is the name of the .py file.

Create a file my_program.py with the following and execute it.

print(__name__)

The output will be:

__main__

This tells us that when a program is executed directly, the variable __name__ is defined as __main__.

This tells us that when a program is executed directly, the variable __name__ is defined as __main__ .

But when it is imported as a module, the value of __name__ is the name of the module.

Python 3.6.9 (default, Nov  7 2019, 10:44:02) 
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import my_program
my_program
>>>

This is how the Python interpreter differentiates the behavior of an imported module and a program executed directly on the terminal.

档案 (Files)

Creating, deleting, reading, and many other functions applied to files are an integral part of many programs.

As such, it is very important to know how to organize and deal with files directly from your code.

Let's see how to handle files in Python.

File create (File create)

First things first, create!

We are going to use the open() function.

This function opens a file and returns its corresponding object.

The first argument is the name of the file we are handling, the second refers to the operation we are using.

The code below creates the file "people.txt", the x argument is used when we just want to create the file. If a file with the same name already exists, it will throw an exception.

people_file = open("people.txt", "x")

You can also use the w mode to create a file. Unlike the x mode, it will not throw an exception since this mode indicates the writing mode. We are opening a file to write data into it and, if the file doesn't exist, it is created.

people_file = open("people.txt", "w")

The last one is the a mode which stands for append. As the name implies, you can append more data to the file, while the w mode simply overwrites any existing data.

The last one is the a mode which stands for append . As the name implies, you can append more data to the file, while the w mode simply overwrites any existing data.

When appending, if the file doesn't exist, it also creates it.

people_file = open("people.txt", "a")

File write (File write)

To write data into a file, you simply open a file with the w mode.

Then, to add data, you use the object return by the open() function. In this case, the object is called people_file. Then you call the write() function passing the data as argument.

Then, to add data, you use the object return by the open() function. In this case, the object is called people_file . Then you call the write() function passing the data as argument.

people_file = open("people.txt", "w")
people_file.write("Bob\n")
people_file.write("Mary\n")
people_file.write("Sarah\n")
people_file.close()

We use \n at the end to break the line, otherwise the content in the file will stay in the same line as "BobMarySarah".

One more detail is to close() the file. This is not only a good practice, but also ensures that your changes were applied to the file.

Remember that when using w mode, the data that already existed in the file will be overwritten by the new data. To add new data without losing what was already there, we have to use the append mode.

File append (File append)

The a mode appends new data to the file, keeping the existing one.

In this example, after the first writing with w mode, we are using the a mode to append. The result is that each name will appear twice in the file "people.txt".

#first write
people_file = open("people.txt", "w")
people_file.write("Bob\n")
people_file.write("Mary\n")
people_file.write("Sarah\n")
people_file.close()

#appending more data
#keeping the existing data
people_file = open("people.txt", "a")
people_file.write("Bob\n")
people_file.write("Mary\n")
people_file.write("Sarah\n")
people_file.close()

File read (File read)

Reading the file is also very straightforward: just use the r mode like so.

If you read the "people.txt" file created in the last example, you should see 6 names in your output.

people_file = open("people.txt", "r")
print(people_file.read())

Bob
Mary
Sarah
Bob
Mary
Sarah

The read() function reads the whole file at once. If you use the readline() function, you can read the file line by line.

people_file = open("people.txt", "r")
print(people_file.readline())
print(people_file.readline())
print(people_file.readline())

Bob
Mary
Sarah

You can also loop to read the lines like the example below.

people_file = open("people.txt", "r")
for person in people_file:
  print(person)

Bob
Mary
Sarah
Bob
Mary
Sarah

Delete a File (Delete a File)

To delete a file, you also need the os module.

Use the remove() method.

import os

os.remove('my_file.txt')

Check if a File Exists (Check if a File Exists)

Use the os.path.exists() method to check the existence of a file.

import os

if os.path.exists('my_file.txt'):
  os.remove('my_file.txt')
else:
  print('There is no such file!')

Copy a File (Copy a File)

For this one, I like to use the copyfile() method from the shutil module.

from shutil import copyfile

copyfile('my_file.txt','another_file.txt')

There are a few options to copy a file, but copyfile() is the fastest one.

Rename and Move a File (Rename and Move a File)

If you need to move or rename a file you can use the move() method from the shutil module.

from shutil import move

move('my_file.txt','another_file.txt')

Classes and Objects (Classes and Objects)

Classes and Objects are the fundamental concepts of Object-Oriented Programming.

In Python, everything is an object!

In Python, everything is an object !

A variable (object) is just an instance of its type (class).

That's why when you check the type of a variable you can see the class keyword right next to its type (class).

This code snippet shows that my_city is an object and it is an instance of the class str.

This code snippet shows that my_city is an object and it is an instance of the class str .

my_city = "New York"
print(type(my_city))

<class 'str'>

Differentiate Class x Object (Differentiate Class x Object)

The class gives you a standard way to create objects. A class is like a base project.

Say you are an engineer working for Boeing.

Your new mission is to build the new product for the company, a new model called 747-Space. This aircraft flies higher altitudes than other commercial models.

Boeing needs to build dozens of those to sell to airlines all over the world, and the aircrafts have to be all the same.

To guarantee that the aircrafts (objects) follow the same standards, you need to have a project (class) that can be replicable.

The class is a project, a blueprint for an object.

This way you make the project once, and reuse it many times.

In our code example before, consider that every string has the same behavior and the same attributes. So it only makes sense for strings to have a class str to define them.

Attributes and Methods (Attributes and Methods)

Objects have some behavior which is is given by attributes and methods.

In simple terms, in the context of an object, attributes are variables and methods are functions attached to an object.

For example, a string has many built-in methods that we can use.

They work like functions, you just need to separate them from the objects using a ..

They work like functions, you just need to separate them from the objects using a . 。

In this code snippet, I'm calling the replace() method from the string variable my_city which is an object, and an instance of the class str.

In this code snippet, I'm calling the replace() method from the string variable my_city which is an object, and an instance of the class str .

The replace() method replaces a part of the string for another and returns a new string with the change. The original string remains the same.

Let's replace 'New' for 'Old' in 'New York'.

my_city = 'New York'
print(my_city.replace('New', 'Old'))
print(my_city)

Old York
New York

Creating a Class (Creating a Class)

We have used many objects (instances of classes) like strings, integers, lists, and dictionaries. All of them are instances of predefined classes in Python.

To create our own classes we use the class keyword.

By convention, the name of the class matches the name of the .py file and the module by consequence. It is also a good practice to organize the code.

Create a file vehicle.py with the following class Vehicle.

Create a file vehicle.py with the following class Vehicle .

class Vehicle:
    def __init__(self, year, model, plate_number, current_speed = 0):
        self.year = year
        self.model = model
        self.plate_number = plate_number
        self.current_speed = current_speed

    def move(self):
        self.current_speed += 1

    def accelerate(self, value):
        self.current_speed += value
    
    def stop(self):
        self.current_speed = 0
    
    def vehicle_details(self):
        return self.model + ', ' + str(self.year) + ', ' + self.plate_number

Let's break down the class to explain it in parts.

The class keyword is used to specify the name of the class Vehicle.

The class keyword is used to specify the name of the class Vehicle .

The __init__ function is a built-in function that all classes have. It is called when an object is created and is often used to initialize the attributes, assigning values to them, similar to what is done to variables.

The first parameter self in the __init__ function is a reference to the object (instance) itself. We call it self by convention and it has to be the first parameter in every instance method, as you can see in the other method definitions def move(self), def accelerate(self, value), def stop(self), and def vehicle_details(self).

The first parameter self in the __init__ function is a reference to the object (instance) itself. We call it self by convention and it has to be the first parameter in every instance method, as you can see in the other method definitions def move(self) , def accelerate(self, value) , def stop(self) , and def vehicle_details(self) .

Vehicle has 5 attributes (including self): year, model, plate_number, and current_speed.

Vehicle has 5 attributes (including self): year , model , plate_number , and current_speed .

Inside the __init__, each one of them is initialized with the parameters given when the object is instantiated.

Inside the __init__ , each one of them is initialized with the parameters given when the object is instantiated.

Notice that current_speed is initialized with 0 by default, meaning that if no value is given, current_speed will be equal to 0 when the object is first instantiated.

Finally, we have three methods to manipulate our vehicle regarding its speed: def move(self), def accelerate(self, value), and def stop(self).

Finally, we have three methods to manipulate our vehicle regarding its speed: def move(self) , def accelerate(self, value) , and def stop(self) .

And one method to give back information about the vehicle: def vehicle_details(self).

And one method to give back information about the vehicle: def vehicle_details(self) .

The implementation inside the methods work the same way as in functions. You can also have a return to give you back some value at the end of the method as demonstrated by def vehicle_details(self).

Using the Class (Using the Class)

To use the class in your terminal, import the Vehicle class from the vehicle module.

Create an instance called my_car, initializing year with 2009, model with 'F8', plate_number with 'ABC1234', and current_speed with 100.

Create an instance called my_car , initializing year with 2009, model with 'F8', plate_number with 'ABC1234', and current_speed with 100.

The self parameter is not taken into consideration when calling methods. The Python interpreter infers its value as being the current object/instance automatically, so we just have to pass the other arguments when instantiating and calling methods.

Now use the methods to move() the car which increases its current_speed by 1, accelerate(10) which increases its current_speed by the value given in the argument, and stop() which sets the current_speed to 0.

Remember to print the value of current_speed at every command to see the changes.

To finish the test, call vehicle_details() to print the information about our vehicle.

>>> from vehicle import Vehicle
>>>
>>> my_car = Vehicle(2009, 'F8', 'ABC1234', 100)
>>> print(my_car.current_speed)
100
>>> my_car.move()
>>> print(my_car.current_speed)
101
>>> my_car.accelerate(10)
>>> print(my_car.current_speed)
111
>>> my_car.stop()
>>> print(my_car.current_speed)
0
>>> print(my_car.vehicle_details())
F8, 2009, ABC1234

If we don't set the initial value for current_speed, it will be zero by default as stated before and demonstrated in the next example.

If we don't set the initial value for current_speed , it will be zero by default as stated before and demonstrated in the next example.

>>> from vehicle import Vehicle
>>>
>>> my_car = Vehicle(2009, 'F8', 'ABC1234')
>>> print(my_car.current_speed)
0
>>> my_car.move()
>>> print(my_car.current_speed)
1
>>> my_car.accelerate(10)
>>> print(my_car.current_speed)
11
>>> my_car.stop()
>>> print(my_car.current_speed)
0
>>> print(my_car.vehicle_details())
F8, 2009, ABC1234

遗产 (Inheritance)

Let's define a generic Vehicle class and save it inside the vehicle.py file.

class Vehicle:
    def __init__(self, year, model, plate_number, current_speed):
        self.year = year
        self.model = model
        self.plate_number = plate_number
        self.current_speed = current_speed

    def move(self):
        self.current_speed += 1

    def accelerate(self, value):
        self.current_speed += value
    
    def stop(self):
        self.current_speed = 0
    
    def vehicle_details(self):
        return self.model + ', ' + str(self.year) + ', ' + self.plate_number

A vehicle has attributes year, model, plate_number, and current_speed.

A vehicle has attributes year , model , plate_number , and current_speed .

The definition of vehicle in the Vehicle is very generic and might not be suitable for trucks, for instance, because it should include a cargo attribute.

On the other hand, a cargo attribute does not make much sense for small vehicles like motorcycles.

To solve this we can use inheritance.

To solve this we can use inheritance .

When a class (child) inherits another class (parent), all the attributes and methods from the parent class are inherited by the child class.

Parent and Child (Parent and Child)

In our case, we want a new Truck class to inherit everything from the Vehicle class. Then we want it to add its own specific attribute current_cargo to control the addition and removal of cargo from the truck.

The Truck class is called a child class that inherits from its parent class Vehicle.

The Truck class is called a child class that inherits from its parent class Vehicle .

A parent class is also called a superclass while a child class is also known as a subclass.

A parent class is also called a superclass while a child class is also known as a subclass .

Create the class Truck and save it inside the truck.py file.

from vehicle import Vehicle

class Truck(Vehicle):
    def __init__(self, year, model, plate_number, current_speed, current_cargo):
        super().__init__(year, model, plate_number, current_speed)
        self.current_cargo = current_cargo

    def add_cargo(self, cargo):
        self.current_cargo += cargo

    def remove_cargo(self, cargo):
        self.current_cargo -= cargo

Let's break down the class to explain it in parts.

The class Vehicle inside the parentheses when defining the class Truck indicates that the parent Vehicle is being inherited by its child Truck.

The class Vehicle inside the parentheses when defining the class Truck indicates that the parent Vehicle is being inherited by its child Truck .

The __init__ method has self as its first parameter, as usual.

The parameters year, model, plate_number, and current_speed are there to match the ones in the Vehicle class.

The parameters year , model , plate_number , and current_speed are there to match the ones in the Vehicle class.

We added a new parameter current_cargo suited for the Truck class.

In the first line of the __init__ method of the Truck class we have to call the __init__ method of the Vehicle class.

To do that we use super() to make a reference to the supperclass Vehicle, so when super().__init__(year, model, plate_number, current_speed) is called we avoid repetition of our code.

To do that we use super() to make a reference to the supperclass Vehicle , so when super().__init__(year, model, plate_number, current_speed) is called we avoid repetition of our code.

After that, we can assign the value of current_cargo normally.

Finally, we have two methods to deal with the current_cargo: def add_cargo(self, cargo):, and def remove_cargo(self, cargo):.

Finally, we have two methods to deal with the current_cargo : def add_cargo(self, cargo): , and def remove_cargo(self, cargo): .

Remember that Truck inherits attributes and methods from Vehicle, so we also have an implicit access to the methods that manipulate the speed: def move(self), def accelerate(self, value), and def stop(self).

Remember that Truck inherits attributes and methods from Vehicle , so we also have an implicit access to the methods that manipulate the speed: def move(self) , def accelerate(self, value) , and def stop(self) .

Using the `Truck` class (Using the `Truck` class)

To use the class in your terminal, import the Truck class from the truck module.

Create an instance called my_truck, initializing year with 2015, model with 'V8', plate_number with 'XYZ1234', current_speed with 0, and current_cargo with 0.

Create an instance called my_truck , initializing year with 2015, model with 'V8', plate_number with 'XYZ1234', current_speed with 0, and current_cargo with 0.

Use add_cargo(10) to increase current_cargo by 10, remove_cargo(4), to decrease current_cargo by 4.

Use add_cargo(10) to increase current_cargo by 10, remove_cargo(4) , to decrease current_cargo by 4.

Remember to print the value of current_cargo at every command to see the changes.

By inheritance, we can use the methods from the Vehicle class to move() the truck which increases its current_speed by 1, accelerate(10) which increases its current_speed by the value given in the argument, and stop() which sets the current_speed to 0.

Remember to print the value of current_speed at every interaction to see the changes.

To finish the test, call vehicle_details() inherited from the Vehicle class to print the information about our truck.

>>> from truck import Truck
>>> 
>>> my_truck = Truck(2015, 'V8', 'XYZ1234', 0, 0)
>>> print(my_truck.current_cargo)
0
>>> my_truck.add_cargo(10)
>>> print(my_truck.current_cargo)
10
>>> my_truck.remove_cargo(4)
>>> print(my_truck.current_cargo)
6
>>> print(my_truck.current_speed)
0
>>> my_truck.accelerate(10)
>>> print(my_truck.current_speed)
10
>>> my_truck.stop()
>>> print(my_truck.current_speed)
0
>>> print(my_truck.vehicle_details())
V8, 2015, XYZ1234

例外情况 (Exceptions)

Errors are a part of every programmer's life, and knowing how to deal with them is a skill on its own.

The way Python deals with errors is called 'Exception Handling'.

If some piece of code runs into an error, the Python interpreter will raise an exception.

Types of Exceptions (Types of Exceptions)

Let's try to raise some exceptions on purpose and see the errors they produce.

TypeError
TypeError

First, try to add a string and an integer

'I am a string' + 32

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: must be str, not int

IndexError
IndexError

Now, try to access an index that doesn't exist in a list.

A common mistake is to forget that sequences are 0-indexed, meaning the first item has index 0, not 1.

In this example, the list car_brands ends at index 2.

car_brands = ['ford', 'ferrari', 'bmw']
print(car_brands[3])

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

NameError
NameError

If we try to print a variable that doesn't exist:

print(my_variable)

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

ZeroDivisionError
ZeroDivisionError

Math doesn't allow division by zero, so trying to do so will raise an error, as expected.

32/0

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

This was just a sample of the kinds of exceptions you might see during your daily routine and what can cause each of them.

Exception Handling (Exception Handling)

Now we know how to cause errors that will crash our code and show us some message saying something is wrong.

To handle these exceptions just make use of the try/except statement.

try:
  32/0
except:
  print('Dividing by zero!')

Dividing by zero!

The example above shows the use of the try statement.

Put the block of code that may cause an exception inside the try scope. If everything runs alright, the except block is not invoked. But if an exception is raised, the block of code inside the except is executed.

This way the program doesn't crash and if you have some code after the exception, it will keep running if you want it to.

Specific Exception Handling (Specific Exception Handling)

In the last example the except block was generic, meaning it was catching anything.

Good practice it to specify the type of exception we are trying to catch, which helps a lot when debugging the code later.

If you know a block of code can throw an IndexError, specify it in the except:

If you know a block of code can throw an IndexError , specify it in the except :

try:
  car_brands = ['ford', 'ferrari', 'bmw']
  print(car_brands[3])
except IndexError:
  print('There is no such index!')

There is no such index!

You can use a tuple to specify as many exception types as you want in a single except:

You can use a tuple to specify as many exception types as you want in a single except :

try:
  print('My code!')
except(IndexError, ZeroDivisionError, TypeError):
  print('My Excepetion!')

`else` (`else`)

It is possible to add an else command at the end of the try/except. It runs only if there are no exceptions.

It is possible to add an else command at the end of the try/except . It runs only if there are no exceptions.

my_variable = 'My variable'
try:
  print(my_variable)
except NameError:
  print('NameError caught!')
else:
  print('No NameError')

My variable
No NameError

Raising Exceptions (Raising Exceptions)

The raise command allows you to manually raise an exception.

This is particularly useful if you want to catch an exception and do something with it -- like logging the error in some personalized way like redirecting it to a log aggregator, or ending the execution of the code since the error should not allow the progress of the program.

try:
  raise IndexError('This index is not allowed')
except:
  print('Doing something with the exception!')
  raise

Doing something with the exception!
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
IndexError: This index is not allowed

`finally` (`finally`)

The finally block is executed independently of exceptions being raised or not.

They are usually there to allow the program to clean up resources like files, memory, network connections, etc.

try:
  print(my_variable)
except NameError:
  print('Except block')
finally:
  print('Finally block')

Except block
Finally block

结论 (Conclusion)

That's it!

而已！

Congratulations on reaching the end.

I want to thank you for reading this article.

If you want to learn more, checkout my blog renanmf.com.

If you want to learn more, checkout my blog renanmf.com .

Remember to download a PDF version of this Python Guide for Beginners.

Remember to download a PDF version of this Python Guide for Beginners .

You can also find me on Twitter: @renanmouraf.

You can also find me on Twitter: @renanmouraf .

翻译自: https://www.freecodecamp.org/news/the-python-guide-for-beginners/

python初学者

cumi7754

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
python初学者_终极Python初学者手册

python初学者Python has become one of the fastest-growing programming languages over the past few years. 在过去的几年中，Python已成为增长最快的编程语言之一。 Not only it is widely used, it is also an awesome language to tackl...
复制链接

扫一扫