python核心編程-第六章-我的筆記(一)

0.    序列包括字符串、列表和元組三種類型

1.    序列

1.0  序列的每個元素能夠經過指定一個偏移量的方式獲得，多個元素能夠經過切片操做的方式一次獲得。偏移量從0開始，到總元素數-1結束

1.1  標準類型操做符

標準類型操做符通常適用於全部的序列類型

1.2  序列類型操做符

1.2.1  成員關係操做符—in和not in

 成員關係操做符用來判斷一個元素是否屬於一個序列，返回True/False：知足成員關係就返回True，不然返回False。

>>> "12" in "123456"
True
>>> "12" not in "13456"
True

1.2.2  鏈接操做符

鏈接操做符能夠鏈接一個序列和另外一個類型相同的序列。

>>> "123" + "456"
'123456'

須要注意：①鏈接、合併字符串，更有效的辦法是把全部子字符串放到一個列表或可迭代對象中，再調用join方法；相似的，合併列表，更有效的辦法是調用列表的extend()方法。

>>> str1 = 'abc'
>>> str2 = 'def'
>>> ' '.join((str1, str2))
'abc def'
abc def
>>> list1 = list(str1)
>>> list2 = list(str2)
>>> list1.extend(list2)
>>> list1
['a', 'b', 'c', 'd', 'e', 'f']

②當僅須要簡單的合併兩個對象的內容，或者鏈接那些沒有返回值（返回None）的時候，鏈接操做符較爲簡便

1.2.3  重複操做符

重複操做符返回一個新的、包含多份原對象拷貝的對象，用於須要一個序列的多份拷貝時，如例：

>>> "12" * 3
"121212"
>>> [12,13] * 3
[12,13,12,13,12,13]

重複操做符鏈接的非列表對象必須是整型，不能是長整型

1.2.4  切片操做符

①用方括號[]加下標能夠訪問序列的每個元素；方括號[]中用冒號:把開始下標和結束下標分開能夠訪問序列的一組元素，這種訪問序列的方式就叫作切片

②訪問單個元素

語法：sequence[index]

index能夠是正數也能夠是負數，區別在於正數從序列的開始爲起點，負數從序列的結束爲起點，故index爲正數時範圍是0<=index<=len(sequence)-1;負數範圍是-len(sequence)<=index<=-1

且

sequence[len(sequence)-1] = sequence[-1]    sequence[0] = sequence[-len(sequence)]

③訪問一組元素

當給出用冒號分割的開始和結束索引值時，能夠訪問一組元素。

語法：sequence[start_index:end_index]

起始索引和結束索引都是可選的，若是沒有提供或者用None做爲參數，則從序列的開始處開始，或者到序列的最後結束

1.2.5  切片擴展

序列切片的第三個可選操做是選擇步長

語法  sequence[start_index:end_index:step]

如：

>>> a = [1,2,3,4,5,6]
>>> a[::-1]
[6,5,4,3,2,1]    #翻轉操做
>>> a[::2]
[1,3,5]      #隔一個取一個

 1.2.6  切片索引

切片索引語法靈活，即便開始和結束的索引值超過字符串的長度也不要緊。

例子①  對一個字符串，經過循環每次把位於最後的一個字符砍掉，下面是一種實現方法

s = 'abcdefg'
i = -1
for i in range(-1,-len(s),-1):
    print s[:i]

②若需在第一次迭代時顯示整個字符串，則可以下修改

s = 'abcdefg'
i = -1
for i in [None] + range(-1,-len(s),-1):
    print s[:i]

1.3  內建函數

1.3.1  類型轉換

list()  把可迭代類型轉換爲列表：

>>> list("123456")
['1','2','3','4','5','6']

str()  把對象轉換成字符串

>>> str(123)
'123'
>>> str([1,2,3])
'[1,2,3]'

str()在輸出對象的可打印信息時頗有用；

list()和tuple()函數在用於列表和元組的互換時頗有用

轉換類型函數說明：

1.3.2  可操做

 Python爲序列類型提供的內建可操做函數包括如下各類，其中len();  reversed();  sum()函數只能接受序列類型做爲參數。剩下的能夠做爲可迭代對象做爲參數。max()、min()函數還能夠接受一個參數列表

2.字符串和操做符

2.1  標準類型操做符

字符串作比較操做時，字符串是按照ASCII碼值比較的

2.2  序列操做符切片

①正向索引範圍從0到len()-1;反向索引範圍從-1到-len()

2.3  成員操做符 in / not in

①成員操做符用於判斷一個字符和字符串是否出如今另外一個字符串中，出現返回True，不然返回False

