• set 集合 内部元素不允许重复容器 可变类型
• dict 字典 键值对
• float 浮点

集合

• 无序 (无索引)
• 可变
• 不允许重复

可用于爬虫(保证链接唯一)

定义新集合

#集合
v1 = set()

#列表
v2 = list()

#元组
v3 = tuple()

#字典
v4 = dict()

独有功能

• 添加

  a = set()
  a.add('关之琳')

• 删除

  a.discard('关之琳')

• 交集

  b = {'刘能','赵四','皮长山'}
  a = {'刘科长','冯乡长','皮长山'}
  b.intersection(a) # {'皮长山'}
  b & a

• 并集

  b.union(a) #{'皮长山', '刘能', '赵四', '冯乡长', '刘科长'}
  b | a

• 差集

  b.difference(a) # {'刘能', '赵四'}
  b - a 

公共功能

• 差集 -
• 交集 &
• 并集 |
• 长度 len()
• for循环

类型转换

• int/str/tuple/dict可转集合

  a = [11,22,33,11]
  data = set(a) #{11,22,33}

• 主要目的为去重
• 集合也可转换为列表等

存储原理

• 转为hash取余数

  a = hash('a')
  data = a % 7 #余数在0-6之间，靠余数判断储存位置

• 集合元素只能是 int/str/tuple/bool 不可变类型
• list/set(本身)不能为集合元素

查询速度

列表元组循环慢

#速度慢,遍历
for i in list:
        pass

for i in tuple:
        pass

集合速度快(排除hash碰撞)

for i in set:
        pass

#原理，取余判断位置是否存在
>>> hash('a')
#5694973841062399683

hash('a')%7 #6
if hash_list[6] == 5694973841062399683
        pass

补充

• 是否可变 是否有序 元素要求 是否可hash 转换 定义空

• set{}集合的子元素或者嵌套元素的元素都不可放可修改元素

  [0,'op',{1,2,'pp',(1,2,[1,2,3])}] #有集合不准放可变元素哪怕是子列表

• True False hash后为1 和整形1互不兼容

  v1 = {True,1} #True
  v2 = {1,True} #False
  
  v3 = {0,False} #0
  v4 = {False,0} #False

元组练习

#在set a就加入list 不在就add
a = {'wupeiqi','alex','king'}
b = []

while True:
    user_input = input('请输入你想添加的(q/Q退出): ').strip()
    if user_input.upper() == 'Q':
        break
    if user_input in a:
        b.append(user_input)
        print(f'{user_input}在里面')
    else:
        a.add(user_input)
        print(f'{user_input}不在里面')
print(a,b)

#判断输入的是否在列表，在就提示，否则添加，
is_login_user = set()

while True:
    name = input('输入你的用户名,(q/Q退出)').strip()
    if name.upper() == 'Q':
        break
    pwd = input('输入你的密码').strip()
    data = (name, pwd)
    if data not in is_login_user:
        is_login_user.add(data)
    else:
        print('此用户已录入')

print(is_login_user)

列表去重可用set

a = [1,2,3,1,2,3,114]
data = set(a)
data = list(data) # [1,2,3,114]

none

特性

• 减少内存使用’

  #None不占空间
  v1 = None
  v1 = [1,2,3]

• bool为False/0

字典

• 无序，python3.6以后 有序
• 元素为键值对
• 键key唯一，会被覆盖

定义

v1 = {}
v1 = dict()

info  = {
    'a':'b',
    '1':'2',
    '3':'4',
    'e':'f'
}
    

• 键必须为可hash，(int,str,bool,tuple) 不可hash (list,set,dict)
• 键中1和True会覆盖
• 常用于固定格式

独有功能

• 获取键 get

  info  = {
      'a':'b',
      '1':'2',
      '3':'4',
      'e':'f'
  }
  
  data = info.get('a') #'b'

  如果get获取到不存在的键，返回None

  data = info.get('hj') #None

  如果获取到为None，又不想返回None

  info.get('hk',123)
  #不存在就返回123

优先处理简单逻辑，在判断复杂逻辑

#判断输入是否在键值对里
info  = {
    'a':'b',
    '1':'2',
    '3':'4',
    'e':'f'
}

