Python基础速通（涵盖常用代码片段）

一、基础环境安装与配置

1. 安装 Python

Python 的安装简单便捷，初学者可从官方网站下载适合自己操作系统的安装包：

下载地址：https://www.python.org/downloads/windows/
安装时，建议勾选“Add Python to PATH”选项，以便在命令行直接运行 Python。
安装完成后，打开命令提示符（Windows）或终端（Linux/Mac），输入以下命令验证安装：
```
python --version
```
或：
```
python3 --version
```
输出类似 Python 3.12.0，表示安装成功。

2. 使用 pip 安装第三方库

Python 的强大得益于其丰富的第三方库生态，pip 是默认的包管理工具：

安装库：
```
pip install requests
```
安装 .whl 文件：
1. 从 https://pypi.org 下载对应的 .whl 文件。
2. 安装命令：
```
pip install xxx.whl
```
加速下载（更改镜像源）：国内用户可使用镜像源（如清华大学镜像）加速下载：
```
pip install requests -i https://pypi.tuna.tsinghua.edu.cn/simple
```
永久更改 pip 源：
1. 在用户目录下创建 .pip 文件夹：
  - Windows：C:\Users\用户名\.pip
  - Linux/Mac：/home/用户名/.pip
2. 在 .pip 文件夹中创建 pip.conf（Linux/Mac）或 pip.ini（Windows），内容如下：
```
[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
```

3. 验证模块安装

安装模块后，可验证是否成功：

import requests
print(requests.__version__)  # 输出 requests 版本号

二、基础语法与常用操作

1. Python 保留关键字

Python 有以下保留关键字，不能用作变量名：

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 
 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 
 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 
 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

示例（错误用法）：

# 错误：def 是关键字，不能作为变量名
def = 123  # SyntaxError

2. 多行语句

Python 通常一行一个语句，但可用反斜杠 \ 连接多行：

a = 100
b = 200
c = 300
total = a + \
        b + \
        c
print(total)  # 输出：600

更推荐的方式是使用括号（更清晰）：

total = (a +
         b +
         c)
print(total)  # 输出：600

3. 单引号、双引号与三引号

