精华内容
下载资源
问答
  • 如果我们扩大清单的范围,统计我们过去一周所有的花费情况,那么这也是一个清单,但这个清单里会类别不同的项,比如我们买东西是一种花费,交水电费也是一种花费,这些项的类型是可以使不同的。python的...

    (1)列表(list)

    什么是列表呢?我觉得列表就是我们日常生活中经常见到的清单。比如,统计过去一周我们买过的东西,把这些东西列出来,就是清单。由于我们买一种东西可能不止一次,所以清单中是允许有重复项的。如果我们扩大清单的范围,统计我们过去一周所有的花费情况,那么这也是一个清单,但这个清单里会有类别不同的项,比如我们买东西是一种花费,交水电费也是一种花费,这些项的类型是可以使不同的。python的列表个跟清单的道理是一样的,特点就是:可重复,类型可不同。类型不同也是跟数组最本质的区别了。python里的列表用“[]”表示:

        lst = ['arwen',123]
        print lst[0] 
        print lst[1]
        lst[0] = 'weiwen'
    

    (2)元组(tuple)

    元组和列表在结构上没有什么区别,唯一的差异在于元组是只读的,不能修改。元组用()表示,如:

    tup = ('arwen',123)
    

    print tup[0]
    

    print tup[1]
    

    (3)集合(set)

    就是我们数学学的集合,没有什么特殊的定义。集合最好的应用是去重。集合没有特殊的表示方法,而是通过一个set函数转换成集合,如:

    lst = [ 1, 1, 0]
    
      lst_set = set( lst )  #lst_set 为1 , 0
    
      tup = (2, 2, 1)
    
      tup_set = set( tup) # tup_set为2 , 1
    
      for item in lst_set:
    
        print item
    

    (4)字典(dict)

    字典存储键值对数据,如:

    1:a,2:b,3:c

    字典最外面用大括号,每一组用冒号连起来,然后各组用逗号隔开。

    字典最大的价值是查询,通过键,查找值。
    创建一个字典:

    方法一:传入 键=值 的形式
    d = dict(a=1,b=2,c=3)
    d
    {'a': 1, 'b': 2, 'c': 3}
    
    方法二:传入映射对象,字典创建字典
    d = dict({'a': 1, 'b': 2, '3': 3}) 
    
    方法三:传入可迭代对象
    d = dict(zip(['one','two','three'],[1,2,3]))
    或者
    d = dict([('one', 1), ('two', 2), ('three', 3)])
    

    这里写一个特殊的

    d = dict([('one', 1), ('two', 2), ('three', 3),('three', 4),('three', 5)])
    d
    {'one': 1, 'two': 2, 'three': 5}
    

    如果传进去的值,有相同的键,那么键的值取最后一次出现的值。

    展开全文
  • 那么列表元组和别的字符串序列有什么不同呢?前者是container sequence,后者是flat sequence。意思是列表和元组可以包含任意的对象(Python中一切皆对象),所以你可以把任何东西放到它们里面。包括类,函数,它们...

    Python中,列表和元组属于序列。序列中的每个元素都被分配一个编号,称为索引。列表、元组、字符串、array.array都属于序列

    那么列表元组和别的字符串序列有什么不同呢?前者是container sequence,后者是flat sequence。意思是列表和元组可以包含任意的对象(Python中一切皆对象),所以你可以把任何东西放到它们里面。包括类,函数,它们也是对象。

    列表是可以修改的,而元组不可以,如果要添加或者删除某些元素,就只能用列表,为了限制某些元素,就会用到元组。一般来说,列表可以替代元组。在列表之中,有索引,分片,加,乘等等。

    1.列表
      list是处理一组有序项目的数据结构,即你可以在一个列表中存储一个序列的项目。列表中的项目。列表中的项目应该包括在方括号中,这样python就知道你是在指明一个列表。一旦你创建了一个列表,你就可以添加,删除,或者是搜索列表中的项目。由于你可以增加或删除项目,我们说列表是可变的数据类型,即这种类型是可以被改变的,并且列表是可以嵌套的
    实例:
    #coding=utf-8
    animalslist=['fox','tiger','rabbit','snake']
    print "I don't like these",len(animalslist),'animals...'

    for items in animalslist:
    print items,

    print "\n操作后"   
    #对列表的操作,添加,删除,排序
    animalslist.append('pig')
    del animalslist[0]
    animalslist.sort()
    for i in range(0,len(animalslist)):
        print animalslist[i],
    结果:
    I don't like these 4 animals...
    fox tiger rabbit snake
    操作后
    pig rabbit snake tiger
    2.元组

      元祖和列表十分相似,不过元组是不可变的。即你不能修改元组。元组通过圆括号中用逗号分隔的项目定义。元组通常用在使语句或用户定义的函数能够安全的采用一组值的时候,即被使用的元组的值不会改变。元组可以嵌套
    >>> zoo=('wolf','elephant','penguin')
    >>> zoo.count('penguin')
    1
    >>> zoo.index('penguin')
    2
    >>> zoo.append('pig')
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    AttributeError: 'tuple' object has no attribute 'append'
    >>> del zoo[0]
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'tuple' object doesn't support item deletion
    3 字典
    字典类似于你通过联系人名称查找地址和联系人详细情况的地址簿,即,我们把键(名字)和值(详细情况)联系在一起。注意,键必须是唯一的,就像如果有两个人恰巧同名的话,你无法找到正确的信息。
      键值对在字典中以这样的方式标记:d = {key1 : value1, key2 : value2 }。注意它们的键/值对用冒号分割,而各个对用逗号分割,所有这些都包括在花括号中。另外,记住字典中的键/值对是没有顺序的如果你想要一个特定的顺 序,那么你应该在使用前自己对它们排序
    实例:
    #coding=utf-8
    dict1={'zhang':'张家辉','wang':'王宝强','li':'李冰冰','zhao':'赵薇'}
    #字典的操作,添加,删除,打印
    dict1['huang']='黄家驹'
    del dict1['zhao']
    for firstname,name in dict1.items():
        print firstname,name
    结果:
    li 李冰冰
    wang 王宝强
    huang 黄家驹
    zhang 张家辉

    展开全文
  • 什么使用列表? 可以包含不同种类、任意类型的对象,甚至可以嵌套列表--异构性 列表里装的元素都是顺序的--有序性 列表里装的元素都是顺序的--可修改性 ''' #'append', 'clear', 'copy', 'count', 'extend', ...

    废话不BB,都在代码里:

    '''
    列表学习
    为什么使用列表?
    可以包含不同种类、任意类型的对象,甚至可以嵌套列表--异构性
    列表里装的元素都是有顺序的--有序性
    列表里装的元素都是可以被修改的--可修改性
    '''
    
    #'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'
    l = [1,2,3,4,5,6,7,8,10,9]
    # 返回第一次的索引位置
    print (l.index(3))
    #只针对数字元素
    l.sort()
    l = l * 1
    l.append('I')
    # 'I'出现的次数
    l.count('I')
    # 第几位插入第几位
    l.insert(0,"Me")
    # 必须是可以迭代的元素
    l.extend('AM')#转成字母插入
    l.extend(['No.1'])
    # 只会删除掉一个元素,没有则报错:x not in list
    l.remove('Me')
    l.remove(10)
    # 删除第几位元素
    l.pop(4)
    # 逆序
    l2 = l[::-1]
    l3 = list(reversed(l2))
    # 第一位到第三位
    l4 = l[1:3]
    # 从0到n-1的位置
    l5 = l[:-1]
    # 最后三位数据
    l6 = l[-3:]
    print (l== l3)
    #return 队列尾
    print (l.pop())
    print (l6)
    print (l.count(1))
    # 多维队列
    matrix = [[1,2,3],[4,5,6],7,8,9]
    print(matrix[1][1],matrix[3])
    # 遍历
    for i in l:
       i #为遍历项
       pass
    
    for i in range(len(l)):
        l[i]#为遍历项
        pass
    
    for i in range(1,10,2):# 从1开始到10,步长为2
        l[i]#为遍历项
        pass
    
    it = iter(l)
    for i in it:
        i#为遍历项
        
    for i in range(len(l)-1,-1,-1):#倒序遍历
        (l[i])#为遍历项
        pass
    
    '''
    元表
    为什么要用元表:
    1、tuple中是不可变的,在CPython中tuple被存储在一块固定连续的内存中,创建tuple的时候只需要一次性分配内存。
    但是List被的被存储在两块内存中,一块内存固定大小,记录着Python Object(某个list对象)的信息,另一块是不固定大小的内存,用来存储数据。所以,查找时tuple可以快速定位(C中的数组);
    list必须遍历(C中的链表)。在编译中,由于Tuple是不可变的,
    python编译器将它存储在它所在的函数或者模块的“常量表”(constants table)中。
    运行时,只要找到这些预构建的常量元组。但是List是可变的,必须在运行中构建,分配内存。
    2、元表可以在字典里作为Key值输入
    '''
    # 'count', 'index'
    t_tuple = (1,2,3)
    print(t_tuple.count(2),t_tuple.index(3))
    
    '''
    字典
    查询速度极快。哈希算法将任意长度的二进制值映射为较短的固定长度的二进制值,这个小的二进制值称为哈希值。
    哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该段落的一个字母,
    随后的哈希都将产生不同的值。要找到散列为同一个值的两个不同的输入,在计算上是不可能的,所以数
    据的哈希值可以检验数据的完整性。一般用于快速查找和加密算法。
    占用内存高。
    '''
    #'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'
    # 创建方法1
    dic1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5,'f':[6,7,8,9]}
    # 创建方法2
    t =(['a',1],['b',2],['c',3],('d',4),{'e',5})
    dic2 = dict(t)
    # 创建方法3
    dic3 =  {}.fromkeys(('a','b','c','d','e'),0)
    # 长度
    len(dic1)
    # 赋值
    dic1['b']=0
    # 复制
    # 浅拷贝(copy):拷贝父对象,不会拷贝对象的内部的子对象。
    # 深拷贝(deepcopy): copy 模块的 deepcopy 方法,完全拷贝了父对象及其子对象。
    dic4 = dic1.copy()
    print(id(dic4['c']),id(dic1['c']))
    dic1['c'] = 0
    dic1['f'].remove(6)
    print((dic4['f']),dic4['c'])
    
    # 输出value
    d = dic1.get('f')
    e = dic1.setdefault('f') #没有则输出None
    f = dic1['f']
    print(dic1.items())
    
    # 删除
    del(dic1['a'])
    dic1.pop('b',False)#没有Key返回第二个值
    dic1.popitem()#删除最后一位
    
    # 增加元素
    dic1.update(dic2)# 有重复的元素则跳过
    print(dic1)
    # 遍历
    for key,value in dic1.items():
        key,value
    for key,value in enumerate(dic1):
        key,value
    
    # 遍历key
    for key in dic1.keys():
        key
    for key in dic1:
        key
    # 遍历value
    for value in dic1.values():
        value
    
    
    展开全文
  • 列表 元组 集合 字典 列表 什么是我们日常生活中经常见到的清单。比如,统计过去一周我们买过的东西,把这些东西列出来,就是清单。由于我们买一种东西可能不止一次,所以清单中是允许重复项的。如果我们扩大...

    列表 元组 集合 字典


    列表

    什么是我们日常生活中经常见到的清单。比如,统计过去一周我们买过的东西,把这些东西列出来,就是清单。由于我们买一种东西可能不止一次,所以清单中是允许有重复项的。如果我们扩大清单的范围,那么这也是一个清单,但这个清单里会有类别不同的项,交水电费也是一种花费,这些项的类型是可以使不同的。python的列表个跟清单的道理是一样的,特点就是:可重复,类型可不同。类型不同也是跟数组最本质的区别了。python里的列表用“[]”表示:

    names1=['zhangsan','lisi','wangermazi','zhaosi',['phone',1000],'wangwu']
    #列表读取
    
    
    a=names1[1]  #listname[position],根据位置取内容
    print(a)
    b=names1.index('zhaosi')  #index根据内容找位置
    print(names1[0]) #打印下标为0的值
    print(names1[1]) #打印下标为1的值
    print(names1[-1]) #打印下标为-1的值(倒数第一个)
    
    #切片 ":"右边不包含左边包含
    print(names1[:])#全部打印
    print(names1[:3])#打印下标是0到下标为3的值,不包含3
    print(names1[:-1])#打印到倒数第二位
    print(names1[1:-1])#打印下标为1到倒数第二位
    print(names1[::-1])#倒序打印
    print(names1[::2])#间隔为2打印全部列表
    print(names1[::2])#间隔为2打印全部列表
    
    
    #列表写入
    #列表追加 append
    names1.append('Hello world')
    print(names1)
    
    #列表插入insert
    names1.insert(0,'wanneng') #插入位置,值
    print(names1)
    

     #修改

    names1[0]='Wanneng'
    print(names1)
    #删除del
    del names1[0] #删除位置
    print(names1)
    
    #remove
    print(names1)
    names1.remove('zhaosi')  #删除zhaosi如果有多个删除第一个
    print(names1)
    
    #pop() 默认删除最后一个值,可写明位置
    print(names1)
    names1.pop(-1) #删除位置编号为-1的值
    print(names1)
    #扩展extend()
    name1=[1,2,3,]
    name2=[3,4,5]
    name1.extend(name2)
    print(name1)
    #列表拷贝
    name1=[1,2,3,]
    name2=[3,4,5]
    name3=name1.copy()
    name3.append(7)
    print(name3)
    print(name1)
    #列表值统计
    name4=name1.extend(name2)
    print(name4)
    # print(name4.count(3))  #统计3的个数
    #列表排序(字符串和数字混合不能排序,尴尬不)
    name4.append('7')
    name4.sort() #正序排序
    #   line 74, in <module>
    #     names1.sort()
    # TypeError: '<' not supported between instances of 'list' and 'str'
    name4[-1]=7
    print(name4)
    name4.reverse()#反序
    print(name4)
    
    #获取下标index
    print(names1)
    print(names1.index('lisi'))

    元组


    #写法,元组只能查询 #tuple_1=('value1','value2','value3')

    list1=(1,2,3,4,3,'make','kobe')
    print(list1)
    print(list1.index(3)) #index方法
    print(list1.count(3)) #count方法

    集合

    集合就是我们数学学的集合,没有什么特殊的定义。集合最好的应用是去重。集合没有特殊的表示方法,而是通过一个set函数转换成集合

    lst = [ 1, 1, 0]
    
    lst_set = set(lst) #lst_set 为1 , 0
    print(lst_set)
    
    tup = (2, 2, 1)
    tup_set = set( tup) # tup_set为2 , 1
    print(tup_set)
    #
    for item in lst_set:
        print(item)

     

     

    字典

    #字典写法
    data={
        1:11,
        2:22,
        3:33,
        4:{
            4:401,
            4:{402:4002
               },
        },
        'china':'中国',
        'chinas':['中国'],
    }
    data[2]='葫芦娃'
    print(data.get(2))
    #字典的写法  {key:value},key必须是唯一的.
    #dict 增加
    data[22]='葫芦娃'
    data[5]='葫芦娃'
    data[2]='葫芦娃'
    print(data)
    #dict 修改
    data[2]='222'
    print(data)
    #dict 删除
    data.pop(4) #pop删除key值为4的数据组
    del data[2] #del删除key2
    data.popitem() #随机删除
    print(data)
    #dict查找
    print(data.get(1)) #获取key为1的内容,get的值如果不存在返回None
    print(4 in data)  #key 4在不在data字典里面
    print(data['china']) #获取key为china的内容,如果key不存在则会报错
    
    print(data.keys())
    #修改
    data['chinas'][0] +='longyao'#值修改为['中国longyao'],值为数组
    # data['chinas'] = 'longyao1' #值修改成longyao1
    
    print(data)
    #setdefault
    data.setdefault(1,'allen') #创建一个key  jp 值allen的条目,如果key存在则不发生改变
    print(data)
    #
    data2={
        'a':'aa',
        'b':'bb',
        3:'cc',
    }
    data.update(data2) #如果两个字典中有重复的后者覆盖之前的没有的就合并
    print(data)
    #item 字典变成列表
    print(data.items())
    #fromkeys初始化一个字典
    a=dict.fromkeys([10,9,3],[11,22,'dac']) #初始化一个新的字典(value都是相同的)key 1 2 3 value是[11,22,'dac']
    a[10][1]='33333'  #这种方法创建的字典由于内存共享修改的后的单个value会全部更改。
    print(a)

    ___________________________

    #练习1

    创建列表data2

    data2={
        'a':'aa',
        'b':'bb',
        3:'cc',
    }

    打印key 和value的值

    1.

    for i in data2:
        print(i,'-----',data2[i])

    2.

    #转换成列表把key和value分别赋值给列表的下标0和1
    for i,x in data2.items():
        print(i,x)

    3.

    #enumerate获取行号
    for x,y in enumerate(data2.items(),1): #默认从0开始,本例从1开始计数
        print(x,y[0],y[1])

     

    练习2

    引用for循环if。。。else循环,while ,数组,列表

    1.创建列表格式是  商品名称:商品价格

    2.对着写商品进行增删改查

    #__Author:  Playon
    #__Date:    2016/3/12 12:05
    #-*- coding:utf-8 -*-
    product={
        '苹果':'6',
        '栗子':'25',
        '鸡蛋':'2.5',
        '花菜':'26',
        'phone':'6000',
        'pen':'16',
    }
    
    def price():
        #price change
        choice = input('Please input change goods:')
        if choice in product:
            price_new=input('Please input %s new price:'%choice)
            product[choice]=price_new
        else:
            print('Goods %s do not exist!'%choice )
    
    def goods_add():
        #goods add
        choice = input('Input new goods name:')
        price = input('Input new goods price:')
        if choice in product:
            print(choice ,'existed')
        else:
            product[choice]=price
    def goods_del():
        # goods del
        choice = input('Input delete goods:')
        if choice in product:
            del product[choice]
        else:
            print('%s not existed!')
    
    while True:
        num = 1  #定义商品序号从1开始
        for goods in product:
    
            print('\033[1;34;m%s.%s\t\t%s\033[0m'%(num,goods,product[goods])) #按照指定格式打印商品
            num +=1
        #选择操作类型
        choice_plan= input(
    """\033[0;33;m############## 请选择 ################
    #       a---添加商品选择 a            #
    #       e---编辑商品选择 e            #
    #       d---删除商品选择 d            #
    #       q---退出系统选择 q            #
    #####################################\033[0m""")
        if choice_plan == 'a':
            goods_add()
        elif choice_plan == 'e':
            price()
        elif choice_plan == 'd':
            goods_del()
        elif choice_plan == 'q':
            break
        else:
            print('Choice Error!')
            continue
    View Code

     

     

     

     

    Please input pen new price:89
    1.苹果 6
    2.栗子 25
    3.鸡蛋 2.5
    4.花菜 26
    5.phone 6000
    6.pen 89
    ############## 请选择 ################
    #      a---添加商品选择 a       #
    #      e---编辑商品选择 e       #
    #      d---删除商品选择 d       #
    #      q---退出系统选择 q        #
    #####################################

     

    转载于:https://www.cnblogs.com/playon/p/11004977.html

    展开全文
  • 如果我们扩大清单的范围,统计我们过去一周所有的花费情况,那么这也是一个清单,但这个清单里会类别不同的项,比如我们买东西是一种花费,交水电费也是一种花费,这些项的类型是可以使不同的。py...
  • 1.‘Type’(元组)与列表类似,不同之处在于元组的元素不能修改。 2.元组:表示多个元素组成的列表。 3.元组在‘Python’开发中,特定的应用场景。 4.用于存储一串信息,数据之间使用‘,’分割 5.元组索引从‘0’...
  • (1)字符串这个没有什么好说的,在Python中以单引号或者双引号包围...如果我们扩大清单的范围,统计我们过去一周所有的花费情况,那么这也是一个清单,但这个清单里会类别不同的项,比如我们买东西是一种花费,交...
  • 列表比字符串还强大“蜘蛛腿、青蛙脚趾头、蝾螈眼、蝙蝠翅、鼻涕虫油和蛇蜕皮”,这不是普通的采购清单(除非你是个巫师wizard),不过我们要用它来作为例子看看字符串和列表有什么不同。我们可以把清单上的这一系列...
  • 元组是异构数据结构(即,它们的条目具有不同的含义),而列表是同构序列.元组有结构,列表有顺序.使用这种区别使代码更加明确和易懂.一个例子是页面和行号对引用书中的位置,例如:my_location = (42, 11) # page number,...
  • 元组的基本使用

    2020-07-14 21:15:26
    元组的使用和列表相似, 不同之处在于元组是不可修改的, 元组使用圆括号, 而列表使用中括号 元组的值是不能够修改的, 而列表是可以进行,增删改查等操作的。元组只能够取值和遍历的一些不修改值的操作 元组应用...
  • Python列表字典的区别

    热门讨论 2020-10-30 11:19:42
    参考Python中列表字典有什么区别?作的学习记录。 目录列表列表具有“异构性”,可以包含不同类型的对象列表是“有序的”,切片,左闭右开负索引步进切片列表插入,修改,删除不需要重新建表排序字典读取插入用...
  • 实际上元组是跟列表非常相近的另一种容器类型,元组列表看起来不同的一点是元组用的是圆括号而列表用的是方括号。而功能上,元组列表相比一个很重要的区别,元组是一种不可变类型。正是因为这个原因元组能做...
  • 其他数据值集合,如列表元组,都是顺序的,所以列表元组,可以使用索引和切片。 知识点2: 字典,是无序数据值集合,因为无序,所以没有索引和切片。 为什么要使用字典呢? 当数据集合太多太复杂的时候,则...
  • Python 的元组列表类似,不同之处在于元组的元素定义了就不能修改。元组可以切片、可以循环。元组没有多少内置函数可以用。Python元组(tuple)包含了以下内置函数:len(tuple):计算元组元素个数。当然字符串、列表...
  • Python3学习 六、字典

    2020-03-07 10:16:34
    列表元组有相似点也有不同点。 这里使用的是大括号“{}”,其中一个字典的内容是由若干个“键-值”对组成。通过“:”将键和值关联起来。使用时用 字典名[键名] 即可访问与键名相关联的值。 二、创建、编辑一个...
  • a=[]和a=list()有什么区别

    千次阅读 2019-04-14 17:27:34
    在最近python的学习中看到一个比较有意思的东西,python的一种复合数据类型叫做列表,a=[]和a=list()都表示列表,但是这两种有什么不同呢? 二、 问题分析 Python的数据类型有很多,但我们常用的数据类型有数值类型...
  • 列表基础

    2020-06-15 19:40:40
    1、容器型数据类型:可以同时保存多个数据的类型列表元组字典,集合,字符串,迭代器,生成器 (容器中的每个独立的数据叫元素) 2、列表 1.什么列表列表是容器型数据类型,将[ ]作为容器的标志,里面...
  • 本文介绍Python常见的7种基本数据类型,如下:1、字符串2、布尔类型3、数字4、列表5、元组6、字典7、日期其中字符串,数字,列表,元祖,字典是Python的五个标准数据类型。每个数据类型其实都可以作为一篇文章深入...
  • 列表元组字典、集合 三、关于列表的定义? 列表是用来存储一组有序元素的数据结构 四、列表的存储数据的形式? 定义列表需要使用方括号([ ]),列表中的元素都包含在方括号中,元素之间用逗号分隔 五、列表的...
  • python的列表详解

    2020-06-15 18:01:08
    常见容器型数据类型列表元组字典,集合,字符串,迭代器,生成器 容器中的每个独立的数据叫元素 2.列表 2.1 什么列表 列表是容器型数据类型,将 [] 作为容器的标志,里面的多个数据(元素)用逗号隔开。...
  • 一、Python是一个什么样的编程语言?特点和优点是什么 问题解析:解释型语言,底层是C开发...列表和元祖有什么不同? 问题解析:列表是动态数组,它们可变且可以重设长度(改变其内部元素的个数)。元组是静态数组...
  • 列表元组列表字典字典字典 比较数据结构的取值效率 如果要找一个学生,关注时间复杂度 》 n 》1 数据结构 解决数据如何保存 保存方式不同,使用效率不同 数据 算法与数据结构,区别 抽象数据...
  • 一:数据的概念 1.数据是什么 ...数字、字符串、列表元组字典、集合、字节串 4:如何开展数据类型的学习? 基本使用(用途;定义方式;常用操作和内置方法) 该类型数据总结 (数据存值:一个值或是...
  • 一切编程语言都是人设计的,既然是人设计的,那么设计各种功能的时候就一定会它的道理,那么设计数据类型的用意是什么呢? (一) 基本数据类型 基本数据类型:数字 int 字符串 str 布尔值 bool 列表 list 元组 ...
  • python面试心得一

    2020-04-13 20:07:48
    2、列表元组有什么不同 相同点 都是序列 都可以存储任何数据类型 可以通过索引访问 不同点 语法差异:列表用方括号[]创建的,而元组使用圆括号()创建的 是否可变:列表是可变的,而元组是不可变的,这标志着...
  • 数字、字符串、列表元组字典、集合、字节串4:如何开展数据类型的学习?基本使用(用途;定义方式;常用操作和内置方法)该类型数据总结 (数据存值:一个值或是多个值;多个值的话,可以存储哪些类型的值;...
  • 引入1.什么是数据数据就是数值,也就是我们通过观察,实验或者计算得出的结果数据可以是...数据类型数字(整形int, 长整形, 浮点型str, 复数)字符串 str列表 list字典 dict布尔 bool集合 set元组 tulp一.数字类型1.整...
  • 1 什么是数据?  x=10,10是我们要存储的数据 2 为何数据要分不同的类型  数据是用来表示状态的,不同的状态就应该用不同的类型的数据去表示 3 数据类型  以下每个类型都是详细介绍链接的哦!  数字...
  • 今天的面试题以基础为主,去面试Python工程师,这几个基础问题不能答错第1题:列表元组有什么不同列表元组是Python中最常用的两种数据结构,字典是第三种。相同点:都是序列都可以存储任何数据类型可以通过...

空空如也

空空如也

1 2 3 4 5
收藏数 89
精华内容 35
关键字:

列表元组字典有什么不同