Python Cookbook --第一章：数据结构和算法（1）

问题1:现在有一个包含N个元素的元组或者是序列，怎样将它里面的值解压后同时赋值给N个变量？

>>> p = (4,5)

>>> x,y = p

>>> x

4

>>> y

5

>>> s = 'hello'

>>> a,b,c,d,e = s

>>> a

'h'

>>> b

'e'

>>> c

'l'

>>> d

'l'

>>> e

'o'

问题2：解压可迭代对象赋值给多个变量

如果一个可迭代对象的元素个数超过变量个数时，会抛出一个ValueError.那么怎么才能从这个可迭代对象中解压出N个元素出来？

Python的星号表达式可以用来解决这个问题。

>>> record = ("Dava", "cadaaf", "4234-54535", "43433676")

>>> name, addr, *num = record

>>> num

['4234-54535', '43433676']

>>> name

'Dava'

注意：解压出来的星号永远都是列表类型，不管解压的里面有没有数值。
星号表达式在迭代元素为可变长元组的序列时很有用。

>>> records = [("a", 1, 2),("b", 3, 4)]

>>> tag, *nums = records[1]

>>> tag

'b'

>>> nums

[3, 4]

星号解压语法在字符串操作的时候也很有用。

>>> line = "nobody:*:-1-2-:Udsdsnndj User:/var/empty:/usr/bin/false"

>>> uname, *_, homedir, sh = line.split(":")

>>> uname

'nobody'

>>> homedir

'/var/empty'

>>> sh

'/usr/bin/false'

注释：解压后不想要的内容，可以用一个废弃名称，例如 _ 。

问题3：保留最后N个元素

在迭代操作或者其他操作的时候，怎样只保留最后有限个元素的历史记录？

保留有限历史记录正是collections.deque 大显身手的时候。（collections是Python内建的一个集合模块，提供了许多有用的集合类。）

>>> from collections import deque

>>> q = deque(maxlen=3)

>>> q.append(1)

>>> q

deque([1], maxlen=3)

>>> q.append(2)

>>> q.append(3)

>>> q

deque([1, 2, 3], maxlen=3)

>>> q.append(2)

>>> q

deque([2, 3, 2], maxlen=3)

deque如果不设置大小，则会得到一个无限大小队列，并且可以在队列的两端执行添加和弹出操作。在队列两端插入或者删除元素时间复杂度都是O(1),而在列表的开头插入或者删除元素的时间复杂度为O(N).

>>> q = deque()

>>> q.append(1)

>>> q.append(2)

>>> q.append(3)

>>> q

deque([1, 2, 3])

>>> q.appendleft(4)

>>> q

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

>>> q.pop()

3

>>> q

deque([4, 1, 2])

>>> q.popleft()

4

>>> q

deque([1, 2])

问题4：查找最大或者最小的N个元素

怎样从一个集合中获得最大或者最小的N个元素列表？---堆

如果N接近于集合大小，则使用排序＋切片较合适。Sorted(items)[:N]
Heapq模块有两个函数：nlargest()和nsmallest()可以完美解决这个问题。

>>> import heapq

>>> nums = [1,2,47,322,86,-42,56,654,2,65,-65]

>>> print(heapq.nlargest(3,nums))

[654, 322, 86]

>>> print(heapq.nsmallest(3,nums))

[-65, -42, 1]

nlargest()和nsmallest() 能接受一个关键字参数，用于更复杂的数据结构

>>>portfolio=[{"name":"IBM","shares":100,"price":91},

{"name":"APPL","shares":100, "price":81},

{"name":"UHD","shares":100, "price":83}

]

>>> cheap = heapq.nsmallest(3, portfolio, key=lambda s:s["price"])

>>> cheap

[

{'name': 'APPL', 'shares': 100, 'price': 81},

{'name': 'UHD', 'shares': 100, 'price': 83},

{'name': 'IBM', 'shares': 100, 'price': 91}

]

