1.列表赋值

a.直接使用一个列表变量给另一个列表变量赋值，赋的是地址。

赋完值之后，对其中一个列表进行增删改，会影响另一个表。

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

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

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

2.列表中的方法

a.列表.count（元素） - 获取指定元素在列表中出现的次数

b.列表.extend(序列) - 将列表中所有的元素添加到列表中

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

注意：
1.如果元素有多个，只取第一个的下标
2.如果这个元素不存在，会报错

d.列表.reverse（） -反向列表（将列表元素倒序）

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

列表.sort（reverse = True） - 对列表进行降序排序（从大到小）
注意：列表的要求：
1.列表的元素类型必须一样
2.元素支持比较元算符

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

注意：清空列表尽量用clear（）

g.列表.copy（） - 将列表中元素直接复制一份产生一个新的列表。和 列表[:] 效果一样

注意：这儿的拷贝是浅拷贝

numbers = [100,100,100,1,2,3]
print(numbers.count(100))

numbers.extend(['abc','hello'])
print(numbers)
numbers.extend('reus')
print(numbers)

numbers.reverse()
print(numbers)

numbers = [1,4, 7,2,5,8,9]
numbers.sort()
print(numbers)

numbers.sort(reverse=True)
print(numbers)

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

3.深拷贝和浅拷贝

import copy

copy.copy(对象) - 浅拷贝 ： 直接拷贝元素的值产生一个新的地址
copy.deepcopy（对象） - 深拷贝 ： 不会直接复制地址，而是将地址对应的值拷贝一份产生新的地址

numbers1 = [1,2,3]
numbers2 = [10,20,30]
list1 = [numbers1,numbers2]
print('浅拷贝：')
list2 = list1.copy() # 浅拷贝
print('修改前list1：',list1)
print('修改前list2：',list2)
list1.append(111)
list1[0].append(100)
print('修改后list1：',list1)
print('修改后list2：',list2)

numbers1 = [1,2,3]
numbers2 = [10,20,30]
list1 = [numbers1,numbers2]
print('深拷贝：')
list2 = copy.deepcopy(list1)
print('修改前list1：',list1)
print('修改前list2：',list2)
list1.append(88)
list1[0].append(99)
print('修改后list1：',list1)
print('修改后list2：',list2)

1.什么事元祖(tuple)

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

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

注意：
a.只有一个元素的元祖：元素后面必须加逗号
b.直接将多个数据用逗号隔开，不用括号括起来，还是元祖
c.获取元祖元素：
1.下标
2.可以通过变量个数和元祖个数保持一致来获取元祖中的每个元素
3.通过在变量名前加* ， 获取没有*的变量获取到的元素的剩下部分，以列表形式返回

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

4. 相关运算和列表一样:+ , * ,in/not in , len() , tuple(), max() ,min()

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

tuple1 = (1,True,'abc',[1,2])
print(tuple1)

tuple2 = (10,)
print(tuple2)

tuple3 = 1,2,3,'abc'
print(tuple3,type(tuple3))

tuple4 =(10,20)
print(tuple4[0])
x,y =tuple4
print(x,y)

tuple5 = ('张程',98,90,99)
name , *scores = tuple5
print(name , scores)

了解

tuple6 = 1,2,3
print(*tuple6)

list1 = ['a','b','c']
print(*list1)

1.什么事字典（dict）

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

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

键值对 - 键：值
键(key) - 不可变的；唯一的(列表和字典不能为key)，一般使用字符串作为key
值(value) - 任何类型的数据

3.什么时候用字典：

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

dict1 ={'aa':10,1:'abc',(19,20):'hello'}
# dict2 ={[1,2]:10,1:'abc',(19,20):'hello'}  # TypeError: unhashable type: 'list'
# dict3 ={'aa':1,'aa':2,'bb':3}   # {'aa': 2, 'bb': 3}
print(dict1)

# 用一个变量来存储一个学生的信息：姓名、年龄、电话、成绩、学号
student = {'name':'小明','age':28,'tel':13800000000,'score':30,'学号':123}
print(student['name'])

1.查（获取字典的值）

a.获取单个值

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

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

b.遍历

# 直接遍历字典拿到的是字典中所有的key
for x in dog1:
    print(x,dog1[x])

# 同时获取key和value（看着方便但是性能差，内存消耗多）
for key,value in dog1.items():
    print(key,value)

2.增（添加键值对）

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

b.字典1.update（序列） - 将序列中的元素转换成键值对，然后再添加到字典1中

注意：
当key值有重名的时候，互用序列中键值对对应的值，更新字典的key对应的值在这儿的序列要求是能够转换成字典的序列。序列中的元素是只能有两个元素的小序列

dict1 = {'a':100}
dict1['b'] = 10
print(dict1)

dict1 = {'a': 100, 'b': 10}
dict1.update({'aa':10,'bb':100,'a':'abc'})
print(dict1)

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

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

4.删（删除键值对）

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

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

person = {'name':'张三','age':30,'sex':'男'}
del person['sex']
print(person)

person = {'name':'张三','age':30,'sex':'男'}
age = person.pop('age')
print(person,age)

# 随机删除一个键值对（取出键值对，以元祖的形式返回）
person = {'name':'张三','age':30,'sex':'男'}
value = person.popitem()
print(person,value)

1.字典不支持+ 和 *

2.in 和 not in

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

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