网站公司介绍模板_免费域名的网站有哪些_网络服务提供者知道或者应当知道_专业外贸网络推广

《Python基础教程》第1章笔记👉https://blog.csdn.net/holeer/article/details/143052930

第2章 列表和元组

本章将介绍一个新概念：数据结构。数据结构是以某种方式（如通过编号）组合起来的数据元素（如数、字符乃至其他数据结构）的集合。在Python中，最基本的数据结构为序列（sequence）。序列中的每个元素都有编号，即其位置或索引，其中第一个元素的索引为0，第二个元素的索引为1，依此类推。同时可回绕到序列末尾，用负索引表示序列末尾元素的位置。

本章首先对序列进行概述，然后介绍一些适用于所有序列（包括列表和元组）的操作。这些操作也适用于本章一些示例中将使用的字符串，下一章将全面介绍字符串操作。讨论这些基本知识后，将着手介绍列表，看看它们有什么特别之处，然后讨论元组。元组是一种特殊的序列，类似于列表，只是不能修改。

2.1 序列概述

Python支持一种数据结构的基本概念，名为容器（container）。容器基本上就是可包含其他对象的对象。序列、映射（如字典）和集合（set）是三种主要的容器。

Python内置了多种序列，本章重点讨论其中最常用的两种：列表和元组。另一种重要的序列是字符串，将在下一章更详细地讨论。

列表和元组的主要不同在于，列表是可以修改的，而元组不可以。这意味着列表适用于需要中途添加元素的情形，而元组适用于出于某种考虑需要禁止修改序列的情形。禁止修改序列通常出于技术方面的考虑，与Python的内部工作原理相关，这也是有些内置函数返回元组的原因所在。在你自己编写程序时，几乎在所有情况下都可使用列表来代替元组。一种例外情况是将元组用作字典键，这将在第4章讨论。在这种情况下，不能使用列表来代替元组，因为字典键是不允许修改的。

在需要处理一系列值时，序列很有用。在数据库中，你可能使用序列来表示人，其中第一个元素为姓名，而第二个元素为年龄。如果使用列表来表示（所有元素都放在方括号内，并用逗号隔开），将类似于下面这样：edward = ['Edward Gumby', 42]。空列表是使用不包含任何内容的两个方括号（[]）表示的。

2.2 通用的序列操作

有几种操作适用于所有序列，包括索引、切片、相加、相乘和成员资格检查。另外，Python还提供了一些内置函数，可用于确定序列的长度以及找出序列中最大和最小的元素。还有一个重要的操作是迭代，它意味着对序列中的每个元素都执行特定的操作，详见本书5.5节。

（1）索引：序列中的所有元素都有编号——从0开始递增。你可像下面这样使用编号来访问各个元素。

>>> greeting = 'Hello'
>>> greeting[0]
H
>>> greeting[-1]
'o'
>>> 'Hello'[1]
'e'
>>> fourth = input('Year: ')[3]
Year: 2005
>>> fourth
'5'

【注意】
①字符串就是由字符组成的序列。不同于其他一些语言，Python没有专门用于表示字符的类型，因此一个字符就是只包含一个元素的字符串。
②序列的元素编号称为索引（indexing）。当你使用负数索引时，Python将从右（即从最后一个元素）开始往左数，因此-1是最后一个元素的位置。
③对于序列字面量（比如字符串）字面量，可直接对其执行索引操作，无需先将其赋给变量。

（2）切片：除使用索引来访问单个元素外，还可使用切片（slicing）来访问特定范围内的元素。为此，可使用两个索引（左索引和右索引），并用冒号分隔，其中左索引是包含的第一个元素的编号，右索引是切片后余下的第一个元素的编号。实例如下。

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> numbers[3:6]
[4, 5, 6]

