分類彙整: python_note

[Python] [Dict] 學習筆記

dict (字典)

最常用的內置數據結構之一，用於存儲鍵值對（key-value pairs）
字典是可變的、無序的（Python 3.7+ 後插入順序被保留），並且鍵必須是唯一的且不可變的（如字串、數字、元組等）

特性:

鍵必須是唯一的：如果重複鍵，後面的值會覆蓋前面的值
鍵必須是不可變的：鍵可以是字串、數字、元組等不可變類型，但不能是列表或字典等可變類型
值可以是任意類型：值可以是字串、數字、列表、字典等
無序性（Python 3.6 之前）：在 Python 3.6 之前，字典是無序的。從 Python 3.7 開始，字典會保留插入順序

建立 dict

# 使用花括號 {}
my_dict = {'name': 'Alice', 'age': 25}

# 使用 dict() 函數
my_dict = dict(name='Alice', age=25)

# 從鍵值對列表創建
my_dict = dict([('name', 'Alice'), ('age', 25)])

# 使用字典推導式
my_dict = {x: x**2 for x in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 使用花括號 {}

my_dict = {'name': 'Alice', 'age': 25}

# 使用 dict() 函數

my_dict = dict(name='Alice', age=25)

# 從鍵值對列表創建

my_dict = dict([('name', 'Alice'), ('age', 25)])

# 使用字典推導式

my_dict = {x: x**2 for x in range(5)}

# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

常用方法 (python 3.11)

keys()
返回字典中所有鍵的視圖

my_dict = {'name': 'Alice', 'age': 25}
keys = my_dict.keys()
print(keys) # dict_keys(['name', 'age'])

my_dict = {'name': 'Alice', 'age': 25}

keys = my_dict.keys()

print(keys) # dict_keys(['name', 'age'])

values()
返回字典中所有值的視圖

my_dict = {'name': 'Alice', 'age': 25}
values = my_dict.values()
print(values) # dict_values(['Alice', 25])

my_dict = {'name': 'Alice', 'age': 25}

values = my_dict.values()

print(values) # dict_values(['Alice', 25])

items()
返回字典中所有鍵值對的視圖

my_dict = {'name': 'Alice', 'age': 25}
items = my_dict.items()
print(items) # dict_items([('name', 'Alice'), ('age', 25)])

my_dict = {'name': 'Alice', 'age': 25}

items = my_dict.items()

print(items) # dict_items([('name', 'Alice'), ('age', 25)])

get(key[, default])
如果 key 存在於字典中則傳回 key 的值，否則傳回 default
如果 default 未給出則預設為 None，因而此方法絕不會引發 KeyError

my_dict = {'name': 'Alice', 'age': 25}
print(my_dict.get('name'))                 # Alice
print(my_dict.get('address', 'Not Found')) # Not Found

my_dict = {'name': 'Alice', 'age': 25}

print(my_dict.get('name')) # Alice

print(my_dict.get('address', 'Not Found')) # Not Found

update([other])
將另一個字典或鍵值對更新到當前字典中。如果鍵已存在，則覆蓋其值

my_dict = {'name': 'Alice', 'age': 25}
my_dict.update({'age': 26, 'address': 'Taipei'})
print(my_dict) # {'name': 'Alice', 'age': 26, 'address': 'Taipei'}

my_dict = {'name': 'Alice', 'age': 25}

my_dict.update({'age': 26, 'address': 'Taipei'})

print(my_dict) # {'name': 'Alice', 'age': 26, 'address': 'Taipei'}

pop(key[, default])
刪除並返回指定鍵對應的值。如果鍵不存在且未提供默認值，則拋出 KeyError

my_dict = {'name': 'Alice', 'age': 25}
age = my_dict.pop('age')
print(age) # 25
print(my_dict) # {'name': 'Alice'}

my_dict = {'name': 'Alice', 'age': 25}

age = my_dict.pop('age')

print(age) # 25

print(my_dict) # {'name': 'Alice'}

popitem()
刪除並返回字典中最後插入的鍵值對（Python 3.7+ 後字典保留插入順序）。如果字典為空，則拋出 KeyError

my_dict = {'name': 'Alice', 'age': 25}
key, value = my_dict.popitem()
print(key, value) # age 25
print(my_dict) # {'name': 'Alice'}

my_dict = {'name': 'Alice', 'age': 25}

key, value = my_dict.popitem()

print(key, value) # age 25

print(my_dict) # {'name': 'Alice'}

clear()
清空字典中的所有鍵值對

my_dict = {'name': 'Alice', 'age': 25}
my_dict.clear()
print(my_dict) # {}

my_dict = {'name': 'Alice', 'age': 25}

my_dict.clear()

print(my_dict) # {}

copy()
返回字典的淺拷貝

my_dict = {'name': 'Alice', 'age': 25}
new_dict = my_dict.copy()
print(new_dict) # {'name': 'Alice', 'age': 25}

my_dict = {'name': 'Alice', 'age': 25}

new_dict = my_dict.copy()

print(new_dict) # {'name': 'Alice', 'age': 25}

setdefault(key[, default])
如果鍵存在，則返回其值；如果鍵不存在，則插入鍵並設置默認值

my_dict = {'name': 'Alice', 'age': 25}
age = my_dict.setdefault('age', 30) # 鍵已存在，返回當前值
print(age) # 25

address = my_dict.setdefault('address', 'Taipei') # 鍵不存在，插入並返回默認值
print(address) # Taipei
print(my_dict) # {'name': 'Alice', 'age': 25, 'address': 'Taipei'}

my_dict = {'name': 'Alice', 'age': 25}

age = my_dict.setdefault('age', 30) # 鍵已存在，返回當前值

print(age) # 25

address = my_dict.setdefault('address', 'Taipei') # 鍵不存在，插入並返回默認值

print(address) # Taipei

print(my_dict) # {'name': 'Alice', 'age': 25, 'address': 'Taipei'}

fromkeys(iterable[, value])
從可迭代對象創建一個新字典，並將所有鍵的值設置為指定的默認值

keys = ['name', 'age', 'address']
my_dict = dict.fromkeys(keys, 'Unknown')
print(my_dict) # {'name': 'Unknown', 'age': 'Unknown', 'address': 'Unknown'}

keys = ['name', 'age', 'address']

my_dict = dict.fromkeys(keys, 'Unknown')

print(my_dict) # {'name': 'Unknown', 'age': 'Unknown', 'address': 'Unknown'}

常用操作:

len(dict)
返回字典中鍵值對的數量

my_dict = {'name': 'Alice', 'age': 25}
print(len(my_dict)) # 2

1 2	my_dict = {'name': 'Alice', 'age': 25} print(len(my_dict)) # 2

in 操作符
檢查鍵是否存在於字典中

my_dict = {'name': 'Alice', 'age': 25}
print('name' in my_dict) # True
print('address' in my_dict) # False

my_dict = {'name': 'Alice', 'age': 25}

print('name' in my_dict) # True

print('address' in my_dict) # False

遍歷
遍歷鍵/值/鍵值對

# 遍歷鍵
for key in my_dict:
    print(key)

for key in my_dict.keys():
    print(key)

# 遍歷值
for value in my_dict.values():
    print(value)

# 遍歷鍵值
for key, value in my_dict.items():
    print(key, value)

# 遍歷鍵

for key in my_dict:

print(key)

for key in my_dict.keys():

print(key)

# 遍歷值

for value in my_dict.values():

print(value)

# 遍歷鍵值

for key, value in my_dict.items():

print(key, value)

[Python] [Set] 學習筆記

發佈留言

集合 (Set):

set 是一種內建的資料結構，用於儲存唯一且無序的元素集合

特點：

唯一性：set 中的元素不會重複，即使你嘗試加入重複的元素，set 也會自動忽略
無序性：set 中的元素沒有固定的順序，因此不能通過索引來訪問元素
可變性：set 是可變的，可以動態地添加或刪除元素
支援集合運算：set 支援交集、聯集、差集等數學集合運算

建立 set

# 注意：如果使用 {} 而不放入任何元素，Python 會將其視為空字典，而不是空 set
# 要創建空 set，必須使用 set()
empty_set = set()

my_set = {1, 2, 3}

# 注意：如果使用 {} 而不放入任何元素，Python 會將其視為空字典，而不是空 set

# 要創建空 set，必須使用 set()

empty_set = set()

my_set = {1, 2, 3}

set 相關方法:

add(element)
將單個元素添加到 set 中
如果元素已經存在，則不會有任何變化

my_set = {1, 2, 3}
my_set.add(4)

print(my_set)  # {1, 2, 3, 4}

my_set = {1, 2, 3}

my_set.add(4)

print(my_set) # {1, 2, 3, 4}

update(iterable)
將一個可迭代對象（如列表、元組、集合等）中的所有元素添加到 set 中
如果元素已經存在，則會被忽略
S |= T

my_set = {1, 2, 3}
my_set.update([3, 4, 5])
print(my_set) # {1, 2, 3, 4, 5}

my_set = {1, 2, 3}

my_set.update([3, 4, 5])

print(my_set) # {1, 2, 3, 4, 5}

remove(element)
刪除 set 中的指定元素
如果元素不存在，會拋出 KeyError 錯誤

my_set = {1, 2, 3}
my_set.remove(2)
print(my_set) # {1, 3}

my_set = {1, 2, 3}

my_set.remove(2)

print(my_set) # {1, 3}

discard(element)
刪除 set 中的指定元素
如果元素不存在，不會拋出錯誤

my_set = {1, 2, 3}
my_set.discard(2)
print(my_set) # {1, 3}

my_set = {1, 2, 3}

my_set.discard(2)

print(my_set) # {1, 3}

pop()
隨機刪除並返回 set 中的一個元素
如果 set 為空，會拋出 KeyError 錯誤

my_set = {1, 2, 3}
element = my_set.pop()
print(element) # 可能輸出: 1, 2 或 3

my_set = {1, 2, 3}

element = my_set.pop()

print(element) # 可能輸出: 1, 2 或 3

clear()
清空 set 中的所有元素

my_set = {1, 2, 3}
my_set.clear()
print(my_set) # set()

my_set = {1, 2, 3}

my_set.clear()

print(my_set) # set()

union(*others)
返回當前 set 與其他集合的聯集
等同於使用 | 運算符
S | T

set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)
print(union_set) # {1, 2, 3, 4, 5}

