一.列表相关方法

1.列表赋值

a.直接使用一个列表变量给另一个列表变量赋值，赋的是地址，赋完值之后对其中一个列表进行增删改会影响另一个列表

list1 = [1,2,3]
list2 = list1
list2.append(100)
print(list1)#[1, 2, 3, 100]

b.如果如果赋值的时候赋的是列表的切片或者拷贝，会产生新的地址，然后将新的地址去赋值，去使用新的地址赋值。

赋完值后两个列表之间相互不影响

list1 = [1,2,3]
list2 = list1[:]
list2.append(100)
print(list1)#[1, 2, 3]

2.关于列表的方法

1.列表.count（元素） - 获取指定元素在列表出现的次数
2.列表1.extend(序列) - 将序列中所有的元素添加到列表1中

            list1 = [1,2,3]
            list2 = [1,2,3]
            list1.extend(list2)
            print(list1)

3.列表.index(元素) - 获取指定元素在列表中的下标

• 注意：
  a.如果元素有多个，只取第一个的下标
  b.如果这个元素不存在，或报错

4.列表.reverce（） - 将列表倒序

     list1 = [1,2,3]
     list1.reverce()
     print(list1)

5.列表.sort（） - 对列表进行升序排序（从小到大）

list1 = [5,2,3,8,1]
list1.sort()
print(list1)

对列表进行降序（从大到小）

    list1 = [5,2,3,8,1]
    list1.sort(reverce = Ture)
    print(list1)

• 注意：
  a.列表元素类型相同
  b.元素支持比较运算符

6.列表.clear（） - 清空列表

7.列表.copy（） - 将列表中的元素赋值一份产生一个新的列表 和列表[:]效果一样

注意：这的拷贝是浅拷贝

8.深拷贝

import copy
'''
copy.copy(对象) - 浅拷贝
copy.deepcopy(对象) - 深拷贝 (不会直接复制地址，而是将地址对应的值拷贝一份产生新的地址)
'''
#深拷贝
numbers1 = [1,2,3]
numbers2 = [10,20,30]
list1 = [numbers1,numbers2]
list2 = copy.deepcopy(list1)
print(list1,list2)
list1.append(101)
list1[0].append(100)
print(list1)
print(list2)

numbers1 = [1,2,3]
list2 = copy.deepcopy(numbers1)
print(numbers1[0] is list2[0])
print((id(numbers1[0])))
print((id(list2[0])))

二.元祖

1.什么是元祖（tuple）

• 元祖就是不可变的列表，（有序，不可变）
  有序 - 可以通过下标获取元素
  不可变 - 不支持 增 删 改

2.元祖的字面量：通过小括号将多个元素括起来，多个元素之间用都好隔开

a.只有一个元素的元祖：小括号中的元素后必须加一个逗号

 tuple = (10,)

b.去掉小括号，直接将多个数据用逗号隔开，也表示一个元祖值

tuple = 1,2,3,'gs'

c.获取元祖元素

tuple = (10,20)
print(tuple[0])
可以通过变量个数和元祖个数保持一致来获取元祖的每个元素
x,y = tuple
print(x,y)

3.获取元祖的元素和列表元素一样

tuple3 = ('hs','df',2,3,4)
print(tuple3[1])
print(tuple3[:3])

for item in tuple3:
    print(item)

4.相关运算 和列表一样

+，*，in/not in , len(),tuple(),max/min()

5.元祖相关方法 只有列表中的 count和index。

三.字典

1.什么是字典

字典是python中内置的容器类数据类型，可变，无序的，字典的元素是键值对

2.字典的字面量：使用大括号括起来。大括号中是键值对，多个键值对之间用逗号隔开

• 键值对 - 键:值（key:value）
  键 -不可变的任何数据，唯一的 （一般使用字符串）
  值 - 任何类型的数据

• 什么时候使用字典
  如果一个容器里面存储的数据是不同意义的数据（数据之间需要区分）就是要字典

#用一个变量来存储一个学生的信息：姓名，年龄，电话，成绩，学号
student1 = {'name':'小虎','tel':'123132','age':'18','score':'88'}
print(student1['age'])

dict3 = {'s':[66,55,{'x':['张三','李四']}]}
print(dict3.get('x'))

3.字典的增，删，改，查

• 1.查（获取字典的值）

a.获取单个值

• 字典[key] - 获取字典中key对应的值(注意：如果key不存在，会报错：KeyError)
• 字典.get（key） - 获取字典中key对应的值（如果key不存在，不会报错，但会返回一个默认值：None）
• None：是python中的一个关键字，表示一个特殊值。（没有，空的意思）

dog1 = {'name':'旺财','age':'5岁','color':'黄色','type':'土狗'}
print(dog1['name'])
print(dog1['type'])
print(dog1.get('age'))

b.遍历

#直接遍历字典拿到的是字典中所有的key
for key in dog1:
    print(key,dog1[key])
#同时获取key和value（看着方便，但性能差，内存消耗多）
for key,value in dog1.items():
    print(key,value)

2.增（添加键值对）

字典[key] = 值 - 当key不存在时，就是在字典中添加键值对

dict2 = {'a':'100'}
dict2['b'] = 250
print(dict2)

• 字典1.update（序列）- 将序列中的元素转换成键值对，添加到字典1中
• 注意：在这儿的序列要求是能够转换成字典的序列，序列中的元素是只有两个元素的小序列

#当key值有重名的时候，会用序列中键值对对应的值，更新原字典的key对应的值

dict3 = {'a': '100', 'b': 250}
dict3.update({'aa':'12','a':'45'})

3.改（修改key对应的值）

• 字典[key] = 值 - 当key存在的时候就修改key对应的值

dict4 = {'a': '100', 'b': 250}
dict4['b'] = 150
print(dict4)

4.删（删除键值对）

a.del 字典[key] - 删除字典中key对应的键值对

dict4 = {'a': '100', 'b': 250}
del dict4['a']
print(dict4)

b.字典.pop（key） - 取出字典中key对应的值，删除整个键值对

dict6 = {'a': '100', 'b': 250}
c = dict6.pop('b')
print(dict6,c)

#删除最后一个键值对（取出最后一个键值对，以元祖的形式返回）
dict6 = {'a': '100', 'b': 250,'c': '100'}
value = dict6.popitem()
print(dict6)

4.字典相关运算符方法

• 1.字典不支持 + 和 *

• 2.in 和 not in

key in 判断字典中是否存在指定的key

dict1 = {'a': 12, 'b': 20, 'c': 30}
print('a' in dict1)