python——序列構成的數組

 序列構成的數組Demo1列表推導計算笛卡爾積

# -*- coding: utf-8 -*-
colors = ['black','white']
sizes = ['S','M','L']
tshirts = [(color,size)for color  in colors for size in sizes]
print(tshirts)
print("-----------------------------")


for   color  in colors :
    for size  in sizes:
        print((color,size))
        
print("-------------------------------")
tshirts = [(color,sizes) for  size in sizes for  color  in colors]
print(tshirts)

        

 序列構成的數組Demo2使用生成器計算笛卡爾積

# -*- coding: utf-8 -*-
colors = ['black','white']
sizes = ['S','M','L']
for tshirt in ('%s %s'%(c,s)for c in colors for s in sizes):
    print(tshirt)

 序列構成的數組Demo3把元組用作記錄

# -*- coding: utf-8 -*-
lax_coordinates = (33.9425,-118.408056) 
city,year,pop,chg,area = ('Tokyo',2019,32450,0.66,8014)
traveler_ids = [('USA','3143125'),('China','346277666'),('ESP','6343223')]
for  passport in sorted(traveler_ids):
    print("%s/%s"%passport)
    
print("---------------------------------")   
for  country,_ in  traveler_ids:     
    print(country)


#一個元組列表，元組的形式爲（country_code,passport_code)
#在迭代的過程中passport被綁定在每一個元組上
#格式%運算符能被匹配到對應的元組上
#for 循環可以分別提取元組裏的元素，也叫做拆包。
#因爲元組中的第二個元素對我們沒有什麼用，所以給他賦值"_"佔位符
    

 序列構成的數組Demo4元組拆包

# -*- coding: utf-8 -*-
#元組拆包形式一：平行賦值
lax_coordinates = (33.9435,-180.9665)
latitude,longitude = lax_coordinates
print(latitude)
print(longitude)

#形式二：不使用中間變量交換兩個變量的值
a,b = b,a

#形式三：可以用*運算符把一個可迭代對象拆開作爲函數的參數
divmod(20,8)

t = (20,8)
divmod(*t)
quotient,remainder = divmod(*t)
print(quotient,remainder)

#形式四： 讓一個個函數可以用元組的形式返回多個值，
#然後調用函數的代碼就能輕鬆接受這些返回值了
import os
_,filename = os.path.split('/home/luciano/.ssh/idrsa.pub')
filename

#形式五 函數用*args來獲取不確定數量的參數
a,b,*rest = range(5)
print(a,b,rest)

#在平行賦值中，*前綴只能用在一個變量名的前面，
#但是這個變量名可以出現在賦值表達式的任意位置
a,*body,c,d = range(5)
print(a,body,c,d)

#嵌套元組拆包
metro_areas = [
        ('Tokyo','JP','36.933',(35.689722,139.691667)),
        ('Delhi NCR','IN',21.935,(28.613889,77.208889)),
        ('Mexico City','MX',20.142,(19.433333,-99.133333)),
        ('New  York-New','US',20.104,(40.252564,-74.2043632)),
        ('Sao Paulo','BR',19.649,(-23.363777,-46.4737257)),
        ]
print ('{:20} |{:^9}|{:^9}'.format('','lat.','long'))
fmt = '{:20}  |{:9.4f}  |{:9.4f}'
for  name,cc,pop,(latitude,longititude) in  metro_areas:
    print(fmt.format(name,latitude,longititude))

 序列構成的數組Demo5之具名元組

# -*- coding: utf-8 -*-
# 1：定義和使用具名函數
"""
collections.namedtuple 是一個工廠函數，
可以用來構建一個帶字名段的元組和一個有名字的類
"""
from collections import  namedtuple
City = namedtuple("City","name country population coordinates")  # 
tokyo = City("Tokyo","JP",933,(35.689722,139.695745))  #  2
print(tokyo)
print(tokyo.population ) #  3
print(tokyo.coordinates)
print(tokyo[1])
"""
  1:創建一個具名元組需要兩個參數，一個是類名，另一個是類的各個字段的名字。
    後者可以是由數個字符串組成的可迭代對象，或者是由空格分隔開的字段名組成的字符串
  2:存放在對應字段裏的數據要以一串參數的形式傳入到構造函數中，（元組的構造函數卻只接受單一的可迭代對象）
  3：可以通過字段名或者位置來獲取一個字段的信息
"""
# 2：具名元組的屬性和方法

