【Python】語法基礎 | 開始使用Python

Python的熱度不言而喻，機器學習、數據分析的首選語言都是Python，想要學習Python的小夥伴也不少，我以前也沒有認真用過Python，因此也想體驗一下它的魅力，索性花了兩天集中看了一下它的基本語法，組織了這篇筆記，一是增強一下本身的記憶和理解，二是能夠分享給共同窗習的小夥伴。這篇筆記主要是Python的基本語法，算是入個門，後面能夠邊用邊增強。

輸入與輸出

在python中，輸入用 input( )，輸出用 print( )。

簡單的例子：

兩點注意：

• Input()接收的輸入數據都認爲是字符串，如作其它類型使用，需轉換。

• Print()能夠作格式化輸出，同C相似，%d（整型）%s（字符串）%f（浮點型），如搞不清，直接都用%s也能夠，它會把任何數據類型轉換爲字符串。

#用python計算圓的面積；
#定義一個變量接收輸入的圓半徑
r=input("請輸入圓半徑：")
#定義一個變量存放計算出的圓面積
#特別注意：python3針對輸入統一都認爲是字符串型
#因此在計算時要將其轉換爲整形數，格式：int（x）
s=3.14*int(r)*int(r)
#輸出計算出的圓面積s
print("圓面積s=",s)
#也能夠直接在輸出print裏計算圓面積
print("直接在print裏計算面積：",3.14*int(r)*int(r))
#利用佔位符實現格式化輸入，這裏和C語言是相似的
print("輸入的圓半徑是%s,圓面積是%f" %(r,3.14*int(r)*int(r)))

運行結果：
請輸入圓半徑：4
圓面積s= 50.24
直接在print裏計算面積：50.24
輸入的圓半徑是4,圓面積是50.240000

變量與數據類型

在c++中，咱們要使用變量，就須要先聲明一個數據類型，不一樣的數據類型長度不一樣，可以存儲的值範圍也不一樣，也就意味着不一樣的數據類型不能混淆使用。下面的代碼是C++中的變量。

#include<iostream>  
#include<string>  
#include <limits>  
using namespace std;  

int main()  
{
    int a=10;  //整型：4個字節
    char b='x';  //字符型：1個字節
    float c=3.14; //單精度浮點：4個字節，7個數字

    cout<<"int a="<<a<<"\t長度是"<<sizeof(int)<<endl
        <<"char b="<<b<<"\t長度是"<<sizeof(char)<<endl
        <<"float c="<<c<<"\t長度是"<<sizeof(float)<<endl;
}

運行結果：
int a=10       長度是4
char b=x       長度是1
float c=3.14   長度是4

在Python中，whatever，一切都是那麼的隨意，充滿着自由的氣息。

#定義一個變量a，給它一個整形值27
a=27
print(a)
#再將a的值變爲一個浮點數，3.1415927
a=3.1415927
print(a)
#再將a的值變爲一個字符串，J_ZHANG
a="J_ZHANG"
print(a)

運行結果：
27
3.1415927
J_ZHANG

能夠看出，變量a是什麼數據類型，who cares，給它賦的值是什麼類型，它就是什麼類型。

一個栗子，有助理解：

a = 123
#執行這句話，python幹了兩件事
#一是在內存中建了個123的整數
#二是在內存中建了個變量a，而後將a指向剛建的整數123
b = a
#執行這句話，python建了個變量b，並指向a所指向的123
a = 'ZNN'
#這句話python建了個字符串ZNN，並將a指向了新建的ZMM
#注意：b沒有改變喲，它仍是指向a原來指向的那個123
print("執行輸出：a=",a,"；b=",b)
#print(b)

運行結果：
執行輸出：a= ZNN ；b= 123

兩個小概念：

🔗動態語言：像Python這樣，變量使用以前不須要類型聲明，變量的類型就是被賦值的那個值的類型，動態語言是在運行時肯定數據類型的語言。

🔗靜態語言：在定義變量時必須指定變量類型，且在賦值時類型要相匹配，不然會出現運行時類型錯誤。如C/C++/JAVA等語言。

 List（列表）

值可變，是一種有序列表，可經過索引訪問列表元素，索引從0開始，也可從-1開始進行反向訪問。可隨意添加、修改、刪除其中的元素，元素數據類型能夠不一樣，可嵌套使用造成多維列表。簡直不要太強大了！

