Python基础

Python入门

第零章：引言

0.1 引言

本书旨在教育，帮助人基础的入门Python，在这本书不会扯什么高大上的词汇，用尽量懂的语言让你听懂，所以这本书是以最浅显的话揭示高深的内涵。

我为什么会选择Python？我一直认为Python是一个很成功的高级语言，它庞大的生态体系，简单的语法不是其它编程语言可以比拟的，要说Python唯几的缺点就是运行速度慢，和打包后体型较大，但是新手一定要首选Python，不要听网上人说要选C语言和C++，先学习C/C++.可能会放弃，甚至断绝兴趣，而且Python就业方向是很多的，现在的很火的AI就是由Python训练的。

咱们不说废话，以精简的语言快速速通Python入门，全篇加上引言，目录等约2万字左右。

本书Python版本以3.13.2为例。

　　　　　　　　　　　 2025年8月14日
　　　　　　　　　　　　　　　编者

第一章：输入输出

1.1 引言

你会在网上常常看到类似视频：

一个人在视频中用任意一个编程语言编写打印Hello World!的代码，然后把代码慢慢删掉，之后卡点一些写LeetCode的题目，或者一些代码之类的，文案通常配上“梦开始的地方”或者“故事的开头总是极具温柔”。
你现在看这本书，也肯定是羡慕他们会使用代码，看起来很酷的样子。

你首选Python是一个不二之选，这个编程语言较为简单，所以让我们开启这段学习Python的旅程吧。

首先先学习输入输出吧。

1.2 输出

我们刚刚说了有人会使用任意编程语言打印Hello World!，事实上这是我们编程里面公认的最简单代码，那我们就先从这里开始学吧。

#例1.1
print("Hello World!")

#后的不用管，如果你用Python解释器（Python如何下载看附录19.1）运行这段代码，你会看到输出：

Hello World!

由此我们能知道print是打印作用，""里就是打印内容。

当然我们可以把""换成''，这样也能运行，因为""几乎等价''。

1.3 输入

在编程里，除了输出还有一件重要事——输入，为什么呢？像别人要帮助你完成一些需求，你总归得把需求告诉他，他才能帮你完成，或者更直观的，程序本来有一段能实现整数数字转二进制的，你想要看看2的二进制是多少，如果没有输入，你就得把这个文件打开，把里面代码修改才行，为了简化此过程，发明了输入，这时，你只要在程序停的地方输入2即可看到2的二进制，同时一般来说要输入的地方会有输入的提示。

从本小段你可以认识到如何输出。

#例1.2
input()

这是一段最简单的输入代码，如果你运行，可以输出如下：

对就是无输出，然后你往里面输入一个1试试呢？那么输出就是：

然后，你按回车键即可结束程序。
正如我之前所言，你不给个输入提示，用户又不是开发者，ta哪里知道要什么时候输入，所以我们可以制作一个输入提示：

#例1.3
input("输入一个数字：")

此时运行，输出如下：

输入一个数字：

此时，输入一个1，输出如下：

输入一个数字：1

回车键即可取消运行。

1.4 end参数

事实上，print()里面还可以写一个end=参数，这是常见的好用的参数。

在这之前，我们先学习一下制表符。

制表符你不需要理解太多，在基础中你只要知道以下即可：

制表符	作用
\n	换行
\t	对齐

如果end参数没写，默认是\n，如果写end参数，但没写是什么制表符，那么后面的输出会在前一个输出的后面，我们来演示一下：

#例1.4
print("Hello ",end="")
print("World",end="")
print("!")

输出：

Hello World!

如果你还想要知道其它参数，你可以自己上网查阅相关资料。

1.5 程序设计

【例题1.1】：

题目描述：输入一段话，打印这段话。

输入格式：任意一段话。

输出格式：这一段话。

样例输入 #1

Hello World!
Hello World!

样例输出 #1

Hello World!

样例输入 #2

你好世界!

样例输出 #2

你好世界!

分析：
我们现在知道了input()是接收用户输入的东西，而print()是打印一段东西，那么我们可以结合一下使用：

#例1.5
print(input())

这段程序会优先执行input()，让用户输入，然后打印用户输入的，输出如下：

Hello World!
Hello World!

