Python 全方面基础知识总结

技术百科 admin 发布时间:2024-03-22 浏览:17 次

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 基础知识的总结,就到这~

在线咨询

点击这里给我发消息售前咨询专员

点击这里给我发消息售后服务专员

在线咨询

免费通话

24h咨询:400-888-8888


如您有问题,可以咨询我们的24H咨询电话!

免费通话

微信扫一扫

微信联系
返回顶部