你必须掌握的 30 个 Python 代码,短小精悍,用处无穷

开发 前端
Python 语言的核心语法细节,涵盖了从基本的字符串操作、列表和字典操作、异常处理、时间计算、内存占用检查、生成器、质数判断、字符计数、列表交集、字典排序、文件操作等方面。熟悉这些语法细节可以大大提高你在编程中的效率和代码的可读性。

1. 字符串的翻转

字符串的翻转,首先最简单的方法就是利用切片的操作,来实现翻转,其次可以利用 reduce 函数来实现翻转,在 Python 3 中,reduce 函数需要从 functools 中进行导入。

示例:

# 使用切片翻转字符串
original_str = "hello"
reversed_str = original_str[::-1]
print("翻转后的字符串:", reversed_str)  # 输出 翻转后的字符串: olleh
# 使用 reduce 函数翻转字符串
from functools import reduce
reversed_str = reduce(lambda x, y: y + x, original_str)
print("翻转后的字符串:", reversed_str)  # 输出 翻转后的字符串: olleh

解释:

切片操作 [::-1] 可以快速翻转字符串。

reduce 函数通过累积操作将字符串翻转。

2. 判断字符串是否是回文

该例也可以看作是第一例的应用,利用字符串的翻转来判断字符是否是回文字符串。

示例:

def is_palindrome(s):
    return s == s[::-1]
test_str = "madam"
if is_palindrome(test_str):
    print(f"{test_str} 是回文字符串。")  # 输出 madam 是回文字符串。
else:
    print(f"{test_str} 不是回文字符串。")

解释:

回文字符串是指正读和反读都一样的字符串。

使用切片操作 [::-1] 翻转字符串并进行比较。

3. 单词大小写

面对一个字符串,想将里面的单词首字母大写,只需要调用 title() 函数,而所有的字母大写只需要调用 upper() 函数,字符串首字母大写则是调用 capitalize() 函数即可。

示例:

original_str = "hello world"
# 首字母大写
capitalized_str = original_str.capitalize()
print("首字母大写:", capitalized_str)  # 输出 首字母大写: Hello world
# 所有单词首字母大写
title_str = original_str.title()
print("所有单词首字母大写:", title_str)  # 输出 所有单词首字母大写: Hello World
# 所有字母大写
upper_str = original_str.upper()
print("所有字母大写:", upper_str)  # 输出 所有字母大写: HELLO WORLD

解释:

capitalize() 方法将字符串的首字母大写。

title() 方法将字符串中每个单词的首字母大写。

upper() 方法将字符串中的所有字母大写。

4. 字符串的拆分

字符串的拆分可以直接利用 split 函数,进行实现,返回的是列表,而 strip 函数用于移除字符串头尾指定的字符(默认为空格或换行符)。

示例:

# 拆分字符串
sentence = "hello world this is python"
words = sentence.split()
print("拆分后的单词:", words)  # 输出 拆分后的单词: ['hello', 'world', 'this', 'is', 'python']
# 移除字符串头尾的空格
trimmed_str = "   hello world   ".strip()
print("移除空格后的字符串:", trimmed_str)  # 输出 移除空格后的字符串: hello world

解释:

split() 方法将字符串按空格拆分为单词列表。

strip() 方法移除字符串头尾的空格。

5. 将列表中的字符串合并

这一条可以认为是第 4 条的反例,这里是将列表中的字符串合并为字符串。第 4 条可以与第 5 条结合,来去除字符串中不想留下的项。

示例:

# 合并列表中的字符串
words = ["hello", "world", "this", "is", "python"]
sentence = " ".join(words)
print("合并后的字符串:", sentence)  # 输出 合并后的字符串: hello world this is python

解释:

join() 方法将列表中的字符串用指定的分隔符连接成一个字符串。

6. 寻找字符串中唯一的元素

在 Python 中,对于唯一值的筛查,首先应该想到对于 set 的利用,set 可以帮助我们快速的筛查重复的元素,上述程序中,set 不仅可以对字符串,而且还可以针对列表进行筛查。

示例:

# 寻找字符串中的唯一元素
original_str = "hello"
unique_chars = set(original_str)
print("唯一字符:", unique_chars)  # 输出 唯一字符: {'l', 'o', 'h', 'e'}
# 寻找列表中的唯一元素
original_list = [1, 2, 2, 3, 4, 4, 5]
unique_items = set(original_list)
print("唯一元素:", unique_items)  # 输出 唯一元素: {1, 2, 3, 4, 5}

