Python 3.6.1 (default, May 31 2017, 18:02:43)

[GCC 4.8.5 20150623 (Red Hat 4.8.5-11)] on linux

Type "help", "copyright", "credits" or "license" for more information.

>>> 1 / 2

0.5

整除使用雙斜杠。python 2 和 python 3 使用方式都一樣

>>> 4 // 6

0

>>> 6 // 3

2

>>> 6 // 5

In [1]: 5.4 // 1.8

Out[1]: 3.0

In [2]: 5.4 // 1.8

Out[2]: 3.0

In [5]: 5.4 % 1.8

Out[5]: 2.220446049250313e-16

雖然Python中浮點數也支持取模運算，但是對浮點數進行運算的時候要格外註意精度的問題。5.4 / 1.8 =3 正好整除，按理應該是0，可是這裏的值不為0，很奇怪？？？

冪運算(乘方) 比一元取反運算優先級要高

In [10]: -2 ** 4

Out[10]: -16

In [11]: (-2) ** 4

Out[11]: 16

In [12]: -(2 ** 4)

Out[12]: -16

-2 ** 4 = -(2 ** 4)

python 2 和 python 3 對於整形數字超出範圍的自動轉換為長整型，不需要過分的關註整型的取值範圍，因為python能夠處理很長的數字。可以手動的數字後面加一個大寫的L就表示這是一個長整型。當然小寫的l也可以只是這裏看起來很像數字1，所以建議使用大寫的L

註意python 2.2 及以前整型值超出範圍會報錯。-2147483648 -- 2147483647

python 2

In [15]: 214748364789987

Out[15]: 214748364789987

In [16]: 214748364789987568978945465 * 4654654167897893212313212312313212313132 + 5213

Out[16]: 999579371218972816926339919579932791950025118287985996498731351593L

In [17]: 4654654167897893212313212312313212313132

Out[17]: 4654654167897893212313212312313212313132L

Python 3

In [11]: 214748364789987

Out[11]: 214748364789987

In [12]: 214748364789987568978945465

Out[12]: 214748364789987568978945465

In [13]: 214748364789987568978945465 * 4654654167897893212313212312313212313132 + 5213

Out[13]: 999579371218972816926339919579932791950025118287985996498731351593

1.2 python 2.x 和 python 3.x print 的區別

python print。python 2 直接輸出即可，python 3 print 變成了函數

python 2

In [18]: print 3 + 3

6

python 3

In [14]: print (2 + 3)

5

In [15]: print 2 + 3

File "<ipython-input-15-b59db2781faf>", line 1

print 2 + 3

^

SyntaxError: Missing parentheses in call to ‘print‘

1.3 python 2.x 和 python 3.x input 的區別

獲取用戶的輸出 python 2 和 Python 3 有區別。input函數接受用戶的輸入python 2輸入的數字會當成整型，而python 3 輸入的數字當成字符型。輸入字符串的時候python 2 需要使用引號括起來，而python 3 可以不用引號括起來

python 2

In [20]: s = input("The meaning of life:")

The meaning of life:45

In [21]: s

Out[21]: 45

In [22]: type(s)

Out[22]: int

In [27]: s = input("The meaning of life:")

The meaning of life:abc

---------------------------------------------------------------------------

NameError Traceback (most recent call last)

<ipython-input-27-e2b30580ea33> in <module>()

----> 1 s = input("The meaning of life:")

<string> in <module>()

NameError: name ‘abc‘ is not defined

In [31]: x = input("x: ")

x: 34

In [32]: y = input("y: ")

y: 23

In [33]: x * y

Out[33]: 782

python 3

In [17]: s = input("The meaning of life:")

The meaning of life:67

In [18]: s

Out[18]: ‘67‘

In [19]: type(s)

Out[19]: str

In [23]: s = input("The meaning of life:")

The meaning of life:‘980‘

In [24]: type(s)

Out[24]: str

In [25]: s = input("The meaning of life:")

The meaning of life:abc

In [26]: s

Out[26]: ‘abc‘

In [33]: y = int(input("y: "))

y: 23

In [34]: x = int(input("x: "))

x: 34

In [35]: x * y

Out[35]: 782

1.4 基礎數學函數

內嵌

pow(x) 求冪函數

abs(x) 求絕對值函數

round(number,ndigits) 對浮點數進行四舍五入

