Python丨语法丨基基基础 之 数据容器

好久没学python了！Sorry！！！！（其实有在写题。但是又是处于一个语法完全不会的状态。。顺便我待会儿可能会讲下那个题！我都不知道是怎么卡了我那么久的。

数据容器

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素，每一个元素，可以是任意类型的据数，如字符串、数字、布尔等。

1. 字符串 String

2. 列表 List：有序的可变序列

3. 元组 Tuple：有序的不可变序列

4. 集合 Set：无序的不重复集合

5. 字典 Dictionary：无序Key-Value集合

（我很想说我真的记不住你们有序无序。。TvT）
 

btw有一些参考：

【Python3 列表 | 菜鸟教程】这是个好东西！

【Python数据容器(五)_观止study的博客-CSDN博客】

字符串 String

在 基基基基础 里面讲了一些，所以这里就不详细介绍了！

传送门：【Python丨语法丨基基基基础 + 判断、循环】

列表 List

- 类似于C++里面的数组！

- 列表的数据项不需要具有相同的类型。

- 列表可以嵌套！就是很正常地随意嵌套，不用像多维数组那样统一长度。

创建列表

1. 空列表 []

emptylist = []

2. 普通列表

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。

list1 = ['pony', 'life', 20, 30]

<<< 插播一条声明！像list、set、dict这种都属于关键字！不要直接用来命名。 >>>

访问列表中的值

可以使用 索引 or 切片 。

索引：

list1 = ['pony', 'life', 20, 30]
print(list1[1])  # life

切片： 

list1 = ['pony', 'life', 20, 30]
print(list1[0:2])  # ['pony', 'life']

嵌套列表：

解析时可以用 a = listt[x][y][z] ，或者递归判断（可以参考之前写过的一道题！）。

# 7-1 列表元素个数的加权和(1)

listt = eval(input())  # 别取名叫list了hhh

c = 0  # 加权数值
sum = 0  # 加权和

def F(listt):
    global sum, c
    c += 1  # 前进一层，加权值+1
    for i in listt:
        # print(type(i))
        if isinstance(i, list):  # 判断数据类型：isinstance()函数
            F(i)
        else:
            sum += c
    c -= 1  # 退回一层，加权值-1

F(listt)
print(sum)

修改列表

list1 = ['pony', 'life', 20, 30]
list1[0] = 'star'
# ['star', 'life', 20, 30]

添加元素 append()

使用 append() 方法来添加列表项：

list1 = ['pony', 'life', 20, 30]
list1.append('star')
# ['pony', 'life', 20, 30, 'star']

删除元素 del remove()

del

可以使用 del 语句来删除列表的元素。

del mylist[2]

remove()

remove() 函数用于移除列表中某个值的第一个匹配项。

listname.remove(obj)

列表运算符

列表对【+】和【*】的操作符与字符串相似。【+】号用于组合列表，【*】号用于重复列表。

len(list1)（求长度）、list1+list2（拼接）、i in list1（是否在列表中）、for i in list1（迭代）

列表内置函数

len(list1)、max(list1)、min(list1)、list(seq1)（元组转列表）

列表内置方法

list1.append(x)、list1.count(x)、list1.remove(x)、...（还有一些，可以自己去找。）

列表比较

列表比较需要引入 operator 模块的 eq 方法（详见：Python operator 模块）：

operator.eq(list1, list2)  # 返回bool

前排小广告：【Python随笔_列表和元组哪个效率更好-CSDN博客】

元组 Tuple

- Python 的元组与列表类似，不同之处在于元组的元素不能修改。

- 元组使用小括号 ( ) ，列表使用方括号 [ ] 。

- 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

- 可以进行切片操作。

创建元组

1. 空元组 ()

tup1 = ()

2. 普通元组

tup1 = ('pony', 'life', 20, 30)
tup2 = (1, 2, 3)
tup3 = 'a', 'b', 'c'  # 可以省略括号 # 好震惊（
print(type(tup3))  # <class 'tuple'>

3. 只包含一个元素的元组⭐

元组中只包含一个元素时，需要在元素后面添加逗号【,】，否则括号会被当作运算符使用。

tup1 = (50)  # 不加逗号，类型为整型
print(type(tup1))  # <class 'int'>

tup2 = (50,)  # 加上逗号，类型为元组
print(type(tup2))  # <class 'tuple'>

