python 學習手札

win7 右鍵選單，轉換影音檔成mp3

2018-01-01T19:18:00.001-08:00

時常會遇到有不錯的mv想轉成mp3上傳到手機來聽，但線上轉檔或相關軟體不是廣告多，就是有收取一些費用，很令人討厭，於是想製做個方便轉換工具！
FFmpeg 是一個跨平台以命令行形式的影像聲音轉換程式，並且也非常容易使用。

例： ffmpeg -i 來源.fav 目的.mp3

所以

第一步: 安裝 FFmpeg

下載位置：
[32bit] http://ffmpeg.zeranoe.com/builds/win32/static
[64bit] http://ffmpeg.zeranoe.com/builds/win64/static

下載後解壓縮到你想安裝的目錄底下

第二步: 寫一個batch檔

C:\ffmpeg\convert2mp3.bat

@echo off
 setlocal ENABLEDELAYEDEXPANSION
 set fName=%1
 set ffmpeg="C:\ffmpeg\bin\ffmpeg.exe"
 
 for /f "tokens=* delims= " %%F in ('echo %fName%') do (
 %ffmpeg% -i "%%~fF" -ab 192k "%%~dpnF.mp3"
 )

pause

注意ffmpeg路徑需修改為你電腦安裝路徑！

第三步: 加到右鍵選單

鍵盤視窗鍵(在ctrl跟alt中間那顆)+ R, 輸入regedit命令

註冊檔路徑找到 HKEY_CLASSES_ROOT\*\shell 底下右鍵新增【機碼(K)】「Convert to mp3」, 接著又再已新增的「Convert to mp3」
底下右鍵新增【機碼(K)】「Command」，在Command底下預設值修改成 C:\ffmpeg\convert2mp3.bat "%1"

這樣就完成了，相當的簡單！

第四步：測試轉換影音檔
可以打開檔案總管找任意影音檔案，點選後按右鍵看是不是有Convert to mp3選項，點擊後，即可讓ffmpeg執行轉換動作。

Good Job!

Pascal's triangle、巴斯卡三角形、楊輝三角形解法

2015-09-24T17:09:00.000-07:00

參考來源: 楊輝三角形 wiki
楊輝三角形，又稱賈憲三角形、帕斯卡三角形、海亞姆三角形，是二項式係數在的一種寫法，形似三角形，在中國首現於南宋楊輝的《詳解九章算術》得名，書中楊輝說明是引自賈憲的《釋鎖算術》，故又名賈憲三角形。

由圖我們可很明顯的找出規律性:
一、每列都比前列多一個數
二、每數都是前列的二數和
三、頭、尾項都為1
四、由網路資料可得知這樣的規律性剛好是 (a+b)ⁿ
二元一次表達式的展開系數表

(a+b)^⁰=	1	1
(a+b)^¹ =	a+b	1 1
(a+b)^² =	a^²+2ab+b^²	1 2 1
(a+b)^³ =	a^³+3a^²b+3ab^²+b^³	1 3 3 1
(a+b)^⁴ =	a^⁴+4a^³b+6a^²b^²+4ab^³+b^⁴	1 4 6 4 1
(a+b)^⁵ =	a^⁵+5a^⁴b+10a^³b^²+10a^²b^³+5ab^⁴+b^⁵	1 5 10 10 5 1
(a+b)^⁶ =	a^⁶+6a^⁵b+15a^⁴b^²+20a^³b^³+15a^²b^⁴+6ab^⁵+b^⁶	1 6 15 20 15 6 1

再參考了這篇資料: 巴斯卡三角形的幾個性質
看完後，只能說搞數學的不簡單能找出這麼多東西出來，也提供了公式，
但公式的東西實在很難看懂，有時覺得很簡單的原理，看了論文的公式，
反而覺得好複雜。

但瞭解越多資訊，越有助解題。
下列代碼，利用了第c[0]項跟最後一項c[-1]都為1，第c[1]項開始剛好等於前列r-1的c[n]+c[n-1]的和
# python

def pascalTriangle(n):
    if n <= 0:
        return 
    else:
        row = [1]
        for i in range(10):
            print row 
            p = row[:]                     # p 代表前一列
            for j in range(1, len(row)):        
                row[j] = p[j] + p[j-1]
            row.append(1)

if __name__ == "__main__":
    pascalTriangle(10)

列印結果如下:

========================

[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
[1, 5, 10, 10, 5, 1]
[1, 6, 15, 20, 15, 6, 1]
[1, 7, 21, 35, 35, 21, 7, 1]
[1, 8, 28, 56, 70, 56, 28, 8, 1]
[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]

沒處理空白問題，這樣代碼較方便理解

另外從網路看另一種利用zip的解法

def pascal(n):
   """Prints out n rows of Pascal's triangle.
   It returns False for failure and True for success."""
   row = [1]
   k = [0]
   for x in range(max(n,0)):
      print row
      row=[l+r for l,r in zip(row+k,k+row)]
   return n>=1

第二列開始
row = [1, 1]
zip(row+[0], [0]+row) -> [(1, 0), (1, 1), (0, 1)]
[(1, 0), (1, 1), (0, 1)] 每項tuple再相加 -> [1, 2, 1]

第三列開始 row = [1, 2, 1]
zip(row+[0], [0]+row) -> [(1, 0), (2, 1), (1, 2), (0, 1)]
[(1, 0), (2, 1), (1, 2), (0, 1)] 一樣相加 -> [1, 3, 3, 1]

最後為練習kotlin 我再將代碼，轉換為kotlin的寫法

// kotlin code

fun pascalTriangle(n: Int) {
    var row = listOf(1)
    var k = listOf(0)
    if (n <= 0) {
        return 
    }
    for (i in 1..n) {
        row.forEach {print("${it.toString().format(5)} ")}
        println()
        row = (row+k).zip(k+row) map {it -> it.first + it.second}
    }
}

fun main(args: Array<String>) {
    pascalTriangle(10)
}

河內塔(漢諾塔)算法解析 The tower of hanoi algorithm analysis

2014-09-10T17:53:00.000-07:00

起源(Origin):
最早發明這個問題的人是法國數學家愛德華·盧卡斯。
傳說印度某間寺院有三根柱子，上串64個金盤。寺院裡的僧侶依照一個古老的預言，以上述規則移動這些盤子；預言說當這些盤子移動完畢，世界就會滅亡。這個傳說叫做梵天寺之塔問題(Tower of Brahma puzzle)。但不知道是盧卡斯自創的這個傳說，還是他受他人啟發。
若傳說屬實，僧侶們需要2⁶⁴ − 1步才能完成這個任務；若他們每秒可完成一個盤子的移動，就需要5849億年才能完成。整個宇宙現在也不過137億年。
這個傳說有若干變體：寺院換成修道院、僧侶換成修士等等。寺院的地點眾說紛紜，其中一說是位於越南的河內，所以被命名為「河內塔」。另外亦有「金盤是創世時所造」、「僧侶們每天移動一盤」之類的背景設定。
佛教中確實有「浮屠」（塔）這種建築；有些浮屠亦遵守上述規則而建。「河內塔」一名可能是由中南半島在殖民時期傳入歐洲的。

來源網址: http://zh.wikipedia.org/wiki/%E6%B1%89%E8%AF%BA%E5%A1%94

這個遊戲有三個柱子，暫以 A B C 代替

目的，要把 A柱上的多個盤子由A 移動到 C 柱
當一個盤子時， A -> C
當二個盤子時， A -> B, A -> C, B -> C

解法重點，只要超過二個盤子，都可以想像只有二個盤子
也就是 n 跟 n-1 個盤子(最低部的盤子跟除了最底部以外的盤子)

最底部以外的盤子 n - 1
最低部的盤子為 n

所以只有三個步驟不斷重複

A -> B
A -> C
B -> C

第一步將 n-1個盤子 A移動到B
第二步將最底部盤子n A移動到B
第三步將 n-1個盤子 B移動到C

有圖說明觀念才會清楚些

# Python 版本

def hanoi(n, A="A", B="B", C="C"):
    if n > 0:
        hanoi(n-1, A, C, B)
        print "Move a Disc from %s to %s" % (A, C)
        hanoi(n-1, B, A, C)

if __name__ == '__main__':
    hanoi(input('How many disks you wanna play? '))

// F# 版本

let rec hanoi(n: int, A: string, B: string, C: string) =
    if n > 0 then
        hanoi(n-1, A, C, B)
        printfn "Move a Disc from %s to %s" A C
        hanoi(n-1, B, A, C)

hanoi(3, "A", "B", "C")

go語言教學2 條件式If else...switch

2014-07-02T19:53:00.000-07:00

func main() {
 for i := 0; i < 20; i++ {
  if i%2 == 0 {
   fmt.Println("even:", i)
  } else {
   fmt.Println("odd:", i)
  }
 }
}

 if i%2 == 0

golang if 條件式省略了() 無需括號即可做條件判斷

多重條件式

func main() {
 scores := []int{30, 50, 60, 80, 70, 90}
 for i := 0; i < len(scores); i++ {
  s := scores[i]
  if s/20 == 5 {
   fmt.Printf("score: %d is S\n", s)
  } else if s/20 == 4 {
   fmt.Printf("score: %d is A\n", s)
  } else if s/20 == 3 {
   fmt.Printf("score: %d is B\n", s)
  } else if s/20 == 2 {
   fmt.Printf("score: %d is C\n", s)
  } else {
   fmt.Printf("score: %d is D\n", s)
  }
 }
}

對於多個條件情況下，可以在else後，再添加一個 if...else

或者改使用switch條件判斷

func main() {
 scores := []int{30, 50, 60, 80, 70, 90}
 for i := 0; i < len(scores); i++ {
  s := scores[i]
  switch level := s / 20; level {
  case 5:
   fmt.Printf("score: %d is S\n", s)
  case 4:
   fmt.Printf("score: %d is A\n", s)
  case 3:
   fmt.Printf("score: %d is B\n", s)
  case 2:
   fmt.Printf("score: %d is C\n", s)
  default:
   fmt.Printf("score: %d is D\n", s)
  }
 }
}

case 後允許有多個條件

case 5, 3, 2:

如所有條件分不符合，則執行default:後的語句。

go語言教學1 基礎

2014-07-02T11:08:00.000-07:00

go 語言被譽為這個世代的C語言，其精神也繼承了c語言的優點，少即多，沒有太多花俏的特性，所用到的關鍵字只有二十五個，跟c語言31個、c++89個比較，顯得相當精簡。並行機制也使得go語言，編寫多線程及網路編程都相當容易！
go語言主要為系統及網路編程而設計，一些設計要求較為嚴格。導入的模組及聲明的變數，未使用無法通過編譯，go精簡的特性，也導致少了一些新穎好用的特性，如函數式語言的列表推導。
>>> [ x for x in range(20) if x % 2]
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
基本語法

go保留了c語言風格，為讓早已熟悉c style的人，減少學習成本，因此語言跟c很相像

package main

import (
 "fmt"
)

func main() {
 fmt.Println("Hello World!")
}

函數聲明關鍵字func 跟c 一樣需有main()函數做為程式進入點。

main() 表示程式一被執行時，就會被執行的位置

採用了大括號{} 做為程式縮排判定

正確

func main() {
 fmt.Println("Hello World!")
}

錯誤

func main()

 fmt.Println("Hello World!")
}