解释:

set 是一种无序不重复的集合,可以快速去重。

7. 将元素进行重复

将元素进行重复,可以采用“乘法”的形式,直接乘以原来的元素,也可以采用“加法”的形式,更方便理解。

示例:

# 使用乘法重复元素
repeated_list = [1, 2] * 3
print("重复后的列表:", repeated_list)  # 输出 重复后的列表: [1, 2, 1, 2, 1, 2]
# 使用加法重复元素
repeated_list = [1, 2] + [1, 2] + [1, 2]
print("重复后的列表:", repeated_list)  # 输出 重复后的列表: [1, 2, 1, 2, 1, 2]

解释:

列表的乘法操作可以重复列表中的元素。

列表的加法操作可以将多个列表合并。

8. 基于列表的扩展

基于列表的扩展,可以充分利用列表的特性和 Python 语法的简洁性,来产生新的列表,或者将嵌套的列表进行展开。

示例:

# 生成新的列表
squares = [x ** 2 for x in range(5)]
print("平方数:", squares)  # 输出 平方数: [0, 1, 4, 9, 16]
# 展开嵌套的列表
nested_list = [[1, 2], [3, 4], [5, 6]]
flattened_list = [item for sublist in nested_list for item in sublist]
print("展开后的列表:", flattened_list)  # 输出 展开后的列表: [1, 2, 3, 4, 5, 6]

解释:

列表推导式可以生成新的列表。

嵌套的列表推导式可以将嵌套的列表展开。

9. 将列表展开

首先,方法 1 中,我们调用的是 iteration_utilities 中的 deepflatten 函数,第二种方法直接采用递归的方法,我们自己来实现复杂列表的展平,便可以得到展开后的列表。

示例:

# 使用 deepflatten 函数
from iteration_utilities import deepflatten
nested_list = [1, [2, [3, 4], 5], 6]
flattened_list = list(deepflatten(nested_list))
print("展开后的列表:", flattened_list)  # 输出 展开后的列表: [1, 2, 3, 4, 5, 6]
# 使用递归方法
def flatten(lst):
    result = []
    for item in lst:
        if isinstance(item, list):
            result.extend(flatten(item))
        else:
            result.append(item)
    return result
nested_list = [1, [2, [3, 4], 5], 6]
flattened_list = flatten(nested_list)
print("展开后的列表:", flattened_list)  # 输出 展开后的列表: [1, 2, 3, 4, 5, 6]

解释:

deepflatten 函数可以递归地展平嵌套列表。

递归方法通过逐层展开嵌套列表来实现展平。

10. 二值交换

Python 中的二值交换,可以直接采用交换的方式,如上图的方法 1,而方法 2 所示的方法,借助第三个变量,来实现了两个数值的交换。

示例:

# 直接交换
a, b = 5, 10
a, b = b, a
print("交换后的值: a =", a, "b =", b)  # 输出 交换后的值: a = 10 b = 5
# 使用第三个变量交换
a, b = 5, 10
temp = a
a = b
b = temp
print("交换后的值: a =", a, "b =", b)  # 输出 交换后的值: a = 10 b = 5

解释:

直接交换使用多重赋值来交换两个变量的值。

使用第三个变量交换通过临时变量来交换两个变量的值。

11. 统计列表中元素的频率

我们可以直接调用 collections 中的 Counter 类来统计元素的数量,当然也可以自己来实现这样的统计,但是从简洁性来讲,还是以 Counter 的使用比较方便。

示例:

from collections import Counter
# 使用 Counter 统计频率
items = [1, 2, 2, 3, 4, 4, 4]
counter = Counter(items)
print("元素频率:", counter)  # 输出 元素频率: Counter({4: 3, 2: 2, 1: 1, 3: 1})
# 自己实现统计频率
frequency = {}
for item in items:
    if item in frequency:
        frequency[item] += 1
    else:
        frequency[item] = 1
print("元素频率:", frequency)  # 输出 元素频率: {1: 1, 2: 2, 3: 1, 4: 3}

解释:

Counter 类可以快速统计列表中元素的频率。

