python基础四

目录

• 元组内置方法
  • • 使用方法
• 字典数据类型内置方法
  • • 优先掌握
    • 需要掌握
• 集合内置方法
• 深浅拷贝

元组内置方法

1. 作用：多个装备，多个爱好，多门课程，多个女朋友
2. 定义：()内可以有多个任意类型的值，逗号分隔元素
3. 常用操作+内置方法：常用操作和内置方法：
4. 如果元组只有个一元素，必须得加逗号

使用方法

1. 索引取值

   tup = (1, 2, 3)
   
   print(tup[0])
   

2. 索引切片

   print(tup[0:3])
   

3. for循环

   for i in tup:
       print(i)
   

4. 成员运算

   print(0 in tup)
   

5. len长度

   print(len(tup))
   

6. index获取元素索引

   print(tup.index(1))
   

7. count计数

   print(tup.count(2))
   

字典数据类型内置方法

1. 作用：存多个值，但每个值都有一个key与值对应，key对值有描述功能。

2. 定义：{}内用逗号分隔开多个元素，没个元素都是key:value的形式，value可以是任意数据类型，而key通常应该是字符串类型，但是key必须位不可变类型

3. 常用操作+内置方法：常用操作和内置方法，需掌握为一周

优先掌握

1. 按key存取值/按key修改值

   dic = {'a': 1, 'b': 2, 'c': 3}
   print(dic['a'])
   
   dic=['a']=4
   print(dic)
   

2. 长度len

   dic = {'a': 1, 'b': 2, 'c': 3}
   
   print(len(dic))
   
   

3. 成员运算in 和not in

   dic = {'a': 1, 'b': 2, 'c': 3}
   
   print('a' in dic)
   

4. del 删除

   dic = {'a': 1, 'b': 2, 'c': 3}
   
   del dic['a']
   print(dic)
   

5. 键keys()，值values(),键值对 items()

   # dic之键keys()、值values()、键值对items()，python2中取出的是列表（鸡蛋）；python3中取出的是元组（鸡）
   dic = {'a': 1, 'b': 2, 'c': 3}
   print(dic.keys())
   print(dic.values)
   print(dic.inems())
   

6. 循环

   dic = {'a': 1, 'b': 2, 'c': 3}
   
   for k,v in dic.items():
       print(k,v)
   

需要掌握

1. get

   dic = {'a': 1, 'b': 2, 'c': 3}
   
   print(dic.get('a'))
   
   

2. update

   dic = {'a': 1, 'b': 2, 'c': 3}
   dic1 = {'d':4}
   
   dic.update(dic2)
   

3. fromkeys

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

4. setdefault

   dic = {'a': 1, 'b': 2, 'c': 3}  # 默认给None
   
   dic.setdefault('j', 2)
   dic.setdefault('a', 2)
   print(dic)
   
   # setdefault  # 字典有这个key，就不修改，没有则增加
   

集合内置方法

1. 作用：用于关系运算的集合体，由于集合内的元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合会打乱原来元素的顺序。

2. 定义：{}内用逗号分隔开多个元素，每个元素必须是不可变类型

3. 使用方法：

   pythoners = {'jason', 'nick', 'tank', 'sean'}
   linuxers = {'nick', 'egon', 'kevin'}
   
   # 并集
   print(pythoners | linuxers)
   
   # 交集
   print(pythoners & linuxers)
   
   # 差集
   print(pythoners - linuxers)
   
   # 补集
   print(pythoners ^ linuxers)
   
   # add（*******）
   pythoners.add('oscar')
   print(pythoners)
   
   # pythoners.pop()  # 随机删除一个
   # print(pythoners)
   
   

深浅拷贝

1. 可变/不可以

   可变：值变id不变

   不可变：值变id也变

2. 拷贝(赋值)

   # 如果l2是l1的拷贝对象，则l1内部的任何数据类型的元素变化，则l2内部的元素也会跟着改变，因为可变类型值变id不变。
   l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
   l2 = l1
   
   l1.append('g')
   print(l1)
    # ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
   print(l2)
    # ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
   

3. 浅拷贝

  ```python
   # 如果l2是l1的浅拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，则l2会跟着改变。
  import copy
  
  l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
  l2 = copy.copy(l1)
  
  l1.append('g')
  
  print(l1)
   # ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
      
  print(l2)
   # ['a', 'b', 'c', ['d', 'e', 'f']]
      
  l1[3].append('g')
  
  print(l1)
   # ['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'g']
      
  print(l2)
   # ['a', 'b', 'c', ['d', 'e', 'f', 'g']]
  ```

  1. 深拷贝

     ```python
      # 如果l2是l1的深拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，l2也不会变，即l2永远不会因为l1的变化而变化。
     import copy
     
     l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
     l2 = copy.deepcopy(l1)
     l1.append('g')
     
     print(l1)
      # ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
         
     print(l2)
      # ['a', 'b', 'c', ['d', 'e', 'f']]
         
     l1[3].append('g')
     
     print(l1)
      # ['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'g']
         
     print(l2)
      # ['a', 'b', 'c', ['d', 'e', 'f']]
     ```