第四部分 列表和字典

city1 = '北京'
city2 = '上海'
city3 = '广州'
city4 = '深圳'
city5 = '成都'
city6 = '天津'
city7 = '重庆'
city8 = '西安'
print(city1+'市')
print(city2+'市')
print(city3+'市')
print(city4+'市')
print(city5+'市')
print(city6+'市')
print(city7+'市')
print(city8+'市')

city = ['北京', '上海', '广州', '深圳','成都', '天津', '重庆','西安']
for i in city:
    print(i+'市')

列表（list） 列表名 中括号 元素 逗号

list1 = ['成都',28,1.35]
print(list1)

city = ['北京', '上海', '广州', '深圳','成都', '天津', '重庆','西安']
print(city[0])
#偏移量是从0开始

city = ['北京', '上海', '广州', '深圳','成都', '天津', '重庆','西安']
print(city[:])
print(city[2:])
print(city[:2])
print(city[1:3])
print(city[2:4])
# 左取右不取  并且取到的还是列表

city = ['北京', '上海', '广州', '深圳','成都', '天津', '重庆','西安']
city[0] = '郫都区'
print(city)

city = ['北京', '上海', '广州', '深圳','成都', '天津', '重庆','西安']
city.append('贵阳')
print(city)

city = ['北京', '上海', '广州', '深圳','成都', '天津', '重庆','西安']
city.append('昆明','桂林')
print(city)

city = ['北京', '上海', '广州', '深圳','成都', '天津', '重庆','西安']
city.append(['昆明','桂林'])
print(city)

city = ['北京', '上海', '广州', '深圳','成都', '天津', '重庆','西安']
city.insert(0,"郫都区")
print(city)

city = ['北京', '上海', '广州', '深圳','成都', '天津', '重庆','西安']
del city[1]
print(city)

city = ['北京', '上海', '广州', '深圳','成都', '天津', '重庆','西安']
a = city.pop()
print(city)
print(a)

city = ['北京', '上海', '广州', '深圳','成都', '天津', '重庆','西安']
a = city.pop(0)
print(city)
print(a)

city = ['北京', '上海', '广州', '深圳','成都', '天津', '重庆','西安']
city.remove('北京')
print(city)

city = ['北京', '上海', '广州', '北京','成都', '天津', '重庆','北京']
city.remove('北京')
print(city)

city = ['北京', '上海', '广州', '北京','成都', '天津', '重庆','北京']
while '北京' in city:
    city.remove('北京')
print(city)

city = ['北京', '上海', '广州']
city1 = city
print(city)
print(city1)

city.append('深圳')

print(city)
print(city1)

city = ['成都', '重庆', '贵州']
city1 = city[:]
print(city)
print(city1)

city.append('深圳')
print(city)
print(city1)

scores = {'小明':95,'小红':90,'小刚':90} 字典名 大括号 键值

students = ['小明','小红','小刚']
scores = {'小明':95,'小红':90,'小刚':90}
print(len(students))
print(len(scores))    

scores = {'小明': 95, '小红': 90, '小明': 90}
print(scores)
#字典中的键具备唯一性，而值可重复。 后出现的【键值对】会覆盖前面的【键值对】

scores = {'小明': 95, '小红': 90, '小刚': 90}
print(scores['小明'])   #和列表通过偏移量来索引不同，字典靠的是键

scores = {'小明': 95, '小红': 90, '小刚': 90}
del scores['小明']
print(scores)

scores = {'小明': 95, '小红': 90, '小刚': 90}
del scores['小明']
print(scores)

scores['小明'] = 88
print(scores)
print(scores['小明'])

scores = {'小明': 95, '小红': 90, '小刚': 90}
scores['小明'] =88
print(scores)

scores = {'小明': 95, '小红': 90, '小刚': 90}
scores['小灰'] =88
print(scores)

scores = {'小明':[95, 92],'小红':90,'小刚':90}
print(scores)

scores = {'小明':'黄小明','小红':'李小红','小刚':'陈小刚'}
print(scores)

