第三天学习

1.列表list

列表使用方括号括起来的[]，每个元素以逗号分隔，可以储存不同的数据类型数据。

是有序的可重复的可变类型

(1)基本操作

(1)创建

创建空列表 list1=[] list2=list() print(type(list1),type(list2)) 创建多元素列表 list1=[1,98,'dine','sr',['I','learnig','python']] print(list1,type(list1)) 强转 str1='sfsfs' list1=list(str1) print(list1,type(list1))

(2)拼接

list1=['i'] list2=['love','python'] print(list1+list2)#将list1和list2拼接在一起

(3)重复

list1=['i'] print(list1*3)#在一个列表将里面的元素重复三次

(4)索引(偏移)，切片

list1=['python','world','i','and','you','love','earth'] print(len(list1))#求长度 print(list1[0],list1[-7])#取第一个，以及从右往左第7位 print(list1[:5])#从0取到第4位 print(list1[::-1])#倒序 print(list1[6][1])#取下标为6的元素的下标为1的值

(2)常见操作

(1)增

list1=[2,'gg',52] list2=['city','number','over'] list1.append(list2) #append将list2列表直接加到list1的最后一个元素 print(list1) list1.extend(list2) #extend把list2的元素依次加到list1末尾 print(list1) list1.insert(0,list2) #insert将list2列表按索引加到list1的指定位置，list1原位置往后移 print(list1)

(2)删

list1=['1',1,'2',2,3,3] list1.pop(2) #pop不给索引，默认删除最后一个元素，否则删除索引对应的元素，而被删除的元素进入pop的返回值 print(list1) list1=['1',1,'2',2,3,3] list1.remove(3) #remove是根据输入的元素来删除列表中的第一个该元素(不是按索引删)，没有返回值 print(list1) list1=['1',1,'2',2,3,3] del list1[2] #del是根据索引删除索引对应的元素 #若是del list1，则直接删除整个列表，这个变量就消失了，相当于未定义过 print(list1) list1=['1',1,'2',2,3,3] list1.clear() #清除列表，但不像del，而是会保留一个空列表 print(list1)

(3)改

list1=['1',1,'2',2,3,3] list1[-2]='3' #直接在list1对应位置进行修改 print(list1) list1[:2]=['0',0,1] #也可以切片出来同时改许多元素 print(list1)

(4)查

利用索引查或者index

list1=['1',1,'2',2,3,3] print(list1.index(2))#按index里的值找到对应下标

(3)遍历

(1)元素遍历

list1=['a','b','c'] for i in list1: print(i)

(2)索引遍历

list1=['a','b','c'] for i in range(len(list1)): print(list1[i])

(3)枚举遍历

enumerate()，对于一个可迭代的/可遍历的对象(如列表，元素等)，将其组成一个索引序列，利用它，我们可以同时获得索引和值

list1=['a','b','c'] for i in enumerate(list1): #enumerate(list1,index),取出list1里的索引和值，加上输入index，变成元组，不填index默认为0 print(i)

(4)常用函数

计数count() list1=[1,1,1,1,1,1,1,1,1,1,1,11,1,1] print(list1.count(1))#查找该元素在列表出现了几次 反转reverse() list1=['a','b','c','d'] list1.reverse()#倒序 print(list1) 排序sort() list1=['a','b','c','d','o','a'] list1.sort()#按ASCII码大小排序，默认是sort(reverse=False)是正序,搞成True,即可逆序 print(list1) max,min list1=['a','b','c'] print(max(list1),min(list1))#按ASCII码大小取大小

练习

1.input()函数实现往空列表中添加元素，当输入"q"的时候，结束输入，并返回列表。

list1=[] while 1: i=input('请输入元素,输入q退出:') if i=='q': print(list1) break else: list1.append(i)

2.随机生成30个0-10的随机整数，并统计每个数出现的次数，返回的结果形式为[[0, 3], [1, 4], … , [10, 5]]

import random list2=[] list3=[] for i in range(30): list2.append(random.randint(0,10)) for k in range(11): list3.append(k,list2.count(k)) print(list3)

(5)赋值与深浅拷贝

赋值

赋值是对对象的引用

la=[1,2,3,4,5,'a',['b1','b2']] lb=la print(la,lb)#lb和la值一样 print(id(la),id(lb))#指向的地址也一样 la[5]='sd' print(la,lb)#改变了la里的一个元素，lb也一起变了，因为lb是对la的引用，指向同一片区域。 深浅引用

深浅拷贝会创建新对象，内容是**原对象**的引用

浅拷贝的三种实现:

(1)切片

(2)工厂函数list()

(3)copy()

la=[1,2,3,4,5,'a',['b1','b2']] lb=la[0:len(la)] #或者lb=list(la) #也或者lb=la.copy() print(la,lb) print(id(la),id(lb))#id不同，说明是指向两个不同的区域 la[5]='sd' print(la,lb)#修改了la，而lb没有改变 print(id(la[6]),id(lb[6]))#但是这些拷贝，list里list的id是一样，指向同一片区域 la[6][0]='sd' print(la,lb)#lb也随着改变,因为浅拷贝只拷贝了最外面的一层

