一：數字 int
int(整型)：
在32位機器上，整數的位數為32位，取值範圍為-2**31～2**31-1，即-2147483648～2147483647
在64位系統上，整數的位數為64位，取值範圍為-2**63～2**63-1，即-9223372036854775808～9223372036854775807
long（長整型）：
跟C語言不同，Python的長整數沒有指定位寬，即：Python沒有限制長整數數值的大小，但實際上由于機器記憶體有限，我們使用的長整數數值不可能無限大
注意：自從python2.2起，如果整數發生溢出，python會自動将整數資料轉換為長整數，是以如今在長整數資料後面不加字母L也不會導緻嚴重後果了
float（浮點型）：
浮點數用來處理實數，即帶有小數的數字，類似于C語言中的double類型，占8個位元組（64位），其中52位表示底，11位表示指數，剩下一位表示符号
class int(object):
"""
int(x=0) -> int or long
int(x, base=10) -> int or long
Convert a number or string to an integer, or return 0 if no arguments
are given. If x is floating point, the conversion truncates towards zero.
If x is outside the integer range, the function returns a long instead.
If x is not a number or if base is given, then x must be a string or
Unicode object representing an integer literal in the given base. The
literal can be preceded by '+' or '-' and be surrounded by whitespace.
The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to
interpret the base from the string as an integer literal.
>>> int('0b100', base=0)
"""
def bit_length(self):
""" 傳回表示該數字的時占用的最少位數 """
"""
int.bit_length() -> int
Number of bits necessary to represent self in binary.
>>> bin(37)
'0b100101'
>>> (37).bit_length()
"""
return 0
def conjugate(self, *args, **kwargs): # real signature unknown
""" 傳回該複數的共轭複數 """
""" Returns self, the complex conjugate of any int. """
pass
def __abs__(self):
""" 傳回絕對值 """
""" x.__abs__() <==> abs(x) """
pass
def __add__(self, y):
""" x.__add__(y) <==> x+y """
pass
def __and__(self, y):
""" x.__and__(y) <==> x&y """
pass
def __cmp__(self, y):
""" 比較兩個數大小 """
""" x.__cmp__(y) <==> cmp(x,y) """
pass
def __coerce__(self, y):
""" 強制生成一個元組 """
""" x.__coerce__(y) <==> coerce(x, y) """
pass
def __divmod__(self, y):
""" 相除，得到商和餘數組成的元組 """
""" x.__divmod__(y) <==> divmod(x, y) """
pass
def __div__(self, y):
""" x.__div__(y) <==> x/y """
pass
def __float__(self):
""" 轉換為浮點類型 """
""" x.__float__() <==> float(x) """
pass
def __floordiv__(self, y):
""" x.__floordiv__(y) <==> x//y """
pass
def __format__(self, *args, **kwargs): # real signature unknown
pass
def __getattribute__(self, name):
""" x.__getattribute__('name') <==> x.name """
pass
def __getnewargs__(self, *args, **kwargs): # real signature unknown
""" 内部調用 __new__方法或建立對象時傳入參數使用 """
pass
def __hash__(self):
"""如果對象object為哈希表類型，傳回對象object的哈希值。哈希值為整數。在字典查找中，哈希值用于快速比較字典的鍵。兩個數值如果相等，則哈希值也相等。"""
""" x.__hash__() <==> hash(x) """
pass
def __hex__(self):
""" 傳回目前數的 十六進制 表示 """
""" x.__hex__() <==> hex(x) """
pass
def __index__(self):
""" 用于切片，數字無意義 """
""" x[y:z] <==> x[y.__index__():z.__index__()] """
pass
def __init__(self, x, base=10): # known special case of int.__init__
""" 構造方法，執行 x = 123 或 x = int(10) 時，自動調用，暫時忽略 """
"""
int(x=0) -> int or long
int(x, base=10) -> int or long
Convert a number or string to an integer, or return 0 if no arguments
are given. If x is floating point, the conversion truncates towards zero.
If x is outside the integer range, the function returns a long instead.
If x is not a number or if base is given, then x must be a string or
Unicode object representing an integer literal in the given base. The
literal can be preceded by '+' or '-' and be surrounded by whitespace.
The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to
interpret the base from the string as an integer literal.
>>> int('0b100', base=0)
# (copied from class doc)
"""
pass
def __int__(self):
""" 轉換為整數 """
""" x.__int__() <==> int(x) """
pass
def __invert__(self):
""" x.__invert__() <==> ~x """
pass
def __long__(self):
""" 轉換為長整數 """
""" x.__long__() <==> long(x) """
pass
def __lshift__(self, y):
""" x.__lshift__(y) <==> x<<y """
pass
def __mod__(self, y):
""" x.__mod__(y) <==> x%y """
pass
def __mul__(self, y):
""" x.__mul__(y) <==> x*y """
pass
def __neg__(self):
""" x.__neg__() <==> -x """
pass
@staticmethod # known case of __new__
def __new__(S, *more):
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __nonzero__(self):
""" x.__nonzero__() <==> x != 0 """
pass
def __oct__(self):
""" 傳回改值的 八進制 表示 """
""" x.__oct__() <==> oct(x) """
pass
def __or__(self, y):
""" x.__or__(y) <==> x|y """
pass
def __pos__(self):
""" x.__pos__() <==> +x """
pass
def __pow__(self, y, z=None):
""" 幂，次方 """
""" x.__pow__(y[, z]) <==> pow(x, y[, z]) """
pass
def __radd__(self, y):
""" x.__radd__(y) <==> y+x """
pass
def __rand__(self, y):
""" x.__rand__(y) <==> y&x """
pass
def __rdivmod__(self, y):
""" x.__rdivmod__(y) <==> divmod(y, x) """
pass
def __rdiv__(self, y):
""" x.__rdiv__(y) <==> y/x """
pass
def __repr__(self):
"""轉化為解釋器可讀取的形式 """
""" x.__repr__() <==> repr(x) """
pass
def __str__(self):
"""轉換為人閱讀的形式，如果沒有适于人閱讀的解釋形式的話，則傳回解釋器課閱讀的形式"""
""" x.__str__() <==> str(x) """
pass
def __rfloordiv__(self, y):
""" x.__rfloordiv__(y) <==> y//x """
pass
def __rlshift__(self, y):
""" x.__rlshift__(y) <==> y<<x """
pass
def __rmod__(self, y):
""" x.__rmod__(y) <==> y%x """
pass
def __rmul__(self, y):
""" x.__rmul__(y) <==> y*x """
pass
def __ror__(self, y):
""" x.__ror__(y) <==> y|x """
pass
def __rpow__(self, x, z=None):
""" y.__rpow__(x[, z]) <==> pow(x, y[, z]) """
pass
def __rrshift__(self, y):
""" x.__rrshift__(y) <==> y>>x """
pass
def __rshift__(self, y):
""" x.__rshift__(y) <==> x>>y """
pass
def __rsub__(self, y):
""" x.__rsub__(y) <==> y-x """
pass
def __rtruediv__(self, y):
""" x.__rtruediv__(y) <==> y/x """
pass
def __rxor__(self, y):
""" x.__rxor__(y) <==> y^x """
pass
def __sub__(self, y):
""" x.__sub__(y) <==> x-y """
pass
def __truediv__(self, y):
""" x.__truediv__(y) <==> x/y """
pass
def __trunc__(self, *args, **kwargs):
""" 傳回數值被截取為整形的值，在整形中無意義 """
pass
def __xor__(self, y):
""" x.__xor__(y) <==> x^y """
pass
denominator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
""" 分母 = 1 """
"""the denominator of a rational number in lowest terms"""
imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
""" 虛數，無意義 """
"""the imaginary part of a complex number"""
numerator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
""" 分子 = 數字大小 """
"""the numerator of a rational number in lowest terms"""
real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
""" 實屬，無意義 """
"""the real part of a complex number"""
int int
二：字元串 str
class str(basestring):
"""
str(object='') -> string
Return a nice string representation of the object.
If the argument is a string, the return value is the same object.
"""
def capitalize(self):
""" 首字母變大寫 """
"""
S.capitalize() -> string
Return a copy of the string S with only its first character
capitalized.
"""
return ""
def center(self, width, fillchar=None):
""" 内容居中，width：總長度；fillchar：空白處填充内容，預設無 """
"""
S.center(width[, fillchar]) -> string
Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)
"""
return ""
def count(self, sub, start=None, end=None):
""" 子序列個數 """
"""
S.count(sub[, start[, end]]) -> int
Return the number of non-overlapping occurrences of substring sub in
string S[start:end]. Optional arguments start and end are interpreted
as in slice notation.
"""
return 0
def decode(self, encoding=None, errors=None):
""" 解碼 """
"""
S.decode([encoding[,errors]]) -> object
Decodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
as well as any other name registered with codecs.register_error that is
able to handle UnicodeDecodeErrors.
"""
return object()
def encode(self, encoding=None, errors=None):
""" 編碼，針對unicode """
"""
S.encode([encoding[,errors]]) -> object
Encodes S using the codec registered for encoding. encoding defaults
to the default encoding. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that is able to handle UnicodeEncodeErrors.
"""
return object()
def endswith(self, suffix, start=None, end=None):
""" 是否以 xxx 結束 """
"""
S.endswith(suffix[, start[, end]]) -> bool
Return True if S ends with the specified suffix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
"""
return False
def expandtabs(self, tabsize=None):
""" 将tab轉換成空格，預設一個tab轉換成8個空格 """
"""
S.expandtabs([tabsize]) -> string
Return a copy of S where all tab characters are expanded using spaces.
If tabsize is not given, a tab size of 8 characters is assumed.
"""
return ""
def find(self, sub, start=None, end=None):
""" 尋找子序列位置，如果沒找到，傳回 -1 """
"""
S.find(sub [,start [,end]]) -> int
Return the lowest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
"""
return 0
def format(*args, **kwargs): # known special case of str.format
""" 字元串格式化，動态參數，将函數式程式設計時細說 """
"""
S.format(*args, **kwargs) -> string
Return a formatted version of S, using substitutions from args and kwargs.
The substitutions are identified by braces ('{' and '}').
"""
pass
def index(self, sub, start=None, end=None):
""" 子序列位置，如果沒找到，報錯 """
S.index(sub [,start [,end]]) -> int
Like S.find() but raise ValueError when the substring is not found.
"""
return 0
def isalnum(self):
""" 是否是字母和數字 """
"""
S.isalnum() -> bool
Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.
"""
return False
def isalpha(self):
""" 是否是字母 """
"""
S.isalpha() -> bool
Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
"""
return False
def isdigit(self):
""" 是否是數字 """
"""
S.isdigit() -> bool
Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
"""
return False
def islower(self):
""" 是否小寫 """
"""
S.islower() -> bool
Return True if all cased characters in S are lowercase and there is
at least one cased character in S, False otherwise.
"""
return False
def isspace(self):
"""
S.isspace() -> bool
Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.
"""
return False
def istitle(self):
"""
S.istitle() -> bool
Return True if S is a titlecased string and there is at least one
character in S, i.e. uppercase characters may only follow uncased
characters and lowercase characters only cased ones. Return False
otherwise.
"""
return False
def isupper(self):
"""
S.isupper() -> bool
Return True if all cased characters in S are uppercase and there is
at least one cased character in S, False otherwise.
"""
return False
def join(self, iterable):
""" 連接配接 """
"""
S.join(iterable) -> string
Return a string which is the concatenation of the strings in the
iterable. The separator between elements is S.
"""
return ""
def ljust(self, width, fillchar=None):
""" 内容左對齊，右側填充 """
"""
S.ljust(width[, fillchar]) -> string
Return S left-justified in a string of length width. Padding is
done using the specified fill character (default is a space).
"""
return ""
def lower(self):
""" 變小寫 """
"""
S.lower() -> string
Return a copy of the string S converted to lowercase.
"""
return ""
def lstrip(self, chars=None):
""" 移除左側空白 """
"""
S.lstrip([chars]) -> string or unicode
Return a copy of the string S with leading whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
"""
return ""
def partition(self, sep):
""" 分割，前，中，後三部分 """
"""
S.partition(sep) -> (head, sep, tail)
Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it. If the separator is not
found, return S and two empty strings.
"""
pass
def replace(self, old, new, count=None):
""" 替換 """
"""
S.replace(old, new[, count]) -> string
Return a copy of string S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
"""
return ""
def rfind(self, sub, start=None, end=None):
"""
S.rfind(sub [,start [,end]]) -> int
Return the highest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation.
Return -1 on failure.
"""
return 0
def rindex(self, sub, start=None, end=None):
"""
S.rindex(sub [,start [,end]]) -> int
Like S.rfind() but raise ValueError when the substring is not found.
"""
return 0
def rjust(self, width, fillchar=None):
"""
S.rjust(width[, fillchar]) -> string
Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space)
"""
return ""
def rpartition(self, sep):
"""
S.rpartition(sep) -> (head, sep, tail)
Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it. If the
separator is not found, return two empty strings and S.
"""
pass
def rsplit(self, sep=None, maxsplit=None):
"""
S.rsplit([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the
delimiter string, starting at the end of the string and working
to the front. If maxsplit is given, at most maxsplit splits are
done. If sep is not specified or is None, any whitespace string
is a separator.
"""
return []
def rstrip(self, chars=None):
"""
S.rstrip([chars]) -> string or unicode
Return a copy of the string S with trailing whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
"""
return ""
def split(self, sep=None, maxsplit=None):
""" 分割， maxsplit最多分割幾次 """
"""
S.split([sep [,maxsplit]]) -> list of strings
Return a list of the words in the string S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are removed
from the result.
"""
return []
def splitlines(self, keepends=False):
""" 根據換行分割 """
"""
S.splitlines(keepends=False) -> list of strings
Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
"""
return []
def startswith(self, prefix, start=None, end=None):
""" 是否起始 """
"""
S.startswith(prefix[, start[, end]]) -> bool
Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
"""
return False
def strip(self, chars=None):
""" 移除兩段空白 """
"""
S.strip([chars]) -> string or unicode
Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
If chars is unicode, S will be converted to unicode before stripping
"""
return ""
def swapcase(self):
""" 大寫變小寫，小寫變大寫 """
"""
S.swapcase() -> string
Return a copy of the string S with uppercase characters
converted to lowercase and vice versa.
"""
return ""
def title(self):
"""
S.title() -> string
Return a titlecased version of S, i.e. words start with uppercase
characters, all remaining cased characters have lowercase.
"""
return ""
def translate(self, table, deletechars=None):
"""
轉換，需要先做一個對應表，最後一個表示删除字元集合
intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab)
str = "this is string example....wow!!!"
print str.translate(trantab, 'xm')
"""
"""
S.translate(table [,deletechars]) -> string
Return a copy of the string S, where all characters occurring
in the optional argument deletechars are removed, and the
remaining characters have been mapped through the given
translation table, which must be a string of length 256 or None.
If the table argument is None, no translation is applied and
the operation simply removes the characters in deletechars.
"""
return ""
def upper(self):
"""
S.upper() -> string
Return a copy of the string S converted to uppercase.
"""
return ""
def zfill(self, width):
"""方法傳回指定長度的字元串，原字元串右對齊，前面填充0。"""
"""
S.zfill(width) -> string
Pad a numeric string S with zeros on the left, to fill a field
of the specified width. The string S is never truncated.
"""
return ""
def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown
pass
def _formatter_parser(self, *args, **kwargs): # real signature unknown
pass
def __add__(self, y):
""" x.__add__(y) <==> x+y """
pass
def __contains__(self, y):
""" x.__contains__(y) <==> y in x """
pass
def __eq__(self, y):
""" x.__eq__(y) <==> x==y """
pass
def __format__(self, format_spec):
"""
S.__format__(format_spec) -> string
Return a formatted version of S as described by format_spec.
"""
return ""
def __getattribute__(self, name):
""" x.__getattribute__('name') <==> x.name """
pass
def __getitem__(self, y):
""" x.__getitem__(y) <==> x[y] """
pass
def __getnewargs__(self, *args, **kwargs): # real signature unknown
pass
def __getslice__(self, i, j):
"""
x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
"""
pass
def __ge__(self, y):
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y):
""" x.__gt__(y) <==> x>y """
pass
def __hash__(self):
""" x.__hash__() <==> hash(x) """
pass
def __init__(self, string=''): # known special case of str.__init__
"""
str(object='') -> string
Return a nice string representation of the object.
If the argument is a string, the return value is the same object.
# (copied from class doc)
"""
pass
def __len__(self):
""" x.__len__() <==> len(x) """
pass
def __le__(self, y):
""" x.__le__(y) <==> x<=y """
pass
def __lt__(self, y):
""" x.__lt__(y) <==> x<y """
pass
def __mod__(self, y):
""" x.__mod__(y) <==> x%y """
pass
def __mul__(self, n):
""" x.__mul__(n) <==> x*n """
pass
@staticmethod # known case of __new__
def __new__(S, *more):
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __ne__(self, y):
""" x.__ne__(y) <==> x!=y """
pass
def __repr__(self):
""" x.__repr__() <==> repr(x) """
pass
def __rmod__(self, y):
""" x.__rmod__(y) <==> y%x """
pass
def __rmul__(self, n):
""" x.__rmul__(n) <==> n*x """
pass
def __sizeof__(self):
""" S.__sizeof__() -> size of S in memory, in bytes """
pass
def __str__(self):
""" x.__str__() <==> str(x) """
pass
str str
字元串是 Python 中最常用的資料類型。我們可以使用引号，雙引号，或三引号來建立字元串。
a = 'poe'
b = "bruce"
c = """Jacky Chen""" 1：字元串連接配接
方法一：join方法
1 a = ['a','b','c','d']
2 content = ''
3 content = ' '.join(a)
4 print(content) 方法二：用字元串的替換占位符替換
1 a = ['a','b','c','d']
2 content = ''
3 content = '%s%s%s%s' % tuple(a)
4 print(content) 方法三：for循環
1 a = ['a','b','c','d']
2 content = ''
3 for i in a:
4 content += i
5 print(content) 注意：方法三效率低，不推薦使用！
原因：在循環連接配接字元串的時候，他每次連接配接一次，就要重新開辟空間，然後把字元串連接配接起來，再放入新的空間，再一次循環，又要開辟新的空間，把字元串連接配接起來放入新的空間，如此反複，記憶體操作比較頻繁，每次都要計算記憶體空間，然後開辟記憶體空間，再釋放記憶體空間，效率非常低，你也許操作比較少的資料的時候看不出來，感覺影響不大，但是你碰到操作資料量比較多的時候，這個方法就要退休了。
2：字元串截取
我們可以通過索引來提取想要擷取的字元，可以把python的字元串也做為字元串的清單就更好了解
python的字串清單有2種取值順序：
1是從左到右索引預設0開始的，最大範圍是字元串長度少1
s = 'ilovepython'
s[0]的結果是i 2是從右到左索引預設-1開始的，最大範圍是字元串開頭
s = 'ilovepython'
s[-1]的結果是n 上面這個是取得一個字元，如果你的實際要取得一段子串的話，可以用到變量[頭下标:尾下标]，就可以截取相應的字元串，其中下标是從0開始算起，可以是正數或負數，下标可以為空表示取到頭或尾。
比如
s = 'ilovepython'
s[1:5]的結果是love 當使用以冒号分隔的字元串，python傳回一個新的對象，結果包含了以這對偏移辨別的連續的内容，左邊的開始是包含了下邊界，比如上面的結果包含了s[1]的值l，而取到的最大範圍不包括上邊界，就是s[5]的值p
注：s[1:5]形式截頭不截尾
3：字元串替換
方法一：使用repalce方法
1 a = 'hello world'
2 b = a.replace('world','python')
3 print(b) 方法二：使用正規表達式
1 import re
2 a = 'hello world'
3 strinfo = re.compile('world')
4 b = strinfo.sub('python',a)
5 print(b) 4：字元串比較
cmp方法比較兩個對象，并根據結果傳回一個整數。cmp(x,y)如果X< Y,傳回值是負數 如果X>Y 傳回的值為正數。
1 str1 = 'strch'
2 str2 = 'strchr'
3 print(cmp(str1,str2))
4 ## -1 5：字元串相加
我們通過操作符号+來進行字元串的相加，不過建議還是用其他的方式來進行字元串的拼接，這樣效率高點。
原因：在循環連接配接字元串的時候，他每次連接配接一次，就要重新開辟空間，然後把字元串連接配接起來，再放入新的空間，再一次循環，又要開辟新的空間，把字元串連接配接起來放入新的空間，如此反複，記憶體操作比較頻繁，每次都要計算記憶體空間，然後開辟記憶體空間，再釋放記憶體空間，效率非常低。
1 str1 = 'strch'
2 str2 = 'strchr'
3 print(str1+str2)
4 ## strchstrchr 6：字元串查找
python 字元串查找有4個方法，1 find,2 index方法，3 rfind方法,4 rindex方法。
方法一：find方法
1 info = 'abca'
2 print info.find('a')##從下标0開始，查找在字元串裡第一個出現的子串，傳回結果：0
3
4 info = 'abca'
5 print info.find('a',1)##從下标1開始，查找在字元串裡第一個出現的子串：傳回結果3
6
7 info = 'abca'
8 print info.find('333')##傳回-1,查找不到傳回-1 方法二：index方法
python 的index方法是在字元串裡查找子串第一次出現的位置，類似字元串的find方法，不過比find方法更好的是，如果查找不到子串，會抛出異常，而不是傳回-1
1 info = 'abca'
2 print info.index('a')
3 print info.index('33') 7：字元串分割
字元串分割，可以用split,rsplit方法，通過相應的規則來切割成生成清單對象
1 info = 'name:haha,age:20$name:python,age:30$name:fef,age:55'
2 content = info.split('$')
3 print content
4 ## ['name:haha,age:20', 'name:python,age:30', 'name:fef,age:55'] 8：字元串反轉
1 a = 'abcd'
2 b = a[::-1]##[::-1]通過步進反轉
3 print b 9：字元串編碼
10：字元串追加和拼接
通過字元串的占位符來進行字元串的拼接
#1 元組拼接
m = 'python'
astr = 'i love %s' % m
print astr
#2 字元串的format方法
m = 'python'
astr = "i love {python}".format(python=m)
print astr
#3 字典格式化字元串
m = 'python'
astr = "i love %(python)s " % {'python':m}
print astr 11：字元串複制
#通過變量來進行指派
fstr = 'strcpy'
sstr = fstr
fstr = 'strcpy2'
print sstr 12：字元串長度
#通過内置方法len()來計算字元串的長度，注意這個計算的是字元的長度。
aa = 'afebb'
bb = '你'
print len(aa)
print len(bb) 13：字元串大小寫
#通過下面的upper(),lower()等方法來轉換大小寫
S.upper()#S中的字母大寫
S.lower() #S中的字母小寫
S.capitalize() #首字母大寫
S.istitle() #S是否是首字母大寫的
S.isupper() #S中的字母是否便是大寫
S.islower() #S中的字母是否全是小寫 14：字元串去空格
#通過strip(),lstrip(),rstrip()方法去除字元串的空格
S.strip() #去掉字元串的左右空格
S.lstrip() #去掉字元串的左邊空格
S.rstrip() #去掉字元串的右邊空格
#注意：strip()函數不僅可以去空格還可以去除指定的字元，如
S.strip("\n") 15：字元串其他方法
#字元串相關的其他方法:count(),join()方法等。
S.center(width, [fillchar]) #中間對齊
S.count(substr, [start, [end]]) #計算substr在S中出現的次數
S.expandtabs([tabsize]) #把S中的tab字元替換沒空格，每個tab替換為tabsize個空格，預設是8個
S.isalnum() #是否全是字母和數字，并至少有一個字元
S.isalpha() #是否全是字母，并至少有一個字元
S.isspace() #是否全是空白字元，并至少有一個字元
S.join()#S中的join，把清單生成一個字元串對象
S.ljust(width,[fillchar]) #輸出width個字元，S左對齊，不足部分用fillchar填充，預設的為空格。
S.rjust(width,[fillchar]) #右對齊
S.splitlines([keepends]) #把S按照行分割符分為一個list，keepends是一個bool值，如果為真每行後而會保留行分割符。
S.swapcase() #大小寫互換 三：清單 list
class list(object):
"""
list() -> new empty list
list(iterable) -> new list initialized from iterable's items
"""
def append(self, p_object): # real signature unknown; restored from __doc__
""" L.append(object) -- append object to end """
pass
def count(self, value): # real signature unknown; restored from __doc__
""" L.count(value) -> integer -- return number of occurrences of value """
return 0
def extend(self, iterable): # real signature unknown; restored from __doc__
""" L.extend(iterable) -- extend list by appending elements from the iterable """
pass
def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
"""
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
"""
return 0
def insert(self, index, p_object): # real signature unknown; restored from __doc__
""" L.insert(index, object) -- insert object before index """
pass
def pop(self, index=None): # real signature unknown; restored from __doc__
"""
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
"""
pass
def remove(self, value): # real signature unknown; restored from __doc__
"""
L.remove(value) -- remove first occurrence of value.
Raises ValueError if the value is not present.
"""
pass
def reverse(self): # real signature unknown; restored from __doc__
""" L.reverse() -- reverse *IN PLACE* """
pass
def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__
"""
L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
cmp(x, y) -> -1, 0, 1
"""
pass
def __add__(self, y): # real signature unknown; restored from __doc__
""" x.__add__(y) <==> x+y """
pass
def __contains__(self, y): # real signature unknown; restored from __doc__
""" x.__contains__(y) <==> y in x """
pass
def __delitem__(self, y): # real signature unknown; restored from __doc__
""" x.__delitem__(y) <==> del x[y] """
pass
def __delslice__(self, i, j): # real signature unknown; restored from __doc__
"""
x.__delslice__(i, j) <==> del x[i:j]
Use of negative indices is not supported.
"""
pass
def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__('name') <==> x.name """
pass
def __getitem__(self, y): # real signature unknown; restored from __doc__
""" x.__getitem__(y) <==> x[y] """
pass
def __getslice__(self, i, j): # real signature unknown; restored from __doc__
"""
x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
"""
pass
def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass
def __iadd__(self, y): # real signature unknown; restored from __doc__
""" x.__iadd__(y) <==> x+=y """
pass
def __imul__(self, y): # real signature unknown; restored from __doc__
""" x.__imul__(y) <==> x*=y """
pass
def __init__(self, seq=()): # known special case of list.__init__
"""
list() -> new empty list
list(iterable) -> new list initialized from iterable's items
# (copied from class doc)
"""
pass
def __iter__(self): # real signature unknown; restored from __doc__
""" x.__iter__() <==> iter(x) """
pass
def __len__(self): # real signature unknown; restored from __doc__
""" x.__len__() <==> len(x) """
pass
def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass
def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass
def __mul__(self, n): # real signature unknown; restored from __doc__
""" x.__mul__(n) <==> x*n """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __reversed__(self): # real signature unknown; restored from __doc__
""" L.__reversed__() -- return a reverse iterator over the list """
pass
def __rmul__(self, n): # real signature unknown; restored from __doc__
""" x.__rmul__(n) <==> n*x """
pass
def __setitem__(self, i, y): # real signature unknown; restored from __doc__
""" x.__setitem__(i, y) <==> x[i]=y """
pass
def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__
"""
x.__setslice__(i, j, y) <==> x[i:j]=y
Use of negative indices is not supported.
"""
pass
def __sizeof__(self): # real signature unknown; restored from __doc__
""" L.__sizeof__() -- size of L in memory, in bytes """
pass
__hash__ = None
list list
1：建立清單
list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"]; 與字元串的索引一樣，清單索引從0開始。清單可以進行截取、組合等
2：通路清單
list1 = ['physics', 'chemistry', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print(list1[0])
print(list2[2:5])#截頭不截尾
## physics
## [3, 4, 5] 3：append方法：在清單末尾添加新的對象
aList = [123, 'xyz', 'zara', 'abc'];
aList.append( 2009 );
print "Updated List : ", aList;
## Updated List : [123, 'xyz', 'zara', 'abc', 2009] 4：count方法：統計某個元素在清單中出現的次數
aList = [123, 'xyz', 'zara', 123];
print(aList.count(123))
## 2 5：extend() 函數用于在清單末尾一次性追加另一個序列中的多個值（用新清單擴充原來的清單）
aList = [123, 'xyz', 'zara', 'abc', 123];
bList = [2009, 'manni'];
aList.extend(bList)
print "Extended List : ", aList ;
## Extended List : [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni'] 6：index() 函數用于從清單中找出某個值第一個比對項的索引位置
aList = [123, 'xyz', 'zara', 'abc'];
print "Index for xyz : ", aList.index( 'xyz' ) ;
print "Index for zara : ", aList.index( 'zara' ) ;
##Index for xyz : 1
## Index for zara : 2 7：insert() 函數用于将指定對象插入清單的指定位置
aList = [123, 'xyz', 'zara', 'abc']
aList.insert( 3, 2009)
print "Final List : ", aList
## Final List : [123, 'xyz', 'zara', 2009, 'abc'] insert()接收兩個參數，list.insert(index, obj)，第一個參數index為要插入的索引位置，第二個參數要插入的元素
8：pop() 函數用于移除清單中的一個元素（預設最後一個元素），并且傳回該元素的值
aList = [123, 'xyz', 'zara', 'abc'];
print "A List : ", aList.pop();
print "B List : ", aList.pop();
## A List : abc
## B List : zara 9：remove() 函數用于移除清單中某個值的第一個比對項
aList = [123, 'xyz', 'zara', 'abc', 'xyz'];
aList.remove('xyz');
print "List : ", aList;
aList.remove('abc');
print "List : ", aList;
## List : [123, 'zara', 'abc', 'xyz']
## List : [123, 'zara', 'xyz'] 10：清單的四種周遊方法
aList = [123, 'xyz', 'zara', 123]; 方法一：隻周遊清單中的值
for value in aList :
print(value)
####################
123
xyz
zara
123 方法二：如果需要周遊清單中的索引與值，就需要用到enumerate
for key,value in enumerate(aList) :
print(key,value)
######################
(0, 123)
(1, 'xyz')
(2, 'zara')
(3, 123) enumrate：為可疊代的對象添加序号，預設從0開始！因為清單的索引也是從0開始，是以我們在enumerate中不指定第二個參數，如有需要，可以指定從幾開始，如下：
for key,value in enumerate(aList,1) :
print(key,value)
######################################
(1, 123)
(2, 'xyz')
(3, 'zara')
(4, 123) 方法三：
for i in range(len(aList)) :
print(i,aList[i])
##############################
(0, 123)
(1, 'xyz')
(2, 'zara')
(3, 123) range和xrange：指定範圍，生成指定的數字
方法四：使用iter()
for i in iter(aList) :
print(i)
##########################################
123
xyz
zara
123 四：元組 tuple
lass tuple(object):
"""
tuple() -> empty tuple
tuple(iterable) -> tuple initialized from iterable's items
If the argument is a tuple, the return value is the same object.
"""
def count(self, value): # real signature unknown; restored from __doc__
""" T.count(value) -> integer -- return number of occurrences of value """
return 0
def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
"""
T.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
"""
return 0
def __add__(self, y): # real signature unknown; restored from __doc__
""" x.__add__(y) <==> x+y """
pass
def __contains__(self, y): # real signature unknown; restored from __doc__
""" x.__contains__(y) <==> y in x """
pass
def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__('name') <==> x.name """
pass
def __getitem__(self, y): # real signature unknown; restored from __doc__
""" x.__getitem__(y) <==> x[y] """
pass
def __getnewargs__(self, *args, **kwargs): # real signature unknown
pass
def __getslice__(self, i, j): # real signature unknown; restored from __doc__
"""
x.__getslice__(i, j) <==> x[i:j]
Use of negative indices is not supported.
"""
pass
def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass
def __hash__(self): # real signature unknown; restored from __doc__
""" x.__hash__() <==> hash(x) """
pass
def __init__(self, seq=()): # known special case of tuple.__init__
"""
tuple() -> empty tuple
tuple(iterable) -> tuple initialized from iterable's items
If the argument is a tuple, the return value is the same object.
# (copied from class doc)
"""
pass
def __iter__(self): # real signature unknown; restored from __doc__
""" x.__iter__() <==> iter(x) """
pass
def __len__(self): # real signature unknown; restored from __doc__
""" x.__len__() <==> len(x) """
pass
def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass
def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass
def __mul__(self, n): # real signature unknown; restored from __doc__
""" x.__mul__(n) <==> x*n """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __rmul__(self, n): # real signature unknown; restored from __doc__
""" x.__rmul__(n) <==> n*x """
pass
def __sizeof__(self): # real signature unknown; restored from __doc__
""" T.__sizeof__() -- size of T in memory, in bytes """
pass
tuple tuple
Python的元組與清單類似，不同之處在于元組的元素不能修改。元組使用小括号，清單使用方括号。元組建立很簡單，隻需要在括号中添加元素，并使用逗号隔開即可
tuple隻有兩個可使用的功能：count , index
1：建立元組
tup1 = ();#建立空元組
tup1 = (50,);#元組中隻包含一個元素時，需要在元素後面添加逗号 元組與字元串類似，下标索引從0開始，可以進行截取，組合等。元組的通路與清單一樣！
2：元組的連接配接組合
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');
# 以下修改元組元素操作是非法的。
# tup1[0] = 100;
# 建立一個新的元組
tup3 = tup1 + tup2;
print tup3;
##########################################
(12, 34.56, 'abc', 'xyz') 3：删除元組
元組中的元素值是不允許删除的，但我們可以使用del語句來删除整個元組，如下執行個體:
tup = ('physics', 'chemistry', 1997, 2000);
print tup;
del tup;
print "After deleting tup : "
print tup;
##########################################
以上執行個體元組被删除後，輸出變量會有異常資訊，輸出如下所示：
('physics', 'chemistry', 1997, 2000)
After deleting tup :
Traceback (most recent call last):
File "test.py", line 9, in <module>
print tup;
NameError: name 'tup' is not defined 五：字典 dict
class dict(object):
"""
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
(key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list. For example: dict(one=1, two=2)
"""
def clear(self): # real signature unknown; restored from __doc__
""" 清除内容 """
""" D.clear() -> None. Remove all items from D. """
pass
def copy(self): # real signature unknown; restored from __doc__
""" 淺拷貝 """
""" D.copy() -> a shallow copy of D """
pass
@staticmethod # known case
def fromkeys(S, v=None): # real signature unknown; restored from __doc__
"""
dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
v defaults to None.
"""
pass
def get(self, k, d=None): # real signature unknown; restored from __doc__
""" 根據key擷取值，d是預設值 """
""" D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """
pass
def has_key(self, k): # real signature unknown; restored from __doc__
""" 是否有key """
""" D.has_key(k) -> True if D has a key k, else False """
return False
def items(self): # real signature unknown; restored from __doc__
""" 所有項的清單形式 """
""" D.items() -> list of D's (key, value) pairs, as 2-tuples """
return []
def iteritems(self): # real signature unknown; restored from __doc__
""" 項可疊代 """
""" D.iteritems() -> an iterator over the (key, value) items of D """
pass
def iterkeys(self): # real signature unknown; restored from __doc__
""" key可疊代 """
""" D.iterkeys() -> an iterator over the keys of D """
pass
def itervalues(self): # real signature unknown; restored from __doc__
""" value可疊代 """
""" D.itervalues() -> an iterator over the values of D """
pass
def keys(self): # real signature unknown; restored from __doc__
""" 所有的key清單 """
""" D.keys() -> list of D's keys """
return []
def pop(self, k, d=None): # real signature unknown; restored from __doc__
""" 擷取并在字典中移除 """
"""
D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
If key is not found, d is returned if given, otherwise KeyError is raised
"""
pass
def popitem(self): # real signature unknown; restored from __doc__
""" 擷取并在字典中移除 """
"""
D.popitem() -> (k, v), remove and return some (key, value) pair as a
2-tuple; but raise KeyError if D is empty.
"""
pass
def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
""" 如果key不存在，則建立，如果存在，則傳回已存在的值且不修改 """
""" D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
pass
def update(self, E=None, **F): # known special case of dict.update
""" 更新
{'name':'alex', 'age': 18000}
[('name','sbsbsb'),]
"""
"""
D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
If E present and has a .keys() method, does: for k in E: D[k] = E[k]
If E present and lacks .keys() method, does: for (k, v) in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]
"""
pass
def values(self): # real signature unknown; restored from __doc__
""" 所有的值 """
""" D.values() -> list of D's values """
return []
def viewitems(self): # real signature unknown; restored from __doc__
""" 所有項，隻是将内容儲存至view對象中 """
""" D.viewitems() -> a set-like object providing a view on D's items """
pass
def viewkeys(self): # real signature unknown; restored from __doc__
""" D.viewkeys() -> a set-like object providing a view on D's keys """
pass
def viewvalues(self): # real signature unknown; restored from __doc__
""" D.viewvalues() -> an object providing a view on D's values """
pass
def __cmp__(self, y): # real signature unknown; restored from __doc__
""" x.__cmp__(y) <==> cmp(x,y) """
pass
def __contains__(self, k): # real signature unknown; restored from __doc__
""" D.__contains__(k) -> True if D has a key k, else False """
return False
def __delitem__(self, y): # real signature unknown; restored from __doc__
""" x.__delitem__(y) <==> del x[y] """
pass
def __eq__(self, y): # real signature unknown; restored from __doc__
""" x.__eq__(y) <==> x==y """
pass
def __getattribute__(self, name): # real signature unknown; restored from __doc__
""" x.__getattribute__('name') <==> x.name """
pass
def __getitem__(self, y): # real signature unknown; restored from __doc__
""" x.__getitem__(y) <==> x[y] """
pass
def __ge__(self, y): # real signature unknown; restored from __doc__
""" x.__ge__(y) <==> x>=y """
pass
def __gt__(self, y): # real signature unknown; restored from __doc__
""" x.__gt__(y) <==> x>y """
pass
def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
"""
dict() -> new empty dictionary
dict(mapping) -> new dictionary initialized from a mapping object's
(key, value) pairs
dict(iterable) -> new dictionary initialized as if via:
d = {}
for k, v in iterable:
d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
in the keyword argument list. For example: dict(one=1, two=2)
# (copied from class doc)
"""
pass
def __iter__(self): # real signature unknown; restored from __doc__
""" x.__iter__() <==> iter(x) """
pass
def __len__(self): # real signature unknown; restored from __doc__
""" x.__len__() <==> len(x) """
pass
def __le__(self, y): # real signature unknown; restored from __doc__
""" x.__le__(y) <==> x<=y """
pass
def __lt__(self, y): # real signature unknown; restored from __doc__
""" x.__lt__(y) <==> x<y """
pass
@staticmethod # known case of __new__
def __new__(S, *more): # real signature unknown; restored from __doc__
""" T.__new__(S, ...) -> a new object with type S, a subtype of T """
pass
def __ne__(self, y): # real signature unknown; restored from __doc__
""" x.__ne__(y) <==> x!=y """
pass
def __repr__(self): # real signature unknown; restored from __doc__
""" x.__repr__() <==> repr(x) """
pass
def __setitem__(self, i, y): # real signature unknown; restored from __doc__
""" x.__setitem__(i, y) <==> x[i]=y """
pass
def __sizeof__(self): # real signature unknown; restored from __doc__
""" D.__sizeof__() -> size of D in memory, in bytes """
pass
__hash__ = None
dict dict
字典是另一種可變容器模型，且可存儲任意類型對象。字典的每個鍵值(key=>value)對用冒号(:)分割，每個對之間用逗号(,)分割，整個字典包括在花括号({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 } 鍵必須是唯一的，但值則不必。值可以取任何資料類型，但鍵必須是不可變的，如字元串，數字或元組。
1：通路字典裡的值
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
print "dict['Name']: ", dict['Name'];
print "dict['Age']: ", dict['Age'];
##########################################
dict['Name']: Zara
dict['Age']: 7 2：修改字典裡的值
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry
print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];
##########################################
dict['Age']: 8
dict['School']: DPS School 3：删除操作
能删單一的元素也能清空字典，清空隻需一項操作。顯示删除一個字典用del指令，如下執行個體：
dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
del dict['Name']; # 删除鍵是'Name'的條目
dict.clear(); # 清空詞典所有條目
del dict ; # 删除詞典
print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];
##########################################
dict['Age']:
Traceback (most recent call last):
File "test.py", line 8, in <module>
print "dict['Age']: ", dict['Age'];
TypeError: 'type' object is unsubscriptable clear() 函數用于删除字典内所有元素：
dict = {'Name': 'Zara', 'Age': 7};
print "Start Len : %d" % len(dict)
dict.clear()
print "End Len : %d" % len(dict) 注：clear函數是删除字典裡的所有元素，删除後，該字典仍然存在，不過是個空字典而已
4： copy() 函數傳回一個字典的淺複制
dict1 = {'Name': 'Zara', 'Age': 7};
dict2 = dict1.copy()
print "New Dictinary : %s" % str(dict2)
##########################################
New Dictinary : {'Age': 7, 'Name': 'Zara'} 有關深淺複制的差別，請點選這裡！
5：fromkeys() 函數用于建立一個新字典，以序列seq中元素做字典的鍵，value為字典所有鍵對應的初始值
seq = ('name','age','sex')
dic = dict.fromkeys(seq)
print(dic)
#########################################
{'age': None, 'name': None, 'sex': None} 可以指定一個值，如：
seq = ('name','age','sex')
dic = dict.fromkeys(seq,10)
print(dic)
##########################################
{'age': 10, 'name': 10, 'sex': 10} 6：get() 函數傳回指定鍵的值，如果值不在字典中傳回預設值
dic = {'Name': 'Zara', 'Age': 27}
print(dic.get('Age'))
print(dic.get('Sex','Never'))#Never為設定的預設值
##########################################
27
Never 7：has_key() 函數用于判斷鍵是否存在于字典中，如果鍵在字典dict裡傳回true，否則傳回false
dic = {'Name': 'Zara', 'Age': 27}
print(dic.has_key('Name'))
print(dic.has_key('Sex'))
##########################################
True
False 8：items() 函數以清單傳回可周遊的(鍵, 值) 元組數組
dic = {'Name': 'Zara', 'Age': 27}
print(dic.items())
##########################################
[('Age', 27), ('Name', 'Zara')] 9：keys() 函數以清單傳回一個字典所有的鍵
dic = {'Name': 'Zara', 'Age': 27}
print(dic.keys())
##########################################
['Age', 'Name'] 10：values() 函數以清單傳回字典中的所有值
dic = {'Name': 'Zara', 'Age': 27}
print(dic.values())
##########################################
[27, 'Zara'] 11：update() 函數把字典dict2的鍵/值對更新到dict1裡
dict1 = {'Name': 'Zara', 'Age': 7}
dict2 = {'Sex': 'female' }
dict1.update(dict2)
print(dict1)
##########################################
{'Age': 7, 'Name': 'Zara', 'Sex': 'female'} 12：字典的周遊
方法一：
dict1 = {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}
for k,v in dict1.items() :
print(k,v)
##########################################
('Age', 7)
('Name', 'Zara')
('Sex', 'female') 方法二：
dict1 = {'Age': 7, 'Name': 'Zara', 'Sex': 'female'}
for (k,v) in dict1.items() :
print(k,v)
##########################################
('Age', 7)
('Name', 'Zara')
('Sex', 'female')