Python 全方面基础知识总结

技术百科

admin

发布时间：2024-03-22

浏览：54 次

1、Python 简介

Python 是一门简单易学的，面向对象的，解释型的脚本语言，也是一种开源的、可移植性强的、可扩展性强的高级编程语言，常用于科学计算与人工智能、WEB 开发、金融、云计算等领域。

最近几年来，随着大数据和人工智能的流行，因简单易学、面向对象、以及有丰富的第三方库支持，Python 作为一门解释型的语言也流行了起来，甚至一度呈现出碾压 Java 老大哥的趋势。当然，多掌握点技术对自己来说并不算什么坏事，因此我也开始步入了 Python 的世界，希望在以后能更加深入的开阔自己的眼界，毕竟人生苦短，多用多学 Python。

Python 目前有两个主流的版本方向，Python2.x和Python3.x，鉴于官网2020年对 Python2.x 停止了更新，Python2.7 也正式成为了最后一个Python2.x的版本。对于学习和使用者来说，Python3.x 才是更合理的选择，去官网看看，可下载自己需要的版本，官网链接：https://www.python.org/。

2、Python 下载、安装与使用

我选择的是3.8.5版本，选择 windows，x86-64是64位的下载，下载时注意以下文件的区别：

web-based installer：需要通过联网完成安装；executable installer：通过可执行文件(*.exe)方式安装（推荐此种类型）；embeddable zip file：嵌入式版本，可以集成到其它应用中。

安装的话，基本是傻瓜式的。如果之前安装过Python其他版本，在系统属性-环境变量中，去掉之前版本的相关环境变量配置；安装过程中，选择自定义安装，最好指定目录安装，勾选安装选项中的“添加环境变量”，“预编译标准库”等选项；

安装成功后，验证方式有：

打开 CMD，输入python -V 或 python --version，输出版本信息正常即可；打开系统属性-环境变量，查看用户变量的 path 是否存在安装目录和scripts目录。

Python 是一门动态解释型的执行语言，无需编译，定义了后缀为.py的文件，在安装了 Python 环境的机器上去执行，使用 python xx.py 命令即可。

常用的编辑器，推荐一下：

CMD：

自带IDLE：

其他编辑器

基础的编辑器可以用：notepad++，当然，还可以使用：

Eclipse + PyDev （插件：https://www.pydev.org/）Sublime Text （ http://www.sublimetext.com）Atom （https://atom.io/）Visual Studio Code （https://code.visualstudio.com/）PyCharm （https://www.jetbrains.com/pycharm/）

3、Python 的数据结构

Python有六种标准数据类型：数字number、字符串str、元组tuple、列表list、集合set、字典dict，而从数据的可变性角度来看，又可分为：不可变的数据类型（数字、字符串、元组）和可变的数据类型（列表、集合、字典）。

<1>、数字类型（Number）

Python 不像 Java 或 C 语言那样会有整型（有的还分为长整型、短整型等）、浮点型、布尔类型等之分。在 Python 的世界里，整型（int）、浮点型（float）、布尔（bool）、复数（complex）都统称为数字类型，在定义变量时，会根据赋值自行推断类型，不需要指定数据类型。

举例说明：

# 多个变量相同数字类型 x = y = z = 10 # 多个变量不同数字类型 a, b, c, d = 52, 3.14, True, 3+4j

当然，也可以通过 Python 内置函数 type() 或 isinstance 来获取或判断变量的类型：

# 获取变量的类型 print(type(a), type(b), type(c), type(d)) <class int> <class float> <class bool> <class complex> # 判断变量额类型 isinstance(a, float) #False isinstance(b, float) #True

<2>、字符串类型（String）

用过 Python2.x 版本写脚本的都知道，字符串是一个很头疼的东西，需要考虑编码，而且使用 print 打印的字符串经常需要转成 unicode才可以输出，这一切在 Python3 做出了重大的改变，因为 Python3 的源码文件默认以 UTF-8 编码，所有字符串默认都是 unicode 字符串。

字符串需要用单引号或双引号表示，支持转义字符，支持对字符串的一系列基本操作：（比如，字符串截取，重复，连接，格式化，逆序，其他操作符等）

