Python期末复习-系列数据类型
其他复习资料
python期末复习-CSDN博客
期末python复习-异常和函数-CSDN博客
期末Python复习-输入输出-CSDN博客
目录
一、系列数据概况
1.元组
2.列表
3.字符串
4.字节系列
二、系列数据的基本操作
1.元组
2.列表
3.字符串
4.字节数据
三、系列的索引访问操作
1.元组
2.列表
3.字符串
4.字节数据
四、系列的切片操作
1.元组
2.列表
3.字符串
4.字节数据
五、系列的连接和重复操作
1.元组
2.列表
3.字符串
4.字节数据
六、系列的成员关系操作
1.元组
2.列表
3.字符串
4.字节数据
七、系列的比较运算操作
1.元组
2.列表
3.字符串
4.字节数据
八、列表的系列基本操作实例
九、字符串的格式化
1.%运算符格式
2.format内置函数
十、字节系列
创建bytes对象
一、系列数据概况
Python内置的序列数据类型有
- 元组（tuple）
- 列表（list）
- 字符串（str）
- 字节数据（bytes和bytearray）
1.元组
元组也称之为定值表，用于存储值固定不变的值表。例如：
>>> s1=(1,2,3)
>>> s1 #输出：(1, 2, 3)
>>> s1[2] #输出：3
2.列表
列表也称之为表，用于存储其值可变的表。例如：
>>> s2=[1,2,3]
>>> s2[2]=4
>>> s2 #输出：[1, 2, 4]
3.字符串
字符串是包括若干字符的序列数据，支持序列数据的基本操作。例如：
>>> s3="Hello, world!"
>>> s3[:5] #字符串前5个字符。输出：'Hello'
4.字节系列
字节系列数据是包括若干字节的序列。Python抓取网页时返回的页面，通常为utf-8编码的字节序列。字节系列和字符串直接可以相互转换。例如：
>>> s1=b"abc"
>>> s1.decode("utf-8") #输出：'abc'
>>> s2="百度"
>>> s2.encode("utf-8") #输出：b'\xe7\x99\xbe\xe5\xba\xa6'
二、系列数据的基本操作
系列的长度、最大值、最小值、求和 len()、max()、min()，获取系列的长度、系列中元素最大值、系列中元素最小值；
sum()获取列表或元组中各元素之和；
下面是各个系列的长度、最大值、最小值操作示例：
1.元组
>>> t=(10,2,3)
>>> len(t)
3
>>> max(t)
10
>>> min(t)
2
>>> t2=()
>>> len(t2)
0
2.列表
>>> lst=[1,2,9,5,4]
>>> len(lst)
5
>>> max(lst)
9
>>> min(lst)
1
>>> lst2=[]
>>> len(lst2)
0
3.字符串
>>> s='abcdefg'
>>> len(s)
7
>>> max(s)
'g'
>>> min(s)
'a'
>>> s2=''
>>> len(s2)
0
4.字节数据
>>> b=b'ABCD'
>>> len(b)
4
>>> max(b)
68
>>> min(b)
65
>>> b2=b''
>>> len(b2)
0
三、系列的索引访问操作
1.元组
>>> t=('a','e','i','o','u')
>>> t[0]
'a'
>>> t[1]
'e'
>>> t[-1] #从右往左数第一个
'u'
>>> t[-5] #从右往左数第五个
'a'
2.列表
>>> lst=[1,2,3,4,5]
>>> lst[0]
1
>>> lst
[1, 2, 3, 4, 5]
>>> lst[2]='a' #修改索引为2的元素
>>> lst[-2]='b' #修改索引为-2的元素
>>> lst
[1, 2, 'a', 'b', 5]
3.字符串
>>> s='abcdef'
>>> s[0]
'a'
>>> s[2]
'c'
>>> s[-1]
'f'
>>> s[-3]
'd'
4.字节数据
>>> b=b'ABCDEF'
>>> b[0]
65
>>> b[1]
66
>>> b[-1]
70
>>> b[-2]
69
系列的索引图如下：
四、系列的切片操作
基本语法为：
s[i:j]或s[i:j:k]
其中i为起始索引，j为终止索引，k为步长，若k不指定则默认为01.元组
>>> t=('a','e','i','o','u')
>>> t[-2:-1] #输出索引为-2到-1的元素，不包含-1
('o',)
>>> t[-2:] #输出索引为-2到队尾的元素
('o', 'u')
>>> t[-99:-5] #t[-99] 实际上会被视为 t[-(len(t) + 1 - 99)]，即 t[-5]，因为 -99 比元组的长度
#-5 还要小。Python会将这个索引调整为从元组末尾开始的相对位置。t[-5] 指向元组的第
#五个元素，即 'u'。
#t[-5:-5] 会输出一个空的元组 ()，因为起始索引和结束索引相同，没有元素被包含在切片
#中。
()
>>> t[-99:-3] #解释如上，实际为t[-5:-3]
('a', 'e')
>>> t[::] #元组所有数据
('a', 'e', 'i', 'o', 'u')
>>> t[1:-1]
('e', 'i', 'o') #输出索引为1到-1的元素，不包含-1
>>> t[1::2] #输出奇数索引的元素
('e', 'o')
2.列表
>>> lst=[1,2,3,4,5]
>>> lst[:2] #起始索引默认为0，输出0到2之间的元素，不包含2
[1, 2]
>>> lst[:1]=[] #在Python中，当你对列表进行切片并赋值为空列表 `[]` 时，实际上是在删除该切片范
#围内的所有元素。
#对于列表 `lst = [1, 2, 3, 4, 5]`，执行 `lst[:1] = []` 意味着你将从列表的开
#始到第一个元素（不包括第一个元素，因为切片是左闭右开的）的所有元素删除。在这个
#例子中，切片 `lst[:1]` 只包含第一个元素 `1`。
#执行这个操作后，列表 `lst` 将只剩下 `[2, 3, 4, 5]`。
>>> lst
[2, 3, 4, 5]
>>> lst[:2]
[2, 3]
>>> lst[:2]='a' #将lst剪切为2个数据并且全设为‘a’
>>> lst[1:]='b' #第二个数据设为‘b’
>>> lst
['a', 'b']
>>> del lst[:1] #删除第一个元素
>>> lst
['b']
3.字符串
>>> s='abcdef' #最大索引为5
>>> s[1:3] #输出索引为1到3的元素，不包含3
'bc'
>>> s[3:10] #在Python中，如果切片的结束索引超出了字符串的长度，Python会将结束索引视为字符串
#的末尾。因此，s[3:10] 会包含从索引 3 到字符串末尾的所有字符。
#所以，s[3:10] 会输出 'def'，这是从索引3开始直到字符串结束的所有字符。
'def'
>>> s[8:2] #由于起始索引 8 超出了字符串的范围，Python会将其视为从字符串的开始处进行切片。
#因此，s[8:2] 实际上会从字符串的开始处切片到索引 2（包含索引 2 处的字符）。
#所以，s[8:2] 会输出 'ab'，
'ab'
>>> s[:] #输出列表所有元素
'abcdef'
>>> s[:2] #同上
'ab'
>>> s[::2] #输出列表偶数索引
'ace'
>>> s[::-1] #倒序输出列表所有元素
'fedcba'
4.字节数据
>>> 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:len(b)]
b'ABCDEF'
五、系列的连接和重复操作
1.元组
就是一个很简单的拼接操作
>>> 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')
2.列表
跟元组的操作基本一致
>>> 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']
3.字符串
>>> s1='abc'
>>> s2='xyz'
>>> s1+s2
'abcxyz'
>>> s1*3
'abcabcabc'
>>> s1 += s2
>>> s1
'abcxyz'
>>> s2 *= 2
>>> s2
'xyzxyz'
4.字节数据
>>> b1=b'ABC'
>>> b2=b'XYZ'
>>> b1+b2
b'ABCXYZ'
>>> b1*3
b'ABCABCABC'
>>> b1+=b2
>>> b1
b'ABCXYZ'
>>> b2*=2
>>> b2
b'XYZXYZ'
六、系列的成员关系操作
1.元组
>>> t=('r', 'g', 'b')
>>> 'r' in t
True
>>> 'y' not in t
True
>>> t.count('r')
1
>>> t.index('g')
1
2.列表
>>> lst=[1,2,3,2,1]
>>> 1 in lst
True
>>> 2 not in lst
False
>>> lst.count(1)
2
>>> lst.index(3)
2
3.字符串
>>> s='Good, better, best!'
>>> 'o' in s
True
>>> 'g' not in s
True
>>> s.count('e')
3
>>> s.index('e', 10)
10
4.字节数据
>>> b=b'Oh, Jesus!'
>>> b'O' in b
True
>>> b'o' not in b
True
>>> b.count(b's')
2
>>> b.index(b's')
6
七、系列的比较运算操作
1.元组
元组和列表的比较比较特殊，当（1,2）与（2,1）比较时，会一个一个的比较，比如第一步就是先拿1和2比较，明显2>1，只要出结果了立马停止，不会去那后面的数据作比较了，因此（2,1）>(1,2)，同理（2,1）>(1,2,3,4...)。
>>> t1=(1,2)
>>> t2=(1,2)
>>> t3=(1,2,3)
>>> t4=(2,1)
>>> t1<t4
True
>>> t1 <= t2
True
>>> t1 == t3
False
>>> t1 != t2
False
>>> t1 >= t3
False
>>> t4 > t3
True
2.列表
如果里面是字母，那比较的就是ASCII码值
>>> s1=['a','b']
>>> s2=['a','b']
>>> s3=['a','b','c']
>>> s4=['c','b','a']
>>> s1<s2
False
>>> s1<=s2
True
>>> s1==s2
True
>>> s1!=s3
True
>>> s1>=s3
False
>>> s4>s3
True
3.字符串
在字符串中，== 比较的是两个字符串中的值
>>> s1='abc'
>>> s2='abc'
>>> s3='abcd'
>>> s4='cba'
>>> s1 > s4
False
>>> s2 <= s3
True
>>> s1 == s2
True
>>> s1 != s3
True
>>> 'a' > 'A'
True
>>> 'a' >= ''
True
4.字节数据
>>> b1=b'abc'
>>> b2=b'abc'
>>> b3=b'abcd'
>>> b4=b'ABCD'
>>> b1<b2
False
>>> b1<=b2
True
>>> b1==b2
True
>>> b1>=b3
False
>>> b3!=b4
True
>>> b4>b3
False
八、列表的系列基本操作实例
>>> s=[1,2,3,4,5,6]
>>> s[1]='a'
>>> s
[1, 'a', 3, 4, 5, 6]
>>> s[2]=[]
>>> s
[1, 'a', [], 4, 5, 6]
>>> del s[3]
>>> s
[1, 'a', [], 5, 6]
>>> s[:2]
[1, 'a']
>>> s[2:3]=[]
>>> s
[1, 'a', 5, 6]
>>> s[:1]=[]
>>> s
['a', 5, 6]
>>> s[:2]='b'
>>> s
['b', 6]
>>> del s[:1]
>>> s
[6]
list对象的方法
九、字符串的格式化
1.%运算符格式
>>> '结果：%f' % 88 #输出：'结果：88.000000'
>>> '姓名：%s, 年龄：%d, 体重：%3.2f' % ('张三', 20, 53)
'姓名：张三, 年龄：20, 体重：53.00'
>>> '%(lang)s has %(num)03d quote types.' % {'lang':'Python', 'num': 2}
'Python has 002 quote types.'
>>> '%0*.*f' % (10, 5, 88) #输出：'0088.00000‘
'0088.00000'
2.format内置函数
>>> format(81.2, "0.5f") #输出：'81.20000'
>>> format(81.2, "%") #输出：'8120.000000%'
>>> format(1000000, "_") #输出：1_000_000'
>>> format(1024, "_b") #输出：'100_0000_0000'
>>> "int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(100)
'int: 100; hex: 64; oct: 144; bin: 1100100'
>>> "int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(100)
'int: 100; hex: 0x64; oct: 0o144; bin: 0b1100100'
>>> '{2}, {1}, {0}'.format('a', 'b', 'c') #输出：'c, b, a‘
'c, b, a'
>>> str.format_map('{name:s},{age:d},{weight:3.2f}', {'name':'Mary', 'age':20, 'weight':49})
'Mary,20,49.00'
十、字节系列
使用字母b加单引号或双引号括起来的内容 bytes常量与字符串定义方式类似
（1）单引号（b' '）。包含在单引号中的字符串，其中可以包含双引号
>>> b'abc'
b'abc'
>>> b'abc\'x\''
b"abc'x'"
>>> b'abc"x"'
b'abc"x"'
>>> x=b'c:\\Python33'
>>> x
b'c:\Python33'
（2）双引号（b" "）。包含在双引号中的字符串，其中可以包含单引号
>>> b"xyz"
b'xyz'
>>> b"x\tyz"
b'x\tyz'
>>> print(b"x\tyz")
b'x\tyz'
>>> print(b"x'y'z")
b"x'y'z"
>>> print(b"x\ny")
b'x\ny'
（3）三单引号（b''' '''）。包含在三单引号中的字符串，可以跨行
>>> s1='''a
\tb
\tc
\td'''
>>> s1=b'''a
\tb
\tc
\td'''
>>> s1
b'a\n\tb\n\tc\n\td'
（4）三双引号（b""" """）。包含在三双引号中的字符串，可以跨行
>>> s2=b"""
She said:
"Yes!"
"""
>>> s2
b'\nShe said:\n"Yes!"\n'
>>> print(s2)
b'\nShe said:\n"Yes!"\n'
创建bytes对象
创建bytes对象示例
>>> bytes()
b''
>>> bytes(2)
b'\x00\x00'
>>> bytes((1,2,3))
b'\x01\x02\x03'
>>> bytes('abc','utf-8')
b'abc'
>>> bytes((123, 456))
Traceback (most recent call last):
File "<pyshell#95>", line 1, in <module>
bytes((123, 456))
ValueError: bytes must be in range(0, 256)