引言

这篇文章介绍 python 中的三种组合数据类型，文章后半段会介绍如何在这些组合数据类型中应用 ” 分片 ” 取出数据。

文章目录

0×1. 元组
0×2. 列表
0×3. 字典
0×4. 数据分片实例

0×1. 元组

在 python 中，元组（Tuple）应用中括号来创立，如果括号中仅蕴含一个元素，须要在元素开端增加一个逗号（不增加逗号数据会被创立成字符串或数值数据类型），元组在创立后，不能增加删除其中的元素，其值的指向是固定不变的，请看上面的实例：

# 创立三个元组，b 元组仅蕴含一个字符串元素，所以开端须要增加一个逗号，否则 b 将被创立为字符串对象，c 元组是一个多维元组，蕴含了 a 和 b 元组
>>> a=(1,2,3,4,5)
>>> b=("www.qingsword.com",)
>>> c=(a,b)

#别离打印出三个元组中的元素
>>> print(a)
(1, 2, 3, 4, 5)
>>> print(b)
('www.qingsword.com',)
>>> print(c)
((1, 2, 3, 4, 5), ('www.qingsword.com',))

#打印出 a 元组第一个元素，python 的索引起始是从 0 开始的
>>> print(a[0])
1

#打印出 a 元组中最初一个元素，len()函数将失去 a 元组元素的个数，因为索引是从 0 开始的，所以元素个数减一，就是最初一个元素的索引号
>>> print(a[len(a)-1])
5

#另一种简便的获取元组中最初一个元素的办法，间接应用 -1，以此类推，获取倒数第二个元素就应用 - 2 作为索引值
>>> print(a[-1])
5
>>> print(a[-2])
4

#获取多维元组中，第 0 个元素（a 元组）中索引地位为 2 的值，也就是 a 子元组中的 3 了
>>> print(c[0][2])
3

#再来看上面这个实例，在元组中蕴含了一个列表，而后应用索引批改元组中列表的两个元素的值，下面所说的元组的元素不可变指的是援用的地位不变（内存地址），在本例中，元组 t1 索引地位为 2 的元素指向了一个列表所在的内存地址，咱们只是扭转了列表中的元素，而并没有扭转元组的这个指向，而如果将这个指向更改成另外的列表或元素，就会产生一个谬误
>>> t1=(1,2,["x","y"])
>>> print(t1)
(1, 2, ['x', 'y'])
>>> t1[2][0]="a"
>>> t1[2][1]="b"
>>> print(t1)
(1, 2, ['a', 'b'])

#甚至还能够应用列表的办法对元组中蕴含的列表增加和删除数据，列表的相干操作将在本文第 2 局部介绍
>>> t1[2].append("c")
>>> print(t1)
(1, 2, ['a', 'b','c'])

0×2. 列表

python 中，能够应用中括号创立列表，在下面的元组实例中的大部分操作都实用于列表，只须要将圆括号替换成中括号即可，不同点是，列表中仅蕴含一个元素时，不须要在开端增加逗号，另外，列表能够增加或删除元素，请看上面的实例：

# 创立三个列表，其中 c 为多维列表，蕴含 a 和 b
>>> a=[1,2,3,4,5]
>>> b=["www.qingsword.com"]
>>> c=[a,b]

#打印出三个列表中的元素
>>> print(a)
[1, 2, 3, 4, 5]
>>> print(b)
['www.qingsword.com']
>>> print(c)
[[1, 2, 3, 4, 5], ['www.qingsword.com']]

#应用 list.append()办法，给 a 列表增加一个元素 6
>>> a.append(6)
>>> print(a)
[1, 2, 3, 4, 5, 6]

#append()办法一次只能增加单个元素，而 list.extend()办法一次能够增加多个元素
>>> a.extend([7,8,9])
>>> print(a)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

