python每个模块用函数来实现_Python 模块，函数

目录

1、函数的基础知识

2、各类的特殊函数

3、getpass模块

4、time模块

5、datetime模块

6、random模块

7、os模块

8、sys模块

9、hashlib模块

10、logging模块

11、configparser模块

12、re模块

13、json模块

14、socket模块

15、subprocess模块

16、socketserver模块

17、tkinter模块

函数的基础知识

模块和包：

其实就是一个py文件，文件中存储了一些常用并且相似的功能函数

模块的导入：

1.import (module name) 导入模块中所有的函数

2.from (moudle name) import (function name) 导入模块中指定的函数，可以直接调用函数

3.from (moudle name) import * 导入模块中所有的函数，可以直接调用所有的函数，但是不推荐，因为容易变量重复

包内模块的导入：

from (package name) import （moudle name） 导入包中的模块

from (package name).(moudle name) import (function name) 导入包中模块中的指定函数，可以直接调用函数

模块的分类：

1.Python的标准库

2.第三方模块

3.在程序中自定义的模块

模块的优点：

1.提高代码的可维护性，当把不同的函数放进不同的模块中时，当你需要修改是时就会方便很多

2.将相似的代码封装在一个py文件中

模块和包关系：

模块就是把函数封装在一起

包就是把模块封装在一起

模块和包的区别：是否有__init__ .py 文件

注意：if __name__ == '__main__' 作用就是防止在调用别的py文件时，执行原文件中的测试代码

函数的作用（优点）：

1.减少代码的重写

2.保持一致性

3.增强代码的可扩展性（方便以后的修改）

函数的创建格式：

def【define（定义）】 函数名（形参）：

函数中的代码块

函数名的命名规则：

1. 只能由数字，下划线，字母组成，但是不能以数字开头

2.不能用Python的关键字命名

3.区分大小写，保证函数名具有一定的说明性

函数的参数：

形参：全称为形式参数是在定义函数名和函数体的时候使用的参数，目的是用来接收调用该函数时传递的参数。

必须参数： 按照形参的顺序，将实参传送个相应的形参

默认参数： 给形参赋值，就可以在调用函数的时候不用传入实参，默认参数总是放在形参的最后一位

关键字参数： 在调用函数的时候可以使用将实参直接赋值给形参的方法

不定长参数：1.加*，接受的实参为无命名参数，将输入的无命名实参存在为元组中，使用的时候可以for循环遍历取值，进行操作

2.加**，接受的实参为 有命名参数，将输入的格式类似键值对的实参，存在一个字典中，使用的时候也可以for循环遍历取值，进行操作

不定长参数的位置关系： *args 总是在**kwargs的左边的

实参：实参，actual parameters，全称为实际参数是在调用时传递给函数的参数，即传递给被调用函数的值。

函数的返回值（return）

return的作用：

1.结束函数

2.返回某个对象

注意：

1.当函数没有返回值（return）的时候，函数的返回值默认为None

2.如果return多个对象，那么Python会帮助我们把这多个对象封装成一个元组返回（其实返回的还是一个对象（元租对象））

函数的作用域

1、函数寻找变量的规则：LEGB

L：local 局部作用域，就是函数中定义的变量

E：enclosing 嵌套函数的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的，也就是说是两层函数中，外层函数的变量

G：global 全局作用域

B：bulit-in Python的一些内置的变量

注意：

1.局部作用域只能查看全局作用域的变量的值，但是不能修改全局变量的值

2.当你需要在局部区域中修改全局变量的时候，只需要在局部区域中，global声明变量即可

3.当在两层函数中，内层函数调用外层函数的变量的时候也是需要变量的声明的，（使用nonlocal声明）

4.只有模块，类，函数是有权利引入新的作用域的，if.for,while，没有权利引入新的作用域

各类的特殊函数

高阶函数

1.要知道一个函数的名字还可以作为另一个函数的参数的参数，如果将一个函数的名字作为另一个函数的实参传入那么这个函数就是一个高阶函数

2.函数名可以进行赋值

3.还可以作为函数的返回值

递归函数

至少满足两个条件

1.在函数的内部自己调用自己

2.必须有一个结束的条件

实例：

def jc(n): #求阶乘

if n == 1:return 1

return n * jc(n-1)print(jc(5))

注意：

1.在某些情况下，递归的效率是相当的低

2、要知道，只要是能递归解决的问题循环都能解决，但是递归不一定能解决循环能解决的问题

其实，装饰器，生成器，迭代器都是一种种特殊的函数

内置函数（built_in function）:

filter(function, sequence) ：

