序列列表操作，文本解析（深浅拷贝）

学习目录大纲

 

列表：
    可变的序列
    是容器
    索引和切片操作
    列表可以索引赋值和切片赋值

del 语句
    用与删除列表中元素＃删除变量
        del　列表[整数表达式]
        del 列表[切片]
与序列相关的函数
len(x) max(x) min(x)  sum(x)  any(x)  all(x)

列表中的方法：
L.index(v [, begin[, end]])  根据值找索引
L.insert(index, obj)    将某个元素插放到列表中指定的位置对象obj需要插入的索引位置

>>> L = [1, 2, 3, 4, 5]
>>> L.insert(3, 10101)
>>> L
[1, 2, 3, 10101, 4, 5]
>>> L.index(3)
2

深拷贝deep copy ，　浅拷贝 shallow copy
字符串的方法
str.split()分割
str.join() 连接

列表推到式
[x**2 / 7 for x in range(1, 10, 2) if ...]
    @4       @2         @1           @3

嵌套
[x + y for x in [10, 20, 30] for y in range(10)]

 

 

 

序列

序列的种类：

字符串   str ,   列表　list ,　元组　tuple,     字节串　bytes ,字节数组   bytearray

支持操作：in /not in 索引　　切片　　＋　　＋＝　* *=　　比较运算

列表的索引操作

语法：
列表【整数表达式】
用法：
等同于字符串的索引操作（索引分正向索引和反向索引，规则与字符串完全相同
列表索引的赋值
语法：列表[整数表达式]　= 表达式
列表是可变的序列

>>>l = [2, 3, 5, 7]
>>>x = l[2]
>>>x
5
>>>[2, 3, 5, 7][2]
5

# 索引赋值2 L = [2, 3, 5, 7]
L[2] = 4#列表的索引赋值操作
print(L)#[2, 3, 4, 7]
L[-1] =5
print(L)#[2, 3, 4, 5]

列表的切片

列表[:]
列表[::]

L = [0, 1, 2, 3, 4, 5, 6, 7, 8]
L2 = L[1::2]#L2=[1, 3, 5, 7]

列表的切片赋值：
作用：
可以改变原列表的排列，可以插入和修改数据
可以用切片改变列表对应的元素的值
语法：
列表[切片slice] = 可迭代对象
说明：
赋值运算符的右侧必须是一个可迭代对象
例：

L = [2, 3, 4]
L[0:1] = [1.1, 2.2]#L=[1.1, 2.2, 3, 4]
L[2:] = [3.3, 4.4, 5.5]
>>> L = [2, 3, 4]
>>> L[2:] = [3.3, 4.4, 5.5]
>>> L
[2, 3, 3.3, 4.4, 5.5]
>>> L = [2, 3, 4, 5]
>>> L[0:1] =[2.2, 3.3] 
>>> L
[2.2, 3.3, 3, 4, 5]
>>> L[:] = [3, 4]
>>> L
[3, 4]
>>> L[0:0] = [1, 2]
>>> L
[1, 2, 3, 4]

 

起止值正负都在索引对应数值的左边进行切片，有位置先后关系

>>> L
[3, 5]
>>> L[1:1] = [4.1, 4.2]
>>> L
[3, 4.1, 4.2, 5]

>>> L
[3, 5]
>>> L[-1:-1] = [6]
>>> L
[3, 6, 5]
>>> L = [3, 5]
>>> L[2:2]=[6]
>>> L
[3, 5, 6]
>>> L[1:2] =[]
>>> L
[3, 6]


>>> L = [1, 6, 10]
>>> L[1:2] = range(2, 10)
>>> L
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> L = ['D', 'E']
>>> L[:0] = "ABC"
>>> L
['A', 'B', 'C', 'D', 'E']
>>> L = [1, 2, 3, 4, 5, 6]
>>> L[::2] = "ABC"
>>> L
['A', 2, 'B', 4, 'C', 6]


