03Python数据类型.docx
《03Python数据类型.docx》由会员分享，可在线阅读，更多相关《03Python数据类型.docx（17页珍藏版）》请在冰豆网上搜索。
03Python数据类型
////根标题=Python程序设计与应用实战
////主标题=数据类型
////作者=张勇
////地址1=电子科技大学~~数学科学学院
////地址2=
////地址3=
////标题缩减级别=1
1数据类型2
1.1数据类型2
1.1.1列表（list）的定义2
1.1.2元组（tuple）的定义2
1.2序列3
1.2.1sequence序列3
1.2.2元素的引用3
1.2.3其他引用方式4
1.2.4尾部元素引用4
1.2.5字符串是元组4
1.3列表（list）4
1.3.1列表的方法6
1.3.2列表当栈7
1.3.3列表当队列7
1.3.4列表推导式8
1.3.5列表嵌套8
1.4元组（tuple）9
1.5字典（dict）10
1.5.1赋值10
1.5.2删除11
1.5.3字典的使用例子11
1.5.4字典的常用方法11
1.5.5示例12
1.6Python序列应用13
1.6.1所有的标准类型操作符适用于序列13
1.6.2序列类型的操作符13
1.6.3序列常用的内建函数14
1数据类型
1.1数据类型
基本数据类型：
字符串，整数，浮点数，布尔型
集合类型：
列表（list）,元组（tuple）,字典（dictionary或hash）
列表（list）的定义：
aList=[23]或者bList=[1,2,3]
printbList[1]
List常用操作：
append,del,+,*,len（list）
[0]*5
列表对象支持的方法
append（x）
count（x）：
X在List中的个数
extend（L）
index（x）
insert（i,x）
pop（x）
remove（x）
reverse（）
sort（）
例子:
list.append（x）#将元素x加入list列表
list.sort（）对列表list进行排序
元组（tuple）的定义：
aTuple=（1,3,5）
printaTuple
元组可以用方括号括起下标做索引
元组一旦创建就不能改变
列表大部分操作同样适用于元组
1.2序列
1.2.1sequence序列
sequence（序列）是一组有顺序的元素的集合
（严格的说，是对象的集合，但鉴于我们还没有引入“对象”概念，暂时说元素）
序列可以包含一个或多个元素，也可以没有任何元素。
我们之前所说的基本数据类型，都可以作为序列的元素。
元素还可以是另一个序列，以及我们以后要介绍的其他对象。
序列有两种：
tuple（定值表；也有翻译为元组）和list（表）
>>>s1=（2,1.3,'love',5.6,9,12,False）#s1是一个tuple
>>>s2=[True,5,'smile']#s2是一个list
>>>prints1,type（s1）
>>>prints2,type（s2）
[newpage]
>>>s1=（2,1.3,'love',5.6,9,12,False）
>>>s1[0]
2
>>>type（s1[0]）
>>>s1[2]
'love'
>>>type（s1[2]）
>>>s1[3]
5.6
>>>type（s1[3]）
tuple和list的主要区别在于，一旦建立，tuple的各个元素不可再变更，而list的各个元素可以再变更。
一个序列作为另一个序列的元素
>>>s3=[1,[3,4,5]]
空序列
>>>s4=[]
1.2.2元素的引用
>>>s3=[1,[3,4,5]]
序列元素的下标从0开始：
>>>prints1[0]
>>>prints2[2]
>>>prints3[1][2]
由于list的元素可变更，你可以对list的某个元素赋值：
>>>s2[1]=3.0
>>>prints2
如果你对tuple做这样的操作，会得到错误提示。
所以，可以看到，序列的引用通过s[]实现，int为下标
1.2.3其他引用方式
范围引用：
基本样式[下限:
上限:
步长]
>>>prints1[:
5]#从开始到下标4（下标5的元素不包括在内）
>>>prints1[2:
]#从下标2到最后
>>>prints1[0:
5:
2]#从下标0到下标4（下标5不包括在内），每隔2取一个元素（下标为0，2，4的元素）
>>>prints1[2:
0:
-1]#从下标2到下标1
从上面可以看到，在范围引用的时候，如果写明上限，那么这个上限本身不包括在内。
1.2.4尾部元素引用
>>>prints1[-1]#序列最后一个元素
>>>prints1[-3]#序列倒数第三个元素
同样，如果s1[0:
-1],那么最后一个元素不会被引用（再一次，不包括上限元素本身）
1.2.5字符串是元组
字符串是一种特殊的元素，因此可以执行元组的相关操作。
>>>str='abcdef'
>>>printstr[2:
4]
总结
tuple元素不可变，list元素可变
序列的引用s[2],s[1:
8:
2]
字符串是一种tuple
1.3列表（list）
主要介绍了Python3的list列表用法,这是Python3数据类型中非常常见的应用,
通常来说Python中任何值都是一个对象，因此任何类型（int、str、list…）都是一个类。
而类就必然有它的方法或属性，我们要记下这么多类的所有方法显然是不可能的，对此本文介绍两个小技巧：
dir（）：
内置函数，用来查询一个类或者对象所有属性，比如>>>dir（list）。
help（）：
内置函数，用来查询具体的说明文档，比如>>>help（int）。
在上一篇的Python3的基本数据类型中，我们初步了解了list列表，也介绍了列表是Python中使用最频繁的数据类型。
本文将进一步深入学习列表的使用。
列表时对象的有序集合。
列表的内容可以修改，列表的长度可变。
列表的定义：
<列表名称>[<列表项>]
其中多个列表项用逗号隔开，它们的类型可以相同，也可以不同，还可以是其列表。
例如
date=[2011,2,9,9,54]
day=['sun','mon','tue','wed','thi','fri','sat']
today=[2011,2,9,"wed"]
data=[date,day]
均是合法的列表。
使用时，通过
<列表名>[索引号]
的形式应用，索引号从0开始，即0是第1项的索引号。
例如date[0]的值是2011，day[1]得到“mon”，data[1][3]的到“wed”。
下列程序：
date=[2011,2,9,9,54]
day=['sun','mon','tue','wed','thi','fri','sat']
today=[2011,2,9,"wed"]
data=[date,day]
print（date[0]）
print（day[1]）
print（data[1][3]）
的运行结果为：
2011
mon
wed
列表可以整体输出，如print（data）
列表的其他运算见表1-2。
表1-2列表的运算
运算格式/举例
说明/结果
L1=[]
空列表
L2=[2011,2,9,19,54]
5项，整数列表，索引号0-4
L3=['sun',['mon','tue','wed']]
嵌套的列表
L2[i],L3[i][j]
索引,L2[1]的值为2，L3[1][1]的值为'tue'
L2[i:
j]
分片，取i到j-1的项
Len（L2）
求列表的长度
L1+L2
合并
L2*3
重复,L2重复3次
forxinL2
循环,x取L2中的每个成员执行循环体
19inL2
19是否是L2的成员
L2.append（4）
增加4作为其成员，即增加一项
L2.sort（）
排序,L2结果变为[2,9,19,54,2011]
L2.index（9）
得到9在列表中的索引号，结果为2
L2.reverse（）
逆序，L2的结果为[2011,54,19,9,2]
delL2[k]
删除索引号为k的项
L2[i:
j]=[]
删除i到j-1的项
L2[i]=1
修改索引号为i的项的值
L2[i:
j]=[4,5,6]
修改i到j-1的项的值，如果项数多，则自动插入
L4=range（5,20,3）
生成整数列表L4实际为[5,8,11,14,17]
1.3.1列表的方法
list.append（x）
在列表的尾部添加一个项，等价于a[len（a）:
]=[x]。
list.extend（L）
将给定的列表L接到当前列表后面，等价于a[len（a）:
]=L。
list.insert（i,x）
在给定的位置i前插入项，例如：
a.insert（0,x）会在列表的头部插入，而a.insert（len（a）,x）则等价于a.append（x）。
list.remove（x）
移除列表中第一个值为x的项，没有的话会产生一个错误。
list.pop（[i]）
删除列表给定位置的项，并返回它。
如果没指定索引，a.pop（）移除并返回列表最后一项。
（方括号表示可选）
list.clear（）
删除列表中的所有项，相当于dela[:
]。
list.index（x）
返回列表中第一个值为x的项的索引。
如果没有匹配的项,则产生一个错误。
list.count（x）
返回列表中x出现的次数。
list.sort（）
就地完成列表排序。
list.reverse（）
就地完成列表项的翻转。
list.copy（）
返回列表的一个浅拷贝，相当于a[:
]。
1.3.2列表当栈
List的方法使得其可以很方便地作为一个栈来使用。
我们知道，栈的特点是最后进入的元素最先出来（即后入先出），用append（）方法进行压栈，用不指定索引的pop（）方法进行出栈。
示例代码如下：
stack=[]
forxinrange（1,6）:
stack.append（x）#入栈
print（'push',x,''）
print（stack）
print（'Nowstackis',stack）
whilelen（stack）>0:
print（'pop',stack.pop（）,''）#出栈
print（stack）
1.3.3列表当队列
列表还可以当作队列来使用，队列的特性是第一个加入的元素第一个取出来（即先入先出）。
然而，把列表当队列使用效率并不高，因为从列表的尾部添加和弹出元素是很快的，而在列表的开头插入或弹出是比较慢的（因为所有元素都得移动一个位置）。
要实现一个队列,使用标准库的collections.deque，它被设计成在两端添加和弹出都很快。
示例代码如下：
fromcollectionsimportdeque
queue=deque（）#创建空队列
forxinrange（1,6）:
queue.append（x）#入队
print（'push',x,''）
print（list（queue））
print（'Nowqueueis',list（queue））
whilelen（queue）>0:
print（'pop',queue.popleft（）,''）#出队
print（list（queue））
1.3.4列表推导式
列表推导式提供了从序列创建列表的简单途径。
通常程序会对序列的每一个元素做些操作，并以其结果作为新列表的元素，或者根据指定的条件来创建子序列。
列表推导式的结构是：
在一个方括号里，首先是一个表达式，随后是一个for子句，然后是零个或更多的for或if子句。
返回结果是一个根据表达从其后的for和if上下文环境中生成出来的列表。
示例代码如下：
squares=[x**2forxinrange（10）]#推导式
print（squares）
#输出是[0,1,4,9,16,25,36,49,64,81]
pairs=[（x,y）forxin[1,2,3]foryin[3,1,4]ifx!
=y]#推导式
print（pairs）
#输出是[（1,3）,（1,4）,（2,3）,（2,1）,（2,4）,（3,1）,（3,4）]
1.3.5列表嵌套
Python中并没有二维数组的概念，但我们可以通过列表嵌套达到同样的目的。
mat=[
[1,2,3],
[4,5,6],
[7,8,9]
]
print（mat）
print（type（mat））
print（mat[1]）
mat[2]=[0,0,0]
print（mat）
同样，我们可以使用推导式生成嵌套的列表：
mat=[[1,2,3],[4,5,6],[7,8,9]]
new_mat=[[row[i]forrowinmat]foriin[0,1,2]]#嵌套
print（new_mat）
#输出[[1,4,7],[2,5,8],[3,6,9]]
附：
del语句
del语句可以通过给定索引（而不是值）来删除列表中的项，它与返回一个值的pop（）方法不同。
del语句也可以移除列表中的切片，或者清除整个列表：
lst=[1,2,3,4,5,6,7,8,9]
dellst[2]#删除指定索引项
print（lst）
dellst[2:
5]#删除切片
print（lst）
dellst[:
]#删除整个列表
print（lst）
del也可以用于删除变量实体：
dellst
在删除变量实体之后引用lst的话会产生错误。
1.4元组（tuple）
元组和列表十分类似，只不过元组和字符串一样是不可变的，即不能修改元组。
元组通过圆括号中用逗号分割的项目定义。
当一组数据，只使用，不修改时使用元组。
元组的使用与列表相同，只是不能修改、删除、增加其元素。
例如：
#useoftuple
#filename:
tuple.py
garden=（"BirdofParadise","rose","tulip","lotus","olive","Sunflower"）
print（'Numberofflowersinthegardenis',len（garden））
i=2;
print（'flower',i,'is',garden[i-1]）
new_garden=（'Phlox','PeachBlossom',garden）
i=1;
print（'flower',i,'is',garden[i-1]）
运行结果如下:
C:
\Python31>pythontuple.py
Numberofflowersinthegardenis6
flower2isrose
flower1isBirdofParadise
元组的运算见表1-3
表1-3元组的运算
运算格式/举例
说明/结果
T1（）
空元组
T2=（2011,）
有一项的元组
T3=（2011,2,9,19,54）
5项，整数元组，索引号0-4
T4=（'sun',（'mon','tue','wed'））
嵌套的元组
T3[i],T4[i][j]
索引,T3[1]的值为2，T4[1][1]的值为'tue'
T3[i:
j]
分片，取i到j-1的项
Len（T3）
求元组的长度
T3+T4
合并
T3*3
重复,T3重复3次
forxinT3
循环,x取T3中的每个成员执行循环体
19inT3
19是否是L2的成员
注意：
元组与列表的最大不同：
一是定义时用一对圆括号，二是内容不能修改。
1.5字典（dict）
字典是python中唯一内置映射数据类型。
通过指定的键从字典访问值，即[key,value]模式
字典为容器，内建len函数可以将字典当作单一参数使用，返回字典对象中项目（键／值对）的数目。
字典是无序的对象的集合，通过键进行操作。
类似于通讯录，通过姓名来查找电话、地址等信息，则姓名就是键。
一定要没有同名的人。
字典的定义为：
<字典名>={键1:
值2,键2:
值2,键3:
值3,…}
其中，键1，键2，键3不相同，值可以是任何类型的数据，可以是列表或元组。
注意，字典定义中使用的是大括号，项通过逗号隔开，每个项有键部分和值部分，键和值之间用冒号隔开。
只可使用简单的对象作为键,而且不能改变，但可以用不可变或可变的对象作为字典的值。
在Python2.2以及后面版本，D中的k运算符检测是否对象k是字典D中的键。
如果是返回True如果不是返回False。
相似的，
字典D中的值与相关的键k被索引表示为：
D[k]。
索引字典没有的键会引起意外。
例如：
d={'x':
42,'y':
3.14,'z':
7}
d['x']#42
d['z']#7
d['a']#raisesexception
1.5.1赋值
D[newkey]=value该操作加载键和值到字典里新的项目中。
1.5.2删除
语法：
delD[k]中的del语句，删除字典中拥有键k的项目。
如果k不是字典D中的键，delD[k]就会引起意外。
1.5.3字典的使用例子
a={'a':
'aa','b':
'bb'}
a['c']='cc'
a.has_key（'a'）#判断字典中是否存在此值
a['a']='uu'
a
a['a']=3
dela['a']#删除键值
a
len（a）
示例：
>>>d={'d':
[3,4],1:
[7],'ab':
['ab','cd','ef']}
>>>d['d']
[3,4]
>>>d[1]
[7]
>>>d['ab']
['ab','cd','ef']
>>>print（d）
{1:
[7],'d':
[3,4],'ab':
['ab','cd','ef']}
>>>deld[1];print（d）
{'d':
[3,4],'ab':
['ab','cd','ef']}
1.5.4字典的常用方法
has_key（x）
keys（）
values（）
items（）
clear（）
copy（）
update（x）
get（x[,y]）
1.5.5示例
例如：
#useofdictionaries
#filename:
dict.py
address1={'zhang':
'larry@wall.org',
'wang':
'wang@wall.org',
'lily':
'lily@ruby-lang.org',
'sam':
'sam@'
}
print（'mailofzhang',address1['zhang']）
address2={'zhang':
['larry@wall.org','shaanxi'],
'wang':
['wang@wall.org','beijing'],
'lily':
['lily@ruby-lang.org','shanghai'],
'sam':
['sam@','hubei']
}
print（'mailofzhang',address2['lily'][0]）
print（'provinceofzhang',address2['lily'][0]）
运行结果如下：
C:
\Python31>pythondict.py
mailofzhanglarry@wall.org
mailofzhanglily@ruby-lang.org
provinceofzhanglily@ruby-lang.org
字典的操作见表1-4：
表1-4字典的运算
运算格式/举例
说明/结果
d1={}
空字典
d2={'class':
'jianhuan','year':
'2011'}
有两项的字典
d3={'xjtu':
{'class':
'huagong','year':
'2011'}}
字典的嵌套
d2['class'],d3['xjtu']['class']
按键使用字典
d2.keys（）
获得键的列表
d2.values（）
获得值的列表
len（d2）
求字典的长度
d2['year']=2020
添加或改变字典的值
deld2['year']
删除键
1.6Python序列应用
序列：
成员有序排列，并且可以通过下标漂移量访问一个（直接指定索引）或者几个成员（切片操作）。
包括字符串（普通字符串和unicode字符串）、列表和元组。
其索引第一个元素从零向后递增（正索引），也可以从最后一个元素的-1索引向前递减（负索引）。
1.6.1所有的标准类型操作符适用于序列
（值比较操作符，对象身份比较，逻辑操作符）。
1.6.2序列类型的操作符
（1）成员关系操作符（in,notin）
判断一个元素是否属于一个序列，返回值为True/False。
（2）连接操作符（+）
将一个序列与另一个相同类型的序列做连接。
这个方法并不是最快最有效的，因为python要为每一个参加连接操作的字符串分配新的内存，包括新产生的字符串。
对于字符串，推荐将子字符串放到一个列表或者可迭代对象中，调用join方法连接，节约内存。
对于列表，推荐使用列表对象的extend（）方法。
示例：
>>>t1=['ab','cd','ef']
>>>t2=[3,4,5]
>>>t1.extend（t2）
>>>t1
['ab','cd','ef',3,4,5]
（３）重复操作符（*）
一个序列的多份拷贝，返回一个包含多份原对象拷贝的新对象。
sequence*copies_int，注意copies_int必须为整型，不能为长整型。
（４）切片操作符（[],[:
][:
:
]）
访问某一个数据元素：
sequence[index]。
（len（）函数可获得序列的
升级会员 