列表和元組

# coding:utf-8

#--------------------------------------   通用序列操做  -----------------------------------------------

#索引

greeting = 'Hello'

print greeting[0]          #第一位是0

#H

print greeting[-1]          #最後一位是-1，不是-0

#o

print 'Hello'[1]            #字符串字面值直接使用索引，和上面方法效果同樣

#e

#fourth = raw_input('Year: ')[3]     #函數返回序列使用索引，只拿取第四位字符

#Year: 2005

#print fourth

#5

#實例腳本詳見date.py

#分片

#分片經過冒號隔開的兩個索引來實現：

tag = '<a href="http://www.python.org">Python web site<\a>'

print tag[9:30]

#http://www.python.org

print tag[32:-4]

#Python web sit

numbers = [1,2,3,4,5,6,7,8,9,10]

print numbers[3:6]

#[4, 5, 6]

print numbers[0:1]

#[1]

print numbers[7:10]     #索引10指向第11個元素，這個元素不存在，倒是在最後一個元素以後

#[8, 9, 10]

print numbers[-3:-1]   #倒數方式，沒法取得最後一位

#[8, 9]

print numbers[-3:]     #取得最後一位方式

#[8, 9, 10]

print numbers[:3]      #從第一位開始

#[1, 2, 3]

print numbers[:]

#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#腳本例子

#對http://www.abc.com 形式的URL進行分割

#url = raw_input('Please enter the URL: ')        #須要輸入URL，好比http://www.abc.com

#domain = url[11:-4]

#print "Domain name: " + domain

#Please enter the URL: http://www.abc.com

#Domain name: abc

#更大的步長

numbers = [1,2,3,4,5,6,7,8,9,10]

print numbers[0:10:1]       #步長爲1

#[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print numbers[0:10:2]      #步長爲2

#[1, 3, 5, 7, 9]

print numbers[3:6:3]

#[4]

print numbers[::4]          #每4個元素第一個提取出來

#[1, 5, 9]

print numbers[8:3:-1]       #步長負數就是倒着來

#[9, 8, 7, 6, 5]

print numbers[10:0:-2]

#[10, 8, 6, 4, 2]

print numbers[0:10:-2]      #步長負數正着來沒法顯示

#[]

print numbers[::-2]

#[10, 8, 6, 4, 2]

print numbers[5::-2]

#[6, 4, 2]

print numbers[:5:-2]

#[10, 8]

#序列相加

numbers = [1,2,3] + [4,5,6]

print numbers

#[1, 2, 3, 4, 5, 6]

numbers = 'Hello, ' + 'world!'

print numbers

#Hello, world!

#numbers = [1,2,3] + 'word!'     #列表和字符串沒法鏈接一塊兒，會報錯

#print numbers

#乘法

print 'python' * 5      #重複5次

#pythonpythonpythonpythonpython

print [42] * 10

#[42, 42, 42, 42, 42, 42, 42, 42, 42, 42]

sequence = [None] * 10      #None表明空列表

print sequence

#[None, None, None, None, None, None, None, None, None, None]

#判斷成員資格

#爲了檢查一個值是否在序列中，可使用in運算符。

permissions = 'rw'

if 'w' in permissions: print True

#True

if 'x' not in permissions: print False

#False

#users = ['mlh', 'foo', 'bar']

#if raw_input('Enter your user name: ') in users: print True

#Enter your user name: mlh

#True

subject = '$$$ Get rich now!!! $$$'

if '$$$' in subject: print True

#True

database = [

   ['albert', '1234'],

   ['dilbert', '4242'],

   ['smith', '7524'],

   ['jones', '9843']

]

#username = raw_input('User name: ')

#pin = raw_input('PIN code: ')

#if [username, pin] in database: print 'Access granted'

#User name: albert

#PIN code: 1234

#Access granted

#長度最小值最大值

numbers = [100, 34, 678]

print len(numbers)      #元素的數量

#3

print max(numbers)      #最大的元素

#678

print min(numbers)      #最小的元素

#34

print max(2, 3)         #顯示最大元素

#3

print min(9, 3, 2, 5)   #顯示最小元素

#2

#--------------------------------------------------   列表  -------------------------------------------------------

#列表是可變的，可修改。

#list函數

print list('Hello')                         #字符串轉換列表

#['H', 'e', 'l', 'l', 'o']

print ''.join(['H', 'e', 'l', 'l', 'o'])   #列表轉換字符串

#Hello

#基本列表操做

#改變列表：元素賦值

x = [1, 1, 1]           #不能爲一個位置不存在的元素進行賦值。若是列表長度爲2，那麼不能爲索引爲100的元素賦值。若是要那樣作，就必須建立一個長度爲101或者更長的列表。

