Python -- 數據類型內置方法:列表/元組/集合

2020-10-03 老王的日誌

list列表類型內置方法

  1. 作用:多個裝備、多個愛好、多門課程,甚至是多個女朋友
  2. 定義方式:[]內用逗號隔開,可以有多個任意數據類型的元素

friends_list = ['longzeluola','canglaoshi','qiaobenai','nick']lis = list('abcd')

方法:

  1. 優先掌握索引取值(正向取值+反向取值) 即可取又可存

#list之索引取值name_list={'nick','jason','tank','sean'}name_list[0]='nick handsome'#name_list[1000]='tank handsome' #報錯print(f"name_list[0]:{name_list[0]}")

name_list[0]:{name_list[0]}

2.切片

#list之切片name_list=['nick','jason','tank','jick']print(name_list[0:3:2]) ----->'nick','tank'

3.長度len

#list之長度name_list=['nick','jason','tank','jick']print(len(name_list)) ------>4

4.append追加值

# list之追加值name_list = ['nick', 'jason', 'tank', 'sean']name_list.append('tank handsome' )print(name_list) ------->['nick', 'jason', 'tank', 'jick', 'tank handsome']

5.成員運算in和not in

# list之成員運算in和not inname_list = ['nick', 'jason', 'tank', 'sean']print('tank handsome' in name_list ) ----->Fslseprint('nick handsome' not in name_list) ------>true

6.for循環

# list之循環name_list = ['nick', 'jason', 'tank', 'sean']for name in name_list: print(name) nickjasontankjick

7.刪除del

# list之刪除name_list = ['nick', 'jason', 'tank', 'sean']del name_list[2]print(name_list) ---->['nick', 'jason', 'jick']

需要掌握

  1. count計數

# list之count()name_list = ['nick', 'jason', 'tank', 'sean']print(name_list.count('tank')) ------>1

2.remove 如果刪除對象不存在則報錯,按照指定的元素刪除

# list之remove()name_list = ['nick', 'jason', 'tank', 'sean']print(name_list.remove('tank')) ------> Noneprint(name_list) ----->['nick', 'jason', 'sean']

3.reverse 反轉列表

# list之reverse()name_list = ['nick', 'jason', 'tank', 'sean']name_list.reverse()print(name_list) ------>['sean', 'tank', 'jason', 'nick']

4.pop 默認刪除最後一個值,刪除指定索引的值

# list之pop(),pop()默認刪除最後一個元素name_list = ['nick', 'jason', 'tank', 'sean']print(name_list.pop(1)) ----->jasonprint(name_list) ----->['nick', 'tank', 'sean']

5.insert 在索引前面加入一個值

# list之insert()name_list = ['nick', 'jason', 'tank', 'sean']name_list.insert(1,'handsome')print(name_list) --->['nick', 'handsome', 'jason', 'tank', 'sean']

6.sort 排序列表

# list之sort(),使用sort列表的元素必須是同類型的name_list = ['nick', 'jason', 'tank', 'sean']name_list.sort()print(name_list) --->['jason', 'nick', 'sean', 'tank']name_list.sort(reverse=True) print(name_list) ------->['tank', 'sean', 'nick', 'jason']

7.index 獲取指定元素的索引,但是只會獲取第一次

# list之index()name_list = ['nick', 'jason', 'tank', 'sean']print(name_list.index('nick')) ---->0

8.copy 複製

# list之copy()name_list = ['nick', 'jason', 'tank', 'sean']print(name_list.copy()) --->['nick', 'jason', 'tank', 'sean']

9.extend 擴展,把extend裡的列表的元素添加到原列表中

# list之extend()name_list = ['nick', 'jason', 'tank', 'sean']name_list2=['nick handsome' ]name_list.extend(name_list2)print(name_list) -->['nick', 'jason', 'tank', 'sean', 'nick handsome']

10.clear 清除列表/清空列表

# list之clear()name_list = ['nick', 'jason', 'tank', 'sean']name_list.clear()print(name_list) ------->[]

  1. 多個值or一個值 :多個值
  2. 有序or無序:有序

hobby_list = ['read', 'run', 'girl']print(f'first:{id(hobby_list)}') --->4522187016hobby_list[2] = ''print(f'second:{id(hobby_list)}') ---->4522187016

  1. 可變or不可變:可變數據類型

