​

目录

数据的名字和种类——变量和类型

初探数据种类

数据类型

数值运算

比较运算

变量和赋值

变量的好处

用赋值更新变量

变量和数据类型的关系

总结

数据类型

数值运算

数值比较

变量和赋值

一串数据怎么存储——列表和字符串

列表（List）

字符串（String）

总结

不只有一条路——分支和循环

input()、print() 和 int() 函数

分支

while 循环

条件的与、或、取反

for 循环

总结

将代码放进盒子——函数

函数的初步理解

函数如何定义

函数的调用

函数有什么用

什么时候用函数

总结

多语言比较

---

Hello，你好呀，我是灰小猿，一个超会写bug的程序猿！

最近发现很多开始学习编程的小伙伴苦于编程入门比较困难，而且有很多想学习编程却苦于没有资源的小伙伴，所以今天在这里为大家爆肝Python基础入门的相关技术，适合刚开始接触Python或苦于编程入门的小伙伴们，建议收藏认真阅读！相信会对大家的Python学习助一臂之力的！

本文持续更新，欢迎小伙伴收藏关注！

话不多说直接开肝！

数据的名字和种类——变量和类型

初探数据种类

在正式开始学习这个小节之前你要明白，现在我们是在学习写程序。那么在写程序之前你要知道程序的作用是什么？

程序的主要作用是处理数据。数据的种类有很多，我们在手机和电脑上看到的那些文字、数字、图片、视频、页面样式等等都是数据。这些数据都是由程序来处理并显示到屏幕上的。

虽然数据的种类形形色色，并且有些看起来比较复杂，但是在编程时它们实际上都是由一些非常基本的数据形式（或经过组合）来表示。这些基本数据形式有哪些呢？比如有常用到的数字和字符，以及其它的诸如数组、字节序列等形式。

以数字和字符为例，为大家介绍下在代码中它们是怎么表示的。

对于数字，数字在代码中的表示形式和平时的电脑输入一样，直接书写即可：

对于字符，和平时的书写稍有不同，Python 代码中表示字符时一定要给字符括上单引号或双引号：

这些不同的数据表示（书写）形式，对应着不同的数据种类，而不同的数据种类又具有不同的功能或者作用。

我们将代码中的数据种类称为数据类型，也就是数据的类型。

数据类型

代码中的所有数据都是有类型的。

数字所对应的数据类型有整数型以及浮点型。整数型表示整数数字，比如：0，-59，100。浮点型表示小数数字，如 -3.5，0.25，0.0。

字符所对应的数据类型叫字符串，所谓字符串就是一串字符。它里面可以是任意语言的字符，比如 '哼哼哈嘿'，'Good Good Study'。当然字符串里也可以只有一个字符，比如 'a'。

有一种表示「是」或「否」的类型，叫做布尔型。它的值叫布尔值，只有 True 和 False 两种取值。这就好比考试时的判断题，结果只能二选一，要么「是」要么「否」。

另外还有一种很特别的类型：None 型，表示什么都没有，它就一个取值 None。

说明：为了不增加大家的记忆负担，这里只介绍这五种基本数据类型，后续的我们慢慢掌握。

考大家一个问题，在代码中 1000 和 '1000' 是相同的东西吗？答案是不同，一个是数字，一个是字符串，数据类型不同。

数值运算

对于整数型和浮点型，因为它们都被用来表示数值，理所应当这二者可以做数值运算，也就是加减乘除等操作。

我们进入 Python 解释器交互模式中，输入代码试验一下这些数值运算：

• 加法

  33+725
  

  

  >>> 33+725
  758

• 减法

  12-24
  

  

  >>> 12-24
  -12

• 乘法

  8*12.5
  

  

  >>> 8*12.5
  100.0

• 除法

  1/3
  

  

  >>> 1/3
  0.3333333333333333

• 除余

  10%3
  

  

  >>> 10%3
  1

可以看到，数值的加（+）、减（-）、乘（*）、除（/）、除余（%）都可以被计算。这些操作也是多种程序语言所通用的，除此之外 Python 还内置了次方运算（**）和整除（//）：

• 次方

  2**3
  

  

  >>> 2**3
  8

• 整除

  9//2
  

  

  >>> 9//2
  4

这恐怕是 Python 的最简单的用法了——当作计算器！

说明：通常我们为了美观，会在上面的运算符号的左右各加上一个空格，如 12 - 24，2 ** 3。

之后的代码示例中我们会添加空格。

