3_序列类型

一、序列类型

序列类型用来表示有序的元素集合。

1. 字符串

python中字符串用str表示，字符串是使用单引号，双引号，三引号包裹起来的字符的序列，用来表示文本信息。

1.1 字符串的定义

a = 'a'
b = "bc"
c = """hello,world"""
d = '''hello,d'''
# 三引号可以定义多行字符
e = """
    hello,
    world!
    """
print('a的类型为：', type(a))    # a的类型为： <class 'str'>
print('b的类型为：', type(b))    # b的类型为： <class 'str'>
print('c的类型为：', type(c))    # c的类型为： <class 'str'>
print('d的类型为：', type(d))    # d的类型为： <class 'str'>
print('e的类型为：', type(e))    # e的类型为： <class 'str'>

使用单引号和双引号进行字符串定义没有任何区别，当要表示字符串的单引号时用双引号进行定义字符串，反之亦然。

一对单引号或双引号只能创建单行字符串，三引号可以创建多行表示的字符串。三双引号一般用来做多行注释，表示函数，类定义时的说明。

# 输出双引号，外层用单引号，反之
print('最近我看了"平凡的世界"')
print("最近我看了'平凡的世界'")

定义空字符串

a = ''
print(a)

1.2 字符串的索引

任何序列类型中的元素都有，索引用来表示它在序列中的位置。

字符串是字符的序列表示，单个字符在字符串中的位置使用 索引来表示，也叫下标。

索引使用整数来表示。

通过索引可以获取字符串中的单个字符

语法如下：

str[index] # s代表字符串，获取索引为index的字符
s = 'hello world!'
print(s[0])
print(s[-1])
结果：
h
!

注意字符串索引从0开始

1.3 字符串的切片

获取序列中的子序列叫切片。

字符串的切片就是获取字符串的子串。

字符串切片的语法如下：

str[start:end:step]

start表示起始索引，end表示结束索引，step表示步长。

当 step为1的时候可以省略。

特别的，当 step为负数时，表示反向切片。

s = '0123456789'
print(s[1:5])  # 包头不包尾

结果：1234

print(s[:5])  # 从头开始切可以省略start

结果：01234

print(s[1:])  # 切到末尾省略end

结果：123456789

print(s[1::2]) # 步长为2进行切片

结果：13579

print(s[::-2]) # 步长为负数反向切片

结果：97531

思考：

获取一个字符串的逆串，例如 'abc’的逆串是 ‘cba’。

q = 'abc'
print(q[::-1])

1.4 字符串拼接

python中可以通过 + 拼接两个字符串

a = 'hello'
b = ' '
c = 'world!'
print(a+b+c)

运行结果：hello world!

字符串和整数进行乘法运算表示重复拼接这个字符串

print('*' * 10)

运行结果：**********

通过format() 或 f

a = '语言'
print('python是最棒的{}'.format(a))
print(f'python是最棒的{a}')

运行结果：
python是最棒的语言
python是最棒的语言

1.5 字符串和数值的相互转化

1 和 '1’不同，1.2和 '1.2’也不相同，但是它们可以相互转化

# 整数和字符串之间的转化
int('1')

1

str(1)

‘1’

# 浮点数和字符串之间的转化
float('1.2')

1.2

str(1.2)

‘1.2’

# 尝试 int('1.2')看看结果会是什么
int('1.2')

1.6 转义符

在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符。常用转义字符如下表：

(在行尾时)	续行符
\\	反斜杠符号
\’	单引号
\"	双引号
\a	响铃
\n	换行
\t	横向制表符
\r	回车
\f	换页
r	强制不转义

print('窗前明月光，\n疑是地上霜。')  # 输出换行

窗前明月光，
疑是地上霜。

print('对\\错')   # 输出反斜杠本身

对\错

print('\"')      # 输出双引号本身

"

# 强制不转义
print(r'对什么人，\n做错了事')   # 在字符串前加一个字符r,raw 原始，这个字符串就不会转义

对什么人，\n做错了事

1.7 字符串格式化

在实际工作中经常需要动态输出字符。

1.7.1 format函数格式化

%的字符串格式化继承自C语言，python中给字符串对象提供了一个 format函数进行字符串格式化，且功能更强大，并且大力推荐，所以我们要首选使用。

基本语法是：

<模板字符串>.format(<逗号分隔的参数>)

在模板字符串中使用 {}代替以前的 %作为槽位

