• python基础知识3——基本的数据类型2——列表，元组，字典，集合

    磨人的小妖精们啊！终于可以归置下自己的大脑啦，在这里我要把——整型，长整型，浮点型，字符串，列表，元组，字典，集合，这几个知识点特别多的东西，统一的捯饬捯饬，不然一直脑袋里面乱乱的。

    一、列表

    列表是可修改可变的，有序的，可迭代的，有索引和切片，可以是任意数据类型，可以包含任意多数据

    1.列表的全部方法

    如：['1','2']、['wupeiqi', 'alex']

    1 >>> dir(list)
2 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

     每个列表都具备如下功能：

      1 class list(object):
  2     """
  3     list() -> new empty list
  4     list(iterable) -> new list initialized from iterable's items
  5     """在数组的末尾新增一项
  6     def append(self, p_object): # real signature unknown; restored from __doc__
  7         """
  8         L.append(object) -- append object to end """
  9         pass
 10 
 11     def count(self, value): # real signature unknown; restored from __doc__
 12         """ 查看lst中某一项出现的次数
 13         L.count(value) -> integer -- return number of occurrences of value """
 14         return 0
 15 
 16     def extend(self, iterable): # real signature unknown; restored from __doc__
 17         """将原列表与其他列表扩展成新列表
 18         L.extend(iterable) -- extend list by appending elements from the iterable """
 19         pass
 20 
 21     def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
 22         """返回列表中第一个匹配项的下标，找不到会报错
 23         L.index(value, [start, [stop]]) -> integer -- return first index of value.
 24         Raises ValueError if the value is not present.
 25         """
 26         return 0
 27 
 28     def insert(self, index, p_object): # real signature unknown; restored from __doc__
 29         """在指定位置插入项
 30         L.insert(index, object) -- insert object before index """
 31         pass
 32 
 33     def pop(self, index=None): # real signature unknown; restored from __doc__
 34         """返回指定位置的值，并将其从列表中删除。默认对末尾项操作
 35         L.pop([index]) -> item -- remove and return item at index (default last).
 36         Raises IndexError if list is empty or index is out of range.
 37         """
 38         pass
 39 
 40     def remove(self, value): # real signature unknown; restored from __doc__
 41         """从列表中移除第一个符合与指定值相等的项
 42         L.remove(value) -- remove first occurrence of value.
 43         Raises ValueError if the value is not present.
 44         """
 45         pass
 46 
 47     def reverse(self): # real signature unknown; restored from __doc__
 48         """列表反转
 49         L.reverse() -- reverse *IN PLACE* """
 50         pass
 51 
 52     def sort(self, cmp=None, key=None, reverse=False): # real signature unknown; restored from __doc__
 53         """排序，数字、字符串按照ASCII，中文按照unicode从小到大排序。
 54         L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
 55         cmp(x, y) -> -1, 0, 1
 56         """
 57         pass
 58 
 59     def __add__(self, y): # real signature unknown; restored from __doc__
 60         """ 字符串拼接
 61         x.__add__(y) <==> x+y """
 62         pass
 63 
 64     def __contains__(self, y): # real signature unknown; restored from __doc__
 65         """ 判断列表中是否包含某一项
 66         x.__contains__(y) <==> y in x """
 67         pass
 68 
 69     def __delitem__(self, y): # real signature unknown; restored from __doc__
 70         """删除列表中指定下标的项
 71         x.__delitem__(y) <==> del x[y] """
 72         pass
 73 
 74     def __delslice__(self, i, j): # real signature unknown; restored from __doc__
 75         """删除指定下标之间的内容，向下包含
 76         x.__delslice__(i, j) <==> del x[i:j]
 77                    
 78                    Use of negative indices is not supported.
 79         """
 80         pass
 81 
 82     def __eq__(self, y): # real signature unknown; restored from __doc__
 83         """ 判断两个列表是否相等
 84         x.__eq__(y) <==> x==y """
 85         pass
 86 
 87     def __getattribute__(self, name): # real signature unknown; restored from __doc__
 88         """ 无条件被调用，通过实例访问属性。
 89         x.__getattribute__('name') <==> x.name """
 90         pass
 91 
 92     def __getitem__(self, y): # real signature unknown; restored from __doc__
 93         """ x.__getitem__(y) <==> x[y] """
 94         pass
 95 
 96     def __getslice__(self, i, j): # real signature unknown; restored from __doc__
 97         """
 98         x.__getslice__(i, j) <==> x[i:j]
 99                    
100                    Use of negative indices is not supported.
101         """
102         pass
103 
104     def __ge__(self, y): # real signature unknown; restored from __doc__
105         """ x.__ge__(y) <==> x>=y """
106         pass
107 
108     def __gt__(self, y): # real signature unknown; restored from __doc__
109         """ x.__gt__(y) <==> x>y """
110         pass
111 
112     def __iadd__(self, y): # real signature unknown; restored from __doc__
113         """ x.__iadd__(y) <==> x+=y """
114         pass
115 
116     def __imul__(self, y): # real signature unknown; restored from __doc__
117         """ 
118         x.__imul__(y) <==> x*=y """
119         pass
120 
121     def __init__(self, seq=()): # known special case of list.__init__
122         """
123         list() -> new empty list
124         list(iterable) -> new list initialized from iterable's items
125         # (copied from class doc)
126         """
127         pass
128 
129     def __iter__(self): # real signature unknown; restored from __doc__
130         """ x.__iter__() <==> iter(x) """
131         pass
132 
133     def __len__(self): # real signature unknown; restored from __doc__
134         """ x.__len__() <==> len(x) """
135         pass
136 
137     def __le__(self, y): # real signature unknown; restored from __doc__
138         """ x.__le__(y) <==> x<=y """
139         pass
140 
141     def __lt__(self, y): # real signature unknown; restored from __doc__
142         """ x.__lt__(y) <==> x<y """
143         pass
144 
145     def __mul__(self, n): # real signature unknown; restored from __doc__
146         """ x.__mul__(n) <==> x*n """
147         pass
148 
149     @staticmethod # known case of __new__
150     def __new__(S, *more): # real signature unknown; restored from __doc__
151         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
152         pass
153 
154     def __ne__(self, y): # real signature unknown; restored from __doc__
155         """ x.__ne__(y) <==> x!=y """
156         pass
157 
158     def __repr__(self): # real signature unknown; restored from __doc__
159         """ x.__repr__() <==> repr(x) """
160         pass
161 
162     def __reversed__(self): # real signature unknown; restored from __doc__
163         """ L.__reversed__() -- return a reverse iterator over the list """
164         pass
165 
166     def __rmul__(self, n): # real signature unknown; restored from __doc__
167         """ x.__rmul__(n) <==> n*x """
168         pass
169 
170     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
171         """ x.__setitem__(i, y) <==> x[i]=y """
172         pass
173 
174     def __setslice__(self, i, j, y): # real signature unknown; restored from __doc__
175         """
176         x.__setslice__(i, j, y) <==> x[i:j]=y
177                    
178                    Use  of negative indices is not supported.
179         """
180         pass
181 
182     def __sizeof__(self): # real signature unknown; restored from __doc__
183         """ L.__sizeof__() -- size of L in memory, in bytes """
184         pass
185 
186     __hash__ = None
187 
188 list         
189 
190 list Code
    help(list)

    2.列表的常用方法
     （1）append：向列表中添加项

    　　   insert：在列表的指定位置加入值

    　　   extend：列表的扩展；那么列表可以自己扩展自己么？？？当然是可以的啦！

     
     1 >>> 
 2 >>> a = [1,2,3,4]
 3 >>> a.append(5)
 4 >>> a
 5 [1, 2, 3, 4, 5]
 6 >>> b = [6,7]
 7 >>> a.extend(b)
 8 >>> a
 9 [1, 2, 3, 4, 5, 6, 7]
