花了2萬多買的Python教程全套，現(xiàn)在分享給大家，入門到精通(Python全棧
# 第一章?
##?輸入輸出print
> print函數(shù)的作用是向目的地輸出內(nèi)容
> 內(nèi)容可以是: 字符串，數(shù)字，表達式
> 目的地可以是：控制臺，文件
print可以在控制臺輸出字符串
```py
print("Hello World!")
```
輸出數(shù)字
```py
print(114514)
```
輸出含有運算符的表達式
```py
print(114000 + 514)
```
向文件輸出，就是編寫文件內(nèi)容
```py
fp = open("D:/Project/Python/study/day01/text.txt", "a+")# 第一個變量是文件路徑,第二個變量表示續(xù)寫文件
print("hello world", file = fp)
fp.close() #關(guān)閉文件
```
不換行輸出
```py
print("114","514")
print(114,"514")
print(114,514)
```
## 轉(zhuǎn)義字符
> 大多數(shù)編程語言會有一些特殊字符：回車，換行，制表符..,這些字符可以通過轉(zhuǎn)義字符反斜杠在字符串中表示出來：\
換行符，可以讓字符串多行輸出
```py
print("第一行\(zhòng)n第二行")
```
回車，回車和換行符不一樣會，回車會讓回車符之前的字符串不輸出
```py
print("hello\rworld")
```
制表符
```py
print("hello\tworld")
print("helloooo\tworld")
```
> 一個制表符代表四個空格，但是制表符前面的字符數(shù)不是4的整數(shù)倍，制表符會補全空格，使字符總數(shù)變成4的整數(shù)倍
退格，退格會把退格字符前一個字符去掉
```py
print("hello\bworld")
```
雙引號、單引號、反斜杠
```py
print("這是一個單引號\'")
print("這是一個雙引號\"")
print("這是一個反斜杠\\")
```
在字符串之前寫一個r可以讓程序忽視轉(zhuǎn)義字符,但是字符串最后的字符不能是單數(shù)個反斜杠
```py
print(r"這是兩個反斜杠\\") # 這是兩個反斜杠\\
print(r"a\"a") # a\"a
print(r""") # 這個會報錯
```
## 字符編碼
>chr()函數(shù)是Python中的一個內(nèi)置函數(shù)，它接受一個整數(shù)參數(shù)，并返回對應的Unicode字符。
ord()函數(shù)是另一個Python中的內(nèi)置函數(shù)，它接受一個Unicode字符作為參數(shù)，并返回對應的整數(shù)值。
chr()函數(shù)和ord()函數(shù)是互逆的，即ord(chr(x)) == x和chr(ord(c)) == c。它們可以在需要將整數(shù)和字符之間進行轉(zhuǎn)換的情況下使用。請注意，chr()函數(shù)和ord()函數(shù)只適用于Unicode字符，而不適用于ASCII字符或其他字符集。
```python
print(chr(23002)) # 姚
print(ord("姚")) #23002
```
## 標識符和保留字
>我們給變量、函數(shù)、類、模塊和其它對象起名名字叫標識符
在python中一些單詞本賦予了特殊的含義，標識符不能使用這些特殊單詞，這些單詞就叫做保留字（關(guān)鍵字）
>定義標識符的規(guī)則：
>可以使用字母(大小寫)、數(shù)字、下劃線
>不能以數(shù)字開頭
>不能是保留字
>嚴格區(qū)分大小寫
使用keyword庫中的keyword變量即可查看有哪些保留字
```py
import keyword
print(keyword.kwlist)
```
## 變量
>變量由三部分組成，id，類型，值。id是該變量在內(nèi)存中的唯一地址
定義變量： 變量名 = 值，python中定義變量不需要寫變量的類型
```py
name = "張三"
```
可以通過函數(shù)來獲取變量的id和類型
```python
print(id(name)) # 2644770188400
print(type(name)) # <class 'str'>
```
變量可以多次賦值
```py
name = '張三'
print(name) # 張三
name = '李四'
print(name) # 李四
```
## 數(shù)據(jù)類型
> 整型 int 114514
> 浮點型 float 114.514
> 布爾型 bool True(代表真) ，F(xiàn)alse(代表假)
> 字符串類型 str "張三" '張三'
### 整形
> 整形 integer 簡寫為int 可以表示正整數(shù)、負整數(shù)和零
> 整數(shù)有不同的表達方式：
> 十進制->默認的進制
> 二進制->以0b開頭
> 八進制->以0o開頭
> 十六進制->以0x開頭
```py
a = 123 #123
b = 0b101010 #42
c = 0o177 #127
d = 0x1ae #430
print(a,b,c,d)
```
### 浮點型
> 浮點數(shù)由整數(shù)部分和小數(shù)部分組成
> 但浮點數(shù)存在不精確性
```py
a = 1.1
b = 2.2
print(a + b) #3.3000000000000003
```
> 解決不精確的方法：導入decimal模塊
```py
from decimal import Decimal
print(Decimal('1.1') + Decimal('2.2')) # 3.3
# 主要這里的1.1和2.2是字符串類型
```
### 布爾類型
> 布爾類型只有兩個值，一個是真:True，一個是假:False，可以在判斷語句中使用
> 布爾類型數(shù)據(jù)可以轉(zhuǎn)換成數(shù)字，Ture可轉(zhuǎn)換為1，F(xiàn)alse可轉(zhuǎn)換成0
```py
bool1 = True;
bool2 = False;
print(bool1,type(bool1)) #True <class 'bool'>
print(bool2,type(bool2)) #False <class 'bool'>
```
### 字符串類型
> 字符串類型是非常常見的數(shù)據(jù)類型，它可以用單引號，雙引號，三引號來表示
> 三引號就是三個單引號或者三個雙引號，用三引號可表示多行字符串
```py
str1 = '張三' # 單引號
str2 = "李四" # 雙引號
str3 = r'''王五
????趙六''' # 三個單引號的三引號
str4 = """王五
????趙六""" # 三個雙引號的三引號
print(str1,type(str1)) #張三 <class 'str'>
print(str2,type(str2)) #李四 <class 'str'>
print(str3,type(str3))?
#王五
#????趙六 <class 'str'>
print(str4,type(str4))
#王五
#????趙六 <class 'str'>
```
### 數(shù)據(jù)類型轉(zhuǎn)換
不同數(shù)據(jù)類型的數(shù)據(jù)可以相互轉(zhuǎn)換
int數(shù)據(jù)可以由字符串或者float數(shù)據(jù)轉(zhuǎn)換（使用int()函數(shù)）
float數(shù)據(jù)可以由int或者字符串數(shù)據(jù)轉(zhuǎn)換（使用float()函數(shù)）
字符串數(shù)據(jù)也可以由int或者float類型數(shù)據(jù)轉(zhuǎn)換（使用str()函數(shù)）
布爾類型數(shù)據(jù)也可以轉(zhuǎn)換成int類型數(shù)據(jù)，True代表1，F(xiàn)alse代表0
int()
```py
a = "1"
b = '-1'
c = 1.1
d = True
print(int(a),type(int(a)))# 1 <class 'int'>
print(int(b),type(int(b)))# -1 <class 'int'>
print(int(c),type(int(c)))# 1 <class 'int'>
print(int(d),type(int(d)))# 1 <class 'int'>
```
float()
```py
a = 1
b = '-1'
c = "1.12"
print(float(a),type(float(a)))# 1.0 <class 'float'>
print(float(b),type(float(b)))# -1.0 <class 'float'>
print(float(c),type(float(c)))# 1.12 <class 'float'>
```
str()
```py
a = 122
b = 1.11
c = True
print(str(a),type(str(a)))# 122 <class 'str'>
print(str(b),type(str(b)))# 1.11 <class 'str'>
print(str(c),type(str(c)))# True <class 'str'>
```
## 注釋
> 注釋即為嵌入在程序中的，對程序沒有影響的，對代碼有標注性意義的文本。（這是我給注釋下的定義）
> 注釋可分為單行注釋和多行注釋
> 單行注釋用井號來表示"#"
> python中沒有多行注釋，但是你可以寫一個多行字符串，不給他添加變量來代替多行注釋
```py
# 單行注釋
"""
多行注釋
"""
```
還有一個特殊類型注釋，中文編碼聲明注釋，聲明該文件的編碼格式
```
# coding: gbk
```
# 第二章
## input()函數(shù)
> 參數(shù)：在控制臺的提示文字
> 作用：input函數(shù)數(shù)用于獲取標準輸入（通常是鍵盤）獲取用戶的輸入，它的返回值就是用戶的輸入
> 返回值：input函數(shù)的返回值都是str類型，如果需要其他類型的數(shù)據(jù)，就使用類型轉(zhuǎn)換函數(shù)進行轉(zhuǎn)換
```py
str = input("請輸入一個字符串："); # bianys
print(str,type(str)) #bianys <class 'str'>
str = input("請輸入一個數(shù)字："); # 2
print(str,type(str)) #2 <class 'str'>
```
可以看到，就算輸入的是數(shù)字，返回的也是字符串類型的數(shù)據(jù)。
## 運算符
### 算術(shù)運算符
```py
print(1+1) #加法運算符：+
print(1-1) #減法運算符：-
print(1*1) #乘法運算符：*
print(3/2) #除法運算符：/ 1.5
print(3//2) #整除運算符：//，返回值向下取整 1
print(9//-4) # -3
print(-9//4) # -3
print(5 % 3) #取余運算符：%，余數(shù) = 被除數(shù) - 除數(shù)*商
print(-5 % 3) # 1
print(5 % -3) # -1
print(2**3) #冪運算符：**，該表達式表示2的三次方
```
### 賦值運算符
>賦值運算符就是給變量賦值的，用直接賦值，鏈式賦值，參數(shù)賦值，解包賦值
>
直接賦值
```py
a = 3
print(a)
```
鏈式賦值
```py
a=b=c= 20
print(a,b,c) # 20 20 20
```
參數(shù)賦值
```py
a=10
a+=5
print(a)# 15
a-=5
print(a)# 10
a*=5
print(a)# 50
a/=5
print(a)# 10.0
a//=5
print(a)# 2.0
a%=5
print(a)# 2.0
```
解包賦值，按照順序賦值
```py
a,b,c = 10,20,30?
print(a,b,c) # 10 20 30
a,b = b,a
print(a,b)# 20 10
```
### 比較運算符
>比較運算符是一類給變量的大小、真假進行判斷的運算符，返回布爾類型數(shù)據(jù)
```py
a,b = 10,20
print(a>b)#False
print(a>=b)#False
print(a>=b)#False
print(a>=b)#False
print(a<=b)#True
print(a<b)#True
print(a==b)#False
print(a!=b)#True
```
== 和 is
> 判斷變量是否同有兩種方式，一種是==，另一種是is
> == 是對變量的值進行比較
> is 和 is not 是針對變量的地址，也就是id進行比較
```py
a = 10
b = 10
print(a==b,id(a),id(b)) #True 140732815369288 140732815369288
print(a is b,id(a),id(b)) #True 140732815369288 140732815369288
a = [1,2,3]
b = [1,2,3]
print(a==b,id(a),id(b)) # True 2014458369216 2014460169280
print(a is b,id(a),id(b)) # False 2014458369216 2014460169280
print(a is not b,id(a),id(b)) # True 2014458369216 2014460169280
```
in 與 not in
>in判斷一個變量是否在另一個變量集合中，這個變量集合其實就是數(shù)組(字符串可當作字符數(shù)組)
>in 與 not in 正好相反，判斷一個變量是否不在另一個變量集合中
```py
list = [1,2,3,4]#這是一個數(shù)組
print(1 in (1,2,3))#True
print(5 in list)#False
print(1 not in [1,2,3])#False
print(8 not in [1,2,3])#True
```
### 布爾運算符(邏輯運算符)
>對布爾類型數(shù)據(jù)進行計算的運算符是布爾運算符，返回值也是布爾類型的值
>都有and、or、not 分別對應著與、或、非，運算邏輯不多展示。
```py
print(True and False) # False
print(True and True) # True
print(True or False) # True
print(False or False) # False
print(not True) # False
print(not False) # True
```
### 位運算符
python中的位運算符有 &(與)、|(或) 、<<(左移運算)、>>(右移運算)
```py
print(4 & 3) # 按位相與:0
print(4 | 3) # 按位相或:7
print(129 << 1) # 4左移1位,邏輯左移:258
print(4 >> 1) # 8又移2位,邏輯右移:2
print(255 >> 2) # 邏輯右移:63
```
### 運算符的優(yōu)先級
> 算數(shù)符的優(yōu)先級
?小括號>算術(shù)運算>位運算>比較運算符>布爾運算符>賦值運算符(=)
?** >?(*,/,//,%) > (+,-) > (<<,>>,&,|) > (>,<,==,>=,<=.is,is not,in) > (and,or,not) > (=)
```py
?a = 2**2 * 3 + 1 > 1 << 4 and True
b = 2**2 * 3 + 1
c = 1 << 4
print(a)# False
print(b)# 13
print(c)# 16
```
# 第三章
## 程序的組織結(jié)構(gòu)（程序的流程控制）
程序的運行結(jié)構(gòu)分為三種，順序結(jié)構(gòu)，選擇結(jié)構(gòu)，循環(huán)結(jié)構(gòu)
### 順序結(jié)構(gòu)
>順序結(jié)構(gòu)就是程序由上到下，由左到右依次執(zhí)行。
```py
print("開始把大象放入冰箱")
print("1-打開冰箱")
print("2-把大象放進冰箱")
print("3-關(guān)閉冰箱")
print("結(jié)束")
"""輸出結(jié)果
開始把大象放入冰箱
1-打開冰箱
2-把大象放進冰箱
3-關(guān)閉冰箱
結(jié)束
"""
```
### 對象的布爾值
>在python中，任何東西都是對象，所有的對象都有一個對應的布爾值，可以通過內(nèi)置函數(shù)bool()來獲取對象的布爾值
>除了以下幾個對象的布爾值是False，其他對象的布爾值都是True
False，0，0.0，""，''，None，空列表[],list()，空元組(),tuple()，空字典{},disc()，空集合set()
```py
# 以下輸出返回值全是False
print(bool(False)) # False
print(bool(0)) # 零
print(bool(0.0))# 零點零
print(bool(""))# 空字符串
print(bool(None))# 空對象
print(bool([]))# 空列表
print(bool(list()))# 空列表
print(bool(()))# 空元組
print(bool(tuple()))# 空元組
print(bool({}))# 空字典
print(bool(dict()))# 空字典
print(bool(set()))# 空集合
```
### 單分支結(jié)構(gòu)
介紹
>單分支結(jié)構(gòu)就是，如果滿足某個條件，就做某件事
語法
>if 布爾表達式:
縮進(一般是4格)要做的事
縮進(一般是4格)要做的事
縮進(一般是4格)要做的事
...
例如
```py
money = 2000000
if money > 114514: #注意這里有個冒號
??print("土豪啊")
```
### 雙分支結(jié)構(gòu)
介紹
>雙分支結(jié)構(gòu)就是，如果滿足某個條件，就做某件事，否則就做另一件事
語法
>if 布爾表達式:
縮進(一般是4格)要做的事
縮進(一般是4格)要做的事
縮進(一般是4格)要做的事
else:
縮進(一般是4格)另一件事
縮進(一般是4格)另一件事
縮進(一般是4格)另一件事
...
例如
```py
height = 190;
if height >= 180:
??print("長得真高啊")
else:
??print("長的真低啊")
```
### 多分支結(jié)構(gòu)
介紹
>如果滿足某個條件，就執(zhí)行某件事，如果不滿足，否則，如果滿足另一個條件，就執(zhí)行另一件事，否則....，最后所有條件都不滿足，執(zhí)行某一件事。
語法
>if 布爾表達式1:
??代碼1
elif 布爾表達式2:
??代碼2
elif 布爾表達式3:
??代碼3
... ...
else:
??代碼n
例如
```py
if 100 <= score >= 90:
??print("真厲害，不愧是我的兒子")
elif score >= 80:
??print("這回考得不錯")
elif score >= 70:
??print("正常發(fā)揮，還行")
elif score >= 60:
??print("這回考的不行，給你一個大比兜")
elif 0 <= score < 60:
??print("龜孫賊，來來來，看你能不能看到明天的太陽！")
else:
??print("這逼老師，瞎幾把判的分吧")
```
### 嵌套分支
>分支結(jié)構(gòu)是可以嵌套的，分支結(jié)構(gòu)里面也可以寫分支結(jié)構(gòu)
例如
```py
money = int(input("消費金額:"))
haveCard = input("是否有會員卡(y/n)：")
if haveCard == "y":
??if money >= 200:
????print("打8折，消費:", money * 0.8, "元")
??elif money >= 100:
????print("打9折，消費:", money * 0.9, "元")
??else:
????print("不打折，消費:", money, "元")
else:
??if money >= 100:
????print("打九五折，消費:", money * 0.95, "元")
??else:
????print("不打折，消費:", money, "元")
```
### 條件表達式
>條件表達式是一個表達式，是表達式它返回的就是一個值
>他會根據(jù)條件的不同返回兩個不同的值
語法
值1 if 布爾表達式 else 值2?# 如果布爾表達式為True，返回值1，否則返回值2
```py
a = 10
b = 20
print("a>b" if a > b else "a<=b")
```
### pass語句
pass代表空語句，當我們在一個地方必須要代碼，否則會報錯的時候，我們可以暫時用pass來代替
```py
if True:
#這個地方必須寫代碼，否則會報錯
else:
#這個地方必須寫代碼，否則會報錯
```
```py
# 這樣就不會報錯了
if True:
pass
else:
pass
```
### 內(nèi)置函數(shù)range()
>range返回一個range類型的對象，range對象可以通過list函數(shù)轉(zhuǎn)換成一個數(shù)組
>根據(jù)參數(shù)的不同返回的集合也不同
>range(int a) # a代表返回從0到a-1的一個數(shù)組，每個數(shù)之間的間隔為1
>range(int a,int b) # a代表返回從a到b-1的一個數(shù)組，每個數(shù)之間的間隔為1
>range(int a, int b, int c) # a代表返回從a到b-1的一個數(shù)組，每個數(shù)之間的間隔為c
```py
r = range(10) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(r))
r = range(2, 10) # [2, 3, 4, 5, 6, 7, 8, 9]
print(list(r))
r = range(2, 7, 2) # [0, 2, 4, 6, 8]
print(3 in r) # False
print(4 in r) # True
print(5 not in r) # True
```
注意：range()函數(shù)返回的只是一個range類型的對象，并不是一個數(shù)組，因此在內(nèi)存中占空間是比較小的，當使用list()函數(shù)將其轉(zhuǎn)換成一個數(shù)組后，他才是一個真正的數(shù)組。
### 循環(huán)
