列表、字典、元组、集合

列表 ArrayList [ ]

相当于java中的数组

实际上存储的是对象的引用的id

• 列表元素按照顺序有序排序
• 所有映射唯一数据
• 列表可以存储重复的数据
• 任意数据类型混存
• 根据需要动态的分配和回收内存

-5	-4	-3	-2	-1
'hello'	'world'	'hjz'	2123	2.15
0	1	2	3	4

**获取列表中指定元素的索引 ** index()

如果列表中有相同的元素的只返回列表中相同元素的第一个元素的索引

index(xx,start,stop) 可以在一个指定范围内查找[start,stop)元素xx

str=['hello','12',12]
print(str.index(12))

2

index(xxx,min,max) 从索引为[min,max)指定的范围内查找xxx

获得列表中的单个元素 list[i]

• 正向是 0 ---> i
• 负向是-N -------> -1

获取列表中的多个元素 列表名[start:stop:step]

• 切片的结果--------------->原列表的拷贝
• 切片的范围---------------->[start,step) start默认为0 stop默认到完
• step的默认的值：1------->简写为[start,step)
• step为正数
  • [:stop:step]------->切片的第一个元素默认是列表的第一个元素------从start开始往后计算
  • [start::step]-------->切片的最后一个元素默认是列表的最后一个元素----从start开始往后计算
• step为负数
  • [:stop:step]------->切片的第一个元素默认是列表的最后一个元素------从start开始往前计算
  • [start::step]-------->切片的最后一个元素默认是列表的第一个元素----从start开始往前计算

切出来的列表是新的列表对象

list[::-1] 将list列表逆序输出

判断是否元素是否存在于列表中

in ----------not in

list= [10,20,30,40,50,60,70,80,90]
print(10 in list)
print(100 not in list)

列表元素的增加操作

操作	说明
appen()	在列表的末尾添加一个元素
extend()	在列表的末尾至少添加一个元素
insert()	在列表的任意位置添加一个元素
切片	在列表的任意位置添加至少一个元素

是在列表的末尾增加新的对象的引用--id--->列表的id不变

例子：

append（）

a = list(['hello',10,20])
print(id(a))
b=['a','b']
a.append(b)
print(id(a),list(a))

2102562597184
2102562597184 ['hello', 10, 20, ['a', 'b']]

extend()

a = list(['hello',10,20])
print(id(a))
b=['a','b']
a.extend(b)
print(id(a),list(a))

2144167209280
2144167209280 ['hello', 10, 20, 'a', 'b']

insert()

a = list(['hello',10,20])
print(id(a))
b=['a','b']
a.insert(1,b)
print(id(a),list(a))

2460445321536
2460445321536 ['hello', ['a', 'b'], 10, 20]

切片

a = list(['hello',10,20])
print(id(a))
b=['a','b']
a[1::]=b
print(id(a),list(a))

2344228497728
2344228497728 ['hello', 'a', 'b']

列表元素的删除操作

方法	操作描述
remove（）	一次只删除一个元素、重复元素只删除第一个、元素不存在抛出异常
pop（）	删除一个指定索引位置上的元素、指定索引不存在抛出异常、不指定索引删除最后一个元素
切片操作	一次至少删除一个元素 会产生一个新的列表对象 相当于通过切片取出对应的元素
clear（）	清空列表
del	删除列表

切片操作

test=[10,20,30,40,20,10]
a = test[2:5]
print(list(test))
print(list(a))

[10, 20, 30, 40, 20, 10]
[30, 40, 20]

或者：

test=[10,20,30,40,20,10]
test[2:5]=[]
print(list(test))

[10, 20, 10]

列表元素的修改操作

• 为指定的元素赋予一个新值
• 未指定的切片赋予一个新值

列表的排序操作

• sort（）默认是从小到大进行升序，指定 reverse = True 进行降序排序
• sorted（）可以指定reverse =True 进行降序排序 原有的列表不发生改变

list=[2,50,12,1,50]
print(list,id(list))
list.sort(reverse=False)
print(list,id(list))

[2, 50, 12, 1, 50] 1998426716224
[1, 2, 12, 50, 50] 1998426716224

使用sorted（）

list=[2,50,12,1,50]
a=sorted(list,reverse=True)
print(list,id(list))
print(a,id(a))

[2, 50, 12, 1, 50] 2766636693568
[50, 50, 12, 2, 1] 2766639395712

列表生成式

语法格式：

a= [i for i in range(1,10)]

例子：

a= [i*i for i in range(1,10)]
print(a)

[1, 4, 9, 16, 25, 36, 49, 64, 81]

字典 HashMap { } 、 dict({....})

• 字典是python内置的数据结构之一，于列表一样是一个可变序列
• 以键值对的方式存储数据，字典是一个无序的序列

sorces = {'张三':100,'李四'：10,'王五':50}

hash(key)------->位置

字典的创建

• 最常用：
• 内置函数dict（key1:value,key2:'value2'........）

字典中获取数据

