• 07 基本数据类型的知识点补充 set()集合 深浅拷贝 冒泡算法


    主要内容:

      1.str.jion()

    s = "abc"
    s1 = s.join("非常可乐") # 把字符串s插入到"非常可乐"中
    print(s1)
    

     jion可以把列表变成字符串,相应的split可以把字符串变成列表

    s = "_".join(["alex", "wuse", "taibai", "ritian"])  # join可以把列表变成字符串, 把字符串变成列表.split()
    print(s)                                            ####结果是:alex_wusir_taibai_ritian_sylar
    

      2.列表在循环的时候不能删除,因为索引会跟着改变,

    lst = ["我不是药神", "西游记", "西红柿首富", "天龙八部"]
    # list在循环的时候不能删. 因为会改变索引,所以要建一个新的列表,循环新的列表,将原来列表中的元素删除.
    del_lst = []
    for el in lst:
        del_lst.append(el)  # 记录下来要删除的内容
    for el in del_lst:  # 循环记录的内容
        lst.remove(el)  # 删除原来的内容
    print(lst)
    

        练习题:删除以周开头的元素

    li = ["周星驰","周杰伦","周树人","马化腾"]
    li1=[]
    for el in li:
        if el.startswith("周"):
            li1.append(el)
    for s in li1:
        li.remove(s)
    print(li)
    

      3.字典也不能直接删除,要把删除的内容放在列表中,循环列表,删原来字典中的数.

    lst = []
    for k, v in zhubo.items():
        if v < avg:
            lst.append(k)   # 列表保存要删除的key
    for el in lst:  # 迭代的是列表
        zhubo.pop(el)   # 删的是字典
    print(zhubo)
    

      4.fromkeys() 不会对原来的字典产生影响,产生新的字典:

    dic={}
    s=dic.fromkeys("王健林", "思聪" )       #返回给一个新的字典
    print(dic)
    print(s) 
    {}                                                #dic
    {'王': '思聪', '健': '思聪', '林': '思聪'}           #s
    

       因为dict是一个类,可以指向指向对象

    a = dict.fromkeys(["jj", 'jay', 'taibai'], "sb")  # 静态方法
    print(a) #结果是:{'jj': 'sb', 'jay': 'sb', 'taibei': 'sb'}

      5.set()集合: set中的元素是不重复的.无序的.⾥面的元素必须是可hash的(int, str, tuple,bool), 我们可以这样来记. set就是dict类型的数据但是不保存value, 只保存key. set也用{}表示.

      注意:set集合中的元素必须是可hash的, 但是set本⾝身是不可hash得. set是可变的.

    s = {123, {1,2,3}}    # 不合法
    print(s)
    

      利用集合的无序,不重复,可以删除集合中的重复的元素;

    lst=["张强","沥青","王磊",'liqing',"张强"]
    s=set(lst)
    print(s)
    

      添加:

    s = {"刘嘉玲","关之琳","王祖贤"}
    s.add("朱茵")
    print(s)
    s.add("朱茵")                    #重复的内容不会添加进去
    s = {"刘嘉玲","关之琳","王祖贤"}
    s.update("马化腾")               #迭代添加     
    print(s)                        #  {'腾', '王祖贤', '关之琳', '刘嘉玲', '马', '化'}
    

      删除:

    s = {"刘嘉玲","关之琳","王祖贤"}
    s.remove("刘嘉玲")
    s.remove("朱茵")              #如果不存在会报错
    s.pop()                        #随机拿出一个删除
    print(s)
    

      修改:

    #set()集合中的数据没有索引,没有办法定位一个元素,所以没有办法直接修改。
    #可以采用先删除后添加的方式来完成修改操作。

            查询:set()是一个可以迭代对象,可以使用for循环

    s = {"刘嘉玲","关之琳","王祖贤"}
    for el in s:
        print(el)

      6.深浅拷贝

        1:直接复制:两个变量指向同一个对象.

    lst1 = ["金毛狮王", "紫衫龙王", "白眉鹰王", "青衣服往"]
    lst2 = lst1 # 列表, 进行赋值操作. 实际上是引用内存地址的赋值. 内存中此时只有一个列表. 两个变量指向一个列表
    lst2.append("杨做事")  # 对期中的一个进行操作. 两个都跟着变
    print(lst2)
    print(lst1)
    

        2:浅拷贝:只拷贝第一层那内容.  copy()

    浅拷贝 copy 创建新对象
    lst1 = ["赵本山", "刘能", "赵四"]
    # lst2 = lst1.copy()  # lst2 和lst1 不是一个对象了
    lst2 = lst1[:]  # 切片会产生新的对象
    lst1.append("谢大脚")
    print(lst1, lst2)
    # print(id(lst1), id(lst2))

        3:深度拷贝:对象中的所有内容都会被拷贝一份

    lst1 = ["超人", "七龙珠", "葫芦娃", "山中小猎人", ["金城武", "王力宏", "渣渣辉"]]
    lst2 = lst1.copy()  # 拷贝. 浅拷贝 拷贝第一层
    lst1[4].append("大阳哥")
    print(lst1, lst2)
    # 深拷贝
    import copy
    lst1 = ["超人", "七龙珠", "葫芦娃", "山中小猎人", ["金城武", "王力宏", "渣渣辉"]]
    lst2 = copy.deepcopy(lst1)  # 把lst1扔进去进行深度拷贝 , 包括内部的所有内容进行拷贝
    lst1[4].append("大阳哥")
    print(lst1, lst2)
    

      为什么要拷贝:因为拷贝比创建对象快的多.

      对列表进行从大到小进行排序

    li=[12,34,2,34,6,5,7,90]
    for a in range(len(li)):                             #记录内部循环的次数
        i = 0
        while i< len(li)-1:                               #把最大值移动到右边
            if li[i] > li[i+1]:                           #比较
                li[i],li[i+1]=li[i+1],li[i]               #交换
            i = i + 1
    print(li)
    

      

     

     

  • 相关阅读:
    socket 网络编程
    错误与异常
    正则与计算器
    正则爬虫案例
    面向对象
    模块与包
    常用模块-----configparser & subprocess
    正则表达式&re模块
    常用模块---sys&logging&序列化模块(json&pickle)
    常用模块----time&random&hushlib&os
  • 原文地址:https://www.cnblogs.com/gyh412724/p/9289570.html
Copyright © 2020-2023  润新知