python循環鏈表
1. 有沒有python中的函數來列印一個對象的所有當前的屬性和值
1. 你是兩個不同的事情真的混在一起。
使用dir()或inspect模塊讓你有興趣（什麼__builtins__作為一個例子，你的任何對象，而不是）。
>>> l = dir(__builtins__)
>>> d = __builtins__.__dict__
列印該字典但是看上你喜歡：
>>> print l
['ArithmeticError', 'AssertionError', 'AttributeError',...
或
>>> from pprint import pprint
>>> pprint(l)
['ArithmeticError',
'AssertionError',
'AttributeError',
'BaseException',
'DeprecationWarning',
...
>>> pprint(d, indent=2)
{ 'ArithmeticError': <type 'exceptions.ArithmeticError'>,
'AssertionError': <type 'exceptions.AssertionError'>,
'AttributeError': <type 'exceptions.AttributeError'>,
...
'_': [ 'ArithmeticError',
'AssertionError',
'AttributeError',
'BaseException',
'DeprecationWarning',
...
2.
你想瓦爾（）與PPRINT混合：
from pprint import pprint
pprint (vars(your_object))
3.
def mp(obj):
for attr in dir(obj):
print "obj.%s = %s" % (attr, getattr(obj, attr))
4.
目錄有但只會給你的屬性'如果你希望自己的價值觀，以及嘗試的__dict__。
class O:
def __init__ (self):
self.value = 3
o = O()
>>> o.__dict__
{'值'：3}
5.
你的「目錄（）」函數來做到這一點。
>>> import sys
>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__name__', '__stderr__', '__stdin__', '__stdo
t__', '_current_frames', '_getframe', 'api_version', 'argv', 'builtin_mole_names', 'byteorder
, 'call_tracing', 'callstats', 'right', 'displayhook', 'dllhandle', 'exc_clear', 'exc_info'
'exc_type', 'excepthook', 'exec_prefix', 'executable', 'exit', 'getcheckinterval', 'getdefault
ncoding', 'getfilesystemencoding', 'getrecursionlimit', 'getrefcount', 'getwindowsversion', 'he
version', 'maxint', 'maxunicode', 'meta_path', 'moles', 'path', 'path_hooks', 'path_importer_
ache', 'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setprofile', 'setrecursionlimit
, 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version', 'version_info', 'warnoption
', 'winver']
>>>
函數是幫助。
>>> help(sys)
Help on built-in mole sys:
NAME
sys
FILE
(built-in)
MODULE DOCS
CodeGo.net
DESCRIPTION
This mole provides access to some objects used or maintained by the
interpreter and to functions that interact strongly with the interpreter.
Dynamic objects:
argv -- command line arguments; argv[0] is the script pathname if known
6.
要列印的對象，你可能的當前狀態：
>>> obj # in an interpreter
或
print repr(obj) # in a script
或
print obj
為你的類定義__str__或__repr__方法。從Python__repr__(self)由被叫repr()內置函數和字元串
轉換（反引號）
計算「官方」的字元串
一個對象的表示。如果在所有
可能的話，這應該看起來像一個
有效的Python表達式，可能是
用於重新創建的對象與
值（給定一個適當的
如果這是不可能的 CodeGo.net，
一個字元串表單的「<...有用
描述...>「應該返回。
返回值必須是一個字元串
對象。如果一個類定義再版（）
但不__str__()，然後__repr__()是
當一個「非正式」的字元串
的該實例的代表性
類是必需的。這通常是
用於調試，所以重要的是
該項表示是
信息豐富，__str__(self)由被叫str()內置函數和由列印
「非正式」
一個對象的字元串表示表單。
這不同於__repr__()在這
它並不必須是一個有效的Python
表達式：更方便或
簡潔的表述，如
代替。返回值必須是一個
字元串對象。
7.
可能是值得一試-
是否有相當於Perl的Data ::自卸車一個Python？
我是這樣的-
需要注意的是Perl有一個名為Data ::
Dumper模塊的轉換對象數據返回到perl的源代碼（註：它並沒有轉化代碼回到源，而且幾乎總是你不想在輸出的函數）。這可持久性，但目的是為了調
試。
有許多事情標準的python
PPRINT未能達到，尤其是剛剛停止時，看到一個對象的實例，並為您的對象的內六角指針（降序呃，這個指針是不是一大堆的方式）。因此，概括地
說，python是所有關於這個偉大的面向對象的範式，但你得到的開箱即用的工具是專為與對象比其他工作。
在Perl的Data ::
Dumper允許你控制你想有多深去，並且還檢測循環鏈表結構（這是非常重要的）。這個過程是比較容易實現的perl的對象有超越他們的祝福沒有特別的魔
法（一個普遍良好定義的線程）。
8.
在大多數情況下，使用__dict__或dir()你將會得到你想要。如果您碰巧需要更多的細節，標准庫包含了inspect模塊，它可以讓你獲得細節令人印象深刻的金額。真正的nuggests包括：
函數
類層次結構
的一個函數/類對象的源代碼
局部變數出對象的
如果你只是尋找「沒有我的對象有什麼屬性值？」，然後dir()和__dict__可能是足夠的。如果你真的希望挖掘到任意對象的當前狀態（牢記在python幾乎一切都是對象），然後inspect是值得考慮的。
9.
例如轉儲對象的魔法：
$貓mp.py
#!/usr/bin/python
import sys
if len(sys.argv) > 2:
mole, metaklass = sys.argv[1:3]
m = __import__(mole, globals(), locals(), [metaklass])
__metaclass__ = getattr(m, metaklass)
class Data:
def __init__(self):
self.num = 38
self.lst = ['a','b','c']
self.str = 'spam'
mps = lambda self: repr(self)
__str__ = lambda self: self.mps()
data = Data()
print data
無
$pythonmp.py
<__main__.Data instance at 0x00A052D8>
與靈知utils的：
$pythonmp.py gnosis.magic MetaXMLPickler
<?xml version="1.0"?>
<!DOCTYPE PyObject SYSTEM "PyObjects.dtd">
<PyObject mole="__main__" class="Data" id="11038416">
<attr name="lst" type="list" id="11196136" >
<item type="string" value="a" />
<item type="string" value="b" />
<item type="string" value="c" />
</attr>
<attr name="num" type="numeric" value="38" />
<attr name="str" type="string" value="spam" />
</PyObject>
這是一個有點過時，但仍然堅持工作。
10.
PPRINT包含一個「漂亮的列印機」為你製造數據結構的美觀交涉。格式化器產生的數據結構的表示，可以正確地由解釋器進行解析，並且也很容易對一個人的閱讀。輸出保持在一行上，如果可能的話，與縮進時，多行拆分。
11.
為什麼不能簡單的：
關鍵，在obj的值。字典iteritems（）。：
列印鍵，值
12.
我需要在日誌中列印並無法PPRINT它會打破它。相反，我這樣做，並幾乎得到了的東西。
DO = DemoObject()
itemDir = DO.__dict__
for i in itemDir:
print '{0} : {1}'.format(i, itemDir[i])
2. Python break 和 continue 語句, 以及循環中的 else 子句的用法
Python 中的 for 語句和 C 或 Pascal 中的略有不同。通常的循環可能會依據一個等差數值步進過程（如 Pascal），或由用戶來定義迭代步驟和中止條件（如 C ），Python 的 for 語句依據任意序列（鏈表或字元串）中的子項，按它們在序列中的順序來進行迭代。例如（沒有暗指）：
>>> # Measure some strings:
... words = ['cat', 'window', 'defenestrate']
>>> for w in words:
... print(w, len(w))
...
cat 3
window 6
defenestrate 12
在迭代過程中修改迭代序列不安全（只有在使用鏈表這樣的可變序列時才會有這樣的情況）。如果你想要修改你迭代的序列（例如，復制選擇項），你可以迭代它的復本。使用切割標識就可以很方便地做到這一點:
>>> for w in words[:]: # Loop over a slice of the entire list.
... if len(w) > 6:
... words.insert(0, w)
...
>>> words
['defenestrate', 'cat', 'window', 'defenestrate']
3. python 這么實現環形列表
遍歷的時候索引值取模運算，模環的長度
4. 160. 相交鏈表（Python）
難度：★★☆☆☆
類型：鏈表
編寫一個程序，找到兩個單鏈表相交的起始節點。
如下面的兩個鏈表：
在節點 c1 開始相交。
示例 1：
輸入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
輸出：Reference of the node with value = 8
輸入解釋：相交節點的值為 8 （注意，如果兩個列表相交則不能為 0）。從各自的表頭開始算起，鏈表 A 為 [4,1,8,4,5]，鏈表 B 為 [5,0,1,8,4,5]。在 A 中，相交節點前有 2 個節點；在 B 中，相交節點前有 3 個節點。
示例2：
輸入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
輸出：Reference of the node with value = 2
輸入解釋：相交節點的值為 2 （注意，如果兩個列表相交則不能為 0）。從各自的表頭開始算起，鏈表 A 為 [0,9,1,2,4]，鏈表 B 為 [3,2,4]。在 A 中，相交節點前有 3 個節點；在 B 中，相交節點前有 1 個節點。
示例3：
輸入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
輸出：null
輸入解釋：從各自的表頭開始算起，鏈表 A 為 [2,6,4]，鏈表 B 為 [1,5]。由於這兩個鏈表不相交，所以 intersectVal 必須為 0，而 skipA 和 skipB 可以是任意值。
解釋：這兩個鏈表不相交，因此返回 null。
注意：
如果兩個鏈表沒有交點，返回 null.
在返回結果後，兩個鏈表仍須保持原有的結構。
可假定整個鏈表結構中沒有循環。
程序盡量滿足 O(n) 時間復雜度，且僅用 O(1) 內存。
這道題與 【題目141. 環形鏈表】 屬於同一題型，環形鏈表可以使用快慢指針判斷，這里我們同樣使用雙指針進行判別，不過步長都是一步，讓兩個指針分別從兩個鏈表頭結點開始向後移動，當其中一個指針走到鏈表末尾後，換到另一個鏈表的頭結點上，另一個指針也是如此，這樣如果兩個鏈表相交，則一定可以相遇，且根據數量關系可知，首次相遇的結點即為相交結點。
如有疑問或建議，歡迎評論區留言~
5. python _ x for x in x
鏈表推導式
鏈表推導式提供了一個創建鏈表的簡單途徑，無需使用 map()， filter() 以及 lambda。返回鏈表的定義通常要比創建這些鏈表更清晰。每一個鏈表推導式包括在一個for語句之後的表達式，零或多個for或if語句。返回值是由for或if子句之後的表達式得到的元素組成的鏈表。如果想要得到一個元組，必須要加上括弧。
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]
>>> [[x,x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
>>> [x, x**2 for x in vec] # error - parens required for tuples
File "<stdin>", line 1, in ?
[x, x**2 for x in vec]
^
SyntaxError: invalid syntax
>>> [(x, x**2) for x in vec]
[(2, 4), (4, 16), (6, 36)]
>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]
為使鏈表推導式匹配for循環的行為，可以在推導之外保留循環變數：
>>> x = 100 # this gets overwritten
>>> [x**3 for x in range(5)]
[0, 1, 8, 27, 64]
>>> x # the final value for range(5)
摘自
Python handbook
Guido van Rossum
Fred L. Drake, Jr., editor
6. python list[3::-1]是什麼意思
「python list[3::-1]」的意思是：從位置3反向截取list中的數組。
list參數分別是截取位置、截取方式。3代表從list第三個位置開始截取，-1代表反向截取。
在編程語言中，List是雙向串列連接，用於管理線性列中的對象集合。 list的功能是在集合中的任何位置添加或刪除元素都是快速的，但不支持隨機訪問。
list是類庫提供的眾多容器（container）之一，除此之外還有vector、set、map、…等等。List被實現為模板（即泛型），並且可以處理任何類型的變數，包括用戶定義的數據類型。
(6)python循環鏈表擴展閱讀：
list是一個雙向循環鏈表，每個元素都知道前一個元素和下一個元素。
在STL中，list（如vector）是常用容器，與vector不同，list不支持對元素的任意訪問。 list中提供的成員函數類似於vector，但是list提供了對表的第一個元素push_front和pop_front的操作，這些操作在vector中不可用。
與vector不同，list迭代器不會失敗。 與vector不同，vector保留了備份空間，當超過容量限制時，將重新分配所有內存，從而導致迭代器失敗。 List沒有備份空間的概念，請求元素進行空間的進出，因此其迭代器不會失敗。
7. python 如何用單向循環鏈表實現堆棧
Node沒什麼問題，就是變數定義的時候是一個下劃線而不是兩個
Stack這里有點問題，
（不知道你這里為啥需要做成一個循環的鏈表，不過不管了）
首先你得定義一個head和一個tail，這樣的話才能把tail和head連接形成一個循環
初始化Stack的話把head和tail都設置成None表示這是個空的stack
push的話看你喜歡這么寫了，比較喜歡的是把push進去的Node作為新的head，然後修改一下self._head為新Node，然後修改新Node的next為老的head，再連接一下Tail和Head便可，這樣就省掉一些循環
pop的話就加一些判定好了，首先看Head是不是None，如果是就說明Stack是空的。如果發現Tail和Head都是同一個的話就說明Stack里就一項了，提取完Head之後就設置Stack為空吧。然後先提取Head，然後讀取Head後面的那一個Node並且設置為新的Head，然後再連接一下Tail和Head便可
附上代碼供參考.
classNode:
def__init__(self,newData):
self._data=newData
self._next=None
defgetData(self):
returnself._data
defgetNext(self):
returnself._next
defsetData(self,newData):
self._data=newData
defsetNext(self,newNode):
self._next=newNode
classStack:
def__init__(self):
self._head=None
self._tail=None
defpush(self,data):
print'Push',data,'intostack'
new=Node(data)
cur=self._head
end=self._tail
ifcurisNone:
self._head=new
new.setNext(new)
self._tail=new
else:
new.setNext(self._head)
self._head=new
self._tail.setNext(new)
defpop(self):
ifself._headisnotNone:
cur=self._head
print'pop',cur.getData(),'outofstack'
ifcur.getNext()isnotcur:
self._head=cur.getNext()
self._tail.setNext(self._head)
else:
self._head=None
self._tail=None
else:
print'Stackisempty'
my=Stack()
foriinrange(5):
my.push(i)
foriinrange(6):
my.pop()
8. 如何用python的單向循環鏈實現猴子選大王
count=10#總猴子數
i=0#開始的序號
skip=1#報數的間隔數
arr=list(range(count))#創建一個列表
print(arr)#[0,1,2,3,4,5,6,7,8,9]
while(count>1):
ifi>=count:i=i%count
print('刪除:',arr[i],end='')
arr.pop(i)
print('剩餘:',arr)
count=len(arr)
i=i+skip
#輸出結果:
#[0,1,2,3,4,5,6,7,8,9]
#刪除:0剩餘:[1,2,3,4,5,6,7,8,9]
#刪除:2剩餘:[1,3,4,5,6,7,8,9]
#刪除:4剩餘:[1,3,5,6,7,8,9]
#刪除:6剩餘:[1,3,5,7,8,9]
#刪除:8剩餘:[1,3,5,7,9]
#刪除:1剩餘:[3,5,7,9]
#刪除:5剩餘:[3,7,9]
#刪除:9剩餘:[3,7]
#刪除:7剩餘:[3]
9. python統計不重復單詞，輸出問題
思路大概是這樣：
將文件內容讀到一個鏈表裡邊，用鏈表count（）函數統計空格數量n，然後循環n次，每次做好單詞前後空格標記，將該單詞取出來，放到一個word【】空鏈表裡，再用count（）函數統計出現數，放到另外一個number【】空鏈表裡，循環執行完之後，結果output=dict(zip(word,number))即為最後字典輸出；
或者可以利用re正則表達式直接查找出空格中間的單詞，輸出到一個新鏈表裡邊，然後直接統計每個單詞就行了
10. python，刪除有序鏈表重復元素，為什麼沒通過
哎！你剛提問題沒多久，我就開始寫代碼，寫到現在，不採納真的是太對不起我了...
因為你沒有寫出具體的線性表，所以我假設該線性表是需要手動輸入的！
代碼如下運行通過：
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
typedef int ElemType;
typedef struct Node
{
ElemType data;
struct Node *next;
}Node,*Sqlist;
void IniList(Sqlist *L) /*初始化*/
{
*L=(Sqlist)malloc(sizeof(Node));
(*L)->next=*L;
}
void Create_cLinkList(Sqlist L) /*尾插法建立鏈表*/
{
Node *s;
int c;
int flag=1;
bool bl;
L->data=NULL;
L->next=NULL;
while(flag)
{
bl=scanf("%d",&c);
if(bl)
{
s=(Node *)malloc(sizeof(Node));
s->data=c;
s->next=L->next;
L->next=s;
}
else
{
flag=0;
}
}
}
void Treserve( Sqlist &L) /*比較鏈表中的每個數字，重復就刪除*/
{
Node *p;
Node *s;
s=p=L->next;
while(p->next!=NULL)
{
p=s;
p=p->next;
if(s->data==p->data)
{
if(p->next==NULL)
s->next=NULL;
else
s->next=p->next;
}
else
{
s=p;
}
}
}
main()
{
Sqlist la;
Node *p;
Node *s;
IniList(&la);
printf("輸入循環單鏈表A數據，按從小到大的順序輸入，輸入$符號結束:\n");
Create_cLinkList(la);
Treserve( la);
s=la;
p=la->next;
while(s->next!=NULL) /*輸出改變後的鏈表*/
{
printf("%d",p->data);
s=p;
p=p->next;
}
}