>>> 'ab' in 'abc'
True
>>> 'ab' in 'bcde'
False
>>> 'ab' not in 'abc'
False
>>> 'ab' not in 'bcde'
True

②string模塊中預約義的方法

>>> import string
>>> string.uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.lowercase
'abcdefghijklmnopqrstuvwxyz'
>>> string.letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.digits
'0123456789'

標識符檢查例子（idcheck.py）

import string

alphas = string.letters + '_'
nums = string.digits

print "Welcome to the Identifier Checker v1.0"
print "Testees must be at least 2 chars long."
myInput = raw_input("Identifier to test? ")

if len(myInput) < 2:
    print "Testees must be at least 2 chars long!"

elif len(myInput) >= 2:
    
    if myInput[0] not in alphas:
        print '''invalid: first symbol must be
            alphabetic'''
            
    else:
        for otherChar in myInput[1:]:
        
            if otherChar not in alphas + nums:
                print '''invalid: remaining
                    symbol must be alphabetic'''
                break
        else:
            print "Okay as an identifier"

注①：這裏用到了for-else結構。for遍歷循環能夠有可選的一個else分支語句，在循環迭代正常完成後執行，即除非以正常方式結束循環，不然其餘任意方式（如break）退出循環時，else分支不會被執行。看下面的例子

>>> for i in range(5)：
...     print i
... else:
...     print "This will print."
...
0
1
2
3
4
This will print
>>>
>>> for i in range(5):
...     if i >= 3:
...         break
...     print i
... else:
...     print "This will not print."
...
0
1
2
>>>

注②通常來講，從性能的角度來考慮，重複操做做爲參數在循環體裏面是很低效的 因此咱們能夠對例子裏的某段代碼作出修改

# 原代碼
# for otherChar in myInput[1:]:    
#     if otherChar not in alphas + nums:
#         pass

# 修改後代碼
alphasnums = alphas + nums

for otherChar in myInput[1:]:
    if otherChar not in alphasnums"
        pass

2.4  鏈接符 "+"

字符串的upper() lower() 方法

>>> Upp = 'ABC'
>>> Low = 'abc'
>>> Upp.lower()
'abc'
>>> Low.upper()
'ABC'

3.  只適用於字符串的操做符

3.1  格式化操做符（%）  格式化字符串

3.1.1  字符串格式化符號

A.字符串格式化的符號

B.格式化操做符輔助指令

 

Python支持兩種格式的輸入參數，一種是元組形式，一種是字典形式。

元組形式的例子：

>>> "%x" % 108
'6c'
>>> "%X" % 108
'6C'
>>> "%#X" % 108    # 八進制數前顯示'0'，十六進制前面顯示'0x'或'0X'
'0X6C'
>>> "%#x" % 108    # x輸出小寫，X輸出大寫
'0x6c'
>>> '%f' % 1234.567890
'1234.567890'
>>> '%.2f' % 1234.567890    # 小數點後保留兩位
'1234.57'
>>> '%08.2f' % 1234.567890  # 小數點後保留2位，且最小顯示寬度爲8，小數點算一位，不足8位用0補充
'01234.57'
>>> '%8.2f' % 1234.567890   # 小樹點後保留2爲，且最小寬度爲8，小數點算一位，不足8位空格補充
' 1234.57'
>>> '%g' % 1234.567890
'1234.57'    # %g會根據值得大小選擇%e或%f控制輸出，且輸出最多保留6位有效數字
>>> '%g' % 1.234567890
'1.23457'
>>> '%g' % 12345678.9
'1.23457e+07'
>>> '%e' % (111111111111L)
'1.111111e+11'

字典形式的例子：

>>> 'There are %(howmany)d %(lang)s Quotation Symbols' % {'lang': 'Python', 'howmany': 3}
'There are 3 Python Quotation Symbols'

3.2  字符串模版：更簡單的替代品

新式的字符串Template對象能夠替代字典形式的字符串格式化，有兩個方法：substitute()和safe_substitute()。前者更加嚴謹，缺乏key時報錯；後者缺乏對應的key則會原封不動的顯示出來。

>>> from string import Template
>>> s = Template('There are ${howmany} ${long} Quotation Symbols')
>>> 
>>> print s.substitute(lang='Python', howmany=3)
There are 3 Python Quotation Symbols
>>> print s.safe_substitute(lang='Python')
There are ${howmany} Python Quotation Symbols

3.3  原始字符串操做符

在字符串引號前加r或R，則對字符串中的轉義字符默認不處理

>>> print '\n'


>>> print r'\n'
\n

3.4  內建函數

3.4.1  序列類型函數

