数据类型（四）

今日内容概要

• 集合
• 内存相关
• 深浅拷贝

内容回顾&补充

1. 内容回顾

2. 补充

   • 列表

     • 反转：列表.reverse()

       v1 = [11,22,33,44,55,66]
       print(v1)
       v1.reverse()
       print(v1)

     • 按序排列：列表.sort(reverse=False / Ture)

       v1 = [111,2,33,454,5,89]
       v1.sort(reverse=False)   #按从小到大排列
       print(v1)    #输出：[2, 5, 33, 89, 111, 454]
       v1.sort(reverse=True)     #按从大到小排列
       print(v1)    #输出：[454, 111, 89, 33, 5, 2]

   • 字典

     • get 取值

       • 列表.get("键",返回的值)
         • 如果没有get到键，则返回第二个参数，无则返回None（None更节省内存）

       v1 = {"k1":11,"k2":22,"k3":33}
       reset = v1.get("k1")         #输出：11
       reset = v1.get("k1","不存在")      #输出：11
       reset = v1.get("k111","不存在") #输出：不存在
       reset = v1.get("k111")           #输出：None
       
       #判断get取得值是否存在于字典中
       info = {"k1":11,"k2":22,"k3":33}
       result = info.get("k111")
       if result:
           print("存在")
       else:
           print("不存在")

     • pop 取删除的值

       # pop删的为键值对，赋值给新变量的是值
       v1 = {"k1":11,"k2":22,"k3":33}
       result = v1.pop("k1")
       print(v1,result)
       #输出为：{'k2': 22, 'k3': 33}       11

     • del 删除字典内的键值对

       v1 = {"k1":11,"k2":22,"k3":33}
       del v1["k1"]
       print(v1)
       #删除字典中的键值对

     • update 将两个字典合并

       • 如果有重复的键，则第二个字典覆盖第一个字典中重复值

       info = {"k1":11,"k2":22,"k3":33}
       info.update({"k4":44,"k5":55,"k6":66})
       print(info)
       #输出为：{'k1': 11, 'k2': 22, 'k3': 33, 'k4': 44, 'k5': 55, 'k6': 66}

     总结：（以后经常用的方法）

     • 字典.keys
     • 字典.values
     • 字典.items
     • 字典.get

   3.判断一个字符是否有敏感字符

   • str

     v = "去你大爷家玩去吧"
     if "你大爷" in v:
         print('含敏感字符')

   • list / tuple

     v = ['yanan','海燕','成龙','alex']
     
     if 'yanan' in v:
         print('含敏感字符')

   • dict

     info = {'k1': 11, 'k2': 22, 'k3': 33, 'k4': 44, 'k5': 55, 'k6': 66}
     
     #默认按照键判断，即：判断"k"是否是字典的键
     if "k" in info:
         pass
     
     #判断字典中值是否存在“22”
        #方法一
     flag = "不存在"
     for v in info.values():
         if v == 22:
             flag = "存在"
             break
     print(flag)
        #方法二
     if 22 in list(info.values()):
         print("存在")            #list(info.values())表示将info的值强制转换为列表，整个循环在列表中判断
     
     #判断字典中键值对是否存在"k1":11
     value = info.get("k1")
     if value == 11:
         print("存在")

   • 敏感字符练习题

     #info为敏感字符列表，用户输入后判断是否包含敏感字符，如包含，打印“包含”，如不包含，打印输入内容
     info = ['大爷','炸弹','无所谓']
     
     prop = input("请输入:")
     
     flag = True
     for v in info:
         if v in prop:
             flag = False
             break
     
     if flag:
         print(prop)
     else:
         print("包含敏感字符")

今日内容

1.集合：set

• 无序的
• 无重复值

v = set()    #表示空集合
v = {1,2,3,4,5,6,7}     #跟字典比没有键值对，只有单一元素

独有功能：

add：往集合中添加元素

v = {'明天',"白天","雨天"}
v.add("晴天")
print(v)        #输出：{'晴天', '白天', '雨天', '明天'}

discard：在集合中删除元素

v = {'明天',"白天","雨天"}
v.discard("白天")
print(v)        #输出：{'明天', '雨天'}

update：批量添加

v = {'明天',"白天","雨天"}
v.update({11,22,33,44})
print(v)        #输出：{33, '明天', '白天', 22, 11, '雨天', 44}

