Python数据结构与算法--数据类型

erlchina

从数据类型开始
　　Python支持面向对象的编程范式，这意味着Python把数据看成解决问题的关键. 在Python中,类似其他的面向对象的编程语言, 我们定义一个类，用来描述数据是什么 (状态) 和数据能做些什么 (行为). 类和抽象数据类型相似，因为一个类的用户只看数据项的状态和行为. 数据项在面向对象编程中被称为对象. 对象是类的实例.
　　本文地址：http://www.iyunv.com/archimedes/p/python-datastruct-algorithm-basedatatypes.html，转载请注明源地址。

内置的原子数据类型
　　我们从原子数据类型开始我们的回顾. Python有两种主要的内建数据类：int和float. 标准的算术操作：+, -, *, /, and ** (幂运算), 可以使用括号改变运算优先级.其他非常有用的操作符为取余运算%, 和整数除法运算//. 注意：当两个整数相除的时候，结果是一个浮点型数. 整数除法操作返回截断小数之后的整数部分.



>>> print 2+3*4
14
>>> print (2+3)*4
20
>>> print 2**10
1024
>>> print 6/3
2
>>> print 7/3
2
>>> print 7//3
2
>>> print 7%3
1
>>> print 3/6
0
>>> print 3//6
0
>>> print 3%6
3
>>> print 2**100
1267650600228229401496703205376
　　boolean类型,由Python的 bool 类提供实现,在表示真值的时候非常有用. 对于一个boolean对象而言，只有两个值：True and False，标准的boolean类型操作： and, or, 和not.



>>> True
True
>>> False
False
>>> False or True
True
>>> not (False or True)
False
>>> True and True
True
　　Boolean数据对象也被用于表示比较运算符的结果，比如：相等 (==) 和大于 (>). 另外, 关系运算符和逻辑运算符可以组合在一起来解决复杂的逻辑问题. 表1 展示了逻辑关系操作，后面还展示了相关的例子.

表1 : 逻辑与关系操作

      操作名       操作符说明



小于

大于操作符


小于等于
=
大于等于操作符


等于
==
等于操作符


不等于
!=
不等于操作符


逻辑与
and
两个同时为True时候才为True


逻辑或
or
两个中至少有一个为True，结果为True


逻辑非
not
否定, False 变为True, True 变为False
　　示例代码：



