#列表型別

======================================基本使用======================================

1、用途：記錄多個值（同種屬性）

2、定義方式：在[]內用逗號分隔開多個任意型別的值

l=['a','b','c'] #l=list(['a','b','c'])

型別轉換

l=list('hello')

l=list({'x':1,'y':2}) #將字典轉換為列表

print(l)

3、常用操作+內建的方法

#優先掌握的操作：

l=['a','b','c','d','e']

1、按索引存取值(正向存取+反向存取)：即可存也可以取

print(l[0]) #讀取列表內第一個元素

print(l[-1]) #讀取列表內最後一個元素

print(id(l))

l[0]='A' #說明列表是可變的，元素改變，但是儲存在記憶體中的ID號不變

print(id(l))

l[4]='EEEEEE' #改變列表中最後一個元素的值

print(l)

l[5]='dddddd' #列表中不能新增新的值

#2、切片(顧頭不顧尾，步長)

l=['a','b','c','d','e']

print(l[1:4]) #列表切片，這裡得到的值是b,c,d

print(l)

#

#3、長度

l=['a','b','c','d','e']

print(len(l)) #檢視列表內有幾個元素這裡是5個

#4、成員運算in和not in

print('a' in l) #檢視a這個字元是不是在列表內

print('ssssss' not in l) #ssss這個元素不在l內， not in 所以也是TrUE

#5、追加&插入

l=['a','b','c','d','e']

l.append(3333333) #append 是新增的意思，在最後的尾部新增

l.append(44444)

print(l) #所以這裡列印的值為a,b,c,d,e,33333333333,444444

#

l.insert(0,11111111111) #inser是插入的意思，這裡0就是首部插入字元為111111111111

print(l) #列印的結果為 [11111111111, 'a', 'b', 'c', 'd', 'e']

#

6、刪除

l=['a','b','c','d','e']

del l[0] #del是刪除的意思，這裡刪除的是a這個元素

res=l.remove('b') #remove是移除的意思，這裡可以使用字元表示不需要根據索引來刪除

print(l)

print(res)

res=l.pop(0) #pop預設是從 首部開始的 如果想尾部刪除就使用-1

print(l)

print(res)

#

#7、迴圈

l=['a','b','c','d','e']

for item in l: #for迴圈列印列表內的元素

print(item)

#需要掌握的操作

l=['a','b','a','c','d','e']

print(l.count('a')) #count是統計列表內a這個元素在列表內有多少個

l=['a','b','a','c','d','e']

items=[1,2,3,4,5]

for item in items:

l.append(item) #for迴圈來依次吧items內的值新增到l內並打印出來

#

l.extend(items) #這裡的話extend一條命令就能完成for迴圈的操作，extend是延申的意思

print(l)

l=['a','b','a','c','d','e']

print(l.index('a',2,5)) #index是檢視a這個元素所在的列表內的位置! 2,5的意思就是從第二索引查到第五索引的位置

l.index(123123123123123123123123)

if 123123123123123123123123 in l:

print(l.index(123123123123123123123123))

l=['a','b','a','c','d','e']

l.reverse() #reverse的意思就是吧列表內的元素全部倒過來

print(l)

#

l=[10,-1,3,11,9]

l.sort(reverse=True) #sort是從小到大排序，但是()內添加了reverse=True時就是反轉，從大到小排序

print(l)

print(l.extend(['a','b','c'])) #直接吧a,b,c新增到l的列表內

print(l.pop(0)) #刪除第一個元素

print(l)

======================================該型別總結====================================

存多個值

有序

可變（1、可變：值變，id不變。可變==不可hash 2、不可變：值變，id就變。不可變==可hash）

練習題

#1. 佇列：先進先出 #佇列就是 吃了就啦 的意思，啦出來肯定是最先吃進去的

l=[] #定義一個空列表

入隊

l.append('first') #新增第一個元素

l.append('second') #新增第二個元素

l.append('third')

print(l)

出隊

print(l.pop(0)) #取出第一個元素 這個時候是first為第一個

print(l.pop(0))

print(l.pop(0))

2. 堆疊：後進先出 #堆疊就是吃了多了嘔吐了，吐出來的肯定是最後吃進去的東西

l=[]

入棧

l.append('first')

l.append('second')

l.append('third')

print(l)

出棧

print(l.pop()) #去除最後一個元素，這個時候是third

print(l.pop())

print(l.pop())

元組tuple：

======================================基本使用======================================

1、用途：元組就是一個不可變的列表