你好世界!
你好世界!

【例题1.2】：

题目描述：输入一段话，打印这段话，并与输入的话在一行。

输入格式：任意一段话。

输出格式：一行这一段话的两次。

样例输入 #1

Hello World!

样例输出 #1

Hello World!Hello World!

分析：

我们学习了end参数，如果里面只填写""，那么便可以不用换行，在一行，直接用end参数即可，代码如下：

#例1.6
print(input(),end="")

输出：

HelloWorld!HelloWorld!

第二章：注释

2.1 引言

在之前很多代码中，我都使用过一个#，我最早在例1.1中使用，当时，我说你不用管，你现在一定很疑惑吧，现在让我们来学习注释。

2.2 注释基础概念

注释就是一段代码的解释，在一段难懂的代码或者一个个变量需要注释，这里来演示一下：

#例2.1
print("Hello")  # 打印Hello

2.3 单行注释和多行注释

我们刚才所接触的注释就是单行注释，这种注释标准注释为：

在一段代码后面加注释，标准规范是：空两格加#空格加注释内容，如果注释前面没有代码，直接在开头加上#再空格再加上注释内容。

那什么是多行注释？

多行注释一般只会出现在空白区域，不会出现在代码后面，例如：

#例2.2
"""
打印Hello
"""
print("Hello")

第三章：docstring

3.1 引言

对于模块等结构或者什么，我们并不知道它们做什么，此时就是docstring的发扬时刻，那么该章节我们就来基础理解docstring吧。

3.2 什么是docstring

简单来说，就像你玩游戏或者使用一款产品，你并不知道该咋做，所以，你玩游戏就需要上网查指南，或者跟着新手教程做，使用一款产品你得看自带的说明书。
那么，docstring就是一个模块，一段程序在做什么，能干什么，需要怎么样，通常用一对三引号包裹，即"""内容"""。

3.3 获得docstring方法

获取docstring有两种方法，__doc__方法和help()方法，且看第一种方法。
一般来说第一种方法的格式为：东西. __doc__，例如：

#例3.1
print(print.__doc__)

输出：

Prints the values to a stream, or to sys.stdout by default.

  sep
    string inserted between values, default a space.
  end
    string appended after the last value, default a newline.
  file
    a file-like object (stream); defaults to the current sys.stdout.
  flush
    whether to forcibly flush the stream.

正如这些所说，sep，end，file，flush是print都所有参数，对于基础只要记住end参数即可。

第二种方法，help()，一般来说格式为：help(东西)，例如：

#例3.2
print(help(input))

输出：

Help on built-in function input in module bui
ltins:

input(prompt='', /)
    Read a string from standard input.  The t
railing newline is stripped.

    The prompt string, if given, is printed t
o standard output without a
    trailing newline before reading input.

    If the user hits EOF (*nix: Ctrl-D, Windo
ws: Ctrl-Z+Return), raise EOFError.
    On *nix systems, readline is used if avai
lable.

None

如果你有兴趣看的话，你用help()和__doc__输出同一个东西，两次是不一样的，我们常用__doc__进行。

第四章：变量

4.1 引言

我们生活中有很多东西来存储东西，像盒子，盒子能摆放很多能放的进去的东西，也有比较小的，只能摆放一个，今天我们来学习比较小的盒子——变量。

4.2 基础理解变量

正如引言所说，变量就是一个很小的盒子，只能摆放一个东西，但是这种盒子上限很高，下限也挺低，小到只能装一个灰尘，大到能装一个宇宙，只要这只是一个。

但是呢，变量与盒子有很大不同，变量只能存储数据，盒子只能存储现实物品，那么让我们一起看看变量如何操作吧。

4.3 定义变量

现在，先让我们学习最基础的定义变量吧。
我们先学习一个符号=，这是赋值符号，将符号右边的赋值到符号左边，现在知道这个，我们就开始定义一个变量吧：

#例4.1
a=1
print(a)

在第二行，我们定义了变量a，并赋值为1，第三行的作用打印a，由此所见，print()里不止可以写表达式，也可以写变量，也可以写""里的内容。

当然，变量不止能定义数字，还可以：

#例4.2
a="123"
print(a)

变量也可以定义为""里的东西。

