1. 变量

1.1 变量及其赋值

在编程时经常要处理数据，如数字、字符串等，既可以直接使用这些数据，也可以把数据保存在变量中，以方便以后使用。

变量（variable）

存放数据值的容器。数据是存放在内存中的，变量相当于这块内存的名字。变量名用标识符表示。

标识符（identifier)

编程时使用的名字，用于给变量、常量、函数、语句块等命名，以建立起名称与使用之间的关系。

1.1 变量及其赋值

在 Python 中，通过直接赋值即可创建各种类型的变量（Python 是动态类型语言，不像其他静态类型语言那样需要预先显式声明变量名及其类型），使用等号 = 给变量赋值

            x = 33  # x 是一个整型变量
            print(x, type(x))  # 33 <class 'int'>

            url = "https://zimo.net/aqmn/"  # url 是一个字符串变量
            print(url, type(url))  # https://zimo.net/aqmn/ <class 'str'>

            is_ready = True
            print(is_ready, type(is_ready))  # True <class 'bool'>
        

上例中，type() 是内置的函数，用于返回变量类型。

1.1 变量及其赋值

一个变量可以被重新赋予不同类型的值（动态类型语言的特点）：

            x = 33  # x 是一个整型变量
            x = False  # x 现在变为一个布尔类型变量
        

可以同时给多个变量赋值：

            # 多变量赋值
            tomato, pumpkin, pepper = '西红柿', '南瓜', '辣椒'
            print(tomato, pumpkin, pepper)  # 西红柿 南瓜 辣椒

            # 链式赋值，三者指向内存中的同一对象
            a = b = c = 33
            print(a, b, c)  # 33 33 33
        

1.1 变量及其赋值

变量值互换：

            x, y = 33, 44

            # 常规方法
            temp = x
            x = y
            y = temp
            print(x, y)

            # 利用多变量赋值快速交换两个变量的值
            x, y = y, x
            print(x, y)
        

1.2 变量的命名

首先，变量名必须是一个合法的标识符，这要求（必须遵守）：

• 只能包含字母（A‐Z 和 a-z）、数字（0-9）和下划线 _；（Python 3.x 中变量名支持统一码 Unicode，因此可以使用更多的字符，如可以包含汉字，但不建议使用汉字）
• 不能以数字开头；
• 不能包含空格；（一般使用下划线来分隔其中的单词）
• 不能使用保留字；（见下页）

注意标识符是区分大小写的，因此 age、Age 和 AGE 是三个不同的标识符。

1.2 变量的命名

保留字在 Python 中也称关键字，是被编程语言内部定义并保留使用的标识符，在编程时不能定义与保留字相同的标识符。目前 Python 中有 35 个保留字：

False      await      else       import     pass
None       break      except     in         raise
True       class      finally    is         return
and        continue   for        lambda     try
as         def        from       nonlocal   while
assert     del        global     not        with
async      elif       if         or         yield

1.2 变量的命名

Python 的变量命名习惯：

• 仅使用 ASCII 字母（A‐Z 和 a-z）、数字（0-9）和下划线 _，不要使用中文，也不要使用拼音；
• 变量名应既简短又具有描述性；
• 不要和作用域内的其他函数（包括 Python 内部函数）重名；
• 使用蛇形命名法（snake_case）：所有单词皆小写，单词之间以下划线 _ 分割。

1.2 变量的命名

请判断下面变量名称是否合法，以及是否符合习惯用法：

2. 基本数据类型

数据类型是可能值和相关操作的集合。在 Python 中，数据以对象的形式出现，数据类型也即对象类型。

Python 内置了多种数据类型，最常使用的有数字（包括整数 int、浮点数 float、复数 complex，等）、字符串 str、布尔 bool、列表 list、元组 tuple、字典 dict 和 集合 set。

在 Python 中，当您为变量赋值时，会同时根据所赋值的类型设置变量的数据类型。

本章仅介绍 Python 的基本数据类型，即数字、字符串和布尔类型。

2.1 数字类型

数字可以用于表示我们班级的总人数，你的考试成绩，你的身高和体重，你一个月的花销，以及其他任何数量值。

