python 序列练习 python序列运算

 

一、序列

序列对象是可迭代的，即可以遍历对象的内部元素。
切片：一次性访问多个元素。

序列相关操作
1.标准类型运算符：值比较（<,>,<=,>=）、对象身份比较(is,is not)、布尔运算(not,and,or)
2.序列类型运算符：获取、重复、连接、判断
3.内建函数：序列类型转换内建函数、序列类型可用内建函数

序列的基本用法示例：

>>> 'apple'<'banana' #比较两个字符串大小
True
>>> [1,3,5]!=[2,4,6] #比较两个列表的大小
True
>>> aTuple=('BA','The Boeing Company','122.64') #创建元组
>>> bTuple=aTuple #复制元组
>>> bTuple is not aTuple
False
>>> #以上是标准类型运算符
>>> #序列类型运算符
>>> week=['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']
>>> print(week[1],week[-1]) #正向索引从0开始，逆向索引从-1开始
Tuesday Sunday
>>> print(week[1:4],'\n',week[:6],'\n') #输出[1,4)，[0,6)
['Tuesday', 'Wednesday', 'Thursday'] 
 ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'] 

>>> print(week[::-1]) #切片序列，对原来的序列进行倒置
['Sunday', 'Saturday', 'Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']
>>> 'pi'*3 #*复制
'pipipi'
>>> 'pi'+'=3.14' #连接运算符
'pi=3.14'
>>> ('i' in 'pi') and ('j' not in 'pi')  #判断某个对象是否包含在序列中
True
>>> #序列类型转换内建函数
>>> list('Hello,World!') #将字符串转成列表
['H', 'e', 'l', 'l', 'o', ',', 'W', 'o', 'r', 'l', 'd', '!']
>>> tuple('Hello,World!') #将字符串转成元组
('H', 'e', 'l', 'l', 'o', ',', 'W', 'o', 'r', 'l', 'd', '!')
>>> #也可通过str()函数将一个元组或列表转成字符串
>>> aStr='Hello,World!'
>>> len(aStr) #求序列长度
12
>>> sorted(aStr) #对序列元素进行排序
['!', ',', 'H', 'W', 'd', 'e', 'l', 'l', 'l', 'o', 'o', 'r']
>>> max(aStr) #求序列里的最大值
'r'
>>> min(sStr) #求序列里的最小值
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    min(sStr) #求序列里的最小值
NameError: name 'sStr' is not defined
>>> min(aStr) #求序列里的最小值
'!'
>>> sum(aStr) #对序列求和
Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    sum(aStr) #对序列求和
TypeError: unsupported operand type(s) for +: 'int' and 'str'
>>> reversed(aStr) #逆序
<reversed object at 0x0000006FC69A6B38>
>>> enumerate(aStr) #返回一个enumerate对象，其元素是由索引和值构成的一个个元组
<enumerate object at 0x0000006FC6D3B948>
>>> # enumerate 在又要遍历索引，又要遍历元素的时候，使用起来非常方便
>>> zip() #由一系列可迭代对象作为参数，返回一个zip对象，把对象对应的元素打包成一个一个的元组
<zip object at 0x0000006FC6D68A08>
>>> range() #也是一个常用序列

留意enumerate()和zip()的使用。

二、字符串

1.用三引号表示有换行的字符串

>>> s1='''hello
world'''
>>> s1  #用三引号表示有换行的字符串
'hello\nworld'

2.表示文件路径

>>> s3=r'd:\python\test.py' #表示文件路径
>>> s3
'd:\\python\\test.py'

3.元素的替换

>>> aStr='Hello,World!'
>>> bStr=aStr[:6]+'Python'  #将aStr中的World替换成Python
>>> bStr
'Hello,Python'

4.接上，计算字符串中标点符号的个数

>>> count=0
>>> for ch in bStr[:]:  #计算bStr中字符的个数
	if ch in ',.!?': #计算标点的个数
		count+=1

>>> print(count)
1

5.格式化输出
（数值数据默认的对齐方式是左对齐，字符串默认右对齐，可用一个<使字符串左对齐）