set1 = {1, 2, 3}

set2 = {3, 4, 5}

union_set = set1.union(set2)

print(union_set) # {1, 2, 3, 4, 5}

intersection(*others)
返回當前 set 與其他集合的交集
等同於使用 & 運算符

set1 = {1, 2, 3}
set2 = {3, 4, 5}
intersection_set = set1.intersection(set2)
print(intersection_set) # {3}

set1 = {1, 2, 3}

set2 = {3, 4, 5}

intersection_set = set1.intersection(set2)

print(intersection_set) # {3}

difference(*others)
返回當前 set 與其他集合的差集
等同於使用 – 運算符

set1 = {1, 2, 3}
set2 = {3, 4, 5}
difference_set = set1.difference(set2)
print(difference_set) # {1, 2}

set1 = {1, 2, 3}

set2 = {3, 4, 5}

difference_set = set1.difference(set2)

print(difference_set) # {1, 2}

symmetric_difference(other)
返回當前 set 與另一個集合的對稱差集（即兩個集合中獨有的元素）
等同於使用 ^ 運算符

set1 = {1, 2, 3}
set2 = {3, 4, 5}
symmetric_difference_set = set1.symmetric_difference(set2)
print(symmetric_difference_set) # {1, 2, 4, 5}

set1 = {1, 2, 3}