修改元组（连接组合）

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合。be like：

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)  # (12, 34.56, 'abc', 'xyz')

删除元组 del

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。be like：

tup = ('friendship', 'is', 'magic')
print(tup)

del tup
print("删除后的元组 tup : ")
print(tup)

以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

('friendship', 'is', 'magic')
删除后的元组 tup : 
Traceback (most recent call last):
  File "009.py", line 6, in <module>
    print(tup)
NameError: name 'tup' is not defined

元组运算符

与字符串一样，元组之间可以使用【+】、【+=】和【*】号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。（有乘法我真的震惊了

元组内置函数

Python元组包含了以下内置函数：

len(tuple)、max(tuple)、min(tuple)、tuple(iterable)（数据类型转换）

集合 Set

集合（set）是一个无序的不重复元素序列。（类似于数学概念里的集合）

集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。

集合中的元素必须是可哈希的（既不可变的，如数字、字符串、元组等）。

参考：【Python3 集合 | 菜鸟教程】 

创建集合

1. 空集合 set()

PS：不同于创建非空集合，创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典的。

PSS：也不可以用 set1 = () ，因为这是用来创建一个空元组的。

emptyset = set()

2. 普通集合

有两种方法！

set1 = {1, 2, 3, 4}       # 直接使用大括号创建集合
set2 = set([5, 5, 6, 7])  # 使用 set() 函数从列表创建集合
                          # set(一个列表)可以自动去重！
print(set1, set2)  # {1, 2, 3, 4} {5, 6, 7}

添加元素 add() update()

1. add(x)

set1.add(x)

将元素 x 添加到集合 set1 中。如果元素已存在，则不进行任何操作。

2. update(x)

参数x可以是列表、元组、字典等，可以是多个（用逗号隔开）。

set1.update(x)

删除元素 remove() discard()

1. remove(x)

set1.remove(x)

将元素 x 从集合 set1 中移除。如果元素不存在，则会发生错误。

2. discard(x)

set1.discard(x)

将元素 x 从集合 set1 中移除。如果元素不存在，不会发生错误。

其它函数 len() clear()

1. len(x) 计算集合元素个数

len(set1)

 2. x.clear() 清空集合

set1.clear()

集合的运算

交集 intersection()

new_set = x.intersection(y, z)

intersection()

返回集合的交集

并集 union()

new_set = x.union(y, z) 

union()

返回两个集合的并集

差集 difference()

返回一个集合，元素包含在集合 x ，但不在集合 y ：

new_set = x.difference(y)

difference()

返回多个集合的差集

字典 Dictionary

键 - 值

key - value

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字。（可变类型dict、list都不可以作为字典的key）

参考：【Python3 字典 | 菜鸟教程】

创建字典

1. 空字典 {}

# 使用大括号 {} 来创建空字典
emptyDict = {}

2. 一般字典

格式：

mydict = {key1: value1, key2: value2, key3: value3}

例子：（全是私货XD

mydict = {'Name': 'Ruru', 'Age': 9, 'Shape': 'Star'}

访问字典里的值

a = dictname[keyname]

如果访问不存在的Key：

my_dict['NoThisKey']  # KeyError # 是会直接报错！
my_dict.get('NoThisKey')  # None # 是输出了None！

顺便讲讲 get() 函数！

dict.get(key, default=None)

my_dict.get('HasThisKey')    # ThisKey的内容
my_dict.get('NoThisKey')     # None
my_dict.get('NoThisKey', x)  # x # x可以是字符串or数字or sth

总之就是有这个键的话，就会返回对应的值。没有的话，可以返回None或者指定内容！ 

参考：【Python 字典 get()函数使用详解，字典获取值_python 字典get-CSDN博客】

修改字典

mydict = {'Name': 'Ruru', 'Age': 9}
mydict['Age'] = 99  # 更新

添加元素

mydict = {'Name': 'Ruru', 'Age': 9}
mydict['Shape'] = 'Star'  # 添加

删除字典元素 del

用 del ！del+元素 - 删除元素，del+字典 - 删除整个字典。

del mydict['Name']  # 删除键 'Name'
mydict.clear()      # 清空字典
del mydict          # 删除字典

一些方法（函数）

len(dict)、key in dict、

dict.keys()、dict.values()、dict.items()、

dict1 = {'语文': 88, '数学': 99, '英语': 90}
print(dict1.keys())        # dict_keys(['语文', '数学', '英语'])
print(type(dict1.keys()))  # <class 'dict_keys'>
print(list(dict1.keys()))  # ['语文', '数学', '英语']

