摘要：本人很少寫代碼一般都是用的去年時(shí)用寫過一些收集系統(tǒng)信息的工具當(dāng)時(shí)是邊看手冊(cè)邊寫的如今又要用來寫一個(gè)生成的工具就又需要查看手冊(cè)了至于為什么不用寫那是因?yàn)榈膸觳患嫒萦乐性谶@里不得不說雖然很火但是一些庫還是不如多不如兼容性好為了避免以后再出這種事

本人很少寫 python 代碼, 一般都是用 go 的, 去年時(shí)用 python 寫過一些收集系統(tǒng)信息的工具, 當(dāng)時(shí)是邊看手冊(cè)邊寫的. 如今又要用 python 來寫一個(gè)生成 xlsx 的工具, 就又需要查看手冊(cè)了, 至于為什么不用 go 寫? 那是因?yàn)?go 的庫不兼容永中. 在這里不得不說, 雖然 go 很火, 但是一些庫還是不如 python 多, 不如 python 兼容性好.

為了避免以后再出這種事情, 這次就好好的了解下 python, 將它的用法按照自己對(duì)語言的理解分塊記錄下來. 要使用某種語言, 個(gè)人認(rèn)為需要了解這些方面:

編碼風(fēng)格

變量的類型, 聲明及使用方式

輸入/輸出

控制語句的寫法

錯(cuò)誤處理的用法

函數(shù)的用法, 還有語言支持的一些特性, python 中就有裝飾器, lambda 語句等

對(duì)于面向?qū)ο笳Z言還需要了解類的聲明, 繼承, 多態(tài)等的用法

還有一些就是此語言的一些特性, python 就還需要了解以下特性:

模塊的使用

下文就將按照這些內(nèi)容來一一記錄.

變量名, 方法名和模塊名建議小寫, 單詞以 _ 分割, 類名建議駝峰命名風(fēng)格, 首字母大寫, 私有類可用一個(gè) _ 開頭.

每行結(jié)尾盡量不要添加 ;, 多行代碼也不要寫在一行

python 是以縮進(jìn)來控制代碼段的, 所以縮減建議使用 4 個(gè)空格

編碼盡量使用 utf-8, python 默認(rèn)使用 ASCII, 所以要在文件的開頭添加 # -*- coding: UTF-8 -*- 或者 #coding=utf-8 來指定

python 有獨(dú)一無二的注釋方式: 文檔字符串, 所以注釋盡量用文檔字符串("""xxxx""")

如果一個(gè)類不從其他類繼承, 就顯示的從 object 類繼承

使用 with 語句來管理文件, 如 open 或 close

添加 TODO 時(shí), 盡量在其后緊跟 (), 在里面寫明作者名或 email 等其他標(biāo)識(shí)信息, 然后緊跟一個(gè) : 后面接著寫要做的事情

每個(gè)導(dǎo)入模塊都占一行, 不要一行導(dǎo)入多個(gè)模塊

盡量定義一個(gè) main 函數(shù), 將主程序放入其中, 并在 "if name = "__main__":" 成立時(shí)執(zhí)行 =main, 這樣被當(dāng)作模塊導(dǎo)入時(shí)就不會(huì)執(zhí)行主程序

Python 是動(dòng)態(tài)語言, 變量的類型不固定, 根據(jù)值的類型而決定, 所以不用顯示的聲明變量， 用的時(shí)候直接賦值即可，如下:

a = 1; // 此時(shí)是整型
print(a);
a = "hello"; // 此時(shí)又為字符串類型

通常變量名全部大寫的為 常量, 空值 用 None 表示.

以 _xxx 或 __xxx 命名的函數(shù)或變量是私有變量, 不能被其他模塊直接引用

這里將整型, 浮點(diǎn)型, 布爾和字符串看作是基本類型, 整型和浮點(diǎn)型的使用就不再介紹了, 布爾的值只能為 True/False, 而字符串的常見操作如下:

使用 """ 或 """ 可以嵌入長(zhǎng)字符串

字符串可以通過下標(biāo)來索引, len 函數(shù)獲取長(zhǎng)度

使用 + 進(jìn)行拼接操作

字符串對(duì)象還內(nèi)置了很多方法提供了一些常見功能, 具體請(qǐng)查閱手冊(cè)

另外它們之間的相互轉(zhuǎn)換是通過 int(arg), float(arg), str(arg) 這些內(nèi)置的方法來處理的.

列表中可以包含不同類型的數(shù)據(jù), 如:

list = ["eggs", 1, 67.12];

通過 list(seq) 可以將一個(gè)序列轉(zhuǎn)換為列表.

array 模塊提供了固定類型的數(shù)據(jù), 可以指定要轉(zhuǎn)換的類型, 具體請(qǐng)查閱手冊(cè).

列表通過下標(biāo)索引, len 函數(shù)獲取大小.

列表對(duì)象常用的方法如下:

append(item): 附加元素

insert(idx, item): 插入元素

pop(idx): 刪除指定位置的元素, 參數(shù)為空則刪除最后一個(gè)元素

列表遍歷:

for  in :
    // do

// 帶下標(biāo)
for idx, name in enumerate():
    // do

// 列表中多個(gè)元素
for x, y in [(1, 1), (2, 4), (3, 9)]:
    // do

// 用 zip 同時(shí)遍歷多個(gè)數(shù)組
a = [1, 2];
b = [5, 6];
for av, bv in zip(a, b):
    // do av=1, bv=5

// 生成
[x * x for x in range(1, 11) if x % 2 == 0]

元組(tuple) 是一個(gè)不可修改的列表, 元組中每個(gè)元素的指向是不可更改的, 但指向里的內(nèi)容是可以更改的, 如元組中包含一個(gè)數(shù)組:

t = ("1", 1, ["A", "B"]);
t[2][0] = "X";
t[2][1] = "Y";

語法:

dict = {"":}

常用的對(duì)象方法:

get(key, value): 獲取指定 key 的值, 如果不存在則返回 value, 如果 value 未指定則返回 None

pop(key): 刪除指定的 key

使用字典需要注意以下幾點(diǎn):

字典中的 key 不能重復(fù)

字典中的 key 不可變, 所以只能用數(shù)字, 字符串和元組

字典的值則沒有限制, 可以是任意對(duì)象

集合與字典類似, 是一組 key 的集合, 但不存儲(chǔ) value, 沒有重復(fù)的 key.

要?jiǎng)?chuàng)建一個(gè)集合, 需要傳入一個(gè)數(shù)組, 重復(fù)的元素會(huì)被自動(dòng)過濾.

遍歷:

for  in :
    // do

// 帶下標(biāo)
for idx, name in dict.items():
    // do

s = set([1, 2, 3 ,3]); // s: {1,2,3}

常用的對(duì)象方法:

add(key): 添加 key

remove(key): 刪除 key

global 關(guān)鍵字用于聲明變量的作用域, 用法如下:

# 全局變量
a = 1

def test():
    # 若下面這行注釋掉, 則下面的 a 是局部變量, "Global" 處的輸出還是全局變量 1
    # 若下面這行取消注釋, 則下面的 a 是全局變量, "Gloabl" 出的輸出是 5
    # global a
    a = 5
    print("In test:", a)

# Global
print("Global:", a)

輸出, global a 注釋掉時(shí):

In test: 5
Global: 1

輸出, global a 取消注釋時(shí):

In test: 5
Global: 5

上面的只是基礎(chǔ)，想要更好的使用變量，還需要了解以下內(nèi)容：

類型對(duì)象的方法

python 中每種類型都是對(duì)象, 都提供了一些內(nèi)置方法, 如字符串類型的 replace() 等

變量的內(nèi)存分配

