列表和元组

数据结构

数据结构是以某种方式（如通过编号）组合起来的数据元素（如数、字符乃至其他数据结构）集合。在Python中，最基本的数据结构为序列（sequence）。序列中的每个元素都有编号，即其位置或索引，其中第一个元素的索引为0，第二个元素的索引为1，依此类推。

Python内置了多种序列，其中最常用的两种：列表和元组。另一种重要的序列
是字符串。

列表和元组的主要不同在于，列表是可以修改的，而元组不可以。这意味着列表适用于需要中途添加元素的情形，而元组适用于出于某种考虑需要禁止修改序列的情形。禁止修改序列通常出于技术方面的考虑，与Python的内部工作原理相关，这也是有些内置函数返回元组的原因所在。在你自己编写程序时，几乎在所有情况下都可使用列表来代替元组。一种例外情况是将元组用作字典键。在这种情况下，不能使用列表来代替元组，因为字典键是不允许修改的。

在需要处理一系列值时，序列很有用。在数据库中，你可能使用序列来表示人，其中第一个元素为姓名，而第二个元素为年龄。如果使用列表来表示（所有元素都放在方括号内，并用逗号隔开），将类似于下面这样：

In [10]: lisi=['lisi',35]

序列还可包含其他序列，因此可创建一个由数据库中所有人员组成的列表：

In [10]: lisi=['lisi',35]                                                                              
In [11]: zhangsan=['zhangsan',30]                                                                      
In [12]: wangwu=['wangwu',32]                                                                          
In [13]: database=[lisi,zhangsan,wangwu]                                                               
In [14]: print(database)                                                                               
[['lisi', 35], ['zhangsan', 30], ['wangwu', 32]]

Python支持一种数据结构的基本概念，名为容器（container）。容器基本上就是可包含其他对象的对象。两种主要的容器是序列（如列表和元组）和映射（如字典）。

在序列中，每个元素都有编号
在映射中，每个元素都有名称（也叫键）。
有一种既不是序列也不是映射的容器，它就是集合（set）。

通用序列操作

有几种操作适用于所有序列，包括索引、切片、相加、相乘和成员资格检查。另外，Python还提供了一些内置函数，可用于确定序列的长度以及找出序列中最大和最小的元素。

索引

序列中的所有元素都有编号——从0开始递增,这称为索引（indexing）。你可使用索引来获取元素。这种索引方式适用于所有序列。当你可像下面这样使用编号来访问各个元素：

In [16]: name = 'Liudehua'                                                                             
In [17]: name[0]                                                                                       
Out[17]: 'L'

也可以使用负数索引，Python将从右（即从最后一个元素）开始往左数，因此-1是最后一个元素的位置。

In [18]: name[-1]                                                                                      
Out[18]: 'a'

对于字符串字面量（以及其他的序列字面量），可直接对其执行索引操作，无需先将其赋给变量。这与先赋给变量再对变量执行索引操作的效果是一样的。

In [19]: 'Liudehua'[1]                                                                                 
Out[19]: 'i'

索引实例：

# 将以数指定年、月、日的日期打印出来
months = [ 
 'January', 
 'February', 
 'March', 
 'April', 
 'May', 
 'June', 
 'July', 
 'August', 
 'September', 
 'October', 
 'November', 
 'December' 
] 
# 一个列表，其中包含数1～31对应的结尾
endings = ['st', 'nd', 'rd'] + 17 * ['th'] \ 
 + ['st', 'nd', 'rd'] + 7 * ['th'] \ 
 + ['st'] 
year = input('Year: ') 
month = input('Month (1-12): ') 
day = input('Day (1-31): ') 
month_number = int(month) 
day_number = int(day) 
# 别忘了将表示月和日的数减1，这样才能得到正确的索引
month_name = months[month_number-1] 
ordinal = day + endings[day_number-1] 
print(month_name + ' ' + ordinal + ', ' + year)

程序运行结果如下：

Year: 1974 
Month (1-12): 8 
Day (1-31): 16 
August 16th, 1974    #这一行为最后输出的结果

切片

除使用索引来访问单个元素外，还可使用切片（slicing）来访问特定范围内的元素。为此，可使用两个索引，并用冒号分隔：

In [20]: tag = '<a href="http://www.python.org">Python web site</a>'                                   
In [21]: tag[9:30]                                                                                     
Out[21]: 'http://www.python.org'
In [22]: tag[32:-4]                                                                                    
Out[22]: 'Python web site'

