Python 数据分析与科学计算 课件 第3章 Python数据类型

Python数据分析与科学计算第3章Python数据类型3.1Python的基本数据类型3.2Python组合数据类型3.3数据的输入与输出3.1python的基本数据类型

在程序设计语言中，都是采用数据类型来描述程序中的数据结构、数据的表示范围和数据在内存中的存储分配等。整型数据即整数，不带小数点，可以有正号或者负号。在Python3.x中，整型数据在计算机内的表示没有长度限制，其值可以任意大。>>>a=12345678900123456789>>>b=a*a>>>b152415787504953525750053345778750190521

1.整型数据3.1python的基本数据类型

十进制整数：由0到9组成。二进制整数：以0b或0B为前缀，由0和1组成。八进制整数：以0o或0O为前缀，其后由0至7的数字组成。十六进制整数：以0x或0X开头，其后由0至9的数字和a至f字母或A至F字母组成。根据前缀来区分各种进制数3.1python的基本数据类型

实数又称浮点数，一般有两种表示形式：十进制小数形式：由数字和小数点组成（必须有小数点

指数形式：用科学计数法表示的浮点数，用字母e（或E）表示以10为底的指数，e之前为数字部分，之后为指数部分。注意：e（或E）前面必须有数字，后面必须是整数。

2.实型数据例如：e-5,1.2E-3.5，1e3.1python的基本数据类型

字符型数据可以使用一对单引号、双引号或者三引号3.字符型数据>>>"Let'sgo""Let'sgo">>>s="'Python'Program">>>s"'Python'Program"3.1python的基本数据类型

转义字符字符形式含义\n

回车换行，将当前位置移到下一行开头\t

横向跳到下一制表位置（Tab）\b

退格，将当前位置退回到前一列\r

回车，将当前位置移到当前行开头\f

走纸换页，将当前位置移到下页开头\\

反斜线符"\"\'单引号符\"双引号符\ddd1～3位8进制数所代表的字符\xhh1～2位16进制数所代表的字符3.1python的基本数据类型

3.1python的基本数据类型

【例2.2】

转义字符的应用。程序代码：a=1b=2c='\101'print("\t%d\n%d%s\n%d%d\t%s"%(a,b,c,a,b,c))运行结果：□□□□□□□□12A12□□□□□□APython的布尔类型有两个值：True和False，分别表示逻辑真和逻辑假。4.布尔型数据>>>type(True)

<class'bool'>>>>True==1

True>>>False==0

True3.1python的基本数据类型

布尔类型还可以与其他数据类型进行逻辑运算，Python规定：0、空字符串、None为False，其他数值和非空字符串为True。>>>0andFalse0>>>NoneorTrueTrue3.1python的基本数据类型

复数由两部分组成：实部和虚部

复数的形式为：实部+虚部j5.复数类型数据>>>x=3+5j>>>x.real

3.0>>>x.imag

5.0>>>y=6-10j>>>x+y

(9-5j)3.1python的基本数据类型

3.2运算符与表达式1.Python运算符Python语言的运算符按照它们的功能可分为：（1）算术运算符（+、–、*、/、**、//、％）。（2）关系运算符（>、<、>=、<=、==、!=）。（3）逻辑运算符（and、or、not）。（4）位运算符（<<、>>、~、|、^、&）。（5）赋值运算符（=、复合赋值运算符）。（6）成员运算符（in、notin）。（7）同一运算符（is、isnot）。（8）下标运算符（[]）。（9）其他（如函数调用运算符（））。3.2运算符与表达式Python中的运算符具有优先级和结合性。（1）优先级：指同一个表达式中不同运算符进行运算时的先后次序。通常所有单目运算符的优先级高于双目运算符。（2）结合性：指在表达式中各种运算符优先级相同时，由运算符的结合性决定表达式的运算顺序。它分为两类：一类运算符的结合性为从左到右，称为左结合性；另一类运算符的结合性是从右到左，称为右结合性。通常单目、三目和赋值运算符是右结合性，其余均为左结合性。

3.2运算符与表达式2.算术运算符和算术表达式运算符含义优先级结合性+加法这些运算符的优先级相同，但比下面的运算符优先级低左结合-减法*乘法这些运算符的优先级相同，但比上面的运算符优先级高/除法//取整除**幂运算%取模

Python中除法有两种：/和//，在Python3.x分别表示除法和整除运算。>>>3/5

0.6-------------------------->>>3//5

0-------------------------->>>-3.0//5

-1.0------------------------->>>3.0//-5

-1.03.2运算符与表达式

**运算符实现乘方运算，其优先级高于*和/。例如：>>>2**3

8---------------------->>>2**3.5

11.313708498984761---------------------->>>4*3**2

36运算符的多重含义：>>>3*5#整数相乘运算

15-------------------------->>>'a'*10#字符串重复运算

