可变对象

• 可变对象就是对象的值可以任意改变

  每个对象的值都保存了三个数据
  id （标识）
  type （类型）
  value（值） 可变对象的值是可以任意改变的

• 可变对象有 list dict set

• 不可变对象有 int str float boor tuple

  举例
      # 用列表举例
  	a = [1,2,3]
  	a[0] = 10 (改对象)
  	# 这个操作是通过变量去修改对象的值
  	# 这种操作不会改变变量所指的对象
  	# 当我们去修改对象时，如果其他变量也指向了该对象，则修改也会在其他变量中体现
  	# 就是通过索引去改列表 改的是对象的值，如果其他变量 也被这个列表赋值了，其他变量也会被修改
  
  	a = [4,5,6] (改变量)
  	# 这个操作是在给变量重新赋值，
  	# 这种操作，会改变变量所指的对象
  	# 为一个变量重新赋值时，不会影响其他变量
  	# 如果在修改a之前其他变量被a赋值，现在修改a就相当于重新创建一个对象在赋值给a
  	# 其他变量度过没有重新赋值的话，值是不会变的
      # 一般只有在为变量赋值时才是修改变量，其余都是修改对象
         # 改变列表的值 
  
         # 第一个是改对象的值 
         # 第二个就相当于重新赋值

== != is 和 is not

• == 和 != 的作用

• 比较的是对象的值是否相等

• is is not 的作用

• 比较的是对象的id是否相等 （就是比较两个是否是同一个对象）

  # 每个列表的id都是不一样的，虽然值一样但是id不一样（两个变量的str和int如果一样的话那么id也是一样的 ）
  	a = [1,2,3]
  	b = [1,2,3]
  	# a is b 结果是false	
  	# 如果再写一个 a = b 就是把b的对象赋值给a
  	# a is b 结果就是 true

字典

• 创建 用 {}
  d = {} # 创建一个空字典
• 创建一个有数据的字典
• 语法 ：

  {key:value,key:value}

• 字典的值可以是任意对象
• 字典的键可以是任意的不可变对象 一般都使用str 作为对象的键
• 字典的键是不可以重复的，如果出现重复的后面的键会自动替换前面的

a = {name:lmk,age:18,gender:man}
- 根据键来获取值

print(d['name'],d['age'],d['gender'])
# 结果就是 	 lmk 18 man 
# 这是通过key 获取字典的值
# 如果使用了字典中不存在的键就会报错

• 使用 dict（）函数创建字典

• 每一个参数都是一个键值对参数名是键，参数名，是值（这种方法创建的key都是字符串形式）

   例：
   a = dict(name='lmk',age=18)
   # name是key  lmk是value 
  

• 将一个包含双值子序列的序列转换为字典

• 双值序列 序列中只有两个值，[1,2] (‘a’,3) ‘ab’

• 子序列，如果序列中的元素也是序列，那么我们就称这个元素为子序列

   例：[(1,2),(3,5)] 
   a = dict( [ ( 'name','lmk' ) , ( 'age',18 ) ])
   # 这个字典的值是 {'name': 'lmk', 'age': 18} name是key lmk是value
  

字典的一些方法

• 大部分都和列表相同

• len() 获取字典中键值对的个数

• in 检查字典中是否包含指定的键
  a = {name:lmk,age:18,gender:man}
  print(‘name’ in a)
  返回结果是true

• not in 检查字典中是否不包含指定的键
  a = {name:lmk,age:18,gender:man}
  print(‘name’ in a)
  返回结果是false

• 获取字典中的值，根据键来获取值

• 通过 [] 方法

• 语法：
  d[key]
  a = {name:lmk,age:18,gender:man}
  print(a[‘name’])
  # 输出结果是lmk
  # 获取值时，如果输入不存在的键就会报错，keyerror

• 通过 get方法

• 语法：
  get(key[,default]) default是默认值

• 该方法用来根据键来获取字典中的值

• 逗号后面是可选参数，可写可不写

• 意思是可以在后面指定一个默认值，如果字典中没有这个键，就会返回默认值，而不会报错
  a = {name:lmk,age:18,gender:man}
  print(a.get(‘lll’,’no’))
  # 返回结果是 no
  print(a.get(‘name’,’no’))
  # 这个返回结果是 lmk

• 修改字典

