一 模塊介紹

1、什麽是模塊？
#常見的場景：一個模塊就是一個包含了一組功能的python文件,比如spam.py，模塊名為spam，可以通過import spam使用。

#在python中，模塊的使用方式都是一樣的，但其實細說的話，模塊可以分為四個通用類別：　

　　1 使用python編寫的.py文件

　　2 已被編譯為共享庫或DLL的C或C++擴展

　　3 把一系列模塊組織到一起的文件夾（註：文件夾下有一個__init__.py文件，該文件夾稱之為包）

　　4 使用C編寫並鏈接到python解釋器的內置模塊
2、為何要使用模塊？

1、從文件級別組織程序，更方便管理
隨著程序的發展，功能越來越多，為了方便管理，我們通常將程序分成一個個的文件，這樣做程序的結構更清晰，方便管理。這時我們不僅僅可以把這些文件當做腳本去執行，還可以把他們當做模塊來導入到其他的模塊中，實現了功能的重復利用

#2、拿來主義，提升開發效率
同樣的原理，我們也可以下載別人寫好的模塊然後導入到自己的項目中使用，這種拿來主義，可以極大地提升我們的開發效率

#ps：
如果你退出python解釋器然後重新進入，那麽你之前定義的函數或者變量都將丟失，因此我們通常將程序寫到文件中以便永久保存下來，需要時就通過python test.py方式去執行，此時test.py被稱為腳本script。

3、以spam.py為例來介紹模塊的使用：文件名spam.py,模塊名spam

#spam.py
print(‘from the spam.py‘)

money=1000

def read1():
    print(‘spam模塊：‘,money)

def read2():
    print(‘spam模塊‘)
    read1()

def change():
    global money
    money=0

二 使用模塊之import

1、import的使用
#模塊可以包含可執行的語句和函數的定義，這些語句的目的是初始化模塊，它們只在模塊名第一次遇到導入import語句時才執行（import語句是可以在程序中的任意位置使用的,且針對同一個模塊很import多次,為了防止你重復導入，python的優化手段是：第一次導入後就將模塊名加載到內存了，後續的import語句僅是對已經加載到內存中的模塊對象增加了一次引用，不會重新執行模塊內的語句），如下 

#test.py
import spam #只在第一次導入時才執行spam.py內代碼,此處的顯式效果是只打印一次‘from the spam.py‘,當然其他的頂級代碼也都被執行了,只不過沒有顯示效果.
import spam
import spam
import spam

‘‘‘
執行結果：
from the spam.py
‘‘‘
2、在第一次導入模塊時會做三件事，重復導入會直接引用內存中已經加載好的結果
 

#1.為源文件(spam模塊)創建新的名稱空間，在spam中定義的函數和方法若是使用到了global時訪問的就是這個名稱空間。

#2.在新創建的命名空間中執行模塊中包含的代碼，見初始導入import spam
    提示:導入模塊時到底執行了什麽？
    In fact function definitions are also ‘statements’ that are 
    ‘executed’; the execution of a module-level function definition 
    enters the function name in the module’s global symbol table.
    事實上函數定義也是“被執行”的語句，模塊級別函數定義的執行將函數名放
    入模塊全局名稱空間表，用globals()可以查看

#3.創建名字spam來引用該命名空間
    這個名字和變量名沒什麽區別，都是‘第一類的’，且使用spam.名字的方式
    可以訪問spam.py文件中定義的名字，spam.名字與test.py中的名字來自
    兩個完全不同的地方。
3、被導入模塊有獨立的名稱空間
每個模塊都是一個獨立的名稱空間，定義在這個模塊中的函數，把這個模塊的名稱空間當做全局名稱空間，這樣我們在編寫自己的模塊時，就不用擔心我們定義在自己模塊中全局變量會在被導入時，與使用者的全局變量沖突
 
示例代碼1::money與spam.money不沖突

#test.py
import spam 
money=10
print(spam.money)

‘‘‘
執行結果：
from the spam.py
1000
‘‘‘