存在三种不同的数字类型：整数、浮点数和复数。此外，布尔类型属于整数的子类型。标准库包含附加的数字类型，如表示有理数的分数类型 fractions.Fraction，以及以用户定制精度表示浮点数的小数类型 decimal.Decimal。

数字是由数字字面值或内置函数与运算符的结果来创建的。Python 完全支持混合运算：当一个二元算术运算符的操作数有不同数值类型时，“较窄”类型的操作数会拓宽到另一个操作数的类型，其中整数比浮点数窄，浮点数比复数窄。

2.1 数字类型

字面量（literal）是用于表达源代码中一个固定值的表示法。下表给出了各种数字字面量的表示示例：

构造函数 int()、float() 和 complex() 也可以用来构造特定类型的数字。

2.1 数字类型

整数是没有小数部分的数值。整数包括正整数、负整数和 0。Python 中的整数可表示的大小没有限制，当数值很大时，会自动转用更高精度存储和计算。以下各变量均为整数类型变量：

            import math

            a = 33
            b = 0
            c = -22
            d = 2 ** 8
            e = a * c
            f = int("886")
            g = abs(c)
            h = math.ceil(3.3)
        

注意：除了 0 之外，其他整数在表示时不能以 0 开头，如 033 是不可以的。

2.1 数字类型

默认使用十进制表示整数，但也可以使用二进制、八进制和十六进制表示整数。如下所示：

            n = 44
            n_2 = 0b101100
            n_8 = 0o54
            n_16 = 0x2c
            # 将打印 True True True
            print(n == n_2, n == n_8, n == n_16)
            # 将打印 44 0b101100 0o54 0x2c
            print(n, bin(n), oct(n), hex(n))
        

虽然在编程时可以用各种进制表示整数，但他们在计算机中的表示却是类似的（即都以二进制表示），因此示例中以各种进制给出的整数值都是相等的。内置函数 bin()、oct() 和 hex() 可以把一个整数转换为三种进制表示的字符串。

2.1 数字类型

浮点数是有小数部分的数值。浮点数通常使用 C 语言中的双精度浮点数 double 来实现。浮点数也可以使用科学计数法表示。以下各变量均为浮点数类型变量：

            import math

            a = 3.0
            b = .1415
            c = -2.78e6
            d = 3.14E-2
            f = 3 / 2  # 除法运算总是产生一个浮点数
            g = 2 * a  # 不同类型的二元运算产生的类型总是会被拓宽
            h = float("33")
            i = math.sin(2)  # 该函数的返回类型是浮点数
        

2.1 数字类型

在计算机中，并不能精确地表示浮点数。即便是最简单的数学运算，也可能带来不可控制的后果。

            a = 2.7
            b = 4.5
            print(a - b == -1.8)  # False
            print(a - b)  # -1.7999999999999998
            a = 2.6
            print(a + b)  # 7.1
        

要控制浮点数的精度，可以使用 decimal 模块的 Decimal 类型：

            from decimal import Decimal
            a = Decimal('2.7')
            b = Decimal('4.5')
            print(a - b)  # -1.8
        

2.1 数字类型

复数包含实部和虚部，各以一个浮点数表示，其中虚部以 j 或 J 结尾。要从一个复数 z 中提取这两个部分，可使用 z.real 和 z.imag。以下各变量均为复数类型变量：

            a = 3.3 + 2.7j
            b = -4.5J
            c = a + b
            d = c.real - c.imag*1.0j
            e = a * b
            f = complex(3.3, 2.7)
            g = complex("3.3+2.7j")  # 注意加号两侧不能有空格
        

2.2 字符串类型

字符串是由零个或多个字符组成的有限序列。字符串用于文本信息（如你的姓名）或任意的字节集合（如图片文件的内容）。

（1）字符串字面量

字符串的字面量有多种不同的写法：

• 单引号包围的文字，如 'hello'、'西安科技大学'、'Einstein wrote: "God does not play dice with the universe"'；
• 双引号包围的文字，如 "hello"、"西安科技大学"、"Xi'an"；
• 三重引号：'''三重单引号''' 或 """三重双引号"""。使用三重引号的字符串可以跨越多行，其中所有的空白字符都将包含在该字符串字面值中。见下页示例。

2.2 字符串类型

（1）字符串字面量

