1. 程式人生 > >python中基本語法

python中基本語法

#輸入語句:
>>> print'100+100=%d' %(100+100)
100+100=200

#輸出語句
>>> name = raw_input('input your name:')
input your name:yinheyi
>>> print('hello,%s' %name)
hello,yinheyi

注意:raw_input()語句接收以後,預設儲存為str格式哦,如果要比較大小的話,記得轉為int型別。

>>> number = raw_input('input a number:')
input a number:
12 >>> type(number) <type 'str'> >>> number = int(raw_input('input a number:')) input a number:12 >>> type(number) <type 'int'>

判斷與迴圈語句:

判斷語句:if…elif…else

>>> if a>= 50:
...     print 'the number is big'
... elif a < 50:
...     print'the number is small
' ... else: ... print "i don't know" ... the number is big

迴圈語句: for…in

>>> sum = 0
>>> for number in range(101):
...     sum = sum + number
... 
>>> print sum
5050

迴圈語句: while

>>> sum = 0
>>> n = 1
>>> while n < 101:
...     sum = sum + n
...     n 
= n + 1 ... >>> print sum 5050

資料型別:列表、元組、字典、set

list: Python內建的一種資料型別是列表。lists是一個有序的集合,可以新增與刪除元素。

生成它是用  []  就可以啦;

呼叫它時,用下標呼叫就可以啦(從0開始);如第一個元素,list[0];倒數第一個,list[-1];

可以用len()函式獲得list元素的個數;

在尾部新增用append(), 中間插入用insert();尾部刪除用pop();指定位置刪除為pop(i);

#定義一個friends的列表
>>> friends = ['xiaoming','ergou','sanmao']
>>> friends
['xiaoming', 'ergou', 'sanmao']
>>> friends[0]
'xiaoming'
>>> friends[-1]
'sanmao'

#新增與刪除
>>> friends.append('dapeng')
>>> friends
['xiaoming', 'ergou', 'sanmao', 'dapeng']
>>> friends.insert(0,'diyi')
>>> friends
['diyi', 'xiaoming', 'ergou', 'sanmao', 'dapeng']

>>> friends.pop()
'dapeng'
>>> friends
['diyi', 'xiaoming', 'ergou', 'sanmao']
>>> friends.pop(2)
'ergou'
>>> friends
['diyi', 'xiaoming', 'sanmao']

#替換
>>> friends[0] = 'wangbadan'
>>> friends
['wangbadan', 'xiaoming', 'sanmao']

元組(tuple):tuple和list非常類似,但是tuple一旦初始化就不能修改。只要記住它不能修改就可以啦。很安全。

用 () 定義啊。

用下標呼叫,即tuple[1];

注意:它定義一個元素的tuple時,一定要這樣寫,如:name = (‘yin’,), 千萬別寫成 name = (‘yin’);

name = ('zhai','yin')
>>> name
('zhai', 'yin')
>>> name[0]
'zhai'
>>> name[-1]
'yin'

字典(dictionary):它就是鍵-值對。如在C++語言中為map的容器。它的特點就是可以快速查詢,需要佔用大量的記憶體,記憶體浪費多。通過key計算位置的演算法稱為雜湊演算法(Hash)。

用 {} 定義dictionary哦;

隨著dictionary的增加,查詢時間不會增加的。

多次對一個key放入value,後面的值會把前面的值沖掉:

可以用  ‘key’in dic 或 dic.get(‘key’)的方法來檢視key是否存在。注意:dict提供的get方法,如果key不存在,可以返回None,或者自己指定的value,返回None的時候Python的互動式命令列不顯示結果。

刪除用: pop(key)。新增時,直接用key值的索引新增就可以的。

注意:ict內部存放的順序和key放入的順序是沒有關係的。

#定義一個dictionary;
score = {'xiaoming':85,'xiaohong':62}
>>> score
{'xiaoming': 85, 'xiaohong': 62}

#新增一個元素;
>>> score['wangdan'] = 85
>>> score
{'xiaoming': 85, 'xiaohong': 62, 'wangdan': 85}

#刪除一個元素;
>>> score.pop('xiaohong')
62
>>> score
{'xiaoming': 85, 'wangdan': 85}

