精华内容
下载资源
问答
  • 2020-12-02 11:32:30

    python基本数据类型之列表与元组(一)

    python中list与tuple都是可以遍历类型。不同的是,list是可以修改的,而元组属于不可变类型,不能修改。

    列表和元组中的元素可以是任意类型,并且同一个列表和元组中可以包含多种类型的元素。

    list中有很多内置方法,元组由于不能修改,所以只有两个方法(count、index)。

    列表的内置方法

    list的内置方法有:append、clear、copy、count、extend、index、insert、pop、remove和sort。

    1、添加方法:append、insert和extend

    列表是可变类型,也就是说我们能够对列表进行元素的添加、删除和修改。list中提供了3种添加元素的方法。

    append:在列表的最后添加元素;

    insert:可以指定在哪个位置添加元素;

    extend:在列表的最后添加新的列表(用于同时添加多个元素)。

    (1) append方法

    该方法仅需要一个参数,即所需要添加的元素。

    l = [‘haha‘, ‘yeye‘, True, 143, {‘name‘: ‘Tom‘, ‘age‘: 3}]

    l.append((‘Jerry‘,5))

    print(l)

    打印结果:

    [‘haha‘, ‘yeye‘, True, 143, {‘name‘: ‘Tom‘, ‘age‘: 3}, (‘Jerry‘, 5)]

    可以看到append方法在列表的最后添加了一个元组。

    (2) insert方法

    该方法可以指定元素添加的位置。insert方法需要两个参数:insert(index, p_object),index用来指定插入位置,p_object是要插入的元素。

    l = [‘haha‘, ‘yeye‘, True, 143, {‘name‘: ‘Tom‘, ‘age‘: 3}]

    l.insert(2, ‘哈喽‘)

    print(l)

    打印结果:

    [‘haha‘, ‘yeye‘, ‘哈喽‘, True, 143, {‘name‘: ‘Tom‘, ‘age‘: 3}]

    (3) extend方法

    extend方法可以扩展原有列表,方法需要传入一个可遍历对象(list、tuple或字符串等),该方法就是将传入的对象添加到原列表的后面。

    l.extend([‘Lily‘, False, (234, 567)])

    print(l)

    打印结果:

    [‘haha‘, ‘yeye‘, ‘哈喽‘, True, 143, {‘name‘: ‘Tom‘, ‘age‘: 3}, ‘Lily‘, False, (234, 567)]

    extend会将传入的对象进行遍历,然后把其中的每个元素作为新的元素添加到原列表中。在添加字符串时,列表后面增加的是字符串的单个字符。

    l = [‘haha‘, ‘yeye‘, True, 143, {‘name‘: ‘Tom‘, ‘age‘: 3}]

    l.extend(‘zhe‘)

    print(l)

    打印结果:

    [‘haha‘, ‘yeye‘, True, 143, {‘name‘: ‘Tom‘, ‘age‘: 3}, ‘z‘, ‘h‘, ‘e‘]

    2、删除方法:clear、pop和remove

    (1) clear方法

    该方法可以清空列表:

    l = [‘haha‘, ‘yeye‘, True, 143, {‘name‘: ‘Tom‘, ‘age‘: 3}]

    l.clear()

    print(l)

    打印结果:[]

    (2) pop方法

    pop方法可以删除列表中的指定元素,并将删除的元素返回。如果不传入参数,pop默认删除列表中最后一个元素;如果传入参数,则需要指定删除元素的索引。

    l = [‘haha‘, ‘yeye‘, True, 143, {‘name‘: ‘Tom‘, ‘age‘: 3}]

    v1 = l.pop()

    print(‘v1 = ‘ + str(v1))

    v2 = l.pop(1)

    print(‘v2 = ‘ + str(v2))

    打印结果:

    v1 = {‘name‘: ‘Tom‘, ‘age‘: 3}

    v2 = yeye

    (3) remove方法

    remove方法同样也可以删除列表中的指定元素,但是remove需要的参数则是要删除的对象,而不是索引。这一点与pop方法不同。

    l.remove(‘haha‘)

    print(l)

    打印结果:

    [‘yeye‘, True, 143, {‘name‘: ‘Tom‘, ‘age‘: 3}]

    remove方法会删除指定元素,但是并不会返回该元素。

    需要注意的是:对于pop方法来说,如果要删除的列表为空或者没有指定的索引,会返回IndexError,即索引溢出错误;对于remove方法,如果删除的元素在列表中不存在,就会返回值错误ValueError。

    3、其他方法

    (1) copy方法

    copy可以复制一个列表,这种复制属于浅拷贝(深浅拷贝的话题参见相关文章)。

    l = [‘haha‘, ‘yeye‘, True, 143, {‘name‘: ‘Tom‘, ‘age‘: 3}]

    v = l.copy()

    print(v)

    打印结果:

    [‘haha‘, ‘yeye‘, True, 143, {‘name‘: ‘Tom‘, ‘age‘: 3}]

    (2) count方法

    该方法用来计算某个元素在列表中出现的次数

    l = [‘haha‘, ‘yeye‘, True, 143, {‘name‘: ‘Tom‘, ‘age‘: 3}, True]

    v = l.count(True)

    print(v)

    打印结果:2

    (3) index方法

    该方法返回某个元素在列表中第一次出现的索引。该方法有3个参数:index(value, start, stop),用法与字符串中的index方法一致。value是要查找的对象,start和stop分别指定查找的起始和终止位置(包含start,不含stop)。

    l = [‘haha‘, ‘yeye‘, True, 143, {‘name‘: ‘Tom‘, ‘age‘: 3}, True]

    v = l.index(True, 3)

    print(v)

    打印结果:5

    上述例子中,True在l中有两个,分别在l[2]和l[5]两个位置。第二个参数‘3‘指定了开始查找的地方,即从索引3开始查找,因此第一个True就是索引‘5‘。

    (4) sort方法

    sort方法是为列表中的元素进行排序,但是使用该方法时,要保证元素的类型保持一致。即元素要么全部为字符串,要么全部为数字。sort方法没有返回值,它的排序会直接改变原来的list。

    sort方法有两个参数:key=None, reverse=False。参数key使用一个函数来指定排序依据,reverse表示是否将顺序进行反转。

    首先看没有参数的sort方法:

    l = ‘This is a sort function test‘.split()

    print(‘before:‘ + str(l))

    l.sort()

    print(‘after:‘ + str(l))

    打印结果:

    before:[‘This‘, ‘is‘, ‘a‘, ‘sort‘, ‘function‘, ‘test‘]

    after:[‘This‘, ‘a‘, ‘function‘, ‘is‘, ‘sort‘, ‘test‘]

    可以看到,sort排序默认是按照ascii码值进行的。大写字母在前,小写字母在后。

    使用key来指定一个按照每个元素的小写字母进行排序的规则:

    l = ‘This is a sort function test‘.split()

    print(‘before:‘ + str(l))

    l.sort(key = lambda x: x.lower())

    print(‘after:‘ + str(l))

    打印结果:

    before:[‘This‘, ‘is‘, ‘a‘, ‘sort‘, ‘function‘, ‘test‘]

    after:[‘a‘, ‘function‘, ‘is‘, ‘sort‘, ‘test‘, ‘This‘]

    可以指定按照tuple中的元素来进行排序:

    l_tuple = [(‘haha‘, 23), (‘yuyu‘, 15), (‘oiui‘, 32), (‘erer‘, 53)]

    l_tuple.sort(key=lambda x: x[1], reverse=True)

    print(l_tuple)

    打印结果:

    [(‘erer‘, 53), (‘oiui‘, 32), (‘haha‘, 23), (‘yuyu‘, 15)]

    上面例子中使用的lambda是匿名函数,相关内容参见函数部分。

    list中的sort方法与python中的sorted()内置方法很像,都可以自定义排序规则。不同的是,sorted()方法可以为所有可遍历类型进行排序。

    tuple方法

    tuple是不可变对象,所以它没有list中的修改、删除、添加等方法,它的方法只有两个:count和index。

    count、index的方法与list中的方法使用方式一致,因此不再赘述。

    更多相关内容
  • Python 列表元素类型转换总结

    千次阅读 2021-10-20 19:53:20
    Python列表通常可以包含整型,字符串,浮点型数据,甚至还可以包含另一个列表,本文主要使用Python函数,实例展示其中整型,字符串的转换。 列表中字符串变为整型(浮点型) 整型 a = ['1','2','3','4','50'] res =...

    Python列表通常可以包含整型,字符串,浮点型数据,甚至还可以包含另一个列表,本文主要使用Python函数,实例展示其中整型,字符串的转换。

    列表中字符串变为整型(浮点型)

    整型

    a = ['1','2','3','4','50']
    res =list(map(int,a))
    

    结果:

    [1,2,3,4,50]
    

    浮点型

    a = ['1.2','2.5','3','4','5']
    res =list(map(float,a))
    

    结果:

    [1.2,2.5,3.0,4.0,5.0]
    

    列表中整型(浮点型)变为字符串

    方法一

    a = [1,2,3,4,5]
    res = list(map(str,a))
    

    结果:

    ['1','2','3','4','5']
    

    方法二

    a = [1,2,3,4,5]
    res = [str(i) for i in a]
    

    结果:

    ['1','2','3','4','5']
    

    字符列表变为整型数字

    a = ['1','2','3','4','5']
    res = int("".join(map(str,a)))
    

    结果:

    12345
    

    整型数字变为字符列表

    a = 12345
    res = list(str(a))
    

    结果:

    ['1','2','3','4','5']
    

    字符列表变为一个字符串

    a = ['a','b','c','d','e']
    res = "".join(map(str,a))
    

    结果:

    abcde
    

    字符串每个字母分开保存成字符列表
    字符串为字母

    a = 'abcde'
    res = list(a)
    

    结果:

    ['a','b','c','d','e']
    

    字符串为数字:

    a = '12345'
    res = list(a)
    

    结果:

    ['1','2','3','4','5']
    

    整型列表变为一个整型数字

    a = [1,2,3,4,5]
    res = int("".join(map(str,a)))
    

    结果:

    12345
    

    整型数字按每个数字分开保存为整型列表

    a = 12345
    res =list(map(int,str(a)))
    

    结果:

    [1,2,3,4,5]
    

    总结:

    1. 字符串变为列表直接使用list[a]
    2. 将整型或者字符变为列表,或者列表元素类型的相互转换,使用list(map()),map()函数的格式是map(function,iterable,…),function接受一个函数名,后面的参数接受一个或多个可迭代的序列,map()不改变原来的列表,而是返回一个新的列表,map()函数可以实现许多不同类型数据转换的问题。

    例1:元组转为列表

    a = (1,2,3,4,5)
    res = map(int,a)
    

    例2:字符串转换为元组,再以列表返回

    a = '1,2,3,4,5'
    res = map(tuple,a)
    
    1. 将列表变为字符或整型,使用“”.join(map()),join函数格式为‘seq’.join(seq),sep为分割符,可以为空,seq为要连接的字符串,元组,字典等,即以sep为分隔符将seq所有元素合并成一个新的字符串。

    例1:使用“!”分割列表

    a = ['a','b','c','d']
    res = "!".join(a)
    

    结果:

    a!b!c!d
    

    例2:使用“!”分割字符串

    a = 'a,b,c,d'
    res = "!".join(a)
    

    结果:

    a!,!b!,!c!,!d
    
    展开全文
  • Python语言数据类型列表

    千次阅读 2020-12-18 05:20:15
    本文主要向大家介绍了Python语言数据类型列表,通过具体的内容向大家展示,希望对大家学习Python语言有所帮助。序列:序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置,或索引,第一...

    本文主要向大家介绍了Python语言数据类型之列表,通过具体的内容向大家展示,希望对大家学习Python语言有所帮助。

    序列:

    序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置,或索引,第一个索引是0,第二个索引是1,依此类推,Python已经内置确定序列的长度以及确定最大和最小的元素的方法。Python有6个序列的内置类型,最常见的是列表和元组。

    序列操作包括:

    索引,切片,加,乘,检查成员

    列表:

    列表是序列的一种,属最常用的Python数据类型,它支持字符,数字,字符串甚至可以包含列表(嵌套),他的数据项不需要具有相同的类型

    创建列表:

    以逗号分隔的不同的数据项使用方括号括起来即可。

    例如:

    list1 = ['physics', 'chemistry', 1997, 2000];list2 = [1, 2, 3, 4, 5 ];list3 = ["a", "b", "c", "d"];list4 = []       #创建空列表list5 = list()  #创建空列表

    列表截取:

    语法:变量[头下标:尾下标]

    从左到右索引默认0开始的,从右到左索引默认-1开始,下标可以为空,表示取到头或尾。

    跟字符串的截取一样,这里不再详述

    例1:

    #!/usr/bin/python

    list1 = ['physics', 'chemistry', 1997, 2000];

    list2 = [1, 2, 3, 4, 5, 6, 7 ];

    print "list1[0]: ", list1[0]print "list2[1:5]: ", list2[1:5]以上实例输出结果:list1[0]:  physicslist2[1:5]:  [2, 3, 4, 5]

    例2:

    L = ['spam', 'Spam', 'SPAM!']| L[2] | 'SPAM!' | 读取列表中第三个元素 || L[-2] | 'Spam' | 读取列表中倒数第二个元素 || L[1:] | ['Spam', 'SPAM!'] | 从第二个元素开始截取列表 |

    更新列表:

    可以对列表的数据项进行修改或更新,也可以使用append()方法来添加列表项例如:#!/usr/bin/pythonlist = ['physics', 'chemistry', 1997, 2000];print "Value available at index 2 : "print list[2]list[2] = 2001    #更新列表元素print "New value available at index 2 : "print list[2]以上实例输出结果:Value available at index 2 :1997New value available at index 2 :2001

    删除列表元素:

    使用 del 语句来删除列表的的元素例:#!/usr/bin/pythonlist1 = ['physics', 'chemistry', 1997, 2000]print list1del list1[2]print "After deleting value at index 2 : "print list1以上实例输出结果:['physics', 'chemistry', 1997, 2000]After deleting value at index 2 :['physics', 'chemistry', 2000]

    Python列表操作符:

    + 号用于组合列表* 号用于重复列表in 判断元素是否在列表中not in 例:

    | Python 表达式 | 结果  |  描述 || [1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 || ['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 || 3 in [1, 2, 3] | True | 元素是否存在于列表中 || for x in [1, 2, 3]: print x, | 1 2 3 | 迭代 |

    Python列表函数:

    | 序号 | 函数 || 1 | cmp(list1, list2)    比较两个列表的元素 || 2 | len(list)                 列表元素个数 || 3 | max(list)               返回列表元素最大值 || 4 | min(list)                返回列表元素最小值 || 5 | list(seq)                将序列转换为列表 |

    Python列表方法:

    | 序号 |                                方法                       || 1 |  list.append(obj) 在列表末尾添加新的对象 || 2 |  list.count(obj)     统计某个元素在列表中出现的次数 || 3 |  list.extend(seq)  在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表) || 4 |  list.index(obj)     从列表中找出某个值第一个匹配项的索引位置 || 5 |  list.insert(index, obj) 将对象插入列表 || 6 |  list.pop(obj=list[-1]) 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值 || 7 |  list.remove(obj)   移除列表中某个值的第一个匹配项 || 8 |  list.reverse()        反向列表中元素 || 9 |  list.sort([func])     对原列表进行排序 |

    给列表插入数据的其他方法:

    In [1]: a=[12,3,4,3]In [2]: a[2:2]=[8,8]In [3]: aOut[3]: [12, 3, 8, 8, 4, 3]

    批量替换:

    In [4]: a=[12, 3, 8, 8, 4, 3]In [5]: a[2:]=[1,1,1,]In [6]: aOut[6]: [12, 3, 1, 1, 1]

    另类删除:

    In [7]: a=[12,3,4,3]In [8]: a[2:]=[]In [9]: aOut[9]: [12, 3]

    列表中嵌套列表:

    >>> a=[1,2,['a','b']]  >>> a[1, 2, ['a', 'b']]>>> a[2]['a', 'b']>>> a[2][0]'a'>>> a[2][1]'b'

    判断一个对象是否是一个列表:

    >> test=[1,2,3]

    >> isinstance(test,list)

    True

    列表变量解包:

    >> l1,l2 = [[1,'x','y'],[2,'z','r']]

    >> print(l1)

    [1, 'x', 'y']

    >> print(l2)

    [2, 'z', 'r']

    查看系统内所有内置函数(BIF):isinstance就在里面

    >> dir(builtins)

    祛除列表中重复的元素

    比较容易记忆的是用内置的set:

    l1 = ['b','c','d','b','c','a','a']l2 = list(set(l1))print l2

    还有一种据说速度更快的,没测试过两者的速度差别

    l1 = ['b','c','d','b','c','a','a']l2 = {}.fromkeys(l1).keys()print l2

    这两种都有个缺点,祛除重复元素后排序变了:

    ['a', 'c', 'b', 'd']

    如果想要保持他们原来的排序:

    用list类的sort方法    l1 = ['b','c','d','b','c','a','a']    l2 = list(set(l1))    l2.sort(key=l1.index)    print l2也可以这样写:    l1 = ['b','c','d','b','c','a','a']    l2 = sorted(set(l1),key=l1.index)    print l2也可以用遍历:    l1 = ['b','c','d','b','c','a','a']    l2 = []    for i in l1:        if not i in l2:            l2.append(i)    print l2上面的代码也可以这样写    l1 = ['b','c','d','b','c','a','a']    l2 = []    [l2.append(i) for i in l1 if not i in l2]    print l2这样就可以保证排序不变了:    ['b', 'c', 'd', 'a']

    本文由职坐标整理并发布,希望对同学们学习Python有所帮助,更多内容请关注职坐标编程语言Python频道!

    展开全文
  • python中的基本数据类型列表,元组

    千次阅读 2020-11-21 02:34:20
    列表是python的基本数据类型之一,用[]来表示,可以存放各种数据类型(什么都能装,能装对象的对象)列表相比于字符串,不仅可以存放不同类型的数据,而且可以存放大量的数据.2.列表的索引和切片(列表和字符串一样,也拥有...

    一.列表

    1.什么是列表.

    列表是python的基本数据类型之一,用[]来表示,可以存放各种数据类型(什么都能装,能装对象的对象)

    列表相比于字符串,不仅可以存放不同类型的数据,而且可以存放大量的数据.

    2.列表的索引和切片(列表和字符串一样,也拥有索引和切片)

    列表切片切出来的内容依旧是列表.

    2.1索引:

    lst=['马化腾','马云','王健林','雷军','刘翔','萧敬腾']print(lst[0])

    lst=['马化腾','马云','王健林','雷军','刘翔','萧敬腾']

    lst[2]='赖美云'

    print(lst)#这里说明列表是可以发生改变的,与字符串不同,字符串每次操作 都会返回一个新的字符串

    2.2切片

    1 lst=['马化腾','马云','王健林','雷军','刘翔','萧敬腾']2 print(lst[0:4])3

    4 lst=['马化腾','马云','王健林','雷军','刘翔','萧敬腾']5 print(lst[-1:-4:-2]) #倒着,带步长,跳着也可以取

    二.列表的增删改查

    1.增加

    1.1append 追加

    1 lst=['马化腾','马云','王健林','雷军','刘翔','萧敬腾']2 print(lst)3 lst.append('张杰')4 print(lst)5 #########运行结果

    6 ['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾']7 ['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾', '张杰'] #在原列表的末尾加入新的东西.

    1.2 insert(index, 元素) 在index位置添加元素

    1 lst = ['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾']2 lst.insert(1,'刘德华') #在1位置插入刘德华,原来在一后面的元素就会向后移动一位

    3 print(lst)

    1.3 extend() 迭代添加

    1 lst = ['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾']2 lst.extend('大张伟') #把输入的字符串一个一个迭代添加到列表的最后

    3 print(lst)4 #['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾', '大', '张', '伟']

    5 lst.extend(['霍元甲']) #把字符串整个添加到列表的最后

    6 print(lst)7 #['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾', '大', '张', '伟', '霍元甲']

    8 lst.extend(['朱元璋','李白']) #把多个字符串添加到列表的最后

    9 print(lst)10 #['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾', '大', '张', '伟', '霍元甲', '朱元璋', '李白']

    2.删除

    2.1pop(index)按照位置删除元素

    1 lst = ['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾']2 lst.pop(2) #删除2号元素,括号里什么也不写,默认删除最后一个

    3 print(lst)4 #['马化腾', '马云', '王健林', '雷军', '刘翔']

    2.2remove(元素)直接删除元素

    1 lst = ['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾']2 lst.remove("马云") #删除知道元素具体内容的指定元素

    3 print(lst)4 #['马化腾', '王健林', '雷军', '刘翔', '萧敬腾']

    5 lst.remove("哈哈") #删除不存在的元素会报错

    6 print(lst)7 #ValueError: list.remove(x): x not in list报错内容

    2.3del切片

    1 lst = ['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾']2 del lst[1:3] #与前两个删除不同的是格式上要 del+空格+列表

    3 print(lst)4 #['马化腾', '雷军', '刘翔', '萧敬腾']

    2.4clear()清空列表

    1 lst = ['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾']2 lst.clear()3 print(lst)4 #[]

    3.修改

    3.1索引修改

    1 lst = ['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾']2 lst[1]='丘比特' #把指定元素修改成指定内容

    3 print(lst)4 #['马化腾', '丘比特', '王健林', '雷军', '刘翔', '萧敬腾']

    3.2切片修改

    lst = ['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾']

    lst[1:4:3]=['杨幂','迪丽热巴'] #如果补偿不是一,要注意元素的个数

    print(lst)#ValueError: attempt to assign sequence of size 2 to extended slice of size 1

    lst = ['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾']

    lst[1:4]=['杨幂','迪丽热巴'] #如果步长是一,就不用关心元素的个数

    print(lst)#['马化腾', '杨幂', '迪丽热巴', '刘翔', '萧敬腾']

    4.查询

    列表是一个可迭代对象,所以可以进行for循环,分别输出列表中的每一个元素.

    for el(元素) in lst:

    print(el)

    5.其他操作

    5.1次数(count)

    1 lst = ['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾']2 num=lst.count('马云') #查询马云出现的个数 3 print(num)4 #1

    5.2排序(sort)

    lst = [1,2,3,9,4,5,6,8]

    lst.sort()#排序,默认升序

    print(lst)#[1, 2, 3, 4, 5, 6, 8, 9]

    lst= [1,2,3,9,4,5,6,8]

    lst.sort(reverse=True) #降序

    print(lst)#[9, 8, 6, 5, 4, 3, 2, 1]

    5.3反转(reverse)

    1 lst = ['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾']2 lst.reverse() #反转

    3 print(lst)4 #['萧敬腾', '刘翔', '雷军', '王健林', '马云', '马化腾']

    5.4长度(len)

    1 lst = ['马化腾', '马云', '王健林', '雷军', '刘翔', '萧敬腾']2 lst.reverse() #反转

    3 print(lst)4 #['萧敬腾', '刘翔', '雷军', '王健林', '马云', '马化腾']

    三.列表的嵌套

    采用降维的操作,一层一层的看lst=[1,'hua',5,'会有鬼',[1,5,'发过火',54,[5,5,6,'fgh','法国红酒']]]

    print(lst[3]) #找到会有鬼

    print(lst[2:4]) #找到5和会有鬼

    print(lst[3][2]) #找到会有鬼的鬼字

    s=lst[1] #拿到hua,将首字母大写,再扔回去

    s=s.capitalize() # lst[1]=s # print(lst) #lst=[1,'hua',5,'会有鬼',[1,5,'发过火',54,[5,5,6,'fgh','法国红酒']]] #把发过火改成发过水

    lst[4][2]=lst[4][2].replace('火','水') #要定位到发过火,不要定位到火,才能改

    print(lst)#[1, 'hua', 5, '会有鬼', [1, 5, '发过火', 54, [5, 5, 6, 'fgh', '法国红酒'], '雪碧']]

    四.元组和元组嵌套

    俗称不可变的列表,又被称为只读列表,元组也是python的只读列表之一用()括起来,里面可以放任何数据类型的数据,但是不能改.

    1 tu=(1,'太白','李白','太黑','怎么黑')2 print(tu)3 print(tu[0])4 print(tu[1])5 print(tu[1:4])6 4.1for循环便利元组7 for el intu:8   print(el)

    五.range

    range可以帮我获取到一组数据通过for循环打印这组数据

    1 for i in range(0,101,2):2 print(i)

    展开全文
  • 1-2:数据类型之元组、列表类型

    万次阅读 2020-12-05 18:46:19
    元组的概念:前面我们学过数字类型,字符串类型,它们都代表一个元素!1.元组是包含多个元素类型元素之间用逗号分隔。t1 = 123,456,"hello"2.元组可以使空的,t2 = ()3.元组包含一个元素: t3 = 123,4.元组外层...
  • Python内置的一种数据类型列表:list。list是一种有序的集合可以随时添加和删除其中的元素。它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型创建一个列表,只要把逗号分隔的不同的数据...
  • Python数据类型列表

    千次阅读 2020-11-21 02:34:58
    列表列表是由一系列按特定循序排列的元素组成(即有序集合)。使用中括号[]来表示,并用逗号来分隔其中的元素。列表的元素可以是任意类型。...操作列表(增,删,改,查)访问列表通过列表索引访问列表元素color = ['red...
  • (3.5分)【单选题】对于序列 s,哪个选项能够返回序列s中第i到j以k为步长的元素子序列? (3.0分)【单选题】Python 中,for 和 while 可以有 else 语句? (2.0分)【判断题】元组可以作为集合的元素。 (2.0分)【判断题...
  • 展开全部这个问题,有部分人的答案是:“是的,必须相同”,就连...对于同一个数组,其所有元素数据类型都是相同的。对此我有不同的理解,我的答案是:“不是”。原因:数组的概念:在程序设计中,为了处理方便,...
  • Python列表中所有元素必须为相同类型数据.更多相关问题【判断题】根据葛兰维买卖法则,价格虽然跌破移动平均线,但又立即回升到移动平均线上,此时移动平均线仍然持续上升,为卖出信号。【单选题】下列选项中,不...
  • \quad对于一个列表:list = [‘a’, ‘b’, ‘a’, ‘b’, ‘c’, ‘c’, ‘a’, ‘a’, ‘b’, ‘d’],这里面总共有10个元素,其中共有4种取值{‘a’, ‘b’, ‘c’, ‘d’},4类元素的个数分别为[4, 3, 2, 1],接...
  • python 数据类型列表(list)

    千次阅读 2020-12-29 17:17:42
    一、表达方式1、英文[]表示2、列表内部可以存储任意类型数据3、可变的有序序列二、常用函数1、type():查询变量的类型,如type(["name", "sex", "age"]) = list2、len():查询列表的长度,如len(["name", "sex", ...
  • python数据类型-列表

    千次阅读 2020-12-04 12:44:11
    本节主要内容:1. 列表2. 列表的增删改查3....它是以[]括起来,每个元素用','隔开而且可以存放各种数据类型:列表相较于字符串,不仅不可以存放不同的数据类型,而且可以存放大量的数据,32位Python可以存放536870912...
  • Python列表数据类型转换

    千次阅读 2019-04-02 22:01:32
    Python数组类型转换 将int型数组转换成字符串型数组 #@Created on Tue Apr 2 16:10:51 2019 #@author: Hu Sai #@email: 17095338g@connect.polyu.hk list1 = [1,2,3,4] list2 = map(str,list1) for i in list1: ...
  • 数据类型-列表(list)

    千次阅读 2019-12-12 17:33:42
    列表的常用方法- 列表元素的增加- 列表元素的删除- 列表元素的查看- 列表元素的排序 1.列表的定义 数组:存储同一种数据类型的集合 scores = [34,56,90,100…] 列表:“打了激素的数组“,可以存储任意数据类型.....
  • 详解Python集合数据类型

    千次阅读 2020-11-21 02:34:58
    ● 掌握集合数据类型● 在程序中使用集合数据类型在数学概念中,集合是由一个或多个确定的元素构成的整体。具体来说是指具有某种特定性质、具体的或抽象的对象汇总成的集体,这些对象称为该集合的元素或成员。例如,...
  • 一、组合数据类型概述 (1)适用场合 很多时候,计算机需要对一组数据进行批量处理, 例如:给定一组单词{python, data, function, list, loop},计算并输出每个单词的长度 (2) 什么是组合数据类型 将多个同类型或...
  • Java List: 列表是什么数据类型,怎么用? 偶然发现容器类的结构在很多代码中越用越多。故,有意识开始整理。方法上觉得:用Java来了解和运用。然后用C++来实现和掌握最为便捷有效。 1 List array vector set 都...
  • 不可变数据类型: 当该数据类型的对应变量的值发生了改变,那么它对应的内存地址也会发生改变,对于这种数据类型,就称不可变数据类型。可变数据类型 :当该数据类型的对应变量的值发生了改变,那么它对应的内存地址...
  • Python改变列表数据类型的方法

    千次阅读 2019-09-25 23:26:40
    方法一: spam=['123','456','789']spam1=[]for i in spam: j=float(i) spam1.append(j)...这段代码的功能是:读取excel中的数据,每十个数值取平均值 import xlrdimport numpywb=xlrd.open_workbook('D:\\avera...
  • 前言在python中,list列表数据类型其实就是一个容器,可以放置大量元素的集合。同时,list列表也有很多特点和使用场景,本文主要讲解list列表的函数方法。概念list列表是一个集合,一个容器,同Java语言中的数组是...
  • 1、问题根源: text = {"a":{"aa":1,"b":2},"b":2,"c":3,"d":4,"e":5} list_dict = [{v:text[v]}...,如整数,浮点数,字符串,元组等(列表,字典,集合类型本身都是可变数据类型,不能做集合的元素出现)  
  • 更改numpy数组的数据类型

    万次阅读 2019-05-22 20:23:59
    a.astype(数据类型) 后面选择自己需要的数据类型即可 import numpy as np a=np.random.random((5,4,3)) b=np.random.randint(1,3,(5,4,3)) a=a+b print(a) print(a.astype(np.int16)) 结果如下: ...
  • Python数据类型(3)—— 字典、集合

    千次阅读 2020-12-04 11:38:58
    一、字典类型1、用途:用来存放多个不同种类的值2、定义方式:在{ }内用逗号分隔开多个key:value的元素,其中value可以是任意数据类型,而key的功能通常是用来描述value的,所以key通常是字符串类型,但其实key必须...
  • 数据结构、数据类型、抽象数据类型之间的区别

    千次阅读 多人点赞 2019-11-03 20:15:37
    数据元素是最基本的数据单位,最基本的数据元素是一个二进制位。) 逻辑结构指反映数据元素之间的逻辑关系的数据结构,其中的逻辑关系是指数据元素之间的前后件关系,而与他们在计算机中的存储位置无关。包括: ...
  • python数据类型列表(list)

    千次阅读 2018-09-03 14:35:26
    列表是python中最常用的内置数据类型,用中括号[元素1,元素2…]括起,以逗号分隔,元素之间没有任何关系,可以是任何类型。 数组是只能存储同一种数据类型的结构,但是列表可不受局限。 2. 列表的特性(与元组的...
  • 4、Python语言中很多数据类型都是序列类型,其中比较重要的是字符串类型,元组类型和列表类型。 通用操作符和函数 操作符 描述 x in s 如果x是序列s的元素,返回True,否则返回False x not in s 如果x是...
  • Python语言包括九种基本的数据类型,我们把它分为以下三类。 数字类型 整数、浮点数、复数 字节类型 字符串、字节串 组合类型 集合、元组、列表、字典 一、数字类型 1 整数类型 与数学中的整数...
  • 【Python】第7次练习:组合数据类型——列表元素的积,重复元素判定A,编辑求集合的最大值和最小值,大多数元素A 1、列表元素的积 题目:一个由n(n>1)个数字组成的列表 ls,输出一个列表lt,其中lt中第i个元素...
  • Python 列表元素替换

    千次阅读 2020-11-21 00:10:24
    在 Python 中,如何替换列表中的元素?其实 Python 并无自带 Replace 方法,只能自己编写循环或者使用列表解析的方法。目录无内置replacePython里 字符串(string)类型 有 replace 方法,但是 列表(list)类型 ...

空空如也

空空如也

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

列表元素的数据类型