Python 入门经典必背的 18 个程序，学完就入门 Python 了-Toy模板网

这篇具有很好参考价值的文章主要介绍了Python 入门经典必背的 18 个程序，学完就入门 Python 了。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

注意：这是初学者要牢记的 18 个代码，入门之后就简单了。

1、Hello World

print("Hello World!")

这段代码使用 print 函数输出字符串 “Hello World!” 到控制台。

2、计算数字的平方和

以下是使用 python 计算数字的平方和的代码：

def square_sum(numbers):
    sum = 0
    for num in numbers:
        sum += num ** 2
    return sum

print(square_sum([1, 2, 3, 4])) # 输出 30

3、计算简单数学表达式

# 计算简单数学表达式
def calculate(expression):
    return eval(expression)

# 用户输入数学表达式
expression = input("请输入一个数学表达式：")

# 计算并输出结果
print("结果是：", calculate(expression))

4、字符串操作

字符串连接：使用 + 或 + 运算符可以将两个字符串连接起来。
字符串重复：使用 * 运算符可以将字符串重复多次。
字符串截取：使用索引和切片可以截取字符串中的一段。
字符串搜索：使用 in 和 not in 运算符可以在字符串中搜索某个子字符串。
字符串替换：使用 replace() 函数可以将字符串中的一个子字符串替换为另一个子字符串。
字符串分割：使用 split() 函数可以将字符串按照指定的分隔符分割为多个子字符串。

# Define a string
string = "Hello World!"

# Print the original string
print("Original string:", string)

# Get the length of the string
string_length = len(string)
print("Length of the string:", string_length)

# Concatenate two strings
new_string = string + " How are you?"
print("Concatenated string:", new_string)

# Repeat the string
repeated_string = string * 3
print("Repeated string:", repeated_string)

# Get a substring
substring = string[0:5]
print("Substring:", substring)

# Replace a substring
replaced_string = string.replace("Hello", "Hi")
print("Replaced string:", replaced_string)

# Check if a string contains a substring
is_hello_there = "Hello there!"
if "Hello" in is_hello_there:
    print("'Hello' is in the string.")
else:
    print("'Hello' is not in the string.")

5、if 语句

if 语句用于检查一个条件是否为真，如果为真，执行对应的代码块。

语法

if condition:
    # Execute this block if the condition is true
else:
    # Execute this block if the condition is false

范例

x = int(input("Enter a number: "))

if x > 0:
    print("Positive number")
elif x < 0:
    print("Negative number")
else:
    print("Zero")

6、for 循环

下面是一段 Python 中使用 for 循环的代码示例：

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print("I like", fruit)

