磨人的小妖精們啊！終於可以歸置下自己的大腦啦，在這里我要把——整型，長整型，浮點型，字符串，列表，元組，字典，集合，這幾個知識點特別多的東西，統一的捯飭捯飭，不然一直腦袋里面亂亂的。
對於Python，一切事物都是對象，對象基於類創建
所以，以下這些值都是對象： "wupeiqi"、38、['北京', '上海', '深圳']，並且是根據不同的類生成的對象。
官方的解釋是這樣的：對象是對客觀事物的抽象，類是對對象的抽象。
因此str是類，int是類，dict、list、tuple等等都是類，但是str卻不能直接使用，因為它是抽象的表示了字符串這一類事物，並不能滿足表示某個特定字符串的需求，我們必須要str1 = ''初始化一個對象，這時的str1具有str的屬性，可以使用str中的方法。
類為我們創建對象，提供功能，在python中，一切事物都是對象！（瞧，誰還敢嫌棄我們程序員沒有對象，我們可以new一個呀！）
在這里介紹些類、對象、方法的查看方式：
1 >>> str1='zhenghao'
2 >>> type(str1)
3 <type 'str'>
4 >>>
查看類的所有方法：dir(類名)，就打印出了所有的類方法。
>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
那么問題來了，方法名為什么有的兩邊帶着下划線，有的沒有呢？那是python用來標識私有方法、非私有方法噠，帶下划線的標識私有方法，他們通常擁有不止一種調用方法。如下，我定義了兩個字符串，__add__的+的效果是相同的。這里有一個內置方法很特殊：__init__，它是類中的構造方法，會在調用其所在類的時候自動執行。
1 >>> str1='zhenghao'
2 >>> str2='love xiaokai'
3 >>> str1.__add__(str2)
4 'zhenghaolove xiaokai'
5 >>> str1+str2 6 'zhenghaolove xiaokai' 7 >>>
在python中，還有一個“help(類名)”方法：可以查看類的詳細功能；“help(類名.功能名)”：查看類中某功能的詳細情況
一、整數
整數是不可變的，不可迭代的
1.全部的方法
1 >>> dir(int)
2 ['__abs__', '__add__', '__and__', '__clas s__', '__cmp__', '__coerce__', '__delattr__', '__div__', '__divmod__', '__doc__', '__float__', '__floordiv__', '__format__', '__getattribute__', '__getnewargs__', '__hash__', '__hex__', '__index__', '__init__', '__int__', '__invert__', '__long__', '__lshift__', '__mod__', '__mul__', '__neg__', '__new__', '__nonzero__', '__oct__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdiv__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'imag', 'numerator', 'real']
每一個整數都具備如下功能：
1 class int(object): 2 """ 3 int(x=0) -> int or long 4 int(x, base=10) -> int or long 5 6 Convert a number or string to an integer, or return 0 if no arguments 7 are given. If x is floating point, the conversion truncates towards zero. 8 If x is outside the integer range, the function returns a long instead. 9 10 If x is not a number or if base is given, then x must be a string or 11 Unicode object representing an integer literal in the given base. The 12 literal can be preceded by '+' or '-' and be surrounded by whitespace. 13 The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to 14 interpret the base from the string as an integer literal. 15 >>> int('0b100', base=0) 16 4 17 """ 18 def bit_length(self): # real signature unknown; restored from __doc__ 19 """返回表示該數字時所用的最小位數 20 int.bit_length() -> int 21 22 Number of bits necessary to represent self in binary. 23 >>> bin(37) 24 '0b100101' 25 >>> (37).bit_length() 26 6 27 """ 28 return 0 29 30 def conjugate(self, *args, **kwargs): # real signature unknown 31 """返回一個復數的共軛復數 32 Returns self, the complex conjugate of any int. """ 33 pass 34 35 def __abs__(self): # real signature unknown; restored from __doc__ 36 """ 返回絕對值 37 x.__abs__() <==> abs(x) """ 38 pass 39 40 def __add__(self, y): # real signature unknown; restored from __doc__ 41 """ 返回兩個數的和 42 x.__add__(y) <==> x+y """ 43 pass 44 45 def __and__(self, y): # real signature unknown; restored from __doc__ 46 """ 返回兩個數按位與的結果 47 x.__and__(y) <==> x&y """ 48 pass 49 50 def __cmp__(self, y): # real signature unknown; restored from __doc__ 51 """返回兩個數比較的結果，參數從左至右（a，b），a>b返回1，a<b返回-1，a=b返回0 52 x.__cmp__(y) <==> cmp(x,y) """ 53 pass 54 55 def __coerce__(self, y): # real signature unknown; restored from __doc__ 56 """a.__coerce__(b),強制返回一個元組（a，b） 57 x.__coerce__(y) <==> coerce(x, y) """ 58 pass 59 60 def __divmod__(self, y): # real signature unknown; restored from __doc__ 61 """ 相除，得到商和余數組成的元組 62 x.__divmod__(y) <==> divmod(x, y) """ 63 pass 64 65 def __div__(self, y): # real signature unknown; restored from __doc__ 66 """返回兩數相除的商 67 x.__div__(y) <==> x/y """ 68 pass 69 70 def __float__(self): # real signature unknown; restored from __doc__ 71 """將數據類型強制轉換為float 72 x.__float__() <==> float(x) """ 73 pass 74 75 def __floordiv__(self, y): # real signature unknown; restored from __doc__ 76 """ 不保留小數點后的小數除法,也可以用‘//’來表示：a//b，我們親切地稱之為“地板除”！！！ 77 x.__floordiv__(y) <==> x//y """ 78 pass 79 80 def __format__(self, *args, **kwargs): # real signature unknown 81 """ 格式化""" 82 pass 83 84 def __getattribute__(self, name): # real signature unknown; restored from __doc__ 85 """無條件被調用，通過實例訪問屬性 86 x.__getattribute__('name') <==> x.name """ 87 pass 88 89 def __getnewargs__(self, *args, **kwargs): # real signature unknown 90 """ 內部調用 __new__方法或創建對象時傳入參數使用 """ 91 pass 92 93 def __hash__(self): # real signature unknown; restored from __doc__ 94 """ 如果對象object為哈希表類型，返回對象object的哈希值。哈希值為整數。在字典查找中，哈希值用於快速比較字典的鍵。兩個數值如果相等，則哈希值也相等 95 x.__hash__() <==> hash(x) """ 96 pass 97 98 def __hex__(self): # real signature unknown; restored from __doc__ 99 """ 返回當前數的 十六進制 表示 100 x.__hex__() <==> hex(x) """ 101 pass 102 103 def __index__(self): # real signature unknown; restored from __doc__ 104 """ 用於切片，對數字無意義 105 x[y:z] <==> x[y.__index__():z.__index__()] """ 106 pass 107 108 def __init__(self, x, base=10): # known special case of int.__init__ 109 """構造函數 110 int(x=0) -> int or long 111 int(x, base=10) -> int or long 112 113 Convert a number or string to an integer, or return 0 if no arguments 114 are given. If x is floating point, the conversion truncates towards zero. 115 If x is outside the integer range, the function returns a long instead. 116 117 If x is not a number or if base is given, then x must be a string or 118 Unicode object representing an integer literal in the given base. The 119 literal can be preceded by '+' or '-' and be surrounded by whitespace. 120 The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to 121 interpret the base from the string as an integer literal. 122 >>> int('0b100', base=0) 123 4 124 # (copied from class doc) 125 """ 126 pass 127 128 def __int__(self): # real signature unknown; restored from __doc__ 129 """ 轉換為整數 130 x.__int__() <==> int(x) """ 131 pass 132 133 def __invert__(self): # real signature unknown; restored from __doc__ 134 """按位求反 135 x.__invert__() <==> ~x """ 136 pass 137 138 def __long__(self): # real signature unknown; restored from __doc__ 139 """轉換為長整數 140 x.__long__() <==> long(x) """ 141 pass 142 143 def __lshift__(self, y): # real signature unknown; restored from __doc__ 144 """ 左移，相對二進制的操作 145 x.__lshift__(y) <==> x<<y """ 146 pass 147 148 def __mod__(self, y): # real signature unknown; restored from __doc__ 149 """ 取余 150 x.__mod__(y) <==> x%y """ 151 pass 152 153 def __mul__(self, y): # real signature unknown; restored from __doc__ 154 """ 返回兩數相乘的積 155 x.__mul__(y) <==> x*y """ 156 pass 157 158 def __neg__(self): # real signature unknown; restored from __doc__ 159 """ 返回一個數的負數，個人覺得和相反數沒差 160 x.__neg__() <==> -x """ 161 pass 162 163 @staticmethod # known case of __new__ 164 def __new__(S, *more): # real signature unknown; restored from __doc__ 165 """ 創建一個int類的新對象 166 T.__new__(S, ...) -> a new object with type S, a subtype of T """ 167 pass 168 169 def __nonzero__(self): # real signature unknown; restored from __doc__ 170 """ 判斷一個數是不是0 171 x.__nonzero__() <==> x != 0 """ 172 pass 173 174 def __oct__(self): # real signature unknown; restored from __doc__ 175 """ 返回該值的 八進制 表示 176 x.__oct__() <==> oct(x) """ 177 pass 178 179 def __or__(self, y): # real signature unknown; restored from __doc__ 180 """ 位運算，或，針對二進制數 181 x.__or__(y) <==> x|y """ 182 pass 183 184 def __pos__(self): # real signature unknown; restored from __doc__ 185 """ 並沒什么卵用，說是a.__pos__()，會返回一個+a，但是不管輸入整數還是負數，返回值都是他本身，感覺歪果仁真有幽默感 186 x.__pos__() <==> +x """ 187 pass 188 189 def __pow__(self, y, z=None): # real signature unknown; restored from __doc__ 190 """ 冪，次方 191 x.__pow__(y[, z]) <==> pow(x, y[, z]) """ 192 pass 193 194 def __radd__(self, y): # real signature unknown; restored from __doc__ 195 """x.__radd__(y) <==> y+x """ 196 pass 197 198 def __rand__(self, y): # real signature unknown; restored from __doc__ 199 """x.__rand__(y) <==> y&x """ 200 pass 201 202 def __rdivmod__(self, y): # real signature unknown; restored from __doc__ 203 """ x.__rdivmod__(y) <==> divmod(y, x) """ 204 pass 205 206 def __rdiv__(self, y): # real signature unknown; restored from __doc__ 207 """ x.__rdiv__(y) <==> y/x """ 208 pass 209 210 def __repr__(self): # real signature unknown; restored from __doc__ 211 """ 轉化為解釋器可讀取的形式 212 x.__repr__() <==> repr(x) """ 213 pass 214 215 def __rfloordiv__(self, y): # real signature unknown; restored from __doc__ 216 """ 217 x.__rfloordiv__(y) <==> y//x """ 218 pass 219 220 def __rlshift__(self, y): # real signature unknown; restored from __doc__ 221 """ x.__rlshift__(y) <==> y<<x """ 222 pass 223 224 def __rmod__(self, y): # real signature unknown; restored from __doc__ 225 """ x.__rmod__(y) <==> y%x """ 226 pass 227 228 def __rmul__(self, y): # real signature unknown; restored from __doc__ 229 """ x.__rmul__(y) <==> y*x """ 230 pass 231 232 def __ror__(self, y): # real signature unknown; restored from __doc__ 233 """ x.__ror__(y) <==> y|x """ 234 pass 235 236 def __rpow__(self, x, z=None): # real signature unknown; restored from __doc__ 237 """ y.__rpow__(x[, z]) <==> pow(x, y[, z]) """ 238 pass 239 240 def __rrshift__(self, y): # real signature unknown; restored from __doc__ 241 """ x.__rrshift__(y) <==> y>>x """ 242 pass 243 244 def __rshift__(self, y): # real signature unknown; restored from __doc__ 245 """ x.__rshift__(y) <==> x>>y """ 246 pass 247 248 def __rsub__(self, y): # real signature unknown; restored from __doc__ 249 """ x.__rsub__(y) <==> y-x """ 250 pass 251 252 def __rtruediv__(self, y): # real signature unknown; restored from __doc__ 253 """ x.__rtruediv__(y) <==> y/x """ 254 pass 255 256 def __rxor__(self, y): # real signature unknown; restored from __doc__ 257 """ x.__rxor__(y) <==> y^x """ 258 pass 259 260 def __str__(self): # real signature unknown; restored from __doc__ 261 """ 轉換為人閱讀的形式，如果沒有適於人閱讀的解釋形式的話，則返回解釋器課閱讀的形式 262 x.__str__() <==> str(x) """ 263 pass 264 265 def __sub__(self, y): # real signature unknown; restored from __doc__ 266 """ 返回兩數相減的差 267 x.__sub__(y) <==> x-y """ 268 pass 269 270 def __truediv__(self, y): # real signature unknown; restored from __doc__ 271 """返回兩數相除的商，這里的除是精確的除法，不會省略小數點后的值 272 x.__truediv__(y) <==> x/y """ 273 pass 274 275 def __trunc__(self, *args, **kwargs): # real signature unknown 276 """返回數值被截取為整形的值，在整形中無意義 277 Truncating an Integral returns itself. """ 278 pass 279 280 def __xor__(self, y): # real signature unknown; restored from __doc__ 281 """ 按位異或 282 x.__xor__(y) <==> x^y """ 283 pass 284 285 denominator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 286 """ 分母 = 1 """ 287 """the denominator of a rational number in lowest terms""" 288 289 imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 290 """ 虛數，無意義 """ 291 """the imaginary part of a complex number""" 292 293 numerator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 294 """ 分子 = 數字大小 """ 295 """the numerator of a rational number in lowest terms""" 296 297 real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default 298 """ 實數，無意義 """ 299 """the real part of a complex number""" 300 301 int Code
我已經在源碼中加入了注釋，原諒我后面很多函數沒有加注釋都，因為那些前面在前面已近出現過了，只是在前面多了一個'r'的，比如and，變成了rand，在這里統一總結，就是參數的順序從右到左反過來了。比如原本的a.__div__(b)是a/b，但是a.__rdiv__(b)的表示的就是b/a，對！就是這么坑爹！
2.常用方法
在int類中，比較普通的就是+，-，*，/，%，位運算，進制間以及數據類型間的轉換。下面對於比較特別但是常用的方法再進行一下記錄：
（1） __cmp__:比較兩個數的大小
1 >>> a = 12 2 >>> b = 15 3 >>> cmp(a,b) #比較兩個參數的值，如果第一個參數小於第二個參數，返回-1 4 -1 5 >>> cmp(b,a) #比較兩個參數的值，如果第一個參數大於第二個參數，返回1 6 1 7 >>> c = 12 8 >>> a.__cmp__(c) #比較兩個參數的值，如果第一個參數等於第二個參數，返回0 9 0 #cmp方法也有兩種調用方式
（2）__neg__/__abs__:取相反數/取絕對值
1 >>> a = -12
2 >>> b = 21
3 >>> a.__neg__() #求相反數
4 12
5 >>> b.__neg__()
6 -21
7 >>> a.__abs__() #求絕對值
8 12
9 >>> b.__abs__() 10 21
（3）__coerce__:強制返回一個元組（好吧，我承認這個並不常用，就是和divmod比較看看）
（4）__divmod__:返回兩個數相除的商和余數組成的元組（商，余數） 應用:顯示數據分頁
1 >>> a = 102 2 >>> b = 10 3 >>> a.__divmod__(b) 4 (10, 2) 5 >>> a.__coerce__(b) 6 (102, 10)
（5）__floordiv__:不保留小數點后的小數除法，在這兒把所有的除法都整理了，然而我並沒發現__div__和__floordiv__的區別啊~~~
1 >>> a = 13 2 >>> b = 2 3 >>> a.__div__(b) 4 6 5 >>> a.__truediv__(b) 6 6.5 7 >>> a.__floordiv__(b) 8 6 9 >>> a/b 10 6 11 >>> a//b 12 6
（6）__repr__/__str__:轉化為解釋器可讀取的形式/轉換為人閱讀的形式
二、長整型
可能如：2147483649、9223372036854775807
1 >>> dir(long)
2 ['__abs__', '__add__', '__and__', '__class__', '__cmp__', '__coerce__', '__delattr__', '__div__', '__divmod__', '__doc__', '__float__', '__floordiv__', '__format__', '__getattribute__', '__getnewargs__', '__hash__', '__hex__', '__index__', '__init__', '__int__', '__invert__', '__long__', '__lshift__', '__mod__', '__mul__', '__neg__', '__new__', '__nonzero__', '__oct__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdiv__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'imag', 'numerator', 'real']
每個長整型都具備如下功能：
long
長整形就是長長的整形。。。現在的操作系統大部分int類型的表示范圍是2^32,而長整形就是2^64，在python里，不需要程序員手動的轉換int和long的數據類型，當數值的大小超過了int的表示范圍，python會自動將數據類型轉換為long型，就是這么智能！！！既然long和int同表示整形，那么他們包含的方法也是差不多的，在這里就不再介紹了。
三、浮點型
如：3.14、2.88
1 >>> dir(float)
2 ['__abs__', '__add__', '__class__', '__coerce__', '__delattr__', '__div__', '__divmod__', '__doc__', '__eq__', '__float__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getformat__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__int__', '__le__', '__long__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__nonzero__', '__pos__', '__pow__', '__radd__', '__rdiv__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rmod__', '__rmul__', '__rpow__', '__rsub__', '__rtruediv__', '__setattr__', '__setformat__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', 'as_integer_ratio', 'conjugate', 'fromhex', 'hex', 'imag', 'is_integer', 'real']
每個浮點型都具備如下功能：
float
我們在創建對象的時候，python也會很聰明的識別出float類型，在計算的時候也是這樣，不管表達式中有多少整形多少浮點型，只要存在浮點型，那么所有計算都按照浮點型計算，得出的結果也會是float類型。其余方法和整形並沒有太大差別，在這里也不做詳細總結了。
四、字符串
字符串是不可修改不可變的，有序的，不可迭代的，有索引和切片
1.字符串全部方法
如：'zhenghao'、‘xiaokai'
1 >> dir(str)
2 ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parser', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
每個字符串都具備如下功能：
1 class str(basestring): 2 """ 3 str(object='') -> string 4 5 Return a nice string representation of the object. 6 If the argument is a string, the return value is the same object. 7 """ 8 def capitalize(self): 9 """ 首字母變大寫 """ 10 """ 11 S.capitalize() -> string 12 13 Return a copy of the string S with only its first character 14 capitalized. 15 """ 16 return "" 17 18 def center(self, width, fillchar=None): 19 """ 內容居中，width：總長度；fillchar：空白處填充內容，默認無 """ 20 """ 21 S.center(width[, fillchar]) -> string 22 23 Return S centered in a string of length width. Padding is 24 done using the specified fill character (default is a space) 25 """ 26 return "" 27 28 def count(self, sub, start=None, end=None): 29 """ 子序列個數 """ 30 """ 31 S.count(sub[, start[, end]]) -> int 32 33 Return the number of non-overlapping occurrences of substring sub in 34 string S[start:end]. Optional arguments start and end are interpreted 35 as in slice notation. 36 """ 37 return 0 38 39 def decode(self, encoding=None, errors=None): 40 """ 解碼 """ 41 """ 42 S.decode([encoding[,errors]]) -> object 43 44 Decodes S using the codec registered for encoding. encoding defaults 45 to the default encoding. errors may be given to set a different error 46 handling scheme. Default is 'strict' meaning that encoding errors raise 47 a UnicodeDecodeError. Other possible values are 'ignore' and 'replace' 48 as well as any other name registered with codecs.register_error that is 49 able to handle UnicodeDecodeErrors. 50 """ 51 return object() 52 53 def encode(self, encoding=None, errors=None): 54 """ 編碼，針對unicode """ 55 """ 56 S.encode([encoding[,errors]]) -> object 57 58 Encodes S using the codec registered for encoding. encoding defaults 59 to the default encoding. errors may be given to set a different error 60 handling scheme. Default is 'strict' meaning that encoding errors raise 61 a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and 62 'xmlcharrefreplace' as well as any other name registered with 63 codecs.register_error that is able to handle UnicodeEncodeErrors. 64 """ 65 return object() 66 67 def endswith(self, suffix, start=None, end=None): 68 """ 是否以 xxx 結束 """ 69 """ 70 S.endswith(suffix[, start[, end]]) -> bool 71 72 Return True if S ends with the specified suffix, False otherwise. 73 With optional start, test S beginning at that position. 74 With optional end, stop comparing S at that position. 75 suffix can also be a tuple of strings to try. 76 """ 77 return False 78 79 def expandtabs(self, tabsize=None): 80 """ 將tab轉換成空格，默認一個tab轉換成8個空格 """ 81 """ 82 S.expandtabs([tabsize]) -> string 83 84 Return a copy of S where all tab characters are expanded using spaces. 85 If tabsize is not given, a tab size of 8 characters is assumed. 86 """ 87 return "" 88 89 def find(self, sub, start=None, end=None): 90 """ 尋找子序列位置，如果沒找到，則異常 """ 91 """ 92 S.find(sub [,start [,end]]) -> int 93 94 Return the lowest index in S where substring sub is found, 95 such that sub is contained within S[start:end]. Optional 96 arguments start and end are interpreted as in slice notation. 97 98 Return -1 on failure. 99 """ 100 return 0 101 102 def format(*args, **kwargs): # known special case of str.format 103 """ 字符串格式化，動態參數，將函數式編程時細說 """ 104 """ 105 S.format(*args, **kwargs) -> string 106 107 Return a formatted version of S, using substitutions from args and kwargs. 108 The substitutions are identified by braces ('{' and '}'). 109 """ 110 pass 111 112 def index(self, sub, start=None, end=None): 113 """ 子序列位置，如果沒找到，則返回-1 """ 114 S.index(sub [,start [,end]]) -> int 115 116 Like S.find() but raise ValueError when the substring is not found. 117 """ 118 return 0 119 120 def isalnum(self): 121 """ 是否是字母和數字 """ 122 """ 123 S.isalnum() -> bool 124 125 Return True if all characters in S are alphanumeric 126 and there is at least one character in S, False otherwise. 127 """ 128 return False 129 130 def isalpha(self): 131 """ 是否是字母 """ 132 """ 133 S.isalpha() -> bool 134 135 Return True if all characters in S are alphabetic 136 and there is at least one character in S, False otherwise. 137 """ 138 return False 139 140 def isdigit(self): 141 """ 是否是數字 """ 142 """ 143 S.isdigit() -> bool 144 145 Return True if all characters in S are digits 146 and there is at least one character in S, False otherwise. 147 """ 148 return False 149 150 def islower(self): 151 """ 是否小寫 """ 152 """ 153 S.islower() -> bool 154 155 Return True if all cased characters in S are lowercase and there is 156 at least one cased character in S, False otherwise. 157 """ 158 return False 159 160 def isspace(self): 161 """是否空格 162 S.isspace() -> bool 163 164 Return True if all characters in S are whitespace 165 and there is at least one character in S, False otherwise. 166 """ 167 return False 168 169 def istitle(self): 170 """是否標題 171 S.istitle() -> bool 172 173 Return True if S is a titlecased string and there is at least one 174 character in S, i.e. uppercase characters may only follow uncased 175 characters and lowercase characters only cased ones. Return False 176 otherwise. 177 """ 178 return False 179 180 def isupper(self): 181 """是否大寫 182 S.isupper() -> bool 183 184 Return True if all cased characters in S are uppercase and there is 185 at least one cased character in S, False otherwise. 186 """ 187 return False 188 189 def join(self, iterable): 190 """ 連接 """ 191 """ 192 S.join(iterable) -> string 193 194 Return a string which is the concatenation of the strings in the 195 iterable. The separator between elements is S. 196 """ 197 return "" 198 199 def ljust(self, width, fillchar=None): 200 """ 內容左對齊，右側填充 """ 201 """ 202 S.ljust(width[, fillchar]) -> string 203 204 Return S left-justified in a string of length width. Padding is 205 done using the specified fill character (default is a space). 206 """ 207 return "" 208 209 def lower(self): 210 """ 變小寫 """ 211 """ 212 S.lower() -> string 213 214 Return a copy of the string S converted to lowercase. 215 """ 216 return "" 217 218 def lstrip(self, chars=None): 219 """ 移除左側空白 """ 220 """ 221 S.lstrip([chars]) -> string or unicode 222 223 Return a copy of the string S with leading whitespace removed. 224 If chars is given and not None, remove characters in chars instead. 225 If chars is unicode, S will be converted to unicode before stripping 226 """ 227 return "" 228 229 def partition(self, sep): 230 """ 分割，前，中，后三部分 """ 231 """ 232 S.partition(sep) -> (head, sep, tail) 233 234 Search for the separator sep in S, and return the part before it, 235 the separator itself, and the part after it. If the separator is not 236 found, return S and two empty strings. 237 """ 238 pass 239 240 def replace(self, old, new, count=None): 241 """ 替換 """ 242 """ 243 S.replace(old, new[, count]) -> string 244 245 Return a copy of string S with all occurrences of substring 246 old replaced by new. If the optional argument count is 247 given, only the first count occurrences are replaced. 248 """ 249 return "" 250 251 def rfind(self, sub, start=None, end=None): 252 """ 253 S.rfind(sub [,start [,end]]) -> int 254 255 Return the highest index in S where substring sub is found, 256 such that sub is contained within S[start:end]. Optional 257 arguments start and end are interpreted as in slice notation. 258 259 Return -1 on failure. 260 """ 261 return 0 262 263 def rindex(self, sub, start=None, end=None): 264 """ 265 S.rindex(sub [,start [,end]]) -> int 266 267 Like S.rfind() but raise ValueError when the substring is not found. 268 """ 269 return 0 270 271 def rjust(self, width, fillchar=None): 272 """ 273 S.rjust(width[, fillchar]) -> string 274 275 Return S right-justified in a string of length width. Padding is 276 done using the specified fill character (default is a space) 277 """ 278 return "" 279 280 def rpartition(self, sep): 281 """ 282 S.rpartition(sep) -> (head, sep, tail) 283 284 Search for the separator sep in S, starting at the end of S, and return 285 the part before it, the separator itself, and the part after it. If the 286 separator is not found, return two empty strings and S. 287 """ 288 pass 289 290 def rsplit(self, sep=None, maxsplit=None): 291 """ 292 S.rsplit([sep [,maxsplit]]) -> list of strings 293 294 Return a list of the words in the string S, using sep as the 295 delimiter string, starting at the end of the string and working 296 to the front. If maxsplit is given, at most maxsplit splits are 297 done. If sep is not specified or is None, any whitespace string 298 is a separator. 299 """ 300 return [] 301 302 def rstrip(self, chars=None): 303 """ 304 S.rstrip([chars]) -> string or unicode 305 306 Return a copy of the string S with trailing whitespace removed. 307 If chars is given and not None, remove characters in chars instead. 308 If chars is unicode, S will be converted to unicode before stripping 309 """ 310 return "" 311 312 def split(self, sep=None, maxsplit=None): 313 """ 分割， maxsplit最多分割幾次 """ 314 """ 315 S.split([sep [,maxsplit]]) -> list of strings 316 317 Return a list of the words in the string S, using sep as the 318 delimiter string. If maxsplit is given, at most maxsplit 319 splits are done. If sep is not specified or is None, any 320 whitespace string is a separator and empty strings are removed 321 from the result. 322 """ 323 return [] 324 325 def splitlines(self, keepends=False): 326 """ 根據換行分割 """ 327 """ 328 S.splitlines(keepends=False) -> list of strings 329 330 Return a list of the lines in S, breaking at line boundaries. 331 Line breaks are not included in the resulting list unless keepends 332 is given and true. 333 """ 334 return [] 335 336 def startswith(self, prefix, start=None, end=None): 337 """ 是否起始 """ 338 """ 339 S.startswith(prefix[, start[, end]]) -> bool 340 341 Return True if S starts with the specified prefix, False otherwise. 342 With optional start, test S beginning at that position. 343 With optional end, stop comparing S at that position. 344 prefix can also be a tuple of strings to try. 345 """ 346 return False 347 348 def strip(self, chars=None): 349 """ 移除兩段空白 """ 350 """ 351 S.strip([chars]) -> string or unicode 352 353 Return a copy of the string S with leading and trailing 354 whitespace removed. 355 If chars is given and not None, remove characters in chars instead. 356 If chars is unicode, S will be converted to unicode before stripping 357 """ 358 return "" 359 360 def swapcase(self): 361 """ 大寫變小寫，小寫變大寫 """ 362 """ 363 S.swapcase() -> string 364 365 Return a copy of the string S with uppercase characters 366 converted to lowercase and vice versa. 367 """ 368 return "" 369 370 def title(self): 371 """ 372 S.title() -> string 373 374 Return a titlecased version of S, i.e. words start with uppercase 375 characters, all remaining cased characters have lowercase. 376 """ 377 return "" 378 379 def translate(self, table, deletechars=None): 380 """ 381 轉換，需要先做一個對應表，最后一個表示刪除字符集合 382 intab = "aeiou" 383 outtab = "12345" 384 trantab = maketrans(intab, outtab) 385 str = "this is string example....wow!!!" 386 print str.translate(trantab, 'xm') 387 """ 388 389 """ 390 S.translate(table [,deletechars]) -> string 391 392 Return a copy of the string S, where all characters occurring 393 in the optional argument deletechars are removed, and the 394 remaining characters have been mapped through the given 395 translation table, which must be a string of length 256 or None. 396 If the table argument is None, no translation is applied and 397 the operation simply removes the characters in deletechars. 398 """ 399 return "" 400 401 def upper(self): 402 """ 403 S.upper() -> string 404 405 Return a copy of the string S converted to uppercase. 406 """ 407 return "" 408 409 def zfill(self, width): 410 """方法返回指定長度的字符串，原字符串右對齊，前面填充0。""" 411 """ 412 S.zfill(width) -> string 413 414 Pad a numeric string S with zeros on the left, to fill a field 415 of the specified width. The string S is never truncated. 416 """ 417 return "" 418 419 def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown 420 pass 421 422 def _formatter_parser(self, *args, **kwargs): # real signature unknown 423 pass 424 425 def __add__(self, y): 426 """ x.__add__(y) <==> x+y """ 427 pass 428 429 def __contains__(self, y): 430 """ x.__contains__(y) <==> y in x """ 431 pass 432 433 def __eq__(self, y): 434 """ x.__eq__(y) <==> x==y """ 435 pass 436 437 def __format__(self, format_spec): 438 """ 439 S.__format__(format_spec) -> string 440 441 Return a formatted version of S as described by format_spec. 442 """ 443 return "" 444 445 def __getattribute__(self, name): 446 """ x.__getattribute__('name') <==> x.name """ 447 pass 448 449 def __getitem__(self, y): 450 """ x.__getitem__(y) <==> x[y] """ 451 pass 452 453 def __getnewargs__(self, *args, **kwargs): # real signature unknown 454 pass 455 456 def __getslice__(self, i, j): 457 """ 458 x.__getslice__(i, j) <==> x[i:j] 459 460 Use of negative indices is not supported. 461 """ 462 pass 463 464 def __ge__(self, y): 465 """ x.__ge__(y) <==> x>=y """ 466 pass 467 468 def __gt__(self, y): 469 """ x.__gt__(y) <==> x>y """ 470 pass 471 472 def __hash__(self): 473 """ x.__hash__() <==> hash(x) """ 474 pass 475 476 def __init__(self, string=''): # known special case of str.__init__ 477 """ 478 str(object='') -> string 479 480 Return a nice string representation of the object. 481 If the argument is a string, the return value is the same object. 482 # (copied from class doc) 483 """ 484 pass 485 486 def __len__(self): 487 """ x.__len__() <==> len(x) """ 488 pass 489 490 def __le__(self, y): 491 """ x.__le__(y) <==> x<=y """ 492 pass 493 494 def __lt__(self, y): 495 """ x.__lt__(y) <==> x<y """ 496 pass 497 498 def __mod__(self, y): 499 """ x.__mod__(y) <==> x%y """ 500 pass 501 502 def __mul__(self, n): 503 """ x.__mul__(n) <==> x*n """ 504 pass 505 506 @staticmethod # known case of __new__ 507 def __new__(S, *more): 508 """ T.__new__(S, ...) -> a new object with type S, a subtype of T """ 509 pass 510 511 def __ne__(self, y): 512 """ x.__ne__(y) <==> x!=y """ 513 pass 514 515 def __repr__(self): 516 """ x.__repr__() <==> repr(x) """ 517 pass 518 519 def __rmod__(self, y): 520 """ x.__rmod__(y) <==> y%x """ 521 pass 522 523 def __rmul__(self, n): 524 """ x.__rmul__(n) <==> n*x """ 525 pass 526 527 def __sizeof__(self): 528 """ S.__sizeof__() -> size of S in memory, in bytes """ 529 pass 530 531 def __str__(self): 532 """ x.__str__() <==> str(x) """ 533 pass 534 535 str 536 537 str Code
2.字符串常用方法：
（1）capitalize：將首字母大寫
1 >>> name = 'hello' 2 >>> name.capitalize() 3 'Hello'
（2）center/ljust/rjust：固定字符串長度，居中/居左/居右 ，下面是使用示例，當然沒有正常人會上來就這么用，一般用在打印列表和字典的時候整理格式。
1 >>> str1='zhenghao love xiaokai' 2 >>> str1.center(30,'*') #設置格式左對齊，其余剩余部分由‘*’填充 3 '****zhenghao love xiaokai*****' 4 >>> str1.ljust(30, ) #設置格式左對齊，其余剩余部分由空格填充 5 'zhenghao love xiaokai ' 6 >>> str1.rjust(30,'$') #設置格式左對齊，其余剩余部分由‘$’填充 7 '$$$$$$$$$zhenghao love xiaokai' 8 >>>
（3）count：子序列個數，用來統計一個字符串中包含指定子序列的個數。這個子序列可以是一個字符，也可以是多個字符~~
1 >>> str1 = 'hello,world'
2 >>> str1.count('o')
3 2
4 >>> str1.count('he')
5 1
（4）encode/decode：編碼/解碼，如下左圖，各個編碼之間是不能直接轉換的，計算機內存中默認存儲的編碼格式是unicode，所以當我們需要將編碼在utf8和gbk之間轉換的時候，都需要和unicode做操作。
我的終端編碼是gbk編碼的，當我創建一個string = '景'時，string就被存儲成gbk格式。此時我想把gbk格式轉換成utf8格式，就要先將原gbk格式的string轉換成unicode格式，然后再將unicode轉換成utf8格式。如下右圖，老師說，把這個字整亂碼了我們的目的就達到了，哈~
（5）endswith:是否以...（子串）結尾。這里的子串依然可以是一個或多個字符。
1 >>> str1 = 'hello,Have a nice day'
2 >>> str1.endswith('day')
3 True
（6）expandtabs：將tab轉換成空格，默認一個tab轉換成8個空格。當然這里也可以自行指定轉換成多少個空格，要不是怕寫不下，我就指定它轉成千八百個。。。
1 >>> name = ' E' 2 >>> name.expandtabs() 3 ' E' 4 >>> name.expandtabs(20) 5 ' E'
（7）find：返回字符串中第一個子序列的下標。
rfind：和find用法一樣，只是它是從右向左查找
index：和find的左右一致，只是find找不到的時候會返回-1，而index找不到的時候會報錯
值得注意的是，當我們在一個字符串中查找某一個子序列的時候，如果這個字符串中含有多個子序列，只會返回第一個找到的下標，不會返回其他的。
3 4
4 >>> name.find('t')
5 -1
6 >>> name.index('e')
7 1
8 >>> name.index('t')
9
10 Traceback (most recent call last):
11 File "<pyshell#234>", line 1, in <module>
12 name.index('t')
13 ValueError: substring not found
（8）format：各種格式化，動態參數。
（9）isalnum/isalpha/isdigit/isspace/islower/istitle/isupper:是否是字母或數字/是否字母/是否數字/是否空格/是否小寫/是否標題/是否全大寫，總之都是一些判斷的方法，返回的不是True就是False。。。
（10）partition/split：這兩個方法都用來分割。
partition會將指定的子串串提取並將子串兩側內容分割，只匹配一次，並返回元祖；
split會根據指定子串，將整個字符串所有匹配的子串匹配到並剔除，將其他內容分割，返回數組。
1 >>> food = 'apple,banana,chocolate'
2 >>> food.split(',')
3 ['apple', 'banana', 'chocolate']
4 >>> food.partition(',')
5 ('apple', ',', 'banana,chocolate')
（11）replace：替換。會替換字符串中所有符合條件的子串。。。原諒我的chinglish。。。
1 >>> str1 = 'I\'m Rita,Do you remember,Rita?'
2 >>> str1.replace('Rita','Eva')
3 "I'm Eva,Do you remember,Eva?"
（12）swapcase：大寫變小寫，小寫變大寫
1 >>> str1 = 'I\'m Eva' 2 >>> str1.swapcase() 3 "i'M eVA"
（13）translate：替換，刪除字符串。這個方法的使用比較麻煩，在使用前需要引入string類，並調用其中的maketrans方法建立映射關系。這樣，在translate方法中，加入映射參數，就可以看到效果了。如下‘aeiou’分別和‘12345’建立了映射關系，於是在最后，aeiou都被12345相應的替換掉了，translate第二個參數是刪除，它刪除了所有的‘.’
1 >>> in_tab = 'aeiou' 2 >>> out_tab = '12345' 3 >>> import string 4 >>> transtab = string.maketrans(in_tab,out_tab) 5 >>> str = 'this is a translate example...wow!' 6 >>> str1 = 'this is a translate example...wow!' 7 >>> print str1.translate(transtab,'..') 8 th3s 3s 1 tr1nsl1t2 2x1mpl2w4w!
3.字符串轉義字符：
如果字符串內部既包含'又包含"怎么辦？可以用轉義字符\來標識，比如：
'I\'m \"OK\"!'
表示的字符串內容是：
I'm "OK"!
轉義字符\可以轉義很多字符，比如\n表示換行，\t表示制表符，字符\本身也要轉義，所以\\表示的字符就是\，可以在Python的交互式命令行用print()打印字符串看看：
1 >>> print('I\'m ok.') 2 I'm ok. 3 >>> print('I\'m learning\nPython.') 4 I'm learning 5 Python. 6 >>> print('\\\n\\') 7 \ 8 \
如果字符串里面有很多字符都需要轉義，就需要加很多\，為了簡化，Python還允許用r''表示''內部的字符串默認不轉義，可以自己試試：
1 >>> print('\\\t\\') 2 \ \ 3 >>> print(r'\\\t\\') 4 \\\t\\
如果字符串內部有很多換行，用\n寫在一行里不好閱讀，為了簡化，Python允許用'''...'''的格式表示多行內容，可以自己試試：
1 >>> print('''line1 2 3 ... line2 4 ... line3''') 5 line1 6 line2 7 line3
上面是在交互式命令行內輸入，注意在輸入多行內容時，提示符由>>>變為...，提示你可以接着上一行輸入。如果寫成程序，就是：
1 print('''line1 2 line2 3 line3''')
多行字符串'''...'''還可以在前面加上r使用，請自行測試。
4.字符串格式化，占位符：
在Python中，采用的格式化方式和C語言是一致的，用%實現，舉例如下：
1 >>> 'Hello, %s' % 'world' 2 'Hello, world' 3 >>> 'Hi, %s, you have $%d.' % ('zh', 1000000) 4 'Hi, zh, you have $1000000.'
你可能猜到了，%運算符就是用來格式化字符串的。在字符串內部，%s表示用字符串替換，%d表示用整數替換，有幾個%?占位符，后面就跟幾個變量或者值，順序要對應好。如果只有一個%?，括號可以省略。
常見的占位符有：
| %d | 整數 |
| %f | 浮點數 |
| %s | 字符串 |
| %x | 十六進制整數 |
其中，格式化整數和浮點數還可以指定是否補0和整數與小數的位數：
1 >>> '%2d-%02d' % (3, 1) 2 ' 3-01' 3 >>> '%.2f' % 3.1415926 4 '3.14'
如果你不太確定應該用什么，%s永遠起作用，它會把任何數據類型轉換為字符串：
1 >>> 'Age: %s. Gender: %s' % (25, True) 2 'Age: 25. Gender: True’
有些時候，字符串里面的%是一個普通字符怎么辦？這個時候就需要轉義，用%%來表示一個%：
1 >>> 'growth rate: %d %%' % 7 2 'growth rate: 7 %'
其實，上面這種格式化方法，常常被認為是太“古老”了。因為在 Python 中還有新的格式化方法。
1 >>> s1 = "I like {}".format("python") 2 >>> s1 3 'I like python' 4 >>> s2 = "Suzhou is more than {} years. {} lives in here.".format(2500, "qiwsir") 5 >>> s2 6 'Suzhou is more than 2500 years. qiwsir lives in here.'
這就是 Python 非常提倡的 string.format()的格式化方法，其中 {} 作為占位符。
這種方法真的是非常好，而且非常簡單，只需要將對應的東西，按照順序在 format 后面的括號中排列好，分別對應占位符 {} 即可。我喜歡的方法。
如果你覺得還不明確，還可以這樣來做。
1 >>> print "Suzhou is more than {year} years. {name} lives in here.".format(year=2500, name="qiwsir") 2 Suzhou is more than 2500 years. qiwsir lives in here.
真的很簡潔，堪稱優雅。
其實，還有一種格式化的方法，被稱為“字典格式化”，這里僅僅列一個例子，如果看官要了解字典的含義，本教程后續會有的。
1 >>> lang = "Python" 2 >>> print "I love %(program)s"%{"program":lang} 3 I love Python
列舉了三種基本格式化的方法，你喜歡那種？我推薦：string.format()
5.字符串的索引和切片
例如這樣一個字符串 Python，它就是幾個字符：P,y,t,h,o,n，排列起來。這種排列是非常嚴格的，不僅僅是字符本身，而且還有順序，換言之，如果某個字符換了，就編程一個新字符串了；如果這些字符順序發生變化了，也成為了一個新字符串。在 Python 中，把像字符串這樣的對象類型（后面還會冒出來類似的其它有這種特點的對象類型，比如列表），統稱為序列。顧名思義，序列就是“有序排列”。
1 >>> str='python' 2 >>> str[0] 3 'p' 4 >>> str[:4] 5 'pyth' 6 >>> str[:] 7 'python' 8 >>> str[1:4] 9 'yth' 10 >>> str[-3:-1] 11 'ho' 12 >>> str.index('t') 13 2 14 >>>
6.字符串連接
1 >>> a='三毛' 2 >>> s='荷西' 3 >>> z=a+s 4 >>> z 5 '\xe4\xb8\x89\xe6\xaf\x9b\xe8\x8d\xb7\xe8\xa5\xbf' 6 >>> print(z) 7 三毛荷西 8 >>>