Python学习笔记三数字和字符串

• 程序由模块构成
• 模块包含语句
• 语句包含表达式
• 表达式建立并处理对象

• 内置对象使程序更容易编写。对于简单的任务，内置类型往往能够表现问题领域的所有结构。
• 内置对象是扩展的组建。对于较为复杂的任务，或许仍需要提供自己的对象，使用Python的类或C语言的接口。
• 内置对象往往比定制的数据结构更有效率。
• 内置对象是语言的标准的一部分。

注：只是列举了一些常用对象，实际上，在Python处理过程中，每一样东西都是对象，如在Python中进行文本模式匹配时，创建了模式对象，在进行网络脚本编程时，使用了嵌套字对象。其它类型的对象往往都是通过导入或使用模块来建立的，而且它们都有各自的行为。

• 数字：整数，浮点，有虚部的复数，固定精度的十进制，带分子和分母的有理分数以及集合等，支持一般的数学运算，如：

  # iPython3
  
  In [1]: 123 + 222
  Out[1]: 345
  
  In [2]: 3.5 * 4
  Out[2]: 14.0
  
  In [3]: 2 ** 100 
  Out[3]: 1267650600228229401496703205376
  
  In [4]: 3.1415 * 2
  Out[4]: 6.283
  

  数字类型可以利用math模块，包含高级的数学工具，进行计算

  In [1]: import math
  
  In [2]: math.pi
  Out[2]: 3.141592653589793
  
  In [3]: math.sqrt(85)
  Out[3]: 9.219544457292887
  
  In [4]: import random
  
  In [5]: random.random()
  Out[5]: 0.41949731611114904
  
  In [6]: random.choice([1,2,3,4])
  Out[6]: 4 
  