事实上，由""，''，""""""包裹起来的，我们统称为字符串，以后我们会详细讲解。

现在，命名变量有一些规则，可以看看：

1.变量只能包含字母，数字，下划线（_）。

2.变量开头不能是数字。

3.变量不能是关键字，即内置函数。（能定义但是会丧失原本的功能）

此外，变量会被覆盖，例如：

#例4.3
a=1
print(a)
a=2
print(a)
a="i"
print(a)

输出：

1
2
i

4.4 变量的数据类型

除了整形数字和字符串，我们还可以有什么能定义变量，学到现在，我还可以告诉你还能定义一个，浮点数。

浮点数，比较简单，浮点数说白了就是小数，定义浮点数方法参考如下：

#例4.4
a=0.1

需要注意一个问题，浮点数精度问题，举个简单的例子：0.1+0.2不等于0.3，解决问题以后会讲解。

4.5 数据连接

数据连接也叫字符串格式化，字符串格式化有三种方法：f-string，format，+，%，我们慢慢讲。

f-string：现在很流行的做法，支持3.6及以上，可以用{}在里面加入表达式变量，来实现字符串格式化，效率高，简单，例如：

#例4.5
a = 5
b = "小明"
print(f"{b}今年{a}岁了。")

输出：

小明今年5岁了。

format：现在和以前都很流行的做法，支持2.6及以上通过{}占位来实现字符串格式化操作，效率高，复杂，功能丰富，例如：

#例4.6
print("{ }今年{ }岁了。".format("小明",5))
#按照默认顺序输出

输出：

小明今年5岁了。

或者代码这样写：

#例4.7
print("{name}今年{age}岁了。".format(name="小明",age=5))
#关键字输出

输出：

小明今年5岁了。

代码也可以这样写：

#例4.8
print("{1}今年{0}岁了。".format(5,"小明"))
#通过位置输出

除此以外format还支持数字格式化，进制转换，转移大括号，有兴趣的可以去查一下。

+拼接：仅限同类型，几乎支持所有版本，现在不流行，效率低，例如：

#例4.9
print("3"+"2"+"1")

输出：

如果这样写：

#例4.10
print("3"+"2"+1)

这样写会抛出一个TypeError，有局限性。

%格式化：这个有严重的bug，官方文档也说了不建议使用这个，现在已经弃用了，想要知道的，自己可以查一下，这里不过多解释。

4.6 程序设计

【例题4.1】：

题目描述：

输入一个字符串，在后面分别拼接+1和+2，并换行输出。

输入格式：

输入一个字符串。

输出格式：

共两行，分别表示拼接+1，拼接+2。

样例输入 #1

样例输出 #1

5+1
5+2

样例输入 #2

样例输出 #2

p+1
p+2

分析：

这题要输出两行，而且需要输入，就没办法使用两个input来输出了，这样会造成两个输入，我们可以用刚刚学习的变量，字符串格式化使用f-string即可，代码如下：

#例4.11
a=input()
print(f"{a}+1")
print(f"{a}+2")

输出：

5+1
5+2

p+1
p+2

第五章：数据类型转换

5.1 引言

我们现在学习了很多数据类型，那么我们该如何进行互转呢，今天我们来学习数据类型互转。

5.2 字符串整数互转

字符串我们常常称为string，整数被称为int。

那么，标题简化便是"int string互转"，同时string简称str，所以还可以简化为"int str互转"。

OK，那么我们开始吧。

现在，int->str就是str函数，我们来使用一下：

#例5.1
print(str(5))

输出：

之所以这是5，看起来像int，事实上，我们用str()转成了str，所以输出的其实是str。

之后我们来看看str->int，同样是int函数，我们来看看代码：

#例5.2
print(int("5"))

输出：

这个5看起来像int，事实上真是int。

5.3 整数，字符串转布尔

我们先认识一下什么是布尔吧，布尔只有两个值，我们叫它们True和False，用数字表示分别是1和0，布尔我们常用bool来代替。

现在，我们可以用bool函数将值改为bool，这个值可以是字符串，数字，表达式。

我们来记下几个特殊的：

如果值是数字，且为0，那么布尔值为False，如果非0，布尔值为True。

如果值是字符串，如果不为空，布尔值为True，如果是空的，那么为False。

