強烈推薦系列教程，建議學起來！！

十萬字python基礎教程，學不會主頁聯系找我！

qq機器人制作系列講解專欄
qq機器人b站視頻教程

三萬字SQL資料庫小白到精通系列

數學建模小白到精通系列

一.pycharm下載安裝

pycharm下載地址：
http://www.jetbrains.com/pycharm/download/#section=windows
下載詳細步驟：
1-

2-

3-

4-

5-

6

7-

8-直接finish

二.python下載安裝

9-python官網：

https://www.python.org/

進去網址后點擊：

10

11-下載好后

12-添加環境變數





記得雙擊安裝：

三.pycharm上配置python

13-雙擊桌面pycharm

隨便取個名字（我取的學習），直接點擊create.
遇到如下情況，則點擊ok(沒遇到就算了)

14-添加解釋器





成功如下：

列印成功：標志配置完成

四.配置鏡像源讓你下載嗖嗖的快

我喜歡用清華的，所以我在這里介紹都用清華源，當然這里是一些比較好用的鏡像源：

清華：https://pypi.tuna.tsinghua.edu.cn/simple
阿里云：http://mirrors.aliyun.com/pypi/simple/
中國科技大學 https://pypi.mirrors.ustc.edu.cn/simple/

一共有三種鏡像源配置，建議你每一種都跟我一起學會，

4.1pycharm內部配置

第一步：

第二步：

第三步：


第四步：
復制上面的清華鏡像源粘貼，然后okokokok

測驗，遇到了這個問題：
pip : 無法將“pip”項識別為 cmdlet、函式、腳本檔案或可運行程式的名稱，請檢查名稱的拼寫，如果包括路徑，請確保路徑正確，然后再試一次，

因為我忘記給pip加環境變數了，所以加一下，一次如下：

第五步：
退出pycharm,因為加了環境變數需要重啟軟體，我們先到cmd輸入pip,如下就是配置成功了：

第六步：
重啟軟體后，隨便裝一個模塊，如下：（你可以看到下載模塊速度很快！）

4.2手動添加鏡像源

使用方法：

pip install 下載的模塊名 -i https://pypi.tuna.tsinghua.edu.cn/simple

比如我要下載numpy這個模塊，執行以下命令：

pip install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple

幾秒就好了：

這個方法的好處就是，你不用像其它配置一樣要去配置一遍，你只需要在后面加上：

-i https://pypi.tuna.tsinghua.edu.cn/simple

4.3永久配置鏡像源

這個配置我是建議你一定要添加配置，
方法一：
到cmd執行如下命令創建pip.ini:

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

回傳：

然后我們把這個路徑添加到系統環境變數就好了（怎么添加環境變數？跟前面給pip添加環境變數一樣操作，只是路徑不一樣）

方法二：
如果剛剛這個命令你執行失敗，你可以自己在c盤創建一個檔案名叫做pip，pip檔案夾下創建一個檔案名pip.ini,內容為：

