Python是一門解釋型編程語言，不需要和c一樣在運行前進行編譯
動態語言，定義變數無需宣告型別
Python可用于許多領域，Web應用程式開發，自動化、數學建模、爬蟲、大資料等


我們在掌握一門編程語言以后，就可以很容易將這門編程語言的知識應用到其它編程語言，諸多編程語言不同之處在于語法格式，而Python則是以語言簡單明了入門簡單受到歡迎，所以初學者來學習Python這門編程語言不會有那么吃力的感覺，

一、變數

---

學習所有編程語言，變數則是最開始所接觸的，也是最為常用的，首先來理解什么是變數：

變數指定是：記錄下可以變化的事物狀態
變：事物的狀態是可變化的
量：事物當前的狀態
變數是一種存取機制
變數使用原則：

1. 先定義
2. 再參考

變數是由三部分組成：

1. 變數名（用來訪問變數值）
2. 賦值符號（把值的記憶體地址系結給變數名）
3. 變數值 （記錄事物的狀態，即存的資料）

創建變數相當于申請了一塊記憶體空間，把這個值存進去然后通過賦值符號和變數名進行系結

變數的定義

test = 20

此時test這個變數名已經可以代表20個值了，變數的書寫最好以賦值符號左右隔開

參考變數

---

print 是python內置方法，用于將括號里面的內容列印到螢屏上，

test = 20
print(test)
20

注意：如果先使用后定義會出現找不到test這個變數的報錯資訊

print(test)
test = 20

語法錯誤，可以看到第二個print少了一個括號，造成語法錯誤，python如果檢測到語法錯誤，那么全部代碼都不會運行起來，格外注意

