Python 核心数据类型

Python的核心数据类型

内置对象 例子 常量/创建
Number 数字 12,3.14,3+4j
String 字符串 ‘hello’,”I’m ok”
List 列表 [1,[2,’three’],4]
Dictionaries 字典 {‘food’: ‘spam’, ‘taste’: ‘yum’}
Tuple 元组 (1,’spam’, 4, ‘U’)
File 文件 myfile = open(‘eggs’, ‘r’)
Set 集合 set(‘abc’),{‘a’,’b’,’c’}
其他 类型 类型、none、布尔型
编程单元 类型 函数、模块、类
与实现相关 类型 编译的代码堆栈跟踪

前面我们学习了数字,字符串,文件三种数据类型,接下来我们将一起学习其他高级数据类型。

列表

Python内置的一种数据类型是列表:list。list是一种有序的集合,可以随时添加和删除其中的元素。

列出班里所有同学的名字,就可以用一个list表示:

In [1]: classmates = ['batman','superman','green']

In [2]: classmates
Out[2]: ['batman', 'superman', 'green']

变量classmates就是一个list。用len()函数可以获得list元素的个数:

In [3]: len(classmates)
Out[3]: 3

用索引来访问list中每一个位置的元素,记得索引是从0开始的:

In [4]: classmates[0]
Out[4]: 'batman'

In [5]: classmates[1]
Out[5]: 'superman'

In [6]: classmates[2]
Out[6]: 'green'

In [7]: classmates[3]
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-7-f6229a45910c> in <module>()
----> 1 classmates[3]

IndexError: list index out of range

当索引超出了范围时,Python会报一个IndexError错误,所以,要确保索引不要越界,记得最后一个元素的索引是len(classmates) - 1

如果要取最后一个元素,除了计算索引位置外,还可以用-1做索引,直接获取最后一个元素:

In [8]: classmates[-1]
Out[8]: 'green'

以此类推,可以获取倒数第2个、倒数第3个:

In [10]: classmates[-1]
Out[10]: 'green'

In [11]: classmates[-3]
Out[11]: 'batman'

In [12]: classmates[-4]
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-12-99b9a0b8ac95> in <module>()
----> 1 classmates[-4]

IndexError: list index out of range

当然,倒数第4个就越界了。

list是一个可变的有序表,所以,可以往list中追加元素到末尾:

In [13]: classmates.append('supergirl')

In [14]: classmates
Out[14]: ['batman', 'superman', 'green', 'supergirl']

也可以把元素插入到指定的位置,比如索引号为1的位置:

In [15]: classmates.insert(1,'leo')

In [16]: classmates
Out[16]: ['batman', 'leo', 'superman', 'green', 'supergirl']

要删除list末尾的元素,用pop()方法:

In [17]: classmates.pop()
Out[17]: 'supergirl'

In [18]: classmates
Out[18]: ['batman', 'leo', 'superman', 'green']

要删除指定位置的元素,用pop(i)方法,其中i是索引位置:

In [18]: classmates
Out[18]: ['batman', 'leo', 'superman', 'green']

In [19]: classmates.pop(1)
Out[19]: 'leo'

In [20]: classmates
Out[20]: ['batman', 'superman', 'green']

要把某个元素替换成别的元素,可以直接赋值给对应的索引位置:

In [21]: classmates[1] = 'oracle'

In [22]: classmates
Out[22]: ['batman', 'oracle', 'green']

list里面的元素的数据类型也可以不同,比如:

In [23]: L = ['apple',1,True]

list元素也可以是另一个list,比如:

In [24]: S = ['python',['java','shell'],'awk']

In [25]: len(S)
Out[25]: 3

要注意s只有3个元素,其中s[1]又是一个list,如果拆开写就更容易理解了:

In [26]: T = [L,S,'and']

In [27]: T
Out[27]: [['apple', 1, True], ['python', ['java', 'shell'], 'awk'], 'and']

In [28]: T[0][0]
Out[28]: 'apple'

