Python基礎語法(三) 1. 數值型數據結構 1.1 要點 在之前的博客也有提到,數值型數據結構在這裡就不過多介紹了。在這裡提及一些需要知道的知識點。 int、float、complex、bool都是類,1\3.14\2+3j都對象(即實例)。這也符合Python一切皆對象的原則。 int: 在 ...
Python基礎語法(三)
1. 數值型數據結構
1.1 要點
在之前的博客也有提到,數值型數據結構在這裡就不過多介紹了。在這裡提及一些需要知道的知識點。
- int、float、complex、bool都是類,1\3.14\2+3j都對象(即實例)。這也符合Python一切皆對象的原則。
- int: 在Python3中,int就是長整型,理論上支持無限大的數字,但是受限於記憶體區域的大小。
- float: 由整數部分和小數部分組成。支持十進位和科學計數法表示。只有雙精度型。浮點型往往不能精確表示一個數,比如π這樣的無理數,它只能儘量靠近。
bool:int的子類,也就是說int有的特性它也有,可以跟整型進行計算。僅有兩個實例True、False,對應1和0。
1.2 類型轉換
int(x)
:返回一個整數float(x)
:返回一個浮點數complex(x)
complex(x,y)
:返回一個複數bool(x)
:返回一個布爾值,在前面的Python基礎語法(二)中的3.2.2裡面已經提及,這裡不再贅述。
num1 = 1234 # 一個整數
num2 = 3.14159 # 一個浮點數
print(float(num1)) # 整數轉浮點數
print(int(num2)) # 浮點數轉整數
print(complex(num1)) # 整數轉複數
print(bool(num2)) # 整數轉布爾值
---------------------------------------
1234.0
3
(1234+0j)
True
1.3 進位轉換
bin(x)
:返回一個二進位數otc(x)
:返回一個八進位數hex(x)
:返回一個十六進位數註意,返回的是一個字元串,不能當做數字使用
print(bin(10))
print(oct(10))
print(hex(20))
-------------
0b1010
0o12
0x14
1.4 數字處理相關函數
1.4.1 取整
在處理數字時,往往需要對數字進行取整或者四捨五入等操作,這時候可以用math庫來對數據進行處理
import math
print(math.floor(2.5)) # math.floor()函數向下取整
print(math.ceil(2.5)) # math.ceil()函數向上取整
print(round(2.51)) # round()函數四舍六入,註意,是四舍六入
print(round(2.5))
print(round(2.4))
----------------------
2
3
3
2
2
關於round()很多同學會覺得奇怪,為什麼是四舍六入,我們平時不是四捨五入的嗎?這裡,是因為在Python3的文檔中規定了小數距離哪個數更近就往哪邊取整,至於0.5,就向偶數取整。有關於這個函數的說明可以點擊這裡查看。建議儘量避免使用這個函數,免得出問題。
1.4.2 最大值與最小值
在一組數中,我們可能需要取最大值或者最小值,使用max()函數可以取最大值,min()函數取最小值。
list = [1,3,2,9,6,4,5,0]
print(min(list)) # min()函數取最小值
print(max(list)) # max()函數取最大值
--------------------------------------
0
9
1.4.2 特殊數值
有時候我們需要定義一些特殊值進行計算,比如π、常數e等等。
import math
print(math.pi) # math.pi返回π的近似值
print(math.e) # math.e返回常數e的近似值
---------------------
3.141592653589793
2.718281828459045
1.5 類型判斷
- type(obj),返回obj的類型,不是字元串
- isinstance(obj, classinfo),返回布爾值
首先介紹type()函數,它返回的是數據類型
a = 5
b = 'hello'
print(type(a))
print(type(b))
--------------
<class 'int'>
<class 'str'>
那麼如何做類型判斷呢?請看下麵例子
a = 5
b = 'hello'
if type(a)==int:
print(True)
if type(b)==str:
print(True)
-----------------
True
True
isinstance(obj,classinfo)
用作判斷obj(對象或實例)是否等於classinfo(直接或間接類名、基本類型或者由它們組成的元組)。
>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False
>>> isinstance (a,(str,int,list)) # 是元組中的一個返回 True
True
isinstance() 與 type() 區別:
- type() 不會認為子類是一種父類類型,不考慮繼承關係。
- isinstance() 會認為子類是一種父類類型,考慮繼承關係。
如果要判斷兩個類型是否相同推薦使用 isinstance()。
2 列表list
- 一個隊列,一個排列整齊的隊伍,它是有序的。
- 列表內的個體稱為元素item,由若幹個元素有序地排列組成列表。
- 元素可以是任意對象(數字、字元串、對象、列表等)
- 列表內元素有順序,可以使用索引index,索引從0開始
- 線性的數據結構(點擊查看詳情)
- 使用[]表示
- 列表是可變的
- 列表不能一開始就定義大小
列表是結合順序表和鏈表的一種動態類型
2.1 初始化
定義一個新的空的列表,有兩種方法yidong
list1 = [] # 這種方法更常用
list2 = list() # 這個list()就是list類,在幫助文檔中有說明
註意:在列表中不能一開始就定義列表大小,但是在其他語言中,往往建議初始化就要定義大小,這和語言的優化策略有關。
使用help()函數可以查看內置的幫助文檔,這裡摘取help(list)
一部分,下麵的魔術方法暫時忽略。
Help on class list in module builtins:
class list(object)
| list(iterable=(), /)
|
| Built-in mutable sequence. # 這說明瞭list是一種Python內置的可變的隊列數據結構
|
| If no argument is given, the constructor creates a new empty list. # 如果沒有接收到參數,構造器建立一個新的空列表
| The argument must be an iterable if specified.# 如果指定參數,它必須是一個可迭代的對象,比如range(1,5)
|
| Methods defined here:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return key in self.
這裡演示指定一個可迭代對象為參數
list1=list(range(1,5))
print(list1)
--------------------
[1, 2, 3, 4]
如果給一個已經存在的列表賦值新的元素,那麼它之前的元素就回收了,回收機制也就是之前提過的GC機制
2.2 索引訪問
- 索引(index)也叫作下標,相當於一個目錄
- 正索引:從左至右,從0開始,為列表中每一個元素編號
- 負索引:從右到左,從-1開始
- 正負索引不可以超界,否則引發異常IndexError
- 為了方便理解,可以認為列表是從左至右排列的,左邊是頭部,右邊是尾部,左邊是上界,右邊是下界
列表通過索引訪問,list[index]
index就是索引,使用中括弧訪問
list1 = [5,1,'h',3.2,[1,2]] #列表內的元素可以是任意對象
print("list1的第1號元素是"+list1[1]) # 利用索引查找元素
------------
list1的第1號元素是1
2.3 列表查詢
index(value, start=0, stop=len(string))
- 通過值value,從指定區間查找列表內的元素是否匹配
- 匹配第一個就立即返回索引
- 匹配不到就拋出異常ValueError
list1= ['a', 'b', 'c', 'c', 'd', 'e']
list1.index('c') # 查找list1中第一個'c'元素的索引值
>>> 2
list1.index('c',3) # 查找list1中從索引值3開始找到的第一個'c'元素的下標
>>> 3
list1.index('c',3, 4) # 查找list1中從索引值3開始到索引值4結束,找到的第一個'c'元素的下標
list1.index('c',4) # 查找list1中從索引值4開始找到的第一個'c'元素的下標
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-3-4a6e298ce585> in <module>
2 list1.index('c')
3 list1.index('c',3)
----> 4 list1.index('c',4)
ValueError: 'c' is not in list
count(value)
:返回列表中匹配value的次數
list1= ['a', 'b', 'c', 'c', 'd', 'e']
list1.count('c')
>>> 2
len(list)
:返回列表list長度
list1= ['a', 'b', 'c', 'c', 'd', 'e']
len(list1)
>>> 6
2.4 列表元素修改
- 索引訪問修改
- list(index) = value
- 索引不能超界
list1= ['a', 'b', 'c', 'c', 'd', 'e'] list1[1]='f' print(list1) >>> ['a', 'f', 'c', 'c', 'd', 'e']
2.5 列表增加、插入元素
- append(obj) -> None
- 列表尾部追加元素,返回None
- 返回None就意味著沒有新的列表產生,就地修改
- 時間複雜度是O(1)
list1= ['a', 'b', 'c', 'c', 'd', 'e']
list1.append('f')
print(list1)
>>> list1= ['a', 'b', 'c', 'c', 'd', 'e', 'f']
- insert(index, object) -> None
- 在指定的索引index處插入元素object
- 返回None就意味著沒有新的列表產生,就地修改
- 時間複雜度為O(n)
- 索引超越上界,在尾部追加,超越下界,在頭部追加
list1= ['a', 'b', 'c', 'c', 'd', 'e']
list1.insert(1, 'f') # 在索引1處插入'f'元素,原來索引1處的元素的索引位置統統往後挪
print(list1)
>>> ['a', 'f', 'b', 'c', 'c', 'd', 'e']
append()和insert()都可以修改列表,但是append()比較常用,運行效率也比較快,而insert()則不太常用,一方面容易打亂原有的元素所在索引位置,另一方面運行效率不高,在列表中間插入一個元素會導致其後面的元素在記憶體中的位置都要挪動。
- extend(iterable) -> None
- 將可迭代對象的元素追加進來,返回None
- 返回None就意味著沒有新的列表產生,就地修改
list1=['a', 'b', 'c']
list2=['d', 'e']
list1.extend(list2)
print(list1)
>>> ['a', 'b', 'c', 'd', 'e']
- + -> list
- 連接操作,將兩個列表連接起來
- 產生新的列表,原列表不變
- 本質上調用的是__add__()方法
list1=['a', 'b', 'c']
list2=['d', 'e']
list3 = list1 + list2
print(list3)
>>> ['a', 'b', 'c', 'd', 'e']
- * -> list
- 重覆操作,將本列表元素重覆n次,返回新的列表
list1=['a', 'b', 'c']
list2 = list1 * 3
print(list2)
>>> ['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
2.6 列表刪除元素
- remove(value) -> None
- 從左到右查找第一個匹配value的值,移除這個值
- 就地修改
- 效率和insert()類似
- pop(index) -> item
- 不指定索引index,就從列表尾部彈出一個元素
- 指定索引index,就從索引處彈出一個元素
- clear() -> None
- 清除列表所有元素,剩下一個空列表
list1=['a', 'b', 'c', 'd', 'e']
list1.remove('a')
print(list1)
>>> ['b', 'c', 'd', 'e']
item = list1.pop()
print(list1)
>>> ['b', 'c', 'd']
print(item)
>>> e
list1.clear() # 清空list1
clear()操作會觸發gc垃圾回收機制,如果在伺服器繁忙運行的時候,突然大規模記憶體需要gc垃圾回收,這時運行效率就會被拉低。
2.7 列表其他操作
- reverse() -> None
- 將列表元素反轉,返回None
- 就地修改
list1=['a', 'b', 'e', 'd', 'c']
list1.reverse()
print(list1)
>>> ['c', 'd', 'e', 'b', 'a']
- sort(key=None, reverse=False) -> None
- 對列表元素進行排序,就地修改,預設升序
- reverse為True,反轉,降序
- key一個函數,指定key如何排序,如
list.sort(key=functionname)
list1=['a', 'b', 'e', 'd', 'c']
list1.sort()
print(list1)
>>> ['a', 'b', 'c', 'd', 'e']
------------------------------------
# 獲取列表的第二個元素
def takeSecond(elem):
return elem[1]
# 列表
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
# 指定第二個元素排序
random.sort(key=takeSecond)
# 輸出類別
print ('排序列表:', random)
>>> 排序列表:[(4, 1), (2, 2), (1, 3), (3, 4)]
- in
[3,4] in [1, 2, [3, 4]]
,返回布爾值,可用作判斷for x in [1, 2, 3, 4]
在Python基礎語法(一)有提及,可以回顧一下