第四篇、编码解码 列表、元祖

Def decode(self,encoding-None,errors=None):
    “”解码
    s.decode([encoding[,errors])  →object

Def encode(self,encoding=None,errors=None):
    “””编码  针对unicode 

>>> ‘无‘
‘\xce\xde‘
>>> str1 =‘\xce\xde‘
>>> print str1
无
>>> str1.decode(‘gbk‘).encode(‘utf-8‘)  →解码成unicode之后编码成utf-8
‘\xe6\x97\xa0‘
>>> print str1.decode(‘gbk‘).encode(‘utf-8‘)
鏃

List = [] 这是空列表
Del list[2] 这个是删除下标为2的列表数据

添加列表   往列表的末尾添加数据
Def append(self,p_object):
    l.append(object)

列表中元素出现的次数
Def count(self,value):
    L.count(value):

列表的扩展，就相当于两个列表相加,注意这里只是扩展，内存地址，也就是id不变
Def extend(self,iterable):
    L.extend(iterable)
代码
>>> list2 = [22,33]
>>> list.extend(list2)
>>> list
[1, 22, 33]

返回列表中元素第一次出现的位置的下标
Def index(self,value,start=None,stop=None):
    L.index（value,[start,[stop]]）

在列表的指定下标位置插入数据
Def insert(self,index,p_object):
    L.insert(index,object)
代码如下：
>>> list
[1, 22, 33]
>>> list.insert(0,"a")
>>> list
[‘a‘, 1, 22, 33]

删除并返回指定下标的值，如果没有指定下标，最后一个返回并且删除
Def pop(self,index=None):
    L.pop([index])
代码如下：
>>> list
[‘a‘, 1, 22, 33]
>>> list.pop()
33
>>> list
[‘a‘, 1, 22]

指定值然后移除，如果列表中有很多这个值，那么只移除第一个
Def remove(self,value)：
    L.remove(value)
代码如下：
>>> list
[‘a‘, 1, 22, 22]
>>> list.remove(22)
>>> list
[‘a‘, 1, 22]

列表数据的反转
Def reverse(self):
    L.reverse()
代码如下：
>>> list
[‘a‘, 1, 22]
>>> list.reverse()
>>> list
[22, 1, ‘a‘]

排序中文unicode比较，英文acicc码比较，数字就按照数字比较
Def sort（self，cmp=None,key=None）:
    L.sort(cmp=None,Key=None)

创建字典的时候清除里面的内容
Def clear(self):
    d.clear()

Def copy(self):        浅拷贝
    d.copy()
深copy需要导入模块,完全独立的复制，就是完全独立了
Import copy
F = copy.deepcopy(dict)

代码例子如下：
>>> for i in range(5):d[i]=[]
...
>>> d
{0: [], 1: [], 2: [], 3: [], 4: []}
>>> c[1].append({"b":1})
>>> d[1].append({"b":1})
>>> d
{0: [], 1: [{‘b‘: 1}], 2: [], 3: [], 4: []}
>>> d[1]
[{‘b‘: 1}]
>>> d[1][0]
{‘b‘: 1}
>>> d[1][0][‘b‘]

获取字典中key的值，如果这个值没有就返回None，如果没有这个key对应的值，可以返回一个指定的值

Def get(self,k,d=None):
    d.get(k[,d])

代码例子：
>>> dic = {"k1":1234}
>>> dic.get("k1")
1234
>>> dic.get("k2")
>>> print dic.get(‘k2‘)
None
>>> print dic.get(‘k2‘,‘ok‘)
ok

把字典中的所有的key分给value
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
代码例子：
>>> a = {}
>>> a.fromkeys([1,2,3],‘t‘)
{1: ‘t‘, 2: ‘t‘, 3: ‘t‘}

检查字典中有没有键对应的这个值,有就返回true，没有就返回false
方法一
def has_key(self, k): # real signature unknown; restored from __doc__
    """ D.has_key(k) -> True if D has a key k, else False """
    return False
代码如下：
>>> b = {1:2,3:4}
>>> b.has_key(3)
True
>>> b.has_key(1)
True
>>> b.has_key(2)
False
方法二
Key in dic
>>> b = {1:2,3:4}
>>> 3 in b
True
>>> 1 in b
True
>>> 2 in b
False

把字典转换成列表
def items(self): # real signature unknown; restored from __doc__
    """ D.items() -> list of D‘s (key, value) pairs, as 2-tuples """
    return []
>>> b.items()
[(1, 2), (3, 4)]

迭代
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__
    """ D.iterkeys() -> an iterator over the keys of D """
    pass

def itervalues(self): # real signature unknown; restored from __doc__
    """ D.itervalues() -> an iterator over the values of D """
    pass

把当前所有的key打印出来
def keys(self): # real signature unknown; restored from __doc__
    """ D.keys() -> list of D‘s keys """
    return []
代码如下：
>>> b
{1: 2, 3: 4}
>>> b.keys()
[1, 3]

删除指定key的值的字典：
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
代码如下：
>>> b
{1: 2, 3: 4}
>>> b.pop(1)
2
>>> b
{3: 4}

按照生成的字典内存顺序，从开始删除
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
>>> c = b.fromkeys(range(100),[])
>>> c.popitem()
(0, [])
>>> c.popitem()
(2, [])
>>> c.popitem()
(3, [])

在字典中，如果这个字典的值存在，就什么不返回，如果不存在就返回这个值
def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
    """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
    pass
代码如下：
>>> b = {1:2,3:4}
>>> b.setdefault(4)
>>> b
{1: 2, 3: 4, 4: None}
>>> b.setdefault(5,6)
6
>>> b
{1: 2, 3: 4, 4: None, 5: 6}

把两个字典整合起来。比如a字典和b字典。如果a字典含有的key和b字典含有的key一样但是值不一样，那么b字典中的key值会把a字典中的key值替换掉。并且b所有的值都会在a字典中
def update(self, E=None, **F): # known special case of dict.update
    """
    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
代码例子：
>>> c = {1:2,3:4}
>>> d = {"a":2,"b":5,3:6}
>>> c.update(d)
>>> c
{‘a‘: 2, 1: 2, 3: 6, ‘b‘: 5}

打印所有的值
def values(self): # real signature unknown; restored from __doc__
    """ D.values() -> list of D‘s values """
    return []
代码例子：如上面的字典例子
>>> c.values()
[2, 2, 6, 5]

下面就是怎么变成一个集合
>>> set(a)
set([8, 9, 5, 6, 7])

那和a的区别是什么呢？如下
>>> a.append(6)
>>> a
[5, 6, 7, 8, 9, 6]
>>> set(a)
set([8, 9, 5, 6, 7])
可以看到上面的区别是集合可以去重以及无序的

集合的作用
>>> d=set(b)→把他们变成集合
>>> c &d   →  这个是取交集
set([8, 9, 7])
>>> c|d        →这个是取并集
set([5, 6, 7, 8, 9, 10, 11])
>>> c^d        →这个是取反交集
set([5, 6, 10, 11])
>>> c-d        →取出c集合中有的，但是d集合没有的元素
set([5, 6])
>>> d-c        →取出d集合中有的，但是c集合没有的元素
set([10, 11])

>>> e=set([8,10])
>>> e
set([8, 10])
>>> e.issubset(d)    →判断e是否是d的子集，如果是就返回的是bool
True

>>> e.issuperset(d)        →判断e是否是d的父集，返回的是bool判断
False

字典删除按照内存，从前往后删除
def pop(self, *args, **kwargs): # real signature unknown
    """
    Remove and return an arbitrary set element.
    Raises KeyError if the set is empty.
    """
    pass
代码如下：
>>> d
set([8, 9, 10, 11, 7])
>>> d.pop()
8
>>> d
set([9, 10, 11, 7])
>>> d.pop()
9
>>> d
set([10, 11, 7])

可以在集合中指定数据删除
def remove(self, *args, **kwargs): # real signature unknown
    """
    Remove an element from a set; it must be a member.
    
    If the element is not a member, raise a KeyError.
    """
    pass
代码如下：
>>> d.remove(7)
>>> d
set([10, 11])

两个集合中如果有不同的元素，整合到一块，如果有重复的元素，就不添加
def update(self, *args, **kwargs): # real signature unknown
    """ Update a set with the union of itself and others. """
    pass
>>> d.remove(7)
>>> d
set([10, 11])

判断一个集合是否是另一个集合的父类
def issuperset(self, *args, **kwargs): # real signature unknown
    """ Report whether this set contains another set. """
    pass

判断一个集合是否是另一个集合的子类
def issubset(self, *args, **kwargs): # real signature unknown
    """ Report whether another set contains this set. """
    pass