博客整理day07

目录

• 一、元祖内置方法
  • 用途
  • 定义
  • 常用操作和内置方法
  • 有序 or 无序
  • 可变 or 不可变
  • 元祖和列表的区别
• 二、字典数据类型
  • 用途
  • 定义
  • 常用操作和内置方法
  • 有序 or 无序
  • 可变 or 不可变
• 三、集合内置方法
  • 用途
  • 定义
  • 常用操作和内置方法
  • 有序 or 无序
  • 可变 or 不可变
• 四、数据类型总结
• 五、Python深浅拷贝

一、元祖内置方法

​ 元祖(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'}

4. & 交集、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'}

5. -差集、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'}
   

6. ^ 对称差集、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'}

7. ==

   # 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
   

8. 父集：>、>= 、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
   

9. 子集：<、<= 、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
   

10. add()

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

11. remove()

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

12. 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'}
    

13. discard()

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

14. 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)