切片适用于提取序列的一部分，其中的编号非常重要：第一个索引是包含的第一个元素的编号，但第二个索引是切片后余下的第一个元素的编号。简而言之，你提供两个索引来指定切片的边界，其中第一个索引指定的元素包含在切片内，但第二个索引指定的元素不包含在切片内。

切片的简写

In [1]: numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]                                                      
In [2]: numbers[7:10]                                                                                  
Out[2]: [8, 9, 10]
#从7到最后
In [3]: numbers[7:]                                                                                    
Out[3]: [8, 9, 10]
#从倒数第三个到最后
In [4]: numbers[-3:]                                                                                   
Out[4]: [8, 9, 10]
#从开始第一个到第3个
In [5]: numbers[:3]                                                                                    
Out[5]: [1, 2, 3]
#复制整个序列，可将两个索引都省略
In [6]: numbers[:]                                                                                     
Out[6]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

步长

执行切片操作时，你显式或隐式地指定起点和终点，但通常省略另一个参数，即步长。在普通切片中，步长为1。这意味着从一个元素移到下一个元素，因此切片包含起点和终点之间的所有元素。

In [7]: numbers[0:10:1]                                                                                
Out[7]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

如果指定的步长大于1，将跳过一些元素。例如，步长为2时，将从起点和终点之间每隔一个元素提取一个元素。

In [8]: numbers[0:10:2]                                                                                
Out[8]: [1, 3, 5, 7, 9]

显式地指定步长时，也可使用简写。例如，要从序列中每隔3个元素提取1个，只需提供步长4即可。

In [10]: numbers[::4]                                                                                  
Out[10]: [1, 5, 9]

步长不能为0，否则无法向前移动，但可以为负数，即从右向左提取元素。

In [11]: numbers[8:3:-1]                                                                               
Out[11]: [9, 8, 7, 6, 5]
In [12]: numbers[10:0:-2]                                                                              
Out[12]: [10, 8, 6, 4, 2]
In [13]: numbers[0:10:-2]                                                                              
Out[13]: []
In [14]: numbers[::-2]                                                                                 
Out[14]: [10, 8, 6, 4, 2]
In [15]: numbers[5::-2]                                                                                
Out[15]: [6, 4, 2]
In [16]: numbers[:5:-2]                                                                                
Out[16]: [10, 8]

第一个索引依然包含在内，而第二个索引不包含在内。步长为负数时，第一个索引必须比第二个索引大。可能有点令人迷惑的是，当你省略起始和结束索引时，Python竟然执行了正确的操作：步长为正数时，它从起点移到终点，而步长为负数时，它从终点移到起点。

序列相加

可使用加法运算符来拼接序列。

In [17]: [1, 2, 3] + [4, 5, 6]                                                                        
Out[17]: [1, 2, 3, 4, 5, 6]
In [18]: 'Hello,' + 'world!'                                                                          
Out[18]: 'Hello,world!'
In [19]: [1, 2, 3] + 'world!'                                                                         
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-19-67e1ff30f8a3> in <module>
----> 1 [1, 2, 3] + 'world!'
TypeError: can only concatenate list (not "str") to list

从错误消息可知，不能拼接列表和字符串，虽然它们都是序列。一般而言，不能拼接不同类型的序列。

乘法

将序列与数x相乘时，将重复这个序列x次来创建一个新序列：

In [20]: 'python' * 5                                                                                  
Out[20]: 'pythonpythonpythonpythonpython'
In [21]: [42] * 10                                                                                     
Out[21]: [42, 42, 42, 42, 42, 42, 42, 42, 42, 42]

None、空列表和初始化

空列表是使用不包含任何内容的两个方括号（[]）表示的。

在Python中，None表示什么都没有。

要将列表的长度初始化为10，可像下面这样做：

In [22]: sequence = [None] * 10                                                                        
In [23]: sequence                                                                                      
Out[23]: [None, None, None, None, None, None, None, None, None, None]

序列（字符串）乘法运算示例:

# 在位于屏幕中央且宽度合适的方框内打印一个句子
sentence = input("Sentence: ") 
screen_width = 80 
text_width = len(sentence) 
box_width = text_width + 6 
left_margin = (screen_width - box_width) // 2 
print() 
print(' ' * left_margin + '+' + '-' * (box_width-2) + '+') 
print(' ' * left_margin + '| ' + ' ' * text_width + ' |') 
print(' ' * left_margin + '| ' + sentence + ' |') 
print(' ' * left_margin + '| ' + ' ' * text_width + ' |') 
print(' ' * left_margin + '+' + '-' * (box_width-2) + '+') 
print()