math

floor(x) 向下取整，將小數部分抹掉

ceil(x) 這個函數向上取整，當x為小數的時候去掉小數部分，整數部分+1

sqrt(x) 求平方根

求冪的函數pow()

python 內建函數

pow(x,y[,z]) = x ** y%z

x的y次方所得的值對z取模

In [34]: pow(2,3)

Out[34]: 8

In [35]: 2 ** 3

Out[35]: 8

In [1]: 10 + pow(2,3*5)/3.0

Out[1]: 10932.666666666666

註意python的版本不同精度有所不同，本實驗所使用的兩個版本的精度一致

內建函數 abs 求絕對值

In [1]: abs(-10)

Out[1]: 10

In [2]: abs(10)

Out[2]: 10

round(number,ndigits)

此內建函數：對浮點數進行四舍五入。對number這個浮點數進行四舍五入，ndigits 這個數是精度，必須是整型。可以是負數

兩個版本的區別

python2 輸出始終是浮點數

python 3 輸出始終是整型

python 2 大於0.49999999999999999這個數輸出值位1.0，小於這個輸出值為0.0

python 3 大於0.5000000000000001 輸出值為1，小於這個數輸出值為0

python 2

In [59]: b = "0.49999999999999999"

In [60]: len(b)

Out[60]: 19

In [61]: round(0.49999999999999999)

Out[61]: 1.0

In [62]: round(0.4999999999999999)

Out[62]: 0.0

python 3

In [74]: round(0.50000000000000001)

Out[74]: 0

In [75]: round(0.5000000000000001)

Out[75]: 1

In [72]: b = ‘0.5000000000000001‘

In [73]: len(b)

Out[73]: 18

兩個版本相同。註意這裏應該是個陷阱，四舍五入是逢五進一

列一

In [76]: round(5.005,2)

Out[76]: 5.0

In [77]: round(5.006,2)

Out[77]: 5.01

列二

In [78]: round(5.32,2)

Out[78]: 5.32

In [79]: round(5.325,2)

Out[79]: 5.33

In [83]: round(5.324,2)

Out[83]: 5.32

列三

In [120]: round(1.675,2)

Out[120]: 1.68

In [121]: round(2.675,2)

Out[121]: 2.67

列四

In [123]: round(-1.436,2)

Out[123]: -1.44

In [124]: round(-1.433,2)

Out[124]: -1.43

這兩個例子，第一個例子是逢六進一，第二個例子是逢五進一。還有一個問題需要註意：round(5.001,2) 輸出5.0而不是5.00.這個問題也很奇怪這樣精度就是1而不是2。第三個列子說明有時候是逢五進一，有時候是逢六進一

math.floor() 這個函數需要導入math模塊 import math 才可以使用。

作用：向下取整，將小數部分抹掉，但是註意這裏有個精度的問題

python 2 返回的是浮點數，python 3 返回的是整型

python 2

In [67]: math.floor(32.999999999999999)

Out[67]: 33.0

In [68]: math.floor(32.99999999999999)

Out[68]: 32.0

In [70]: a = ‘32.999999999999999‘

In [71]: len(a)

Out[71]: 18

大於 或等於32.999999999999997，小於33 math.floor返回33.0

大於32，小於或等於32.999999999999996 math.floor 返回32.0

python 3

In [103]: math.floor(32.99999999999999)

Out[103]: 32

In [104]: math.floor(32.999999999999997)

Out[104]: 33

In [105]: b = ‘32.999999999999997‘

In [106]: len(b)

Out[106]: 18

大於 或等於32.999999999999997，小於33 math.floor返回33

大於32，小於或等於32.999999999999996 math.floor 返回32

math.ceil(x) 這個函數向上取整，當x為小數的時候去掉小數部分，整數部分+1

python 2 返回的浮點值

In [121]: math.ceil(4.0000000000000004)

Out[121]: 4.0

In [122]: math.ceil(4.0000000000000005)

Out[122]: 5.0

4.0000000000000005 <= x < 5 math.ceil(x) 返回5.0

4 <= x < 4.0000000000000004 math.ceil(x) 返回4.0

python 3 返回的是整型

In [121]: math.ceil(4.0000000000000004)

Out[121]: 4

In [122]: math.ceil(4.0000000000000005)

Out[122]: 5

4.0000000000000005 <= x < 5 math.ceil(x) 返回5

