python自定义函数func_python自定义函数与面向对象
前言
python的最大特點就是dynamically typed就是動態類型，不像java需要定義數據類型
引入
先從一段代碼引入：
1
2
3
4
5
6
7
8
9
10class Dog():
def __init__(self,name,age):
self.name=name
self.age=age
def getName(self):
return self.name
dog=Dog('name',16)
print(dog.getName())
別急，我們先學習下py的函數，這個形式跟C以及java等語言有點不一樣。跨度有點大，對于剛接觸來說，我們需要對比一下。
自定義函數
先來看一個例子
1
2
3
4
5def my_func(message):
print('Got a messag: {}'.format(message))
my_func('hello world')
#這里其實我有個地方不是很懂，不過大約能夠知道什么意思，就是{}用來占位，記得在java中log常常這么用
大致形式
1
2
3def 函數名(參數):
處理
return/yeild
與其他語言不一樣的是，def是可執行語句，即函數被調用前，都是不存在的，直到被調用的時候才會創建一個新的函數對象，并賦予其名字
對于以上這段話不理解的我們需要對比以下代碼
1
2
3
4
5
6
7
8
9
10
11
12
13
14hello()
def hello():
print('hello')
return
#報錯，在主程序里，函數要先于調用前的定義
def my_func():
hello()
return
def hello():
print('hello')
return
my_func()
#正常運行，因為def是可執行語句，在調用的時候都不存在，但是我們必須保證調用前都已經聲明定義了
注：我們先有個全局的概念，然后我們在看一下細節
我們深入來看一個代碼
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15def my_func(l):
if not isinstance(l,list):
print('what you input is not a list')
return
if len(l)==0:
print('waht you input is empty')
return
largest=l[0]
for item in l:
if item>largest:
largest=item
print('the largest item in l is {}'.format(largest))
return
my_func([8,-1,0,2])
多態
看到這個我真的哭了，這里的多態完全跟java不同
1
2
3
4
5
6
7def my_sum(a,b):
print(a+b)
return
my_sum(1,2)
my_sum([1,2],[3,4])
my_sum('hello','world')
#對于這種來什么就接受什么的函數，必要時需要在前面進行類型檢查
函數變量的作用域1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27MAX_VALUE=100
def test1(value):
global MAX_VALUE
MAX_VALUE=value
print(MAX_VALUE)
return
def test2(value):
MAX_VALUE=value
print(MAX_VALUE)
return
def test3():
print(MAX_VALUE)
return
test3()
test2(1)
test3()
test1(1)
test3()
----
輸出結果：
100
1
100
1
1
分析一下：
函數內部默認為局部變量，即當函數調用結束后(return)，該變量會被收回，并且不能夠被訪問
Python的全局變量定義在主程序中
函數可以調用全局變量，如果用更改全局變量的時候需要 global關鍵字，這里并不是重新創建一個新的變量，而是告訴Python 解釋器，這里的變量就是之前定義的全局變量
如果函數內部的變量名與主程序的變量名重名，那么局部變量將覆蓋全局變量
現在我們基本上了解了python的函數基本規則，我們回到類
1
2
3
4
5
6
7
8
9
10class Dog():
def __init__(self,name,age):
self.name=name
self.age=age
def getName(self):
return self.name
dog=Dog('name',16)
print(dog.getName())
在這里我們對比java的dog類如何去定義
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17public class Dog{
private String name;
private int age;
Dog(String name,int age){
this.name=name;
this.age=age;
}
String getName(){
return this.name;
}
public static void main(String...ags){
Dog dog=new Dog("name",16);
System.out.println(dog.getName());
}
}
這兩段代碼執行的效果是一樣的。
區別：
python不需要提前聲明的類的屬性，因為不要指明屬性的數據類型
Python的構造函數不是以類名，雖然調用的時候是以類名，說明在聲明定義該類的對象的時候，會自動調用Init函數
注意到python的每個函數里面都有一個變量self，但是在調用的時候又不需要傳入該參數，你可以看到這個self的作用跟this的作用差不多，只不過在python中必須使用這個self,在每一個類的方法中，self總是指向當前的實例，在init函數中self指向的最新被創建的對象，在其他函數中，指向調用該方法的對象
1
2
3
4
5
6
7
8
9
10
11
12
13
14class Dog():
def __init__(self,name,age):
self.__name=name
self.age=age
self.__sex='boy'
def getName(self):
return self.__name
dog=Dog('name',16)
dog.__name='Name'
print(dog.__name)
print(dog.getName())
print(dog.__sex)
注：在一次被python的數據定義給坑了
首先我們注意到java里面數據是由private屬性的，那么在python中默認以兩個下劃線表示該屬性為私有屬性，不可被對象之間調用
但是如果dog.__name記住這里的name屬性不是該類的屬性，而是你給dog這個變量重新定義的一個，與類里定義的不同
接著我們深入了解面向對象里面的細節，先來看一下下面這段代碼
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28class Dog():
MAX_AGE=16
def __init__(self,name,age):
self.name=name
self.age=age
@classmethod
def newName(cls,name):
cls.name=name
return
def getName(self):
return self.name
@staticmethod
def get_MAX_AGE(age):
if age
print("the dog age is {}".format(age))
return
else:
print('the maxage is {}'.format(Dog.MAX_AGE))
return
dog=Dog('NAME',14)
print(dog.getName())
dog.newName('name')
print(dog.getName())
dog.get_MAX_AGE(16)
第一個MAX_AGE是類中定義的常量，可以通過self.MAX_AGE或者Entity.MAX_AGE調用
注意到 @classmethod和@staticmethod 我們已經將類中的函數區別開來了，首先是classmethod類函數，能夠動態訪問或者修改對象的屬性，其第一個參數一般為cls，最常用的功能是實現不用的init構造函數(好吧，上述代碼不具有參考意義) ，@staticmehod是靜態函數，可以用來做一些簡單獨立的任務，像什么測試等等，最后就是成員函數，是最正常的函數，不需要任何聲明，第一個self代表當前對象的引用
寫到最后
這樣，已經大致的會寫python的類了，但是面向對象里面還有個重要的思想就是繼承。不過這個留到后面來深入。當前我的目標就是對python基礎有個全貌的了解。
總結
以上是生活随笔為你收集整理的python自定义函数func_python自定义函数与面向对象的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： php扩展返回字符数组,PHP扩展之数组
- 下一篇： sap 一代增强_在SAP故乡，感受“边