2015-05-12-python核心编程(六)Python序列

#####Python序列
----------------------------------------------------------------------------------------------------------------------
-----6.1 序列
1.标准类型操作符
2.序列类型操作符
seq[ind]-->获得下标为ind 的元素
seq[ind1:ind2]-->获得下标从ind1 到ind2 间的元素集合
seq*expr-->序列重复expr 次
seq1+seq2-->连接序列seq1 和seq2
obj in seq-->判断obj 元素是否包含在seq 中
obj not in seq-->判断obj元素是否不包含在seq 中


s='abcdefgh'
s[::-1] --翻转
s[::2] --隔一个取一个


s='abcde'
i=-1
for i in range(-1,-len(s),-1):
    print s[:i]
    
for i in [None]+range(-1,-len(s),-1):
    print s[:i]
3.内建函数(BIFs)
(1).类型转换
list(iter)   把可迭代对象转换为列表
str(obj)     把obj对象转换成字符串(对象的字符串表示法)
unicode(obj) 把对象转换成Unicode 字符串(使用默认编码)
basestring() 抽象工厂函数,其作用仅仅是为str和unicode函数提供父类，所以不能被实例化，也不能被调用
tuple(iter)  把一个可迭代对象转换成一个元组对象
(2).Operational
enumerate(iter)接受一个可迭代对象作为参数，返回一个enumerate 对象(同时也是一个迭代器),该对象生成由iter 每个元素的index 值和item 值组成的元组
len(seq) 返回seq 的长度
max(iter,key=None) or
max(arg0,arg1...,key=None)b 返回iter 或(arg0,arg1,...)中的最大值，如果指定了key,这个key 必须是一个可以传给sort()方法的,用于比较的回调函数.
min(iter, key=None) or
min(arg0, arg1.... key=None)b 返回iter 里面的最小值;或者返回(arg0,arg2,...)里面的最小值;如果指定了key,这个key 必须是一个可以传给sort()方法的,用于比较的回调函数.
reversed(seq)c 接受一个序列作为参数,返回一个以逆序访问的迭代器(PEP 322)
sorted(iter,func=None,key=None,reverse=False)c 接受一个可迭代对象作为参数，返回一个有序的列表;
可选参数func,key 和reverse 的含义跟list.sort()内建函数的参数含义一样.
sum(seq, init=0)a 返回seq 和可选参数init 的总和, 其效果等同于reduce(operator.add,seq,init)
zip([it0, it1,... itN])d 返回一个列表，其第一个元素是it0,it1,...这些元素的第一个元素组成的一个元组，第二个...,类推.
----------------------------------------------------------------------------------------------------------------------
-----6.2 字符串
1.字符串的创建和赋值
>>> aString = 'Hello World!' # 使用单引号
>>> anotherString = "Python is cool!" # 使用双引号
>>> print aString # print 不带引号的 Hello World!
>>> anotherString # 不是进行print 操作，带有引号
>>> s = str(range(4)) # 把一个列表转换成一个字符串
2.如何访问字符串的值(字符和子串)
aString = 'Hello World!'
aString[0]
aString[1:5]
aString[6:]
3.如何改变字符串
aString=aString[:6]+'Python!'
aString
aString='different string algogether'
aString
4.如何删除字符和字符串
aString='hello World!'
aString=aString[:3]+aString[4:]
aString


aString=''
aString
del aString
----------------------------------------------------------------------------------------------------------------------
-----6.3 字符串和操作符
1.标准类型操作符
str1='abc'
str2='lmn'
str3='xyz'
str1<str2
str2!=str3
str1<str3 and str2=='xyz'
2.序列操作符
  aString='abcd'
  len(aString)
  正向索引
  aString[0]
  aString[1:3]
  aString[2:4]
  aString[4]
  反向索引
  aString[-1]
  aString[-3:-1]
  aString[-4]
  默认索引
  aString[2:]
  aString[1:]
  aString[:-1]
  aString[:]
