登录
当前位置： 首页 > 编程笔记 >

Python编程语言的35个与众不同之处（语言特征和使用技巧）

祁柏
2023-03-14
本文向大家介绍Python编程语言的35个与众不同之处（语言特征和使用技巧），包括了Python编程语言的35个与众不同之处（语言特征和使用技巧）的使用技巧和注意事项，需要的朋友参考一下

一、Python介绍

　　从我开始学习Python时我就决定维护一个经常使用的“窍门”列表。不论何时当我看到一段让我觉得“酷，这样也行！”的代码时（在一个例子中、在StackOverflow、在开源码软件中，等等），我会尝试它直到理解它，然后把它添加到列表中。这篇文章是清理过列表的一部分。如果你是一个有经验的Python程序员，尽管你可能已经知道一些，但你仍能发现一些你不知道的。如果你是一个正在学习Python的C、C++或Java程序员，或者刚开始学习编程，那么你会像我一样发现它们中的很多非常有用。

每个窍门或语言特性只能通过实例来验证，无需过多解释。虽然我已尽力使例子清晰，但它们中的一些仍会看起来有些复杂，这取决于你的熟悉程度。所以如果看过例子后还不清楚的话，标题能够提供足够的信息让你通过Google获取详细的内容。

二、Python的语言特征

列表按难度排序，常用的语言特征和技巧放在前面。

1. 分拆


>>> a, b, c = 1, 2, 3

>>> a, b, c

(1, 2, 3)

>>> a, b, c = [1, 2, 3]

>>> a, b, c

(1, 2, 3)

>>> a, b, c = (2 * i + 1 for i in range(3))

>>> a, b, c

(1, 3, 5)

>>> a, (b, c), d = [1, (2, 3), 4]

>>> a

1

>>> b

2

>>> c

3

>>> d

4

2.交换变量分拆


>>> a, b = 1, 2

>>> a, b = b, a

>>> a, b

(2, 1)

3.拓展分拆 (Python 3下适用)


>>> a, *b, c = [1, 2, 3, 4, 5]

>>> a

1

>>> b

[2, 3, 4]

>>> c

5

4.负索引
 

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> a[-1]

10

>>> a[-3]

8

5.列表切片 (a[start:end])
 

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> a[2:8]

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

6.使用负索引的列表切片
 

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> a[-4:-2]

[7, 8]

7.带步进值的列表切片 (a[start:end:step])
 

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> a[::2]

[0, 2, 4, 6, 8, 10]

>>> a[::3]

[0, 3, 6, 9]

>>> a[2:8:2]

[2, 4, 6]

8.负步进值得列表切片
 

>>> a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> a[::-1]

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

>>> a[::-2]

[10, 8, 6, 4, 2, 0]

9.列表切片赋值
 

>>> a = [1, 2, 3, 4, 5]

>>> a[2:3] = [0, 0]

>>> a

[1, 2, 0, 0, 4, 5]

>>> a[1:1] = [8, 9]

>>> a

[1, 8, 9, 2, 0, 0, 4, 5]

>>> a[1:-1] = []

>>> a

[1, 5]

10.命名切片 (slice(start, end, step))
 

>>> a = [0, 1, 2, 3, 4, 5]

>>> LASTTHREE = slice(-3, None)

>>> LASTTHREE

slice(-3, None, None)

>>> a[LASTTHREE]

[3, 4, 5]

11.zip打包解包列表和倍数
 

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

>>> b = ['a', 'b', 'c']

>>> z = zip(a, b)

>>> z

[(1, 'a'), (2, 'b'), (3, 'c')]

>>> zip(*z)

[(1, 2, 3), ('a', 'b', 'c')]

12.使用zip合并相邻的列表项
 

>>> a = [1, 2, 3, 4, 5, 6]

>>> zip(*([iter(a)] * 2))

[(1, 2), (3, 4), (5, 6)]

 

>>> group_adjacent = lambda a, k: zip(*([iter(a)] * k))

>>> group_adjacent(a, 3)

[(1, 2, 3), (4, 5, 6)]

>>> group_adjacent(a, 2)

[(1, 2), (3, 4), (5, 6)]

>>> group_adjacent(a, 1)

[(1,), (2,), (3,), (4,), (5,), (6,)]

 

>>> zip(a[::2], a[1::2])

[(1, 2), (3, 4), (5, 6)]

 

>>> zip(a[::3], a[1::3], a[2::3])

[(1, 2, 3), (4, 5, 6)]

 