#利用 extend()办法的个性，能够将一个列表中的元素齐全复制给另外一个列表，上面创立了一个空列表 d，而后将 c 列表中的元素复制给 d，这里有个很奇怪的中央，在创立 c 的时候，蕴含的 a 列表只有前五位，当初 c 列表的第一个元素变成了 9 位，这是因为 c 列表第一个元素只是指向 a 列表的内存地址，a 列表扭转时，c 读取到的数据也会扭转
>>> d=[]
>>> d.extend(c)
>>> print(d)
[[1, 2, 3, 4, 5, 6, 7, 8, 9], ['www.qingsword.com']]

#应用 list.remove()办法能够删除列表中的元素，这个办法接管的不是索引值，而是元素值（本例间接删除了 a 列表中的元素 1 和 2）>>> a.remove(1)
>>> a.remove(2)
>>> print(a)
[3, 4, 5, 6, 7, 8, 9]

#list.pop()办法接管一个索引值，如果不指定索引值则默认为最初一位元素的索引值，这个办法将取出并返回对应元素给调用者，而后从列表中删除这个元素
>>> print(a.pop())
9
>>> print(a)
[3, 4, 5, 6, 7, 8]

#删除索引值为 0 的元素
>>> print(a.pop(0))
3
>>> print(a)
[4, 5, 6, 7, 8]

python 提供了一个 set()函数用于解决列表中的反复元素，将他们合并成一个元素，例如：

# 应用 set()去除列表中的反复值
>>> lst1=set([1,2,3,3,4,4])
>>> lst2=set([3,4,5,5,6,6])
>>> lst3=set(["a","a","b","c","c"])

>>> print(list(lst1))
[1, 2, 3, 4]
>>> print(list(lst2))
[3, 4, 5, 6]
>>> print(list(lst3))
['a', 'c', 'b']

#set 类型的列表因为不存在反复值，所以可用于科学计算，例如求交加和并集
>>> print(list(lst1&lst2))
[3, 4]
>>> print(list(lst1|lst2))
[1, 2, 3, 4, 5, 6]

除了手动输出每个列表的元素外，python 还提供了一个列表高级个性——” 列表生成式 ”，配合 for 循环可能主动生成列表，例如：

#"列表生成式" 语法：[元素后果表达式 for 循环 判断语句或嵌套循环]
#执行程序为，先运行 "for 循环"，而后执行 "判断语句或嵌套循环"，将 "for 循环 判断语句或嵌套循环" 这一部分失去的每一个值，放入 "元素后果表达式" 进行计算，最初将后果保留到列表中

#生成 1~10 中每位数字平方的列表
>>> L0=[x*x for x in range(1,11)]
>>> print(L0)
[1, 4, 9, 16, 25, 36, 49, 64, 81,100]

#从 0~9 中一一读取数字，如果读取的数字可能整除 2，则执行 x * x 并将后果保留到列表中
>>> L1=[x*x for x in range(0,10) if x%2==0]
>>> print(L1)
[0, 4, 16, 36, 64]

#嵌套循环，实现全组合，x 相当于外层循环，y 相当于嵌套的子循环，每个 x 都将失去 3 个 y 值，每个后果都将执行 x + y 并将后果保留到列表中
>>> L2=[x+y for x in "ABC" for y in "abc"]
>>> print(L2)
['Aa', 'Ab', 'Ac', 'Ba', 'Bb', 'Bc', 'Ca', 'Cb', 'Cc']

#大小写转换
>>> L3=[x.upper() for x in "abc"]
>>> print(L3)
['A', 'B', 'C']
>>> L3=[x.lower() for x in "ABC"]
>>> print(L3)
['a', 'b', 'c']

#应用 a 和 b 变量读取字典 {"one":1,"two":2} 中的每一个元素的键和值，最初将他们用等号连贯保留到列表中
>>> L4=[a+"="+str(b) for a,b in {"one":1,"two":2}.items()]
>>> print(L4)
['two=2', 'one=1']

#有时候咱们在生成一组列表的时候，如果应用了大小写转换函数，但生成式中却蕴含了数值类型，就会触发异样，例如
 L5=[x.lower() for x in ["A","B",1,2]]

