Python语法——列表、元组、集合、字典

综述：

列表（List）    [         ]
是一种有序和可更改 的集合。允许重复的成员。
元组（Tuple） (        )
是一种有序且不可更改的集合。允许重复的成员。
集合（Set）     {        }
是一个无序和无索引的集合。没有重复的成员。
词典（Dictionary）{"key":"value"......}
是一个无序，有索引和可变的集合。没有重复的成员。

一、列表的相关操作

#创建列表
thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(thislist)

#访问
负索引表示从末尾开始，0 表示第一个项目，-1 表示倒数第一个项目，依此类推。
print(thislist[-1])  #结果是 mango

#len()方法   获取列表有多少项  print(len(thislist))
#count()方法 返回具有指定值的元素数量 变量=列表.count("元素")
#reverse()方法 反转元素的排序顺序 列表.reverse()
#sort()方法  默认情况下,对列表进行升序排序,还可以让函数来决定排序标准
list.sort(reverse=True/False, key=函数方法)
实例：
        def myFunc(e):
          return len(e)
        cars = ['Porsche', 'Audi', 'BMW', 'Volvo']
        cars.sort(key=myFunc)
        print(cars)
count()函数:统计了列表指定元素的个数
实例：
        >>> a = 'banana pie banana'
        >>> a.count('a',2)
        5
#列表的增
1. append()方法 将项目添加到列表的末尾 方法：列表.append("元素")
2. insert()方法 在指定的索引出添加项目 方法：列表.insert(索引位置,"元素")
3. extend()方法 指定的列表元素（或任何可迭代的元素）添加到当前列表的末尾 方法：目标列表.extende(后接的列表)
#列表的删
1. remove()方法 删除指定的元素 方法：列表.remove("元素") 删除列表第一个匹配项
2. pop()方法    删除指定的索引（如果未指定索引，则删除最后一项）方法：列表.pop(index)
3. del()方法    删除指定的索引 方法：del thinlist[index]
                删除完整的列表 方法：del 列表名
4. clear()方法  清空列表内容,保留列表格式 方法：列表名.clear()
#列表的改
 直接覆盖
#列表的查
if "apple" in thislist:
  print("Yes, 'apple' is in the fruits list")

二、元组的相关操作

#创建元组
thistuple = ("apple", "banana", "cherry")
print(thistuple)

#访问
返回第三、第四、第五个项目
thistuple = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(thistuple[2:5])  左闭右开
print(thistuple[-4:-1]) 左开右闭
#元组的增
#元组的删
#元组的改
    注意：
        创建元组后，您将无法更改其值。元组是不可变的，或者也称为恒定的。
        但是有一种解决方法。您可以将元组转换为列表，更改列表，然后将列表转换回元组。
    实例：
        x = ("apple", "banana", "cherry")
        y = list(x)
        y[1] = "kiwi"
        x = tuple(y)
        print(x)
#合并两个元组
实例：
    tuple1 = ("a", "b" , "c")
    tuple2 = (1, 2, 3)
    tuple3 = tuple1 + tuple2
    print(tuple3)

三、集合的相关操作

#创建集合
thisset = {"apple", "banana", "cherry"}
print(thisset)
#访问
    无法通过引用索引来访问 set 中的项目，因为 set 是无序的，项目没有索引。
    但是您可以使用 for 循环遍历 set 项目，或者使用 in 关键字查询集合中是否存在指定值。
#集合的增
1. add() 要将一个项添加到集合 方法：集合.add("元素")
2. update() 要向集合中添加多个项目 方法：集合.update(["orange", "mango", "grapes"])
实例：
    set1 = {"a", "b" , "c"}
    set2 = {1, 2, 3}
    set1.update(set2)
    print(set1)
3. union() 返回一个新集合，其中包含两个集合中的所有项目 
实例：
    set1 = {"a", "b" , "c"}
    set2 = {1, 2, 3}
    set3 = set1.union(set2)
    print(set3)
