Python模块

什么是模块

Python默认安装仅包含部分基本或核心模块，但用户可以安装大量的扩展模块，pip是管理模块的重要工具。

在Python启动时，仅加载了很少的一部分模块，在需要时由程序员显式地加载（可能需要先安装）其他模块。

减小运行的压力，仅加载真正需要的模块和功能，且具有很强的可扩展性。

可以使用sys.modules.items()显示所有预加载模块的相关信息。

导入模块

import 模块名

可以使用dir()函数查看任意模块中所有的对象列表，如果调用不带参数的dir()函数，则返回当前作用域所有名字列表。

可以使用help()函数查看任意模块或函数的使用帮助。

from 模块名 import 对象名[ as 别名] #可以减少查询次数，提高执行速度
from math import *    #谨慎使用

在2.x中可以使用reload函数重新导入一个模块，在3.x中，需要使用imp模块的reload函数。

导入模块的过程

Python首先在当前目录中查找需要导入的模块文件，如果没有找到则从sys模块的path变量所指定的目录中查找。

可以使用sys模块的path变量查看python导入模块时搜索模块的路径，也可以向其中append自定义的目录以扩展搜索路径。

在导入模块时，会优先导入相应的pyc文件，如果相应的pyc文件与py文件时间不相符，则导入py文件并重新编译该模块。

导入模块的顺序

导入模块时的文件搜索顺序：

• 当前文件夹
• sys.path变量指定的文件夹
• 优先导入pyc

如果需要导入多个模块，一般建议按如下顺序进行导入：

• 标准库
• 成熟的第三方扩展库
• 自己开发的库

Python内置函数

内置函数不需要导入任何模块即可使用。

执行下面的命令可以列出所有内置函数：

>>> dir(__builtins__)

dir()函数可以查看指定模块中包含的所有成员或者指定对象类型所支持的操作。

help()函数则返回指定模块或函数的说明文档。

常用内置函数表

常用的内置函数

数制转换 bin()、oct()、hex()

内置函数bin()、oct()、hex()用来将整数转换为二进制、八进制和十六进制形式，这三个函数都要求参数必须为整数。

>>> bin(555)                      # 把数字转换为二进制串
'0b1000101011'
>>> oct(555)                      # 转换为八进制串
'0o1053'
>>> hex(555)                      # 转换为十六进制串
'0x22b'

内置函数int()用来把实数转换为整数，或把数字字符串按指定进制转换为十进制数。

>>> int(3.5)
3
>>> int(-3.5)
-3
>>> int('101', 2)             # 二进制
5
>>> int('101', 16)            # 十六进制
257
>>> int('x2', 36)             # 36进制
1190
>>> int('\t 8 \n')            # 自动忽略数字两侧的空白字符
8

字符转换 ord()、chr()

ord()和chr()是一对功能相反的函数，ord()用来返回单个字符的序数或Unicode码，而chr()则用来返回某序数对应的字符。

>>> ord('a')                   >>> chr(65)
97                             'A'
>>> chr(ord('A')+1)            >>> str(1)
'B'                            '1'
>>> str(1234)                  >>> str([1,2,3])
'1234'                         '[1, 2, 3]'

str()直接将其任意类型参数转换为字符串。

>>> str((1,2,3))               >>> str({1,2,3})
'(1, 2, 3)'                    '{1, 2, 3}'

最值与求和 max()、min()、sum()

max()、min()、sum()这三个内置函数分别用于计算列表、元组或其他可迭代对象中所有元素最大值、最小值以及所有元素之和，sum()要求元素支持加法运算，max()和min()则要求序列或可迭代对象中的元素之间可比较大小。

>>> a = [72, 26, 80, 65, 34, 86, 19, 74, 52, 40]
>>> print(max(a), min(a), sum(a))
86 19 548

>>> sum(a)/len(a)  #计算平均值
54.8

内置函数max()和min()的key参数可以用来指定比较规则。

>>> x = ['21', '1234', '9']
>>> max(x)
'9'
>>> max(x, key=len)
'1234'
>>> max(x, key=int)
'1234'

