社群
學習
工具庫
AI工具
休閒
搜尋
繁体中文
首頁 後端開發 Python教學 混淆'世界你好！” Python 上的混淆

混淆'世界你好！” Python 上的混淆

Linda Hamilton
Linda Hamilton
Jan 04, 2025 am 03:37 AM

Obfuscating “Hello world!” obfuscate on Python

創建最奇怪的混淆程序，列印字串「Hello world！」。我決定寫一篇解釋它到底是如何運作的。所以，這是 Python 2.7 中的條目：

(lambda _, __, ___, ____, _____, ______, _______, ________:
    getattr(
        __import__(True.__class__.__name__[_] + [].__class__.__name__[__]),
        ().__class__.__eq__.__class__.__name__[:__] +
        ().__iter__().__class__.__name__[_____:________]
    )(
        _, (lambda _, __, ___: _(_, __, ___))(
            lambda _, __, ___:
                chr(___ % __) + _(_, __, ___ // __) if ___ else
                (lambda: _).func_code.co_lnotab,
            _ << ________,
            (((_____ << ____) + _) << ((___ << _____) - ___)) + (((((___ << __)
            - _) << ___) + _) << ((_____ << ____) + (_ << _))) + (((_______ <<
            __) - _) << (((((_ << ___) + _)) << ___) + (_ << _))) + (((_______
            << ___) + _) << ((_ << ______) + _)) + (((_______ << ____) - _) <<
            ((_______ << ___))) + (((_ << ____) - _) << ((((___ << __) + _) <<
            __) - _)) - (_______ << ((((___ << __) - _) << __) + _)) + (_______
            << (((((_ << ___) + _)) << __))) - ((((((_ << ___) + _)) << __) +
            _) << ((((___ << __) + _) << _))) + (((_______ << __) - _) <<
            (((((_ << ___) + _)) << _))) + (((___ << ___) + _) << ((_____ <<
            _))) + (_____ << ______) + (_ << ___)
        )
    )
)(
    *(lambda _, __, ___: _(_, __, ___))(
        (lambda _, __, ___:
            [__(___[(lambda: _).func_code.co_nlocals])] +
            _(_, __, ___[(lambda _: _).func_code.co_nlocals:]) if ___ else []
        ),
        lambda _: _.func_code.co_argcount,
        (
            lambda _: _,
            lambda _, __: _,
            lambda _, __, ___: _,
            lambda _, __, ___, ____: _,
            lambda _, __, ___, ____, _____: _,
            lambda _, __, ___, ____, _____, ______: _,
            lambda _, __, ___, ____, _____, ______, _______: _,
            lambda _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)
登入後複製
登入後複製
登入後複製
登入後複製

不允許使用字串文字，但我為了好玩設定了一些其他限制：它必須是單一表達式（因此沒有列印語句），具有最少的內建用法，並且沒有整數文字。
開始使用

由於我們無法使用列印，我們可以寫入 stdout 檔案物件：

import sys
sys.stdout.write("Hello world!\n")
登入後複製
登入後複製
登入後複製
登入後複製

但是讓我們使用較低等級的東西：os.write()。我們需要 stdout 的檔案描述符，它是 1（可以使用 print sys.stdout.fileno() 檢查）。 

import os
os.write(1, "Hello world!\n")
登入後複製
登入後複製
登入後複製

我們想要一個表達式，所以我們將使用 import():

__import__("os").write(1, "Hello world!\n")
登入後複製
登入後複製
登入後複製

我們也希望能夠混淆 write()，因此我們將引入 getattr()：

getattr(__import__("os"), "write")(1, "Hello world!\n")
登入後複製
登入後複製
登入後複製

這是起點。從現在開始，一切都將混淆三個字串和整數。
將字串串在一起

「os」和「write」相當簡單，因此我們將透過連接各個內建類別的部分名稱來建立它們。有很多不同的方法可以做到這一點，但我選擇了以下方法：

"o" from the second letter of bool: True.__class__.__name__[1]
"s" from the third letter of list: [].__class__.__name__[2]
"wr" from the first two letters of wrapper_descriptor, an implementation detail in CPython found as the type of some builtin classes’ methods (more on that here): ().__class__.__eq__.__class__.__name__[:2]
"ite" from the sixth through eighth letters of tupleiterator, the type of object returned by calling iter() on a tuple: ().__iter__().__class__.__name__[5:8]
登入後複製
登入後複製

我們開始取得一些進展！ 

getattr(
    __import__(True.__class__.__name__[1] + [].__class__.__name__[2]),
    ().__class__.__eq__.__class__.__name__[:2] +
    ().__iter__().__class__.__name__[5:8]
)(1, "Hello world!\n")
登入後複製
登入後複製

「Hello world!n」更複雜。我們將把它編碼為一個大整數，它由每個字元的 ASCII 代碼乘以 256 的字元在字串中的索引次方組成。換句話說，以下總和：
Σn=0L−1cn(256n)

哪裡L
是字串的長度，cn 是 n

的 ASCII 碼 字串中的第

個字元。建立號碼：

>>> codes = [ord(c) for c in "Hello world!\n"]
>>> num = sum(codes[i] * 256 ** i for i in xrange(len(codes)))
>>> print num
802616035175250124568770929992
登入後複製
登入後複製

現在我們需要程式碼將此數字轉換回字串。我們使用一個簡單的遞歸演算法：

>>> def convert(num):
...     if num:
...         return chr(num % 256) + convert(num // 256)
...     else:
...         return ""
...
>>> convert(802616035175250124568770929992)
'Hello world!\n'
登入後複製
登入後複製

用 lambda 重寫一行：

convert = lambda num: chr(num % 256) + convert(num // 256) if num else ""
登入後複製
登入後複製

現在我們使用匿名遞歸將其轉換為單一表達式。這需要一個組合器。從這個開始：

>>> comb = lambda f, n: f(f, n)
>>> convert = lambda f, n: chr(n % 256) + f(f, n // 256) if n else ""
>>> comb(convert, 802616035175250124568770929992)
'Hello world!\n'
登入後複製
登入後複製

現在我們只需將這兩個定義代入表達式中，我們就得到了我們的函數：

>>> (lambda f, n: f(f, n))(
...     lambda f, n: chr(n % 256) + f(f, n // 256) if n else "",
...     802616035175250124568770929992)
'Hello world!\n'
登入後複製
登入後複製

現在我們可以將其貼到先前的程式碼中，一路替換一些變數名稱 (f → , n → _):

getattr(
    __import__(True.__class__.__name__[1] + [].__class__.__name__[2]),
    ().__class__.__eq__.__class__.__name__[:2] +
    ().__iter__().__class__.__name__[5:8]
)(
    1, (lambda _, __: _(_, __))(
        lambda _, __: chr(__ % 256) + _(_, __ // 256) if __ else "",
        802616035175250124568770929992
    )
)
登入後複製
登入後複製

函數內部

我們在轉換函數的主體中留下了一個「」（記住：沒有字串文字！），以及我們必須以某種方式隱藏的大量數字。讓我們從空字串開始。我們可以透過檢查某個隨機函數的內部結構來即時製作一個：

(lambda _, __, ___, ____, _____, ______, _______, ________:
    getattr(
        __import__(True.__class__.__name__[_] + [].__class__.__name__[__]),
        ().__class__.__eq__.__class__.__name__[:__] +
        ().__iter__().__class__.__name__[_____:________]
    )(
        _, (lambda _, __, ___: _(_, __, ___))(
            lambda _, __, ___:
                chr(___ % __) + _(_, __, ___ // __) if ___ else
                (lambda: _).func_code.co_lnotab,
            _ << ________,
            (((_____ << ____) + _) << ((___ << _____) - ___)) + (((((___ << __)
            - _) << ___) + _) << ((_____ << ____) + (_ << _))) + (((_______ <<
            __) - _) << (((((_ << ___) + _)) << ___) + (_ << _))) + (((_______
            << ___) + _) << ((_ << ______) + _)) + (((_______ << ____) - _) <<
            ((_______ << ___))) + (((_ << ____) - _) << ((((___ << __) + _) <<
            __) - _)) - (_______ << ((((___ << __) - _) << __) + _)) + (_______
            << (((((_ << ___) + _)) << __))) - ((((((_ << ___) + _)) << __) +
            _) << ((((___ << __) + _) << _))) + (((_______ << __) - _) <<
            (((((_ << ___) + _)) << _))) + (((___ << ___) + _) << ((_____ <<
            _))) + (_____ << ______) + (_ << ___)
        )
    )
)(
    *(lambda _, __, ___: _(_, __, ___))(
        (lambda _, __, ___:
            [__(___[(lambda: _).func_code.co_nlocals])] +
            _(_, __, ___[(lambda _: _).func_code.co_nlocals:]) if ___ else []
        ),
        lambda _: _.func_code.co_argcount,
        (
            lambda _: _,
            lambda _, __: _,
            lambda _, __, ___: _,
            lambda _, __, ___, ____: _,
            lambda _, __, ___, ____, _____: _,
            lambda _, __, ___, ____, _____, ______: _,
            lambda _, __, ___, ____, _____, ______, _______: _,
            lambda _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)
登入後複製
登入後複製
登入後複製
登入後複製

我們在這裡真正要做的是查看函數中包含的程式碼物件的行號表。由於它是匿名的，因此沒有行號，因此字串為空。將 0 替換為 _ 以使其更加混亂（這並不重要，因為該函數沒有被呼叫），然後將其插入。我們也將把 256 重構為一個參數，該參數傳遞給我們混淆的 Convert()連同號碼。這需要為組合器添加一個參數：

import sys
sys.stdout.write("Hello world!\n")
登入後複製
登入後複製
登入後複製
登入後複製

繞道

讓我們暫時解決一個不同的問題。我們想要一種方法來混淆程式碼中的數字，但是每次使用它們時重新建立它們會很麻煩（而且不是特別有趣）。如果我們可以實作range(1, 9) == [1, 2, 3, 4, 5, 6, 7, 8]，那麼我們可以將目前的工作包裝在一個函數中，該函數接受包含以下數字的變數1 到8，並用這些變數取代正文中出現的整數文字：

import os
os.write(1, "Hello world!\n")
登入後複製
登入後複製
登入後複製

即使我們還需要形成 256 和 802616035175250124568770929992，它們也可以透過對這八個「基本」數字進行算術運算來創建。 1-8 的選擇是任意的，但似乎是一個很好的中間立場。

我們可以透過函數的程式碼物件來取得函數接受的參數數量：

__import__("os").write(1, "Hello world!\n")
登入後複製
登入後複製
登入後複製

建構參數計數在 1 到 8 之間的函數元組：

getattr(__import__("os"), "write")(1, "Hello world!\n")
登入後複製
登入後複製
登入後複製

使用遞歸演算法，我們可以將其轉換為 range(1, 9) 的輸出：

"o" from the second letter of bool: True.__class__.__name__[1]
"s" from the third letter of list: [].__class__.__name__[2]
"wr" from the first two letters of wrapper_descriptor, an implementation detail in CPython found as the type of some builtin classes’ methods (more on that here): ().__class__.__eq__.__class__.__name__[:2]
"ite" from the sixth through eighth letters of tupleiterator, the type of object returned by calling iter() on a tuple: ().__iter__().__class__.__name__[5:8]
登入後複製
登入後複製

和之前一樣，我們將其轉換為 lambda 形式：

getattr(
    __import__(True.__class__.__name__[1] + [].__class__.__name__[2]),
    ().__class__.__eq__.__class__.__name__[:2] +
    ().__iter__().__class__.__name__[5:8]
)(1, "Hello world!\n")
登入後複製
登入後複製

然後，進入匿名遞歸形式：

>>> codes = [ord(c) for c in "Hello world!\n"]
>>> num = sum(codes[i] * 256 ** i for i in xrange(len(codes)))
>>> print num
802616035175250124568770929992
登入後複製
登入後複製

為了好玩，我們將 argcount 操作分解為一個附加函數參數，並混淆一些變數名稱：

>>> def convert(num):
...     if num:
...         return chr(num % 256) + convert(num // 256)
...     else:
...         return ""
...
>>> convert(802616035175250124568770929992)
'Hello world!\n'
登入後複製
登入後複製

現在有一個新問題：我們仍然需要一種隱藏 0 和 1 的方法。我們可以透過檢查任意函數中局部變數的數量來獲得這些：

convert = lambda num: chr(num % 256) + convert(num // 256) if num else ""
登入後複製
登入後複製

儘管函數體看起來相同，但第一個函數中的 _ 不是參數，也不是在函數中定義的，因此 Python 將其解釋為全域變數：

>>> comb = lambda f, n: f(f, n)
>>> convert = lambda f, n: chr(n % 256) + f(f, n // 256) if n else ""
>>> comb(convert, 802616035175250124568770929992)
'Hello world!\n'
登入後複製
登入後複製

無論 _ 是否實際在全域範圍內定義，都會發生這種情況。

將其付諸實踐：

>>> (lambda f, n: f(f, n))(
...     lambda f, n: chr(n % 256) + f(f, n // 256) if n else "",
...     802616035175250124568770929992)
'Hello world!\n'
登入後複製
登入後複製

現在我們可以取代 funcs 的值，然後使用 * 將結果整數列表作為八個單獨的變數傳遞，我們得到：

getattr(
    __import__(True.__class__.__name__[1] + [].__class__.__name__[2]),
    ().__class__.__eq__.__class__.__name__[:2] +
    ().__iter__().__class__.__name__[5:8]
)(
    1, (lambda _, __: _(_, __))(
        lambda _, __: chr(__ % 256) + _(_, __ // 256) if __ else "",
        802616035175250124568770929992
    )
)
登入後複製
登入後複製

移位

快到了！我們將用、_、、_ 等來取代n{1..8} 變量，因為它會與中使用的變數產生混淆我們的內在功能。這不會造成實際問題，因為範圍規則意味著將使用正確的規則。這也是我們將 256 重構為 _ 指涉 1 而不是我們混淆的 Convert() 函數的原因之一。有點長了，就只貼前半部了：

(lambda _, __, ___, ____, _____, ______, _______, ________:
    getattr(
        __import__(True.__class__.__name__[_] + [].__class__.__name__[__]),
        ().__class__.__eq__.__class__.__name__[:__] +
        ().__iter__().__class__.__name__[_____:________]
    )(
        _, (lambda _, __, ___: _(_, __, ___))(
            lambda _, __, ___:
                chr(___ % __) + _(_, __, ___ // __) if ___ else
                (lambda: _).func_code.co_lnotab,
            _ << ________,
            (((_____ << ____) + _) << ((___ << _____) - ___)) + (((((___ << __)
            - _) << ___) + _) << ((_____ << ____) + (_ << _))) + (((_______ <<
            __) - _) << (((((_ << ___) + _)) << ___) + (_ << _))) + (((_______
            << ___) + _) << ((_ << ______) + _)) + (((_______ << ____) - _) <<
            ((_______ << ___))) + (((_ << ____) - _) << ((((___ << __) + _) <<
            __) - _)) - (_______ << ((((___ << __) - _) << __) + _)) + (_______
            << (((((_ << ___) + _)) << __))) - ((((((_ << ___) + _)) << __) +
            _) << ((((___ << __) + _) << _))) + (((_______ << __) - _) <<
            (((((_ << ___) + _)) << _))) + (((___ << ___) + _) << ((_____ <<
            _))) + (_____ << ______) + (_ << ___)
        )
    )
)(
    *(lambda _, __, ___: _(_, __, ___))(
        (lambda _, __, ___:
            [__(___[(lambda: _).func_code.co_nlocals])] +
            _(_, __, ___[(lambda _: _).func_code.co_nlocals:]) if ___ else []
        ),
        lambda _: _.func_code.co_argcount,
        (
            lambda _: _,
            lambda _, __: _,
            lambda _, __, ___: _,
            lambda _, __, ___, ____: _,
            lambda _, __, ___, ____, _____: _,
            lambda _, __, ___, ____, _____, ______: _,
            lambda _, __, ___, ____, _____, ______, _______: _,
            lambda _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)
登入後複製
登入後複製
登入後複製
登入後複製

只剩下兩件事了。我們從簡單的開始：256. 256=28

，所以我們可以將其改寫為 1

我們將對 802616035175250124568770929992 使用相同的想法。一個簡單的分而治之演算法可以將其分解為數字總和，這些數字本身就是移位在一起的數字總和，依此類推。例如，如果我們有 112，我們可以將其分解為 96 16，然後是 (3 >)，這兩者都是涉及其他I/O 方式的轉移注意力的內容。

數字可以用多種方式分解；沒有一種方法是正確的（畢竟，我們可以將其分解為 (1 

import sys
sys.stdout.write("Hello world!\n")
登入後複製
登入後複製
登入後複製
登入後複製

這裡的基本思想是，我們測試一定範圍內的數字的各種組合，直到得出兩個數字，基數和移位，使得基數

range() 的參數 span 表示搜尋空間的寬度。這不能太大，否則我們最終將得到 num 作為我們的基數和 0 作為我們的移位（因為 diff 為零），並且由於基數不能表示為單個變量，所以它會重複，無限遞歸。如果它太小，我們最終會得到類似於上面提到的 (1 span=⌈log1.5|num|⌉ ⌊24−深度⌋

將偽代碼翻譯成 Python 並進行一些調整（支援深度參數，以及一些涉及負數的警告），我們得到：

(lambda _, __, ___, ____, _____, ______, _______, ________:
    getattr(
        __import__(True.__class__.__name__[_] + [].__class__.__name__[__]),
        ().__class__.__eq__.__class__.__name__[:__] +
        ().__iter__().__class__.__name__[_____:________]
    )(
        _, (lambda _, __, ___: _(_, __, ___))(
            lambda _, __, ___:
                chr(___ % __) + _(_, __, ___ // __) if ___ else
                (lambda: _).func_code.co_lnotab,
            _ << ________,
            (((_____ << ____) + _) << ((___ << _____) - ___)) + (((((___ << __)
            - _) << ___) + _) << ((_____ << ____) + (_ << _))) + (((_______ <<
            __) - _) << (((((_ << ___) + _)) << ___) + (_ << _))) + (((_______
            << ___) + _) << ((_ << ______) + _)) + (((_______ << ____) - _) <<
            ((_______ << ___))) + (((_ << ____) - _) << ((((___ << __) + _) <<
            __) - _)) - (_______ << ((((___ << __) - _) << __) + _)) + (_______
            << (((((_ << ___) + _)) << __))) - ((((((_ << ___) + _)) << __) +
            _) << ((((___ << __) + _) << _))) + (((_______ << __) - _) <<
            (((((_ << ___) + _)) << _))) + (((___ << ___) + _) << ((_____ <<
            _))) + (_____ << ______) + (_ << ___)
        )
    )
)(
    *(lambda _, __, ___: _(_, __, ___))(
        (lambda _, __, ___:
            [__(___[(lambda: _).func_code.co_nlocals])] +
            _(_, __, ___[(lambda _: _).func_code.co_nlocals:]) if ___ else []
        ),
        lambda _: _.func_code.co_argcount,
        (
            lambda _: _,
            lambda _, __: _,
            lambda _, __, ___: _,
            lambda _, __, ___, ____: _,
            lambda _, __, ___, ____, _____: _,
            lambda _, __, ___, ____, _____, ______: _,
            lambda _, __, ___, ____, _____, ______, _______: _,
            lambda _, __, ___, ____, _____, ______, _______, ________: _
        )
    )
)
登入後複製
登入後複製
登入後複製
登入後複製

現在，當我們呼叫convert(802616035175250124568770929992)時，我們得到了一個很好的分解：

import sys
sys.stdout.write("Hello world!\n")
登入後複製
登入後複製
登入後複製
登入後複製

將其作為 802616035175250124568770929992 的替代品，並將所有部件放在一起：

import os
os.write(1, "Hello world!\n")
登入後複製
登入後複製
登入後複製

這就是你的。
附錄：Python 3 支持

自從寫這篇文章以來，有幾個人詢問了 Python 3 支援的問題。我當時沒有想到這一點，但隨著 Python 3 不斷獲得關注（感謝您！），這篇文章顯然早就該更新了。

幸運的是，Python 3（截至撰寫本文時為 3.6）不需要我們進行太多更改：

__import__("os").write(1, "Hello world!\n")
登入後複製
登入後複製
登入後複製

這是完整的 Python 3 版本：

getattr(__import__("os"), "write")(1, "Hello world!\n")
登入後複製
登入後複製
登入後複製

感謝您的閱讀！我仍然對這篇文章的受歡迎程度感到驚訝。

以上是混淆'世界你好！” Python 上的混淆的詳細內容。更多資訊請關注PHP中文網其他相關文章！

本網站聲明
本文內容由網友自願投稿，版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容，請聯絡admin@php.cn

熱AI工具

Undresser.AI Undress

Undresser.AI Undress

人工智慧驅動的應用程序，用於創建逼真的裸體照片

AI Clothes Remover

AI Clothes Remover

用於從照片中去除衣服的線上人工智慧工具。

Undress AI Tool

Undress AI Tool

免費脫衣圖片

Clothoff.io

Clothoff.io

AI脫衣器

Video Face Swap

Video Face Swap

使用我們完全免費的人工智慧換臉工具，輕鬆在任何影片中換臉！

顯示更多

熱門文章

<🎜>：種植花園 - 完整的突變指南
3 週前 By DDD
<🎜>：泡泡膠模擬器無窮大 - 如何獲取和使用皇家鑰匙
3 週前 By 尊渡假赌尊渡假赌尊渡假赌
如何修復KB5055612無法在Windows 10中安裝？
3 週前 By DDD
北端：融合系統，解釋
3 週前 By 尊渡假赌尊渡假赌尊渡假赌
Mandragora：巫婆樹的耳語 - 如何解鎖抓鉤
3 週前 By 尊渡假赌尊渡假赌尊渡假赌
顯示更多

熱工具

記事本++7.3.1

記事本++7.3.1

好用且免費的程式碼編輯器

SublimeText3漢化版

SublimeText3漢化版

中文版，非常好用

禪工作室 13.0.1

禪工作室 13.0.1

強大的PHP整合開發環境

Dreamweaver CS6

Dreamweaver CS6

視覺化網頁開發工具

SublimeText3 Mac版

SublimeText3 Mac版

神級程式碼編輯軟體(SublimeText3)

顯示更多

熱門話題

Java教學
1666
14
CakePHP 教程
1426
52
Laravel 教程
1328
25
PHP教程
1273
29
C# 教程
1254
24
顯示更多
Related knowledge
Python：遊戲，Guis等 Python：遊戲，Guis等 Apr 13, 2025 am 12:14 AM

Python在遊戲和GUI開發中表現出色。 1)遊戲開發使用Pygame，提供繪圖、音頻等功能，適合創建2D遊戲。 2)GUI開發可選擇Tkinter或PyQt，Tkinter簡單易用，PyQt功能豐富，適合專業開發。

Python與C：學習曲線和易用性 Python與C：學習曲線和易用性 Apr 19, 2025 am 12:20 AM

Python更易學且易用，C 則更強大但複雜。 1.Python語法簡潔，適合初學者，動態類型和自動內存管理使其易用，但可能導致運行時錯誤。 2.C 提供低級控制和高級特性，適合高性能應用，但學習門檻高，需手動管理內存和類型安全。

Python和時間：充分利用您的學習時間 Python和時間：充分利用您的學習時間 Apr 14, 2025 am 12:02 AM

要在有限的時間內最大化學習Python的效率，可以使用Python的datetime、time和schedule模塊。 1.datetime模塊用於記錄和規劃學習時間。 2.time模塊幫助設置學習和休息時間。 3.schedule模塊自動化安排每週學習任務。

Python vs.C：探索性能和效率 Python vs.C：探索性能和效率 Apr 18, 2025 am 12:20 AM

Python在開發效率上優於C ，但C 在執行性能上更高。 1.Python的簡潔語法和豐富庫提高開發效率。 2.C 的編譯型特性和硬件控制提升執行性能。選擇時需根據項目需求權衡開發速度與執行效率。

Python標準庫的哪一部分是：列表或數組？ Python標準庫的哪一部分是：列表或數組？ Apr 27, 2025 am 12:03 AM

pythonlistsarepartofthestAndArdLibrary，herilearRaysarenot.listsarebuilt-In，多功能，和Rused ForStoringCollections，而EasaraySaraySaraySaraysaraySaraySaraysaraySaraysarrayModuleandleandleandlesscommonlyusedDduetolimitedFunctionalityFunctionalityFunctionality。

Python：自動化，腳本和任務管理 Python：自動化，腳本和任務管理 Apr 16, 2025 am 12:14 AM

Python在自動化、腳本編寫和任務管理中表現出色。 1)自動化：通過標準庫如os、shutil實現文件備份。 2)腳本編寫：使用psutil庫監控系統資源。 3)任務管理：利用schedule庫調度任務。 Python的易用性和豐富庫支持使其在這些領域中成為首選工具。

學習Python：2小時的每日學習是否足夠？ 學習Python：2小時的每日學習是否足夠？ Apr 18, 2025 am 12:22 AM

每天學習Python兩個小時是否足夠？這取決於你的目標和學習方法。 1)制定清晰的學習計劃，2)選擇合適的學習資源和方法，3)動手實踐和復習鞏固，可以在這段時間內逐步掌握Python的基本知識和高級功能。

Python vs. C：了解關鍵差異 Python vs. C：了解關鍵差異 Apr 21, 2025 am 12:18 AM

Python和C 各有優勢，選擇應基於項目需求。 1)Python適合快速開發和數據處理，因其簡潔語法和動態類型。 2)C 適用於高性能和系統編程，因其靜態類型和手動內存管理。

See all articles