In [29]: L[0]
Out[29]: 'apple'

要拿到’apple’可以写T[0][0]或者L[0],因此T可以看成是一个二维数组,类似的还有三维、四维……数组,不过很少用到。

如果一个list中一个元素也没有,就是一个空的list,它的长度为0:

In [30]: L = []

In [31]: len(L)
Out[31]: 0
name set
新建列表 testList=[10086,’中国移动’,[1,2,4,5]]
删除列表元素 del testList[0:4]
列表长度 len(testList)
到列表结尾 print testList[1:]
向列表添加元素 testList.append(‘i'm new here!’)
弹出列表的最后一个元素 testList.pop(1)
列表运算 numlist * 2
插入元素 testList[0:2] = [1,0,0,0]
扩展列表 testList.extend([7,8,9,10])
列表反转 testList.reverse()
In [16]: tl = [10086,'zgyd',[1,2,3,4]]

In [17]: len(tl)
Out[17]: 3

In [18]: print tl[1:]
['zgyd', [1, 2, 3, 4]]

In [19]: print tl[0:1]
[10086]

In [20]: print tl[0]
10086

In [21]: print tl[2]
[1, 2, 3, 4]

In [22]: print tl[4]
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-22-3a4496fea863> in <module>()
----> 1 print tl[4]

IndexError: list index out of range

In [23]: print tl[0:9]
[10086, 'zgyd', [1, 2, 3, 4]]

In [25]: tl.append("I'm here!")

In [26]: tl[0:-1]
Out[26]: [10086, 'zgyd', [1, 2, 3, 4]]

In [27]: tl[1:]
Out[27]: ['zgyd', [1, 2, 3, 4], "I'm here!"]

In [28]: tl[0:-1]
Out[28]: [10086, 'zgyd', [1, 2, 3, 4]]

In [29]: tl[-1]
Out[29]: "I'm here!"

In [32]: tl.pop(1)
Out[32]: 'zgyd'

列表的运算

列表也可以进行加和乘。

In [33]: numlist = [1,2,3,4]

In [34]: print numlist
[1, 2, 3, 4]

In [35]: print numlist * 2
[1, 2, 3, 4, 1, 2, 3, 4]

In [36]: alist = ['a','b','c']

In [37]: print numlist + alist
[1, 2, 3, 4, 'a', 'b', 'c']

上面进行了列表的乘法,注意并不是每个元素乘以二,而是整个列表被重复
了两次,重新接合成一个新的列表。

列表操作

In [41]: testlist=[]

In [42]: testlist[0:2]=[1,0,0]

In [43]: print testlist
[1, 0, 0]

In [44]: testlist.append(u'菜鸟')

In [45]: print testlist
[1, 0, 0, u'\u83dc\u9e1f']

In [46]: testlist.sort()

In [47]: print testlist.sort()
None

In [48]: testlist.extend([7,8,9,10])

In [49]: print testlist
[0, 0, 1, u'\u83dc\u9e1f', 7, 8, 9, 10]

In [50]: testlist.reverse()

In [51]: print testlist
[10, 9, 8, 7, u'\u83dc\u9e1f', 1, 0, 0]

In [52]: testlist.pop(0)
Out[52]: 10

In [53]: testlist.pop(1)
Out[53]: 8

In [54]: del testlist[0:4]

In [55]: testlist
Out[55]: [0, 0]

重点:在 list 上调用 sort 之类的函数会造成 list 本身被改变,这个 immutable
的变量是不一样的。一定不能重新赋值,例如:
testList = testList.sort()
将会导致 testList 失去对原对象的引用。

注意引用的问题

用一个例子程序来说明这个问题:

引用,而非拷贝

  • 引用 testList;如果 testList 被改变了,就会影响 newTestList;
  • 但是如果 testList 被重新定义了;就不会影响 newTestList
In [66]: testlist=[1,2,3,4]

In [67]: newtestlist=[9,8,7,6,testlist]

In [68]: newtestlist
Out[68]: [9, 8, 7, 6, [1, 2, 3, 4]]

In [69]: testlist.append(5)

In [70]: newtestlist
Out[70]: [9, 8, 7, 6, [1, 2, 3, 4, 5]]

In [71]: testlist=[100,99]

In [72]: testlist
Out[72]: [100, 99]

In [73]: newtestlist
Out[73]: [9, 8, 7, 6, [1, 2, 3, 4, 5]]

01.png

课堂练习

#!/usr/bin/env python
#-*- coding: utf-8 -*-
shoplist = ['apple', 'mango', 'carrot', 'banana']
print('我有{0} 个东西要买。'.format(len(shoplist)))
print('要买的东西是:')
for item in shoplist:
print('{0} '.format(item))

print('我还需要买rice')
shoplist.append('rice')
print('我现在的购物列表为:{0}'.format(shoplist))

print('接下来我要将购物列表排序')
shoplist.sort()
print('排序后的购物列表为:{0}'.format(shoplist))

print('第一个我要买的东西是:{0}'.format(shoplist[0]))
olditem = shoplist[0]
del shoplist[0]
print('我已经买了{0}'.format(olditem))
print('我现在的购物列表为:{0}'.format(shoplist))

执行结果:

我有4 个东西要买。
要买的东西是:
apple
mango
carrot
banana
我还需要买rice
我现在的购物列表为:['apple', 'mango', 'carrot', 'banana', 'rice']
接下来我要将购物列表排序
排序后的购物列表为:['apple', 'banana', 'carrot', 'mango', 'rice']
第一个我要买的东西是:apple
我已经买了apple
我现在的购物列表为:['banana', 'carrot', 'mango', 'rice']

元组

另一种有序列表叫元组:tuple。tuple和list非常类似,但是tuple一旦初始化就不能修改.

name set
新建元组 classmates = (‘Michael’, ‘Bob’, ‘Tracy’)
删除元组 del classmates

比如同样是列出同学的名字:

In [1]: classmates = ('Michael', 'Bob', 'Tracy')

In [2]: classmates
Out[2]: ('Michael', 'Bob', 'Tracy')

现在,classmates这个tuple不能变了,它也没有append()insert()这样的方法。其他获取元素的方法和list是一样的,你可以正常地使用classmates[0]classmates[-1],但不能赋值成另外的元素。

不可变的tuple有什么意义?因为tuple不可变,所以代码更安全。如果可能,能用tuple代替list就尽量用tuple。

tuple的陷阱:当你定义一个tuple时,在定义的时候,tuple的元素就必须被确定下来,比如:

In [3]: t = (1,2)

In [4]: t
Out[4]: (1, 2)

如果要定义一个空的tuple,可以写成():

In [5]: t = ()

In [6]: t
Out[6]: ()

但是,要定义一个只有1个元素的tuple,如果你这么定义:

In [7]: t = (1)

In [8]: t
Out[8]: 1

定义的不是tuple,是1这个数!这是因为括号()既可以表示tuple,又可以表示数学公式中的小括号,这就产生了歧义,因此,Python规定,这种情况下,按小括号进行计算,计算结果自然是1。

所以,只有1个元素的tuple定义时必须加一个逗号,,来消除歧义:

In [9]: t = (1,)

In [10]: t
Out[10]: (1,)

Python在显示只有1个元素的tuple时,也会加一个逗号,,以免你误解成数学计算意义上的括号。

最后来看一个“可变的”tuple:

In [11]: t = ('a','b',['A','B'])

In [12]: t[2][0]
Out[12]: 'A'

In [14]: t[2][1]
Out[14]: 'B'
In [15]: t[2][0] = 'X'

In [16]: t[2][1] = 'Y'

In [17]: t
Out[17]: ('a', 'b', ['X', 'Y'])

这个tuple定义的时候有3个元素,分别是’a’,’b’和一个list。不是说tuple一旦定义后就不可变了吗?怎么后来又变了?

别急,我们先看看定义的时候tuple包含的3个元素:

03.png

当我们把list的元素’A’和’B’修改为’X’和’Y’后,tuple变为:

04.png

表面上看,tuple的元素确实变了,但其实变的不是tuple的元素,而是list的元素。tuple一开始指向的list并没有改成别的list,所以,tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。即指向’a’,就不能改成指向’b’,指向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的!

理解了“指向不变”后,要创建一个内容也不变的tuple怎么做?那就必须保证tuple的每一个元素本身也不能变。

小结

list和tuple是Python内置的有序集合,一个可变,一个不可变。根据需要来选择使用它们。


字典

name set
新建字典 testDict={ ‘time’:’时间’,’machine’:’机器’,’time machine’:’时间机器’}
输出字典key的value testDict[‘time’]
删除字典or key del testDict[‘a’]
删除key d.pop(‘Bob’)

Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快的查找速度。

举个例子,假设要根据同学的名字查找对应的成绩,如果用list实现,需要两个list:

  • names = ['Michael', 'Bob', 'Tracy']
  • scores = [95, 75, 85]

给定一个名字,要查找对应的成绩,就先要在names中找到对应的位置,再从scores取出对应的成绩,list越长,耗时越长。

如果用dict实现,只需要一个“名字”-“成绩”的对照表,直接根据名字查找成绩,无论这个表有多大,查找速度都不会变慢。用Python写一个dict如下:

In [18]: d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}