print(123)
print(456
print(789)

邏輯錯誤：指的是某一段代碼出現錯誤，但并不會影響之前代碼的運行，
這里從abc那一行開始中斷運行，上面兩個不會受影響，這里出現的錯誤是abc未定義

print(123)
print(456)
abc
print(789)

變數名的命名

---

大前提：見名知意
age=18
level=18
在見名知意的前提下應該遵循以下規范：
變數名是由字母數字下劃線組成
不能以數字開頭
不能使用python語言的關鍵字（不需要一次性記住 通過后面學習慢慢記憶）

[‘and’, ‘as’, ‘assert’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘exec’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘not’, ‘or’, ‘pass’, ‘print’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, 'yield]

命名的風格

1、純小寫加下劃線：age_of_tom = 18（較長的變數名推薦使用這種）
2、駝峰體：AgeOfTom = 18

變數名只要不在等號左邊，代表的是取值操作

age = 18
age = age + 1
print(age)

這里下面的age代表新的變數名，將上面的age這個值取出來加1后再賦值給左邊的新age(下面會介紹運算)

變數值有兩大特征

---

id：變數值的身份證，反映的是記憶體地址
type：變數值的型別

id一樣，代表記憶體地址一樣，也就說指向的是同一個記憶體空間，值肯定是一樣

x = 10
y = x
z = 'test'

print(id(x))
140457508094688
print(id(y))
140457508094688
print(id(z))
140654736153552

print(type(x),type(y),type('z'))
<class 'int'> <class 'int'> <class 'str'>

Python的一種優化機制，值相同就沒必要重新劃分一塊空間

x = 10
y = 10
print(id(x))
4351208384
print(id(y))
4351208384

垃圾回識訓制

---

Python中是不需要程式員手動管理記憶體的，它的GC(Garbage Collection)機制 實作了自動記憶體管理，GC做的事情就是解放程式員的雙手，找出記憶體中不用的資源并釋放這塊記憶體，

參考計數：

當一個變數值被多次參考，那么它的計數也會隨之增加

x = 20	# 20這個值的記憶體地址計數+1
y = 20	# 20這個值的記憶體地址計數+1
		# 當前值為2
		
del x 	# 解除了x這個變數名與20這個值記憶體地址的系結
		# 計數-1
del y 	# 解除了x這個變數名與20這個值記憶體地址的系結
		# 計數-1
"""

當前20這個值的記憶體地址沒有被任何變數指定，那么它無法被取出
問題就是它會一直占用這塊記憶體空間，如果是C/C++的話是需要
手動清理這個記憶體空間的，那么在python里面的話，它會排查
如果計數為0的記憶體地址直接回收掉，不需要程式員手動來
清理它

"""

二、注釋

---

注釋的作用是來對所寫代碼進行一個說明，或是對整體代碼檔案進行一個說明

單行注釋：對某一段代碼進行說明，或是暫時不啟用此段代碼也可以進行注釋,被注釋后全部不會被當做代碼執行

tom_name = "tom"
tom_age = 18	# tom的年齡
# test = 'python'

使用單行注釋的標準格式為 # 后跟空格再跟注釋內容，注釋也可以用來進行代碼測驗，這里是 test就不會被python所執行，

多行注釋：通常用于對整個代碼檔案進行說明 也可以對某一個代碼功能進行多行詳解，寫法是3雙引號或3單引號

"""
2020年x月x日
這個檔案用于代碼測驗

這是3個雙引號多行注釋

"""

'''
2020年x月x日
這個檔案用于代碼測驗

這是3個單引號多行注釋

'''

三、運算子

---

演算法運算子

假設變數x = 10，y = 31

運算子	描述	實體
+	兩個物件相加	x + y 輸出結果為 41
-	兩個數相減	x - y 輸出結果為 -21
*	兩個數相乘或是回傳一個被重復n次的字串	x * y 輸出結果為 310
/	x除以y	y / x 輸出結果為 3.1
%	取模 回傳觸除法的余數	y % x 輸出結果為1
**	回傳x的y次冪	x ** y 為10的31次方
//	取接近商的數	9 // 2 結果為4 -9 // 2 結果為5

print(10 + 3)	13
print(10 - 3)	10
print(10 * 3)	30
print(10 ** 3)	100
print(10 / 3)	3.33333335
print(10 // 3)	3
print(10 % 3)	1

print(10 * 3.333)  33.33

print([1,2,3]+[3,4,5])	[1,2,3,4,5]
print([1,2,3]*3)	[1,2,3,1,2,3,1,2,3]

比較運算子

運算子	描述	實體
==	等于 比較兩個物件是否相等	(a == b) 回傳 False
!=	不等于 - 比較兩個物件是否不相等	(a != b) 回傳 True
>	大于 - 回傳x是否大于y	(a > b) 回傳 False
<	小于 - 回傳x是否小于y，所有比較運算子回傳1表示真，回傳0表示假，這分別與特殊的變數True和False等價，注意，這些變數名的大寫	(a < b) 回傳 True
>=	大于等于 - 回傳x是否大于等于y	(a >= b) 回傳 False
<=	小于等于 - 回傳x是否小于等于y	(a <= b) 回傳 True

print(10 == 10)	# True
print(10 > 10)	# False 10不大于10
print(10 >= 10)	# True
print("abc" != "ddd")	# True

print(10 > 3.1)	# True
print(10 > "12")	# 數字型別不能于字串進行比較

print("a12" == "a12")	# True
print([1,2,3] == [1,2,3])	# True


print("abc" > "az")	# False	字串比較是一個個字符進行比較，參照ASCII碼

l1=[111,222,333]
l2=[111,999]
l2=[111,"aaa"]
print(l1 > l2)	# 也是取出每一個元素進行對比,這是結果為False 因為222不大于999

變數賦值

---

鏈式賦值：多個變數進行相同賦值

a = b = c = 10
print(a,b,c)
10 10 10

交叉賦值：多個變數進行不同賦值

a, b, c = 10, 20, 30	# 同時進行多個變數賦值
print(a,b,c)
10 20 30

x = 10
y = 20
x, y = y, x	# x與y的值進行交換

解壓賦值

# 第一種：必須滿足串列的長度定義變數 不能多也不能少 如果少寫一個變數就會報錯
l = [1,2,3,4,5]
a,b,c,d,e = l   
print(a,b,c,d,e)
1 2 3 4 5

# 第二種：自定義取值 從*開始的位置打包后面的值賦給下劃線這個變數（也可以定義別的）
#	最后定義的e變數 表示要取最后一個值，所以這個*打包到它前面就停止了
a,b,*_,e = l
print(a,b,e)
1 2 5
print(_)	# 列印它的打包內容
[3,4]

邏輯運算子

---

and：連接左右兩邊的條件，左右兩邊的判斷結果都為True，結果才為True
or：連接左右兩邊的條件，左右兩邊其中一個為True，結果就為True

2 > 1 and 2 > 3 # 判斷為False
2 > 1 or 2 > 3  # 判斷為True

短路運算：and(有一個錯誤結果整體都為錯誤)、or(有正確結果就不看后面的判斷)

優先級：not > and > or

not 取反

1 == 3  # 結果為 False
not 1== 3  # 結果為 True

可以判斷一下以下的比較結果為 True 還是False

3 > 4 and 4 > 3 or not 1 == 3 and 'x' == 'x' or 3 > 3

先查看not 以及其后面的一個判斷條件

再從頭開始查看優先級

(3 > 4 and 4 > 3) or (not 1 == 3 and 'x' == 'x') or 3 > 3

括號優先級才是最高的，但這里用到括號主要用于標識

in 用于匹配是否存在該內容 而前面的==是比較兩個內容是否相同

name = 'root'
print('r' in name)
True

print('r' == name)
False

四、基本資料型別

---

在Python中變數不需要宣告型別，變數在使用前必須要進行賦值，變數賦值以后才算創建好這個變數

在 Python 中，變數就是變數，它沒有型別，我們所說的"型別"是變數所指的記憶體中物件的型別，

多個變數賦值：

a = b = c = 1 # 多個變數賦值相同
a, b, c = 1, 2, 3 # 多個變數賦值不同

Python3 中有六個標準的資料型別：

• Number（數字）
• String（字串）
• List（串列）
• Tuple（元組）
• Set（集合）
• Dictionary（字典）

Python3 的六個標準資料型別中：

不可變資料（3 個）：Number（數字）、String（字串）、Tuple（元組)
可變資料（3 個）：List（串列）、Dictionary（字典）、Set（集合）

不可變型別：值改變的情況下，記憶體地址也變，證明時產生了新的值，即原值不可變=>可hash型別
可變型別：值改變的情況下，記憶體地址/id不變，證明改變的就是原值，即可變型別=>不可hash型別

type() 可以用來查看資料型別

---

Number（數字）

Python3 只有一種整數型別 int 表示為長整型，沒有Python2的long

# 通常用于存盤手機號、qq號、編號、門牌號等等
a = 123		# 整數型別

# 通常用于存盤 薪資、身高、體重等等
b = 3.14	# 浮點型別
c = 4+3j	# 復數型別
print(type(a),type(b),type(c))
<class 'int'> <class 'float'> <class 'complex'>

a += b # 相當于 a = a + b
print(a)

# 不能對源資料進行更改，但是可以通過相加來進行改變，不再是原來的記憶體地址了

a = 123
print(id(a))
4411812320

a += 456
print(id(a))
140618798753168

字串型別（str）

---

Python 字串是用兩個`單引號`或者兩個`雙引號`括起來，執行`\`轉移 字串的作用是需要寫入字符就需要往這里存盤

test_str = 'Hello World'	
test_str = "Hello World"

相同的變數名，相同的值則指向記憶體地址是相同的，不同值的話則是替換的意思

Python 使用反斜杠 \ 轉義特殊字符，如果你不想讓反斜杠發生轉義，可以在字串前面添加一個 r，表示原始字串：

test_str = 'Hello \nihao'
print(test_str)
Hello 
ihao

str_test = r"Hello\nihao"
print(str_test)
Hello\nihao

因為\n在python里面是代表換行的字符 ，如果堅持這樣使用那么在前面添加r

字串變數值是不可變的，定義了就不能改變，但可以連接或分割

str_test = 'Hello'
test_str = 'World'
test = str_test + test_str	# +相對字串用于兩個進行連接
print(test)
HelloWorld

len() 查看變數值的長度

字串分割：大部分編程語言0代表了第一個，這里指的是獲取test變數值的0-5位置的字符，注意：分割 顧頭不顧尾 其實只能到截取到第四個

test = 'HelloWorld'

ziye = test[0:5]
print(ziye)
Hello

print(test[-1])   # 代表獲取最后一個字符
d
print(test[5:-1]) # 注意 顧頭不顧尾 只能獲取到 5-倒數第二個字符
Worl
print(test[5:])   # 獲取從5-最后一個字符
World

字串的常用方法

strip() 默認用于去除左右兩邊的空白

name = '    root    '
print(name)
    root    
print(name.strip())
root

# 首先從最左邊往右看 如果有空白就去除，遇到別的字符就停止，再從右往左看去除空白
name = '   ro ot    '.strip()
print(name)
ro ot

'''

strip() 如果未加選項默認去除就是空白，但是strip是可以增加去除篩選的

'''

name = '**** root ****'.strip('*')	# 這里就是去除*號了
print(name)
 root # 注意空白還在

# 或者去除多個
name = '(-)*&123)*)-'.strip('(-)*&')
print(name)
123

split() 字符切割，用于找到字串中的指定字符進行分隔開來

# 一般用于有規律的字串進行分隔
name = 'root:tom:jack'.split(':')	# 指定分隔符
print(name)
['root','tom','jack']	# 分隔以后會放到串列里面

str型別常用方法過多，另寫一篇博客詳細說明

串列（List）

---

List是Python中最常用的資料型別，

串列中的資料型別可以是整數、字串、串列（嵌套）、字典、集合、元組
串列是寫在放括號內的[]
同字串一樣，串列是可以進行索引和截取的，
截取方式：變數名[頭上標：頭下標]

# List定義 取值
test_list = [123,'abc']
print(test_list)
[123,'abc']

print(test[0])
123

List嵌套

list_test = [123,'abc',['這是嵌套,,,','this is 嵌套...']]
print(list_test[2])
['這是list嵌套,,,','this is list 嵌套...']

print(list_test[2][1])
'this is 嵌套...'

List 反序

test_list = [1,2,3,4,5,6]

print(test_list[::-1])	
[6, 5, 4, 3, 2, 1]

串列元素修改

test_list = [1,2,3,4,5,6]

test_list[0] = 10
print(test_list)
[10,2,3,4,5,6]

往串列追加內容

test_list = [1,2,3,4,5,6]

test_list.append(7)
print(test_list)
[1, 2, 3, 4, 5, 6, 7]

往串列插入內容

test_list = [1,2,3,4,5,6]

test_list.insert(1,'this is insert') # 在第一個插入內容 原來的會往后移動
print(test_list)
[1, 'this is insert', 2, 3, 4, 5, 6]

Tuple（元組）

---

元組使用方法和串列類似，但元組已存的資料不能對其進行更改但是可以更改其子元素

# 元組的定義
test_tuple = (1,2,3,4)
print(test_tuple)
(1,2,3,4)

test_tuple[0] = 10 # 元組創建時的資料不可變，此行報錯

# 元組的參考
print(test_tuple[1])
2

修改元組子元素的內容

test_tuple = (1,2,3,['a','b','c'])
print(test_tuple)
(1, 2, 3, ['a', 'b', 'c'])
print(id(test_tuple[3]))
140602894031872

test_tuple[3] = 'abc'	# 無法修改，直接報錯，因為正在修改元組的資料

# 但可以修改串列里的子元素 而修改串列子元素與元組無關，且串列為可變資料型別
test_tuple[3][0] = 'A'
print(test_tuple)
(1, 2, 3, ['A', 'b', 'c'])
140602894031872		# 通過觀測可以看到串列自身并沒有發生改變

Dict（字典）

---

與串列不同的是，字典取值是通過key來取value的，字典的內容也可以存放各個資料型別的值，實體：

# 字典的定義
dic = {'name':'tom','age':18,'height':180,'salary':15300}

# 字典取值 通過key(鍵)來獲取對應的值
print(dic['name'])
tom

# 字典 嵌套串列
dic = {'name':'tom','hobby':['music','movie','basketball']}
print(dic['hobby'][1])
movie

修改字典的內容

dic = {'name':'tom','age':18,'height':180,'salary':15300}

dic['name'] = 'jack'

print(dic)
{'name': 'jack', 'age': 18, 'height': 180, 'salary': 15300}

字典追加內容

dic = {'name': 'jack', 'age': 18, 'height': 180, 'salary': 15300}

dic['width'] = 200
{'name': 'jack', 'age': 18, 'height': 180, 'salary': 15300, 'width': 200}

bool（布爾型別）

---

bool 只有兩個值：True、False

True 代表真、False 代表假

另外一些其它的值也可以代表 True、False

它們分為顯性和隱性

顯性：

print(1 == True)	# 1 可以直接代表 True
True

print(0 == False)	# 0 可以直接代表 False
True	# 比較成功結果才為True

'''

False [] {} "" '' None 這些都可以代表 False
True 1  以及除開0的其它數字

'''
bool() # 把內容轉換成bool型別
print(bool([]) == False)	# True
print(bool({}) == False)	# True
print(bool("") == False)	# True
print(bool('') == False)	# True
# 這些 判斷都成立 表示它們確實可以代表False

print(bool(-1) == False)	# 結果為False	因為數字只有0可以代表False
print(bool(-1) == True)		# True

隱性

print(5 > 10) # False
print(10 > 5 and 5 < 10) # True
print(not 5 > 10 and 20 > 15) 	# True
print(False > True) # False

型別轉換

---

當資料型別符合轉換標準才能夠轉換

x = '123'	
x = int(x)	# x變數值 帶有數字字符 可以轉換成數字不會報錯
print(type(x))
<class 'int'>

x = 'abc'
x = int(x)	# 內容不符合轉換，直接報錯

x = [1,2,3,4,5]
x = str(x)	# 所有型別都可以轉換成字串
print(type(x))
<class 'str'>

x = '[1,2,3,4,5]'
x = list(x)	# 內容符合 才可以轉換成串列型別
print(type(x))
<class 'list'>

技術小白記錄學習程序，有錯誤或不解的地方請指出，如果這篇文章對你有所幫助請點贊+收藏 謝謝！