本节书摘来自异步社区《Abaqus GUI程序开发指南（Python语言）》一书中的第2章，第2.4节,作者： 贾利勇 , 富琛阳子 , 贺高 , 周正光 更多章节内容可以访问云栖社区“异步社区”公众号查看。
2.4 内置对象类型
Python语言中提供了强大的对象类型作为语言的组成部分，内置对象使得程序编写更加容易，并且内置对象往往比自己定制的数据结构更有效率。Python语言中主要有如表2.1所示几类对象类型。
2.4.1 数字
Python语言中的数字类型包括整型、浮点型、复数型等，与一般的C、C++等语言没有太大的区别，以下是几类数字类型的内置对象定义方法。
【实例2.4】定义数字类型
>>>a=5+5 #定义整形数据
>>>a
10
>>> b=5**35 #长整型数据
>>> b
2910383045673370361328125L
>>> c=3.14
>>> c
3.14
>>> n=(5+4j) +(5+8j) #定义复数类型数据
>>>n
(10+12j)
>>>type(n) #查询数据类型
<type 'complex'>
注
符号>>>表示代码在Abaqus GUI命令行交互窗口或者Abaqus PDE命令输入窗口中输入代码，符号>>>不是代码的组成部分。
2.4.2 字符串
字符串型数据一般用单引号或者双引号包络，并且单引号以及双引号必须成对出现。另外，当字符串内部包含有单引号或者双引号时，需要通过转义符“”实现，例如：
>>>Str='what 's up with him' #语法错误
>>>Str='what \'s up with him' #正确格式
>>>Str="what \'s up with him" #正确格式
有关转义字符“”的使用方法读者可以参考其他Python语言的语法书，此处不再赘述。除了转义字符之外，字符串还支持格式化的替代表达，可以用一个变量或者表达式替代字符串中的部分字符，操作符为“%”。
格式化操作符“%”的使用方法如下。
（1）在“%”操作符的左侧放置一个需要进行格式化的字符串，这个字符串带有一个或者多个嵌入的转换目标，都以“%”开头（例如，%、%f、%s等）。
（2）在“%”操作符的右侧放置一个（或多个，多个时需要嵌入到一个元组中）对象，这些对象将会插入到左侧想让Python进行格式化替代的字符串对应位置上去。
以下是格式化操作符的使用实例。
【实例2.5】格式化表达
>>> str='%s, apple' % 'orange'
>>> str
'orange, apple'
>>> n=8
>>> str='%i apples' % n
>>> str
'8 apples'
>>> 'pi=%f, g=%f' % (3.14, 9.18)
'pi=3.140000, g=9.180000'
表2.2所示的是Python语言中的字符串格式化代码，其中大部分与C语言相似，另外，表中一些格式化代码为同一类型的格式化提供了不同的格式选择，例如，%e、%f都可以表示浮点型数据，但是显示格式分别为指数型和浮点型，另外虽然%e和%E都是科学计数法的形式，但是有大小写的区分。
除了单引号和双引号字符串之外，Python中还有一种特殊的三重引号内的字符串常量格式，也被称作块字符串，这是一种对编写多行文本数据来说很便捷的语法。这种字符串以三重引号“'''”开头，并紧跟任意行数的文本，最后以同样的三重引号“'''”作为结尾。
【实例2.6】三重引号的用法
>>> str='''abc
... def
... ghi
... xyz'''
>>> str
'abc\ndef\nghi\nxyz'
可以看出，上述定义的字符串中包含四行，Python会把三重引号内部的文本收集到一起形成一个单独的多行字符串，并在代码换行处嵌入了换行字符“n”。三重引号字符串在程序需要输入多行文本的时候是很有用的，例如嵌入多行注释信息，另外也可以通过三重引号来废除多行代码，使其无效，当需要再次使用该部分代码时，只需要将三重引号去掉即可，这样就避免了每行行首都需要添加“#”注释带来的不便。例如：
【实例2.7】使用三重引号注释以及废除代码
'''以下几行代码的主要作用是创建菜单栏
并在菜单栏添加子菜单'''
menu = AFXMenuPane(self)
AFXMenuTitle(self, '主菜单', None, menu)
AFXMenuCommand(self, menu, '子菜单一',
afxCreatePNGIcon(r"icon\icon1.PNG"),
myForm1(self), AFXMode.ID_ACTIVATE)
AFXMenuCommand(self, menu, '子菜单二',
afxCreatePNGIcon(r"icon\icon2.PNG"),
myForm2(self), AFXMode.ID_ACTIVATE)
'''
subMenu = AFXMenuPane(self)
AFXMenuCascade(self, menu, '子菜单三', None, subMenu)
AFXMenuCommand(self, subMenu, '子项目1', None,
self, AFXMode.ID_ACTIVATE)
AFXMenuCommand(self, subMenu, '子项目2', None,
self, AFXMode.ID_ACTIVATE)
'''
另外，在使用Python读取文本时，经常需要按照一定的规则将每一行数据拆分成一系列子字符串，这种情况下通常需要使用split()函数来实现对一个长字符串的切分。
【实例2.8】split()分割字符串
>>> A="a b c d e f"
>>> B= A.split() #以空格键对字符串进行分割
>>> B
['a', 'b', 'c', 'd', 'e', 'f']
上述情况下，字符串内部两个非空字符间的空格数量对分割结果没有影响，例如：
>>> A="a b c d e f"
>>> B
['a', 'b', 'c', 'd', 'e', 'f']
另外，当字符串中有具有分隔特征的符号时，例如逗号或者分号等，可以使用这些分隔符号对字符串进行分割。但是需要注意的是，当使用特定的分隔符进行分割时，空字符不会被忽略。
>>> A="a;b; c; d; e ;f"
>>> B= A.split(";") #用分号进行切分
>>> B
['a', 'b', ' c', ' d', ' e ', 'f']
>>> A="a,b, c, d, e, f"
>>> B= A.split(",") #用逗号进行切分
>>> B
['a', 'b', ' c', ' d', ' e', ' f'] #空字符未忽略
2.4.3 元组
元组型数据（tuple）由一系列元素组成，且对每个元素的数据类型不做限制，可以使用字符串、整型、浮点型的混合。元组在建立时，以小括号包括逗号（，）进行间隔，并且可以是多维数据。元组中的元素一旦确定是不允许修改的。
【实例2.9】元组的定义及使用
>>> one=('A')
>>> type(one)
<type 'str'>
注意上述代码中，小括号内没有逗号，所定义的类型为字符串型。
>>> one=('A',)
>>> type(one)
<type 'tuple'>
小括号内添加逗号，所定义类型便成为元组型。
>>> pets=(("dog",2),("cat",3),("hamster",5)) #创建多维元组
>>> len(pets)
3 #其长度是按照第一维数据计算
>>> pets[2][0] #调用元组中的某一个数据
'hamster'
2.4.4 列表
列表型数据（list）指的是能够存储有序元组的数据结构，在Python语言中，列表中的所有元素都包括在方括号[]内，各元素之间使用逗号分割。与元组不同的是，用户可以对列表中的元素进行添加、删除、修改等操作，因此，列表是可操作的数据结构。
【实例2.10】列表的定义
>>>fruits=["apple","pear","medlar","lopuat","",] #定义一维列表
>>> fruits
['apple', 'pear', 'medlar', 'lopuat', '']
>>> len(fruits) #计算列表长度
5
>>> fruits=[["apple","pear","medlar","lopuat",""],["apple","pear","medlar","lopuat"]]
>>> len(fruits) # 定义二维列表，并计算其长度
2
>>>fruits[1][3]
'lopuat'
与元组型数据不同的是，列表末尾加不加逗号没有区别，列表中即使只有一个元素也是列表型数据，例如：
>>> fruits=["apple","pear","medlar","lopuat",""] #末尾不加逗号
>>> fruits
['apple', 'pear', 'medlar', 'lopuat', '']
>>> len(fruits) #长度相同
5
>>> fruits=["apple"] #单元素列表
>>> type(fruits)
<type 'list'>
【实例2.11】列表的操作
>>> myList = [0,1,2,1,2,3,2,3,4,3,4,5]
>>> myList.count(2) #返回某一元素在list中出现的次数
3
>>> myList.index(5) #返回某一元素在list中首次出现的索引号
11
>>> myList.index(4) #当某一元素多次出现时，返回其首次出现时的索引号
8
>>> myList.insert(2,22) #在列表中指定位置插入元素
>>> myList
[0, 1, 22, 2, 1, 2, 3, 2, 3, 4, 3, 4, 5]
>>> myList.reverse() #对列表中的元素反序排列
>>> myList
[5, 4, 3, 4, 3, 2, 3, 2, 1, 2, 22, 1, 0]
>>> myList.sort() #对列表中元素进行排序
>>> myList
[0, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 22]
>>> myList
[1, 9, 3]
>>> myList.append(33) #在列表末尾添加新元素
>>> myList
[1, 9, 3, 33]
>>> myList.remove(9) #移除列表中的元素
>>> myList
[1, 3, 33]
2.4.5 字典
字典型数据（dictionaries）是Python之中最灵活的内置数据结构类型，如果把列表看作是有序的对象集合，那么就可以把字典当成是无序的集合。两者的主要区别在于，在字典中元素是通过键来存取的，而不是通过顺序索引号来存取，字典中的元素没有特定的顺序，各个元素从左到右随机排列，以便快速查找，键提供的是字典中元素的象征性位置（非物理存储位置）。
字典型数据用大括号{}包络，字典中的每一组元素都包含数据键key和数值value两部分，两者之间以冒号间隔，冒号前面是键key，后面是数值value。key是独一无二的，且不可改变，可以是字符串型、整型、浮点型或者元组等多种类型。字典中的两个元素之间用逗号隔开。当需要访问字典中的某一元素时，需要通过索引数据键来获取其对应的数据值。
【实例2.12】字典的定义
（1）dictionaries型数据以大括号包括逗号进行间隔。
>>> insects={"AAA":5000,"BBB":200,"CCC":1200} #定义包含3个元素的字典
>>> insects["AAA"] #获取键"AAA"所对应的值
5000
另外，也可以采用以下方式对字典进行定义。
>>> insects=dict(AAA=5000,BBB=200,CCC=1200)
>>> insects
{'AAA': 5000, 'BBB': 200, 'CCC': 1200}
（2）dictionaries型数据以tuples作为key。
>>> points3d={(3,7,2):"green",(4,4,6):"blue",(2,8,9):"yellow"}
>>> points3d[(3,7,2)]
'green'
【实例2.13】字典的操作
dictionaries型数据调用keys()、values()、items()函数。
>>> dict1=dict(AAA=5000,BBB=200,CCC=1200)
>>>v1= dict1.keys() #获取字典的所有键值
>>> v1
['AAA', 'BBB', 'CCC']
>>> dict1.items() #获取字典所有元素
[('AAA', 5000), ('BBB', 200), ('CCC', 1200)]
>>> dict1.items()[0] #获取字典中某一元素
('AAA', 5000)
>>> dict1.items()[0][1] #获取字典中某一元素的键或者值
5000
>>> dict1.values() #获取字典中的所有值
[5000, 200, 1200]
>>> del(dict1 ["AAA"]) #删除字典中某一键值对
>>> dict1
{'BBB': 200, 'CCC': 1200}
>>> dict1["DDD"]=999 #字典中添加新元素
>>> dict1
{'BBB': 200, 'CCC': 1200, 'DDD': 999}
>>> dict1.pop("CCC") #pop函数，返回某键对应的值，并在字典中删除该键值对
1200
>>> dict1
{'BBB': 200, 'DDD': 999}
>>> dict1.clear() #清空字典
>>> dict1
{}
2.4.6 集合
集合（set）又分为普通set和frozenset两类，都是无序的，都不属于sequence类型。set类型数据是可以改变的，可以增加、删除元素。frozenset是不可变的，frozenset可以作为字典的键。
set中的数据都是独一无二的，如果某一set中已经含有了某数据，则使用add()函数时，不会再增添一个。
【实例2.14】集合的定义
>>> set_fox=set(("AA","BB","CC")) #定义普通set
>>> set_fox=frozenset(("AA","BB","CC")) #定义frozenset
>>> "AA" in set_fox #判断set中是否包含某一项
True
set类型数据与元组和列表等不同的是，集合中的元素不支持索引，例如：
>>> set_fox[1]
TypeError: 'set' object does not support indexing #报错
【实例2.15】集合的操作
>>> set_fox.add("DD") #集合中添加新元素
>>> set_fox
set(['AA', 'CC', 'DD', 'BB'])
>>> set_fox.remove('AA') #删除集合中的元素
>>> set_fox
set(['CC', 'DD', 'BB'])
>>> set_fox.clear() #清空集合元素
>>> set_fox
set([])
2.4.7 布尔型
Python的布尔类型扩展了Python中真假的概念，布尔类型有True或者False两个变量值，一般Python中判断语句的判断结果不使用1和0来表征判断结果的真假，而是采用布尔型的True或者False来表征。
Python提供了一个内置的bool函数，它可以测试一个对象的布尔值，当一个对象为0或者空值时，测试结果为False，当对象为非零或非空时，测试结果为True。
【实例2.16】布尔型
>>> bool([]) #空值
False
>>> bool(['']) #含空字符串的非空列表
True
>>> bool(1) #非零
True
>>> bool(0) #零值
False
2.4.8 None型
除了上述内置对象类型之外，Python还有一个特殊对象：None。一般起到一个空的占位作用，类似于C语言中的NULL。None是一个真正的对象，并且真用内存空间。一般对于一个自定义函数，当不使用return指定其返回值时，默认地会返回None。另外，也可以通过None占用内存实现对可变对象的预分配。
【实例2.17】None型
>>> X=[None]*999
>>> X
[None, None, None, None,…, None, None]
2.4.9 数据格式转换
前面讲述的数据结构中，有多种数据类型是可以对其数据格式进行转换的。下面将介绍几种常用的数据转换函数。
【实例2.18】数据格式转换
（1）将字符串类型转化为列表类型
>>> myString='noise'
>>> myList = list(myString)
>>> myList
['n', 'o', 'i', 's', 'e']
>>> myList[0] = 'p' #将列表中第一元素重新赋值。
>>> myList
['p', 'o', 'i', 's', 'e']
（2）将字符串类型转化为元组类型
>>> myTuple = tuple(myString)
>>> myTuple
('n', 'o', 'i', 's', 'e')
（3）将元组转化为列表
>>> mylist=list(myTuple)
>>> mylist
['n', 'o', 'i', 's', 'e']
（4）将浮点型转化为整型
>>> a=3.1415
>>> b=int(a)
>>> b
3
（5）将整型转化为浮点型
>>> c=float(b)
>>> c
3.0
（6）将浮点型数据转化为字符串
>>> c=3.0
>>> str(c)
'3.0'
（7）返回ASCII码对应的字符
>>> print chr(65)
A
>>> print chr(66)
B
>>> print chr(65)+chr(66)
AB
>>>
（8）把字符串或者数字转化为复数
>>> a=complex("2+5j") #将字符串转化为复数
>>> a
(2+5j)
>>> b=complex(2,5) #将数字转化为复数
>>> b
(2+5j)
（9）将整数转化为十六进制数或者八进制数
>>> hex(25) #将整数转化为十六进制数
'0x19'
>>> oct(25) #将整数转化为八进制数
'031'
（10）将字符串或者数字转化为长整型数据
>>> long("123") #将字符串转化为长整型
123L
>>> long(123) #将整数转化为长整型
123L
>>> long(123.5) #将浮点型数据转化为长整型
123L
2.4.10 对象查询与索引
读者可以使用type()函数来查询某对象的数据类型，也可以通过min()和max()函数查询元组或者列表中数据的最小值或最大值。另外还可以通过index()函数查询某个索引号对应的元素值等，下面将简单介绍几种常用的对象操作函数。
【实例2.19】对象查询与索引
（1）type()函数
>>> type(123)
<type 'int'>
>>> type(123.4)
<type 'float'>
>>> type(123+5j)
<type 'complex'>
>>> type("hello")
<type 'str'>
>>> type([1,2,3])
<type 'list'>
>>> type((1,2,3))
<type 'tuple'>
（2）min()函数和max()函数
>>> min(1,2,3,4,5) #获取最小值
1
>>> max(1,2,3,4,5) #获取最大值
5
（3）index()函数
>>> a=[111,222,333,444,555,666]
>>> a.index(555) #获取某一元素的顺序号
4
>>> a[1:3] #按顺序获取某几个元素
[222, 333]
（4）len()函数
>>> a=[111,222,333,444,555,666]
>>> len(a) #获取某列表的长度
6