set2 = {3, 4, 5}

symmetric_difference_set = set1.symmetric_difference(set2)

print(symmetric_difference_set) # {1, 2, 4, 5}

intersection_update(*others)
更新當前 set，只保留與其他集合的交集

set1 = {1, 2, 3}
set2 = {3, 4, 5}
set1.intersection_update(set2)
print(set1) # {3}

set1 = {1, 2, 3}

set2 = {3, 4, 5}

set1.intersection_update(set2)

print(set1) # {3}

difference_update(*others)
更新當前 set，移除與其他集合共有的元素

set1 = {1, 2, 3}
set2 = {3, 4, 5}
set1.difference_update(set2)
print(set1) # {1, 2}

set1 = {1, 2, 3}

set2 = {3, 4, 5}

set1.difference_update(set2)

print(set1) # {1, 2}

symmetric_difference_update(other)
更新當前 set，只保留與另一個集合的對稱差集
S ^= T

set1 = {1, 2, 3}
set2 = {3, 4, 5}
set1.symmetric_difference_update(set2)
print(set1) # {1, 2, 4, 5}

set1 = {1, 2, 3}

set2 = {3, 4, 5}

set1.symmetric_difference_update(set2)

print(set1) # {1, 2, 4, 5}

issubset(other)
檢查當前 set 是否是另一個集合的子集
等同於使用 <= 運算符

set1 = {1, 2}
set2 = {1, 2, 3}
print(set1.issubset(set2)) # True

set1 = {1, 2}

set2 = {1, 2, 3}

print(set1.issubset(set2)) # True

issuperset(other)
檢查當前 set 是否是另一個集合的超集
等同於使用 >= 運算符