自己实现统计频率通过字典来记录每个元素出现的次数。

12. 判断字符串所含元素是否相同

Counter 函数还可以用来判断字符串中包含的元素是否相同,无论字符串中元素顺序如何,只要包含相同的元素和数量,就认为其是相同的。

示例:

from collections import Counter
# 判断字符串是否包含相同的元素
str1 = "abc"
str2 = "cba"
str3 = "abcd"
if Counter(str1) == Counter(str2):
    print(f"{str1} 和 {str2} 包含相同的元素。")  # 输出 abc 和 cba 包含相同的元素。
else:
    print(f"{str1} 和 {str2} 不包含相同的元素。")
if Counter(str1) == Counter(str3):
    print(f"{str1} 和 {str3} 包含相同的元素。")
else:
    print(f"{str1} 和 {str3} 不包含相同的元素。")  # 输出 abc 和 abcd 不包含相同的元素。

解释:

Counter 对象可以比较两个字符串中元素的频率,从而判断它们是否包含相同的元素。

13. 将数字字符串转化为数字列表

上述程序中,方法 1 利用的 map 函数,map 函数可以将 str19 中的每个元素都执行 int 函数,其返回的是一个迭代器,利用 list 函数来将其转化为列表的形式。注意,在 Python 2 中执行 map 函数就会直接返回列表,而 Python 3 做了优化,返回的是迭代器,节省了内存。

示例:

# 使用 map 函数
str19 = "1 2 3 4 5"
num_list = list(map(int, str19.split()))
print("数字列表:", num_list)  # 输出 数字列表: [1, 2, 3, 4, 5]
# 使用列表推导式
num_list = [int(num) for num in str19.split()]
print("数字列表:", num_list)  # 输出 数字列表: [1, 2, 3, 4, 5]

解释:

map 函数将字符串中的每个元素转换为整数。

列表推导式也可以实现相同的功能,更加简洁。

14. 使用 try-except-finally 模块

当我们在执行程序时,可能会遇到某些不可预知的错误,使用 try-except 可以帮助我们去捕获这些错误,然后输出提示。注意,如果需要程序无论是否出错,都要执行一些程序的话,需要利用 finally 来实现。

示例:

# 使用 try-except-finally
try:
    num = int(input("请输入一个数字: "))
    result = 10 / num
    print("结果:", result)
except ZeroDivisionError:
    print("不能除以零。")
except ValueError:
    print("无效输入。")
finally:
    print("程序结束。")

解释:

try 块用于尝试可能引发异常的代码。

except 块用于捕获并处理异常。

finally 块无论是否有异常都会执行。

15. 使用 enumerate() 函数来获取索引-数值对

enumerate() 函数用于将一个可遍历的数据对象(如上图的列表,字符串)组合为一个索引序列。

示例:

# 使用 enumerate 函数
fruits = ["apple", "banana", "cherry"]
for index, fruit in enumerate(fruits):
    print(f"索引: {index}, 水果: {fruit}")
# 输出
# 索引: 0, 水果: apple
# 索引: 1, 水果: banana
# 索引: 2, 水果: cherry

解释:

enumerate 函数返回一个包含索引和值的枚举对象。

16. 代码执行消耗时间

利用 time 函数,在核心程序开始前记住当前时间点,然后在程序结束后计算当前时间点和核心程序开始前的时间差,可以帮助我们计算程序执行所消耗的时间。

示例:

import time
# 计算代码执行时间
start_time = time.time()
# 核心代码
time.sleep(2)
end_time = time.time()
execution_time = end_time - start_time
print("代码执行时间:", execution_time, "秒")  # 输出 代码执行时间: 2.00012345 秒

解释:

time.time() 返回当前时间戳。

通过计算开始时间和结束时间的差值来获取代码执行时间。

17. 检查对象的内存占用情况

在 Python 中可以使用 sys.getsizeof 来查看元素所占内存的大小。

示例:

import sys
# 检查对象的内存占用
num = 10
str1 = "hello"
list1 = [1, 2, 3]
print("数字占用内存:", sys.getsizeof(num), "字节")  # 输出 数字占用内存: 28 字节
print("字符串占用内存:", sys.getsizeof(str1), "字节")  # 输出 字符串占用内存: 54 字节
print("列表占用内存:", sys.getsizeof(list1), "字节")  # 输出 列表占用内存: 88 字节

