一、元组

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

二、字典

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