本章涉及内容：

• if语句（if代码块、else代码块、elif代码块）
• 缩进
• 流程图
• 比较运算符
• pass语句
• 逻辑型
• 布尔型
• 表达式和求值
• 逻辑运算符
• 短路求值
• 通过集合来判断
• 条件运算符
• 嵌套if语句
• 简单语句和复合语句（代码组）
• min函数和max函数
• 排序（升序/降序）和sorted函数
• token、关键字、标识符、运算符、分隔符、字面量
• 语法错误和异常
• 编码规范和PEP8

1. if语句

可以根据给定条件是否成立来决定是否执行处理操作。

基础示例

# 读取的整数是否为正数
n = int(input("整数："))
if n > 0:
    print("该值为正数")
    

运行结果：

以上代码中，print前有4个空格，在python中是一定要有的，这样的做法叫做“缩进”，实际上，空格的数量不一定必须为4个，但至少要有一个，也可以使用制表符代替空格，但是不建议这样，因为在 不同的系统中空格和缩进会展示出不同的效果，不便于代码阅读，也不可以使用全角符号的空格

比较运算符

对左操作数的值和右操作数的值进行比较的运算符称为比较运算符，比较运算符共有6种，具体列表如下：

• 即使是不同类型的操作数，也可以使用比较运算符进行比较
• >=、!=、<=、==之间不能有空格

else代码块

前面小节中的示例在读取的值为正数时才会输出，但是值为负数或0时不显示任何内容，为了让程序可以显示“该值为0或负数”，可以使用else表达式，修改程序如下：

# 读取的整数是否为正数
n = int(input("整数："))
if n > 0:
    print("该值为正数")
else:
    print("该值为0或负数")

运行结果：

与之前的程序相同，每个print之前必须使用缩进；else表示“如果不是XXX，则执行XXX”，表达式在求值后，如果结果为真则执行if代码块中的内容，如果结果为假则执行else代码块中的内容

判断是否相等

编写如下程序：

# 判断输入的两个数是否相等
a = int(input("整数a:"))
b = int(input("整数b:"))

if b == a:
    print("两个数相等")
else:
    print("两个数不相等")

正例：

反例：

elif代码块

如果要对更多条件执行更多的操作，可以使用elif代码块：

# 读取的整数是否为正数
n = int(input("整数："))
if n > 0:
    print("该值为正数")
elif n < 0:
    print("该值为负数")
else:
    print("该值为0")

以上代码实现了对正数、负数和0的区分，elif代码块可以有多个，用来实现更多的分支

• 各个代码块中的语句属于不同分支，整个if语句只会执行某一个分支中的语句
• python中不支持switch语句

pass语句

• 不执行任何操作
• 在语法结构上必须有语句，但是此处逻辑上不需要任何操作时，可以使用pass语句

简单语句

pass就是一种简单语句，常用的简单语句还有：

• 表达式语句

  • 调用的表达式直接变为语句，例如print('ABC')

• 赋值语句

  • 进行赋值操作的语句，例如a=b
• break
• continue
• del

逻辑型

又称bool型，表示真和假。逻辑性包含两个值，分别是True和False，在Python内部分别使用1和0表示

• False、0、0.0、None、空值（包括空字符串、空列表、空元组、空字典、空集合）都为假
• 除以上列出的值外的其他值和True都为真

• 虽然False为假，但被视为假的值不一定是False，同样，True的值为真，但被视为真的值不一定是True
• 逻辑值转换为字符串后会变为'False'或'True'
• 使用print函数输出逻辑值后，程序会显示出字符串

表达式和求值

表达式

• 变量
• 字面量
• 用运算符结合变量和字面量的项

以上三项内容的总称称为表达式，此外，“XX运算符”和操作数结合在一起的表达式称为“XX表达式”，例如使用比较运算符>将a和135结合在一起后的a>135称为比较表达式

表达式求值

表达式中一般包含类型和值，其中，值会在程序运行时被解析，解析的过程称为求值。表达式的整体类型和各个操作数的类型不一定是相同的。

no = int(input('no的值'))