三重引号表示的字符串，其中可以包含回车和换行符：

            python = '''
            ______      _   _                 
            | ___ \    | | | |                
            | |_/ /   _| |_| |__   ___  _ __  
            |  __/ | | | __| '_ \ / _ \| '_ \ 
            | |  | |_| | |_| | | | (_) | | | |
            \_|   \__, |\__|_| |_|\___/|_| |_|
                   __/ |                      
                  |___/                       
            '''
            print(python)
        

2.2 字符串类型

（2）字符串序列的操作：获取长度

字符串作为序列，像列表、元组一样，支持一些序列特有的操作，如获取长度、索引、切分和拼接。这些操作对其他序列也适用。

可通过内置的 len() 函数获取字符串的长度（元素个数），该函数同样可用于其他序列和集合类型。如下所示：

            >>> s = 'Hello'
            >>> len(s)
            5
            >>> xust = '西安科技大学'
            >>> len(xust)
            6
        

（2）字符串序列的操作：索引

字符串的每个字符元素都有一个整数类型的数值偏移量，其中第一个字符的偏移量为 0， 第二个为 1，依此类推。可以通过 s[i] 的形式获得字符串 s 中偏移量为 i 的字符所构成的单字符字符串，此即字符串的索引。

此外，Python 的字符串还支持反向索引，即从最后一个字符开始用负整数计数，最后一个字符的索引为 -1，倒数第二个是 -2，依此类推。

（2）字符串序列的操作：索引

            >>> s = 'Hello'
            >>> s[0]
            'H'
            >>> s[1]
            'e'
            >>> s[-1]
            'o'
            >>> s[-2]
            'l'
            >>> s[len(s)-1]
            'o'
            # Python 中没有专门的字符类型，因此字符串的每项索引结果是长度为 1 的字符串
            >>> type(s[0])
            <class 'str'>
        

（2）字符串序列的操作：分片

可以对字符串进行切分操作，得到字符串的一个分片（或称切片），此分片是一个子字符串。

其常规形式是 s[i:j]，表示取得在字符串 s 中从偏移量 i 开始，到偏移量 j 结束（不包括 j）的字符串内容。

也可以省略 i 或 j，省略 i 时，其值默认为 0，省略 j 时，其值默认为字符串的长度 len(s)。

（2）字符串序列的操作：分片

            >>> s = 'Hello'
            >>> s[1:3]  # 获得偏移量 [1, 3) 范围内的切片
            'el'
            >>> s[:3]   # 获得偏移量 [0, 3) 范围内的切片
            'Hel'
            >>> s[1:]   # 获得偏移量 [1, len(s)) 范围内的切片
            'ello'
            >>> s[:]    # 获得偏移量 [0, len(s)) 范围内的切片
            'Hello'
            >>> s[:-1]  # 获得偏移量 [0, len(s)-1) 范围内的切片
            'Hell'
        

（2）字符串序列的操作：拼接

可以使用加号 + 对字符串进行拼接（Concatenation），即将两个字符串合并成一个字符串；也可以使用乘号 * 将字符串重复多次以创建一个新的字符串。

            >>> 'Hello,' + ' world!'
            'Hello, world!'
            >>> '-' * 80
            '--------------------------------------------------------------------------------'
        

在表达式中，之间只由空格分隔的多个字符串字面值会被隐式地拼接为单个字符串字面值。如下所示：

            >>> 'abc' "def"
            'abcdef'
        

2.2 字符串类型

（3）字符串是不可变的

字符串值是不可变的，即在创建后，不能原位改变其内容。以下操作时不允许的：

            >>> s = 'Hello'
            >>> s[1] = 'o'  # 将会出现错误
        

要改变一个字符串变量，必须重新为其赋值。

            >>> s[:4] + ' world!'
            'Hell world!'
        

2.2 字符串类型

（4）转义

字符串中有一些特殊字符，由于不便输入，经常需要以转义（Escape）的形式输入，即用一个反斜杠 \ 后跟一个或多个ASCII 字符表示该字符串。Python 支持如下转义字符：

（4）转义

可以在字符串的左引号前面加一个 r，不让字符串进行转义，这样的字符串称为原始字符串。

