数 据 结 构 与 算 法 从 零 开 始 学 习 ( 2 0 2 0 )

用Python解决数据结构与算法问题（一）：Python基础

python学习之路 - 从入门到精通到大师

一、你【实战追-女生视频】好世界

Python是一种现代的，易于学习的面向对象的编程语言。它具有一组强【扣扣】大的内置数据类型和易于使用的控件结构。由于是解释【１】型语言，因此通过简单地查看和描述交互式会话，更容易进行【О】检查。所以好多人会和你说推荐你使用 anaconda 的，比如：【⒈】深度学习入门笔记（五）：神经网络的编程基础。

在 j【б】upyter notebook 中是提示输入语句，然后计算你提供的Py【９】thon语句。例如：

pri【５】nt("Hello，World")

Hel【２】lo，World

打印结果【６】：

print("".join("Hello World"))

二、数据入门

因为Python是支持面向对象的编程范式，这意味着Python认为在解决问题的过程中的重点是数据。在任何面向对象的编程语言中，类都是被定义用来描述数据的外观（状态）和数据能做什么（行为）。因为类的用户只看数据项的状态和行为，所以类类似于抽象的数据类型。数据项在面向对象的范式中称为对象，对象是类的实例。

Python有：

两个主要的内置数字类，分别是 int （整型数据类型）和 float （浮点数据类型）。

标准的算术运算，+，-，*，-，和 **（取幂），可以用括号强制操作的顺序来规避正常的操作符优先级。

其他很有用的操作是余数（模组）操作符%、和整数除法--。注意，当两个整数相除，结果是一个浮点数。整数除法运算符通过截断所有小数部分来返回商的整数部分。

布尔数据类型，作为Python bool类的实现，在表示真值时非常有用。

布尔数据

在标准的布尔操作中，and、or、not，布尔类型的状态值可能是True 和 False。

False or True

not (False or True)

True and True

布尔数据对象也被用作比较运算符的结果，例如相等（==）和大于（）。

关系运算符和逻辑运算符

此外，关系运算符和逻辑运算符可以组合在一起形成复杂的逻辑问题。下表展示了关系和逻辑运算符：

标识符在编程语言中作为名称使用。在Python中，标识符以字母

或下划线（_）开头，大小写敏感，并且可以是任意长度的。请记住，使用表示含义的名称。

赋值语句

在赋值语句的左边第一次使用一个名称时，就会产生一个Python 变量。赋值语句提供了一种将名称与值关联起来的方法。该变量将持有对一块数据的引用而不是数据本身。思考以下会话：

theSum = 0

theSum = theSum + 1

theSum = True

赋值语句 theSum = 0 创建一个变量称为 theSum 并让它持有对数据对象0的引用。通常，会对赋值语句的右侧进行求值，并将对结果数据对象的引用赋值给左侧的名称。如果数据的类型发生变化，变成布尔值 True，那么变量的类型也如此，theSum 现在变成布尔型。即相同的变量可以引用许多不同类型的数据。

除了数字和布尔类之外，Python还有许多非常强大的内置集合类。

列表、字符串和元组是有序集合。

集合和字典是无序的集合。

2.1、列表

列表是对Python数据对象的零个或多个引用的有序集合。列表的写法是用方括号括起来、以逗号分隔。空列表简单的用[]表示。列表是异构的，这意味着数据对象不需要全部是同一类型，并且可以集合在一起，赋值给一个变量，如下所示。下面的代码展示了列表中的各

种Python数据对象。

[1,3,True,6.5]

[1, 3, True, 6.5]

myList = [1,3,True,6.5]

[1, 3, True, 6.5]

请注意，当Python对列表求值时，会返回列表本身。然而，为了记住后面的列表操作，它的引用需要赋值给一个变量。

由于列表被认为是按顺序排列，所以它们支持许多可以应用于任何Python序列的操作。

注意，列表（序列）的索引从0开始计数。切片操作，myList[1:3]，返回一个包含索引从1到3的项的列表、但不包含索引为3的项，即左闭右开。

有时需要初始化一个列表，这可以通过使用重复操作快速完成。例如，

myList = [0] * 6

[0, 0, 0, 0, 0, 0]

除了重复操作符之外，还有一个非常重要的问题是其结果是对序列中的数据对象的引用的重复。通过思考以下代码得到最好的印证： myList = [1,2,3,4]

A = [myList]*3

print(A)

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

print(A)

[[1, 2, 45, 4], [1, 2, 45, 4], [1, 2, 45, 4]]

变量 A 持有三个名为 myList 的原始列表的引用。注意，对myList 的一个元素的更改，在 A 的所有三种情况中都体现了出来列表基本操作

列表支持许多用于构建数据结构的方法，如下：

例子如下：

