pycharm下載地址:
http://www.jetbrains.com/pycharm/download/#section=windows
下載詳細步驟:
1-
2-
3-
4-
5-
6
7-
8-直接finish
9-python官網:
https://www.python.org/
進去網址後點選:
10
11-下載好後
12-新增環境變數
記得雙擊安裝:
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/
一共有三種映象源設定,建議你每一種都跟我一起學會。
第一步:
第二步:
第三步:
第四步:
複製上面的清華映象源貼上,然後okokokok
測試,遇到了這個問題:
pip : 無法將「pip」項識別為 cmdlet、函數、指令碼檔案或可執行程式的名稱。請檢查名稱的拼寫,如果包括路徑,請確保路徑正確,然後再試一次。
因為我忘記給pip加環境變數了,所以加一下,一次如下:
第五步:
退出pycharm,因為加了環境變數需要重新啟動軟體。我們先到cmd輸入pip,如下就是設定成功了:
第六步:
重新啟動軟體後,隨便裝一個模組,如下:(你可以看到下載模組速度很快!)
使用方法:
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
這個設定我是建議你一定要新增設定。
方法一:
到cmd執行如下命令建立pip.ini:
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
返回:
然後我們把這個路徑新增到系統環境變數就好了(怎麼新增環境變數?跟前面給pip新增環境變數一樣操作,只是路徑不一樣)
方法二:
如果剛剛這個命令你執行失敗,你可以自己在C槽任意找個位置建立一個檔名叫做pip資料夾,在這下面下建立一個檔名pip.ini,內容為:
[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
然後新增到環境變數。
首先個人不建議漢化,最後我再演示漢化外掛。我是想要推薦一些不錯的外掛。
首先進入如下介面:
推薦使用:TabNine,當然kite也不錯,你可以都安裝,我是都在用。我演示一款:
彈出這個頁面刪了不要管:
測試:已經開始有提示了
(底部掃碼也可以)到我公眾號:川川菜鳥 傳送:kite 即可領取kite軟體,無腦安裝設定就餓可以了。實在不會左側加我再給你說。
直接跳轉我這一篇文章,如果你效果跟我一樣,那就是成功了:
Kite神器
首先,個人不建議漢化,不管你英語好不好,都要去適應這個英語介面,當然你實在需要漢化,這是教學:
現在就已經全部漢化:
如果需要下載別的外掛,你可以百度搜一下pycharm有哪些好的外掛,都是安裝上述方式安裝。
你是否想要如下桌面?
教學傳送門:
美女桌面背景設定
你是都在先每次建立一個檔案,開頭都是如下?
節約版面,跳轉此文:
自定義指令碼開頭
擁有本篇文章,意味著你擁有一本最完善的書籍,講得比書上全,語法也會比買的書上更詳細,大家要慢慢看。擁有本篇文章,你將基礎無敵,從此可以有能力自學一些高階教學。作者寫了好幾天,實在很累,希望你三連支援。
python,言簡意賅就是:通俗易懂,功能強大無比,上手快,實用強。你跟著我在這裡認真學完這一篇,你一定會學會最紮實的python基礎,同時我還可以提供免費輔導,作者本是一名學生,並不圖有任何好處。如果需要輔導,可以加從左側欄加群,當然僅是交流,不會有時間一直教你,只能幫助你解決一些問題,更多要靠自己。
軟體安裝我就不介紹了,大家b站搜一下python和pycharm安裝安裝即可,個人是推薦python和pycharm結合使用,pycharm是什麼?是python的編譯器,如果我們沒有編譯器,寫程式碼是很困難的,而且pycharm提供了許多外掛和優美的介面,使得你寫程式碼又快又舒服,不會因為在python的IDE上寫得頭疼。
當然!下載軟體不用到官網下,你只需要到軟體管家下載即可,我也是這個公眾號的忠實粉絲了。
入門第一步:列印
print("Hello, World!")
當然,你想列印別的也可以,對吧?
print('川川帥哥,我愛你')
最基本的語法,我不可能在這裡把所有的語法都講一遍,但是最基本語法要說一下。在這裡,我們又不得不鳴謝pycharm編譯器,實在幫助我們太多了。為什麼這麼說?pycharm中,它會自動幫助我們完成換行,縮排等問題,不會像IDE中寫程式碼,要自己手動,如果忘記手動就回報錯,因此我是不建議只用python直譯器,一定要用pycharm!
舉一些例子,當然,如果你是小白,現在只會列印,大可不必著急,你只需要看看,後面我會講到。
比如縮排問題,縮排是指程式碼行開頭的空格。if後面的語句需要tap一下(當然,如果你用pycharm編譯器,會自動tap)。
例如:
if 6 > 2:
print("六大於二")
註釋可用於解釋 Python 程式碼。註釋可用於使程式碼更具可讀性。註釋可用於在測試程式碼時阻止執行。
將需要註釋的部分開頭用#
例如:
#川川真帥
print('川川帥哥,我愛你')
或者這樣:
print("Hello, World!") #川川真帥
你可以看到如下,這就是註釋意義了,懂了吧。
第一種方法(不建議,太麻煩)
#川川真帥
#川川真帥
#川川真帥
print("Hello, World!")
你也可以左鍵選中我們需要註釋的程式碼,鬆開,按:Ctrl+/,就完成相同效果註釋。
第二種方法:
把要註釋的內容放到三個引號對裡面。,例如:
'''
川川真帥
川川真帥
'''
print('川川帥哥,我愛你')
取消註釋
左鍵選中我們需要取消註釋的程式碼,鬆開,按:Ctrl+/
在 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)
返回為:
變數可以有一個簡短的名稱(如 x 和 y)或一個更具描述性的名稱(age、carname、total_volume)。Python 變數的規則:
例如:
myvar = "川川"
my_var = "川川""
_my_var = "川川""
myVar = "川川""
MYVAR = "川川""
myvar2 = "川川""
命名法則:
駱駝法則:除了第一個單詞外,每個單詞都以大寫字母開頭
myNameIs = "川川"
帕斯卡法則:每個單詞都以大寫字母開頭
MyNameIs = "川川"
蛇形法則:每個單詞由下劃線字元分隔
My_Name_Is = "川川"
多個變數的多個值。
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)
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)
成功返回:
在函數外部建立的變數稱為全域性變數。都可以使用全域性變數,無論是在函數內部還是外部。當然,在這裡,你可能還不知道函數是什麼,後面我會講到,大可不必慌張。
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)
返回為:
預設情況下,Python 具有以下內建資料型別,在這些類別中:
文字型別: str
數位型別: int, float, complex
序列型別: list, tuple, range
對映型別: dict
套裝型別: set, frozenset
布林型別: bool
二進位制型別: bytes, bytearray, memoryview
此時你大可不必知道這些型別到底是什麼,在後續的深入中,你一定會用得到,所以是需要記住的。
您可使用以下type()函數獲取任何物件的資料型別。
例如,列印變數 x 的資料型別:
x = 6
print(type(x))
我們可以看到返回為:int型別
在 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))
我會舉一些例子說明,儘量很全,大可不必擔心。先舉一個完整例子,後面的是一樣的列印就不演示了。
強調特定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))
回答下面的問題結果為什麼型別?
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 共有三種數位型別:
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))
Int 或 integer,是一個整數,正負,不帶小數,長度不限。
例如:
x = 1
y = 3562254887
z = -35522
print(type(x))
print(type(y))
print(type(z))
浮點數或「浮點數」是包含一位或多位小數的正數或負數。
例如:
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))
複數寫有「j」作為虛部。
x = 3+5j
y = 5j
z = -5j
print(type(x))
print(type(y))
print(type(z))
比如你可以從一種型別轉變成另一種同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))
Python 有一個內建模組 random可以用來生成亂數。
範例:匯入 random 模組,並顯示 1 到 10之間的一個亂數:
import random
print(random.randrange(1, 11))
1-插入正確的語法將 x 轉換為浮點數。
x = 5
x = _(x)
2-插入正確的語法以將 x 轉換為整數。
x = 5.5
x = _(x)
3-插入正確的語法以將 x 轉換為複數。
x = 5
x = _(x)
python 中的轉換是使用建構函式完成的:
我將每一個型別都舉例子說明。
整數
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 中的字串被單引號或雙引號包圍。'hello’與"hello"相同。您可以使用以下print()函數顯示字串文字:
print("Hello")
print('Hello')
a = "川川"
print(a)
您可以使用三個引號將多行字串分配給變數:
a = """從前有座山,
山裡有座廟
廟裡有個小和尚"""
print(a)
返回如下:
或三個單引號:
a = '''從前有座山,
山裡有座廟
廟裡有個小和尚'''
print(a)
Python 沒有字元資料型別,單個字元只是一個長度為 1 的字串。方括號可用於存取字串的元素。這裡用到了切片,你可以不懂。
獲取位置 1 處的字元(記住第一個字元的位置為 0):
a = "Hello, World!"
print(a[1])
迴圈遍歷單詞「chuanchuan」中的字母:
for x in "chuanchuan":
print(x)
len()函數返回字串的長度,注意標點符號和空格也算一個長度:
a = "Hello, World!"
print(len(a))
要檢查字串中是否存在某個短語或字元,我們可以使用關鍵字 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'存在.")
檢查以下文字中是否不存在「川川」:
txt = "川川就讀上海交大!"
print("川川" not in txt)
因為存在,返回false:
僅在不存在「川川」時才列印:
txt = "川川就讀上海交大!"
if "川川" not in txt:
print("No, '川川' 不在檔案.")
因為不符合條件,所以不會列印。
您可以使用切片語法返回一系列字元。指定開始索引和結束索引,以冒號分隔,以返回字串的一部分。
範例:獲取從位置 2 到位置 5 的字元(不包括在內):
b = "Hello, World!"
print(b[2:5])
返回為:
注意:第一個字元的索引為 0。
範例:獲取從開始到位置 5 的字元(不包括在內):
b = "Hello, World!"
print(b[:5])
返回為:
通過省略結束索引,範圍將到最後。
例如,獲取從位置 2 到最後的字元:
b = "Hello, World!"
print(b[2:])
返回:
使用負索引從字串末尾開始切片,就是從右往左看,不再是從左往右看。
例如:
b = "Hello, World!"
print(b[-5:-2])
返回為:
upper()方法以大寫形式返回字串:
a = "Hello, World!"
print(a.upper())
返回為:
lower()方法以小寫形式返回字串:
a = "Hello, World!"
print(a.lower())
返回為:
空白是實際文字之前和/或之後的空間,通常您想刪除這個空間。
strip()方法從開頭或結尾刪除任何空格:
a = " Hello, World! "
print(a.strip())
返回為:
replace()方法用另一個字串替換一個字串.
a = "Hello, World!"
print(a.replace("H", "J"))
返回為:
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)
返回為:
我們不能像這樣組合字串和數位:
#會報錯
age = 20
txt =" 川川今年 " + age
print(txt)
但是我們可以通過使用format() 方法來組合字串和數位!format()方法接受傳遞的引數,格式化它們,並將它們放在預留位置所在的字串中 {}。
例如,使用format()方法將數位插入字串:
age = 20
txt = "川川今年 {}"
print(txt.format(age))
返回為:
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-使用 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))
提示:{}
布林值表示兩個值之一: True或False。在程式設計中,您經常需要知道表示式是否為 True或False。舉一些例子就明白了。
當您比較兩個值時,將計算表示式並且 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")
返回為:
bool()函數允許您評估任何值,並給您 True或False 作為返回。
例如:評估一個字串和一個數位
print(bool("川川"))
print(bool(20))
返回為:
評估兩個變數:
x = "川川"
y = 15
print(bool(x))
print(bool(y))
返回為:
True如果它具有某種內容,幾乎任何值都會被評估。任何字串都是True,空字串除外。任何數位都是True,除了 0。任何列表、元組、集合和字典都是True,空的除外。
例如以下都會返回True:
bool("abc")
bool(123)
bool(["apple", "cherry", "banana"])
實際上,False除了空值(例如()、 []、{}、 「」、 數位 0和 值 )之外,計算為 的值 None。當然,結果為 False。
bool(False)
bool(None)
bool(0)
bool("")
bool(())
bool([])
bool({})
返回為:
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))
返回為
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))
自己賦值貼上執行下就懂了!
加減法:(+ -)
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)
等於(=)
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
基本形式為:
mylist = ["川川一號", "川川二號", "川川三號"]
列表是使用方括號建立的:
mylist = ["川川一號", "川川二號", "川川三號"]
print(mylist)
返回:
建立新列表時也可以使用 list() 建構函式。
thislist = list(("apple", "banana", "cherry"))
print(thislist)
允許重複
由於列表已編入索引,因此列表可以包含具有相同值的專案:
thislist = ["川川一號", "川川二號", "川川三號","川川一號"]
print(thislist)
列表項是有序的、可變的,並允許重複值。列表項被索引,第一項有索引[0],第二項有索引[1]等等。
單個索引
例如我要索取川川一號:
mylist = ["川川一號", "川川二號", "川川三號"]
print(mylist)
print(mylist[0])
返回:
遍歷列表
for i in mylist:
print(i)
返回為:
確定列表有多少項,請使用以下 len()函數:
thislist = ["川川一號", "川川二號", "川川三號","川川一號"]
print(len(thislist))
返回:
列表項可以是任何資料型別。例如:
list1 = ["apple", "banana", "cherry"]
list2 = [1, 5, 7, 9, 3]
list3 = [True, False, False]
print(list1)
print(list2)
print(list3)
列表項已編入索引,您可以通過參照索引號來存取它們:
mylist = ["川川一號", "川川二號", "川川三號"]
print(mylist[0])
注意:第一項的索引為 0。
負索引意味著從頭開始,-1指最後一項, -2指倒數第二項等。
mylist = ["川川一號", "川川二號", "川川三號"]
print(mylist[-1])
mylist = ["川川一號", "川川二號", "川川三號"]
print(mylist[1:3])
mylist = ["川川一號", "川川二號", "川川三號"]
print(mylist[-3:-1])
要確定列表中是否存在指定的專案,請使用in關鍵字。
例如,檢查列表中是否存在「apple」:
thislist = ["apple", "banana", "cherry"]
if "apple" in thislist:
print("Yes, 'apple' is in the fruits list")
要更改特定位置的值,需要通過索引號:
mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist[0]="川川五號"
print(mylist[0])
修改成功:
索引號需要用範圍表示。
mylist = ["川川一號", "川川二號", "川川三號","川川四號","川川五號"]
mylist[1:3]=["哈皮川川","憨批川川"]
print(mylist)
修改成功:
insert()方法在指定的索引處插入一個專案。
mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.insert(2,'帥哥呀')
print(mylist)
插入成功:
要將值新增到列表的末尾,請使用append() 方法:
mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.append("憨批川川")
print(mylist)
新增成功:
mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.insert(2,'川川菜鳥')
print(mylist)
新增成功:
要將另一個列表中的元素附加到當前列表,請使用extend()方法。
mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist1 = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.extend(mylist1)
print(mylist)
合併成功:
extend()方法不一定要 列表,您也可以新增任何可迭代物件(元組、集合、字典等)。
mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist2=("川川","菜鳥")
mylist.extend(mylist2)
print(mylist)
新增成功:
remove()方法刪除指定的專案。
mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.remove('川川二號')
print(mylist)
刪除成功:
pop()方法刪除指定的索引。
mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.pop(2)
print(mylist)
刪除成功:
如果不指定索引,該pop()方法將刪除最後一項。
mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.pop()
print(mylist)
刪除成功:
mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
del mylist[0]
print(mylist)
刪除成功:
該del關鍵字也可以完全刪除列表。
mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
del mylist
clear()方法清空列表。該列表仍然存在,但沒有內容。
mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
mylist.clear()
print(mylist)
清空:
堅持!!!
方法一:
迴圈遍歷列表您可以使用迴圈遍歷列表項for 。
mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
for i in mylist:
print(i)
遍歷成功:
方法二:遍歷索引號
mylist = ["川川一號", "川川二號", "川川三號","川川四號"]
for i in range(len(mylist)):
print(mylist[i])
返回:
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)
返回為:
預設情況下,該sort()方法區分大小寫,導致所有大寫字母都排在小寫字母之前:
thislist = ["banana", "Orange", "Kiwi", "cherry"]
thislist.sort()
print(thislist)
返回:
如果你想要一個不區分大小寫的排序函數,使用 str.lower 作為鍵函數:
thislist = ["banana", "Orange", "Kiwi", "cherry"]
thislist.sort(key = str.lower)
print(thislist)
返回:
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( )
元組用於在單個變數中儲存多個專案。Tuple 是 Python 中用於儲存資料集合的 4 種內建資料型別之一,其他 3 種是List、 Set和Dictionary,它們具有不同的性質和用法。元組是一個集合是有序的和不可改變的。元組是用圓括號寫的。
基本形式如下:
mytuple = ("川川一號", "川川二號", "川川三號")
print(mytuple)
元組項是有序的、不可更改的,並允許重複值。元組項被索引,第一項被索引[0],第二項被索引[1]等。
允許重複舉個例子:
mytuple = ("川川一號", "川川二號", "川川三號",'川川一號')
print(mytuple)
索引舉個例子:
mytuple = ("川川一號", "川川二號", "川川三號")
# print(mytuple)
print(mytuple[0])
我們還是跟列表一樣,用到len函數,例子如下:
mytuple = ("川川一號", "川川二號", "川川三號",'川川一號')
# print(mytuple)
print(len(mytuple))
返回長度:
一項元組,記住逗號,不然就不是元祖了!我將兩個形式讀寫出來,可以做一個對比:
mytuple = ("川川一號", )
print(type(mytuple))
mytuple = ("川川一號")
print(type(mytuple))
我們來看看返回什麼:第一個是元祖,第二個是字串。
元組項可以是任何資料型別:字串、整數和布林資料型別.
tuple1 = ("川川一號", "川川二號", "川川三號",'川川一號')
tuple2 = (1, 8, 5, 9, 3)
tuple3 = (True, False, False)
元組可以包含不同的資料型別。
包含字串、整數和布林值的元組,形式如下:
tuple4 = ("川川一號", 34, True, 40, "帥哥")
使用tuple()來建立元組,形式如下:
tuple5 = tuple(("川川一號", "川川二號", "川川三號",'川川一號'))
print(tuple5)
您可以通過參照方括號內的索引號來存取元組項,比如列印第二項:
mytuple = ("川川一號", "川川二號", "川川三號")
# print(mytuple)
print(mytuple[1])
注意:第一項的索引為 0。
負索引意味著從頭開始。-1指最後一項, -2指倒數第二項等。
例如列印元組的最後一項:
mytuple = ("川川一號", "川川二號", "川川三號")
print(mytuple[-1])
您可以通過指定範圍的開始和結束位置來指定索引範圍。指定範圍時,返回值將是具有指定項的新元組。這裡我們用到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("哈哈, '帥哥川川' 在元祖列表")
返回:
元組是不可更改的,這意味著一旦建立了元組,您就無法更改、新增或刪除專案。但是有一些解決方法:將元組轉換為列表,更改列表,然後將列表轉換回元組。
比如我要將下面第二個元素改為帥哥:
x = ("川川一號", "川川二號", "川川三號",'川川一號')
y = list(x)
y[1] = "帥哥"
x = tuple(y)
print(x)
返回為:
由於元組是不可變的,它們沒有內建 append()方法,但有其他方法可以向元組新增項。
方法1:轉換為列表:就像更改元組的解決方法一樣,您可以將其轉換為列表,新增您的專案,然後將其轉換回元組。
例如:將元組轉換為列表,新增「愛你」,然後將其轉換回元組:
thistuple = ("川川一號", "川川二號", "川川三號",'川川一號')
y = list(thistuple)
y.append("愛你")
thistuple = tuple(y)
print(thistuple)
返回:
方法2:將元組新增到元組。您可以向元組新增元組,因此如果您想新增一個(或多個)專案,請使用該專案建立一個新元組,並將其新增到現有元組中。
例如:建立一個值為「orange」的新元組,並新增該元組
thistuple = ("川川一號", "川川二號", "川川三號",'川川一號')
y = ("愛你",)
thistuple += y
print(thistuple)
同樣返回:
注意:建立只有一個item的元組時,記得在item後面加上逗號,否則不會被識別為元組。
注意:您不能刪除元組中的專案。元組是不可更改的,因此您無法從中刪除專案,但您可以使用與我們用於更改和新增元組專案相同的解決方法:
範例
將元組轉換為列表,刪除「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)
也就是遍歷元組的意思,只要我們提到遍歷,那就是for迴圈。
方法一:直接遍歷
例子如下:遍歷專案並列印值
thistuple = ("川川菜鳥", "川川二號", "川川三號",'川川一號')
for i in thistuple:
print(i)
方法二: 遍歷索引號
使用range()和len()函數建立合適的可迭代物件。
thistuple = ("川川菜鳥", "川川二號", "川川三號",'川川一號')
for i in range(len(thistuple)):
print(thistuple[i])
返回都i為:
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[])
基本形式:
myset = {"川川一號", "川川二號", "川川三號"}
集合是用大括號寫的。
建立一個集合:
myset = {"川川一號", "川川二號", "川川三號"}
print(myset)
返回:
注意:集合是無序的,因此您無法確定專案的顯示順序。
您不能通過參照索引或鍵來存取集合中的專案。但是您可以使用迴圈遍歷集合項for ,或者使用in關鍵字詢問集合中是否存在指定的值 。
例如:
myset = {"川川一號", "川川二號", "川川三號"}
for i in myset:
print(i)
返回:
檢查集合中是否存在「串串一號」:(顯然不在)
myset = {"川川一號", "川川二號", "川川三號"}
print('串串一號' in myset)
返回布林值:
建立集合後,您無法更改其專案,但可以新增新專案。要將一項新增到集合中,請使用add() 方法。
例如:新增川川菜鳥到集合中
myset = {"川川一號", "川川二號", "川川三號"}
myset.add('川川菜鳥')
print(myset)
返回:
要將另一個集合中的專案新增到當前集合中,請使用update() 方法。
例如將myset1新增到myset中:
myset = {"川川一號", "川川二號", "川川三號"}
myset1 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset.update(myset1)
print(myset)
返回:
為什麼?別忘了我們的集合不能重複,重複的集合會被覆蓋,因此只新增了新的值進來。
update()方法中的物件不一定是集合,它可以是任何可迭代物件(元組、列表、字典等)。
例如:將myset2列表加入集合myset1
myset1 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset2=['菜鳥','川川']
myset.update(myset2)
print(myset)
返回為:
要刪除集合中的專案,請使用remove()、 或discard()方法。
例如我要移除川川菜鳥:
myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset4.remove('川川菜鳥')
print(myset4)
返回:
注意:如果要刪除的專案不存在,remove()將引發錯誤。
使用以下discard() 方法刪除「川川菜鳥」 :
myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset4.discard('川川菜鳥')
print(myset4)
返回:
注意:如果要刪除的專案不存在,discard()則 不會引發錯誤。
使用以下pop() 方法刪除最後一項:
myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset4.pop()
print(myset4)
返回:
注意:集合是無序的,因此在使用該pop()方法時,您不知道哪個專案被刪除。
clear() 方法清空集合:
myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset.clear()
print(myset4)
列印為空。
該del關鍵字將完全刪除該集合:
myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
del myset4
集合已經不存在了,因此我們不列印。
for迴圈遍歷即可
myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
for i in myset4:
print(i)
返回:
您可以使用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() 將排除任何重複的專案。
intersection_update()方法將只保留兩個集合中都存在的專案。
保留myset4和myset5重複項:
myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset5 = {"川川一號", "川川五號", "川川三號",'川川菜鳥'}
myset4.intersection_update(myset5)
print(myset4)
返回:
或者用intersection()方法將返回一個新集合,該集合僅包含兩個集合中都存在的專案。
myset4 = {"川川一號", "川川二號", "川川三號",'川川菜鳥'}
myset5 = {"川川一號", "川川五號", "川川三號",'川川菜鳥'}
z=myset4.intersection(myset5)
print(z)
返回:
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"}
基本形式:
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
字典用於在鍵值對中儲存資料值。字典是有序*、可變且不允許重複的集合。(從 Python 3.7 版開始,字典是有序的。在 Python 3.6 及更早版本中,字典是無序的。)
字典是用大括號寫的,有鍵和值。
建立並列印字典:
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(thisdict)
字典項是有序的、可變的,並且不允許重複。字典項以鍵值對的形式呈現,可以使用鍵名進行參照。
例如列印brand的值
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(thisdict["brand"])
字典不能有兩個具有相同鍵的專案:重複值將覆蓋現有值
返回:
還是用用len函數
hisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964,
"year": 2020
}
print(len(thisdict))
字典項中的值可以是任何資料型別:
例如:
thisdict = {
"brand": "Ford",
"electric": False,
"year": 1964,
"colors": ["red", "white", "blue"]
}
型別:dict()
列印字典的資料型別:
thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(type(thisdict))
補充鞏固:
您可以通過參照方括號內的鍵名來存取字典的專案:
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)
返回:
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
}
Python 支援數學中常見的邏輯條件:
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")
如果前面的條件是不正確的,那就試試這個條件。
例如:
a = 33
b = 33
if b > a:
print("b 大於 a")
elif a == b:
print("a 等於b")
返回:
在這個例子中a等於b,所以第一個條件不成立,但elif條件成立,所以我們列印到螢幕「a 和 b 相等」
在其他關鍵字捕獲任何未通過前面的條件抓獲。
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")
測試 if a是否大於 b,並且 if c 大於a:
a = 200
b = 33
c = 500
if a > b and c > a:
print("兩種條件都滿足")
測試 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")
x = 41
if x > 10:
print("Above ten,")
if x > 20:
print("and also above 20!")
else:
print("but not above 20.")
if語句不能為空,但如果您出於某種原因有一個if沒有內容,pass語句請放入該語句以避免出錯。
a = 33
b = 200
if b > a:
pass
使用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語句,我們可以停止當前的迭代,並繼續下一個:
i = 0
while i < 6:
i += 1
if i == 3:
continue
print(i)
返回:可以並沒有列印3
使用else語句,當條件不再為真時,我們可以執行一次程式碼塊:
一旦條件為假,列印一條訊息:
i = 1
while i < 6:
print(i)
i += 1
else:
print("i is no longer less than 6")
使用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語句,我們可以停止迴圈的當前迭代,並繼續下一個:
不要列印banana:
fruits = ["apple", "banana", "cherry"]
for x in fruits:
if x == "banana":
continue
print(x)
要回圈一組程式碼指定的次數,我們可以使用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)
返回:
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("川川", "菜鳥")
返回:
如果您不知道將傳遞給函數的引數有多少,請*在函數定義中的引數名稱前新增一個。這樣,該函數將接收一個引數元組,並可以相應地存取這些專案。
如果引數數量未知,則*在引數名稱前新增一個:
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。
如果您不知道有多少關鍵字引數將被傳遞到您的函數中,請**在函數定義中的引數名稱之前新增兩個星號。這樣,該函數將接收一個引數字典,並可以相應地存取這些專案.
例如:
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))
function定義不能為空,但如果您出於某種原因有一個function沒有內容的定義,請放入pass語句中以避免出錯。
def myfunction():
pass
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 中的幾乎所有東西都是一個物件,有它的屬性和方法。類就像一個物件建構函式,或者是建立物件的「藍圖」。
要建立一個類,請使用關鍵字class。
例如:建立一個名為 MyClass 的類,其屬性名為 x
class MyClass:
x = 5
print(MyClass)
現在我們可以使用名為 MyClass 的類來建立物件。
例如建立一個名為 p1 的物件,並列印 x 的值:
class MyClass:
x = 5
p1 = MyClass()
print(p1.x)
返回:
上面的例子是最簡單形式的類和物件,在現實生活應用程式中並沒有真正有用。要理解類的含義,我們必須瞭解內建的 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,您可以隨意呼叫它,但它必須是類中任何函數的第一個引數:
class 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 屬性:
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.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)#物件都不在了肯定報錯
class定義不能為空,但如果您出於某種原因有一個class沒有內容的定義,請放入pass語句中以避免出錯。
class Person:
pass
繼承允許我們定義一個從另一個類繼承所有方法和屬性的類。父類別是被繼承的類,也稱為基礎類別。子類是從另一個類繼承的類,也稱為派生類。
任何類都可以是父類別,因此語法與建立任何其他類相同:
這裡建立一個名為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__()函數新增到子類(而不是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()
這樣效果一樣:
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類的方法:
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
def welcome(self):
print("Welcome", self.firstname, self.lastname, "to the class of", self.graduationyear)
x = Student("川川", "菜鳥", 2021)
x.welcome()
返回
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對時區)。
該datetime物件具有將日期物件格式化為可讀字串的方法。該方法被呼叫strftime(),並採用一個引數 format,來指定返回字串的格式。
例如顯示月份名稱:
import datetime
x = datetime.datetime(2011, 8, 25)
print(x.strftime("%B"))
返回
實在太多,不能一一演示,大家自己看下。
JSON 是一種用於儲存和交換資料的語法。JSON 是文字,用 JavaScript 物件表示法編寫。
Python 有一個名為 的內建包json,可用於處理 JSON 資料。
匯入 json 模組:
import json
如果您有 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如果沒有出現錯誤,您可以使用關鍵字來定義要執行的程式碼塊:
try:
print("Hello")
except:
print("Something went wrong")
else:
print("Nothing went wrong")
返回:
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 有一個名為 的內建包re,可用於處理正規表示式。匯入re模組:
import re
匯入re模組後,您可以開始使用正規表示式。
例如:搜尋字串以檢視它是否以「The」開頭並以「Spain」結尾:
import re
txt = "The rain in Spain"
x = re.search("^The.*Spain$", txt)
if x:
print("匹配成功!")
else:
print("匹配失敗")
執行:
當然,你現在看不懂這個例子,既然手把手教學,並不會教大家一步登天。
該findall()函數返回一個包含所有匹配項的列表。
例如:列印所有匹配項的列表
import re
txt = "川川菜鳥啊菜鳥啊"
x = re.findall("菜鳥", txt)
print(x)
執行返回:
該列表按找到的順序包含匹配項。如果未找到匹配項,則返回一個空列表:
import re
txt = "菜鳥並不菜"
x = re.findall("川川", txt)
print(x)
if (x):
print("匹配成功了喲")
else:
print("找不到這個呀!")
執行返回:
該search()函數在字串中搜尋匹配項,如果有匹配項,則返回一個Match 物件。如果有多個匹配項,則只返回匹配項的第一次出現。
例如:搜尋字串中的第一個空白字元:
import re
txt = "菜鳥 呢"
x = re.search("\s", txt)
print("第一個空格字元位於位置:", x.start())
執行結果:
如果未找到匹配項,None則返回該值:
import re
txt = "天上飛的是菜鳥"
x = re.search("川川", txt)
print(x)
返回:
該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)
返回:
該sub()函數用您選擇的文字替換匹配項。
例如:用只替換就
import re
txt = "學python就找川川菜鳥"
x = re.sub("就", "只", txt)
print(x)
執行:
您可以通過指定count 引數來控制替換次數 :
例如替換前 2 次出現:
import re
txt = "學python就就就川川菜鳥"
x = re.sub("就", "只", txt,2)
print(x)
返回:
[] 用於一組字元
例如:#按字母順序查詢「a」和「m」之間的所有小寫字元
import re
txt = "apple chuanchuan "
#按字母順序查詢「a」和「m」之間的所有小寫字元
x = re.findall("[a-m]", txt)
print(x)
執行:
** 表示特殊序列(也可用於跳脫特殊字元)
例如匹配所有數位:
import re
txt = "我今年20歲了"
#查詢所有數位字元
x = re.findall("\d", txt)
print(x)
執行返回:
. 可以任何字元(換行符除外)。
例如:搜尋以「he」開頭、後跟兩個(任意)字元和一個「o」的序列
import re
txt = "hello world"
#搜尋以「he」開頭、後跟兩個(任意)字元和一個「o」的序列
x = re.findall("he..o", txt)
print(x)
執行返回:
^符號用於匹配開始。
import re
txt = "川川菜鳥 飛起來了"
x = re.findall("^川", txt)
if x:
print("哇,我匹配到了")
else:
print("哎呀,匹配不了啊")
執行:
$ 符號用於匹配結尾,例如:匹配字串是否以「world」結尾
import re
txt = "hello world"
#匹配字串是否以「world」結尾
x = re.findall("world$", txt)
if x:
print("匹配成功了耶")
else:
print("匹配不到哦")
執行:
import re
txt = "天上飛的是菜鳥,學python找川川菜鳥!"
#檢查字串是否包含「ai」後跟 0 個或多個「x」字元:
x = re.findall("菜鳥*", txt)
print(x)
if x:
print("匹配到了!")
else:
print("氣死了,匹配不到啊")
執行:
+ 用於匹配一次或者多次出現
例如:檢查字串是否包含「菜鳥」後跟 1 個或多個「菜鳥」字元:
import re
txt = "飛起來了,菜鳥們!"
#檢查字串是否包含「菜鳥」後跟 1 個或多個「菜鳥」字元:
x = re.findall("菜鳥+", txt)
print(x)
if x:
print("匹配到了!")
else:
print("煩死了,匹配不到")
執行:
{} 恰好指定的出現次數
例如:檢查字串是否包含「川」兩個
import re
txt = "川川菜鳥並不菜!"
#檢查字串是否包含「川」兩個
x = re.findall("川{2}", txt)
print(x)
if x:
print("匹配到了兩次的川")
else:
print("匹配不到啊,帥哥")
返回:
| 匹配兩者任一
例如:匹配字串菜鳥或者是我了
import re
txt = "菜鳥們學會python了嗎?串串也是菜鳥啊!"
x = re.findall("菜鳥|是我了", txt)
print(x)
if x:
print("匹配到了哦!")
else:
print("匹配失敗")
執行:
\A : 如果指定的字元位於字串的開頭,則返回匹配項。
例如:匹配以菜字元開頭的字元
import re
txt = "菜鳥在這裡"
x = re.findall("\A菜", txt)
print(x)
if x:
print("是的匹配到了")
else:
print("匹配不到")
執行:
\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("匹配不到")
執行:
\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("找不到")
執行:
\d 返回字串包含數位(0-9 之間的數位)的匹配項。
例如:
import re
txt = "我今年20歲了啊"
#檢查字串是否包含任何位數(0-9的數位)
x = re.findall("\d", txt)
print(x)
if x:
print("哇哇哇,匹配到數位了")
else:
print("找不到哦")
執行:
\D 返回字串不包含數位的匹配項
例如:
import re
txt = "我今年20歲"
#匹配任何非數位符號
x = re.findall("\D", txt)
print(x)
if x:
print("匹配到了,開心!")
else:
print("匹配不到,生氣")
執行:
\s 返回一個匹配字串包含空白空間字元的匹配項。
例如:
import re
txt = "我 是 川 川 菜 鳥"
#匹配任何空格字元
x = re.findall("\s", txt)
print(x)
if x:
print("匹配到了")
else:
print("匹配不到啊")
執行:
\S 返回字串不包含空格字元的匹配項
import re
txt = "菜鳥是 我 了"
#匹配任意非空字元
x = re.findall("\S", txt)
print(x)
if x:
print("匹配到了!")
else:
print("匹配不到啊")
執行:
返回一個匹配,其中字串包含任何單詞字元(從 a 到 Z 的字元,從 0 到 9 的數位,以及下劃線 _ 字元)
例如:
import re
txt = "菜鳥啊 是串串呀"
#在每個單詞字元(從a到z的字元,0-9的數位)返回匹配項,以及下劃線_字元):
x = re.findall("\w", txt)
print(x)
if x:
print("匹配到了啊")
else:
print("匹配不到哇")
執行:
返回字串不包含任何單詞字元的匹配項,在每個非單詞字元中返回匹配(不在A和Z之間的字元。「!」,「?」空白位等)
例如:
import re
txt = "菜鳥 是 我嘛?我不信!!"
#在每個非單詞字元中返回匹配(不在A和Z之間的字元。「!」,「?」空白位等):
x = re.findall("\W", txt)
print(x)
if x:
print("匹配到了!")
else:
print("匹配不到啊")
執行:
\Z 如果指定的字元位於字串的末尾,則返回匹配項。
例如:
import re
txt = "川川是菜鳥啊"
x = re.findall("啊\Z", txt)
print(x)
if x:
print("匹配到了哦!")
else:
print("匹配不到")
例如集合:[arn]
import re
txt = "The rain in Spain"
x = re.findall("[arn]", txt)
print(x)
if x:
print("匹配到了!")
else:
print("匹配不到")
返回任何小寫字元的匹配項,按字母順序在 a 和 n 之間。
例如:
import re
txt = "hello wo r l d"
x = re.findall("[a-n]", txt)
print(x)
if x:
print("匹配到了!")
else:
print("匹配不到")
執行:
同樣的道理,依次其它情況如下:
[^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()返回字串中匹配的部分
例如:列印第一個匹配項的位置(開始和結束位置)。正規表示式查詢任何以大寫「S」開頭的單詞:
import re
#搜尋單詞開頭的大寫「S」字元,並列印其位置
txt = "The rain in Spain"
x = re.search(r"\bS\w+", txt)
print(x.span())
執行:
例如:列印傳遞給函數的字串
import re
#返回字串
txt = "The rain in Spain"
x = re.search(r"\bS\w+", txt)
print(x.string)
例如:列印字串中匹配的部分。正規表示式查詢任何以大寫「S」開頭的單詞
import re
#搜尋單詞開頭的大寫「w」字元,並列印該單詞:
txt = "hello world"
x = re.search(r"\bw\w+", txt)
print(x.group())
執行:
注意:如果沒有匹配,None將返回值,而不是匹配物件。
節約版面,跳轉本文:資料庫連線
節約版面,跳轉本文:資料庫建立表
節約版面,跳轉本文:資料庫插入表
節約版面,跳轉本文:資料庫插入表
節約版面,跳轉本文:資料庫位置定位
節約版面,跳轉本文:資料庫排序
節約版面,跳轉本文:資料庫操作刪除
節約版面,跳轉本文:資料庫更新表
節約版面,跳轉本文:資料庫的限制輸出
節約版面,跳轉本文:資料庫表的合併
節約版面,跳轉本文:資料庫刪除表
前面的部分操作中都用到了SQL語句,在掌握基本python基礎情況下,你必須數SQL,節約版面,跳轉本文:三萬字SQL詳細教學
目前專欄還不夠完善,但也有一些內容,後續我會更新。節約版面,跳轉專欄:
爬蟲教學案例
節約版面,跳轉本文:QQ機器人制作教學
更多原始碼與教學請看機器人專欄,節約版面,跳轉本專欄:
QQ機器人專欄
參與我發起的活動,並加入鐵桿粉絲群,都有機會領取紙質版的python書籍一本,我付費,包郵放心。本片活動送這本書,為什麼送這本書?這本書專注於Python資料分析與視覺化操作中實際用到的技術。相比大而全的書籍資料,本書能讓讀者儘快上手,開始專案開發。
參與方式:
本篇文章在前面寫過的文章之上有過修改,加入了資料庫與機器人實戰教學,為什麼我要出這麼完整的文章而不是一篇一篇出呢?考慮到小白會看系列文章容易看糊塗,因此我在這裡總結為一篇,保證任何人都可以從零到基礎紮實。至此,python基礎教學全部這一篇全部講完了,希望大家支援三聯一下。
私人粉絲群,非誠勿擾:970353786
python學習問題加入大家庭一起交流學習,一起加油!創作實在不容易,希望能幫助到你學習,給我三連一下吧。