内置函数sum()的start参数可以实现非数值型列表元素的求和。

>>> sum([1,2,3,4])
10
>>> sum([[1], [2], [3], [4]], [])
[1, 2, 3, 4]

判断数据类型 type()、isinstance()

内置函数type()和isinstance()可以判断数据类型。

>>> type([3])                             #查看[3]的类型

>>> isinstance(3, int)                    #判断3是否为int类型的实例
True

排序 sorted()、reversed()

sorted()对列表、元组、字典、集合或其他可迭代对象进行排序并返回新列表。

>>> data = [18, 38, 35, 5, 13, 48, 13, 2, 19, 47, 3]
>>> sorted(data)
[2, 3, 5, 13, 13, 18, 19, 35, 38, 47, 48]

>>>sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]

reversed()对可迭代对象（生成器对象和具有惰性求值特性的zip、map、filter、enumerate等类似对象除外）进行翻转（首尾交换）并返回可迭代的reversed对象。

>>> x = ['aaaa', 'bc', 'd', 'b', 'ba']
>>> reversed(x)                 #逆序，返回reversed对象

>>> list(reversed(x))           #reversed对象是可迭代的
['ba', 'b', 'd', 'bc', 'aaaa']

范围 range()

range()语法格式为range([start,] end [, step] )，返回具有惰性求值特点的range对象，其中包含左闭右开区间[start,end)内以step为步长的整数。参数start默认为0，step默认为1。

>>> range(5)                  #start默认为0，step默认为1
range(0, 5)
>>> list(_)
[0, 1, 2, 3, 4]
>>> list(range(1, 10, 2))     #指定起始值和步长
[1, 3, 5, 7, 9]
>>> list(range(9, 0, -2))     #步长为负数时，start应比end大
[9, 7, 5, 3, 1]

枚举 enumerate()

enumerate()函数用来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值的元组。

>>> list(enumerate('abcd'))                        #枚举字符串中的元素
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]
>>> list(enumerate(['Python', 'Great']))          #枚举列表中的元素
[(0, 'Python'), (1, 'Great')]
>>> list(enumerate({'a':97, 'b':98, 'c':99}.items())) #枚举字典中的元素
[(0, ('a', 97)), (1, ('b', 98)), (2, ('c', 99))]
>>> for index, value in enumerate(range(10, 15)):  #枚举range对象中的元素
    print((index, value), end=' ')

(0, 10) (1, 11) (2, 12) (3, 13) (4, 14) 

函数映射 map()

内置函数map()把一个 函数func依次映射到序列或迭代器对象的每个元素上，并返回一个可迭代的map对象作为结果，map对象中每个元素是原序列中元素经过函数func处理后的结果。

>>> list(map(str, range(5)))  #把列表中元素转换为字符串
['0', '1', '2', '3', '4']

>>> def add5(v):              #单参数函数
    return v+5
>>> list(map(add5, range(10)))#把单参数函数映射到一个序列的所有元素
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

>>> def add(x, y):            #可以接收2个参数的函数
    return x+y
>>> list(map(add, range(5), range(5,10)))       #把双参数函数映射到两个序列上
[5, 7, 9, 11, 13]

函数迭代 reduce()

标准库functools中的函数reduce()可以将一个接收2个参数的函数以迭代累积的方式从左到右依次作用到一个序列或迭代器对象的所有元素上，并且允许指定一个初始值。

>>> from functools import reduce
>>> seq = list(range(1, 10))
>>> reduce(lambda x, y: x+y, seq)
45

函数筛选过滤 filter()

内置函数filter()将一个单参数函数作用到一个序列上，返回该序列中使得该函数返回值为True的那些元素组成的filter对象，如果指定函数为None，则返回序列中等价于True的元素。

>>> seq = ['foo', 'x41', '?!', '***']
>>> def func(x):
    return x.isalnum()                  #测试是否为字母或数字

>>> filter(func, seq)                   #返回filter对象

>>> list(filter(func, seq))             #把filter对象转换为列表
['foo', 'x41']

>>> list(filter(str.isalnum, seq))      #等价的用法
['foo', 'x41']

