《Python基础知识-2高级数据类型A》

-Sussurro-

已于 2022-03-29 16:42:36 修改

阅读量1k

点赞数

分类专栏： Python 文章标签： python

于 2022-03-28 10:37:40 首次发布

本文链接：https://blog.csdn.net/weixin_44315848/article/details/123729686

版权

Python 专栏收录该内容

7 篇文章 1 订阅

订阅专栏

1 字符串

1.1 字符串的定义

字符串(str)：字符串就是一系列字符。在Python中，用引号括起来的都是字符串，其中的引号可以是单引号也可以是双引号（这种灵活性让你能够在字符串中包括引号和撇号，亦可以使用 \’ 或 \" 做字符串的转义）。

# 字符串
'I told my friend, "Python is my favorite language!"'
"I told my friend, \"Python is my favorite language!\""

可以使用索引获取一个字符串中指定位置的字符，索引计数从 0 开始（顺序索引）。此外Python还支持倒序索引，最右边的索引值是 -1，从右到左依次递减。

In [1]: string = 'Hello, Python'
In [2]: print(string[0])  # return H

可以使用 for 遍历字符串中的每一个字符。

In [1]: string = 'Hello, Python'
In [2]: for c in string:
In [3]:     print(c)

1.2 字符串的常用操作

（参考链接：字符串方法）

1）判断类型-10

方法	描述
str.isspace()	如果字符串中只有空白字符且至少有一个字符，则返回 True，否则返回 False。
str.isalnum()	如果字符串中的所有字符都是字母或数字且至少有一个字符，则返回 True，否则返回 False。
str.isalpha()	如果字符串中的所有字符都是字母且至少有一个字符，返回 True，否则返回 False。
str.isascii()	如果字符串为空或字符串中的所有字符都是 ASCII ，返回 True，否则返回 False。
str.isdecimal()	如果字符串中的所有字符都是十进制字符且该字符串至少有一个字符，则返回 True，否则返回 False。 $\newline$ 严格地讲，十进制字符是 Unicode 通用类别 “Nd” 中的一个字符。
str.isdigit()	如果字符串中的所有字符都是数字且至少有一个字符，返回 True，否则返回 False。 $\newline$ 严格地讲，数字是指属性值为 Numeric_Type=Digit 或 Numeric_Type=Decimal 的字符。
str.isnumeric()	如果字符串中的所有字符均为数值字符且至少有一个字符，返回 True，否则返回 False。 $\newline$ 严格地讲，数值字符就是具有特征属性值 Numeric_Type=Digit, Numeric_Type=Decimal 或 Numeric_Type=Numeric 的字符。
str.istitle()	如果字符串中至少有一个字符且为标题字符串（每个单词的首字母大写）则返回 True，否则返回 False。
str.islower()	如果字符串中至少有一个区分大小写的字符且此类字符均为小写则返回 True ，否则返回 False。
str.isupper()	如果字符串中至少有一个区分大小写的字符且此类字符均为大写则返回 True ，否则返回 False。

2）查找替换-7

