Python中基础的查找和排序

查找和排序

• 这里说的查找和排序是针对set，tuple，list和dict结果而言的
• 仅使用内置的方法和运算符

查找

set中的查找

• 判断元素是否在set中，in和not in

  val = {1, 2, 3}
  flag1 = 1 in val
  flag2 = 4 in val
  print(flag1)
  print(flag2)
  
  # 结果
  True
  False
  
  

• 由于set是无序结构，无法通过值查找而返回对应的索引

• 由于set是无序结构，所以set不支持索引查而返回对应的值

tuple中的查找

• 判断元素是否在tuple中，in和not in

  val = (1, 2, 3)
  flag1 = 1 in val
  flag2 = 4 in val
  print(flag1)
  print(flag2)
  
  # 结果
  True
  False
  

• 值查找，返回对应的下标获取要查找的值所对应索引下标；tuple.index(x,start,end)

  val = (1, 'a', 3)
  inx1 = val.index('a')
  print(inx1) 
  
  # 结果
  1
  

  • 若被查找的元素不在tuple中，则抛异常

• 索引查找，返回对应的值。索引取值 []

  val = (1, 2, 3)
  res1 = val[0]
  print(res1)
  
  # 结果
  1
  

  • 若索引越界，抛异常

list中的查找

• 判断元素是否在list中，in和not in

  val = [1, 2, 3]
  flag1 = 1 in val
  flag2 = 4 in val
  print(flag1)
  print(flag2)
  
  # 结果
  True
  False
  

• 值查找，返回对应的索引下标；list.index(x, start, end)

  val = [1, 'a', 3]
  inx1 = val.index(3)
  print(inx1) 
  
  # 结果
  2
  

  • 若被查找值不在list中，则抛异常

• 索引查找，返回对应的值。索引取值 []

  val = [1, 2, 3]
  res1 = val[2]
  print(res1)
  
  # 结果
  2
  

  • 若索引越界，则抛异常

dict中的查找

• 判断元素是否在dict中，

  • 判断键是否在dict中；将字典dict中的键转化为列表，再通过in和not in来判断

    val = {1:'a', 'abc':2}
    key_flag1 = 1 in list(val.keys())
    key_flag2 = 3 in list(val.keys())
    print(key_flag1)
    print(key_flag2)
    
    # 结果
    True
    False
    

  • 判断值是否在dict中；将字典dict中的键转化为列表，再通过in和not in来判断

    val = {1:'a', 'abc':2}
    value_flag1 = 'c' in list(val.values())
    value_flag2 = 2 in list(val.values())
    print(value_flag1)
    print(value_flag2)
    
    # 结果
    False
    True
    

  • 判断键值对是否在dict中；将字典dict中的键值对转化为列表，再通过in和not in来判断

    val = {1:'a', 'abc':2}
    item_flag1 = (1, 'a') in list(val.items())
    item_flag2 = ('abc', 3) in list(val.values())
    print(item_flag1)
    print(item_flag2)
    
    # 结果
    True
    False
    

    • dict.items() 会将键值对转化为以元组形式(key,value)作为元素的可迭代对象

• dict是无序的，不支持通过值查找返回索引下标（dict就没有索引）

• dict是无序的，不支持通过索引取值 （dict中没有索引）

排序

set中的排序

• set是无序的结构，不支持排序操作

tuple中的排序

• tuple中元素不可改变，所以不支持排序

list中的排序

• 使用**list.sort(key=None, reverse=False)**排序

  • 尽可以作用的在list上
  • 原地修改原有的list，返回值为None

  val =  [1, 3, 2]
  val.sort()
  print(val)
  
  # 结果
  [1, 2, 3]
  

  val = [('a', 1), ('c', 3), ('b', 2)]
  val.sort(key=lambda x: x[1])  # 按照列表中元组的第二个位置进行排序
  							  # x表示列表中的第一级元素，即其中的元组。 x[1]
  print(val)
  
  # 结果
  [('a', 1), ('b', 2), ('c', 3)]
  

• 使用内置函数**sorted(可迭代对象,key=None,reverser=Flase)**进行排序

  • 可以作用在可迭代对象上，自然包括list
  • 返回排序后的新列表，原可迭代对象不变

  val  = [1, 3, 2]
  new_val =  sorted(val)
  print(val)
  print(new_val)
  
  # 结果
  [1, 3, 2]
  [1, 2, 3]
  

  val = [('a', 1), ('c', 3), ('b', 2)]
  new_val  = sorted(val, key=lambda x: x[1])
  print(val)
  print(new_val)
  
  # 结果
  val = [('a', 1), ('c', 3), ('b', 2)]
  new_val  = sorted(val, key=lambda x: x[1])
  print(val)
  print(new_val)
  

  • cmp在Python3中被弃用，可以使用functiontools中的cmp_to_key替代

    from functools import cmp_to_key
    val = [('a', 1), ('c', 3), ('b', 2)]
    my_key = cmp_to_key(lambda x,y: ord(x[0]) - ord(y[0])) # 自定义比较函数
    												       # 位置上说，x作为第一个参数
                                                           #         y作为第二个参数
                                                           # 所以x-y表示进行升序排列
    new_val = sorted(val, key=my_key)
    print(val)
    print(new_val)
    
    # 结果
    [('a', 1), ('c', 3), ('b', 2)]
    [('a', 1), ('b', 2), ('c', 3)]
    

dict中的排序

• 使用**sorted(可迭代对象,key=None,reverser=Flase)**进行排序，以列表的形式返回

  • 字典按键排序

    before = {"key7": 5, "key2": 6, "key3": 4, "key4": 3}
    new_list = sorted(before.items(), key=lambda x:x[0]) # before.items()将键值对转为                                                      # 可迭代的对象，[(键，值),...]
    													 # x表示items中的一个元素                                                          # x[0]表示按第一个位置排序
    print(before)
    print(new_list)
    
    # 结果
    {'key7': 5, 'key2': 6, 'key3': 4, 'key4': 3}
    [('key2', 6), ('key3', 4), ('key4', 3), ('key7', 5)]
    

  • 字典按值排序

    before = {"key7": 5, "key2": 6, "key3": 4, "key4": 3}
    new_list = sorted(before.items(), key=lambda x:x[1]) # before.items()将键值对转为                                                      # 可迭代的对象，[(键，值),...]
    													 # x表示items中的一个元素                                                          # x[1]表示按第一个位置排序
    print(before)
    print(new_list)
    
    # 结果
    {'key7': 5, 'key2': 6, 'key3': 4, 'key4': 3}
    [('key4', 3), ('key3', 4), ('key7', 5), ('key2', 6)]
    

  • 字典排序完，仍将其转化为字典

    • 注意到，**sorted()**输出结果是一个列表，如何将形如 [(键1，值1),(键2,值2)…]的数据转为字典呢？

      ​ 使用dict([(键1，值1),(键2,值2)…])即可

    val = [('key2', 6), ('key3', 4), ('key4', 3), ('key7', 5)]
    new_val = dict(val)
    print(new_val)
    
    # 结果
    {'key2': 6, 'key3': 4, 'key4': 3, 'key7': 5}