3.列表的常见操作

在列表中增加元素

在列表中增加元素的方式有多种，具体如下：

• 通过append可以向列表末尾添加元素

• 通过extend可以将另一个列表的元素添加到列表末尾。

• 通过insert在指定位置(index)前插入元素(object)。

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
namesList.append('xiaoLiu')
print(namesList)
namesList2 = ['ximen','xiahou']
namesList.extend(namesList2)
print(namesList)
namesList.insert(2,'huangfu')
print(namesList)

在列表中查找元素

在列表中查找元素的方法包括：

• in（存在）,如果存在那么结果为true，否则为false。

• not in（不存在），如果不存在那么结果为true，否则false。

namesList = ['xiaoWang','xiaoZhang','xiaoHua']
print('xiaowang' in namesList)
print('xiaowang' not in namesList)

在列表中修改元素

列表元素的修改，是通过下标来实现的。

nameList = ['xiaoWang','xiaoZhang','xiaoHua']
nameList[1] = 'xiaoLu'
print(nameList)

在列表中删除元素

列表元素的常用删除方法有三种，具体如下：

• del：根据下标进行删除(例：del l[0])

• pop：根据索引移除元素，不指定参数则删除最后一个元素(例：l.pop())

• remove：根据元素的值进行删除（例：l.remove('xiaoWang')）

• clear：清空列表（例：l.clear()）

l = ['xiaoWang','xiaoZhang','xiaoHua']
l.remove('xiaoWang')
print(l)
l.pop()
print(l)
del l[0]
print(l)

列表的排序操作

列表的排序可以通过下面两个方法实现：

• sort方法：列表的元素按照特定顺序排列，默认为从小到大。

注：l.sort()后，已经改变了l的排序，reverse参数可选

• reverse方法：将列表逆置。

numList = [0,4,7,2]
numList.sort()
print(numList)
numList.sort(reverse=True)
print(numList)
numList.reverse()
print(numList)

列表的运算符操作

• +：将两个列表中的元素合并在一起产生一个新的列表(相当于extend函数)

例：
print([1, 2, 3] + ['a', 'b', 'c'])
# [1, 2, 3, 'a', 'b', 'c']

• *：将列表中的元素重复N次，产生一个新的列表

例：
print([1, 2, 3] * 3)
# [1, 2, 3, 1, 2, 3, 1, 2, 3]

• ==，<，>：比较运算符与字符串比较大小相似

例：
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(list1 == list2) # True
print(list1 == [1, 3, 2]) # False（顺序不对）

• in 和 not in：判断列表中是否存在指定的元素

例：
print(1 in [1, 2, 3]) #True
print([1, 2] in [1, 2, 3]) # False

列表生成式

生成列表的公式

[ 表示列表元素的表达式 for 自定义变量 in 可迭代对象 ]
注：表示列表元素的表达式通常包含自定义变量

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

例：

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

4.列表的嵌套

列表的嵌套指的是一个列表的元素又是一个列表。

schoolNames = [['北京大学','清华大学'],
              ['南开大学','天津大学','天津师范大学'],
              ['山东大学','中国海洋大学']]

二、元组

元组概述

Python的元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

写法1：
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )
写法2：（不建议）
tup3 = "a", "b", "c", "d"

元组使用规则:

1. 使用圆括号()表示开始和结束。

2. 不同元素以逗号分隔。

3. 每个元素的排列是有序号的，元素相同但排列不同的元组属于不同的元组。

元组的相关操作

1. 访问元组

元组可以使用下标索引来访问元组中的值

tuple=('hello',100,4.5)
print(tuple[0])
print(tuple[1])
print(tuple[2])

2. 元组不允许修改元组

tup1 = (12, 34.56)
# 以下修改元组元素操作是非法的。
tup1[0] = 100

什么时候使用元组而不用列表呢？
例：定义某些不变量，比如黄色的三原色组成：
yellow = (255,0,255)#(粉色对应rgb(255,0,255)，rgb为红绿蓝)

为什么要将元组设计成不可变序列?
在多任务环境下，同时操作对象时不需要加锁。

注意事项：
如果元组本身是不可变对象，则不能再引用其他对象。
如果元组中的对象是可变对象，则可变对象的引用不允许修改，但数据可以改变。