[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple

還是一樣添加到環境變數，

五.插件安裝（比如漢化？）

首先個人不建議漢化，最后我再演示漢化插件，我是想要推薦一些不錯的插件，
首先進入如下界面：

5.1自動補碼神器第一款

推薦使用：TabNine，當然kite也不錯，你可以都安裝，我是都在用，我演示一款：

彈出這個頁面刪了不要管：

測驗：已經開始有提示了

5.2漢化pycharm

首先，個人不建議漢化，不管你英語好不好，都要去適應這個英語界面，當然你實在需要漢化，這是教程：

現在就已經全部漢化：

5.3其它插件

如果需要下載別的插件，你可以百度搜一下pycharm有哪些好的插件，都是安裝上述方式安裝，

六.美女背景

你是否想要如下桌面？

教程傳送門：
美女桌面背景設定

七.自定義腳本開頭

你是都在先每次創建一個檔案，開頭都是如下？

教程傳送門：
自定義腳本開頭

八、這個前言一定要看

擁有本篇文章，意味著你擁有一本最完善的書籍，講得比書上全，語法也會比買的書上更詳細，大家要慢慢看，擁有本篇文章，你將基礎無敵，從此可以有能力自學一些高級教程，作者寫了好幾天，實在很累，希望你三連支持，

python，言簡意賅就是：通俗易懂，功能強大無比，上手快，實用強，你跟著我在這里認真學完這一篇，你一定會學會最扎實的python基礎，同時我還可以提供免費輔導，作者本是一名學生，并不圖有任何好處，如果需要輔導，可以加從左側欄加群，當然僅是交流，不會有時間一直教你，只能幫助你解決一些問題，更多要靠自己，

九、python入門

軟體安裝我就不介紹了，大家b站搜一下python和pycharm安裝安裝即可，個人是推薦python和pycharm結合使用，pycharm是什么？是python的編譯器，如果我們沒有編譯器，寫代碼是很困難的，而且pycharm提供了許多插件和優美的界面，使得你寫代碼又快又舒服，不會因為在python的IDE上寫得頭疼，
當然!下載軟體不用到官網下，你只需要到軟體管家下載即可，我也是這個公眾號的忠實粉絲了，
入門第一步：列印

print("Hello, World!")

當然，你想列印別的也可以，對吧？

print('川川帥哥，我愛你')

十、python縮進

最基本的語法，我不可能在這里把所有的語法都講一遍，但是最基本語法要說一下，在這里，我們又不得不鳴謝pycharm編譯器，實在幫助我們太多了，為什么這么說？pycharm中，它會自動幫助我們完成換行，縮進等問題，不會像IDE中寫代碼，要自己手動，如果忘記手動就回報錯，因此我是不建議只用python解釋器，一定要用pycharm!

舉一些例子,當然，如果你是小白，現在只會列印，大可不必著急，你只需要看看，后面我會講到，
比如縮進問題，縮進是指代碼行開頭的空格，if后面的陳述句需要tap一下（當然，如果你用pycharm編譯器，會自動tap），
例如：

if 6 > 2:
  print("六大于二")

十一、Python注釋

注釋可用于解釋 Python 代碼，注釋可用于使代碼更具可讀性，注釋可用于在測驗代碼時阻止執行，

1.單行注釋

將需要注釋的部分開頭用#
例如：

#川川真帥
print('川川帥哥，我愛你')

或者這樣：

print("Hello, World!") #川川真帥

你可以看到如下，這就是注釋意義了，懂了吧，

2.多行注釋

第一種方法（不建議，太麻煩）

#川川真帥
#川川真帥
#川川真帥
print("Hello, World!")

你也可以左鍵選中我們需要注釋的代碼，松開，按：Ctrl+/，就完成相同效果注釋，
第二種方法：
把要注釋的內容放到三個引號對里面，，例如：

'''
川川真帥
川川真帥
'''
print('川川帥哥，我愛你')

取消注釋
左鍵選中我們需要取消注釋的代碼，松開，按：Ctrl+/

十二、Python 變數

1.變數定義理解

在 Python 中，當你給它賦值時就會創建變數：Python 沒有用于宣告變數的命令，變數在您第一次為其賦值時創建，
例如：

x = 5
y = "川川"
print(x)
print(y)

對于同一個變數，賦值型別不同則會發生型別的變化，例如：

x = 4       # x 現在是整形
x = "川川" # x 現在是字串
print(x)

則列印為：

如果要指定變數的資料型別，可以通過強制轉換來完成，比如：

x = str(3)    # x will be '3'
y = int(3)    # y will be 3
z = float(3)  # z will be 3.0

那么剛剛我說到了型別，小白肯定還不知道型別是什么，怎么查看,我們來說一下如何獲取型別，這里我們要用到type函式，舉個例子：

x = 5
y = "川川"
print(type(x))
print(type(y))

看看回傳什么：int為整形，str為字串，這是你要背的，

可以使用單引號或雙引號來宣告字串變數：

x1 = "川川真棒"
x2 = '川川真棒'
print(x1)
print(x2)

回傳為：

變數名區分大小寫：

a = 4
A = "川川"
print(a)
print(A)

回傳為：

2. 變數名命名

變數可以有一個簡短的名稱（如 x 和 y）或一個更具描述性的名稱（age、carname、total_volume），Python 變數的規則：

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

例如：

myvar = "川川"
my_var = "川川""
_my_var = "川川""
myVar = "川川""
MYVAR = "川川""
myvar2 = "川川""

命名法則：
駱駝法則：除了第一個單詞外，每個單詞都以大寫字母開頭

myNameIs = "川川"

帕斯卡法則：每個單詞都以大寫字母開頭

MyNameIs = "川川"

蛇形法則：每個單詞由下劃線字符分隔

My_Name_Is = "川川"

3. 分配多個值

多個變數的多個值，
Python 允許您在一行中為多個變數賦值：

x, y, z = "川川一號", "川川二號", "川川三號"
print(x)
print(y)
print(z)

輸出為：

注意：確保變數的數量與值的數量相匹配，否則你會得到一個錯誤，

多個變數的一個值
您可以在一行中為多個變數分配相同的值：

x = y = z = "川川菜鳥"
print(x)
print(y)
print(z)

輸出為：

打開一個集合
如果您在串列、元組等中有一組值，Python 允許您將值提取到變數中，這稱為拆包，當然，在這里，你可能還不知道集合串列，元組是什么，沒有關系，后面我會講到，

fruits = ["apple", "banana", "cherry"]
x, y, z = fruits
print(x)
print(y)
print(z)

4. 輸出變數

print陳述句通常用于輸出變數，
為了組合文本和變數，Python 使用 +字符：

x = "川川"
print("帥哥是" + x)

輸出為：

您還可以使用該+字符將一個變數添加到另一個變數中：

x = "川川真"
y = "帥"
z = x + y
print(z)

回傳一樣：

對于數字，該+字符用作數學運算子：

x = 6
y = 10
print(x + y)

回傳：

如果你嘗試組合一個字串和一個數字，Python 會給你一個錯誤，比如：

?```c
x = 5
y = "川川"
print(x + y)

該怎么修改呢？把數字轉為字符即可，則修改為：

x = 5
y = "川川"
print(str(x) + y)

成功回傳：

5. 全域變數與區域變數，全域關鍵字

在函式外部創建的變數稱為全域變數，都可以使用全域變數，無論是在函式內部還是外部，當然，在這里，你可能還不知道函式是什么，后面我會講到，大可不必慌張，

x = "川川"
def myfunc():
  print("帥哥是 " + x)
myfunc()

回傳為：

如果在函式內部創建同名變數，該變數將是區域變數，只能在函式內部使用，具有相同名稱的全域變數將保持原樣，全域且具有原始值，

x = "awesome"

def myfunc():
  x = "fantastic"
  print("Python is " + x)

myfunc()

print("Python is " + x)

回傳為：

全域關鍵字
通常，當您在函式內部創建變數時，該變數是區域的，并且只能在該函式內部使用，要在函式內創建全域變數，可以使用 global關鍵字，

x = "帥哥"

def myfunc():
  global x
  x = "菜鳥"

myfunc()

print("川川" + x)

回傳為：

6. 練習題

1. 創建一個名為的變數carname并為其賦值菜鳥，
2. 創建一個名為的變數x并為其賦值60，
3. 5 + 10使用兩個變數x和y，顯示，列印它們的總和
4. 創建一個名為的變數z，x=8,y=9,分配x + y給它，并顯示結果，

十三、Python資料型別

1.置資料型別

默認情況下，Python 具有以下內置資料型別，在這些類別中：

文本型別：	str
數字型別：	int, float, complex
序列型別：	list, tuple, range
映射型別：	dict
套裝型別：	set, frozenset
布爾型別：	bool
二進制型別：	bytes, bytearray, memoryview

此時你大可不必知道這些型別到底是什么，在后續的深入中，你一定會用得到，所以是需要記住的，

2.獲取資料型別

您可使用以下type()函式獲取任何物件的資料型別，
例如，列印變數 x 的資料型別：

x = 6
print(type(x))

我們可以看到回傳為：int型別

3.設定資料型別

在 Python 中，資料型別是在為變數賦值時設定的，
例如以下例子，
str字串：

x = "Hello World"
print(x)
print(type(x)) 

int整形：

x1 = 6
print(type(x1))

float浮點型別：

x2 = 6.5
print(type(x2))

complex復數型別：

x3 = 2j
print(x3)
print(type(x3))

list串列型別：

x4 = ["apple", "banana", "cherry"]
print(x4)
print(type(x4))

tuple元祖型別：

x5 = ("apple", "banana", "cherry")
print(x5)
print(type(x5)) 

后面還有其它一些型別，我就不以完整代碼形式演示了，直接以例子形式讓大家看看什么樣子是什么型別，當然如果你能親自動手像我上面的例子一樣進行操作列印看一看就再好不過了，
range范圍型別

x = range(6

dict字典型別

x = {"name" : "John", "age" : 36}	

set集合型別：

x = {"apple", "banana", "cherry"}

不常用的凍結集型別：

x = frozenset({"apple", "banana", "cherry"})

bool布爾型別：

x = True

不常用byte位元組型別：

x = b"Hello"

不常用bytearray位元組陣列型別：

x = bytearray(5)

更有冷門到爆的memoryview記憶體試圖型別

x = memoryview(bytes(5))

4.設定特定資料型別

我會舉一些例子說明，盡量很全，大可不必擔心，先舉一個完整例子，后面的是一樣的列印就不演示了，
強調特定x為字串：

x = str("Hello World")
print(x)
print(type(x))

回傳為：

強調x為整形：

x = int(20)

強調x為浮點：

x = float(20.5)

強調x為復數：

x = complex(1j)

強調為串列

x = list(("apple", "banana", "cherry"))

強調為元祖

x = tuple(("apple", "banana", "cherry"))

強調為范圍

x = range(6)

強調為字典

x = dict(name="John", age=36)

強調為集合

x = set(("apple", "banana", "cherry"))

強調凍結集（沒啥用的型別）

x = frozenset(("apple", "banana", "cherry"))

強調布爾型別

x = bool(5)

強調位元組型別

x = bytes(5)

強調位元組組型別

x = bytearray(5)

強調記憶體試圖型別（又是沒啥用的型別）

x = memoryview(bytes(5))

6.練習題

回答下面的問題結果為什么型別？
1-

x = 5
print(type(x))

2-

x = "Hello World"
print(type(x))

3-

x = 20.5
print(type(x))

4-

x = ["apple", "banana", "cherry"]
print(type(x))

5-

x = ("apple", "banana", "cherry")
print(type(x))

6-

x = {"name" : "John", "age" : 36}
print(type(x))

7-

x = True
print(type(x))

十四、python數字

Python 共有三種數字型別：

• int
• float
• complex
  三種型別分別對應如下例子：

x = 1    # int
y = 2.8  # float
z = 1j   # complex

要驗證 Python 中任何物件的型別，請使用以下type()函式：

print(type(x))
print(type(y))
print(type(z))

因此你可以運行如下代碼：

x = 1    # int
y = 2.8  # float
z = 1j   # complex
print(type(x))
print(type(y))
print(type(z))

1.整數

Int 或 integer，是一個整數，正負，不帶小數，長度不限，
例如：

x = 1
y = 3562254887
z = -35522
print(type(x))
print(type(y))
print(type(z))

2.浮點數

浮點數或“浮點數”是包含一位或多位小數的正數或負數，
例如：

x = 1.10
y = 1.0
z = -35.59
print(type(x))
print(type(y))
print(type(z))

浮點數也可以是帶有“e”的科學數字，表示 10 的冪，
例如：

x = 35e3
y = 12E4
z = -87.7e100

print(type(x))
print(type(y))
print(type(z))

3.虛數

復數寫有“j”作為虛部，

x = 3+5j
y = 5j
z = -5j

print(type(x))
print(type(y))
print(type(z))

4.型別轉換

比如你可以從一種型別轉變成另一種同int()， float()和complex()方法，
例如：（你可以親自運行一下）

x = 1    # int
y = 2.8  # float
z = 1j   # complex


a = float(x)


b = int(y)


c = complex(x)

print(a)
print(b)
print(c)

print(type(a))
print(type(b))
print(type(c))

5.亂數

Python 有一個內置模塊 random可以用來生成亂數，
示例：匯入 random 模塊，并顯示 1 到 10之間的一個亂數：

import random
print(random.randrange(1, 11))

6.練習題

1-插入正確的語法將 x 轉換為浮點數，

x = 5
x = _(x)

2-插入正確的語法以將 x 轉換為整數，

x = 5.5
x = _(x)

3-插入正確的語法以將 x 轉換為復數，

x = 5
x = _(x)

十五、python指定變數型別

python 中的轉換是使用建構式完成的：

• int() - 從整數文字、浮點文字（通過洗掉所有小數）或字串文字（提供字串表示整數）構造整數
• float() - 從整數文字、浮點文字或字串文字構造浮點數（提供字串表示浮點數或整數）
• str() - 從多種資料型別構造一個字串，包括字串、整數文字和浮點文字

我將每一個型別都舉例子說明，
整數

x = int(1)   # x will be 1
y = int(2.8) # y will be 2
z = int("3") # z will be 3

浮點

x2 = float(1)     # x will be 1.0
y2 = float(2.8)   # y will be 2.8
z2 = float("3")   # z will be 3.0
w2 = float("4.2") # w will be 4.2

字串

x1 = str("s1") # x will be 's1'
y1 = str(2)    # y will be '2'
z1 = str(3.0)  # z will be '3.0'

十六、Python字串

一.字串基本使用

1.字串理解

python 中的字串被單引號或雙引號包圍，'hello’與"hello"相同，您可以使用以下print()函式顯示字串文字：

print("Hello")
print('Hello')

2.將字串分配給變數

a = "川川"
print(a)

3.多行字串

您可以使用三個引號將多行字串分配給變數：

a = """從前有座山，
山里有座廟
廟里有個小和尚"""
print(a)

回傳如下：

或三個單引號：

a = '''從前有座山，
山里有座廟
廟里有個小和尚'''
print(a)

4.字串是陣列

Python 沒有字符資料型別，單個字符只是一個長度為 1 的字串，方括號可用于訪問字串的元素，這里用到了切片，你可以不懂，
獲取位置 1 處的字符（記住第一個字符的位置為 0）：

a = "Hello, World!"
print(a[1])

5.遍歷字串

回圈遍歷單詞“chuanchuan”中的字母：

for x in "chuanchuan":
  print(x)

6.字串長度

len()函式回傳字串的長度，注意標點符號和空格也算一個長度：

a = "Hello, World!"
print(len(a))

7.檢查字串

要檢查字串中是否存在某個短語或字符，我們可以使用關鍵字 in，

txt = "The best things in life are free!"
print("free" in txt)

回傳布爾型別(True代表有)：

也可以通過if來判斷是否存在：

txt = "The best things in life are free!"
if "free" in txt:
  print("是的, 'free'存在.")

8.檢查如果不是

檢查以下文本中是否不存在“川川”：

txt = "川川就讀上海交大!"
print("川川" not in txt)

因為存在，回傳false:

僅在不存在“川川”時才列印：

txt = "川川就讀上海交大!"
if "川川" not in txt:
  print("No, '川川' 不在檔案.")

因為不符合條件，所以不會列印，

二.切片字串

1.切片

您可以使用切片語法回傳一系列字符，指定開始索引和結束索引，以冒號分隔，以回傳字串的一部分，
示例：獲取從位置 2 到位置 5 的字符（不包括在內）：

b = "Hello, World!"
print(b[2:5])

回傳為：

注意：第一個字符的索引為 0，

2.從頭開始切片

示例：獲取從開始到位置 5 的字符（不包括在內）：

b = "Hello, World!"
print(b[:5])

回傳為：

3.切到最后

通過省略結束索引，范圍將到最后，
例如，獲取從位置 2 到最后的字符：

b = "Hello, World!"
print(b[2:])

回傳：

4.負索引

使用負索引從字串末尾開始切片，就是從右往左看，不再是從左往右看，
例如：

b = "Hello, World!"
print(b[-5:-2])

回傳為：

三.修改字串

1.小寫轉大寫

upper()方法以大寫形式回傳字串：

a = "Hello, World!"
print(a.upper())

回傳為：

2.大寫轉小寫

lower()方法以小寫形式回傳字串：

a = "Hello, World!"
print(a.lower())

回傳為：

3.洗掉空格

空白是實際文本之前和/或之后的空間，通常您想洗掉這個空間，
strip()方法從開頭或結尾洗掉任何空格：

a = " Hello, World! "
print(a.strip())

回傳為：

4.替換字串

replace()方法用另一個字串替換一個字串.

a = "Hello, World!"
print(a.replace("H", "J"))

回傳為：

5.拆分字串

split()方法回傳一個串列，其中指定分隔符之間的文本成為串列項，split()如果找到分隔符的實體，該方法會將字串拆分為子字串，
例如我要將下面的字串以逗號分隔：

a = "Hello, World!"
print(a.split(","))

回傳為：

四.字串連接

要連接或組合兩個字串，您可以使用 + 運算子，
例如，將變數a與變數b, 合并到變數中c：

a = "Hello"
b = "World"
c = a + b
print(c)

回傳為：

例如要在a和b變數之間添加空格，請添加" "：

a = "Hello"
b = "World"
c = a + " " + b
print(c)

回傳為：

五.格式化字串

1.format單個傳參

我們不能像這樣組合字串和數字：

#會報錯
age = 20
txt =" 川川今年 " + age
print(txt)

但是我們可以通過使用format() 方法來組合字串和數字！format()方法接受傳遞的引數，格式化它們，并將它們放在占位符所在的字串中 {}，
例如，使用format()方法將數字插入字串:

age = 20
txt = "川川今年 {}"
print(txt.format(age))

回傳為：

2.format多個個傳參

format() 方法接受無限數量的引數，并放置在各自的占位符中：

quantity = 20
itemno = 3000
price = 49.95
myorder = "川川今年 {}歲 買了個華為手機 {} 每個月花費 {} 元."
print(myorder.format(quantity, itemno, price))

回傳為：

您可以使用索引號{0}來確保引數放置在正確的占位符中：

quantity = 20
itemno = 3000
price = 49.95
myorder = "川川今年 {2}歲 買了個華為手機 {0} 每個月花費 {1} 元."
print(myorder.format(quantity, itemno, price))

這樣就會導致數字傳的順序發生了變化，看看結果就明白了：

六. 字串的其它處理方法總結

1. capitalize() 將第一個字符轉換為大寫
2. casefold() 將字串轉換為小寫
3. center() 回傳一個居中的字串
4. count() 回傳指定值在字串中出現的次數
5. encode() 回傳字串的編碼版本
6. endswith() 如果字串以指定的值結尾，則回傳 true
7. join() 將可迭代的元素連接到字串的末尾
8. find() 在字串中搜索指定值并回傳找到它的位置
9. format() 初始化字串中的指定值
   10.index() 在字串中搜索指定值并回傳找到它的位置
   當然還有很多，個人感覺不是很常用，就不繼續總結別的了，

七.練習題

1-使用 len 方法列印字串的長度，

x = "Hello World"
print(  )

2-獲取字串 txt 的第一個字符，

txt = "Hello World"
x =

3.獲取從索引 2 到索引 4 (llo) 的字符，

txt = "Hello World"
x =

4.回傳開頭或結尾沒有任何空格的字串，

txt = " Hello World "
x = 

提示 使用strip()
5-將 txt 的值轉換為大寫，

txt = "Hello World"
txt =

6-將 txt 的值轉換為小寫，

txt = "Hello World"
txt = 

7-用 J 替換字符 H，

txt = "Hello World"
txt = txt.

8-插入正確的語法以添加年齡引數的占位符，

age = 36
txt = "My name is John, and I am   "
print(txt.format(age))

提示：{}

十七、Python布林值

布林值表示兩個值之一： True或False，在編程中，您經常需要知道運算式是否為 True或False，舉一些例子就明白了，

1.比較

當您比較兩個值時，將計算運算式并且 Python 回傳布林值答案：

print(10 > 9)
print(10 == 9)
print(10 < 9)

回傳為：

在 if 陳述句中運行條件時，Python 回傳 True or False：

a = 100
b = 30

if b > a:
  print("b大于a")
else:
  print("b不大于a")

回傳為：

2.評估值和變數

bool()函式允許您評估任何值，并給您 True或False 作為回傳，
例如：評估一個字串和一個數字

print(bool("川川"))
print(bool(20))

回傳為：

評估兩個變數：

x = "川川"
y = 15

print(bool(x))
print(bool(y))

回傳為：

3.布爾真值

True如果它具有某種內容，幾乎任何值都會被評估，任何字串都是True，空字串除外，任何數字都是True，除了 0，任何串列、元組、集合和字典都是True，空的除外，
例如以下都會回傳True:

bool("abc")
bool(123)
bool(["apple", "cherry", "banana"])

4.布爾假值

實際上，False除了空值（例如()、 []、{}、 “”、 數字 0和 值 ）之外，計算為 的值 None，當然，結果為 False，

bool(False)
bool(None)
bool(0)
bool("")
bool(())
bool([])
bool({})

回傳為：

5.函式可以回傳布林值

def myFunction() :
  return True

print(myFunction())

回傳為：

列印“YES！” 如果函式回傳 True，否則列印“NO！”：

def myFunction() :
  return True

if myFunction():
  print("YES!")
else:
  print("NO!")

Python 也有許多回傳布林值的內置函式，如 isinstance() 函式，可用于確定物件是否屬于某種資料型別
例如：檢查物件是否為整數

x = 200
print(isinstance(x, int))

回傳為

6.練習題

1.回答下面的陳述句回傳值True還是False:

print(10 > 9)

2.回答下面的陳述句回傳值True還是False:
print(10 == 9)

3.回答下面的陳述句回傳值True還是False:

print(10 < 9)

4.回答下面的陳述句回傳值True還是False:

print(bool("abc"))

5.回答下面的陳述句回傳值True還是False:

print(bool(0))

十八、python運算子

1.算術運算子

自己賦值粘貼運行下就懂了！
加減法：（+ -）

a=2
b=3
c=a-b
d=a-b
print(c,d)

乘除法：（* /）

a=(50-5*6)/4
print(a)

a=8/5
print(a)

取余數（同時與除法比較）

'''/回傳為float,//回傳整數，%回傳余數'''
a=17/3
print(a)


a=17//3
print(a)

a=5*3+2
print(a)

冪運算 （**’）

'''冪運算  **'''
# a=4**2
# b=2**3
# print(a,b)

2.賦值運算子

等于（=）

x = 5
print(x)

加等于（ +=）等效： x = x +

x = 5
x += 3
print(x)

減等于（-=） 等效：x=x-

x = 5
x -= 3
print(x)

類似的我們可以得到以下不同的方式等效：

	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

	x ^= 3	等效 x = x ^ 3

	x >>= 3	等效x = x >> 3

	x <<= 3	等效x = x << 3

十九、Python串列

一.串列基本知識

基本形式為：

mylist = ["川川一號", "川川二號", "川川三號"]

1.創建串列

串列是使用方括號創建的：

mylist = ["川川一號", "川川二號", "川川三號"]
print(mylist)

回傳：

創建新串列時也可以使用 list() 建構式，

thislist = list(("apple", "banana", "cherry"))
print(thislist)

允許重復
由于串列已編入索引，因此串列可以包含具有相同值的專案：

thislist = ["川川一號", "川川二號", "川川三號","川川一號"]
print(thislist)

2.列出表值

串列項是有序的、可變的，并允許重復值，串列項被索引，第一項有索引[0]，第二項有索引[1]等等，
單個索引
例如我要索取川川一號：

mylist = ["川川一號", "川川二號", "川川三號"]
print(mylist)
print(mylist[0])

回傳：

遍歷串列

for i in mylist:
    print(i)

回傳為：

3.串列長度

確定串列有多少項，請使用以下 len()函式：

thislist = ["川川一號", "川川二號", "川川三號","川川一號"]
print(len(thislist))

回傳：

4.串列項 - 資料型別

串列項可以是任何資料型別，例如：

list1 = ["apple", "banana", "cherry"]
list2 = [1, 5, 7, 9, 3]
list3 = [True, False, False]

print(list1)
print(list2)
print(list3)

5.Python 集合（陣列）

1. List串列是一個有序且可變的集合，允許重復成員，
2. turple元組是一個有序且不可更改的集合，允許重復成員，
3. Set集合是一個無序且無索引的集合，沒有重復的成員，
4. dict字典是一個有序*且可變的集合，沒有重復的成員，
   ！！！從 Python 3.7 版開始，字典才是有序的！！！

二.訪問串列

1.正常索引

串列項已編入索引，您可以通過參考索引號來訪問它們：

mylist = ["川川一號", "川川二號", "川川三號"]
print(mylist[0])

注意：第一項的索引為 0，

2.負索引

負索引意味著從頭開始，-1指最后一項， -2指倒數第二項等，

mylist = ["川川一號", "川川二號", "川川三號"]
print(mylist[-1])

3.索引范圍

mylist = ["川川一號", "川川二號", "川川三號"]
print(mylist[1:3])

4.負指數范圍

mylist = ["川川一號", "川川二號", "川川三號"]
print(mylist[-3:-1])

5.檢查是否存在

要確定串列中是否存在指定的專案，請使用in關鍵字，
例如，檢查串列中是否存在“apple”：

thislist = ["apple", "banana", "cherry"]
if "apple" in thislist:
  print("Yes, 'apple' is in the fruits list")

三.更改串列

1.單個更改

要更改特定位置的值，需要通過索引號：

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist[0]="川川五號"
print(mylist[0])

修改成功：

2.多個更改

索引號需要用范圍表示，

mylist = ["川川一號", "川川二號", "川川三號","川川四號","川川五號"]
mylist[1:3]=["哈皮川川","憨批川川"]
print(mylist)

修改成功：

3.插入串列

insert()方法在指定的索引處插入一個專案，

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.insert(2,'帥哥呀')
print(mylist)

插入成功：

四.添加串列

1.末尾添加

要將值添加到串列的末尾，請使用append() 方法：

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.append("憨批川川")
print(mylist)

添加成功：

2.指定位置添加

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.insert(2,'川川菜鳥')
print(mylist)

添加成功：

3.合并串列

要將另一個串列中的元素附加到當前串列，請使用extend()方法，

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist1 = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.extend(mylist1)
print(mylist)

合并成功：

extend()方法不一定要 串列，您也可以添加任何可迭代物件（元組、集合、字典等），

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist2=("川川","菜鳥")
mylist.extend(mylist2)
print(mylist)

添加成功：

五.洗掉串列

1.洗掉指定目標

remove()方法洗掉指定的專案，

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.remove('川川二號')
print(mylist)

洗掉成功：

2.洗掉指定索引

pop()方法洗掉指定的索引，

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.pop(2)
print(mylist)

洗掉成功：

如果不指定索引，該pop()方法將洗掉最后一項，

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.pop()
print(mylist)

洗掉成功：

3.del洗掉指定的索引

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
del mylist[0]
print(mylist)

洗掉成功：

該del關鍵字也可以完全洗掉串列，

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
del mylist

4.清除串列

clear()方法清空串列，該串列仍然存在，但沒有內容，

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.clear()
print(mylist)

清空：

堅持！！！

六.回圈串列

1.for回圈遍歷

方法一：
回圈遍歷串列您可以使用回圈遍歷串列項for ，

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
for i in mylist:
    print(i)

遍歷成功：

方法二：遍歷索引號

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
for i in range(len(mylist)):
    print(mylist[i])

回傳：

2.while回圈遍歷

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
i = 0
while i < len(mylist):
  print(mylist[i])
  i = i + 1

回傳：

七.串列推導式

例如：根據fruits串列，您需要一個新串列，其中僅包含名稱中帶有字母“a”的fruits，
如果沒有串列理解，您將不得不撰寫一個for帶有條件測驗的陳述句：

fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = []

for x in fruits:
  if "a" in x:
    newlist.append(x)

print(newlist)

回傳為：

使用串列推導式，你只需要一行代碼即可！

fruits = ["apple", "banana", "cherry", "kiwi", "mango"]

newlist = [x for x in fruits if "a" in x]

print(newlist)

回傳一樣：

換一個例子，只接受小于 5 的數字：

newlist = [x for x in range(10) if x < 5]
print(newlist)

回傳“orange”而不是“banana”：（這個不是很好理解，多想想）

fruits = ["apple", "banana", "cherry", "kiwi", "mango"]
newlist = [x if x != "banana" else "orange" for x in fruits]
print(newlist)

回傳為：

八.串列排序

1.區分大小寫的排序

默認情況下，該sort()方法區分大小寫，導致所有大寫字母都排在小寫字母之前：

thislist = ["banana", "Orange", "Kiwi", "cherry"]
thislist.sort()
print(thislist)

回傳：

2.不區分大小寫的排序

如果你想要一個不區分大小寫的排序函式，使用 str.lower 作為鍵函式：

thislist = ["banana", "Orange", "Kiwi", "cherry"]
thislist.sort(key = str.lower)
print(thislist)

回傳：

3.倒序

reverse()方法反轉元素的當前排序順序，

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.reverse()
print(mylist)

回傳為：

九.復制串列

copy()方法制作串列的副本：

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
my = mylist.copy()
print(my)

回傳：

list()方法制作串列的副本：

mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
my = list(mylist)
print(my)

回傳為：

十.加入串列

最簡單的方法之一是使用+ 運算子，

list1 = ["a", "b", "c"]
list2 = [1, 2, 3]
list3 = list1 + list2
print(list3)

回傳：

稍微有意思點，連接兩個串列的另一種方法是將 list2 中的所有項一個一個地附加到 list1 中：

list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

for x in list2:
  list1.append(x)

print(list1)

回傳：

extend() 方法，其目的是將元素從一個串列添加到另一個串列：

list1 = ["a", "b" , "c"]
list2 = [1, 2, 3]

list1.extend(list2)
print(list1)

回傳：

十一.串列所有操作總結

如果你英文好可以看看，當然，這些所有操作我都講過一遍了，

十二.練習

1-列印fruits串列中的第二項，

fruits = ["apple", "banana", "cherry"]
print( )

2-將fruits串列中的值從“apple”改為“kiwi”，

fruits = ["apple", "banana", "cherry"]
   =

3-使用 append 方法將“orange”添加到fruits串列中，

fruits = ["apple", "banana", "cherry"]

4-使用插入方法將“檸檬”添加為fruits串列中的第二項，

fruits = ["apple", "banana", "cherry"]
     ="lemon")

5-使用 remove 方法從fruits串列中洗掉“banana”，

fruits = ["apple", "banana", "cherry"]

6-使用負索引列印串列中的最后一項，

fruits = ["apple", "banana", "cherry"]
print（  ）

7-使用索引范圍列印串列中的第三、第四和第五項，

fruits = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]
print(fruits[])

8-使用正確的語法列印串列中的專案數

fruits = ["apple", "banana", "cherry"]
print( )

二十、Python元組

一.元組理解

1.1基本定義

元組用于在單個變數中存盤多個專案，Tuple 是 Python 中用于存盤資料集合的 4 種內置資料型別之一，其他 3 種是List、 Set和Dictionary，它們具有不同的性質和用法，元組是一個集合是有序的和不可改變的，元組是用圓括號寫的，
基本形式如下：

mytuple = ("川川一號", "川川二號", "川川三號")
print(mytuple)

元組項是有序的、不可更改的，并允許重復值，元組項被索引，第一項被索引[0]，第二項被索引[1]等，
允許重復舉個例子：

mytuple = ("川川一號", "川川二號", "川川三號",'川川一號')
print(mytuple)

索引舉個例子：

mytuple = ("川川一號", "川川二號", "川川三號")
# print(mytuple)
print(mytuple[0])

1.2元組長度

我們還是跟串列一樣，用到len函式，例子如下：

mytuple = ("川川一號", "川川二號", "川川三號",'川川一號')
# print(mytuple)
print(len(mytuple))

回傳長度：

一項元組，記住逗號，不然就不是元祖了！我將兩個形式讀寫出來，可以做一個對比：

mytuple = ("川川一號", )
print(type(mytuple))
mytuple = ("川川一號")
print(type(mytuple))

我們來看看回傳什么：第一個是元祖，第二個是字串，

1.3資料型別

元組項可以是任何資料型別：字串、整數和布爾資料型別.

tuple1 = ("川川一號", "川川二號", "川川三號",'川川一號')
tuple2 = (1, 8, 5, 9, 3)
tuple3 = (True, False, False)

元組可以包含不同的資料型別，
包含字串、整數和布林值的元組，形式如下：

tuple4 = ("川川一號", 34, True, 40, "帥哥")

使用tuple()來創建元組，形式如下：

tuple5 = tuple(("川川一號", "川川二號", "川川三號",'川川一號'))
print(tuple5)

二.訪問元組

2.1正常訪問

您可以通過參考方括號內的索引號來訪問元組項，比如列印第二項：

mytuple = ("川川一號", "川川二號", "川川三號")
# print(mytuple)
print(mytuple[1])

注意：第一項的索引為 0，

2.2負索引

負索引意味著從頭開始，-1指最后一項， -2指倒數第二項等，
例如列印元組的最后一項：

mytuple = ("川川一號", "川川二號", "川川三號")
print(mytuple[-1])

2.3范圍性索引

您可以通過指定范圍的開始和結束位置來指定索引范圍，指定范圍時，回傳值將是具有指定項的新元組，這里我們用到range函式，前面講過，
回傳第三、第四和第五項：

mytuple = ("川川一號", "川川二號", "川川三號",'帥哥川川','川川真棒')
print(mytuple[2:5])

注意：搜索將從索引 2（包括）開始并在索引 5（不包括）處結束，
請記住，第一項的索引為 0，

通過省略起始值，范圍將從第一項開始（自己列印看看）：

mytuple = ("川川一號", "川川二號", "川川三號",'帥哥川川','川川真棒')
print(mytuple[:4])

通過省略結束值，范圍將繼續到串列的末尾：

mytuple = ("川川一號", "川川二號", "川川三號",'帥哥川川','川川真棒')
print(mytuple[2:])

負數范圍

mytuple = ("川川一號", "川川二號", "川川三號",'帥哥川川','川川真棒')
print(mytuple[-4:-1])

檢查專案值是否存在
要確定元組中是否存在指定的專案，請使用in關鍵字：

thistuple = ("川川一號", "川川二號", "川川三號",'帥哥川川','川川真棒')
if "帥哥川川" in thistuple:
  print("哈哈, '帥哥川川' 在元祖串列")

回傳：

三.更新元組

元組是不可更改的，這意味著一旦創建了元組，您就無法更改、添加或洗掉專案，但是有一些解決方法：將元組轉換為串列，更改串列，然后將串列轉換回元組，

3.1替換

比如我要將下面第二個元素改為帥哥：

x = ("川川一號", "川川二號", "川川三號",'川川一號')
y = list(x)
y[1] = "帥哥"
x = tuple(y)
print(x)

回傳為：

3.2添加專案值

由于元組是不可變的，它們沒有內置 append()方法，但有其他方法可以向元組添加項，
方法1:轉換為串列：就像更改元組的解決方法一樣，您可以將其轉換為串列，添加您的專案，然后將其轉換回元組，
例如：將元組轉換為串列，添加“愛你”，然后將其轉換回元組：

thistuple = ("川川一號", "川川二號", "川川三號",'川川一號')
y = list(thistuple)
y.append("愛你")
thistuple = tuple(y)
print(thistuple)

回傳：

方法2：將元組添加到元組，您可以向元組添加元組，因此如果您想添加一個（或多個）專案，請使用該專案創建一個新元組，并將其添加到現有元組中，
例如：創建一個值為“orange”的新元組，并添加該元組

thistuple = ("川川一號", "川川二號", "川川三號",'川川一號')
y = ("愛你",)
thistuple += y
print(thistuple)

同樣回傳：

注意：創建只有一個item的元組時，記得在item后面加上逗號，否則不會被識別為元組，

3.3洗掉專案

注意：您不能洗掉元組中的專案，元組是不可更改的，因此您無法從中洗掉專案，但您可以使用與我們用于更改和添加元組專案相同的解決方法：

示例
將元組轉換為串列，洗掉“apple”，然后將其轉換回元組：

thistuple = ("川川菜鳥", "川川二號", "川川三號",'川川一號')
y = list(thistuple)
y.remove("川川菜鳥")
thistuple = tuple(y)
print(thistuple)

或者您可以完全洗掉元組：該del關鍵字可以完全洗掉的元組

this = ("川川菜鳥", "川川二號", "川川三號",'川川一號')
del this
print(this)

這就會回傳錯誤，因為這個元祖已經不在了，

四.解包元組

當我們創建一個元組時，我們通常會為其分配值，這稱為“打包”元組，
包裝元組：

fruits = ("apple", "banana", "cherry")
print(fruits)

但是，在 Python 中，我們也可以將值提取回變數中，這稱為“解包”，
解包元組：

fruits = ("apple", "banana", "cherry")
(green, yellow, red) = fruits
print(green)
print(yellow)
print(red)

使用星號*
如果變數的數量少于值的數量，您可以*在變數名中添加一個，值將作為串列分配給變數，
將其余值分配為名為“red”的串列：

fruits = ("apple", "banana", "cherry", "strawberry", "raspberry")
(green, yellow, *red) = fruits
print(green)
print(yellow)
print(red)

如果星號被添加到另一個變數名而不是最后一個，Python 將為變數賦值，直到剩余的值數量與剩余的變數數量匹配，
添加值串列“tropic”變數：

fruits = ("apple", "mango", "papaya", "pineapple", "cherry")

(green, *tropic, red) = fruits

print(green)
print(tropic)
print(red)

五.回圈元祖

5.1遍歷元祖

也就是遍歷元組的意思，只要我們提到遍歷，那就是for回圈，
方法一：直接遍歷
例子如下：遍歷專案并列印值

thistuple = ("川川菜鳥", "川川二號", "川川三號",'川川一號')
for i in thistuple:
    print(i)

方法二： 遍歷索引號
使用range()和len()函式創建合適的可迭代物件，

thistuple = ("川川菜鳥", "川川二號", "川川三號",'川川一號')
for i in range(len(thistuple)):
    print(thistuple[i])

回傳都i為：

5.2使用 While 回圈

thistuple = ("川川菜鳥", "川川二號", "川川三號",'川川一號')
i = 0
while i < len(thistuple):
  print(thistuple[i])
  i = i + 1

六.元組合并

合并兩個元祖，我們用+連接即可，

tuple1 = ("川川菜鳥", "川川二號", "川川三號",'川川一號')
tuple2 = (1, 2, 3)

tuple3 = tuple1 + tuple2
print(tuple3)

如果要將元組的內容乘以給定次數，可以使用* 運算子：

tuple1 = ("川川菜鳥", "川川二號", "川川三號",'川川一號')
tuple4=tuple1*2
print(tuple4)

回傳：

count函式用于回傳指定值次數：查找5出現次數

thistuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)
x = thistuple.count(5)
print(x)

回傳：

index()找出指定值并回傳它的位置：查找元祖中8位置

thistuple = (1, 3, 7, 8, 7, 5, 4, 6, 8, 5)
x = thistuple.index(8)
print(x)

七.練習

1-使用正確的語法列印fruits元組中的第一項

fruits = ("apple", "banana", "cherry")
print

2-使用正確的語法列印fruits元組中的專案數，

fruits = ("apple", "banana", "cherry")
print

3-使用負索引列印元組中的最后一項，

fruits = ("apple", "banana", "cherry")
print

4-使用一系列索引列印元組中的第三、第四和第五項，

fruits = ("apple", "banana", "cherry", "orange", "kiwi", "melon", "mango")
print(fruits[])

二十一、Python集合

一.集合理解

基本形式：

myset = {"川川一號", "川川二號", "川川三號"}

集合是用大括號寫的，
創建一個集合：

myset = {"川川一號", "川川二號", "川川三號"}
print(myset)

回傳：

注意：集合是無序的，因此您無法確定專案的顯示順序，

二.訪問集合

2.1遍歷集合

您不能通過參考索引或鍵來訪問集合中的專案，但是您可以使用回圈遍歷集合項for ，或者使用in關鍵字詢問集合中是否存在指定的值 ，
例如：

myset = {"川川一號", "川川二號", "川川三號"}
for i in myset:
    print(i)

回傳：

3.2檢查是否存在

檢查集合中是否存在“串串一號”：（顯然不在）

myset = {"川川一號", "川川二號", "川川三號"}
print('串串一號' in myset)

回傳布林值：

三.添加集合

3.1添加專案值

創建集合后，您無法更改其專案，但可以添加新專案，要將一項添加到集合中，請使用add() 方法，
例如：添加川川菜鳥到集合中

myset = {"川川一號", "川川二號", "川川三號"}
myset.add('川川菜鳥')
print(myset)

回傳：

3.2添加集合

要將另一個集合中的專案添加到當前集合中，請使用update() 方法，
例如將myset1添加到myset中：

myset = {"川川一號", "川川二號", "川川三號"}
myset1 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset.update(myset1)
print(myset)

回傳：

為什么?別忘了我們的集合不能重復，重復的集合會被覆寫，因此只添加了新的值進來，

3.3添加任何可迭代物件

update()方法中的物件不一定是集合，它可以是任何可迭代物件（元組、串列、字典等），
例如：將myset2串列加入集合myset1

myset1 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset2=['菜鳥','川川']
myset.update(myset2)
print(myset)

回傳為：

四.移除集合項

4.1remove方法

要洗掉集合中的專案，請使用remove()、 或discard()方法，
例如我要移除川川菜鳥：

myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset4.remove('川川菜鳥')
print(myset4)

回傳：

注意：如果要洗掉的專案不存在，remove()將引發錯誤，

4.2discard() 方法

使用以下discard() 方法洗掉“川川菜鳥” ：

myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset4.discard('川川菜鳥')
print(myset4)

回傳：

注意：如果要洗掉的專案不存在，discard()則 不會引發錯誤，

4.3pop() 方法

使用以下pop() 方法洗掉最后一項：

myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset4.pop()
print(myset4)

回傳：

注意：集合是無序的，因此在使用該pop()方法時，您不知道哪個專案被洗掉，

4.4clear() 方法

clear() 方法清空集合：

myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset.clear()
print(myset4)

列印為空，

4.5del關鍵字

該del關鍵字將完全洗掉該集合：

myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
del myset4

集合已經不存在了，因此我們不列印，

五.回圈集合

for回圈遍歷即可

myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
for i in myset4:
    print(i)

回傳：

六.集合連接

6.1普通連接

您可以使用union()回傳包含兩個集合中所有項的新集合的方法，或將一個集合中的所有項update()插入另一個集合的方法，
方法一：使用union()方法回傳一個包含兩個集合中所有專案的新集合

set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}

set3 = set1.union(set2)
print(set3)

方法二：update()方法將 set2 中的項插入到 set1 中

set1 = {"a", "b" , "c"}
set2 = {1, 2, 3}

set1.update(set2)
print(set1)

注意：無論union()和update() 將排除任何重復的專案，

6.2僅保留重復項

intersection_update()方法將只保留兩個集合中都存在的專案，
保留myset4和myset5重復項：

myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset5 = {"川川一號", "川川五號", "川川三號",'川川菜鳥'}
myset4.intersection_update(myset5)
print(myset4)

回傳：

或者用intersection()方法將回傳一個新集合，該集合僅包含兩個集合中都存在的專案，

myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset5 = {"川川一號", "川川五號", "川川三號",'川川菜鳥'}
z=myset4.intersection(myset5)
print(z)

回傳：

6.3保留所有，但不保留重復項

symmetric_difference_update()方法將只保留兩個集合中都不存在的元素，

myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset5 = {"川川一號", "川川五號", "川川三號",'川川菜鳥'}
z=myset4.symmetric_difference_update(myset5)
print(z)

回傳：

symmetric_difference()方法將回傳一個新集合，該集合僅包含兩個集合中都不存在的元素，

myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset5 = {"川川一號", "川川五號", "川川三號",'川川菜鳥'}
z=myset4.symmetric_difference(myset5)
print(z)

回傳：

七.練習

1-檢查fruits集中是否存在“appl”，

fruits = {"apple", "banana", "cherry"}
if "apple"   fruits:
  print("Yes, apple is a fruit!")

2-使用 add 方法將“orange”添加到fruits集中，

fruits = {"apple", "banana", "cherry"}

3-使用正確的方法將多個專案（more_fruits）添加到fruits 集中，

fruits = {"apple", "banana", "cherry"}
more_fruits = ["orange", "mango", "grapes"]
fruits.update(more_fruits)#答案

4-使用 remove 方法從fruits 集中洗掉“banana，

fruits = {"apple", "banana", "cherry"}

5-使用discard方法從fruits 集中洗掉“香蕉”，

fruits = {"apple", "banana", "cherry"}

二十二、Python字典

一.字典理解

基本形式：

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}

字典用于在鍵值對中存盤資料值，字典是有序*、可變且不允許重復的集合，（從 Python 3.7 版開始，字典是有序的，在 Python 3.6 及更早版本中，字典是無序的，）

1.1創建字典與訪問

字典是用大括號寫的，有鍵和值，
創建并列印字典：

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print(thisdict)

字典項是有序的、可變的，并且不允許重復，字典項以鍵值對的形式呈現，可以使用鍵名進行參考，
例如列印brand的值

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print(thisdict["brand"])

字典不能有兩個具有相同鍵的專案：重復值將覆寫現有值
回傳：

1.2字典長度

還是用用len函式

hisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964,
  "year": 2020
}
print(len(thisdict))

1.3資料型別

字典項中的值可以是任何資料型別：
例如：

thisdict = {
  "brand": "Ford",
  "electric": False,
  "year": 1964,
  "colors": ["red", "white", "blue"]
}

型別：dict()
列印字典的資料型別：

thisdict = {
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print(type(thisdict))

補充鞏固：

二.訪問字典

2.1訪問鍵名

您可以通過參考方括號內的鍵名來訪問字典的專案：

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
x = thisdict["name"]
print(x)

還有一個被呼叫的方法get()會給你同樣的結果：

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
x = thisdict["name"]
y=thisdict.get('name')
print(x)
print(y)

回傳：

2.2訪問健值

keys()方法將回傳字典中所有鍵的串列，

hisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
x = thisdict.keys()
print(x)

向原始字典添加一個新專案，并看到鍵串列也得到更新：

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
thisdict['age']=20
print(thisdict)

回傳：

獲取值
values()方法將回傳字典中所有值的串列，

x = thisdict.values()

items()方法將回傳字典中的每個專案，作為串列中的元組，

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
thisdict['age']=20
print(thisdict)
x = thisdict.items()
print(x)

回傳元祖：

要確定字典中是否存在指定的鍵，請使用in關鍵字：

hisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
if 'name' in thisdict:
    print('name在字典')

回傳：

三.更改字典各種方法

前面我們講到了一部分更改內容，這里我們具體講一下，
例如我要把川川改為川川菜鳥：

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
thisdict['name'] = '川川菜鳥'
print(thisdict)

回傳：

或者我們使用update()方法：

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
thisdict.update({'name':'川川菜鳥'})
print(thisdict)

效果一樣：

四.添加字典項各種方法

比如我要添加一個年齡為20：

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
thisdict['age']=20
print(thisdict)

回傳：

或者還是使用update:

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
thisdict['age']=20
print(thisdict)
thisdict.update({'age':'20歲'})
print(thisdict)

回傳：

五.洗掉字典的各種方法

pop()方法洗掉具有指定鍵名的項，
比如我要洗掉地址專案：

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
thisdict.pop("address")
print(thisdict)

回傳：

popitem()方法洗掉最后插入的專案（在 3.7 之前的版本中，將洗掉隨機專案）：

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
thisdict.pop("address")
print(thisdict)
thisdict.popitem()
print(thisdict)

回傳：

del關鍵字洗掉與指定鍵名稱的專案：

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
del thisdict['name']
print(thisdict)

回傳：

del關鍵字也可以洗掉字典完全：

del thisdict

clear()方法清空字典：

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
thisdict.clear()
print(thisdict)

回傳空：

六.遍歷字典

將字典中的所有鍵名，一一列印出來：

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
for x in thisdict:
  print(x)

一一列印字典中的所有值：

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
for x in thisdict:
  print(thisdict[x])

回傳：

您還可以使用該values()方法回傳字典的值：

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
for x in thisdict.values():
  print(x)

您可以使用該keys()方法回傳字典的鍵：

hisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
for x in thisdict.keys():
  print(x)

回傳：

使用以下 方法回圈遍歷keys和valuesitems()：

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
for x, y in thisdict.items():
  print(x, y)

回傳：

七.復制字典

用copy()函式

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
mydict=thisdict.copy()
print(mydict)

內置dict(）函式

thisdict = {
  "name": "川川",
  "address": "上海",
  "year": 2000
}
mydict=dict(thisdict)
print(mydict)

效果都一樣：

八.嵌套字典

創建一個包含三個字典的字典：

myfamily = {
  "child1" : {
    "name" : "Emil",
    "year" : 2004
  },
  "child2" : {
    "name" : "Tobias",
    "year" : 2007
  },
  "child3" : {
    "name" : "Linus",
    "year" : 2011
  }
}
print(myfamily)

回傳：

創建三個字典，然后創建一個包含其他三個字典的字典：

child1 = {
  "name" : "Emil",
  "year" : 2004
}
child2 = {
  "name" : "Tobias",
  "year" : 2007
}
child3 = {
  "name" : "Linus",
  "year" : 2011
}

myfamily = {
  "child1" : child1,
  "child2" : child2,
  "child3" : child3
}
print(myfamily)

效果一樣：

九.練習

1-使用get方法列印汽車字典的“model”鍵的值，

car =	{
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}
print

2-將“year”值從 1964 更改為 2020，

car =	{
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}

3-將鍵/值對 “color” : “red” 添加到汽車字典中，

car =	{
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}

4-使用 pop 方法從汽車字典中洗掉“model”，

car =	{
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}

5-使用clear方法清空car字典，

car =	{
  "brand": "Ford",
  "model": "Mustang",
  "year": 1964
}

二十三、If … Else陳述句

Python 支持數學中常見的邏輯條件：

• 等于：a == b
• 不等于：a != b
• 小于：a < b
• 小于或等于：a <= b
• 大于：a > b
• 大于或等于：a >= b

一.if陳述句

a = 33
b = 200
if b > a:
  print("b 大于 a")

回傳：

注意:if后面要有冒號
在這個例子中，我們使用兩個變數a和b，它們用作 if 陳述句的一部分來測驗b是否大于a，由于a是33，而b是200，我們知道 200 大于 33，所以我們列印到螢屏上“b 大于 a”，

二.縮進

Python 依靠縮進（行首的空格）來定義代碼中的范圍，為此，其他編程語言通常使用大括號，
If 陳述句，沒有縮進（會引發錯誤）：

a = 33
b = 200
if b > a:
print("b 大于 a")

三.elif陳述句

如果前面的條件是不正確的，那就試試這個條件，
例如：

a = 33
b = 33
if b > a:
  print("b 大于 a")
elif a == b:
  print("a 等于b")

回傳：

在這個例子中a等于b，所以第一個條件不成立，但elif條件成立，所以我們列印到螢屏“a 和 b 相等”

四.else陳述句

4.1基本else

在其他關鍵字捕獲任何未通過前面的條件抓獲，

a = 200
b = 33
if b > a:
  print("b 大于 a")
elif a == b:
  print("a 等于b")
else:
  print("a 小于 b")

回傳：

在這個例子中a大于b，所以第一個條件不成立，elif條件也不成立，所以我們轉到else條件并列印到螢屏“a 小于 b”，

你也可以有一個else沒有 elif：

a = 200
b = 33
if b > a:
  print("b 大于 a")
else:
  print("b 小于 a")

4.2and陳述句

測驗 if a是否大于 b，并且 if c 大于a：

a = 200
b = 33
c = 500
if a > b and c > a:
  print("兩種條件都滿足")

4.3or 陳述句

測驗 if a是否大于 b，或 if a 大于c：

a = 200
b = 33
c = 500
if a > b or a > c:
  print("At least one of the conditions is True")

4.4嵌套if陳述句

x = 41
if x > 10:
  print("Above ten,")
  if x > 20:
    print("and also above 20!")
  else:
    print("but not above 20.")

4.4pass陳述句

if陳述句不能為空，但如果您出于某種原因有一個if沒有內容，pass陳述句請放入該陳述句以避免出錯，

a = 33
b = 200

if b > a:
  pass

二十四、while回圈陳述句

一.基本理解

使用while回圈，只要條件為真，我們就可以執行一組陳述句，
例如：只要 i 小于 6 就列印 i

i = 1
while i < 6:
  print(i)
  i += 1

回傳為：

注意：記住要限制 i，否則回圈將永遠持續下去，

二.中斷宣告

使用break陳述句，即使 while 條件為真，我們也可以停止回圈：
例如當 i 為 3 時退出回圈：

i = 1
while i < 6:
  print(i)
  if i == 3:
    break
  i += 1

回傳：

三.continue 宣告

使用continue陳述句，我們可以停止當前的迭代，并繼續下一個：

i = 0
while i < 6:
  i += 1
  if i == 3:
    continue
  print(i)

回傳：可以并沒有列印3

四.else 陳述句

使用else陳述句，當條件不再為真時，我們可以運行一次代碼塊：
一旦條件為假，列印一條訊息：

i = 1
while i < 6:
  print(i)
  i += 1
else:
  print("i is no longer less than 6")

二十五、for回圈陳述句

一.基本遍歷

使用for回圈，我們可以執行一組陳述句，對串列、元組、集合等中的每個專案執行一次，
例如：列印水果串列中的每個水果

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)

二.遍歷字串

例如回圈遍歷單詞“banana”中的字母：

for x in "banana":
  print(x)

三.中斷宣告

使用break陳述句，我們可以在回圈遍歷所有專案之前停止回圈.
例如當x是“banana”時退出回圈：

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)
  if x == "banana":
    break

當x是“banana”時退出回圈，但這次中斷出現在列印之前：

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  if x == "banana":
    break
  print(x)

就會回傳只有applr:

四.continue 宣告

使用continue陳述句，我們可以停止回圈的當前迭代，并繼續下一個：
不要列印banana：

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  if x == "banana":
    continue
  print(x)

五.range() 函式

要回圈一組代碼指定的次數，我們可以使用range()函式，的范圍（）函式回傳由1個數字，通過默認從0開始，并遞增的順序（預設），并結束在指定次數，
例如：

for x in range(6):
  print(x)

回傳：

注意 range(6)不是 0 到 6 的值，而是 0 到 5 的值，
range函式默認被1至遞增序列，但是有可能通過增加第三引數指定增量值：range（2，30，3）

六.嵌套回圈

嵌套回圈是回圈內的回圈，“內回圈”將在“外回圈”的每次迭代中執行一次，
為每個fruits列印每個形容詞：

adj = ["red", "big", "tasty"]
fruits = ["apple", "banana", "cherry"]

for x in adj:
  for y in fruits:
    print(x, y)

回傳：

七.pass陳述句

for回圈不能為空，但如果由于某種原因有一個for沒有內容的回圈，請放入pass陳述句以避免出錯，

for x in [0, 1, 2]:
  pass

二十六、函式

一.創建函式與呼叫

在 Python 中，函式是使用def 關鍵字定義的：

def my_function():
  print("Hello from a function")

呼叫函式
要呼叫函式，請使用函式名稱后跟括號：

def my_function():
  print("川川菜鳥")
my_function()

回傳：

二.引數

資訊可以作為引數傳遞給函式，引數在函式名后的括號內指定，您可以根據需要添加任意數量的引數，只需用逗號分隔它們，

下面的示例有一個帶一個引數 (fname) 的函式，當函式被呼叫時，我們傳遞一個名字，在函式內部使用它來列印全名：

def my_function(fname):
  print(fname + " 菜鳥")

my_function("川川")
my_function("川川嗎")
my_function("憨批")

回傳：

三.引數數量

默認情況下，必須使用正確數量的引數呼叫函式，這意味著如果您的函式需要 2 個引數，則必須使用 2 個引數呼叫該函式，不能多也不能少，

例如此函式需要 2 個引數，并獲得 2 個引數：

def my_function(fname, lname):
  print(fname + " " + lname)

my_function("川川", "菜鳥")

回傳：

四.任意引數，*args

如果您不知道將傳遞給函式的引數有多少，請*在函式定義中的引數名稱前添加一個，這樣，該函式將接收一個引數元組，并可以相應地訪問這些專案，

如果引數數量未知，則*在引數名稱前添加一個：

def my_function(*kids):
  print("川川帥哥 " + kids[2])
my_function("名字", "性別", "菜鳥")

回傳：

五.關鍵字引數

您還可以使用key = value語法發送引數，這樣，引數的順序就無關緊要了，

def my_function(child3, child2, child1):
  print("最帥的是 " + child3)

my_function(child1 = "大白", child2 = "小白", child3 = "豬豬俠")

回傳：

短語關鍵字引數在 Python 檔案中通常縮寫為kwargs，

七.任意關鍵字引數，**kwargs

如果您不知道有多少關鍵字引數將被傳遞到您的函式中，請**在函式定義中的引數名稱之前添加兩個星號，這樣，該函式將接收一個引數字典，并可以相應地訪問這些專案.
例如：

def my_function(**kid):
  print("它的名字是 " + kid["lname"])

my_function(fname = "菜鳥", lname = "川川")

回傳：

八.默認引數值

如果我們不帶引數呼叫函式，它使用默認值：

def my_function(country = "Norway"):
  print("I am from " + country)
my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")

回傳：

九將串列作為引數傳遞

例如，如果你發送一個 List 作為引數，當它到達函式時它仍然是一個 List：

def my_function(food):
  for x in food:
    print(x)
fruits = ["apple", "banana", "cherry"]
my_function(fruits)

回傳：

十.回傳值

要讓函式回傳值，請使用以下return 陳述句：

def my_function(x):
  return 5 * x

print(my_function(3))
print(my_function(5))
print(my_function(9))

十一.pass陳述句

function定義不能為空，但如果您出于某種原因有一個function沒有內容的定義，請放入pass陳述句中以避免出錯，

def myfunction():
  pass

二十七、lambda

lambda 函式是一個小的匿名函式，一個 lambda 函式可以接受任意數量的引數，但只能有一個運算式，
語法：
lambda arguments : expression
執行運算式并回傳結果：

示例將 10 添加到 argument a，并回傳結果：

x = lambda a : a + 10
print(x(5))

回傳：

Lambda 函式可以接受任意數量的引數，
例將引數a與引數 相乘b并回傳結果：

x = lambda a, b : a * b
print(x(5, 6))

回傳：

把引數a、 b和c并回傳結果：

x = lambda a, b, c : a + b + c
print(x(5, 6, 2))

回傳：

假設您有一個接受一個引數的函式定義，并且該引數將乘以一個未知數：

def myfunc(n):
  return lambda a : a * n

使用該函式定義來創建一個函式，該函式始終將您發送的數字加倍：

def myfunc(n):
  return lambda a : a * n
mydoubler = myfunc(2)
print(mydoubler(11))

使用相同的函式定義來創建一個始終將您發送的數字增加三倍的函式：

def myfunc(n):
  return lambda a : a * n

mytripler = myfunc(3)

print(mytripler(11))

二十八、陣列

Python 沒有對陣列的內置支持，但可以使用Python 串列代替，
例如：

chuan = ["川川", "菜鳥", "帥哥"]

一.訪問陣列的元素

您可以通過參考索引號來參考陣列元素，例如：

chuan = ["川川", "菜鳥", "帥哥"]
te=chuan[0]
print(te)

修改陣列：

chuan = ["川川", "菜鳥", "帥哥"]
chuan[0]='高富帥'
print(chuan)

回傳：

二.陣列的長度

用len函式，
例如：

chuan = ["川川", "菜鳥", "帥哥"]
chuan[0]='高富帥'
# print(chuan)
print(len(chuan))

三.修改陣列

補充一點：回圈陣列元素，您可以使用for in回圈遍歷陣列的所有元素，
例如：

chuan = ["川川", "菜鳥", "帥哥"]
for i in chuan:
    print(i)

添加陣列元素
使用append函式（跟串列一樣）

chuan = ["川川", "菜鳥", "帥哥"]
chuan.append('上海')
print(chuan)

回傳：

洗掉陣列元素
您可以使用該pop()方法從陣列中洗掉一個元素，（注意起始位置是0）
例如洗掉第二個元素：

chuan = ["川川", "菜鳥", "帥哥"]
chuan.pop(1)
print(chuan)

回傳：

您還可以使用該remove()方法從陣列中洗掉一個元素，

chuan = ["川川", "菜鳥", "帥哥"]
chuan.pop(1)
print(chuan)
chuan.remove('帥哥')
print(chuan)

回傳：

注意：串列的remove()方法只洗掉指定值的第一次出現，

四.陣列的其它操作

二十九、Python類和物件

Python 類/物件，Python 是一種面向物件的編程語言，Python 中的幾乎所有東西都是一個物件，有它的屬性和方法，類就像一個物件建構式，或者是創建物件的“藍圖”，

一.創建類

要創建一個類，請使用關鍵字class，
例如：創建一個名為 MyClass 的類，其屬性名為 x

class MyClass:
  x = 5
print(MyClass)

二.創建物件

現在我們可以使用名為 MyClass 的類來創建物件，
例如創建一個名為 p1 的物件，并列印 x 的值：

class MyClass:
  x = 5
p1 = MyClass()
print(p1.x)

回傳：

三.init() 函式

上面的例子是最簡單形式的類和物件，在現實生活應用程式中并沒有真正有用，要理解類的含義，我們必須了解內置的 init() 函式，所有類都有一個名為 init() 的函式，它總是在類被初始化時執行，使用 init() 函式為物件屬性賦值，或在創建物件時需要執行的其他操作，

例如創建一個名為 Person 的類，使用 init() 函式為 name 和 age 賦值：

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

p1 = Person("川川菜鳥", 20)

print(p1.name)
print(p1.age)

回傳：

注意：init()每次使用該類創建新物件時都會自動呼叫該函式，

四.物件方法

讓我們在 Person 類中創建一個方法，
例如插入一個列印問候語的函式，并在 p1 物件上執行它：

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

  def myfunc(self):
    print("我的名字是 " + self.name)

p1 = Person("川川菜鳥", 20)
p1.myfunc()

回傳：

五.自引數

self引數是對類當前實體的參考，用于訪問屬于該類的變數，它不必命名self，您可以隨意呼叫它，但它必須是類中任何函式的第一個引數：

lass Person:
  def __init__(mysillyobject, name, age):
    mysillyobject.name = name
    mysillyobject.age = age

  def myfunc(abc):
    print("我的名字是 " + abc.name)

p1 = Person("川川菜鳥", 20)
p1.myfunc()

跟使用self效果一樣

六.物件及其屬性更改

替換
例如修改年齡為21

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

  def myfunc(abc):
    print("我的名字是 " + abc.name)

p1 = Person("川川菜鳥", 20)
p1.age = 21
print(p1.age)

回傳：

洗掉物件屬性
例如從 p1 物件中洗掉 age 屬性：

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

  def myfunc(self):
    print("Hello my name is " + self.name)
p1 = Person("John", 36)
del p1.age
print(p1.age)#沒有了自然列印報錯

洗掉物件
比如洗掉物件p1

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

  def myfunc(self):
    print("Hello my name is " + self.name)

p1 = Person("John", 36)

del p1

print(p1)#物件都不在了肯定報錯

七.pass陳述句

class定義不能為空，但如果您出于某種原因有一個class沒有內容的定義，請放入pass陳述句中以避免出錯，

class Person:
  pass

三十、Python繼承

繼承允許我們定義一個從另一個類繼承所有方法和屬性的類，父類是被繼承的類，也稱為基類，子類是從另一個類繼承的類，也稱為派生類，

一.創建父類

任何類都可以是父類，因此語法與創建任何其他類相同：
這里創建一個名為Person、 firstname和lastname屬性的類，以及一個printname方法：

class Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)


x = Person("川川", "菜鳥")
x.printname()

回傳：

二.創建子類

創建從另一個類繼承功能的類，請在創建子類時將父類作為引數發送，
例如：創建一個名為 的類Student，它將繼承該類的屬性和方法Person

class Student(Person):
  pass

注意： pass 當您不想向類添加任何其他屬性或方法時，請使用關鍵字，
現在 Student 類具有與 Person 類相同的屬性和方法，使用Student類創建物件，然后執行printname方法：

class Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)

class Student(Person):
  pass

x = Student("川川", "菜鳥")
x.printname()

回傳還是一樣

三.添加 init() 函式

到目前為止，我們已經創建了一個繼承父類的屬性和方法的子類，我們想將__init__()函式添加到子類（而不是pass關鍵字），
注意：init()每次使用該類創建新物件時都會自動呼叫該函式，
例如：將__init__()函式添加到 Student類中

class Student(Person):
  def __init__(self, fname, lname):

添加__init__()函式后，子類將不再繼承父類的__init__()函式，注：孩子的__init__() 功能覆寫父母的繼承 init()功能，為了保持父__init__() 函式的繼承，添加對父函式的呼叫__init__()：

class Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)

class Student(Person):
  def __init__(self, fname, lname):
    Person.__init__(self, fname, lname)

x = Student("川川", "菜鳥")
x.printname()

這樣效果一樣：

四.使用 super() 函式

Python 還有一個super()函式可以讓子類繼承其父類的所有方法和屬性：

class Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)

class Student(Person):
  def __init__(self, fname, lname):
    super().__init__(fname, lname)

x = Student("川川", "菜鳥")
x.printname()

一樣回傳：

通過使用該super()函式，您不必使用父元素的名稱，它會自動從其父元素繼承方法和屬性，

五.添加屬性

添加一個屬性呼叫graduationyear到 Student類：

class Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)

class Student(Person):
  def __init__(self, fname, lname):
    super().__init__(fname, lname)
    self.graduationyear = 2021

x = Student("川川", "菜鳥")
print(x.graduationyear)

回傳：

年份2019應該是一個變數，并Student在創建學生物件時傳遞給 類，為此，請在 init() 函式中添加另一個引數，
添加year引數，并在創建物件時傳遞正確的年份：

class Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)

class Student(Person):
  def __init__(self, fname, lname, year):
    super().__init__(fname, lname)
    self.graduationyear = year

x = Student("川川", "菜鳥", 2021)
print(x.graduationyear)

回傳一樣為2021

六.添加方法

添加一個呼叫welcome到 Student類的方法：

lass Person:
  def __init__(self, fname, lname):
    self.firstname = fname
    self.lastname = lname

  def printname(self):
    print(self.firstname, self.lastname)

class Student(Person):
  def __init__(self, fname, lname, year):
    super().__init__(fname, lname)
    self.graduationyear = year

  def welcome(self):
    print("Welcome", self.firstname, self.lastname, "to the class of", self.graduationyear)

x = Student("川川", "菜鳥", 2021)
x.welcome()

回傳

三十一、Python日期

Python 中的日期不是它自己的資料型別，但我們可以匯入一個名為的模塊datetime來處理日期作為日期物件，

一.日期輸入輸出

匯入 datetime 模塊并顯示當前日期：

import datetime

x = datetime.datetime.now()
print(x)

回傳：

日期輸出
當我們執行上面示例中的代碼時，結果將是：2021-08-25 05:36:01.704218
日期包含年、月、日、小時、分鐘、秒和微秒，

回作業日的年份和名稱：

import datetime

x = datetime.datetime.now()

print(x.year)
print(x.strftime("%A"))

回傳：

二.創建日期物件

要創建日期，我們可以使用模塊的datetime()類（建構式） datetime，本datetime()類需要三個引數來創建日期：年，月，日，

import datetime

x = datetime.datetime(2021, 8, 25)

print(x)

回傳

datetime()類也需要引數的時間和時區（小時，分鐘，秒，微秒，tzone），但它們是可選的，并且具有一個默認值0，（None對時區），

三.strftime() 方法

該datetime物件具有將日期物件格式化為可讀字串的方法，該方法被呼叫strftime()，并采用一個引數 format，來指定回傳字串的格式，
例如顯示月份名稱：

import datetime
x = datetime.datetime(2011, 8, 25)
print(x.strftime("%B"))

回傳

四.其它呼叫方法

實在太多，不能一一演示，大家自己看下，

三十二、Python JSON

JSON 是一種用于存盤和交換資料的語法，JSON 是文本，用 JavaScript 物件表示法撰寫，
Python 有一個名為 的內置包json，可用于處理 JSON 資料，
匯入 json 模塊：

import json

一.從 JSON 轉換為 Python

如果您有 JSON 字串，則可以使用json.loads()方法對其進行決議 ，
結果將是一個Python 字典，
例如：

import json
# some JSON:
x ='{ "name":"川川", "age":20, "city":"上海"}'

# 決議x
y = json.loads(x)
#會回傳字典
print(y["age"])

回傳：

如果您有 Python 物件，則可以使用json.dumps()方法將其轉換為 JSON 字串，

import json
# x為字典
x = {
  "name": "John",
  "age": 30,
  "city": "New York"
}
# 轉為json
y = json.dumps(x)
# 結果為json字串
print(y)
print(type(y))

回傳為

三十三、例外處理

try塊可讓您測驗代碼塊的錯誤，except塊可讓您處理錯誤，finally無論 try- 和 except 塊的結果如何，該塊都允許您執行代碼，

一.例外處理

例如該try塊將產生例外，因為x未定義：

try:
  print(x)
except:
  print("An exception occurred")

回傳

由于 try 塊引發錯誤，因此將執行 except 塊，如果沒有 try 塊，程式將崩潰并引發錯誤，

二.else搭配

else如果沒有出現錯誤，您可以使用關鍵字來定義要執行的代碼塊：

try:
  print("Hello")
except:
  print("Something went wrong")
else:
  print("Nothing went wrong")

回傳：

三.finally陳述句

finally如果指定了該塊，則無論 try 塊是否引發錯誤，都將執行該塊，
例如：

try:
  print(x)
except:
  print("Something went wrong")
finally:
  print("The 'try except' is finished")

回傳：

這對于關閉物件和清理資源很有用，
例如嘗試打開并寫入不可寫的檔案：

try:
  f = open("demofile.txt")
  f.write("Lorum Ipsum")
except:
  print("Something went wrong when writing to the file")
finally:
  f.close()

程式可以繼續，而無需打開檔案物件，

四.引發例外

要拋出（或引發）例外，請使用raise關鍵字，
例如如果 x 小于 0，則引發錯誤并停止程式：

x = -1

if x < 0:
  raise Exception("Sorry, no numbers below zero")

回傳：

該raise關鍵字用于引發例外，您可以定義要引發的錯誤型別以及要列印給用戶的文本，
例如如果 x 不是整數，則引發 TypeError：

x = "hello"

if not type(x) is int:
  raise TypeError("Only integers are allowed")

回傳

三十四、用戶輸入

實在太簡單了，就是使用一個input(),將輸入后的值傳遞給另一個變數，相當于動態賦值、
例如：

username = input("你叫什么名字:")
print("名字叫: " + username)

回傳：

三十五.格式化輸入輸出

講解在注釋里面，

'''在字串開頭的引號/三引號前添加 f 或 F ，在這種字串中，可以在 { 和 } 字符之間輸入參考的變數'''
# year = 2021
# event = 'Referendum'
# a=f'Results of the {year} {event}'
# print(a)
'''str.format() 該方法也用 { 和 } 標記替換變數的位置a  這種方法支持詳細的格式化指令'''
# yes_votes = 42_572_654
# no_votes = 43_132_495
# percentage = yes_votes / (yes_votes + no_votes)
# a='{:-5} YES votes  {:1.1%}'.format(yes_votes, percentage)#調整{}內部感受下
# print(a)


'''只想快速顯示變數進行除錯，可以用 repr() 或 str() 函式把值轉化為字串，'''
# s = 'Hello, world.'
# print(str(s))#str() 函式回傳供人閱讀的值
# print(repr(s))#repr() 則生成適于解釋器讀取的值
# print(str(1/7))
# hellos = repr('hello')
# print(hellos)

'''7.1.1. 格式化字串字面值'''
'''格式化字串字面值 （簡稱為 f-字串）在字串前加前綴 f 或 F，通過 {expression} 運算式，把 Python 運算式的值添加到字串內'''
'''下例將 pi 舍入到小數點后三位'''
# import math
# print(f'The value of pi is approximately {math.pi:.3f}.')
'''在 ':' 后傳遞整數，為該欄位設定最小字符寬度，常用于列對齊'''
# table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
# for name, phone in table.items():
#     print(f'{name:10} ==> {phone:10d}')


'''7.1.2. 字串 format() 方法'''
# print('We are the {} who say "{}!"'.format('knights', 'Ni'))
'''花括號及之內的字符（稱為格式欄位）被替換為傳遞給 str.format() 方法的物件，花括號中的數字表示傳遞給 str.format() 方法的物件所在的位置，'''
# print('{0} and {1}'.format('spam', 'eggs'))
# print('{1} and {0}'.format('spam', 'eggs'))
'''使用關鍵字引數名參考值，'''
# print('This {food} is {adjective}.'.format(food='spam', adjective='absolutely horrible'))
'''位置引數和關鍵字引數可以任意組合'''
# print('The story of {0}, {1}, and {other}.'.format('Bill', 'Manfred',
#                                                        other='Georg'))

'''用方括號 '[]' 訪問鍵來完成'''
# table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
# print('Jack: {0[Jack]:d}; Sjoerd: {0[Sjoerd]:d}; ''Dcab: {0[Dcab]:d}'.format(table))
'''也可以用 '**' 符號，把 table 當作傳遞的關鍵字引數，'''
# print('Jack: {Jack:d}; Sjoerd: {Sjoerd:d}; Dcab: {Dcab:d}'.format(**table))

'''生成一組整齊的列，包含給定整數及其平方與立方'''
# for x in range(1, 11):
#     print('{0:2d} {1:3d} {2:4d}'.format(x, x * x, x * x * x))


'''7.1.3. 手動格式化字串'''
# for x in range(1, 11):
#     print(repr(x).rjust(2), repr(x * x).rjust(3), end=' ')
#     print(repr(x * x * x).rjust(4))

'''7.1.4. 舊式字串格式化方法'''
# import math
# print('The value of pi is approximately %5.3f.' % math.pi)


'''7.2. 讀寫檔案?'''
'''最常用的引數有兩個: open(filename, mode)'''
# f = open('workfile', 'w')
'''
第一個實參是檔案名字串第二個實參是包含描述檔案使用方式字符的字串，
mode 的值包括 'r' ，表示檔案只能讀取；'w' 表示只能寫入（現有同名檔案會被覆寫）；
'a' 表示打開檔案并追加內容，任何寫入的資料會自動添加到檔案末尾，'r+' 表示打開檔案進行讀寫，
mode 實參是可選的，省略時的默認值為 'r'，
'''
# with open('workfile') as f:
#     read_data = f.read()
#     print(read_data)
# f.close()#如果沒有使用 with 關鍵字，則應呼叫 f.close() 關閉檔案，即可釋放檔案占用的系統資源，

# with open('workfile') as f:
#     a=f.read()
#     print(a)
# f.close()

'''f.readline() 從檔案中讀取單行資料'''
# with open('workfile') as f:
   # a=f.readline()
   # b=f.readline()
   # c=f.readline()
   # print(a,b,c)
   # for i in f:
   #     print(i)
# f.close()

'''從檔案中讀取多行時，可以用回圈遍歷整個檔案物件'''
# with open('workfile') as f:
#     for line in f:
#         print(line, end='')
# f.close()

'''f.write(string) 把 string 的內容寫入檔案，并回傳寫入的字符數，'''
# with open('workfile','w') as f:
#     f.write('This is a test\n')
# f.close()

'''寫入其他型別的物件前，要先把它們轉化為字串（文本模式）或位元組物件（二進制模式）'''
# with open('workfile','a') as f:
#     value = ('the answer', 42)
#     s = str(value)
#     f.write(s)
# f.close()

# f = open('workfile', 'rb+')
# f.write(b'0123456789abcdef')
# print(f.read())
# print(f.seek(5))
# print(f.read(1))

'''7.2.2. 使用 json 保存結構化資料'''
# import json
# a=json.dumps([1, 'simple', 'list'])
# print(a)
'''dumps() 函式還有一個變體， dump() ，它只將物件序列化為 text file '''
#如果 f 是 text file 物件
# json.dump(x, f)
#要再次解碼物件，如果 f 是已打開、供讀取的 text file 物件
# x = json.load(f)
? 2021 GitHub, Inc.

三十六、python正則運算式

Python 有一個名為 的內置包re，可用于處理正則運算式，匯入re模塊：

import re

一.Python中的正則運算式

匯入re模塊后，您可以開始使用正則運算式，
例如：搜索字串以查看它是否以“The”開頭并以“Spain”結尾：

import re

txt = "The rain in Spain"
x = re.search("^The.*Spain$", txt)

if x:
  print("匹配成功!")
else:
  print("匹配失敗")

運行：

當然，你現在看不懂這個例子，既然手把手教學，并不會教大家一步登天，

二.正則運算式函式

2.1 findall() 函式

該findall()函式回傳一個包含所有匹配項的串列，
例如：列印所有匹配項的串列

import re

txt = "川川菜鳥啊菜鳥啊"
x = re.findall("菜鳥", txt)
print(x)

運行回傳：

該串列按找到的順序包含匹配項，如果未找到匹配項，則回傳一個空串列：

import re

txt = "菜鳥并不菜"


x = re.findall("川川", txt)
print(x)

if (x):
  print("匹配成功了喲")
else:
  print("找不到這個呀！")

運行回傳：

2.2search() 函式

該search()函式在字串中搜索匹配項，如果有匹配項，則回傳一個Match 物件，如果有多個匹配項，則只回傳匹配項的第一次出現，
例如：搜索字串中的第一個空白字符：

import re

txt = "菜鳥 呢"
x = re.search("\s", txt)

print("第一個空格字符位于位置:", x.start()) 

運行結果：

如果未找到匹配項，None則回傳該值：

import re

txt = "天上飛的是菜鳥"
x = re.search("川川", txt)
print(x)

回傳：

2.3 split() 函式

該split()函式回傳一個串列，其中的字串在每次匹配時被拆分，
例如：在每個空白字符處拆分

import re

txt = "菜鳥 學 python"
x = re.split("\s", txt)
print(x)

運行回傳：

您可以通過指定maxsplit 引數來控制出現次數
例如：僅在第一次出現時拆分字串：

import re

#Split the string at the first white-space character:

txt = "飛起來 菜鳥 們"
x = re.split("\s", txt, 1)
print(x)

回傳：

2.4 sub() 函式

該sub()函式用您選擇的文本替換匹配項，
例如：用只替換就

import re

txt = "學python就找川川菜鳥"
x = re.sub("就", "只", txt)
print(x)

運行：

您可以通過指定count 引數來控制替換次數 ：
例如替換前 2 次出現：

import re

txt = "學python就就就川川菜鳥"
x = re.sub("就", "只", txt,2)
print(x)

回傳：

三.元字符

3.1 串列符號

[] 用于一組字符
例如：#按字母順序查找“a”和“m”之間的所有小寫字符

import re

txt = "apple chuanchuan "

#按字母順序查找“a”和“m”之間的所有小寫字符

x = re.findall("[a-m]", txt)
print(x)

運行：

3.2轉義符

** 表示特殊序列（也可用于轉義特殊字符）
例如匹配所有數字：

import re

txt = "我今年20歲了"

#查找所有數字字符

x = re.findall("\d", txt)
print(x)

運行回傳：

3.4 任意符號

. 可以任何字符（換行符除外），
例如：搜索以“he”開頭、后跟兩個（任意）字符和一個“o”的序列

import re

txt = "hello world"

#搜索以“he”開頭、后跟兩個（任意）字符和一個“o”的序列

x = re.findall("he..o", txt)
print(x)

運行回傳：

3.5開始符

^符號用于匹配開始，

import re

txt = "川川菜鳥 飛起來了"


x = re.findall("^川", txt)
if x:
  print("哇，我匹配到了")
else:
  print("哎呀，匹配不了啊")

運行：

3.6 結束符

$ 符號用于匹配結尾，例如：匹配字串是否以“world”結尾

import re

txt = "hello world"

#匹配字串是否以“world”結尾

x = re.findall("world$", txt)
if x:
  print("匹配成功了耶")
else:
  print("匹配不到哦")

運行：

3.7 星號符

• 星號符用于匹配零次或者多次出現，

import re

txt = "天上飛的是菜鳥，學python找川川菜鳥!"

#檢查字串是否包含“ai”后跟 0 個或多個“x”字符：

x = re.findall("菜鳥*", txt)

print(x)

if x:
  print("匹配到了!")
else:
  print("氣死了，匹配不到啊")

運行：

3.8 加號符

+ 用于匹配一次或者多次出現
例如：檢查字串是否包含“菜鳥”后跟 1 個或多個“菜鳥”字符：

import re

txt = "飛起來了，菜鳥們!"

#檢查字串是否包含“菜鳥”后跟 1 個或多個“菜鳥”字符：

x = re.findall("菜鳥+", txt)

print(x)

if x:
  print("匹配到了!")
else:
  print("煩死了，匹配不到")

運行：

3.9集合符號

{} 恰好指定的出現次數
例如：檢查字串是否包含“川”兩個

import re

txt = "川川菜鳥并不菜!"

#檢查字串是否包含“川”兩個

x = re.findall("川{2}", txt)

print(x)

if x:
  print("匹配到了兩次的川")
else:
  print("匹配不到啊，帥哥")

回傳：

3.10或符

| 匹配兩者任一
例如：匹配字串菜鳥或者是我了

import re

txt = "菜鳥們學會python了嗎？串串也是菜鳥啊!"



x = re.findall("菜鳥|是我了", txt)

print(x)

if x:
  print("匹配到了哦！")
else:
  print("匹配失敗")

運行：

四.特殊序列

4.1 指定字符

\A ： 如果指定的字符位于字串的開頭，則回傳匹配項，
例如：匹配以菜字符開頭的字符

import re

txt = "菜鳥在這里"


x = re.findall("\A菜", txt)

print(x)

if x:
  print("是的匹配到了")
else:
  print("匹配不到")

運行：

4.2 指定開頭結尾

\b 回傳指定字符位于單詞開頭或結尾的匹配項 （開頭的“r”確保字串被視為原始字串），
例如：匹配愛開頭

import re

txt = "愛你，川川"

x = re.findall(r"\b愛", txt)

print(x)

if x:
  print("匹配到了")
else:
  print("匹配不到")

運行：

又例如：匹配川結尾

import re

txt = "愛你，川川"

x = re.findall(r"川\b", txt)

print(x)

if x:
  print("匹配到了")
else:
  print("匹配不到")

運行：

4.3匹配中間字符

\B 回傳存在指定字符但不在單詞開頭（或結尾）的匹配項 （開頭的“r”確保字串被視為“原始字串”）
比如我匹配菜鳥：

import re

txt = "我是菜鳥我是菜鳥啊"

#檢查是否存在“ain”，但不是在單詞的開頭：

x = re.findall(r"\菜鳥", txt)

print(x)

if x:
  print("匹配到了嘛！!")
else:
  print("匹配不到哇！")

運行：

但是你匹配結尾就會回傳空，比如我匹配鳥：

import re

txt = "川川菜鳥"

#檢查是否存在“鳥”，但不是在單詞的末尾：

x = re.findall(r"鳥\B", txt)

print(x)

if x:
  print("匹配到了哦")
else:
  print("找不到")

運行：

4.4匹配數字

\d 回傳字串包含數字（0-9 之間的數字）的匹配項，
例如：

import re

txt = "我今年20歲了啊"

#檢查字串是否包含任何位數（0-9的數字）

x = re.findall("\d", txt)

print(x)

if x:
  print("哇哇哇，匹配到數字了")
else:
  print("找不到哦")

運行：

4.5 匹配非數字

\D 回傳字串不包含數字的匹配項
例如：

import re

txt = "我今年20歲"

#匹配任何非數字符號

x = re.findall("\D", txt)

print(x)

if x:
  print("匹配到了，開心!")
else:
  print("匹配不到，生氣")

運行：

4.6 空格匹配

\s 回傳一個匹配字串包含空白空間字符的匹配項，
例如：

import re

txt = "我 是 川 川 菜 鳥"

#匹配任何空格字符

x = re.findall("\s", txt)

print(x)

if x:
  print("匹配到了")
else:
  print("匹配不到啊")

運行：

4.7 匹配非空格

\S 回傳字串不包含空格字符的匹配項

import re

txt = "菜鳥是  我  了"

#匹配任意非空字符

x = re.findall("\S", txt)

print(x)

if x:
  print("匹配到了!")
else:
  print("匹配不到啊")

運行：

4.8 匹配任意數字和字母

回傳一個匹配，其中字串包含任何單詞字符（從 a 到 Z 的字符，從 0 到 9 的數字，以及下劃線 _ 字符）
例如：

import re

txt = "菜鳥啊 是串串呀"

#在每個單詞字符（從a到z的字符，0-9的數字）回傳匹配項，以及下劃線_字符）：
x = re.findall("\w", txt)

print(x)

if x:
  print("匹配到了啊")
else:
  print("匹配不到哇")

運行：

4.9匹配任意非數字和字母

回傳字串不包含任何單詞字符的匹配項，在每個非單詞字符中回傳匹配（不在A和Z之間的字符，“！”，“？”空白位等）
例如：

import re

txt = "菜鳥 是 我嘛？我不信！！"

#在每個非單詞字符中回傳匹配（不在A和Z之間的字符，“！”，“？”空白位等）：

x = re.findall("\W", txt)

print(x)

if x:
  print("匹配到了!")
else:
  print("匹配不到啊")

運行：

4.10 匹配結尾

\Z 如果指定的字符位于字串的末尾，則回傳匹配項，
例如：

import re

txt = "川川是菜鳥啊"


x = re.findall("啊\Z", txt)

print(x)

if x:
  print("匹配到了哦!")
else:
  print("匹配不到")

五.集合套裝

5.1 指定符范圍匹配

例如集合：[arn]

import re

txt = "The rain in Spain"


x = re.findall("[arn]", txt)

print(x)

if x:
  print("匹配到了!")
else:
  print("匹配不到")

5.2 匹配任意范圍內小寫字母

回傳任何小寫字符的匹配項，按字母順序在 a 和 n 之間，
例如:

import re

txt = "hello wo r l d"

x = re.findall("[a-n]", txt)

print(x)

if x:
  print("匹配到了!")
else:
  print("匹配不到")

運行：

5.3 其它

同樣的道理，依次其它情況如下：

[^arn] 回傳除 a、r 和 n 之外的任何字符的匹配項

[0123] 回傳存在任何指定數字（0、1、2 或 3）的匹配項

[0-9] 回傳 0 到 9 之間任意數字的匹配項

[0-5][0-9] 回傳 00 到 59 中任意兩位數的匹配項

[a-zA-Z] 按字母順序回傳 a 和 z 之間的任何字符的匹配，小寫或大寫

[+] 在集合中，+, *, ., |, (), $,{} 沒有特殊含義，所以 [+] 的意思是：回傳字串中任意 + 字符的匹配項，這個我i舉個例子：

import re

txt = "5+6=11"

#檢查字串是否有任何 + 字符：

x = re.findall("[+]", txt)

print(x)

if x:
  print("匹配到了")
else:
  print("匹配不到")

運行：

六.匹配物件

匹配物件是包含有關搜索和結果的資訊的物件，注意：如果沒有匹配，None將回傳值，而不是匹配物件，
直接舉個例子：
執行將回傳匹配物件的搜索

import re

#search() 函式回傳一個 Match 物件：

txt = "hello world"
x = re.search("wo", txt)
print(x)

運行：

Match 物件具有用于檢索有關搜索和結果的資訊的屬性和方法：

span()回傳一個包含匹配開始和結束位置的元組，
string回傳傳遞給函式的字串
group()回傳字串中匹配的部分

6.1 span函式

例如：列印第一個匹配項的位置（開始和結束位置），正則運算式查找任何以大寫“S”開頭的單詞：

import re

#搜索單詞開頭的大寫“S”字符，并列印其位置

txt = "The rain in Spain"
x = re.search(r"\bS\w+", txt)
print(x.span())

運行：

6.2 string函式

例如：列印傳遞給函式的字串

import re

#回傳字串

txt = "The rain in Spain"
x = re.search(r"\bS\w+", txt)
print(x.string)

6.3 group函式

例如：列印字串中匹配的部分，正則運算式查找任何以大寫“S”開頭的單詞

import re

#搜索單詞開頭的大寫“w”字符，并列印該單詞：

txt = "hello world"
x = re.search(r"\bw\w+", txt)
print(x.group())

運行：

注意：如果沒有匹配，None將回傳值，而不是匹配物件，

三十七、參考資料

《python從入門到實戰》，需要電子版書記可以主頁加我，

菜鳥教程，確實很全：
https://www.runoob.com/python3/python3-tutorial.html

python官方文檔案：

https://docs.python.org/3/

感謝這些資料，我才能寫出這么全，

三十八、總結

本篇文章在前面寫過的文章之上有過修改，并加入了正則運算式詳細講解，為什么我要出這么完整的文章而不是一篇一篇出呢？考慮到小白會看系列文章容易看糊涂，因此我在這里總結為一篇，保證任何人都可以從零到基礎扎實，至此，python基礎教程全部這一篇全部講完了，希望大家支持三聯一下，

創作實在不容易，希望能幫助到你學習，給我三聯一下吧，我是川川菜鳥，有任何疑問都可以主頁左側加我的小窩，