示例代碼2：read1與spam.read1不沖突

#test.py
import spam
def read1():
    print(‘========‘)
spam.read1()

‘‘‘
執行結果:
from the spam.py
spam->read1->money 1000
‘‘‘
示例代碼3：執行spam.change()操作的全局變量money仍然是spam中的

#test.py
import spam
money=1
spam.change()
print(money)

‘‘‘
執行結果：
from the spam.py
1
‘‘‘
4、為模塊名起別名
為已經導入的模塊起別名的方式對編寫可擴展的代碼很有用

1 import spam as sm
2 print(sm.money)
有兩中sql模塊mysql和oracle，根據用戶的輸入，選擇不同的sql功能

#mysql.py
def sqlparse():
    print(‘from mysql sqlparse‘)
#oracle.py
def sqlparse():
    print(‘from oracle sqlparse‘)

#test.py
db_type=input(‘>>: ‘)
if db_type == ‘mysql‘:
    import mysql as db
elif db_type == ‘oracle‘:
    import oracle as db

db.sqlparse() 

假設有兩個模塊xmlreader.py和csvreader.py，它們都定義了函數read_data(filename):用來從文件中讀取一些數據，但采用不同的輸入格式。可以編寫代碼來選擇性地挑選讀取模塊

if file_format == ‘xml‘:
    import xmlreader as reader
elif file_format == ‘csv‘:
    import csvreader as reader
data=reader.read_date(filename)
5、在一行導入多個模塊

1 import sys,os,re

三 使用模塊之from ... import...

1、from...import...的使用 
from spam import read1,read2
2、from...import 與import的對比

#唯一的區別就是：使用from...import...則是將spam中的名字直接導入到當前的名稱空間中，所以在當前名稱空間中，直接使用名字就可以了、無需加前綴：spam.

#from...import...的方式有好處也有壞處
    好處：使用起來方便了
    壞處：容易與當前執行文件中的名字沖突
驗證一：當前位置直接使用read1和read2就好了，執行時，仍然以spam.py文件全局名稱空間

#測試一：導入的函數read1，執行時仍然回到spam.py中尋找全局變量money
#test.py
from spam import read1
money=1000
read1()
‘‘‘
執行結果:
from the spam.py
spam->read1->money 1000
‘‘‘

#測試二:導入的函數read2，執行時需要調用read1(),仍然回到spam.py中找read1()
#test.py
from spam import read2
def read1():
    print(‘==========‘)
read2()

‘‘‘
執行結果:
from the spam.py
spam->read2 calling read
spam->read1->money 1000
‘‘‘
驗證二：如果當前有重名read1或者read2，那麽會有覆蓋效果。

#測試三:導入的函數read1，被當前位置定義的read1覆蓋掉了
#test.py
from spam import read1
def read1():
    print(‘==========‘)
read1()
‘‘‘
執行結果:
from the spam.py
==========
‘‘‘
驗證三：導入的方法在執行時，始終是以源文件為準的

from spam import money,read1
money=100 #將當前位置的名字money綁定到了100
print(money) #打印當前的名字
read1() #讀取spam.py中的名字money,仍然為1000

‘‘‘
from the spam.py
100
spam->read1->money 1000
‘‘‘
3、也支持as

1 from spam import read1 as read
4、一行導入多個名字

from spam import read1,read2,money
5、from...import *

#from spam import * 把spam中所有的不是以下劃線(_)開頭的名字都導入到當前位置

#大部分情況下我們的python程序不應該使用這種導入方式，因為*你不知道你導入什麽名字，很有可能會覆蓋掉你之前已經定義的名字。而且可讀性極其的差，在交互式環境中導入時沒有問題。

from spam import * #將模塊spam中所有的名字都導入到當前名稱空間
print(money)
print(read1)
print(read2)
print(change)

‘‘‘
執行結果:
from the spam.py
1000
<function read1 at 0x1012e8158>
<function read2 at 0x1012e81e0>
<function change at 0x1012e8268>
‘‘‘
可以使用__all__來控制*（用來發布新版本），在spam.py中新增一行

