python元組與字典

1、元組

1.元組的表達

（1,2,3,4）
（'olive',123）
（"python",）

建立元組：

a=tuple((1,2,3,))
b=("python",)

2.元組功能屬性

 1 class tuple(object):
 2     """
 3     tuple() -> empty tuple
 4     tuple(iterable) -> tuple initialized from iterable's items
 5     
 6     If the argument is a tuple, the return value is the same object.
 7     """
 8     def count(self, value): # real signature unknown; restored from __doc__
 9         """ T.count(value) -> integer -- return number of occurrences of value """
10         return 0
11 
12     def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
13         """
14         T.index(value, [start, [stop]]) -> integer -- return first index of value.
15         Raises ValueError if the value is not present.
16         """
17         return 0
18 
19     def __add__(self, *args, **kwargs): # real signature unknown
20         """ Return self+value. """
21         pass
22 
23     def __contains__(self, *args, **kwargs): # real signature unknown
24         """ Return key in self. """
25         pass
26 
27     def __eq__(self, *args, **kwargs): # real signature unknown
28         """ Return self==value. """
29         pass
30 
31     def __getattribute__(self, *args, **kwargs): # real signature unknown
32         """ Return getattr(self, name). """
33         pass
34 
35     def __getitem__(self, *args, **kwargs): # real signature unknown
36         """ Return self[key]. """
37         pass
38 
39     def __getnewargs__(self, *args, **kwargs): # real signature unknown
40         pass
41 
42     def __ge__(self, *args, **kwargs): # real signature unknown
43         """ Return self>=value. """
44         pass
45 
46     def __gt__(self, *args, **kwargs): # real signature unknown
47         """ Return self>value. """
48         pass
49 
50     def __hash__(self, *args, **kwargs): # real signature unknown
51         """ Return hash(self). """
52         pass
53 
54     def __init__(self, seq=()): # known special case of tuple.__init__
55         """
56         tuple() -> empty tuple
57         tuple(iterable) -> tuple initialized from iterable's items
58         
59         If the argument is a tuple, the return value is the same object.
60         # (copied from class doc)
61         """
62         pass
63 
64     def __iter__(self, *args, **kwargs): # real signature unknown
65         """ Implement iter(self). """
66         pass
67 
68     def __len__(self, *args, **kwargs): # real signature unknown
69         """ Return len(self). """
70         pass
71 
72     def __le__(self, *args, **kwargs): # real signature unknown
73         """ Return self<=value. """
74         pass
75 
76     def __lt__(self, *args, **kwargs): # real signature unknown
77         """ Return self<value. """
78         pass
79 
80     def __mul__(self, *args, **kwargs): # real signature unknown
81         """ Return self*value.n """
82         pass
83 
84     @staticmethod # known case of __new__
85     def __new__(*args, **kwargs): # real signature unknown
86         """ Create and return a new object.  See help(type) for accurate signature. """
87         pass
88 
89     def __ne__(self, *args, **kwargs): # real signature unknown
90         """ Return self!=value. """
91         pass
92 
93     def __repr__(self, *args, **kwargs): # real signature unknown
94         """ Return repr(self). """
95         pass
96 
97     def __rmul__(self, *args, **kwargs): # real signature unknown
98         """ Return self*value. """
99         pass

tuple

3.元組的部分功能屬性介紹

元組和列表有很大類似性，可是元組的元素是不可修改的，因此不少列表有的功能元組都沒有。

1）count(self, value):

統計元組中包含value元素的數量，返回一個int值。

1 a=(1,2,3,4,1,2,3,1,2,)
2 b=a.count(1)
3 print(a,type(a))
4 print(b,type(b))
5 
6 #運行結果
7 (1, 2, 3, 4, 1, 2, 3, 1, 2) <class 'tuple'>
8 3 <class 'int'>

demo

2)index(self, value, start=None, stop=None):

索引，查找元組中value元素第一個出現的位置，start與stop參數是查找起始與結束位置，默認爲None，返回int數值，若是查找中不包含這個元素，則返回ValueError: 'f' is not in tuple報錯。

1 a=(1,2,3,4,1,2,3,1,2,)
2 b=a.index(3)
3 print(a,len(a))
4 print(b,type(b))
5 
6 #運行結果
7 (1, 2, 3, 4, 1, 2, 3, 1, 2) 9
8 2 <class 'int'>

