Python 的运算符和语句（条件、循环、异常）基本使用指南

r囧r小猫 2023-10-16 09:09 6阅读 0赞

## 运算符的分类 ##

*  算数运算符
 *  赋值运算符
 *  复合赋值运算符
 *  比较运算符
 *  逻辑运算符

### 算数运算符 ###

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>+</td> 
   <td>加</td> 
   <td>1 + 1 输出结果为 2</td> 
  </tr> 
  <tr> 
   <td>-</td> 
   <td>减</td> 
   <td>1 - 1 输出结果为 0</td> 
  </tr> 
  <tr> 
   <td>*</td> 
   <td>乘</td> 
   <td>2 * 2 输出结果为 4</td> 
  </tr> 
  <tr> 
   <td>/</td> 
   <td>除</td> 
   <td>10 / 2 输出结果为 5</td> 
  </tr> 
  <tr> 
   <td>//</td> 
   <td>整除</td> 
   <td>9 // 4 输出结果为 2</td> 
  </tr> 
  <tr> 
   <td>%</td> 
   <td>取余</td> 
   <td>9 % 4 输出结果为 1</td> 
  </tr> 
  <tr> 
   <td>**</td> 
   <td>指数</td> 
   <td>2 ** 4 输出结果为 16，<code>2 * 2 * 2 * 2</code></td> 
  </tr> 
  <tr> 
   <td>()</td> 
   <td>小括号</td> 
   <td>小括号用来提高运算优先级，即 (1 + 2) * 3 输出结果为 9</td> 
  </tr> 
 </tbody> 
</table>

注：

*  混合运算优先级顺序： () ⾼于 \*\* ⾼于 \* / // % ⾼于 + -
 *  由于算术运算符是 双目运算符 ，即有两个操作数参加运算，当参加运算的两个操作数的类型不一致时，首先转换成同一类型，然后进行运算，否则会提示错误。
    
    转换的基本规则是：
    
     *  如果参加算术运算的两个操作数中有一个是 复数 ，则把另一个也转换为复数；
     *  如果两个操作数中有一个是 浮点数 ，则把另一个也换成浮点数；
     *  如果两个操作数中有一个是 长整数 ，则把另一个也转换成长整数。
    
    转换时不同类型之间的转换必须遵守一定转换方向，例如不可以把一个浮点数转换为一个整数，也不能把一个复数转换为其它数值类型。

### 赋值运算符 ###

*  **单个变量赋值（简单赋值）**
    
        num = 1
        print ( num )
 *  **多个变量赋值（序列赋值）**
    
    在序列赋值语句中，等号左侧是元组或列表表示的多个变量，等号右侧是元组、列表或字符串等序列表示的数据。Python 按先后顺序依次将数据赋值给变量。
    
        num1, float1, str1 = 10, 0.5, 'hello world'
        print(num1)
        print(float1)
        print(str1)
    
    注：
    
     *  等号右侧为字符串时，Python 会将字符串分解为单个字符，依次赋值给各个变量，此时，变量个数和字符个数必须相等，否则会出错；
        
            a, b, c, d, f = 'hello'
            print(a)
            print(b)
            print(c)
            print(d)
            print(f)
     *  序列赋值时，可以在变量名之前使用 \*，不带星号的变量仅匹配一个值，剩余的值作为列表赋值给带星号的变量。
        
            a, b, *c = 'hello'
            print(a)
            print(b)
            print(c)
 *  **多变量赋相同值（多目标赋值）**
    
        a = b = 10
        print(a)
        print(b)

### 复合赋值运算符 ###

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>+=</td> 
   <td>加法赋值运算符</td> 
   <td>c += a 等价于 c == c + a</td> 
  </tr> 
  <tr> 
   <td>-=</td> 
   <td>减法赋值运算符</td> 
   <td>c -= a 等价于 c == c - a</td> 
  </tr> 
  <tr> 
   <td>*=</td> 
   <td>乘法赋值运算符</td> 
   <td>c *= a 等价于 c == c * a</td> 
  </tr> 
  <tr> 
   <td>/=</td> 
   <td>除法赋值运算符</td> 
   <td>c /= a 等价于 c == c / a</td> 
  </tr> 
  <tr> 
   <td>//=</td> 
   <td>整除法赋值运算符</td> 
   <td>c //= a 等价于 c == c // a</td> 
  </tr> 
  <tr> 
   <td>%=</td> 
   <td>取余法赋值运算符</td> 
   <td>c % = a 等价于 c == c % a</td> 
  </tr> 
  <tr> 
   <td>**=</td> 
   <td>幂赋值运算符</td> 
   <td><code>c **= a</code> 等价于 <code>c = c ** a</code></td> 
  </tr> 
 </tbody> 
</table>

