用py也很久了，很多東西只知道拿來用，並沒有深究，感覺這樣是不夠的。

我決定寫這麼一篇總結，把很多遺忘的東西拾起來，把很多沒搞懂的東西搞清楚。

1.eval函式

用法：eval(expression, globals=None, locals=None)

解釋：將字串str當成有效的表示式來求值並返回計算結果。

就是可以將字串轉換為表示式來執行，當然可以轉換為某個函式執行。 python是用名稱空間來記錄變數的軌跡的，名稱空間是一個dictionary，鍵是變數名，值是變數值。 當一行程式碼要使用變數 x 的值時，Python 會到所有可用的名字空間去查詢變數，按照如下順序: 1）區域性名字空間 - 特指當前函式或類的方法。如果函式定義了一個區域性變數 x, 或一個引數 x，Python 將使用它，然後停止搜尋。 2）全域性名字空間 - 特指當前的模組。如果模組定義了一個名為 x 的變數，函式或類，Python 將使用它然後停止搜尋。 3）內建名字空間 - 對每個模組都是全域性的。作為最後的嘗試，Python 將假設 x 是內建函式或變數。 python的全域性名字空間儲存在一個叫globals()的dict物件中；區域性名字空間儲存在一個叫locals()的dict物件中。我們可以用print (locals())來檢視該函式體內的所有變數名和變數值。  

使用：

a = 1
b = 1
val1 = a + b
val2 = eval("a+b")
def f():
    a = 10
    b = 10
    val3 = eval("a+b",globals())
    val4 = eval("a+b")
    return val3,val4
print(val1,val2,f())
 
#2 2 (2, 20)

 

2.sort sorted高階用法 

只要是可迭代物件資料，都能夠進行排序，生成一個排序後的列表。
list.sort()函式會對list進行排序操作，改變原有list；而sorted(list)之後會返回一個copy，不會對原來的list有影響。

sorted(iterable, key=None, reverse=False)

list.sort(iterable, key=None, reverse=False)

 

兩者引數一模一樣，因此用程式碼加以區分：

a = [1,5,3,9,7]
b = [9,3,7,2,6]
print(a.sort())
print(a)
print(sorted(b))
print(b)

#None
#[1, 3, 5, 7, 9]
#[2, 3, 6, 7, 9]
#[9, 3, 7, 2, 6]

 

3.split 用法 

Python中有split()和os.path.split()兩個函式，具體作用如下：

split()：拆分字串。通過指定分隔符對字串進行切片，並返回分割後的字串列表（list）

os.path.split()：按照路徑將檔名和路徑分割開

str.split(str="",num=string.count(str))[n]

str：分隔符，預設為空格，但是不能為空''，如果沒有分隔符，就把整個字串作為列表的第一個元素。
num：分割次數。
[n]：取第n個分片。

使用：

str = "http://cnblogs.com/aoru45"
val1 = str.split()
val2 = str.split("/")
val3 = str.split("/",2)
val4 = str.split("/",2)[0]
print(val1,val2,val3,val4) #['http://cnblogs.com/aoru45'] ['http:', '', 'cnblogs.com', 'aoru45'] ['http:', '', 'cnblogs.com/aoru45'] http:

 

4.list各種操作和操作的時間複雜度 

Operation	Average Case	Amortized Worst Case
Copy	O(n)	O(n)
Append[1]	O(1)	O(1)
Pop last	O(1)	O(1)
Pop intermediate	O(k)	O(k)
Insert	O(n)	O(n)
Get Item	O(1)	O(1)
Set Item	O(1)	O(1)
Delete Item	O(n)	O(n)
Iteration	O(n)	O(n)
Get Slice	O(k)	O(k)
Del Slice	O(n)	O(n)
Set Slice	O(k+n)	O(k+n)
Extend[1]	O(k)	O(k)
Sort	O(n log n)	O(n log n)
Multiply	O(nk)	O(nk)
x in s	O(n)
min(s), max(s)	O(n)
Get Length	O(1)	O(1)

 

5.help函式的使用 

使用help()可以幫助我們迅速瞭解某個函式的作用。同時呢，當我們定義某個函式的時候，我們也一樣可以寫一些幫助方便別人理解。
當我輸入help(print)的時候呢，終端會返回：

Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

我們便可以看到print函式的說明和引數情況。
當我們自己定義函式的時候呢，我們可以這樣：

def f(int a):
    '''this is a function that returns a+1'''
    return a+1
help(f)
#會輸出
#Help on function f in module __main__:
#f(a=0)
#    this is a function that returns a+1

 

6. = copy.copy copy.deepcopy區別

copy和deepcopy都能實現拷貝的操作，不同的是，copy拷貝的過程中不會建立新空間，看下面的例子，b使用copy拷貝了a，當a的2改為99的時候，b的值也改變了，但是為什麼a新增[7,8,9]的時候，b沒有新增呢，原來，b拷貝的只是a原有的list中的兩個地址，當a新增一個元素的時候呢，相當於加了一個地址，而在b中沒拷貝，所以b還是不新增元素。c是deepcopy來的，完全是一個新變數，a的任何變化都不能影響c的變化。

import copy
a = [[1,2,3],[4,5,6]]
b = copy.copy(a)
c = copy.deepcopy(a)
a.append([7,8,9])
a[0][1] = 99
print(a)
print(b)
print(c)

'''
[[1, 99, 3], [4, 5, 6], [7, 8, 9]]
[[1, 99, 3], [4, 5, 6]]
[[1, 2, 3], [4, 5, 6]]
'''

 

7.*l 函式接受任意個數引數 **kw 函式接受任意個關鍵字引數

在python中，使用*可以接受任意個數的引數，而使用**可以接受任意個數的關鍵字引數。

def a(*l):
    result = 0
    for val in l:
        result = result + val
    return result
def b(**kw):
    result = 0
    result = kw["keyword_1"]+kw["keyword_2"]
    return result
print(a(1,2,3,4,5))
print(a(1,2,3))
print(b(keyword_1 = 10,keyword_2=20))

'''
15
6
30
'''

 

 

 

 

參考：

1.python eval() https://www.cnblogs.com/dadadechengzi/p/6149930.html

2.Python 內建函式sorted()在高階用法 https://www.cnblogs.com/brad1994/p/6697196.html

3.Python中的split()函式的用法 https://www.cnblogs.com/hjhsysu/p/5700347.html

4.list各種操作和操作的時間複雜度 https://wiki.python.org/moin/TimeComplexity