set1 = {1, 2, 3}
set2 = {1, 2}
print(set1.issuperset(set2)) # True

set1 = {1, 2, 3}

set2 = {1, 2}

print(set1.issuperset(set2)) # True

isdisjoint(other)
檢查當前 set 與另一個集合是否沒有共同元素

set1 = {1, 2}
set2 = {3, 4}
print(set1.isdisjoint(set2)) # True

set1 = {1, 2}

set2 = {3, 4}

print(set1.isdisjoint(set2)) # True

set 相關操作:

len()
返回集合中的元素個數

my_set = {1, 2, 3}
print(len(my_set)) # 3

1 2	my_set = {1, 2, 3} print(len(my_set)) # 3

in 運算符
檢查元素是否存在於集合中

my_set = {1, 2, 3}
print(2 in my_set) # True
print(4 in my_set) # False

my_set = {1, 2, 3}

print(2 in my_set) # True

print(4 in my_set) # False

sorted()
返回一個排序後的列表（set 本身無序）

my_set = {3, 1, 2}
sorted_list = sorted(my_set)
print(sorted_list) # [1, 2, 3]

my_set = {3, 1, 2}

sorted_list = sorted(my_set)

print(sorted_list) # [1, 2, 3]

min()、max() 和 sum()
min(): 返回集合中的最小值
max(): 返回集合中的最大值
sum(): 返回集合中所有元素的總和

my_set = {1, 2, 3}
print(min(my_set)) # 1
print(max(my_set)) # 3
print(sum(my_set)) # 6

my_set = {1, 2, 3}

print(min(my_set)) # 1

print(max(my_set)) # 3

print(sum(my_set)) # 6

frozenset
創建一個不可變的集合，可以作為字典的鍵或集合的元素

my_frozenset = frozenset([1, 2, 3])
my_dict = {my_frozenset: "value"}
print(my_dict) # {frozenset({1, 2, 3}): 'value'}

my_frozenset = frozenset([1, 2, 3])

my_dict = {my_frozenset: "value"}

print(my_dict) # {frozenset({1, 2, 3}): 'value'}

[Python] [tuple] 學習筆記

發佈留言

元組(tuple):

Python 中的一種內置資料結構，用於儲存有序且不可變（immutable）的元素集合
與 list 不同，tuple 一旦創建後，其內容無法修改（例如添加、刪除或更改元素）
正因為其不可變性，tuple 通常用於儲存不應被修改的數據，例如固定配置、常量值或作為字典的鍵

特性:

有序性：tuple 中的元素按順序儲存，可以通過索引訪問
不可變性：tuple 創建後無法修改其內容
可嵌套：tuple 可以包含其他 tuple 或其他資料結構（如 list）
可哈希（Hashable）：由於不可變性，tuple 可以作為字典的鍵或集合的元素

tuple v.s. list:
tuple通常可以用來取代串列，但tuple的功能較少，沒有append()、insert()等等
為何不使用串列來取代所有的tuple?

tuple 不可變，list 可變
tuple佔用的空間較少
不會不小心破壞tuple的項目(因為不可變)
可以將tuple當成字典鍵
可以將具名tuple當成物件的簡化替代品
函式引數是以tuple的形式傳入的

創建 tuple

# 用逗號區格
my_tuple_1 = (1, 2, 3)
my_tuple_2 = 1, 2, 3

# 創建空tuple
my_tuple_3 = tuple()
my_tuple_4 = ()

# 用逗號區格

my_tuple_1 = (1, 2, 3)

my_tuple_2 = 1, 2, 3

# 創建空tuple

my_tuple_3 = tuple()

my_tuple_4 = ()

tuple 方法:
count()、index()

# count(x)
# 返回 tuple 中值為 x 的元素個數
my_tuple = (1, 2, 2, 3, 2)
print(my_tuple.count(2))  # 3

# index(x[, start[, end]])
# 返回第一個值為 x 的元素的索引，可選參數 start 和 end 用於指定搜索範圍
my_tuple = (1, 2, 3, 2, 4)
print(my_tuple.index(2))     # 輸出: 1
print(my_tuple.index(2, 2))  # 從索引 2 開始搜索，輸出: 3

# count(x)

# 返回 tuple 中值為 x 的元素個數

my_tuple = (1, 2, 2, 3, 2)

print(my_tuple.count(2)) # 3

# index(x[, start[, end]])

# 返回第一個值為 x 的元素的索引，可選參數 start 和 end 用於指定搜索範圍

my_tuple = (1, 2, 3, 2, 4)

