集当中的元素是散放的，是一个散列值，是个哈希。
python当中所有数据结构，在其他语言当中都能够找到。
列表更适合尾部追加，两头要操作就要用queue。
前面学过的可变的，就是bytearray,list。
可变不可变，指的就是能不能就地修改。
集合当中的元素，本身就是不能重复的。
集合最大的一个用处，就是去重。
s1 = set()
s2 = set(range(5))
s3 = set(list(range(10)))
s4 = {} # dict
s5 = {9,10,11} # set
s6 = {(1,2),3,‘a‘}
s7 = {[1],(1,)1} # ?
s = set(enumerate(range(10)))
s = set(range(10))
s = {}
type(s) # dict，集合当中什么都不写，这个就是字典了
s = {1}
type(s) # set
s1 = set() # 这个才是定义一个空的字典。
s = {(1,2),2,None}
s = {(1,2),2,None,‘abc‘,b‘abc‘,[1]} # unhashable type : ‘list‘
# list是一个不可哈希类型的。
# set当中的元素，要么都是不可变类型，要么就是一个单值。
s = {(1,2),2,None,‘abc‘,b‘abc‘,bytearray(b‘abc‘)}
hash(‘abc‘)
hash(b‘abc‘)
上面两个哈希值一样
hash(10000000)
hash(1)
s = set([‘abc‘,b‘abc‘]) # ‘abc‘,b‘abc‘两个哈希值一样，但是可以存进去的。
set??
set(s)
无序是迭代的，不可以索引，成员运算符，是可以的。
s = add(2)
s = update({1,2,3}) # 这个就是在做集合运算了
s = update([1,2,3],[1,3,4]) # 给了两个集合，把多个集合合并到当前集合
s = update([1,2,3],[1,3,4],(11,23,45))
s = update([1,2,3],[1,3,4],[11,23,45])
移除的方式，就是求了元素的哈希值。
顺序结构的移除，就是要遍历一遍的。用索引，找的过程很快。
找到这个值，就是O(1)的。
但是移除这个值之后，后面的元素都要向前补充一下，所以速度慢。
但是集合是通过值的hash来进行移除的，这个hash就是相当于值的key。
移除了之后，大家也不用移动位置。
所以效率还是很高的。
pop?
help(s.pop())
s.pop()当中不要传参数
a = s.pop()
总结：
1. remove() 有异常处理
2. pop() 有异常处理
3. discard() 无异常处理
4. clear() 无异常处理
移除元素，都会面临到一个垃圾回收的问题。
%%timeit lst1 = list(range(100))
-1 in lst1 # 这个就是true或者false的问题。-1必须遍历全部。
%%timeit set1 = set(range(100)) # set_up_code 不计时了
-1 in set1 # 这个就是true或者false的问题。-1必须遍历全部。
当我们判断或者迭代的时候，用set效率会更高。
线性结构的查询时间复杂度是O(n)，随着数据规模的增大而增加耗时
set、dict等结构，内部使用hash值作为key，时间复杂度可以做到O(1)，查询时间和数据规模无关
可hash
set的元素必须是可以hash的。
这里不要和可迭代对象搞混了，只要可迭代对象当中的元素是可以哈希的，那么就可以
s = set(list)这种用法
原文：https://www.cnblogs.com/gnuzsx/p/12743831.html