>>> L = [1, 2, 3, 4, 5, 6]
>>> L[::-2]= "DEF"
>>> L
[1, 'F', 3, 'E', 5, 'D']
>>>

 

代码执行

切片赋值注意事项：
对于步长不等于１的切片赋值，赋值运算符的右侧的可迭代对象提供的数据元素的个数一定要等于切片切出的片数

L=[1, 2, 3 ,4, 5, 6]
L[::2] = "ABC"#正确
L[::2] = "ABCDE"#错误

>>> L=[1, 2, 3 ,4, 5, 6]
>>> L[::2] = "ABC"
>>> L
['A', 2, 'B', 4, 'C', 6]

 

del语句用于删除列表的元素
语法：
del 列表[索引]
del 列表[切片]
例：

L = [0, 1, 2, 3, 4, 5, 6]
del L[0] #L = [1, 2, 3, 4, 5, 6]
del L[::2 ] #L = [1, 3, 5] 
>>> L = [0, 1, 2, 3, 4, 5, 6]
>>> del L[::-2]
>>> L
[1, 3, 5]

 

#   已知有列表:
#     L = [3, 5]

#     1) 用索引和切片等操作，将原列表改变为:
#     L = [1, 2, 3, 4, 5, 6]
    
#     2) 将列表反转,删除最后一个元素后打印此列表
#        ...
#        print(L)  # [6, 5, 4, 3, 2]

L = [3, 5]

# 1) 用索引和切片等操作，将原列表改变为:
L[1:1] = [4]
L[0:0] = [1, 2]
L[5:5] = [6]
print(L) # L = [1, 2, 3, 4, 5, 6]

# 2) 将列表反转,删除最后一个元素后打印此列表
L[:] = L[::-1]  # L = L[::-1]  反转
del L[-1]
print(L)  # [6, 5, 4, 3, 2]

 

python3中相关函数
序列５种
str, list, tuple, bytes, bytearray

len(x) 序列长度
max(x) 序列最大值元素
min(x) 最小
sum(x)　　　所有元素的和（元素必须为数值类型）
any(x)　　　真值测试，如果列表中其中一个值为真值则返回True
all(x) 真值测试，如果列表中所有值为真值则返回True
例：

L =　['北京', 1000, '天津']
len(L)#返回３
L= [8, 3, 6, 2]
max(L)#8
min(L)#2
sum(L)#19

1 L2 = L1[::-1] #或L1 = L1[::-1]
2 del L2[-1]#del [-1]
3 print(L2)
4 
5 L = ["fjkbo", 'aithbtyn', 'uo']
6 print(max(L))
7 print(min(L))
8 
9 print(any([0, 0.0, None, 3.14, False]))

 

2. 写一个程序，让用户输入很多正整数，当输入小于零的数时结束输入,
1) 打印这些数中最大的一个数
2) 打印这些数中第二大的一个数
3) 删除最小的一个数
4) 打印剩余数的和

L = []
while True:
    n = int(input("请输入正整数: "))
    if n < 0:
        break
    L.append(n)

print(L)

# 1) 打印这些数中最大的一个数
L.sort()  # 从小到大排序
print("最大的是:", L[-1])
# 2) 打印这些数中第二大的一个数
print("第二大的数是:", L[-2])
# 3) 删除最小的一个数
del L[0]
# 4) 打印剩余数的和
print("剩余这些数的和是:", sum(L))

 

列表中常用的方法(menthod)

>>>help(list)
>>>help(if)
>>>help('while')

L.index(v [, begin[, end]]) 返回对应元素的索引下标, begin为开始索引，end为结束索引,当 value 不存在时触发ValueError错误
>>> L = [0, 1, 2, 3, 4, 5, 6]
>>> L.index(4,0,5)
4

L.insert(index, obj) 将某个元素插放到列表中指定的位置
>>> L = [0, 1, 2, 3, 9, 8, 6]
>>> L.insert(3, 9)
>>> L
[0, 1, 2, 9, 3, 9, 8, 6]