str = hello,world!\n # 取值,下标从0开始，使用切片格式进行字符串截取操作 print(str[0]) #h print(str[0:-1]) #hello,world! print(str[0:len(str)-1]) #hello,world! print(str[::]) #hello,world! print(str[0:5:1]) #hello # 字符串连接 print(str[2] + str[4] + str[9]) #lol # 字符串重复 print(str[0]*2) #hh # 字符串格式化 % #你今年10岁了,你想说的话是:hello print("你今年%d岁了,你想说的话是：%s"%(10, str[0:5])) # 字符串逆序 print(str[::-1]) #!dlrow,olleh # 转义字符如果需要输出，加上r或R即可 print(rhello,world!\n) #hello,world!\n # 其他操作符：in/not in print(hello in str) #True

Python3.6 以上版本增强了字符串的格式化操作，使用f-string完全可以替代用%进行格式化，此外Python3.8+ 还支持表达式的输出，如下：

# Python3.6以上版本 ss = "world" print(fhello, {ss}) #hello, world print(f{2+3}) #5 # Python3.8+版本 print(f{2+3=}) #2+3=5

Python 内置模块也提供了许多操作字符串的 API，常见的 API 有：

str(xx)：xx转成字符串类型；len(str)：计算字符串长度；count(str,start, end)：返回指定范围内str在字符串string出现的次数；startswith(str,start, end)：在指定范围字符串string内是否存在str开头，存在返回True，否则返回False。endswith(str,start, end)类似。upper()：字母转大写，lower():字母转小写。isdigit()：字符串是否全部为数字；islower()：字符串是否全部小写；spilt()：分割字符串；replace(old, new)：替换字符串；

<3>、元组类型（Tuple）

用(value1,value2,...valueN)形式定义元组，元素可以是任意类型，若一旦被创建将，不能被修改。元组的基本操作也很简单，有切片取值、遍历、删除等。

#定义一个空元组 tup = () #定义只有一个元素的元组，不能少了逗号, tup1 = (2022, ) # 定义包含多种类型元素的元组 tup2 = (2022, 5.20, 中国加油, tup1, [123,abc], {"key1":True}) print(type(tup2)) #<class tuple> # 使用切片操作元组 print(tup2[1:3]) #(5.2, 中国加油) # 操作符判断 print(2022 in tup2) #False #遍历元组,依次输出每个元素 for i in tup2: print(i,) #删除 del tup1 print(tup1) #报错 Traceback (most recent call last): File "dataType.py", line 24, in <module> print(type(tup1)) NameError: name tup1 is not defined #常用函数 s = hello print(len(tup2)) #6 # print(max(tup2)) #元素相同类型才可使用max、min函数取最值 # print(min(tup2)) print(tuple(s)) #(h, e, l, l, o)

上面的三种类型都有一个共同点，即元素被创建后具有不变性，特别注意元素不能被修改。比如，上面的字符串使用 str[0]=k 赋值修改元素是不合法的；上面的 tup2[0]=2022 赋值修改元素也是不合法的。

<4>、列表类型（List）

列表类型使用[value1,value2,...valueN]形式定义，列表元素存储是有序的且可重复的。与元组定义一样，列表元素可以是任意类型，不同的是，列表元素是可以被修改的，基本操作如下：

#定义两个列表 list1 = [2022] list2 = [2022, 5.20, 中国加油, list1, [123,abc], {"key1":True}] print(type(list2)) #<class list> print(list2[1:3]) #[5.2, 中国加油] #遍历列表，依次输出每个元素 for i in list2: print(i) #常用函数 s = hello print(list(s)) #[h, e, l, l, o] print(len(list2)) #6 list2.append(True) #[2022, 5.2, 中国加油, [2022], [123, abc], {key1: True}, True] print(list2) #移除list1, list2.remove(list1) print(list2) #[2022, 5.2, 中国加油, [123, abc], {key1: True}, True] list3 = list2.copy() print(list3) #[2022, 5.2, 中国加油, [123, abc], {key1: True}, True] #反转列表 list3.reverse() print(list3) #[True, {key1: True}, [123, abc], 中国加油, 5.2, 2022] #修改元素 list3[0] = False print(list3) #[False, {key1: True}, [123, abc], 中国加油, 5.2, 2022]

<5>、集合类型（Set）

使用set()函数或 {value1,value2,...valueN}形式定义集合，集合元素存储是无序的但不能重复。基本操作如下：

