Python 基础 （三）Python基本语句与基本运算

Python基础文章系列

Python 基础 （一）Python基本认识与环境搭建	Python 基础 （一）Python基本认识与环境搭建
Python 基础 （二）Python变量与基本数据类型	Python 基础 （二）Python变量与基本数据类型
Python 基础 （三）Python基本语句与基本运算	Python 基础 （三）Python基本语句与基本运算
Python 基础 （四）Python函数	Python 基础 （四）Python函数
Python 基础 （五）Python包与模块	Python 基础 （五）Python包与模块
Python 基础 （六）Python的文件模块	Python 基础 （六）Python的文件模块
Python 基础 （七）Python的异常处理机制	Python 基础 （七）Python的异常处理机制
Python 基础 （八）Python的类与对象	Python 基础 （八）Python的类与对象
Python 基础 （九）Python的内置模块	Python 基础 （九）Python的内置模块
Python 基础 （十）Python实现简单的图书管理系统	Python 基础 （十）Python实现简单的图书管理系统

4.2 基本语句

以下是一些Python的基本语句和示例：

1. 赋值语句：

x = 5  # 将5赋值给变量x
name = "Alice"  # 将字符串赋值给变量name

2. 条件语句（if语句）：

if x > 0:
    print("x是正数")
elif x < 0:
    print("x是负数")
else:
    print("x是零")

3. 循环语句（for循环）：

for i in range(5):
    print(i)  # 打印0到4

4. 循环语句（while循环）：

i = 0
while i < 5:
    print(i)  # 打印0到4
    i += 1

5. 函数定义：

def add(a, b):
    return a + b

6. 函数调用：

result = add(3, 4)  # 调用add函数，返回7

7. 列表（List）：

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

8. 字典（Dictionary）：

person = {"name": "Alice", "age": 30}

9. 字符串操作：

greeting = "Hello, World!"
print(greeting[0])  # 打印第一个字符 "H"

下面我们来详细看看一些语句

4.2.1 IF语句

当你需要在程序中根据条件来执行不同的代码块时，你可以使用Python中的if语句。if语句的基本语法如下：

if 条件:
    # 条件成立时执行的代码块
elif 另一个条件:  # 可选
    # 如果第一个条件不成立，且这个条件成立时执行的代码块
else:  # 可选
    # 如果上述条件都不成立时执行的代码块

以下是一个示例，演示了如何使用if语句：

# ---encoding:utf-8---
# @Time    : 2023/9/2 13:16
# @Author  : Darwin_Bossen
# @Email   ：[email protected]
# @Site    :  IF语句
# @File    : IF.py


if __name__ == '__main__':
    age = 25
    if age < 18:
        print("未成年人")
    elif age >= 18 and age < 65:
        print("成年人")
    else:
        print("老年人")

在这个示例中，根据年龄的不同，会打印不同的消息。如果age小于18，将打印"未成年人"；如果age在18到65之间（包括18但不包括65），将打印"成年人"；否则，将打印"老年人"

4.2.2 For循环

for循环是在Python中用于迭代（遍历）序列或可迭代对象的重要工具。它的基本语法如下：

for 变量 in 序列或可迭代对象:
    # 在每次迭代中执行的代码块

这里的"变量"是一个临时变量，它在每次迭代中都会取序列或可迭代对象中的下一个值。循环将继续，直到序列中没有更多的元素可供迭代为止。

# ---encoding:utf-8---
# @Time    : 2023/9/2 13:20
# @Author  : Darwin_Bossen
# @Email   ：[email protected]
# @Site    : for循环
# @File    : FOR.py
if __name__ == '__main__':
    # for循环
    for i in range(1, 10):
        for j in range(1, i + 1):
            print('%d*%d=%d' % (j, i, i * j), end='\t')
        print()
            
    fruits = ["apple", "banana", "cherry"]
    for fruit in fruits:
        print(fruit)
    
    for x in "banana":
        print(x)
    
    for x in range(6):
        print(x)    

以下是一些示例，演示了如何使用for循环：

1. 迭代列表（List）中的元素：

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