比较运算

整数型和浮点型除了数值运算外，还可以做比较运算，也就是比较两个数值的大小。比较的结果是布尔值。如：

>>> 2 > 3
False

>>> 2 <= 3
True

>>> 2 == 3
False

比较运算的运算符可以是大于（>），小于（<），大于等于（>=），小于等于（<=），等于（==），不等于（!=）。其写法与数学中的比较运算很相似，但不同的是「等于」和「不等于」，尤其注意「等于」是用两个等号 == 表示。

变量和赋值

刚才我们学习了数值运算，那我们现在来算算一周有多少秒，一年有多少秒。

首先我们不难得出一天有 60 * 60 * 24 秒。我们可以暂时把这个结果用某种方式记录下来，以便后续使用。用什么方式记录呢？我们可以使用变量。

变量其实就是编程者给代码中的某个数据所取的名字，之后的编程过程中使用这个名字就相当于使用它背后的数据。简单地来理解的话，我们可以把变量看作是代码中用于保存数据的临时容器。

创建变量的动作我们称之为定义变量。如下是定义变量的方法：

在这里我们起了个名字 seconds_per_day，并且通过符号 = 把 60 * 60 * 24 的计算结果给了它。seconds_per_day 这个名字就是我们所定义的变量，它的值（也就是其背后的数据）是 60 * 60 * 24 的实际运算结果。也就是说我们将一天的秒数 60 * 60 * 24 保存在了变量 seconds_per_day 中。

等号（=） 在代码中是赋值的意思，表示将 = 右边的值赋予 = 左边的变量。注意赋值用等号 = 表示，而「等于」用 == （连续两个等号）表示。

执行刚才的代码后，紧接着输入 seconds_per_day 可以看到这个变量的值：

>>> seconds_per_day
86400

回到「一周有多少秒」的问题上去。我们有了表示一天的秒数的 seconds_per_day 变量，那我们的程序就可以这样写下去：

>>> seconds_per_day * 7
604800

一天的秒数乘以七（天），最终结果是 604800，没有任何问题。

刚才的完整连贯代码是：

seconds_per_day = 60 * 60 * 24
seconds_per_day * 7

变量的好处

你可能会说「一周的秒数，直接计算 60 * 60 * 24 * 7 不就好了，也用不着使用变量」？是的，有时确实可以不使用变量。但使用变量有一个好处，那就是可以暂存一个中间结果，方便之后去重复利用它。

比如我们现在还想要再算一下「一年有多少秒」，因为前面已经算好了一天的秒数 seconds_per_day，所以可以直接拿来利用：

>>> seconds_per_day * 365
31536000

除此之外变量的好处还有，你可以通过妥当的变量名字来改善程序的可读性（阅读的容易程度）。比如我们在代码里写下 60 * 60 * 24，别人（包括未来的你自己）在阅读时很难一下子理解这串运算表示什么。但是如果这样写呢： seconds_per_day = 60 * 60 * 24。噢，原来是指一天的秒数。

用赋值更新变量

前面内容中的变量是在定义的时候被赋值的，其实变量被定义后也可以反复给这个变量赋予新的值，这样变量中的数据就被更新了。如：

>>> day = 1
>>> day
1
>>> day = 2
>>> day
2
>>> day = 3
>>> day
3

变量和数据类型的关系

变量用来保存数据，而数据类型用来指明数据的种类。

刚才我们使用了 seconds_per_day = 60 * 60 * 24 语句来定义变量 seconds_per_day，并将它赋值为 60 * 60 * 24。因为变量 seconds_per_day 中保存的是个整数型的值，所以我们说 seconds_per_day 是个整数型（的）变量。

总结

数据类型

这个章节中我们提到的 Python 基础数据类型有：

类型	表示	取值示例
整数型	整数	-59，100
浮点型	小数	-3.5，0.01
字符串	文本	'哼哼哈嘿'，'Good Good Study'
布尔型	是与非	True，False
None 型	什么都没有	None

Python 中的数据类型不止这些，之后会渐渐涉及，表格中的这些类型也会在之后被应用到。

数值运算

数值运算的符号有：

符号	含义	示例
+	加法	1 + 1
-	减法	2 - 3
*	乘法	4 * 5
/	除法	6 / 7
%	取余	8 % 9
**	次方	2 ** 3（2 的 3 次方）
//	整除	5 // 4

数值比较

数值比较的符号有：

