从数据类型开始

Python支持面向对象的编程范式，这意味着Python把数据看成解决问题的关键. 在Python中,类似其他的面向对象的编程语言, 我们定义一个类，用来描述数据是什么 (状态) 和数据能做些什么 (行为). 类和抽象数据类型相似，因为一个类的用户只看数据项的状态和行为. 数据项在面向对象编程中被称为对象. 对象是类的实例.

本文地址：，转载请注明源地址。

内置的原子数据类型

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

>>> print 2+3*414>>> print (2+3)*420>>> print 2**101024>>> print 6/32>>> print 7/32>>> print 7//32>>> print 7%31>>> print 3/60>>> print 3//60>>> print 3%63>>> print 2**1001267650600228229401496703205376

boolean类型,由Python的 bool 类提供实现,在表示真值的时候非常有用. 对于一个boolean对象而言，只有两个值：True and False，标准的boolean类型操作： and, or, 和not.

>>> TrueTrue>>> FalseFalse>>> False or TrueTrue>>> not (False or True)False>>> True and TrueTrue

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 <= 10))True

标识符以名字的形式被用于程序语言. 在Python中, 标识符以字母或一条下划线开始，大小写敏感且可以是任意长度.记住经常使用变量来表达你的意思，使得你的代码更加简单的被阅读和理解.一个 Python 变量被创建一旦被赋予左值. 赋值语句提供了一种联系变量和值的方法. 变量保持一个指向数据区域的引用，并不是数据本身. 看下面的代码:

>>> theSum = 0>>> theSum0>>> theSum += 1>>> theSum1>>> theSum = True>>> theSumTrue

内建集合数据类型

作为数据类型和布尔类型的补充, 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]	删除第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] = falseTraceback (most recent call last):  File "
       
        ", line 1, in 
        
             myTuple[1] = falseNameError: 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}>>> mySetset([False, 3, 4.3, 6, 'cat'])

表 5: Python中的Set操作

操作名	操作	说明
成员	in	判断成员
长度	len	返回set中的元素个数
|	aset | otherset	返回一个新的set，作为并集
&	aset & otherset	返回一个新的set，作为交集
-	aset - otherset	返回一个新的set，作为差集
<=	aset <= otherset	判断第一个集合是否为第二个集合的子集

>>> {3,6,"cat",4.3,False}set([False, 3, 4.3, 6, 'cat'])>>> mySet = {3,6,"cat",4.3,False}>>> mySetset([False, 3, 4.3, 6, 'cat'])>>> >>> mySet = {3,6,"cat",4.3,False}>>> len(mySet)5>>> False in mySetTrue>>> "dog" in mySetFalse>>> yourSet = {3,1,"cat",4.7,False}>>> mySet | yourSetset([False, 1, 3, 6, 4.3, 'cat', 4.7])>>> mySet & yourSetset([False, 3, 'cat'])>>> mySet - yourSetset([4.3, 6])>>> mySet <= yourSetFalse

Sets 提供的方法类似于数学中的集合. 表 6 提供了概要. 例子如下所示：

表 6: Python中Sets提供的方法

方法名	应用	说明
union	aset.union(otherset)	返回一个新的set，元素由两个set的并集组成
intersection	aset.intersection(otherset)	返回一个新的set ，元素由两个set的交集组成
difference	aset.difference(otherset)	返回一个新的set，元素由两个set的差组成
issubset	aset.issubset(otherset)	判断第一个set中的所有元素是不是在第二个set中
add	aset.add(item)	向set中添加元素
remove	aset.remove(item)	从set中删除元素
pop	aset.pop()	从set中删除任意元素
clear	aset.clear()	将set中所有元素删除

>>> mySet = {False, 4.5, 3, 6, 'cat'}>>> yourSet = {99, 3, 100}>>> mySet.union(yourSet)set([4.5, False, 3, 100, 6, 'cat', 99])>>> mySet | yourSetset([4.5, False, 3, 100, 6, 'cat', 99])>>> mySet.intersection(yourSet)set([3])>>> mySet & yourSetset([3])>>> mySet.difference(yourSet)set([4.5, False, 6, 'cat'])>>> mySet - yourSetset([4.5, False, 6, 'cat'])>>> {3, 100}.issubset(yourSet)True>>> {3, 100}<=yourSetTrue>>> mySet.add("house")>>> mySetset([4.5, False, 3, 6, 'house', 'cat'])>>> mySet.remove(4.5)>>> mySetset([False, 3, 6, 'house', 'cat'])>>> mySet.pop()False>>> mySetset([3, 6, 'house', 'cat'])>>> mySet.clear()>>> mySetset([])

Dictionaries（字典）既有方法又有操作. 表7 和 表 8 描述了它们. 

表 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

作者：

出处：

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利.