恭喜您決定參加為期30 天的 Python編程挑戰賽，在這個挑戰中，您將學習成為 Python 程式員所需的一切以及整個編程概念，在挑戰結束時，您將獲得30DaysOfPython編程挑戰證書，

1、第一天-介紹

Python 是一種用于通用編程的高級編程語言，它是一種開源、解釋型、面向物件的編程語言，Python 是由荷蘭程式員 Guido van Rossum 創建的，Python 編程語言的名稱來源于英國的小品喜劇系列《Month Python’s Flying Circus》，第一個版本于 1991 年 2 月 20 日發布，這個為期 30 天的 Python 挑戰將幫助您逐步學習最新版本的 Python，Python 3，

這個挑戰是為想要學習 Python 編程語言的初學者設計的，完成挑戰可能需要30到100天，主要看個人能力，邏輯思維好的可能30天就能學會，

1.1為什么是 Python？

它是一種非常接近人類語言的編程語言，因此易于學習和使用，Python 被各種行業和公司（包括 Google）使用，它已被用于開發 Web 應用程式、桌面應用程式、系統管理和機器學習庫，

1.2環境設定

安裝 Python

要運行 python 腳本，您需要安裝 python，讓我們下載python，如果您是 Windows 用戶，單擊紅色圈出的按鈕，

如果您是 macOS 用戶，單擊紅色圈出的按鈕，

要檢查是否安裝了 python，請在設備終端上寫入以下命令，

Python–版本

從終端可以看出，我目前使用的是Python 3.7.5版本，您的 Python 版本可能與我的不同，應該是 3.6 或更高版本，如果你能看到 python 版本，那就太好了，Python 已安裝在您的機器上，繼續下一節，

Python Shell

Python 是一種解釋性腳本語言，因此不需要編譯，這意味著它逐行執行代碼，Python 自帶一個Python Shell（Python Interactive Shell），它用于執行單個 python 命令并獲取結果，

Python Shell 等待來自用戶的 Python 代碼，當您輸入代碼時，它會解釋代碼并在下一行顯示結果，打開終端或命令提示符（cmd）并寫入：

Python

Python 互動式 shell 已打開，它正在等待您撰寫 Python 腳本，您將在此符號 >>> 旁邊撰寫 Python 腳本，然后單擊 Enter，讓我們在 Python 腳本 shell 上撰寫我們的第一個腳本，

上面一步完成后，可以在 Python 互動式 shell 上撰寫了第一個 Python 腳本，我們如何關閉 Python 互動式 shell？要關閉 shell，請在此符號旁邊 >> 寫exit()命令并按 Enter，

現在，您知道如何打開 Python 互動式 shell 以及如何退出它，

如果您撰寫 Python 理解的腳本，Python 會給您結果，否則回傳錯誤，讓我們故意犯一個錯誤， Python 會回傳出無效的語法錯誤，

從回傳的錯誤中可以看出，Python 非常聰明，它知道我們犯的錯誤是Syntax Error: invalid syntax，在 Python 中使用 x 作為乘法是一個語法錯誤，因為 x 在 Python 中不是有效的語法，我們使用星號 *代替 x 進行乘法，回傳的錯誤清楚地顯示了要修復的內容，

從程式中識別和消除錯誤的程序稱為除錯，讓我們用 * 代替x來除錯它，

修復語法錯誤

我們的錯誤被修復了，代碼運行了，我們得到了我們期望的結果，作為程式員，您每天都會看到此類錯誤，一定要善于除錯，要了解您面臨的錯誤型別，有時你可能會遇到的錯誤是SyntaxError錯誤，IndexError，NameError，ModuleNotFoundError，KeyError例外，匯入錯誤，AttributeError錯誤，型別錯誤，ValueError例外，ZeroDivisionError等，

讓我們多練習一下如何使用 Python 互動式 shell，轉到您的終端或命令提示符并輸入單詞python，

Python 互動式 shell 已打開，讓我們做一些基本的數學運算加、減、乘、除、模、指數，

在撰寫任何 Python 代碼之前，讓我們先做一些數學運算：

2 + 3 = 5
3 - 2 = 1
3 * 2 = 6
3 / 2 = 1.5
3 ^ 2 = 3 x 3 = 9

在python中，我們有以下附加操作：

3 % 2 = 1 => 表示求余數
3 // 2 = 1 => 這意味著去除余數

我們把上面的數學運算式改成 Python 代碼，在 shell 的最開始寫一個注釋，

我們可以在我們的代碼中留下一些文本，讓我們的代碼更具可讀性，python 中的注釋以 hash# 符號開頭，

 #注釋以 hash 開頭
 #這是一條 Python 注釋，因為它以 (#) 符號開頭

python shell上的數學

在shell上寫exit()關閉打開的shell，再打開，練習如何在Python shell上寫文本，

在 python shell 上寫字串

1.3Python基礎

Python 語法

Python 腳本可以在 Python shell 或代碼編輯器中撰寫，Python 檔案的擴展名為 .py，

Python 縮進

縮進是文本中的空白，許多語言都使用縮進來提高代碼可讀性，但是 Python 使用縮進來創建代碼塊，在其他編程語言中，大括號用于創建代碼塊而不是縮進，撰寫python代碼時的常見錯誤之一是縮進錯誤，

注釋

