python基礎題（53道題詳解）
1、簡述解釋型和編譯型編程語言？
概念：
- 編譯型語言：把做好的源程序全部編譯成二進制代碼的可運行程序。然后，可直接運行這個程序。
- 解釋型語言：把做好的源程序翻譯一句，然后執行一句，直至結束！
區別：
- 編譯型語言，執行速度快、效率高；依賴編譯器、跨平台性差些。如C、C++、Delphi、Pascal，Fortran。
- 解釋型語言，執行速度慢、效率低；依賴解釋器、跨平台性好。如Java、Basic.
2、Python解釋器種類以及特點
- CPython
- c語言開發的 使用最廣的解釋器
- IPython
- 基於cpython之上的一個交互式計時器 交互方式增強 功能和cpython一樣
- PyPy
- 目標是執行效率 采用JIT技術 對python代碼進行動態編譯，提高執行效率
- JPython
- 運行在Java上的解釋器 直接把python代碼編譯成Java字節碼執行
- IronPython
- 運行在微軟 .NET 平台上的解釋器，把python編譯成. NET 的字節碼
3、python常見的PEP8規范
- 每級縮進用4個空格
- Python 3中不允許混合使用Tab和空格縮進。
- 限制所有行的最大行寬為79字符。
- 在核心Python發布的代碼應該總是使用UTF-8(ASCII在Python 2)。
- 推薦絕對路徑導入，因為它們通常更可讀
4、通過代碼實現如下進制轉換：
1 hex() 2 轉換一個整數對象為十六進制的字符串 3 4 >>> hex(16) 5 '0x10' 6 >>> hex(18) 7 '0x12' 8 >>> hex(32) 9 '0x20'
1 oct() 2 轉換一個整數對象為八進制的字符串 3 4 >>> oct(8) 5 '0o10' 6 >>> oct(166) 7 '0o246'
1 bin() 2 轉換一個整數對象為二進制字符串 3 4 >>> bin(10) 5 '0b1010' 6 >>> bin(255) 7 '0b11111111'
1 chr() 2 轉換一個[0, 255]之間的整數為對應的ASCII字符 3 4 >>> chr(65) 5 'A' 6 >>> chr(67) 7 'C' 8 >>> chr(90) 9 'Z' 10 >>> chr(97) 11 'a'
1 ord() 2 將一個ASCII字符轉換為對應整數 3 4 >>> ord('A') 5 65 6 >>> ord('z') 7 122
1 16進制轉10進制 2 >>> int('10', 16) 3 16 4 >>> int('0x10', 16) 5 16 6 7 8進制轉10進制 8 >>> int('0o10', 8) 9 8 10 >>> int('10', 8) 11 8 12 13 2進制轉10進制 14 >>> int('0b1010', 2) 15 10 16 >>> int('1010', 2) 17 10
5、python遞歸的最大層數
1 import sys 2 sys.setrecursionlimit(100000) 3 4 def foo(n): 5 print(n) 6 n += 1 7 foo(n) 8 9 if __name__ == '__main__': 10 foo(1)
得到的最大數字在3925-3929之間浮動，這個是和計算機有關系的，不然也不會是一個浮動的數字了（數學邏輯講求嚴謹）
6、三元運算規則以及應用場景
- 三元運算符就是在賦值變量的時候，可以直接加判斷，然后賦值
- 三元運算符的功能與'if....else'流程語句一致，它在一行中書寫，代碼非常精煉，執行效率更高
- 格式：[on_true] if [expression] else [on_false]
- res = 值1 if 條件 else 值2
7、列舉 Python2和Python3的區別
- input
-
1 問題：如何獲取編碼方式的信息？ 2 獲取目標bytes的編碼方式 3 這一情況可以通過chardet模塊的detect()函數來獲取信息，chardet是第三方庫，可以通過pip來安裝 4 5 b是待檢測的bytes變量 6 7 import chardet 8 print(chardet.detect(b)) 9 ######output#### 10 {'confidence': 1.0, 'encoding': 'ascii'} 11 1 12 2 13 3 14 4 15 5 16 confidence是指匹配程度，encoding是指可能的編碼方式 17 18 獲取當前環境的編碼方式 19 這一情況可以使用sys模塊下的getdefaultencoding()函數來獲取信息 20 21 import sys 22 print(sys.getdefaultencoding()) 23 24 ######## output##### 25 utf-8
- 問題在控制台上看到的到底是什么
1 寫上面的東西的時候產生了一個疑問，現在已經知道Python內部存儲str的方式是使用unicode字符集，但是我們在屏幕上看到的並不是unicode字符集 3 s = "你好" 4 print(s) 6 #########output############# 7 你好 13 s的 unicode 是 \u4f60\u597d 14 1 15 那么，這中間應該是進行了某種轉換 16 實際上，在執行print(str)的時候，python內部執行了encoding操作，控制台拿到的其實是一個bytes變量 17 之后，控制台又根據環境內部的編碼方式，將所得到的bytes內容進行decoding的操作，就顯示了原先str的內容
- 打開文件不再支持 file 方法，只能用 open
- range不再返回列表，而是一個可迭代的range對象
- 除法 / 不再是整除，而是得到浮點數，整除需要用雙斜杠 //
- urllib和urllib2合並成了urllib，常用的urllib2.urlopen()變成了urllib.request.urlopen()
- 字符串及編碼相關有大變動，簡單來說就是原來的str變成了新的bytes，原來的unicode變成了新的str。
8、xrange和range的區別
python2中 xrange 用法與 range 完全相同，所不同的是生成的不是一個list對象，而是一個生成器。
9、python的read() 、readline()、readlines()、xreadlines()
- read()會讀取整個文件，將讀取到底的文件內容放到一個字符串變量，返回str類型。
- readline()讀取一行內容，放到一個字符串變量，返回str類型。
- readlines() 讀取文件所有內容，按行為單位放到一個列表中，返回list類型。
- xreadlines()返回一個生成器，來循環操作文件的每一行。
10、列舉布爾值為False的常見值
None、""、0、[]、()、{}
11、字符串、列表、元組、字典每個常用的5個方法（整型，浮點，字符串，布爾型，列表、元組、字典、集合、日期）
字符串：
# encoding:utf-8 __author__ = 'Fioman' __date__ = '2018/11/19 15:10' # 1. 去掉空格和特殊符號 name = " abcdefgeyameng " name1 = name.strip() # 並不會在原來的字符串上操作,返回一個去除了兩邊空白的字符串 print(name1, len(name1), name, len(name)) # abcdefgeyameng 14 abcdefgeyameng 17 # 去掉左邊的空格和換行符 name2 = name.lstrip() print(name2, len(name2))# print(name2, len(name2))# # 去掉右邊的空格和換行符 name3 = name.rstrip() print(name3, len(name3)) # abcdefgeyameng 15 # 2.字符串的搜索和替換 name.count('e') # 查找某個字符在字符串中出現的次數 name.capitalize() # 首字母大寫 name.center(100,'-') # 把字符串方中間,兩邊用-補齊,100表示占位多少 name.find('a') # 找到這個字符返回下標,多個時返回第一個,不存在時返回-1 name.index('a') # 找到這個字符返回下標,多個時返回第一個,不存在時報錯 print(name.replace(name,'123')) # 字符串的替換 name.replace('abc','123') # 注意字符串的替換的話,不是在原來的字符串上進行替換.而是返回一個替換后的字符串. # 3.字符串的測試和替換函數 name.startswith("abc") # 是否以abc開頭 name.endswith("def") # 是否以def結尾 name.isalnum() # 是否全是字母和數字,並且至少包含一個字符 name.isalpha() # 是否全是字母,並至少包含一個字符 name.isdigit() # 是否全是數字,並且至少包含一個字符 name.isspace() # 是否全是空白字符,並且至少包含一個字符 name.islower() # 是否全是小寫 name.isupper() # 是否全是大寫 name.istitle() # 是否是首字母大寫 # 4.字符串的分割 name.split('') # 默認按照空格進行分隔,從前往后分隔 name.rsplit() # 從后往前進行分隔 # 5.連接字符串 '.'.join(name) # 用.號將一個可迭代的序列拼接起來 name = 'geyameng' # 6.截取字符串(切片) name1 = name[0:3] # 第一位到第三位的字符,和range一樣不包含結尾索引 name2 = name[:] # 截取全部的字符 name3 = name[6:] # 截取第6個字符到結尾 name4 = name[:-3] # 截取從開頭到最后一個字符之前 name5 = name[-1] # 截取最后一個字符 name6 = name[::-1] # 創造一個與原字符串順序相反的字符串 name7 = name[:-5:-1] # 逆序截取
列表：
# encoding:utf-8 __author__ = 'Fioman' __date__ = '2018/11/19 16:26' # 1.創建一個列表 list1 = ['1', '2', '3', '4'] list2 = list("1234") print(list1, list2) print(list1 == list2) # 以上創建的兩個列表是等價的,都是['1', '2', '3', '4'] # 2.添加新元素 # 末尾追加 a = [1, 2, 3, 4, 5] a.append(6) print(a) # 指定位置的前面插入一個元素 a.insert(2, 100) # 在下標為2的前面插入一個元素100 print(a) # 擴展列表list.extend(iterable),在一個列表上追加一個列表 a.extend([10, 11, 12]) print(a) # 3.遍歷列表 # 直接遍歷 for i in a: print(i) # 帶索引的遍歷列表 for index, i in enumerate(a): print(i, index) # 4.訪問列表中的值,直接通過下標取值.list[index] print(a[2]) # 從list刪除元素 # List.remove() 刪除方式1:參數object 如果重復元素,只會刪除最靠前的. a = [1,2,3] a.remove(2) # 返回值是None # List.pop() 刪除方式2:pop 可選參數index,刪除指定位置的元素 默認為最后一個元素 a = [1,2,3,4,5] a.pop() print(a) a.pop(2) print(a) # 終極刪除,可以刪除列表或指定元素或者列表切片,list刪除后無法訪問 a = [1,2,3,4,5,6] del a[1] print(a) # 1, 3, 4, 5, 6] del a[1:] print(a) # 1 del a # print(a) # 出錯,name a is not defined # 排序和反轉代碼 # reverse 反轉列表 a = [1,2,3,4,5] a.reverse() print(a) # sort 對列表進行排序,默認升序排列.有三個默認參數cmp = None,key = None,reverse = False # 7.Python的列表的截取與字符串操作類型相同,如下所示 L = ['spam','Spam','SPAM!'] print(L[-1]) # ['SPAM'] # 8.Python列表操作的函數和方法 len(a) # 列表元素的個數 max(a) # 返回列表元素最大值 min(a) # 返回列表元素最小值 list(tuple) #將一個可迭代對象轉換為列表 # 列表常用方法總結 a.append(4) a.count(1) a.extend([4,5,6]) a.index(3) a.insert(0,2) a.remove() a.pop() a.reverse() a.sort()
元組：
1.用一個可迭代對象生成元組 T = tuple('abc')
對元組進行排序 注意 當對元組進行排序的時候,通常先得將它轉換為列表並使得它成為一個可變對象.或者使用sorted方法,它接收任何序列對象. T = ('c','a','d','b') tmp = list(T) tmp.sort() ==> ['a','b','c','d'] T = tunple(tmp) sorted(T)
字典：
以下實例展示了 fromkeys()函數的使用方法： 實例(Python 2.0+) #!/usr/bin/python # -*- coding: UTF-8 -*- seq = ('Google', 'Runoob', 'Taobao') dict = dict.fromkeys(seq) print "新字典為 : %s" % str(dict) dict = dict.fromkeys(seq, 10) print "新字典為 : %s" % str(dict) 以上實例輸出結果為： 新字典為 : {'Google': None, 'Taobao': None, 'Runoob': None} 新字典為 : {'Google': 10, 'Taobao': 10, 'Runoob': 10}
通過zip函數構建字典
D = dict(zip(keyslist,valueslist))
通過賦值表達式元組構造字典(鍵必須是字符串,因為如果不是字符串,構造的時候也會當成是字符串處理) D = dict(name='Bob',age=42) ==> {'name':'Bob,'age':42}
列出所有的鍵,值.注意得到的是一個可迭代對象,而不是列表.用的時候需要轉換
D.keys()
D.values()
D.items() --> 鍵 + 值
刪除字典(根據鍵)以及長度 D.pop(key) len(D) del D[key]
新增或者是修改鍵對應的值 D[key] = value # 如果key已經存在則修改,如果不存在就創建.
字典推導式 D = [x:x**2 for x in range(10) if x %2 == 0]
12、lambda表達式格式以及應用場景
1、lambda函數與list的結合使用
list = lambda:x for x in range(10) print (list[0]) >>>9 list = lambda x:x for x in range(10) print (list[0]) >>>0
2、map,filter,reduce函數
例子： a = [('a',1),('b',2),('c',3),('d',4)] a_1 = list(map(lambda x:x[0],a)) 如上例子，map函數第一個參數是一個lambda表達式，輸入一個對象，返回該對象的第一個元素。第二個就是需要作用的對象，此處是一個列表。Python3中map返回一個map對象，我們需要人工轉為list，得到的結果就是[‘a’,’b’,’c’,’d’] 例子： a = [1,2,3,4] b = [2,3,4,5] a_1 = list(map(lambda x,y:x+y,a,b)) 上邊這個例子是為了說明,lambda表達式參數可以是多個。返回結果是[3,5,7,9]
例子： a = [1,2,3,4,5,6,7] a_1 = filter(lambda x:x<4,a) 如上例子，定義lambda表達式，篩選a列表中小於4的元素，結果為[1,2,3]。filter函數直接返回一個列表，無需再進行轉換，第三個是初始值，我們沒給初始值，那么開始操作的兩個元素就是序列的前兩個。否則將使用我們給出的初始值和序列第一個元素操作，然后結果再與第三個元素操作，以此類推。上個例子結果是28
例子： from functools import reduce #python3需要導入此模塊 a = [1,2,3,4,5,6,7] a_1 = reduce(lambda x,y:x+y,a) reduce中使用的lambda表達式需要兩個參數，reduce函數共三個參數， 第一個是就是lambda表達式，第二個是要累計的序列，第三個是初始值， 我們沒給初始值，那么開始操作的兩個元素就是序列的前兩個。否則將使 用我們給出的初始值和序列第一個元素操作，然后結果再與第三個元素操 作，以此類推。上個例子結果是28
3、字典多條件排序
例子： dict = {'a':1,'b':2,'c':3,'d':4,'e':3,'f':1,'g':7} sorted_dict_asc = sorted(dict.items(),key=lambda item:item[0]) sorted_dict_dsc = sorted(dict.items(),key=lambda item:item[0],reverse=True) 輸出（第一個升序，第二個降序）： [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 3), ('f', 1), ('g', 7)] [('g', 7), ('f', 1), ('e', 3), ('d', 4), ('c', 3), ('b', 2), ('a', 1)]]
13、pass的作用
pass是空語句占位符，是為了保持程序結構的完整性。
14、*arg和**kwarg作用
定義函數時，使用*arg和**kwarg *arg和**kwarg 可以幫助我們處理上面這種情況，允許我們在調用函數的時候傳入多個實參 def exmaple2(required_arg, *arg, **kwarg): if arg: print "arg: ", arg if kwarg: print "kwarg: ", kwarg exmaple2("Hi", 1, 2, 3, keyword1 = "bar", keyword2 = "foo") >> arg: (1, 2, 3) >> kwarg: {'keyword2': 'foo', 'keyword1': 'bar'} 從上面的例子可以看到，當我傳入了更多實參的時候 *arg會把多出來的位置參數轉化為tuple **kwarg會把關鍵字參數轉化為dict
15、is和==的區別
- Python中對象包含的三個基本要素，分別是：id(身份標識)、type(數據類型)和value(值)。
- ==是python標准操作符中的比較操作符，用來比較判斷兩個對象的value(值)是否相等
- is也被叫做同一性運算符，這個運算符比較判斷的是對象間的唯一身份標識，也就是id是否相同。
只有數值型和字符串型的情況下，a is b才為True，當a和b是tuple，list，dict或set型時，a is b為False。
16、簡述Python的深淺拷貝以及應用場景
深淺拷貝用法來自copy模塊。
導入模塊：import copy
淺拷貝：copy.copy
深拷貝：copy.deepcopy
對於 數字 和 字符串 而言，賦值、淺拷貝和深拷貝無意義，因為其永遠指向同一個內存地址。
字面理解：淺拷貝指僅僅拷貝數據集合的第一層數據，深拷貝指拷貝數據集合的所有層。所以對於只有一層的數據集合來說深淺拷貝的意義是一樣的，比如字符串，數字，還有僅僅一層的字典、列表、元祖等.
字典（列表）的深淺拷貝
賦值：
import copy
n1 = {'k1':'wu','k2':123,'k3':['alex',678]}
n2 = n1
淺拷貝：
import copy
n1 = {'k1':'wu','k2':123,'k3':['alex',678]}
n3 = copy.copy(n1)
深拷貝：
import copy
n1 = {'k1':'wu','k2':123,'k3':['alex',678]}
n4 = copy.deepcopy(n1)
深拷貝的時候python將字典的所有數據在內存中新建了一份，所以如果你修改新的模版的時候老模版不會變。相反，在淺copy 的時候，python僅僅將最外層的內容在內存中新建了一份出來，字典第二層的列表並沒有在內存中新建，所以你修改了新模版，默認模版也被修改了。
17、Python是如何進行內存管理的
答:從三個方面來說,一對象的引用計數機制,二垃圾回收機制,三內存池機制
一、對象的引用計數機制
Python內部使用引用計數，來保持追蹤內存中的對象，所有對象都有引用計數。
引用計數增加的情況：
1，一個對象分配一個新名稱
2，將其放入一個容器中（如列表、元組或字典）
引用計數減少的情況：
1，使用del語句對對象別名顯示的銷毀
2，引用超出作用域或被重新賦值
Sys.getrefcount( )函數可以獲得對象的當前引用計數
多數情況下，引用計數比你猜測得要大得多。對於不可變數據（如數字和字符串），解釋器會在程序的不同部分共享內存，以便節約內存。
二、垃圾回收
1，當一個對象的引用計數歸零時，它將被垃圾收集機制處理掉。
2，當兩個對象a和b相互引用時，del語句可以減少a和b的引用計數，並銷毀用於引用底層對象的名稱。然而由於每個對象都包含一個對其他對象的應用，因此引用計數不會歸零，對象也不會銷毀。（從而導致內存泄露）。為解決這一問題，解釋器會定期執行一個循環檢測器，搜索不可訪問對象的循環並刪除它們。
三、內存池機制
Python提供了對內存的垃圾收集機制，但是它將不用的內存放到內存池而不是返回給操作系統。
1，Pymalloc機制。為了加速Python的執行效率，Python引入了一個內存池機制，用於管理對小塊內存的申請和釋放。
2，Python中所有小於256個字節的對象都使用pymalloc實現的分配器，而大的對象則使用系統的malloc。
3，對於Python對象，如整數，浮點數和List，都有其獨立的私有內存池，對象間不共享他們的內存池。也就是說如果你分配又釋放了大量的整數，用於緩存這些整數的內存就不能再分配給浮點數。
18、Python的可變類型和不可變類型
- 數字、字符串、元組是不可變的，列表、字典是可變的。
對象池：
小整數對象池
[-5, 256] 這些小整數被定義在了一個整數對象池里，當引用小整數時會自動引用整數對象池里的對象，所以這些小整數不會重復創建，當多個變量指向同一個小整數時，實質上它們指向的是同一個對象。
字符串對象池
字符串對象是不可變對象，python有個intern機制，簡單說就是維護一個字典，這個字典維護已經創建字符串(key)和它的字符串對象的地址(value)，每次創建字符串對象都會和這個字典比較，沒有就創建，重復了就用指針進行引用就可以了。intern機制處理字符串長度小於等於20且僅由數字字母下划線構成的，只創建一次。
19、列舉常見的內置函數
數學相關
- abs(a) : 求取絕對值。abs(-1)
- max(list) : 求取list最大值。max([1,2,3])
- min(list) : 求取list最小值。min([1,2,3])
- sum(list) : 求取list元素的和。 sum([1,2,3]) >>> 6
- sorted(list) : 排序，返回排序后的list。
- len(list) : list長度,len([1,2,3])
- divmod(a,b): 獲取商和余數。 divmod(5,2) >>> (2,1)
- pow(a,b) : 獲取乘方數。pow(2,3) >>> 8
- round(a,b) : 獲取指定位數的小數。a代表浮點數，b代表要保留的位數。round(3.1415926,2) >>> 3.14
- range(a[,b]) : 生成一個a到b的數組,左閉右開。 range(1,10) >>> [1,2,3,4,5,6,7,8,9]
類型轉換
- int(str) : 轉換為int型。int('1') >>> 1
- float(int/str) : 將int型或字符型轉換為浮點型。float('1') >>> 1.0
- str(int) : 轉換為字符型。str(1) >>> '1'
- bool(int) : 轉換為布爾類型。 str(0) >>> False str(None) >>> False
- bytes(str,code) : 接收一個字符串，與所要編碼的格式，返回一個字節流類型。bytes('abc', 'utf-8') >>> b'abc' bytes(u'爬蟲', 'utf-8') >>> b'\xe7\x88\xac\xe8\x99\xab'
- list(iterable) : 轉換為list。 list((1,2,3)) >>> [1,2,3]
- iter(iterable)： 返回一個可迭代的對象。 iter([1,2,3]) >>> <list_iterator object at 0x0000000003813B00>
- dict(iterable) : 轉換為dict。 dict([('a', 1), ('b', 2), ('c', 3)]) >>> {'a':1, 'b':2, 'c':3}
- enumerate(iterable) : 返回一個枚舉對象。
- tuple(iterable) : 轉換為tuple。 tuple([1,2,3]) >>>(1,2,3)
- set(iterable) : 轉換為set。 set([1,4,2,4,3,5]) >>> {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) >>> {1,2,3}
- hex(int) : 轉換為16進制。hex(1024) >>> '0x400'
- oct(int) : 轉換為8進制。 oct(1024) >>> '0o2000'
- bin(int) : 轉換為2進制。 bin(1024) >>> '0b10000000000'
- chr(int) : 轉換數字為相應ASCI碼字符。 chr(65) >>> 'A'
- ord(str) : 轉換ASCI字符為相應的數字。 ord('A') >>> 65
相關操作
- eval() : 執行一個表達式，或字符串作為運算。 eval('1+1') >>> 2
- exec() : 執行python語句。 exec('print("Python")') >>> Python
- filter(func, iterable) : 通過判斷函數fun，篩選符合條件的元素。 filter(lambda x: x>3, [1,2,3,4,5,6]) >>> <filter object at 0x0000000003813828>
- map(func, *iterable) : 將func用於每個iterable對象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) >>> [6,8,10]
- zip(*iterable) : 將iterable分組合並。返回一個zip對象。 list(zip([1,2,3],[4,5,6])) >>> [(1, 4), (2, 5), (3, 6)]
- type()：返回一個對象的類型。
- id()： 返回一個對象的唯一標識值。
- hash(object)：返回一個對象的hash值，具有相同值的object具有相同的hash值。 hash('python') >>> 7070808359261009780
- help()：調用系統內置的幫助系統。
- isinstance()：判斷一個對象是否為該類的一個實例。
- issubclass()：判斷一個類是否為另一個類的子類。
- globals() : 返回當前全局變量的字典。
- next(iterator[, default]) : 接收一個迭代器，返回迭代器中的數值，如果設置了default，則當迭代器中的元素遍歷后，輸出default內容。
- reversed(sequence) ： 生成一個反轉序列的迭代器。 reversed('abc') >>> ['c','b','a']
20、Python寫9*9乘法表的兩種簡單方法
1 for i in range(1,10): 2 for j in range(1,i+1): 3 print("%s * %s = %s" %(j,i,i*j),end="") 4 print("")
print "\n".join("\t".join(["%s*%s=%s" %(x,y,x*y) for y in range(1, x+1)]) for x in range(1, 10))
21、如何安裝第三方模塊？以及用過哪些第三方模塊？
pip install 模塊名
一、Python爬蟲
1. 請求
requests（第三方模塊）
2. 解析：
bs4（即beautifulsoup，第三方模塊）
3. 儲存：
把數據寫入MongoDB
MySQL-python（第三方模塊）：
把數據寫入MySQL里面。
協程：gevent（第三方模塊）
二、Python數據分析&科學計算
Copy了MATLAB的數據結構。很多數據分析和科學計算庫的底層模塊。提供了良好的數組數據結構和C拓展接口。
Copy了R的data frame的數據結構。
22、常用模塊都有那些？
1 import time 2 import datetime 3 4 print(time.asctime()) # 返回時間格式：Sun May 7 21:46:15 2017 5 print(time.time()) # 返回時間戳 ‘1494164954.6677325’ 6 print(time.gmtime()) # 返回本地時間 的struct time對象格式，time.struct_time(tm_year=2017, tm_mon=5, tm_mday=7, tm_hour=22, tm_min=4, tm_sec=53, tm_wday=6, tm_yday=127, tm_isdst=0) 7 print(time.localtime()) # 返回本地時間 的struct time對象格式，time.struct_time(tm_year=2017, tm_mon=5, tm_mday=7, tm_hour=22, tm_min=4, tm_sec=53, tm_wday=6, tm_yday=127, tm_isdst=0) 8 print(time.gmtime(time.time()-800000)) # 返回utc時間的struc時間對象格式 9 print(time.asctime(time.localtime())) # 返回時間格式Sun May 7 22:15:09 2017 10 print(time.ctime()) # 返回時間格式Sun May 7 22:15:09 2017 11 print(time.strftime('%Y-%m-%d')) #默認當前時間 2017-05-07 12 print(time.strftime('%Y-%m-%d',time.localtime())) #默認當前時間 2017-05-07 13 14 string_struct = time.strptime("2016/05/22","%Y/%m/%d") # 將日期字符串 轉成 struct時間對象格式 15 print(string_struct) # 返回struct time對象格式 time.struct_time(tm_year=2016, tm_mon=5, tm_mday=22, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=143, tm_isdst=-1) 16 17 # 將日期字符串轉成時間戳 18 struct_stamp = time.mktime(string_struct) # 將struct time時間對象轉成時間戳 19 print(struct_stamp) # 返回時間戳 ‘1463846400.0’ 20 21 # 將時間戳轉為字符串格式 22 print(time.gmtime(time.time()-86640)) # 將utc時間戳轉換成struct_time格式 23 print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) # 將utc struct_time格式轉成指定的字符串格式 24 25 26 # 時間加減 27 print(datetime.datetime.now()) # 返回當前時間 2017-05-07 22:36:45.179732 28 print(datetime.date.fromtimestamp(time.time())) # 時間戳直接轉換成日期格式 2017-05-07 29 print(datetime.datetime.now() + datetime.timedelta(3)) # 返回時間在當前日期上 +3 天 30 print(datetime.datetime.now() + datetime.timedelta(-3)) # 返回時間在當前日期上 -3 天 31 print(datetime.datetime.now() + datetime.timedelta(hours= 3)) # 返回時間在當前時間上 +3 小時 32 print(datetime.datetime.now() + datetime.timedelta(minutes= 30)) # 返回時間在當前時間上 +30 分鍾 33 34 c_time = datetime.datetime.now() 35 print(c_time) # 當前時間為 2017-05-07 22:52:44.016732 36 print(c_time.replace(minute=3,hour=2)) # 時間替換 替換時間為‘2017-05-07 02:03:18.181732’ 37 38 print(datetime.timedelta) # 表示時間間隔，即兩個時間點之間的長度 39 print (datetime.datetime.now() - datetime.timedelta(days=5)) # 返回時間在當前時間上 -5 天 40 41 # python 日歷模塊 42 import calendar 43 44 print(calendar.calendar(theyear= 2017)) # 返回2017年整年日歷 45 print(calendar.month(2017,5)) # 返回某年某月的日歷，返回類型為字符串類型 46 47 calendar.setfirstweekday(calendar.WEDNESDAY) # 設置日歷的第一天(第一天以星期三開始） 48 cal = calendar.month(2017, 4) 49 print (cal) 50 51 print(calendar.monthrange(2017,5)) # 返回某個月的第一天和這個月的所有天數 52 print(calendar.monthcalendar(2017,5)) # 返回某個月以每一周為元素的序列 53 54 cal = calendar.HTMLCalendar(calendar.MONDAY) 55 print(cal.formatmonth(2017, 5)) # 在html中打印某年某月的日歷 56 57 print(calendar.isleap(2017)) # 判斷是否為閏年 58 print(calendar.leapdays(2000,2017)) # 判斷兩個年份間閏年的個數
1 import random 2 3 # 隨機數 4 print(random.random()) # 返回一個隨機小數'0.4800545746046827' 5 print(random.randint(1,5)) # 返回（1-5）隨機整型數據 6 print(random.randrange(1,10)) # 返回（1-10）隨機數據 7 8 # 生成隨機驗證碼 9 code = '' 10 for i in range(4): 11 current = random.randrange(0,4) 12 if current != i: 13 temp = chr(random.randint(65,90)) 14 else: 15 temp = random.randint(0,9) 16 code += str(temp) 17 18 print(code)
import os print(os.getcwd()) # 獲得當前工作目錄 print(os.chdir("dirname")) # 改變當前腳本的工作路徑，相當於shell下的cd print(os.curdir) # 返回當前目錄‘.' print(os.pardir) # 獲取當前目錄的父目錄字符串名‘..' print(os.makedirs('dirname1/dirname2')) # 可生成多層遞歸目錄 print(os.removedirs('dirname1/dirname2')) # 若目錄為空，則刪除，並遞歸到上一級目錄，如若也為空，則刪除，依此類推 print(os.mkdir('test4')) # 生成單級目錄；相當於shell中mkdir dirname print(os.rmdir('test4')) # 刪除單級空目錄，若目錄不為空則無法刪除，報錯；相當於shell中rmdir dirname print(os.listdir('/pythonStudy/s12/test')) # 列出指定目錄下的所有文件和子目錄，包括隱藏文件，並以列表方式打印 print(os.remove('log.log')) # 刪除一個指定的文件 print(os.rename("oldname","newname")) # 重命名文件/目錄) print(os.stat('/pythonStudy/s12/test')) # 獲取文件/目錄信息 print(os.pathsep) # 輸出用於分割文件路徑的字符串';' print(os.name) # 輸出字符串指示當前使用平台。win->'nt'; Linux->'posix' print(os.system(command='bash')) # 運行shell命令，直接顯示 print(os.environ) # 獲得系統的環境變量 print(os.path.abspath('/pythonStudy/s12/test')) # 返回path規范化的絕對路徑 print(os.path.split('/pythonStudy/s12/test')) # 將path分割成目錄和文件名二元組返回 print(os.path.dirname('/pythonStudy/s12/test')) # 返回path的目錄。其實就是os.path.split(path)的第一個元素 print(os.path.basename('/pythonStudy/s12/test')) # 返回path最后的文件名。如果path以／或\結尾，那么就會返回空值。即os.path.split(path)的第二個元素 print(os.path.exists('test')) # 判斷path是否存在 print(os.path.isabs('/pythonStudy/s12/test')) # 如果path是絕對路徑，返回True print(os.path.isfile('test')) # 如果path是一個存在的文件，返回True。否則返回False print(os.path.isdir('/pythonStudy/s12/test')) # 如果path是一個存在的目錄，則返回True。否則返回False print(os.path.getatime('/pythonStudy/s12/test')) # 返回path所指向的文件或者目錄的最后存取時間 print(os.path.getmtime('/pythonStudy/s12/test')) # 返回path所指向的文件或者目錄的最后修改時間
import sys print(sys.argv) # 命令行參數List，第一個元素是程序本身路徑 print(sys.exit(n)) # 退出程序，正常退出時exit(0) print(sys.version) # 獲取python的版本信息 print(sys.path) # 返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值 print(sys.platform) # 返回操作平台的名稱
# xml的格式如下，就是通過<>節點來區別數據結構的: import xml.etree.ElementTree as ET tree = ET.parse("xmltest.xml") root = tree.getroot() print(root.tag) #遍歷xml文檔 for child in root: print(child.tag, child.attrib) for i in child: print(i.tag,i.text) #只遍歷year 節點 for node in root.iter('year'): print(node.tag,node.text) # 修改和刪除xml文檔內容 import xml.etree.ElementTree as ET tree = ET.parse("xmltest.xml") root = tree.getroot() #修改 for node in root.iter('year'): new_year = int(node.text) + 1 node.text = str(new_year) node.set("updated","yes") tree.write("xmltest.xml") #刪除node for country in root.findall('country'): rank = int(country.find('rank').text) if rank > 50: root.remove(country) tree.write('output.xml') # 自己創建xml文檔 import xml.etree.ElementTree as ET new_xml = ET.Element("namelist") name = ET.SubElement(new_xml, "name", attrib={"enrolled": "yes"}) age = ET.SubElement(name, "age", attrib={"checked": "no"}) age = ET.SubElement(name, "age") age.text = '33' name2 = ET.SubElement(new_xml, "name", attrib={"enrolled": "no"}) age = ET.SubElement(name2, "age") age.text = '19' et = ET.ElementTree(new_xml) # 生成文檔對象 et.write("test.xml", encoding="utf-8", xml_declaration=True) ET.dump(new_xml) # 打印生成的格式
python的logging模塊提供了標准的日志接口，你可以通過它存儲各種格式的日志，logging的日志可以分為 debug(), info(), warning(), error() and critical() 5個級別。
import logging # %(message)s 日志信息 # %（levelno)s 日志級別 # datefmt 設置時間格式 # filename 設置日志保存的路徑 # level=loggin.INFO意思是，把日志紀錄級別設置為INFO，也就是說，只有比日志是INFO或比INFO級別更高的日志才會被紀錄到文件里， # 在這個例子， 第一條日志是不會被紀錄的，如果希望紀錄debug的日志，那把日志級別改成DEBUG就行了。 logging.basicConfig(format='%(asctime)s %(message)s %(levelno)s', datefmt='%m/%d/%Y %I:%M:%S %p',filename='example.log',level=logging.INFO) logging.debug('This message should go to the log file') logging.info('So should this')