Python語言簡介

list
清單(列表,list)的用法。

# list operation
a=[0,1,2,3,4,5,6,7]
print 'a=',a
print 'a[1:5]=',a[1:5]   # a的第2~5的元素。
print 'a[1:5:2]=',a[1:5:2]   # a的第2~5每隔2的元素。
print 'len(a)=',len(a)	 # a 的元素個數。
print 'max(a)=',max(a)	# a 的最大元素。
print 'min(a)=',min(a)	# a 的最小元素。
print '3 in a:', 3 in a	# 3在a之中。True
print '8 in a:', 8 in a	# 8在a之中。False
print '9 not in a:', 9 not in a	# 9不在a之中。True
c=['x','y','z']	
print 'a+c=',a+c	# 將清單a與清單c結合。

b=a*3		# a的內容擴充為原來的3倍。
print 'b=',b

L1=list('python')	#將字串轉換為清單。
print 'L1=',L1

L2=[[1,2],[3,4],[5,6],7,8]
print 'L2=',L2
print 'L2[2][0]=',L2[2][0]  # 取出巢狀清單之特定元素(L2的第3元素之第1元素)

L2[1]='YCC'	# 將L2的第2元素取代為字串'YCC'。
print 'L2=',L2

L2[1]=L2[1]*3	# 將L2的第2元素擴充為原來的3倍。
print L2

L2[1:4]=[]	# 將L2的第2~4元素清空。
print 'L2-delete=',L2

####### 清單的常用涵數
####### list function: append(object), extend(L), insert(index,object),
####### remove(value), sort(), count(value), pop(index)

L2.append(12)	# 從L2的最後增加一元素12。
print 'append, L2=',L2
L2.pop(1)	# 將L2的第2元素抽去。
print 'pop L2=',L2
L2.insert(1,'THU')	# L2的第2元素前插入'THU'
print 'inset, L2=',L2

L1=[1,3,2,4,5,2,6,3,1,2]
L1.sort()	# L1的元素從小到大排列。
print L1
n=L1.count(2)	# L1中2出現的次數。
print n

print 'L1=',L1
print 'L2=',L2
L1.extend([1,2,3])	# 將清單L1
print 'L1=',L1
print 'L2=',L2
L1.extend(L2)	# 將清單L1從後方加入L2
print 'L1.extend(L2)=',L1

Please compare the 2 prints of the code below.

A=[1,2,3,4,5,'\n']
for x in A:
    print x,

for x in A:
    print x
###################the output:
1 2 3 4 5 
1
2
3
4
5

list的應用1.

list在向量的應用

a=[1,2,1]
b=[1,2,3]
# 向量的長度
a1=sum(a[i]**2 for i in range(3))
b1=sum(b[i]**2 for i in range(3))
print a1,b1,a1**0.5,b1**0.5
# 向量的內積
sc=sum(a[i]*b[i] for i in range(3))
print 'a dot b=',sc
# 向量的外積
c=[0 for i in range(3)]
c[0]=a[1]*b[2]-a[2]*b[1]
c[1]=a[2]*b[0]-a[0]*b[2]
c[2]=a[0]*b[1]-a[1]*b[0]
print 'c=a x b=',c

list的應用2:排序

1. 基本排序:單筆數據

a=[2,5,3,4,6,1]
b=[]
for i in range(len(a)):
    b.append(min(a))
    a.remove(min(a))
print 'b=',b

2. 多筆數據排序

def sort2(e,N1,N2,x):
    ee=[]
    for i in range(N1):
        e1=[]
        e1.append(e[i][x])
        for j in range(N2):
            e1.append(e[i][j])
        ee.append(e1)
    ee.sort()
    es=[]
    for i in range(N1):
        ee[i].pop(0)
        es.append(list(ee[i]))
    return es

N1=4
N2=3
x=2
e1=[[2,300,5],[1,400,3],[4,100,2],[3,200,6]]
print 'e1=',e1
e2=sort2(e1,N1,N2,x)
print 'e2=',e2

3. 從檔案輸入數據排序：

def sort2(e,N1,N2,x):
    ee=[]
    for i in range(N1):
        e1=[]
        e1.append(e[i][x])
        for j in range(N2):
            e1.append(e[i][j])
        ee.append(e1)
    ee.sort()
    es=[]
    for i in range(N1):
        ee[i].pop(0)
        es.append(list(ee[i]))
    return es

####################data read in from a file########
f=open('data.txt','r')
a=f.read()
b=a.split()
N1=8
N2=5
x=0
dat1=[]
for i in range(len(b)):
    dat1.append(float(b[i]))
print 'dat1=',dat1
dat2=[]
for i in range(N1):
    L=[]
    for j in range(N2):
        n=i*N2+j
        L.append(dat1[n])
    dat2.append(L)
