day05回顾 ：

break语句

for 语句

for 变量 in 可迭代对象:

... do somthing...

else:

...

continue 语句

while i < 100:

pass

else:

pass

循环相关的语句：

while

for

break

continue

range 函数:

等差数列

1 3 5 7

for 嵌套:

列表：

列表是可变的序列

列表是容器

[] 空列表 等同于 list()

[1,2,3,4] 等同于 list(range(1,5))

列表的运算:

+ += * *=

列表的比较:

< <= > >= == != is is not

day06笔记:

列表的 in / not in运算符 (成员身份验证运算符)

作用：

判断一个值是否存在于列表中,存在返回True,不存在返回 False

同字符串的in运算符相同.

示例：

x = [1, "two", 3, "Four"]

3 in x # True

3 not in x # False

'two' in x # True

列表的索引操作:

语法:

列表[整数表达式]

用法：

等同于字符串的索引

索引分正向索引和反向索引(同字符串)

示例：

L = [1, 2, 3, 4]

print(L[0]) # 1

print(L[-1]) # 4

思考：

如何让列表从后向前依次打印列表的值：

# 正向的打印

for x in L:

print(x)

# 反向打印:

for x in L[::-1]:

print(x)

for i in range(3, -1, -1):

print(L[i])

列表的索引赋值:

列表是可变的序列，可以通过索引改变列表的元素

例：

L = [1,2,3,4]

L[2] = 3.14 # 索引赋值

print(L)

对比字符串:

L = [1,2,3,4]

L += [5] # 创建了新的列表，不是改变原列表

print(L) #

s = "ABCD"

s += "E"

print(s)

列表的切片

语法:

列表[开始索引:终止索引: 步长]

列表的切片取值规则等同于字符串切片规则.

示例：

x = [0,1,2,3,4,5,6,7,8]

y = x[1:9:2] # y = [1,3,5,7] 奇数

y = x[9:1:-2] # y = [8,6,4,2]

x[::-2]

列表的切片赋值:

作用：

可以改变原列表，可以插入和删除数据，也可以改变数据

说明：

切片赋值的等号运算符的右侧必须是一个序列

语法：

列表[(开始索引):(终止索引)(:(步长))] = 序列

示例:

L = [2,3,4]

L[0:1] = [1.1, 2.2]

L = [2,3,4]

L[2:] = [3.3, 4.4, 5.5]

L = [2,3,4]

L[3:] = [5.5, 6.6]

L = [2,3,4]

L[0:0] = [0, 1] # [0, 1, 2, 3, 4]

L = [2,3,4]

L[1:1] = [2.5, 2.6]

# 删除数据

L = [2,3,4]

L[1:] = []

L = [2,3,4]

L[1:2] = "ABC" # L=[2, 'A', 'B', 'C', 4]

L[1:2] = ["ABC"] # L=[2, "ABC", 4]

对于步长大于1 的切片赋值:

L = [1, 2, 3, 4, 5, 6]

L[::2] = [] # 错的

L[::2] = [1.1, 3.3, 5.5] # L = [1.1, 2, 3.3, 4, 5.5, 6]

L[::2] =[1,2,3,4] # ????

说明：

对于步长大于1的切片赋值，序列的个数要等于切出的段数

对于反向切片的赋值,规则同正向切片，同学们自己偿试

思考:

L = [1, 2, 3, 4, 5, 6]

能否将 1,3,5删除? 答案是用切片无法实现

L[::2] = [[], [], []]

del 语句

可以用del语句删除变量，也可以用它来删除列中的元素

语法:

del 列表[整数表达式] # 索引

del 列表[::] # 切片

示例：

L = [1,2,3,4,5,6]

del L[3] # 结果 L = [1,2,3,5,6]

L = [1,2,3,4,5,6]

del L[::2] # 结果 L = [2,4,6]

Python3中常用于序列的函数:

len(seq)

max(x)

min(x)

-----以上是我们以前学过的-----

sum(x) 返回序列中所有元素的和(元素必须是数值类型)

any(x) 真值测试,如果序列中其中一个值为真值则返回True,全为假返回False

all(x) 真值测试，如果序列中所有值为真值返回True,否则返回False

示例:

L = [1, 2, 3, 4, 6]

len(L) # 5

max(L) # 6

min(L) # 1

L = [1, 2.0, 3.14]

max(L) # 对的 返回值为3.14

L = [1, 2, "3"]

max(L) # 错的

练习：