>>> group_adjacent = lambda a, k: zip(*(a[i::k] for i in range(k)))

>>> group_adjacent(a, 3)

[(1, 2, 3), (4, 5, 6)]

>>> group_adjacent(a, 2)

[(1, 2), (3, 4), (5, 6)]

>>> group_adjacent(a, 1)

[(1,), (2,), (3,), (4,), (5,), (6,)]

13.使用zip和iterators生成滑动窗口 (n -grams) 

>>> from itertools import islice

>>> def n_grams(a, n):

...     z = (islice(a, i, None) for i in range(n))

...     return zip(*z)

...

>>> a = [1, 2, 3, 4, 5, 6]

>>> n_grams(a, 3)

[(1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6)]

>>> n_grams(a, 2)

[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]

>>> n_grams(a, 4)

[(1, 2, 3, 4), (2, 3, 4, 5), (3, 4, 5, 6)]

14.使用zip反转字典
 

>>> m = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

>>> m.items()

[('a', 1), ('c', 3), ('b', 2), ('d', 4)]

>>> zip(m.values(), m.keys())

[(1, 'a'), (3, 'c'), (2, 'b'), (4, 'd')]

>>> mi = dict(zip(m.values(), m.keys()))

>>> mi

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

15.摊平列表:
 

>>> a = [[1, 2], [3, 4], [5, 6]]

>>> list(itertools.chain.from_iterable(a))

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

 

>>> sum(a, [])

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

 

>>> [x for l in a for x in l]

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

 

>>> a = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]

>>> [x for l1 in a for l2 in l1 for x in l2]

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

 

>>> a = [1, 2, [3, 4], [[5, 6], [7, 8]]]

>>> flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) is list else [x]

>>> flatten(a)

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

 

注意: 根据Python的文档，itertools.chain.from_iterable是首选。

16.生成器表达式


>>> g = (x ** 2 for x in xrange(10))

>>> next(g)

0

>>> next(g)

1

>>> next(g)

4

>>> next(g)

9

>>> sum(x ** 3 for x in xrange(10))

2025

>>> sum(x ** 3 for x in xrange(10) if x % 3 == 1)

408

17.迭代字典
 

>>> m = {x: x ** 2 for x in range(5)}

>>> m

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

 

>>> m = {x: 'A' + str(x) for x in range(10)}

>>> m

{0: 'A0', 1: 'A1', 2: 'A2', 3: 'A3', 4: 'A4', 5: 'A5', 6: 'A6', 7: 'A7', 8: 'A8', 9: 'A9'}

18.通过迭代字典反转字典
 

>>> m = {'a': 1, 'b': 2, 'c': 3, 'd': 4}

>>> m

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

>>> {v: k for k, v in m.items()}

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

19.命名序列 (collections.namedtuple)
 

>>> Point = collections.namedtuple('Point', ['x', 'y'])

>>> p = Point(x=1.0, y=2.0)

>>> p

Point(x=1.0, y=2.0)

>>> p.x

1.0

>>> p.y

2.0

20.命名列表的继承:
 

>>> class Point(collections.namedtuple('PointBase', ['x', 'y'])):

...     __slots__ = ()

...     def __add__(self, other):

...             return Point(x=self.x + other.x, y=self.y + other.y)

...

>>> p = Point(x=1.0, y=2.0)

>>> q = Point(x=2.0, y=3.0)

>>> p + q

Point(x=3.0, y=5.0)

21.集合及集合操作
 

>>> A = {1, 2, 3, 3}

>>> A

set([1, 2, 3])

>>> B = {3, 4, 5, 6, 7}

>>> B

set([3, 4, 5, 6, 7])

>>> A | B

set([1, 2, 3, 4, 5, 6, 7])

>>> A & B

set([3])

>>> A - B

set([1, 2])

>>> B - A

set([4, 5, 6, 7])

>>> A ^ B

set([1, 2, 4, 5, 6, 7])

>>> (A ^ B) == ((A - B) | (B - A))

True

22.多重集及其操作 (collections.Counter)
 

>>> A = collections.Counter([1, 2, 2])

>>> B = collections.Counter([2, 2, 3])

>>> A

Counter({2: 2, 1: 1})

>>> B

Counter({2: 2, 3: 1})

>>> A | B

Counter({2: 2, 1: 1, 3: 1})

>>> A & B

Counter({2: 2})

>>> A + B

Counter({2: 4, 1: 1, 3: 1})

>>> A - B

Counter({1: 1})

>>> B - A

Counter({3: 1})

23.迭代中最常见的元素 (collections.Counter)
 

