data structure in python

data structure in python

1. list（数组） order, changeable

including 2-dimension & 3-dimensio

note: x represents element in list, i represents index or location

1.append(x) add x into the list on the last position

2.insert(i,x) insert x into the position i-th

3.remove(x) delete the first x

4.pop(i) delete the i-th element, and return this element. If now argument, delete the last element

5.index(x) return the position of the first x. If no x, then return an error.

6.count(x) return the frequent number(how many x) of x in the list.

7.sort() make an order in list

8.reverse() make an opposite order in list

2.dict（字典） without order, changeable

It is a kind of corresponding or mapping structure, consisting with key-value. The data type of key cannot be changed, like string, int, tuple. However, value can be any data type.

1.create dict

>>dict1 = {}

2.add dict element (two way)

 first: >dict1[‘a’]=1. We can see dict1 this time is {‘a’:1}

 second: setdefault add a key-value pair on the last position.

 >>dict1.setdefault(‘b’,2). We can see dict1 after the first & second   method becomes {‘a’:1,’b’:2}

3.delete dict

suppose we have dict1 in step 2

>>del dict1[‘a’]   we can see that dict1 becomes {‘b’:2}

also >>dict1.pop(‘a’) can have the same perfomance

4.clear the dict into empty

>>dict1.clear()

delete the dict1 object

>>del dict1

5. method in dict

 1.get(key,default=None)

 if >>dict1.get(‘a’) cuz key a is not in dict1, thus return none

 if >>dict1.get(‘a’,’no1’) we set the default as ’no1’. Thus we get no1 as return if a is not in dict1.

 if >>dict1.get(‘a’) and there is a key named a, then return the corresponding value.

 

 2.clear dict

 dict.clear()

 3.has_key(key) check whether key is in dict. If so, return True, otherwise false.

 4.items

 return dict(key-value) as a tuple pair in list

 >>dict1.items()  we get a result [(‘a’,’1'),(‘b’,’2')]

 5. keys  return the key list of dict

 >>dict1.keys()  we get a result [‘a’,’b']

 6. value return the value list of dict

 >>dict.values() we get a result [‘1’,’2']

 7.>>setdefault(key,default=None)

  if there is a key in dict, return the value of key. If not key in dict, add this key into dict, corresponding value is provided by argument default.

 8.>>dict1.update(dict2)

 take the elements in dict2 adding into dict1. If there are repeat key, replace the original one(in dict1)

 9.popitem

 delete one key-value pair from the very beginning and return this pair. If dict is empty, return an error

 10.pop(key,[d])

 delete the specific key-value pair and return the corresponding value(not this pair, only value)

3.tuple（元组）order, unchangeable

 if the element in tuple is list, which is changeable, thus changing the element of tuple is feasible.

Cuz tuple storage the pointer（指针） of each element, which cannot be changed. It also means that the address of each element is stable. However, if the element is list, the pointer to this list can keep same and just modify the element in list.

However to express tuple

T = (23)  means that gives integer 23 to T

T = (23,) means that gives tuple containing only one element to T