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循环等解决问题,其实就是对内置函数/方法不熟悉~
以上内容有任何错误欢迎指出,我是啥都生,下期再见