'''注意：union() 和 update() 都将排除任何重复项。'''

#集合的删
1. remove() 与列表一致            如果要删除的项目不存在 将引发错误
2. discard() 集合.discard("元素") 如果要删除的项目不存在 不会引发错误
3. pop() 与列表一致 但是注意：     集合是没有索引的，因此在使用该方法时，您不会知道删除的是哪个项目
4. del() 与列表一致
#集合的改
#集合的查
 1.for 循环遍历
 2.if xx in xx：

四、字典的相关操作

#字典的创建
thisdict =	{
  "brand": "Porsche",
  "model": "911",
  "year": 1963
}
print(thisdict)
#访问
    通过在方括号内引用其键名来访问字典的项目
    x = thisdict["model"]
    #打印所有键名
    for x in thisdict:
    	print(x)
    #打印所有值
    for x in thisdict:
  		print(thisdict[x])
    #打印键和值
    for x, y in thisdict.items():
  		print(x, y)
#字典的改
    直接覆盖
    thisdict["year"] = 2019
#字典的删
1. pop() 删除键和值 字典.pop("key")
2. popitem() 删除最后的键和值 字典.popitem()
3. del 关键字删除具有指定键名的项目 也可以完全删除字典
4. clear() 关键字清空字典

一、元组(tuple)：
1.定义：
t=（1，2，3）每个数据间用，隔开。当只有一个元素时，元素后加“，”。（不加会被当作int型）

2.下标：与字符串相同，t[2] 一个元素一个下标。

3.不允许被修改

4.切片：t[起始:终止:步长] 当步长为负数时，起始默认为-1。

5.内置函数：len（） type（） max（） min（） sum（） sorted() 排序

6.操作：

t = (1,2,3)
t.count("x")          #统计x出现的个数
t.index(5)            #第一次出现5的下标，即索引

7.遍历

for i in range(len(t)):
    print(i)
for t1 in t:
    print(t1)

二、列表（list）:
1.定义：[1,“a”,2] []中必须是9个类型中的一个。

2.下标：与字符串，元组相同

3.可以修改

4.切片：与字符串，元组相同

5.内置函数：type（），len（）,sorted（）,{max,min,sum(需要是同一类型)}

6.操作：

list = [1,2,3,4]
list.count()            # 统计个数
list.index()            #查找（“要查的内容”，起始，终止）
list.append("x")        #追加，在列表，末尾加上x.因为没有返回值，不能直接放在print（）里！
list.pop()              #删除最右侧的元素，并返回被删元素。
list.sort()             #排序  必须是同一类型，无返回值
s = list.copy()         #复制list的值给s（浅复制）
list.reverse()          #反转  无返回值
list.remove()           #删除，只能删除一个
list.remove(list[2])    #指定位置删除
list.insert()           #插入 （下标，“x”）  在下标处插入x
list.clear()            #清空
list.extend("123")      #将123加入list中[.......,"1","2","3"]
#list.extend(1,2,3)           [.......,1,2,3]
#list.extend[1,2,3]           [.......,1,2,3]

7.遍历：

for i in range(len(list)):
    print(i)
for s in list:
    print(s)

8.排序：冒泡排序，选择排序，插入排序，基数排序，快速排序，希尔排序，堆排序（大根堆和小根堆） 归并排序

冒泡排序

my_list = [8,6,1,7,4,0,6,2]
for i in range(len(my_list)):
    flag = False
    for j in range(len(my_list)-1-i):
        if my_list[j] > my_list[j+1]:
            flag = True
            my_list[j],my_list[j+1] = my_list[j+1],my_list[j]
if not flag:
    print(my_list)

三、字典（dict）：
1.定义：d={“age”:18,“name”:“张三”，“sex”:“男”}
键：key——value（值）

2.没有下标，可以通过键来获取值 如： d[“age”]

3.value可以修改

4.没有切片

