python计算菜单消费总额字典_三、Python的列表、字典、元组合集合

1.列表

变量可以存储一个元素，而列表是一个大容器，可以存储多个元素，程序可以方便的对这些数据进行整体操作.

#第一种创建方式,使用“[]"

lst1 = ['hello','world',98]

#第二种创建方式，使用内置函数list()

lst2 = list(['hello','world',98])

一些性质：列表可以存储重复数据

列表可以存储不同类型的数据

根据需要动态分配和回收内存

1).index()获取列表中指定数据的索引，如果列表中有相同元素，只返回列表中相同元素的第一个的索引.

lst1 = ['hello','world',98,'hello']

print(lst1.index('hello'))

结果为：0

index()可以在指定范围内查找元素的索引.

lst1 = ['hello','world',98,'hello']

print(lst1.index('hello',1,4))

结果为：3

2).获取列表中的单个元素：

lst1 = ['hello','world',98,'hello','world',234]

print(lst1[2])

print(lst1[-3])

结果：

3).列表的切片：获取列表中的多个元素.

lst = [10,20,30,40,50,60,70,80]

lst1 = lst[1:6:1]

lst2 = lst[1:6:2]

lst3 = lst[::2]

print("原列表lst",id(lst))

print("列表lst1",id(lst1))

print("列表lst2",id(lst2))

print(lst1)

print(lst2)

print(lst3)

结果：

通过结果知道，切片后得到的列表是一个新的列表，因为id变化了.

列表切片负索引时：

lst = [10,20,30,40,50,60,70,80]

lst1 = lst[::-1]

lst2 = lst[6::-2]

print(lst1)

print(lst2)

结果：

4).判断指定元素是否在列表中

lst = [10,20,30,40,50,60,70,80]

print(10 in lst)

print(15 not in lst)

结果：

5).列表元素的遍历

lst = [10,20,30,40,50,60,70,80]

for item in lst:

print(item)

结果：

6).列表元素的增加操作

四种方法.

lst = [10,20,30]

#向列表末尾增加一个元素

print("添加元素前的id",id(lst))

lst.append(100)

print(lst)

print("添加元素后的id",id(lst))

#在列表末尾添加一个或者多个元素

lst1 = ["hello","world"]

lst.extend(lst1)

print(lst)

#在列表的任意位置插入一个元素

lst.insert(1,50)

print(lst)

#在列表的任意位置添加至少一个元素

lst2 = [True,False,"Hello"]

lst[1:]=lst2 #相当于后面的砍掉不要了，用lst2接上

print(lst)

结果：

注：增加元素，列表id不变.

7).列表元素的删除操作

lst = [10,20,30,40,50,60,30]

#remove方法

lst.remove(30) #若移除的元素有相同元素，则移除前面的一个

print(lst)

#pop方法

lst.pop(1)

print(lst)

lst.pop() #不指定索引位置，则移除最后一个元素

print(lst)

#切片删除方法，删除至少一个元素，将产生一个新的列表对象

new_list = lst[1:3]

print(new_list)

#clear,可以清楚列表中的所有元素

lst.clear()

print(lst)

#del语句可以将整个列表对象删除

del lst

结果：

8).列表元素的修改

lst = [10,20,30,40,50,60,30]

lst[2] = 100

print(lst)

print(id(lst[1]))

print(id(lst[2]))

lst[1:3] = [300,400,500,600]

print(lst)

结果：

9).列表的排序

列表方法：.sort()

lst = [10,20,30,40,50,60,30]

print("排序前的列表",lst,id(lst))

lst.sort()

print("排序后的列表：",lst,id(lst))

lst.sort(reverse=True) #降序排序.reverse的值默认为False

print(lst)

结果：

注：不产生新的列表对象.

内置函数：sorted()

lst = [10,20,30,40,50,60,30]

print("排序前的列表",lst)

new_list = sorted(lst)

print("排序后的列表：",new_list)

desc_list = sorted(lst,reverse=True)

print("排序后的列表：",desc_list)

结果：

注：产生新的列表对象.

10).列表生成式

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

print(lst)

结果：

练习：列表中的元素的值为2,4,6,8,10.

lst = [i*2 for i in range(1,6)]

print(lst)

总结一下关于列表的知识点：

2.字典

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

注：python中的字典是根据key查找value所在的位置.

1).字典的创建

# 使用{}创建

scores = {'张三':100,'李四':98,'王五':99}

print(scores)

print(type(scores))

#第二种，使用dict()创建

student = dict(name = 'jack',age = 20)

print(student)

student1 = dict(nme = 250,age = 20)

print(student1)

#创建空字典

d = {}

print(d)

结果：

2).从字典中获取元素

scores = {'张三':100,'李四':98,'王五':99}

#第一种方式，使用[]

print(scores["张三"])

#第二种方式，使用get()方法

print(scores.get("张三"))

print(scores.get("张五"))

