赵工的个人空间

Python程序由包package、模块module和函数function组成。函数是一个能完成特定功能的代码块，可在程序中重复使用。模块可把一个复杂的程序按功能分开，分别放在不同的文件中，使程序容易维护和管理。包是由一系列模块组成的集合，一般是一个目录，包下面还可以有子包。
Python提供了许多有用的工具包，如字符串处理、图像用户接口、Web应用、图形图像处理、数据库操作等其中很多安装在Python安装目录下的Lib子目录中。包中必须至少包含一个__init__.py文件，该文件的内容可以为空，用于标识当前目录是一个包。导入包的过程与导入模块基本一致，但导入包时会执行此包目录下的__init__.py文件，如果其中没有明确有其他初始化操作，那么此包下面的模块不会自动导入。

一、Python中的函数：

1. 函数的定义：

函数的定义使用保留字def，定义时需要定义返回值的类型，语法为：
def function_name ([arg1, arg2, ...]):
    docstr
    statement
    [return value1,value2,...,valuen]
其中，返回值不是必须的，如果没有return语句，默认返回值为None。函数的参数可以是一个或多个，参数之间用逗号分隔。return语句中的返回值可以是多个，那么会把这些值当成元组返回。
docstr为文档字符串，是紧跟def的未赋值的字符串，用于描述函数功能和使用方法，可以省略，为了便于维护和代码共享建议编写。可以通过function_name.__doc__来访问文档字符串。
函数的函数体内可以创建函数，称为内部函数或内嵌函数，内嵌函数可以使用lambda语句定义。内嵌函数都位于其外部函数的作用域中，除了其外部函数，其他地方都不能对其进行调用。
1）默认参数值：
Python函数支持默认参数值，当某个参数没有传递实际值时，函数将使用默认参数值。
def login(username='user',password='user'):
    if(username=='admin')and(password=='admin'):
        print('登录成功！')
    else:
        print('登录失败！')
调用时可以使用：
login('admin','admin')
login('admin')
login(password='admin')
login()
2）列表参数值：
参数可以是变量，也可以是元组、列表等内置数据结构。
def login(usernames=[],password='admin'):
    username=usernames[0]
    if(username=='admin')and(password=='admin'):
        print('登录成功！')
    else:
        print('登录失败！')
调用方法可使用：
login(['admin','user'])
3）可变长度参数值：
在函数的参数前使用“*”，可以传递可变长度参数。“*”可以引用元组。示例：
def login(* usereds):
    username=userwds[0]
    password=userwds[1]
    if(username=='admin')and(password=='admin'):
        print('登录成功！')
    else:
        print('登录失败！')
调用方法：
login('admin','admin')
login('user','user')
4）字典类型参数值：
Python还提供了标识符**，用来引用一个字典作为参数。示例：
def login(** usereds):
    keys=userpwds.keys()
    username=''
    password=''
    for key in keys:
        if 'username'==key:
            username=userpwds[key]
        if 'password'==key:
            password=userpwds[key]
    if(username=='admin')and(password=='admin'):
        print('登录成功！')
    else:
        print('登录失败！')
调用方法：
login(username='admin',password='admin')
login()函数的形式参数** usereds与实际参数username='admin',password='admin'对应，生成一个结构为{username:'admin',password:'admin'}的字典。
如果函数的参数类型中既有元组，又有字典，那么语法规定*要写在**的前面。
5）partial函数：
这是functools模块的partial函数，将带有n个参数的函数，固化其中一个参数，并返回另一个带有n-1个参数的函数对象。固化参数的值可以根据需要指定。固化的参数可以根据形参名指定，不指定时固化第一个参数。示例：
def tax(s1,price,number,m):
    pass
tax1=partial(tax,0.01)
tax10=partial(tax,m=10)

2. 匿名函数：