>>> age,height=21,1.758
>>> print('Age:{0:<5d},Height:{1:5.2f}'.format(age,height))
Age:21   ,Height: 1.76
>>> cCode=['AXP','BA','CAT','CSCO','CVX']
>>> cPrice=['78.51','184.76','96.39','33.71','106.09']
>>> for i in range(5):
	print('{:<8d}{:8s}{:8s}'.format(i,cCode[i],cPrice[i]))

0       AXP     78.51   
1       BA      184.76  
2       CAT     96.39   
3       CSCO    33.71   
4       CVX     106.09

print()函数的常用格式：

类型说明符：

其他常用格式说明符

案例1
判断一个字符串是否为回文串

#判断一个字符串是否为回文串
import operator
sStr='acdhdca'

#法一：
if(sStr==''.join(reversed(sStr))):
   print('Yes')
else:
   print('No')

#法二：
if operator.eq(sStr,''.join(reversed(sStr)))==0:
    print('Yes')
else:
    print('No')

#法三：
if(sStr==sStr[::-1]): #将字符串倒置
    print('Yes')
else:
    print('No')

字符串的常用方法

示例：

>>> song="Blowing in the wind"
>>> song.find("the") #查找某个子串在字符串中的位置
11
>>> song.find("the",8,12) #查找[8,12)的范围中子串的位置，返回-1表示没有找到
-1
>>> song.lower()  #将字符串转换成小写的方式，中间结果，原始的字符串没有变化
'blowing in the wind'
>>> song
'Blowing in the wind'
>>> song.split(' ') #将字符串按某个特征截断，此处为按空格截断
['Blowing', 'in', 'the', 'wind']
>>> song.replace("the","that") #替换
'Blowing in that wind'
>>> aList=['hello','world']
>>> ' '.join(aList) #用空格连接aList中的字符串元素
'hello world'
>>> y="你好"
>>> z=y.encode('utf-8') #将字符串编码成字节包(bytes对象)
>>> z
b'\xe4\xbd\xa0\xe5\xa5\xbd'
>>> x=z.decode() #对字符串进行解码
>>> x
'你好'

案例2
对于句子中双引号的内容，首先判断其是否满足标题格式，不管满足与否最终都将其转换为标题格式输出

aStr='What do you think of this saying "No pain,No gain"?'

#法一：
lindex=aStr.index('\"',0,len(aStr))  #标记左双引号的位置
rindex=aStr.rindex('\"',0,len(aStr)) #标记右双引号的位置，转义字符表双引号 \"
tempStr=aStr[lindex+1:rindex] #保存双引号中的字符串
print(tempStr)
if tempStr.istitle():  #判断字符串是不是标题格式
    print('It is title format.')
else:
    print('It is not title format.')
print(tempStr.title())

#法二：
tempstr=aStr.split("\"")[1] #依据双引号将字符串分成三段，选取中间的一段
if tempstr.istitle():  #判断字符串是不是标题格式
    print('It is title format.')
else:
    print('It is not title format.')
print(tempstr.title())

三、列表

python中字符串是不可变的，变化主要靠列表

列表是一种可扩展的容器对象
（容器：
Python中的一种数据对象，基本上就是包含其他对象的任意对象
列表、元组、映射、字典 是Python中的主要容器）

可通过重新赋值改变列表中的元素
同一个列表可包含不同的元素类型（整型、字符型、实型……），或以元组等容器作为其中的元素

列表可以用适用序列的函数和它自己独有的方法。

案例1
某学校组织了一场校园歌手比赛，每个歌手得分由10名
评委和观众决定，最终得分的规则是去掉10名评委所打
分数的一个最高分和一个最低分，再加上所有观众评委
分数后的平均值，求该选手的最终得分。

jScores=[9,9,8.5,10,7,8,8,9,8,10] #评委打分
aScore=9 #观众打分
x=sorted(jScores) #函数 jScores的值并不会改变，而将排序的结果给x
jScores.sort() #方法 排序  令参数reverse=True可实现逆序排序
jScores.pop() #弹出列表中的最后一个值
jScores.pop(0) #弹出下标为0的元素
jScores.append(aScore) #将某一元素添加到列表之后
aveScore=sum(jScores)/len(jScores)
print(aveScore)

案例2
将工作日([‘Monday’,‘Tuesday’,‘Wednesday’,‘Thursday’,‘Friday’])
和周末([‘Saturday’,‘Sunday’])的表示形式合并，并将它们用序号标出并分行显示