demo

3）__add__(self, *args, **kwargs):

給元組添加一個新的元素，添加的新元素須要以元組的形式添加，生成一個新的元組。

1 a=(1,2,3,4)
2 b=a.__add__((5,1))   #括號理給出的必須是元組
3 print(a,type(a))
4 print(b,type(b))
5 
6 #運行結果
7 (1, 2, 3, 4) <class 'tuple'>
8 (1, 2, 3, 4, 5, 1) <class 'tuple'>

demo

4）__contains__(self, *args, **kwargs):

判斷元組中是否包含某個元素，返回布爾值。

 1 a=(1,2,3,4,1,2,3,1,2,)
 2 b=a.__contains__(2)
 3 c=a.__contains__(5)
 4 print(a)
 5 print(b)
 6 print(c)
 7 
 8 #運行結果
 9 (1, 2, 3, 4, 1, 2, 3, 1, 2)
10 True
11 False

demo

2、字典

1.字典的表達

{"name":"olive","age":18}

建立字典：

a={"name":"olive","age":18}
b=dict({"name":"lusi","age":18})

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     def clear(self): # real signature unknown; restored from __doc__
 14         """ D.clear() -> None.  Remove all items from D. """
 15         pass
 16 
 17     def copy(self): # real signature unknown; restored from __doc__
 18         """ D.copy() -> a shallow copy of D """
 19         pass
 20 
 21     @staticmethod # known case
 22     def fromkeys(*args, **kwargs): # real signature unknown
 23         """ Returns a new dict with keys from iterable and values equal to value. """
 24         pass
 25 
 26     def get(self, k, d=None): # real signature unknown; restored from __doc__
 27         """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
 28         pass
 29 
 30     def items(self): # real signature unknown; restored from __doc__
 31         """ D.items() -> a set-like object providing a view on D's items """
 32         pass
 33 
 34     def keys(self): # real signature unknown; restored from __doc__
 35         """ D.keys() -> a set-like object providing a view on D's keys """
 36         pass
 37 
 38     def pop(self, k, d=None): # real signature unknown; restored from __doc__
 39         """
 40         D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
 41         If key is not found, d is returned if given, otherwise KeyError is raised
 42         """
 43         pass
 44 
 45     def popitem(self): # real signature unknown; restored from __doc__
 46         """
 47         D.popitem() -> (k, v), remove and return some (key, value) pair as a
 48         2-tuple; but raise KeyError if D is empty.
 49         """
 50         pass
 51 
 52     def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
 53         """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
 54         pass
 55 
 56     def update(self, E=None, **F): # known special case of dict.update
 57         """
 58         D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 59         If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
 60         If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
 61         In either case, this is followed by: for k in F:  D[k] = F[k]
 62         """
 63         pass
 64 
 65     def values(self): # real signature unknown; restored from __doc__
 66         """ D.values() -> an object providing a view on D's values """
 67         pass
 68 
 69     def __contains__(self, *args, **kwargs): # real signature unknown
 70         """ True if D has a key k, else False. """
 71         pass
 72 
 73     def __delitem__(self, *args, **kwargs): # real signature unknown
 74         """ Delete self[key]. """
 75         pass
 76 
 77     def __eq__(self, *args, **kwargs): # real signature unknown
 78         """ Return self==value. """
 79         pass
 80 
 81     def __getattribute__(self, *args, **kwargs): # real signature unknown
 82         """ Return getattr(self, name). """
 83         pass
 84 
 85     def __getitem__(self, y): # real signature unknown; restored from __doc__
 86         """ x.__getitem__(y) <==> x[y] """
 87         pass
 88 
 89     def __ge__(self, *args, **kwargs): # real signature unknown
 90         """ Return self>=value. """
 91         pass
 92 
 93     def __gt__(self, *args, **kwargs): # real signature unknown
 94         """ Return self>value. """
 95         pass
 96 
 97     def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
 98         """
 99         dict() -> new empty dictionary
100         dict(mapping) -> new dictionary initialized from a mapping object's
101             (key, value) pairs
102         dict(iterable) -> new dictionary initialized as if via:
103             d = {}
104             for k, v in iterable:
105                 d[k] = v
106         dict(**kwargs) -> new dictionary initialized with the name=value pairs
107             in the keyword argument list.  For example:  dict(one=1, two=2)
108         # (copied from class doc)
109         """
110         pass
111 
112     def __iter__(self, *args, **kwargs): # real signature unknown
113         """ Implement iter(self). """
114         pass
115 
116     def __len__(self, *args, **kwargs): # real signature unknown
117         """ Return len(self). """
118         pass
119 
120     def __le__(self, *args, **kwargs): # real signature unknown
121         """ Return self<=value. """
122         pass
123 
124     def __lt__(self, *args, **kwargs): # real signature unknown
125         """ Return self<value. """
126         pass
127 
128     @staticmethod # known case of __new__
129     def __new__(*args, **kwargs): # real signature unknown
130         """ Create and return a new object.  See help(type) for accurate signature. """
131         pass
132 
133     def __ne__(self, *args, **kwargs): # real signature unknown
134         """ Return self!=value. """
135         pass
136 
137     def __repr__(self, *args, **kwargs): # real signature unknown
138         """ Return repr(self). """
139         pass
140 
141     def __setitem__(self, *args, **kwargs): # real signature unknown
142         """ Set self[key] to value. """
143         pass
144 
145     def __sizeof__(self): # real signature unknown; restored from __doc__
146         """ D.__sizeof__() -> size of D in memory, in bytes """
147         pass
148 
149     __hash__ = None

