每天都在用的20个Python技巧，学编程的你知道几个？

---

包含编程资料、学习路线图、源代码、软件安装包等！【[点击这里]】！

---

1.单行代码实现变量值交换

• 学过 C 语言的朋友应该知道，要想交换两个变量的值，总是需要借助第三个变量缓存，像这样：

a = 3;   
b = 4;   
c = a; 
a = b; 
b = c;   

• 但是在Python中，你可以直接调换顺序完成变量值交换：

a: str = 'I love you'   
b: int = 520   
print(f'Before swap: a = {
      
      a}, b = {
      
      b}')   
a, b = b, a   
print(f'After swap: a = {
      
      a}, b = {
      
      b}')   # 多个变量同样适用   
c: str = 'Every single night'   
a, b, c = c, a, b   
print(f'After swap: a = {
      
      a}, b = {
      
      b}, c = {
      
      c}')   

Output:   
Before swap: a = I love you, b = 520   
After swap: a = 520, b = I love you   
After swap: a = Every single night, b = 520, c = I love you   

---

2.序列反转很简单

• • 对于列表或字符串这类序列，想要反转其元素，其实很简单，只需要通过切片索引即可一步实现：

numbers: list[int] = [1, 2, 3, 4, 5]   
greeting: str = 'Hello, Jack!'   
print(numbers[::-1])    # [5, 4, 3, 2, 1]   
print(greeting[::-1])   # !kcaJ ,olleH   

• 表示从后往前逐一遍历元素。

---

3.字符串乘法

• 有些时候，你可能需要输出同一个字符串多次，初学者可能会老老实实的手动输入n次目标字符串。

• 比如，输出5次“love”，你可能会这样：

target = 'lovelovelovelovelove'   

• 但其实，你可以通过字符串乘法轻松搞定，达到目的的同时代码还更简洁，可读性更强：

target: str = 'loveloveloveloveloveyou!'   
target2: str = ('love' * 5) + 'you!'    # 等价于 target   
print(target)   # loveloveloveloveloveyou!   
print(target2)  # loveloveloveloveloveyou!   

---

4.单行代码实现条件赋值

• 假设你需要判断一个整数是奇数还是偶数，并将结果赋给另一个变量，常规的做法是这样：

number: int = 10   result: str = None   if number % 2 == 0:       result = 'Even'   else:       result = 'Oddd'   

• 但其实你可以通过单行代码完成条件赋值：

nubmer: int = 10   
result: str = 'Even' if 
nubmer % 2 == 0 else 'Odd'   
print(result)   # Even   

---

5.字符串连接有妙招

• 假设有如下由字符串构成的列表：

names: list[str] = ['John', 'Doe', 'Jack', 'Bob', 'Smith']   

• 需要你用指定分隔符（比如逗号）连接后输出，初学Python时，只会老老实实的用加号这样连接：

result: str = ''   
for name in names:       
result = result + name + ', '   
print(result)   

• 但实际上，调用字符串的内置函数join()可以轻松实现按照指定分隔符连接字符串，简单高效：

# 可以使用任何指定分隔符   
print(f'Names: {
      
      ", ".join(names)}')   
print(f'Names: {
      
      "---".join(names)}')   

Output:   
Names: John, Doe, Jack, Bob, Smith   
Names: John---Doe---Jack---Bob---Smith   

---

6.使用 get 方法获取字典元素不报错

• 获取字典元素的常规方法是通过中括号加键值的方式，但是如果访问的键值不存在时，则会报KeyError错误，中止代码运行。

• 而如果改用字典的get方法的话，则可以完全避免这个问题，并且对于不存在的键值，还可以设置个性化返回默认值。

info: dict[str, str] = {
    
    'Name': 'John', 'Age': 25}   
# print(info['job'])  
# 报 KeyError 错误   
print(info.get('job'))  # 返回 None   
print(info.get('job', -1))  # 返回指定的默认值 -1   

