集合|列表|元组|字典

集合

列表

元组

字典

一、集合

1.定义：

某些指定的对象集在一起就成为一个集合,其中每一个对象叫元素.
    无序---不支持下标索引
	可变
	元素唯一
	无索引

2.格式：

集合名 = {元素1，元素2，...}
    例：my_set = {1, 3, 5}
       定义一个空的集合  my_set = set()
	   注意： my_set = {}  是一个空字典

3.集合的常见操作

1）增加元素

   .add()  #添加一个元素
          eg：s1 = set()
		      s1.add('hello')
			  s1.add('小猪佩奇')
			  print(s1)
   .update() #可以添加多个元素
              t1 = (‘林志玲’, ‘言承旭’)
			  s1.update(t1)
			  print(s1)
			  s1.add(t1)  # t1作为一个元素被添加进集合
			  print(s1)

2）删除元素

   .remove()  #如果元素存在则删除，不存在则报错
               s1.remove("言承旭")
			   print(s1)
   .pop()  #随机删除
   .clear() #清空
   .discard()  ##类似 remove()  移除不存在的元素的时候不会报错

3）交并集

    差集（项在前一个集合中，但不在后一个集合中）
           eg：set1 = {1, 2, 3, 4}
			   set2 = {3, 4, 5, 6}
			   new_set = set1 - set2
			   new_set1 = set2 - set1
			   print(new_set)
			   print(new_set1)
			   输出：{1, 2}
			         {5, 6}
		. difference()			 
		   eg：new_set = set1.difference(set2)
		       new_set1 = set2.difference(set1)
			   print(new_set)
			   print(new_set1)
               输出：{1, 2}
			         {5, 6}
	交集	
			   set1 = {1, 2, 3, 4}
			   set2 = {3, 4, 5, 6}
			   new_set = set1 & set2
			   print(new_set)
        .intersection()
			   # new_set = set1.intersection(set2)
			   new_set = set2.intersection(set1)
			   print(new_set)
               输出：{3,4}
	并集
               set1 = {1, 2, 3, 4}
			   set2 = {3, 4, 5, 6}
			   new_set = set1 | set2
			   print(new_set)
        .union()
			   new_set = set1.union(set2)
			   print(new_set)
               输出：{1, 2, 3, 4, 5, 6}
	差集（项在前一个集合或后一个集合中，但不会同时出现在二者中）
	           set1 = {1, 2, 3, 4}
			   set2 = {3, 4, 5, 6}
               #new_set = (set1 | set2) - (set1 & set2)
			   new_set = set1 ^ set2
			   print(new_set)
        .symmetric_difference()
               # new_set = set1.symmetric_difference(set2)
			   new_set = set2.symmetric_difference(set1)
               print(new_set)
               输出：{1, 2, 5, 6}

二、列表

1.定义：

专门用于储存 一串 信息，能够同时定义多个 同类型 或 不同类型  的变量
     列表的 索引 从 0 开始
     索引 就是数据在 列表 中的位置编号，索引 又可以被称为 下标

2.语法：

列表用 [ ] 定义，数据 之间使用 ，分隔 
     name_list = ["zhangsan", "lisi", "wangwu"]
      内存中开辟了连续的3块空间
	  管每一块空间称为这个列表的 元素
      想要访问到数组中某一块元素，需要通过这个元素的 下标 或者 索引 去访问

3.列表的赋值

     num_list = [1,2,3,4,5,6,7,8,9]
     name_list = ["zhangsan", "lisi", "wangwu"]
	列表的取值 name_list[1]
              输出：'lisi'

4.常用操作

1	增加	列表.insert（索引，数据）	在指定位置插入数据
            列表.append（数据）	        在末尾追加数据
            列表.extend（列表2）	    将列表2的数据追加到列表
2	修改	列表[索引] = 数据	        修改指定索引的数据
3	删除	Del列表[索引]	            删除指定索引的数据
            列表.remove[数据]	        删除第一个出现的指定数据
            列表.pop	                删除末尾数据
            列表.pop（索引）	            删除指定索引数据
            列表.clear	                清空列表
4	统计	Len(列表)	                列表长度
            列表.count(数据)	            数据在列表冲出现的次数
5	排序	列表.sort()	                升序排列
            列表.sort(reverse=True)	    降序排列
            列表.reverse（）          	逆序、反转
6.循环遍历列表
遍历 就是 从头到尾 依次 从 列表中获取数据
在循环体内部 针对 每一个元素，执行相同的操作
使用 for 就能够实现迭代遍历
    #for 循环内部使用的变量 in 列表
    for name in name_list:
       #循环内部针对列表元素进行操作
       print（name）

三、元组

1.定义：