L.count(x) 返回列表中元素x的个数
>>> L
[0, 1, 2, 9, 3, 9, 8, 6]
>>> L.count(4)
0
>>> L.count(9)
2
L.remove(x) 从列表中删除第一次出现在列表中的值x
>>> L
[0, 1, 2, 9, 3, 9, 8, 6]
>>> L.remove(1)
>>> L
[0, 2, 9, 3, 9, 8, 6]

L.copy() 复制此列表（只复制一层，不会复制深层对象)
L1 = [1,2,3,4,5]
L2 = L1.copy()
print(L2)

L.append(x) 向列表中追加单个元素x
>>> L
[0, 2, 9, 3, 9, 8, 6]
>>> L.append(20)
>>> L
[0, 2, 9, 3, 9, 8, 6, 20]

L.extend(lst) 向列表追加另一个列表
>>> L
[0, 2, 9, 3, 9, 8, 6, 20]
>>> L2
[0, 2, 9, 3, 9, 8, 6]
>>> L.extend(L2)
>>> L
[0, 2, 9, 3, 9, 8, 6, 20, 0, 2, 9, 3, 9, 8, 6]

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

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

>>> l=[1, 2, 5, 3, 6, 9, 10, 4]
>>> l.sort(reverse=False)
>>> l
[1, 2, 3, 4, 5, 6, 9, 10]
>>> l.sort(reverse=True)
>>> l
[10, 9, 6, 5, 4, 3, 2, 1]
>>> l.sort()
>>> l
[1, 2, 3, 4, 5, 6, 9, 10]

L.reverse() 列表的反转，用来改变原列表的先后顺序
>>> l
[1, 2, 3, 4, 5, 6, 9, 10]
>>> l.reverse()
>>> l
[10, 9, 6, 5, 4, 3, 2, 1]

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

L = {1, 2, 3, 2, 4, 3, 4, 5, 4, 5, 6}
L.index(3)
L.index(3, 3)

>>> L = [2, 3, 5, 7]
>>> L.insert(2, 4)
>>> L
[2, 3, 4, 5, 7]
>>> L.insert(0, 1)
>>> L
[1, 2, 3, 4, 5, 7]
>>> L.insert(6, 8)
>>> L
[1, 2, 3, 4, 5, 7, 8]

>>> L=[1, 2, 3, 2, 3, 4, 5, 4, 5, 6]
>>> L.count(4)
2
>>> L.count(100)
0
>>> L.remove(3)
>>> L
[1, 2, 2, 3, 4, 5, 4, 5, 6]
>>> L.remove(3)
>>> L
[1, 2, 2, 4, 5, 4, 5, 6]
>>> L.remove(3)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list

 

>>> L= [2, 3, 5, 7]
>>> L2 = L.copy()
>>> L2[1] = 3.14
>>> L2
[2, 3.14, 5, 7]
>>> L
[2, 3, 5, 7]

>>> L=[2, 3, 4,]
>>> L2 =L
>>> L2[1] = 3.14
>>> L2
[2, 3.14, 4]
>>> L
[2, 3.14, 4]

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

>>> L=['hello', 'world']
>>> L
['hello', 'world']
>>> L.append([100,200])
>>> L
['hello', 'world', [100, 200]]

>>> L = [1, 2]
>>> L.extend([3, 4])
>>> L
[1, 2, 3, 4]

 

>>> L = [0, 1, 2, 3, 9, 8, 6]
>>> L.sort(reverse=False)
>>> L
[0, 1, 2, 3, 6, 8, 9]
>>> L.sort(reverse=True)
>>> L
[9, 8, 6, 3, 2, 1, 0]

 

练习：
输入多行文字，存入列表中，每次输入回车后算一行
任意输入多行，当输入回车（空行结束）
１）按原输入内容在屏幕上输出
２）打印出您一共输入多少行文字
３）打印出您一共输入了多少个字符