字符串转义使用示例：

            s = 'Xi\'an'
            print(s)  # Xi'an
            s = 'Hello, \
            world!'
            print(s)  # Hello, world!
            s = 'Hello, \nworld!'
            # Hello, 
            # world!
            print(s)
            s = 'Hello,\tworld!'
            print(s)  # Hello,  world!
            s = 'Hello,\b\b world!'
            print(s)  # Hell world!

            s = 'a\0b\0c'
            print(len(s))  # 5
            s = 'C:\new\text.txt'
            print(len(s))  # 13
            s = 'C:\\new\\text.txt'
            print(len(s))  # 15
            s = r'C:\new\text.txt'  # 原始字符串
            print(len(s))  # 15

            # 字符 '$' 的 8、16 进制编码分别是 044、24，
            # 因此以下各行的效果是相同的
            s = '$'
            s = '\44'  
            s = '\x24'
            s = '\u0024'
            s = '\U00000024'
            
            # 汉字 '我' 的十六进制编码是 6211，因此以下两行的效果是相同的
            s = '\u6211'
            s = '\U00006211'
        

2.2 字符串类型

（5）将其他对象转换为字符串

Python 设计的座右铭之一是拒绝猜测，如下面将字符串和数字相加，因无法知道执行的是数字加法还是字符串拼接，因此会报错：

            >>> 33 + '44'
            TypeError: unsupported operand type(s) for +: 'int' and 'str'
        

要想执行字符串拼接，可以使用内置函数 str 将数字转换为字符串：

            >>> str(33) + '44'
            '3344'
        

还有另外一个内置函数 repr 也能将对象转换为字符串，但它返回的是可作为代码的字符串对象，请自行学习。

2.2 字符串类型

（6）字符串的方法

Python 有一组可以在字符串上使用的内建方法，即字符串的方法，可以采用如下方式调用字符串的方法：

字符串对象.方法名称(参数列表)

示例如下：

            >>> s = 'Hello, world!'
            >>> s.upper()  # upper() 方法把字符串转换为大写
            'HELLO, WORLD!'
            >>> s.replace('world', '世界')  # 将字符串中出现的所有 'world' 子字符串替换为 '世界'
            'Hello, 世界!'
        

字符串的方法有很多个，请自行查看并了解各个方法的功能。

2.2 字符串类型

（7）字符串格式化

在编程时，经常需要根据数据对象的值动态生成具有复杂格式的文本，这就需要用到字符串格式化。字符串格式化允许在单个步骤中对一个字符串执行多个特定类型的替换。

Python 支持三种形式的字符串格式化：

1. 字符串格式化表达式，形如：'...%s...' % (values)

   从 Python 诞生的时候就有的最初技术，其形式是基于 C 语言的 printf 函数模型。

2. 字符串格式化方法调用，形如：'...{}...'.format(values)

   Python 2.6/3.0 新增的技术，其形式部分起源于 C#/.NET 中的同名工具；其主要使用字符串的 format() 方法进行格式化。

（7）字符串格式化

3. 格式字符串字面值，形如：f'...{value}...'

   又称 f-string，这是 Python 3.6 新增的技术。相对于前两者，其更简单和直观，效率也更高。

这三种字符串格式化方法提供的功能都比较相似，尤其是后两者。他们都可以提供复杂的格式化功能，需要花较多的功夫学习掌握。限于篇幅，这里只在下页中对三种方法给出一个简单的例子，然后再简要地介绍第三种 f-string 的用法。

要更深入地了解 f-string 方法，请先阅读这个简单的教程，再进一步阅读器参考手册，最好根据需要阅读此格式规格迷你语言。

（7）字符串格式化

三种字符串格式化方法示例：

            student = '小明'
            course = '高等数学'
            score = 92.3
            
            # 字符串格式化表达式
            s = '%s 的 %s 考了 %.1f 分。' % (student, course, score)
            print(s)
            # 字符串格式化方法调用
            s = '{} 的 {} 考了 {:.1f} 分。'.format(student, course, score)
            print(s)
            # 格式字符串字面值（f-string）
            s = f'{student} 的 {course} 考了 {score:.1f} 分。'
            print(s)
            # 均打印：小明 的 高等数学 考了 92.3 分。
        

（7）字符串格式化

