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中，标识符是用于命名变量、函数、类、模块以及其他对象的名称。标识符有一些规则和约定，这些规则和约定包括：

1. 标识符由字母、数字和下划线（_）组成。
2. 标识符必须以字母（a-z、A-Z）或下划线（_）开头，不能以数字开头。
3. 标识符区分大小写，这意味着myvariable和myVariable是不同的标识符。
4. Python关键字（保留字）不能用作标识符，因为它们具有特殊的含义。一些常见的关键字包括if、else、for、while、class等。

以下是一些有效的Python标识符示例：

my_variable
myVariable
count_1
PI
AnimalClass

以下是一些无效的Python标识符示例：

2variable  # 以数字开头
my-variable  # 包含连字符
for  # 关键字不能用作标识符
class  # 关键字不能用作标识符

除了这些基本规则，还有一些命名约定，用于提高代码的可读性。例如，变量名通常使用小写字母，用下划线分隔单词，而类名通常使用大写字母开头的单词，采用驼峰命名法。这些约定不是强制性的，但它们有助于编写更清晰和易于理解的代码。

变量

在Python中，变量是用于存储数据的名称。变量是程序中的标识符，用于引用内存中的数据对象。当您将数据赋给变量时，Python会自动分配内存以存储该数据，并将变量与该内存位置关联。

以下是创建和使用变量的基本规则：

1. 变量的命名：变量的命名需要遵循标识符规则，如前面所述。变量名应具有描述性，以便易于理解变量所存储的数据。

2. 变量赋值：要将数据分配给变量，使用等号（=）运算符。例如，x = 10 表示将整数值 10 分配给变量 x。

3. 动态类型：Python是一种动态类型语言，这意味着您不需要显式指定变量的数据类型。Python会根据分配给变量的值自动确定其数据类型。

# 创建一个整数变量
x = 10
 
# 创建一个字符串变量
name = "Alice"
 
# 创建一个列表变量
my_list = [1, 2, 3]
 
# 变量可以随时重新赋值不同类型的数据
x = "Hello"

1. 变量引用：在代码中使用变量时，只需使用变量名即可。例如，print(x) 会输出变量 x 的值。

2. 变量的作用域：变量的作用域指的是变量在代码中可见的范围。在函数内部定义的变量只能在该函数内部访问，而在函数外部定义的变量则具有全局作用域，可以在整个程序中访问。

示例：

# 全局作用域
global_var = 100
 
def my_function():
    # 局部作用域
    local_var = 50
    print(local_var)
 
my_function()
print(global_var)  # 可以访问全局变量

字面量

在Python中，字面量是一种表示数据值的语法表达方式，它们表示不同数据类型的常量值。以下是一些常见的Python字面量：

1. 整数字面量：表示整数值的字面量。可以是十进制、八进制（以0o或0O开头）、十六进制（以0x或0X开头）或二进制（以0b或0B开头）。例如：

   x = 42  # 十进制
   y = 0o52  # 八进制，等于十进制的42
   z = 0x2A  # 十六进制，等于十进制的42
   binary = 0b101010  # 二进制，等于十进制的42
   

2. 浮点数字面量：表示浮点数值的字面量，可以包含小数点。例如：

   a = 3.14
   b = 2.0
   

3. 字符串字面量：表示文本字符串的字面量，可以使用单引号、双引号或三引号（用于多行字符串）。例如：

   s1 = 'Hello, World!'
   s2 = "Python is great!"
   s3 = """This is a
   multi-line string."""
   

4. 布尔字面量：表示布尔值的字面量，只有两个值：True 和 False。

   is_true = True
   is_false = False
   

5. None 字面量：表示空值的字面量，用于表示缺少值或占位符。

   empty_value = None
   

6. 列表字面量：表示列表数据结构的字面量，使用方括号 [] 包围元素。

   my_list = [1, 2, 3]
   

7. 字典字面量：表示字典数据结构的字面量，使用花括号 {} 包围键-值对。

   my_dict = {"name": "Alice", "age": 30}
   

8. 集合字面量：表示集合数据结构的字面量，使用花括号 {} 包围元素，但没有键-值对。

   my_set = {1, 2, 3}
   

数据类型转化

在Python中，您可以进行不同数据类型之间的转换，以满足特定的需求。以下是一些常见的数据类型转换方法：

1. 隐式类型转换：在某些情况下，Python会自动进行隐式类型转换，以使表达式成立。例如，在整数和浮点数之间的运算会将整数转换为浮点数。

   x = 5
   y = 2.0
   z = x + y  # x会隐式转换为浮点数，z的值为 7.0
   

2. 显式类型转换：您可以使用内置函数来执行显式的类型转换。以下是一些常见的类型转换函数：

   • 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}
     

