Python基礎筆記系列九：變量、自定義函數以及局部變量和全局變量

　　本系列教程供我的學習筆記使用，若是您要瀏覽可能須要其它編程語言基礎（如C語言），why?由於我寫得爛啊，只有我本身看得懂！！

• 變量
  在前面的系列中也許就能夠發現，python中的變量和C中的變量有些許不一樣。好比在C中：
  例子：

   1 #include <stdio.h>
   2 
   3 int main(void)  4 {  5     /* code */
   6     int a,b,c;  7     int *p,*q,*t;  8 
   9     a = 5,b=8,c=5; 10     p = &a; 11     q = &b; 12     t = &c; 13     printf("%d\n",p); 14     printf("%d\n",q); 15     printf("%d\n",t); 16     return 0; 17 }

  輸出：

  1 6487604
  2 6487600
  3 6487596

  　　從輸出結果能夠看出，雖然a和c的值是同樣的，可是a和c的地址是不一樣的。也就是說a開始賦值爲5開闢了一塊空間，當c賦值爲5時又會給它分配一塊空間。
  　　可是在python 中就不一樣，以下的例子。
  例子：

  1 #----------變量--------
  2 a = 5
  3 b = 8 
  4 c = 5 
  5 print id(a)  #id(變量名) 用於取變量的地址
  6 print id(b) 7 print id(c)

  輸出：

  1 86995552
  2 86995516
  3 86995552

  從上面兩個例子中咱們能夠看出區別：
  　　1）c語言中定義變量須要定義變量類型，具體這個變量是int、long仍是char等等，而python中不關心變量的類型，直接定義變量，它會本身尋找最合適的類型進行存儲，可經過type(變量名)來查看變量的類型，在前面的系列中也能夠看出python的變量沒有類型，好比定義一個字符串str則能夠直接：str = "hello"。
  　　2）c語言中定義變量時無論內存空間中有沒有這個值都會從新開闢一塊新的空間，而python中若是在內存空間中存在一個相同的值，就不會開闢新空間，直接將變量指向這塊空間。