myList = [1024, 3, True, 6.5]

myList.append(False)

print(myList)

[1024, 3, True, 6.5, False]

myList.insert(2,4.5)

print(myList)

[1024, 3, 4.5, True, 6.5, False]

print(myList.pop())

print(myList)

[1024, 3, 4.5, True, 6.5]

print(myList.pop(1))

print(myList)

[1024, 4.5, True, 6.5]

myList.pop(2)

[1024, 4.5, 6.5]

可以看到一些方法，比如 pop，返回一个值，并修改列表。

myList.sort()

print(myList)

[4.5, 6.5, 1024]

myList.reverse()

print(myList)

[1024, 6.5, 4.5]

print(myList.count(6.5))

print(myList.index(4.5))

myList.remove(6.5)

print(myList)

[1024, 4.5]

del myList[0]

print(myList)

其他的，比如 reverse 和 append，只是简单地修改列表，没有返回值。除此之外，还应该注意到熟悉的 dot 符号，使对象调用方法。

(54).__add__(21)

在此段中，整型对象54来执行它的 add 方法（在Python中称为__add__），并将它与传过去的21相加，结果是75。当然，通常还是

直接把它写成54+21。

range函数

通常与列表一起讨论的一个常见的Python函数是 range 函数。range 产生一个范围对象，表示一系列的值。通过使用 list 函数，可以将 range 对象的值看作一个列表。例子如下：

range(10)

range(0, 10)

list(range(10))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

range(5,10)

range(5, 10)

list(range(5,10))

[5, 6, 7, 8, 9]

list(range(5,10,2))

list(range(10,1,-1))

[10, 9, 8, 7, 6, 5, 4, 3, 2]

range 对象代表一个整数序列。默认情况下，它将从0开始。常用的参数有三个，在特定的点开始和结束，甚至可以跳过某项。

在第一个例子中，（10），序列从0开始，递增到10但不包括10。

在第二个例子中，范围（5,10）从5开始，递增到10但不包括10。

在第三个例子中，范围（5,10,2）类似的执行，但是跳过2（同

样，10不包括在内）。

2.2、字符串

字符串是由零个或多个字母、数字和其他符号组成的序列集合。通过使用引号（单引号或双引号）将文字字符串值与标识符区分开来。

myName = "David"

myName[3]

myName*2

'DavidDavid'

len(myName)

由于字符串也是序列，所以可以使用上面描述的任何操作。另外，字符串有许多方法，其中一些方法如下所示。

举几个例子：

myName.upper()

myName.center(10)

myName.find('v')

myName.split('v')

['Da', 'id']

myName.split()

['David']

其中，split 对于处理数据非常有用。split 将使用一个字符串，并使用分割字符作为分隔点返回字符串列表。在这个例子中，v 是分隔点。如果没有指定分隔点，split 方法会寻找空格字符，如制表符、

换行符和空格。

列表和字符串之间的主要区别是，列表可以被修改，而字符串不能，这被称为可变性。列表是可变的；字符串是不可变的。

[1, 3, True, 6.5]

myList[0]=2**10

[1024, 3, True, 6.5]

myName[0]='X'

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

ipython-input-7-c44c71c6d2f3 in module

1 myName = "David"

---- 2 myName[0]='X'

TypeError: 'str' object does not support item assignment

2.3、元组

元组与列表非常相似，因为它们是异构的数据序列。不同之处在于，元组是不可变的，就像字符串一样。任何元组都不能被改变。

作为序列，它们可以使用上面描述的任何操作。例如,

myTuple = (2,True,4.96)

(2, True, 4.96)

len(myTuple)

myTuple[0]

myTuple * 3

(2, True, 4.96, 2, True, 4.96, 2, True, 4.96)

myTuple[0:2]

(2, True)

但是，如果试图改变元组中的一个项，将会得到一个错误。注意，错误消息提供了问题的位置和原因。

myTuple[0] = 1

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

ipython-input-6-a2c5dba3de3b in module

1 myTuple = (2,True,4.96)

---- 2 myTuple[0] = 1

TypeError: 'tuple' object does not support item assignment

2.4、集合

set 是一个无序的，为空或是更多不可变的Python数据对象集合。集合中的值不允许重复，写在大括号中。空集合由 set() 表示。如下所示。

{3,6,"cat",4.5,False}

{False, 4.5, 3, 6, 'cat'}

mySet = {3,6,"cat",4.5,False}

{False, 4.5, 3, 6, 'cat'}

尽管集合不被认为是连续的，但是它们确实支持前面提到的一些熟悉的操作。下表回顾了这些操作，并给出了使用示例。

{False, 4.5, 3, 6, 'cat'}

len(mySet)

False in mySet

"dog" in mySet

