Python 程序结构及代码规范

每一个可执行的 python 程序中都会有各种各样的文件类型、文件中也有基本的代码结构和代码规范

1、文件类型

在 python 中，常用的文件类型有 3 种：分别是源代码文件、字节代码文件和优化代码文件。

1. 源代码文件。
   Python 源代码文件扩展名为 .py，可以使用文本编辑器编辑，如使用记事本、Editplus 或一些集成开发环境自带的文本编辑器进行编辑。

2. 字节代码文件
   字节代码文件的扩展名为.pyc，是由 Python 源代码文件编译而成的二进制文件，由 Python 加速执行，其速度快，能够隐藏源代码。可以通过 Python.exe 或脚本方式将 Python 源文件编译成 Python 字节代码文件。
   下面演示这两种方式：

第一种，使用命令行的方式：使用 python -m py_compile 文件路径 的方式对任意一个 .py 文件进行操作，都会将其编译成相应的字节代码文件 文件名.pyc，并存放在文件路径下的 _pycache_ 文件夹中(如无则自动创建)。并且可以使用 python 命令执行该生成文件。


第二种，通过脚本操作。比如我们创建另一个 .py 文件，并在其中写如下语句，执行，则同样可以看到生成了相应的字节代码文件。

import py_compile    # 导入模块，这是一个python 内置模块，具体信息上 python 文档查看
py_compile.compile('F:\demo\demo710.py') #文件路径换成自己的

运行结果如下：

此时我们再次查看源代码文件路径，发现多出了 一个 __pycache__文件，其中有相对应的 .pyc 文件。

3. 优化代码文件。
   python 优化代码文件是优化编译后的文件（文件格式同样是 .pyc，但是和前面的不同，不能混淆），无法用文本编辑器进行编辑，一般用于嵌入式系统。
   可以在 Windows 命令行中执行命令 python -O -m py_compile 源代码文件(.py)路径 将源文件 编译成优化代码文件，并存放在 pycache 中，可以使用 python 命令去执行生成的代码优化文件。
   
   

2、代码结构

引入一个实例：求解两个数平方和的平方根

import math    # 导入模块

def func(x, y):    # 定义函数
	z = math.sqrt(x ** 2 + y ** 2)
	return z

if __name__ == '__main__':
	a = int(input("请输入一个整数:"))   # 定义变量a
	b = int(input("请输入一个整数:"))   # 定义变量b
	c = func(a, b)   # 调用函数 func，并将结果赋值给 c
	print("c = ", c)    # 输出

从上例可以看出，一个完整的 python 代码一般包括以下几个部分：

1. 导入模块（使用关键字 import）。一般放在程序最开头的部分，用来导入 python 内置或者来自外部的模块或对象，在代码中进行调用，实现特定的功能。
2. 定义函数（使用关键字 def）。能够完成一定功能、被外部调用的独立程序块。
3. 定义变量或常量。常量或变量用来存储数据对象，必须遵循一定的命名规则。
4. 输入（函数 input）。用于动态的接受从键盘输入的内容，并赋值给相应的变量。
5. 处理。调用函数或者一些基本运算符对数据进行相应的处理。
6. 输出（函数 print）。对程序处理的结果进行输出，以观察是否和预期结果一致。
7. 注释。不被程序执行的一部分用于增强程序功能和关键算法可读性的语句。
8. __name __。用来设置 Python 程序文件是作为模块导入还是单独运行模式的。简单来说，对于我们每创建的一个 .py 文件，系统都会对其有一个 __name__属性，如果我们只是运行该 .py文件，则系统会将该文件__name__属性默认设置为’main’，这时
   if name == ‘main’: 后面的语句将会被执行；而假如说我们将该 .py 文件作为一个模块导入到另一个 .py 文件中使用其函数，那么这时系统会将该模块的__name__设置为文件名，所以模块的 if 后面的语句将不会被执行！(切记，此处均为双下画线)

我们可以简单看一个实例：

# demo2.py

def printhello():
    """打印 “hello xxx” 语句 """
    print("hello,这是函数")
    
if __name__ == '__main__':
    print("__name__ 被执行")
    printhello()

如果仅仅是运行demo2.py，则会看到如下结果，if 语句后的程序被执行：

>>> __name__ 被执行
>>> hello,这是函数

