python基础--核心数据类型5

python 的核心数据类型：

• Number 数字（整数，浮点数，复数，布尔型数）
• String 字符串
• List 列表
• Tuple 元组
• Dictionary 字典
• Set 集合

1. 字典 dict

• 什么是字典：

1、字典是一种可变的容器，可以存储任意类型的数据
2、字典中每个数据都是用"键"(key) 进行索引的，不像序列（字符串，列表，元组）可以用下标来索引，键不能是可变的，值可以是任意类型
3、字典的数据没有先后顺序关系，字典的存储是无序的
4、字典中的数据以键(key)-值(value)对的形式进行存储
5、字典的键不能重复（键是唯一的），且只能用不可变类型作为字典的键

• 字典的字面值表示方法：

以{}括起来，用":" 分隔键值对，各键值对用逗号分隔

• 创建空字典：

d = {}   #空字典 
或
d = dict()

• 创建非空字典：

       键  :   值
d = {"name": "zyz", "age": 25}

d = {1: "one", 2: "two",3: 3.3333}

########以下是错的#######

d = {[1, 2, 3]: "ABC"}   # 可变类型不能做字典的键
d = {1: "one", 1: "yi"}   # 键冲突，只保留最后一个

• 构造函数创建字典

dict()   创建空字典
dict(iterable)   用可迭代对象创建一个字典
dict(**kwargs)   用关键字传参来创建一个字典

d = dict()
print(d)
d = dict([(1, 2), (3, 4), (5, 6)])
print(d)
d = dict([(1, 2), (3, 4), "AB", [5, 6]])
print(d)
d = dict(name = "zyz", age = 25)   # 只有这样赋值的时候键不能是数字
print(d)

{}
{1: 2, 3: 4, 5: 6}
{1: 2, 3: 4, 'A': 'B', 5: 6}
{'name': 'zyz', 'age': 25}

2. 字典的基本操作：

• 字典的键索引语法：通过键获取键所对应的值

字典[键]

d = dict(name = "zyz", age = 25)
print(d['name'])

zyz

• 添加和修改字典的元素：

语法：字典[键] = 对象
实例 = {}

说明：键不存在，则创建键值对，键存在，则修改键绑定的值, 键存在，则修改键绑定的值

d = {}
print(d)
d['name'] = "zyz"
print(d)
d['age'] = 15   # 创建新的键-值对
print(d)
d['age'] = 25   # 修改原键"age" 所对应的值
print(d)
d[2008] = '润年'
print(d)
d[3.14] = {"pi":3.1415926}
print(d)

{}
{'name': 'zyz'}
{'name': 'zyz', 'age': 15}
{'name': 'zyz', 'age': 25}
{'name': 'zyz', 'age': 25, 2008: '润年'}
{'name': 'zyz', 'age': 25, 2008: '润年', 3.14: {'pi': 3.1415926}}

• 删除字典的元素 del 语句

del 语句（删除变量，删除列表中的元素，删除字典的键值对）
del 字典[键]   # 注意键的类型

• in/not in 运算符（字典的成员资格运算符）

可以用 in 运算符来判断一个键是否存在于字典中
not in 与 in 返回结果相反

d = {'name': 'zyz', 'age': 25}
print("name" in d, 15 in d)

True False

• 字典的迭代访问：

字典是可迭代对象，字典只能对键进行迭代访问

d = {1:"One", 2:"Two", "三":"tree"}
for k in d:
    print(k)

1
2
三

练习: 输入一段字符串，打印出这个字符串中出现过字符及出现过的次数

如：请输入：abcdabcaba
打印结果如下：
a : 4
b : 3
d : 1
c : 2

s = input("请输入：")
d = {}

for ch in s:
    if ch in d:
        d[ch] += 1
    else:  # ch不在字典中，加入字典
        d[ch] = 1
print(d)
for k in d:
    print("%s : %d" % (k, d[k]))

请输入：abcdabcaba
{'a': 4, 'b': 3, 'c': 2, 'd': 1}
a : 4
b : 3
c : 2
d : 1

3. 字典的方法：

D代表字典
D.clear()   清空字典
D.copy()    返回字典D的副本，只复制一层（浅拷贝）

D.pop(key[,default])   删除字典给定键 key 及对应的值，返回值为被删除的值。key 值必须给出。 否则，返回 default 值。
D.popitem()   从字典中移除并返回一个 (键, 值) 对。popitem() 适用于对字典进行消耗性的迭代，这在集合算法中经常被使用。如果字典为空，调用 popitem() 将引发 KeyError。在 3.7 版更改: 现在会确保采用 LIFO 顺序。在之前的版本中，popitem() 会返回一个任意的键/值对。

D.items()    将字典的键值对以元组的方式形成一个列表
D.values()   以列表返回字典中的所有值
D.keys()     以列表返回一个字典所有的键
D.update(D1)  将字典D1合并到D中，如果键相同，则此键的值取D1的值作为新值
D.get(key, default)   返回键key所对应的值，如果没有此键，则返回default

D.fromkeys(iterable[, value])  使用来自 iterable 的键创建一个新字典，并将键值设为 value。fromkeys() 是一个返回新字典的类方法。 value 默认为 None。 所有值都只引用一个单独的实例，因此让 value 成为一个可变对象例如空列表通常是没有意义的

D.setdefault(key[, default])  如果字典存在键 key ，返回它的值。如果不存在，插入值为 default 的键 key ，并返回 default。default 默认为 None。

4. 字典推导式：使用可迭代对象依次生成字典内的键值对的简单方式

• 语法：

{键表达式:值表达式 for 变量 in 可迭代对象 [if真值表达式]}

注：[] 的内容代表可省略

实例：要想生成一个字典，键为数字(1-10)，值为键的平方

d = { x : x**2 for x in range(1, 10)}
print(d)

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

• 字典推导式可以嵌套

语法如下：
{键表达式:值表达式
    for 变量1 in 可迭代对象1 [if 真值表达式1]
    for 变量2 in 迭代对象2 [if 真值表达式2]
}

练习：有字符串列表如下：

L = ['zyz', 'xiaozhuang', 'hello']

生成如下字典：

d = {'zyz': 3, 'xiaozhuang': 10, 'hello': 5}

L = ['zyz', 'xiaozhuang', 'hello']
D = {k: len(k) for k in L}
print(D)

{'zyz': 3, 'xiaozhuang': 10, 'hello': 5}

练习：已知有两个列表：Nubers = [1001, 1002, 1003, 1004]，names = ['Tom', 'Jerry', 'Spike', 'Tyke'], 要生成一个字典：d = {1001:'Tom', 1002:'Jerry',.....}

Nubers = [1001, 1002, 1003, 1004]
names = ['Tom', 'Jerry', 'Spike', 'Tyke']
D = {Nubers[x]: names[x] for x in range(len(Nubers))}
print(D)

{1001: 'Tom', 1002: 'Jerry', 1003: 'Spike', 1004: 'Tyke'}

同名公众号： 庄AC