print(my_tuple.index(2)) # 輸出: 1

print(my_tuple.index(2, 2)) # 從索引 2 開始搜索，輸出: 3

tuple 常用操作:

# 索引與切片
my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[0])   # 1
print(my_tuple[1:4]) # (2, 3, 4)

# 合併 Tuple
# + 運算符可以合併兩個 tuple
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
combined = tuple1 + tuple2
print(combined)  # (1, 2, 3, 4, 5, 6)

# 重複 Tuple
# * 運算符可以重複 tuple
my_tuple = (1, 2)
repeated = my_tuple * 3
print(repeated)  # (1, 2, 1, 2, 1, 2)

# 使用 in 運算符檢查元素是否存在於 tuple 中
my_tuple = (1, 2, 3)
print(2 in my_tuple)  # True
print(4 in my_tuple)  # False

# Unpacking
# 將 tuple 中的元素解包到變數中
my_tuple = (1, 2, 3)
a, b, c = my_tuple
print(a, b, c)  # 1 2 3

# tuple 可以包含其他 tuple 或其他資料結構
nested_tuple = (1, (2, 3), [4, 5])
print(nested_tuple[1])  # (2, 3)

# 索引與切片

my_tuple = (1, 2, 3, 4, 5)

print(my_tuple[0]) # 1

print(my_tuple[1:4]) # (2, 3, 4)

# 合併 Tuple

# + 運算符可以合併兩個 tuple

tuple1 = (1, 2, 3)

tuple2 = (4, 5, 6)

combined = tuple1 + tuple2

print(combined) # (1, 2, 3, 4, 5, 6)

# 重複 Tuple

# * 運算符可以重複 tuple

my_tuple = (1, 2)

repeated = my_tuple * 3

print(repeated) # (1, 2, 1, 2, 1, 2)

# 使用 in 運算符檢查元素是否存在於 tuple 中

my_tuple = (1, 2, 3)

print(2 in my_tuple) # True

print(4 in my_tuple) # False

# Unpacking

# 將 tuple 中的元素解包到變數中

my_tuple = (1, 2, 3)

a, b, c = my_tuple

print(a, b, c) # 1 2 3

# tuple 可以包含其他 tuple 或其他資料結構

nested_tuple = (1, (2, 3), [4, 5])

print(nested_tuple[1]) # (2, 3)

具名元組 (namedtuple)
namedtuple 是 Python 中 collections 模組提供的一個工廠函數，用於創建具有命名字段的輕量級元組子類，它結合了元組的不可變性和字典的可讀性，適合用來儲存簡單的資料結構

特點:

不可變性：創建後，namedtuple 的字段無法修改
命名字段：可以通過字段名稱來存取資料，提升程式碼的可讀性
記憶體高效：與普通類別相比，namedtuple 佔用的記憶體更少

namedtuple 適合用來儲存簡單的不可變資料，兼具元組的高效性和字典的可讀性，常用於替代簡單的類別或字典，如果你需要一個輕量且不可變的資料結構，namedtuple 是一個很好的選擇

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)

# 可以通過字段名稱或索引來存取資料
print(p.x)   # 10
print(p[1])  # 20

# 嘗試修改字段會引發 AttributeError
p.x = 30  # AttributeError


# 其他方法
# _asdict()：將 namedtuple 轉換為字典
print(p._asdict())  # {'x': 10, 'y': 20}

# _replace()：創建一個新的實例並替換指定字段
p_new = p._replace(x=30)
print(p_new)  # Point(x=30, y=20)

from collections import namedtuple

Point = namedtuple('Point', ['x', 'y'])

p = Point(10, 20)

# 可以通過字段名稱或索引來存取資料

print(p.x) # 10

print(p[1]) # 20

# 嘗試修改字段會引發 AttributeError

p.x = 30 # AttributeError

# 其他方法

# _asdict()：將 namedtuple 轉換為字典

print(p._asdict()) # {'x': 10, 'y': 20}

# _replace()：創建一個新的實例並替換指定字段

p_new = p._replace(x=30)

print(p_new) # Point(x=30, y=20)

[Python] [list] 學習筆記

發佈留言

List 基本概念:
清單是Python中的一種有序、可變的集合資料類型，可以儲存不同類型的元素

1. 建立list

# 空 list，使用方括號來建立
empty_list = []

# 初始化一個具有不同類型元素的list
my_list = [1, 2, 3, 'a', 'b', 'c']

# 空 list，使用方括號來建立

empty_list = []

# 初始化一個具有不同類型元素的list

