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