5.内置函数：type（)，len(), sorted(),{max,min,sum(按照键比大小和排序)}

6.操作：

#     print(my_list)
d={"age":18,"name":"张三","sex":"男"}
d.copy()            #浅复制
d.clear()           #清楚
f=d.pop("x","y")    #删掉指定的键并返回x所对应的值，如果没有x，返回y
print(f)
d.get("x","y")      #获取x的值，若没有返回y
d.keys()            #取所有键，并返回成列表
d.items()           #取所有键和值返回成列表中带有元组的形式
d.update(age=88)    #将键age的value改为88，若没有age则在末尾加上“x”：y。   没有返回值

7.遍历：

for key,value in d.items():
    print(key,value)
for key in d.keys():    #对键循环
    print(key,d.get(key))
for valus in d.values():
    print(valus)

四、集合（set）：
1.定义：d={1，“a”，3014，False}

2.没有下标

3.修改: s.update(“b”)增加

4.没有切片

5.内置函数：type，len,sorted,max,min,sum(都是数字可以求和)

6.操作：

s = {1,"a",2,3.14,"s"}
ss = {1,"s",6,7.14,"k"}
s.pop()             #删除
s.remove(3.14)      #删除3.14
s.add(200)          #添加200
s.difference(ss)    #取s中ss不一样的元素，并返回一个新的集合
s.difference_update(ss)#返回s中与ss不一样的元素（删掉s中与ss的元素）

7.遍历：

for d in s:
    print(d)

一、列表、元组、集合、字典的区别

• 列表：长度可变有序的数据存储容器，可以通过下标索引取到相应的数据。
• 元组：固定长度不可变的顺序容器，访问效率高，适合存储一些常量数据，可以作为字典的键使用。
• 集合：无序，元素只出现一次，可以自动去重。
• 字典：长度可变的hash字典容器。存储的方式为键值对，可以通过相应的键获取相应的值。key支持多种类型，key必须是不可变类型且唯一。

列表和元组的主要区别如下：

• 列表上可以修改的，而元组不能修改。如果要增添和删除元素，只能用列表。元组被称为只读列表，即数据可以被查询，但不能被修改。若元组一旦被定义，长度和内容都是固定的，不能被修改，即不能对元组进行更新、增加和删除的操作。
• 列表用’[]'表示，元组用()表示
• 列表不能作为字典的可以，元组可以
• 如果元组中仅有一个元素，需要在元素后加上逗号。

二、for循环遍历列表、元组、字典和集合

1.遍历列表

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

print("遍历list：",end='')
for items in testList:
    print(items,end=' ')

2.遍历元组

print()
print("遍历tuple：",end='')
testTuple = (5,2,1,3,4)
for items in testTuple:
    print(items,end=' ')

3.遍历字典

print()
print("遍历dict：",end='')
testDict = {'a':1,'b':2}
for key,value in testDict.items():
    print(key,value,end=' ')

4.遍历集合

print()
print('遍历set：',end='')
testSet = {12,4,6,5}
for items in testSet:
    print(items,end=' ')

输出如下所示：

遍历list：4 2 3 1 4 
遍历tuple：5 2 1 3 4 
遍历dict：a 1 b 2 
遍历set：4 12 5 6

三、列表、元组、集合和字典相互转换

1.列表元组转化为集合（去重）

#两个列表转集合，去重
list1 = [6,7,7,8,8,9]
set1 = set(list1)
print(set1)

输出如下所示：

{8, 9, 6, 7}

2.两个列表转字典

#两个列表转字典
list1 = ["key1","key2","key3"]
list2 = ["1","2","3"]
dict1 = dict(zip(list1,list2))
print(dict1)

输出如下所示：

{'key1': '1', 'key2': '2', 'key3': '3'}

3.嵌套列表转字典

#嵌套列表转字典
list3 = [["key1","valu1"],["key2",'value2'],['key3','value3']]
dict1 = dict(list3)
print(dict1)

输出如下所示：