__all__=[‘money‘,‘read1‘] #這樣在另外一個文件中用from spam import *就這能導入列表中規定的兩個名字

四 模塊的重載 (了解)

考慮到性能的原因，每個模塊只被導入一次,放入字典sys.module中，如果你改變了模塊的內容，你必須重啟程序，python不支持重新加載或卸載之前導入的模塊，

有的同學可能會想到直接從sys.module中刪除一個模塊不就可以卸載了嗎，註意了，你刪了sys.module中的模塊對象仍然可能被其他程序的組件所引用，因而不會被清楚。

特別的對於我們引用了這個模塊中的一個類，用這個類產生了很多對象，因而這些對象都有關於這個模塊的引用。

如果只是你想交互測試的一個模塊，使用 importlib.reload(), e.g. import importlib; importlib.reload(modulename)，這只能用於測試環境。

aa.py的初始內容
def func1():
    print(‘func1‘)

執行test.py

1 import time,importlib
2 import aa
3 
4 time.sleep(20)
5 # importlib.reload(aa)
6 aa.func1()

在20秒的等待時間裏，修改aa.py中func1的內容，等待test.py的結果。

打開importlib註釋，重新測試

五 py文件區分兩種用途:模塊與腳本

#編寫好的一個python文件可以有兩種用途：
    一：腳本，一個文件就是整個程序，用來被執行
    二：模塊，文件中存放著一堆功能，用來被導入使用


#python為我們內置了全局變量__name__，
    當文件被當做腳本執行時：__name__ 等於‘__main__‘
    當文件被當做模塊導入時：__name__等於模塊名

#作用：用來控制.py文件在不同的應用場景下執行不同的邏輯
    if __name__ == ‘__main__‘:

#fib.py

def fib(n):    # write Fibonacci series up to n
    a, b = 0, 1
    while b < n:
        print(b, end=‘ ‘)
        a, b = b, a+b
    print()

def fib2(n):   # return Fibonacci series up to n
    result = []
    a, b = 0, 1
    while b < n:
        result.append(b)
        a, b = b, a+b
    return result

if __name__ == "__main__":
    import sys
    fib(int(sys.argv[1]))


#執行：python fib.py <arguments>
python fib.py 50 #在命令行

六 模塊搜索路徑

模塊的查找順序是：內存中已經加載的模塊->內置模塊->sys.path路徑中包含的模塊

#模塊的查找順序
1、在第一次導入某個模塊時（比如spam），會先檢查該模塊是否已經被加載到內存中（當前執行文件的名稱空間對應的內存），如果有則直接引用
    ps：python解釋器在啟動時會自動加載一些模塊到內存中，可以使用sys.modules查看
2、如果沒有，解釋器則會查找同名的內建模塊
3、如果還沒有找到就從sys.path給出的目錄列表中依次尋找spam.py文件。


#sys.path的初始化的值來自於：
The directory containing the input script (or the current directory when no file is specified).
PYTHONPATH (a list of directory names, with the same syntax as the shell variable PATH).
The installation-dependent default.

#需要特別註意的是：我們自定義的模塊名不應該與系統內置模塊重名。雖然每次都說，但是仍然會有人不停的犯錯。 

#在初始化後，python程序可以修改sys.path,路徑放到前面的優先於標準庫被加載。
1 >>> import sys
2 >>> sys.path.append(‘/a/b/c/d‘)
3 >>> sys.path.insert(0,‘/x/y/z‘) #排在前的目錄，優先被搜索
註意：搜索時按照sys.path中從左到右的順序查找，位於前的優先被查找，sys.path中還可能包含.zip歸檔文件和.egg文件，python會把.zip歸檔文件當成一個目錄去處理，

#首先制作歸檔文件：zip module.zip foo.py bar.py 
import sys
sys.path.append(‘module.zip‘)
import foo,bar

#也可以使用zip中目錄結構的具體位置
sys.path.append(‘module.zip/lib/python‘)


