列表和元組

昨日回顧

    1. 基本數據類型概述
        int 整數
        str 字符串
        bool 布爾值  True, False
        list 列表 []
        tuple 元組 ()
        dict 字典 存儲key:value
        set 集合 不重複
        bytes 字節
    2. int 整數
        bit_length()  求二進制長度
    3. bool 類型
        類型轉換
        結論一: 把x轉化成y類型. y()
        結論二: 能表示False的數據有: 0, None, "", [], tuple(), set(), {}
    4. str 字符串
        索引: 下標從0開始的數字. 指示的是字符串中的每個字符

        切片: 從源字符串中截取一部份內容做爲新字符串
            s[start: end: step]
            start: 開始
            end: 結束. 取不到
            step: 步長, 默認是1. 每step取一個. 經過符號來控制方向. +從左往右, -從右往左

        一大波操做:
            1. upper() 轉化成大寫
            2. strip() 去掉兩端的空白(空格, \n, \t)
            3. replace(old, new) 把字符串中的old替換成new
            4. split() 字符串切割. 返回列表
            5. startswith() 判斷是否以xxx開頭
            6. find() 查找 若是找不到返回-1
            7. isdigit() 判斷是不是數字組成
            8. len() 字符串長度

        字符串的 遍歷(迭代)
        for c in s:
            print(c)

        迭代:能夠一個一個的往外拿

        for 變量 in 可迭代對象:

 

今日內容

    1. 什麼是列表
        定義: 能裝對象的對象
        在python中使用[]來描述列表, 內部元素用逗號隔開. 對數據類型沒有要求

        列表存在索引和切片. 和字符串是同樣的.

    2. 相關的增刪改查操做(重點)
        添加:(記憶1,2)
            1. append() 追加
            2. insert(位置, 元素) 插入指定元素到指定位置
            #3.extend(可迭代對象) 迭代添加 把傳遞進去的參數進行迭代,把每一項添加到列表的末尾  (這個瞭解)
        刪除:(記憶1,2)
            1. pop(index) 根據索引刪除 刪除並返回索引項
            2. remove(元素)  根據元素刪除 刪除第一次出現的指定元素,若是元素不存在則報錯(,沒有返回值,打印的結果是None)
            #3.del 用切片或者索引刪除 全局刪除 不經常使用(是關鍵字???)
            #4.clear() 清空

        修改:
            索引修改
            lst[索引] = 元素  坑: 若是步長不是1. 元素的個數必需要和切片的個數一致
        查詢:
            for循環.

    3. 列表的嵌套
        多個列表互相嵌套
    4. 列表的其餘操做
        1. count('元素')  計數
        2. sort() 排序,改變原列表  reverse = True
        3. reverse() 翻轉,改變原列表
        4. len() 求長度

    5. 什麼是元組
        能裝對象的對象. 不可變. 一旦確認好. 不可更改
        只讀列表
        能夠迭代

    6. 元組的嵌套
        和列表同樣.均可以互相嵌套.
        元組的不可變: 指向不變

    7. range(重點, 難點)
        數數
        range(n) 數學中的[0, n),前閉後開(前面能取到,後面不能取到)
        range(m,n) [m, n)
        range(m,n,p) [m,n) 每隔p取一個

        # 重點
        for i in range(len(lst)):
            i 是索引
            lst[i] 是元素


    預習:
        字典(新華字典)
        增刪改查
        字典嵌套

        set集合

1. 列表

1.1 列表的介紹

列表是python的基礎數據類型之一 ,其餘編程語言也有相似的數據類型. 好比JS中的組, java中的數組等等. 它是以[ ]括起來, 每一個元素用' , '隔開並且能夠存放各類數據類型:

 lst = [1, '哈哈', "吼吼", [1,8,0,"百度"], ("我","叫", "元", "組"), "abc", {"我 叫":"dict字典"},{"我叫集合","集合"}]

列表相比於字符串. 不只能夠存放不一樣的數據類型. 並且能夠存放⼤量的數據. 32位 python能夠存放: 536870912個元素, 64位能夠存放: 1152921504606846975個元素.並且列表是有序的(按照你保存的順序),有索引, 能夠切片方便取值.

 

1.2 列表的索引和切片

列表和字符串同樣也擁有索引:

