Python学习笔记《Python核心编程》第6章 序列：字符串、列表、元组

序列类型操作符

     1、成员关系操作符（in、not in）：用来判断一个元素是否属于一个序列。返回值为True/False。语法如下：

          对象 [not] in 序列

     2、连接操作符（+）：允许我们把一个序列和另一个相同类型的序列做连接：

          sequence1 + sequence2   #推荐使用列表类型的extend()方法来把两个或者多个列表对象合并。

     3、重复操作符（*），一个序列多份拷贝，语法如下：

          sequence * copies_int    #copies_int必须为整型

     4、切片操作符([],[:],[::])，这个操作符非常方便啊，javascript里面的slice substring一样作用，其中[::]第三个索引值被用做步长参数。如下：

          s = 'abcdefgh'

          s[::-1]     # 可以视为“翻转”操作，输出：‘hgfedcba’

          s[::2]      # 隔一个取一个的操作，输出'aceg'

内建函数：

     1、类型转换——内建函数list()、str()、tuple()被用做在各种序列类型之间的转换。

          list(iter)   把可迭代对象转换为列表

          str(obj)   把obj对象转换成字符串（对象的字符串表示法）

          unicode(obj)   把对象转换成Unicode字符串

          basestring()    抽象工厂函数，为str 和 unicode函数提供父类，不能被实例化，也不能被调用

          tuple(iter)       把一个可迭代对象转换成一个元组对象

    2、可操作内建函数，len()、reversed()和sum()函数只能接受序列类型对象作为参数,而剩下的则还可以接受可迭代对象作为参数，max() 和min()函数也可以接受一个参数列表。

        函数名                                                         功能

    enumerate(iter)                               接受一个可迭代对象作为参数，返回一个enumerate对象，该对象生成有iter每个元素的index值和item值组成的元组

    len(seq)                                          返回seq的长度

    max(iter,key=None) or max(arg0,arg1....,key=None)    返回iter或者(arg0,arg1...)中的最大值，如果指定了key，这个key必须是一个可以传给sort()方法的，用于比较的回调函数

    reversed(seq)              接受一个序列作为参数，返回一个以逆序访问的迭代器

    sorted(iter,func=None,key=None,reverse=False)     接受一个可迭代对象作为参数，返回一个有序的列表：可选参数func、key和reverse的含义跟list.sort()内建函数的参数含义一样

    sum(seq,init=0)           返回seq可可选参数init的总和，其效果等同于reduce(operator.add,seq,init)

    zip([it0,it1,...itN])         返回一个列表，其第一个元素是it0,it1...这些元素的第一个元素组成的一个元组

#!usr/bin/env python
# 标识符合法性检查，首字母以数字或者下划线开始，后面跟字母，下划线或者数字

import string

alphas = string.letters + '_'
nums = string.digits

print 'welcome to the Identifier checker v1.0'
print 'Testees must be at leatst 2 chars long.'
myInput = 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 "okey as an identifier"           

只适用于字符串的操作符：

      格式化操作符(%)：符号有如下

      %c                     转换成字符（ASCII码值，或者长度为一的字符串）

      %r                     优先用repr()函数进行字符串转换

      %s                     优先用str()函数进行字符串转换

      %d、%i             转换成有符号十进制

      %o                    转换成无符号八进制

      %x、%X            转换成无符号十六进制（Xx代表转换后的十六进制字符的大小写）

      %e、%E            转成科学计数法

      %f  %F              转成浮点型(小数部分自然截断)

      %g  %G             %e和%f/%E和%F的简写

      %%                   输出%

例子：

      “%x”  %  108             # '6c'

      "%X"  % 108              # '6C'

      "%#X"   %  108           # 输出： ‘0X6C’  其中  "#"的用途在八进制数前面显示0，在十六进制前面显示‘0x’或者’0X‘(取决于用的是’x‘ 还是 ’X‘)

      ‘%f’   %   1234.567890   #   '1234.567890'

      '%.2f' %   1234.567890   #    '1234.57'

      '%E'   %    1234.567890  #    '1.234568E+03'

      '%+d'  %   4             #  +4

      '%+d'  %   -4            # -4

字符串模板:Template对象，有两个方法，substitute() 和 safe_substitute()。前者更严谨，在缺少KEY的情况下它会报错，后者去烧KEY是直接原封不动吧字符串显示出来

from string import Template

s = Template('There are ${howmany} ${lang} Quotation Symbols')

print s.safe_substitute(lang='Python',howmany=3)                 # 'There are 3 python Quotation Symbols'

print s.substitute(lang='Python')                                # 'There are ${howmany} python Quotation Symbols'

