第 7 課： 列表的基本操作（賦值、刪除和分片賦值)
# 列表的基本操作
# 賦值、刪除列表元素、分片賦值
# 1. 列表元素的賦值
values = ["Bill", "Mary", "John"]
values[0] = "Mike"
values[1] = 10.4
values[-1] = "Joe"
# values[-5] = "abc" # 拋出異常
print(values) # ['Mike', 10.4, 'Joe']
# 刪除列表中的元素
numbers = [1,2,3,4,5,6,7,8]
del numbers[3]
print(len(numbers)) # 7
print(numbers) # [1, 2, 3, 5, 6, 7, 8]
# 分片賦值
names = ["Bill", "Joe", "李寧","馬雲"]
print(names[3:]) # ['馬雲']
names[3:] = ["a","b","c"]
print(len(names)) # 6
print(names) # ['Bill', 'Joe', '李寧', 'a', 'b', 'c']
name = list("John") # 將一個字符串轉化爲一個列表
print(name) #['J', 'o', 'h', 'n']
name[2:] = list("e")
print(name) ## ['J', 'o', 'e']
print(numbers) # [1, 2, 3, 5, 6, 7, 8]
# 刪除 和del 函數差不多 但是del只能刪除一個
numbers[3:6] = []
print(numbers) # [1, 2, 3, 8]
--------------------
列表與元組的加法 乘法
data1 = [1,2,3,4]
data2 = [2,3,4,5,"hello"]
data3 = data1 + data2
print(data3) # [1, 2, 3, 4, 2, 3, 4, 5, 'hello']
num1 = (1,2,3,4)
num2 = (3,4,'ff')
num3 = num1 + num2
print(num3) # (1, 2, 3, 4, 3, 4, 'ff')
如何把一個元組 強制的轉化爲一個列表呢？
num1 = (1,2,3,4)
print(list(num1)) # [1, 2, 3, 4]
如何把一個列表 強制轉化爲一個元組呢？
data1 = [1,2,3,4]
print(tuple(data1)) # (1, 2, 3, 4)
列表與元組的乘法
a1 = [1,2,3,4]
print(a1 * 2) # [1, 2, 3, 4, 1, 2, 3, 4]
b1 = (2,3,4,5)
print(b1 * 3) # (2, 3, 4, 5, 2, 3, 4, 5, 2, 3, 4, 5)
字符串乘法：
print('a' * 10) # aaaaaaaaaa
print('a,' * 10) # a,a,a,a,a,a,a,a,a,a,
data1 = [1,2,3,4]
num2 = (3,4,'ff')
print(data1 + list(num2) * 2) # [1, 2, 3, 4, 3, 4, 'ff', 3, 4, 'ff'] 先做乘法 再做加法
-----------------------------------------------
第8課 列表中的方法 重點啊 ******
# 列表方法
'''
1. append：在列表最後(結尾)插入新的值，改變原來的列表
2. clear：用於清除列表的所有內容
3. copy：用於複製一個列表 //通過分片也是可以複製一個列表的
4. count：用於統計某個元素在列表中出現的次數
5. extend：用於在列表結尾插入另一個列表，也就是讓兩個列表首尾相接。
該方法改變的是被擴展的列表。 list1.extend(list2)//這一步是 把list2接到list1的後面 他改變的是list1的本身
比如list1長度爲3 list2長度爲4 那麼我們調用這個方法後 list1的長度 就變成了7 改變了list1的長度
,而我們之前講過的 列表的相加創建一個新的列表 和extend 這個方法 是本質的區別
6. index：用於從列表中找出某個值第一次出現的索引位置
7. insert：用於將值插入到列表中的指定位置 //這個方法可以取代append 因爲可以在列表中的任意位置插入
8. pop：用於移除彈出列表中的元素（默認是最後一個元素），並返回該元素的值
9. remove：用於移除列表中某個值的第一次匹配項
10. reverse：用於將列表中的元素反向存放 // 把序列中的步長設置成-1的效果是一樣的
11. sort：用於對列表進行排序，調用該方法會改變原來的列表
'''
from sqlalchemy.sql.expression import false
print("--------append方法---------") # append：在列表最後(結尾)插入新的值，改變原來的列表
numbers = [1,2,3,4,5]
numbers.append(20)
print(numbers) #[1, 2, 3, 4, 5, 20]
numbers.append("hello") # 這個值可以爲字符串
numbers.append([1,2,3]) # 也可以爲另外一個列表
print(numbers) #[1, 2, 3, 4, 5, 20, 'hello', [1, 2, 3]]
print("---------clear方法---------") # clear：用於清除列表的所有內容
names = ["Bill", "Mary"]
print(names) #['Bill', 'Mary']
names.clear()
print(names) #[]
print("----------copy方法----------") # copy：用於複製一個列表
a = [1,2,3,4,5]
acopy = a
acopy1 = a[:] #通過分片複製列表 acopy1 和 a 這2個列表的值是完全一樣的 但是是2個不同的序列
acopy2 = a.copy()
a[3] = "hello" #這一步的目的是 要改變 3這個位置上的數
print(acopy) #[1, 2, 3, 'hello', 5]
print(acopy1) #[1, 2, 3, 4, 5]
print(acopy2) #[1, 2, 3, 4, 5]
# 分片的方式或者是copy的方式 就是一個副本
print("----------count方法-----------") # count：用於統計某個元素在列表中出現的次數
search = ["he", "new", "he", [1,2,3],"he", "world", "peter",[1,2,3]]
# 搜素“he”在search出現的次數
print(search.count("he")) # 3
print(search.count([1,2,3])) # 2
print(search.count(20)) # 如果沒有找到指定的列表元素，返回0
print("------extend方法------") # extend：用於在列表結尾插入另一個列表，也就是讓兩個列表首尾相接。
a = [1,2,3]
b = [4,5,6]
a.extend(b)
print(a) # [1, 2, 3, 4, 5, 6] a 這個列表改變了
a[2] =123
print(a) # [1, 2, 123, 4, 5, 6]
a = [1,2,3]
b = [4,5,6]
x = a
a = a + b
x[2] = 543
print(a) # [1, 2, 3, 4, 5, 6]
print(x) # [1, 2, 543]
print("------index方法------") # index：用於從列表中找出某個值第一次出現的索引位置
numbers = [5,3,6,8]
print(numbers.index(6)) # 2 6的位置上2
# print(numbers.index(10)) # 如果指定的值在列表中不存在，會拋出異常
print("-------insert方法-------") # insert：用於將值插入到列表中的指定位置 //這個方法可以取代append 因爲可以在列表中的任意位置插入
numbers = [1,2,3,4,5]
#numbers.insert(3,"four") # [1, 2, 3, 'four', 4, 5]
#print(numbers)
# 使用分片賦值完成同樣的效果
numbers[3:3]="four"
print(numbers) # [1, 2, 3, 'f', 'o', 'u', 'r', 4, 5]
numbers[3:3] = ["four"] # 開始索引和結束索引相等 不代表任何的元數 只是光標到達此位置 把這個位子代表4這個位子
print(numbers) # [1, 2, 3, 'four', 4, 5]
print("-------pop方法-------") # pop：用於移除彈出列表中的元素（默認是最後一個元素），並返回該元素的值
numbers = [1,2,3]
print(numbers.pop()) # 默認不指定的話 就彈出 最後一個元數 3 結果爲3
print(numbers.pop(1)) # 彈出第索引位子爲1的元素 1表示 要彈出位子的索引 結果爲2
print(numbers) # 我們彈出了2次 就剩下一個1 了 結果爲 [1]
print("---------remove方法---------") # remove：用於移除列表中某個值的第一次匹配項
words = ["he", "new", "he","yes"]
words.remove("he")
print(words) # 結果爲 ['new', 'he', 'yes'] 只移除第一個 出現的第一個
print("------reverse方法--------") # reverse：用於將列表中的元素反向存放
numbers = [1,2,3,4,5,6,7]
numbers.reverse() # [7, 6, 5, 4, 3, 2, 1] 倒序 如果執行2次 那麼就又正面返回了
print(numbers)
# 用分片的方法 第一個爲開始索引 結束索引 步長
print(numbers[len(numbers)::-1]) # 結果爲 [7, 6, 5, 4, 3, 2, 1]
print("--------sort方法-------") # sort：用於對列表進行排序，調用該方法會改變原來的列表
numbers = [4,3,1,7,4,83,2,-3]
numbers.sort()
print(numbers) # [-3, 1, 2, 3, 4, 4, 7, 83] 排序 是一種升序的排序 改變了原來的列表
# 要是不想改變原來的列表怎麼辦？
#方法1:使用分片或者copy的方法 將這個列表複製一份 然後在排序
numbers1 = [4,3,1,7,4,83,2,-3]
numbers2 = numbers[:] # 分片複製方法 很簡單
numbers2.sort()
print(numbers1) # [4, 3, 1, 7, 4, 83, 2, -3]
print(numbers2) # [-3, 1, 2, 3, 4, 4, 7, 83]
numbers3 = numbers1.copy() # 用copy的方法 複製
print(numbers3) # [4, 3, 1, 7, 4, 83, 2, -3]
#方法2 我們不使用sort這個函數 因爲他改變了原來的列表 我們使用 sorted函數 這個函數是返回排好序的列表 sorted函數 不改變原來列表的順序
# 可以對任意的序列進行排列 ，可以對字符串進行排列
x = [5,4,7,2]
y = sorted(x)
print(x) # [5, 4, 7, 2]
print(y) # [2, 4, 5, 7]
# 對字符串進行排序
print(sorted("www.baidu.com")) # ['.', '.', 'a', 'b', 'c', 'd', 'i', 'm', 'o', 'u', 'w', 'w', 'w']
# 利用askm值進行排序 從低到高
# 我們可以通過關鍵字 讓他降序排列
x = [4,6,2,8,44,56,22]
x.sort(reverse = True) # 關鍵字 reverse 爲true 爲降序 ；如果 爲flase爲升序 默認爲升序 # reverse：用於將列表中的元素反向存放
print(x) # [56, 44, 22, 8, 6, 4, 2]
x.sort(reverse = False)
print(x) # [2, 4, 6, 8, 22, 44, 56]
課程九 元組 元組屬於序列
元組和列表的操作基本上上一樣的，操作呢基本上是相同的，只有一點不一樣，元組是隻讀的，元組是不可以修改的，列表中的所有修改操作，元組都不支持
# 元組
# 元組的定義是用 () 來定義的
a = () # 這裏就是定義了一個空的元組
b = (1,2,3)
c = 1,2,3,4,5 # 這樣的方式也是定義一個元組 基本上不用這個
print(c) # (1, 2, 3, 4, 5)
x = (30,) # 這裏一定要加 , 要不然就會當成一個值去處理了
print(x) # (30,)
print((12) * 12) # 144 這裏的12沒有加, 就會當成一個值去處理
print((12,) * 12) # (12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12) 這裏就是當成了一個元組去操作的
aa = (1,2,4)
aa = aa.index(2)
print(aa) # 結果爲 1 index：用於從列表中找出某個值第一次出現的索引位置
aa = (1,2,4,2,2)
# aa = aa.index(2)
aa = aa.count(2)
print(aa) # 結果爲3 count：用於統計某個元素在列表中出現的次數
// 元組理論上只支持 index 和 count 方法
// 元組和列表基本相同 爲什麼要用元組呢？有2點原因
'''
1. 元組可以在映射中作爲鍵值使用，而列表是不能作爲鍵值使用 // kv的形似的話，後面講到的字典的話，那麼k（一組數和一組值作爲k的話） 就必須要用 元組的
2. 很多內建函數和方法的返回值就是元組，所以在使用這些函數和方法是必須使用元組
'''
列表和元組的小結：
1、序列包含 列表和元組
2、列表的表達方式爲： names = ["Bill", "Mary", "Jack"]
3、元組的表達方式爲： b = (1,2,3)
4、元組和列表的操作基本上上一樣的，操作呢基本上是相同的，只有一點不一樣，元組是隻讀的，元組是不可以修改的，列表中的所有修改操作，元組都不支持
# 我們以前講過2種序列：1列表 2元組
# 共同點：都是通過索引引用元素值
# 不同點：列表是可讀寫的，元組是隻讀的
names = ["Bill", "Mike", "John", "Mary"]
numbers = ["1234", "4321", "6789", "6543"]
print(numbers[names.index("Mike")]) #4321
print(names[numbers.index("6543")]) # Mary