lst = ["麻花藤", "王劍林", "馬芸", "周鴻醫", "向華強"] print(lst[0]) # 獲取第一個元素
print(lst[1])
print(lst[2])

lst[3] = "流動強" # 注意. 列表是能夠發生改變的. 這里和字符串不同樣 
print(lst) # ['麻花藤', '王劍林', '馬芸', '流動強', '向華強']

s0 = "向華強"
s0[1] = "美" # TypeError: 'str' object does not support item assignment 不容許改
print(s0)

列表的切片:

 lst = ["麻花藤", "王劍林", "馬芸", "周鴻醫", "向華強"] print(lst[0:3]) # ['麻花藤', '王劍林', '馬芸'] 
print(lst[:3]) # ['麻花藤', '王劍林', '馬芸']

print(lst[1::2])  # ['王劍林', '周鴻醫'] 也有步長
print(lst[2::-1])  # ['⻢馬芸', '王劍林', '麻花藤'] 也能夠倒着取
print(lst[-1:-3:-2])  # 倒着帶步長

2. 列表的增刪改查

# 列表
lst = ["光頭強", 1, True, {}, (1, ), {123}, ["周杰倫",[], "周杰", "結論"]]
print(lst)

# 索引和切片
lst = ["天龍八部", "西遊記", "紅樓夢", "銀平煤", "綠平煤"]

print(lst[3])
print(lst[-3])
print(lst)
print(lst[1:4]) # 切片，原來是什麼類型. 獲得的就是什麼類型
print(lst[-1::-2]) # 倒着切


lst = ["凡人修仙傳", "誅仙", "神墓"]
# 添加 append() 追加. 在後面添加
lst.append("看見")
lst.append("追風箏的人")

# 插入 insert(位置, 元素), 效率相對比較低
lst.insert(1, "琴帝")

# 迭代添加, 把傳遞進去的參數進行迭代. 把每一項添加到列表的末尾
lst.extend(["胡辣湯","豬蹄子", "豬頭肉", "五花肉"])

print(lst)


# # 刪除
lst = ["鬥破蒼求", "手機", "爵跡", "滿城盡帶黃金甲", "三生三世十里桃花"]

# pop() 默認從後往前刪
lst.pop()
# pop(索引) 按照索引位置刪除
lst.pop(1)

# remove(元素)  移除
print(lst.remove("滿城盡帶黃金甲")) # 當元素不存在的時候會報錯,沒有返回值(結果是None)

# del lst[::2] # 用切片或者索引刪除 不經常使用
lst.clear() # 清空.

print(lst)

# 修改
lst = ["蘇秦", "武大", "武二", "寶元", "李誕", "池子", "王建國"]
lst[3] = "松江" # 經過索引修改  index out of range 索引下標越界
print(lst)
lst[1:3] = ["麻花藤"] # 迭代更新(不經常使用)
print(lst)
lst[1:5:2] = ["麻花藤", "碼雲"]  # 坑: 若是步長不是1. 元素的個數必需要和切片的個數一致
print(lst)

lst = ["alex", "wusir", "胡辣湯"]
# 把列表中的wusir替換成大寫 WUSIR
# 首先你要獲取到2元素
# 變成大寫
# 塞回去(必需要放回去)
lst[1] = lst[1].replace("wusir", "WUSIR")
print(lst)

# 查詢, 列表是一個可迭代對象
lst = ["jay", "wlh", "lzw", "wf"]
for item in lst: # item是lst中的每一項
    print(item)

for i in 123:  # 'int' object is not iterable
    print(i)

View Code

 

1. 增

注意, list和str是不同的. lst能夠發生改變. 因此直接就在原來的對象上進⾏了操做

# 末尾添加  append
lst = ["麻花藤", "林俊傑", "周潤發", "周芷若"] 
print(lst)
lst.append("wusir")
print(lst)

lst = []
while True:
    content = input("請輸入你要錄⼊的員工信息, 輸入Q退出:") 
    if content.upper() == 'Q':
        break
    lst.append(content)
print(lst)

# 插入  insert
lst = ["麻花藤", "張德忠", "孔德福"]
lst.insert(1, "劉德華") # 在1的位置插入劉德華. 原來的元素向後移動一位 
print(lst)

# 迭代添加  extend
lst = ["王志文", "張一山", "苦海無涯"] 
lst.extend(["麻花藤", "麻花不疼"]) 
print(lst)        

 

2. 刪除