值是空白，默认是False

OK，我们分别试一下，代码如下：

#例5.3
print(bool(1))
print(bool(0))
print(bool("0"))
print(bool(""))
print(bool())

输出

True
False
True
False
False

5.4 认识进制

在我们生活中有很多的进制存在，在电脑中常用的进制有十进制，二进制，八进制，十六进制，我们常用的是十进制，也就是逢十进一，所以二进制就是逢二进一，其实我们还有很多进制，例如：26进制，32进制，36进制，52进制，56进制，62进制等等。

我们来基础的看一下二进制，八进制，十进制，十六进制的区别（以十进制10为例）：

进制	值
二进制	1010
八进制	12
十进制	10
十六进制	a

5.5 认识进制函数

我们常用的进制函数仅有二进制，八进制，十进制，十六进制。

以下是对应的进制与函数：

十进制 -> int()
八进制 -> oct()
十六进制 -> hex()
二进制 -> bin()

5.6 进制互转

我们需要知道如下：

int只接受字符串，因为二进制不是数字，八进制和十六进制会出现非数字字符，通常的格式为：

int(字符串，进制)

其中进制只填写数字，也就是填：2，8，16。

oct，hex，bin只接受数字，也就是只接受十进制，它们的格式分别为：

oct(十进制值)
hex(十进制值)
bin(十进制值)

例如：

#例5.4
print(int("1010",2))
print(int("a",16))
print(int("12",8))
print(bin(10))
print(hex(10))
print(oct(10))

输出：

其中0b代表二进制，0x代表十六进制，0o代表八进制，通常只看后面的。

5.7 程序设计

【例题5.1】

阅读如下代码，会输出什么：

print(bool(0))
print(bool(""))
print(bool(0.0))

分析：我们之前说过，用bool函数判断0和空字符串会返回一个False，0.0也是0，所以也是False，所以答案为：

False
False
False

嗯，都是False。

【例题5.2】

题目描述：

输入一个数字，把它加上5。

输入格式：

一行，一个数字。

输出格式：

一行，一个数字，代表输入的数字加上5。

样例输入 #1

样例输出 #1

样例输入 #2

-5

样例输出 #2

分析：当我们输入任何东西时，哪怕是一段数字，也是字符串，既然题目说输入数字，那么我们只需要当它是数字就行。我们可以用int函数把string变成int，然后加上5即可，代码如下：

#例5.5
print(int(input())+5)

输出：

【例题5.3】

题目描述：

输入一个十进制，把它转成二进制。

输入格式：

一行，一个十进制。

输出格式：

一行，一个二进制，代表输入的二进制。

样例输入 #1

样例输出 #1

0b10

样例输入 #2

样例输出 #2

0b1010

分析：我们刚刚学到可以用bin函数接收十进制数字并转化成二进制，我们也要使用刚刚也用过的int函数转成数字才可以使用，代码如下：

#例5.6
print(bin(int(input())))

输出：

0b10

0b1010

【例题5.4】

题目描述：

输入一个二进制，并转化成十六进制。

输入格式：

一行，一段二进制。

输出格式：

一段十六进制，表示这段二进制的十六进制。

样例输入 #1

样例输出 #1

0xa

分析：我们没有函数可以把二进制转化成十六进制的，但是我们可以先把二进制转化成十进制再转成十六进制即可，由于有点儿多，我们可以使用变量来存储，代码如下：

#例5.7
a = int(input(),2)
print(hex(a))

输出：

0xa

或者你比较头铁非要写在一行写，也可以这样：

#例5.8
print(hex(int(int(input(),2))))

输出：

0xa

但是这样可读性较差，我们以可读性作为首位，这也是便于后续人员进行维护。

第六章：结构

6.1 引言

我们生活中经常进行判断，循环等操作，这些都是结构，结构大致分两种，一是顺序结构，二是嵌套结构，顺序结构就是多个语句并列在一起，嵌套结构就是语句中还有语句，让我们在今天开始学习结构吧。

6.2 for语句

什么是for语句？很简单就是6.1引言中提到的循环，当然for还有其他用处，这章只教循环。
for循环的基本语法是这样的：

for 循环变量 in range(次数):
　　循环体
并列代码

