Python基础编程教程-原创手记-慕课网

Python简介

Python是一种高级编程语言，广泛应用于各种领域，包括Web开发、数据科学、机器学习、自动化脚本等。Python的特点包括简洁的语法、强大的库支持、跨平台性等。Python由Guido van Rossum于1989年开始设计，第一个公开发行版本发布于1991年。Python的最新稳定版本为Python 3.10.0，发行于2021年10月4日。

Python在软件开发社区中受到广泛欢迎，拥有庞大的开发者群体和丰富的开源资源。Python支持多种编程范式，如过程化、面向对象和函数式编程，这使得Python在解决各种问题时非常灵活。

Python环境搭建

安装Python

安装Python的步骤如下：

访问Python官方网站，下载最新版本的Python安装包。
运行下载好的安装包，选择合适的安装路径。
安装过程中，确保勾选“Add Python to PATH”选项，这将把Python添加到系统路径中，便于后续使用。

配置环境变量

安装完成后，需要配置环境变量以确保Python能被系统识别。以下是配置环境变量的步骤：

打开系统属性，选择“高级系统设置”。
点击“环境变量”按钮。
在“系统变量”列表中找到“Path”，双击打开。
点击“新建”，将Python安装路径添加到列表中。
点击“确定”保存设置。

安装IDE

Python可以通过多种集成开发环境（IDE）进行开发，如PyCharm、Visual Studio Code等。以下是安装PyCharm的步骤：

访问PyCharm官方网站，下载对应版本的安装包。
运行安装包，按照提示完成安装。
打开PyCharm，设置Python解释器。

验证安装

验证Python是否安装成功可以通过在命令行中运行Python命令来检查：

python --version

如果输出Python版本信息，说明Python已经成功安装。

Python基础语法

语法概述

Python语言的语法简洁明了。代码块的开始和结束通常使用冒号和缩进来表示。Python的缩进规则要求同一代码块的缩进量相同，通常使用4个空格或一个Tab键。

代码注释

Python中的注释用于解释代码，帮助其他开发者理解代码的意图。Python支持两种注释方式：

