zoukankan      html  css  js  c++  java
  • day07

    1. 基础数据类型补充

    1. 补充一个字符串的基本操作
    
        s = "abc"  # 字符串
        s1 = s.join("非常可乐")  # 把字符串s插入到"非常可乐"中
        print(s1)  # 非abc常abc可abc乐
    
        # .join()可以把列表变成字符串
        s = "_".join(["aelx","wuse","taibai","ritian"])  # 列表
        print(s)  # aelx_wuse_taibai_ritian
    
        # .split()把字符串变成列表
        s = "我_爱_你"
        lst = s.split("_")
        print(lst)  # ['我', '爱', '你']
    2. 列表循环删除
    
        # list在循环的时候不能删. 因为会改变索引
        li = [11, 22, 33, 44]
        for e in li:
             li.remove(e)
        print(li)  # [22,44]
    
        li = [11, 22, 33, 44]
        for i in range(0, len(li)):
            del li[i]
        print(li)  # 报错
    
        for el in li:
            li.pop() # [11,22]
        print(li)
        
        # 要想循环删除列表,就把要删除的再添加的一个新列表,然后循环这个新列表,删除列表里的元素
        # 1.
        lst = ['我不是药神','西游记','西虹市首富','天龙八部']
        del_lst = []  # 新列表
        for el in lst:
            del_lst.append(el)  # 把要删除的添加到新列表中
    
        for el in del_lst:  # 循环新列表
            lst.remove(el)  # 删除原来的列表
        print(lst)  # []
        
        # 2.
        lst = ['周杰伦','周润发','周星星','马化腾','周树人']
        del_lst = []
        for el in lst:
            if "" in el:
                del_lst.append(el)
        
        for el in del_lst:
            if "" in el:
                lst.remove(el)
        print(lst)  # ['马化腾']
      
      # 3.
      # 循环len(li)次, 然后从后往前删除
      li =[11,22,33,44]
      for i in range(0,len(li)):
        li.pop() # 删除最后一个元素
      print(li) # []
    3. 字典在循环过程中不能更改大小
        (1 ) 删除
        # 字典循环过程中不能删除
        dic = {'k1': 'alex', 'k2': 'wusir', 's1': '⾦⽼板'}
        # 删除key中带有'k'的元素
        for k in dic:
            if 'k' in k:
                del dic[k]  # 在循环迭代的时候不允许进⾏删除操作
        print(dic)  # RuntimeError: dictionary changed size during iteration
    
        # dict中的元素在迭代过程中是不允许进⾏删除的,把要删除的元素暂时先保存在⼀个list中, 然后循环list, 再删除.
        dic = {'k1': 'alex', 'k2': 'wusir', 's1': '⾦⽼板'}
        dic_del_list = []
        # 删除key中带有'k'的元素
        for k in dic:
            if 'k' in k:
                dic_del_list.append(k)
        for el in dic_del_list:
            del dic[el]
        print(dic)
    
        (2) 增加
        # 字典循环过程中不能添加
        dic = {"易大师":"剑圣","大宝剑":"盖伦","暗夜猎手":"薇恩"}
        # 如果keyshi"易大师",就添加"潮汐海灵"和它对于的value值"小鱼人".
        for el in dic:
            if el == "易大师":
                dic.setdefault("潮汐海灵","小鱼人")
        print(dic)  # RuntimeError: dictionary changed size during iteration
    
        # dict中的元素在迭代过程中是不允许进⾏删除的,把要删除的元素暂时先保存在⼀个list中, 然后循环list, 再删除.
        dic = {"易大师":"剑圣","大宝剑":"盖伦","暗夜猎手":"薇恩"}
        lst = []
        for el in dic:
            lst.append(el)
       
        for i in lst:
            if i in dic:
                dic.setdefault("潮汐海灵","小鱼人")
        print(dic)  # {'易大师': '剑圣', '大宝剑': '盖伦', '暗夜猎手': '薇恩', '潮汐海灵': '小鱼人'}

      注意: 由于删除元素会导致元素的索引改变, 所以容易出现问题. 尽量不要再循环中直接去删
      除元素. 可以把要删除的元素添加到另⼀个集合中然后再批量删除.
    4. fromkey()
        # dict中的fromkey(),可以帮我们通过list来创建⼀个dict,返回一个新的字典.
    
        a = dict.fromkeys(['jj','jay','taibai'],'sb')  # 静态方法
        print(a)  # {'jj': 'sb', 'jay': 'sb', 'taibai': 'sb'}
        
        dic = {'a':'123'}  # 没有用
        s = dict.fromkeys('王健林','思聪')  # 返回给你一个新的字典
        print(s)  # {'王': '思聪', '健': '思聪', '林': '思聪'}
    5. 类型转换
        元组 => 列表    list(tuple)
        列表 => 元组    tuple(list)
        
        list => str     str.join(list)
        str => list     str.split()
        
        转换成False的数据:
        0,'',None,[],(),{}.set() => False

    2. set集合

    1. set集合简介
        set中的元素是不重复的(去重), 无序的.里面的元素必须是可hash(不可变)的(int,str,tuple,bool)
        set就是dic类型的数据但是不保存value,只保存key. set也用{}表示
        注意: set集合中的元素必须是可hash(不可变)的,但是set本身是不可hash(可变)的.
      

      s = set() # 空集合
      
    dic = dict() # 空字典
      s = str() # 空字符串
      i = int() # 0
      lst = list() # 空列表

      s = {'a'}
      print(type(s)) # <class 'set'>
    2. 去重 和 frozenset()
        (1) 去重
        # set本身就可以去重
        s = {'王者荣耀','英雄联盟','王者荣耀', 123, True, True}
        print(s)  # {123, True, '英雄联盟', '王者荣耀'}
    
        # 其他数据可以先转换成set类型,再转换回去,就可以去重.
        lst = ['张强','李强','王磊','刘伟','张伟','张伟','刘洋','刘洋']
        s = set(lst)  # 去重复
        print(s)  # {'张强', '李强', '王磊', '刘伟', '刘洋', '张伟'}
        lst = list(s)  # 变回来
        print(lst)  # ['张强', '李强', '王磊', '刘伟', '刘洋', '张伟']
    
        (2) frozenset
        # 冻结了的set集合. 可哈希(不可变)的.
        s = frozenset([1,3,6,6,9,8])    # 可以去重复
        print(s)  # frozenset({1, 3, 6, 8, 9})
        
        ss = {'a',s}
        print(ss)  # {frozenset({1, 3, 6, 8, 9}), 'a'}
    3. set集合的增删改查
        (1) 增加
            s = {"刘嘉玲", '关之琳', "王祖贤"}
            s.add("郑裕玲")
            print(s)
            s.add("郑裕玲") # 重复的内容不会被添加到set集合中
            print(s)
    
            s = {"刘嘉玲", '关之琳', "王祖贤"}
            s.update("麻花藤") # 迭代更新
            print(s)  # {'王祖贤', '花', '关之琳', '藤', '麻', '刘嘉玲'}
            s.update(["张曼⽟", "李若彤","李若彤"])
            print(s)  # {'王祖贤', '花', '关之琳', '藤', '张曼⽟', '李若彤', '麻', '刘嘉玲'}
        (2) 删除
            s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
            item = s.pop() # 随机弹出⼀个.
            print(s)  # {'关之琳', '张曼⽟', '李若彤', '王祖贤'}
            print(item)  # 刘嘉玲
        
            s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
            s.remove("关之琳") # 直接删除元素
            print(s)  # {'王祖贤', '刘嘉玲', '李若彤', '张曼⽟'}
            s.remove("⻢⻁疼") # 不存在这个元素. 删除会报错
            print(s)  # KeyError: '⻢⻁疼'
    
            s.clear() # 清空set集合.需要注意的是set集合如果是空的. 打印出来是set()         
            因为要和dict区分的.
            print(s) # set()
    
        (3) 修改
            # set集合中的数据没有索引. 也没有办法去定位⼀个元素. 所以没有办法进⾏ 
            直接修改.
            # 我们可以采⽤先删除后添加的⽅式来完成修改操作
           
            s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
            把刘嘉玲改成赵本⼭
            s.remove("刘嘉玲")
            s.add("赵本⼭")
            print(s)  # {'张曼⽟', '关之琳', '李若彤', '王祖贤', '赵本⼭'}
    
        (4) 查询    
            # set是⼀个可迭代对象. 所以可以进⾏for循环
            for el in s:
                print(el)
    4. set集合的常用操作
        s1 = {"刘能", "赵四", "⽪⻓⼭"}
        s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
        
        # 交集
        # 两个集合中的共有元素
        print(s1 & s2) # {'⽪⻓⼭'}
        print(s1.intersection(s2)) # {'⽪⻓⼭'}
    
        # 并集
        print(s1 | s2) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'}
        print(s1.union(s2)) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'}
    
        # 差集
        print(s1 - s2) # {'赵四', '刘能'} 得到第⼀个中单独存在的
        print(s1.difference(s2)) # {'赵四', '刘能'}
    
        # 反交集
        print(s1 ^ s2) # 两个集合中单独存在的数据 {'冯乡⻓', '刘能', '刘科⻓', '赵 '}
        print(s1.symmetric_difference(s2)) # {'冯乡⻓', '刘能', '刘科⻓', '赵四'}
        s1 = {"刘能", "赵四"}
        s2 = {"刘能", "赵四", "⽪⻓⼭"}
    
        # ⼦集
        print(s1 < s2) # set1是set2的⼦集吗? True
        print(s1.issubset(s2))
    
        # 超集
        print(s1 > s2) # set1是set2的超集吗? False
        print(s1.issuperset(s2))

    3. 深浅拷贝

    (1) = 不会产生新的对象
        # ,一个变量改变,另一个也跟着变,因为两个变量指向一个数据
        lst1 = ["金毛狮王", "紫衫龙王", "白眉鹰王", "青衣服往"]
        lst2 = lst1  # 列表. 进行赋值操作实际上是引用内存地址的赋值. 内存中此时只有一 
        个列表. 两个变量指向一个列表,所以内存地址一样.
    
        lst2.append('杨做事')  # 对其中的一个进行操作. 两个都跟着变
        print(lst2)  # ['金毛狮王', '紫衫龙王', '白眉鹰王', '青衣服往', '杨做事'] 
        print(id(lst2))  # 2939242504776
        print(lst1)  # ['金毛狮王', '紫衫龙王', '白眉鹰王', '青衣服往', '杨做事']
        print(id(lst1))  # 2939242504776
    
    (2) 浅拷贝
        #  copy 创建新对象
        lst1 = ['赵本山','刘能','赵四']
        lst2 = lst1.copy()  # lst2 和list1 不是一个对象了,内存地址不一样.
        print(id(lst2),id(lst1))  # 1737898025608 1737898025544
        
        lst1.append("谢大脚")  # lst1添加'谢大脚",lst2不会变.
        print(lst1)  # ['赵本山', '刘能', '赵四', '谢大脚']
        print(lst2)  # ['赵本山', '刘能', '赵四']
        
        # 切片会产生新的对象
        lst1 = ['赵本山','刘能','赵四']
        lst2 = lst1[:]  # 产生新对象, 内存地址不一样
        print(id(lst2),id(lst1))  # 2403266159240 2403266159176
    
        # 浅拷贝只拷贝第一层,第二层的内容不会被拷贝.
        lst1 = ['超人','七龙珠',"葫芦娃",'山中小猎人',['金城武','王力宏','渣渣辉']]
        lst2 = lst1.copy()  # 浅拷贝只拷贝第一层, 第⼆层的内容不会拷⻉. 所以被 
        称为浅拷⻉
    
        lst1.append("aelx")  # 第一层被拷贝了,列表1和2各自有一个第一层,所以列表1添加"alex",列表2第一层就不会改变.
        
        lst1[4].append("大阳哥")  # 第二层没有被拷贝,列表1和2共用的痛一个第二层,
        所以第二层的元素改变,列表1和2的第二层都一起改变
        
        print(lst1)  # ['超人', '七龙珠', '葫芦娃', '山中小猎人', ['金城武', '王力宏', '渣渣辉', '大阳哥'], 'aelx']
        print(lst2)  # ['超人', '七龙珠', '葫芦娃', '山中小猎人', ['金城武', '王力宏', '渣渣辉', '大阳哥']]
    
    (3) 深拷贝
        # 深度拷贝会把内部的所有内 容进行拷贝
        import copy
    
        lst1 = ['超人','七龙珠',"葫芦娃",'山中小猎人',['金城武','王力宏','渣渣辉']]
        lst2 = copy.deepcopy(lst1)  # 把lst1扔进去进行深度拷贝, 包括内部的所有内 
        容进行拷贝
        lst1[4].append("大阳哥")  # 深度拷贝,列表1和2的第二层列表也是不共用的,各自拥有各自的第二层,所以改变列表1的第二层,列表2的第二层不会改变.
        print(lst1)  # ['超人', '七龙珠', '葫芦娃', '山中小猎人', ['金城武', '王力宏', '渣渣辉', '大阳哥']]
        print(lst2)  # ['超人', '七龙珠', '葫芦娃', '山中小猎人', ['金城武', '王力宏', '渣渣辉']]

      总结:
        1. = 不会产生新的对象
        2. 浅拷贝. 只拷贝第一层. 创建新对象
        3. 深拷贝. 把这个对象完全的进行拷贝. 创建出全新的对象
  • 相关阅读:
    (转)一台服务器安装两个tomcat6 服务的解决方案
    目标的改变
    常用但易忘的sql语句及java程序
    数据可视化工具 Gephi
    R中library和require的区别
    python BeautifulSoup解决中文乱码问题
    【转载】MySQL全文检索笔记
    poj 1011
    Nest,很酷的东西
    H.264开源解码器评测
  • 原文地址:https://www.cnblogs.com/kangqi452/p/11285749.html
Copyright © 2011-2022 走看看