4 <= x < 4.0000000000000004 math.ceil(x) 返回4

sqrt(x) 對x求平方根，x>0，為整數和浮點數。返回的是浮點數

from math import sqrt 這樣寫可以避免當多個包中有sqrt函數的時候出現混淆的情況，而且這樣就可以不用寫math.這個前綴

In [141]: from math import sqrt

In [142]: sqrt(9)

Out[142]: 3.0

In [143]: sqrt(15)

Out[143]: 3.872983346207417

In [144]: help(sqrt)

In [145]: sqrt(-9)

---------------------------------------------------------------------------

ValueError Traceback (most recent call last)

<ipython-input-145-4abb6f6b3805> in <module>()

----> 1 sqrt(-9)

ValueError: math domain error

使用變量引用的方式來使用函數，這樣的方式更精簡，適用。

In [151]: foo = math.sqrt

In [152]: foo(36)

Out[152]: 6.0

math.sqrt() 這個函數只能處理浮點數，而負數的平方根是虛數。而虛數(以及復數，虛數和實數之和)是完全不同的，這裏需要使用使用另外一個包中函數。cmath.sqrt()

In [138]: import cmath

In [139]: square_root = cmath.sqrt

In [140]: square_root(-36)

Out[140]: 6j

In [141]: square_root(-49)

Out[141]: 7j

註意這裏沒有使用from ... import ... 語句，如果使用 from cmanth import sqrt 那麽不能直接使用sqrt 因為前面有使用 from math import sqrt。所以一般情況下最好還是使用import語句，不要使用from .. import ...。如果不想寫前置，可以使用變量引用的方式簡化函數調用

後綴帶j表示虛數，python本身也支持虛數

In [142]: (1+3j) * (9+4j)

Out[142]: (-3+31j)

1.5input 與 raw_input 的區別

input 和 raw_input 區別

1、input 接受標準的python表達式，如果是字符串需要使用引號括起來。而raw_input 接受任意類型的輸入

2、對於數字來講，raw_input 將數字當做字符串，而input把輸入的數字當做int,float 等類型

列1

In [201]: c = raw_input(3 + 5)

8

In [202]:

In [173]: input(1+3)

4

File "<string>", line unknown

^

SyntaxError: unexpected EOF while parsing

input 直接敲回車會報錯，因為沒有輸入內容

列2

In [205]: raw_input("what number is: ")

what number is: 56

Out[205]: ‘56‘

In [206]: input("what number is: ")

what number is: 56

Out[206]: 56

列3

In [202]: raw_input("what is your name: ")

what is your name: zhangsan

Out[202]: ‘zhangsan‘

In [203]: input("what is your name: ")

what is your name: zhangsan # 要加引號

---------------------------------------------------------------------------

NameError Traceback (most recent call last)

<ipython-input-203-aa9bc168e8eb> in <module>()

----> 1 input("what is your name: ")

<string> in <module>()

NameError: name ‘zhangsan‘ is not defined

In [204]: input("what is your name: ")

what is your name: ‘zhangshan‘

Out[204]: ‘zhangshan‘

input() 本質上還是使用 raw_input() 來實現的，只是調用完 raw_input() 之後再調用 eval() 函數，所以，你甚至可以將表達式作為 input() 的參數，並且它會計算表達式的值並返回它。

除非有特殊需要，一般都不使用input() 這個函數，使用raw_input()

python 3 中沒有raw_input() 這個內嵌函數，只有input() 這個函數

1.6 python 單引號，雙引號，三引號以及單反引號，轉義符”\”的使用

輸出一個字符串，裏面包含一個整型變量

In [208]: temp = 43

In [209]: print ‘The tempreature is ‘ + temp

File "<ipython-input-209-8542dd1140c6>", line 1

print ‘The tempreature is " + temp

^

SyntaxError: EOL while scanning string literal

In [212]: print ‘The tempreature is ‘ + `temp`

The tempreature is 43

In [213]: print ‘The tempreature is ‘ + ‘temp‘

The tempreature is temp

#使用反引號將temp括起來

In [214]: print ‘The tempreature is ‘ + repr(temp)

The tempreature is 43

註意python 3 不支持反引號

print ‘‘‘This is a very long string.

It continues here.

And it‘s not over yet

Hello, world!"

Still here.‘‘‘