10 >>> a.insert(2,0)
11 >>> a
12 [1, 2, 0, 3, 4, 5, 6, 7]
    1 >>> a  
2 [1, 2, 3, 'a', 'b', 'c']  
3 >>> b  
4 ['q', 'python']  
5 >>> a[len(a):]=b  
6 >>> a  
7 [1, 2, 3, 'a', 'b', 'c', 'q', 'python']


    list.extend(L) 等效于 list[len(list):] = L，L是待并入的list

    （2）index：返回列表中第一个匹配项的下标

    　　 __contain__:查看列表中是否包含某一项

    　　 count：查看列表中某一项出现的次数

     
     1 >>> a
 2 [1, 2, 0, 3, 4, 5, 6, 7]
 3 >>> a.index(0)
 4 2
 5 >>> a.__contains__(7)
 6 True
 7 >>> a.__contains__(8)
 8 False
 9 >>> a.count(5)
10 1

    （3）pop:删除并返回指定下标的值，默认为列表的最后一个值

    　　 remove：删除列表中与指定值匹配的第一个值

               __delitem__:删除指定下标的值

    　　　__delslice__:删除指定下标区域内的所有值，下标向下包含

     1 >>> a
 2 [1, 2, 0, 3, 4, 5, 6, 7]
 3 >>> a.pop()
 4 7
 5 >>> a
 6 [1, 2, 0, 3, 4, 5, 6]
 7 >>> a.pop(2)
 8 0
 9 >>> a
10 [1, 2, 3, 4, 5, 6]
11 >>> a.remove(2)
12 >>> a
13 [1, 3, 4, 5, 6]
14 >>> a.__delitem__(0)
15 >>> a
16 [3, 4, 5, 6]
17 >>> a.__delslice__(0,2)
18 >>> a
19 [5, 6]

    （4）reverse：列表反转，这个反转并没有什么编码顺序，就是单纯的把原来的列表从头到尾调转过来而已。。。
     　　  sort：排序，数字、字符串按照ASCII，中文按照unicode从小到大排序。

    1 >>> a = [5,4,6,8,2,6,9]
2 >>> a.sort()
3 >>> a
4 [2, 4, 5, 6, 6, 8, 9]
5 >>> a.reverse()
6 >>> a
7 [9, 8, 6, 6, 5, 4, 2]
    1 >>> a=[3,2,4,2,5,85,3,1]
2 >>> a.sort(reverse=True)
3 >>> a
4 [85, 5, 4, 3, 3, 2, 2, 1]
5 
6 >>> a=[3,2,4,2,5,85,3,1]
7 >>> sorted(a, reverse=True)
8 [85, 5, 4, 3, 3, 2, 2, 1]

    3. “+”：字符串和列表连接

     1 >>> a=[1,2,3,4]
 2 >>> s=[1,2]
 3 >>> a+s
 4 [1, 2, 3, 4, 1, 2]
 5 >>> 
 6 >>> a-s
 7 Traceback (most recent call last):
 8   File "<stdin>", line 1, in <module>
 9 TypeError: unsupported operand type(s) for -: 'list' and 'list'
10 >>> 
11 >>> a='asd'
12 >>> s='as'
13 >>> a+s
14 'asdas'
15 >>> a-s
16 Traceback (most recent call last):
17   File "<stdin>", line 1, in <module>
18 TypeError: unsupported operand type(s) for -: 'str' and 'str'
19 >>>

     生成列表：Python的简洁

    1 >>> l = [x**2 for x in range(1,10)]  