解释:

sys.getsizeof 函数返回对象在内存中占用的字节数。

18. 字典的合并

在 Python 3 中,提供了新的合并字典的方式,如方法 1 所示,此外 Python 3 还保留了 Python 2 的合并字典的方式,如方法 2 所示。

示例:

# 使用新的合并方式
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
merged_dict = {**dict1, **dict2}
print("合并后的字典:", merged_dict)  # 输出 合并后的字典: {'a': 1, 'b': 3, 'c': 4}
# 使用 update 方法
dict1 = {"a": 1, "b": 2}
dict2 = {"b": 3, "c": 4}
dict1.update(dict2)
print("合并后的字典:", dict1)  # 输出 合并后的字典: {'a': 1, 'b': 3, 'c': 4}

解释:

使用解包操作 {**dict1, **dict2} 可以合并两个字典。

update 方法在原字典上添加另一个字典的键值对。

19. 随机采样

使用 random.sample 函数,可以从一个序列中选择 n_samples 个随机且独立的元素。

示例:

import random
# 随机采样
items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sampled_items = random.sample(items, 5)
print("随机采样的元素:", sampled_items)  # 输出 随机采样的元素: [2, 5, 3, 7, 9]

解释:

random.sample 函数从列表中随机选择指定数量的元素。

20. 检查唯一性

通过检查列表长度是否与 set 后的列表长度一致,来判断列表中的元素是否是独一无二的。

示例:

# 检查列表中的元素是否唯一
items = [1, 2, 3, 4, 5]
if len(items) == len(set(items)):
    print("列表中的元素是唯一的。")  # 输出 列表中的元素是唯一的。
else:
    print("列表中的元素不是唯一的。")
items = [1, 2, 2, 3, 4, 5]
if len(items) == len(set(items)):
    print("列表中的元素是唯一的。")
else:
    print("列表中的元素不是唯一的。")  # 输出 列表中的元素不是唯一的。

解释:

set 去重后,如果长度与原列表长度相同,则说明列表中的元素是唯一的。

21. 生成斐波那契数列

生成斐波那契数列是一个经典的编程问题,可以使用生成器来实现。

示例:

# 生成斐波那契数列
def fibonacci(n):
    a, b = 0, 1
    while a < n:
        yield a
        a, b = b, a + b
# 使用生成器
for num in fibonacci(10):
    print(num)
# 输出
# 0
# 1
# 1
# 2
# 3
# 5
# 8

解释:

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

生成器函数每次调用时返回一个值,并保留状态。

22. 计算列表的平均值

计算列表中所有元素的平均值是一个常见的需求,可以使用简单的数学运算来实现。

示例:

# 计算列表的平均值
numbers = [1, 2, 3, 4, 5]
average = sum(numbers) / len(numbers)
print("平均值:", average)  # 输出 平均值: 3.0

解释:

sum() 函数计算列表中所有元素的总和。

len() 函数返回列表的长度。

平均值通过总和除以长度来计算。

23. 判断一个数是否为质数

判断一个数是否为质数是另一个经典的编程问题,可以通过检查该数是否能被小于其平方根的任何数整除来实现。

示例:

# 判断一个数是否为质数
def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True
# 测试
num = 17
if is_prime(num):
    print(f"{num} 是质数。")  # 输出 17 是质数。
else:
    print(f"{num} 不是质数。")

解释:

质数是大于 1 且只能被 1 和自身整除的自然数。

通过检查小于等于其平方根的所有数来判断是否为质数。

24. 计算字符串中每个字符的出现次数

计算字符串中每个字符的出现次数可以使用 collections.Counter 类来实现。

示例:

from collections import Counter
# 计算字符串中每个字符的出现次数
text = "hello world"
char_count = Counter(text)
print("字符出现次数:", char_count)  # 输出 字符出现次数: Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

解释:

Counter 类可以快速统计字符串中每个字符的出现次数。

25. 检查两个列表是否有共同元素

检查两个列表是否有共同元素可以通过集合的交集操作来实现。

示例:

# 检查两个列表是否有共同元素
list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common_elements = set(list1) & set(list2)
if common_elements:
    print("两个列表有共同元素:", common_elements)  # 输出 两个列表有共同元素: {4, 5}
