python

一.分支的基本語法

單if

if表達式：
    語句1
    語句2
    ……

2.條件表達式就是計算結果必須爲布爾值得表達式
3.表達式後面的冒號不能少
4.注意if後面出現的語句，若是屬於if語句塊，則必須同一個縮進等級
5.條件表達式結果爲True執行if後面的縮進語句塊

雙向分支

if表達式：
    語句1
    語句2
    ……
else：
    語句
    語句
    ……

縮進問題，if和else一個層次，其他語句一個層次。

多線路分支

if 條件表達式:
        語句1：           
    elif 條件表達式:                    
     語句1           
    elif 條件表達式:                    
        語句1            
    else:                   
        語句1

注意：

1.if語句能夠嵌套使用，但不推薦。
2.python沒有switch-case語句。

二.循環語句

1.for循環
2.while循環

for循環

for 變量 in 列表：
    語句
    語句
    ……

eg:
~~~
for name in ['abc','bcd','ddd']:
print(name)
~~~
輸出:
abc
bcd
ddd
break,continue,pass
break與continue和C++中的沒有區別
pass:表示略過，一般用於佔位
eg:
~~~
for letter in 'Python':
if letter == 'h':
pass
print ('這是 pass 塊')
print ('當前字母 :', letter)
~~~
輸出：
當前字母 : P
當前字母 : y
當前字母 : t
這是 pass 塊
當前字母 : h
當前字母 : o
當前字母 : n
注：
也可用於函數中的佔位：
~~~
def sample(n_samples):
pass
~~~
該處的 pass 即是佔據一個位置，由於若是定義一個空函數程序會報錯，當你沒有想好函數的內容是能夠用 pass 填充，使程序能夠正常運行。

while循環

語法：
~~~
while 條件表達式:
語句塊
~~~
注：表達式兩邊不用加括號

三.函數

函數代碼塊以 def 關鍵詞開頭，後接函數標識符名稱和圓括號 ()。
任何傳入參數和自變量必須放在圓括號中間，圓括號之間能夠用於定義參數。
函數的第一行語句能夠選擇性地使用文檔字符串—用於存放函數說明。
函數內容以冒號起始，而且縮進。
return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return至關於返回 None。
~~~
def 函數名（參數列表）:
函數體
~~~
默認狀況下，參數值和參數名稱是按函數聲明中定義的順序匹配起來的。

可更改(mutable)與不可更改(immutable)對象

在 python 中，strings, tuples, 和 numbers 是不可更改的對象，而 list,dict 等則是能夠修改的對象。
~~~
不可變類型：變量賦值 a=5 後再賦值 a=10，
這裏實際是新生成一個 int 值對象 10，再讓 a 指向它，而 5 被丟棄，
不是改變a的值，至關於新生成了a。
可變類型：變量賦值 la=[1,2,3,4]
後再賦值 la[2]=5 則是將 list la 的第三個元素值更改，
自己la沒有動，只是其內部的一部分值被修改了。
~~~
python 函數的參數傳遞：

不可變類型：相似 c++ 的值傳遞，如 整數、字符串、元組。
           如fun（a），傳遞的只是a的值，沒有影響a對象自己。
           好比在 fun（a）內部修改 a 的值，只是修改另外一個複製的對象，不會影響 a

eg:
~~~
def ChangeInt( a ):
a = 10

b = 2
ChangeInt(b)
print( b ) # 結果是 2

可變類型：相似 c++ 的引用傳遞，如 列表，字典。
             如 fun（la），則是將 la 真正的傳過去，修改後fun外部的la也會受影響
eg:

def changeme( mylist ):
"修改傳入的列表"
mylist.append([1,2,3,4])
print ("函數內取值: ", mylist)
return

調用changeme函數

mylist = [10,20,30]
changeme( mylist )
print ("函數外取值: ", mylist)
~~~
傳入函數的和在末尾添加新內容的對象用的是同一個引用。故輸出結果以下：
~~~
函數內取值: [10, 20, 30, [1, 2, 3, 4]]
函數外取值: [10, 20, 30, [1, 2, 3, 4]]
~~~
python 中一切都是對象，嚴格意義咱們不能說值傳遞仍是引用傳遞，咱們應該說傳不可變對象和傳可變對象

參數

如下是調用函數時可以使用的正式參數類型：
必需參數
關鍵字參數
默認參數
不定長參數

