序列
-
序列中每个元素都有一个跟位置相关的序号称为索引
-
常见的序列:字符串、列表、元组
-
序列对象可迭代,也就是可以遍历,序列对象的迭代要用到它的索引
-
访问模式:元素从0开始通过下标偏移量进行访问
-
一次可访问一个或多个元素,也叫做切片
-
标准类型运算符:值比较、对象身份比较、布尔运算
-
内建函数:序列类型转换内建函数、序列类型可用内建函数
-
list():把一个可迭代对象转换为列表
-
tuple([iterable]):把一个可迭代对象转换为元组
-
str(obj):把obj对象转换为字符串
-
len(sub):返回长度
扫描二维码关注公众号,回复: 10343569 查看本文章 -
max():返回序列或者参数集合中的最大值
-
min():返回序列或者参数集合中的最小值
注意:使用max()和min()要保证数据类型是统一的
>>> a = 'i love Python!'
>>> a = list(a)
>>> a
['i', ' ', 'l', 'o', 'v', 'e', ' ', 'P', 'y', 't', 'h', 'o', 'n', '!']
>>> b = (1,2,3,5,8,12,14,11)
>>> b = list(b)
>>> b
[1, 2, 3, 5, 8, 12, 14, 11]
>>> len(b)
8
>>> max(b)
14
>>> min(b)
1
zip()
:用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元组组成的对象,这样做的好处是节约了不少的内存。
>>> a = [1,2,3,4,5,6]
>>> b = [2,3,4,5,7,8]
>>> list(zip(a,b))
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 7), (6, 8)]
'apple' < 'banana'
Out[1]: True
[1,3,5] != [2,4,6]
Out[2]: True
aTuple = ('BA','The Boeing Company','122.64')
bTuple = aTuple
bTuple is not aTuple
Out[5]: False
('86.40' < '122.64' ) and ('apple' > 'banana')
Out[6]: False
- 序列类型运算符:获取、重复、连接、判断
week = ['Monday','Tuesday','Wednesday','Thursday','Friday','Saturday','Sunday']
print(week[1],week[-2],'\n',week[1:4],'\n',week[:6],'\n',week[::-1])
Tuesday Saturday
['Tuesday', 'Wednesday', 'Thursday']
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
['Sunday', 'Saturday', 'Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']
'apple' * 3
Out[9]: 'appleappleapple'
'pine' + 'apple'
Out[10]: 'pineapple'
'BA' in ('BA','The Boeing Company','122.64')
Out[11]: True
week[-5::]
Out[12]: ['Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
week[1:-1]
Out[13]: ['Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
- 序列类型转换内建函数
>>> Str = 'hello,world!'
>>> len(Str)
12#长度
>>> sorted(Str)
['!', ',', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']
#排序
>>> max(Str)
'w'
#最大
>>> min(Str)
'!'
#最小
>>> Str = ('h','e','l','l','o')
>>> print(list(reversed(Str)))
['o', 'l', 'l', 'e', 'h']
>>> Str = 'hello world'
>>> print(list(reversed(Str)))
['d', 'l', 'r', 'o', 'w', ' ', 'o', 'l', 'l', 'e', 'h']
#reversed()函数:反转
>>> sum([1,2,3,4,5,6,7,8,9])
45
#求和
>>> 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', '!')
enumerate()函数
:既遍历索引又遍历值时使用较为方便
dict = [{"name":"小明","age":19},{"name":"小王","age":"20"},{"name":"小李","age":"21"}]
for index,t in enumerate(dict):
print(index,t)
0 {'name': '小明', 'age': 19}
1 {'name': '小王', 'age': '20'}
2 {'name': '小李', 'age': '21'}
zip()函数
:由一系列可迭代的对象作为参数,返回一个zip对象,把对象对应的元素打包成一个一个的元组
x = [1,2,3,4,5,6]
y = ['a','b','c','d','e','f']
for num,str in zip(x,y):
print(num,str)
1 a
2 b
3 c
4 d
5 e
6 f
字符串
-
常用方法:
-
casefold
:把整个字符串的所有字母改成小写 -
center(width)
:将字符串居中,并使用空格填充至长度width的新字符串。 -
count(sub[,start[,end]])
:返回sub在字符串里面出现的次数,start和end参数表示范围,可选。 -
endswith(sub[,start[,end]])
:检查字符串是否以sub子字符串结束,如果是返回True,如果不是返回False,start和end表示范围,可选。 -
find(sub[,start[,end]])
:检测sub是否包含在字符串中,如果有则返回索引值,否则返回-1,start和end表示参数范围,可选。 -
index(sub[,start[,end]])
:跟find方法一样,不过如果sub不在字符串中会产生一个异常。 -
isalnum()
:如果字符串至少有一个字符并且所有字符都是字母或数字返回True,否则返回False. -
isalpha()
:如果字符串中至少含有一个字符并且所有字符都是字母返回True,否则返回False. -
isdecimal()
:如果字符串中只包含十进制数字则返回True,否则返回False. -
isdigit()
:如果字符串中只包含数字则返回True,否则返回False. -
islower()
:如果字符串中至少包含一个区分大小写的字符,并且这些字符都是小写则返回True,否则返回False。 -
isnumeric()
:如果字符串中只包含数字字符,则返回True,否则返回False. -
isspace()
:如果字符串中只包含空格,则返回True,否则返回False. -
istitle()
:如果字符串是标题化(所有的单词都是以大写开始其余字母均是小写)则返回True,否则返回False. -
isupper()
:如果字符串中至少包含一个区分大小写的字符,并且这些字符都是大写则返回True,否则返回False. -
join(sub)
:以字符串作为分隔符,插入到sub中所有的字符之间。
>>> aStr = 'HELLO,python'
>>> aStr.casefold()
'hello,python'
>>> aStr.center(20)
' HELLO,python '
>>> a = 'absabdabsdbaasd'
>>> a.count('a')
5
>>> a.count('a',1,10)
2
aStr = 'hello,world!'#字符串
bStr = "student"
cStr = '''the boeing'''
>>> s1 = "I'm a student"
>>> s1
"I'm a student"
>>> s2 = '''hello
world'''
>>> s2
'hello\nworld'
>>> s3 = r'd:\Python\test.py'
aStr = "Hello,world!"
bStr = aStr[:6] + "Python!"
count = 0
for ch in bStr[:]:
if ch in ',.!?':
count += 1
print("Punctuation marks = {:d}".format(count))
print(bStr)
Punctuation marks = 2
Hello,Python!
>>> s1 = "I'm a student"
>>> s1
"I'm a student"
>>> s2 = '''hello
world'''
>>> s2
'hello\nworld'
>>> s3 = r'd:\Python\test.py'
>>> song = "Blowing in the wind"
>>> song.find("the")
11
>>> song.find("the",8,12)
-1
>>> song.lower()#不改变本身的song
'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)
'hello world'
>>> y = "你好"
>>> z = y.encode('utf-8')#编码
>>> z
b'\xe4\xbd\xa0\xe5\xa5\xbd'
>>> t = z.decode()#解码
>>> t
'你好'
>>> c = b'\xe6\x89\x8e\xe5\xbf\x83\xe4\xba\x86\xef\xbc\x8c\xe8\x80\x81\xe9\x93\x81'
>>> t = c.decode()
>>> t
'扎心了,老铁'
aStr = 'What do you think of this saying "NO pain,NO gain"?'
tempStr = aStr.split("\"")[1]
if tempStr.istitle():
print('It is title format.')
else:
print('It is not title format.')
print(tempStr.title())
It is not title format.
No Pain,No Gain
- 回文方法:
str = str[::-1]
列表
- 列表是可扩展的容器对象
- append()
- copy()
- count()
- extend()
- index()
- insert()
- pop()
- remove()
- reverse()
- sort()
- 注意sort()与sorted(),reverse()与reversed()
aList = [2,3,6,7,11]#列表
pList = [('AXP','American Express Company','78.51'),('BA','The Boeing Company','184.76')]#由元组组成的列表
jScores = [9,9,8.5,10,7,8,8,9,8,10]
aScore = 9
jScores.sort()
jScores.pop()#弹出最后一个值
jScores.pop(0)#加上索引弹值
jScores.append(aScore)
aveScore = sum(jScores)/len(jScores)
print(jScores)
print(aveScore)
[8, 8, 8.5, 9, 9, 9, 10, 9]
8.722222222222221
week = ['Monday','Tuesday','Wednesday','Thursday','Friday']
weekend = ['Saturday','Sunday']
week.extend(weekend)
for i,j in enumerate(week):
print(i+1,j)
1 Monday
2 Tuesday
3 Wednesday
4 Thursday
5 Friday
6 Saturday
7 Sunday
- 参数的作用:
list.sort(key = None,reverse = False)
numList = [3,11,5,8,16,1]
fruitList = ['apple','banana','pear','lemon','avocado']
numList.sort(reverse = True)
print(numList)
fruitList.sort(key = len)
print(fruitList)
[16, 11, 8, 5, 3, 1]
['pear', 'apple', 'lemon', 'banana', 'avocado']
- 列表解析:在改变列表时使用
[expression for expr in sequence 1
for expr2 in sequence 2
for exprN in sequence N
if condition]
>>> [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)]
def clean_list(lst):
cleaned_list = []
for item in lst:
for c in item:
if c.isalpha() != True:
item = item.replace(c,'')
cleaned_list.append(item)
return cleaned_list
coffee_list = ['32Latte','_Americano30','/34Cappuccino','Mocha35']
cleaned_list = clean_list(coffee_list)
1 Latte
2 Americano
3 Cappuccino
4 Mocha
元组
aTuple = ('Sunday','happy')#元组
pList = [('AXP','American Express Company','78.51'),('BA','The Boeing Company','184.76')]#由元组组成的列表
>>> bTuple = (['Monday',1],2,3)
>>> bTuple
(['Monday', 1], 2, 3)
>>> bTuple[0][1]
1#获得二级长度值
>>> len(bTuple)
3
>>> bTuple[1:]
(2, 3)#切片
>>> 2020,
(2020,)#创建一个元素的元组
>>> aList = ['AXP','BA','CAT']
>>> aTuple = ('AXP','BA','CAT')
>>> aList[1] = 'Alibiabia'
>>> print(aList)
['AXP', 'Alibiabia', 'CAT']#列表可以改变元组不可以改变
>>> aList = [3,5,2,4]
>>> aList
[3, 5, 2, 4]
>>> sorted(aList)
[2, 3, 4, 5]
>>> aList
[3, 5, 2, 4]#sorted()生成一个副本不改变原始列表
>>> aList.sort()
>>> aList
[2, 3, 4, 5]#原始列表被改变
>>> bTuple = (2,3,4,7,5,6)
>>> bTuple
(2, 3, 4, 7, 5, 6)
>>> sorted(bTuple)
[2, 3, 4, 5, 6, 7]
>>> bTuple.sort()#元组对象没有sort方法
Traceback (most recent call last):
File "<pyshell#21>", line 1, in <module>
bTuple.sort()
AttributeError: 'tuple' object has no attribute 'sort'
元组在Python中的使用:
- 在映射中作为键来使用,利用元组不可变性
- 作为函数的特殊类型参数
>>> foo('Hello,')
Hello, world!
>>> foo('Hello,',args2='Python!')
Hello, Python!
>>> foo(args2='Apple!',args1='Hello,')
Hello, Apple!
>>> foo('Hello,','wangdachui','niuyun','linling')
Hello,
('wangdachui', 'niuyun', 'linling')#Python中利用元组作为函数的参数,元组的长度是不定长的(*号可以用来收集参数)
- 作为函数的特殊返回类型
>>> def foo():
return 1,2,3
>>> foo()
(1, 2, 3)#