[python全栈]02.python基础[part I](6)

目录

1. in 与 not in、索引
2. 列表索引赋值
3. 列表切片
4. del语句、常用序列函数
5. 列表方法
6. 字符串文本解析(S.split/S.join)
7. 深拷贝、浅拷贝
8. 列表推导式

1. in 与 not in、索引

	列表的 in / not in
		1.判断一个数据元素是否存在于容器(列表)内,如果存在返回True,否则返回False
		2.not in 的返回值与 in 运算符相反
		eg:
			x = [1,'Two',3.14,'四']
			1 in x			#True
			2 in x			#False
			3 not in x		#True
			'四' not in x	#False 
	索引 index / 切片 slice
		列表的索引语句:
			列表[整数表达式]
		用法:
			列表的索引取值与字符串的索引取值规则完全相同
			列表的索引分为正向索引和反向索引

2. 列表索引赋值

列表式是可变的序列,可以通过索引赋值改变列表中的元素
!!字符串不是可变序列,创建后不可修改
	语法:	
		列表[索引] = 表达式
	eg:
		x = [1,2,3, 4]
		x[2] = 3.14
		# x >>>[1, 2, 3.14, 4]

3. 列表切片

列表的切片:
	列表[start:end]
	列表[start:end:step]
	列表的切片取值返回一个列表,规则等同于字符串的切片规制
eg:
	x = list(range(9))
	y = x[1:9:2] #y>>>[1,3,5,7]
列表切片的赋值操作 :
	列表[切片] = 可迭代对象	#可迭代对象!!!
	说明 :
		切片赋值的赋值运算符右侧必须是一个可迭代对象
	eg :
		L = [2,3,4]
		L[0:1] = [1.1 ,2.2]
		print(L)	#>>>[1.1, 2.2, 3, 4]
		
		L = [2, 3, 4]
		L[:] = [7, 8]
		print(L)	#>>>[7, 8]
		
		L = [2, 3, 4]
		L[1:2] = [3.1,3.2,3.3]
		print(L)	#>>>[2, 3.1, 3.2, 3.3, 4]
	特殊切片赋值:
		L = [2, 3, 4]
		L[1:1] = [2.1, 2.2]		#L[1:1] = []
		print(L)				#>>>[2, 2.1, 2.2, 3, 4]
		#前插
		L = [2, 3, 4]
		L[0:0] = [0, 1]
		print(L)				#>>>[0, 1, 2, 3, 4]
		#后插
		L = [2, 3, 4]
		L[3:3] = [5, 6]
		print(L)				#>>>[2, 3, 4, 5, 6]
		#删除
		L = [2, 3, 4]
		L[1:2] = []
		print(L)				#>>>[2, 4]
		#步长不为1的切片(多个切片)
		L = [1,2,3,4,5,6,7,8]
		L[1: :2] = [2.2, 4.4, 6.6, 8.8]	
		print(L)	#>>>[1, 2.2, 3, 4.4, 5, 6.6, 7, 8.8]
		#步长不为1时，切片总数要等于要赋值提供元素数,且会依次替换,不等于时报错

4. del语句、常用序列函数

del 语句用于删除列表元素
	语法:
		del 列表[索引]
		del 列表[切片]
	eg:
		L = [1, 2, 3, 4, 5, 6]
		del L[0]	#L = [2,3,4,5,6]
		del L[-1] 	#L = [2,3,4,5]
		del L[::2]	#L = [3,5]
python 3 中常用的序列函数:
	len(x)	返回序列的长度(元素个数)
	max(x)	返回序列的最大值元素
	min(x)	返回序列中最小值元素
	sum(x)	返回序列中所有元素的和(元素必须是数值类型)
	any(x)	真值测试,如果列表中一个值为True则返回True,反之返回False
	all(x)	真值测试,如果列表中所有值为真值,返回True,只要有一个为假,则返回False

eg :

#将列表L = [1,2,3,4,5,6]反转(前后对调),然后删除最后一个元素
L = [1,2,3,4,5,6]
c = 0
n = int(len(L)) - 1
for i in range(n) :
    c = L[i]
    L[i] = L[n - i]
    L[n- i] = c
    i+= 1
    if i > n//2 :
        break
#切片方法反转:
#L[:] = L[::-1]
del L[-1]
print(L)

#让用户循环输入一些整数，当输入-1时结束输入
#将这些整数存于列表L中，求:
#    1.输入了几个数 2.打印输入数的最大数 3.最小数 4. 平均值
L = []
while True :
    a = int(input('请输入一个整数,输入-1结束输入: '))
    if a != -1 :
        L[0:0] = [a]
    else :
        break
print('您共输入了 ' ,len(L) ,' 个数')
print('最大数为' ,max(L) )
print('最小数为' ,min(L) )
print('平均数为' ,sum(L)/len(L))

5. 列表方法
python 3 中常用列表方法 , 见:help(list)