#定義一個list變量stuName，list元素可爲不一樣類型
stuName=['FF','NN','ZZ',1999,'HH','XY']
#獲取list的長度，len()
print('stuName的元素個數：',len(stuName))
print(stuName)
#訪問list元素，索引是從0開始，反向訪問從-1開始，-1是最後一個元素索引
print('第一個元素是:%s，倒數第二個元素是:%s' %(stuName[0],stuName[-2]))
#增、刪、改
stuName.append('J_ZHANG')#在末尾追加一個元素
print(stuName)
stuName.insert(0,2009)#在指定位置插入元素
print(stuName)
stuName.pop()#刪除最後一個元素
print(stuName)
stuName.pop(4)#刪除第五個元素
print(stuName)
stuName[3]='J_ZHANG'#修改索引爲3的元素
print(stuName)
stuInfo=[stuName,[10,20,30]]#嵌套使用
print(stuInfo)
print(stuInfo[0][3])#二維List的訪問方式

運行結果：
stuName的元素個數：6
['FF', 'NN', 'ZZ', 1999, 'HH', 'XY']
第一個元素是:FF，倒數第二個元素是:HH
['FF', 'NN', 'ZZ', 1999, 'HH', 'XY', 'J_ZHANG']
[2009, 'FF', 'NN', 'ZZ', 1999, 'HH', 'XY', 'J_ZHANG']
[2009, 'FF', 'NN', 'ZZ', 1999, 'HH', 'XY']
[2009, 'FF', 'NN', 'ZZ', 'HH', 'XY']
[2009, 'FF', 'NN', 'J_ZHANG', 'HH', 'XY']
[[2009, 'FF', 'NN', 'J_ZHANG', 'HH', 'XY'], [10, 20, 30]]
J_ZHANG

Tuple（元組）

值不可變，與List相似，元素可爲任意類型，但其一旦定義了，裏面的值是不可改變的，沒有append()、 insert()這些方法，但若是Tuple裏面有個元素爲List類型，則這個List裏的值是能夠改變的。

#定義一個Tuple變量stuName，元素可爲不一樣類型，但值不可改變
stuName=('FF','NN','ZZ',1999,'HH','XY')
print(stuName)
print(stuName[0],stuName[-1])#Tuple元素訪問與List相似
#stuName[2]='J_ZHANG' #會報錯，值不可變
stuInfo=('aa','bb',[10,20,'string'])#Tuple裏面包含List類型元素
print(stuInfo)
stuInfo[2][2]=30#包含的List裏的元素是能夠修改的
print(stuInfo)

運行結果：
('FF', 'NN', 'ZZ', 1999, 'HH', 'XY')
FF XY
('aa', 'bb', [10, 20, 'string'])
('aa', 'bb', [10, 20, 30])

Dictionary（字典）

字典是以鍵值對（key-value）的方式存儲，該方式鍵與值一一對應，能夠快速的根據key找到value，查詢速度快。注意，鍵（key）不可變，值（value）可變。簡單理解，學生的姓名（key）和成績（value）用字典存放，是一一對應的，找到學生的姓名，便可立刻知道他的成績了，查找速度快。

#定義一個Dict變量stuScore，姓名（key）與成績（value）一一對應
stuScore={'FF':80,'NN':90,'ZZ':100}
stuScore['HH']=70#在後面添加一個鍵值對
print(stuScore)
print(stuScore['HH'])#獲取鍵所對應的值
stuScore.pop('HH')#刪除指定的鍵值對
stuScore['ZZ']=89#修改鍵ZZ的值
print(stuScore)
print(stuScore.keys())#獲取全部鍵
print(stuScore.values())#獲取全部值
print(stuScore.items())#按組打印

運行結果：
{'FF': 80, 'NN': 90, 'ZZ': 100, 'HH': 70}
70
{'FF': 80, 'NN': 90, 'ZZ': 89}
dict_keys(['FF', 'NN', 'ZZ'])
dict_values([80, 90, 89])
dict_items([('FF', 80), ('NN', 90), ('ZZ', 89)])

一個簡單的應用，統計一組數據中不一樣性別的數量，有助理解字典。

#定義一個Dict變量stuInfo，姓名（key）與性別（value）
stuInfo={'FF':'女','NN':'女','ZZ':'男'}
#下面統計 stuInfo 裏面'男'、'女'的數量
stuXBTJ={}#定義一個空字典用於存放統計結果
for xb in stuInfo.values():#遍歷
    if xb in stuXBTJ:#若是該性別已存在，則加1
        stuXBTJ[xb]= stuXBTJ[xb] + 1
    else:#不然，該性別數量初始化爲1
        stuXBTJ[xb]=1
print(stuXBTJ)#打印結果

運行結果：
{'女': 2, '男': 1}

Set（集合）

集合是無序的，也沒法經過數字進行索引。此外，集合中的元素不能重複。集合能夠進行數學意義上的交集、並集等計算。建立set，須要一個list做爲輸入集合。