我们来慢慢理解。

循环变量就是在这个循环中的变量，每次循环，循环变量都会增加1，且可以被调用。

循环体就是你要写的代码，我们叫它下级代码，下级代码通常会执行“次数”次。

此外，如果执行完后会执行并列代码。

例如：

#例6.1
for i in range(5):
　　print("1")

这段代码会打印5次“1”，来看输出：

需要注意的是，循环变量默认是从0开始的，而循环变量只会到“次数”-1的时候，而且每次只会增加一个，要想改变只能增加起始值，终止值，步长，所以for循环的语法是：

for 循环变量 in range(起始值，终止值，步长):
　　循环体

我们也来慢慢理解。

起始值就是最开始的值，终止值就是结束的值，但循环变量只能循环到终止值-1，步长就是每次改变循环变量的方式。

需要注意的是，起始值和步长可以不要，但终止值一定要有，平常就随便填一个数字也是终止值，例如：例6.1括号中的5就是终止值。

其余基本一样。

来看一段代码：

#例6.2
for i in range(1,11):
    print(i)

这个代码的作用是打印出来1到10，来看输出：

如果我们加上步长呢？如这段代码：

#例6.3
for i in range(2,101,3):
　　print(i)

输出：

由输出可得知，for循环循环时优先执行判断，如果加上3大于100，那么就不执行了。

另外，我们还有两个专门为循环而生的函数：
continue函数与break函数。让我们分别看一下这些功能吧：

continue: 跳过该循环，continue执行后直接进入下次循环。
break：跳出该循环，break执行后不执行循环了，直接继续执行与for语句并列的代码。

我们来举个例子吧：

#例6.4
for i in range(10):
    print(1)
    break
    print(2)
print()
for i in range(10):
    print(1)
    continue
    print(2)

输出：

代码第六行用\n做了个隔断，让我们来看看吧：

break：输出完1后直接没了，然后执行第六行和下一个for循环，且不输出2。
continue：输出完1后继续输出1，直到输出了10次。
break与continue的共同点：
- 第一个：执行完continue或者break后，剩余的下级代码就不输出了，要么跳过循环，要么跳出循环。
- 第二个：只能在循环中使用。
  
  6.3 if语句
  
  同时，我们还说过会判断，判断我们常用的是if语句，if语句的格式通常为：
```
if 条件:
下级代码
并列代码
```
  条件如果为真（True），就执行下级代码，如果为假（False）那么执行并列代码。

例如：

#例6.5
a=1
if a==2:
    print(1)
if a==1:
    print(2)
print(3)

这段代码的意思是判断a，a是2输出1，a是1输出2，然后输出3。

输出如下：

2
3

因为第二个if语句为真所以执行输出2，之后输出3是无论什么都输出3。

同时我们由if又拓展出了if…elif，if…elif…else，if…else，if…elif…elif……else这几个语句，我们慢慢来。

if是必须执行的，如果if的条件不成立那么执行elif，elif的条件还不成立，那么执行下一个elif，如果所有的elif和if都不成立，那么执行else。

所以格式通常为：

if 条件：
    代码
elif 条件：
    代码
…
else:
    代码

现在来讲讲if…elif和if……if的区别：

if…elif：若if成立，elif不判断，若if不成立，elif判断。
if……if：无论第一个if成立不成立，第二个if都会判断。

以后会学到更高效，简单的写法——match-case写法，但match-case不是万能的，有时还会更复杂。

我们刚刚使用过==符号，这属于逻辑运算符，其它的逻辑运算符还有：

==
>
<
>=
>=
!=

每个的意思是：

是否相等
是否大于
是否小于
是否大于等于
是否小于等于
是否不等于

那么，我现在有两个条件，要两个条件都成立才能执行下级代码，该怎么办呢？可以这样：

if 条件1:
    if 条件2:
        下级代码

如果我现在有两个条件，两个条件任意之一成立就能执行下级代码，该怎么办呢？可以这样：

if 条件1:
    下级代码
if 条件2:
    下级代码

这样未免过于复杂，相同代码要写两遍，可能还要进行其他的，其实两个都可以简化，先看第一个简化：

if 条件1 and 条件2:
    下级代码