这个程序的运行情况类似于下面这样：

Sentence: He's a very naughty boy! 
 +-----------------------------+ 
 |                             | 
 |  He's a very naughty boy!   | 
 |                             | 
 +-----------------------------+

成员资格

要检查特定的值是否包含在序列中，可使用运算符in。这个运算符与前面讨论的运算符（如乘法或加法运算符）稍有不同。它检查是否满足指定的条件，并返回相应的值：满足时返回True，不满足时返回False。这样的运算符称为布尔运算符，而前述真值称为布尔值。

In [24]: permissions = 'rw'                                                                            
In [25]: 'w' in permissions                                                                            
Out[25]: True
In [26]: 'x' in permissions                                                                            
Out[26]: False
In [27]: users = ['mlh','foo','bar']                                                                   
In [28]: input('Enter your user name: ') in users                                                      
Enter your user name: mlh
Out[28]: True
In [29]: subject = '$$$ Get rich now!!! $$$'                                                           
In [30]: '$$$' in subject                                                                              
Out[30]: True

开头两个示例使用成员资格测试分别检查’w’和’x’是否包含在字符串变量permissions中。在UNIX系统中，可在脚本中使用这两行代码来检查对文件的写入和执行权限。
接下来的示例检查提供的用户名mlh是否包含在用户列表中，这在程序需要执行特定的安全策略时很有用（在这种情况下，可能还需检查密码）。
最后一个示例检查字符串变量subject是否包含字符串’$$$’，这可用于垃圾邮件过滤器中。

# 检查用户名和PIN码
database = [ 
 ['albert', '1234'], 
 ['dilbert', '4242'], 
 ['smith', '7524'], 
 ['jones', '9843'] 
] 
username = input('User name: ') 
pin = input('PIN code: ') 
if [username, pin] in database: print('Access granted')

长度、最小值和最大值

内置函数len、min和max很有用，其中函数len返回序列包含的元素个数，而min和max分别返回序列中最小和最大的元素。

In [31]: numbers = [100,34,678,90,56]                                                                  
In [32]: len(numbers)                                                                                  
Out[32]: 5
In [33]: max(numbers)                                                                                  
Out[33]: 678
In [34]: min(numbers)                                                                                  
Out[34]: 34
In [35]: max(2,3)                                                                                      
Out[35]: 3
In [36]: min(9,3,2,5)                                                                                  
Out[36]: 2

列表：Python 的主力

前面的示例大量地使用了列表，你明白了它们很有用，但本节主要讨论列表不同于元组和字符串的地方——列表是可变的，即可修改其内容。另外，列表有很多特有的方法。

列表使用举例：

例1：通讯录每个学生都有id 名字电话号。那我们就可以使用列表的索引作为id，值为“名字和电话号组成的列表” ———-[[‘Tom’,18801116580],[‘Lily’,18801116581]]
例2：如果需要统计公司计算机设备固定资产，我们可以这个来处理硬件信息：
[“厂商”,“型号”,“购买时间”,“所在位置”,“原价”,“用途”,“IP”]
例3：可以模拟实现堆栈
- 堆，先进先出（FIFO—first in first out）
- 栈，先进后出 (FILO—First-In/Last-Out)

函数list

可以使用字符串来创建列表。为此，可使用函数list。

In [37]: list('hello')                                                                                 
Out[37]: ['h', 'e', 'l', 'l', 'o']

基本的列表操作

可对列表执行所有的标准序列操作，如索引、切片、拼接和相乘，但列表的有趣之处在于它是可以修改的。下面介绍一些修改列表的方式：给元素赋值、删除元素、给切片赋值以及使用列表的方法。（请注意，并非所有列表方法都会修改列表。）

1. 修改列表：给元素赋值

使用索引表示法给特定位置的元素赋值，如x[1] = 2。

In [1]: x = [1,1,1]                                                                                    
In [2]: x[1] = 2                                                                                       
In [3]: x                                                                                              
Out[3]: [1, 2, 1]
In [4]: x[4] = 10                                                                                      
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-4-e257b27bcdef> in <module>
----> 1 x[4] = 10
IndexError: list assignment index out of range

不能给不存在的元素赋值，因此如果列表的长度为2，就不能给索引为100的元素赋值。要这样做，列表的长度至少为101。

2. 删除元素

从列表中删除元素也很容易，只需使用del语句即可。