# 定义集合，空集合不能使用{}定义，它默认表示的是字典 print(type({})) #<class dict> print(set(2022)) #{2, 0} print({2022,5.20,中国加油}) #不支持列表、集合、字典 print(type(set2)) #<class set> #遍历，输出：3.14 True abc 123 for i in set2: print(i, end= ) # 定义的集合，要保证元素是相同的 print(set(abcdefg)) #{e, b, f, g, c, a, d} print(set(["a","b","c"])) #{b, c, a} print(set(("a","b","c"))) #{b, c, a} #常用函数：元素增删，集合求交并差集等 st=set(("a","b","c")) st.add(d) #追加元素 print(st) #{d, a, c, b} st1 = st.copy() #拷贝 print(st1.issubset(st)) #True 子集判断 st.pop() #随机移除元素 print(st) #{d, c, b} print(st1.intersection(st)) #求交集 {d, c, b} st.remove(c) #指定移除元素，该元素不存在抛异常 print(st) #{b, d}

<6>、字典类型（dict）

使用{key1:value1, key2:value2,...keyN:valueN}形式定义字典，类似于Java的Map，字典元素存储是键值对。基本操作如下：

dicts = {key1:150,key2:0.99,1:True,2:2} # 访问 print(dicts[key1]) #150 print(dicts[1]) #True #修改 dicts[key2] = 0.88 print(dicts[key2]) #0.88 #遍历 for d in dicts: print(d, end=,) for k,v in dicts.items(): print(k,v) #删除key del dicts[key1] #清空字典 dicts.clear()

4、Python 流程控制语句

Python 流程控制语句也很简单，但与 Java 的流程控制语句相比会有许多不同之处，这里流程控制语句主要有条件语句、循环语句等。条件语句指的是if条件语句，Python 是没有swith-case语句的；循环语句的话，指的是for循环和while循环，Python 是没有do-while循环的，不过for循环和while循环都是可以带有else语句的，表示循环条件不满足时执行else语句。

<1>、条件语句

# if条件语句举例 str = hello,world!\n if h in str: print(字符串包含h) elif d in str: print(字符串包含d) else: pass #不做任何事情，一般用做占位语句

<2>、循环语句

while 循环，举例：

a = 5 b = 5 while a < 10: a = a + 1 #python没有a++或a--运算符 b = b - 1 if b >= 2: if a == 8: continue #跳出当前循环进入下一次循环，break则是终止当前循环 print(a, end= ) else: print(\n----------+str(a)) 6 7 ----------10

for循环，举例 9*9乘法表：

for i in range(1, 10): for j in range(1, i+1): print("{}x{}={}\t".format(j, i, i*j), end=) print() 1x1=1 1x2=2 2x2=4 1x3=3 2x3=6 3x3=9 1x4=4 2x4=8 3x4=12 4x4=16 1x5=5 2x5=10 3x5=15 4x5=20 5x5=25 1x6=6 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36 1x7=7 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49 1x8=8 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64 1x9=9 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81

Python 似乎精简了流程控制语句中的许多东西，使用起来更加的简便，而实际上，for 循环经常还会和迭代器、生成器一起使用，这里不再说明，在 Python 进阶知识总结再进行梳理。

5、Python 函数的概念

Python 也是一门支持函数式编程的语言，而函数式编程的特点为：支持非纯函数式编程、支持闭包、支持高阶函数、及有限度的支持匿名函数。作为入门的知识点，先梳理下 Python 函数的基本概念。

Python中的函数定义也很简单，如图所示：

函数定义：

通过def关键字标识，入参可以无参也可以有参，函数体内可以有返回值也可以没有返回值；入参的话，写在()内，注意一些特殊传参，比如*args，**kwargs等可变长参数，它们的区别在于：*args传入元组类型，可有多个，**kwargs传入字典类型，也可有多个；书写函数需要注意行的缩进，注意英文冒号:不要遗漏等；

参数传递：

不可变类型参数传递 (如数字、字符串、元组等类型)，本质是按值传递。

def fun1(a): a = 5 return a a1 = 10 fun1(a1) print(a1) #10

可变类型参数传递 (如列表、集合、字典等类型)，本质是引用传递。

def fun2(a): a.append(2022) values = [True, 3.14, (28,)] fun2(values) print(values) #[True, 3.14, (28,), 2022]

注意：函数也能作为参数进行传递的，这就是高阶函数的特征，后面进阶总结时再详细说明。

变量作用域：

