python程序设计与算法基础江红答案_《Python程序设计与算法基础教程（第二版）》江红 余青松，第十一章课后习题答案...

推荐阅读 《Python程序设计与算法基础教程(第二版)》江红 余青松 全部章节的课后习题，上机实践，课后答案，案例研究

文章目录

一些知识点总结和几个例题

选择题：1~5

填空题：1~8

思考题：1~15

上机实践：2~13

案例研究：程序运行时间度量分析

一些知识点总结和几个例题

一：二分查找法，冒泡、选择、插入、归并、快速排序算法

我把这几个例题中的查找算法和排序算法，把自己对它们的理解总结了一下：

Python 关于下标的运用技巧(二分查找法，冒泡、选择、插入、归并、快速排序算法)

二：数组

import array

array.array(typecode [, initializer])

typecode：array对象中数据元素的类型

创建array对象时必须指定其元素类型typecode，且其元素只能为该类型，否则将导致TypeError

initializer：为初始化数据序列或可迭代对象

例11.15

>>> import array

>>> a = array.array('b', (1, 2, 3, 4, 5))

>>> a[1] = 66

>>> a[1:]

array('b', [66, 3, 4, 5])

>>> a[0] = 'zgh'

Traceback (most recent call last):

File "", line 1, in

a[0] = 'zgh'

TypeError: an integer is required (got type str)

下表来自https://docs.python.org/3.5/library/array.html#module-array

三：栈和队列(collections.deque)

collections模块中的deque对象：双端队列

支持从任意一端增加和删除元素。

deque是线程安全的，内存高效的队列，它被设计为从两端追加和弹出都非常快

import collections

collections.deque([iterable [, maxlen]])

iterable：初始元素

maxlen：指定队列长度(默认无限制)

deque对象dq支持的方法：

dq.append(x)

在右端添加元素x

dq.appendleft(x)

在左端添加元素x

dq.pop()

从右端弹出元素。若队列中无元素，则导致IndexError

dq.popleft()

从左端弹出元素。若队列中无元素，则导致IndexError

dq.extend(iterable)

在右端添加序列iterable中的元素

dq.extendleft(iterable)

在左端添加序列iterable中的元素

dq.remove(value)

移除第一个找到的x。若未找到，则导致IndexError

dq.count(x)

返回元素x在队列中出现的个数

dq.clear()

清空队列，删除所有元素

dq.reverse()

反转

dq.rotate(n)

如果n>0，则所有元素向右移动n个位置(循环)，否则向左

例11.17(读取文件，返回文件最后的n行内容)

import collections

def tail(filename, n = 10):

'Return the last n lines of a file'

with open(filename) as f:

return collections.deque(f, n)

if __name__ == '__main__':

path = r'test.py'

dq = tail(path, n = 2)

print(dq.popleft())

print(dq.popleft())

输出：

print(dq.popleft())

print(dq.popleft())

若将代码中的这一句改为dq = tail(path, n = 5)

再看输出：

if __name__ == '__main__':

path = r'test.py'

例11.18(deque作为栈)

入栈：deque的append()方法

出栈：deque的pop()方法

>>> from collections import deque

>>> dq = deque()

>>> dq.append(1)

>>> dq.append(2)

>>> dq.append(3)

>>> dq.pop()

3

>>> dq.pop()

2

>>> dq.pop()

1

例11.16(用列表list实现栈)

list.append()入栈

list.pop()出栈

class Stack:

def __init__(self, size = 16):

self.stack = []

def push(self, obj):

self.stack.append(obj)

def pop(self):

try:

return self.stack.pop()

except IndexError as e:

print("stack is empty")

def __str__(self):

return str(self.stack)

def main():

stack = Stack()

#1,2先后入栈

stack.push(1)

stack.push(2)

print(stack)

#出栈

stack.pop()

print(stack)

stack.pop()

print(stack)

stack.pop()

print(stack)

if __name__ == '__main__':main()

输出：

[1, 2]

[1]

[]

stack is empty

[]

例11.19(deque作为队列)

进队：deque的append()方法

出队：deque的popleft()方法

>>> from collections import deque

>>> dq = deque()

>>> dq.append(1)

>>> dq.append(2)

>>> dq.append(3)

>>> dq.popleft()

1

>>> dq.popleft()

2

>>> dq.popleft()

3

四：集合

可变集合对象 set

set()

set(iterable)

不可变集合对象 frozenset

frozenset()

frozenset(iterable)

集合中的元素不可重复，且无序，其存储依据对象的hash码

hash码是依据对象的值计算出来的一个唯一的值

一个对象的hash值可以使用内置函数hash()获得

所有的内置不可变对象，都是可hash对象

可hash对象，即实现了__hash__()的对象

bool、int、float、complex、str、tuple、frozenset

所有内置可变对象，都是非hash对象

list、dict、set

因为可变对象的值可以变化，故无法计算唯一的hash值

在集合中可以包含内置不可变对象，不能包含内置可变对象

例11.20(创建集合对象示例)

集合：无序、不可重复

>>> {1, 2, 1}

{1, 2}

在集合中，重复元素，保留前面的

>>> {'a', 1, True, False, 0}

{False, 1, 'a'}

在集合中可以包含内置不可变对象，不能包含内置可变对象(list、dict、set)

>>> {'zgh', [6,6,6]}

Traceback (most recent call last):

File "", line 1, in

{'zgh', [6,6,6]}