print('no + 135的类型是{}，值是{}'.format(type(no+135), no + 135))
print('no > 135的类型是{}，值是{}'.format(type(no>135), no > 135))

运行结果：

逻辑运算符

在Python中，逻辑运算符用于组合布尔值（True 或 False）并返回布尔结果。以下是Python中的基本逻辑运算符：

1. and：逻辑与运算符。如果两个操作数都为真（True），则结果为真（True）；否则为假（False）。

   示例:

   True and True   # 返回 True
   True and False  # 返回 False

2. or：逻辑或运算符。如果两个操作数中至少有一个为真（True），则结果为真（True）；如果两者都为假（False），则结果为假（False）。

   示例:

   True or False   # 返回 True
   False or False  # 返回 False

3. not：逻辑非运算符。用于反转操作数的布尔值。如果操作数为真（True），则返回假（False）；如果操作数为假（False），则返回真（True）。

   示例:

   not True   # 返回 False
   not False  # 返回 True

这些逻辑运算符通常用于控制流语句（如 if、while）中，以及在布尔表达式中进行复杂的条件判断。例如：

a = 10
b = 20
if a > 5 and b > 15:
    print("Both conditions are True")

在这个例子中，and 运算符用于确保两个条件都满足。如果 a 大于 5 并且 b 大于 15，那么打印语句将被执行。

逻辑运算表达式的求值和短路求值

逻辑运算表达式的求值是根据逻辑运算符的定义来计算表达式的最终布尔值。在Python中，逻辑运算符and、or和not遵循特定的求值规则。

短路求值（Short-circuit evaluation）是逻辑运算表达式求值时的一个特性，其中逻辑表达式的求值会在确定最终结果的那一刻停止。这意味着在使用and和or运算符时，并不总是需要评估所有的操作数。

• 对于and运算符，如果第一个操作数为False，那么整个表达式的结果一定是False，因此不需要再评估第二个操作数。

  示例：

  result = False and some_function()  # some_function() 不会被调用，因为结果已经确定为 False

• 对于or运算符，如果第一个操作数为True，那么整个表达式的结果一定是True，因此不需要再评估第二个操作数。

  示例：

  result = True or some_function()  # some_function() 不会被调用，因为结果已经确定为 True

短路求值的优点是可以提高效率，避免执行不必要的计算，甚至可以用于防止可能导致错误的计算（例如，防止除以零的情况）。

示例：

a = 0
b = 10

# 由于短路求值，下面的表达式中的 b / a 不会被执行，因此避免了除以零错误
if a != 0 and (b / a) > 2:
    print("b is more than twice of a")

在这个例子中，如果a等于0，那么(b / a) > 2的计算将会导致一个除以零的错误。但是由于and运算符的短路行为，如果a等于0，那么(b / a) > 2将不会被评估，从而避免了错误。

多重比较

在Python中，可以使用多重比较来同时比较多个操作数。这是一种链式比较，允许你以一种更加直观和紧凑的方式表达一系列的关系测试。多重比较可以使用比较运算符，如<、>、<=、>=、==和!=来完成。

例如，如果你想检查一个变量x是否在两个数a和b之间，你可以使用多重比较来代替两个单独的比较表达式：

a < x < b

这个表达式相当于：

a < x and x < b

这两种表达式都会检查x是否大于a并且小于b。如果x确实在这两个数之间，那么表达式的结果是True；否则，结果是False。

多重比较的一个关键优点是所有的比较都是按照从左到右的顺序进行的，而且比较操作会短路，这意味着一旦某个比较结果为False，随后的比较就不会再执行了。

下面是一些多重比较的例子：

# 检查 x 是否在 5 和 10 之间
if 5 < x < 10:
    print("x is between 5 and 10")

# 检查 x 是否在 5 和 10 之间或者等于 20
if 5 < x < 10 or x == 20:
    print("x is between 5 and 10 or equals to 20")

# 检查 x 是否不等于 y 且大于 z
if x != y > z:
    print("x is not equal to y and y is greater than z")

在使用多重比较时，要确保你的比较逻辑是清晰的，以避免引入可能的逻辑错误。当你的比较逻辑变得复杂时，有时候将条件分开写可能会更清晰、更易于理解。

