Python 知识点总结 - 基础篇

一、Python 基础

1.1 Python 简介

  • 定义：Python 是一种高级、解释型、面向对象的编程语言，由 Guido van Rossum 于 1991 年发布。
  • 命名由来：名字来源于英国喜剧团体 Monty Python，并非以蛇命名。
  • 设计哲学：“优雅”、“明确”、“简单”，强调代码可读性。
  • 应用领域：Web 开发、数据科学、人工智能、自动化运维、游戏开发等。

1.2 Python 的特点

  • 简单易学：语法简洁，接近自然语言，入门门槛低。
  • 跨平台：可在 Windows、Linux、macOS 等多种操作系统上运行。
  • 丰富的标准库：内置大量模块，覆盖文件处理、网络通信、正则表达式等功能。
  • 强大的第三方库：NumPy、Pandas、TensorFlow、PyTorch 等库支撑科学计算和人工智能。
  • 多范式支持：支持面向对象、函数式、过程式编程。
  • 动态类型：变量无需声明类型，运行时自动推断。
  • 自动内存管理：通过引用计数和垃圾回收机制自动管理内存。

1.3 开发环境

  • Python 解释器：核心执行引擎，运行 .py 文件。
  • IDE 推荐：
    • PyCharm：功能强大，智能提示和调试支持优秀。
    • VS Code：轻量级，插件丰富，适合快速开发。
    • Jupyter Notebook：交互式编程，适合数据分析和教学。
  • 包管理工具：
    • pip：Python 官方包管理工具，用于安装和管理第三方库。
    • conda：Anaconda 附带的包管理器，适合数据科学环境。

1.4 基本语法

  • 注释：
    • 单行注释：以 # 开头，注释内容到行尾。
    # 这是一行注释
print("Hello")  # 这也是注释
    • 多行注释：使用 """ 内容 """ 或 ''' 内容 '''，常用于文档说明。
    """
这是多行注释
可以写很多行
"""
  • 关键字：具有特殊含义的保留字，如 if、else、for、while、def、class 等，不可作为变量名。
  • 标识符：
    • 由字母、数字、下划线组成。
    • 不能以数字开头。
    • 区分大小写（name 和 Name 是不同变量）。
  • 命名规范：
    • 驼峰命名法：camelCase（首字母小写，后续单词首字母大写）、PascalCase（所有单词首字母大写）。
    • 蛇形命名法：snake_case（单词之间用下划线连接），Python 官方推荐风格。

1.5 变量与数据类型

  • 变量：程序运行过程中可改变的值，用于存储数据。语法：变量名 = 值。 
    name = "Alice"
age = 25
  • 数值类型：
    • int：整数，如 10、-5、0，支持任意精度。
    a = 10
b = -5
c = 1000000000000000000000  # Python 支持大整数
    • float：浮点数，如 3.14、-2.5、1.0e10。
    pi = 3.14159
scientific = 1.5e10  # 科学计数法，等于 15000000000.0
    • complex：复数，如 3 + 4j、2j。
    z = 3 + 4j
real_part = z.real  # 获取实部
imag_part = z.imag  # 获取虚部
  • 字符串：
    • 用单引号 '、双引号 " 或三引号 """ 包裹。
    • 支持 Unicode 编码，可表示中文等任意字符。
    • 不可变序列，即创建后不能修改单个字符。
    str1 = 'Hello'
str2 = "World"
str3 = """多行
字符串"""
  • 布尔值：
    • True：表示真（等价于 1）。
    • False：表示假（等价于 0）。
    is_active = True
is_empty = False
  • 类型转换：
    • int(x)：转换为整数。
    • float(x)：转换为浮点数。
    • str(x)：转换为字符串。
    • bool(x)：转换为布尔值（0、空字符串、空容器为 False）。
    num_str = "123"
num_int = int(num_str)  # 123
num_float = float(num_str)  # 123.0
is_true = bool(1)  # True
is_false = bool(0)  # False

1.6 运算符

  • 算术运算符： 
    a = 10
