【Python | 列表、元组、字典、集合的学习】

文章目录

• 一、列表
• • 1. 列表的查看
  • • (1). 索引
    • (2). 切片
  • 2. 列表的添加
  • • (1). append
    • (2). insert
    • (3). extend
    • (4). +
  • 3. 列表的删除
  • • (1). pop
    • (2). remove
    • (3). del
    • (4). clear
  • 4. 列表的修改
  • • (1). 索引修改
    • (2). 切片修改
    • (?)思考alist.clear和alist = []的区别（查看id号，内存地址的区别）
    • (3). 反转
    • (4). 排序
  • 5. 统计
  • • (1). len
    • (2). count
    • (3). index
  • 6. 成员关系
  • 7. 列表转化
• 二、元组
• • 1. 元组的查看
  • • (1). 索引、切片
  • 2. 元组的统计
  • • (1). len
    • (2). count
    • (3). index
  • 3. 元组嵌套列表
  • 4. 元组转为列表
• 三、字典
• • 1. 字典的去重特性
  • 2. 字典的查找
  • 3. 字典的添加
  • • (1). 新增
    • (2). update
    • (3). dict()函数
  • 4. 字典的删除
  • • (1). pop('key')
    • (2). popitem()
  • 5. 字典的成员关系
  • 6. 字典遍历
• 四、集合
• • 1. 集合的添加
  • • (1). 新增一个元素
    • (2). 新增多个元素
  • 2. 集合的删除
  • • (1). remove
    • (2). discard
  • 3. 集合的基本操作
  • • (1). 并集
    • (2). 交集
  • print(s & t) print(s.intersection(t))
• 五、总结

---

一、列表

mylist = ['apple', 'orange', 123, 0.1111, 1, 2, 3, 4, 5]

• 是可变的
• 是有序的
• 可以放任意类型数据
  内存中存储方式：

• 长度问题：定义了一个列表10个元素，那么此列表长度应该是15或20个
  因为列表可变，所以会有备用空间

1. 列表的查看 (1). 索引

• 注意：索引值(下标)不能超出界限，不然就会报错。

mylist = [1, 'a', 1.1, None, [1,2], False]
print(mylist[3])

None

print(mylist[-3])

None

print(mylist[10])

索引越界 => IndexError
IndexError: list index out of range

(2). 切片

• 没有下标越界问题 => 不会有越界的报错
• 前闭后开 => mylist[startstep]

mylist = ['Hello', 'zoey', 'Today', 'is', 'Sunday']
print(mylist[1::-1])

[‘zoey’, ‘Hello’]

print(mylist[-4::-1])

[‘zoey’, ‘Hello’]

a = ['apple', 'orange', 123, 0.111, 'zoey']
print(a[1:])

[‘orange’, 123, 0.111, ‘zoey’]

print(a[2:6])

[123, 0.111, ‘zoey’] => 此处就没有下标越界问题

• slice切片
  slice(start, stop[, step])

sub_list = slice(-4,0,-1)
print(mylist[sub_list])

[‘zoey’]

2. 列表的添加 (1). append

• 在列表末尾追加一个元素

1. 添加单个元素

mylist = [0, 1, 2, 3]
mylist.append("apple")
print(mylist)

[0, 1, 2, 3, ‘apple’]

2. 添加一整个列表

mylist.append([4,5])
print(mylist)

[0, 1, 2, 3, ‘apple’, [4, 5]]

(2). insert

• 在index的位置插入数据，2个参数（索引，插入的元素）

mylist.insert(0, "banana")
print(mylist)

[‘banana’, 0, 1, 2, 3, ‘apple’, [4, 5]]

mylist.insert(2, "orange")
print(mylist)

[‘banana’, 0, ‘orange’, 1, 2, 3, ‘apple’, [4, 5]]

(3). extend

• 扩展：将可迭代对象在列表末尾添加
• 改变了原来的列表

mylist2 = ["zoey", "wangjunkai", "xiaozhan"]
mylist.extend(mylist2)
print(mylist)

[‘banana’, 0, ‘orange’, 1, 2, 3, ‘apple’, [4, 5], ‘zoey’, ‘wangjunkai’, ‘xiaozhan’]

mylist.extend(12)

TypeError: ‘int’ object is not iterable => int是不可迭代对象
简单理解：迭代 => 可以依次从对象中取出元素

(4). +

• +两边的数据类型要一致（相同）
• 不是在原列表上添加，而是产生了一个新的列表

mylist3 = ['wangyuan', 'boys']
print(mylist+mylist3)

[‘banana’, 0, ‘orange’, 1, 2, 3, ‘apple’, [4, 5], ‘zoey’, ‘wangjunkai’, ‘xiaozhan’, ‘wangyuan’, ‘boys’]

print(mylist)

[‘banana’, 0, ‘orange’, 1, 2, 3, ‘apple’, [4, 5], ‘zoey’, ‘wangjunkai’, ‘xiaozhan’]

[1, 2, 3] + 'ab'

TypeError: can only concatenate list (not “str”) to list
不可以合并，因为两边数据类型不一样

