python教程--基础语法

2.1 缩进规则

在 Python 中，缩进是用来定义代码块的关键元素，而不是使用大括号 {} 或 begin/end 之类的关键字。正确的缩进对于 Python 程序的执行至关重要。同一个代码块中的语句必须有相同的缩进级别。通常，每个缩进级别使用 4 个空格，但也可以使用 1 个制表符（Tab），不过不推荐混合使用空格和制表符，因为这可能会导致缩进错误。
缩进规则主要应用于以下场景：

• 函数定义和调用：函数体需要缩进。
• 条件语句：在 if、elif、else 之后的代码块需要缩进。
• 循环：for 和 while 循环中的代码块需要缩进。
• 类定义：类的方法需要缩进。
• 异常处理：try、except、finally 和 else 代码块需要缩进。
  示例：

# 正确的缩进示例
if True:
    print("True")
else:
    print("False")
# 错误的缩进示例，会导致 IndentationError
if True:
  print("True")
    print("False")

在第二个示例中，第二行的 print("False") 缩进不一致，会导致 Python 解释器抛出 IndentationError 异常。
遵循良好的缩进习惯是编写清晰、易维护 Python 代码的基础。

---

2.2 函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。在 Python 中，函数通过 def 关键字来定义。函数定义后，可以使用其名称来调用函数。函数可以接受参数，并且可以返回值。

函数定义

def function_name(parameters):
    """文档字符串（docstring）- 描述函数的作用（可选）"""
    # 函数体
    return value  # 返回值（如果有的话）

函数调用

result = function_name(arguments)

参数传递

Python 中的函数参数传递有几种形式：

• 位置参数：按照参数定义的顺序传递值。
• 关键字参数：按照参数名传递值，这样可以不按照定义顺序传递。
• 默认参数：在定义函数时可以为参数设置默认值，调用函数时如果没有传递该参数，则使用默认值。
• 不定长参数：可以使用 *args 来收集任意数量的位置参数，使用 **kwargs 来收集任意数量的关键字参数。

示例

# 定义一个简单的函数，打印问候语
def greet(name):
    """打印问候语"""
    return f"Hello, {name}!"
# 调用函数
print(greet("World"))  # 输出: Hello, World!
# 定义一个带有默认参数的函数
def greet_with_default(name="Guest"):
    """带有默认参数的问候语函数"""
    return f"Hello, {name}!"
# 调用函数，不传递参数时使用默认值
print(greet_with_default())  # 输出: Hello, Guest!
# 定义一个带有不定长参数的函数
def sum_all(*numbers):
    """计算所有参数的和"""
    return sum(numbers)
# 调用函数，传递任意数量的参数
print(sum_all(1, 2, 3, 4, 5))  # 输出: 15

函数是 Python 中非常重要的概念，它们帮助我们将代码组织成可重用的逻辑单元，使得程序更加模块化和易于管理。

---

2.3 类

类是 Python 中面向对象编程的基础。类定义了一组属性（称为成员变量）和方法（称为成员函数），它们共同构成了一个对象的数据和行为的蓝图。使用类，我们可以创建具有特定功能和属性的实例（对象）。

类的定义

类使用 class 关键字定义，类名通常采用驼峰命名法（首字母大写）。类可以包含属性（变量）和方法（函数）。

class ClassName:
    def __init__(self, param1, param2):
        self.attribute1 = param1
        self.attribute2 = param2
    
    def method(self):
        # 方法体
        pass

__init__ 方法是一个特殊的方法，当创建类的实例时，它会自动被调用。这个方法内的 self 参数代表类的实例本身。

类的实例化

创建类的实例（对象）时，会调用 __init__ 方法。

# 创建类的实例
instance = ClassName(value1, value2)

类的属性和方法访问

通过实例可以访问类的属性和方法。

# 访问属性
print(instance.attribute1)
# 调用方法
instance.method()

示例

# 定义一个简单的类
class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def bark(self):
        return f"{self.name} says woof!"
# 创建 Dog 类的实例
my_dog = Dog("Buddy", 3)
# 访问属性
print(my_dog.name)  # 输出: Buddy
print(my_dog.age)   # 输出: 3
# 调用方法
print(my_dog.bark())  # 输出: Buddy says woof!

类是 Python 中实现面向对象编程的核心概念，它们允许我们创建具有数据和功能的复杂对象，并且可以用于模拟现实世界中的实体和行为。

---

2.4 顺序语句结构

顺序语句结构是编程中最基本的结构，它指的是程序按照代码编写的顺序依次执行。在 Python 中，程序从第一行开始执行，然后按照从上到下的顺序依次执行后续的语句，除非遇到跳转语句（如循环控制语句或条件分支语句）改变程序的执行流程。

示例

# 顺序语句结构示例
print("第一行代码")
print("第二行代码")
print("第三行代码")

当运行上述代码时，输出将会是：

第一行代码
第二行代码
第三行代码

