文章目录
- for循环
- while循环
- 字符串操作
- 访问字符串中的字符
- 切片总结
- 字符串拼接
- 文件读写
- try...except 异常处理
- 函数
- 模块和包
- 类和面向对象编程
- 完结
for循环
在 Python 中，for 循环用于遍历序列（list、tuple、range 对象等）或其他可迭代对象。for 循环的基本语法如下：
for 变量 in 可迭代对象:
# 循环体
其中，变量 表示每次循环中取出的一个元素，可迭代对象 表示被遍历的对象。下面是一个 for 循环的例子：
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
输出结果为：
apple
banana
cherry
代码中，fruits 是一个列表，fruit 是当前循环中取出的元素。
除了用于遍历序列外，for 循环还可以结合 range() 函数使用。range() 函数用于生成一个整数序列，它的基本语法如下：
range([start], stop[, step])
其中，start 为可选参数，表示序列的起始值；stop 是必需参数，表示序列的结束值（不包括该值）；step 为可选参数，表示步长，默认为 1。下面是一个 for 循环结合 range() 函数的例子：
for i in range(1, 5):
print(i)
输出结果为：
1
2
3
4
上述代码中，range(1, 5) 生成了一个包含整数 1、2、3、4 的序列。
除了常规使用外，for 循环还可以和 break 和 continue 语句一起使用。break 语句用于结束整个循环，而 continue 语句用于跳过本次循环。下面是一个包含 break 和 continue 的 for 循环例子：
fruits = ["apple", "banana", "cherry", "orange", "kiwi"]
for fruit in fruits:
if fruit == "orange":
break
elif fruit == "banana":
continue
print(fruit)
输出结果为：
apple
cherry
代码中，当循环到 “orange” 时，使用 break 语句结束循环；当循环到 “banana” 时，使用 continue 语句跳过本次循环。
while循环
Python 中，while 循环用于重复执行一段代码，直到满足某个条件才停止循环。while 循环的基本语法如下：
while 条件:
# 循环体
其中，条件 表示一个表达式或变量，当该表达式或变量为 True 时，循环体会被执行。下面是一个简单的 while 循环的例子：
i = 1
while i <= 5:
print(i)
i += 1
输出结果为：
1
2
3
4
5
代码中，i 的初始值为 1，每次循环 i 的值都会加 1，当 i 大于 5 时，循环停止。
需要注意的是，在使用 while 循环时要确保循环条件最终能够变为 False，否则会导致死循环。下面是一个死循环的例子：
# 死循环，永远不会停止
while True:
print("Hello, world!")
字符串操作
在 Python 中，字符串是一种不可变对象，即不能修改其内容。但是我们可以通过字符串函数来操作字符串，例如访问字符串中的字符、拼接字符串等。
访问字符串中的字符
使用 [] 运算符可以访问字符串中的单个字符。Python 中的字符串索引从 0 开始，也可以使用负数索引从右侧开始计数。例如，字符串 “Hello, world!” 可以表示为以下索引：
+---+---+---+---+---+---+---+---+---+---+---+---+
| H | e | l | l | o | , | | w | o | r | l | d |
+---+---+---+---+---+---+---+---+---+---+---+---+
0 1 2 3 4 5 6 7 8 9 10 11
-12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1
下面是一个字符串访问的例子：
string = "Hello, world!"
print(string[0]) # H
print(string[-1]) # !
print(string[7:12]) # world
输出结果为：
H
!
world
代码中，我们使用 [] 运算符访问字符串中的单个字符。例如 string[0] 返回字符串中的第一个字符，string[-1] 返回字符串中的最后一个字符。
还可以使用切片语法访问字符串的子串。切片语法是指通过指定开始位置和结束位置来获取字符串的子字符串，语法如下：
string[start:end]
其中，start 和 end 是可选参数，表示子字符串的开始位置和结束位置。如果不指定 start，则默认为 0；如果不指定 end，则默认为字符串的长度。下面是一个使用切片访问字符串的例子：
string = "Hello, world!"
print(string[0:5]) # Hello
print(string[7:]) # world!
print(string[:5]) # Hello
print(string[:-1]) # Hello, world
输出结果为：
Hello
world!
Hello
Hello, world
切片语法中还可以使用第三个参数 step（步长）来指定从字符串中每隔多少个字符取一个字符。例如，当 step=2 时，表示每隔一个字符取一个字符，以此类推。需要注意的是，步长不能为 0，否则会抛出 ValueError 异常。
下面是一个使用步长访问字符串的例子：
string = "Hello, world!"
print(string[::2]) # Hlo ol!
在这个例子中，[::2] 表示从字符串中每隔一个字符取一个字符，所以输出结果为 Hlo ol!。
需要注意的是，如果要逆序遍历字符串，我们可以先将步长设为 -1，然后再反向取子字符串。例如：
string = "Hello, world!"
print(string[::-1]) # !dlrow ,olleH
在这个例子中，[::-1] 表示从字符串的末尾开始，每隔一个字符取一个字符，所以输出结果为 !dlrow ,olleH，即原字符串翻转过来的字符串。
切片总结
s = "Hello, world!"
# 基本切片操作，获取子字符串
print(s[0:5]) # 输出 "Hello"，包含开头位置，不包含结束位置
print(s[7:]) # 输出 "world!"，从第 7 个字符开始，一直到字符串末尾
print(s[2:9]) # 输出 "llo, wo"，包含开头位置和结束位置之间的所有字符
print(s[:5]) # 输出 "Hello"，从字符串开头位置开始，一直到第 5 个字符（不包含）
print(s[:-1]) # 输出 "Hello, world"，没有指定结束位置，默认到字符串末尾
# 步长操作，获取间隔多少个字符的子字符串
print(s[::2]) # 输出 "Hlo,wr!d"，从第 0 个字符开始，每隔 2 个字符取一个字符
print(s[1::3]) # 输出 "eood"，从第 1 个字符开始，每隔 3 个字符取一个字符
# 反转字符串
print(s[::-1]) # 输出 "!dlrow ,olleH"，步长为 -1 表示反转字符串
字符串拼接
使用加号 + 可以将两个或多个字符串拼接成一个新的字符串。下面是一个字符串拼接的例子：
string1 = "Hello"
string2 = "world"
string3 = string1 + ", " + string2 + "!"
print(string3) # Hello, world!
输出结果为：
Hello, world!
除了加号 + 外，还可以使用 join() 方法来拼接字符串。join() 方法是一个字符串方法，它将一个可迭代对象中的字符串元素连接起来，并返回一个新的字符串。下面是一个使用 join() 方法拼接字符串的例子：
string1 = "Hello"
string2 = "world"
strings = [string1, string2, "!"]
string3 = "".join(strings)
print(string3) # Hello, world!
输出结果与上一个例子相同。
文件读写
在 Python 中，可以使用内置的 open() 函数来读取和写入文件。open() 函数的基本语法如下：
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
其中，file 参数是必需的，表示要打开的文件路径（相对或绝对），mode 参数是可选的，表示打开文件的模式，默认为 ‘r’（只读）。下面是一个使用 open() 函数读取文件的例子：
# 打开文件
f = open("example.txt", "r")
# 读取文件内容
content = f.read()
# 关闭文件
f.close()
# 输出文件内容
print(content)
代码中，我们使用 open() 函数打开一个名为 example.txt 的文件，并使用 read() 方法读取其内容。最后，我们关闭了该文件。
如果要写入文件，需要将 mode 参数设置为 ‘w’ 或 ‘a’。‘w’ 表示写入模式，会覆盖原有的内容；‘a’ 表示追加模式，会在文件末尾添加新的内容。下面是一个使用 open() 函数写入文件的例子：
# 打开文件
f = open("example.txt", "a")
# 写入文件内容
f.write("\n 李白醉酒诗百篇")
# 关闭文件
f.close()
效果如图:
代码中，我们使用 open() 函数打开一个名为 example.txt 的文件，并使用 write() 方法在文件末尾添加了一行新的内容。最后， 关闭了该文件。
需要注意的是，在打开文件后，必须要使用 close() 方法关闭文件。如果不关闭文件会导致资源泄漏，甚至可能会影响其他应用程序读取该文件。
使用 with 语句来自动关闭文件，例如：
with open("example.txt", "r") as f:
content = f.read()
print(content)
代码中，使用 with 语句来打开一个文件，并使用 read() 方法读取文件内容。当 with 语句块结束时，自动调用文件的 close() 方法关闭文件。这种写法可以减少代码量，并提高代码的可读性。
try…except 异常处理
在 Python 中，可以使用 try…except 语句来捕获和处理异常。 try 语句用来执行一段可能会抛出异常的代码块，如果代码块中发生了异常，就会跳转到 except 语句块中处理异常。
例子如下：
try:
# 尝试执行可能会抛出异常的代码
result = 10 / 0
except ZeroDivisionError as e:
# 处理 ZeroDivisionError 异常
print("除数不能为0:", e)
代码中，我们尝试将 10 除以 0，这会抛出一个 ZeroDivisionError 异常。在 except 语句中，我们使用 as 关键字来给异常命名为 e，并打印错误信息。
在 except 块中，还可以使用 else 语句处理未发生异常的情况。如果 try 块中的代码没有抛出异常，就会执行 else 块中的代码。下面是一个带有 else 块的 try…except 语句的例子：
try:
# 尝试执行可能会抛出异常的代码
result = 10 / 2
except ZeroDivisionError as e:
# 处理 ZeroDivisionError 异常
print("除数不能为0:", e)
else:
# 处理未发生异常的情况
print("结果为:", result)
代码中，我们尝试将 10 除以 2，这不会抛出异常。因此，程序会执行 else 块中的代码，打印计算结果。
除了使用 except 处理特定的异常类型外，还可以使用 except Exception 来处理所有类型的异常。
Exception 是所有异常类的基类，因此可以捕获任何异常。
使用 except Exception 处理所有类型的异常的例子如下：
try:
# 尝试执行可能会抛出异常的代码
result = 10 / 0
except Exception as e:
# 处理所有类型的异常
print("发生了异常:", e)
代码中，我们使用 except Exception 处理任何类型的异常，并打印错误信息。
在 try…except 块中，还可以使用 finally 语句来执行一些清理工作。无论是否发生异常，都会执行 finally 块中的代码。
下面是一个带有 finally 块的 try…except 语句的例子：
try:
# 尝试执行可能会抛出异常的代码
f = open("example.txt", "r")
content = f.read()
except IOError:
# 处理 IOError 异常
print("无法打开文件")
else:
# 处理未发生异常的情况
print(content)
finally:
# 关闭文件
f.close()
代码中，我们使用 try 块尝试打开一个文件并读取其中的内容。如果打开文件失败会抛出 IOError 异常，在 except 块中处理异常。如果打开文件成功，就会处理未发生异常的情况，在 else 块中输出文件内容。无论是否发生异常，程序都要执行 finally 块中的代码，以确保文件被关闭。
函数
在 Python 中，可以使用 def 语句来定义函数。 def 语句的基本语法如下：
def function_name(arguments):
# function body
return value
其中，function_name 是函数名，arguments 是传递给函数的参数列表。函数体是函数要执行的一系列语句。如果函数需要返回值，可以使用 return 语句将结果返回。下面是一个定义函数和调用函数的例子：
def add(a, b):
"""求和函数"""
result = a + b
return result
# 调用函数
sum = add(3, 5)
print(sum)
代码中，我们使用 def 关键字定义了一个名为 add 的函数，该函数接受两个参数并返回它们的和。在程序的主体部分，我们调用了该函数，将 3 和 5 作为参数传递给它，并将其返回值赋给变量 sum。最后，我们打印出 sum 的值，结果为 8。
在 Python 中，还可以使用 *args 和 **kwargs 参数来接受可变数量的位置参数和关键字参数。*args 表示接受任意数量的位置参数，**kwargs 表示接受任意数量的关键字参数。下面是一个使用 *args 和 **kwargs 参数的例子：
def func(*args, **kwargs):
"""可变参数函数"""
print("位置参数:", args)
print("关键字参数:", kwargs)
# 调用函数
func(1, 2, 3, a=4, b=5)
代码中，我们定义了一个名为 func 的函数，并使用 *args 和 **kwargs 参数来接受任意数量的位置和关键字参数。在函数体中，我们打印出这些参数的值。在程序的主体部分，我们调用该函数，传递了一组位置参数和关键字参数。
在 Python 中，还可以使用 lambda 表达式来定义匿名函数。lambda 表达式的语法如下：
lambda arguments: expression
其中，arguments 是传入的参数列表，expression 是表达式，执行该表达式并将结果返回。下面是一个使用 lambda 表达式的例子：
# 定义匿名函数
square = lambda x: x ** 2
# 调用函数
print(square(3)) # 9
上述代码中，我们使用 lambda 表达式定义了一个名为 square 的匿名函数，该函数接受一个参数并返回该参数的平方。在程序的主体部分，我们使用该函数计算 3 的平方，并打印出结果。
模块和包
在 Python 中，模块是指一个包含 Python 代码的文件。模块可以包含函数、类、变量以及可执行的代码。在 Python 中，每一个文件都可以作为一个模块来使用。要使用一个模块，可以使用 import 语句导入该模块。下面是一个导入模块的例子：
import math
# 计算正弦值
x = math.sin(3.14 / 2)
print(x)
上述代码中，我们使用 import 语句导入了 Python 的 math 模块。在程序的主体部分，我们调用了 math 模块中的 sin() 函数，并计算了 π/2 的正弦值，结果为 1.0。
在 Python 中，还可以使用 from…import 语句从模块中导入部分内容。这样可以避免使用长名称的标识符。下面是一个使用 from…import 语句导入部分内容的例子：
from math import sin, pi
# 计算正弦值
x = sin(pi / 2)
print(x)
代码中，我们使用 from…import 语句仅导入了 math 模块中的 sin() 函数和 pi 变量。在程序的主体部分，我们调用了这些导入的函数和变量，并计算了 π/2 的正弦值，结果为 1.0。
在 Python 中，还可以使用包来组织模块。包是指一个包含模块和子包的文件夹，其中还包括一个名为 __init__.py 的空文件，该文件必须存在。要使用一个包中的模块，可以使用 import 语句导入该模块，格式为：
import package_name.module_name
下面是一个使用包的例子：
my_package/
__init__.py
module1.py
module2.py
我们可以使用以下语句来导入 my_package 包中的 module1 模块：
import my_package.module1
# 调用函数
my_package.module1.my_function()
如果想从 my_package 包中导入多个模块，可以使用以下语句：
from my_package import module1, module2
# 调用函数
module1.my_function()
module2.my_function()
代码中，我们使用 from…import 语句从 my_package 包中导入了 module1 和 module2 两个模块，并分别调用了这两个模块中的函数。
类和面向对象编程
在 Python 中，类是一种用于定义对象的模板。类包含数据属性和方法，它们定义了对象的特征和行为。要定义一个类，可以使用 class 语句。下面是一个定义类的例子：
class MyClass:
"""一个简单的类"""
def __init__(self, name):
self.name = name
def say_hello(self):
print(f"Hello, {self.name}")
# 创建对象
my_object = MyClass("World")
# 调用方法
my_object.say_hello()
代码中，我们定义了一个名为 MyClass 的类，并使用 __init__() 方法创建了一个对象。这个方法会在对象创建时被自动调用，并将对象本身作为第一个参数传入（通常被命名为 self）。在 __init__() 方法中，我们使用 self.name 来初始化对象的 name 属性。
MyClass 类还包含一个 say_hello() 方法，该方法向控制台打印出一条问候语，其中包含对象的 name 属性。在程序的主体部分，我们使用 MyClass 创建了一个名为 my_object 的对象，并调用了该对象的 say_hello() 方法，输出了一条问候语。
在 Python 中，还可以使用继承来创建一个类。子类继承父类的数据属性和方法，并允许子类添加自己的数据属性和方法。下面是一个使用继承的例子：
class MyChildClass(MyClass):
"""一个简单的子类"""
def say_goodbye(self):
print(f"Goodbye, {self.name}!")
# 创建对象
my_child_object = MyChildClass("World")
# 调用方法
my_child_object.say_hello()
my_child_object.say_goodbye()
代码中，我们定义了一个名为 MyChildClass 的子类，并使用 MyClass 作为其父类。MyChildClass 子类包含一个 say_goodbye() 方法，该方法向控制台打印出一条告别语，其中包含对象的 name 属性。
在程序的主体部分，我们使用 MyChildClass 创建了一个名为 my_child_object 的对象，并调用了该对象的 say_hello() 和 say_goodbye() 方法，输出了一条问候语和一条告别语。
在 Python 中，还可以使用装饰器来扩展类和方法的功能。装饰器可以在运行时修改、增强或包装函数或类的功能。下面是一个使用装饰器的例子：
def my_decorator(function):
def wrapper(*args, **kwargs):
print("Before function is called.")
result = function(*args, **kwargs)
print("After function is called.")
return result
return wrapper
@my_decorator
class MyDecoratedClass:
def __init__(self, name):
self.name = name
def say_hello(self):
print(f"Hello, {self.name}")
# 创建对象
my_decorated_object = MyDecoratedClass("World")
# 调用方法
my_decorated_object.say_hello()
代码中，我们定义了一个名为 my_decorator 的装饰器，并使用它来装饰了 MyDecoratedClass 类。在程序的主体部分，我们创建了一个名为 my_decorated_object 的对象，并调用了该对象的 say_hello() 方法，输出了一条问候语。在调用 MyDecoratedClass 类的构造函数和 say_hello() 方法时，会自动调用 my_decorator 装饰器中定义的代码，输出 Before function is called 和 After function is called。
完结
下一篇文章 Python网络爬虫 基础进阶到实战 , 如有兴趣给个关注加订阅
