简单python五子棋代码，学习Python全套代码【超详细，一招彻底弄懂

a = 100

这是一个浮点型变量

b = 3.14

整形和浮点形数值可以相互运算，比如

c是一个浮点型变量

c = a + b

这个很容易理解，一个整数加上一个小数，得到的肯定还是一个小数。我们再看另一个例子，可以先猜猜是什么类型。

a = 0.14
b = 3.14
c = b - a

c=3.0

这里面变量c还是一个浮点型，它的值是3.0，可以得出一个结论，只要有浮点数参与的运算，它的结果肯定也是浮点数。

2.2.2 字符串

我们在Hello world例子中使用的就是字符串类型

a = “Hello world”

当如果字符串含有特殊字符，比如双引号，我们可以加一个\来进行转义。

print(“Buddha: “What we think, we become.””)

输出的结果是：Buddha: “What we think, we become.”

截止目前，我们在定义字符串时使用的都是双引号，其实Python也支持单引号，它们并没有什么区别。

a = “Hello”
b = ‘world’

print(a, b)

输出的结果仍然是Hello world

这种灵活的写法给了我们便利，比如上面那个字符串中包含双引号的例子中，我们可以使用单引号定义字符串，这样就不用对字符中的字符串进行转义了，这样看起来是不是清爽了很多。

print(‘Buddha: “What we think, we become.”’)

有时候我们要定义的字符串比较长，超出了一行的长度，在编写的时候使用一个反斜杠""来连接多行：

sentence = “This’s a very long long long
long long sentence…”

print(sentence)

上面的代码在输出的时候还是会显示为一整行。如果说还有更长的字符串，类似一整段话，我们可以使用三引号

zen = “”“Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.”“”

print(zen)

当然，上面的双引号也可以用单引号代替。

2.2.3 布尔值(boolean, bool)

布尔值只有两个值: True 和 False，顾名思义，True代表真，False代表假，我们用布尔值一般是用来做条件判断。在Python3中，True和False是关键字，所以我们不能定义为变量名。

2.2.4 空值 None

空值None是Python中的一个特殊值，它代表空值，表示“什么都没有”，None同时也是关键字。None的用处有很多，比如说你想定义一个变量，但一时还没想好给它赋什么值，甚至连它用什么类型也没决 定好，这时可以先用None。

temp = None
print(temp)

None被输出的时候显示为一个字符串"None"

2.2.5 类型转换

2.2.5.1 布尔值转换

要想把其他值转换为布尔值，需要使用一个内置函数bool()，我们在控制台按顺序输入以下的代码：

Python

以下值都为True

bool(1)
bool(-1)
bool(255)
bool(0.0000001)
bool(-99.99)

下面的值为False

bool(0)
bool(0.0)

通过上面的代码，不难总结出：对于数值类型，所有的非零值转换为True, 只有零值才转换为False. 字符串也可以转换为布尔值

这是一个空字符串，转换结果为False

bool(“”)

转换结果为True

bool(“abc”)

这是一个只包含一个空格的字符串，转换结果为为True

bool(" ")

对于任何非空的字符串，转换为布尔值都是True。注意第一行代码和第三行代码。

空值转换为布尔值永远都是False（敲黑板）

结果为False

bool(None)

2.2.5.2 字符串转换

首先介绍一下我们可以使用str() 将其他类型转换为字符串，

True, False, None 这三个值转换为字符串就是它们的单词本身，实际上在实际编程中，我们很少需要把它们转换成字符串来使用。

str(True)
str(False)
str(None)

结果是’True’ # 结果是’False’ # 结果是’None’

对于数值类型，我们也可以用str()将它们转换为字符串，

print(“My age is”, str(18))

在上面的例子中，我们使用str()将18转换为"18"，然后再输出。实际上，在这个例子中，如果不进行强制转换的话，也不会出错，那是因为，print函数会自动将数值先转换成字符串再输出。

2.2.5.3 数值转换

数值转换是我们在数据分析过程中经常用到的，因为我们从任何文件中读到的数字一开始都是字符串， 需要将它们转换为数值才能进行运算。

如果想要把一个整数字符串转换为int类型，使用int()；

num = “1”
int(num) + 1

如果将int()去掉，这段代码则会报错，因为num是个字符串，不能将字符串和数值进行相加。

数值的前后带有空格也可以成功转换：

int(" 100 ")

结果为100

带有符号的数字也可以成功转换

int(“-1”) # 结果为-1
int(“+1”) # 结果为1

如果想要把一个带小数点的字符串转换为float类型，使用float() pi = “3.1415926”

float(pi)

int类型和float类型之间也可以相互转换

int(3.14) #结果为3
int(9.9) # 结果为9
float(100) # 结果为100.0

