循环:列表，元组

数据结构。数据结构是以某种方式（如通过编号）组合起来的数据元素（如数、字符乃至其他数据结构）集合

在Python中，最基本的数据结构为序列（sequence）。序列中的每个元素都有编号，即其位置或索引，其中第一个元素的索引为0，第二个元素的索引
为1.

python 内置多种序列，最常用的两种：列表和元组，还有字符串
列表和元组的主要不同在于，列表是可以修改的，而元组不可以，列表适用于需要中途添加元素的情形，而元组适用于出于某种考虑需要禁止修改序列的情形

列表来表示（所有元素都放在方括号内，并用逗号隔开）

序列还可包含其他序列,Python支持一种数据结构的基本概念，名为容器（container）。容器基本上就是可包含其他对象的对象。两种主要的容器是序列（如列表和元组）和映射（如字典）。在序列中，每个元素都有编号，而在映射中，每个元素都有名称（也叫键）

通用的序列操作

索引、切片、相加、相乘和成员资格检查，迭代（iteration）。

grr = "shlsjgjl"
print(grr[2])
l


endings = ['st', 'nd', 'rd'] + 17 * ['th'] 
 + ['st', 'nd', 'rd'] + 7 * ['th'] 
 + ['st'] 
print(endings)

['st', 'nd', 'rd', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'st', 'nd', 'rd', 'th', 'th', 'th', 'th', 'th', 'th', 'th', 'st']
​

遍历列表

bis= ["sss", "ass222","kjjga","dksjkgj"]
for xx in bis :
    print(xx)



sss
ass222
kjjga
dksjkgj

循环临时存储建议：

for cat in cats:
for dog in dogs:
for item in list_of_items: 

循环中执行更多操作：

bis= ["sss", "ass222","kjjga","dksjkgj"]
for xx in bis :
    print(xx + "  你好" "
")
print("loop  is end ")    


sss  你好

ass222  你好

kjjga  你好

dksjkgj  你好

loop  is end 

避免缩进错误

Python根据缩进来判断代码行与前一个代码行的关系
不必要的缩进/忘记缩进/循环后不必要的缩进/遗漏冒号

创建数值列表

列表非常适合用于存储数字集合
range()函数

for xx in range(1,5):
    print(xx)
1
2
3
4

使用 range()创建数字列表

xxx = list(range(1,5))
print(xxx)
for x in xxx:
    print(x)


 for value in range(1,11): 
        xx = value ** 2
        print(xx)

列表步长

xx = list(range(1,10,2))
print(xx)

对数字列表执行简单的统计计算

>>> digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
>>> min(digits)
0
>>> max(digits)
9
>>> sum(digits)
45 

列表解析

列表解析将for循环和创建新元素的代码合并成一行，并自动附加新元素。

squares = [value**2 for value in range(1,11)]
print(squares) 

切片:切片（slicing）来访问特定范围内的元素,使用两个索引，并用冒号分隔

可指定要使用的第一个元素和最后一个元素的索引。
与函数range()一样，Python在到达你指定的第二个索引前面的元素后停止。要输出列表中的前三个元素，需要指定索引0~3，这将输出分别为0、1和2的元素。
提供两个索引来指定切片的边界，其中第一个索引指定的元素包含在切片内，但第二个索引指定的元素不包含在切片内

players = ['charles', 'martina', 'michael', 'florence', 'eli'] 
print(players[0:4])

如果你没有指定第一个索引，Python将自动从列表开头开始

players = ['charles', 'martina', 'michael', 'florence', 'eli'] 
print(players[:4])

要让切片终止于列表末尾，也可使用类似的语法

players = ['charles', 'martina', 'michael', 'florence', 'eli'] 
print(players[2:])

特定位置到末尾：

players = ['charles', 'martina', 'michael', 'florence', 'eli'] 
print(players[-2:])

遍历切片

players = ['charles', 'martina', 'michael', 'florence', 'eli'] 
print("Here are the first three players on my team:") 
for xx in players[-3:]:
    print(xx)

复制列表

players = ['charles', 'martina', 'michael', 'florence', 'eli'] 
xx = players[:]
print(xx)

结果不同：
xx = players

对一个变量操作会导致另一个变量也变化，因为两者指向同一个列表

序列相加:
不能拼接列表和字符串，不能拼接不同类型的序列

[1, 2, 3] + [4, 5, 6] 

'Hello,' + 'world!' 

乘法：

'python' * 5 

None、空列表和初始化

空列表是使用不包含任何内容的两个方括号（[]）表示的
None表示“什么都没有”的值，如表示还没有在列表中添加任何内容。在这种情况下，可使用None

sequence = [None] * 10
print(sequence)    

成员资格

检查特定的值是否包含在序列中，可使用运算符in，它检查是否满足指定的条件，并返回相应的值：满足时返回True，
不满足时返回False。这样的运算符称为布尔运算符，真值称为布尔值

ss = "kskljg"
'k' in ss

元组tuple

tuple一旦初始化就不能修改
tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来

列表非常适合用于存储在程序运行期间可能变化的数据集。列表是可以修改的。
Python将不能修改的值称为不可变的，而不可变的列表被称为元组。

元组使用圆括号定义。可以使用索引来访问其元素，就像访问列表元素一样

players = ('charles', 'martina', 'michael', 'florence', 'eli')
print(players[3])

##赋值失败
players[0] = "xxxxxx"
此Python指出不能给元组的元素赋值

如果要定义一个空的tuple，可以写成()：
要定义一个只有1个元素的tuple，如果你这么定义：

>>> t = (1)
>>> t
1

定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。

只有1个元素的tuple定义时必须加一个逗号,，来消除歧义
Python在显示只有1个元素的tuple时，也会加一个逗号

a = (1,)
print(a)

一个可变的元组

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

遍历

players = ('charles', 'martina', 'michael', 'florence', 'eli')
for x in players:
    print(x)

修改元组变量

不能修改元组的元素，但可以给存储元组的变量赋值

 dimensions = (200, 50)
 dimensions = (400, 100) 

代码格式

每级缩进4个空格
都建议每行不超过80字符
将程序的不同部分分开，可使用空行

参考廖雪峰博客

函数 list

可将任何序列（而不仅仅是字符串）作为list的参数

#拆分
list("hellow")

#合并
x = ['h', 'e', 'l', 'l', 'o', 'w']
''.join(x)

索引

并行迭代两个序列zip 函数

将两个序列“缝合”起来，并返回一个由元组组成的序列。返回值是一个适合迭代的对象，要查看其内容，可使用list将其转换为列表。
当序列的长度不同时，函数zip将在最短的序列用完后停止“缝合”

names = ['anne', 'beth', 'george', 'damon']
ages = [12, 45, 32, 102] 
list(zip(names, ages))

迭代时获取索引

用内置函数enumerate

for index, string in enumerate(strings):
 if 'xxx' in string:
 strings[index] = '[censored]'