3. 请注意，进行显式类型转换时，确保数据能够合理地转换为目标类型，否则可能会引发异常。例如，将无法将非整数字符串转换为整数。类型转换通常用于确保正确的数据处理和运算。

运算符

在Python中，运算符是用于执行各种数学和逻辑操作的特殊符号或关键词。Python支持多种不同类型的运算符，包括算术运算符、比较运算符、逻辑运算符、赋值运算符等。以下是常见的运算符及其用法：

1. 算术运算符：

   • +：加法
   • -：减法
   • *：乘法
   • /：除法
   • %：取余（模运算）
   • //：整数除法
   • **：幂运算

     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
     

2. 比较运算符：

   • ==：等于
   • !=：不等于
   • <：小于
   • >：大于
   • <=：小于等于
   • >=：大于等于

   比较运算符返回布尔值（True 或 False）：

   x = 5
   y = 10
   result1 = x == y  # False
   result2 = x < y   # True
   

3. 逻辑运算符：

   • and：逻辑与
   • or：逻辑或
   • not：逻辑非

   逻辑运算符通常用于组合布尔表达式：

   a = True
   b = False
   result1 = a and b  # False
   result2 = a or b   # True
   result3 = not a    # False
   

4. 赋值运算符：

   • =：赋值
   • +=：加法赋值
   • -=：减法赋值
   • *=：乘法赋值
   • /=：除法赋值
   • %=：取余赋值
   • //=：整数除法赋值
   • **=：幂赋值

   赋值运算符用于将右侧表达式的值赋给左侧的变量：

   x = 5
   x += 2  # 等同于 x = x + 2，x的值变为7
   

5. 成员运算符：

   • in：用于检查某个元素是否存在于序列（如列表、字符串、元组等）中。
   • not in：用于检查某个元素是否不存在于序列中。

   my_list = [1, 2, 3, 4, 5]
   result1 = 3 in my_list  # True
   result2 = 6 not in my_list  # True
   

6. 身份运算符：

   • is：用于检查两个对象是否是同一个对象。
   • is not：用于检查两个对象是否不是同一个对象。

   a = [1, 2, 3]
   b = a
   result1 = a is b  # True
   result2 = a is not b  # False
   

控制流

Python的控制流是一组结构和语句，用于管理程序的执行流程。控制流可以分为以下几个主要方面：

1. 条件语句（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")
   

2. 循环语句（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
     

3. 控制循环：

   • break：用于退出当前循环。
   • continue：用于跳过当前循环迭代，继续下一次迭代。

   for i in range(1, 10):
       if i % 2 == 0:
           continue  # 跳过偶数
       print(i)
       if i == 5:
           break  # 退出循环
   

4. 异常处理（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提供了多种内置的数据结构，包括以下一些常见的：

1. 列表（List）：列表是有序的可变序列，用于存储多个元素。列表使用方括号 [] 表示，元素之间用逗号分隔。

2. 元组（Tuple）：元组是有序的不可变序列，用于存储多个元素。元组使用圆括号 () 表示，元素之间用逗号分隔。

3. 集合（Set）：集合是无序的独立元素的集合，用于存储唯一的元素。集合使用花括号 {} 表示，元素之间用逗号分隔。

4. 字典（Dictionary）：字典是键-值对的集合，用于存储映射关系。字典使用花括号 {} 表示，键和值之间使用冒号 : 分隔，键-值对之间用逗号分隔。

