python 知识点梳理(二)

列表、元组与字典知识总结

• 去掉列表或元组中的重复元素
  1、在python中如何定义集合，集合与列表有什么区别
  a = [1,2,3,4,5]#列表
  print(type(a))
  b = (1,2,3,4,5)#元组
  print(type(b))
  c = {1,2,3,4,5}#集合
  print(type©)

  区别：集合没有重复的元素，列表可以有重复的元素；集合中元素与顺序无关，而列表中的元素与顺序有关

  2、如何去重
  先将列表或元组转换成集合，然后再转换回来
  a = [1,2,3,4,4,4,5]
  a_result=list(set(a))
  print(a_result)
  print(type(a_result))
  print(tuple(set(a)))

• 集合的并集与交集
  1、如何向集合中添加和删除元素，需要注意什么，
  x = {3,2,1}
  x.add(123)
  print(x)
  x.add(‘adf’)

  x.remove(123)
  print(x)
  if x._ _contains(444):##检测元素是否存
         x.remove(444)
  else:
         print(‘444在集合中不存在’)

  2、如何求集合的并、交，集合之间是否还支持其他操作
  x1= {1,2,3}
  x2={3,4,5}
  print(‘x1和x2合并：’，x1 | x2)
  print(‘x1和x2合并：’, x1.union(x2))

  print(‘x1和x2相交’，x1 & x2)
  print(‘x1和x2相交’, x1.intersection(x2))

  print(x1.difference(x2))##将x1中有的，x2中也有的删除，返回的是x1的子集
  print(x1^x2)#刨除x1和x2共有的元素，返回的是集合并的子集

• 如何让两个列表首尾相接
  1、列表和元组的连接方式有哪些,列表有两种（+和extend），元组只有一种
  a = [1,5,7,9,6]
  b = [2,3,3,6,8]
  print(a+b)
  print(a.extend(b))
  2、差异
  区别一：+不会改变参与连接的列表的值，但extend方法可以改变a列表的值
  区别二：+两侧要么都是元组要么都是列表，但是列表的extend方法可以将一个元组添加在列表后，元组无extend方法

• 你知道乱序列表元素有哪些方式吗
  1、编写一个函数（不实用python模块）随机排列列表中的元素
  a=[1,2,3,4,5,6,7,8,9,0]
  import random
  ##方法一
  def random_list1(a):
  for i in range(0,100)
         index1 = random.randint(0,len(a)-1)
         index2 = random.randint(0,len(a)-1)
         a[index1],a[index2] = a[index2],a[index2]
  b = random_list1(a)
  print(b)

  ##方法二
  def random_list2(a):
  a_copy = a.copy()
  result=[]
  count = len(a)
  for i in range(0,count):
         index=random.randint(0,lan(a_copy)-1)
         result.extend(a_copy(index))
         del a_copy(index)
  return result
  a=[1,2,3,4,5,6,7,8,9,0]
  b=random_list2(a)
  print(b)

  2、对列表元素随机排列，改变列表原来元素值
  a=[1,2,3,4,5,6,7,8,9,0]
  random.shuffle(a)
  print(a)

• 单星和双星运算符的作用，并举例说明
  1、描述单星（*）和双星（**）运算符的作用，并举例说明
  ##单星，以元组形式导入
  ##如果可变参数不是最后一个参数，那么为可变参数后面的形参指定参数值，必须用命名参数
  def fun1(param1,*param2,x):
  print(‘param1:’,param1)
  print(‘param2:’,param2)
  print(‘x:’,x)
  fun1(1,2,3,4,5,x=6)

  ##双星，以字典的形式导入
  ##以字典的形式导入key和value
  def func2(param1,**param2):
         print(‘param1:’,param1)
         print(‘param2:’,param2, type(param2))
  func2(1,a=1,b=2,c=3,d=4,e=5)
  2、描述合并列表和字典的方法有哪些
  #列表
  a = [1,2,3]
  b = [4,5,6]
  #法1
  print(a+b)
  #法2
  print(a.extend(b))
  #法3
  a = [1,2,3]
  b = [4,5,6]
  x=[a,b]##[[1,2,3], [4,5,6]]
  print(x)
  x=[*a,*b]##[1,2,3,4,5,6]
  print(x)

  #字典
  a = {‘A’:1,‘B’:2}
  b = {‘C’:1,‘D’:2}
  c = {**a,**b}

• 快速调换字典中的key和value
  1、如何快速调换字典中的key和value
  d = {‘a’:1,‘b’:2}
  print({v:k for k,v in d.items()})

  2、如何循环快速生成一个列表
  a = [i for i in range(101)]
  总结：列表和字典中都支持for循环