方法	作用
L.index(v[,begin,[,end]])	返回对应元素的索引下标,不存在时触发ValueError. eg:L=[1,2,3,2,1]; L.index(2,2,4)] #>>>3
L.insert(index,obj)	将某个元素插入到列表中index前面的位置. eg:L= [2,3] ; L.insert(0,4) #>>>L = [4, 2, 3]
L.count(x)	返回列表中该元素的总个数 eg:L = [1,3,2,4,2,3,1,4,2] ; L.count(3) #>>>2
L.remove(x)	从列表中删除第一次出现在列表中的值. eg:L = [1, 3, 2, 4, 2, 3, 1, 4, 2] ; L.remove(1) #>>>L = [3, 2, 4, 2, 3, 1, 4, 2]
L.copy()	复制此列表(只复制一层,不会复制深层对象) eg: L1 = [1,2,3];L2 = L1.copy();L2.remove(1) #>>>L2 = [2,3] ; L1 = [1,2,3]
L.append(x)	向列表中追加单个元素 eg:L = [1,2,3];L.append(7);L.append([1,2,3]) #>>>[1, 2, 3, 7, [1, 2, 3]]
L.extend(list)	向列表中追加另一个列表 eg: L = [1,2,3];L.extend([1,2,3]) #>>>L = [1, 2, 3, 1, 2, 3]
L.clear()	清空列表,相当于 L[:] = [] eg:L1 = [1,2,3];L1.clear() #>>>L1 = []
L.sort(reverse = False)	将列表中的元素进行排序,默认顺序从小到大 #reverse = True 从大到小 eg:L= [3,1,4,2];L.sort() #>>>L=[1,2,3,4]
L.reverse()	列表反转,用来改变列表的先后顺序
L.pop([index])	删除索引对应的元素,如果不加索引,默认删除最后元素,同时返回该元素 eg:L=[1,2,3];a = L.pop(1) #>>>L =[1,3];a=2

6. 字符串文本解析(S.split/S.join)

字符串文本解析方法 split 和 join
	S.split(sep = None)  :
		将字符串使用sep作为分隔符分隔字符串 S,
		当不给定参数时,用空白字符作为分隔符进行分割
	S.join(iterable) :
		用可迭代对象中的字符串,返回一个中间用S进行分隔的字符串
eg:
	s = 'Beijing is captial'
	L = s.split(' ')	#L = ['Beijing','is','captial']
	s = '\\'	
	L = ['c:','Program files','python3']
	s2 = s.join(L)	#s2 = 'c:\\Program files\\python'

7. 深拷贝、浅拷贝

浅拷贝 shallow copy 和 深拷贝 deep copy 
浅拷贝 shallow copy :
	是指在复制过程中只复制一层变量,不会复制深层变量绑定的对象的复制过程
	L = [3.1, 3.2]
  	L1 = [1, 2, L]
  	L2 = L1.copy()  # 等同于 L1[:]  浅拷贝
	print(L1)  # [1, 2, [3.1, 3.2]]
  	print(L2)  # [1, 2, [3.1, 3.2]]
  	L2[2][0] = 3.14
  	print(L1)  # [1, 2, [3.14, 3.2]]
  	print(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) # 深拷贝
  	print(L1)  # [1, 2, [3.1, 3.2]]
  	print(L2)  # [1, 2, [3.1, 3.2]]
  	L2[2][0] = 3.14
  	print(L1)  # [1, 2, [3.1, 3.2]]
  	print(L2)  # [1, 2, [3.14, 3.2]]
	注:深拷贝通常只对可变对象进行复制，不可变对象通常不变

8. 列表推导式

列表推导式  list comprehension :
	列表推导式使用可迭代对象依次生成带有多个元素的列表的表达式
	作用:
		用简易方法生成列表
	语法:
		[表达式 for 变量 in 可迭代对象]
		[表达式 for 变量 in 可迭代对象 if 真值表达式]
	eg :
		#生成一个数值为1~9的平方的列表
		L = [x*x for x in range(1,10)]
		#>>>L = [1, 4, 9, 16, 25, 36, 49, 64, 81]
列表推导式的嵌套 :
	语法:
		[ 表达式1
			for 变量1 in可迭代对象1 if 真值表达式1
				for 变量2 in 可迭代对象2 if 真值表达式2
					... ]
	eg :
		L1 = [2,3,5]
		L2 = [7,11,13]
		#将L1中的全部元素与L2中的全部元素依次相乘后放到列表L3中
		L3 = [x*y for x in L1 for y in L2]
		print(L3)
		#>>>L3 = [14, 22, 26, 21, 33, 39, 35, 55, 65]

练习 :

'''
用字符串s='ABC'和s2='123'生成如下列表
['A1','A2','A3','B1','B2','B3','C1','C2','C3']
'''

s='ABC'
s2 = '123'
L = [i+j for i in s for j in s2]
print(L)

'''
生成前40个斐波那契数列(Fibonacci)
1 1 2 3 5 8 13 ......
(自第三个起，之后所有数为前两个数之和)
要求,将这些数保存在列表中,最后打印列表中的数
提示:用循环、列表和变量组合可以实现
'''
#方法一
L = [1,1]
for i in range(2,40) :
    L.append(L[i-1]+L[i-2])
#while len(L) < 40 :
#	L.append(L[-1]+L[-2])
print(L)
#方法二
a = 0
b = 1
L = []
while len(L) < 40 :
	#在此处生成一个新的数,加到列表L中
	a , b = b, a+b	#序列赋值(a,b = 1,1+0 ; a = 1; b = 1)
	L.append(a)
print(L)

'''
去重算法：
有一些数存在于列表L中,如
L=[1,3,2,1,6,4,2,98,82]
将列表L中的数存入于另一个列表L2中
(要求重复出现多次的数字只在L2列表中保留一份)
'''
#方法一
L = [1,1,3,2,1,6,4,2,98,2,3,1,82]
L2 = []
for i in L :
    if i not in L2 :
        L2.append(i)
print(L2)
#方法二
L = [1,1,3,2,1,6,4,2,98,2,3,1,82]
L2 = L.copy()
i = 0
while i < len(L2) :
    if L2.count(L2[i]) > 1 :
        del L2[i]
        continue
    i +=1
print(L2)