pythonhstack函數

❶ python，輸入一個字元串，然後依次顯示該字元串的每一個字元以及該字元的ASCII碼。

data segment para
str1 db 『one』, 』$』
str2 db 『Two』, 』$』
str3 db 『Three』, 』$』
str4 db 『four』, 』$』
str5 db 『five』, 』$』
tab dw str1,str2,str3,str4,str5
data ends
ssg segment stack
dw 256 p(?)
ssg ends
code segment para
assume cs:code,ss:ssg,ds:data
main proc far
mov ax, data
mov ds, ax
mov ah, 1 ;鍵盤輸入
int 21h
call asc2bin
mov bl, al
mov bh, 0
dec bx
shl bx, 1
mov dx, tab[bx]
mov ah, 9
int 21h
mov ax, 4c00h
Int 21h
main endp
;將ASCII轉換為二進制數
;入口：AL存放ASCII
;出口：轉換後數值在AL
asc2bin proc
sub al, 30h
cmp al, 9
jbe next
sub al, 7
next: ret
asc2bin endp
end main
上面的程序是：從鍵盤輸入1~5之間的一個數，在屏幕上顯示one…five。雖然不一樣，但要求差不多，希望對你有幫助！

❷ 用Python3實現表達式求值

include <malloc.h> #include <stdio.h> #include <ctype.h>//判斷是否為字元的函數的頭文件 #define maxsize 100 typedef int elemtype; typedef struct sqstack sqstack;//由於sqstack不是一個類型 而struct sqstack才是 char ch[7]=;//把符號轉換成一個字元數組 int f1[7]=;//棧內元素優先順序 int f2[7]=;//棧外的元素優先順序 struct sqstack { elemtype stack[maxsize]; int top; }; void Initstack(sqstack *s) { s->top=0; } void Push(sqstack *s,elemtype x) { if(s->top==maxsize-1) printf("Overflow\n"); else { s->top++; s->stack[s->top]=x; } } void Pop(sqstack *s,elemtype *x) { if(s->top==0) printf("underflow\n"); else { *x=s->stack[s->top]; s->top--; } } elemtype Gettop(sqstack s) { if(s.top==0) { printf("underflow\n"); return 0; } else return s.stack[s.top]; } elemtype f(char c) { switch(c) { case '+': return 0; case '-': return 1; case '*': return 2; case '/': return 3; case '(': return 4; case ')': return 5; default: return 6; } } char precede(char c1,char c2) { int i1=f(c1); int i2=f(c2);//把字元變成數字 if(f1[i1]>f2[i2])//通過原來設定找到優先順序 return '>'; else if(f1[i1]<f2[i2]) return '<'; else return '='; } int Operate(elemtype a,elemtype theta,elemtype b) { int sum; switch(theta) { case 0: sum=a+b; break; case 1: sum=a-b; break; case 2: sum=a*b; break; default: sum=a/b; } return sum; } EvaluateExpression() { char c; int i=0,sum=0; int k=1,j=1;//設置了開關變數 elemtype x,theta,a,b; sqstack OPTR,OPND; Initstack(&OPTR); Push(&OPTR,f('#'));//0壓入棧 Initstack(&OPND); c=getchar(); if(c==ch[2]||c==ch[3]||c==ch[5]||c==ch[6])//先對＋和-的情況忽略和左括弧的情況 { printf("錯誤1 \n"); k=0; return 0; } if(c==ch[0]) c=getchar();//如果是＋，把它覆蓋 if(c==ch[1]) { j=0; c=getchar();//也把－號覆蓋 } while(c!='#'||ch[Gettop(OPTR)]!='#') { if(isdigit(c)) { sum=0; while(isdigit(c)) { if(!j) { sum=sum*10-(c-'0');//實現了數字串前面有負號（之前是：sum=-(sum*10)-(c-'0')結果是－12＋13＝21） } else sum=sum*10+(c-'0'); c=getchar(); } Push(&OPND,sum);//如果還是數字先不壓棧，把數字串轉化成十進制數字再壓棧 j=1; } else if(k) { switch(precede(ch[Gettop(OPTR)],c)) { case'<': Push(&OPTR,f(c));//把它們整型化 c=getchar(); if(c==ch[0]||c==ch[1]||c==ch[2]||c==ch[3]||c==ch[5]||c=='\n')//要除去下個是『（』的情況 也把以運算符歸到這里來 { printf("出錯2\n"); k=0; return 0;//加了開關變數和返回0的值使程序更以操作 } break; case'=': Pop(&OPTR,&x); c=getchar(); if(c==ch[0]||c==ch[1]||c==ch[2]||c==ch[3]||c==ch[5]||c=='\n')//把ch[6]的情況也忽略了但此時並沒有注意到右括弧後面右運算符的情況 { printf("出錯2\n"); k=0; return 0; } break; case'>': Pop(&OPTR,&theta); Pop(&OPND,&b); Pop(&OPND,&a);//注意這里是誰先出棧 Push(&OPND,Operate(a,theta,b)); break; } } }//在這里判斷是否以運算符結束是不對的 return(Gettop(OPND)); } main() { int result; printf("輸入你的算術表達式：\n"); result=EvaluateExpression(); printf("結果是 :%d\n",result); return 0; } : 本計算器利用堆棧來實現。 1、定義後綴式計算器的堆棧結構 因為需要存儲的單元不多，這里使用順序棧，即用一維數組來模擬堆棧： #define MAX 100 int stack[MAX]; int top=0; 因此程序中定義了長度為MAX的一維數組，這里MAX用宏定義為常數100，我們可以修改宏定義而重新定義堆棧的大小。 整型數據top為棧頂指示，由於程序開始時堆棧中並無任何數據元素，因此top被初始化為0。 2、存儲後綴式計算器的運算數 我們定義了堆棧stack[MAX]後，就可以利用入棧操作存儲先後輸入的兩個運算數。 下面看一下是如何實現的： int push(int i) /*存儲運算數，入棧操作*/ { if(top<MAX) { stack[++top]=i; /*堆棧仍有空間，棧頂指示上移一個位置*/ return 0; } else /*堆棧已滿，給出錯誤信息，返回出錯指示*/ { printf("The stack is full"); return ERR; } } 我們在調用函數push時，如果它的返回值為0，說明入棧操作成功；否則，若返回值為ERR(在程序中說明為-1)，說明入棧操作失敗。 3、從堆棧中取出運算數 當程序中讀完了四則運算符後，我們就可以從堆棧中取出已經存入的兩個運算數，構成表達式，計算出結果。取出運算數的函數採用的正是出棧演算法。在本例中，實現該演算法的函數 為pop(): int pop(); /*取出運算數，出棧操作*/ { int var; /*定義待返回的棧頂元素*/ if(top!=NULL) /*堆棧中仍有數據元素*/ { var=stack[top--]; /*堆棧指示下移一個位置*/ return var; } else /*堆棧為空，給出錯誤信息，並返回出錯返回值*/ printf("The stack is cmpty!\n"); return ERR; } 同樣，如果堆棧不為空，pop()函數返回堆棧頂端的數據元素，否則，給出棧空提示，並返回錯誤返回值ERR。 4、設計完整的後綴式計算器 有了堆棧存儲運算數，後綴式計算器的設計就很簡單了。程序首先提示用戶輸入第一個運算數，調用push()函數存入堆棧中；而後提示用戶輸入第二個運算數，同樣調用push()函數存入堆棧中。接下來，程序提示用戶輸入+,-,*,/四種運算符的一種，程序通過switch_case結構判斷輸入運算符的種類，轉而執行不同的處理代碼。以除法為例，說明程序的執行流程： case '/': b=pop(); a=pop(); c=a/b; printf("\n\nThe result is %d\n",c); printf("\n"); break; 程序判斷用戶輸入的是除號後，就執行上述代碼。首先接連兩次調用pop()函數從堆棧中讀出先前輸入的運算數，存入整型數a和b中；然後執行除法運算，結果存入單元c中。這時需要考慮究竟誰是被除數，誰是除數。由於開始我們先將被除數入棧，根據堆棧「先進後出」的原則，被除數應該是第二次調用pop()函數得到的返回值。而除數則是第一次調用pop()函數得到的返回值。 最後程序列印出運算結果，並示提示用戶是否繼續運行程序： printf("\t Continue?(y/n):"); l=getche(); if(l=='n') exit(0); 如果用戶回答是"n"，那麼結束程序，否則繼續循環。 完整的程序代碼如下： #include<stdio.h> #include<conio.h> #include<stdlib.h> #define ERR -1 #define MAX 100 /*定義堆棧的大小*/ int stack[MAX]; /*用一維數組定義堆棧*/ int top=0; /*定義堆棧指示*/ int push(int i) /*存儲運算數,入棧操作*/ { if(top<MAX) { stack[++top]=i; /*堆棧仍有空間，棧頂指示上移一個位置*/ return 0; } else { printf("The stack is full"); return ERR; } } int pop() /*取出運算數，出棧操作*/ { int var; /*定義待返回的棧頂元素*/ if(top!=NULL) /*堆棧中仍有元素*/ { var=stack[top--]; /*堆棧指示下移一個位置*/ return var; /*返回棧頂元素*/ } else printf("The stack is empty!\n"); return ERR; } void main() { int m,n; char l; int a,b,c; int k; do{ printf("\tAriothmatic Operate simulator\n"); /*給出提示信息*/ printf("\n\tPlease input first number:"); /*輸入第一個運算數*/ scanf("%d",&m); push(m); /*第一個運算數入棧*/ printf("\n\tPlease input second number:"); /*輸入第二個運算數*/ scanf("%d",&n); push(n); /*第二個運算數入棧*/ printf("\n\tChoose operator(+/-/*//):"); l=getche(); /*輸入運算符*/ switch(l) /*判斷運算符，轉而執行相應代碼*/ { case '+': b=pop(); a=pop(); c=a+b; printf("\n\n\tThe result is %d\n",c); printf("\n"); break; case '-': b=pop(); a=pop(); c=a-b; printf("\n\n\tThe result is %d\n",c); printf("\n"); break; case '*': b=pop(); a=pop(); c=a*b; printf("\n\n\tThe result is %d\n",c); printf("\n"); break; case '/': b=pop(); a=pop(); c=a/b; printf("\n\n\tThe result is %d\n",c); printf("\n"); break; } printf("\tContinue?(y/n):"); /*提示用戶是否結束程序*/ l=getche(); if(l=='n') exit(0); }while(1); } : #include <stdio.h> #include <conio.h> #include <malloc.h> #include <stdlib.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 typedef int Status; #define STACK_INIT_SIZE 100 //初始分配量 #define STACKINCREMENT 10 //存儲空間的分配增量 typedef char ElemType; typedef ElemType OperandType; //操作數 typedef char OperatorType; typedef struct { ElemType *base; ElemType *top; int stacksize; }SqStack; Status InitStack(SqStack &S) { //構造一個空棧S S.base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType)); if(!S.base) exit (OVERFLOW); S.top = S.base; S.stacksize = STACK_INIT_SIZE; return OK; } Status GetTop(SqStack S){ ElemType e; if (S.top == S.base) return ERROR; e = *(S.top-1); return e; } Status Push (SqStack &S,ElemType e) { //插入元素e為新的棧頂元素 if (S.top - S.base >= S.stacksize){ S.base = (ElemType *) realloc ( S.base, (S.stacksize + STACKINCREMENT) * sizeof(ElemType)); if(!S.base) exit (OVERFLOW); S.top = S.base + S.stacksize; S.stacksize += STACKINCREMENT; } *S.top++ = e; return OK; } Status Pop (SqStack &S,ElemType &e){ //若棧不空，則刪除S的棧頂元素，用e返回其值，並返回OK；否則返回ERROR if(S.top == S.base) return ERROR; e = * --S.top; return OK; } char In(char c,char OP[]) { if(c>=35 && c<=47) return 1; else return 0; } char OP[8]=; int m[7][7]={1,1,2,2,2,1,1, 1,1,2,2,2,1,1, 1,1,1,1,2,1,1, 1,1,1,1,2,1,1, 2,2,2,2,2,0,-1, 1,1,1,1,-1,1,1, 2,2,2,2,2,-1,0};//1 > 2 < 0 = -1 不存在 char Precede(char i,char j) { int a,b; char *p; for(p=OP,a=0;*p!='\0';p++,a++) if(*p==i) break; for(p=OP,b=0;*p!='\0';p++,b++) if(*p==j) break; if(m[a][b]==1) return '>'; else if(m[a][b]==2) return '<'; else if(m[a][b]==0) return '='; else return 'O'; } char Operate(char a,char theta,char b) { if(a>47) a=atoi(&a); if(b>47) b=atoi(&b); switch(theta) { case '+': return a+b; break; case '-': return a-b; break; case '*': return a*b; break; case '/': return a/b; break; } } OperandType EvaluateExpression() { SqStack OPTR,OPND; OperandType a,b,c; OperatorType theta; InitStack(OPTR); Push(OPTR,'#'); InitStack(OPND); c=getchar(); while (c!='#' || GetTop(OPTR)!='#') { if (!In(c,OP)) else switch(Precede(GetTop(OPTR),c)) { case '<' : Push(OPTR,c); c = getchar(); break; case '=' : Pop(OPTR,c); c = getchar(); break; case '>' : Pop(OPTR,theta); Pop(OPND,b); Pop(OPND,a); Push(OPND,Operate(a,theta,b)); break; } } return GetTop(OPND); } void main() { printf("(以#為結束符)\n"); printf("請輸入：\n"); int a; a=(int)EvaluateExpression(); printf("%d",a); getch(); } : ls都正確 : C++ In Action這本書裡面有表達式求值的詳細項目分析. : 數據結構的書裡面都有的,仔細看一下 : studyall123的只能對0到9的數字運算才有效,對於10以上的數字就不行!不知道有沒有更好的方法! : 現在的人，連google一下都懶啊 : 實際上是按照逆波蘭式的順序讓輸入的表達式入棧，再根據運算符優先順序來計算。 : lenrning!