變量只是值的引用, 具體的內(nèi)存分配是在值的這一邊, 有些類型的值是不可變的, 這些是需要深入了解的

結(jié)構(gòu)體

python 中沒有結(jié)構(gòu)體, 可以使用下列方式實(shí)現(xiàn):

使用 struct 模塊來實(shí)現(xiàn), 需要了解與 c 中類型的格式對(duì)照, 創(chuàng)建時(shí)需要指定結(jié)構(gòu)體的成員類型

使用類來實(shí)現(xiàn), 在類的構(gòu)造函數(shù) __init__ 中定義結(jié)構(gòu)體成員

使用 raw_input(prompt) 可以接受控制臺(tái)的輸入

使用 print() 可以打印內(nèi)容到控制臺(tái), 格式化輸出:

n = 1;
s = "Joy";
print("The %d student"s name is %s" % (n, s));

也可以使用 format 來格式化, 它會(huì)用傳入的參數(shù)依次替換字符串內(nèi)的占位符 {0}、{1}…… :

// {3:.1f} 表示保留一位小數(shù)
s = "The {0} student"s name is {1}, score: {3:.1f}".format(1, "Joy", 87.75);
print(s);

控制語句中可以使用 break, continue, pass 關(guān)鍵字, break 與 continue 的作用與其他語言中的一樣, pass 則是一個(gè)空語句, 不做任何事情, 一般是為了保持結(jié)構(gòu)的完整性, 常被用來占位, 表明之后會(huì)實(shí)現(xiàn).

注意: python 中沒有 goto 和 switch.

語法:

if :
elif :
else:

for  in :
    // do
else:

else 可選

while :
    // do
else:

else 可選

語法:

try:
    // do
except  as e:
   // do
except  as e:
else:
   // no error
finally:
   // do

如果 finally 存在, 則無論有沒有異常都會(huì)執(zhí)行, else 則在 except 都沒進(jìn)入時(shí)才執(zhí)行.

語法:

def func(arg1, arg2=value, arg3=value):
    // do
    return ret1, ret2

# 不定長(zhǎng)參數(shù)
def func(arg1, *vartuple):
   "打印所有參數(shù)"
   print(arg1)
   for var in vartuple:
       print(var)
   return

定義函數(shù)時(shí)可以給參數(shù)指定默認(rèn)值, 這樣在調(diào)用時(shí)就可以不傳入這些參數(shù), 沒有默認(rèn)值的參數(shù)是必須要傳入的.

定義默認(rèn)參數(shù)要牢記一點(diǎn)：默認(rèn)參數(shù)必須指向不變對(duì)象(數(shù), 字符串, 元組)！

參數(shù)前加了 * 的變量會(huì)存放所有未命名的變量.

__name__ 是函數(shù)對(duì)象的一個(gè)屬性, 可以拿到此函數(shù)的名稱

使用關(guān)鍵字 lambda, 就可以創(chuàng)建短小的匿名函式, 如:

# 語法
lambda [arg1 [,arg2,.....argn]]:expression

sum = lambda arg1, arg2: arg1 + arg2
print(sum(10, 10) # 20
print(sum(10, 20) # 30

特點(diǎn):

lambda 只是一個(gè)表達(dá)式, 函數(shù)體比 def 簡(jiǎn)單的多, 近能封裝有限的邏輯進(jìn)去

lambda 函數(shù)擁有自己的命名空間, 并且不能訪問自有參數(shù)之外或全局命名的參數(shù)

lambda 函數(shù)雖然間短, 但不等同于 內(nèi)聯(lián)函數(shù)

當(dāng)需要增強(qiáng)某個(gè)函數(shù)的功能時(shí), 但有不希望修改函數(shù), 此時(shí)可以使用裝飾器. 如添加日志功能:

def log(func):
    def wrapper(*args, **kw):
        print("call %s():" % func.__name__)
        return func(*args, **kw)
    return wrapper

@log
def test():
    print("Test")

通過 @ 語法就給函數(shù) test 添加了日志功能

模塊就是一個(gè) python 文件, 使用 import 導(dǎo)入模塊, 調(diào)用模塊中的方法時(shí)就必須以 . 來調(diào)用.

from import ,... 語句是從模塊中導(dǎo)入指定的函數(shù), from import * 則將模塊中的所有方法都導(dǎo)入

導(dǎo)入一個(gè)模塊時(shí)的路徑搜索順序如下:

先從當(dāng)前目錄查找是否有此模塊

如果當(dāng)前目錄沒有, 就從 PYTHONPATH 定義的目錄下查找

如果都找不到, 就查看默認(rèn)路徑, linux 下一般是 /usr/lib/python

搜索路徑定義在 sys.path 中, 可以用 append 函數(shù)來添加指定目錄, 如項(xiàng)目中模塊不再同一個(gè)目錄就可以添加 path 來導(dǎo)入

python 中的包就是一個(gè)分層次的目錄, 定義了一個(gè)由模塊及子包組成的環(huán)境.

包簡(jiǎn)單來說就是一個(gè)目錄, 目錄中必須包含一個(gè) __init__.py, 該文件可以為空, 目的使用來標(biāo)識(shí)這個(gè)目錄是一個(gè)包, 一個(gè)簡(jiǎn)單的例子如下:

如存在目錄 package_test , 此目錄下有 __init__.py, foo1.py, foo2.py 等文件

foo1.py 文件:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

def foo1():
    print("Foo1 test")

foo2.py 文件:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

def foo2():
    print("Foo2 test")

調(diào)用:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from package_test.foo1 import foo1
from package_test.foo2 import foo2

if __name__ == "__main__":
    foo1()
    foo2()

python 是一門面向?qū)ο笳Z言, 所以創(chuàng)建類和對(duì)象是很容易的, 先簡(jiǎn)單介紹下面向?qū)ο蟮囊恍┗咎卣?

類: 用來描述具有相同屬性和方法的對(duì)象的集合, 定義了每個(gè)對(duì)象共有的屬性和方法, 對(duì)象是類的實(shí)例

數(shù)據(jù)成員: 類中的變量, 用于處理類及對(duì)象的相關(guān)的數(shù)據(jù)

私有成員: 只能在類的內(nèi)部方法中訪問的成員

受保護(hù)成員: 只能由本類或子類訪問的成員

公有成員: 全局的, 類內(nèi)部, 外部和子類都能訪問的成員

方法: 類中定義的函數(shù)

方法重寫: 如果從父類繼承的方法不滿足需求, 可以對(duì)其重新實(shí)現(xiàn), 這個(gè)過程就叫重寫

操作符重載: 自定義某些操作符的功能, 如 + 操作符, 指明2個(gè)對(duì)象的數(shù)據(jù)如何相加

繼承: 從一個(gè)父類派生出一個(gè)子類

多態(tài): 如果多個(gè)對(duì)象都繼承子一個(gè)父類, 通過傳入一個(gè)父類變量來調(diào)用某個(gè)方法時(shí), 如果此時(shí)傳入的是子類的對(duì)象, 則會(huì)調(diào)用這個(gè)子類中實(shí)現(xiàn)的方法(方法已被重寫)

python 中類創(chuàng)建的語法如下:

# 創(chuàng)建一個(gè)類
class Human:
    # 類變量
    var1 = 0 # 公有成員
    _var2 = 0 # 受保護(hù)成員
    __var3 = 0 # 私有成員

    # 構(gòu)造函數(shù), 里面可以定義實(shí)例變量, 這些變量只有在這個(gè)函數(shù)調(diào)用后才能使用, 子類如果重寫了構(gòu)造函數(shù), 則不能使用這些變量
    def __init__(self, arg1, arg2...):
        self.arg1 = arg1
        self._arg2 = arg2
        self.__arg3 = arg3

    # 類方法
    def foo(self):
        print("Var1:", var1)
        print("Arg1:", self.arg1)

"""
動(dòng)態(tài)類型的語言在創(chuàng)建實(shí)例后, 可以給實(shí)例綁定任何的屬性和方法, 但這些綁定只對(duì)當(dāng)前實(shí)例有效
如果要對(duì)所以實(shí)例生效, 可以在創(chuàng)建實(shí)例前給動(dòng)態(tài)的給類綁定
"""

# 動(dòng)態(tài)的給類綁定屬性和方法, 這些屬性和方法所有實(shí)例都可用
Human.school = ""
# 實(shí)例化
h = Human(arg1, arg2...)
print(h.school)
# 方法調(diào)用
h.foo()
# 動(dòng)態(tài)的給實(shí)例綁定屬性和方法, 這些屬性和方法只能該實(shí)例可用
h.parent = "Big Joy"
# 類的銷毀
del h

類的實(shí)例化是通過調(diào)用構(gòu)造函數(shù)完成的, __init__ 函數(shù)中定義了實(shí)例化時(shí)需要的參數(shù).

類中以一個(gè) _ 開頭命令的變量或方法叫做受保護(hù)成員, 以二個(gè) _ 開頭命名的叫做私有成員, 以 __ 開頭并以 __ 結(jié)尾的為系統(tǒng)定義的, 一般是內(nèi)置的成員.

使用 del 則可銷毀一個(gè)類實(shí)例.

類內(nèi)置了以下屬性:

__dict__: 類的數(shù)據(jù)屬性組成的字典

__doc__: 類的文檔

__name__: 類名

__module__: 類定義所在的模塊名

__bases__: 類繼承的所有父類的元組

語法如下:

class SubName(Parent1, Parent2...):
    pass

一個(gè)子類可以繼承多個(gè)父類, 使用 isintance(obj, type) 可以判斷一個(gè)對(duì)象的類型, 使用 issubclass(sub, parent) 可以判斷是否為另一個(gè)類的子類.

如果父類的方法不能滿足子類的需求, 子類就可重寫此方法, 在使用子類對(duì)象調(diào)用此方法時(shí)會(huì)調(diào)用重寫后的方法.

運(yùn)算符重載 也是方法的重寫, 只不過是對(duì)一些內(nèi)置方法進(jìn)行重寫.

下面列出一些基本的內(nèi)置方法:

__init__(self, [, args…]): 構(gòu)造函數(shù), 用戶實(shí)例化對(duì)象

__del__(self): 析構(gòu)函數(shù), 用于刪除對(duì)象

__repr__(self): 轉(zhuǎn)化為供解釋器讀取的形式

__str__(self): 用于將值轉(zhuǎn)化為適于人閱讀的形式

__cmp__(self, obj): 對(duì)象比較

__add__(self, obj): "+" 對(duì)象相加

__sub__(self, obj): "-" 對(duì)象相減

__eq__(self, obj): "==" 對(duì)象是否相等

__gt__(self, obj): ">" 對(duì)象是否小于

__lt__(self, obj): "<" 對(duì)象是否小于

__iadd__(self, obj): "+=" 對(duì)象相加

更多的內(nèi)置方法請(qǐng)查閱手冊(cè)

以上就介紹完了 python 的基礎(chǔ)知識(shí), 按照上面的內(nèi)容就能夠?qū)懗?python 程序了, 當(dāng)然前提是你不是一個(gè)小白, 至少熟悉一門編程語言.

但 python 還有很多高級(jí)知識(shí)則需要你自行使用學(xué)習(xí)了, 如文件操作, 進(jìn)程和線程, 網(wǎng)絡(luò)編程, 圖形編程等等. 本文的目的只是讓你明白 python 程序應(yīng)該怎么寫, 怎么把你用其他語言寫的程序轉(zhuǎn)換成 python 語言的, 更多高級(jí)的特性只能靠你自己學(xué)習(xí)嘗試.