python基礎之列表，元組，字典

時間 2019-11-16

原文原文鏈接

otherhtml

help(str.strip) #查看是否有返回值以及返回值類型
[] :稱爲索引操做符

1.列表python

列表相比字符串來講能存儲大量數據的python的基本數據類型，而且也擁有字符串的一些方法(索引，切片等等)

列表是以[]中括號組成，每一個元素以,逗號隔開的，容器型數據類型。

列表中的常見的方法
　　l1 =['kobe','james','t-mac','123',789,[123,'admin']]

　　索引
  　　  print(l1[1])
  　　  print(ret1,type(ret1))
   　　 print(l1[-1])

　　切片  顧頭不顧腚
  　　  print(l1[:4])
   　　 print(l1[:5:2])

　　倒敘取值
  　　  print(l1[-1:-4:-1])

　　增長
   　　 l1.append('123')  #追加增長
    　　l1.insert(1,'123')  #在索引爲1的位置插入
    　　l1.extend([123,'ab']) #迭代的而加入是：根據要添加的類型進行一次迭代以後，在添加到列表中。若是添加的時字符串，就分割以後，添加到列表。
　　　　　　　　　　　　　　　　　 #若是添加的是列表，就循環列表，在分別添加到要添加的列表中。和切片修改是同一個意思，說白了迭代增長的必須是可迭代的元素


　　刪除
   　　 l1.pop(0)  #按照索引刪除，會將刪除的元素做爲返回值返回
   　　 l1.remove('kobe')  #按照元素刪除，不會返回被刪數據
   　　 l1.clear()  #清空列表

　　del 刪除
   　　 del l1[0]  #1.按照索引刪除，默認刪除最後一個
    　　del l1[2:5:2] #按照切片(能夠加步長)刪除
   　　 del l1[:]   或者del l1#刪除整個列表

　　改   
  　　  l1[0] = "男神"  #按索引修改,l1[0]指的時位置，修改l1[0]這個位置的元素的值爲男神，本意指的li[0]這個元素，可是放在等號左邊就是表明位置，要接受新值
   　　 l1[:3] = [123,"1234565"]或者l1[:3] ="123456" #按切片範圍修改，要添加的內容必須是可迭代元素，和迭代增長同樣
    　　l1[1:4:2] = "12" #切片(加步長)：必須一一對應，改了幾個就得寫幾個修改的值，不能多或少

　　查
   　　 按照索引(index)，按照切片（步長查詢），列表沒有find方法
    　　使用for循環

　　其餘操做
   　　 len()：去長度 index():經過元素找索引，找到第一個就返回，找不到就報錯
  　　  l1.sort() 從小到大排序#不會生成新的字符串 l1.sort(reverse=True) #從大到小
   　　 l1.reverse()翻轉  #不會生成新的字符串
   other：
　　　　pop()：執行後惟一有返回值的

2.元組app

python中基礎數據類型之一，容器型數據類型，存儲大量的數據。只讀列表。
元組是()裏面的元素以,隔開的數據類型。
其餘語言中，沒有元組的概念。元組是不能夠進行修改的，只能查詢。元組中存儲的都是重要的數據，我的信息等等。 
元組練習
　　tu1 = (1,'kobe','123',[1,2,'mac',True])
　　print(tu1[0])    #能夠索引
　　print(tu1[:3])   #能夠切片
　　print(tu1[:4:2]) #能夠根據步長切片

查：注意：元組只能查不能改， #根據索引和切片等進行查詢或者#根據for循環
　　for item in tu1:
    　　print(item)