Out[20]: 95

为什么dict查找速度这么快?因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字,我们要查某一个字,一个办法是把字典从第一页往后翻,直到找到我们想要的字为止,这种方法就是在list中查找元素的方法,list越大,查找越慢。

第二种方法是先在字典的索引表里(比如部首表)查这个字对应的页码,然后直接翻到该页,找到这个字,无论找哪个字,这种查找速度都非常快,不会随着字典大小的增加而变慢。

dict就是第二种实现方式,给定一个名字,比如’Michael’,dict在内部就可以直接计算出Michael对应的存放成绩的“页码”,也就是95这个数字存放的内存地址,直接取出来,所以速度非常快。

你可以猜到,这种key-value存储方式,在放进去的时候,必须根据key算出value的存放位置,这样,取的时候才能根据key直接拿到value。

把数据放入dict的方法,除了初始化时指定外,还可以通过key放入:

In [21]: d['Adam'] = 67

In [22]: d['Adam']
Out[22]: 67

由于一个key只能对应一个value,所以,多次对一个key放入value,后面的值会把前面的值冲掉:

In [23]: d['Jack'] = 90

In [24]: d['Jack']
Out[24]: 90

In [25]: d['Jack'] = 88

In [26]: d['Jack']
Out[26]: 88

如果key不存在,dict就会报错:

In [27]: d['Thomas']
\---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-27-d933a34735ff> in <module>()
\----> 1 d['Thomas']

KeyError: 'Thomas'

要避免key不存在的错误,有两种办法,一是通过in判断key是否存在:

In [28]: 'Thomas' in d
Out[28]: False

二是通过dict提供的get方法,如果key不存在,可以返回None,或者自己指定的value:

In [29]: d.get('Thomas')

In [30]: d.get('Thomas',-1)
Out[30]: -1

注意:返回None的时候Python的交互式命令行不显示结果。

要删除一个key,用pop(key)方法,对应的value也会从dict中删除:

In [31]: d
Out[31]: {'Adam': 67, 'Bob': 75, 'Jack': 88, 'Michael': 95, 'Tracy': 85}

In [32]: d.pop('Bob')
Out[32]: 75

In [33]: d
Out[33]: {'Adam': 67, 'Jack': 88, 'Michael': 95, 'Tracy': 85}

请务必注意,dict内部存放的顺序和key放入的顺序是没有关系的。

和list比较,dict有以下几个特点:

  • 查找和插入的速度极快,不会随着key的增加而增加;
  • 需要占用大量的内存,内存浪费多。

而list相反:

  • 查找和插入的时间随着元素的增加而增加;
  • 占用空间小,浪费内存很少。

