Python 基础知识：语法、数据类型和控制结构

推荐：使用NSDT场景编辑器快速搭建3D应用场景

如果开发和环境中已安装 Python，请启动 Python REPL 和代码。或者，如果您想跳过安装并立即开始编码，我建议您前往Google Colab并一起编码。

在我们用Python编写经典的“Hello，world！”程序之前，这里有一些关于语言的信息。Python是一种解释型语言。这是什么意思？

在任何编程语言中，您编写的所有源代码都应翻译成机器语言。虽然像C和C++这样的编译语言在程序运行之前需要整个机器代码，但解释器会解析源代码并动态解释它。

创建一个 Python 脚本，键入以下代码并运行它：

print("Hello, World!")

为了打印出Hello， World！，我们使用了“print（）”函数，这是Python中众多内置函数之一。

在这个超级简单的示例中，请注意“Hello， World！”是一个序列 - 一串字符。Python 字符串由一对单引号或双引号分隔。因此，要打印出任何消息字符串，您可以使用“print（”<message_string>“）”。

现在让我们更进一步，使用 'input（）' 函数读取用户的一些输入。应始终提示用户让他们知道应输入的内容。

这是一个简单的程序，它将用户名作为输入并问候他们。

注释通过向用户提供其他上下文来帮助提高代码的可读性。Python 中的单行注释以 # 开头。

请注意，下面代码片段中的字符串前面有一个“f”。此类字符串称为格式化字符串或 f 字符串。若要替换 f 字符串中变量的值，请在一对大括号内指定变量的名称，如下所示：

# Get user input
user_name = input("Please enter your name: ")

# Greet the user
print(f"Hello, {user_name}! Nice to meet you!")

运行程序时，系统将首先提示您输入，然后打印出问候消息：

Please enter your name: Bala
Hello, Bala! Nice to meet you!

让我们继续学习 Python 中的变量和数据类型。

在任何编程语言中，变量都像存储信息的容器。在我们到目前为止编写的代码中，我们已经创建了一个变量 'user_name'。当用户输入其名称（字符串）时，它将存储在“user_name”变量中。

让我们来看看 Python 中的基本数据类型：“int”、“float”、“str”和“bool”，使用相互构建的简单示例：

整数（'int'）：整数是没有小数点的整数。您可以创建整数并将它们分配给变量，如下所示：

age = 25
discount= 10

这些是将值赋给变量的赋值语句。在 C 等语言中，声明变量时必须指定数据类型，但 Python 是一种动态类型语言。它从值推断数据类型。因此，您可以重新分配一个变量来保存完全不同的数据类型的值：

number = 1
number = 'one'

您可以使用“type”函数检查Python中任何变量的数据类型：

number = 1
print(type(number))

“数字”是一个整数：

Output >>> <class 'int'>

我们现在为“数字”分配一个字符串值：

number = 'one'
print(type(number))

Output >>> <class 'str'>

浮点数（“float”）：浮点数表示带有小数点的实数。您可以创建“float”数据类型的变量，如下所示：

height = 5.8
pi = 3.14159

您可以对数值数据类型执行各种运算（加法、减法、下限除法、幂等）。以下是一些示例：

# Define numeric variables
x = 10
y = 5

# Addition
add_result = x + y
print("Addition:", add_result)  # Output: 15

# Subtraction
sub_result = x - y
print("Subtraction:", sub_result)  # Output: 5

# Multiplication
mul_result = x * y
print("Multiplication:", mul_result)  # Output: 50

# Division (floating-point result)
div_result = x / y
print("Division:", div_result)  # Output: 2.0

# Integer Division (floor division)
int_div_result = x // y
print("Integer Division:", int_div_result)  # Output: 2

# Modulo (remainder of division)
mod_result = x % y
print("Modulo:", mod_result)  # Output: 0

# Exponentiation
exp_result = x ** y
print("Exponentiation:", exp_result)  # Output: 100000

字符串（'str'）：字符串是字符序列，括在单引号或双引号中。

name = "Alice"
quote = 'Hello, world!'

布尔值（“bool”）：布尔值表示“真”或“假”，表示条件的真值。

is_student = True
has_license = False

Python 在处理不同数据类型方面的灵活性使您可以有效地存储、执行各种操作和操作数据。

下面是一个示例，将我们迄今为止学到的所有数据类型放在一起：