符号	含义
>	大于
<	小于
>=	大于等于
<=	小于等于
==	等于
!=	不等于

上面的内容看起来罗列了很多，但其实不会带来记忆负担。数值运算和数值比较与数学上的概念和符号大致相同，略有区别而已。

变量和赋值

我们通过以下形式来定义变量和赋值：

---

多语言比较：

「多语言比较」这部分内容，是为让大家了解本章节所介绍的语言基本特性在其它语言中是如何表达的。大家可以了解体会它们之间的相识之处。

不同于动态类型的 Python，在静态类型的语言中数据类型还有长度一说，也就是类型所能容纳的数据大小。并且变量在定义时还需先声明它的类型。以整数型为例。Java 中的整数型根据长度的不同分为：byte（1 字节）、short（2 字节）、int（4 字节）、long（8 字节），浮点型分为 float（4 字节）、double（8 字节）。其它语言也有一些类似。C/C++ 中的整数型有「有无符号」之分（如 unsigned int 表示无符号的 int 型，也就是说这只能表示 0 和正数，不能表示负数）。

Java 定义变量并初始化：

int yearDays = 365

C/C++ 定义变量并初始化：

int yearDays = 365 

把 C 和 C++ 合并称为 C/C++，是因为 C++ 基本上是 C 的强大很多的超集，虽然 C++ 严格来说不是 100% 兼容 C，但几乎是兼容的。

Go 语言定义变量并初始化：

var yearDays int = 365

Go 语言中的变量定义需要加上关键字 var，且数据类型（这里是 int）放在变量名后面。或者采用另一种写法：

yearDays := 365

这种写法不但可以省略关键字 var 还可以省略数据类型，数据类型可直接由编译器推导出来。

以上语言在变量定义后，都可通过下述语句再次赋值：

yearDays = 366

一串数据怎么存储——列表和字符串

上一节中讲了数据类型，有一个问题，之前所介绍的数据类型大多是用来表示单个数据的。比如整数型，一个整数型的变量只能保存一个整数。又如布尔型，一个布尔型的变量只能保存一个布尔值。浮点型和 None 型也是如此。要是此刻有一系列的数据，那该怎么在程序里保存和使用呢？

举个栗子：当我的只有一个电话号码的时候，我可以使用整数型来表示，并保存在变量里：

但如果有十个电话号码，该怎么来表示和使用它们呢？

13011110000
18022221111
13433332222
13344443333
17855554444
13866665555
15177776666
13388887777
18799998888
17800009999

你可能会说，「那就用十个变量」，像这样：

或者「把它们用逗号拼在一起然后放到字符串里」：

是的，看起来这似乎能解决问题。但是这两种办法的弊端也很明显。第一种使用多个变量的方式，在数据量很大的情况下使用起来会十分繁琐；第二种使用字符串的方式，如果我们需要对其中的某些数据做处理，那这种方式就很不方便灵活了。

这时我们可以选择使用列表。

列表（List）

列表是一种用于保存批量数据的数据类型。它和整数型、布尔型等数据类型一样都被内置在 Python 中。

列表的写法

列表的写法为 [ 数据项1, 数据项2, ..., 数据项N ]，方括号就代表列表，每个数据项放在方括号中并用逗号分隔。

如之前的那一串电话号码可以这样来保存：

扩展：为了方便阅读，我们也可以把把这个列表写成多行的形式：

tels = [
 13011110000, 
 18022221111, 
 13433332222, 
 13344443333, 
 17855554444, 
 13866665555, 
 15177776666, 
 13388887777, 
 18799998888, 
 17800009999
]

每个数据项一行，这样是不是更好看了！

在解释器的交互模式中输入这样的多行代码时，我们会发现第一行的提示符是 >>>，之后每行的提示符会变成 ...，直到完成了多行输入则又变回 >>>。如：

>>> tels = [
… 13011110000,
… 18022221111,
… 13433332222
… ]
>>>

列表中的数据可以是任意类型的。比如整数型、字符串类型和布尔类型等：

列表索引

列表中的每个数据项都是有先后次序的，最前面的数据项的位置编号为 0，之后依次是 1 ，2 …… N，这个位置编号在编程中的术语叫做索引（Index）。注意 Python 中索引是从 0 开始计数的，0 即代表第一个位置。

可以通过符号 [] 来获取某个索引所对应的数据项。比如：

>>> fruits = [‘apple’, ‘banana’, ‘cherry’, ‘durian’]
>>> fruits[0]
’apple’
>>> fruits[2]
’cherry’