#windows下的路徑不加r開頭，會語法錯誤
sys.path.insert(0,r‘C:\Users\Administrator\PycharmProjects\a‘)
 

#至於.egg文件是由setuptools創建的包，這是按照第三方python庫和擴展時使用的一種常見格式，.egg文件實際上只是添加了額外元數據(如版本號，依賴項等)的.zip文件。

#需要強調的一點是：只能從.zip文件中導入.py，.pyc等文件。使用C編寫的共享庫和擴展塊無法直接從.zip文件中加載（此時setuptools等打包系統有時能提供一種規避方法），且從.zip中加載文件不會創建.pyc或者.pyo文件，因此一定要事先創建他們，來避免加載模塊是性能下降。

七 編譯python文件（了解）

為了提高加載模塊的速度，強調強調強調：提高的是加載速度而絕非運行速度。python解釋器會在__pycache__目錄中下緩存每個模塊編譯後的版本，格式為：module.version.pyc。通常會包含python的版本號。例如，在CPython3.3版本下，spam.py模塊會被緩存成__pycache__/spam.cpython-33.pyc。這種命名規範保證了編譯後的結果多版本共存。

Python檢查源文件的修改時間與編譯的版本進行對比，如果過期就需要重新編譯。這是完全自動的過程。並且編譯的模塊是平臺獨立的，所以相同的庫可以在不同的架構的系統之間共享，即pyc使一種跨平臺的字節碼，類似於JAVA火.NET,是由python虛擬機來執行的，但是pyc的內容跟python的版本相關，不同的版本編譯後的pyc文件不同，2.5編譯的pyc文件不能到3.5上執行，並且pyc文件是可以反編譯的，因而它的出現僅僅是用來提升模塊的加載速度的，不是用來加密的

#python解釋器在以下兩種情況下不檢測緩存
#1 如果是在命令行中被直接導入模塊，則按照這種方式，每次導入都會重新編譯，並且不會存儲編譯後的結果（python3.3以前的版本應該是這樣）
    python -m spam.py

#2 如果源文件不存在，那麽緩存的結果也不會被使用，如果想在沒有源文件的情況下來使用編譯後的結果，則編譯後的結果必須在源目錄下
sh-3.2# ls
__pycache__ spam.py
sh-3.2# rm -rf spam.py 
sh-3.2# mv __pycache__/spam.cpython-36.pyc ./spam.pyc
sh-3.2# python3 spam.pyc 
spam
 

#提示：
1.模塊名區分大小寫，foo.py與FOO.py代表的是兩個模塊
2.你可以使用-O或者-OO轉換python命令來減少編譯模塊的大小
    -O轉換會幫你去掉assert語句
    -OO轉換會幫你去掉assert語句和__doc__文檔字符串
    由於一些程序可能依賴於assert語句或文檔字符串，你應該在在確認需要
    的情況下使用這些選項。
3.在速度上從.pyc文件中讀指令來執行不會比從.py文件中讀指令執行更快，只有在模塊被加載時，.pyc文件才是更快的

4.只有使用import語句是才將文件自動編譯為.pyc文件，在命令行或標準輸入中指定運行腳本則不會生成這類文件，因而我們可以使用compieall模塊為一個目錄中的所有模塊創建.pyc文件

模塊可以作為一個腳本（使用python -m compileall）編譯Python源  
python -m compileall /module_directory 遞歸著編譯
如果使用python -O -m compileall /module_directory -l則只一層
  
命令行裏使用compile()函數時，自動使用python -O -m compileall
  
詳見：https://docs.python.org/3/library/compileall.html#module-compileall

八 包介紹

1、什麽是包？
#官網解釋
Packages are a way of structuring Python’s module namespace by using “dotted module names”
包是一種通過使用‘.模塊名’來組織python模塊名稱空間的方式。

#具體的：包就是一個包含有__init__.py文件的文件夾，所以其實我們創建包的目的就是為了用文件夾將文件/模塊組織起來