# 另：由于本人不加思考犯了错误，意外发现以下代码也莫名其妙可以执行。。：
print(dict.keys(dict1))    # dict_keys(['语文', '数学', '英语'])
# 绷不住了55555

【Python dict字典keys()、values()和items()方法】

...

快乐废话

我来说废话了！刚敲完实验1-1，心情好得很！！

我：刚写完两个python题，好兴奋...

vv：你好变态！

（主要是还可以顺便听歌嘿嘿w。为什么呢？看看题目就知道啦！（当时收到文件的时候差点以为老师发错东西了。。

题目：编写代码选择播放音乐
描述：两类音乐分别存储在文件夹happy和sad中
用户输入心情（0代表开心，1代表伤心，8代表不想听了），系统根据随机选取音乐播放100秒

>u< 一边写作业一边（超级正当地）听歌真的爽死了！！！

讲讲题目

（我要讲什么来着....

可以写：

1. 环

2. 随机播放音乐

3. 打怪物游戏（写UI好玩！身上有很多游戏的影子ww（比如《Pony Island》里面的其中一种游戏模式、《火山的女儿》里面的文字战斗系统...

1. 环

约瑟夫问题，是一个计算机科学和数学中的问题，在计算机编程的算法中，类似问题又称为约瑟夫环，又称“丢手绢问题”。

约瑟夫问题是个有名的问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。

2. 随机播放音乐

我稍微改了一下题目！（改成了我喜欢的样子。

# 前排提示：大music文件夹（在此程序中为GameOST）要和.py文件放在同一目录下
"""
文件树大概是这样：
listen.py
GameOST     The King's Bird
            Undertale
            ......
"""

import os
import time
import random
import pygame

while 1:
    a = input("要听点什么呢？\n（[0]不听了 [1]The King's Bird [2]Undertale）\n>")
    a = eval(a)
    if a == 0:
        break
    elif a == 1:
        game_name = "The King's Bird"
    elif a == 2:
        game_name = 'Undertale'

    music_list = os.listdir('.\GameOST\\' + game_name)  # 获取选择的文件夹下的歌曲列表
    # print(musiclist)
    music_name = random.choice(music_list)  # 在列表里随机选择歌曲
    while not '.mp3' in music_name:  # 防止有些别的文件混入
        music_name = random.choice(music_list)  # 在列表里随机选择歌曲
        # 直到后缀为 .mp3 为止
        # 如果找不到好像会陷入死循环（。）
    print('正在播放：', music_name)
    pygame.mixer.init()
    pygame.mixer.music.load('.\GameOST\\' + game_name + '\\' + music_name)
    pygame.mixer.music.play()
    time.sleep(10)  # 过10秒会再次询问
    # pygame.mixer.music.stop()  # 停止播放

3. 打怪物游戏

# 实验1-3

"""
题目：打怪物游戏
描述：假设有一个玩家，一个怪物，分别对应一连串数字，
第一个数字为初始血量，从第二个开始到最后为其可能的攻击力，
可选择的攻击力数量大于等于2，每回合都有可能是玩家或者怪物攻击（随机选择），
攻击力为玩家/怪物本身的攻击力中的随机一个，互相攻击直到其中一方血量小于等于0，输出胜利者及其剩余血量。

解析：
1. 假设一个玩家，一个怪物，分别对应一串数字，典型的Key：Value，用字典，Value为list
    role = {"player": [5, 2, 3, 4], "monster": [10, 1, 2]}
2. 每回合都选择一个角色随机攻击，攻击力随机选择，用random
    n = random.randint(1, 2)  choice = random.randint(1, 3)
    atk = role["player"][choice]   role["monster"][0] -= atk
3. 直到一方血量小于等于0，外层套一个while循环
              while role["player"][0] > 0 and role["monster"][0] > 0:
4. 判断胜利者
              if : xxx   else xxx
"""

import random

role = {"player": [5, 2, 3, 4], "monster": [10, 1, 2]}
print("player HP: 5    monster HP: 10")

while role["player"][0] > 0 and role["monster"][0] > 0:
    role_list = ["player", "monster"]  # 角色列表
    attacker = random.choice(["player", "monster"])  # 确定攻击方
    role_list.remove(attacker)  # 移除攻击方
    attacked = role_list[0]  # 剩下被攻击方
    choice = random.randint(1, len(role[attacker]) - 1)  # 选择攻击力
    atk = role[attacker][choice]  # 确定攻击力
    role[attacked][0] -= atk  # 扣血
    print("*", attacker, "attacking:", atk)  # 实时监控战况

