python冲击二级--开始真正的编程，代码规范，内置武器库之一

子曰：“工欲善其事，必先利其器。居是邦也，事其大夫之贤者，友其士之仁者。”《論語•衛靈公》

本章我们将通过实际的代码，来展示python给我们的内置武器库，并就官方的PEP8代码格式规范，有一定涉及，毕竟整洁，条理清晰的代码谁不爱呢。

最近笔者一直在写这些基础的教程，原来的ide也不用了，用着python自带的idle，才发现原来没有了ide，好像自己都不会写代码了，仿佛回到了最开始学python的时候，但是经过这半个月不断错误的暴击，也终于习惯了。所以建议初学者们，自虐会让你更快的发现问题，错误犯的越多，你的进步也会更快。

每个缩进级别使用4个空格。
连续行应该垂直对齐包裹的元素，或者使用Python的隐式行连接括号、括号和大括号，或者使用悬挂缩进[1]。使用悬挂缩进时，应考虑以下事项：；第一行上不应有任何参数，应使用进一步的缩进，以明确区分其作为续行：

# 正确的示范

# 与开头分隔符对齐
foo = long_function_name(var_one, var_two,
                         var_three, var_four)

#添加4个空格（额外的缩进级别）以区分参数和其他参数。 
def long_function_name(
        var_one, var_two, var_three,
        var_four):
    print(var_one)

# 悬挂缩进应该增加一个级别。
foo = long_function_name(
    var_one, var_two,
    var_three, var_four)
    

当一个条件部分 if-语句足够长，需要 它被写成多行，值得注意的是 两个字符关键字的组合（即 if)，加上一个空格， 加上一个左括号为 多行条件的后续行。 这可以产生视觉 与嵌套在 if-陈述， 这也自然会缩进 4 个空格。 这个 PEP 不需要 关于如何（或是否）进一步在视觉上区分此类的明确立场 来自嵌套套件内的条件行 if-陈述。 在这种情况下可接受的选项包括但不限于：

if (this_is_one_thing and
    that_is_another_thing):
    do_something()

if (this_is_one_thing and
    that_is_another_thing):
  
    do_something()

if (this_is_one_thing
        and that_is_another_thing):
    do_something()

多行结构上的右大括号/方括号/括号可以 在最后一个的第一个非空白字符下排列 列表行，如：

my_list = [
    1, 2, 3,
    4, 5, 6,
    ]
result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
    )

my_list = [
    1, 2, 3,
    4, 5, 6,
]
result = some_function_that_takes_arguments(
    'a', 'b', 'c',
    'd', 'e', 'f',
)

制表符还是空格？

空格是首选的缩进方法。

选项卡应仅用于与以下代码保持一致 已经用制表符缩进了。

Python 不允许在缩进时混合制表符和空格。

最大线长

将所有行限制为最多 79 个字符。

用于流动结构限制较少的长文本块 （文档字符串或注释），行长应限制为 72 人物。

限制所需的编辑器窗口宽度使得有可能 几个文件并排打开，在使用代码时效果很好 查看在相邻列中显示两个版本的工具。

大多数工具中的默认包装破坏了 代码，使其更难理解。 限制被选择为 避免在窗口宽度设置为 80 的编辑器中换行，即使
如果工具在包装时将标记字形放置在最后一列中 线。 一些基于 Web 的工具可能根本不提供动态换行。

一些团队非常喜欢更长的线路长度。 对于维护的代码 完全或主要由可以就此达成协议的团队 问题，可以将行长限制增加到 99 个字符，
前提是注释和文档字符串仍以 72 包装 人物。

Python标准库比较保守，需要限制 行至 79 个字符（文档字符串/注释至 72）。

包装长行的首选方法是使用 Python 的隐含 圆括号、方括号和大括号内的行继续。 排长龙 可以通过将表达式包装在多行中 括号。
这些应该优先使用反斜杠 用于续行。

反斜杠有时可能仍然合适。 例如，长， 多 with- 语句不能使用隐式延续 在 Python 3.10
之前，因此在这种情况下反斜杠是可以接受的：

