程序设计是大专院校计算机、电子信息、工商管理等相关专业的必修课程。Python语言是一种解释型、面向对象的计算机程序设计语言,广泛用于计算机程序设计教学语言、系统管理编程脚本语言、科学计算等,特别适用于快速的应用程序开发。Python编程语言广受开发者的喜爱,并被列入LAMP(Linux、Apache、MySQL以及PythonPerlPHP),已经成为最受欢迎的程序设计语言之一。本教程集教材、练习册、上机指导于一体,基于Windows 10和Python 3.5.2构建Python开发平台,通过大量的实例,由浅入深、循序渐进地阐述Python语言的基础知识,以及使用Python语言的实际开发应用实例。具体内容包括:Python概述、Python语言基础、程序流程控制、常用内置数据类型、系列数据类型、输入和输出、错误和异常处理、函数、类和对象、模块和客户端、算法与数据结构基础、图形用户界面、图形绘制、数值日期和时间处理、字符串和文本处理、文件、数据库访问、网络和Web编程、多线程编程以及系统管理等。本教程各章节涉及的源程序代码和相关素材,以及供教师参考的教学电子文稿均可以通过清华大学出版社网站(www.tup.tsinghua.edu.cn)下载,也可以通过hjiang@cc.ecnu.edu.cn直接与作者联系。本教程由华东师范大学江红和余青松共同编写。由于时间和编者学识有限,书中不足之处在所难免,敬请诸位同行、专家和读者指正。 编 者 2017年3月
系列数据类型 系列数据类型(bytes、bytearray、list、str和tuple)是Python内置的组合数据类型,可以实现复杂数据的处理。
5.1Python系列数据概述 5.1.1数组 数组是一种数据结构,用于存储和处理大量的数据。将所有的数据存储在一个或多个数组中,然后通过索引下标访问并处理数组的元素,可实现复杂数据处理任务。
Python语言没有提供直接创建数组的功能,但可以使用其内置的系列数据类型(例如列表list),实现数组的功能。
5.1.2系列数据类型 系列数据类型是Python基础的数据结构,是一组有顺序的元素的集合。系列数据可以包含一个或多个元素(对象,元素也可以是其他系列数据),也可以是一个没有任何元素的空系列。
Python内置的系列数据类型包括:元组(tuple)、列表(list)、字符串(str)和字节数据(bytes和bytearray)。
元组也称为定值表,用于存储值固定不变的值表。例如:
s1=1,2,3
s1 #输出:1, 2, 3
s1[2] #输出:3
列表也称为表,用于存储其值可变的表。例如:
s2=[1,2,3]
s2[2]=4
s2 #输出:[1, 2, 4]
字符串是包括若干字符的系列数据,支持系列数据的基本操作。例如:
s3="abc"
s3="Hello, world!"
s3[:5]#字符串前5个字符。输出:''Hello''
字节系列数据是包括若干字节的序列。Python抓取网页时返回的页面,通常为UTF-8编码的字节序列。字节系列和字符串直接可以相互转换。例如:
s1=b"abc"
s1.decode"utf-8" #输出:''abc''
s2="百度"
s2.encode"utf-8" #输出:b''\xe7\x99\xbe\xe5\xba\xa6''
5.2系列数据的基本操作 5.2.1系列的长度、最大值、最小值、求和 通过内置函数len、max、min,可以获取系列的长度、系列中元素最大值、系列中元素最小值。内置函数sum可获取列表或元组中各元素之和;如果有非数值元素,则导致TypeError;对于字符串(str)和字节数据(bytes),也将导致TypeError。
【例5.1】系列数据的求和示例。
t1=1,2,3,4
sumt1#输出:10
t2=1,''a'',2
sumt2#TypeError: unsupported operand types for: ''int'' and ''str''
s=''1234''
sums#TypeError: unsupported operand types for: ''int'' and ''str''
【例5.2】系列的长度、最大值、最小值操作示例。
s=''abcdefg''
lens
7
maxs
''g''
mins
''a''
s2=''''
lens2
0
t=10,2,3
lent
3
maxt
10
mint
2
t2=
lent2
0
lst=[1,2,9,5,4]
lenlst
5
maxlst
9
minlst
1
lst2=[ ]
lenlst2
0
b=b''ABCD''
lenb
4
maxb
68
minb
65
b2=b''''
lenb2
0
5.2.2系列的索引访问操作 系列表示可以通过索引下标访问的可迭代对象。可以通过整数下标访问系列s的元素。
s[i]#访问系列s在索引i处的元素
索引下标从0开始,第1个元素为s[0],第2个元素为s[1],依此类推,最后一个元素为s[lens -1]。
如果索引下标越界,则导致IndexError;如果索引下标不是整数,则导致TypeError。例如:
s=''abc''
s[0]#输出:''a''
s[3]#IndexError: string index out of range
s[''a'']#TypeError: string indices must be integers
系列s的索引下标示意图如图5-1所示。
图5-1系列s的索引下标示意图
【例5.3】系列的索引访问示例。
s=''abcdef''
s[0]
''a''
s[2]
''c''
s[-1]
''f''
s[-3]
''d''
t=''a'',''e'',''i'',''o'',''u''
t[0]
''a''
t[1]
''e''
t[-1]
''u''
t[-5]
''a''
lst=[1,2,3,4,5]
lst[0]
1
lst
[1, 2, 3, 4, 5]
lst[2]=''a''
lst[-2]=''b''
lst
[1, 2, ''a'', ''b'', 5]
b=b''ABCDEF''
b[0]
65
b[1]
66
b[-1]
70
b[-2]
69
5.2.3系列的切片操作 通过切片操作,可以截取系列s的一部分。切片操作的基本形式为:
s[i:j] 或者 s[i:j:k]
其中,i为系列开始下标(包含s[i]);j为系列结束下标(不包含s[j]);k为步长。如果省略i,则从下标0开始;如果省略j,则直到系列结束为止;如果省略k,则步长为1。
注意,下标也可以为负数。如果截取范围内没有数据,则返回空元组;如果超过下标范围,不报错。
【例5.4】系列的切片操作示例。
s=''abcdef''
s[1:3]
''bc''
s[3:10]
''def''
s[8:2]
''''
s[:]
''abcdef''
s[:2]
''ab''
s[::2]
''ace''
s[::-1]
''fedcba''
t=''a'',''e'',''i'',''o'',''u''
t[-2:-1]
''o'',
t[-2:]
''o'', ''u''
t[-99:-5]
t[-99:-3]
''a'', ''e''
t[::]
''a'', ''e'', ''i'', ''o'', ''u''
t[1:-1]
''e'', ''i'', ''o''
t[1::2]
''e'', ''o''
lst=[1,2,3,4,5]
lst[:2]
[1, 2]
lst[:1]=[]
lst
[2,3, 4, 5]
lst[:2]
[2, 3]
lst[:2]=''a''
lst[1:]=''b''
lst
[''a'', ''b'']
del lst[:1]
lst
[''b'']
b=b''ABCDEF''
b[2:2]
b''''
b[0:1]
b''A''
b[1:2]
b''B''
b[2:2]
b''''
b[-1:]
b''F''
b[-2:-1]
b''E''
b[0:lenb]
b''ABCDEF''
5.2.4系列的连接和重复操作 通过连接操作符 ,可以连接两个系列(s1和s2),形成一个新的系列对象;通过重复操作符*,可以重复一个系列n次(n为正整数)。系列连接和重复操作的基本形式为:
s1 s2 或者 s*n或者 n *s
连接操作符 和重复操作符*也支持复合赋值运算,即: =和*=。
【例5.5】系列的连接和重复操作示例。
s1=''abc''
s2=''xyz''
s1 s2
''abcxyz''
s1*3
''abcabcabc''
s1= s2
s1
''abcxyz''
s2 *= 2
s2
''xyzxyz''
t1=1,2
t2=''a'',''b''
t1 t2
1, 2, ''a'', ''b''
t1*2
1, 2, 1, 2
t1= t2
t1
1, 2, ''a'', ''b''
t2 *= 2
t2
''a'', ''b'', ''a'', ''b''
lst1=[1,2]
lst2=[''a'',''b'']
lst1 lst2
[1, 2, ''a'', ''b'']
2 *lst2
[''a'', ''b'', ''a'', ''b'']
lst1= lst2
lst1
[1, 2, ''a'', ''b'']
lst2 *=2
lst2
[''a'', ''b'', ''a'', ''b'']
b1=b''ABC''
b2=b''XYZ''
b1 b2
b''ABCXYZ''
b1*3
b''ABCABCABC''
b1 =b2
b1
b''ABCXYZ''
b2*=2
b2
b''XYZXYZ''
5.2.5系列的成员关系操作 可以通过下列方式之一判断一个元素x是否存在于系列s中。
xin s #如果为True,则表示存在
x not in s#如果为True,则表示不存在
s.countx#返回x在s(指定范围[start,end)中出现的次数
s.indexx[, i[, j]]#返回x在s(指定范围[i, j)中第一次出现的下标
其中,指定范围[i,j,从下标i(包括,默认为0)开始,到下标j结束(不包括,默认为lens)。
对于s.indexvalue, [start, [stop]]方法,如果找不到时,则导致ValueError。例如:
''To be or not to be, this is a question''.index''123''#ValueError: substring not found
【例5.6】系列中元素的存在性判断示例。
s=''Good, better, best!''
''o'' in s
True
''g'' not in s
True
s.count''e''
3
s.index''e'', 10
10
t=''r'', ''g'', ''b''
''r'' in t
True
''y'' not in t
True
t.count''r''
1
t.index''g''
1
lst=[1,2,3,2,1]
1 in lst
True
2 not in lst
False
lst.count1
2
lst.index3
2
b=b''Oh, Jesus!''
b''O'' in b
True
b''o'' not in b
True
b.countb''s''
2
b.indexb''s''
6
5.2.6系列的比较运算操作 两个系列支持比较运算符(、、==、!=、=、),字符串比较运算按顺序逐个元素进行比较。
【例5.7】系列的比较运算示例。
s1=''abc''
s2=''abc''
s3=''abcd''
s4=''cba''
s1 s4
False
s2
True
s1 == s2
True
s1 != s3
True
''a'' ''A''
True
''a'' = ''''
True
t1=1,2
t2=1,2
t3=1,2,3
t4=2,1
t1
True
t1
True
t1 == t3
False
t1 != t2
False
t1 = t3
False
t4 t3
True
s1=[''a'',''b'']
s2=[''a'',''b'']
s3=[''a'',''b'',''c'']
s4=[''c'',''b'',''a'']
s1
False
s1
True
s1==s2
True
s1!=s3
True
s1=s3
False
s4s3
True
b1=b''abc''
b2=b''abc''
b3=b''abcd''
b4=b''ABCD''
b1
False
b1
True
b1==b2
True
b1=b3
False
b3!=b4
True
b4b3
False
5.2.7系列的排序操作 通过内置函数sorted,可以返回系列的排序列表。通过类reversed构造函数,可以返回系列的反序的迭代器。内置函数sorted形式如下:
sortediterable, key=None, reverse=False#返回系列的排序列表
其中,key是用于计算比较键值的函数(带一个参数),例如:key=str.lower;如果reverse=True,则反向排序。
【例5.8】系列的排序操作示例。
s1=''axd''
sorteds1
[''a'', ''d'', ''x'']
s2=1,4,2
sorteds2
[1, 2, 4]
sorteds2,reverse=True
[4, 2, 1]
s3=''abAC''
sorteds3, key=str.lower
[''a'', ''A'', ''b'', ''C'']
5.2.8内置函数all和any 通过内置函数all和any,可以判断系列的元素是否全部和部分为True。函数形式 如下:
alliterable#如果序列的所有值都为True,返回True;否则,返回False
anyiterable#如果序列的任意值为True,返回True;否则,返回False
例如:
any1, 2, 0
True
all[1, 2, 0]
False
5.2.9系列拆封 1.变量个数和系列长度相等 使用赋值语句,可以将系列值拆封,然后赋值给多个变量:
变量1, 变量2,,变量n= 系列或可迭代对象
变量个数和系列的元素个数不一致时,将导致ValueError。例如:
a, b = 1, 2
a, b #输出:1, 2
a, b, c = 1, 2#ValueError: need more than 2 values to unpack
data = 1001, ''张三'', 80, 79, 92
sid, name, scores = data
scores#输出:80, 79, 92
sid, name, chinese, math, english = data
math#输出:79
2.变量个数和系列长度不等 如果系列长度未知,可使用*元组变量,将多个值作为元组赋值给元组变量。一个赋值语句中,*变量只允许出现一次,否则导致SyntaxError。例如:
first, *middles, last = range10
middles#输出:[1, 2, 3, 4, 5, 6, 7, 8]
first, second, third, *lasts = range10
lasts#输出:[3, 4, 5, 6, 7, 8, 9]
*firsts, last3, last2, last1 = range10
firsts#输出:[0, 1, 2, 3, 4, 5, 6]
first, *middles, last = sorted[70, 85, 89, 88, 86, 95, 89] #去掉最高分和最低分
summiddleslenmiddles#计算去掉最高分和最低分后的平均值。输出:87.4
3.使用临时变量_ 如果只需要部分数据,系列其他位置可以使用临时变量_。例如:
_, b, _ = 1, 2, 3
b#输出:2
record = ''Zhangsan'', ''szhang@abc.com'', ''021-62232333'', ''13912349876''
name, _, *phones = record
phones#输出:[''021-62232333'', ''13912349876'']
5.3元 组 元组是一组有序系列,包含零个或多个对象引用。元组和列表十分类似,但元组是不可变的对象,即不能修改、添加或删除元组中的项目,但可以访问元组中的项目。
5.3.1使用元组字面量创建元组实例对象 使用元组字面量,可以创建元组实例对象。元组字面量采用圆括号中用逗号分隔的项目定义。圆括号可以省略。其基本形式如下:
x1, [x2, , xn] 或者 x1, [x2, , xn]
其中,x1、x2、、xn为任意对象。
【例5.9】使用元组字面量创建元组实例对象示例。
t1=1,2,3
t2=
t3=1,
i1=1
t4=''a'',''b'',''c''
t5=2.0,
printt1,t2,t3,t4,t5,i1
1, 2, 3 1, ''a'', ''b'', ''c'' 2.0, 1
注意,如果元组中只有一个项目时,后面的逗号不能省略,这是因为Python解释器把x1解释为x1,例如,1解释为整数1,1,解释为元组。
5.3.2使用tuple对象创建元组实例对象 也可以通过创建tuple对象来创建元组。其基本形式为:
tuple #创建一个空列表
tupleiterable#创建一个列表,包含的项目为可枚举对象iterable中的元素
【例5.10】使用tuple对象创建元组实例对象示例。
t1=tuple
t2=tuple"abc"
t3=tuple[1,2,3]
t4=tuplerange3
printt1,t2,t3,t4
''a'', ''b'', ''c'' 1, 2, 3 0, 1, 2
5.3.3元组的系列操作 元组支持系列的基本操作,包括索引访问、切片操作、连接操作、重复操作、成员关系操作、比较运算操作,以及求元组长度、最大值、最小值等。
【例5.11】元组的系列操作示例。
t1=1,2,3,4,5,6,7,8,9,10
lent1 #输出:10
maxt1 #输出:10
sumt1 #输出:55
5.4列 表 列表是一组有序项目的数据结构。创建一个列表后,可以访问、修改、添加或删除列表中的项目,即列表是可变的数据类型。Python没有数组,可以使用列表代替。
5.4.1使用列表字面量创建列表实例对象 使用列表字面量,可以创建列表实例对象。列表字面量列表采用方括号中用逗号分隔的项目定义。其基本形式为:
[x1, [x2, , xn]]
【例5.12】使用列表字面量创建列表实例对象示例。
l1=[]
l2=[1]
l3=["a","b","c"]
printl1,l2,l3 #输出:[] [1] [''a'', ''b'', ''c'']
5.4.2使用list对象创建元组实例对象 也可以通过创建list对象来创建列表。其基本形式为:
list #创建一个空列表
listiterable#创建一个列表,包含的项目为可枚举对象iterable中的元素
|