python中的序列总结：列表，元组，字符串

首先python中的序列有列表，元组，字符串。

列表List是python里面最基本的数据结构。序列中每个元素都是从索引（下标）从0开始，依次叠加。

List操作的方法很多，只能熟悉基本常用的这个方法。

第二个数据结构是元祖，元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表。

元祖的方法只有count和index。

列表的一些基本操作

0.创建

 # list 有两种创建方式
 # 第一种
list1 = ["1", "2"]
 # 第一种方式等同于第二钟方式，其实也是调用第二种方式创建列表
 # 第二种
 list(("1", "2"))
 # 会自动加载构造函数__init__,内部执行for循环，把元祖转换为列表，相当于创建一个列表

1.切片（获取多个元素）

 poets = ["libai", "dufu", "luyou", "wangwei", "sushi", "qinguan", "qinshaoyou", "liyu", "yanshu"]
 poets[1:5]  # 从下标1开始取，至第5个内（不包括5）1 <= x < 5
 # ['dufu', 'luyou', 'wangwei', 'sushi']
 poets[-1]  # -1直接获取最后一个元素
 # yanshu
 poets[3:-1]  # 如果想取最后一个元素，不能这样写，这样包含-1在内，应该是这样写 poets[3:]
 # ['wangwei', 'sushi', 'qinguan', 'qinshaoyou', 'liyu']
 poets[::2]  # 最后一个参数 相当于步长，每隔元素就取一个
 # ['libai', 'luyou', 'sushi', 'qinshaoyou', 'yanshu']

2.追加（在某尾添加一个元素）

poets.append("dumu")
# ['libai', 'dufu', 'luyou', 'wangwei', 'sushi', 'qinguan', 'qinshaoyou', 'liyu', 'yanshu', 'dumu']
# poets = poets.append("dumu") || print(poets.append("dumu"))  该方法没有返回值，如果这样操作得到结果为none

3.插入

sancao = ["caozhi", "coacao", "caopi"]
 poets.insert(1, sancao)
 # ['libai', ['caozhi', 'coacao', 'caopi'], 'dufu', 'luyou', 
 # 'wangwei', 'sushi', 'qinguan', 'qinshaoyou', 'liyu', 'yanshu', 'dumu']
 # 这个方法需要两个参数，选择要插入的位置和要插入的元素 如果只用一个参数，会报错：insert() takes exactly 2 arguments (1 given)
 # 第一个参数 只能是数字 不能是字符串  否则会报错： 'str' object cannot be interpreted as an integer
 # 第二个参数 可以不填，要填字符串,数字都可以,或者列表等等。。。

4.更新

poets[1] = "dufu" # 更新好像没什么可以说的，就是这样，选择对应下标的元素覆盖，如果括号没有输入索引，会报错语法错误 invalid syntax
# poets[] = "ceishi"
# poets['1'] = "ceishi" # 当然索引只能是整形不能是字符串 list indices must be integers or slices, not str

5.移除

poets = ["libai", "dufu", "libai", "luyou"]
poets.remove("libai")
# ['dufu', 'libai', 'luyou']
#  选择要移除的元素，不是索引，如果有两个相同元素，只移除第一个匹配项
# 如果不输入元素，会报错 x not in list 或者放空 remove() takes exactly one argument (0 given)
poets.pop()  # 默认删除最后一个元素
# ['dufu', 'libai']
poets = ["libai", "dufu", "luyou", "wangwei", "sushi", "qinguan", "qinshaoyou", "liyu", "yanshu"]
poets.pop(4)
# ['libai', 'dufu', 'luyou', 'wangwei', 'qinguan', 'qinshaoyou', 'liyu', 'yanshu']
sancao = ["caocao", "caozhi", "caopi"]
poets.insert(1, sancao)
# ['libai', ['caocao', 'caozhi', 'caopi'], 'dufu', 'luyou', 'wangwei', 'qinguan', 'qinshaoyou', 'liyu', 'yanshu']
poets.pop(1)  # pop可以删除嵌套中的列表
# ['libai', 'dufu', 'luyou', 'wangwei', 'qinguan', 'qinshaoyou', 'liyu', 'yanshu']
del poets[0:3]  # 删除列表的元素，此方法可以一次性删除多个元素，跟切片道理一样
# ['wangwei', 'qinguan', 'qinshaoyou', 'liyu', 'yanshu']