'aaaaaaaaaa'--------------------------

赋值运算符赋值运算符用“=”表示。

赋值表达式

变量=表达式等号的左边必须是变量，右边是表达式。>>>y=2>>>x=(y+2)/3>>>x

1.33333333333333333.2运算符与表达式3.赋值运算符和赋值表达式（1）链式赋值在Python中，可通过链式赋值将同一个值赋给多个变量的，一般形式为：>>>x=y=5>>>x5多变量赋值（2）多变量并行赋值

变量1,变量2,…,变量n=表达式1,表达式2,…,表达式n变量个数要与表达式的个数一致，其过程为：首先计算表达式右边n个表达式的值，然后同时将表达式的值赋给左边的n个变量。例如：>>>x,y,z=2,5,8>>>x

2------------------->>>y

5------------------->>>z

83.2运算符与表达式3.2运算符与表达式例如：

采取并行赋值，可以使用一条语句就可以交换两个变量的值：x,y=y,x。>>>x=20>>>x,x=3,x*3>>>x60赋值运算符“＝”与7种算术运算符（+、-、*、/、//、**、％）和5种位运算符（>>、<<、&、^、|）结合构成12种复合的赋值运算符。例如：a+=3 等价于 a=a+3a*=a+3 等价于 a=a*(a+3)a%=3 等价于 a=a%3注意：“a*=a+3”与“a=a*a+3”是不等价的，“a*=a+3”等价于“a=a*(a+3）”，这里括号是必需的。3.2运算符与表达式复合的赋值运算符【例2.6】复合的赋值运算符。>>>a=3>>>b=5>>>a+=b>>>a

8----------------------------------------->>>a>>=2>>>a

2----------------------------------------->>>a*=a+3>>>a

103.2运算符与表达式

3.2运算符与表达式4.关系运算符和关系表达式运算符含义运算符含义>

大于>=大于等于<

小于<=小于等于==等于!=不等于在Python中，真用“True”表示，假用“False”表示。

3.2运算符与表达式>>>x,y,z=2,3,5>>>x>yFalse>>>y<zTrue>>>x<y<zTrue注意正确使用“=”与“==”a,b=0,1ifa=b:print("aequaltob")else:print("anotequaltob")语法错误：invalidsyntaxa,b=0,1ifa==b:print("aequaltob")else:print("anotequaltob")运行结果：anotequaltob关系运算符——注意符号区别3.2运算符与表达式

3.2运算符与表达式5.逻辑运算符和逻辑表达式逻辑运算符运算符含义结合性not逻辑非右结合and逻辑与左结合Or逻辑或（1）对于与运算aandb如果a为真，继续计算b，b将决定最终整个表达式的真值，所以，结果为b的值。如果a为假，无需计算b，就可以得知整个表达式的真值为假，所以，结果为a的值。例如：

3.2运算符与表达式逻辑表达式>>>Trueand0

0

>>>Falseand12False（2）对于或运算aorb如果a为真，无需计算b，就可得知整个表达式的真值为真，所以结果为a的值。如果a为假，继续计算b，b将决定整个表达式最终的值，所以结果为b的值。例如：3.2运算符与表达式>>>Trueor0

True>>>Falseor12

12>>>Falseor12or0

12

成员运算符用于判断一个元素是否在某一个序列中，或者判断一个字符是否属于这个字符串等，运算结果仍是逻辑值。运算符含义优先级结合性in存在

相同左结合notin不存在>>>'a'in'abcd'True>>>'ac'in'abcd'False3.2运算符与表达式6.成员运算符和成员表达式

notin运算符用于在指定的序列中查找某个值是否不存在，不存在返回True，存在返回False。3.2运算符与表达式>>>'a'notin'bcd'

True>>>3notin[1,2,3,4]False同一性运算符用于测试两个变量是否指向同一个对象，其运算结果是逻辑值。运算符含义优先级结合性is相同

相同左结合isnot不相同is检查用来运算的两个变量是否引用同一对象，如果相同返回True，不相同则返回False。isnot检查用来运算的两个变量是否不是引用同一对象，如果不是同一个对象返回True，否则返回False。3.2运算符与表达式7.同一性运算符和同一性表达式>>>x=y=2.5>>>z=2.5>>>xisyTrue>>>xiszFalse>>>xisnotzTrue3.2运算符与表达式位运算是一种对运算对象按二进制位进行操作的运算。位运算不允许只操作其中的某一位，而是对整个数据按二进制位进行运算。位运算的对象只能是整型数据，其运算结果仍是整型。Python语言提供的位运算符主要有：&（按位“与”）、|（按位“或”）、^（按位“异或”）、~（按位“取反”）、<<（“左移”）和>>（“右移”）6种。除~是单目运算符外，其余均是双目运算符。3.2运算符与表达式8.位运算符和位运算表达式&（按位“与”）3.2运算符与表达式运算规则为：0&0=0、0&1=0、1&0=0、1&1=1。参与运算的两个数均以补码形式出现。按位“与”运算通常用来对某些位清0或保留某些位。例如把a=123清零，可作a&0运算；b=12901的高八位清零，保留低八位，可作