TypeError: unhashable type: 'list'

>>> {'zgh', {6, 6, 6}}

Traceback (most recent call last):

File "", line 1, in

{'zgh', {6, 6, 6}}

TypeError: unhashable type: 'set'

>>> {'zgh', {'sex':'male'}}

Traceback (most recent call last):

File "", line 1, in

{'zgh', {'sex':'male'}}

TypeError: unhashable type: 'dict'

例11.21(集合解析表达式)

>>> {i for i in range(5)}

{0, 1, 2, 3, 4}

>>> {2**i for i in range(5)}

{1, 2, 4, 8, 16}

>>> {x**2 for x in [1, 1, 2]}

{1, 4}

判断元素x是否在集合s是否存在：

x in s 如果为True，则表示存在

x not in s 如果为True，则表示不存在

集合的运算：并集、交集、差集、对称差集

运算符

说明

s1 | s2 | ...

返回 s1、s2…的并集

s1 & s2 | ...

返回 s1、s2…的交集

s1 - s2 - ...

返回 s1、s2…的差集

s1 ^ s2

返回 s1、s2 的对称差集

集合的对象方法：

方法

说明

s1.union(s2, ...)

返回集合s1、s2…的并集

s1.update(s2, ...)

返回集合s1、s2…的并集，s1 |= (s2 | ...) (可变集合的方法)

s1.intersection(s2, ...)

返回集合s1、s2…的交集

s1.intersection_update(s2, ...)

返回集合s1、s2…的交集，s1 &= (s2 & ...) (可变集合的方法)

s1.difference(s2, ...)

返回集合s1、s2…的差集

s1.difference_update(s2, ...)

返回集合s1、s2…的差集，s1 -= (s2 - ...) (可变集合的方法)

s1.symmetric_difference(s2)

返回集合s1、s2的对称差集

s1.symmetric_difference_update(s2)

返回集合s1、s2的对称差集，s1 ^= (s2) (可变集合的方法)

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

>>> s2 = {2, 3, 4}

>>> '''并集'''

>>> s1 | s2

{1, 2, 3, 4}

>>> s1.union(s2)

{1, 2, 3, 4}

>>> '''交集'''

>>> s1 & s2

{2, 3}

>>> s1.intersection(s2)

{2, 3}

>>> '''差集'''

>>> s1 - s2

{1}

>>> s2 - s1

{4}

>>> s1.difference(s2)

{1}

>>> '''对称差集'''

>>> s1 ^ s2

{1, 4}

>>> s1.symmetric_difference(s2)

{1, 4}

集合的比较运算：相等、子集、超集

运算符

说明

s1 == s2

s1和s2的元素相同

s1 != s2

s1和s2的元素不完全相同

s1 < s2

s1是s2的纯子集

s1 <= s2

s1是s2的子集

s1 >= s2

s1是s2的超集

s1 > s2

s1是s2的纯超集

方法

说明

s1.isdisjoint(s2)

如果集合s1和s2没有共同元素，返回True

s1.issubset(s2)

如果集合s1是s2的子集，返回True

s1.issuperset(s2)

如果集合s1是s2的超集，返回True

集合的长度、最大值、最小值、元素和

len()

max()

min()

sum() 如果元素有非数值类型(数值类型：int、float、bool、complex)，则求和将导致TypeError

可变集合 set 的常用方法：

set的方法

说明

s.add(x)

把对象x添加到集合s

s.remove(x)

从集合s中移除对象x，若不存在，则导致KeyError

s.discard(x)

从集合s中移除对象x(如果存在)

s.pop()

从集合s中随机弹出一个元素，如果s为空，则导致KeyError

s.clear()

清空集合s

五：字典

字典(dict)是一组键/值对的数据类型

字典的键必须是可hash对象

每个键对应于一个值

在字典中，键不能重复，根据键可以查询到值

字典的定义：

dict()

创建一个空字典

>>> {}

{}

>>> dict()

{}

dict(**kwargs)

使用关键字参数创建一个新的字典，此方法最紧凑

>>> dict(baidu = 'baidu.com', google = 'google.com')

{'baidu': 'baidu.com', 'google': 'google.com'}

dict(mapping)

从一个字典对象创建一个新的字典

>>> {'a':'apple', 'b':'boy'}

{'a': 'apple', 'b': 'boy'}

>>> dict({'a':'apple', 'b':'boy'})

{'a': 'apple', 'b': 'boy'}

dict(iterable)

使用序列创建一个新的字典

>>> dict([('id','666'),('name','zgh')])

{'id': '666', 'name': 'zgh'}

>>> dict((('id','666'),('name','zgh')))

{'id': '666', 'name': 'zgh'}

字典的访问操作：

d[key]

返回键为key的value，如果key不存在，则导致KeyError

>>> d = {1:'zgh', 2:'666'}

>>> d

{1: 'zgh', 2: '666'}

>>> d[1]

'zgh'

>>> d[2]

'666'

>>> d[3]

Traceback (most recent call last):

File "", line 1, in

d[3]

KeyError: 3

d[key] = value

设置d[key]的值为value，如果key不存在，则添加键/值对

>>> d[3] = 'yes'

>>> d

{1: 'zgh', 2: '666', 3: 'yes'}

del d[key]

删除字典元素，如果key不存在，则导致KeyError

>>> del d[2]

>>> d

{1: 'zgh', 3: 'yes'}

字典的视图对象：

d.keys()

返回字典d