精华内容
下载资源
问答
  • python的数据类型

    2017-05-26 12:06:00
    栈:  栈(Stack)是一个数据集合,可以理解为只能在一端进入或删除操作列表  栈特点:后进先出(last-in,first-out)  栈概念: ... 栈的python实现  不需要自己定义,使用列表...

    栈:

      栈(Stack)是一个数据集合,可以理解为只能在一端进入或删除操作的列表

      栈的特点:后进先出(last-in,first-out)

      栈的概念:

        1.栈顶

        2.栈底

      栈的基本操作:

        1.进栈(压栈):push

        2.出栈:pop

        3.取栈顶:gettop

      栈的python实现

      不需要自己定义,使用列表结构即可。

        进栈函数:append

        出栈函数:pop

        查看栈顶函数:li[-1]

      栈的应用--括号匹配问题

        括号匹配问题:给一个字符串,其中包含小括号、中括号、大括号,求该字符串中的括号是否匹配。

        1.()()[]{}          匹配

        2.([{()}])      匹配

        3.[](         不匹配

        4.[(])        不匹配

     1 def check_kuohao(s):
     2     stack = []
     3     for char in s :
     4         if char in {'(','[','{'}:
     5             stack.append(char)
     6         elif char == ")":
     7             if len(stack) > 0 and stack[-1] == '(':
     8                 stack.pop()
     9             else:
    10                 return False
    11         elif char == "]":
    12             if len(stack) > 0 and stack[-1] == '[':
    13                 stack.pop()
    14             else:
    15                 return False
    16         elif char == "}":
    17             if len(stack) > 0 and stack[-1] == '{':
    18                 stack.pop()
    19             else:
    20                 return False
    21     if len(stack) == 0:
    22         return True
    23     else:
    24         return False

     

    队列:

      队列(Queue)是一个数据集合,仅允许在列表的一端进行插入,另一端进行删除

      进行插入的一端成为队尾(rear),插入动作称为进队或入队

      进行删除的一端称为队头(front),删除动作称为出队

      队列的性质:先进先出(First-in,First-out)

      双向队列:队列的两端都允许进行进队和出队操作。

      使用方法: from collections import deque

        创建队列:queue = deque(li)

        进队:append

        出队:popleft

        双向队列队首进队:appendleft

        双星队列队尾进队:pop

      队列的实现原理

     1 maze = [
     2     [1,1,1,1,1,1,1,1,1,1],
     3     [1,0,0,1,0,0,0,1,0,1],
     4     [1,0,0,1,0,0,0,1,0,1],
     5     [1,0,0,0,0,1,1,0,0,1],
     6     [1,0,1,1,1,0,0,0,0,1],
     7     [1,0,0,0,1,0,0,0,0,1],
     8     [1,0,1,0,0,0,1,0,0,1],
     9     [1,0,1,1,1,0,1,1,0,1],
    10     [1,1,0,0,0,0,0,0,0,1],
    11     [1,1,1,1,1,1,1,1,1,1]
    12 ]
    13 
    14 dirs = [
    15     lambda x,y:(x+1,y),
    16     lambda x,y:(x-1,y),
    17     lambda x,y:(x,y+1),
    18     lambda x,y:(x,y-1),
    19 ]
    20 
    21 def mgmaze(x1,y1,x2,y2):
    22     stack=[]
    23     stack.append((x1,y1))
    24     while len(stack)>0 :  #只要栈不为空
    25         curNode = stack[-1]
    26         if curNode[0]==x2 and curNode[1] ==y2:
    27             #到达终点打印路径
    28             for p in stack:
    29                 print(p)
    30             return True
    31         for dir in dirs:
    32             nextNode = dir(*curNode)
    33             if maze[nextNode[0]][nextNode[1]] == 0:
    34                 stack.append(nextNode)
    35                 maze[nextNode[0]][nextNode[1]] = 2 #2表示已走过
    36                 break
    37         else:
    38             stack.pop()
    39             maze[curNode[0]][curNode[1]] = 2  #死路一条
    40     return False
    41 
    42 mgmaze(1,1,8,8)

     队列实现迷宫方法

     1 from collections import deque
     2 maze = [
     3     [1,1,1,1,1,1,1,1,1,1],
     4     [1,0,0,1,0,0,0,1,0,1],
     5     [1,0,0,1,0,0,0,1,0,1],
     6     [1,0,0,0,0,1,1,0,0,1],
     7     [1,0,1,1,1,0,0,0,0,1],
     8     [1,0,0,0,1,0,0,0,0,1],
     9     [1,0,1,0,0,0,1,0,0,1],
    10     [1,0,1,1,1,0,1,1,0,1],
    11     [1,1,0,0,0,0,0,0,0,1],
    12     [1,1,1,1,1,1,1,1,1,1]
    13 ]
    14 
    15 dirs = [
    16     lambda x,y:(x+1,y),
    17     lambda x,y:(x-1,y),
    18     lambda x,y:(x,y+1),
    19     lambda x,y:(x,y-1),
    20 ]
    21 def mgmaze(x1,y1,x2,y2):     #队列方法
    22     queue = deque()
    23     path = []
    24     queue.append((x1,y1,-1))
    25     while len(queue) > 0:
    26         curNode = queue.popleft()
    27         path.append(curNode)
    28 
    29         if curNode[0] == x2 and curNode[1] == y2:  #找到终点
    30             realpath = []
    31             p = len(path) -1
    32             while path[p][2] != -1:
    33                 realpath.append((path[p][0],path[p][1]))
    34                 p = path[p][2]
    35             realpath.append((path[p][0],path[p][1]))
    36             realpath.reverse()
    37             print(realpath)
    38             return True
    39 
    40         for dir in dirs:
    41             nextNode = dir(curNode[0],curNode[1])
    42             if maze[nextNode[0]][nextNode[1]] == 0 : #能走
    43                 queue.append((nextNode[0],nextNode[1],len(path)-1))
    44                 maze[nextNode[0]][nextNode[1]] == 2
    45     return False
    46 mgmaze(1,1,8,8)

     

    转载于:https://www.cnblogs.com/baifumei/p/6907881.html

    展开全文
  • 继续学习数据类型,发现python有一些方法作用是相似,比如:print, str, repr都会打印输出; 比如remove, pop, del都会删除元素。 那么它们之间又有什么区别呢? 今天先来比较一下remove, pop, del这一组方法对于...

    继续学习数据类型,发现python有一些方法的作用是相似的,比如:print, str, repr都会打印输出; 比如remove, pop, del都会删除元素。
    那么它们之间又有什么区别呢?
    今天先来比较一下remove, pop, del这一组方法对于不同的数据类型有什么区别。


    remove pop del
    list a.remove[‘name’] 删除列表a中第一个’name’元素。
    返回Null
    => a.pop(1)删除列表 a 中索引为 1 的元素 。
    => a.pop()删除列表a的最后一个元素。
    返回删除的值
    => del a[1]删除列表a中索引为1的元素;
    => del a[1, 3]删除列表a中索引1和2的元素 ;
    => del a 删除整个列表a。
    没有返回值
    tuple - - 元组中元素不允许删除
    del tup会删除整个tup元组
    dict - => dict.pop(key)删除键key所在的键值对
    返回被删除的值
    如果key不存在,则报错
    => dict.pop(key, default)删除键key所在键值对
    如果key不存在,返回default
    => del dict[key] 删除键key所在的键值对
    没有返回值
    => del dict 删除整个字典
    set set.remove(item)删除元素item, 返回删除的元素
    元素不存在,会报错
    set.pop() 随机删除元素
    返回删除的元素
    set是无序的,不能索引
    del set删除整个set

    补充

    1. 删除dict元素还有一种内置方法popitem()
      随机返回并删除字典中的一对键和值(一般删除末尾对)
      返回一个键值对(key,value)形式
    2. 删除set元素还有一种内置方法discard()
      set.discard(item) 删除元素item。与remove不同的是,如果item不存在,不会报错
    3. del是python语句,语法:del obj
      remove, pop, discard, popitem都是数据类型的内置方法,语法:Type.method()
    展开全文
  • Python数据类型的性能

    2019-09-23 12:45:08
    Python数据类型的性能list与dict4种方法生成前n个数列表list基本操作大O数量级list.pop的计时实验实验代码运行结果dict数据类型list和dictin操作对比实验代码实验结果更多Python数据类型操作复杂度 ...

    list与dict

    4种方法生成前n个数的列表

    from timeit import Timer
    
    
    def test_01():    # 利用循环连接列表(以'+'的方式)
        num_list = []
        for i in range(0, 1000):
            num_list += [i]
    
    
    def test_02():    # 利用循环连接列表(用'append'方法)
        num_list = []
        for i in range(1000):
            num_list.append(i)
    
    
    def test_03():    # 利用列表推导式
        num_list = [i for i in range(1000)]
    
    
    def test_04():    # 利用range函数转化为列表
        num_list = list(range(1000))
    
    
    if __name__ == '__main__':
        """
        使用timeit模块的原因: 这四个个函数执行时间太快, time.time()之差可能为0,无法比较
        生成Timer对象的两个参数:
            第一个参数: 所需执行的语句 (字符串形式 如下方的"test_01()")
            第二个参数: setup语句(安装语句): 把反复运行语句里面出现的变量利用import导入
        """
        t1 = Timer('test_01()', 'from __main__ import test_01')
        print("利用循环连接列表(以'+'的方式)耗时: {}s".format(t1.timeit(number=1000)))    # 反复运行1000次
    
        t2 = Timer('test_02()', 'from __main__ import test_02')
        print("利用循环连接列表(用'append'方法)耗时: {}s".format(t2.timeit(number=1000)))
    
        t3 = Timer('test_03()', 'from __main__ import test_03')
        print("利用列表推导式耗时: {}s".format(t3.timeit(number=1000)))
    
        t4 = Timer('test_04()', 'from __main__ import test_04')
        print("利用range函数转化为列表耗时 {}:".format(t4.timeit(number=1000)))
    
    

    运行结果:

    利用循环连接列表(以'+'的方式)耗时: 0.08248674s
    利用循环连接列表(用'append'方法)耗时: 0.06562316899999998s
    利用列表推导式耗时: 0.034037808s
    利用range函数转化为列表耗时 0.014597790999999999:
    

    由此得出:最有方法为第四种”range()函数转化为列表“

    list基本操作的大O数量级

    操作 O()
    index[] O(1)
    index assigment O(1)
    append O(1)
    pop() O(n)
    insert(i, item) O(n)
    del operate O(n)
    iteration O(n)
    contains(in) O(n)
    get slice[x: y] O(k)
    del slice O(n)
    set slice O(n+k)
    reverse O(n)
    concatenate O(k)
    sort O(n log n)
    multiply O(nk)

    list.pop的计时实验

    pop():从列表末尾一处元素,O(1)
    pop(i): 从列表中移除索引为i的元素,O(n)

    这是一种对常用和不常用的折衷方案
            从中部移除元素需把一处元素后面的元素全部向前挪位复制一边,虽然看起来笨拙但这种实现方法能够保证列表“按索引取值”和“赋值”的操作很快,达到O(1)

    实验代码

    from timeit import Timer
    
    x = list(range(2000000))
    t1 = Timer('x.pop(0)', 'from __main__ import x')
    print('x.pop(0)所需要的时间为: {}'.format(t1.timeit(number=1000)))
    
    x = list(range(2000000))
    t2 = Timer('x.pop()', 'from __main__ import x')
    print('x.pop()所需要的时间为:{}'.format(t2.timeit(number=1000)))
    print()
    print('pop(0)    pop()')
    for i in range(1000000, 10000001, 1000000):
        x = list(range(i))
        p_zero = t1.timeit(number=1000)
        x = list(range(i))
        p_last = t2.timeit(number=1000)
        print('{:.6}    {:0.6}'.format(p_zero, p_last))
    
    

    运行结果

    x.pop(0)所需要的时间为: 2.8185749490000003
    x.pop()所需要的时间为:7.777800000008384e-05
    
    pop(0)    pop()
    0.936079    7.2889e-05
    2.53314    7.4222e-05
    4.15481    7.4222e-05
    6.10848    7.4667e-05
    7.28053    7.5556e-05
    8.91227    7.2e-05
    10.6295    0.000124001
    12.6854    7.6889e-05
    14.1984    9.5111e-05
    15.2277    7.3778e-05
    

    dict数据类型

    字典与列表不同, 根据key找到value,而列表是根据索引
    常用的取值get和赋值set,性能为O(1)
    另一个重要操作contains(in)是判断字典种是否存在某个key,性能也为O(1)
     

    操作 O()
    copy O(n)
    get item O(1)
    set item O(1)
    delete item O(1)
    contains(in) O(1)
    iteration O(n)

    list和dict的in操作对比

    设计一个性能试验来验证list种检索一个值,以及dict种检索一个之的计时对比

    实验代码

    import timeit
    import random
    
    print("i    list_time    dict_time")
    for i in range(10000, 100001, 10000 ):
        t = timeit.Timer("random.randrange({}) in x".format(i), "from __main__ import random, x")
        x = list(range(i))
        list_time = t.timeit(number=1000)
        x = {j: None for j in range(i)}
        dict_time = t.timeit(number=1000)
        print("{}    {:.3}    {:.3}".format(i, list_time, dict_time))
        
    

    实验结果

    i    list_time    dict_time
    10000    0.0656    0.00123
    20000    0.13    0.00116
    30000    0.195    0.000963
    40000    0.323    0.00118
    50000    0.327    0.00104
    60000    0.427    0.001
    70000    0.454    0.00112
    80000    0.593    0.0011
    90000    0.582    0.00103
    100000    0.654    0.00171
    
    

    list和dict的in操作对比

    • 可见字典的执行时间与规模无关
    • 列表的执行时间随着列表的规模加大而线性上升

    更多Python数据类型操作复杂度

    Python官方的算法复杂度网站:https://wiki.python.org/moin/TimeComplexity

    展开全文
  • python组合数据类型

    2019-09-13 18:40:23
    处理,提供了各种组合类型,常见如列表、元组、字典等组合数据类型。 列表 List 列表语法结构:通过一堆方括号包含起来数据序列,可以存放重复数据。 append 列表中追加数据:append() insert(index...

    python 中为了方便一部分相似数据
    的处理,提供了各种组合类型,常见的如列表、元组、字典等组合数据类型。

    列表 List 列表的语法结构:通过一堆方括号包含起来的数据序列,可以存放重复数据。

    在这里插入图片描述
    append
    列表中追加数据:append()
    在这里插入图片描述

    insert(index,data)
    列表中指定位置(第一个参数就是要插入数据的索引位)追加数据:insert()
    在这里插入图片描述

    pop()
    删除列表末尾的元素:pop()
    在这里插入图片描述

    pop(index)
    删除列表中指定位置的元素:pop(index)
    在这里插入图片描述
    |-- remove ()
    通过元素本身将元素移除列表
    在这里插入图片描述
    |-- index()
    查找元素在列表中的位置,注意:如果元素不存在,则抛出异常
    在这里插入图片描述如果是数字则不需要中括号与引号
    |-- reverse ()
    翻转列表
    在这里插入图片描述
    |-- sort()
    将列表排序,按照ASCII表排序
    在这里插入图片描述
    |-- copy
    复制、拷贝对象(浅拷贝)
    在这里插入图片描述
    |-- extend
    合并列表
    在这里插入图片描述

    集合 set 中存放数据是不能重复的,并且是没有存放顺序的,也就是没有下 标的。

    语法:使用一对大括号/花括号包含起来的一组数据
    在这里插入图片描述

    当然列表也可以转换为集合,语法为:
    集合名称 = set([‘将列表转换成集合’]);
    在这里插入图片描述

    |-- add
    添加元素
    在这里插入图片描述
    |-- pop
    随机移除元素
    在这里插入图片描述
    |-- remove # 移除指定的元素
    在这里插入图片描述

    元组在 python 中,其实是列表的一种特殊的形式,一旦声明创建就不允许改变。 语法结构:使用一对圆括号包含起来的一组数据,可以存放重复数据。

    在这里插入图片描述

    注意:元组中如果存放的是其他的内容可变的元素的话,一定要注意此时的元组中对象 的数据是可变的。

    count
    统计元素出现的次数
    在这里插入图片描述

    index
    查找元素在列表中的位置,注意:如果元素不存在,则抛出异常,如果该元素存在多个,则返回第一个
    在这里插入图片描述\

    为了方便数据在组合数据类型中的管理,python 还提供了一种特殊存储数据的组合数 据类型:字典。通过 key-value 键值对的形式来存储数据,可以很方便的通过 key 来对 value 进行增删改查的操作

    在这里插入图片描述

    |-- clear
    |-- copy
    |-- pop(“key”) # 通过key删除对应的键值对
    |-- popitem # 随机删除一个键值对
    |-- get # 通过key获取值
    在这里插入图片描述
    |-- keys()
    |-- values()
    |-- items()

    展开全文
  • python数据类型汇总一.数值型Number1.int2.float3.complex4.数据类型转换二.字符串str对字符串进行操作,字符串方法。1. 字符串切片2. 字符串统计3. 判断4. 拼接5. 对字符串操作后输出6. 转换7. 索引三.列表list对...
  • python之列表类型内置方法 文章目录python之列表类型内置方法引入一.定义方式二.类型转换三....pop7、循环取值需要掌握操作()1.统计字符个数 : .count()2.扩展,追加多个值 : .extend()3.清空列表 :
  • Python基础数据类型

    2019-06-18 01:18:28
    一个包含唯一元素可变和无序集合数据类型 变量初始化,同列表类似,元素可以是任何数据类型(排除列表) 添加(add、update) update:把要传入元素拆分,作为个体传入到集合中 删(remove/pop/discard): remove:...
  • Python-数据类型:字典

    2021-06-21 22:48:04
    Python-数据类型:字典0 前言6 字典Dictionary6.1 字典方法列表6.2 创建字典6.3 访问字典 get keys values6.4 修改字典 update pop clear6.5 字典解包 items keys values 0 前言 >>返回Python系列文章目录&...
  • python基本数据类型

    2017-04-11 14:34:11
    1.list–[] 列表,有序...pop(n)–pop()从尾部删除元素,和append相对应,返回被删除元素,也可指定删除元素位置n sort()–针对统一类型的元素可进行排序操作,不是同一类型会报错。 注意:可以从头到尾也可以从
  • python数据类型

    2020-05-28 21:43:14
    列表: ...元组Tuple,用法与List类似,但Tuple一经初始化,就不能修改,没有List中append(), insert(), pop()等修改方法,只能对元素进行查询;因为tuple不可变,所以代码更安全。如果可能,能用t
  • #coding=utf8 ''' 标准类型函数: cmp():进行序列比较算法规则如下: ----------------------------...2. 如果比较元素是同类型的,则比较其值,返回结果 3. 如果两个元素不是同一种类型,则检查它们是否是数字
  • # 移除指定key元素-pop() car_dict = {"name": "特斯拉", "name1": "标致", "name2": "道奇", "name3": "jeeb", "name4": "凯迪拉克"} car_dict.pop("name") print(car_dict) # 复制dict-copy() car_dict1 = car_...
  • python数据类型

    2020-01-07 17:17:01
    ####列表 #添加 appent() extend()...#删除 del remove() pop() clear() #其它 reverse() import random ll = [x for x in range(10)] ll.append(“sdcs”) ll.extend(“sdfsdfsdfs”) #列表合并 ll.insert(3,“sd...
  • Python-数据类型

    2015-05-26 14:01:45
    Python内置了字典:dict支持,dict全称dictionary,在其他语言中也称为map,使用键-值(key-value)存储,具有极快查找速度。 例如: >>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85} >>>...
  • python基础数据类型

    2019-06-30 21:10:00
    ①:int整型,float浮点型,(3E2代表3*10二次方)booleen布尔型,复数型 ②:字符串  字符串截取操作 str=‘hello world...索引下表是在0开始,方法append() pop() ④:元组,tuple 元组一旦定义好,里面元素...
  • python常用数据类型

    2018-04-05 12:47:53
    list list是一种有序集合,可以随时添加和删除其中元素。 常用操作 初始化一个list 通过len()函数获得list元素个数 使用索引来访问list中元素,索引是从0开始,...删除列表末尾元素使用pop()方法...
  • Python数据类型之六6.字典类型描述特点1.字典增删改查2.字典内置函数(1). len(dict)(2). str(dict)(3). type(variable)2.字典常用内置方法(1)items()(2)keys() / values()(3)update(dict2)(4)pop(key)(5)popitem...
  • python的基本数据类型

    2017-08-17 19:37:00
    int long float str list tuple dict set 转载于:https://www.cnblogs.com/POP-w/p/7384009.html
  • python经典数据类型

    2018-07-08 23:38:42
    2)常用方法:append insert pop 3)下标截断取值 4)如何更新值 5)for循环结合使用遍历列表元素 6)有序   2、实战操作 1)#往列表当中追加一个值:列表变量名.append(数据),加到列表末尾 list_a = []...
  • Python常用数据类型

    2017-12-03 23:22:02
    一 、列表 name = ['zhangshan', 'lishi', 'wangwu'] # 列表赋值 name.append('liujun') # 增,默认增加到最后位置 ...name.remove(name[0]) # 删除指定值name.pop(1) # 弹出指定索引值,默认弹出最后
  • python3传参类型记录

    2018-11-01 17:53:42
    python3中, 给函数传入dict和list, 相当于是传入了一份引用copy (浅拷贝) 向函数中传入dict: def modify(d): d['a'] = 11 def delete(d): d.pop('b') def insert(d): d['c'] = 3 d1 = {'a': 1, 'b': 2} ...
  • python中常见集合类型介绍

    千次阅读 2020-08-30 18:37:22
    list是python的一个列表集合,有顺序,可以包含不同类型的元素,用L=['a',1,123]表示,与数组类似,下标都是从0开始,是可变长度集合;append方法可在list末尾添加元素;insert(x,y)方法可在任意位置添加一个元素;...
  • python字典类型

    2020-12-02 15:37:10
    字典类型—映射 1.键值对 2.采用{}和dict创建 3.键值对用冒号:表示 del d[k] 删除字典d中键k对应数据值 k in d 判断k是否在d中,返回true或false d.keys() 返回d中所有键信息 d.values() 返回字典d中...
  • 本文实例讲述了Python基于listappend和pop方法实现堆栈与队列功能。分享给大家供大家参考,具体如下: #coding=utf8 ''''' 堆栈: 堆栈是一个后进先出(LIFO)数据结构。 在栈上"push"元素是个常用术语,意思是把...
  • 我们知道,python有列表和字典等数据类型,下面我们就以列表为例,分析对列表操作一些函数性能。 pop操作测试 1 x = range(2000000) 2 pop_zero = Timer("x.pop(0)","from __main__ import x") 3 print(...
  • list列表中可存储不同元素类型的数据,通过索引访问相应元素,类似于数组操作方式; append()方法再在尾部追加元素; insert(索引号, 插入内容)实现在指定位置插入元素; pop()方法直接删除尾部元素,而pop(0)...
  • python 字典类型用法

    2019-03-13 15:07:00
    python 字典类型用法info={ 'name':'唐家三少', 'age':180}info2={ 'name':'冰火魔厨' 'love':'nice'}1 popitem取出字典中最后元素print(info.popitem())2 pop取出字中key为namevalue print(info.pop('name'))3...

空空如也

空空如也

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

python的pop类型

python 订阅