3.成员操作符(in ,not in)  
  'bc' in 'abcd'
  'n' in 'abcd'
  'nm' not in 'abcd'
  
  import string
  string.ascii_uppercase
  string.ascii_lowercase
  string.ascii_letters
  string.digits
  --------------------------------------------------  
  标识串检查
  import string
  alphas=string.letters+'_'
  nums=string.digits
  print 'Welcome to the Identifier Checker v1.0'
  print 'Testees must be at least 2 chars long.'
  inp=raw_input('Identifier to test?')
  
  if len(myInput)>1:
      if myInput[0] not in alphas:
          print '''invalid: first symbol must be alphabetic'''
      else:
          for otherChar in myInput[1:]:
              if otherChar not in alphas+nums:
                  print '''invalid remaining symbols must be alphanumeric'''
                  break
              else:
                  print "okay as an identifier"
  --------------------------------------------------
4.连接符(+)       
  'Spanish'+'Inquisition'
  'Spanish'+' '+'Inquisition'
  s='Spanish'+' '+'Inquisition'+' Made Easy'
  import string
  string.upper(s[:3]+s[20])       
                  
  '%s %s'%('Spanish','Inquisition')   
  s=' '.join(('Spanish','Inquisiton','Made Easy'))
  ('%s%s'%(s[:3],s[20])).upper()             
5.编译时字符串连接   
  foo="hello"'world!'
  foo    
6.普通字符串转化为Unicode 字符串
  'Hello'+u' '+'World'+u'!'
7.重复操作符( * )
  'Ni!'*3
  '*'*40  
  print '-'*20,'Hello World!','-'*20
  who='knights'
  who*2
  who
----------------------------------------------------------------------------------------------------------------------
-----6.4 只适用于字符串的操作符 
1.格式化操作符(%)
%c      转换成字符(ASCII 码值，或者长度为一的字符串)
%ra     优先用repr()函数进行字符串转换
%s      优先用str()函数进行字符串转换
%d/%i   转成有符号十进制数
%ub     转成无符号十进制数
%ob     转成无符号八进制数
%xb/%Xb (Unsigned)转成无符号十六进制数(x/X 代表转换后的十六进制字符的大小写)
%e/%E   转成科学计数法(e/E 控制输出e/E)
%f/%F   转成浮点数(小数部分自然截断)
%g/%G   %e和%f/%E和%F的简写
%%      输出%
  
  格式化操作符辅助指令
  符号 作用
*     定义宽度或者小数点精度
-     用做左对齐
+     在正数前面显示加号( + )
<sp>  在正数前面显示空格
#     在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于
     用的是'x'还是'X')
0     显示的数字前面填充‘0’而不是默认的空格
%     '%%'输出一个单一的'%'
(var) 映射变量(字典参数)
m.n m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)


eg:
  十六进制输出:
  "%x"%108
  "%X"%108
  "%#x"%108
  "%#X"%108
  浮点数和科学记数法形式输出:
  '%f'%1234.567890
  '%.2f'%1234.567890
  '%E'%1234.567890
  '%e'%1234.567890
  '%G'%1234.567890
  '%g'%1234.567890
  "%e"%(1111111111111111111111111L)  
  整数和字符串输出:
  "%+d"%4
  "%+d"%-4
  "we are at %d%%"%100
  "Your host is:%s"% 'earth'
  'Host:%s\tPort:%d'%('mars',80)
  num=123
  'dec:%d/oct:%#o/hex:%#X'%(num,num,num)
  "MM/DD/YY=%02d/%02d/%d"%(2,15,67)
  w,p='Web','page'
  'http://xxx.yyy.zzz/%s/%s.html'%(w,p)
  
  'There are %(howmany)d %(lang)s Quotation Symbols'%{'lang':'Python','howmany':3}
2.字符串模板: 更简单的替代品
  from string import Template
  s=Template('There are ${howmany} ${lang} Quotation Symbols')
  print s.substitute(lang='Python',howmany=3)
  print s.substitute(lang='Python')
  print s.safe_substitute(lang='Python') 
3.原始字符串操作符(r/R)
  '\n'
  print '\n'
  r'\n'
  print r'\n'


  f=open('D:\t1\readme.txt','r')--出错
  
  f=open(r'D:\t1\readme.txt','r')
  f.readline()
  f.close()
  
  import re
  m=re.search('\\[rtfvn]',r'Hello World!\n')
  if m is not None:m.group()
  
  m=re.search(r'\\[rtfvn]',r'Hello World!\n')
  if m is not None:m.group()
