摘要：本人很少寫代碼一般都是用的去年時用寫過一些收集系統信息的工具當時是邊看手冊邊寫的如今又要用來寫一個生成的工具就又需要查看手冊了至于為什么不用寫那是因為的庫不兼容永中在這里不得不說雖然很火但是一些庫還是不如多不如兼容性好為了避免以后再出這種事

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

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

編碼風格

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

輸入/輸出

控制語句的寫法

錯誤處理的用法

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

對于面向對象語言還需要了解類的聲明, 繼承, 多態等的用法

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

模塊的使用

下文就將按照這些內容來一一記錄.

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

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

python 是以縮進來控制代碼段的, 所以縮減建議使用 4 個空格

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

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

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

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

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

每個導入模塊都占一行, 不要一行導入多個模塊

盡量定義一個 main 函數, 將主程序放入其中, 并在 "if name = "__main__":" 成立時執行 =main, 這樣被當作模塊導入時就不會執行主程序

Python 是動態語言, 變量的類型不固定, 根據值的類型而決定, 所以不用顯示的聲明變量， 用的時候直接賦值即可，如下:

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

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

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

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

使用 """ 或 """ 可以嵌入長字符串

字符串可以通過下標來索引, len 函數獲取長度

使用 + 進行拼接操作

字符串對象還內置了很多方法提供了一些常見功能, 具體請查閱手冊

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

列表中可以包含不同類型的數據, 如:

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

通過 list(seq) 可以將一個序列轉換為列表.

array 模塊提供了固定類型的數據, 可以指定要轉換的類型, 具體請查閱手冊.

列表通過下標索引, len 函數獲取大小.

列表對象常用的方法如下:

append(item): 附加元素

insert(idx, item): 插入元素

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

列表遍歷:

for  in :
    // do

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

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

// 用 zip 同時遍歷多個數組
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) 是一個不可修改的列表, 元組中每個元素的指向是不可更改的, 但指向里的內容是可以更改的, 如元組中包含一個數組:

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

語法:

dict = {"":}

常用的對象方法:

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

pop(key): 刪除指定的 key

使用字典需要注意以下幾點:

字典中的 key 不能重復

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

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

集合與字典類似, 是一組 key 的集合, 但不存儲 value, 沒有重復的 key.

要創建一個集合, 需要傳入一個數組, 重復的元素會被自動過濾.

遍歷:

for  in :
    // do

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

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

常用的對象方法:

add(key): 添加 key

remove(key): 刪除 key

global 關鍵字用于聲明變量的作用域, 用法如下:

# 全局變量
a = 1

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

# Global
print("Global:", a)

輸出, global a 注釋掉時:

In test: 5
Global: 1

輸出, global a 取消注釋時:

In test: 5
Global: 5

上面的只是基礎，想要更好的使用變量，還需要了解以下內容：

類型對象的方法

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

變量的內存分配

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

結構體

python 中沒有結構體, 可以使用下列方式實現:

使用 struct 模塊來實現, 需要了解與 c 中類型的格式對照, 創建時需要指定結構體的成員類型

使用類來實現, 在類的構造函數 __init__ 中定義結構體成員

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

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

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

也可以使用 format 來格式化, 它會用傳入的參數依次替換字符串內的占位符 {0}、{1}…… :

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

控制語句中可以使用 break, continue, pass 關鍵字, break 與 continue 的作用與其他語言中的一樣, pass 則是一個空語句, 不做任何事情, 一般是為了保持結構的完整性, 常被用來占位, 表明之后會實現.

注意: 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 存在, 則無論有沒有異常都會執行, else 則在 except 都沒進入時才執行.

語法:

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

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

定義函數時可以給參數指定默認值, 這樣在調用時就可以不傳入這些參數, 沒有默認值的參數是必須要傳入的.

定義默認參數要牢記一點：默認參數必須指向不變對象(數, 字符串, 元組)！

參數前加了 * 的變量會存放所有未命名的變量.

__name__ 是函數對象的一個屬性, 可以拿到此函數的名稱

使用關鍵字 lambda, 就可以創建短小的匿名函式, 如:

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

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

特點:

lambda 只是一個表達式, 函數體比 def 簡單的多, 近能封裝有限的邏輯進去

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

lambda 函數雖然間短, 但不等同于 內聯函數

當需要增強某個函數的功能時, 但有不希望修改函數, 此時可以使用裝飾器. 如添加日志功能:

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

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

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

模塊就是一個 python 文件, 使用 import 導入模塊, 調用模塊中的方法時就必須以 . 來調用.

from import ,... 語句是從模塊中導入指定的函數, from import * 則將模塊中的所有方法都導入

導入一個模塊時的路徑搜索順序如下:

先從當前目錄查找是否有此模塊

如果當前目錄沒有, 就從 PYTHONPATH 定義的目錄下查找

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

搜索路徑定義在 sys.path 中, 可以用 append 函數來添加指定目錄, 如項目中模塊不再同一個目錄就可以添加 path 來導入

python 中的包就是一個分層次的目錄, 定義了一個由模塊及子包組成的環境.

包簡單來說就是一個目錄, 目錄中必須包含一個 __init__.py, 該文件可以為空, 目的使用來標識這個目錄是一個包, 一個簡單的例子如下:

如存在目錄 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")

調用:

#!/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 是一門面向對象語言, 所以創建類和對象是很容易的, 先簡單介紹下面向對象的一些基本特征:

類: 用來描述具有相同屬性和方法的對象的集合, 定義了每個對象共有的屬性和方法, 對象是類的實例

數據成員: 類中的變量, 用于處理類及對象的相關的數據

私有成員: 只能在類的內部方法中訪問的成員

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

公有成員: 全局的, 類內部, 外部和子類都能訪問的成員

方法: 類中定義的函數

方法重寫: 如果從父類繼承的方法不滿足需求, 可以對其重新實現, 這個過程就叫重寫

操作符重載: 自定義某些操作符的功能, 如 + 操作符, 指明2個對象的數據如何相加

繼承: 從一個父類派生出一個子類

多態: 如果多個對象都繼承子一個父類, 通過傳入一個父類變量來調用某個方法時, 如果此時傳入的是子類的對象, 則會調用這個子類中實現的方法(方法已被重寫)

python 中類創建的語法如下:

# 創建一個類
class Human:
    # 類變量
    var1 = 0 # 公有成員
    _var2 = 0 # 受保護成員
    __var3 = 0 # 私有成員

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

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

"""
動態類型的語言在創建實例后, 可以給實例綁定任何的屬性和方法, 但這些綁定只對當前實例有效
如果要對所以實例生效, 可以在創建實例前給動態的給類綁定
"""

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

類的實例化是通過調用構造函數完成的, __init__ 函數中定義了實例化時需要的參數.

類中以一個 _ 開頭命令的變量或方法叫做受保護成員, 以二個 _ 開頭命名的叫做私有成員, 以 __ 開頭并以 __ 結尾的為系統定義的, 一般是內置的成員.

使用 del 則可銷毀一個類實例.

類內置了以下屬性:

__dict__: 類的數據屬性組成的字典

__doc__: 類的文檔

__name__: 類名

__module__: 類定義所在的模塊名

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

語法如下:

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

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

如果父類的方法不能滿足子類的需求, 子類就可重寫此方法, 在使用子類對象調用此方法時會調用重寫后的方法.

運算符重載 也是方法的重寫, 只不過是對一些內置方法進行重寫.

下面列出一些基本的內置方法:

__init__(self, [, args…]): 構造函數, 用戶實例化對象

__del__(self): 析構函數, 用于刪除對象

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

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

__cmp__(self, obj): 對象比較

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

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

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

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

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

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

更多的內置方法請查閱手冊

以上就介紹完了 python 的基礎知識, 按照上面的內容就能夠寫出 python 程序了, 當然前提是你不是一個小白, 至少熟悉一門編程語言.

但 python 還有很多高級知識則需要你自行使用學習了, 如文件操作, 進程和線程, 網絡編程, 圖形編程等等. 本文的目的只是讓你明白 python 程序應該怎么寫, 怎么把你用其他語言寫的程序轉換成 python 語言的, 更多高級的特性只能靠你自己學習嘗試.