注釋對于使代碼更具可讀性以及在我們的代碼中留下注釋非常重要，Python 不會運行我們代碼的注釋部分，Python 中任何以 hash(#) 開頭的文本都是注釋，

示例：單行注釋

#這是第一條評論
#這是第二條評論
# Python 正在吞噬世界

示例：多行注釋

如果未分配給變數，則三重引號可用于多行注釋

" " "這是多行注釋
多行注釋需要多行
，python 正在吃掉世界
" " "

資料型別

在 Python 中有幾種型別的資料型別，讓我們從最常見的開始，其他部分將詳細介紹不同的資料型別，目前，讓我們通過不同的資料型別并熟悉它們，

數字

• 整數：整數（負、零和正）數 示例：… -3, -2, -1, 0, 1, 2, 3 …
• 浮點數：十進制數 示例 … -3.5, -2.25, -1.0, 0.0, 1.1, 2.2, 3.5 …
• 復雜示例 1 + j, 2 + 4j

細繩
單引號或雙引號下的一個或多個字符的集合，如果一個字串不止一個句子，那么我們使用三重引號，

例子：

'Asabeneh' 
'芬蘭' 
'Python' 
'我喜歡教學' 
'我希望你享受 30DaysOfPython 挑戰賽的第一天'

布林值
布爾資料型別是 True 或 False 值，T 和 F 應始終為大寫，

例子：

   True   # 燈亮了嗎？如果
    燈亮，則值為 True False  # 燈亮了嗎？如果關閉，則值為 False

串列
Python 串列是一個有序集合，它允許存盤不同的資料型別項，串列類似于 JavaScript 中的陣列，

例子：

[ 0 , 1 , 2 , 3 , 4 , 5 ]   # 都是相同的資料型別 - 數字串列
[ 'Banana' , 'Orange' , 'Mango' , 'Avocado' ] # 所有相同的資料型別 - a字串串列（水果） 
[ 'Finland' , 'Estonia' , 'Sweden' , 'Norway' ] # 所有相同的資料型別 - 字串串列（國家） 
[ 'Banana' , 10 , False , 9.81 ]# 串列中的不同資料型別 - 字串、整數、布林值和浮點數

字典
Python 字典物件是鍵值對格式的無序資料集合，

例子：

{
 'first_name' : 'Asabeneh' ,
 'last_name' : 'Yetayeh' ,
 'country' : 'Finland' , 
 'age' : 250 , 
 'is_married' : True ,
 'skills' :[ 'JS' , 'React' , '節點'，'Python' ]
}

元組
元組是不同資料型別（如串列）的有序集合，但元組一旦創建就無法修改，它們是不可變的，

例子：

( 'Asabeneh' , 'Pawel' , 'Brook' , 'Abraham' , 'Lidiya' ) # 名字

（“地球”、“木星”、“海王星”、“火星”、“金星”、“土星”、“天王星”、“水星”）#行星
放

集合
集合是類似于串列和元組的資料型別的集合，與串列和元組不同，集合不是專案的有序集合，就像在數學中一樣，Python 中的 set 只存盤唯一的專案，

在后面的部分中，我們將詳細介紹每種 Python 資料型別，

例子：

{ 2 , 4 , 3 , 5 }
{ 3.14 , 9.81 , 2.7 } # 順序在集合中并不重要

檢查資料型別

要檢查某些資料/變數的資料型別，我們使用type函式，在以下終端中，您將看到不同的 Python 資料型別：

Python檔案

首先打開你的專案檔案夾，30DaysOfPython，如果您沒有此檔案夾，請創建一個名為 30DaysOfPython 的檔案夾，在此檔案夾中，創建一個名為 helloworld.py 的檔案，

Python shell 在不使用print 的情況下進行列印，查看我們的結果，我們應該使用內置函式 *print()，在列印（）內置函式有一個或多個引數如下印刷（“arument1”，“引數2”，“引數3”） ，請參閱下面的示例，

例子：

檔案名為 helloworld.py

# 第 1 天 - 30DaysOfPython 挑戰

print ( 2  +  3 )              #加法(+) 
print ( 3  -  1 )              #減法(-) 
print ( 2  *  3 )              #乘法(*) 
print ( 3  /  2 )              # 除法(/) 
print ( 3  **  2 ) )             # 指數(**)
列印( 3  %  2 )              # 模數(%)
列印( 3  //  2)             # 樓層除法運算子(//)

# 檢查資料型別
print ( type ( 10 ))           # Int 
print ( type ( 3.14 ))         # Float 
print ( type ( 1  +  3j ))       # Complex number 
print ( type ( 'Asabeneh' ))   # String 
print ( type ([ 1 , 2 , 3 ]))    # List 
print ( type ({ 'name' : 'Asabeneh'})) # 字典
列印( type ({ 9.8 , 3.14 , 2.7 }))     # 設定
列印( type (( 9.8 , 3.14 , 2.7 )))     # 元組

要運行 python 檔案，請檢查下圖，您可以通過在 Visual Studio Code 上運行綠色按鈕或在終端中鍵入python helloworld.py來運行 python 檔案，

你真了不起，您剛剛完成了第 1 天的挑戰，正在走向偉大，

第 2 天 - 變數、內置函式

2.1內置函式

在 Python 中，我們有很多內置函式，內置函式可供您全域使用，這意味著您無需匯入或配置即可使用內置函式，一些最常用的 Python 內置函式如下：print()、len()、type()、int()、float()、str()、input()、list()、dict()、min()、max()、sum()、sorted()、open()、file()、help()和dir(). 在下表中，您將看到取自python 檔案的 Python 內置函式的詳盡串列，

讓我們打開 Python shell 并開始使用一些最常見的內置函式，

讓我們通過使用不同的內置函式來練習更多

從上面的終端可以看出，Python 有保留字，我們不使用保留字來宣告變數或函式，我們將在下一節介紹變數，

我相信，現在您已經熟悉內置函式了，讓我們再做一次內置函式的練習，我們將繼續下一節，

2.2變數

變數將資料存盤在計算機記憶體中，推薦在許多編程語言中使用助記變數，助記變數是易于記憶和關聯的變數名稱，變數是指存盤資料的記憶體地址，命名變數時不允許以數字開頭、特殊字符、連字符，變數可以有一個簡短的名稱（如 x、y、z），但強烈建議使用更具描述性的名稱（名字、姓氏、年齡、國家/地區），

Python 變數名規則

• 變數名必須以字母或下劃線字符開頭
• 變數名不能以數字開頭
• 變數名稱只能包含字母數字字符和下劃線（Az、0-9 和 _ ）
• 變數名區分大小寫（firstname、Firstname、FirstName 和 FIRSTNAME）是不同的變數）

讓我們設定有效的變數名

名
姓
年齡
國家
城市
名
姓
首都_城市
_if #如果我們想使用保留字作為變數
年_2021
2021年
當前_year_2021
出生年
編號 1
數量 2

無效的變數名

名
名
第一個$name
數字 1
1號

我們將使用許多 Python 開發人員采用的標準 Python 變數命名風格，Python 開發人員使用蛇形大小寫（snake_case）變數命名約定，對于包含多個單詞的變數（例如 first_name、last_name、engine_rotation_speed），我們在每個單詞后面使用下劃線字符，下面的例子是一個標準的變數命名示例，當變數名超過一個單詞時需要下劃線，

當我們為變數分配某種資料型別時，稱為變數宣告，例如，在下面的示例中，我的名字被分配給變數 first_name，等號是賦值運算子，賦值意味著將資料存盤在變數中，Python 中的等號與數學中的等號不同，

例子：

＃在Python變數
FIRST_NAME  =  'Asabeneh'
姓氏 =  'Yetayeh'
國家 =  '芬蘭
城市 =  '赫爾辛基'
年齡 =  250 
is_married  = 真
技能 = [ 'HTML' ，'CSS' ，'JS' ，'陣營'，' Python' ]
 person_info  = {
    'firstname' : 'Asabeneh' ,
    'lastname' : 'Yetayeh' ,
    '國家' ：'芬蘭',
    '城市' : '赫爾辛基' 
   }

讓我們使用print()和len()內置函式，列印函式采用無限數量的引數，引數是我們可以傳遞或放入函式括號內的值，請參見下面的示例，

例子：

print ( 'Hello, World!' ) # 文本 Hello, World! 是一個引數
print ( 'Hello' , ',' , 'World' , '!' ) # 它可以接受多個引數，已經傳遞了四個引數
print ( len ( 'Hello, World!' )) # 它只需要一個爭論

讓我們列印并找出在頂部宣告的變數的長度：

例子：

列印（'名字長度：'，first_name）
列印（'名字長度：'，len（first_name））
列印（'姓氏：'，last_name）
列印（'姓氏長度：'，len（last_name））
列印（'國家：'，國家）
列印（'城市：'，城市）
列印（'年齡：'，年齡）
列印（'已婚：' , is_married )
列印( '技能: ' ,技能)
列印( '個人資訊: ' , person_info )

