語法總結

1 再確認一次，在語言使用時 "string " 等同於 'string'  沒區別

2 無論tuple ,list , dict 本身是用不同的符號() [ ] {}，但是引用 index/key 都使用 [ ]

    tuple[index] list[index] dict["key"]

如果用了() 就會被認為是函式

如果用{} ，沒有這種用法，是語法錯誤

>>> listB1{1}
SyntaxError: invalid syntax

3  string字串， int  float數字等型別，是基礎型別，不存在巢狀問題

   屬於無法巢狀型別，單層資料型別？

  比如  12345 無法再細分

  比如  "abcde" ，無法這麼寫“ab""ced"  （2個字串） 或 “ab"c"ed" （語法錯誤，不是巢狀）

 

先吧各種型別的總結寫在前面

		是否可修改-hash	是否有序	是否有重複	是否可下標	備註
tuple	index-value/obj	不可修改(可hash)	有序	可有重複	是
str		不可修改(可hash)	有序	可有重複	是	特別的list
list	index-value/obj	可修改	有序	可有重複	是
dict	key:value	可修改	無序	key無重複	是
set	key	不可修改	無序	key無重複	不可	無value的dict
int/float		不可修改	有序	可有重複	不可

 

總結：可修改==不可做index/key，可下標==有index/key==可查詢

（1） 各種資料型別，包括資料型別的 index / key （一定不可變） 和value(有的可變 / 有的不可變)

          如果是不可變的（可hash），那麼只能是 int,float,string,tuple等（不能是list dict）

         如果是可變的，可以是各種型別

        所以dictA1={[ ]:"jack"}  肯定錯誤

（2）如果這一層想通過下標查詢

         這一層如果是可變型別（list 或 dict）或例外 tuple  string，那麼這一層一定可以  [ ] 這樣查詢  

         或者說是，可下標的（list,dict,tuple,string 沒例外），那麼這一層一定可以  [ ] 這樣查詢 

          或者說是，有index/key（list,dict,tuple,string 沒例外），那麼這一層一定可以  [ ] 這樣查詢 

（3）如果想通過最外層，想通過 巢狀下標 查詢

         這多層，每層都必須是可變型別（list 或 dict）或例外 tuple string，那麼這多層巢狀可以  [ ] 這樣查詢 

        或者說是，這多層都是可下標的（list,dict,tuple,string 沒例外），那麼這多層巢狀可以  [ ] 這樣查詢  

       或者說是，這多層都有index/key（list,dict,tuple,string 沒例外），那麼這多層巢狀可以  [ ] 這樣查詢  

 

詳細的內容

（1）支援下標的型別：tuple ,list  ,dict, string  （有序index或者有key 就支援下標）

        巢狀後仍然支援

       可下標的特點：有index/key

（2）不支援下標的型別：set， int ,float 和各種數字型別

       不可下標的特點：無index/key   （比如 int float set）

       巢狀後仍然不支援

（3）list

        list的元素可變，所以可以是任何型別

（4）dict

        dict的key的巢狀，因為key不可變

              只支援可hash型別：int, float, string ,tuple, 不支援可變的 list ,dict ,set型別

        dict的value巢狀，因為value可變

              所有型別都可以

             但set 等型別還是無法使用下標

（5）set的用法   set={value/obj   ,  value/obj }  

         set 不支援使用 index (肯定也不支援 key)，set 裡只有一堆 value/obj

         set的元素，需要可hash，只支援 int,float ,string,tuple

        同理，string ,int ,float set 因為本身不可修改，元素也是不可修改的

       所以也只能是 對應string ,int float  tuple  等，不能是 可變型別，list,dict,

       一個數據型別，本身不可變 (可hash)，那麼這個資料型別的元素也不可變

      但是特列是tuple，他的元素可以是可變的 list,dict

 

LIST巢狀和使用下標

(1)  list裡的元素可以是各種型別：

     list,tuple,dict,set,string,int,float 等等

(2)  list 允許巢狀和使用下標，只能是  list, tuple,dict，string

     list[ list, tuple,dict]

(3) 如果是string,int，肯定不能往下嵌套了，但是set 也是不能的

     而且set 和 上   int float一樣，是不支援 index的

 

巢狀後支援index的

>>> listB1=[{"name":"jack","age":"15"},{"name":"john","age":"16"}]
>>> listB1[0]["name"]
'jack'
>>> listB1=[("a",1),("b",2)]
>>> listB1[1][1]
2
>>> listB1=[["a",11],["b",22]]
>>> listB1[0][1]
11

>>> listC1=["abcde","hhh"]
>>> listC1[0][3]
'd'

 

巢狀後不支援index的

>>> listB1=[{"apple","pear"},{"red"},{"blue"}]
>>> listB1[0][1]
Traceback (most recent call last):
  File "<pyshell#51>", line 1, in <module>
    listB1[0][1]
TypeError: 'set' object does not support indexing
>>> 

>>> listB1=["str1","str2","str3"]
>>> listB2=[11,2,3]

 

tuple巢狀和使用下標

巢狀後支援index的,同list