模块内存在两种类型的变量，即局部变量和全局变量，通常以变量是否声明在函数体内来区分局部变量和全局变量。如果需要在函数体内定义全局变量，需要加上global关键字声明。

a = 0 b = 0 def fun3(): global a #注意不能这样写：global a = 1 a = 1 def fun4(): b = 1 fun3() print(a) #1 fun4() print(b) #0

6、Python 异常处理

Python 作为一门高级语言，也有着自己的一套异常处理机制。如果代码里没有任何捕获异常处理，Python 会调用默认的异常处理器处理。程序运行前，不管你是否是类型错误(TypeError)，还是名称未定义(NameError)，还是数组越界(IndexEoor)等其他异常，首先都会进行语法错误(SyntaxError)检查，例如：

x = 0 print(--- + x) #属于类型错误 print(y) #属于名称未定义错误 #属于语法错误 print("我是小小)

常见的 SyntaxError 有：

#SyntaxError: Missing parentheses in call to print. print hello,world! #SyntaxError: invalid syntax ，缺少冒号： if True pass #SyntaxError: invalid syntax ，应该用==判断 x = 0 if x = 0: pass #SyntaxError: EOL while scanning string literal print("我是小小)

因此，平时需要多注意规范书写，避免低级的语法错误。在 Python 的世界里，运行期间检查到的错误称为异常，大多数的异常都不会被程序去处理，而是以错误的形式展示出来，大多数的异常的名字都以"Error"结尾，和标准的异常命名一样。

Python 有三种异常处理结构：即 try...except...finally语句块、assert 断言和 with 语句。

<1>、异常代码块

Python 也可以主动捕获异常，捕获异常的代码块完整结构及相关用法，如下所示：

try: #执行代码 execept Exception as e: #打印异常信息 print(e) #可以指定具体异常去捕获，也可以写范围更大的异常，如Exception #该部分可省略，异常时执行的代码，会抛出异常信息 raise e execept Exception1 as e1: #可以抛出多个异常 print(e) else: #该部分可省略，未发生异常时执行的代码 finally: #该部分可省略，无论是否发生异常，一定会执行（除非程序退出/中断）

<2>、assert断言

断言，是一种判断表达式，当表达式结果为False时会触发异常，完整的断言语法为：

assert expression [,args] # 等价于： if not expression: raise AssertionError(args)

举例说明：

assert 1==2 , 你两不合适，没有相等！ #运行结果 D:\XXX\demo>python a.py Traceback (most recent call last): File "a.py", line 3, in <module> assert 1==2 , 你两不合适，没有相等！ AssertionError: 你两不合适，没有相等！

<3>、with语句块

像 Java 语言异常处理时，使用异常语句块书写的代码显得特别的臃肿，然而 Python 异常处理的话，除了可以使用try...except...finally语句块外，还可以使用with语法，如果对比二者的代码量，一定会为 Python 代码的短小而精简震撼，以使用游标查询数据来举例说明：

try...except...finally：

try: conn = getconnection() sql = select * from t cursor = conn.cursor() cursor.execute(sql) print(cursor.fecthall()) except Exception as e: print(e) cursor.rollback() #异常时回滚 raise e #捕获异常 finally: #释放资源 cursor.close() conn.close()

with...as语句：

with getconnection().cursor() as cursor: cursor.execute(select * from t) print(cursor.fecthall())

with 语句强大之处在于，不用我们再去手动捕获异常，不用再去一个个close资源连接，将这一系列的工作都交给了 Python 内部去处理。with 语句在操作文件读写，操作数据库等方面很实用，推荐使用。

7、Python 文件读写操作

os 模块是 Python 的内置模块，它提供了很多的 API 方法用来操作目录和文件，我们可以在 Python 安装目录找到 doc，里面可以找到 os 模块的文档说明，os 模块的主要用途如下：

要进行文件读写操作的话，使用open()函数;要操作文件属性及路径的话，使用os.path模块;要读取命令行中文件的话，使用fileinput模块；要操作临时目录或文件的话，使用tempfile模块；更高级的目录或文件操作，使用shutil模块。

这里，重点说明下文件的读写操作。在计算机的世界里，文件后缀的格式多不胜数，我们只需要知道常见的文件格式就行，比如：.txt、.log、.json、.csv、.xls/.xlsx、.doc/.docx、.ppt、.xml、.yml等。

< 1 > 、文件读写API

读写文件的方法为open()，通常有两种写法：