scores = {'小明':['高手', 92, '钢琴' , 7],'小红':90,'小刚':90}
print(scores)

scores = {45:[95, 92],'小红':90,'小刚':90}
print(scores)
print(scores[45]) 

#遍历字典
scores = {'小明':'黄小明','小红':'李小红','小刚':'陈小刚'}
for i, j in scores.items():
    print("\nkey:"+i)
    print("\nvalue:"+j)

#遍历键
scores = {'小明':'黄小明','小红':'李小红','小刚':'陈小刚'}
for i in scores.keys():
    print("\n"+i)

#默认
scores = {'小明':'黄小明','小红':'李小红','小刚':'陈小刚'}
for i in scores:
    print("\n"+i)

scores = {'小明':'黄小明','小红':'李小红','小刚':'陈小刚'}
for i in scores:
    print("\n"+scores[i])

scores = {'小明':'黄小明','小红':'李小红','小刚':'陈小刚'}
for i in scores.values():
    print("\n"+i)

##重复怎么办? 如何取消重复
scores = {'小明':99,'小红':70,'小刚':99}
for i in scores.values():
    print(i)

列表VS字典
列表有位置，位置不同，列表不同。

a = [1,2,3]
b = [3,2,1]
print(a == b)

scores1 = {1:1,2:2,3:3}
scores2 = {3:3,2:2,1:1}
print(scores1 == scores2)

students = [['小明','小红','小刚','小美'],['小强','小兰','小伟','小芳']]  #取小芳

scores = {
    '第一组':{'小明':95,'小红':90,'小刚':100,'小美':85},
    '第二组':{'小强':99,'小兰':89,'小伟':93,'小芳':88}
    }

students = {
    '第一组':['小明','小红','小刚','小美'],
    '第二组':['小强','小兰','小伟','小芳']
    }
#取'小美'


scores = [
    {'小明':95,'小红':90,'小刚':100,'小美':85},
    {'小强':99,'小兰':89,'小伟':93,'小芳':88}
    ]
print(scores[1]['小强'])
#取99。

#取'love'
list1 = [{'嫉妒':'envy'},{'恨':'hatred'},{'爱':'love'}]


dict1 = {1:['cake','scone','puff'],2:['London','Bristol','Bath'],3:['love','hatred','envy']}

• 列表地址

var1 = [['', '', ''], ['', '', ''], ['', '', '']]
var1

var1[0][0] = "X"
var1

# 我们先初始化一个变量row
row = [""]*3 
var2 = [row]*3
var2

var2[0][0] = "X"
var2

#不用变量 row 生成 var
var3 = [['']*3 for _ in range(3)]
var3[0][0] = "X"
var3

元组（tuple）。 元组和列表很相似，不过，它是用小括号来包的。
元组和列表都是序列,提取的方式也是偏移量，如 tuple1[1]、tuple1[1:]。另外，元组也支持任意的嵌套。

#取 tuple1中的A和list2中的D
tuple1 = ('A','B')
list2 = [('A','B'),('C','D'),('E','F')]
print(tuple1[0])
print(list2[1][1])

1. 可变性 #元组通常用于函数返回多个值时使用元组，或者用作字典的键（因为字典的键必须是不可变的）。
2. 内存 #内存开销较小，并且访问速度更快
3. 内置方法

my_list = [1, 2, 3]
my_list[0] = 4  
my_list.append(5)  
print(my_list) 

my_tuple = (1, 2, 3)
my_tuple[0] = 4 

my_list = [1, 2, 3]
your_list = [99, 100]
my_list.append(4)  # 增加元素
my_list.remove(1)  # 删除元素
a = my_list.pop(0)  # 删除元素
my_list.extend(your_list)  # 删除元素
print(my_list)  

my_tuple = (85, 88, 100, 100)
print(my_tuple.count(100))  # 2出现的次数
print(my_tuple.index(88))  # 3的索引

my_tuple = (85, 88, 100, 100)
my_tuple = (1, 2, 3, 4)
my_tuple
#不能修改值，但可以重新赋值