# 判断胜利者
if role["player"][0] > role["monster"][0]:
    print("player win! HP last:", role["player"][0])
else:
    print("monster win! HP last:", role["monster"][0])

一些神奇操作

包括：

for ... in ...（从一个数据序列构建另一个新的数据序列）

zip()（简单合并）

map()（对多个序列的元素批量处理）

sorted()（排序）

推导式 for in

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

我觉得，有点像批量处理之类的东西。对数据序列里的每一个元素进行处理，或者先过滤再批量处理。

啊。。也可以以多个数据序列为基础来处理。！（套娃套娃~）

参考：【Python 推导式 | 菜鸟教程】

表达式 for 变量 in 数据序列（对数据序列里的每一个元素进行处理）

表达式 for 变量 in 数据序列 if 条件（对数据序列里符合条件的元素进行处理）

PS：如果是列表就用 [ ] 框住，字典就用 { } 框住。

list_1 = [int(i) for i in list_1]

import random

subj_list = ['语文', '数学', '英语']
test_dict1 = {key: random.randint(50, 150) for key in subj_list}
# random.randint(50, 150) 随机产生 50-150 之间的整数
# 相当于subj_list里的每一个元素都成为新字典里的key，并且分配一个随机数给它。
print('test_dict1:', test_dict1)
# {'语文': 50, '数学': 99, '英语': 150}

# num_list
num_list = []
for i in range(5):
    num_list.append(str(i) + '号')
print('num_list:', num_list)
# ['0号', '1号', '2号', '3号', '4号']

test_dict2 = {key: 'xxx' for key in num_list}
print('test_dict2:', test_dict2)
# {'0号': 'xxx', '1号': 'xxx', '2号': 'xxx', '3号': 'xxx', '4号': 'xxx'}

# 合成新字典
# 把 'xxx' 替换为之前写的 test_dict1 的那一段条件
new_dict = {key: {key: random.randint(50, 150) for key in subj_list}
            for key in num_list}  # 推导式嵌套

print('new_dict:', new_dict)
# {'0号': {'语文': 132, '数学': 141, '英语': 83},
# '1号': {'语文': 102, '数学': 78, '英语': 117},
# '2号': {'语文': 77, '数学': 148, '英语': 78},
# '3号': {'语文': 84, '数学': 147, '英语': 60},
# '4号': {'语文': 101, '数学': 92, '英语': 146}}

# 本质是套娃，我悟了！

用起来有点复杂，可以多调试，多输出！

zip() 函数

- 大概是用于 需要一一对应的多合一 的情况！

- 返回值是一个迭代器（zip object），所以我们一般会调用list()将它强制转换成列表。（后面函数那一章会讲到迭代器是个很神奇的东西）

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

一个简单例子：

>>> a = ['a', 'b', 'c']
>>> b = ['1', '2', '3', '4']
>>> list(zip(a, b))
[('a', '1'), ('b', '2'), ('c', '3')]

参考：【Python zip()用法，看这一篇就够了-CSDN博客】

map() 函数

map() 会根据提供的函数对指定序列做映射。

第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

批量处理！

- 返回迭代器（map object）。

- 是个高阶函数。（高阶函数指的是能接收一个或多个函数作为参数的函数，python中有一些内置的高阶函数，在某些场合使用可以提高代码的效率。）（后面的章节里有讲。）

map(function, iterable, ...)

大概就是，map（function，参数序列1，参数序列2，......）

function：是 lambda x , y : ... 或者 函数名。

参数序列：这里的1和2都是序列，序列的元素一个个传进函数，最后返回一串结果（迭代器 -> list）。

......：function有几个参数，后面就跟几个参数序列。

举一个非常简单的例子： 

list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8, 9, 10]
list3 = list(map(lambda x, y: x * y, list1, list2))
print(list3)  # [6, 14, 24, 36, 50]

这边有一个题目！

题目：利用高阶函数map求解所有3位4位5位水仙花数

def cul(x, y):
    x = int(x)
    y = int(y)
    return x ** y