x[1] = 2

print x

#[1, 2, 1]

#刪除元素

names = ['Alice', 'Beth', 'Cecil', 'Dee-Dee', 'Earl']

del names[2]        #除了刪除列表中的元素，del還能夠刪除其餘元素，好比字典元素或是其餘變量元素。

print names

#['Alice', 'Beth', 'Dee-Dee', 'Earl']

#分片賦值

name = list('Perl')

print name

#['P', 'e', 'r', 'l']

name[2:] = list('ar')

print name

#['P', 'e', 'a', 'r']

name = list('Perl')

name[1:] = list('ython')

print name

#['P', 'y', 't', 'h', 'o', 'n']

numbers = [1, 5]

print numbers

#[1, 5]

numbers[1:1] = [2, 3, 4]        #能夠在不須要替換任何原有元素的狀況插入新的元素

print numbers                   #這個程序只是「替換」了一個空的分片，所以實際的操做是插入了一個序列。

#[1, 2, 3, 4, 5]

numbers[1:4] = []           #經過分片賦值來刪除元素

print numbers

#[1, 5]

numbers[1:-1] = [2, 3, 4]

print numbers

#[1, 2, 3, 4, 5]

del numbers[1:-2]

print numbers

#[1, 4, 5]

numbers[1:-2] = [2, 3]

print numbers

#[1, 2, 3, 4, 5]

#列表方法

#方法調用：對象.方法（參數）

#append追加

lst = [1, 2, 3]         #不能夠用內建函數list做爲變量

lst.append(4)           #在列表末尾追加新的對象

print lst

#[1, 2, 3, 4]

#count統計

#count方法統計某個元素在列表中出現的次數

print ['to', 'be', 'or', 'not', 'to', 'be'].count('to')

#2

x = [[1, 2], 1, 1, [2, 1, [1, 2]]]

print x.count(1)

#2

print x.count([1,2])

#1

#extend追加列表

#extend方法能夠在列表的末尾一次性追加另外一個序列中的多個值。換句話說，能夠用新列表擴展原有的列表：

a = [1, 2, 3]

b = [4, 5, 6]

a.extend(b)

print a

#[1, 2, 3, 4, 5, 6]

#這個操做看起來很像鏈接操做，二者最主要區別在於：extend方法修改了被擴展的序列（在這個例子中，就是a）。而原始的鏈接操做則否則，它會返回一個全新的列表。

a = [1, 2, 3]

b = [4, 5, 6]

c =  a + b

print a

#[1, 2, 3]

print c

#[1, 2, 3, 4, 5, 6]

a = a + b           #這樣的並無被修改，而是建立了一個a和b副本的新列表，這樣的方式效率比較低。

print a

#[1, 2, 3, 4, 5, 6]

a = [1, 2, 3]

b = [4, 5, 6]

a[len(a):] = b      #咱們可使用分片賦值來實現相同結果，但代碼可讀性就不如使用extend方法

print a

#[1, 2, 3, 4, 5, 6]

#index 查找索引

#index方法用於從列表中找出某個值第一個匹配項的索引位置：

knights = ['We', 'are', 'the', 'knights', 'who', 'say', 'ni']

print  knights.index('who')

#4

print knights[knights.index('who')]         #同等於print knights[4]

#who

#insert 插入對象

#insert方法用於將對象插入到列表中：

numbers = [1, 2, 3, 5, 6, 7]

numbers.insert(3, 'four')

print numbers

#[1, 2, 3, 'four', 5, 6, 7]

#與extend方法同樣，insert方法的操做也能夠用分片賦值來實現。

numbers = [1, 2, 3, 5, 6, 7]

numbers[3:3] = ['Four']         #可讀性不如insert

print numbers

#[1, 2, 3, 'four', 5, 6, 7]

#pop 移除元素

#pop方法會移除列表中的一個元素（默認是最後一個），而且返回該元素的值：

x = [1, 2, 3]

print x.pop()         #默認刪除最後一個

#3

print x

#[1, 2]

print x.pop(0)

#1

print x

#[2]

#棧，先進後出FIFO隊列。就是頂部放入，底部移出。入棧（push）和出棧（pop），python沒有入棧方法，能夠用append也能夠用insert(0,...)替代。出棧能夠用pop

#remove 移除第一個匹配的元素

x = ['to', 'be', 'or', 'not', 'to', 'be']

x.remove('be')      #能夠看到remove是一個沒有返回值的原位置改變方法，它修改了列表卻沒有返回值，這與pop方法相反。

print x

#['to', 'or', 'not', 'to', 'be']

#reverse 反向存放