要使用 f-string 方法，需要在字符串开头的引号/三引号前添加 f 或 F，然后在字符串中用 {expression} 表示将要被替换的表达式，之后该大括号内的表达式将被求值，并将该值转换而成的字符串替换大括号位置。如下所示：

            year = 2022
            place = '四川泸定县'
            event = '地震'
            s = f'{year}年，在{place}发生了一次{event}。'
            print(s)  # 2022年，在四川泸定县发生了一次地震。
        

f-string 是在运行时被求值的，你可以在其中放入任意有效的表达式：

            print(f'{2 + 2 * 4}')  # 10
            print(f'{abs(-33)}')   # 33
        

（7）字符串格式化

可以为表达式指定格式，这通过在表达式后加一个冒号 :，然后附加格式规格实现。如下所示：

            import math
            print(f'π 的值为：{math.pi:.3f}。')

            scores = {'Zhang-San': 76.5, 'Li-Si': 83.0, 'Wang-Laowu': 66.8}
            for name, score in scores.items():
                print(f'{name:>10} ==> {score:6.1f}分')
            #  Zhang-San ==>   76.5分
            #      Li-Si ==>   83.0分
            # Wang-Laowu ==>   66.8分
        

以上 {math.pi:.3f} 中的 f 表示以十进制浮点数呈现对象，.3 表示小数点后保留三个数字。{name:>10} 中的 10 表示强制该项占据 10 个字符的宽度（不足部分补空格），> 表示右对齐（字符串默认为左对齐）。{score:6.1f} 中的 6 表示强制该项占据 6 个字符的宽度，.1f 表示以十进制浮点数呈现对象，且小数点后保留 1 位。

（7）字符串格式化

更多格式规格示例：

            x = -0.0314
            print(f'{x:e}')  # 以科学记数法显示浮点数，以小写 e 分割系数和指数
            print(f'{x:E}')  # 以科学记数法显示浮点数，以大写 E 分割系数和指数
            print(f'{x:.2%}')  # 以百分数形式显示浮点数，且小数点后保留 2 位
            
            n = 66
            print(f'{n:b}')  # 以二进制格式显示整数
            print(f'{n:0>9_b}')  # 以二进制格式显示整数，总宽度为 9，不足部分补 0，右对齐，每 4 位用下划线分割
            print(f'{n:+d}')  # 以十进制格式显示整数，总是在其前方加正号或负号
        

请自行运行示例查看显示结果。更详细的格式语法，请参见格式规格迷你语言。

2.3 布尔类型

布尔是计算机科学中的逻辑数据类型，以发明布尔代数的数学家乔治·布尔为名。它是只有两种值的原始类型，通常是真和假。在 Python 中，他们对应两个字面量，分别是 True 和 False（注意首字母必须为大写）。

比较运算、逻辑运算会产生布尔类型值，Python 的 if 语句和 while 语句都需要一个布尔类型的表达式作为控制语句流向的判别式。如下所示：

            n = int(input('请输入一个数字：'))
            b = n > 50  # n 是一个布尔类型值
            if b:
                print('你输入的数字', n, '大于 50。')
            else:
                print('你输入的数字', n, '小于 50。')	
        

2.3 布尔类型

在 Python 中，可以把所有对象用在需要布尔值的场合，只有下面的几种情况得到的值为假：

• 被定义为假值的常量: None 和 False。

• 任何数值类型的零: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)

• 空的序列和多项集: '', (), [], {}, set(), range(0)

示例如下：

            n = int(input('请输入一个数字：'))
            if n:
                print('你输入的数字不为零。')
            else:
                print('你输入的数字为零。')	
        

2.3 布尔类型

前面说过，布尔类型属于整数的子类型，这表示你可以把布尔类型值用在需要数字的场合进行数值计算，这时 True 代表 1，False 代表 0。如下所示

            >>> False + 2
            2
            >>> True + 2
            3
        

3.1 算术运算符

算术运算符是处理四则运算的符号，在数字的处理中应用得最多。

3.1 算术运算符

示例：已知一个三角形三边的长度分别为 a = 3.3, b = 6.2, c = 4.2，求该三角形的面积 S。

根据三边长求三角形面积的公式为：

$$p=\frac{a+b+c}{2}$$