• 真的不可变？

some_tuple = ("xi", "hua", "student", "economic")
another_tuple = ([1, 2], [3, 4], [5, 6])

some_tuple[2] = "class"

another_tuple[2].append(1000)
another_tuple

another_tuple[2] += [99, 999]

another_tuple

• 不可变序列 不可变序列的对象一旦创建就不能再改变.
• 如果对象包含对其他对象的引用，则这些其他对象可能是可变的并且可能会被修改
• 但是，由不可变对象直接引用的对象集合不能更改

#取狼
townee = [
    {'海底王国':['小美人鱼''海之王''小美人鱼的祖母''五位姐姐'],'上层世界':['王子','邻国公主']},
    '丑小鸭','坚定的锡兵','睡美人','青蛙王子',
    [{'主角':'小红帽','配角1':'外婆','配角2':'猎人'},{'反面角色':'狼'}]
    ]

• 集合
• 唯一、无序

type({})

type({"xhu"})

type({"xhu":1})

{"xhua","西华"}

{s for s in "我是西华大学的学生"}

s = set("我是西华大学的学生")
print(s)

s[0]

'我' in s

'你' in s

for i in s:
    print(i)

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

s = [1,1,1,1,2,2,2,3,3,3,3]
len(s) == len(set(s))

##重复怎么办? 如何取消重复
scores = {'小明':99,'小红':70,'小刚':99}
for i in scores.values():
    print(i)

scores = {'小明':99,'小红':70,'小刚':99}
for i in set(scores.values()):
    print(i)

• 字典
• 键的唯一性是根据 等价性，而不是同一性

some_dict = {}
some_dict[1.5] = "张三"
some_dict[2.0] = "李四"
some_dict[2] = "王五"
print(some_dict)

print(some_dict[1.5])
print(some_dict[2.0])
print(some_dict[2])

• 复数

a = complex(2, 4)
b = 3 - 5j
print(a)
print(b)

complex_five = 2 + 0j
type(complex_five)

some_dict[complex_five]

 2 == 2.0 == 2 + 0j

print(2 is not 2.0 is not 2 + 0j)

# 赋值的时候也相同
my_dict = {}
my_dict[2.0] = "宏观"

print(my_dict)

my_dict[2] = "微观"
my_dict

del my_dict[2.0]
my_dict

• 枚举

# 定义常量集合，字典不是用于定义常量集合的工具，而是用于存储和检索键值对数据的数据结构。
from enum import Enum

# 定义一个枚举类
class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

# 使用枚举常量
print(Color.RED)    # 输出：Color.RED
print(Color.RED.value)  # 输出：1

some_string = "xhu"
some_dict = {}
for i, some_dict[i] in enumerate(some_string):
    pass
#enumerate() 函数返回一个枚举对象，其中包含字符串 some_string 中每个字符的索引和对应的字符。

print(some_dict)

for i in range(4):
    print(i)
    i = 10

• 将序列分解为单独的变量

#任何的序列（或者是可迭代对象）可以通过一个简单的赋值语句解压并赋值给多个变量。
p = (4, 5)
x, y = p
x

data = [ 'Lee', 20231131, 2, (2024, 9, 16) ]
name, number, myclass, date = data
name

date

name, number, myclass, (year, mon, day) = data
name

year

• 可迭代对象即可！！

s = 'xihua'
a, b, c, d, e = s
a

#解压一部分，丢弃其他的值
data = [ 'Lee', 20231131, 2, (2024, 9, 16) ]
_, number, myclass, _ = data
number

• 如何从可迭代对象中解压出 N 个元素出来？

record = ('小明', '202311031', 'python', 'stata', 'R')
name, number, *class_name = record
name

number

class_name

record = ('小明', '202311031', 'python', 'stata', 'R')
*all_cord, last_class = record
all_cord

• 进一步

line = 'nobody:*:-2:-2:Unprivileged User:/var/empty:/usr/bin/false'
uname, *fields, homedir, sh = line.split(':')
uname

homedir

sh