• 将两个列表或元组合并成一个字典
  zip和dict
  1、如何将两个列表或元组合并成一个字典
  a = [“a”,“b”]
  b = [1,2]
  print(dict(zip(a,b)))

  filed = (‘id’,‘name’,‘age’)
  records = [[‘01’,‘bill’,‘25’],[‘02’,‘army’,‘56’]]
  result = []
  for record in records:
         result.append(dict(zip(filed,record)))
  print(result)

  • 详细秒速列表与元组的差异
    1、有哪些差异，举例说明
    （1）语法不通，元组（），列表[]
    （2）元组是只读的，列表是可读写的
    （3）使用元组函数后，元组任然是自身，使用列表函数后，会复制一个列表
    （4）大小不同，元组占用空间小
    列表占用空间大于元组，python将低开销较大的块儿分配给元组，因为元组不可变，对于列表，则分配小的内存块儿，因为列表可变，列表相比于元组的内存更小，元组只用比较大的内润快，占用空间小，如果有大量元素的话，使用元组比较快

  • 如何排序一个列表
    1、对列表排序有那些方法(两种方法)
    a = [1,2,3,4,5,6,7]
    a.sort()##生序
    b = [1,3,4,5,6,6,7]
    c =sorted(b)
    2、列表的sort方法和sorted函数都可以对列表进行排序，他们有什么区别
    (1)sort属于列表，sorted是独立函数
    (2)sort改变列表本身，sorted返回一个排序好的列表副本
    3、如何倒序排列一个列表
    设置reverse参数为Ture
    a.sort(reverse=Ture)
    print(a)
    print(sorted(b,reverse=Ture))

  • 如果列表元素是对象，如何排序
    1、如果列表元素是对象，对这样的列表排序有那些方法：
    class MyClass:
    def --init–(self):
           self.value = 0

    def --gt__(self , other):
            self.value>other.value

    def --lt__(self,other):
            return self.value<other.value

    my1 = MyClass()
    my1.value = 20

    my2 = MyClass()
    my2.value = 10

    my3 = MyClass()
    my3.value = 30

    a = [my1,my2,my3]
    print(a)

    import operator
    a.sort(key = operator.attrgetter(‘value’))
    b = sorted(a,key = operator.attrgetter(‘value’))
    #a.sort()
    #print(a[0].value)
    #print(a[1].value)
    #print(a[2].value)
    print(b[0].value)
    print(b[1].value)
    print(b[2].value)

    2、如何降序排列
    a.sort(key = operator.attrgetter(‘value’), reverse=Ture)
    print(a[0].value)
    print(a[1].value)
    print(a[2].value)
    print(b[0].value)

    总结：为类添加gt和lt方法，可以让该类的实例支持sort方法和sorted函数
    通过改变gt和lt方法的返回值，或者设置sort方法和sorted函数的reverse参数，可以让列表倒序排列

  • del和pop在删除列表元素上有什么区别
    del(a[0])
    del是一个关键字，根据索引删除列表元素，没有返回值
    a.pop(2)
    pop是一个方法，根据索引弹出列表元素，并返回该元素，同时从列表中删除该元素

  • 用lambda表达式对列表进行排序
    1、如何列表元素是字典类型，如何利用lambda表达式对列表进行生序降序排列
    a = [
    {‘name’:‘bill’,‘age’:12},
    {‘name’:‘mike’,‘age’:11},
    {‘name’:‘johb’,‘age’:13},
    ]
    print(a)
    print(sorted(a,key = lambda x:x[‘age’]))
    print(a.sort(key = lambda x:x[‘age’]),reverse = Ture))

  • 字典键值支持哪些数据类型
    1、有哪些数据类型不能作为字典键值的类型
    列表和字典
    2、为什么列表和字典类型的值不能作为字典的键值
    因为字典里的key是不能变的，列表和字典的元素是可以变化的，一旦变化就再也找不到value了

  • 对产生器类型的对象使用切片
    学习itertools模块中的API
    1、我们知道使用分片可以获取列表的部分元素，那么如何使用切片获取产生器类型对象中的部分元素呢？
    from itertools import islice
    gen = iter(range(10))
    print(type(gen))

    for i in islice(gen,2,6):
           print(i)
    总结：使用itertools模块中的islice函数可以使用分片获取产生器类型对象中的部分元素，islice函数的第一个参数是产生器，第二个参数是开始索引，第三个参数是结束索引的下一个元素的索引

  • 将循环参数的列表变成产生器
    1、如何将[for i in range(20)]变成产生器
    a = [i for i in range(10)]
    print(a)
    b = (i for i in range(10))
    print(b)
    print(type(b))
    总结：如果列表是通过一个for循环产生的，只需将方括号变成圆括号，就会将列表变成一个产生器

  • python字典和JSON字符串如何互转
    json模块相关函数的使用
    1、python字典和JSON字符串如何互转
    d = {‘a’:1,‘b’:2.‘c’:‘xyz’}
    print(d)
    print(type(d))

    import json
    json_str = json.dumps(d)#字典形式转json
    print(json_str)
    print(type(json_str))

    d1 = json.loads(json_str)#json形式转字典
    print(d1)
    print(type(d1))