Python基础语法与编程实践

概述

本文介绍了Python编程语言的基础语法和常用特性，包括变量与数据类型、控制结构、函数、数据结构等。此外，还涵盖了文件操作、异常处理、模块与包、面向对象编程等内容。通过示例代码，读者可以快速掌握Python编程技巧。本文还简要介绍了JWT开发的相关概念和实践。

1. 变量与数据类型

1.1 变量

在Python中，变量是用来存储数据的容器。Python中不需要显式声明变量的数据类型，Python会根据赋值自动推断变量类型。

x = 5
print(type(x))  # 输出：<class 'int'>
y = "Hello, world!"
print(type(y))  # 输出：<class 'str'>

1.2 基本数据类型

Python的基本数据类型包括整型（int）、浮点型（float）、字符串（str）、布尔型（bool）等。

整型（int）

整型是Python中最基本的数据类型之一，用于表示整数。

x = 42
print(type(x))  # 输出：<class 'int'>

浮点型（float）

浮点型用于表示带有小数点的数字。

y = 3.14
print(type(y))  # 输出：<class 'float'>

字符串（str）

字符串用于表示文本信息，由单引号或双引号包围。

message = "Hello, Python!"
print(type(message))  # 输出：<class 'str'>

布尔型（bool）

布尔型用于表示真（True）或假（False）。

is_active = True
print(type(is_active))  # 输出：<class 'bool'>

2. 控制结构

2.1 条件语句

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

if 语句

x = 10
if x > 5:
    print("x is greater than 5")

if-else 语句

x = 3
if x > 5:
    print("x is greater than 5")
else:
    print("x is not greater than 5")

if-elif-else 语句

x = 7
if x > 10:
    print("x is greater than 10")
elif x > 5:
    print("x is greater than 5 but not greater than 10")
else:
    print("x is not greater than 5")

2.2 循环语句

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

for 循环

for i in range(5):
    print(i)

while 循环

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

3. 函数

函数是一段可重用的代码，用于执行特定功能。

3.1 定义函数

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

print(greet("Alice"))  # 输出：Hello, Alice!

3.2 参数与返回值

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

result = add(3, 4)
print(result)  # 输出：7

3.3 默认参数

def greet(name="World"):
    return f"Hello, {name}!"

print(greet())  # 输出：Hello, World!
print(greet("Alice"))  # 输出：Hello, Alice!

3.4 可变参数

可变参数（*args）

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

print(add(1, 2, 3, 4))  # 输出：10

关键字参数（**kwargs）

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=30, city="Beijing")  # 输出：name: Alice, age: 30, city: Beijing

4. 列表与元组

列表和元组是Python中用于存储多个值的数据结构。

4.1 列表（List）

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

创建列表

my_list = [1, 2, 3, "Python", True]
print(my_list)  # 输出：[1, 2, 3, 'Python', True]

访问列表元素

my_list = ["apple", "banana", "cherry"]
print(my_list[0])  # 输出：apple

切片操作

my_list = [1, 2, 3, 4, 5]
print(my_list[1:4])  # 输出：[2, 3, 4]

修改列表元素

my_list = [1, 2, 3]
my_list[1] = 20
print(my_list)  # 输出：[1, 20, 3]

列表方法

my_list = [1, 2, 3]
my_list.append(4)
my_list.insert(1, 10)
print(my_list)  # 输出：[1, 10, 2, 3, 4]

4.2 元组（Tuple）

元组是一种不可变的有序集合，可以存储不同类型的数据。

创建元组

my_tuple = (1, 2, 3, "Python", True)
print(my_tuple)  # 输出：(1, 2, 3, 'Python', True)

访问元组元素

my_tuple = (1, 2, 3)
print(my_tuple[0])  # 输出：1

元组的不可变性

my_tuple = (1, 2, 3)
try:
    my_tuple[1] = 20
except TypeError as e:
    print(e)  # 输出：'tuple' object does not support item assignment

5. 字典与集合

5.1 字典（Dictionary）

字典是一种可变的、无序的数据集合，键值对存储数据。

创建字典

my_dict = {"name": "Alice", "age": 30, "city": "Beijing"}
print(my_dict)  # 输出：{'name': 'Alice', 'age': 30, 'city': 'Beijing'}

访问字典元素

my_dict = {"name": "Alice", "age": 30, "city": "Beijing"}
print(my_dict["name"])  # 输出：Alice

