一、序列类型
序列类型用来表示有序的元素集合。
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