一、列表類型

????????列表是指一系列的按特定順序排列的元素組成。使用[]定義列表，元素與元素之間使用英文的逗號分隔，列表中的元素可以是任意的數據類型。

#直接使用[]創建
lst=['hello','world',99.8,100]
print(lst)#可以使用內置的list()函數創建列表
lst2=list('helloworld')
lst3=list(range(1,10,2)) #從1開始，到10結束（不包含10），步長為2
print(lst2)
print(lst3)#列表中序列中的一種，對序列操作的運算符，操作符，函數均可以使用
print(lst+lst2+lst3) # 序列中的相加操作
print(lst*3) #相乘的操作
print(len(lst))
print(max(lst3))
print(min(lst3))
print(lst2.count('o')) # 統計o的個數
print(lst2.index('o')) #o在列表lst2中第一次出現的位置#列表的刪除操作lst4=[10,20,30]
print(lst4)
# 刪除列表
del lst4
#print(lst4)#NameError: name 'lst4' is not defined

?

?遍歷列表

lst=['hello','world','python','php']
# 使用遍歷循環for遍歷列表元素
for item  in lst:print(item)# 使用for循環,range()函數,len()函數，根據索引進行遍歷
for i in range(len(lst)):print(i,'-->',lst[i])#使用for循環與enumerate()函數，進行遍歷
for index,item in enumerate(lst):  #默認序號從0開始print(index,item)for index,item in enumerate(lst,1):  #序號從1開始print(index, item)

????????最后一個for循環for index,item in enumerate(lst,1)將序號設置為從1開始，但并沒有改變索引，索引依然從0開始。

列表的方法	描述說明
lst.append(x)	在列表中第index位置增加一個元素
lst.insert(index,x)	在列表中第index位置增加一個元素
lst.clear()	清除列表lst中所有元素
lst.pop(index)	將列表lst中第index位置的元素取出，并從列表中將其刪除
lst.remove(x)	將列表lst中出現的第一個元素x刪除
lst.reverse(x)	將列表lst中的元素反轉
lst.copy()	拷貝列表lst中的所有元素，生成一個新的列表

# coding:utf-8
lst=['hello','world','python']
print('原列表:',lst,id(lst))#新增元素的操作
lst.append('sql')
print('增加元素之后',lst,id(lst))#使用insert(index,x)在指定的位置上插入元素
lst.insert(1,100)
print(lst)#列表元素的刪除操作
lst.remove('world')
print('刪除元素之后的列表',lst,id(lst))#使用pop(index)根據索引移出元素，先將元素取出，再將元素刪除
print(lst.pop(1))
print(lst)#清除列表中所有的元素clear()
#lst.clear()
#print(lst,id(lst))#列表反向
lst.reverse()
print(lst)#列表的拷貝，將產生一個新的列表對象
new_lst=lst.copy()
print(lst,id(lst))
print(new_lst,id(new_lst))#列表元素的修改
#根據索引進行修改元素
lst[1]='mysql'
print(lst)

# coding:utf-8
lst=[4,56,3,78,40,56,89]
print('原列表:',lst)
#排序，默認是升序
lst.sort()   # lst.sort(reverse=False)
print('升序:',lst)#排序，降序
lst.sort(reverse=True)
print('降序:',lst)print('------------------------')
lst2=['banana','apple','Cat','Orange']
print('原列表:',lst2)
#升序排序 ,先排大寫，再排小寫
lst2.sort()
print('升序:',lst2)#降序  先排小寫，后排大寫
lst2.sort(reverse=True)
print('降序:',lst2)#忽略大小寫進行比較
lst2.sort(key=str.lower)
print(lst2)

# coding:utf-8
lst=[4,56,3,78,40,56,89]
print('原列表:',lst)
#排序
asc_lst=sorted(lst)
print('升序:',asc_lst)
print('原列表:',lst)#降序
desc_lst=sorted(lst,reverse=True)
print('降序:',desc_lst)
print('原列表:',lst)lst2=['banana','apple','Cat','Orange']
print('原列表:',lst2)#忽略大小寫的排序
new_lst2=sorted(lst2,key=str.lower)
print('原列表:',lst2)
print('排序后的列表:',new_lst2)

二維表

# coding:utf-8
# 創建二維列表
lst=[['城市','環比','同比'],['北京',102,103],['上海',104,504],['深圳',100,39]
]
print(lst)
#
for row in lst: #行for item in row:#列print(item,end='\t')print()#換行# 列表生成式生成一個四行五列的二維列表
lst2=[[j for j in range(5)] for i in range(4)]
print(lst2)

二、元組類型

元組是Python中的不可變數據類型，它沒有增、刪、改的一系統列操作方法，對于元組類型只可以使用索引獲取元素和使用for循環遍歷元素。

# coding:utf-8
# 直接使用()創建元組
t=('hello',[10,20,30],'python','world')
print(t)# 使用內置tuple()創建元組
t=tuple('helloworld')
print(t)t=tuple([10,20,30,40])
print(t)t=tuple(range(1,10))
print(t)# 元組的相關操作
print('10在元組中是否存在:',(10 in t))
print('10在元組中不存在:',(10 not in t))
print('max:',max(t))
print('min:',min(t))
print('len:',len(t))
print('t.index:',t.index(1))
print('t.count:',t.count(3))x=(10)
print(x,type(x))y=(10,) #元組中只有一個元素，逗號不能省
print(y,type(y))#元組的刪除
del t
#print(t)