用于存储 一串信息,数据之间使用 ,  分离
  与列表类似,不同之处在于元组的 元素不能修改
  元组 表示多个元素组成的序列

2.语法：元组用 ( ) 定义

        元组的 索引 从 0 开始
		info_tuple = ("zhangsan",18,1.75)

3.元组的赋值

  t1 = ()  # 定义空元组
  print(type(t1))  # 查看元组类型
  
  t2 = (‘hello’,) # 1个元素的元组定义方式
  
  t3 = (“aa”, “bb”) # 多个元素的元组定义方式
        python 中的交换变量：(a,b) =(b,a)
		
  t4 = (3, 5, 7, 8, 1, 4, 7, 8, 9, 0) # 元组的元素数据类型

4.类型转换——列表转元组

  t5 = tuple(list1)  # 元组的数据类型转换
  print(t5)
  
  元组转列表
   list(元组)

5.元组的数据查询

  print(t5[0])  # 通过下标查看元组中元素的值
  print(t5[2:-3])  # 通过切片取元组中元素的值
  print(max(t5))   #最大值
  print(min(t5))   #最小值
  print(sum(t5))   #求和
  print(len(t5))   #查看个数
  print(t5.count(4))  # 相同值元素的个数
  print(t5.index(12))  # 从 t5这个元组中，没有元素就报错找出 4 的下标位置

  整形元素
  t1 = (2, 5, 8, 9, 7)
  t1 = a，*b，c
  print(a, b, c)
  输出：a：2
        b：5,8,9
		c：7

6.元组的运算符

  t2 = (4, 5) + (1, 2)
  t3 = (3, 4) * 2
  print(t2)print(t3)
  print(t2 is t3)
  print(3 not in t3)
  输出：(4, 5, 1, 2)
        (3, 4, 3, 4)
         False
         False

四、字典

1.定义：

字典使用 键值对 存储数据,键值对之间使用 , 分隔
        字典同样可以用来 存储多个数据
        通常用于存储 描述一个 物体 的相关信息
	 无序的对象集合

2.语法：字典用 { } 定义

     键 key 是索引
     值 value 是数据
     键 和 值 之间使用 : 分隔
     键必须是唯一的
     值 可以取任何数据类型,但 键 只能使用 字符串 数字 或者 元组
        eg：tom = {"name": "tom"，
			       "age": 18,
				   "height": 1.75,
				   "weight": 75}

3.字典的赋值

  dict1 = {}  # 定义空字典
  dict2 = dict()  # 空字典 其他容器： list1 = list()  空列表  tuple = tuple()
  dict3 = {"ID": '120220200011112222', 'name': "lucky", "age": 18}  # 有内容的字典的定义

4.类型转换————元组转字典

  dict4 = dict([("name", "lucy"), ("age", 18)])
这样写，其实是将列表强转成字典，这个列表的每个元素是元组，每个元组有2个元素
  只有符合固定格式的写法才能转换成字典

5.字典的增删改查

dict6 = {}   #格式：dict6[key] = value
               # 特点： 按照上面的格式，如果在字典中存在同名的key，则发生值的覆盖(后面的值覆盖原来的值)
			   # 如果没有同名的 key，则实现添加的功能(key:value添加到字典中)
增：dict6['brand'] = 'huawei'
       dict6['brandq'] = "mi"
	   print(dict6)
	   输出：{'brand': 'huawei', 'brandq': 'mi'}
	   # 增加同名的key 会替换掉原来字典的值
	   # key是唯一的  value 值可以是不唯一的
查：dict1 = {"1": "张三", "2": "李四", "3": "王五"}
	    print(dict1["2"]) 
		输出：李四
    遍历：
	遍历分数大于90的人
	   for i in dict2:
	   print(i)
	   
	   # 把字典转换成 列表的形式，元素是元组
       print(dict2.items())
       
	   # 考试分输大于 90 分的人：
	   for key, value in dict2.items():
          if value > 90:        
	         print(key, value)

删：del
	    list1 = [3, 5, 7, 9]
		del list1[1]
		print(list1)
		#根据key删除字典中的键值对，返回的是 只要删除成果，则返回键值对的值 value
         pop的默认值 往往实在删除的时候没有找到对应的 key，则返回默认值
        
		# popitem():  随机删除字典中键值对(一般是从末尾删除)
		# clear()  同列表的 clear
其他：
	    update()  合并操作  # 相当于 列表里面的 extend()
	    
		dict1 = {0: 'tom', 1: "jack", 2: "lucy"}
		dict2 = {0: "lily", "4": "ruby"}
		dict1.update(dict2)
		print(dict1)
        
		fromkeys(seq，[]) #将seq 转成字典的形式，[ ]如果没有指定默认的value，则用 none