单行注释：使用#符号。
```
# 这是一行注释
```
多行注释：使用三引号"""。
```
"""
这是一段多行注释
"""
```

变量与类型

Python中的变量不需要声明类型，只需直接赋值即可。

整型
```
a = 10  # 整型变量
```
浮点型
```
b = 3.14  # 浮点型变量
```
字符串
```
name = "张三"  # 字符串变量
```
布尔型
```
is_active = True  # 布尔型变量
```

变量的类型可以通过内置函数type()获取：

print(type(a))  # <class 'int'>
print(type(b))  # <class 'float'>
print(type(name))  # <class 'str'>
print(type(is_active))  # <class 'bool'>

运算符

Python支持多种运算符，包括算术运算符、比较运算符、逻辑运算符等。

算术运算符

a = 10
b = 3
print(a + b)  # 13
print(a - b)  # 7
print(a * b)  # 30
print(a / b)  # 3.3333333333333335
print(a % b)  # 1
print(a ** b)  # 1000

比较运算符

print(a > b)  # True
print(a < b)  # False
print(a == b)  # False
print(a != b)  # True
print(a >= b)  # True
print(a <= b)  # False

逻辑运算符

x = True
y = False
print(x and y)  # False
print(x or y)  # True
print(not x)  # False

Python控制结构

条件语句

条件语句用于根据不同的条件执行不同的代码块。Python中的条件语句使用关键字if、elif和else。

age = 20

if age < 18:
    print("未成年")
elif age < 60:
    print("成年")
else:
    print("老年")

循环语句

循环语句用于重复执行一段代码。Python中的循环语句主要有for循环和while循环。

for循环

for循环通常用于遍历序列（如列表、元组、字符串等）。

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

for number in numbers:
    print(number)

while循环

while循环用于在条件为真时重复执行一段代码。

count = 0

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

break和continue语句

break语句用于提前退出循环，continue语句用于跳过当前循环的剩余部分，继续执行下一次循环。

for i in range(10):
    if i == 5:
        break
    print(i)

for i in range(10):
    if i % 2 == 0:
        continue
    print(i)

Python数据结构

列表（List）

列表是一种可变的数据结构，可以存储任意类型的多个元素。

# 创建列表
fruits = ["apple", "banana", "cherry"]

# 访问元素
print(fruits[0])  # apple

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

# 添加元素
fruits.append("grape")
print(fruits)  # ['apple', 'orange', 'cherry', 'grape']

# 删除元素
del fruits[2]
print(fruits)  # ['apple', 'orange', 'grape']

元组（Tuple）

元组是一种不可变的数据结构，可以存储任意类型的多个元素。

# 创建元组
numbers = (1, 2, 3)

# 访问元素
print(numbers[0])  # 1

# 元组是不可变的
# numbers[0] = 10  # TypeError: 'tuple' object does not support item assignment

字典（Dictionary）

字典是一种键值对的数据结构，可以存储任意类型的键和对应的值。

# 创建字典
person = {"name": "张三", "age": 20, "is_student": True}

# 访问元素
print(person["name"])  # 张三

# 修改元素
person["age"] = 21
print(person["age"])  # 21

# 添加元素
person["address"] = "北京市"
print(person)  # {'name': '张三', 'age': 21, 'is_student': True, 'address': '北京市'}

# 删除元素
del person["is_student"]
print(person)  # {'name': '张三', 'age': 21, 'address': '北京市'}

集合（Set）

集合是一种无序不重复的数据结构，可以存储任意类型的元素。

# 创建集合
numbers = {1, 2, 3, 4, 5, 1}

# 访问元素
for number in numbers:
    print(number)

# 添加元素
numbers.add(6)
print(numbers)  # {1, 2, 3, 4, 5, 6}

# 删除元素
numbers.remove(1)
print(numbers)  # {2, 3, 4, 5, 6}

Python函数

函数定义

Python中的函数使用def关键字定义。

def greet(name):
    print(f"Hello, {name}!")

greet("张三")  # Hello, 张三!

参数与返回值

函数可以接受多个参数，并可以返回一个或多个值。

def add(a, b):
    return a + b

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

默认参数

默认参数允许函数在调用时无需提供某些参数的值。

def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("张三")  # Hello, 张三!
greet("张三", "你好")  # 你好, 张三!

可变参数

Python允许函数接受不定数量的参数。

def sum(*args):
    return sum(args)

result = sum(1, 2, 3, 4, 5)
print(result)  # 15

匿名函数

匿名函数使用lambda关键字定义，通常用于简单的一次性操作。

add = lambda x, y: x + y
result = add(3, 5)
print(result)  # 8

Python类与对象

类定义

类是面向对象编程的基础，用于定义具有特定属性和方法的对象。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

p = Person("张三", 20)
p.greet()  # Hello, my name is 张三 and I am 20 years old.

继承

继承允许一个类继承另一个类的属性和方法。

class Student(Person):
    def __init__(self, name, age, grade):
        super().__init__(name, age)
        self.grade = grade

    def study(self):
        print(f"{self.name} is studying in grade {self.grade}.")

s = Student("李四", 18, 10)
s.greet()  # Hello, my name is 李四 and I am 18 years old.
s.study()  # 李四 is studying in grade 10.

封装

封装是将数据和操作数据的方法绑定在一起，防止外部直接访问对象的内部数据。

class BankAccount:
    def __init__(self, owner, balance=0):
        self.__owner = owner
        self.__balance = balance

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if self.__balance >= amount:
            self.__balance -= amount
        else:
            print("Not enough balance.")

    def get_balance(self):
        return self.__balance

account = BankAccount("张三", 1000)
account.deposit(500)
print(account.get_balance())  # 1500
account.withdraw(2000)  # Not enough balance.

多态

多态允许不同类的对象在相同的接口下表现出不同的行为。

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("汪汪汪")

class Cat(Animal):
    def speak(self):
        print("喵喵喵")

dog = Dog()
cat = Cat()

dog.speak()  # 汪汪汪
cat.speak()  # 喵喵喵

Python模块与包

模块

模块是包含Python代码的文件，可以是一个简单的文件或一个文件夹。模块可以通过import语句导入。

# my_module.py
def say_hello():
    print("Hello")

# 在其他文件中使用模块
import my_module

my_module.say_hello()  # Hello

包

包是一组模块的集合，通常用于组织相关的模块。包中的模块可以通过.语法访问。

# my_package/__init__.py
# 一个空文件，用于表示这是一个包

# my_package/utils.py
def say_hello():
    print("Hello")

# 在其他文件中使用包中的模块
from my_package import utils

utils.say_hello()  # Hello

Python异常处理

异常处理

异常处理允许程序在遇到错误时进行优雅的处理。

try:
    result = 10 / 0
except ZeroDivisionError:
    print("除数不能为0")

异常的种类

Python中常见的异常包括ZeroDivisionError、IndexError、KeyError等。

try:
    numbers = [1, 2, 3]
    print(numbers[10])
except IndexError:
    print("索引超出范围")

自定义异常

可以自定义异常类，继承自Exception类。

class MyException(Exception):
    def __init__(self, message):
        super().__init__(message)

try:
    raise MyException("这是一个自定义异常")
except MyException as e:
    print(e)  # 这是一个自定义异常

Python文件操作

文件读写

文件操作是程序与外部数据交互的重要手段。

# 写入文件
with open("example.txt", "w") as file:
    file.write("Hello, World!")

# 读取文件
with open("example.txt", "r") as file:
    content = file.read()
    print(content)  # Hello, World!

文件夹操作

文件夹操作用于创建、删除和操作文件夹。

import os

# 创建文件夹
os.mkdir("new_folder")

# 删除文件夹
os.rmdir("new_folder")

Python高级话题

迭代器与生成器

迭代器是用于遍历集合的数据结构，生成器是一种特殊的迭代器，可以在运行时动态生成值。

# 迭代器
numbers = [1, 2, 3]
iterator = iter(numbers)
print(next(iterator))  # 1
print(next(iterator))  # 2
print(next(iterator))  # 3

# 生成器
def generator():
    yield 1
    yield 2
    yield 3

gen = generator()
print(next(gen))  # 1
print(next(gen))  # 2
print(next(gen))  # 3

装饰器

装饰器是一种修改函数行为的特殊函数。

def my_decorator(func):
    def wrapper():
        print("调用前")
        result = func()
        print("调用后")
        return result
    return wrapper

@my_decorator
def say_hello():
    print("Hello")

say_hello()
# 调用前
# Hello
# 调用后

装饰器的使用场景

装饰器常用于日志记录、事务控制、缓存等场景。

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} 耗时: {end_time - start_time}s")
        return result
    return wrapper

@timer
def my_function():
    time.sleep(2)
    print("函数执行")

my_function()
# 函数执行
# my_function 耗时: 2.001s

Python网络编程

HTTP请求

Python可以使用内置的urllib库或第三方库如requests来发送HTTP请求。

import requests

response = requests.get("https://httpbin.org/get")
print(response.text)

网络服务器

Python可以使用socket库或第三方库如Flask来创建网络服务器。

from flask import Flask

app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello, World!"

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

Python数据处理

数据清洗

数据清洗是数据处理的重要步骤，包括去除无效数据、填充缺失值等。

import pandas as pd

data = {
    "name": ["张三", "李四", "王五"],
    "age": [20, None, 25],
    "city": ["北京", "上海", "广州"]
}

df = pd.DataFrame(data)
print(df)
#    name   age    city
# 0  张三  20.0    北京
# 1  李四    NaN    上海
# 2  王五  25.0    广州

df["age"] = df["age"].fillna(0)
print(df)
#    name  age    city
# 0  张三  20.0    北京
# 1  李四   0.0    上海
# 2  王五  25.0    广州

数据可视化

Python可以使用matplotlib或seaborn等库进行数据可视化。

import matplotlib.pyplot as plt

x = [1, 2, 3, 4, 5]
y = [2, 3, 5, 7, 11]

plt.plot(x, y)
plt.xlabel("x")
plt.ylabel("y")
plt.title("示例曲线")
plt.show()

Python机器学习

机器学习简介

机器学习是人工智能的一个分支，通过算法让计算机从数据中学习规律。

机器学习库

Python中有多个优秀的机器学习库，如scikit-learn、TensorFlow、PyTorch等。

from sklearn.linear_model import LinearRegression
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split

X, y = make_regression(n_samples=1000, n_features=1, noise=0.1)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

model = LinearRegression()
model.fit(X_train, y_train)
score = model.score(X_test, y_test)
print(score)  # 0.999...

Python爬虫开发

爬虫简介

爬虫是一种自动化程序，用于抓取互联网上的数据。

爬虫开发库

Python中有多个爬虫开发库，如requests、BeautifulSoup、Scrapy等。

import requests
from bs4 import BeautifulSoup

url = "https://example.com"
response = requests.get(url)
soup = BeautifulSoup(response.text, "html.parser")

for link in soup.find_all("a"):
    print(link.get("href"))

总结

Python是一种功能强大的编程语言，适用于多种应用场景。本文介绍了Python的基础语法、控制结构、数据结构、函数、面向对象编程、模块与包、异常处理、文件操作、高级话题、网络编程、数据处理和机器学习等内容。希望本文对Python学习者有所帮助。