❸ python--怎麼查看模塊OS里listdir()函數的源代碼，也就是怎麼定義istdir()的代碼

去 python 官網下載 Gzipped source tar ball， 解壓縮後， 你會發現 Lib/os.py 文件這行代碼

from posix import *

可是沒有文件叫 posix.py 啊， 到底在那 ? 其實 posix mole 是 builtin 的其中一分子，如下所示範:

>>> import sys
>>> print sys.builtin_mole_names
(*__builtin__*, *__main__*, *_ast*, *_codecs*, *_sre*, *_symtable*, *_warnings*, *_weakref*, *errno*, *exceptions*, *gc*, *imp*, *marshal*, *posix*, *pwd*, *signal*, *sys*, *thread*, *zipimport*)
>>>

所以要去 Moles 目錄查找 c 代碼， 你會看見 posixmole.c， 打開它看見這行代碼:

{"listdir", posix_listdir, METH_VARARGS, posix_listdir__doc__},

再尋找上面所得到的 posix_listdir method, 可以找到 listdir 源代碼:

static PyObject *
posix_listdir(PyObject *self, PyObject *args)
{
/* XXX Should redo this putting the (now four) versions of opendir
in separate files instead of having them all here... */
#if defined(MS_WINDOWS) && !defined(HAVE_OPENDIR)

PyObject *d, *v;
HANDLE hFindFile;
BOOL result;
.... 省略
來自puthon吧

❹ 如何用PyTorch實現遞歸神經網路

從 Siri 到谷歌翻譯，深度神經網路已經在機器理解自然語言方面取得了巨大突破。這些模型大多數將語言視為單調的單詞或字元序列，並使用一種稱為循環神經網路（recurrent neural network/RNN）的模型來處理該序列。但是許多語言學家認為語言最好被理解為具有樹形結構的層次化片語，一種被稱為遞歸神經網路（recursive neural network）的深度學習模型考慮到了這種結構，這方面已經有大量的研究。雖然這些模型非常難以實現且效率很低，但是一個全新的深度學習框架 PyTorch 能使它們和其它復雜的自然語言處理模型變得更加容易。

雖然遞歸神經網路很好地顯示了 PyTorch 的靈活性，但它也廣泛支持其它的各種深度學習框架，特別的是，它能夠對計算機視覺（computer vision）計算提供強大的支撐。PyTorch 是 Facebook AI Research 和其它幾個實驗室的開發人員的成果，該框架結合了 Torch7 高效靈活的 GPU 加速後端庫與直觀的 Python 前端，它的特點是快速成形、代碼可讀和支持最廣泛的深度學習模型。

開始 SPINN

鏈接中的文章（https://github.com/jekbradbury/examples/tree/spinn/snli）詳細介紹了一個遞歸神經網路的 PyTorch 實現，它具有一個循環跟蹤器（recurrent tracker）和 TreeLSTM 節點，也稱為 SPINN——SPINN 是深度學習模型用於自然語言處理的一個例子，它很難通過許多流行的框架構建。這里的模型實現部分運用了批處理（batch），所以它可以利用 GPU 加速，使得運行速度明顯快於不使用批處理的版本。

SPINN 的意思是堆棧增強的解析器-解釋器神經網路（Stack-augmented Parser-Interpreter Neural Network），由 Bowman 等人於 2016 年作為解決自然語言推理任務的一種方法引入，該論文中使用了斯坦福大學的 SNLI 數據集。

該任務是將語句對分為三類：假設語句 1 是一幅看不見的圖像的准確標題，那麼語句 2（a）肯定（b）可能還是（c）絕對不是一個准確的標題？（這些類分別被稱為蘊含（entailment）、中立（neutral）和矛盾（contradiction））。例如，假設一句話是「兩只狗正跑過一片場地」，蘊含可能會使這個語句對變成「戶外的動物」，中立可能會使這個語句對變成「一些小狗正在跑並試圖抓住一根棍子」，矛盾能會使這個語句對變成「寵物正坐在沙發上」。

特別地，研究 SPINN 的初始目標是在確定語句的關系之前將每個句子編碼（encoding）成固定長度的向量表示（也有其它方式，例如注意模型（attention model）中將每個句子的每個部分用一種柔焦（soft focus）的方法相互比較）。

數據集是用句法解析樹（syntactic parse tree）方法由機器生成的，句法解析樹將每個句子中的單詞分組成具有獨立意義的短語和子句，每個短語由兩個詞或子短語組成。許多語言學家認為，人類通過如上面所說的樹的分層方式來組合詞意並理解語言，所以用相同的方式嘗試構建一個神經網路是值得的。下面的例子是數據集中的一個句子，其解析樹由嵌套括弧表示：

( ( The church ) ( ( has ( cracks ( in ( the ceiling ) ) ) ) . ) )

這個句子進行編碼的一種方式是使用含有解析樹的神經網路構建一個神經網路層 Rece，這個神經網路層能夠組合詞語對（用詞嵌入（word embedding）表示，如 GloVe）、 和/或短語，然後遞歸地應用此層（函數），將最後一個 Rece 產生的結果作為句子的編碼：

X = Rece(「the」, 「ceiling」)
Y = Rece(「in」, X)
... etc.

但是，如果我希望網路以更類似人類的方式工作，從左到右閱讀並保留句子的語境，同時仍然使用解析樹組合短語？或者，如果我想訓練一個網路來構建自己的解析樹，讓解析樹根據它看到的單詞讀取句子？這是一個同樣的但方式略有不同的解析樹的寫法：

The church ) has cracks in the ceiling ) ) ) ) . ) )

