1 定义

什么是字典:

  

 1. 字典是一种可变的容器，可以存储任意类型的数据

 2. 字典中的每个数据都是用"键" (key) 进行索引，而不像序列可以用下标进行索引

 3. 字典中的数据没有先后关系，字典的存储是无序的

 4. 字典的数据是以键(key)-值(value)对的形式进行存储的

 5. 字典的表示方式是以{} 括起来，以冒号(:)分割的键值对，各键值对之间用逗号分隔开

 6. 字典的键不能重复

2创建空字典的方法：

d = {}    # 空字典

  

d = dict() # 空字典

 

3创建非空的字典的方法：

d = { "name":"weimingze", "age": 35}

  d ={ "name": None, "age": 1}

  

# 以下写法可能存在问题

 

  d ={ "a": 1, "b": 2, "a": 1.1} # 去掉重复的键

#字典的值(value)可以为任意类型

4 字典的key-value

 1）字典的值（value）

可以是布尔值，数据，字符串，None,列表，元组，字典，以及后面要学到的集合，函数，类对象等所有类型

{"a" : 100 }

   {"a" : "abc" }

   {"a" : True }

   {"a" : None }

   {"a" : [1,2,3] }

   {"a" : (1,2,3) }

   {"a" : {"aa":11 } }

2）字典的键(key)

必须为不可变类型的值

不可变的类型：

bool, int, float, complex, str, tuple,frozenset

   包括：None

不能充当键的类型有

列表list,字典dict,集合set

          推导式

以下是正确格式

{"a": "a"}

 {100: "100"}

 {True: "True"}

 {None: "abc"}

 {(1970, 1, 1): "computer year!"}

5字典的基本操作

1）字典的访问

   用[]运算符访问字典内的成员

   字典[键]

例：

　　d = {"name":"tarena", "age": 15}

 print("姓名：",d["name"], "年龄：",d["age"])

2）添加／修改字典的元素

字典[键] = 值

例：

　　d = {}

 d['name'] = 'tarena'   # 创建新的键值对

   d['age']= 15                    # 创建新的键值对

   d['age']= 16                    # 修改age键所对应的值

　                                                键不存在，创建键，并绑定键对应的值

 键存在，修改键绑定的值

3）删除字典元素

 del 字典[键]

例：

　　　del d['age']  # 删除年龄和其对应的值

 

4）获取字典中元素个数len

len函数:

 len(字典)    返回字典的元素(键值对)个数

5）字典的成员资格判断 in /not in 运算符

可以用in /not in 运算符来判断一个键是否存在于字典中,如果存在则返回True,否则返回False

  notin 与 in相反

示例：

　　d = {'age': 16,'name': 'tarena'}

 "age" in d   # True

  16in d      # False

6字典的生成函数

dict()  生成一个字典，等同于{}

dict(iterable)  用可迭代对象初始化一个字典

dict(**kwargs)  关键字参数形式生成一个字典

例：

　d = dict()

  d =dict([('name', 'tarena'), ('age', 15)])

 #{'age': 15, 'name': 'tarena'}

  d =dict(name="tarena", age=16)

                        #  {'age': 16, 'name': 'tarena'}

 name = "weimingze"

     d = {'name': name}   #字典的增加，用字典[key]= value

 

 

7字典的方法

D代表字典对象

D.clear()	清空字典
D.pop(key)	移除键，同时返回此键所对应的值
D.copy()	返回字典D的副本，只复制一层（浅拷贝)
D.update(D2)	将字典D2合并到D中，如果键相同，则此键的值取D2的值作为新值
D.get(key, default)	返回键key所对应的值，如果没有此键则返回default
D.keys()	返回可迭代的dict_keys集合对象
D.values()	返回可迭代的dict_values值对象
D.items()	返回可迭代的dict_items对象

示例

D = {1 : "1", 2 : "2"}

D2 = {2: "2.2", 3:"3.3"}

 

D.update(D2)              #D = {1 : "1", 2: "2.2", 3:"3.3"}

 

for k in D.keys():

print(k)                         #1 2 3

 

for v in D.values():# 打印所有的值

print(v)

 

 

for i in D.items():

   print(i)

结果如下：

(1, '1')

(2, '2.2')

(3, '3.3')

 fork, v in D.items():

  print("键", k,"--->", v)

8字典推导式:

语法：

　　{ 键表达式 : 值表达式 for 变量 in 可迭代对象

         (if 条件表达式) }

示例：

  numbers = [1001, 1002, 1003, 1004]

  names  = ["Tom","Jerry", "Spike", "Tyke"]

  animals = { numbers[i] : names[i] for i in range(4)}

animals = { numbers[i] : names[i] for i inrange(4) if numbers[i] % 2 == 0}

 

补充示例

为了防止重复添加字典中同样的键，每次循环把s字典清空，看似合理，其实是也把stu中下表绑定的s数据也给删除了， 把生成的字典直接添加到列表中 stu = []     for x in range(2):     name = input("输入名字：")     age = input('输入年龄：')     score = int(input("分数："))     stu.append({"name": name, 'age': age, 'score': score}) print(stu)
stu = [] s = {} for x in range(2):     name = input("输入名字：")     age = input('输入年龄：')     score = int(input("分数："))     s["name"] = name     s['age']   = age     s['score'] = score     print(s)     stu.append(s)     print(stu)     s.clear()

 1）in/not in9 字典与列表的比较

   列表的in操作通常要每个都要进行比较，字典的in操作则不需要

2）字典是无序，索引是键（key、不可变类型），查找速度快

   列表是有序的，索引是下标