In [5]: tianwang = ['liudehua','zhangxueyou','liming','guofucheng']                                    
In [6]: del tianwang[2]                                                                                
In [7]: tianwang                                                                                       
Out[7]: ['liudehua', 'zhangxueyou', 'guofucheng']

注意到liming彻底消失了，而列表的长度也从4变成了3。除用于删除列表元素外，del语句还可用于删除其他东西。可将其用于字典乃至变量。

3. 给切片赋值

切片是一项极其强大的功能，而能够给切片赋值让这项功能显得更加强大。

In [8]: name = list('Perl')                                                                            
In [9]: name                                                                                           
Out[9]: ['P', 'e', 'r', 'l']
In [10]: name[2:] = list('ar')                                                                         
In [11]: name                                                                                          
Out[11]: ['P', 'e', 'a', 'r']

通过使用切片赋值，还可将切片替换为长度与其不同的序列。

In [12]: name = list('Perl')                                                                           
In [13]: name[1:] = list('ython')                                                                      
In [14]: name                                                                                          
Out[14]: ['P', 'y', 't', 'h', 'o', 'n']

使用切片赋值还可在不替换原有元素的情况下插入新元素。

In [15]: numbers = [1,5]                                                                               
In [16]: numbers[1:1] = [2,3,4]                                                                        
In [17]: numbers                                                                                       
Out[17]: [1, 2, 3, 4, 5]

在这里，我“替换”了一个空切片，相当于插入了一个序列。你可采取相反的措施来删除切片。

In [17]: numbers                                                                                       
Out[17]: [1, 2, 3, 4, 5]
In [18]: numbers[1:4] = []                                                                             
In [19]: numbers                                                                                       
Out[19]: [1, 5]

上述代码与del numbers[1:4]等效。现在，你可自己尝试执行步长不为1（乃
至为负）的切片赋值了。

In [21]: numbers                                                                                       
Out[21]: [1, 2, 3, 4, 5]
In [22]: numbers[:5:2] = ['a','b','c']                                                                 
In [23]: numbers                                                                                       
Out[23]: ['a', 2, 'b', 4, 'c']

列表方法

方法是与对象（列表、数、字符串等）联系紧密的函数。通常，像下面这样调用方法：

object.method(arguments)

方法调用与函数调用很像，只是在方法名前加上了对象和句点。列表包含多个可用来查看或修改其内容的方法。

1. append

方法append用于将一个对象附加到列表末尾。

In [1]: lst = ["麻花藤", "林俊杰", "周润发", "周芷若"]                                                 
In [2]: lst                                                                                            
Out[2]: ['麻花藤', '林俊杰', '周润发', '周芷若']
In [3]: lst.append('赵敏')                                                                             
In [4]: lst                                                                                            
Out[4]: ['麻花藤', '林俊杰', '周润发', '周芷若', '赵敏']

append就地修改列表。这意味着它不会返回修改后的新列表，而是直接修改旧列表。

append方法一般用于给列表增加内容,例如：

lst = []
while True:
    content = input("请输入你要录入的员工信息, 输入Q退出:")
    if content.upper() == 'Q':
        break
    lst.append(content)
print(lst)

2. insert

方法insert用于将一个对象插入列表。

In [5]: numbers = [1, 2, 3, 5, 6, 7]                                                                   
In [6]: numbers.insert(3,'four')  # 在3的位置插入，原来的元素向后移动一位                                                                     
In [7]: numbers                                                                                        
Out[7]: [1, 2, 3, 'four', 5, 6, 7]

3. extend

方法extend让你能够同时将多个值附加到列表末尾，为此可将这些值组成的序列作为参数提供给方法extend。换而言之，你可使用一个列表来扩展另一个列表。

In [8]: a = [1,2,3]                                                                                    
In [9]: b = [4,5,6]                                                                                    
In [10]: a.extend(b)                                                                                   
In [11]: a                                                                                             
Out[11]: [1, 2, 3, 4, 5, 6]
In [13]: a.extend([8,9,10])                                                                            
In [14]: a                                                                                             
Out[14]: [1, 2, 3, 4, 5, 6, 8, 9, 10]

extend也是修改原来的列表。

在常规拼接中，情况是返回一个全新的序列。

In [13]: a = [1,2,3]                                                                                   
In [14]: b = [4,5,6]                                                                                   
In [15]: a + b                                                                                         
Out[15]: [1, 2, 3, 4, 5, 6]
In [16]: a                                                                                             
Out[16]: [1, 2, 3]

4. pop