由此可见，and是判断条件1和条件2是否成立，都成立才成立，例如：

#例6.6
print(1==2 and 1==1)
print(2==2 and 1==1)

输出：

False
True

来看第二段代码的简化：

if 条件1 or 条件2:
    下级代码

由此可见，or就是判断条件1和条件2是否有至少一个条件成立，只要有成立的就成立了，例如：

#例6.7
print(1==1 or 2==1)
print(1==2 or 2==1)
print(1==1 or 2==2)

输出：

True
False
True

还有内容会在后面讲。

6.4 while语句

while语句也是循环的一种，但不同于for循环，while语句的格式通常为：

while 条件:
    下级代码

当条件成立时，执行下级代码，注意，while语句没有循环变量。

当条件里填True时，那么下级代码会一直执行，为了防止这样发生，你得在下级代码里设置一个break才行，反之填False时，while语句永远不会执行。

来看几个例子：

#例6.8
i=1
while i==1:
    print(1)
    break

输出：

#例6.9
i=1
while i==1:
    i=2
print(i)

输出：

#例6.10
while True:
    print(1)

输出：

省略号代表省略无数个1，所以执行while True时，得设置一个break，我们常用if进行判断，然后设置break，这会在以后讲解，我们俗称“嵌套结构”。

6.5 嵌套结构

刚才，我提到了“嵌套结构”，现在就来学习一下。

紧接上回，在执行while True时得设置一个break，通常用if判断，例如：

#例6.11
i=1
while True:
     print(i)
     if i==2:
         break
     i=2

输出：

1
2

为什么会输出1，2呢？因为if语句没有放到首位，如果放到首位会先执行if判断，但这里没有，会执行print，可以参考这个表：

第几次	发生了什么事情
第一次	打印i if判断不成立
第二次	打印i if判断成立跳出循环

在嵌套结构和for循环中，有一个很重要的算法思想是“枚举”，也称作“穷举”，这会在以后学完其它数据类型后会讲解。

6.6 match-case结构

Python中的match-case结构类似于C++里的switch-case结构，但是match-case比其它类似结构能做的要多的多，这个小结只教基础。

match-case的格式基本如下：

match 变量:
    case 值1:
        代码块
    case 值2:
        代码块
    case _:
        代码块

其中case _代表之前的值都不对应时执行，例如：

#例6.12
a=1
match a:
    case 1:
        print(1)
    case 2:
        print(2)
    case _:
        print("other")

输出：

如果a是2，那么打印2，如果是3，那么打印other，如果换成if…elif…else语句是这样的：

#例6.13
a=1
if a==1:
    print(1)
elif a==2:
    print(2)
else:
    print("other")

输出：

但是，match-case运用得当，比if语句更高效更简单。

这个小结就教这么多，后续其它方法会在以后讲解。

6.7 程序设计

【例题6.1】

阅读下面代码，会输出什么：

for i in range(10):
    if i==5:
        print(2)
        continue
    print(1)

分析：这段代码是嵌套结构，每次循环会判断循环变量i是否是5，是打印2，然后继续下一次循环，需要注意的是i是从0开始的，i=5时是在第六行，所以答案如下：

【例题6.2】

将如下if语句转为非if语句：

a=5
if a==0:
    print("zero")
else:
    print("not zero")

分析：我们可以将这个if语句转成match-case结构，代码如下：

#例6.14
a=5
match a:
    case 0:
        print("zero")
    case _:
        print("not zero")

输出应该是：

not zero

【例题6.3】

题目描述：

输入一个整数a，再输入一个整数b，判断a是否比b大，是输出yes，不是输出no。

输入格式：

两行，一行一个数字，分别表示a和b

输出格式：

一行，表示a是否比b大

样例输入 #1

10
2

样例输出 #1

no

样例输入 #2

50
10

样例输出 #2

yes

分析：我们可以分别定义两个变量来存储a和b，然后用if语句判断，代码如下：

#例6.14
a=int(input())
b=int(input())
if a>b:
    print("yes")
else:
    print("no")

我们还能简化例6.14，如：

#例6.15
if int(input()) > int(input()):
    print("yes")
else:
    print("no")

与例1.5一样，这段代码会优先执行input()，然后用int()转成整数形式，之后才会进行判断，输出。

