python 基础系列篇：二、输入输出，开始培养程序员的思想

• 约定
• 输入与输出
• • 输出 print
  • • 数据类型转换
    • eval 运算
  • 输入
  • • 多个值同时赋值
• 流程控制
• • 缩进语法
  • 分支 if .. elif .. else
  • 迭代循环 for
  • • • ⚠️ 除非明确知道影响，否则不要在迭代循环内操作迭代对象
  • 条件循环 while
  • • 循环控制 continue 和 break
• 习题示例
• • 打印一个任意系数的杨辉三角
  • • • 需求分析
  • 打印所有的水仙花数，四叶玫瑰数。。。
  • • • 需求分析
  • 输出指定索引位置的斐波那契数列中的数字
• 结束语

约定

约定，阅读本文的读者都已经具有了 python 的数据类型知识，都已经具有了基础语法知识。如需补充上述内容，可以参考《python 基础系列篇：一、基本语法与基础数据类型》。

约定，阅读本文的读者有一定耐心，老顾的岁数大了，又不是专门码字的，有时候说话比较啰嗦，还望大家见谅。

约定，文中会出现部分示例，仅代表老顾自己的思路。道路不是唯一的，各种算法老顾不会过多提及，还望见谅。

约定，老顾本身高中毕业，编程是考自学，属于野路子，文中如果出现错漏，还望指正，但请勿喷。

输入与输出

在前文中，老顾已经简单的介绍了开发环境的反馈机制，以及一个用来输出的指令 print。在这里，我们可以对这个 print 进行更深入的了解，以方便理解之后的使用。

输出 print

Definition : print(value, …, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False)
定义：print(值,…sep=’ ‘,end=’‘\n’,file=sys.stdout,flush=False)
Type : Function of builtins module
类型：内置功能模块
Prints the values to a stream, or to sys.stdout by default. Optional keyword arguments: file: a file-like object (stream); defaults to the current sys.stdout. sep: string inserted between values, default a space. end: string appended after the last value, default a newline. flush: whether to forcibly flush the stream.
将值打印到流中，或者默认情况下打印到sys.stdout中。可选关键字参数：file：类似文件的对象（流）；默认为当前sys.stdout.sep：插入值之间的字符串，默认为空格。end：附加在最后一个值之后的字符串，默认为换行符。flush：是否强制冲洗流。

其实，这些定义，如果小伙伴的英文比较好，可以直接阅读原文的。就算不太好，也可以自己开百度翻译。至于如何调出这个定义的说明，老顾以 spyder 为例。

如图所示，第一步，在右侧，切换到帮助页，第二步，帮助来源可选，第三步，在对象那里输入关键字，下边自然就会把定义调出来进行查阅了。

print 很简单，把值，或者多个值顺序输出，sep 设置为每个值之间间隔的字符，end 设置输出完毕后，结束的字符，如果设置了 file 则直接输出到指定的文件里，flush。。。说实话，老顾也是第一次见到还有这定义。。。

# 简单的输出多个内容，sep 默认是空格，所以每个数字之间有一个空格
print(1,2,3,4,5)
1 2 3 4 5
# 简单的输出多个内容，sep 指定为一个逗号，所以每个数字之间有一个逗号
print(1,2,3,4,5,sep=',')
1,2,3,4,5
# 简单的输出一个列表
a = [1,2,3,4,5]
print(a,sep=',')
[1, 2, 3, 4, 5]
# 简单的输出一个列表的所有值，注意，这里变量 a 在输出的时候多了一个 * 号修饰，表示将列表中的值提取出来，忽略列表定义本身
a = [1,2,3,4,5]
print(*a,sep=',')
1,2,3,4,5
a = [1,2,3,4,5]
# 简单的输出列表项，并求和，sum 就是全部数据相加的意思
print(*a,sep='+',end='='+ str(sum(a)))
1+2+3+4+5=15

数据类型转换

需要注意的是，print虽然大多数时候可以直接将结果输出，但如果结果是拼接而成的，那么就需要注意数据类型的问题了。就如同上述最后一个输出 end 指定的内容，我们需要将数值型的内容转成字符型的内容，才可以进行字符串相加（即拼接）运算。

那么，上一篇文章中，我将所有数据类型列出，那就有其意义了，因为在 python 中，我们可以强制指定类型，就是通过“类型(数据)”这样的格式