上面的 fruits 有 4 项数据，所以最大的索引是 3。如果我们强行要用更大的索引值去取数据会怎样呢，来试一下：

>>> fruits[4]
Traceback (most recent call last):
     File “”, line 1, in
IndexError: list index out of range

可以看到代码直接就报错了，具体信息为「list index out of range」，列表索引超出范围。

扩展：这是 Python 的典型报错形式，这里有三行内容（也可能会有很多行），前两行是错误定位，描述出错的位置（如某文件的某行），后面是错误描述，指出这是个 IndexError 错误，具体信息为「list index out of range」。

若大家在写代码时遇到错误，可以按照这种方法尝试自己分析错误信息。

除了通过索引去获取值，也可以通过索引去改变列表中某项数据的值。通过赋值的方式来实现：

>>> fruits[0]
‘apple’

>>> fruits[0] = 'pear’
>>> fruits[0]
‘pear’

列表的长度

列表中数据项的个数，叫做列表（的）长度。

想要获得列表的长度可以使用 len() 这个东西。像这样：

>>> len(fruits)
4

>>> len([1, 2, 3, 4, 5, 6, 7])
7

说明：len() 是 Python 中的内置函数。函数的概念会在之后的章节中介绍。

向列表添加数据

之前使用时，列表中的数据在一开始就已经被确定下来了，并一直保持着这个长度。但在很多时候，我们需要随时向列表中添加数据。

向列表的末尾添加数据可以用 .append()这个东西，它的写法是：

看一个示例。这里首先创建了一个空的列表，将其变量命名为 fruits，然后通过 .append() 向其中添加内容。

>>> fruits = []
>>> fruits
[]

>>> fruits.append(‘pear’)
>>> fruits
[‘pear’]

>>> fruits.append(‘lemon’)
>>> fruits
[‘pear’, ‘lemon’]

扩展：append() 是列表的方法。「方法」具体是什么我们在之后的面向对象章节中介绍。这里暂且把方法理解为某个数据类型自带的功能，如 append() 是列表自带的功能。

字符串（String）

字符串也可以保存批量数据，只不过其中的数据项只能是字符。

我们在前一个章节中介绍过字符串，字符串是用来表示文本的数据类型。字符串以单引号或双引号以及包裹在其中的若干字符组成，如：

字符串索引

从形式上我们不难看出，字符串中的字符也是有先后次序的。字符串是字符的有序序列，所以也具有索引。也可以根据索引取出其中某一个字符。其索引使用方式和列表相同：

>>> ‘good good study’[3]
‘d’

也可以先把字符串保存在变量里，然后在变量上使用索引。结果是一样的：

>>> words = ‘good good study’
>>> words[3]
‘d’

有一点需要注意，字符串不能像列表那样通过索引去改变数据项的值。因为字符串类型的值是不可变的（Immutable），我们不能在原地修改它其中的某个字符。

>>> words = ‘good good study’
>>> words[3] = 'b’
Traceback (most recent call last):
     File “”, line 1, in
TypeError: ‘str’ object does not support item assignment

上面报出一个 TypeError 错误，具体信息为「‘str’ object does not support item assignment」，其中「‘str’ object」指的就是字符串，它不支持直接为其中某一个项（字符）赋值。

字符串长度

字符串中字符的个数也就是字符串的长度（包括空格在内的所有空白符号）。

获取字符串长度的方式和列表一样，也是使用 len()：

>>> len(‘good good study’)
15

总结

如果我们想要保存和表示批量数据，可以使用 Python 中的列表（List）类型。列表是有序序列，能保存任意类型的数据项，可以通过索引（Index）来获取和修改其中某一个数据项，可以通过 len() 函数来获取列表的长度，也可以通过 .append() 在列表末尾追加数据项。

如果数据是文本，那么可以用字符串类型（String）来表示。字符串类型是字符的有序序列，可以通过索引获取某个位置的字符，也可以通过 len() 函数来获取长度。

Python 中的列表和字符串还有很多功能，之后讲「数据结构」时为大家一一介绍。

---

多语言比较：

数组是保存和表示批量数据的最基本的结构，它也是构造字符串、集合和容器的基石。

Python 中没有数组概念，取而代之的是列表这种更高级的数据结构，列表涵盖了数组的功能并提供了更多且更强大的功能。

Java 中，用 类型[] 的写法来表示数组：

