自学Python——有序的集合 List和tuple

1.List基础

1.1定义

classmates = ['Michael', 'Bob', 'Tracy']
print('Max:'+max(classmates))

1.2整体和单个输出

print(classmates)
print(classmates[0])

1.3判断某个元素是否存在

print("Bob" in classmates)

1.4获取最后一个元素

print("最后一个元素为"+ classmates[-1])

1.5获取倒数第二个元素

print("倒数第二个元素为"+ classmates[-2])

1.6赋值

可以赋不同类型的值

classmates[0]="0"
classmates[1]=1
classmates[2]="2"

1.7取长度

print("集合长度为： %d " % len(classmates))

1.8循环遍历

for i in range(0, 2 + 1):
    print(classmates[i])

for temp in classmates:
    print(temp)

1.9末尾添加和指定位置添加

classmates.append("3")
classmates.insert(0,12)
print(classmates)

1.10移除指定元素

classmates.remove('0')
print(classmates)

1.11移除末尾和移除指定位置的元素

classmates.pop()
classmates.pop(0)
print(classmates)

1.12多维集合

p=['asp', 'php']
s = ['python', 'java',p , 'scheme' ]
print(s)
print(s[2][1])

2.tuple

2.1tuple和list非常类似，但是tuple一旦初始化就不能修改

mates = ('Michael', 'Bob', 'Tracy')
print(mates)

2.2

获取元素和遍历的方法与List相同，但是不能 添加 修改 删除 其中的元素

mates[0])=0   #E0001:invalid syntax  tuple
print(mates[0])

2.3 只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

t = (1,)
print(t)

2.4“可变的”tuple：

t = (1,[2],3)
t[1].append(3)
t[1].insert(0,20) 
print(t)

tuple不变，指的是，tuple的每个元素，指向永远不变，当元素存储的是基本数据类型时，就直接指向该数值，而第二个元素 指向的是 List的首地址，tuple始终指向该List未发生改变

2.5遍历

for temp in t:
    print(temp) 

3.切片

3.1 List切片

有序集合List取指定索引范围的操作，Python提供了切片（Slice）操作符

L =[1,2,3,4,5,6,7,8,9,9,55,5,22]
print(L[0:3])
# 从索引0开始取，直到索引3为止，但不包括索引3。即索引0，1，2，正好是3个元素。
L1=L[2:6]
print(L1)
print(L[6:])# 第二个索引缺失表示到最后
print(L[:3])# 第一个索引缺失表示到最前
print(L[-2:])# -2 表示倒数第二个

L=list(range(100))

# 前十个
print(L[:10])
# 后十个
print(L[-10:])
# 11-20
print(L[10:20])
# 前十个，每两个取一个
print(L[:10:2])
# 所有数，每5个取一个：
print(L[::5])

3.2 tuple切片

tuple也是一种list，唯一区别是tuple不可变。 因此，tuple也可以用切片操作，只是操作的结果仍是tuple：

T=(1,2,3,4,5,6,7,8,9)
print(T)
print(T[:3])

3.3 字符串切片

字符串’xxx’也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：

S="0123456789"
print(S[:3])

4. 迭代

L=[1,2,3,4,5,6,7,8,9]
T =(1,2,3,4,5,6,7,8,9)
S=set(L)
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d['TOM']=100 
d['Bob']=200 
s='123456789'

# 迭代，统一采用相同的个数

# list
print('-------------')
for temp in L:
    print(temp)

# tuple
print('-------------')
for temp in T:
    print(temp)


# dict
print('-------------')
for temp in d:
    print(temp)

print('-------------')
for temp in d.keys():
    print(temp)

print('-------------')
for temp in d.values():
    print(temp)

print('-------------')
for tempK,tempV in d.items():
    print(tempK)
    print(tempV)

# set
print('-------------')
for temp in S:
    print(temp)

# str
print('-------------')
for temp in s:
    print(temp)

所以，当我们使用for循环时，只要作用于一个可迭代对象，for循环就可以正常运行，而我们不太关心该对象究竟是list还是其他数据类型。那么，如何判断一个对象是可迭代对象呢？
方法是通过collections模块的Iterable类型判断：

1.引包，2.判断

from collections import Iterable
f=isinstance('abc', Iterable) # str是否可迭代
print(f)

最后一个小问题，如果要对list实现类似Java那样的下标循环怎么办？
Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：

for i, value in enumerate(['A', 'B', 'C']):
    print(i, value)

上面的for循环里，同时引用了两个变量，在Python里是很常见的，比如下面的代码：

for x, y in [(1, 1), (2, 4), (3, 9)]:
    print(x, y)

列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。
要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用

print(list(range(1, 11)))

但如果要生成[1x1, 2x2, 3x3, …, 10x10]怎么做

方法一、循环生成

L=[]
for i in range(1,11):
    L.append(i*i)
print(L)

方法二、用列表生成式

L2=[i*i for i in range(1,11)]
print(L2)

同样可以在for后面加上if

L3=[i*i for i in range(1,11)if i%2==0]
print(L3)

变着花样的来

L4=[i+j for i in 'abc' for j in 'xyz']
L5=[i+j for i in 'abc' if i>'b'  for j in 'xyz' if j>'y']
print(L4)
print(L5)

运用列表生成式，可以写出非常简洁的代码。例如，列出当前目录下的所有文件和目录名，可以通过一行代码实现：

import os  # 导入os模块，模块的概念后面讲到
L6=[d for d in os.listdir('.')] # os.listdir可以列出文件和目录
print(L6)

把一个list中所有的字符串变成小写：

L7= ['Hello', 'World', 'IBM', 'Apple']
L8=[s1.lower() for s1 in L7]
print(L8)

练习

如果list中既包含字符串，又包含整数，由于非字符串类型没有lower()方法，所以列表生成式会报错：
使用内建的isinstance函数可以判断一个变量是不是字符串：

L9 = ['Hello', 'World', 18, 'Apple', None]
请修改列表生成式，通过添加if语句保证列表生成式能正确地执行：
期待输出: [‘hello’, ‘world’, ‘apple’]

L10=[s1.lower() for s1 in L9 if isinstance(s1 ,str)]
print(L10)

5. 生成器

在循环的过程中不断推算出后续的元素呢？
在Python中，这种一边循环一边计算的机制，称为生成器：generator。

5.1例子介绍

L = [x * x for x in range(10)]
print(L)
g = (x * x for x in range(10))

L是一个list，而g是一个generator。注意与 tuple区分

print(g)
print(next(g))
print(next(g))
print(next(g))
print(next(g))

for n in g:
    print(n)

因为g是一个generator，因此，会在之前生成的基础上进行生成，不会每次从最初值开始

5.2另一种方式创建 generator

定义一个斐波那契数列函数

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

a, b = b, a + b 相当于：
t = (b, a + b) # t是一个tuple
a = t[0]
b = t[1]

5.3定义一个斐波那契数列生成器

def fib1(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'


f= fib1(5)
for i in f:
    print(i)