Python 程序结构及代码规范_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') #文件路径换成自己的

1
2
3

运行结果如下：

此时我们再次查看源代码文件路径，发现多出了 一个 __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)    # 输出
1
2
3
4
5
6
7
8
9
10
11

从上例可以看出，一个完整的 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()
1
2
3
4
5
6
7
8
9
'
运行
运行

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

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

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

# demo_2_import

import demo2
demo2.printhello()
1
2
3
4

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

>>> hello,这是函数
1

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

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

print("__name__ 被执行")
printhello()
1
2
3
4
5
6
7
'
运行
运行

作为模块导入后的结果：

>>> __name__ 被执行
>>> hello,这是函数
>>> hello,这是函数
1
2
3

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

3、编码规范

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

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

必须遵循的规则：

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

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

import keyword
print("Python 中的保留字:", keyword.kwlist)
1
2
'
运行
运行

3、注释

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

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

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

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

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

代码    # 注释
# 代码
1
2

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

# 注释
# 注释
# 注释

'''
注释
'''

"""
注释
"""
1
2
3
4
5
6
7
8
9
10
11
'
运行
运行

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

• 首先选中需要注释掉的代码
• 在 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
1
2
3
4
5
6
7
8
'
运行
运行

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

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

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

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

a = 1.2; b = 2.3; c = a + b
1
'
运行
运行

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

import math
             # 空行
语句块1

语句块2
1
2
3
4
5

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

• 导入整个模块

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

• 导入模块的单个对象

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

from os import mkdir as mk
c = mk(xxx)
1
2
3
4
5
6

• 导入模块的多个对象

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

• 导入模块的全部对象

from 模块 import *
from math import *
1
2

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   # 注意此句 = 两边不要留空格
1
2
'
运行
运行

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'
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
'
运行
运行

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形式解码:  你好
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4、输入输出函数

input()：输入函数

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

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

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

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

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

# 类型转换
a = int(input('请输入一个整数:'))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

print()：输出函数

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

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

# 输出数字
>>> 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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

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

print() 函数格式符及含义

>>> 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岁了
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

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