3. 列表的删除 (1). pop

• 删除指定位置的一个元素，默认删除列表最后一个元素
• 会返回删除的数据，返回值：当前删除的元素

mylist.pop()

‘xiaozhan’

mylist.pop(7)

[4, 5]

(2). remove

• 删除指定元素内容的元素
• 返回值：None

mylist.remove(1)
print(mylist)

[‘banana’, 0, ‘orange’, 2, 3, ‘apple’, [4, 5], ‘zoey’, ‘wangjunkai’, ‘xiaozhan’]

(3). del

• 通用的删除 => 不会有返回值

del mylist[1]
print(mylist)

[‘banana’, ‘orange’, 2, 3, ‘apple’, [4, 5], ‘zoey’, ‘wangjunkai’, ‘xiaozhan’]

(4). clear

• 全部清除

print(mylist3)

[‘wangyuan’, ‘boys’]

mylist3.clear()
print(mylist3)

[]

4. 列表的修改 (1). 索引修改

print(mylist)

[‘banana’, ‘orange’, 2, 3, ‘apple’, [4, 5], ‘zoey’, ‘wangjunkai’, ‘xiaozhan’]

mylist[2] = "liu"
print(mylist)

[‘banana’, 0, ‘liu’, 2, 3, ‘apple’, [4, 5], ‘zoey’, ‘wangjunkai’, ‘xiaozhan’]

(2). 切片修改

mylist[3:5] = ["karry", "roy"]
print(mylist)

[‘banana’, 0, ‘liu’, ‘karry’, ‘roy’, ‘apple’, [4, 5], ‘zoey’, ‘wangjunkai’, ‘xiaozhan’]

mylist[-1:] = ["mashan", "zhouzheng", "machao"]
print(mylist)

[‘banana’, 0, ‘liu’, ‘karry’, ‘roy’, ‘apple’, [4, 5], ‘zoey’, ‘wangjunkai’, ‘mashan’, ‘zhouzheng’, ‘machao’]

---

• 批量指定下标的删除数据

mylist[0:5]=""
print(mylist)

[‘apple’, [4, 5], ‘zoey’, ‘wangjunkai’, ‘mashan’, ‘zhouzheng’, ‘machao’]

mylist[0:5]=[]
print(mylist)

[‘zhouzheng’, ‘machao’]

---

• 批量在指定位置增加数据

print(mylist[1:1])

[]

mylist[1:1]="abc"
print(mylist)

[‘zhouzheng’, ‘a’, ‘b’, ‘c’, ‘machao’]

(?)思考alist.clear和alist = []的区别（查看id号，内存地址的区别）

(3). 反转

• mylist.reverse() 的效果 = mylist[::-1]
• 操作mylist对象

(4). 排序

• 列表中的元素必须是相同类型的才能排序
• 默认升序
• mylist.sort()

5. 统计 (1). len

print(mylist)
print(len(mylist))

[‘zhouzheng’, ‘a’, ‘b’, ‘c’, ‘machao’]
5

(2). count

print(mylist5)

[‘a’, ‘b’, ‘c’, ‘d’, ‘a’, ‘b’, ‘d’, ‘java’, [‘liu’, ‘cali’, 123, 456], ‘C’, ‘a’]

mylist5.count('a')

3

(3). index

• 返回:第一个出现的元素的下表位置

mylist5.index("java")

7

6. 成员关系

• in, not in

print(mylist5)

[‘a’, ‘b’, ‘c’, ‘d’, ‘a’, ‘b’, ‘d’, ‘java’, [‘liu’, ‘cali’, 123, 456], ‘C’, ‘a’]

print("Java" in mylist5)
print("java" in mylist5)

False
True

7. 列表转化

1. 字符串转为列表

mystr = "abc"
print(list(mystr))

[‘a’, ‘b’, ‘c’]

2. 列表转为字符串
   拼接 => string.join(iterable)

3. 列表转为元组

print(tuple(mylist5))

(‘a’, ‘b’, ‘c’, ‘d’, ‘a’, ‘b’, ‘d’, ‘java’, [‘liu’, ‘cali’, 123, 456], ‘C’, ‘a’)

二、元组

mytuple = (1, 2, 3, 4, 5)
mytup = (1,)  # 当元组只有一个元素时，最后要加逗号

• 是不可变的
• 是有序的
• 可以放任何数据类型

1. 元组的查看 (1). 索引、切片

mytup = (1, 2, 3, 4, 5)
print(mytup[1:4])

(2, 3, 4)

不可修改

mytup[0] = "a"

TypeError: ‘tuple’ object does not support item assignment

2. 元组的统计 (1). len (2). count (3). index 3. 元组嵌套列表

mytup = (1, 2, [3, 4, 5])
mytup[0]="a"

TypeError: ‘tuple’ object does not support item assignment

mytup2 = [1, 2, (3, 4, 5)]
mytup2[2][0]="a"

TypeError: ‘tuple’ object does not support item assignment