深拷贝

import copy la=[1,2,3,4,5,'a',['b1','b2']] lb=copy.deepcopy(la) print(la,lb) print(id(la[6]),id(lb[6]))#id不同了 la[6][0]='sd' print(la,lb)#lb没变

总结：

浅拷贝相当于我们只拷贝了一层，修改外层元素，会修改引用，让它们指向另一个位置;但是嵌套的列表地址没有变，修改嵌套列表的元素，指向的还是同一个位置。

深拷贝是拷贝对象的所有元素，包括多层嵌套的元素。是开辟一个新的内存储空间，和原数据源没有关联了。

(6)列表解析式

list1=[] for x in range(10): list1.append(x) print(list1) #上面运用操作依次将0-9添加到列表中，虽然正确。 print([x for x in range(10)])#但使用这行代码效果是一样，十分简洁 #基本格式 #[表达式 for 迭代元素 in 可迭代对象] #deemo: name=['Tom','Jack','Lucy'] subject=['Python','Java','C','C++'] list1=[] for i in name: for j in subject: list1.append([i,j]) print(list1) print([[i,j] for i in name for j in subject])#两个结果一样，表达式非常方便

实现原理：

迭代[可迭代对象]中的每一个元素每迭代依次的结果赋值给对应的迭代元素，在通过表达式运算得到一个新的值最后将所有通过表达式计算的值以一个列表的形势返回

类似于三目运算符

y = 8 x = y + 1 if y > 10 else y - 6 #x=[表达式1]if[条件]else[表达式2] ##满足if后面的条件，即为x=表达式1，否则x=表达式2 print(x) # x为2而不为9

2.元祖tuple

符号使用()，每个元素以逗号分隔，可以储存不同的数据类型数据。

有序可重复不可更改(修改元组里的列表除外)

(1)基本操作

(1)创建

创建空元组 tuple1=tuple() tuple2=() print(type(tuple2)) 创建单元素元组 tuple1=('a',) print(tuple1)#必须在括号后加,不然会成为str类型 创建多元素元组 tuple1=('',123) print(type(tuple1))#多元素后不需要再在末尾加,

(2)拼接

tuple1=('a',123) tuple2=('sfsf',) print(tuple1+tuple2,type(tuple1+tuple2))#操作跟列表类似，不再做过多描述

(3)重复

tuple1=('a',123) tuple2=('sfsf',) print(tuple1*3,type(tuple1*3))#操作跟列表类似，不再做过多描述

(4)索引(偏移)，切片

tuple1=('a',123,'b',456,'c',789,'d',[1,2,3]) print(len(tuple1)) print(tuple1[0],tuple1[-2]) print(tuple1[:5]) print(tuple1[::-1]) print(tuple1[7][1])#操作跟列表类似，不再做过多描述

(5)查

因为其特性，内部无列表时基本上无法对内部元素进行增删改，不过可以改变整个元组

使用index或者切片来查看

tuple1=('a',123,'b',456,'c',789,'d',[1,2,3]) print(tuple1.index('b')) #按值找下标。注意，里面的列表是作为一个元素，必须一样才能找到，不能对列表内部单个元素查找 #如一定要找，要定位到元组中的列表tuple1[-1].index(2)，其中tuple1[-1]类型是列表

(2)遍历

大致操作等同于列表，不再做过多解释.

(1)元素遍历

tuple1=('a','b','c') for i in tuple1: print(i)

(2)索引遍历

tuple1=('a','b','c') for i in range(len(tuple1)): print(tuple1[i])

(3)枚举遍历

tuple1=('a','b','c') for i in enumerate(tuple1): print(i)

(3)嵌套

列表里有很多地方涉及了，但没有讲，在这里补充一下

tuple1=(('a','b','c'),('d',('e','f'))) print(tuple1[1][1][0])#总之就是有里面一层套一层，找到里层的元素，要一层层进入找。

补充：

print >>> help(print) >>> Help on built-in function print in module builtins: print(...) print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False) Prints the values to a stream, or to sys.stdout by default. Optional keyword arguments: file: a file-like object (stream); defaults to the current sys.stdout. sep: string inserted between values, default a space. end: string appended after the last value, default a newline. flush: whether to forcibly flush the stream.

语法格式：

print(value1, value2, ..., valuen, sep=' ', end='\n', file=sys.stdout, flush=False)

格式化字符串

1.%号格式化

格式描述%d整型%s字符串%c字符及ASCII码%o无符号八进制整数%x/%X无符号十六进制整数%e/%E科学计数法，是浮点型%f浮点型%%传递一个%,第一个%视为转义字符

2.format格式化

(1)位置映射

print("name：{},age:{},".format('Tom',18)

(2)关键字映射

print("name：{},age:{},{address}".format('Tom',18,address='Hangzhou'))

(3)元素访问

print("第一个元素是:{0[0]}，第二个元素是:{0[1]},第三个元素是:{1[0]}," "第四个元素是：{1[1]}，第二个元素是:{0[2]}".format(('www.','google','com'),("baidu.","com")))