010-012列表：一个打了激素的数组

010-012列表：一个打了激素的数组

1. 数组内的对象必须是同一类型，由于Python的变量没有数据，所以Python没有数组，但是Python加入了列表，以下内容都可以加入到列表里：整数、浮点数、字符串、对象。

2. 创建列表：

a) 创建一个普通的列表

b) 创建一个混合列表：不像数组一样只能存放同一数据类型的内容，而是都可以放置：

i. Mix = [1, ‘小甲鱼’, 3.14, [1, 2, 3] ]

c) 创建一个空列表：目前不知道将来会用到什么数据类型，可以先创建以个空列表：

i. Empty = []

3. 向列表添加元素

a) Append()语法：member.append(‘福禄娃娃’)（这个点暂时可以理解为范围的意思，我们把属于对象的函数称之为方法，append这个方法是属于member列表的对象的，所以用.来限制）

i. Member = [‘小甲鱼’, ‘小布丁’, ‘黑夜’, ‘迷途’]

ii. Member.append(‘福禄娃娃’)

iii. Member

iv. [‘小甲鱼’, ‘小布丁’, ‘黑夜’, ‘迷途’, ‘福禄娃娃’]（福禄娃娃被添加在列表的末端了）

v. Append()括号里面只能放一个参数，放两个会报错

vi. Member.append(‘竹林小溪’, ‘Crazy迷恋’)会报错

b) Extend()：其原理是用一个列表来扩展另一个列表，所以它的参数是列表，而且也只能放一个参数（即一个列表）在括号内，不过可以用这个扩展的列表来同时加入两个名字：member.extend([‘竹林小溪’, ‘Crazy迷恋’])（该列表会自动添加到原列表的末尾）

c) Insert()：有两个参数，第一个参数代表在列表中的位置，第二个参数代表在第一个参数的位置插入新增的内容：member.insert(1, ‘ 牡丹‘)

i. [‘小甲鱼’, ‘牡丹’, ‘小布丁’, ‘黑夜’, ‘迷途’, ‘福禄娃娃’, ‘竹林小溪’, ‘Crazy迷恋’]

ii. 为什么没有排在最前面？因为是从1开始的，而在编程中，凡是顺序索引，均从0开始

4. Member.append(['竹林小溪', 'Crazy迷恋'])和member.extend(['竹林小溪', 'Crazy迷恋'])实现的效果相同么？

a) 不相同，member.append(['竹林小溪', 'Crazy迷恋'])打印出来是[‘小甲鱼’, ‘小布丁’, ‘黑夜’, ‘迷途’, ‘福禄娃娃’, ['竹林小溪', 'Crazy迷恋']]

b) Member[3]会打印出member列表中位置为3的内容

c) Print(,)可以并排打逗号前后的内容

5. 从列表中获取元素：元素的索引值（index）

a) Member = [‘小甲鱼’, ‘牡丹’, ‘小布丁’, ‘黑夜’, ‘迷途’, ‘怡静’, ‘福禄娃娃’, ‘竹林小溪’, ‘Crazy迷恋’]

b) Member[0]

c) ‘小甲鱼’

d) 如何将牡丹与小甲鱼的位置调换？引入一个中间变量：

i. Temp = member[0]

ii. Member[0] = member[1]

iii. Member[1] = temp

6. 从列表删除元素

a) Remove()方法：member.remove(‘怡静’)：必须要知道列表要删除元素的名字，但不需要知道位置；如果打了列表中不存在的元素，会报错

b) Del语句：

i. Del member[1]会删掉小甲鱼

ii. Del member会删掉整个列表

c) Pop()：从列表中取出最后一个元素并返回给你

i. Member.pop()

ii. ‘Crazy迷恋’

iii. Member = ['牡丹', '小布丁', '黑夜', '迷途', '福禄娃娃', '竹林小溪']

iv. 可以给pop()赋值

v. name = member.pop()

vi. >>> name

vii. '竹林小溪'

viii. >>> member

ix. ['牡丹', '小布丁', '黑夜', '迷途', '福禄娃娃']

x. member.pop(1)

xi. '小布丁'

xii. >>> member

xiii. ['牡丹', '黑夜', '迷途', '福禄娃娃']

7. 列表分片（Slice）：利用索引值，每次只能从列表中获取一个元素，如果一次性需要获取多个元素，可以利用列表分片实现：