#默认, mode=r f = open(filename) #指定 f = open(filename, mode [,encoding=utf-8 ,...])

模式 mode 参数有：

文件读取操作有关的方法有：

f.read()：读取文件内容；f.readline(size)：读取一行，size表示读取该行多少个字符；f.readlines()：读取文件所有的行,以列表的形式返回；f.tell()：返回文件当前的位置；f.seek(offset[, whence])：移动文件读取指针到指定位置，offset：开始的偏移量，whence：0 从文件开头开始算起，1 从当前位置开始算起，2 从文件末尾算起；f.close()：关闭文件，释放资源。

文件写入操作有关的方法有：

f.write(str)：将字符串写入文件，返回的是写入的字符长度；f.writelines(sequence)：向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符；f.flush()：刷新文件内部缓冲，直接把内部缓冲区数据立刻写入文件, 而不是被动等待输出缓冲区写入。

普通的 open() 操作，无论读写，在最后都要使用 close() 方法手动关闭连接，这一点不要忽略了。而如果使用的是 with open() 语法形式，则不需要手动去关闭，举例说明：

#写入 with open("D:\\XXX\\test.txt", a+, encoding=utf-8) as wf: tell = wf.tell(); wf.write("\n当前位置：杭州市西湖区留下街道梦溪街") tell2 = wf.tell(); if tell2 > tell: print("写入成功！") if wf.closed == False: print("--------测试---------" ) wf.close() print("文件是否关闭：" , wf.closed) #读取 with open(D:\\XXX\\test.txt,r,encoding=utf-8) as rf: context = rf.readlines() if rf.closed == False: print("-------测试----------" ) rf.close() print("文件是否关闭：" , rf.closed) print("文件文本内容：" , context)

执行结果：

< 2>、读写.txt/.log文件

使用上面的有关的API即可实现，比较简单。

< 3>、读写.json文件

第一步：导入json模块；第二步：借助该模块dump()实现写入文件功能， load()实现读取文件功能；更多API可以参考：https://docs.python.org/zh-cn/3/library/json.html 。

举例说明：

import json dicts = {a:100, b:200, c:300} with open(D:\\XXX\\response.json, a, encoding=utf-8) as wf: json_str = json.dump(dicts, wf) print(json_str) print(type(json_str)) with open(D:\\XXX\\response.json, r, encoding=utf-8) as rf: json_obj = json.load(rf) print(json_obj) print(type(json_obj))

执行结果：

< 4>、读写csv文件/excel文件

csv文件已在上面的演示中用过了，不再举例。excel文件与csv文件看上去很相似，但依赖的模块和操作却不一样，excel文件的后缀是.xls 或 .xlsx，有许多模块支持 excel 的读写操作，比如：

openpyxl ：A Python library to read/write Excel 2010 xlsx/xlsm files；xlrd + xlwt + xlutils ：三个模块搭配使用，对excel读写和复制等操作。

这里，使用 openpyxl 模块，使用pip命令下载：

pip install openpyxl

举例说明：

from openpyxl import load_workbook,Workbook #write excel excelName = D:\\XXX\\test-write-0605.xlsx lwb = Workbook() print("开始写入......") #激活sheet，默认sheet，以后新增sheet1，sheet2...... ws = lwb.active tableHeader = [姓名,年龄,身份证号码,现居住地,原籍所在地,联系电话] for c in range(len(tableHeader)): col = c + 1 ws.cell(row=1, column=col).value = tableHeader[c] tableBody = [[魏详详,27,341226199203071600,杭州市,颍上县,15077925650],[魏详详1,28,341226199203171604,杭州市,颍上县江口镇,15077925655]] for r in range(len(tableBody)): ws.append(tableBody[r]) lwb.save(excelName) print("写入完成！！！") #read excel wb = load_workbook(D:\\XXX\\20210605.xlsx) print("开始读取......") #获取所有的sheet #sheetList = wb.get_sheet_names() sheetList = wb.sheetnames print("sheetList: " + str(sheetList)) #获取第一个sheet #currentSheet = wb.get_sheet_by_name(sheetList[0]) currentSheet = wb[sheetList[0]] print("title: " + str(currentSheet.title))#sheet名称 print("max_row: " + str(currentSheet.max_row))#最大行数 print("max_column: " + str(currentSheet.max_column))#最大列数 #读取第一个sheet, 逐行按单元格读取 lineList=[] for i in range(2, currentSheet.max_row+1): for j in range(1, currentSheet.max_column+1): cellValue = currentSheet.cell(row=i, column=j).value lineList.append(cellValue) print("读取完成！！！") print("结果：" + str(lineList))