records = [
    (2,3,3,3,3, 1, 2),
    ('bar', 'hello'),
    ('foo', 3, 4),
]
for tag, *args in records:
    print(tag,args)

record = [ 'Lee', 20231131, 2, (2024, 9, 16) ]
name, *_, (*_, day) = record
name

day

items = [1, 10, 7, 4, 5, 9]
head, *tail = items
head

tail

• 字典的运算

socre = {
    '李明': [20231,96],
    '张三': [20234,88],
    '王刚': [20233,75],
    '薛四': [20232,98],
    '赵六': [20235,81]
}

socre = {
    '李明': 96,
    '张三': 88,
    '王刚': 75,
    '薛四': 98,
    '赵六': 81
}

#直接对字典进行运算--结果不对
print(min(socre))
print(max(socre))

print(min(socre.values())) 
print(max(socre.values())) 
# 可能还想要知道对应的键的信息

print(min(socre, key=lambda k: socre[k]))  
print(max(socre, key=lambda k: socre[k])) 

#但是，如果还想要得到最小值，你又得执行一次查找操作
min_value = socre[min(socre, key=lambda k: socre[k])]
print(min_value)

• 更好的方法

#为了对字典值执行计算操作，通常需要使用 zip() 函数先将键和值反转过来。
min_socre = min(zip(socre.values(), socre.keys()))
print(min_socre)
max_socree = max(zip(socre.values(), socre.keys()))
print(max_socree)

• 值是队列怎么办？

#类似的，可以使用 zip() 和 sorted() 函数来排列字典数据
socre_sorted = sorted(zip(socre.values(), socre.keys()))
print(socre_sorted)

• 值是队列怎么办？

#需要注意的是 zip() 函数创建的是一个只能访问一次的迭代器。 比如，下面的代码就会产生错误
scores_and_names = zip(scores.values(), scores.keys())
print(min(scores_and_names)) # OK
print(max(scores_and_names)) # ValueError: max() arg is an empty sequence

• ！注意：当多个实体拥有相同的值的时候，键会决定返回结果

prices = { 'AAA' : 45.23, 'ZZZ': 45.23 }
min(zip(prices.values(), prices.keys()))

max(zip(prices.values(), prices.keys()))

• 查找两字典的相同点

a = {
    'x' : 1,
    'y' : 2,
    'z' : 3
}

b = {
    'w' : 10,
    'x' : 11,
    'y' : 2
}

a.keys() & b.keys() 

a.keys() - b.keys() 

a.items() & b.items() 

• 进一步

c = {key:a[key] for key in a.keys() - {'z', 'w'}}
print(c)

• [练习]

a, b = a[b] = {}, 5

a  # 等于多少？

#类同
a, b = {}, 5
a[b] = a, b
a

#递归引用
some_list = some_list[0] = [0]
some_list

some_list[0]

some_list is some_list[0]

some_list[0][0][0][0][0][0] == some_list

• 列表的迭代

list_1 = [1, 2, 3, 4]
list_2 = [1, 2, 3, 4]
list_3 = [1, 2, 3, 4]
list_4 = [1, 2, 3, 4]

for idx, item in enumerate(list_1):
    del item

for idx, item in enumerate(list_2):
    list_2.remove(item)

for idx, item in enumerate(list_3[:]):
    list_3.remove(item)

for idx, item in enumerate(list_4):
    list_4.pop(idx)

#del item 只是删除了 item 变量的引用，但并没有修改 list_1 列表
print(list_1)

#在迭代列表时删除元素，会导致列表大小变化，索引也会发生变化
print(list_2)

• [ ]列表相加练习

a = [1, 2, 3, 4]
b = a
a = a + [5, 6, 7, 8]
print(a,b)

a = [1, 2, 3, 4]
b = a
a += [5, 6, 7, 8]
print(a,b)

a= 1 
a =a +1 
a 

a= 1 
a += 1 
a 

items = [1, 10, 7, 4, 5, 9]
def my_sum1(items):
    head, *tail = items
    return head + my_sum1(tail) if tail else head 

#该函数的结果是什么？