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))
