代码收藏家 【LLM】Python 基础语法
Python 作为最佳的机器学习和深度学习语言，如果你想入门大模型（如 GPT、BERT 等）与自然语言处理（NLP），那么 Python 一定是最佳选择，这篇文章将带你入门Python语法。（PS：爆肝整理，请不要吝啬你的赞）。
1. 注释
1.1 单行注释
单行注释：使用 # 符号。
# 这是一个单行注释1.2 多行注释
多行注释：使用三个引号 ''' 或 """。
'''
这是多行注释，
可以跨多行
'''
"""
这也是多行注释，
可以跨多行
"""2. 变量和数据结构
Python 是动态类型语言，不需要显式声明变量类型。
支持：整数 (int)、浮点数 (float)、字符串 (str)、布尔值 (bool)、列表 (list)、元组 (tuple)、字典 (dict)、集合 (set)
a = 10 # 整数
b = 3.14 # 浮点数
s = "Hello" # 字符串
l = [1, 2, 3] # 列表
t = (1, 2, 3) # 元组
d = {"key": "value"} # 字典
s = {1, 2, 3} # 集合3. 基本运算符
3.1 算术运算符
算数运算符：+, -, *, /, //（整除）, %（取余）, **（幂）
# 算术运算符
a = 10
b = 3
print(a + b) # 13
print(a - b) # 7
print(a * b) # 30
print(a / b) # 3.3333333333333335
print(a % b) # 1
print(a // b) # 3
print(a ** b) # 10003.2 比较运算符
比较运算符：==, !=, >, <, >=, <=
# 比较运算符
print(a > b) # True
print(a < b) # False3.3 赋值运算符
赋值运算符： =, +=, -=, *=, /=, %=, //=, **=
# 赋值运算符
a = 10
b = 3
c = a
# 加
c += b # c = c + b
print(c) # 13
# 减
c -= b # c = c - b
print(c) # 7
# 乘
c *= b # c = c * b
print(c) # 30
# 除
c /= b # c = c / b
print(c) # 3.3333333333333335
# %=, //=, **= 此处省略3.4 逻辑运算符
逻辑运算符: and, or, not
# 逻辑运算符
x = True
y = False
print(x and y) # False
print(x or y) # True
print(not x) # False3.5 位运算符
位运算符： &, |, ^, ~, <<, >>
# 按位与 (&)，对应位都为1时，结果位为1，否则为0
a = 5 # 二进制：0101
b = 3 # 二进制：0011
result = a & b # 结果：0001，即1
# 按位或 (|)，对应位只要有一个为1，结果位为1。
a = 5 # 二进制：0101
b = 3 # 二进制：0011
result = a | b # 结果：0111，即7
# 按位异或 (^)，对应位不同则结果位为1，相同则为0。
a = 5 # 二进制：0101
b = 3 # 二进制：0011
result = a ^ b # 结果：0110，即6
# 按位取反 (~)，对每个二进制位取反，即0变1，1变0。
a = 5 # 二进制：0101
result = ~a # 结果：1010，即-6（在Python中，按位取反结果为负数是因为使用了补码表示法）
# 左移 (<<)，将二进制位向左移动指定的位数，右侧用0填充。
a = 5 # 二进制：0101
result = a << 1 # 结果：1010，即10
# 右移 (>>)，将二进制位向右移动指定的位数，左侧根据符号位填充（正数填充0，负数填充1）。
a = 5 # 二进制：0101
result = a >> 1 # 结果：0010，即23.6 成员运算符
成员运算符: in, not in
# 成员运算符
fruits = ["apple", "banana", "cherry"]
print("apple" in fruits) # True
print("orange" not in fruits) # True3.7 身份运算符
身份运算符: is, is not
# 身份运算符
a = [1, 2, 3]
b = [1, 2, 3]
c = a
print(a is b) # False
print(a is c) # True4. 控制结构
4.1 条件语句(if,elif,else)
age = 18
if age < 18:
print("未成年")
elif age == 18:
print("刚成年")
else:
print("成年")4.2 循环(for,while)
a. for循环
for循环用于遍历序列（如列表、元组、字符串）。
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)b. while
while循环用于在条件为真时重复执行代码块。
count = 0
while count < 5:
print(count)
count += 14.3 控制循环(break,continue,pass)
a. break 退出循环
for i in range(10):
if i == 5:
break
print(i)b. contionue 跳过当前迭代，继续下一次迭代
for i in range(10):
if i % 2 == 0:
continue
print(i)c. pass 占位符，表示什么都不做
for i in range(10):
if i % 2 == 0:
pass # 占位符，不做任何操作
else:
print(i)5. 函数
5.1 定义函数
使用 def 关键字来定义一个函数，后跟函数名和圆括号内的参数列表。函数体使用缩进来表示。
def 函数名(参数1, 参数2, ...):
# 函数体
# 执行的代码
return 返回值 # 可选示例：
def greet(name):
print(f"你好, {name}!")5.2 调用函数
定义函数后，可以通过函数名和参数来调用它。
greet("小明") # 输出：你好, 小明!5.3 参数
函数可以有多个参数，也可以没有参数。
def add(a, b=10):
return a + b
print(add(5)) # 输出：15，使用默认参数b=10
print(add(5, 3)) # 输出：8，b被显式传递为3
def print_args(*args):
for arg in args:
print(arg)
print_args(1, 2, 3) # 输出：1 2 3
def print_kwargs(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
print_kwargs(name="小明", age=20) # 输出：name: 小明 age: 205.4 返回值
函数可以返回一个或多个值，使用 return 语句。
def square(x):
return x * x
result = square(4)
print(result) # 输出：16
def get_name_and_age():
return "小明", 20
name, age = get_name_and_age()
print(name, age) # 输出：小明 205.5 匿名函数（Lambda）
square = lambda x: x * x
print(square(5)) # 输出：25
add = lambda a, b: a + b
print(add(3, 4)) # 输出：76. 数据结构
6.1 列表(List)
有序、可变的集合。底层基于动态数组。
a. 定义元素
# 定义一个list
fruits = ["apple", "banana", "cherry"]b. 新增元素
# 在末尾添加一个元素
my_list.append(element)
# 在指定位置插入一个元素
my_list.insert(index,element)
# 将另一个列表中的所有元素添加到当前列表末尾
my_list.extend(another_list)举例：
# 假设有两个列表
list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]
# 将list2中的所有元素添加到list1的末尾
list1.extend(list2)
# 输出结果：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list1)c. 删除元素
# 1、pop()方法
# 根据索引删除元素，并返回该元素
# 如果不指定索引，默认删除并返回最后一个元素
# 如果索引超出范围，会引发IndexError
my_list.pop(index)
# 2、remove()方法
# 根据元素的值删除第一个匹配的元素
# 如果元素不存在，会引发ValueError。
my_list.remove(element)
# 3、del语句
# 根据索引删除元素
del my_list[index]举例：
# 假设有一个列表
my_list = [1, 2, 3, 4, 5]
# 1 使用remove()，my_list结果：[1, 2, 4, 5]
my_list.remove(3)
# 2 使用pop()，my_list结果：[1, 2, 4, 5]，removed_element值为3
removed_element = my_list.pop(2) d. 修改元素
# 直接赋值修改指定索引的元素
my_list[index] = new_elemente. 查询元素
# 检查元素是否在列表
if element in my_list:
print("Element is in the list")
# 获取元素的索引
index = my_list.index(element)f. 遍历元素
# for循环
for fruit in fruits:
print(fruit) 6.2 元祖(Tuple)
有序、不可变的集合。
tuple（元组）是一种内置的数据结构，用于存储多个元素。与列表类似，元组可以存储不同类型的数据，但与列表不同的是，元组是不可变的，这意味着一旦创建，就不能修改其内容。
a. 定义元素
# 创建一个空元组
empty_tuple = ()
# 创建一个包含多个元素的元组
my_tuple = (1, 2, 3, "hello")
# 创建一个单元素元组
single_element_tuple = (5,)b. 查询元素
my_tuple = (10, 20, 30)
print(my_tuple[0]) # 输出：10c. 遍历元祖
for item in my_tuple:
print(item)d. 解包元祖
my_tuple = (1, 2, 3)
a, b, c = my_tuple
print(a, b, c) # 输出：1 2 36.3 字典(Dictionary)
键值对集合。
a. 定义元素
# 定义一个键值对
my_dict = {'a': 1, 'b': 2}b. 新增元素
# 新增单个键值对
my_dict['c'] = 3
# 新增多个键值对
my_dict.update({'c': 3, 'd': 4})
# 合并字典
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged_dict = {**dict1, **dict2}c. 删除元素
# del语句，删除键 'b' 及其对应的值
del my_dict['b']
# pop()方法，删除键 'b' 并返回其值
value = my_dict.pop('b')
# 清空字典中的所有键值对
my_dict.clear()d. 修改元素
# 修改
my_dict['key1'] = 'new_value1'e. 查询元素
# 检查键是否存在
if 'key1' in my_dict:
print("Key exists")
# 获取所有键和值
keys = my_dict.keys()
values = my_dict.values()
# 字典长度
length = len(my_dict)f. 遍历元素
# 遍历字典
for key, value in my_dict.items():
print(key, value)
# 遍历key
for key in my_dick:
print(key)
# 遍历value
for value in my_dick.values():
print(value)6.4 集合(Set)
无序、不重复的集合。底层基于Hash表。
集合中的元素是唯一的，因此相同的元素只会存储一次。集合是无序的，因此不能通过索引来访问元素。
a. 定义元素
my_set = {1, 2, 3, 4}
# 或者
my_set = set([1, 2, 3, 4])b. 新增元素
# 添加单个元素
my_set.add(1)
# 添加多个元素
my_set.update(2,3) c. 删除元素
# 删除元素
my_set = {1, 2, 3}
my_set.remove(2) # 删除元素2，删除指定元素，如果元素不存在则会抛出KeyError
my_set.discard(4) # 尝试删除元素4，如果元素不存在也不会抛出错误。
my_set.pop() # 随机删除并返回一个元素，如果集合为空则会抛出KeyError。d. 修改元素
# set是无序且不重复的元素集合，因此不能直接修改其中的某个元素。
# 但是可以通过删除旧元素并添加新元素的方式来达到类似的效果。
my_set = {1, 2, 3}
my_set.remove(2)
my_set.add(5)e. 查询元素
my_set = {1, 2, 3}
if 2 in my_set:
print("2 存在于集合中")
else:
print("2 不存在于集合中")f. 遍历元素
my_set = {1, 2, 3, 4}
for item in my_set:
print(item)7. 文件操作
7.1 读取文件
with open('example.txt', 'r') as file:
content = file.read()
print(content)7.2 写入文件
with open('example.txt', 'w') as file:
file.write("Hello, World!")8. 异常处理
try:
result = 10 / 0
except ZeroDivisionError:
print("除零错误")
finally:
print("执行完毕")9. 模块和包
9.1 导入模块
a. 基本导入
使用 import 关键字导入整个模块。导入后，可以通过 模块名.对象名 的方式访问模块中的对象。
import math
print(math.sqrt(16)) # 输出：4.0b. 导入模块中特定对象
使用 from … import … 语句导入模块中的特定对象（如函数、类、变量等）。导入后，可以直接使用对象名。
from math import sqrt
print(sqrt(16)) # 输出：4.0c. 导入模块中所有对象
使用 from … import * 导入模块中的所有对象。这种方式不推荐使用，因为它可能导致命名冲突。
from math import *
print(sqrt(16)) # 输出：4.0d. 为模块或对象起别名
使用 as 关键字为模块或对象起别名，方便使用。
import math as m
print(m.sqrt(16)) # 输出：4.0
from math import sqrt as square_root
print(square_root(16)) # 输出：4.0e. 导入自定义模块
可以导入同一目录下的自定义模块，或者通过设置 PYTHONPATH 环境变量来导入其他目录中的模块。
# 假设有一个自定义模块 my_module.py
import my_module
my_module.my_function()f. 导入包中的模块
包是一个包含多个模块的目录。可以通过 import 包名.模块名 的方式导入包中的模块。
# 假设有一个包 my_package，里面有一个模块 my_module
import my_package.my_module
my_package.my_module.my_function()g. 相对导入
在包的内部，可以使用相对导入来导入同一包中的其他模块。相对导入使用 . 表示当前目录，.. 表示上一级目录。
# 在包内部模块中
from . import sibling_module # 导入同一包中的 sibling_module
from ..parent_package import parent_module # 导入上一级包中的 parent_moduleh. 从子模块导入
如果模块是一个包（包含多个子模块），可以使用 from … import … 语法从子模块导入
from package.submodule import function
# 使用导入的函数
function()i. 导入包中的所有子模块
如果需要导入一个包中的所有子模块，可以使用 __all__ 列表来指定哪些子模块应该被导入。
# package/__init__.py
__all__ = ['submodule1', 'submodule2']
# main.py
from package import *j. 动态导入
使用 importlib 模块进行动态导入，适用于在运行时决定要导入的模块
import importlib
module_name = 'math'
module = importlib.import_module(module_name)
# 使用动态导入的模块
result = module.sqrt(16)
print(result) # 输出: 4.010. 类（class）和对象（Object）
10.1 类（class）
类是创建对象的蓝图或模板。它定义了一组属性和方法，这些属性和方法是对象所具有的。
a. 定义类
class Dog:
# 类属性
species = "Canis familiaris"
# 初始化方法（构造函数）
def __init__(self, name, age):
# 实例属性
self.name = name
self.age = age
# 实例方法
def bark(self):
return f"{self.name} 说 汪汪!"
def get_age(self):
return f"{self.name} 是 {self.age} 岁"b. 类的组成
i. 类属性：属于类的属性，所有实例共享。
print(Dog.species) # 输出：Canis familiarisii. 实例属性：属于对象的属性，每个实例有独立的值。
print(my_dog.name) # 输出：旺财iii. 方法：定义在类中的函数，用于操作对象的数据
class Dog:
species = "Canis familiaris"
def __init__(self, name, age):
self.name = name
self.age = age
def bark(self):
return f"{self.name} 说 汪汪!"
@classmethod
def get_species(cls):
return cls.species
@staticmethod
def info():
return "狗是人类的好朋友"
print(Dog.get_species()) # 输出：Canis familiaris
print(Dog.info()) # 输出：狗是人类的好朋友10.2 对象（Object）
对象是类的实例。创建对象时，类的 __init__ 方法会被调用，初始化对象的属性。
a. 创建对象
# 创建对象
my_dog = Dog("旺财", 3)
# 访问对象的属性和方法
print(my_dog.name) # 输出：旺财
print(my_dog.age) # 输出：3
print(my_dog.bark()) # 输出：旺财 说 汪汪!
print(my_dog.get_age()) # 输出：旺财 是 3 岁10.3 继承
继承是面向对象编程的重要特性，允许一个类继承另一个类的属性和方法。
class Labrador(Dog):
def retrieve(self, item):
return f"{self.name} retrieves {item}"
my_lab = Labrador("Buddy", 5)
print(my_lab.bark()) # 输出：Buddy 说 汪汪!
print(my_lab.retrieve("球")) # 输出：Buddy retrieves 球11. 命名空间和作用域
11.1 局部作用域
在函数内部定义的变量
11.2 全局作用域
在函数外部定义的变量
x = 10 # 全局变量
def my_function():
y = 5 # 局部变量
print(x + y)
my_function() # 输出: 15
print(y) # 报错: NameError: name 'y' is not defined12. 标准库
Python 提供了丰富的标准库，涵盖文件I/O、系统调用、网络编程、日期和时间等。
12.1 os模块
import os
# 获取当前工作目录
current_directory = os.getcwd()
print(current_directory)
# 列出目录内容
files = os.listdir('.')
print(files)12.2 sys模块
mport sys
# 获取命令行参数
print(sys.argv)
# 退出程序
sys.exit(0)13. 第三方库
13.1 使用 requests 库
import requests
response = requests.get('https://api.github.com')
print(response.status_code) # 200
print(response.json())作者：herogus丶
