python基础2之字符串、列表、字典、集合

内容概要：

一、python2 or 3

二、字符串拼接

三、字符串

四、列表、元祖

五、字典

六、集合

七、练习

一、python2 or python3

目前大多使用python2.7，随着时间的推移，python3将会成为python爱好者的主流。

python2和3区别：

1.PRINT IS A FUNCTION

 Old: print "The answer is", 2*2 New: print("The answer is", 2*2)
 Old: print x, # Trailing comma suppresses newline New: print(x, end=" ") # Appends a space instead of a newline
 Old: print # Prints a newline
 New: print() # You must call the function!
 Old: print >>sys.stderr, "fatal error" New: print("fatal error", file=sys.stderr)
 Old: print (x, y) # prints repr((x, y))
 New: print((x, y)) # Not the same as print(x, y)!

2.某些库名改变

例如：

2.x	3.x
_winreg	winreg
copy_reg	copyreg
Queue	queue
SockerServer	sockerserver
repr	reprlib

3.ALL IS UNICODE NOW

所有的字符编码变为unicode

二、字符串拼接

方法一：使用“+”（不推荐）

原因：python中的字符串在C语言中体现为是一个字符数组，每次创建字符串时候需要在内存中开辟一块连续的空，并且一旦需要修改字符串的话，就需要再次开辟空间，万恶的+号每出现一次就会在内从中重新开辟一块空间

name="wd"
msg="my name is "+name
print(msg)
输出：
my name is wd

方法二：使用格式化字符串

%s:字符串

%d:整数

%f:浮点数

 name="wd"
 age=22
 job="IT"
 msg="my name is %s age %d job %s"%(name,age,job)
 print(msg)
 输出：
 my name is wd age 22 job IT

方法三：使用format进行格式化输出（变量名替换）

 name="wd"
 age=22
 job="IT"
 msg='''my name is:{_name}
         age is: {_age}
         job is: {_job}'''.format(_name=name,_age=age,_job=job)
 print(msg)
 输出：
 my name is:wd
         age is: 22
         job is: IT

或者：（位置替换）

 name="wd"
 age=22
 job="IT"
 msg='''my name is:{0}
         age is: {1}
         job is: {2}'''.format(name,age,job)
 print(msg)
 输出：
 my name is:wd
         age is: 22
         job is: IT

总结：对比以上三种方法,使用+方式进行拼接字符串会开辟较多的内存空间，效率低，推荐使用第二种和第三种方法。

三、字符串

1.字符串常用操作

• 移除空白(strip)
• 分割(split)
• 长度(len)
• 索引(index)
• 切片

字符串对方法如下：

 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 = ""
         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

四、列表、元祖

1.列表（list）

列表常用操作：

索引(index)

 a=["a","b","c",1,2,3]
 print(a.index("a"))#不加位置参数
 输出：
 0

 a=["a","b","c","a",2,3]
 print(a.index("a"))
 print(a.index("a",1,5))#从索引1开始到5之间查找
 输出：
 0
 3

切片

 >>> names = ["Alex","Tenglan","Eric","Rain","Tom","Amy"]
 >>> names[1:4]  #取下标1至下标4之间的数字，包括1，不包括4
 ['Tenglan', 'Eric', 'Rain']
 >>> names[1:-1] #取下标1至-1的值，不包括-1
 ['Tenglan', 'Eric', 'Rain', 'Tom']
 >>> names[0:3]
 ['Alex', 'Tenglan', 'Eric']
 >>> names[:3] #如果是从头开始取，0可以忽略，跟上句效果一样
 ['Alex', 'Tenglan', 'Eric']
 >>> names[3:] #如果想取最后一个，必须不能写-1，只能这么写
 ['Rain', 'Tom', 'Amy']
 >>> names[3:-1] #这样-1就不会被包含了
 ['Rain', 'Tom']
 >>> names[-3:-1] #取最后两个效果同names[3:4]
 ['Tom','Amy']
 >>> names[0::2] #后面的2是代表，每隔一个元素，就取一个
 ['Alex', 'Eric', 'Tom']
 >>> names[::2] #和上句效果一样
 ['Alex', 'Eric', 'Tom']

追加(append)

 a=["a","b","c","a",2,3]
 a.append("WD")
 print(a)
 输出：
 ['a', 'b', 'c', 'a', 2, 3, 'WD']

删除(del，pop)

 a=["a","b","c","d"]
 del a[0]
 print(a)
 输出：
 ['b', 'c', 'd']

 #pop

 a=["a","b","c","d"]
 a.pop()
 print(a)#默认移除最后一个
 输出：
 ['a', 'b', 'c']
 #移除制定位置元素
 a=["a","b","c","d"]
 a.pop(2)#移除位置2的元素等价del a[2]
 print(a)
 输出：
 ['a', 'b', 'd']

插入(insert)

 a=["a","b","c","a",2,3]
 a.insert(0,"WD")#0代表索引，在0位置之前插入
 print(a)
 输出：
 ['WD', 'a', 'b', 'c', 'a', 2, 3]

