python集合、内存相关、深浅拷贝

python集合

1.集合

  • 特点：天生去重，无序

  • 格式：v={1,2,3,4,5,6} 、 set{}

  • 注意事项：

    • 不能作为key来存放的类型（列表、字典、集合等可变类型）【unhashable错误】，因为内部会将一个值进行hash计算对应，用于快速查找。

    • True和False在列表中对应的是1和0，则true和1不会同时存在。

独有方法

  • add 添加

  • discard 删除

  • update 更新

 v={1,2,3,4,5,6,7,'allen'}
 v.add('Alice')
 v.discard(2)
 v.update({'1','2','allen',1})
 v.update('1','2','allen')  #allen会被拆分
 print(v)
 {1, 3, 4, 5, 6, 7, 'Alice', 'a', 'n', '2', '1', 'allen', 'e', 'l'}

  • intersection() 交集

  • union() 并集

  • difference() 差集

  • symmetric_difference() 对称差集

共有方法

  • len

     v={1,2,3,4}
 print(len(v))

  • 循环

     v={1,2,3,4}
 for i  in v:
     print(i)

  • 索引（无）

  • 步长（无）

  • 切片（无）

  • 删除（无）

  • 修改（无）

2.内存相关

  • 修改内容还是指向，这个是关键。

  • 内存地址查看（id）

     v1=[1,2,3]
 v2=v1
 v1.append(4)
 v1=[1]
 print(v2)
 print(id(v1)) #1717028392584  内存地址查看
 print(id(v2)) #1717028309128

  • python小数据池 在python中常见的一些数值有缓存机制，有些内存地址是一样的

  • 整型：（-5~256）地址相同

  • 字符串： 里面包含非数字 字母下换下,地址相同（包含_-*2a，等多种类型的组合字符串 ID是不同的）

　　
   >>> a=1
   >>> b=1
   >>> print(id(a))
   1678336224
   >>> print(id(b))
   1678336224
   ##############
   >>> c=256
   >>> d=-6
   >>> print(id(c))
   1678344384
   >>> print(id(d))
   2054654098064
   >>>

  • == 和 is的区别？

  • ==是比较的是值是否相等

  • is比较的是地址是否一致

     
     1 #特殊案例，因为有小数据池的原因
 2  >>> aa=10
 3  >>> cc=10
 4  >>> aa is cc
 5  True
 6  >>> aa == cc
 7  True
 8  #正常情况下
 9  >>> aa=1000
10  >>> cc=1000
11  >>> aa == cc
12  True
13  >>> aa is cc
14  False
15  ​
16  #注意情况
17  data1=[1,2,3,4,]
18  data2=[]
19  for i in data1:
20      data2.append(i)  #地址指定 如果改成data2.append(str(i))则地址就不同了
21  print(id(data1[0]))
22  print(id(data2[0]))

     

3.深/浅拷贝

  • 浅拷贝：拷贝第一层

  • 深拷贝：拷贝所有数据（可变）

  • 总结：深浅拷贝的却别就是在嵌套时有区别，因为浅拷贝之拷贝第一层深拷贝拷贝多层。

    • 如果拷贝的目标是字符串、整形、布尔值，则深浅拷贝就是内存指向 ，元组属于不可变类型，一般深浅拷贝没区别，如果元组里面有可变类型（列表、字典、集合等）则深浅拷贝有区别

     1  #一般情况
 2  import copy
 3  a='allen'
 4  c=copy.deepcopy(a)
 5  print(id(a)) #2107962686296
 6  print(id(c)) #2107962686296
 7  ​
 8  #特殊情况
 9  a=(1,2,3,['allen',12])
10  import copy
11  b=copy.copy(a)
12  c=copy.deepcopy(a)
13  print(id(a)) #1856971200696
14  print(id(b)) #1856971200696
15  print(id(c)) #2659884051416

     

    • 如果拷贝的选项是列表、字典、集合。对于这类可变的类型，深浅拷贝已有项目都是相同的，不同的是新增的值。应用在列表字典集合里面有嵌套的时候

     1  a=[1,2,3,['allen',12]]
 2  import copy
 3  b=copy.copy(a)
 4  c=copy.deepcopy(a)
 5  print(id(a)) #2659882503688 第一层不同
 6  print(id(b)) #2659884051400  第一层不同
 7  print(id(c)) #2659884051464 第一层不同
 8  print(id(a[3])) #2659881665160 嵌套相同
 9  print(id(b[3])) #2659881665160 嵌套相同
10  print(id(c[3])) #2659884094024 嵌套不同

     

补充：

  • 集合中不能共存的特殊值True 和1 False和0（字典中的key也是一样的）

     info={True:'allen',1:'alice'}
 print(info)  #{True: 'alice'}

     

  • 集合和列表的查询效率测试。

     1 import time
 2  flag=True
 3  while flag:
 4      choice=input('list or set >>')
 5      if choice == 'list':
 6          code=[]
 7          for i in range(100000000):
 8              code.append(i)
 9          break
10      elif choice=='set':
11          code=set()
12          for i in range(100000000):
13              code.add(i)
14          break
15      else:
16          print('input error!')
17  while True:
18      check_num=input('Please Input the number of check(0-100000000):')
19      if check_num.isdigit():
20          break
21      else:
22          continue
23  # print(type(check_num))
24  ​
25  def run_time():
26      if int(check_num) in code:
27          print('existed。')
28      else:
29          print('null')
30  ​
31  def times():
32      s=time.time()
33      run_time()
34      e=time.time()
35      run_code1=e-s
36      print('%s run time:%ss'%(check_num,run_code1))
37  ​
38  times()
    View Code

     

  •  

posted @ 2019-07-09 10:31  PlayOn  阅读(138)  评论(0)  编辑  收藏  举报