with open('/path/to/some/file/you/want/to/read') as file_1, \
     open('/path/to/some/file/being/written', 'w') as file_2:
    file_2.write(file_1.read())

简单的编码规范先到此为止，规范只不过是让我们的代码更易阅读的一种非强制的规定，并不影响我们代码的书写，况且现在大部分的ide都有自动格式化的功能。

#这里是单行注释“#”开始

'''
这里是多行注释，需要写在三个单引号之间，注意符号都要用英文字符，
否则会出现错误。编程要敢想，敢写，不要怕出错，没一个程序员都是从
错误中成长的，而且依然在不断的犯错。这世界上没有多少天才，唯有努力
而已。
'''
'''
第一个程序：接受输入一个字符串，判断字符串长度,如果是双数则打印，出双入对，
如果是单数则打印，形单影只，如果是空字符串则打印空空如也。
'''

'''
设计一个变量接受input输入，用if语句进行判断，由于判断类型字符串长度,属于互斥性的
判断，所以我们用if elif，else来进行控制
'''

#我们要时刻记得input函数返回值，永远是字符串类型
word = input("请输入一个字符串:")

#用len函数计算变量word值得长度
length = len(word)

#如何长度除以2的余数为0，那必为偶数,注意每个判断语句后的冒号

if length%2 == 0:
    print("出双入对")#注意缩进建议四个空格，也可以使用TAB
    
elif length%2 != 0:
    print("形单影只")

else:
    print("空空如也")


#完成，按下F5启动测试

注意，对于一个程序员来说，我们首先测试的一定要是意外情况，比如输入为空，就是直接按下回车键，结果是：

请输入一个字符串:
出双入对
>>> 

由于什么也没有输入，字符长度为0，直接满足了偶数条件，所以重新修改程序。

#由于代码比较短，我们也可以直接采取一行书写的形式，但是并不推荐

if length == 0: print("空空如也")

elif length%2 == 0: print("出双入对")
    
else: print("形单影只")

最常见的控制流语句是 if 语句。if 语句的子句（也就是紧跟 if 语句的语句块）， 将在语句的条件为 True 时执行。如果条件为 False，子句将跳过。 在英文中，if 语句念起来可能是： “如果条件为真，执行子句中的代码。”在 Python 中，if语句包含以下部分：
 if 关键字；
 条件（即求值为 True 或 False 的表达式）；
 冒号；
在下一行开始，缩进的代码块（称为 if 子句）。

if 子句后面有时候也可以跟着 else 语句。只有 if 语句的条件为 False 时，else子句才会执行。在英语中，else语句读起来可能是：“如果条件为真，执行这段代码。否则，执行那段代码”。else 语句不包含条件，在代码中，else 语句中包含下面部分：
 else 关键字；
 冒号；
 在下一行开始，缩进的代码块（称为 else 子句）。

虽然只有 if 或 else 子句会被执行，但有时候可能你希望，“许多”可能的子句 中有一个被执行。elif 语句是“否则如果”，总是跟在 if 或另一条 elif 语句后面。它 提供了另一个条件，仅在前面的条件为 False 时才检查该条件。在代码中，elif 语句总是包含以下部分：
 elif 关键字；
 条件（即求值为 True 或 False 的表达式）；
 冒号；
 在下一行开始，缩进的代码块（称为 elif 子句）。
如果有一系列的 elif 语句，仅有一条或零条子句会被执行。一旦一个语句的条件为 True，剩下的 elif 子句会自动跳过。

编程的核心循环，循环无处不在，有了循环，程序才有了程序的样子，才能让我们处理更复杂的问题。

while 循环语句
利用 while 语句，可以让一个代码块一遍又一遍的执行。只要 while 语句的条件为 True，while 子句中的代码就会执行。在代码中，while 语句总是包含下面几部分：
 关键字；
 条件（求值为 True 或 False 的表达式）；
 冒号；
 从新行开始，缩进的代码块（称为 while 子句）。
