字符串和常用數據結構

使用字符串

def main():
    str1 = 'hello, world!'
    # 通過len函數計算字符串的長度
    print(len(str1))  # 13
    # 獲得字符串首字母大寫的拷貝
    print(str1.capitalize())  # Hello, world!
    # 獲得字符串變大寫後的拷貝
    print(str1.upper())  # HELLO, WORLD!
    # 從字符串中查找子串所在位置
    print(str1.find('or'))  # 8
    print(str1.find('shit'))  # -1
    # 與find類似但找不到子串時會引發異常
    # print(str1.index('or'))
    # print(str1.index('shit'))
    # 檢查字符串是否以指定的字符串開頭
    print(str1.startswith('He'))  # False
    print(str1.startswith('hel'))  # True
    # 檢查字符串是否以指定的字符串結尾
    print(str1.endswith('!'))  # True
    # 將字符串以指定的寬度居中並在兩側填充指定的字符
    print(str1.center(50, '*'))
    # 將字符串以指定的寬度靠右放置左側填充指定的字符
    print(str1.rjust(50, ' '))
    str2 = 'abc123456'
    # 從字符串中取出指定位置的字符(下標運算)
    print(str2[2])  # c
    # 字符串切片(從指定的開始索引到指定的結束索引)
    print(str2[2:5])  # c12
    print(str2[2:])  # c123456
    print(str2[2::2])  # c246
    print(str2[::2])  # ac246
    print(str2[::-1])  # 654321cba
    print(str2[-3:-1])  # 45
    # 檢查字符串是否由數字構成
    print(str2.isdigit())  # False
    # 檢查字符串是否以字母構成
    print(str2.isalpha())  # False
    # 檢查字符串是否以數字和字母構成
    print(str2.isalnum())  # True
    str3 = '  [email protected] '
    print(str3)
    # 獲得字符串修剪左右兩側空格的拷貝
    print(str3.strip())


if __name__ == '__main__':
    main()

使用列表

def main():
    list1 = [1, 3, 5, 7, 100]
    print(list1)
    list2 = ['hello'] * 5
    print(list2)
    # 計算列表長度(元素個數)
    print(len(list1))
    # 下標(索引)運算
    print(list1[0])
    print(list1[4])
    # print(list1[5])  # IndexError: list index out of range
    print(list1[-1])
    print(list1[-3])
    list1[2] = 300
    print(list1)
    # 添加元素
    list1.append(200)
    list1.insert(1, 400)
    list1 += [1000, 2000]
    print(list1)
    print(len(list1))
    # 刪除元素
    list1.remove(3)
    if 1234 in list1:
        list1.remove(1234)
    del list1[0]
    print(list1)
    # 清空列表元素
    list1.clear()
    print(list1)


if __name__ == '__main__':
    main()

和字符串一樣，列表也可以做切片操作，通過切片操作我們可以實現對列表的複製或者將列表中的一部分取出來創建出新的列表，代碼如下所示。

def main():
    fruits = ['grape', 'apple', 'strawberry', 'waxberry']
	fruits += ['pitaya', 'pear', 'mango']
	# 循環遍歷列表元素
    for fruit in fruits:
        print(fruit.title(), end=' ')
    print()
    # 列表切片
    fruits2 = fruits[1:4]
    print(fruits2)
    # fruit3 = fruits  # 沒有複製列表只創建了新的引用
    # 可以通過完整切片操作來複制列表
    fruits3 = fruits[:]
    print(fruits3)
    fruits4 = fruits[-3:-1]
    print(fruits4)
    # 可以通過反向切片操作來獲得倒轉後的列表的拷貝
    fruits5 = fruits[::-1]
    print(fruits5)


if __name__ == '__main__':
    main()

fruit3 = fruits 沒有複製列表只創建了新的引用
fruits3 = fruits[:] 可以通過完整切片操作來複製列表

排序

def main():
    list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
    list2 = sorted(list1)
    # sorted函數返回列表排序後的拷貝不會修改傳入的列表
    # 函數的設計就應該像sorted函數一樣儘可能不產生副作用
    list3 = sorted(list1, reverse=True)
    # 通過key關鍵字參數指定根據字符串長度進行排序而不是默認的字母表順序
    list4 = sorted(list1, key=len)
    print(list1)
    print(list2)
    print(list3)
    print(list4)
    # 給列表對象發出排序消息直接在列表對象上進行排序
    list1.sort(reverse=True)
    print(list1)


if __name__ == '__main__':
    main()

創建列表

列表的生成式語法

import sys


def main():
    f = [x for x in range(1, 10)]
    print(f)
    f = [x + y for x in 'ABCDE' for y in '1234567']
    print(f)
    # 用列表的生成表達式語法創建列表容器
    # 用這種語法創建列表之後元素已經準備就緒所以需要耗費較多的內存空間
    f = [x ** 2 for x in range(1, 10)]
    print(sys.getsizeof(f))  # 查看對象佔用內存的字節數
    print(f)
    # 請注意下面的代碼創建的不是一個列表而是一個生成器對象
    # 通過生成器可以獲取到數據但它不佔用額外的空間存儲數據
    # 每次需要數據的時候就通過內部的運算得到數據(需要花費額外的時間)
    f = (x ** 2 for x in range(1, 10))
    print(sys.getsizeof(f))  # 相比生成式生成器不佔用存儲數據的空間
    print(f)
    for val in f:
        print(val)


if __name__ == '__main__':
    main()

2. yield關鍵字將一個普通函數改造成生成器函數