集合支持许多方法，这些方法对于在数学集合中使用它们的人来说应该是熟悉的。下表提供了总结，它们的使用示例如下。请注意，联合，交集，子集和差分都有可以使用的运算符。

{False, 4.5, 3, 6, 'cat'}

yourSet = {99,3,100}

mySet.union(yourSet)

{False, 4.5, 3, 100, 6, 'cat', 99}

mySet | yourSet

{False, 4.5, 3, 100, 6, 'cat', 99}

mySet.intersection(yourSet)

mySet yourSet

mySet.difference(yourSet)

{False, 4.5, 6, 'cat'}

mySet - yourSet

{False, 4.5, 6, 'cat'}

{3,100}.issubset(yourSet)

{3,100}=yourSet

mySet.add("house")

{False, 4.5, 3, 6, 'house', 'cat'}

mySet.remove(4.5)

{False, 3, 6, 'house', 'cat'}

mySet.pop()

{3, 6, 'house', 'cat'}

mySet.clear()

2.5、字典

最后一个，Python集合是一个无序的结构，称为字典。字典是一组关联项，其中每一项由一个键和一个值组成。这个键-值对通常被写成 key：value。字典的键值对以逗号分隔并用花括号括起来。例如：

capitals = {'Iowa':'DesMoines','Wisconsin':'Madison'} capitals

{'Wisconsin': 'Madison', 'Iowa': 'DesMoines'}

可以通过它的键来访问它的值，或者通过添加另一个键-值对来操作字典。取值语法除了使用键值而不是使用项目的索引，看起来很像序列取值，添加新值类似。

capitals = {'Iowa':'DesMoines','Wisconsin':'Madison'} print(capitals['Iowa'])

DesMoines

capitals['Utah']='SaltLakeCity'

print(capitals)

{'Iowa': 'DesMoines', 'Wisconsin': 'Madison', 'Utah': 'SaltLakeCity'}

capitals['California']='Sacramento'

print(capitals)

{'Iowa': 'DesMoines', 'Wisconsin': 'Madison', 'Utah': 'SaltLakeCity', 'California': 'Sacramento'}

print(len(capitals))

for k in capitals:

print(capitals[k]," is the capital of ", k) DesMoines is the capital of Iowa

Madison is the capital of Wisconsin

SaltLakeCity is the capital of Utah

Sacramento is the capital of California

字典既有方法又有操作符，下面两个表格分别描述了它们：

phoneext={'david':1410,'brad':1137}

phoneext

{'brad': 1137, 'david': 1410}

phoneext.keys()

dict_keys(['brad', 'david'])

list(phoneext.keys())

['brad', 'david']

phoneext.values()

dict_values([1137, 1410])

list(phoneext.values())

[1137, 1410]

phoneext.items()

dict_items([('brad', 1137), ('david', 1410)])

list(phoneext.items())

[('brad', 1137), ('david', 1410)]

keys、values 和 items 方法都返回包含感兴趣的值的对象。而get 方法有两种变体，如果字典里没有对应键，get 将返回空。然而，第二个可选参数可以指定一个返回值。

phoneext={'david':1410,'brad':1137}

phoneext

{'brad': 1137, 'david': 1410}

phoneext.get("kent")

# 返回空说明没有对应的键

phoneext.get("kent","NO ENTRY")

'NO ENTRY'

三、输入和输出

我们经常需要与用户交互，要么获取数据，要么提供某种结果。现今的大多数程序都使用一个对话框来让用户提供某种类型的输入，

比如百度的搜索框。

虽然Python确实有创建对话框的方法，但是可以使用一个简单得多的函数 input。它接受单个参数，即字符串。这个字符串通常被称为提示符，因为它包含一些有用的文本，提示用户输入一些东西。

再比如，可以按如下方式调用输入：

aName = input('Please enter your name: ')

无论用户在提示符后面输入什么，都将存储在 aName 变量中。通过使用 input 函数，可以轻松地编写指令，提示用户输入数据，然后将这些数据合并到进一步的处理中。

例如，在接下来的两个语句中，首先询问用户的名称，第二个语句打印基于所提供的字符串的一些简单处理的结果（名字全大写并返回长度）。

aName = input("Please enter your name ")

print("Your name in all capitals is",aName.upper(), "and has length", len(aName))

需要注意的是，输入函数返回的值将是一个字符串，表示在提示后输入的确切字符。如果想将此字符串解释为另一种类型，必须提供显示的类型转换。

在下面的语句中，由用户输入的字符串被转换为浮点数，以便它可以用于进一步的算术处理。

sradius = input("Please enter the radius of the circle ") radius = float(sradius)

diameter = 2 * radius

print(diameter)

格式化字符串