如果是将demo2.py作为模块导入到其他文件中，则 if 语句后面的程序不会被执行

# demo_2_import

import demo2
demo2.printhello()

可以看到结果，只是执行了函数

>>> hello,这是函数

可如果说将demo2 中的 if 语句去掉，没有了__name__属性的限制，那么将其作为模块导入时，demo2中内容将会被全部执行

# 更改后的 demo2
def printhello():
    """打印 “hello xxx” 语句 """
    print("hello,这是函数")

print("__name__ 被执行")
printhello()

作为模块导入后的结果：

>>> __name__ 被执行
>>> hello,这是函数
>>> hello,这是函数

简略的说，我们的代码结构遵从 IPO 规则,即：输入（input）－－>处理（process）－－>输出（output）

3、编码规范

像大多数的编程语言一样， Python 也有约定俗称的编码规范， Python 非常注重代码的可读性，对代码布局和排版有更加严格的要求。

1、标识符
用来给类、对象、方法、变量、接口和自定义数据类型等命名的名称。
组成：数字、字母、汉字、下划线

必须遵循的规则：

• 标识符必须以字母、汉字或下划线开头，不能以数字开头，且要注意下划线在 Python 中还有特殊的含义。
• 标识符不能使用空格或标点符号（括号、逗号、引号等）。
• 不能使用 Python 关键字（如 if 等）作为标识符。
• 不建议使用模块名、类型名或函数名等作为标识，以免影响程序的正常运行。
• 标识符对字母的大小写是敏感的。如 Age 和 age 是两个不同的标识符。
• 有意义的标识符应该是有意义的、易于辨认的，可以增强程序的可读性。如使用 age
• 作为年龄的标识符比使用 a1 或其他更加容易区别和理解。

2、保留字
即关键字，不能作为标识符使用. python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有保留字。

import keyword
print("Python 中的保留字:", keyword.kwlist)

False	None	True	and
as	assert	break	class
continue	def	del	elif
else	except	finally	for
from	global	if	import
in	is	lambda	nonlocal
not	or	pass	raise
return	try	while	with
yield

3、注释

• 注释，是指在程序代码中添加的标注性文字，类似于东西的使用说明。

• 当程序被处理时，这些注释会被自动忽略不会被当做代码处理。

• 为程序的关键算法、函数功能、模块功能等重要位置添加相关的注释，可以有效的提高程序的可读性。

• 注释帮助我们理清代码逻辑；与别人合作开发时，添加注释，可以减少沟通成本；开发模块时添加注释可以减少他人使用成本；可以临时注释一段代码，方便调试。

• 单行注释：将要注释的一行代码以 # 开头

代码    # 注释
# 代码

• 多行注释：
  将要注释的多行代码以 # 开头，或者将多行代码放在成对的 ‘’'（3个单引号）或是成对的"“”（3个双引号）中

# 注释
# 注释
# 注释

'''
注释
'''

"""
注释
"""

注释的方法有手动注释法，即上面讲到的 一个一个加 # 或引号，而批量注释法可以通过快捷键实现（此方法可以快速的将暂时不需要但还有用的代码注释掉，让程序跳过这部分代码，方便调试）：

• 首先选中需要注释掉的代码
• 在 IDLE 中，同时按住 Alt + 3 ，添加批量注释；同时按住 Alt + 4，删除批量注释。
• 在 Pycharm 中，添加注释和删除注释均使用 Ctrl + / 。

小贴士：
对程序中关键代码和重要业务进行必要的注释，可以很好地增加程序的可读性。
据不完全统计，可读性好的程序常常包含 30% 以上的注释。
注释不会被执行，只是程序员用来理解程序的。

4、代码缩进
Python 采用严格地缩进方式来体现代码的从属关系，而不使用大括号 {}。缩进空格数是可变的，但同一语句块的语句必须包含相同的缩进空格数，否则，要么出现语法错误，要么出现逻辑错误。

• 常规格的是使用 4 个空格，或者一个 Tab 键表示缩进关系

5、多行书写一条语句
Python 通常是一行书写一条语句。但是，如果语句很长，也可以多行书写一条语句，这可以使用反斜杠（\）来实现。

a = 5
b = 6
# 使用两行书写一条语句
c = a + \
	b
print("c = ", c)

# 结果为：c = 11