City._fields  #  1
LatLong= namedtuple('LatLong','lat long')
delhi_data = ("China","in",21.935,LatLong(28.61456,77.63456457))
delhi = City._make(delhi_data)  # 2
delhi._asdict()   # 3
OrderedDict(([('name','China'),('country','in'),
              ('population',21.2345),('coordinates',
              LatLong(lat =28.6145,long =77.6345645))])
for key,value in  delhi._asdict().items():
    print(key +':',value)
 """
 1:_fileds屬性是一個包含這個類所有字段名稱的元組
 2：用——make（）通過接受一個可迭代對象來生成這個類的實例，他的作用跟City(*delhi_data)一樣
 3：_asdict()把具名元組以collections.OrderedDict的形式返回

序列構成的數組Demo6切片

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

#  純文本文件形式的收據以一行字符串的形式被解析

invoice = """
...0.....6.........................40.........52...55..........
1909  Pimoroni PiBrella              $17.50   3   $52.50
1489  6mm   Tactile Switch  x20      $4.95    2   $9.50
1510  Panavise  Jr.-PV-201           $28.00   1   $28.00
1601  PiTFT  Mini Kit 320x240        $34.95   1   $34.95
"""
SKU = slice(0,6)
DESCRIPTION = slice(6,40)
UNIT_PRICE = slice(40,52)
QUANTITY = slice(52,55)
ITEM_TOTAL = slice(55,None)
line_items = invoice.split('\n')[2:]
for  item in line_items:
    print(item[UNIT_PRICE],item[DESCRIPTION])

"""
給切片賦值
"""
l = list(range(10))
l
l[2:5] = [20,30]
l
del l[5:7]
l
l[3::2] = [11,22]
l
l[2:5] =100   #  1
l
l[2:5]= [100]

"""
如果賦值的對象是一個切片，那麼賦值語句的右側必須是一個可迭代的對象（list，tuple，str）
即便有單獨的一個指，也要把他轉化成可迭代的序列
"""

序列構成的數組Demo7建立由列表組成的列表

 

# -*- coding: utf-8 -*-
board = [['']*3 for i  in range(3) ]  #  1
print(board)
print(board[1][2] = 'X' ) #  2
"""
1：建立一個包含3個列表的的列表，被包含的3個列表各自有3個元素。
2：把第一行第二列的元素標記爲X，再打印出這個列表

"""

# 含有三個指向同一對象的引用的列表是毫無用處的
weird_board = [['_']*3]*3  #  1 

print(weird_board)
weird_board[1][2] = '0'  #   2
print(weird_board)
"""
1: 外面的列表其實包含3個指向同一列表的引用。
2：當我們嘗試修改[1][2]的元素，就暴露了列表內3個元素指向同一位置的事實  
"""

序列構成的數組Demo8序列的增量賦值

# -*- coding: utf-8 -*-
l = [1,2,3]
print(id(l))   #  1
l*=2
iprint(d(l))   #  2
t = (1,2,3)
print(id(t) )  #  3
t *=2
print(id(t))     #   4
 """
  1.剛開始時的列表id
  2。運用增量懲罰後，列表id沒變，新元素追加到列表上
  3.元組最開始的id
  4.運用增量後，新的元組被創建
  """
  

序列構成的數組Demo9用bisect來管理已排好的序列

# -*- coding: utf-8 -
"""
import  bisect
import sys
HAYSTACK = [1, 4, 5, 6, 8, 12, 15, 20, 21, 23, 23, 26, 29, 30]
NEEDLES = [0,1,2,5,8,10,22,23,29,30,31]
ROW_FMT = '{0:2d}@{1:2d}   {2}{0:<2d}'
def  demo (bisect_fn):
    for  needle  in reversed(NEEDLES):
        position = bisect_fn(HAYSTACK,needle)   #  1
        offset = position*' | '   #  2
        print(ROW_FMT.format(needle,position,offset))   #  3
if __name__ =='__main__' :
    if  sys.argv[-1] == 'left':   #  4
        bisect_fn = bisect.bisect_left
    else:
        bisect_fn = bisect.bisect
    print('DEMO:',bisect_fn.__name__)   #  5
    print('haystack->',''.join('%2d'% n  for n in  HAYSTACK))
    demo(bisect_fn)
 
    

    1.用特定的bisect函數來計算元素應該出現的位置
    2。利用該位置計算注需要幾個分隔符號
    3.把元素和其應該出現的位置打印出來
    4.根據命令上最後一個參數來選用bisect函數
    5.把選定的函數在擡頭打印出來
  
 

   # bisect 可以用來建立一個用數字作爲索引的查詢表格，比如說把分數和成績對應起來

    #  根據一個分數，找到它對應的成績
  
def  grade(score,breakpoints = [60,70,80,90], grades = 'FDCBA') :
    i = bisect.bisect(breakpoints,score)
    return grades[i]
print( [grade(score) for score in [33,99,55,70,67,89,90,100]])

當排序很費時時，在得到一個有序序列時，最好保持它的有序，bisect.insort就是爲了這個而存在的
insort(seq,item)把變量item插入到序列seq中，並能保持seq的升序排序
"""
import  bisect
import  random
SIZE = 7
random.seed(1729)
my_list = []
for  i  in  range (SIZE):
    new_item = random.randrange(SIZE*2)
    bisect.insort(my_list,new_item)
    print('%2d ->'% new_item,my_list)

 序列構成的數組Demo10sorted ,sort.

# -*- coding: utf-8 -
"""
import  bisect
import sys
HAYSTACK = [1, 4, 5, 6, 8, 12, 15, 20, 21, 23, 23, 26, 29, 30]
NEEDLES = [0,1,2,5,8,10,22,23,29,30,31]
ROW_FMT = '{0:2d}@{1:2d}   {2}{0:<2d}'
def  demo (bisect_fn):
    for  needle  in reversed(NEEDLES):
        position = bisect_fn(HAYSTACK,needle)   #  1
        offset = position*' | '   #  2
        print(ROW_FMT.format(needle,position,offset))   #  3
if __name__ =='__main__' :
    if  sys.argv[-1] == 'left':   #  4
        bisect_fn = bisect.bisect_left
    else:
        bisect_fn = bisect.bisect
    print('DEMO:',bisect_fn.__name__)   #  5
    print('haystack->',''.join('%2d'% n  for n in  HAYSTACK))
    demo(bisect_fn)
 
    

    1.用特定的bisect函數來計算元素應該出現的位置
    2。利用該位置計算注需要幾個分隔符號
    3.把元素和其應該出現的位置打印出來
    4.根據命令上最後一個參數來選用bisect函數
    5.把選定的函數在擡頭打印出來
  
 

   # bisect 可以用來建立一個用數字作爲索引的查詢表格，比如說把分數和成績對應起來

    #  根據一個分數，找到它對應的成績
  
def  grade(score,breakpoints = [60,70,80,90], grades = 'FDCBA') :
    i = bisect.bisect(breakpoints,score)
    return grades[i]
print( [grade(score) for score in [33,99,55,70,67,89,90,100]])

當排序很費時時，在得到一個有序序列時，最好保持它的有序，bisect.insort就是爲了這個而存在的
insort(seq,item)把變量item插入到序列seq中，並能保持seq的升序排序
"""
import  bisect
import  random
SIZE = 7
random.seed(1729)
my_list = []
for  i  in  range (SIZE):
    new_item = random.randrange(SIZE*2)
    bisect.insort(my_list,new_item)
    print('%2d ->'% new_item,my_list)

序列構成的數組Demo11numpy

# -*- coding: utf-8 -*-
"""
from  array import  array             # 1
from  random  import random
floats = array('d',(random() for  i  in range(10**7)))         #  2
print(floats[-1]) #  3
fp = open('floats.bin','wb')
floats.tofile(fp)  #  4
fp.close()
floats2 = array('d')  #   5
fp = open('floats.bin','rb')
floats2.fromfile(fp,10**7)   #  6
fp.close
print(floats2[-1])   #   7
print(floats2 ==floats)             #  8

1.引入array類型
2.利用一個可迭代對象來建立一個雙精度浮點數組(類型碼是'd'),
這裏我們用的是一個生成器表達式
3.查看數組的最後一個元素
4.把數組存入一個二進制文件中
5.新建一個雙精度浮點空數組
6.把1000萬個浮點數從二進制文件裏讀取出來
7.查看新數組的最後一個元素
8.檢查倆個數組的內容是不是完全一樣
.numpy字符編碼

整數 ：i
無符號整數：u
單精度浮點數：f
雙精度浮點數：d
布爾值：b
複數：D
字符串：s
unicode字符串：U
void(空)：v


#  通過改變數組中的某一個字節來更新數組裏某個元素的值
import array
numbers = array.array('h',[-2,-1,0,1,2])
memv = memoryview(numbers)   #  1
print(len(memv))
print(memv[0])       #  2
memv_oct = memv.cast('B')      #  3
print(memv_oct.tolist())     #  4
memv_oct[5] = 4         #  5
print(numbers)          # 6


1.利用 含有5個短整型由符號整數的數組（類型碼是'h')創建一個memoryview
2.memv裏的5個元素跟數組裏的沒有區別
3.創建一個memv_oct，把memv裏的內容轉換成'B'類型，
也就是無符號字符
4.以列表的形式查看memv_oct的內容
5.把位於位置5的字節賦值成4
6.因爲我們把佔2個字節的整數的高位字節改成了4 ，
所以這個有符號整數的值就變成了1024