4.Unicode字符串操作符(u/U)
  u'abc'
  u'\u1234'
  u'abc\u1234\n'
  ur'hello\nWorld'
----------------------------------------------------------------------------------------------------------------------
-----6.5 内建函数
1.标准类型函数
cmp() 根据字符串的ASCII 码值进行比较 
str1='abc'
str2='lmn'
str3='xyz'
cmp(str1,str2)
cmp(str3,str1)
cmp(str2,'lmn')
2.序列类型函数
(1).len()
str1='abc'
len(str1)
len('hello World')
(2).max() and min()
str2='lmn'
str3='xyz'
max(str2)
min(str3)

min('ab12cd')
min('AB12CD')
min('ABabCDcd')
(3).enumerate()
  s='foobar'
  for i,t in enumerate(s):
      print i,t
(4)zip()
  s,t='foa','obr'
  zip(s,t)
3.字符串类型函数
(1).raw_input()
  user_input=raw_input("Enter your name:")
(2).str() and unicode()
isinstance(u'\0xAB',str)
not isinstance('foo',unicode)
isinstance(u'',basestring)
not isinstance('foo',basestring)
(3).chr(),unichr(),and ord()  
  chr(65)
  ord('a')
  unichr(12345)
  ord(u'\u2345')
----------------------------------------------------------------------------------------------------------------------
-----6.6 字符串内建函数
--1.string.capitalize()
  把字符串的第一个字符大写
--2.string.center(width)
  返回一个原字符串居中,并使用空格填充至长度width 的新字符串
--3.string.count(str, beg=0,end=len(string))
  返回str 在string 里面出现的次数，如果beg 或者end 指定则返回指定范围内str 出现的次数
--4.string.decode(encoding='UTF-8',errors='strict')
以encoding指定的编码格式解码string，如果出错默认报一个ValueError 的异常
除非errors 指定的是'ignore' 或者'replace'
--5.string.encode(encoding='UTF-8',errors='strict')
  以encoding指定的编码格式编码string，如果出错默认报一个ValueError 的异常
  除非errors 指定的是'ignore'或者'replace'
--6.string.endswith(obj, beg=0,end=len(string))
  检查字符串是否以obj结束，如果beg 或者end 指定则检查指定的范围内是否以obj 结束，如果是，返回True,否则返回False.
--7.string.expandtabs(tabsize=8)
  把字符串string 中的tab 符号转为空格，默认的空格数tabsize 是8.
--8.string.find(str, beg=0,end=len(string))
  检测str 是否包含在string 中，如果beg 和end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
--9.string.index(str, beg=0,end=len(string))
  跟find()方法一样，只不过如果str 不在string 中会报一个异常.
--10.string.isalnum()
  如果string 至少有一个字符并且所有字符都是字母或数字则返回True,否则返回False
--11.string.isalpha()
  如果string 至少有一个字符并且所有字符都是字母则返回True,否则返回False
--12.string.isdecimal()
  如果string 只包含十进制数字则返回True 否则返回False.
--13.string.isdigit()
  如果string 只包含数字则返回True 否则返回False.
--14.string.islower()
  如果string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回True，否则返回False
--15.string.isnumeric()
  如果string 中只包含数字字符，则返回True，否则返回False
--16.string.isspace()
  如果string 中只包含空格，则返回True，否则返回False.
--17.string.istitle()
  如果string 是标题化的(见title())则返回True，否则返回False
--18.string.isupper()
  如果string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回True，否则返回False
--19.string.join(seq) Merges (concatenates)
  以string 作为分隔符，将seq 中所有的元素(的字符串表示)合并为一个新的字符串
--20.string.ljust(width)
  返回一个原字符串左对齐,并使用空格填充至长度width 的新字符串
--21.string.lower()
  转换string 中所有大写字符为小写.
--22.string.lstrip()
  截掉string 左边的空格
--23.string.partition(str)
  有点像find()和split()的结合体,从str 出现的第一个位置起,把字符串string 分成一个3 元素的元组
  (string_pre_str,str,string_post_str),如果string 中不包含str 则string_pre_str == string.
--24.string.replace(str1, str2,num=string.count(str1))
  把string 中的str1 替换成str2,如果num 指定，则替换不超过num 次.