#檢視key是否存在;
>>> 'xiaoming' in score
True

#檢視一個key對應的值;
>>> score.get('wangdan')
不存在時,返回一個自定義的值;
85>>> score.get('hehehe',-1)
-1

set:set和dict類似,也是一組key的集合,但不儲存value。由於key不能重複,所以,在set中,沒有重複的key。set和dict的唯一區別僅在於沒有儲存對應的value,但是,set的原理和dict一樣,所以,同樣不可以放入可變物件。

要建立一個set,需要提供一個list作為輸入集合:

通過add(key)與remove(key)新增與刪除元素;

>>> s = set([1, 2, 3])
>>> s
set([1, 2, 3])

注意,傳入的引數[1, 2, 3]是一個list,而顯示的set([1, 2, 3])只是告訴你這個set內部有1,2,3這3個元素,顯示的[]不表示這是一個list。

重複元素在set中自動被過濾:

>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
set([1, 2, 3])

新增與刪除

>>> s = set([1,2,3])
>>> s
set([1, 2, 3])
>>> s.add('xiaoming')
>>> s
set([1, 2, 3, 'xiaoming'])
>>> s.add(0)
>>> s
set([0, 1, 2, 3, 'xiaoming'])
>>> s.remove(2)
>>> s
set([0, 1, 3, 'xiaoming'])

對於list與tuple的切片操作:

如list[:5]或list[0:5]表示第0,1,2,3,4個索引值;當然也可以為負的如,list[-2:0]等於list[-2:]即倒數第2、倒數第1個數;也可以跳著來哦:list[1:10:2],表示步長為2的。