>>> data = list(range(20))
>>> data
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> filterObject = filter(lambda x:x%2==1, data)
                                 #过滤，只留下所有奇数
>>> filterObject

>>> 3 in filterObject            #3以及3之前的元素都访问过了
True
>>> list(filterObject)           #现在所有元素都访问过了
[5, 7, 9, 11, 13, 15, 17, 19]
>>> list(filterObject)           #filterObject中不再包含任何元素
[]

压缩合并 zip()

zip()函数用来把多个可迭代对象中的元素压缩到一起，返回一个可迭代的zip对象，其中每个元素都是包含原来的多个可迭代对象对应位置上元素的元组，如同拉拉链一样。

>>> list(zip('abcd', [1, 2, 3]))             #压缩字符串和列表
[('a', 1), ('b', 2), ('c', 3)]
>>> list(zip('123', 'abc', ',.!'))           #压缩3个序列
[('1', 'a', ','), ('2', 'b', '.'), ('3', 'c', '!')]
>>> x = zip('abcd', '1234')
>>> list(x)
[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')]

map、filter、enumerate、zip的注意事项

map、filter、enumerate、zip等对象不仅具有惰性求值的特点，还有另外一个特点：访问过的元素不可再次访问。

>>> x = map(str, range(10))
>>> list(x)
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
>>> list(x)
[]
>>> x = map(str, range(10))
>>> '2' in x
True
>>> '2' in x
False
>>> '8' in x
False

一些模块

数学 - math

>>> dir(math)
['__doc__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

ceil:取大于等于x的最小的整数值，如果x是一个整数，则返回x

copysign:把y的正负号加到x前面，可以使用0

cos:求x的余弦，x必须是弧度

degrees:把x从弧度转换成角度

e:表示一个常量

exp:返回math.e,也就是2.71828的x次方

expm1:返回math.e的x(其值为2.71828)次方的值减１

fabs:返回x的绝对值

factorial:取x的阶乘的值

floor:取小于等于x的最大的整数值，如果x是一个整数，则返回自身

fmod:得到x/y的余数，其值是一个浮点数

frexp:返回一个元组(m,e),其计算方式为：x分别除0.5和1,得到一个值的范围

fsum:对迭代器里的每个元素进行求和操作

gcd:返回x和y的最大公约数

hypot:如果x是不是无穷大的数字,则返回True,否则返回False

isfinite:如果x是正无穷大或负无穷大，则返回True,否则返回False

isinf:如果x是正无穷大或负无穷大，则返回True,否则返回False

isnan:如果x不是数字True,否则返回False

ldexp:返回x*(2**i)的值

log:返回x的自然对数，默认以e为基数，base参数给定时，将x的对数返回给定的base,计算式为：log(x)/log(base)

log10:返回x的以10为底的对数

log1p:返回x+1的自然对数(基数为e)的值

log2:返回x的基2对数

modf:返回由x的小数部分和整数部分组成的元组

pi:数字常量，圆周率

pow:返回x的y次方，即x**y

radians:把角度x转换成弧度

sin:求x(x为弧度)的正弦值

sqrt:求x的平方根

tan:返回x(x为弧度)的正切值

trunc:返回x的整数部分

随机 - random

randint 随机整数

random 随机浮点数

uniform 随机浮点数

choice 从序列随机选择一个元素

sample 从序列随机选择N个不同的元素

shuffle 打乱排序

import random
import string

# 随机整数：
print random.randint(1,50)

# 随机选取0到100间的偶数：
print random.randrange(0, 101, 2)

# 随机浮点数：
print random.random()
print random.uniform(1, 10)

# 随机字符：
print random.choice('abcdefghijklmnopqrstuvwxyz!@#$%^&*()')

# 多个字符中生成指定数量的随机字符：
print random.sample('zyxwvutsrqponmlkjihgfedcba',5)

# 从a-zA-Z0-9生成指定数量的随机字符：
ran_str = ''.join(random.sample(string.ascii_letters + string.digits, 8))
print ran_str

# 多个字符中选取指定数量的字符组成新字符串：
print ''.join(random.sample(['z','y','x','w','v','u','t','s','r','q','p','o','n','m','l','k','j','i','h','g','f','e','d','c','b','a'], 5))

# 随机选取字符串：
print random.choice(['剪刀', '石头', '布'])

# 打乱排序
items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print random.shuffle(items)

加密与哈希 - zlib、hashlib

使用zlib计算CRC32值。

>>> import zlib
>>> print(zlib.crc32('1234'.encode()))
2615402659
>>> print(zlib.crc32('111'.encode()))
1298878781
>>> import binascii
>>> binascii.crc32('SDIBT'.encode())
2095416137

使用hashlib计算MD5值。

>>> import hashlib
>>> hashlib.md5('12345'.encode()).hexdigest()
'827ccb0eea8a706c4c34a16891f84e7b'
>>> hashlib.md5('123456'.encode()).hexdigest()
'e10adc3949ba59abbe56e057f20f883e'

实现MD5计算器。

import hashlib
import os
import sys

fileName = sys.argv[1]
if os.path.isfile(fileName):
    with open(fileName, 'rb') as fp:
        data = fp.read()
        print(hashlib.md5(data).hexdigest())

Excel文件操作 - xlwt、xlrd

使用xlwt写入Excel文件。

from xlwt import *

book = Workbook()                        #新建workbook
sheet1 = book.add_sheet("First")         #新建worksheet
al=Alignment()
al.horz = Alignment.HORZ_CENTER
al.vert = Alignment.VERT_CENTER          #对齐方式
borders = Borders()
borders.bottom = Borders.THICK           #边框样式
style = XFStyle()
style.alignment = al
style.borders = borders
row0 = sheet1.row(0)
row0.write(0, 'test', style=style)       #写入单元格
book.save(r'd:\test.xls')                #保存文件

使用xlrd读取Excel文件。

>>> import xlrd
>>> book = xlrd.open_workbook(r'd:\test.xls')
>>> sheet1 = book.sheet_by_name('First')
>>> row0 = sheet1.row(0)
>>> print(row0[0])
text:u'test'
>>> print(row0[0].value)
test

Excel文件操作 - Pywin32

使用Pywin32操作Excel文件。

xlApp = win32com.client.Dispatch('Excel.Application') #打开EXCEL
xlBook = xlApp.Workbooks.Open('D:\\1.xls')            #打开文件
xlSht = xlBook.Worksheets('sheet1')                   #获取工作表
aaa = xlSht.Cells(1,2).Value                          #访问单元格
xlSht.Cells(2,3).Value = aaa 
xlBook.Close(SaveChanges=1)                           #保存
del xlApp

Excel文件操作 - openpyxl

使用扩展库openpyxl读写Excel 2007及更高版本的Excel文件。

import openpyxl
from openpyxl import Workbook
fn = r'f:\test.xlsx'                     #文件名
wb = Workbook()                          #创建工作簿
ws = wb.create_sheet(title='你好，世界')  #创建工作表
ws['A1'] = '这是第一个单元格'              #单元格赋值
ws['B1'] = 3.1415926
wb.save(fn)                               #保存Excel文件

wb = openpyxl.load_workbook(fn)      #打开已有的Excel文件
ws = wb.worksheets[1]                #打开指定索引的工作表
print(ws['A1'].value)                #读取并输出指定单元格的值
ws.append([1,2,3,4,5])               #添加一行数据
ws.merge_cells('F2:F3')              #合并单元格
ws['F2'] = "=sum(A2:E2)"             #写入公式
for r in range(10,15):
    for c in range(3,8):
        ws.cell(row=r, column=c, value=r*c) #写入单元格数据
wb.save(fn)

压缩文件操作 - zipfile、rarfile

查看zip和rar压缩文件中的文件列表。

Python标准库zipfile提供了对zip和apk文件的访问。

import zipfile
with zipfile.ZipFile(r'D:\Jakstab-0.8.3.zip') as fp:
    for f in fp.namelist():
        print(f)

Python扩展库rarfile提供了对rar文件的访问。

import rarfile
with rarfile.RarFile(r'D:\asp网站.rar') as r:
    for f in r.namelist():
        print(f)