2. 迭代字符串中的字符：

word = "Python"
for letter in word:
    print(letter)

3. 使用range()函数创建一系列数字并进行迭代：

for i in range(5):  # 从0到4的数字
    print(i)

4. 迭代字典（Dictionary）的键和值：

person = {"name": "Alice", "age": 30, "country": "USA"}
for key, value in person.items():
    print(key, ":", value)

5. 迭代集合（Set）中的元素：

colors = {"red", "green", "blue"}
for color in colors:
    print(color)

for循环是Python中常用的控制结构之一，它允许你有效地遍历各种数据结构和序列。你可以根据具体的需求来使用for循环。

4.2.3 While

while循环是Python中的一种迭代结构，它在满足特定条件的情况下重复执行一段代码块。循环会一直执行，直到条件不再满足为止。以下是while循环的基本语法：

while 条件:
    # 当条件为真时执行的代码块

在每次循环迭代时，程序会检查条件是否为真。只要条件为真，循环就会继续执行。一旦条件变为假，循环就会停止执行。

# ---encoding:utf-8---
# @Time    : 2023/9/2 13:26
# @Author  : Darwin_Bossen
# @Email   ：[email protected]
# @Site    : While 循环
# @File    : WHILE.py

if __name__ == '__main__':
    count = 0
    while count < 5:
        print(count, "小于5")
        count += 1
    else:
        print(count, "大于或等于5")

print("----------分割线----------")

以下是一个示例，演示了如何使用while循环：

count = 0

while count < 5:
    print("当前计数:", count)
    count += 1

在这个示例中，循环会持续执行，直到count的值不再小于5。每次迭代中，会打印当前的计数值，并将count增加1。一旦count达到5，循环就会终止。
需要谨慎使用while循环，因为如果条件永远不为假，循环可能会无限循环，导致程序停止响应。确保在循环内部有适当的逻辑来改变条件，以便在适当的时候退出循环。

4.2.4 Pass语句

pass语句是Python中的一个特殊语句，它是一个空操作，用于在语法上需要代码块但不需要执行任何操作的情况下。通常，pass语句用作占位符，以保持代码的结构完整，或者在编写代码时暂时跳过某个部分。

# ---encoding:utf-8---
# @Time    : 2023/9/2 13:28
# @Author  : Darwin_Bossen
# @Email   ：[email protected]
# @Site    : PASS语句
# @File    : PASS.py

if __name__ == '__main__':
    for letter in 'Python':
        if letter == 'h':
            pass
            print('这是pass块')
        print('当前字母：', letter)

    print('Good Bye')

以下是一些使用pass语句的示例场景：

1. 函数或类的占位符：

def my_function():
    pass  # 暂时没有实现任何功能

class MyEmptyClass:
    pass  # 空的类，稍后可以添加成员

2. 循环中的占位符：

for i in range(5):
    pass  # 暂时不执行任何操作，保持循环结构

3. 条件语句的占位符：

if condition:
    pass  # 暂时没有条件的处理

pass语句的主要作用是在代码的特定位置保持结构完整，同时允许你将注意力集中在其他部分的实现上。在开发过程中，你可以使用它来标记未来需要实现的部分，以防止因缺少代码而导致语法错误。
需要注意的是，虽然pass语句本身不执行任何操作，但它在语法上是有效的Python代码，不会引发错误。

4.3 基本运算

4.3.1 数学运算

Python支持各种基本数学运算，包括加法、减法、乘法、除法、取余数等。以下是Python中常见的基本运算示例：

1. 加法：

x = 5
y = 3
result = x + y  # 结果是8

2. 减法：

x = 5
y = 3
result = x - y  # 结果是2

3. 乘法：

x = 5
y = 3
result = x * y  # 结果是15

4. 除法：

x = 6
y = 2
result = x / y  # 结果是3.0（在Python 3中，整数除法会返回浮点数）

5. 取整除法：

x = 6
y = 2
result = x // y  # 结果是3（返回整数部分）

6. 取余数：

x = 7
y = 3
result = x % y  # 结果是1