2 >>> l  
3 [1, 4, 9, 16, 25, 36, 49, 64, 81]  
    1 >>> mybag = [' glass',' apple','green leaf ']  #有的前面有空格，有的后面有空格  
2 >>> [one.strip() for one in mybag]       #去掉元素前后的空格  
3 ['glass', 'apple', 'green leaf']  
4 enumerate

    这是一个有意思的内置函数，本来我们可以通过for i in range(len(list))的方式得到一个list的每个元素编号，然后在用list[i]的方式得到该元素。如果要同时得到元素编号和元素怎么办？就是这样了:

    1 >>> for i in range(len(week)):  
2 ...   print week[i]+' is '+str(i)   #注意，i是int类型，如果和前面的用+连接，必须是str类型  
3 ...   
4 monday is 0  
5 sunday is 1  
6 friday is 2

    python中提供了一个内置函数enumerate，能够实现类似的功能：

    1 >>> for (i,day) in enumerate(week):  
2 ...   print day+' is '+str(i)  
3 ...   
4 monday is 0  
5 sunday is 1  
6 friday is 2

    还有这个有趣的内置函数的例子：

    1 >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']  
2 >>> list(enumerate(seasons))  
3 [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]  
4 >>> list(enumerate(seasons, start=1))  
5 [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

    3.列表的索引和切片 

     1 >>> list(range(10))
 2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 3 >>> l=list(range(10))
 4 >>> l
 5 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 6 >>> l[:3]
 7 [0, 1, 2]
 8 >>> l[3:5]
 9 [3, 4]
10 >>> l[-5:-3]
11 [5, 6]
12 >>> l[-5:]
13 [5, 6, 7, 8, 9]
14 >>> l[::2]
15 [0, 2, 4, 6, 8]
16 >>> (0,1,2,3,4,5,6)[:3]      #元组也是列表只是不能改，所以也可以切片，得到的还是元组
17 (0, 1, 2)
18 >>> 'zhenghaolovexiaokai'[::2] #字符串可以看成列表
19 'zegalvxaki'

    列表和字符串 两种类型的数据，有共同的地方，它们都属于序列（都是一些对象按照某个次序排列起来，这就是序列的最大特征），因此，就有很多类似的地方。如刚才演示的索引和切片，是非常一致的。

     1 >>> l=[1,2,3,4,5]
 2 >>> l[1]
 3 2
 4 >>> l.index(2)
 5 1
 6 >>> l[1]=1      #直接赋值修改，给覆盖了
 7 >>> l
 8 [1, 1, 3, 4, 5]
 9 >>> s='asdfg'   #字符串不可修改
10 >>> s[0]='b'
11 Traceback (most recent call last):
12   File "<stdin>", line 1, in <module>
13 TypeError: 'str' object does not support item assignment
14 >>>

    4.通过extend（）方法学习什么是可迭代的？

    1 help（list.extend）  #extend的参数必须是可迭代的。
2 
3 extend(...) L.extend(iterable) -- extend list by appending elements from the iterable
    1 >>> l=[1,2,3]
2 >>> s='python'
3 >>> lst=[7,8,9]
4 >>> lst.extend(l) #列表是可迭代的
5 >>> lst
6 [7, 8, 9, 1, 2, 3] 
7 >>> lst.extend(s) 为啥？
8 >>> lst
9 [7, 8, 9, 1, 2, 3, 'p', 'y', 't', 'h', 'o', 'n']

       >>> i=8     #整型不是可迭代的
       >>> lst.extend(i)
       Traceback (most recent call last):
       File "<stdin>", line 1, in <module>
       TypeError: 'int' object is not iterable

       这就报错了。错误提示中告诉我们，那个数字 8，是 int 类型的对象，不是 iterable 的

    这里用内建函数 hasattr()判断一个字符串和列表是否是可迭代的？——得出字符串不是可迭代的，而列表是可迭代的(这里不太懂，为啥字符串不是可迭代的呢，和上面矛盾啊)

    1 >>> str='python'
2 >>> hasattr(str,'__iter__')
3 False
4 >>> lst=[1,2]
5 >>> hasattr(lst,'__iter__')
6 True

    hasattr()的判断本质就是看那个类型中是否有__iter__函数。还可以用 dir()找一找，在数字、字符串、列表中，谁有__iter__。同样还可找一找 元组，字典两种类型对象是否含有这个方法。

    5.列表重要特征：

    列表是可以修改的。这种修改，不是复制一个新的，而是在原地进行修改。

    没有返回值，即不能赋值给某个变量。

    1 >>> lst=[7,8,9]
2 >>> id(lst)
3 139795244578144
4 >>> lst.append(5)
5 >>> lst
6 [7, 8, 9, 5]
7 >>> id(lst)
8 139795244578144
    1 >>> a=[1,2,3]
2 >>> b=a.extend([4,5,6]) #a原地修改了，没有返回值
3 >>> b          #所以b什么也没有得到
4 >>> a
5 [1, 2, 3, 4, 5, 6]

    6.列表生成式 

    1 >>> [x*x for x in range(1, 11) if x%2==0]
2 [4, 16, 36, 64, 100]
3 >>> [m+n for m in 'abc' for n in 'asd']  #两层循环
4 ['aa', 'as', 'ad', 'ba', 'bs', 'bd', 'ca', 'cs', 'cd']

     7.字符串和列表比较

    都属于序列类型的数据，很多方法很类似总结

    list 和 str 的最大区别是：list 是可以改变的，str 不可变 

    二、元组


    元组是不可修改不可变的，有序的，可迭代的，有索引和切片

    1.元组的全部方法

    如：(11,22,33)、('zhenghao', 'xiaokai')

    1 1 >>> dir(tuple)
2 2 ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index'] 
     1 Help on class tuple in module __builtin__:
 2 
 3 class tuple(object)
 4  |  tuple() -> empty tuple
 5  |  tuple(iterable) -> tuple initialized from iterable's items
 6  |  
 7  |  If the argument is a tuple, the return value is the same object.
 8  |  
 9  |  Methods defined here:
10  |  
11  |  __add__(...)
12  |      x.__add__(y) <==> x+y
13  |  
14  |  __contains__(...)
15  |      x.__contains__(y) <==> y in x
16  |  
17  |  __eq__(...)
18  |      x.__eq__(y) <==> x==y
19  |  
20  |  __ge__(...)
21  |      x.__ge__(y) <==> x>=y
22  |  
23  |  __getattribute__(...)
24  |      x.__getattribute__('name') <==> x.name
25  |  
26  |  __getitem__(...)
27  |      x.__getitem__(y) <==> x[y]
28  |  
29  |  __getnewargs__(...)
30  |  
31  |  __getslice__(...)
32  |      x.__getslice__(i, j) <==> x[i:j]
33  |      
34  |      Use of negative indices is not supported.
35  |  
36  |  __gt__(...)
37  |      x.__gt__(y) <==> x>y
38  |  
39  |  __hash__(...)
40  |      x.__hash__() <==> hash(x)
41  |  
42  |  __iter__(...)
43  |      x.__iter__() <==> iter(x)
44  |  
45  |  __le__(...)
46  |      x.__le__(y) <==> x<=y
47  |  
48  |  __len__(...)
49  |      x.__len__() <==> len(x)
50  |  
51  |  __lt__(...)
52  |      x.__lt__(y) <==> x<y
53  |  
54  |  __mul__(...)
55  |      x.__mul__(n) <==> x*n
56  |  
57  |  __ne__(...)
58  |      x.__ne__(y) <==> x!=y
59  |  
60  |  __repr__(...)
61  |      x.__repr__() <==> repr(x)
62  |  
63  |  __rmul__(...)
64  |      x.__rmul__(n) <==> n*x
65  |  
66  |  count(...)
67  |      T.count(value) -> integer -- return number of occurrences of value
68  |  
69  |  index(...)
70  |      T.index(value, [start, [stop]]) -> integer -- return first index of value.
71  |      Raises ValueError if the value is not present.
72  |  
73  |  ----------------------------------------------------------------------
74  |  Data and other attributes defined here:
75  |  
76  |  __new__ = <built-in method __new__ of type object>
77  |      T.__new__(S, ...) -> a new object with type S, a subtype of T
78 
79 None
    View Code

    2.元组和字符串，列表的比较

    tuple 是一种序列类型的数据，这点上跟 list/str 类似。它的特点就是其中的元素不能更改，所以也就没有添加，删除，修改等方法，这点上跟列表不同，倒是跟字符串类似；它的元素又可以是任何类型的数据，这点上跟 list 相同，但不同于 str。

     1 >>> tup=(1, 'python', [3,4], (5,6)) #元组的元素可以任意类型，和列表类似
 2 >>> tup[1]  #元组的索引，是序列类型
 3 'python'
 4 >>> tup[1]=2  #元组元素不可原地修改，和字符串类似
 5 Traceback (most recent call last):
 6   File "<stdin>", line 1, in <module>
 7 TypeError: 'tuple' object does not support item assignment
 8 >>> tup.append(2) #元素不可更改，没有此方法，和str类似
 9 Traceback (most recent call last):
10   File "<stdin>", line 1, in <module>
11 AttributeError: 'tuple' object has no attribute 'append'

       >>> tup[2][0] 
       3
       >>> tup[2].append(5) #元组的元素之一为列表，所以通过修改列表，元组样子改变了，但是注意元组的元素还不没变
       >>> tup
       (1, 'python', [3, 4, 5], (5, 6))

     

    3.元组的索引和切片

    4.tuple 用在哪里？

    既然它是 list 和 str 的杂合，它有什么用途呢？不是用 list 和 str 都可以了吗？

    在很多时候，的确是用 list 和 str 都可以了。但是，看官不要忘记，我们用计算机语言解决的问题不都是简单问题，就如同我们的自然语言一样，虽然有的词汇看似可有可无,用别的也能替换之,但是我们依然需要在某些情况下使用它们.

    一般认为,tuple 有这类特点,并且也是它使用的情景:

    • Tuple 比 list 操作速度快。如果您定义了一个值的常量集，并且唯一要用它做的是不断地遍历它，请使用 tuple 代替 list。
    • 如果对不需要修改的数据进行 “写保护”，可以使代码更安全。使用 tuple 而不是 list 如同拥有一个隐含的 assert 语句，说明这一数据是常量。如果必须要改变这些值，则需要执行 tuple 到 list 的转换 (需要使用一个特殊的函数)。
    • Tuples 可以在 dictionary（字典，后面要讲述） 中被用做 key，但是 list 不行。Dictionary key 必须是不可变的。Tuple 本身是不可改变的，但是如果您有一个 list 的 tuple，那就认为是可变的了，用做 dictionary key 就是不安全的。只有字符串、整数或其它对 dictionary 安全的 tuple 才可以用作 dictionary key。
    • Tuples 可以用在字符串格式化中。

    三、字典


    字典是可修改可变的，无序的，无索引和切片，可迭代的，键不可以是可变的（list，dict）而且不能重复（键都是唯一的），值可以是任意类型，可存储任意多的对象

    dict（dictory）也被称为关联数组或哈希表

    1.字典的全部方法

    如：{'name': 'zhenghao', 'age': 18} 、{'host': '127.0.0.1', 'port': 8000]}

    1 >>> dir(dict)