堆数据结构最重要的特征就是heap[0]永远是最小的元素。并且生于的元素可以很容易通过调用heap.heappop()方法得到，该方法会将第一个元素弹出，然后用下一个最小元素来取代被弹出元素（时间复杂度：O(logN)，N是堆大小）。

>>> nums = [1,8,3,56,-54,53,-6,25]

>>> import heapq

>>> heapq.heapify(nums)

>>> nums

[-54, 1, -6, 25, 8, 53, 3, 56]

>>> heapq.heappop(nums)

-54

>>> heapq.heappop(nums)

-6

>>> heapq.heappop(nums)

1

问题5：字典中的键映射多个值

怎样实现一个键对应多个值的字典（也叫multidict）?

一个字典就是一个键对应一个单值的映射。如果想要一个键映射多个值，那么就需要将多个值放到另外一个容器中，例如列表，元组，集合或者字典。

>>> d = {"a":[1,2,3],"b":(1,2,3)}

>>> d

{'a': [1, 2, 3], 'b': (1, 2, 3)}

也可以使用collections模块中的defaultdict来构造这样的字典。Defaultdict的一个特征是它会自动初始化每个key刚开始对应的值。

>>> d = defaultdict(list)

>>> d["a"].append(1)

>>> d["a"].append(2)

>>> d["b"].append(4)

>>> d

defaultdict(<class 'list'>, {'a': [1, 2], 'b': [4]})

>>> d = defaultdict(set)

>>> d["a"].add(1)

>>> d["a"].add(2)

>>> d["b"].add(3)

>>> d

defaultdict(<class 'set'>, {'a': {1, 2}, 'b': {3}})

关于数据处理中的记录归类问题有关联。

>>> d = defaultdict(list)

>>> for key,value in pairs:

d[key].append(value)

问题6：字典排序

若创建一个字典，并且在迭代或者序列化这个字典的时候能够控制元素的顺序。

为了控制一个字典中元素的顺序，可以使用collections模块中的OrderedDict类，在迭代操作的时候，他会保持元素被插入时的顺序。

>>> from collections import OrderedDict

>>> d = OrderedDict()

>>> d["foo"] = 1

>>> d["bar"] = 2

>>> d["spam"] = 3

>>> d["grok"] = 4

>>> d

OrderedDict([('foo', 1), ('bar', 2), ('spam', 3), ('grok', 4)])

注：OrderedDict内部维护着一个根据键插入顺序排序的双向链表。所以一个OrderedDict的大小是一个普通字典的两倍。

问题7：字典运算

怎样在数据字典中执行一些计算操作（比如求最小值、最大值、排序等等）？

考虑下面的股票名和价格映射字典:

Prices = {

“ACME”:45.32,

“AAPL”:642.54,

“IBM”:433.52,

“HPQ”:34.21,

“FB”:12.76

}

为了对字典值执行计算操作，通常需要使用zip()函数先将键和值反转过来。

>>> min_price = min(zip(Prices.values(),Prices.keys()))

>>> min_price

(12.76, 'FB')

>>> max_price = max(zip(Prices.values(),Prices.keys()))

>>> max_price

(642.54, 'AAPL')

注意：zip()函数创建的是一个只能访问一次的迭代器。

>>> price_name = zip(Prices.values(),Prices.keys())

>>> min(price_name)

(12.76, 'FB')

>>> max(price_name)

Traceback (most recent call last):

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

ValueError: max() arg is an empty sequence

注意：当多个实体拥有相同的值的时候，键会决定返回结果。

>>> prices = {"AAA":23,"ZZZ":23}

>>> min(zip(prices.values(),prices.keys()))

(23, 'AAA')

>>> max(zip(prices.values(),prices.keys()))

(23, 'ZZZ')

问题8：查找两字典的相同点

怎样在两个字典中寻找相同点（比如相同的键、相同的值等等）？

为了寻找两个字典的相同点，可以简单的在两字典的keys()或者items()方法返回结果上执行集合操作。

>>> a = {"x":1,"y":2,"z":3}

>>> b = {"w":10,"x":22,"y":2}

>>> a.keys()&b.keys()

{'y', 'x'}

>>> a.keys()-b.keys()