def fib(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
        yield a


def main():
    for val in fib(20):
        print(val)


if __name__ == '__main__':
    main()

詳解：https://www.runoob.com/w3cnote/python-yield-used-analysis.html

使用元組

Python 的元組與列表類似，不同之處在於元組的元素不能修改

def main():
    # 定義元組
    t = ('駱昊', 38, True, '四川成都')
    print(t)
    # 獲取元組中的元素
    print(t[0])
    print(t[3])
    # 遍歷元組中的值
    for member in t:
        print(member)
    # 重新給元組賦值
    # t[0] = '王大錘'  # TypeError
    # 變量t重新引用了新的元組原來的元組將被垃圾回收
    t = ('王大錘', 20, True, '雲南昆明')
    print(t)
    # 將元組轉換成列表
    person = list(t)
    print(person)
    # 列表是可以修改它的元素的
    person[0] = '李小龍'
    person[1] = 25
    print(person)
    # 將列表轉換成元組
    fruits_list = ['apple', 'banana', 'orange']
    fruits_tuple = tuple(fruits_list)
    print(fruits_tuple)


if __name__ == '__main__':
    main()

應用場景

元組中的元素是無法修改的，事實上我們在項目中尤其是多線程環境（後面會講到）中可能更喜歡使用的是那些不變對象（一方面因爲對象狀態不能修改，所以可以避免由此引起的不必要的程序錯誤，簡單的說就是一個不變的對象要比可變的對象更加容易維護；另一方面因爲沒有任何一個線程能夠修改不變對象的內部狀態，一個不變對象自動就是線程安全的，這樣就可以省掉處理同步化的開銷。一個不變對象可以方便的被共享訪問）。
所以結論就是：如果不需要對元素進行添加、刪除、修改的時候，可以考慮使用元組，當然如果一個
方法要返回多個值，使用元組也是不錯的選擇。
元組在創建時間和佔用的空間上面都優於列表。

使用集合

def main():
    set1 = {1, 2, 3, 3, 3, 2}
    print(set1)
    print('Length =', len(set1))
    set2 = set(range(1, 10))
    print(set2)
    set1.add(4)
    set1.add(5)
    set2.update([11, 12])
    print(set1)
    print(set2)
    # discard的元素如果不存在不會引發KeyError
    set2.discard(5)
    # remove的元素如果不存在會引發KeyError
    if 4 in set2:
        set2.remove(4)
    print(set2)
    # 遍歷集合容器
    for elem in set2:
        print(elem ** 2, end=' ')
    print()
    # 將元組轉換成集合
    set3 = set((1, 2, 3, 3, 2, 1))
    print(set3.pop())
    print(set3)
    # 集合的交集、並集、差集、對稱差運算
    print(set1 & set2)
    # print(set1.intersection(set2))
    print(set1 | set2)
    # print(set1.union(set2))
    print(set1 - set2)
    # print(set1.difference(set2))
    print(set1 ^ set2)
    # print(set1.symmetric_difference(set2))
    # 判斷子集和超集
    print(set2 <= set1)
    # print(set2.issubset(set1))
    print(set3 <= set1)
    # print(set3.issubset(set1))
    print(set1 >= set2)
    # print(set1.issuperset(set2))
    print(set1 >= set3)
    # print(set1.issuperset(set3))


if __name__ == '__main__':
    main()

上面的代碼中我們對集合進行運算的時候可以調用集合對象的方法，也可以直接使用對應的運算符，例如&運算符跟intersection方法的作用就是一樣的，但是使用運算符讓代碼更加直觀。

使用字典

字典是另一種可變容器模型，類似於我們生活中使用的字典，它可以存儲任意類型對象，與列表、集合不同的是，字典的每個元素都是由一個鍵和一個值組成的“鍵值對”，鍵和值通過冒號分開。

def main():
    scores = {'駱昊': 95, '白元芳': 78, '狄仁傑': 82}
    # 通過鍵可以獲取字典中對應的值
    print(scores['駱昊'])
    print(scores['狄仁傑'])
    # 對字典進行遍歷(遍歷的其實是鍵再通過鍵取對應的值)
    for elem in scores:
        print('%s\t--->\t%d' % (elem, scores[elem]))
    # 更新字典中的元素
    scores['白元芳'] = 65
    scores['諸葛王朗'] = 71
    scores.update(冷麪=67, 方啓鶴=85)
    print(scores)
    if '武則天' in scores:
        print(scores['武則天'])
    print(scores.get('武則天'))
    # get方法也是通過鍵獲取對應的值但是可以設置默認值
    print(scores.get('武則天', 60))
    # 刪除字典中的元素
    print(scores.popitem())
    print(scores.popitem())
    print(scores.pop('駱昊', 100))
    # 清空字典
    scores.clear()
    print(scores)


if __name__ == '__main__':
    main()

參考資料：https://github.com/jackfrued/Python-100-Days/blob/master/Day01-15/Day07/字符串和常用數據結構.md

Python100天打卡-Day07 - 字符串和常用數據結構

字符串和常用數據結構

使用字符串

使用列表

使用元組

使用集合

使用字典

《Python進階》學習筆記

Leetcode 3161. 物塊放置查詢

leetcode 60 排列序列

一個docker容器暴露多個端口

微服務實踐之使用 Visual Studio 2022 調試Dapr 應用程序

wpf附加屬性理解 WPF附加屬性

動手學深度學習讀書筆記-4

Python100天打卡-Day08- 面向對象編程基礎

Python100天打卡-Day06 - 函數和模塊的使用

Python100天打卡-Day05 - 總結與練習

Python100天打卡-Day04 - 循環結構

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結