pyton筆記-part2

1.為啥類函數中函數調用需要加self.函數名，因為全局變量的影響

  1. a = 1  

  2. def say(): 

  3.     print '調用了全局方法' 

  4. class people: 

  5.     a = 100 

  6.     def say(self): 

  7.         print '調用了類的方法' 

  8.     def do(self): 

  9.         say() 

  10.        self.say() 

  11.        print 'a = ' , a 

  12.        print 'self.a = ' , self.a 

  13. p = people()  

  14. p.do() 

  15. 結果：

  16. 調用了全局方法 

  17. 調用了類的方法 

  18. a =  1 

  19. self.a =  100

\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

2.python轉義字元

有時我們并不想讓轉義字元生效，我們隻想顯示字元串原來的意思，這就要用r和R來定義原始字元串。如：

print r'\t\r'

實際輸出為“\t\r”。

轉義字元：

\ === 在行尾時代表續行

\\=== 反斜杠符号

\t=== 橫向制表符

\v=== 縱向制表符

\'=== 單引号

\"=== 雙引号

\000===空

\n=== 換行

\r===回車

\f===換頁

\e===轉義

\b===倒退（backspace）

\oyy===八進制數yy代表的字元如\o12代表換行

\xyy===十進制數yy代表的字元如\xoa代表換行

\a===響鈴

\other===其他字元以普通格式輸出

 \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

 3.正規表達式[],'字元串'比對用法

import re

