1.list和tuple的区别

list 是一个长度可变，内容可变的序列
tuple 是一长度不可变，内容不可变的序列，但是，如果元组中套用列表或其他可变序列，由于列表和其他可变序列可变，所以一旦列表发生改变，元组中的列表也会发生改变，导致元组发生改变。

2.学到的序列有哪几种

str 字符串
byte 字节
tuple 元组
list 列表
dict 字典

3.list中所有方法的使用

 |  append(self, object, /)
 |      Append object to the end of the list.
 |  	# 在list的最后添加一个元素
    	""" list_var = [1, 2, 3] list_var.append(4) print(list_var) """
 |  clear(self, /)
 |      Remove all items from list.
 |  	# 删除list中所有的元素
		list_var = [1, 2, 3]
        list_var.clear()
        print(list_var)

 |  copy(self, /)
 |      Return a shallow copy of the list.
 |  	# 
 |  count(self, value, /)
 |      Return number of occurrences of value.
 |  	# 统计元素出现得次数（执行时没找到不会报错）
    	""" list_var = [1, 2, 3, 1] number = list_var.count(1) print(number) """
 |  extend(self, iterable, /)
 |      Extend list by appending elements from the iterable.
    	# 扩张列表 将一个可迭代对象（序列）添加到list的最后面
        """ list_var = [1, 2, 3, 1] str_var = "123456789" byte_var = b'123456789' tuple_var = (1, 2, 3, 4) list_var1 = [1, 2, 3, 1] list_var1.extend(str_var) print(list_var1) list_var1.extend(list_var) print(list_var1) list_var1.extend(byte_var) print(list_var1) list_var1.extend(tuple_var) print(list_var1) """
 |  
 |  index(self, value, start=0, stop=9223372036854775807, /)
 |      Return first index of value.
 |      # 返回元素第一次出现的下标（如果值不存在，会报错）
 |      Raises ValueError if the value is not present.
		""" list_var1 = [1, 2, 3, 1] print(list_var1.index(1, 1, 4)) """
 |  	
 |  insert(self, index, object, /)
 |      Insert object before index.
 |  	# 在指定的下标处添加一个元素（index,value）
    	""" list_var1 = [1, 2, 4] list_var1.insert(2, 3) print(list_var1) """
 |  pop(self, index=-1, /)
 |      Remove and return item at index (default last).
		# 弹出对应下标的值
 |      """ list_var = [1, 2, 3] number = list_var.pop() print(number) print(list_var) list_var1 = [1, 2, 3] number1 = list_var1.pop(1) print(number1) print(list_var1) """
 |      Raises IndexError if list is empty or index is out of range.
 |  
 |  remove(self, value, /)
 |      Remove first occurrence of value.
 |      # 删除传入的值（第一个），值不存在，则会报错
    	""" list_var = [1, 2, 2, 3] list_var.remove(2) print(list_var) """
 |      Raises ValueError if the value is not present.
 |  
 |  reverse(self, /)
 |      Reverse *IN PLACE*.
 |  	# 反转倒置(不进行排序)
		""" list_var = [1, 3, 2] list_var.reverse() print(list_var) """
 |  sort(self, /, *, key=None, reverse=False)
 |      Sort the list in ascending order and return None.
 |      # 正向排序
    	""" list_var = [1, 3, 5, 4, 6, 9, 8] list_var.sort() print(list_var) """
        # 自己改变规则
        """ def sort1(str_data): return str_data[-1], str_data[-2], str_data[-1] # return str_data[-1] str_list = ['banana', "drain", "pineapple", "cherry", "strawberry", "kiwifruit", "peach", "grape"] str_list.sort() print(str_list) str_list.sort(reverse=True) print(str_list) str_list.sort(key=sort1) print(str_list) """
 |      The sort is in-place (i.e. the list itself is modified) and stable 	(i.e. the order of two equal elements is maintained).
 |      
 |      If a key function is given, apply it once to each list item and sort them,ascending or descending, according to their function values.
 |      
 |      The reverse flag can be set to sort in descending order.

