封装结构、集合、字典及各种解析式

封装和解构

• 封装

  • 将多个值使用逗号分割，组合在一起
  • 本质上，返回一个元组，只是省略掉了小括号
  • python特有语法，被很多语言借鉴

• 交换

  • a = 4
    b = 5
    temp = a 
    a = b
    b = temp
    等价于
    a, b = b, a  # 右边封装，左边解构
    

• 解构

  • 把线性结构的元素解开，并顺序的付给其他变量
  • 左边接纳的变量数要和右边解开的元素个数一致

Python3的解构

• 使用*变量名接收，但不能单独使用

• 被*变量名收集后组成一个列表

• 举例

  • lst = list(range(1, 21, 2))
    head, *mid, tail = lst
    *lst2 = lst
    *body, tail = lst
    head, *tail = lst
    head, *m1, *m2, tail = lst
    head, *mid, tail = "abcdefghijk"
    type(mid)
    --->
    

• 丢弃变量

  • 这是一个惯例，是不成文的约定，不是标准

  • 如果不关心一个变量，就可以定义该变量的名字为_

  • _是一个合法的标识符，也可以作为一个有效的变量使用，但是定义成下划线就是希望不要被使用，除非你明确知道整个数据需要使用

  • lst = [9, 8, 7, 20]
    first, *second = lst
    head, *_, tail = lst
    print(head)
    print(tail)
    --->9
    	20
    

  • 总结：

    • _这个变量本身无任何语义，没有任何可读性，所以不是用来给人使用的
    • Python中很多库，都是用这个变量，使用十分广泛。请不要在不明确变量作用域的情况下使用，导致和库中的_冲突

• 总结：

  • 解构，是Python中提供的很好的功能，可以方便提取复杂数据结构的值
  • 配合_的使用，会更加的便利

set及操作

集set

• 约定
  • set翻译为集合
  • collection翻译为集合类型或容器，是一个大概念
• set
  • 可变的，无序的，不重复的元素的集合
• set定义 初始化
  • set（）
  • set（iterable）
• set的元素
  • set的元素要求必须可以hash
  • 目前学过的不可hash的类型有list、set、bytearray
  • 元素不可以索引
  • set可以迭代
• set增加
  • add（elem）
    • 增加一个元素到set中
    • 如果元素存在，什么都不做
  • update（*others）
    • 合并其他元素到set集合中
    • 参数others必须是可迭代对象
    • 就地修改
• set删除
  • remove（elem）
    • 从set中移除一个元素
    • 元素不存在，抛出KeyError异常
  • discard（elem）
    • 从set中移除一个元素
    • 元素不存在，什么都不做
  • pop（）->item
    • 移除并返回任意的元素
    • 空集返回KeyError异常
  • clear（）
    • 移除所有元素
• set修改、查询
  • 要么删除，要么加入新的元素，不可修改
  • 非线性结构，无法索引
  • 可以迭代所有元素
• set和线性结构
  • 线性结构的查询时间复杂度是O(n),即随数据规模的增大而耗时增加
  • set、dict等结构，内部使用hash值作为key，时间复杂度可以做到O(1),查询时间和数据规模无关
  • 可hash
    • 数值型 int、float、complex
    • 布尔型 True、False
    • 字符串 string、bytes
    • tuple
    • None
    • 以上都是不可变类型，称为可哈希类型，hashable
  • set的元素必须是可hash的
• 集合
  • 全集
  • 子集subset和超集superset
  • 真子集和真超集
• 集合运算
  • 并集
    • 将两个集合A和B的所有元素合并到一起，组成的集合称作A与B的并集
    • | 运算符重载（等同union）
    • |= 将多个集合合并，就地修改（等同update）
  • 交集
    • 集合A和B，由所有属于A且属于B的元素组成的集合
    • intersection（*others）
      • 返回和多个集合的交集
    • &
      • 等同intersection
    • intersection_update(*others)
      • 获取和多个集合的交集，并就地修改
    • &=
      • 等同intersecton_update
  • 差集
    • 集合A和B，由所有属于A切不属于B的元素组成的集合
    • difference（*others）
      • 返回和多个集合的差集
    • • 等同difference
    • difference_update(*others)
      • 获取和多个集合的差集并就地修改
    • -=
      • 等同difference_update
  • 对称差集
    • 集合A和B，由所有不属于A和B的交集元素组成的集合，记作（A-B）∪（B-A）
    • symmetric_difference(other)
      • 返回和另一个集合的对称差集
    • ^
      • 等同symmetric_difference
    • symmetric_difference_update(other)
      • 获取和另一个几个的对称差集并就地修改
    • ^=
      • 等同symmetric_difference_update
  • issubset（other）、<=
    • 判断当前集合是否是另一个集合的子集
  • set1 < set2
    • 判断set1是否是set2的真子集
  • issuperset（other）、>=
    • 判断当前集合是否是other的超集
  • set1 > set2
    • 判断set1是否是set2的真超集
  • isdisjoint（other）
    • 当前集合和另一个几个没有交集
    • 没有交集，返回True
• 幂等性
  • 输入的参数不变，输出的值也对应相等
• hash冲突
  • 两个不同的值，经过hash，hash值一样（可能性极小）

字典dict

• key-value键值对的数据的集合
• 可变的、无序的、key不重复

字典dict定义 初始化

• d = dict()或者d = {}
• dict(**kwargs)使用name=value对初始化一个字典
• dict(iterable, **kwarg)使用可迭代对象和name=value对构造字典，不过可迭代对象的元素必须是一个二元结构
  • d=dict(((1,‘a’), (2,‘b’)))或者d=dict(([1,‘a’],[2,‘b’]), c=300)
• dict(mapping, **kwarg)使用一个字典构建另一个字典
• d={‘a’:10, ‘b’:20,‘c’:None,‘d’:[1,2,3]}
• 类方法dict.fromkeys(iterabe, value)
  • d=dict.fromkeys(range(5))
  • d=dict.fromkeys(range(5), 0)

字典元素的访问

• d[key]
  • 返回key对应的值value
  • key不存在抛出KeyError异常
• get(key[,default])
  • 返回key对应的值value
  • key不存在返回缺省值，如果没有设置缺省值就返回None
• setdefault(key[,default])
  • 返回key对应的值value
  • key不存在，添加kv对，value设置为default，并返回default，如果default没有设置，缺省为None

字典增加和修改

• d[key] = value
  • 将key对应的值修改为value
  • key不存在添加新的kv对
• update([other]) -> None
  • 使用另一个字典的kv对更新本字典
  • key不存在，就添加
  • key存在，覆盖已经存在的key对应的值
  • 就地修改

字典删除

• pop(key[,default])
  • key存在，移除它，斌返回它的value
  • key不存在，返回给定的default
  • default未设置，key不存在则抛出KeyError异常
• popitem()
  • 移除并返回一个任意的键值对
  • 字典为empty，抛出KeyError异常
• clear()
  • 清空字典
• del语句

字典遍历

• 遍历key

  for ... in dict
      # 遍历key
      for k in d:
          print(K)
  
      for k in d.keys():
          print(k)
  

• 遍历value

• for ... in dict
  	# 遍历value
  	for k in d:
  		print(d[k])
  	
  	for k in d.keys():
  		print(d.get(k))
  		
  	for v in d.values():
  		print(v)
  

• 遍历item

• for ... in dict:
  	for item in d.items():
  		print(item)
  	for item in d.items():
  		print(item[0], item<