#获取name和pwd
name = input('请输入name: ').strip()
password = input('请输入密码： ').strip()

#data输出为none不在键值对，True再对比值
data = info.get(name)

# # if data==None:
# #     print('你输入的值不存在')
# # else:
# #     if password==data:
# #         print('登录成功')
# #     else:
# #         print('密码错误')

if not data:
    print('你输入的值不存在')
else:
    if password==data:
        print('登录成功')
    else:
        print('密码错误')

• 获取所有键 - keys()

  获取的键在类似列表的容器内

  类列表可for循环

  类列表可判断，也可list转换为列表(默认获取的类型是dict_keys)

  info  = {
      'a':'b',
      '1':'2',
      '3':'4',
      'e':'f'
  }
  
  if 'a' in info:
          pass
  

• 获取所有的值 values()

  可循环，在类似列表容器内部，可判断

• 获取所有的键值items()

  循环获取键值对

  info  = {
      'a':'b',
      '1':'2',
      '3':'4',
      'e':'f'
  }
  
  for item in info.items():
          print(item[0],item[1])
  
  for k,v in info.items():
          print(k,v)
          

  也可判断键值对是否在内部(不常用)

  if ('a','b') in info.values():
          pass

(python2时，获取容器为列表，目的是优化缓存，减少内存占用)

• 新加 setdefault() 元组

  值不存在就添加，否则不加

  info.setdefault('a','b')

• 更新 update() 字典

  如果不存在就添加，存在就更新值

  info.update({'a':'b','c':'d'})

• 删除 pop() 键

  pop后能获取到删除的值

  data = info.pop('a')
  print(data)

• 顺序删除 popitem()

  3.6 以前字典无序，随机删除

  3.6 以后字典有序，删除最右侧键值对

  也能获取到删除的键值对(以元组存在)

  data = info.popitem()
  print(data)

  字典练习

  """
  结合下面的两个变量 header 和 stock_dict实现注意输出股票信息，格式如下：
      SH601778，股票名称:中国晶科、当前价:6.29、涨跌额:+1.92。
      SH688566，股票名称:吉贝尔、当前价:...               。
      ...
  """
  header = ['股票名称', '当前价', '涨跌额']
  
  stock_dict = {
      'SH601778': ['中国晶科', '6.29', '+1.92'],
      'SH688566': ['吉贝尔', '52.66', '+6.96'],
      'SH688268': ['华特气体', '88.80', '+11.72'],
      'SH600734': ['实达集团', '2.60', '+0.24']
  }
  '''
  '''
  
  #获取具体数据
  for k,v in stock_dict.items():
      #值和名称对应
      vlaue_list = []
      for i in range(len(v)):
          data = f'{header[i]}:{v[i]}'
          vlaue_list.append(data)
      #转换成字符串输出
      result = ', '.join(vlaue_list)
      print(f'{k},{result}')
  

公共功能

• 求并集 python3.9之间新加

  类似update 但不作用于自身

  a = {'v1':23,'v2':2}
  b = {'v2':24,'v3':12}
  data = v1 | v2 #{'v1':23,'v2':24,'v3':12}
  

• 长度 len()

• 是否在内 in

  默认判断键

  a = {"age":12, "status":True,"name":"武沛齐"}
  
  a1 = 'age' in a
  b = 'age' in a.keys()
  c = 12 in a.values()
  d = ('age',12) in a.items()

• 索引

  默认使用get 因为引用失败不报错，返回None

  a = {"age":12, "status":True,"name":"武沛齐"}
  

• 添加与修改

  如果键存在修改值，不存在就添加新键值对

  a = {"age":12, "status":True,"name":"武沛齐"}
  a['age'] = 22 #  {"age":12, "status":True,"name":"武沛齐"}
  a['gender'] = '男' # {"age":12, "status":True,"name":"武沛齐",'gender':'男'}

• 删除 del 常用

  与pop一样，无符合键会报错，需要校验键是否存在

  a = {"age":12, "status":True,"name":"武沛齐"}
  if 'age' in a.keys():
          del a['age'] # {"status":True,"name":"武沛齐"}
  else:
          print('值不存在')