time = '11:15'
percent = 75
format_str = '{}计算机的内存利用率为{}%'
res = format_str.format(time, percent)
print(res)

运行结果：
11:15计算机的内存利用率为75%

当format中的参数使用位置参数提供时，{}中可以填写参数的整数索引和参数一一对应

time = '11:15'
percent = 75
format_str = ('{0}计算机的内存利用率为{1}%'.format(time, percent))
print(format_str)

运行结果：
11:15计算机的内存利用率为75%

当format中的参数使用关键字参数提供时，{}中可以填写参数名和参数一一对应

time = '11:15'
percent = 75
format_str = ('{a}计算机的内存利用率为{b}%'.format(a=time, b=percent))
print(format_str)

运行结果：
11:15计算机的内存利用率为75%

1.7.2 格式字符串字面值或称为 f-string，

是标注了 ‘f’ 或 ‘F’ 前缀的字符串字面值。
这种字符串可包含替换字段，即以 {} 标注的表达式。

直接在f字符串的花括号内写上变量名，解释器会自动将变量的值的字符串形式替换

time = '11:15'
percent = 75
f_str = f'{time}计算机的内存利用率为{percent}%'
print(f_str)

运行结果：
11:15计算机的内存利用率为75%

2. 列表

python中列表list用来表示任意元素的序列，元素可以是任意数据类型，序列中的元素可以增，删，改。

2.1 列表的定义

列表由一对中括号进行定义，元素与元素直接使用逗号隔开。

a = []                      # 空列表
b = ["a", "b", "cde"]       # 字符串列表项
c = [1, "b", "c"]           # 数字列表项  
d = [1, "b", []]            # 列表列表项
e = [1, "b", [2, "c"]]      # 列表作为列表的元素叫做列表的嵌套


print('a的类型为：', type(a))    # a的类型为： <class 'list'>
print('b的类型为：', type(b))    # b的类型为： <class 'list'>
print('c的类型为：', type(c))    # c的类型为： <class 'list'>
print('d的类型为：', type(d))    # d的类型为： <class 'list'>
print('e的类型为：', type(e))    # e的类型为： <class 'list'>

2.2 列表的拼接

像字符串一样，列表之间可以进行加法运算实现列表的拼接，列表可以和整数进行乘法运算实现列表的重复

a = ['a', 'ab', 'abc']
b = [1, 2, 3, 'a']
print(a + b)

[‘a’, ‘ab’, ‘abc’, 1, 2, 3, ‘a’]

[1,2,3] * 3

[1, 2, 3, 1, 2, 3, 1, 2, 3]

2.3 列表的索引和切片

序列的切片操作完全一致，参见字符串

注意嵌套列表的元素获取

ls = [1,2,['a','b']]
ll = ls[2][0]
print(ll, type(ll))

a <class ‘str’>

2.4 列表的常用操作

python中的列表操作非常灵活，是非常重要和经常使用的数据类型。

2.4.1 增加元素

给列表添加元素需要使用到列表的方法

.append(el)，在列表的末尾添加一个元素

ls = [1,2,3]
ls.append(4)
print(ls)

[1, 2, 3, 4]

.insert(index, el)，在列表的指定索引处插入一个元素

ls = [1,2,3]
ls.insert(0, 0)
print(ls)

[0, 1, 2, 3]

.extend(iterable)，扩展列表，元素为传入的可迭代对象中的元素（一次加多个）

a = [1, 2, 3]
b = [4, 5, 6]
c = '我是好奇宝宝'
a.extend(b)
b.extend(c)
print(a)
print(b)

[1, 2, 3, 4, 5, 6]
[4, 5, 6, ‘我’, ‘是’, ‘好’, ‘奇’, ‘宝’, ‘宝’]

2.4.2 修改元素

列表的中的元素可以进行修改，只需使用索引赋值即可。

ls = [1,2,3]
ls[1] = 'a'
print(ls)

[1, ‘a’, 3]

2.4.3 删除元素

.pop(index=-1)，删除指定索引的元素,并返回该元素，没有指定索引默认删除最后一个元素

ls = [1,2,3]
ls.pop()

3

print(ls)

[1, 2]

ls.pop(0)

1

print(ls)

[2]

.remove(value)，从列表中删除第一个指定的值value，如不不存在value则报错。

ls = [1,2,3,1]
ls.remove(1)
print(ls)

[2, 3, 1]