list=range(100)
#正著切片
>>> list[:10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#負索引切片
 list[-10:]
[90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
#倒著切片
>>> list[10:0:-1]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
>>> list[-1:-10:-1]
[99, 98, 97, 96, 95, 94, 93, 92, 91]
#跳著切片
>>> list[::10]
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
#tuple的切片
>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)
#字串的切片
>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'

它的迭代:

對於list、tuple還有字串都可以用 for…in 進行迭代哦;

而對於dictionary的話,也可以哦,只不過預設情況下,dict迭代的是key。如果要迭代value,可以用for value in d.itervalues(),如果要同時迭代key和value,可以用for k, v in d.iteritems()

那麼,如何判斷一個物件是可迭代物件呢?方法是通過collections模組的Iterable型別判斷:

另外:Python內建的enumerate函式可以把一個list、tuple、字串本身變成索引-元素對,這樣就可以在for迴圈中同時迭代索引和元素本身:

>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整數是否可迭代
False

列表生成式:很牛逼很方便的;它是用來建立list的生成式;我們舉例子看看哈:

生成1-10的list:

>>> range(1,11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

生成 12、22、……102的list:

>>> list = [x*x for x in range(1,11)]
>>> list
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

還可以再選擇一下哦:

>>> [x * x for x in range(1, 11)if x % 2 == 0]
[4, 16, 36, 64, 100]

還可以兩層迴圈的:

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

生成器:

通過列表生成式,我們可以直接建立一個列表。但是,受到記憶體限制,列表容量肯定是有限的。而且,建立一個包含100萬個元素的列表,不僅佔用很大的儲存空間,如果我們僅僅需要訪問前面幾個元素,那後面絕大多數元素佔用的空間都白白浪費了。

所以,如果列表元素可以按照某種演算法推算出來,那我們是否可以在迴圈的過程中不斷推算出後續的元素呢?這樣就不必建立完整的list,從而節省大量的空間。在Python中,這種一邊迴圈一邊計算的機制,稱為生成器(Generator)。

建立方法1:第一種方法很簡單,只要把一個列表生成式的[]改成(),就建立了一個generator:

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x104feab40>

可以通過generator的.next()方法打印出來資料,另外也可以通過迭代哦,基本上我們都選擇for…in迭代方法。

建立方法2:通過特殊函式建立:如果一個函式定義中包含yield關鍵字,那麼這個函式就不再是一個普通函式,而是一個generator。

#這是函式,輸出斐波那契數列
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print b
        a, b = b, a + b
        n = n + 1

#這是generator,也是生成斐波那契數列;
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1

注意:這裡,最難理解的就是generator和函式的執行流程不一樣。函式是順序執行,遇到return語句或者最後一行函式語句就返回。而變成generator的函式,在每次呼叫next()的時候執行,遇到yield語句返回,再次執行時從上次返回的yield語句處繼續執行。

>>> def odd():
...     print 'step 1'
...     yield 1
...     print 'step 2'
...     yield 3
...     print 'step 3'
...     yield 5
...
>>> o = odd()
>>> o.next()
step 1
1
>>> o.next()
step 2
3
>>> o.next()
step 3
5
>>> o.next()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

函式的定義:

使用def語句,依次寫出函式名、括號、括號中的引數和冒號:,然後,在縮排塊中編寫函式體,函式的返回值用return語句返回。

當用return 返回多個值時,返回的其實是一個tuple,即元組。

當一個語句塊是什麼也不做時,請用pass語句,如果為空的話,分出錯的。

如果函式沒有return或者只有單單的一個reuturn時 , 則返回none。

>>> def sum(x, y):
...     sum = x + y
...     return sum
... 
>>> print sum(1,2)
3

函式的引數問題:

函式可以有預設的引數:且函式的預設引數必須指向不變的物件(否則有邏輯錯誤)。

複製程式碼

>>> def sum(x=1, y=2):
...     return x + y
... 
>>> print sum()
3
>>> print sum(5)
7
>>> print sum(y=10)
11

複製程式碼

函式的可變引數:定義可變引數和定義list或tuple引數相比,僅僅在引數前面加了一個*號。在函式內部,引數numbers接收到的是一個tuple,因此,函式程式碼完全不變。但是,呼叫該函式時,可以傳入任意個引數,包括0個引數。另外,Python允許你在list或tuple前面加一個*號,把list或tuple的元素變成可變引數傳進去。

複製程式碼

#可變引數;
>>> def sum(*numbers):
...     sum = 0
...     for num in numbers:
...             sum = sum + num
...     return sum
... 
>>> sum(1,2,3)
6
>>> sum(1,2,3,4,5,6)
21

#把list或tuple元素變為可變引數傳入
>>> list = [1,2,3,4,5,6,7,8]
>>> sum(*list)
36
>>> tuple = (1,3,4,75)
>>> sum(*tuple)
83

複製程式碼

關鍵字引數:它也是可變的,僅僅在引數前面加了兩個*號。這些關鍵字引數在函式內部自動組裝為一個dict,Python允許你dictionary前面加**號,把dictionary元素變成可變引數傳進去。。

複製程式碼

>>> def person(name, age, **other):
...     print 'name:',name,'\n'\
...           'age:',age,'\n'\
...           'other:',other
... 
>>> person('xiaoming',18,sex='boy')
name: xiaoming 
age: 18 
other: {'sex': 'boy'}

複製程式碼

#把dictionar元素引數傳入
>>> dic = {'sex':'boy','tall':174}
>>> person('xiaohong',22,**dic)
name: xiaohong 
age: 22 
other: {'tall': 174, 'sex': 'boy'}

引數可以組合使用:在Python中定義函式,可以用必選引數、預設引數、可變引數和關鍵字引數,這4種引數都可以一起使用,或者只用其中某些,但是請注意,引數定義的順序必須是:必選引數、預設引數、可變引數和關鍵字引數。

另外,對於對於任意函式,都可以通過類似func(*list, **dictionary)的形式呼叫它,無論它的引數是如何定義的。

對於遞迴函式:優點是定義簡單,邏輯清晰。但是有一個問題,使用遞迴函式需要注意防止棧溢位。在計算機中,函式呼叫是通過棧(stack)這種資料結構實現的,每當進入一個函式呼叫,棧就會加一層棧幀,每當函式返回,棧就會減一層棧幀。由於棧的大小不是無限的,所以,遞迴呼叫的次數過多,會導致棧溢位。

高階函式:就是能接收其它函式作為引數的函式。

複製程式碼

#定義一個簡單的高階函式:
>>> def add(x, y, f):
...     return f(x) + f(y)

#定義一個函式:
 def square(x):
...     return x * x

#呼叫高階函式:
>>> add(5,6,square)
61

複製程式碼

map()高階函式

map()函式接收兩個引數,一個是函式,一個是序列,map將傳入的函式依次作用到序列的每個元素,並把結果作為新的list返回。

複製程式碼

#map函式分別用函式對傳入的元素做處理哦
>>> def square(x):
...     return x*x
>>> list = range(1,6)
>>> list
[1, 2, 3, 4, 5]
>>> map(square, list)
[1, 4, 9, 16, 25]

複製程式碼

reduce()高階函式

reduce把一個函式作用在一個序列[x1, x2, x3...]上,這個函式必須接收兩個引數,reduce把結果繼續和序列的下一個元素做累積計算,其效果就是:reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4).

複製程式碼

#看看reduce,把[1, 2, 3, 4, 5] 變為 一個數:12345
>>> list
[1, 2, 3, 4, 5]
>>> def func(x, y):
...     return x*10 + y
... 
>>> reduce(func, list)
12345

複製程式碼

filter()高階函式:

filter()函式用於過濾序列。接收一個函式和一個序列。filter()把傳入的函式依次作用於每個元素,然後根據返回值是True還是False決定保留還是丟棄該元素。

def is_odd(n):
    return n % 2 == 1

filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])
# 結果: [1, 5, 9, 15]