元組類型內置方法

  1. 作用: 類似於列表,可以存不可以取
  2. 定義方式: 在()內可以有多個任意類型的值,逗號分隔元素

friends_tuple = ('longzeluola','canglaoshi','qiaobenai','nick')tup = tuple('abcd')

  1. 方法索引取值(無法更改)切片(顧頭不顧尾,步長)長度 len成員運算 in 和not infor循環countindex
  2. 多個值or一個值:多個值
  3. 有序or無序:有序
  4. 可變or不可變:無可變不可變這一說列表可變的原因是:索引所對應的值的內存地址是可以改變的元組不可變得原因是:索引所對應的值的內存地址是不可以改變的,或者反過來說,只要索引對應值的內存地址沒有改變,那么元組是始終沒有改變的。

字典類型內置方法

  1. 作用:當列表存在很多值的時候,列表會顯得很亂,所以就有了字典。多用於存的值表示的是不同的狀態時,例如存的值有姓名、年齡、身高、體重、愛好。
  2. 定義方式:{}內用逗號分隔開多個鍵值對key:value的值,value可以是任意數據類型,而key通常應該是字符串類型,但是key必須為不可變類型。

nick_info_dict = {'name':'nick','height':180,'weight':140,'hobby_list':['read','run','music','fishing','programming','coding','debugging']}for k,v in nick_info_dict.items(): print(k,v)

name nick
height 180
weight 140
hobby_list ['read', 'run', 'music', 'fishing', 'programming', 'coding', 'debugging']

  1. 方法
  2. 按鍵取值:可存可取

# dic之按key存取值dic = {'a': 1, 'b': 2}print(f"first dic['a']: {dic['a']}")dic['a'] = 3print(f"second dic['a']: {dic['a']}")

first dic['a']: 1
second dic['a']: 3

3.長度:

```print(len(dic))

4.鍵keys() / 值values()/ 鍵值對items()

# dic之鍵keys()、值values()、鍵值對items(),python2中取出的是列表(雞蛋);python3中取出的是元組(雞)dic = {'a': 1, 'b': 2}print(f"dic.keys(): {dic.keys()}")print(f"dic.values(): {dic.values()}")print(f"dic.items(): {dic.items()}")

dic.keys(): dict_keys(['a', 'b'])
dic.values(): dict_values([1, 2])
dic.items(): dict_items([('a', 1), ('b', 2)])

5.for循環

# dic之循環# dic是無序的,但是python3採用了底層優化算法,所以看起來是有序的,但是python2中的字典是無序dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}for k, v in dic.items(): # items可以換成keys()、values() print(k, v)

a 1
b 2
c 3
d 4

6.成員運算in 和 not

# dic之成員運算in和not indic = {'a': 1, 'b': 2}print(f"'a' in dic: {'a' in dic}")print(f"1 in dic: {1 in dic}")

'a' in dic: True
1 in dic: False

7.刪除del

# dic之刪除deldic = {'a': 1, 'b': 2}del dic['a']print(f"dic.get('a'): {dic.get('a')}")

dic.get('a'): None

8.需要掌握
1. fromkeys 來自鍵值,默認把給定列表內的元素取出來當成key,然後使用一個默認value新建一個字典

# dic之fromkeys()dic = dict.fromkeys(['name', 'age', 'sex'], None)print(f"dic: {dic}")

dic: {'name': None, 'age': None, 'sex': None}

2. setdefault 如果字典中有該key的話,則key對應的值不變:如果沒有,則增加 ```python # dic之setdefault(),有指定key不會改變值;無指定key則改變值 dic = {'a': 1, 'b': 2} print(f"dic.setdefault('a'): {dic.setdefault('a',3)}") print(f"dic: {dic}") print(f"dic.setdefault('c'): {dic.setdefault('c',3)}") print(f"dic: {dic}") ``` dic.setdefault('a'): 1 dic: {'a': 1, 'b': 2} dic.setdefault('c'): 3 dic: {'a': 1, 'b': 2, 'c': 3}3. get 如果鍵不存在,返回不會報錯,可以給默認值 ```python # dic之get() dic = {'a': 1, 'b': 2} print(f"dic.get('a'): {dic.get('a')}") print(f"dic.get('c'): {dic.get('c')}") ``` dic.get('a'): 1 dic.get('c'): None4. update 有就更新,沒有就添加 ```python # dic之update() dic1 = {'a': 1, 'b': 2} dic2 = {'c': 3} dic1.update(dic2) print(f"dic1: {dic1}") ``` dic1: {'a': 1, 'b': 2, 'c': 3}

  1. 多個值or一個值:多個值,值可以是多個類型,key必須是不可變類型,通常應該是不可變類型中的字符串類型
  2. 有序or無序:無序
  3. 可變or不可變:可變數據類型