3. 元组的遍历

for循环：

a_tuple = (1, 2, 3, 4, 5)
for num in a_tuple:
     print(num,end=" ") #end指定结尾符，默认回车

while循环：

a_tuple = (1, 2, 3, 4, 5)
i = 0
while i < len(a_tuple):
    print(a_tuple[i],end=" ")
    i += 1

4. 元组的内置函数

    方法                             描述
 len(tuple)            计算元组元素个数(同样适用于列表、字典、集合)
 max(tuple)            返回元组中元素最大值(同样适用于列表、字典、集合)
 min(tuple)            返回元组中元素最小值(同样适用于列表、字典、集合)
 tuple(seq)            将列表转为元组

元组的运算符操作

• +：将两个元组中的元素合并在一起产生一个新的元组。(和列表相同)

• *：将元组中的元素重复N次，产生一个新的元组

print((1, 2, 3) + (4, 5, 6))
print((1, 2, 3) * 3)
#(1, 2, 3, 4, 5, 6)
# (1, 2, 3, 1, 2, 3, 1, 2, 3)

三、字典

字典介绍

字典是一种存储数据的容器，它和列表一样，都可以存储多个数据。

 info = {'name':'张三', 'sex':'f', 'address':'北京'}

每个元素都是由两部分组成的，分别是键(key)和值(value)；‘name’为键，‘张三’为值。

字典概述

字典使用规则:

1. 使用花括号{}表示开始和结束，并且每个元素是以key:value方式成对出现。

2. 不同元素以逗号分隔。

3. 每个元素的排列是无序的，元素相同但排列不同的字典属于相同的字典。

例：

a = {'姓名':'kumisan','年龄':'17',}
print(a)
print(type(a))
b = dict(姓名='kumisan',age=17) # 使用内置函数dict()
print(b)
print(type(b))

字典的常见操作

1. 根据键访问值

info = {'name':'班长', 'id':100, 'sex':'f', 'address':'北京'}
print(info['name'])
print(info['address'])

注意：如果使用的是不存在的键，则程序会报错。

如果我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值。

info = {'name':'班长', 'id':100, 'sex':'f', 'address':'北京'}
age = info.get('name')
print(age)
age = info.get('age')
print(age) #'age'键不存在，所以age为None
age = info.get('age', 18) # 若info不存在'age'，返回默认值18
print(age)
age = info.get('age', '索引不存在')
print(age)

2. 修改字典的元素

info = {'name':'班长', 'id':100, 'sex':'f', 'address':'北京'}
print(info)
newId = input('请输入新的id')
info['id'] = int(newId)
print('修改之后的id为：%d'  % info['id'])
print(info)

3. 添加新的字典元素

添加方法一：

info = {'name':'班长', 'id':100,'sex':'f', 'address':'北京'}
newId = input('请输入电话')
info['phone'] = newId
print(info)

添加方法二：使用update方法添加

info = {'name':'班长', 'id':100,'sex':'f', 'address':'北京'}
phone_dic = {'phone':'18812345678'}
info.update(phone_dic)
print(info)

4. 删除字典元素

• del：可删除字典中元素或者删除字典；删除字典后，字典完全不存在了，无法再根据键访问字典的值。del info['sex'], del info

• pop：删除元素并返回value值。info.pop('sex')

• clear：只是清空字典中的数据，字典还存在，只不过没有元素。 info.clear()

5. 计算字典中键值对的个数

dicts = {'Name': 'Zara', 'Age': 7}
print("Length : %d" % len (dicts))

6. 获取字典中键的列表

keys()方法返回在字典中的所有可用的键，可通过list(dict.keys())方式转换为列表。

dicts = {'Name': 'Zara', 'Age': 7}
print(dicts.keys())
print(list(dicts.keys())) #可转换为list类型

7. 获取字典中值的列表

values()方法返回在字典中的所有可用的值，同样可通过list()转化为列表。

dicts = {'Name': 'Zara', 'Age': 7}
print(dicts.values())
print(list(dicts.values()))#可转换为list类型

8. 计算字典中键值对的个数

items()方法返回字典的(键，值)元组对的列表。