mytup2 = [1, 2, (3, 4, 5)]
mytup2[2] = "a"
print(mytup2)

[1, 2, ‘a’]

mytup[2][0] = "a" 
print(mytup)

(1, 2, [‘a’, 4, 5])

• 元组元素的存储方式：存储地址

print(id(mytup))

2156592232320

print(id(mytup[2]))

2156593431936

4. 元组转为列表

print(list(mytup))

[1, 2, [‘a’, 4, 5]]

三、字典

mydict = {
    "key": "value",
    0: "value",
    None: "value",
    (1,2): "value",
    # [1,2]: "value"
    "key": [1, 2, 3],
    "key": {"key":"value", "key2":"value"}
}

• 是可变的
• 是无序的
• key是唯一的，so天生去重
• 键值对: key => hashable 可哈希对象 => 不可变对象(可变对象 => list) => value可以是任意数据类型

1. 字典的去重特性

• 后面重复的key会覆盖前面的key

adict = {"ok":1, "a":2, "ok":3}
print(adict)

{‘ok’: 3, ‘a’: 2}

2. 字典的查找

取值：
通过key取值

1. mydic[‘key’]
2. mydic.get(‘key’) => mydic.get(‘key’,“nothing”)
   mydict.get(, [defalt])

songs_dict = {
    "孤勇者": {"singer":"陈奕迅", "count":"100"},
    "青花瓷": {"singer":"周杰伦", "count":"105"},
    "荷塘月色": {"singer":"凤凰传奇", "count":"99"}
}
song = input("请输入您要查询的歌曲1：")
print(f"{song}的播放量是：{songs_dict[song]['count']}")

简化：

songs = {
    '孤勇者': ['陈奕迅', 100],
    '青花瓷': ['周杰伦', 105],
    '荷塘月色': ['凤凰传奇', 99]
}
song = input("请输入您要查询的歌曲2：")
song["key"]
print(f"{song}的播放量是：{songs[song][-1]}")

3. 字典的添加 (1). 新增

新增一个key: mydict[‘key’] = ‘value’

songs["恰恰恰"]={}
print(songs)

{‘孤勇者’: [‘陈奕迅’, 100], ‘青花瓷’: [‘周杰伦’, 105], ‘荷塘月色’: [‘凤凰传奇’, 99], ‘恰恰恰’: {}}

(2). update

• mydic.update(mydic2)

songs.update({"key1":"value1", "key2":"value2"})
print(songs)

{‘孤勇者’: [‘陈奕迅’, 100], ‘青花瓷’: [‘周杰伦’, 105], ‘荷塘月色’: [‘凤凰传奇’, 99], ‘恰恰恰’: {}, ‘key1’: ‘value1’, ‘key2’: ‘value2’}

(3). dict()函数

• dict(mydic, **mydic2)

songs0 = {"key1":"value1", "key2":"value2"}
songs2 = dict(songs0, **songs)
print(songs2)
print(songs)

{‘key1’: ‘value1’, ‘key2’: ‘value2’, ‘孤勇者’: [‘陈奕迅’, 100], ‘青花瓷’: [‘周杰伦’, 105], ‘荷塘月色’: [‘凤凰传奇’, 99], ‘恰恰恰’: {}}

{‘孤勇者’: [‘陈奕迅’, 100], ‘青花瓷’: [‘周杰伦’, 105], ‘荷塘月色’: [‘凤凰传奇’, 99], ‘恰恰恰’: {}, ‘key1’: ‘value1’, ‘key2’: ‘value2’}
=> 可以看出字典的不重复性

4. 字典的删除 (1). pop(‘key’)

dicts.pop(key)
可以修改默认报错的返回值：songs.pop(“key”, default)

(2). popitem()

dicts.popitem() => last in, first out => 删除最后一个

5. 字典的成员关系

• in => 对字典来说比较的是key
  print(“青花瓷” in songs)
  True
• 也可以比较值：
  print(“value1” in songs.values())
  True

6. 字典遍历

遍历取的也是key
for key in songs:
print(key)

四、集合

myset = {'key1', 'key2'}

• 是可变的
• 是无序的
• 是不重复的
• 只包含key的字典 => key => 可hash对象 => 不可变对象

1. 集合的添加

myset = {‘key1’, ‘key2’}

(1). 新增一个元素

myset.add(‘key3’)

(2). 新增多个元素

myset.update(‘abc’)

2. 集合的删除 (1). remove

• remove => 删除不存在对象，会报错
  myset.remove(‘key’)

(2). discard

• discard => 如果key不存在，也不会报错
  myset.discard(‘key’)

3. 集合的基本操作 (1). 并集

s = set(‘hello’) # h,e,l,l,o
t = set(‘python’) # p,y,t,h,o,n
print(s | t)
print(s.union(t))

(2). 交集 print(s & t)
print(s.intersection(t)) 五、总结

提示：这里对文章进行总结：
本文对python四种基本容器数据类型进行了比较详细的介绍，把列表、元组、字典、集合他们在python中的特点列举出来，并列出了主要使用方法，以方便区分学习与使用。