匿名函数是指没有函数名的简单函数，只可以包含一个表达式，不允许包含其他复杂的语句，表达式的结果是函数的返回值。Python中，使用lambda定义匿名函数，也称为lambda函数，定义格式：
lambda [arg1[,arg2, ......,argn]]:exp
关键字lambda表示匿名函数，冒号前面是函数参数，可以有多个函数参数，但只有一个返回值，所以只能用一个表达式，返回值就是该表达式的结果。匿名函数不能包含语句或多个表达式，不用return语句。示例：
lambda x,y:x+y
1）匿名函数的调用：
匿名函数也是一个对象，可以把匿名函数赋值给一个变量，利用变量来调用该函数。示例：
f=lambda x,y:x+y
f(3,2) # 结果5
匿名函数也可以指定默认值参数：f=lambda a,b=2,c=5:a*a-b*c
2）匿名函数作为函数的返回值：
可以把匿名函数作为普通函数的返回值返回。示例：
def f():
    return lambda x,y:x*x+y*y
fx=f()
print(fx(3,4))
3）把匿名函数作为序列或字典的元素：
可以将匿名函数作为序列或字典的元素，以列表为例，格式为：
listname=[lambda1, lambda2, ......, lambdan]
这时可以以序列或字典元素引用作为函数名来调用匿名函数。示例：
f=[lambda x,y:x+y, lambda x,y:x-y]
print(f(0)(3,5), f(0)(3,5))
也可以使用字典：
f={'a':lambda x,y:x+y, 'b':lambda x,y:x-y}
[('a'](3,5)

3. 递归函数：

递归recursion是指在连续执行某一处理过程中，该过程中的某一步要用到它自身的上一步或上几步的结果。Python中允许使用递归，递归是指一个函数的函数体中又直接或间接地调用该函数本身。如果函数a中调用函数a自己，则函数a为直接递归；如果函数a中先调用函数b，函数b中又调用函数a，则称函数a为间接递归。
比如定义一个阶乘的递归：
def fac(n):
    if n<=1:
        return 1
    else:
        return x*fac(n-1)
调用方法：
m=fac(3)
当一个问题蕴含了递归关系且结构比较复杂时，采用递归函数可以使程序变得间接、紧凑。但递归函数是以牺牲存储空间为代价的，因为每一次递归调用都要保存相关的参数和变量，而且由于反复调用会增加时间开销所以也会影响程序执行速度。

4. 装饰器：

装饰器decorator可以理解为一个函数，是用来包装函数的函数，经常用于为已经存在的函数添加额外功能。当函数有重复代码时，可以将此部分代码单独拿出来整理成一个装饰器，然后对每个函数调用该装饰器。另外，当需要为多个已经写好的函数添加一个共同功能，比如参数合法性检查，就可以单独写一个检查合法性的装饰器，然后在每个需要检查参数合法性的函数处调用，而不用去每个函数内部修改。
1）无参装饰器：
装饰器使用def定义，其输入参数就是被装饰的函数对象，并返回一个新的函数对象。装饰器函数一定要返回一个函数对象。调用装饰器通过@语句，放在一个函数定义之前，实际上是将定义的函数传递给装饰器，并将装饰器返回的新函数对象赋给原来的函数名。示例：
def deco(func):
    def new_func(x,y):
        print("原始数据：",x,y)
        return func(x,y)
    return new_func
@deco
def square_sum(x,y):
    return x**2+y**2
print(square_sum(10,20))
从本质上，装饰器起到的是重新指向函数名的作用，让同一个对象名指向一个新返回的函数，从而达到修改可调用函数的目的。所以函数调用相当于执行如下语句：
square_sum=deco(square_sum)
square_sum(10,20)
2）有参数装饰器：
deco装饰器调用中，默认它后面的函数是唯一的参数。在调用装饰器时，可以提供其他函数，为装饰器的定义和调用提供了更大灵活性。示例：
def DECO(argv):
    def deco(dunc):
        def new_func(x,y):
            print(argv+"原始数据：",x,y)
            return func(x,y)
        return new_func
    return deco
@DECO('Sum')
def square_sum(x,y):
    return x**2+y**2
print(aquare_sum(10,20))
带参数的装饰器函数，实际上是对原有装饰器的封装，并返回一个装饰器。当调用时，相当于执行：
square_sum=DECO('Sum')(square_sum)
3）多重装饰器：
即多个装饰器修饰同一个函数。示例：
def deco1(func):
    print("deco1")
    return func
def deco2(func):
    print("deco2")
    return func
@deco2
@deco1
def foo():
    print("foo")
使用多重装饰器，是先执行后面的装饰器，再执行前面的装饰器。
foo=deco2(deco1(foo))

5. 变量的作用域：

Python程序可由若干个函数组成，每个函数都要使用一些变量。一般情况下，要求各函数的数据独立，有时又需要相互交换数据。程序设计中，需要注意处理的作用域。
在程序中，能对变量进行存取操作的范围为变量的作用域，根据作用域不同，变量分为局部变量和全局变量。
1）局部变量：
在一个函数体或语句块内定义的变量为局部变量，局部变量只在定义它的函数体或语句块内有效，即只能在定义它的函数体或语句块内部使用，而在定义的函数体或语句块之外不能使用。
2）全局变量：
在函数之外定义的变量为全局变量，可以被多个函数引用。在同一程序文件中，如果全局变量与局部变量同名，在局部变量的作用范围内，全局变量不起作用。而如果想在函数体内为函数体外的全局变量重新赋值，或者使用全局变量的值，可以使用global语句，表明变量是全局变量。
Python 3.x还引入了nonlocal关键字，在内层函数中使用nonlocal语句说明变量，就可以让解释器在外层函数中修改变量的值。

6. 闭包：

定义在外部函数中，但被内部函数引用或使用的变量称为自由变量。如果一个内部函数对外部作用域的自由变量进行了引用或使用，那么这个内部函数就称为闭包。
闭包将内部函数的代码和作用域与外部函数的作用域结合起来，对维护函数内部变量安全和在函数对象及作用域中随意切换很有用。
使用闭包，能有效减少函数定义时所需的参数数目，有利于提高函数的可移植性。

7. 生成器：

生成器是带有yield语句的函数，可以暂停执行并返回一个中间结果。当调用生成器的next方法时，生成器会从刚才暂停的位置继续执行。示例：
def gen():
    i=1
    yield(u'第%d次返回' %i)
    i=i+1
    yield(u'第%d次返回' %i)
    i=i+1
    yield(u'第%d次返回' %i)
调用生成器函数：
g=gen()
当调用print(g.__next__())时，三次调用分别显示“第1次返回”、“第2次返回”、“第3次返回”，第4次调用后则出现StopIteration异常。
因为Python的for语句可以自动调用next方法并处理StopIteration异常，所以通常使用for语句：
for eachi in gen():
    print(eachi)
Python还可以使用send方法传送新值，使用throw方法抛出异常，使用close方法结束生成器。示例：
def gen():
    i=0
    while True:
        m=yield(i)
        if m is not None:
            i=m
        else:
            i=i+1
调用gen生成器：y=gen()
y.__next__() # 0
y.__next__() # 1
y.send(8) # 8
y.__next__() # 9
y.throw(ValueError("hi,Error")) # 抛出ValueError错误，显示错误提示hi,Error
y.close() # 结束生成器

8. 常用内置函数：

Python内置函数built-in function包含在模块builtins中，该模块在启动Python解释器时自动装入内存，随着Python解释器的运行而创建，可以随时调用这些函数，包括print()、type()、id()等。
1）数学函数：
⑴abs()函数：返回数字的绝对值，x为复数是返回复数的模
⑵pow(x,y[,z])函数：返回x的y次幂，如果有z参数，表示x的y次幂对z求余数。
⑶round(x[,n])函数：对浮点数四舍五入，返回浮点数，n为精确到小数点后的指定位数
⑷divmod(x,y)函数：把除法和求余结合起来，返回一个包含商和余数的元组
2）计算函数：
⑴len()函数：返回一个对象的长度
⑵max()函数：返回列表、元组或字符串中最大的元素
⑶min()函数：返回列表、元组或字符串中的最小元素
⑷range()函数：返回一个迭代器，有3个参数，分别为起始值、结束值和步长
⑸sum()函数：把列表中的元素加在一起并返回总和
3）数据类型转换函数：
⑴bool(x)函数：返回True或Fasle
对数字使用bool函数，0返回False，其他值返回True。对字符串，空字符串返回False，否则返回Ture。对列表、元组、字典等，空列表、元组、字典返回False，否则返回True。
⑵float(x)函数：把字符串或数字转换为浮点数
float('3.14159265')
⑶int(x)函数：把字符串或数字转换成整数
⑷complex(x[,y])函数：将x和y转换成一个复数，其中实部为x，虚部为y。y缺省时为0。
4）特殊函数：
⑴dir()函数：返回关于值的相关信息
一般情况下，会按字符顺序显示相关值可以使用哪些函数。
⑵eval()函数：把一个字符串为参数返回作为一个表达式的结果
ecal('10*5')
⑶exec()函数：可以运行复杂的程序
⑷help()函数：解释器提示符下输入，可以进入联机帮助环境，quit命令退出

二、Python的模块：

模块把一组相关的函数或代码组织到一个文件中，即一个Python文件就是一个模块。模块是由代码、类和函数组成，其中的类和函数可以有0个或多个。有些Python模块在Python解释器启动时会被自动导入，用于完成系统相关操作。

1. 模块中类和方法的调用：

调用模块中的类或方法前，首先使用import导入对应模块，然后才能使用：
import module_name1[, module_name2, ......, module_namen]
导入模块从本质上讲，就是在一个文件中载入另一个文件，并且能够读取那个文件的内容。而调用模块已经定义的类或函数，需要以模块名作为前缀，语法为：
module_name.function_name
调用模块中的类时，需要创建类的对象，然后再通过类对象调用类中的方法。语法：
class_object=module_name.class_name
class_object.class_funcname
示例：
import myModule
myModule.myFunc1()
myModule.myFunc2()
myclass=myModule.NyClass()
myclass.myClassFun()
如果模块名太长，使用不不便，可以在导入时使用as关键字为其重命名：
import module_name as mname
加载模块会导致模块被执行，导入模块的顶层代码将直接被执行，通常包括全局变量以及类和函数的声明。如果模块中的代码不想在加载时运行，应尽可能封装到函数中，只把函数和模块定义放入模块的顶层。
Python文件有对应的编译版本.pyc文件。Python模块载入时，如果有可用的.pyc文件，则会使用此文件提高加载速度。
Python中的import语句更加灵活，可以放置于程序中的任意位置，甚至可以存放在条件语句中，实现条件导入。

2.导入指定模块的属性方法到当前作用域：

Python中还有from...import语句可以将模块中的类或函数导入，并加入当前的命名空间，从而不需要使用模块名作为前缀。语法格式：
from module_name import function_name
也可以导入一个模块下的所有类和函数，使用语句：
from module_name import *
使用这种方法导入时，新导入的属性、方法等名称会覆盖当前作用域已存在的同名对象。但这种方法导入时，以下划线开头的函数及变量并不会引入，因为是私有函数和变量。

3. 搜索路径与加载列表：

当使用import导入一个模块时，系统首先会搜索当前路径，然后查找lib目录、site-packages目录和环境变量PYTHONPATH设置的目录，在这些路径下搜索并导入相应模块。Python是按照sys.path列表中的路径，依次进行搜索。可以通过sys.path查看模块搜索路径，其中第1个路径往往是主模块所在目录。有三种方法可以将自定义模块的路径加入搜索路径：
⑴动态添加模块路径：sys.path.append(path)
⑵Python安装目录下的\Lib\site-packages文件夹下建立一个纯文本文件，其中添加模块路径，文件扩展名改为.pth。Python在遍历已知的模块文件目录时，如果遇到.pth文件，就会将文件中记录的路径加入到sys.path的设置中。
⑶修改环境变量PYTHONPATH的值，添加新的搜索路径
程序开发中，模块可能在多处被导入，但Python只会加载一次，因为将所有加载到内存的模块都放在sys.modules中，在加载新的模块时会先在其中查找是否已经加载了，没有加载的会搜索模块并载入内存，并更新sys.modules。可以通过字典变量sys.modules来查看已导入的模块名和所处位置。

4. 名称空间：

Python程序执行时，存在内建名称空间、全局名称空间和局部名称空间。Python解释器会首先加载内建名称空间，这由__builtins__模块中所有内建名称构成，然后加载执行模块的全局名称空间，模块执行时就有了两个活动的名称空间。如果程序调用了函数，则Python解释器会创建局部名称空间。
程序使用一个名称时，Python解释器会先从局部名称空间查找，如果没有找到，接着查询全局名称空间，如果还没有找到，则查询内建名称空间。如果还没有找到，则会报错。
因为查找顺序的原因，如果局部名称空间、全局名称空间和内建名称空间中有同名的对象，则局部名称空间中的对象会遮蔽全局名称空间和内建名称空间中对应的对象，而全局名称空间中的对象会遮蔽内建名称空间中的对象。

5. 模块的有条件执行：

Python程序，一般是由多个程序文件组成的，一般是一个主程序及多个模块，其中每个程序文件就是一个.py源程序文件。主程序定义了程序的主控流程，是执行的启动文件，处于顶层；模块则是函数库，相当于子程序。
模块是以磁盘文件形式存在，其中可以包括变量、类、函数及可以直接执行的程序。模块的定义部分，如全局变量、类定义、函数定义等，因为没有程序执行入口，所以不能直接运行。
Python中有一个全局系统变量__name__，在模块内部是用来标识模块名称，如果模块是被导入的，变量__name__的值就是模块的名称，但当Python解释器直接运行此模块文件时其值则为__main__。通过变量__name__，可以将一个模块文件作为普通模块库以供其他模块使用，也可以作为一个可执行文件运行，具体办法是在程序执行入口前加上if判断语句：
if __name__=='__main__':
    function_name()
当使用import命令导入模块时，__name__变量的值是模块名，所以不执行function_name()函数调用；当直接运行此py文件时，__name__变量的值是“__main__”，所以执行函数function_name()。

6. 模块属性：

Python中的每个模块都有一些特定的属性，最常用的是__name__和__doc__。
⑴__name__属性：
__name__属性用于判断当前模块是不是程序的入口。如果当前程序正在被使用，__name__的值为__main__。在编写程序时，通常需要给模块添加条件语句，用于单独测试该模块的功能。示例：
if __name__=='__main__':
    print 'myThirdModule为主程序'
else:
    print 'myThirdModule被另一个模块调用'
代码中，使用if条件语句判断__name__属性的值是否为__main__，如果成立，表明该模块为程序入口。
⑵__doc__属性：
Python中的模块是一个对象，而每一个对象都会有一个__doc__属性，用于描述该对象的作用，可以输出文档字符串的内容。

7. 内联模块buildin：

模块buildin中定义了软件开发中经常用到的许多函数，可以实现数据类型的转换、数据的计算、序列的处理等功能。
⑴apply()函数：
apply()函数可以实现调用可变参数列表的功能，把函数的参数存放到一个元组或序列中。
apply (function_name [, args[, kwargs]])
参数function_name是必需的，是自定义函数的名称，此函数的返回值就是apply()函数的返回值；args是可选的，包含了自定义函数参数的列表和元组，不指定时表示被执行函数没有参数；kwargs是可选的，是字典类型参数，字典中key值为函数的参数名称，value值为实际参数的值。示例：
print(apply(login,('admin','admin'))
⑵filter()函数：
filter()函数可以对序列做过滤处理，即过滤一个序列。格式为：
filter (function_name, sequence)
其中，function_name是必需参数，是一个自定义函数，函数中定义过滤规则；参数sequence也是必需参数，表示需要过滤的序列。
filter()函数的返回值由function_name()函数的返回值决定，function_name()函数返回所有True的过滤项组成的序列，返回值的类型与参数sequence的类型相同；如果function_name()函数返回None，表示sequence序列中的每一项都为True。示例：
def validate(username):
    if (len(username)>4) and (len(username)<12):
        return username
name=filter(validate, ('admin','tom','localuser','adm','anonymous'))
for item in name:
    print(item)
注意，function_name()函数的参数不能为空，否则没有可存储sequence元素的变量，也就不能处理过滤。
⑶map()函数：
map()函数可以对多个序列中的每个元素执行相同的操作，并返回一个与输入序列长度相同的列表，其中每一个元素都是对输入序列中相应位置的元素转换的结果。语法：
map(function_name, sequence[, sequence, ...])
其中，function_name为自定义函数名，实现对序列中每个元素的操作；sequence参数表示待处理的序列，可以有多个序列，如果多个序列长度不一，会在短序列后面补None。示例：
def add1(a):
    return a+1
def add2(a, b):
    return a+b
def add3(a, b, c):
    return a+b+c
a1=[1,2,3,4,5]
a2=[1,2,3,4,5]
a3=[1,2,3,4,5]
b=map(add1,a1)
for item in b:
    print(item)
b=map(add2,a1,a1)
for item in b:
    print(item)
b=map(add3,a1,a2,a3)
for item in b:
    print(item)

8. 常用模块：

Python标准库包含很多模块，每个模块定义了很多函数，这些函数称为系统函数，任何Python程序都可直接或间接调用这些函数。调用系统函数之前，需要使用import导入相应的模块。
1）math模块：
包含了常用数学常量和函数。
⑴数学常量：
·math.e：自然对数的底
·math.pi：圆周率
⑵绝对值和平方根函数：
·math.fabs(x)：返回x的绝对值，返回值为浮点数
·math.sqrt(x)：返回x的平方根，要求x>0
⑶幂函数和对数函数：
·math.pow(x, y)：返回x的y次幂
·math.exp(x)：返回e的x次幂
·math.log(x[, base])：返回x的自然对数，可以使用base改变对数的底，默认e
·math.log10(x)：返回x的常用对数
⑷取整和求余函数：
·math.ceil(x)：多x向上取整
·math.floor(x)：对x向下取整
·math.fmod(x, y)：返回求x/y的余数，返回值为浮点数
⑸弧度角度转换函数：
·math.degrees(x)：将弧度转换为角度
·math.radians(x)：将角度转换为弧度
⑹三角函数和反三角函数：
·math.sin(x)：返回x的正弦值，x为弧度
·math.cos(x)：返回x的余弦值，x为弧度
·math.tan(x)：返回x的正切值，x为弧度
·math.asin(x)：返回x的反正弦值，返回值为弧度
·math.acos(x)：返回x的反余弦值，返回值为弧度
·math.atan(x)：返回x的反正切值，返回值为弧度
2）cmath模块：
cmath模块函数与math模块函数基于一致，函数名也一样，但cmath模块支持对复数的运算，而math只支持对实数的运算。cmath模块中也有一些特有的函数：
⑴cmath.phase(x)：返回复数的幅角，复数的模使用cmath.abs(x)计算
⑵cmath.polar(x)：将复数的笛卡尔坐标表示转换为极坐标表示，输出为二元组(r, p)
⑶cmath.rect(x)：将复数的极坐标表示转换为笛卡尔坐标表示，输出r*cos(p)+r*sin(p)*1j
3）random模块：用来生成随机数
⑴random.seed(x)：设置随机数种子。对于相同的种子，每次调用随机函数生成的随机数是相同的。默认将系统时间作为种子值，使得每次产生的随机数都不一样。
⑵随机挑选和排序：
·random.choice(seq)：从序列的元素中随机选取一个元素
·random.sample(seq, k)：从序列中随机挑选k个元素
·random.shuffle(seq)：将序列中所有元素随机排序
⑶生成随机数：
·random.random()：随机生成一个[0, 1)范围内的实数
·random.uniform(a, b)：随机生成一个[a, b]范围内的实数
·random.randrange(a, b, c)：随机生成一个[a, b)范围内以c递增的整数，省略c以1递增
·random.randint(a, b)函数：随机生成一个[a, b]范围内的整数
print(random.randint(1,100))
4）time模块：时间相关函数模块
Python的时间格式化符号有：%y表示两位数年份，00~99；%Y表示4位数年份，000~9999；%m表示月份，01~12；%d表示月中的1天，0~31；%H表示24小时制小时数0~23；%I表示12小时制小时数，01~12；%M表示分钟数，00~59；%S表示秒，00~59。
⑴time.time()：返回当前的时间戳，是从Epoch(1970年1月1日00:00:00UTC)开始经过的秒数，不包括闰秒。
⑵time.localtime([sec])：接收从Epoch开始的秒数，并返回一个时间元组，其中包括9个元素，相当于struct_time结构。缺省sec参数时，返回当前时间戳对应的时间元组。
''' time.struct_time(tm_year=2018, tm_mon=5, tm_mday=22, tm_hour=7, tm_min=21, tm_sec=28, tm_wday=1, tm_yday=142, tm_isdst=0) '''
⑶time.asctime([tupletime])：接收一个时间元组，并返回一个日期时间字符串。tupletime缺省时返回当前系统日期和时间。
⑷time.ctime([sec])：类似于time.asctime(localtime([sec]))，不带参数时与time.asctime()相同。
⑸time.strtime(日期格式)：按指定的日期格式返回当前日期时间。示例：
time.strtime('%Y-%m-%d %H:%M:%S')
⑽time.sleep()函数：暂停一段时间。示例：time.sleep(1)
5）calendar模块：日期模块，提供与日历相关的功能
默认情况下，日历把星期一作为一周的第一天，星期日为最后一天。
⑴calendar.setfirstweekday(weekday)：设置每个星期的开始工作日，weekday为0~6，代表星期一~星期日。
⑵calendar.firstweekday()：返回当前设置的每个星期开始工作日，默认0，即星期一
⑶calendar.isleap(year)：如果指定年份是闰年返回True，否则为False。
⑷calendar.leapdays(y1,y2)：返回在[y1,y2]范围内的闰年数
⑸calendar.calendar(year)：返回指定年份的日历。
⑹calendar.month(year,month)：返回指定年份和月份的日历。
⑺calendar.monthcalendar(year,month)：返回整数列表，每个子列表表示一个星期。
⑻calendar.monthrange(year,month)：返回两个整数，第1个数代表指定年和月的第一天是星期几，第2个数代表所指定月份的天数。
⑼calendar.weekday(year,month,day)：返回给定日期的星期代码。
6）copy模块：
包含了对象复制的函数。
⑴copy.copy()函数：复制对象
import copy
jerry=copy.copy(tom)
这是浅拷贝，没有拷贝对象中的对象。
⑵copt.deepcopy()函数：拷贝对象中的所有对象
7）keyword模块：
⑴keyword.iskeyword()函数：返回一个字符串是否为Python关键字
⑵keyword.kwlist变量：Python中所有关键字的列表
print(keyword.kwlist) #显示Python中关键字列表
8）sys模块：
⑴sys.exit()函数：停止Python Shell或者控制台
⑵sys.stdin对象：提示用户输入信息
v=sys.stdin.readline()
⑶sys.stdout()对象：向Shell程序或控制台写消息
sys.stdout.write('hello')
当write结束时会返回所写的字符个数。
⑷sys.version变量：Python的版本
print(sys.version)
# 3.7.0b4 (v3.7.0b4:eb96c37699, May  2 2018, 19:02:22) [MSC v.1913 64 bit (AMD64)]
9）pickle模块：把Python对象转换成方便写入到文件和从文件中读取的形式
⑴pickle.dump()函数：序列化数据
⑵pickle.load()函数：反序列化数据

9. 其他一些比较常用的模块：

·pywon32模块：提供Windows API函数接口，可以编写与Windows底层功能相关的程序
·py2exe模块：可以将Python程序转换为exe可执行程序，使其脱离Python环境运行
·numpy模块：科学计算基础库，主要用于矩阵处理与运算
·scipy模块：numpy模块上的科学计算工具集，包括统计、数值积分、傅里叶变换等
·matplotlib模块：绘图模块，可以快速将计算结果用图形显示出来
·其他科学计算模块：SymPy、Traits、TraitsUI、TVTK、Mayavi、VPython、OpenCV等
·sqlite3模块：内置的访问SQLite数据库模块，访问Access数据库可使用pywin32模块
·pymysql模块：访问MySQL数据库
·PyMedia模块：用于多媒体操作的模块，用于WAV、MP3、AVI格式文件编解码及播放
·PyOpenGL模块：封装了OpenGL应用程序编程接口
·PIL模块：即pillow模块，提供了图像处理功能，支持多种图像文件格式
·socket模块：多Socket接口进行封装，支持对Socket接口的访问
·对网页读取和处理模块：urllib、cookielib、httplib、scrapy等
·Pygame模块：用来开发电子游戏

三、程序打包：

程序完成后交付用户使用，一般需要将程序做成安装包，以方便用户使用。Python提供了Distutils、Setuptools、Py2exe、PyInstaller、cx_freeze等程序打包工具。其中Py2exe、PyInstaller、cx_freeze是Window平台下制作exe文件的工具。Distutils包含在Python发行包中，Setuptools则是其增强工具。
1. Distutils：
使用步骤为：
⑴建立setup.py文件，内容为：
from distutils.core import setup
setup(name='filename',version='1.0',descroption='description',author='abc',py_modules=['filename'],)
其中，py_modules是一个模块列表，setup将在发布版本的根目录中找到列表中的模块filename.py，并将filename.py包含在发布版本中。
与py_modules对应的键有packages、scripts、Extension、ext_modules、data_files等。packages表示一个包的列表，如果packages键包含mypack，则setup将在发布版本的根目录中找到一个子目录mypack，并在发行版本中包含mypack/__init__.py，并包含mypack目录下的所有*.py，但并不包含mypack下子目录中的内容。
Extension用于Python扩展，可包含C/C++语言文件.c/.cpp，还有Fortran文件及SWIG的.i文件。包含了Extension键的setup.py文件，执行Python Setup.py build将定义相应的编译器，把Extension中指定的文件编译为相应的.py文件。Extension中可以指定库的位置、包含路径等信息。
data_files用于包含任意类型的文件到发布版本文件中，如图片文件等。
⑵执行打包命令：
python setup.py sdist
然后会出现提示信息。该命令创建了dist目录，并将要打包的文件复制到filename-version.zip的压缩文件中。
除了build、install、sdisk命令，还有bdist、bdist_rpm、bdist_wininst用于生成不同操作系统的安装包。生成Windows下的exe文件步骤基本相同，也要先创建setup.py文件，在其他包含符合相应软件要求的格式，然后调用相应命令生成。
⑶安装：
压缩文件可以直接给用户，用户将该文件解包，执行python setup.py install完成安装过程。
打包时也可以使用命令直接生成Windows或Linux下可以直接运行的安装文件：
python setup.py bdist_wininst //Windows下使用
python setup.py bdist_rpm //Linux下使用
然后在Windows或Linux下直接运行安装文件。
2. py2exe：
py2exe为distutils的扩展，能把Python脚本转换为exe文件，可以使用pip方式安装。
⑴建立setup.py文件，内容：
fron distutils.core import setup
import py2exe
setup(console=["filename.py"])
⑵执行命令将py文件转换为可执行文件：
python setup.py py2exe
执行后会生成dist和build两个目录，dist目录下有一个对应的filename.exe文件以及各种动态库文件，这个exe文件不能脱离dist目录下的动态库支持。