修改字典元素

my_dict = {"name": "Alice", "age": 30, "city": "Beijing"}
my_dict["age"] = 31
print(my_dict)  # 输出：{'name': 'Alice', 'age': 31, 'city': 'Beijing'}

字典方法

my_dict = {"name": "Alice", "age": 30, "city": "Beijing"}
my_dict["gender"] = "female"
my_dict.update({"hobby": "coding"})
print(my_dict)  # 输出：{'name': 'Alice', 'age': 31, 'city': 'Beijing', 'gender': 'female', 'hobby': 'coding'}

5.2 集合（Set）

集合是一种可变的、无序的数据集合，不允许重复元素。

创建集合

my_set = {1, 2, 3, 4, 5}
print(my_set)  # 输出：{1, 2, 3, 4, 5}

添加元素

my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # 输出：{1, 2, 3, 4}

集合方法

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)
intersection_set = set1.intersection(set2)
print(union_set)  # 输出：{1, 2, 3, 4, 5}
print(intersection_set)  # 输出：{3}

6. 文件操作

文件操作是编程中非常常见的任务，包括读取文件、写入文件等。

6.1 读取文件

with open("example.txt", "r") as file:
    content = file.read()
    print(content)

6.2 写入文件

with open("example.txt", "w") as file:
    file.write("Hello, world!")

6.3 追加文件

with open("example.txt", "a") as file:
    file.write("\nAdditional line")

6.4 文件压缩与解压缩

压缩文件

import zipfile

def compress_files(file_paths, output_filename):
    with zipfile.ZipFile(output_filename, 'w', zipfile.ZIP_DEFLATED) as zipf:
        for file in file_paths:
            zipf.write(file)

compress_files(["file1.txt", "file2.txt"], "archive.zip")

解压缩文件

import zipfile

def extract_files(zip_filename, output_dir):
    with zipfile.ZipFile(zip_filename, 'r') as zipf:
        zipf.extractall(output_dir)

extract_files("archive.zip", "output")

7. 异常处理

异常处理是处理程序在运行时可能出现的错误情况。

7.1 try-except 结构

try:
    x = 10 / 0
except ZeroDivisionError as e:
    print(e)  # 输出：division by zero

7.2 try-except-else 结构

try:
    x = 10 / 5
except ZeroDivisionError as e:
    print(e)
else:
    print(x)  # 输出：2.0

7.3 try-except-finally 结构

try:
    x = 10 / 0
except ZeroDivisionError as e:
    print(e)  # 输出：division by zero
finally:
    print("This is always executed")

8. 模块与包

8.1 导入模块

Python中可以通过import语句导入模块。

import math

result = math.sqrt(16)
print(result)  # 输出：4.0

8.2 从模块导入特定函数

from math import sqrt

result = sqrt(16)
print(result)  # 输出：4.0

8.3 创建模块

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

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

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

然后在另一个文件中导入：

from my_module import add, greet

print(add(3, 4))  # 输出：7
print(greet("Alice"))  # 输出：Hello, Alice!

8.4 创建包

创建一个简单的包my_package，其中包含一个模块module1.py：

my_package/
│
├── __init__.py
└── module1.py

module1.py：

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

然后在另一个文件中导入：

from my_package.module1 import add

print(add(3, 4))  # 输出：7

9. 高级特性

9.1 列表推导式

列表推导式是一种简洁的语法，用于快速生成列表。

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

9.2 生成器表达式

生成器表达式是生成器的推导形式，用于生成动态的迭代器。

gen = (x**2 for x in range(1, 6))
print(next(gen))  # 输出：1
print(next(gen))  # 输出：4

9.3 迭代器

迭代器用于遍历集合的元素。

class MyIterator:
    def __init__(self, n):
        self.n = n
        self.current = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.current >= self.n:
            raise StopIteration
        self.current += 1
        return self.current

my_iter = MyIterator(5)
for i in my_iter:
    print(i)  # 输出：1, 2, 3, 4, 5

9.4 生成器函数

生成器函数使用yield关键字生成值。

def my_generator(n):
    for i in range(n):
        yield i**2

gen = my_generator(5)
print(next(gen))  # 输出：0
print(next(gen))  # 输出：1

9.5 装饰器

装饰器是一种特殊类型的函数，可以修改或增强其他函数的功能。

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

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