7. 幂运算：

x = 2
y = 3
result = x ** y  # 结果是8

8. 绝对值：

x = -5
result = abs(x)  # 结果是5

9. 四舍五入：

x = 3.7
result = round(x)  # 结果是4

10. 比较运算（返回布尔值）：

x = 5
y = 3
greater = x > y  # 结果是True
less_equal = x <= y  # 结果是False
equal = x == y  # 结果是False

这些是Python中一些常见的基本数学运算。你可以根据需要使用这些运算符来执行各种数学计算。如果需要更多复杂的数学操作，还可以使用Python的数学库，如math来扩展功能。

4.3.2 赋值运算

赋值运算用于将值赋给变量，使变量持有特定的值。Python支持多种不同的赋值运算符，以下是常见的赋值运算符示例：

1. 等号（=）赋值：

x = 5  # 将5赋值给变量x

2. 加等于（+=）赋值：

x = 5
x += 3  # 等同于 x = x + 3，将x的值增加3，x现在等于8

3. 减等于（-=）赋值：

x = 5
x -= 2  # 等同于 x = x - 2，将x的值减少2，x现在等于3

4. 乘等于（=）赋值：** **

x = 5
x *= 4  # 等同于 x = x * 4，将x的值乘以4，x现在等于20

5. 除等于（/=）赋值：

x = 10
x /= 2  # 等同于 x = x / 2，将x的值除以2，x现在等于5.0（在Python 3中，除法通常返回浮点数）

6. 取整除等于（//=）赋值：

x = 10
x //= 3  # 等同于 x = x // 3，将x的值取整除以3，x现在等于3

7. 取余等于（%=）赋值：

x = 10
x %= 3  # 等同于 x = x % 3，将x的值对3取余，x现在等于1

8. 幂等于（=）赋值：**

x = 2
x **= 3  # 等同于 x = x ** 3，将x的值做幂运算，x现在等于8

4.3.3 比较运算

比较运算用于比较两个值或表达式，通常返回布尔值（True或False）。Python支持一系列比较运算符，以下是常见的比较运算符以及示例：

1. 等于（==）：

x = 5
y = 5
result = x == y  # 结果是True，因为x和y相等

2. 不等于（!=）：

x = 5
y = 3
result = x != y  # 结果是True，因为x不等于y

3. 大于（>）：

x = 5
y = 3
result = x > y  # 结果是True，因为x大于y

4. 小于（<）：

x = 5
y = 8
result = x < y  # 结果是True，因为x小于y

5. 大于等于（>=）：

x = 5
y = 5
result = x >= y  # 结果是True，因为x大于或等于y

6. 小于等于（<=）：

x = 5
y = 8
result = x <= y  # 结果是True，因为x小于或等于y

这些比较运算符用于比较两个值或表达式，生成一个布尔值结果，指示比较的结果。你可以在条件语句（如if语句）中使用这些运算符，以根据不同的条件执行不同的代码块。
请注意，比较运算的结果是布尔值（True或False），用于确定两个值之间的关系。这些运算符在控制流和条件判断中非常有用。

4.3.4 逻辑运算

逻辑运算用于处理布尔值（True和False）并生成新的布尔值结果。Python支持三种主要的逻辑运算：与（and）、或（or）和非（not）。以下是这些逻辑运算的详细说明和示例：

1. 与运算（and）：
   • 如果所有操作数都为True，结果为True；否则，结果为False。

x = True
y = False
result = x and y  # 结果是False，因为其中一个操作数是False

2. 或运算（or）：
   • 如果至少有一个操作数为True，结果为True；只有所有操作数都为False时，结果为False。

x = True
y = False
result = x or y  # 结果是True，因为其中一个操作数是True

3. 非运算（not）：
   • 对单个操作数进行取反操作，将True变为False，将False变为True。

x = True
result = not x  # 结果是False，因为对True取反

这些逻辑运算符通常在条件语句中使用，以便根据不同的条件执行不同的代码块。它们也在布尔代数中有广泛的应用，用于组合和操作布尔值。
你还可以将多个逻辑运算组合在一起，以构建更复杂的逻辑条件。例如，你可以使用括号来明确运算的优先级。以下是一个示例：