2、定義方式：在()內用逗號分隔開多個任意型別的元素

t=(1,2.2,'aa',('b','c'),['a','b','c']) # t=tuple(...)

print(type(t)) #檢視元祖型別為tuple

強調：

l=['a']

print(type(l),l[0]) #元祖也可以通過識別符號來取值

#

t=('a',)

print(type(t)) #只要元祖內有個逗號，他就是元祖，沒有逗號光一個值他就是字串

print(t)

msg=('hello world') #這個就是字串，一個不是元祖

型別轉換

t1=tuple('hello') #將字串轉換為元祖

t2=tuple([1,2,3]) #將列表轉化為元祖

print(t1)

print(t2)

3、常用操作+內建的方法

#優先掌握的操作：

t=(1,2.2,'aa',('b','c'),['a','b','c'])

1、按索引取值(正向取+反向取)：只能取

print(t[0]) #元祖正向取值根據索引去第一個為1

print(t[-1]) #元祖方向取值根據定位符取最後一個值 他是['a', 'b', 'c']

#

t[0]=1111111111

#2、切片(顧頭不顧尾，步長)
t=('a','b','c','e','f')

print(t[1:4]) #元祖切片，切出來的是'b','c','e'

#3、長度

print(len(t)) #顯示元祖內有幾個元素

#4、成員運算in和not in

print('a' in t)

#5、迴圈

for item in t:

print(item)

需要掌握的操作

t=('a','b','c','e','a','f')

print(t.index('a',1,5)) #index是索引的意思，定義a 在這個元祖內的位置! 1,5是在第一位置到第五位置去查詢

print(t.count('a')) #count是統計這個a元素在元祖內有多少個

======================================該型別總結====================================

存多個值

有序

不可變（1、可變：值變，id不變。可變==不可hash 2、不可變：值變，id就變。不可變==可hash）

t=('a','b','c')

print(id(t))

t=('A','B','C')

print(id(t)) #這裡表示的是元祖是不可變的

#字典型別dict

======================================基本使用======================================

1、用途:記錄多個值,列表是索引對應值,而字典是key對應值,其中key對value有描述性的功能

2、定義方式:在{}用逗號分隔開多個元素,每個元素都是key:value的形式,其中key可以不可變型別,通常是字串型別

而value可以是任意型別

d={1:'aaa',2.2:'bbb','xxx':'ccc',(1,2,3):'dddd'} #d=dict(...)

print(d[(1,2,3)]) #字典取值的方式，如果要取多個 print(d[1],d['xxx'])

類轉換

d=dict(x=1,y=2,z=3) #這也是一次生成字典的方式

print(d)

items=[('name','egon'),('age',18),('gender','male')] #這也是字典生成的一種方式

d={}

for item in items:

d[item[0]]=item[1]

d=dict(items) #這dict是字典生成的方式

print(d)

瞭解

keys=['name','age','gender','height','weight']

d={}

for key in keys:

d[key]=None

#

d={}.fromkeys(keys,None) #fromkeys是生成value的關鍵詞

print(d,type(d)) #生成的資訊是{'name': None, 'age': None, 'gender': None, 'height': None, 'weight': None}

#

3、常用操作+內建的方法

#優先掌握的操作：

1、按key存取值：可存可取

dic={'name':'egon','age':18}

print(dic['name'])

dic['name']='EGON'

dic['gender']='male' #字典是可以改變vale 並可以新增新的key 和value進去

print(dic)

l=['a','b','c']

l[0]='A'

l[4]='AAA'

#2、長度len

dic={'name':'egon','age':18}

print(dic)

print(len(dic)) #字典統計長度是統計key有幾個的

#3、成員運算in和not in :是以字典的key為準的

dic={'name':'egon','age':18}

print('name' in dic)

print('egon' in dic)

#4、刪除
dic={'name':'egon','age':18}

del dic['name']

print(dic)

res=dic.pop('name')

print(dic) #字典用pop刪除字典key ，可以打印出來key對應的value的值

print(res)

res=dic.popitem() #popitem是刪除key和value的值 並且可以打印出來，刪除的內容

print(res)

#5、鍵keys()，值values()，鍵值對items()

在python2

>>> dic={'name':'egon','age':18}

>>>

>>>

>>> dic.keys()

['age', 'name']

>>>

>>>

>>> dic.values()

[18, 'egon']

>>>

>>>

>>> dic.items()

[('age', 18), ('name', 'egon')]

在python3

>>> dic={'name':'egon','age':18}