所以,dict是用空间来换取时间的一种方法。

dict可以用在需要高速查找的很多地方,在Python代码中几乎无处不在,正确使用dict非常重要,需要牢记的第一条就是dict的key必须是不可变对象。

这是因为dict根据key来计算value的存储位置,如果每次计算相同的key得出的结果不同,那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法(Hash)。

要保证hash的正确性,作为key的对象就不能变。在Python中,字符串、整数等都是不可变的,因此,可以放心地作为key。而list是可变的,就不能作为key:

In [34]: key = [1, 2, 3]

In [35]: d[key] = 'a list'

---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-35-24a3c62d5559> in <module>()
----> 1 d[key] = 'a list'

TypeError: unhashable type: 'list'


集合

name set
新建集合 s = set([1, 2, 3])
添加元素 s.add(key)
删除元素 s.remove(key)
交集、并集 “&|”

set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。

要创建一个set,需要提供一个list作为输入集合:

In [36]: s = set([1, 2, 3])

In [37]: s
Out[37]: set([1, 2, 3])

注意,传入的参数[1, 2, 3]是一个list,而显示的set([1, 2, 3])只是告诉你这个set内部有1,2,3这3个元素,显示的[]不表示这是一个list。

重复元素在set中自动被过滤:

In [38]: s = set([1, 1, 2, 2, 3, 3])

In [39]: s
Out[39]: set([1, 2, 3])

通过add(key)方法可以添加元素到set中,可以重复添加,但不会有效果:

In [40]: s.add(4)

In [41]: s
Out[41]: set([1, 2, 3, 4])

通过remove(key)方法可以删除元素:

In [42]: s.remove(4)

In [43]: s
Out[43]: set([1, 2, 3])

set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集等操作:

In [44]: s1 = set([1,2,3])

In [45]: s2 = set([2,3,4])

In [46]: s1 & s2
Out[46]: set([2, 3])

In [47]: s1 | s2
Out[47]: set([1, 2, 3, 4])

set和dict的唯一区别仅在于没有存储对应的value,但是,set的原理和dict一样,所以,同样不可以放入可变对象,因为无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”。试试把list放入set,看看是否会报错。

再议不可变对象

上面我们讲了,str是不变对象,而list是可变对象。

  • 对于可变对象,比如list,对list进行操作,list内部的内容是会变化的
  • 虽然字符串有个replace()方法,也确实变出了’Abc’,但变量a最后仍是’abc’,应该怎么理解呢?
  • 要始终牢记的是,a是变量,而’abc’才是字符串对象!有些时候,我们经常说,对象a的内容是’abc’,但其实是指,a本身是一个变量,它指向的对象的内容才是’abc’
  • 当我们调用a.replace(‘a’, ‘A’)时,实际上调用方法replace是作用在字符串对象’abc’上的,而这个方法虽然名字叫replace,但却没有改变字符串’abc’的内容。相反,replace方法创建了一个新字符串’Abc’并返回,如果我们用变量b指向该新字符串,就容易理解了,变量a仍指向原有的字符串’abc’,但变量b却指向新字符串’Abc’了:

所以,对于不变对象来说,调用对象自身的任意方法,也不会改变该对象自身的内容。相反,这些方法会创建新的对象并返回,这样,就保证了不可变对象本身永远是不可变的。

小结

  • 使用key-value存储结构的dict在Python中非常有用,选择不可变对象作为key很重要,最常用的key是字符串。
  • tuple虽然是不变对象,但试试把(1, 2, 3)和(1, [2, 3])放入dict或set中,并解释结果。

课后习题

列表和字典

python完成

  1. 举出两种方法来创建内含五个整数领的列表
  2. 举出两种方法来创建一个字典,由两个健’a’和’b’,而且每个健相关联的值都是0
  3. 举出四种在原处修改列表对象的运算
  4. 举出四种在原处修改字典对象的运算