这段代码中，我们创建了一个名为 fruits 的列表，并使用 for` 循环迭代该列表的每一项。在每一次循环迭代中，我们可以访问当前迭代项，并对其进行一些操作，如在这里打印。

7、while 循环

i = 1
while i <= 10:
    print(i)
    i += 1

以上是一个简单的 Python while 循环。
在循环内，每次执行 i 的值都会自增 1 ，直到当前的 i 值大于等于 10 时循环终止。
循环体中的代码每次都会被执行，因此每次执行后 i 的值会被更新。

8、函数定义和调用

函数是 Python 中实现模块化编程的一种重要手段。它是一组功能性代码的封装，可以方便地调用。以下是一个简单的函数定义示例：

def say_hello(name):
    """
    输出Hello，加上参数
    """
    print("Hello, " + name)

以上代码定义了一个函数 say_hello，该函数接收一个名为 name 的参数，并在调用时打印出 “Hello, ” 加上参数。

如果要调用这个函数，可以在代码中调用：

say_hello("Tom")

9、列表操作

Python 列表是一种动态的、有序的数据结构，它可以包含不同的数据类型，并且可以通过索引来访问列表中的元素。以下是列表的一些常用操作：

创建列表：可以使用方括号（ [] ）将元素放入列表中，例如：

a = [1, 2, 3, 4]

访问列表元素：可以通过索引访问列表中的元素，例如：

a = [1, 2, 3, 4]
print(a[0]) # 输出 1

修改列表元素：可以通过索引修改列表中的元素，例如：

a = [1, 2, 3, 4]
a[0] = 5
print(a) # 输出 [5, 2, 3, 4]

删除列表元素：可以使用 del 关键字删除列表中的元素，例如：

a = [1, 2, 3, 4]
del a[0]
print(a) # 输出 [2, 3, 4]

列表长度：可以使用 len() 函数求列表的长度，例如：

a = [1, 2, 3, 4]
print(len(a)) # 输出 4

列表操作符：可以使用加号（+）和乘号（*）对列表进行操作，例如：

a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
print(c) # 输出 [1, 2, 3, 4, 5, 6]
d = a * 3
print(d) # 输出 [1, 2, 3, 1, 2, 3, 1, 2,

10、字典操作

Python字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(, )分割，整个字典包括在花括号({})中 , 格式如下所示：

d = {key1 : value1, key2 : value2 }

一些常见的字典操作如下：

字典中添加元素：

dict[key] = value

字典中访问元素：

dict[key]

字典中修改元素：

dict[key] = value

字典中删除元素：

del dict[key]

字典中判断一个键是否存在：

key in dict

python中字典是一种无序的键值对集合，每个键都关联了一个值。使用大括号 {} 创建字典，使用方括号 [] 访问字典中的值。例如：

# 创建字典
dict1 = {'name': 'John', 'age': 30, 'gender': 'male'}

# 访问字典中的值
print(dict1['name']) # John

# 修改字典中的值
dict1['age'] = 40
print(dict1) # {'name': 'John', 'age': 40, 'gender': 'male'}

# 删除字典中的键值对
del dict1['gender']
print(dict1) # {'name': 'John', 'age': 40}

# 判断字典中是否包含某个键
print('name' in dict1) # True

其他字典操作方法：

dict.keys()：返回字典中的键列表
dict.values()：返回字典中的值列表
dict.items()：返回字典中的键值对列表
dict.get(key, default)：返回字典中的 key 对应的值，如果 key 不存在，则返回 default

11、元组操作

Python 中的元组是不可变的序列，支持以下操作：
访问：通过索引访问元素。
遍历：使用 for 循环遍历元组中的元素。
计算长度：使用内置函数 len() 计算元组的长度。
合并：使用加号 (+) 将两个元组合并成一个新元组。
元素查找：使用元素值在元组中查找，如果存在返回元素的索引位置，否则返回 ValueError 异常。
统计：统计元素在元组中出现的次数，使用元组的 count() 方法。
元素删除：由于元组是不可变的，所以不能删除元素，但可以删除整个元组。

12、文件操作

下面是 Python 中文件操作的一些基本操作。

读文件
使用 open() 函数打开文件，返回一个文件对象，然后使用 .read() 方法读取文件内容。

f = open("filename.txt", "r")
content = f.read()
f.close()

写文件
使用 open() 函数打开文件，如果文件不存在，会自动创建一个新文件。使用 .write() 方法写入内容：

f = open("filename.txt", "w")
f.write("Some text")
f.close()

追加内容
使用 open() 函数打开文件，使用 "a" 模式打开文件，然后使用 .write() 方法写入内容：

f = open("filename.txt", "a")
f.write("Some more text")
f.close()

使用 with 语句
使用 with 语句可以省去手动关闭文件的步骤，代码也更加简洁：

with open("filename.txt", "r") as f:    
	content = f.read()

读取文件中的一行
使用 .readline() 方法可以读取文件中的一行内容：

with open("filename.txt", "r") as f:    
	line = f.readline()

13、异常处理

Python 中的异常处理操作包括：

try-except 语句：使用 try-except 语句捕获异常，try 语句中的代码可能抛出异常，except 语句用于处理异常。
raise 语句：使用 raise 语句抛出异常，用于主动引发异常。
finally 语句：使用 finally 语句定义清理操作，无论是否发生异常都会执行该语句。
自定义异常：使用 raise 关键字和自定义的异常类，引发自定义的异常。
assert 语句：使用 assert 语句检查条件，如果条件为假，则引发 AssertionError 异常。

14、面向对象编程

面向对象编程 (OOP) 是一种编程范式，其中程序由对象组成，每个对象表示一种实体并具有属性和行为。Python 支持面向对象编程，提供了如下特性：

类：定义对象的抽象模型，包含属性和行为。
对象：实例化类得到的实体，具有类定义的属性和行为。
继承：通过继承，可以从现有的类创建新的类，并继承其属性和行为。
多态：对象可以根据其类型调用不同的行为，即同一消息可以由多个对象响应。
封装：隐藏对象内部状态和实现细节，提供给外部的只有接口。

15、模块和包

Python 模块和包是 Python 程序组织的基本单位。

模块：一个 Python 文件就是一个模块，模块可以包含变量、函数、类等。
包：一个文件夹，其中包含了一组 Python 模块，每个模块可以提供特定的功能。

模块和包可以被导入到其他程序中，以实现代码的复用。

16、常用模块

Python 有很多内置的和第三方模块，以下是一些常用的模块：

os：提供与操作系统交互的功能，如读取文件、创建文件夹等。
sys：提供了一些 Python 解释器和系统相关的变量和函数。
re：提供了正则表达式的功能。
math：提供了数学相关的函数，如三角函数、对数等。
time：提供了时间相关的函数，如读取当前时间、格式化时间等。
random：提供了随机数生成相关的函数。
string：提供了字符串相关的函数，如字符串的替换、拼接等。
datetime：提供了日期和时间处理相关的函数。
collections：提供了高效的数据类型，如列表、字典、集合等。
NumPy：是一个用于科学计算的 Python 模块，提供了高效的数组运算。

17、常见算法实现

排序算法

冒泡排序

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

快速排序

def quick_sort(arr, low, high):
    if low < high:
        pivot = partition(arr, low, high)
        quick_sort(arr, low, pivot-1)
        quick_sort(arr, pivot+1, high)

def partition(arr, low, high):
    pivot = arr[high]
    i = low - 1
    for j in range(low, high):
        if arr[j] < pivot:
            i = i + 1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i + 1], arr[high] = arr[high], arr[i + 1]
    return i + 1

查找算法

顺序查找：

def sequential_search(arr, x):
    for i in range(len(arr)):
        if arr[i] == x:
            return i
    return -1

二分查找：

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

数据结构

队列：

class Queue:
    def __init__(self):
        self.items = []
    def is_empty(self):
        return self.items == []
    def enqueue(self, item):
        self.items.append(item)
    def dequeue(self):
        return self.items.pop(0)
    def size(self):
        return len(self.items)

队列：

class Stack:
    def __init__(self):
        self.items = []
    def is_empty(self):
        return self.items == []
    def push(self, item):
        self.items.append(item)
    def pop(self):
        return self.items.pop()
    def size(self):
        return len(self.items)

18、爬虫程序

以下是一个简单的 Python 爬虫程序，它从网页上爬取文本内容：

import requests
from bs4 import BeautifulSoup

url = 'https://www.example.com/'
page = requests.get(url)
soup = BeautifulSoup(page.content, 'html.parser')
text = soup.get_text()
print(text)