Python 支持单引号 '、双引号 " 和三引号 ''' 或 """ 定义字符串：

单引号和双引号：等效，用于单行字符串。

str1 = 'Hello'
str2 = "World"
print(str1, str2)  # 输出：Hello World

三引号：用于多行字符串或文档字符串。

multi_str = '''
第一行
第二行
第三行
'''
print(multi_str)

4. 注释

注释提高代码可读性：

单行注释：使用 #。

# 这是一个单行注释
print("Hello")  # 输出 Hello

多行注释：使用三引号。

'''
这是一个多行注释
可以写多行
'''

快捷键：在大多数编辑器中，Ctrl + / 可快速注释/取消注释选中代码。

5. print 函数

print 是输出到控制台的常用函数：

基本用法：

print("Hello, Python!")  # 输出：Hello, Python!

格式化输出：

使用 f-string（推荐，Python 3.6+）：

name = "张三"
age = 18
print(f"{name} 今年 {age} 岁")  # 输出：张三 今年 18 岁

使用 format 方法：

print("{} 今年 {} 岁".format(name, age))  # 输出：张三 今年 18 岁

使用 % 运算符（旧方式）：

print("%s 今年 %d 岁" % (name, age))  # 输出：张三 今年 18 岁

多参数输出：
```
print("a", "b", "c", sep="|", end="!\n")  # 输出：a|b|c!
```
- sep：设置参数间的分隔符，默认空格。
- end：设置输出结束字符，默认换行符 \n。

6. import 导入模块

Python 通过 import 导入模块：

导入内置模块：

import os
import math
print(os.getcwd())      # 输出当前工作目录
print(math.sqrt(16))    # 输出：4.0

导入自定义模块（假设有文件 num.py）：

import num
print(num.jia(1, 2))  # 假设 num.py 中有 jia 函数

别名导入：

import numpy as np
print(np.array([1, 2, 3]))  # 输出：[1 2 3]

7. input 函数

input 接收用户输入，返回字符串：

name = input("请输入您的名字：")
print(f"欢迎，{name}！")
# 输入数字时需转换类型
number = int(input("请输入一个数字："))
print(number + 1)

8. 运算符

Python 支持多种运算符：

算术运算：+, -, *, /, //（整除）, %（取模）, **（幂）

print(10 + 5)   # 输出：15
print(10 // 3)  # 输出：3
print(2 ** 3)   # 输出：8

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

print(5 > 3)    # 输出：True
print(5 != 5)   # 输出：False

逻辑运算：and, or, not

print(True and False)  # 输出：False
print(not True)        # 输出：False

成员运算：in, not in
```
print(3 in [1, 2, 3])  # 输出：True
```

9. 循环语句

Python 支持 for 和 while 循环，适用于字符串、列表、字典等。

for 循环：

# 遍历列表
fruits = ["苹果", "香蕉", "橙子"]
for fruit in fruits:
    print(fruit)
# 遍历字符串
for char in "Python":
    print(char)
# 使用 range
for i in range(1, 6, 2):  # 从 1 到 5，步长 2
    print(i)  # 输出：1, 3, 5

while 循环：

count = 0
while count < 5:
    print(count)
    count += 1

嵌套循环：

for i in range(3):
    for j in range(2):
        print(f"i={i}, j={j}")

循环控制：break, continue, pass

for i in range(10):
    if i == 5:
        break  # 退出循环
    if i % 2 == 0:
        continue  # 跳过本次循环
    print(i)  # 输出：1, 3

10. if 判断

if 语句用于条件判断：

score = 85
if score >= 90:
    print("优秀")
elif score >= 60:
    print("及格")
else:
    print("不及格")
# 输出：及格

嵌套 if：

if score >= 60:
    if score >= 80:
        print("良好")
    else:
        print("刚及格")

三、列表、字典、元组操作

1. 列表操作

列表是 Python 最常用的数据结构，支持动态修改。

创建与访问：

my_list = [1, 2, 3, "Python", True]
print(my_list[0])       # 输出：1
print(my_list[1:4])     # 输出：[2, 3, 'Python']
print(my_list[-1])      # 输出：True
print(my_list[::2])     # 每隔一个元素，输出：[1, 3, True]

添加元素：

my_list.append("新元素")  # 末尾添加
print(my_list)  # 输出：[1, 2, 3, 'Python', True, '新元素']
my_list.insert(1, "插入")  # 在索引 1 插入
print(my_list)  # 输出：[1, '插入', 2, 3, 'Python', True, '新元素']
my_list.extend([4, 5])  # 扩展多个元素
print(my_list)  # 输出：[1, '插入', 2, 3, 'Python', True, '新元素', 4, 5]

删除元素：

del my_list[0]  # 删除索引 0
print(my_list)  # 输出：['插入', 2, 3, 'Python', True, '新元素', 4, 5]
my_list.remove("Python")  # 删除指定元素
print(my_list)  # 输出：['插入', 2, 3, True, '新元素', 4, 5]
popped = my_list.pop(1)  # 弹出索引 1
print(popped, my_list)  # 输出：2 ['插入', 3, True, '新元素', 4, 5]

修改元素：

my_list[0] = "修改"
print(my_list)  # 输出：['修改', 3, True, '新元素', 4, 5]

常用方法：

numbers = [3, 1, 4, 1, 5, 9]
print(max(numbers))     # 输出：9
print(min(numbers))     # 输出：1
print(len(numbers))     # 输出：6
print(numbers.count(1)) # 输出：2
numbers.sort(reverse=True)  # 降序排序
print(numbers)          # 输出：[9, 5, 4, 3, 1, 1]
numbers.reverse()       # 反转
print(numbers)          # 输出：[1, 1, 3, 4, 5, 9]

去重：

list1 = ['zhangsan', 'lisi', 'wangwu', 'zhangsan']
list2 = []
for item in list1:
    if item not in list2:
        list2.append(item)
print(list2)  # 输出：['zhangsan', 'lisi', 'wangwu']
# 更简洁：使用集合
list2 = list(set(list1))
print(list2)  # 输出：['zhangsan', 'lisi', 'wangwu']

列表推导式：

squares = [x**2 for x in range(1, 6)]
print(squares)  # 输出：[1, 4, 9, 16, 25]
evens = [x for x in range(10) if x % 2 == 0]
print(evens)  # 输出：[0, 2, 4, 6, 8]

2. 字典操作

字典以键值对存储数据，键唯一，值可重复。

创建与访问：

dic = {"name": "zhangsan", "age": 18, "hobby": "打篮球"}
print(dic["name"])        # 输出：zhangsan
print(dic.get("age"))     # 输出：18
print(dic.get("不存在", "默认值"))  # 输出：默认值

添加与修改：

dic["name"] = "lisi"    # 修改
dic["degree"] = "本科"  # 添加
print(dic)  # 输出：{'name': 'lisi', 'age': 18, 'hobby': '打篮球', 'degree': '本科'}

删除：

del dic["age"]  # 删除键值对
print(dic)      # 输出：{'name': 'lisi', 'hobby': '打篮球', 'degree': '本科'}
dic.clear()     # 清空
print(dic)      # 输出：{}

遍历：

dic = {"name": "zhangsan", "age": 18, "hobby": "打篮球"}
for key in dic:
    print(key, dic[key])
for key, value in dic.items():
    print(f"{key}: {value}")
for value in dic.values():
    print(value)

字典推导式：

squares_dict = {x: x**2 for x in range(1, 5)}
print(squares_dict)  # 输出：{1: 1, 2: 4, 3: 9, 4: 16}

3. 元组操作

元组与列表类似，但不可修改。

创建与访问：

tup = (1, 2, 3, "Python")
print(tup[0])       # 输出：1
print(tup[1:3])     # 输出：(2, 3)
print(tup + (4, 5)) # 输出：(1, 2, 3, 'Python', 4, 5)

删除：

del tup  # 删除整个元组
# print(tup)  # 报错：tup 未定义

元组拆包：

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

四、函数与高阶函数

1. 定义函数

使用 def 定义函数：

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"
print(greet("张三"))       # 输出：Hello, 张三!
print(greet("李四", "Hi")) # 输出：Hi, 李四!

可变参数：

def print_args(*args, **kwargs):
    print("位置参数:", args)
    print("关键字参数:", kwargs)
print_args(1, 2, 3, name="张三", age=18)
# 输出：
# 位置参数: (1, 2, 3)
# 关键字参数: {'name': '张三', 'age': 18}

文件删除函数示例：

import os
def delfile(filename, *args, isfile=True):
    print("额外参数:", args)
    if isfile and os.path.exists(filename):
        print(f"删除文件: {filename}")
        # os.remove(filename)
    else:
        print("文件不存在或不是文件")
delfile("test.txt", 1, 2, 3)

2. lambda 匿名函数

lambda 定义简单函数：

heshui = lambda name, duoshao: f"{name}喝了{duoshao}水"
print(heshui("张三", "1L"))  # 输出：张三喝了1L水

排序应用：

pairs = [(1, "one"), (3, "three"), (2, "two")]
pairs.sort(key=lambda x: x[0])
print(pairs)  # 输出：[(1, 'one'), (2, 'two'), (3, 'three')]

3. 高阶函数

Python 支持高阶函数，如 map, filter, reduce 等。

map：对序列中每个元素应用函数：

numbers = [1, 2, 3, 4]
squares = list(map(lambda x: x**2, numbers))
print(squares)  # 输出：[1, 4, 9, 16]

filter：筛选符合条件的元素：

evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # 输出：[2, 4]

reduce（需导入 functools）：

from functools import reduce
sum_result = reduce(lambda x, y: x + y, numbers)
print(sum_result)  # 输出：10

4. 变量作用域

全局变量与局部变量：

a = 2  # 全局变量
def test():
    b = 3  # 局部变量
    print(a, b)
test()  # 输出：2 3
# print(b)  # 报错：b 未定义

global 关键字：

a = 2
def modify_global():
    global a
    a = 10
modify_global()
print(a)  # 输出：10

nonlocal 关键字（用于嵌套函数）：

def outer():
    x = 10
    def inner():
        nonlocal x
        x += 5
    inner()
    print(x)  # 输出：15
outer()

五、面向对象编程

1. 定义类与对象

类是对象的模板，包含属性和方法：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def introduce(self):
        return f"我是{self.name}，今年{self.age}岁"
    
    def birthday(self):
        self.age += 1
        return f"{self.name} 过生日，年龄变为 {self.age}"

p = Person("张三", 18)
print(p.introduce())  # 输出：我是张三，今年18岁
print(p.birthday())   # 输出：张三 过生日，年龄变为 19

2. 封装

封装隐藏内部实现，暴露必要接口：

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance  # 私有属性
    
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            return f"存入 {amount}，余额：{self.__balance}"
        return "存款金额必须大于 0"
    
    def get_balance(self):
        return self.__balance

account = BankAccount("张三")
print(account.deposit(100))  # 输出：存入 100，余额：100
print(account.get_balance())  # 输出：100

3. 继承

子类继承父类的属性和方法：

class Animal:
    def __init__(self, name):
        self.name = name
    
    def eat(self):
        return f"{self.name} 在吃饭"

class Dog(Animal):
    def bark(self):
        return f"{self.name} 在叫"

dog = Dog("旺财")
print(dog.eat())   # 输出：旺财 在吃饭
print(dog.bark())  # 输出：旺财 在叫

方法重写：

class Dog(Animal):
    def eat(self):
        return f"{self.name} 在吃骨头"
dog = Dog("旺财")
print(dog.eat())  # 输出：旺财 在吃骨头

4. 多态

不同对象对同一方法有不同实现：

class Cat(Animal):
    def eat(self):
        return f"{self.name} 在吃鱼"

animals = [Dog("旺财"), Cat("咪咪")]
for animal in animals:
    print(animal.eat())
# 输出：
# 旺财 在吃骨头
# 咪咪 在吃鱼

5. 多层继承

子类可继承多层父类：

class Pet(Animal):
    def play(self):
        return f"{self.name} 在玩耍"

class SuperPet(Pet):
    def super_skill(self):
        return f"{self.name} 有超能力"

pet = SuperPet("小白")
print(pet.eat())        # 输出：小白 在吃饭
print(pet.play())       # 输出：小白 在玩耍
print(pet.super_skill())  # 输出：小白 有超能力

六、文件操作与异常处理

1. 文件操作

Python 提供丰富的文件操作功能：

写文件：

with open("example.txt", "w", encoding="utf-8") as f:
    f.write("Hello, Python!\n")
    f.write("这是第二行")

读文件：

with open("example.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)
# 输出：
# Hello, Python!
# 这是第二行

逐行读取：

with open("example.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())

追加内容：

with open("example.txt", "a", encoding="utf-8") as f:
    f.write("\n追加一行")

2. 异常处理

使用 try-except 处理错误：

try:
    result = 10 / 0
except ZeroDivisionError:
    print("除数不能为 0")
except ValueError:
    print("值错误")
else:
    print("计算成功")
finally:
    print("无论如何都会执行")
# 输出：
# 除数不能为 0
# 无论如何都会执行

捕获所有异常：

try:
    result = 10 / 0
except Exception as e:
    print(f"发生错误：{e}")

七、实用模块与进阶操作

1. 时间处理

使用 datetime 模块处理时间：

from datetime import datetime, timedelta
now = datetime.now()
print(now)  # 输出：当前时间
print(now.strftime("%Y-%m-%d %H:%M:%S"))  # 输出：2025-06-01 16:08:00
# 计算一天后
tomorrow = now + timedelta(days=1)
print(tomorrow)  # 输出：明天时间

2. 正则表达式

使用 re 模块处理字符串：

import re
text = "我的邮箱是 example@domain.com"
match = re.search(r"[\w\.-]+@[\w\.-]+\.\w+", text)
if match:
    print(match.group())  # 输出：example@domain.com

3. 集合操作

集合用于去重和集合运算：

set1 = {1, 2, 3}
set2 = {2, 3, 4}
print(set1 | set2)  # 并集：{1, 2, 3, 4}
print(set1 & set2)  # 交集：{2, 3}
print(set1 - set2)  # 差集：{1}

4. 列表排序

基本排序：

numbers = [3, 1, 4, 1, 5]
numbers.sort()
print(numbers)  # 输出：[1, 1, 3, 4, 5]

自定义排序：

words = ["apple", "banana", "cherry"]
words.sort(key=len)
print(words)  # 输出：['apple', 'banana', 'cherry']

5. 迭代器与生成器

迭代器：

my_list = [1, 2, 3]
iterator = iter(my_list)
print(next(iterator))  # 输出：1
print(next(iterator))  # 输出：2

生成器：

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b
print(list(fibonacci(5)))  # 输出：[0, 1, 1, 2, 3]

八、综合示例

以下是一个综合示例，结合多种操作：

import os
from datetime import datetime

class FileManager:
    def __init__(self, directory):
        self.directory = directory
    
    def list_files(self):
        return [f for f in os.listdir(self.directory) if os.path.isfile(os.path.join(self.directory, f))]
    
    def log_files(self, log_file="file_log.txt"):
        try:
            files = self.list_files()
            with open(log_file, "a", encoding="utf-8") as f:
                f.write(f"Log at {datetime.now()}:\n")
                f.write("\n".join(map(str, files)))
                f.write("\n\n")
            print(f"文件列表已记录到 {log_file}")
        except Exception as e:
            print(f"错误：{e}")

# 使用示例
fm = FileManager(".")
print(fm.list_files())
fm.log_files()

九、总结

本文详细介绍了 Python 编程中的常用代码操作与函数方法，从环境配置到基础语法、数据结构操作、函数、高阶函数、面向对象编程、文件操作、异常处理等，提供了大量实用代码示例。新手可通过模仿和实践这些代码快速上手 Python，掌握常见操作。

原文 https://blog.csdn.net/2301_79518550/article/details/144069177