Python 编程语法基础入门教程

4. 表达式

Python3 中的表达式是由变量、常量和运算符组成的式子，可以用来计算结果。常见的运算符有：

• 算术运算符：+、-、*、/、%、**、//。
• 比较运算符：==、!=、>、<、>=、<=。
• 逻辑运算符：and、or、not。

5. 运算符

Python3 中的运算符有很多种，包括算术运算符、比较运算符、逻辑运算符、位运算符等。

• 算术运算符：用于执行基本的数学运算，如加、减、乘、除、取模、幂等。例如：+、-、*、/、%、**。
• 比较运算符：用于比较两个值的大小关系，返回 True 或 False。例如：==、!=、>、<、>=、<=。
• 赋值运算符：用于给变量赋值。例如：=、+=、-=、*=、/=、%=、**=。
• 逻辑运算符：用于组合多个条件，返回 True 或 False。例如：and、or、not。
• 位运算符：用于对二进制数进行操作。例如：&、|、^、~、<<、>>。
• 成员运算符：用于判断一个值是否在序列中。例如：in、not in。
• 身份运算符：用于比较两个对象的内存地址是否相同。例如：is、is not。
• 运算符优先级：用于确定运算符的执行顺序。

操作对象包括：

• 数字：整数、浮点数、复数等。
• 字符串：由一系列字符组成的序列。
• 列表：由一系列元素组成的序列，可以包含不同类型的元素。
• 元组：与列表类似，但是元素不可修改。
• 字典：由一系列键值对组成的无序集合。
• 集合：由一系列元素组成的无序集合，元素不可重复。

6. 字符串

Python3 中的字符串是由一串字符组成的，可以用单引号或双引号来表示。字符串可以进行拼接、切片、替换等操作。

7. 注释

Python3 中的注释用 # 来表示，可以在代码中添加注释来解释代码的作用。注释可以单独一行，也可以在代码行后面添加。注释不会被解释器执行。

二、列表与元组

在 Python 中，列表和元组都是用来存储一组有序数据的容器，它们的区别在于列表是可变的，而元组是不可变的。

列表

列表是 Python 中最常用的数据类型之一，它可以存储任意类型的数据，包括数字、字符串、布尔值、列表、元组、字典等。列表用方括号 [] 来表示，其中的元素用逗号分隔开。

创建列表

# 创建一个空列表
my_list = []

# 创建一个包含元素的列表
my_list = [1, 2, 3, 'hello', True, [4, 5, 6]]

访问列表元素

可以通过下标来访问列表中的元素，下标从 0 开始，可以是负数，表示从后往前数。

my_list = [1, 2, 3, 'hello', True, [4, 5, 6]]

print(my_list[0])  # 输出 1
print(my_list[3])  # 输出 'hello'
print(my_list[-1])  # 输出 [4, 5, 6]
print(my_list[-1][0])  # 输出 4

修改列表元素

列表是可变的，可以通过下标来修改列表中的元素。

my_list = [1, 2, 3, 'hello', True, [4, 5, 6]]

my_list[0] = 100
my_list[-1][0] = 400

print(my_list)  # 输出 [100, 2, 3, 'hello', True, [400, 5, 6]]

列表操作

列表支持一些常用的操作，如添加元素、删除元素、切片等。

• 添加元素：可以使用 append() 方法向列表末尾添加一个元素，使用 insert() 方法在指定位置插入一个元素。

my_list = [1, 2, 3]

my_list.append(4)
print(my_list)  # 输出 [1, 2, 3, 4]

my_list.insert(1, 5)
print(my_list)  # 输出 [1, 5, 2, 3, 4]

• 删除元素：可以使用 remove() 方法删除指定元素，使用 pop() 方法删除指定位置的元素。

my_list = [1, 2, 3, 4]

my_list.remove(3)
print(my_list)  # 输出 [1, 2, 4]

my_list.pop(1)
print(my_list)  # 输出 [1, 4]

• 切片：可以使用切片来获取列表的子集，语法为 [start:end:step]，其中 start 表示起始位置（默认为 0），end 表示结束位置（默认为列表长度），step 表示步长（默认为 1）。

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

print(my_list[1:3])  # 输出 [2, 3]
print(my_list[:3])  # 输出 [1, 2, 3]
print(my_list[::2])  # 输出 [1, 3, 5]

元组

元组和列表类似，也是用来存储一组有序数据的容器，但是元组是不可变的，一旦创建就不能修改。元组用圆括号 () 来表示，其中的元素用逗号分隔开。

创建元组

# 创建一个空元组
my_tuple = ()