.clear()，清空列表，原列表变成空列表

ls = [1, 2, 3]
ls.clear()
print(ls)

[]

2.5 列表的其他方法

.index(self, value, start=0, stop=9223372036854775807)，返回列表中指定值value的第一个索引，入宫value不存在则报错

a = [1, 2, 1, 4]
print(a.index(1))

0

.reverse()，翻转列表元素顺序

a = [1, 2, 3, 4]
a.reverse()
print(a)

[4, 3, 2, 1]

.sort(key=None, reverse=False)，对列表进行排序，默认按照从小到大的顺序，当参数reverse=True时，从大到小。注意列表中的元素类型需要相同，否则抛出异常。

b = [1, 4, 3, 7, 5, 2]
b.sort()
print(b)

[1, 2, 3, 4, 5, 7]

b = [1, 4, 3, 7, 5, 2]
b.sort(reverse=True)
print(b)

[7, 5, 4, 3, 2, 1]

ls = [1,2,'3']
ls.sort()

报错：
Traceback (most recent call last):
File “D:/Git/test-practice/py38/day04/c.py”, line 22, in
b.sort(reverse=True)
TypeError: ‘<’ not supported between instances of ‘int’ and ‘str’

.count(value)，统计列表中value的出现次数，列表中没有value返回0

b = [1, 4, 3, 7, 5, 1]
print(b.count(1))

2

2.6 字符串和列表的转换

字符串是字符组成的序列，可以通过 list函数将字符串转换成单个字符的列表。

c = 'hello world'
d = list(c)
print(d)

[‘h’, ‘e’, ‘l’, ‘l’, ‘o’, ’ ', ‘w’, ‘o’, ‘r’, ‘l’, ‘d’]

由字符组成的列表可以通过字符串的join方法进行拼接

f = ['好', '好', '学', '习']
g = ''.join(f)
print(g)
或
f = ['好', '好', '学', '习']
g = '/'.join(f)
print(g)

好好学习
好/好/学/习

3. 元组

元组(tuple)表示任意元素的序列，元素可以是任意数据类型，序列中的元素不能增，删，改，可以说元组就是不可变的列表。

3.1 元组的定义

元组通过一对小括号进行定义，元组之间使用逗号隔开。

a = ()                      # 空元祖
b = ("a", "b", "cde")       # 字符串
c = (1, "b", "c")           # 数字
d = (1, "b", [])            # 列表
e = (1, "b", (2, "c"))      # 元祖
f = 1,2

print('a的类型为：', type(a))    # a的类型为： <class 'tuple'>
print('b的类型为：', type(b))    # b的类型为： <class 'tuple'>
print('c的类型为：', type(c))    # c的类型为： <class 'tuple'>
print('d的类型为：', type(d))    # d的类型为： <class 'tuple'>
print('e的类型为：', type(e))    # e的类型为： <class 'tuple'>
print('f的类型为：', type(f))    # f的类型为： <class 'tuple'>

注意单元素元组的定义,一定要多加个逗号

g = ('hello')
h = ('hello',)
print('g的类型为：', type(g))    # g的类型为： <class 'str'>
print('h的类型为：', type(h))    # h的类型为： <class 'tuple'>

3.2 元组的索引和切片

序列的索引和切片完全一致，参加字符串。

3.3 len函数

python内建函数 len可以获取对象中包含的元素个数

• 字符串：字符的个数
• 列表：列表的个数
• 元组：元素的个数

s = 'hello'
ls = [1,2,3]
t = (1,2,3)
print(len(s))
print(len(ls))
print(len(t))

5
3
3

4. 可变与不可变对象

python中的对象根据底层内存机制分为可变与不可变两种。

可变对象可以在其 id()保持固定的情况下改变其取值。

a = 123
print(id(a))

140715127399904

下面的列表a，修改值后，id保持不变
基本数据类型中列表，集合和字典都是可变数据类型。

a = [1,2,3]
print(id(a))
a[0] = 'a'
print(id(a))

2935119720576
2935119720576

基本数据类型中列表，集合和字典都是可变数据类型。

如果修改一个对象的值，必须创建新的对象，那么这个对象就是不可变对象。

例如下面的字符串s，修改内容后id发生了改变。
基本数据类型中数字，字符串，元组是不可变对象。

s = 123
print(id(s))
s = 'hello'
print(id(s))
s = '我是'
print(id(s))

140715127399904
2041592352432
2041592237296