精华内容
下载资源
问答
  • python四种数据结构

    2020-06-01 15:16:59
    python四种数据结构,分别是:列表,字典,元组,集合。 1,列表 列表中的每一个元素都是可变的;我们可以在列表中添加,删除,修改元素; 列表中的元素是有序的,也就是说每一个元素都有一个位置;我们可以通过...

    python有四种数据结构,分别是:列表,字典,元组,集合。

    1,列表
    列表中的每一个元素都是可变的;我们可以在列表中添加,删除,修改元素;
    列表中的元素是有序的,也就是说每一个元素都有一个位置;我们可以通过位置来替换位置上面的值;
    列表可以容纳任何对象
    例如:
    list[1,1.0,‘hello’,print(1 or 0),true,[1,2],(1,2),{‘key’:‘value’}]
    list[整数,浮点数,字符串,函数,布尔值,列表中套列表,元组,字典]

    2字典
    字典中的数据必须是以键值对形式出现的;
    键值是不能重复的,不可变的,值可以
    例如:
    test={‘name’:‘molly’}

    3元组
    元组是不可修改的,可以看成是一个列表
    例如:
    test=(1,2,3)

    4集合
    每一个集合中的元素是无序不可重复的任意对象,可以通过集合去判断集合的从属关系,也可i恶意通过集合把重复的元素剪掉
    例如
    test={1,2,34,}

    展开全文
  • 对于每编程语言一般都会规定一些容器来保存某些数据,就像java的集合和数组一样python也同样有这样的结构而对于python他有个这样的内置容器来存储数据,他们都是python语言的一部分可以直接使用而无需额外的导入...

    对于每种编程语言一般都会规定一些容器来保存某些数据,就像java的集合和数组一样python也同样有这样的结构

    而对于python他有四个这样的内置容器来存储数据,他们都是python语言的一部分可以直接使用而无需额外的导入

    一.列表(list)

    列表一种跟java和c中的数据很像的一种数据结构,他都是保存一系列相似,且有序元素的集合,不过不同的是列表中的元素可以不是同一种数据类型,且列表的长度是可变的

    可以动态的增加可减少这一点则有点像java中的stringBuilder对象,列表中有一点值得注意的是在对列表进行复制是,不能简单的使用赋值语句,这样会使得两个变量同时指向一个列表,当一个改变时另一个变量的值也会改变,正确的复制方法是用copy()方法来进行复制

    关于一个存储结构增删查看则其必备的功能:

    1.列表元素的增加

    append的方法是将所要加的元素直接加到先前列表的末尾的方法,在增加的同时还会使得列表得长度增加

    extend方法是将一个列表中得所有元素加拓展到另一个列表的末尾将两个列表合并为一个列表

    insert方法是将一个元素插入到指定的位置,但是值得注意的是insert方法不能插到列表的末尾

    2.列表元素的删除

    remove删除列表中指定的值,如果列表中没有remove参数中指定的值解释器将会报错

    pop删除指定索引位置对应的对象,如果pop方法中没有参数是则其默认的是删除列表的最后的一个对象,该方法的返回值就是对应删除的对象,若其指定的索不存在      时解释器同样会报错

    下面通过一个简单的例子来说明以上方法的使用:

    #在 Don"t panic变为 on tap

    phrase="Don"t panic"plist=list(phrase) #将phrase表示的字符串转化为列表

    print(phrase) #将该字符串输出

    print(plist) #结果为["D", "o", "n", """, "t", " ", "p", "a", "n", "i", "c"]

    plist.remove(""") #将"在列表中删除

    for i in range(3):

    plist.pop()#将列表末尾的3个字符给删除,"n","i","c"

    plist.pop(0)#将plist中索引对应的对象删除,也就是D

    #此时list中的值为["o", "n", "t", " ", "p", "a"]

    plist.extend([plist.pop(5),plist.pop(4)]) #将p和a的位置交换

    plist.insert(2,plist.pop(3)) #将空格插入到对应索引为2的对象前

    phrase="".join(plist) #将列表转化为字符串

    print(phrase)

    3.列表元素的查看:

    值得说明的是列表的查看和数组相似,都支持下标查看不过不同的是列表的查看功能比数组更多

    a.中括号加下标可以查看列表中的任意元素且元素的下标也都是从0开始的,这点与数组相同,但不同的是数组中的下标不能为负数,而列表可以

    其表示的是从右到左,而正数则是从左到右

    b.列表中支持切片查看,也就是查看某一段元素其用法为:list[开始位置:结束位置:步长]其中所有元素都可以省,只需要在括号中有一个元素即可例如:

    list[: :2]表示开始为0,结束为列表尾,步长为2

    下面我们任然以一段简单的代码来展示其用法:

    #在 Don"t panic变为 on tap

    phrase="Don"t panic"plist=list(phrase)

    new_phase="".join(plist[1:3])#在列表中截取on

    print(new_phase)

    new_phase=new_phase+"".join([plist[5],plist[4],plist[7],plist[6]])#切片的实例,以及负数

    plist[-1] #c

    temp=plist[5:1:-1] #[" ", "t", """, "n"]当步长为负数时其结果时从右到左遍历

    temp2=plist[::2]#["D", "n", "t", "p", "n", "c"],从头遍历到尾步长为2

    事实上对于存储类似对象的时候我们一般是使用列表,而对于那种有结构的数据是列表就显得不那么实用了因为列表很难存储数据之间的结构

    所以对于那种结构化的数据我们一般采用字典来存储

    二.字典(dict)

    字典使用来保存一个键值对集合,其中每个唯一的键都有一个与之对应的值,通常我们把字典称为关联数组,如果你学过java的那么对字典就不会陌生了因为它其实就是java中的set集合,python的字典是无序的它不会保留你插入时的顺序,同时由于字典使用的是一种高度优化的散列算法所以即使是没有顺序字典一样能快速的访问与一个键相关的值

    1字典的定义:

    其结构为{键1:值1,键2:值2},可以看出字典的开始和结束都是用大括号键和值用冒号隔开,不同键值对之间用逗号分隔,其中值可以为列表,另一个字典

    2字典的增加:

    字典时一个动态的集合他可以在键对不存在时插入新的键值对,但是字典中键必须进行初始化后才可以引用例如:在一个商店中你不知到你的商店中的苹果又没  有时

    你不可以直接的使用苹果这个值而当你像添加时也需要查明商店中是否有这样物品,对于字典则无需这样。因为字典已经分装好了一个setdefault()方法只需直接调用即可

    下面用一段简单代码展示:

    #字典的添加键值对

    fruit={}#当直接使用不存在的键值对时

    fruit["apple"]+=1 #没有对该键初始化而直接使用会出现keyError

    #当不使用setdefault方法时动态的增加键值对

    if "apple" not infruit:

    fruit["apple"]=0 #初始化键值

    fruit["apple"]+=1 #增加苹果的量

    print(fruit["apple"])#使用setdefault时,其实就是设置一个默认值,确保使用时这个使用的键存在即可

    fruit.setdefault("apple",0)#当键存在时这个语句没有任何作用,相当于上面选择的分装

    fruit["apple"]+=1

    print(fruit["apple"])

    3字典的遍历:

    对于一个集合来说我们一般都会采用集合来遍历其中的所有元素但是对于字典来说单单只用循环的话并不够方便因为仅仅只用循环的话解释器只会处理字典的键

    对于其值任然需要用键来查值,对于这种问题python提供了一个items()的方法使得可以直接使用循环变量来访问字典的键和值

    下面通过一段简单的代码说明:

    fruit={"apple":10,"pears":5,"bananas":20,"orange":4}#直接使用for循环遍历

    for i infruit:print("种类",i,"数量",fruit[i])#使用items方法遍历

    for i,v infruit.items():print("种类",i,"数量",v)

    4字典的元素删除:

    python的字典删除有三种方法,一种是clear()是删除字典中的所有元素,二是pop()根据pop中的参数删除与其键相同的键值对,三是popitem()随机删除字典中的元素

    对于有结构的数据我们使用字典时会显得非常方便,因为他不仅可以保存结构,还可以保证记录不重复,但是对于那些没有结构的数据我们又不希望他们重复时,字典和列表显然都不适合我们使用了,这时我们就会想到使用集合了

    三.集合(set)

    1集合的定义:

    {元素1,元素2,元素3.....}和字典一样都是用大括号定义,不过不同的是其中没有冒号分割,还有一种定义方法是向set()函数中传递任意一个序列(如一个字符串set("fsdaf"))

    2集合的运算:

    python中的集合同于数学中的集合同样有交,并,差等运算其中并算提供方法union(),差集方法difference()不过这里不同的是只能显示使用该方法的集合中不同于另一个集合的所有元素,交集的方法intersection()显示相同的元素

    下面用代码来实现上述方法:

    #集合的运算

    temp={"a","e","i","o","u"}

    temp2=set("fda");#交运算

    result=temp.intersection(temp2)#{"a"}

    #并运算

    result=temp.union(temp2)#{"a", "o", "f", "d", "u", "e", "i"}

    #差运算

    result=temp.difference(temp2)#{"o", "e", "u", "i"}

    我们知道变量有两种一种是变量一种是常量,变量的值可以重新赋予,而常量的值则不行,在python中我们同样有一个不变的结构叫做元组

    四.元组(tuple)

    1元组的定义:

    元组与列表密切相关列表是用中括号定义而元组则是用小括号定义(元素1,元素2,元素3,.....),值得注意的是当只有一个对象是并不能仅仅(对象)这样定义并不是元组,正确的定义方法是(对象,)这样才是元组

    在最后我有必要说明一下:在这四个内置结构为空时的解释器的表示方法:1.空列表[] 2.空字典{} 3.空集合set() 4.空元组()

    展开全文
  • 数据结构:存储大量数据的容器 此文主要介绍Python四种数据结构分为:列表,字典,元组,集合 格式如下: 列表:list = [val_1, val_2, val_3, val_4],用中括号表示; 字典:dict = {key_11:val_1,key_2:val_2}, ...

    数据结构:存储大量数据的容器    此文主要介绍Python四种数据结构分为:列表,字典,元组,集合

    格式如下:

    • 列表:list = [val_1, val_2, val_3, val_4],用中括号表示;
    • 字典:dict = {key_11:val_1,key_2:val_2}, 用大括号表示,并且每个元素是带有冒号的K,V组成的对应关系组;
    • 集合:set = {val_1, val_2, val_3, val_4}, 用大括号表示;
    • 元组:tuple = (val_1, val_2, val_3, val_4),用小括号表示。

    <1>列表:

         list = [val_1, val_2, val_3, val_4]

    列表最显著的特征是:

    • 列表中每个元素都是可变的;
    • 列表中的元素都是有序的,即每个元素都有一个位置;
    • 列表可以容纳Python中的任何对象。

    常用的增删改查:

    • 增:  主要有insert,extend,append三种方法
    >>> list = [1, 'wn', 3.14]
    >>> list.insert(0, 'gf')
    >>> print list
    ['gf', 1, 'wn', 3.14]
    >>> list = [1, 'wn', 3.14]
    >>> list[0:0] = [9]
    # 【0:0】是指在list中的第1个位置插入新元素
    >>> list[3:3] = ['a']
    # 【3:3】是指在list中的第4个位置插入新元素
    >>> print list
    [9, 1, 'wn', 'a', 3.14]

    使用insert方法可以在列表中增加元素,insert方法需要写明增加在哪个位置和增加的内容,新增元素的实际位置是在指定位置元素之前的位置,如果指定的位置不存在,默认会添加到列表末尾,上面说到的这两种方法都是添加单个元素,除了添加单个元素,还可以添加对个元素,用extend()方法来实现

    >>> list_a = [1, 'wn', 3.14]
    >>> list_b = ['Python', 555, 'lol']
    >>> list_a.extend(list_b)
    #extend(list)方法用于在列表的末尾一次性追加另一个列表中的多个值
    >>> print list_a
    [1, 'wn', 3.14, 'Python', 555, 'lol']
    

    还可以用append(a)的方法,直接在列表末尾进行添加元素

    >>> list_a = [720, 'wn', 3.14]
    >>> list_a.append('1')
    >>> list_a.append(135)
    >>> print list_a
    [720, 'wn', 3.14, '1', 135]
    

    append 和extend都只需要一个参数,并且自动添加到数组末尾,如果需要添加多个,可用数组嵌套,但是  append是将嵌套后的数组作为一个对象,extend是将嵌套的数组内容作为多个对象,添加到原数组中

    >>> list = [720, 'wn', 3.14]
    >>> list.append(535)
    >>> list.append([234, 4.31])
    >>> list.extend(['abdx', 532])
    >>> print list
    [720, 'wn', 3.14, 535, [234, 4.31], 'abdx', 532]
    

    删:

    list = [720, 'wn', 3.14, True]
    >>> list.remove('wn')
    >>> print list
    [720, 3.14, True]
    

    删除列表中的元素除了用上面的remove方法来实现外,也可以用del关键字来声明:

    1 list = [1, 'wn', 3.14]
    2 del list[0:2]
    3 # 【0:2】是删除第1和第2个位置的元素
    4 print(list)

    改:

    >>> list = [720, 'wn', 3.14, True]
    >>> list[2] = 111
    >>> list[0] = 'reset'
    #如果想要替换掉列表中的某个元素,可以直接给列表某位置的元素重新赋值,list[2]指list列表中的第3个元素。
    >>> print list
    ['reset', 'wn', 111, True]
    

    查:

    列表的索引与字符串的索引类似,同样是分正反两种索引方式,可以从前往后,也可以从后往前索引。但如果想查看某个元素的位置,就不适合用这种方式,程序会报错。因为列表只接受用位置进行索引,不可以通过元素来查找位置。

    1 list = [1,'dwd',3.6]
    2 print(list[1])
    3 # 打印第2个位置的元素
    4 print(list[-1])
    5 # 打印倒数第一个位置的元素
    6 print(list[:2])
    7 # 打印第1和第2个元素
    8 print(list[1:])
    9 # 打印第2到最后一个的元素

    <2>字典:

    dict = {key_11:val_1,key_2:val_2}

    编程世界中的很多概念都源自于生活,字典也是。字典(dictionary)是Python中另一个非常有用的内置数据类型。这种数据结构如我们使用的字典一样,通过“名称—内容”来构建,在Python中每个元素是带有冒号的key与val的对应关系组,习惯称之为对。列表是有序的对象集合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。字典是一种映射类型,字典用"{ }"标识,它是一个无序的键(key) : 值(value)对集合。键(key)必须使用不可变类型。在同一个字典中,键(key)必须是唯一的。

    字典的特征如下:

    • 字典中的元素必须是键值对的形式;
    • 键(key)不可以重复,而值(val)可以重复;
    • 键不可变,无法修改;值可修改,可以是任何对象。

    即使字典中有重复的键,打印出来时也只会出现一次。

    接下来看字典的增删改查

    增:

    单个元素如下表示

    1 dict = {'A':'art','B':'big','C':'cute'}
    2 dict['D'] = 'dictionary'
    3 print(dict)

    多个元素类似列表的extend()方法,字典中有update方法

    1 dict = {'A':'art','B':'big','C':'cute'}
    2 dict.update({'D':'dictionary','E':'exam'})
    3 print(dict)

    删:

    在字典中删除某元素,也可以使用del关键字,不过需要注意的是,虽然字典是用大括号的,但在删除时依然使用的是中括号。

    1 dict = {'A':'art','B':'big','C':'cute'}
    2 del dict['B']
    3 print(dict)

    改:

    如果要修改字典里的元素,直接重新给键赋值即可。

    >>> dict = {'A':'art','B':'big','C':'cute'}
    >>> dict['B'] = 'beyond'
    >>> print(dict)
    {'A': 'art', 'C': 'cute', 'B': 'beyond'}
    

    查:

     在字典中进行索引时,和删除一样,用的是中括号,中括号中存放字典的键,也就是说对字典元素进行索引时是通过键来索引的。

    >>> dict = {'A':'art','B':'big','C':'cute'}
    >>> dict['B']
    'big'
    >>> print(dict['B'])
    big
    

    循环输出

    >>> dic = {'name' : 'wangning','sex' : 'girl', 'bir' : '7,20'}
    >>> print dic
    {'bir': '7,20', 'name': 'wangning', 'sex': 'girl'}
    >>> for k,v in dic.items(): print k,v   
    #使用for in  items方法可以循环读出想要的K, V键值对
    ... 
    bir 7,20
    name wangning
    sex girl
    >>> for k,v in sorted(dic.items()):     print k,v    
    #通过sorted(items())方法对输出进行排序
    ... 
    bir 7,20
    name wangning
    sex girl
    

    <3>集合:

    set = {val1,val2,val3,val4}

    • 集合(set)是一个无序,不重复元素的序列。我们可以通过集合去判断数据的从属关系,有时还可以通过集合把数据结构中重复的元素减掉。集合不可以被切片也不能被索引,除了做集合运算之外,集合元素可以被添加和删除。基本功能是进行成员关系测试和删除重复元素。
    1 set = {7,1,8,3,4,5,3}
    2 set.add(0)
    3 # 新增元素0
    4 set.discard(7)
    5 # 删除掉元素7
    6 print(set)
    7 # 打印出的集合会从小到达排列,并去重
    8 set = {}   #空 定义出来的为字典
    9 set = {1,2,3,4}  #定义为集合
    10 set_a = set('1,2,3,4') #快速定义集合
    11 print set_a
    {'1','2','3','4'}
    • 集合提供大量内置功能,包括常用的并集(union),差集(difference),交集(intersection)
    >>> vowel = set('aeiou')
    >>> word = 'hello'
    >>> u = vowel.union(set(word))
    #并集
    >>> u
    set(['a', 'e', 'i', 'h', 'l', 'o', 'u'])
    >>> v = vowel.difference(set(word))
    #差集
    >>> v
    set(['a', 'i', 'u'])
    >>> w = vowel.intersection(set(word))
    #交集
    >>> w
    set(['e', 'o'])
    

    <4>元组:

    tuple = (val_1,val_2,val_3,val_4)

    Python中的元组与列表类似,不同之处在于元组不可以修改,类似于稳固版的列表,因此在列表中可以使用的增删改的方法在元组中是不可以使用的,但是可以对元组中的元素进行索引,和列表类似。

    1 tup = (1,2,'s',7)
    2 print(tup[0])
    3 print(tup[-1])
    4 print(tup[1:])
    5 print(tup[:-2])
    展开全文
  • 四种数据结构: list 使用[]表示,线性的数据结构,适合查找数据,不适合增删数据  链表: 适合增删数据,不适合查找数据  queue:队列:(先进先出或后进先出) 不允许队列在中间进行变化。  stack:栈 后进先出...

    四种数据结构:

    list

    使用[]表示,线性的数据结构,适合查找数据,不适合增删数据

    链表:

    适合增删数据,不适合查找数据

    queue:队列:(先进先出或后进先出)

    不允许队列在中间进行变化。

    stack:栈

    后进先出(落盘子)

    列表表示
    l1 = []
    l2 = [1,2,'abc']
    l3 = list()
    l4 = list(range(5))
    可以嵌套
    l5 = [1,'ab',[bool,str]]
    l5[0] :打印出1,正数进行正索引,负数进行负索引
    l5[-1] :打印出[bool,str],超界很危险
    l5.index(1) :返回索引号0,有相同按索引顺序选取第一个
    l5.count(#) :查找共有几个#,低效,能不用就不用
    O(n)时间复杂度,n代表有多少元素,.count()与.index()都是O(n)
    len(l5) : 显示当前列表长度,(列表有长度属性),时间复杂度为O(1)

    增加:
    l5.append(#) :向列表尾部加#元素。并且返回值是none,时间复杂度为O(1)
    l5.insert(0,1): 向索引0位置插入1这个元素,索引超出直接在尾部追加(最好少用这个),返还值none,O(n)

    扩展:
    l5.extend(range(200,205))
    l5.extend([301,302,303]) :尾部追加扩展,如[1,2],用完这个变[1,2,301,302,303]

    l5 + [1,2,3] :返回出一个新列表,原列表没有改变。

    l9=[0,1,2] 3 :创建新列表:l9 = [0,1,2,0,1,2,0,1,2]



    l10 = l9.copy() :将l9拷贝给l10,不是普通拷贝,嵌套是引用,表示地址
    浅拷贝:嵌套类型相当于门牌号,只拷贝了房间号,房间号内住的不会拷贝。
    例:l9 = [0,1,[2,3],4]
    l10 = l9.copy()
    l9[2][1] = 5
    l10与l9均变为[0,1,[2,5],4]

    import copy
    l10 = copy.deepcopy(l9) :深拷贝,相当于嵌套的门牌号重新创建


    l1 = [[1,2,3]]
    3 就是浅拷贝

    id(x) : 取内存地址


    列表删除元素
    l9.remove(2) :移除列表元素中的2 (第一个索引) ,删完会移动,少用

    l9.pop(3) :弹出并移除第[3]个索引元素,会引起挪动(推荐这个),建议从尾部移除

    l9.clear() :清除列表所有元素,剩余一个空列表

    l9.reverse() :列表反转,不建议用,更多用反索引


    l9.sort(key = int) :将列表中所有元素用int转化成×××排序,转不了就报错;默认从小到大排列,元素类型本身不变
    l9.sort(key = str) :转化成字符串,按ascii码排序
    l9.sort(key = int,reverse=True) :从大到小排

    3 in l9 :判断3是否在列表中(如果3只在嵌套中,则False)

    l1 = [1,2,3]
    l2 = l1 相当于l2直接指向到l1

    转载于:https://blog.51cto.com/13445354/2370162

    展开全文
  • 主要介绍了python四种内置数据结构,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Python四种数据结构

    2018-04-25 08:16:09
    本篇文章将会讲解Python数据结构中的list、tuple、set、dict。 list list是一有序集合 操作数据 直接添加数据 mylist = ['Google', 'Microsoft', 'Apple'] 追加元素 mylist.append('Facebook') ...
  • python四种数据结构

    2021-04-20 15:30:09
    列表list a = [1,2,3] ##数组 a = ['b','c'] ##初始化 a[1] = 'd' ##修改 a.append('d') ##在列表末尾追加元素 a.pop() ##删除列表末尾元素 a.insert(2,'d') ##在指定下标插入元素 a.remove('b') ##移除列表中...
  • 对于每编程语言一般都会规定一些容器来保存某些数据,就像java的集合和数组一样python也同样有这样的结构 而对于python他有个这样的内置容器来存储数据,他们都是python语言的一部分可以直接使用而无需额外的...
  • 四种时间表示方法: # 1. string s = "2017-05-02 21:03:07" # 2. datetime import datetime datetime.datetime.now() # datetime.datetime(2017, 5, 2, 21, 4, 25, 348000) # 3. time.struct_time ...
  • Python四种常见数据结构比较Pythonlisttuplesetdict Contents 本质上的区别语法上的比较 本质上的区别 最重要的区别在于是否可变,是否有序这两个维度,可以分成4个象限,如下图 比较 语法上的比较 ...
  • Python中的内置数据结构(Built-in Data Structure):列表list、元组tuple、字典dict、集合set,涵盖的仅有部分重点。 一、列表list list的显著特征: 列表中的每个元素都可变的,意味着可以对每个元素进行修改和...
  • python是什么? 1:一门流行的脚本语言。 2:在web开发、网络开发、脚本...python四种数据结构 1:列表 #定义一个列表 shopList=['zl','maer','zhengl'] #获取列表的长度 print len(shopList) #遍历列表 ...
  • python数据结构四个链表的集合 结点的创建 import os # 创建节点 class Node: def __init__(self, data): self.data = data self.next = None self.prev = None 创建单链表类 class SingleLinkList: ""...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,278
精华内容 511
关键字:

python四种结构

python 订阅