### 比较运算符 ###

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>==</td> 
   <td>判断相等。如果两个操作数的结果相等，则条件结果为真（True），否则为假（False）</td> 
  </tr> 
  <tr> 
   <td>!=</td> 
   <td>不等于。如果两个操作数的结果不相等，则条件结果为真（True），否则为假（False）</td> 
  </tr> 
  <tr> 
   <td>&gt;</td> 
   <td>运算符左侧操作数结果是否大于右侧操作数结果，如果大于，则条件为真，否则为假</td> 
  </tr> 
  <tr> 
   <td>&lt;</td> 
   <td>运算符左侧操作数结果是否小于右侧操作数结果，如果小于，则条件为真，否则为假</td> 
  </tr> 
  <tr> 
   <td><code>&gt;=</code></td> 
   <td>运算符左侧操作数结果是否大于等于右侧操作数结果，如果大于等于，则条件为真，否则为假</td> 
  </tr> 
  <tr> 
   <td>&lt;=</td> 
   <td>运算符左侧操作数结果是否小于等于右侧操作数结果，如果小于等于，则条件为真，否则为假</td> 
  </tr> 
 </tbody> 
</table>

### 逻辑运算符 ###

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>逻辑表达式</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>and</td> 
   <td>x and y</td> 
   <td>布尔"与"：x 和 y 均为 True，则 x and y 为 True，否则为 False</td> 
   <td>True and False，返回 False</td> 
  </tr> 
  <tr> 
   <td>or</td> 
   <td>x or y</td> 
   <td>布尔"或"：x 和 y 均为 False，则 x and y 为 False，否则为 True</td> 
   <td>True or False，返回 True</td> 
  </tr> 
  <tr> 
   <td>not</td> 
   <td>not x</td> 
   <td>布尔"非"：如果 x 为 True，返回 False。如果 x 为 False，返回 True</td> 
   <td>not True，返回 False</td> 
  </tr> 
 </tbody> 
</table>

### 三元运算符 ###

在 Python 中，三元运算符（也称为条件运算符）是一种简洁的方式来编写条件表达式

*  语法结构如下：
    
        value_if_true if condition else value_if_false
        
        # 示例
        x = 10
        y = 20
        max_value = x if x > y else y		# 输出：20

## 条件语句（if-elif-else） ##

*  **if 语句**
    
        if 条件:
          条件成⽴执⾏的代码1
          条件成⽴执⾏的代码2
          ......
 *  **if…else…**
    
        if 条件:
          条件成⽴执⾏的代码
          ......
        else:
          条件不成⽴执⾏的代码
          ......
 *  **多重判断**
    
        if 条件1:
          条件1成⽴执⾏的代码
          ......
        elif 条件2：
          条件2成⽴执⾏的代码
          ......
        ......
        else:
          以上条件都不成⽴执⾏执⾏的代码
 *  **if 嵌套**
    
        if 条件1：
          条件1成⽴执⾏的代码
          ......
          if 条件2：
            条件2成⽴执⾏的代码
            ......

## 循环语句（for、while） ##

*  **for 循环**
    
    for 循环是 Python 中最常用的循环语句之一，可以遍历任何序列，如一个列表或者一个字符串。
    
    基本语法为：
    
        for variable in sequence:
            # 循环体
        [else]
        	# 循环体
    
     *  **variable** ：表示变量名
     *  **sequence** ：表示要遍历的序列
    
    示例：
    
        # 遍历列表或元组
        for number in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
            print(number**2)
        
        # 遍历字符串
        for char in "hello world":
            print(char.upper())
        
        # 遍历字典
        d = {
              'apple': 2, 'banana': 3, 'orange': 4}
        for key, value in d.items():
            print(key, value)
        
        # 遍历文件内容
        with open('file.txt', 'r') as f: 
            for line in f:
                print(line.strip())
 *  **while 循环**
    
    基本语法：
    
        while 条件:
            # 循环体
        [else]
        	# 循环体
    
    示例：
    
        fruits = ['apple', 'banana', 'orange', 'grape']
        i = 0
        while i < len(fruits):
            print(fruits[i])
            i += 1
 *  **break** 语句可以跳出 for 和 while 的循环体，如果从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
 *  **continue** 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
 *  **pass** 语句是空语句，是为了保持程序结构的完整性，pass 不做任何事情，一般用做占位语句

## 异常的捕获和处理（try-except-finally） ##

*  **try** 语句和 **except** 语句：用于捕获和处理异常
    
     *  **try** 语句：包含可能会引发异常的代码块。如果在 `try` 代码块中发生异常，程序将立即跳转到 `except` 代码块，以执行异常处理操作。
     *  **except** 语句：在 `except` 语句中，异常对象被赋值给变量 `e`，可以使用它来获取有关异常的信息。
     *  **else 语句**：可以使用 `else` 语句来指定当没有异常发生时要执行的代码块
 *  **finally 语句**：指定无论是否发生异常都必须执行的代码块
 *  **自定义异常**：可以创建自定义异常类，以便根据应用程序需求引发和捕获异常。
 *  代码示例：
    
        # 自定义异常类
        class MyCustomError(Exception):
            pass
        
        try:  # 可能会引发异常的代码块
            if some_condition:
                raise MyCustomError("This is a custom error")	# 抛出自定义异常
            result = 10 / 0  # 除以零会引发一个异常
        except MyCustomError as e:  # 处理自定义异常
            print(f"Custom error occurred: {
                e}")
        except ZeroDivisionError as e:
            print(f"Division by zero error: {
                e}")
        except Exception as e:
            print(f"An error occurred: {
                e}")
        else:  # 当没有异常发生时要执行的代码块
            print(f"Result is {
                result}")
        finally:  # 无论是否发生异常都必须执行的代码块
            print("This code always runs")