每天都在用的20个Python技巧,让你从此告别平庸!

发布时间:2024-12-17 14:33

从书中找寻生活的点滴感悟,让每一天都别有洞天。 #生活乐趣# #生活体验# #读书生活感悟# #平凡生活乐趣#

今天我将向大家分享日常工作中常用的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!'    

print(target)   

print(target2)  

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.get('job'))  

print(info.get('job', -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)   

Output:

100

0

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

提问:你知道为什么最后输出的字典会多出一个新的条目('James': 0)吗?

Tip8:简单便捷的元素计数器

假设我们想对序列中所有元素出现的频次进行计数,可以通过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)]

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                          

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 = 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

Tip13:创建你自己的方法链技术

方法链是一种非常高效、简洁且让你的代码更加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

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 = 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)

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'{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))  

print('Min: ', min(names))  

假设我们想按照字符串长度获取最大最小值,则可以给 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个技巧就分享到这,感谢你的阅读!

网址:每天都在用的20个Python技巧,让你从此告别平庸! https://www.yuejiaxmz.com/news/view/499324

相关内容

个性设计让你家告别平庸
超实用房间收纳整理小技巧,让你从此告别“乱室佳人”
超实用房间收纳整理小技巧,让你从此告别“乱室佳人”
3 个节省时间的 Python 技巧
7个Python内存优化技巧,你用过几个?
最好的一生,是接纳平凡,告别平庸
4个必学的Python自动化技巧,助你提升效率
3 个节省时间的 Python 技巧!
教你几招巧加这些小物,鞋柜从此告别异味
Python 简介:用自动化告别手动任务

随便看看