#需要強調的是：
　　1. 在python3中，即使包下沒有__init__.py文件，import 包仍然不會報錯，而在python2中，包下一定要有該文件，否則import 包報錯

　　2. 創建包的目的不是為了運行，而是被導入使用，記住，包只是模塊的一種形式而已，包的本質就是一種模塊
2、為何要使用包

包的本質就是一個文件夾，那麽文件夾唯一的功能就是將文件組織起來
隨著功能越寫越多，我們無法將所以功能都放到一個文件中，於是我們使用模塊去組織功能，而隨著模塊越來越多，我們就需要用文件夾將模塊文件組織起來，以此來提高程序的結構性和可維護性
3、註意事項

#1.關於包相關的導入語句也分為import和from ... import ...兩種，但是無論哪種，無論在什麽位置，在導入時都必須遵循一個原則：凡是在導入時帶點的，點的左邊都必須是一個包，否則非法。可以帶有一連串的點，如item.subitem.subsubitem,但都必須遵循這個原則。但對於導入後，在使用時就沒有這種限制了，點的左邊可以是包,模塊，函數，類(它們都可以用點的方式調用自己的屬性)。

#2、import導入文件時，產生名稱空間中的名字來源於文件，import 包，產生的名稱空間的名字同樣來源於文件，即包下的__init__.py，導入包本質就是在導入該文件

#3、包A和包B下有同名模塊也不會沖突，如A.a與B.a來自倆個命名空間

九 包的使用

1、示範文件

glance/                   #Top-level package

├── __init__.py      #Initialize the glance package

├── api                  #Subpackage for api

│   ├── __init__.py

│   ├── policy.py

│   └── versions.py

├── cmd                #Subpackage for cmd

│   ├── __init__.py

│   └── manage.py

└── db                  #Subpackage for db

    ├── __init__.py

    └── models.py

#文件內容

#policy.py
def get():
    print(‘from policy.py‘)

#versions.py
def create_resource(conf):
    print(‘from version.py: ‘,conf)

#manage.py
def main():
    print(‘from manage.py‘)

#models.py
def register_models(engine):
    print(‘from models.py: ‘,engine)

包所包含的文件內容
執行文件與示範文件在同級目錄下
2、包的使用之import 

1 import glance.db.models
2 glance.db.models.register_models(‘mysql‘) 
單獨導入包名稱時不會導入包中所有包含的所有子模塊，如

#在與glance同級的test.py中
import glance
glance.cmd.manage.main()

‘‘‘
執行結果：
AttributeError: module ‘glance‘ has no attribute ‘cmd‘

‘‘‘ 
解決方法：

1 #glance/__init__.py
2 from . import cmd
3 
4 #glance/cmd/__init__.py
5 from . import manage

執行：

1 #在於glance同級的test.py中
2 import glance
3 glance.cmd.manage.main()

3、包的使用之from ... import ...

需要註意的是from後import導入的模塊，必須是明確的一個不能帶點，否則會有語法錯誤，如：from a import b.c是錯誤語法

1 from glance.db import models
2 models.register_models(‘mysql‘)
3 
4 from glance.db.models import register_models
5 register_models(‘mysql‘)

4、from glance.api import *

在講模塊時，我們已經討論過了從一個模塊內導入所有*，此處我們研究從一個包導入所有*。

此處是想從包api中導入所有，實際上該語句只會導入包api下__init__.py文件中定義的名字，我們可以在這個文件中定義__all___:

1 #在__init__.py中定義
2 x=10
3 
4 def func():
5     print(‘from api.__init.py‘)
6 
7 __all__=[‘x‘,‘func‘,‘policy‘]

此時我們在於glance同級的文件中執行from glance.api import *就導入__all__中的內容（versions仍然不能導入）。

5、絕對導入和相對導入

我們的最頂級包glance是寫給別人用的，然後在glance包內部也會有彼此之間互相導入的需求，這時候就有絕對導入和相對導入兩種方式：

絕對導入：以glance作為起始

