1.运算符

算术运算符

以下假设变量 a=10，变量 b=21：

逻辑运算符

以下假设变量 a 为 10, b为 20:

位运算符

a = 0011 1100
b = 0000 1101

成员运算符

a = 10
b = 20
list = [1, 2, 3, 4, 5 ]
 
if ( a in list ):
   print ("变量 a 在给定的列表中 list 中")
else:
   print ("变量 a 不在给定的列表中 list 中")
 
if ( b not in list ):
   print ("变量 b 不在给定的列表中 list 中")
else:
   print ("变量 b 在给定的列表中 list 中")

身份运算符

身份运算符用于比较两个对象的存储单元

注：id(object) 函数返回对象的唯一标识符，标识符是一个整数

>>>a = 'runoob'
>>> id(a)
4531887632   #变量a的唯一标识符
>>> b = 1
>>> id(b)
140588731085608    #变量b的唯一标识符

---

2.列表

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。

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

创建一个列表

list1 = ['Google', 'dahe', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
list4 = ['red', 'green', 'blue', 'yellow', 'white', 'black']

与字符串的索引一样，列表索引从 0 开始，第二个索引是 1，依此类推

索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推

通过索引列表可以进行截取、组合等操作

截取

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(nums[0:4])
# 从第二位开始（包含）截取到倒数第二位（不包含）
print (nums[1:-2])
#从第二位开始，到列表末尾的所有元素
print(nums[1:])
--------------------------------------------------
输出：

[10, 20, 30, 40]
[20, 30, 40, 50, 60, 70]
[20, 30, 40, 50, 60, 70, 80, 90]

更新列表

你可以对列表的数据项进行修改或更新，你也可以使用 append() 方法来添加列表项，如下所示：

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
nums[2]=521     #更改列表中的元素
nums.append(1314)     #向列表末尾插入数据
print(nums)
---------------------------------------------------------------
输出：
[10, 20, 521, 40, 50, 60, 70, 80, 90, 1314]

删除列表元素

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
del nums[1]    #删除第二个元素
print(nums)
--------------------------------------------------
输出：
[10, 30, 40, 50, 60, 70, 80, 90]

嵌套列表（类似于多维数组）

>>>a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

列表函数，方法

1.基本使用方法

nums = [10, 20, 30, 40, 50, 60, 70, 80, 90]
print(len(nums))     #返回列表元素个数
print(max(nums))     #返回列表的最大值
print(min(nums))     #返回列表的最小值

print(nums.count(10))   #统计列表中某元素出现的个数
nums.reverse()       #反向列表元素
nums.clear()         #清空列表
print(nums)

2.列表追加

list.extend() 函数用于在列表末尾一次性追加另一个序列中的多个值

list1=[10,20,30]
list2=[521,1314]
list2.extend(list1)
#在list2追加元素list1，注意，list1不一定需要是列表类型
#也可以是元组，集合类型
print(list2)

3.列表查找list.index(x,[start],[end])

list1=['Google','Tencent','ctfoj']
print(list1.index('Google'))      #输出：0
print(list1.index('aiqiyi'))      #没有找到，返回一个异常信息

4.列表排序

list.sort([key],[reverse]) 函数用于对原列表进行排序

参数：

• key – 主要是用来进行比较的函数
• reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）

演示：

# 获取列表的第二个元素
def takeSecond(elem):
    return elem[1]


# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]

# 指定第二个元素排序,降序排序
random.sort(key=takeSecond,reverse=True)

print('排序列表：', random)

5.插入元素到列表中

list.insert(index,obj)

参数：

• index – 对象obj需要插入的索引位置
• obj – 要插入列表中的对象

list1 = ['Google', 'imustoj', 'Taobao']
list1.insert(1, 'Baidu')
print ('列表插入元素后为 : ', list1)
----------------------------------------------------
输出：

列表插入元素后为 :  ['Google', 'Baidu', 'imustoj', 'Taobao']

6.移除列表元素

list1 = ['Google', 'imustctf', 'Taobao', 'Baidu']
list1.remove('Taobao')
print ("列表现在为 : ", list1)
list1.remove('Baidu')
print ("列表现在为 : ", list1)
-------------------------------------------------------
输出：
列表现在为 :  ['Google', 'imustctf', 'Baidu']
列表现在为 :  ['Google', 'imustctf']

7.移除列表中的某一个元素

list.pop([index]) index默认为-1，会返回删除的元素

list1 = ['Google', 'imustctf', 'Taobao']
list1.pop()
print ("列表现在为 : ", list1)
list1.pop(1)
print ("列表现在为 : ", list1)
---------------------------------------------------
输出：

列表现在为 :  ['Google', 'imustctf']
列表现在为 :  ['Google']

---

3.元组

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

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

元组与字符串类似，下标索引从 0/-1 开始，可以进行截取，组合等，元组可以使用下标索引来访问元组中的值

创建元组

tup=(1,2,3)
print(tup)
#注意，当元组中只有一个元素时，要用如此表示
#tup=(1,),否则编译器会把它当作整形来对待

元组的连接

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

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组

tup3 = tup1 + tup2
print(tup3)
------------------------------------
输出：
(12, 34.56, 'abc', 'xyz')

删除元组

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

tup = ('Google', 'imustctf', 1997, 2000)
del tup     #删除一整个元组
print("删除后的元组 tup : ")
print(tup)
--------------------------------------------------
输出：异常信息

元组内置函数

---

4.字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：

注：键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字

d = {key1 : value1, key2 : value2, key3 : value3 }
tinydict = {'name': 'imustctf', 'likes': 123, 'url': 'imustctf.top'}

访问字典

把相应的键放入到方括号中

tinydict = {'name': 'imustctf', 'likes': 123, 'url': 'imustctf.top'}
print(tinydict['name'])
print(tinydict['now'])     #字典中没有的数据，访问会抛出一个异常

修改字典

tinydict = {'Name': 'imustctf', 'Age': 7, 'Class': 'First'}

tinydict['Age'] = 8  # 更新 Age
tinydict['School'] = "内蒙古科技大学"  # 添加信息

删除字典的元素

tinydict = {'Name': 'imustctf', 'Age': 7, 'Class': 'First'}

del tinydict['Name']  # 删除键 'Name'
#tinydict.pop['name']  删除键的函数表示方法
#tinydict.popitem()    删除字典的最后一串元素
tinydict.clear()  # 清空字典
del tinydict  # 删除字典

字典内置函数，方法

1.dict.fromkeys(seq,[value])

用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值

参数：

• seq – 字典键值列表。
• value – 可选参数, 设置键序列（seq）对应的值，默认为 None。

seq = ('name', 'age', 'sex')

tinydict = dict.fromkeys(seq)
print(tinydict)

tinydict = dict.fromkeys(seq, 10)
print(tinydict)
----------------------------------------------
输出：
{'name': None, 'age': None, 'sex': None}
{'name': 10, 'age': 10, 'sex': 10}

2.len(dict) 返回字典的个数

tinydict = {'Name': 'imustctf', 'Age': 7, 'Class': 'First'}
print(len(tinydict))      #输出字典的个数

3.dict.items()

以列表返回视图对象，是一个可遍历的key/value 对

dict1={'one':1,'two':2}
print(dict1.items())
--------------------------------
输出：
dict_items([('one', 1), ('two', 2)])

将字典的 key 和 value 组成一个新的列表：

d={1:"a",2:"b",3:"c"}
result=[]
for k,v in d.items():
    result.append(k)
    result.append(v)

print(result)
---------------------------------------------
输出：
[1, 'a', 2, 'b', 3, 'c']

4.update添加

d={1:"a",2:"b",3:"c"}
c={4:"d"}
d.update(c)     #将c字典添加到d字典里
print(d)
--------------------------
输出：
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}