>>> A = collections.Counter([1, 1, 2, 2, 3, 3, 3, 3, 4, 5, 6, 7])

>>> A

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

>>> A.most_common(1)

[(3, 4)]

>>> A.most_common(3)

[(3, 4), (1, 2), (2, 2)]

24.双端队列 (collections.deque)
 

>>> Q = collections.deque()

>>> Q.append(1)

>>> Q.appendleft(2)

>>> Q.extend([3, 4])

>>> Q.extendleft([5, 6])

>>> Q

deque([6, 5, 2, 1, 3, 4])

>>> Q.pop()

4

>>> Q.popleft()

6

>>> Q

deque([5, 2, 1, 3])

>>> Q.rotate(3)

>>> Q

deque([2, 1, 3, 5])

>>> Q.rotate(-3)

>>> Q

deque([5, 2, 1, 3])

25.有最大长度的双端队列 (collections.deque)
 

>>> last_three = collections.deque(maxlen=3)

>>> for i in xrange(10):

...     last_three.append(i)

...     print ', '.join(str(x) for x in last_three)

...

0

0, 1

0, 1, 2

1, 2, 3

2, 3, 4

3, 4, 5

4, 5, 6

5, 6, 7

6, 7, 8

7, 8, 9

26.字典排序 (collections.OrderedDict)
 

>>> m = dict((str(x), x) for x in range(10))

>>> print ', '.join(m.keys())

1, 0, 3, 2, 5, 4, 7, 6, 9, 8

>>> m = collections.OrderedDict((str(x), x) for x in range(10))

>>> print ', '.join(m.keys())

0, 1, 2, 3, 4, 5, 6, 7, 8, 9

>>> m = collections.OrderedDict((str(x), x) for x in range(10, 0, -1))

>>> print ', '.join(m.keys())

10, 9, 8, 7, 6, 5, 4, 3, 2, 1

27.缺省字典 (collections.defaultdict)
 

>>> m = dict()

>>> m['a']

Traceback (most recent call last):

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

KeyError: 'a'

>>>

>>> m = collections.defaultdict(int)

>>> m['a']

0

>>> m['b']

0

>>> m = collections.defaultdict(str)

>>> m['a']

''

>>> m['b'] += 'a'

>>> m['b']

'a'

>>> m = collections.defaultdict(lambda: '[default value]')

>>> m['a']

'[default value]'

>>> m['b']

'[default value]'

28. 用缺省字典表示简单的树
 

>>> import json

>>> tree = lambda: collections.defaultdict(tree)

>>> root = tree()

>>> root['menu']['id'] = 'file'

>>> root['menu']['value'] = 'File'

>>> root['menu']['menuitems']['new']['value'] = 'New'

>>> root['menu']['menuitems']['new']['onclick'] = 'new();'

>>> root['menu']['menuitems']['open']['value'] = 'Open'

>>> root['menu']['menuitems']['open']['onclick'] = 'open();'

>>> root['menu']['menuitems']['close']['value'] = 'Close'

>>> root['menu']['menuitems']['close']['onclick'] = 'close();'

>>> print json.dumps(root, sort_keys=True, indent=4, separators=(',', ': '))

{

    "menu": {

        "id": "file",

        "menuitems": {

            "close": {

                "onclick": "close();",

                "value": "Close"

            },

            "new": {

                "onclick": "new();",

                "value": "New"

            },

            "open": {

                "onclick": "open();",

                "value": "Open"

            }

        },

        "value": "File"

    }

}

 

