python程式設計基礎

写代码的大学生發表於2024-10-25

1.python中的變數和資料型別
- 1.1變數
- 1.2python基本資料型別
- 1.3基本輸入與輸出
  - 輸入（Input）
  - 輸出（Output）
    - 基本輸出
    - 列印多個引數
    - 格式化輸出
    - 列印到檔案
- 1.4python中的運算子
  - 算術運算子
  - 比較運算子
  - 賦值運算子
  - 邏輯運算子
  - 位運算子
  - 成員運算子
  - 身份運算子
2.python中的列表、元組、字典、集合
- 2.1列表
- 2.2元組
- 2.3字典
- 2.4集合
3.range、zip、enumerate
- 3.1range函式
- 3.2zip函式
- 3.3enumerate函式
4.序列、推導式、生成器與迭代器
- 4.1序列的切片
- 4.2序列的基本操作
  - 列表特有操作
  - 元組特有操作
  - 通用操作
- 4.3列表推導式
- 4.4生成器與迭代器
  - 迭代器（Iterator）
  - 生成器（Generator）
5.程式流程控制
- 5.1分支結構
- 5.2迴圈結構
6.函式
- 6.1python函式的定義
- 6.2形參與實參
- 6.3變數的作用域
- 6.4函式的型別
7.python的常用內建函式
- 7.1python主要的內建函式
- 7.2eval函式
- 7.3filter函式
- 7.4map函式
- 7.5lamdba函式
- 7.6sorted函式
8.字串
- 8.1字串的格式化
- 8.2字串的常用方法
9.物件導向程式設計
- 9.1物件導向的概念
- 9.2類的定義與例項化
- 9.3類的成員
- 9.4封裝
- 9.5繼承
- 9.6多型
10 python檔案操作
- 10.1 開啟檔案
- 10.2 關閉檔案
- 10.3 使用with as進行檔案續寫
- 10.4 檔案續寫的其他方法

Python 是一種廣泛使用的高階程式語言，它以其清晰的語法和程式碼可讀性而聞名。Python 支援多種程式設計正規化，包括物件導向、命令式、函式式和程序式程式設計。它由 Guido van Rossum 建立，並於1991年首次釋出。本文將詳細介紹python程式設計語法。

1.python中的變數和資料型別

1.1變數

在Python中，變數是用來儲存資料的容器。你可以將變數視為一個有標籤的盒子，這個標籤就是變數名，盒子裡面可以放入資料。Python中的變數不需要顯式宣告型別，直譯器會根據賦給變數的值自動確定型別。

以下是一些關於Python變數的基本規則和特點：

命名規則：
- 變數名必須以字母或下劃線開頭，不能以數字開頭。
- 變數名只能包含字母、數字和下劃線（A-z, 0-9, 和 _ ）。
- 變數名是區分大小寫的，這意味著Variable和variable是兩個不同的變數。
動態型別：
- Python是動態型別語言，變數可以在執行時改變型別。例如：
```
x = 10      # x是整數
x = "Hello" # x現在是字串
```
無需宣告：
- 在Python中，你不需要宣告變數的型別，直接賦值即可。
全域性變數和區域性變數：
- 如果在函式內部賦值給一個變數，那麼這個變數是區域性變數，僅在函式內部有效。
- 如果在函式外部賦值給一個變數，那麼這個變數是全域性變數，可以在程式的任何地方訪問。
變數作用域：
- Python中有LEGB規則，即Local（區域性），Enclosing（封閉），Global（全域性），Built-in（內建）。
可變型別與不可變型別：
- 變數可以指向可變型別（如列表、字典）或不可變型別（如整數、字串、元組）。
- 對於不可變型別，賦值操作實際上是建立了一個新的物件，並更新了變數的引用。
- 對於可變型別，賦值操作只是改變了變數的引用，指向了一個新的物件。
垃圾回收：
- Python有自動垃圾回收機制，當一個變數不再被引用時，它會被自動回收。
關鍵字：
- 一些單詞在Python中有特殊的意義，被稱為關鍵字，不能用作變數名。

這裡有一個簡單的Python變數示例：

# 定義一個變數並賦值
my_variable = 42

# 列印變數的值
print(my_variable)

# 改變變數的型別
my_variable = "Now I'm a string"

# 再次列印變數的值
print(my_variable)

在這段程式碼中，我們首先定義了一個名為my_variable的變數，並賦值為整數42。然後我們列印了這個變數的值。接著我們將變數的值改為字串"Now I'm a string"，並再次列印了變數的值。這展示了Python變數的動態型別特性。

1.2python基本資料型別

Python中有幾種基本資料型別，用於儲存不同型別的資料。以下是Python中常見的基本資料型別：