{'z'}

>>> a.items()&b.items()

{('y', 2)}

这些操作也可以用于修改或者过滤字典元素。

>>> c = {key:a[key] for key in a.keys()-{"z","w"}}

>>> c

{'y': 2, 'x': 1}

问题9：删除序列相同元素并保持顺序

怎样在一个序列上保持元素顺序的同时消除重复的值？

用列表+循环

问题10：命名切片

当程序有一段代码要从一个记录字符串中几个固定位置提取出特定的数据字段（比如文件或者类似格式）。

命名切片使代码更加清晰可读，硬编码下标会阅读困难。

Slice(start, stop, step) slice[ )

>>> record = "..........100.......521.43"

>>> shares = slice(10,13)

>>> record[shares]

'100'

>>> price = slice(20,26)

>>> record[price]

'521.43'

>>> cost = int(record[shares])*float(record[price])

>>> cost

52142.99999999999

还可以通过调用切片的indices(size)方法将它映射到一个确定大小的序列上，避免出现IndexError异常。

indices相当于是切片的stop位置。若indices的size大于切片的stop则取原切片的stop，若小于则取size大小。下面示例详细说明：

>>> s = slice(0,100,2)

>>> s

slice(0, 100, 2)

>>> print(s.indices(9))

(0, 9, 2)

>>> print(s.indices(100))

(0, 100, 2)

>>> print(s.indices(1000))

(0, 100, 2)

Python Cookbook --第一章：数据结构和算法（2）

Python Cookbook --第一章：数据结构和算法（1）相关推荐

第一章数据结构与算法-前言
Hello,I'm 郭永峰,一名IT从业者,也是一名Java Sharer.Teacher.欢迎添加微信号或者QQ号,一起学习交流,微信与QQ同号(1030103135).目前在腾讯课堂也出了一些教程 ...
python思想读后感_数据结构与算法：Python语言描述读后感1000字
<数据结构与算法:Python语言描述>是一本由裘宗燕著作,机械工业出版社出版的平装图书,本书定价:CNY 45.00,页数:343,特精心从网络上整理的一些读者的读后感,希望对大家能有帮 ...
程序员求职成功路(2) - 第3章数据结构与算法
第3章数据结构与算法 1. memmove边界问题 void memmove_(char *pDst,const char* pSrc,size_t size){ assert(pSrc!= ...
python 机器学习第一章
机器学习是一门能够发掘数据价值的算法和应用,是计算机科学中最激动人心的一个领域之一. 接下来的时间,开始学习吧! python机器学习第一章 1.机器学习方法分为三类:监督学习,无监督学习,强化学习. ...
Python绝技第一章入门 python3实现密码破解
前言对我而言,武术的非凡之处在于它的简单.简单的方法也是正确的方法,同时武术也没有什么特别之处.越接近武术的真谛,招式表现上浪费越少简介 python 绝技第一章是python入门语法,两个需要 ...
第六章.数据结构与算法基础
目录第六章.数据结构与算法基础(重点) 第一节.数组与矩阵数组稀疏矩阵第二节.数据结构的定义第三节.线性表链表详解顺序存储与链式存储对比队列与栈第四节.广义表第五节.树与二叉树树 ...
《HeadFirst Python》第一章学习笔记
对于Python初学者来说,舍得强烈推荐从<HeadFirst Python>开始读起,这本书当真做到了深入浅出,HeadFirst系列,本身亦是品质的保证.这本书舍得已在<Pyth ...
NHibernate.3.0.Cookbook第一章第六节Handling versioning and concurrency的翻译
NHibernate.3.0.Cookbook第一章第六节Handling versioning and concurrency的翻译第一章第二节Mapping a class with XML第一 ...
第一章程序设计入门--算法竞赛入门经典
第一章程序设计入门–算法竞赛入门经典知识点一: int m=25; printf("%d\n",m); printf("%03d\n",m); 输出如下: ...

Python Cookbook --第一章：数据结构和算法（1）

Python Cookbook --第一章：数据结构和算法（1）相关推荐

最新文章

热门文章