在 [ ] 、{ }、( ) 中的多行语句不需要使用反斜杠( \ )

list1 = [1, 2, 
         3, 4, 5]
print("list1: ", list1)

# 结果为: list1: [1, 2, 3, 4, 5]

6、一行书写多行语句
Python 可以在一行中书写多条语句，语句之间使用分号 ； 隔开

a = 1.2; b = 2.3; c = a + b

7、空行
空行也是程序代码的一部分。例如，函数之间或类的方法之间用空行隔开，表示一段新的代码的开始，类和函数入口之间也用空行隔开，以突出函数入口的开始。
简单来说，空行不是 python 语法的一部分，书写时不插入空行，也不会报错，作用是分隔两段不同功能或含义的代码，使程序结构更加清晰，便于日后代码的维护或重构。

import math
             # 空行
语句块1

语句块2

8、模块及模块对象导入
Python 默认安装仅包含最基本的核心模块，启动时只加载了基本模块。
在需要使用标准库或第三方库中的对象时，可以显式的导入模块，这样可以减轻程序运行时的压力，具有很强的扩展性，也有利于提高系统的安全性。
使用 import 导入模块的几种方法：

• 导入整个模块

import 模块名
import socket
c = socket.socket() # 使用方法 ： 模块名.方法()

• 导入模块的单个对象

from 模块名 import 对象 [as 别名 ]
from os import mkdir 
c = mkdir(xxx)

from os import mkdir as mk
c = mk(xxx)

• 导入模块的多个对象

from 模块 import 对象1, 对象2...
from time import ctime, asctime

• 导入模块的全部对象

from 模块 import *
from math import *

9、语句块
缩进相同的一组语句构成一个语句块，又称为语句组。比如一个 if 语句块，一个函数def 语句块等，通常不同的语句块还使用空行隔开，增强可读性和层次性。

10、字符编码及转换
几种计算机中常见的字符编码：

• ASCLL：占1个字节8位，采用二进制对英文大小写字母、数字、标点符号和控制符等进行编码，例如，‘A’的 ASCLL 编码为 65.
• Unicode：又称为万国码或统一码，占2个字节16位，包含了世界上大多数国家的字符编码。例如，汉字‘严’的 Unicode 是十六进制数 4E25
• UTF-8：是一种变长的编码方式，使用1~4个字节表示一个符号，根据不同的符号而改变字节长度。如，汉字“严”的 UTF-8 是十六进制数 E4B8A5
• GBK：专门用来解决中文编码，是在国家标准 GB2312 基础上扩容后兼容 GB2312 的标准，中英文都是双字节的。

在 python 2.x 中默认的字符编码是 ASCLL，如果要处理中文字符，则需要在源文件的开头添加（两种方式选其一即可）

# -*- coding: UTF-8 -*-
#coding=utf-8   # 注意此句 = 两边不要留空格

Python 3.x 默认的字符编码是 Unicode编码，所以可以直接使用包括汉字的各种字符。
对字符进行不同的编码格式转换，可以使用如下两个方法：

1. str.encode()，编码函数。用于将 Unicode 格式的字符串转换成其他编码格式，返回一个字符串

'''
一般格式：
str.encode(encoding='编码类型'[,errors='strict'])
str 为字符串，encoding为需要更改成的编码格式，如utf-8等，errors为错误处理方案，可选参数

如：
'''
str = '你好'
gbk_str = str.encode(encoding='gbk', errors='strict')
utf_8_str = str.encode(encoding='utf-8', errors='strict')
print('gbk格式：', gbk_str)
print('utf-8格式：', utf_8_str)

"""
结果：
gbk格式： b'\xc4\xe3\xba\xc3'
utf-8格式： b'\xe4\xbd\xa0\xe5\xa5\xbd'
"""

2、str.decode()，解码函数。指定编码格式解码字符串，默认编码格式为 Unicode 编码。

"""
一般格式：
bstr.decode(encoding='编码类型', errors='strict')
bstr：需要解码的字符串
encoding：bstr的类型，如上文中的 gbk_str是gbk编码方式的，则需要用gbk方式解码（即什么方式编码，就什么方式解码）
errors是错误处理方案
"""
# 可以将上面的代码和下面的代码结合使用
de_gbk_str = gbk_str.decode(encoding='gbk', errors='strict')
de_utf_8_str = utf_8_str.decode(encoding='utf-8', errors='strict')
print('gbk形式解码: ', de_gbk_str)
print('utf-8形式解码: ', de_utf_8_str)

