2.6基本數據類型——列表

列表的創建

list_test=[‘張三‘,‘李四’,‘alex‘]
#或
list_test=list(‘alex‘)
#或
list_test=list([‘張三‘,‘李四’,‘alex‘])

列表的特點和常用操作

特性：

1.可存放多個值

2.按照從左到右的順序定義列表元素，下標從0開始順序訪問，有序

3.可修改指定索引位置對應的值，可變

常規操作：

#索引
>>> l = [‘egon‘,‘alex‘,‘seven‘,‘yuan‘]
>>> l[0]
‘egon‘
>>> l[2]
‘seven‘

#
 
切片
>>> l[0:2]
[‘egon‘, ‘alex‘]
>>> l[2:5]
[‘seven‘, ‘yuan‘]
>>> l[:2]
[‘egon‘, ‘alex‘]
>>> l[2:]
[‘seven‘, ‘yuan‘]
>>> l[:]
[‘egon‘, ‘alex‘, ‘seven‘, ‘yuan‘]
>>> l[::2]
[‘egon‘, ‘seven‘]
>>> l[::-1]
[‘yuan‘, ‘seven‘, ‘alex‘, ‘egon‘]

#追加
>>> l.append("
 
eva")
>>> l
[‘egon‘, ‘alex‘, ‘seven‘, ‘yuan‘, ‘eva‘]

#刪除
>>> l.remove(‘eva‘)
>>> l
[‘egon‘, ‘alex‘, ‘seven‘, ‘yuan‘]
>>> l.pop()
‘yuan‘
>>> l
[‘egon‘, ‘alex‘, ‘seven‘]

#長度
>>> len(l)
3

#包含
>>> ‘seven‘ in l
True
>>> ‘yuan‘ in l
False

 
#循環:為什麽是“i”？
>>> for i in l:
    print(i)


egon
alex
seven

列表與字符串——split和join

#分割
>>> s = ‘hello world‘
>>> s.split(‘ ‘)
[‘hello‘, ‘world‘]
>>> s2= ‘hello,world‘
>>> s2.split(‘,‘)

#連接
>>> l = [‘hi‘,‘eva‘]
>>> ‘!‘.join(l)
‘hi!eva‘

2.7基本數據類型——元素

元組的定義和特性

定義：與列表類似，只不過［］改成（）

特性：

　　1.可存放多個值
　　2.不可變
　　3.按照從左到右的順序定義元組元素，下標從0開始順序訪問，有序

元素的創建：

ages = (11, 22, 33, 44, 55)
#或
ages = tuple((11, 22, 33, 44, 55))

元素的常規操作：

#索引
>>> ages = (11, 22, 33, 44, 55)
>>> ages[0]
11
>>> ages[3]
44
>>> ages[-1]
55

#切片:同list　　

#循環
>>> for age in ages:
    print(age)


11
22
33
44
55

#長度
>>> len(ages)
5

#包含
>>> 11 in ages
True
>>> 66 in ages
False
>>> 11 not in ages
False

元素特性：

1.可以存放多個值

當它只有一個值時

t = (1,)
t = (1)   #<==>t = 1

元組中不僅可以存放數字、字符串，還可以存放更加復雜的數據類型

2.不可變原則

元組本身不可變，如果元組中還包含其他可變元素，這些可變元素可以改變

2.8可變、不可變數據類型和hash

可變類型：列表

不可變類型：數字、字符串、元組

列表：

>>> l = [1,2,3,4]
>>> id(l)
4392665160
>>> l[1] = 1.5
>>> l
[1, 1.5, 3, 4]
>>> id(l)
4392665160

數字：

>>> a = 1
>>> id(a)
4297537952 
>>> a+=1
>>> id(a)
4297537984

字符串：

#例1
>>> s = ‘hello‘
>>> s[1] = ‘a‘
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    s[1] = ‘a‘
TypeError: ‘str‘ object does not support item assignment
#例2
>>> s = ‘hello‘
>>> id(s)
4392917064
>>> s += ‘ world‘
>>> s
‘hello world‘
>>> id(s)
4393419504

元素——不允許修改

>> t = (1,2,3,4)
>>> t[1] = 1.5
Traceback (most recent call last):
  File "<pyshell#10>", line 1, in <module>
    t[1] = 1.5
TypeError: ‘tuple‘ object does not support item assignment

hash:

>>> hash("張三")
6480394008723176318
>>> hash("李四")
-114706925611844552
>>> hash("王老五")
3250319002057530081

註：不可變的數據類型是可以被hash的，可變類型是不可以hash的。

2.9基本數據類型——字典

字典是python語言中唯一的映射類型。

定義：｛key1:value1,key2:value2｝

1、鍵與值用冒號“：”分開；
2、項與項用逗號“，”分開；

特性：

1.key-value結構
2.key必須可hash、且必須為不可變數據類型、必須唯一
3.可存放任意多個值、可修改、可以不唯一
4.無序

字典創建：

person = {"name": "alex", ‘age‘: 20}
#或
person = dict(name=‘seven‘, age=20)
#或
person = dict({"name": "egon", ‘age‘: 20})
#或

person = dict(([‘name‘,‘苑昊‘],[‘文周‘,18]))
{}.fromkeys(seq,100) #不指定100默認為None
#註意
>>> dic={}.fromkeys([‘k1‘,‘k2‘],[])
>>> dic
{‘k1‘: [], ‘k2‘: []}
>>> dic[‘k1‘].append(1)
>>> dic
{‘k1‘: [1], ‘k2‘: [1]}

字典的常規操作：

鍵、值、鍵值對
　　　　1、dic.keys() 返回一個包含字典所有KEY的列表；
　　　　2、dic.values() 返回一個包含字典所有value的列表；
　　　　3、dic.items() 返回一個包含所有（鍵，值）元祖的列表；
　　　　4、dic.iteritems()、dic.iterkeys()、dic.itervalues() 與它們對應的非叠代方法一樣，不同的是它們返回一個叠代子，而不是一個列表；
新增
　　　　1、dic[‘new_key‘] = ‘new_value‘；
　　　　2、dic.setdefault(key, None) ,如果字典中不存在Key鍵，由 dic[key] = default 為它賦值；_
刪除
　　　　1、dic.pop(key[,default]) 和get方法相似。如果字典中存在key，刪除並返回key對應的vuale；如果key不存在，且沒有給出default的值，則引發keyerror異常；
　　　　2、dic.clear() 刪除字典中的所有項或元素；    
修改
　　　　1、dic[‘key‘] = ‘new_value‘,如果key在字典中存在，‘new_value‘將會替代原來的value值；
　　　　2、dic.update(dic2) 將字典dic2的鍵值對添加到字典dic中
查看
　　　　1、dic[‘key‘]，返回字典中key對應的值，若key不存在字典中，則報錯；
　　　　2、dict.get(key, default = None) 返回字典中key對應的值，若key不存在字典中，則返回default的值（default默認為None）
循環
　　　　1、for k in dic.keys()
　　　　2、for k,v in dic.items()
　　　　3、for k in dic
長度
　　　　1、len(dic)

字典的工廠函數

class dict(object):
    """
    dict() -> new empty dictionary
    dict(mapping) -> new dictionary initialized from a mapping object‘s
        (key, value) pairs
    dict(iterable) -> new dictionary initialized as if via:
        d = {}
        for k, v in iterable:
            d[k] = v
    dict(**kwargs) -> new dictionary initialized with the name=value pairs
        in the keyword argument list.  For example:  dict(one=1, two=2)
    """
    def clear(self): # real signature unknown; restored from __doc__
        """ D.clear() -> None.  Remove all items from D. """
        pass

    def copy(self): # real signature unknown; restored from __doc__
        """ D.copy() -> a shallow copy of D """
        pass

    @staticmethod # known case
    def fromkeys(*args, **kwargs): # real signature unknown
        """ Returns a new dict with keys from iterable and values equal to value. """
        pass

    def get(self, k, d=None): # real signature unknown; restored from __doc__
        """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
        pass

    def items(self): # real signature unknown; restored from __doc__
        """ D.items() -> a set-like object providing a view on D‘s items """
        pass

    def keys(self): # real signature unknown; restored from __doc__
        """ D.keys() -> a set-like object providing a view on D‘s keys """
        pass

    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

    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

    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

    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 is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
        If E is present and lacks a .keys() method, then 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

    def values(self): # real signature unknown; restored from __doc__
        """ D.values() -> an object providing a view on D‘s values """
        pass

....略....

2.10基本數據類型——集合

集合中元素的三個特征：

1.確定性（元素必須可hash)

2.互異性（去重）

3.無序性（集合中的元素沒有先後之分），如集合{3，4，5}和{3，5，4}算同一個集合。

註意：集合存在的意義就在於去重和關系運算。

用集合解決問題

l={‘張三‘，’李四‘，’老男孩‘}   #集合定義
p={’張三‘，’李四‘，‘alex‘}
l_p=l&p        #集合求集
print(l_p)

集合的定義：

l={1,2,3,1} #此處應該說明集合“去重”的效果
#定義可變集合
>>> set_test=set(‘hello‘)#此處說明集合的“無序性”
>>>set_test
{‘l‘,‘o‘,‘e‘,‘h‘}
#改為不可變集合frozenset
>>>f_set_test=frozenset(sey_test)
>>>f_set_test
frozenset{‘l‘,‘e‘,‘h‘,‘o‘}

集合的關系運算：

|，|=合集，也叫並集

l={‘張三‘，‘李四‘，‘老男孩‘}
p={‘張三‘，‘李四‘，‘alex‘}
print(l.union(P))
print(l|p)

-,-=差集

l={‘張三‘,‘李四‘,‘老男孩‘}
p = {‘張三‘,‘李四‘,‘alex‘}
print(l.difference(p))
print(l-p)

^,^=對稱差集

a = {1,2,3}
b = {2,3,4,5}
print(a.symmetric_difference(b))
print(a^b)

包含關系

in，not in：判斷某元素是否在集合內

= =，!:判斷兩個集合是否相等

兩個集合之間一般有是三種關系，相交、包含、不相交。在Python中分別用下面的方法判斷:

• set.isdisjoint(s)：判斷兩個集合是不是不相交
• set.issuperset(s)：判斷集合是不是包含其他集合，等同於a>=b
• set.issubset(s)：判斷集合是不是被其他集合包含，等同於a<=b

集合的常用操作

元素的增加：

>>> a={1,2}
>>>a.update([3,4],[1,2,7])
>>>a
{1,2,3,4,7}
>>>a.update("hello")
>>>a
{1,2,3,4,7,‘h‘,‘e‘,‘l‘,‘o‘}
>>>a.add("hello")
>>>a
{1,2,3,4,‘hello",7,‘h‘,‘e‘,l‘,‘o‘}

元素的刪除集合刪除單個元素有兩種方法：

元素不在原集合中時：

set.discard不會拋出異常

set.remove(x)會拋出Key Error錯誤

>>> a={1,2,3,4}
>>> a.discard(1)
>>> a
{2, 3, 4}
>>> a.discard(1)
>>> a
{2, 3, 4}
>>> a.remove(1)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
KeyError: 1

pop():由於集合是無序的，pop返回的結果不能確定，且當集合為空時調用pop會拋出Key Error錯誤，clear（）：清空集合

>>> a={3,"a",2.1,1}
>>> a.pop()
>>> a.pop()
>>> a.clear()
>>> a
set()
>>> a.pop()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
KeyError: ‘pop from an empty set‘

2.11collections模塊

collections模塊在內置數據類型（dict、list、set、tuple）基礎上，還提供幾個額外的數據類型：

Chain Map、Counter、dequ、defaultdict、namedtuple和orderdict等

1.namedtuple: 生成可以使用名字來訪問元素內容的tuple子類
2.deque: 雙端隊列，可以快速的從另外一側追加和推出對象
3.Counter: 計數器，主要用來計數
4.OrderedDict: 有序字典
5.defaultdict: 帶有默認值的字典

nameduple

amedtuple是一個函數，它用來創建一個自定義的tuple對象，並且規定了tuple元素的個數，並可以用屬性而不是索引來引用tuple的某個元素。（註：tuple是不變集合）

驗證創建的Piont對象是tuple的一種子類：

>>>isinstance(p,Piont)
True
>>>isinstance(p,Piont)
True

如果要用坐標和半徑表示一個園，也可以用nameduple定義：

#namedtuple(‘名稱‘，[屬性list]):
Circle=namedtuple(Circle‘,[‘x‘,‘y‘,‘r‘])

deque

deque是為了高效實現列表，適合隊列和棧：

>>>from collections import deque
>>>q=deque([‘a‘,‘b‘,‘c‘])
>>>q.append(‘x‘)
>>>q.appendleft(‘y‘)
>>>q
deque([‘y‘,‘a‘,‘b‘,‘c‘,‘x‘])

deque除了實現listde append()和pop（）外，還支持append left（）和popleft()，這樣就可以非常高效的往頭部添加或刪除元素

defaultdict

使用dict時，如果引用的Key不存在，就會拋出Key Error。如果不希望Key不存在時，返回一個默認值，就可以用defaultdict:

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: ‘N/A‘)
>>> dd[‘key1‘] = ‘abc‘
>>> dd[‘key1‘] # key1存在
‘abc‘
>>> dd[‘key2‘] # key2不存在，返回默認值
‘N/A‘

ordereddict

使用dict時，Key是無序的。在對dict做叠代時，我們無法確定Key的順序。

如果要保持Key的順序，可以用OrderedDict：

>>> from collections import OrderedDict
>>> d = dict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
>>> d # dict的Key是無序的
{‘a‘: 1, ‘c‘: 3, ‘b‘: 2}
>>> od = OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])
>>> od # OrderedDict的Key是有序的
OrderedDict([(‘a‘, 1), (‘b‘, 2), (‘c‘, 3)])

註意，orderdict的Key會按照插入的順序排列，不是Key本身排序：

>>> od = OrderedDict()
>>> od[‘z‘] = 1
>>> od[‘y‘] = 2
>>> od[‘x‘] = 3
>>> od.keys() # 按照插入的Key的順序返回
[‘z‘, ‘y‘, ‘x‘]

ordereddict可以實現FIFO（先進先出）的dict，當容量超出限制時，先刪除最早添加的Key：

from collections import OrderedDict

class LastUpdatedOrderedDict(OrderedDict):

    def __init__(self, capacity):
        super(LastUpdatedOrderedDict, self).__init__()
        self._capacity = capacity

    def __setitem__(self, key, value):
        containsKey = 1 if key in self else 0
        if len(self) - containsKey >= self._capacity:
            last = self.popitem(last=False)
            print ‘remove:‘, last
        if containsKey:
            del self[key]
            print ‘set:‘, (key, value)
        else:
            print ‘add:‘, (key, value)
        OrderedDict.__setitem__(self, key, value)

Counter

counter是一個簡單的計數器，例如，統計字符出現的個數：

>>>form collertions import Counter
>>>c=counter()
>>>for ch in ‘programming‘:
...         c[ch]=c[ch]+1
...
>>>c
Counter({‘g‘,2,‘m‘:2,‘r‘:2,‘a‘:1,‘i‘:1,‘o‘:1,‘n‘:1,‘p‘:1})

Counter實際上也是dicde 一個子類，上面的結果可以看出，字符’g‘、‘m‘、‘r‘各出現了兩次，其他字符各出現了一次。

2.12本章小結

基本數據類型：

可變的數據類型：list dict set

不可變數據類型：數字類（bool,int,float,cinpiex)、str tuple frozenset

擴展數據類型collectins:

1.namedtuple(): 生成可以使用名字來訪問元素內容的tuple子類
2.deque: 雙端隊列，可以快速的從另外一側追加和推出對象
3.Counter: 計數器，主要用來計數
4.OrderedDict: 有序字典
5.defaultdict: 帶有默認值的字典

第二章python基礎續