相對導入：用.或者..的方式最為起始（只能在一個包中使用，不能用於不同目錄內）

例如：我們在glance/api/version.py中想要導入glance/cmd/manage.py

1 在glance/api/version.py
2 
3 #絕對導入
4 from glance.cmd import manage
5 manage.main()
6 
7 #相對導入
8 from ..cmd import manage
9 manage.main()
測試結果：註意一定要在於glance同級的文件中測試

1 from glance.api import versions 

6、包以及包所包含的模塊都是用來被導入的，而不是被直接執行的。而環境變量都是以執行文件為準的

比如我們想在glance/api/versions.py中導入glance/api/policy.py，有的同學一抽這倆模塊是在同一個目錄下，十分開心的就去做了，它直接這麽做

1 #在version.py中
2 
3 import policy
4 policy.get()

沒錯，我們單獨運行version.py是一點問題沒有的，運行version.py的路徑搜索就是從當前路徑開始的，於是在導入policy時能在當前目錄下找到

但是你想啊，你子包中的模塊version.py極有可能是被一個glance包同一級別的其他文件導入，比如我們在於glance同級下的一個test.py文件中導入version.py，如下

 1 from glance.api import versions
 2 
 3 ‘‘‘
 4 執行結果:
 5 ImportError: No module named ‘policy‘
 6 ‘‘‘
 7 
 8 ‘‘‘
 9 分析:
10 此時我們導入versions在versions.py中執行
11 import policy需要找從sys.path也就是從當前目錄找policy.py,
12 這必然是找不到的
13 ‘‘‘

# time與datetime模塊

在Python中，通常有這幾種方式來表示時間：

• 時間戳(timestamp)：通常來說，時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量。我們運行“type(time.time())”，返回的是float類型。
• 格式化的時間字符串(Format String)
• 結構化的時間(struct_time)：struct_time元組共有9個元素共九個元素:(年，月，日，時，分，秒，一年中第幾周，一年中第幾天，夏令時)

• 1 import time
  2 #--------------------------我們先以當前時間為準,讓大家快速認識三種形式的時間
  3 print(time.time()) # 時間戳:1487130156.419527
  4 print(time.strftime("%Y-%m-%d %X")) #格式化的時間字符串:‘2017-02-15 11:40:53‘
  5 
  6 print(time.localtime()) #本地時區的struct_time
  7 print(time.gmtime())    #UTC時區的struct_time

格式化字符串的時間格式