# 创建一个包含元素的元组
my_tuple = (1, 2, 3, 'hello', True, [4, 5, 6])

访问元组元素

可以通过下标来访问元组中的元素，下标从 0 开始，可以是负数，表示从后往前数。

my_tuple = (1, 2, 3, 'hello', True, [4, 5, 6])

print(my_tuple[0])  # 输出 1
print(my_tuple[3])  # 输出 'hello'
print(my_tuple[-1])  # 输出 [4, 5, 6]
print(my_tuple[-1][0])  # 输出 4

元组操作

元组是不可变的，不能修改元素，但是可以进行一些常用的操作，如切片、拼接等。

• 切片：可以使用切片来获取元组的子集，语法和列表相同。

my_tuple = (1, 2, 3, 4, 5)

print(my_tuple[1:3])  # 输出 (2, 3)
print(my_tuple[:3])  # 输出 (1, 2, 3)
print(my_tuple[::2])  # 输出 (1, 3, 5)

• 拼接：可以使用 + 运算符来拼接两个元组。

my_tuple1 = (1, 2, 3)
my_tuple2 = ('hello', 'world')

my_tuple3 = my_tuple1 + my_tuple2
print(my_tuple3)  # 输出 (1, 2, 3, 'hello', 'world')

列表和元组的选择

列表和元组都是用来存储一组有序数据的容器，它们的区别在于列表是可变的，而元组是不可变的。因此，如果需要对数据进行增删改操作，应该使用列表；如果数据不需要修改，应该使用元组，因为元组比列表更加轻量级，占用的内存更少。

三、字符串

Python 中的字符串是一种不可变的序列类型，可以使用单引号、双引号或三引号来表示。以下是一些常见的字符串操作：

1. 字符串拼接

可以使用加号（+）来拼接两个字符串，也可以使用乘号（*）来重复一个字符。

str1 = "Hello"
str2 = "World"
str3 = str1 + " " + str2  # 拼接字符串
print(str3)  # 输出：Hello World

str4 = str1 * 3  # 重复字符串
print(str4)  # 输出：HelloHelloHello

2. 字符串索引和切片

可以使用索引来访问字符串中的单个字符，索引从 0 开始。也可以使用切片来访问字符串中的一部分，切片的语法为 [start:end:step]，其中 start 表示起始位置（包含），end 表示结束位置（不包含），step 表示步长（默认为 1）。

str = "Hello World"
print(str[0])  # 输出：H
print(str[-1])  # 输出：d
print(str[0:5])  # 输出：Hello
print(str[6:])  # 输出：World
print(str[::2])  # 输出：HloWrd

3. 字符串常用方法

Python 中的字符串还有许多常用方法，例如：

• len()：返回字符串的长度。
• upper()：将字符串中的所有字母转换为大写。
• lower()：将字符串中的所有字母转换为小写。
• strip()：去除字符串两端的空格。
• split()：将字符串按照指定的分隔符分割成多个子字符串，并返回一个列表。

str = " Hello World "
print(len(str))  # 输出：13
print(str.upper())  # 输出： HELLO WORLD 
print(str.lower())  # 输出： hello world 
print(str.strip())  # 输出：Hello World
print(str.split())  # 输出：['Hello', 'World']

总之，字符串是 Python 中非常重要的数据类型之一，掌握字符串的基本操作和常用方法对于编写 Python 程序非常有帮助。

四、字典

在 Python 中，字典是一种无序的数据结构，用于存储键值对。字典中的键必须是唯一的，而值可以是任何类型的对象。字典用花括号{}表示，每个键值对之间用逗号分隔。

创建字典的方法：

1. 直接使用花括号{}创建空字典

my_dict = {}

2. 使用键值对创建字典

my_dict = {'name': 'Tom', 'age': 18, 'gender': 'male'}

3. 使用 dict() 函数创建字典

my_dict = dict(name='Tom', age=18, gender='male')

访问字典中的值

可以使用键来访问字典中的值，如果键不存在，则会抛出 KeyError 异常。

my_dict = {'name': 'Tom', 'age': 18, 'gender': 'male'}
print(my_dict['name'])  # 输出 Tom

添加或修改字典中的键值对：

可以使用赋值语句来添加或修改字典中的键值对。

my_dict = {'name': 'Tom', 'age': 18, 'gender': 'male'}
my_dict['name'] = 'Jerry'  # 修改 name 的值
my_dict['height'] = 180  # 添加新的键值对
print(my_dict)  # 输出{'name': 'Jerry', 'age': 18, 'gender': 'male', 'height': 180}

删除字典中的键值对：

可以使用 del 语句来删除字典中的键值对。