#能够应用上面的办法解决这个问题，isinstance 函数接管两个参数，第一个参数是传入的值，第二个参数是比对类型，当传入的值和比对类型匹配的时候返回 True，在上面这个列表生成式中，依据 python 中 and 和 or 的返回原理，当 isinstance(x,str)为真时，返回 x.lower()，即如果 x 是字符串，将其转换成小写，而当 isinstance(x,str)为假时 "isinstance(x,str) and x.lower()" 为假，返回 or 前面的 x，行将 x 不做任何批改增加到列表中
>>> L5=[isinstance(x,str) and x.lower() or x for x in ["A","B",1,2]]
>>> print(L5)
['a', 'b', 1, 2]

下面应用的 ” 列表生成式 ” 在创立列表的时候就曾经计算出了列表的所有成员并贮存在内存中了，这其实并不迷信，有时咱们创立的生成式会计算出很多元素，如果元素过多就会占用大量的内存，而咱们仅须要拜访列表中局部元素，这个时候就能够应用另外一种形式创立列表——” 列表生成器 ”（generator）；

与 ” 列表生成式 ” 不同，” 列表生成器 ” 保留的仅仅是列表生成算法自身，只有当咱们去迭代这个 ” 列表生成器 ” 对象的时候，才执行算法计算出咱们拜访的值，请看上面的实例：

# 创立 "列表生成器" 而不是 "列表生成式" 仅须要将中括号改成圆括号即可
>>> L6=(x*x for x in range(0,10) if x%2==0)
>>> print(L6)
<generator object <genexpr> at 0x7faec4938410>

#有两种办法来让生成器执行算法，第一种办法是应用 next()函数，如果 next()曾经获取完所有值，则会抛出一个 StopIteration 异样
>>> print(next(L6))
0
>>> print(next(L6))
4
>>> print(next(L6))
16
>>> print(next(L6))
36
>>> print(next(L6))
64
>>> print(next(L6))
Traceback (most recent call last):
    print(next(L6))
StopIteration

#但理论利用中很少应用 next()函数，而是应用 for 循环迭代
>>> L6=(x*x for x in range(0,10) if x%2==0)
>>> for a in L6:
        print(a)   
0
4
16
36
64

0×3. 字典

python 中，应用大括号可能创立字典，字典中每个元素都是以 ” 键值对 ” 的模式贮存的，请看上面的实例：

# 有两种办法能够创立字典，第一种间接创立一个空的字典，而后一一增加键值
>>> a={}
>>> a["早餐"]="牛奶鸡蛋"
>>> a["午餐"]="可乐牛排"
>>> a["晚餐"]="水果沙拉"
>>> print(a)
{'早餐': '牛奶鸡蛋', '晚餐': '水果沙拉', '午餐': '可乐牛排'}

#第二种办法创立字典，一次性增加所有的键值，用冒号分隔每一组元素，冒号前为 "键"，冒号后为 "值"
>>> a={'早餐': '牛奶鸡蛋', '晚餐': '水果沙拉', '午餐': '可乐牛排'}

#python 容许不同的键领有雷同的值，所以上面的语法是正确的
b={"one":"qing","two":"qing"}

#有两种办法能够读取字典中的值，间接应用 "字典 [键]" 来读取值，或应用 "字典.get(键)" 来读取值，在应用 get() 办法取出值的时候，如果 get 的键不存在，get()办法会返回一个 "None"，或咱们指定的值
>>> print(a["早餐"])
牛奶鸡蛋
>>> print(a.get("午餐"))
可乐牛排
>>> print(a.get("233"))
None
#如果字典中不存在 "233" 返回本站网址
>>> print(a.get("233","www.qingsword.com"))
www.qingsword.com

#判断字典中是否存在某个键值对，除了应用 get()办法看返回是否为 "None" 外，还能用关键字 in，如果存在就返回 True，否则返回 False
>>> "早餐" in a
TRUE

#读取字典 keys 和 values 列表
>>> print(a.keys())
dict_keys(['早餐', '晚餐', '午餐'])
>>> print(a.values())
dict_values(['牛奶鸡蛋', '水果沙拉', '可乐牛排'])

#除此之外，能够应用 items()办法读取字典中每一组 "键值对"
>>> for z in a.items():
        print(z)