# Using different data types together
age = 30
score = 89.5
name = "Bob"
is_student = True

# Checking if score is above passing threshold
passing_threshold = 60.0
is_passing = score >= passing_threshold

print(f"{name=}")
print(f"{age=}")
print(f"{is_student=}")
print(f"{score=}")
print(f"{is_passing=}")

这是输出：

Output >>>

name='Bob'
age=30
is_student=True
score=89.5
is_passing=True

假设您正在管理课堂上有关学生的信息。创建一个集合（存储所有学生的信息）会比为每个学生重复定义变量更有帮助。

列表是项的有序集合，括在一对方括号内。列表中的项都可以是相同或不同的数据类型。列表是可变的，这意味着您可以在创建后更改其内容。

在这里，“student_names”包含学生的姓名：

# List
student_names = ["Alice", "Bob", "Charlie", "David"]

元组是类似于列表的有序集合，但它们是不可变的，这意味着您在创建后无法更改其内容。

假设您希望“student_scores”成为包含学生考试成绩的不可变集合。

# Tuple
student_scores = (85, 92, 78, 88)

字典是键值对的集合。字典的键应该是唯一的，并且它们映射到相应的值。它们是可变的，允许您将信息与特定键相关联。

在这里，“student_info”包含有关每个学生的信息（姓名和分数）作为键值对：

student_info = {'Alice': 85, 'Bob': 92, 'Charlie': 78, 'David': 88}

但是等等，有一种更优雅的方法可以在 Python 中创建字典。

我们即将学习一个新概念：字典理解。如果不是马上就清楚了，不要担心。您可以随时了解更多信息并在以后处理它。

但是理解是非常直观的理解。如果您希望“student_info”词典将学生姓名作为键，并将他们相应的考试成绩作为值，则可以像这样创建字典：

# Using a dictionary comprehension to create the student_info dictionary
student_info = {name: score for name, score in zip(student_names, student_scores)}

print(student_info)

请注意我们如何使用 'zip（）' 函数同时遍历 'student_names' 列表和 'student_scores' 元组。

Output >>>

{'Alice': 85, 'Bob': 92, 'Charlie': 78, 'David': 88}

在此示例中，字典理解直接将“student_names”列表中的每个学生姓名与“student_scores”元组中的相应考试分数配对，以创建“student_info”字典，其中姓名作为键，分数作为值。

现在您已经熟悉了原始数据类型和一些序列/可迭代对象，让我们继续讨论的下一部分：控制结构。

运行 Python 脚本时，代码执行按顺序执行，顺序与代码在脚本中执行的顺序相同。

有时，您需要实现逻辑来根据某些条件控制执行流，或者循环通过可迭代对象来处理其中的项。

我们将了解 if-else 语句如何促进分支和条件执行。我们还将学习如何使用循环迭代序列，循环控制语句中断并继续。

当仅当特定条件为真时才需要执行代码块时，可以使用“if”语句。如果条件的计算结果为 false，则不执行代码块。

图片来源：作者

请考虑以下示例：

score = 75

if score >= 60:
    print("Congratulations! You passed the exam.")

在此示例中，仅当“score”大于或等于 60 时，才会执行“if”块中的代码。由于“分数”是 75，因此消息“恭喜！你通过了考试“，将打印出来。

Output >>> Congratulations! You passed the exam.

“if-else”语句允许您在条件为真时执行一个代码块，如果条件为假，则执行另一个代码块。

图片来源：作者

让我们以测试分数示例为基础：

score = 45

if score >= 60:
    print("Congratulations! You passed the exam.")
else:
    print("Sorry, you did not pass the exam.")

在这里，如果“分数”小于 60，则将执行“else”块中的代码：

Output >>> Sorry, you did not pass the exam.

当您有多个条件要检查时，将使用“if-elif-else”语句。它允许您测试多个条件，并为遇到的第一个 true 条件执行相应的代码块。

如果 'if' 和所有 'elif' 语句中的条件计算结果为 false，则执行 'else' 块。

图片来源：作者

score = 82

if score >= 90:
    print("Excellent! You got an A.")
elif score >= 80:
    print("Good job! You got a B.")
elif score >= 70:
    print("Not bad! You got a C.")
else:
    print("You need to improve. You got an F.")

在此示例中，程序根据多个条件检查“分数”。将执行第一个 true 条件块中的代码。由于“分数”是 82，我们得到：