$$S=\sqrt{p\left( p-a \right) \left( p-b \right) \left( p-c \right)}$$

            a = 3.3
            b = 6.2
            c = 4.2
            p = (a + b + c) / 2
            s = (p*(p-a)*(p-b)*(p-c)) ** 0.5
            print(s)  # 6.472008478826334
        

3.2 赋值运算符

赋值运算符主要用来为变量等赋值。除了 = 外，Python 还支持像 +=、-= 这样的复合赋值运算符。

3.3 比较（关系）运算符

比较运算符，也称关系运算符，用于对变量或表达式的结果大小、真假等进行比较。如果比较结果为真，则返回 True；如果为假，则返回 False。比较运算符通常用在 if 和 while 语句中作为判定语句流流向的依据。

3.3 比较（关系）运算符

Python 支持链式比较，相当于拆分多个逻辑表达式，再进行逻辑与操作。如下所示：

            print(1 < 2 < 3)  # True
            # 相当于
            print(1 < 2 and 2 < 3)  # True
            
            x = 8
            print(0 < x <= 10)  # True
            # 相当于
            print(x > 0 and x <= 10)  # True
        

3.4 逻辑运算符

逻辑运算符是对真或假两种布尔值进行运算，运算的结果仍是一个布尔值。

3.4 逻辑运算符

示例：某软件开发公司要招聘一名程序员，其职位要求如下：

• 具备三年及以上工作经验，或者应届本科毕业，且平均成绩在 75 分及以上；
• 掌握 Python 语言；
• 主导开发过任何语言编写的较知名开源项目的，可直接参与面试。

以下代码描述了某个面试者的基本条件，其中各个变量的意义可以从变量名称直接看出，请进一步完成程序设计，判断该面试者是否能获得面试资格。

3.4 逻辑运算符

某面试者的条件：

            service_years = 0
            is_fresh_graduate = True
            avg_score = 75.7
            is_python_programmer = True
            is_opensource_owner = False
        

答案：

            has_interview_qualification = ((service_years >= 3 
                or (is_fresh_graduate and avg_score >= 75)) 
                and is_python_programmer) or is_opensource_owner
        
            print(has_interview_qualification)  # True
        

3.5 位运算符 >> 选学

位运算符是把数字看作二进制数来进行计算的，因此，需要先把要执行运算的数据转换为二进制，然后才能执行运算。

Python 中的位运算符有位与（&）、位或（|）、位异或（^）、取反（~）、左移位（<<）和右移位（>>）。

3.5 位运算符 >> 选学

（1）位与运算

位与运算的运算符为 &，其运算规则是：两个操作数的二进制表示，只有对应数位都是 1 时，结果数位才是 1，否则为 0。如果两个操作数的精度不同，则结果的精度与精度高的操作数相同。

            #   0010_1100
            # & 0011_1010
            # = 0010_1000
        

3.5 位运算符 >> 选学

（2）位或运算

位或运算的运算符为 |，其运算规则是：两个操作数的二进制表示，只有对应数位都是 0 时，结果数位才是 0，否则为 1。如果两个操作数的精度不同，则结果的精度与精度高的操作数相同。

            #   0010_1100
            # | 0011_1010
            # = 0011_1110
        

3.5 位运算符 >> 选学

（3）位异或运算

位异或运算的运算符为 ^，其运算规则是：两个操作数的二进制表示相同时（同时为 0 或同时为 1），结果数位才是 0，否则为 1。如果两个操作数的精度不同，则结果的精度与精度高的操作数相同。

            #   0010_1100
            # ^ 0011_1010
            # = 0001_0110
        

3.5 位运算符 >> 选学

（3）位取反运算

位取反运算也称位非运算，其运算符为 ~，运算规则是：将操作数中对应的二进制数 1 修改为 0，0 修改为 1。

            # ~ 00101100
            # = 11010011
        

3.5 位运算符 >> 选学

（4）左移位运算

左移位运算的运算符为 <<，该运算将一个二进制操作数向左移动指定的位数，左边（高位端）溢出的位被丢弃，右边（低位端）的空位用 0 补充。左移 n 位运算相当于乘以 2 的 n 次幂。

            #   0010_1100 << 1
            # = 0101_1000
            # 
            #   0010_1100 << 2
            # = 1011_0000            
        

3.5 位运算符 >> 选学

（5）右移位运算

