文档章节

python入门(四)-- 列表、元组、字典具体操作

兴趣使然的程序员
 兴趣使然的程序员
发布于 2017/05/14 13:41
字数 2536
阅读 52
收藏 1

1、序列(列表、元组和字符串)的方法

Python包含以下函数:

序号 函数
1 len(seq):返回序列中的元素个数
2 max(seq):返回序列元素最大值
3 min(seq):返回序列元素最小值
4 sum(seq):返回序列值的和
5 sort(seq):对序列进行排序,返回一个list
5 list(seq):将序列转换为列表
6 tuple(seq):将序列转换为列表
7 str(obj):将任意对象转换为字符串

注意:

  • sum、max和min要求序列中的值必须是同一个类型,不然无法比较或者求和。

例如:

>>> string = "asdfqer12314"
>>> sorted(string)
['1', '1', '2', '3', '4', 'a', 'd', 'e', 'f', 'q', 'r', 's']
>>> max(string)
's'
>>> min(string)
'1'
>>> string
'asdfqer12314'
>>> list = sorted(string)
>>> max(list)
's'
>>> min(list)
'1'
>>> list = [1,1,2,3,4,'a','d']
>>> max(list)
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    max(list)
TypeError: unorderable types: str() > int()

注意:

  • 和其他语言中不同,python中没有和数字类型可以互转的char类型,所以单个字符'a'实际上也是字符串,无法直接和数字进行比较。

1.1、序列的filter函数

filter函数的定义是:filter(function or None, iterable) --> filter object。

可以通过输入的函数来对序列进行过滤,并返回一个filter object。注意:

  • 输入None的话,会自动将0和False过滤掉
In [16]: list(filter(None,[1,0,False,True]))
Out[16]: [1, True]
  • 可以输入函数来指定过滤的规则(和Java8中的Stream类似的功能),例如:
In [18]: list(filter(lambda x:(x&0x01)==1,[1,2,3,4,5,6,7]))
Out[18]: [1, 3, 5, 7]

1.2、序列的map函数

map函数的定义是: map(func, *iterables) --> map object。

map函数可以对输入的序列中的每一个函数,进行一次func操作,并返回一个map object。(同样和Java中Stream的map类似)。例如:

In [21]: list(map(lambda x: x+1,[1,2,3,4,5,6]))
Out[21]: [2, 3, 4, 5, 6, 7]

2、列表

2.1、有关列表的所有方法和函数

List包含以下内置函数:

序号 方法
1 list.append(obj):在列表末尾添加新的对象
2 list.count(obj):统计某个元素在列表中出现的次数
3 list.extend(seq):在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
4 list.index(obj):从列表中找出某个值第一个匹配项的索引位置
5 list.insert(index, obj):将对象插入列表的指定位置之前,不会覆盖原位置的元素
6 list.pop(obj=list[-1]):移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
7 list.remove(obj):移除列表中某个值的第一个匹配项
8 list.reverse():反向列表中元素
9 list.sort([func]):对原列表进行原址排序
10 list.clear():清空列表
11 list.copy():返回列表的一个“浅拷贝”,等同于list[:]

例如:

2.1.1、向列表中插入元素

In [1]: animals = ['cai','dog','snake','lion']

In [2]: animals.append('pig')

In [3]: animals
Out[3]: ['cai', 'dog', 'snake', 'lion', 'pig']

In [4]: animals.append('bird','cow')
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-4-57b332645244> in <module>()
----> 1 animals.append('bird','cow')

TypeError: append() takes exactly one argument (2 given)

In [5]: animals.extend('bird','cow')
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-5-d37215d6ed56> in <module>()
----> 1 animals.extend('bird','cow')

TypeError: extend() takes exactly one argument (2 given)

In [6]: animals.extend(['bird','cow'])

In [7]: animals
Out[7]: ['cai', 'dog', 'snake', 'lion', 'pig', 'bird', 'cow']

In [8]: animals.insert(0,'dragon')

In [9]: animals
Out[9]: ['dragon', 'cai', 'dog', 'snake', 'lion', 'pig', 'bird', 'cow']