x = [1, 2, 3]

x.reverse()         #reverse不返回值，就像remove和sort

print x

#[3, 2, 1]

#sort 排序

#sort方法用於在原位置對列表進行排序。在「原位置排序」意味着改變原來的列表，從而讓其中的元素按必定的順序排序，而不是簡單地返回一個已排序的列表副本。

x = [4, 6, 2, 1, 7, 9]

x.sort()            #x變量的列表已經被修改，但不會返回值。

print x

#當用戶須要一個排好序的列表副本，同時又保留原有列表不變的時候，問題就出現了：

x = [4, 6, 2, 1, 7, 9]

y = x.sort()         #Don't do this!

print y

#None

#由於sort方法修改了x卻返回了空值，那麼最後獲得的是已排序的x以及值爲None的y。實現這個功能正確方法是，首先把x的副本賦值給y，而後對y進行排序：

x = [4, 6, 2, 1, 7, 9]

y = x[:]

y.sort()

print x                #保留x變量

#[4, 6, 2, 1, 7, 9]

print y                #顯示y變量的排序

#[1, 2, 4, 6, 7, 9]

#再次調用x[:]獲得的是包含了x全部元素的分片，這是一種頗有效率的複製整個列表的方法。只是簡單的把x賦值給y是沒用的，由於這樣作讓x和y都指向同一個列表了。

y = x           #指向了同一個列表

y.sort()        #x和y是同一個列表，因此列表排序後，x和y都會被排序。

print x

#[1, 2, 4, 6, 7, 9]

print y

#[1, 2, 4, 6, 7, 9]

#另外一種獲取已排序的列表副本方法是sorted函數：

x = [4, 6, 2, 1, 7, 9]

y = sorted(x)

print x         #x的列表保留不變

#[4, 6, 2, 1, 7, 9]

print y

#[1, 2, 4, 6, 7, 9]

#想把一些元素按相反方向的順序排列，能夠先使用sort（或者sorted），而後調用reverse方法。

#注意須要分兩次調用，若是打算經過x.sort().reverse()來實現，會發現行不通，由於x.sort()返回的是None空值。正確方法：

x = [4, 6, 2, 1, 7, 9]

x = sorted(x)

x.reverse()

print x

#高級排序

print cmp(42, 32)    #42比32大，返回正數

#1

print cmp(99, 100)   #99比100小，返回負數

#-1

print cmp(10, 10)    #相等返回0

#0

numbers = [5, 2, 9, 7]

numbers.sort(cmp)      #根據cmp函數方式排序

print numbers

#[2, 5, 7, 9]

x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']

x.sort(key=len)         #根據key進行排序，key須要建立一個鍵函數，根據len鍵字符長度排序

print x

#['add', 'acme', 'aerate', 'abalone', 'aardvark']

x = [4, 6, 2, 1, 7, 9]

x.sort(reverse=True)    #reverse反向排序，指明True反向排序，指明False正向排序

print x

#[9, 7, 6, 4, 2, 1]

#--------------------------------   元組   ---------------------------------------------------

#元素不可變，沒法修改

#建立元組

x = 1, 2, 3

print x

#(1, 2, 3)

x = (1, 2, 3)

print x

#(1, 2, 3)

x = ()          #空元組

print x

#()

x = 42,         #一個值的元組，也須要逗號

print x

#(42,)

x = (42, )

print x

#(42,)

x = 42          #沒有逗號不是元組

print x

#42

x = 3*(40+2)      #不是元組

print x

#126

x = 3*(40+2, )    #是元組。逗號很重要，加個逗號能完全改變表達式的值。

print x

#(42, 42, 42)

#tuple 轉換爲元組

print tuple([1, 2, 3])      #列表轉換元組

#(1, 2, 3)

print tuple('abc')          #字符串轉換元組

#('a', 'b', 'c')

print tuple((1, 2, 3))      #自己是元組，返回一樣元組

#(1, 2, 3)

#元組基本操做

#元組其實並不複雜--除了建立元組的訪問元組元素以外，沒有太多其餘操做。

x = 1, 2, 3

print x[1]

#2

print x[0:2]                #元組的分片仍是元組，就像列表的分片仍是列表同樣

#(1, 2)

#涉及的函數

#cmp(x,y)           #比較兩個值

#len(seq)           #返回序列的長度

#list(seq)          #把序列轉換成列表

#max(args)          #返回序列或者參數集合中的最大值

#min(args)          #返回序列或者參數集合中的最小值

#reversed(seq)      #對序列進行反向迭代

#sorted(seq)        #返回已排序的包含seq全部元素的列表

#tuple(seq)         #把序列轉換成元組