重要知识点
输出
{‘AAPL’: 191.88, ‘GOOG’: 1186.96, ‘IBM’: 149.24, ‘ACN’: 166.89, ‘FB’: 208.09}

重要知识点

生成式（推导式）的用法 ```python prices = { ‘AAPL’: 191.88, ‘GOOG’: 1186.96, ‘IBM’: 149.24, ‘ORCL’: 48.44, ‘ACN’: 166.89, ‘FB’: 208.09, ‘SYMC’: 21.29 }

prices2 = {key: value for key, value in prices.items() if value > 100} print(prices2)

输出

{‘AAPL’: 191.88, ‘GOOG’: 1186.96, ‘IBM’: 149.24, ‘ACN’: 166.89, ‘FB’: 208.09}

> 说明：生成式（推导式）可以用来生成列表、集合和字典
- 嵌套的列表的坑
```python
names = ['关羽', '张飞', '赵云', '马超', '黄忠']
courses = ['语文', '数学', '英语']
# 录入五个学生三门课程的成绩
# 错误 - 参考http://pythontutor.com/visualize.html#mode=edit
# scores = [[None] * len(courses)] * len(names)
scores = [[None] * len(courses) for _ in range(len(names))]
for row, name in enumerate(names):
    for col, course in enumerate(courses):
        scores[row][col] = float(input(f'请输入{name}的{course}成绩: '))
        print(scores)

headq 模块（堆排序）
- 关注 key= labmda 的写法 ```python “”” 从列表中找出最大的或最小的N个元素堆结构(大根堆/小根堆) “”” import heapq

list1 = [34, 25, 12, 99, 87, 63, 58, 78, 88, 92] list2 = [ {‘name’: ‘IBM’, ‘shares’: 100, ‘price’: 91.1}, {‘name’: ‘AAPL’, ‘shares’: 50, ‘price’: 543.22}, {‘name’: ‘FB’, ‘shares’: 200, ‘price’: 21.09}, {‘name’: ‘HPQ’, ‘shares’: 35, ‘price’: 31.75}, {‘name’: ‘YHOO’, ‘shares’: 45, ‘price’: 16.35}, {‘name’: ‘ACME’, ‘shares’: 75, ‘price’: 115.65} ] print(heapq.nlargest(3, list1)) print(heapq.nsmallest(3, list1)) print(heapq.nlargest(2, list2, key=lambda x: x[‘price’])) print(heapq.nlargest(2, list2, key=lambda x: x[‘shares’]))


- `itertools` 模块
   - 官方文档 [https://docs.python.org/3/library/itertools.html](https://docs.python.org/3/library/itertools.html)
```python
import itertools
# 产生ABCD的全排列
for i in itertools.permutations('ABCD'):
    print(i)
# 产生ABCDE的五选三组合
for i in itertools.combinations('ABCDE', 3):
    print(i)
# 产生ABCD和123的笛卡尔积
for i in itertools.product('ABCD', '123'):
    print(i)
# 产生ABC的无限循环序列
for i in itertools.cycle(('A', 'B', 'C')):
    print(i)

collection 模块

常用的工具类：

namedtuple 命令元组，是一个类工厂，接收类型的名称和属性列表来创建一个类
deque 双向队列，是列表的替代实现。Python中的列表底层是基于数组实现的，而deque底层是双向链表，一次当需要在头尾添加和删除元素时，deque会表现出很好的性能，渐进时间复杂度为
Counter ： dict 的子类，键时元素，值时元素的基数，它的 most_common() 方法可以帮助我们获取出现频率做高的元素。 Counter 和 dist 的继承关系是值得商榷的，按照CARP原则， Counter 跟 dict 的关系应该设计为关联关系更合理
OrderedDict ： dict 的子类，它记录了键值对插入的顺序，看起来既有字典的行为，也有链表的行为
defaultdict ：类似于字典类型，但是可以通过默认的工厂函数来获得键对应的默认值，相比字典中的 setdefault() 方法，这种做法更加高效 ```python “”” 找出序列中出现次数最多的元素 “”” from collections import Counter

words = [ ‘look’, ‘into’, ‘my’, ‘eyes’, ‘look’, ‘into’, ‘my’, ‘eyes’, ‘the’, ‘eyes’, ‘the’, ‘eyes’, ‘the’, ‘eyes’, ‘not’, ‘around’, ‘the’, ‘eyes’, “don’t”, ‘look’, ‘around’, ‘the’, ‘eyes’, ‘look’, ‘into’, ‘my’, ‘eyes’, “you’re”, ‘under’ ] counter = Counter(words) print(counter.most_common(3))

<a name="Cil2u"></a>
# 数据结构和算法
- 排序算法（选择、冒泡和归并）和查找算法（顺序和折半）
```python
def select_sort(items, comp=lambda x, y: x < y):
    """简单选择排序"""
    items = items[:]
    for i in range(len(items) - 1):
        min_index = i
        for j in range(i + 1, len(items)):
            if comp(items[j], items[min_index]):
                min_index = j
        items[i], items[min_index] = items[min_index], items[i]
    return items

def bubble_sort(items, comp=lambda x, y: x > y):
    """冒泡排序"""
    items = items[:]
    for i in range(len(items) - 1):
        swapped = False
        for j in range(i, len(items) - 1 - i):
            if comp(items[j], items[j + 1]):
                items[j], items[j + 1] = items[j + 1], items[j]
                swapped = True
        if not swapped:
            break
    return items

def bubble_sort(items, comp=lambda x, y: x < y):
    """搅拌排序(冒泡排序升级版)"""
    items = items[:]
    for i in range(len(items) - 1):
        swapped = False
        for j in range(i, len(items) - i - 1):  # 正向：把当前循环最大的放到最后
            if comp(items[j], items[j+1]):
                items[j], items[j+1] = items[j+1], items[j]
                swapped = True
        if swapped:
            swapped = False
            for j in range(len(items) - 2 - i, i, -1):  # 反向：把当前循环最小的放到最前
                if comp(items[j-1], items[j]):
                    items[j], items[j-1] = items[j-1], items[j]
                    swapped = True
        if not swapped:
            break
    return items

def merge(items1, items2, comp=lambda x, y: x < y):
    """合并(将两个有序的列表合并成一个有序的列表)"""
    items = []
    index1, index2 = 0, 0
    while index1 < len(items1) and index2 < len(items2):
        if comp(items1[index1], items2[index2]):
            items.append(items1[index1])
            index1 += 1
        else:
            items.append(items2[index2])
            index2 += 1
    items += items1[index1:]
    items += items2[index2:]
    return items
def merge_sort(items, comp=lambda x, y: x < y):
    return _merge_sort(list(items), comp)
def _merge_sort(items, comp):
    """归并排序"""
    if len(items) < 2:
        return items
    mid = len(items) // 2
    left = _merge_sort(items[:mid], comp)
    right = _merge_sort(items[mid:], comp)
    return merge(left, right, comp)

def seq_search(items, key):
    """顺序查找"""
    for index, item in enumerate(items):
        if item == key:
            return index
    return -1

def bin_search(items, key):
    """折半查找"""
    start, end = 0, len(items) - 1
    while start <= end:
        mid = (start + end) // 2
        if key > items[mid]:
            start = mid + 1
        elif key < items[mid]:
            end = mid - 1
        else:
            return mid
    return -1

Programming Language

【Python进阶】重要知识点&数据结构与算法

重要知识点

输出

{‘AAPL’: 191.88, ‘GOOG’: 1186.96, ‘IBM’: 149.24, ‘ACN’: 166.89, ‘FB’: 208.09}