或者用第 3 種方式表示，如下：

WORDS: The church has cracks in the ceiling .
PARSES: S S R S S S S S R R R R S R R

我所做的只是刪除開括弧，然後用「S」標記「shift」，並用「R」替換閉括弧用於「rece」。但是現在可以從左到右讀取信息作為一組指令來操作一個堆棧（stack）和一個類似堆棧的緩沖區（buffer），能得到與上述遞歸方法完全相同的結果：

1. 將單詞放入緩沖區。
2. 從緩沖區的前部彈出「The」，將其推送（push）到堆棧上層，緊接著是「church」。
3. 彈出前 2 個堆棧值，應用於 Rece，然後將結果推送回堆棧。
4. 從緩沖區彈出「has」，然後推送到堆棧，然後是「cracks」，然後是「in」，然後是「the」，然後是「ceiling」。
5. 重復四次：彈出 2 個堆棧值，應用於 Rece，然後推送結果。
6. 從緩沖區彈出「.」，然後推送到堆棧上層。
7. 重復兩次：彈出 2 個堆棧值，應用於 Rece，然後推送結果。
8. 彈出剩餘的堆棧值，並將其作為句子編碼返回。

我還想保留句子的語境，以便在對句子的後半部分應用 Rece 層時考慮系統已經讀取的句子部分的信息。所以我將用一個三參數函數替換雙參數的 Rece 函數，該函數的輸入值為一個左子句、一個右子句和當前句的上下文狀態。該狀態由神經網路的第二層（稱為循環跟蹤器（Tracker）的單元）創建。Tracker 在給定當前句子上下文狀態、緩沖區中的頂部條目 b 和堆棧中前兩個條目 s1\s2 時，在堆棧操作的每個步驟（即，讀取每個單詞或閉括弧）後生成一個新狀態：