extend 和 append的区别

​ extend是将一个序列里面的每一个元素给存储到列表里

​ append是将一个序列（一个元素）作为一个元素给存储到列表里

tuple_var = (1, 2, 3, 4)
list_var1 = [1, 2, 3, 1]
list_var1.extend(tuple_var)
print(list_var1)
list_var1.append(tuple_var)
print(list_var1)

4.将元组和列表转换成字典

dict() key: value 序列(每个元素包含两个元素的序列)中应该包含两部分，一部分对应字典的key，一部分对应字典的value

tuple_var = ((1, 2), (3, 4))
list_var = [[1, 2], [3, 4]]
dict_var1 = dict(tuple_var)
dict_var2 = dict(list_var)
print(dict_var1)
print(dict_var2)

5.dict中所有方法的使用

	clear(...)
 |      D.clear() -> None.  Remove all items from D.
		# 清空字典
    	""" dict_var = {1: 2, 2: 3} print(dict_var) dict_var.clear() print(dict_var) """
 |  
 |  copy(...)
 |      D.copy() -> a shallow copy of D
		# 拷贝
 |  
 |  get(self, key, default=None, /)
 |      Return the value for key if key is in the dictionary, else default.
 |  	# 得到key为？的值，如果key不存在，返回None
    	""" dict_var = {1: 2, 2: 3} print(dict_var) var = dict_var.get(1) var1 = dict_var.get(3) print(var, var1) """
 |  items(...)
 |      D.items() -> a set-like object providing a view on D's items
        # 返回字典中所有键值对
 |  	""" a = {'数学': 95, '语文': 89, '英语': 90} print(a.items()) """
 |  keys(...)
 |      D.keys() -> a set-like object providing a view on D's keys
 |  	# 用于返回字典中所有的键。
    	""" a = {'数学': 95, '语文': 89, '英语': 90} print(a.keys()) """
 |  pop(...)
 |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 |      If key is not found, d is returned if given, otherwise KeyError is raised
 |  	# 弹出字典中key对应的值
		""" dict_var = {1: (1, 2, 3), 2: 3} var = dict_var.pop(1) print(var) print(dict_var) """


 |  popitem(self, /)
 |      Remove and return a (key, value) pair as a 2-tuple.
 |      # 弹出字典中最后一个键值对，并为元组
    	''' dict_var = {1: (1, 2, 3), 2: 3, 7: 4} var = dict_var.popitem() print(var) print(dict_var) '''
 |      Pairs are returned in LIFO (last-in, first-out) order.
 |      Raises KeyError if the dict is empty.
 |  
 |  setdefault(self, key, default=None, /)
 |      Insert key with a value of default if key is not in the dictionary.
 |      
 |      Return the value for key if key is in the dictionary, else default.
 |  
 |  update(...)
 |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 |      In either case, this is followed by: for k in F:  D[k] = F[k]
 |  
 |  values(...)
 |      D.values() -> an object providing a view on D's values
		# 返回字典所有键对应的值
    	""" a = {'数学': 95, '语文': 89, '英语': 90} print(a.values()) """
   

6.list或dict浅拷贝画图加代码解释

b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）
a,b 只要其中一个发生改变，两个都发生改变

a = {
    1: [1,2,3]}
b = a.copy()
print(a, b)
# {1: [1, 2, 3]}, {1: [1, 2, 3]}
a[1].append(4)
print(a, b)
# {1: [1, 2, 3, 4]}, {1: [1, 2, 3, 4]}
print(id(a[1]), id(b[1]))
# 2698953608384, 2698953608384

b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。
a, b 不管其中那一个发生改变，互不影响。
深拷贝

import copy
a = {
    1: [1,2,3]}
b = copy.deepcopy(a)
print(a, b)
# {1: [1, 2, 3]}, {1: [1, 2, 3]}
a[1].append(5)
print(a, b)
# {1: [1, 2, 3, 4, 5]}, {1: [1, 2, 3, 4]}
print(id(a[1]), id(b[1]))
# 2307260074176 2307259917760