排序演算法:sorted()函式

通常規定,對於兩個元素xy,如果認為x < y,則返回-1,如果認為x == y,則返回0,如果認為x > y,則返回1,這樣,排序演算法就不用關心具體的比較過程,而是根據比較結果直接排序。

>>> sorted([123,34,654,24,623342,4546,32,0])
[0, 24, 32, 34, 123, 654, 4546, 623342]

另外,它也可以接收一個函式,用於自定義的排序。

複製程式碼

#定義一個倒序
>>> def reversed_cmp(x, y):
...     if x > y:
...         return -1
...     if x < y:
...         return 1
...     return 0
... 

>>> sorted([123,34,654,24,623342,4546,32,0],reversed_cmp)
[623342, 4546, 654, 123, 34, 32, 24, 0]

複製程式碼

返回函式這個變數:可以在一個函式裡面在定義一個一個函式,並返回這個函式名。

內部函式可以引用外部函式的引數和區域性變數,當內部函式名被返回時,外部函式的相關引數和變數都儲存在返回的函式中,這種稱為“閉包(Closure)”的程式結構擁有極大的威力。

來,舉例說明:

複製程式碼

>>> def sum(x, y):
...     def sum1():
...             return x + y
...     return sum1

>>> f = sum(1, 2)
>>> f
<function sum1 at 0x7fab499ec8c0> #可以看出 f 為一個函式變數哦;
>>> f()     #返回這個函式的值;
3

複製程式碼

看下面兩個程式,仔細體會哦:

複製程式碼

>>> def func1():
...     i = 1
...     def func2():
...             return i * i
...     return func2
... 
>>> f = func1()
>>> f()
1

複製程式碼

複製程式碼

>>> def func1():
...     i = 1
...     def func2():
...             return i * i
...     i = 5
...     return func2
... 
>>> f = func1()
>>> f()
25

複製程式碼

看到了吧,返回的函式沒有立刻執行,而是直到呼叫了f()才執行。當執行時,i 變為了5。

返回閉包時牢記的一點就是:返回函式不要引用任何迴圈變數,或者後續會發生變化的變數。

我們可以這樣做,讓它保證不受影響,這樣做的原因是因為已經把函式func2()的引數綁定了哦,為1。

複製程式碼

>>> def func1():
...     i = 1
...     def func2(i):
...             def func3():
...                     return i * i
...             return func3
...     return func2(i)
...     i = 5
... 
>>> f = func1()
>>> f()
1

複製程式碼

匿名函式:有些時候,不需要顯式地定義函式,直接傳入匿名函式更方便。

關鍵字lambda表示匿名函式,匿名函式有個限制,就是隻能有一個表示式,返回值就是該表示式的結果。

下面見識一下匿名函式哦:

>>> list = range(1,11)
>>> list
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> map(lambda x: x*x ,list)
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

函式裝飾器:

就是說,我們想對一個函式進行增強一些功能,但是呢,我們又不修改函式的定義,這種在程式碼執行期間動態增加功能的方式,稱之為“裝飾器”(Decorator)。本質上,decorator就是一個返回函式的高階函式。

