歡迎加我QQ1689458826，一起學習?。?！

每個對象都有類型，python 中最基本的內置數(shù)據(jù)類型：

1. 整型
   整數(shù)，2345,10,50
2. 浮點型
   小數(shù)，3.14 或者科學計數(shù)法 314e-2
3. 布爾型
   表示真假，僅包含：True、False
4. 字符串型
   由字符組成的序列。"攻城獅"，"攻城獅"，"攻城獅"，"攻城獅"

數(shù)字和基本運算符

Python 支持整數(shù)(如：50,520)和浮點數(shù)(如：3.14,10.0, 1.23e2)，我們可以對數(shù)字做如下運算。

數(shù)字和基本運算符

【操作】基本運算符的使用

>>> a = 7/2
>>> a
3.5
>>> a = 7//2
>>> a
3
>>> a = 7%2
>>> a
1
>>> 7%4
3
>>> 2**3
8
>>> 3/0
Traceback (most recent call last):
File "<pyshell#37>", line 1, in <module>
3/0
ZeroDivisionError: division by zero
>>> divmod(10,5)
(2, 0)
>>> divmod(10,3)
(3, 1)

除數(shù)為 0，會產生異常：

>>> 3/0
Traceback (most recent call last):
File "<pyshell#31>", line 1, in <module>
3/0
ZeroDivisionError: division by zero

使用 divmod()函數(shù)同時得到商和余數(shù)：

>>> divmod(13,3)
(4, 1)

divmod()是一個函數(shù)，返回的是一個元組(后續(xù)再詳說)

整數(shù)

Python 中，除 10 進制，還有其他三種進制：
·0b 或 0B，二進制 0 1
·0o 或 0O，八進制 0 1 2 3 4 5 6 7
·0x 或 0X，十六進制 0 1 2 3 4 5 6 7 8 9 a b c d e f
這三種進制可以非常方便的進行“位運算”操作。至于位運算，后續(xù)我會寫一個文章介紹
操作】測試不同進制

>>> 12
12
>>> 0b101
5
>>> 0o19
SyntaxError: invalid syntax
>>> 0o10
8
>>> 0xff
255
>>> 0xf
15
>>> 0x10
16

使用 int()實現(xiàn)類型轉換：

1. 浮點數(shù)直接舍去小數(shù)部分。如：int(9.9)結果是：9
2. 布爾值 True 轉為 1，F(xiàn)alse 轉為 0。 如：int(True)結果是 1
3. 字符串符合整數(shù)格式（浮點數(shù)格式不行）則直接轉成對應整數(shù)，否則報錯。

>>> int("456")
456
>>> int("456abc")
Traceback (most recent call last):
  File "<pyshell#41>", line 1, in <module>
  int("456abc")
ValueError: invalid literal for int() with base 10: '456abc'
>>> int("456.78")
Traceback (most recent call last):
  File "<pyshell#42>", line 1, in <module>
  int("456.78")
ValueError: invalid literal for int() with base 10: '456.78'
>>>

自動轉型：

整數(shù)和浮點數(shù)混合運算時，表達式結果自動轉型成浮點數(shù)。比如：2+8.0 的結果是 10.0

整數(shù)可以有多大？

Python2 中，int 是 32 位，可以存儲從-2147483648 到 2147483647 的整數(shù)（約±
21 億）。Long 類型是 64 位，可以存儲：-2^63--263-1 之間的數(shù)值。
Python3 中，int 可以存儲任意大小的整數(shù)，long 被取消。我們甚至可以存儲下面的
值：

>>> googol = 10**100
>>> googol
1000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000
000

Googol 也是 Google 最初的名字，這也是 Google 最初的含義。
Python3 中可以做超大數(shù)的計算，而不會造成“整數(shù)溢出”，這也是 Python 特別適
合科學運算的特點。

浮點數(shù)

浮點數(shù)，稱為 float。
浮點數(shù)用a*b^10形式的科學計數(shù)法表示。比如：3.14，表示成：314E-2 或者 314e-2。這些數(shù)字在內存中也是按照科學計數(shù)法存儲。

類型轉換和四舍五入

1. 類似于 int()，我們也可以使用 float()將其他類型轉化成浮點數(shù)。
2. 整數(shù)和浮點數(shù)混合運算時，表達式結果自動轉型成浮點數(shù)。比如：2+8.0 的結果是 10.0
3. round(value)可以返回四舍五入的值
   注：但不會改變原有值，而是產生新的值

增強型賦值運算符

運算符+、-、，/、//、*和%和賦值符=結合可以構成“增強型賦值運算符”。
a = a + 1 等價于： a +=1

增強型賦值運算符

時間的表示

計算機中時間的表示是從“1970 年 1 月 1 日 00:00:00”開始，以毫秒（1/1000 秒）進行計算。我們也把 1970 年這個時刻成為“unix 時間點”。
這樣，我們就把時間全部用數(shù)字來表示了。

計算機時間

python 中可以通過 time.time() 獲得當前時刻，返回的值是以秒為單位，帶微秒
（1/1000 毫秒）精度的浮點值。例如：1530167364.8566。