#利用一個List建立一個Set集合
stu=['FF','ZZ','NN','JJ','ZZ','FF']
s=set(stu)#建立集合s
print(s)#打印s發現重複項已被自動過濾
s.add(27)#添加一項
s.remove('JJ')#刪除一項
print(s)
s1=set([1,2,3,4,5])
s2=set([4,5,6,7,8])
print('交集',s1 & s2)#計算兩個集合的交集
print('並集',s1 | s2)#計算兩個集合的並集
print('差集',s1 - s2)#計算兩個集合的差集

運行結果：
{'NN', 'ZZ', 'JJ', 'FF'}
{'NN', 'ZZ', 27, 'FF'}
交集 {4, 5}
並集 {1, 2, 3, 4, 5, 6, 7, 8}
差集 {1, 2, 3}

選擇與循環

選擇與循環是程序設計的兩種主要結構，Python的選擇與循環與其它語言的寫法截然不同，習慣C/C++/C#的寫法開始會有些不適應的。（注意：Python裏沒有大括號，它是靠縮進來區分代碼段的。）

選擇：if  else  &  if  elif else

score=78
if score>=60:
    print('及格！')#執行
    print('OK ！')#執行，沒有大括號，用縮進
else:
    print('不及格！')

if score>=80:
    print('優秀！')
elif score>=70:
    print('良好！')#執行 
elif score>=60:
    print('及格！')  
else:
    print('差！') 
#if...elif是從上到下判斷，遇到true即執行，其他忽略。

運行結果：
及格！
OK ！
良好！

循環：for  &  whele

#for循環實現list遍歷
stuName=('FF','NN','ZZ')
for name in stuName:
    print(name)

stuInfo=[['FF','NN'],[22,27]]
for i in stuInfo:#Ffor循環嵌套使用
    for j in i:
        print(j)

sum=0
n=0
while n<=10:#while循環的使用
    sum=sum+n
    n=n+1
print(sum)

運行結果：
FF
NN
ZZ
FF
NN
22
27
55

break和continue的用法與C++一致。

break：提早結束循環。

continue：結束本輪循環，直接開始下一輪循環。

文件讀寫

讀文件：同C相似，Python內置了讀文件的函數open()，使用注意事項：

• 文件打開用完要關閉，open()和close()配對使用。

• 避免文件打開失敗或忘記關閉等形成的錯誤，使用with…as…操做文件。

#使用open()函數讀文件，文件位置：D:\test.txt
f=open("D:\\test.txt","r")#打開文件，第二個參數「r」表示讀
fn=f.read()
print(fn)
f.close()#完成操做後必需要關閉文件

#文件打開用完就要關閉，但不排除一通操做後忘了關閉文件，
#同時還存在文件打開失敗的狀況，使用with…as…操做文件更可靠，更簡潔。
with open("D:\\test.txt","r") as f:
    fn=f.read()
print(fn)

運行結果：
python file_IO
FF 22
NN 09
ZZ 26
python file_IO
FF 22
NN 09
ZZ 26

寫文件：寫文件和讀文件是同樣的，先open，而後write，最後close，open時第二個參數是「w」。

• 寫文件時，若是目標位置沒有文件，python會建立文件。

• 若是目標位置有文件，參數「w」就會覆蓋寫入，追加寫入可用參數「a」。

• 能夠反覆調用write()寫數據，但若是最後忘記close()文件，後果多是數據丟失，保險起見，仍是使用with…as…更靠譜。

#在D盤建立一個新文件test_new.txt,而後寫入內容，
f=open("D:\\test_new.txt","w")
f.write("J_ZHANG")
f.close()
#再次寫入就會覆蓋原內容
with open("D:\\test_new.txt","w") as f:
    f.write("覆蓋了嗎？")
    f.write("\n")#換一下行
#使用參數「a」實現追加寫入
with open("D:\\test_new.txt","a") as f:
    f.write("J_ZHANG追加寫入的。")
#打印出來看一下
with open("D:\\test_new.txt","r") as f:
    print(f.read())

運行結果：
覆蓋了嗎？
J_ZHANG追加寫入的。

定義與使用函數

Python用def關鍵字定義一個函數，定義時需肯定函數名與參數，函數能夠有多個返回值，但如函數沒有return，則默認還回none。因python變量爲動態類型，如函數對參數有類型要求，需在函數體內進行類型檢查。

#使用def定義一個函數：求圓面積
def cir_area(r):
    if not isinstance(r,(int,float)):#參數類型檢查，r爲整型或浮點型
        raise TypeError("參數r類型錯誤！")
    if r<=0:
        return 0#判斷若是半徑小於等於0則返回0
    else:
        return 3.14*r*r

#調用函數
s=cir_area(4)#半徑爲4的圓面積
print(s) 

運行結果：
50.24

OK，就醬紫！暫時先到這兒。

-------------------------- END --------------------------