可以看到，while 语句看起来和 if 语句类似。不同之处是它们的行为。if 子句结束时，程序继续执行 if 语句之后的语句。但在 while 子句结束时，程序执行跳回到 while 语句开始处。while 子句常被称为“while 循环”，或就是“循环”。

试想这样一段程序，我想从100个数里找到那个最大的能被7整除的数。我们目的是找到最大的，显然要从100开始向后找，然后用if判断是否能被7整除，是就打印并且结束循环。

n = 100

#当n的值为真则一直循环,当n为0时结束循环
while n:
    if n%7 == 0:
        print(n)
        
    #可简写为n -= 1,每次循环n-1，这行并不属于if语句块，它们的关系是并列的。
    n = n-1 

#完成，按下F5启动测试

结果输入：

================ RESTART: C:/Users/Administrator/Desktop/test.py ===============
98
91
84
77
70
63
56
49
42
35
28
21
14
7
>>> 

我们确实找到了结果，但是把所有能被7整除的数字都找出来了，我们只想要最大的，所以在得到最大的结果之后我们就要打破循环，结束循环，更改代码：

n = 100

#当n的值为真则一直循环,当n为0时结束循环
while n:
    if n%7 == 0:
        print(n)
        #通过break关键字，打破循环
        break
        
    #可简写为n -= 1,每次循环n-1
    n = n-1 
    

我们如愿以偿得到了，最终的结果，每次循环while都会判断n的值，然后if语句判断是否能被7整除，如果是则打印并打破循环。如果你说这不符合你的思路，你就想从1开始循环，那么该如何做呢？
如果从1开始循环，我们首先要改变结束循环的条件，我们要去n要小于100，所以就以此为判断条件，另外还需要一个变量存储最大值，需要不听的比较这个值和n的大小，把大的留下。

n = 1
#存储结果的值，赋值为0。
r = 0
#当n<=100的值为真,则一直循环,当n大于100时结束循环

while n<=100:
    
    if n%7 == 0:
        #三元赋值，如果n>r,则r=n,否则r=r,保证每次满足if条件r存储最大值
        r = n if n>r else r
            
    #可简写为n += 1,每次循环n+1
    n = n+1 

#最后才打印r，因为我们要等到循环结束才能得到最大值
print(r)

#完成，按下F5启动测试

• 被定义为假值的常量: None 和 False。
• 任何数值类型的零: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
• 空的序列和多项集: ‘’, (), [], {}, set(), range(0)
产生布尔值结果的运算和内置函数总是返回 0 或 False 作为假值，1 或 True 作为真值，除非另行说
明。（重要例外：布尔运算 or 和 and 总是返回其中一个操作数。）

如果你不想让你的while一直循环下去，一定要设定一个条件，以便于让它适时的停止。如果你不想让他停下来，那就让条件一直为True，比如while True：

name = ''

while name != '李白':
    name = input("请输入你的名字：")

print("很好你通过了")

想一想上面的代码会如何运行，如果你一直输错，会怎么样。

下面我们用循环来模拟一个简单的用户登录操作，我们需要验证用户名和密码，如果任意一个不对，都不能通过，让用户重新输入，如果对了就打印登录成功。

while True:
    name = input("请输入用户名：")
    if name != "CSDN":
        continue
    #字符串格式化语法，用{}占位，format中的参数会自动填充到{}.\n为换行转义字符
    print("欢迎你{}\n".format(name))
    password = input("请输入密码：")
    if password == "123456":
        break

print("登录成功用户名{}，密码{}".format(name,password))

输入几次错误的用户名，看看程序是如何运行的。

continue 语句 像 break 语句一样，continue 语句用于循环内部。如果程序执行遇到 continue 语句，就会马上跳回到循环开始处，重新对循环条件求值（这也是执行到达循环末 尾时发生的事情）。

在条件为 True 时，while 循环就会继续循环（这是它的名称的由来）。但如果你想让一个代码块执行固定次数，该怎么办？可以通过 for 循环语句和 range()函数来实现。

在代码中，for 语句看起来像 for i in range(5):这样，总是包含以下部分：
 for 关键字；
 一个变量名；
 in 关键字；
 调用 range()方法，最多传入 3 个参数；
 冒号；
 从下一行开始，缩退的代码块（称为 for 子句）。