执行结果：

日志：

需要注意，读写excel时，单元格的坐标位置起始值是（1,1），load_workbook用于写excel、Workbook用于读取excel。更多API参考：https://openpyxl.readthedocs.io/en/stable/index.html#。

<5>、读写Word文件

Word 文件的后缀有.doc 和 .docx 格式，以下模块支持 word 文档的读写：

python-docx ：只支持.docx 格式，但可以将 .doc 转成 .docx 格式，从而间接支持 .doc 格式；（API参考：https://python-docx.readthedocs.io/en/latest/index.html）win32com ：调用系统的word功能，可以同时支持.doc 和 .docx 格式。

这里，使用 wun32com模块，使用pip命令下载：

pip install pywin32

我们能如此方便的调用 Word，得益于其底层的 COM（组件对象模型）可以被任意语言调用，操作 word 时需要知道以下对象：

Application ：表示Word应用。包含了菜单栏、工具栏、命令以及所有文档等；Documents ：表示文档，可有多个。有打开Open()、创建Add()等API；Selection ：表示当前窗口的光标焦点或选择范围。有输入TypeText()、复制Copy()、粘贴Paste()、删除Delete()、全选WholeStory() 、左移MoveLeft()、右移MoveRight(start, end)等API；Range ：表示连续区域，用于区分文档不同位置，Range(0, 0)表示开始位置，Range()表示文末位置。对 Selection 和 Range 也可以设置字体 Font、设置段落 ParagraphFormat 、设置 PageSetup、设置样式 Styles等。

举例1 ：创建Word文档，并转储到txt文件中

import win32com import win32com.client #wordPath = D:\\XXX\\SpringCloud学习笔记.docx txtPath = D:\\XXX\\转储创建的word文档1.txt app = win32com.client.Dispatch(Word.Application) #显示word app.Visible = True #创建word，并插入文字 doc = app.Documents.Add() contxt1 = doc.Range(0, 0) contxt1.InsertBefore(Hello word\n) contxt2 = doc.Range(10, 11) contxt2.InsertAfter(我是魏详详\n) contxt3 = doc.Range() contxt3.InsertAfter(\n updatetime: 20210605) #转储到其他文件:2为txt， doc.SaveAs(txtPath, 2) print("文件转储成功！！！") #关闭word doc.Close() app.Quit()

转储txt内容：

举例2 ：读取Word文档，并转储到txt文件中

import win32com import win32com.client wordPath = D:\\XXX\\SpringCloud学习笔记.docx txtPath = D:\\XXX\\SpringCloud学习笔记.txt #打开office app = win32com.client.Dispatch(Word.Application) #打开word word = app.Documents.Open(wordPath) #打印word内容 for i in word.Paragraphs: line = i.Range.Text print(line) #转储到其他文件:2为txt， word.SaveAs(txtPath, 2) print("文件转储成功！！！") #关闭word word.Close() #关闭office app.Quit()

<6>、读写其他文件

文件类型那么多，不可能面面俱到的去演示读写操作的，从上面的Demo可以看到通用的思路如下：

要先明确是否需要导入模块，可以自行百度或去pip官网进行依赖查询；尽量找到详细可参考的文档读写操作API，并亲测该方法的功能后再使用；

8、Python 模块

Python 流行而强大之处在于支持丰富的第三方库，这为实现很多的拓展功能提供的可能。通常使用 pip 命令安装需要的第三方模块，但使用 pip 命令之前，请确保机器上安装了 Python 环境，并在环境变量中配置了 Scripts 目录。

pip 支持的第三方模块，可以去官网查询相关依赖：https://pypi.org/ 。当然，有必要了解下 pip 的相关命令：

pip list：查看已安装的第三方模块pip install模块名：安装第三方模块pip show --files 模块名：查看是否已安装的模块信息pip list --outdated：检查哪些模块名需要更新升级pip install --upgrade 模块名：更新升级第三方模块pip uninstall 模块名：卸载第三方模块pip --help：帮助命令

以图像处理模块（Pillow）为例，演示：

第一步，先下载该模块：

pip install Pillow

