『壹』 python怎麼獲取網頁上html dom element 對象
可以使用Python自帶的HTMLParser模塊解析HTML文檔：
HTMLParser的核心模塊是org.htmlparser.Parser類，這個類實際完成了對於HTML頁面的分析工作。這個類有下面幾個構造函數：
public Parser ();
public Parser (Lexer lexer, ParserFeedback fb);
public Parser (URLConnection connection, ParserFeedback fb) throws ParserException;
public Parser (String resource, ParserFeedback feedback) throws ParserException;
public Parser (String resource) throws ParserException;
public Parser (Lexer lexer);
public Parser (URLConnection connection) throws ParserException;
和一個靜態類public static Parser createParser (String html, String charset);
『貳』 python文件操作
我覺得要逐行的話最好這樣寫：
forlineinfo.readlines():
至於為什麼直接fo可以迭代出每行，應該是open函數返回值的內部實現和返回值類型決定的（應該在c代碼里，直接轉open定義看不見實現細節）。
『叄』 用Python的類與對象
class Student():
def __init__(self,name,age,score):
self.name = name
self.age = age
self.score = score
def get_name(self):
return self.name
def get_age(self):
return self.age
def get_course(self):
return max(self.score)
st = Student('張三', 20, [150, 88, 100])
print(st.get_name())
print(st.get_age())
print(st.get_course())
『肆』 python 獲取列表元素有幾種方式，常見的是哪種
Python中列表常見的方法有哪些？
Python列表定義:按特定順序排列的元素組成。在Python中，用方括弧[]來表示列表，並用逗號來分隔其中的元素。Python列表是編程中很常見的數據類型 。
列表是一種可修改的集合類型，其元素可以是數字、string等基本類型，也可以是列表、元組、字典等集合對象，甚至可以是自定義的類型。其定義方式如下：>>> nums = [1,2,3,4]>>> type(nums)>>> print nums[1, 2, 3, 4]>>> strs = ["hello","world"]>>> print strs['hello', 'world']>>> lst = [1,"hello",False,nums,strs]>>> type(lst)>>> print lst[1, 'hello', False, [1, 2, 3, 4], ['hello', 'world']]
下面我們來看一下列表中有哪些常見的方法：count():統計某個元素在列表中出現的次數。index():從列表中找出某個值第一個匹配項的索引位置。append():在列表末尾添加新對象。extend():在列表末尾一次性追加另一個序列的多個值。insert():在列表的指定位置插入對象。pop():移除列表中的一個元素(默認最後一個元素)，並且返回該元素的值。remove():移除列表中某個值的第一個匹配項。reverse():將列表中的元素反向，不重新拷貝一個列表。reversed():將列表中的元素反向，重新拷貝一個列表。sort():將列表中的元素排序，不重新拷貝一個列表。sortd():將列表中的元素排序，重新拷貝一個列表。():淺拷貝，只是給原來的列表貼上了一個新標簽，對於一個復雜對象的子對象並不會完全復制，如果有子列表，改變原來的值，新的拷貝對象也會改變。deep():深拷貝，將復雜對象的每一層復制一個單獨的個體出來。就是完全拷貝。常見內置函數：max()、min()、sum()、len()、all()、any()、zip()、enumerate()由於文章篇幅有限，具體的代碼，推薦大家看這篇文章：https://www.jianshu.com/p/da6e449f4c6a
『伍』 如何獲取一個對象obj 的類型 python
內置type函數就可以返回對象的類型
type('hello')
#str
type(123)
#int
『陸』 在Python中用requests.get（）獲取到的內容是什麼類型的
#coding=utf-8
importrequests
url='http://www..com'
ret=requests.get(url)
print(type(ret))#返回類型<class'requests.models.Response'>
print(ret)#返回值:<Response[200]>
print(ret.text)#輸出文本信息
print(ret.content)#以二進制輸出
『柒』 python3 怎麼讀取位元組對象
1. python讀取二進制文件
讀取二進制文件並保存為Long型 (讀取原文件通過UltraEdit查看16進制編碼是「78 56 34 12」)
#以二進制的方式讀取文件
#coding: UTF-8
fileData = open('/home/ubuntu/staff_sample.dat','rb')
#讀取文件的前4個位元組 #將讀取的4個位元組轉換為long
data_id = struct.unpack("l",fileData.read(4))
print data_id
列印的結果是305419896。
『捌』 python常見數據類型
一,python整數類型所表示的數據。
1,一般用以表示一類數值:所有正整數,0和負整數;
2,整型作為最常用的,頻繁參與計算的數據類型，在python3.5中解釋器會自動在內存中創建-5-3000之間的（包含5，不包含3000）整型對象，也就是說在該范圍內,相等都是同一個已經創建好的整型對象。范圍之外的即使相等也表示不同對象，該特性隨python版本而改變，不要過於依賴。
3,bool型繼承了int型，他是int的子類。
4,Python2中有長整型long，數值范圍更大，在python3中已取消，所有整型統一由int表示。
5,參與所有數值計算，數學運算，科學計算。這也是所有編程語言都有的數據類型，因為編程語言生而需要模擬人的思維，藉助數學方式，自動計算、更好的解決大量重復性的事務，因此數值類型、整數類型在編程語言中不可或缺。
6,支持二進制(0b\0B開頭),十進制,八進制(0o\0O),十六進制(0x\0X)
二，python整數和浮點型支持常規的數值運算
整數和浮點數都可參與的運算：+ - * / %（取余） //（整除） **（冪）
Python字元型：
python字元型表示的數據：
python3支持Unicode編碼，由字母、數字和符號組成的形式就叫字元串，更接近或者相同與人們文字元號表示，因此在信息表示和傳遞時它也是最受認可的形式。在程序編寫中也是非常常用，對應的可操作的方法也很多，很有意思。
字元串不可被修改，可以拼接等方法創建新字元串對象；
支持分片和下標操作；a[2:]
支持+拼接，*重復操作和成員關系in/not in；
表示形式：用單引號雙引號包含起來的符號；a = str(『sdfsdfsdf』) 或 r』\t\nabcd』 原始字元，Bytes：b』abcd』；
6,字元串屬於不可變數據類型，內部機制為了節省空間，相同的兩個字元串表示相同的一個對象。a = 『python』 b = 『python』 a is b :True
二, 字元串支持的運算方法
1,capitalize() :首字母大寫後邊的字母小寫 a = 『abcd』 b = a.capitalize() b:Abcd
2,casefold() lower():字母轉換為全小寫
3,center(width,fillchar) :居中，width填補的長度；fillchar添加的字元
a = a.center(10,』_』) //』____abcd____』 默認無fillchar填充空格
4,count(sub,star,end) :字母計數：sub要查詢的字元
5,encode(encoding=』utf-8』,errors=』strict』) 設置編碼
Errors :設置錯誤類型
6,endswith(suffix,star,end) : 若以suffix結尾返回True
7，expandtabs(8) :設置字元串中tab按鍵符的空格長度：』\tabcde』
8,find(sub,star,end) : 返回指定范圍內的字元串下標，未找到返回-1
9，index(sub,star,end) :返回指定范圍字元串下標未找到拋出異常
10，isalnum() :判斷字元串是否是字母或數字，或字母和數字組合
11，isalpha() :判斷是否全是字母
12，isdecimal() :判斷字元串是否是十進制數值
13，isdigit() :判斷字元串是否是數字
14，isidentifier() :判斷字元串中是否包含關鍵字
15，islower() :判斷是否全小寫
16，isnumeric() :判斷全是數字
17，isspace() :判斷是否是空格
18，isupper() 判斷是否大寫
19，istitle() :判斷是否首字母大寫
20，join(iterable) :把可迭代對象用字元串進行分割：a.join(『123』)
21,ljust(width,fillchar);rjust() :左對齊右對齊
22, upper() :將字元串改為大寫
23，split(sep=None,maxsplit=-1) :分割一個字元串，被選中字元在字元串中刪除
『ab1cd1efg』.split(『1』) :[『ab』,』cd』,』efg』]
三，字元串格式化：按照規格輸出字元串
format(*args,**kwargs) :args位置參數，kwargs關鍵字參數
『{0:.1f}』.format(123.468) :格式化參數，小數點後保留1位四捨五入
四，字元串操作符%
1，%s :格式化字元串 『abcd%sdef』%』dddd』
2，%d:格式化整數
3，%o格式化無符號八進制
4，%x格式化無符號十六進制
5，%f格式化定點數
6, %e: 科學計數法格式化定點數
7，%g 根據值大小自動選%f,%e
8, %G E X :大寫形式
五，格式化輔助命令：
m.n :m最小總寬度，n小數點後位數：』%12.4f』%23456.789
六，轉義字元：字元串前r避免轉義：r』\nhello\thi』
\n:換行符
\t:橫向製表符
\':'
\":"
\b:退格符
\r:回車
\v:縱向製表符
\f:換頁符
\o,\x:八進制和十六進制
\0:空字元串
Python列表list
一，Python的列表list類型表示的數據：
Python列表在cpython中被解釋為長度可變的數組，用其他對象組成的連續數組。
列表中元素可以是相同或不同的數據類型；
當列表元素增加或刪除時，列表對象自動進行擴展或收縮內存，保證元素之間沒有縫隙，總是連續的。
Python中的列表是一個序列，也是一個容器類型
創建列表：a = []; b = [1,』python』]; c = list(); d = list((1,3,4,5))
支持切片操作list[start,stop,step]
python列表常用方法
1,append添加單個元素：list.append(object); //a.append(『python』)
2,extend添加可迭代對象: list.extend(iterable); //a.extend(『abcde』/[1,2,3])
3,insert 插入元素：list.insert(index,object): 在index下標前插入元素//a.insert(2,』python』)
4,clear 清空所有元素：list.clear() //a.clear()
5,pop 刪除並返回一個元素：list.pop(index) //默認刪除默認一個元素
remove 刪除指定元素：list.remove(v) ,v元素不存在報錯 //a.remove(『c』)
7，count 返回這個值在列表中數量：list.count(value)
8, 淺拷貝一個新列表：list.()
9,sort:排序list.sort(reverse=False/True) :默認升序
排序函數：sorted(list)
10，reverse: 原地翻轉：list.reverse()
11，index(value,star,stop) :指定范圍內該值下標：list.index(2,0,5)
列表元素訪問：
下標訪問：list[1]
For循環遍歷
通過下標修改元素：list[2 ] = 『hello』
列表常用運算符：
1,比較運算符：從第一個元素開始對比
2，+ 拼接一個新列表：l1+ l2
3, 重復操作符：* ,多個列表拼接
成員關系操作符：in/ not in
邏輯運算符：and not or
列表常用的排序方法：
冒泡排序；選擇排序；快速排序；歸並排序
Python元組tuple
一，Python元組tuple數據類型表示的數據：
元組是受到限制的、不可改變的列表；
可以是同構也可以是異構；
元組是序列類型、是可迭代對象，是容器類型。
元組的創建: a = (1,2,3)或a=1,2,3; b = tuple(); c = tuple(iterable)
支持切片操作tuple[start,stop,step]
二，python元組常用方法
1,index(value,star,stop) :指定范圍內該值下標：tuple.index(2,0,5)
2,count(value) ：值出現次數
三，支持運算：
1,比較運算符：從第一個元素開始對比
2，+ 拼接一個新元組：l1+ l2
3, 重復操作符：* ,多個元組拼接
4成員關系操作符：in/ not in
邏輯運算符：and not or
四，元組的訪問
下標操作；
For循環遍歷訪問。
Python字典類型
一,Python字典dict表示的數據：{key:value}
可根據關鍵字：鍵快速索引到對應的值；
字典是映射類型，鍵值對一一對應關系，不是序列；
字典元素是無序的；
字典是可迭代對象，是容器類型；
字典的創建：k = {}; k1={『keyword』:object}; k2 = dict();
K3 = dict(mapping); dict=(iterable)
二，字典的訪問：
通過key：k[『key』]
修改key對應的值：K[『key』] = value
For循環遍歷出來的是key；
For循環鍵值對：for I in d.items():
For 循環enumerate: for k,v in enumerate(k1):
In/not in 成員關系查詢鍵不支持查值
三，字典常用方法
get(key,de):獲取值：k.get(key,de) //若不存在則默認輸出de
pop(k,de):刪除一個鍵值對，不存在輸出de，未設置報錯；
keys() :返回字典所有key組成的序列：list(k.keys()) [1,2,3];
values():返回字典所有value組成的序列：list(k.values())
items():返回鍵值對組成的元組為元素的序列：（類set）list(k.items())
update(e):更新字典：e可是字典或兩元素組成的單位元素序列：e=[(5,6),(7,8)];
k.update(e)
clear():清空字典；
popitem()刪除某個鍵值對，若字典為空則報錯
() :淺拷貝
10, fromkeys(iterable,value=None):從可迭代對象創建字典
{}.fromkeys([1,2,3]) -----{1:None,2:None,3:None}
11,setdefault(k,d=None) :若key不存在則生成一個鍵值對
k.setdefault(『keyword』)
Python 集合set
集合表示的數據：
多個元素的無序組合，集合是無序的，集合元素是唯一的；
字典的鍵是由集合實現的；
集合是可迭代對象
集合創建：s = {1,2}; s1 = set(); s2 = set(iterable)
集合元素的訪問：
For 循環將集合所有元素全部訪問一遍，不重復
常用方法：
add(object):s.add(『hi』) 向集合添加一個元素
pop() :彈棧，集合為空則報錯：刪除任意一個元素；
clear():清空集合，返回一個空集合對象；
remove(object):刪除一個元素，不存在和報錯：s.remove(『hi』)
update(集合)：更新另一個集合，元素不存在則不更新；
() :淺拷貝
集合的運算：
交集：s1&s2;
差集,補集：s1-s2;
並集：s1|s2;
Issubset():判斷是否是子集：s1.issubset(s2) s1是否s2的集合子集
Issuperset():判斷是否是父集：s1.issuperset()
不可變集合：
Frozenset():返回一個空的不可變集合對象
Frozenset(iterable):
S = frozenset(iterable)
Python序列類型共同特性
一,序列類型共同特性
python序列類型有:str字元串,list列表,tuple元組
都支持下標索引，切片操作；
下標都是從0開始，都可通過下標進行訪問；
擁有相同的操作符
二，支持的函數：
len(obj):返回對象長度；
list(iterable):將可迭代對象轉為列表；
tuple(iterable):將可迭代對象轉為元組；
str(ojb):將任何對象轉為字元串形式；
max(iterable): python3中元素要是同類型，python2中元素可異構：max([『a』,1])
min(iterable):和max類似；
sum(iterable,star=0),求可迭代對象和，默認star為0，元素不能為字元串
sorted(iterable,key=None,reverse=False)
s=[(『a』,3),(『b』,2),(『c』,9)]
sorted(s,key=lambda s:s[1]) //按照數字排序
reversed(sequence):翻轉序列，返回迭代器
enumerate(iterable):返回enumerate對象,其元素都是一個元組（下標，值）
zip（iter1,iter2）: zip([1,2],[3,4]) ----[(1,3),(2,4)]
序列類型的切片操作：
Slice:
L[index]; 訪問某個元素；
L[1:4]; 區間
L[star:stop:step]; 設置步長取區間元素
『玖』 Python如何通過字元或數字動態獲取對象的名稱或者屬性
首先通過一個例子來看一下本文中可能用到的對象和相關概念。
#coding: UTF-8
import sys # 模塊，sys指向這個模塊對象
import inspect
def foo(): pass # 函數，foo指向這個函數對象
class Cat(object): # 類，Cat指向這個類對象
def __init__(self, name='kitty'):
self.name = name
def sayHi(self): # 實例方法，sayHi指向這個方法對象，使用類或實例.sayHi訪問
print self.name, 'says Hi!' # 訪問名為name的欄位，使用實例.name訪問
cat = Cat() # cat是Cat類的實例對象
print Cat.sayHi # 使用類名訪問實例方法時，方法是未綁定的(unbound)
print cat.sayHi # 使用實例訪問實例方法時，方法是綁定的(bound)
有時候我們會碰到這樣的需求，需要執行對象的某個方法，或是需要對對象的某個欄位賦值，而方法名或是欄位名在編碼代碼時並不能確定，需要通過參數傳遞字元串的形式輸入。舉個具體的例子：當我們需要實現一個通用的DBM框架時，可能需要對數據對象的欄位賦值，但我們無法預知用到這個框架的數據對象都有些什麼欄位，換言之，我們在寫框架的時候需要通過某種機制訪問未知的屬性。
這個機制被稱為反射（反過來讓對象告訴我們他是什麼），或是自省（讓對象自己告訴我們他是什麼，好吧我承認括弧里是我瞎掰的- -#），用於實現在運行時獲取未知對象的信息。反射是個很嚇唬人的名詞，聽起來高深莫測，在一般的編程語言里反射相對其他概念來說稍顯復雜，一般來說都是作為高級主題來講；但在Python中反射非常簡單，用起來幾乎感覺不到與其他的代碼有區別，使用反射獲取到的函數和方法可以像平常一樣加上括弧直接調用，獲取到類後可以直接構造實例；不過獲取到的欄位不能直接賦值，因為拿到的其實是另一個指向同一個地方的引用，賦值只能改變當前的這個引用而已。
1. 訪問對象的屬性
以下列出了幾個內建方法，可以用來檢查或是訪問對象的屬性。這些方法可以用於任意對象而不僅僅是例子中的Cat實例對象；Python中一切都是對象。
cat = Cat('kitty')
print cat.name # 訪問實例屬性
cat.sayHi() # 調用實例方法
print dir(cat) # 獲取實例的屬性名，以列表形式返回
if hasattr(cat, 'name'): # 檢查實例是否有這個屬性
setattr(cat, 'name', 'tiger') # same as: a.name = 'tiger'
print getattr(cat, 'name') # same as: print a.name
getattr(cat, 'sayHi')() # same as: cat.sayHi()
dir([obj]):
調用這個方法將返回包含obj大多數屬性名的列表（會有一些特殊的屬性不包含在內）。obj的默認值是當前的模塊對象。
hasattr(obj, attr):
這個方法用於檢查obj是否有一個名為attr的值的屬性，返回一個布爾值。
getattr(obj, attr):
調用這個方法將返回obj中名為attr值的屬性的值，例如如果attr為'bar'，則返回obj.bar。
setattr(obj, attr, val):
調用這個方法將給obj的名為attr的值的屬性賦值為val。例如如果attr為'bar'，則相當於obj.bar = val。
2. 訪問對象的元數據
當你對一個你構造的對象使用dir()時，可能會發現列表中的很多屬性並不是你定義的。這些屬性一般保存了對象的元數據，比如類的__name__屬性保存了類名。大部分這些屬性都可以修改，不過改動它們意義並不是很大；修改其中某些屬性如function.func_code還可能導致很難發現的問題，所以改改name什麼的就好了，其他的屬性不要在不了解後果的情況下修改。
接下來列出特定對象的一些特殊屬性。另外，Python的文檔中有提到部分屬性不一定會一直提供，下文中將以紅色的星號*標記，使用前你可以先打開解釋器確認一下。
2.0. 准備工作：確定對象的類型
在types模塊中定義了全部的Python內置類型，結合內置方法isinstance()就可以確定對象的具體類型了。
isinstance(object, classinfo):
檢查object是不是classinfo中列舉出的類型，返回布爾值。classinfo可以是一個具體的類型，也可以是多個類型的元組或列表。
types模塊中僅僅定義了類型，而inspect模塊中封裝了很多檢查類型的方法，比直接使用types模塊更為輕松，所以這里不給出關於types的更多介紹，如有需要可以直接查看types模塊的文檔說明。本文第3節中介紹了inspect模塊。
2.1. 模塊(mole)
__doc__: 文檔字元串。如果模塊沒有文檔，這個值是None。
*__name__: 始終是定義時的模塊名；即使你使用import .. as 為它取了別名，或是賦值給了另一個變數名。
*__dict__: 包含了模塊里可用的屬性名-屬性的字典；也就是可以使用模塊名.屬性名訪問的對象。
__file__: 包含了該模塊的文件路徑。需要注意的是內建的模塊沒有這個屬性，訪問它會拋出異常！
import fnmatch as m
print m.__doc__.splitlines()[0] # Filename matching with shell patterns.
print m.__name__ # fnmatch
print m.__file__ # /usr/lib/python2.6/fnmatch.pyc
print m.__dict__.items()[0] # ('fnmatchcase', <function fnmatchcase="" at="" 0xb73deb54="">)</function>
2.2. 類(class)
__doc__: 文檔字元串。如果類沒有文檔，這個值是None。
*__name__: 始終是定義時的類名。
*__dict__: 包含了類里可用的屬性名-屬性的字典；也就是可以使用類名.屬性名訪問的對象。
__mole__: 包含該類的定義的模塊名；需要注意，是字元串形式的模塊名而不是模塊對象。
*__bases__: 直接父類對象的元組；但不包含繼承樹更上層的其他類，比如父類的父類。
print Cat.__doc__ # None
print Cat.__name__ # Cat
print Cat.__mole__ # __main__
print Cat.__bases__ # (<type ?object?="">,)
print Cat.__dict__ # {'__mole__': '__main__', ...}</type>
2.3. 實例(instance)
實例是指類實例化以後的對象。
*__dict__: 包含了可用的屬性名-屬性字典。
*__class__: 該實例的類對象。對於類Cat，cat.__class__ == Cat 為 True。
print cat.__dict__
print cat.__class__
print cat.__class__ == Cat # True
2.4. 內建函數和方法(built-in functions and methods)
根據定義，內建的(built-in)模塊是指使用C寫的模塊，可以通過sys模塊的builtin_mole_names欄位查看都有哪些模塊是內建的。這些模塊中的函數和方法可以使用的屬性比較少，不過一般也不需要在代碼中查看它們的信息。
__doc__: 函數或方法的文檔。
__name__: 函數或方法定義時的名字。
__self__: 僅方法可用，如果是綁定的(bound)，則指向調用該方法的類（如果是類方法）或實例（如果是實例方法），否則為None。
*__mole__: 函數或方法所在的模塊名。
2.5. 函數(function)
這里特指非內建的函數。注意，在類中使用def定義的是方法，方法與函數雖然有相似的行為，但它們是不同的概念。
__doc__: 函數的文檔；另外也可以用屬性名func_doc。
__name__: 函數定義時的函數名；另外也可以用屬性名func_name。
*__mole__: 包含該函數定義的模塊名；同樣注意，是模塊名而不是模塊對象。
*__dict__: 函數的可用屬性；另外也可以用屬性名func_dict。
不要忘了函數也是對象，可以使用函數.屬性名訪問屬性（賦值時如果屬性不存在將新增一個），或使用內置函數has/get/setattr()訪問。不過，在函數中保存屬性的意義並不大。
func_defaults: 這個屬性保存了函數的參數默認值元組；因為默認值總是靠後的參數才有，所以不使用字典的形式也是可以與參數對應上的。
func_code: 這個屬性指向一個該函數對應的code對象，code對象中定義了其他的一些特殊屬性，將在下文中另外介紹。
func_globals: 這個屬性指向當前的全局命名空間而不是定義函數時的全局命名空間，用處不大，並且是只讀的。
*func_closure: 這個屬性僅當函數是一個閉包時有效，指向一個保存了所引用到的外部函數的變數cell的元組，如果該函數不是一個內部函數，則始終為None。這個屬性也是只讀的。
下面的代碼演示了func_closure：
#coding: UTF-8
def foo():
n = 1
def bar():
print n # 引用非全局的外部變數n，構造一個閉包
n = 2
return bar
closure = foo()
print closure.func_closure
# 使用dir()得知cell對象有一個cell_contents屬性可以獲得值
print closure.func_closure[0].cell_contents # 2
由這個例子可以看到，遇到未知的對象使用dir()是一個很好的主意 ：）
2.6. 方法(method)
方法雖然不是函數，但可以理解為在函數外面加了一層外殼；拿到方法里實際的函數以後，就可以使用2.5節的屬性了。
__doc__: 與函數相同。
__name__: 與函數相同。
*__mole__: 與函數相同。
im_func: 使用這個屬性可以拿到方法里實際的函數對象的引用。另外如果是2.6以上的版本，還可以使用屬性名__func__。
im_self: 如果是綁定的(bound)，則指向調用該方法的類（如果是類方法）或實例（如果是實例方法），否則為None。如果是2.6以上的版本，還可以使用屬性名__self__。
im_class: 實際調用該方法的類，或實際調用該方法的實例的類。注意不是方法的定義所在的類，如果有繼承關系的話。
im = cat.sayHi
print im.im_func
print im.im_self # cat
print im.im_class # Cat
這里討論的是一般的實例方法，另外還有兩種特殊的方法分別是類方法(classmethod)和靜態方法(staticmethod)。類方法還是方法，不過因為需要使用類名調用，所以他始終是綁定的；而靜態方法可以看成是在類的命名空間里的函數（需要使用類名調用的函數），它只能使用函數的屬性，不能使用方法的屬性。
2.7. 生成器(generator)
生成器是調用一個生成器函數(generator function)返回的對象，多用於集合對象的迭代。
__iter__: 僅僅是一個可迭代的標記。
gi_code: 生成器對應的code對象。
gi_frame: 生成器對應的frame對象。
gi_running: 生成器函數是否在執行。生成器函數在yield以後、執行yield的下一行代碼前處於frozen狀態，此時這個屬性的值為0。
next|close|send|throw: 這是幾個可調用的方法，並不包含元數據信息，如何使用可以查看生成器的相關文檔。
def gen():
for n in xrange(5):
yield n
g = gen()
print g # <generator object gen at 0x...>
print g.gi_code # <code object gen at 0x...>
print g.gi_frame # <frame object at 0x...>
print g.gi_running # 0
print g.next() # 0
print g.next() # 1
for n in g:
print n, # 2 3 4
接下來討論的是幾個不常用到的內置對象類型。這些類型在正常的編碼過程中應該很少接觸，除非你正在自己實現一個解釋器或開發環境之類。所以這里只列出一部分屬性，如果需要一份完整的屬性表或想進一步了解，可以查看文末列出的參考文檔。
2.8. 代碼塊(code)
代碼塊可以由類源代碼、函數源代碼或是一個簡單的語句代碼編譯得到。這里我們只考慮它指代一個函數時的情況；2.5節中我們曾提到可以使用函數的func_code屬性獲取到它。code的屬性全部是只讀的。
co_argcount: 普通參數的總數，不包括*參數和**參數。
co_names: 所有的參數名（包括*參數和**參數）和局部變數名的元組。
co_varnames: 所有的局部變數名的元組。
co_filename: 源代碼所在的文件名。
co_flags: 這是一個數值，每一個二進制位都包含了特定信息。較關注的是0b100(0×4)和0b1000(0×8)，如果co_flags & 0b100 != 0，說明使用了*args參數；如果co_flags & 0b1000 != 0，說明使用了**kwargs參數。另外，如果co_flags & 0b100000(0×20) != 0，則說明這是一個生成器函數(generator function)。
co = cat.sayHi.func_code
print co.co_argcount # 1
print co.co_names # ('name',)
print co.co_varnames # ('self',)
print co.co_flags & 0b100 # 0
2.9. 棧幀(frame)
棧幀表示程序運行時函數調用棧中的某一幀。函數沒有屬性可以獲取它，因為它在函數調用時才會產生，而生成器則是由函數調用返回的，所以有屬性指向棧幀。想要獲得某個函數相關的棧幀，則必須在調用這個函數且這個函數尚未返回時獲取。你可以使用sys模塊的_getframe()函數、或inspect模塊的currentframe()函數獲取當前棧幀。這里列出來的屬性全部是只讀的。
f_back: 調用棧的前一幀。
f_code: 棧幀對應的code對象。
f_locals: 用在當前棧幀時與內建函數locals()相同，但你可以先獲取其他幀然後使用這個屬性獲取那個幀的locals()。
f_globals: 用在當前棧幀時與內建函數globals()相同，但你可以先獲取其他幀……。
def add(x, y=1):
f = inspect.currentframe()
print f.f_locals # same as locals()
print f.f_back # <frame object at 0x...>
return x+y
add(2)
2.10. 追蹤(traceback)
追蹤是在出現異常時用於回溯的對象，與棧幀相反。由於異常時才會構建，而異常未捕獲時會一直向外層棧幀拋出，所以需要使用try才能見到這個對象。你可以使用sys模塊的exc_info()函數獲得它，這個函數返回一個元組，元素分別是異常類型、異常對象、追蹤。traceback的屬性全部是只讀的。
tb_next: 追蹤的下一個追蹤對象。
tb_frame: 當前追蹤對應的棧幀。
tb_lineno: 當前追蹤的行號。
def div(x, y):
try:
return x/y
except:
tb = sys.exc_info()[2] # return (exc_type, exc_value, traceback)
print tb
print tb.tb_lineno # "return x/y" 的行號
div(1, 0)
3. 使用inspect模塊
inspect模塊提供了一系列函數用於幫助使用自省。下面僅列出較常用的一些函數，想獲得全部的函數資料可以查看inspect模塊的文檔。
3.1. 檢查對象類型
is{mole|class|function|method|builtin}(obj):
檢查對象是否為模塊、類、函數、方法、內建函數或方法。
isroutine(obj):
用於檢查對象是否為函數、方法、內建函數或方法等等可調用類型。用這個方法會比多個is*()更方便，不過它的實現仍然是用了多個is*()。
im = cat.sayHi
if inspect.isroutine(im):
im()
對於實現了__call__的類實例，這個方法會返回False。如果目的是只要可以直接調用就需要是True的話，不妨使用isinstance(obj, collections.Callable)這種形式。我也不知道為什麼Callable會在collections模塊中，抱歉！我猜大概是因為collections模塊中包含了很多其他的ABC(Abstract Base Class)的緣故吧：）
3.2. 獲取對象信息
getmembers(object[, predicate]):
這個方法是dir()的擴展版，它會將dir()找到的名字對應的屬性一並返回，形如[(name, value), ...]。另外，predicate是一個方法的引用，如果指定，則應當接受value作為參數並返回一個布爾值，如果為False，相應的屬性將不會返回。使用is*作為第二個參數可以過濾出指定類型的屬性。
getmole(object):
還在為第2節中的__mole__屬性只返回字元串而遺憾嗎？這個方法一定可以滿足你，它返回object的定義所在的模塊對象。
get{file|sourcefile}(object):
獲取object的定義所在的模塊的文件名|源代碼文件名（如果沒有則返回None）。用於內建的對象（內建模塊、類、函數、方法）上時會拋出TypeError異常。
get{source|sourcelines}(object):
獲取object的定義的源代碼，以字元串|字元串列表返回。代碼無法訪問時會拋出IOError異常。只能用於mole/class/function/method/code/frame/traceack對象。
getargspec(func):
僅用於方法，獲取方法聲明的參數，返回元組，分別是(普通參數名的列表, *參數名, **參數名, 默認值元組)。如果沒有值，將是空列表和3個None。如果是2.6以上版本，將返回一個命名元組(Named Tuple)，即除了索引外還可以使用屬性名訪問元組中的元素。
def add(x, y=1, *z):
return x + y + sum(z)
print inspect.getargspec(add)
#ArgSpec(args=['x', 'y'], varargs='z', keywords=None, defaults=(1,))
getargvalues(frame):
僅用於棧幀，獲取棧幀中保存的該次函數調用的參數值，返回元組，分別是(普通參數名的列表, *參數名, **參數名, 幀的locals())。如果是2.6以上版本，將返回一個命名元組(Named Tuple)，即除了索引外還可以使用屬性名訪問元組中的元素。
def add(x, y=1, *z):
print inspect.getargvalues(inspect.currentframe())
return x + y + sum(z)
add(2)
#ArgInfo(args=['x', 'y'], varargs='z', keywords=None, locals={'y': 1, 'x': 2, 'z': ()})
getcallargs(func[, *args][, **kwds]):
返回使用args和kwds調用該方法時各參數對應的值的字典。這個方法僅在2.7版本中才有。
getmro(cls):
返回一個類型元組，查找類屬性時按照這個元組中的順序。如果是新式類，與cls.__mro__結果一樣。但舊式類沒有__mro__這個屬性，直接使用這個屬性會報異常，所以這個方法還是有它的價值的。
print inspect.getmro(Cat)
#(<class '__main__.Cat'>, <type 'object'>)
print Cat.__mro__
#(<class '__main__.Cat'>, <type 'object'>)
『拾』 Python獲取指定內存地址中的對象
你找一找這個庫，rpyc。這個東西是目前RPC方面最好用的一個東西了。比我以前接觸學習的分布式對象系統更好用。 其實python這個東西，因為是腳本，所以做分布式對象特別容易。主要是做好系列化與反系列化就可以了。
此外rpc-xml也是常用的一個方法。
如果你對需求理解深，通常不會選擇分布式對象，而是自己定製數據結構，傳輸協議，序列化與反序列化。這樣才能實現高效，可擴展性。
你在一個進程中創建一個對象，可以使用python自帶的系列化模塊pickle進行轉換。然後傳遞到另一個進程中，再反序列化就可以實現。操作完成後，再傳遞回來。這就是原理。
如果使用指定內存地址也是可以的。可以設計一個共享內存，然後通過numpy這個模塊進行內存與對象的轉換。其它的就不多說了。 當然你也可以自己設計序列化與反序列化模塊。
通常復雜的對象效率低。整型固定長度數組是最快的。