a) Member[1:3]#包含前面不包含后面，且只是原列表所选部分的拷贝，原列表并没有任何变化

b) ['黑夜', '迷途']

c) >>> member

d) ['牡丹', '黑夜', '迷途', '福禄娃娃']

e) member[:3]#默认从0开始

f) ['牡丹', '黑夜', '迷途']

g) >>> member[1:]#默认到最后

h) ['黑夜', '迷途', '福禄娃娃']

i) >>> member[:]#默认整个列表

j) ['牡丹', '黑夜', '迷途', '福禄娃娃']

k) >>> member2 = member[:]#当你想要对列表进行一些改动，但是有不希望变动原列表，可以用这个放法直接创建一个和原列表一样的列表

l) >>> member2

m) ['牡丹', '黑夜', '迷途', '福禄娃娃']

n) List1 = [1, 3, 2, 9, 7, 8]

o) list1[0]和list1[0:1]不一样，前者返还回第0个元素的值，后者返还回只有一个含有第0个元素的列表：1和[1]的区别

p) Python列表支持负数索引：正常索引是从左到右索引，负数索引为从右到左索引List[-3:-1]会得到[9, 7]

8. 分片操作可以设置步长，不设置步长时默认为1，表示逐个遍历元素

a) “简洁”分片操作在这里有效：

i. List1[::2]

ii. [1, 2, 7]

b) 步长不能为0，否则会报错

c) 步长可以为负数，改变方向（从尾部开始向左走）：

i. List1[::-2]

ii. [8, 9, 3]

d) 步子太大容易扯着蛋……（这句话有没有用啊？）

9. 课堂上小甲鱼说可以利用分片完成列表的拷贝list2 = list1[:]，那可不可以直接list2 = list1这样更简洁呢？千万不可以！

a) 第一步

i. >>> list1 = [1, 3, 2, 9, 7, 8]

ii. >>> list2 = list1[:]

iii. >>> list2

iv. [1, 3, 2, 9, 7, 8]

v. >>> list3 = list1

vi. >>> list3

vii. [1, 3, 2, 9, 7, 8]

b) 第二步：看上去貌似一样，但实际上根本不一样，看以下操作：

i. >>> list1.sort()

ii. >>> list1

iii. [1, 2, 3, 7, 8, 9]

iv. List1从小到大排了个序，而list2没变，但是list3变了

v. >>> list2

vi. [1, 3, 2, 9, 7, 8]

vii. >>> list2

viii. [1, 3, 2, 9, 7, 8]

c) Python的变量就像一个标签，一个名字而已，贴哪指哪，为一个固定的东西指定另一个名字的做法只是向同一个东西增加一个标签而已。

10. 列表的一些常用操作符

a) 比较操作符：列表可以比较大小，按照列表里面第一个数比较，不往后看

i. list1 = [123]

ii. >>> list2 = [234]

iii. >>> list2 > list1

iv. True

v. >>> list2 < list1

vi. False

vii. >>> list1 = [123, 456]

viii. >>> list2 = [234, 123]

ix. >>> list1 > list2

x. False

b) 逻辑操作符

i. >>> list3 = [123, 456]

ii. >>> (list1 < list2) and (list1 == list3)

iii. True

c) 连接操作符：注意连接的两个内容必须是同一类型的，都是列表，类似字符串的拼接，否则会报错；两个列表拼接得到一个新列标，有点类似extend()扩展列表，但是extend()更规范，还是用extend()比较好。

i. list4 = list1 + list2

ii. >>> list4

iii. [123, 456, 234, 123]

iv. >>> list1 + '小甲鱼'  #不能添加元素到列表中，应该用append()方法或者Insert()方法

v. Traceback (most recent call last):

vi.   File "<pyshell#11>", line 1, in <module>

vii.     list1 + '小甲鱼'

viii. TypeError: can only concatenate list (not "str") to list

d) 重复操作符

i. list3

ii. [123, 456]

iii. >>> list3 * 3

iv. [123, 456, 123, 456, 123, 456]

v. >>> list3

vi. [123, 456]

vii. >>> list3 *= 3

viii. >>> list3

ix. [123, 456, 123, 456, 123, 456]

x. >>> list3 *= 5

xi. >>> list3

xii. [123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456, 123, 456]

e) 成员关系操作符

i. >>> 123 in list3

