Python编程入门：从基础到实践-原创手记-慕课网

Python 简介

Python 是一种广泛使用的高级编程语言，由 Guido van Rossum 在 1989 年底发明，并在 1991 年首次发布。Python 设计时注重代码的可读性和简洁性，使得它成为初学者学习编程的理想选择。Python 支持多种编程范式，包括面向对象、命令式、函数式和过程式编程。

Python 被广泛应用在多个领域，包括但不限于 Web 开发、数据分析、人工智能、机器学习、科学计算、网络爬虫等。Python 代码通常简洁明了，易于维护，广受开发者欢迎。Python 社区也十分活跃，提供了大量的第三方库和工具，使得开发效率大大提高。

Python 的官方解释器是 CPython，它是 Python 语言的参考实现，也是最常用的实现。此外，还有 Jython（基于 Java）、PyPy（优化版 CPython）、IronPython（基于 .NET）等多种实现。Python 的语法简单易懂，使得开发者能够快速上手并编写出高效可靠的代码。

Python 开发环境搭建

Python 安装

Python 提供了多种安装方法。最直接的方式是访问 Python 官方网站（https://www.python.org/）下载最新版本的 Python 安装包。该网站提供了 Windows、macOS 和 Linux 等多个版本的安装包。

以下是 Windows 下的安装步骤：

访问 Python 官方网站（https://www.python.org/downloads/）。
下载最新版本的 Python 安装包，选择 Windows 版本。
运行下载的安装包，按照提示完成安装过程。
在安装过程中，请确保选中“Add Python to PATH”选项（这一步非常重要，可以为系统添加 Python 解释器的路径）。

Python 环境配置

安装完 Python 之后，需要进行一些环境配置，以便更好地使用 Python。

配置环境变量

通过配置环境变量，可以在任意位置运行 Python 命令。

在 Windows 上，环境变量的配置步骤如下：
1. 右键点击“此电脑”或“计算机”，选择“属性”。
2. 点击“高级系统设置”。
3. 点击“环境变量”。
4. 在“系统变量”部分，找到并选中“Path”变量，然后点击“编辑”。
5. 在“编辑环境变量”对话框中，点击“新建”。
6. 输入 Python 的安装路径（通常为 C:\Python39），然后点击“确定”。

验证安装

在命令行中输入 python --version 或 python3 --version，可以看到已经安装的 Python 版本号。若输出正常，则说明 Python 已成功安装。

Python 开发工具

Python 提供了多种开发工具，如 PyCharm、Visual Studio Code、Jupyter Notebook 等，它们都具有不同的特点和优势。

PyCharm：专为 Python 开发设计的集成开发环境（IDE），提供了强大的代码分析、调试和测试功能。
Visual Studio Code：一个轻量级、可扩展的代码编辑器，支持多种编程语言，包括 Python。
Jupyter Notebook：一个基于 Web 的交互式计算环境，允许用户创建和分享包含代码、公式、文字和图表等内容的文档。

推荐使用 Visual Studio Code，因为它界面简洁、功能强大且支持大量插件扩展，适合编程入门和进阶学习。

配置 Visual Studio Code

下载并安装 Visual Studio Code（https://code.visualstudio.com/download）。
打开 Visual Studio Code，通过左侧菜单栏的扩展图标（四个方块），搜索插件“Python”并安装。
在 Visual Studio Code 中新建一个 Python 文件（例如 hello.py），用编辑器编写 Python 代码。
在终端中输入 code . 命令，即可打开当前目录中的文件，并在 Visual Studio Code 中进行编辑。

Python 基础语法

Python 的语法简洁明了，易于初学者理解。以下是 Python 中的一些基本语法概念：

变量与类型

变量用于存储数据，Python 支持多种数据类型，包括整型、浮点型、布尔型、字符串、列表、元组、字典等。

整型

整型（int）用于存储整数，如 0、100、-123 等。

# 定义一个整型变量
a = 10
print(a)  # 输出 10

浮点型

浮点型（float）用于存储带有小数点的数字，如 3.14、0.5 等。

# 定义一个浮点型变量
b = 3.14
print(b)  # 输出 3.14

布尔型

布尔型（bool）用于存储真（True）或假（False）的值。

# 定义一个布尔型变量
c = True
print(c)  # 输出 True

字符串

字符串（str）用于存储文本，如 'Hello, World!'、"Python" 等。

# 定义一个字符串变量
d = "Hello, World!"
print(d)  # 输出 Hello, World!

运算符