// 定义数组
int numbers[];

// 定义数组并用指定值初始化：
int numbers[] = {1, 2, 3};

C/C++ 定义数组：

// 定义数组
int numbers[3];

// 定义数组并用指定值初始化：
int numbers[] = {1, 2, 3};

Go 语言定义数组：

// 定义数组
var numbers [3] int

// 定义数组并用指定值初始化：
var numbers = [3]int {1, 2, 3}

不只有一条路——分支和循环

前面的章节中我们学习了数据类型、变量、赋值、数值运算，并且用这些知识编写程序来做一些简单的运算，比如「计算一年有多少秒」。像这样的程序，执行流程是完全固定的，每个步骤事先确定好，运行时一步一步地线性地向下执行。

但是很多时候程序的功能会比较复杂，单一的执行流程并无法满足要求，程序在运行时可能需要对一些条件作出判断，然后选择执行不同的流程。这时就需要分支和循环语句了。

input()、print() 和 int() 函数

在开始学习分支和循环前，为了可以让程序与我们交互，先来学习三个函数。至于什么是函数，我们暂且把它看作是程序中具有某种功能的组件，下一小节中将会详细介绍函数的概念。

input() 函数

如果想要通过命令行与程序交互，可以使用 input() 函数。

input() 函数可以在代码执行到此处时输出显示一段提示文本，然后等待我们的输入。在输入内容并按下回车键后，程序将读取输入内容并继续向下执行。读取到的输入内容可赋值给变量，供后续使用。写法如下：

>>> age = input(‘请输入你的年龄：’)
请输入你的年龄：30
>>> age
’30’

这行代码会在命令行中显示「请输入你的年龄：」，然后等待输入，读取到输入内容后赋值给 age 变量。

input() 返回的结果是字符串类型，如 '30'。如果我们需要整数型，可以使用 int() 函数进行转换。

int() 函数

int() 函数可以将字符串、浮点型转换整数型。写法为：

将字符串类型 ‘1000’ 转换为整数型 1000：

>>> int(‘1000’)
1000

将浮点数 3.14 转化为整数：

>>> int(3.14)
3

print() 函数

print() 函数可以将指定的内容输出到命令行中。写法如下：

>>> print(‘Hello World!’)
Hello World!
>>> print(‘你的年龄是’, 20)
你的年龄是 20

要输出的内容放在括号中，多项内容时用逗号分隔，显示时每项以空格分隔。

input()、print() 示例

我们可以把 input() 和 print() 结合起来。如下面这两行代码将在命令行中提示「请输入你的年龄：」，然后等待输入，手动输入年龄后按下回车键，将显示「你的年龄是 x」。

我们把代码保存到文件中，文件命名为 age.py， 然后执行下：

➜ ~ python3 age.py
请输入你的年龄：18
你的年龄是 18

分支

上一个例子很简单，接收一个输入内容然后把该内容显示出来。现在难度升级。在刚才代码的基础上，如果所输入的年龄小于 18 岁，那么在最后再显示一句勉励语——「好好学习，天天向上」。如何来实现？

if 语句

如果想要表达「如果……」或者「当……」这种情形，需要用到 if 语句。它的写法是：

它的执行规则是，若「条件」满足，则执行 if 下的「代码块」，若「条件」不满足则不执行。

条件满足指的是，条件的结果为布尔值 True，或非零数字，或非空字符串，或非空列表。

代码块就是一段代码（可以是一行或多行），这段代码作为一个整体以缩进的形式嵌套在 if 下面。按照通常的规范，缩进以 4 个空格表示。

回到我们之前的需求上，「当年龄小于 18 岁」就可以通过 if 语句来实现。完整代码如下：

保存在文件中，执行一下看看：

➜ ~ python3 age.py
请输入你的年龄：17
你的年龄是 17
好好学习，天天向上

➜ ~ python3 age.py
请输入你的年龄：30
你的年龄是 30

可以看到，当所输入的年龄小于 18 时，程序在最后输出了「好好学习，天天向上」，而输入年龄大于 18 时则没有。

else 语句

又在上面的基础上，如果输入的年龄大于等于 18 岁，输出「革命尚未成功，同志任需努力」。该如何实现？

我们可以在 if 语句之后紧接着使用 else 语句，当 if 的条件不满足时，将直接执行 else 的代码块。写法如下：

若条件满足，则执行代码块 1，若不满足则执行代码块 2。所以之前的需求我们可以这样实现：

执行下看看：