• 语法 ：
  a[key] = value

  • 如果key存在则覆盖，不存在则添加
    例：
    a = {‘name’:’lmk’,’age’:18,’gender’:’man’}
    a[‘lll’] = ‘kml’
    print(a)
    # a的值为 {‘name’: ‘lmk’, ‘age’: 18, ‘gender’: ‘man’, ‘lll’: ‘kml’} 增加了 ‘lll’: ‘kml’
    
    ———————————————————————————-
    a = {‘name’:’lmk’,’age’:18,’gender’:’man’}
    a[‘name’] = ‘kml’
    print(a)
    # a的值是 {‘name’: ‘kml’, ‘age’: 18, ‘gender’: ‘man’} name的值被改为 kml

• 语法 :
  setdefault(key,[,default])

  • 可以用来向字典中添加key-value

  • 如果key已经存在于字典中，则返回key的值，不会对字典做任何操作

  • 如果key不存在，则向字典中添加这个key，并设置value

      例：
          a = {'name':'lmk','age':18,'gender':'man'}
          b = a.setdefault('name','kml')
          print(b)
          print(a)
          # 输出结果是    lmk
                       {'name': 'lmk', 'age': 18, 'gender': 'man'}
          # 值并没有改变，如果key是有value的则返回value不会改变key的value
      --------------------------------------------------------------------------------------------
                      
          a = {'name':'lmk','age':18,'gender':'man'}
          b = a.setdefault('hello','kml')
          print(b)
          print(a)
          # 输出结果   kml
                    {'name': 'lmk', 'age': 18, 'gender': 'man', 'hello': 'kml'}	
          # 结果是在字典后面添加了一个hello的key以及value，并返回已添加的value
    

• 语法 ：
  update ([other]) 将其他字典中的key-value添加到字典中

  • 如果有重复的key ，则后面的会替换当前的
    例 ：
    a = {‘name’:’lmk’,’age’:18,’gender’:’man’}
    b = {‘name’:’kml’,’hello’:’kkk’}
    a.update(b)
    print(a)
    # 输出结果是 {‘name’: ‘kml’, ‘age’: 18, ‘gender’: ‘man’, ‘hello’: ‘kkk’}
    # 其中name 被替换了，并且在后面添加了hello的key和value

• 语法：
  clear() 用来清空字典

      例：
          a = {'name':'lmk','age':18,'gender':'man'}
          a.clear()
          print(a)	
          # 输出结果是 ｛｝一个空的字典
              
  

• 语法：
  copy() 该方法用于对字典进行浅复制

  • 复制以后的对象，和原对象是独立的，修改一个不会影响另一个
  • 浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制
    例:
    a = {‘name’:’lmk’,’age’:18,’gender’:’man’}
    b = a.copy()
    print(b,id(b))
    print(a,id(a))
    # b 是复制的字典，修改b这个字典后不会影响a 并且a和b不是一个对象 id不同

字典的遍历

1. 通过keys() 函数来遍历字典 该方法会返回一个序列，序列中保存有字典的所有的键

• 语法
  for k in a.keys() :
  例：
  a = {‘name’:’lmk’,’age’:18,’gender’:’man’}
  
  for k in a.keys()
  print(k,a[k])
  # k 是键 a[k]是值
  # 输出结果就是
  name lmk
  age 18
  gender man

2. 通过values()函数返回一个序列，序列中保存有字典的所有值

• 语法
  for k in a.values() :
  
  例：
  a = {‘name’:’lmk’,’age’:18,’gender’:’man’}
  
  for k in a.values()
  print(k)
  # 输出结果是，这个函数并没有返回key的值，所以很少用
  lmk
  18
  man

3. 通过items()函数，该方法会返回字典中所有的项，它会返回一个序列，序列中包含有双值子序列

• 双值分别是字典中的key和value 所以用for循环遍历列表的话要给两个值
  • 语法
    for k in a.items():
    例：
    a = {‘name’:’lmk’,’age’:18,’gender’:’man’}
    for k,v in a.items() ：
    print(k,v)
    # 输出结果是
    name lmk
    age 18
    gender man
    # k是key v是value

集合

• 使用｛｝来创建集合 集合的元素顺序是不固定的

• 语法
  a = {value,value}

• 使用set()函数来创建集合

   # 通过set()来将序列和字典转换为集合，
   a = set([1,2,3,4,5])
   b = set({'lmk':'123'}) 
   # a 的值是 {1, 2, 3, 4, 5}
   # b 的值是 {'lmk'} 只是把key变成集合了
   
  

• 使用 in 和not in是检查集合中的元素
  例
  a = {1,2,3,4}
  print(1 in a)
  # 返回结果是true 表示集合中有这个元素 not in 同理

• 一些方法