---

5.集合

集合（set）是一个无序的不重复元素序列，支持集合的运算操作

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}     #创建一个集合
>>> print(basket)                      
# 这里演示的是去重功能{'orange', 'banana', 'pear', 'apple'}


>>> # 下面展示两个集合间的运算
>>> a = set('abracadabra')    #set方法创建集合
>>> b = set('alacazam')
>>> a - b                              
# 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              
# 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              
# 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              
# 不同时包含于a和b的元素{'r', 'd', 'b', 'm', 'z', 'l'}

添加元素

1.s.add(x)

将元素 x 添加到集合 s 中（开头处），如果元素已存在，则不进行任何操作

thisset = set(("Google", "imustctf", "Taobao"))
thisset.add("jingdong")
print(thisset)
---------------------------------------------------
输出：
{'jingdong', 'Google', 'imustctf', 'Taobao'}

2.s.update(x)

添加元素，且参数可以是列表，元组，字典等

thisset = set(("Google", "imustctf", "Taobao"))
thisset.update({1,3})
print(thisset)
thisset.update([1,4],[5,6])
print(thisset)
----------------------------------------------------
输出：
{'Google', 'Taobao', 1, 3, 'imustctf'}
{'Google', 'Taobao', 1, 3, 4, 5, 6, 'imustctf'}