Python 提供了多种运算符，用于执行不同的操作，包括算术运算符、比较运算符、逻辑运算符等。

算术运算符

算术运算符用于执行基本的数学操作。

# 加法运算
a = 10 + 5
print(a)  # 输出 15

# 减法运算
b = 10 - 5
print(b)  # 输出 5

# 乘法运算
c = 10 * 5
print(c)  # 输出 50

# 除法运算
d = 10 / 5
print(d)  # 输出 2.0

# 取余运算
e = 10 % 3
print(e)  # 输出 1

比较运算符

比较运算符用于比较两个值。

# 等于运算
a = 10 == 10
print(a)  # 输出 True

# 不等于运算
b = 10 != 5
print(b)  # 输出 True

# 大于运算
c = 10 > 5
print(c)  # 输出 True

# 小于运算
d = 10 < 5
print(d)  # 输出 False

# 大于等于运算
e = 10 >= 5
print(e)  # 输出 True

# 小于等于运算
f = 10 <= 5
print(f)  # 输出 False

逻辑运算符

逻辑运算符用于对布尔值进行逻辑运算。

# 逻辑与运算
a = True and False
print(a)  # 输出 False

# 逻辑或运算
b = True or False
print(b)  # 输出 True

# 逻辑非运算
c = not True
print(c)  # 输出 False

条件语句

条件语句用于根据条件的真假来执行不同的代码块。

# 简单的 if 语句
a = 10
if a > 5:
    print("a 大于 5")  # 输出 a 大于 5

# if-else 语句
b = 3
if b > 5:
    print("b 大于 5")
else:
    print("b 小于等于 5")  # 输出 b 小于等于 5

# if-elif-else 语句
c = 8
if c > 10:
    print("c 大于 10")
elif c > 5:
    print("c 大于 5")  # 输出 c 大于 5
else:
    print("c 小于等于 5")

循环语句

循环语句用于重复执行某段代码，直到满足某个条件为止。

for 循环

for 循环用于遍历序列或范围内的元素。

# 遍历列表
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)
# 输出 apple
# 输出 banana
# 输出 cherry

# 遍历范围
for i in range(5):
    print(i)
# 输出 0
# 输出 1
# 输出 2
# 输出 3
# 输出 4

while 循环

while 循环用于根据某个条件是否为真来重复执行代码块。

# 计算 0 到 4 的和
total = 0
i = 0
while i <= 4:
    total += i
    i += 1
print(total)  # 输出 10

函数

函数用于封装一段可重用的代码块，便于调用和管理。

# 定义函数
def add(a, b):
    return a + b

# 调用函数
result = add(10, 20)
print(result)  # 输出 30

异常处理

异常处理用于捕获和处理程序执行过程中可能出现的错误。

# 尝试执行可能引发异常的代码
try:
    result = 10 / 0
except ZeroDivisionError as e:
    print("除零错误:", e)  # 输出 除零错误: division by zero
finally:
    print("程序执行结束")  # 输出 程序执行结束

Python 数据结构

Python 提供了多种数据结构，包括列表、元组、字典和集合等。这些数据结构在不同的场景下有着不同的用途。

列表

列表（list）是一种有序的可变序列，可以存储不同类型的数据。

# 创建一个列表
fruits = ["apple", "banana", "cherry"]
print(fruits)  # 输出 ['apple', 'banana', 'cherry']

# 访问列表元素
print(fruits[0])  # 输出 apple
print(fruits[-1])  # 输出 cherry

# 修改列表元素
fruits[1] = "orange"
print(fruits)  # 输出 ['apple', 'orange', 'cherry']

# 列表切片
print(fruits[1:3])  # 输出 ['orange', 'cherry']

# 列表操作
fruits.append("grape")  # 添加元素
print(fruits)  # 输出 ['apple', 'orange', 'cherry', 'grape']
fruits.remove("apple")  # 删除元素
print(fruits)  # 输出 ['orange', 'cherry', 'grape']

元组

元组（tuple）与列表类似，但不可更改。元组通常用于存储一组固定的数据。

# 创建一个元组
person = ("Alice", 25, "Engineer")
print(person)  # 输出 ('Alice', 25, 'Engineer')

# 访问元组元素
print(person[0])  # 输出 Alice
print(person[-1])  # 输出 Engineer

# 元组切片
print(person[0:2])  # 输出 ('Alice', 25)

字典

字典（dict）是一种键值对的集合，键必须是唯一的。

# 创建一个字典
person = {"name": "Alice", "age": 25, "job": "Engineer"}
print(person)  # 输出 {'name': 'Alice', 'age': 25, 'job': 'Engineer'}

