ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

列表与元组

2020-09-28 07:01:20  阅读:157  来源: 互联网

标签:列如 元素 value 列表 元组 Out


标准数据类型--列表

列表是一种有序的可变容器,且可存储任意类型数据。列表是有序的,列表是序列的一种,每个元素都对应一个索引值,索引值是从0开始的自然整数。列表中每个元素之间用"," 分隔。

  • 初始化创建
    tmplist = []
    tmplist = ['a',123,[9,8]]
    tmplist = list(iterable)
    例如:
In [1]: a=[]                                                                                                

In [2]: type(a)                                                                                             
Out[2]: list

In [3]: a1=['a','b']                                                       
  • 增加元素
    append(value)
    extend(iterable)
    insert(index,object)
    列如:
In [6]: a.append('b')                                                                                       

In [7]: a.extend('hello')              \\批量增加                                                                       

In [8]: a                                                                                                   
Out[8]: ['b', 'h', 'e', 'l', 'l', 'o']

In [9]: a.insert(2,'c')                                                                                     

In [10]: a                                                                                                  
Out[10]: ['b', 'h', 'c', 'e', 'l', 'l', 'o']
  • 删除元素

remove(value) 注仅删除第一次出现在元素
pop([index]) 删除最后一个列表元素并返回最后一个元素

列如:

In [11]: a                                                                                                  
Out[11]: ['b', 'h', 'c', 'e', 'l', 'l', 'o']

In [12]: a.remove('h')        

In [14]: a.pop(2)                                                                                           
Out[14]: 'e'

In [15]: a                                                                                                  
Out[15]: ['b', 'c', 'l', 'l', 'o']
  • 查看元素

[] 使用切片查看
index(value, [start, [stop]]) 查看某一元素索引
count(value) 查看某一元素个数
len(tmplist) 查看列表长度

列如:

In [20]: a[:]                                                                                               
Out[20]: ['b', 'c', 'l', 'l', 'o']

In [21]: a.index('c')                                                                                       
Out[21]: 1
In [24]: a.count('b')                                                                                       
Out[24]: 1

In [25]: len(a)                                                                                             
Out[25]: 5
  • 排序
    sort()
    sum
    min
    max
    len
    del
    type
    id

列如:

n [29]: a                                                                                                  
Out[29]: [2, 3, 1, 5, 8, 9]

In [30]: a.sort()                                                                                           

In [31]: a                                                                                                  
Out[31]: [1, 2, 3, 5, 8, 9]

In [33]: type(a)                                                                                            
Out[33]: list

In [34]: sum(a)                                                                                             
Out[34]: 28

In [35]: len(a)                                                                                             
Out[35]: 6

In [36]: min(a)                                                                                             
Out[36]: 1

In [37]: del(a)       
  • 关系判断

in
not in

列如:

In [40]: a=[1,2,3,'a']                                                                                                        

In [41]: a                                                                                                                    
Out[41]: [1, 2, 3, 'a']

In [42]: 'a' in a                                                                                                             
Out[42]: True

In [43]: 1 not in a                                                                                                           
Out[43]: False
  • 深拷贝浅拷贝

L1 = L 浅拷贝L和L1会互相影响相当于硬链接。
L2 = L[:] 深拷贝L2 会完全复制一份L,之后两都毫无关系

列如:

In [44]: a                                                                                                                    
Out[44]: [1, 2, 3, 'a']

In [45]: a1 = a                                                                                                               

In [46]: a1                                                                                                                   
Out[46]: [1, 2, 3, 'a']

In [47]: a.append('b')                                                                                                        

In [48]: a                                                                                                                    
Out[48]: [1, 2, 3, 'a', 'b']

In [50]: a1                                                                                                                   
Out[50]: [1, 2, 3, 'a', 'b']

深拷贝

In [51]: a                                                                                                                    
Out[51]: [1, 2, 3, 'a', 'b']

In [52]: a2=a[:]                                                                                                              

In [53]: a.append('c')                                                                                                        

In [54]: a                                                                                                                    
Out[54]: [1, 2, 3, 'a', 'b', 'c']

In [55]: a2                                                                                                                   
Out[55]: [1, 2, 3, 'a', 'b']

标准数据类型--元组

元组是一种有序的不可变容器,且可存储任意类型数据。元组是有序的,每个元素都对应一个索引值,索引值是从0开始的自然整数,元组中每个元素之间用"," 分隔。元组就是一个只读的列表。

  • 初始化创建
In [56]: a=()                                                                                                                 

In [57]: type(a)                                                                                                              
Out[57]: tuple

In [58]: a=tuple('a')                                                                                                         

In [59]: a                                                                                                                    
Out[59]: ('a',)

count(value) 查看元组只某一元素个数
index(value, [start, [stop]]) 查看元组中某一元素索引值

标签:列如,元素,value,列表,元组,Out
来源: https://blog.51cto.com/14400213/2538267

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有