my_dict = {'name': 'Tom', 'age': 18, 'gender': 'male'}
del my_dict['age']  # 删除 age 键值对
print(my_dict)  # 输出{'name': 'Tom', 'gender': 'male'}

遍历字典：

可以使用 for 循环遍历字典中的键值对。

my_dict = {'name': 'Tom', 'age': 18, 'gender': 'male'}
for key, value in my_dict.items():
    print(key, value)

其他常用方法：

• keys()：返回字典中所有的键。
• values()：返回字典中所有的值。
• items()：返回字典中所有的键值对。

五、条件、循环和其他语句

条件语句

Python 中的条件语句包括 if、elif 和 else。它们用于根据条件执行不同的代码块。

if 语句的语法如下：

if condition:
    # code block

如果条件为 True，则执行代码块。如果条件为 False，则跳过代码块。

elif 语句用于在 if 语句中添加多个条件。它的语法如下：

if condition1:
    # code block
elif condition2:
    # code block

如果条件 1 为 True，则执行第一个代码块。如果条件 1 为 False 且条件 2 为 True，则执行第二个代码块。如果条件 1 和条件 2 都为 False，则跳过代码块。

else 语句用于在 if 语句中添加一个默认情况。它的语法如下：

if condition1:
    # code block
elif condition2:
    # code block
else:
    # code block

如果条件 1 为 True，则执行第一个代码块。如果条件 1 为 False 且条件 2 为 True，则执行第二个代码块。如果条件 1 和条件 2 都为 False，则执行 else 代码块。

循环语句

Python 中的循环语句包括 for 和 while。它们用于重复执行代码块。

for 循环用于遍历序列（如列表、元组、字符串等）。它的语法如下：

for variable in sequence:
    # code block

在每次循环中，变量将被设置为序列中的下一个值，并执行代码块。当序列中的所有值都被遍历后，循环结束。

while 循环用于在条件为 True 时重复执行代码块。它的语法如下：

while condition:
    # code block

在每次循环中，检查条件是否为 True。如果是，则执行代码块。如果不是，则跳出循环。

其他语句

Python 中还有一些其他语句，如 break、continue 和 pass。

break 语句用于跳出循环。它的语法如下：

while condition:
    # code block
    if some_condition:
        break

在循环中，如果满足某个条件，则使用 break 语句跳出循环。

continue 语句用于跳过当前循环中的剩余代码，并开始下一次循环。它的语法如下：

while condition:
    # code block
    if some_condition:
        continue
    # remaining code in loop

在循环中，如果满足某个条件，则使用 continue 语句跳过当前循环中的剩余代码，并开始下一次循环。

pass 语句用于在代码块中占位。它的语法如下：

if some_condition:
    pass
else:
    # code block

在代码块中，如果需要占位，则使用 pass 语句。它不执行任何操作，只是占据一个位置。

六、函数

在 Python 中，函数是一段可重用的代码块，用于执行特定的任务。函数可以接受参数并返回值。函数的定义以关键字 def 开头，后跟函数名和括号，括号中可以包含参数列表。函数体包含在冒号后面的缩进块中。

以下是一个简单的函数示例：

def greet(name):
    print("Hello, " + name + "!")

greet("Alice")

输出：

Hello, Alice!

在这个例子中，greet 函数接受一个参数 name，并在控制台上打印出一条问候语。

函数可以返回一个值，使用关键字 return。以下是一个返回两个数之和的函数示例：

def add_numbers(x, y):
    return x + y

result = add_numbers(3, 5)
print(result)

输出：

8

在这个例子中，add_numbers 函数接受两个参数 x 和 y，并返回它们的和。我们将函数的返回值存储在变量 result 中，并在控制台上打印出来。

函数可以有默认参数值，这些值在函数被调用时可以被覆盖。以下是一个带有默认参数值的函数示例：

def greet(name, greeting="Hello"):
    print(greeting + ", " + name + "!")

greet("Alice")
greet("Bob", "Hi")

输出：

Hello, Alice!
Hi, Bob!

在这个例子中，greet 函数有一个默认参数值 greeting="Hello"。如果我们不提供 greeting 参数，函数将使用默认值。如果我们提供了 greeting 参数，它将覆盖默认值。

函数可以接受任意数量的参数，使用星号*。以下是一个接受任意数量参数的函数示例：

def print_numbers(*numbers):
    for number in numbers:
        print(number)

print_numbers(1, 2, 3)
print_numbers(4, 5, 6, 7)

输出：

1
2
3
4
5
6
7

在这个例子中，print_numbers 函数接受任意数量的参数，并使用 for 循环打印它们。