右移位运算的运算符为 >>，该运算将一个二进制操作数向右移动指定的位数，右边（低位端）溢出的位被丢弃，而在填空左边（高位端）的空位时，如果最高位是 0（正数），左侧空位填入 0；如果最高位是 1（负数），左侧空位填入 1。右移 n 位运算相当于除以 2 的 n 次幂。

            #   0010_1100 >> 1
            # = 0001_0110
            #
            #   0010_1100 >> 2
            # = 0000_1011
            
            #   1101_1010 >> 1
            # = 1110_1101
        

3.6 运算符的优先级

请先回答表达式 2 + 2 * 4 的计算结果！

——答案不是 16，而是 10。这是因为数学的四则运算应遵循先乘除，后加减的规则。

在 Python 中，各种运算符也有不同的优先级，其运算规则为：

优先级高的运算先执行，优先级低的运算后执行，同一优先级的操作按照从左到右的顺序进行。也可以像四则运算那样使用小括号，括号内的运算最先执行。

以下两页表按照优先级从高到低的顺序列出了各运算符的优先级，同一行中的运算符具有相同的优先级。

3.6 运算符的优先级

3.6 运算符的优先级

作业

1. 力学中，在平面应力状态下，有两个主应力 $\left( {{\sigma _1},{\sigma _3}} \right)$ 作用在某一点上，则最大主应力 ${\sigma _1}$ 与外法线成 ${\alpha}$ 角的斜切面上法向应力 ${\sigma _\alpha}$ 和剪应力 ${\tau_\alpha}$ 的表达式为：

   $$\left. \begin{array}{l} {\sigma _\alpha } = \frac{{{\sigma _1} + {\sigma _3}}}{2} + \frac{{{\sigma _1} - {\sigma _3}}}{2}\cos 2\alpha \\ {\tau _\alpha } = \frac{{{\sigma _1} - {\sigma _3}}}{2}\sin 2\alpha \end{array} \right\}$$

   现已知某点处 ${\sigma _1} = 27.3 \times 10^6$ Pa, ${\sigma _3} = 10.7 \times 10^6$Pa，分别求 ${\alpha}$ = 48° 的斜切面上的法向应力 ${\sigma _\alpha}$ 和剪应力 ${\tau_\alpha}$。

   提示：该题比较复杂，你需要导入 math 模块（import math）以利用其中的常量值 pi 和三角函数，注意计算时应将角度转换为弧度。请自己设定合适的变量名称。

作业

2. 某学院的保送硕士研究生筛选条件是：① 通过英语六级考试，② 总成绩平均分不低于 80 分，③ 班级总评排名在前 7 名内，或至少获得过一次国家特等或一等奖学金。已知某同学通过了英语六级考试，总成绩平均分为 83.2 分，班级总评排名为第 9 名，获得过一次国家一等奖学金，请编程分析该同学是否具备保研资格。
   （请自行设定合适的变量名称）
3. 字符串 '好用的\nVS Cod\x65' 包含多少个字符？并解释其原因。
4. 从字符串 '借问酒家何处有？牧童遥指杏花村。' 中切分出 '借问' 和 '牧童' 两个分片，并将他们拼接为一个新的字符串。
5. 请在字符串的方法中找出一个方法，判断 'the quick brown fox jumps over a lazy dog' 中是否包含有 'jum' 子字符串。
6. 使用字符串格式化，在屏幕上打印自然对数函数的底数 math.e，要求小数点后保留 4 个小数位，总体占据 10 个字符的宽度，强制在数字前面加上 +/- 号。

作业

要求：

1. 将本章全部作业放在一个 安模作业02-02-学号-姓名.py 的源文件中，通过电子邮件以附件形式发给任课教师。
2. 在源文件中以注释的形式醒目地写明本次作业对应的章编号、各个作业题的编号，并按要求写出解题思路、代码注释。
3. 以上各题不能只有文字说明，而应同时有可执行的示例代码。
4. 邮件标题统一用 安模作业02-02-学号-姓名 的形式。
5. 所有关于作业的回答都以代码注释的形式写在源文件中，不需要再额外附加其他文档或图片，请保证代码执行不会发生错误。
6. 待本次作业批改后，请通过此链接下载本次作业的参考答案。