2.3在一行中宣告多個變數

也可以在一行中宣告多個變數：

例子：

first_name , last_name , country , age , is_married  =  'Asabeneh' , 'Yetayeh' , 'Helsink' , 250 , True

列印（FIRST_NAME，姓氏，國家，年齡，is_married）
列印（'名字：'，FIRST_NAME）
列印（'姓：'，姓氏）
列印（'國家：'，國家）
列印（'年齡：'，年齡）
列印（'已婚：'，is_已婚）

使用input()內置函式獲取用戶輸入，讓我們將從用戶那里獲得的資料分配給 first_name 和 age 變數，
例子：

first_name  =  input ( '你叫什么名字：' )
 age  =  input ( '你多大了？'）

列印（名字）
列印（年齡）

2.4資料型別

Python 中有多種資料型別，為了識別資料型別，我們使用type內置函式，我想請你專注于很好地理解不同的資料型別，說到編程，全都與資料型別有關，我一開始就介紹了資料型別，它又來了，因為每個主題都與資料型別有關，我們將在它們各自的部分中更詳細地介紹資料型別，

2.5檢查資料型別和轉換

• 檢查資料型別：要檢查某些資料/變數的資料型別，我們使用型別
  示例：

# 不同的python 資料型別
# 讓我們宣告不同資料型別的變數

first_name  =  'Asabeneh'      # str 
last_name  =  'Yetayeh'        # str 
country  =  'Finland'          # str 
city =  'Helsinki'             # str 
age  =  250                    # int，這不是我的真實年齡，別擔心

# 列印型別
print ( type ( 'Asabeneh' ))      # str 
print ( type ( first_name ))      # str 
print ( type ( 10 ))              # int 
print ( type ( 3.14 ))            # float 
print ( type ( 1  +  1j ) )          # complex 
print ( type ( True ))            # bool 
print ( type([ 1 , 2 , 3 , 4 ]))      # list 
print ( type ({ 'name' : 'Asabeneh' , 'age' : 250 , 'is_married' : 250 }))     # dict 
print ( type (( 1 , 2 )))                                               # 元組
列印( type ( zip ([ 1 , 2 ],[ 3 , 4])))                                    # 設定

• 轉換：將一種資料型別轉換為另一種資料型別，我們使用int() , float() , str() , list , set
  當我們進行算術運算時，字串數字應該首先轉換為 int 或 float
  ，否則會回傳錯誤，如果我們把一個數字和一個字串連接起來，這個數字應該首先被轉換成一個字串，我們將在字串部分討論連接，

例子：

# int to float 
num_int  =  10 
print ( 'num_int' , num_int )          # 10 
num_float  =  float ( num_int )
 print ( 'num_float:' , num_float )    # 10.0

# 浮到 int
重力 =  9.81
列印( int ( gravity ))              # 9

# int to str 
num_int  =  10 
print ( num_int )                   # 10 
num_str  =  str ( num_int )
 print ( num_str )                   # '10'

# str to int or float 
num_str  =  '10.6' 
print ( 'num_int' , int ( num_str ))       # 10 
print ( 'num_float' , float ( num_str ))   # 10.6

# str to list 
first_name  =  'Asabeneh' 
print ( first_name )                # 'Asabeneh' 
first_name_to_list  =  list ( first_name )
 print ( first_name_to_list )             # ['A', 's', 'a', 'b', 'e', ' n', 'e', 'h']

2.6數字

Python 中的數字資料型別：

1. 整數：整數（負、零和正）數 示例：… -3, -2, -1, 0, 1, 2, 3 …
2. 浮點數（十進制數） 示例：… -3.5, -2.25, -1.0, 0.0, 1.1, 2.2, 3.5 …
3. 復數示例：1 + j、2 + 4j、1 - 1j

🌕你太棒了，您剛剛完成了第 2 天的挑戰，您在通往偉大的道路上領先了兩步，

第 3 天 - 運算子

3.1布林值

布爾資料型別表示兩個值之一：True或False，一旦我們開始使用比較運算子，這些資料型別的使用就會很清楚，與 JavaScript 不同，True的第一個字母T和False 的F應該大寫，
示例：

列印（真）
列印（假）

3.2運營商

Python 語言支持多種型別的運算子，在本節中，我們將重點介紹其中的幾個，

3.3賦值運算子

賦值運算子用于為變數賦值，讓我們以 = 為例，數學中的等號表示兩個值是相等的，但是在 Python 中這意味著我們將一個值存盤在某個變數中，我們稱之為賦值或賦值給變數，下表顯示了不同型別的 python 賦值運算子，

3.4算術運算子：

• 加法（+）：a + b
• 減法（-）：a - b
• 乘法（*）：a * b
• 除法（/）：a / b
• 模量(%): a % b
• 樓層劃分(//): a // b
• 求冪（**）：a ** b

3.5算術運算子

示例：整數

# Python 中的算術運算
# 整數

print ( 'Addition: ' , 1  +  2 )         # 3 
print ( 'Subtraction: ' , 2  -  1 )      # 1 
print ( 'Multiplication: ' , 2  *  3 )   # 6 
print ( 'Division: ' , 4  /  2 )        # Python 中的 2.0 Division 給出浮點數
print ( 'Division: ' , 6  /  2 )         # 3.0          
print ('Division: ' , 7  /  2 )         # 3.5 
print ( 'Division without the余數: ' , 7  //  2 )    # 3, 給出不帶浮點數或不帶余數
列印( 'Division without the余數: ' , 7  / /  3 )    # 2 
print ( 'Modulus: ' , 3  %  2 )          # 1, 給出余數
print ( 'Exponentiation: ' , 2  **  3 )# 9 表示 2 * 2 * 2

示例：浮點數

# 浮點數
print ( 'Floating Point Number, PI' , 3.14 )
 print ( 'Floating Point Number, Gravity' , 9.81 )

示例：復數

# 復數
print ( 'Complex number: ' , 1  +  1j )
 print ( 'Multiplying complex numbers: ' ,( 1  +  1j ) * ( 1  -  1j ))

讓我們宣告一個變數并分配一個數字資料型別，我將使用單字符變數，但請記住不要養成宣告此類變數的習慣，變數名應該一直是助記符，

例子：

# 首先宣告頂部的變數

a  =  3  # a 是變數名，3 是整數資料型別
b  =  2  # b 是變數名，3 是整數資料型別

# 算術運算并將結果賦值給變數
total  =  a  +  b 
diff  =  a  -  b 
product  =  a  *  b
除法 =  a  /  b
余數 =  a  %  b 
floor_division  =  a  //  b
指數 =  a  **  b

# 我應該使用 sum 而不是 total 但 sum 是一個內置函式 - 盡量避免覆寫內置函式
print ( total ) # 如果你沒有用一些字串標記你的列印，你永遠不知道結果在哪里from 
print ( 'a + b = ' , total )
 print ( 'a - b = ' , diff )
 print ( 'a * b = ' , product )
 print ( 'a / b = ' ,除法)
 print ( 'a % b = ' ,余數)
列印('a // b = ' , floor_division )
列印( 'a ** b = ' ,求冪)
例子：

列印（'==加法，減法，乘法，除法，模數=='）

# 宣告值并將它們組織在一起
num_one  =  3 
num_two  =  4

# 算術運算
total  =  num_one  +  num_two 
diff  =  num_two  -  num_one 
product  =  num_one  *  num_two 
div  =  num_two  /  num_one
余數 =  num_two  %  num_one

# 用標簽
列印值print ( 'total:' , total )
 print ( 'difference:' , diff )
 print ( 'product:' , product )
 print ( 'division:' , div )
 print ( 'remainder:' , remason )

讓我們開始連接點并開始利用我們已知的計算（面積、體積、密度、重量、周長、距離、力），

例子：

# 計算圓的面積
radius  =  10                                  #
圓的半徑area_of_circle  =  3.14  *  radius  **  2          # 兩個 * 符號表示指數或冪
print ( 'Area of?? a circle:' , area_of_circle )

# 計算矩形的面積
length  =  10 
width  =  20 
area_of_rectangle  =  length  *  width 
print ( 'Area of?? rectangle:' , area_of_rectangle )

＃計算的物體的重量
的質量 =  75
重力 =  9.81
重量 = 質量 * 重力
列印（重量，“N”）                          ＃添加單元的重量

# 計算液體
質量 的密度=  75  # 公斤
體積 =  0.075  # 立方米
密度 = 質量 / 體積 # 1000 Kg/m^3

3.6比較運算子

在編程中我們比較值，我們使用比較運算子來比較兩個值，我們檢查一個值是否大于或小于或等于其他值，

示例：比較運算子

print ( 3  >  2 )      # 真，因為 3 大于 2 
print ( 3  >=  2 )     # 真，因為 3 大于 2 
print ( 3  <  2 )      # 假，因為 3 大于 2 
print ( 2  <  3 )      # 真，因為 2 小于 3 
print ( 2  <=  3 )     # 真，因為 2 小于 3 
print ( 3  ==  2 )     # 假，因為 3 不等于 2
print ( 3  !=  2 )     # 真，因為 3 不等于 2 
print ( len ( 'mango' ) ==  len ( 'avocado' ))   # False 
print ( len ( 'mango' ) !=  len ( 'avocado ' ))   # True 
print ( len ( 'mango' ) <  len ( 'avocado' ))    # True 
print ( len ( 'milk' ) != len ( 'meat' ))       # False 
print ( len ( 'milk' ) ==  len ( 'meat' ))       # True 
print ( len ( 'tomato' ) ==  len ( 'potato' ))   # True 
print ( len ( 'python' ) >  len ( 'dragon' ))    # 假


# 比較某事給出真或假

列印（'真==真：'，真 == 真）
列印（'真==假：'，真 == 假）
列印（'假==假：'，假 == 假）

除了上述比較運算子之外，Python 還使用：

• is：如果兩個變數是同一個物件，則回傳 true（x 是 y）
• is not：如果兩個變數不是同一個物件，則回傳 true（x 不是 y）
• in：如果查詢串列包含某個專案（x in y），則回傳 True
• not in：如果查詢的串列沒有某個專案（x in y），則回傳 True

print ( '1 is 1' , 1  is  1 )                    # True - 因為資料值是相同的
print ( '1 is not 2' , 1  is  not  2 )            # True - 因為 1 is not 2 
print ( 'A in Asabeneh ' , 'A'  in  'Asabeneh' ) # True - A 在字串中找到
print ( 'B in Asabeneh' , 'B'  in  'Asabeneh' ) # False - 沒有大寫的 B 
print ( 'coding' 在 'coding for all' ) # True - 因為對 all 進行編碼有單詞 coding 
print ( 'a in an:' , 'a'  in  'an' )       # True 
print ( '4 is 2 ** 2:' , 4  is  2  **  2 )    # 真

3.7邏輯運算子

與其他編程語言不同，python 使用關鍵字and , or and not用于邏輯運算子，邏輯運算子用于組合條件陳述句：

print ( 3  >  2  and  4  >  3 ) # True - 因為兩個陳述句都是真的
print ( 3  >  2  and  4  <  3 ) # False - 因為第二個陳述句是假的
print ( 3  <  2  and  4  <  3 ) # False -因為這兩個陳述句都是假的
print ( 'True and True: ' , True  and  True )
 print ( 3  >  2  or  4 >  3 )   # True - 因為兩個陳述都是真的
print ( 3  >  2  or  4  <  3 )   # True - 因為其中一個陳述是真的
print ( 3  <  2  or  4  <  3 )   # False - 因為兩個陳述都是假的
print ( 'True or False:' , True  or  False )
 print ( not  3  >  2 )      # False - 因為 3 > 2 為真，那么 not True 給出 False 
print (not  True )       # False - 否定，not 運算子將 true 變為 false 
print ( not  False )      # True 
print ( not  not  True )   # True 
print ( not  not  False ) # False

🌕你有無限的能量，您剛剛完成了第 3 天的挑戰，您在通往偉大的道路上領先了三步，

第 4 天 - 字串

文本是一種字串資料型別，任何寫成文本的資料型別都是字串，單引號、雙引號或三引號下的任何資料都是字串，有不同的字串方法和內置函式來處理字串資料型別，要檢查字串的長度，請使用 len() 方法，

4.1創建字串

letter  =  'P'                 # 字串可以是單個字符或一堆文本
print ( letter )                # P 
print ( len ( letter ))           # 1 
greeting  =  'Hello, World!'   # 字串可以使用單引號或雙引號"Hello, World!" 
列印（問候）              #你好，世界！
print ( len ( greeting ))         # 13 
sentence  =  "我希望你享受 Python 挑戰的 30 天" 
print (句子）

多行字串是通過使用三重單引號 (’’’) 或三重雙引號 (""") 創建的，請參見下面的示例，

multiline_string  =  '''我是一名老師，喜歡教學，
我發現沒有什么比賦予人們權力更有價值的事情了，
這就是為什么我創建了 30 天的 python.''' 
print ( multiline_string )

# 做同樣事情的另一種方式
multiline_string  =  """我是一名老師，喜歡教書，
我沒有發現任何事情比賦予人們權力更有價值，
這就是我創建 30 天 Python 的原因，""" 
print ( multiline_string )

4.2字串連接

我們可以將字串連接在一起，合并或連接字串稱為串聯，請參閱下面的示例：

first_name  =  'Asabeneh' 
last_name  =  'Yetayeh' 
space  =  ' ' 
full_name  =  first_name   +   space  +  last_name 
print ( full_name ) # Asabeneh Yetayeh 
# 使用 len() 內置函式檢查字串的長度
print ( len ( first_name ))   # 8
列印( len ( last_name ))    # 7
列印( len ( first_name ) >  len (last_name )) # 真
列印( len ( full_name )) # 16

4.3字串中的轉義序列

在 Python 和其他編程語言中，\ 后跟一個字符是一個轉義序列，讓我們看看最常見的轉義字符：

1. \n: 換行
2. \t: Tab 表示（8 個空格）
3. \: 反斜杠
4. ‘: 單引號 (’)
5. “：雙引號 (”)

現在，讓我們通過示例來看看上述轉義序列的使用，

print ( '我希望每個人都喜歡 Python 挑戰，\n你是嗎？' ) # 換行符
print ( 'Days \t Topics \t Exercises' ) # 添加制表符空格或 4 個空格
print ( 'Day 1 \t 3 \ t 5' )
列印( 'Day 2 \t 3 \t 5' )
列印( 'Day 3 \t 3 \t 5' )
列印( 'Day 4 \t 3 \t 5' )
print ( '這是一個反斜杠符號 ( \\ )' ) # 寫一個反斜杠
print ( '在每種編程語言中它都以\" Hello, World! \" ' ' ) # 在單引號內寫一個雙引號

＃輸出
我 希望 每 一個 被 欣賞 的 Python的 挑戰，
是 你？
Days 	Topics	練習
Day  1 	5 	    5 
Day  2 	6 	    20 
Day  3 	5 	    23 
Day  4 	1 	    35
這 是 一個 反斜杠  符號(\)
在 每種 編程 語言中， 它都 以“Hello, World!”開頭 ， 

4.4字串格式化

舊式字串格式（% 運算子）

在 Python 中有很多格式化字串的方法，在本節中，我們將介紹其中的一些，“%”運算子用于格式化包含在“元組”（固定大小的串列）中的一組變數，以及一個格式字串，其中包含普通文本和“引數說明符”，特殊符號如“%s” , “%d”, “%f”, “%.number of numbersf”，

1. %s - 字串（或任何具有字串表示的物件，如數字）
2. %d - 整數
3. %f - 浮點數
4. “%.number of digitsf” - 具有固定精度的浮點數

＃字串只
FIRST_NAME  =  'Asabeneh'
姓氏 =  'Yetayeh'
語言 =  'Python的
formated_string  =  “我是％s％S，我教 %s'  % ( first_name , last_name , language )
列印( formated_string )

# 字串和數字
radius  =  10 
pi  =  3.14 
area  =  pi  *  radius  **  2 
formated_string  =  '半徑為 %d 的圓的面積是 %.2f.'  % ( radius , area ) # 2 指的是點后的 2 個有效數字

python_libraries  = [ 'Django的，'瓶'，'NumPy的'，'Matplotlib' ，'熊貓' ]
 formated_string  =  '以下是Python庫：％s'的 ％（python_libraries）
列印（formated_string）＃“下面是Python庫:['Django', 'Flask', 'NumPy', 'Matplotlib','Pandas']"

新樣式字串格式 (str.format)

這種格式是在 Python 版本 3 中引入的，

FIRST_NAME  =  'Asabeneh'
姓氏 =  'Yetayeh'
語言 =  'Python的
formated_string  =  “我{} {}，我教 {}'，格式（名字，姓氏，語言）
列印（格式化字串）
 a  =  4 
b  =  3

列印( '{} + {} = {}' .格式( a , b , a  +  b ))
列印( '{} - {} = {}' .格式( a , b , a  -  b ))
列印( '{} * {} = {}' . format ( a , b , a  *  b ))
 print ( '{} / {} = {:.2f}' . format ( a , b , a /  b )) # 限制為小數點后兩位數
print ( '{} % {} = {}' . format ( a , b , a  %  b ))
 print ( '{} // {} = {}' .格式( a , b , a  //  b ))
列印( '{} ** {} = {}' . format ( a , b , a  **  b ))

# 輸出
4  +  3  =  7 
4  -  3  =  1 
4  *  3  =  12 
4  /  3  =  1.33 
4  %  3  =  1 
4  //  3  =  1 
4  **  3  =  64

# 字串和數字
radius  =  10 
pi  =  3.14 
area  =  pi  *  radius  **  2 
formated_string  =  '半徑為 {} 的圓的面積是 {:.2f}.' . format ( radius , area ) # 小數點后 2 位
列印( formated_string )

字串插值 / f-Strings (Python 3.6+)

另一種新的字串格式是字串插值，f-strings，字串以 f 開頭，我們可以在相應的位置注入資料，

a  =  4 
b  =  3
列印( f' { a } + { b } = { a  + b } ' )
列印( f' { a } - { b } = { a  -  b } ' )
列印( f' { a } * { b } = { a  *  b } ')
列印( f' { a } / { b } = { a  /  b :.2f } ' )
列印( f' { a } % { b } = { a  %  b } ' )
列印( f' { a } / / { b } = { a  //  b } ' )
列印(f' { a } ** { b } = { a  **  b } ' )

4.4Python 字串作為字符序列

Python 字串是字符序列，并與其他 Python 有序物件序列（串列和元組）共享它們的基本訪問方法，從字串（以及任何序列中的單個成員）中提取單個字符的最簡單方法是將它們解包到相應的變數中，

拆包字符

language = 'Python'
a,b,c,d,e,f = language # unpacking sequence characters into variables
print(a) # P
print(b) # y
print(c) # t
print(d) # h
print(e) # o
print(f) # n

通過索引訪問字串中的字符

在編程中計數從零開始，因此，字串的第一個字母的索引為零，字串的最后一個字母是字串的長度減一，

language  =  'Python' 
first_letter  =  language [ 0 ]
 print ( first_letter ) # P 
second_letter  =  language [ 1 ]
 print ( second_letter ) # y 
last_index  =  len ( language ) -  1 
last_letter  =  language [ last_index ]
 print ( last_letter ) # n

如果我們想從右端開始，我們可以使用負索引，-1 是最后一個索引，

language  =  'Python' 
last_letter  =  language [ - 1 ]
 print ( last_letter ) # n 
second_last  =  language [ - 2 ]
 print ( second_last ) # o

切片 Python 字串

在 python 中，我們可以將字串切片為子字串，

language  =  'Python' 
first_three  =  language [ 0 : 3 ] # 從零索引開始，最多 3 但不包括 3 
print ( first_three ) #Pyt 
last_three  =  language [ 3 : 6 ]
 print ( last_three ) # hon 
# 另一種方式
last_three  =  language [ - 3 :]
 print ( last_three )    # hon 
last_three  =  language [3 :]
列印( last_three )    # 親愛的

反轉字串

我們可以輕松地在 python 中反轉字串，

問候 =  '你好，世界！
列印（問候[:: - 1 ]）# !dlroW ,olleH

切片時跳過字符

通過將 step 引數傳遞給 slice 方法，可以在切片時跳過字符，

language  =  'Python' 
pto  =  language [ 0 : 6 : 2 ] # 
print ( pto ) # Pto

4.5字串方法

有許多字串方法允許我們格式化字串，請參閱以下示例中的一些字串方法：

• 大寫（）：將字串的第一個字符轉換為大寫字母

挑戰 =  “30DaysOfPython”
列印（挑戰，利用（））＃“30DaysOfPython”

• count()：回傳字串中子字串的出現次數，count(substring, start=…, end=…)，start
  是計數的起始索引，end 是要計數的最后一個索引，

挑戰 =  '30DaysOfPython'
列印（挑戰，計數（'Y' ））＃3
印刷（挑戰，計數（'Y' ，7，14））＃1，
列印（挑戰，計數（'日'））# 2`

• Endswith()：檢查字串是否以指定的結尾結尾

挑戰 =  '30DaysOfPython'
列印（挑戰，的endsWith（'開'））   ＃真
印刷（挑戰，的endsWith（'灰'）） ＃假

• expandtabs()：用空格替換制表符，默認制表符大小為 8，它接受制表符大小引數

挑戰 ='thirty\tdays\tof\tpython'
列印（挑戰，expandtabs（））    ＃“30天”
列印（挑戰，expandtabs（10））＃“30天”

• find()：回傳子字串第一次出現的索引，如果沒有找到回傳-1

挑戰 =  '30DaysOfPython'
列印（挑戰，找到（'Y' ））   ＃16
列印（挑戰，找到（'日'））＃17

• rfind()：回傳子串最后一次出現的索引，如果沒有找到回傳-1

挑戰 =  '30DaysOfPython'
列印（挑戰，RFIND（'Y' ））   ＃5
列印（挑戰，RFIND（'日'））＃1

• format(): 將

first_name  =  'Asabeneh' 
last_name  =  'Yetayeh' 
age  =  250 
job  =  'teacher' 
country  =  'Finland' 
sentence  =  '我是{} {}，我是一個 {}，我已經 {} 歲了，我住在 {}，' . 格式（FIRST_NAME，姓氏，年齡，職業，國家）
列印（句）＃我Asabeneh Yetayeh，我今年 250 歲，我是老師，我住在芬蘭，

radius  =  10 
pi  =  3.14 
area  =  pi  *  radius  **  2 
result  =  '半徑為 {} 的圓的面積為 {}'，format ( str ( radius ), str ( area ))
 print ( result ) #半徑為10的圓的面積是314

• index()：回傳子字串的最低索引，附加引數表示開始和結束索引（默認為 0 和字串長度 - 1），如果未找到子字串，則會引發
  valueError，

挑戰 =  '30DaysOfPython' 
SUB_STRING  =  'DA'
列印（挑戰，指數（SUB_STRING））   ＃7
列印（挑戰，指數（SUB_STRING，9）） ＃錯誤

• rindex()：回傳子串的最高索引，附加引數表示起始和結束索引（默認0和字串長度-1）

挑戰 =  '30DaysOfPython' 
SUB_STRING  =  'DA'
列印（挑戰，RINDEX（SUB_STRING））   ＃8
列印（挑戰，RINDEX（SUB_STRING，9）） ＃錯誤

• isalnum()：檢查字母數字字符

挑戰 =  '30DaysOfPython'
列印（挑戰，字符isalnum（）） ＃真

挑戰 =  '30DaysPython'
列印（挑戰，字符isalnum（）） ＃真

挑戰 =  “30DaysOfPython”
列印（挑戰，字符isalnum（）） ＃假，空間不是字母數字字符

挑戰 =  '30DaysOfPython2019的'
列印（挑戰，字符isalnum（）） ＃假

• isalpha()：檢查所有字串元素是否都是字母字符（az 和 AZ）

挑戰 =  '30DaysOfPython'
列印（挑戰，因而isalpha（）） ＃假，空間被再次排除
挑戰 =  'ThirtyDaysPython'
列印（挑戰，因而isalpha（）） ＃真
NUM  =  '123'
列印（NUM，因而isalpha（ ))       # 錯誤

• isdecimal(): 檢查字串中的所有字符是否都是十進制 (0-9)

挑戰 =  '30DaysOfPython'
列印（挑戰，isdecimal（））  ＃假
的挑戰 =  '123'
列印（挑戰，isdecimal（））  ＃真
挑戰 =  ' \ u00B2 '
列印（挑戰，ISDIGIT（））   ＃假
的挑戰 =  '12 3'
列印（挑戰，isdecimal（））  ＃假，空間不允許

• isdigit()：檢查字串中的所有字符是否都是數字（0-9 和其他一些用于數字的 unicode 字符）

挑戰 =  '30DaysOfPython'
列印（挑戰，ISDIGIT（）） ＃假
的挑戰 =  '30'
列印（挑戰，ISDIGIT（））   ＃真
挑戰 =  ' \ u00B2 '
列印（挑戰，ISDIGIT（））   ＃真

• isnumeric()：檢查字串中的所有字符是否都是數字或數字相關的（就像 isdigit()，只接受更多的符號，比如 ?）

NUM  =  '10'
印刷（NUM，ISNUMERIC（）） ＃真
NUM  =  ' \ u00BD '  ＃?
列印（NUM，ISNUMERIC（）） ＃真
NUM  =  '10 0.5'
列印（NUM，ISNUMERIC（）） ＃假

• isidentifier()：檢查一個有效的識別符號——它檢查一個字串是否是一個有效的變數名

挑戰 =  '30DaysOfPython'
列印（挑戰，isIdentifier不同（）） ＃假的，因為它以數字開頭的
挑戰 =  '30_days_of_python'
列印（挑戰，isIdentifier不同（）） ＃真

• islower()：檢查字串中的所有字母字符是否都是小寫

挑戰 =  “30 days of python”
列印（挑戰，islower判斷（）） ＃真
挑戰 =  “30 days of python”
列印（挑戰，islower判斷（）） ＃假

• isupper()：檢查字串中的所有字母字符是否都是大寫

挑戰 =  “30 days of python”
列印（挑戰，isupper（）） ＃假
的挑戰 =  '30 days of python
列印（挑戰，isupper（）） ＃真

• join()：回傳一個連接的字串

web_tech  = [ 'HTML' , 'CSS' , 'JavaScript' , 'React' ]
 result  =  ' '，join ( web_tech )
 print ( result ) # 'HTML CSS JavaScript React'
web_tech  = [ 'HTML' , 'CSS' , 'JavaScript' , 'React' ]
 result  =  '# '，join ( web_tech )
 print ( result ) # 'HTML# CSS# JavaScript# React'

• strip()：從字串的開頭和結尾洗掉所有給定的字符

Challenge  =  '30 days of python' 
print ( challenge . strip ( 'noth' )) # '三十天的 py'

• replace()：用給定的字串替換子字串

挑戰 =  “30 days of python”
列印（挑戰，替換（“Python”，“編碼”））＃“30天編碼”

• split()：拆分字串，使用給定的字串或空格作為分隔符

挑戰 =  “30 days of python”
列印（挑戰，分裂（））＃[“30”，“天”，“of”，“Python”]
挑戰 =  “30，天，，Python”
列印（挑戰，分裂( ', ' )) # ['30', '天', 'of', 'python']

• title()：回傳一個標題大小寫的字串

挑戰 =  “30 days of python”
列印（挑戰，標題（）） ＃Python30天

• swapcase()：將所有大寫字符轉換為小寫，將所有小寫字符轉換為大寫字符

挑戰 =  '30 days of python'
列印（挑戰，的swapCase（））   # Python30天
挑戰 =  '30 days of python'
列印（挑戰，的swapCase（））  # Python30天

 - startswith()：檢查字串是否以指定的字串開頭

```python
挑戰 =  “30 days of python”
列印（挑戰，startswith（“30”）） ＃真

挑戰 =   '30 days of python'
列印（挑戰，startswith（'30'）） ＃假

🎉 恭喜！ 🎉你是一個非凡的人，你有非凡的潛力，您剛剛完成了第 4 天的學習，

今天分享的字數已經很多了，作為一個續集更新，感興趣了解下面的學習內容，記得關注我，你們的三連是我持續輸出的動力，感謝，