"""

1.比對字元串包含規則的字段

'findall(rule , target [,flag] )'是個比較直覺的函數，就是在目标字元串中查找符合規則的字元串。

第一個參數是規則，第二個參數是目标字元串,傳回結果是個清單

r'字元串'可以省去好多需要轉義的，如r'\e','\\e'兩個是一個意思

s = "abc3isjffabc99skjflAkabc abck^skdflks"

b = re.findall(r'abc', s)

print b

'''

2.[]括起來表示一個字元的集合

[^abc]表示非a，b，c，比對除abc外任意一個字元

[a-z^A-Z]表示比對包含a-z，^，A-Z任意一個字元，^放在中間不再表示非的含義

c = re.findall('[abc123]', s)

d = re.findall('[^A-Z^]', s)

e = re.findall('[A-Z^]', s)

print c

print d

print e

結果：

D:\Python27\python.exe "D:/python-pycharm-installpackage/python script/our test/Test11.py"

['abc', 'abc', 'abc', 'abc']

['a', 'b', 'c', '3', 'a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']

['a', 'b', 'c', '3', 'i', 's', 'j', 'f', 'f', 'a', 'b', 'c', '9', '9', 's', 'k', 'j', 'f', 'l', 'k', 'a', 'b', 'c', ' ', 'a', 'b', 'c', 'k', 's', 'k', 'd', 'f', 'l', 'k', 's']

['A', '^']

Process finished with exit code 0

\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

4.正規表達式|的用法

# -*- coding: UTF-8 -*-

# __author__ = '10459'

1.符号|的用法，[a-z]|[A-Z]與[a-zA-Z]等效，可以了解成或的關系

[|]:|在[]裡面不再表示或的關系，而是表示|本身

[]\|[]:在[]外面表示|字元，則必須用\|轉義

|：它的有效範圍是它兩邊的整條規則，如a cat|dog 比對的不是t，d，而是a cat和dog

如果想限定它的有效範圍，必需使用一個無捕獲組 ‘(?: )’ 包起來。

比如要比對 ‘ I have a dog’ 或 ’I have a cat’ ，需要寫成 r’I have a (?:dog|cat)’ ，

而不能寫成 r’I have a dog|cat’

s = "I have a dog, I have a cat||a"

a = re.findall(r"[a-z]|[A-Z]", s)

b = re.findall(r"[|]", s)

c = re.findall(r"[a-z]\|\|[a-z]", s)

print a

d = re.findall(r'I have a (?:dog|cat)', s)

e = re.findall(r'I have a dog|cat', s)

['|', '|']

['I', 'h', 'a', 'v', 'e', 'a', 'd', 'o', 'g', 'I', 'h', 'a', 'v', 'e', 'a', 'c', 'a', 't', 'a']

['t||a']

['I have a dog', 'I have a cat']

['I have a dog', 'cat']

---------------------------------------------------------

5. .?, .+? , .*? , .* , .+ 的用法，前面沒有邊界時.+,.+?用的多

.*?表示比對任意數量的重複，但是在能使整個比對成功的前提下使用最少的重複，重複次數可以是零次-多次，

從開始到結尾依次比對。注意每換行制表符的時候會重新比對

.+?表示這裡比對任意數量重複，比對成功情況下可能少重複，但是重複次數為一次-多次，從開始到結尾依次比對

.*表示貪婪比對盡可能長的比對，重複次數0-多次，從每行的全部往裡面縮減比對，每換行的時候都會重新比對

.+表示貪婪比對盡可能長的比對，重複次數1-多次，從每行的全部往裡面縮減比對，每換行的時候都會重新比對

ss = "abbabaababa\nbabba babbbbbbbbbbbbbbbbbbbbbbbbbb"

a = re.findall(r"a.*?b", ss)

b = re.findall(r"a.?b", ss)

c = re.findall(r"a.*b", ss)

d = re.findall(r"a.+b", ss)

e = re.findall(r"a.+?b", ss)

['ab', 'ab', 'aab', 'ab', 'ab', 'a b', 'ab']

['abb', 'ab', 'aab', 'ab', 'abb', 'a b', 'abb']

['abbabaabab', 'abba babbbbbbbbbbbbbbbbbbbbbbbbbb']

['abb', 'abaab', 'abb', 'a b', 'abb']

----------------------------------------------------------

6.正規表達式貪婪模式，勉強模式，占用模式

假定要分析的字元串是xfooxxxxxxfoo

1.??? 模式.*foo （貪婪模式）:     模式分為子模式p1(.*)和子模式p2(foo)兩個部分. 其中p1中的量詞比對方式使用預設方式(貪婪型)。 比對開始時,吃入所有字元xfooxxxxxxfoo去比對子模式p1。比對成功,但這樣以來就沒有了字元串去比對子模式p2。本輪比對失敗；第二輪：減少p1部分的比對量，吐出最後一個字元, 把字元串分割成xfooxxxxxxfo和o兩個子字元串s1和s2。 s1比對p1, 但s2不比對p2。本輪比對失敗；第三輪，再次減少p1部分比對量，吐出兩個字元, 字元串被分割成xfooxxxxxxf和oo兩部分。結果同上。第四輪，再次減少p1比對量, 字元串分割成xfooxxxxxx和foo兩個部分, 這次s1/s2分别和p1/p2比對。停止嘗試,傳回比對成功。

2.??? 模式.*?foo （勉強模式）: 最小比對方式。第一次嘗試比對, p1由于是0或任意次，是以被忽略，用字元串去比對p2,失敗；第二次，讀入第一個字元x, 嘗試和p1比對, 比對成功; 字元串剩餘部分fooxxxxxxfoo中前三個字元和p2也是比對的. 是以, 停止嘗試, 傳回比對成功。在這種模式下，如果對剩餘字元串繼續去尋找和模式相比對的子字元串，還會找到字元串末尾的另一個xfoo，而在貪婪模式下，由于第一次比對成功的子串就已經是所有字元，是以不存在第二個比對子串。

結果：['xfoo', 'xxxxxxfoo']

3.??? 模式.*+foo （侵占模式）:

python 2.7沒有這種模式

也叫占用模式。比對開始時讀入所有字元串, 和p1比對成功, 但沒有剩餘字元串去和p2比對。是以, 比對失敗。傳回。

?

簡單地說, 貪婪模式和占有模式相比, 貪婪模式會在隻有部分比對成功的條件下, 依次從多到少減少比對成功部分模式的比對數量, 将字元留給模式其他部分去比對; 而占用模式則是占有所有能比對成功部分,

 絕不留給其他部分使用。

 ----------------------------------------

 7.正規表達式一些重要的比對項目

 1）‘^’ 和 ’$’ 比對字元串開頭和結尾

注意 ’^’ 不能在‘ [ ] ’中，否則含意就發生變化，具體請看上面的 ’[‘ ‘]’ 說明。 在多行模式下，它們可以比對每一行的行首和行尾。具體請看後面 compile 函數說明的 ’M’ 選項部分

2）#‘\d’ 比對數字

這是一個以 ’/’ 開頭的轉義字元， ’\d’ 表示比對一個數字，即等價于 [0-9]

#‘\D’ 比對非數字

這個是上面的反集，即比對一個非數字的字元，等價于 [^0-9] 。注意它們的大小寫。下面我們還将看到 Python 的正則規則中很多轉義字元的大小寫形式，代表互補的關系。這樣很好記。

\d+:表示比對數字至少一個或多個

\d：等價于[0-9]中單個字元

^:放在[]外面表示比對行首，空格為斷點假如沒有re.M則表示整個段落行首，假如有re.M則表示每行行首都會比對,每行空格後面

不比對

$:放在[]外面表示比對行尾，空格作為斷點，假如沒有re.M則表示整個段落段尾，假如有re.M則表示每行的行尾都會比對，每行

空格前面不比對

\D:表示比對非數字[^0-9]

\D+:表示比對非數字至少一個或多個

ss = "1 123\n456\n78M9 10"

a = re.findall(r"^\d+", ss)

b = re.findall(r"^\d+",ss, re.M)

c = re.findall(r"\d+$", ss, re.M)

d = re.findall(r"\d+$", ss)

e = re.findall(r"\D+", ss)

f = re.findall(r"\d", ss)

g = re.findall(r"\D", ss)

print f,g

['1']

['1', '456', '78']

['123', '456', '10']

['10']

[' ', '\n', '\n', 'M', ' ']

['1', '1', '2', '3', '4', '5', '6', '7', '8', '9', '1', '0'] [' ', '\n', '\n', 'M', ' ']

3）#‘\w’ 比對字母和數字單個字元一個個比對

比對所有的英文字母和數字，即等價于 [a-zA-Z0-9] 。

#‘\W’ 比對非英文字母和數字單個字元一個中括号取一個

即 ’\w’ 的補集，等價于 [^a-zA-Z0-9] 。

\w:等價[a-z0-9A-Z]比對數字字母任意一個

\w+:表明以空格和換行為斷點，比對任意一個或一串數字或字母組合

\W:等價[^a-z0-9A-Z]比對非數字字母任意一個

\W+：以空格和換行為斷點，比對任意非數字和非字母一個或一串

ss = "1 123\n456\n78M9  10"

a = re.findall(r"\W", ss)

b = re.findall(r"\W+", ss)

c = re.findall(r"\w", ss)

d = re.findall(r"\w+", ss)

print a,b

print c,d

[' ', '\n', '\n', ' ', ' '] [' ', '\n', '\n', '  ']

['1', '1', '2', '3', '4', '5', '6', '7', '8', 'M', '9', '1', '0'] ['1', '123', '456', '78M9', '10']

4）‘\s’ 比對間隔符

即比對空格符、制表符、回車符等表示分隔意義的字元，它等價于 [ \t\r\n\f\v] 。（注意最前面有個空格 )

‘\S’ 比對非間隔符

即間隔符的補集，等價于 [^ \t\r\n\f\v]

\s:等價[ \t\n\v\r\f]比對包含并展示分隔符任意一個

\s+:比對任意一個或多個連續的分隔符

\S:比對分隔符但是不展示分隔符，至少後面字元為兩個

\S+：比對包含但不展示一個或多個連續分隔符旁邊的字段

ss = "1 123\n456\n 7 8M9  10"

a = re.findall(r"\s+\w+", ss)

c = re.findall(r"\s\w+\s",ss)

b = re.findall(r"\S\w", ss)

d = re.findall(r"\S\w+", ss)

[' 123', '\n456', '\n 7', ' 8M9', '  10'] ['12', '45', '8M', '10']

[' 123\n', ' 7 '] ['123', '456', '8M9', '10']

5）‘\A’ 比對字元串開頭

比對字元串的開頭。它和 ’^’ 的差別是， ’\A’ 隻比對整個字元串的開頭，即使在 ’M’ 模式下，它也不會比對其它行的很首。

‘\Z’ 比對字元串結尾

比對字元串的結尾。它和 ’$’ 的差別是， ’\Z’ 隻比對整個字元串的結尾，即使在 ’M’ 模式下，它也不會比對其它各行的行尾。

例：

6)‘\b’ 比對單詞邊界

它比對一個單詞的邊界，比如空格等，不過它是一個‘ 0 ’長度字元，它比對完的字元串不會包括那個分界的字元。而如果用 ’\s’ 來比對的話，則比對出的字元串中會包含那個分界符。

‘\B’ 比對非邊界

和 ’\b’ 相反，它隻比對非邊界的字元。它同樣是個 0 長度字元。

7）(?iLmsux) 編譯選項指定

Python 的正則式可以指定一些選項，這個選項可以寫在 findall 或 compile 的參數中，也可以寫在正則式裡，成為正則式的一部分。這在某些情況下會便利一些。具體的選項含義請看後面的 compile 函數的說明。

此處編譯選項 ’i’ 等價于 IGNORECASE ，L 等價于 LOCAL ，m 等價于 MULTILINE ， s 等價于 DOTALL ， u 等價于 UNICODE ， x 等價于 VERBOSE 。

請注意它們的大小寫。在使用時可以隻指定一部分，比如隻指定忽略大小寫，可寫為 ‘(?i)’ ，要同時忽略大小寫并使用多行模式，可以寫為 ‘(?im)’ 。

另外要注意選項的有效範圍是整條規則，即寫在規則的任何地方，選項都會對全部整條正則式有效。

s = "abc a bcbc de dfsda bcc de 123 sdddbcbcdaad bc ddssa"

a = re.findall(r"\bbc+\b", s)

b = re.findall(r"\b(?:bc)+\b", s)

c = re.findall(r"\Bbc\B", s)      # sdddbcbcdaad 比對這裡面兩個bc

e = re.findall(r"\B(bc)+\B", s)  

# 比對sdddbcbcdaad裡面的bcbc，重複兩次比對上了，隻是僅寫出了bc

d = re.findall(r"\B(?#jkjkdf)(?:bc)(?#dffs)+\B", s)

# 無捕獲組（？：）比對sdddbcbcdaad以bc為整體比對重複次數兩次并寫出

# (？#ksfkd)注釋

print a, b

print c, d

['bcc', 'bc'] ['bcbc', 'bc']

['bc', 'bc'] ['bcbc']

['bc']

----------------------------------------------------

8正規表達式重複的使用*,?,+

重複

*:前面重複0次或者多次

？：前面字元重複0次或者1次

+：前面字元重複1次或者多次

s = "abc a bcbc de b dfsda bccc de 123 sdddbcbcdaad bc ddssa"

e = re.findall(r"bc*", s)   # c的次數可以是零次意味着輸出b，也可以是多次輸出bcccc...

a = re.findall(r"bc+", s)   # c的次數至少出現一次，意味着最少bc，最多bcccc....

c = re.findall(r"bc?", s)   # c的次數隻能是0次或一次，可以輸出b，bc

['bc', 'bc', 'bc', 'b', 'bccc', 'bc', 'bc', 'bc']

['bc', 'bc', 'bc', 'bccc', 'bc', 'bc', 'bc']

['bc', 'bc', 'bc', 'b', 'bc', 'bc', 'bc', 'bc']

-----------------------------------------------------------

9.精确比對{m},{m，n}次的用法

精确比對

{m}:比對前面一個字元m次

{m,n}:m<n，比對前面字元最少m次，最多n次

s = "1  22 333 4444  5555cc 666666 7777777eeee  22333"

e = re.findall(r"\b\d{2,4}\b", s)

a = re.findall(r"\d{2,4}", s)

c = re.findall(r"\b\d{2,4}", s)

d = re.findall(r"\d{2,4}\b", s)

f = re.findall(r"\b\d{3}\b", s)

g = re.findall(r"\b\d{3,}\b", s)

h = re.findall(r"\b3{3}\b", s)

print f

print g,h

結果:

['22', '333', '4444']

['22', '333', '4444', '5555', '6666', '66', '7777', '777', '2233']

['22', '333', '4444', '5555', '6666', '7777', '2233']

['22', '333', '4444', '6666', '2333']

['333']

['333', '4444', '666666', '22333'] ['333']

-------------------------------------------

10.正規表達式.？，.+?,.*?比對方式的不同

.?:比對0次或1次

.+?:比對1次或多次

.*?：比對0次或多次

s = r'/* part 1 */ code /* part 2 *//**/'

a = re.findall(r"/\*.*\*/", s)    # /\*後面*号需要轉義，然後.*是貪婪比對，全部往裡縮減

c = re.findall(r"/\*.*?\*/", s)   # .*?懶惰比對，從裡往外擴充，裡面最少0個字元

d = re.findall(r"/\*.+?\*/", s)   # .+?懶惰比對裡面至少要一個字元

f = re.findall(r"/\*.?\*/", s)    # .?懶惰比對裡面隻能零次或一個字元

['/* part 1 */ code /* part 2 *//**/']

['/* part 1 */', '/* part 2 */', '/**/']

['/* part 1 */', '/* part 2 */']

['/**/']

---------------------------------------------------

11.前向界定，後向界定，前向非界定，後向非界定

#‘(?<=…)’ 前向界定

括号中 ’…’ 代表你希望比對的字元串的前面應該出現的字元串。

#‘(?=…)’  後向界定

括号中的 ’…’ 代表你希望比對的字元串後面應該出現的字元串。

#‘(?<!...)’ 前向非界定

隻有當你希望的字元串前面不是’…’ 的内容時才比對

#‘(?!...)’ 後向非界定

隻有當你希望的字元串後面不跟着 ’…’ 内容時才比對。

(?<=。。。):前向界定，裡面為常量，不能正規表達式寫

(?=):後向界定，裡面可以為常量，也可以為正規表達式

(?<!。。。)：前向非界定

(?!...):後向非界定

a = re.findall(r"(?<=/\*).*(?=\*/)", s)

c = re.findall(r"(?<=/\*).*?(?=\*/)", s)

d = re.findall(r"(?<=/\*).+?(?=\*/)", s)

f = re.findall(r"(?<=/\*).?(?=\*/)", s)

ss = 'aaa111aaa , bbb222 , 333ccc'

bb = re.findall(r"\d+(?=[a-z]+)", ss)  

#不能用r"(?<=[a-z]+)\d+(?=[a-z]+)"前向界定與前向非界定隻能用可以确定的常量比如不确定的正則就不能有

這種可以有

aa = re.findall(r"(?<![a-z])\d+", ss)

cc = re.findall(r"[a-z]+(\d+)[a-z]+", ss)

dd = re.findall(r"\d+(?!\w+)", ss)

ff = re.findall(r"\d+(?![a-z]+)", ss)

print cc

print ff

print dd

print bb

print aa

['111'] ['11', '222', '33']

['222']

['111', '333']

['11', '22', '333']

[' part 1 */ code /* part 2 *//*', '']

[' part 1 ', ' part 2 ', '']

[' part 1 ', ' part 2 ']

['']

--------------------------------------------

12.組的了解

#‘(‘’)’       無命名組   隻展示組裡面的東西

最基本的組是由一對圓括号括起來的正則式。比如上面比對包夾在字母中間的數字的例子中使用的 (/d+) ，我們再回顧一下這個例子：

s = 'aaa111aaa , bbb222 , 333ccc'

dd = re.findall(r'[a-z]+(\d+)[a-z]+', s)

['111']

有兩個括号，則以元組的形式展示

s = 'aaa111aaa,bbb222,333ccc,444ddd444,555eee666,fff777ggg'

dd = re.findall(r'([a-z]+)\d+([a-z]+)', s)

[('aaa', 'aaa'), ('fff', 'ggg')]

可以看到 findall 函數隻傳回了包含在 ’()’ 中的内容，而雖然前面和後面的内容都比對成功了，#卻并不包含在結果中。

除了最基本的形式外，我們還可以給組起個名字，它的形式是

#‘(?P<name>…)’ 命名組

‘(?P’ 代表這是一個 Python 的文法擴充 ’<…>’ 裡面是你給這個組起的名字，比如你可以給一個全部由數字組成的組叫做 ’num’ ，它的形式就是 ’(?P<num>\d+)’ 。起了名字之後，我們就可以在後面的正則式中通過名字調用這個組，它的形式是

#‘(?P=name)’ 調用已比對的命名組

要注意，再次調用的這個組是已被比對的組，也就是說它裡面的内容是和前面命名組裡的内容是一樣的。

我們可以看更多的例子：請注意下面這個字元串各子串的特點。

#命名組不同名字的會都列印，同名引用隻列印一個，同名引用一定對稱的#

dd = re.findall(r'(?P<g1>[a-z]+)\d+(?P<g2>[a-z]+)', s)

ds = re.findall(r'(?P<g1>[a-z]+)\d+(?P=g1)', s)

da = re.findall(r'[a-z]+(?P<g2>\d+)(?P<g3>[a-z]+)', s)

print ds

print da

['aaa']#假如上面是aaa111aa，則這裡列印aa不是aaa

[('111', 'aaa'), ('777', 'ggg')]

我們可以通過命名組的名字在後面調用已比對的命名組，不過名字也不是必需的。

#‘/number’      通過序号調用已比對的組（相同的也會列印出來與名字命名調用有點差別）

正則式中的每個組都有一個序号，序号是按組從左到右，從 1 開始的數字，你可以通過下面的形式來調用已比對的組

比如上面找出被中間夾有數字的前後同樣的字母的例子，也可以寫成：

備注：對稱的列印

dd = re.findall(r'\b(\d+)\w+(\1)\b', s)

結果

[('444', '444')]

。

我們再看一個例子

s = '111aaa222aaa111 , 333bbb444bb33'

dd = re.findall(r'(\d+)([a-z]+)(\d+)(\2)(\1)', s)

print dd          

# 找出完全對稱的 數字－字母－數字－字母－數字 中的數字和字母

[('111', 'aaa', '222', 'aaa', '111')]

#‘(?( id/name )yes-pattern|no-pattern)’

判斷指定組是否已比對，執行相應的規則

這個規則的含義是，如果 id/name 指定的組在前面比對成功了，則執行 yes-pattern 的正則式，否則執行 no-pattern 的正則式。

舉個例子，比如要比對一些形如 usr@mail 的郵箱位址，不過有的寫成 < usr@mail > 即用一對 <> 括起來，有點則沒有，要比對這兩種情況，可以這樣寫

ee='<usr1@mail1>  usr2@maill2 <skkl@2  user3@df> <use4@skf'

kk = re.findall(r"(<)?\s*(\w+@\w+)\s*(?(1)>)", ee)

print kk

結果：[('<', 'usr1@mail1'), ('', 'usr2@maill2'), ('', 'skkl@2'), ('', 'user3@df'), ('', 'use4@skf')]

-------------------------------------------------

13.題目如下

1）啟動程式後，讓使用者輸入工資，然後列印商品清單

2）允許使用者根據商品編号購買商品

3）使用者選擇商品後，檢測餘額是否夠，夠就直接扣款，不夠就提醒

4）課随時退出，退出時，列印已購買商品和餘額

shopping_list = []

goods = [

    ('iphone', 5000),

    ('ipad', 4000),

    ('watch', 7000),

    ('orange', 400),

    ('car', 40000),

    ('pen', 800)

]

salary = raw_input('輸入工資：')

if salary.isdigit():

    salary = int(salary)

    b = True

else:

    b = False

while b == False:

    print "您的輸入有誤，請重新輸入"

    salary = raw_input('請重新輸入工資：')

    if salary.isdigit():

        salary = int(salary)

        b = True

    else:

        b = False

a = True

while a:

    for index, product in enumerate(goods):

        print index, product

    user_choice = raw_input('輸入要買的商品:')

    if user_choice.isdigit():

        user_choice = int(user_choice)

        if user_choice < len(goods) and user_choice >= 0:

            p_item = goods[user_choice]

            if salary >= p_item[1]:

                shopping_list.append(p_item)

                salary -= p_item[1]

                print "add %s to shopping list,you current balance is \033[31;1m%s\033[0m" % (p_item, salary)

            else:

                print ('\033[41;1m的餘額隻剩%s,請充值再購買\033[0m' % salary)

        else:

            print ("goods code %s is not exist" % user_choice)

    elif user_choice == "q":

        print "-------shoppinglist--------"

        sum = 0

        for p in shopping_list:

            print p

            sum += p[1]

        print "=========消費金額與餘額========="

        print "you total cost：%s" % sum

        print "you current balance is %s" % salary

        exit()

        print ("請務必準确輸入産品代碼，代碼必須為整數，謝謝")

1)

輸入工資：qq

您的輸入有誤，請重新輸入

請重新輸入工資：1

0 ('iphone', 5000)

1 ('ipad', 4000)

2 ('watch', 7000)

3 ('orange', 400)

4 ('car', 40000)

5 ('pen', 800)

輸入要買的商品:q

-------shoppinglist--------

=========消費金額與餘額=========

you total cost：0

you current balance is 1

2）

輸入工資：40000

輸入要買的商品:4

add ('car', 40000) to shopping list,you current balance is 0

輸入要買的商品:1

的餘額隻剩0,請充值再購買

('car', 40000)

you total cost：40000

you current balance is 0

--------------------------------------------------------

14.形參和實參

def test(x,y,z):     # x,y,z是形式參數

    print x

    print y

    print z

test(1,2,3)   # 位置參數調用，1，2，3實際參數調用 輸出1 2 3

test(x=1,z=3,y=2)  #關鍵字調用  随便什麼順序，輸出1 2 3

test(3,z=3,y=2)  # 混合參數調用，關鍵字參數不能放在位置參數之前

# test(x=3,3,2) 這個是錯的  注意

----------------------------

15.二進制，十六進制，十進制，八進制，ASCII的一些轉換

将二進制，八進制，十六進制轉換成10進制用int（）

a = int('1100', base=2)

b = int("ff", base=16)

c = int('16', base=8)

print a, b, c

将整型轉換成字元，用chr（）,将字元轉換成×××，用ord（）ASCII碼

ss = chr(89)

sss = ord("Y")

print ss, sss

将十進制轉換成16進制用hex()，将十進制轉換成8進制用oct()，将十進制轉換成2進制用bin()

sixteen = hex(45)

ba = oct(567)

er = bin(455)

print sixteen, ba, er

D:\Python27\python.exe "D:/python-pycharm-installpackage/python script/our test/shoppingcart.py"

12 255 14

Y 89

0x2d 01067 0b111000111

16.題目：1，2，3，4中組成互不相同且無重複的三位數

list_num = [1,2,3,4]

list = [i*100 + j*10 + k for i in list_num for j in list_num for k in list_num if ( i != j and i != k and j != k)]

d = len(list)

print('1,2,3,4能組成 %d 個互不相同且無重複數字的三位數。' % d)

print('他們各是:%s' % list)

1,2,3,4能組成 24 個互不相同且無重複數字的三位數。

他們各是:[123, 124, 132, 134, 142, 143, 213, 214, 231, 234, 241, 243, 312, 314, 321, 324, 341, 342, 412, 413, 421, 423, 431, 432]

----------------

17.

print '''line1

line2

line3'''

或者

print r'''line1

line1

line3

----------------------