整數（Integers）：
- 用於儲存整數，沒有小數點。
- 示例：42, -7, 0, 1024
浮點數（Floats）：
- 用於儲存小數點後的數字。
- 示例：3.14, -0.01, 2.0
字串（Strings）：
- 用於儲存文字資料。
- 可以用單引號'、雙引號"或三引號'''或"""來定義字串。
- 示例：'hello', "world", ```"""multiline
  text"""`
布林值（Booleans）：
- 只有兩個值：True和False。
- 用於邏輯判斷。
- 示例：True, False
複數（Complex Numbers）：
- 用於儲存複數。
- 示例：3+4j, 1.2-3.4j
列表（Lists）：
- 有序的元素集合，可以包含不同型別的元素。
- 元素可以重複。
- 可變型別，可以修改。
- 示例：[1, 'a', 3.14], [True, False, True]
元組（Tuples）：
- 有序的元素集合，可以包含不同型別的元素。
- 元素不可重複。
- 不可變型別，一旦建立不能修改。
- 示例：(1, 'a', 3.14), (1, 2, 3)
字典（Dictionaries）：
- 無序的鍵值對集合。
- 鍵必須是不可變型別，如字串、整數。
- 值可以是任何資料型別。
- 可變型別，可以修改。
- 示例：{'name': 'John', 'age': 30}
集合（Sets）：
- 無序的元素集合。
- 元素必須是可雜湊的，不可重複。
- 可變型別，可以修改。
- 示例：{1, 2, 3}, {'a', 'b', 'c'}
凍結集合（Frozen Sets）：
- 和集合類似，但是不可變型別。
- 示例：frozenset([1, 2, 3])

這些基本資料型別構成了Python程式設計的基礎，並且可以用於建立更復雜的資料結構和物件。在Python中，除了這些基本資料型別，還有用於處理日期和時間的datetime型別，用於處理二進位制資料的bytes和bytearray型別等。此外，Python還支援自定義資料型別，通常透過類來實現。

1.3基本輸入與輸出

在Python中，輸入和輸出是程式設計中的基本操作，用於與使用者互動或處理資料。以下是Python中基本的輸入和輸出方法：

輸入（Input）

Python使用input()函式來接收使用者的輸入。這個函式會暫停程式的執行，等待使用者在控制檯輸入文字，並按下Enter鍵。輸入的文字預設為字串型別。

# 請求使用者輸入並儲存到變數中
user_input = input("請輸入一些內容: ")

# 列印使用者輸入的內容
print("你輸入的內容是: " + user_input)

如果你需要使用者輸入一個特定的資料型別，比如整數或浮點數，你可能需要使用int()或float()函式來轉換輸入的字串。

# 請求使用者輸入一個整數
user_number = int(input("請輸入一個整數: "))

# 使用輸入的整數
print("你輸入的整數是: " + str(user_number))

輸出（Output）

Python使用print()函式來輸出內容到控制檯。這個函式可以接受多個引數，並且可以格式化輸出。

基本輸出

# 列印簡單的文字
print("Hello, World!")

列印多個引數

# 列印多個引數，用空格分隔
print("Hello", "World", "!")

格式化輸出

Python支援多種字串格式化方法，包括傳統的%運算子、str.format()方法和f-string（Python 3.6+）。

使用%運算子：

name = "Kimi"
age = 30
print("我的名字是%s, 我的年齡是%d" % (name, age))

使用str.format()方法：

name = "Kimi"
age = 30
print("我的名字是{name}, 我的年齡是{age}".format(name=name, age=age))

使用f-string：

name = "Kimi"
age = 30
print(f"我的名字是{name}, 我的年齡是{age}")

f-string是格式化字串的現代方法，它簡潔且易於閱讀。在f-string中，你只需在字串前加上f，然後將變數放在花括號{}中即可。

列印到檔案

除了列印到控制檯，Python也可以將輸出重定向到檔案。

# 開啟一個檔案用於寫入
with open('output.txt', 'w') as file:
    file.write("這是檔案中的內容。\n")

# 追加內容到檔案
with open('output.txt', 'a') as file:
    file.write("這是追加的內容。\n")

在這個例子中，with語句用於開啟檔案，確保在操作完成後自動關閉檔案。'w'模式表示寫入模式，如果檔案已存在，它會被覆蓋；'a'模式表示追加模式，內容會被新增到檔案末尾。

這些是Python中進行基本輸入和輸出操作的方法。透過這些方法，你可以與使用者互動，處理資料，並將結果輸出到螢幕或檔案中。

1.4python中的運算子

Python提供了豐富的運算子來執行各種數學和邏輯運算。以下是Python中常用的運算子：

算術運算子

用於執行基本的數學運算。

加法（+）：5 + 3 結果為 8
減法（-）：5 - 3 結果為 2
乘法（*）：5 * 3 結果為 15
除法（/）：5 / 3 結果為 1.6666666666666667
整除（//）：5 // 3 結果為 1（返回商的整數部分）
模運算（%）：5 % 3 結果為 2（返回餘數）
指數運算（**）：5 ** 3 結果為 125（5的3次方）

比較運算子

用於比較兩個值，並返回布林值（True 或 False）。

等於（==）：5 == 3 結果為 False
不等於（!=）：5 != 3 結果為 True
大於（>）：5 > 3 結果為 True
小於（<）：5 < 3 結果為 False
大於等於（>=）：5 >= 3 結果為 True
小於等於（<=）：5 <= 3 結果為 False

賦值運算子

用於給變數賦值。

簡單賦值（=）：x = 5
複合賦值（+=, -=, *=, /=, //=, %=, **=）：
- x += 3 等同於 x = x + 3
- x -= 3 等同於 x = x - 3
- x *= 3 等同於 x = x * 3
- x /= 3 等同於 x = x / 3
- x //= 3 等同於 x = x // 3
- x %= 3 等同於 x = x % 3
- x **= 3 等同於 x = x ** 3

邏輯運算子

用於執行布林邏輯運算。

邏輯與（and）：True and False 結果為 False
邏輯或（or）：True or False 結果為 True
邏輯非（not）：not True 結果為 False

位運算子

用於對二進位制位進行操作。

按位與（&）：0b101 & 0b110 結果為 0b100
按位或（|）：0b101 | 0b110 結果為 0b111
按位異或（^）：0b101 ^ 0b110 結果為 0b011
按位非（~）：~0b101 結果為 -0b110（注意：Python中沒有無符號整數型別）
左移（<<）：0b101 << 1 結果為 0b110
右移（>>）：0b101 >> 1 結果為 0b001

成員運算子

用於檢查某個值是否存在於序列中。

屬於（in）：'a' in 'abc' 結果為 True
不屬於（not in）：'b' not in 'abc' 結果為 False

身份運算子

用於比較兩個物件的記憶體身份。

身份相等（is）：x is y 檢查 x 和 y 是否為同一個物件
身份不等（is not）：x is not y 檢查 x 和 y 是否不是同一個物件

這些運算子在Python程式設計中非常常用，它們使得程式碼更加簡潔和強大。

2.python中的列表、元組、字典、集合

2.1列表

在Python中，列表（List）是一種內建的資料結構，它是一個有序的元素集合，可以包含不同型別的元素，並且元素可以重複。列表是可變的，這意味著你可以在列表中隨時新增、刪除或更改元素。

以下是Python列表的一些關鍵特性：

有序：列表中的元素有明確的順序，這個順序是按照元素被新增到列表的順序確定的。
可變：你可以修改列表的內容，比如新增、刪除或替換元素。
異構：列表可以包含不同型別的元素，例如整數、浮點數、字串，甚至是其他列表。
動態大小：列表的大小可以根據需要動態變化。
索引：列表中的每個元素都有一個索引，這是它在列表中的位置，索引從0開始。
切片：你可以使用切片操作來獲取列表的一部分。
方法豐富：列表提供了大量的方法來操作列表，比如append()、extend()、insert()、remove()、pop()、sort()等。

以下是一些使用列表的示例：

# 建立一個列表
my_list = [1, 2, 3, 4, 5]

# 訪問列表中的元素
print(my_list[0])  # 輸出第一個元素，索引為0

# 修改列表中的元素
my_list[1] = 20

# 新增元素到列表末尾
my_list.append(6)

# 插入元素到指定位置
my_list.insert(1, 'a')

# 刪除列表末尾的元素
last_item = my_list.pop()

# 刪除指定位置的元素
del my_list[1]

# 列表切片
sub_list = my_list[1:3]  # 獲取索引1到2的元素

# 列表長度
print(len(my_list))  # 輸出列表中的元素數量

# 檢查元素是否在列表中
print(2 in my_list)  # 輸出 True 或 False

# 列表排序
my_list.sort()

# 列表反轉
my_list.reverse()

# 列表複製
new_list = my_list.copy()

列表是Python中非常靈活和強大的資料結構，它在程式設計中有著廣泛的應用，比如儲存資料集合、處理序列化資料等。

2.2元組

在Python中，元組（Tuple）是一種內建的資料結構，它與列表類似，也是有序的元素集合。然而，與列表的主要區別在於元組是不可變的，這意味著一旦元組被建立，你就不能修改它的元素。

以下是Python元組的一些關鍵特性：

有序：元組中的元素有明確的順序。
不可變：元組一旦建立，其內容就不能被修改。這意味著你不能新增、刪除或更改元組中的元素。
異構：元組可以包含不同型別的元素。
索引：元組中的每個元素都有一個索引，索引從0開始。
切片：與列表一樣，你可以使用切片操作來獲取元組的一部分。
方法較少：與列表相比，元組提供的方法較少，因為元組不支援修改操作。
不可變性帶來的優勢：由於元組的不可變性，它們在多執行緒環境中更安全，可以作為字典的鍵，而列表則不能。

以下是一些使用元組的示例：

# 建立一個元組
my_tuple = (1, 2, 3, 4, 5)

# 訪問元組中的元素
print(my_tuple[0])  # 輸出第一個元素

# 修改元組元素的嘗試將導致錯誤
# my_tuple[1] = 20  # 這將丟擲 TypeError

# 元組切片
sub_tuple = my_tuple[1:3]  # 獲取索引1到2的元素

# 元組長度
print(len(my_tuple))  # 輸出元組中的元素數量

# 檢查元素是否在元組中
print(2 in my_tuple)  # 輸出 True 或 False

# 元組複製
new_tuple = my_tuple.copy()

由於元組的不可變性，它們通常用於保護資料不被更改，或者在函式中返回多個值。例如：

def get_user_info():
    # 假設我們從資料庫獲取了使用者資訊
    user_id = 1
    username = "Kimi"
    email = "kimi@example.com"
    return user_id, username, email  # 返回一個元組

# 使用返回的元組
user_id, username, email = get_user_info()
print(f"User ID: {user_id}, Username: {username}, Email: {email}")

在這個例子中，函式get_user_info返回了一個包含三個元素的元組，分別代表使用者的ID、使用者和電子郵件。由於元組的不可變性，這些返回的值在函式外部是安全的，不會被意外修改。

2.3字典

在Python中，字典（Dictionary）是一種內建的資料結構，它儲存鍵值對（key-value pairs）。字典是可變的，這意味著你可以在執行時新增、刪除或更改鍵值對。

以下是Python字典的一些關鍵特性：

無序：在Python 3.6之前，字典是無序的，即鍵值對的順序是不確定的。從Python 3.7開始，字典保持插入順序，即鍵值對按照插入的順序儲存。
可變：你可以修改字典的內容，比如新增、刪除或更改鍵值對。
鍵必須是不可變型別：字典的鍵必須是不可變型別，如字串、整數或元組。這是因為不可變型別可以被雜湊，而雜湊值用於快速檢索字典中的鍵值對。
值可以是任何型別：字典的值可以是任何資料型別，包括可變型別和不可變型別。
鍵唯一：字典中的鍵必須是唯一的，不能有重複的鍵。
索引：字典不是透過索引訪問的，而是透過鍵來檢索對應的值。
方法豐富：字典提供了大量的方法來操作字典，比如get()、keys()、values()、items()、update()、pop()、popitem()等。

以下是一些使用字典的示例：

# 建立一個字典
my_dict = {'name': 'Kimi', 'age': 30, 'city': 'Shanghai'}

# 訪問字典中的值
print(my_dict['name'])  # 輸出 'Kimi'

# 新增新的鍵值對
my_dict['email'] = 'kimi@example.com'

# 修改已有的鍵值對
my_dict['age'] = 31

# 刪除鍵值對
del my_dict['city']

# 使用pop方法刪除並返回值
removed_value = my_dict.pop('age', None)

# 獲取字典中的所有鍵
keys = my_dict.keys()

# 獲取字典中的所有值
values = my_dict.values()

# 獲取字典中的所有鍵值對
items = my_dict.items()

# 檢查鍵是否存在於字典中
print('name' in my_dict)  # 輸出 True 或 False

# 獲取字典的長度
print(len(my_dict))  # 輸出字典中的鍵值對數量

# 遍歷字典
for key, value in my_dict.items():
    print(f"{key}: {value}")

字典在Python中非常靈活和強大，它在程式設計中有著廣泛的應用，比如儲存配置資訊、快取資料、實現關聯陣列等。由於字典的鍵值對結構，它特別適合用於儲存和管理具有對映關係的資料。

2.4集合

在Python中，集合（Set）是一種內建的資料結構，它儲存唯一元素的無序集合。集合中的元素必須是可雜湊的，這意味著它們必須是不可變型別，如整數、浮點數、字串或元組。集合是可變的，這意味著你可以在集合中隨時新增或刪除元素。

以下是Python集合的一些關鍵特性：

無序：集合中的元素沒有固定的順序，每次迭代集合時元素的順序可能不同。
元素唯一：集合自動去除重複的元素，只保留唯一的元素。
可變：你可以修改集合的內容，比如新增或刪除元素。
無重複元素：集合不允許有重複的元素。如果你嘗試新增一個已經存在於集合中的元素，該元素不會被新增。
方法豐富：集合提供了大量的方法來操作集合，比如add()、remove()、discard()、clear()、union()、intersection()、difference()、symmetric_difference()等。

以下是一些使用集合的示例：

# 建立一個集合
my_set = {1, 2, 3, 4, 5}

# 新增元素到集合
my_set.add(6)

# 嘗試新增重複元素
my_set.add(3)  # 沒有效果，因為3已經在集合中了

# 刪除元素
my_set.remove(2)

# 刪除元素時不丟擲錯誤（如果元素不存在）
my_set.discard(7)

# 清空集合
my_set.clear()

# 建立另一個集合
another_set = {4, 5, 6, 7}

# 集合的並集
union_set = my_set.union(another_set)

# 集合的交集
intersection_set = my_set.intersection(another_set)

# 集合的差集
difference_set = my_set.difference(another_set)

# 集合的對稱差集
symmetric_difference_set = my_set.symmetric_difference(another_set)

# 檢查元素是否在集合中
print(3 in my_set)  # 輸出 True 或 False

# 獲取集合的長度
print(len(my_set))  # 輸出集合中的元素數量

# 遍歷集合
for element in my_set:
    print(element)

集合在Python中非常有用，特別是當你需要處理一組唯一的元素時。集合還常用於數學集合操作，如並集、交集、差集等。由於集合中的元素是無序的，所以它們不適合用作索引或需要有序元素的情況。

3.range、zip、enumerate

3.1range函式

Python 中的 range() 函式用於生成一個整數序列。這個函式非常靈活，可以根據你提供的引數生成不同的序列。range() 函式可以接收一到三個引數，具體如下：

不帶引數：當你不傳遞任何引數給 range() 時，它會生成一個從 0 開始到停止值預設為 100000 的序列。這通常不是你想要的，因此很少單獨使用 range()。
一個引數：如果你只傳遞一個引數 n 給 range()，它會生成一個從 0 到 n-1 的序列。
```
list(range(5))  # [0, 1, 2, 3, 4]
```
兩個引數：你可以傳遞兩個引數 start 和 stop 給 range()，它會生成一個從 start 到 stop-1 的序列。
```
list(range(2, 5))  # [2, 3, 4]
```
三個引數：range() 也可以接收三個引數 start、stop 和 step，它會生成一個從 start 開始，每次增加 step，直到 stop-1 的序列。
```
list(range(2, 10, 2))  # [2, 4, 6, 8]
```

range() 生成的是一個“範圍物件”（range object），這是一個可迭代的物件，可以在迴圈中直接使用，或者使用 list() 函式轉換成列表。轉換成列表後，你就可以使用列表的所有方法。

range() 也可以生成負數序列，只需將 step 引數設定為負數即可。

list(range(-5, 5, 1))  # [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]

range() 函式在迴圈中非常有用，尤其是在需要迭代一系列連續整數時。它比手動建立列表更加高效和簡潔。

3.2zip函式

Python 中的 zip() 函式是一個非常有用的內建函式，它用於將多個可迭代物件（如列表、元組、集合等）中對應的元素打包成一個個元組，然後返回由這些元組組成的物件。zip() 可以接收任意數量的可迭代引數，並且返回一個迭代器。

以下是 zip() 函式的一些基本用法：

合併兩個或多個列表：
你可以使用 zip() 來合併兩個或多個列表，將它們的元素配對成元組。

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
zipped = zip(list1, list2)
print(list(zipped))  # 輸出：[(1, 'a'), (2, 'b'), (3, 'c')]

與 * 運算子一起使用：
在 Python 3 中，你可以使用 * 運算子來解包引數。

*args = [1, 2, 3]
zipped = zip(*args)
print(list(zipped))  # 輸出：[(1,), (2,), (3,)]

處理不同長度的可迭代物件：
如果傳入的可迭代物件長度不同，zip() 會以最短的可迭代物件為界，停止合併。
```
list1 = [1, 2, 3]
list2 = ['a', 'b']
zipped = zip(list1, list2)
print(list(zipped))  # 輸出：[(1, 'a'), (2, 'b')]
```

與 map() 函式結合使用：
你可以將 zip() 與 map() 函式結合使用，對配對的元素執行操作。

list1 = [1, 2, 3]
list2 = [4, 5, 6]
zipped = zip(list1, list2)
summed = map(lambda x, y: x + y, *zipped)
print(list(summed))  # 輸出：[5, 7, 9]

使用 zip() 函式生成字典：
zip() 可以與 dict() 函式結合使用，快速生成字典。

keys = ['name', 'age', 'city']
values = ['Alice', 30, 'New York']
dictionary = dict(zip(keys, values))
print(dictionary)  # 輸出：{'name': 'Alice', 'age': 30, 'city': 'New York'}

使用 itertools.zip_longest() 處理不同長度的可迭代物件：
如果你需要在可迭代物件長度不同時填充缺失值，可以使用 itertools.zip_longest()。

from itertools import zip_longest
list1 = [1, 2, 3]
list2 = ['a', 'b']
zipped = zip_longest(list1, list2, fillvalue='None')
print(list(zipped))  # 輸出：[(1, 'a'), (2, 'b'), (3, 'None')]

zip() 函式是處理多個列表或序列時的強大工具，它可以幫助你輕鬆地將資料配對和組合。

3.3enumerate函式

Python 中的 enumerate() 函式是一個非常實用的內建函式，它用於將一個可迭代物件（如列表、元組、字串等）組合為一個索引序列，同時列出資料和資料下標。這在迴圈遍歷可迭代物件時非常有用，尤其是當你需要知道元素的索引時。

基本用法

enumerate() 函式的基本用法是提供一個可迭代物件，它返回一個列舉物件，該物件生成包含索引和值的元組。

my_list = ['apple', 'banana', 'cherry']
for index, value in enumerate(my_list):
    print(index, value)

這將輸出：

0 apple
1 banana
2 cherry

自定義起始索引

enumerate() 還允許你指定起始索引，這在索引不是從0開始的情況下非常有用。

my_list = ['apple', 'banana', 'cherry']
for index, value in enumerate(my_list, start=1):
    print(index, value)

這將輸出：

1 apple
2 banana
3 cherry

在 enumerate() 中使用列表推導式

你也可以在列表推導式中使用 enumerate()，這樣可以建立一個包含索引和值的新列表。

my_list = ['apple', 'banana', 'cherry']
enumerated_list = [(index, value) for index, value in enumerate(my_list)]
print(enumerated_list)

這將輸出：

[(0, 'apple'), (1, 'banana'), (2, 'cherry')]

使用 enumerate() 與字典

enumerate() 也可以用來建立字典，尤其是當你需要將列表轉換為字典，並且列表的元素作為值，索引作為鍵時。

my_list = ['apple', 'banana', 'cherry']
my_dict = {index: value for index, value in enumerate(my_list)}
print(my_dict)

這將輸出：

{0: 'apple', 1: 'banana', 2: 'cherry'}

enumerate() 函式是 Python 程式設計中常用的工具之一，它使得在迴圈中處理索引和值變得簡單直觀。透過使用 enumerate()，你可以避免使用傳統的 for 迴圈計數器，從而使程式碼更加清晰和易於維護。

4.序列、推導式、生成器與迭代器

4.1序列的切片

在Python中，序列的切片（Slicing）是一種強大的操作，它允許你從序列型別（如列表、元組、字串等）中提取出一部分元素，建立一個新的序列。切片操作透過指定起始索引、結束索引和步長來完成。

切片的基本語法如下：

sequence[start:end:step]

start：切片開始的索引（包含該索引處的元素）。
end：切片結束的索引（不包含該索引處的元素）。
step：步長，表示取元素的間隔。

如果省略某個引數，Python會使用預設值：

如果省略 start，它預設為0。
如果省略 end，它預設為序列的長度。
如果省略 step，它預設為1。

以下是一些切片操作的例子：

提取序列的一部分：

my_list = [0, 1, 2, 3, 4, 5]
print(my_list[1:4])  # 輸出 [1, 2, 3]

從頭開始切片：
```
print(my_list[:3])  # 輸出 [0, 1, 2]
```

從末尾切片到特定位置：

print(my_list[2:])  # 輸出 [2, 3, 4, 5]

切片到序列的末尾：
```
print(my_list[4:])  # 輸出 [4, 5]
```
使用負索引進行切片：
負索引表示從序列的末尾開始計數。
```
print(my_list[-3:-1])  # 輸出 [2, 3]
```

使用步長進行切片：
步長可以是正數或負數。

print(my_list[::2])  # 輸出 [0, 2, 4]，從開始到結束，步長為2
print(my_list[1::2])  # 輸出 [1, 3, 5]，從索引1開始到結束，步長為2
print(my_list[::-1])  # 輸出 [5, 4, 3, 2, 1, 0]，從末尾到開始，步長為-1（反轉序列）

切片賦值：
你可以對切片的結果進行賦值，這會修改原始序列。
```
my_list[1:3] = [10, 20]
print(my_list)  # 輸出 [0, 10, 20, 3, 4, 5]
```

切片是處理序列資料時非常有用的工具，它允許你快速訪問和修改序列的一部分，而不需要編寫複雜的迴圈結構。

4.2序列的基本操作

Python 中的序列型別（如列表和元組）提供了許多有用的方法來進行常見操作。以下是一些序列型別的常用操作：

列表特有操作

append(x)：在列表末尾新增一個元素 x。

lst = [1, 2, 3]
lst.append(4)
print(lst)  # 輸出：[1, 2, 3, 4]

extend(iterable)：將一個可迭代物件 iterable 的所有元素新增到列表末尾。
```
lst = [1, 2, 3]
lst.extend([4, 5])
print(lst)  # 輸出：[1, 2, 3, 4, 5]
```

insert(i, x)：在指定位置 i 新增一個元素 x。

lst = [1, 2, 4]
lst.insert(2, 3)
print(lst)  # 輸出：[1, 2, 3, 4]

remove(x)：移除列表中第一個值為 x 的元素。

lst = [1, 2, 3, 2, 4]
lst.remove(2)
print(lst)  # 輸出：[1, 3, 2, 4]

pop([i])：移除列表中位置 i 的元素，並返回該元素。如果不指定 i，預設移除並返回列表的最後一個元素。
```
lst = [1, 2, 3, 4]
item = lst.pop(1)
print(item)  # 輸出：2
print(lst)  # 輸出：[1, 3, 4]
```

clear()：清空列表中的所有元素。

lst = [1, 2, 3]
lst.clear()
print(lst)  # 輸出：[]

index(x[, start[, end]])：返回列表中第一個值為 x 的元素的索引，可以指定搜尋的起始和結束位置。
```
lst = [1, 2, 3, 2, 4]
print(lst.index(2))  # 輸出：1
```

count(x)：返回元素 x 在列表中出現的次數。

lst = [1, 2, 3, 2, 4]
print(lst.count(2))  # 輸出：2

sort(key=None, reverse=False)：對列表中的元素進行排序。
```
lst = [4, 1, 3, 2]
lst.sort()
print(lst)  # 輸出：[1, 2, 3, 4]
```

reverse()：反轉列表中的元素順序。

lst = [1, 2, 3, 4]
lst.reverse()
print(lst)  # 輸出：[4, 3, 2, 1]

元組特有操作

元組是不可變的，所以沒有像列表那樣的修改操作，如 append()、extend()、insert()、remove()、pop() 等。但是，元組支援以下操作：

count(x)：返回元素 x 在元組中出現的次數。

tup = (1, 2, 3, 2, 4)
print(tup.count(2))  # 輸出：2

index(x[, start[, end]])：返回元組中第一個值為 x 的元素的索引，可以指定搜尋的起始和結束位置。
```
tup = (1, 2, 3, 2, 4)
print(tup.index(2))  # 輸出：1
```

通用操作

切片：獲取序列的一部分。

seq = [0, 1, 2, 3, 4, 5]
print(seq[1:4])  # 輸出：[1, 2, 3]

len(seq)：獲取序列的長度。

seq = [0, 1, 2, 3, 4, 5]
print(len(seq))  # 輸出：6

成員檢查：
- x in seq：檢查 x 是否是序列的元素。
- x not in seq：檢查 x 是否不是序列的元素。
```
seq = [0, 1, 2, 3, 4, 5]
print(2 in seq)  # 輸出：True
print(6 in seq)  # 輸出：False
```

max(seq) 和 min(seq)：獲取序列中的最大值和最小值。

seq = [3, 1, 4, 1, 5, 9, 2]
print(max(seq))  # 輸出：9
print(min(seq))  # 輸出：1

sum(seq)：計算序列中所有元素的總和。

seq = [1, 2, 3, 4, 5]
print(sum(seq))  # 輸出：15

這些操作是處理Python序列時的基礎工具，它們使得資料操作變得簡單而高效。

4.3列表推導式

列表推導式（List Comprehension）是Python中建立列表的一種簡潔而強大的工具。它允許你透過一個現有的列表或任何可迭代物件來建立一個新的列表，同時可以應用條件過濾和複雜的表示式。

基本語法

列表推導式的基本語法如下：

[expression for item in iterable if condition]

expression：對每個元素進行的操作或計算。
item：來自 iterable 的每個元素的變數名。
iterable：一個可迭代物件，如列表、元組、字串等。
condition：（可選）一個布林表示式，用於過濾結果。

示例

基本列表推導式：

squares = [x**2 for x in range(10)]
print(squares)  # 輸出：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

帶有條件的列表推導式：

even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares)  # 輸出：[0, 4, 16, 36, 64]

使用多個迴圈的列表推導式：

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(flattened)  # 輸出：[1, 2, 3, 4, 5, 6, 7, 8, 9]

對字典的鍵或值進行列表推導式：

dict = {'a': 1, 'b': 2, 'c': 3}
keys = [key for key in dict]
values = [value for value in dict.values()]
print(keys)      # 輸出：['a', 'b', 'c']
print(values)    # 輸出：[1, 2, 3]

對字典的鍵值對進行列表推導式：

dict = {'a': 1, 'b': 2, 'c': 3}
items = [(key, value) for key, value in dict.items()]
print(items)    # 輸出：[('a', 1), ('b', 2), ('c', 3)]

使用條件和表示式的組合：

numbers = [1, 2, 3, 4, 5, 6]
multiples_of_three = [num for num in numbers if num % 3 == 0]
print(multiples_of_three)  # 輸出：[3, 6]

列表推導式不僅使程式碼更加簡潔，而且通常比等效的 for 迴圈執行得更快。它們是處理列表和可迭代物件的強大工具，能夠使程式碼更加Pythonic。

4.4生成器與迭代器

在Python中，迭代器（Iterator）和生成器（Generator）是處理資料集合時非常有用的抽象概念，它們允許我們逐個處理資料集中的元素，而不必一次性將整個資料集合載入到記憶體中。

迭代器（Iterator）

迭代器是一個實現了迭代器協議的物件，這意味著它有兩個方法：__iter__() 和 __next__()。迭代器從集合的開始到結束進行遍歷，並且你可以隨時檢查迭代器是否還有更多的元素。

迭代器的特點：

一次遍歷：迭代器只能遍歷一次，一旦遍歷完成，它就會變得無效。
惰性計算：迭代器不會立即載入所有元素，而是在需要的時候才生成下一個元素。

建立迭代器的示例：

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __iter__(self):
        return self

    def __next__(self):
        if self.index < len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration

# 使用迭代器
my_iter = MyIterator([1, 2, 3, 4])
for value in my_iter:
    print(value)

生成器（Generator）

生成器是一種特殊的迭代器，它透過使用 yield 語句來產生值。每次迭代時，生成器會返回 yield 表示式的值，並且會在下一次迭代時從它離開的地方繼續執行。

生成器的特點：

惰性計算：生成器只在需要的時候計算下一個值，這使得它們在處理大型資料集時非常高效。
狀態儲存：生成器儲存了迭代的狀態，包括變數值和執行位置，使得它們可以在每次 yield 之後恢復執行。

建立生成器的示例：

def my_generator(data):
    for value in data:
        yield value  # 生成器透過 yield 返回值

# 使用生成器
my_gen = my_generator([1, 2, 3, 4])
for value in my_gen:
    print(value)

生成器還可以使用 yield from 來從一個生成器中委託給另一個生成器：

def nested_generator():
    yield from [1, 2, 3, 4]

# 使用巢狀生成器
for value in nested_generator():
    print(value)

生成器和迭代器是Python中強大的工具，它們允許你以一種高效且記憶體友好的方式來處理資料集合。生成器特別適用於資料流和大型資料集，因為它們不需要一次性將所有資料載入到記憶體中。

5.程式流程控制

5.1分支結構

Python中的分支結構主要透過if、elif和else語句來實現。這些語句允許程式根據條件判斷來執行不同的程式碼塊。下面是Python中分支結構的基本用法：

單分支 if

if 條件:
    # 條件為真時執行的程式碼塊

雙分支 if-else

if 條件:
    # 條件為真時執行的程式碼塊
else:
    # 條件為假時執行的程式碼塊

多分支 if-elif-else

if 條件1:
    # 條件1為真時執行的程式碼塊
elif 條件2:
    # 條件1為假且條件2為真時執行的程式碼塊
else:
    # 所有條件都為假時執行的程式碼塊

示例

x = 20
if x < 10:
    print("x is less than 10")
elif x < 20:
    print("x is less than 20 but not less than 10")
else:
    print("x is 20 or more")

在這個例子中，x 的值為 20，所以程式會檢查每個條件，直到找到滿足條件的分支。由於 x 不小於 10，第一個 if 分支被跳過。然後，由於 x 小於 20 的條件也不成立，程式執行 else 分支。

使用 in 和 not in

你還可以在 if 語句中使用 in 和 not in 來檢查某個元素是否存在於序列中。

my_list = [1, 2, 3, 4]
if 2 in my_list:
    print("2 is in the list")
if "Kimi" not in my_list:
    print("Kimi is not in the list")

巢狀 if 語句

if 語句可以巢狀在其他 if 語句內部，這允許你建立複雜的邏輯。

x = 10
y = 5
if x > y:
    if x > 10:
        print("x is greater than 10")
    else:
        print("x is greater than y but less than or equal to 10")
else:
    print("x is not greater than y")

分支結構是控制流語言中的基礎，它允許程式根據條件執行不同的程式碼路徑。在Python中，分支結構通常用於決策制定，例如在函式中根據輸入引數的不同執行不同的邏輯，或者在程式中根據使用者的選擇來執行不同的操作。

5.2迴圈結構

Python中的迴圈結構允許你重複執行一段程式碼，直到滿足特定的條件。主要有兩種型別的迴圈結構：for 迴圈和 while 迴圈。

for 迴圈

for 迴圈通常用於遍歷序列（如列表、元組、字串等）或其他可迭代物件。

基本語法：

for 變數 in 可迭代物件:
    # 迴圈體，對每個元素執行的操作

示例：

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

for 迴圈也可以使用 range() 函式生成一系列數字：

for i in range(5):
    print(i)  # 輸出：0 1 2 3 4

while 迴圈

while 迴圈會一直執行，直到指定的條件不再為真。

基本語法：

while 條件:
    # 迴圈體，只要條件為真就執行

示例：

count = 0
while count < 5:
    print(count)
    count += 1  # 遞增計數器

迴圈控制語句

在迴圈中，你可能需要提前退出迴圈或者跳過某些迭代。Python提供了兩個這樣的語句：break 和 continue。

break：立即終止迴圈。
continue：跳過當前迭代，繼續執行下一次迭代。

示例使用 break：

for num in range(10):
    if num == 5:
        break
    print(num)
# 輸出：0 1 2 3 4

示例使用 continue：

for num in range(10):
    if num % 2 == 0:
        continue
    print(num)
# 輸出：1 3 5 7 9

else 子句與迴圈

Python的迴圈還支援 else 子句。如果迴圈正常結束（即不是因為 break 語句退出的），則執行 else 塊。

示例：

for i in range(3):
    print(i)
else:
    print("迴圈結束")
# 輸出：
# 0
# 1
# 2
# 迴圈結束

如果迴圈中包含 break 語句，且 break 被執行，則 else 塊不會被執行。

for i in range(3):
    print(i)
    if i == 1:
        break
else:
    print("迴圈結束")
# 輸出：
# 0
# 1
# 迴圈不會執行 "迴圈結束" 的輸出

迴圈結構是程式設計中處理重複任務的基本工具，它們使得程式碼更加簡潔，減少了重複程式碼的編寫。在Python中，for 迴圈和 while 迴圈各有適用場景，可以根據需要選擇使用。

6.函式

6.1python函式的定義

在Python中定義函式是一個將重複使用的程式碼塊封裝起來的過程，使其可以被多次呼叫。以下是定義函式的基本步驟：

使用 def 關鍵字開始定義函式。
指定函式的名稱，這應該描述函式的功能。
在圓括號 () 內，可以定義零個或多個引數，這些引數是函式呼叫時接收的輸入值。
函式的第一行程式碼之後是一個冒號 :。
縮排的程式碼塊構成了函式體，即當函式被呼叫時將執行的程式碼。
函式可以透過 return 語句返回值。

下面是一個定義函式的示例：

def say_hello(name):
    ""“這是一個簡單的函式，用於列印歡迎資訊。”""
    print(f"Hello, {name}!")

在這個例子中，say_hello 是函式的名稱，name 是函式的引數，花括號 {} 中的字串是函式的文件字串（docstring），它是一個字串文字，用來描述函式的功能。文件字串是可選的，但它是一個很好的程式設計習慣，因為它可以讓閱讀程式碼的人更容易理解函式的用途和行為。

函式定義後，可以透過提供必要的引數來呼叫它：

say_hello("Chengfu")  # 輸出：Hello, Chengfu!

在定義函式時，還可以為引數設定預設值，使其成為可選引數：

def say_hello(name, message="Hello"):
    print(f"{message}, {name}!")

say_hello("Chengfu")          # 使用預設訊息
say_hello("Chengfu", "Hi")   # 使用自定義訊息

此外，Python允許使用可變數量的引數，這使得函式可以接收任意數量的引數：

def sum_numbers(*args):
    total = 0
    for num in args:
        total += num
    return total

# 可以傳遞任意數量的數值引數
print(sum_numbers(1, 2, 3, 4, 5))  # 輸出：15

在定義函式時，你可以使用 * 來收集所有未命名的額外引數到一個元組中，使用 ** 來收集命名引數到一個字典中：

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Chengfu", country="Moonshot", job="AI Assistant")

這將輸出：

name: Chengfu
country: Moonshot
job: AI Assistant

定義函式是Python程式設計的基礎，它有助於程式碼的模組化和重用。透過定義函式，你可以建立更清晰、更易於維護的程式碼。

6.2形參與實參

我們來重新看一下形參（Parameter）和實參（Argument）的概念，。

形參（Parameter）

形參是在函式定義中宣告的變數名，用於在函式呼叫時接收傳遞進來的值。這些變數在函式體內部被視為區域性變數。

示例：

def introduce(title, name):
    print(f"{title}, {name}!")

在這個例子中，title 和 name 是形參。

實參（Argument）

實參是在呼叫函式時實際傳遞給函式的具體值。實參可以是字面量、變數、表示式或任何可產生值的實體。

示例：

introduce("Mr", "John")

在這裡，"Mr" 和 "John" 是實參。

形參與實參的關係

函式呼叫時，實參會按照函式定義中形參的順序傳遞給形參。如果函式定義中某個引數有預設值，那麼在呼叫時可以省略該引數對應的實參，此時形參會被賦予預設值。

示例：

# 定義函式時，title 和 name 是形參
def introduce(title, name="Smith"):
    print(f"{title}, {name}!")

# 呼叫函式時，"Mr" 是實參，對應形參 title
# 由於沒有傳遞 name 的實參，形參 name 使用預設值 "Smith"
introduce("Mr")

輸出：

Mr, Smith!

如果呼叫函式時傳遞的實引數量多於形參，那麼多餘部分的實參將會被忽略，除非函式使用了 *args 或 **kwargs 來收集多餘的引數。

示例：

def greet(name):
    print(f"Hello, {name}!")

# 呼叫函式時傳遞了兩個實參，但函式定義中只有一個形參
greet("Alice", "Bob")  # "Bob" 會被忽略

輸出：

Hello, Alice!

理解形參和實參的概念對於掌握函式的使用和呼叫至關重要。希望這些例子有助於你更好地理解這些概念。

6.3變數的作用域

在Python中，變數的作用域（Scope）決定了變數在程式中的可見性和生命週期。變數的作用域主要分為以下幾種：

區域性作用域（Local Scope）：

區域性變數是在函式內部定義的變數，它們只能在該函式內部被訪問。

例子：

def my_function():
    x = 5  # x是區域性變數
    print(x)

my_function()
# print(x)  # 這將引發錯誤，因為x不在區域性作用域之外可見

全域性作用域（Global Scope）：
- 全域性變數是在所有函式之外定義的變數，它們可以在整個程式中被訪問。
- 例子：
```
y = 10  # y是全域性變數

def my_function():
    print(y)

my_function()
print(y)
```
內建作用域（Built-in Scope）：
- 內建變數是Python直譯器內建的變數，它們屬於Python的內建名稱空間。
- 例子：
```
print(len("Hello World"))  # len是內建函式
```
封裝作用域（Enclosing Scope）：
- 如果一個函式巢狀在另一個函式內部，那麼內部函式可以訪問外部函式的區域性變數。
- 例子：
```
def outer_function():
    z = 15
    def inner_function():
        print(z)  # z在外部函式的區域性作用域中
    inner_function()

outer_function()
```
類作用域（Class Scope）：
- 類變數是屬於類的變數，它們在類的內部定義，可以被類的所有例項訪問。
- 例子：
```
class MyClass:
    class_var = 20

print(MyClass.class_var)
```
名稱空間（Namespace）：
- Python使用名稱空間來儲存物件引用，每個變數名都與一個名稱空間相關聯。
- 名稱空間分為：__builtins__（內建名稱空間）、__main__（全域性名稱空間）和模組名稱空間。

理解變數的作用域對於編寫清晰的程式非常重要。它決定了變數的生命週期，以及變數在程式中不同部分的可見性。正確地管理作用域可以避免命名衝突，並提高程式碼的模組化和可維護性。

6.4函式的型別

在Python中，函式本身也是一種物件，因此可以像任何其他物件一樣被處理。函式物件可以被分配給變數，可以作為引數傳遞給其他函式，也可以作為函式的返回值。以下是一些與函式型別相關的要點：

普通函式：
這是最常用的函式型別，使用 def 關鍵字定義。
```
def my_function():
    pass
```
匿名函式（Lambda函式）：
使用 lambda 關鍵字定義的匿名函式，常用於建立簡單的、一次性使用的函式。
```
square = lambda x: x * x
print(square(4))  # 輸出：16
```

巢狀函式：
在另一個函式內部定義的函式，可以訪問外部函式的區域性變數（除了引數）。

def outer_function():
    def inner_function():
        print("Hello from inner function")
    return inner_function
my_function = outer_function()
my_function()  # 輸出：Hello from inner function

遞迴函式：
呼叫自身的函式稱為遞迴函式，通常用於處理重複的任務。

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)
print(factorial(5))  # 輸出：120

高階函式：
高階函式是接受函式作為引數或返回函式作為結果的函式。

def greet(name):
    def say_hello():
        print(f"Hello, {name}!")
    return say_hello
my_greet = greet("Alice")
my_greet()  # 輸出：Hello, Alice!

生成器函式：
使用 yield 關鍵字定義的函式，用於建立迭代器。

def count_up_to(max):
    n = 1
    while n <= max:
        yield n
        n += 1
counter = count_up_to(5)
for number in counter:
    print(number)  # 輸出：1 2 3 4 5

靜態函式（在類定義中）：
使用 @staticmethod 裝飾器定義的函式，它不接收類或例項的引用。

class MyClass:
    @staticmethod
    def my_static_function():
        print("This is a static method.")
MyClass.my_static_function()  # 輸出：This is a static method.

類方法（在類定義中）：
使用 @classmethod 裝飾器定義的函式，它接收類作為第一個引數。

class MyClass:
    @classmethod
    def my_class_method(cls):
        print(f"This is a class method of {cls}")
MyClass.my_class_method()  # 輸出：This is a class method of <class '__main__.MyClass'>

例項方法（在類定義中）：
在類中定義但不使用 @staticmethod 或 @classmethod 裝飾器的函式，它們接收例項作為第一個引數。

class MyClass:
    def my_instance_method(self):
        print("This is an instance method.")
instance = MyClass()
instance.my_instance_method()  # 輸出：This is an instance method.

這些不同型別的函式提供了靈活性，允許你根據需要選擇最合適的函式型別來實現特定的功能。

7.python的常用內建函式

7.1python主要的內建函式

函式名	描述	示例
`abs()`	返回數的絕對值	`abs(-10)` 返回 `10`
`all()`	所有元素為真時返回True	`all([True, True, False])` 返回 `False`
`any()`	任一元素為真時返回True	`any([False, False, True])` 返回 `True`
`ascii()`	返回物件的ASCII表示式	`ascii(123)` 返回 `'123'`
`bin()`	將整數轉換為二進位制字串	`bin(10)` 返回 `'0b1010'`
`bool()`	將值轉換為布林型別	`bool([])` 返回 `False`
`bytearray()`	建立一個可變的位元組陣列	`bytearray([1, 2, 3])`
`bytes()`	建立一個不可變的位元組物件	`bytes([72, 101, 108, 108, 111])` 返回 `b'Hello'`
`chr()`	將ASCII碼轉換為對應的字元	`chr(65)` 返回 `'A'`
`complex()`	建立一個複數	`complex(1, 2)` 返回 `(1+2j)`
`dict()`	建立一個字典	`dict([['one', 1], ['two', 2]])` 返回 `{'one': 1, 'two': 2}`
`divmod()`	同時得到除法的商和餘數	`divmod(10, 3)` 返回 `(3, 1)`
`enumerate()`	將一個可遍歷的資料物件(如列表、元組或字串)組合為一個索引序列，同時列出資料和資料下標	`list(enumerate(['a', 'b', 'c']))` 返回 `[(0, 'a'), (1, 'b'), (2, 'c')]`
`eval()`	計算表示式的值，並返回結果	`eval('1 + 2')` 返回 `3`
`exec()`	執行動態Python程式碼	`exec('print("Hello World")')` 列印 `Hello World`
`filter()`	使用函式過濾序列，過濾掉不符合條件的元素，返回一個迭代器	`list(filter(lambda x: x > 1, [1, 2, 3, 4]))` 返回 `[2, 3, 4]`
`float()`	將值轉換為浮點數	`float('3.14')` 返回 `3.14`
`format()`	格式化物件	`format(12.34, '.2f')` 返回 `'12.34'`
`frozenset()`	建立一個不可變集合	`frozenset([1, 2, 3])`
`getattr()`	獲取物件屬性	`getattr(math, 'sin')` 返回 `<function sin>`
`globals()`	返回當前全域性符號表的字典	`globals()`
`hasattr()`	檢查物件是否包含某個屬性	`hasattr(math, 'sin')` 返回 `True`
`hash()`	返回物件的雜湊值	`hash((1, 2))`
`help()`	獲取物件的幫助資訊	`help(print)`
`hex()`	將整數轉換為十六進位制字串	`hex(255)` 返回 `'0xff'`
`id()`	返回物件的記憶體地址	`id([1, 2, 3])`
`input()`	獲取使用者輸入的字串	`input("Enter something: ")`
`int()`	將值轉換為整數	`int('123')` 返回 `123`
`isinstance()`	檢查例項是否是類或派生類的例項	`isinstance(3, int)` 返回 `True`
`issubclass()`	檢查一個類是否是另一個類的子類	`issubclass(int, float)` 返回 `False`
`iter()`	返回物件的迭代器	`iter([1, 2, 3])`
`len()`	獲取物件的長度	`len([1, 2, 3])` 返回 `3`
`list()`	將物件轉換為列表	`list((1, 2, 3))` 返回 `[1, 2, 3]`
`locals()`	返回當前區域性符號表的字典	`locals()`
`map()`	使用給定函式對映序列的每個元素	`list(map(lambda x: x + 1, [1, 2, 3]))` 返回 `[2, 3, 4]`
`max()`	獲取可迭代物件中的最大值	`max([1, 2, 3])` 返回 `3`
`memoryview()`	建立物件的記憶體檢視	`memoryview(b'Hello')`
`min()`	獲取可迭代物件中的最小值	`min([1, 2, 3])` 返回 `1`
`next()`	返回迭代器的下一個專案	`next(iter([1, 2, 3]))` 返回 `1`
`object()`	建立一個新物件	`object()`
`oct()`	將整數轉換為八進位制字串	`oct(10)` 返回 `'0o12'`
`open()`	開啟一個檔案，並返回檔案物件	`open('file.txt', 'r')`
`ord()`	返回字元的ASCII碼	`ord('A')` 返回 `65`
`pow()`	返回x的n次冪	`pow(2, 3)` 返回 `8`
`print()`	列印物件	`print("Hello World")`
`property()`	建立屬性	`property()`
`range()`	建立一個整數序列	`range(3)` 返回 `range(0, 3)`
`repr()`	獲取物件的官方字串表示	`repr(True)` 返回 `'True'`
`reversed()`	反轉序列	`list(reversed([1, 2, 3]))` 返回 `[3, 2, 1]`
`round()`	四捨五入	`round(3.14)` 返回 `3`
`set()`	建立一個可變集合	`set([1, 2, 3])`
`setattr()`	設定物件屬性	`setattr(math, 'sqrt', lambda x: x**0.5)`
`slice()`	建立一個切片物件	`slice(1, 3, 1)`
`sorted()`	排序可迭代物件	`sorted([3, 1, 2])` 返回 `[1, 2, 3]`
`staticmethod()`	建立靜態方法	`staticmethod()`
`str()`	將物件轉換為字串	`str(123)` 返回 `'123'`
`sum()`	計算可迭代物件的總和	`sum([1, 2, 3])` 返回 `6`
`super()`	返回物件的超級代理	`super()`
`tuple()`	將物件轉換為元組	`tuple([1, 2, 3])` 返回 `(1, 2, 3)`
`type()`	獲取物件的型別	`type(123)` 返回 `<class 'int'>`
`vars()`	以字典的形式返回物件的屬性	`vars(123)`
`zip()`	將多個迭代器的對應元素打包為元組	`list(zip([1, 2], ['a', 'b']))` 返回 `[(1, 'a'), (2, 'b')]`

7.2eval函式

Python 中的 eval() 函式是一個內建函式，它用於計算字串表示式的值。當傳給 eval() 的字串引數是一個有效的 Python 表示式時，eval() 會計算該表示式並返回結果。

基本用法

result = eval(expression)

這裡的 expression 是一個字串，它包含了一個有效的 Python 表示式。eval() 函式會計算這個表示式並返回結果。

示例

# 計算簡單的算術表示式
print(eval('1 + 2'))  # 輸出：3

# 計算更復雜的表示式
print(eval('10 * (2 + 3)'))  # 輸出：50

# 使用變數名
x = 5
print(eval('x + 1'))  # 輸出：6，因為 eval() 可以訪問外部變數 x

# 呼叫函式
print(eval('len("Hello World")'))  # 輸出：11

7.3filter函式

Python 中的 filter() 函式是一個內建函式，用於過濾序列，過濾掉不符合條件的元素，返回一個迭代器。filter() 函式把一個函式和一個序列作為引數，返回一個迭代器，該迭代器包含所有使得函式返回值為True的元素。

基本語法

filter(function, iterable)

function：這是一個函式，它接收一個引數，返回一個布林值（True或False）。
iterable：這是一個序列，它的每個元素都將傳給function函式進行判斷。

示例

# 定義一個簡單的過濾函式
def is_even(num):
    return num % 2 == 0

# 使用 filter() 函式過濾列表
numbers = [1, 2, 3, 4, 5, 6]
even_numbers = filter(is_even, numbers)

# 將 filter() 物件轉換為列表
print(list(even_numbers))  # 輸出：[2, 4, 6]

你也可以使用 lambda 表示式來簡化這個過程：

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers))  # 輸出：[2, 4, 6]

使用場景

filter() 函式常用於從序列中提取符合條件的元素。例如，從一個列表中提取所有偶數，或者從一個字串列表中提取所有以特定字母開頭的字串。

注意事項

filter() 返回的是一個迭代器，如果你需要一個列表，可以使用 list() 函式進行轉換。
filter() 函式不會修改原始序列，它返回一個新的迭代器。
如果序列很大，使用 filter() 可以節省記憶體，因為它是惰性計算的，即它只有在需要的時候才會計算下一個元素。

與列表推導式比較

雖然 filter() 函式很有用，但在Python中，列表推導式通常更受歡迎，因為它們更簡潔，更易於閱讀：

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = [x for x in numbers if x % 2 == 0]
print(even_numbers)  # 輸出：[2, 4, 6]

儘管如此，filter() 函式在某些情況下仍然很有用，特別是在你需要一個迭代器而不是列表時，或者當你需要將過濾邏輯與函式分離時。

7.4map函式

Python 中的 map() 函式是一個內建函式，它允許你將一個給定的函式應用於一個序列（或多個序列）的所有專案，並返回一個包含結果的迭代器。

基本語法

map(function, iterable, ...)

function：這是要應用於每個元素的函式。
iterable：這是一個或多個序列（如列表、元組、字串等），函式將依次應用於這些序列的每個元素。

示例

# 定義一個簡單的函式，用於加倍數值
def double_number(num):
    return num * 2

# 使用 map() 函式將 double_number 函式應用於數字列表
numbers = [1, 2, 3, 4]
doubled_numbers = map(double_number, numbers)

# 將 map 物件轉換為列表
print(list(doubled_numbers))  # 輸出：[2, 4, 6, 8]

如果你不想定義一個函式，你可以使用 lambda 表示式：

numbers = [1, 2, 3, 4]
doubled_numbers = map(lambda x: x * 2, numbers)
print(list(doubled_numbers))  # 輸出：[2, 4, 6, 8]

多個序列

map() 也可以接受多個序列引數，但你必須提供對應的函式，該函式接受的引數數量應該與序列數量相同：

# 使用 map() 函式將兩個列表的對應元素相加
list1 = [1, 2, 3]
list2 = [4, 5, 6]
added_pairs = map(lambda x, y: x + y, list1, list2)

print(list(added_pairs))  # 輸出：[5, 7, 9]

使用場景

map() 函式通常用於對序列中的每個元素執行相同的操作。它特別適合於簡單的、不需要額外狀態的操作。

注意事項

map() 返回的是一個迭代器，如果你需要一個列表，可以使用 list() 函式進行轉換。
map() 函式不會修改原始序列，它返回一個新的迭代器。
如果序列很大，使用 map() 可以節省記憶體，因為它是惰性計算的，即它只有在需要的時候才會計算下一個元素。

與列表推導式比較

與 filter() 類似，列表推導式通常比 map() 更簡潔，更易於閱讀，並且在處理複雜的轉換時更加靈活：

numbers = [1, 2, 3, 4]
doubled_numbers = [x * 2 for x in numbers]
print(doubled_numbers)  # 輸出：[2, 4, 6, 8]

儘管如此，map() 在某些情況下仍然很有用，特別是在你需要一個迭代器而不是列表時，或者當你需要將操作邏輯與函式分離時。此外，map() 在函式應用於多個序列的元素時，可以非常清晰地表達意圖。

7.5lamdba函式

Python 中的 lambda 關鍵字用於建立匿名函式，這些函式沒有名稱，定義後只能使用一次。lambda 函式通常用於編寫簡單的、臨時的函式，它們在需要一個函式物件但不想費神命名並定義一個完整函式時非常有用。

基本語法

lambda arguments: expression

arguments：這是傳遞給 lambda 函式的引數，可以有一個或多個。
expression：這是 lambda 函式返回的表示式。

示例

# 建立一個 lambda 函式，計算兩個數的和
add = lambda x, y: x + y

# 使用 lambda 函式
print(add(3, 4))  # 輸出：7

lambda 函式可以包含任意複雜的表示式，但它們通常用於簡單的操作：

# 建立一個 lambda 函式，返回數字的平方
square = lambda num: num ** 2

# 使用 lambda 函式
print(square(5))  # 輸出：25

使用 lambda 與 map()、filter()、sorted() 等

lambda 函式經常與 map()、filter() 和 sorted() 等函式配合使用，為這些函式提供所需的函式邏輯。

# 使用 lambda 函式和 map() 來將列表中的每個元素乘以 2
numbers = [1, 2, 3, 4]
doubled = list(map(lambda x: x * 2, numbers))
print(doubled)  # 輸出：[2, 4, 6, 8]

# 使用 lambda 函式和 filter() 來過濾出列表中的偶數
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 輸出：[2, 4]

# 使用 lambda 函式和 sorted() 來根據元素的第二個項對元組列表進行排序
tuples_list = [(1, 'one'), (3, 'three'), (2, 'two')]
sorted_list = sorted(tuples_list, key=lambda item: item[1])
print(sorted_list)  # 輸出：[(1, 'one'), (2, 'two'), (3, 'three')]

注意事項

lambda 函式只能包含單個表示式，因此它們不能包含多個語句或複雜的邏輯。
lambda 函式沒有自己的區域性作用域，它們只能訪問外部作用域中的變數。
lambda 函式通常用於簡短的、一次性的函式定義，對於更復雜的函式，最好使用 def 關鍵字定義一個完整的函式。

儘管 lambda 函式在某些情況下非常有用，但過度使用會使程式碼難以閱讀和維護。因此，應當在適當的時候選擇使用 lambda 函式。

7.6sorted函式

Python 中的 sorted() 函式是一個內建函式，用於對可迭代物件的元素進行排序，並返回一個新的排好序的列表。原始的可迭代物件不會被 sorted() 改變。

基本語法

sorted(iterable, key=None, reverse=False)

iterable：要排序的可迭代物件，例如列表、元組或字串。
key：一個函式，它會被用來在進行比較之前從每個列表元素中提取一個比較鍵（比如透過一個函式指定排序的依據）。
reverse：一個布林值。如果設定為 True，則列表元素將被逆序排列，預設為 False。

示例

預設排序

numbers = [3, 1, 4, 1, 5, 9, 2]
sorted_numbers = sorted(numbers)
print(sorted_numbers)  # 輸出：[1, 1, 2, 3, 4, 5, 9]

字串排序

words = ['banana', 'apple', 'cherry']
sorted_words = sorted(words)
print(sorted_words)  # 輸出：['apple', 'banana', 'cherry']

逆序排序

sorted_numbers_desc = sorted(numbers, reverse=True)
print(sorted_numbers_desc)  # 輸出：[9, 5, 4, 3, 2, 1, 1]

使用 key 引數

# 根據字串的長度進行排序
sorted_words_by_length = sorted(words, key=len)
print(sorted_words_by_length)  # 輸出：['apple', 'banana', 'cherry']

# 使用 lambda 表示式作為 key 函式
sorted_words_custom = sorted(words, key=lambda x: (len(x), x))
print(sorted_words_custom)  # 輸出：['apple', 'cherry', 'banana']

物件列表排序

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person({self.name}, {self.age})"

people = [Person("John", 45), Person("Diana", 32), Person("Tom", 42)]
# 根據年齡排序
sorted_people = sorted(people, key=lambda person: person.age)
print(sorted_people)  # 輸出：[Person(Diana, 32), Person(Tom, 42), Person(John, 45)]

注意事項

sorted() 總是返回一個新的列表，它不會修改原始的可迭代物件。
如果要對原始列表進行排序，可以使用列表的 list.sort() 方法，這將對列表進行就地排序。
key 引數接受的函式可以是內建函式或者自定義函式，它定義了排序的具體行為。

sorted() 函式是一個非常強大的工具，它提供了靈活的排序功能，可以用於各種資料型別的排序，並且可以透過 key 引數定製排序邏輯。

8.字串

8.1字串的格式化

在Python中，字串格式化是一種將資料嵌入到字串中的方法。Python提供了多種字串格式化的方式，包括傳統的 % 格式化、str.format() 方法，以及Python 3.6+中引入的 f-string（格式化字串字面量）。

% 格式化

這是較早的字串格式化方法，透過在字串中使用 % 運算子來嵌入變數。

name = "Alice"
age = 30
sentence = "Hello, %s. You are %d years old." % (name, age)
print(sentence)  # 輸出：Hello, Alice. You are 30 years old.

你還可以使用字典來解構鍵值對：

data = {'name': 'Alice', 'age': 30}
sentence = "Hello, %(name)s. You are %(age)d years old." % data
print(sentence)  # 輸出：Hello, Alice. You are 30 years old.

str.format() 方法

str.format() 方法提供了一個新的字串格式化方法，它允許你使用花括號 {} 作為佔位符。

name = "Alice"
age = 30
sentence = "Hello, {}. You are {} years old.".format(name, age)
print(sentence)  # 輸出：Hello, Alice. You are 30 years old.

你同樣可以使用索引和關鍵字來引用傳遞給 format() 的引數：

sentence = "Hello, {0[name]}. You are {0[age]} years old.".format(data)
print(sentence)  # 輸出：Hello, Alice. You are 30 years old.

f-string（格式化字串字面量）

從Python 3.6開始，引入了f-string，它提供了一種更簡潔和直觀的方式來格式化字串。

name = "Alice"
age = 30
sentence = f"Hello, {name}. You are {age} years old."
print(sentence)  # 輸出：Hello, Alice. You are 30 years old.

f-string還支援表示式內的計算和更復雜的表示式：

sentence = f"Hello, {name}. You are {age + 10} years old in 10 years."
print(sentence)  # 輸出：Hello, Alice. You are 40 years old in 10 years.

注意事項

f-string 是最快的字串格式化方法，推薦在效能要求較高的場景下使用。
% 格式化和 str.format() 方法在多種情況下都很有用，尤其是在需要與舊程式碼相容時。
使用 str.format() 或 f-string 時，如果引數數量多於佔位符，Python會丟擲 IndexError 或 ValueError。如果引數數量少於佔位符，剩餘的佔位符將被替換為 None。

字串格式化是Python程式設計中的一個基本技能，它使得資料的展示更加靈活和動態。f-string因其簡潔和效能優勢而成為現代Python程式碼的首選格式化方法。

8.2字串的常用方法

在Python中，字串提供了多種方法來查詢子字串或字元，以下是 find(), rfind(), index(), rindex(), count()、‘ spilt’、rspilt、partation、rpartation join、replace這些方法的詳細說明和示例：

以下是字串查詢和操作相關函式的詳細說明和示例：

查詢函式
find()
返回子字串首次出現的最低索引，如果找不到子字串則返回 -1。

s = "hello world"
print(s.find("world"))  # 輸出：6
print(s.find("Python"))  # 輸出：-1

rfind()
返回子字串最後一次出現的最低索引，如果找不到子字串則返回 -1。

s = "hello world world"
print(s.rfind("world"))  # 輸出：12
print(s.rfind("Python"))  # 輸出：-1

index()
返回子字串首次出現的最低索引，如果找不到子字串則丟擲 ValueError。

s = "hello world"
print(s.index("world"))  # 輸出：6
# print(s.index("Python"))  # 將丟擲 ValueError

rindex()
返回子字串最後一次出現的最低索引，如果找不到子字串則丟擲 ValueError。

s = "hello world world"
print(s.rindex("world"))  # 輸出：12
# print(s.rindex("Python"))  # 將丟擲 ValueError

count()
返回子字串在字串中出現的次數。

s = "hello world world"
print(s.count("world"))  # 輸出：2
print(s.count("Python"))  # 輸出：0

分割函式

split()
按照指定的分隔符（預設為空格）分割字串，返回一個包含所有分割結果的列表。

s = "hello world"
print(s.split())  # 輸出：['hello', 'world']

rsplit()
與 split() 類似，但是從字串的末尾開始分割。

s = "hello world world"
print(s.rsplit())  # 輸出：['hello', 'world', 'world']

partition()
將字串按照第一個出現的分隔符進行分割，並返回一個包含分割結果的元組（分割符前的部分，分隔符本身，分隔符後的部分）。

s = "hello-world"
print(s.partition("-"))  # 輸出：('hello', '-', 'world')

rpartition()
與 partition() 類似，但是從字串的末尾開始分割。

s = "hello-world-again"
print(s.rpartition("-"))  # 輸出：('hello-world', '-', 'again')

連線和替換函式

join()
將序列中的元素連線成一個字串，元素之間用指定的分隔符連線。

words = ["hello", "world"]
print(" ".join(words))  # 輸出：hello world

replace()
將字串中的部分內容替換為另一個字串，返回新的字串。

s = "hello world"
print(s.replace("world", "Python"))  # 輸出：hello Python

這些函式在處理字串時非常有用，可以幫助你完成各種字串的查詢、分割、連線和替換操作。

9.物件導向程式設計

物件導向程式設計（Object-Oriented Programming，OOP）是一種程式設計正規化，它使用物件和類來模擬現實世界中的實體和它們之間的關係。

9.1物件導向的概念

物件導向程式設計的核心思想是將資料和處理資料的方法封裝在物件中。物件是具有狀態和行為的實體，狀態由物件的屬性（資料）表示，行為由物件的方法（函式）表示。

9.2類的定義與例項化

類是物件的藍圖或模板，定義了物件的屬性和方法。例項化是建立類的一個具體物件的過程。

class Dog:
    def __init__(self, name, age):  # 初始化方法
        self.name = name  # 例項變數
        self.age = age

    def bark(self):  # 例項方法
        print("Woof!")

# 例項化
my_dog = Dog("Buddy", 3)
my_dog.bark()

9.3類的成員

類的成員包括屬性（變數）和方法（函式）。屬性定義了物件的狀態，方法定義了物件的行為。

class Car:
    def __init__(self, make, model):
        self.make = make
        self.model = model

    def start_engine(self):
        print("Engine started.")

# 屬性訪問
my_car = Car("Toyota", "Corolla")
print(my_car.make)  # 輸出: Toyota

# 方法呼叫
my_car.start_engine()

9.4封裝

封裝是將物件的狀態（屬性）和行為（方法）結合在一起，並隱藏內部實現細節的過程。在Python中，可以透過使用私有變數（以雙下劃線開頭）來實現封裝。

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance  # 私有變數

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print("Deposit successful.")

    def get_balance(self):
        return self.__balance

# 私有變數不能直接訪問
# my_account.__balance  # 這將引發錯誤
print(my_account.get_balance())  # 正確方式

9.5繼承

繼承允許一個類（子類）繼承另一個類（父類）的屬性和方法。這有助於程式碼重用和建立類之間的層次結構。

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("Subclasses must implement this method")

class Dog(Animal):  # Dog繼承自Animal
    def speak(self):
        print("Woof!")

my_dog = Dog("Buddy")
my_dog.speak()  # 輸出: Woof!

9.6多型

多型是指不同類的物件對同一訊息做出響應的能力，即同一個介面可以被不同的例項以不同的方式實現。在Python中，多型通常是透過方法重寫實現的。

class Animal:
    def speak(self):
        raise NotImplementedError("Subclasses must implement this method")

class Dog(Animal):
    def speak(self):
        print("Woof!")

class Cat(Animal):
    def speak(self):
        print("Meow!")

def animal_sound(animal):
    animal.speak()

my_dog = Dog("Buddy")
my_cat = Cat("Whiskers")

animal_sound(my_dog)  # 輸出: Woof!
animal_sound(my_cat)  # 輸出: Meow!

在上述程式碼中，animal_sound 函式可以接收任何Animal型別的物件，呼叫它們的speak方法，這就是多型的體現。

10 python檔案操作

在Python中，檔案操作是常見的任務，涉及到開啟、讀取、寫入和關閉檔案。以下是如何使用Python進行檔案操作的一些基本方法：

10.1 開啟檔案

在Python中，可以使用內建的open()函式來開啟檔案。這個函式返回一個檔案物件，你可以用它來讀取或寫入檔案。

# 開啟檔案用於讀取
with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

# 開啟檔案用於寫入
with open('example.txt', 'w') as file:
    file.write('Hello, World!')

10.2 關閉檔案

在Python中，通常不需要顯式關閉檔案，因為open()函式返回的檔案物件會在離開with塊時自動關閉。如果檔案是在with塊外部開啟的，則需要呼叫檔案物件的close()方法來關閉檔案。

file = open('example.txt', 'r')
content = file.read()
file.close()  # 顯式關閉檔案

10.3 使用`with as`進行檔案續寫

with語句提供了一種方便的方式來管理檔案的開啟和關閉，即使在發生異常時也能確保檔案被正確關閉。使用with語句時，檔案預設以獨佔模式開啟，如果要進行檔案續寫，需要使用'a'（追加）模式。

# 使用with語句和'a'模式進行檔案續寫
with open('example.txt', 'a') as file:
    file.write('\nThis is another line.')

10.4 檔案續寫的其他方法

如果不使用with語句，也可以手動開啟檔案，寫入內容，然後關閉檔案。在使用這種方法時，需要確保在完成檔案操作後呼叫close()方法。

# 手動開啟檔案，進行續寫，然後關閉檔案
file = open('example.txt', 'a')  # 'a'模式用於追加內容
file.write('\nThis is yet another line.')
file.close()

在Python中，推薦使用with語句來處理檔案操作，因為它可以自動管理檔案的開啟和關閉，即使在發生異常時也能確保檔案資源被正確釋放。此外，with語句的程式碼更加簡潔，可讀性更好。

以上是python的基礎內容，還請繼續深入學習。

python 程式設計基礎案例
2022-03-20
Python程式設計
python_4程式設計基礎
2017-04-14
Python程式設計
python物件導向程式設計基礎
2019-12-05
Python物件程式設計
python基礎（物件導向程式設計）
2019-03-28
Python物件程式設計
Python程式設計基礎Task12
2020-10-05
Python程式設計
程式設計基礎
2017-09-26
程式設計
Python多程式程式設計基礎——圖文版
2018-05-27
Python程式設計
Python基礎程式設計(六)——序列型別
2020-12-16
Python程式設計型別
【Python入門基礎】網路程式設計
2020-12-16
Python程式設計
Python基礎程式設計(十六)——函式4
2020-12-17
Python程式設計函式
Python程式設計基礎：f-字串格式
2024-06-18
Python程式設計字串
Socket程式設計基礎
2018-10-25
程式設計
Go程式設計基礎
2018-11-05
Go程式設計
Java程式設計基礎
2016-12-07
Java程式設計
Shell程式設計-基礎
2018-05-11
程式設計
C程式設計基礎
2015-12-21
C程式程式設計
shell程式設計基礎
2024-07-10
程式設計
網路程式設計基礎-socket基礎
2015-05-20
程式設計
學Python，不需要有程式設計基礎！
2021-09-11
Python程式設計
Java 基礎02Java程式設計基礎
2019-03-03
Java程式設計
python程式設計基礎：深度學習基礎：繪相簿之matplotlib(1)
2018-06-24
Python程式設計深度學習
學Python程式設計有什麼用?Python基礎教程!
2021-03-18
Python程式設計
程式設計基礎知識
2020-04-07
程式設計
shell程式設計基礎二
2021-02-26
程式設計
【程式設計基礎】輸出
2020-11-16
程式設計
【socket程式設計基礎模板】
2020-08-28
程式設計
網路程式設計基礎
2021-12-03
程式設計
QML程式設計基礎小白
2020-10-19
程式設計
JNI程式設計基礎（一）
2017-04-23
程式設計
【Java基礎】通用程式設計
2016-06-28
Java程式設計
linux程式設計基礎
2016-07-15
Linux程式設計
pl/sql程式設計基礎
2013-06-02
SQL程式設計
python程式設計基礎教程第一季
2020-04-04
Python程式設計
python程式設計基礎教程第二季
2020-04-04
Python程式設計
Python程式設計入門基礎語法詳解
2019-06-21
Python程式設計
Python基礎入門（6）- 物件導向程式設計
2021-12-20
Python物件程式設計
如何以零基礎學習Python程式設計？
2020-09-16
Python程式設計
OpenGL基礎圖形程式設計(四)基礎程式結構
2016-04-06
程式設計

python程式設計基礎

1.python中的變數和資料型別

1.1變數

1.2python基本資料型別

1.3基本輸入與輸出

輸入（Input）

輸出（Output）

基本輸出

列印多個引數

格式化輸出

列印到檔案

1.4python中的運算子

算術運算子

比較運算子

賦值運算子

邏輯運算子

位運算子

成員運算子

身份運算子

2.python中的列表、元組、字典、集合

2.1列表

2.2元組

2.3字典

2.4集合

3.range、zip、enumerate

3.1range函式

3.2zip函式

3.3enumerate函式

4.序列、推導式、生成器與迭代器

4.1序列的切片

4.2序列的基本操作

列表特有操作

元組特有操作

通用操作

4.3列表推導式

4.4生成器與迭代器

迭代器（Iterator）

生成器（Generator）

5.程式流程控制

5.1分支結構

5.2迴圈結構

6.函式

6.1python函式的定義

6.2形參與實參

6.3變數的作用域

6.4函式的型別

7.python的常用內建函式

7.1python主要的內建函式

7.2eval函式

7.3filter函式

7.4map函式

7.5lamdba函式

7.6sorted函式

8.字串

8.1字串的格式化

8.2字串的常用方法

9.物件導向程式設計

9.1物件導向的概念

9.2類的定義與例項化

9.3類的成員

9.4封裝

9.5繼承

9.6多型

10 python檔案操作

10.1 開啟檔案

10.2 關閉檔案

10.3 使用with as進行檔案續寫

10.4 檔案續寫的其他方法

相關文章

10.3 使用`with as`進行檔案續寫