else:
    print("两个列表没有共同元素。")

解释:

将列表转换为集合,然后使用交集操作 & 来检查共同元素。

26. 将字典按值排序

将字典按值排序可以使用 sorted 函数和 lambda 表达式来实现。

示例:

# 将字典按值排序
scores = {"Alice": 95, "Bob": 85, "Charlie": 90}
sorted_scores = sorted(scores.items(), key=lambda x: x[1], reverse=True)
print("按值排序后的字典:", sorted_scores)  # 输出 按值排序后的字典: [('Alice', 95), ('Charlie', 90), ('Bob', 85)]

解释:

sorted 函数可以对字典的项进行排序。

key=lambda x: x[1] 指定按值排序。

reverse=True 指定降序排序。

27. 从字典中删除指定的键

从字典中删除指定的键可以使用 pop 方法或 del 语句来实现。

示例:

# 从字典中删除指定的键
scores = {"Alice": 95, "Bob": 85, "Charlie": 90}
# 使用 pop 方法
removed_value = scores.pop("Bob")
print("删除后的字典:", scores)  # 输出 删除后的字典: {'Alice': 95, 'Charlie': 90}
print("删除的值:", removed_value)  # 输出 删除的值: 85
# 使用 del 语句
del scores["Charlie"]
print("删除后的字典:", scores)  # 输出 删除后的字典: {'Alice': 95}

解释:

pop 方法删除指定键并返回对应的值。

del 语句删除指定键。

28. 检查文件是否存在

检查文件是否存在可以使用 os.path.exists 函数来实现。

示例:

import os
# 检查文件是否存在
file_path = "example.txt"
if os.path.exists(file_path):
    print("文件存在。")
else:
    print("文件不存在。")

解释:

os.path.exists 函数检查指定路径的文件是否存在。

29. 读取文件的每一行

读取文件的每一行可以使用 with 语句和 for 循环来实现。

示例:

# 读取文件的每一行
file_path = "example.txt"
with open(file_path, 'r', encoding='utf-8') as file:
    for line in file:
        print("行内容:", line.strip())  # 输出 行内容: 你好,世界!

解释:

with 语句确保文件在操作完成后自动关闭。

for 循环逐行读取文件内容。

30. 将列表中的元素转换为字符串

将列表中的元素转换为字符串可以使用 map 函数和 join 方法来实现。

示例:

# 将列表中的元素转换为字符串
numbers = [1, 2, 3, 4, 5]
str_numbers = ", ".join(map(str, numbers))
print("转换后的字符串:", str_numbers)  # 输出 转换后的字符串: 1, 2, 3, 4, 5

解释:

map 函数将列表中的每个元素转换为字符串。

join 方法将列表中的字符串用逗号和空格连接成一个字符串。

总结

以上是 Python 语言的核心语法细节,涵盖了从基本的字符串操作、列表和字典操作、异常处理、时间计算、内存占用检查、生成器、质数判断、字符计数、列表交集、字典排序、文件操作等方面。熟悉这些语法细节可以大大提高你在编程中的效率和代码的可读性。

责任编辑:武晓燕 来源: 测试开发学习交流
相关推荐

2020-03-03 14:55:03

Python代码编程语言

2020-03-03 10:18:42

Python数据程序员

2020-12-30 19:08:16

Python编程程序段

2021-06-08 09:36:20

Python代码内存

2022-04-25 08:43:47

pandas代码Python

2023-12-06 09:49:36

自动驾驶算法

2021-04-12 15:34:33

C语言printfscanf

2021-12-19 22:48:53

JavaScript开发代码

2020-12-10 11:00:37

JavaJVM命令

2024-09-13 09:59:27

2017-11-23 15:24:35

Python速览实战

2020-09-15 08:53:08

parallelStr表达式函数

2020-04-08 17:10:03

GitHub代码开源

2019-06-24 09:57:39

网络工具调试

2018-06-21 11:03:54

shelllinux命令

2012-05-22 00:55:44

代码工具CodeMirror

2010-07-16 14:00:07

乔布斯

2021-01-19 22:27:36

Python编程语言开发

2023-09-21 14:55:24

Web 开发TypeScript

2019-06-20 17:39:12

Android启动优化
点赞
收藏

51CTO技术栈公众号