移除元素

1.s.remove(x)

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

thisset = {"Google", "imustctf", "Taobao"}
thisset.remove("Google")

2.s.discard(x)

移除集合中的元素，且如果元素不存在，不会发生错误

thisset = {"Google", "imustctf", "Taobao"}
thisset.discard("imustctf")

3.s.pop()

随机删除集合中的一个元素

thisset = {"Google", "imustctf", "Taobao"}
thisset.pop()

多次执行测试结果都不一样。 set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除

4.s.clear()

清空集合中的元素

thisset = {"Google", "imustctf", "Taobao"}
thisset.clear()

集合内置方法

1.差集

x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}

z = x.difference(y)
#返回x与y的差集，元素包含在集合 x ，但不在集合 y
print(z)

x.difference_update(y)
#移除x集合中两个集合中都存在的元素
print(x)
--------------------------------------------------
输出：
{'cherry', 'banana'}
{'cherry', 'banana'}

2.交集

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}

z = x.intersection(y)
#返回集合的交集
print(z)

x.intersection_update(y)
#返回x与y都存在的元素，并赋值给x集合
print(x)
-----------------------------------------------
输出：
{'apple'}
{'apple'}

3.并集

x = {"a", "b", "c"}
y = {"f", "d", "a"}
z = {"c", "d", "e"}

result = x.union(y, z)
#合并多个集合

print(result)
-----------------------------------
输出：
{'e', 'b', 'd', 'c', 'f', 'a'}

4.集合的一些判断

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "facebook"}

z = x.isdisjoint(y)
#判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False
print(z)

z2 = x.issubset(y)
#判断x是否为y集合的子集，是则返回True,不是则返回False
print(z2)
----------------------------------------------------------------------
输出：
True
False

版权声明：本文教程基于菜鸟教程

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() 关键字清空字典

1、列表(list)
列表中的数据类型可以包含多种，包含数字、字符串、字典、布尔型等，并且列表中还可以嵌套列表

print(type([1, 2, 3, 4, 5, 6]))
print(type(['Hello', 'World', 1, 6]))
print(type(['Hello', 1, 2, True, 'a']))
print(type([['Hello', 1, 2, 3], [True, 1]]))
# 列表中嵌套列表
print(type([['Hello', 'World'], [1, 2, 3], [True, False]]))
print(type([['Hello', 'World'], [1, 2, 3], [True, False], {'name': 'alex', 'age': 18}]))

结果为：
<class ‘list’>
<class ‘list’>
<class ‘list’>
<class ‘list’>
<class ‘list’>
<class ‘list’>

• 列表的访问

print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][0])
print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][3])
print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][0:2])
print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][-1:])
print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"][-1])

结果为：

新月打击
月神冲刺
[‘新月打击’, ‘苍白之瀑’]
[‘月神冲刺’]
月神冲刺

可以发现，单一数字的索引来访问的时候，得到的是一个元素；用冒号的方式来访问，得到的是一个列表，哪怕这个列表只有一个元素

• 列表的操作

print(["新月打击", "苍白之瀑", "月之降临", "月神冲刺"] + ["点燃", "打击"])
print(["点燃", "打击"]*3)

结果为：

[‘新月打击’, ‘苍白之瀑’, ‘月之降临’, ‘月神冲刺’, ‘点燃’, ‘打击’]
[‘点燃’, ‘打击’, ‘点燃’, ‘打击’, ‘点燃’, ‘打击’]

注意： print([“点燃”, “打击”]-[“点燃”]) # 输出错误

---

2、元组(tuple)

元组中的数据类型也可以包含多种

print((1, 2, 3, 4, 5))
print((1, '-1', True, 'morning', {'name': 'alex', 'age': 18}, [1, 'Hello', '1']))

结果为：

(1, 2, 3, 4, 5)
(1, ‘-1’, True, ‘morning’, {‘name’: ‘alex’, ‘age’: 18}, [1, ‘Hello’, ‘1’])

• 元组的访问

print((1, 2, 3, 4, 5)[0])
print((1, 2, 'morning', 4, True)[0:3])
print((1, 2, 'morning', 4, True)[-1:])
print((1, 2, 'morning', 4, True)[-1])
print((1, 2, 3) + (4, 5, 6))
print((1, 2, 3) * 3)
print((1, 2)[-1:])

结果为：

