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)方法会把迭代器里的元素逐个添加到双向对列的左边，
因此迭代器里的元素会逆序出现在队列里

"""