pop, remove, clear, del

lst = ["麻花藤", "王劍林", "李嘉誠", "王富貴"] 
print(lst)

deleted = lst.pop() # 刪除最後一個 
print("被刪除的", deleted)
print(lst)

# 按照索引位置刪除,pop原意是彈出
el = lst.pop(2) # 刪除2號元素 
print(el)
print(lst)

lst.remove("麻花藤") # 刪除指定元素
print(lst)
# lst.remove("哈哈") # 刪除不存在的元素會報錯 
# # print(lst)

lst.clear()  # 清空list
print(lst)

# 切⽚刪除 
del lst[1:3] 
print(lst)

 

3. 修改

索引切片修改

 # 修改
lst = ["太白", "太黑", "五色", "銀王", "日天"] 
lst[1] = "太污" # 把1號元素修改爲太污 
print(lst)

lst[1:4:3] = ["麻花藤", "哇靠"] # 切片修改也OK. 若是步⻓長不是1, 要注意. 元素的個數
print(lst)

lst[1:4] = ["李嘉誠個龜兒子"] # 若是切片沒有步長或者步⻓是1. 則不用關心個數 
print(lst)

 

4. 查詢

列表是一個可迭代對象,因此能夠進行for循環

 for el in lst:
    print(el)

 

5. 其餘操做

lst = ["太白", "太白", "太黑", "日天", "女神", "alex", "太白"]
print(lst.count("太白")) # 查看xxx元素出現的次數


lst = [1, 8,12,22,1,1,2,33,4,5]
lst.sort() # 排序. 默認升序
lst.sort(reverse=True) # reverse 反向, 降序
print(lst)

lst = ["赤木", "櫻木花道", "流川楓", "三井"]
lst.reverse() # 把列表翻轉
print(lst)  # ['三井', '流川楓', '櫻木花道', '赤木']

lst= [1,2,3,4,5,"胡辣湯"]
print(len(lst)) # 查看列表中元素的個數

list # 按住ctrl +鼠標左鍵查看源碼

View Code

 

lst = ["太白", "太黑", "五色", "銀王", "日天", "太白"] 
c = lst.count("太白") # 查詢太白出現的次數 
print(c)

lst = [1, 11, 22, 2]
lst.sort() # 排序. 默認升序  直接改變到原列表
print(lst)
lst.sort(reverse=True) # 降序   reserve是翻轉,反向的意思
print(lst)

lst = ["太白", "太黑", "五色", "銀王", "日天", "太白"] 
print(lst)
lst.reverse()  # 把列表的元素翻轉
print(lst)

l = len(lst) # 列表的長度,即列表中元素的個數 
print(l) 

3. 列表的嵌套

lst = [["張藝謀", "馮小剛", "陳凱歌"], ["李安", "王家衛", "王晶"], ["周杰倫",["abc", "alex_wusir", ["胡辣湯", "c"]], "風扇哥"]]
print(lst[1][1][2])

# 把王晶換成"賈樟柯"
lst[1][2] = "賈樟柯"
print(lst)

# $$$$$$$
# 降維操做 ["哈哈", "hehe", "houhou"] 一維  [[1,2,3], [12,4,5], [6,7,8]] 二維
# 數數
lst[2][1][1] = lst[2][1][1].replace("_", "$")
print(lst)

View Code

 

採⽤降維操做.一層一層的看就好.

lst = [1, "太白", "wusir", ["馬⻁疼", ["可口可樂"], "王劍林"]] 

# 找到wusir
print(lst[2])

# 找到太白和wusir
print(lst[1:3]) 

# 找到太白的白字
print(lst[1][1])

# 將wusir拿到. 而後⾸字母大寫. 再扔回去 
s = lst[2]
s = s.capitalize()
lst[2] = s
print(lst)
# 簡寫
lst[2] = lst[2].capitalize() # 注意:必定要再扔回去
print(lst)  

# 把太白換成太⿊
lst[1] = lst[1].replace("白", "黑") 
print(lst)

# 把馬虎疼換成馬化疼
lst[3][0] = lst[3][0].replace("虎", "化")
print(lst[3][0])

lst[3][1].append("雪碧") 
print(lst)

4. 元組和元組嵌套

# 元組用()表示, 只讀列表. 馮提莫
tu = ("DNF", "LOL", "王者榮耀", "QQ飛車", "炫舞", {}, tuple(), [])
print(tu)
# tu[1] = "呵呵" # 報錯'tuple' object does not support item assignment
print(tu)