week=['Monday','Tuesday','Wednesday','Thursday','Friday']
weekend=['Saturday','Sunday']
week.extend(weekend) #对两个列表进行合并，注意和append()区分
for i,j in enumerate(week): #enumerate既遍历索引，又遍历元素本身
    print(i+1,j)

列表解析
在需要改变列表而不是新建列表的时候使用它
解析的基本语法：由多个for循环以及可迭代的序列构成，此外还可加条件(可选)
示例：

[expression for expr1 in sequence1
            for expr2 in sequence2
            for exprN in sequenceN
            if condition]

语法1：迭代sequence里面的内容，每次迭代，都将其放进expr对象中去，再在表达式中应用这样的一个对象，形成列表
语法2：加入判断语句，只有满足条件，才执行如上操作

>>> [x for x in range(10)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [x**2 for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> [x**2 for x in range(10) if x**2<50]
[0, 1, 4, 9, 16, 25, 36, 49]
>>> [(x+1,y+1) for x in range(2) for y in range(2)]
[(1, 1), (1, 2), (2, 1), (2, 2)]

生成器表达式 Generator expression
用圆括号创建生成器表达式，生成器表达式并不是创建一个列表，而是返回一个生成器,这个生成器在每次计算一个条目以后，才把这个条目产生出来，所以在大数据量处理的时候有优势
案例
有一个咖啡列表[‘32Latte’,’_Americano30’,’/34Cappuccino’,‘Mocha35’]，列表中的每一个元素都是咖啡名称、价格和一些其他非字母字符组成，编写一个程序处理列表，使得处理后的列表中只含咖啡名称

def clean_list(lst):
    cleaned_list=[]
    for item in lst:
        for c in item:
            if c.isalpha()!=True: #如果字符c不是字母
                item=item.replace(c,'') #item本身不可变，但item.replace()的返回结果是我们需要的，所以item=
        cleaned_list.append(item) #将处理后的结果放入一个新列表
    return cleaned_list

coffee_list=['32Latte','_Americano30','/34Cappuccino','Mocha35']
cleaned_list=clean_list(coffee_list)
for k,v in zip(range(1,len(cleaned_list)+1),cleaned_list):
    print(k,v)

四、元组

元组的使用和列表相似，但是元组是不可变的，而列表是可变的。
由于元组中的元素是不能被改变的，所以元组不支持sort()方法，但对序列通用的sorted方法对元组是适用的。

元组的一些基本操作：

>>> bTuple=(['Monday',1],2,3)
>>> bTuple
(['Monday', 1], 2, 3)
>>> bTuple[1:] #对元组进行切片操作
(2, 3)
>>> len(bTuple) #计算元组长度
3
>>> bTuple[0][1] #获得二级元素的值
1
>>> 2020, #创建只有一个元素的元组
(2020,)
>>> aList=['AXP','BA','CAT']
>>> aTuple=('AXP','BA','CAT')
>>> aList[1]='Alibaba' #列表元素可以改变
>>> print(aList)
['AXP', 'Alibaba', 'CAT']
>>> aTuple[1]='Alibaba' #元组元素不可以改变
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    aTuple[1]='Alibaba' #元组元素不可以改变
TypeError: 'tuple' object does not support item assignment

在Python中元组主要用在以下三个地方：
1.在映射类型中当做键来使用（因为它不可变）
2.作为函数的特殊类型参数
3.作为函数的特殊返回值

**案例：**元组作为函数的特殊类型参数（可变长位置参数）

>>> def foo(args1,*argst):
	print(args1)
	print(argst)

>>> foo('Hello','Wang','Niu','Lin') #此处为位置参数
Hello
('Wang', 'Niu', 'Lin')

星号*有收集参数的作用
Python当做多个参数可以构成一个元组作为函数的参数，而元组的个数是不定长的，所以这即为可变长的函数参数

**案例：**元组作为函数特殊返回类型

>>> def f():
	return 1,2,3 #返回多个值

>>> f()
(1, 2, 3)
>>>

让主调函数和被调函数数据间交互的功能更加灵活和强大，又让Python与C、Java等传统的程序语言保持一致，即返回对象只有一个