dicts= {'Name': 'Zara', 'Age': 7}
print("Value : %s" %  dicts.items())
print(type(list( dicts.items() )[0])) # 查看第0个item的类型

字典的遍历

1. 遍历字典的键key（直接遍历，不必转换为list）

dicts = {'Name': 'Zara', 'Age': 7}
for key in dicts.keys():
    print(key)

2. 遍历字典的值value（不必转换为list）

dicts = {'Name': 'Zara', 'Age': 7}
for value in dicts.values():
    print(value)

3. 遍历字典的元素

dicts = {'Name': 'Zara', 'Age': 7}
for item in dicts.items():
     print(item)

4. 遍历字典的键值对

dicts = {'Name': 'Zara', 'Age': 7}
for key,value in dicts.items():
	print("key=%s，value=%s" % (key,value))

字典的特点

• 字典中的所有元素都是一个键值对，key不允许重复，value可以重复。
• 字典中的元素是无序的。
• 字典中的key必须是不可变的对象。
• 字典也可以根据需要动态地伸缩。
• 字典会浪费较大的内存，是一种使用空间转时间的数据结构。

四、集合

集合介绍

集合（set）是一个无序的不重复元素序列。对应于数学中集合的概念。

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
letters = set(['apple', 'orange', 'apple', 'pear', 'orange', 'banana'])

可以使用大括号 { } 或者 set() 函数创建集合。

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

集合概述

集合使用规则:

1. 使用花括号{}表示开始和结束，并且每个元素是以单个元素方式出现。

2. 不同元素以逗号分隔。

3. 每个元素的排列是无序的，元素相同但排列不同的集合属于相同的集合。

4. 集合中若有重复元素，会自动删除重复值，不会报错。

集合的常见操作

添加元素

add()方法：

thisset = {"Google", "Runoob", "Taobao"}
thisset.add("Facebook")
print(thisset)

合并

update()方法：

thisset = {"Google", "Runoob", "Taobao"}
newset = {'HUAWEI','Alibaba'}
thisset.update(newset)
print(thisset)

删除元素

• 调用remove()方法，一次删除一个指定元素，

• 调用discard()方法，一次删除一个指定元素

• 调用clear()方法，清空集合

thisset = {"Runoob", "Taobao"}
thisset.remove("Google") #删除没有的元素会报错
print(thisset)
thisset.discard("Google")#删除没有的元素不会报错
print(thisset)
thisset.clear()

随机删除

pop()方法：

thisset = {"Google", "Runoob", "Taobao"}
print(thisset) #可以发现每次输出的元素顺序不同
print(thisset.pop())
# 实际每次删除的是前边第一个元素，而集合的排列每次是随机的，所以相当于随机删除一个元素

集合的交、并、差、交叉补集

1. 集合的交集

s1 & s2 ，s1.intersection(s2)

2. 集合的并集

s1 | s2 ，s1.union(s2)

3. 集合的差集

s1 - s2 , s1.difference(s2)

从集合s1里去掉和s2交集的部分

4. 集合的交叉补集

s1 ^ s2 , s1.symmetric_difference(s2)

从s1和s2并集里去掉交集的部分

注：使用函数不改变原集合

• S - T 返回一个新集合，包括在集合S但不在T中的元素

• S ^ T 返回一个新集合， 包括集合S和T中不相同元素

• S <= T 或 S < T 返回True/False， 判断S是否为T的子集、真子集。（如果A包含B,且A不等于B,就说集合B是集合A的真子集）

• S >= T 或 S > T 返回True/False， 判断S是否包含子集T、真子集T。

五、列表、元组、字典、集合对比

列表、元组、字典、集合对比

zip函数

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组。

1. 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

2. 利用 * 号操作符，可以将元组解压为列表。

a, b, c = [1,2,3], [4,5,6], [4,5,6,7,8]
zipped = list(zip(a,b))     # 打包为元组的列表
>>>[(1, 4), (2, 5), (3, 6)]
list(zip(a,c))              # 元素个数与最短的列表一致
>>>[(1, 4), (2, 5), (3, 6)]
zipped = zip(a,c)
print(*zipped)
>>>(1, 4) (2, 5) (3, 6)

结尾

不要让追求之舟停泊在幻想的港湾，而应扬起奋斗的风帆，驶向现实生活的大海。