# 元組也有索引和切片
print(tu[3:5])
print(tu[3:7:2])

# 元組有坑
# 空元組
tu = tuple() # 固定寫法
# 元組中若是隻有一個元素(括號不是元組的標誌,逗號纔是,有逗號就是元組)
tu = (1) # 不是元組   <class 'int'>
tu = (1, ) # 這個是元組 <class 'tuple'>
print(type(tu))

# 好習慣: 寫元組的時候末尾加個逗號

tu = ("鍋包肉", "酸菜燉粉條+五花肉", "紅燒鯉魚", "紅燒肉")
# 元組也是可迭代的
for item in tu: # 可使用for循環
    print(item)


tu = (1, "哈哈", "胡辣湯", ["忍者", "神龜"])
# tu[1] = "呵呵" # 元組不可變
tu[3] = ["我是新列表"] # 改變了指向. 報錯
tu[3].append("孫悟空") # 元組沒改. 改的是元素內部 沒有改變元組的指向. 不報錯
print(tu)

tu = tuple()#空元組 的固定寫法
tu = (1)# 不是元組,是 int,這裏的()當成數學上的小括號,相似於(1+1)
tu = (1,)# 只有一個元素的時候,末尾必須加個逗號 此時纔是元組
#好習慣: 寫元組的時候末尾加個逗號

#可迭代  for
#元祖的的不可變,是內部元素的指向不可變.  是元組對內部元素的指向不變,可是內部的可變元素的內部是可變的

View Code

 

元組: 俗稱不可變的列表.又被稱爲只讀列表, 元組也是python的基本數據類型之一, 用小括號括起來, ⾥面能夠聽任何數據類型的數據, 查詢能夠. 循環也能夠. 切片也能夠. 但就是不能改.

tu = (1, "太白", "李白", "太黑", "怎麼黑")
print(tu)

print(tu[0])
print(tu[2])
print(tu[2:5]) # 切片以後仍是元組

# for循環遍歷元組 
for el in tu: 
    print(el)
# 嘗試修改元組
# tu[1] = "⻢虎疼" # 報錯 'tuple' object does not support item assignment

tu = (1, "哈哈", [], "呵呵")
# tu[2] = ["fdsaf"] # 這麼改不行

tu[2].append("麻花藤") # 能夠改了. 沒報錯 tu[2].append("王劍林")
print(tu)
 

關於不可變, 注意:

這裏元組不可變的意思是子元素不可變,而子元素內部的子元素是能夠改變的,這取決於子元素是不是可變對象.

關於元組的書寫,注意:

元組中若是隻有一個元素. 必定要添加一個逗號, 不然就不是元組.元組的標誌是逗號,而不是小括號

 

# type(對象) 是查看對象的數據類型

tu = (1)
print(type(tu))  # <class 'int'>

tu = (1,)
print(type(tu))  # <class 'tuple'>

tu = 1,
print(type(tu))  # <class 'tuple'>

元組也有count(), index(), len()等方法. 能夠⾃本身測試使⽤

5. range

i = 1
while i <=100:
    print(i)
    i += 1

 # range(參數)  [0,參數)
for i in range(20): #  range()能夠被迭代 0-9
    print(i)

# range(參數1, 參數2)  [參數1, 參數2) 切片
for i in range(10, 20):
    print(i)

# range(參數1, 參數2, 參數3)  [參數1, 參數2) 每隔參數3個位置取一個
for i in range(10, 20, 3):
    print(i)

lst = ["周杰倫", "動畫城", "大風車", "隨便加", "寶寶", "孟孟", "萌萌", "孟萌"]

for item in lst: # 只能拿到元素. 獲取不到索引
    print(item)

for i in range(len(lst)): # i就是索引 lst[i]元素
    print(i, lst[i])

View Code

 

range能夠幫咱們獲取到一組數據. 經過for循環可以獲取到這些數據.

# range(start,end,step)前閉後開,相似於切片
# 只有一個參數的話,默認是做爲end,從0開始的,步長爲1

for num in range(10):
    print(num)

for num in range(1, 10, 2):
    print(num)

for num in range(10, 1, -2):  # 反着來,和切片同樣
    print(num)

 

 

 

今日做業

今日做業