Python基礎5：列表 元祖 字典 集合 Json

[ 列表]

列表（list）是Python以及其他語言中最常用到的數據結構之一。Python使用使用中括號 [ ] 來解析列表。

列表是可變的（mutable）——即：可以改變列表的內容。

相關操作：

1 查（［］）

names_class2=['張三','李四','王五','趙六']
 
# print(names_class2[2])
# print(names_class2[0:3])
# print(names_class2[0:7])
# print(names_class2[-1])
# print(names_class2[2:3])
# print(names_class2[0:3:1])
# print(names_class2[3:0:-1])
# print(names_class2[:])　

2 增（append，insert）

insert 方法用於將對象插入到列表中，而append方法則用於在列表末尾追加新的對象

names_class2.append('jesson')
names_class2.insert(2,'pitter')
print(names_class2)

 3 改（重新賦值)

names_class2=['張三','李四','王五','趙六']
 
names_class2[3]='趙七'
names_class2[0:2]=['jesson','pitter']
print(names_class2)

4 刪（remove，del，pop）

names_class2.remove('jesson')
del names_class2[0]
del names_class2
names_class2.pop()#注意，pop有返回值　

5 其他操作

5.1  count

       count 方法統計某個元素在列表中出現的次數：

>>> ['to', 'be', 'or', 'not', 'to', 'be'].count('to') 
2 
>>> x = [[1,2], 1, 1, [2, 1, [1, 2]]] 
>>> x.count(1) 
2 
>>> x.count([1,2]) 
1

5.2 extend

         extend 方法可以在列表的末尾一次性追加另一個序列中的多個值。

>>> a = [1, 2, 3] 
>>> b = [4, 5, 6] 
>>> a.extend(b) 
>>> a 
[1, 2, 3, 4, 5, 6] 

　　　　extend 方法修改了被擴展的列表，而原始的連接操作（+）則不然，它會返回一個全新的列表。

>>> a = [1, 2, 3] 
>>> b = [4, 5, 6] 
>>> a.extend(b) 
>>> a 
[1, 2, 3, 4, 5, 6] 
>>> 
>>> a + b 
[1, 2, 3, 4, 5, 6, 4, 5, 6] 
>>> a 
[1, 2, 3, 4, 5, 6] 

5.3  index

       index 方法用於從列表中找出某個值第一個匹配項的索引位置：

names_class2.index('李四')

5.4  reverse

       reverse 方法將列表中的元素反向存放。

names_class2.reverse()
print(names_class2)

5.5  sort

       sort 方法用於在原位置對列表進行排序。

x = [4, 6, 2, 1, 7, 9]
x.sort()#x.sort(reverse=True) 

注意：

列表中有個地方需要注意下，即Python在操作列表的時候，None數據類型 和 空‘ ’保存在列表中的時候，都是有效元素。

Python 3.5.2 (v3.5.2:4def2a2901a5,2016, 22:18:55) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> L = []
>>> L.append('')
>>> L
['']
>>> len(L) # 列表元素個數
1
>>> L.append(None)
>>> L
['', None]
>>> len(L) 
2

5.6  列表的切片操作

Python2中可以直接用L=range(0,100)構造一個列表：[0,1,2,3,4,........,98,99]

python3中的構造方法有點區別：L = list(range(0，100))

可以通過切片輕松取出某一段數列。比如前10個數：