say_hello()  # 输出：Something is happening before the function is called.
             #       Hello!
             #       Something is happening after the function is called.

9.6 上下文管理器

上下文管理器允许资源在使用完毕后自动释放，如文件打开和关闭。

class ManagedResource:
    def __enter__(self):
        print("Resource acquired via __enter__")
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        print("Resource released via __exit__")

    def do_something(self):
        print("Doing something with the resource")

with ManagedResource() as resource:
    resource.do_something()

9.7 多线程与多进程

多线程

import threading

def worker():
    print(f"Worker thread started")

for _ in range(5):
    thread = threading.Thread(target=worker)
    thread.start()

多进程

import multiprocessing

def worker():
    print(f"Worker process started")

for _ in range(5):
    process = multiprocessing.Process(target=worker)
    process.start()

10. 面向对象编程

10.1 类定义

在Python中，使用class关键字定义类。

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

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

person = Person("Alice", 30)
print(person.greet())  # 输出：Hello, my name is Alice and I'm 30 years old.

10.2 继承

类可以继承其他类，以实现代码复用。

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

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

student = Student("Bob", 15, 10)
print(student.greet())  # 输出：Hello, my name is Bob and I'm 15 years old.
print(student.study())  # 输出：Bob is studying in grade 10.

10.3 类属性与实例属性

类属性是所有实例共享的属性，而实例属性是每个实例独有的。

class Vehicle:
    wheels = 4  # 类属性

    def __init__(self, brand):
        self.brand = brand  # 实例属性

car = Vehicle("Toyota")
print(car.wheels)  # 输出：4
print(car.brand)  # 输出：Toyota

10.4 魔法方法

魔法方法是一些特殊的方法，使用双下划线开头和结尾，用于实现特定的功能。

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author

    def __str__(self):
        return f"{self.title} by {self.author}"

    def __repr__(self):
        return f"Book(title={self.title}, author={self.author})"

book = Book("Python Crash Course", "Eric Matthes")
print(book)  # 输出：Python Crash Course by Eric Matthes
print(repr(book))  # 输出：Book(title=Python Crash Course, author=Eric Matthes)

11. 数据结构与算法

11.1 常见的数据结构

Python中常用的内置数据结构包括列表、元组、字典、集合等。

列表

my_list = [1, 2, 3, 4, 5]
print(my_list)  # 输出：[1, 2, 3, 4, 5]

元组

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple)  # 输出：(1, 2, 3, 4, 5)

字典

my_dict = {"name": "Alice", "age": 30, "city": "Beijing"}
print(my_dict)  # 输出：{'name': 'Alice', 'age': 30, 'city': 'Beijing'}

集合

my_set = {1, 2, 3, 4, 5}
print(my_set)  # 输出：{1, 2, 3, 4, 5}

11.2 常见的算法

二分查找

def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

sorted_list = [1, 2, 3, 4, 5, 6, 7]
index = binary_search(sorted_list, 4)
print(index)  # 输出：3

插入排序

def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr

unsorted_list = [7, 2, 5, 1, 3, 8]
sorted_list = insertion_sort(unsorted_list)
print(sorted_list)  # 输出：[1, 2, 3, 5, 7, 8]

11.3 链表

链表是一种常见的数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的引用。

单链表

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            return
        last = self.head
        while last.next:
            last = last.next
        last.next = new_node

    def display(self):
        elements = []
        current = self.head
        while current:
            elements.append(current.data)
            current = current.next
        return elements

linked_list = LinkedList()
linked_list.append(1)
linked_list.append(2)
linked_list.append(3)
print(linked_list.display())  # 输出：[1, 2, 3]

双链表

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.prev = None

class DoublyLinkedList:
    def __init__(self):
        self.head = None
        self.tail = None

    def append(self, data):
        new_node = Node(data)
        if not self.head:
            self.head = new_node
            self.tail = new_node
            return
        self.tail.next = new_node
        new_node.prev = self.tail
        self.tail = new_node

    def display(self):
        elements = []
        current = self.head
        while current:
            elements.append(current.data)
            current = current.next
        return elements

doubly_linked_list = DoublyLinkedList()
doubly_linked_list.append(1)
doubly_linked_list.append(2)
doubly_linked_list.append(3)
print(doubly_linked_list.display())  # 输出：[1, 2, 3]

