列表（list）和元組（tuple）比較相似，它們都按順序保存元素，所有的元素占用一塊連續的內存，每個元素都有自己的索引，因此列表和元組的元素都可以通過索引（index）來訪問。它們的區別在於：列表是可以修改的，而元組是不可修改的。
字典（dict）和集合（set）存儲的數據都是無序的，每份元素占用不同的內存，其中字典元素以 key-value 的形式保存
需要明確的是，Python 中沒有數組，但是加入了更加強大的列表
列表可以存儲整數、小數、字符串、列表、元組等任何類型的數據，並且同一個列表中元素的類型也可以不同
num = [1, 2, 3, 4, 5, 6, 7]
name = ["C語言中文網", "http://c.biancheng.net"]
program = ["C語言", "Python", "Java"]
#將字符串轉換成列表
list1 = list("hello")
print(list1)
#將元組轉換成列表
tuple1 = ('Python', 'Java', 'C++', 'JavaScript')
list2 = list(tuple1)
print(list2)
#將字典轉換成列表
dict1 = {
'a':100, 'b':42, 'c':9}
list3 = list(dict1)
print(list3)
#將區間轉換成列表
#range() 函數能夠輕松地生成一系列的數字，讓 Python 從指定的第一個值開始，一直數到指定的第二個值停止，但不包含第二個值
range1 = range(1, 6)
list4 = list(range1)
print(list4)
#創建空列表
print(list())
索引從0開始，用len()函數可以獲得list元素的個數，當索引超出了范圍時，Python會報一個IndexError錯誤，所以，要確保索引不要越界，記得最後一個元素的索引是len(classmates) - 1。
listname[start : end : step]
其中，listname 表示列表名字，start 表示起始索引，end 表示結束索引，step 表示步長。
url = list("http://c.biancheng.net/shell/")
#使用索引訪問列表中的某個元素
print(url[3]) #使用正數索引
print(url[-4]) #使用負數索引
#使用切片訪問列表中的一組元素
print(url[9: 18]) #使用正數切片
print(url[9: 18: 3]) #指定步長
print(url[-6: -1]) #使用負數切片
language = ["Python", "C++", "Java"]
birthday = [1991, 1998, 1995]
info = language + birthday
print("language =", language)
print("birthday =", birthday)
print("info =", info)
listname.append(obj)
其中，listname 表示要添加元素的列表；obj 表示到添加到列表末尾的數據，它可以是單個元素，也可以是列表、元組等。
l = ['Python', 'C++', 'Java']
#追加元素
l.append('PHP')
print(l)
#追加元組，整個元組被當成一個元素
t = ('JavaScript', 'C#', 'Go')
l.append(t)
print(l)
#追加列表，整個列表也被當成一個元素
l.append(['Ruby', 'SQL'])
print(l)
extend() 和 append() 的不同之處在於：extend() 不會把列表或者元祖視為一個整體，而是把它們包含的元素逐個添加到列表中。
extend() 方法的語法格式如下：
listname.extend(obj)
其中，listname 指的是要添加元素的列表；obj 表示到添加到列表末尾的數據，它可以是單個元素，也可以是列表、元組等，但不能是單個的數字。
l = ['Python', 'C++', 'Java']
#追加元素
l.extend('C')
print(l)
#追加元組，元祖被拆分成多個元素
t = ('JavaScript', 'C#', 'Go')
l.extend(t)
print(l)
#追加列表，列表也被拆分成多個元素
l.extend(['Ruby', 'SQL'])
print(l)
append() 和 extend() 方法只能在列表末尾插入元素，如果希望在列表中間某個位置插入元素，那麼可以使用 insert() 方法。
listname.insert(index , obj)
其中，index 表示指定位置的索引值。insert() 會將 obj 插入到 listname 列表第 index 個元素的位置。
l = ['Python', 'C++', 'Java']
#插入元素
l.insert(1, 'C')
print(l)
#插入元組，整個元祖被當成一個元素
t = ('C#', 'Go')
l.insert(2, t)
print(l)
#插入列表，整個列表被當成一個元素
l.insert(3, ['Ruby', 'SQL'])
print(l)
#插入字符串，整個字符串被當成一個元素
l.insert(0, "http://c.biancheng.net")
print(l)
在 Python 列表中刪除元素主要分為以下 3 種場景：
del 可以刪除列表中的單個元素，格式為：
del listname[index]
其中，listname 表示列表名稱，index 表示元素的索引值。
lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
#使用正數索引
del lang[2]
print(lang)
#使用負數索引
del lang[-2]
print(lang)
del 也可以刪除中間一段連續的元素，格式為：
del listname[start : end]
lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
del lang[1: 4]
print(lang)
lang.extend(["SQL", "C#", "Go"])
del lang[-5: -2]
print(lang)
其中，start 表示起始索引，end 表示結束索引。del 會刪除從索引 start 到 end 之間的元素，不包括 end 位置的元素。
Python pop() 方法用來刪除列表中指定索引處的元素，具體格式如下：
listname.pop(index)
其中，listname 表示列表名稱，index 表示索引值。如果不寫 index 參數，默認會刪除列表中的最後一個元素
nums = [40, 36, 89, 2, 36, 100, 7]
nums.pop(3)
print(nums)
nums.pop()
print(nums)
remove() 方法只會刪除第一個和指定值相同的元素，而且必須保證該元素是存在的，否則會引發 ValueError 錯誤。
nums = [40, 36, 89, 2, 36, 100, 7]
#第一次刪除36
nums.remove(36)
print(nums)
#第二次刪除36
nums.remove(36)
print(nums)
#刪除78
nums.remove(78)
print(nums)
Python clear() 用來刪除列表的所有元素，也即清空列表，請看下面的代碼：
url = list("http://c.biancheng.net/python/")
url.clear()
print(url)
Python 提供了兩種修改列表（list）元素的方法，你可以每次修改單個元素，也可以每次修改一組元素（多個）。
修改單個元素非常簡單，直接對元素賦值即可。請看下面的例子：
nums = [40, 36, 89, 2, 36, 100, 7]
nums[2] = -26 #使用正數索引
nums[-3] = -66.2 #使用負數索引
print(nums)
Python 支持通過切片語法給一組元素賦值
nums = [40, 36, 89, 2, 36, 100, 7]
#修改第 1~4 個元素的值（不包括第4個元素）
nums[1: 4] = [45.25, -77, -52.5]
print(nums)
Python 列表（list）提供了 index() 和 count() 方法，它們都可以用來查找元素。
index() 方法用來查找某個元素在列表中出現的位置（也就是索引），如果該元素不存在，則會導致 ValueError 錯誤
index() 的語法格式為：
listname.index(obj, start, end)
其中，listname 表示列表名稱，obj 表示要查找的元素，start 表示起始位置，end 表示結束位置。
start 和 end 參數用來指定檢索范圍：
nums = [40, 36, 89, 2, 36, 100, 7, -20.5, -999]
#檢索列表中的所有元素
print( nums.index(2) )
#檢索3~7之間的元素
print( nums.index(100, 3, 7) )
#檢索4之後的元素
print( nums.index(7, 4) )
#檢索一個不存在的元素
print( nums.index(55) )
count() 方法用來統計某個元素在列表中出現的次數，基本語法格式為：
listname.count(obj)
其中，listname 代表列表名，obj 表示要統計的元素。
如果 count() 返回 0，就表示列表中不存在該元素，所以 count() 也可以用來判斷列表中的某個元素是否存在。
nums = [40, 36, 89, 2, 36, 100, 7, -20.5, 36]
#統計元素出現的次數
print("36出現了%d次" % nums.count(36))
#判斷一個元素是否存在
if nums.count(100):
print("列表中存在100這個元素")
else:
print("列表中不存在100這個元素")
另一種有序列表叫元組：tuple。tuple和list非常類似，但是tuple一旦初始化就不能修改，比如同樣是列出同學的名字：
通過( )創建元組後，一般使用=將它賦值給某個變量，具體格式為：
tuplename = (element1, element2, ..., elementn)
其中，tuplename 表示變量名，element1 ~ elementn 表示元組的元素。
需要注意的一點是，當創建的元組中只有一個字符串類型的元素時，該元素後面必須要加一個逗號,
#最後加上逗號
a =("http://c.biancheng.net/cplus/",)
print(type(a))
print(a)
#最後不加逗號
b = ("http://c.biancheng.net/socket/")
print(type(b))
print(b)
t = (1)
print(t)
t1 = (1,)
print(t1)
#將字符串轉換成元組
tup1 = tuple("hello")
print(tup1)
#將列表轉換成元組
list1 = ['Python', 'Java', 'C++', 'JavaScript']
tup2 = tuple(list1)
print(tup2)
#將字典轉換成元組
dict1 = {
'a':100, 'b':42, 'c':9}
tup3 = tuple(dict1)
print(tup3)
#將區間轉換成元組
range1 = range(1, 6)
tup4 = tuple(range1)
print(tup4)
#創建空元組
print(tuple())
和列表一樣，我們可以使用索引（Index）訪問元組中的某個元素（得到的是一個元素的值），也可以使用切片訪問元組中的一組元素（得到的是一個新的子元組）。
tuplename[i]
#i表示索引值。元組的索引可以是正數，也可以是負數。
tuplename[start : end : step]
#start 表示起始索引，end 表示結束索引，step 表示步長。
url = tuple("http://c.biancheng.net/shell/")
#使用索引訪問元組中的某個元素
print(url[3]) #使用正數索引
print(url[-4]) #使用負數索引
#使用切片訪問元組中的一組元素
print(url[9: 18]) #使用正數切片
print(url[9: 18: 3]) #指定步長
print(url[-6: -1]) #使用負數切片
前面我們已經說過，元組是不可變序列，元組中的元素不能被修改，所以我們只能創建一個新的元組去替代舊的元組。
例如，對元組變量進行重新賦值：
tup = (100, 0.5, -36, 73)
print(tup)
#對元組進行重新賦值
tup = ('Shell腳本',"http://c.biancheng.net/shell/")
print(tup)
還可以通過連接多個元組（使用+可以拼接元組）的方式向元組中添加新元素，例如：
tup1 = (100, 0.5, -36, 73)
tup2 = (3+12j, -54.6, 99)
print(tup1+tup2)
print(tup1)
print(tup2)
當創建的元組不再使用時，可以通過 del 關鍵字將其刪除，例如：
tup = ('Java教程',"http://c.biancheng.net/java/")
print(tup)
del tup
print(tup)
Python 字典（dict）是一種無序的、可變的序列，它的元素以“鍵值對（key-value）”的形式存儲。相對地，列表（list）和元組（tuple）都是有序的序列。
Python 字典特征：
由於字典中每個元素都包含兩部分，分別是鍵（key）和值（value），因此在創建字典時，鍵和值之間使用冒號:分隔，相鄰元素之間使用逗號,分隔，所有元素放在大括號{ }中。
使用{ }創建字典的語法格式如下：
dictname = {
'key':'value1', 'key2':'value2', ..., 'keyn':valuen}
其中 dictname 表示字典變量名，keyn : valuen 表示各個元素的鍵值對。需要注意的是，同一字典中的各個鍵必須唯一，不能重復。
#使用字符串作為key
scores = {
'數學': 95, '英語': 92, '語文': 84}
print(scores)
#使用元組和數字作為key
dict1 = {
(20, 30): 'great', 30: [1,2,3]}
print(dict1)
#創建空元組
dict2 = {
}
print(dict2)
Python 中，還可以使用 dict 字典類型提供的 fromkeys() 方法創建帶有默認值的字典，具體格式為：
dictname = dict.fromkeys(list，value=None)
其中，list 參數表示字典中所有鍵的列表（list）；value 參數表示默認值，如果不寫，則為空值 None。
knowledge = ['語文', '數學', '英語']
scores = dict.fromkeys(knowledge, 60)
print(scores)
#str 表示字符串類型的鍵，value 表示鍵對應的值。使用此方式創建字典時，字符串不能帶引號。
a = dict(str1=value1, str2=value2, str3=value3)
#向 dict() 函數傳入列表或元組，而它們中的元素又各自是包含 2 個元素的列表或元組，其中第一個元素作為鍵，第二個元素作為值。
#方式1
demo = [('two',2), ('one',1), ('three',3)]
#方式2
demo = [['two',2], ['one',1], ['three',3]]
#方式3
demo = (('two',2), ('one',1), ('three',3))
#方式4
demo = (['two',2], ['one',1], ['three',3])
a = dict(demo)
#通過應用 dict() 函數和 zip() 函數，可將前兩個列表轉換為對應的字典。
keys = ['one', 'two', 'three'] #還可以是字符串或元組
values = [1, 2, 3] #還可以是字符串或元組
a = dict( zip(keys, values) )
列表和元組是通過下標來訪問元素的，而字典不同，它通過鍵來訪問對應的值。因為字典中的元素是無序的，每個元素的位置都不固定，所以字典也不能像列表和元組那樣，采用切片的方式一次性訪問多個元素。
Python 訪問字典元素的具體格式為：
dictname[key]
其中，dictname 表示字典變量的名字，key 表示鍵名。注意，鍵必須是存在的，否則會拋出異常。
tup = (['two',26], ['one',88], ['three',100], ['four',-59])
dic = dict(tup)
print(dic['one']) #鍵存在
print(dic['five']) #鍵不存在
除了上面這種方式外，Python 更推薦使用 dict 類型提供的 get() 方法來獲取指定鍵對應的值。當指定的鍵不存在時，get() 方法不會拋出異常。
get() 方法的語法格式為：
dictname.get(key[,default])
其中，dictname 表示字典變量的名字；key 表示指定的鍵；default 用於指定要查詢的鍵不存在時，此方法返回的默認值，如果不手動指定，會返回 None。
a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get('one') )
a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get('five', '該鍵不存在') )
為字典添加新的鍵值對很簡單，直接給不存在的 key 賦值即可，具體語法格式如下：
dictname[key] = value
a = {
'數學':95}
print(a)
#添加新鍵值對
a['語文'] = 89
print(a)
#再次添加新鍵值對
a['英語'] = 90
print(a)
Python 字典中鍵（key）的名字不能被修改，我們只能修改值（value）。
字典中各元素的鍵必須是唯一的，因此，如果新添加元素的鍵與已存在元素的鍵相同，那麼鍵所對應的值就會被新的值替換掉
a = {
'數學': 95, '語文': 89, '英語': 90}
print(a)
a['語文'] = 100
print(a)
如果要刪除字典中的鍵值對，還是可以使用 del 語句。例如：
# 使用del語句刪除鍵值對
a = {
'數學': 95, '語文': 89, '英語': 90}
del a['語文']
del a['數學']
print(a)
如果要判斷字典中是否存在指定鍵值對，首先應判斷字典中是否有對應的鍵。判斷字典是否包含指定鍵值對的鍵，可以使用 in 或 not in 運算符。
a = {
'數學': 95, '語文': 89, '英語': 90}
# 判斷 a 中是否包含名為'數學'的key
print('數學' in a) # True
# 判斷 a 是否包含名為'物理'的key
print('物理' in a) # False
將這三個方法放在一起介紹，是因為它們都用來獲取字典中的特定數據：
scores = {
'數學': 95, '語文': 89, '英語': 90}
print(list(scores.keys()))
print(scores.values())
print(scores.items())
copy() 方法返回一個字典的拷貝，也即返回一個具有相同鍵值對的新字典，例如：
a = {
'one': 1, 'two': 2, 'three': [1,2,3]}
b = a.copy()
print(b)
update() 方法可以使用一個字典所包含的鍵值對來更新己有的字典。
在執行 update() 方法時，如果被更新的字典中己包含對應的鍵值對，那麼原 value 會被覆蓋；如果被更新的字典中不包含對應的鍵值對，則該鍵值對被添加進去。
a = {
'one': 1, 'two': 2, 'three': 3}
a.update({
'one':4.5, 'four': 9.3})
print(a)
pop() 用來刪除指定的鍵值對
a = {
'數學': 95, '語文': 89, '英語': 90, '化學': 83, '生物': 98, '物理': 89}
print(a)
a.pop('化學')
print(a)
set和dict類似，也是一組key的集合，但不存儲value。由於key不能重復，所以，在set中，沒有重復的key。
同一集合中，只能存儲不可變的數據類型，包括整形、浮點型、字符串、元組，無法存儲列表、字典、集合這些可變的數據類型，否則 Python 解釋器會拋出 TypeError 錯誤。比如說：
a={
{
'a':1}}
b={
[1,2,3]}
c={
{
1,2,3}}
print(a,b,c)
不可變的數據類型：整形、浮點型、字符串、元組
可變的數據類型：列表、字典、集合
對於不變對象來說，調用對象自身的任意方法，也不會改變該對象自身的內容。相反，這些方法會創建新的對象並返回，這樣，就保證了不可變對象本身永遠是不可變的
對於可變對象，比如list，對list進行操作，list內部的內容是會變化的，比如：
>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']
而對於不可變對象，比如str，對str進行操作呢：
>>> a = 'abc'
>>> a.replace('a', 'A')
'Abc'
>>> a
'abc'
a = {
1,'c',1,(1,2,3),'c'}
print(a)
set1 = set("c.biancheng.net")
set2 = set([1,2,3,4,5])
set3 = set((1,2,3,4,5))
print("set1:",set1)
print("set2:",set2)
print("set3:",set3)
由於集合中的元素是無序的，因此無法向列表那樣使用下標訪問元素。Python 中，訪問集合元素最常用的方法是使用循環結構，將集合中的數據逐一讀取出來。
a = {
1,'c',1,(1,2,3),'c'}
for ele in a:
print(ele,end=' ')
set 集合中添加元素，可以使用 set 類型提供的 add() 方法實現
需要注意的是，使用 add() 方法添加的元素，只能是數字、字符串、元組或者布爾類型（True 和 False）值，不能添加列表、字典、集合這類可變的數據，否則 Python 解釋器會報 TypeError 錯誤。例如：
a = {
1,2,3}
a.add((1,2))
print(a)
a.add([1,2])
print(a)
添加列表或集合中的元素到 set1
>>> set1 = {
1,2,3}
>>> set1.update([3,4])
>>> set1
{
1,2,3,4}
a = {
1,2,3}
a.remove(1)
print(a)
a.remove(1)
print(a)
隨機刪除元素
set1 = {
"a",2,3}
a = set1.pop()
print(a,set1)
