python:struct、ord()、chr()

import  struct

import  binascii

values =  ( 1 , 'abc' , 2.7 )

s =  struct.Struct( 'I3sf' )

packed_data =  s.pack( * values)

unpacked_data =  s.unpack(packed_data)

代码中，首先定义了一个元组数据，包含int、string、float三种数据类型，然后定义了struct对象，并制定了format‘I3sf’，I 表示int，3s表示三个字符长度的字符串，f 表示 float。最后通过struct的pack和unpack进行打包和解包。通过输出结果可以发现，value被pack之后，转化为了一段二进制字节串，而unpack可以把该字节串再转换回一个元组，但是值得注意的是对于float的精度发生了改变，这是由一些比如操作系统等客观因素所决定的。打包之后的数据所占用的字节数与C语言中的struct十分相似。定义format可以参照官方api提供的对照表：

chr(65) #'A' chr()函数用一个0~255内的整数作为参数，返回一个对应的字符
ord('a') # 97ord()函数用一个字符（长度为1的字符串作为参数，返回对应的ASCII码）

sum的用法

#注意sum的用法，sum的参数必须是list
List={1,2,3,4,6,7,8,6,7,5,4}
list1={1,2,3,4,5}
#取List中在list1中元素的和
c=sum(item for item in List if item in list1)
print(c)
#求list1的和
print(sum(list1))

struct.pack() struct.unpack()

import struct
a=12
bytes1=struct.pack('i',a)#'i'表示转换为int
#struct.pack(fmt,v1,v2) 将python的值根据格式符转换为字符串（字节流、字节数组），fmt是格式字符串，v1,v2...表示要转换的python值
byte2=struct.pack('ii',10,23)
print (byte2)
print(repr(byte2))
a,=struct.unpack('i',bytes1)#将字节流转换为python数据类型，返回一个元组
print(bytes1)

result=int('d',16)#转为16进制
resultBytes=bytes(result)#转为字节流

collect dic

import collections
s={2:100,2:200,3:300,4:400}
s=[('one',1),('two',2),('three',3),('four',4),('five',5)]
d=collections.defaultdict(list)
for k,v in s:
	d[k].append(v)
l=list(d.items())#转为list

g={}
for k,v in s:
	g.setdefault(k,[]).append(v)

e={}
for k,v in s:
	e[k]=v

print(type(d))#<class 'collections.defaultdict'>
print(type(g))#dict
print(type(e))#dict
print(d)
print(g)
print(e)
'''输出结果
<class 'collections.defaultdict'>
<class 'dict'>
<class 'dict'>
defaultdict(<class 'list'>, {'five': [5], 'two': [2], 'one': [1], 'three': [3], 'four': [4]})
{'five': [5], 'two': [2], 'one': [1], 'three': [3], 'four': [4]}
{'five': 5, 'two': 2, 'one': 1, 'three': 3, 'four': 4}
'''

zip isinstance

import collections
ro=collections.defaultdict(list)
#print(ro.items)#<built-in method items of collections.defaultdict object at 0x0000000002AA6438>
string='name'#type:str
ss=string.split()#转换为list
ss1=string.split('*')#转换为list
fal_dic=collections.OrderedDict()#<class 'collections.OrderedDict'>
#print(fal_dic,type(fal_dic))

bool1=isinstance(1,int)#判断i 是否属于int中
bool2=isinstance('hello',str)
bool3=isinstance('c',(float,int))
print(bool1,bool2,bool3)#True True False
'hell'.capitalize() # Hell capitalize()将字符串的第一个字母变成大写,其他字母变小写
#zip函数接受任意多个（包括0个和1个）序列作为参数，返回一个tuple列表
zip()#<zip object at 0x00000000024DB788>
x=[100,200,300]
y=[2,3,7,8,9,0]
xx=zip(x)
xy=zip(x,y)#zip()参数可以接受任何类型的序列，同时也可以有两个以上的参数;当传入参数的长度不同时，zip能自动以最短序列长度为准进行截取，获得元组。
xyl=list(zip(x,y))
#zip()方法用在for循环中，就会支持并行迭代
for (k,v) in zip(x,y):
	print(k,v)
'''100 2
200 3
300 7'''

super()继承

class A:
  def __init__(self):
   print "enter A"
   print "leave A"

 class B(A):
  def __init__(self):
   print "enter B"
   A.__init__(self)
   print "leave B"
#即使用非绑定的类方法（用类名来引用的方法），并在参数列表中，引入待绑定的对象（self），从而达到调用父类的目的。
#这样做的缺点是，当一个子类的父类发生变化时（如类B的父类由A变为C时），必须遍历整个类定义，把所有的通过非绑定的方法的类名全部替换过来
class A(object):    # A must be new-style class
  def __init__(self):
   print "enter A"
   print "leave A"

class B(C):     # A --> C
  def __init__(self):
   print "enter B"
   super(B, self).__init__()
   print "leave B"
 #继承的父类改变时，修改的代码只有一处，把代码的维护量降到最低
 #对于super(B, self).__init__()的理解：super(B, self)首先找到B的父类（就是类A），然后把类B的对象self转换为类A的对象，然后“被转换”的类A对象调用自己的__init__函数。考虑到super中只有指明子类的机制，因此，在多继承的类定义中，通常我们保留使用类似代码段1的方法