方法	描述
str.startswith(prefix[, start[, end]])	如果字符串以指定的 prefix 开始则返回 True，否则返回 False。 $\newline$ prefix 也可以为由多个供查找的前缀构成的元组。 $\newline$ 如果有可选项 start，将从所指定位置开始检查。如果有可选项 end，将在所指定位置停止比较。
str.endswith(suffix[, start[, end]])	如果字符串以指定的 suffix 结束则返回 True，否则返回 False。 $\newline$ suffix 也可以为由多个供查找的后缀构成的元组。 $\newline$ 如果有可选项 start，将从所指定位置开始检查。如果有可选项 end，将在所指定位置停止比较。
str.find(sub[, start[, end]])	返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 $\newline$ 可选参数 start 与 end 会被解读为切片表示法。如果 sub 未被找到则返回 -1。
str.rfind(sub[, start[, end]]	返回子字符串 sub 在 s[start:end] 切片内被找到的最大（最右）索引。 $\newline$ 可选参数 start 与 end 会被解读为切片表示法。如果 sub 未被找到则返回 -1。
str.index(sub[, start[, end]])	类似于 find()，但在子字符串 sub 未找到时会引发 ValueError。
str.rindex(sub[, start[, end]])	类似于 rfind()，但在子字符串 sub 未找到时会引发 ValueError。
str.replace(old, new[, count])	返回字符串的副本，其中出现的所有子字符串 old 都将被替换为 new。 $\newline$ 如果给出了可选参数 count，则只替换前 count 次出现。

例如：

In [1]: S = "this is a string example!!!"
In [2]: print(S.startswith('string', 10))  # return True
In [3]: print(S.endswith('!!'))  # return True
In [4]: print(S.find('s', 4))  # return 6
In [5]: print(S.rfind('s'))  # return 10
In [6]: print(S.index('ss'))  # return ValueError: substring not found
In [7]: print(S.rindex('s'))  # return 10
In [8]: print(S.replace('!', '?', 2))  # return this is a string example??!

3）大小写转换-5

方法	描述
str.capitalize()	返回原字符串的副本，其首个字符大写，其余为小写。
str.title()	返回原字符串的标题版本，其中每个单词第一个字母为大写，其余字母为小写。
str.upper()	返回原字符串的副本，其中所有区分大小写的字符均转换为大写。
str.lower()	返回原字符串的副本，其中所有区分大小写的字符均转换为小写。
str.swapcase()	返回原字符串的副本，其中大小写翻转，即大写字符转换为小写，反之亦然。

4）文本对齐-4

方法	描述
str.center(width[, fillchar])	返回长度为 width 的字符串，原字符串在其正中。 $\newline$ 使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。如果 width 小于等于 len(s) 则返回原字符串的副本。
str.ljust(width[, fillchar])	返回长度为 width 的字符串，原字符串在其中靠左对齐。 $\newline$ 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。如果 width 小于等于 len(s) 则返回原字符串的副本。
str.rjust(width[, fillchar])	返回长度为 width 的字符串，原字符串在其中靠右对齐。 $\newline$ 使用指定的 fillchar 填充空位 (默认使用 ASCII 空格符)。如果 width 小于等于 len(s) 则返回原字符串的副本。
str.zfill(width)	返回原字符串的副本，在左边填充 ASCII ‘0’ 数码使其长度变为 width。 $\newline$ 正负值前缀 (’+’/’-’) 的处理方式是在正负符号之后填充而非在之前。如果 width 小于等于 len(str) 则返回原字符串的副本。

例如：

In [1]: S = "-42"
In [2]: print(S.center(8, '0'))  # return 00-42000
In [3]: print(S.ljust(8, '0'))  # return -4200000
In [4]: print(S.rjust(8, '0'))  # return 00000-42
In [5]: print(S.zfill(8))  # return -0000042

5）删除空格-3

方法	描述
str.lstrip([chars])	返回原字符串的副本，移除其中的前导字符。 chars 参数为指定要移除字符的字符串。 $\newline$ 如果省略或为 None，则 chars 参数默认移除空白符。实际上 chars 参数并非指定单个前缀；而是会移除参数值的所有组合。
str.rstrip([chars])	返回原字符串的副本，移除其中的末尾字符。 chars 参数为指定要移除字符的字符串。 $\newline$ 如果省略或为 None，则 chars 参数默认移除空白符。实际上 chars 参数并非指定单个后缀；而是会移除参数值的所有组合。
str.strip([chars])	返回原字符串的副本，移除其中的前导和末尾字符。 chars 参数为指定要移除字符的字符串。 $\newline$ 如果省略或为 None，则 chars 参数默认移除空白符。实际上 chars 参数并非指定单个前缀或后缀；而是会移除参数值的所有组合。

例如：

In [1]: print('www.example.com'.lstrip('cmowz.'))  # return example.com
In [2]: print('www.example.com'.rstrip('cmowz.'))  # return www.example
In [3]: print('www.example.com'.strip('cmowz.'))  # return example

6）拆分连接-6

方法	描述
str.partition(sep)	在 sep 首次出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 $\newline$ 如果分隔符未找到，则返回的 3 元组中包含字符本身以及两个空字符串。
str.rpartition(sep)	在 sep 最后出现的位置拆分字符串，返回一个 3 元组，其中包含分隔符之前的部分、分隔符本身，以及分隔符之后的部分。 $\newline$ 如果分隔符未找到，则返回的 3 元组中包含两个空字符串以及字符串本身。
str.split(sep=None, maxsplit=-1)	返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 $\newline$ 如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）。 $\newline$ 如果 maxsplit 未指定或为 -1，则不限制拆分次数（进行所有可能的拆分）。 $\newline$ 如果 sep 未指定或为 None，任何空白字符串都会被作为分隔符。
str.rsplit(sep=None, maxsplit=-1)	返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 $\newline$ 如果给出了 maxsplit，则最多进行 maxsplit 次拆分，从最右边开始。
str.splitlines([keepends])	返回由原字符串中各行组成的列表，在行边界的位置拆分。 $\newline$ 结果列表中不包含行边界，除非给出了 keepends 且为真值。
str.join(iterable)	返回一个由 iterable 中的字符串拼接而成的字符串。 $\newline$ 如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。调用该方法的字符串将作为元素之间的分隔。

例如：

In [1]: print('www.example.com'.partition('m'))  # return ('www.exa', 'm', 'ple.com')
In [2]: print('www.example.com'.rpartition('m'))  # return ('www.example.co', 'm', '')

In [3]: print('1,2,3'.split(',', maxsplit=1))  # return ['1', '2,3']
In [4]: print('1,2,3'.split())  # return ['1,2,3']
In [5]: print('1,2,3'.rsplit(',', maxsplit=1))  # return ['1,2', '3']

In [6]: print('ab c\n\nde fg\rkl\r\n'.splitlines())  # return ['ab c', '', 'de fg', 'kl']
In [7]: print('ab c\n\nde fg\rkl\r\n'.splitlines(keepends=True))  # return ['ab c\n', '\n', 'de fg\r', 'kl\r\n']

In [8]: print('-'.join(('1', '2', '3')))  # return 1-2-3

2 列表

2.1 列表的定义

（参考链接：列表、创建多维列表）
列表(list)：列表是由一系列按特定顺序排列的元素组成。你可以创建包含字母表中所有字母、数字0~9或所有家庭成员姓名的列表；也可以将任何东西加入列表中，其中的元素之间可以没有任何关系。鉴于列表通常包含多个元素，给列表指定一个表示复数的名称（如letters 、 digits 或names ）是个不错的主意。在Python中，用方括号（[ ]）来表示列表，并用逗号来分隔其中的元素。

# 列表
['trek', 'cannondale', 'redline', 'specialized']
[1, 2, 3]

可以使用索引访问一个列表中指定位置的元素，索引计数从 0 开始（顺序索引）。此外Python还支持倒序索引，最右边的索引值是 -1，从右到左依次递减。

In [1]: bicycles = ['trek', 'cannondale', 'redline', 'specialized']
In [2]: print(bicycles[0])  # return trek
In [3]: print(bicycles[-2])  # return redline

可以使用 for 遍历列表中的每一个元素。

In [1]: bicycles = ['trek', 'cannondale', 'redline', 'specialized']
In [2]: for bicycle in bicycles：
In [3]:     print(bicycle)

2.2 创建数值列表

1）创建数字列表(range( ))

Python的函数 range( ) 能够轻松地生成一系列的数字。例如，可以像下面这样使用函数 range( ) 来打印一系列的数字：

In [1]: for value in range(1, 5):
In [2]:     print(value)
Out[2]: 1
        2
        3
        4

In [1]: squares = []
In [2]: for value in range(1, 5):
In [3]:     squares.append(value**2)
In [4]: print(squares)  # return [1, 4, 9, 16]

注意：函数 range( ) 让Python从指定的第一个值开始数，并在到达指定的第二个值后停止，因此输出不包含第二个值。使用 range( ) 时，如果输出不符合预期，请尝试将指定的值加1或减1。
要创建数字列表，可使用函数 list( ) 将 range( ) 的结果直接转换为列表。如果将 range( ) 作为 list( ) 的参数，输出将为一个数字列表。使用函数 range( ) 时，还可指定步长。

In [1]: even_numbers = list(range(2, 11, 2))
In [2]: print(even_numbers)  # return [2, 4, 6, 8, 10]

2）列表解析

前面介绍的生成列表 squares 的方式包含三四行代码，而列表解析只需编写一行代码就能生成这样的列表。列表解析将 for 循环和创建新元素的代码合并成一行，并自动附加新元素。
例如：

In [1]: squares = [value**2 for value in range(1, 5)]
In [2]: print(squares)  # return [1, 4, 9, 16]

3）对数字列表执行简单的统计计算

有几个专门用于处理数字列表的Python函数。例如，得到数字列表的最大值、最小值和总和：

digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(min(digits))  # return 0
print(max(digits))  # return 9
print(sum(digits))  # return 45

2.3 列表的常用操作

1）修改列表元素

修改列表元素的语法与访问列表元素的语法类似。要修改列表元素，可指定列表名和要修改的元素的索引，再指定该元素的新值。

列表[索引] = 新元素

例如：

In [1]: bicycles = ['trek', 'cannondale', 'redline', 'specialized']
In [2]: bicycles[0] = 'phoenix'
In [3]: print(bicycles)  # return ['phoenix', 'cannondale', 'redline', 'specialized']

2）添加列表元素

方法	描述
list.append(element)	在列表末尾添加新元素，element 参数为要添加的新元素，返回 None。等同于 list[len(list):len(list)] = [element]。
list.extend(t)	在列表末尾追加列表，t 参数为要追加的列表，返回 None。等同于 list += t、list[len(list):len(list)] = t。
list.insert(index, element)	在由 index 给出的索引位置插入 element，返回 None。等同于 list[index:index] = [element]。

例如：

In [1]: bicycles = ['trek', 'cannondale', 'redline', 'specialized']
In [2]: bicycles.append('phoenix')
In [3]: print(bicycles)  # return ['trek', 'cannondale', 'redline', 'specialized', 'phoenix']
In [4]: bicycles[len(bicycles):len(bicycles)] = ['phoenix']
In [5]: print(bicycles)  # return ['trek', 'cannondale', 'redline', 'specialized', 'phoenix', 'phoenix']

In [1]: bicycles = ['trek', 'cannondale']
In [2]: bicycles.extend(['redline', 'specialized'])
In [3]: print(bicycles)  # return ['trek', 'cannondale', 'redline', 'specialized']
In [4]: bicycles[len(bicycles):len(bicycles)] = ['phoenix', 'phoenix']
In [5]: print(bicycles)  # return ['trek', 'cannondale', 'redline', 'specialized', 'phoenix', 'phoenix']

In [1]: bicycles = ['trek', 'cannondale', 'redline', 'specialized']
In [2]: bicycles.insert(2, 'phoenix')
In [3]: print(bicycles)  # return ['trek', 'cannondale', 'phoenix', 'redline', 'specialized']

3）删除列表元素

语句	描述
del list[index]	删除列表 list 中指定索引 index 的元素。等同于 list[index]= []。

例如：

In [1]: bicycles = ['trek', 'cannondale', 'redline', 'specialized']
In [2]: del bicycles[0]
In [3]: print(bicycles)  # return ['cannondale', 'redline', 'specialized']

In [1]: bicycles = ['trek', 'cannondale', 'redline', 'specialized']
In [2]: bicycles[1:3] = []
In [3]: print(bicycles)  # return ['trek', 'specialized']

方法	描述
list.pop([index])	删除指定索引 index 的元素，并返回被删除的元素。如果 index 未指定，则删除末尾元素。
list.remove(element)	删除第一个出现的指定元素 element，返回 None。
list.clear()	清空列表，返回 None。等同于 del list[:]。

例如：

In [1]: bicycles = ['trek', 'cannondale', 'redline', 'specialized']
In [2]: print(bicycles.pop(1))  # return cannondale
In [3]: print(bicycles)  # renturn ['trek', 'redline', 'specialized']

In [1]: bicycles = ['trek', 'cannondale', 'trek', 'redline', 'specialized']
In [2]: bicycles.remove('trek')
In [3]: print(bicycles)  # return ['cannondale', 'trek', 'redline', 'specialized']

In [1]: bicycles = ['trek', 'cannondale', 'redline', 'specialized']
In [2]: bicycles.clear()
In [3]: print(bicycles)  # renturn []

注意：如果你不确定该使用 del 语句还是 pop( ) 方法，下面是一个简单的判断标准：如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用 del 语句；如果你要在删除元素后还能继续使用它，就使用方法 pop( ) 。

4）组织列表

函数	描述
len(list)	返回列表 list 的长度。
sorted(list[, reverse])	返回对列表的临时升序排序。reverse 为真值时对列表降序排序。

例如：

In [1]: bicycles = ['trek', 'cannondale', 'redline', 'specialized']
In [2]: print(len(bicycles))  # return 4

In [1]: bicycles = ['trek', 'cannondale', 'redline', 'specialized']
In [2]: print(sorted(bicycles, reverse=True))  # return ['trek', 'specialized', 'redline', 'cannondale']

方法	描述
list.count(element)	返回元素 element 在列表 list 中出现的次数。
list.copy()	返回列表 list 的浅拷贝。等同于list[:]。
list.index(element)	返回元素 element 在列表 list 中首次出现的索引。
list.reverse()	反转列表元素的排列顺序，返回 None。
list.sort([reverse])	对列表进行升序排序，返回 None。reverse 为真值时对列表降序排序。

例如：

In [1]: bicycles = ['trek', 'cannondale', 'trek', 'redline', 'specialized']
In [2]: print(bicycles.count('trek'))  # return 2

In [3]: a = bicycles.copy()
In [4]: print(a)  # return ['trek', 'cannondale', 'trek', 'redline', 'specialized']

In [5]: print(bicycles.index('trek'))  # return 0

In [6]: bicycles.reverse()
In [7]: print(bicycles)  # return ['specialized', 'redline', 'trek', 'cannondale', 'trek']

In [1]: bicycles = ['trek', 'cannondale', 'redline', 'specialized']
In [2]: bicycles.sort()
In [3]: print(bicycles)  # return ['cannondale', 'redline', 'specialized', 'trek']

In [1]: bicycles = ['trek', 'cannondale', 'redline', 'specialized']
In [2]: bicycles.sort(reverse=True)
In [3]: print(bicycles)  # return ['trek', 'specialized', 'redline', 'cannondale']

赋值和 copy( ) 的区别：赋值语法实际上是让Python将新变量关联到包含在旧变量中的列表，因此这两个变量都指向同一个列表。

In [1]: my_foods = ['pizza', 'falafel', 'carrot cake']
In [2]: friend_foods = my_foods
In [3]: my_foods.append('cannoli')
In [4]: friend_foods.append('ice cream')
In [5]: print(my_foods)  # return ['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']
In [6]: print(friend_foods)  # return ['pizza', 'falafel', 'carrot cake', 'cannoli', 'ice cream']

In [1]: my_foods = ['pizza', 'falafel', 'carrot cake']
In [2]: friend_foods = my_foods.copy()
In [3]: my_foods.append('cannoli')
In [4]: friend_foods.append('ice cream')
In [5]: print(my_foods)  # return ['pizza', 'falafel', 'carrot cake', 'cannoli']
In [6]: print(friend_foods)  # return ['pizza', 'falafel', 'carrot cake', 'ice cream']

注意：在并非所有的值都是小写时，按字母顺序排列列表要复杂些。决定排列顺序时，有多种解读大写字母的方式，要指定准确的排列顺序，可能比我们这里所做的要复杂。然而，大多数排序方式都基于本节介绍的知识。

5）使用列表的一部分（切片）

要创建切片，可指定要使用的第一个元素和最后一个元素的索引。与函数 range( ) 一样，Python在到达指定的第二个索引前面的元素后停止。

In [1]: bicycles = ['trek', 'cannondale', 'redline', 'specialized']
In [2]: print(bicycles[0:3])  # return ['trek', 'cannondale', 'redline']

如果没有指定第一个索引，Python将自动从列表开头开始；如果没有指定最后一个索引，切片终止于列表末尾。无论列表多长，这种语法都能够让你输出从特定位置到列表末尾的所有元素。前边提到负数索引返回离列表末尾相应距离的元素，因此可以输出列表末尾的任何切片。

In [1]: bicycles = ['trek', 'cannondale', 'redline', 'specialized']
In [2]: print(bicycles[:3])  # return ['trek', 'cannondale', 'redline']
In [3]: print(bicycles[2:])  # return ['redline', 'specialized']
In [4]: print(bicycles[-3:])  # return ['cannondale', 'redline', 'specialized']