for i in range(10):
    print(i)
================ RESTART: C:/Users/Administrator/Desktop/test.py ===============
0
1
2
3
4
5
6
7
8
9
>>> 

首先看范围range(10),范围从0-9，range接受3个参数，开始，结束，步长，所以range（10）相当于range(1,10,0)。自己可以打印测试一下，各种参数的输出情况。

下面我们来考虑一个经典问题，鸡兔同笼。

鸡兔同笼是中国古代的数学名题之一。大约在1500年前，《孙子算经》中就记载了这个有趣的问题。书中是这样叙述的：
今有雉兔同笼，上有三十五头，下有九十四足，问雉兔各几何？ 这四句话的意思是：
有若干只鸡兔同在一个笼子里，从上面数，有35个头，从下面数，有94只脚。问笼中各有多少只鸡和兔？

古人说话真是言简意赅，有数学基础的是不是立刻就想到了一个方程式：x+y=35,2x+4y=94
那通过编程我们如何快速解决问题：

#鸡,也可以不预先设定，直接用for语句
#x = 1

#让x的值从1到35递增
for x in range(1,36):

    #兔的数量，每次重新计算
    y = 35-x
    #判断条件
    if 2*x+4*y == 94:
        print("鸡有{}只，兔有{}只".format(x, y))
        #因为我们不知道有多少值满足条件所以先不break，直接循环到最后
        #break

这算是最简单的对现实世界建模了吧。体验到编程了乐趣了吗？打印结果我们发现，只有一个值，符合，所以为了提高程序运行速度，我们可以加上break,这算是最简单的优化了吧。
如果我们想改变鸡兔的总数，我们就需要更改代码，为了让代码更通用，并且拿来就用，我们可以用函数简单的封装。

#num鸡和兔子的总数，int类型整数
def jitu(num):
    for x in range(1,num+1):
    #兔的数量，每次重新计算
        y = num-x
    #判断条件
        if 2*x+4*y == 94:
            print("鸡有{}只，兔有{}只".format(x, y))
        #因为我们不知道有多少值满足条件所以先不break，直接循环到最后
            break
#调用函数        
jitu(35)

但是有一个问题，如果我们胡乱输入一个数字，并不会有结果什么显示都没有，所以我们还要优化一下。

def jitu(num):
    for x in range(1,num+1):
        y = num-x
        if 2*x+4*y == 94:
            print("鸡有{}只，兔有{}只".format(x, y))
            break
    #for循环，全部循环完成,没有被break，则进入else语句块。
    else:
        print("没有这样的数字")



#调用函数        
jitu(88)
jitu(35)
================ RESTART: C:/Users/Administrator/Desktop/test.py ===============
没有这样的数字
鸡有23只，兔有12只
>>> 

for …else语句并不常用，但是有些时候还是很有用的，只有当for循环全部循环完毕，没有被break，才会执行else部分。这也符合我们的要求，

现在升级我们的要求，我想在想知道500个数字之内，有多少个条件能满足鸡兔同笼的问题。

def jitu(num):
    for x in range(1,num+1):
        y = num-x
        if 2*x+4*y == 94:
            print("鸡有{}只，兔有{}只".format(x, y))
            break
    else:
        print("没有这样的数字")

#调用函数        
for i in range(1,501):
    jitu(i)

================ RESTART: C:/Users/Administrator/Desktop/test.py ===============
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
没有这样的数字
鸡有1只，兔有23只
鸡有3只，兔有22只
鸡有5只，兔有21只
鸡有7只，兔有20只
鸡有9只，兔有19只
鸡有11只，兔有18只
鸡有13只，兔有17只
鸡有15只，兔有16只
鸡有17只，兔有15只
鸡有19只，兔有14只
鸡有21只，兔有13只
鸡有23只，兔有12只
鸡有25只，兔有11只
鸡有27只，兔有10只
鸡有29只，兔有9只
鸡有31只，兔有8只
鸡有33只，兔有7只
鸡有35只，兔有6只
鸡有37只，兔有5只
鸡有39只，兔有4只
鸡有41只，兔有3只
鸡有43只，兔有2只
鸡有45只，兔有1只
鸡有47只，兔有0只
没有这样的数字
没有这样的数字
没有这样的数字