>>>

>>> dic.keys()

dict_keys(['name', 'age'])

>>> dic.values()

dict_values(['egon', 18])

>>> dic.items()

dict_items([('name', 'egon'), ('age', 18)])

#6、迴圈
dic={'name':'egon','age':18}
for k in dic: #預設是列印key
print(k)

for k in dic.keys(): #這個是後面指定列印key值
print(k)

for v in dic.values(): #這個是指定列印value的值
print(v)

for k,v in dic.items(): #k,v=('name', 'egon') #當使用.items時， 前面需要使用2個值來對應,這樣可以同時打印出key，和value的值
print(k,v)

======================================該型別總結====================================

存一個值or存多個值

有序or無序

可變or不可變（1、可變：值變，id不變。可變==不可hash 2、不可變：值變，id就變。不可變==可hash）

pythons=['張鐵蛋','李銅淡','王金蛋','趙銀膽','alex','kevin']

linuxs=['oldboy','張鐵蛋','趙銀膽','alex','wxx']

#

res=[]

for stu in pythons:

if stu in linuxs:

res.append(stu)

#

print(res)

集合型別set

======================================基本使用======================================

1、用途:I: 關係運算 II:去重

2、定義方式:在{}內用逗號分隔開多個元素,但是元素的特點是

I: 集合內的元素必須是不可變型別

II: 集合內元素無序

III: 集合內元素不能重複

s={1,'aaa',2,} #s=set(...)

print(s,type(s))

s=set()

print(s,type(s))

s={1,1,1,1,1,1,1,1,1,1,1,1,'a','a','a'} #集合有去重複的意思，這裡顯示只有{1,'a'}

print(s)

資料型別轉換

res=set('hello') #吧字串變為集合顯示的為{'l', 'h', 'e', 'o'} 因為集合是無序的，去重所以少了個l

print(res)

res=set([1,'a','b']) #吧列表轉換為集合，顯示為{1, 'b', 'a'}

print(res)

3、常用操作+內建的方法

#優先掌握的操作：
#1、長度len
#2、成員運算in和not in

pythons={'張鐵蛋','李銅淡','王金蛋','趙銀膽','alex','kevin'}
linuxs={'oldboy','張鐵蛋','趙銀膽','alex','wxx'}
#3、|合集:求所有報名的學生

print(pythons | linuxs) # | 這個是讓幾個元祖 合集

print(pythons.union(linuxs))

#4、&交集:求同時報名兩門課程的學生

print(pythons & linuxs) # & 這個是顯示交集 顯示的是{'alex', '張鐵蛋', '趙銀膽'} 因為他們都報了2們課程

#5、-差集: 求只報名python課程的學員

print(pythons - linuxs) # - 這個是差集 是讓2個元祖內的元素相減

print(linuxs - pythons) #求只報名linux課程的學員

#6、^對稱差集:求沒有同時報名兩門課程的學生

res=(pythons - linuxs) | (linuxs - pythons)

res=pythons ^ linuxs # ^對稱差集

print(res)

#7、==

s1={1,2,3}

s2={3,2,1}

print(s1 == s2)

注意:父子集描述的是一種包含與被包含的關係

#8、父集：>= #>= 父集就是包含的意思
#9、子集：<=

s1={1,2,3}

s2={1,2,3,4}

print(s2 >= s1)

print(s1 <= s2)

需要掌握的

s1={1,2,3}

s1.update({3,4,5,6}) #update是更新的意思，就是新增元素到集合內{1, 2, 3, 4, 5, 6}

print(s1)

s1={1,'aa','bb',3}

print(s1.pop())

#

res=s1.remove('bbbbbb')

print(s1)

print(res)

s1.discard('bbb')

s1.add(4)

print(s1)

======================================該型別總結====================================

存多個值

無序

可變（1、可變：值變，id不變。可變==不可hash 2、不可變：值變，id就變。不可變==可hash）

集合的去重

侷限性

#1. 只能針對不可變型別
#2. 不能保證原來的順序

names=['egon','egon','egon','alex','alex','kevin']

new_names=list(set(names))

print(new_names)

l=[
{'name':'egon','age':18,'sex':'male'},
{'name':'alex','age':73,'sex':'male'},
{'name':'kevin','age':20,'sex':'female'},
{'name':'egon','age':18,'sex':'male'},
{'name':'egon','age':18,'sex':'male'},
]
new_l=[]
for dic in l:
if dic not in new_l:
new_l.append(dic)

print(new_l)