习题解答

  1. [0,0,0,0][0] * 5
  2. {'a':0,'b':0}D={};D['a']=0;D['b']=0
  3. append()增加元素;extend()增长列表;sort()排序列表;reverse()翻转
  4. 字典的修改主要是赋值新的见或已存在的健。D['c']=0 del D['a'] D.pop(key)

元组

python完成

  1. 你怎么确定元组多大?
  2. 写一个表达式,修改元组中的第一个元素。在此过程中,(4,5,6)应该变为(1,5,6)

习题解答

  1. len(T)
  2. 无法修改元组,但可以通过表达式重新赋值:T=(4,5,6);T=(1,)+T[1:] ;可以将元组转变为列表,修改后的列表转化为元组:T=(4,5,6);L=list(T);L[0]=1;T=tuple(L)

总习题

基础——打开ipython交互式模式解释器,输入以下表达式,然后试着说明每种情况所产生的结果:

2 ** 16
2 / 5, 2 / 5.0
"spam" + "eggs"
S = "ham"
"eggs " + S
S * 5
S[:0]
"green %s and %s" % ("eggs", S)
'green {0} and {1}'.format('eggs', S)
('x',)[0]
('x', 'y')[1]
L = [1,2,3] + [4,5,6]
L, L[:], L[:0], L[−2], L[−2:]
([1,2,3] + [4,5,6])[2:4]
[L[2], L[3]]
L.reverse(); L
L.sort(); L
L.index(4)
{'a':1, 'b':2}['b']
D = {'x':1, 'y':2, 'z':3}
D['w'] = 0
D['x'] + D['w']
D[(1,2,3)] = 4
list(D.keys()), list(D.values()), (1,2,3) in D
[[]], ["",[],(),{},None]

索引和分片运算——ipython交互模式下,定义一个名为L的列表,内含四个字符串或数字(例如,L=[0,1,2,3])。然后,实验一些边界情况,你可能不会在真实的程序种看到这些例子,但是它们用来促使你思考底层的模型,并且其中一些可能在较少的人为编写的形式种有用:

L[4]
L[-1000:100]
L[3:1]
L[3:1]=['?']
  • 索引值超过边界,会如何?
  • 分片运算超出边界会如何?
  • 反向抽取序列,当较低边界值大于高边界值会如何?
  • 试着赋值到上题分片,看看此值将置于何处?
  • 你觉得这和分片超出边界是相同现象吗?

索引运算、分片运算以及del——定义另一个列表L,有四个元素,然后赋值给一个空列表给器偏移值之一(例如,L[2]=[]),发生什么事?然后,赋值空列表个分片L[2:3]=[]。现在,发生了什么?回想以下,分片赋值运算删除分片,并将新值插入分片曾经的地方。

del会删除偏移量、健、属性以及名称。将其用在列表上来删除一个元素del L[0]。如果你删除整个分片,会发生什么del L[1:] ?当你赋值非序列给分片时,会发生什么变化L[1:2]=1

  1. 元祖赋值运算——输入下面几行:X='spam';Y='eggs';X,Y=Y,X,你觉得X和Y会发生什么变化?
  2. 文件——写一个脚本,创建名为myfile.txt的新的输出文件,把字符串"Hello file word!"写入。然后写另一个脚本,开启myfile.txt,把其内容取出来并将其打印出来。

从系统命令行执行你的两个脚本。

新文件是否出现在执行脚本所在目录?

如果对开启的文件名新增不同的目录路径,有会怎样?

#!/usr/bin/env python

S="Hello file word!\n"
with open('myfile.txt','w') as f:
f.write(S)
print open('myfile.txt').read()

总结

数据类型之间的转换
数字---字符串 '%d'%num
字符串---数字 str.atoi()
字符串---list import string string.split()
list---tuple tuple(list)
tuple---list list(tuple)
list---字符串 'str'.join(list)
dict---》list dic.items()
文件---》list open('file').readlines()
文件---》string open('file').read()