# 输入多行文字，存入列表中,
# 每次输入回车后算一行
# 任意输入多行，当输入回车(即输入空行时结束输入)
L = []
while True:
    s = input("请输入文字: ")
    if s == '':  # 直接回车得到空字符串
        break
    L += [s]  # L.append(s)
# print(L)

# 1) 按原输入内容在屏幕上输出内容
for line in L:
    print(line)
# 2) 打印出您共输入了多少行文字
print("   共输入了%d行文字" % len(L))
# 3) 打印出您共输入了多少个字符
count = 0
for line in L:
    count += len(line)  # 把字符个数累加到count中
print('   您共输入了%d个字符' % count)

 

字符串的文本解析方法split和join

s 代表字符串
s.split(sep=None)
将字符串使用sep作为分隔符分割s 字符串，返回分割后的字符串列表，当不给定参数时，用空白字符作为分隔

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

字符串的两个方法
　s.split('字符串')
s.join(可迭代对象)

示例：

s='Beijing is capital'
L=s.split(' ') # L=['Beijing','is','capital']
ui #或L=s.split()
L=["C:","windows","System32"]
s='\\'.join(L) # s=r"C:\windows\System32"
6 s = 'beijing is capital'
7 L = s.split(' ')#L = ['beijing', 'is', 'capital']

 

练习：
1)有字符串"hello"
请用次字符串生成：
'h e l l o'　和　'h-e-l-l-o'

a = 'hello'
s = " ".join(a)
h = "-".join(a)
print(s, h)

2)写程序，让用户输入很多正整数，当输入小于零的数时结束输入‘
a.打印最大数
b.打印第二大数
c.删除最小数
d.打印剩余数的和

L = []
while True:
    n = int(input("请输入正整数: "))
    if n < 0:
        break
    L.append(n)
print(L)
# 1) 打印这些数中最大的一个数
L.sort()  # 从小到大排序
print("最大的是:", L[-1])
# 2) 打印这些数中第二大的一个数
print("第二大的数是:", L[-2])
# 3) 删除最小的一个数
del L[0]
# 4) 打印剩余数的和
print("剩余这些数的和是:", sum(L))

 

# 方法2
l = []
while True:
    a = int(input('请输入：'))
    if a < 0:
        break
    l +=[a]#l.append(a)
    l.sort(reverse=True)#从大到小#l.sort()#从小到大
print(l)
print('zuida',l[0], 'dierda', l[1])#print("zuida", l[-1], 'dierda',l[-2])
l.pop()
print(l)
print('shenghe', sum(l))

 

浅拷贝shallow copy
浅拷贝是指在复制过程中，只复制一层变量，不会复制深层变量绑定的对象的对象的复制过程

l2 = l1.copy()

 

例
l = [3.1, 3.2]
l1 = [1, 2, L]
l2 = l1.copy()
l2[2][0] = 3.14
print(l1)
print(l2)
回　
[1, 2, [3.14, 3.2]]
[1, 2, [3.14, 3.2]]

深拷贝deep copy

import copy #导入ｃｏｐｙ模块，以后再讲导入
l = [3.1, 3.2]
l1 = [1, 2, L]
l2 = copy.deepcopy(l1)
#深拷贝
l2[2][0] = 3.14
print(l1)
print(l2)

[1, 2, [3.1, 3.2]]
[1, 2, [3.14, 3.2]]

l = []
for l in a:
    a = int(input('请输入：'))
    if a < 0:
        break
    l +=[a]
    l.sort(reverse=True)
print(l)   

import copy#导入copy模块，
l = [3.1, 3.2]
l1 = [1, 2, l]
l2 = copy.deepcopy(l1)
l2[2][0] = 3.14
print(l1)
print(l2)

 

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

小结：
L1 = [1, 2, [3.1, 3.2]]
L2 = L1#不拷贝，创建一个变量同时绑定原对象
L3 = L1,copy()#浅拷贝等同于L3=L1[:]
import copy
L4 = copy. deepcopy(L1)

列表推导式list comprehension
列表推导式是用可迭代对象生成列表的表达式
作用：用简洁方法生成列表