方法pop从列表中删除一个元素（默认为最后一个元素），并返回这一元素。

lst = ["麻花藤", "王剑林林", "李李嘉诚", "王富贵"] 
print(lst)
lst.pop()
deleted = lst.pop()
print('被删除的',deleted)
print(lst)
el = lst.pop(2)  # 删除下标为2的元素
print(el)        # 被删除的元素
print(lst)

pop是唯一既修改列表又返回一个非None值的列表方法。

使用pop可实现一种常见的数据结构——栈（stack）。栈就像一叠盘子，你可在上面添加盘子，还可从上面取走盘子。最后加入的盘子最先取走，这被为后进先出（LIFO）。

5. remove

方法remove用于删除第一个为指定值的元素。

In [15]:  x = ['to', 'be', 'or', 'not', 'to', 'be']                                                    
In [16]: x.remove('be')                                                                                
In [17]: x                                                                                             
Out[17]: ['to', 'or', 'not', 'to', 'be']
In [18]: x.remove('bee')                                                                               
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-18-78e8416f31e9> in <module>
----> 1 x.remove('bee')
ValueError: list.remove(x): x not in list

remove只删除了为指定值的第一个元素，并无法删除列表中不存在指定值的元素。

请注意，remove是就地修改且不返回值的方法之一。不同于pop的是，它修改列表，但不返回任何值。

6. clear

方法clear就地清空列表的内容。

In [19]: lst = ["麻花藤", "王剑林", "李嘉诚", "王富贵"]                                                
In [20]: lst.clear()                                                                                   
In [21]: lst                                                                                           
Out[21]: []

这类似于切片赋值语句lst[:] = []。

7. copy

方法 copy 复制列表。

In [1]: a = [1,2,3]                                                                                    
In [2]: b = a.copy()                                                                                   
In [3]: b                                                                                              
Out[3]: [1, 2, 3]
In [4]: id(a)                                                                                          
Out[4]: 140103980924360
In [5]: id(b)                                                                                          
Out[5]: 140103991227272
In [6]: a[2] = 5                                                                                       
In [7]: a                                                                                              
Out[7]: [1, 2, 5]
In [8]: b                                                                                              
Out[8]: [1, 2, 3]

深拷贝浅拷贝

L = [1,2,3]

L1 = L 浅拷贝L和L1会互相影响相当于硬链接。

L2 = L[:] 深拷贝L2 会完全复制一份L,之后两都毫无关系

8. count

方法count计算指定的元素在列表中出现了多少次。

In [9]:  ['to', 'be', 'or', 'not', 'to', 'be'].count('to')                                             
Out[9]: 2
In [10]: x = [[1, 2], 1, 1, [2, 1, [1, 2]]]                                                            
In [11]: x.count(1)                                                                                    
Out[11]: 2
In [12]: x.count([1,2])                                                                                
Out[12]: 1

9. index

方法index在列表中查找指定值第一次出现的索引。

In [17]:  knights = ['We', 'are', 'the', 'knights', 'who', 'say', 'ni']                                
In [18]: knights.index('who')                                                                          
Out[18]: 4    #'who'的第一次出现的索引为4
In [19]: knights.index('herring')                                                                      
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-19-ee9b1a4b9dff> in <module>
----> 1 knights.index('herring')
ValueError: 'herring' is not in list
# 搜索'herring'时引发了异常，因为根本就没有找到这个单词。

10. reverse

方法reverse按相反的顺序排列列表中的元素。

In [20]: x = [1,2,3,4,5]                                                                               
In [21]: x.reverse()                                                                                   
In [22]: x                                                                                             
Out[22]: [5, 4, 3, 2, 1]

到reverse修改列表，但不返回任何值（与remove和sort等方法一样）。

11. sort

方法sort用于对列表就地排序。就地排序意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本。

In [23]:  x = [4, 6, 2, 1, 7, 9]                                                                       
In [24]: x.sort()                                                                                      
In [25]: x                                                                                             
Out[25]: [1, 2, 4, 6, 7, 9]

sort没有返回值，如果想保留原始列表，下面这样做是不对的

In [26]:  x = [4, 6, 2, 1, 7, 9]                                                                       
In [27]: y = x.sort()                                                                                  
In [29]: print(y)                                                                                      
None
In [30]: x                                                                                             
Out[30]: [1, 2, 4, 6, 7, 9]

正确方法之一是先将y关联到x的副本，再对y进行排序