--25.string.rfind(str, beg=0,end=len(string))
  类似于find()函数，不过是从右边开始查找.
--26.string.rindex( str, beg=0,end=len(string))
  类似于index()，不过是从右边开始.
--27.string.rjust(width)
  返回一个原字符串右对齐,并使用空格填充至长度width 的新字符串
--28.string.rpartition(str)
  类似于partition()函数,不过是从右边开始查找.
--29.string.rstrip()
  删除string 字符串末尾的空格.
--30.string.split(str="", num=string.count(str))
  以str 为分隔符切片string，如果num有指定值，则仅分隔num 个子字符串
--31.string.splitlines(num=string.count('\n'))
  按照行分隔，返回一个包含各行作为元素的列表，如果num 指定则仅切片num 个行.
--32.string.startswith(obj, beg=0,end=len(string))
  检查字符串是否是以obj 开头，是则返回True，否则返回False。如果beg 和end 指定值，则在指定范围内检查.
--33.string.strip([obj])
  在string 上执行lstrip()和rstrip()
--34.string.swapcase()
  翻转string 中的大小写
--35.string.title()
  返回"标题化"的string,就是说所有单词都是以大写开始，其余字母均为小写(见istitle())
--36.string.translate(str, del="")
  根据str 给出的表(包含256 个字符)转换string 的字符,要过滤掉的字符放到del 参数中
--37.string.upper() 转换string 中的小写字母为大写
--38.string.zfill(width) 返回长度为width 的字符串，原字符串string 右对齐，前面填充0
eg:
  quest='What is your favorite color'
  quest.capitalize()
  quest.center(40)
  quest.count('or')
  quest.endswith('blue')
  quest.endswith('color')
  quest.find('or',30)
  quest.find('or',22)
  quest.index('or',10)
  ':'.join(quest.split())
  quest.replace('favorite color','quest')
  quest.upper()
----------------------------------------------------------------------------------------------------------------------
-----6.7 字符串的独特特性
1.特殊字符串和控制字符
/X 八进制 十进制  十六进制  字符  说明
\0 000    0 0x00 NUL  空字符Nul
\a 007    7 0x07 BEL 响铃字符
\b 010    8 0x08 BS 退格
\t 011    9 0x09 HT 横向制表符
\n 012 10 0x0A LF 换行
\v 013 11 0x0B VT 纵向制表符
\f 014 12 0x0C FF 换页
\r 015 13 0x0D CR 回车
\e 033 27 0x1B ESC 转义
\" 042 34 0x22 " 双引号
\' 047 39 0x27 ' 单引号
\\ 134 92 0x5C \ 反斜杠


\OOO 八进制值(范围是000 到0177)
\xXX x 打头的十六进制值(范围是0x00 到0xFF)
\ 连字符，将本行和下一行的内容连接起来.
2.三引号
允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符.
hi='''hi there'''
hi 
print hi
3.字符串不变性
  s='abc'
  id(s)
  s+='def'
  id(s)
   
  s='%sC%s'%(s[0:2],s[3:])
  s
  s[0:3]+'DEF'