>>> print(5==10)
False
>>> print(10 > 5)
True
>>> print((5 >= 1) and (5 >> theSum = 0
>>> theSum
0
>>> theSum += 1
>>> theSum
1
>>> theSum = True
>>> theSum
True
内建集合数据类型
　　作为数据类型和布尔类型的补充, Python还有一些内建的集合类型. Lists, strings, 和 tuples（元组）都是有序集合，非常类似普通的结构但是有些特殊的不同点，所以必须理解它们这样才能正确地使用它们. Sets 和 dictionaries 是无序集合.
　　list 是一个空的或多个指向Python数据对象类型的引用. Lists 通常写为用方括号包含的一些用逗号分隔的值. 空表表示为 [ ]. Lists内部的元素可以是不同的数据对象,  下面的例子展示了一个list中不同的数据类型.



>>> [1,3,True,6.5]
[1, 3, True, 6.5]
>>> myList = [1,3,True,6.5]
>>> myList
[1, 3, True, 6.5]
　　当给list赋值的时候, list被返回. 但是, 想在 list上作操, 就需要将其赋值给一个对象.
　　lists 被认为是连续的序列, 它们支持一些可用于其他序列的通用操作. 表2 展示了这些操作，接着给出一些例子来进一步说明它们的应用.

表 2: Python中序列的通用操作

操作名操作符              解释               



索引
[ ]
访问 sequence中的元素


连接
+
合并sequences


重复
*
连续重复次数


成员
in
判断元素是否在quence中


长度
len
计算sequence的长度


分片
[ : ]
给sequence分片
　　注意到lists (序列)的索引从0开始. 取片操作, myList[1:3], 返回list的数据项，起始于1结束但不包含3.有时, 你想初始化一个list. 可以使用重复来快速的完成. 例如,



>>> myList = [0]*6
>>> myList
[0, 0, 0, 0, 0, 0]
　　通过下面的例子很容易理解:



>>> myList = [1,2,3,4]
>>> A=[myList]*3
>>> print(A)
[[1, 2, 3, 4], [1, 2, 3, 4], [1, 2, 3, 4]]
>>> myList[2]=45
>>> print(A)
[[1, 2, 45, 4], [1, 2, 45, 4], [1, 2, 45, 4]]
　　Lists 提供大量用于构建数据结构的方法.表3 提供概要. 接着是一些例子.

表 3: Python中list提供的方法

方法名应用说明



append
alist.append(item)
在list的结尾添加一个项


insert
alist.insert(i,item)
在list的第i个位置插入一个项


pop
alist.pop()
移除并返回list中的最后一个元素


pop
alist.pop(i)
移除并返回list中的第i个位置的元素


sort
alist.sort()
排序修改list


reverse
alist.reverse()
将list倒序操作


del
del alist
删除第i个位置的元素


index
alist.index(item)
返回第一次出现 item 的索引


count
alist.count(item)
返回出现 item 的次数


remove
alist.remove(item)
删除第一次出现的 item
　　list中的方法示例代码：



>>> myList = [1024, 3, True, 6.5]
>>> myList.append(False)
>>> print(myList)
[1024, 3, True, 6.5, False]
>>> myList.insert(2, 4.5)
>>> print(myList)
[1024, 3, 4.5, True, 6.5, False]
>>> print(myList.pop())
False
>>> print(myList)
[1024, 3, 4.5, True, 6.5]
>>> print(myList.pop(1))
3
>>> print(myList)
[1024, 4.5, True, 6.5]
>>> myList.pop(2)
True
>>> print(myList)
[1024, 4.5, 6.5]
>>> myList.sort()
>>> print(myList)
[4.5, 6.5, 1024]
>>> myList.reverse()
>>> print(myList)
[1024, 6.5, 4.5]
>>> print(myList.count(6.5))
1
>>> print(myList.index(4.5))
2
>>> myList.remove(6.5)
>>> print(myList)
[1024, 4.5]
>>> del myList[0]
>>> print(myList)
[4.5]
　　即使像整型这样的对象也可以调用方法如下：



>>> (54).__add__(21)
75
　　上面的代码中我们使整型对象 54 执行 add 方法(称为 __add__ ) 并且传递 21 作为被加数. 结果是它们的和, 75. 当然, 我们通常写作 54+21. 在后面还将详细介绍这个方法.
　　一个Python经常用来连接lists的常见函数： range 函数.range 产生了一个范围内的对象. 通过使用 list 函数, 可以看到list中指定范围内的值，如下面的代码所示：



>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(0, 10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(5,10)
[5, 6, 7, 8, 9]
>>> list(range(5,10))
[5, 6, 7, 8, 9]
>>> list(range(5,10,2))
[5, 7, 9]
>>> list(range(10,1,-1))
[10, 9, 8, 7, 6, 5, 4, 3, 2]
　　Strings 包含0个或多个数字或其他的字符的连续的顺序集合. 我们称这些为字母, 数字和其他的符号字符.



>>> "David"
'David'
>>> myName = "David"
>>> myName[3]
'i'
>>> myName * 2
'DavidDavid'
>>> len(myName)
5
　　既然strings是序列, all of the 上面提到的序列的所有操作都可以使用. 然而, strings 还有一些自身的方法, 如表 4所示. 例如,



>>> myName
'David'
>>> myName.upper()
'DAVID'
>>> myName.center(10)
'  David   '
>>> myName.find('v')
2
>>> myName.split('v')
['Da', 'id']
表 4: Python中Strings 提供的方法

方法名应用说明



center
astring.center(w)
返回一个以 w 为宽度的居中字符串


count
astring.count(item)
返回字符串中包含 item 的个数


ljust
astring.ljust(w)
返回一个以 w 为宽度的左对齐字符串


lower
astring.lower()
返回string的小写形式


rjust
astring.rjust(w)
返回一个以 w 为宽度的右对齐字符串


find
astring.find(item)
返回第一次出现 item 的索引


split
astring.split(schar)
将string以 schar为分隔符划分为子串
　　lists 和 strings的主要区别是 lists 可以修改但是 strings 不能修改. 例如, 你可以通过索引和赋值改变项的值. 对于string不能发生改变.



>>> myList = [1,3,True,6.5]
>>> myList[0] = 2 ** 10
>>> myList
[1024, 3, True, 6.5]
>>> myName = 'David'
>>> myName[0] = 'X'
Traceback (most recent call last):
File "", line 1, in
myName[0] = 'X'
TypeError: 'str' object does not support item assignment
　　Tuples（元组）非常类似于lists，因为它们的元素都可以是不同类型的.不同的是tuple是不可以变的, 就像 string. Tuples是一组用圆括号包围的用逗号分隔的值. 作为序列，你可以使用上面介绍的所有方法. 例如：



>>> myTuple = (2, True, 4.32)
>>> myTuple
(2, True, 4.32)
>>> len(myTuple)
3
>>> myTuple[0]
2
>>> myTuple * 3
(2, True, 4.32, 2, True, 4.32, 2, True, 4.32)
>>> myTuple[0:2]
(2, True)
　　然而，假如你试图修改元组中的元素，就会出错，如下所示.



>>> myTuple[1] = false
Traceback (most recent call last):
File "", line 1, in
myTuple[1] = false
NameError: name 'false' is not defined
　　set 是一个包含0个或多个不可变Python对象的无序集合.  空set 表示为 set(). Sets 的元素类型多样.



>>> {3,6,"cat",4.3,False}
set([False, 3, 4.3, 6, 'cat'])
>>> mySet = {3,6,"cat",4.3,False}
>>> mySet
set([False, 3, 4.3, 6, 'cat'])
表 5: Python中的Set操作

操作名操作说明



成员
in
判断成员


长度
len
返回set中的元素个数


|
aset | otherset
返回一个新的set，作为并集


&
aset & otherset
返回一个新的set，作为交集


-
aset - otherset
返回一个新的set，作为差集


> {3,6,"cat",4.3,False}
set([False, 3, 4.3, 6, 'cat'])
>>> mySet = {3,6,"cat",4.3,False}
>>> mySet
set([False, 3, 4.3, 6, 'cat'])
>>>
>>> mySet = {3,6,"cat",4.3,False}
>>> len(mySet)
5
>>> False in mySet
True
>>> "dog" in mySet
False
>>> yourSet = {3,1,"cat",4.7,False}
>>> mySet | yourSet
set([False, 1, 3, 6, 4.3, 'cat', 4.7])
>>> mySet & yourSet
set([False, 3, 'cat'])
>>> mySet - yourSet
set([4.3, 6])
>>> mySet >> mySet = {False, 4.5, 3, 6, 'cat'}
>>> yourSet = {99, 3, 100}
>>> mySet.union(yourSet)
set([4.5, False, 3, 100, 6, 'cat', 99])
>>> mySet | yourSet
set([4.5, False, 3, 100, 6, 'cat', 99])
>>> mySet.intersection(yourSet)
set([3])
>>> mySet & yourSet
set([3])
>>> mySet.difference(yourSet)
set([4.5, False, 6, 'cat'])
>>> mySet - yourSet
set([4.5, False, 6, 'cat'])
>>> {3, 100}.issubset(yourSet)
True
>>> {3, 100}>> mySet.add("house")
>>> mySet
set([4.5, False, 3, 6, 'house', 'cat'])
>>> mySet.remove(4.5)
>>> mySet
set([False, 3, 6, 'house', 'cat'])
>>> mySet.pop()
False
>>> mySet
set([3, 6, 'house', 'cat'])
>>> mySet.clear()
>>> mySet
set([])
　　Dictionaries（字典）既有方法又有操作. 表7 和 表 8 描述了它们.

[table]表 7: Python中Dictionaries 提供的操作

操作符应用说明



[]
myDict[k]
返回键为 k 的值，否则发生错误


in
key in adict
当key在字典中的时候返回 True 否则返回 False


del
del adict[key]
删除所有的 dictionary 元素



>>> phoneext = {'david':1410, 'brad':1137}
>>> phoneext
{'brad': 1137, 'david': 1410}
>>> phoneext.keys()
['brad', 'david']
>>> phoneext.values()
[1137, 1410]
>>> phoneext.items()
[('brad', 1137), ('david', 1410)]
>>> phoneext.get("kent")
表 8: Python中Dictionaries 提供的方法

方法名应用说明



keys
adict.keys()
返回dictionary中的key


values
adict.values()
返回dictionary中的值


items
adict.items()
返回字典中的所有键-值对


get
adict.get(k)
返回 k 对应的值,否则返回 None


get
adict.get(k,alt)
返回 k 对应的值,否则返回 alt

　　您还可能感兴趣：
　　Python基础（11）--面向对象1
　　Python基础（10）--数字
　　Python基础（9）--正则表达式
　　Python基础（8）--文件
　　Python基础（7）--函数
　　Python基础（6）--条件、循环
　　Python基础（5）--字典
　　Python基础（4）--字符串
　　Python基础（3）--列表和元组
　　Python基础（2）--对象类型
　　Python基础（1）--Python编程习惯与特点