三、字典類型

與列表和元組類型不同，字典類型是根據一個信息查找另一個信息的方式構成了“鍵值對”，它表示索引用的鍵和對應的值構成的成對關系。

典中沒有整數索引的概念，要想檢索字典中的元素只能通過鍵（key)

# coding:utf-8
# (1)直接使用{}創建
d={10:'cat',20:'dog',30:'pet',20:'zoo'}  # key相同，值進行覆蓋
print(d)#zip函數的使用
lst1=[10,20,30,40]
lst2=['cat','dog','car','zoo']
zipobj=zip(lst1,lst2)  #映射函數的結果是一個zip對象
#print(zipobj)
#print(list(zipobj))
d=dict(zipobj)
print(d)#使用參數創建字典
d=dict(cat=10,dog=20) # 注意事項，參數相當于變量，變量的名字不加引號
print(d)t=(10,20,30) # 創建一個元組
print({t:10})#lst=[10,20,30] #TypeError: unhashable type: 'list'
#print({lst:10}) 因為列表是可變數據類型#字典屬于序列類型
print('max:',max(d))
print('min:',min(d))
print('len:',len(d))#字典的刪除
del d
print(d)

字典的遍歷

# coding:utf-8
d={'hello':10,'world':20,'python':30}
# 訪問字典中的元素
# (1)使用[key]
print(d['hello'])
#（2）使用d.get(key)
print(d.get('hello'))#二者之間是有區別的，如果Key不存在時d[key]報錯，而使用get(key)可以指定默認值
#print(d['java'])#KeyError: 'java'
print(d.get('java')) #None
print(d.get('java','不存在'))# 字典的遍歷
for item in d.items():print(item) #key-value組成的一個元組#在使用for循環遍歷時，分別獲取key和value
for key,value in d.items():print(key, value)

字典的方法	描述說明
d.keys()	獲取所有的key數據
d.values()	獲取所有的value數據
d.pop(key,default)	key存在獲取相應的value，同時刪除key-value對，否則獲取默認值
d.popitem()	隨機從字典中取出一個key-value對，結果為元組類型，同時將該key-value從字典中刪除
d.clear()	清空字典中所有的key-value對

# coding:utf-8
d={1001:'李梅',1002:'王華',1003:'張峰'}
print(d)
#向字典中添加數據
d[1004]='張麗麗'  #直接使用賦值運算符=向字典中添加元素
print(d)#獲取字典中所有的key
keys=d.keys() # d.keys()結果是dict_keys ，Python中的一種內部數據類型， 專用于表示字典的key
#如果希望更好的顯示數據，可以使用list或者tuple轉成相應的數據類型print(keys)
print(list(keys))
print(tuple(keys))#獲取字典中所有的value
values=d.values()
print(values) #dict_values
print(list(values))
print(tuple(values))#字典遍歷的時用到的一個方法items
items=d.items() #dict_items
print(items)
print(list(items))
print(tuple(items))lst=list(items) #將字典中的數據轉成鍵-值對的形式，以元組的方式進行展示
print(lst)#直接可以使用dict函數將[(1001, '李梅'), (1002, '王華'), (1003, '張峰'), (1004, '張麗麗')]轉成字典
d=dict(lst)
print(d)#使用pop函數
print(d.pop(1001))
print(d)
print(d.pop(1008,'不存在')) #如果Key不存在，結果輸出默認值"不存在"#隨機刪除
print(d.popitem()) #先獲取key-value對
print(d)#清空字典中所有的元素
d.clear()
print(d)#Python中一切皆對象，而每一個對象都一個布爾值
print(bool(d)) #空字典的bool值為False

四、集合類型

Python中的集合與數學中集合的概念一致，是一個無序的不重復元素序列，所以集合中的元素要求唯一，由于集合的底層數據結構與字典中key的數據結構相同都是使用了Hash表，所以集合中只能存儲不可變數據類型(字符串、整數、浮點數、元組)。在Python中字典使用{}定義，集合也使用{}定義，元素之間使用英文的逗號進行分隔。集合與列表、字典一樣，都是Python中的可變數據類型。

# coding:utf-8
#使用{}直接創建集合
s={10,20,30,40}
print(s)
#s={[10,20],[30,40]}#TypeError: unhashable type: 'list'
#s={([10,20]),([20,30])}
print(s)s={} # 創建的是字典還是集合呢？
print(type(s)) #<class 'dict'>字典#如何創建空集合
s=set()
print(type(s),bool(s))# 第二種創建集合的方式set()
s=set('helloworld')
s2=set([10,20,30])
s3=set(range(1,10))
print(s)
print(s2)
print(s3)#集合屬于序列中的一種
print('max:',max(s3))
print('min:',min(s3))
print('len:',len(s3))print('9在集合中是否存在?',(9 in s3))
print('9在集合中不存在?',(9 not in s3))#集合的刪除
del s3
#print(s3) #NameError: name 's3' is not defined