print(scores.get("张五",999)) #字典中不存在该元素时，返回999.

结果：

3).字典的一些操作

key的判断：

scores = {'张三':100,'李四':98,'王五':99}

print("张三" in scores)

结过为：True

增加，删除，修改：

scores = {'张三':100,'李四':98,'王五':99}

#删除指定的键值对

del scores["张三"]

print(scores)

#新增元素

scores['陈六'] = 88

print(scores)

#修改元素

scores['陈六'] = 86

print(scores)

结果：

4).获取字典视图操作

scores = {'张三':100,'李四':98,'王五':99}

#获取所有的键

keys = scores.keys()

print(keys)

print(type(keys))

print(list(keys)) #可转为列表

#获取所有的值

values = scores.values()

print(values)

print(type(values))

print(list(values)) #可转为列表

#获取素有的键值对

items = scores.items()

print(items)

print(list(items)) #可转为列表

结果：

5).字典元素的遍历

scores = {'张三':100,'李四':98,'王五':99}

for item in scores:

#获取键值

print(item,scores[item],scores.get(item))

结果：

字典的一些特点：

6).字典生成式

内置函数zip():用于将可迭代对象作为参数，将对象中对应的元素打包成一个元组.然后返回由这些元组组成的序列.

items = ["Fruits",'BOOKs',"Others"]

prices = [93,78,80,96,100]

lst = zip(items,prices)

print(list(lst))

d = {item.upper():price for item,price in zip(items,prices)}

print(d)

结果：

关于字典的知识点的总结：

3.元组

python内置的数据结构，不可变序列.不可以对其中元素进行增、删、改.

注：列表和字典是可变序列.

1).元组的创建方式

#第一种方式，使用()

t1 = ("Python","hello",98)

print(t1)

print(type(t1))

t11 = "Python","hello",98,"world"

print(t11)

#第二种方式，使用功内置函数tuple()

t2 = tuple(("Python","hello",98))

print(t2)

结果：

注：元组的创建不能没有逗号.

t1 = "python",

print(t1)

t2 = ("python",)

print(t2)

t3 = ("Python")

print(type(t3))

#空元组

t4 = tuple()

print(t4)

t5 = ()

print(t5)

print(type(t5))

结果：

一些关于元组的其他内容：

t = (10,[20,30],40)

print(t)

print(id(t[1]))

t[1].append(100)

print(t)

print(id(t[1]))

结果：

2).元组的遍历

t = ("python","world",98)

for item in t:

print(item)

结果：

4.集合

可变类型的序列.

1).集合的创建

#第一种方式，使用{}

set1 = {2,3,4,6,7,7} #集合中的元素不可重复

print(set1)

#第二种方式，使用内置函数set()

set2 = set(range(6))

print(set2)

print(set([1,2,3,5]))

print(set((1,2,6,5))) #集合元素无序

print(set("Pytohn"))

print(set({4,5,"py"}))

#空集合

print(set())

print(type({})) #不可以用{}定义空集合

结果：

2).集合的相关操作

增加元素：

set1 = {10,20,30,40,60}

# 判断元素是否在集合中

print(10 in set1)

#使用add添加元素

set1.add(80)

print(set1)

#使用update一次性添加多个元素

set1.update({100,200,300})

print(set1)

set1.update([100,200,300])

print(set1)

结果：

删除元素：

set1 = {10,20,30,40,60}

#remove方法,没有该元素则报错

set1.remove(20)

print(set1)

#discard方法，指定元素不存在不会报错

set1.discard(100)

print(set1)

#pop方法

set1.pop() #pop没有参数

print(set1)

#clear方法，清空集合

set1.clear()

print(set1)

结果：

3).集合之间的关系

set1 = {10,20,30,40,60}

#两个集合是否相等

set2 = {20,10,30,60,40}

print(set1==set2)

#一个集合是否是另一个集合的子集

set3 = {10,30}

print(set3.issubset(set1))

#一个集合是否是另一个集合的超集

print(set1.issuperset(set3)) #若集合A是集合B的子集，则集合B是集合A的超集

print(set2.issuperset(set3))

#两个集合是否有交集

print(set3.isdisjoint(set1)) #有交集为False

set4 = {50,99.5}

print(set4.isdisjoint(set1)) #没有交集为True

结果：

4).集合的运算

set1 = {10,20,30,40,60}

set2 = {10,20,100}

#求交集

print(set1.intersection(set2))

print(set1 & set2)

#求并集

print(set2.union(set1))

print(set1 | set2)

#求差集

print(set1.difference(set2))

print(set1 - set2)

#求对称差集

print(set1.symmetric_difference(set2))

print(set1 ^ set2)

#集合的运算不影响原集合

print(set1)

print(set2)

结果：

5).集合生成式

注：元组没有生成式.

set1 = {i*i for i in range(6)}

print(set1)

结果：

元组合集合的总结：

python数据结构的总结：

注：元组的创建不能少逗号，而不是括号.