Python Data Structure Sec.2.py

#创建元组元组与列表非常相似，都是有序元素的集合，并且可以包含任意类型的元素。不同的是元组是不可变的，
# 即元组一旦创建后就不能被修改，不能对元组对象中的元素进行修改、增添、删除等操作。
#列表的可变性使其能更方便地处理复杂问题，如更新动态数据等。但很多时候我们不希望某些处理过程修改对象内容，
# 如敏感数据，这就需要用到元组的不可变性。

#1. 使用圆括号创建元组
# 使用圆括号将有序元素括起来，并用逗号隔开，即可创建元组。需要注意，这里的逗号是必须存在的，
# 即使元组当中只有一个元素，其后也需要有逗号。
#在Python中定义元组的关键是元组当中的逗号，而圆括号则可以省略。当输出元组时，Python会自动加上一对圆括号。
# 如果不向圆括号中传入任何元素，那么会创建一个空元组。使用圆括号创建元组的示例如下。
"""
# 使用圆括号创建元组
mytuple1 = (1, 2.5, ('three', 'four'), [True, 5], False)
print(mytuple1)
mytuple2 = 2, True, 'five', 3.5  # 省略圆括号
print(mytuple2)  # 结果自动加上圆括号
empty_tuple = ()  # 创建空元组
print(empty_tuple)

#2. 使用tuple函数创建元组
#tuple函数能够将其他数据结构对象转换成元组对象。先创建一个列表，再将列表传入tuple函数中转换成元组，即可实现元组创建。
#使用tuple函数对代码中的元组对象进行再次创建，示例代码如下。需要注意的是，在tuple函数中传入元组时需要加上圆括号。

# 使用tuple函数将列表转换为元组
mytuple1 = tuple([1, 2.5, ('three', 'four'), [True, 5], False])
print(mytuple1)
mytuple2 = tuple((2, True, 'five', 3.5))
print(mytuple2)
empty_tuple = tuple()
print(empty_tuple)

#元组常用方法和函数
#元组是不可变的，类似对列表元素的增添、删除、修改等处理都不能作用在元组对象上，但元组属于序列类型数据结构，
# 因此可以在元组对象上进行元素索引访问提取和切片操作提取。
#可以使用元组解包来简化赋值操作，特别是当需要从元组中提取多个元素并将其赋值给多个变量时。

#1．元组元素提取
#（1）元组索引访问提取与列表索引访问提取类似，只要传入元素索引，就能够提取对应元素。
# 同样，若传入的索引超出元组索引范围，则会返回一个错误，代码如下。

mytuple3 = ( '制造强国', '质量强国', '航天强国', '交通强国','网络强国', '数字中国')
print(mytuple3[0])#提取元组第1个元素
#print(mytuple3[10])  # 传入的索引超出元组索引范围

#（2）元组切片操作提取
# 使用类似列表的切片操作，也可以提取元组的切片，并且无须考虑超出索引范围的问题，示例代码如下。
print(mytuple3[-2::-1])  # 提取元组倒数第2个元素到左端第1个元素之间的所有元素
print(mytuple3[1:10])  # 超出元素索引范围

#2．元组解包
#将元组中的各个元素赋值给多个不同变量的操作通常称为元组解包，其使用格式为obj_1,obj_2,…,obj_n=tuple。
# 由于创建元组时可以省略圆括号，因此元组解包可以看成是多条赋值语句的集合，示例如下。
A, B, C, D, E, F = mytuple3  # 利用元组解包给多个变量赋值
print(A)
print(B)
print(C)
x, y, z = 1, True, 'one'
print(x)
print(z)
print(type(z))

#3．元组常用操作
# 相比于列表，由于元组无法修改元素，因此可对元组进行的操作相对较少，但仍然能够对元组进行元素位置查询等操作。
# 其他常用的元组操作/运算符如下。

#count()方法：记录某个元素在元组中出现的次数
#index()方法：获取元素在元组中第一次出现的位置索引
#sorted函数：创建对元素进行排序后的元组
#len函数：获取元组长度，即元组中元素的个数
# +  ：将两个元组合并为一个元组
# *  ：重复合并同一个元组为一个更长的元组

#其他常用的元组操作/运算符
# 使用count()方法进行元素计数
mytuple4 = ('A', 'D', 'C', 'A', 'C', 'B', 'B', 'A')
print(mytuple4.count('B'))
# 使用index()方法获取元素在元组中第1次出现的位置索引
print(mytuple4.index('C'))
# 使用sorted函数对元组元素进行排序
print(sorted(mytuple4))
# 使用len函数获取元组长度
print(len(mytuple4))
# 使用加号合并两个元组
print((1, 2, 3) + (4, 5, 6))
# 使用乘号重复合并元组
print((10,20,30,40) * 3)

#【任务3-2】实现学生成绩管理
scores=('78:语文','89:数学','89:外语','90:政治','69:实践课程')
print(scores[-1])


#创建字典并进行增、删、改、查等操作
#1解析字典的键与值
#字典中的每个元素都具有与之对应且唯一的键，元素就是键所对应的值，键与值共同构成一个映射关系，
# 即键→值，每个键都可以映射到相应的值。
#键和值的这种映射关系在Python中具体表示为键:值（key:value），键和值之间用冒号隔开，
# 这里将其称为“键值对”，字典中会包含多组键值对。
#字典中的键必须使用不可变数据类型的对象，例如数字、字符串、元组等，并且键是不允许重复的；
# 而值则可以是任意类型的，且在字典中可以重复。

#2创建字典
#(1)使用花括号创建字典  将字典中的一系列键和值按键值对的格式传入花括号中，
# 并用逗号将各键值对隔开，即可实现字典的创建，具体格式如下。
#dict = {key_1:value_1, key_2:value_2, …, key_n:value_n}
#如果在花括号中不传入任何键值对，那么将会创建一个空字典。
#当在花括号中重复传入相同的键时，因为键在字典中不允许重复，
# 所以字典最终会采用最后出现的重复键的键值对。具体应用示例如下。

mydict1 = {'myint': 1, 'myfloat': 3.1415, 'mystr': 'name',
           'myint': 100, 'mytuple': (1, 2, 3), 'mydict': {}}  # 使用花括号创建字典
# 对于重复键，采用最后出现的对应键值对
print(mydict1)
empty_dict = {}  # 创建空字典
print(empty_dict)

#(2)使用dict函数创建字典
#     可以使用dict函数创建字典。Python中dict函数的作用主要是将包含双值子序列的序列对象转换为字典类型，
# 其中各双值子序列中的第1个元素作为字典的键，第2个元素作为键对应的值，即双值子序列中包含键值对信息。
#     还可以直接向dict函数传入键和值创建字典，其中，键和值应通过“=”隔开。这种创建方式不允许键重复，
# 否则会返回错误。具体格式如下。dict = {key_1:value_1, key_2:value_2, …, key_n:value_n}

# 使用dict函数转换列表对象为字典对象
mydict1 = dict([('myint', 1), ('myfloat', 3.1415), ('mystr', 'name'),
                ('myint', 100), ('mytuple', (1, 2, 3)), ('mydict', {})])
print(mydict1)
mydict2 = dict(zero=0, one=1, two=2)  # 使用dict函数创建字典
print(mydict2)
empty_dict = dict()  # 创建空字典
print(empty_dict)

#3提取字典元素
#     与序列类型数据结构不同，字典作为映射类型数据结构，并没有索引的概念，也不支持切片操作等处理方法，
#字典中只有键和值之间的映射关系，因此对字典元素的提取主要是利用这种映射关系来实现的。
#     通过在字典对象后紧跟方括号，在方括号中包含指定的键即可提取相应的值，具体使用格式为dict[key]，
#即字典[键]。传入的键要存在于字典中，否则会返回一个错误。提取字典元素的示例如下。

mydict3 = {'spring': (3, 4, 5), 'summer': (6, 7, 8), 'autumn': (9, 10, 11), 'winter': (12, 1, 2)}
print(mydict3['autumn'])  # 提取键'autumn'对应的值
print(mydict3['Spring'])  # 提取字典中不存在的键'Spring'对应的值

mydict3 = {'spring': (3, 4, 5), 'summer': (6, 7, 8), 'autumn': (9, 10, 11), 'winter': (12, 1, 2)}

#（1）提取前使用in关键字测试键是否存在
# 在传入键之前，测试字典中是否存在要传入的键，如果不存在，就不进行提取操作。
# 这种功能具体可以使用in关键字来实现，示例代码如下。
print('Spring' in mydict3)  # 使用in关键字测试键是否存在

#（2）使用字典方法get()
#字典方法get()能够灵活地处理元素的提取，无论键是否存在，向get()方法传入需要的键和一个代替值即可。
#若只传入键，当键存在于字典中时，get()方法会返回对应的值；当键不存在时，get()方法会返回None。具体应用示例如下。

print(mydict3.get('summer'))  # 传入存在的键并返回对应值
mydict3.get('Spring')  # 仅传入不存在的键，不显示任何内容
print(mydict3.get('Spring'))  # 输出get()方法返回的结果
# 传入不存在的键并返回代替值
print(mydict3.get('Spring', 'Not in this dict'))#print总会输出点东西，不管是不是none，还是空集


#4 字典常用方法和函数  字典常用方法和函数
#在Python的内置数据结构当中，列表和字典是最为灵活的数据结构。类似于列表，字典也属于可变数据结构，
# 因此字典也含有丰富且功能强大的方法和函数。
#与列表一样，字典中也有copy()方法，其作用是复制字典内容并创建一个副本对象。
# 由于上述字典处理会直接作用在字典对象上，而且各种处理方式包含多种方法。

#[1]增添字典元素

#（1）使用键访问赋值增添元素
#利用字典元素提取方法传入一个新的键，并对这个新键进行赋值操作，即dict [newkey] = new_value，
# 字典中就会产生新的键值对。这种赋值操作可能会因为键不存在而出现错误，示例代码如下。
country = dict(China='Beijing',
               England='London',
               France='Paris',
               Canada='Ottawa')  # 使用dict函数创建字典
country_copy = country.copy()  # 创建一个字典对象副本
country_copy['Russia'] = 'Moscow'  # 增添元素
print(country_copy)

#(2)使用update()方法合并字典
#字典方法update()能将两个字典进行合并，传入字典中的键值对会被复制并增添到调用此方法的字典对象中。
# 如果两 个 字典中存在相同的键，那么传入字典中的键所对应的值会替换掉调用update()方法的字典对象中的原有值，
# 从而实现值更新的效果，示例代码如下。

others = dict(Australia='Canberra', Japan='tokyo', Canada='OTTAWA')
country.update(others)  # 使用update()方法增添多个元素
print(country)

#[2]删除字典元素

#（1）使用del语句删除字典元素
# 使用del语句删除字典元素的具体格式为del dict [key]，应用示例如下。
country_copy = country.copy()
del country_copy['Canada']  # 使用del语句删除副本对象中的元素
print(country_copy)

#（2）使用pop()方法删除字典元素
# 向pop()方法传入需要删除的元素的键，将会返回对应的值，并在字典当中删除相应的键值对。
# 若将返回的结果赋值给变量，则相当于从字典当中抽离出值，示例如下。

old_value = country.pop('Canada')  # 将键对应的值赋值给变量，并删除键值对
print(old_value)
print(country)  #值给old_value了

#（3）使用clear()方法删除字典元素
# clear()方法可以删除字典中的所有元素，最终返回一个空字典，代码如下。

country_copy = country.copy()
country_copy.clear()  # 清空副本对象内容
print(country_copy)

#[3]修改字典元素
# 要修改字典中的某个元素，同样可以使用键访问赋值实现，其格式为dict[key] = new_value。
# 赋值操作在字典中的使用非常灵活，无论键是否存在于字典中，所赋予的新值都会覆盖或增添到字典中。具体应用示例如下。

country['Japan'] = 'Tokyo'  # 直接将新值赋值给对应元素
print(country)

#[4]查询和获取字典元素信息
#在实际应用当中，往往需要查询某个键或值是否存在于字典当中，除了可以使用提取字典元素的方法进行查询外，
# 还可以使用Python中的in关键字进行查询。字典的方法中有3种方法可以用于获取键值信息。
#（1）keys()：用于获取字典中的所有键。
#（2）values()：用于获取字典中的所有值。
#（3）items()：用于获取字典中的所有键值对。
#调用以上3种方法返回的结果分别是字典中键、值和键值对的迭代形式，可以通过list函数将返回结果转换为列表类型，
# 同时可以配合使用in关键字，判断键值和键值对是否存在于字典中。具体应用示例如下。

#获取键值信息
# 判断键是否存在于字典中
print('Canada' in country)
# 获取所有键
all_keys = country.keys()  # 使用keys()方法获取所有键
print(all_keys)
all_values = country.values()  # 使用values()方法获取所有值
print(all_values)

print('Beijing' in all_values)  # 判断值是否存在于字典中

print(list(all_values))  # 将值的迭代形式转换为列表

all_items = country.items()  # 使用items()方法获取所有键值对

print(all_items)

print(('Australia', 'Canberra') in all_items)  # 判断键值对是否存在于字典中

print(list(all_items))  # 将键值对的迭代形式转换为列表

#如果需要对字典进行更复杂、更高级的处理，那么需要灵活地将这些方法和函数进行组合运用。
# 例如，利用值来查询所有与之对应的键，示例代码如下。
test = {'A':100, 'B':300, 'C':True, 'D':200}
keys = list(test.keys())  # 获取字典中的所有键
values = list(test.values())  # 获取字典中的所有值
print(keys)
print(values)  # 获取的所有键和值的索引正好一一对应，构成原字典中的键值对
print(keys[values.index(True)])  # 利用值True的索引来获取对应的键
"""

#5【任务3-3】创建简单的货物库存查询程序