# 访问字典值
print(person["name"])  # 输出 Alice
print(person.get("age"))  # 输出 25

# 修改字典值
person["age"] = 26
print(person)  # 输出 {'name': 'Alice', 'age': 26, 'job': 'Engineer'}

# 添加字典元素
person["address"] = "123 Main St"
print(person)  # 输出 {'name': 'Alice', 'age': 26, 'job': 'Engineer', 'address': '123 Main St'}

# 删除字典元素
del person["address"]
print(person)  # 输出 {'name': 'Alice', 'age': 26, 'job': 'Engineer'}

集合

集合（set）是一种不重复的数据集合。

# 创建一个集合
fruits = {"apple", "banana", "cherry"}
print(fruits)  # 输出 {'banana', 'apple', 'cherry'}

# 添加元素
fruits.add("grape")
print(fruits)  # 输出 {'banana', 'apple', 'cherry', 'grape'}

# 删除元素
fruits.remove("apple")
print(fruits)  # 输出 {'banana', 'cherry', 'grape'}

# 集合操作
set1 = {1, 2, 3}
set2 = {2, 3, 4}
print(set1.union(set2))  # 输出 {1, 2, 3, 4}
print(set1.intersection(set2))  # 输出 {2, 3}
print(set1.difference(set2))  # 输出 {1}

Python 文件操作

文件操作是 Python 中非常常见的任务，涉及到读写数据、处理文本文件等。Python 提供了丰富的文件操作功能，使得文件处理变得简单而高效。

文件读写

读取文件

使用 open 函数打开文件，并使用 read 方法读取文件内容。

# every_word.txt 文件内容:
# Hello, world!
# This is a test file.

# 文件读取
with open("every_word.txt", "r") as file:
    content = file.read()
    print(content)  # 输出 Hello, world!\nThis is a test file.

写入文件

使用 write 方法将内容写入文件。

# 写入文件
with open("output.txt", "w") as file:
    file.write("Hello, world!\n")
    file.write("This is a new line.")

追加内容

使用 open 函数的 "a" 模式，将内容追加到文件末尾。

# 追加内容
with open("output.txt", "a") as file:
    file.write("\nAppended content.")

文件遍历

使用 open 函数的 "r" 模式，逐行读取文件内容。

# 每行读取
with open("every_word.txt", "r") as file:
    for line in file:
        print(line.strip())  # 输出每行内容并去掉行尾的换行符

文件操作示例

创建一个简单的程序，读取一个文件，处理内容后写入另一个文件。

# 文件读写示例
def process_file(input_file, output_file):
    with open(input_file, "r") as infile:
        lines = infile.readlines()
    processed_lines = [line.upper() for line in lines]
    with open(output_file, "w") as outfile:
        outfile.writelines(processed_lines)

process_file("every_word.txt", "processed_output.txt")

Python 模块与包

Python 模块是包含 Python 代码的文件，通常以 .py 为扩展名。模块可以包含函数、类、变量等。包是包含模块和其他包的目录，通常包含一个 __init__.py 文件。

模块导入

使用 import 语句导入模块。

# 导入模块
import math

# 使用模块中的函数
print(math.sqrt(16))  # 输出 4.0

包的使用

包中的模块可以像普通模块一样导入。

# 导入包中的模块
import mypackage.mymodule

# 使用包中模块的函数
mypackage.mymodule.my_function()

创建模块

创建一个简单的模块 my_module.py。

# my_module.py
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

创建包

创建一个简单的包 mypackage，包含一个 __init__.py 文件和一个 mymodule.py 文件。

mypackage/
    __init__.py
    mymodule.py

__init__.py 文件可以是空的，也可以包含包的一些初始化代码。

mymodule.py 文件可以包含包中的函数或类。

# mypackage/mymodule.py
def my_function():
    print("This is a function in mypackage.mymodule.")

使用模块和包

在主程序中导入并使用模块和包。

# 主程序
import my_module
import mypackage.mymodule

result = my_module.add(10, 5)
print(result)  # 输出 15

mypackage.mymodule.my_function()  # 输出 This is a function in mypackage.mymodule.

Python 面向对象编程

面向对象编程是一种编程范式，通过类和对象来组织和管理代码。Python 是一种支持面向对象编程的语言，提供了类和对象的概念。

类与对象

定义类

使用 class 关键字定义类，类中可以包含属性和方法。

# 定义一个简单的类
class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        return f"{self.name} is barking."