>>> L[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

后10個數：

>>> L[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

前11-20個數：

>>> L[10:20]
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

前10個數，每兩個取一個：

>>> L[:10:2]
[0, 2, 4, 6, 8]

所有數，每5個取一個：

>>> L[::5]
[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]

甚至什么都不寫，只寫[:]就可以原樣復制一個list：

>>> L[:]
[0, 1, 2, 3, ..., 99]

tuple也是一種list，唯一區別是tuple不可變。因此，tuple也可以用切片操作，只是操作的結果仍是tuple：

>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)

字符串'xxx'也可以看成是一種list，每個元素就是一個字符。因此，字符串也可以用切片操作，只是操作結果仍是字符串：

>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'

 

[ tuple (元組) ]

元組被稱為只讀列表，即數據可以被查詢，但不能被修改，所以，列表的切片操作同樣適用於元組。

元組類似與列表，用逗號（,）來分隔存儲的數據，與列表不同的是元組是不可變類型（immutable），列表可以任你插入或改變，而元組不行。所以，元組適用於你的數據是固定且不需改變的情形。從內存的角度來看，使用元組有一大好處是，Python可以明確地知道需要分配多少內存給元組（同樣 Frozensets 也有這個好處）。

元組寫在小括號(())里，元素之間用逗號隔開。

雖然tuple的元素不可改變，但它可以包含可變的對象，比如list列表。

構造包含 0 個或 1 個元素的元組比較特殊，所以有一些額外的語法規則：

tup1 = ()    # 空元組
tup2 = (20,) # 元組中只有一個元素的時候，需要在元素后添加逗號，以消除歧義，避免解釋器誤解成數學計算意義上的括號。
             # 這是因為括號()既可以表示tuple，又可以表示數學公式中的小括號，一個元素不加逗號，就產生了歧義。
               Python規定，不加逗號情況下，按小括號進行計算，這里計算結果是20；
               所以，只有1個元素的元組定義時，元素后邊必須加一個逗號,，來消除歧義。

作用：

1 對於一些數據我們不想被修改，可以使用元組；

2 另外，元組的意義還在於，元組可以在映射（和集合的成員）中當作鍵使用——而列表則不行；元組作為很多內建函數和方法的返回值存在。

元組相關操作：

1 創建元組

tup1 = ('jesson', 'pitter', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";

print(tup1,type(tup1))
print(tup2,type(tup2))
print(tup3,type(tup3))

# 輸出結果
# ('jesson', 'pitter', 1997, 2000) <class 'tuple'>
# (1, 2, 3, 4, 5) <class 'tuple'>
# ('a', 'b', 'c', 'd') <class 'tuple'>

元組與字符串類似，下標索引從0開始，可以進行截取，組合等。

2 訪問元組

tup1 = ('jesson', 'pitter', 1997, 2000);
tup2 = (1, 2, 3, 4, 5, 6, 7 );

print ("tup1[0]是: ", tup1[0])      # 訪問元組tup1的第一個元素
print ("tup2[1:5]是: ", tup2[1:5])  # 對元組tup2中的元素 從索引下標1開始到4 進行切片操作 

# 輸出結果：
# tup1[0]是:  jesson
# tup2[1:5]是:  (2, 3, 4, 5)

3 修改元組

   元組中的元素值是不允許修改的，但我們可以對元組進行連接組合，如下實例:

tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');

# tup1[0] = 100;      # 這種修改元組元素操作是非法的，編譯的時候會報錯。
tup3 = tup1 + tup2; # 可以 創建一個新的元組
print(tup3)

# 輸出結果：
#(12, 34.56, 'abc', 'xyz')

4 刪除元組

元組中的元素值是不允許刪除的，但我們可以使用del語句來刪除整個元組。

tup = ('jesson', 'pitter',"你好",1997, 2000);
print(tup)

del(tup)
print("執行del刪除操作后的元組 tup:")
print(tup)

# 以上實例元組被刪除后，輸出變量會有異常信息，輸出如下所示：
# Traceback (most recent call last):
#   File "J:/元組 tuple.py", line 51, in <module>
#     print(tup)
# NameError: name 'tup' is not defined

5 元組運算符
   與字符串一樣，元組之間可以使用 + 號和 * 號進行運算。這就意味着他們可以組合和復制，運算后會生成一個新的元組。

6 元組內置函數

Python元組包含了以下內置函數
1、cmp(tuple1, tuple2)：比較兩個元組元素。
2、len(tuple)：計算元組元素個數。
3、max(tuple)：返回元組中元素最大值。
4、min(tuple)：返回元組中元素最小值。
5、tuple(seq)：將列表轉換為元組。

7 元組總結

   tuple和list非常類似，但是tuple一旦初始化就不能修改；這樣也就有了一個要求，就是：當你定義一個tuple時，在定義的時候，tuple的元素就必須被確定下來。

   既然元組是不能修改的，那么它的這種不可變性有什么意義？

   因為tuple不可變，所以代碼更安全；如果可能，能用tuple(元組)代替list(列表)就盡量用tuple。

 

[ Dictionary (字典) ]

字典是python中唯一的映射類型，采用鍵值對（key-value）的形式存儲數據。python對key進行哈希函數運算，根據計算的結果決定value的存儲地址，所以字典是無序存儲的，且key必須是可哈希的。可哈希表示key必須是不可變類型，如：數字、字符串、元組。

字典(dictionary)是除列表意外python之中最靈活的內置數據結構類型。列表是有序的對象結合，字典是無序的對象集合。兩者之間的區別在於：字典當中的元素是通過鍵來存取的，而不是通過偏移存取。

創建字典：

dic1={'name':'jesson','age':26,'sex':'male'}
dic2=dict((('name','jesson'),))
print(dic1)
print(dic2)

相關操作：

1 增

dic3={}
 
dic3['name']='jesson'
dic3['age']=26
print(dic3)#{'name': 'jesson', 'age': 26}
 
a=dic3.setdefault('name','pitter')
b=dic3.setdefault('ages',25)
print(a,b)
print(dic3)

2 查

dic3={'name': 'jesson', 'age': 26}
 
# print(dic3['name'])
# print(dic3['names'])
#
# print(dic3.get('age',False))
# print(dic3.get('ages',False))
 
print(dic3.items())
print(dic3.keys())
print(dic3.values())
 
print('name' in dic3)# py2:  dic3.has_key('name')
print(list(dic3.values()))

3 改

dic3={'name': 'jesson', 'age': 26}

dic3['name']='pitter'
dic4={'sex':'male','hobby':'sports','age':26}
dic3.update(dic4)
print(dic3)

4 刪

dic4={'name': 'jesson', 'age': 26,'class':1}
 
# dic4.clear()
# print(dic4)
del dic4['name']
print(dic4)
 
a=dic4.popitem()
print(a,dic4)
 
# print(dic4.pop('age'))
# print(dic4)
 
# del dic4
# print(dic4)

5 字典其他操作以及涉及到的方法

5.1 dict.fromkeys

d1=dict.fromkeys(['host1','host2','host3'],'Mac')
print(d1)
 
d1['host1']='jesson'
print(d1)
#######
d2=dict.fromkeys(['host1','host2','host3'],['Mac','huawei'])
print(d2)
d2['host1'][0]='jesson'
print(d2)

5.2  d.copy() 對字典 d 進行淺復制，返回一個和d有相同鍵值對的新字典

5.3 sorted(dict) : 返回一個有序的包含字典所有key的列表

dic={5:'555',2:'222',4:'444'}
print(sorted(dic))　

5.4 d.get() 獲取字典 d 中的相關值;

d = {'name':'jesson','age':'18'}
print(d['name'])     # 輸出結果：jesson 通過字典的鍵 獲取對應值
print(d.get('name')) # 輸出結果：jesson 通過get方法獲取相應鍵的值

print(d.get('sex','male')) #輸出結果：male # 字典的get()方法操作，如果字典中沒有鍵(sex)
# 默認返回值是:none 這里可以在鍵"sex"后 添加默認值，比如:(male)
# 如果原字典中可以找到該鍵，就輸出相應的值；如果找不到鍵，就輸出添加的默認值。

5.5 字典的遍歷

 

dic5={'name': 'jesson', 'age': 26}
# print(dic5.keys())
# print(dic5.values())

for i in dic5:
    print(i, dic5[i])
#輸出結果
# age 26
# name jesson

for items in dic5.items():
    print(items)
# 輸出結果
# ('age', 26)
# ('name', 'jesson')

for keys, values in dic5.items():
    print('key:{},value:{}'.format(keys,values))   # Python兩種字符串拼接方式 實現輸出功能一樣
    print('key:%s,value:%s' %(keys, values))
# 輸出結果
# age 26
# name jesson

5.6 通過字典來存取班級學生信息：

dic={'zhangsan':{'age':23,'sex':'male'},
     '李四':{'age':33,'sex':'male'},
     '王五':{'age':27,'sex':'women'}  
     }

 5.7 update合並：

用法待補充

 

[ Set (集合) ]

把不同的元素組成一起形成集合，是python基本的數據類型。

集合元素(set elements):組成集合的成員(不可重復)

li=[1,2,'a','b']
s =set(li)
print(s)    # {1, 2, 'a', 'b'}
 
li2=[1,2,1,'a','a']
s=set(li2)
print(s)  #{1, 2, 'a'}

集合對象是一組無序排列的可哈希的值：集合成員可以做字典的鍵

li=[[1,2],'a','b']
s =set(li) #TypeError: unhashable type: 'list'
print(s)

集合分類：可變集合、不可變集合

可變集合(set)：可添加和刪除元素，非可哈希的，不能用作字典的鍵，也不能做其他集合的元素

不可變集合(frozenset)：與上面恰恰相反

li=[1,'a','b']
s =set(li)
dic={s:'123'} #TypeError: unhashable type: 'set'

集合相關操作：

1、創建集合

     由於集合沒有自己的語法格式，只能通過集合的工廠方法set()和frozenset()創建

s1 = set('jesson')
s2 = frozenset('pitter')
 
print(s1,type(s1))  #{'l', 'v', 'i', 'a', 'n'} <class 'set'>
print(s2,type(s2))  #frozenset({'n', 'y', 'a', 'u'}) <class 'frozenset'>

2、訪問集合

由於集合本身是無序的，所以不能為集合創建索引或切片操作，只能循環遍歷或使用in、not in來訪問或判斷集合元素。

s1 = set('jesson')
print('a' in s1)
print('b' in s1)
# s1[1]  #TypeError: 'set' object does not support indexing

for i in s1:
    print(i)

#輸出結果：
False
False
s
j
n
o
e

3、更新集合

可使用以下內建方法來更新：

s.add()
s.update()
s.remove()

注意只有可變集合才能更新：

# s1 = frozenset('jesson')
# s1.add(0)  #輸出報錯：AttributeError: 'frozenset' object has no attribute 'add'

s2 = set('jesson')

# s2.add('mm')
# print(s2)  #輸出結果： {'e', 'mm', 'o', 's', 'n', 'j'} # 注意：.add()和.update()的區別，兩者都可以更新集合內元素，
但是.add()方法是把（）中新值，當作整體去更新；而.update()方法是將（）中的新值分開，單個，一個一個的添加更新。

# s2.update('HO')  # 添加多個元素
# print(s2)  #輸出結果： {'j', 'o', 'n', 'e', 'H', 'O', 's'}

# s2.remove('e')
# print(s2)  #輸出結果： {'j', 'o', 's', 'n'}

del：刪除集合本身

4、集合類型操作符　

（1）   in ,not in
（2）   集合等價與不等價(==, !=)
（3）   子集、超集

s=set('jessonwang')
s1=set('jesson')
print('e' in s)
print(s1<s)

（4）   聯合(|)

聯合(union)操作與集合的or操作其實等價的，聯合符號有個等價的方法，union()。

s1=set('jesson')
s2=set('wang')
s3=s1|s2
print(s3)  #輸出結果：{'e', 'o', 'a', 'w', 's', 'g', 'n', 'j'}
print(s1.union(s2)) #輸出結果：{'e', 'o', 'a', 'w', 's', 'g', 'n', 'j'}

（5） 交集(&)

與集合and等價，交集符號的等價方法是intersection()

s1 = set('jessonWang')
s2 = set('pitterZhao')
s3 = s1 & s2
print(s3)  # 輸出結果：{'e', 'a', 'o'}

print(s1.intersection(s2))  # 輸出結果：{'e', 'a', 'o'}

（6） 查補(-)
      等價方法是difference()

s1 = set('jesson')
s2 = set('wang')
s3 = s1 - s2
print(s3)  #輸出結果：{'j', 's', 'o', 'e'}

print(s1.difference(s2))  #輸出結果：{'j', 's', 'o', 'e'}

（7） 對稱差分(^)

對稱差分是集合的XOR(‘異或’)，取得的元素屬於s1,s2但不同時屬於s1和s2.其等價方法symmetric_difference()

s1 = set('jesson')
s2 = set('wang')
s3 = s1 ^ s2
print(s3)  #輸出結果： {'s', 'a', 'o', 'w', 'e', 'j', 'g'}

print(s1.symmetric_difference(s2))  #輸出結果：{'s', 'a', 'o', 'w', 'e', 'j', 'g'} 

應用技巧：

'''最簡單的去重方式'''

lis = [1,2,3,4,1,2,3,4]
print list(set(lis))    #[1, 2, 3, 4]

 補充：http://www.jb51.net/article/84869.htm

 

Json 序列化數據

Json數據類型 雖然不是Python的基本數據類型，但是，在日常開發中，涉及到的數據交互類型中，卻經常會遇到Json 數據類型，因此這里有必要，針對性的學習一下。

Json 數據類型格式：

小技巧：學習json的時候，格式類比python中的字典！但是，Python中一切皆對象，字典是字典對象，json是json格式的字符串對象；另外，注意，Json格式的數據中，沒有單引號！！！一般都是雙引號！！！

Json相關的操作中，常用的有四個參數，分別是：json.dumps和json.loads  json.dump和json.load，它們是成對出現的。

json.dumps 是將一個Python數據類型列表進行json格式的編碼解析，

示例如下：

>>> import json #導入python 中的json模塊
>>> l = [‘iplaypython’,[1,2,3], {‘name’:’xiaoming’}] #創建一個l列表
>>> encoded_json = json.dumps(l) # 將l列表，進行json格式化編碼
>>> print repr(l)   #輸出結果： ['iplaypython', [1, 2, 3], {'name': 'xiaoming'}]
>>> print encoded_json #輸出結果 ["iplaypython", [1, 2, 3], {"name": "xiaoming"}]

這樣我們就將一個list列表對象，進行了json格式的編碼轉換。

 

解碼python json格式，可以用這個模塊的json.loads()函數的解析方法，
示例如下：

>>> decode_json = json.loads(encoded_json)
>>> print type(decode_json) #查看一下解碼后的對象類型 <class 'list'>
>>> print decode_json #輸出結果 ['iplaypython', [1, 2, 3], {'name': 'xiaoming'}]

將python json格式解碼成Python數據風格

 

json.dump和json.dumps很不同，json.dump主要用來json文件讀寫，和json.load函數配合使用。

json.dump(x,f)，x是對象，f是一個文件對象，這個方法可以將json字符串寫入到文本文件中。

import json

data = [{"a":"aaa","b":"bbb","c":[1,2,3,(4,5,6)]},33,'tantengvip',True]
data2 = json.dumps(data)
print(data2)
f = open('./tt.txt','a')
json.dump(data2,f)

這樣就生成了一個tt.txt文件，保存了json格式的數據。dumps還提供pritty print，格式化的輸出。

json.load加載json格式文件   下面是從txt文件中讀取了json數據。

f = open('./tt.txt','r')
hehe = json.load(f)
print(hehe)

 

dumps & loads 針對內存對象，
即將Python內置數據序列化為字串
如使用json.dumps序列化的對象d_json=json.dumps({'a':1, 'b':2})，在這里d_json是一個字串'{"b": 2, "a": 1}'
d=json.loads(d_json)  #{ b": 2, "a": 1}，使用load重新反序列化為dict
 dump & load 針對文件句柄，(即，json.dump()方法，增加了對文件的操作，可以直接將支持序列化的數據，dump成json格式的字符串，並將其保存到指定文件；反之，json.load()方法是將json格式字符串

從指定文件中讀取出來，反序列化為原來dump之前的數據格式！) 比如：本地有一個json文件a.json則可以d=json.load(open('a.json'))， 而如果是dump操作，就是將內置類型序列化為json對象后寫入指定的文件！

 

Json總結：

json.dumps : dict轉成str      json.dump 是將python數據---->>序列化為json格式的字符串，並將其保存到指定文件中；

json.loads :  str轉成dict       json.load 是從某個數據文件中讀取json格式的數據  ---->>將其反序列化成Python數據