字符串类型内建方法：

     string.capitalize()         把字符串的第一个字符大写

     string.center(width)     返回一个原字符串居中，并使用空格填充至长度width的新字符串

     string.count(str,beg=0,end=len(string))         返回str在string里面出现的字数，如果beg或者end指定，则返回指定范围内str出现的次数

     string.decode(encoding='UTF-8'  errors='strict')   以dncoding指定的编码格式解码string，如果出错默认报以个valueError的异常，除非errors指定的是‘ignore'或者‘replace’

     string.encode(encoding='UTF-8'  errors='strict')   以encoding指定的编码格式编码string，如果出错默认报一个ValueError异常，除非errors指定的是‘ignore'或者‘replace’

     string.endswith(obj,beg=0,end=len(string))        检查字符串是否以obj结束，beg、end指定范围

     string.expandtabs(tabsize=8)                            把字符串string中的tab符号转为空格，默认的空格数tabsize是8

     string.find(str,beg=0,end=len(string))                检测str是否包含在string中，如果beg和end指定范围，则检查是否包含在指定范围内，如果是返回开始的索引，否则返回-1

     string.index(str,beg=0,end=len(string))              跟find()方法一样，只不过如果str不在string中会报一个异常

     string.isalnum()                                                如果string至少有一个字符并且所有的字符都是字母或者数字则返回True，否则返回False

     string.isalpha()                                                 如果string至少有一个字符丙炔所有的字符都是字母则返回True，否则返回False

     string.isdecimal()                                              如果string只包含十进制数字则返回True、否则返回Flase

     string.isdigit()                                                  如果string只包含数字则返回True，否则返回False

     string.islower()                                                 如果string中包含至少一个区分大小写的字符，并且所有这些字符都是小写，则返回True，否则返回False

     string.isnumeric()                                              如果string中只包含数字字符，则返回True

     string.isspace()                                                 如果string中只包含空格，则返回True，否则为False

     string.istitle()                                                    如果string是标题化的则返回True，否者返回False

     string.isupper()                                                 如果string中包含至少一个区分大小写的字符，并且所有这些字符都是大写，则返回True

     string.join(seq)                                                 以string作为分隔符，将seq中所有的元素合并为以个新的字符串

     string.ljust(with)      string.lower()          string.lstrip()                string.partition(str)                 string.replace(str1,str2,num=string count(str1))

     string.rfind(str,beg=0,end=len(string))        string.rindex(str,beg=0,end=len(string))                string.rjust(width)        string.rpartition(str)

     string.rstrip()       strin.split(str='',num=string.count(str))           string.splitlines(num=string.count('\n'))      

     string.startswith(obj,beg=0,end=len(string))          string.strip([obj])      string.swapcase()              string.title()              string.translate(str,del="")

     string.upper()      string.zfill(width)

>>> quest = 'what is your favorite color?'
>>> quest.capitalize()
'What is your favorite color?'
>>> quest.center(40)
'      what is your favorite color?      '
>>> quest.count('or')
2
>>> quest.endswith('blue')
False
>>> quest.endswith('color')
False
>>> quest.endswith(''color?)
SyntaxError: invalid syntax
>>> quest.endswith('color?')
True
>>> quest.find('or',22)
25
>>> quest.index('or',10)
16
>>> ':'.join(quest.split())
'what:is:your:favorite:color?'
>>> quest.replace('favorite color','quest')
'what is your quest?'
>>> quest.upper()
'WHAT IS YOUR FAVORITE COLOR?'
>>> 

另：三引号""" """  输出所见即所得格式！！

列表

    类似javascript中的数组，如何创建列表：

          aList = [123,'abc',4.56,['inner','list'],7-9j]  

    访问列表的值：用切片操作符和索引值范围一起使用

          aList[1:4]         #['abc',4.56,['inner','list']]

    更新列表，可以通过在等号的左边指定一个索引或者索引范围的方式来更新一个或者几个元素，也可以用append()方法来最佳元素导列表中去。

          aList[2] = 'float replacer'     #更改列表第三个值

          aList.append('hi,i'm new here')    #在最后新增一个列表值 

    如何删除列表中的元素或者列表:

          del aList[1]        #删除列表中的第二个元素

          aList.remove(123)  #删除列表中值为123的元素

          还可以通过pop()方法来删除并从列表中返回一个特定对象。

          del aList         #删除整个列表

     序列类型操作符：切片操作符[:]    成员关系操作(in,not in)   连接操作符（+）   重复操作符（*）

     列表比较内建函数 cmp() :

      1、对两个列表的元素进行比较。

      2、如果比较的元素师同类型的，则比较其值，返回结果。

      3、如果两个元素不是同一种类型，则检查他们是否是数字。

          a、如果是数字，执行必要的数字强制类型转换，然后比较

          b、如果有一方的元素是数字，则另一方的元素”大“（数字是”最小的“）。

          c、否则，通过类型名字的字母顺序进行比较。

      4、如果有一个列表首先到达末尾，则另一个长一点的列表大。

     len()   返回列表或者元组的元素个数， max() 和 min()  返回最大和最小的元素； sorted() 和 reversed()  排序和反转， enumerate() 和 zip()，sum()

     list()  和 tuple() 接受可迭代的对象作为参数，通过浅拷贝数据来创建一个信的列表或者元组。

      aList = ['tao',93,99,'time']

      aTuple = tuple(aList)

      >>> aList,aTuple    #(['tao',93,99,'time'],('tao',93,99,'time'))

列表类型的类建函数

                   列表函数                                                                  作用

    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;否则引发异常

    list.insert(index,obj)                                      在索引量为index的位置插入对象obj

    list.pop(index=-1)                                         删除并返回指定位置的对象，默认是最后一个对象

    list.remove(obj)                                             从列表中删除对象obj

    list.reverse()                                                 原地翻转列表

    list.sort(func=None,key=None,reverse=Flase)   以指定的方式排序列表中的成员，如果func和key参数指定，则按照指定的方式比较各个元素，如果reverse标志被设为True，则列表以反序排列。

元组

    元组是用的圆括号，列表时用的是方括号。功能上，元组是一种不可变类型。

    创建元组： aTuple = (123,'abc',4.56,['inner','tuple'],7-9j)

    使用切片操作符([::])来访问元组； 如何更新元组，通过构造一个新字符串的方式解决。

     删除一个单独的元组元素是不可能的 ，删除元组  del aTuple

深拷贝：    

person = ['name',['savings',100.00]]
hubby = person
import copy
wifey = copy.deepcopy(person)
[id(x) for x in person,hubby,wifey]
#[34400536, 34400536, 34429408]