context[t+1] = Tracker(context[t], b, s1, s2)

容易設想用你最喜歡的編程語言來編寫代碼做這些事情。對於要處理的每個句子，它將從緩沖區載入下一個單詞，運行跟蹤器，檢查是否將單詞推送入堆棧或執行 Rece 函數，執行該操作；然後重復，直到對整個句子完成處理。通過對單個句子的應用，該過程構成了一個大而復雜的深度神經網路，通過堆棧操作的方式一遍又一遍地應用它的兩個可訓練層。但是，如果你熟悉 TensorFlow 或 Theano 等傳統的深度學習框架，就知道它們很難實現這樣的動態過程。你值得花點時間回顧一下，探索為什麼 PyTorch 能有所不同。

圖論

圖 1：一個函數的圖結構表示

深度神經網路本質上是有大量參數的復雜函數。深度學習的目的是通過計算以損失函數（loss）度量的偏導數（梯度）來優化這些參數。如果函數表示為計算圖結構（圖 1），則向後遍歷該圖可實現這些梯度的計算，而無需冗餘工作。每個現代深度學習框架都是基於此反向傳播（backpropagation）的概念，因此每個框架都需要一個表示計算圖的方式。

在許多流行的框架中，包括 TensorFlow、Theano 和 Keras 以及 Torch7 的 nngraph 庫，計算圖是一個提前構建的靜態對象。該圖是用像數學表達式的代碼定義的，但其變數實際上是尚未保存任何數值的佔位符（placeholder）。圖中的佔位符變數被編譯進函數，然後可以在訓練集的批處理上重復運行該函數來產生輸出和梯度值。