---

7.使用 setdefault 方法给字典设置默认值

• 上一个技巧中，我们讲到了用get方法获取字典元素不会报错，但不会对字典本身做任何修改。这里，我们要说的setdefault方法也可以根据键值获取字典元素，但是如果键值不存在，它会向字典中添加一个条目。

scores: dict[str, int] = {
    
    'Jack': 100, 'Smith': 50}   
jacks_score: int = scores.setdefault('Jack', 102)   
print(jacks_score)   
james_score: int = scores.setdefault('James', 0)   
print(james_score)   
print(scores)   # 现在 scores 会多出一个条目，即 'James': 0   

Output:   
100   
0   
{
    
    'Jack': 100, 'Smith': 50, 'James': 0}   

提问：你知道为什么最后输出的字典会多出一个新的条目（‘James’: 0）吗？

---

8.简单便捷的元素计数器

• 假设我们想对序列中所有元素出现的频次进行计数，可以通过Python内置的Counter模块轻松实现。比如：

from collections 
import Counter      
letters: list[str] = ['a', 'b', 'c', 'a', 'a', 'c', 'c', 'd']   
counter: Counter = Counter(letters)   
print(counter.total())              # Output: 8   
print(counter.most_common())        # Output: 每个元素出现次数构成的列表   
print(counter.most_common(n=3))     # Output: 出现频次最高的前3个元素   

Output:   
8   
[('a', 3), ('c', 3), ('b', 1), ('d', 1)]   
[('a', 3), ('c', 3), ('b', 1)]   

---

9.便捷高效的 Enumerate

• 很多时候，我们在对序列进行操作的时候，不仅需要获取它的元素，还需要元素的索引位置。你不需要再通过别的循环去实现这个目的，在同一个循环中即可同时获取序列的位置和元素：

names: list[str] = ['John', 'Doe', 'Jack', 'Bob']   
for idx, name in enumerate(names):       
print(f'{
      
      idx}: {
      
      name}')   

Output:   
0: John   
1: Doe   
2: Jack   
3: Bob   

• 元素索引默认从0开始，如果你不喜欢，你可以自定义任意起始位置

• 比如，我们想从1开始，只需要给 enumerate的start参数传入指定的值即可。

for idx, name in enumerate(names, start=1):       
print(f'{
      
      idx}: {
      
      name}')   

Output:   
1: John   
2: Doe   
3: Jack   
4: Bob   

---

10.字典合并很简单

• 实际工作中，常常会遇到字典合并的情况，我常用的是以下两种方式，都很Pythonic：

a: dict[str, int] = {
    
    'a': 1, 'b': 2}   
b: dict[str, int] = {
    
    'c': 3, 'd': 4}   
c: dict[str, int] = {
    
    **a, **b}  # 使用双 * 号解包字典并合并   
d: dict[str, int] = a | b       # 使用竖线（|）符号合并字典   a |= b                          

# 直接就地执行合并操作，等价于 a = a | b   
print(a)   
print(c)   
print(d)   

Output:   
{
    
    'a': 1, 'b': 2, 'c': 3, 'd': 4}   
{
    
    'a': 1, 'b': 2, 'c': 3, 'd': 4}   
{
    
    'a': 1, 'b': 2, 'c': 3, 'd': 4}   

• 其中，第二种类似于数值四合运算中的+=, -=, *=, /=操作。

---

11.千分位标识符——让你输入长串数字时不再眼花缭乱

• 有些时候，在输入一个很大的数字时，你可能想知道位数是否满足，但是肉眼看的话估计让你眼花缭乱。

• 这个时候你可以给数字加上分隔符，Python解释器会忽略分隔符：

big_number: int = 10000000000000000         
# 让你数有多少个0你是什么感觉？   
print(big_number)   
big_number2: int = 10_000_000_000_000_000   
# 解释器会忽略下划线   
print(big_number2)   

Output:   
10000000000000000   
10000000000000000   