条件运算符

在Python中，条件运算符（也称为三元运算符）是一种基于条件表达式的值来选择两个表达式中的一个的方式。Python中的条件运算符的语法如下：

value_if_true if condition else value_if_false

这个表达式的工作方式是：如果condition为真（True），则表达式的结果是value_if_true；如果condition为假（False），则结果是value_if_false。

这种语法通常用于在单行中编写简短的条件语句，从而可以使代码更加紧凑。下面是一个使用条件运算符的例子：

a = 10
b = 5
max_value = a if a > b else b
print(max_value)  # 输出结果是 10

在这个例子中，条件运算符检查a是否大于b。由于a确实大于b，所以变量max_value被赋值为a的值。如果b大于a，则max_value将被赋值为b的值。

条件运算符非常适合进行简单的条件赋值，但对于更复杂的逻辑和多个条件的情况，使用传统的if-else语句通常更清晰易读。

2. if语句嵌套和代码组

在Python中，if语句可以嵌套在其他if语句内部，以便根据多个条件执行不同的操作。嵌套if语句意味着在一个if或elif代码块内部有另一个if或elif代码块。这通常用于在满足某个条件的情况下进一步检查其他条件。

代码组是指一组在同一逻辑级别上执行的代码行。在Python中，代码组通常是通过缩进来定义的，同一组代码具有相同的缩进级别。

下面是一个使用嵌套if语句的例子：

age = 20
has_license = True

if age >= 18:
    if has_license:
        print("You are allowed to drive.")
    else:
        print("You are not allowed to drive without a license.")
else:
    print("You are too young to drive.")

在这个例子中，外层if语句首先检查年龄是否大于或等于18岁。如果这个条件为真，程序进入内层if语句，这时会进一步检查是否拥有驾驶执照。内层if语句的代码组是由缩进来区分的，它们只有在外层if语句的条件为真时才会执行。

使用嵌套if语句时应该小心，因为过多的嵌套层次可能会导致代码难以理解和维护。通常，如果你发现自己在嵌套了很多层if语句，可能需要考虑重构代码，例如通过将逻辑分解为函数或使用更复杂的控制结构来简化嵌套。

3. 程序的构成要素

在Python程序中，行（换行符）和缩进（空格）都被赋予了明确的含义。

• 在代码行末尾使用\可以延续本行代码至下一行。
• 空行实际上被程序忽略了
• 缩进的含义和使用方法
• 代码可以在()中随意换行，此外，在[]，{}中也可以随意换行

除了换行、缩进、空格外，程序还包括关键字、标识符、注释、运算符和分隔符等。这些要素被称为 “Token”，类似中文中的“单词”。

关键字

Python 3的关键字列表如下。这些关键字是Python语言的保留字，它们具有特殊的含义和功能，不能用作变量名或其他标识符名称。

下面是一个表格，展示了Python中的所有关键字：

Python的关键字列表可能会随着语言的更新而发生变化。 若要获取当前Python解释器中可用的关键字列表，可以使用keyword模块：

import keyword
print(keyword.kwlist)

运行上述代码将输出当前Python版本的关键字列表。

关键字也称为保留字

标识符

Python 中的标识符遵循一定的命名规则：

1. 字符集：标识符可以包含字母（a 到 z 或 A 到 Z）、数字（0 到 9）或下划线（_）。但是，标识符的第一个字符不能是数字。
2. 区分大小写：在Python中，标识符是区分大小写的。例如，myVariable 和 myvariable 被认为是两个不同的标识符。
3. 不使用关键字：标识符不能是Python的关键字。关键字是保留的单词，它们有特殊的语法意义。
4. 无长度限制：理论上，标识符可以是任意长度的，但为了可读性，建议使用适当长度的名称。
5. 不使用特殊字符：标识符不能包含如 @、$、% 等特殊字符。

以下是一些有效的Python标识符的例子：

• my_variable
• index1
• UserClass
• __init__
• _private
• MAX_COUNT

以下是一些无效的Python标识符的例子：