這種靜態計算圖（static computation graph）方法對於固定結構的卷積神經網路效果很好。但是在許多其它應用中，有用的做法是令神經網路的圖結構根據數據而有所不同。在自然語言處理中，研究人員通常希望通過每個時間步驟中輸入的單詞來展開（確定）循環神經網路。上述 SPINN 模型中的堆棧操作很大程度上依賴於控制流程（如 for 和 if 語句）來定義特定句子的計算圖結構。在更復雜的情況下，你可能需要構建結構依賴於模型自身的子網路輸出的模型。

這些想法中的一些（雖然不是全部）可以被生搬硬套到靜態圖系統中，但幾乎總是以降低透明度和增加代碼的困惑度為代價。該框架必須在其計算圖中添加特殊的節點，這些節點代表如循環和條件的編程原語（programming primitive），而用戶必須學習和使用這些節點，而不僅僅是編程代碼語言中的 for 和 if 語句。這是因為程序員使用的任何控制流程語句將僅運行一次，當構建圖時程序員需要硬編碼（hard coding）單個計算路徑。

例如，通過詞向量（從初始狀態 h0 開始）運行循環神經網路單元（rnn_unit）需要 TensorFlow 中的特殊控制流節點 tf.while_loop。需要一個額外的特殊節點來獲取運行時的詞長度，因為在運行代碼時它只是一個佔位符。