{'key1': 'valu1', 'key2': 'value2', 'key3': 'value3'}

4.列表、元组转字符串

#列表、元组转字符串
list1 = ['s','a','b']
str1 = " ".join(list1)
print(str1)

tup1 = ('b','t','u')
str2 = "-".join(tup1)
print(str2)

输出如下所示：

s a b
b-t-u

5.字典转化为字符串

dic1 = {'a':1,"b":2}
str1 = str(dic1)
print(type(str1))
print(str1)

输出如下所示：

<class 'str'>
{'a': 1, 'b': 2}

6.字典key和value互相转换

#字典key和value互相转换

dic2 = {"a":1,"b":2}

dic3 = {value:key for key,value in dic2.items()}
print(dic3)

输出如下所示：

{1: 'a', 2: 'b'}

7.字符串转换为列表

#字符串转换为列表
s = 'dstewsg'
list1 = list(s)
print(list1)

输出如下所示：

['d', 's', 't', 'e', 'w', 's', 'g']

8.字符串转元组

#字符串转元组
s = "ugjhaga;w"
tu1 = tuple(s)
print(tu1)

输出如下所示：

('u', 'g', 'j', 'h', 'a', 'g', 'a', ';', 'w')

9.字符串转集合

#字符串转集合
dic2 = eval("{'a':1,'age':2}")
print(dic2)

输出如下所示：

{'a': 1, 'age': 2}

10.切分字符串

#切分字符串
a = 'a b c'
a = a.split(' ')
print(a)

输出如下所示：

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

四、删除一个列表重复元素

1.使用集合set方式

#利用set中的元素不可重复性来去重
elements = ['a','b','e','c','b','d','a','c','f']

e = list(set(elements))
print(e)

输出如下所示：

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

要保持列表元素的原来顺序，可以利用list类的sort方法

#利用list的sort方法保持列表原来顺序
e.sort(key=elements.index)
print(e)

输出如下所示：

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

2.使用字典的方式，利用字典key的唯一性

#使用字典的方式
#利用了字典的键的唯一性
elements = ['a','b','e','c','b','d','a','c','f']
e = list({}.fromkeys(elements).keys())
print(e)

python函数dict.fromkey(seq,[,value])用于创建一个新字典以序列seq中元素做字典的键，value为字典所有键对应的初始值

#python函数dict.fromkey(seq,[,value])用于创建一个新字典
#以序列seq中元素做字典的键，value为字典所有键对应的初始值
seq = ['a','b','c']
dict1 = dict.fromkeys(seq,[9,4,3])
print(dict1)

输出如下所示：

{'a': [9, 4, 3], 'b': [9, 4, 3], 'c': [9, 4, 3]}

3.列表推导的方式

#方式三：列表推导的方式
elements = ['a','b','e','c','b','d','a','c','f']
e = []
for i in elements:
    if not i in e:
        e.append(i)
print(e)

以上代码也可以使用列表生成式简写成

#以上代码也可以使用列表生成式简写成
elements = ['a','b','e','c','b','d','a','c','f']
e = []
[e.append(i) for i in elements if i not in e]
print(e)

4.reduce函数

• reduce函数的定义：
• reduce(function, sequence[, initial]) -> value
• function参数是一个有两个参数的函数，reduce依次从sequence中取一个元素，和上一次调用function的结果做参数再次调用function。

#reduce函数
from functools import reduce

# reduce函数的定义：
# reduce(function, sequence[, initial]) -> value
# function参数是一个有两个参数的函数，reduce依次从sequence中取一个元素，和上一次调用function的结果做参数再次调用function。

elements = ['a','b','e','c','b','d','a','c','f']
print([[]]+elements)  #[[], 'a', 'b', 'e', 'c', 'b', 'd', 'a', 'c', 'f']
v = reduce(lambda x,y:x if y in x else x+[y],[[]]+elements)
print(v)

输出如下所示：

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

五、求两个列表的交集、差集或并集