"""
结果为：
gbk形式解码:  你好
utf-8形式解码:  你好
"""

4、输入输出函数

input()：输入函数

• input()的执行规则是：先输出自定义的提示字符串，然后接受用户输入
• input() 所接受的任何内容均为字符串的形式，所以在使用变量接收时一定要注意类型的转换

'''
一般格式：变量 = input(['提示字符串'])
**变量和提示字符串均可以省略**
用户按 Enter（回车）完成输入，在按回车之前，所有内容均作为输入字符串赋给变量

'''
# 省略变量：这种情况也是可以的，不过不推荐
>>> print(input('请输入：'))
请输入：2

# 从键盘输入一个字符串
name = input('请输入您的姓名:')

# 从键盘接收多个字符串
Ssex, Sdept = input('请输入您的性别、职业:').split()
# split()：字符串分隔函数，可以根据给定的字符分隔字符串，不给定则默认是空格 

# 类型转换
a = int(input('请输入一个整数:'))

print()：输出函数

可以直接输出数字、字符串、列表等常量、变量或表达式，也可对他们格式化输出。

'''
一般格式：
print([obj1,obj2,...][,sep=''][,end='\n'][,file=sys.stdout])
其中：
obj1,obj2,...：输出对象
sep：分隔符，即参数obj1,obj2,...之间的分隔符，默认''(为空)
end:终止符，默认为'\n'
file：输出位置，即输出到文件还是命令行，默认是命令行（终端）
'''

# 输出数字
>>> print(23)
23

# 输出字符串
>>> print('hello world')
hello world

# 输出列表
>>> print([1, 2, 3])
[1, 2, 3]

# 输出多个对象
>>> print("a = ", 8)
a = 8

# 修改分隔符为'-'
>>> print(123, 'abc', sep='-')
123-abc

# 修改终止符为空格' '
>>> print(123, 'abc', end='')
123 abc

使用print() 函数格式化输出

'''
一般格式为：
print("格式化字符串" % (变量、常量或表达式))
其中，格式化字符串中包含一个或多个指定格式参数，与后面括号中的变量、常量或表达式在个数和类型上一一对应。当有多个变量、常量或表达式时，中间用逗号隔开.
'''

print() 函数格式符及含义

符号	描述	符号	描述
%c	单字符（接收整数或单字符字符串）	%r	字符串（使用repr 转化任意 python 对象）
%s	字符串	%f 或 %F	格式化浮点数，可指定小数点后的精度，默认为 6 为小数
%d 或 %i	格式化整数	%e 或 %E	用科学计数法格式化浮点数
%u	格式化无符号整型	%g	%f 和 %e 的简写
%o	格式化无符号八进制数	%G	%F 和 %E 的简写
%x 或 %X	格式化无符号十六进制数小写/大写	%P	用十六进制数格式化变量的地址

>>> a = 100
>>> print("a = %d(十进制)" % a)
a = 100(十进制)
>>> print("a = %o(八进制)" % a)
a = 144(八进制)
>>> print("a = %x(十六进制)" % a)
a = 64(十六进制)

>>> b = 123.4567
>>> print("b = %f" % b)
b = 123.456700
>>> print("b = %8.2f" % b)
b = 123.46

"""
%8.2f:指精确到 2 位小数，且输出宽度为 8 位，默认以空格填充，可以复制下面的代码在编辑器中运行体验

a = "%8.2f" % 123.4567
print(a)
print(len(str(a)))
"""

>>> print("b = %e" % b)
b = 1.234567e + 02

>>> print("字符串: %s" % "tiger")
字符串: tiger
>>> print("字符: %c" % "a")
字符: a

>>> print("它的名字是%s，它今年%d岁了" % ("hally", 2))
它的名字是hally，它今年2岁了

写在最后：
首先，如果本篇文章有任何错误，烦请读者告知！不胜感激！
其次，本篇文章仅用于日常学习以及学业复习，如需转载等操作请告知作者（我）一声！
最后，本文会持续修改和更新，如果对本分栏的其他知识也感兴趣，可以移步目录导航专栏，查看本分栏的目录结构，也更方便对于知识的系统总结！
感谢！笔芯！