b&255运算。|（按位“或”）3.2运算符与表达式运算规则为：0|0=0、0|1=1、1|0=1、1|1=1。参与运算的两个数均以补码形式出现。按位“或”运算通常用来对某些位置1。例如把a=160的低4位置1，可作a|15运算；把b=3的第0位和第3位置1，其余位不变，可作b|9运算。^（按位“异或”）3.2运算符与表达式运算规则为：0^0=0、0^1=1、1^0=1、1^1=0。参与运算的两个数均以补码形式出现。按位“异或”运算通常用来使特定位翻转或保留原值。例如使a=123低4位翻转，可作a^15运算；使b=12901保持原值，可作b^0运算。～（按位“取反”）3.2运算符与表达式运算规则为：~0=1、~1=0。按位“取反”运算通常用来间接地构造一个数，以增强程序的可移植性。<<（按位“左移”）运算规则为：将操作对象各二进制位全部左移指定的位数，移出的高位丢弃，空出的低位补0。如a<<4指把a的各二进制位向左移动4位，a=57,则0000000000111001（十进制57）左移4位后为0000001110010000（十进制912）。若左移时丢弃的高位不包含1，则每左移一位，相当于给该数乘以2。>>（按位“右移”）3.2运算符与表达式运算规则为：将操作对象各二进制位全部右移指定的位数。移出的低位丢弃，空出的高位对于无符号数补0。对于有符号数，右移时符号位将随同移动，空出的高位正数补0，负数补1。如a>>4指把a的各二进制位向右移动4位，a=57则0000000000111001（十进制57）右移4位后为0000000000000011（十进制3）。