1
(1, 2, 'morning')
(True,)
True
(1, 2, 3, 4, 5, 6)
(1, 2, 3, 1, 2, 3, 1, 2, 3)
(2,)

注意：单一数字的索引来访问的时候，得到的是一个元素；用冒号的方式来访问，得到的是一个元组，哪怕这个元组只有一个元素

• 类型的判断1

print(type((1, 2, 3)))
print(type(1))
print(type((1)))  # 小括号代表运算符号时,比如(1+1)*2，和元组的括号有冲突，Python当括号里面只有一个元素时，规定为运算符号
# 定义只有一个元素的元组
print(type((1,)))
# 表示一个空的元组
print(type(()))

结果为：

<class 'tuple'>
<class 'int'>
<class 'int'>
<class 'tuple'>
<class 'tuple'>

• 类型的判断2

print(type("Hello"))
print(type(("Hello")))
print(type([1, 2, 3]))
print(type([1]))

结果为：

<class 'str'>
<class 'str'>
<class 'list'>
<class 'list'>

---

3、str list tuple ---->序列

• 每个元素都被分配一个序号

print((1, 2, 3)[2])
print('hello world'[2])

结果为：

3
l

• 都可以进行切片操作

print([1, 2, 3, 4, 5][0:3])
print([1, 2, 3, 4, 5][-1:])
print("Hello world"[0:8:2])

结果为：

[1, 2, 3]
[5]
Hlow

• 都可进行 + 和 *
• 判断元素是否在序列中

print(3 in [1, 2, 3, 4, 5])
print(3 not in [1, 2, 3, 4, 5])

结果为：

True
False

• 都可以求取序列的长度、元素的最大最小值

print(len([1, 2, 3, 4, 5, 6]))
print(len("Hello world"))

print(max([1, 2, 3, 4, 5, 6]))
print(min([1, 2, 3, 4, 5, 6]))

print(max("Hello world"))
print(min("Helloworld"))

结果为：

6
11
6
1
w
H

求取ASCII 的求取

print(ord('H'))
print(ord('w'))
print(ord(' '))

结果为：

72
119
32

---

4、 集合

• 无序

print(type({1, 2, 3, 4, 5, 6}))
# print({1, 2, 3, 4, 5, 6}[0])  # 错误

结果为：

<class 'set'>

• 不重复

print({1, 1, 2, 3, 6, 6})

结果为：

{1, 2, 3, 6}

• 长度

print(len({1, 2, 3}))

结果为：

3

• 剔除3，4,求集合的差集

print({1, 2, 3, 4, 5, 6}-{3, 4})

{1, 2, 5, 6}

• 求集合的交集

print({1, 2, 3, 4, 5, 6} & {3, 4})

结果为：

{3, 4}

• 两个合并成一个，不出现相同的元素，合集或并集

print({1, 2, 3, 4, 5, 6} | {3, 4, 7})

结果为：

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

• 定义一个空的集合

print(type({}))
print(type(set()))

结果为：

<class 'dict'>
<class 'set'>}

约个拓展练习可好：

快乐的LeetCode — 14. 最长公共前缀 方法2中包含了集合的巧妙使用

---

5、字典(dict)
形式：{key1:value1,key2:value2,key3:value3,} 。 可以有很多个key和value，属于集合类型(set),不是序列类型

• 访问

print({'Q': "新月打击", 'W': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"}['Q'])

# 相同的key情况，尽管有结果输出
print({'Q': "新月打击", 'Q': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"}['Q'])

# 验证发现，已经存在丢失
print({'Q': "新月打击", 'Q': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"})

结果为：

新月打击
苍白之瀑
{'Q': '苍白之瀑', 'R': '月之降临', 'E': '月神冲刺'}

• 可以有数字类型的key

print({1: "新月打击", '1': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"})

# key必须是不可变的类型， 数字1，字符串"1"
# 反例 print({[1, 2]: "新月打击", 'Q': "苍白之瀑", 'R': "月之降临", 'E': "月神冲刺"})

结果为：

{1: '新月打击', '1': '苍白之瀑', 'R': '月之降临', 'E': '月神冲刺'}

• value 本身可以是 int float str set dict list…

print({1: "新月打击", '1': "苍白之瀑", 'R': {1, 2, 3}, 'E': "月神冲刺"})

结果为：

{1: '新月打击', '1': '苍白之瀑', 'R': {1, 2, 3}, 'E': '月神冲刺'}

• 定义空的字典

print(type({}))

结果为：

<class 'dict'>

---

大家加油！
第4章 Python中表示“组”的概念与定义.mp4