函数可以嵌套在其他函数中。以下是一个嵌套函数的示例：

def outer_function():
    print("Outer function")

    def inner_function():
        print("Inner function")

    inner_function()

outer_function()

输出：

Outer function
Inner function

在这个例子中，outer_function 包含一个嵌套函数 inner_function。当 outer_function 被调用时，它将打印一条消息并调用 inner_function。inner_function 也将打印一条消息。

函数可以作为参数传递给其他函数。以下是一个将函数作为参数的示例：

def add_numbers(x, y):
    return x + y

def apply_function(f, x, y):
    return f(x, y)

result = apply_function(add_numbers, 3, 5)
print(result)

输出：

8

在这个例子中，apply_function 函数接受一个函数 f 和两个参数 x 和 y。它将调用 f(x, y) 并返回结果。我们将 add_numbers 函数作为参数传递给 apply_function，并将结果存储在变量 result 中。

七、面向对象

Python 是一种面向对象的编程语言，它支持面向对象编程（OOP）。面向对象编程是一种编程范式，它将数据和操作数据的方法组合在一起，形成一个对象。在 Python 中，对象是由类定义的，类是一种用户定义的数据类型，它包含数据和方法。

Python 中的面向对象编程有以下几个关键概念：

• 类（Class）：类是一种用户定义的数据类型，它定义了一组属性和方法。类是创建对象的模板。
• 对象（Object）：对象是类的实例，它包含了类定义的属性和方法。
• 属性（Attribute）：属性是对象的数据成员，它可以是变量或常量。
• 方法（Method）：方法是对象的操作成员，它可以是函数或过程。
• 继承（Inheritance）：继承是一种机制，它允许一个类继承另一个类的属性和方法。
• 多态（Polymorphism）：多态是一种机制，它允许不同的对象对同一消息做出不同的响应。

下面是一个简单的 Python 类的例子：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print("Hello, my name is", self.name, "and I am", self.age, "years old.")

person1 = Person("Alice", 25)
person1.say_hello()

在这个例子中，我们定义了一个名为 Person 的类，它有两个属性（name 和 age）和一个方法（say_hello）。我们使用__init__方法来初始化对象的属性，使用 self 关键字来引用对象本身。我们还定义了一个 say_hello 方法，它打印出对象的属性。

我们创建了一个名为 person1 的 Person 对象，并调用了它的 say_hello 方法。输出结果为：

Hello, my name is Alice and I am 25 years old.

这是一个简单的面向对象编程的例子，它展示了 Python 中类和对象的基本概念。在实际编程中，面向对象编程可以帮助我们更好地组织代码，提高代码的可重用性和可维护性。

在 Python 中，继承是面向对象编程的一个重要概念。继承允许我们创建一个新的类，该类继承了另一个类的属性和方法。被继承的类称为父类或基类，继承的类称为子类或派生类。

继承

在 Python 中，继承的语法如下：

class ParentClass:
    # 父类的属性和方法

class ChildClass(ParentClass):
    # 子类的属性和方法

在这个例子中，ChildClass 继承了 ParentClass 的所有属性和方法。子类可以使用父类的方法和属性，也可以添加自己的方法和属性。

例如，我们可以定义一个 Person 类作为父类，然后定义一个 Student 类作为子类，继承 Person 类的属性和方法：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print("Hello, my name is", self.name)

class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.grade = grade

    def say_hello(self):
        super().say_hello()
        print("I am a student in grade", self.grade)

在这个例子中，Student 类继承了 Person 类的__init__方法和 say_hello 方法。子类中的__init__方法使用 super() 函数调用父类的__init__方法，以便子类可以继承父类的属性。子类中的 say_hello 方法使用 super() 函数调用父类的 say_hello 方法，并添加了自己的打印语句。

现在我们可以创建一个 Student 对象并调用它的方法：

student = Student("Alice", 15, 9)
student.say_hello()

输出结果为：

Hello, my name is Alice
I am a student in grade 9

这个例子展示了如何使用继承来创建一个子类，并继承父类的属性和方法。子类可以添加自己的方法和属性，也可以重写父类的方法。

封装

在 Python 中，封装是指将数据和方法包装在一个类中，以保护数据不被外部直接访问和修改。这样可以确保数据的安全性和一致性，同时也可以隐藏实现细节，使代码更加简洁和易于维护。

Python 中实现封装的方式是通过使用访问控制符来限制对类的属性和方法的访问。Python 中有两种访问控制符：公有和私有。

公有属性和方法可以被类的外部访问，私有属性和方法只能在类的内部访问。在 Python 中，私有属性和方法的命名规则是在属性或方法名前加上两个下划线'__'。