1.for循环

a = [1,2,3,4,5]
b = [2,4,5,6,7]

#交集
result = [i for i in a if i in b]
print('a与b的交集：',result)

#差集，在a中但不在b中

result = [i for i in a if i not in b]
print('a与b的差集：',result)

#并集
result = a
for r in b:
    if r not in result:
        result.append(r)
print('a与b的并集：',result)

输出如下所示：

a与b的交集： [2, 4, 5]
a与b的差集： [1, 3]
a与b的并集： [1, 2, 3, 4, 5, 6, 7]

2.用set操作

#用set操作
a = [1,2,3,4,5]
b = [2,4,5,6,7]

#交集
result = list(set(a).intersection(set(b)))
print('a与b的交集：',result)

#差集 在a中但不在b中
result = list(set(a).difference(set(b)))
print("a与b的差集：",result)

#并集
result = list(set(a).union(set(b)))
print('a与b的交集:',result)

输出如下所示：

a与b的交集： [2, 4, 5]
a与b的差集： [1, 3]
a与b的交集: [1, 2, 3, 4, 5, 6, 7]

六、反序地迭代一个序列

对序列反序，可以利用内置函数reversed()或range()来实现，也可以用扩展切片[::-1]的形式实现。序列是列表，还可以使用列表自带的reverse()方法。

1. reversed()是python内置函数，参数可以是字符串、列表或元组等序列

2. 利用range()方法生成序列宕反序索引，然后从最后的元素遍历到开始的元素，就可以反序输出序列的元素。range(start,stop[,step])方法的参数说明

   • start：计数从start开始，默认是从0开始
   • end：计数到end结束，但不包括end
   • step：步长，默认为1

3. sea[::-1]扩展切片方法是利用粱序列宕切片操作，切片是序列的高级特性。seq[::-1]表示反向获取seq中的所有元素，并且每次取一个。-1表示从序列宕最后一个元素反向遍历获取。

4. 如果是列表序列，还可以直接用列表的reverse()方法

1.reversed()内置的函数方法

seq = "Hello World"

#reversed()内置的函数方法
for s in reversed(seq):
    print(s,end='')

#输出换行
print()

输出如下所示：

dlroW olleH

2.range()函数方法

#range()函数方法
for i in range(len(seq)-1,-1,-1):
    s = seq[i]
    print(s,end='')
#输出换行
print()

3.[::-1]扩展切片方法

#[::-1]扩展切片方法
for s in seq[::-1]:
    print(s,end='')
#输出换行
print()

4.list自带的reverse()方法

#list自带的reverse()方法
seq = [1,2,3,4,5,6]
seq.reverse()
for s in seq:
    print(s,end='')
print()

输出如下所示：

654321

七、列表的sort方法和sorted方法

• sort是列表方法，只可用来对列表进行排序，是在原序列上进行修改，不会产生新的序列
• 内置的sorted方法可以用于任何迭代的对象(字符串、列表、元组、字典等)会产生一个新的序列，旧的对象依然存在，不需要旧的序列可以采用sort方法

1.sort()方法

seq = [1,3,5,4,2,6]
seq.sort()
print(seq)

输出如下所示：

[1, 2, 3, 4, 5, 6]

2.sorted()方法

seq = [1,3,5,4,2,6]
s = sorted(seq)
print(s)

输出如下所示：

[1, 2, 3, 4, 5, 6]

3.按列表a1中字典元素的键age由大到小排序

a1 = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]

print(sorted(a1,key=lambda x:x['age'],reverse=True))

输出如下所示：

[{'name': 'b', 'age': 30}, {'name': 'c', 'age': 25}, {'name': 'a', 'age': 20}]

八、列表中常用的方法