2 ['__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'has_key', 'items', 'iteritems', 'iterkeys', 'itervalues', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values', 'viewitems', 'viewkeys', 'viewvalues']

    2.字典的常用方法

      1 class dict(object):
  2     """
  3     dict() -> new empty dictionary
  4     dict(mapping) -> new dictionary initialized from a mapping object's
  5         (key, value) pairs
  6     dict(iterable) -> new dictionary initialized as if via:
  7         d = {}
  8         for k, v in iterable:
  9             d[k] = v
 10     dict(**kwargs) -> new dictionary initialized with the name=value pairs
 11         in the keyword argument list.  For example:  dict(one=1, two=2)
 12     """
 13 
 14     def clear(self): # real signature unknown; restored from __doc__
 15         """ 清除内容 """
 16         """ D.clear() -> None.  Remove all items from D. """
 17         pass
 18 
 19     def copy(self): # real signature unknown; restored from __doc__
 20         """ 浅拷贝 """
 21         """ D.copy() -> a shallow copy of D """
 22         pass
 23 
 24     @staticmethod # known case
 25     def fromkeys(S, v=None): # real signature unknown; restored from __doc__
 26         """
 27         dict.fromkeys(S[,v]) -> New dict with keys from S and values equal to v.
 28         v defaults to None.
 29         """
 30         pass
 31 
 32     def get(self, k, d=None): # real signature unknown; restored from __doc__
 33         """ 根据key获取值，d是默认值 """
 34         """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
 35         pass
 36 
 37     def has_key(self, k): # real signature unknown; restored from __doc__
 38         """ 是否有key """
 39         """ D.has_key(k) -> True if D has a key k, else False """
 40         return False
 41 
 42     def items(self): # real signature unknown; restored from __doc__
 43         """ 所有项的列表形式 """
 44         """ D.items() -> list of D's (key, value) pairs, as 2-tuples """
 45         return []
 46 
 47     def iteritems(self): # real signature unknown; restored from __doc__
 48         """ 项可迭代 """
 49         """ D.iteritems() -> an iterator over the (key, value) items of D """
 50         pass
 51 
 52     def iterkeys(self): # real signature unknown; restored from __doc__
 53         """ key可迭代 """
 54         """ D.iterkeys() -> an iterator over the keys of D """
 55         pass
 56 
 57     def itervalues(self): # real signature unknown; restored from __doc__
 58         """ value可迭代 """
 59         """ D.itervalues() -> an iterator over the values of D """
 60         pass
 61 
 62     def keys(self): # real signature unknown; restored from __doc__
 63         """ 所有的key列表 """
 64         """ D.keys() -> list of D's keys """
 65         return []
 66 
 67     def pop(self, k, d=None): # real signature unknown; restored from __doc__
 68         """ 获取并在字典中移除 """
 69         """
 70         D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 71         If key is not found, d is returned if given, otherwise KeyError is raised
 72         """
 73         pass
 74 
 75     def popitem(self): # real signature unknown; restored from __doc__
 76         """ 获取并在字典中移除 """
 77         """
 78         D.popitem() -> (k, v), remove and return some (key, value) pair as a
 79         2-tuple; but raise KeyError if D is empty.
 80         """
 81         pass
 82 
 83     def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
 84         """ 如果key不存在，则创建，如果存在，则返回已存在的值且不修改 """
 85         """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
 86         pass
 87 
 88     def update(self, E=None, **F): # known special case of dict.update
 89         """ 更新
 90             {'name':'alex', 'age': 18000}
 91             [('name','sbsbsb'),]
 92         """
 93         """
 94         D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 95         If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
 96         If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
 97         In either case, this is followed by: for k in F: D[k] = F[k]
 98         """
 99         pass
100 
101     def values(self): # real signature unknown; restored from __doc__
102         """ 所有的值 """
103         """ D.values() -> list of D's values """
104         return []
105 
106     def viewitems(self): # real signature unknown; restored from __doc__
107         """ 所有项，只是将内容保存至view对象中 """
108         """ D.viewitems() -> a set-like object providing a view on D's items """
109         pass
110 
111     def viewkeys(self): # real signature unknown; restored from __doc__
112         """ D.viewkeys() -> a set-like object providing a view on D's keys """
113         pass
114 
115     def viewvalues(self): # real signature unknown; restored from __doc__
116         """ D.viewvalues() -> an object providing a view on D's values """
117         pass
118 
119     def __cmp__(self, y): # real signature unknown; restored from __doc__
120         """ x.__cmp__(y) <==> cmp(x,y) """
121         pass
122 
123     def __contains__(self, k): # real signature unknown; restored from __doc__
124         """ D.__contains__(k) -> True if D has a key k, else False """
125         return False
126 
127     def __delitem__(self, y): # real signature unknown; restored from __doc__
128         """ x.__delitem__(y) <==> del x[y] """
129         pass
130 
131     def __eq__(self, y): # real signature unknown; restored from __doc__
132         """ x.__eq__(y) <==> x==y """
133         pass
134 
135     def __getattribute__(self, name): # real signature unknown; restored from __doc__
136         """ x.__getattribute__('name') <==> x.name """
137         pass
138 
139     def __getitem__(self, y): # real signature unknown; restored from __doc__
140         """ x.__getitem__(y) <==> x[y] """
141         pass
142 
143     def __ge__(self, y): # real signature unknown; restored from __doc__
144         """ x.__ge__(y) <==> x>=y """
145         pass
146 
147     def __gt__(self, y): # real signature unknown; restored from __doc__
148         """ x.__gt__(y) <==> x>y """
149         pass
150 
151     def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
152         """
153         dict() -> new empty dictionary
154         dict(mapping) -> new dictionary initialized from a mapping object's
155             (key, value) pairs
156         dict(iterable) -> new dictionary initialized as if via:
157             d = {}
158             for k, v in iterable:
159                 d[k] = v
160         dict(**kwargs) -> new dictionary initialized with the name=value pairs
161             in the keyword argument list.  For example:  dict(one=1, two=2)
162         # (copied from class doc)
163         """
164         pass
165 
166     def __iter__(self): # real signature unknown; restored from __doc__
167         """ x.__iter__() <==> iter(x) """
168         pass
169 
170     def __len__(self): # real signature unknown; restored from __doc__
171         """ x.__len__() <==> len(x) """
172         pass
173 
174     def __le__(self, y): # real signature unknown; restored from __doc__
175         """ x.__le__(y) <==> x<=y """
176         pass
177 
178     def __lt__(self, y): # real signature unknown; restored from __doc__
179         """ x.__lt__(y) <==> x<y """
180         pass
181 
182     @staticmethod # known case of __new__
183     def __new__(S, *more): # real signature unknown; restored from __doc__
184         """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
185         pass
186 
187     def __ne__(self, y): # real signature unknown; restored from __doc__
188         """ x.__ne__(y) <==> x!=y """
189         pass
190 
191     def __repr__(self): # real signature unknown; restored from __doc__
192         """ x.__repr__() <==> repr(x) """
193         pass
194 
195     def __setitem__(self, i, y): # real signature unknown; restored from __doc__
196         """ x.__setitem__(i, y) <==> x[i]=y """
197         pass
198 
199     def __sizeof__(self): # real signature unknown; restored from __doc__
200         """ D.__sizeof__() -> size of D in memory, in bytes """
201         pass
202 
203     __hash__ = None
204 
205 dict
206 
207 dict code
    help(dict)

            字典是python数据类型中的一大亮点，在其中占有着独特的地位，在这里先介绍一下字典的特性，和list不同，字典是无序的，没有索引和切片，它依靠key和value之间的联系进行索引，由于这种特殊的索引方式，字典中不可以有重复的key。

    （1）keys/values/items：取所有字典的key/取所有字典的value/取所有字典的key，value

    1 >>> dic={'name':'zhenghao', 'age':20}
2 >>> dic.keys()
3 ['age', 'name']
4 >>> dic.values()
5 [20, 'zhenghao']
6 >>> dic.items()
7 [('age', 20), ('name', 'zhenghao')]

    （2）已知key的情况下，获取value的值时可以使用‘字典名[key值]’的方法，在循环遍历中，尽管字典提供了for k，v in dic.items()的方法，但是为了避免占用内存空间，我们还是遍历key，再利用key的值就可以获取到value啦！

    　　　　get：字典名[key值]的方式有一点弊端，那就是当key值不存在的时候会报错，这个时候我们使用get方法，可以避免报错的情况

     1 >>> dic={'name':'zhenghao', 'age':20}
 2 >>> for n in dic:  #循环时默认循环的是keys
 3 ...     print 'key:', n, 'value:', dic[n]
 4 ... 
 5 key: age value: 20  
 6 key: name value: zhenghao
 7 >>> dic['name'] 
 8 'zhenghao'
 9 >>> dic['score']  #会报错
10 Traceback (most recent call last):
11   File "<stdin>", line 1, in <module>
12 KeyError: 'score'
13 >>> dic.get('name')
14 'zhenghao'
15 >>> dic.get('score') #不会报错
16 >>> 
    17 >>>dic.get('score', -1) #不会报错，默认-1
    18 -1
    19 >>>'score' in dic #也不会报错
    20 False

    （3）clear：清空字典

    1 >>> dic.get('score')
2 >>> dic={'name':'zhenghao', 'age':20}
3 >>> dic.clear()
4 >>> dic
5 {}
6 >>>

    （4）pop：根据指定的key删除一组数据

    　  popitem：随机的删除一组数据。。。我觉得这就是python在逗我。。。

    （5）setdefault：dic.setdefault[key1],key1存在，则返回value1，不存在，则自动创建value = 'None'

    1 >>> dic={'name':'zhenghao'}
2 >>> dic.setdefault('name')
3 'zhenghao'
4 >>> dic.setdefault('age')
5 >>> dic
6 {'age': None, 'name': 'zhenghao'}
7 >>>

    （6）update:dict1.update(dict2),判断dict2中的每一个key在dict1中是否存在，存在：就将dict1中的value更新成dict2中的，不存在：将key和value都复制过去

     1 >>> dic
 2 {'age': None, 'name': 'E'}
 3 >>> dic1 = dic
 4 >>> 
 5 >>> dic1
 6 {'age': None, 'name': 'E'}
 7 >>> dic2 = {'age': 18, 'name': 'E','gender':'female'}
 8 >>> dic1.update(dic2)
 9 >>> dic1
10 {'name': 'E', 'gender': 'female', 'age': 18}

    （7）fromkeys：可以通过list或元组创建一个字典，

    　　dict.fromkeys([1,2,3],'test'),可以创建一个字典，但是如果a.fromkeys([1,2,3]，[]},创建的字典的值都是一个空列表，那么其中一个列表的值发生了变化，所有的列表都会跟着发生变化，因为这个方法就是很傻很天真的把所有value的指针指向了同一个列表。所以感觉这个方法也是逗我玩儿的。。。

    >>> a = dict.fromkeys([1,2,3],'test')
>>> a
{1: 'test', 2: 'test', 3: 'test'}
>>> a = dict.fromkeys([1,2,3],[])
>>> a[1].append('test')
>>> a
{1: ['test'], 2: ['test'], 3: ['test']}

    3.字典可以嵌套：

    1 >>> a_list = [[1,2,3],[4,5],[6,7]]  
2 >>> a_list[1][1]  
3 5  
4 >>> a_dict = {1:{"name":"qiwsir"},2:"python","email":"qiwsir@gmail.com"}  
5 >>> a_dict  
6 {1: {'name': 'qiwsir'}, 2: 'python', 'email': 'qiwsir@gmail.com'}  
7 >>> a_dict[1]['name']  #一个嵌套的dict访问其值的方法：一层一层地写出键  
8 'qiwsir

    4.获取键、值

    在上一讲中，已经知道可以通过dict的键得到其值。例上面的例子。

    还有别的方法得到键值吗？有！python一般不是只有一个方法实现某个操作的

      
     1 >>> website = {1:"google","second":"baidu",3:"facebook","twitter":4}  
 2   
 3 >>>#用d.keys()的方法得到dict的所有键，结果是list  
 4 >>> website.keys()  
 5 [1, 'second', 3, 'twitter']  
 6   
 7 >>>#用d.values()的方法得到dict的所有值，如果里面没有嵌套别的dict，结果是list  
 8 >>> website.values()  
 9 ['google', 'baidu', 'facebook', 4]  
10   
11 >>>#用items()的方法得到了一组一组的键值对，  
12 >>>#结果是list，只不过list里面的元素是元组  
13 >>> website.items()  
14 [(1, 'google'), ('second', 'baidu'), (3, 'facebook'), ('twitter', 4)]

    从上面的结果中，我们就可以看出，还可以用for语句循环得到相应内容。例如：

     1 >>> for key in website.keys():  
 2 ...   print key,type(key)  
 3 ...   
 4 1 <type 'int'>  
 5 second <type 'str'>  
 6 3 <type 'int'>  
 7 twitter <type 'str'>  
 8   
 9 >>>#下面的方法和上面的方法是一样的  
10 >>> for key in website:  
11 ...   print key,type(key)  
12 ...   
13 1 <type 'int'>  
14 second <type 'str'>  
15 3 <type 'int'>  
16 twitter <type 'str'>


    以下两种方法等效：

     1 >>> for value in website.values():  
 2 ...   print value  
 3 ...   
 4 google  
 5 baidu  
 6 facebook  
 7 4  
 8   
 9 >>> for key in website:  
10 ...   print website[key]  
11 ...   
12 google  
13 baidu  
14 facebook  
15 4

    下面的方法又是等效的：

     1 >>> for k,v in website.items():  
 2 ...   print str(k)+":"+str(v)  
 3 ...   
 4 1:google  
 5 second:baidu  
 6 3:facebook  
 7 twitter:4  
 8   
 9 >>> for k in website:  
10 ...   print str(k)+":"+str(website[k])  
11 ...   
12 1:google  
13 second:baidu  
14 3:facebook  
15 twitter:4

    下面的方法也能得到键值，不过似乎要多敲键盘

    1 >>> website  
2 {1: 'google', 'second': 'baidu', 3: 'facebook', 'twitter': 4}  
3 >>> website.get(1)     
4 'google'  
5 >>> website.get("second")  
6 'baidu'

    3.字典可以原地修改

    1 >>> dic={}
2 >>> id(dic)
3 139795272803784
4 >>> dic['name']='zhenghao' #直接给键值
5 >>> dic
6 {'name': 'zhenghao'}
7 >>> id(dic)
8 139795272803784
9 >>>

    3.字典的几种创建方法

     1 >>> dic={}  1 #空字典，原地修改，往里面添键值
 2 >>> dic
 3 {}
 4 >>> 
 5 >>> dic['name']='zhenghao'
 6 >>> dic
 7 {'name': 'zhenghao'}
 8 >>> 
 9 >>> dic2={'name':'zhenghao', 'age':20} 2 #直接给键值
10 >>> dic2
11 {'age': 20, 'name': 'zhenghao'}
12 >>>
       >>> dic3=(['name', 'zhenghao'], ['age', '20']) 3 #用dict（）方法，利用元组构造字典
13 >>> ifo=dict(dic3)
14 >>> ifo
15 {'age': '20', 'name': 'zhenghao'}
16 >>> 
17 >>> ifo=dict(name='zhenghao', age=20) #用dict（）方法
18 >>> ifo
19 {'age': 20, 'name': 'zhenghao'}
20 >>> 
21 >>> ifo={}.fromkeys(('name1', 'name2'), 'zhenghao') 4  #用fromkeys（）方法，注意：这种方法是重新建立一个dict
22 >>> ifo
23 {'name2': 'zhenghao', 'name1': 'zhenghao'}
24 >>> 
25 >>> ifo={}.fromkeys(['name1', 'name2'], 'zhenghao')
26 >>> ifo
27 {'name2': 'zhenghao', 'name1': 'zhenghao'}
28 >>> 
29 >>> dic3={(1,2):1}  #在字典中的键必须是不可变数据，值可以是任何类型
30 >>> dic3
31 {(1, 2): 1}
32 >>> 
33 >>> dic3={[1,2]:1}  #这里列表不可以做字典的键，因为是可变的数据类型，列表和字典是可变的，整数和字符串和元组都是不可变的
34 Traceback (most recent call last):
35   File "<stdin>", line 1, in <module>
36 TypeError: unhashable type: 'list'
37 >>>

        >>> dic3={{'s':2}:1}
        Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
        TypeError: unhashable type: 'dict'

    4.字典练习题

    1 练习：元素分类
2 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于等于 66 的值保存至第二个key的值中。
3 即： {'k1': 大于66 , 'k2': 小于等于66}

    回答：

    a=[11,22,33,44,55,66,77,88,99,90]
dict1={'k1':[],'k2':[]}

for i in a:
    if i >66:
        dict1['k1'].append(i)
    else:
        dict1['k2'].append(i)
print dict1

最好的是用下面的方法来动态的扩展字典：
a=[11,22,33,44,55,66,77,88,99,90]
dict1={}  #动态的增加字典

for i in a:
    if i >66:
        if 'k1' in dict1.keys():
            dict1['k1'].append(i)
        else:
            dict1['k1'] = [i,]
    else:
        if 'k2' in dict1.keys():
            dict1['k2'].append(i)
        else:
            dict1['k2'] = [i,]
print dict1

    四、set集合


    集合是不可重复的（dict的键），有的可修改可变，有的不可修改不可变（冷冻的集合），无序的，无索引和切片，无序的

    1.集合的全部方法

    set是一个无序且不重复的元素集合

    1 >>> dir(set)
2 ['__and__', '__class__', '__cmp__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
3 >>>

    2.集合的常用方法（可修改可变的）：

     1.add（）：

    1 >>> a_set = {}       #我想当然地认为这样也可以建立一个set  
2 >>> a_set.add("q")   #报错.看看错误信息,居然告诉我dict没有add.我分明建立的是set呀.  
3 Traceback (most recent call last):  
4  File "<stdin>", line 1, in <module>  
5 AttributeError: 'dict' object has no attribute 'add'  
6 >>> type(a_set)       #type之后发现,计算机认为我建立的是一个dict     
7 <type 'dict'>

    特别说明一下,{ }这个东西,在dict和set中都用.但是,如上面的方法建立的是dict,不是set.这是python规定的.要建立set,只能用下面介绍的方法了

    2.update（）：合并

    1 >>> a={1,2}
2 >>> s={'a','s'}
3 >>> a.update(s)
4 >>> a
5 set(['a', 1, 2, 's'])
6 >>> s
7 set(['a', 's'])
8 >>>

    3.pop（）：删除任意一个

     1 >>> s={1,2,3,'qer'}
 2 >>> s.pop()
 3 3
 4 >>> s
 5 set([1, 2, 'qer'])
 6 >>> s.pop()
 7 1
 8 >>> s
 9 set([2, 'qer'])
10 >>>

    4.remove（）：删除指定元素

    >>> s={1,2,3,'qer'}
>>> s.remove(1)
>>> s
set([3, 2, 'qer'])
>>> s.remove('qer')
>>> s
set([3, 2])
>>>

    5.clear（）：删除所有

    1 >>> s={1,2,3,'qer'}
2 >>> s.clear()
3 >>> s
4 set([])
5 >>>

     2.集合的创建

    set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。它的特点是：有的可变，有的不可变；元素无次序，不可重复。无序所以没有索引不能切片。

     1 >>> s=set('zhenghao') 2 #用set（）方法创建
 2 >>> s
 3 set(['a', 'e', 'g', 'h', 'o', 'n', 'z']) #可看出集合是不可重复的，无序的
 4 >>> 
 5 >>> s2=set([20, 'zhenghao', 20, 'xiaokai']) #用list创建集合，元素可以是int，str，tuple不可变的
 6 >>> s2
 7 set(['zhenghao', 20, 'xiaokai'])
 8 >>> 
 9 >>> s3={'zhenghao', 20}  1 #直接用{}创建
10 >>> s3
11 set(['zhenghao', 20])

    3.集合里的元素应该都是不可变的

     1 >>> s={2, 'zheng', [1,2,3], (3,4,5)}
 2 Traceback (most recent call last):
 3   File "<stdin>", line 1, in <module>
 4 TypeError: unhashable type: 'list'          #集合元素有列表，列表是可变的，所以报错
 5 >>> 
 6 >>> s={2, 'zheng', (3,4,5), {1:2,'d':4}}
 7 Traceback (most recent call last):
 8   File "<stdin>", line 1, in <module>
 9 TypeError: unhashable type: 'dict'          #字典也是可变的，不可哈希”(unhashable)就是其可变，如 list/dict，都能原地修改
10 >>>

    4.集合是无序的，没有索引

    1 >>> s={2, 'zheng', (3,4,5)}
2 >>> s[1]='xiao'                 #集合没有索引值
3 Traceback (most recent call last):
4   File "<stdin>", line 1, in <module>
5 TypeError: 'set' object does not support item assignment
6 >>>

    set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

    1 >>> s1 = set([1, 2, 3])
2 >>> s2 = set([2, 3, 4])
3 >>> s1 & s2
4 {2, 3}
5 >>> s1 | s2
6 {1, 2, 3, 4}

     冷冻的集合，集合的运算等http://www.lai18.com/content/384856.html

     
  • 相关阅读:
    2017-2018-1 20155209 20155230 实验四 外设驱动程序设计
    2017-2018-1 20155230《信息安全系统设计基础》第十一周学习总结
    20155209 20155230 《信息安全技术》实验四 木马及远程控制技术
    2017-2018-1 20155230 实验三 实时系统
    2017-2018-1 20155230 mypwd实现
    2017-2018-1 20155230 《信息安全系统设计基础》第九周学习总结
    20155204《信息安全系统设计基础》课程总结
    20155204 《信息安全系统设计基础》第十四周学习总结
    20155204 《信息安全系统设计基础》第十三周学习总结
    2017-2018-1 20155203 20155204 实验五 通讯协议设计
  • 原文地址：https://www.cnblogs.com/zhenghaonihao/p/6213139.html
Copyright © 2020-2023  润新知