dat3=sort2(dat2,N1,N2,x)
print 'dat3=',dat3

4. 元組(tuple)

在這篇文章中，您將學習有關Python元組的一切。更具體地說，什麼是元組，如何創建它們，何時使用它們以及您應該熟悉的各種方法。在Python編程中，元組與列表類似。兩者之間的區別在於，一旦賦值就不能改變元組的元素，而在列表中可以改變元素。因為元組與列表非常相似，所以它們在相似的情況下也是相同的。但是，在列表上實現元組有一定的優勢。下面列出的是一些主要的優點：我們通常將元組用於異構（不同）數據類型，並列出同類（類似）數據類型。由於元組是不可變的，所以通過元組迭代比列表快。所以有一點提升。包含不可變元素的元組可以用作字典的關鍵字。隨著名單，這是不可能的。如果你的數據沒有改變，那麼把它作為元組來實現將保證它仍然是寫保護的。創建一個元組通過將所有項（元素）放在圓括號（）中創建一個元組，用逗號分隔。括號是可選的，但是寫一個很好的做法。一個元組可以有任意數量的項目，它們可以是不同的類型（整數，浮點數，列表，字符串等）。

# 空元組
# Output: ()
my_tuple = ()
print(my_tuple)

# 具有整數的元組
# Output: (1, 2, 3)
my_tuple = (1, 2, 3)
print(my_tuple)

# 具有混合數據類型的元組
# Output: (1, "Hello", 3.4)
my_tuple = (1, "Hello", 3.4)
print(my_tuple)

# 嵌套元組
# Output: ("mouse", [8, 4, 6], (1, 2, 3))
my_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
print(my_tuple)

#元組可以創建沒有括號
#也叫tuple包裝
#輸出：3，4.6，“狗”


my_tuple = 3, 4.6, "dog"
print(my_tuple)

# 元組拆包也是可以的
# Output:
# 3
# 4.6
# dog
a, b, c = my_tuple
print(a)
print(b)
print(c)

我們可以使用索引操作符[]來訪問索引從0開始的元組中的項目。因此，具有6個元素的元組將具有從0到5的索引。嘗試訪問除（6,7，...）以外的元素將引發IndexError。索引必須是一個整數，所以我們不能使用float或其他類型。這將導致TypeError。同樣，使用嵌套索引訪問嵌套元組，如下例所示。

my_tuple = ('p','e','r','m','i','t')

# Output: 'p'
print(my_tuple[0])

# Output: 't'
print(my_tuple[5])

# index must be in range
# If you uncomment line 14,
# you will get an error.
# IndexError: list index out of range

#print(my_tuple[6])

# index must be an integer
# If you uncomment line 21,
# you will get an error.
# TypeError: list indices must be integers, not float

#my_tuple[2.0]

# nested tuple
n_tuple = ("mouse", [8, 4, 6], (1, 2, 3))

# nested index
# Output: 's'
print(n_tuple[0][3])

# nested index
# Output: 4
print(n_tuple[1][1])

我們可以通過使用切片運算符 - 冒號“：”來訪問元組中的一系列項目。

my_tuple = ('p','r','o','g','r','a','m','i','z')

# elements 2nd to 4th
# Output: ('r', 'o', 'g')
print(my_tuple[1:4])

# elements beginning to 2nd
# Output: ('p', 'r')
print(my_tuple[:-7])

# elements 8th to end
# Output: ('i', 'z')
print(my_tuple[7:])

# elements beginning to end
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
print(my_tuple[:])

我們可以使用關鍵字in來測試一個物件是否存在於一個元組中。

my_tuple = ('a','p','p','l','e',)
# Count
# Output: 2
print(my_tuple.count('p'))
# Index
# Output: 3
print(my_tuple.index('l'))

my_tuple = ('a','p','p','l','e',)
# In operation
# Output: True
print('a' in my_tuple)
# Output: False
print('b' in my_tuple)
# Not in operation
# Output: True
print('g' not in my_tuple)

我們不能改變元組中的一個元素

my_tuple = (4, 2, 3, [6, 5])

#我們不能改變一個元素
#如果您取消註釋 # my_tuple [1] = 9
#你會得到一個錯誤：
# TypeError: 'tuple' object does not support item assignment

# my_tuple[1] = 9

# 但可變元素的項目可以改變
# Output: (4, 2, 3, [9, 5])
my_tuple[3][0] = 9
print(my_tuple)
# 元組可以被重新分配
# Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
my_tuple = ('p','r','o','g','r','a','m','i','z')
print(my_tuple)

# Output: 
# Hello John
# Hello Kate
for name in ('John','Kate', 'Emily'):
     print("Hello",name)