• len()函数 用来获取序列中的元素数量
  a = {1,2,3,4}
  print(len(a))
  # 元素数量 是 4

• add() 向集合中添加元素
  a.add(10)
  print(a)
  # 结果是 {1, 2, 3, 4, 10} 添加了一个10

• update() 将一个集合中的元素添加到当前集合中

  • update() 可以传递序列或字典作为参数，字典时会使用键
    例：
    a = {1,2,3,4}
    b = {5,6,7,8}
    a.update(b)
    print(a)
    # 输出结果是 {1, 2, 3, 4, 5, 6, 7, 8}
    ———————————————————–
    # 如果用字典的话
    a = {1,2,3,4}
    b = {‘name’:’lmk’,’age’:18}
    a.update(b)
    print(a)
    输出结果是 {1, 2, 3, 4, ‘name’, ‘age’} 只会输出字典的key

• pop() 随机删除并返回一个集合中的元素

  • 按照集合的规律删除的，所以是随机删除
    a = {1,2,3,4}
    print(a.pop())
    print(a)
    # 输出结果是 1 {2, 3, 4}
    # 这次删除的是1 是随机的

• remove() 删除集合中的指定元素
  a = {1,2,3,4}
  a.remove(2) # 这个2 是元素不是索引
  print(a)
  # 输出结果是 {1, 3, 4}
  # remove没有返回值

集合的运算

• 在做集合的运算时，不会影响原来的集合，而是返回一个运算结果

• 先创建两个集合，

• & 交集运算 （交集运算会取两个集合中相同的元素）
  a = {1,2,3,4}
  b = {3,4,5,6}
  c = a & b
  print(c)
  # 输出结果是 {3, 4} 交集运算会取两个集合中相同的元素

• | 并集运算 （并集运算会合并两个集合 和 update()函数差不多）
  a = {1,2,3,4}
  b = {3,4,5,6}
  c = a | b
  print(c)
  # 输出结果是 {1, 2, 3, 4, 5, 6} 并集运算会合并两个集合 和 update()函数差不多

• “ -“差集运算 （差集运算会取左边独有的值）
  a = {1,2,3,4}
  b = {3,4,5,6}
  c = a - b
  print(c)
  # 输出结果是 {1, 2} 差集运算会取a独有的值 就是取左边独有的值 如果是 b - a 输出结果就是 {5,6} 了

• ^ 异或集运算 (异或集运算会取左右两边独有的值)
  a = {1,2,3,4}
  b = {3,4,5,6}
  c = a ^ b
  print(c)
  # 输出结果是 {1, 2, 5, 6} 异或集运算会取a 和 b 独有的值 就是取两边不相同的值

• <= 检查一个集合是否是另一个集合的子集和
  a = {1,2,3,4}
  b = {3,4,5,6}
  c = a <= b
  print(c)
  # 输出结果是false 意思是如果a集合里面的元素b集合中都有那么a就是b的子集和
  —————————————————————–
  a = {3,4}
  b = {3,4,}
  c = a <= b
  print(c)
  # 结果是true 这个时候a就是b的子集合

• < 检查一个集合是否是另一个集合的超子集

  • 大概意思就是
  • 如果a 集合中的元素，全部都在b集合中出现那么a集合就是b集合的子集,b集合就是a集合的超集,如果b集合中还有a集合中没有的元素,那么b集合就是a集合的真超集
  • 超子集是 a集合的元素b集合中都有，而且b集合中还有a集合中没有的元素，那么a集合就是b集合的超子集
    a = {3,4}
    b = {3,4,5,6}
    c = a < b
    print(c) # 输出结果是true 这是a就是b的超子集b是a的超集

• “ >=”检查一个集合是否是另一个集合的超集
  a = {3,4}
  b = {3,4,5,6}
  c = b > a
  print(c) 输出结果是 true 和<= 相反

• “ >” 检查一个集合是否是另一个集合的真超集
  a = {3,4}
  b = {3,4,5,6}
  c = b > a
  print(c) # 输出结果是 true
  
  a = {3,4}
  b = {3,4}
  c = b > a
  print(c) # 输出结果是false 这样就不是真超集了 现在的b只是a的超集

超集，子集 和 真超集，真子集

• 超集 和 子集 指的是 a集合中的元素b集合中都有这时b集合就是a集合的超集而a集合就是b集合的子集
• 真超集 和 真子集 指的是 a集合中的元素b集合中都有，而且b集合中还有a集合中没有的元素，这时b集合就是a集合的真超集，而a集合就是b集合的真子集