b = 3
print(a + b)   # 13，加法
print(a - b)   # 7，减法
print(a * b)   # 30，乘法
print(a / b)   # 3.333...，除法
print(a // b)  # 3，整除
print(a % b)   # 1，取模
print(a ** b)  # 1000，幂运算
  • 赋值运算符： 
    x = 5
x += 3  # 等价于 x = x + 3，结果为 8
x -= 2  # 等价于 x = x - 2，结果为 6
x *= 4  # 等价于 x = x * 4，结果为 24
x /= 2  # 等价于 x = x / 2，结果为 12.0
  • 比较运算符： 
    a = 10
b = 5
print(a > b)   # True
print(a >= b)  # True
print(a < b)   # False
print(a <= b)  # False
print(a == b)  # False，判断相等
print(a != b)  # True，判断不等
  • 逻辑运算符： 
    x = True
y = False
print(x and y)  # False，逻辑与
print(x or y)   # True，逻辑或
print(not x)    # False，逻辑非

二、容器类型

2.1 字符串 (str)

  • 特性：有序、不可变序列。
  • 索引：从 0 开始，支持负数索引（-1 表示最后一个字符）。 
    s = "Hello"
print(s[0])   # 'H'
print(s[-1])  # 'o'
  • 切片：str[start:end:step]，左闭右开区间。 
    s = "Python"
print(s[1:4])    # 'yth'
print(s[:3])     # 'Pyt'，从头开始
print(s[2:])     # 'thon'，到末尾
print(s[::2])    # 'Pto'，步长为 2
print(s[::-1])   # 'nohtyP'，反转字符串
  • 常用方法： 
    s = "  Hello World!  "
print(s.find("World"))    # 7，查找子串位置
print(s.index("World"))   # 7，查找子串位置，未找到抛出异常
print(s.replace("World", "Python"))  # '  Hello Python!  '
print(s.split())          # ['Hello', 'World!']，按空白分割
print("-".join(["a", "b", "c"]))  # 'a-b-c'，连接字符串
print(s.strip())          # 'Hello World!'，去除首尾空白
print(s.upper())          # '  HELLO WORLD!  '
print(s.lower())          # '  hello world!  '
  • 格式化方式： 
    name = "Alice"
age = 25

# %格式化
print("Hello %s, you are %d years old." % (name, age))

# format()
print("Hello {}, you are {} years old.".format(name, age))
print("Hello {1}, you are {0} years old.".format(age, name))  # 指定顺序

# f-string（Python 3.6+）
print(f"Hello {name}, you are {age} years old.")
print(f"Next year you'll be {age + 1} years old.")

2.2 列表 (list)

  • 特性：有序、可变序列，用 [] 表示。
  • 创建： 
    list1 = [1, 2, 3, 4, 5]
list2 = list(range(10))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list3 = ["apple", "banana", "cherry"]
  • 常用方法： 
    fruits = ["apple", "banana", "cherry"]

fruits.append("date")       # 添加到末尾：["apple", "banana", "cherry", "date"]
fruits.extend(["fig", "grape"])  # 添加多个元素：["apple", "banana", "cherry", "date", "fig", "grape"]
fruits.insert(1, "blueberry")    # 在索引 1 处插入：["apple", "blueberry", "banana", "cherry", "date", "fig", "grape"]
fruits.remove("banana")    # 删除第一个匹配项：["apple", "blueberry", "cherry", "date", "fig", "grape"]
removed = fruits.pop()     # 删除并返回最后一个元素
fruits.clear()             # 清空列表

numbers = [3, 1, 4, 1, 5, 9]
numbers.sort()             # 原地排序：[1, 1, 3, 4, 5, 9]
numbers.reverse()          # 原地反转：[9, 5, 4, 3, 1, 1]
print(numbers.index(4))    # 2，返回元素索引
print(numbers.count(1))    # 2，统计元素出现次数
  • 嵌套列表： 
    matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(matrix[0][1])  # 2，访问第一行第二列

2.3 元组 (tuple)

  • 特性：有序、不可变序列，用 () 表示。
  • 创建： 
    t1 = (1, 2, 3)
t2 = 1, 2, 3        # 括号可省略
t3 = (1,)           # 单元素元组必须加逗号
  • 常用方法： 
    t = (1, 2, 3, 2, 4)
print(t.count(2))   # 2，统计出现次数
print(t.index(3))   # 2，返回索引
  • 应用场景： 
    # 函数返回多个值
def get_size():
    width = 10
    height = 20
    return width, height  # 实际返回元组

w, h = get_size()  # 解包

2.4 字典 (dict)

  • 特性：无序键值对集合，用 {} 表示（Python 3.7+ 保持插入顺序）。
  • 键的要求：必须是不可变类型（字符串、数字、元组）。
  • 常用方法： 
    person = {"name": "Alice", "age": 25, "city": "New York"}

print(person.keys())    # dict_keys(['name', 'age', 'city'])
print(person.values())  # dict_values(['Alice', 25, 'New York'])
print(person.items())   # dict_items([('name', 'Alice'), ('age', 25), ('city', 'New York')])

print(person.get("name"))        # 'Alice'
print(person.get("gender", "Unknown"))  # 'Unknown'，键不存在返回默认值

person.pop("city")      # 删除键并返回值
person.update({"gender": "female", "age": 26})  # 更新字典

person.clear()          # 清空字典
  • 遍历方式： 
    person = {"name": "Alice", "age": 25}

# 遍历键
for key in person:
    print(key)

# 遍历值
for value in person.values():
    print(value)

# 遍历键值对
for key, value in person.items():
    print(f"{key}: {value}")

2.5 集合 (set)

  • 特性：无序、不重复元素集合，用 {} 或 set() 表示。
  • 创建： 
    s1 = {1, 2, 3, 3, 2}  # 自动去重：{1, 2, 3}
s2 = set([1, 2, 2, 3]) # 从列表创建：{1, 2, 3}
s3 = set()             # 空集合
  • 常用操作： 
    s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}

