《Abaqus GUI程序开发指南（Python语言）》——2.4　内置对象类型

本节书摘来自异步社区《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都是科学计数法的形式，但是有大小写的区分。

https://yqfile.alicdn.com/95e61f863d6aca9f427ef6c51ff7afe424cea83e.png" >

除了单引号和双引号字符串之外，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