一、recode

列表(list) - 有序、可变
[12, 34, 56]

列表元素的要求：任何类型的数据都可以作为列表元素

获取单个元素、获取部分元素(切片)、遍历

相关运算: +, *, ==/!=, in / not in, len(), list(), max(), min()

name = '张三'
list1 = [12, 'abc', True, name, max('abcz')]
print(list1[-1])

补充： == 和 is

== - 判断两个数据的值是否相等

is - 判断地址是否相等

python数据存储:1.给变量赋值的时候，如果数据的类型是数字或者字符串，不会直接开辟空间存数据，
而是现在数字字符串对应的缓存区里面去查看是否已经存储过对应的数据。如果已经存了，
直接将之前的数据对应的地址赋给变量。如果没有存储才会开辟空间存储数据。
其他类型的数据，都是直接开辟空间存储数据。然后再把地址返回
2.容器类型中的元素，在容器中不是直接存的值，而是元素值对应的地址

list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1
print(list1 == list2)
print(list1 is list2)
print('===:',list1[0] is list2[0])
print(list1 is list3)
number1 = 10
number2 = 10
print(number1 is number2)

二、列表相关方法

1.列表赋值

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

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

b.如果赋值的时候赋的是列表的切片或者拷贝，会产生新的地址，然后使用新的地址赋值。
赋完值之后，两个列表相互之间不影响

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

2.列表中的方法

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

2.列表.extend（序列） - 将序列中的所有元素都添加到列表中

nums=[2,3,45,34]
nums.extend(['hello'])
print(nums) #[2, 3, 45, 34, 'hello']
nums.extend('what')
print(nums) #[2, 3, 45, 34, 'hello', 'w', 'h', 'a', 't']
nums.extend(range(10))
print(nums) #[2, 3, 45, 34, 'hello', 'w', 'h', 'a', 't', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

3.列表.index（元素） - 获取指定元素在列表中下标

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

4.列表.reverse() - 反向列表 （将列表倒序）

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

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

nums1=[23,22,434,55,112,6,67,8]
nums1.sort()
print(nums1) # [6, 8, 22, 23, 55, 67, 112, 434]
nums1.sort(reverse=True)
print(nums1) # [434, 112, 67, 55, 23, 22, 8, 6]

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

nums1=[23,22,434,55,112,6,67,8]
nums1.clear()
print(nums1) #[]
#注意：尽量使用上面的方法清空列表 列表.clear（）
nums1=[23,22,434,55,112,6,67,8]
nums1=[]
print(nums1) #[]

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

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

nums1=[23,22,434,55,112,6,67,8]
nums2=nums1.copy()
print(nums2)#[23,22,434,55,112,6,67,8]
print(nums2==nums1) #True
print(nums1 is nums2) #False

三、浅拷贝和深拷贝

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

import copy
copy.copy(对象) - 浅拷贝
nums1=[1,2,3]
nums2=[10,20,30]
list1=[nums1,nums2]
list2=copy.copy(list1) 或者写成list2=list.copy()
list1.append(111)
print('浅拷贝list1：',list1)浅拷贝list1： [[1, 2, 3], [10, 20, 30], 111]
print('浅拷贝list2：',list2)浅拷贝list2： [[1, 2, 3], [10, 20, 30]]
修改list1元素中元素
list1[0].append(112)
print('修改浅拷贝list1：',list1)修改浅拷贝list1： [[1, 2, 3, 112], [10, 20, 30], 111]
print('修改浅拷贝list2：',list2)修改浅拷贝list2： [[1, 2, 3, 112], [10, 20, 30]]
copy.deepcopy(对象) - 深拷贝
nums1=[1,2,3]
nums2=[10,20,30]
list1=[nums1,nums2]
list2=copy.deepcopy(list1)
print('深拷贝list1:',list1)深拷贝list1: [[1, 2, 3], [10, 20, 30]]
print('深拷贝list2:',list2)深拷贝list2: [[1, 2, 3], [10, 20, 30]]
list1.append(222)
print('深拷贝修改list1后list1:',list1)深拷贝修改list1后list1: [[1, 2, 3], [10, 20, 30], 222]
print('深拷贝修改list1后list2:',list2)深拷贝修改list1后list2: [[1, 2, 3], [10, 20, 30]]
list1[0].append(333)
print('深拷贝修改list1中元素后list1:',list1)深拷贝修改list1中元素后list1: [[1, 2, 3, 333], [10, 20, 30], 222]
print('深拷贝修改list1中元素后list2:',list2)深拷贝修改list1中元素后list2: [[1, 2, 3], [10, 20, 30]]

四、元祖

1.什么是元祖（tuple）

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

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

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

tuple1=(10,)
print(tuple1,type(tuple1))(10,) <class 'tuple'>

b.直接将多个数据用逗号隔开，不用小括号括起来。还是一个元祖值

tuple2=1,2,3,34
print((tuple2,type(tuple2)))((1, 2, 3, 34), <class 'tuple'>)

c.获取元祖元素

1.可以通过变量个数和元祖元素个数保持一致来获取元祖中的每个元素

tuple2=1,2,3,'34'
x,y,z,k = tuple2
print(x,y,z,k) #1 2 3 34
print(k,type(k)) #34 <class 'str'>

2.通过变量名前加，获取没有的变量获取到的元素的剩下的部分。以列表的形式返回

tuple2=（1,2,3,'34'）
a,*b=tuple2
print(a)
print(*b,type(*b))
(了解)
*列表、*元祖等直接获取列表元祖中元素的值  
tuple1 = (1, 2, 3)
print(*tuple1)
list1 = ['aa', 'bb', 'cc']
a = list1[0]
 b = list1[1]
c = list1[2]
*list1 == a b c
print(*list1)

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

4.相关运算和列表一样

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

print((1, 2) + ('a', 'n'))
print((1, 2) * 3)
print(1 in (1, 2))
print(len((1, 2, 4)))
print(max((1, 89, 0)))
print(min((1, 89, 0)))

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

tuple2=(1,2,3,'34')
a,*b=tuple2
print(a)
print(b)

五、认识字典

1.什么是字典（dict）

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

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

键值对 -- 键：值
键(key) - 不可变的；唯一的 （一般使用字符串作为key）
值(value) - 任何类型的数据

dict1={'aa':100,10:'abc',(10,20):'hello'}
dict2={[1,2]:100,10:'abc',(10,20):'hello'} TypeError: unhashable type: 'list' 列表不能作为key
ict2={{1:100}:1,10:'abc',(10,20):'hello'}  TypeError: unhashable type: 'dict' 字典不能作为key
key是唯一的
dict2={'aa':100,'aa':1001,'bb':323}
print(dict2)#{'aa': 1001, 'bb': 323}
用一个变量储存一个学生的信息：姓名、年龄、电话、成绩、学号
student={'name':'小明','age':28,'tel':18282053064,'score':30,'学号':58}
print(student['name'])

什么时候使用字典：

如果一个容器里面存储的数据是不同意义的数据 - 数据之间需要区分

六、字典的增删改查

1.查（获取字典的值）

a.获取单个值
字典[key] - 获取字典中key对应的值(如果key不存在会发生异常) key确定使用此法
字典.get（key） - 获取字典中key对应的值(如果key不存在不会报错，并且会返回一个默认值None)

None是python中的关键字，表示一个特殊值（没有或者空）

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

b.遍历

直接遍历字典拿到的是字典中所有的key值

dog1={'name':'旺财','age':3,'color':'黄色','type':'土狗'}
for x in dog1:
    print(x)

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

2.增（添加键值对）

字典[key] = 值 - 当key不存在的时候，就是在字典中添加键值对
dict1={'a':100}
dict1['b']=233
print(dict1){'a': 100, 'b': 233}

字典1.update(序列) - 将序列中的元素转化成键值对然后再添加到字典1中
注：在这儿的序列要求是能够转换成字典的序列，并且序列中的元素是只有两个元素的小序列

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

dict1={'a':100,'b': 233}
dict1.update({'aa':22,'bb':24,'a':222})
print(dict1)#{'a': 222, 'b': 233, 'aa': 22, 'bb': 24}

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

字典[key] = 值 - 当key存在的时候就是修改key对应的值
dict1={'a':10,'b':20}
dict1['a']=100
print(dict1) #{'a': 100, 'b': 20}

4,删（删除键对）

a.del 字典[key] - 删除字典中key对应的键对
person={'name':'张三','age':18,'sex': '男'}
del person['sex']
print(person)  {'name': '张三', 'age': 18}

b.字典.pop() - 取出字典中key对应的值
person={'name':'张三','age':18,'sex': '男'}
age=person.pop('age')
print(person,age) {'name': '张三', 'sex': '男'} 18
删除最后一个键值对（取出最后一个键值对，以元祖形式返回） 描述是随机删除因为字典是无序的
person={'name':'张三','age':18,'sex': '男'}
a=person.popitem()
print(a)     ('sex', '男')

七、字典的相关运算和方法

1.字典不支持+和*

1.in 和 not in
dict1={'a':1,'b':2,'c':3}
print('a' in dict1)

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