# TensorFlow
# (this code runs once, ring model initialization)
# 「words」 is not a real list (it』s a placeholder variable) so
# I can』t use 「len」
cond = lambda i, h: i < tf.shape(words)[0]
cell = lambda i, h: rnn_unit(words[i], h)
i = 0
_, h = tf.while_loop(cond, cell, (i, h0))

基於動態計算圖（dynamic computation graph）的方法與之前的方法有根本性不同，它有幾十年的學術研究歷史，其中包括了哈佛的 Kayak、自動微分庫（autograd）以及以研究為中心的框架 Chainer和 DyNet。在這樣的框架（也稱為運行時定義（define-by-run））中，計算圖在運行時被建立和重建，使用相同的代碼為前向通過（forward pass）執行計算，同時也為反向傳播（backpropagation）建立所需的數據結構。這種方法能產生更直接的代碼，因為控制流程的編寫可以使用標準的 for 和 if。它還使調試更容易，因為運行時斷點（run-time breakpoint）或堆棧跟蹤（stack trace）將追蹤到實際編寫的代碼，而不是執行引擎中的編譯函數。可以在動態框架中使用簡單的 Python 的 for 循環來實現有相同變數長度的循環神經網路。

# PyTorch (also works in Chainer)
# (this code runs on every forward pass of the model)
# 「words」 is a Python list with actual values in it
h = h0
for word in words:
h = rnn_unit(word, h)

PyTorch 是第一個 define-by-run 的深度學習框架，它與靜態圖框架（如 TensorFlow）的功能和性能相匹配，使其能很好地適合從標准卷積神經網路（convolutional network）到最瘋狂的強化學習（reinforcement learning）等思想。所以讓我們來看看 SPINN 的實現。

代碼

在開始構建網路之前，我需要設置一個數據載入器（data loader）。通過深度學習，模型可以通過數據樣本的批處理進行操作，通過並行化（parallelism）加快訓練，並在每一步都有一個更平滑的梯度變化。我想在這里可以做到這一點（稍後我將解釋上述堆棧操作過程如何進行批處理）。以下 Python 代碼使用內置於 PyTorch 的文本庫的系統來載入數據，它可以通過連接相似長度的數據樣本自動生成批處理。運行此代碼之後，train_iter、dev_iter 和 test_itercontain 循環遍歷訓練集、驗證集和測試集分塊 SNLI 的批處理。

from torchtext import data, datasets
TEXT = datasets.snli.ParsedTextField(lower=True)
TRANSITIONS = datasets.snli.ShiftReceField()
LABELS = data.Field(sequential=False)train, dev, test = datasets.SNLI.splits(
TEXT, TRANSITIONS, LABELS, wv_type='glove.42B')TEXT.build_vocab(train, dev, test)
train_iter, dev_iter, test_iter = data.BucketIterator.splits(
(train, dev, test), batch_size=64)

你可以在 train.py中找到設置訓練循環和准確性（accuracy）測量的其餘代碼。讓我們繼續。如上所述，SPINN 編碼器包含參數化的 Rece 層和可選的循環跟蹤器來跟蹤句子上下文，以便在每次網路讀取單詞或應用 Rece 時更新隱藏狀態；以下代碼代表的是，創建一個 SPINN 只是意味著創建這兩個子模塊（我們將很快看到它們的代碼），並將它們放在一個容器中以供稍後使用。

import torchfrom torch import nn
# subclass the Mole class from PyTorch』s neural network package
class SPINN(nn.Mole):
def __init__(self, config):
super(SPINN, self).__init__()
self.config = config self.rece = Rece(config.d_hidden, config.d_tracker)
if config.d_tracker is not None:
self.tracker = Tracker(config.d_hidden, config.d_tracker)

當創建模型時，SPINN.__init__ 被調用了一次；它分配和初始化參數，但不執行任何神經網路操作或構建任何類型的計算圖。在每個新的批處理數據上運行的代碼由 SPINN.forward 方法定義，它是用戶實現的方法中用於定義模型向前過程的標准 PyTorch 名稱。上面描述的是堆棧操作演算法的一個有效實現，即在一般 Python 中，在一批緩沖區和堆棧上運行，每一個例子都對應一個緩沖區和堆棧。我使用轉移矩陣（transition）包含的「shift」和「rece」操作集合進行迭代，運行 Tracker（如果存在），並遍歷批處理中的每個樣本來應用「shift」操作（如果請求），或將其添加到需要「rece」操作的樣本列表中。然後在該列表中的所有樣本上運行 Rece 層，並將結果推送回到它們各自的堆棧。