>>> tupleA1=((1,2,3),4,5,6)
>>> tupleA1[0][2]
3
>>> tupleA2=(["a","b"],["c"])
>>> tupleA2[0][1]
'b'
>>> tupleA3=({"name":"jack"},{"class":1})
>>> tupleA3[1]["class"]
1

 

巢狀後不支援index的，還是set 和  int等

>>> tupleA4=({"a","b"},{"aaa"})

>>> tupleA4[0]
{'b', 'a'}
>>> tupleA4[1]
{'aaa'}
>>> tupleA4[0][0]
Traceback (most recent call last):
  File "<pyshell#65>", line 1, in <module>
    tupleA4[0][0]
TypeError: 'set' object does not support indexing

 

dict巢狀和使用下標

dict的key的限制

python不支援dict的key為list,dict,set型別，因為list和dict型別是unhashable（不可雜湊）的

只支援key是tuple的

>>> dictA1={{"name":"jack","name":"john"}:{"math":90,"phy":95}}
Traceback (most recent call last):
  File "<pyshell#67>", line 1, in <module>
    dictA1={{"name":"jack","name":"john"}:{"math":90,"phy":95}}
TypeError: unhashable type: 'dict'
>>> dictA2={[1,2,3]:[4,5,6]}
Traceback (most recent call last):
  File "<pyshell#68>", line 1, in <module>
    dictA2={[1,2,3]:[4,5,6]}
TypeError: unhashable type: 'list'

>>> dictA4={{1,2,3}:{7,8,9}}
Traceback (most recent call last):
  File "<pyshell#74>", line 1, in <module>
    dictA4={{1,2,3}:{7,8,9}}
TypeError: unhashable type: 'set'

 

只有tuple,string,int,float可以作為key

>>> dictA3={(1,2,3):(4,5,6)}
>>> dictA3[(1,2,3)][1]
5

 

dict的value的限制

>>> dictB1={"aa":{"a":1,"b":2},"bb":11}   #value可以是dict,可以下標查
>>> dictB1["bb"]
11
>>> dictB1["aa"]["a"]
1

>>> dictB2={"aa":[1,2,3],"bb":11}            #value可以是list,可以下標查
          
>>> dictB2["aa"][2]
          
3

>>> dictB3={(1,2,3):(11,12,13),"bb":11}     #key可以是tuple ,value可以是tuple,可以下標查
          
>>> dictB3[(1,2,3)][1]
          
12

 

巢狀後不支援index的
>>> dictB4={"aa":{11,12,13},"bb":11}      #value可以是set, 但是不可以下標查
          
>>> dictB4["aa"][0]
          
Traceback (most recent call last):
  File "<pyshell#85>", line 1, in <module>
    dictB4["aa"][0]
TypeError: 'set' object does not support indexing
>>> 

 

python裡 什麼叫不可雜湊（可變的不可hash）

作者：三十六_
連結：https://www.jianshu.com/p/bc5195c8c9cb

一個物件能被稱為 hashable ， 它必須有個 hash 值，這個值在整個生命週期都不會變化，而且必須可以進行相等比較，所以一個物件可雜湊，它必須實現__hash__() 與 __eq__() 方法。

Python 的某些連結庫在內部需要使用hash值，例如往集合中新增物件時會用__hash__() 方法來獲取hash值，看它是否與集合中現有物件的hash值相同，如果相同則會捨去不加入，如果不同，則使用__eq__() 方法比較是否相等，以確定是否需要加入其中。

對於 Python 的內建型別來說，只要是建立之後無法修改的(immutable)型別都是 hashable 如字串，可變動的都是 unhashable的比如：列表、字典、集合，他們在改變值的同時卻沒有改變id,無法由地址定位值的唯一性,因而無法雜湊。我們自定義的類的例項物件預設也是可雜湊的（hashable），而hash值也就是它們的id()。

 

set巢狀和--set本身無下標

（1） set 沒有下標index

（2）set的 value/obj  還不能是list ,dict ,set等不能hash的型別

        也就是說,set 一般元素使用  string,int，float 等，不能巢狀

（3）set唯一可巢狀的，tuple

        但是仍然無法有下標，和查詢

set無法巢狀 list dict

>>> setA={[1,2,3],[6,5,4]}
          
Traceback (most recent call last):
  File "<pyshell#86>", line 1, in <module>
    setA={[1,2,3],[6,5,4]}
TypeError: unhashable type: 'list'

>>> setA={{"a":1,"b":2},"aaa"}

Traceback (most recent call last):
  File "<pyshell#91>", line 1, in <module>
    setA={{"a":1,"b":2},"aaa"}
TypeError: unhashable type: 'dict'
>>> 

 

SET只能巢狀 tuple( 其實就是 set的元素只能是 int float string tuple等)

>>> setA={(1,2,3),(6,5,4)}
          
>>> setA[1][1]
          
Traceback (most recent call last):
  File "<pyshell#88>", line 1, in <module>
    setA[1][1]
TypeError: 'set' object does not support indexing
>>> setA[(1,2,3)][1]
          
Traceback (most recent call last):
  File "<pyshell#89>", line 1, in <module>
    setA[(1,2,3)][1]
TypeError: 'set' object is not subscriptable