【例题6.3】

题目描述：

分别输入两个数字，找出较大的数，输出较大的数字，若一样输出一样的数字。

输入格式：

一共两行，一行一个，分别表示两个数字。

输出格式：

一行，表示较大是数字。

输入样例 #1

123
56

输出样例 #1

输入样例 #2

5
5

输出样例 #2

分析：这题很明显是要用if语句进行判断，代码如下：

#例6.16
a=int(input())
b=int(input())
if a>b:
    print(a)
else:
    print(b)  # 如果一样，输出b也可以

输出：

当然，我们还有更简单的写法：

#例6.17
print(max(int(input()),int(input())))

max()函数是对括号里的参数进行一个比较并返回一个最大的数字，参数可以是无限的，所以我们也可以把参数改为3个，甚至更多。

第七章：运算符

7.1 引言

在我们生活中，时常会进行很多计算，如：加减乘除，幂运算等等。今天我们来学习运算符。

7.2 运算符的种类

在Python中有很多运算符，我们大致可以分为以下几类：

运算符种类	一些符号
1.算术运算符	+-/*%//
2.比较运算符(逻辑运算符)	><==…
3.布尔运算符	and or not
4.位运算符	& >><<…

现在只需要知道1，2，3即可。

首先，第一个是我们平常的运算，分别是：

名称	作用	示例
+	加	1+2=3
-	减	15-2=13
*	乘	3*21=63
/	除	10/2=5
**	幂运算	5**2=25
％	取余	5%2=1

然后是比较运算符，有时也称作逻辑运算符，基础只要学会如下：

名称	作用
>=	判断是否大于等于
>	判断是否大于
＜和≤	也是同理
!=	判断是否不等于
==	判断是否等于

以及布尔运算符只需要暂时学习and和not即可，功能可以参考下表。

名称	作用	示例
and	两个或者多个条件是否都是True	1==1 and 2==2为True，1==1 and 2==1为False，1==2 and 2==1为False
or	两个或者多个条件是否只有一个条件为True	1==1 or 2==2为True，1==1 or 2==1为True，2==1 or 1==2为False

对于优先级，你可以参考如下（从高到低）：

名称	成员（部分）
括号	()，注意[]等不算，这有其他用处
幂运算	**
乘，除，取模，整除	*/%//
加，减	+-
比较运算符	><==……
逻辑与	and
逻辑或	or(优先级最低)

对于这些，你可以记住一个口诀：

先括号，再计算，后比较，逻辑啥的不重要。

注意，逻辑真的不是不重要的。

7.3 程序设计

【例题7.1】

题目描述：

输入一个整数n，判断是否是3的倍数，是输出"Yes"，反之输出"No"。

输入格式：

共一行，第一行是一个数字，表述整数n。

输出格式：

共一行，表示是否是3的倍数。

输入样例 #1

输出样例 #1

Yes

输入样例 #2

输出样例 #2

No

分析：我们用取余与之前学习的if语句结合进行判断，然后用比较运算符的==，来看代码：

#例7.1
a=int(input())
if a%3==0:
    print("Yes")
else:
    print("No")

输出：

Yes

No

也可以简化例7.1，来看代码：

#例7.2
if int(input()) % 3 == 0:
    print("Yes")
else:
    print("No")

【例题7.2】

题目描述：

输入一个整数n，如果n的两倍是5的倍数，是输出"yes"，反之输出"no"。

输入格式：

共一行，表示整数n。

输出格式：

共一行，第一行输出"yes"或者"no"，表示是否合法。

输入样例 #1

输出样例 #1

yes

输入样例 #2

输出样例 #2

no

分析：这题可以用*乘，再判断，来看代码：

#例7.3
a=int(input())*2
if a%5==0:
    print("yes")
else:
    print("no")

输出：

yes

no

其实，这道题有一个致命漏洞，我们可以直接接受，不用乘2，是5的倍数的数字乘2还是5的倍数，因为这是个公倍数，一定能被5除，所以我们稍微简化下可以这样：

#例7.4
if int(input()) % 5 == 0:
    print("yes")
else:
    print("no")

输出：

yes

no

输出也是一样的。

【例题7.3】

题目描述：