x = True
y = False
z = True
result = (x or y) and (not z)  # 结果是False，因为(x or y)为True，但 (not z) 为False

逻辑运算在编程中用于控制流程、筛选数据和实现条件逻辑，是编程中非常重要的一部分。

4.3.5 位移运算

位移运算是对二进制数进行位级别的移动操作，分为左移（<<）和右移（>>）两种。这些运算对整数的二进制表示进行操作，将二进制位向左或向右移动指定的位数，并且在移动过程中填充0或截断。

1. 左移运算（<<）：
   • 将一个整数的二进制表示向左移动指定的位数，右侧用0填充。

x = 5  # 二进制表示为 101
result = x << 2  # 左移2位，结果是20（二进制表示为 10100）

2. 右移运算（>>）：
   • 将一个整数的二进制表示向右移动指定的位数，左侧用原来的最高位填充（正数用0，负数用1）。

x = 20  # 二进制表示为 10100
result = x >> 2  # 右移2位，结果是5（二进制表示为 101）

位移运算通常用于对整数进行高效的乘法和除法操作，特别是在嵌入式系统和底层编程中。左移运算相当于将一个整数乘以2的幂次方，而右移运算相当于将一个整数除以2的幂次方。
需要注意的是，位移运算只能应用于整数，不适用于浮点数。此外，在进行右移运算时，符号位（最高位）的处理方式可能因整数的正负而不同。

4.3.6 运算父优先级

在Python中，运算符具有不同的优先级，它们会影响表达式中运算的执行顺序。以下是一些常见运算符按优先级从高到低的顺序：

1. 括号： ()，括号用于强制指定运算的顺序，具有最高的优先级。
2. 指数运算： **，例如，2 ** 3表示2的3次方。
3. 正负号： + 和 -，用于表示正数和负数。
4. 乘法、除法、取整除和取余： *、/、//、%，这些运算符具有相同的优先级，按从左到右的顺序计算。
5. 加法和减法： + 和 -，这些运算符也具有相同的优先级，按从左到右的顺序计算。
6. 位运算： <<、>>、&、|、^，位运算符按照它们的运算符号顺序计算，具有较低的优先级。
7. 比较运算： ==、!=、<、<=、>、>=、is、is not，比较运算符按从左到右的顺序计算，具有较低的优先级。
8. 成员运算： in 和 not in，用于检查元素是否在容器中，具有较低的优先级。
9. 逻辑运算： not、and、or，逻辑运算符按照它们的运算符号顺序计算，具有较低的优先级。

注意，优先级较高的运算符在表达式中会优先执行。如果你不确定某个表达式的运算顺序，可以使用括号来明确指定优先级。例如，(2 + 3) * 4确保了加法运算在乘法之前执行。
这个优先级列表可以帮助你理解Python中运算符的执行顺序，但在复杂的表达式中，建议使用括号来明确指定运算的顺序，以避免歧义。

4.3.7 推导式

Python推导式是一种简洁的语法结构，用于创建列表、集合和字典等数据结构。推导式是Python编程的一个重要概念，可能对你有帮助。

# ---encoding:utf-8---
# @Time    : 2023/9/2 14:33
# @Author  : Darwin_Bossen
# @Email   ：[email protected]
# @Site    :  Python 推导式
# @File    : Comprehensions.py

if __name__ == '__main__':
    #列表推导式
    list1 = [i for i in range(1, 10)]
    # 循环打印
    for item in list1:
        print(item)
    #集合推导式
    set1 = {i for i in range(1, 10)}
    # 循环打印
    for item in set1:
        print(item)
    #字典推导式
    dict1 = {i: i + 1 for i in range(1, 10)}
    # 循环打印
    for item in dict1:
        print(item)
    #生成器推导式
    gen1 = (i for i in range(1, 10))
    # 循环打印
    for item in gen1:
        print(item)

以下是Python中常见的推导式类型：