➜ ~ python3 age.py
请输入你的年龄：18
你的年龄是 18
革命尚未成功，同志任需努力

➜ ~ python3 age.py
请输入你的年龄：17
你的年龄是 17
好好学习，天天向上

elif 语句

我们可以看到，if 和 else 表达的是「如果……否则……」这样的二元对立的条件，非此即彼。但有时我们还需要表达「如果……或者……或者……否则……」这样多个条件间的选择。

举个例子，下表是年龄和其对应的人生阶段。

年龄	人生阶段
0-6 岁	童年
7-17 岁	少年
18-40 岁	青年
41-65 岁	中年
65 岁之后	老年

当我们在程序中输入一个年龄时，输出对应的人生阶段。该如何实现？我们先用汉语来描述一下代码逻辑（这种自然语言描述的代码逻辑，也叫作伪代码）：

可以看到，我们需要依次进行多个条件判断。要实现它就要用到 elif 语句了，字面上它是 else if 的简写。

elif 置于 if 和 else 之间，可以有任意个：

之前根据年龄输出人生阶段的需求，可以这样实现：

➜ ~ python3 age.py
请输入年龄：3
童年
➜ ~ python3 age.py
请输入年龄：17
少年
➜ ~ python3 age.py
请输入年龄：30
青年
➜ ~ python3 age.py
请输入年龄：65
中年
➜ ~ python3 age.py
请输入年龄：100
老年

分支语句小结

如上所述，if 可以配合 elif 和 else 一起使用。代码执行时，将会从第一个条件开始依次验证判断，若其中某个条件满足，则执行对应的代码块，此时后续条件将直接跳过不再验证。

一个 if-elif-else 组合中，elif 可出现任意次数，else 可出现 0 或 1 次。

while 循环

之前介绍的 if 语句，是根据条件来选择执行还是不执行代码块。我们还有一种很重要的场景——根据条件来判断代码块该不该被重复执行，也就是循环。

在 Python 中可以使用 while 语句来执行循环操作，写法如下：

它的执行流程是，从 while 条件这句出发，判断条件是否满足，若满足则执行代码块，然后再次回到 while 条件，判断条件是否满足……循环往复，直到条件不满足。

可以看到，如果这里的条件一直满足且固定不变，那么循环将无穷无尽地执行下去，这称之为死循环。一般情况下我们很少会刻意使用死循环，更多的是让条件处于变化中，在循环的某一时刻条件不被满足然后退出循环。

循环示例

举个例子，如何输出 100 次「你很棒」？

显然我们可以利用循环来节省代码，对循环条件做一个设计，让它刚好执行 100 次后结束。

利用一个计数器 count 让它保存循环的次数，当 count 小于 100 就执行循环，代码块每执行一次就给 count 加 1。我们在大脑中试着来模拟这个流程，用大脑来调试（Debug）。

将代码写入文件 loop.py，执行下看看：

➜ ~ python3 loop.py
你很棒
你很棒
你很棒
…

程序将如预期输出 100 行「你很棒」。

扩展：count = count + 1 可以简写为 count += 1

条件的与、或、取反

if 语句和 while 语句中的条件可以由多个语句组合表达。

and 关键字

要表达多个条件同时满足的情况，可以使用 and 关键字。使用 and 关键字时，在所有并列的条件均满足的情况下结果为 True。至少一个条件不满足时结果为 False。如：

>>> 2 > 1 and ‘abc’ == ‘abc’ and True
True
>>> 1 > 0 and 0 != 0
False

在 if 语句中可以这样使用 and 关键字 ：

上述 if 语句只有在所有的条件均满足的情况下，代码块才会被执行。

例如我们假设把年龄大于 30 并且为男性的人称为大叔，「年龄大于 30 」和「男性」是两个判断条件，并且需要同时满足，这种情况就可以用 and 关键字来表达。如：

or 关键字

要表达多个条件中至少一个满足即可的情况，可以使用 or 关键字。使用 or 关键字时，并列的条件中至少有一个满足时，结果为 True。全部不满足时结果为 False。

在 if 语句中可以这样使用 or 关键字 ：

上述 if 语句中只要有任意一个（或多个）条件满足，代码块就会被执行。

not 关键字

not 关键字可以将一个布尔值取反。如：

>>> not True
False
>>>
>>> not 1 > 0
False

用在 if 语句和 while 语句的条件上时，条件的结果被反转。

在 if 语句中可以这样使用 not 关键字 ：