注意第二行中，9.9并没有转换为10，虽然这样更符合我们的常识，四舍五入嘛，但float在被转换为int的过程中，它的小数部分精度将被丢弃，只取整数部分。所以在将float转换为int的过程中，永远要小 心。

那如果想要四舍五入的来转换呢，毕竟这样更符合我们的需求。Python给我们提供了一个内置函数： round

round(9.9) #结果为10
round(9.5) #结果为10
round(9.49) #结果为9

甚至，round函数让我们可以指定要保留小数点后几位：
保留小数点后两位，由于第三位是1，所以结果是3.14 round(3.1415926, 2)
保留小数点后三位，由于第四位是5，所以结果是3.142 round(3.1415926, 3)

布尔值也可以转换为int或者float

int(True) # 结果是1
int(False) # 结果是0

float(True) # 结果是1.0
float(False)# 结果是0.0

观察一下，恰好是数值类型转换为布尔类型的相反过程。

第三节 运算符

2.3.1 算术运算符

Python中进行数值运算需要的符号如下，我们来一一学习一下。

运算符 描述 实例

•   加	    1 + 1; a + b
  

•   减	    10 - 5; a - b -c
  

•   乘	    4 * 2 相当 4 × 2
  

/ 除 4 / 2 相当于 4 ÷ 2
// 取整除 10 // 4 结果是 2
% 取模 10 % 4 相当于 10 - (10 // 4) × 4
** 指数 2 ** 3 相当于 2 * 2 * 2，也就是2的3次方
() 小括号 提高运算优先级，比如: (2 + 8) * 3

我们来看几个例子：

print(1 + 1)
print(10 - 5)
print(4 * 2)
print(4 / 2) # 结果是2.0

上面的例子都是简单的加减乘除，我们用肉眼就能观察出结果，需要注意的是除法运算, 当我们使用单斜杠除法运算符时，即使除数和被除数都是整数，它的返回结果也是一个浮点数。

print(5 / 2) # 结果是2.5
print(5 // 2) # 结果是2

当我们需要对两个整数进行除法运算，且对结果的小数精度要求不高的时候，一般使用双斜杠来进行运算，这样能保证结果也是整数，不用再进行类型转换。

print(10 / 3) # 结果是3.3333333333333335

、

上面这行代码的结果很有意思，我们都清楚，10 ÷ 3的结果是3.333…无限循环小数，但无限循环小数毕竟是个数学概念，计算机无法表达，所以只能显示到一定的位数。细心的你可能会发现最后一位为什么是5呢？四舍五入的话也应该是3呀。这是因为小数以二进制形式表示时的有穷性导致的，也就是计算机底层机制的原因。这里面的细节大家可以先不管，但要记住进行浮点数运算时是有精度问题的。

print(10 % 4) # 结果是2
print((2 + 8) * 3) # 结果是30

取模运算符大家先暂时可以理解为取余数，记住以下几个规则：

1. 当两个数能整除时，取模运算的结果为0，比如 8 % 4 的结果是0
2. 当0<a<b时，a % b = a，比如 3 % 8 的结果是3
3. 当两个数中有负数时，结果可能会跟我们预料的不同，记住这个公式就行了 ：a % b 就相当于a - (a // b) * b

2.3.2 使用算术运算符操作字符串

对，没有看错，字符串在Python中也可以“运算”，有两种操作，我们先看看加法。

print("Hello " + “world”)

加号可以将两个字符串拼接成一个字符串，也可以将多个字符串拼接在一起：

print("apple " + "apple " + "apple ")

那如果有太多的"apple"怎么办呢？总不能一直加下去吧，这时候我们可以使用"*"运算符，表示将该字符串重复几次并拼接成一个字符串。

print("apple " * 5)

使用加号拼接字符串时需要注意，不能将字符串与数值一起相加，比如说我们要给用户发现一条查询积分的消息：

print(“您账户积分为：” + 500)

这样写将会报错，所以我们要在拼接之前，先将500转换为字符串，运用我们上面学过的知识，修改成这样：

print(“您账户积分为：” + str(500))

2.3.3 赋值运算符

赋值操作其实我们已经用过了，在前面定义变量的时候我们都会使用等于号。

num = 1
name = “Smith”

结合上面的运算符，我们可以做更多的赋值操作：

运算符 描述 实例
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
//= 取整除赋值运算符 c //= a 等效于 c = c // a
%= 取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c = a 等效于 c = c a

我们在日常编程中最常用的是加法赋值和减法赋值，比如设置一个计数器，每次+1

count = 0
count += 1
count += 1

执行了两次加法赋值操作后，count的值变成了2。

2.3.4 比较运算符

比较运算符是用来运算布尔值的， 将两个值放在一起比较，最后得到True或者False。

运算符 描述 实例
== 等于 100 == 100
!= 不等于 100 != 99

  大于		2 > 1

< 小于 1 < 2

= 大于等于 3 >= 2
<= 小于等于 2 <= 3

我们可以在控制台cmd中的python里输入一些比较运算，看看它们的返回值是什么

100 == 100 # True
100 == “abc” # False
1 != 2 # True
2 != 2 # False
3 > 3 # False
3 >= 3 # True
2 < 3 # True
2 <= 3 # True

这都是符合我们的常识的操作，大家在控制台里试着敲一遍就明白了。下面再试试一些比较特殊的例子：

100 == “100” # False
100 == 50 * 2 # True
str(100) == “100” # True
1.0 != 1 # False
int(1.9) == 1 # True

需要注意的一点是，数值100 和字符串"100"是不相等的，这一点尤其要小心，这种隐藏的bug很难被发现。

2.3.4 逻辑运算符

真实的程序中，常常需要判断的条件是复杂的，所以我们需要逻辑运算符将多个比较运算连接起来。

运算符 逻辑表达式 描述
and x and y 任意一个是False，结果就是False True and False 结果为False
or x or y 任意一个是True，结果就是True; True or False 结果为True
not not x 将条件取反 not False 结果为True

我们来看几个例子：

定义两个变量

a, b = 1, 2

a > 0 and a < b # True

a % 2 == 0 or b % 2 == 0 # True

not a > b # True

and, or, not它们也是Python中的关键字，这是经常需要使用的三个关键字。掌握好逻辑运算符是学好任何一门编程语言的基础。

逻辑运算符可以与赋值操作组合，让你的代码更老练：

a = 0 or 100 # a=100
b = 1 or 2 # b=1

第四节 流程控制

经过前面三个小节的学习，我们已经对Python编程语言有了一个初步的了解。如果说Python是一条蟒蛇，变量、数据类型、运算符就是它的肌肉和骨架，而流程控制相当于它的神经系统，掌握了流程控 制知识，就可以让Python灵活的游动起来。

Python的流程控制比较简洁，主要分为两块：条件判断和循环控制。

2.4.1 条件判断

2.4.1.1 if…else…语句

在这里要介绍两个重要的关键字，if 和 else，看它们的字面意思就能猜到它们表示“如果”… “否则”… 我们来看看在代码中如何使用

num = 3

通过取模运算判断num是否能被2整除

if num % 2 == 0:
print(str(num) + “是一个偶数”)
else:
print(str(num) + “是一个奇数”)

这一波段代码是一个完整的逻辑，今后我们写的程序会更复杂，但也只不过是这段代码的重复和组合而 已。

2.4.1.2 elif

上面的例子中是一个非常简单的逻辑，一个整数，它要么是偶数要么是奇数，如果说再复杂一点的条件，我们该如何写呢？比如说来判断一个学生的考试成绩，60分以下的为不及格，60~90分为合格，90 分以上为优秀，这里面有三个条件。

score = 59

if score < 60:
print(“您的考试成绩不及格”)
elif score < 90:
print(“您的考试成绩合格”)
else:
print(“您的考试成绩优秀”)

在这个例子中，使用了一个新的关键字"elif", 它只能用在if判断之后，else之前。

2.4.1.3 if 条件嵌套

还是以学生考试成绩的例子来说，现在我们想对60-100分的进行更细的划分，60-70分为合格，70-90 分为良好，90分以上为优秀。

score = 100

if score >= 60:
if score < 70:
print(“您的考试成绩为合格”)
elif score < 90:
print(“您的考试成绩为良好”)
else:
print(“您的考试成绩为优秀”)
else:
print(“您的考试成绩不及格”)

嵌套循环可以嵌套无数层，但通常我们都建议尽量减少嵌套的层数，以增加代码的可读性。

2.4.1.3 与逻辑运算符组合

age = 22
if age > 18 and age < 60:
print(“你已经不是个孩子啦，该去工作啦”)

上面的例子表示，年龄大于18岁并且小于60岁，也可以这样写：

age = 22

if 18 < age < 60:
print(“你已经不是个孩子啦，该去工作啦”)

这样的代码更简洁，可读性更高，这是Python特有的简洁写法。

2.4.1.4 自动类型转换

if 和 elif 的后面总是跟着一个表达式，这个表达式的结果必须是True或者False，如果表达式运算出来的结果不是一个布尔值，则会自动将结果转换为布尔值，无论它是什么类型的值。转换的结果遵循我们之 前学过的布尔转换规律。

count = 0

if count:
print(“条件成立”)
else:
print(“条件不成立”)

试着将count的值改为1，条件则成立了。

result = None
if result:
pass
else:
print(“什么收获都没有”)

记住：0值、None 和空字符串转换为布尔值后都是False

pass是Python的关键字，它表示什么也不做。

2.4.2 循环

看到循环我们首先会想到一些物体，比如旋转的风扇、车轮，一个圆的形状。一个圆形的跑道，如果沿着它跑，除非我们自己停下来，永远不会有终点，但是可以计算我们跑了多少圈。假设我们在跑步之前，给自己设定一个目标，跑完10圈就不跑了，然后去一圈一圈的跑完了10圈，停止。这个过程就很像代码里的循环语句了。

2.4.2.1 while循环

lap = 0

while lap < 10:
lap += 1

print(“我跑完了第” + str(lap + 1) + “圈”)

运行上面的代码，会得到以下的输出：

我跑完了第1圈
我跑完了第2圈
我跑完了第3圈
我跑完了第4圈
我跑完了第5圈
我跑完了第6圈
我跑完了第7圈
我跑完了第8圈
我跑完了第9圈
我跑完了第10圈

2.4.2.2 for循环

for循环可以用来遍历序列，序列指的是一个可迭代的有序的集合，比如字符串就是一个序列，下面我 们用for循环来打印出一个字符串中的所有字符。

seq = “hello”

for s in seq:
print(s)

这段代码的输出如下：

h
e
l
l
o

也可以用for循环来打印一连串的数字，这里需要用到一个新的内置函数：range。

for i in range(5):
print(i)

range函数的作用就是提供一个从0到4的迭代器，而for可以遍历这个迭代器。注意是从0开始的，整个循环一共打印了5个数。

输出结果是：

0
1
2
3
4

我们可以修改一下之前写的跑圈的while循环，改用for循环加range函数来实现：

for lap in range(10):
print(“我跑完了第” + str(lap + 1) + “圈”)

对比一下，哪种写法更简洁，更优雅 ？很明显是用for循环这种。这里面有一个细节需要注意，由于lap的值是从0开始到9结束，所以我们需要在输出的时候给它+1。

2.4.2.3 嵌套循环

既然掌握了两种循环写法，那可以把它们组合起来运用，我们来写一个例子，在控制台中打印出指定边长的长方形或者正方形图案。

指定长方形的宽和高

width, height = 10, 5

因为是从上往下开始打印，所以先遍历高度

for i in range(height):
for j in range(width):
print(“*”, end=“”)
print()

在这里，print函数有了第二个参数，end表示在打印完指定的内容后，在结尾再打印一个指定的字符串，默认每个print语句在结尾会加一个换行符"\n", 传递一个空字符串给它，表示打印完星号以后不再添加任何输出内容。

第二个print函数没有任何参数，那它会输出一个换行符。

所以整个程序的逻辑就是每输出10个星号后，输出一个换行符，最终输出的图案如下：

---

---

---

---

---

既然可以打印出一个长方形，那我们也可以打印一个直角三角形：

**

---

---

---

代码如下

for i in range(5):
for j in range(i + 1):
print(“*”, end=“”)
print()

再来一个稍微复杂一点的案例，打印出这样一个九九乘法表：

11=1
12=2 22=4
13=3 23=6 33=9
14=4 24=8 34=12 44=16
15=5 25=10 35=15 45=20 55=25
16=6 26=12 36=18 46=24 56=30 66=36
17=7 27=14 37=21 47=28 57=35 67=42 77=49
18=8 28=16 38=24 48=32 58=40 68=48 78=56 88=64
19=9 29=18 39=27 49=36 59=45 69=54 79=63 89=72 9*9=81

代码如下：

for i in range(1, 10):
for j in range(1, i + 1):
print(“%s*%s=%s” % (j, i, i * j), end=" ")
print()

2.4.2.4 break 和continue

有时候在循环内部，我们需要临时略过某一次循环或者干脆跳出整个循环，这时候就需要用到break和continue。

在下面这个例子中，我们使用for循环和continue来打印出10以内的所有奇数相加的式子，并求出它们的和。

total = 0

for i in range(10):
if i % 2 == 0:
continue
print(i, end=" + ")
total += i

print(" = %s" % total)

关键字break用来打断整个循环并跳出。看这个例子，给一个字符串，这个字符串是一个小数，要求打印出小数的整数部分。

s = “238.9237834829”

for i in s:
if i == ‘.’:
print()
break

print(i, end=‘’)

小数的整数部分都在小数点的左边，而我们遍历字符串是从左往右，所以当遇到小数点后，就停止遍历，这样就正好实现了打印这个小数的整数部分。

2.4.3 演示：智能密码锁程序

最近几年很流行的智能密码锁程序，除了可以用指纹开锁、人脸识别开锁外，都会有密码开锁的功能， 以防万一。密码开锁功能是这样的，首先设定好密码，以后每次开锁的时候只要输入的数字中含有设定的密码，就视为解锁成功。这样的设定是为了防止别人的窥探，具有更高的安全性。

首先，由于涉及到了输入，先来学习一下Python内置的输入函数: input

password = input(“请设置您的密码”)

在执行到这行代码时，控制台就变成光标闪烁的状态，用户可以用键盘进行字符的输入，输入完成后， 再输入一个回车表示输入结束，输入的字符串赋给等号左边的变量。

设置初始密码

password = “123”

while True:
pwd = input(“请输入您想要设置的密码：”)

如果没有输入任何密码，则使用初始密码作为密码

if not pwd:
break
confirm_password = input(“请再次输入您的密码：”)
if pwd == confirm_password:
password = pwd
break
else:
print(“您两次输入的密码不一致，请重新输入。”)

print(“您的初始密码已设置为：” + password)
print(“进入开锁程序。。。”)

开锁

while True:
input_pwd = input(“请输入您的密码：”)

判断输入的密码中是否包含密码

if password in input_pwd:
print(“开锁成功！”)
break
else:
print(“您输入的密码有误，请重新输入”)

注意 password in input_pwd 这行代码，关键字in表示如果在指定的序列中找到值返回 True，否则返回 False。

第三部分 数据结构

第一节 字符串

在任何一门编程语言中，字符串都是最基础、最重要的数据结构。前面我们已经学习过字符串的基本使用方法，现在继续深入的学习更多的知识。

3.1.1 字符串的格式化输出

3.1.1.1 格式化运算符

在之前while循环的一个例子中， 有这样一行代码：

print(“我跑完了第” + str(lap + 1) + “圈”)

这里我们使用了两个加号做了字符串拼接，并且将整形转换成了字符串，现在介绍一种更好的办法，使用格式化输出来打印这句话。

print(“我跑完了第%d圈” % 1)

这里的百分号就是格式化符号，跟模运算符一样，但在不同的地方用法不一样。%d是一种占位，表示 要显示在这里是一个整数，常用的占位符有以下几种：

占位符 描述
%d 整数占位符
%f 浮点数占位符
%.f 指定精度的浮点数占位符
%s 字符串占位符
%% 输出百分号%

如果给%d 传入一个浮点数，那它会自动将它转换成整数

print(“%d” % 3.14) # 输出3
print(“%d” % 3.99) # 输出3

转换成整数的规则和类型转换的规则一 样，不会四舍五入。

%f的用法有两种，一种就是直接使用，比如

print(“%f” % 3.14)

它会输出“3.140000”，后面的0是自动补齐的，如果我们只想要输出小数点后两位，可以这样写： print(“%.2f” % 3.14)

print(“%.2f” % 3.1415926)

上面的两行代码输出都是"3.14"，“%.2f” 这种写法指定了小数点后面的位数，即使浮点数后面的小数部分超出了2位，也只会输出两位。如果不足两位，或者是个整数，会自动补零到两位。

print(“%.2f” % 3) # 3.00
print(“%.2f” % 3.1) # 3.10
print(“%s” % 100) print(“%s” % 3.14) # 输出100 # 输出3.14
print(“%s” % “python”) # 输出python

%s 是胜任最广泛的占位符，它可以对应任何类型的变量。
在同一个字符串可以同时使用多个占位符：

report = “%d年%s公司营收增长了百分之%.2f” % (2019, “腾讯”, 20.28)
print(report)

当我们需要在字符串输出一个百分比，就需要用到%%，比如说：

report = “%d年%s公司营收增长了%.2f%%” % (2019, “腾讯”, 20.28)
print(report)

3.1.1.2 format 函数

除了%运算符外，Python还为我们提供了字符串的format函数提供丰富的格式化。比如说，在输出一个较长的数字时，根据国际惯例，每三位用逗号分隔：

print(‘{:,}’.format(1234567890)) # 1,234,567,890

format函数也可以像%那样来格式化多个参数：

report = “{0}年{1}公司营收增长了{2}%”.format(2019, “腾讯”, 20.28)
print(report)

{0}表示第一个参数，{1}{2}表示第二、第三个参数，以此类推。这样做的好处是，如果有参数在字符串出现多次，可以不用重复的传入。

‘{0}的GDP为{1:,}…虽然它的GDP只有{1:,}美元，但它的人均GDP高达18万美元’.format(“摩纳哥”, 7100000000)

假设这个GDP数据在报告中多处被引用，万一需要修订的话，我们只需要修改一处就行了。

3.1.2 字符串的下标和切片

字符串其实也是一种序列，可以理解为一串整齐的按顺序排着队的字符，组成了字符串，那每个字符在队伍中都有自己的位置，这个位置就是下标，又叫作索引。

C	H	I	N	A
1	2	3	4	5

如上表，"CHINA"这个字符串，从左往右每一个字符对应了一个下标（索引），需要特别注意的是，在计算机编程中，所有的下标都是从0开始的，当我们要访问一个字符串的第1个字符时，使用的下标应该是0。

“CHINA”[0]

使用中括号加数字的方式，表示要访问的是具体哪个位置上的字符。

“CHINA”[1] # 第2个字符"H"
“CHINA”[4] # 第5个字符"A"

第5个字符"A"是这个字符串的最后一个，我们也可以这样来访问：

“CHINA”[-1] # 最后一个字符"A"
“CHINA”[-2] # 倒数第二个字符"N"

使用负数下标可以从右往左访问，这种写法是Python特有的，非常的快捷，对于任意长度的字符串，我们都可以使用-1来获取它的最后一个字符，注意使用负数下标是是从-1开始的，因为-0也是0，产生重复了。

切片操作也是Python的一大特色，极大简化了序列访问和操作，

“CHINA”[0:3]

上面的切片将会得到"CHI"，切片操作是以冒号隔开两个下标，冒号左边的代表开始下标，右边的代表结束下标，特别需要注意的是，结尾下标表示截取到该下标前一个位置的下标。那[0:3]，一共截取了3-0=3个字符，从0开始数，0、1、2，恰好是三个。

所以如果我们用[0:0]这种写法，将会得到一个空的字符串，

“CHINA”[0:0] “CHINA”[0:-1] # 空字符串 # CHIN

那如果想得到切片出整个字符串，可以这样写

“CHINA”[0:6] # CHINA

但一般我们都会这样写，冒号右边的省略，表示一直截取到最后一个字符。

“CHINA”[0:] # CHINA

事实上，前面的0也可以不写，冒号左边为空表示从第一个字符开始截取。

从0到末尾

“CHINA”[:] # CHINA

从0到第3个

“CHINA”[:3] # CHI

从第3个到末尾

“CHINA”[2:] # INA

如果想要隔一个字符取一个，可以这样写 # 每隔两个字符截取一个

“CHINA”[::2] # CIA

第二个冒号表示截取步长，这里的2表示每两个字符取一个，如果不传，默认就是每一个都取。步长也可以为负数，如果传递了一个负数，则表示是从右往左进行截取。

从右往左每隔两个两个字符截取一个

“CHINA”[::-2] # AIC

所以，如果想倒序输出一个字符串，可以这样写

“CHINA”[::-1] # ANIHC

3.1.3 字符串函数

字符串本身有很多函数，前面其实已经学习过一个format函数，我们再来介绍几个其他的常用函数： 3.1.3.1 去除空白字符函数

先来了解一下什么是空白字符，空白符包括空格、换行（\n）、制表符（\t）。

print(“A\tB\tC\nD\tE\tF”)

在控制台里会整齐的输出成这样：

A B C
D E F

在C后面有一个\n换行符，所以D才会显示在了第二行。而ABC、DEF之间的空白则是\t制表符造成的。 按键盘上的空格键会产生一个空格，按回车键则会产生一个换行符，按Tab键则会产生一个制表符，用户在输入数据的时候有时候经常会误输入这几个字符，所以在在处理用户输入的数据时，要先去除头尾 的空白字符。

password = “123”
input_password = " 123"
print(password == input_password)

print输出为False，由于在1前面有一个空格，导致了密码校验失败，所以必须对用户的输入先进行处理 password = “123”

input_password = " 123"
print(password == input_password.strip())

我们在input_password后面加了一个函数strip()，现在输出变成了True。strip函数的作用就是去除字符串首尾的所有空白字符。

" abc ".strip()
“\t abc \n”.strip()

得到的将是字符串"abc"，但是strip函数并不会去除掉字符串之间的空白字符

" a b c ".strip()

得到的结果是"a b c"，只去掉了首尾空白字符，保留了中间的。另外还有lstrip和rstrip函数，分别去除字符串左边和右边的空白字符。

3.1.3.2 大小写操作

这个比较简单，我们直接看代码。

将所有字符变成大写

“china”.upper()

CHINA

将字符串的首字母变成大写

“china”.capitalize()

China

将所有字符变成小写

“CHINA”.lower()

china

将每个单词的首字母变成大写

“i have a dream”.title()

I Have A Dream

3.1.3.3 字符串判断

判断字符串是否以指定的字符串开头或者结尾

函数 说明
startswith 是否以指定的字符串开头
endswith 是否以指定的字符串结尾
isdigit 是否是一串数字
islower 是否全是小写字母
isupper 是否全是大写字母

3.1.3.4 查找与替换

在前面智能密码锁的案例中，我们用过in来判断一个字符串是否被包含在另一个字符中 password = ‘123’

input_pwd = ‘456123789’

print(password in input_pwd) # True

这样可以判断出是input_pwd中是否有password，但如果想要知道password在input_pwd中的确切位置，就需要使用find函数

input_pwd.find(password) # 结果是3

结果是3。在input_pwd中寻找password，找到了，且它的出现的位置是3，也就是第4个字符。如果没有找到则会返回-1

input_pwd.find(“notexists”) # 结果是-1

除了find函数，index函数也有相同的功能，唯一的区别是 ，index函数如果没有找到相应的字符串就会报错

input_pwd.index(password) # 结果是3

这行代码将会在运行时报错 input_pwd.index(“notexists”)

count函数能够查找出指定的字符串一共出现了几次，如果没有出现，则返回0。

“abba”.count(‘a’) # 2
‘abba’.count(‘c’) # 0

replace函数提供了替换字符串中某些部分的功能

“abba”.replace(‘a’, ‘b’) # 结果是’bbbb’

‘apple banana’.replace(‘apple’, ‘orange’) # 结果是’orange banana’

3.1.3.5 字符串长度

字符串本身没有测量长度的函数，需要借助一个Python内置函数len。

len(“China”) # 5
len(“”) # 0
len(“a”) # 1

len函数非常重要，它不光可以测量字符串的长度，也可以测量其他所有有长度的对象。 r = range(10)

len® # 10

3.1.4 综合案例：异常号码数据分析

结合以上的字符操作知识，可以开发一个电话号码识别程序，用户输入一串数字，程序识别它是不是一 个有效的电话号码，如果是有效电话号码，我们再识别它是一个固定电话号码、手机号码、还是400号 码。用户输入"exit"后，程序退出。

这是一个稍微复杂的需求，在动手写代码之前，我们先分析一下需求。先列举一下常见的几种电话号码 形式，手机号码是11位的，以1开头，不同运营商的前三位不一样，由于三位太多了，我们就以前两位来判断，包括13,15,17,18,19

再看固定号码，区号+电话号码的方式，区号可能是三位（010），也可能是四位（0888），电话号码是8位，那加起来一共是11位或12位。

最是400电话，这个特征很明显，以400开头，共10位。

实现代码如下：

cellphone_number_start = “13,15,17,18,19”
telephone_number_start = “010,021,022,025,0888,0555”

while True:
num = input(“请输入一个电话号码: \n”)
if num == ‘exit’:
break
if not num:
print(“电话号码不能为空”)
num = num.strip()
if not num.isdigit():
print(“您输入的是一个无效电话号码”)
continue

if num.startswith(‘1’) and len(num) == 11 and num[0:2] in cellphone_number_start:
print(“这是一个手机号码”)
continue
elif num.startswith(‘400’) and len(num) == 10:
print(“这是一个广告电话”)
continue
elif num.startswith(“0”): # 当代码太长时，可以用反斜杠分割成多行。
if (len(num) == 12 and num[0:4] in telephone_number_start) or
(len(num) == 11 and num[0:3] in telephone_number_start):
print(“这是一个固定电话”)
continue

print(“无法识别该号码”)

第二节 元组 tuple

3.2.1 定义元组

现在我们知道了字符串是一种序列，它可以迭代循环，也可以按索引访问，也可以切片访问。但它的成员只能是单个的字符，现在来介绍一种更多元化的序列：元组，英文叫tuple，可这样来定义一个元组：

t = (‘My’, ‘age’, ‘is’, 18)

在这个元组中包含了3个字符串，一个整形数字，元组中的每一项称作元素，4个元素按照从左到右的顺序排列。可以用下标索引访问：

t[0] # ‘my’
t[-1] # 18

也可以通过切片来访问，注意切片返回的是一个包含切片片段的新元组。

t[0:2] # (‘My’, ‘age’)

事实上元组定义的时候也可以不用括号

t = ‘My’, ‘age’, ‘is’, 18

但当，元组中只有一个元素的时候，必须要加一个逗号：

t = (‘solo’,）

或者不带括号

t = ‘solo’,

可以将一个序列强制转换为元组

tuple(‘abc’) # (‘a’, ‘b’, ‘c’)

tuple(range(5)) # (0, 1, 2, 3, 4)

后面的逗号表明这是一个元组，否则就会被认为是一个字符串。

3.2.2 元组操作

现在我们介绍字符串的另一个函数join，有了它，可以把元组这样的序列拼接成一个整体的字符串。

注意最后一个元素

t = (‘My’, ‘age’, ‘is’, “18”)
print(" ".join(t)) # 输出结果：‘My age is 18’

注意最后一个元素，这次我们将它设置成了字符串，因为join函数要求参数序列中的每一个元素都必须是字符串。

和字符串一样，元组也有count, index函数，使用的方法也是一样：

t = (‘a’, ‘b’, ‘b’, ‘a’)

t.count(‘a’) # 2
t.index(‘b’) # 1
t.index(‘c’) # Error

查看长度

len(t) # 4

元组也支持 in 操作，想要判断元组中是否包含某个元素：

‘a’ in t # True

‘x’ in t # False

最后，需要记住的是元组和字符串都是只读的，也就是不可修改的。我们不能单独改变元组中的某个元素，或者是字符串中的某个字符。

3.2.3 遍历元组

元组属于序列，所以可以像字符串那样去遍历它：

lst = (‘a’, ‘b’, ‘c’, ‘d’, ‘e’)

for i in lst:
print(i)

使用for循环可以方便快捷的遍历元组，上面的例子将打印出元组中的每一个元素。也可以使用while来遍历元组，虽然并不经常这样使用。

lst = list(range(10))
i = 0

while i < 10:
print(lst[i])
i += 1

3.2.4 综合案例：销售数据统计-销冠

在真实的项目中，数据结构通常是比较复杂，经常碰到嵌套的元组，甚至是多层嵌套，我们来看一个例 子：

当元组元素较多、较长时，可以这样书写

sales = ((“Peter”, (78, 70, 65)), (“John”, (88, 80, 85)), (“Tony”, (90, 99, 95)), (“Henry”, (80, 70, 55)), (“Mike”, (95, 90, 95)))

这是包含某公司所有销售人员第一季度销售业绩的元组，单位是万元，其中的每一个元素对应一个销售人员的信息，人员信息也是一个元组，包括姓名和业绩，业绩又是一个元组，按照顺序分别是1、2、3 月份的销售额。需求：找出总销售额最高的那个员工，并将TA的名字和总销售额输出。

champion = ‘’
max_amount = 0

for sale in sales:
name = sale[0]
quarter_amount = sale[1]
total_amount = 0
for month_amount in quarter_amount:
total_amount += month_amount

if total_amount > max_amount:
max_amount = total_amount
champion = name

print(“第一季度的销冠是%s, TA的总销售额是%d万元” % (champion, max_amount))

上面的代码也可进一步优化一下，使得代码行数更少，结构更简单。

champion = ‘’
max_amount = 0

for name, quarter_amount in sales:
total_amount = sum(quarter_amount)

if total_amount > max_amount:
champion, max_amount = name, total_amount

print(“第一季度的销冠是%s, TA的总销售额是%d万元” % (champion, max_amount))

这里用到了一个sum函数，它是Python内置函数，可以计算出一个序列里所有数值的总和。

第三节 列表 list

3.3.1 定义列表

列表可以理解为可变的元组，它的使用方式跟元组差不多，区别就是列表可以动态的增加、修改、删除元素。

看一下列表的定义：

定义一个空列表

lst = []
lst = list()

定义带有初始值的列表

lst = [1, 2, 3]
lst = [“a”, 1, 2, 3, “b”, “c”]
lst = list(range(5))
lst = list(“abc”)
lst = list((1, 2, 3))

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Python开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024c （备注Python）

（1）Python所有方向的学习路线（新版）

这是我花了几天的时间去把Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

最近我才对这些路线做了一下新的更新，知识体系更全面了。

（2）Python学习视频

包含了Python入门、爬虫、数据分析和web开发的学习视频，总共100多个，虽然没有那么全面，但是对于入门来说是没问题的，学完这些之后，你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。

（3）100多个练手项目

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了，只是里面的项目比较多，水平也是参差不齐，大家可以挑自己能做的项目去练练。

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

：

定义一个空列表

lst = []
lst = list()

定义带有初始值的列表

lst = [1, 2, 3]
lst = [“a”, 1, 2, 3, “b”, “c”]
lst = list(range(5))
lst = list(“abc”)
lst = list((1, 2, 3))

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-5iPACopx-1712562315052)]
[外链图片转存中…(img-E9YlSFyj-1712562315052)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Python开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024c （备注Python）
[外链图片转存中…(img-lkuraWuP-1712562315053)]

（1）Python所有方向的学习路线（新版）

这是我花了几天的时间去把Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

最近我才对这些路线做了一下新的更新，知识体系更全面了。

（2）Python学习视频

包含了Python入门、爬虫、数据分析和web开发的学习视频，总共100多个，虽然没有那么全面，但是对于入门来说是没问题的，学完这些之后，你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。

（3）100多个练手项目

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了，只是里面的项目比较多，水平也是参差不齐，大家可以挑自己能做的项目去练练。

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-8wPmBtju-1712562315053)]