11.4 栈和队列

栈（LIFO）

class Stack:
    def __init__(self):
        self.items = []

    def is_empty(self):
        return len(self.items) == 0

    def push(self, item):
        self.items.append(item)

    def pop(self):
        if not self.is_empty():
            return self.items.pop()
        return None

    def peek(self):
        if not self.is_empty():
            return self.items[-1]
        return None

    def size(self):
        return len(self.items)

stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)
print(stack.pop())  # 输出：3
print(stack.peek())  # 输出：2
print(stack.size())  # 输出：2

队列（FIFO）

class Queue:
    def __init__(self):
        self.items = []

    def is_empty(self):
        return len(self.items) == 0

    def enqueue(self, item):
        self.items.append(item)

    def dequeue(self):
        if not self.is_empty():
            return self.items.pop(0)
        return None

    def size(self):
        return len(self.items)

queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
print(queue.dequeue())  # 输出：1
print(queue.size())  # 输出：2

12. 实践示例

12.1 实现一个简单的计算器

下面是一个简单的计算器，可以执行加法、减法、乘法和除法操作。

class Calculator:
    def add(self, a, b):
        return a + b

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

    def multiply(self, a, b):
        return a * b

    def divide(self, a, b):
        if b == 0:
            return "Cannot divide by zero"
        return a / b

calculator = Calculator()
print(calculator.add(2, 3))  # 输出：5
print(calculator.subtract(5, 2))  # 输出：3
print(calculator.multiply(4, 5))  # 输出：20
print(calculator.divide(10, 2))  # 输出：5.0
print(calculator.divide(10, 0))  # 输出：Cannot divide by zero

12.2 实现一个简单的文本处理工具

下面是一个简单的文本处理工具，可以读取一个文本文件并统计每个单词的出现次数。

import re

def count_words(filename):
    word_count = {}
    with open(filename, "r") as file:
        content = file.read()
        words = re.findall(r'\w+', content)
        for word in words:
            word = word.lower()
            if word in word_count:
                word_count[word] += 1
            else:
                word_count[word] = 1
    return word_count

word_counts = count_words("example.txt")
for word, count in word_counts.items():
    print(f"{word}: {count}")

12.3 实现一个简单的图形界面应用

下面是一个使用Tkinter库实现的简单图形界面应用，用户可以输入一个数字并显示其平方。

import tkinter as tk

def square(number):
    return number ** 2

def on_button_click():
    number = float(entry.get())
    result = square(number)
    result_label.config(text=f"The square of {number} is {result}")

root = tk.Tk()
root.title("Square Calculator")

label = tk.Label(root, text="Enter a number:")
label.pack()

entry = tk.Entry(root)
entry.pack()

button = tk.Button(root, text="Calculate", command=on_button_click)
button.pack()

result_label = tk.Label(root, text="")
result_label.pack()

root.mainloop()

12.4 实现JWT开发

JWT（JSON Web Token）是一种开放标准（RFC 7519），用于在网络应用环境间安全地传输信息。下面的例子展示了如何生成和验证JWT。

生成JWT

import jwt
import datetime

def create_jwt_token(secret_key, payload):
    token = jwt.encode(payload, secret_key, algorithm="HS256")
    return token

secret_key = "secret"
payload = {
    "user_id": 1,
    "exp": datetime.datetime.utcnow() + datetime.timedelta(seconds=30)
}

token = create_jwt_token(secret_key, payload)
print(token)

验证JWT

def verify_jwt_token(token, secret_key):
    try:
        decoded = jwt.decode(token, secret_key, algorithms=["HS256"])
        return decoded
    except jwt.ExpiredSignatureError:
        return "Token expired"
    except jwt.InvalidTokenError:
        return "Invalid token"

print(verify_jwt_token(token, secret_key))

13. 总结与进阶学习

本文介绍了Python编程语言的基础语法和一些常见的高级特性，包括变量与数据类型、控制结构、函数、数据结构、文件操作、异常处理、模块与包、面向对象编程等。通过上述示例，您已经了解了如何使用Python进行编程。接下来，您可以尝试掌握更多的Python高级特性，例如装饰器、上下文管理器、多线程与多进程等。此外，您还可以通过编程挑战和实际项目来提升您的编程技能。推荐您访问慕课网，那里提供了丰富的Python学习资源，可以帮助您进一步提升Python编程技能。