python 基础语法和基本概念
目录
注释
标识符
变量
字面量
数据类型转化
运算符
控制流
数据结构
列表操作
元组操作
集合操作
字典操作
字符串操作
本文只记录python的基础语法，方便查阅。
注释
单行注释
使用#符号来注释单行代码。在#之后的所有内容都会被解释器忽略。
# 这是一个单行注释
多行注释
使用三重引号(""")或三个单引号(''')来注释多行代码。这种注释通常用于函数、类或模块级别的说明。
"""
这是一个多行注释的示例。
这里可以写更多的内容来解释代码。
"""
函数注释
在函数定义的行上方使用文档字符串来描述函数的目的、参数和返回值。文档字符串是多行注释的一种特殊形式。
def add_numbers(a, b):
"""
这个函数用于将两个数字相加。
参数：
- a: 第一个数字
- b: 第二个数字
返回值：
两个数字的和
"""
return a + b
类注释
在类定义的行上方使用文档字符串来描述类的目的、属性和方法。文档字符串也是多行注释的一种形式。
class Person:
"""
这个类表示一个人的属性和行为。
属性：
- name: 姓名
- age: 年龄
方法：
- greet(): 打招呼
"""
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
print(f"你好，我是{self.name}，今年{self.age}岁。")
标识符
在Python中，标识符是用于命名变量、函数、类、模块以及其他对象的名称。标识符有一些规则和约定，这些规则和约定包括：
- 标识符由字母、数字和下划线（_）组成。
- 标识符必须以字母（a-z、A-Z）或下划线（_）开头，不能以数字开头。
- 标识符区分大小写，这意味着
myvariable和myVariable是不同的标识符。 - Python关键字（保留字）不能用作标识符，因为它们具有特殊的含义。一些常见的关键字包括
if、else、for、while、class等。
以下是一些有效的Python标识符示例：
my_variable
myVariable
count_1
PI
AnimalClass
以下是一些无效的Python标识符示例：
2variable # 以数字开头
my-variable # 包含连字符
for # 关键字不能用作标识符
class # 关键字不能用作标识符
除了这些基本规则，还有一些命名约定，用于提高代码的可读性。例如，变量名通常使用小写字母，用下划线分隔单词，而类名通常使用大写字母开头的单词，采用驼峰命名法。这些约定不是强制性的，但它们有助于编写更清晰和易于理解的代码。
变量
在Python中，变量是用于存储数据的名称。变量是程序中的标识符，用于引用内存中的数据对象。当您将数据赋给变量时，Python会自动分配内存以存储该数据，并将变量与该内存位置关联。
以下是创建和使用变量的基本规则：
-
变量的命名：变量的命名需要遵循标识符规则，如前面所述。变量名应具有描述性，以便易于理解变量所存储的数据。
-
变量赋值：要将数据分配给变量，使用等号（
=）运算符。例如，x = 10表示将整数值 10 分配给变量x。 -
动态类型：Python是一种动态类型语言，这意味着您不需要显式指定变量的数据类型。Python会根据分配给变量的值自动确定其数据类型。
# 创建一个整数变量
x = 10
# 创建一个字符串变量
name = "Alice"
# 创建一个列表变量
my_list = [1, 2, 3]
# 变量可以随时重新赋值不同类型的数据
x = "Hello"
-
变量引用：在代码中使用变量时，只需使用变量名即可。例如，
print(x)会输出变量x的值。 -
变量的作用域：变量的作用域指的是变量在代码中可见的范围。在函数内部定义的变量只能在该函数内部访问，而在函数外部定义的变量则具有全局作用域，可以在整个程序中访问。
示例：
# 全局作用域
global_var = 100
def my_function():
# 局部作用域
local_var = 50
print(local_var)
my_function()
print(global_var) # 可以访问全局变量
字面量
在Python中，字面量是一种表示数据值的语法表达方式，它们表示不同数据类型的常量值。以下是一些常见的Python字面量：
-
整数字面量：表示整数值的字面量。可以是十进制、八进制（以0o或0O开头）、十六进制（以0x或0X开头）或二进制（以0b或0B开头）。例如：
x = 42 # 十进制 y = 0o52 # 八进制，等于十进制的42 z = 0x2A # 十六进制，等于十进制的42 binary = 0b101010 # 二进制，等于十进制的42 -
浮点数字面量：表示浮点数值的字面量，可以包含小数点。例如：
a = 3.14 b = 2.0 -
字符串字面量：表示文本字符串的字面量，可以使用单引号、双引号或三引号（用于多行字符串）。例如：
s1 = 'Hello, World!' s2 = "Python is great!" s3 = """This is a multi-line string.""" -
布尔字面量：表示布尔值的字面量，只有两个值：
True和False。is_true = True is_false = False -
None 字面量：表示空值的字面量，用于表示缺少值或占位符。
empty_value = None -
列表字面量：表示列表数据结构的字面量，使用方括号
[]包围元素。my_list = [1, 2, 3] -
字典字面量：表示字典数据结构的字面量，使用花括号
{}包围键-值对。my_dict = {"name": "Alice", "age": 30} -
集合字面量：表示集合数据结构的字面量，使用花括号
{}包围元素，但没有键-值对。my_set = {1, 2, 3}
数据类型转化
在Python中，您可以进行不同数据类型之间的转换，以满足特定的需求。以下是一些常见的数据类型转换方法：
-
隐式类型转换：在某些情况下，Python会自动进行隐式类型转换，以使表达式成立。例如，在整数和浮点数之间的运算会将整数转换为浮点数。
x = 5 y = 2.0 z = x + y # x会隐式转换为浮点数，z的值为 7.0 -
显式类型转换：您可以使用内置函数来执行显式的类型转换。以下是一些常见的类型转换函数：
-
int()：将一个值转换为整数类型。
x = 3.7 y = int(x) # y的值为 3 -
float()：将一个值转换为浮点数类型。
x = 5 y = float(x) # y的值为 5.0 -
str()：将一个值转换为字符串类型。
x = 42 y = str(x) # y的值为 "42" -
list()：将一个可迭代对象（如元组、字符串或集合）转换为列表。
tpl = (1, 2, 3) lst = list(tpl) # lst的值为 [1, 2, 3] -
tuple()：将一个可迭代对象转换为元组。
lst = [1, 2, 3] tpl = tuple(lst) # tpl的值为 (1, 2, 3) -
set()：将一个可迭代对象转换为集合。
lst = [1, 2, 2, 3, 3] st = set(lst) # st的值为 {1, 2, 3} -
dict()：将可迭代对象中的键-值对转换为字典。
pairs = [("a", 1), ("b", 2)] d = dict(pairs) # d的值为 {'a': 1, 'b': 2}
-
-
请注意，进行显式类型转换时，确保数据能够合理地转换为目标类型，否则可能会引发异常。例如，将无法将非整数字符串转换为整数。类型转换通常用于确保正确的数据处理和运算。
运算符
在Python中，运算符是用于执行各种数学和逻辑操作的特殊符号或关键词。Python支持多种不同类型的运算符，包括算术运算符、比较运算符、逻辑运算符、赋值运算符等。以下是常见的运算符及其用法：
-
算术运算符：
+：加法-：减法*：乘法/：除法%：取余（模运算）//：整数除法**：幂运算a = 10 b = 3 c = a + b # 13 d = a / b # 3.3333 e = a % b # 1 f = a // b # 3 g = a ** b # 1000
-
比较运算符：
==：等于!=：不等于<：小于>：大于<=：小于等于>=：大于等于
比较运算符返回布尔值（
True或False）：x = 5 y = 10 result1 = x == y # False result2 = x < y # True -
逻辑运算符：
and：逻辑与or：逻辑或not：逻辑非
逻辑运算符通常用于组合布尔表达式：
a = True b = False result1 = a and b # False result2 = a or b # True result3 = not a # False -
赋值运算符：
=：赋值+=：加法赋值-=：减法赋值*=：乘法赋值/=：除法赋值%=：取余赋值//=：整数除法赋值**=：幂赋值
赋值运算符用于将右侧表达式的值赋给左侧的变量：
x = 5 x += 2 # 等同于 x = x + 2，x的值变为7 -
成员运算符：
in：用于检查某个元素是否存在于序列（如列表、字符串、元组等）中。not in：用于检查某个元素是否不存在于序列中。
my_list = [1, 2, 3, 4, 5] result1 = 3 in my_list # True result2 = 6 not in my_list # True -
身份运算符：
is：用于检查两个对象是否是同一个对象。is not：用于检查两个对象是否不是同一个对象。
a = [1, 2, 3] b = a result1 = a is b # True result2 = a is not b # False
控制流
Python的控制流是一组结构和语句，用于管理程序的执行流程。控制流可以分为以下几个主要方面：
-
条件语句（if、elif、else）：
条件语句允许根据条件的真假来执行不同的代码块。以下是条件语句的基本结构：
if condition: # 如果条件为真，执行这里的代码 elif another_condition: # 如果另一个条件为真，执行这里的代码 else: # 如果以上条件都不为真，执行这里的代码 x = 10 if x > 5: print("x 大于 5") elif x == 5: print("x 等于 5") else: print("x 小于 5") -
循环语句（for、while）：
循环语句允许多次执行一组代码块。以下是两种主要类型的循环：
-
for循环：用于遍历可迭代对象（如列表、元组、字符串等）中的元素。
if condition: # 如果条件为真，执行这里的代码 elif another_condition: # 如果另一个条件为真，执行这里的代码 else: # 如果以上条件都不为真，执行这里的代码 x = 10 if x > 5: print("x 大于 5") elif x == 5: print("x 等于 5") else: print("x 小于 5") -
while循环：根据条件的真假来执行一组代码块，直到条件变为假。
while condition: # 只要条件为真，就执行这里的代码 count = 0 while count < 5: print(count) count += 1
-
-
控制循环：
break：用于退出当前循环。continue：用于跳过当前循环迭代，继续下一次迭代。
for i in range(1, 10): if i % 2 == 0: continue # 跳过偶数 print(i) if i == 5: break # 退出循环 -
异常处理（try、except）：
异常处理允许您捕获和处理运行时错误，以避免程序崩溃。以下是异常处理的基本结构：
try: # 尝试执行可能引发异常的代码 except ExceptionType as e: # 处理异常的代码 else: # 如果没有发生异常，执行这里的代码 finally: # 无论是否发生异常，都执行这里的代码 try: result = 10 / 0 except ZeroDivisionError as e: print("除以零错误:", e) else: print("结果:", result) finally: print("异常处理完成")
数据结构
在Python中，数据结构用于存储和组织数据，使其易于访问和操作。Python提供了多种内置的数据结构，包括以下一些常见的：
-
列表（List）：列表是有序的可变序列，用于存储多个元素。列表使用方括号
[]表示，元素之间用逗号分隔。 -
元组（Tuple）：元组是有序的不可变序列，用于存储多个元素。元组使用圆括号
()表示，元素之间用逗号分隔。 -
集合（Set）：集合是无序的独立元素的集合，用于存储唯一的元素。集合使用花括号
{}表示，元素之间用逗号分隔。 -
字典（Dictionary）：字典是键-值对的集合，用于存储映射关系。字典使用花括号
{}表示，键和值之间使用冒号:分隔，键-值对之间用逗号分隔。 -
字符串（String）：字符串是字符序列，用于存储文本数据。字符串可以用单引号
''、双引号""或三引号'''表示。 -
栈（Stack）：栈是一种后进先出（LIFO）的数据结构，通常用于管理函数调用、表达式求值等。
-
队列（Queue）：队列是一种先进先出（FIFO）的数据结构，通常用于任务调度等。
-
堆（Heap）：堆是一种用于优先级队列和堆排序的数据结构。
-
链表（Linked List）：链表是一种动态数据结构，通常用于构建其他数据结构。
-
树（Tree）：树是一种层次结构，包括二叉树、二叉搜索树、堆、树等。
-
图（Graph）：图是一种用于表示各种关系的数据结构，包括有向图和无向图。
-
其他：Python还支持自定义数据结构，如命名元组、命名空间、枚举等。
列表操作
在Python中，列表（List）是一种有序的可变数据结构，用于存储一组元素。您可以执行各种操作来创建、访问、修改和处理列表。以下是一些常见的列表操作：
-
创建列表：
您可以使用方括号
[]来创建一个列表，并在其中包含元素。例如：my_list = [1, 2, 3, 4, 5] -
访问列表元素：
您可以使用索引来访问列表中的元素，索引从0开始。例如，
my_list[0]访问第一个元素，my_list[1]访问第二个元素，以此类推。 -
列表切片：
使用切片操作可以访问列表的一部分。语法为
list[start:end]，其中start是起始索引，end是结束索引（不包括）。例如：sub_list = my_list[1:4] # 获取索引1到3的元素，结果为 [2, 3, 4] -
修改列表元素：
列表是可变的，可以通过索引赋值来修改元素的值。例如：
my_list[2] = 100 # 将第三个元素修改为100 -
添加元素：
使用
append()方法可以在列表末尾添加元素。例如：my_list.append(6) # 添加元素6到列表末尾 -
插入元素：
使用
insert()方法可以在指定位置插入元素。例如：my_list.insert(2, 7) # 在索引2处插入元素7 -
删除元素：
使用
remove()方法可以删除指定值的元素，使用pop()方法可以删除指定索引的元素，或者使用del语句删除指定索引的元素。例如：my_list.remove(4) # 删除值为4的元素 my_list.pop(2) # 删除索引为2的元素 del my_list[0] # 删除第一个元素 -
查找元素：
使用
index()方法可以查找元素的索引，使用in运算符可以检查元素是否在列表中。例如：index = my_list.index(3) # 查找元素3的索引 is_present = 4 in my_list # 检查元素4是否在列表中 -
列表长度：
使用
len()函数可以获取列表的长度（元素个数）。例如：length = len(my_list) # 获取列表长度 -
列表操作：
列表支持多种操作，如连接两个列表、重复列表、排序、反转等。例如：
new_list = my_list + [6, 7] # 连接两个列表 repeated_list = my_list * 2 # 重复列表 my_list.sort() # 排序列表 my_list.reverse() # 反转列表
元组操作
元组（Tuple）是Python中的有序不可变数据结构，它类似于列表，但不支持修改元素。以下是一些常见的元组操作：
-
创建元组：
您可以使用圆括号
()来创建一个元组，并在其中包含元素。例如：my_tuple = (1, 2, 3, 4, 5)或者，如果元组只包含一个元素，需要在元素后面添加逗号，以区分它和普通的括号：
single_element_tuple = (42,) -
访问元组元素：
您可以使用索引来访问元组中的元素，索引仍然从0开始。例如，
my_tuple[0]访问第一个元素，my_tuple[1]访问第二个元素，以此类推。 -
元组切片：
使用切片操作可以访问元组的一部分，语法为
tuple[start:end]，其中start是起始索引，end是结束索引（不包括）。例如：sub_tuple = my_tuple[1:4] # 获取索引1到3的元素，结果为 (2, 3, 4) -
元组拆包：
您可以将元组中的元素赋值给多个变量，以便分别访问各个元素。这被称为元组拆包。例如：
a, b, c = my_tuple # 将元组的元素分配给变量a、b和c -
元组合并：
使用
+运算符可以将两个元组合并为一个新元组。例如：new_tuple = my_tuple + (6, 7) # 合并两个元组 -
元组重复：
使用
*运算符可以重复元组中的元素多次。例如：repeated_tuple = my_tuple * 2 # 重复元组 -
查找元组元素：
使用
index()方法可以查找元素的索引，使用in运算符可以检查元素是否在元组中。例如：index = my_tuple.index(3) # 查找元素3的索引 is_present = 4 in my_tuple # 检查元素4是否在元组中 -
元组长度：
使用
len()函数可以获取元组的长度（元素个数）。例如：length = len(my_tuple) # 获取元组长度
集合操作
在Python中，集合（Set）是一种无序且具有唯一性的数据结构，用于存储不重复的元素。集合提供了多种操作，以便处理和操作集合中的数据。以下是一些常见的集合操作：
-
创建集合：
您可以使用花括号
{}或set()构造函数来创建一个集合。例如：my_set = {1, 2, 3, 4, 5} -
添加元素：
使用
add()方法可以向集合中添加元素。元素必须是唯一的，如果添加已存在的元素，它将被忽略。例如：my_set.add(6) # 添加元素6到集合 -
删除元素：
使用
remove()方法可以从集合中删除指定元素，如果元素不存在，将引发KeyError异常。使用discard()方法可以删除元素，但如果元素不存在，不会引发异常。例如：my_set.remove(4) # 删除元素4 my_set.discard(7) # 删除元素7（如果存在） -
清空集合：
使用
clear()方法可以清空集合中的所有元素。例如：my_set.clear() # 清空集合 -
集合操作：
集合支持各种操作，如并集、交集、差集等，可以使用相关方法来执行这些操作。例如：
- 并集：
union() - 交集：
intersection() - 差集：
difference() - 对称差集：
symmetric_difference()
示例：
set1 = {1, 2, 3} set2 = {3, 4, 5} union_set = set1.union(set2) # 并集 intersection_set = set1.intersection(set2) # 交集 difference_set = set1.difference(set2) # 差集 symmetric_difference_set = set1.symmetric_difference(set2) # 对称差集 - 并集：
-
子集和超集检查：
使用
issubset()和issuperset()方法可以检查一个集合是否是另一个集合的子集或超集。例如：subset_check = set1.issubset(set2) # 检查set1是否是set2的子集 superset_check = set1.issuperset(set2) # 检查set1是否是set2的超集 -
集合长度：
使用
len()函数可以获取集合的长度（元素个数）。例如：length = len(my_set) # 获取集合长度 -
转换为列表：
使用
list()函数可以将集合转换为列表。例如：my_list = list(my_set) # 将集合转换为列表
字典操作
字典（Dictionary）是Python中的一种数据结构，用于存储键-值对的集合，键是唯一的，用于快速查找值。以下是一些常见的字典操作：
-
创建字典：
您可以使用花括号
{}来创建一个字典，其中包含键-值对。例如：my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'} -
访问字典值：
您可以使用键来访问字典中的值。例如，
my_dict['name']返回键'name'对应的值'Alice'。 -
添加或修改键值对：
使用赋值语句可以添加或修改字典中的键值对。例如：
my_dict['gender'] = 'Female' # 添加新的键值对 my_dict['age'] = 31 # 修改年龄的值 -
删除键值对：
使用
del语句可以删除字典中的键值对。例如：del my_dict['city'] # 删除'city'键值对 -
检查键是否存在：
使用
in运算符可以检查键是否存在于字典中。例如：if 'name' in my_dict: print("Name is in the dictionary.") -
获取所有键、所有值和键值对：
使用
keys()方法可以获取字典中的所有键，使用values()方法可以获取所有值，使用items()方法可以获取所有键值对。例如：keys = my_dict.keys() # 获取所有键 values = my_dict.values() # 获取所有值 items = my_dict.items() # 获取所有键值对 -
遍历字典：
使用
for循环可以遍历字典中的键，然后使用键来获取相应的值。例如：for key in my_dict: value = my_dict[key] print(key, value)或者，使用
items()方法可以遍历键值对：for key, value in my_dict.items(): print(key, value) -
复制字典：
使用
copy()方法可以复制一个字典，创建一个新的字典。例如：new_dict = my_dict.copy() # 复制字典 -
清空字典：
使用
clear()方法可以清空字典中的所有键值对。例如：my_dict.clear() # 清空字典
字符串操作
在Python中，字符串（String）是一种常见的数据类型，用于存储文本数据。Python提供了许多字符串操作方法，以便处理和操作字符串数据。以下是一些常见的字符串操作：
-
创建字符串：
您可以使用单引号
''、双引号""或三引号'''来创建字符串。例如：my_string = "Hello, World!" -
字符串连接：
使用
+运算符可以将两个字符串连接在一起。例如：string1 = "Hello" string2 = "World" combined_string = string1 + ", " + string2 # 连接两个字符串 -
字符串重复：
使用
*运算符可以重复一个字符串多次。例如：repeated_string = "ABC" * 3 # 重复字符串3次 -
字符串长度：
使用
len()函数可以获取字符串的长度（字符数）。例如：length = len(my_string) # 获取字符串长度 -
字符串索引和切片：
您可以使用索引来访问字符串中的单个字符，索引从0开始。还可以使用切片操作来访问字符串的一部分。例如：
first_char = my_string[0] # 获取字符串的第一个字符 sub_string = my_string[7:12] # 获取索引7到11的子字符串 -
字符串查找：
使用
find()方法可以查找子字符串在主字符串中的位置，或者使用in运算符来检查子字符串是否存在。例如：index = my_string.find("World") # 查找子字符串的位置 is_present = "Hello" in my_string # 检查子字符串是否存在 -
字符串替换：
使用
replace()方法可以替换字符串中的子字符串。例如：new_string = my_string.replace("World", "Python") # 替换子字符串 -
字符串分割：
使用
split()方法可以将字符串拆分成子字符串列表，根据指定的分隔符。例如：words = my_string.split(", ") # 使用逗号和空格分割字符串 -
字符串格式化：
使用字符串的
format()方法或f-strings可以将变量的值插入到字符串中，以创建格式化字符串。例如：name = "Alice" age = 30 formatted_string = "My name is {} and I am {} years old.".format(name, age)或使用f-strings：
formatted_string = f"My name is {name} and I am {age} years old." -
字符串大小写转换：
使用
upper()方法可以将字符串转为大写，使用lower()方法可以将字符串转为小写。例如：uppercase_string = my_string.upper() # 转为大写 lowercase_string = my_string.lower() # 转为小写