python index函数时间复杂度_初学python之以时间复杂度去理解列表常见使用方法
列表list，一個有序的隊列
列表內的個體為元素，由若干個元素按照順序進行排列，列表是可變化的，也就是說可以增刪
list定義
常用的列表定義方式： 使用[] 或者 a = list()
取數列表可以用range()
列表查詢方法
index
index =索引，以0開始查找
方法:value，[start,[stop]]
通過對應位置的索引進行查找，找到列表內的元素是否有匹配，如有則返回索引值
匹配到第一個元素則立即返回索引位
有時候從右邊查找更加便利，比如反斜杠/ 從右邊找更加便捷
例：
In [22]: a
Out[22]: [1, 2, 3, 5, 10, 20, 33, 55]
In [23]: a.index(3)
Out[23]: 2
In [24]: a.index(33)
Out[24]: 6
從右向左查找?index(value, [start, [stop]])
從某個值開始查找
In [46]: a.index(33,3)
Out[46]: 6
In [50]:a.index(55,-1)
Out[50]: 7
計算元素出現的次數
In [53]: a = [1,1,1,3,2,11,5,43,1,1]
In [54]: a.count(1)
Out[54]: 5
時間復雜度
計算機科學中，算法的時間復雜度是一個函數，它定性描述了該算法的運行時間。這是一個關于代表算法輸入值的字符串的長度的函數。時間復雜度常用大O符號表述，不包括這個函數的低階項和首項系數。使用這種方式時，時間復雜度可被稱為是漸近的，它考察當輸入值大小趨近無窮時的情況
index和count 方法對應的時間復雜度
數學符號對應 O
O(n)
O(2)
O(1)
n表示多少個元素，意思為有多少個元素就從前到后多少個元素
將所有的元素都遍歷一遍
需要考慮index方法和count方法適用性，是否該用，選型哪個需要考慮
隨著列表數據規模增加而效率下降，如果能做到O1/2/3 這樣則可以很快返回結果
list列表元素修改
對某一項索引位置賦值(修改)
In [59]: a
Out[59]: [1, 1, 1, 3, 2, 11, 5, 43, 1, 1]
In [60]: a[1] = 2
In [61]: a
Out[61]: [1,2, 1, 3, 2, 11, 5, 43, 1, 1]
列表就地修改
對列表本身進行追加元素
lst.append(100)
[1, 2, 3, 2, 2, 5, 6, 100]
append對list進行增加元素，返回一個None
In [71]: lst = [1,2,3,2,2,5,6]
In [72]: a = lst.append(100)
In [73]: type(a)
Out[73]: NoneType
In [74]: a
In [75]: print(a)
None
這里返回值為空
list運算
In [77]: a = [1,2,3]
In [78]: a * 3
Out[78]: [1, 2, 3, 1, 2, 3, 1, 2, 3]
這里有返回打印
有輸出則是沒有被就地修改，都是構造新的列表
我們看到增加之后原列表發生了變化，這樣被稱為就地修改，就地修改為只對當前列表進行修改，修改的是對象的本身
append對時間復雜度為O(1),因為通過索引進行修改，而且是從尾部進行修改
這樣通過索引線性修改所耗時間很快，并非O(n) ，O（n)為逐步遍歷，找到某個項再進行修改
insert插入元素
In [81]: a.insert(1,'a')
In [82]: a
Out[82]: [1, 'a', 2, 3]
insert為在指定處插入對象，這樣會引起整個內存結構變化，所有數據統一向后錯位，如果量級大則不要去做，盡可能new一個
所以盡可能避免挪動
insert時間復雜度為 O(n),如果放在開頭則不建議，一般list規模很大，所以要考慮效率問題
所以，insert更適合鏈表方式
extend將迭代對象追加
迭代對象不用解釋了，可以是列表，可以是字典等等
b = {'c':123}
In [85]: a.extend(b)
In [86]: a
Out[86]: [1, 'a', 2, 3, 'c']
追加迭代自己
In [88]: a.extend(a)
In [89]: a
Out[89]: [1, 'a', 2, 3, 'c', 1, 'a', 2, 3,'c']
remove刪除某個元素
remove為刪除某個內容，而并非索引
remove為就地修改，在做位置的挪動，所以這里需要注重效率
In [89]: a
Out[89]: [1, 'a', 2, 3, 'c', 1, 'a', 2, 3,'c']
In [90]: a.remove(1)
In [91]: a
Out[91]: ['a', 2, 3, 'c', 1, 'a', 2, 3,'c']
In [92]: a.remove(1)
In [93]: a
Out[93]: ['a', 2, 3, 'c', 'a', 2, 3, 'c']
在順序列表中，在中間包括開頭，需要考慮效率問題
pop彈出
從尾部進行彈出并且刪除尾部的元素
In [103]: a = [1,2,3,11,13,12,20]
In [104]: a.pop()
Out[104]: 20
pop效率為O(1)由于是在尾部進行就地修改，所以效率非常高
使用index進行pop，而索引則是從1開始并非是0
In [108]: a.pop(0)
Out[108]: 1
In [109]: a
Out[109]: [2, 3, 11, 13, 12]
pop的特性直接將前端顯示，移除+修改并行操作
在清除對象過多的情況下，會引起大規模GC垃圾回收，同樣要考慮到效率問題
list的排序
sort()排序
In [113]: a = [63,1,44,2,19,94,64,21]
In [114]: a.sort()
In [115]: a
Out[115]: [1, 2, 19, 21, 44, 63, 64, 94]
reverse進行到排序
默認為： sort(Key=None,reverse=False)
默認情況下是升序排列，降序由大到小，那么進行到排序：
In [116]: a.sort(reverse=True)
In [117]: a
Out[117]: [94, 64, 63, 44, 21, 19, 2, 1]
但是當前如果遇到字符串則無法進行
In [117]: a
Out[117]: [94, 64, 63, 44, 21, 19, 2, 1]
In [118]: a.append('haha')
In [119]: a.sort(reverse=False)
---------------------------------------------------------------------------
TypeError? ? ? ? ?? ? ? ? ? ? ? ? ? ? ??Traceback (most recent call last)
in()
----> 1 a.sort(reverse=False)
TypeError: unorderable types: str()
那么我們可以使用key=None 的方法進行對字符串排序
In [121]: a.sort(key=str)
In [122]: a
Out[122]: [1, 19, 2, 21, 44, 63, 64, 94,'haha']
In [123]: a.sort(key=str,reverse=True)
In [124]: a
Out[124]: ['haha', 94, 64, 63, 44, 21, 2,19, 1]
同樣可以按照字母進行正排倒排
In [125]: a.append('ab')
In [126]: a.append('ba')
In [127]: a.sort(key=str,reverse=True)
In [128]: a
Out[128]: ['haha', 'ba', 'ab', 94, 64, 63,44, 21, 2, 19, 1]
In [129]: a.sort(key=str)
In [130]: a
Out[130]: [1, 19, 2, 21, 44, 63, 64, 94,'ab', 'ba', 'haha']
排序規則：將每個元素轉為字符串，其都是直接轉為ASCII碼進行排序，這里的str為當前定義的函數，如果是自己寫的函數可以自定義排序規則
取隨機數
涉及random
choice從非空序列的元素中隨機選擇
In [167]: a
Out[167]: [1, 19, 2, 21, 44, 63, 64, 94,'ab', 'ba', 'haha']
In [168]: import random
In [169]: random.choice(a)
Out[169]: 1
In [170]: random.choice(a)
Out[170]: 64
randrange取之間的隨機數的，以及步長
In [172]: random.randrange(1,10)
Out[172]: 5
shuffle打亂元素
In [174]: random.shuffle(a)
In [175]: a
Out[175]: [94, 64, 'ba', 21, 44, 19, 63, 2,1, 'ab', 'haha']
列表復制
==和is 的區別
In [131]: lst0 = list(range(4))
In [132]: lst0
Out[132]: [0, 1, 2, 3]
In [133]: id(lst0)
Out[133]: 140196597896584
首先進行哈希匹配
In [134]: hash(id(lst0))
Out[134]: 140196597896584
給lst1 進行賦值 讓其等于lst0
In [135]: lst1 = list(range(4))
In [136]: id(lst1)
Out[136]: 140196608816840
查看兩個列表的值
In [138]: lst1
Out[138]: [0, 1, 2, 3]
In [139]: lst0
Out[139]: [0, 1, 2, 3]
In [140]: lst0 == lst1
Out[140]: True
In [141]: lst0 is lst1
Out[141]: False
通過以上，可以明白：
==比較返回值 判斷是否依次相等
is比較內存地址是否一致
地址空間的引用
In [142]: id(lst0[1])
Out[142]: 9177888
In [143]: id(lst1[1])
Out[143]: 9177888
以上看到，是沒有復制的過程，而是被引用了同樣的內存地址空間
使用copy進行復制并返回一個新的列表
In [150]: lst0
Out[150]: [0, 1, 2, 3]
In [151]: lst5=lst0.copy()
In [152]: lst5
Out[152]: [0, 1, 2, 3]
使用= 進行拷貝
In [163]: lst5 = lst0
In [164]: lst0[1] = 555
In [165]: lst0
Out[165]: [0, 555, 2, 3]
In [166]: lst5
Out[166]: [0, 555, 2, 3]
因為賦值的是引用類型，所以直接將嵌套的list拷貝的內存地址
通過這個內存地址修改，則對兩個list同時修改
需要注意的是：需要觀察拷貝的類型是什么，不然會引起副作用，但是也可以通過特性批量進行操作
深拷貝和潛拷貝的基本概念
淺拷貝
在一般都是實現了淺拷貝，只拷貝了第一層結構，
被稱為 shadow copy,但是引用的都是同一個內存地址
深拷貝
如果出現層次嵌套，會對引用類型進行深入拷貝，在結構上拷貝的一模一樣，引用的內存地址則獨立開辟
使用deepcopy可以進行深拷貝
使用list求100內的質數：
lst1 = []
for x in range(2,101):
for i in lst1:
if x % i == 0:
break
else:
lst1.append(x)
print(lst1)
本文轉自zuzhou 51CTO博客，原文鏈接:http://blog.51cto.com/yijiu/1966783
《新程序員》：云原生和全面數字化實踐50位技術專家共同創作，文字、視頻、音頻交互閱讀總結
以上是生活随笔為你收集整理的python index函数时间复杂度_初学python之以时间复杂度去理解列表常见使用方法的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： lua 调用文件中的函数调用_四、C++
- 下一篇： 每天九点十分开始每半小时一次执行一个cr