#  演示一下NumPy二維數組的基本操作：對numpy.ndarray的行和列進行基本操作
import  numpy  #  1
a = numpy.arange(12)  #  2
print(a)
print(type(a))
print(a.shape)   #
a.shape =  3,4  # 4
print(a)  
print(a[2])    #      5
print(a[2,1])   #  6
print(a[:,1])   #  7
print(a.transpose())  #  8

1.導入
2，新建一個0~11的整數numpy.ndarray,然後把它打印出來
3.看看數組的維度，他是一個一維的，有12個元素的數組
4.把數組變成二維數組，然後打印出來
5.打印第二行
6.打印第二行第一列的元素
7.把第一列打印出來
8.把行和列交換，就得到一個新數組


#使用雙向隊列
"""  

from  collections import deque
dq = deque(range(10),maxlen = 10)   #  1
print(dq)
dq.rotate(3)      #         2
print(dq)
dq.rotate(-4)      
print(dq)
dq.appendleft(-1)   #        3
print(dq)
dq.extend([11,22,33])        #  4
print(dq)
dq.extendleft([10,20,30,40])  #  5
print(dq)
"""
1.maxlen是一個可選參數，代表這個隊列可以容納的元素的數量，
而且一旦設定，這個屬性就不能修改了
2隊列的旋轉操作可以接受一個參數n,
當n>0時，隊列的最右邊的n個元素會被移動到隊列的左邊，
當n<0時，最做左邊的n個元素會被移動到右邊
3當試圖對一個已滿（len(d)==d.maxlen)的隊列做頭部添加操作的時候，
它尾部的元素會被刪除掉，注意在一下行裏，元素0被刪除掉
4.在尾部添加三個元素的操作會擠掉-1,1,2
5.extendleft(iter)方法會把迭代器裏的元素逐個添加到雙向對列的左邊，
因此迭代器裏的元素會逆序出現在隊列裏

"""