扩展(extend)

 a=["a","b","c"]
 b=[1,2,3]
 a.extend(b)
 print(a)
 输出：
 ['a', 'b', 'c', 1, 2, 3]

统计(count)

 >>> names
 ['Alex', 'Amy', 'Amy', 'Tenglan', 'Tom', '', '', '']
 >>> names.sort()
 >>> names
 ['', '', '', 'Alex', 'Amy', 'Amy', 'Tenglan', 'Tom']

 >>> names.reverse() #反转
 >>> names
 ['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '', '', '']

排序(sort)

 >>> names
 ['Alex', 'Tenglan', 'Amy', 'Tom', 'Amy', 1, 2, 3]
 >>> names.sort() #排序
 Traceback (most recent call last):
   File "<stdin>", line 1, in <module>
 TypeError: unorderable types: int() < str()   #3.0里不同数据类型不能放在一起排序了
 >>> names[-3] = ''
 >>> names[-2] = ''
 >>> names[-1] = ''
 >>> names
 ['Alex', 'Amy', 'Amy', 'Tenglan', 'Tom', '', '', '']
 >>> names.sort()
 >>> names
 ['', '', '', 'Alex', 'Amy', 'Amy', 'Tenglan', 'Tom']

 >>> names.reverse() #反转
 >>> names
 ['Tom', 'Tenglan', 'Amy', 'Amy', 'Alex', '', '', '']

循环(for)

 a=["a","b","c","d"]
 for i in a:
     print(i)
 输出：
 a
 b
 c
 d

包含（in）

 a=["alex","wusir","wd"]
 if "alex" in a:
     print("oh you are here!")
 输出：
 oh you are here!

长度（len）

 a=["a","b","c"]
 print(len(a))
 结果：
 3

清空（clear）

 a=["a","b","c"]
 a.clear()
 print(a)
 结果：
 []

列表中含有的方法：

 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

2.元祖（tuple）

元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表

元祖操作：

• 索引
• 切片
• 循环
• 长度
• 包含

五、字典

3.字典

字典的特性：

• dict是无序的
• key必须是唯一的,天生去重

字典操作：

索引(key)

 a={"name":"WD","age":"","job":"IT"}
 print(a["name"])
 输出：
 WD

增加 

 a={"name":"WD","age":"","job":"IT"}
 a["city"]="chengdu"
 print(a)
 输出：
 {'city': 'chengdu', 'age': '', 'job': 'IT', 'name': 'WD'}

修改

 a={"name":"WD","age":"","job":"IT"}
 a["name"]="alex"
 print(a)
 输出：
 {'name': 'alex', 'job': 'IT', 'age': ''}

删除(del、pop)

 >>> info
 {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya', 'stu1101': '武藤兰'}
 >>> info.pop("stu1101") #标准删除姿势
 '武藤兰'
 >>> info
 {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
 >>> del info['stu1103'] #换个姿势删除
 >>> info
 {'stu1102': 'LongZe Luola'}
 >>>
 >>>
 >>>
 >>> info = {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'}
 >>> info
 {'stu1102': 'LongZe Luola', 'stu1103': 'XiaoZe Maliya'} #随机删除
 >>> info.popitem()
 ('stu1102', 'LongZe Luola')
 >>> info
 {'stu1103': 'XiaoZe Maliya'}

查找(get) 

 >>> msg={"name":"WD","age":22,"job":"IT"}
 >>> msg["name"]#如果获取索引不存在会报错
 'WD'
 >>> "name" in msg#标准姿势
 True
 >>> msg.get("name")#get获取不到元素返回None不会报错
 'WD'

键、值、键值对

 msg={"name":"WD","age":22,"job":"IT"}
 print(msg.keys())#打印所有的key
 print(msg.values())#打印所有的值
 print(msg.items())#打印键值对
 结果：
 dict_keys(['job', 'age', 'name'])
 dict_values(['IT', 22, 'WD'])
 dict_items([('job', 'IT'), ('age', 22), ('name', 'WD')])

循环（for、enumerate）

 for
 #方法1
 for key in info:
     print(key,info[key])

 #方法2
 for k,v in info.items(): #会先把dict转成list,数据里大不要用
     print(k,v)

 enumerate#自动为对象添加序号
 a={"name":"WD","age":22,"job":"IT"}
 for i,k in enumerate(a.keys()):#此处有坑，a.keys()每次顺序可能不一样
     print(i,a[k])
 结果：
 0 22
 1 IT
 2 WD

长度（len）

 msg={"name":"WD","age":22,"job":"IT"}
 print(len(msg))
 结果：
 3

其他操作（update、setdefault）

 update#字典更新，若key相同覆盖，key不存在则增加
 a={"name":"WD","age":22,"job":"IT"}
 b={"name":"alex","age":33,"city":"beijing"}
 a.update(b)
 print(a)
 结果：
 {'name': 'alex', 'age': 33, 'city': 'beijing', 'job': 'IT'}

 setdefault#为字典设置默认值，若字典中没有该值，采用默认。
 a={"name":"WD","age":22,"job":"IT"}
 a.setdefault("name","alex")
 print(a)
 结果：
 {'name': 'WD', 'job': 'IT', 'age': 22}#为采用默认值

字典中含有的方法：

 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

六、集合

集合是一个无序的，不重复的数据组合，特性：

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

常用操作：

 s = set([3,5,9,10])      #创建一个数值集合  

 t = set("Hello")         #创建一个唯一字符的集合  

 a = t | s          # t 和 s的并集  

 b = t & s          # t 和 s的交集  

 c = t – s          # 求差集（项在t中，但不在s中）  

 d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）  

 基本操作：  

 t.add('x')            # 添加一项  

 s.update([10,37,42])  # 在s中添加多项  

 使用remove()可以删除一项：  

 t.remove('H')  

 len(s)
 set 的长度  

 x in s
 测试 x 是否是 s 的成员  

 x not in s
 测试 x 是否不是 s 的成员  

 s.issubset(t)
 s <= t
 测试是否 s 中的每一个元素都在 t 中  

 s.issuperset(t)
 s >= t
 测试是否 t 中的每一个元素都在 s 中  

 s.union(t)
 s | t
 返回一个新的 set 包含 s 和 t 中的每一个元素  

 s.intersection(t)
 s & t
 返回一个新的 set 包含 s 和 t 中的公共元素  

 s.difference(t)
 s - t
 返回一个新的 set 包含 s 中有但是 t 中没有的元素  

 s.symmetric_difference(t)
 s ^ t
 返回一个新的 set 包含 s 和 t 中不重复的元素  

 s.copy()
 返回 set “s”的一个浅复制

七、练习题

1.三级菜单

需求：

1. 运行程序输出第一级菜单
2. 选择一级菜单某项，输出二级菜单，同理输出三级菜单
3. 菜单数据保存在文件中

代码：

 #/usr/bin/env python
 # -*- coding:utf-8 -*-
 #Author:W-D
 flag=True
 menu_list=[]#保存文件中每条菜单信息
 menu_key=[]#保存一级菜单中的key
 menu = {}#保存需要用的菜单
 with open ("menu.txt","r",encoding="utf-8") as f:
     for line in f:
         msg=line.strip().split(":")#将文件中的每行按：分割成列表
         if msg[0] not in menu_key:
             menu_key.append(msg[0])#将一级菜单中的key追加到列表中
         menu_list.append(msg)#将文件中每条信息追加到列表中，用于后续处理
     for city in menu_key:#外层循环城市
         menu3 = {}#这个是个坑！！每次循环完结果出来以后，需要将第是三级菜单清空，会影响下一个城市所生成的字典
         for each in menu_list:#
             if city==each[0]:
                 key,value=each[1].split(" ")[0],each[1].split(" ")[1:]#生成三级菜单的key和value
                 menu3[key]=value#同上
                 menu[city]=menu3#同上
 while flag:
     for i in menu:
         print(i)
     choice=input("请输入您的选择（q退出）：")
     if choice in menu:
         while flag:
             for i1 in menu[choice]:
                 print(i1)
             choice1 = input("请输入您的选择（q退出，b返回）：")
             if choice1 in menu[choice]:
                 while flag:
                     for i2 in menu[choice][choice1]:
                         print(i2)
                     choice2 = input("请输入您的选择（q退出，b返回）：")
                     if choice2 == 'q':
                         flag = False
                         break
                     elif choice2 == 'b':
                         break
                     else:
                         print("已经到底了！")
             elif choice1=='q':
                 flag=False
                 break
             elif choice1=='b':
                 break
     if choice=='q':
          flag=False
          break

三级菜单之常用方法

菜单文件：

 北京市:昌平 A公司 B公司 C公司,
 北京市:回龙观 E公司 F公司 G公司
 上海市:浦东 H公司 I公司 J公司
 上海市:虹桥 U公司 V公司 W公司
 成都市:金牛区 O公司 P公司 Q公司
 成都市:高新区 X公司 Y公司 Z公司

menu.txt

大王的无敌方法：

 menu = {
     '北京':{
         '海淀':{
             '五道口':{
                 'soho':{},
                 '网易':{},
                 'google':{}
             },
             '中关村':{
                 '爱奇艺':{},
                 '汽车之家':{},
                 'youku':{},
             },
             '上地':{
                 '百度':{},
             },
         },
         '昌平':{
             '沙河':{
                 '老男孩':{},
                 '北航':{},
             },
             '天通苑':{},
             '回龙观':{},
         },
         '朝阳':{},
         '东城':{},
     },
     '上海':{
         '闵行':{
             "人民广场":{
                 '炸鸡店':{}
             }
         },
         '闸北':{
             '火车战':{
                 '携程':{}
             }
         },
         '浦东':{},
     },
     '山东':{},
 }

 exit_flag = False
 current_layer = menu

 layers = [menu]

 while not  exit_flag:
     for k in current_layer:
         print(k)
     choice = input(">>:").strip()
     if choice == "b":
         current_layer = layers[-1]
         #print("change to laster", current_layer)
         layers.pop()
     elif choice not  in current_layer:continue
     else:
         layers.append(current_layer)
         current_layer = current_layer[choice]

三级菜单之文艺方法