程序会按照 print 语句在代码中的顺序依次执行，先打印第一行，然后是第二行，最后是第三行。
顺序结构是构建复杂程序的基础，因为即使是最复杂的程序，也是由一系列按照特定顺序执行的简单语句组成的。在实际编程中，顺序结构通常与其他结构（如循环和条件分支）结合使用，以实现更复杂的功能。

---

2.5 条件和分支

条件和分支是编程中用于根据特定条件执行不同代码路径的结构。在 Python 中，主要使用 if、elif（else if 的简写）和 else 关键字来实现条件分支。

条件语句的基本结构

if condition1:
    # 如果 condition1 为 True，则执行的代码块
elif condition2:
    # 如果 condition1 为 False 且 condition2 为 True，则执行的代码块
else:
    # 如果上述条件都为 False，则执行的代码块

示例

# 条件和分支示例
age = 20
if age < 18:
    print("您未成年")
elif age >= 18 and age < 60:
    print("您是成年人")
else:
    print("您是老年人")

在这个例子中，根据变量 age 的值，程序会执行不同的打印语句。如果 age 小于 18，会打印 “您未成年”；如果 age 在 18 到 60 之间（包括 18），会打印 “您是成年人”；否则，会打印 “您是老年人”。

单个 if 语句

if 语句也可以单独使用，不需要 elif 或 else。

if age >= 18:
    print("您是成年人")

嵌套条件语句

条件语句可以嵌套使用，即在一个条件代码块中包含另一个条件语句。

if age >= 18:
    print("您是成年人")
    if age >= 60:
        print("并且您是老年人")

条件和分支是控制程序流程的关键，它们允许程序根据不同的输入或状态采取不同的行动。

---

2.6 循环

循环是编程中用于重复执行一段代码的结构。Python 提供了两种主要的循环机制：for 循环和 while 循环。

For 循环

for 循环用于遍历序列（如列表、元组、字符串）或其他可迭代对象。循环会依次取出序列中的每个元素，执行循环体中的代码。

# For 循环示例
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

在这个例子中，for 循环会遍历 fruits 列表，并在每次迭代中打印出一个水果的名称。

While 循环

while 循环会在指定的条件为真时继续执行循环体中的代码。需要注意的是，必须确保循环条件最终会变为假，以避免无限循环。

# While 循环示例
count = 0
while count < 5:
    print(count)
    count += 1  # 增加 count 的值，以避免无限循环

在这个例子中，while 循环会一直执行，直到 count 的值达到 5。

循环控制语句

• break：立即退出循环体，不再执行后续的迭代。
• continue：跳过当前的迭代，直接进入下一次迭代。
• else：在循环正常完成后执行（即没有遇到 break 时）。

# 使用 break 和 else 的循环示例
for num in range(10):
    if num == 5:
        break  # 当 num 等于 5 时退出循环
    print(num)
else:
    print("循环正常完成")

在这个例子中，当 num 等于 5 时，break 语句会导致循环提前结束，因此 else 代码块不会执行。如果循环正常结束（即没有遇到 break），则会执行 else 代码块。
循环是编程中用于处理重复性任务的重要工具，它们可以大大简化代码并提高效率。

---

2.7 数据类型

Python 中的数据类型用于定义变量可以存储的数据种类。Python 是动态类型语言，这意味着你在创建变量时不需要显式声明数据类型，Python 解释器会在运行时自动确定数据类型。以下是 Python 中一些基本的数据类型：

数字类型

• 整数 (int): 表示没有小数部分的数字，如 1, 100, -10。
• 浮点数 (float): 表示小数点后的数字，如 3.14, -0.001, 2.0。
• 复数 (complex): 表示实数部分和虚数部分的组合，如 3+4j, 5j。

序列类型

• 字符串 (str): 表示一串字符，如 "hello", 'Python'。
• 列表 (list): 表示有序的元素集合，元素可以是不同类型，如 [1, "two", 3.0]。
• 元组 (tuple): 表示不可变的有序元素集合，如 (1, "two", 3.0)。

映射类型

• 字典 (dict): 表示键值对的集合，键是唯一的，如 {"name": "John", "age": 30}。

布尔类型

• 布尔 (bool): 表示逻辑值，有两个值 True 和 False。

示例

# 数字类型
integer = 10
floating = 3.14
complex_number = 1 + 2j
# 序列类型
string = "Hello, World!"
list_example = [1, 2, 3, "four"]
tuple_example = (5, "six", 7.0)
# 映射类型
dictionary = {"key": "value", "age": 25}
# 布尔类型
boolean_true = True
boolean_false = False
# 打印变量的数据类型
print(type(integer))  # 
print(type(floating))  # 
print(type(complex_number))  # 
print(type(string))  # 
print(type(list_example))  # 
print(type(tuple_example))  # 
print(type(dictionary))  # 
print(type(boolean_true))  # 

了解不同的数据类型对于编写有效的 Python 代码至关重要，因为它们决定了变量能够执行的操作和适用的方法。

---

2.8 内置类

Python 提供了一系列内置类，这些类可以直接使用，不需要用户定义。内置类提供了对基本数据结构的支持，如数字、字符串、列表、元组、字典等。下面是一些常用的内置类：

数字类型