①简写：如果切片结束于序列末尾，可省略右索引。如果切片始于序列开头，可省略第一个索引。要复制整个序列，可将两个索引都省略。（冒号不能省略）
②更大的步长：在普通切片中，步长为1。这意味着从一个元素移到下一个元素，因此切片包含起点和终点之间的所有元素。要显式指定步长，请在切片中使用第三个索引。步长还可以是负数，即从右向左提取元素。示例如下。

>>> numbers[0:10:2]
[1, 3, 5, 7, 9]
>>> numbers[::-2]
[10, 8, 6, 4, 2]

（3）序列相加：可使用加法运算符来拼接序列。一般而言，不能拼接不同类型的序列，比如不能将列表与字符串拼接。

（4）乘法：将序列与数x相乘时，将重复这个序列x次来创建一个新序列：

>>> 'python' * 5
'pythonpythonpythonpythonpython'
>>> [42] * 10
[42, 42, 42, 42, 42, 42, 42, 42, 42, 42]

（5）成员资格：要检查特定的值是否包含在序列中，可使用运算符in。这个运算符属于布尔运算符，返回的值（True或False）称为真值。示例如下。

>>> permissions = 'rw'
>>> 'w' in permissions
True
>>> 'x' in permissions
False
>>> 'mlh' in users = ['mlh', 'foo', 'bar']
True
>>> subject = '$$$ Get rich now!!! $$$'
>>> '$$$' in subject
True# 一段简易的登录程序
database = [ ['albert', '1234'], ['dilbert', '4242'], ['smith', '7524'], ['jones', '9843']
]username = input('User name: ')
pin = input('PIN code: ')
if [username, pin] in database: print('Access granted')

（6）常用内置函数：内置函数len、min和max分别返回序列包含的元素个数、序列中最小的元素、序列中最大的元素。示例如下。

>>> numbers = [100, 34, 678]
>>> len(numbers)
3
>>> max(numbers)
678
>>> min(numbers)
34
>>> max(2, 3)
3
>>> min(9, 3, 2, 5)
2

2.3 列表：Python的主力

2.3.1 函数list

在有些情况下使用字符串来创建列表很有帮助。为此，可使用函数list。反之，要将字符列表转换为字符串，可使用以下表达式：''.join(somelist)。

>>> list('Hello')
['H', 'e', 'l', 'l', 'o']

2.3.2 基本的列表操作

本节将介绍一些修改列表的方式。

（1）修改列表：给元素赋值，如x[1] = 2。

（2）删除元素：如 del names[2]。

（3）给切片赋值。

>>> name = list('Perl')
>>> name
['P', 'e', 'r', 'l']
>>> name[2:] = list('ar')
>>> name
['P', 'e', 'a', 'r']
>>> name = list('Perl')
>>> name[1:] = list('ython')
>>> name
['P', 'y', 't', 'h', 'o', 'n']
>>> numbers = [1, 5]
# 替换了一个空切片，相当于插入了一个序列
>>> numbers[1:1] = [2, 3, 4]
>>> numbers
[1, 2, 3, 4, 5]

2.3.3 列表方法

方法调用与函数调用很像，只是在方法名前加上了对象和句点。列表包含多个可用来查看或修改其内容的方法。