• 看这个输出也挺糟心的，其实，输出也可以加上千分位标识符：

print(f'{
      
      big_number:,}')    # 解释器会自动加上千分位标识符   

Output:   
10,000,000,000,000,000   

---

12.__call__ 特殊方法——让类的实例直接可调用

• 假设我们想要一个乘法计算器，实例化后调用实例本身即可执行乘法运算，可以像下面这样，只需要在类定义中实现__call__特殊方法即可：

class Multiplier:       
def __init__(self, value: int) -> None:           
self.value = value          
def __call__(self, other_value: int) -> int:           
return self.value * other_value      
double: Multiplier = Multiplier(2)   
print(double(10))   # Output: 20   
print(double(5))    # Output: 10   

---

13.创建你自己的方法链技术

• 方法链是一种非常高效、简洁且让你的代码更加Pythonic的技术，实际工作中经常用到。比如，对字符串的操作：

love: str = 'I love you'   
result: str = love.replace('love', '❤').replace('you', 'u').upper()   
print(result)   # I ❤ U   

• 其实，我们也可以实现自己的方法链技术，只需要在类定义中，将方法的返回值设为实例本身（self）即可。

from typing 
import Self      
class Person:       
def __init__(self, name: str, age: int) -> None:           
self.name = name           
self.age = age          
def modify_name(self, new_name: str) -> Self:           
self.name = new_name           
return self          
def modify_age(self, new_age: int) -> Self:           
self.age = new_age           
return self      
jack: Person = Person(name='Jack', age=29)   
print(f'{
      
      jack.name}: {
      
      jack.age}')   # Output: Jack: 29   
jack.modify_name('Stefan').modify_age(17)   # modify_name返回实例本身，因此可以接着调用类的其他方法   print(f'{jack.name}: {jack.age}')   # Output: Stefan: 17   

---

14.让你的控制台输出更友好可读

foods: list[str] = ['Apples', 'Oranges', 'Bananas']   # 可指定任意分隔符   
print(*foods, sep=', ', end='.\n')   
print(*foods, sep=' -- ', end='.\n')   

Output:   
Apples, Oranges, Bananas.   
Apples -- Oranges -- Bananas.   

---

15.__repr__ 特殊方法——让类实例具象化

• 一般情况下，当你实例化了一个类后，当你输出该实例化对象后，返回的是该对象在内存中的地址信息。像下面这样：

class Person:       
def __init__(self, name: str, age: int) -> None:           
self.name = name           
self.age = age   
jack: Person = Person(name='Jack', age=29)   
print(jack)  # Output: <__main__.Person object at 0x0000019454570A10>   

• 如果你想要看到实例对象的具体信息，那么你只需要实现__repr__特殊方法即可：

class Person:       
def __init__(self, name: str, age: int) -> None:           
self.name = name           
self.age = age          
def __repr__(self) -> str:           
return f'Person(name="{
      
      self.name}", age={
      
      self.age})'      
jack: Person = Person(name='Jack', age=29)   
print(jack)     # Output：Person(name="Jack", age=29)   

---

16.更优雅的获取序列首尾元素

• 正常情况下，对于初学者来说，如果想要获取序列的首尾元素，一般通过下标索引获取，像这样：

first = target_sequence[0]   
last = target_sequence[-1]

• 但是还有更加Pythonic的方式：

people: list[str] = ['John', 'Doe', 'James', 'Bob', 'Smith', 'Stefan']   
first_person, *_, last_person = people   
print(first_person, last_person)    # Output: John Stefan   
print(_)    # 你猜这会输出什么？   

---

17.简洁高效的控制台输出方式——你的调试好帮手

• 如果控制台输出能像下面这样的话，我相信你的调试会更加直观明了：

name: str = 'Jack'   
age: int = 29   
print(f'{
      
      name=}')   # 等价于 print(f'name={name}')，下同   
print(f'{
      
      age=}')   