my_list = [1, 2, 3, 'a', 'b', 'c']

2. 存取 list 元素
使用索引(index)方式來存取，索引初始值為0，最大值為該 list長度 – 1
使用負數索引則是由 -1 開始至 -1 – 長度 + 1

# 現有以下 list
test_list = [1, 2, 3, 4, 1]

# 此list長度為5，索引為 0~4，取出超過範圍的索引會發生 IndexError 異常
print(test_list[0]) # 1
print(test_list[5]) # IndexError: list index out of range

# 快速取出最後一個元素，使用負數索引
print(test_list[-1]) # 1

# index(x[, start[, end])
# 返回第一個值為 x 的元素的索引，可選參數 start 和 end 用於指定搜索範圍
print(test_list.index(1)) # 0
print(test_list.index(1, 1)) # 4 從索引1開始尋找值為1的元素索引值

# 現有以下 list

test_list = [1, 2, 3, 4, 1]

# 此list長度為5，索引為 0~4，取出超過範圍的索引會發生 IndexError 異常

print(test_list[0]) # 1

print(test_list[5]) # IndexError: list index out of range

# 快速取出最後一個元素，使用負數索引

print(test_list[-1]) # 1

# index(x[, start[, end])

# 返回第一個值為 x 的元素的索引，可選參數 start 和 end 用於指定搜索範圍

print(test_list.index(1)) # 0

print(test_list.index(1, 1)) # 4 從索引1開始尋找值為1的元素索引值

3. 列表切片
切片操作是一種強大且靈活的功能，可以輕鬆地從列表中提取子列表或進行其他操作。
切片操作使用 [start:stop:step] 的語法

PS:
1. 切片操作不會修改原始列表，而是返回一個新的列表（除非你直接對切片賦值）。
2. 如果索引超出範圍，Python 不會報錯，而是會自動調整為有效範圍。
3. 切片操作的時間複雜度為 O(k)，其中 k 是切片後的列表長度。

# list[start:stop:step]
# start: 起始索引（包含）
# stop： 結束索引（不包含）
# step: 步長（可選，預設為 1）

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 提取索引 2 到 5 的元素（不包含索引 5）
sub_list = my_list[2:5]
print(sub_list) # [2, 3, 4]

# 從頭開始提取
# 如果省略 start，則從清單的開頭開始
sub_list = my_list[:4] # 等價於 my_list[0:4]
print(sub_list) # [0, 1, 2, 3]

# 提取到結尾
# 如果省略 stop，則提取到列表的結尾
sub_list = my_list[6:] # 從索引 6 到結尾
print(sub_list) # 輸出: [6, 7, 8, 9]

# 使用負索引
# 負索引表示從清單的末尾開始計算
sub_list = my_list[-3:] # 擷取最後 3 個元素
print(sub_list) # [7, 8, 9]

# 使用步長（step）
# step 參數可以控制提取元素的間隔
sub_list = my_list[::2] # 從頭到尾，每隔一個元素擷取
print(sub_list) # [0, 2, 4, 6, 8]

# 如果 step 為負數，則從後往前提取
sub_list = my_list[::-1] # 反轉列表
print(sub_list) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# 指定範圍並使用步長
sub_list = my_list[1:8:2] # 從索引 1 到 8，每隔一個元素提取
print(sub_list) # [1, 3, 5, 7]

# 切片高階用法
# 修改清單中的部分元素
my_list[2:5] = [10, 11, 12] # 將索引 2 到 5 的元素替換為 [10, 11, 12]
print(my_list) # [0, 1, 10, 11, 12, 5, 6, 7, 8, 9]

# 刪除部分元素
# 將切片賦值為空列表，可以刪除部分元素
my_list[2:5] = [] # 刪除索引 2 到 5 的元素
print(my_list) # [0, 1, 5, 6, 7, 8, 9]

# 插入元素
my_list[2:2] = [20, 21, 22] # 在索引 2 的位置插入 [20, 21, 22]
print(my_list) # [0, 1, 20, 21, 22, 2, 3, 4, 5, 6, 7, 8, 9]

# 複製
my_list[2:2] = [20, 21, 22] # 在索引 2 的位置插入 [20, 21, 22]
print(my_list) # [0, 1, 20, 21, 22, 2, 3, 4, 5, 6, 7, 8, 9]

# list[start:stop:step]

# start: 起始索引（包含）

# stop：結束索引（不包含）

# step: 步長（可選，預設為 1）

my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 提取索引 2 到 5 的元素（不包含索引 5）