#（1）append：将一个对象附加到列表末尾。
>>> lst = [1, 2, 3]
>>> lst.append(4)
>>> lst
[1, 2, 3, 4]
#（2）clear：就地清空列表的内容。
#（3）copy：返回列表的副本。
#（4）count：计算指定的元素在列表中出现了多少次。
>>> x = [[1, 2], 1, 1, [2, 1, [1, 2]]]
>>> x.count(1)
2
>>> x.count([1, 2])
1
#（5）extend：使用一个列表来扩展另一个列表。
>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 6]
#（6）index：在列表中查找指定值第一次出现的索引。
>>> knights = ['We', 'are', 'the', 'knights', 'who', 'say', 'ni']
>>> knights.index('who')
4
#（7）insert：将一个对象插入列表
>>> numbers = [1, 2, 3, 5, 6, 7]
>>> numbers.insert(3, 'four')
>>> numbers
[1, 2, 3, 'four', 5, 6, 7]
pop
#（8）pop：从列表中删除一个元素（默认为最后一个元素），并返回这一元素。
>>> x = [1, 2, 3]
>>> x.pop()
3
>>> x
[1, 2]
>>> x.pop(0)
1
>>> x
[2]
# 搭配使用append和pop，可用列表模拟栈。
#（9）remove：删除第一个为指定值的元素。
>>> x = ['to', 'be', 'or', 'not', 'to', 'be']
>>> x.remove('be')
>>> x
['to', 'or', 'not', 'to', 'be']
#（10）reverse：按相反的顺序排列列表中的元素。（就地逆置）
#（11）sort：对列表就地排序
#（12）sort(key,reverse)：高级排序。reverse取值True时反向排序。key是一个用于排序的函数。不会直接使用这个函数来判断一个元素是否比另一个元素小，而是使用它来为每个元素创建一个键，再根据这些键对元素进行排序。比如，根据长度对元素进行排序：
>>> x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']
>>> x.sort(key=len)
>>> x
['add', 'acme', 'aerate', 'abalone', 'aardvark']

2.4 元组：不可修改的序列

元组的语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组。如果元组中只有一个值，也必须在它后面加上逗号。元组还可用圆括号括起（这也是通常采用的做法）。空元组用两个不包含任何内容的圆括号表示。函数tuple将一个序列作为参数，并将其转换为元组。元组的切片也是元组。

>>> 1, 2, 3
(1, 2, 3)
>>> 42,
(42,)
>>> (1, 2, 3)
(1, 2, 3)
>>> tuple([1, 2, 3])
(1, 2, 3)
>>> tuple('abc')
('a', 'b', 'c')
>>> x = 1, 2, 3
>>> x[1]
2

第3章 使用字符串

3.2 设置字符串的格式：精简版

将值转换为字符串并设置其格式是一个重要的操作，需要考虑众多不同的需求，因此随着时间的流逝，Python提供了多种字符串格式设置方法。以前，主要的解决方案是使用字符串格式设置运算符——百分号。这个运算符的行为类似于C语言中的经典函数printf：在%左边指定一个字符串（格式字符串），并在右边指定要设置其格式的值。指定要设置其格式的值时，可使用单个值（如字符串或数字），可使用元组（如果要设置多个值的格式），还可使用字典（这将在下一章讨论），其中最常见的是元组。

>>> format = "Hello, %s. %s enough for ya?"
>>> values = ('world', 'Hot')
>>> format % values
'Hello, world. Hot enough for ya?

上述格式字符串中的%s称为转换说明符，指出了要将值插入什么地方。s意味着将值视为字符串进行格式设置。如果指定的值不是字符串，将使用str将其转换为字符串。其他说明符将导致其他形式的转换。例如，%.3f将值的格式设置为包含3位小数的浮点数。

这种格式设置方法现在依然管用，且依然活跃在众多代码中，因此你很可能遇到。可能遇到的另一种解决方案是所谓的模板字符串，如下所示：

>>> from string import Template
>>> tmpl = Template("Hello, $who! $what enough for ya?")
>>> tmpl.substitute(who="Mars", what="Dusty")
'Hello, Mars! Dusty enough for ya?

现在推荐使用的是字符串方法format。使用这种方法时，每个替换字段都用花括号括起，其中可能包含名称，还可能包含有关如何对相应的值进行转换和格式设置的信息。