下面是一个简单的例子，演示了如何在 Python 中实现封装：

class Person:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age

    def get_name(self):
        return self.__name

    def get_age(self):
        return self.__age

    def set_name(self, name):
        self.__name = name

    def set_age(self, age):
        self.__age = age

p = Person("Tom", 20)
print(p.get_name())  # 输出：Tom
print(p.get_age())   # 输出：20

p.set_name("Jerry")
p.set_age(25)
print(p.get_name())  # 输出：Jerry
print(p.get_age())   # 输出：25

# 下面这行代码会报错，因为__name 是私有属性，外部无法直接访问
# print(p.__name)

在上面的例子中，我们定义了一个 Person 类，包含了两个私有属性__name 和__age，以及四个公有方法 get_name、get_age、set_name 和 set_age。通过这些方法，我们可以获取和修改对象的属性值，同时保证了属性的安全性。

需要注意的是，Python 中的私有属性和方法并不是真正的私有，只是通过命名规则来实现的。如果知道了私有属性和方法的名称，仍然可以在类的外部访问和修改它们。因此，封装并不是完全保证数据的安全性，而是提高了数据的安全性和可维护性。

类的专有方法

在 Python 中，类的专有方法是指以双下划线开头和结尾的方法，也称为魔术方法或特殊方法。这些方法在类的实例化、属性访问、运算符重载等方面起着重要作用。以下是一些常用的类的专有方法：

• __init__(self, …)：构造方法，用于初始化对象的属性。
• __str__(self)：返回对象的字符串表示，可以通过 print() 函数输出。
• __repr__(self)：返回对象的字符串表示，可以通过交互式命令行输出。
• __getattr__(self, name)：当访问不存在的属性时调用。
• __setattr__(self, name, value)：当设置属性值时调用。
• __delattr__(self, name)：当删除属性时调用。
• __len__(self)：返回对象的长度，可以通过 len() 函数调用。
• __getitem__(self, key)：当通过索引访问对象时调用。
• __setitem__(self, key, value)：当通过索引设置对象的值时调用。
• __delitem__(self, key)：当通过索引删除对象的值时调用。
• __eq__(self, other)：当比较两个对象是否相等时调用。
• __lt__(self, other)：当比较两个对象大小时调用。

八、异常与文件处理

异常处理

在 Python 中，异常处理是一种处理程序中出现错误的方式。当程序出现错误时，Python 会引发异常。异常是一种 Python 对象，表示程序中的错误或异常情况。Python 提供了 try-except 语句来捕获和处理异常。

try-except 语句的基本语法如下：

try:
    # 代码块
except ExceptionType:
    # 异常处理代码块

其中，try 语句块中包含可能引发异常的代码，如果 try 语句块中的代码引发了异常，则会跳转到 except 语句块中执行异常处理代码。

文件处理

Python 中的文件处理包括文件的读取、写入和关闭等操作。Python 提供了 open() 函数来打开文件，可以指定文件名、打开模式和编码方式等参数。

打开文件的基本语法如下：

file = open(filename, mode, encoding)

其中，filename 是文件名，mode 是打开模式，encoding 是编码方式。打开模式包括：

• 'r'：只读模式，打开文件后只能读取文件内容，不能修改文件内容。
• 'w'：写入模式，打开文件后可以写入文件内容，如果文件不存在则创建文件，如果文件已存在则清空文件内容。
• 'a'：追加模式，打开文件后可以在文件末尾追加内容，如果文件不存在则创建文件。
• 'x'：独占模式，打开文件后只能写入文件内容，如果文件已存在则抛出 FileExistsError 异常。
• 'b'：二进制模式，打开文件时以二进制方式读取或写入文件内容。

文件打开后，可以使用 read()、write() 和 close() 等方法来读取、写入和关闭文件。

读取文件的基本语法如下：

content = file.read()

其中，file 是文件对象，read() 方法用于读取文件内容。

写入文件的基本语法如下：

file.write(content)

其中，file 是文件对象，write() 方法用于写入文件内容。

关闭文件的基本语法如下：

file.close()

其中，file 是文件对象，close() 方法用于关闭文件。

总结

本文详细介绍了 Python 编程的基础语法，涵盖了数据类型、变量、运算符、字符串、列表、元组、字典、条件语句、循环、函数、面向对象编程以及异常处理等核心知识点。掌握这些基础内容是进一步深入学习 Python 高级特性、数据分析、Web 开发及人工智能应用的前提。建议读者通过实际编写代码来巩固所学内容，并结合具体项目实践以提升编程能力。