5. 字符串（String）：字符串是字符序列，用于存储文本数据。字符串可以用单引号 ''、双引号 "" 或三引号 ''' 表示。

6. 栈（Stack）：栈是一种后进先出（LIFO）的数据结构，通常用于管理函数调用、表达式求值等。

7. 队列（Queue）：队列是一种先进先出（FIFO）的数据结构，通常用于任务调度等。

8. 堆（Heap）：堆是一种用于优先级队列和堆排序的数据结构。

9. 链表（Linked List）：链表是一种动态数据结构，通常用于构建其他数据结构。

10. 树（Tree）：树是一种层次结构，包括二叉树、二叉搜索树、堆、树等。

11. 图（Graph）：图是一种用于表示各种关系的数据结构，包括有向图和无向图。

12. 其他：Python还支持自定义数据结构，如命名元组、命名空间、枚举等。

列表操作

在Python中，列表（List）是一种有序的可变数据结构，用于存储一组元素。您可以执行各种操作来创建、访问、修改和处理列表。以下是一些常见的列表操作：

1. 创建列表：

   您可以使用方括号 [] 来创建一个列表，并在其中包含元素。例如：

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

2. 访问列表元素：

   您可以使用索引来访问列表中的元素，索引从0开始。例如，my_list[0] 访问第一个元素，my_list[1] 访问第二个元素，以此类推。

3. 列表切片：

   使用切片操作可以访问列表的一部分。语法为 list[start:end]，其中 start 是起始索引，end 是结束索引（不包括）。例如：

   sub_list = my_list[1:4] # 获取索引1到3的元素，结果为 [2, 3, 4]
   

4. 修改列表元素：

   列表是可变的，可以通过索引赋值来修改元素的值。例如：

   my_list[2] = 100 # 将第三个元素修改为100
   

5. 添加元素：

   使用 append() 方法可以在列表末尾添加元素。例如：

   my_list.append(6) # 添加元素6到列表末尾
   

6. 插入元素：

   使用 insert() 方法可以在指定位置插入元素。例如：

   my_list.insert(2, 7) # 在索引2处插入元素7
   

7. 删除元素：

   使用 remove() 方法可以删除指定值的元素，使用 pop() 方法可以删除指定索引的元素，或者使用 del 语句删除指定索引的元素。例如：

   my_list.remove(4) # 删除值为4的元素 
   my_list.pop(2) # 删除索引为2的元素 
   del my_list[0] # 删除第一个元素
   

8. 查找元素：

   使用 index() 方法可以查找元素的索引，使用 in 运算符可以检查元素是否在列表中。例如：

   index = my_list.index(3) # 查找元素3的索引 
   is_present = 4 in my_list # 检查元素4是否在列表中
   

9. 列表长度：

   使用 len() 函数可以获取列表的长度（元素个数）。例如：

   length = len(my_list) # 获取列表长度
   

10. 列表操作：

    列表支持多种操作，如连接两个列表、重复列表、排序、反转等。例如：

    new_list = my_list + [6, 7] # 连接两个列表 
    repeated_list = my_list * 2 # 重复列表 
    my_list.sort() # 排序列表 
    my_list.reverse() # 反转列表
    

元组操作

元组（Tuple）是Python中的有序不可变数据结构，它类似于列表，但不支持修改元素。以下是一些常见的元组操作：

1. 创建元组：

   您可以使用圆括号 () 来创建一个元组，并在其中包含元素。例如：

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

   或者，如果元组只包含一个元素，需要在元素后面添加逗号，以区分它和普通的括号：

   single_element_tuple = (42,)
   

2. 访问元组元素：

   您可以使用索引来访问元组中的元素，索引仍然从0开始。例如，my_tuple[0] 访问第一个元素，my_tuple[1] 访问第二个元素，以此类推。

3. 元组切片：

   使用切片操作可以访问元组的一部分，语法为 tuple[start:end]，其中 start 是起始索引，end 是结束索引（不包括）。例如：

   sub_tuple = my_tuple[1:4] # 获取索引1到3的元素，结果为 (2, 3, 4)
   

4. 元组拆包：

   您可以将元组中的元素赋值给多个变量，以便分别访问各个元素。这被称为元组拆包。例如：

   a, b, c = my_tuple # 将元组的元素分配给变量a、b和c
   

5. 元组合并：

   使用 + 运算符可以将两个元组合并为一个新元组。例如：

   new_tuple = my_tuple + (6, 7) # 合并两个元组
   

6. 元组重复：

   使用 * 运算符可以重复元组中的元素多次。例如：

   repeated_tuple = my_tuple * 2 # 重复元组
   

7. 查找元组元素：

   使用 index() 方法可以查找元素的索引，使用 in 运算符可以检查元素是否在元组中。例如：

   index = my_tuple.index(3) # 查找元素3的索引 
   is_present = 4 in my_tuple # 检查元素4是否在元组中
   

8. 元组长度：

   使用 len() 函数可以获取元组的长度（元素个数）。例如：

   length = len(my_tuple) # 获取元组长度
   

集合操作

在Python中，集合（Set）是一种无序且具有唯一性的数据结构，用于存储不重复的元素。集合提供了多种操作，以便处理和操作集合中的数据。以下是一些常见的集合操作：

1. 创建集合：

   您可以使用花括号 {} 或 set() 构造函数来创建一个集合。例如：

   my_set = {1, 2, 3, 4, 5}
   

2. 添加元素：

   使用 add() 方法可以向集合中添加元素。元素必须是唯一的，如果添加已存在的元素，它将被忽略。例如：

   my_set.add(6) # 添加元素6到集合
   

3. 删除元素：

   使用 remove() 方法可以从集合中删除指定元素，如果元素不存在，将引发KeyError异常。使用 discard() 方法可以删除元素，但如果元素不存在，不会引发异常。例如：

   my_set.remove(4) # 删除元素4 
   my_set.discard(7) # 删除元素7（如果存在）
   

4. 清空集合：

   使用 clear() 方法可以清空集合中的所有元素。例如：

   my_set.clear() # 清空集合
   

5. 集合操作：

   集合支持各种操作，如并集、交集、差集等，可以使用相关方法来执行这些操作。例如：

   • 并集：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) # 对称差集
   

6. 子集和超集检查：

   使用 issubset() 和 issuperset() 方法可以检查一个集合是否是另一个集合的子集或超集。例如：

   subset_check = set1.issubset(set2) # 检查set1是否是set2的子集 
   superset_check = set1.issuperset(set2) # 检查set1是否是set2的超集
   

7. 集合长度：

   使用 len() 函数可以获取集合的长度（元素个数）。例如：

   length = len(my_set) # 获取集合长度
   

8. 转换为列表：

   使用 list() 函数可以将集合转换为列表。例如：

   my_list = list(my_set) # 将集合转换为列表
   

字典操作

字典（Dictionary）是Python中的一种数据结构，用于存储键-值对的集合，键是唯一的，用于快速查找值。以下是一些常见的字典操作：

1. 创建字典：

   您可以使用花括号 {} 来创建一个字典，其中包含键-值对。例如：

   my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}
   

2. 访问字典值：

   您可以使用键来访问字典中的值。例如，my_dict['name'] 返回键 'name' 对应的值 'Alice'。

3. 添加或修改键值对：

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

   my_dict['gender'] = 'Female' # 添加新的键值对 
   my_dict['age'] = 31 # 修改年龄的值
   

4. 删除键值对：

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

   del my_dict['city'] # 删除'city'键值对
   

5. 检查键是否存在：

   使用 in 运算符可以检查键是否存在于字典中。例如：

   if 'name' in my_dict: print("Name is in the dictionary.")
   

6. 获取所有键、所有值和键值对：

   使用 keys() 方法可以获取字典中的所有键，使用 values() 方法可以获取所有值，使用 items() 方法可以获取所有键值对。例如：

   keys = my_dict.keys() # 获取所有键 
   values = my_dict.values() # 获取所有值 
   items = my_dict.items() # 获取所有键值对
   

7. 遍历字典：

   使用 for 循环可以遍历字典中的键，然后使用键来获取相应的值。例如：

   for key in my_dict: value = my_dict[key] print(key, value)
   

   或者，使用 items() 方法可以遍历键值对：

   for key, value in my_dict.items(): print(key, value)
   

8. 复制字典：

   使用 copy() 方法可以复制一个字典，创建一个新的字典。例如：

   new_dict = my_dict.copy() # 复制字典
   

9. 清空字典：

   使用 clear() 方法可以清空字典中的所有键值对。例如：

   my_dict.clear() # 清空字典
   

字符串操作

在Python中，字符串（String）是一种常见的数据类型，用于存储文本数据。Python提供了许多字符串操作方法，以便处理和操作字符串数据。以下是一些常见的字符串操作：

1. 创建字符串：

   您可以使用单引号 ''、双引号 "" 或三引号 ''' 来创建字符串。例如：

   my_string = "Hello, World!"
   