上述 if 语句在条件不满足时执行代码块，条件满足时反而不执行，因为 not 关键字对结果取了反。

for 循环

前面介绍了 while 循环，在 Python 中还有一种循环方式——for 循环。

for 循环更多的是用于从头到尾地去扫描列表、字符串这类数据结构中的每一个项，这种方式叫做遍历或迭代。

for 循环写法为：

其执行过程是，反复执行 for 项 in 序列 语句和其代码块，项 的值依次用序列的各个数据项替换，直到序列的所有项被遍历一遍。

比如，有个列表为 ['apple', 'banana', 'cherry', 'durian']，我们想依次输出它的每个列表项，就可以用 for 循环。

将代码写入 for.py，执行下：

➜ ~ python3 for.py
apple
banana
cherry
durian

可以看到，

1. 第一次循环时， fruit 的值为 apple
2. 第二次循环时， fruit 的值为 banana
3. 第三次循环时， fruit 的值为 cherry
4. 第四次循环时， fruit 的值为 durian

每次循环时 fruit 都自动被赋予新的值，直到 fruit_list 的所有列表项遍历完，循环退出。

总结

input() 函数可以在程序运行到此处时输出一段提示文本，然后停留在此等待我们的输入，输入内容后按下回车键，程序将读取输入内容并向下执行。写法为：

print() 函数可以将内容输出到命令行中，内容放到括号中，多项内容时可用逗号分隔。写法为：

int() 函数可以将字符串、浮点型转换整数型。写法为：

if，elif，else 组合使用，根据条件来选择对应的执行路径。写法为：

while 语句来用执行循环操作，根据条件来判断代码块该不该被重复执行。写法为：

for 循环通常用于执行遍历操作。写法为：

---

多语言比较：

Java 中的分支语句：

if (条件1) {
 代码块1
} else if (条件2) {
 代码块2
} else {
 代码块3
}

C/C++ 中的分支语句：

if (条件1) {
 代码块1
} else if (条件2) {
 代码块2
} else {
 代码块3
}

Go 中的分支语句：

if 条件1 {
 代码块1
} else if 条件2 {
 代码块2
} else {
 代码块3
}

Java 中的循环：

for (int i=0; i < 100; i++) {
 代码块
}

// 或 for each 形式
for (int number: numbers) {
 代码块
}

C/C++ 中的循环：

for (int i=0; i < 100; i++) {
 代码块
}

Go 中的循环：

for i := 0; a < 100; i++ {
 代码块
}

// 相当于 while 
for 条件 {
 代码块
}

// for each 形式
for index, item := range numbers {
 代码块
}

将代码放进盒子——函数

我们之前介绍过一些函数，如 print()、int()、input() 等。直接使用它们就可以获得一些功能，如向命令行输出内容、转换数字、获取命令行输入，那么它们到底是什么呢？

函数的初步理解

大家应该都非常熟悉数学上的函数，简单来说数学上的函数就是一个映射关系，给定一个 x，经映射后将得到 y 值，至于这其中的映射关系我们可以直接把它抽象为 y=f(x)。

程序中的函数与数学上的函数有一丝类似，我们也可以把它抽象地看作一个映射关系，给定输入参数后，经函数映射，返回输出结果。如之前我们使用过的 int() 和 len()：

给定输入值，经函数处理，返回输出值，这是函数最单纯的模式。

函数如何定义

Python 中函数的定义方式如下：

函数的输入值叫做函数参数，如上面的「参数1」、「参数2」。函数参数的个数可以是任意个，如 0 个、1 个或多个。需要注意参数是有顺序的，使用时要按对应位置传递参数。

函数内部的代码块就是函数的实现。所有的函数功能都实现于此。

函数的输出结果叫函数的返回值。函数可以没有返回值，也可以有一个或多个返回值。返回值通过 return 语句传递到函数外部，如：

函数定义示例

我们来编写一个函数试试，这个函数的需要的参数是年龄，返回值是年龄对应的人生阶段。

年龄	人生阶段
0-6 岁	童年
7-17 岁	少年
18-40 岁	青年
41-65 岁	中年
65 岁之后	老年

这个功能好像有点眼熟，没错，上一章节中我们完成过这个功能，现在把这个功能改写成函数。

可以这样来定义这个函数：

我们给函数起名为 stage_of_life，需要一个参数 age，最终通过 return 语句返回对应的人生阶段，这个人生阶段就是函数的返回值。