len()  max()  min()  enumerate()    zip()函數均適用於字符串

>>> str1 = 'abc'
>>> len(str1)
3
>>> str2 = 'lmn'
>>> str3 = 'xyz'
>>> max(str2)
'n'
>>> min(str3)
'x'
>>> s = 'Python'
>>> for i, t in enumerate(s):
...     print i, t
...
0 P
1 y
2 t
3 h
4 o
5 n
>>> s, t = 'Pyt', 'hon'
>>> zip(s,t)
[('P', 'h'), ('y', 'o'), ('t', 'n')]

3.5  字符串內建方法

字符串內建方法可參考下列表

下面是一些例子

>>> quest = 'what is your favorite color?'
>>> quest.capitalize()
'What is your favorite color?'      
>>>
>>> quest.center(40)
'      What is your favorite color?      '
>>>
>>> quest.count('or')
2
>>>
>>> quest.endswith('or')
False
>>> quest.endswith('or?')
True
>>>
>>> quest.find('or')
16
>>> quest.find('ro')
-1
>>> quest.find('or',18)
25
>>>
>>> quest.index('or',0,18)
16
>>>
>>> alnum = 'abc123'
>>> notalnum = 'abc 123'
>>> alpha = 'abc'
>>> num = '123'
>>> num_hex = '017'
>>> num_oct = '0X17'
>>> alnum.isalnum()
True
>>> notalnum.isalnum()
False
>>> alpha.isalpha()
True
>>> alnum.isalpha()
False
>>> u'123'.isdecimal()
True
>>> u'0X17'.isdecimal()
False
>>> alpha.isdigit()
False
>>> num.isdigit()
True 
>>> quest.islower()
True 
>>> quest.capitalize().islower()
False
>>> quest.isspace()
False
>>> '  '.isspace()
True
>>> quest.istitle()
False
>>> quest.title().istitle()
True
>>> quest.isupper()
False
>>> quest.upper().isupper()
True
>>> ':'.join(quest.split())
'what:is:your:favorite:color?'
>>> quest.ljust(40)
'what is your favorite color?            '
>>> '   abc'.lstrip()
'abc'
>>> quest.partition('or')
('what is your fav', 'or', 'ite color?')
>>> quest.split('or')
['what is your fav', 'ite col', '?']
>>> quest.replace('or', 'OR')
'what is your favORite colOR?'
>>> 
>>> quest.rjust(40)
'            what is your favorite color?'

3.6 字符串的獨特特性

3.6.1  特殊字符串和控制字符

①一個反斜線"\"加一個單一字符能夠表示一個特殊字符，一般是一個不可打印的字符，這就是轉義的功能

②轉義字符表

③單獨的反斜線做爲連字符，將本行和下一行的內容鏈接起來

>>> print "This a \
... sentence \
... and \
... this."
This is a sentence and this.

3.6.2  三引號

①Python的三引號容許一個字符串跨多行，字符串中能夠包含換行符、製表符以及其餘特殊字符

3.7  編碼問題

3.7.1  raw_input在Windows系統的命令後模式下偶有中文提示語言亂碼問題，緣由在於Windows的CMD輸出的編碼問題，以下操做便可

>>> # -*- coding:utf-8 -*-
>>> print u'中文測試'
中文測試
>>> raw_input(u'中文測試'.encode('gbk'))
中文測試_

3.7.2  一個例子

'''
An example of reading and writing Unicode strings:Writes
a Unicode string to file in utf-8 and reads it back in.
'''
CODEC = 'utf-8'
FILE = 'Unicode.txt'

hello_out = u"Hello world\n"
bytes_out = hello_out.encode(CODEC)
f = open(FILE, 'w')
f.write(bytes_out)
f.close()

f = open(FILE, 'r')
bytes_in = f.read()
f.close()
hello_in = bytes_in.decode(CODEC)
print hello_in,

3.7.3  實際應用中的建議

    ①程序中出現字符串是在前面加前綴"u"

    ②用unicode()代替str()函數

    ③非必要時不要編解碼Unicode字符。只有在寫入文件/數據庫/網絡時才調用encode()函數；相應的，須要把數據讀取回來時才使用decode()函數

    ④Python標準庫裏面大部分模塊都支持Unicode,但pickle模塊不支持，因此最好避免基於文本的pickle操做

    ⑤假設構建一個用數據庫來讀寫Unicode數據的web應用，爲了支持Unicode，必須確保如下方面對Unicode的支持：

            A.數據庫服務器（MySQL等）

            B.數據庫適配器

            C.web開發框架            

3.8  相關模塊

下表列出了Python標準庫裏面與字符串有關的模塊

3.9  列表