%a    Locale’s abbreviated weekday name.     
%A    Locale’s full weekday name.     
%b    Locale’s abbreviated month name.     
%B    Locale’s full month name.     
%c    Locale’s appropriate date and time representation.     
%d    Day of the month as a decimal number [01,31].     
%H    Hour (24-hour clock) as a decimal number [00,23].     
%I    Hour (12-hour clock) as a decimal number [01,12].     
%j    Day of the year as a decimal number [001,366].     
%m    Month as a decimal number [01,12].     
%M    Minute as a decimal number [00,59].     
%p    Locale’s equivalent of either AM or PM.    (1)
%S    Second as a decimal number [00,61].    (2)
%U    Week number of the year (Sunday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Sunday are considered to be in week 0.    (3)
%w    Weekday as a decimal number [0(Sunday),6].     
%W    Week number of the year (Monday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Monday are considered to be in week 0.    (3)
%x    Locale’s appropriate date representation.     
%X    Locale’s appropriate time representation.     
%y    Year without century as a decimal number [00,99].     
%Y    Year with century as a decimal number.     
%z    Time zone offset indicating a positive or negative time difference from UTC/GMT of the form +HHMM or -HHMM, where H represents decimal hour digits and M represents decimal minute digits [-23:59, +23:59].     
%Z    Time zone name (no characters if no time zone exists).     
%%    A literal ‘%‘ character.

 1 #--------------------------按圖1轉換時間
 2 # localtime([secs])
 3 # 將一個時間戳轉換為當前時區的struct_time。secs參數未提供，則以當前時間為準。
 4 time.localtime()
 5 time.localtime(1473525444.037215)
 6 
 7 # gmtime([secs]) 和localtime()方法類似，gmtime()方法是將一個時間戳轉換為UTC時區（0時區）的struct_time。
 8 
 9 # mktime(t) : 將一個struct_time轉化為時間戳。
10 print(time.mktime(time.localtime()))#1473525749.0
11 
12 
13 # strftime(format[, t]) : 把一個代表時間的元組或者struct_time（如由time.localtime()和
14 # time.gmtime()返回）轉化為格式化的時間字符串。如果t未指定，將傳入time.localtime()。如果元組中任何一個
15 # 元素越界，ValueError的錯誤將會被拋出。
16 print(time.strftime("%Y-%m-%d %X", time.localtime()))#2016-09-11 00:49:56
17 
18 # time.strptime(string[, format])
19 # 把一個格式化時間字符串轉化為struct_time。實際上它和strftime()是逆操作。
20 print(time.strptime(‘2011-05-05 16:37:06‘, ‘%Y-%m-%d %X‘))
21 #time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6,
22 #  tm_wday=3, tm_yday=125, tm_isdst=-1)
23 #在這個函數中，format默認為："%a %b %d %H:%M:%S %Y"。

1 #--------------------------按圖2轉換時間
2 # asctime([t]) : 把一個表示時間的元組或者struct_time表示為這種形式：‘Sun Jun 20 23:21:05 1993‘。
3 # 如果沒有參數，將會將time.localtime()作為參數傳入。
4 print(time.asctime())#Sun Sep 11 00:43:43 2016
5 
6 # ctime([secs]) : 把一個時間戳（按秒計算的浮點數）轉化為time.asctime()的形式。如果參數未給或者為
7 # None的時候，將會默認time.time()為參數。它的作用相當於time.asctime(time.localtime(secs))。
8 print(time.ctime())  # Sun Sep 11 00:46:38 2016
9 print(time.ctime(time.time()))  # Sun Sep 11 00:46:38 2016

1 #--------------------------其他用法
2 # sleep(secs)
3 # 線程推遲指定的時間運行，單位為秒。

#時間加減
import datetime

# print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925
#print(datetime.date.fromtimestamp(time.time()) )  # 時間戳直接轉成日期格式 2016-08-19
# print(datetime.datetime.now() )
# print(datetime.datetime.now() + datetime.timedelta(3)) #當前時間+3天
# print(datetime.datetime.now() + datetime.timedelta(-3)) #當前時間-3天
# print(datetime.datetime.now() + datetime.timedelta(hours=3)) #當前時間+3小時
# print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #當前時間+30分


#
# c_time  = datetime.datetime.now()
# print(c_time.replace(minute=3,hour=2)) #時間替換

#random模塊

 1 import random
 2  
 3 print(random.random())#(0,1)----float    大於0且小於1之間的小數
 4  
 5 print(random.randint(1,3))  #[1,3]    大於等於1且小於等於3之間的整數
 6  
 7 print(random.randrange(1,3)) #[1,3)    大於等於1且小於3之間的整數
 8  
 9 print(random.choice([1,‘23‘,[4,5]]))#1或者23或者[4,5]
10  
11 print(random.sample([1,‘23‘,[4,5]],2))#列表元素任意2個組合
12  
13 print(random.uniform(1,3))#大於1小於3的小數，如1.927109612082716 
14  
15  
16 item=[1,3,5,7,9]
17 random.shuffle(item) #打亂item的順序,相當於"洗牌"
18 print(item)

生成隨機驗證碼

import random
def make_code(n):
    res=‘‘
    for i in range(n):
        s1=chr(random.randint(65,90))
        s2=str(random.randint(0,9))
        res+=random.choice([s1,s2])
    return res

print(make_code(9))
..................................
更多模塊介紹請看http://www.cnblogs.com/linhaifeng/articles/6384466.html

Python學習-基礎篇4 模塊與包與常用模塊