字符串中既有雙引號也有單引號，可以考慮使用三個單引號或者3個雙引號將這個字符串括起來。而且三引號支持字符串跨行。同樣也可以用於註釋多行代碼

如果字符串中既有雙引號也有單引號不想使用三引號，那麽單雙引號需要轉義(使用反斜線\)

原始字符串

In [218]: print ‘C:\\Program Files\\fnord\\foo\\bar\\baz\\frozz\\bozz‘

C:\Program Files\fnord\foo\bar\baz\frozz\bozz

In [219]: print r‘C:\\Program Files\\fnord\\foo\\bar\\baz\\frozz\\bozz‘

C:\\Program Files\\fnord\\foo\\bar\\baz\\frozz\\bozz

In [220]: print r‘C:\Program Files\fnord\foo\bar\baz\frozz\bozz‘

C:\Program Files\fnord\foo\bar\baz\frozz\bozz

原始字符串以r開頭，輸入什麽就輸出什麽，一些python特有的字符串在原始字符串哪裏沒有特殊意義。最尾部不能以反斜線結尾

pytho 2

In [221]: print r‘C:\Program Files\fnord\foo\bar\baz\frozz\bozz\‘

File "<ipython-input-221-755d0826b88d>", line 1

print r‘C:\Program Files\fnord\foo\bar\baz\frozz\bozz\‘

^

SyntaxError: EOL while scanning string literal

In [222]: print r‘C:\Program Files\fnord\foo\bar\baz\frozz\bozz‘ + ‘\\‘

C:\Program Files\fnord\foo\bar\baz\frozz\bozz\

python 3

In [151]: print (r‘C:\Program Files\fnord\foo\bar\baz\frozz\bozz\‘)

File "<ipython-input-151-4570817c0148>", line 1

print (r‘C:\Program Files\fnord\foo\bar\baz\frozz\bozz\‘)

^

SyntaxError: EOL while scanning string literal

In [152]: print (r‘C:\Program Files\fnord\foo\bar\baz\frozz\bozz‘ + ‘\\‘)

C:\Program Files\fnord\foo\bar\baz\frozz\bozz\

在原始字符串中單引號，雙引號和三引號可以輸出，註意原始字符串r後面的字符需要用引號括起來，所以開始和結尾處使用的引號中間是不能出現的。如開始和結尾使用單引號擴起來，那麽中間的字符串中就不能包含單引號.除非使用反斜線\，雖然這裏的反斜線\不是轉義，但是可以隔開引號的範圍

python 2

In [235]: print r‘‘‘"hello python",‘hi python‘,‘‘‘

"hello python",‘hi python‘,

In [236]: print r"test,‘‘‘python‘‘‘,hello"

test,‘‘‘python‘‘‘,hello

In [239]: print r"test,‘‘‘python‘‘‘,hello,\"kong\""

test,‘‘‘python‘‘‘,hello,\"kong\"

In [240]: print r"test,‘‘‘python‘‘‘,hello,"kong""

File "<ipython-input-240-ce337e291739>", line 1

print r"test,‘‘‘python‘‘‘,hello,"kong""

^

SyntaxError: invalid synta

python 3

In [154]: print (r‘‘‘Hello python,"test",‘hi python‘.‘‘‘)

Hello python,"test",‘hi python‘.

In [155]: print (r‘‘‘Hello python,"test",‘hi python‘‘‘‘)

File "<ipython-input-155-cd93259d7f5d>", line 1

print (r‘‘‘Hello python,"test",‘hi python‘‘‘‘)

^

SyntaxError: EOL while scanning string literal

In [156]: print (r‘‘‘Hello python,"test",‘hi python‘,\‘‘‘kong\‘‘‘‘‘‘)

Hello python,"test",‘hi python‘,\‘‘‘kong\‘

In [157]: print (r‘‘‘Hello python,"test",‘hi python‘,\‘‘‘kong\‘‘‘.‘‘‘)

Hello python,"test",‘hi python‘,\‘‘‘kong\‘‘‘.

python 默認情況下普通字符串在內部以ascII碼存儲。

Unicode編碼前面加u

In [3]: print u‘Hello, world!‘

Hello, world!

In [4]: u‘Hello, world!‘

Out[4]: u‘Hello, world!‘

註意python3 普通字符串在內部已Unicode編碼存儲

python 基礎教程 筆記 一