def forward(self, buffers, transitions):
# The input comes in as a single tensor of word embeddings;
# I need it to be a list of stacks, one for each example in
# the batch, that we can pop from independently. The words in
# each example have already been reversed, so that they can
# be read from left to right by popping from the end of each
# list; they have also been prefixed with a null value.
buffers = [list(torch.split(b.squeeze(1), 1, 0))
for b in torch.split(buffers, 1, 1)]
# we also need two null values at the bottom of each stack,
# so we can from the nulls in the input; these nulls
# are all needed so that the tracker can run even if the
# buffer or stack is empty
stacks = [[buf[0], buf[0]] for buf in buffers]
if hasattr(self, 'tracker'):
self.tracker.reset_state()
for trans_batch in transitions:
if hasattr(self, 'tracker'):
# I described the Tracker earlier as taking 4
# arguments (context_t, b, s1, s2), but here I
# provide the stack contents as a single argument
# while storing the context inside the Tracker
# object itself.
tracker_states, _ = self.tracker(buffers, stacks)
else:
tracker_states = itertools.repeat(None)
lefts, rights, trackings = [], [], []
batch = zip(trans_batch, buffers, stacks, tracker_states)
for transition, buf, stack, tracking in batch:
if transition == SHIFT:
stack.append(buf.pop())
elif transition == REDUCE:
rights.append(stack.pop())
lefts.append(stack.pop())
trackings.append(tracking)
if rights:
reced = iter(self.rece(lefts, rights, trackings))
for transition, stack in zip(trans_batch, stacks):
if transition == REDUCE:
stack.append(next(reced))
return [stack.pop() for stack in stacks]

在調用 self.tracker 或 self.rece 時分別運行 Tracker 或 Rece 子模塊的向前方法，該方法需要在樣本列表上應用前向操作。在主函數的向前方法中，在不同的樣本上進行獨立的操作是有意義的，即為批處理中每個樣本提供分離的緩沖區和堆棧，因為所有受益於批處理執行的重度使用數學和需要 GPU 加速的操作都在 Tracker 和 Rece 中進行。為了更干凈地編寫這些函數，我將使用一些 helper（稍後將定義）將這些樣本列表轉化成批處理張量（tensor），反之亦然。

我希望 Rece 模塊自動批處理其參數以加速計算，然後解批處理（unbatch）它們，以便可以單獨推送和彈出。用於將每對左、右子短語表達組合成父短語（parent phrase）的實際組合函數是 TreeLSTM，它是普通循環神經網路單元 LSTM 的變型。該組合函數要求每個子短語的狀態實際上由兩個張量組成，一個隱藏狀態 h 和一個存儲單元（memory cell）狀態 c，而函數是使用在子短語的隱藏狀態操作的兩個線性層（nn.Linear）和將線性層的結果與子短語的存儲單元狀態相結合的非線性組合函數 tree_lstm。在 SPINN 中，這種方式通過添加在 Tracker 的隱藏狀態下運行的第 3 個線性層進行擴展。

圖 2：TreeLSTM 組合函數增加了第 3 個輸入（x，在這種情況下為 Tracker 狀態）。在下面所示的 PyTorch 實現中，5 組的三種線性變換（由藍色、黑色和紅色箭頭的三元組表示）組合為三個 nn.Linear 模塊，而 tree_lstm 函數執行位於框內的所有計算。圖來自 Chen et al. (2016)。

❺ python3.6程序運行出錯，下面是提示 Traceback (most recent call last):

樓上說的不對，出的錯與單引號無關，是編碼的問題。你的代碼本身沒錯，把你現在的文件刪掉，重新建一個就行。下面和你的一樣，只是換了路徑，測試可行
1234567891011121314src_path = 'E:\\test_0.txt'des_path = 'E:\\test_1.txt' file_wait_to_read = open(src_path, 'r')file_wait_to_write = open(des_path, 'w') <a href="https://www..com/s?wd=sat&tn=44039180_cpr&fenlei=_5y9YIZ0lQzqlpA-" target="_blank" class="-highlight">sat</a> = raw_input('Please input the selected <a href="https://www..com/s?wd=sat&tn=44039180_cpr&fenlei=_5y9YIZ0lQzqlpA-" target="_blank" class="-highlight">sat</a>ellite: ')for line in file_wait_to_read.readlines(): if line.startswith(<a href="https://www..com/s?wd=sat&tn=44039180_cpr&fenlei=_5y9YIZ0lQzqlpA-" target="_blank" class="-highlight">sat</a>): file_wait_to_write.write(line) file_wait_to_write.flush()file_wait_to_read.close()file_wait_to_write.close()

❻ 為什麼一用innerproct，python中就會出現check failure stack trace

解決方法如下：
typedef struct lista{

struct lista *next;
int data;
}list;
void insert(list *h);
void del(list *h);