# 三位数
for i in range(100, 1000):
    i = str(i)
    if sum(map(cul, i, '333')) == int(i):
           # cul(i[0], '3')
           # cul(i[1], '3')
           # cul(i[2], '3')
        print(i[0] + '**3+' + i[1] + '**3+' + i[2] + '**3==' + i)
# 四位数
for i in range(1000, 10000):
    i = str(i)
    if sum(map(cul, i, '4444')) == int(i):
        print(i[0] + '**4+' + i[1] + '**4+' + i[2] + '**4+' + i[3] + '**4==' + i)
# 五位数
for i in range(10000, 100000):
    i = str(i)
    if sum(map(cul, i, '55555')) == int(i):
        print(i[0] + '**5+' + i[1] + '**5+' + i[2] + '**5+' + i[3] + '**5+' + i[4] + '**5==' + i)

输出：

1**3+5**3+3**3==153
3**3+7**3+0**3==370
3**3+7**3+1**3==371
4**3+0**3+7**3==407
1**4+6**4+3**4+4**4==1634
8**4+2**4+0**4+8**4==8208
9**4+4**4+7**4+4**4==9474
5**5+4**5+7**5+4**5+8**5==54748
9**5+2**5+7**5+2**5+7**5==92727
9**5+3**5+0**5+8**5+4**5==93084

sorted() 函数

sorted(iterable, cmp=None, key=None, reverse=False)

iterable —— 可迭代对象。
cmp —— 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为：大于则返回1；小于则返回-1；等于则返回0。
key —— 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse —— 排序规则：reverse = False 升序（默认）；reverse = True 降序。

它有几种情况：

对字典：

PS：对字典排序后只会返回只有一级key的list。

1. 根据字典的key进行排序

# 根据字典的key进行排序
dict_1 = {'key3': 11, 'key2': 33, 'key1': 22}

sorted_list = sorted(dict_1, key=lambda a: a)
print(sorted_list)  # ['key1', 'key2', 'key3']

2. 根据字典的value值进行排序

# 根据字典的value值进行排序
dict_2 = {'key1': 11, 'key2': 33, 'key3': 22}

sorted_list = sorted(dict_2, key=lambda a: dict_2[a])
print(sorted_list)  # ['key1', 'key3', 'key2']

到这里我们可以发现 a 其实就是遍历出来的 key 了。 

3.  根据字典的二级key的value进行排序

# 根据字典的二级key的value进行排序
dict_3 = {'key1': {'keyA': 1, 'keyB': 11},
          'key2': {'keyA': 2, 'keyB': 33},
          'key3': {'keyA': 3, 'keyB': 22}}

sorted_list = sorted(dict_3, key=lambda a: dict_3[a]['keyB'])
print(sorted_list)  # ['key1', 'key3', 'key2']

对列表：

1. 根据列表的value进行排序

list_1 = [11, 33, 22]
sorted_list = sorted(list_1, key=lambda a: a)
print(sorted_list)  # [11, 22, 33]

2. 根据列表里字典的value值进行排序

# 根据列表里字典的value值进行排序
# [{},{},{}] -> [{},{},{}]
list_2 = [{'keyA': 1, 'keyB': 11},
          {'keyA': 2, 'keyB': 33},
          {'keyA': 3, 'keyB': 22}]

sorted_list = sorted(list_2, key=lambda a: a['keyB'])
print(sorted_list)  # [{},{},{}]
# [{'keyA': 1, 'keyB': 11}, {'keyA': 3, 'keyB': 22}, {'keyA': 2, 'keyB': 33}]
# 和原来一样拥有全部内容，但[]里面的{}被排序好了

这里的 a 是列表下的第一层东西。（比如是 list_2 里的 {'keyA': 1, 'keyB': 11} 。

熟悉了这个规律之后你就可以尽情地按自己需要的字段去排序了。！

对集合：

x = {1, 6, 2, 4, 3, 5}
print(sorted(x))  # [1, 2, 3, 4, 5, 6]
x = {1, 6, 2, 4, 3, 5}
# print(x.sort())  # 不可用
# AttributeError: 'set' object has no attribute 'sort'

返回一个有序列表。

参考：（嘿嘿我现在觉得我的示例比较有用！）

【Python sorted() 函数 | 菜鸟教程】

【Python使用sorted函数对字典进行排序_python字典排序sorted-CSDN博客】

【【python】详解字典sorted函数(高级篇)_python 字典 sorted-CSDN博客】

【Python sorted()函数及用法 - 知乎】