6.扩展（在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表））

 aList = ["liubei", "guanyu", "zhangfei"]
 bList = ["zhaoyun", "machao", "huangzhong"]
 aList.extend(bList)
 # ['liubei', 'guanyu', 'zhangfei', 'zhaoyun', 'machao', 'huangzhong']
 aList.extend("bList")  # 如果是字符串，会把字符串分割依次放入列表中
 # ['liubei', 'guanyu', 'zhangfei', 'b', 'L', 'i', 's', 't']
 aList.extend(1) # int' object is not iterable 

7.统计（统计某个元素在列表中出现的次数）

 List1 = ["a", "v", "b", "a", "a", " ", "",1]
 List1.count("")  # 统计元素的个数
 # 3
 List1.count("")  # 如果不填，应该是统计空格  注意" " 和 ""的区别
 # 1
 List1.count(1)  # 也可以统计整形的个数
 # 1

8.获取下标

 List1 = ["a", "v", "b", "a", "a", " ", "", 1]
 List1.index("a")  # 如果有多个相同，至返回第一个元素的下标
 # 0
 List1.index("")
 # 6
 List1.index("c")  # 如果没找到，如果没有找到对象则抛出异常

9.排序&翻转(对列表的元素进行反向排序)

  List3 = ["lin", "huang", "li", 1, 3, 4]
  # List3.sort()  # python 版本问题  3.0版本 不支持  数字和字符串排序 unorderable types: int() < str()
  # python 2.0版本支持 数字和字符串排序
  List3[3] = '1'
  List3[4] = '3'
  List3[5] = '4'
  List3.sort()
  # ['1', '3', '4', 'huang', 'li', 'lin']
  List3.reverse()
 List3
 # ['lin', 'li', 'huang', '4', '3', '1']

10.拷贝

  List1 = ['a', 'b', 'c', 2, 3, 4, [8, 9, 4], 'h']
  List2 = List1.copy()  # 复制一份出来
  List2[0] = 'A'  # copy只能完整把列表第一层数据复制一份
  List2[6][0] = 'k'  # 深层里面列表不会完全复制一份，深层列表都指向同一个内存地址。如果深层的数据很大，整个复制不来很占内存
  List1
  List2
  # ['a', 'b', 'c', 2, 3, 4, ['k', 9, 4], 'h']
  # ['A', 'b', 'c', 2, 3, 4, ['k', 9, 4], 'h']
  # 如果想实现深层列表完全复制一份，必须调用第三方库
 # copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。
 # copy.deepcopy 深拷贝 拷贝对象及其子对象
 import copy
 # List3 = List1.deepcopy()  # 深copy

11.判断一个列表是否为空

  menghuan = ["jianxiage", "xiaoyaosheng", "gujingling", "shentianbing", "longtaizi"]
  if len(menghuan):
      print("list have %s element" % len(menghuan))
  else:
      print("list is empty")
  # 由于一个空列表等于false,所以可以简化len(List)
  menghuan = []
  if menghuan:
      print("not empty")
 else:
     print("empty")
 
 
 list1 = ["a", "b", "c", "d", 2, 3, 4, 2, 4, "ds", 23, 23, 12, "qw", "23"]
 # 元素是否存在于列表中
 if 2 in list1:
     num_of_ele = list1.count(2)
     position_of_ele = list1.index(2)
     print(" [%s]  is in list1, position[%s]" % (num_of_ele, position_of_ele))

12.迭代器

 # 遍历列表同时获取索引
 i = 0
 for element in list1:
     print(element)
     i += 1
 # 既要遍历索引又要遍历元素时 这样写更简洁些
 for i, element in enumerate(list1):  # enumerate是python的内置函数，在字典上是枚举、列举的意思
     print(i)
     print(element)

元组

元组是用圆括号括起的一组序列。
之前讲的列表类型是list，而元组的类型为tuple。

>>> type((1,2,3))

>>> type([1,2,3])

与列表一样，元组也是序列，唯一的差别在于元组是不能修改的。