----------------------------------------------------------------------------------------------------------------------
-----6.8 Unicode 
1.术语
ASCII       美国标准信息交换码
BMP         基本多文种平面(第零平面)
BOM         字节顺序标记(标识字节顺序的字符)
CJK/CJKV    中文-日文-韩文(和越南语)的缩写
Code point  类似于ASCII 值，代表Unicode 字符的值，范围在range(1114112)或者说0x000000 到0x10FFFF.
Octet       八位二进制数的位组
UCS         通用字符集
UCS2        UCS 的双字节编码方式(见UTF-16)
UCS4        UCS 的四字节编码方式.
UTF         Unicode 或者UCS 的转换格式.
UTF-8       八位UTF 转换格式(无符号字节序列， 长度为一到四个字节)
2.什么是Unicode?
Unicode 通过使用一个或多个字节来表示一个字符的方法突破了ASCII 的限制. 在这样机
制下, Unicode 可以表示超过90,000 个字符.
3.你是怎么用Unicode 的？
新的内建函数unicode()和unichar()可以看成Unicode 版本的str()和chr().Unicode()
函数可以把任何Python 的数据类型转换成一个Unicode 字符串,如果是对象，并且该对象定义
了__unicode__()方法，它还可以把该对象转换成相应的Unicode 字符串.
4.Codecs是什么?
codec是COder/DECoder的首字母组合,它定义了文本跟二进制值的转换格式
5.编码解码
6.把Unicode应用到实际应用中
7.从现实中得来的教训
8.Python的Unicode支持
----------------------------------------------------------------------------------------------------------------------
-----6.9 相关模块
----------------------------------------------------------------------------------------------------------------------
-----6.10 字符串关键点总结
1.一些引号分隔的字符
2.不可分字符类型
3.字符串格式化操作符(%)提供类似于printf()那样的功能.
4.三引号
5.原始字符串对每个特殊字符串都使用它的原意
6.Python 字符串不是通过NULL或者'\0'来结束的
----------------------------------------------------------------------------------------------------------------------
-----6.11 列表
1.如何创建列表类型数据并给它赋值
  aList=[123,'abc',4.56,['inner','list'],7-9j]
  anotherList=[None,'something to see here']
  print aList
  print anotherList
  aListThatStartedEmpty=[]
  print aListThatStartedEmpty
  list('foo')
2.如何访问列表中的值
  aList[0]
  aList[1:4]
  aList[:3]
  aList[3][1]
3.如何更新列表
  你可以通过在等号的左边指定一个索引或者索引范围的方式来更新一个或几个元素,你也
  可以用append()方法来追加元素到列表中去.
  aList
  aList[2]
  aList[2]='float replacer'
  aList
  anotherList.append("hi,i'm new here")
  print anotherList
  aListThatStartedEmpty.append('not empty anymore')
  print aListThatStartedEmpty
4.如何删除列表中的元素或者列表(本身)
  要删除列表中的元素,如果你确切的知道要删除元素的素引可以用del 语句,否则可以用remove()方法.
  aList
  del aList[1]
  aList
  aList.remove(123)
  aList  
  如果你想明确的删除一整个列表,你可以用del 语句
  del aList
----------------------------------------------------------------------------------------------------------------------
-----6.12 操作符
1.标准类型操作符
  list1=['abc',123]
  list2=['xyz',789]
  list3=['abc',123]
  list1<list2
  list2<list3
  list2>list3 and list1==list3
2.序列类型操作符
(1).切片([] 和[:])
  num_list=[43,-1.23,-2,6.19e5]
  str_list=['jack','jumped','over','candlestick']
  mixup_list=[4.0,[1,'x'],'beef',-1.9+6j]
(2).成员关系操作(in,not in)
(3).连接操作符(+)
  ①.连接操作符允许我们把多个列表对象合并在一起
  ②.从Python1.5.2 起,我们可以用extend()方法来代替连接操作 ???
  符把一个列表的内容添加到另一个中去.使用extend()方法比连接操作的一个优点是它实际上
  是把新列表添加到了原有的列表里面,而不是像连接操作那样新建一个列表。
  ③.连接操作符并不能实现向列表中添加新元素的操作.
  ④.使用内建函数append()
(4).重复操作符(*)
  num_list
  num_list*2
  num_list*3
  hr='-'
  hr *=30
3.列表类型操作符和列表解析
  [i*2 for i in [8,-2,5]]
  [i for i in range(8) if i%2==0]
----------------------------------------------------------------------------------------------------------------------
-----6.13 内建函数
1.标准类型函数
(1).cmp()
list1,list2=[123,'xyz'],[456,'abc']
cmp(list1,list2)
cmp(list2,list1)
list3=list2+[789]
list3
cmp(list2,list3)
列表的比较方法:
①.对两个列表的元素进行比较.
②.如果比较的元素是同类型的,则比较其值,返回结果.
③.如果两个元素不是同一种类型,则检查它们是否是数字.
  a.如果是数字,执行必要的数字强制类型转换,然后比较.
  b.如果有一方的元素是数字,则另一方的元素"大"(数字是"最小的")
  c.否则,通过类型名字的字母顺序进行比较.
④.如果有一个列表首先到达末尾,则另一个长一点的列表"大".
⑤.如果我们用尽了两个列表的元素而且所有元素都是相等的,那么结果就是个平局,就是说返回一个0.
2.序列类型函数
(1).len()
  num_list=[12,13,34,23]
  len(num_list)
  len(num_list*2)