• [] -举例：scores['张三’]
  
  

• get（）方法 scores.get('张三')

区别：

• 使用【】如果字典中不存在指定的key会抛出异常， keyError
• 使用get不会抛异常而是会返回None，可以参数设置默认的value，一遍指定的key

a= {'张三':100,'李四':"hao",1:2}
print(a['张三'])
print(a.get(1))
print(a.get(99,'不存在'))

100
2
不存在

字典的常用操作

字典的判断操作

• in 指定的key在字典中存在返回True-------->'张三' in scores
• not in 指定的key在字典中不存在返回True ---------->'Marry' not in scores

字典的删除

del sorces['张三']

字典的新增操作

socres['jack']=90

清空指定的字典

socres.clear()

修改元素

socres['jack']=50

视图操作

• keys（） ：获取字典中所有的key
• values（）：获得字典中的所有的value
• items（）：获得字典中所有的key、value对

a= {'张三':100,'李四':"hao",1:2}
b= a.items()
c= a.values()
d=a.keys()
print(list(b))#转换之后的数据是由元祖组成的
print(list(c))
print(list(d))

[('张三', 100), ('李四', 'hao'), (1, 2)]
[100, 'hao', 2]
['张三', '李四', 1]

字典元素的遍历

a= {'张三':100,'李四':"hao",1:2}
for item in a:
    print(item,a[item],a.get(item))

张三 100 100
李四 hao hao
1 2 2

字典的特点：

• 字典的所有元素是key - value对，key不允许重复，value可以重复key值重复会出现值覆盖的情况
• 字典中的元素是无序的
• 字典中的key必学是不可变的对象
• 字典可以根据需要进行动态地收缩
• 字典会浪费较大的内存，是一种使用空间换时间的数据结构

字典生成式

key= ['aa','bb','cc']
value=[1,2,3]
d={item.upper():price  for item,price in zip(key,value)}
print(d)

{'AA': 1, 'BB': 2, 'CC': 3}

元组 () 、tuple((....))

• 元组是Python内置的数据结构之一，是一个不可变序列

不可变序列和可变序列的区别：

• 不可变序列是：字符串、元组
  • 不可变序列：没有增删改的操作
• 可变序列：列表、字典
  • 可变序列：可以对序列执行增删改查的操作，对象的地址不发生改变

元组的创建方式

• 直接（） ---可以省略小括号
• 使用内置函数 tuple('Python',90)

a=('python',1)
b=tuple(('python',12))
print(a,b)

('python', 1) ('python', 12)

元组中只有一个元素时，需要使用逗号和小括号

t=(10 ,)

为什么元组不可变

• 在多任务环境下，同时操作对象时不需要加锁
• 因此，在程序中尽量使用不可变序列

注意事项：

• 元组中存储的是对象的引用
• 如果元组中对象是不可变对象，则不能再引用其他对象
• 如果元组中的对象时可变对象，则可变对象的引用不允许改变，但数据可以改变

a = (10,[20,10],20)
print(a,type(a))
print(a[1])
a[1].append(7)
print(a)

(10, [20, 10], 20) <class 'tuple'>
[20, 10]
(10, [20, 10, 7], 20)

元组的遍历

• 通过索引
• for i in t：。。。。

a = (10,[20,10],20)
for e in a:
    print(e)

10
[20, 10]
20

集合 HashSet { }、set（{...}）

• Python语言提供的内置数据结构
• 与列表、字典一样都属于可变类型的序列
• 集合是没有value的字典

集合的创建方式

• 使用
• 使用内置函数set（）

集合中的元素不允许重复

集合中的元素是无序的

s=set(range(6))
ss=set([1,2,3,4,4,4])
sss=set((1,2,3,4))
ssss=set('python')
print(s,ss,sss,ssss)

{0, 1, 2, 3, 4, 5} {1, 2, 3, 4} {1, 2, 3, 4} {'p', 't', 'h', 'y', 'o', 'n'}

集合元素的判断操作

• in
• not in

s=set(range(6))
print(1 in s,55 not in s)

True True

集合的新增操作

• 调用add（）方法，一次添加一个元素
• 调用update（）方法至少添中一个元素

s= set(range(6))
print(s)
s.add(7)
print(s)
s.update([10,20,30])
print(s)
s.update({100,200,300})
print(s)

{0, 1, 2, 3, 4, 5}
{0, 1, 2, 3, 4, 5, 7}
{0, 1, 2, 3, 4, 5, 7, 10, 20, 30}
{0, 1, 2, 3, 4, 5, 100, 7, 200, 10, 300, 20, 30}

集合的删除操作

• 调用remove方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError
• 调用discard（）方法，一次删除一个指定的元素，如果指定元素不存在不抛出异常
• 调用pop（）方法，一次只删除一个任意元素
• 调用clear（）方法，清空集合

集合之间的关系

• 两个集合是否相等
  • 可以使用运算符==或！=进行判断
• 一个集合是否是另一个集合的子集
  • 可以调用方法issubset进行判断
  • B是A的子集
• 一个集合是否是另一个集合的超集
  • 可以调用方法issuperset进行判断
  • A是B的超集
• 俩个集合是否没有交集
  • 可以调用方法isdisjoint进行判断

例子：

判断相等

s1 = {10,20,30,40,50}
s2 ={50,20,10,30,40}
print(s1==s2,s1!=s2)

True False

元素相同即相等

判断子集

s1={10,20,30,40,50}
s2={10,20,60}
s3={10,20}
print(s1.issubset(s2),s2.issubset(s1),s3.issubset(s1))

False False True

判断父类集合

s1={10,20,30,40,50}
s2={10,20,60}
s3={10,20}
print(s1.issuperset(s2),s2.issuperset(s3))

False True

判断是否有交集

s1={10,20,30,40,50}
s2={10,20,60}
s3={10,20}
print(s1.isdisjoint(s2),s1.isdisjoint(s3))

False False

没有交集为True，有交集为Flase

集合的数据操作

• 交集 & intersection 两不变
• 并集 | union 两不变
• 差集 - difference 两不变
• 对称 ^ symmetrice_difference 去掉连交集的并集

集合生成式

语法格式：

a={i for i in range(1,10)}

例子：

a={i*i for i in range(1,10)}
print(a)

{1, 4, 9, 16, 25, 36, 49, 64, 81}