sub_list = my_list[2:5]

print(sub_list) # [2, 3, 4]

# 從頭開始提取

# 如果省略 start，則從清單的開頭開始

sub_list = my_list[:4] # 等價於 my_list[0:4]

print(sub_list) # [0, 1, 2, 3]

# 提取到結尾

# 如果省略 stop，則提取到列表的結尾

sub_list = my_list[6:] # 從索引 6 到結尾

print(sub_list) # 輸出: [6, 7, 8, 9]

# 使用負索引

# 負索引表示從清單的末尾開始計算

sub_list = my_list[-3:] # 擷取最後 3 個元素

print(sub_list) # [7, 8, 9]

# 使用步長（step）

# step 參數可以控制提取元素的間隔

sub_list = my_list[::2] # 從頭到尾，每隔一個元素擷取

print(sub_list) # [0, 2, 4, 6, 8]

# 如果 step 為負數，則從後往前提取

sub_list = my_list[::-1] # 反轉列表

print(sub_list) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# 指定範圍並使用步長

sub_list = my_list[1:8:2] # 從索引 1 到 8，每隔一個元素提取

print(sub_list) # [1, 3, 5, 7]

# 切片高階用法

# 修改清單中的部分元素

my_list[2:5] = [10, 11, 12] # 將索引 2 到 5 的元素替換為 [10, 11, 12]

print(my_list) # [0, 1, 10, 11, 12, 5, 6, 7, 8, 9]

# 刪除部分元素

# 將切片賦值為空列表，可以刪除部分元素

my_list[2:5] = [] # 刪除索引 2 到 5 的元素

print(my_list) # [0, 1, 5, 6, 7, 8, 9]

# 插入元素

my_list[2:2] = [20, 21, 22] # 在索引 2 的位置插入 [20, 21, 22]

print(my_list) # [0, 1, 20, 21, 22, 2, 3, 4, 5, 6, 7, 8, 9]

# 複製

my_list[2:2] = [20, 21, 22] # 在索引 2 的位置插入 [20, 21, 22]

print(my_list) # [0, 1, 20, 21, 22, 2, 3, 4, 5, 6, 7, 8, 9]

4. 修改列表 (增刪改)
append, insert, remove, pop, del

# 更新修改元素
my_list = [1, 2, 3]
my_list[0] = 10
print(my_list) # [10, 2, 3]

# 新增元素
# append、extend(iterable)
my_list.append(15)
print(my_list) # [10, 2, 3, 15]

my_list.extend([20, 30])
print(my_list) # [10, 2, 3, 15, 20, 30]

# 插入元素
# insert(i, x) 在索引i插入元素x
my_list.insert(1, 100)
print(my_list) # [10, 100, 2, 3, 15, 20, 30)

# 刪除元素
# remove, pop, del
# remove(x) 刪除list中第一個值為 x 的元素，若找不到該元素會拋出 ValueError
my_list.remove(100)
print(my_list) # [10, 2, 3, 15, 20, 30]

# pop([i])，刪除並返回 索引i 的元素。如果未指定i，則刪除並返回最後一個元素
my_list.pop()
print(my_list) # [10, 2, 3, 15, 20]

del my_list[1]
print(my_list) # [10, 3, 15, 20]

my_list.clear()
print(my_list) # []

# 更新修改元素

my_list = [1, 2, 3]

my_list[0] = 10

print(my_list) # [10, 2, 3]

# 新增元素

# append、extend(iterable)

my_list.append(15)

print(my_list) # [10, 2, 3, 15]

my_list.extend([20, 30])

print(my_list) # [10, 2, 3, 15, 20, 30]

# 插入元素

# insert(i, x) 在索引i插入元素x

my_list.insert(1, 100)

print(my_list) # [10, 100, 2, 3, 15, 20, 30)

# 刪除元素

# remove, pop, del

# remove(x) 刪除list中第一個值為 x 的元素，若找不到該元素會拋出 ValueError

my_list.remove(100)

print(my_list) # [10, 2, 3, 15, 20, 30]

# pop([i])，刪除並返回索引i 的元素。如果未指定i，則刪除並返回最後一個元素

my_list.pop()

print(my_list) # [10, 2, 3, 15, 20]

del my_list[1]

print(my_list) # [10, 3, 15, 20]

my_list.clear()

print(my_list) # []

5. 列表操作
使用 + 運算子連接兩個清單
使用 * 運算子複製

my_list = [1, 2, 3]
new_list = my_list + [4, 5, 6]
print(new_list) # [1, 2, 3, 4, 5, 6]