int main()
{
int flag;
list *head=(list *)malloc(sizeof(list));
head->next=NULL;
while(1)
{

❼ 棋盤擺米用Python怎麼做

摘要 棋盤擺米用Python：

❽ 假設有個列表存儲了奇數個數字,請問如何用python編寫程序,輸出中間位置的數字

假設那個list叫a

那就直接：

result = a[int(len(a)/2)]

print(result)

例如：

>>> [0,1,2,3,4,5][1::2]

[1, 3, 5]

>>> from itertools import accumulate

>>> list(accumulate([1,1,1]))

[1, 2, 3]

>>> list(accumulate([1,-1,3]))

[1, 0, 3]

>>> list(map(int,str(123)))

[1, 2, 3]

(8)pythonhstack函數擴展閱讀：

堆棧存儲器指定兩個寄存器來定址：堆棧指針ESP和堆棧段寄存器SS，使用堆棧段之前首先要定義，程序中對堆棧段的定義語句為：STACK 200H；就是對堆棧的定義，即在內存中劃分200H~SS：000001FFH，那麼堆棧指針ESP的初值為00000200H。

當字數據AX壓入堆棧時，高8位放入由ESP-1定址的單元，低8位放入由ESP-2定址的單元，然後ESP中的值減2。當字數據從堆棧彈出到BX時，低8位從ESP定址的單元移出，高8位從ESP+1定址的單元移出，然後ESP寄存器加2。

❾ python二叉樹演算法

定義一顆二叉樹，請看官自行想像其形狀

class BinNode( ):
def __init__( self, val ):
self.lchild = None
self.rchild = None
self.value = val

binNode1 = BinNode( 1 )
binNode2 = BinNode( 2 )
binNode3 = BinNode( 3 )
binNode4 = BinNode( 4 )
binNode5 = BinNode( 5 )
binNode6 = BinNode( 6 )

binNode1.lchild = binNode2
binNode1.rchild = binNode3
binNode2.lchild = binNode4
binNode2.rchild = binNode5
binNode3.lchild = binNode6

❿ Python基礎 numpy中的常見函數有哪些

有些Python小白對numpy中的常見函數不太了解，今天小編就整理出來分享給大家。

Numpy是Python的一個科學計算的庫，提供了矩陣運算的功能，其一般與Scipy、matplotlib一起使用。其實，list已經提供了類似於矩陣的表示形式，不過numpy為我們提供了更多的函數。

數組常用函數
1.where()按條件返回數組的索引值
2.take(a,index)從數組a中按照索引index取值
3.linspace(a,b,N)返回一個在(a,b)范圍內均勻分布的數組，元素個數為N個
4.a.fill()將數組的所有元素以指定的值填充
5.diff(a)返回數組a相鄰元素的差值構成的數組
6.sign(a)返回數組a的每個元素的正負符號
7.piecewise(a,[condlist],[funclist])數組a根據布爾型條件condlist返回對應元素結果
8.a.argmax(),a.argmin()返回a最大、最小元素的索引

改變數組維度
a.ravel(),a.flatten():將數組a展平成一維數組
a.shape=(m,n),a.reshape(m,n):將數組a轉換成m*n維數組
a.transpose,a.T轉置數組a

數組組合
1.hstack((a,b)),concatenate((a,b),axis=1)將數組a,b沿水平方向組合
2.vstack((a,b)),concatenate((a,b),axis=0)將數組a,b沿豎直方向組合
3.row_stack((a,b))將數組a,b按行方向組合
4.column_stack((a,b))將數組a,b按列方向組合

數組分割
1.split(a,n,axis=0),vsplit(a,n)將數組a沿垂直方向分割成n個數組
2.split(a,n,axis=1),hsplit(a,n)將數組a沿水平方向分割成n個數組

數組修剪和壓縮
1.a.clip(m,n)設置數組a的范圍為(m,n),數組中大於n的元素設定為n,小於m的元素設定為m
2.a.compress()返回根據給定條件篩選後的數組

數組屬性
1.a.dtype數組a的數據類型
2.a.shape數組a的維度
3.a.ndim數組a的維數
4.a.size數組a所含元素的總個數
5.a.itemsize數組a的元素在內存中所佔的位元組數
6.a.nbytes整個數組a所佔的內存空間7.a.astype(int)轉換a數組的類型為int型

數組計算
1.average(a,weights=v)對數組a以權重v進行加權平均
2.mean(a),max(a),min(a),middle(a),var(a),std(a)數組a的均值、最大值、最小值、中位數、方差、標准差
3.a.prod()數組a的所有元素的乘積
4.a.cumprod()數組a的元素的累積乘積
5.cov(a,b),corrcoef(a,b)數組a和b的協方差、相關系數
6.a.diagonal()查看矩陣a對角線上的元素7.a.trace()計算矩陣a的跡，即對角線元素之和

以上就是numpy中的常見函數。更多Python學習推薦:PyThon學習網教學中心。