编程语言中最长见的几种数据类型,字典,列表,等。同样在Python中也有这些数据类型,只是有些表现形式不同。同时在Python中又多了一种叫做元组(tuple)的东西。

  list(列表)

  • 初始化列表
 li = list([1,2,3,4])
  • 还可以直接创建
 li_dir = [42,534,4654,64]
  • append(self, p_object) 在列表最后加上一个元素,默认是加上None
 li_append = list([1,2,3,4])
li_append.append(43)
print(li_append) # [1, 2, 3, 4, 43]
  • clear(self) 清空数组
 li_clear = list([1,2,3,4])
li_clear.clear()
print(li_clear) # []
  • copy(self) 浅拷贝(跟深拷贝有什么区别暂时还未研究)
 li_copy = list([11,22,33])
li_copy_copy = li_copy.copy()
print(li_copy_copy) #[11, 22, 33]
  • count(self, value 返回某个值在列表中的个数,必须传入某个需要统计的值,否则会报错
 li_count = list([111,222,333,444,111])
li_counts = li_count.count(11) #
print(li_counts)
li_counts_two = li_count.count(111)
print(li_counts_two) #
  • extend(self, iterable) 相当于扩展,扩展的参数必须同样是列表或者元组,同时是在原列表的基础上扩展,并且扩展的数据是在列表最后
 li_extend = list([111,222,333,444,111])
# 当扩展的参数是元组时,如果元组元素最后不加 ',' 那么就会扩展失败,报错
li_extend.extend((12,))
print(li_extend) # [111, 222, 333, 444, 111, 12]
li_extend.extend([12,124,3,4,534,5,5])
print(li_extend) # [111, 222, 333, 444, 111, 12, 12, 124, 3, 4, 534, 5, 5]
  • index(self, value, start=None, stop=None) 根据值 来查找某个元素在列表中的下标
 li_index = list([111,222,333,444,111])
# 默认从查找整个列表,并且当查找到第一个存在的值就会返回,不会继续查找后面的列表元素,如果不存在某个元素就会报错
li_index_index = li_index.index(111,0,4)
print(li_index_index) #
  • insert(self, index, p_object) 在指定下标下插入指定元素
 li_insert = list([111,222,333,444,111])
li_insert.insert(3,'Python')
print(li_insert) # [111, 222, 333, 'Python', 444, 111]
  • pop(self, index=None) 弹出指定下标元素,同时可以定义一个变量来接收弹出的元素.默认弹出最后一个,如果列表为空,或者下标超出列表最大下标就会报错
 li_pop = list([12,4234,3,534,64536])
li_receive = li_pop.pop(3)
print(li_pop) # [12, 4234, 3, 64536]
print(li_receive) #
  • remove(self, value) 根据值来删除列表中元素,如果删除的值在列表中有多个,只会删除第一个出现的值,如果删除的值不存在会报错
 li_remove = list([11,23213,11,232323242])
li_remove.remove(11)
print(li_remove) # [23213, 11, 232323242]
  • reverse(self) 翻转列表
li_reverse = list([11,23213,11,232323242,'fdsa','rt433',13423])
li_reverse.reverse()
print(li_reverse) # [13423, 'rt433', 'fdsa', 232323242, 11, 23213, 11]
  • sort(self, key=None, reverse=False) 排序(这个暂时研究的也不是很多)
li_sort = list([4, 6, 2, 1, 7, 9])
li_sort.sort()
print(li_sort) # [1, 2, 4, 6, 7, 9]
# 排序的同时保留副本
li_sort_y = li_sort[ : ]
li_sort_y.sort()
print(li_sort_y) # [1, 2, 4, 6, 7, 9],同时保留了li_sort

  tuple(元组)

  方法比较简单,但是在创建的时候一定要注意 最后要加上 ',' 只有查找动能,没有增,删,改

tup = tuple((12,3242,3,4435,43,45,6,12))
  • count(self, value) 在元组中查找某个值出现的数量
tup = tuple((12,3242,3,4435,43,45,6,12))
tup_count = tup.count(1) #
print(tup_count)
  • index(self, value, start=None, stop=None) 在元组中根据某个值,查找下标,默认是整个数组,同时可以自定义查找范围,如果多次重复出现,只会查找第一个
tup = tuple((12,3242,3,4435,43,45,6,12))
tup_index = tup.index(12)
print(tup_index) #

  dict(字典)

  在字典中键是不可以重复的,如果重复,最先出现的会被覆盖

dic = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
print(dic) # {'k1': 'v4', 'k2': 'v2', 'k3': 'v3'}
  • clear(self) 清空字典中所有元素
dic_clear = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_clear.clear()
print(dic_clear) # {}
  • copy(self) 浅拷贝(类似于数组,也还是没深入研究)
dic_copy = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_copy_copy = dic_copy.copy()
print(dic_copy_copy) # {'k1': 'v4', 'k3': 'v3', 'k2': 'v2'}
  • fromkeys(*args, **kwargs) 为一个数组中赋值为同样的值。
dic_keys = dict.fromkeys([1,232,423,43,43],['da','fsda']) # {232: ['da', 'fsda'], 1: ['da', 'fsda'], 43: ['da', 'fsda'], 423: ['da', 'fsda']}
dic_keyss = dict.fromkeys([1,232,423,43,43],'da')
print(dic_keyss) # {232: 'da', 1: 'da', 43: 'da', 423: 'da'}
  • get(self, k, d=None) 返回根据某个键返回的值,如果不存在返回指定值,同时可以自定义默认值
dic_get = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_get_get = dic_get.get('k1','rookieJX')
print(dic_get_get) # v4
dic_get_get2 = dic_get.get('k','rookieJX')
print(dic_get_get2) # rookieJX
  • items(self 返回所有元素(所有键值对)
dic_items = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_items.items()
print(dic_items) # {'k3': 'v3', 'k2': 'v2', 'k1': 'v4'} 注意,这里的返回的动态的,顺序是不断变化的
  • keys(self 返回所有的键
dic_keys = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_keys_receive = dic_keys.keys()
print(dic_keys_receive) # (['k1', 'k3', 'k2']) 注意,这里返回的是另外一个列表,多以还需要额外的定义列表来接收返回值
  • pop(self, k, d=None) 由于字典是无序的,所以好像用处不是非常多;如果键值不存在,又没有默认值
dic_pop = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_res = dic_pop.pop('k10',100)
print(dic_pop) # {'k3': 'v3', 'k1': 'v4', 'k2': 'v2'} 不会改变原来字典,需要重新定义来接受数据
print(dic_res) # 100 如果没有指定弹出键值对,那么久返回我们指定值,默认为None
dic = dic_pop.pop('k1',100) # {'k3': 'v3', 'k1': 'v4', 'k2': 'v2'} 不会改变原来字典,需要重新定义一个字典来接收
print(dic_pop) # {'k2': 'v2', 'k3': 'v3'}
print(dic) # v4
  • popitem(self) 弹出某个对象,因为是无序的,所以现在是真的蛋疼了
dic_popitem = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_popitem.popitem() # {'k1': 'v4', 'k3': 'v3'} 删除的对象还不一定
print(dic_popitem)
  • setdefault(self, k, d=None) 类似于get
dic_default = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_default_get = dic_get.setdefault('k1','rookieJX')
print(dic_default_get) # v4
dic_default_get2 = dic_default.get('k','rookieJX')
print(dic_default_get2) # rookieJX
  • update(self, E=None, **F) 字典dict2的键/值对更新到dict里,貌似跟extend差不多的好像,但是是不会产生新的字典
dic_update = {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_other = {'k10':'v4'}
dic_update.update(dic_other)
print(dic_update) # {'k3': 'v3', 'k1': 'v4', 'k2': 'v2', 'k10': 'v4'}
  • values(self) 所有的值
dic_values =  {'k1':'v1','k2':'v2','k3':'v3','k1':'v4'}
dic_values_values = dic_values.values()
print(dic_values_values) # ['v2', 'v4', 'v3']

Python_Day_03 list,dic,tuple方法总结的更多相关文章

  1. Python 元组 tuple() 方法

    描述 Python 元组 tuple() 方法用于将可迭代对象(字符串.列表.元祖.字典)转换为元组. 语法 tuple() 方法语法: tuple(iterable) 参数 iterable -- ...

  2. Python Tuple(元组) tuple()方法

    描述 Python 元组 tuple() 函数将列表转换为元组.每组词 www.cgewang.com 语法 tuple()方法语法: tuple( iterable ) 参数 iterable -- ...

  3. Tuple方法

    组元是C# 4.0引入的一个新特性,编写的时候需要基于.NET Framework 4.0或者更高版本.组元使用泛型来简化一个类的定义. public class Point { public int ...

  4. tuple 方法总结整理

    #!/usr/bin/env python #Python 3.7.0 元祖常用方法 __author__ = "lrtao2010" #元祖和列表类似,只不过元祖一旦被创建一级元 ...

  5. 自学Python2.3-基本数据类型-元组tuple(object) 方法

    Python tuple方法总结 一.元组的简介 1.元组与列表一样,也是一种序列,但是唯一不同的元组是不能修改的 2.元组的元素不可修改,但是元组元素的元素是可以修改的 3.元组通过()括起来表示 ...

  6. Python 数据类型常用的内置方法(三)

    目录 Python 数据类型常用的内置方法(三) 1.列表内置方法 1.sort():升序 2.reverse():颠倒顺序 3.列表比较运算 2.字典内置方法 1.对Key的操作 2.len( )- ...

  7. Python笔记·第六章——字典 (dict) 的增删改查及其他方法

    字典是python中唯一的映射类型,采用键值对(key-value)的形式存储数据.python对key进行哈希函数运算,根据计算的结果决定value的存储地址,所以字典是无序存储的,且key必须是可 ...

  8. Python数据结构之二——tuple(元组)

    Python版本:3.6.2  操作系统:Windows  作者:SmallWZQ 列表和元组是Python中最常见的内建序列.元组与列表一样,但是tuple一旦创建就不能修改.创建元组的语法非常简单 ...

  9. Dictionary 的几种遍历方法

    Dictionary 的几种遍历方法 Dictionary<string, int>dic = newDictionary<string, int>(); 方法1 foreac ...

随机推荐

  1. XCod5 SVN

    近日开始学习IOS开发, 涉及版本管理问题,老大说要使用SVN, 在Windows系统中使用SVN的经验使得俺以为需要首先安装SVN,然后再配置等等, 殊不知XCode5中已经内置了SVN, 在百度一 ...

  2. SQL Server恢复软件 Stellar Phoenix sql recovery

    SQL Server恢复软件 Stellar Phoenix sql recovery http://www.stellarinfo.com/ http://www.stellarinfo.com/ ...

  3. 玩转SQL Server复制回路の变更数据类型、未分区表转为分区表

    玩转SQL Server复制回路の变更数据类型.未分区表转为分区表 复制的应用: 初级应用:读写分离.数据库备份 高级应用:搬迁大型数据库(跨机房).变更数据类型.未分区表转为分区表 京东的复制专家 ...

  4. ABP理论学习之异常处理

    返回总目录 本篇目录 介绍 开启错误处理 非Ajax请求 展示异常信息 UserFriendlyException Error模型 Ajax请求 异常事件 介绍 在一个web应用中,异常通常是在MVC ...

  5. ASP.NET Web API标准的“管道式”设计

    ASP.NET Web API的核心框架是一个消息处理管道,这个管道是一组HttpMessageHandler的有序组合.这是一个双工管道,请求消息从一端流入并依次经过所有HttpMessageHan ...

  6. spring事务管理器设计思想(二)

    上文见<spring事务管理器设计思想(一)> 对于第二个问题,涉及到事务的传播级别,定义如下: PROPAGATION_REQUIRED-- 如果当前没有事务,就新建一个事务.这是最常见 ...

  7. 《Entity Framework 6 Recipes》翻译系列 (4) -----第二章 实体数据建模基础之从已存在的数据库创建模型

    不知道对EF感兴趣的并不多,还是我翻译有问题(如果是,恳请你指正),通过前几篇的反馈,阅读这个系列的人不多.不要这事到最后成了吃不讨好的事就麻烦了,废话就到这里,直奔主题. 2-2 从已存在的数据库创 ...

  8. Lua table之弱引用

    Lua采用了基于垃圾收集的内存管理机制,因此对于程序员来说,在很多时候内存问题都将不再困扰他们.然而任何垃圾收集器都不是万能的,在有些特殊情况下,垃圾收集器是无法准确的判断是否应该将当前对象清理.这样 ...

  9. angularjs 2.0 快速开始

    前言 angularjs2.0 如果发布,公司的项目会基于2.0开发,在1.0的时候就踩了好多坑,趁这2.0还没正式发布,赶紧踩下坑. 这篇文章是参考angularjs2.0 官方文档写的,开发环境需 ...

  10. [笔记]linux下和windows下的 创建线程函数

    linux下和windows下的 创建线程函数 #ifdef __GNUC__ //Linux #include <pthread.h> #define CreateThreadEx(ti ...