(2).max() and min()
(3).sorted() and reversed()
s=['They','stamp','them','when',"they're",'small']
for t in reversed(s):
  print t,
sorted(s)
(4).enumerate() and zip()
albums=['tales','robot','pyramid']
for i,album in enumerate(albums):
 print i,album
 
    fn=['ian','stuart','david']
    ln=['bairnson','elliott','paton']
    for i,j in zip(fn,ln):
      print('%s %s'%(i,j)).title()
(5).sum()
    a=[6,4,5]
    import operator
    reduce(operator.add,a)
    sum(a)
    sum(a,5)
    a=[6.,4.,5.]
    sum(a)
(6).list() and tuple()
  aList=['tao',93,99,'time']
  aTuple=tuple(aList)
  aList,aTuple
  aList==aTuple
  anotherList=list(aTuple)
  aList==anotherList
  aList is anotherList
  [id(x) for x in aList,aTuple,anotherList]
----------------------------------------------------------------------------------------------------------------------
-----6.14 列表类型的内建函数
list.append(obj)向列表中添加一个对象obj
list.count(obj)返回一个对象obj 在列表中出现的次数
list.extend(seq)把序列seq 的内容添加到列表中
list.index(obj, i=0,j=len(list)) 返回list[k] == obj 的k 值,并且k 的范围在 i<=k<j;否则引发ValueError 异常.
list.insert(index, obj) 在索引量为index 的位置插入对象obj.
list.pop(index=-1)a 删除并返回指定位置的对象,默认是最后一个对象
list.remove(obj) 从列表中删除对象obj
list.reverse() 原地翻转列表
list.sort(func=None,key=None,reverse=False)b以指定的方式排序列表中的成员,如果func 和key 参数指定,
则按照指定的方式比较各个元素,如果reverse 标志被置为True,则列表以反序排列.


  music_media=[45]
  music_media.insert(0,'compact disc')
  music_media
  music_media.append('long playing record')
  music_media
  music_media.insert(2,'8-track tape')
  music_media
  
  'cassette' in music_media
  'compact disc' in music_media
  music_media.index(45)
  music_media.index('8-track tape')
  music_media.index('cassette')
  
  for eachMediaType in(45,'8-track tape','cassette'):
  if eachMediaType in music_media:
  print music_media.index(eachMediaType)
  
  music_media
  music_media.sort()
  music_media
  music_media.reverse()
  music_media
  
  extend()方法接受一个列表的内容然后把它的所有元素追加到另一个列表中去
  new_media=['24/96 digital audio disc','DVD Audio disc','Super Audio CD']
  music_media.extend(new_media)
  
  核心笔记:那些可以改变对象值的可变对象的方法是没有返回值的!
  
  motd=[]
  motd.append('MSG OF THE DAY')
  f=open('1.txt','r')  
  motd.extend(f)
  f.close()
  motd
----------------------------------------------------------------------------------------------------------------------
-----6.15 列表的特殊特性
1.用列表构建其他数据结构
(1)堆栈
-------------------------------------堆栈start
stack=[]
def pushit():
stack.append(raw_input('Enter new string:').strip())

def popit():
if len(stack)==0:
print 'Cannot pop from an empty stack!'
else:
print 'Removed[',stack.pop(),']'

def viewstack():
print stack

CMDs={'u':pushit,'o':popit,'v':viewstack}


def showmenu():
pr="""
p(U)sh
p(O)p
(V)iew
(Q)uit
Enter Choice:"""


while True:
while True:
try:
choice=raw_input(pr).strip()[0].lower()
except(EOFError,KeyboardInterrupt,IndexError):
choice='q'

print '\n You picked:[%s]'%choice
if choice not in'uovq':
print 'Invalid option,try again'
else:
break


if choice=='q':
break

CMDs[choice]()

if __name__=='__main__':
showmenu()
-------------------------------------堆栈end
(2)队列
-------------------------------------队列start
queue=[]
def enQ():
queue.append(raw_input('Enter new string:').strip())


def deQ():
if len(queue)==0:
print 'Cannot pop from an empty queue!'
else:
print 'Removed[',queue.pop(0),']'