str(1e5)
Out[7]: '100000.0'int('15')
Out[9]: 15list(range(5))
Out[10]: [0, 1, 2, 3, 4]tuple(range(5))
Out[11]: (0, 1, 2, 3, 4)set(range(5))
Out[12]: {0, 1, 2, 3, 4}int('1e5')
Traceback (most recent call last):File "C:\Users\sosome\AppData\Local\Temp\ipykernel_7460\3091306503.py", line 1, in int('1e5')
ValueError: invalid literal for int() with base 10: '1e5'

如果遇到了无法转类型的时候，他会提示报错信息，如最后一次，他提示的内容就是“值错误”。

eval 运算

除了上述我们指定类型转换之外，其实，还可以使用 eval 来进行转换，这里就不再贴定义了。之后除非遇到特别重要的内容，否则都不再贴定义了。

简单来说，eval 可以将任何可执行，合法的指令当做本地输入的指令运行一次，并返回结果。

eval('1e5')
Out[13]: 100000.0eval('1e5 * 12')
Out[14]: 1200000.0eval('list(range(5)) * 5')
Out[16]: [0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4]

看起来就像一个我们自己控制的运行环境一样。他返回的结果，是按照实际类型返回的，所以不要担心返回内容不对。他比类型转换更加方便的地方在于，我们可以在 eval 的内容中输入各种表达式，甚至引用各种已有的定义。

a = 10
b = 5
print(eval('a + b'))
15

输入

与输出相对的，就是输入，那么与 print 相对的，这里就是 input 了。

从用户输入那里接收一些字符信息，注意，这里明确说明了，这里接收的是字符类型哦。另外在定义里，也提到了特殊情况，比如用户输入的是 Ctrl-D，Ctrl-Z之类的，会造成程序中断或字符串截断的数据时，可能会引发异常哦。

a = input()
print(a,type(a))
15
15 a = input()
print(a,type(a))
asdf
asdf a = input('请输入多个数字，中间空格分开：')
print(a,type(a))
请输入多个数字，中间空格分开：1 2 3 4 5
1 2 3 4 5 

所以，我们需要对输入的信息进行一些简单的处理。比如最后一个输入了多个数字，我们用推导方式把他转成列表。

a = input('请输入多个数字，中间空格分开：')
a = [int(n) for n in a.split()]
print(a,type(a))
请输入多个数字，中间空格分开：1 2 3 4 5
[1, 2, 3, 4, 5] 

多个值同时赋值

在 python 中，有一个元组类型的存在，如果我们在给变量赋值的时候，等号前有多个变量名的话，那么等号后就需要有相等数量的值，或相等长度的可转成元组的数据。

a,b = 3,4
c,d,e = list(range(3,6))
print(a,b,c,d,e)
3 4 3 4 5

那么由于元组的存在，所以，python 在实现变量的数据交换的时候，发生了一件其他语言所不能实现的功能–去掉了中间商！（其实中间商由运算是产生的元祖数据代替了。）

a,b = 3,4
print(a,b)
a,b = b,a
print(a,b)
3 4
4 3

那么，在了解了输入输出之后，我们可以再了解一些简单的流程控制指令，就可以进行程序代码的编写了。

流程控制

简单来讲，就是我们现在在没有接触面向对象，面向事件等等这些开发结构的时候，所有的程序都是单线程的，都是线性运行的，指令前后很重要。

那么，为了让一些内容可以多次执行，就需要控制一下这个线性的过程，比如分支，比如循环。

缩进语法

在进入到流程控制之前，我们需要了解 python 的另一个个性化设置，即缩进语法。在讲到缩进语法之前，我们先了解一下其他编程语言时怎么定义程序片段的。

// 以 javascript 为例
(function(){setTimeout(function(){console.log('我在一秒后才执行。')},1000)})()

嗯，资深人士一眼就能看出来这个代码片段如何划分层级，但对新手不友好，所以有一个缩进格式可以有效的改变可读性

// 以 javascript 为例
(function(){setTimeout(function(){console.log('我在一秒后才执行。')},1000)
})()

这样看起来，就舒服多了，但是，在所有其他语言里，都没有对缩进格式做出严格的要求，我们主要靠花括号来划分代码层级，每一对花括号内的内容，是同一级别的代码片段。

而在 python 中，他反程序员习惯的把花括号划分片段的方式去掉了！他完全依靠缩进来控制代码片段层级！所以在 python 中必须严格的按照缩进来书写代码。。。