语法：【表达式　for 变量　in 可迭代对象】
或【表达式　for 变量　in 可迭代对象　if 真值表达式】
说明：
for in 表达式的if 子句可以省略，省略后将所以生成的对象进行求值处理
例：生成１～９的平方的列表

L= [x ** 2 for x in range(1, 10)

l = []
for x in range(1, 10):
print(x**2)

 

1~100内的奇数列表
L=[x for x in range(1, 100, 2)

l = [x for x in range(1, 100) if x % 2 ==1]

去掉奇数的平方1~9的平方
L = [x**2 for x in fange(1,10) if x % 2 ==0]

列表推导式的嵌套：
语法：
表达式　ｆｏｒ　变量１　ｉｎ可迭代对象１　ｉｆ　真值表达式１
ｆｏｒ　变量２　ｉｎ　可迭代对象

[x + y for x in [10, 20, 30] for y in range(10)]
L = [x + y for x in "ABC" for y in "123"]

 

练习：
　１．已知有一个字符串
s = '100, 200, 300, 500, 800'
将其转化为整数的列表存于Ｌ列表中
L = [100, 200, 300, 500, 800]

2. 生成前４０个斐波那契数(Fibonacci)
1 1 2 3 5 8 13....
要求将这些数保存在列表中
打印这些数
３．有一些数存于列表中
L = [1, 3, 2, 1, 6, 4, 2,....98, 82]
将列表中出现的数字存入到另一个列表L2中
要求：重复出现多次的数字在L2列表中只保留一份（去重）

 

# １．已知有一个字符串
# s = '100, 200, 300, 500, 800'
# 将其转化为整数的列表存于Ｌ列表中
# L = [100, 200, 300, 500, 800]

# l = []
# s = '100,200,300,500,800'
# y = s.split(',')
# for x in l:
#     a = int(x)
#     l.append(a)
# print(l)

s = '100, 200, 300, 500, 800'
lst = s.split(',')
print(lst)
L = [int(x) for x in lst]
print(L)



# 2. 生成前４０个斐波那契数(Fibonacci)
# 1 1 2 3 5 8 13....
# 要求将这些数保存在列表中
# 打印这些数


# l = [1,1]
# s = 2
# f = int(input('请输入你想打印斐波拿契数的个数:'))
# a = 1
# b = 1
# while s < f:
#     c = a + b; b = c; a = b
#     l.append(c)  
#     s +=1
# print(l, len(l))

# 交换赋值
# while True:
#     n = int(input('请输入你想打印斐波拿契数的个数:'))
#     L = []
#     i = 1
#     a = 1
#     b = 1
#     c = 2
#     while i <= n:
#         c=a+b
#         a, b=b, a
#         b, c=c, b 
#         i +=1
#         L.append(c)
#     print(L,len(L))


# l = [1]
# fibs = 1
# n = 1
# i = 1
# while i < 40:
#     l.append(fibs)
#     fibs +=n#f(n+1)= f(n)+f(n-1)这里表示f(n)
#     n = fibs-n#f(n-1),就是把前一个值重新赋值给n
#     i +=1
# print(l)
# print(len(l))



# l = [1,1]#先创建一个有第一和第二个的的元素的列表
# for i in range(2,40):
#     n = l[i-1]+l[i-2]#利用斐波那契的公式f(n)=f(n-1)+f(n-2)
#     l.append(n)
# print(l,len(l))



# print('?'*100)
# def fibs(n):
#     if n ==1 or n ==2:
#         return 1
#     else:
#         return fibs(n-1)+fibs(n-2)
#     fib(3)#引用函数，该函数只有返回值，需要打印出来
# print(fibs(3))



# 迭代法
# print('?'*100)
# # fibs = int(input('请输入你想打印斐波拿契数的个数:'))
# def fibs(n):
#     terms = [0,1]
#     i = 2
#     while i <= n:
#         terms.append(terms(i-1)+terms(i-2))
#         i = i + 1
#     return terms(n)
# # print(terms)


# nterms = int(input('你需要几项？'))#获取用户输入数据
# n1 = 0#代表当前一个数
# n2 = 1#
# count = 2
# #判断输入的值是否合法
# if nterms <= 0:
#     print("请输入一个正整数：")
# elif nterms == 1:
#     print('斐波那契数列：')
#     print(n1)
# else:
#     print("斐波那契数列：")
#     print(n1, ",", n2, end=",")
#     while count<nterms:
#         nth = n1+n2
#         print(nth, end=",")
#         n1 = n2
#         n2 = nth
#         count +=1

a=0#代表当前一个数
b = 1#代表当前数
L = []#用来存放算出来的数
while len(L) < 40:
   #此处拿到斐波那契数，　然后放入列表中
    L .append(b)
    c = a+b#a, b = b, a+b   #序列赋值
    a = b
    b = c

print(L)


L = [1,1]
while len(L) <40:
    l.append(L[-1] + L[-2])
print(L)


# ３．有一些数存于列表中
# L = [1, 3, 2, 1, 6, 4, 2,....98, 82]
# 将列表中出现的数字存入到另一个列表L2中
# 要求：重复出现多次的数字在L2列表中只保留一份（去重）

L = [1, 3, 2, 1, 6, 4, 2, 42, 20, 46, 42, 20, 98, 82]
l = []
for s in L:
   if s not in l:
        l.append(s)
print (l)

l = [1,1]
s = 2
f = int(input('请输入你想打印斐波拿契数的个数:'))
a = 1
b = 1
while s < f:
    c = a + b; b = c; a = b
    l.append(c)  
    s +=1
print(l, len(l))

# 交换赋值
while True:
    n = int(input('请输入你想打印斐波拿契数的个数:'))
    L = []
    i = 1
    a = 1
    b = 1
    c = 2
    while i <= n:
        c=a+b
        a, b=b, a
        b, c=c, b 
        i +=1
        L.append(c)
    print(L,len(L))


l = [1]
fibs = 1
n = 1
i = 1
while i < 40:
    l.append(fibs)
    fibs +=n#f(n+1)= f(n)+f(n-1)这里表示f(n)
    n = fibs-n#f(n-1),就是把前一个值重新赋值给n
    i +=1
print(l)
print(len(l))



l = [1,1]#先创建一个有第一和第二个的的元素的列表
for i in range(2,40):
    n = l[i-1]+l[i-2]#利用斐波那契的公式f(n)=f(n-1)+f(n-2)
    l.append(n)
print(l,len(l))



print('?'*100)
def fibs(n):
    if n ==1 or n ==2:
        return 1
    else:
        return fibs(n-1)+fibs(n-2)
    fib(3)#引用函数，该函数只有返回值，需要打印出来
print(fibs(3))



# 迭代法
print('?'*100)
# fibs = int(input('请输入你想打印斐波拿契数的个数:'))
def fibs(n):
    terms = [0,1]
    i = 2
    while i <= n:
        terms.append(terms(i-1)+terms(i-2))
        i = i + 1
    return terms(n)
# print(terms)


nterms = int(input('你需要几项？'))#获取用户输入数据
n1 = 0#代表当前一个数
n2 = 1#
count = 2
#判断输入的值是否合法
if nterms <= 0:
    print("请输入一个正整数：")
elif nterms == 1:
    print('斐波那契数列：')
    print(n1)
else:
    print("斐波那契数列：")
    print(n1, ",", n2, end=",")
    while count<nterms:
        nth = n1+n2
        print(nth, end=",")
        n1 = n2
        n2 = nth
        count +=1

a=0#代表当前一个数
b = 1#代表当前数
L = []#用来存放算出来的数
while len(L) < 40:
    #此处拿到斐波那契数，　然后放入列表中
    L .append(b)
    c = a+b#a, b = b, a+b   #序列赋值
    a = b
    b = c

print(L)


L = [1,1]
while len(L) <40:
    l.append(L[-1] + L[-2])
print(L)