Output >>> Good job! You got a B.

当您需要检查另一个条件中的多个条件时，使用嵌套的“if”语句。

name = "Alice"
score = 78

if name == "Alice":
    if score >= 80:
        print("Great job, Alice! You got an A.")
    else:
        print("Good effort, Alice! Keep it up.")
else:
    print("You're doing well, but this message is for Alice.")

在此示例中，有一个嵌套的“if”语句。首先，程序检查“名称”是否为“爱丽丝”。如果为 true，则检查“分数”。由于“分数”为 78，因此执行内部的“else”块，打印“努力好，爱丽丝！坚持下去。

Output >>> Good effort, Alice! Keep it up.

Python 提供了几个循环构造来迭代集合或执行重复性任务。

在 Python 中，“for”循环提供了一个简洁的语法，让我们迭代现有的可迭代对象。我们可以像这样迭代“student_names”列表：

student_names = ["Alice", "Bob", "Charlie", "David"]

for name in student_names:
    print("Student:", name)

上面的代码输出：

Output >>>

Student: Alice
Student: Bob
Student: Charlie
Student: David

如果你想在条件为真的情况下执行一段代码，你可以使用“while”循环。

让我们使用相同的“student_names”列表：

# Using a while loop with an existing iterable

student_names = ["Alice", "Bob", "Charlie", "David"]
index = 0

while index < len(student_names):
    print("Student:", student_names[index])
    index += 1

在此示例中，我们有一个包含学生姓名的列表“student_names”。我们使用“while”循环通过跟踪“index”变量来迭代列表。

只要“索引”小于列表的长度，循环就会继续。在循环中，我们打印每个学生的姓名并递增“索引”以移动到下一个学生。请注意使用“len（）”函数来获取列表的长度。

这实现了与使用“for”循环遍历列表相同的结果：

Output >>>

Student: Alice
Student: Bob
Student: Charlie
Student: David

让我们使用一个 'while' 循环，从列表中弹出元素，直到列表为空：

student_names = ["Alice", "Bob", "Charlie", "David"]

while student_names:
    current_student = student_names.pop()
    print("Current Student:", current_student)

print("All students have been processed.")

列表方法“pop”删除并返回列表中存在的最后一个元素。

在此示例中，只要“student_names”列表中存在元素，“while”循环就会继续。在循环中，“pop（）”方法用于删除并返回列表中的最后一个元素，并打印当前学生的姓名。

循环将继续，直到所有学生都已处理完毕，并在循环外打印最后一条消息。

Output >>>

Current Student: David
Current Student: Charlie
Current Student: Bob
Current Student: Alice
All students have been processed.

“for”循环通常更简洁，更易于阅读，用于迭代现有的可迭代对象（如列表）。但是，当循环条件更复杂时，“while”循环可以提供更多的控制。

“break”过早退出循环，“continue”跳过当前迭代的其余部分并移动到下一个迭代。

下面是一个示例：

student_names = ["Alice", "Bob", "Charlie", "David"]

for name in student_names:
    if name == "Charlie":
        break
    print(name)

当“名字”是查理时，控件脱离循环，给我们输出：

Output >>>
Alice
Bob

在Python中，没有像其他一些编程语言那样的内置“do-while”循环。但是，您可以使用带有“break”语句的“while”循环来实现相同的行为。以下是在 Python 中模拟“do-while”循环的方法：

while True:
    user_input = input("Enter 'exit' to stop: ")
    if user_input == 'exit':
        break

在此示例中，循环将无限期地继续运行，直到用户进入“exit”。循环至少运行一次，因为条件最初设置为“True”，然后在循环内检查用户的输入。如果用户输入“exit”，则执行“break”语句，退出循环。

下面是一个示例输出：

Output >>>
Enter 'exit' to stop: hi
Enter 'exit' to stop: hello
Enter 'exit' to stop: bye
Enter 'exit' to stop: try harder!
Enter 'exit' to stop: exit

请注意，此方法类似于其他语言中的“do-while”循环，其中循环体保证在检查条件之前至少执行一次。

我希望您能够毫无困难地编写本教程的代码。现在您已经了解了 Python 的基础知识，是时候开始编写一些超级简单的项目了，应用您学到的所有概念。

原文链接：Python 基础知识：语法、数据类型和控制结构 (mvrlink.com)