如图所示，不管是何种的流程控制，都需要按照缩进来确定代码属于哪一级。

而缩进被称之为语法的原因，则在于，他每个缩进之前，都有一个流程控制、定义控制之类的语句，并在句末加冒号。

当然，虽然说是严格控制缩进，其实也没那么严格，只要同一片段中，缩进保持一致即可，比如我截图中， return 之前最后一个 break 的做进就和 continue 不同，但是这一片段中，只有 break 本身，所以并不受影响。

缩进长度也没有严格眼球，你可以用一个空格，两个空格，三个空格之类的，只要你觉得可读性好，怎么舒服怎么来。唯一需要注意的是，有些开发环境中，tab键会转成空格，这个时候可能是4个空格，而有些开发环境中，tab键并不会转成空格，他就是 tab（对应ascii码的9），所以有时候看起来一样的缩进，其实是不同的，需要自行注意。

分支 if … elif … else

用一个简单的例子，来学习一下分支控制，比如，用户输入一个数字，是单数还是双数。

a = input('请输入一个数字：')
if not a.isnumeric():print('你输入的不是合法的数字')
elif int(a) != float(a):print('你输入的不是一个整数')
elif int(a) % 2 == 0:print('你输入的是一个双数')
else:print('你输入的是一个单数')

if 就是如果，elif 则是 else if 的缩写，其他情况如果，else 则表示其他情况。很简单的一个判定条件，了解一下分支即可。在 python 中，并未提供多分支语句 switch，需要完全靠 if 和 elif 来控制。

迭代循环 for

for 语句就是一个迭代语句，枚举范围或列表或集合之类的内容，并参与计算。

for i in range(1,10):print(i)
1
2
3
4
5
6
7
8
9

⚠️ 除非明确知道影响，否则不要在迭代循环内操作迭代对象

经常有小伙伴问，我从一个列表中迭代循环，为什么输出的结果总是有些不对劲。比如下边的代码：

a = list(range(10))
print(a)
for i in a:print(i)a.pop(0)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0
2
4
6
8

我们会发现，如果我们在循环内进行操作迭代的对象，会对结果造成无法预料的影响。

我们来使用另一方式进行迭代，来仔细看一下是怎么受到的影响。

a = list(range(10))
print(a)
for i,v in enumerate(a):print(i,v,a)a.pop(0)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]  # 原始数据 a
0 0 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # 开始迭代，迭代索引为0，对应的值为 0
1 2 [1, 2, 3, 4, 5, 6, 7, 8, 9] # 迭代索引为1，由于已经删除了一个元素，所以当前索引对应的值为 2
2 4 [2, 3, 4, 5, 6, 7, 8, 9] # 迭代索引为2，对应值是4
3 6 [3, 4, 5, 6, 7, 8, 9]
4 8 [4, 5, 6, 7, 8, 9]

我们发现迭代的时候是按索引迭代的，并不是我们预想中的，挨个遍历。所以小伙伴们一定要注意。

条件循环 while

同样是上边的例子，我们这次用 while 来控制。

a = list(range(10))
print(a)
while len(a) > 0:  # 以列表对象 a 的长度作为循环条件b = a.pop(0)  # 删除第一个元素，并将该元素的值传递给变量 bprint(b)
print(a)  # 查看最后 a 的内容
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0
1
2
3
4
5
6
7
8
9
[]  # 查看最后 a 的内容，已经被删光光了。

循环控制 continue 和 break

不管是哪种循环，都可以使用循环控制，continue 表示从新进入下一次循环，break 则表示跳出循环。

a = 0
while a < 20:a += 1if a % 2 == 0:continueif a % 3 == 0:print('3的倍数',end=' ')if a % 13 == 0:breakprint(a)
1
3的倍数 3
5
7
3的倍数 9
11

在 a 是偶数时，直接进入到下一次循环，后续不再执行
在 a 是13的倍数时，直接跳出循环，后续不再执行

习题示例

打印一个任意系数的杨辉三角

在开始之前，我们需要想一下，如何使杨慧三角输出的系数是居中显示的。比如下图。

需求分析

杨辉三角如果有人不知道，那就自行补课了啊，这里只分析下打印出上图，需要什么内容。

1、有完整的杨辉三角计算结果
2、可以得到最大数的位数，用来确定每个数的间隔和占位
3、在数字较少的行，补上空格，每个数字之间至少一个空格间隔

