Python核心数据类型——列表与字典

原创 2015年11月17日 21:38:16
列表和字典这两种类型几乎是Python所有脚本的主要工作组件。

======================================================================================

列表

列表是:
任意对象的有序集合
通过偏移读取
可变长度、异构以及任意嵌套
属于可变序列的分类
对象引用数组

======================================================================================

基本的列表操作,前面已经有学过,这里只记录没学过或比较重要的

1.内置函数map,它对序列中的各项应用一个函数并把结果收集到一个新的列表中:

>>> list(map(abs,[-1,-2,-3,1,2,3]))
[1, 2, 3, 1, 2, 3]
2.分片赋值:
>>> L = [1,2,3]
>>> L[:2]=[9,8]
>>> L
[9, 8, 3]


>>> L
[9, 8, 3]
>>> L[1:2]=['a','b','c']
>>> L
[9, 'a', 'b', 'c', 3]
分片赋值可以分成两步来理解:
(1)删除。删除等号左边指定的分片
(2)插入。将包含在等号右边对象中的片段插入旧分片被删除的位置。

--所以,插入元素的数目不需要与删除的数目相匹配。
--所以,分片赋值能够用来替换(覆盖)、增长(插入)、缩短(删除)主列表,这是功能强大的操作。

3.列表排序 sort,我们可以通过传入关键字参数来修改排序行为--这是指定按名称传递的函数调用中特殊的“name=value”语法。
在排序中,key参数给出了一个单个参数的函数,它返回在排序中使用的值,reverse参数允许排序按照降序而不是升序进行。

>>> L = ['abc','ABD','aBc']
>>> L.sort()
>>> L
['ABD', 'aBc', 'abc']
>>> L = ['abc','ABD','aBc']
>>> L.sort(key=str.lower)
>>> L
['abc', 'aBc', 'ABD']
>>> L = ['abc','ABD','aBc']
>>> L.sort(key=str.lower,reverse=True)
>>> L
['ABD', 'abc', 'aBc']
排序在最近的Python中可以作为内置函数使用了,它可以排序任何集合(不只是列表),并且针对结果返回一个新的列表(而不是原处修改)
>>> L = ['abc','ABD','aBe']
>>> sorted(L,key=str.lower,reverse=True)
['aBe', 'ABD', 'abc']

>>> L = ['abc','ABD','aBe']
>>> sorted([x.lower() for x in L],reverse=True)
['abe', 'abd', 'abc']
注意上述两个例子的区别。

4.extend和pop方法分别能够在末端插入多个元素、删除一个元素。也有一个reversed内置函数,像sorted一样地工作,但是,它必须包装在一个list调用中,因为它是一个迭代器。

>>> L =[1,2]
>>> L.extend([3,4,5])
>>> L
[1, 2, 3, 4, 5]
>>> L.pop()
5
>>> L
[1, 2, 3, 4]
>>> L.reverse()
>>> L
[4, 3, 2, 1]
>>> list(reversed(L))
[1, 2, 3, 4]
在某些类型的应用程序中,往往会把这里用到的列表pop方法和append方法联用,来实现快速的后进先出的(LIFO)堆栈结构。列表的末端作为堆栈的顶端
>>> L
[4, 3, 2, 1]
>>> L.append(5)
>>> L
[4, 3, 2, 1, 5]
>>> L.pop()
5
>>> L
[4, 3, 2, 1]
pop方法也能够接受某一个即将删除并返回的元素的偏移(默认值为最后一个元素),这一偏移是可选的。其他列表方法可以通过值删除(remove)某元素,在偏移处插入(insert)某元素,查找某元素的偏移(index)等

>>> L = ['spam','eggs','ham']
>>> L.index('eggs')
1
>>> L.insert(1,'toast')
>>> L
['spam', 'toast', 'eggs', 'ham']
>>> L.remove('eggs')
>>> L
['spam', 'toast', 'ham']
>>> L.pop(1)
'toast'
>>> L
['spam', 'ham']
5.其他常见的列表操作
由于列表是可变的,你可以用del语句在原处删除某项或某片段:

>>> L
['SPAM!', 'eat', 'more', 'please']
>>> del L[0]
>>> L
['eat', 'more', 'please']
>>> del L[1:]
>>> L
['eat']
因为分片赋值时删除外加插入操作,可以通过将空列表赋值给分片来删除列表片段。
==========================================================================================

字典

除了列表之外,字典也许是Python之中最灵活的内置数据结构类型。如果把列表看做是有序的对象集合,那么就可以把字典当成是无序的集合。它们主要的差别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。

Python字典主要属性如下:
通过键而不是偏移量来读取
任意对象的无序集合
可变长、异构、任意嵌套
属于可变映射类型
对象引用表
【字典是唯一内置的映射类型(键映射到值的对象)】

字典解析:

>>> D = {x:x*2 for x in range(10)}
>>> D
{0: 0, 1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6: 12, 7: 14, 8: 16, 9: 18}
【1】.字典的update方法有点类似于合并,但是,他和从左到右的顺序无关,它把一个字典的键和值合并到另一个字典中,盲目地覆盖相同键的值:
>>> D
{'eggs': 3, 'ham': 1, 'spam': 2}
>>> D2 = {'toast':4,'muffin':5}
>>> D.update(D2)
>>> D
{'eggs': 3, 'muffin': 5, 'ham': 1, 'spam': 2, 'toast': 4}
>>> D2['muffin']=999
>>> D.update(D2)
>>> D
{'muffin': 999, 'eggs': 3, 'ham': 1, 'spam': 2, 'toast': 4}
【2】.字典的pop方法与列表类似,不过删除的是一个键而不是一个可选的位置
>>> D.pop('spam')
2
>>> D
{'muffin': 999, 'eggs': 3, 'ham': 1, 'toast': 4}
【3】.使用字典可模拟灵活的列表,即键值用整数,这样用不到的索引不占用空间,反而提高了效率
【4】.字典用于稀疏数据结构
【5】.使用字典作为“记录”
【6】.创建字典的其他方法:

(1){'name':'mel','age':45}
(2)	 D = {}
	 D['name']='mel'
 	 D['age']=45
(3)dict(name='mel',age=45)
(4)dict([('name','mel'),('age',45)])
这四种形式都会建立相同的两键字典
如果所有键的值都相同,也可以用如下特殊形式对字典进行初始化:

>>> dict.fromkeys(['a','b'],0)
{'a': 0, 'b': 0}
另外,zip函数是在一个单个调用中从键和值的列表来构建一个字典的方式之一。如果不能在代码中预计键和值的集合,总是可以将它们构建为列表然后再对应起来:
>>> list(zip(['a','b','c'],[1,2,3]))
[('a', 1), ('b', 2), ('c', 3)]
>>> dict(zip(['a','b','c'],[1,2,3]))
{'a': 1, 'b': 2, 'c': 3}
在Python3.0中,可以用一个字典解析表达式来实现同样的效果
>>> D = {k:v for (k,v) in zip(['a','b','c'],[1,2,3])}
>>> D
{'a': 1, 'b': 2, 'c': 3}
字典解析应用如下:
>>> D ={x :x**2 for x in range(1,6)}
>>> D
{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
>>> D = {c.lower():c+'!' for c in['SPAM','EGGS','HAM']}
>>> D
{'eggs': 'EGGS!', 'ham': 'HAM!', 'spam': 'SPAM!'}

【7】:排序字典键

D={ ... }
for k in sorted(D.keys()):
...

【8】:has_key方法已死:in永生

>>> D
{'a': 1, 'b': 2, 'c': 3}
>>> D.has_key('a')
Traceback (most recent call last):
  File "<pyshell#77>", line 1, in <module>
    D.has_key('a')
AttributeError: 'dict' object has no attribute 'has_key'
>>> 'a' in D
True
>>> 'a' in D.keys()
True
广为使用的字典has_key键存在测试方法在Python3.0中取消了,相反,使用in成员关系表达式,或者带有默认测试的一个get(其中,in通常是首选的)
>>> D.get('c',0)
3
>>> D.get('d',0)
0
版权声明:本文为博主原创文章,未经博主允许不得转载。 举报

相关文章推荐

Python核心数据类型——列表与字典

本文介绍了Python的核心数据类型——列表和字典,介绍了列表的分片赋值、列表排序、extend和pop方法以及del删除操作;介绍了字典解析的应用、创建字典的几种方法、排序字典键和in成员测试

Python核心数据类型——数字

本文介绍Python中数字这一核心数据类型,介绍了hex(I),oct(I),bin(I)三个内置转换函数、复数的表示方法、除法(传统除法、Floor除法和真除法)、eval函数 ;介绍了内置的mat...

精选:深入理解 Docker 内部原理及网络配置

网络绝对是任何系统的核心,对于容器而言也是如此。Docker 作为目前最火的轻量级容器技术,有很多令人称道的功能,如 Docker 的镜像管理。然而,Docker的网络一直以来都比较薄弱,所以我们有必要深入了解Docker的网络知识,以满足更高的网络需求。

python数据类型--字典

python数据类型--字典{}   字典是python中惟一的映射类型(哈希表)   字典对象时可变的,但是字典的键必须使用不可变对象,并且一个字典中可以使用不同类型的键值   keys(...

Python数据类型 -- 字典

字典: 字典是无序的,它不能通过偏移来存取,只能通过键来存取。 字典 = {'key':value} key:类似我们现实的钥匙,而value则是锁。一个钥匙开一个锁 特...

python数据类型——字典

引入 没有字典的时候我们可能会这么做: >>> t = ['name', 'age', 'sex'] >>> v = ['chen', 24, 'male'] >>>...

Python数据类型-字典

python 基础数据类型 字典

Python基础——核心数据类型_序列_列表

列表列表方法: listname.append(x):在列表后添加元素,修改原来的列表。listname1.extend(listname2):在listname1后面添加listname2的所有元素...

Python基础——核心数据类型_映射_字典

映射是通过名字来引用值,而不是像序列那样通过索引。字典字典是python唯一的内建映射,键可以为任意不可变类型,如字符串或者元组。字典中的键是唯一的,值可以不唯一。 创建student = {'Al...

python3之python的核心数据类型(字典)

python3之python的核心数据类型(字典) ---------- python中的字典是一种映射(mapping)。映射是一个其他对象的集合,但是它们是通过键而不是相对位置来存储的。它也具...
  • fhd001
  • fhd001
  • 2011-10-23 14:30
  • 2836

python3之python的核心数据类型(其他核心类型)

python3之python的核心数据类型(其他核心类型) ---------- 到目前为止除了我们看到的核心类型外,还有其他的或许能够称得上核心类型的类型,这取决于我们定义的分类有多大。例如,集...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)