a=[1，2，3，[11，22，33]]

        b=a

        print(b) -->b=[1，2，3，[11，22，33]]    

        浅拷贝:我们创建a时，计算机给a开辟了一段空间给a存储数据，并让a指向 存储这个数据的地方（我们暂时叫做存储块）

        　　　　那么a 就有了这个存储数据的地址

        　　　　我们再把a复制b，由于数据完全一样，所以计算机并没有给b再开辟一个空间去存储数据，而是直接把a的地址引

        　　　　用给b了。这样a和b其实是指向同一个地址的（可以用print(id(a),id(b)查看他们俩的地址）。浅拷贝。

　　　　　　001）：例子a是一个列表，它里面的元素还有一个列表，由于a和b是指向同一个地址的变量，当列a表里面的那个

            列表元素发生变化时，b也会跟着变化的。

            例子：

            a[3].append("0000")---->打印的结果是a增加了，b也增加了

例子：

        a = [1,2,3,[11,22,33]]

        b=a[:]     #[:]获取a列表的所有的元素，然后组成一个新的列表给b

        b = a.copy()   #拷贝就是计算机创建一个新的列表，重新分配一个地址给b

        print(a,b)

        print(id(a),id(b))

        列表a和列表b的地址是不一样的，他们是内存地址不同的列表！

       当我们向列表a增加一个字符时，

例如：

       a = [1,2,3,[11,22,33]]

       b=a.copy()   #当我们先copy给b时，可以发现打印结果显示a和b是不一样的

       a.append("")   #不能将a.append("0000")放在上一句的程序前面，那样是先增加后copy  没有比较意义

       print(a)   --> [1, 2, 3, [11, 22, 33], '']

       print(b)   --> [1, 2, 3, [11, 22, 33]]

       print(id(a)) --> 927592748360

       print(id(b)) --> 927592749128

       由以上例子可以得到，浅拷贝时，当其原来的值发生变化时，他们的内容不会随着改变。

特例：当我们改变列表a中的元素，改变a[3]这个元素列表时 ，b也会改变

       a = [1,2,3,[11,22,33]]

       b=a.copy()

       a[3].append("")

       print(a)    -->  [1, 2, 3, [11, 22, 33, '']]     #a和b完全一样

       print(b)   -->   [1, 2, 3, [11, 22, 33, '']]

       print(id(a),id(b)) -->302083610632      302083609928  (a和b内存地址不一样)

深拷贝( copy.deepcopy()  )由于不是内置方法，所以需要引入模块 import copy

        import copy

        a = [1, 2, 3, [11, 22, 33]]

        b=copy.deepcopy(a)   #深拷贝

        a[3].append("")    #给列表增加元素

        print(a)             #打印：  [1, 2, 3, [11, 22, 33, '11'], '9999']

        print(b)             #打印：  [1, 2, 3, [11, 22, 33]]

        a[3].append("")

        print(id(a),id(b))   #打印：577208750472    577207277576

 总结：由以上例子可以得出，对对象进行深拷贝时，会拷贝一份内容一模一样的新对象出来，这个新对象和原来的对象

        除了内容相同外，其他没有任何相同的地方，属于两个不同的对象。

       原对象进行改变后，深拷贝出来的对象不会随之变化，

       特点：深拷贝比较召内存（内存需要给其一个新的存储空间）

   lst_1="&".join(lst)    #要记住这个方法

        print(lst_1)   #打印： 2&3&4&5

 lst="qwer"

            lst_1=lst("_")

            print(lst_1)  #打印： ['qwer']

            lst="qwer"

            lst_1=lst.split("")  #当切割的xx  是空字符串时，会报错：ValueError: empty separator

            print(lst_1)

lst=["qw","rt","t","u"]

        for i in lst:

            lst.remove(i)   ###删除是不彻底的。 原因是每次删除都会导致元素的移动。 每次都会更新一次索引

        print(lst)

        #打印：['rt', 'u']

     # 原因解析：

        #进行for 循环输出后，remove会从列表的第一个元素进行移除，当把第一个元素进行移除后，

        此时移除的是索引为0  元素，移除后，后面的元素会往左移动，顶替到刚刚被移除

        的索引为0的位置，这样索引原本为1 的元素顶替到索引为0的位置，成为新的索引为0的

        元素，由于计算机已经移除了索引为0 的元素，此时会移除索引为1的元素，（原本索引是1）

        顶替到索引0的元素不会被删除，这样，移除的时候就会漏掉移除元素。 最后到尽头了就不

        再进行移除了！所以这个列表的打印结果为：['rt', 'u']

  lst=["qw","rt","t","u"]

        lst_new=[]

        for i in lst:

            lst_new.append(i)

            print(i)      #打印：qw  rt  t  u

        # print(lst_new)  #打印：  ['qw', 'rt', 't', 'u']

        for m in lst_new:   #由于lst列表是在循环中，不能进行删除，所以我们新建一个新的列表lst_new,

            lst.remove(m)   # 将新的列表lst_new进行循环，然后再删除旧的列表

        print(lst)     打印：[]

创建一个字典d={}   dict.fromkeys不是在原有的字典上增加  键值对

    d1=dict.fromkeys("张三","李四")

    d2=dict.fromkeys("张张","李四")

    print(d1)  #打印： {'张': '李四', '三': '李四'}

    print(d2)   #打印：{'张': '李四'}  列表是就是去重复的，由于有两个张，所以只有一个   键值对

你的value如果是可变的数据类型。 所有的key都可以改动这个数据。 一个改动， 所有的value都跟着改变

    d=dict.fromkeys("张三",["许先生"])

    print(d)   #打印： d={'张': ['许先生'], '三': ['许先生']}

    #如果我们对d["张"]这个列表进行 增加后

    d["张"].append("增加")

    print(d)   #打印：{'张': ['许先生', '增加'], '三': ['许先生', '增加']}

  s={1,2,3,4,57,7,7,7,7,7}  #集合去重

   print(s)  #打印：{1, 2, 3, 4, 7, 57}

列表：s=["","","","",""]  将这个列表转换为集合  lst

       列表--〉集合：lst=set(s)  #打印：集合： lst={'2', '6', '3'}

       集合--〉列表：a=list(lst)  #打印：a=['6', '3', '2']

    #frozenset #可哈希的集合, 不可变.  将集合转换为列表

    s = frozenset([1,2,3,4,5])

    print(s)

    for el in s:

        print(el)

        打印：frozenset({1, 2, 3, 4, 5})