这是第一次的分析，然后细化一下

1、根据用户输入的系数自行计算出所需要的行数并填充系数
这个可以用循环来完成
2、得到最大的数
这个可以在系数填充完毕后，用最后一行的最大的数来确定
3、补空格的规律应该是最多数字的行减去当前行的数字再除以2，即只需要补左边的，右边的可以忽略

那么，有了以上的分析，大体思路就应该已经出来了，老顾在这里举出一个示例，小伙伴们可以自行编写一下。老顾可以保证，所有的知识都已经提及过了哦。

n = 0
while n <= 0:b = input('请输入一个整数系数：')if b.isnumeric():n = int(b)a = [[1]] # 初始化杨辉三角的第一层
for i in range(n):a.append([]) # 初始化下一层杨辉三角系数列表for j in range(len(a[-2]) + 1):if j == 0:a[-1].append(a[-2][0])elif j == len(a[-2]):a[-1].append(a[-2][-1])else:a[-1].append(a[-2][j] + a[-2][j - 1])max_len = len(str(max(a[-1]))) + 1 # 记录数字最长位数
for i in range(n + 1):print(' ' * int(max_len * ((n - i) / 2)) + ''.join([(' ' * max_len + str(v))[-max_len:] for v in a[i]]))

打印所有的水仙花数，四叶玫瑰数。。。

嗯，在混 csdn 问答前，老顾根本不知道这些什么什么数到底是什么鬼，数字就数字，最多谁喜欢哪个数字，做个幸运数字好了，还有别的玩法？结果是老顾天真了，除了这些3位数4位数，还有什么黑洞数，什么什么星数，各种见鬼的数，谁这么闲的给他们命名的？

言归正传

水仙花数就是三位数，每个位上的数字的立方和是数字本身
四叶玫瑰数就是四位数，每个位上的数字的四次方和是数字本身
以及不超过9位数的其他这种规律的各种数

行吧，这个恨简单，我们用循环，把所有的数字都遍历尝试一遍，看看到底是不是符合规律，符合规律的输出就可以了

需求分析

这次我们不指定输出的是什么数了，先把6位数的全部输出出来好了，看看都有什么数字。

1、从数字100开始，因为这是最小的三位数
2、可以确定这是几位数，确定用几次方
3、对符合运算规律的数字进行输出

简单的逻辑一摆，自然知道怎么写代码了。

for i in range(100,1000000): # 限制到100万以内，只输出到六合数，七星数以上就不输出了n = [int(v) for v in str(i)] # 通过类型转换成字符串，然后推导成数字列表if sum([v ** len(n) for v in n]) == i: # len用来测量长度，可以用长度作为乘方系数，并最终求和print('{}={}'.format(i,'+'.join([str(v)+'^' + str(len(n)) for v in n])))
153=1^3+5^3+3^3
370=3^3+7^3+0^3
371=3^3+7^3+1^3
407=4^3+0^3+7^3
1634=1^4+6^4+3^4+4^4
8208=8^4+2^4+0^4+8^4
9474=9^4+4^4+7^4+4^4
54748=5^5+4^5+7^5+4^5+8^5
92727=9^5+2^5+7^5+2^5+7^5
93084=9^5+3^5+0^5+8^5+4^5
548834=5^6+4^6+8^6+8^6+3^6+4^6

输出指定索引位置的斐波那契数列中的数字

这见鬼的名字我终于记住了。。。。就是很常见的数列：1,1,2,3,5,8,13,21,34…

老顾用两种方式来实现一下这个需求

n = int(input('请输入一个正整数：'))
a = [1,1]
while len(a) < n:a.append(a[-1] + a[-2])print(a[-1])

这个办法，是建立一个列表，将所有数列中 的数字放进去，最后取出指定索引的数字即可。

n = int(input('请输入一个正整数：'))
a,b = 1,1
while n > 2:a,b = b,a + bn -= 1
print(b)

而这个办法，则是无需列表支持，自己进行累加即可，由于前两个数固定是1，所以b=1的时候输出b也没有问题。

就实现上来说，后一种方法内存消耗更低，效率上没什么大的差别。

结束语

在学习了基本语法，数据类型和流程控制之后，我们就可以自行练习一些算法题目了，当然还有链表、多维数组之类的东西，我们可以慢慢熟悉。

愿大家都能有一个良好的开端，进入到程序员的世界。