golang 編譯時會統一格式輸出

編輯器存檔時，也會調用golang的format，做語法編排修正

因此在golang上難以看到五花八門的寫法

程式語言，只要有地方略有不同，就可能引起爭論，例著名的大括號戰爭或

以空白代替大括號…等。任何一種都有不同人馬爭論著。

go的做法減少了一些爭論點。

go聲明變數的方式為：

var i int     // 初始化

var i int = 1 // 初始化並給予初始值

i := 1 // 新的聲明方式，go 能自行推導出變數類型

s := "hi" // string

go 數字類型聲明為

int8 int16 int32 int64 和 uint8 uin16 uin32 uint64 等

改善了c語言長久已來的聲明方式

short
int
long
long long
不同位元機器，所代的位元數將有所不同

假如long 為32位元整數 long long 為64 位元，那麼127位元呢？

所以go 的聲明方式 int32 int64 int128 會較為明確

簡單加總例子

func main() {
 sum := 0
 for i := 0; i < 10; i++ {
  sum += i
 }
 fmt.Printf("0 + 2 + 3...9 = %d", sum)
}

輸出：

1 + 2 + 3...10 = 45

for 條件式 {

    // do something

如省略條件式，則變成while一樣的功能

for {

   // 無窮迴圈

因此go 沒while 和 do...while 一切由for 包辨

有許多語言for 可用來迭代陣列裡的物件

例:

#python

arr = [1, 2, 3]

for i in arr:

    print i

或者像c#, php裡的foreach語法

golang裡則是使用

for i, v := range arr {

    //do something

range arr 會返回二個值 index, value

// example

func main() {
 s := "I am golang!"
 arr := []byte(s)

 fmt.Println(arr)
 for i, v := range arr {
  fmt.Println(i, string(v))
 }
}

[]byte(s) 將字串轉為byte slice

arr 內容

[73 32 97 109 32 103 111 108 97 110 103 33]

所有字元被變成 byte 數字

要顯示為原來英文字，需做轉換

for i, v := range arr {

    fmt.Println(i, string(v))
}

range arr 返回值給 i, v 如想省略不用可以使用 _ 符號

_, v 或 i, _

另外需注意的是

var i int

var j int32

同為32位元整數，但是二者之間是無法做運算的，仍需做同類型轉換

func main() {
 var i int = 100
 var j int32 = 100
 fmt.Println(i + j)
}

編譯警告：

invalid operation: i + j (mismatched types int and int32)

go也不支持隱式轉換，只能顯示轉換完，再做運算

var i int8 = 10

var j int32 = 100

fmt.Println(i + j)

invalid operation: i + j (mismatched types int8 and int32)

fmt.Println(int32(i) + j)

it's ok.

Python & Java 數字金字塔解法

2014-01-16T15:42:00.004-08:00

問題:讓電腦列印數字金字塔
          1
       1 2 1
      1 2 4 2 1
    1 2 4 8 4 2 1
1 2 4 8 16 8 4 2 1

Java解法:
我以位移運算解決
1 2 4 8 16 8 4 2 1
問題

int k = 5;

for (int i = 0; i < k; i++) {
 System.out.print((1 << i) + " ");
}

會打印 1 2 4 8 16

for (int j = 0; j < k+1; j++) {
 System.out.print(((1 << k) >> j) + " ");
}

再接著打印 8 4 2 1

int num = 5;
for (int k = 0; k < num; k++) {
 //printSpace(num-k);
 for (int i = 0; i < k; i++) {
  System.out.print((1 << i) + " ");
 }
 for (int j = 0; j < k+1; j++) {
  System.out.print(((1 << k) >> j) + " ");
 }
  System.out.print("\n");
 }
}

1
1 2 1
1 2 4 2 1
1 2 4 8 4 2 1
1 2 4 8 16 8 4 2 1

這樣子只有直角三角形，只要在打印每行前先打印二格空白" "
就能呈現金字塔了
完整代碼如下

public class Pyramid {
 public static void main(String[] args) {
 int num = 5;
 for (int k = 0; k < num; k++) {
  printSpace(num-k);
  for (int i = 0; i < k; i++) {
   System.out.print((1 << i) + " ");
  }
  for (int j = 0; j < k+1; j++) {
   System.out.print(((1 << k) >> j) + " ");
  }
   System.out.print("\n");
  }
 }
 
 public static void printSpace(int num) {
  for (int s = 0; s < num; s++) {
   System.out.print("  ");
  }
 }
}

因為是先用python做測試，隨便附上python版

def pyramid(num):
    for i in range(num):
        print '\0\0'*(num-i),
        for j in range(i):
            print 1<> k,
        print

PyQt4 教學3 Regexp 測試器

2013-12-30T00:38:00.002-08:00

 
Step 1.
先建立基本 視窗 
# -*- coding: UTF8 -*-
import os, sys, re
from PyQt4.QtGui import *
from PyQt4.QtCore import *

class RegexTest(QWidget):
    def __init__(self, parent=None):
        super(self.__class__, self).__init__(parent)
        self.setWindowTitle("RegexExpress Test")

        #self.setupUI()
 
if __name__ == "__main__":
    app = QApplication(sys.argv)
    main = RegexTest()
    main.show()
    sys.exit(app.exec_())
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Step 2.
我們只需要簡單 添加 三個元件
QTextEdit * 2
QLineEdit * 1
QHBoxLayout *1
class RegexTest 添加函數 setupUI
 
 
   def setupUI(self):
        layout = QHBoxLayout()
        rightLayout = QVBoxLayout()

        self.inputTextEdit = QTextEdit()
        self.outputTextEdit = QTextEdit()
        self.lineEdit = QLineEdit("Type an expression and press Enter")

        rightLayout.addWidget(self.inputTextEdit)
        rightLayout.addWidget(self.outputTextEdit)
        rightLayout.addWidget(self.lineEdit)

        layout.addLayout(rightLayout)

        self.setLayout(layout)

 
 

 
 
 這樣程式的基本雛形，就已經有了
再來我們可以寫個函數，取得self.inputTextEdit的文字，來做正則語法匹配


   def setupUI(self):
        .
        .
        self.lineEdit.returnPressed.connect(self.update)

    def update(self):
        self.outputTextEdit.clear()
        try:
            text = str(self.inputTextEdit.toPlainText())
            rule = unicode(self.lineEdit.text())
            result = re.findall(rule, text)
            self.outputTextEdit.append("%s" % result)

        except Exception, e:
            self.outputTextEdit.append(
                "%s is invalid!" % unicode(
                                                self.lineEdit.text()))
            self.outputTextEdit.append(unicode(e))

if __name__ == "__main__":
    app = QApplication(sys.argv)
    main = RegexTest()
    main.show()
    testText = """
    Beautiful is better than ugly.
    translate by noname.tam@gmail.com
    16 minutes  37.57.166.156
    22 minutes  201.211.193.192
    """
    main.inputTextEdit.setText(testText)
    sys.exit(app.exec_())

 
 



 
 
 Step:
基本功能有了後，剩再做一些美化、加強功能的事情
標籤: 
styleString = "%s"
inputLabel = QLabel(styleString % "Input Text:")
rightLayout.addWidget(inputLabel)
 
控制元件
controlLayout = QHBoxLayout()
self.addBtn = QPushButton("Add")
self.removeBtn = QPushButton("Remove")
optionLabel = QLabel("Option:")
self.option = QComboBox()
self.option.addItem("findall")
self.option.addItem("match")
controlLayout.addWidget(self.addBtn)
controlLayout.addWidget(self.removeBtn)
controlLayout.addWidget(optionLabel)
controlLayout.addWidget(self.option)
controlLayout.addStretch()


基本上都還很陽春，其它功能，留待後面有時間再做補充…
 
現在完整代碼如下: 


# -*- coding: UTF8 -*-
import os, sys, re
from PyQt4.QtGui import *
from PyQt4.QtCore import *

class RegexTest(QWidget):
    def __init__(self, parent=None):
        super(self.__class__, self).__init__(parent)
        self.setWindowTitle("RegexExpress Test")

        self.setupUI()

    def setupUI(self):
        styleString = "%s"
        layout = QHBoxLayout()
        rightLayout = QVBoxLayout()
        inputLabel = QLabel(styleString % "Input Text:")
        self.inputTextEdit = QTextEdit()
        outputLabel = QLabel(styleString % "Result:")
        self.outputTextEdit = QTextEdit()
        self.lineEdit = QLineEdit("Type an expression and press Enter")
        self.lineEdit.selectAll()

        controlLayout = QHBoxLayout()
        self.addBtn = QPushButton("Add")
        self.removeBtn = QPushButton("Remove")
        optionLabel = QLabel("Option:")
        self.option = QComboBox()
        self.option.addItem("findall")
        self.option.addItem("match")
        controlLayout.addWidget(self.addBtn)
        controlLayout.addWidget(self.removeBtn)
        controlLayout.addWidget(optionLabel)
        controlLayout.addWidget(self.option)
        controlLayout.addStretch()

        rightLayout.addWidget(inputLabel)
        rightLayout.addWidget(self.inputTextEdit)
        rightLayout.addWidget(outputLabel)
        rightLayout.addWidget(self.outputTextEdit)
        rightLayout.addLayout(controlLayout)
        rightLayout.addWidget(self.lineEdit)
        layout.addLayout(rightLayout)
        self.setLayout(layout)
        self.lineEdit.setFocus()
        self.lineEdit.returnPressed.connect(self.update)

    def update(self):
        print 'test'
        self.outputTextEdit.clear()
        try:
            text = self.inputTextEdit.toPlainText()
            rule = unicode(self.lineEdit.text())
            result = re.findall(rule, text)
            print "test", result
            self.outputTextEdit.append(str(result))
        except Exception, e:
            self.outputTextEdit.append(
                "%s is invalid!" % unicode(
                                                self.lineEdit.text()))
            self.outputTextEdit.append(unicode(e))


if __name__ == "__main__":
    app = QApplication(sys.argv)
    main = RegexTest()
    main.show()
    testText = """
    Beautiful is better than ugly.
    translate by noname.tam@gmail.com
    16 minutes  37.57.166.156
    22 minutes  201.211.193.192
    """
    main.inputTextEdit.setText(testText)
    sys.exit(app.exec_())

python 小技巧 try except 捕捉錯誤時，列印錯誤行數

2013-12-27T22:47:00.000-08:00

import sys

sys.exc_info() 返回一個tuple，能取得 (type, value, traceback)
 
例:
>>> sys.exc_info()
(, Empty(), ) 
 
我取出 traceback 出來用 
traceback = sys.exc_info()[2]

而 traceback.tb_lineno 能列印錯誤行數
 
所以我將程式改寫並包裝成一個函數來使用

traceback(err) 顯示錯誤的時間、錯誤訊息，錯誤的所在行數

import sys, time

def traceback(err):
    now = time.strftime('%H:%M:%S', time.localtime(time.time()))
    traceback = sys.exc_info()[2]
    print now, err, 'exception in line', traceback.tb_lineno

PyQt4 教學3 QThread 多線程

2013-12-02T12:42:00.001-08:00

多線程python 已有 threading, pyqt 又有 QThread, 一開始都容易有疑問，二者有何不同？應該那一個比較對，我是覺得二者皆可用，網上曾看過有人說，應儘量用 python 本身的 threading, QThread 是原本針對 C++而寫。

任務量較少的情況，我會直接用 threading, 任務量大且需向其它gui 物件傳遞訊息的情況，我會用QThread

這篇是寫PyQt，所以這邊我也只寫 QThread部份

會想使用QThread，我所遇到的情況，是向網頁，抓取資料，又遇網路過慢，延遲過久造成Gui介面等待過久，介面會卡卡、頓頓的。

首先先寫介面，然後點擊 startBtn 可以測試無線程情況下，圖形介面是不是卡卡的

# -*- coding: UTF8 -*-
import sys
import urllib2
from PyQt4.QtGui import *
from PyQt4.QtCore import *

class Window(QWidget):
    def __init__(self, parent=None):
        super(self.__class__, self).__init__(parent)
        layout = QVBoxLayout()
        hbox = QHBoxLayout()
                                   
        self.edit = QTextEdit()
        self.startBtn = QPushButton("Start")
        self.stopBtn = QPushButton("Stop")
        
        hbox.addStretch()
        hbox.addWidget(self.startBtn)
        hbox.addWidget(self.stopBtn)
        
        layout.addWidget(self.edit)
        layout.addLayout(hbox)
        
        self.setLayout(layout)
    
        # SIGNAL&SLOT
        self.startBtn.clicked.connect(self.test)
                
    def test(self):
        url = 'http://blog.sina.com.cn/'
        html = urllib2.urlopen(url).read()
        length = len(html)
        self.edit.append("Url:%s Content:%s" % (url, length))

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = Window()
    window.show()
    sys.exit(app.exec_())

 
加入線程
 class Worker(QThread):    
    def __init__(self, parent=None):
        super(self.__class__, self).__init__(parent)
        self.url = 'http://blog.sina.com.cn/'
        
    def run(self):
        html = br.urlopen(self.url).read()
        length = len(html)
        self.emit(SIGNAL("length"), self.url, str(length))
        print 'success'
 self.emit(SIGNAL("length"), self.url, str(length))
當線程完成任務時，我們請線程發送訊號"length"，並傳遞url及所抓取網頁的資料大小


 



 主程式添加
 class Window(QWidget):
    def __init__(self, parent=None):
        super(self.__class__, self).__init__(parent)
               .
               .
               . 


        self.work = Worker()
        # SIGNAL&SLOT
        self.startBtn.clicked.connect(self.start)
        self.connect(self.work, SIGNAL("length"), 
                     self.updateUI)
        
    def start(self):
        self.work.start()
    
    def updateUI(self, url, length):
        self.edit.append("Url:%s Content:%s" % (url, length))
 
 
self.connect(self.work, SIGNAL("length"), 
                     self.updateUI)
主程式這邊接收剛線程傳遞出來的資料"length" 


現在我們多添加一點任務給線程
 
import lxml.html as H


 線程改寫成
 
class Worker(QThread):    
    def __init__(self, parent=None):
        super(self.__class__, self).__init__(parent)
        self.url = 'http://blog.sina.com.cn/'
        
    def run(self):
        self.url = 'http://blog.sina.com.cn/'
        html = urllib2.urlopen(self.url).read()
        doc = H.document_fromstring(html)
        urlList = doc.xpath('//a/@href')
        for i in range(10):
            url = urlList[i]
            html = urllib2.urlopen(url).read()
            length = len(html)
            self.emit(SIGNAL("length"), url, str(length))
        print 'success'

doc = H.document_fromstring(html)
urlList = doc.xpath('//a/@href')
這邊我們用 lxml.html  xpath語法 取得了，所有文章連結
讓線程去跑十篇文章。


在跑文章時候，我們希望避免重複按下startBtn
應修改 
   def start(self):
        self.work.start()
        self.startBtn.setEnabled(False)

在任務一執行時，先關閉

self.startBtn
 
任務完成時，再開啟 self.startBtn
主程式添加以下代碼
        self.connect(self.work, SIGNAL("finished()"), 
                     self.finished)
        
    def finished(self):
        self.startBtn.setEnabled(True)
 
 


 
 
 那如果我們希望執行當中，停止任務呢？
 QMutex() 上鎖吧！
 
最後整個程式代碼如下: 
 
 # -*- coding: UTF8 -*-
import sys
import lxml.html as H
import urllib2
from PyQt4.QtGui import *
from PyQt4.QtCore import *

class Window(QWidget):
    def __init__(self, parent=None):
        super(self.__class__, self).__init__(parent)
        layout = QVBoxLayout()
        hbox = QHBoxLayout()
                                   
        self.edit = QTextEdit()
        self.startBtn = QPushButton("Start")
        self.stopBtn = QPushButton("Stop")
        
        hbox.addStretch()
        hbox.addWidget(self.startBtn)
        hbox.addWidget(self.stopBtn)
        
        layout.addWidget(self.edit)
        layout.addLayout(hbox)
        
        self.setLayout(layout)
        #
        self.work = Worker()
        # SIGNAL&SLOT
        self.startBtn.clicked.connect(self.start)
        self.stopBtn.clicked.connect(self.stop)
        self.connect(self.work, SIGNAL("length"), 
                     self.updateUI)
        self.connect(self.work, SIGNAL("finished()"), 
                     self.finished)
        
    def start(self):
        self.work.start()
        self.startBtn.setEnabled(False)
        
    def updateUI(self, url, length):
        self.edit.append("Url:%s Content:%s" % (url, length))

    def finished(self):
        self.startBtn.setEnabled(True)
    
    def stop(self):
        self.work.stop()
        self.startBtn.setEnabled(True)

class Worker(QThread):    
    def __init__(self, parent=None):
        super(self.__class__, self).__init__(parent)
        self.stoped = False
        self.mutex = QMutex()
    
    def run(self):
        with QMutexLocker(self.mutex):
            self.stoped = False
        self.url = 'http://blog.sina.com.cn/'
        html = urllib2.urlopen(self.url).read()
        doc = H.document_fromstring(html)
        urlList = doc.xpath('//a/@href')
        for i in range(10):
            url = urlList[i]
            if self.stoped:
                return 
            html = urllib2.urlopen(url).read()
            length = len(html)
            self.emit(SIGNAL("length"), url, str(length))
        print 'success'
    
    def stop(self):
        with QMutexLocker(self.mutex):
            self.stoped = True
    
    def isStop(self):
        with QMutexLocker(self.mutex):
            return self.stoped

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = Window()
    window.show()
    sys.exit(app.exec_())

PyQt4 教學2

2013-09-22T20:10:00.002-07:00

時常安裝軟體完後，需要設定環境變數 Path，而window的設定環境感覺很麻煩，好像沒快捷鍵或指令直接呼叫，得『電腦』→右鍵『內容』→『進階電腦系統設定』→『環境變數』，才能進行設定。

所以想寫個圖形介面，來做快速設定。

第一步: 先設計介面

這是原先 window sample

所以可以很簡單的就寫出

# -*- coding: UTF8 -*-
import os, sys, win32api, win32con, _winreg
from PyQt4.QtCore import *
from PyQt4.QtGui import *

class EditEnvironmentDlg(QDialog):
    def __init__(self, parent=None):
        super(self.__class__, self).__init__(parent)
        title =  u"編輯系統變數" 
        self.setWindowTitle(title)
        nameLabel = QLabel(u"變數名稱:")
        self.nameEdit = QLineEdit()
        valueLabel = QLabel(u"變數值:") 
        valueLabel.setAlignment(Qt.AlignRight)
        buttonBox = QDialogButtonBox(QDialogButtonBox.Ok|
                                     QDialogButtonBox.Cancel)
        grid = QGridLayout()
        grid.addWidget(nameLabel, 0, 0) 
        grid.addWidget(self.nameEdit, 0, 1) 
        grid.addWidget(valueLabel, 1, 0) 
        self.valueEdit = QLineEdit()
            
        grid.addWidget(self.valueEdit, 1, 1) 
        grid.addWidget(buttonBox, 2, 1)
        self.setLayout(grid)
        
if __name__ == "__main__":
    import sys 
    app = QApplication(sys.argv)
    dialog = EditEnvironmentDlg()
    dialog.show()
    sys.exit(app.exec_())

為了讓各個物件能整齊排列，我們用到了 QGridLayout 網狀佈局
沒用這個就得一一為各個物件設定座標，這樣是很麻煩的一件事
所以有了 grid 就變得很方便又美觀！

nameLabel(0, 0)	self.nameEdit(0, 1)
valueLabel(1, 0)	self.valueEdit(1, 1)
	buttonBox(2, 1)

第二步取出環境變數:

import os, sys, win32api, win32con, _winreg

python 有 _winreg 可以很方便幫我們操作 註冊表的查詢、修改

但我在修改時遇到 [WINDOWS Error 5] 無法存取

權限被擋了，所以不得以改用 win32api, win32con 來做操作

_winreg 語法是比較簡單，但要修改的位置有權限問題，只好

先暫時用 win32api, win32con

首先我們可以用 python IDLE 先試試是不是能查詢到我們要的

這樣就查詢到我們要到，接著我們就是把資料送到我們的程式輸入物件中

    def getEnvironmentVariable(self):
        key = win32con.HKEY_LOCAL_MACHINE
        subkey = r"SYSTEM\CurrentControlSet\Control\Session Manager\Environment"
        regKey = win32api.RegOpenKey(key, subkey)
        value, datatype = win32api.RegQueryValueEx(regKey, "Path")
        self.nameEdit.setText("Path")
        self.valueEdit.setText(value)

函數 __init__ 最後添加一行

self.getEnvironmentVariable()

path裡的值通常是很長，這樣做修改對我們來講不是很方便，可以
調整一下程式讓修改值，變方便點。

原本的 self.valueEdit = QLineEdit() 換成:

self.valueEdit = QTextEdit()

並且把self.valueEdit 調大一點

self.valueEdit.setMinimumSize(320, 200)

這樣雖然方便點，但文字排版還是有亂！我們再處理一下，讓它整齊點

for line in (value.split(';')):

    if line: self.valueEdit.append(line + ';')

這樣就整齊多了，可以一目瞭然知道我們有什麼path設定

那麼最後一步就是修改了存檔了

QLineEdit 要取得輸入框的值是用
lineEdit.text()

而 QTextEdit 的話是用 textEdit.toPlainText()

value = str(self.valueEdit.toPlainText())

#去除 QTexEdit產生的換行符 '\n'
value = value.replace('\n', '')

所以程式碼如下:

    def setEnvironmentVariable(self):
        key = win32con.HKEY_LOCAL_MACHINE
        subkey = r"SYSTEM\CurrentControlSet\Control\Session Manager\Environment"
        value = str(self.valueEdit.toPlainText())
        value = value.replace('\n', '')
        try:
            regKey = win32api.RegOpenKeyEx(key, subkey,
                                            0 ,win32con.KEY_WRITE)
            win32api.RegSetValueEx(
                    regKey, "Path", 0, 
                    win32con.REG_EXPAND_SZ, value)
        except NameError, e:
            print e
        except Exception, e:
            print e
        finally:
            win32api.RegCloseKey(regKey)

要讓程式按下『確認』鍵能產生動作，我們得設定一下

PyQt 的 SINGAL & SLOT 訊號與插槽

其動作原理即 我們按下『OK』送出一個訊號 SIGNAL("accepted()")

然後這個訊號要到那邊有什麼動作呢？

我們希望程式幫我們修改 註冊表

所以我們在程式的__init__ 初始化函數增添下面二行:

self.connect(buttonBox, SIGNAL("accepted()"),
                     self.setEnvironmentVariable)

按下『Cancel』則不做修改退出

self.connect(buttonBox, SIGNAL("rejected()"),
                     self, SLOT("reject()"))

這樣整個程式就算大功告成！！

如要再進階點，做整個環境變數修改也可以

不過程式會變得較複雜，會使我解釋老半天，也沒幾個人有耐心看完！
有興趣的可以自已做研究，自已嘗試學較多進步較多！

文章還是以儘量簡單為主！

Easy To Be Happy!

【轉載】其實Unix很簡單

2013-04-05T16:08:00.002-07:00

陳皓

很多編程的朋友都在網上問我這樣的幾個問題，Unix怎麼學？Unix怎麼這麼難？如何才能學好？並且讓我給他們一些學好Unix的經驗。在絕大多數時候，我發現問這些問題的朋友都有兩個特點：

1）對Unix有畏難心理，對其沒有信心；

2）喜歡用拿Windows來和Unix做比較。

這兩種特點就像兩個“心理暗示”，暗示著自己Unix很不好學，暗示著Unix很糟糕，不如Windows好。於是，自己也就被自己的這種長期的“暗示”所催眠了。因為，從一開始就有畏難情緒，所以也就覺得Unix不好，覺得非常很吃力，最後還會導致對Unix的厭惡和反感的情緒。所以，為了糾正上述朋友們的“心理暗示”。我想寫下這篇文章，想告訴大家，Unix真的很簡單。

在正式敘述“簡單的Unix”之前，我想做幾點說明：（以免陷入無意義的爭論）

1）本文是站在開發者的角度來說明的，所以，如果有朋友不同意我的觀點，請也以開發者的角度來向我提出質問和討論，本人非常歡迎。

2）本文難免要用Windows來和Unix做對比。這並不代表我不喜歡Windows，也不代表我要叫你放棄Windows。我們也知道這種對比已經沒有什麼意思了，但因為眾多的朋友被Windows先入為主了，所以，我一定要拿Windows來開刀，才能扭轉那個“心理暗示”。僅此而已。

       OK，言歸正傳。先說Unix的一個最重要的特點——“高內聚，低藕合”！也就是說，Unix下的各種應用程序都和別人不相干。這就是貫穿整個Unix的思維——模塊和程序的高度獨立性。這樣的設計和做法，會讓你的系統比較的穩定，也會讓你的系統特別地容易管理和維護。Unix下的應用程序們就像一支正規軍一樣排列地整整齊齊，只要司令（內核）還在，系統是不會因為某個軍隊的損失而無法自舉的。而Windows的應用程序們就像一片樹林一樣，從地表上看過去，樹木們排列地整整齊齊，但是他們的樹根在地下卻相互纏繞在一起，剪不斷，理還亂，異常地復雜。

       “高內聚，低藕合”的給Unix造成的結果是，其系統中基本上都是功能單一的小程序，這些小程序就像積木一樣，當我們需要構造建一個自定義的建築時，大多數情況下，我們只需要做的只是一個“搭積木”的簡單游戲。Windows建設得富麗堂皇，可惜，別人的“積木”你幾乎不可能拿到自己的建築中來。總是要你模仿或重寫。

（插一句：你是否注意到在網上下載Windows的軟件時，會有一種所謂的“綠色軟件”？這就是對Windows的最大諷刺，Windows下裝一個軟件，N個DLL放到Windows系統目錄下，注冊表裡寫入N個鍵值，還有很多你不知道的動作。而在Unix裝軟件，你不用擔心你的系統目錄下會莫明其妙地多出些亂七八糟的文件。就是copy那麼簡單，那怕是rpm自動安裝，安裝完後，你也能夠查詢到軟件安裝後對系統所做的改變。所以，你在Unix下分發你的軟件時，你會覺得比Windows下要做得簡單了許多許多。）

       再說說Unix的另一個最重要的特點——“所有的設備都可以像文件一樣地操作”。簡單吧。所有的調備，文件、打印機、顯示器、終端、網絡、軟盤、磁帶、USB、CDROM、等等的I/O操作，都以文件描述符的方式進行操作。兩個Unix下最重要的系統調用read/write就可以勝任所有設備的I/O了。Unix早就在/dev目錄下為你建好了這些文件。使用起來很簡單。

       也許很多人都覺得Unix的命令行太過復雜。一個命令有著若干的參數，異常地復雜。但之所以今天Unix下的應用程序還在以字符界面為主，這恰好體現了Unix的簡單的特征。這也是Unix的另一個特點——“命令的相互支持性”，命令們通過一個管道或是重定向，可以互相聯系在一起，再加以Shell腳本的支持，哪怕要實現一些復雜的功能（比如一個小型的文本數據庫），也是簡單之極。

       如果上面的論述依然不能讓你信服Unix很簡單，那麼，讓我們來用一些具體地實際的例子來看一下，Unix是如何簡單的。讓我們試著做下面的這樣一個假設：“如果我們在學習編程的時候一開始是學Unix，然後轉去做Windows”，那會是怎麼樣的一個情況？

1）我們在Unix下創建進程，使用fork調用。到了Windows下，我們查了MSDN，發現了一個叫CreateProcess的系統調用可以創建進程，但我們卻發現這個系統調用有10個參數。而Unix下的fork卻一個參數都沒有。這種情況下，你是否會有一種頭大的感覺？因為，在Unix下，你根本看不到會有10參數這樣復雜的系統調用API。

2）我們在Unix下操作文件權限很簡單，文件權限分三組（本人，同組，別人），每組都是可讀，可寫，可執行。兩個簡單的系統調用chmod/chown就搞定。到了Windows下，如果是NTFS，如果要以程序的方式設置文件權限，呵呵，你需要先了解什麼是：SID，什麼是DACL，什麼是SACL，什麼是ACE，還有十幾相關的系統API函數等著你。（參看我的《以程序操作NTFS文件權限》）你也許會覺得這麼復雜的安全策略是讓系統更安全的基礎，可以自從Windows出現的那一天以後，在安全方面的表現就沒有勝過Unix。這無疑讓人感到Windows做了一件吃力不討好的事。

（插一句：Unix下的用戶切換是相當簡易方便的。而Windows下的用戶切換會導致你需要退出當前用戶的前台程序。這導致了Windows下的用戶幾乎無一例外地都會選擇在超級用戶的權限下工作/上網，這完全是讓自己的機器在裸奔，所以，Windows下的病毒一旦在系統中運行就為所欲為了。而Unix下，很少用戶會以root身份操作本機，因為切換用戶非常方便。）

3）在Unix下，用戶有ID，用戶組有ID，進程/線程都有ID。ID很簡單易懂，就像我們的身份證一樣。到了Windows下，用戶標識叫Token，進程標識叫Handle（其實也就是一個DWORD的類型），我看到網上很多問題都在問Windows下的Handle的概念問題。我一直在想，為什麼微軟不取一個簡單易懂的術語？要取得那麼抽像，那麼讓人很迷惑。雖然這讓Windows看起很NB，但也會因此加大了學習復雜度。（Windows的開發學習復雜度要比Unix復雜多了，而且有太多的看似很高深的術語讓人一頭霧水）

4）讓我們再來看一下用戶管理和程序所有者方面的東西。在Unix下，需要你做的是配置NIS服務器和NFS服務器（以Autofs自動mount），簡潔，清楚。到了Windows下，與其相似的是一個叫Domain的東西（主域控制器），首先，為了加入域，你需要重啟電腦（Unix下只需要配置/etc/nsswitch.conf文件來告訴本機的用戶登錄源，無需重啟），而對開發者來說，Unix的這個配置對程序是完全透明的。而Windows的域用戶和本地用戶需要一個域名來區分。在程序中切換用戶時，Unix只需要setuid/seteuid就行了，Windows對此有三個比較復雜的API：CreateProcessAsUser, ImpersonateLoggedOnUser, LogonUser，其復雜度就不用比較了。另外，在Domain方式下，你的Document and Setting目錄下的文件，會全部放到Domain服務器上去，你在別的機器上登錄時，需要下載這些文件。最後，我倒不擔心你和網友的MSN聊天記錄會因為你的登錄而到處都是，我擔心的是，你在這麼復雜的管理環境中寫出來的代碼是否能讓別人放心？:-(

5）在Unix下，要把自己的程序加入系統的啟動服務只需要在/etc/init.d中配置就行了。寫下一個有啟動停止功能腳本，以特殊命名的方式鏈接到不同啟動模式目錄下就行了。Windows下加一個啟動服務，如果你不編寫程序，估計比較困難。

6）在Unix下，如果要取得系統的信息。只需要到/proc目錄下去cat那堆文件。所有進/線程的狀態、命令行、內存/交換區使用情況、打開的文件描述符，等等，系統的CPU，內存，交換區，內存文件IO，分區，信息，網絡，系統運行狀態，系統設備，等等，要有多詳細就有多詳細，而且完全是純文本的，直接就可以看了。到了Windows下，要窮舉系統當前進程的信息，就不是一樣很容易的事，更別說要取得別的信息了。

我很佩服微軟把操作系統搞得那麼復雜，又是注冊表，又是安全策略，又是OLE，又是COM……。每次打開regedit.exe時，我根本不敢碰HKEY_CLASSES_ROOT，因為我看著裡面那些成千上萬個CLSID，我有點暈菜。

自1995年以來，10來年過去了。微軟推出了多種各式各樣的技術。我還記得Visual Studio 6.0中還有兩個叫做FoxPro和J++的東西，FoxPro來自Foxbase，還有個幾年，J++好像就沒有幾年。ActiveX Control完全是一個失敗的技術，而那個叫做VB的編程語言，今天看來，它的確毀了很多很有潛力的程序員。在COM出現的時候，不知道今天還有多少人還記得一個叫MTS的玩意？今天，不知道還有多少人記得有一個叫ODBC的東西？在這種復雜混亂的Windows世界中，是否讓你疲於追趕？今天的.NET不知道又有多少技術會隨著時間所沉澱？在Windows上面，我們學習了許多的失敗技術或是說是過渡技術。而我們的Unix自從上紀70年代以來，就沒有多大的變化，而因為Unix應運而生的C語言直到今天依然光彩奪目。我相信這個30多年來久經考驗還那麼簡單的Unix。

Unix就是這麼簡單，各位想在Unix下學開發的朋友，Windows那麼復雜的操作系統都過來了，你還會怕這麼簡單的Unix麼？

(轉載時請注明作者和出處。未經許可，請勿用於商業用途)

更多文章請訪問我的Blog: http://blog.csdn.net/haoel

Python 修改 IE Proxy 設定

2013-02-27T20:29:00.000-08:00

網路上怎麼找，都找到這種程式碼,但這些改法只是改『區域網路』的部份，並非我真正要的。

improt _winreg
key = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER,r"Software\Microsoft\Windows\CurrentVersion\Internet Settings",0,_winreg.KEY_ALL_ACCESS)
_winreg.SetValueEx(key,"ProxyEnable",0, _winreg.REG_DWORD, 1)
_winreg.SetValueEx(key,"ProxyServer",0, _winreg.REG_SZ, "proxy:port")

真的需要修改的位置應該位於
r"Software\Microsoft\Windows\CurrentVersion\Internet Settings\Connections"

再來得看adsl設定什麼名稱就修改那個檔案

但到這一步，就遇到了難題登錄檔的檔式為 REG_BINARY 二進位檔
不像修改區域網路的部份為 REG_SZ 可以直接設定實際 IP 數值
winreg.SetValueEx(key,"ProxyServer",0, winreg.REG_SZ, "proxy:port")

網路上也難以找到相關資料，或好用的修改方式、模組

只好認命一點，取出對應的值的替換掉

第一步，一樣先取所在位置的所有值:

key = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER,r"Software\Microsoft\Windows\CurrentVersion\Internet Settings\Connections",0, _winreg.KEY_ALL_ACCESS)

再來查詢 adsl 名稱，取出value

adsl = _winreg.QueryValueEx(key, 'adsl')
返回tuple 值

選第一個

a = adsl[0]

我們所需要修改的部份為第5個值跟第9個值，還有proxy ip 設定的第17個起，往後算20個位置

每個我們在 IE 裡設定，啟用proxy 或關閉proxy 第5個值都會自動加1
啟用proxy的話第9個值為3

瞭解原理後，要修改就不太難了

修改 REG_BINARY 二進位檔，我所能想到的方式就是轉 16進位來替換修改

所以導入 binascii 模組

import binascii

adsl_ascii = binascii.b2a_hex(a)

adsl_ascii 的內容，會是類似以下這樣:

'46000000010000000300000014000000
3231382e3138382e31332e3233373a383
838380000000000000000000000000000
000000000000000000000000000000000
000000000000000000000'

修改方式

adsl_ascii = adsl_ascii[:9] + '1' + adsl_ascii[10:17] + '3' + adsl_ascii[18:]

原本的第5跟第9，換算成16進位變第10跟第18的位置
替換後轉回二進位檔

adsl_binary = binascii.a2b_hex(adsl_ascii )

然後再修改註冊表
_winreg.SetValueEx(key, "adsl", 0, _winreg.REG_BINARY, adsl_binary)

這樣 proxy 就啟用了，如要關閉就是用:

adsl_ascii = adsl_ascii[:9] + '0' + adsl_ascii[10:17] + '1' + adsl_ascii[18:]
adsl_binary = binascii.a2b_hex(adsl_ascii )
_winreg.SetValueEx(key, "adsl", 0, _winreg.REG_BINARY, adsl_binary)

但因為proxy 的 ip 還未要設定所以，我們再添加修改ip的位置
# 啟用 Proxy
adsl_ascii = adsl_ascii[:9] + '1' + adsl_ascii[10:17] + '3' + adsl_ascii[18:]
# 設定 Proxy IP
adsl_ascii = adsl_ascii[32] + proxy_ip + i[72:]

但一般proxy IP 格式為 221.130.23.82:80
一樣得先轉成 16進位的格式再來做替換

所以簡單的寫個轉換函數

def proxy2hex(proxy):
        proxy_hex = ''
        for i in proxy:
            proxy_hex += (hex(ord(i)))[2:]
        proxy_hex += '0' * (40 - len(proxy_hex))
        return proxy_hex

proxy_ip = proxy2hex("221.130.23.82:80")
'3232312e3133302e32332e38323a383000000000'

adsl_ascii = adsl_ascii[32] + proxy_ip + i[72:]
adsl_binary = binascii.a2b_hex(adsl_ascii )
_winreg.SetValueEx(key, "adsl", 0, _winreg.REG_BINARY, adsl_binary)
這樣就能啟用IE的proxy跟設定ip位置

如不想關掉ie再重開讓設定生效

def refresh(self):
        import ctypes
        INTERNET_OPTION_REFRESH = 37
        INTERNET_OPTION_SETTINGS_CHANGED = 39
        internet_set_option = ctypes.windll.Wininet.InternetSetOptionW
        internet_set_option(0, INTERNET_OPTION_REFRESH, 0, 0)
        internet_set_option(0, INTERNET_OPTION_SETTINGS_CHANGED, 0, 0)

如有更好的修改方式，請告知一下，修改REG_BINARY格式蠻麻煩的！！

try: except: 錯誤處理列表

2013-01-05T13:31:00.000-08:00

BaseException
+-- SystemExit
+-- KeyboardInterrupt
+-- GeneratorExit
+-- Exception
      +-- StopIteration
      +-- ArithmeticError
      |    +-- FloatingPointError
      |    +-- OverflowError
      |    +-- ZeroDivisionError
      +-- AssertionError
      +-- AttributeError
      +-- BufferError
      +-- EnvironmentError
      |    +-- IOError
      |    +-- OSError
      |         +-- WindowsError (Windows)
      |         +-- VMSError (VMS)
      +-- EOFError
      +-- ImportError
      +-- LookupError
      |    +-- IndexError
      |    +-- KeyError
      +-- MemoryError
      +-- NameError
      |    +-- UnboundLocalError
      +-- ReferenceError
      +-- RuntimeError
      |    +-- NotImplementedError
      +-- SyntaxError
      |    +-- IndentationError
      |         +-- TabError
      +-- SystemError
      +-- TypeError
      +-- ValueError
      |    +-- UnicodeError
      |         +-- UnicodeDecodeError
      |         +-- UnicodeEncodeError
      |         +-- UnicodeTranslateError
      +-- Warning
           +-- DeprecationWarning
           +-- PendingDeprecationWarning
           +-- RuntimeWarning
           +-- SyntaxWarning
           +-- UserWarning
           +-- FutureWarning
           +-- ImportWarning
           +-- UnicodeWarning
           +-- BytesWarning

mechanize 模擬瀏覽器

2013-01-05T13:25:00.001-08:00

文章參考來源: http://stockrt.github.com/p/emulating-a-browser-in-python-with-mechanize/

import mechanize
import cookielib

# Browser
br = mechanize.Browser()

# Cookie Jar
cj = cookielib.LWPCookieJar()
br.set_cookiejar(cj)

# Browser options
br.set_handle_equiv(True)
#br.set_handle_gzip(True)
br.set_handle_redirect(True)
br.set_handle_referer(True)
br.set_handle_robots(False)

# Follows refresh 0 but not hangs on refresh > 0
br.set_handle_refresh(mechanize._http.HTTPRefreshProcessor(), max_time=1)

# Want debugging messages?
#br.set_debug_http(True)
#br.set_debug_redirects(True)
#br.set_debug_responses(True)

# User-Agent (this is cheating, ok?)
br.addheaders = [('User-agent', 'Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.0.1) Gecko/2008071615 Fedora/3.0.1-1.fc9 Firefox/3.0.1')]

將以上程式碼存成 browser.py , 丟到python27/lib 目錄裡

這樣一個簡單實用的陽春型模擬器就完成了。

我們每次要用時就可以很方便的呼叫出來用

>>> from browser import br

到無名逛逛

>>> html = br.open('http://www.wretch.cc/blog/').read()

>>> br.title()

'Blog - Wretch.cc'

這樣我們就已經到了無名

如果想登入的話，我們可以打開登入的網址

>>> html = br.open('https://login.yahoo.com/config/login?.intl=tw&.partner=&.last=&.src=wrtch&.scrumb=0&.pd=c=R.kjIs2p2e5IjYgxHnmFvubWqw--&pkg=&stepid=i&&.done=https%3a//login.yahoo.com/config/validate%3f.src=wrtch%26.pc=1164%26.scrumb=0%26.done=http%3a//www.wretch.cc/IDintegration/?ref=%25252Fblog%25252F').read()

>>> print br.title()
登入 - Yahoo!奇摩

登入的網址挺長的

>>> for f in br.forms():
 print f

會將網頁的form秀給我們看

>>> br.select_form(name="login_form")

得看網頁的form 設什麼名字，萬一沒有設，我們可以用

>>> br.select_form(nr=0) # 看是第幾個form，數字就輸入多少

如果還查找不到，那麼form可能是用javascript動態生成，在此就不介紹處理方法。

>>> br.form['login'] = '帳號'
>>> br.form['passwd'] = '密碼'
>>> br.submit() #請程式送出登入form

成功的話，我們就可以以登入帳號的狀態去瀏覽無名網站。

再配合

Beautiful Soup, re, XPath(lxml)

等查找網頁元素資料工具，想要什麼資料將是輕而易舉！

# 以XPath 簡單示範一下
import lxml.html as H

>>> html = br.open('http://www.wretch.cc/blog/XXXXXX').read()
>>> blog = H.document_fromstring(html)                                        #格式化網頁資料元素
>>> who = blog.xpath("//div[@id='whowrapper']/ul/li/a/@href")       #抓出誰來我家連結
>>> for w in who:
    print w


http://tw.rd.yahoo.com/referurl/wretch/blog/user/whocome/*http://www.wretch.cc/blog/as12345634
http://tw.rd.yahoo.com/referurl/wretch/blog/user/whocome/*http://www.wretch.cc/blog/xdxd0819
http://tw.rd.yahoo.com/referurl/wretch/blog/user/whocome/*http://www.wretch.cc/blog/s5725j5725
http://tw.rd.yahoo.com/referurl/wretch/blog/user/whocome/*http://www.wretch.cc/blog/baibai0914
http://tw.rd.yahoo.com/referurl/wretch/blog/user/whocome/*http://www.wretch.cc/blog/happy880328
http://tw.rd.yahoo.com/referurl/wretch/blog/user/whocome/*http://www.wretch.cc/blog/candy88622
http://tw.rd.yahoo.com/referurl/wretch/blog/user/whocome/*http://www.wretch.cc/blog/alice21622
http://tw.rd.yahoo.com/referurl/wretch/blog/user/whocome/*http://www.wretch.cc/blog/cul3977ssy
http://tw.rd.yahoo.com/referurl/wretch/blog/user/whocome/*http://www.wretch.cc/blog/weary898
>>>

這樣我們就知道誰來過了
Chrome 瀏覽器，可以查看網頁元素轉 xpath，很方便。

PyQt4 教學1

2012-12-11T09:22:00.000-08:00

我們先簡單的載入sys及pyqt4介面相關模組，然後寫個hello world標籤讓它顯示 
# -*- coding: UTF8 -*-
import sys
from PyQt4.QtGui import *
from PyQt4.QtCore import *

app = QApplication(sys.argv)

hello = QLabel('Hello World')
hello.show()

sys.exit(app.exec_()) 





pyqt4 習慣先載入一個程式主循環
app = QApplication(sys.argv)
 
如無這行，程式是不會有所反應的
所以這個小程式主要就是:
讓hello 等於 QLabel 然後讓程式顯示於視窗
hello = QLabel('Hello World')
hello.show()

簡單直覺
 
所以GUI介面我選擇了PyQt4
smart more smart
&nbsp
再來我們將程式直接轉成物件導向寫法！
# -*- coding: UTF8 -*-
import sys
from PyQt4.QtGui import *
from PyQt4.QtCore import *

app = QApplication(sys.argv)

class Hello(QWidget):
    def __init__(self, parent=None):
        super(self.__class__, self).__init__(parent)
        hello = QLabel('Hello World', self)

hello = Hello()
hello.show()
sys.exit(app.exec_())

先建立個class並繼承了QWidget
hello = QLabel('Hello World', self)
語法裡多個參數self, 主要是讓hello丟向QWidget
self等同代表了QWidget本身 
super(self.__class__, self).__init__(parent)
 
super算是python較特殊的東西，在此我只簡單的講，
在此使用super主要方便繼承 QWidget的__init__初始化
super(self.__class__, self).__init__(parent)跟使用
super(Hello, self).__init__(parent)是相同作用
但當class Hello(QWidget): 改成 class World(QWidget): 時
super(Hello, self).__init__(parent)一樣得跟著改
super(World, self).__init__(parent)
 
因此使用self.__class__會較方便點
如對super相當迷惑，請網路查詢一下資料，
super非三言兩語能解說清楚！ 

最後 sys.exit(app.exec_()) 
用於讓hello主程式關閉時，讓 app 也跟著關閉

python 第三方擴展模組安裝包下載點整理

2012-09-23T22:22:00.000-07:00

PyV8 Python Wrapper for Google V8 Javascript Engine

能在python底下使用 v8 javascript 引擎執行 js

Home Page: http://code.google.com/p/pyv8/
Download URL: http://code.google.com/p/pyv8/downloads/list

>>> import PyV8
>>> ctxt = PyV8.JSContext()          # create a context with an implicit global object
>>> ctxt.enter()                     # enter the context (also support with statement)
>>> ctxt.eval("1+2")                 # evalute the javascript expression
3                                    # return a native python int
>>> class Global(PyV8.JSClass):      # define a compatible javascript class
...   def hello(self):               # define a method
...     print "Hello World"    ...
>>> ctxt2 = PyV8.JSContext(Global()) # create another context with the global object
>>> ctxt2.enter()                    >>> ctxt2.eval("hello()")            # call the global object from javascript
Hello World                          # the output from python script

python re 正則表達式模組

2012-09-23T22:06:00.001-07:00

re模組
限定符說明：
".": 匹配任何字符
"^": 匹配開頭
"$": 匹配結尾
"*": 匹配0次或更多次之前的表達式。貪婪時，匹配盡可能多次
"+": 匹配1次或更多次之前的表達式。等價於{1,}
"?": 匹配0次或1次之前的表達式。等價於{0,1}
"*?,+?,??": 非貪婪匹配
"{m,n}": 貪婪式匹配之前的表達式m到n次
"{m,n}?": 非貪婪匹配之前的表達式m到n次
"\": 將下一個字符轉義
[ABC]: 指定一個字符集
[^ABC]: 指定一個不在範圍內的字符集
"A|B": 匹配條件A或條件B
(pattern): 匹配括號內的表達式，並作為匹配項
(?:pattern): 匹配括號內的表達式，但不作為匹配項
(?#...): 註釋，忽略
(?=pattern): 預查，若之後的內容匹配表達式，則成立
(?!pattern): 預查，若之後的內容不匹配表達式，則成立
(?Ppattern): 給一個匹配項命名
(?P=name)：匹配與之前命名的匹配項內容相同的部分
如：s='12a34a56'
   re.findall('12(?P.).*(?P=xxx)56)', s)
   (?P.)匹配到a，則(?P=xxx)的內容也必須為a時才pp
(?iLmsux): 設置I,L,M,S,U,or X標記
轉義符說明:
\A: 匹配開頭
\Z: 匹配結尾
\b: 匹配開頭或結尾的空字符串，通常是指單詞邊界？？？
\B: 匹配非開頭和結尾的空字符串，通常是指非單詞邊界？？？
\d: 匹配一個數字。等價於[0-9]
\D: 匹配一個非數字。等價於[^0-9]
\s: 匹配一個空白字符。等價於[ \t\n\r\f\v]
\S: 匹配一個非空白字符。等價於[^ \t\n\r\f\v]
\w: 匹配一個字母數字字符。等價於[a-zA-Z0-9_]
\W: 匹配一個非字母數字字符。等價於[^a-zA-Z0-9_]
\\: 匹配一個反斜杠
\f: 匹配一個換頁符。等價於\x0C 和 \cL
\n: 匹配一個換行符。等價於\x0A 和 \cJ
\r: 匹配一個回車符。等價於\x0D 和 \cM
\t: 匹配一個制表符。等價於\x09 和 \cI
\v: 匹配一個垂直制表符。等價於\x0B 和 \cK
\xHH: 匹配 HH，其中 HH 為十六進制轉義值
\uHHHH: 匹配 HHHH，其中 HHHH 是一個用四個十六進制數字表示的Unicode字符
常用匹配：
匹配中文字符的正則表達式： [\u4e00-\u9fa5]
匹配雙字節字符(包括漢字在內)：[^\x00-\xff]
匹配空行的正則表達式：\n[\s| ]*\r
匹配首尾空格的正則表達式：(^\s*)|(\s*$)
匹配Email地址的正則表達式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
匹配網址URL的正則表達式：^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*\\? \\S*)?$
匹配帳號是否合法(字母開頭，允許5-16字節，允許字母數字下劃線)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$
匹配國內電話號碼：(\d{3}-|\d{4}-)?(\d{8}|\d{7})?
匹配騰訊QQ號：^[1-9]*[1-9][0-9]*$
模塊使用：
    match:
    search:
    sub: 替換
    subn: 替換並返回替換的次數
    split: 分隔
    findall: 查找所有匹配項
    compile:
    purge:
    escape:
可選參數：
    I(IGNORECASE): 忽略大小寫
    L(LOCALE): 使用\w,\W,\b,\B時依據本地配置？？？
    M(MULTILINE): 多行，"^"匹配每行的開頭，"$"匹配每行的末尾
    S(DOTALL): 使"."匹配包含換行符在內的任意字符
    X(VERBOSE): 忽略空白處和註釋內容
    U(UNICODE): 使\w,\W,\b,\B依靠UNICODE編碼

python time 模組

2012-09-23T22:04:00.001-07:00

time模組
這個模組定義的都是和時間、時鐘、計時相關的內容：
    clock():返回第一次調用到當前調用時的計時，是以秒為單位的浮點數
    localtime([t]):返回時間的數組，有9個元素(年,月,日,時,分,秒,星期幾,當年的第幾天,是否夏令時)，星期一為0
    mktime(tlist):是localtime的反函數，將一個9元數組轉成一個浮點時間值，後3個元素，系統會自己調整
    sleep(n):掛起線程n秒
    strftime(fstring[,t]):格式化顯示時間，fstring常用關鍵字：
      %a,%A:星期的縮寫，全拼
      %b,%B:月份的縮寫，全屏
      %c,%x,%X:本地默認表示法（日期時間，日期，時間）
      %Y(%y:2位),%m,%d,%H,%M,%S:年月日時分秒
      %w:星期，0為星期天
    strptime(string[,format]):將字符串解析為9元素的時間數組
    time():返回當前時間值，浮點數
更高級的用法可以使用datetime模組，創建其中的date,time物件，可以進行加減操作，得出timedelta對象。

python 內建模組 built-in

2012-09-23T22:01:00.000-07:00

python 本身內建無需用 import 導入的模組
built-in
    eval(expr[,globals[,locals]]):執行一段代碼，並返回結果
    exec(expr[,globals[,locals]]):執行一段代碼
    execfile(file[,globals[,locals]]):執行一個文件
    filter(func,list):使用函數來過濾list，返回滿足要求的list元素組
    getattr(obj,name[,default]):獲取對象的屬性，若沒有該屬性，則返回默認值
    setattr(obj,name,value):設置對象的屬性，若沒有該屬性，則異常
    hasattr(obj,name):返回對象是否有指定屬性
    input([prompt]):提示控制臺輸入，必須輸入常量或變量，若想直接輸入字符串，需要使用引號括起來
    raw_input([prompt]):提示控制臺輸入，直接輸入數字或字符串
    open(filename,mode):打開文件，mode可以為：w,r,a，若想同時讀寫，則加上+，若想以二進制讀寫，則加上b
    reload(module):再次導入已導入過的模塊
    type(obj):返回一個對象的類型
    zip(seq1,...):將若幹個元組進行合並，長度以元組中的最短的為準

python sys 模組操作方式

2012-09-23T21:58:00.000-07:00

sys模組
系統信息和方法模組，提供了很多實用的變量和方法：
    argv:命令行參數List，第一個元素是程序本身路徑
    builtin_module_names:Python解釋器導入的模塊列表
    modules.keys():返回所有已經導入的模塊列表
    exc_info():獲取當前正在處理的異常類
    exc_type、exc_value、exc_traceback:當前處理的異常詳細信息
    executable:Python解釋程序路徑
    exit(n):退出程序，正常退出時exit(0)
    getwindowsversion():獲取Windows的版本
    hexversion:獲取Python解釋程序的版本值，16進制格式如：0x020403F0
    version:獲取Python解釋程序的版本信息
    maxint:最大的Int值
    maxunicode:最大的Unicode值
    modules:返回系統導入的模塊字段，key是模塊名，value是模塊
    path:返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值
    platform:返回操作系統平臺名稱

python os 模組操作方式

2012-09-23T21:54:00.002-07:00

os模組:
os模組包裝了不同操作系統的通用接口，使用戶在不同操作系統下，可以使用相同的函數接口，返回相同結構的結果。

os.name:返回當前操作系統名稱（'posix', 'nt', 'os2', 'mac', 'ce' or 'riscos'）

os中定義了一組文件、路徑在不同操作系統中的表現形式參數，如
    os.sep（文件夾分隔符，windows中是 \ ）
    os.extsep（擴展名分隔符，windows中是 . ）
    os.pathsep（目錄分隔符，windows中是 ; ）
    os.linesep（換行分隔符，windows中是 \r\n ）

os中有大量文件、路徑操作的相關函數，如：
    listdir(path):列舉目錄下的所有文件
    makedir(path):創建文件夾，註：創建已存在的文件夾將異常
    makedirs(path):遞歸式的創建文件夾，註：創建已存在的文件夾將異常
    remove(filename):刪除一個文件
    rmdir(path):刪除一個文件夾，註：刪除非空的文件夾將異常
    removedirs(path):遞歸的刪除文件夾，直到有一級的文件夾非空，註：文件夾路徑不能以'\'結束
    rename(src,dst):給文件或文件夾改名（可以改路徑，但是不能覆蓋目標文件）
    renames(src,dst):遞歸式的給文件或文件名改名
    walk(path):列舉path下的所有文件、文件夾

os中與進程相關的操作，如：
    execl(path):運行一個程序來替代當前進程，會阻塞式運行
    _exit(n):退出程序
    startfile(filename):用與文件關聯的程序運行，關聯程序打開後，立即返回
    system(cmd):運行一個程序或命令，會立即返回，並在cmd執行完成後，會返回cmd退出代碼

os.path
在不同的操作系統中調用不同的模組，是一個可import的模組，這個模組中提供很多有用的操作：
    abspath(path):返回path的絕對路徑，若path已經是絕對路徑了，則保持。
    basename(path):返回path中的文件名。
    commonprefix(list):返回list中的統一前綴，用於獲得一組字符串的左起相同的內容
    dirname(path):返回path中的文件夾部分，結果不包含'\'
    exists(path):文件或文件夾是否存在
    getatime(path):文件或文件夾的最後訪問時間，從新紀元到訪問時的秒數
    getmtime(path):文件或文件夾的最後修改時間
    getctime(path):文件或文件夾的創建時間
    getsize(path):文件或文件夾的大小，若是文件夾返回0
    isabs(path):返回是否是絕對路徑
    isfile(path):返回是否是文件路徑
    isdir(path):返回是否是文件夾路徑
    islink(path):返回是否是快捷方式
    join(path1,path2,...):將path進行組合，若其中有絕對路徑，則之前的path將被刪除
    normcase(path):轉換路徑中的間隔符
    normpath(path):轉換路徑為系統可識別的路徑
    realpath(path):轉換路徑為絕對路徑
    split(path):將路徑分解為(文件夾,文件名)
    splitext(path):將路徑分解為(其余部分,.擴展名)，若文件名中沒有擴展名，擴展名部分為空字符串
在操作與系統不支持的對象時，拋出OSError異常。

快速關螢幕

2012-09-21T23:28:00.003-07:00

用自已的手按螢幕開關，不然就得靠軟體設定一下快速鍵

系統支援：Windows XP/Vista/Win7
官方網站：http://www.sdsoftware.org/

BlackTop 的功能很簡單，安裝好之後即可提供一個鍵盤快速鍵組合「Ctrl」+「Alt」+「b」，當我們按下後即可馬上關閉螢幕、停止顯示畫面。等要用電腦時，動一動滑鼠或隨便按一下鍵盤上的任意按鍵，即可恢復使用。

讓電腦快速休眠省電大作戰

2012-09-21T23:23:00.005-07:00

有時只是短暫離開電腦一下！
關機重開，又需重新載入系統，再開原本在用的應用程式，會花費不少時間，
不關又有點浪費電！

此時讓電腦快速進入休眠狀態，不失為一舉二得的好辦法^^

WIN7 系統

桌面滑鼠右鍵→新增(w)

點選捷徑(s)

輸入項目的位置:

填入 rundll32.exe powrprof.dll,SetSuspendState Hibernate 下一步

捷徑的名稱填入「休眠」或任何你想用的名稱都可

再來點選捷徑右鍵→內容可設一下快捷鍵增添方便性

with as

2012-08-11T13:18:00.000-07:00

要打開文件，我習慣照書本教的

fobj = open(filename, 'r')

怕文件不存在，可能還得再加個捕捉錯誤

try:
    fobj = open(filename, 'r')
except IOError:
    pass

但有了with as 就方便多了，可以

  1 
  2

with open(filename, 'r') as fobj:
    do something

為了讓class 也能使用，需添加二個函數__enter__和 __exit__

class A:
    def __enter__(self):
        print 'in enter'
    def __exit__(self, e_t, e_v, t_b):
        print 'in exit'

with A() as a:
    print 'in with'


in enter
in with
in exit

使用模組contextlib，便不用構造__enter__和 __exit__

>>> from contextlib import contextmanager
>>> from __future__ import with_statement
>>> @contextmanager
... def context():
...     print 'entering the zone'
...     try:
...         yield
...     except Exception, e:
...         print 'with an error %s'%e
...         raise e
...     else:
...         print 'with no error'
...
>>> with context():
...     print '----in context call------'
...
entering the zone
----in context call------
with no error

官方範例

from contextlib import contextmanager

@contextmanager
def tag(name):
    print "<%s>" % name
    yield
    print "</%s>" % name

>>> with tag("h1"):
...    print "foo"
...
<h1>
foo
</h1>

還有一個closing可在抓網頁資料時使用

from contextlib import closing
import urllib

with closing(urllib.urlopen('http://www.python.org')) as page:
    for line in page:
        print line

LIST的妙用

2012-08-11T12:35:00.001-07:00

在彼得．狼的獸窩看到一遍文章覺得蠻有趣的！
Java & Python 程式碼疊疊樂之二

內容主要比較 python&java寫輸入一分數判定等級ABCDE那種

這種東西常見的寫法大部分都是:

#!/usr/bin/python 

# -*- coding: utf-8 -*-

# Filename: gradingRobotOne.py



grade = raw_input("請輸入分數： ")      #利用 raw_input 的函式取得鍵盤輸入

score = int(grade)                      #從 raw_input 取得的字串類型 (String) 資料，轉換為 int 的類型

print "====================="

print "您輸入的分數為：", score



gradeLevel = "未判定！"                  #預設成績等級為「未判定！」

#利用判斷式把輸入的成績分等級

if score > 100 or score < 0:

print "分數應該介於 0 到 100 之間！"

elif score <= 100 and score >= 90:

gradeLevel = "A"

elif score <= 89 and score >= 80:

gradeLevel = "B"

elif score <= 79 and score >=70:

gradeLevel = "C"

elif score <= 69 and score >=60:

gradeLevel = "D"

else:

gradeLevel = "F"



print "成績評定為：", gradeLevel        #印出評定結果

那有趣的是，我看最後面有一個回文提供的寫法，蠻有智慧的！

Grade = ["E","D","C","B","A"];
Score = int(raw_input());
print Grade[int((Score-51)/10)];

直接利用LIST的特性，判定成績，讓代碼大為減少！！！