• int: 表示整数类型。
• float: 表示浮点数类型。
• complex: 表示复数类型。

序列类型

• str: 表示字符串类型。
• list: 表示列表类型。
• tuple: 表示元组类型。

映射类型

• dict: 表示字典类型。

集合类型

• set: 表示集合类型。
• frozenset: 表示不可变集合类型。

布尔类型

• bool: 表示布尔类型，有两个实例 True 和 False。

其他内置类型

• bytes: 表示字节类型。
• bytearray: 表示字节数组类型。
• memoryview: 表示内存视图类型。
• range: 表示范围类型，用于生成一系列连续的整数。

示例

# 使用内置类创建对象
integer_object = int(10)  # 创建整数对象
float_object = float(3.14)  # 创建浮点数对象
complex_object = complex(1, 2)  # 创建复数对象
string_object = str("Hello")  # 创建字符串对象
list_object = list([1, 2, 3])  # 创建列表对象
tuple_object = tuple((1, 2, 3))  # 创建元组对象
dict_object = dict({"key": "value"})  # 创建字典对象
set_object = set([1, 2, 3])  # 创建集合对象
frozenset_object = frozenset([1, 2, 3])  # 创建不可变集合对象
bool_true = bool(True)  # 创建布尔对象，表示真
bool_false = bool(False)  # 创建布尔对象，表示假
# 打印对象的类型
print(type(integer_object))  # 
print(type(float_object))  # 
print(type(complex_object))  # 
print(type(string_object))  # 
print(type(list_object))  # 
print(type(tuple_object))  # 
print(type(dict_object))  # 
print(type(set_object))  # 
print(type(frozenset_object))  # 
print(type(bool_true))  # 
print(type(bool_false))  # 

内置类是 Python 语言的核心组成部分，它们提供了一种高效的方式来处理常见的数据结构和操作。

---

2.9 常用内置函数

Python 提供了许多内置函数，这些函数可以直接使用，无需导入任何模块。这些函数覆盖了从类型转换到数据操作的各种常见任务。以下是一些常用的内置函数：

类型转换

• int(): 将一个值转换为整数。
• float(): 将一个值转换为浮点数。
• str(): 将一个值转换为字符串。
• list(): 将一个序列转换为列表。
• tuple(): 将一个序列转换为元组。
• dict(): 创建一个字典。
• set(): 创建一个集合。

数学运算

• abs(): 返回一个数的绝对值。
• max(): 返回给定参数的最大值。
• min(): 返回给定参数的最小值。
• sum(): 对序列中的所有元素进行求和。
• round(): 对一个数进行四舍五入。

输入输出

• print(): 打印输出。
• input(): 获取用户输入。

序列操作

• len(): 返回序列的长度。
• sorted(): 对序列进行排序。
• reversed(): 返回一个序列的反向迭代器。
• enumerate(): 同时遍历序列中的元素及其下标。

字符串操作

• upper(): 将字符串中的所有字符转换为大写。
• lower(): 将字符串中的所有字符转换为小写。
• strip(): 移除字符串头尾的空白字符。
• replace(): 将字符串中的指定子串替换成另一个子串。

帮助和文档

• help(): 提供交互式帮助。
• dir(): 列出一个对象的所有属性和方法。
• id(): 返回对象的唯一标识符。
• type(): 返回对象的类型。

示例

# 类型转换
number = int("123")  # 将字符串转换为整数
float_number = float("456.789")  # 将字符串转换为浮点数
string_value = str(789)  # 将整数转换为字符串
# 数学运算
absolute_value = abs(-10)  # 计算绝对值
maximum_value = max(1, 2, 3, 4, 5)  # 计算最大值
minimum_value = min(1, 2, 3, 4, 5)  # 计算最小值
total_sum = sum([1, 2, 3, 4, 5])  # 计算和
rounded_number = round(3.14159, 2)  # 四舍五入到小数点后两位
# 输入输出
print("Hello, World!")  # 打印输出
user_input = input("Enter your name: ")  # 获取用户输入
# 序列操作
list_length = len([1, 2, 3])  # 计算列表长度
sorted_list = sorted([3, 1, 4, 1, 5, 9, 2, 6])  # 对列表进行排序
reversed_list = reversed([1, 2, 3, 4, 5])  # 反转列表
for index, value in enumerate(["apple", "banana", "cherry"]):
    print(index, value)  # 遍历列表及其索引
# 字符串操作
uppercase_string = "hello world".upper()  # 转换为大写
lowercase_string = "HELLO WORLD".lower()  # 转换为小写
stripped_string = "  hello world  ".strip()  # 移除空白字符
replaced_string = "hello world".replace("world", "Python")  # 替换子串
# 帮助和文档
help(print)  # 获取 print 函数的帮助文档
attributes_and_methods = dir("string")  # 列出字符串对象的所有属性和方法
object_id = id("string")  # 获取对象的唯一标识符
object_type = type("string")  # 获取对象的类型

内置函数是 Python 语言的核心组成部分，它们提供了一种高效的方式来执行常见任务，无需编写额外的代码。