一些額外的知識:函式物件都有一個__name__的屬性,可以得到函式名字。如:

複製程式碼

>>> def hello():
...     print 'hello,world'
... 
>>> f = hello
>>> hello.__name__
'hello'
>>> f.__name__
'hello'

複製程式碼

看看下面實現的decorator:

複製程式碼

#定義了一個函式的decorator;
def f1(func):
        def f2(x, y): 
                print 'i am using decorator'
                print 'call %s ' %func.__name__
                return func(x, y)
        return f2


#用 @ 語法,把decorator置於函式的定義處,即邦定函式哦;
@f1
def sum(x,y):
        return x + y 

#呼叫它:
print sum(2,3)

複製程式碼

輸出為:

i am using decorator
call sum 
5

這是的@f1,就相當於 sum = f1(sum);

再看一個哈,我們可以給decorator傳入一定的引數哦:

複製程式碼

# 定義一個函式的decorator;
def f1(name):
        def f2(func):
                def f3(x, y): 
                        print 'my name is %s' %name
                        print 'i am using decorator'
                        print 'call %s ' %func.__name__
                        return func(x, y)
                return f3
        return f2

#用 @語法哦;
@f1('yinheyi')
def sum(x,y):
        return x + y 

#呼叫它
print sum(2,3)

複製程式碼

輸出為:

my name is yinheyi
i am using decorator
call sum 
5

這是的@f1('yinheyi') 相當於 sum = f1('yinheyi') (sum);

對於上面的操作還有一些小問題:

上面的sum.__func__ 變為了f3,而不再是sum。所以:需要把原始函式sum的__name__等屬性複製到f3函式中,否則,有些依賴函式簽名的程式碼執行就會出錯。

Python內建的functools.wraps就是幹這個事的,所以, 在加入這個一句就可以啦:具體如下:

複製程式碼

# 新增這個庫
import functools

def f1(name):
        def f2(func):
                @functools.wraps(func)    #加入這個一個語句哦;
                def f3(x, y): 
                        print 'my name is %s' %name
                        print 'i am using decorator'
                        print 'call %s ' %func.__name__
                        return func(x, y)
                return f3
        return f2


@f1('yinheyi')
def sum(x,y):
        return x + y 
print sum(2,3)
print 'the name of sum is \'%s\'' %sum.__name__

複製程式碼

輸出為:

my name is yinheyi
i am using decorator
call sum 
5
the name of sum is 'sum'

偏函式:functools.partial幫助我們建立一個偏函式。它的作用為:把一個函式的某些引數給固定住(也就是設定預設值),返回一個新的函式,呼叫這個新函式會更簡單。

舉例說明,如int()函式,它可以把字串轉換為整數,加外,它還提供了額外的base引數,如果傳入base引數,就可以做N進位制的轉換。如:

int('12345', base=8)
5349

當我們想假設要轉換大量的二進位制字串,每次都傳入int(x, base=2)非常麻煩,於是,我們想到,可以定義一個int2()的函式,預設把base=2傳進去:

def int2(x, base=2):
    return int(x, base)

functools.partial就是幫助我們建立一個偏函式的,不需要我們自己定義int2(),可以直接使用下面的程式碼建立一個新的函式int2

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85

所以,簡單總結functools.partial的作用就是,把一個函式的某些引數給固定住(也就是設定預設值),返回一個新的函式,呼叫這個新函式會更簡單。

注意到上面的新的int2函式,僅僅是把base引數重新設定預設值為2,但也可以在函式呼叫時傳入其他值:

>>> int2('1000000', base=10)
1000000

模組:在Python中,一個.py檔案就稱之為一個模組(Module)。

為了避免模組名衝突,Python又引入了按目錄來組織模組的方法,稱為包(Package)。例如兩個名不hello.py的模組分別在china的包和school裡的包裡,然後呢,現在它們的名字分別為:china.hello與school.hello, 這樣就不衝突了吧。

每一個包目錄下面都會有一個__init__.py的檔案,這個檔案是必須存在的,否則,Python就把這個目錄當成普通目錄,而不是一個包。