print(s1 & s2)  # {3, 4}，交集
print(s1 | s2)  # {1, 2, 3, 4, 5, 6}，并集
print(s1 - s2)  # {1, 2}，差集
print(s1 ^ s2)  # {1, 2, 5, 6}，对称差
  • 常用方法： 
    s = {1, 2, 3}
s.add(4)        # 添加元素：{1, 2, 3, 4}
s.remove(2)     # 删除元素，不存在抛出异常
s.discard(5)    # 删除元素，不存在不报错
s.clear()       # 清空集合
  • 应用场景： 
    # 去重
duplicates = [1, 2, 2, 3, 3, 3]
unique = list(set(duplicates))  # [1, 2, 3]

三、控制流程

3.1 条件语句

  • 单分支： 
    age = 18
if age >= 18:
    print("成年人")
  • 双分支： 
    score = 85
if score >= 60:
    print("及格")
else:
    print("不及格")
  • 多分支： 
    score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")
  • 三元运算符： 
    age = 20
status = "成年" if age >= 18 else "未成年"
print(status)  # '成年'
  • 注意：Python 使用缩进（通常 4 个空格）表示代码块，而非大括号。

3.2 循环语句

  • while 循环： 
    count = 0
while count < 5:
    print(count)
    count += 1  # 必须修改条件，否则无限循环
# 输出：0 1 2 3 4
  • for 循环： 
    fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)
# 输出：apple banana cherry
  • range() 函数： 
    for i in range(5):
    print(i)      # 0 1 2 3 4

for i in range(2, 8):
    print(i)      # 2 3 4 5 6 7

for i in range(0, 10, 2):
    print(i)      # 0 2 4 6 8
  • 嵌套循环： 
    for i in range(3):
    for j in range(3):
        print(f"({i}, {j})", end=" ")
    print()
# 输出：
# (0, 0) (0, 1) (0, 2) 
# (1, 0) (1, 1) (1, 2) 
# (2, 0) (2, 1) (2, 2)

