资深程序员才知道的30个Python技巧

1. Python中的省略号

Python省略号是三点序列，通常在自然语言中使用。但是您可能不知道的是，这也是Python中的有效对象：

 

>>> ...

Ellipsis

 

它主要用于NumPy中的矩阵切片操作。但是，您可以在尚未实现的函数中使用它代替占位符，而不必使用通常的方法：

 

def my_awesome_func():

...

 

这就是有效的Python代码

2.数据类别

从3.7版开始，Python附带了数据类。与常规类或其他替代方法相比，它们具有一些优点：

• 返回多个值或字典;
• 数据类需要最少的代码量；
• 比较数据类别的能力；
• 使用__repr__打印数据类以进行调试的能力；
• 减少由于类型提示数据类的要求而导致的错误机会。

运行中的示例数据类：

 

from dataclasses import dataclass


@dataclass

class Card:

rank: str

suit: str


card = Card("Q", "hearts")


print(card == card)

# True


print(card.rank)

# 'Q'

print(card)

Card(rank='Q', suit='hearts')

 

3. Python之禅

最早的Python pep之一是PEP-20。这是19个Python编程论文的清单，称为“ The Zen of Python”。这些规则可以追溯到2004年，并以PEP-8为基础。

这个复活节彩蛋在Python中已经存在很长时间了，并列出了一组规则：

因此，只要您拥有Python REPL，就可以在屏幕上查看这些规则。

4.匿名功能

有时，函数的命名不值得特别注意。例如，如果您确定只使用一次。对于这种情况，Python建议使用匿名函数，也称为lambda函数。

可以将lambda函数分配给变量，从而创建一种定义函数的简洁方法：

 

>>> add_one = lambda x: x + 1

>>> add_one(3)

4

 

当您需要使用函数作为参数时，它会变得更加有趣。在这种情况下，通常只使用一次。如您所知，map将函数应用于可迭代对象的所有元素。我们可以在调用map时使用lambda：

 

>>> numbers = [1, 2, 3, 4]

>>> times_two = map(lambda x: x * 2, numbers)

>>> list(times_two)

[2, 4, 6, 8]

>>>

 

这段代码很普通。例如，当您要将操作应用于迭代对象的每个元素时。在这种情况下，将map（）与lambda函数结合使用既简洁又有效。

5.清单理解

整体理解可以替代用于填充列表的非审美循环。语法如下：

[ expression for item in list if conditional ]

用数字序列填充列表的最简单示例：

mylist = [i for i in range(10)]

print(mylist)

# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

 

由于您可以在此处使用表达式，因此可以使用数学：

 

squares = [x**2 for x in range(10)]

print(squares)

# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

 

外部函数调用：

 

def some_function(a):

return (a + 5) / 2


my_formula = [some_function(i) for i in range(10)]

print(my_formula)

# [2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0]

 

最后，您可以使用“ if”来过滤列表。在这种情况下，将仅保存那些可被2整除的值：

 

filtered = [i for i in range(20) if i%2==0]

print(filtered)

# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

 

很多人学习python，不知道从何学起。
很多人学习python，掌握了基本语法过后，不知道在哪里寻找案例上手。
很多已经做案例的人，却不知道如何去学习更加高深的知识。
那么针对这三类人，我给大家提供一个好的学习平台，免费领取视频教程，电子书籍，以及课程的源代码！
QQ群：810735403

6.替换变量

 

这个巧妙的技巧将为您节省几行代码：

 

a = 1

b = 2

a, b = b, a

print (a)

# 2

print (b)

# 1

 

7.格式化命名字符串

这并不经常使用，但是如果数据已经在字典中，则以下技巧对于格式化命名字符串很有用：

 

您甚至可以使用locals（）函数，但是在Python的最新版本中，您将必须像下面这样访问f字符串：

 

8.嵌套列表推导

还记得列表推导的基本语法吗？

[ expression for item in list if conditional ]

如果expression可以是任何有效的Python表达式，那么它也可以是另一个列表推导。当您需要创建矩阵时，这很有用：

 

>>> [[j for j in range(3)] for i in range(4)]

[[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]

 

或者，如果您要“展平”以前的矩阵：

 

>>> [value

for sublist in m

for value in sublist]

[0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]

 

循环的第一部分穿过矩阵m，第二部分穿过每个向量的元素。

9.必填参数

要强制使用参数，请在其前面放置一个星号，强制所有参数变为关键字：

 

>>> def f(*, a, b):

... print(a, b)

...

>>> f(1, 2)

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: f() takes 0 positional

arguments but 2 were given

>>> f(a=1, b=2)

1 2

>>>

 

10.在REPL中使用下划线

您可以使用下划线运算符在Python REPL中获得最后一个表达式的结果，例如，在Python REPL中，它看起来像这样：

 

>>> 3 * 3

9

>>> _ + 3

12

 

该技巧也可以在IPython Shell中使用。

11.检查所需的Python版本

为了防止用户以不兼容的版本运行脚本，值得在代码中检查Python的当前版本。做一个简单的测试：

 

if not sys.version_info > (2, 7):

# berate your user for running a 10 year

# python version

elif not sys.version_info >= (3, 5):

# Kindly tell your user (s)he needs to upgrade

# because you're using 3.5 features

 

12.装饰功能

装饰器是对函数的包装，该函数以某种方式更改其行为。装饰器有一些用例，在使用Flask之类的框架时，您可能已经使用过它们。

让我们创建自己的装饰器：

 

def print_argument(func):

def wrapper(the_number):

print("Argument for",

func.__name__,

"is", the_number)

return func(the_number)

return wrapper

@print_argument

def add_one(x):

return x + 1

print(add_one(1))

 

在print_argument内部，我们定义了包装函数。它打印出被调用函数的参数和名称，执行实际函数，并返回其结果，就好像该函数被“正常”调用一样。

通过@print_argument，我们将装饰器应用于函数。装饰器也可以重新用于其他功能。

让我们创建自己的装饰器：

 

Argument for add_one is 1

2

 

13.返回多个值

Python中的函数可以不使用字典，列表或类而返回多个变量。它是这样的：

 

def get_user(id):

# fetch user from database

# ....

return name, birthdate


name, birthdate = get_user(4)

 

这是返回元组的地方。您可能已经写出了具有相同效果的申报表（姓名，生日）。

对于有限数量的返回值，这很好。但是任何超过3个值的东西都必须放在（data）类中。

14.合并字典

从Python 3.5开始，合并字典变得更加容易。

 

dict1 = { 'a': 1, 'b': 2 }

dict2 = { 'b': 3, 'c': 4 }

merged = { **dict1, **dict2 }


print (merged)

# {'a': 1, 'b': 3, 'c': 4}


# Python >= 3.9 only

merged = dict1 | dict2


print (merged)

# {'a': 1, 'b': 3, 'c': 4}

 

如果有重复的键，则它们将在第一个词典中被覆盖。

15.切片列表

切片语法如下：

a[start:stop:step]

 

开始， 停止和步进是可选的。它们具有默认值，如果您不填写参数将被激活：

• 0开始;
• 停止清单的末端;
• 1为步骤。

这里有些例子：

 

# We can easily create a new list from

# the first two elements of a list:

first_two = [1, 2, 3, 4, 5][0:2]

print(first_two)

# [1, 2]


# And if we use a step value of 2,

# we can skip over every second number

# like this:

steps = [1, 2, 3, 4, 5][0:5:2]

print(steps)

# [1, 3, 5]


# This works on strings too. In Python,

# you can treat a string like a list of

# letters:

mystring = "abcdefdn nimt"[::2]

print(mystring)

# 'aced it'

 

16.内存使用

使用sys.getsizeof（），您可以检查对象的内存使用情况：

 

import sys


mylist = range(0, 10000)

print(sys.getsizeof(mylist))

# 48

 

庞大的列表只有48个字节，因为range函数返回的行为类似于列表。就内存而言，范围比使用实际数字列表更有效。

 

import sys


myreallist = [x for x in range(0, 10000)]

print(sys.getsizeof(myreallist))

# 87632

 

17，使用*和**解压功能参数

某些函数需要一长串参数。应该避免这种情况（例如，使用数据类），尽管它并不总是由您决定。另一种选择是使用命名参数创建字典并将其传递给函数。这将使您的代码更具可读性。

您可以使用**前缀解压缩字典：

 

>>> def f(a, b):

... print(a, b)

...

>>> args = { "a": 1, "b": 2 }

>>> f(**args)

1 2

 

同样，您可以使用*解压缩数组并将其内容作为参数传递给函数：

 

>>> def f(a, b, c):

... print(a, b, c)

...

>>> l = [1, 2, 3]

>>> f(*l)

1 2 3

 

18.行-标题

如果您想快速获得一个不错的标题，请执行以下操作：

 

mystring = "10 awesome python tricks"

print(mystring.title())

'10 Awesome Python Tricks'

 

19.将字符串拆分为列表

您可以将字符串拆分为字符串列表。在这种情况下，分割发生在空格字符处：

 

mystring = "The quick brown fox"

mylist = mystring.split(' ')

print(mylist)

# ['The', 'quick', 'brown', 'fox']

 

您不需要传递 任何参数来分割以空格分割—使用mystring.split（）。

Split还具有第二个参数maxsplit，它确定最大拆分数。默认情况下，它是-1（无限制）。这是一个示例，将拆分限制为1：

 

>>> mystring.split(' ', 1)

['The', 'quick brown fox']

 

20.从字符串列表中创建一个字符串

从列表创建字符串并在每个单词之间设置空格：

 

mylist = ['The', 'quick', 'brown', 'fox']

mystring = " ".join(mylist)

print(mystring)

# 'The quick brown fox'

 

归结为这样一个事实，即String.join（）函数不仅可以联接列表，而且可以联接任何可迭代对象。将其放在字符串中会阻止在多个位置实现相同功能。

21.查询JSON

JMESpath是一种JSON查询语言，可让您从JSON文档或字典中检索所需的数据。该库可用于Python和其他语言，从而扩展了其功能。

以下是一些一般介绍的代码示例：

 

>>> import jmespath

>>> persons = {

... "persons": [

... { "name": "erik", "age": 38 },

... { "name": "john", "age": 45 },

... { "name": "rob", "age": 14 }

... ]

... }

>>> jmespath.search('persons[*].age', persons)

[38, 45, 14]

 

22.反向字符串和列表

您可以使用切片符号来反转字符串或列表。如果步长值为负，则交换元素：

 

revstring = "abcdefg"[::-1]

print(revstring)

# 'gfedcba'


revarray = [1, 2, 3, 4, 5][::-1]

print(revarray)

# [5, 4, 3, 2, 1]

 

23.从列表或字符串中获取唯一项

通过使用set（）函数创建一个集合，可以从列表或对象中获得所有唯一元素：

 

mylist = [1, 1, 2, 3, 4, 5, 5, 5, 6, 6]

print (set(mylist))

# {1, 2, 3, 4, 5, 6}


# And since a string can be treated like a

# list of letters, you can also get the

# unique letters from a string this way:

print (set("aaabbbcccdddeeefff"))

# {'a', 'b', 'c', 'd', 'e', 'f'}

 

24.有效的字典值

您可以在字典中放入任何内容-不限于数字或字符串。您可以将列表放入字典中并访问嵌套值：

 

>>> a = { 'sub_dict': { 'b': True }, 'mylist': [100, 200, 300] }

>>> a['sub_dict']['b']

True

>>> a['mylist'][0]

100

 

25.三元条件赋值运算符

这是使代码更简洁并保持可读性的另一种方法：

[on_true] if [expression] else [on_false]

这是一个例子：

x = "Success!" if (y == 2) else "Failed!"

26.计算列表中的条目

使用集合库中的Counter可以获得列表中所有唯一项的字典：

 

from collections import Counter


mylist = [1, 1, 2, 3, 4, 5, 5, 5, 6, 6]

c = Counter(mylist)

print(c)

# Counter({1: 2, 2: 1, 3: 1, 4: 1, 5: 3, 6: 2})


# And it works on strings too:

print(Counter("aaaaabbbbbccccc"))

# Counter({'a': 5, 'b': 5, 'c': 5})

 

27.比较运算符链

使您的代码更具可读性和整洁性：

 

x = 10


# Instead of:

if x > 5 and x < 15:

print("Yes")

# yes


# You can also write:

if 5 < x < 15:

print("Yes")

# Yes

 

28.处理日期

该Python-dateutil模块提供标准的DATETIME一个强大的扩展。它的安装如下：

pip3 install python-dateutil

 

这是从日志中解析日期的示例：

 

from dateutil.parser import parse


logline = 'INFO 2020-01-01T00:00:01 Happy new year, human.'

timestamp = parse(logline, fuzzy=True)

print(timestamp)

# 2020-01-01 00:00:01

 

29.使用地图（）

这是此内置函数的语法：

map(function, something_iterable)

 

以下是使用列表的示例：

 

def upper(s):

return s.upper()


mylist = list(map(upper, ['sentence', 'fragment']))

print(mylist)

# ['SENTENCE', 'FRAGMENT']


# Convert a string representation of

# a number into a list of ints.

list_of_ints = list(map(int, "1234567"))

print(list_of_ints)

# [1, 2, 3, 4, 5, 6, 7]

 

30.词汇和定格理解

字典需要一个键和一个值：

 

>>> {x: x**2 for x in (2, 4, 6)}

{2: 4, 4: 16, 6: 36}

 

我们在表达式中定义键和值。

集合理解语法与列表理解没有太大区别。我们只使用花括号而不是方括号：

{ <expression> for item in list if <conditional> }

例子：

 

>>> {s for s in range(1,5) if s % 2}

{1, 3}

 

在这里还是要推荐下我自己建的Python开发交流学习（qq）群:810735403，群里都是学Python开发的，如果你正在学习Python ，欢迎你加入，大家都是软件开发党，不定期分享干货（只有Python软件开发相关的），包括我自己整理的一份2021最新的Python进阶资料和高级开发教程，欢迎进阶中和想深入Python的小伙伴！