other
    del tul  print(tu1)  #刪除元組
    print(len(tu1))  #查看元組長度
    print(tu1.count("123")) #查看包含字符個數
    print(tu1.index("kobe") #和列表，字符串中使用同樣，查找元素的索引
 元組真的不能修改麼？
    tul = ('123', True, 456, [123, 'jordan', '中文'])
    tul[3].append('123')
    print(tul)
    #:在元組中的元素的是可迭代對象的話，就能夠改：兒子不能改，孫子可能改。

有意思的一個問題：
　　tu = (123,1,'123',True)
　　print(tu.index(True))  
　　#這個索引不該該是3麼？ 由於True和false在內存中存儲的是1和0，因此tu.index(True) =tu.index(1),打印這個至關於打印print(tu.index(1))的索引，元組中正好有1這個元素，因此打印1這個元素的索引

#坑
　(22) --->int類型，不加，都是元素自己
　(s)  --->字符串類型

3.rangeide

range函數練習
    內置函數，python給你提供的一個功能。
    將range視爲：可控制範圍的數字列表。

#打印1-100
    for item in range(1,101):
        print(item)

#打印1-100奇數
    for item in range(1,100,2):
        print(item)

#打印1-100偶數
    for item in range(2,102,2):
        print(item)

#打印10-1
for item in  range(10,0,-1):
    print(item, '', end='')

注意：
　　1.range()的起始位置默認爲0 
　　2.python2中是一塊兒所有生成，不用迭代出來，直接打印，python3中是先放在內存裏面，等使用了再生成。(這也是python3比python2性能上高的一點)

做業函數

# 使用循環查找一個字符串中指定字符的全部索引值， 保存在一個列表中,找出全部a的索引值
　　s = 'abcabcabc'
　　count = 0
　　l1=[]
　　for item in s:
    　　if item == 'a':
        　　l1.append(s.index('a',count,))  #主要是字符串索引能夠經過起始位置和結束位置來查找
    　　else:
        　　pass
    　　count += 1
　　print (l1)

4.字典性能

爲何要使用元組？
　　1.列表若是存儲的數據較多的話，查詢速度會比較慢
　　2.列表存儲數據的關聯性不強
　　字典的查找是根據鍵值的hash來對應的內存地址進行查找的，比二分法還會快一些

字典介紹:
　　python中惟一的映射類的數據，花括號{}括起來，他是以鍵值對形式存儲，每一對鍵值對以,逗號分開！
　　dic = {'name': 'kobe', 'age': 18, 'sex': 'man'}

字典的特色:
　　1.字典是以鍵值對形式存儲的，
　　　　鍵：不重複的,惟一的，鍵的數據類型必須是不可變的數據類型。(鍵惟一;指的是不管添加多少個相同的鍵，只有最後一個起做用，起到了覆蓋的做用)
　　　　值：任意數據類型，對象。
　　2.字典能夠存儲大量的鍵值對數據，
　　3.python3.6以前：字典是無序的。python3.6以後，字典變成有序的。3.7之後確實從語法層面上變得有序了。(3.6中的有序是解釋器的做用，不是python的源碼特色)

字典的優勢：
    1，字典存儲大量的關係型數據。
    2，字典的查詢速度很是快。
字典的缺點：
　　佔用空間大

　　dic ={
　　　　　　'name':'kobe',
　　　　　　'age':40,
　　　　　　'hobby':'wife'
　　}spa

　　增長操做
　　　　1.有就修改，沒有就添加,根據鍵值,不會報錯
　　　　　　dic['agesdas1']=203d

　　　　2.有就不變，沒有就添加，根據鍵值，不會報錯
　　　　　　dic.setdefault('h') #默認添加None，默認返回鍵h的值，有返回值
　　　　　　dic.setdefault('name','123') code

　　刪除操做
　　　　pop() 刪除，按照鍵刪除
　　　　　　dic.pop('name') #按照鍵值刪除，默認刪除的鍵值不存在的話會報錯
　　　　　　dic.pop('name','沒有此鍵')#第二個參數爲提示語，通常設置成None
　　　　clear() 清空
　　　　　 dic.clear()
　　　　popitem()： 3.6以前版本隨機刪除，可是3.6版本刪除最後一個鍵值對,由於python3.6版本以前，dict類型是無序的，在3.6版本以後變成有序的了
　　　　　　ref = dic.popitem() 有返回值，是被刪除的鍵值對組成的元組
　　　　del刪除
　　　　　　del dic['name'] 按照鍵刪除，若是鍵值不存在會報錯
　　　　　　del dic 刪除字典orm

　　修改操做
　　　　1.dic['age']=73 根據鍵值來修改，沒有鍵值的話就添加
　　　　2.update
　　　　　　a.dic.update(abc="123",bcd="456") #有就覆蓋，沒有鍵值就增長
　　　　　　b.dic.update(dic2) #將一個字典添加到另外一個字典中,dic1裏面有和dic2相同的鍵值，就將dic1中鍵所對應值修改爲dic2中(將dic2中的鍵值對覆蓋追加到dic中)
　　　　　　update裏面的鍵值不能是數字

　　查操做
　　　　print(dic['age']) 若是不存在鍵，則報錯
　　　　print(dic.get('ag')) 若是不存在鍵，返回nono
　　　　print(dic.get('ag',"沒有此鍵")) 可設置返回值

　　　　print（setdefault.('1')）

　　formkeys: 用於建立一個新的字典，並以可迭代對象中的元素分別做爲字典中的鍵，且全部鍵對應同一個值，默認爲None
　　　　iterable=[1,2] value='a'
　　　　v1 = dict.fromkeys(iterable,value)
　　　　　　iterable：用於建立新的字典的鍵的可迭代對象（字符串、列表、元祖、字典）。
　　　　　　value: 可選參數, 字典全部鍵對應同一個值的初始值，默認爲None。
　　　　print(v) {'1': 'a', '2': 'a'}

　　other 其餘三個相似列表的類型,均可以轉化成list,是高仿list，沒有索引
　　　　print(dic.keys(),type(dic.keys()))
　　　　print(dic.values(),type(dic.values()))
　　　　print(dic.items()) #可使用for循環
　　　　for k,y in dic.items():
　　　　　　print(k,y)

　　分別賦值：a =18,b=32,使用一句代碼將其調轉
　　　　a,b=32,18
　　　　　　print(a,b) #a=32,b=18
　　　　a,b={'name':'alex','age':73}
　　　　　　print(a,b) #a=name b=age
　　　　a,b =[123,2345]
　　　　　　print(a,b) #a=123 b=2345

　　　　原理就是將a和b指向的內存地址的標籤調換

5.數據類型的比較

 數據類型的劃分：
    容器非容器劃分：
           容器型數據類型：list，tuple，dict，set。
           非容器型數據類型：int str bool
　　可變與不可變劃分：
           可變（不可哈希hash）的數據類型：list dict，set
           不可變（可哈希hash的）的數據類型： int bool str tuple
                                        
序列類型：

6.字典裏習題

#將a和b組合成c的樣式，並支持擴展
a = [
'a,1',
'b,3,22',
'c,3,4',
'f,5'
]

b=[
'a,2',
'b,4',
'd,2',
'e,12'
]

c = [
'a,1,2',
'b,3,22,4',
'c,3,4',
'd,2',
'e,12',
'f,5'
]

dic ={i[0]:i for i in a}
print(dic)
for ite in b:
    if ite[0] in dic:
    # if dic.get(ite[0]):
        dic[ite[0]] += ite[1:]
    else:
        dic[ite[0]] = ite
print(list(dic.values()))