• 字符串：记录任意文本信息，它们是在Python中作为序列（也就是说，一个包含其它对象的有序集合）。序列中的元素包含了一个从左到右的顺序——序列中的元素根据它们的相对位置进行存储和读取。从严格意义上讲，字符串是单个字符的字符串序列，其它类型的序列还包括列表和元组。
  • 序列操作。作为序列，字符串支持假设其中各个元素包含位置顺序的操作。如len函数

  In [1]: S = 'Spam'
  
  In [2]: len(S)
  Out[2]: 4
  
  In [3]: S[0]
  Out[3]: 'S'
  
  In [4]: S[1]
  Out[4]: 'p'
  
  

  在Python中，索引是按照从最前面的偏移量进行编码的，也就是从0开始，第一项索引位0，第二项为1，依此类推。在Python中，我们也可以反向索引，从最后一个开始，及从字符串右边开始计算，如

  In [5]: S[-1]
  Out[5]: 'm'
  
  In [6]: S[-2]
  Out[6]: 'a'
  

  一般来说，负的索引号会简单地与字符串的长度相加，因此，以下两个操作是等效的

  In [7]: S[-1]
  Out[7]: 'm'
  
  In [8]: S[len(S)-1]                                                            
  Out[8]: 'm'                                                                    
  

  注意：我们能够在方括号中使用任意表达式，而不仅仅是使用数字常量，只要Python需要一个值，我们可以使用一个常量，一个变量或任意表达式。

  • 分片字符串。除了简单地从位置进行索引，序列也支持分片（slice），例如

  In [9]: S                                                                      
  Out[9]: 'Spam' 
  
  In [10]: S[1:3] 
  Out[10]: 'pa'	 
  

  slice的一般形式为X[I:J]，表示取出X从偏移量为I，直到但不包括偏移量为J的内容。结果就是返回一个新的对象。在一个分片中，左边界默认为0，并且右边界默认为分片序列的长度。这引入了一些常用方法的变体：

  In [11]: S[1:]                                                                 
  Out[11]: 'pam'                                                                 
  
  In [12]: S                                                                     
  Out[12]: 'Spam'                                                                
  
  In [13]: S[0:3]                                                                
  Out[13]: 'Spa'                                                                 
  
  In [14]: S[:3]                                                                 
  Out[14]: 'Spa'                                                                 
  
  In [15]: S[:-1]                                                                
  Out[15]: 'Spa'                                                                 
  
  In [16]: S[:]                                                                  
  Out[16]: 'Spam'                                                                
  

  • 合并字符串。最后，作为一个序列，字符串也支持使用加号进行合并，将两个字符串合并成一个新的字符串，或者重复，通过再重复一次创建一个新的字符串：

  In [17]: S                                                                     
  Out[17]: 'Spam'
  
  In [18]: S + 'xzy'
  Out[18]: 'Spamxzy'
  
  In [19]: S
  Out[19]: 'Spam'
  
  In [20]: S * 8
  Out[20]: 'SpamSpamSpamSpamSpamSpamSpamSpam'
  
  In [21]: S
  Out[21]: 'Spam'
  

  • 不可变性。 在以上例子中，没有通过任何操作对原始字符串进行改变。每个字符串都被定义为生成新的字符串作为结果，因为字符串在Python中具有不可变性，在创建后 不能就地改变。但是你可以通过建立一个新的字符串并以同一个变量名对其进行赋值，因为在Python运行中，会清理旧的对象。

  In [21]: S
  Out[21]: 'Spam'
  
  In [22]: S = 'z' + S[1:]
  
  In [23]: S
  Out[23]: 'zpam'
  

  注意：在Python核心数据类型中，数字，字符串和元组是不可变的，列表和字典不是这样（它们可以完全自由地改变）。

  • 字符串特定的方法。find方法是一个基本的字符串查找的操作，它将返回一个传入子字符串的偏移量，或者没有找到的情况下返回-1，而字符串replace方法将会对全局进行搜索和替换。

  In [24]: S = 'Spam'
  
  In [25]: S
  Out[25]: 'Spam'
  
  In [26]: S.find('pa')
  Out[26]: 1
  
  In [27]: S.replace('pa','xyz')
  Out[27]: 'Sxyzm'
  
  In [28]: S
  Out[28]: 'Spam'
  

  • 字符串的其它方法

  In [1]: line='aaa,bbb,cccc,dd'
  
  In [2]: line.split(',')                    //以，分割字符串
  Out[2]: ['aaa', 'bbb', 'cccc', 'dd']
  
  In [3]: S='Spam'
  
  In [4]: S.upper()                          //转化为大写
  Out[4]: 'SPAM'
  
  In [5]: S.isalpha()                        //判断是否为英文字母
  Out[5]: True
  
  In [6]: line='aaa,bbb,cccc,dd\n'
  
  In [7]: line=line.rstrip()                 //删除末尾的指定字符(默认为空格)
  
  In [8]: line
  Out[8]: 'aaa,bbb,cccc,dd'
  

  • 格式化高级替代操作

  In [1]: '%s,eggs,and %s' % ('spam','SPAM!')
  Out[1]: 'spam,eggs,and SPAM!'
  
  In [2]: '{0},eggs,and {1}'.format('spam','SPAM!')
  Out[2]: 'spam,eggs,and SPAM!'
  

  注意：尽管序列操作是通用的，但是方法不通用，虽然某些类型共享某些方法名，字符串的方法只能用于字符串。一条简明的法则是这样的：可作用于多种类 型的通用型操作是以内置函数或表达式的形式出现的，例如len（X），X[0]，但是类型特定的操作是以方法调用的形式出现的，例如 aString.upper()。

  • 获取类型的所有的方法。你也可以通过调用dir函数，列出当前字符串的所有方法，通过help函数查询具体说明。

  In [1]: S='spam'
  
  In [2]: dir(S)
  Out[2]: 
  ['__add__',
   '__class__',
   '__contains__',
   '__delattr__',
   '__dir__',
   '__doc__',
   '__eq__',
   '__format__',
   '__ge__',
   '__getattribute__',
   '__getitem__',
   '__getnewargs__',
   '__gt__',
   '__hash__',
   '__init__',
   '__iter__',
   '__le__',
   '__len__',
   '__lt__',
   '__mod__',
   '__mul__',
   '__ne__',
   '__new__',
   '__reduce__',
   '__reduce_ex__',
   '__repr__',
   '__rmod__',
   '__rmul__',
   '__setattr__',
   '__sizeof__',
   '__str__',
   '__subclasshook__',
   'capitalize',
   'casefold',
   'center',
   'count',
   'encode',
   'endswith',
   'expandtabs',
   'find',
   'format',
   'format_map',
   'index',
   'isalnum',
   'isalpha',
   'isdecimal',
   'isdigit',
   'isidentifier',
   'islower',
   'isnumeric',
   'isprintable',
   'isspace',
   'istitle',
   'isupper',
   'join',
   'ljust',
   'lower',
   'lstrip',
   'maketrans',
   'partition',
   'replace',
   'rfind',
   'rindex',
   'rjust',
   'rpartition',
   'rsplit',
   'rstrip',
   'split',
   'splitlines',
   'startswith',
   'strip',
   'swapcase',
   'title',
   'translate',
   'upper',
   'zfill']
  
  In [3]: help(S.replace)
  
  Help on built-in function replace:
  
  replace(...) method of builtins.str instance
      S.replace(old, new[, count]) -> str
  
      Return a copy of S with all occurrences of substring
      old replaced by new.  If the optional argument count is
      given, only the first count occurrences are replaced.
  lines 1-8/8 (END)
  

  • 编写字符串的其它方法。

  In [1]: S = 'A\nB\tC'
  
  In [2]: len(S)
  Out[2]: 5
  
  In [3]: ord('\n')
  Out[3]: 10
  
  In [4]: S = 'A\0B\0C'
  
  In [5]: len(S)
  Out[5]: 5
  
  In [6]: S
  Out[6]: 'A\x00B\x00C'
  

  注释：chr()函数用一个范围在range（256）内的（就是0～255）整数作参数，返回一个对应的字 符。unichr()跟它一样，只不过返回的是Unicode字符，这个从Python 2.0才加入的unichr()的参数范围依赖于你的Python是如何被编译的。如果是配置为USC2的Unicode，那么它的允许范围就是 range（65536）或0x0000-0xFFFF；如果配置为UCS4，那么这个值应该是range（1114112）或 0x000000-0x110000。如果提供的参数不在允许的范围内，则会报一个ValueError的异常。

  ord()函数是chr()函数（对于8位的ASCII字符串）或unichr()函数（对于Unicode对象）的配对函数，它以一个字符（长度 为1的字符串）作为参数，返回对应的ASCII数值，或者Unicode数值，如果所给的Unicode字符超出了你的Python定义范围，则会引发一 个TypeError的异常。

  关于转义格式：

  \x** 用2个16进制数表示一个字符

  \*** 用3个8进制数表示一个字符

  其实上面第一个的 \0 = NULL 用的就是 8进制的转义格式只不过是\000的缩写,高位的0可以省去就像表示\42不用写成\042

  为什么说他是二进制字符? 二进制字符是一个概念,意思是里面完全由字节数据组成,而不是平常的字符串, 打印出来你是看不见的,或是乱码。

  Python允许字符串包括在单引号或双引号中（它们代表着相同的东西）。它也允许在三个引号（单引号或双引号）中包括多行字符串常量。当采用这种 形式的时候，所有的行都合并在一起，并在每一行的末尾增加换行符。这是一个微妙的语法上的便捷方式，但是在Python脚本中嵌入像html和xml这样 的内容时，这是很方便的。

  In [1]: msg="""aaaaaaaaaaaaa
     ...: bbb'''bbbbbbbbbbb""bbbbbbb'bbbb
     ...: ccccccccccccccc"""
  
  In [2]: msg
  Out[2]: 'aaaaaaaaaaaaa\nbbb\'\'\'bbbbbbbbbbb""bbbbbbb\'bbbb\nccccccccccccccc'
  

  • 模式匹配。我们需要一个re模块，这个模块包含了类似搜索，分割，替换等调用，因为使用模式去定义子字符串，可以更通用一些。

  In [1]: import re
  
  In [2]: match = re.match('Hello[\t]*(.*)world','Hello Python world')
  
  In [3]: match.group(1)
  Out[3]: ' Python '
  

  这个例子的目的是搜索子字符串，这个子字符串以Hello开始，后面跟着零个或者几个制表符或者空格，接着有任意字符并将其保存至匹配的group 中，最后以world结尾。如果找到了这样的子字符串，与模式中括号包含的部分匹配的子字符串的对应部分保存为组。再例如取出三个被斜线分割的组：

  In [4]: match = re.match('/(.*)/(.*)/(.*)','/usr/local/src')
  In [5]: match.groups()
  Out[5]: ('usr', 'local', 'src')