字典————python 文档学习

python标准库: dict.
python教程: link.
python教程: link.
迭代器: link.

作为演示,以下示例返回的字典均等于{"one": 1, "two": 2, "three": 3}:

理解字典的最好方式,就是将它看做是一个 键: 值 对的集合,键必须是唯一的(在一个字典中)。一对花括号可以创建一个空字典:{} 。另一种初始化字典的方式是在一对花括号里放置一些以逗号分隔的键值对,而这也是字典输出的方式。

1. 创建字典方式

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})

对一个字典执行 list(d) 将返回包含该字典中所有键的列表,按插入次序排列 (如需其他排序,则要使用 sorted(d))。要检查字典中是否存在一个特定键,可使用 in 关键字。

2. 小例子

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'jack': 4098, 'sape': 4139, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape'] 
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'guido': 4127, 'irv': 4127}
>>> list(tel)
['jack', 'guido', 'irv']
>>> sorted(tel)
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False

将 dict[key] 从 dict 中移除。 如果映射中不存在 key 则会引发 KeyError。

3. dict()构造函数小技巧

dict() 构造函数可以直接从键值对序列里创建字典。

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'guido': 4127, 'jack': 4098}

此外,字典推导式可以从任意的键值表达式中创建字典

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

4.循环技巧

当在字典中循环时,用 items() 方法可将关键字和对应的值同时取出

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

当在序列中循环时,用 enumerate() 函数可以将索引位置和其对应的值同时取出

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

当同时在两个或更多序列中循环时,可以用 zip() 函数将其内元素一一匹配。

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

如果要逆向循环一个序列,可以先正向定位序列,然后调用 reversed() 函数(内置函数reversed)

>>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1

如果要按某个指定顺序循环一个序列,可以用 sorted() 函数,它可以在不改动原序列的基础上返回一个新的排好序的序列

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)
...
apple
banana
orange
pear

有时可能会想在循环时修改列表内容,一般来说改为创建一个新列表是比较简单且安全的

>>> import math
>>> raw_data = [56.2, float('NaN'), 51.7, 55.3, 52.5, float('NaN'), 47.8]
>>> filtered_data = []
>>> for value in raw_data:
...     if not math.isnan(value):
...         filtered_data.append(value)
...
>>> filtered_data
[56.2, 51.7, 55.3, 52.5, 47.8]

5 for 语句

Python 中的 for 语句与你在 C 或 Pascal 中所用到的有所不同。 Python 中的 for 语句并不总是对算术递增的数值进行迭代(如同 Pascal),或是给予用户定义迭代步骤和暂停条件的能力(如同 C),而是对任意序列进行迭代(例如列表或字符串),条目的迭代顺序与它们在序列中出现的顺序一致。 例如(此处英文为双关语):

>>> # Measure some strings:
... words = ['cat', 'window', 'defenestrate']
>>> for w in words:
...     print(w, len(w))
...
cat 3
window 6
defenestrate 12

在遍历同一个集合时修改该集合的代码可能很难获得正确的结果。通常,更直接的做法是循环遍历该集合的副本或创建新集合:

# Strategy:  Iterate over a copy
for user, status in users.copy().items():
    if status == 'inactive':
        del users[user]

# Strategy:  Create a new collection
active_users = {}
for user, status in users.items():
    if status == 'active':
        active_users[user] = status

例子实现:

# Strategy:  Iterate over a copy
d = {"one": 1, "two": 2, "three": 3, "four": 4}
# Strategy:  Iterate over a copy
for key, value in d.copy().items():
    if value == 1:
        del d[key]
for key,values in d.items():
    print(key , values )
## Strategy:  Iterate over a copy
#result
two 2
three 3
four 4
# Strategy:  Create a new collection
d = {"one": 1, "two": 2, "three": 3, "four": 4}    
active_users = {}
for  key, value in d.items():
    if key == "one":
        active_users[key] = value
for key,values in active_users.items():
    print(key , values )
#result:
one 1

6 迭代器:

在python中列表,元组等都是可迭代对象,我们可以通过iter()函数获取这些可迭代对象的迭代器。然后我们可以对获取到的迭代器不断使⽤next()函数来获取下⼀条数据。iter()函数实际上就是调⽤了可迭代对象的__iter__方法(注意是两个横线,简单来说就是类似于C语言中的对链表结构的遍历,当指针不为空时就一直遍历下去,不停迭代。

7 这些是字典所支持的操作(因而自定义的映射类型也应当支持):

  • list(d)
    返回字典 d 中使用的所有键的列表。
>>> d = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> d
{'one': 1, 'two': 2, 'three': 3, 'four': 4}
>>> list(d)
['one', 'two', 'three', 'four']
>>> list(d.values())
[1, 2, 3, 4]
  • len(d)
    返回字典 d 中的项数。
len(d)
Out[71]: 4
  • d[key] = value
    当插入新的键值对时,作用相当于列表中添加元素的函数append()
d
Out[76]: {'one': 1, 'two': 2, 'three': 3, 'four': 4}

d['five']=5

d
Out[78]: {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}

不仅如此,还可以,改变键对应的值

d['three']=9
d
Out[80]: {'one': 1, 'two': 2, 'three': 9, 'four': 4, 'five': 5}
  • d[key]
    返回 d 中以 key 为键的项。 如果映射中不存在 key 则会引发 KeyError

  • del d[key]
    d[key] 从 d 中移除。 如果映射中不存在 key 则会引发 KeyError。

>>> d
d
Out[89]: {'one': 1, 'two': 2, 'three': 3, 'four': 4}

del d['two']

d
Out[91]: {'one': 1, 'three': 3, 'four': 4}

d["two"] = None

d
Out[93]: {'one': 1, 'three': 3, 'four': 4, 'two': None}
  • key in d

    如果 d 中存在键 key 则返回 True,否则返回 False。

  • key not in d

如果 d 中存在键 key 则返回 False,否则返回 true。
等价于 not key in d。

  • iter(d)
    返回以字典的键为元素的迭代器。 这是 iter(d.keys()) 的快捷方式。
d
Out[80]: {'one': 1, 'two': 2, 'three': 9, 'four': 4, 'five': 5}

it=iter(d)

next(it)
Out[82]: 'one'

next(it)
Out[83]: 'two'

next(it)
Out[84]: 'three'

next(it)
Out[85]: 'four'
# iter()。 该函数返回一个定义了 __next__() 方法的迭代器对象,
# 此方法将逐一访问容器中的元素。
  • copy()
    返回原字典的浅拷贝。

  • items()
    返回由字典项 ((键, 值) 对) 组成的一个新视图。 参见
    视图对象文档: link.。

  • keys()
    返回由字典键组成的一个新视图。 参见
    视图对象文档: link.。

  • values()
    返回由字典值组成的一个新视图。 参见
    视图对象文档: link.。

#两个 dict.values() 视图之间的相等性比较将总是返回 False。 
#这在 dict.values() 与其自身比较时也同样适用:
>>> d = {'a': 1}
>>> d.values() == d.values()
False
  • pop(key[, default])
    如果 key 存在于字典中则将其移除并返回其值,否则返回 default。 如果 default 未给出且 key 不存在于字典中,则会引发 KeyError。
d
Out[105]: {'one': 1, 'two': 2, 'three': 3, 'four': 4}

d.pop('two')
Out[106]: 2

d
Out[107]: {'one': 1, 'three': 3, 'four': 4}
  • popitem()
    从字典中移除并返回一个 (键, 值) 对。 键值对会按 LIFO(后进先出) 的顺序被返回。
d
Out[109]: {'one': 1, 'two': 2, 'three': 3, 'four': 4}

d.popitem()
Out[110]: ('four', 4)

d
Out[111]: {'one': 1, 'two': 2, 'three': 3}
  • reversed(d)
    这是 reversed(d.keys()) 的快捷方式
    但是从3.7开始将保证字典键的严格顺序,下面的代码将错误
# TypeError: 'dict' object is not reversible
for k in reversed(d): 
    print(k)

# TypeError: 'dict_keys' object is not reversible
for k in reversed(d.keys()): 
    print(k)
#错误提示
'dict_keys' object is not reversible

修改成正确代码如下:

d = {"one": 1, "two": 2, "three": 3, "four": 4}    
for k in reversed(list(d.keys())): 
    print(k)
#结果如下
four
three
two
one

零基础掌握 Python 入门到实战

11-08
【为什么学PythonPython 是当今非常热门的语言之一,2020年的 TIOBE 编程语言排行榜中 ,Python名列第一,并且其流行度依然处在上升势头。 在2015年的时候,在网上还经常看到学Python还是学R的讨论,那时候老齐就选择了Python,并且开始着手出版《跟老齐学Python》。时至今日,已经无需争论。Python给我们带来的,不仅仅是项目上的收益,我们更可以从它“开放、简洁”哲学观念中得到技术发展路线的启示。 借此机会,老齐联合CSDN推出了本课程,希望能影响更多的人走进Python,踏入编程的大门。 【课程设计】 本课程共包含三大模块: 一、基础知识篇 内置对象和基本的运算、语句,是Python语言的基础。本课程在讲解这部分知识的时候,不是简单地将各种知识做简单的堆砌,而是在兼顾内容的全面性的同时,更重视向学习者讲授掌握有关知识的方法,比如引导学习者如何排查错误、如何查看和理解文档等。   二、面向对象篇 “面向对象(OOP)”是目前企业开发主流的开发方式,本课程从一开始就渗透这种思想,并且在“函数”和“类”的学习中强化面向对象开发方式的学习——这是本课程与一般课程的重要区别,一般的课程只在“类”这里才提到“对象”,会导致学习者茫然失措,并生畏惧,乃至于放弃学习。本课程则是从开始以“润物细无声”的方式,渗透对象概念,等学习到本部分的时候,OOP对学习者而言有一种“水到渠成”的感觉。   三、工具实战篇 在项目实战中,除了前述的知识之外,还会用到很多其他工具,至于那些工具如何安装?怎么自己做工具?有那些典型工具?都是这部分的内容。具体来说,就是要在这部分介绍Python标准库的应用以及第三方包的安装,还有如何开发和发布自己的工具包。此外,很多学习Python的同学,未来要么从事数据科学、要么从事Web开发,不论哪个方向,都离不开对数据库的操作,本部分还会从实战的角度,介绍如何用Python语言操作常用数据库。
©️2020 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值