• 博客整理day07


    一、元祖内置方法

    ​ 元祖(tuple)是不可变的列表

    用途

    ​ 存储多个值

    定义

    ​ 在()内可以有多个任意类型的值,用逗号分隔

    常用操作和内置方法

    1. 索引取值

      print(tup[0])

    2. 索引切片(顾头不顾尾,步长)

      print(tup[0,2])

    3. 长度len

      print(len(tup))

    4. 成员运算(in 和 not in)
      print(0 in tup)

    5. 计数count
      print(tup.count(2))

    6. 获取元素索引index
      print(tup.index(2))

    7. 循环for

      for i in tup:
          print(i)
      

    有序 or 无序

    ​ 有序

    可变 or 不可变

    ​ 不可变数据类型

    元祖和列表的区别

    ​ 列表可变的原因是:

    ​ 索引所对应的值的内存地址是可以改变的

    ​ 元组不可变得原因是:

    ​ 索引所对应的值的内存地址是不可以改变的,或者反 过来说,只要索引对应值的内存地址没有改变,那么元 组是始终没有改变的。

    二、字典数据类型

    用途

    ​ 存储多个值,但每个值都有一个key与之对应,key对值有描述功能

    定义

    ​ {}内用逗号分隔开多个元素,每个元素都是key:value的形式,value可以是任意数据类型,而key通常是字符串类型,但是key必须为不可变类型

    常用操作和内置方法

    1. 按key存取值:可存可取

      print(dic['a'])

    2. 长度len

      print(len(dic))

    3. 成员运算(in 和 not in)

      print('a' in dic)

    4. 删除del

      # dic之删除del
      dic = {'a':1,'b':2}
      del dic{'a'}
      print(dic.get('b', 1))  # 字典中没有返回None,可以给定一个默认值
      
      # dic之删除pop()
      dic = {'a':1,'b':2}
      dic.pop('a')  # 指定元素删除
      print(f"dic.pop('b'): {dic.pop('b')}")
      print(f"dic.get('a'): {dic.get('a')}")
      
      # dic之删除popitem()
      dic = {'a': 1, 'b': 2}
      
      print(f"dic.popitem(): {dic.popitem()}")  # popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)。
      
    5. 键key()/值values()/键值对items()

      # dic之键keys()、值values()、键值对items(),
      dic = {'a': 1, 'b': 2}
      
      print(f"dic.keys(): {dic.keys()}")
      print(f"dic.values(): {dic.values()}")
      print(f"dic.items(): {dic.items()}")
      #dic.keys(): dict_keys(['a', 'b'])
      #dic.values(): dict_values([1, 2])
      #dic.items(): dict_items([('a', 1), ('b', 2)])
      
    6. 循环

      # dic之循环
      # dic是无序的,但是python3采用了底层优化算法,所以看起来是有序的,但是python2中的字典是无序
      dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
      
      for k, v in dic.items():  # items可以换成keys()、values()
          print(k, v)
      
    7. get获取值

      # dic之get()
      dic = {'a': 1, 'b': 2}
      
      print(f"dic.get('a'): {dic.get('a')}")
      print(f"dic.get('c'): {dic.get('c')}")
      
    8. update()更新值

      # dic之update()
      dic1 = {'a': 1, 'b': 2}
      dic2 = {'c': 3}
      dic1.update(dic2)
      
      print(f"dic1: {dic1}")
      
    9. fromkeys()创建值为空的字典

      # dic之fromkeys()
      dic = dict.fromkeys(['name', 'age', 'sex'], None)
      
      print(f"dic: {dic}")
      #dic: {'name': None, 'age': None, 'sex': None}
      
    10. setdefault()

      # dic之setdefault(),有指定key不会改变值;无指定key则改变值
      dic = {'a': 1, 'b': 2}
      
      print(f"dic.setdefault('a'): {dic.setdefault('a',3)}")
      print(f"dic: {dic}")
      print(f"dic.setdefault('c'): {dic.setdefault('c',3)}")
      print(f"dic: {dic}")
      #dic.setdefault('a'): 1
      #dic: {'a': 1, 'b': 2}
      #dic.setdefault('c'): 3
      #dic: {'a': 1, 'b': 2, 'c': 3}
      

    有序 or 无序

    ​ 无序

    可变 or 不可变

    ​ 可变数据类型

    三、集合内置方法

    用途

    ​ 用于关系运算的集合体

    定义

    ​ {}内用逗号隔开多个元素,每个元素必须是不可变类型

    常用操作和内置方法

    1. 长度len

      print(f"len(s): {len(s)}")

    2. 成员运算(in和not in)

      print(f"1 in s: {1 in s}")

    3. | 并集、union

    # str之|并集
    pythoners = {'jason', 'nick', 'tank', 'sean'}
    linuxers = {'nick', 'egon', 'kevin'}
    
    print(f"pythoners|linuxers: {pythoners|linuxers}")
    print(f"pythoners.union(linuxers): {pythoners.union(linuxers)}")
    #pythoners|linuxers: {'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}
    #pythoners.union(linuxers): {'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}
    
    1. & 交集、intersection
    # str之&交集
    pythoners = {'jason', 'nick', 'tank', 'sean'}
    linuxers = {'nick', 'egon', 'kevin'}
    
    print(f"pythoners&linuxers: {pythoners&linuxers}")
    print(f"pythoners.intersection(linuxers): {pythoners.intersection(linuxers)}")
    #pythoners&linuxers: {'nick'}
    #pythoners.intersection(linuxers): {'nick'}
    
    1. -差集、difference

      # str之-差集
      pythoners = {'jason', 'nick', 'tank', 'sean'}
      linuxers = {'nick', 'egon', 'kevin'}
      
      print(f"pythoners-linuxers: {pythoners-linuxers}")
      print(f"pythoners.difference(linuxers): {pythoners.difference(linuxers)}")
      #pythoners-linuxers: {'tank', 'jason', 'sean'}
      #pythoners.difference(linuxers): {'tank', 'jason', 'sean'}
      
    2. ^ 对称差集、symmetric_difference

    # str之^对称差集
    pythoners = {'jason', 'nick', 'tank', 'sean'}
    linuxers = {'nick', 'egon', 'kevin'}
    
    print(f"pythoners^linuxers: {pythoners^linuxers}")
    print(
        f"pythoners.symmetric_difference(linuxers): {pythoners.symmetric_difference(linuxers)}")
    #pythoners^linuxers: {'egon', 'tank', 'kevin', 'jason', 'sean'}
    #pythoners.symmetric_difference(linuxers): {'egon', 'tank', 'kevin', 'jason', 'sean'}
    
    1. ==

      # str之==
      pythoners = {'jason', 'nick', 'tank', 'sean'}
      linuxers = {'nick', 'egon', 'kevin'}
      javers = {'nick', 'egon', 'kevin'}
      
      print(f"pythoners==linuxers: {pythoners==linuxers}")
      print(f"javers==linuxers: {javers==linuxers}")
      #pythoners==linuxers: False
      #javers==linuxers: True
      
    2. 父集:>、>= 、issuperset

      # str之父集:>、>=
      pythoners = {'jason', 'nick', 'tank', 'sean'}
      linuxers = {'nick', 'egon', 'kevin'}
      javaers = {'jason', 'nick'}
      
      print(f"pythoners>linuxers: {pythoners>linuxers}")
      print(f"pythoners>=linuxers: {pythoners>=linuxers}")
      print(f"pythoners>=javaers: {pythoners>=javaers}")
      print(f"pythoners.issuperset(javaers): {pythoners.issuperset(javaers)}")
      #pythoners>linuxers: False
      #pythoners>=linuxers: False
      #pythoners>=javaers: True
      #pythoners.issuperset(javaers): True
      
    3. 子集:<、<= 、issubset

      # str之子集:<、<=
      pythoners = {'jason', 'nick', 'tank', 'sean'}
      linuxers = {'nick', 'egon', 'kevin'}
      javaers = {'jason', 'nick'}
      
      print(f"pythoners<linuxers: {pythoners<linuxers}")
      print(f"pythoners<=linuxers: {pythoners<=linuxers}")
      print(f"javaers.issubset(javaers): {javaers.issubset(javaers)}")
      #pythoners<linuxers: False
      #pythoners<=linuxers: False
      #javaers.issubset(javaers): True
      
    4. add()

      # set之add()
      s = {1, 2, 'a'}
      s.add(3)
      
      print(s)
      #{1, 2, 3, 'a'}
      
    5. remove()

      # set之remove()
      s = {1, 2, 'a'}
      s.remove(1)
      
      print(s)
      #{2, 'a'}
      
    6. difference_update()

      # str之difference_update()
      pythoners = {'jason', 'nick', 'tank', 'sean'}
      linuxers = {'nick', 'egon', 'kevin'}
      pythoners.difference_update(linuxers)
      
      print(f"pythoners.difference_update(linuxers): {pythoners}")
      #pythoners.difference_update(linuxers): {'tank', 'jason', 'sean'}
      
    7. discard()

      # set之discard()
      s = {1, 2, 'a'}
      # s.remove(3)  # 报错
      s.discard(3)
      
      print(s)
      #{1, 2, 'a'}
      
    8. isdisjoint()

      # set之isdisjoint(),集合没有共同的部分返回True,否则返回False
      pythoners = {'jason', 'nick', 'tank', 'sean'}
      linuxers = {'nick', 'egon', 'kevin'}
      pythoners.isdisjoint(linuxers)
      
      print(f"pythoners.isdisjoint(linuxers): {pythoners.isdisjoint(linuxers)}")
      #pythoners.isdisjoint(linuxers): False
      

    有序 or 无序

    ​ 无序

    可变 or 不可变

    ​ 可变数据类型

    四、数据类型总结

    # 存一个值:整型/浮点型/字符串
    # 存多个值:列表/元组/字典/集合
    
    # 有序or无序
    # 有序:字符串/列表/元组(序列类型)
    # 无序:字典/集合
    
    # 可变or不可变
    # 可变:列表/字典/集合
    # 不可变:整型/浮点型/字符串/元组
    
    # 深浅拷贝(只针对可变数据类型) --. 用一定用不到,面试很大概率会问,这不是python独有的,而是一种语言独有的
    

    五、Python深浅拷贝

    # 主要内容
    
    # 当lt2为lt1的拷贝对象,lt1内部的不可变数据变化,lt2变;lt1内部的可变数据变化,lt2变(*****)
    
    # 当lt2为lt1的浅拷贝对象时,lt1内部的不可变元素变化,lt2不变;lt1内部的可变元素变化,lt2变(******)
    
    # 当lt2是lt1的深拷贝对象时,lt1内部的不可变类型变化,lt2不变;lt1内部的可变类型变化,lt2不变(*****)
    
    # 拷贝/浅拷贝/深拷贝 --> 只针对可变数据类型
    
    s1 = 'nick'
    s2 = copy.copy(s1)  # 无论s2是指向s1指向的值nick,还是自己新开辟内存空间
    
    # 内置方法中的copy方法都是浅拷贝的copy,也就是说如果你的列表里面有可变数据类型,那就不要使用.copy方法
    lt = [1,2,3,[1,]]
    lt2 = copy.deepcopy(lt)
    

  • 相关阅读:
    myeclipse源码相关操作
    来自一个程序员内心深处的心声
    编程乐趣--汉字转拼音
    MyEclipse下安装FreeMark插件
    java web 加载Spring --web.xml 篇
    注解方式实现声明式事务管理
    spring与struts简单整合案例
    创建对象与对象依赖关系
    几种对数据的处理以及对数据的封装
    Action开发、通配符、路径问题和struts中常量用法
  • 原文地址:https://www.cnblogs.com/samoo/p/11529430.html
Copyright © 2020-2023  润新知