03Python数据类型.docx
- 文档编号:8504803
- 上传时间:2023-01-31
- 格式:DOCX
- 页数:17
- 大小:24.89KB
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[
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]
(3)重复操作符(*)
一个序列的多份拷贝,返回一个包含多份原对象拷贝的新对象。
sequence*copies_int,注意copies_int必须为整型,不能为长整型。
(4)切片操作符([],[:
][:
:
])
访问某一个数据元素:
sequence[index]。
(len()函数可获得序列的
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 03 Python 数据类型