2. 字符串连接：

   使用 + 运算符可以将两个字符串连接在一起。例如：

   string1 = "Hello" string2 = "World" combined_string = string1 + ", " + string2 # 连接两个字符串
   

3. 字符串重复：

   使用 * 运算符可以重复一个字符串多次。例如：

   repeated_string = "ABC" * 3 # 重复字符串3次
   

4. 字符串长度：

   使用 len() 函数可以获取字符串的长度（字符数）。例如：

   length = len(my_string) # 获取字符串长度
   

5. 字符串索引和切片：

   您可以使用索引来访问字符串中的单个字符，索引从0开始。还可以使用切片操作来访问字符串的一部分。例如：

   first_char = my_string[0] # 获取字符串的第一个字符 
   sub_string = my_string[7:12] # 获取索引7到11的子字符串
   

6. 字符串查找：

   使用 find() 方法可以查找子字符串在主字符串中的位置，或者使用 in 运算符来检查子字符串是否存在。例如：

   index = my_string.find("World") # 查找子字符串的位置 
   is_present = "Hello" in my_string # 检查子字符串是否存在
   

7. 字符串替换：

   使用 replace() 方法可以替换字符串中的子字符串。例如：

   new_string = my_string.replace("World", "Python") # 替换子字符串
   

8. 字符串分割：

   使用 split() 方法可以将字符串拆分成子字符串列表，根据指定的分隔符。例如：

   words = my_string.split(", ") # 使用逗号和空格分割字符串
   

9. 字符串格式化：

   使用字符串的 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."
   

10. 字符串大小写转换：

    使用 upper() 方法可以将字符串转为大写，使用 lower() 方法可以将字符串转为小写。例如：

    uppercase_string = my_string.upper() # 转为大写 
    lowercase_string = my_string.lower() # 转为小写