方法	描述
list.append(x)	把一个元素添加到列表的结尾
list.extend(L)	通过添加指定列表的所有元素来扩充列表
list.insert(i,x)	在指定位置插入一个元素，第一个参数是准备插入到其前面的那个元素的索引。例如a.insert(0,x)会插入到整个列表之前
list.remove(x)	删除列表中值为x的第一个元素。没有这样元素，就会返回一个错误
list.pop([i])	从列表的指定位置移除元素，并将其返回。没有指定索引，a.pop()返回最后一个元素。
list.clear()	移除列表中的所有项，等于del a[:]
list.index(x)	返回列表中第一个值为x的元素的索引。没有匹配的元素就返回一个错误
list.count(x)	返回x在列表中出现的次数
list.sort()	对列表中的元素进行排序
list.reverse()	倒排列表中的元素
list.copy()	返回列表的浅复制，等于a[:]

• list可以看作一个对象，对象有很多中方法，调用方法是：对象.方法，append是这个对象的方法
• 对象可以理解为人，方法append类似这个人可以跑步、吃饭、打球

#list可以看作一个对象，append是这个对象的方法
# 对象可以理解为人，方法append类似这个人可以跑步、吃饭、打球
list1 = ['a','b','c']

list1.append('d')

print(list1)

list1.extend(['1','2','3'])
print(list1)

输出如下所示：

['a', 'b', 'c', 'd']
['a', 'b', 'c', 'd', '1', '2', '3']

九、列表生成式

用来创建列表的表达式就是列表生成式，也被称为列表推导式。

• 每个列表生成式都在for之后跟一个表达式，然后有零到多个for或if子句。返回结果是一个根据表达从其后的for和if上下文环境中生成出来的列表。
• 列表生成式的语法：[表达式 for 循环]

list1 = [x+1 for x in range(1,8)]
print(list1)

输出如下所示：

[2, 3, 4, 5, 6, 7, 8]

十、字典内置函数

函数及描述	描述
len(dict)	计算字典中的元素个数，键的总数
str(dict)	输出字典，以可打印的字符串表示
type(variable)	返回输入变量类型，如果变量是字典就返回字典类型
radiansdict.clear()	删除字典内所有元素
radiansdict.copy()	返回一个字典的浅复制
radiansdict.fromkeys()	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
key in dict	键在字典dict里返回True，否则返回False
radiansdict.items()	以列表返回可遍历的(键、值)元组数组
radiansdict.keys()	返回一个迭代器，可以使用list()转换为列表
radiansdict.setdefault(key,default=None)	和get类似，键不存在字典中，将会添加键并将值设为default
radiansdict.update(dict2)	把字典dict2的键/值对更新到dict里
radiansdict.values()	返回一个迭代器，可以使用list()转换为列表
pop(key[,default])	删除字典给定键key所对应的值，返回值为被删除的值。key值必须给出，否则，返回default值
popitem()	随机返回并删除字典中的一对键和值（一般删除末尾对）

使用pop和del删除字典中的name字段

dic = {"name":"刘备","age":19}
dic.pop("name")
print(dic)

dic = {"name":"刘备","age":19}
del dic["name"]
print(dic)

输出如下所示：

{'age': 19}
{'age': 19}

合并两个字典

dic1 = {"name":"刘备","age":19}

dic2 = {"hobby":"足球","money":100}

dic1.update(dic2)
print(dic1)

输出如下所示：

{'name': '刘备', 'age': 19, 'hobby': '足球', 'money': 100}

十一、集合常见内置方法

集合常见内置方法如下表所示：

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	复制一个集合
difference()	返回多个集合的差集
discard()	删除集合中指定的元素
intersection()	返回集合的交集
isdisjoint()	判断两个集合是否包含相同的元素，没有则返回True，否则返回False
issubset()	判断指定集合是否为该方法参数集合的子集
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合
union()	返回两个集合的并集
update()	给集合添加元素

给定两个列表找出相同的元素和不同的元素

list1 = [1,2,3]
list2 = [3,4,5]

set1 = set(list1)
set2 = set(list2)

print(set1&set2)
print(set1^set2)

输出如下所示：

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