当前位置:   article > 正文

Python 程序结构及代码规范_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 文件。
在这里插入图片描述

  1. 优化代码文件
    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
'
运行
FalseNoneTrueand
asassertbreakclass
continuedefdelelif
elseexceptfinallyfor
fromglobalifimport
inislambdanonlocal
notorpassraise
returntrywhilewith
yield

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() 函数格式符及含义

符号描述符号描述
%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岁了
  • 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

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

本文内容由网友自发贡献,转载请注明出处:【wpsshop博客】
推荐阅读
相关标签
  

闽ICP备14008679号