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

青衫煙雨客發表於2019-08-12
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 --------------------------

相關文章