def viewQ():
print queue


CMDs={'e':enQ,'d':deQ,'v':viewQ}


def showmenu():
pr="""
(E)nqueue
(D)equeue
(V)iew
(Q)uit


Enter choice:"""
while True:
while True:
try:
choice=raw_input(pr).strip()[0].lower()
except(EOFError,KeyboardInterrupt,IndexError):
choice='q'

print '\nYou picked:[%s]'%choice
if choice not in 'devq':
print 'Invalid option,try again'
else:
break
if choice=='q':
break
CMDs[choice]()




if __name__=='__main__':
showmenu()
-------------------------------------队列end


----------------------------------------------------------------------------------------------------------------------
-----6.16 元组
--如何创建一个元组并给它赋值
aTuple=(123,'abc',4.56,['inner','tuple'],7-9j)
anotherTuple=(None,'something to see here')
print aTuple
print anotherTuple
emptiestPossibleTuple=(None,)
print emptiestPossibleTuple
tuple('bar')
--如何访问元组中的值
aTuple[1:4]
aTuple[:3]
aTuple[3][1]
--如何更新元组
aTuple=aTuple[0],aTuple[1],aTuple[-1]
tup1=(12,34.56)
tup2=('abc','xyz')
tup3=tup1+tup2
tup3
--如何移除一个元组的元素以及元组本身
del aTuple


----------------------------------------------------------------------------------------------------------------------
-----6.17 元组操作符和内建函数
1.标准类型操作符,序列类型操作符和内建函数.
2.元组类型操作符和内建函数,内建方法
----------------------------------------------------------------------------------------------------------------------
-----6.18 元组的特殊特性.
1.不可变性给元组带来了什么影响?
2.元组也不是那么“不可变”
t=('third','fourth')
t
t=t+('fifth','sixth')
t
元组包含的可变对象可变
t=(['xyz',123],23,-103.4)
t
t[0][1]=['abc','def']
t
3.默认集合类型
4.单元素元组 ('xyz',)
5.字典的关键字
----------------------------------------------------------------------------------------------------------------------
-----6.19 相关模块
copy 提供浅拷贝和深拷贝的能力
operator 包含函数调用形式的序列操作符，比如operator.concat(m,n)就相当于连接操作(m+n)。
re Perl 风格的正则表达式查找(和匹配)
StringIO/cStringIO 把长字符串作为文件来操作，比如read(),seek()函数等,C 版的更快一些,但是它不能被继承.
Textwrap 用作包裹/填充文本的函数，也有一个类
types 包含Python 支持的所有类型
collections 高性能容器数据类型
----------------------------------------------------------------------------------------------------------------------
-----6.20 拷贝Python 对象
--1.浅拷贝
--序列类型对象的浅拷贝是默认类型拷贝,并可以以下几种方式实施:
--(1)完全切片操作[:],(2)利用工厂函数,比如list(),dict()等,(3)使用copy 模块的copy 函数.
person=['name',['savings',100.00]]
hubby=person[:]
wifey=list(person)
[id(x) for x in person,hubby,wifey]
[id(x) for x in hubby]
[id(x) for x in wifey]


--修改
hubby[0]='joe'
wifey[0]='jane'
hubby,wifey
hubby[1][1]=50.00
hubby,wifey
[id(x) for x in hubby]
[id(x) for x in wifey]
--2.深拷贝
person=['name',['savings',100.00]]
hubby=person
import copy
wifey=copy.deepcopy(person)
[id(x) for x in person,hubby,wifey]


--修改
hubby[0]='joe'
wifey[0]='jane'
hubby,wifey
hubby[1][1]=50.00
hubby,wifey
[id(x) for x in hubby]
[id(x) for x in wifey]


--非容器类型(比如数字,字符串和其他"原子"类型的对象,像代码,类型和xrange 对象等)没有被拷贝一说,浅拷贝是用完全切片操作来完成的.
--如果元组变量只包含原子类型对象,对它的深拷贝将不会进行.
person=['name',('savings',100.00)]
newPerson=copy.deepcopy(person)
[id(x) for x in person,newPerson]
[id(x) for x in person]
[id(x) for x in newPerson]


----------------------------------------------------------------------------------------------------------------------
-----6.21 序列类型小结