自己寫一個模組:(主要學習它的格式),建立一個hello.py的檔案,內容如下:

複製程式碼

1 #!/usr/bin/python                                                     
  2 # -*- coding: utf-8 -*-
  3 
  4 'this is a hello module, i am coming '
  5 __author__='yinheyi'
  6 
  7 import sys
  8 
  9 def test():
 10         args = sys.argv
 11         if len(args) == 1:
 12                 print 'hello,world'
 13                 print '你好,世界!'
 14         elif len(args) == 2:
 15                 print 'hello,%s' % args[1]
 16         else:
 17                 print '你的引數個數不對啊,我的哥!'
 18 if __name__== '__main__':
 19         test()

複製程式碼

第2行註釋表示.py檔案本身使用標準UTF-8編碼;

第4行是一個字串,表示模組的文件註釋,任何模組程式碼的第一個字串都被視為模組的文件註釋;

第5行使用__author__變數把作者寫進去,這樣當你公開原始碼後別人就可以瞻仰你的大名;

注意:

if __name__=='__main__':
    test()

當我們在命令列執行hello模組檔案時,Python直譯器把一個特殊變數__name__置為__main__,而如果在其他地方匯入該hello模組時,則不會置為__main__, 所以我們可以直接執行這個模組哦,用於執行測試。

給模組起一個別名:

import 模組名 as 別名

模組內的變數與函式的作用域:

在一個模組中,我們可能會定義很多函式和變數,但有的函式和變數我們希望給別人使用,有的函式和變數我們希望僅僅在模組內部使用。在Python中,是通過_字首來實現的。

正常的函式和變數名是公開的(public),可以被直接引用,比如:abcx123PI等;

類似__xxx__這樣的變數是特殊變數,可以被直接引用,但是有特殊用途,比如上面的__author____name__就是特殊變數,hello模組定義的文件註釋也可以用特殊變數__doc__訪問,我們自己的變數一般不要用這種變數名;

類中,__xxx這樣的函式或變數就是非公開的(private),即有__開頭的名字;

模組的搜尋路經:預設情況下,Python直譯器會搜尋當前目錄、所有已安裝的內建模組和第三方模組,搜尋路徑存放在sys模組的path變數中。

如果我們要新增搜尋目錄,有兩種方法,

一是直接修改sys.path,這種方法在退出python後,會失效的。

>>> import sys
>>> sys.path.append('你自己的路經')

二是設定環境變數PYTHONPATH.可以在.bashrc裡新增的,如,export PYTHONPATH = ‘目錄‘:$PYTHONPATH

使用__future__模組:比如當我們是python2.7時,而我們想使用python3.4的python的功能時,怎麼辦呢?我們可以從

__future__模組裡,匯入我們想要用的功能。如除法:

複製程式碼

#這是在python2.7中的
>>> 5/3
1
#匯入新的;
>>> from __future__ import division
>>> 5/3
1.6666666666666667

複製程式碼

面向物件的程式設計:它就是把一個物件作為基本單元,這個物件裡有資料,也有對資料的操作方法啦。你看看C語言中,是不是以函式 為單元呢??這就是差別。例如一個水杯,它的元素就是水,它可以的操作有加水,倒水等。

面向物件程式設計的過程很簡單,首先建立一個類(其實,我認為就是一個數據型別啦,如int),然後再建立這個類的物件就可以啦。就好像你定義了一個汽車,然後,根據你的定義造出汽車的例項就可以啦。

類的定義,舉個例子:

複製程式碼

#這是從 最根類繼承的,舊的方式定義Python類允許不從object類繼承,但這種程式設計方式已經嚴重不推薦使用。任何時 候,如果沒有合適的類可以繼承,就繼承自object類。 
7 class Car(object):   
  8 #定義一個含有的屬性啦;
  9         color_ = ''
 10         weight_ = 0
 11         __wheel_ = 4  #可以通過__開頭開定義私有的屬性;
 12 #定義它的方法;
 13         def __init__(self, color, weight, wheel):
 14                 self.color_ = color
 15                 self.weight_ = weight
 16                 self.__wheel_ = wheel
 17         def get_color(self):
 18                 return self.color_
 19         def get_weight(self):
 20                 return self.weight_