注意:

  • append一次只能添加一个元素
  • 一次添加多个元素需要使用extend
  • 注意extend接受一个数组,而不能以多个元素的形式输入,否则报错
  • insert插入,不替换原位置的元素

2.1.2、删除列表元素

In [9]: animals
Out[9]: ['dragon', 'cai', 'dog', 'snake', 'lion', 'pig', 'bird', 'cow']

In [10]: animals.remove('cai')

In [11]: animals
Out[11]: ['dragon', 'dog', 'snake', 'lion', 'pig', 'bird', 'cow']

In [12]: del animals[0]

In [13]: animals
Out[13]: ['dog', 'snake', 'lion', 'pig', 'bird', 'cow']

In [14]: animals.pop()
Out[14]: 'cow'

In [15]: animals
Out[15]: ['dog', 'snake', 'lion', 'pig', 'bird']

In [16]: animals.pop(1)
Out[16]: 'snake'

In [17]: animals.remove(0)
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-17-98c2ad3daa0d> in <module>()
----> 1 animals.remove(0)

ValueError: list.remove(x): x not in list

注意:

  • remove返回None,只接收元素,不接收下标
  • pop不接收元素,接收下标
  • 也可以用del指定删除元素

2.1.3、列表的排序

Python可以通过list.sort()和sorted(list)进行排序。差别是:

  • list.sort()对数组进行原址排序,返回None
  • sorted(list)数组本身不变,返回排序好的数组的副本
list = [1,8,3,6,7,9]
# 返回[1, 3, 6, 7, 8, 9]
print(sorted(list))
# 返回[1, 8, 3, 6, 7, 9]
print(list)
# 返回None
print(list.sort())
print(list)
# 还可以指定进行逆序排序
print(list.sort(reverse=True))

2.1.4、其他函数

In [25]: animals
Out[25]: ['dog', 'lion', 'pig', 'bird']

In [26]: animals.index('lion')
Out[26]: 1

In [27]: animals.append('dragon')

In [28]: animals.append('dragon')

In [29]: animals.count('dragon')
Out[29]: 2

In [30]: animals
Out[30]: ['dog', 'lion', 'pig', 'bird', 'dragon', 'dragon']

In [31]: animals.reverse()

In [32]: animals
Out[32]: ['dragon', 'dragon', 'bird', 'pig', 'lion', 'dog']

2.2、 把列表当做“栈”使用

“栈”是一个“后进先出”的数据结构,用append()和pop()可以轻松实现栈的操作:

  • 压栈:append()
  • 弹栈:pop()

和Java中的LinkedList等结构不同,Java中的实现是在列表的“头”存取,而python是在列表的“尾”存取,但是这并不重要,“栈”结构重要的是在“同一端存取”。

2.3、“队列”

“队列”是一个“先进先出”的数据结构。

和“栈”的情况不同,队列“不在同一端存取”。python中的列表类似于Java中的ArrayList,在头部删除、添加需要移动所有元素,效率低下。

固一般不用列表实现队列,而使用专门的类似于Java中LinkedList的类:collections.deque(双向链表):

from collections import deque
queue = deque([1, 2, 3])
queue.append(4)
print(list(queue))
pop = queue.pop()
print(pop)
popleft = queue.popleft()
print(popleft)
  • 入队:append()
  • 出队:popleft()

栈同样可以用deque实现,方法和list的相同。

2.4、列表推导式

列表推导式由一个包含一个表达式的括号组成,表达式后面跟随一个或多个for或者if语句(for语句和if语句按顺序进行)。

