【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) # 1000

3.2 比较运算符

比较运算符：==, !=, >, <, >=, <=

# 比较运算符
print(a > b)  # True
print(a < b)  # False

3.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)    # False

3.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，即2

3.6 成员运算符

成员运算符: in, not in

# 成员运算符
fruits = ["apple", "banana", "cherry"]
print("apple" in fruits)  # True
print("orange" not in fruits)  # True

3.7 身份运算符

身份运算符: is, is not

# 身份运算符
a = [1, 2, 3]
b = [1, 2, 3]
c = a
print(a is b)  # False
print(a is c)  # True

4. 控制结构

4.1 条件语句(if,elif,else)

age = 18if 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 += 1

4.3 控制循环(break,continue,pass)

a. break 退出循环

for i in range(10):if i == 5:breakprint(i)

b. contionue 跳过当前迭代，继续下一次迭代

for i in range(10):if i % 2 == 0:continueprint(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 参数

函数可以有多个参数，也可以没有参数。

位置参数：按顺序传递的参数。
关键字参数：通过参数名传递的参数。
默认参数：在定义函数时为参数提供默认值。
可变参数：使用 *args 和 **kwargs 来接收多个位置参数和关键字参数。

def add(a, b=10):return a + bprint(add(5))        # 输出：15，使用默认参数b=10
print(add(5, 3))     # 输出：8，b被显式传递为3def print_args(*args):for arg in args:print(arg)print_args(1, 2, 3)  # 输出：1 2 3def print_kwargs(**kwargs):for key, value in kwargs.items():print(f"{key}: {value}")print_kwargs(name="小明", age=20)  # 输出：name: 小明  age: 20

5.4 返回值

函数可以返回一个或多个值，使用 return 语句。

def square(x):return x * xresult = square(4)
print(result)  # 输出：16def get_name_and_age():return "小明", 20name, age = get_name_and_age()
print(name, age)  # 输出：小明 20

5.5 匿名函数（Lambda）

square = lambda x: x * x
print(square(5))  # 输出：25add = lambda a, b: a + b
print(add(3, 4))  # 输出：7

6. 数据结构

6.1 列表(List)

有序、可变的集合。底层基于动态数组。

a. 定义元素

# 定义一个list
fruits = ["apple", "banana", "cherry"]

b. 新增元素

# 在末尾添加一个元素
my_list.append(element)
# 在指定位置插入一个元素
my_list.append(element)
# 将另一个列表中的所有元素添加到当前列表末尾
my_list.extend(another_list)

c. 删除元素

# 删除元素
my_list.extend(another_list)
# 删除第一个匹配的元素
my_list.remove(element)
# 根据索引删除元素
del my_list[index]

d. 修改元素

# 直接赋值修改指定索引的元素
my_list[index] = new_element

e. 查询元素

# 检查元素是否在列表
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])  # 输出：10

c. 遍历元祖

for item in my_tuple:print(item)

d. 解包元祖

可以将元组中的元素解包到多个变量中。

my_tuple = (1, 2, 3)
a, b, c = my_tuple
print(a, b, c)  # 输出：1 2 3

6.3 字典(Dictionary)

键值对集合。

a. 定义元素

# 定义一个键值对
my_dict = {'key1': 'value1', 'key2': 'value2'}

b. 新增元素

# 新增
my_dict['key3'] = 'value3' 
# 合并字典
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
merged_dict = {**dict1, **dict2}

c. 删除元素

# 删除
del my_dict['key2']

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. 新增元素

s.add(1)    # 添加单个元素
s.update(2,3) # 添加多个元素

c. 删除元素

# 删除元素
s = {1, 2, 3}
s.remove(2)       # 删除元素2，删除指定元素，如果元素不存在则会抛出KeyError
s.discard(4)      # 尝试删除元素4，如果元素不存在也不会抛出错误。
s.pop()           # 随机删除并返回一个元素，如果集合为空则会抛出KeyError。

d. 修改元素

# set是无序且不重复的元素集合，因此不能直接修改其中的某个元素。
# 但是可以通过删除旧元素并添加新元素的方式来达到类似的效果。
s = {1, 2, 3}
s.remove(2)
s.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.0

b. 导入模块中特定对象

使用 from ... import ... 语句导入模块中的特定对象（如函数、类、变量等）。导入后，可以直接使用对象名。

from math import sqrt
print(sqrt(16))  # 输出：4.0

c. 导入模块中所有对象

使用 from ... import * 导入模块中的所有对象。这种方式不推荐使用，因为它可能导致命名冲突。

from math import *
print(sqrt(16))  # 输出：4.0

d. 为模块或对象起别名

使用 as 关键字为模块或对象起别名，方便使用。

import math as m
print(m.sqrt(16))  # 输出：4.0from math import sqrt as square_root
print(square_root(16))  # 输出：4.0

e. 导入自定义模块

可以导入同一目录下的自定义模块，或者通过设置 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_module

h. 从子模块导入

如果模块是一个包（包含多个子模块），可以使用 from ... import ... 语法从子模块导入

from package.submodule import function# 使用导入的函数
function()

i. 导入包中的所有子模块

如果需要导入一个包中的所有子模块，可以使用 __all__ 列表来指定哪些子模块应该被导入。

# package/__init__.py
__all__ = ['submodule1', 'submodule2']# main.py
from package import *

j. 动态导入

使用 importlib 模块进行动态导入，适用于在运行时决定要导入的模块

import importlibmodule_name = 'math'
module = importlib.import_module(module_name)# 使用动态导入的模块
result = module.sqrt(16)
print(result)  # 输出: 4.0

10. 类（class）和对象（Object）

10.1 类（class）

类是创建对象的蓝图或模板。它定义了一组属性和方法，这些属性和方法是对象所具有的。

a. 定义类

class Dog:# 类属性species = "Canis familiaris"# 初始化方法（构造函数）def __init__(self, name, age):# 实例属性self.name = nameself.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 familiaris

ii. 实例属性：属于对象的属性，每个实例有独立的值。

print(my_dog.name)  # 输出：旺财

iii. 方法：定义在类中的函数，用于操作对象的数据

实例方法：第一个参数通常是 self，用于引用调用该方法的实例。
类方法：使用 @classmethod 装饰器，第一个参数是 cls，用于引用类本身。
静态方法：使用 @staticmethod 装饰器，不需要 self 或 cls 参数。

class Dog:species = "Canis familiaris"def __init__(self, name, age):self.name = nameself.age = agedef bark(self):return f"{self.name} 说 汪汪!"@classmethoddef get_species(cls):return cls.species@staticmethoddef 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 defined

12. 标准库

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 requestsresponse = requests.get('https://api.github.com')
print(response.status_code)  # 200
print(response.json())