必須參數

必需參數須以正確的順序傳入函數。調用時的數量必須和聲明時的同樣。
調用 printme() 函數，你必須傳入一個參數，否則會出現語法錯誤：
~~~
def printme( str ):
"打印任何傳入的字符串"
print (str)
return

調用 printme 函數，不加參數會報錯

printme()
~~~
會輸出：
~~~
Traceback (most recent call last):
File "test.py", line 10, in
printme()
TypeError: printme() missing 1 required positional argument: 'str'
~~~

關鍵字參數

關鍵字參數和函數調用關係緊密，函數調用使用關鍵字參數來肯定傳入的參數值。
使用關鍵字參數容許函數調用時參數的順序與聲明時不一致，由於 Python 解釋器可以用參數名匹配參數值。
~~~
def printinfo( name, age ):
"打印任何傳入的字符串"
print ("名字: ", name)
print ("年齡: ", age)
return

調用printinfo函數

printinfo( age=50, name="runoob" )

輸出：
名字: runoob
年齡: 50
~~~

默認參數

調用函數時，若是沒有傳遞參數，則會使用默認參數。如下實例中若是沒有傳入 age 參數，則使用默認值：
~~~
def printinfo( name, age = 35 ):
"打印任何傳入的字符串"
print ("名字: ", name)
print ("年齡: ", age)
return

調用printinfo函數

printinfo( age=50, name="runoob" )
print ("------------------------")
printinfo( name="runoob" )

輸出：
名字: runoob
年齡: 50
------------------------
名字: runoob
年齡: 35
~~~

不定長參數

可看python基礎教程（第三版）的p100和p66

你可能須要一個函數能處理比當初聲明時更多的參數。這些參數叫作不定長參數，和上述 2 種參數不一樣，聲明時不會命名。基本語法以下：
~~~
def functionname([formal_args,] var_args_tuple ):
"函數_文檔字符串"
function_suite
return [expression]
~~~
加了星號 的參數會以元組(tuple)的形式導入，存放全部未命名的變量參數。
~~~
def printinfo( arg1, *vartuple ):
"打印任何傳入的參數"
print ("輸出: ")
print (arg1)
print (vartuple)

調用printinfo 函數

printinfo( 70, 60, 50 )
~~~
若是在函數調用時沒有指定參數，它就是一個空元組。咱們也能夠不向函數傳遞未命名的變量。

還有一種就是參數帶兩個星號
基本語法以下：
~~~
def functionname([formal_args,] var_args_dict ):
"函數_文檔字符串"
function_suite
return [expression]
~~~
加了兩個星號 的參數會以字典的形式導入。
~~~
def printinfo( arg1, vardict ):
"打印任何傳入的參數"
print ("輸出: ")
print (arg1)
print (vardict)

調用printinfo 函數

printinfo(1, a=2,b=3)

輸出:
1
{'a': 2, 'b': 3}
~~~
聲明函數時，參數中星號 * 能夠單獨出現，例如:
~~~
def f(a,b,,c):
return a+b+c
~~~
若是單獨出現星號 後的參數必須用關鍵字傳入。
~~~

def f(a,b,*,c):
... return a+b+c
...
f(1,2,3) # 報錯
Traceback (most recent call last):
File " ", line 1, in
TypeError: f() takes 2 positional arguments but 3 were given
f(1,2,c=3) # 正常
6

~~~

匿名參數

（感受和C的宏定義有點像）
python 使用 lambda 來建立匿名函數。
所謂匿名，意即再也不使用 def 語句這樣標準的形式定義一個函數。

lambda 只是一個表達式，函數體比 def 簡單不少。
lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
lambda 函數擁有本身的命名空間，且不能訪問本身參數列表以外或全局命名空間裏的參數。
雖然lambda函數看起來只能寫一行，卻不等同於C或C++的內聯函數，後者的目的是調用小函數時不佔用棧內存從而增長運行效率。

lambda 函數的語法只包含一個語句，以下：
~~~
lambda [arg1 [,arg2,.....argn]]:expression
~~~
~~~
sum = lambda arg1, arg2: arg1 + arg2

調用sum函數

print ("相加後的值爲 : ", sum( 10, 20 ))
print ("相加後的值爲 : ", sum( 20, 20 ))

相加後的值爲 : 30 相加後的值爲 : 40 ~~~