第二步，查看该模块的详细信息：

pip show --files Pillow

之后便可以愉快的使用 Pillow 模块提供的API了~~

这里需要注意区分：Python 自带模块与第三方模块？

Python自身带有内置的模块供开发者使用，在安装的时候勾选了文档的话，可以通过提供的文档查看有哪些内置模块：http://localhost:57952/ 。第三方模块的话，需要额外去下载才能被使用，可以先查询是否存在再下载或者升级。

不论是自带模块，还是第三方提供的模块，导入的方式有下面几种：

#用法1：分行导入模块 import module1 import module2 import moduleN #用法2：一行导入模块 import module1 [,module2 ,module3, ...,moduleN] #用法3：可以导入模块中所有内容（除了私有的变量/函数） import module from name1[,name2 ,name3, ...,nameN] #用法4：可以导入模块中所有内容（除了私有的变量/函数），不推荐使用* import module from * #用法5：导入模块中需要的内容 import module from name1,name2

值得注意的是用法4，可以使用但不推荐。使用*导入模块中所有的内容，这里会把私有变量和私有函数除外的所有变量/函数/类等导入，容易造成混乱，也可能会覆盖当前模块的同名变量或同名函数，所以要注意这类规范。

Python 模块很简单，深入起来也有点东西，下面是我学习过程中遇到的问题及思考过程，也顺便记录下。

思考一个问题，在一个模块中，我们使用了其他很多的模块也存在的变量或函数，为什么在这个模块中能正常使用而不发生冲突呢？

这是因为 Python 中的每个模块都拥有各自独立的符号表，每个模块中的所有函数都会在符号表中被当做全局符号使用，每个模块间的全局变量相互是隔离的，因此能正常使用。

再思考一个问题，比如当前模块A要引入模块B或模块B中指定的变量或函数，在第一次运行程序时，模块B中的变量或函数会放到模块A中的符号表中，那我怎么保证模块B的某段代码块不会再模块A中被执行呢？

这个问题的答案发现是我之前疑惑已久的问题，那就是为什么类的模块里经常要写以下代码呢：

if __name__==__main__: pass

其实，__name__属性是模块的私有属性，通过 __name__==__main__: 能控制某些代码块只在本模块内会被使用，不会在引入该模块的模块里使用！

接着，思考更复杂的一些问题。假设存在以下目录结构：（src下有两个模块mod1.py和mod2.py、两个包p1和p2，而p1包和p2包又存在各自的模块，p1包下为mod.py和mod1.py，p2包下为mod.py和mod2.py）

<1>、导入平级目录的模块

在src目录下的mod1.py中导入src下的mod2.py（同级目录的模块引入），直接按模块名称导入即可。如果当前模块mod1存在与模块mod2的同名变量或同名函数时，使用导入模块名.变量或导入模块名.函数区分。

mod2.py ：

a = 3.14 def m1(): print(-----mod2模块的m1()----->+str(a)) def m2(): print(-----mod2模块的m2()-----) if __name__==__main__: print(不会输出到其他模块！！！)

mod1.py ：（测试）

import mod2 a = 3.14 def m1(): print(-----mod1模块的m1()----->+str(a)) def m2(): print(-----mod1模块的m2()-----) print(a) print(mod2.a) print(m1()) print(mod2.m1()) print(m2()) print(mod2.m2())

结果：

<2>、导入下级子目录模块

在src目录下的mod1.py中导入p1包下的mod.py（父包引入子包），这里使用包名.模块名导入即可，包可以理解为Python管理模块命名空间的方式，最好在该包下加入__init__.py模块标识。如果当前模块mod1存在与模块mod的同名变量或同名函数时，使用导入包名.模块名.变量或导入包名.模块名.函数区分。

p1包下的mod.py

pi = 3.14 def m1(): print(-----p1包mod模块的m1()----->+str(pi)) if __name__==__main__: print(测试1：不会输出到其他模块！！！) print(测试2：会输出到其他模块！！！)

mod1.py ：（测试）

import p1.mod as pmod a = 3.14 def m1(): print(-----mod1模块的m1()----->+str(a)) print(m1()) print(pmod.m1())

结果：

<3>、导入上级父目录模块

在p2包下的mod2.py中导入src目录下的mod2.py（子包引入父包），使用 import src.mod2 as smod2 方式会报错：ModuleNotFoundError: No module named src 。