输入一个整数n，输出 $2n-1$ 的结果。

输入格式：

共一行，第一行一个数字，表示整数n。

输出格式：

共一行，第一行一个数字，表示结果。

输入样例 #1

输出样例 #1

分析：这题考验你是否能读懂题目，要是读懂了就很简单了，我们用*和-来进行运算，代码如下：

#例7.5
print(int(input())*2-1)

输出：

第八章：字符串

8.1 引言

我们在第二章变量中就略微提过字符串，并说过会在以后详细讲解，现在来了，让我们一起走进字符串的学习。

8.2 字符串

字符串通常由英文的双引号表示，比如：""，''，""""""或''''''这些基础知识我们在之前基本都讲过了，我也不在这赘述。

字符串每个由字符组成，字符通常是一个，例如：

"123"

其中，1是字符，2是字符，3是字符。

就这样。

8.3 遍历字符串

这是基本的操作，在以后学习列表也是。

字符串的遍历我们常使用for循环，不过时一种更简单的方式，来看代码：

#例8.1
for i in "123":
    print(i)

输出：

1
2
3

因为i为"123"里的第i个元素，也就是第一次执行时，i为"123"里的第一个元素，即"1"，第二次执行时是"123"里的第二个元素，即"2"，第三次执行时是"123"里的第三个元素，即"3"。

例如例8.1类似的还有其它很多。

8.4 输出改变后的字符串字符

我们用刚刚使用的方法，例如：

#例8.2
a = "123"
for i in a:
    print(str(int(i)+1))

输出：

2
3
4

或者说，这样写：

#例8.3
a = "123"
for i in range(3):
    print(str(int(a[i])+1))

输出也是：

2
3
4

如你所见，我们使用了a[i]，我们管这个叫做下标，下标不止字符串，还可以作用在列表等数据结构上，我们可以在以后中学到。

8.5 字符串切片

看到这个标题应该很蒙吧，什么是切片，直观来讲，就是简便的输出某个部分，常用的是下标。来看示例：

#例8.4
a = '123'
print(a[:2])
print(a[1:])
print(a[1:2])
print(a[1:-1])

输出：

'1'
'23'
'2'
'2'

所以，我们可以知道：

:N: 表示前N位。
N:: 表示后N位。
N1:N2：表示N1到N2位，其中通常N2不被获取值。
-1：表示最后一位，大部分的存储方式都支持。

那么，下面这段代码会输出什么？

#例8.5
a = 'Hello World'
print(a[0:-1])

根据刚刚学过的切片，可以知道这段代码的意思是Hello World的除最后一位以外的所有字符，输出：

Hello Worl

8.6程序设计

【例题8.1】

Python入门

目录

第零章：引言

第一章：输入输出

第二章：注释

第三章：docstring

第四章：变量

第五章：数据类型转换

第六章：结构

第七章：运算符

第八章：字符串

第九章：列表

第十章：字典

第十一章：元组

第十二章：集合

第十三章：函数

第十四章：文件操作

第十五章：异常处理

第十六章：基础类

第十七章：模块和包

第十八章：Python虚拟环境

附录

第零章：引言

0.1 引言

第一章：输入输出

1.1 引言

1.2 输出

1.3 输入

1.4 end参数

1.5 程序设计

第二章：注释

2.1 引言

2.2 注释基础概念

2.3 单行注释和多行注释

第三章：docstring

3.1 引言

3.2 什么是docstring

3.3 获得docstring方法

第四章：变量

4.1 引言

4.2 基础理解变量

4.3 定义变量

4.4 变量的数据类型

4.5 数据连接

4.6 程序设计

第五章：数据类型转换

5.1 引言

5.2 字符串整数互转

5.3 整数，字符串转布尔

5.4 认识进制

5.5 认识进制函数

5.6 进制互转

5.7 程序设计

第六章：结构

6.1 引言

6.2 for语句

6.3 if语句

6.4 while语句

6.5 嵌套结构

6.6 match-case结构

6.7 程序设计

第七章：运算符

7.1 引言

7.2 运算符的种类

7.3 程序设计

第八章：字符串

8.1 引言

8.2 字符串

8.3 遍历字符串

8.4 输出改变后的字符串字符

8.5 字符串切片

8.6程序设计