Python可以说是这十年来兴起的编程语言，并且被证明是一种非常强大的语言。我用Python从交互式地图到区块链构建了很多应用程序。Python有很多特性，初学者很难一开始就掌握所有的特性。

即使您是一个从其他语言（如C或MATLAB）转换过来的程序员，用更高抽象级别的Python编写代码绝对是另一种体验。我希望早些时候就知道一些Python特性，并重点介绍了其中五个最重要的特性。

1.列表理解-压缩代码

很多人会提到lambda、map和filter是每个初学者都应该学习的Python“技巧”。虽然我认为它们是我们应该注意的功能，但我发现它们大多数时候不是特别有用，因为它们缺乏灵活性。

Lambda是在一行中编写一个一次性使用的函数的方法。如果函数被多次调用，性能会受到影响。另一方面，map将一个函数应用于列表中的所有元素，而filter则获取满足用户定义条件的集合中的元素子集。

       add_func = lambda z: z ** 2

       is_odd = lambda z: z%2 == 1

       multiply = lambda x,y: x*y



       aList = list(range(10))

       print(aList)

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

列表理解是一种简洁而灵活的方法，它可以用灵活的表达式和条件从其他列表创建列表。它是由一个方括号构造的，其中的表达式或函数仅在元素满足某种条件时才应用于列表中的每个元素。它还可以嵌套来处理嵌套列表，并且比使用map和filter灵活得多。

# Syntax of list comprehension

[ expression(x) for x in aList if optional_condition(x) ]

       print(list(map(add_func, aList)))

       print([x ** 2 for x in aList])

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

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

    

       print(list(filter(is_odd, aList)))

       print([x for x in aList if x%2 == 1])

       # [1, 3, 5, 7, 9]

       # [1, 3, 5, 7, 9]

2.列表操作-循环列表

Python允许反向索引，其中列表[-1]==列表[len(列表)-1]。因此，我们可以通过调用aList[-2]等方法获取列表中的最后一个元素。

我们还可以使用syntax aList[start:end:step]对列表进行切片，其中包含开始元素，但不包含结束元素。

我们还可以使用语法列表对列表进行切片，其中包含起始元素，但不包含结束元素。因此，调用aList[2:5]给出了[2,3,4]。我们还可以通过调用aList[::-1]来反转列表，我发现这种技术非常优雅。



列表也可以解压成单独的元素，或者使用星号将元素和子列表混合。

a, b, c, d = aList[0:4]

       print(f'a = {a}, b = {b}, c = {c}, d = {d}')

       # a = 0, b = 1, c = 2, d = 3

      

       a, *b, c, d = aList

       print(f'a = {a}, b = {b}, c = {c}, d = {d}')

       # a = 0, b = [1, 2, 3, 4, 5, 6, 7], c = 8, d = 9

3.压缩和Enumeratefor循环

Zip函数创建一个迭代器，用于聚合来自多个列表的元素。它允许在for循环中并行遍历列表并并行排序。可以使用星号解压缩它。

       numList = [0, 1, 2]

       engList = ['zero', 'one', 'two']

       espList = ['cero', 'uno', 'dos']

       print(list(zip(numList, engList, espList)))

       # [(0, 'zero', 'cero'), (1, 'one', 'uno'), (2, 'two', 'dos')]

       

       for num, eng, esp in zip(numList, engList, espList):

           print(f'{num} is {eng} in English and {esp} in Spanish.')

       # 0 is zero in English and cero in Spanish.

       # 1 is one in English and uno in Spanish.

       # 2 is two in English and dos in Spanish.



 

 

      Eng = list(zip(engList, espList, numList))

       Eng.sort() # sort by engList

       a, b, c = zip(*Eng)

     

       print(a)

       print(b)

       print(c)

       # ('one', 'two', 'zero')

       # ('uno', 'dos', 'cero')

       # (1, 2, 0)

Enumerate一开始可能看起来有点吓人，但在许多场景中非常方便。它是一个经常在for循环中使用的自动计数器，因此在for循环中不再需要通过counter = 0和counter += 1来创建和初始化计数器变量。在构造for循环时，Enumerate和zip是两个最强大的工具。

upperCase = ['A', 'B', 'C', 'D', 'E', 'F']

       lowerCase = ['a', 'b', 'c', 'd', 'e', 'f']

       for i, (upper, lower) in enumerate(zip(upperCase, lowerCase), 1):

           print(f'{i}: {upper} and {lower}.')

       # 1: A and a.

       # 2: B and b.

       # 3: C and c.

       # 4: D and d.

       # 5: E and e.

       # 6: F and f.

4.生成器-内存效率

当我们打算计算大量结果，但希望避免同时分配所有结果所需的内存时，将使用生成器。换句话说，它们动态地生成值，并且不将以前的值存储在内存中，因此我们只能对它们进行一次迭代。

它们通常用于读取大文件或使用关键字yield生成无限序列。我经常发现它在我的大多数数据科学项目中很有用。

def gen(n):    # an infinite sequence generator that generates integers >= n

           while True:

               yield n

               n += 1              

       G = gen(3)     # starts at 3

       print(next(G)) # 3

       print(next(G)) # 4

       print(next(G)) # 5

       print(next(G)) # 6

5.虚拟环境-隔离

如果您只能记住本文中的一件事，那么它应该是虚拟环境的使用。



Python应用程序经常使用来自具有复杂依赖关系的不同开发人员的许多不同包。不同的应用程序是使用特定的库设置开发的，其中的结果不能使用其他库版本复制。不存在满足所有应用要求的单个安装。

conda create -n venv pip python=3.7 # select python version

source activate venv

...

source deactivate

因此，为每个应用程序创建独立的自包含虚拟环境非常重要，可以使用pip或conda来完成。

原文链接：https://towardsdatascience.com/5-python-features-i-wish-i-had-known-earlier-bc16e4a13bf4