python基础语言法则_python语言基础3
一:python函數
是組織好的,可重復使用的,用來實現單一,或相關聯功能的代碼塊。以前使用過的一些Python提供的內建函數,如print()、max(4,18)、min(100,50)。當然我們自己創建的函數,叫做自定義函數。
①、代碼要遵循的原則:高內聚,低耦合
模塊內部之間的聯系,應該非常緊密的
模塊與模塊之間的聯系,應該盡量少
②、優點:
函數能提高應用的模塊性,和代碼的重復利用率。
③、定義函數的場合:
凡是我們需要描述某個功能的時候,都將它定義為函數
④、函數定義規則:
函數代碼塊以 def 關鍵詞開頭,后接函數標識符名稱和圓括號 ()。任何傳入參數和自變量必須放在圓括號中間,圓括號之間可以用于定義參數。 函數內容以冒號起始,并且縮進。
return [表達式] 結束函數,選擇性地返回一個值給調用方。不寫return,相當于返回 None。
⑤、定義函數格式:
def 函數名(參數列表):
函數體
函數調用:
函數不調用就不會執行,調用函數通過函數名完成
⑥、建議:
函數的第一行語句,可以選擇性地使用文檔字符串,用于存放函數說明,函數定義時,一個函數的功能要單一。
1、簡單定義函數
#定義函數
def hello() :
print("Hello Python ...!")
#調用函數 函數不調用,不執行
hello()
運行結果:
Hello Python ...!
2、簡單實現業務
#定義函數,實現打印5行5列的*號
def print_tr() :
for i in range(5):
for j in range(5):
print("* ",end="")
print()
#調用
print_tr()
運行結果:
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *
3、在函數中,定義參數
函數是否需要未知數參與,需要可以用參數定義出來。
#計算兩個數之和
#2個數是未知數,未知數相當于python的參數
def add(a,b):
#print('{0}+{1}={2}'.format(a,b,a+b))
print('%s+%s=%s'%(a,b,a+b))
#調用
add(7,8)
運行結果:
7+8=15
4、在函數中,指定返回值
return [表達式] 結束函數,選擇性地返回一個值給調用方,不帶表達式的return相當于返回None。
#調addCopy01()函數,返回兩個數之和的值
def addCopy01(a,b):
return a+b
#調用
result = addCopy01(100,200)
print(result)
print('-------------------------------')
#return 直接結束函數,'函數結束'提示,沒有輸出。
def test_method():
for i in range(10):
print(i)
return # return結束函數 break結束循環
print('函數結束')
#調用
test_method()
運行結果:
300
-------------------------------
0
5、參數類型
①、必需參數
必需參數須以正確的順序傳入函數。調用時的數量必須和聲明時的一樣。調用函數,你必須傳入參數,不然會出現語法錯誤:
#必須傳入,2個參數
def addCopy01(a,b):
return a+b
#調用
addCopy01(100,200)
②、關鍵字參數
關鍵字參數和函數調用關系緊密,函數調用使用關鍵字參數來確定傳入的參數值。使用關鍵字參數允許函數調用時參數的順序與聲明時不一致:
#關鍵字參數:
def printinfo(name, age):
print("名字: ", name)
print("年齡: ", age)
#調用
printinfo(age=50, name="張三")
運行結果:
名字: 張三
年齡: 50
③、默認參數
調用函數時,如果沒有傳遞參數,則會使用默認參數。
#默認參數:
def printinfo(name, age=35):
print("名字: ", name)
print("年齡: ", age)
#調用
printinfo(name="張三",age=50)
print("------------------------")
printinfo(name="張三")
運行結果:
名字: 張三
年齡: 50
------------------------
名字: 張三
年齡: 35
④、不定長參數
有時可能需要一個函數能處理比當初聲明時更多的參數。這些參數叫做不定長參數。
加了星號(*)的參數名,會存放所有未命名的變量參數。如果在函數調用時,沒有指定參數,它就是一個空元組。
#查看不定長參數,傳入的值
def add2(a,*b):
print(a,end="")
print(b)
#調用
add2(1) #1()
add2(1,2) #1(2,)
add2(1,2,3) #1(2, 3)
print("------------------------")
#求和 [不限制幾個參數]
def add3(a,*b):
sum = 0
for i in b:
sum += i
return a+sum
#調用
print(add3(1))
print(add3(1,2))
print(add3(1,2,3))
運行結果:
1()
1(2,)
1(2, 3)
------------------------
1
3
6
python 使用 lambda 來創建匿名函數。所謂匿名,意即不再使用 def 語句來定義一個函數。
①、lambda 函數的語法只包含一個語句
②、命名空間:python中存放變量名的空間或字典!
注意:
①、lambda 只是一個表達式,函數體比 def 簡單很多。
②、 lambda的主體是一個表達式,而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
③、 lambda 函數擁有自己的命名空間,且不能訪問自己參數列表之外或全局命名空間里的參數。
sum = lambda a,b:a+b
print(sum(10,20))
運行結果:
30
7、參數傳遞問題
①、對象是真實存在的數據,類型屬于對象,變量是沒有類型的。
number = [1,2,3,4,5,6]
info = "Hello"
解釋:[1,2,3,4,5,6] 是 List 類型,“Hello” 是 String 類型,而變量number與info是沒有類型,它僅僅是一個對象的引用(一個指針),可以是指向 List 類型對象,也可以是指向 String 類型對象
②、可更改與不可更改對象
python 中一切都是對象,傳遞參數分為傳不可變對象和傳可變對象
python 中,string字符串,tuple元組,和numbers整數,是不可更改的對象,而list列表,dict字典等則是可以修改的對象。
使用函數的時候,如果傳入參數是不可變的,那么參數里面對數據做的任何操作,都不會對函數外面的數據帶來影響。不可變類型:如fun(a),傳遞的只是a 的值,沒有影響a對象本身。比如在 fun(a)內部修改 a 的值,只是修改另一個復制的新對象,不會影響 a 本身。
# 不可變類型參數傳遞
num = 1
def change(num):
num = 3 #沒有對num操作,重新定義了一個num
print(num)
change(num)
print(num) #不會影響函數外,num本身的值
print('----------------------')
# 返回值例外
num2 = 1
def change(num2):
print(num2) # 1
num2 = 3
return num2
num_result = change(num2)
print(num_result) #返回值例外 3
print(num2) #函數內改變,不影響函數外的不可變對象 1
運行結果:
3
1
----------------------
1
3
1
可變對象類型:如 fun(la),則是將 la 真正的傳過去,在函數內部,修改后,fun外部的la也會受影響
list_num = [1,2]
def change(list_num):
list_num.append(3)
print(list_num) #[1, 2, 3]
change(list_num)
print(list_num) #[1, 2, 3]
運行結果:
[1, 2, 3]
[1, 2, 3]
二:變量作用域
Python 中,程序的變量并不是在哪個位置都可以訪問的,訪問權限決定于這個變量是在哪里賦值的。變量的作用域決定了在哪一部分程序可以訪問哪個特定的變量名稱。
Python的作 用域一共有4種,從小到大分別是:
L (Local) 局部作用域
局部作用域,即函數中定義的變量
局部變量(只能在函數內部使用)
E (Enclosing) 閉包函數外的函數中
嵌套的父級函數的局部作用域,即包含此函數的上級函數的局部作用域,但不是全局的;
G (Global) 全局作用域
全局變量,就是模塊(python文件)級別定義的變量;
定義在函數外的變量
B (Built-in) 內建作用域
系統固定模塊里面的變量,比如int, bytearray等。
總結:以 L –> E –> G –>B 的規則查找,即:在局部找不到,便會去局部外的局部找(例如閉包),再找不到就會去全局找,再者去內建中找,內建中找不到程序報錯
name = str('張三') #python內置的作用域 ->內建作用域
y = 2 #全局 ->全局作用域
def outer():
a = 3 #閉包 -> 閉包
def inner():
b=2 #局部 ->局部作用域
print(a)
inner()
#print(b) #報錯
outer()
#print(a) #報錯
運行結果:
3
1、作用域一
Python 中只有模塊(module),類(class)以及函數(def、lambda)才會引入新的作用域(有作用域的限制);其它的代碼塊(如 if/elif/else/、try/except、for/while等)是不會引入新的作用域的,也就是說這些語句內定義的變量,外部也可以訪問。
# 實例中 msg 變量定義在 if 語句塊中,但外部還是可以訪問的。
if True:
msg = "ok"
print(msg)
# 實例中 msg 定義在函數中,則它就是局部變量,外部不能訪問:
def test():
msg_inner = 'ok'
# print(msg_inner) #報錯,無法訪問局部變量
運行結果:
ok
2、作用域二
①、局部變量:定義在函數內部的變量擁有一個局部作用域,局部變量只能在其被聲明的函數內部訪問。
②、全局變量:定義在函數外的擁有全局作用域, 全局變量可以在整個程序范圍內訪問。
③、調用函數時,所有在函數內聲明的變量名稱都將被加入到作用域中。
total = 0
def sumcopyt(arg1,arg2):
total= arg1+arg2
print("局部變量",total) # 結果是:3而不是0(以 L –> E –> G –>B 的先后規則查找)
return total
sumcopyt(1,2)
print('全局變量',total)
運行結果:
局部變量 3
全局變量 0
3、作用域三
一個不在局部作用域里的變量默認是只讀的,如果試圖為其綁定一個新的值,python認為是在當前的局部作用域里創建一個新的變量,也就是說在當前局部作 用域中,如果直接使用外部作用域的變量,那么這個變量是只讀的,不能修改。
global:通過里面的操作,改變外面的值
name='50'
def change_name():
name='100'
print('局部變量的值:',name)
change_name()
print('全局變量的值:',name) #全局的變量,并沒有修改
print('--------------------------')
name2='50'
def change_name2():
#想讓局部的total和全局的total變為同一個total(通過里面的操作,改變外面的值)
global name2
name2='100'
print('局部變量的值:',name2)
change_name2()
print('全局變量的值:',name2) #全局的變量,已經修改啦
運行結果:
局部變量的值:100
全局變量的值:50
--------------------------
局部變量的值:100
全局變量的值:100
4、作用域四
如果要修改嵌套作用域即閉包函數(enclosing 作用域,外層非全局作用域)中的變量則需要nonlocal關鍵字
def method_01():
a = 1
def method_02():
nonlocal a
a=2
print(a)
method_02()
print(a)
method_01()
運行結果:
2
2
三:Python內置函數
為了提高程序員的開發效率,Python 提供了很多可以直接拿來用的函數。
內容參考:http://www.runoob.com/python3/python3-built-in-functions.html
總結
以上是生活随笔為你收集整理的python基础语言法则_python语言基础3的全部內容,希望文章能夠幫你解決所遇到的問題。
- 上一篇: linux python pymssql
- 下一篇: linux 配置DNS正反区域,Linu