In [31]:  x = [4, 6, 2, 1, 7, 9]                                                                       
In [32]: y = x.copy()                                                                                  
In [33]: y.sort()                                                                                      
In [34]: x                                                                                             
Out[34]: [4, 6, 2, 1, 7, 9]
In [35]: y                                                                                             
Out[35]: [1, 2, 4, 6, 7, 9]

方法sort接受两个可选参数：key和reverse

In [36]: x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']                                          
In [37]: x.sort(key=len)                                                                               
In [38]: x                                                                                             
Out[38]: ['add', 'acme', 'aerate', 'abalone', 'aardvark']

关键字参数reverse，只需将其指定为一个真值（True或False），以指出是否要按相反的顺序对列表进行排序。

In [48]: x = [4,7,1,3,10,32]                                                                           
In [49]: x.sort(reverse=True)                                                                          
In [50]: x                                                                                             
Out[50]: [32, 10, 7, 4, 3, 1]

列表的嵌套

注意:采用降维操作,一层一层的看就好

lst = [1,'太白','wusir',['麻花疼',['可口可乐'],'王健林']]
# 找到wusir
print(lst[2])
# 找到太白和wusir
print(lst[1:3])
# 找到太白的白字
print(lst[1][1])
# 将wusir拿到,然后首字母大写 在扔回去
s = lst[2]
s = s.capitalize()
lst[2] = s
print(lst)
# 简写
lst[2] = lst[2].capitalize()
print(lst)
# 把太白换成太黑
lst[1] = lst[1].replace('白','黑')
# 把麻花疼换成麻花不疼
lst[3][0] = lst[3][0].replace('疼','不疼')
print(lst)
# 在可口可乐后边添加一个雪碧
lst[3][1].append('雪碧')
print(lst)

元组：不可修改的序列

与列表一样，元组也是序列，且可存储任意类型数据,唯一的差别在于元组是不能修改的。元组语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组。逗号至关重要。

tmptuple = ()    #空元组，由于元组是只读的，空元组没有实际意义
tmptuple = （'abc',666,['hello',9527] ）
tmptuple = (‘value’,)    #当元组只有一个值是后面必须加个","，否则python不认可其为元组类型     
tmptuple = 'value',  
tmptuple = tuple(iterable)
tmptuple = 1,2,3
a = (42)  #这样是不对的,(42)和42是一样的
a = (42,)  #这样才可以

对序列的操作，元组也是可以的。

tu = ('我','怎么','这么','可爱')
tu1 = tu[0]  # 记性下标
print(tu1)
for i in tu:
    print(i)  # 进行for循环
tu2 = tu[0:3]
print(tu2)  # 进行切片

元组的切片也是元组，就像列表的切片也是列表一样。为何要熟悉元组呢？原因有以下两个:

它们用作映射中的键（以及集合的成员），而列表不行。
有些内置函数和方法返回元组，这意味着必须跟它们打交道。只要不尝试修改元组，与元组“打交道”通常意味着像处理列表一样处理它们。
作为参数使用，用来给函数等传参，将多个参数作为一个整体传给程序。

一般而言，使用列表足以满足对序列的需求

关于不可变, 注意: 这里元组的不可变的意思是子元素不可变. 而子元素内部的子元素是可以变, 这取决于子元素是否是可变对象.

In [66]: tu3 = (1,2,3,[5,6,7])                                                                         
In [67]: tu3[3][1]=10                                                                                  
In [68]: tu3                                                                                           
Out[68]: (1, 2, 3, [5, 10, 7])

元组嵌套

tu = ('今天姐姐不在家','姐夫和小姨子在客厅聊天',('姐夫问小姨子税后多少钱','小姨子说提什么钱'))
tu1 = tu[0]
tu2 = tu[1]
tu3 = tu[2][0]
tu4 = tu[2][1]
print(tu1)
print(tu2)
print(tu3)
print(tu4)

range

翻译过来就是范围,那我们我来先看下.

range(0,5,1)
参数第一个是范围的起始位置
参数第二个是范围的结束位置
参数第三个是步长
print(range(0,5))
# 结果:
range(0, 5)  #一个范围
# 我们可以通过list方法来转换这个范围来查看一下
l = list(range(0,5))
print(l)
# 结果:
[0, 1, 2, 3, 4]
l = list(range(0,5,2))
print(l)
# 结果:
[0, 2, 4]   # 这个结果就会发现和我之前用步长获取的内容是相似的,是的他就是步长
In [88]: list(range(10))  #生成10个数                                                                             
Out[88]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Python编程

3. 列表和元组