>>> "{}, {} and {}".format("first", "second", "third")
'first, second and third'
>>> "{0}, {1} and {2}".format("first", "second", "third")
'first, second and third'
>>> from math import pi
>>> "{name} is approximately {value:.2f}.".format(value=pi, name="π"
'π is approximately 3.14.'
# 如果变量与替换字段同名，还可使用一种简写。在这种情况下，需要在字符串前面加上f。
>>> e = 2.7                                         
>>> f"Euler's constant is roughly {e}."
"Euler's constant is roughly 2.7.

3.3 设置字符串的格式：完整版

这里的基本思想是对字符串调用方法format，并提供要设置其格式的值。字符串包含有关如何设置格式的信息，而这些信息是使用一种微型格式指定语言（mini-language）指定的。每个值都被插入字符串中，以替换用花括号括起的替换字段。要在最终结果中包含花括号，可在格式字符串中使用两个花括号（即{{或}}）来指定。

替换字段由如下部分组成，其中每个部分都是可选的。

（1）字段名：索引或标识符，指出要设置哪个值的格式并使用结果来替换该字段。除指定值外，还可指定值的特定部分，如列表的元素。

（2）转换标志：跟在叹号后面的单个字符。当前支持的字符包括r（表示repr）、s（表示str）和a（表示ascii）。如果你指定了转换标志，将不使用对象本身的格式设置机制，而是使用指定的函数将对象转换为字符串，再做进一步的格式设置。

（3）格式说明符：跟在冒号后面的表达式（这种表达式是使用微型格式指定语言表示的）。格式说明符能够详细地指定最终的格式，包括格式类型（如字符串、浮点数或十六进制数），字段宽度和数的精度，如何显示符号和千位分隔符，以及各种对齐和填充方式。

下面详细介绍其中的一些要素。

3.3.1 替换字段名

# 在字段名中可使用索引访问列表元素
>>> fullname = ["Alfred", "Smoketoomuch"]
>>> "Mr {name[1]}".format(name=fullname)
'Mr Smoketoomuch'
# 在字段名中可使用句点访问模块中的变量
>>> import math
>>> tmpl = "The math module defines the value {mod.pi} for π"
>>> tmpl.format(mod=math)
'The math module defines the value 3.141592653589793 for π

3.2.2 基本转换

>>> print("{pi!s} {pi!r} {pi!a}".format(pi="π"))
π 'π' '\u03c0'

上述三个标志（s、r和a）指定分别使用str、repr和ascii进行转换。函数str通常创建外观普通的字符串版本（这里没有对输入字符串做任何处理）。函数repr尝试创建给定值的Python表示（这里是一个字符串字面量）。函数ascii创建只包含ASCII字符的表示。

对于格式说明符，下面给出了完整清单。

表3-1 字符串格式设置中的类型说明符

类型	含义
b	将整数表示为二进制数
c	将整数解读为Unicode码点
d	将整数视为十进制数（默认）
e/E	使用科学表示法表示
f	将小数表示为定点数
F	与f相同，但对于特殊值（nan和inf），使用大写表示
o	将整数表示为八进制数
s	保持字符串的格式不变
x	将整数表示为十六进制数并使用小写字母
X	与x相同，但使用大写字母
%	将数表示为百分比值（乘以100，按说明符f设置格式，再在后面加上%）

3.3.3 宽度、精度和千位分隔符

设置浮点数（或其他更具体的小数类型）的格式时，默认在小数点后面显示6位小数，并根据需要设置字段的宽度，而不进行任何形式的填充。当然，你可以根据需要在格式说明中指定宽度和精度。

# 用整数指定宽度，比如将字符串的总宽度设置为10
>>> "{num:10}".format(num=3)
'         3'
>>> "{name:10}".format(name="Bob")
'Bob       '
# 用句点加整数指定精度
>>> "Pi day is {pi:.2f}".format(pi=pi)
'Pi day is 3.14'
# 同时指定宽度和精度
>>> "{pi:10.2f}".format(pi=pi)
'      3.14'
# 如果要添加千位分隔符，使用逗号
>>> 'One million is {:,}'.format(10**6)
'One googol is 1,000,000'

3.3.4 符号、对齐和用0填充

为了打印整齐的表格，有很多用于设置数字格式的机制。在大多数情况下，只需指定宽度和精度，但包含负数后，原本漂亮的输出可能不再漂亮。另外，字符串和数的默认对齐方式不同。在指定宽度和精度的数前面，可添加一个标志。这个标志可以是零、加号、减号或空格，其中零表示使用0来填充数字。

>>> '{:010.2f}'.format(pi)
'0000003.14'
# 要指定左对齐、右对齐和居中，可分别使用<、>和^
>>> print('{0:<10.2f}\n{0:^10.2f}\n{0:>10.2f}'.format(pi))
3.143.143.14  
# 使用指定的字符而不是默认的空格来填充
>>> "{:$^15}".format(" WIN BIG ")
'$$$ WIN BIG $$$'
# 在正数之前加上正号或空格
>>> print('{0:+.2}\n{1:+.2}'.format(pi, -pi))
+3.1
-3.1
>>> print('{0: .2}\n{1: .2}'.format(pi, -pi))3.1
-3.1

3.4 字符串方法

前面介绍了列表的方法，而字符串的方法要多得多，因为其很多方法都是从模块string那里“继承”而来的。

模块string中有几个很有用的常量。

string.digits：包含数字0～9的字符串。
string.ascii_letters：包含所有ASCII字母（大写和小写）的字符串。
string.ascii_lowercase：包含所有小写ASCII字母的字符串。
string.printable：包含所有可打印的ASCII字符的字符串。
string.punctuation：包含所有ASCII标点字符的字符串。
string.ascii_uppercase：包含所有大写ASCII字母的字符串。

字符串的方法太多了，这里只介绍一些最有用的。完整的字符串方法清单请参阅附录B。

#（1）center：通过在两边添加填充字符（默认为空格）让字符串居中。
>>> "The Middle by Jimmy Eat World".center(39)
'     The Middle by Jimmy Eat World     '
#（2）find：在字符串中查找子串。如果找到，就返回子串的第一个字符的索引，否则返回-1。
>>> title = "Monty Python's Flying Circus"
>>> title.find('Monty')
0
#（3）join：用于合并字符串序列
>>> sep = '+'
>>> seq = ['1', '2', '3', '4', '5']
>>> sep.join(seq) # 合并一个字符串列表
'1+2+3+4+5'
#（4）lower：返回字符串的小写版本。
#（5）replace：将指定子串都替换为另一个字符串，并返回替换后的结果。
>>> 'This is a test'.replace('is', 'eez')
'Theez eez a test'
#（6）split：将字符串拆分为序列。如果没有指定分隔符，将默认在单个或多个连续的空白字符（空格、制表符、换行符等）处进行拆分。
>>> '1+2+3+4+5'.split('+')
['1', '2', '3', '4', '5']
>>> 'Using the default'.split()
['Using', 'the', 'default']
#（7）strip：将字符串开头和末尾的空白删除，并返回删除后的结果。
>>> '    internal whitespace is kept    '.strip()
'internal whitespace is kept'

第4章 字典

本章介绍一种可通过名称来访问其各个值的数据结构。这种数据结构称为映射（mapping）。字典是Python中唯一的内置映射类型，其中的值不按顺序排列，而是存储在键下。键可以是数、字符串或元组。

4.1 字典的用途

字典旨在让你能够轻松地找到特定的单词（键），以获悉其定义（值）。

在很多情况下，使用字典都比使用列表更合适。下面是Python字典的一些用途：

• 表示棋盘的状态，其中每个键都是由坐标组成的元组；
• 存储文件修改时间，其中的键为文件名；
• 数字电话/地址簿。

4.2 创建和使用字典

字典以类似于下面的方式表示：phonebook = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

字典由键及其相应的值组成，这种键-值对称为项（item）。在前面的示例中，键为名字，而值为电话号码。每个键与其值之间都用冒号（:）分隔，项之间用逗号分隔，而整个字典放在花括号内。空字典（没有任何项）用两个花括号表示，类似于下面这样：{}。注意，在字典中，键必须是独一无二的。

4.2.1 函数dict

可使用函数dict从键-值对序列创建字典。

>>> items = [('name', 'Gumby'), ('age', 42)]
>>> d = dict(items)
>>> d{'age': 42, 'name': 'Gumby'}
>>> d = dict(name='Gumby', age=42)
>>> d{'age': 42, 'name': 'Gumby'}

4.2.2 基本的字典操作

字典的基本行为在很多方面都类似于序列。

• len(d)返回字典d包含的项（键-值对）数。
• d[k]返回与键k相关联的值。
• d[k] = v将值v关联到键k。
• del d[k]删除键为k的项。
• k in d检查字典d是否包含键为k的项。

虽然字典和列表有多个相同之处，但也有一些重要的不同之处。

（1）键的类型：字典中的键可以是整数，但并非必须是整数。字典中的键可以是任何不可变的类型，如浮点数（实数）、字符串或元组。

（2）自动添加：即便是字典中原本没有的键，也可以给它赋值，这将在字典中创建一个新项。然而，如果不使用append或其他类似的方法，就不能给列表中没有的元素赋值。

（3）成员资格：表达式k in d（其中d是一个字典）查找的是键而不是值，而表达式v in l（其中l是一个列表）查找的是值而不是索引。

4.2.3 将字典用于字符串格式设置功能

在有些情况下，通过在字典中存储一系列命名的值，可让格式设置更容易些。例如，可在字典中包含各种信息，这样只需在格式字符串中提取所需的信息即可。示例如下。

>>> phonebook = {'Beth': '9102', 'Alice': '2341', 'Cecil': '3258'}
>>> "Cecil's phone number is {Cecil}.".format_map(phonebook)
"Cecil's phone number is 3258."

在模板系统（见本书10.3.8.6）中，这种字符串格式设置方式很有用。

4.2.4 字典方法

（1）clear：删除所有的字典项。
（2）复制：copy为浅复制，deepcopy.copy为深复制。

#（3）fromkeys：创建一个新字典，其中包含指定的键，且每个键对应的值都默认为None。
>>> dict.fromkeys(['name', 'age'])
{'age': None, 'name': None}
>>> dict.fromkeys(['name', 'age'], '(unknown)')
{'age': '(unknown)', 'name': '(unknown)'}
#（4）get(key)：容错访问。通常，如果你试图访问字典中没有的项，将引发错误。使用该函数访问不存在的项则会返回None。你也可指定其他错误值。
>>> d.get('name', 'N/A')
'N/A'

（5）items：返回一个包含所有字典项的列表，其中每个元素都为(key, value)的形式。字典项在列表中的排列顺序不确定。返回值属于一种名为字典视图的特殊类型。字典视图可用于迭代。另外，你还可确定其长度以及对其执行成员资格检查。视图的一个优点是不复制，它们始终是底层字典的反映，即便你修改了底层字典亦如此。
（6）keys：返回一个字典视图，其中包含指定字典中的键。
（7）pop(key)：获取与指定键相关联的值，并将该键-值对从字典中删除。
（8）popitem：随机地弹出一个字典项，并将其从字典中删除。

#（9）setdefault：获取与指定键相关联的值，在字典不包含指定的键时，在字典中添加指定的键-值对。
>>> d = {}
>>> d.setdefault('name', 'N/A')
'N/A'
>>> d
{'name': 'N/A'}
>>> d['name'] = 'Gumby'
>>> d.setdefault('name', 'N/A')
'Gumby'
>>> d
{'name': 'Gumby'}
#（10）update(dict)：使用一个字典中的项来更新另一个字典。对于作为参数的新字典，将其项添加到当前字典中。如果当前字典包含键相同的项，就替换它。
#（11）values：返回一个由字典中的值组成的字典视图。该方法返回的视图可能包含重复的值。
>>> d = {}
>>> d[1] = 1
>>> d[2] = 2
>>> d[3] = 1
>>> d.values()
dict_values([1, 2, 1])