今天我将向大家分享日常工作中常用的20个Python技巧，小巧而优雅，让你的代码更加 Pythonic👍
目录
Tip1：单行代码实现变量值交换
Tip2：序列反转很简单
Tip3：字符串乘法
Tip4：单行代码实现条件赋值
Tip5：字符串连接有妙招
Tip6：使用 get 方法获取字典元素不报错
Tip7：使用 setdefault 方法给字典设置默认值
Tip8：简单便捷的元素计数器
Tip9：便捷高效的 Enumerate
Tip10：字典合并很简单
Tip11：千分位标识符——让你输入长串数字时不再眼花缭乱
Tip12：__call__ 特殊方法——让类的实例直接可调用
Tip13：创建你自己的方法链技术
Tip14：让你的控制台输出更友好可读
Tip15：__repr__ 特殊方法——让类实例具象化
Tip16：更优雅的获取序列首尾元素
Tip17：简洁高效的控制台输出方式——你的调试好帮手
Tip18：round——四舍五入还可以这么用
Tip19：字符串替换
Tip20：自定义获取元素最大最小值的方式
Tip1：单行代码实现变量值交换
学过 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
Tip2：序列反转很简单
对于列表或字符串这类序列，想要反转其元素，其实很简单，只需要通过切片索引即可一步实现：
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
-1表示从后往前逐一遍历元素。
Tip3：字符串乘法
有些时候，你可能需要输出同一个字符串多次，初学者可能会老老实实的手动输入n次目标字符串。比如，输出5次“love”，你可能会这样：
target = 'lovelovelovelovelove'
但其实，你可以通过字符串乘法轻松搞定，达到目的的同时代码还更简洁，可读性更强：
target: str = 'loveloveloveloveloveyou!'
target2: str = ('love' * 5) + 'you!' # 等价于 target
print(target) # loveloveloveloveloveyou!
print(target2) # loveloveloveloveloveyou!
Tip4：单行代码实现条件赋值
假设你需要判断一个整数是奇数还是偶数，并将结果赋给另一个变量，常规的做法是这样：
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
Tip5：字符串连接有妙招
假设有如下由字符串构成的列表：
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
Tip6：使用 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
Tip7：使用 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）吗？
Tip8：简单便捷的元素计数器
假设我们想对序列中所有元素出现的频次进行计数，可以通过Python内置的 Counter 模块轻松实现。比如：
from collections import Counterletters: 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)]
Tip9：便捷高效的 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
Tip10：字典合并很简单
实际工作中，常常会遇到字典合并的情况，我常用的是以下两种方式，都很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}
其中，第二种类似于数值四合运算中的 +=, -=, *=, /= 操作。
Tip11：千分位标识符——让你输入长串数字时不再眼花缭乱
有些时候，在输入一个很大的数字时，你可能想知道位数是否满足，但是肉眼看的话估计让你眼花缭乱。这个时候你可以给数字加上分隔符，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
这样看是不是瞬间就友好很多，不至于想砸键盘了吧！🤭
Tip12：__call__ 特殊方法——让类的实例直接可调用
假设我们想要一个乘法计算器，实例化后调用实例本身即可执行乘法运算，可以像下面这样，只需要在类定义中实现 __call__ 特殊方法即可：
class Multiplier:def __init__(self, value: int) -> None:self.value = valuedef __call__(self, other_value: int) -> int:return self.value * other_valuedouble: Multiplier = Multiplier(2)
print(double(10)) # Output: 20
print(double(5)) # Output: 10
Tip13：创建你自己的方法链技术
方法链是一种非常高效、简洁且让你的代码更加Pythonic的技术，实际工作中经常用到。比如，对字符串的操作：
love: str = 'I love you'
result: str = love.replace('love', '❤').replace('you', 'u').upper()
print(result) # I ❤ U
其实，我们也可以实现自己的方法链技术，只需要在类定义中，将方法的返回值设为实例本身（self）即可。
from typing import Selfclass Person:def __init__(self, name: str, age: int) -> None:self.name = nameself.age = agedef modify_name(self, new_name: str) -> Self:self.name = new_namereturn selfdef modify_age(self, new_age: int) -> Self:self.age = new_agereturn selfjack: 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
Tip14：让你的控制台输出更友好可读
在做测试时，如果你想让你的控制台输出更加格式化、友好可读，可以这样做：
foods: list[str] = ['Apples', 'Oranges', 'Bananas']
# 可指定任意分隔符
print(*foods, sep=', ', end='.\n')
print(*foods, sep=' -- ', end='.\n')
Output:
Apples, Oranges, Bananas.
Apples -- Oranges -- Bananas.
Tip15：__repr__ 特殊方法——让类实例具象化
一般情况下，当你实例化了一个类后，当你输出该实例化对象后，返回的是该对象在内存中的地址信息。像下面这样：
class Person:def __init__(self, name: str, age: int) -> None:self.name = nameself.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 = nameself.age = agedef __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)
Tip16：更优雅的获取序列首尾元素
正常情况下，对于初学者来说，如果想要获取序列的首尾元素，一般通过下标索引获取，像这样：
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(_) # 你猜这会输出什么？
Tip17：简洁高效的控制台输出方式——你的调试好帮手
如果控制台输出能像下面这样的话，我相信你的调试会更加直观明了：
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
Tip18：round——四舍五入还可以这么用
number: float = 1314521.56789
print(round(number, 2)) # 这种用法 我们的熟悉，保留小数点后2位
print(round(number, -1))
print(round(number, -3))
第一种用法是我们所熟知的，即保留n位小数。那么你猜猜后面两行会输出什么呢？🤭🤭
Tip19：字符串替换
与前面 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'))
Tip20：自定义获取元素最大最小值的方式
假设有一个字符串列表，你想要获取它的最大最小值，可以通过内置的 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个技巧就分享到这，感谢你的阅读！
![[C/C++入门][变量和运算]9、数据类型以及占用存储空间大小](https://i-blog.csdnimg.cn/direct/e0161164fe12412c92f8730871007601.png)