repeated_list = new_list * 2
print(repeated_list) # [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]

my_list = [1, 2, 3]

new_list = my_list + [4, 5, 6]

print(new_list) # [1, 2, 3, 4, 5, 6]

repeated_list = new_list * 2

print(repeated_list) # [1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]

6. 清單常用方法
count()、reverse()、copy()、len()、max()、min()、sort()

# count(x)
# 返回值為 x 的元素在列表中出現的次數
my_list = [1, 2, 2, 3, 4]
print(my_list.count(2))  # 2

# reverse()
# 反轉列表
my_list.reverse()
print(my_list)  # [4, 3, 2, 2, 1]

# copy()
# 返回列表的一個淺拷貝
new_list = my_list.copy()

# PS: 淺拷貝與深拷貝
import copy
shallow_copy = copy.copy(my_list)
deep_copy = copy.deepcopy(my_list)

# len()
# 返回列表的長度
print(len(my_list))  # 輸出: 5

# max()
# 返回列表中最大的元素
print(max(my_list))  # 4

# min()
# 返回列表中最小的元素
print(min(my_list))  # 1

# sort(key=None, reverse=False)
# 對列表進行排序，默認升序，reverse=True 降序
test_list = [1, 2, 4, 3]
test_list.sort()
print(test_list)  # [1, 2, 3, 4]
test_list.sort(reverse=True)
print(test_list)  # [4, 3, 2, 1]

# count(x)

# 返回值為 x 的元素在列表中出現的次數

my_list = [1, 2, 2, 3, 4]

print(my_list.count(2)) # 2

# reverse()

# 反轉列表

my_list.reverse()

print(my_list) # [4, 3, 2, 2, 1]

# copy()

# 返回列表的一個淺拷貝

new_list = my_list.copy()

# PS: 淺拷貝與深拷貝

import copy

shallow_copy = copy.copy(my_list)

deep_copy = copy.deepcopy(my_list)

# len()

# 返回列表的長度

print(len(my_list)) # 輸出: 5

# max()

# 返回列表中最大的元素

print(max(my_list)) # 4

# min()

# 返回列表中最小的元素

print(min(my_list)) # 1

# sort(key=None, reverse=False)

# 對列表進行排序，默認升序，reverse=True 降序

test_list = [1, 2, 4, 3]

test_list.sort()

print(test_list) # [1, 2, 3, 4]

test_list.sort(reverse=True)

print(test_list) # [4, 3, 2, 1]

7. 列表推導式 (list comprehension)
是一種簡潔且強大的語法，用於快速創建列表。它允許你在一行代碼中生成新的列表，並且通常比使用 for 迴圈更簡潔和高效
PS: 需要額外紀錄介紹相關用法與範例

# [expression for item in iterable if condition]
# expression: 對 item 進行操作或計算，結果會成為新列表的元素
# item: 從 iterable 中取出的元素
# iterable: 可迭代對象（如列表、元組、字串、範圍等）
# if condition（可選）: 過濾條件，只有滿足條件的 item 才會被處理

numbers = [1, 2, 3, 4, 5]
squares = [x**2 for x in numbers]
print(squares) # [1, 4, 9, 16, 25]

# [expression for item in iterable if condition]

# expression: 對 item 進行操作或計算，結果會成為新列表的元素

# item: 從 iterable 中取出的元素

# iterable: 可迭代對象（如列表、元組、字串、範圍等）

# if condition（可選）: 過濾條件，只有滿足條件的 item 才會被處理

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

squares = [x**2 for x in numbers]

print(squares) # [1, 4, 9, 16, 25]

8. 嵌套列表
一個list內的元素也是list，在機器學習與矩陣運算下常使用到

nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(nested_list[1][2]) # 6

1 2	nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] print(nested_list[1][2]) # 6

9. 列表循環
使用 for 迴圈遍歷列表

for item in my_list:
    print(item)

1 2	for item in my_list: print(item)

10. in 與 not in
檢查元素是否存在

my_list = [1, 2, 3, 4, 5]
if 1 in my_list:
    print("1 is in my_list")

if 6 not in my_list:
    print("6 is not in my_list")

Coding worker

學習、紀錄與分析

分類彙整: python_note

[Python] [Dict] 學習筆記

dict (字典)

常用方法 (python 3.11)

常用操作:

[Python] [Set] 學習筆記

集合 (Set):

set 相關方法:

set 相關操作:

[Python] [tuple] 學習筆記

[Python] [list] 學習筆記