p2包下的mod2.py：（测试，报错！！！）

import src.mod2 as smod2 a = 3.14 def m1(): print(-----p2包下mod2模块的m1()----->+str(a)) print(a) print(smod2.a) print(m1()) print(smod2.m1())

这里，我接着测试了p2包的mod2模块导入p1包的mod模块（兄弟包模块引入），报错： ModuleNotFoundError: No module named p1 。

额，这结果太让人疑惑了，我在想上面这两报错种情况的出现，应该是与Python搜索模块的机制有关系的，那有必要搞清楚Python搜索模块的顺序：

优先搜索内置模块（上面的自定义模块不属于内置模块）接着搜索sys.path（打印出来sys.path都有哪些东西？）

#当前所在位置p2目录 import sys print(sys.path) #返回一个列表 [D:\\XXX\\src\\p2, #自定义模块在的目录 D:\\Python38\\python38.zip, #标准库的目录 D:\\Python38\\DLLs, D:\\Python38\\lib, D:\\Python38, D:\\Python38\\lib\\site-packages, #第三方扩展模块的目录 D:\\Python38\\lib\\site-packages\\win32, D:\\Python38\\lib\\site-packages\\win32\\lib, D:\\Python38\\lib\\site-packages\\Pythonwin]

可以看到，列表返回的搜索顺序为：

自定义模块所在的根目录，这里是p2包；标准库的目录；最后是site-packages，即第三方扩展模块的目录；

由此可以清晰的看到，对于自定义模块所在的包会成为根目录，而根目录是没有父目录或者兄弟目录的，这就解释了为什么子包引入父包、兄弟包之间引用会报错找不到父包找不到兄弟包。因此，平时引用自定义模块时应当避免这些情况的发生，做到规范引入模块！！！

最后呢，值得关注下__init__.py模块的作用，前面提及到该模块是为了标识当前目录是一个包，能够避免影响到搜索路径中的有效模块，这也是一种约定俗成的规范吧。有时候该模块可能会定义一个__all__的私有变量，那么它是干嘛用的呢？

比如有一个场景：使用from p2.mod import * ，预期的结果是将自定义p2包下mod.py模块的所有的非私有变量/函数全部引入到了当前模块里，假如内置模块或标准库也存在p2包及包下的mod.py模块，那么进行搜索路径模块时可能就无法区分是否来自于自定义模块了。

此时，通过自定义包p1下的__init__.py模块维护一个__all__变量，里面存放着该包下的所有模块列表，当搜索路径模块时根据它就能唯一确定模块的位置了。__all__变量定义如下：

__all__ = [mod.py, mod1.py]

当该包发生更新时（如修改模块名称，或新增模块名），记得维护下这个变量的列表内容！！！

模块很简单，深入起来也有点东西，通过深入了解后，总结一下几个值得注意的规范：

慎用 import module from * 方式导入；引入包的模块时，避免引入它的父包和兄弟包下的模块；自定义包下最好定义一个__init__.py模块，该模块里最好定义一个__all__变量，当该包更新时及时维护__all__变量；Python搜索路径模块的大致顺序为：内置模块 > 自定义模块 >环境变量目录下的模块 > 标准库目录下的模块 > 第三方扩展目录下的模块等，尽量不要在除了自定义模块目录外的其他目录下定义包或模块。

Python 基础知识的总结，就到这~

上一篇 : 什么是Google海外营销

下一篇 : 如何从 WordPress 中的静态资源中删除查询字符串

Python 全方面基础知识总结

1、Python 简介

2、Python 下载、安装与使用

CMD：

自带IDLE：

其他编辑器

3、Python 的数据结构

<2>、字符串类型（String）

<3>、元组类型（Tuple）

<4>、列表类型（List）

<5>、集合类型（Set）

<6>、字典类型（dict）

4、Python 流程控制语句

<1>、条件语句

<2>、循环语句

5、Python 函数的概念

函数定义：

参数传递：

变量作用域：

6、Python 异常处理

<1>、异常代码块

<2>、assert断言

<3>、with语句块

try...except...finally：

with...as语句：

7、Python 文件读写操作

8、Python 模块

<1>、导入平级目录的模块

结果：

<2>、导入下级子目录模块

结果：

<3>、导入上级父目录模块

相关推荐

关于明升M88博彩

明升M88博彩新闻

客户案例

联系我们

在线咨询

免费通话

微信扫一扫