# 使用lambda表达式快速创建list
squares = list(map(lambda x: x**2, range(10)))
print(squares)
# 使用列表推导式快速创建list
squares = [x**2 for x in range(10)]
print(squares)
# 带if的列表推导式
squares = [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
print(squares)
# 上面的列表推导式等同于
squares1 = []
for x in [1, 2, 3]:
    for y in [3, 1, 4]:
        if x != y:
            squares1.append((x,y))
print(squares1)
# 还可以有更复杂的表达式
from math import pi
squares2 = [str(round(pi, i)) for i in range(1, 6)]
print(squares2)

除了这些“简单”的列表以外,还可以用嵌套的列表推导式,进行更复杂的操作:

# 矩阵
matrix = [
            [1, 2, 3, 4],
            [5, 6, 7, 8],
            [9, 10, 11, 12]
        ]
print(matrix)

# 交换行列
tMatrix = [[row[i] for row in matrix] for i in range(4)]
print(tMatrix)

# 交换行列还可以通过拆分列表实现,*代表拆分,zip按顺序取每个子列表的同位置的元素
print(list(zip(*matrix)))

嵌套的多个for或者if语句,按嵌套的内外关系,外层的先进行。

2.5、序列的相互比较

序列对象可以与相同类型的其他对象比较。序列的相互比较和字符串的相互比较类似,由按顺序第一个不同的元素的”大小“来决定两个序列的大小

需要注意的是,元素的比较只比较”值“。

例如:

In [19]: list1 = [123]

In [20]: list2 = [234]

In [21]: list1 > list2
Out[21]: False

In [22]: list1 = [123,456]

In [23]: list2 = [234,123]

In [24]: list1 > list2
Out[24]: False

2.6、序列的拆分

序列(列表、元组和字符串)都可以进行如下形式的快速拆分操作:

# 声明元组
t = 12345, 54321, 'hello!'
# 拆分元组,变量数需要和元组的元素个数相等
x, y, z = t

3、集合

集合的操作(并集、交集、差集、对称差集):

# 构建元组
t = {"q","w","e","r"}
# 还可以用和列表推导式类似的方法构建
a = {x for x in "asdfqewrgq" if x not in "abc"}
print(a)

# 并集
print(t | a)
# 交集
print(t & a)
# 差集(注意,a-t和t-a不同)
print(a - t)
# 对称差集(不同时在t和a中的元素)
print(t ^ a)

4、字典

字典以关键字为索引,关键字可以是任意不可变类型。需要注意的是:

  • 如果元组只包含字符串和数字或者其他不可变类型,则它可以作为关键字,如果包含任何可变类型,则不能作为关键字

字典同样可以通过推导式创建:

# 使用推导式创建字典
dict1 = {x: x ** 2 for x in (2, 5, 6)}
print(dict1)

除此之外还可以通过元组创建:

dict1 = dict(((1,'cai'),(2,'li')))
print(dict1)

4.1、fromkeys()函数

fromkeys函数接收元组,创建指定key和值的dict。例如:

In [3]: dict1 = dict.fromkeys((1,2,3,4,5))

In [4]: dict1
Out[4]: {1: None, 2: None, 3: None, 4: None, 5: None}

In [5]: dict1 = dict.fromkeys((1,2,3,4,5),'Number')

In [6]: dict1
Out[6]: {1: 'Number', 2: 'Number', 3: 'Number', 4: 'Number', 5: 'Number'}

In [7]: dict1 = dict.fromkeys((1,2,3,4,5),('n1','n2','n3','n4','n5'))

In [8]: dict1
Out[8]:
{1: ('n1', 'n2', 'n3', 'n4', 'n5'),
 2: ('n1', 'n2', 'n3', 'n4', 'n5'),
 3: ('n1', 'n2', 'n3', 'n4', 'n5'),
 4: ('n1', 'n2', 'n3', 'n4', 'n5'),
 5: ('n1', 'n2', 'n3', 'n4', 'n5')}

In [12]: dict1 = dict.fromkeys(range(3))

In [13]: dict1
Out[13]: {0: None, 1: None, 2: None}

注意:

  • 如果不指定值,会自动填充None
  • 如果指定了值,所有的key都会被填充相同的值
  • 除了元组以外,也可以接收range

4.2、setdefault函数 

许多时候我们需要往字典中的元素添加数据,我们首先要判断这个元素是否存在,不存在则创建一个默认值。如果在循环里执行这个操作,每次迭代都需要判断一次,降低程序性能。

我们可以使用 dict.setdefault(key, default) 更有效率的完成这个事情。

>>> data = {}
>>> data.setdefault('names', []).append('Ruby')
>>> data
{'names': ['Ruby']}
>>> data.setdefault('names', []).append('Python')
>>> data
{'names': ['Ruby', 'Python']}
>>> data.setdefault('names', []).append('C')
>>> data
{'names': ['Ruby', 'Python', 'C']}

试图索引一个不存在的键将会抛出一个 keyError 错误(这点和Java不同,Java会返回Null)。我们可以使用 dict.get(key, default) 来索引键,如果键不存在,那么返回指定的 default 值。

>>> data['foo']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'foo'
>>> data.get('foo', 0)
0

 

© 著作权归作者所有

共有 人打赏支持
兴趣使然的程序员
粉丝 21
博文 112
码字总数 87412
作品 0
深圳
程序员
Python 入门之基本数据类型

为什么我要学习Python这门语言呢?其实很简单,我想拓展技术面的同时,尝试更多的方向,可能最后会不了了之,谁知道呢?有可能的话,我会向爬虫和数据分析这个方向走。所以也就开始了我的Pyt...

YJK923
08/17
0
0
Python爬虫入门 | 3 爬虫必备Python知识

点击上方蓝色字体,关注我们 15 这是一个适用于小白的Python爬虫免费教学课程,只有7节,让零基础的你初步了解爬虫,跟着课程内容能自己爬取资源。看着文章,打开电脑动手实践,平均45分钟就...

ch3ruf0termb3yh
04/20
0
0
Python基础总结成千行代码,让Python入门更简单!

只要学会这千行代码,不管你是零基础还是弱基础或是没有接触过编程,都可以快速入门Python!当时我就不信邪啊,等我看完之后,即使作为一个Python老鸟了,还是领会到了很多教授他的独特见解!...

糖宝lsh
09/10
0
0
Python3基础知识点的讲解(四)

绪论 本篇文章既上篇文章之后为大家带来的是关于Python3中一些基础的知识点,通过上篇的学习,我们队Python3中的一些基本的语法有所了解和掌握。 主要内容的介绍 字典的介绍 字典的运用 元组...

长风留言
06/08
0
0
Python学习系列入门篇(二)

这些天忙的不可开交,今天终于想起来继续写,工欲善其事必先利其器,得找个markdown编辑器用一下,windows找了个破解版的(主要是可以传图片),使用起来还不错,支持实时预览,就用它了,首...

疑似一僧
2014/03/17
0
0

没有更多内容

加载失败,请刷新页面

加载更多

smart-doc特殊功能使用介绍

smart-doc从8月份底开始开源发布到目前为止已经迭代了几个版本。在这里非常感谢那些敢于用smart-doc去做尝试并积极提出建议的社区用户。因此决定在本博客中重要说明下smart-doc的功能,包括使...

上官胡闹
昨天
0
0
JavaEE——Junit

声明:本栏目所使用的素材都是凯哥学堂VIP学员所写,学员有权匿名,对文章有最终解释权;凯哥学堂旨在促进VIP学员互相学习的基础上公开笔记。 Junit Junit又名单元测试,Junit是用来测试Jav...

凯哥学堂
昨天
0
0
读《美丽新世界》

一、背景 十一国庆节从重庆回深圳的时候,做得绿皮车,路上看了两本书:李笑来的《韭菜的自我修养》和禁书《美丽新世界》。 上篇文章已经分享了 读《韭菜的自我修养》,这篇文章来记录一下《...

tiankonguse
昨天
0
0
archlinux下基于Jenkins,docker实现自动化部署(持续交互)

本文永久更新地址:https://my.oschina.net/bysu/blog/2250954 【若要到岸,请摇船:开源中国 不最醉不龟归】 -----------------------------------第一部分Jenkins的安装与使用-----------...

不最醉不龟归
昨天
0
0
Spark Parquet file split

在实际使用 spark + parquet 的时候, 遇到了两个不解的地方: 我们只有一个 parquet 文件(小于 hdfs block size), 但是 spark 在某个 stage 生成了4个 tasks 来处理. 4个 tasks 中只有一个 ta...

Aaaaaaaron
昨天
0
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部