3.3 跳转语句

  • break： 
    for i in range(10):
    if i == 5:
        break  # 终止循环
    print(i)
# 输出：0 1 2 3 4
  • continue： 
    for i in range(10):
    if i % 2 == 0:
        continue  # 跳过偶数
    print(i)
# 输出：1 3 5 7 9
  • else 子句： 
    for i in range(5):
    if i == 10:
        break
else:
    print("循环正常结束")  # 会执行，因为没有 break

for i in range(5):
    if i == 3:
        break
else:
    print("循环正常结束")  # 不会执行，因为被 break 终止

四、函数

4.1 函数定义与调用

  • 定义语法： 
    def greet(name):
    """向用户打招呼"""
    print(f"Hello, {name}!")

# 调用
greet("Alice")  # 输出：Hello, Alice!
  • 带返回值的函数： 
    def add(a, b):
    """计算两个数的和"""
    return a + b

result = add(3, 5)
print(result)  # 8

4.2 参数类型

  • 位置参数： 
    def power(base, exponent):
    return base ** exponent

result = power(2, 3)  # base=2, exponent=3
print(result)  # 8
  • 关键字参数： 
    result = power(exponent=3, base=2)  # 顺序无关
print(result)  # 8
  • 默认参数： 
    def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

print(greet("Alice"))       # "Hello, Alice!"
print(greet("Bob", "Hi"))   # "Hi, Bob!"
  • 可变参数： 
    # *args：接收任意数量的位置参数
def sum_all(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum_all(1, 2, 3))     # 6
print(sum_all(1, 2, 3, 4, 5))  # 15

# **kwargs：接收任意数量的关键字参数
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=25, city="New York")

4.3 返回值

  • 单个返回值： 
    def square(x):
    return x ** 2
  • 多个返回值： 
    def calculate(a, b):
    return a + b, a - b, a * b, a / b

add_result, sub_result, mul_result, div_result = calculate(10, 5)
print(add_result)  # 15
print(sub_result)  # 5
print(mul_result)  # 50
print(div_result)  # 2.0

4.4 匿名函数

  • 语法：lambda 参数: 表达式
  • 示例： 
    add = lambda x, y: x + y
print(add(3, 5))  # 8

# 作为高阶函数参数
numbers = [(1, 3), (2, 1), (3, 2)]
sorted_numbers = sorted(numbers, key=lambda x: x[1])
print(sorted_numbers)  # [(2, 1), (3, 2), (1, 3)]

4.5 函数嵌套

  • 定义：函数内部定义另一个函数
  • 示例： 
    def outer_function(x):
    def inner_function(y):
        return y * 2
    
    result = inner_function(x)
    return result + 1

print(outer_function(5))  # 11
  • 闭包：内部函数可以访问外部函数的变量 
    def make_adder(n):
    def adder(x):
        return x + n
    return adder

add5 = make_adder(5)
print(add5(3))  # 8
print(add5(10)) # 15
# python # 开发语言 # 后端
Logo
亚马逊云科技技术品牌专区

更多推荐

cover

[Loop Engineering在MAF中的实现-01]基于评估结果针对Agent的循环调用

avatar 亚马逊云科技技术品牌专区
cover

考证别只看难度！社会认可度，才是学生和职场人的核心底牌

avatar 亚马逊云科技技术品牌专区

智能变电站配电房集中监控系统解决方案

未来，随着数字孪生、5G通信、区块链等技术的进一步成熟，该系统将向更深的“自治”方向发展，实现自感知、自诊断、自决策、自恢复，最终构建起真正意义上的“无人值守”智能配电房，为构建新型电力系统提供坚实支撑。它通过物联网、大数据、人工智能等先进技术的深度融合，实现了对配电房运行状态的“可知、可测、可控”，显著提升了电网的可靠性、经济性与安全性。：实现对配电房内环境（温湿度、SF6浓度、水浸、烟感）、设

avatar 亚马逊云科技技术品牌专区