第一个参数为含有过滤条件的函数，第二个参数是一个序列，fliter循环遍历序列，将序列中的每个值作为function的参数传入，用function对sequence进行过滤，但是filter函数只能实现对序列中的值的过滤，不能进行操作，返回一个迭代器对象

map（function， sequence）：

第一个参数为含有过滤条件的函数，第二个参数是一个序列，fliter循环遍历序列，将序列中的每个值作为function的参数传入，用function对sequence进行操作，返回一个迭代器对象

filter和map函数的区别：filter函数不能对序列进行操作，只能进行过滤，但是map函数正好实现了对序列中的值进行操作这个功能

reduce（function，sequence）：

能够对序列进行一个叠加，或者类似阶乘的一个功能，方便实用，返回的就是一个值，返回值和filter，map不一样

实例：

importfunctoolsdefjc(x, y):return x *yprint(functools.reduce(jc, range(1, 6））

lambda函数：

用于函数式编程

实例：

importfunctoolsprint(functools.reduce(lambda x, y: x*y, range(1, 6))) #lambda函数作为一个参数传入reduce函数中

闭包现象：（closure）

1.有两层甚至多层函数

2.内层函数可以调用外层函数的作用域中的变量（这里指的并不是全局作用域，是enclosing）

满足这两个条件就将内层的这个函数称为闭包函数

装饰器：

在保证封闭原则的情况下，对原函数进行功能的扩展

importtimedef show_time(func): #装饰器函数

def inner(x, y): #闭包函数

start_time =time.time()print(func(x, y)) #如果原函数中的返回值使用return返回的，在装饰器函数中添加print函数

end_time =time.time()

run_time= end_time -start_timereturnrun_time#this is source function ,need add some new functions now

returninner

@show_time#对原函数名进行重新赋值 @show_time = (add = show_time(add))

def add(x, y): #原函数

result = x +y

time.sleep(3)returnresultprint(add(1, 3))

注意：

1.封闭原则：一个已经完成功能的函数理论上是不允许修改的，这就是封闭原则，不能修改源码

2.开放原则：对源代码进行新功能的扩展，这个时候为了遵循封闭原则，就需要使用装饰器来对原函数进行新功能的扩展

示例代码：

生成器：

创建生成器的两种方法：

1.直接用（）创建：L = （ x for x in range(10)）现在拿到的这个L就是一个生成器对象

2.用yield方法创建 : 当一个函数中出现yield（相当于return一个值）方法。这时候这个函数就是一个生成器对象

特点：

1.省内存：对于一个生成器对象，当你在不用的时候，他只是一个对象，不会生成任何的数据和内容，当你在使用的时候，他也是一个一个按照顺序将数据计算出来，然后打印在屏幕上，生成器的机制就是，自始至终你的你的内存中只存在当前数据。

2.只能按照顺序来计算和打印值

利用生成器计算值：

1.next（）方法

2.for 循环，其实for的内部就是对生成器进行了一个next方法的循环调用

生成器（斐波那契）实例：

deffibs(bit):

before, after= 0, 1

for i inrange(bit):yieldbefore

before, after= after, before +afterfor fibs_num in fibs(10):print(fibs_num)

for循环内部做的三件事：

1.用iter方法将一个可迭代对象转换为一个迭代器对象

2.用迭代器对象的next方法，循环将数据计算并打印出来

3.异常处理，捕捉stopitaretor异常

迭代器：

注意：所有的生成器对象都是迭代器，但是迭代器对象不一定都是生成器

iter方法：将可迭代对象转化为迭代器对象

.这里顺便说一下，为什么对文件进行操作时，要使用for方法对文件句柄进行遍历，就是当你文件的内容很多时，for就会将你的文件句柄转换为一个迭代器对象，

这样就不会出现爆内存的现象

3、getpass模块

可以保证在你提示输入的时候，你输入的东西可以隐藏，但是pycharm不支持（无显示）

importgetpass

answer= getpass.getpass('please input your password:')print(answer)

4、time模块

输出时间的三种格式：时间戳，格式化时间，结构化时间

time模块的方法：

time.time() 返回时间戳，距1970年Unix诞生到当前时间

time.sleep() 让cpu停止执行时间

time.clock() 返回cpu正真执行程序所花费的时间

time.gmtime() 返回结构化时间（世界标准时间：格林威治时间）

time.localtime() 返回当地的结构化时间

time.strftime() 返回格式化时间，可以自定义时间的返回格式，第一个参数为输出时间的格式，第二个参数为结构化时间（元组）

time.strptime() 返回结构化时间，参数为格式化时间

time.ctime() 返回结构化时间，参数为时间戳，返回相对正常的格式化时间

time.mktime() 返回时间戳，参数为结构化时间

5、datetime模块

datetime.datetime.now() 返回平常习惯的格式化时间

6、random模块

random.random() 返回（0,1） 随机的一个浮点数

random.randint(start，end) 参数为两个整型的数字，随机返回一个整型的数字，包含end

random.randrange(start，end) 参数也是为两个整型的数字，随机返回一个整型数字，不包含end

random.sample() 在序列中自定义随机的返回几个元素， 两个参数，第一个参数是一个序列，第二个参数是一个整型数字

random.choice() 在序列中随机的输出一个元素

7、os模块（与操作系统进行交互）

与操作系统之间的交互

os.getcwd() 返回当前执行程序的目录

os.chdir() 改变当前的工作目录

os.makedirs() 创建多层的文件夹

os.removedirs() 删除多层文件夹，从最内层的文件夹开始，只删除空的文件夹

os.mkdir() 创建一个文件夹

os.rmdir() 删除一个文件夹

os.listdir() 将当前工作路径下的所有文件和文件夹以列表的的形式返回

os.remove() 删除文件，不能删除文件夹

os.rename() 对文件夹或者文件进行重命名

os.stat() 返回文件的详细信息

os.sep() 返回当前操作系统的路径分隔符 （Windows：‘\’, linux : '/'）

os.pathsep() 返回当前操作系统的路径之间的分隔符 （windows：‘；’， linux：‘：’）

os.linesep() 返回当前操作系统的换行符（Windows：‘\r\n’, linux : '\n', mac: '\r'）

os.name 放回当前的操作系统 （Windows：‘nt’， linux ：‘posix’）

os.system() 可以执行shell命令，cmd作用

os.environ 返回所有的环境变量

os.path.abspath() 返回相对路径的绝对路径

os.path.split() 将绝对路径，分割成文件名和路径

os.path.dirname() 返回os.path.split返回值的前半部分（路径）

os.path.basename() 返回os.path.split返回值的后半部分（文件名）

os.path.exists() 判断一个path是否存在，返回布尔值

os.path.isabs() 判断path是否为一个绝对路径，返回布尔值

os.path.isfile() 判断path是一个存在的文件，返回布尔值

os.path.isdir() 判断path是一个存在的目录，返回布尔值

os.path.join() 拼接路径的神器

实例：

new_path = os.path.join('C:', 'balaba', 'haha')print(new_path)

8、sys模块（与Python解释器进行交互）

sys.argv() 返回命令行参数的list，第一个元素是程序的本身路径，后面的元素，是你在shell执行py程序时所加的参数（可以根据不同的参数，执行文件中相应的代码块）

sys.exit() 退出正在执行的程序

sys.version() 返回当前工作的Python版本信息

sys.path() 返回Python解释器的搜索路径

sys.path.append() 添加自定义的搜索路径

sys.platform 返回当前操作系统的平台名称

9、hashlib模块（文本加密）

注意：所有加密的密文都是不可逆的

hashlib.md5()

hashlib.sha256()

实例：

importhashlib

head1=hashlib.sha256()

head1.update('hello mary'.encode()) #写入明文

print(head1.hexdigest()) #c4d6759ce553b4e9b40e0f50ee911b6cce261724c5cd7f772bf05a4bdfe4d202

10、 logging模块（日志记录）

logging.basicConfig() 设置日志输出格式

输入内容的方法：

logging.debug(' message ')

logging.info('message ')

logging.warning ('message')

logging.error('message')

logging.critical('message')、

日志输出级别：critical > error > warning > info > debug

%（filename）s 执行程序的文件名

%（asctime）s 实时的时间

%（lineno）d 程序所在的行号

%（message）s 日志的内容

%（levelname）s 级别的名称

level 设置日志的输出级别

format 设置日志的输出格式

datefmt 设置日志中时间的输出格式

filemode 如果是将日志打印在文件中，可以设置对文件的打开模式，默认是追加模式

实现屏幕和文件双打印的方法：

logging.getLogger() 拿到logger对象

logging.FileHandle() 可以将日志打印在文件中的对象

logging.StreamHandle() 可以将日志打印在屏幕中的对象

logging.Formatter() 设置日志打印的格式

logger.addHandler() 对logger对象添加打印的方式

logger.setLevel() 给logger对象设置输出级别（level）

实例：

importlogging

logger= logging.getLogger() #拿到logger对象

file_handle= logging.FileHandler('lock') #创建打印在文件中的对象

steam_handle = logging.StreamHandler() #打印在屏幕上的对象

output_format= logging.Formatter('%(asctime)s %(levelname)s %(message)s') #日志的打印格式

file_handle.setFormatter(output_format)#给对象自定义输出格式

steam_handle.setFormatter(output_format)

logger.addHandler(file_handle)#给logger对象添加打印方式

logger.addHandler(steam_handle)

logger.setLevel(logging.DEBUG)#改变logger的打印级别

logger.debug('hello world') #logger对象调用debug方法输入内容

11、configparser模块（适用于配置文件）

作用：可以实现对配置文件进行 增， 删， 改， 查， 的功能

注意：需要将写好的内容，一定要进行保存

config = configparser.ConfigParser() 拿到操作句柄

增：

（和字典中添加键值对是一样的方法，但是这个是嵌套两层的字典，字典的名称就是config）

写入实例：

importconfigparser

config= configparser.ConfigParser() #拿到配置文件的句柄

config['shopping'] = {'apple': '10','bicycle': '100','pone': '100'}

config['book'] = {'linux': '100','python': '100','c++': '100'}

with open('shopping.txt', 'w') as file:

config.write(file)

删：

config.remove_section(section) 删除一个字典块

config.remove_option(section，key) 删除块中的值

注意：由于文件中的内容，只要是写入，就不能修改，所以我们必须把修改或者删除后的文件进行重新存入一个文件中

改：

config.set(section, key, new_value) 三个参数，用于修改某个键对应的值

修改实例：

importconfigparser

config=configparser.ConfigParser()

config.read('shopping.txt') #拿到操作的权限

config.set('shopping', 'apple', '10000') #更改内容

config.write(open('shopping.txt', 'w')) #重新写入

查：

config.read(filename) 这个方法只是帮助你得到了查看配置文件的权限

config.default() 某时候用来查看配置文件中的默认块

config.has_section(string) 参数为字符串，判断配置文件中是否有这个字符串，返回值为布尔值

for i in config ： 可以使用for循环进行查看内容

12、re模块(正则模块)

>> re其实的本质是一门小型的，高度专业化的编程语言，由c语言编写，re模块所有的操作都是对于字符串进行的（抓包，爬虫常用的URL匹配工具）

re的方法：

re.findall(format， string， flag) 有三个参数，第三个参数也可以没有但是必须有前两个参数，从字符串中匹配中所有符合format 的字符串

re.compile() 参数是一个匹配的格式，返回值就是一个匹配的格式，方便使用

re.split() 对字符串进行切割

re.match() 只能从头开始匹配，和【^】的作用一样，也是返回一个对象，通过group取值

re.search() 返回匹配到的内容和在字符串中起始和结束的索引值，只能匹配到第一个，通过group取值

ret.group() ret是一个对象，group方法可以将对象中的值取出来

re.sub(before_string, after_string, string) 三个参数，对字符串中的字符进行替换

普通字符：

在字符串中没有特殊意义的字符就叫做特殊字符（例如 \n 在字符串中就是一个非普通字符）

re元字符：

正则表达式中的元字符就是只在正则模块的调用下，具有特殊意义的字符，也正是re的各种的元字符成就了re的厉害之处

. （通配符）可以表示任意的一个字符（除\n外，但是在re.findall中也可以自定义的设置换行符为通配符的对象）

* 重复匹配前面一个字符零次到多次

? 重复匹配前面一个字符零次到一次

+ 重复匹配前面一个字符一次到多次

{ }　　 重复匹配前面一个字符自定义次数，也可以是一个次数的区间

^ 只能从头开始进行匹配，只能匹配一个

$ 只能从结尾开始匹配，也是只能匹配一个

[ ] 字符集，中括号中可以是一个字符的范围，若是用逗号分开就是表示匹配中括号中的某一个字符，表示或的关系

中括号还可以将普通字符转换为有意义的字符，并且可以将元字符取消特殊意义（元字符 \ - ^ 不能被取消特殊意义 ）：

\d 所有的数字字符

\D 除数字外的所有字符

\w 所有的数字，字母字符

\W 除数字，字母外的所有字符

\s 所有的空字符（\n \t \r \f \v）

\S 所有的非空字符

\b 可以匹配到和特殊字符的边界

| 或的作用，匹配管道符左右两边的字符

() 分组，将括号中的字符作为一个整体进行匹配

\ 将具有特殊意义的字符，转换为普通字符

13、json模块

方法：

json.dumps() 将不是字符串类型的数据传入文件中（文件中存放的是json类型的数据）

json.loads() 将json类型的数据，转换为数据原来的类型

json.dump(序列化对象， 文件句柄)

json.load(文件句柄)

代码示例：

importjson

test_list= ['ert', 'ert', 'ale']

with open('file', 'r') as file:#json.dump(test_list, file) # 写入内容

print(json.load(file)) #读取内容

14、 socket模块

用于网络编程，也就是用于端到端之间的通信（client----server）

client的方法：

socket.socket() 创建一个socket对象

family参数：

AF_INET:服务器之间的通信（IPV4）

AF_INET6:服务器之间的通信（IPV6）

AF_UNIX:Unix不同进程之间的通信

type参数：

SOCK_STREAM(TCP)

SOCK_DGRAM(UDP)

send（） 用于发送信息，每次有最大的发送限度，参数必须是一个bits类型

sendall （） 实际上就是内部做了一个while True 的循环，循环的发送信息

recv（） 接受信息，参数是接受信息的最大长度

close（） 关闭当前与服务端的通信通道

注意： 无论是server还是client的发送和接受方法都是通过客户端和服务端之间的通信信道的socket对象的

实例：

#模拟客户端

importsocket

client=socket.socket()

address= ('192.168.205.1', 3400)

client.connect(address)#就是指定这个客户端访问的主机和端口

resquests = client.recv(1024) #允许接受的最大字符长度

print(str(resquests, 'utf8')) #因为所有发送或者是接受的数据都是bits类型的，所以需要转换一下

client.close() # 关闭这个客户端和服务端创建的唯一的通信信道

server的方法：

socket.socket() 创建一个socket对象

bind（ ） 用于绑定服务端的ip地址和端口（参数是一个元组形式）

listen（） 指定服务端一共能接受多少个排队的客户端，参数是一个int类型

accept（）用于阻塞，返回值是当前建立信道的socket对象和客户端的ip地址和端口

send（） 用于发送信息，每次有最大的发送限度

sendall （） 实际上就是内部做了一个while True 的循环，循环的发送信息

recv（） 接受信息，参数是接受信息的最大长度

close（ ） 关闭当前的通信信道

实例：

#模拟服务端

importsocket

server= socket.socket() #创建一个socket对象

address = ('192.168.205.1', 3400) #本地的ip地址和自定义的端口

server.bind(address) #对socket对象绑定

server.listen(3) #指定最多允许几个客户端连接

print('writing.....')

conn, adr= server.accept() #进程阻塞，作用是等待客户端的连接

your_send = input('your send:')

conn.send(bytes(your_send,'utf8')) #发送信息

综合方法：

setblocking（） 参数为布尔值，默认为True，当参数为False时，程序在运行的过程中不会发生阻塞

connect_ex () 有返回值，当客户端和服务端连接成功的时候，返回值为0，连接失败时，返回错误编码

recvfrom（） 和recv用法一样， 返回值是接受的数据和发送端的地址

settimeout（） 当客户端和服务端建立连接时，可以设置连接的具体时长，参数时间的单位为秒

setsocktime（） 当建立连接时，返回本机ip地址和当前进程端口

setpeername() 当建立连接时，返回对端设备的ip地址和进程端口

fileno（） 套接字的文件描述符

15、subprocess模块

subprocess.call(‘命令’， shell = True) 执行shell命令

实例代码：拿到cmd执行

importsubprocess

obj= subprocess.Popen('dir', shell=True, stdout=subprocess.PIPE)

res=obj.stdout.read()print(str(res, 'gbk'))

16、socketserver模块（用于多进程通信）

socketserver.ThreadingTCPServer() 有两个参数，第一个是绑定服务端的端口号和ip地址（以元组的形式），第二个参数是你自定义的类名，也就是即将要执行类中的逻辑代码

实例代码：（这里只是贴出服务端的相关代码）

#使用socketserver模块实现，多线程进行通信

importsocketserverclass myserver(socketserver.BaseRequestHandler): #定义一个类，自定义的类继承socketserver

def setup(self): #连接通信之前的准备代码

print('hhhhhhhhh')def handle(self): #取代父代中的handle功能，放入主逻辑代码

conn = self.request #拿到与client端连接的对象

print('%s 连接成功' %conn)print('---------------------------------')whileTrue:

return_info= conn.recv(1024)print(str(return_info, 'utf8'))

your_enter= input('your enter:')

conn.send(bytes(your_enter,'utf8'))

server= socketserver.ThreadingTCPServer(('127.0.0.1', 8000), myserver) #拿到server对象， 多线程功能的参数，第一个参数是server端的端口和ip地址，第二个参数是自定义的类

server.serve_forever() #执行server对象的server_forever方法

17.Tkinter模块

Python实现窗口应用程序的模块