dict

3.字典的部分功能屬性介紹
1）clear(self):

清除字典中的全部元素。

1 a={"name":"olive","age":18}
2 b=a.clear()
3 print(a)
4 print(b)
5 
6 #運行結果
7 {}
8 None

demo

2）copy(self):

複製一份元組，至關於一次淺拷貝。 

 1 a={"name": "olive","age":18}
 2 b=a.copy()
 3 print(a,id(a),id("name"))
 4 print(b,id(b),id("name"))
 5 
 6 #賦值
 7 c={"name": "lusi","age":18}
 8 d=c
 9 print(c,id("name"))
10 print(d,id("name"))
11 
12 #淺拷貝
13 e={"name": "shy","age":18}
14 f=copy.copy(e)
15 print(e,id(e),id("name"))
16 print(f,id(f),id("name"))
17 
18 #運行結果
19 {'name': 'olive', 'age': 18} 2915224 2019840
20 {'name': 'olive', 'age': 18} 2915304 2019840
21 {'name': 'lusi', 'age': 18} 2019840
22 {'name': 'lusi', 'age': 18} 2019840
23 {'name': 'shy', 'age': 18} 5584616 2019840
24 {'name': 'shy', 'age': 18} 5586056 2019840

demo

3）fromkeys(*args, **kwargs):【fromkeys(seq,value=None)】

建立一個新的字典，以seq爲字典的keys（鍵），value爲字典的值，默認爲None。適合建立一個同樣值的字典。

 1 a={"hunan": "changsha","guangdong":"guangzhou","jiangsu":"nanjing",'hubei':"wuhan"}
 2 b=dict.fromkeys(a,"good")
 3 c=dict.fromkeys(["a","b","c"],"abc")
 4 d=dict.fromkeys("abcc")           
 5 print(a)
 6 print(b)
 7 print(c)
 8 print(d)
 9 
10 #運行結果
11 {'guangdong': 'guangzhou', 'hubei': 'wuhan', 'hunan': 'changsha', 'jiangsu': 'nanjing'}
12 {'hubei': 'good', 'guangdong': 'good', 'hunan': 'good', 'jiangsu': 'good'}
13 {'c': 'abc', 'b': 'abc', 'a': 'abc'}
14 {'c': None, 'b': None, 'a': None}   #seq給出的字符串c是重複的，可是建立的鍵只取一個。

demo

 4）get(self, k, d=None):

獲取字典中鍵爲k的值，若是字典中不包含k，則給出d值，d默認爲None。

 1 a={"a":1,"b":2,"c":3,"d":4}
 2 b=a.get("a")
 3 c=a.get("e")
 4 d=a.get("e",5)
 5 print(a)
 6 print(b)
 7 print(c)
 8 print(d)
 9 
10 #運行結果
11 {'b': 2, 'a': 1, 'c': 3, 'd': 4}
12 1
13 None
14 5

demo

5）items(self):