• 注意：只包含一个值的元组，必须在这个值后面加上逗号。因为如果不加逗号，那么输出的不是元组而是这个值本身的类型。用type()就可以证明哟。

   >>> (1)    # 1后面没有逗号，即使外壳是括号，它依然是整型数。
    1
    >>> (1,)  # 1后面加了逗号才可以是元组
    (1,)
    >>> type((1))
    
    >>> type((1,))
    
  

Python 字符串

字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。

创建字符串很简单，只要为变量分配一个值即可。例如：

var1 = 'Hello World!'
var2 = "Python Runoob"

Python访问字符串中的值
Python不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

Python访问子字符串，可以使用方括号来截取字符串，如下实例：

实例(Python 2.0+)

#!/usr/bin/python
 
var1 = 'Hello World!'
var2 = "Python Runoob"
 
print "var1[0]: ", var1[0]
print "var2[1:5]: ", var2[1:5]

以上实例执行结果：

var1[0]:  H
var2[1:5]:  ytho

Python字符串更新
你可以对已存在的字符串进行修改，并赋值给另一个变量，如下实例：

实例(Python 2.0+)

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
var1 = 'Hello World!'
 
print "更新字符串 :- ", var1[:6] + 'Runoob!'

以上实例执行结果

更新字符串 :-  Hello Runoob!

Python3 字典

字典是另一种可变容器模型，且可存储任意类型对象。

字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：

d = {key1 : value1, key2 : value2 }
键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

一个简单的字典实例：

dict = {‘Alice’: ‘2341’, ‘Beth’: ‘9102’, ‘Cecil’: ‘3258’}
也可如此创建字典：

dict1 = { ‘abc’: 456 };
dict2 = { ‘abc’: 123, 98.6: 37 };
访问字典里的值
把相应的键放入到方括号中，如下实例:

实例
#!/usr/bin/python3

dict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’}

print ("dict[‘Name’]: ", dict[‘Name’])
print ("dict[‘Age’]: ", dict[‘Age’])
以上实例输出结果：

dict[‘Name’]: Runoob
dict[‘Age’]: 7
如果用字典里没有的键访问数据，会输出错误如下：

实例
#!/usr/bin/python3

dict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’};

print ("dict[‘Alice’]: ", dict[‘Alice’])
以上实例输出结果：

Traceback (most recent call last):
File “test.py”, line 5, in
print ("dict[‘Alice’]: ", dict[‘Alice’])
KeyError: ‘Alice’
修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

实例
#!/usr/bin/python3

dict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’}

dict[‘Age’] = 8; # 更新 Age
dict[‘School’] = “菜鸟教程” # 添加信息

print ("dict[‘Age’]: ", dict[‘Age’])
print ("dict[‘School’]: ", dict[‘School’])
以上实例输出结果：
dict[‘Age’]: 8
dict[‘School’]: 菜鸟教程
删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下实例：

实例
#!/usr/bin/python3

dict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Class’: ‘First’}

del dict[‘Name’] # 删除键 ‘Name’
dict.clear() # 清空字典
del dict # 删除字典

print ("dict[‘Age’]: ", dict[‘Age’])
print ("dict[‘School’]: ", dict[‘School’])
但这会引发一个异常，因为用执行 del 操作后字典不再存在：

Traceback (most recent call last):
File “test.py”, line 9, in
print ("dict[‘Age’]: ", dict[‘Age’])
TypeError: ‘type’ object is not subscriptable
注：del() 方法后面也会讨论。

字典键的特性
字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。

两个重要的点需要记住：

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：

实例
#!/usr/bin/python3

dict = {‘Name’: ‘Runoob’, ‘Age’: 7, ‘Name’: ‘小菜鸟’}

print ("dict[‘Name’]: ", dict[‘Name’])
以上实例输出结果：

dict[‘Name’]: 小菜鸟
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：

实例
#!/usr/bin/python3

dict = {[‘Name’]: ‘Runoob’, ‘Age’: 7}

print ("dict[‘Name’]: ", dict[‘Name’])
以上实例输出结果：

Traceback (most recent call last):
File “test.py”, line 3, in
dict = {[‘Name’]: ‘Runoob’, ‘Age’: 7}
TypeError: unhashable type: ‘list’