• 自定義函數
  1、函數的定義規則
  　　#1.def定義函數  2.函數後有":"號  3.以代碼縮進表示函數體

  　　#def 函數名（參數名）:
  　　# '註釋內容'
  　　# 執行語句
  　　# return
  例子1：

  1 def add(x,y): 2     z = x + y 3     return z 4 
  5 result = add(3,5) 6 print result

  輸出：8
  例子2：

  def printName(str): '打印任意傳入的參數'
      print str return

  輸出：

  1 你好，python

  2、函數的調用
  　　1.若是函數在於另外一個模塊中，則須要import導入模塊才能調用；
  　　  2.若是函數在當前模塊中，則能夠直接調用。

  1 #若是函數在單獨的一個文件 須要先import 文件名 
  2 printName('你好，python')  #調用函數
  3 #好比經過help 查看函數中的註釋內容，其實就是使用了python的help函數
  4 print help(printName)

  3、函數的值傳遞和引用傳遞

  　　在此以前要知道函數的參數有兩種：形參和實參
  　　形參：在函數定義時的變量成爲函數的形參，形參主要用於接收調用方傳遞過來的值或引用；
  　　實參：函數調用時的實際參數。
  　　函數的值傳遞也就是實實在在值的傳遞問題。
  例子：

   1 def function1(var):  2     '按值傳遞，修改值'
   3     var = 100
   4     print 'id= ',id(var)  5     print '函數內取值：',var  6     return
   7 
   8 var =5
   9 function1(var) #調用函數
  10 print 'id= ',id(var) 11 print '函數外取值：',var   #

  輸出：

  1 id=  89814444
  2 函數內取值： 100
  3 id=  89813600
  4 函數外取值： 5

  　　函數的引用傳遞傳的是一個引用，若是你在函數裏修改了參數，那麼在調用這個函數的函數裏，原始的參數也改變了。
  例子：

   1 def changeme(mylist):  2     '修改傳入的列表'
   3     # mylist =[1111,222,333] #從新進行了賦值操做，變爲值傳遞
   4     mylist.append([1,2,3,4])  5     print 'id= ',id(mylist)  6     print '函數內取值：',mylist  7     return
   8 
   9 mylist = [4,5,6,7] 10 changeme(mylist)  #調用函數
  11 print 'id= ',id(mylist) 12 print '函數外取值：',mylist      #

  輸出：

  1 id=  91525568
  2 函數內取值： [4, 5, 6, 7, [1, 2, 3, 4]] 3 id=  91525568
  4 函數外取值： [4, 5, 6, 7, [1, 2, 3, 4]]

  從上面兩個例子中能夠看出，其實就是說若是在函數裏面對傳進來的這個變量進行了賦值(就有了不一樣空間地址)，那麼函數內部這個變量的值就改變了，而函數外部仍是沒有變化，這就是值傳遞。若是函數裏面對傳進來的那個變量只是在他本來的基礎上（同一塊地址上）進行操做，那麼函數內部這個變量的值就改變了，而函數外部也跟着變化，這就是引用傳遞。從C語言的角度來講，值傳遞和或引用傳遞也就是地址或值的改變。（我的這樣認爲，若是你有更好的看法歡迎教小弟一把~底部有聯繫方式）
  4、函數的參數類型
  　　python函數的參數類型主要有四種：必備參數、命名參數、缺省參數、不定長參數。
  　　必備參數：調用方必須以正確順序傳入參數，且數量要和聲明時的同樣；
  　　命名參數：調用方用參數的命名肯定傳入的參數值
  　　缺省參數：函數的參數能夠設置默認值，若是設置了默認值則調用方能夠不給它傳參而使用默認值
  　　不定長參數：一個函數能夠處理比當初聲明時更多的參數，這些參數就是不定長參數
  例子：

   1 #1必備參數
   2 def printA(a,b):  3     '打印任意傳入的參數'
   4     print a + b  5     return
   6 printA(1,2) #調用函數
   7 print '-'*30
   8 #2命名參數
   9 def printA(a,b): 10     '打印任意傳入的參數'
  11     print a + b 12     return
  13 printA(b=1,a=2) #調用函數
  14 print '-'*30
  15 #3缺省參數
  16 def printB(a,b=5): #設置了默認值
  17     '打印任意傳入的參數'
  18     print 'a=%d'%a 19     print 'b=%d'%b 20     return
  21 printB(1) #只傳了一個參數，則b使用默認值
  22 printB(1,2) #若傳了兩個參數，則不使用默認值

  輸出：

  1 3
  2 ------------------------------
  3 3
  4 ------------------------------
  5 a=1
  6 b=5
  7 a=1
  8 b=2

  不定長參數是一個函數能夠處理比當初聲明時更多的參數，不定長參數有兩種定義方式。一種是將不定長參數匹配爲元組，另外一種是將不定長參數匹配爲字典。
  例子：

   1 #不定長參數匹配爲元組
   2 def arglist(a,*b): #不定長參數用*號定義 其本質爲一個元組
   3     print a  4     print b  5     return
   6 arglist(1,2,3,5,6)  #第一個匹配a,後面的就是一個元組b
   7 
   8 print '-'*30
   9 #不定長參數匹配爲字典(key-value)
  10 #例1
  11 def arglist1(a,**b): #不定長參數用**號定義 其本質爲一個字典
  12     print a 13     print b 14     return
  15 arglist1(1,x=2,y=3)  #第一個匹配a,後面的就是一個字典b
  16 
  17 #例2
  18 def arglist2(**a): #不定長參數用**號定義 其本質爲一個字典
  19     print a 20     for key in a: 21         print key+' = '+ str(a[key]) 22     return
  23 arglist2(x=2,y=3,z=5) 24 
  25 print'-'*30

  輸出：

  1 1
  2 (2, 3, 5, 6) 3 ------------------------------
  4 1
  5 {'y': 3, 'x': 2} 6 {'y': 3, 'x': 2, 'z': 5} 7 y = 3
  8 x = 2
  9 z = 5

  5、函數的return語句
  　　python不一樣與其它編程語言，它的return語句能夠返回多個返回值,返回多個值放在一個元組中。
  例子：

  1 def arglist3(): 2     print 'call this function'
  3     return 1,2,3,4,5
  4 
  5 res = arglist3()  #調用方法
  6 print res    #打印返回值（元組）
  7 print res[0:3] #一樣能夠操做這個元組

  輸出：

  1 call this function 2 (1, 2, 3, 4, 5) 3 (1, 2, 3)

  6、匿名函數
  　　匿名函數，顧名思義就是沒有名字的函數，在python中使用lambda表達式定義。

  #1.得名於省略了用def聲明函數的標準步驟
  #2.Lambda函數能接收任何數量的參數但只能返回一個表達式的值
  #3.不能包含多個命令和表達式
  #4.匿名函數不能直接調用print ,由於lambda須要一個表達式，因此須要一個變量來存表達式的值
  #5.lambda函數擁有本身的名字空間，且不能訪問自由參數列表以外或全局名字空間裏的參數
  #6.lambda函數的語法只包含一個語句，例如，函數名=lambda [參數1，參數2，...] :表達式
  例子：

  1 sum = lambda arg1,arg2 : arg1+arg2 2 print sum(5,3) #調用sum函數
  3 print type(sum)

  輸出：

  1 8
  2 <type 'function'>

   

• 局部變量和全局變量
  通常地，在函數體內部定義的變量是局部變量，只能在函數體內部訪問（可使用global關鍵字將局部變量定義爲全局變量），而不包含於任何一個函數的，或者說是與main函數屬於同一級的是全局變量，能夠在main函數中任何地方使用(若是要在某函數體內部修改全局變量的值，使用global關鍵字)。
  函數在調用時就會所有解析函數體，若是函數體內有定義和全局變量同名的局部變量，則函數體使用的是局部變量，在定義以前使用則會出錯；可是若是整個函數體都沒有定義該變量，它能夠直接調用全局變量
  例子：

   1 def function1():  2     #print num1 #在定義以前打印(報錯)
   3     num1 = 10
   4     global num2  5     num2 = 20
   6     print num1  7 num1=5
   8 function1()  9 print num1 10 print num2 #調用全局變量num2 

  輸出：

  1 10
  2 5
  3 20