1. 列表推导式（List Comprehensions）：
   列表推导式用于创建新的列表，通过对现有的列表或可迭代对象中的元素进行处理。示例：

numbers = [1, 2, 3, 4, 5]
squared_numbers = [x**2 for x in numbers]

2. 集合推导式（Set Comprehensions）：
   集合推导式类似于列表推导式，但创建的是集合。它们用花括号 {} 表示。示例：

numbers = [1, 2, 2, 3, 3, 4, 5]
unique_numbers = {x for x in numbers}

3. 字典推导式（Dictionary Comprehensions）：
   字典推导式用于创建新的字典。它们允许你通过处理现有字典的键值对来生成新的字典。示例：

names = {'Alice': 25, 'Bob': 30, 'Charlie': 35}
age_squared = {name: age**2 for name, age in names.items()}

这些推导式是Python中常用的高效编程工具，可以帮助你简化代码，提高可读性。

4.3.8 迭代器

• 迭代器是一个可以记住遍历的位置的对象。
• 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
• 迭代器有两个基本的方法：iter() 和 next()。

迭代器（Iterator）是 Python 中用于遍历可迭代对象的机制。虽然您的用户资料显示您是Java代码辅助开发，但我可以为您提供有关Python迭代器的信息。
在Python中，迭代器通常用于遍历诸如列表（lists）、元组（tuples）、字典（dictionaries）等可迭代对象的元素。以下是迭代器的基本概念和使用方法：

1. 可迭代对象（Iterable）：任何实现了__iter__()方法的对象都被称为可迭代对象。可迭代对象可以通过iter()函数来获得一个迭代器。
2. 迭代器对象（Iterator）：迭代器是一个具有__next__()方法的对象，它用于逐个返回可迭代对象中的元素。当没有元素可供返回时，迭代器会引发StopIteration异常。

下面是一个简单的示例，演示如何创建和使用迭代器：

# ---encoding:utf-8---
# @Time    : 2023/9/2 14:39
# @Author  : Darwin_Bossen
# @Email   ：[email protected]
# @Site    : 迭代器
# @File    : IterNext.py

if __name__ == '__main__':
    # 创建一个可迭代对象
    my_list = [1, 2, 3, 4, 5]
    # 获取一个迭代器
    my_iter = iter(my_list)
    # 使用迭代器遍历元素
    try:
        while True:
            element = next(my_iter)
            print(element)
    except StopIteration:
        pass

在这个示例中，我们首先将一个列表转换为可迭代对象，然后使用iter()函数获取了一个迭代器。接着，我们使用next()函数逐个访问列表中的元素，直到触发StopIteration异常表示没有更多元素可供遍历。
迭代器是Python中强大而灵活的工具，用于处理大型数据集合和生成数据流。

4.3.9 生成器

生成器（Generator）是 Python 中一种强大的迭代器，允许您按需生成数据，而不需要一次性将所有数据存储在内存中。
生成器的主要特点是您可以使用函数来定义生成器，而不必一次性生成所有数据。生成器函数使用yield关键字来产生值，并在每次生成时保留函数的状态，以便在下次生成时继续执行。这使得生成器非常适合处理大型数据集或需要逐个生成数据的情况。
下面是一个简单的生成器函数示例：

def simple_generator():
    yield 1
    yield 2
    yield 3

# 创建生成器对象
my_generator = simple_generator()

# 使用生成器逐个生成值
print(next(my_generator))  # 输出 1
print(next(my_generator))  # 输出 2
print(next(my_generator))  # 输出 3

# 如果再次调用next会引发StopIteration异常

在这个示例中，simple_generator 是一个生成器函数，它通过使用yield关键字来生成值。当我们创建生成器对象my_generator并调用next()函数时，生成器会从上一次yield语句的位置开始执行，并在下一次调用next()时继续执行，直到没有更多的值可生成，此时会引发StopIteration异常。
生成器在处理大型数据集时非常有用，因为它们不会一次性加载所有数据，而是逐个生成，节省了内存空间。您可以在循环中使用生成器，处理文件逐行读取，或者执行任何需要逐个生成数据的操作。