遍歷字典的一個方法，把字典中每對key和value組成一個元組，並把這些元組放在一個相似列表的dict_items中返回。

1 a={"a":1,"b":2,"c":3,"d":4}
2 b=a.items()
3 print(a)
4 print(b,type(b))
5 
6 #運行結果
7 {'d': 4, 'c': 3, 'a': 1, 'b': 2}
8 dict_items([('d', 4), ('c', 3), ('a', 1), ('b', 2)]) <class 'dict_items'>

demo

6）keys(self):

遍歷字典鍵keys的一個方法，返回一個相似列表的dict_keys，與items方法用法相同。

1 a={"a":1,"b":2,"c":3,"d":4}
2 b=a.keys()
3 print(a)
4 print(b,type(b))
5 
6 #運行結果
7 {'b': 2, 'a': 1, 'c': 3, 'd': 4}
8 dict_keys(['b', 'a', 'c', 'd']) <class 'dict_keys'>

demo

7)values(self):

遍歷字典值value的一個方法，返回一個相似列表的dict_values，與items方法用法相同。

1 a={"a":1,"b":2,"c":3,"d":4}
2 b=a.values()
3 print(a)
4 print(b,type(b))
5 
6 #運行結果
7 {'c': 3, 'd': 4, 'b': 2, 'a': 1}
8 dict_values([3, 4, 2, 1]) <class 'dict_values'>

demo

8）pop(self, k, d=None):

和get方法用法類似，只不過，get是獲取字典中鍵爲k的值，而pop是取出字典中鍵爲k的值。當字典中不含鍵k時，d不是默認值時，取到的值就爲d值，若是d爲默認值None時，則KeyError報錯。

 1 a={"a":1,"b":2,"c":3,"d":4}
 2 b=a.pop("a")
 3 c=a.pop("e","five")
 4 print(a)
 5 print(b,type(b))
 6 print(c,type(c))
 7 
 8 #運行結果
 9 {'c': 3, 'd': 4, 'b': 2}
10 1 <class 'int'>
11 five <class 'str'>

demo

9）popitem(self):

從字典中隨機取出一組鍵值，返回一個新的元組。若是字典中無鍵值可取，則KeyError報錯。

1 a={"a":1,"b":2,"c":3,"d":4}
2 b=a.popitem()
3 print(a)
4 print(b,type(b))
5 
6 #運行結果
7 {'d': 4, 'b': 2, 'a': 1}
8 ('c', 3) <class 'tuple'>

demo

10）setdefault(self, k, d=None):

從字典中獲取鍵爲k的值，當字典中包含鍵k值時，功能和get基本一致，當字典中不包含鍵k值時，在原字典上添加上鍵爲k的初始鍵值對，並返回值d。

 1 a={"a":1,"b":2,"c":3,"d":4}
 2 b=a.setdefault("a")
 3 c=a.setdefault("e")
 4 d=a.setdefault("f",6)
 5 print(a)
 6 print(b)
 7 print(c)
 8 print(d)
 9 
10 #運行結果
11 {'f': 6, 'c': 3, 'a': 1, 'e': None, 'b': 2, 'd': 4}
12 1
13 None
14 6

demo

11）update(self, E=None, **F):

給字典新增元素，沒有返回值。用法：dict.update(dict2)。

1 a={"a":1,"b":2,"c":3,"d":4}
2 b=a.update({"e":5})
3 print(a)
4 print(b)
5 
6 #運行結果
7 {'c': 3, 'b': 2, 'd': 4, 'a': 1, 'e': 5}
8 None

demo

12）__contains__(self, *args, **kwargs):

判斷列表中是否包含某個鍵值對，返回布爾值。用法：dict.__contains__(keys)。

1 a={"a":1,"b":2,"c":3,"d":4}
2 b=a.__contains__("a")
3 print(a)
4 print(b)
5 
6 #運行結果
7 {'a': 1, 'd': 4, 'c': 3, 'b': 2}
8 True

demo

13）__delitem__(self, *args, **kwargs):

刪除字典中的某個鍵值對，沒有返回值。用法：dict.__delitem__(keys)。

1 a={"a":1,"b":2,"c":3,"d":4}
2 b=a.__delitem__("a")
3 print(a)
4 print(b)
5 
6 #運行結果
7 {'c': 3, 'b': 2, 'd': 4}
8 None

demo