①更新列表能夠經過在等號左邊指定一個索引或一個索引範圍，也能夠經過append()方法

>>> a_list = [123, 456, 789, 'abc', 'def']
>>> a_list[2] = 'hhh'
>>> a_list
[123, 456, 'hhh', 'abc', 'def']
>>> a_list.append('I am the new')
>>> a_list
[123, 456, 'hhh', 'abc', 'def', 'I am the new']

②刪除列表中的元素，能夠用del語句和remove方法及pop方法，經過例子來看不一樣

>>> a_list
[123, 456, 'hhh', 'abc', 'def', 'I am the new']
>>> del a_list[2]
>>> a_list
[123, 456, 'abc', 'def', 'I am the new']
>>> a_list.remove(123)
>>> a_list
[456, 'abc', 'def', 'I am the new']
>>> a_list.pop()
>>> a_list
[456, 'abc', 'def']
>>> a_list.pop(1)
[456, 'def']

3.10  操做符和內建函數

3.10.1  標準類型操做符

標準類型操做符比較兩個列表時，兩個列表的每一個元素分別比較，直到有一方的元素勝出爲止。

3.10.2  列表類型操做符和列表解析

列表解析結合了列表的方括弧和for循環

>>> [i ** 3 for i in [8, -2, 5]]
[512, -8, 125]
>>> [i * 3 for i in 'abcde']
['aaa', 'bbb', 'ccc', 'ddd', 'eee']

3.10.3  cmp()函數比較

cmp()比較兩個列表的算法以下：

    ①對兩個列表的每一個元素逐一進行比較

    ②若是比較的元素是同類型的，則比較其值並返回結果

    ③若不是同一類型，則檢查他們是不是數字：

        A。若是是數字，則進行必要的強制類型轉換，而後比較

        B。若是隻有一方的元素是數字，則另外一方的元素"大"（數字是"最小的"）

        C。不然，經過類型名字的字母順序進行比較

    ④若是有一個列表首先達到末尾，則另外一個長一點的元素大

    ⑤若是兩個列表都達到末尾且全部元素都相等，則返回0即斷定兩個列表相等

3.10.4  序列類型函數

    ①len()函數返回列表或元組元素個數，每一個對象都做爲一項來處理

    ②max()和min()返回列表或元組各元素中最大或最小的項

    ③函數reversed()對列表或詞典進行翻轉；sorted()對列表排序

>>> s = ['They', 'stamp', 'them', 'when', "They're", 'small']
>>> for t in reversed(s):
...     print t,
...
small They're when them stamp They
>>> sorted(s)
['They', "They're", 'small', 'stamp', 'them', 'when']

    ④enumerate()和zip()

>>> albums = ['tales', 'robot', 'pyramid']
>>> for i, album in enumerate(albums):
...     print i, album
...
0 tales
1 robot
2 pyramid
>>> fn = ['ian', 'stuart', 'david']
>>> ln = ['bairnson', 'elliott', 'paton']
>>>
>>> for i, j in zip(fn, ln):
...     print ('%s %s' % (i, j)).title() 
...
Ian Bairnson
Stuart Elliott
David Paton

    ⑤sum()

>>> a = [12, 3, 4]
>>> sum(a)
19
>>> sum(a, 1)
20
>>> import operator
>>> reduce(operator.mul, a)
144

    注：reduce()是內建函數，接收的第一個參數是一個二元操做函數，接受的第二個參數是一個列表或元組，先對列表或元組中的第1和第2個元素利用給定函數進行操做，獲得的結果再與第3個元素利用給定函數計算，最終獲得一個結果。

3.11  列表的內建方法

    3.11.1  列表內建方法表

下面是使用這些方法的例子

>>> music_media = [45]
>>> music_media
[45]
>>> music_media.append('long playing record')
>>> music_media
[45, 'long playing record']
>>> music_media.count(45)
1
>>> music_media.count('Hello')
0
>>> music_media.extend(['Hello'])
>>> music_media
[45, 'long playing record', 'Hello']
>>> music_media.index(45)
0
>>> music_media.index('H')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'H' is not in list 
>>> music_media.insert(1, 46)
>>> music_media
[45, 46, 'long playing record', 'Hello']
>>> music_media.pop(1)
46
>>> music_media
[45, 'long playing record', 'Hello']  
>>> music_media.remove(45)
>>> music_media
['long playing record', 'Hello']
>>> music_media.reverse()
>>> music_media
['Hello', 'long playing record']
>>> music_media.extend('Hello')
>>> music_media.sort()
>>> music_media
['H', 'Hello', 'e', 'l', 'l', 'long playing record', 'o']