ii. True

iii. >>> '小甲鱼' not in list3

iv. True

v. >>> 123 not in list3

vi. False

vii. >>> list5 = [123, ['小甲鱼', '牡丹'], 456]

viii. >>> '小甲鱼' in list5

ix. False #成员关系操作符不能直接判断列表中的列表，类似break和continue一样只能访问一层，可以按照列表中索引的方法来实现访问列表中的列表

x. >>> '小甲鱼' in list5[1]

xi. True

xii. >>> list5[1][1] #索引列表中列表的元素可以用两个[]实现，第一个[]定位列表中列表位置，第二个定位索引元素位置

xiii. '牡丹'

11. 列表的小伙伴们（列表类型的BIF）

a) >>> dir(list)

b) ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

c) Count()：计算其参数在列表中出现的次数

i. >>> list3.count(123)

ii. 15

d) Index()：这个方法会返回其参数在列表中的位置

i. >>> list3.index(123)

ii. 0

iii. >>> list3.index(123, 3, 7) #后面两个参数一个是寻找范围的起始位置另一个是结束位置

iv. 4

v. >>> list3.index(123, 3, 16)

vi. 4 #只能索引第一个出现的位置

e) Reverse()：将整个列表完全翻转，默认不需要参数

i. 

f) Sort()：用指定的方式对列表的成员进行排序，默认不需要参数，从小到大进行排序

i. >>> list6 = [4, 2, 5, 1, 9, 23, 32, 0]

ii. >>> list6.sort()

iii. >>> list6

iv. [0, 1, 2, 4, 5, 9, 23, 32]

v. >>> list6.reverse()

vi. >>> list6

vii. [32, 23, 9, 5, 4, 2, 1, 0]

viii. >>> list6.sort(reverse=True)

ix. >>> list6

x. [32, 23, 9, 5, 4, 2, 1, 0]

g) Copy()：拷贝列表，和使用切片拷贝是一样的

i. >>> list2 = list1.copy()

ii. >>> list2

iii. [1, [1, 2, ['小甲鱼']], 3, 5, 8, 13, 18]

h) Clear()：用于清空列表的元素，但要注意，清空后列表仍然存在只是变成一个空列表

i. >>> list2.clear()

ii. >>> list2

iii. []

12. 下边这个列表的’小甲鱼’修改为’小鱿鱼’？

a) list1 = [1, [1, 2, ['小甲鱼']], 3, 5, 8, 13, 18]

b) list1[1][2][0] = '小鱿鱼'

13. 列表解析（列表推导式）：列表推导式（list comprehensions）也叫列表解析，灵感来取自函数式编程语言Haskell。Ta是一个非常有用和灵活的工具，可以用来动态的创建列表，语法如：[有关于A的表达式 for A in B]

a) Eg1.

i. >>> [i*i for i in range(10)]

ii. [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

b) Eg2.

i. >>> list1 = [x**2 for x in range(10)]

ii. >>> list1

iii. [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

iv. 相当于：

v. list1 = []

vi. for x in range(10):

vii.     list1.append(x**2)

c) Eg3.

i. >>> list1 = [(x, y) for x in range(10) for y in range(10) if x%2==0 if y%2!=0]

ii. 相当于：

iii. list1 = []

iv. for x in range(10):

v.     for y in range(10):

vi.         if x%2 == 0:

vii.             if y%2 != 0:

viii.                 list1.append((x, y))

d) Eg4.

i. >>> list1 = ['1.Just do It', '2.一切皆有可能', '3.让编程改变世界', '4.Impossible is Nothing']

ii. >>> list2 = ['4.Adidas', '2.Lining', '3.FishC studio', '1.Nike']

iii. >>> list3 = [name + ':' + slogan[2:] for slogan in list1 for name in list2 if slogan[0] == name[0]]

iv. >>> list3

v. ['1.Nike:Just do It', '2.Lining:一切皆有可能', '3.FishC studio:让编程改变世界', '4.Adidas:Impossible is Nothing']

vi. >>> for each in list3:

vii.  print(each)

viii. 

ix. 

x. 1.Nike:Just do It

xi. 2.Lining:一切皆有可能

xii. 3.FishC studio:让编程改变世界

xiii. 4.Adidas:Impossible is Nothing

MicrosoftInternetExplorer402DocumentNotSpecified7.8 磅Normal0