这里虽然有多个 return 语句，但是实际上每次函数使用时，只会有一个 return 语句被执行。

副作用

上面这个示例中，给定一个参数 age，便返回对应的人生阶段。函数内部只是做了一个映射，并没有对程序和系统的状态作出影响，这样的函数是纯函数。

纯函数是函数的一个特例，更普遍的情况是，函数包含一些会引起程序或系统状态变化的操作，如修改全局变量、命令行输入输出、读写文件等，这样的变化叫做函数的副作用。

副作用并不是不好的作用，它只是函数在输入值和输出值间映射之外，所附带的作用。副作用在有些时候是不可避免的。

因为有了副作用，函数就不必完全遵从 输入 -> 映射 -> 输出 这种模式，函数可以在没有参数或返回值的情况下，拥有其功能。如果你看到一个函数没有参数或返回值，要自然的想到，那是副作用在发挥作用。

没有参数没有返回值：

有参数没有返回值：

没有参数有返回值：

函数的调用

函数定义完成后，就可以在后续的代码中使用它了，对函数的使用叫做函数调用。

以前我们调用过 int()、len()，它们是内置在 Python 语言中的函数，也就是内置函数。现在我们自己定义了 stage_of_life，调用的方式是一样的：

用参数的形式将数据传递给函数，用赋值语句来接收返回值。

需要说明的是

• 函数有多个参数时，参数是有顺序的，要按对应位置将参数传递进去。

  >>> def minus(x, y):
  … return x - y
  …
  >>> minus(1, 3)
  -2
  >>> minus(3, 1)
  2

• 函数需要先经过定义，之后才能被调用，否则解释器将找不到这个函数名，也就无法调用它。

  未定义函数便直接调用，解释器将报出「名字未定义」的错误：

  >>> stage = abc(18)
  Traceback (most recent call last):
  File “”, line 1, in
  NameError: name ‘abc’ is not defined

函数有什么用

从形式上来看，函数将一段代码包裹起来，调用函数就像当于执行那段代码。代码所需要的数据我们可以通过函数参数的形式传递进去，代码的执行结果通过返回值出传递出来。那么函数到底有什么用呢？

抽象

函数的价值主要体现在调用时，而不是定义时。调用时函数就像个盒子，使用者不需要了解其中有什么代码，是什么样的逻辑，只要知道怎么使用它的功能就足够了。以 len() 函数为例，我们不知道这个函数的原理，但是能用它达到我们获取列表长度的目的，这就是它的重要价值。

简单来说函数的主要作用是抽象，屏蔽繁杂的内部细节，让使用者在更高的层次上简单明了地使用其功能。我们之前说过「计算机的世界里最重要的原理之一就是抽象」，函数就是其一个体现。

代码复用

因为具有抽象的好处，函数也延伸出另一个作用——复用，或者叫代码复用。也就是便于重复使用，节省代码。举个例子，假如我们想用程序计算并输出 -33，456，-0.03 的绝对值，不用函数时我们这样写：

显然有大量重复的代码，这些重复代码是可以避免的。用函数修改后如下：

代码量减少很多，也能应对未来的相同需求，这就是复用的好处。

什么时候用函数

看了上面函数的好处之后，想必你已经知道在什么时候用函数了吧？

• 需要通过函数的形式把这些复杂性隔离出来，之后在使用时只需调用这个函数即可，清晰且优雅。

• 需要复用时。一段相似甚至完全一致的代码在多处被使用，可以考虑将这段代码定义为函数，然后在各处去调用它。

总结

函数的主要作用是抽象和代码复用。

Python 中函数的定义方法：

返回值通过 return 语句传递到函数外部。

---

多语言比较

Java 中所有的函数都需要定义在类中，类中的函数也叫做方法。

Java 中定义函数：

int add(int x, int y) {
 return x + y
}

C/C++ 中定义函数：

int add(int x, int y) {
 return x + y
}

Go 中定义函数：

func max(x, y int) int {
   return x + y
}

到这里python基础入门的一些知识就先和大家分享到这里了，内容有点多，小伙伴们可以收藏慢慢阅读！

在学习中有疑问或者不懂的地方欢迎小伙伴评论留言！

之后持续为大家更新Python入门及进阶技术分享！

觉得有用的小伙伴记得点赞关注哟！

灰小猿陪你一起进步！

【生长吧！Python】有奖征文火热进行中：https://bbs.huaweicloud.cn/blogs/278897