Python基礎語法
- python技術鏈接
-
Python編程基礎
-
Python簡介
Python語言由Guido van Rossum於1989年末開始設計，並於1991年公開發行。html
Python崇尚優美、清晰、簡單，是一個優秀並普遍使用的語言。python
Python目前有兩個版本，Python2和Python3，最新版分別爲2.7和3.6，現階段大部分公司用的是Python2。linux
Life is shot, you need Python. 人生苦短，我用Python。git
Python特色 github
簡單/易學web
免費、開源sql
跨平臺/可移植性shell
面向對象數據庫
可擴展性編程
豐富的庫
Python的應用
人工智能/科學計算
雲計算/自動化運維
Web應用開發/數據挖掘
桌面軟件/遊戲
-
Python安裝
安裝python3.6可能使用的依賴
yum -y install openssl-devel bzip2-devel expat-devel gdbm-devel readline-devel sqlite-devel
導入python3.6
./configure --prefix=/usr/local/
make
make altinstall
python3.6程序的執行文件：/usr/local/bin/python3.6
python3.6應用程序目錄：/usr/local/lib/python3.6
pip3的執行文件：/usr/local/bin/pip3.6
pyenv3的執行文件：/usr/local/bin/pyenv-3.6
--------------------------------------------------------------
替換python2爲python3.6
更改/usr/bin/python連接（儘可能不用，容易出問題）
# cd/usr/bin
# mv python python.backup
# ln -s /usr/local/bin/python3.6 /usr/bin/python
# ln -s /usr/local/bin/python3.6 /usr/bin/python3
#rm -rf /usr/bin/python2
#ln -s /usr/bin/python2.6 /usr/bin/python2
更改yum腳本的python依賴
# cd /usr/bin
# ls yum*
yum yum-config-manager yum-debug-restore yum-groups-manager
yum-builddep yum-debug-dump yumdownloader
更改以上文件頭爲
#!/usr/bin/python 改成 #!/usr/bin/python2
Linux系統自帶python，注意版本，安裝python3。
開發工具：vim Sublime
-
Python編程入門
第一個python程序
vim hello.py
#!/usr/bin/python
print("Hello World")
運行方式：./hello.py或python hello.py
註釋
單行註釋：#
多行註釋：'''註釋內容''' 或 """註釋內容"""
中文支持
#coding=utf-8
標準寫法：# -*- coding:utf-8 -*-
變量
num1 = 10
num2 = 20
result = num1 + num2
type(變量) #變量的類型肯定
變量的類型
Numbers（數字）
分爲 int(整數)、float（浮點）、bool（布爾）、complex（複數x+2y）
String（字符串）
Tuple（元組）
Sets（集合）
Dictionary（字典）
Number能夠具體
布爾類型
在python2中當時是沒有布爾類型的 使用 0 或者1表示
在python3中新增了True和False的關鍵字，可是依然使用數字存儲
布爾類型只有2個值：True和False
命名規則
駝峯式命名規則
單駝峯式命名法：例如：myName、logFile
雙駝峯式命名法：例如：LogFile、AccessLog
關鍵字
python已經使用的，因此不容許開發者本身定義和關鍵字相同的名字的標示符
查看關鍵字:
and as assert break class continue def del
elif else except exec finally for from global
if in import is lambda not or pass
print raise return try while with yield
>>> keyword.kwlist #查看關鍵字
輸出
print('hello world') #輸出變量hello world
vim print.py
age = 11
print("個人姓名是%s,年齡是%d"%(name,age))
#格式化輸出%s字符串，%d整數，必須空4格
輸入
pw = raw_input("please input password:")
print "password:%s"%pw
raw_input()的小括號中放入的是，提示信息，用來在獲取數據以前給用戶的一個提示
raw_input()在從鍵盤獲取數據之後，會存放到等號左邊的變量中
raw_input()會把用戶輸入的任何值都做爲字符串來對待
pw = input("please input password:")
print ("password:%s"%pw)
Python3沒有raw_input()函數，只有input()
print函數 python2 中能夠沒有（） python3中須要添加（）
-
運算符
算術運算符
賦值運算符
複合賦值運算符
數據類型轉換
函數 說明
a = '100' # 此時a的類型是一個字符串，裏面存放了100這3個字符
b = int(a) # 此時b的類型是整型，裏面存放的是數字100
#適合用於腳本運算
比較/關係運算符
邏輯運算符
-
判斷語句和循環語句
if-else
實例if1.py
fileLog = 1
if fileLog == 1: #若是字符串判斷，須要加""號
print("存在，能夠寫入")
else:
print("不存在，不能寫入記錄，請創建文件")
elif
實例if2.py
score = 85
if score>=90 and score<=100:
print('本次考試，等級爲A')
elif score>=80 and score<90:
print('本次考試，等級爲B')
elif score>=70 and score<80:
print('本次考試，等級爲C')
elif score>=60 and score<70:
print('本次考試，等級爲D')
while循環
實例while1.py： #while必需要有條件變量
i = 0
while i<5:
print("當前是第%d次執行循環"%(i+1))
print("i=%d"%i)
i+=1
for循環
實例for1.py
name = 'lampBrother'
for x in name:
print(x)
------------------
name = 'lampBrother'
for x in name:
print(x)
else:
print("沒有數據")
break
例1：
name = 'lampBrother'
for x in name:
print('----')
if x == 'm':
break
print(x)
例2：
i = 0
while i<10:
i = i+1
print('----')
if i==5:
break
print(i)
continue
例1：
name = 'lampBrother'
for x in name:
print('----')
if x == 'm':
continue
print(x)
例2：
i = 0
while i<10:
i = i+1
print('----')
if i==5:
continue
print(i)
-
字符串（string）
雙引號或者單引號中的數據，就是字符串
注意：input獲取的數據，都以字符串的方式進行保存，即便輸入的是數字
下標
所謂"下標"，就是編號
列表與元組支持下標索引，字符串實際上就是字符的數組，因此也支持下標索引
切片
切片是指對操做的對象截取其中一部分的操做
切片的語法：[起始:結束:步長]
注意：選取的區間屬於左閉右開型，即從"起始"位開始，到"結束"位的前一位結束（不包含結束位自己)。
若是取出一部分，則能夠在中括號[]中，使用:
name = 'abcdef'
print(name[0:3]) #取下標0~2 的字符
name = 'abc'
print(name[3:5]) #取下標爲三、4 的字符
name = 'de'
print(name[2:]) #取下標爲2開始到最後的字符
name = 'cdef'
str = "abcdef"
str[::2] #步長2，2個元素爲一組，輸出每組第一個字符
'ace'
str[1:5:2]
'bd'
str[::-2] #2個一組，倒序輸出
'fdb'
字符串常見函數
<1>find
檢測 str 是否包含在 mystr中，若是是返回開始的索引值，不然返回-1
mystr.find(str)
mystr.find(str, start=0, end=len(mystr))
<2>index
跟find()方法同樣，只不過若是str不在 mystr中會報一個異常
mystr.index(str)
mystr.index(str, start=0, end=len(mystr))
<3>count
返回 str在start和end之間 在 mystr裏面出現的次數
mystr.count (str)
mystr.count(str, start=0, end=len(mystr))
<4>replace
把 mystr 中的 str1 替換成 str2,若是 count 指定，則替換不超過 count 次
mystr.replace(str1, str2)
mystr.replace(str1, str2, mystr.count(str1))
<5>split
以 str 爲分隔符切片 mystr，若是 maxsplit有指定值，則僅分隔 maxsplit 個子字符串
mystr.split(str=" ", 2)
<6>capitalize
把字符串的第一個字符大寫
mystr.capitalize()
<7>title
把字符串的每一個單詞首字母大寫
>>> a = "hello lamp"
>>> a.title()
'Hello Lamp'
<8>startswith
檢查字符串是不是以 obj 開頭, 是則返回 True，不然返回 False
mystr.startswith(obj)
<9>endswith
檢查字符串是否以obj結束，若是是返回True,不然返回 False.
mystr.endswith(obj)
<10>lower
轉換 mystr 中全部大寫字符爲小寫
mystr.lower()
<11>upper
轉換 mystr 中的小寫字母爲大寫
mystr.upper()
<12>ljust
返回一個原字符串左對齊,並使用空格填充至長度 width 的新字符串
mystr.ljust(width)
<13>rjust
返回一個原字符串右對齊,並使用空格填充至長度 width 的新字符串
mystr.rjust(width)
<14>center
返回一個原字符串居中,並使用空格填充至長度 width 的新字符串
mystr.center(width)
<15>lstrip
刪除 mystr 左邊的空白字符
mystr.lstrip()
<16>rstrip
刪除 mystr 字符串末尾的空白字符
mystr.rstrip()
<17>strip
刪除mystr字符串兩端的空白字符
>>> a = "\n\t lamp \t\n"
>>> a.strip()
'lamp'
<18>rfind
相似於 find()函數，不過是從右邊開始查找.
mystr.rfind(str, start=0,end=len(mystr) )
<19>rindex
相似於 index()，不過是從右邊開始.
mystr.rindex( str, start=0,end=len(mystr))
<20>partition
把mystr以str分割成三部分,str前，str和str後
mystr.partition(str)
<21>rpartition
相似於 partition()函數,不過是從右邊開始.
mystr.rpartition(str)
<22>splitlines
按照行分隔，返回一個包含各行做爲元素的列表
mystr.splitlines()
<23>isalpha
若是 mystr 全部字符都是字母 則返回 True,不然返回 False
mystr.isalpha()
<24>isdigit
若是 mystr 只包含數字則返回 True 不然返回 False.
mystr.isdigit()
<25>isalnum
若是 mystr 全部字符都是字母或數字則返回 True,不然返回 False
mystr.isalnum()
<26>isspace
若是 mystr 中只包含空格，則返回 True，不然返回 False.
mystr.isspace()
<27>join
mystr 中每一個字符後面插入str,構造出一個新的字符串
mystr.join(str)
-
列表list
列表的格式
namesList = ['xiaoZhang','xiaoLi','xiaoWang']
print(namesList[0])
print(namesList[1])
print(namesList[2])
列表的循環遍歷輸出
例1：
namesList = ['xiaoZhang','xiaoLi,'xiaoWang']
for name in namesList:
print(name)
例2：
namesList = ['xiaoZhang','xiaoLi,'xiaoWang']
length = len(namesList)
i = 0
while i<length:
print(namesList[i])
i+=1
添加元素("增"append, extend, insert)
append
實例
A = ['xiaoWang','xiaoZhang','xiaoHua']
temp = input('請輸入要添加的學生姓名:')
A.append(temp)
for tempName in A:
print(tempName)
extend
經過extend能夠將另外一個集合中的元素逐一添加到列表中
>>> a = [1, 2]
>>> b = [3, 4]
>>> a.append(b)
>>> a
[1, 2, [3, 4]]
>>> a.extend(b)
>>> a
[1, 2, [3, 4], 3, 4]
insert
insert(index, object) 在指定位置index前插入元素object
>>> a = [0, 1, 2]
>>> a.insert(1, 3)
>>> a
[0, 3, 1, 2]
修改元素("改")
修改元素的時候，要經過下標來肯定要修改的是哪一個元素，而後才能進行修改
A = ['xiaoWang','xiaoZhang','xiaoHua']
A[1] = 'xiaoxiao' #修改元素
查找元素("查"in, not in, index, count)
in（存在）,若是存在那麼結果爲true，不然爲false
not in（不存在），若是不存在那麼結果爲true，不然false
實例:
nameList = ['xiaoWang','xiaoZhang','xiaoHua']
findName = input('請輸入要查找的姓名:')
if findName in nameList:
print('在字典中找到了相同的名字')
else:
print('沒有找到')
刪除元素("刪"del, pop, remove)
del：根據下標進行刪除
pop：刪除最後一個元素
remove：根據元素的值進行刪除
實例 (del)
movieName = ['戰狼1','戰狼2','速8','孫悟空','星球大戰','異星覺醒']
del movieName[2]
print('------刪除以後------')
for tempName in movieName:
print(tempName)
實例(pop)
movieName = ['戰狼1','戰狼2','速8','孫悟空','星球大戰','異星覺醒']
movieName.pop()
print('------刪除以後------')
for tempName in movieName:
print(tempName)
實例:(remove)
movieName = ['戰狼1','戰狼2','速8','孫悟空','星球大戰','異星覺醒']
movieName.remove('星球大戰')
print('------刪除以後------')
for tempName in movieName:
print(tempName)
排序(sort, reverse)
sort方法是將list按特定順序從新排列，默認爲由小到大，參數reverse=True可改成倒序
reverse方法是將list逆置。
>>> a = [1, 4, 2, 3]
>>> a
[1, 4, 2, 3]
>>> a.reverse()
>>> a
[3, 2, 4, 1]
>>> a.sort()
>>> a
[1, 2, 3, 4]
>>> a.sort(reverse=True)
>>> a
[4, 3, 2, 1]
-
元組tuple
Python的元組與列表相似，不一樣之處在於元組的元素不能修改。元組使用小括號，列表使用方括號。
>>> Tuple = ('xiaoming',177,79)
>>> Tuple
('xiaoming',177,79)
<1>訪問元組
Tuple[1]
<2>修改元組 （不容許）
注意： python中不容許修改元組的數據，包括不能刪除其中的元素。
-
字典dict
info = {'name':'超哥', 'id':100, 'sex':'f', 'address':'回龍觀'}
注意：
字典和列表同樣，也可以存儲多個數據
列表中找某個元素時，是根據下標進行的
字典中找某個元素時，是根據'名字'（就是冒號:前面的那個值，例如上面代碼中的'name'、'id'、'sex'）
字典的每一個元素由2部分組成，鍵:值。例如 'name':'超哥' ,'name'爲鍵，'超哥'爲值
根據鍵訪問值
info = {'name':'超哥', 'id':100, 'sex':'f', 'address':'回龍觀'}
print(info['name'])
print(info['address'])
結果:
超哥
回龍觀
修改元素
字典的每一個元素中的數據是能夠修改的，只要經過key找到，便可修改
實例
info = {'name':'超哥', 'id':100, 'sex':'f', 'address':'回龍觀'}
newId = input('請輸入新的學號')
info['id'] = int(newId)
print('修改以後的id爲%d:'%info['id'])
添加元素
若是在使用 變量名['鍵'] = 數據 時，這個"鍵"在字典中，不存在，那麼就會新增這個元素
實例
info = {'name':'超哥', 'sex':'f', 'address':'回龍觀'}
newId = input('請輸入新的學號:')
info['id'] = int(newId)
print('添加以後的id爲:%d'%info['id'])
刪除元素(del, clear())
del
info = {'name':'超哥', 'sex':'f', 'address':'回龍觀'}
print('刪除前,%s'%info['name'])
del info['name']
print('刪除後,%s'%info['name'])
實例del1.py:del刪除整個字典 報錯！！！
info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('刪除前,%s'%info)
del info
print('刪除後,%s'%info)
clear
info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('清空前,%s'%info)
info.clear()
print('清空後,%s'%info)
字典經常使用操做
info = {'name':'超哥', 'id':100, 'sex':'f', 'address':'回龍觀'}
<1>len()
測量字典中，鍵值對的個數
>>>len(info)
<2>keys
返回一個包含字典全部KEY的列表
>>> info.keys()
<3>values
返回一個包含字典全部value的列表
>>> info.values()
<4>items
返回一個包含全部（鍵，值）元祖的列表
>>> info.items()
-
函數
函數格式
def 函數名():
代碼
# 定義一個函數，可以完成打印信息的功能
def printInfo():
print '------------------------------------'
print ' Hello Python'
print '------------------------------------'
調用函數
調用函數很簡單的，經過 函數名() 便可完成調用
printInfo()
函數參數
形參：定義時小括號中的參數，用來接收參數用的，稱爲 "形參"
實參：調用時小括號中的參數，用來傳遞給函數用的，稱爲 "實參"
例1：
def add2num():
a = 11
b = 22
c = a+b
print (c)
add2num()
例2：
def add2num(a, b):
c = a+b
print (c)
調用帶有參數的函數 注意程序執行過程
add2num(22,33)
a=input("輸入數字:")
a1=int(a)
b=input("輸入數字:")
b1=int(b)
add2num(a1,b1)
函數返回值
return返回值，就是程序中函數完成一件事情後，最後給調用者的結果
例1：
def add2num(a, b):
c = a+b
return c
例2：
def add2num(a, b):
return a+b
result = add2num(10,20)
print result
函數的分類
函數根據有沒有參數，有沒有返回值，能夠相互組合，一共有4種
無參數，無返回值
無參數，有返回值
有參數，無返回值
有參數，有返回值
無參數，無返回值的函數
此類函數，不能接收參數，也沒有返回值，打印提示等相似的功能，使用這類的函數
例：
def printMenu():
print('--------------------------')
print(' 請輸入大寫字母')
print('')
print(' 1. INSTALL')
print(' 2. REMOVE')
print(' 3. 完成請退出')
print('--------------------------')
無參數，有返回值的函數
不能接收參數，可是能夠返回某個數據，通常狀況下，採集數據，用此類函數
def getTemperature():
#獲取溫度的一些處理過程
#模擬返回一個數據
return 37
temperature = getTemperature()
print('當前的溫度爲:%d'%temperature)
有參數，無返回值的函數
能接收參數，但不能夠返回數據，通常狀況下，對某些變量設置數據而不需結果時，用此類函數
有參數，有返回值的函數
能接收參數，但不能夠返回數據，通常狀況下，對某些變量設置數據而不需結果時，用此類函數
def calculateNum(num): #計算1~num的累積和
result = 0
i = 1
while i<=num:
result = result + i
i+=1
return result
result = calculateNum(100)
print('1~100的累積和爲:%d'%result)
函數的嵌套調用
例1：
def testB():
print('---- testB start----')
print('這裏是testB函數執行的代碼...(省略)...')
print('---- testB end----')
def testA():
print('---- testA start----')
testB()
print('---- testA end----')
testA()
例2：
def sum3Number(a,b,c): #求3個數的和
return a+b+c # return 的後面能夠是數值，也但是一個表達式
def average3Number(a,b,c): #完成對3個數求平均值
# 由於sum3Number函數已經完成了3個數的就和，因此只需調用便可
# 即把接收到的3個數，當作實參傳遞便可
sumResult = sum3Number(a,b,c)
aveResult = sumResult/3
return aveResult
result = average3Number(30,20,100) #調用函數，完成對3個數求平均值
print("average is %d"%result)
變量在函數中的分類
局部變量
局部變量，就是在函數內部定義的變量
不一樣的函數，能夠定義相同的名字的局部變量，可是各用個的不會產生影響
做用：爲臨時保存數據，須要在函數中定義變量，進行存儲
全局變量
若是一個變量，既能在一個函數中使用，也能在其餘的函數中使用，這樣的變量就是全局變量
在函數外邊定義的變量叫作全局變量
全局變量可以在全部的函數中進行訪問
若是在函數中修改全局變量，那麼就須要使用global進行聲明，不然出錯
若是全局變量的名字和局部變量的名字相同，那麼使用的是局部變量(做用域)
遞歸函數
自我調用的函數。
一個函數能夠調用其餘函數。
若是一個函數在內部不調用其它的函數，而是調用本身自己，這個函數就是遞歸函數。
例：
def getNums(num):
if num>1:
return num * getNums(num-1) #不斷調用函數，直到num小於1
else:
return num
result = getNums(10)
print(result)
匿名函數
用lambda關鍵詞能建立小型匿名函數。
省略用def聲明函數的標準步驟。
Lambda函數能接收任何數量的參數但只能返回一個表達式的值
匿名函數不能直接調用print，由於lambda須要一個表達式
例：
sum = lambda arg1, arg2: arg1 + arg2
#調用sum函數
print ("Value of total : ", sum( 10, 20 ))
print ("Value of total : ", sum( 20, 20 ))
匿名函數的應用
例1：
>>> def fun(a, b, opt):
... print ("a =", a)
... print ("b =", b)
... print ("result =", opt(a, b))
...
>>> fun(1, 2, lambda x,y:x+y) #函數做爲參數傳遞
a = 1
b = 2
result = 3
例2：
做爲內置函數的參數
stus = [
{"name":"zhangsan", "age":18},
{"name":"lisi", "age":19},
{"name":"wangwu", "age":17}
]
按name排序：
>>> stus.sort(key = lambda x:x['name'])
>>> stus
[{'name': 'lisi', 'age': 19}, {'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}]
按age排序：
>>> stus.sort(key = lambda x:x['age'])
>>> stus
[{'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}, {'name': 'lisi', 'age': 19}]
-
文件操做
打開文件
使用open函數，打開一個已經存在的文件，或者建立一個新文件
open(文件名，訪問模式)
f = open('test.txt', 'w')
關閉文件
close( )
# 新建一個文件，文件名爲:test.txt
f = open('test.txt', 'w')
# 關閉這個文件
f.close()
文件的讀寫操做
使用write()能夠完成向文件寫入數據，若是文件不存在那麼建立，若是存在那麼就先清空，而後寫入數據
f = open('test.txt', 'w')
f.write('hello python, very good!')
f.close()
讀數據(read)
使用read(num)能夠從文件中讀取數據，num表示要從文件中讀取的數據的長度（單位是字節），若是沒有傳入num，那麼就表示讀取文件中全部的數據
若是使用讀了屢次，那麼後面讀取的數據是從上次讀完後的位置開始的
例：
f = open('test.txt')
content = f.read(5)
print(content)
print("-"*20)
content = f.read()
print(content)
f.close()
讀數據（readlines）
readlines能夠按照行的方式把整個文件中的內容進行一次性讀取，而且返回的是一個列表，其中每一行的數據爲一個元素
例：
f = open('test.txt', 'r')
content = f.readlines()
print(type(content))
i=1
for temp in content:
print("%d:%s"%(i, temp))
i+=1
f.close()
讀數據（readline）
讀取1行，光標停在第二行
例：
f = open('test.txt', 'r')
content = f.readline()
print("1:%s"%content)
content = f.readline()
print("2:%s"%content)
content = f.readline()
print("3:%s"%content)
f.close()
文件操做應用
製做文件的備份
要求：輸入文件的名字，而後程序自動完成對文件進行備份
#coding=utf-8
oldFileName = input("請輸入要拷貝的文件名字:")
oldFile = open(oldFileName,'r')
#若是打開文件
if oldFile:
#提取文件的後綴
fileFlagNum = oldFileName.rfind('.')
if fileFlagNum > 0:
fileFlag = oldFileName[fileFlagNum:]
#組織新的文件名字
newFileName = oldFileName[:fileFlagNum] + '[bak]' + fileFlag
#建立新文件
newFile = open(newFileName, 'w')
#把舊文件中的數據，一行一行的進行復制到新文件中
for lineContent in oldFile.readlines():
newFile.write(lineContent)
oldFile.close()
newFile.close()
文件定位讀寫
獲取當前讀寫的位置
在讀寫文件的過程當中，若是想知道當前的位置，可使用tell()來獲取
f = open("test.txt", "r")
str = f.read(3)
print ("讀取的數據是 : ", str)
# 查找當前位置
position = f.tell()
print ("當前文件位置 : ", position)
str = f.read(3)
print ("讀取的數據是 : ", str)
# 查找當前位置
position = f.tell()
print ("當前文件位置 : ", position)
f.close()
定位到某個位置
若是在讀寫文件的過程當中，須要從另一個位置進行操做的話，可使用seek()
seek(offset, from)有2個參數
offset:偏移量
from:方向
0:表示文件開頭
1:表示當前位置
2:表示文件末尾
#把位置設置爲：從文件開頭，偏移5個字節
# 打開一個已經存在的文件
f = open("test.txt", "r")
str = f.read(30)
print ("讀取的數據是 : ", str)
# 查找當前位置
position = f.tell()
print ("當前文件位置 : ", position)
# 從新設置位置
f.seek(5,0)
# 查找當前位置
position = f.tell()
print ("當前文件位置 : ", position)
f.close()
文件重命名
在對文件進行重命名、刪除等操做，經過python的os模塊實現
rename(須要修改的文件名, 新的文件名)
import os
#os.rename("test.txt", "b.txt")
os.remove("b.txt")
刪除文件
os模塊中的remove()能夠完成對文件的刪除操做
remove(待刪除的文件名)
建立文件夾
若是要操做文件夾，一樣須要os模塊
import os
os.mkdir("ttt")
a = os.getcwd()
print (a)
os.chdir("../")
os.mkdir("aaaaaaaaa") #建立文件夾
os.mkdir("張三")
os.getcwd() #獲取當前目錄
os.chdir("../") #改變默認目錄
os.listdir("./") #獲取目錄列表
刪除文件夾
import os
os.rmdir("張三")
批量修改文件名
# 批量在文件名前加前綴
import os
funFlag = 2 # 1表示添加標誌 2表示刪除標誌
folderName = './renameDir/'
# 獲取指定路徑的全部文件名字
dirList = os.listdir(folderName)
# 遍歷輸出全部文件名字
for name in dirList:
print (name)
if funFlag == 1:
newName = '[python]-' + name
elif funFlag == 2:
num = len('[python]-')
newName = name[num:]
print (newName)
os.rename(folderName+name, folderName+newName)
-
面向對象編程
類
具備相同屬性和行爲事物的統稱。
類是抽象的,在使用的時候一般會找到這個類的一個具體的存在,使用這個具體的存在。一個類能夠找到多個對象。
對象
某一個具體事物的存在 ,在現實世界中能夠是看得見摸得着的；能夠是直接使用的。
區分類和對象
硬盤 類
固態硬盤 類
張三的硬盤 對象
文件 類
Shell文件 類
李四寫的shell文件 對象
汽車 類
寶馬汽車 類
王五的寶馬汽車 對象
類的構成
類(Class) 由3個部分構成
類的名稱:類名
類的屬性:一組數據
類的方法:容許對象進行操做的方法 (行爲)
定義類，格式：
class Car()
def getCarInfo(self):
print('車輪子個數:%d, 顏色%s'%(self.wheelNum, self.color))
def move(self):
print("車正在移動...")
定義類時有2種：
新式類和經典類，上面的Car爲經典類，若是是Car(object)則爲新式類
類名的命名規則按照"雙駝峯"
建立對象
class Car:
def move(self):
print('奔跑...')
def toot(self):
print("鳴笛...")
BMW = Car() #建立一個對象，並用變量BMW來保存它的引用
BMW.move()
BMW.toot()
總結：
BMW = Car()，這樣就產生了一個Car的實例對象，此時也能夠經過實例對象BMW來訪問屬性或者方法
第一次使用BMW.color = '黑色'表示給BMW這個對象添加屬性，若是後面再次出現BMW.color = xxx表示對屬性進行修改
BMW是一個對象，它擁有屬性（數據）和方法（函數）
當建立一個對象時，就是用一個模板，來製造一個實物
-
模塊
模塊引入
在Python中用關鍵字import來引入某個模塊.
>>>import os #引入一個模塊
>>>os.__file__
import module1,mudule2...
from 模塊名 import 函數名1,函數名2.... #引入模塊中的一個應用
模塊安裝
一.
1.找到模塊的壓縮包（官網下載）
2.解壓
3.進入文件夾
4.執行命令python setup.py install
（缺點 依賴關係複雜）
二.
網絡安裝：pip install 模塊名
Python實現服務器監控
/proc 文件系統
系統信息：從/proc/stat 中得到，其中包括 CPU 佔用狀況、磁盤空間、內存對換等。
CPU信息：利用/proc/cpuinfo 文件能夠得到cpu的信息。
負載信息：/proc/loadavg 文件包含系統負載信息。
系統內存信息：/proc/meminfo 文件包含系統內存的詳細信息，其中顯示物理內存的數量、可用交換空間的數量，以及空閒內存的數量等。
/proc 目錄中的主要文件的說明
文件或目錄名稱 描 述
cpuinfo 中央處理器信息
loadavg 系統平均負載均衡
meminfo 存儲器使用信息，包括物理內存和交換內存
net 網絡協議狀態信息
CPU監測獲取信息
實例：
from __future__ import print_function
from collections import OrderedDict
import pprint
def cpuinfo():
cpuinfo=OrderedDict()
procinfo=OrderedDict()
nprocs = 0
with open('/proc/cpuinfo') as f:
for line in f:
if not line.strip():
cpuinfo['proc%s' % nprocs] = procinfo
nprocs=nprocs+1
procinfo=OrderedDict()
else:
if len(line.split(':')) == 2:
procinfo[line.split(':')[0].strip()] = line.split(':')[1].strip()
else:
procinfo[line.split(':')[0].strip()] = ''
return cpuinfo
if __name__=='__main__':
cpuinfo = cpuinfo()
for processor in cpuinfo.keys():
print(cpuinfo[processor]['model name'])
監測系統負載
實例：
import os
def load_stat():
loadavg = {}
f = open("/proc/loadavg")
con = f.read().split()
f.close()
loadavg['lavg_1']=con[0]
loadavg['lavg_5']=con[1]
loadavg['lavg_15']=con[2]
loadavg['nr']=con[3]
loadavg['last_pid']=con[4]
return loadavg
print ("loadavg",load_stat()['lavg_15'])
print ("loadavg",load_stat()['lavg_1'])
print ("loadavg",load_stat()['lavg_5'])
獲取內存使用信息
實例：
from __future__ import print_function
from collections import OrderedDict
def meminfo():
''' /proc/meminfo '''
meminfo=OrderedDict()
with open('/proc/meminfo') as f:
for line in f:
meminfo[line.split(':')[0]] = line.split(':')[1].strip()
return meminfo
if __name__=='__main__':
print(meminfo())
meminfo = meminfo()
print('Total memory: {0}'.format(meminfo['MemTotal']))
print('Free memory: {0}'.format(meminfo['MemFree']))
網絡接口監測（流量監控）
實例：
import time
import sys
if len(sys.argv) > 1:
INTERFACE = sys.argv[1]
else:
INTERFACE = 'eth0'
STATS = []
print ('Interface:',INTERFACE)
def rx():
ifstat = open('/proc/net/dev').readlines()
for interface in ifstat:
if INTERFACE in interface:
stat = float(interface.split()[1])
STATS[0:] = [stat]
def tx():
ifstat = open('/proc/net/dev').readlines()
for interface in ifstat:
if INTERFACE in interface:
stat = float(interface.split()[9])
STATS[1:] = [stat]
print ('In Out')
rx()
tx()
while True:
time.sleep(1)
rxstat_o = list(STATS)
rx()
tx()
RX = float(STATS[0])
RX_O = rxstat_o[0]
TX = float(STATS[1])
TX_O = rxstat_o[1]
RX_RATE = round((RX - RX_O)/1024/1024,3)
TX_RATE = round((TX - TX_O)/1024/1024,3)
print (RX_RATE ,'MB ',TX_RATE ,'MB')
經常使用模塊說明
OrderedDict，實現了對字典對象中元素的排序。模塊collections，裏面自帶一個子類。
pprint模塊 提供打印出任何python數據結構類和方法。
__future__模塊，把下一個新版本的特性導入到當前版本，能夠在當前版本中測試一些新版本的特性
strip() 方法用於移除字符串頭尾指定的字符（默認爲空格）
split() 經過指定分隔符對字符串進行切片，若是參數num 有指定值，則僅分隔 num 個子字符串
python 中__name__ = '__main__' 的做用：
讓你寫的腳本模塊既能夠導入到別的模塊中用，另外該模塊本身也可執行。
sys.argv中[]是用來獲取命令行參數的，sys.argv中[0]表示代碼自己文件路徑，因此參數從1開始
os：該模塊提供了使用操做系統相關功能的便攜式方法,提供了一種方便的使用操做系統函數的方法。
sys：該模塊提供對解釋器使用或維護的一些變量以及與解釋器強烈交互的函數的訪問,這個模塊可供訪問由解釋器使用或維護的變量和與解釋器進行交互的函數。
os經常使用方法
os.remove（）刪除文件
os.rename（）重命名文件
os.walk（）生成目錄樹下的全部文件名
os.chdir（）改變目錄
os.mkdir / makedirs建立目錄/多層目錄
os.rmdir / removedirs刪除目錄/多層目錄
os.listdir（）列出指定目錄的文件
os.getcwd（）取得當前工做目錄
os.chmod（）改變目錄權限
os.path.basename（）去掉目錄路徑，返回文件名
os.path.dirname（）去掉文件名，返回目錄路徑
os.path.join（）將分離的各部分組合成一個路徑名
os.path.split（）返回（dirname（），basename（））元組
os.path.splitext（）返回（filename，extension）元組
os.path.getatime \ ctime \ mtime分別返回最近訪問，建立，修改時間
os.path.getsize（）返回文件大小
os.path.exists（）是否存在
os.path.isabs（）是否爲絕對路徑
os.path.isdir（）是否爲目錄
os.path.isfile（）是否爲文件
sys經常使用方法
sys.argv命令行參數列表，第一個元素是程序自己路徑
sys.modules.keys（）返回全部已經導入的模塊列表
sys.exc_info（）獲取當前正在處理的異常類，exc_type，exc_value，exc_traceback當前處理的異常詳細信息
sys.exit（n）退出程序，正常退出時exit（0）
sys.hexversion獲取Python解釋程序的版本值，16進制格式如：0x020403F0
sys.version獲取Python解釋程序的版本信息
sys.maxint最大的Int值
sys.maxunicode最大的Unicode值
sys.modules返回系統導入的模塊字段，key是模塊名，value是模塊
sys.path返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值
sys.platform返回操做系統平臺名稱
sys.stdout標準輸出
sys.stdin標準輸入
sys.stderr錯誤輸出
sys.exc_clear（）用來清除當前線程所出現的當前的或最近的錯誤信息
sys.exec_prefix返回平臺獨立的python文件安裝的位置
sys.byteorder本地字節規則的指示器，big-endian平臺的值是"big"，little-endian平臺的值是"little"
sys.copyright記錄python版權相關的東西
sys.api_version解釋器的C的API版本
OS模塊負責程序與操做系統的交互，提供了訪問操做系統底層的接口; SYS模塊負責程序與python解釋器的交互，提供了一系列的函數和變量，用於操控python的運行時環境。
time模塊中經常使用函數：
1）time.localtime([secs])：將一個時間戳轉換爲當前時區的struct_time。secs參數未提供，則以當前時間爲準。
>>> time.localtime()
2）time.gmtime([secs])：和localtime()方法相似，gmtime()方法是將一個時間戳轉換爲UTC時區（0時區）的struct_time。
>>>time.gmtime()
3）time.time()：返回當前時間的時間戳。
>>> time.time()
4）time.mktime(t)：將一個struct_time轉化爲時間戳。
>>> time.mktime(time.localtime())
5）time.sleep(secs)：線程推遲指定的時間運行。單位爲秒。
6）time.clock()：這個須要注意，在不一樣的系統上含義不一樣。在UNIX系統上，它返回的是"進程時間"，它是用秒錶示的浮點數（時間戳）。而在WINDOWS中，第一次調用，返回的是進程運行的實際時間。而第二次以後的調用是自第一次調用之後到如今的運行時間。（其實是以WIN32上QueryPerformanceCounter()爲基礎，它比毫秒錶示更爲精確）
7）time.asctime([t])：把一個表示時間的元組或者struct_time表示爲這種形式：'Sun Jun 20 23:21:05 1993'。若是沒有參數，將會將time.localtime()做爲參數傳入。
>>> time.asctime()
8）time.ctime([secs])：把一個時間戳（按秒計算的浮點數）轉化爲time.asctime()的形式。若是參數未給或者爲None的時候，將會默認time.time()爲參數。它的做用至關於time.asctime(time.localtime(secs))。
9）time.strftime(format[, t])：把一個表明時間的元組或者struct_time（如由time.localtime()和time.gmtime()返回）轉化爲格式化的時間字符串。若是t未指定，將傳入time.localtime()。若是元組中任何一個元素越界，ValueError的錯誤將會被拋出。
-
Ansible自動化運維
發展階段
傳統運維
命令行 批量腳本
特色：資源少機器少 幾臺機器 規模 數據量少 運維工做簡單
缺點：效率低 重複工做 沒法跨平臺 資源分散 無標準
自動化運維（把運維平常須要登陸機器的操做，徹底web化）
一組將靜態的設備結構轉化爲智能的根據IT服務需求動態彈性響應的策略，目的就是實現IT運維的質量，提升效率，下降成本。
優勢： 高效率 重複的工做由機器作
平臺化 任務自動執行 監控 日誌管理
標準化
流程化 業務流程 部署流程 代碼上線
自動化運維思想
管理體系化 管理機器 代碼 業務
工做流程化 標準
人員專業化 懂運維 懂編程 懂業務
任務自動化 環境定義自動化 部署自動化 監控自動化
現階段自動化運維缺點
數據沒法共享：A公司和B公司 沒法共享
沒法主動式發現(預測)問題
部署成本高
標準不統一
DevOps
DevOps（Development和Operations）一組過程、方法與系統的統稱，用於促進開發（應用程序/軟件工程）、技術運營和質量保障（QA）部門之間的溝通、協做與整合。它的出現是因爲軟件行業日益清晰地認識到：爲了按時交付軟件產品和服務，開發和運營工做必須緊密合做。
DevOps是開發（軟件工程）、技術運營和質量保障（QA）三者的組合。
自動化運維工具：
Ansible
Ansible自動化運維工具，基於Python開發，集合了衆多運維工具的優勢，實現了批量系統配置、批量程序部署、批量運行命令等功能。ansible是基於模塊工做的，自己沒有批量部署的能力。真正具備批量部署的是ansible所運行的模塊，ansible只是提供一種框架。
特色
(1) no agents：不須要在被管控主機上安裝任何客戶端；
(2) no server：無服務器端，使用時直接運行命令便可；
(3) modules in any languages：基於模塊工做，可以使用任意語言開發模塊；
(4) yaml，not code：使用yaml語言定製劇本playbook；
(5) ssh by default：基於SSH工做；
(6) strong multi-tier solution：可實現多級管理。
優點
(1) 輕量級，無需在客戶端安裝agent，更新時，只需在操做機上進行一次更新便可；
(2) 批量任務執行能夠寫成腳本，並且不用分發到遠程就能夠執行；
(3) 使用python編寫，維護更簡單；
(4) 支持sudo。
工做原理
CMDB(開發)
CMDB（Configuration Management Database），配置管理數據庫，是IT管理信息的重要工具和手段。開發CMDB主要採集硬件數據,API和頁面管理。
系統：硬件 軟件 服務管理 人員 業務 ......
收費CMDB
開源CMDB github 開源社區
資源
www.google.com
www.w3cschool.cnAnsible安裝配置與應用
安裝方式：1）pip 自動安裝 2）yum 自動安裝
1. pip 方式 （參考）
安裝python-pip 和 python-devel 程序包
yum -y install python-pip python-devel
安裝Ansible服務
yum -y install gcc glibc-devel zlib-devel rpm-build openssl-devel
pip install --upgrade pip
pip install ansible --upgrade
測試 ansible --version
2.yum 方式（網絡）（重點）
先安裝EPEL源後可找到並安裝Ansible
rpm -Uvh https://dl.fedoraproject.org/pub/epel/epel-release-latest-6.noarch.rpm
yum -y install ansible
測試 ansible --version
Ansible配置
1.配置文件目錄
/etc/ansible/
兩個核心文件：ansible.cfg和hosts文件,默認都存放在/etc/ansible目錄下。
ansible.cfg：主要設置ansible初始化信息，好比：日誌存放路徑、模塊、插件等配置信息。
hosts：機器清單（被控主機文件），進行分組管理
命令文件
/usr/bin/ansiable*
配置文件 /etc/ansible/ansible.cfg
[defaults] 通用默認配置
inventory = /etc/ansible/hosts 這個是默認庫文件位置,腳本,或者存放可通訊主機的目錄
#library = /usr/share/my_modules/ Ansible默認搜尋模塊的位置
remote_tmp = $HOME/.ansible/tmp Ansible 經過遠程傳輸模塊到遠程主機,而後遠程執行,執行後在清理現場.在有些場景下,你也許想使用默認路徑但願像更換補丁同樣使用
pattern = * 若是沒有提供"hosts"節點,這是playbook要通訊的默認主機組.默認值是對全部主機通訊
forks = 5 在與主機通訊時的默認並行進程數 ，默認是5
poll_interval = 15 當具體的poll interval 沒有定義時,多少時間回查一下這些任務的狀態, 默認值是5秒
sudo_user = root sudo使用的默認用戶 ，默認是root
ask_sudo_pass = True 用來控制Ansible playbook 在執行sudo以前是否詢問sudo密碼.默認爲no
ask_pass = True 控制Ansible playbook 是否會自動默認彈出密碼
transport = smart 通訊機制.默認 值爲'smart'。若是本地系統支持 ControlPersist技術的話,將會使用(基於OpenSSH)'ssh',若是不支持講使用'paramiko'.其餘傳輸選項包括'local', 'chroot','jail'等等
remote_port = 22 遠程SSH端口。 默認是22
module_lang = C 模塊和系統之間通訊的計算機語言，默認是C語言
被控主機信息配置文件，進行分組管理
hosts
-
安裝Ansible 而且配置應用
1）準備工做
兩臺被控主機：192.168.31.168 192.168.31.178
一臺主控管理主機：192.168.31.188
安裝要求：
被控主機：須要安裝 Python2.6/2.7
主控主機：須要安裝 Python2.4 以上版本，關閉selinux
2）配置主機清單
vim /etc/ansible/hosts
192.168.31.168
192.168.31.178
3）配置控制主機SSH密鑰
在控制主機中生成ssh密鑰對
#ssh-keygen -t rsa
4）將公鑰拷貝到管理主機中.ssh/authorized_keys文件中，實現免密碼登陸遠程管理主機
ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.31.168
ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.31.178
（ssh-copy-id命令會自動將id_rsa.pub文件的內容追加到遠程主機root用戶下.ssh/authorized_keys文件中）
5) ansible配置
vim /etc/ansible/ansible.cfg
1 禁用每次執行ansbile命令檢查ssh key host
host_key_checking = False
6）開啓日誌記錄
log_path = /var/log/ansible.log
測試：
#ansible all -m ping
3、Ansible應用
1.經常使用模塊使用
1）setup
查看遠程主機基本信息
# ansible [HostGroup or IP] -m setup
2）ping
測試遠程主機運行狀態
# ansible [HostGroup or IP] -m ping
3）file
設置文件屬性
相關選項：
group：定義文件/目錄的屬組
mode：定義文件/目錄的權限
owner：定義文件/目錄的屬主
path：必選項，定義文件/目錄的路徑
recurse：遞歸設置文件的屬性，只對目錄有效
src：被連接的源文件路徑，只應用於state=link的狀況
dest：被連接到的路徑，只應用於state=link的狀況
force：須要在兩種狀況下強制建立軟連接，一種是源文件不存在，但以後會創建的狀況下；另外一種是目標軟連接已存在，須要先取消以前的軟鏈，而後建立新的軟鏈，有兩個選項：yes|no
state：
directory：若是目錄不存在，就建立目錄
file：即便文件不存在，也不會被建立
link：建立軟連接
hard：建立硬連接
touch：若是文件不存在，則會建立一個新文件，若是文件或目錄已存在，則更新其最後修改時間
absent：刪除目錄、文件或者取消連接文件
-
ansible實例：
遠程文件連接建立
# ansible [HostGroup or IP] -m file -a "src=/etc/resolv.conf dest=/tmp/resolv.conf state=link"
遠程文件連接刪除
# ansible [HostGroup or IP] -m file -a "path=/tmp/resolv.conf state=absent"
copy複製文件到遠程主機
相關選項：
backup：在覆蓋以前，將源文件備份，備份文件包含時間信息。有兩個選項：yes|no
content：用於替代"src"，能夠直接設定指定文件的值
dest：必選項。要將源文件複製到的遠程主機的絕對路徑，若是源文件是一個目錄，那麼該路徑也必須是個目錄
directory_mode：遞歸設定目錄的權限，默認爲系統默認權限
force：若是目標主機包含該文件，但內容不一樣，若是設置爲yes，則強制覆蓋，若是爲no，則只有當目標主機的目標位置不存在該文件時，才複製。默認爲yes
others：全部的file模塊裏的選項均可以在這裏使用
src：被複制到遠程主機的本地文件，能夠是絕對路徑，也能夠是相對路徑。若是路徑是一個目錄，它將遞歸複製。在這種狀況下，若是路徑使用"/"來結尾，則只複製目錄裏的內容，若是沒有使用"/"來結尾，則包含目錄在內的整個內容所有複製，相似於rsync。
實例：
將本地文件"/etc/ansible/ansible.cfg"複製到遠程服務器
#ansible [HostGroup or IP] -m copy -a "src=/etc/ansible/ansible.cfg dest=/tmp/ansible.cfg owner=root group=root mode=0644"
command在遠程主機上執行命令
相關選項以下：
creates：一個文件名，當該文件存在，則該命令不執行
free_form：要執行的linux指令
chdir：在執行指令以前，先切換到該目錄
removes：一個文件名，當該文件不存在，則該選項不執行
executable：切換shell來執行指令，該執行路徑必須是一個絕對路徑
實例：
# ansible [HostGroup or IP] -m command -a "uptime"
遠程文件信息查看
# ansible [HostGroup or IP] -m command -a "ls –al /tmp/resolv.conf"
切換到shell執行指定的指令，參數與command相同。
與command不一樣的是，此模塊能夠支持命令管道，同時還有另外一個模塊也具有此功能：raw
實例：
先在本地建立一個SHELL腳本
# vim /tmp/test.sh
#!/bin/sh
date +%F_%H:%M:%S
#chmod +x /tmp/test.sh
將建立的腳本文件分發到遠程
# ansible [HostGroup or IP] -m copy -a "src=/tmp/test.sh dest=/tmp/test.sh owner=root group=root mode=0755"
遠程執行
# ansible [HostGroup or IP] -m shell -a "/tmp/test.sh"
cron建立和刪除計劃任務
#ansible [HostGroup or IP] -m cron -a "name='....' job='.....' $time"
-m 跟模塊，使用的是 cron 模塊
name= 指定計劃任務的名字，方便往後管理
job= 指定具體的任務
$time 指定具體的執行時間，minute分鐘，hour小時，day 天，month 月份。weekday 0 或者 7 表明週末。
state= 選項用來指定 name 並刪除
增長計劃任務
# ansible [HostGroup or IP] -m cron -a "name='test cron' job='/bin/bash /tmp/test.sh' weekday=6"
#ansible [HostGroup or IP] -m cron -a "name='test n' job='/bin/bash /tmp/test.sh' weekday=6 minute=30 hour='*/8'"
#ansible [HostGroup or IP] -m cron -a "name='test cron' job='/bin/bash /tmp/test.sh' minute=30 hour='*/8' day='1,10,20' weekday=6"
刪除計劃任務
# ansible [HostGroup or IP] -m cron -a "name='test n' state=absent"
# ansible [HostGroup or IP] -m cron -a "name='test cron' state=absent"
安裝 rpm 包
-m 使用 yum 模塊
state= installed removed ，不加state選項默認是 installed
# ansible [HostGroup or IP] -m yum -a "name=tree"
# ansible [HostGroup or IP] -m yum -a "name=wget"
# ansible [HostGroup or IP] -m yum -a "name=wget state=removed"
管理服務
-m service 模塊
name= 系統服務，能夠用 chkconfig --list 查看
enabled= 是否開機啓動，yes| no。
# ansible [HostGroup or IP] -m service -a "name=httpd state=started enabled=no"
# ansible [HostGroup or IP] -m service -a "name=httpd state=stopped enabled=yes"
Ansible 文檔使用
列出全部模塊
# ansible-doc -l
查看具體的模塊使用方法
# ansible-doc service
# ansible-doc cron
# ansible-doc shell
爲Ansible定義節點的清單
文件 /etc/ansible/hosts 維護着Ansible中服務器的清單。
[root@artemis ~]# vi /etc/ansible/hosts
[dbservers]
192.168.56.212
192.168.56.213
嘗試在Ansible服務端運行命令
[root@artemis ~]# ansible -m ping 'dbservers'
執行shell命令
例子1：檢查Ansible節點的運行時間（uptime):
[root@artemis ~]# ansible -m command -a "uptime" 'dbservers'
例子2：檢查節點的內核版本
[root@artemis ~]# ansible -m command -a "uname -r" 'dbservers'
例子3：給節點增長用戶
[root@artemis ~]# ansible -m command -a "useradd david" 'dbservers'
[root@artemis ~]# ansible -m command -a "grep david /etc/passwd" 'dbservers'
例子4：重定向輸出到文件中
ansible -m command -a "df -Th" 'dbservers' > /tmp/command-output.txt
cat /tmp/command-output.txt
-
- 1. Python基礎語法
- 2. Python 基礎語法
- 3. Python 語法基礎
- 4. python基礎語法
- 5. python語法基礎
- 6. Python語法基礎
- 7. PYTHON基礎語法
- 8. Python——基礎語法
- 9. python 基礎語法
- 更多相關文章...
- • Kotlin 基礎語法 - Kotlin 教程
- • Scala 基礎語法 - Scala教程
- • Kotlin學習（一）基本語法
- • Kotlin學習（二）基本類型
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Python基礎語法
- 2. Python 基礎語法
- 3. Python 語法基礎
- 4. python基礎語法
- 5. python語法基礎
- 6. Python語法基礎
- 7. PYTHON基礎語法
- 8. Python——基礎語法
- 9. python 基礎語法