python学习-进阶

知识点

生成式（推导式）用法

生成式 用来生成列表、集合、字典。

prices = {
    'AAPL': 191.88,
    'GOOG': 1186.96,
    'IBM': 149.24,
    'ORCL': 48.44,
    'ACN': 166.89,
    'FB': 208.09,
    'SYMC': 21.29
}
# 用股票价格大于100元的股票构造一个新的字典
prices2 = {key: value for key, value in prices.items() if value > 100}
print(prices2)

嵌套的列表

我对他的理解就是C语言中的二维数组

herpq 模块（堆排列）

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(1, list1))      ## 列表中 最大的1个
print(heapq.nsmallest(3, list1))     ## 列表中 最小的3个
print(heapq.nlargest(2, list2, key=lambda x: x['price']))   ##以key:price来找出最大的2
print(heapq.nlargest(2, list2, key=lambda x: x['shares']))  ##以key:shares来找最小的2

itertools模块

import itertools

itertools.permutations('ABCD') # 产生ABCD的全排列

itertools.combinations('ABCDE', 3)# 产生ABCDE的五选三组合

itertools.product('ABCD', '123')# 产生ABCD和123的笛卡尔积

itertools.cycle(('A', 'B', 'C'))# 产生ABC的无限循环序列

collections模块

用到再看。

数据结构

算法：解决问题的步骤和方法
用时间复杂度和空间复杂度判断算法的好坏【现在一般除了嵌入式领域，一帮都不看空间复杂度，现在的硬件的大小远远够用的】
一般用O(n）来表示。有常数时间复杂度、对数时间复杂度、线性时间复杂度、平方时间复杂度、阶乘时间复杂度。
以上就是一些概念。一些简单的算法
排序算法。

1. 简单的选择排序

def select_sort(items):  #lambda 是匿名函数，定义一个函数，比较大小的
    for i in range(len(items)-1):                ##下标从0开始的。所以减一 ，开始遍历
        print("排%s次"%(i+1))
        min_index =i                             ##起始的下标为0
        for j in  range(i+1,len(items)):         ##这个循环是找到最小元素的下标。
            if items[j]<items[min_index]:  ##
                min_index=j
        items[i],items[min_index]=items[min_index],items[i]    ##把小的元素往前移。
        print("得到%s"%items)
    return items

import random
li=list(range(8))
random.shuffle(li)  ##随机生成
print(li)
select_sort(li)
print(li)

2. 冒泡排序
   冒泡排序，相邻的两个元素比较，将小的对调的前面。用了两个循环。先把最大的元素放到了最后，把最小的元素往前放。完成一次内循环就将最大的元素移到了最后。内循环中减 i 的目的少一次循环（不管已经找到的大元素）。

def bubble_sort(items):
    for i in range(len(items) - 1):
        swapped = False
        for j in range(len(items) - 1 - i):           #直接对换元素，
            if  items[j]> items[j + 1]:
                items[j], items[j + 1] = items[j + 1], items[j]
                swapped = True
                print("排序第%s和%s结果：%s"%(j,j+1,li))
        if not swapped:
            break
    return items

import random
li=list(range(9))
random.shuffle(li)
print("随  机  列  表：%s"% li)
bubble_sort(li)
print(li)

3. 搅拌排序（升级版的冒泡排序）
   两头排，把大的排一遍，在把小的排一遍

def bubble_sort(items):
    for i in range(len(items)-1):
        swapped = False
        for j in range(len(items)-1-i):       #这个循环完成就将最大元素放到最后
            if items[j]>items[j+1]:
                items[j],items[j+1]=items[j+1],items[j]
                print("第%s和第%s位交换后：%s"%(j,(j+1),items))
                swapped=True
        if swapped:
            swapped=False
            #这里，已经完成了最大元素的排序，就可以少一次循环
            #这个循环是找最小的移动到最前面，
            for j in range(len(items)-2-i,i,-1):  #注意哦这里的j的取值是倒序的。
                if items[j-1]>items[j]:  
                    items[j],items[j-1]=items[j-1],items[j]
                    print("第%s和第%s位交换后：%s" % (j, (j + 1), items))
                    swapped=True
        if not swapped:
            break
    return items
import random
li=list(range(9))
random.shuffle(li)
print("随机生成列表%s："%li)
bubble_sort(li)
print("拍列完成%s"%li)

4. 合并

#合并两个有序列表为有序列表
def merge(items1,items2):
    items=[]  #空列表
    nm1,nm2=0,0           #分别用来控制两个有序列表的。
    while nm1<len(items1) and nm2<len(items2):
        if items1[nm1]<items2[nm2]:    #按序比较两个列表的元素
            items.append(items1[nm1])  ##将小的那个元素追加到items中。
            nm1+=1
        else:
            items.append(items2[nm2])
            nm2+=1
    items+=items1[nm1:]     ##拼接剩下的
    items+=items2[nm2:]
    return items

import random
li1=[1,3,5,7,9]
li2=[0,2,4,6,8]
li=merge(li1,li2)
print(li)

结果

5. 顺序查找
   这个循环就按照顺序，一个一个对比来找。

def seq_search(items,key):
    for index,item in enumerate(items):   #enumerate枚举  index 用于下标
        if item==key:
            return index
    return -1
li=[1,5,0,9,3,8,6,4,2,7]
l=seq_search(li,6)
print(l)

6. 折半查找
   从中间开始比较大小，一步一步缩小范围，从而找到元素。

#折半查找
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
li=[1,4,2,5,3,6,0]
l=bin_search(li,5)
print(l)

常用算法