Python语言基础(2)
2018-01-17 18:01
134 查看
5. 结构化数据和序列
Python拥有丰富的结构化的数据类型,这是Python语言的优势所在,掌握这些数据类型,也是学习Python最主要的任务。所谓“结构化数据”,就是把一组数据或对象,用一定的方式组合起来,可以更好地表达真实事物,可以更便捷地处理数据。
5.1 元组Tuple
5.1.1 元组的特征
元组Tuple是一组Python对象序列,三个特征:一维、定长、不可变。元组内的元素可以是各种Python对象,可以是不同的数据类型。
元组常用于固定的数据组合,例如:12个星座的名称:('水瓶座','双鱼座'...)。
创建元组对象,最简单的方法就是一组用逗号隔开的数据,用圆括号包括起来(在不产生歧义的情况下,也可以不用括号)。
In [1]:
tup1 = 1, 2, 3 tup1
Out[1]:
(1, 2, 3)
In [2]:
tup1 = 1, 2, (3, 4) tup1
Out[2]:
(1, 2, (3, 4))
用tuple()函数可以把大部分Python对象转为元组
In [3]:
tuple([4, 0, 2])
Out[3]:
(4, 0, 2)
In [4]:
tup2 = tuple('string') tup2
Out[4]:
('s', 't', 'r', 'i', 'n', 'g')
读取元组的元素,方法与数组类似,就是用“方括号+序号”来读取。与Java等语言类似,Python的序列都是从0开始的
In [5]:
tup2[0]
Out[5]:
's'
元组的不变性,体现在元组创建后,不能再对已有的元素重新赋值,但已有的元素本身是可变的。
In [6]:
tup3 = 'abc', [1, 2], 59 tup3
Out[6]:
('abc', [1, 2], 59)
In [7]:
tup3[2] = 60
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-7-d63b5e6d6b0a> in <module>()
----> 1 tup3[2] = 60
TypeError: 'tuple' object does not support item assignment
In [8]:
tup3[1].append(3) tup3
Out[8]:
('abc', [1, 2, 3], 59)
5.1.2 元组合并
用+加号连接几个不同的元组In [9]:
tup1 + tup2 + tup3
Out[9]:
(1, 2, (3, 4), 's', 't', 'r', 'i', 'n', 'g', 'abc', [1, 2, 3], 59)
元组乘以一个整数,相当于连接了几个副本。
In [10]:
tup1 * 4
Out[10]:
(1, 2, (3, 4), 1, 2, (3, 4), 1, 2, (3, 4), 1, 2, (3, 4))
5.1.3 元组的长度
元组的长度就是元组中元素的个数。某个元素即使拥有很多子元素,也只能算一个元素。In [11]:
tup = (1, 2, (3, 4), 'abc') len(tup)
Out[11]:
4
5.1.4 统计元组中某个数值的个数
In [12]:a = (1, 2, 2, 2, 3, (4, 2)) a.count(2)
Out[12]:
3
5.2 列表 List
5.2.1 列表的特征
列表List的组成方式与元组一样,但它的长度可变,内容也可以修改。创建列表的方法,是用方括号包括一组用逗号隔开的元素。如下:
In [13]:
lst1 = [2, 3.14, True, 'abc', None] lst1
Out[13]:
[2, 3.14, True, 'abc', None]
对已有的某个元素重新赋值。
In [14]:
lst1[1]='x' lst1
Out[14]:
[2, 'x', True, 'abc', None]
5.2.2 列表增加和删除元素
在列表后面追加元素In [15]:
lst1.append('end') lst1
Out[15]:
[2, 'x', True, 'abc', None, 'end']
在某个中间位置插入元素
In [16]:
lst1.insert(2, 'word') lst1
Out[16]:
[2, 'x', 'word', True, 'abc', None, 'end']
按位置标号删除元素。pop与insert互为逆运算
In [17]:
lst1.pop(2) lst1
Out[17]:
[2, 'x', True, 'abc', None, 'end']
按元素的值删除元素。
思考:如果列表中,有多个值相同的元素,这时用remove方法按值删除,会得到什么结果?
In [18]:
lst1.remove('abc') lst1
Out[18]:
[2, 'x', True, None, 'end']
用 in 判断列表中是否包含某数据
In [19]:
'end' in lst1
Out[19]:
True
5.2.3 列表合并
用 + 加号可以合并,形成一个新的列表,原列表的值不变。In [20]:
lst1 + [7, 8, (2, 3)]
Out[20]:
[2, 'x', True, None, 'end', 7, 8, (2, 3)]
用extend()方法,在原列表后追加多个元素。
In [21]:
lst1.extend([7, 8, (2, 3)]) lst1
Out[21]:
[2, 'x', True, None, 'end', 7, 8, (2, 3)]
5.2.4 列表的长度
与元组一样,列表的长度就是列表中元素的个数。注意:如果列表中某个元素也是列表或其他结构化数据,在计算整个列表的长度时,这个列表元素也只能贡献一个长度。
In [22]:
len(lst1)
Out[22]:
8
5.2.5 排序
如果一个列表中都是数值(整数或浮点数)元素,或都是字符串元素时,可以用自带的sort()方法,对其元素进行排序。调用sort()方法排序不生成新的对象,而是取代了旧的对象。所以,如果要保留排序前的列表,可以先把列表赋值给另一个变量名后再排序。默认情况下,sort()方法是按由小到大的顺序排序。
In [23]:
lst2 = [7, 2, 5, 1, 3] lst2.sort() lst2
Out[23]:
[1, 2, 3, 5, 7]
如果想要由大到小排序,可以指定参数 revers=True
In [24]:
lst2.sort(reverse=True) lst2
Out[24]:
[7, 5, 3, 2, 1]
通过设置sort函数的参数,可以按特定的函数值排序。例如对一组字符串按长度进行排序:
In [25]:
lst3 = ['saw', 'small', 'He', 'foxes', 'six'] lst3.sort(key=len) lst3
Out[25]:
['He', 'saw', 'six', 'small', 'foxes']
5.2.6 切片
切片(Slice),是指通过序号选取序列类型(数组、列表、元组等)的子集。切片基本形式是: [ 起始序号 : 结束序号 ]
实际选中的元素序号为:起始序号、起始序号+1、...、结束序号-1
也就是说,起始序号元素是被选中的,而结束序号的元素没有被选中。
注意:Python的序列类型,元素序号都是从0开始的。
In [26]:
lst4 = [0, 1, 2, 3, 4, 5, 6, 7] lst4[1:5]
Out[26]:
[1, 2, 3, 4]
切片时,起始序号空缺表示从0开始,结束序号空缺时,表示直到序列结尾处。
In [27]:
lst4[:5]
Out[27]:
[0, 1, 2, 3, 4]
In [28]:
lst4[3:]
Out[28]:
[3, 4, 5, 6, 7]
“起始序号”和“结束序号”也可以为负数,负数表示从结尾开始切片。“-i”表示从结尾往前数第i个元素(这里从1开始数),其作用效果等价于“序列长度 - i”。
In [29]:
len(lst4)
Out[29]:
8
In [30]:
lst4[-2:]
Out[30]:
[6, 7]
In [31]:
lst4[ len(lst4)-2 : ]
Out[31]:
[6, 7]
In [32]:
lst4[-6 : -2]
Out[32]:
[2, 3, 4, 5]
In [33]:
lst4[len(lst4)-6 : len(lst4)-2]
Out[33]:
[2, 3, 4, 5]
还可以在切片时,再用一个冒号和数字,表示取元素的步长,比如每隔一位取一个元素:
In [34]:
lst4[::2]
Out[34]:
[0, 2, 4, 6]
步长取负数,表示从切片的结尾处开始,按步长取元素。比如步长用-1,可以实现逆序
In [35]:
lst4[::-1]
Out[35]:
[7, 6, 5, 4, 3, 2, 1, 0]
5.3 字典
字典(dict)是Python重要的数据结构之一。字典的特征:字典的元素是一个“key : value”(键 : 值)的组合。其中键和值可以是Python的各种对象。
创建字典用大括号{}把元素包含在内,元素间用逗号隔开,每个元素的key和value之间用冒号隔开。
字典的长度、内容都是是可变的
与列表不同,访问字典内元素的方法,不是用序号,而是用key
字典的键必须是“不可变”对象,比如:标量、字符串、元组等
In [36]:
dct1 = {'a' : 'hello', 'b' : [1, 2, 3, 4]} dct1
Out[36]:
{'a': 'hello', 'b': [1, 2, 3, 4]}
In [37]:
dct1[0] = 'bye' #这里不是表示第0个元素,而是键值为0 dct1
Out[37]:
{'a': 'hello', 'b': [1, 2, 3, 4], 0: 'bye'}
In [38]:
dct1['a'] = 'hi' dct1
Out[38]:
{'a': 'hi', 'b': [1, 2, 3, 4], 0: 'bye'}
用 in 关键字判断字典中是否包含某个key
In [39]:
'b' in dct1
Out[39]:
True
In [40]:
0 in dct1
Out[40]:
True
5.3.1 删除和添加元素
用del关键字或pop()方法删除字典的元素,它们的区别是,pop()方法除了删除元素之外,还返回了被删除的值。In [41]:
dct1[5] = 'some value' dct1['one'] = '某个数值' dct1
Out[41]:
{'a': 'hi', 'b': [1, 2, 3, 4], 0: 'bye', 5: 'some value', 'one': '某个数值'}
In [42]:
del dct1[5] ret = dct1.pop('one') ret
Out[42]:
'某个数值'
In [43]:
dct1
Out[43]:
{'a': 'hi', 'b': [1, 2, 3, 4], 0: 'bye'}
用update()方法对字典增加新元素,或修改原有键的值
In [44]:
dct1.update({'b' : 'new value', 'c' : 12})
dct1
Out[44]:
{'a': 'hi', 'b': 'new value', 0: 'bye', 'c': 12}
5.3.2 获取所有键或值
用字典自带的keys()和values()方法,可以分别获得字典的所有键和值。需要注意的是,这里获取的键和值都是数据集合,一般要再用一个for循环结构才能获得某个键和值。In [45]:
dct1.keys()
Out[45]:
dict_keys(['a', 'b', 0, 'c'])
In [46]:
dct1.values()
Out[46]:
dict_values(['hi', 'new value', 'bye', 12])
In [47]:
for v in dct1.values(): print(v)
hi new value bye 12
5.3.3 从列表创建字典
将两个列表中的元素两两配对地组成一个字典,一个列表的元素成为字典的key,另一个列表的元素成为value。这里可以使用Python内置的zip()函数。
In [48]:
lst1 = [0, 1, 2, 3] lst2 = ['one', 'two', 'three'] dct2 = dict(zip(lst1, lst2)) dct2
Out[48]:
{0: 'one', 1: 'two', 2: 'three'}
5.4 集合Set
集合Set与数学中的集合概念一样,由一组不重复的对象组成。可以看作没有值只有键的字典。集合的特征:集合内的元素可以是各种Python对象,但不能重复
集合内的元素是无序的,不能像list那样用序号访问元素,也不能切片操作
创建一个集合,可以用set()函数,或用大括号把元素包括起来即可。
In [49]:
set1 = {'hello', 1, 4.1} set1
Out[49]:
{1, 'hello', 4.1}
以下例子中可以看出集合元素的唯一性特点
In [50]:
set2 = set([2, 2, 2, 1, 3, 3]) set2
Out[50]:
{1, 2, 3}
集合增加或删除元素。如果把一批对象加进集合中,实际上集合只会吸收那些新的对象,其他重复的对象被忽略掉。
In [51]:
set1.add('abc') set1
Out[51]:
{1, 'hello', 4.1, 'abc'}
In [52]:
set1.add('hello') set1
Out[52]:
{1, 'hello', 4.1, 'abc'}
In [53]:
set1.remove('abc') set1
Out[53]:
{1, 'hello', 4.1}
集合之间可以进行交、并、差等运算,与我们在数学中的集合概念完全一样。
In [54]:
set1 | set2 # 并集
Out[54]:
{1, 2, 'hello', 4.1, 3}
In [55]:
set1 & set2 # 交集
Out[55]:
{1}
In [56]:
set1 - set2 # 差
Out[56]:
{'hello', 4.1}
In [57]:
set1 ^ set2 # 异或(对称差)
Out[57]:
{2, 3, 4.1, 'hello'}
判断两个集合之间是否子集或超集
In [58]:
set3 = {1, 2} set3.issubset(set2)
Out[58]:
True
In [59]:
set2.issuperset(set3)
Out[59]:
True
集合的无序性
In [60]:
{1, 2, 3} == {3, 2, 1}
Out[60]:
True
5.5 元组、列表、字典、集合的遍历
对于本章所学习的元组、列表、字典和集合这几个结构化数据来说,遍历是最常用的操作,而且它们的遍历方法基本一致,就是用for循环实现。元组的遍历
In [61]:
for element in tup1: print(element)
1 2 (3, 4)
In [62]:
for element in lst1: print(element)
0 1 2 3
In [63]:
for element in dct1: print(element)
a b 0 c
In [64]:
for element in dct1.values(): print(element)
hi new value bye 12
In [65]:
for element in set1: print(element)
1 hello 4.1
相关文章推荐
- python自动化--语言基础线程、生产者消费者示例
- python自动化--语言基础四模块、文件读写、异常
- python语言基础之基本数据类型及其运算(2)
- python语言基础问题汇总
- python入门系列(3) -- python语言基础语法
- Python语言基础--4(词频统计)
- Python语言基础学习不错的网站
- 【语言处理与Python】4.3风格的问题/4.4函数:结构化编程的基础/4.5更多关于函数
- 利用百度AI开放平台的语言处理基础技术(Python)
- python学习笔记(一)——python语言基础
- python基础语言
- python初入门:与其他语言略有区别的一些基础知识1
- Python语言基础之常量-变量
- Python语言基础之计时,pickle,列表解析
- Python语言基础--6.1(Json解析)
- Python基础--第3章 语言规则——Python的条条框框
- 【脚本语言系列】关于Python基础知识推导式,你需要知道的事
- 坚持#第229天~零基础自学云计算基础语言应用之python第5节
- python自动化--语言基础三字典、函数、全局/局部变量
- 零基础掌握百度地图兴趣点获取POI爬虫(python语言爬取)(代码篇)