• for循环

  循环keys values items

  a = {"age":12, "status":True,"name":"武沛齐"}
  for key in a:
          pass
  
  for key in a.keys():
          pass
  
  for value in a.values():
          pass
  
  for key,value in a.items():
          pass

转换

• 元组，列表转字典

  
  b = (('v1','a'),('v2','b'))
  print(dict(b)) #{'v1': 'a', 'v2': 'b'}
  
  b = [('v1','a'),('v2','b')]
  print(dict(b))  # {'v1': 'a', 'v2': 'b'}
  

• 字典转列表,元组

  a = {'v1': 'a', 'v2': 'b'}
  list(a) # ['v1','v2']
  
  a = {'v1': 'a', 'v2': 'b'}
  list(a.values()) # ['a','b']
  
  a = {'v1': 'a', 'v2': 'b'}
  list(a.items()) # [('v1','a'),('v2','b')]

其他

• 原理

  hash后 取余 确定位置

• 速度快，不需要迭代

• 嵌套

  键可hash(不可等于list,set,dict),键内部元素也必须可hash

  元组元素也遵循hash全部

  注意集合和字典键的True和1

浮点

• 类型转换(去掉小数)

• 保留小数点N位(四舍五入)

  v1 = 3.1415
  v2 = round(v1,3)
  print(v2)

• 浮点数相加会报错

  import decimal
  
  v1 = decimal.Decimal('0.1')
  v2 = decimal.Decimal('0.2')
  print(v1+v2) # 

二进制浮点数计算

小数部分x2，如果大于1减1 x2 小于1继续x2，等值等于1结束

取整数部分进行拼接就是二进制(01001010)

默认会进行无限循环

a = 0.29
value_list = []
i = 0
while i<100:
    if a == 1:
        break
    if not a>1:
        a*=2
    else:
        a-=1
        a*=2
    value_list.append(round(a,3))
    i+=1

print(value_list)
#[0.58, 1.16, 0.32, 0.64, 1.28, 0.56, 1.12, 0.24, 0.48, 0.96, 1.92, 1.84, 1.68, 1.36, 0.72, 1.44, 0.88, 1.76, 1.52, 1.04, 0.08, 0.16, 0.32, 0.64, 1.28, 0.56, 1.12, 0.24, 0.48, 0.96, 1.92, 1.84, 1.68, 1.36, 0.72, 1.44, 0.88, 1.76, 1.52, 1.04, 0.08, 0.16, 0.32, 0.64, 1.279, 0.559, 1.117, 0.234, 0.469, 0.938, 1.875, 1.75, 1.5, 1.0]
#在0.32与0.32之间循环

转换科学计数法

[0.58, 1.16, 0.32, 0.64, 1.28, 0.56, 1.12, 0.24, 0.48, 0.96, 1.92, 1.84, 1.68, 1.36, 0.72, 1.44, 0.88, 1.76, 1.52, 1.04, 0.08, 0.16, 0.32, 0.64, 1.28, 0.56, 1.12, 0.24, 0.48, 0.96, 1.92, 1.84, 1.68, 1.36, 0.72, 1.44, 0.88, 1.76, 1.52, 1.04, 0.08, 0.16, 0.32, 0.64, 1.279, 0.559, 1.117, 0.234, 0.469, 0.938, 1.875, 1.75, 1.5, 1.0]

#将列表取整拼接成字符串
str_zs = []
for i in value_list:
    str_zs.append(str(int(i)))

data = ''.join(str_zs)
print(data)
#010010100011110101110000101000111101011100001010001111
#1.0010100011110101110000101000111101011100001010001111*2**-2

• float32 单精度 float64双精度 用32,64位存储

• sign正负1bit exponent指数8位 fraction 23位

  • sign 正1 负0
  • exponent最大表示28 256位(-126-127) 25(127+5=132)存二进制

  • fraction 最大存储23位 ，不准确，可使用Decimal库进行详细计算

    import decimal
    
    v1 = decimal.Decimal('0.1')
    v2 = decimal.Decimal('0.2')
    print(v1+v2)

  • [https://www.bilibili.com/video/BV1354y1B7o1/

代码原则

• 尽可能少if判断
• 简单的逻辑先处理