('晚餐', '水果沙拉')
('早餐', '牛奶鸡蛋')
('午餐', '可乐牛排')

#如果应用两个参数，就能获取每一组键值对中单个键和值数据
>>> for x,y in a.items():
        print(x,y)
午餐 可乐牛排
早餐 牛奶鸡蛋
晚餐 水果沙拉

#如果想删除字典中的某个 "键值对"，能够应用 pop()办法，向这个办法传递字典中的一个键名称，就能够取出并删除对应的 "键值对"
>>> a.pop("早餐")
>>> print(a)
{'晚餐': '水果沙拉', '午餐': '可乐牛排'}

0×4. 数据分片实例

在 python 中可能通过数据分片，实现读取某段字符串中单个字符的目标，这种思维同样实用于元组和列表，如果列表中贮存的为字符串，就能够通过分片技术取出某个元素的第几个字符，这种办法在某些环境中会十分实用，请看上面的实例：

# 首先来看 python 对字符串数据的分片提取办法，本例取出 a 指向的字符串数据中，索引地位为 2 的单个字符
>>> a="abcdefg"
>>> print(a[2])
c

#在列表数据中，能够将每个字符串元素看做一个子列表，应用多维列表的思维，提取子列表中对应索引地位的值
>>> b=["www.qingsword.com","abcdefg","12345678"]
>>> print(b[0][4])
q

#提取 b 中索引地位为 2 的元素的最初一位字符
>>> print(b[2][-1])
8

应用字符串分片技术，将一组列表中的每个元素的首字母提取进去作为字典的键，并对应这个元素的值，上面是一段比拟残缺的程序：

#!/usr/bin/env python3
#创立一个名称列表
a=["Qingsword","John","Tom","George","Kali","Eva"]
x=0
#创立一个空字典
b={}
#当 x 值小于 a 列表元素个数时循环
while x<len(a):
    b[a[x][0]]=a[x]
    x+=1  
print(b)   

#程序输入
{'E': 'Eva', 'G': 'George', 'Q': 'Qingsword', 'K': 'Kali', 'J': 'John', 'T': 'Tom'}

除了下面介绍的简略切片技术外，python 还提供了一种非凡的切片技术——” 分号切片 ”，请看上面的实例：

# 分号切片同样实用于字符串或元组列表，语法为 "[起始索引: 完结索引(不蕴含)]"

#从字符串 a 索引为 2（3）的地位开始切片，直到索引 6（7）的地位，截取这其中的数据输入（蕴含起始索引值，不蕴含完结索引值）>>> a="123456789"
>>> print(a[2:6])
3456

#从 b 中索引为 3（d）的地位开始，直到索引为 5（f）的地位
>>> b=["a","b","c","d","e","f","g"]
>>> print(b[3:5])
['d', 'e']

#再来看几个实例，创立一个蕴含元素 1~9 的列表
>>> L=list(range(1,10))
>>> print(L)
[1, 2, 3, 4, 5, 6, 7, 8, 9]

#取出列表中从倒数第三个元素直到开端的全副元素
>>> print(L[-3:])
[7, 8, 9]

#取出列表中从倒数第三个元素到倒数第一个元素（不蕴含最初一个元素）>>> print(L[-3:-1])
[7, 8]

#如果从第一个元素开始取，能够省略冒号前的 0
>>> print(L[:3])
[1, 2, 3]

#从第 1 到 6 个元素中，每隔一个元素取一个（步长为 2）>>> print(L[:6:2])
[1, 3, 5]

#全副列表元素，每隔一个元素取一个
>>> print(L[::2])
[1, 3, 5, 7, 9]

#中括号中什么都不写，只有一个冒号，就是取全副的元素
>>> print(L[:])
[1, 2, 3, 4, 5, 6, 7, 8, 9]

#同样的分片操作也实用于元组和字符串
>>> T=tuple(range(1,10))
>>> print(T[::2])
(1, 3, 5, 7, 9)
>>> s="www.qingsword.com"
>>> print(s[::2])
'wwqnsodcm'