intersection：交集(新值接收)

• 取两个集合的交集，如没有则返回空集合
• 第二个可以是list / tuple / set

v = {'明天',"白天","雨天"}
result = v.intersection({"白天","雨天","晴天"})
print(result)       #输出为{'雨天', '白天'}

union：并集(新值接收)

• 取两个集合的并集，两个集合合并
• 第二个可以是list / tuple / set

v = {'明天',"白天","雨天"}
result = v.union({"白天","雨天","晴天"})
print(result)       #输出为{'明天', '白天', '雨天', '晴天'}

difference：差集(新值接收)

• 取第一个集合中有，第二个集合中没有的元素
• 第二个可以是list / tuple / set

v = {'明天',"白天","雨天"}
result = v.difference({"白天","雨天","晴天"})
print(result)       #输出为{'明天'}

symmetric_difference：对称差集(新值接收)

• 取两个集合中都没有的元素
• 第二个可以是list / tuple / set

v = {'明天',"白天","雨天"}
result = v.symmetric_difference({"白天","雨天","晴天"})
print(result)

公共功能：

len()

v = {'明天',"白天","雨天"}
print(len(v))

for循环

v = {'明天',"白天","雨天"}
for item in v:
    print(item)

• 索引（无）
• 步长（无）
• 切片（无）
• 删除 / 修改（无）

嵌套

• 列表/字典/集合-->不能放在集合中
• 列表/字典/集合-->也不能作为字典的key（unhashable）

hash

• 因为在内部会将值进行哈希算法并得到一个数值（对应内存地址），用户快速查找目标元素
• 有序的才可被哈希（str / int / list / tuple / dict的键）
• 集合和字典是查找最快的，速度高于列表

v = ['明天',"白天","雨天"]
val = hash(v[0])
print(val)

2.内存相关

注意：

• 重新赋值和修改内存地址不一样

• 常用的int和str会做缓存

• int（-5 ~ 256）内存地址一样，缓存现象

• str（字母+字符，多次出现内存地址会不一样）

  v1 = "as&d"*2
  v2 = "as&d"*2
  print(id(v1),id(v2))  #内存地址不同

• 示例一：

  v1 = [11,22,33]
  v2 = [11,22,33]       #所指的不是同一块内存
  
  v1 = 666
  v2 = 666          #所指的是同一块内存（-5至256范围内存地址一样，范围外不一样）
  
  v1 = "asdf"
  v2 = "asdf"           #所指的是同一块内存（）

• 示例二：

  v1 = [11,22,33,44]
  v1 = [11,22,33]

• 示例三：

  v1 = [11,22,33]
  v2 = v1
  
  #练习1：（内部修改）
  v1 = [11,22,33]
  v2 = v1
  v1.append(999)
  print(v2) #含 999
  
  #练习2：（赋值）
  v1 = [11,22,33]
  v2 = v1
  v1 = [1,2,3,4]
  print(v2)
  
  #练习3：（重新赋值）
  v1 = "yanan"
  v2 = v1
  v1 = "zhoujielun"
  print(v2)

• 示例四：

  v = [1,2,3]
  values = [11,22,v]
  
  #练习1：
  v.append(9)
  print(values) #[11,22,[1,2,3,9]]
  
  #练习2：
  values[2].append(999)
  print(v)  #[1,2,3,999]
  
  #练习3：
  v = 999
  print(values) # [11,22,[1,2,3]]
  
  #练习4：
  values[2] = 666
  print(v)  #[1,2,3]

• 示例五:

  v1 = [1,2]
  v2 = [2,3]
  
  v3 = [11,22,v1,v2]

• 查看内存地址：

  • id(变量)

  v={"k1":1,"k2":2}
  print(id(v))

总结

• 列表list
  • reverse
  • sort
• 字典dict
  • get （重点）
  • update
• 集合set （无序，不重复的）
  • add
  • discard
  • update
  • intersection （重点）
  • union
  • difference
• 特殊
  • 嵌套：集合/字典的key
  • 空集合：set()
• id
• type
• 嵌套的应用 （重点）
  • 赋值
  • 修改内部元素：列表 / 字典 / 集合

python笔记(5)--数据类型（四）

原文：https://www.cnblogs.com/lynlearnde/p/11609472.html