集合類型內置方法

  1. 作用:存多個值,為了集合之間做運算,由於集合內的元素無序且集合元素不可重複,因此集合可以去重,但是去重後的集合會打亂原來元素的順序。
  2. 定義方式:{}內用逗號分隔開多個元素,每個元素必須是不可變類型。

s = set()s = {1,2,3,4,5,1}

方法:

  1. 優先掌握去重併集 | ,union

# str之|併集pythoners = {'jason', 'nick', 'tank', 'sean'}linuxers = {'nick', 'egon', 'kevin'}print(f"pythoners|linuxers: {pythoners|linuxers}")print(f"pythoners.union(linuxers): {pythoners.union(linuxers)}")

  1. pythoners|linuxers: {'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}
    pythoners.union(linuxers): {'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}交集 & intersection差集 -difference對稱差集 ^symmetric_difference父集 >&emsp;>=issuperset子集 <&emsp;<=issubset==
  2. 需要掌握add()

# set之add()s = {1, 2, 'a'}s.add(3)print(s)

{1, 2, 3, 'a'}

2.difference_update

# str之difference_update()pythoners = {'jason', 'nick', 'tank', 'sean'}linuxers = {'nick', 'egon', 'kevin'}pythoners.difference_update(linuxers)print(f"pythoners.difference_update(linuxers): {pythoners}")

pythoners.difference_update(linuxers): {'tank', 'jason', 'sean'}

3.isdisjoint 是否不聯合

# set之isdisjoint(),集合沒有共同的部分返回True,否則返回Falsepythoners = {'jason', 'nick', 'tank', 'sean'}linuxers = {'nick', 'egon', 'kevin'}pythoners.isdisjoint(linuxers)print(f"pythoners.isdisjoint(linuxers): {pythoners.isdisjoint(linuxers)}")

pythoners.isdisjoint(linuxers): False

4.remove # 值不存在會報錯

# set之remove()s = {1, 2, 'a'}s.remove(1)print(s)

{2, 'a'}

5.discard # 放棄,刪除,不會報錯

# set之discard()s = {1, 2, 'a'}# s.remove(3) # 報錯s.discard(3)print(s)

{1, 2, 'a'}

4.多個值or一個值:多個值,且值為不可變類型

5.有序or無序:無序

6.可變or不可變:可變數據類型

數據類型總結

一個值多個值整型/浮點型/字符串列表/元祖/字典/集合/

有序無序字符串/列表/元祖字典/集合

可變不可變列表/字典/集合整型/浮點型/字符串

拷貝

  • 拷貝/淺拷貝/深拷貝都是針對可變類型數據而言的

l1 = ['a','b','c',['d','e','f']]l2 = l1l1.append('g')print(l1) # ['a','b','c',['d','e','f'],'g']print(l2) # ['a','b','c',['d','e','f'],'g']

如果l2是l1的拷貝對象,則l1內部的任何數據類型的元素變化,則l2內部的元素也會跟著改變,因為可變類型值變id不變

淺拷貝

import copyl1 = ['a','b','c',['d','e','f']]l2 = copy.copy(l1)l1.append('g')print(l1) # ['a','b','c',['d','e','f'],'g']print(l2) # ['a','b','c',['d','e','f']]l1[3].append('g')print(l1) # ['a','b','c',['d','e','f','g'],'g']print(l2) # ['a','b','c',['d','e','f','g']]

如果l2是l1的淺拷貝對象,則l1內的不可變元素發生了改變,l2不變;如果l1內的可變元素發生了改變,則l2會跟著改變

深拷貝

import copyl1 = ['a','b','c',['d','e','f']]l2 = copy.deepcopy(l1)l1.append('g')print(l1) # ['a','b','c',['d','e','f'],'g']print(l2) # ['a','b','c',['d','e','f']]l1[3].append('g')print(l1) # ['a','b','c',['d','e','f','g'],'g']print(l2) # ['a','b','c',['d','e','f']]

如果l2是l1的深拷貝對象,則l1內的不可變元素發生了改變,l2不變;如果l1內的可變元素發生了改變,l2也不會變,即l2永遠不會因為l1的變化而變化!

相關焦點

  • 一、Python之列表、元組、字典和集合詳解
    從內容上看,列表可以存儲整數、小數、字符串、列表、元組等任何類型的數據,並且同一個列表中元素的類型也可以不同。比如說:str=&34;print(&39; not in str)輸出結果:False可以看到,列表中同時包含字符串、整數、列表、浮點數這些數據類型。
  • 詳解python中的列表,元組,字典以及集合的操作
    在Python中有4種內建的數據結構:列表、元組、字典、集合。今天我們將會學習如何使用它們,以及它們如何使編程變得簡單。在開始講解之前小編在這磨嘰兩句:小編本身就是一名python開發工程師,我自己花了三天時間整理了一套python學習教程,從最基礎的python腳本到web開發,爬蟲,數據分析,數據可視化,
  • 元組(tuple)-Python基本數據類型之四
    在python中,元組這種數據結構同列表類似,都可以描述一組數據的集合,它們都是容器,是一系列組合的對象,不同的地方在於,元組裡的元素是不能更改的,它們之間的差異性我們用一個例子來說明一下:列表:>>>find_files("*.txt")["file1.txt","file2.txt","file3
  • python數據類型總結——元組
    python中的列表還有一個弟弟,他的名字叫元組。這個弟弟和哥哥比起來,就是有了點脾氣……python元組元組通過小括號的方式聲明。它也是一種序列,包含若干個元素。除了聲明方式,還有一點不同於列表的是,元組是不可變的。
  • python數據類型總結——列表
    多個元素的集合也是一種常見的表達方式。python用列表或元組來幫助我們。python列表一系列元素組成一個集合,可能通過索引,對每個元素進行訪問。這種數據類型統稱為序列。在python中,字符串就是一種序列。列表,也是序列的一種。
  • Python列表和元組
    @Author :RunsenPython列表和元組總結什麼是列表和元組列表是動態的,長度大小不固定,可以隨意地增加、刪減或者改變而元組是靜態的,長度大小固定,無法增加刪減或者改變定義列表和函數```l = [1, 2, 'hello', 'world'] # 列表中同時含有
  • python基礎教程:列表list與元組tuple
    介紹:列表是一種可變的有序集合,可以進行訪問、添加和刪除操作。元組是一種不可變的有序集合,可以訪問。1、列表的基本操作創建列表注意:列表中的元素可以為不同類型,且可以為列表列表元素的訪問和截取注意:以上不返回的函數和方法就是對列表本身做修改,不會生成新的列表,這裡一定要注意!
  • 柳小白Python學習筆記 5 列表、元組、集合、字典基本概念學習
    昨天沒有完成複習計劃,我發現學習數字、字符串,列表,元組,集合,字典的時候,出現了數據結構,數據類型,序列三種不同的概念。我不清楚它們之間的聯繫,所以就需要系統地去查找下資料。什麼是數據結構呢?數據結構是計算機存儲、組織數據的方式,是通過某種方式組織在一起的數據元素的集合。這些元素可以是數字或字符。序列是Python中最基本的數據結構。數據結構分別為邏輯結構、物理結構和數據的運算。而且數據結構操作的就是數據, 數據類型也包括在了數據裡面。什麼是數據類型?
  • Python3的基本類型,列表(瘋狂Python)
    本章內容框架結構:1.簡述列表[list],元組[tuple],字典[dict]2.了解一下序列3. List(列表)1.簡述列表[list],元組[tuple],字典[dict]1-1 python內置三種常用的數據結構:list,tuple,dict,都可用於保存多個數據項。
  • 詳解Python集合數據類型
    本篇介紹Python集合數據類型。集合不同於列表和元組類型,集合存儲的元素是無序且不能重複的,同數學中的集合一樣,集合可以執行集合的並、交、差運算。通過本篇的學習,可以達成如下目標。● 掌握集合數據類型● 在程序中使用集合數據類型在數學概念中,集合是由一個或多個確定的元素構成的整體。
  • python語言基本數據類型-元組(tuple)
    元組(tuple)是有序的不可變的元素集合 。元組與列表幾乎一樣,元組使用小括號(),列表使用方括號[]。但列表可以修改(追加,移除,刪除),元組是不可變對象,元組不能修改,如果需要改變,轉化成列表即可。
  • python 數據類型
    2 組合數據類型2.1 集合類型集合的定義及操作集合操作方法集合應用場景包含關係比較;數據去重。2.1 序列類型定義~ 序列是具有先後關係的一組元素~ 序列是一個基類類型(基本數據類型)~ 序列類型分為字符串、列表、元組類型2.2
  • 入門人工智慧熱門語言python,透視4種內置類型的實現黑盒
    作為人工智慧網紅語言的python, 內部有四種標準容器:字典({})、集合(set)、列表([])、元組(()), 除了集合外,其他三種類型對應於大括號、中括號、小括號。很多python初學者,會很奇怪,為什麼python沒有數組?很多書上來就講這幾種類型的各種初始化及操作等,但對應背後的數據結構和各種操作的複雜度都不講。
  • Python學習之路(4) - 基本數據類型:Lists, Tuples
    Python提供了四種內置數據結構,可以保存任意對象。他們是:列表(list)、元組(tuple)、字典(Dictionary)、集合(Set)。這些內置數據類型可以在代碼中直接使用,無需先導入(import)。
  • 問了面試同學Python列表和元組的區別
    都是一個可以放置任意數據類型的有序集合,都是既可以存放數字、字符串、對象等但還是有區別的:數組結構方面:雖然都是數組。列表是動態數組,可變且可以重設長度。元組是靜態數組,不可變,內部數據一旦創建無法改變。
  • python數據結構總結——集合
    python中,列表和元組都是序列的一種,它們的基本特徵,最大區別在於,列表是可變的,而元組則是不可變的。python中還有另外一種序列,叫做集合。python集合集合也是一種序列。它的特點是可變,但是無法通過索引操作。因為集合中的元素是無序的。
  • Python入門基礎數據類型之可變數據,列表、集合、字典詳解
    Python3 的六個標準數據類型中可變數據(3 個):List(列表)、Set(集合)、Dictionary(字典)。列表(list):列表是一種有序的集合,可以隨時添加和刪除其中的元素。創建列表:只要把逗號分隔的不同的數據項使用方括號括起來即可。集合(set):集合是無序的不重複元素。
  • 如何在python中引入高性能數據類型?
    作者|skura 來源|AI開發者 python 就像一件藝術珍藏品!python 最大的優點之一是它可以廣泛地選擇模塊和包。它們將 python 的功能擴展到許多流行的領域,包括機器學習、數據科學、web 開發、前端等等。其中最好的一個優點是 python 的內置 collections 模塊。
  • python數據類型串講(下)
    在上一篇文章中討論了python標準類型中序列的兩種:列表和元祖,下面我們繼續介紹python的第二種標準類型:字典(dict)。1、字典dict顧名思義,字典就像我們日常生活中使用的新華字典,其作用在於根據索引(拼音或偏旁)快速查找到所需內容,而python中的字典也是如此,python中字典的索引稱為「鍵」(key),由python中不可變的數據類型(如字符串、數值等)構成,具有固定(不可變)、唯一(不可重複)性;python中字典的內容稱為「值」,其可以為python中的任意標準數據類型的一種或多種
  • Python乾貨整理:一分鐘了解元組與列表使用與區別
    元組是 Python 對象的集合,跟列表十分相似。下面進行簡單的對比。列表與元組1、python中的列表list是變量,而元組tuple是常量。列表:是使用方括號[],元組:則是使用圓括號()2、兩者都可以使用索引讀取值列表1.列表中的append()和extend()都是對列表增加元素的方法