為什么80%的碼農都做不了架構師？>>> ??

1. Python對象

? ? 所有的Python對象都擁有三個特性:身份,類型和值.

身份: 每一個對象都有一個唯一的身份標識自己,任何對象的身份可以使用內建函數id()來得到.這個值可以被認為是該對象的內存地址.

類型: 對象的類型決定了該對象可以保存什么類型的值,可以進行什么樣的操作,以及遵循什么樣的規則.我們可以使用type()查看Python對象的類型.

值: 對象表示的數據項.

1. type在函數中起判斷作用

? ? 我們定義一個函數,要求傳遞的參數必須是元組(因為元組不可更改),則我們可以這樣判斷(可以引申到判斷參數為整數,浮點數,字典等等):

>>> def func(aTuple):if type(aTuple) != tuple:print 'not tuple'else:print 'tuple'>>> func([1, 2, 3]) not tuple >>> func((1, 2, 3)) tuple 2. is/is not, isinstance操作符

A is B: A和B是同一個對象

A is not B: A和B不是同一個對象

isinstance(A, (int, long, float, complex)): A的類型是否為(int, long, float, complex),也適用于類實例的判斷

3. 內建類型,引用類型的區別

內建類型: 整型,字符串,元組

引用類型:列表,字典,類對象

? ? 對內建類型的賦值,實際上是銷毀原對象,新建一個對象:

>>> ss = 'hello world' >>> id(ss) 46651264L >>> ss = 'what' >>> id(ss) 34271280L ? ? 而引用類型則保持不變: >>> arr = [1, 2, 3] >>> id(arr) 45887240L >>> arr.append(4) >>> id(arr) 45887240L 4. 標準類型的分類

以存儲模型為標準的類型分類:

標量/原子類型(保持單個字面對象的類型): 數值(所有的數值類型),字符串

容器類型(容納多個相同/不同對象的類型): 列表,元組,字典

以更新模型為標準的類型分類:

可變類型: 列表,字典

不可變類型: 數字,字符串,元組

以訪問模型為標準的類型分類:

直接訪問: 數字

順序訪問: 字符串,列表,元組

映射訪問: 字典

2. 序列:字符串,列表和元組

1. 通用函數

額外知識：淺拷貝和深拷貝

? ? 淺拷貝只是拷貝對象的索引，而不是重新建立了一個對象。如果完全拷貝一個對象，則需要深拷貝：

In [22]: arr Out[22]: [1, 2, 3, [4, 5]]In [23]: Tuple1 = tuple(arr)In [24]: import copyIn [25]: Tuple2 = copy.deepcopy(tuple(arr))In [26]: [id(x) for x in arr] Out[26]: [42791256, 42791232, 42791208, 140595426198232]In [27]: [id(x) for x in Tuple1] Out[27]: [42791256, 42791232, 42791208, 140595426198232]In [28]: [id(x) for x in Tuple2] Out[28]: [42791256, 42791232, 42791208, 140595427957864] ? ? 這里arr和Tuple1的元素id全部一樣（由于整形1,2,3是不可改變，所以重新賦值會新建一個對象），而Tuple2的[4, 5]的id不一樣，說明進行了深拷貝。

list(iter): 把可迭代對象轉換為列表。

str(obj): 把obj對象轉換成字符串

tuple(iter): 把一個可迭代對象轉換成一個元組對象

enumerate(iter): 接受一個可迭代對象作為參數，返回一個enumerate對象（同時也是一個迭代器），該對象生成由iter每個元素的index值和item值組成的元組。

len(seq): 返回seq的長度

max/min(iter, key = None):返回最大值，指定key則必須是一個可以傳給sort()方法的，用于比較的回調函數。

reversed(seq): 接受一個序列作為參數，返回一個以逆序訪問的迭代器。

sorted(iter, func = None, key = None, reverse = False): 接受一個可迭代對象作為參數，返回一個有序的列表。

sum(seq, init = 0): 返回seq和可選參數init的總和，其效果等同于reduce(operator.add, seq, init)

zip([it0, it1, it2]):舉例說明

In [29]: iter1 = (1, 2, 3)In [30]: iter2 = [11, 12, 13]In [31]: iter3 = [21, 22, 23]In [32]: zip(iter1, iter2, iter3) Out[32]: [(1, 11, 21), (2, 12, 22), (3, 13, 23)]

