B站|公众号：啥都会一点的研究生
相关阅读
这七个100%提高Python代码性能的技巧，一定要知道
整理了几个100%会踩的Python细节坑，提前防止脑血栓
整理了十个100%提高效率的Python编程技巧，更上一层楼
Python-列表，从基础到进阶用法大总结，进来查漏补缺
Python-元组，从基础到进阶用法大总结及与列表核心区别，进来查漏补缺
Python-字典，从基础到进阶用法大总结，进来查漏补缺
Python-集合，从基础到进阶大总结，进来查漏补缺
这些包括我在内都有的Python编程陋习，趁早改掉
Python可变类型的坑，不要再踩了
列表推导式，Python中最好的特性？可读性？
元组啊，不就是不可变的列表吗？
订阅专栏 ===> Python
hello我是啥都生，在这篇文章中，介绍17个有很大改进空间的Python编程案例，既然都用Python了，那么提供的轮子就赶紧用起来哈哈，一起看看吧~
1.使用多个打印语句
初级
如果想打印多个变量，部分人会觉得每个变量都应该有自己的 print() 语句，哈哈哈以前我也是
a, b, c = 10, 5, 3
print(a)
print(b)
print(c)
# 10
# 5
# 3
进阶
使用多个打印语句尤其是新手在使用 Python 编码时最常犯的错误，其实，使用print()，可以在单个打印语句中打印多个变量，如下所示：
a, b, c = 10, 5, 3
print(a, b, c, sep = "\n")
# 10
# 5
# 3
上面的 sep参数指定使用相同打印语句（上面的 a、b 和c）打印的各种变量之间的分隔符
注意，
end参数用于指定print语句的结束符
a, b, c = 10, 5, 3
print(a, end = "\n---\n")
print(b, end = "\n---\n")
print(c)
# 10
# ---
# 5
# ---
# 3
在上面的代码中，end='\n---\n' 参数打印换行符，再是 ---，然后是换行符
2. 使用Print语句代替日志记录模块
在小型项目中可能无关紧要，我自己也是喜欢print，但值得一提的是大型项目中日志就太重要了
初级
>>> print('This is a warning message')
# This is a warning message
>>> print('This is an error message')
# This is an error message
>>> print('This is a critical message')
# This is a critical message
进阶
>>> import logging
>>> logging.warning('This is a warning message')
# WARNING:root:This is a warning message
>>> logging.error('This is an error message')
# ERROR:root:This is an error message
>>> logging.critical('This is a critical message')
# CRITICAL:root:This is a critical message
3.使用for循环打印相同的变量
初级
如标题所述，我们的目标是多次打印同一个变量
当然，创建一个for循环打印，能说这有问题吗，当然没什么问题
repeat = 10
a = "ABC"
for _ in range(repeat):
print(a, end = "")
# ABCABCABCABCABCABCABCABCABCABC
进阶
虽然写一个for循环没坏处，但没必要，可以这样
repeat = 10
a = "ABC"
print(a*repeat)
# ABCABCABCABCABCABCABCABCABCABC
4.创建一个单独的变量来跟踪循环中的索引
初级 - 1
为实现这一点，通常会定义一个新变量 idx 来跟踪索引值并在每次迭代时递增它，如下所示：
idx = 0
char_list = ["a", "b", "c", "d", "e", "f"]
for i in char_list:
print("index =", idx, "value =", i, sep = " ")
idx += 1
# index = 0 value = a
# index = 1 value = b
# index = 2 value = c
# index = 3 value = d
# index = 4 value = e
# index = 5 value = f
初级 - 2
或者，创建一个range迭代器来跟踪索引，如下：
char_list = ["a", "b", "c", "d", "e", "f"]
for idx in range(len(char_list)):
print("index =", idx, "value =", char_list[idx], sep = " ")
idx += 1
# index = 0 value = a
# index = 1 value = b
# index = 2 value = c
# index = 3 value = d
# index = 4 value = e
# index = 5 value = f
进阶
不得不提enumerate()方法，使用此方法，可以跟踪索引idx和值i，如下所示：
char_list = ["a", "b", "c", "d", "e", "f"]
for idx, i in enumerate(char_list):
print("index =", idx, "value =", i, sep = " ")
# index = 0 value = a
# index = 1 value = b
# index = 2 value = c
# index = 3 value = d
# index = 4 value = e
# index = 5 value = f
5.使用for循环将列表转换为字符串
初级
如下所示，使用for循环一次拼接列表中的一个元素
char_list = ["A", "B", "C", "D", "E"]
final_str = ""
for i in char_list:
final_str += i
print(final_str)
# ABCDE
进阶
其实将列表转换为字符串的简便方法是使用 join() 方法，如下所示：
char_list = ["A", "B", "C", "D", "E"]
final_str = "".join(char_list)
print(final_str)
# ABCDE
这不仅能免于编写一些不必要的长代码，而且与 for 循环方法一样直观。
6.使用for循环从列表中删除重复项
初级
遍历输入列表并将唯一元素存储在新列表中
char_list = ["A", "B", "A", "D", "C", "B", "E"]
final_list = []
for i in char_list:
if i not in final_list:
final_list.append(i)
print(final_list)
# ['A', 'B', 'D', 'C', 'E']
进阶
其实，集合就行啦，使用一行代码就可以从列表中删除重复项
char_list = ["A", "B", "A", "D", "C", "B", "E"]
set(list(char_list))
# {'A', 'B', 'C', 'D', 'E'}
二者可以相互转换
char_list = ["A", "B", "A", "D", "C", "B", "E"]
list(set(list(char_list)))
# ['E', 'A', 'B', 'C', 'D']
7.使用for循环在列表中搜索元素
初级
假设想知道某个元素是否存在于列表（或集合）中并返回布尔（如果存在则为True，否则为False）
初级用法如下所示：
char_list = ["A", "B", "A", "D", "C", "B", "E"]
search_char = "D"
found = False
for i in char_list:
if i == search_char:
found = True
break
print(found)
# True
太复杂了
进阶
使用in关键字将其简化为单行实现
char_list = ["A", "B", "A", "D", "C", "B", "E"]
search_char = "D"
search_char in char_list
# True
8.使用索引变量迭代两个相同size的可迭代对象
初级
类似于在第4节中所提，定义一个专门用于索引的变量，在两个size相同的列表中取值，如下所示：
list1 = [1, 3, 6, 2, 5]
list2 = [0, 4, 1, 9, 7]
for idx in range(len(list1)):
print("value1 =", list1[idx], "value2 =", list2[idx], sep = " ")
# value1 = 1 value2 = 0
# value1 = 3 value2 = 4
# value1 = 6 value2 = 1
# value1 = 2 value2 = 9
# value1 = 5 value2 = 7
进阶
进阶一点的方法是使用zip()函数，将两个可迭代对象中的相应值配对
list1 = [1, 3, 6, 2, 5]
list2 = [0, 4, 1, 9, 7]
for i, j in zip(list1, list2):
print("value1 =", i, "value2 =", j, sep = " ")
# value1 = 1 value2 = 0
# value1 = 3 value2 = 4
# value1 = 6 value2 = 1
# value1 = 2 value2 = 9
# value1 = 5 value2 = 7
9.使用for循环反转列表
初级
反向迭代列表并将元素添加到新列表，如下所示：
input_list = [1, 2, 3, 4, 5]
output_list = []
for idx in range(len(input_list), 0, -1):
output_list.append(input_list[idx-1])
print(output_list)
# [5, 4, 3, 2, 1]
进阶
如果了解 Python 中的切片，那么一个简单的单行代码就可以实现（其实内置方法等都可以实现）
input_list = [1, 2, 3, 4, 5]
output_list = input_list[::-1]
print(output_list)
# [5, 4, 3, 2, 1]
10.使用for循环计算可迭代对象中元素的出现次数
初级
查找元素频率的简单方法是使用for循环遍历列表并计算次数
char_list = ["A", "B", "A", "D", "C", "B", "E"]
search_char = "B"
char_count = 0
for i in char_list:
if search_char == i:
char_count += 1
print(char_count)
# 2
进阶
其实可以使用count()方法：
char_list = ["A", "B", "A", "D", "C", "B", "E"]
char_list.count("A")
# 2
同样的，也可以在字符串中使用：
string = "ABADCBE"
string.count("A")
# 2
11.使用for循环获取字符串的子字符串
初级
这里的目标是返回一个长度为n_chars的子串，从位置start_index开始。
很多人解决这个问题的方法是使用for循环，如下所示：
input_str = "ABCDEFGHIJKL"
start_index = 4
n_chars = 5
output_str = ""
for i in range(n_chars):
output_str += input_str[i+start_index]
print(output_str)
# EFGHI
进阶
单行方法是使用切片，这样可以避免编写for循环
input_str = "ABCDEFGHIJKL"
start_index = 4
n_chars = 5
output_str = input_str[start_index:start_index+n_chars]
print(output_str)
# EFGHI
12.定义长整型常量
假设想声明一个值为 10²¹ 的整型变量
初级
x = 1000000000000000000000
# True
很多情况下，会连续写入零并在键入时进行计数
但是别人若要参考这段代码，就得把所有的零都数一遍，当场去世
进阶
为提高可读性，可以用_（下划线）分隔，如下：
x = 1_000_000_000_000_000_000_000
但这仍然很麻烦，还是要数零。
如果数字能以 a^b 的形式表示，则可以改用 pow() 方法：
x = pow(10, 21)
13.使用if条件更改字符串的大小写
给定一个字符串，目标是将大写字母变为小写，反之亦然
初级
检查每个元素的情况，然后为每个情况设置特定条件
input_str = "AbCDeFGhIjkl"
output_str = ""
for i in input_str:
if i.islower():
output_str += i.upper()
elif i.isupper():
output_str += i.lower()
else:
output_str += i
print(output_str)
# aBcdEfgHiJKL
进阶
可以改用swapcase()方法。
input_str = "AbCDeFGhIjkl"
output_str = input_str.swapcase()
print(output_str)
# aBcdEfgHiJKL
14.获得两个集合的并集
初级
迭代这两个集合并将元素添加到一个新集合中
set_a = {
1, 2, 4, 8}
set_b = {
3, 8, 7, 1, 9}
union_set = set()
for i in set_a:
union_set.add(i)
for i in set_b:
union_set.add(i)
print(union_set)
# {1, 2, 3, 4, 7, 8, 9}
进阶
Python 为两个集合的并集提供了union()方法
set_a = {
1, 2, 4, 8}
set_b = {
3, 8, 7, 1, 9}
union_set = set_a.union(set_b)
print(union_set)
# {1, 2, 3, 4, 7, 8, 9}
更重要的是，可以将其扩展到任意数量的输入集：
set_a = {
1, 2, 4, 8}
set_b = {
3, 8, 7, 1, 9}
set_c = {
5, 9, 10, 3, 2}
set_d = {
7, 2, 13, 15, 0}
union_set = set_a.union(set_b, set_c, set_d)
print(union_set)
# {0, 1, 2, 3, 4, 5, 7, 8, 9, 10, 13, 15}
想象一下，需要编写多少个for循环来合并这四个集合，同样的集合还有求补、交等等便捷内置方法
15.更改列表中所有元素的数据类型
给定一个表示整数的字符串列表，目标是通过更改数据类型将它们转换为整数列表
初级
循环遍历列表并对单个元素进行类型转换
input_list = ["7", "2", "13", "15", "0"]
output_list = []
for idx, i in enumerate(input_list):
output_list.append(int(input_list[idx]))
print(output_list)
# [7, 2, 13, 15, 0]
进阶
使用map()，如下所示：
input_list = ["7", "2", "13", "15", "0"]
output_list = list(map(int, input_list))
print(output_list)
# [7, 2, 13, 15, 0]
作为其第一个参数，map() 方法接受一个函数 int，第二个参数是一个可迭代对象 input_list。
16.交换变量
给定两个变量，目标是将第一个变量的值传递给第二个变量，将第二个变量的值传递给第一个变量
初级
大多数写惯了 C/C++ 的程序员采用的方法是定义一个新变量 temp
a = "123"
b = "abc"
temp = a
a = b
b = temp
print(a, b)
# abc 123
进阶
而Python 允许在单个语句中进行多次赋值，从而消除对临时变量的需要，就是解包啦，之前教程都有说过
a = "123"
b = "abc"
a, b = b, a
print(a, b)
# abc 123
17.使用嵌套循环生成两个列表的所有组合
给定两个列表（a 的长度为 n，b 的长度为 m），生成所有n*m 结构
初级
编写两个嵌套的for循环并将所有组合添加到列表中
list1 = ["A", "B", "C"]
list2 = [1, 2]
combinations = []
for i in list1:
for j in list2:
combinations.append([i, j])
print(combinations)
# [['A', 1], ['A', 2], ['B', 1], ['B', 2], ['C', 1], ['C', 2]]
进阶
使用 itertools 库中的product()方法，如下所示：
from itertools import product
list1 = ["A", "B", "C"]
list2 = [1, 2]
combinations = list(product(list1, list2))
print(combinations)
# [('A', 1), ('A', 2), ('B', 1), ('B', 2), ('C', 1), ('C', 2)]
事实上包括我在内，以前很多时候都习惯于用for循环等解决问题，其实就是对内置函数/方法不熟悉~
以上内容有任何错误欢迎指出，我是啥都生，下期再见