• 1variable （不能以数字开头）
• my-variable （包含减号，这不是允许的字符）
• global （这是一个关键字）
• class （这是一个关键字）

遵循好的命名习惯可以使你的代码更容易阅读和维护。例如，通常使用小写字母和下划线来命名变量（例如 my_variable），而使用首字母大写的方式来命名类（例如 MyClass）。此外，对于私有变量或方法，有时会在名称前加一个下划线（例如 _private_var），以表示它们不应该在类的外部使用。

运算符

在Python中，运算符是用于执行操作的特殊符号。以下是一些主要的运算符类别，以及它们的定义、优先级、结合规则和注意点。

算术运算符

• 定义：执行数学运算，如加法、减法、乘法等。
• 例子：+ (加法), - (减法), * (乘法), / (除法), // (整除), % (取模), ** (幂运算)。
• 优先级：幂运算 > 乘除 > 加减。
• 结合规则：幂运算符是从右向左结合的，其他算术运算符是从左向右结合。
• 注意点：除法总是产生浮点数，要得到整数结果应使用整除。

赋值运算符

• 定义：用于将值赋给变量。
• 例子：=, +=, -=, *=, /=, //=, %=, **=.
• 优先级：优先级较低。
• 结合规则：从右向左。
• 注意点：a += b 是 a = a + b 的缩写形式。

比较运算符

• 定义：用于比较两个值。
• 例子：== (等于), != (不等于), > (大于), < (小于), >= (大于等于), <= (小于等于)。
• 优先级：优先级较低。
• 结合规则：从左向右。
• 注意点：比较运算符的结果总是布尔值。

逻辑运算符

• 定义：用于组合布尔值。
• 例子：and, or, not。
• 优先级：not > and > or。
• 结合规则：and 和 or 是从左向右结合，not 有最高优先级。
• 注意点：and 和 or 使用短路求值。

成员运算符

• 定义：用于测试序列成员关系。
• 例子：in, not in。
• 优先级：优先级较低。
• 结合规则：从左向右。
• 注意点：可以用于字符串、列表、元组等。

身份运算符

• 定义：用于比较两个对象的内存地址。
• 例子：is, is not。
• 优先级：优先级较低。
• 结合规则：从左向右。
• 注意点：is 用于比较对象标识，而 == 用于比较值。

位运算符

• 定义：对整数进行二进制位操作。
• 例子：& (按位与), | (按位或), ^ (按位异或), ~ (按位取反), << (左移), >> (右移)。
• 优先级：按位运算符的优先级较低。
• 结合规则：大多数位运算符从左向右结合。
• 注意点：位运算符用于整数类型，且操作在二进制层面上进行。

运算符优先级总结

Python中，运算符的优先级从高到低排列如下：

1. () (括号)
2. ** (幂运算)
3. +x, -x, ~x (一元加、减和按位取反)
4. *, /, //, % (乘法、除法、整除、取模)
5. +, - (加法、减法)
6. <<, >> (位左移、位右移)
7. & (按位与)
8. ^ (按位异或)
9. | (按位或)
10. ==, !=, >, <, >=, <= (比较运算符)
11. is, is not, in, not in (身份运算符和成员运算符)
12. not (逻辑非)
13. and (逻辑与)
14. or (逻辑或)
15. 赋值运算符 (=, +=, -=, 等)

注意事项

• 使用括号 () 可以改变运算顺序。
• 在实际编程中，为了提高代码的可读性，建议使用括号明确运算顺序，即使它们不是必需的。
• 在使用复合赋值运算符时，例如 a += b，如果 a 是不可变类型，这将创建一个新对象并将其赋值给 a；如果 a 是可变类型，则会就地修改 a。
• 在进行比较时，特别是浮点数比较时，由于精度问题，可能需要考虑使用容差或者 math.isclose 函数来判断两个数是否足够接近。

分隔符

在Python中，分隔符通常用于在语法结构中分隔元素，如变量、函数参数、列表项等。以下是一些常见的分隔符及其用途：

1. 逗号 (,)

   • 用于分隔列表、元组、字典中的项。
   • 在函数调用和定义中分隔参数和参数列表。
   • 在多重赋值和返回语句中分隔值。

   示例：

   my_list = [1, 2, 3]
   def func(a, b, c):
       return a, b, c