print(f'{
      
      5+10=}')   

Output:   
name='Jack'   
age=29   
5+10=15   

---

18.round——四舍五入还可以这么用

number: float = 1314521.56789   
print(round(number, 2))     # 这种用法 我们的熟悉，保留小数点后2位   
print(round(number, -1))   
print(round(number, -3))   

---

19.字符串替换

• 与前面 Tip13类似，其实字符串替换很简单，而且还支持方法链技术。

• 这个例子只是演示字符串的替换，同时警示替换时要格外小心，否则会出现不期望的结果。

sentence: str = 'The tired red fox on the red farm ate a bored red pig.'   
print(sentence.replace('red', 'XXX'))   
print(sentence.replace(' red', ' blue')) 

Output:   
The tiXXX XXX fox on the XXX farm ate a boXXX XXX pig.  
The tired blue fox on the blue farm ate a bored blue pig.   

• 如果 red 的前面不加空格的话，就会将我们不想替换的部分也替换掉。像这样：

print(sentence.replace('red', ' blue'))   

20.自定义获取元素最大最小值的方式

• 假设有一个字符串列表，你想要获取它的最大最小值，可以通过内置的max和min方法实现，默认按照字母顺序排序。

names: 
list[str] = ['John', 'Doe', 'Jack', 'Bob', 'Smith','Timothy', 'Amanda', 'Zebra']   # 默认按字母顺序排序   
print('Max: ', max(names))  # Output: Max:  Zebra   
print('Min: ', min(names))  # Output: Min:  Amanda   

• 假设我们想按照字符串长度获取最大最小值，则可以给max和min方法的key参数传递排序行为即可：

for name in names:       
print(name, len(name), sep=': ')      
print('Max: ', max(names, key=len))   
print('Min: ', min(names, key=len))   

John: 4   
Doe: 3   
Jack: 4   
Bob: 3   
Smith: 5   
Timothy: 7   
Amanda: 6   
Zebra: 5   
Max:  Timothy   
Min:  Doe   

提问：如果你仔细观察的话，Doe 和 Bob 的长度都为3，为什么最小值是 Doe？你知道原因吗？

• 此外，如果我们想根据含有某个字符（比如字母‘a’）数量的多少来获取最大最小值，又该如何实现呢？你可以定义一个排序函数，然后传递给参数key即可：

for name in names:       
print(name, name.count('a'), sep=': ')      
print('Max: ', max(names, key=lambda x: x.count('a')))   
print('Min: ', min(names, key=lambda x: x.count('a')))   

Output:   
John: 0   
Doe: 0   
Jack: 1   
Bob: 0   
Smith: 0   
Timothy: 0   
Amanda: 2   
Zebra: 1   
Max:  Amanda   
Min:  John   

提问：类似的问题，有好几个名字中都不含字母‘a’，为什么最小值却是 John？你知道原因吗？
练习：如果长度相同或字母‘a’的数量相同时，我想根据字母顺序排序，该如何实现呢？有兴趣的朋友可以去实践一下，留言给大家分享。

好啦，今天关于Python每天常用的20个技巧就分享到这，感谢你的阅读！

总结

• 最后希望你编程学习上不急不躁,按照计划有条不紊推进,把任何一件事做到极致,都是不容易的,加油,努力！相信自己！

文末福利

• 最后这里免费分享给大家一份Python全套学习资料，希望能帮到那些不满现状，想提升自己却又没有方向的朋友，也可以和我一起来学习交流呀。

包含编程资料、学习路线图、源代码、软件安装包等！【[点击这里]】领取！

• ① Python所有方向的学习路线图，清楚各个方向要学什么东西
• ② 100多节Python课程视频，涵盖必备基础、爬虫和数据分析
• ③ 100多个Python实战案例，学习不再是只会理论
• ④ 华为出品独家Python漫画教程，手机也能学习

可以扫描下方二维码领取【保证100%免费】