好长啊，很显然我们的函数不行啊，不满足程序要求要修改，我只想要结果，不想打印这些无聊的没有这样的数字了。

def jitu(num):
    for x in range(1,num+1):
        y = num-x
        if 2*x+4*y == 94:
        #当满足条件的时候直接返回，循环终止
           return "鸡有{}只，兔有{}只,鸡兔一共{}只".format(x, y, num) 
#调用函数        
for i in range(1,501):
    #接收jiutu函数return 后面的值
    s = jitu(i)
    print(s)

这次运行完成后发现，出现了大量None,因为当没有满足函数内if条件的时候，没有执行return语句，导致函数没有返回值，默认返回了None,再次处理：

for i in range(1,501):
    #接收jiutu函数return 后面的值
    s = jitu(i)
    #如果s为真，也就是不是None，也可以用 s is not None
    if s:
        print(s)

================ RESTART: C:/Users/Administrator/Desktop/test.py ===============
鸡有1只，兔有23只,鸡兔一共24只
鸡有3只，兔有22只,鸡兔一共25只
鸡有5只，兔有21只,鸡兔一共26只
鸡有7只，兔有20只,鸡兔一共27只
鸡有9只，兔有19只,鸡兔一共28只
鸡有11只，兔有18只,鸡兔一共29只
鸡有13只，兔有17只,鸡兔一共30只
鸡有15只，兔有16只,鸡兔一共31只
鸡有17只，兔有15只,鸡兔一共32只
鸡有19只，兔有14只,鸡兔一共33只
鸡有21只，兔有13只,鸡兔一共34只
鸡有23只，兔有12只,鸡兔一共35只
鸡有25只，兔有11只,鸡兔一共36只
鸡有27只，兔有10只,鸡兔一共37只
鸡有29只，兔有9只,鸡兔一共38只
鸡有31只，兔有8只,鸡兔一共39只
鸡有33只，兔有7只,鸡兔一共40只
鸡有35只，兔有6只,鸡兔一共41只
鸡有37只，兔有5只,鸡兔一共42只
鸡有39只，兔有4只,鸡兔一共43只
鸡有41只，兔有3只,鸡兔一共44只
鸡有43只，兔有2只,鸡兔一共45只
鸡有45只，兔有1只,鸡兔一共46只
鸡有47只，兔有0只,鸡兔一共47只

>>> 

结果貌似不错，其实这个程序仍然有问题，因为有兔子是0的情况，想一想如何修改吧！！！

最后的题外话：
编程只是我们的工具，你写的代码越多，遇到的问题就越多，就离大神更近一步。

我刚学的时候什么都要自己写，梦想着有一天在编程界叱咤风云，成为自己照镜子都吓得瑟瑟发抖的存在，现实是全栈看上去很牛逼，其实是样样松，很少有人能有那样旺盛的精力，覆盖编程的每一个领域，你去看看tcp/ip协议，再看看http协议，搞懂这几个协议就要多久，每天都有新的技术诞生，新的编程语言出现，你始终要有自己的一条路，而不是四处乱逛。不要否认自己的平庸，也不要妄自菲薄，这个世界上天才不多，无论多么牛逼的代码，也是人写出来的，是靠日积月累的学习，练习，思考，产生的。
我写这些基础的东西，其实何尝不是对自己知识的再次巩固，虽然身边的人都劝我，为什么要写这些基础的东西网上多的是，我自己也是下了好久的决心，毕竟这些基础的东西，感觉不会给自己带来任何提高，但是越写下去才发现，原来我忽视了好多东西，有些一直在脑海中的观念居然是不对的。这就像你总会忽视那些，身边的事物，指导某一天才发现，原来楼下的花园，花开的很美。
所以只要有时间，我会坚持下去，与诸君共勉吧！文章中如有疏漏之处，请留言，毕竟我们都是在错误中成长的。