標籤彙整: python

[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")

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")

Python: os.path module

發佈留言

os.path 模組中有幾個好用的api來取得當前檔案路徑，使得程式可以用更彈性方式去使用(避免了固定路徑)

import os

# 當前檔案的完整名稱路徑為 D:\test\test.py
# 絕對路徑
print(os.path.abspath(__file__))
# D:\test\test.py


# 檔案名稱
print(os.path.basename(__file__))
# test.py

# 上層路徑名稱
print(os.path.dirname(__file__))
# D:\test

# 檔名與副檔名
print(os.path.splitext(os.path.basename(__file__)))
# ('test', '.py')

# 承上，分別獲取並設置變數
file_name, file_ext = os.path.splitext(os.path.basename(__file__))
print(f"{file_name = }, {file_ext = }")
# file_name = 'test', file_ext = '.py'

import os

# 當前檔案的完整名稱路徑為 D:\test\test.py

# 絕對路徑

print(os.path.abspath(__file__))

# D:\test\test.py

# 檔案名稱

print(os.path.basename(__file__))

# test.py

# 上層路徑名稱

print(os.path.dirname(__file__))

# D:\test

# 檔名與副檔名

print(os.path.splitext(os.path.basename(__file__)))

# ('test', '.py')

# 承上，分別獲取並設置變數

file_name, file_ext = os.path.splitext(os.path.basename(__file__))

print(f"{file_name = }, {file_ext = }")

# file_name = 'test', file_ext = '.py'

python built-in function: abs

發佈留言

abs(x, /)

回傳一個數的絕對值，引數可以是整數、浮點數或有實現 abs() 的物件。如果引數是一個複數，回傳它的純量（大小）

print(abs(-1))          # 1
print(abs(-1.3232))     # 1.3232

# 1+1.0j的純量為 (1^2 + 1^2)^1/2 => 2^1/2
print(abs(1 + 1.0j))    # 1.4142135623730951
print(abs(3 + 4.0j))    # 5.0

print(abs(-1)) # 1

print(abs(-1.3232)) # 1.3232

# 1+1.0j的純量為 (1^2 + 1^2)^1/2 => 2^1/2

print(abs(1 + 1.0j)) # 1.4142135623730951

print(abs(3 + 4.0j)) # 5.0

使用python與PyQt5製作登入UI畫面

發佈留言

在PyQt5中，使用QLineEdit來模擬製作帳號密碼登入UI，首先使用Qt designer來拉出元件
如以下畫面所示，拉出Label、QLineEdit、QCheckBox與QpushButton，同時在designer中設定QCheckBox與QPushButton的信號-槽

QCheckBox搭配show_pw訊號，用來控制當勾選此checkBox時，就顯示密碼
QPushButton搭配login_test訊號，當點擊時就開始進行帳號密碼的登入測試，這邊只印出log，沒有實際的進行實質的登入
密碼可見與不可見，使用QLineEdit原生的setEchoMode與QLineEdit.Password進行設定
PasswordEchoOnEdit效果不好，必須等當前QLineEdit失去焦點才能將密碼不可見，在簡單的UI元件下，不好控制，除非再額外新增相關焦點控制

範例程式:

import os
import sys
from PyQt5 import QtCore, QtWidgets, QtGui

from login_ui import Ui_Form

class MainWindow(QtWidgets.QMainWindow, Ui_Form):

    def __init__(self, parent=None):
        super(MainWindow, self).__init__(parent)
        self.setupUi(self)

    def login_test(self):
        print("login_test")
        print(self.ac_lineEdit.text())
        print(self.pw_lineEdit.text())
        print(self.checkBox.isChecked())

    def show_pw(self):
        if self.checkBox.isChecked():
            self.pw_lineEdit.setEchoMode(QtWidgets.QLineEdit.Normal)
        else:
            self.pw_lineEdit.setEchoMode(QtWidgets.QLineEdit.Password)

    def closeEvent(self, event):
        QtWidgets.QApplication.closeAllWindows()


if __name__== "__main__":
    app = QtWidgets.QApplication(sys.argv)
    win = MainWindow()
    win.show()
    sys.exit(app.exec_())

import os

import sys

from PyQt5 import QtCore, QtWidgets, QtGui

from login_ui import Ui_Form

class MainWindow(QtWidgets.QMainWindow, Ui_Form):

def __init__(self, parent=None):

super(MainWindow, self).__init__(parent)

self.setupUi(self)

def login_test(self):

print("login_test")

print(self.ac_lineEdit.text())

print(self.pw_lineEdit.text())

print(self.checkBox.isChecked())

def show_pw(self):

if self.checkBox.isChecked():

self.pw_lineEdit.setEchoMode(QtWidgets.QLineEdit.Normal)

else:

self.pw_lineEdit.setEchoMode(QtWidgets.QLineEdit.Password)

def closeEvent(self, event):

QtWidgets.QApplication.closeAllWindows()

if __name__== "__main__":

app = QtWidgets.QApplication(sys.argv)

win = MainWindow()

win.show()

sys.exit(app.exec_())

UI檔案

from PyQt5 import QtCore, QtGui, QtWidgets


class Ui_Form(object):
    def setupUi(self, Form):
        Form.setObjectName("Form")
        Form.resize(470, 200)
        Form.setMinimumSize(QtCore.QSize(470, 200))
        Form.setMaximumSize(QtCore.QSize(470, 200))
        font = QtGui.QFont()
        font.setFamily("Bahnschrift Light SemiCondensed")
        Form.setFont(font)
        Form.setWindowTitle("")
        self.ac_lineEdit = QtWidgets.QLineEdit(Form)
        self.ac_lineEdit.setGeometry(QtCore.QRect(140, 30, 221, 31))
        font = QtGui.QFont()
        font.setFamily("Courier New")
        font.setPointSize(12)
        self.ac_lineEdit.setFont(font)
        self.ac_lineEdit.setObjectName("ac_lineEdit")
        self.pw_lineEdit = QtWidgets.QLineEdit(Form)
        self.pw_lineEdit.setGeometry(QtCore.QRect(140, 79, 221, 31))
        font = QtGui.QFont()
        font.setFamily("Courier New")
        font.setPointSize(12)
        self.pw_lineEdit.setFont(font)
        self.pw_lineEdit.setEchoMode(QtWidgets.QLineEdit.Password)
        # self.pw_lineEdit.setEchoMode(QtWidgets.QLineEdit.PasswordEchoOnEdit)
        self.pw_lineEdit.setObjectName("pw_lineEdit")
        self.label = QtWidgets.QLabel(Form)
        self.label.setGeometry(QtCore.QRect(30, 30, 91, 31))
        font = QtGui.QFont()
        font.setFamily("Courier New")
        font.setPointSize(12)
        self.label.setFont(font)
        self.label.setObjectName("label")
        self.label_2 = QtWidgets.QLabel(Form)
        self.label_2.setGeometry(QtCore.QRect(30, 80, 91, 31))
        font = QtGui.QFont()
        font.setFamily("Courier New")
        font.setPointSize(12)
        self.label_2.setFont(font)
        self.label_2.setObjectName("label_2")
        self.pushButton = QtWidgets.QPushButton(Form)
        self.pushButton.setGeometry(QtCore.QRect(30, 140, 411, 31))
        font = QtGui.QFont()
        font.setFamily("Courier New")
        font.setPointSize(12)
        self.pushButton.setFont(font)
        self.pushButton.setObjectName("pushButton")
        self.checkBox = QtWidgets.QCheckBox(Form)
        self.checkBox.setGeometry(QtCore.QRect(380, 70, 81, 41))
        font = QtGui.QFont()
        font.setFamily("Courier New")
        font.setPointSize(12)
        self.checkBox.setFont(font)
        self.checkBox.setObjectName("checkBox")

        self.retranslateUi(Form)
        self.pushButton.clicked.connect(Form.login_test) # type: ignore
        self.checkBox.clicked['bool'].connect(Form.show_pw) # type: ignore
        QtCore.QMetaObject.connectSlotsByName(Form)

    def retranslateUi(self, Form):
        _translate = QtCore.QCoreApplication.translate
        Form.setWindowTitle(_translate("Form", "Login"))
        self.label.setText(_translate("Form", "account:"))
        self.label_2.setText(_translate("Form", "password:"))
        self.pushButton.setText(_translate("Form", "Login"))
        self.checkBox.setText(_translate("Form", "show"))

from PyQt5 import QtCore, QtGui, QtWidgets

class Ui_Form(object):

def setupUi(self, Form):

Form.setObjectName("Form")

Form.resize(470, 200)

Form.setMinimumSize(QtCore.QSize(470, 200))

Form.setMaximumSize(QtCore.QSize(470, 200))

font = QtGui.QFont()

font.setFamily("Bahnschrift Light SemiCondensed")

Form.setFont(font)

Form.setWindowTitle("")

self.ac_lineEdit = QtWidgets.QLineEdit(Form)

self.ac_lineEdit.setGeometry(QtCore.QRect(140, 30, 221, 31))

font = QtGui.QFont()

font.setFamily("Courier New")

font.setPointSize(12)

self.ac_lineEdit.setFont(font)

self.ac_lineEdit.setObjectName("ac_lineEdit")

self.pw_lineEdit = QtWidgets.QLineEdit(Form)

self.pw_lineEdit.setGeometry(QtCore.QRect(140, 79, 221, 31))

font = QtGui.QFont()

font.setFamily("Courier New")

font.setPointSize(12)

self.pw_lineEdit.setFont(font)

self.pw_lineEdit.setEchoMode(QtWidgets.QLineEdit.Password)

# self.pw_lineEdit.setEchoMode(QtWidgets.QLineEdit.PasswordEchoOnEdit)

self.pw_lineEdit.setObjectName("pw_lineEdit")

self.label = QtWidgets.QLabel(Form)

self.label.setGeometry(QtCore.QRect(30, 30, 91, 31))

font = QtGui.QFont()

font.setFamily("Courier New")

font.setPointSize(12)

self.label.setFont(font)

self.label.setObjectName("label")

self.label_2 = QtWidgets.QLabel(Form)

self.label_2.setGeometry(QtCore.QRect(30, 80, 91, 31))

font = QtGui.QFont()

font.setFamily("Courier New")

font.setPointSize(12)

self.label_2.setFont(font)

self.label_2.setObjectName("label_2")

self.pushButton = QtWidgets.QPushButton(Form)

self.pushButton.setGeometry(QtCore.QRect(30, 140, 411, 31))

font = QtGui.QFont()

font.setFamily("Courier New")

font.setPointSize(12)

self.pushButton.setFont(font)

self.pushButton.setObjectName("pushButton")

self.checkBox = QtWidgets.QCheckBox(Form)

self.checkBox.setGeometry(QtCore.QRect(380, 70, 81, 41))

font = QtGui.QFont()

font.setFamily("Courier New")

font.setPointSize(12)

self.checkBox.setFont(font)

self.checkBox.setObjectName("checkBox")

self.retranslateUi(Form)

self.pushButton.clicked.connect(Form.login_test) # type: ignore

self.checkBox.clicked['bool'].connect(Form.show_pw) # type: ignore

QtCore.QMetaObject.connectSlotsByName(Form)

def retranslateUi(self, Form):

_translate = QtCore.QCoreApplication.translate

Form.setWindowTitle(_translate("Form", "Login"))

self.label.setText(_translate("Form", "account:"))

self.label_2.setText(_translate("Form", "password:"))

self.pushButton.setText(_translate("Form", "Login"))

self.checkBox.setText(_translate("Form", "show"))

最終UI畫面效果如下，包含密碼可見與不可見

勾選show checkbox則密碼可見

預設密碼不可見

vscode 禁止覆蓋原本檔案

發佈留言

vscode 客製化設定

問題內容:
查看點擊其他程式檔案時，常常會覆蓋原本編輯位置檔案，這對想要同時比較兩個檔案或者查詢相關函數時會非常不方便

解決方法:
在設定內(ctrl + ,)，輸入並查找 “Enable Preview”，將其預設勾選取消掉即可

disable “enable preview”

python built-in function: bytes

發佈留言

class bytes(source=b”)
class bytes(source, encoding)
class bytes(source, encoding, errors)

bytes物件是不可變類型(bytearray則為可變類型)的序列，其元素為 0 <= x <= 256 整數

s = 'abcd'
b = bytes(s, encoding='utf-8')
print(b)       # b'abcd'
print(b[0])    # 97
print(b[:1])   # b'a'
print(b[1])    # 98
print(b[1:2])  # b'b'
print(b[1:2].decode(encoding='utf-8')) # b


for i in b:
    # 97為a在ascii編碼中10進制表示
    print(i, chr(i), bytes(chr(i), 'utf-8'))
    # 97 a b'a'
    # 98 b b'b'
    # 99 c b'c'
    # 100 d b'd'

# 產生列表
print(list(map(bytes, zip(b'abcd'))))  # [b'a', b'b', b'c', b'd']
print([i for i in b'abcd'])            # [97, 98, 99, 100]

s = 'abcd'

b = bytes(s, encoding='utf-8')

print(b) # b'abcd'

print(b[0]) # 97

print(b[:1]) # b'a'

print(b[1]) # 98

print(b[1:2]) # b'b'

print(b[1:2].decode(encoding='utf-8')) # b

for i in b:

# 97為a在ascii編碼中10進制表示

print(i, chr(i), bytes(chr(i), 'utf-8'))

# 97 a b'a'

# 98 b b'b'

# 99 c b'c'

# 100 d b'd'

# 產生列表

print(list(map(bytes, zip(b'abcd')))) # [b'a', b'b', b'c', b'd']

print([i for i in b'abcd']) # [97, 98, 99, 100]

int轉換bytes，bytes轉換回int

x = 123
v_bytes = x.to_bytes(length=4, byteorder='little', signed=False)
print(type(v_bytes), v_bytes)     # <class 'bytes'> b'{\x00\x00\x00'

v_int = int.from_bytes(v_bytes, byteorder='little', signed=False)
print(type(v_int), v_int)         # <class 'int'> 123

x = 123

v_bytes = x.to_bytes(length=4, byteorder='little', signed=False)

print(type(v_bytes), v_bytes) # <class 'bytes'> b'{\x00\x00\x00'

v_int = int.from_bytes(v_bytes, byteorder='little', signed=False)

print(type(v_int), v_int) # <class 'int'> 123

bytes類別相關方法:

# replace(bytes,bytes)
print(b'abcd'.replace(b'c', b'x'))       # b'abxd'

# find(bytes)
print(b'abcd'.find(b'c'))                # 2
print(b'abcd'.find(b'x'))                # -1


# decode()
print(b'abcd'.decode(encoding='utf-8'))  # abcd

# classmethod fromhex(string)
print(bytes.fromhex("61626364"))         # b'abc'


# hex([sep[, bytes_per_sep]])            # 61626364
print(b'abcd'.hex())

# replace(bytes,bytes)

print(b'abcd'.replace(b'c', b'x')) # b'abxd'

# find(bytes)

print(b'abcd'.find(b'c')) # 2

print(b'abcd'.find(b'x')) # -1

# decode()

print(b'abcd'.decode(encoding='utf-8')) # abcd

# classmethod fromhex(string)

print(bytes.fromhex("61626364")) # b'abc'

# hex([sep[, bytes_per_sep]]) # 61626364

print(b'abcd'.hex())

python built-in function: eval

發佈留言

eval(expression, /, globals=None, locals=None)

expression: 字串
globals: 必須是一個 dictionary
locals: 可以是任何映射 (mapping) 物件

EX:

x = 1
print(eval('x + 1'))     # 2
print(eval('3 * x'))     # 3
print(eval('pow(2,2)'))  # 4

x = 3
y = 4
print(eval("x + y"))     # 7

x = 1

print(eval('x + 1')) # 2

print(eval('3 * x')) # 3

print(eval('pow(2,2)')) # 4

x = 3

y = 4

print(eval("x + y")) # 7

EX: 比較 eval 與 exec

# eval僅可以執行單個表達式, exec可執行多個表達式
# print(eval('z = 3\nprint(z + 1)'))    # SyntaxError: invalid syntax
print(exec('z = 3\nprint(z + 1)'))      # 4

# eval僅可以執行單個表達式, exec可執行多個表達式

# print(eval('z = 3\nprint(z + 1)')) # SyntaxError: invalid syntax

print(exec('z = 3\nprint(z + 1)')) # 4

EX: 動態修改PyQt

import random

d = {"A": "_01_a_rb", "B": "_02_b_rb", "C": "_03_c_rb"}

key_name = random.choice(list(d.keys()))
rb_name = d.get(key_name)

# 根據隨機選擇d中key，設置其pyqt checkbox為True(選取)
eval("self." + rb_name + ".setChecked(True)")

import random

d = {"A": "_01_a_rb", "B": "_02_b_rb", "C": "_03_c_rb"}

key_name = random.choice(list(d.keys()))

rb_name = d.get(key_name)

# 根據隨機選擇d中key，設置其pyqt checkbox為True(選取)

eval("self." + rb_name + ".setChecked(True)")

Coding worker

學習、紀錄與分析

標籤彙整: python

[Python] [Dict] 學習筆記

dict (字典)

常用方法 (python 3.11)

常用操作:

[Python] [Set] 學習筆記

集合 (Set):

set 相關方法:

set 相關操作:

[Python] [tuple] 學習筆記

[Python] [list] 學習筆記

Python: os.path module

python built-in function: abs

使用python與PyQt5製作登入UI畫面

vscode 禁止覆蓋原本檔案

python built-in function: bytes

python built-in function: eval