任意输入五个数，存于列表中，打印出这五个数的最大值，最小值，平均值

常用的列表 方法 method:

对象.方法名(传参)

假设列表名为L

L.index(v[, begin[, end]]) 返回对应元素的索引下标，begin为开始索引，end为结束索引

L.insert(index, obj) 将某个元素插入到列表中的指定位置

L.count(x) 返回列表中的元素个数

L.remove(x) 从列表中删除第一次出现在列表中的值

L.copy() 复制此列表(只复制一层，不会复制深层对象)

L.append(x) 向列表中追加单个元素

L.extend(lst) 向列表追加另一个列表

L.clear() 清空列表,等同于 L[:] = []

L.sort(reverse=False) 将列表中的元素进行排序，默认顺序按值的小到大顺序排列

L.reverse() 列表的反转，用来改变原列表的先后顺序

L.pop([index]) 删除索引用对应的元素，如果不加索引，默认删除最后元素，同时返回删除的元素

详见: >>> help(list)

示例：

L = [5, 7, 9, 3, 1]

L2 = L.copy() # L2 = [5, 7, 9, 3, 1]

L[2] = 10

L2 # L2的值不变

L = [1,2,3]

L2 = L[:] # 切片实现复制

L[1] = 2.2

L2 # L2 = [1,2,3]

# append 和extend

L = [1,2,3]

L.append(4) # L = [1,2,3,4]

L.extend([5,6,7]) # L = [1,2,3,4,5,6,7]

# 思考

L = [1,2,3,4]

L.append([5,6,7]) # L = [1,2,3,4,[5,6,7]]

# 思考

L = [1,2,3]

L2 = L

# L = [] # 这算清空列表吗？答：不算清空列表

L[:] = [] # 同于L.clear()

print(L2) # [1,2,3]

# 排序

L = [5, 7, 9, 3, 1]

L.sort() # L = [1, 3, 5, 7, 9]

L = [5, 7, 9, 3, 1]

L.sort(reverse=True) # L = [9,7,5,3,1]

练习：

输入多行文字，存入列表中

每次输入后回车算作一行，

任意输入多行，当直接输入回车(即空行时算作输入结束)

1) 打印刚才输入的行数

2) 按原输出的内容在屏幕上输出内容

3) 打印刚才您共输出了多少字符

深拷贝 和 浅拷贝

浅拷贝 (shallow copy):

示例：

L = [3.1, 3.2]

L1 = [1, 2, L]

L2 = L1.copy()

L[0] = 3.14

print(L1) # L1 = [1, 2, [3.14, 3.2]]

print(L2) # L2 = [1, 2, [3.14, 3.2]]

深拷贝 (deep copy)

import copy # 导入copy 模块

L = [3.1, 3.2]

L1 = [1, 2, L]

L2 = copy.deepcopy(L1) # 深拷贝

L[0] = 3.14

print(L1) # [1, 2, [3.14, 3.2]]

print(L2) # [1, 2, [3.1, 3.2]] #此对象不会被修改

注：深拷贝通常只对可变对象进行复制，不可变对象通常不变

列表与字符串比较:

1） 列表和字符串都是序列，元素之间有先后关系

2） 字符串是不可变的序列，列表是可变的序列

3） 字符串中每个元素只能存储字符，而列表可以存储任意类型的元素

4） 列表和字符串都是可迭代对象

L = [1,2,3,4]

for x in L:

print(x)

练习：

已知有列表

L = [3,5]

用L的方法实现原列表变为:

L = [1,2,3,4,5]

将列表反转，删除最后一个后打印此列表

print(L) [5,4,3,2]

字符串文本解析方法:

S.split(sep=None) 将字符串，使用sep作为分隔符分割字符串，返回分割后的列表。

S.join(iterable) 用可迭代对像中的字符串，返回一个中间用s进行分隔的字符串

中文帮助文档:

示例：

# 字符拆成列表

s = "abcd abc ab a"

s.split(' ')

# 由字符串组成的序列合并为字符串

L = ["welcome", "to", "beijing"]

s = ' '.join(L) # s = "welcome to beijing"

练习：

１．　有字符串"hello"

生成字符串"h e l l o" 和 "h-e-l-l-o"

s = 'hello'

' '.join(list(s))

2. 有一些数存于列表中．如：

L = [1, 3, 2, 1, 6, 4, 2, ....., 99, 82]

要求将列表中只出现一次的元素存入另一个列表L2中

3. 将10000以内的所有素数存于列表中，求这些素数的和