>>> import time
>>> b = int(time.time())
>>> b
1581841251
>>> totalMinutes = b/60
>>> totalMinutes
26364020.85
>>> totalMinutes = b//60
>>> totalMinutes
26364020
>>> totalHours = totalMinutes//60
>>> totalHours
439400
>>> totalDays = totalHours//24
>>> totalDays
18308
>>> totalYears = totalDays//365
>>> totalYears
50
>>> 

【操作】定義多點坐標繪出折線并計算起始點和終點距離

import turtle
import math
#定義多個點的坐標
x1,y1 = 100,100
x2,y2 = 100,-100
x3,y3 = -100,-100
x4,y4 = -100,100
#繪制折線
turtle.penup()
turtle.goto(x1,y1)
turtle.pendown()
turtle.goto(x2,y2)
turtle.goto(x3,y3)
turtle.goto(x4,y4)
#計算起始點和終點的距離
distance = math.sqrt((x1-x4)**2 + (y1-y4)**2)
turtle.write(distance)

結果展示

布爾值

Python2 中沒有布爾值，直接用數(shù)字 0 表示 False,用數(shù)字 1 表示 True。
Python3 中，把 True 和 False 定義成了關鍵字，但他們的本質還是 1 和 0，甚至可以和數(shù)
字相加。

>>> a = True
>>> b = 3
>>> a+b
4

比較運算符

所有比較運算符返回 1 表示真，返回 0 表示假。這分別與特殊的變量 True 和 False 等價。
以下假設變量 a 為 15，變量 b 為 30：

比較運算符

邏輯運算符

邏輯運算符

同一運算符

同一運算符用于比較兩個對象的存儲單元，實際比較的是對象的地址。

同一運算符

is 與 == 區(qū)別：

is 用于判斷兩個變量引用對象是否為同一個，既比較對象的地址。
== 用于判斷引用變量引用對象的值是否相等，默認調用對象的 eq()方法。

整數(shù)緩存問題

Python 僅僅對比較小的整數(shù)對象進行緩存（范圍為[-5, 256]）緩存起來，而并非是所有整數(shù)對
象。需要注意的是，這僅僅是在命令行中執(zhí)行，而在 Pycharm 或者保存為文件執(zhí)行，結果是不一樣
的，這是因為解釋器做了一部分優(yōu)化(范圍是[-5,任意正整數(shù)])。

·總結

1、is 比較兩個對象的 id 值是否相等，是否指向同一個內存地址；
2、== 比較的是兩個對象的內容是否相等，值是否相等；
3、小整數(shù)對象[-5,256]在全局解釋器范圍內被放入緩存供重復使用；
4、is 運算符比 == 效率高，在變量和 None 進行比較時，應該使用 is。
【操作】同一運算符測試

>>> a = 1000
>>> b = 1000
>>> a == b
True
>>> a is b
False
>>> id(a)
46764560
>>> id(b)
46765216
>>> c = 10
>>> d = 10
>>> c is d
True
>>> id(c)
1388831648
>>> id(d)
1388831648

基本運算符
在前面有說到了“+”、“-”、“*”、“/”、“//”、“%”等運算符，這里說一些其他運算符，并進行測試。

其他運算符

1. 比較運算符可以連用，并且含義和我們日常使用完全一致。

>>> a = 4
>>> 3<a<10 #關系運算符可以連用

True

2. 位操作

>>> a = 0b11001
>>> b = 0b01000
>>> c = a|b
>>> bin(c) #bin()可以將數(shù)字轉成二進制表示
'0b11001'
>>> bin(c&b)
'0b1000'
>>> bin(c^b)
'0b10001'
>>> a = 3
>>> a<<2 #左移 1 位相當于乘以 2.左移 2 位，相當于乘以 4
12
>>> a = 8
>>> a>>1 #右移 1 位相當于除以 2.

3. 加法操作
   (1) 數(shù)字相加 3+2 ==> 5
   (2) 字符串拼接 “3”+“2”==> “32”
   (3) 列表、元組等合并 [10,20,30]+[5,10,100] ==>[10,20,30,5,10,100]
4. 乘法操作
   (1) 數(shù)字相乘 32 ==> 6
   (2) 字符串復制 “sxt”3 ==> ”sxtsxtsxt”
   (3) 列表、元組等復制 [10,20,30]*3 ==> [10,20,30,10,20,30,10,20,30]

復合賦值運算符

復合賦值可以讓程序更加精煉，提高效率。

復合賦值運算符

注：與 C 和 JAVA 不一樣，Python 不支持自增(++)和自減(--)

運算符優(yōu)先級問題

如下優(yōu)先級，從高到低。

運算符優(yōu)先級問題

實際使用中，記住如下簡單的規(guī)則即可，復雜的表達式一定要使用小括號組織。

1. 乘除優(yōu)先加減

2. 位運算和算術運算>比較運算符>賦值運算符>邏輯運算符
   【操作】使用 python 表示數(shù)學式

   
   
   數(shù)學式

>>> x = 5
>>> y = 3
>>> w = (5+10*x)/5-13*(y-1)*(a+b)/x+9*(5/x+(12+x)/y)
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    w = (5+10*x)/5-13*(y-1)*(a+b)/x+9*(5/x+(12+x)/y)
NameError: name 'a' is not defined
>>> a = 2
>>> b = 6
>>> w = (5+10*x)/5-13*(y-1)*(a+b)/x+9*(5/x+(12+x)/y)
>>> w
29.4