(到 https://gist.github.com/hrldcpr/2012250查看详情)

29.映射对象到唯一的序列数 (collections.defaultdict)

 

>>> import itertools, collections

>>> value_to_numeric_map = collections.defaultdict(itertools.count().next)

>>> value_to_numeric_map['a']

0

>>> value_to_numeric_map['b']

1

>>> value_to_numeric_map['c']

2

>>> value_to_numeric_map['a']

0

>>> value_to_numeric_map['b']

1

30.最大最小元素 (heapq.nlargest和heapq.nsmallest)
 

>>> a = [random.randint(0, 100) for __ in xrange(100)]

>>> heapq.nsmallest(5, a)

[3, 3, 5, 6, 8]

>>> heapq.nlargest(5, a)

[100, 100, 99, 98, 98]

31.笛卡尔乘积 (itertools.product)
 

>>> for p in itertools.product([1, 2, 3], [4, 5]):

(1, 4)

(1, 5)

(2, 4)

(2, 5)

(3, 4)

(3, 5)

>>> for p in itertools.product([0, 1], repeat=4):

...     print ''.join(str(x) for x in p)

...

0000

0001

0010

0011

0100

0101

0110

0111

1000

1001

1010

1011

1100

1101

1110

1111

32.组合的组合和置换 (itertools.combinations 和 itertools.combinations_with_replacement)
 

>>> for c in itertools.combinations([1, 2, 3, 4, 5], 3):

...     print ''.join(str(x) for x in c)

...

123

124

125

134

135

145

234

235

245

345

>>> for c in itertools.combinations_with_replacement([1, 2, 3], 2):

...     print ''.join(str(x) for x in c)

...

11

12

13

22

23

33

33.排序 (itertools.permutations) 


>>> for p in itertools.permutations([1, 2, 3, 4]):

...     print ''.join(str(x) for x in p)

...

1234

1243

1324

1342

1423

1432

2134

2143

2314

2341

2413

2431

3124

3142

3214

3241

3412

3421

4123

4132

4213

4231

4312

4321

34.链接的迭代 (itertools.chain)
 

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

>>> for p in itertools.chain(itertools.combinations(a, 2), itertools.combinations(a, 3)):

...     print p

...

(1, 2)

(1, 3)

(1, 4)

(2, 3)

(2, 4)

(3, 4)

(1, 2, 3)

(1, 2, 4)

(1, 3, 4)

(2, 3, 4)

>>> for subset in itertools.chain.from_iterable(itertools.combinations(a, n) for n in range(len(a) + 1))

...     print subset

...

()

(1,)

(2,)

(3,)

(4,)

(1, 2)

(1, 3)

(1, 4)

(2, 3)

(2, 4)

(3, 4)

(1, 2, 3)

(1, 2, 4)

(1, 3, 4)

(2, 3, 4)

(1, 2, 3, 4)

35.按给定值分组行 (itertools.groupby)
 

>>> from operator import itemgetter

>>> import itertools

>>> with open('contactlenses.csv', 'r') as infile:

...     data = [line.strip().split(',') for line in infile]

...

>>> data = data[1:]

>>> def print_data(rows):

...     print '\n'.join('\t'.join('{: <16}'.format(s) for s in row) for row in rows)

...

 

>>> print_data(data)

young               myope                   no                      reduced                 none

young               myope                   no                      normal                  soft

young               myope                   yes                     reduced                 none

young               myope                   yes                     normal                  hard

young               hypermetrope            no                      reduced                 none

young               hypermetrope            no                      normal                  soft

young               hypermetrope            yes                     reduced                 none

young               hypermetrope            yes                     normal                  hard

pre-presbyopic      myope                   no                      reduced                 none

pre-presbyopic      myope                   no                      normal                  soft

pre-presbyopic      myope                   yes                     reduced                 none

pre-presbyopic      myope                   yes                     normal                  hard

pre-presbyopic      hypermetrope            no                      reduced                 none

pre-presbyopic      hypermetrope            no                      normal                  soft

pre-presbyopic      hypermetrope            yes                     reduced                 none

pre-presbyopic      hypermetrope            yes                     normal                  none

presbyopic          myope                   no                      reduced                 none

presbyopic          myope                   no                      normal                  none

presbyopic          myope                   yes                     reduced                 none

presbyopic          myope                   yes                     normal                  hard

presbyopic          hypermetrope            no                      reduced                 none

presbyopic          hypermetrope            no                      normal                  soft

presbyopic          hypermetrope            yes                     reduced                 none

presbyopic          hypermetrope            yes                     normal                  none

 

>>> data.sort(key=itemgetter(-1))

>>> for value, group in itertools.groupby(data, lambda r: r[-1]):

...     print '-----------'

...     print 'Group: ' + value

...     print_data(group)

...

-----------

Group: hard

young               myope                   yes                     normal                  hard

young               hypermetrope            yes                     normal                  hard

pre-presbyopic      myope                   yes                     normal                  hard

presbyopic          myope                   yes                     normal                  hard

-----------

Group: none

young               myope                   no                      reduced                 none

young               myope                   yes                     reduced                 none

young               hypermetrope            no                      reduced                 none

young               hypermetrope            yes                     reduced                 none

pre-presbyopic      myope                   no                      reduced                 none

pre-presbyopic      myope                   yes                     reduced                 none

pre-presbyopic      hypermetrope            no                      reduced                 none

pre-presbyopic      hypermetrope            yes                     reduced                 none

pre-presbyopic      hypermetrope            yes                     normal                  none

presbyopic          myope                   no                      reduced                 none

presbyopic          myope                   no                      normal                  none

presbyopic          myope                   yes                     reduced                 none

presbyopic          hypermetrope            no                      reduced                 none

presbyopic          hypermetrope            yes                     reduced                 none

presbyopic          hypermetrope            yes                     normal                  none

-----------

Group: soft

young               myope                   no                      normal                  soft

young               hypermetrope            no                      normal                  soft

pre-presbyopic      myope                   no                      normal                  soft

pre-presbyopic      hypermetrope            no                      normal                  soft

presbyopic          hypermetrope            no                      normal 

 类似资料：
  • R 语言特征工程实战

    R语言介绍 熟悉R语言的朋友请直接略过。R语言是贝尔实验室开发的S语言(数据统计分析和作图的解释型语言)的一个分支，主要用于统计分析和绘图，R可以理解为是一种数学计算软件，可编程，有很多有用的函数库和数据集。 R的安装和使用 在https://mirrors.tuna.tsinghua.edu.cn/CRAN/下载对应操作系统的安装包安装。安装好后单独创建一个目录作为工作目录(因为R会自动在目录里

  • Go和Python编程语言之间的区别

    本文向大家介绍Go和Python编程语言之间的区别，包括了Go和Python编程语言之间的区别的使用技巧和注意事项，需要的朋友参考一下 走 Go是一种程序语言，由Robert Griesemer，Rob Pike和Ken Thompson于2007年在Google开发，并于2009年开源。Go的开发旨在简化并发编程和环境采用。 Python Python是Guido van Rossum在1991

  • 1. 语言处理与Python

    上百万字的文本，是容易拿到手的。假设我们会写一些简单的程序，那我们可以用它来做些什么？在本章中，我们将解决以下几个问题： 将简单的程序与大量的文本结合起来，我们能实现什么？ 我们如何能自动提取概括文本风格和内容的关键词和短语？ Python 编程语言为上述工作提供了哪些工具和技术？ 自然语言处理中有哪些有趣的挑战？ 本章分为完全不同风格的两部分。在“语言计算”部分，我们将选取一些语言相关的编程任务

  • 编译语言与口译语言

    问题内容： 我正在尝试更好地理解它们之间的区别。我在网上找到了很多解释，但是它们倾向于抽象的差异，而不是实际的含义。 我的大部分编程经验都来自CPython（动态的，解释的）和Java（静态的，编译的）。但是，我知道还有其他种类的解释和编译语言。除了可以从以编译语言编写的程序中分发可执行文件这一事实之外，每种类型是否有优点/缺点？通常，我听到人们争辩说解释语言可以交互使用，但是我相信编译语言也可以

  • 程序语言与非程序语言之间的差异

    本文向大家介绍程序语言与非程序语言之间的差异，包括了程序语言与非程序语言之间的差异的使用技巧和注意事项，需要的朋友参考一下 在这篇文章中，我们将了解过程语言和非过程语言之间的区别- 程序语言 程序代码以指令序列的形式编写。 用户将指定必须执行的操作以及如何i.e执行的步骤以及逐步执行的过程。 它被认为是命令驱动的语言。 它与机器状态一起工作。 与其他范例相比，它的语义很难理解。 该程序的大小将很大

  • Python语言特性

    1 Python的函数参数传递 看两个例子: a = 1 def fun(a): a = 2 fun(a) print a # 1 a = [] def fun(a): a.append(1) fun(a) print a # [1] 所有的变量都可以理解是内存中一个对象的“引用”，或者，也可以看似c中void*的感觉。 通过id来看引用a的内存地址可以比较理解： a = 1

相关阅读

总结JavaScript的正则与其他语言的不同之处R编程语言的Python接口Scala与Python | 哪种编程语言更好不同编程语言中的浮点数学gVim和多种编程语言

相关文章

使用VS2019编写C语言程序使用VS2017编写C语言程序使用VS2015编写C语言程序C语言编译与预处理指令Go语言的特性

相关问答

Gradle静态编程语言静态编程语言List和MutableList：两个不同的引用，指向同一个集合对象将程序从一种编码语言转换成另一种编码语言的技术术语是什么？使用静态编程语言编译守护程序不成功MongoDB与Scala语言

相关工具

"明"编程语言LIME编程语言《Go语言高级编程》神语言Shen语言

相关文档

Swift 编程语言Python 自然语言处理教程Python 和 NLTK 自然语言处理汇编语言教程Swift 编程语言 v2021.8.16
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.