#! /usr/bin/env python
# -*- coding: utf-8 -*-
?
# 注釋
換行寫代碼 \
?
進制
十進制 123456789
二進制 0b123
八進制 0o123
十六進制 0x123
?
變量不用聲明必須賦值
字符串 ' ' " " """ """ ''' ''' 用來括長字符串，保留換行格式
轉義字符 \
\uxxxx 表示使用Unicode編碼 # eg: "\u0040"
?
格式化字符串
在Python中很少用“+”進行字符串拼接，字符串只能和字符串拼接
print('a=',a)
創建字符串時指定占位符
b = 'sdasdasd%s'%'孫悟空'
b= 'dsadad%s%s'%('sdsad','sdad')
b = 'sdasdasd%3s'%'孫悟空' 最小填充3，不夠前邊補位空格
b = 'sdasdasd%3.5s'%'孫悟空' 最小填充3最長5，不夠前邊補位空格超出后邊截尾
?
b = 'sdasdasd%s'%123
b = 'sdasdasd%.1f'%123.5
b = 'sdasdasd%d'%123
?
b = r'sadsad' #字符串前加r表示，啟用原始字符串模式，轉義字符串等失效
?
%s%f%d
?
格式化字符串
c=f"hello {a} "
?
print('a=',+a)
print('a=',a)
print('a=%s'%a)
print(f'a={a}')
print("adas",end="")
a="小米" * 20 #字符串乘以數字，字符串復制
?
boolean值 True False
bool python簡寫
None 空值
?
類型檢查
c=type(變量) #用來檢查值的類型
對象 id #內存地址 id()
type #類型 功能 type()
value #值
a 可變對象
123 不可變對象
?
int()
float()
bool() # '' 0 None
str()
?
算術運算符 +-*/ // #整除 ** 冪運算 %
賦值運算符
關系運算符 < > <= >= == != is is not #比較兩個對象是否為同一對象
邏輯運算符 not and or
非布爾值進行邏輯運算時，Python會將其當成boolean值運算，返回原值
邏輯運算符可以連號 result = 1 < 2 < 3
條件運算符
語句1 if 條件表達式 else 語句2
max = a if a > b else b
?
流程控制
條件判斷語句（if）
語法 ： if 條件表達式 : 語句
代碼塊縮進管理多行
input(['參數'])
語法： if 條件表達式 :
代碼塊
else :
代碼塊
?
語法： if 條件表達式 :
代碼塊
elif 條件表達式 :
代碼塊
elif 條件表達式 :
代碼塊
elif 條件表達式 :
代碼塊
else :
代碼塊
?
?
?
循環語句
while
語法：
while 條件表達式 ：
代碼塊
?
while 條件表達式 ：
代碼塊
else :
代碼塊
?
break
continue
pass #占位
?
模塊引入
from time import *
time()
?
序列
列表 list [ ]
python列表可以存放任意數據
以下為通用操作對字符串有效
len(s)
index可以是負數，倒數 eg：-1 倒數第一個
切片獲取 list[start:end] #包括起始位置，不包括結束位置
起始位置和結束位置都可以省略
list[:]
list[start:end:步長] #步長不能是0，可以是負數，負數為逆序
list + 列表拼接 * 復制
in not in 檢查是否存在
print('dd' in list) # True False
min(list) #獲取最小值
max(list) #獲取最大值
s.index()
s.count(s[0]) #統計指定元素出現的次數
序列——————有序
可變序列
list
不可變序列
str
tuple #元組
?
可變序列可修改
索引修改
del s[2] # 刪除
切片 s[:] ##從頭到尾切片，獲得副本
切片替換 s[0:2] = ['s','w','w'] #可以多個替換一個
s[0:0] = 'd' # 索引0位置插入
s[::2] = ['s','s'] #設置步長時，賦值雙方list 數量一致
del s[::2] #切片刪除
s[0:2]=[] #賦值空來刪除
?
不可變序列
s=list(s) #強制轉換
?
可變序列方法
s.append(str) #添加元素
s.insert(i,x) #插入元素（非替換）
s.extend() #使用新序列擴展當前序列 【添加有個序列】
s.clear() #清空序列
s.pop(index) #根據索引刪除返回被刪除對象
s.pop() #刪除最后一個
s.remove(x) #刪除指定值，【刪除第一個】
s.reverse() #反轉
s.sort() #排序
s.sort(reverse = True) #排序
s.copy() s[:] ##制作副本的兩種方法
列表遍歷
for 變量 in 序列 :
代碼塊
?
range([start],end,[step]) #生成自然數的序列的函數
r = range(5) #[0,1,2,3.4]
list(r)
?
!!!! python 里的for循環
for i in range([start],end,[step]) :
代碼塊
else
break;/continue
?
?
tuple 元組 ()
創建
my_tuple = ()
my_tuple = 1,2,3,4 #元組不為空括號可以省略
my_tuple = 1,
#元組的解包（解構）
a,b,c,d = my_tuple
a,b = b,a #變量交換
a,b,*c = my_tuple # *c獲得剩余元素，像指針
##也可以對列表和str解包
?
可變對象
?
== != #比較值 is is not #比較對象
?
字典 dict
item項
key-value
創建
d = { }
語法：
d = { key:value,key:value }
d = dict(key=value,key=value) #dict 函數
雙值子序列
[1,2] (1,2) #雙值
[(1,2),(3,5)] #子序列
d = dict( [(1,2),(3,5)])
len(變量)
in
not in
'hello' in d #查看鍵是否存在
d[key] # key必須加引號
d['key'] = value #沒有的可以添加，不能讀取
setdefault(key[,default]) #添加字段，設置默認值
result = setdefault(key[,default]) # result 返回實際值
update([other])
eg:
d1={'a':1,'b':2}
d2 = {'c':3,'d':4}
d1.update(d2)
d1 = {'a':1,'b':2,'c':3,'d':4} #重復key會被d2替換
del d[key] #刪除
####方法
popitem() #隨機刪除一個item元素（一般刪除最后一個）返回兩個元素的元組，被刪除的那個
pop(key[,default]) #刪除指定的，返回刪除的值
#寫上默認值沒有不報錯，返回默認值
clear() #清空
copy() #對字典進行淺復制 只復制值，不會進行智能級聯復制
遍歷字典：方法
keys() :
for k in d.keys() :
d[k]
values() :
for v in d.values() :
v
items() :
for k.v in d.items() :
k v
?
集合（set） { }
存儲不可變對象 無序 不重復
s = {1,2,34,4}
s = set() #空集合
s = { } #空字典
s = set(序列或者字典) #轉換為集合
s = set(字典) #保留的集合體是鍵
in not in
'a' in s
len(s)
add() #集合中添加
s.add(10)
update() #講一個集合中的所有元素添加到集合中
s.update(s2) #s2可以是集合，序列，字典
pop()隨機刪除一個集合中的元素,并返回這個元素
s.pop()
result = s.pop()
remove() #刪除指定元素
s.remove(100)
clear() #清空
s.clear()
copy() #對集合進行淺復制
?
集合運算
s1={1,2,3,4,5}
s2={3,4,5,6,7}
& #交集
s3 = s1 & s2
| #并集
s3 = s1 | s2
- #差集
s3 = s1 - s2 # s3 = {`,2}
^ #異或集
s3 = s1 ^ s2 # s3 = {1,2,6,7}
<= #檢查一個集合是否為另一個集合的子集
a <= b # true a是b的子集，b是a的超集
< #檢查一個集合是否為另一個集合的真子集
a
>= > #檢查一個集合是否為另一個集合的超集
?
函數（function）
def 函數名（[形參1，形參2，....形參n]）:
代碼塊
調用函數 fn()
##函數的參數
在定義函數使，可以定義數量不等的形參，用‘，’隔開
def fn2(a,b):
a+b
def fn3(a,b=2) : # b=2 為默認值不傳參數不報錯，默認值生效
代碼塊
?
##調用時**
##位置參數一一對應
fn2(1,2)
##關鍵字參數
fn2(b=1,a=2)
##位置參數和關鍵字參數可以混合使用，，位置參數必須在關鍵字參數的前邊
eg:
print('hello',end=' ') #防止換行
?
實參類型可以為任意類型 ##Python 不檢查，所以Python函數中需要檢查參數類型
?
在定義函數時，可以在形參前加一個* ，這樣這個形參會獲取所有實參，并保存為元組，“參數裝包”
##不定長參數只能有一個，但可以配合其他參數
def fn(*a):
sum=0
for n in a :
sum+=n
print(sum)
?
def fn(a,b,*c):
?
所有帶* 的參數后的參數必須以關鍵字參數傳遞
def fn(a,b,*c，d,e):
fn(1,2,3,4,5,d=6,e=7)
?
def fn(*,a,b):
##表明該函數必須以關鍵字參數傳遞
!!## *形參必須以位置參數傳遞，不能接收關鍵字參數
## “**” 形參可以接收其他關鍵字參數，他會將這些參數保存到一個字典中，字典的key為參數名，value為參數值
## **形參只能有一個，并只能放在所有形參最后
?
實參
參數解包（拆包） * 序列解包
#fn(1,2,3)
# t=(1,2,3) #序列都可以，元組或列表
fn(*t)
傳遞參數時也可以在序列的參數前添加星號，這樣他會自動將序列中的元素依次作為參數傳遞
?
字典實參解包,用**解包
d={a:1,b:2,c:3}
fn(**d)
?
返回值
return :
return #100 or 變量
return None
return 結束函數
?
文檔字符串(doc str)
help() #Python的內置函數，可以查詢Python中函數用法
hellp(函數對象) #hellp(print)
--函數內部編寫函數說明
--文檔字符串，直接寫在函數第一行的字符串
def fn(a:int,b:bool,c:str='hello') ->str : # 參數后冒號只是描述作用，也能看成文檔字符串的一種;= 表示默認值 ； ->表示返回值
'''
doc str
'''
代碼塊
?
作用域（scope），命名空間(namespace)#變量存儲位置
每一個作用域都有一個自己的命名空間
命名空間實際上就是一個字典，是一個專門用來存儲變量的字典
locals() #用來獲取當前作用域的命名空間
#如果在全局作用域中調用locals()獲取全局命名空間
dict = locals()
scope = locals() #當前命名空間
scope['c'] = 1000 #向字典中添加key-value 相當于在全局變量中創建了一個變量
globals() #此函數可以在任意位置獲得全局命名空間
scope = globals() #全局命名空間
、
遞歸 1.基線條件問題分解的最小條件，此時不再遞歸，直接返回
2.遞歸條件 將問題繼續分解的條件
#基線條件，判斷n==1 不再循環
10！=10*9！
9！=9*8！
......
2！=2*1！
1！=1
def fn(n) :
#基線條件
if(n==1):
return 1
#遞歸條件
return n*fn(n-1)
?
def hui_wen(s):
#基線條件
if len(s) < 2 :
return True
elif s[0] != s[-1] :
return False
return hui_wen(s[1:-1])
?
Python中函數是一等對象
函數式編程
?
高階函數：接收一個或多個函數，將函數作為返回值返回
?
普通函數改變的返回值，得到返回值不影響原對象
?
【高階函數1：參數是函數】
def fn(fnc,lst):
new_ls = []
for n in lst :
if fnc(n) :
snew_ls.append(n)
return new_ls
?
內置函數
filter(function,iterable) #參數：1方法；2可迭代
#過濾器
#參數
# 1.函數，根據此函數過濾 。True 為通過元素，通過過濾
# 2.需要過濾的序列（可迭代）
#返回值
# 過濾后的新序列（可迭代）
?
匿名函數 lambda函數表達式(語法糖)
#語法
lambda 參數列表 : 返回值
實例
1. def fn(a,b):
return a+b
2. lambda a,b : a+b
調用
(lambda a,b : a+b)(10,20)
3. fn = lambda a,b : a+b
調用
fn(10,20)
?
map()
map()函數可以對可跌倒對象中的所以元素做指定操作，然后將其添加到一個對象中返回
l = [1,2,3,4,5,6,7]
r = map(lambda i : i+1 , l) #i 為l中的元素
?
sort() #列表的方法
#該方法用來對列表中的元素進行排序，影響原對象
#sort()方法默認是直接比較列表中的元素的大小
#在sort()可以接收一個關鍵字參數，key
# key需要一個函數作為參數，當設置了函數作為參數
# 每次都會以列表中的一個元素作為參數來調用函數，并且使用函數返回值來比較元素大小
list.sort()
#是用“<”進行比較的
list.sort(key=len)
?
sorted() #與sort()使用方法一樣
#對任意序列都可以排序，返回新對象
?
【高階函數2】
返回值是函數
#閉包
def fn():
#函數內部定義一個函數
def inner():
print('晚上好')
return inner
fn()()
?
通過閉包可以創建只有當前函數可以訪問的變量
?
# sum(list)/len(list) 求平均值
?
def make_averager():
#創建一個列表，用來保存數值
nums= [ ]
#創建一個函數，用來計算平均值
def averager(n) :
#將n添加到列表中 #nums=[] 不能放這里是因為重新new了，會為空
nums.append(n)
#求平均值
return sum(nums)/len(nums)
return averager
?
#閉包的形成->數據安全，隱藏外部變量
1.有函數嵌套
2.將內部函數作為返回值返回
3.內部函數必須要使用到外部函數的變量
?
裝飾器
#OCP原則 開放對程序擴展，要關閉對程序的修改
###? 運用了閉包
-----------------------------------------------------------------------
def fn(old):
...
用來對其他函數進行擴展
...
def new_fn(*args , **kwargs): #對位置參數和關鍵字參數進行裝包
xxxxxx #擴展代碼
result = old(*args , **kwargs) #對位置參數和關鍵字參數進行解包
xxxxxx #擴展代碼
return resukt
#返回新函數
return new_function
----------------------------------------------------------------------
調用
f= fn(fn1)
r=fn(fn2)
?
真實場景:
創建裝飾器函數begin_end
使用
@begin_end #注解方式添加裝飾器
def say_helllo():
print('大家好')
調用
say_hello()
#可以多個裝飾同時使用
@begin_end #注解方式添加裝飾器
@fn
def say_helllo():
print('大家好')
say_hello() #內裝飾器先起作用，fn先起作用
?
面向過程，符合人類思想；函數式編程，復用性提高；面向對象，對象自己自己完成
?
?
##類class
#類的定義
構成：1數據（屬性【一般保存到實例中】）2行為（方法【一般保存到類中】）
#語法 class 類名([父類])：
代碼塊
公共的屬性。。
#對象初始方法
def __init__(self,....):
...
#其他方法
def method_1(self,....):
....
def method_2(self,....):
....
.........
class MyClass():
name='' #公共屬性 相當于java中static類型，只有實例沒有時，默認查找
def fn(self): #公共函數，類中的函數必須有一個形參
print(1) #函數無法訪問類中的變量
print(MyClass)
#類方法（在類內部使用@classmethod來修飾的方法屬于類方法）
@classmethod
class MyClass():
name='' #公共屬性 相當于java中static類型，只有實例沒有時，默認查找
@classmethod
def fn(cls): #類方法，也必須有一個形參cls,cls代表類對象
print(1) #函數無法訪問類中的變量
print(MyClass)
#創建對象
mc = MyClass() #創建對象不像java一樣需要new
# isinstance(object,Class) 函數檢查一個對象是否為一個類 的實例
對象.屬性= 值；
mc.myFunction() #調用類中方法時自動傳一個參數(對象本身,和java中的this有點像)
#方法每次調用時第一個參數，默認為self
?
#類中可以創建一些特殊方法（魔術方法）
#特殊方法以__開頭，以__結尾
#特殊方法不需要 我們自己調用,會自動調用
class Person :
def __init__(self):
print('a')
pass
def say_hello(self):
pass
?
p1=Person()
p1.say_hello()
?
對象創建流程
自上而下執行代碼，先執行類中代碼塊
1創建一個變量
2在內存中創建一個對象
3_init_(self)方法執行
4將對象id賦值給變量
?
#可以為class中對象的屬性定義時使用雙下劃線，__xxxx
#雙下劃線開頭的屬性，是對象的隱藏屬性，隱藏屬性只能類內部訪問，不能通過對象訪問（!=java中的private） __屬性名 -> _類名_屬性名
?
一般類中的私有屬性用“下劃線”+屬性
?
get set 方法屬性話
添加"屬性"裝飾器
get方法裝飾器方法上邊添加
@property
set方法裝飾器
@屬性名.setter
_# get方法先設計，才能設計setter方法
?
繼承
Class 類名（[父類]）:
pass
isinstance(d,Object) #判斷d是否為object的實例
issubclass(a,b) #判斷a是否為b的子類
#類名.__bases__ 獲得當前類的父類
##Python是多繼承的（java是單繼承的）
類名(父類,父類):
pass
#多個父類中有同名方法，先在第一個父類中找
?
多態
?
len()是因為對象中有特殊方法__len__()
?
類的屬性和方法
#靜態方法
@staticmethod
def fn():
pass #類中靜態方法無參數
?
垃圾回收
自動垃圾回收機制（和java挺像的嘛，哈哈）
#del是一個特殊方法，他會在對象被垃圾回收前自動調用,回收的是類對象
def __del__(self):
pass
?
#特殊方法，魔術方法
雙下劃線開頭結尾
一般不需要我們手動調用，一般在特殊情況下自動調用
__str__() ：對象被打印時調用
__repr__() :在對對象使用repr（）函數時調用，是在交互模式下自動調用，即在命令窗口a回車，輸出a的值時調用
object.__lt__(self, other) <
object.__le__(self, other) <=
object.__eq__(self, other) =
object.__ne__(self, other) !=
object.__gt__(self, other) >
object.__ge__(self, other) >=
#判斷大小
__len__() #獲得長度
__bool__() #boolean 裝換規則
object.__add__(self, other)
object.__sub__(self, other)
object.__mul__(self, other)
object.__matmul__(self, other)
object.__truediv__(self, other)
object.__floordiv__(self, other)
object.__mod__(self, other)
object.__divmod__(self, other)
object.__pow__(self, other[, modulo])
object.__lshift__(self, other)
object.__rshift__(self, other)
object.__and__(self, other)
object.__xor__(self, other)
object.__or__(self, other)
.....................
#運算特殊方法
?
模塊化
#一個Python文件就是一個模塊
#在一個模塊中引入外部模塊
1.import 模塊名（Python文件名，不帶后綴）
module為單實例
2..import 模塊名 as 模塊別名
import 可以在程序的任意位置調用，一般在開頭
每個模塊內部都有一個__name__屬性。通個這個屬性可以獲得模塊的名字
__name__為__main__的是主模塊
#調用
模塊名.變量名
3.只引入模塊的部分內容
#語法
from 模塊名 import 變量，變量，....
from 模塊名 import 變量 as 變量別名
#調用
變量名
from 模塊名 import *
#### 模塊中 _變量 是隱藏變量，用from 模塊名 import *不起作用
?
#測試代碼
#只有單前代碼為主模塊時執行
if __name__ == '__main__' :
pass
?
包 package
import 包名
#包中必須有一個__init__.py 文件，其中有包中的主要文件
from 包名 import 文件名/模塊名
?
#__pycache__是模塊緩存文件
#py代碼在執行時會轉換為機器碼，所以我們在使用模塊時，也需要將模塊代碼轉換為機器碼，Python在編譯一次后會放入緩存文件中
?
Python標準庫
核心思想：開箱
sys模塊，Python系統參數變量，操作解析器
import sys
1.sys..argv 獲得解釋器參數列表
print（sys..argv）
2.sys.modules 獲得當前進程引入的所有模塊（字典）
print（sys..modules ）
#key 模塊名，value 模塊實例對象
3.sys.path 模塊搜索路徑的列表，即調用模塊的搜索順序
4.sys.platform 當前Python運行平臺即系統環境
5.sys.exit([str提示]) 函數用來退出程序
?
pprint 模塊 提供了pprint（）方法，該方法可以對打印的數據做簡單的格式化
pprint .pprint (數據)
?
os 模塊，對操作系統進行訪問
import os
1.os.environ 通過這個屬性可以獲得系統的環境變量
pprint .pprint (os.environ['path'])
2.os.system([str命令]) #執行系統自身的命令
3.listdir()
import os
from pprint import pprint
#os.listdir([path=''])獲取指定的目錄的目錄列表（默認為當前目錄'.'）
r=os.listdir()
pprint(r)
4.os.getcwd()#獲得當前所在目錄
5.os.chdir([path])#切換目錄
6.os.mkdir(path)#創建目錄
7.os.rmdir(path)#刪除目錄
8.open('aa.txt','w')#創建文件
9.os.remove('aa.txt')#刪除文件
10.os.rename('舊名字','新名字')#重命名或剪貼
os.rename('舊名字','新路徑名字')
?
##異常
try語句
try:
代碼塊(可能錯誤代碼)
except:
代碼塊（處理方式）
else:
代碼塊（沒錯誤時執行代碼，錯誤不執行）
?
異常的傳播---拋出異常
產生異常時，實際上是創建了一個異常對象
?
try語句
try:
代碼塊(可能錯誤代碼)
except NameError:
#如果except后邊不跟內容，捕獲所有異常
#如果except后邊跟一個異常類型，捕獲此類異常
代碼塊（處理方式）
except IndexError:
代碼塊
except [Exception]:
代碼塊
else:
代碼塊（沒錯誤時執行代碼，錯誤不執行）
?
?
try:
代碼塊(可能錯誤代碼)
except Exception as e :
代碼塊（處理方式）
else:
代碼塊（沒錯誤時執行代碼，錯誤不執行）
finally :
代碼塊
?
try必須有，except 和 finally必須有一個
?
?
#拋出異常
raise
raise 語句后需要跟一個異常類或者異常的實例
if(a<0):
raise Exception('a為負數') #強行拋出異常
?
自定義異常類，創建類繼承Exception
class MyException(Exception):
pass
?
文件(File)
1.打開文件
open()
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
默認是以文本模式打開(文本模式，二進制模式)
文本文件： encoding='utf-8'
操作模式：mode='r' # mode='w' 時，沒有文件會創建，存在會截斷； # mode='a' 追加內容，沒有文件會創建，存在會追加內容 ；# + 追加操作，mode='r+',即可讀又可寫，mode='w+',即可寫又可讀，mode='a+',即可追加又可讀； mode='x' 新建文件，如果文件存在報錯，不存在創建，并可寫入（可避免覆蓋已有的）；t 默認情況下，文本文件；b 二進制文件，mode='rb';
參數：file文件路徑
file_object = open(路徑) #返回文件對象
2.操作
content = file_object.read() #讀取所有內容
@1 讀取
#help(file_object.read)
#file_object.read(-1)
#file_object.read(count) #讀取指定數量的內容, i
try:
with open(file_name,encoding='utf-8') as file_object :
file_count=''
chunk = 100
while True:
content = file_object.read(chunk ) #讀取所有內容
print(content,end='' )
if not content :
break
file_count +=content
except FileNotFoundError:
代碼塊（處理方式）
?
# readline() 讀一行
# readlines() 以列表形式保存
try:
with open(file_name,encoding='utf-8') as file_object :
for file_count in file_object :
print(file_count )
file_count +=file_count
except FileNotFoundError:
代碼塊（處理方式）
?
@2 寫 write()
with open(file_name,mode='w',encoding='utf-8') as file_object :
# open(file_name,'w',encoding='utf-8')
#指定操作類型w
#write文本型直接write(str)
file_object.write('hello')
file_object.write('hello\n')
r=file_object.write(str(123)) #可以分段寫入，只能寫入字符串,每次寫入會返回寫入的長度
?
#舊文件
file_name=''
with open(file_name,mode='rb') as file_object :
#二進制不要encoding
#新文件
new_name = '';
with open(file_name,mode='wb') as new_object :
#每次讀取大小
chunk = 1024*100
while True :
#從舊文件讀取
content = file_object.read(chunk)
#內容讀取完畢終止
if not content :
break
#將讀取到的寫入新文件
new_object.write(content )
?
@3 讀取位置
tell()查看當前讀取位置
seek() 修改當前讀取位置
#seek()需要兩個參數，1要切換的位置；2計算位置方式（0,1,2）
#0表示從頭計算（默認值）；1表示從當前已讀位置計算；2表示從最后位置接著讀，用-1倒數
with open(file_name,mode='rb') as file_object :
print(file_object.read(100),end='' )
print('當前讀取到了',file_object.tell())
file_object.seek(55,0)
?
3.保存
4.關閉
file_object.close()
?
#with ... as 語句
with open(file_name) as file_object :
#file_object 存活時間只是在with 。。。 as 的代碼塊中，等于自動關閉
print(file_object .read())
?
#
try:
with open(file_name) as file_object :
print(file_object .read())
except FileNotFoundError:
代碼塊（處理方式）
else:
代碼塊（沒錯誤時執行代碼，錯誤不執行）
?
文件的其他操作
os
更多文章、技術交流、商務合作、聯系博主
微信掃碼或搜索：z360901061
微信掃一掃加我為好友
QQ號聯系： 360901061
您的支持是博主寫作最大的動力，如果您喜歡我的文章，感覺我的文章對您有幫助，請用微信掃描下面二維碼支持博主2元、5元、10元、20元等您想捐的金額吧，狠狠點擊下面給點支持吧，站長非常感激您！手機微信長按不能支付解決辦法：請將微信支付二維碼保存到相冊，切換到微信，然后點擊微信右上角掃一掃功能，選擇支付二維碼完成支付。
【本文對您有幫助就好】元