# 创建一个对象
dog = Dog("Buddy", 3)
print(dog.name)  # 输出 Buddy
print(dog.age)  # 输出 3
print(dog.bark())  # 输出 Buddy is barking.

类的继承

继承是一种允许子类继承父类属性和方法的机制。

# 定义一个父类
class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def make_sound(self):
        return f"{self.name} makes a sound."

# 定义一个子类，继承自 Animal 类
class Dog(Animal):
    def bark(self):
        return f"{self.name} is barking."

# 创建一个对象
dog = Dog("Buddy", 3)
print(dog.name)  # 输出 Buddy
print(dog.age)  # 输出 3
print(dog.bark())  # 输出 Buddy is barking.
print(dog.make_sound())  # 输出 Buddy makes a sound.

类的封装

封装是一种将数据和处理数据的方法封装在一起的机制，使得数据对外部是不可直接访问的。

# 使用私有属性和方法
class Car:
    def __init__(self, brand, model):
        self._brand = brand  # 建议使用 _ 作为私有属性的前缀
        self._model = model

    def get_brand(self):
        return self._brand

    def set_brand(self, brand):
        self._brand = brand

# 创建一个对象
car = Car("Toyota", "Corolla")
print(car.get_brand())  # 输出 Toyota
car.set_brand("Honda")
print(car.get_brand())  # 输出 Honda

类的多态

多态是一种允许在运行时根据对象的类型调用不同方法的机制。

# 定义一个父类
class Animal:
    def make_sound(self):
        return "Animal makes a sound."

# 定义两个子类
class Dog(Animal):
    def make_sound(self):
        return "Dog barks."

class Cat(Animal):
    def make_sound(self):
        return "Cat meows."

# 创建两个对象
dog = Dog()
cat = Cat()

# 多态性示例
for animal in [dog, cat]:
    print(animal.make_sound())
# 输出 Dog barks.
# 输出 Cat meows.

Python 实践示例：爬虫

网络爬虫是一种自动抓取网页内容的程序。Python 提供了多种库来实现网络爬虫，如 requests 和 BeautifulSoup。

安装依赖库

使用 pip 安装 requests 和 beautifulsoup4。

pip install requests beautifulsoup4

编写爬虫代码

以下是一个简单的爬虫示例，爬取百度首页并解析其中的内容。

import requests
from bs4 import BeautifulSoup

# 发送 HTTP 请求
url = "https://www.baidu.com"
response = requests.get(url)

# 解析 HTML 内容
soup = BeautifulSoup(response.text, 'html.parser')

# 查找标题
title = soup.title.string
print(f"标题: {title}")

# 查找链接
links = soup.find_all('a')
for link in links:
    href = link.get('href')
    text = link.string
    print(f"链接: {href}, 文本: {text}")

运行爬虫

运行上述代码，即可抓取百度首页并解析其中的内容。

python spider.py

Python 实践示例：数据分析

Python 在数据分析领域非常流行，主要使用 pandas 和 numpy 库。

安装依赖库

使用 pip 安装 pandas 和 numpy。

pip install pandas numpy

编写数据分析代码

以下是一个简单的数据分析示例，读取 Excel 文件并进行基本的数据处理。

import pandas as pd
import numpy as np

# 读取 Excel 文件
df = pd.read_excel("data.xlsx")

# 显示前 5 行数据
print(df.head())

# 计算平均值
mean_values = df.mean()
print("平均值:", mean_values)

# 计算标准差
std_dev = df.std()
print("标准差:", std_dev)

# 添加新列
df['new_column'] = np.random.randint(1, 100, len(df))
print(df.head())

运行数据分析

运行上述代码，即可读取 Excel 文件并进行数据分析。

python data_analysis.py

Python 实践示例：Web 开发

Python 在 Web 开发领域也有着广泛的应用，主要使用 Flask 和 Django 框架。

安装依赖库

使用 pip 安装 Flask。

pip install Flask==2.0.1

编写 Web 应用代码

以下是一个简单的 Flask Web 应用示例。

from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run()

运行 Web 应用

运行上述代码，即可启动一个简单的 Flask Web 服务。

python app.py

访问 http://127.0.0.1:5000/，可以看到输出 "Hello, World!"。

总结

Python 是一种功能强大且易学易用的编程语言，适用于多种应用场景。通过学习 Python 的基础语法、数据结构、文件操作、面向对象编程等知识，可以编写出高质量的 Python 程序。同时，Python 社区提供了大量的库和框架，使得开发效率大大提高。希望本文能够帮助你入门 Python 编程，并为后续深入学习打下坚实的基础。