2. 冒号 (:)

   • 用于切片操作，指定开始、结束和步长。
   • 在字典中分隔键和值。
   • 在控制流语句（如 if、for、while）和函数定义后指示代码块的开始。

   示例：

   my_slice = my_list[0:2]
   my_dict = {'key': 'value'}
   def my_function():
       pass

3. 点 (.)

   • 用于访问对象的属性和方法。
   • 在模块导入语句中指定路径。

   示例：

   import my_module.sub_module
   my_object.my_method()

4. 分号 (;)

   • 可用于在同一行中分隔多个语句，但这种做法在Python中不推荐，因为它降低了代码的可读性。

   示例（不推荐）：

   a = 5; b = 10; c = a + b

5. 反斜杠 (\)

   • 用于续行符，当一行代码很长需要分成多行书写时，可以使用反斜杠。

   示例：

   if a == 1 and b == 2 and \
      c == 3 and d == 4:
       pass

6. 括号 ((), [], {})

   • 圆括号用于定义元组、优先改变运算顺序、函数调用和定义。
   • 方括号用于定义列表、字典以及进行索引和切片操作。
   • 花括号用于定义集合和字典。

   示例：

   my_tuple = (1, 2, 3)
   my_list = [1, 2, 3]
   my_dict = {'key': 'value'}
   my_set = {1, 2, 3}

在编写Python代码时，正确使用这些分隔符对于保持代码的清晰和组织性至关重要。

.也会用在浮点数字面量和虚数字面量中。此外，.也会作为省略符号...使用。在这些情况下，.并不作为分隔符使用。

语法错误和异常

在编程中，错误可以分为两大类：语法错误和异常。

语法错误 (Syntax Errors)

语法错误，也称为解析错误，是由于代码不符合编程语言的规范而发生的。这些是初学者最常见的问题，通常是因为打字错误、缺少括号、错误的缩进或者遗漏了某些必要的符号。

例如，在Python中，忘记冒号或者错误的缩进会导致语法错误：

# Syntax error caused by missing colon
if True
    print("This will cause a syntax error.")

# Syntax error caused by incorrect indentation
if True:
print("This will also cause a syntax error.")

当Python解释器遇到语法错误时，它无法执行代码，并且通常会提供错误消息和出错的位置来帮助你找到问题所在。

异常 (Exceptions)

异常是在程序执行时检测到的错误，即使代码在语法上是正确的。异常可能由多种原因引起，包括逻辑错误、运行时环境问题或者不可预见的情况。

在Python中，异常是通过特殊的对象来处理的，这些对象可以被捕获和处理，从而允许程序恢复并继续执行。如果异常没有被捕获和处理，程序将终止，并显示一个错误消息，这通常包括异常的类型和堆栈跟踪。

常见的Python异常包括：

• ZeroDivisionError：尝试除以零。
• NameError：尝试访问一个未被定义的变量。
• TypeError：对类型进行了不合适的操作，例如尝试将字符串和数字相加。
• IndexError：尝试访问序列（如列表）中不存在的索引。
• KeyError：尝试访问字典中不存在的键。
• FileNotFoundError：尝试打开一个不存在的文件。
• ValueError：传递给函数的参数类型正确，但值不合适。

异常处理通常使用try和except语句来完成：

try:
    # 尝试执行可能引发异常的代码
    result = 10 / 0
except ZeroDivisionError:
    # 处理特定的异常
    print("You can't divide by zero!")

在Python中，你还可以使用else子句来定义当try块没有引发异常时执行的代码，以及finally子句来定义无论是否引发异常都会执行的清理代码。

try:
    # 尝试执行代码
    result = 10 / 1
except ZeroDivisionError:
    # 处理异常
    print("You can't divide by zero!")
else:
    # 没有异常发生时执行
    print("Division successful!")
finally:
    # 总是执行的代码
    print("Cleaning up, regardless of any exceptions.")

正确处理异常对于编写健壮、可靠和用户友好的程序非常重要。