python列表可以不按顺序查找元素吗_Python进阶05_列表排序和查找方法

列表中的两个排序方法

list.sort 排序

list.sort 排序直接对list本身进行排序，不会新建一个新的列表，也就是说不会复制一份原有的列表，返回只仅仅是一个None，仅仅是将list的元素进行一次排序。

Python的惯例

如果一个函数或者方法对对象进行的是就地改动，那它就应该返回 None，好让调用者知道传入的参数发生了变动，而且并未产生新的对象。例如，random.shuffle函数。

内置函数sorted 排序

sorted排序：会新建一个新的列表作为返回值，该函数可以接受的参数： - 受任何形式的可迭代对象 - 不可变序列 - 生成器

排序函数的关键字参数

reverseTrue: 被排序的序列里的元素会以降序输出

False: 默认值

key一个只有一个参数的函数，这个函数会被用在序列里的每一个元素上

在对一些字符串排序时，可以用 key=str.lower 来实现忽略大小写的排序

用 key=len 进行基于字符串长度的排序

# 列表中的两个排序方法

fruits = ['grape', 'raspberry', 'apple', 'banana']

# 新建一个排序列表

print(sorted(fruits))

#原列表并未被改变

print(fruits)

#reverse 降序

print(sorted(fruits,reverse=True))

#key的使用

print(sorted(fruits,key=len))

print(sorted(fruits,reverse=True,key=len))

#list.sort的使用，会改变fruits本身

print(fruits.sort())

print(fruits)

['apple', 'banana', 'grape', 'raspberry']

['grape', 'raspberry', 'apple', 'banana']

['raspberry', 'grape', 'banana', 'apple']

['grape', 'apple', 'banana', 'raspberry']

['raspberry', 'banana', 'grape', 'apple']

None

['apple', 'banana', 'grape', 'raspberry']

列表排序的管理bisect

关于bisect模块

bisect是一个模块，使用的时候需要import,标准库的 bisect模块提供了二分查找算法主要。包括两个函数： - bisect:利用二分查找算法来在有序序列中查找 - insort:利用二分查找算法来在有序序列中插入元素

用bisect来搜索

bisect(haystack, needle) 在 haystack(干草垛)里搜索 needle(针)的位置，该位置满足的条件是，把 needle 插入这个位置之后，haystack 还能保持升序。haystack 必须是一个有序的序列。

bisect(haystack, needle) 查找位置 index

再用 haystack.insert(index, needle) 来插入新值。

bisect 两个调优方向首先可以用它的两个可选参数——lo 和 hi——来缩小搜寻的范围。

其次，bisect 函数其实是 bisect_right 函数的别名，后者还有个姊妹函数叫 bisect_left。bisect_left 返回的插入位置是原序列中跟被插入元素相等的元素的位置，新元素会被放置于它相等的元素的前面。

bisect_right 返回的则是跟它相等的元素之后的位置。

# 演示bisect函数搜索和插入的过程

import bisect

import sys

HAYSTACK =[1, 4, 5, 6, 8, 12, 15, 20, 21, 23, 23, 26, 29, 30]

NEEDLES = [0, 1, 2, 5, 8, 10,22, 23, 29, 30, 31]

# 打印的格式

ROW_FMT = '{0:2d} @ {1:2d} {2}{0:<2d}'

def demo(bisect_fn):

for needle in reversed(NEEDLES):

# 利用bisect_fn找到要插入的位置

position = bisect_fn(HAYSTACK,needle)

offset = position * ' |'

print(ROW_FMT.format(needle,position,offset))

if __name__ == '__main__':

if sys.argv[-1] == 'left':

bisect_fn = bisect.bisect_left

else:

bisect_fn = bisect.bisect

print('DEMO：',bisect_fn.__name__)

print('haystack ->',' '.join('%2d' % n for n in HAYSTACK))

demo(bisect_fn)

DEMO： bisect

haystack -> 1 4 5 6 8 12 15 20 21 23 23 26 29 30

31 @ 14 | | | | | | | | | | | | | |31

30 @ 14 | | | | | | | | | | | | | |30

29 @ 13 | | | | | | | | | | | | |29

23 @ 11 | | | | | | | | | | |23

22 @ 9 | | | | | | | | |22

10 @ 5 | | | | |10

8 @ 5 | | | | |8

5 @ 3 | | |5

2 @ 1 |2

1 @ 1 |1

0 @ 0 0

建立一个用数字作为索引的查询表格

可以在很长的有序序列中作为 index 的替代，用来更快地查找一个元素的位置。

# 建立一个用数字作为索引的查询表格

def grade(score,breakpoints=[60,70,80,90],grade='FDCBA'):

i = bisect.bisect(breakpoints,score)

return grade[i]

print([grade(score) for score in [33,80,20,70,90,79,99]])

['F', 'B', 'F', 'C', 'A', 'C', 'A']

用bisect.insort插入新元素

insort(seq, item) 把变量 item 插入到序列 seq 中，并能保持 seq 的升序顺序。

- insort 跟 bisect 一样，有 lo 和 hi 两个可选参数用来控制查找的范围。 - 它也有个变体叫insort_left，这个变体在背后用的是 bisect_left。

import bisect

import random

SIZE = 7

random.seed(1729)

my_list = []

for i in range(SIZE):

new_item = random.randrange(SIZE * 2)

bisect.insort(my_list,new_item)

print('%2d->' % new_item,my_list)

10 -> [10]

0 -> [0, 10]

6 -> [0, 6, 10]

8 -> [0, 6, 8, 10]

7 -> [0, 6, 7, 8, 10]

2 -> [0, 2, 6, 7, 8, 10]

10 -> [0, 2, 6, 7, 8, 10, 10]

分享关于人工智能，机器学习，深度学习以及计算机视觉的好文章，同时自己对于这个领域学习心得笔记。想要一起深入学习人工智能的小伙伴一起结伴学习吧！扫码上车！