python基础知识--3列表元组字典集合

1.列表list()

空列表[ ]

创建只有一个元素的列表

[1,]

创建含有不同数据类型的列表

['a',1,3.14,[1,2,3,4]]

列表基本操作-列表相加相乘操作

[1,2] + [3.4]

[1, 2, 3.4]

# 不支持列表之间的相减操作

[1,2] * 5

[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]

[1,2] / [3,4] # 不支持列表之间的相除操作

# list.count (x)
# 统计列表中x出现的次数，若不存在则返回0

x = [1,2,3,4,2]

x.count(5)
0

# list.append(x)
# 向列表尾部追加成员x

a = [1,2,3]

a.append(4)
print(a)

[1, 2, 3, 4]

# list.extend(l)
# 向列表尾部追加另外一个列表

b = [4,5,6]

b.extend([7,8,9])
print([4, 5, 6, 7, 8, 9])

# list.index(x)
# 返回参数x在列表中的序号，若不存在则报错

c = [7,8,9]

print(c.index(8))

运行结果：1


# list.insert(index,object)
# 向列表指定位置插入数据x

d = ['a','b','c']

d.insert(2,'d')
d

['a', 'b', 'd', 'c']

# list.pop()
# 默认删除列表尾部成员，并返回删除的成员x

e = [10,11,12,13]

e.pop()

13

[10, 11, 12]

# list.remove(x)
# 删除列表中指定成员（有多个则只删除第一个），若指定成员不存在则报错

f = [14,15,16,14,15]

f.remove(14)
print(f)

运行结果：[15, 16, 14, 15]

# list.reverse()
# 将列表中的成员顺序颠倒

 

g = [17,10,20]

g.reverse()
print(g)

[20, 10, 17]

# list.sort()
# 将列表中的成员排序（要求成员间可排序，否则报错）

h = [21,30,23]

h.sort()
h

[21, 23, 30]

元组

tuple()

# 元组的元素一旦创建，是不可变的。
# 元组的元素不可变，但当元组元素为列表或字典数据类型时，列表或字典内的内容是可以变的。

创建只有一个元素的元组

(1,)

访问元组元素

a = (1,2,3)

a[0]
1

元组元素为列表或字典数据类型时，列表或字典内的内容是可以变的。

b = (1,2,3,[4,5,6])

 

b[3][0] = 10

 b

(1, 2, 3, [10, 5, 6])

元组常见函数

c = (1,2,5,8,9)

len(c)
5

max(c)
9

min(c)
1


字典Dict
大括号{}
# 基本格式：大括号 { } 包围的数据集合，通过键访问成员，而不能通过序号位置。

# 字典，是Python中比较常用的数据类型，每个成员以键值对的形式存在。

创建一个简单字典

fruits = {"lemon":5,"apple":10}

fruits['lemon']
5

更新字典成员

fruits = {"lemon":5,"apple":10}

fruits['lemon'] = 20

fruits

{'lemon': 20, 'apple': 10}

fruits['pear'] = 15

fruits

{'lemon': 20, 'apple': 10, 'pear': 15}

字典删除操作

del fruits['pear']

fruits

{'lemon': 20, 'apple': 10}

fruits.clear()

fruits
{}

（一）字典的键是不可变的，值可以为任何数据类型。

键的数据类型，可以为字符串、数字和元组不可变数据类型，不能为列表类型

（二）字典的键最好唯一。

创建时如果同一个键被赋值多次，最后一个值会被记住。

fruits = {'lemon':1,'lemon':10,'lemon':20,'apple':10,'apple':5,'pear':6}

fruits

{'lemon': 20, 'apple': 5, 'pear': 6}

复制字典

# dict.copy()

fruit1 = {'lemon':5,'apple':10}

fruit2 = fruit1.copy()

print(fruit2)

{'lemon': 5, 'apple': 10}

获取字典的健

# dict.get(key,default=None)
# 获取key对应的值，若key不存在则返回default

fruit1 = {'lemon':5,'apple':10}

fruit1.get('pear','该键不存在')

'该键不存在'

字典的迭代

# dict.items()  获取由键和值组成的迭代器
# dict.keys()   获取键的迭代器
# dict.values() 获取值的迭代器

fruit1 = {'lemon':5,'apple':10}

fruit1.items()

fruit1.keys()

dict_keys(['lemon', 'apple'])

fruit1.values()

dict_values([5, 10])

删除字典成员

# dict.pop(key,[default])
# 删除key:value的指定成员对。若key不存在，则返回default

fruit1 = {'lemon':5,'apple':10,'pear':20}

fruit1.pop('lemon')
5

# dict.popitem()
# 从字典末尾删除key:value，并返回key:value

fruit1 = {'lemon':5,'apple':10,'pear':20}

fruit1.popitem()

('pear', 20)

更新字典成员

# dict.update({key:value})  从另外一个字典更新成员（若不存在就创建，存在则覆盖）

fruit1 = {'lemon':5,'apple':10,'pear':20}

fruit1.update({'lemon':10})

fruit1

{'lemon': 10, 'apple': 10, 'pear': 20}

设置字典默认值

# dict.setdefault(key,default=None) 
# 若字典存在key，则返回对应的值（不会覆盖原值）。若不存在，则建立一个key:default的字典成员

集合set

集合（set）是一个无序的，不重复的数据集合

set()

# 注意：创建一个空集合必须用 set() 而不是 {}，因为 {} 是用来创建一个空字典。

集合特点--无序的

无法通过序号访问

集合特点--唯一性

b = {1,1,3,3,2,2,4,4}

b

{1, 2, 3, 4}

集合常见操作

1.len() 求出集合长度

a = {1,2,3,4,5,6}

b = {3,4}

len(a)
6

2.判断元素是否在集合中

7 in a

False

3.求出集合间的差集

a - b

{1, 2, 5, 6}

4.求出集合间的交集

a & b

{3, 4}

5.求出集合间的并集

a | b

{1, 2, 3, 4, 5, 6}