每右移一位，相当于给该数除以2，并去掉小数。3.3组合数据类型序列中的每一个元素都有自己的位置编号，可以通过偏移量索引来读取数据。1.序列类型读取元素方法：序列名[索引]索引范围：-n~n-1(包含n个元素的序列)3.3组合数据类型集合类型中的元素是无序的，无法通过下标索引的方法访问集合类型中的每一个数值集合中的元素不能重复集合中的元素类型只能是固定的数据类型2.集合类型映射类型是“键-值”对的集合元素之间是无序的，通过键可以找出该键对应的值映射类型的典型代表是字典3.映射类型3.3组合数据类型-列表是Python中内置数据类型，是一个元素的有序集合一个列表中的数据类型可以各不相同列表中的每一个数据称为元素其所有元素用逗号分割并放在一对中括号“[”和“]”中例如：[1,2,3,4,5]['Python','C','HTML','Java','Perl

']['wade',3.0,81,['bosh','haslem']]>>>a_list=

['physics','chemistry',2017,2.5]>>>b_list=['wade',3.0,81,['bosh','haslem']]>>>c_list=[1,2,(3.0,'helloworld!')]>>>d_list=[]3.3组合数据类型-列表1.列表的基本操作列表的创建使用赋值运算符“=”将一个列表赋值给变量即可创建列表对象。>>>a_list=[‘physics’,‘chemistry’,2017,2.5,[0.5,3]]>>>a_list[1]'chemistry'>>>a_list[-1][0.5,3]>>>a_list[5]#下标越界Traceback(mostrecentcalllast):File"<pyshell#9>",line1,in<module>a_list[5]IndexError:listindexoutofrange3.3组合数据类型-列表列表元素读取方法为：列表名[索引]切片操作的方法是：列表名[开始索引:结束索引:步长]列表切片>>>a_list[1:3]#开始为1，结束为2，不包括3，步长缺省1['chemistry',2017]>>>a_list[1:-1]['chemistry',2017,2.5]>>>a_list[:3]#左索引缺省为0['physics','chemistry',2017]>>>a_list[1:]#从第一个元素开始截取列表['chemistry',2017,2.5,[0.5,3]]>>>a_list[:]#左右索引均缺省['physics','chemistry',2017,2.5,[0.5,3]]>>>a_list[::2]#左右索引均缺省，步长为2['physics',2017,[0.5,3]]3.3组合数据类型-列表a_list=[‘physics’,‘chemistry’,2017,2.5,[0.5,3]]（1）使用“+”运算符将一个新列表添加在原列表的尾部增加元素>>>id(a_list)#获取列表a_list的地址49411096>>>a_list=a_list+[5]>>>a_list['physics','chemistry',2017,2.5,[0.5,3],5]>>>id(a_list)#获取添加元组时候a_list的地址498449923.3组合数据类型-列表a_list=[‘physics’,‘chemistry’,2017,2.5,[0.5,3]]（2）使用append()方法向列表尾部添加一个新的元素

>>>a_list.append('Python')

>>>a_list['physics','chemistry',2017,2.5,[0.5,3],5,'Python']（3）使用extend()方法将一个新列表添加在原列表的尾部>>>a_list.extend([2017,'C'])>>>a_list['physics',2017,'chemistry',2.5,[0.5,3],5,'Python',2017,'C']（4）使用insert()方法将一个元素插入到列表的指定位置>>>

a_list.insert(3,3.5)>>>a_list['physics',2017,'chemistry',3.5,2.5,[0.5,3],5,'Python',2017,'C']3.3组合数据类型-列表a_list=[‘physics’,‘chemistry’,2017,2.5,[0.5,3],5]（1）使用index()方法可以获取指定元素首次出现的下标一般形式：index(value,[,start,[,end]])检索元素>>>a_list.index(2017)1>>>a_list.index(2017,2)8>>>a_list.index(2017,5,7)Traceback(mostrecentcalllast):File"<pyshell#10>",line1,in<module>a_list.index(2017,5,7)ValueError:2017isnotinlist3.3组合数据类型-列表a_list=['physics',2017,'chemistry',3.5,2.5,[0.5,3],5,'Python',2017,'C']>>>5ina_listTrue>>>0.5ina_listFalse3.3组合数据类型-列表（2）使用count()方法统计列表中指定元素出现的次数>>>a_list.count(2017)2>>>a_list.count([0.5,3])1>>>a_list.count(0.5)

0（3）使用in运算符检索某个元素是否在该列表中a_list=['physics',2017,'chemistry',3.5,2.5,[0.5,3],5,'Python',2017,'C']删除元素>>>b_list=[10,7,1.5]>>>b_list[10,7,1.5]>>>delb_list>>>b_listTraceback(mostrecentcalllast):File"<pyshell#42>",line1,in<module>b_listNameError:name'b_list'isnotdefined3.3组合数据类型-列表（1）使用del命令删除列表中指定位置的元素>>>dela_list[2]>>>a_list['physics',2017,3.5,2.5,[0.5,3],5,'Python',2017,'C']del命令也可以直接删除整个列表a_list=['physics',2017,'chemistry',3.5,2.5,[0.5,3],5,'Python',2017,'C']>>>a_list.remove(2017)>>>a_list['physics',3.5,2.5,[0.5,3],5,'Python',2017,'C']>>>a_list.remove(2017)>>>a_list['physics',3.5,2.5,[0.5,3],5,'Python','C']>>>a_list.remove(2017)Traceback(mostrecentcalllast):File"<pyshell#30>",line1,in<module>a_list.remove(2017)ValueError:list.remove(x):xnotinlist3.3组合数据类型-列表（2）使用remove()方法删除首次出现的指定元素a_list=['physics',2017,'chemistry',3.5,2.5,[0.5,3],5,'Python',2017,'C']2.列表的常用函数cmp()格式：cmp(列表1,列表2)在Python3.x中，不再支持cmp()函数，可以直接使用关系运算符来比较数值或列表。>>>[123,'Bsaic']>[123,'Python']False>>>[1,2,3]==[1,2,3]True3.3组合数据类型-列表>>>cmp([1,2,5],[1,2,3])1>>>cmp([1,2,3],[1,2,3])0>>>cmp([123,'Bsaic'],[123,'Python'])-1>>>a_list=['physics','chemistry',2017,2.5,[0.5,3]]>>>len(a_list)5>>>len([1,2.0,'hello'])3>>>a_list=['123','xyz','zara','abc']>>>max(a_list)'zara'>>>min(a_list)'123'3.3组合数据类型-列表len()格式：len(列表)max()和min()格式：max(列表)，min(列表)>>>a_list=[23,59,-1,2.5,39]>>>sum(a_list)122.5>>>b_list=['123','xyz','zara','abc']>>>sum(b_list)Traceback(mostrecentcalllast):File"<pyshell#11>",line1,in<module>sum(b_list)TypeError:unsupportedoperandtype(s)for+:'int'and'str'3.3组合数据类型-列表sum()格式：sum(列表)>>>a_list=[80,48,35,95,98,65,99,95,18,71]>>>sorted(a_list,reverse=True)[99,98,95,95,80,71,65,48,35,18]>>>sorted(a_list,reverse=False)[18,35,48,65,71,80,95,95,98,99]3.3组合数据类型-列表sorted()格式：sorted(列表)功能：对列表进行排序，默认是按照升序排序。该方法不会改变原列表的顺序。>>>a_list=[80,48,35,95,98,65,99,95,18,71]>>>sorted(a_list)[18,35,48,65,71,80,95,95,98,99]>>>a_list[80,48,35,95,98,65,99,95,18,71]降序排序:在sorted()函数的列表参数后面增加一个reverse参数，其值等于True表示降序排序，等于Flase表示升序排序。>>>a_list=[80,48,35,95,98,65,99,95,18,71]>>>a_list.sort(reverse=True)>>>a_list[99,98,95,95,80,71,65,48,35,18]>>>a_list.sort(reverse=False)>>>a_list[18,35,48,65,71,80,95,95,98,99]3.3组合数据类型-列表sort()格式：list.sort()功能：对列表进行排序，排序后的新列表会覆盖原列表，默认为升序排序。>>>a_list=[80,48,35,95,98,65,99,95,18,71]>>>a_list.sort()>>>a_list[18,35,48,65,71,80,95,95,98,99]降序排序:在sort()方法中增加一个reverse参数>>>a_list=[80,48,35,95,98,65,99,95,18,71]>>>a_list.reverse()>>>a_list

[71,18,95,99,65,98,95,35,48,80]3.3组合数据类型-列表reverse()格式：list.reverse()功能：对list列表中的元素进行翻转存放，不会对原列表进行排序。方法功能list.append(obj)在列表末尾添加新的对象list.extend(seq)在列表末尾一次性追加另一个序列中的多个值list.insert(index,obj)将对象插入列表list.index(obj)从列表中找出某个值第一个匹配项的索引位置list.count(obj)统计某个元素在列表中出现的次数list.remove(obj)移除列表中某个值的第一个匹配项list.pop(obj=list[-1])移除列表中的一个元素，并返回该元素的值sort()对原列表进行排序reverse()反向存放列表元素cmp(list1,list2)比较两个列表的元素len(list)求列表元素个数max(list)返回列表元素的最大值min(list)返回列表元素的最小值list(seq)将元组转换为列表sum(list)对数值型列表元素求和列表基本操作及常用函数3.3组合数据类型-列表3.列表应用举例【例6.1】从键盘上输入一批数据，对这些数据进行逆置，最后按照逆置后的结果输出。分析：将输入的数据存放在列表中，将列表的所有元素镜像对调，即第一个与最后一个对调，第二个与倒数第二个对调，……。b_list=input("请输入数据:")a_list=[]foriinb_list.split(','):a_list.append(i)print("逆置前数据为:",a_list)n=len(a_list)foriinrange(n//2):a_list[i],a_list[n-i-1]=a_list[n-i-1],a_list[i]print("逆置后数据为:",a_list)3.3组合数据类型-列表【例6.2】编写程序，求出1000以内的所有完数，并按下面的格式输出其因子：6itsfactorsare1，2，3。分析：一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如6就是一个完数，因为6的因子有1、2、3，且6=1+2+3。3.3组合数据类型-列表程序代码：m=1000forainrange(2,m+1):s=0L1=[]foriinrange(1,a):ifa%i==0:s+=iL1.append(i)ifs==a:print("%ditsfactorsare："%a,L1)运行结果：6itsfactorsare：[1,2,3]28itsfactorsare：[1,2,4,7,14]496itsfactorsare：[1,2,4,8,16,31,62,124,248]元组（tuple）的定义形式与列表类似，区别在于定义元组时所有元素放在一对圆括号“(”和“)”中。例如：

(1,2,3,4,5)('Python','C','HTML','Java','Perl')3.3组合数据类型-元组1.元组的基本操作>>>a_tuple=

('physics','chemistry',2017,2.5)>>>b_tuple=(1,2,(3.0,'helloworld!'))>>>c_tuple=('wade',3.0,81,['bosh','haslem'])>>>d_tuple=()>>>x=(1)>>>x1>>>y=(1,)>>>y(1,)

>>>z=(1,2)>>>z(1,2)3.3组合数据类型-元组元组的创建赋值运算符“=”将一个元组赋值给变量即可创建元组对象。创建只包含一个1个元素的元组方法：>>>a_tuple=('physics','chemistry',2017,2.5)>>>a_tuple[1]'chemistry'>>>a_tuple[-1]2.5>>>a_tuple[5]Traceback(mostrecentcalllast):File"<pyshell#14>",line1,in<module>a_tuple[5]IndexError:tupleindexoutofrange3.3组合数据类型-元组读取元素方法为：元组名[索引]>>>a_tuple[1:3]('chemistry',2017)>>>a_tuple[::3]('physics',2.5)元组切片元组也可以进行切片操作，方法与列表类似>>>a_tuple.index(2017)2>>>a_tuple.index('physics',-3)Traceback(mostrecentcalllast):File"<pyshell#24>",line1,in<module>a_tuple.index('physics',-3)ValueError:tuple.index(x):xnotintuple3.3组合数据类型-元组检索元素（1）使用index()方法可以获取指定元素首次出现的下标>>>'chemistry'ina_tupleTrue>>>0.5ina_tupleFalse（2）使用count()方法统计元组中指定元素出现的次数>>>a_tuple.count(2017)1>>>a_tuple.count(1)0（3）使用in运算符检索某个元素是否在该元组中。a_tuple=('physics','chemistry',2017,2.5)>>>dela_tuple>>>a_tupleTraceback(mostrecentcalllast):File"<pyshell#30>",line1,in<module>a_tupleNameError:name'a_tuple'isnotdefined3.3组合数据类型-元组删除元组使用del语句删除元组，删除之后对象就不存在了，再次访问会出错。2.列表与元组的区别及转换列表与元组的区别（1）元组的处理速度和访问速度比列表快。如果定义了一系列常量值，主要对其进行遍历或者类似用途，而不需要对其元素进行修改，这种情况一般使用元组。可以认为元组对不需要修改的数据进行了“写保护”，可以使代码更安全。（2）作为不可变序列，元组（包含数值、字符串和其他元组的不可变数据）可用作字典的键，而列表不可以充当字典的键，因为列表是可变的。3.3组合数据类型-元组列表与元组的转换>>>a_list=['physics','chemistry',2017,2.5,[0.5,3]]>>>tuple(a_list)('physics','chemistry',2017,2.5,[0.5,3])>>>type(a_list)<class'list'>>>>b_tuple=(1,2,(3.0,'helloworld!'))>>>list(b_tuple)[1,2,(3.0,'helloworld!')]>>>type(b_tuple)<class'tuple'>3.3组合数据类型-元组3.元组应用>>>v=('Python',2,True)>>>(x,y,z)=v>>>x'Python'>>>y2>>>zTrue3.3组合数据类型-元组利用元组来一次性给多个变量赋值。Python中的字符串用一对单引号（'）或双引号（"）括起来。例如：>>>'Python' 'Python'>>>"PythonProgram"'PythonProgram'3.3组合数据类型-字符串1.三重引号字符串>>>'''Pythonisan"object-oriented"open-sourceprogramminglanguage''''Pythonisan"object-oriented"\nopen-sourceprogramminglanguage'2.字符串基本操作>>>str1="Hello">>>str1"Hello">>>str2='Program\n\'Python\'' >>>str2"Program\n'Python'"3.3组合数据类型-字符串字符串创建使用赋值运算符“=”将一个字符串赋值给变量字符串元素读取方法为：字符名[索引]>>>str1[0]'H'>>>str1[-1]‘o’>>>str="PythonProgram">>>str[0:5:2] 'Pto'>>>str[:]'PythonProgram'>>>str[-1:-20]''

>>>str[-1:-20:-1]'margorPnohtyP'3.3组合数据类型-字符串字符串分片方法：字符串名[开始索引:结束索引:步长]>>>"Hello"+"World"'HelloWorld'>>>"P"+"y"+"t"+"h"+"o"+"n"+"Program"'PythonProgram'将字符串和数值类型数据进行连接时，需要使用str()函数将数值数据转换成字符串，然后再进行连接运算。>>>"Python"+str(3)'Python3'连接使用运算符“+”，将两个字符串对象连接起来>>>"Hello"*3'HelloHelloHello'>>>3*"HelloWorld!"'HelloWorld!HelloWorld!HelloWorld!'3.3组合数据类型-字符串重复字符串重复操作使用运算符“*”，构建一个由字符串自身重复连接而成的字符串对象。关系运算>>>"a"=="a"True>>>"a"=="A"False>>>"0">"1"False（1）单字符字符串的比较单个字符字符串的比较是按照字符的ASCII码值大小进行比较。>>>"abc"<"abd“True>>>"abc">"abcd“False>>>"abc"<"cde“True>>>""<"0"True关系运算3.3组合数据类型-字符串（2）多个字符字符串的比较注意：空字符串（""）比其他字符串都小，因为它的长度为0。>>>"ab"in"aabb"True>>>"abc"in"aabbcc"False>>>"a"notin"abc"False成员运算字符串使用in或notin运算符判断一个字符串是否属于另一个字符串。字符串1[not]in字符串2

str.find(substr,[start,[,end]])>>>s1="beijingxi'antianjinbeijingchongqing">>>s1.find("beijing")0>>>s1.find("beijing",3)22>>>s1.find("beijing",3,20)-13.3组合数据类型-字符串3.字符串的常用方法子串查找：find()方法字符串替换：replace()方法

str.replace(old,new(,max))>>>s2="thisisstringexample.thisisstringexample.">>>s2.replace("is","was")

'thwaswasstringexample.thwaswasstringexample.'>>>s2="thisisstringexample.thisisstringexample.">>>s2.replace("is","was",2)'thwaswasstringexample.thisisstringexample.'3.3组合数据类型-字符串>>>s3="beijing,xi'an,tianjin,beijing,chongqing">>>s3.split(',')

['beijing',"xi'an",'tianjin','beijing','chongqing']

>>>s3.split('a')

["beijing,xi'",'n,ti','njin,beijing,chongqing']>>>s3.split()

["beijing,xi'an,tianjin,beijing,chongqing"]3.3组合数据类型-字符串字符串分离:str.split([sep])字符串连接

sep.join(sequence)>>>s4=["beijing","xi'an","tianjin","chongqing"]>>>sep="-->">>>str=sep.join(s4)>>>str"beijing-->xi'an-->tianjin-->chongqing">>>s5=("Hello","World")>>>sep="">>>sep.join(s5)'HelloWorld'3.3组合数据类型-字符串4.字符串应用举例【例6.3】从键盘输入5个英文单词，输出其中以元音字母开头的单词。3.3组合数据类型-字符串程序代码：str="AEIOUaeiou"a_list=[]foriinrange(0,5):word=input("请输入一个英文单词：")a_list.append(word)print("输入的5个英文单词是：",a_list)print("首字母是元音的英文单词有：")foriinrange(0,5):forchinstr:ifa_list[i][0]==ch:print(a_list[i])break运行结果：请输入一个英文单词：china请输入一个英文单词：program请输入一个英文单词：Egg请输入一个英文单词：apple请输入一个英文单词：software输入的5个英文单词是：['china','program','Egg','apple','software']首字母是元音的英文单词有：Eggapple【例6.4】输入一段字符，统计其中单词的个数，单词之间用空格分隔。3.3组合数据类型-字符串程序代码：str=input("请输入一串字符：")flag=0count=0

forcinstr:ifc=="":flag=0else:ifflag==0:flag=1count=count+1print("共有%d个单词"%count)运行结果：请输入一串字符：Pythonisanobject-orientedprogramminglanguageoftenusedforrapidapplicationdevelopment共有12个单词【例6.5】输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。分析：首先输入一个字符串，根据字符串中每个字符的ASCII码值判断其类型。数字0~9对应的码值为48~57，大写字母A~Z对应65~90，小写字母a~z对应97~122。使用ord()函数将字符转换为ASCII码表上对应的数值。可以采用先找出各类型的字符，放到不同列表中，再分别计算列表的长度。3.3组合数据类型-字符串程序代码：a_list=list(input('请输入一行字符：'))letter=[]space=[]number=[]other=[]

foriinrange(len(a_list)):iford(a_list[i])inrange(65,91)orord(a_list[i])inrange(97,123):letter.append(a_list[i])elifa_list[i]=='':space.append('')eliford(a_list[i])inrange(48,58):number.append(a_list[i])else:other.append(a_list[i])print('英文字母个数：%s'%len(letter))print('空格个数：%s'%len(apace))print('数字个数：%s'%len(number))print('其他字符个数：%s'%len(other))运行结果：请输入一行字符：Python3.5.2中文版英文字母个数：6空格个数：1数字个数：3其它字符个数：53.3组合数据类型-字典字典（dictionary）是Python语言中唯一的映射类型。这种映射类型由键（key）和值（value）组成，是“键值对”的无序可变序列。定义字典时，每个元组的键和值用冒号分隔，相邻元素之间用逗号分隔，所有的元组放在一对大括号“{”和“}”中。字典中的键可以是Python中任意不可变类型，例如整数、实数、复数、字符串、元组等。键不能重复，而值可以重复。一个键只能对应一个值，但多个键可以对应相同的值。例如：{1001:'Alice',1002:'Tom',1003:'Emily'}{(1,2,3):'A',65.5,'B'}{'Alice':95,'Beth':82,'Tom':65.5,'Emily':95}1.字典常用操作（1）使用“=”将一个字典赋给一个变量>>>a_dict={'Alice':95,'Beth':82,'Tom':65.5,'Emily':95}>>>a_dict{'Emily':95,'Tom':65.5,'Alice':95,'Beth':82}>>>b_dict={}>>>b_dict{}3.3组合数据类型-字典字典的创建（2）使用内建函数dict()>>>c_dict=dict(zip(['one','two','three'],[1,2,3]))>>>c_dict{'three':3,'one':1,'two':2}>>>d_dict=dict(one=1,two=2,three=3)>>>e_dict=dict([('one',1),('two',2),('three',3)])>>>f_dict=dict((('one',1),('two',2),('three',3)))>>>g_dict=dict()>>>g_dict{}

3.3组合数据类型-字典（3）使用内建函数fromkeys()一般形式：dict.fromkeys(seq[,value]))>>>h_dict={}.fromkeys((1,2,3),'student’)>>>h_dict{1:'student',2:'student',3:'student'}>>>i_dict={}.fromkeys((1,2,3))>>>i_dict{1:None,2:None,3:None}>>>j_dict={}.fromkeys(())>>>j_dict{}3.3组合数据类型-字典字典元素的读取（1）使用下标的方法>>>a_dict={'Alice':95,'Beth':82,'Tom':65.5,'Emily':95}>>>a_dict['Tom']65.5>>>a_dict[95]Traceback(mostrecentcalllast):File"<pyshell#32>",line1,in<module>a_dict[95]KeyError:953.3组合数据类型-字典（2）使用get方法获取执行键对于的值一般形式：dict.get(key,default=None)default是指指定的“键”值不存在时，返回的值>>>a_dict.get('Alice')95>>>a_dict.get('a','address')'address'>>>a_dict.get('a')>>>print(a_dict.get('a'))Nonea_dict={'Alice':95,'Beth':82,'Tom':65.5,'Emily':95}字典元素的添加与修改（1）使用“字典名[键名]=键值”形式>>>a_dict['Beth']=79>>>a_dict{'Alice':95,'Beth':79,'Emily':95,'Tom':65.5}>>>a_dict['Eric']=98>>>a_dict{'Alice':95,'Eric':98,'Beth':79,'Emily':95,'Tom':65.5}（2）使用update()方法>>>a_dict={'Alice':95,'Beth':79,'Emily':95,'Tom':65.5}>>>b_dict={'Eric':98,'Tom':82}>>>a_dict.update(b_dict)>>>a_dict{'Alice':95,'Beth':79,'Emily':95,'Tom':82,'Eric':98}a_dict={'Alice':95,'Beth':82,'Tom':65.5,'Emily':95}字典元素的删除（1）使用del命令删除字典中指定“键”对应的元素>>>dela_dict['Beth']>>>a_dict{'Alice':95,'Emily':95,'Tom':82,'Eric':98}>>>dela_dict[82]Traceback(mostrecentcalllast):File"<pyshell#56>",line1,in<module>dela_dict[82]KeyError:82a_dict{'Alice':95,'Beth':79,'Emily':95,'Tom':82,'Eric':98}（2）使用pop()方法删除并返回指定“键”的元素>>>a_dict.pop('Alice')95>>>a_dict{Emily':95,'Tom':82,'Eric':98}（3）使用popitem()方法，删除随机元素并返回删除的键值对>>>a_dict.popitem()('Emily',95)>>>a_dict{'Tom':82,'Eric':98}a_dict{'Alice':95,'Emily':95,'Tom':82,'Eric':98}（4）使用clear()方法>>>a_dict.clear()>>>a_dict{}（5）使用del命令删除整个字典>>>dela_dict>>>a_dictTraceback(mostrecentcalllast):File"<pyshell#68>",line1,in<module>a_dictNameError:name'a_dict'isnotdefined3.3组合数据类型-字典2.字典的遍历一般形式：dict.keys()>>>a_dict.keys()dict_keys(['Tom','Emily','Beth','Alice'])遍历字典关键字一般形式：dict.values()>>>a_dict.values()dict_values([65.5,95,79,95])遍历字典的值3.3组合数据类型-字典一般形式：dict.items()>>>a_dict.items()dict_items([('Tom',65.5),('Emily',95),('Beth',79),('Alice',95)])遍历字典元素3.字典应用举例【例6.6】将一个字典的键和值对调。3.3组合数据类型-字典程序代码：a_dict={'a':1,'b':2,'c':3}b_dict={}forkeyina_dict:b_dict[a_dict[key]]=keyprint(b_dict)运行结果：{1:'a',2:'b',3:'c'}3.字典应用举例【例6.7】输入一串字符，统计其中单词出现的次数，单词之间用空格分隔开。3.3组合数据类型-字典程序运行结果：程序代码：string=input("inputstring:")string_list=string.split()word_dict={}forwordinstring_list:ifwordinword_dict:word_dict[word]+=1else:word_dict[word]=1print(word_dict)运行结果：inputstring:tobeornottobe{'or':1,'not':1,'to':2,'be':2}【例】《Hamlet》英文词频统计3.3组合数据类型-字典程序代码：defgetText():txt=open("hamlet.txt","r").read()txt=txt.lower()forchin'!"#$%&()*+,-./:;<=>?@[\\]^_‘{|}~':txt=txt.replace(ch,"")returntxthamletTxt=getText()words=hamletTxt.split()counts={}forwordinwords:counts[word]=counts.get(word,0)+1items=list(counts.items())items.sort(key=lambdax:x[1],reverse=True)foriinrange(10):word,count=items[i]print("{0:<10}{1:>5}".format(word,count))1.集合常用操作集合的创建（1）用一对大括号将多个用逗号分隔的数据括起来>>>a_set={0,1,2,3,4,5,6,7,8,9}>>>a_set{0,1,2,3,4,5,6,7,8,9}>>>b_set={1,3,3,5}//重复元素>>>b_