打印功能 print 采用零个或更多的参数，并使用单个空格作为默认分隔符来显示它们。可以通过设置 sep 参数来更改分隔符。此外，每次打印在默认情况下都以换行符结尾，可以通过设置结束参数来改变这种行为。这些变化将显示在以下会话中：

print("Hello")

print("Hello","World")

Hello World

print("Hello","World", sep="***")

Hello***World

print("Hello","World", end="***")

Hello World***

Python提供了一种称为格式化字符串的替代方案。格式化的字符串是一个模板，在这个模板中，结合了保持不变的单词或空格与插入到字符串中的变量的占位符。例如：

print(aName, "is", age, "years old.")

包含词语 is 和 years old，但是名称和年龄将根据执行时的变量值而变化。使用格式化的字符串，改写为

print("%s is %d years old." % (aName, age))

这个简单的例子说明了一个新的字符串表达式。%号是一个字符串

操作符，称作格式化操作符。表达式的左边含有模板或格式字符串，右边包含将被替换成格式字符串的值的集合。

注意，右侧集合中的值的数量与格式字符串中的%字符数相对应，值从左到右依次从集合中获取并插入到格式字符串中。

一个转换字符告诉格式化操作符将插入到字符串中的那个位置的值类型。在上面的例子中，%s指定一个字符串，而%d指定一个整数。其他可能的类型规范包括i、u、f、e、g、c或%。下表总结了各种类型的规范：

除了格式字符之外，还可以在%和格式字符之间包含一个格式修饰符。格式修饰符可以用来对指定字段宽度的值进行左对齐或右对齐。修饰符也可以用来指定字段宽度，以及小数点后的数字。下表解释了这些格式修饰符：

格式操作符的右边是一组值，这些值将被插入到格式字符串中，这个值可能是元组或者字典。

如果是一个元组，那么这些值就会按照位置的顺序插入；

如果集合是一个字典，那么这些值就会按照键插入键所对应的值。在这种情况下，所有格式字符都必须使用(name)修饰符来指定键的名称。

price = 24

item = "banana"

print("The %s costs %d cents"%(item,price))

The banana costs 24 cents

print("The %+10s costs %5.2f cents"%(item,price))

The banana costs 24.00 cents

print("The %+10s costs %10.2f cents"%(item,price))

The banana costs 24.00 cents

itemdict = {"item":"banana","cost":24}

print("The %(item)s costs %(cost)7.1f cents"%itemdict) The banana costs 24.0 cents

自从Python2.6 开始，新增了一种格式化字符串的函数 .format()，它增强了字符串格式化的功能。基本语法是通过 {} 和 : 来代替以前的 %。format 函数可以接受不限个参数，位置可以不按顺序。

print("{} {}".format("hello", "world"))

hello world

print("{0} {1}".format("hello", "world"))

hello world

print("{1} {0} {1}".format("hello", "world"))

world hello world

四、控制结构

算法需要两个重要的控制结构：迭代和选择。

迭代语句

对于迭代，Python提供了一个标准的 while 语句和一个非常强大的 for 语句。只要条件为真，while 语句就会重复一段代码。例

如，

counter = 1

while counter = 5:

. print("Hello, world")

. counter = counter + 1

Hello, world

Hello, world

Hello, world

Hello, world

Hello, world

在每次重复的开始时评估 while 语句的条件。如果条件为真，则将执行语句主体。由于python语言强制执行的强制缩进模式，很容易看到 while 语句的结构。

while 语句是一个非常通用的迭代结构，在许多情况下，复合条件将控制迭代。

while counter = 10 and not done:

另一个迭代结构 for 语句，可以与序列一起使用，用于迭代成员。例如，

for item in [1,3,6,2,5]:

. print(item)

将变量 item 指定为列表中[1,3,6,2,5]的每个连续值。然后执行迭代的主体。这适用于任何序列（列表，元组和字符串）。

for 语句的一个常见用途是在一系列值上实现明确的迭代。如下 for item in range(5):

. print(item**2)

该语句将执行五次 print 功能，range 函数将返回表示序列0,1,2,3,4的范围对象，并且每个值将分配给变量 item，然后计算该值平方并打印。

此迭代结构还可以用于处理字符串的每个字符，以下代码输出的是所有单词中字母的列表：

wordlist = ['cat','dog','rabbit']

letterlist = [ ]

for aword in wordlist:

for aletter in aword:

letterlist.append(aletter)

print(letterlist)

['c', 'a', 't', 'd', 'o', 'g', 'r', 'a', 'b', 'b', 'i', 't'] 选择语句

选择语句允许程序员提出问题，然后根据结果执行不同的操作。大多数编程语言都提供了两个版本：ifelse 和 if。举一个分数判定的例子：

if score = 90:

print('A')

if score =80: