list

list可以存储任何数据类型的数据。
list是有序的，指的是添加元素和取出元素的顺序是一致的，即先进先出，后进后出

list列表声明的语法：

列表名=[值，值2，...值n]
列表中的每一个元素都对应一个索引
列表中的第一个元素的索引是：0
列表中的最后一个索引是：列表的长度-1

一般情况下一个容器中，尽量存放同一个类型的数据，方便后续操作

容器的学习:

1.C create

2.D delete

3.U update

4.S select  R reader

5.算法 排序

list常见的操作方法:

1.添加   
    列表 * num 
    列表.append(value) 功能:向列表的尾部添加指定的元素
    列表.insert(index,value) 功能:向列表中的指定位置 添加元素
    列表.extend(list) 功能:向列表的尾部 添加list中的所有元素

2.查询:

    value=列表[index] 功能:根据索引获取指定的值

    index=列表.index(value) 功能:获取列表中第一次出现指定值的索引 如果值不存在 则报出错误

    count=列表.count(value) 功能:统计列表中出现指定的值的次数

    length=len(列表) 功能:获取列表的长度

    max=max(列表) 功能:获取列表中最大值

    min=min(列表) 功能:获取列表中的最小值

3.修改

    列表[index]=value 功能:根据列表的索引 修改值

4.删除

    value=列表.pop() 功能:删除列表中最后一个元素 并返回此元素

    value=列表.pop(index) 功能:根据索引删除列表中的元素 并返回此元素

    del 列表[index] 功能:根据索引删除列表中的元素

    列表.remove(value) 功能:删除列表中第一次出现的值
            
            list1.clear()  功能：清空列表
 判断:
    in  如果存在返回True 否则返回False
    not in 如果不存在返回True 否则返回False
5. +   *
  + 列表之间表示组合
  list1 += [1000, 2000]
  * 重复元组元素
  list2 = ['hello'] * 5
6. 排序
   列表.reverse() 反转列表中的元素
   列表.sort() 列表排序
7.切片    
   # 可以通过完整切片操作来复制列表
   fruits3 = fruits[:]
   # 可以通过反向切片操作来获得倒转后的列表的拷贝
   fruits5 = fruits[::-1]
8. 生成列表
  用range创建数字列表   list(range(1,11))
  生成表达式  【】
  生成器 （）
9. COPY
  list.copy()

zip([iterable, ...])

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)] # [i for i in zip(a, b)]
>>> zip(a,c)              # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]

元组 tuple

元组是不可变类型
元组和列表非常相似
元组是用小括号 列表使用[]
元组的元素都一个索引
元组中第一个元素的索引是:0
元组中最后一个元素的索引:元组的长度-1
元组中也有内置函数:len(元组名) 来获取元组的长度

元组的声明:

元组名=(元素...元素)

元组声明的方式:

第一种方式: 有多个元素
           
    arr=(12,3,4,5)

第二种方式:没有包含元素的元组
            
    tup=()

第三种方式：声明一个包含元素的元组

    tup=(10)

元组中的元素是不能被删除的 但是可以通过del 元组名 删除整个元组

tup4=(2,3,5,7)
print(tup4)
del tup4 #元组中的元素是不能被删除的 但是可以通过del 元组名 删除整个元组   

第一种遍历方式 :根据索引

tupx=(11,22,33,44,55,66)
x=0
while x<len(tupx):
    print("索引:%s--->元素:%s"%(x,tupx[x]))
    x+=1
print("********************")

第二种方式: for in

for t in tupx:
    print(t)
print("********************")

第三种方式:for in range(元组名)

for f in range(len(tupx)):
    print("索引:%s--->元素:%s"%(f,tupx[f]))

print("********************")
for g,obj in enumerate(tupx):
    print("索引:%s--->元素:%s"%(g,obj))

求元组最值

max(元组名)
min(元组名)

用基础代码写最值

#声明一个元组
tup=(90,56,23,-12,88,345)
#把元组中的第一个元素看做是最大值
m=tup[0]
#把元组中的第一个元素看做是最小值
m2=tup[0]
#遍历元组
a=0
while a<len(tup):
    #求最大值
    if m<tup[a]:
        m=tup[a]
    #求最小值
    if m2>tup[a]:
        m2=tup[a]
    a+=1
print("元组中的最大值:%s"%m)
print("元组中的最小值:%s"%m2)

#换索引
tup2=(90,56,23,-12,88,345)
#把第一个元素的索引 看做是最大值对应的索引
maxIndex=0
#把第一个元素的索引 看做是最小值对应的索引
minIndex=0
#遍历元组
b=0
while b<len(tup2):
    #求最大值对应的索引
    if tup2[maxIndex]<tup2[b]:
        maxIndex=b
    #求最小值对应的索引
    if tup2[minIndex]>tup2[b]:
        minIndex=b
    b+=1
print("元组中的最大值:%s"%tup2[maxIndex])
print("元组中的最小值:%s"%tup2[minIndex])

列表元组转换

list()

1.把字符串分割成一个一个的字符 存储到新的列表中

2.把元组中的每个元素 存储到新的列表中

tuple()

1.把字符串分割成一个一个的字符 存储到新的元组中

2.把列表中的每个元素 存储到新的元组中

---

字典 dict

字典是以键值对的形式存储信息
字典中必须保证键的唯一型
字典中键重复 值覆盖
字典也称为双列集合

字典声明的语法:

字典名={'键':'值','键':'值',...'键':'值'}

字典常用的操作:

1.添加/修改

    字典[键]=值  如果字典中没有该键 就是添加

    如果字典中已经存在了该键 就是修改(覆盖)

2.删除:

    dict.pop(键)  根据键删除指定的键值对 如果键不存在则报出错误

    del dict[键] 根据键删除指定的键值对  如果键不存在则报出错误

    dict.popitem() 随机删除一个键值对

    dict.clear() 清空字典中所有的键值对

3.获取：

    value=字典[键]  根据键获取值 如果该字典中没有该键 则报出错误

    value=dict.get(键) 根据键获取值 如果字典中没有该键 则返回None

    len(字典) 功能:获取字典中 键值对的个数

    str(字典) 功能:把字典转换为字符串

    keys() 功能:获取字典中所有的键 返回的是一个列表

    values() 功能:获取字典中所有的值 返回的是一个列表

遍历字典第一种方式

map4={"1":"张三","2":"李四","3":"王五","4":"赵六","5":"田七","6":"孙八"}
for k in map4:
    #print(k)
    #v=map4[k]
    v=map4.get(k)
    print("key--->%s,--->value--->%s"%(k,v))

遍历字典第二种方式：获取所有的键

keyList=map4.keys()

for k2 in keyList:
    
    v2=map4.get(k2)
    print("key--->%s,--->value--->%s"%(k2,v2))

遍历字典第三种方式：获取所有的键值对

kyValue=map4.items()
for k3,v3 in kyValue:
    print("key--->%s,--->value--->%s"%(k3,v3))

id方法的返回值就是对象的内存地址

map5={"1":"张三","2":"李四","3":"王五","4":"赵六","5":"田七","6":"孙八"}
print(map5)
print(id(map5))
map6=map5.copy() 
print(map6)
print(id(map6))