3. 映射

1. 哈希表

? ? 哈希表是一種數據結構，哈希表中存儲的每一條數據，叫做一個值，是根據與它相關的一個被稱作鍵的數據項進行存儲的。鍵和值合在一起被稱為“鍵-值”對。哈希表的算法是活取鍵，對鍵執行一個叫做哈希函數的操作，并根據計算的結果，選擇在數據結構的某個地址中來存儲你的值。任何一個值存儲的地址皆取決于它的鍵。正因為這種隨意性，哈希表中的值是沒有順序的。你擁有的是一個無序的數據集。

? ? 你所能獲得的有序集合只能是字典中的鍵的集合或者值的集合。方法Keys()或values()返回一個列表，該列表是可排序的。你還可以用item()方法得到包含鍵，值對的元組的列表來排序。由于字典本身是哈希的，所以是無序的。

? ? 哈希表一般有很好的性能，因為用鍵查詢相當快。

2. 字典的鍵必須是可哈希的

? ? 因為我們需要通過鍵來查找數據，所以鍵必須保持不變，即鍵必須是可哈希的（通過hash判斷）：

In [45]: dst = {}In [46]: dst[[1, 2]] = 3 --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-46-70dfcbeb49dc> in <module>() ----> 1 dst[[1, 2]] = 3TypeError: unhashable type: 'list'In [47]: hash([1, 2]) --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-47-0e7c08465b16> in <module>() ----> 1 hash([1, 2])TypeError: unhashable type: 'list'

3. 映射相關函數

dict()： 工廠函數，用來創建字典，參數為可迭代對象。

len()： 返回字典的長度

hash()： 判斷對象是否可哈希，返回其哈希值。

in/ not in: 判斷鍵是否在字典中

映射類型的內建方法：

keys(), values(), items()： 返回字典的鍵，值，鍵-值對

clear()： 刪除字典中所有元素

copy(): 返回字典的一個副本（淺復制）

fromkeys(seq, val = None): 創建并返回一個新字典，以seq中的元素做該字典的鍵，val做該字典中所有鍵對應的初始值。

get(key, default = None): 獲取鍵key對應的值，如果不存在則返回默認值default.

pop(key, [, default])： key存在，則刪除并返回dict[key]，否則返回default。如果key不存在也不提供default，則引發KeyError異常。

setdefault(key, default = None): 如果字典中不存在key鍵，則用default賦值。

4. 迭代器，列表解析和生成器

1. 迭代器

? ? 從根本上說，迭代器就是有一個next()方法的對象，而不是通過索引來計數，全部迭代完會引發一個StopIteration異常。

? ? 我們一般可以迭代序列，字典和文件：

In [56]: arr = [1, 2]In [57]: i = iter(arr)In [58]: i.next() Out[58]: 1In [59]: i.next() Out[59]: 2In [60]: i.next() --------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-60-e590fe0d22f8> in <module>() ----> 1 i.next()StopIteration: ? ? 而迭代器實際上等價于for循環： for i in seq:do_something_to(i) <==> fetch = iter(seq)while True:try:i = fetch.next()except StopIteration:breakdo_something_to(i)

2. 列表解析

? ? 語法如下：

[expr for iter_var in iterable if cond_expr]

實例如下：

In [61]: [x for x in range(6) if x % 2] Out[61]: [1, 3, 5]

3. 生成器表達式

? ? 語法如下：

(expr for iter_var in iterable if cond_expr) ? ? 列表解析的一個不足就是必要生成所有的數據。但是生成器表達式是返回一個生成器，每次計算出一個條目后，把這個條目yield出來，采用了延遲計算。 In [63]: lst = (x for x in range(6) if x % 2)In [64]: lst Out[64]: <generator object <genexpr> at 0x7fdeec558320>In [65]: for i in lst:....: print i,....: 1 3 5 <==> In [67]: def fun(arr):....: for i in arr:....: yield i....: In [68]: arr = [1, 2, 3]In [71]: for i in fun(arr):....: print i,....: 1 2 3

轉載于:https://my.oschina.net/voler/blog/394856

總結

以上是生活随笔為你收集整理的python核心编程:杂记2的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。