列表及元组基础知识

print的补充与格式化字符串

print()在help后返回的帮助文件

>>> help(print)
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    # ...表示 其他传入值 value2、value3...
    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.
     #将内容打印的地方默认为当前窗口 可以在txt等其他允许的文件打印 
    sep:   string inserted between values, default a space.
    #set表示value之间的间隔输入的元素，默认为空格
    >>> print (1,2,3,4,5,sep='!')
    >>>1!2!3!4!5
    end:   string appended after the last value, default a newline.
    >>> for i in range(4):
	      print(i,end='#')
    >>> 0#1#2#3#    
    #end表示在打印完所有value之后再追加打印一个元素，默认为换行(\n)
    flush: whether to forcibly flush the stream.
    #是否刷新数据流 Ture后即为及时显示（输入1个字符即显示)

字符串的格式

• %号格式化

name='Bob'
age=13
print('His name is %s,his age is %d.'%(name,age))
print('His name is ',name,',his age is ',age,',',sep='')
print('His name is '+name+',his age is '+str(age)+',')
结果
His name is Bob,his age is 13.
His name is Bob,his age is 13.
His name is Bob,his age is 13.

• 占位符

格式	描述
%d	有符号的整数
%s	字符串
%c	字符及ASCII码
%o	无符号八进制整数
%x(X)	无符号十六进制整数
%e(E)	浮点数，科学计数(10的多少次幂)
%f	浮点数

注：如当需要使用%打印’100%'时

print('%d%%'%100) #此时'%%’表示一个%，前面的%表示转译字符，用\会报错
100%

format格式化

1.位置映射

print('name:{},age:{}'.format('tom',18))
结果
name:tom,age:18

2.关键字映射

print('name:{},age:{},adress:{address}'.format('tom',18,address='China'))
结果
name:tom,age:18,adress:China #注作为关键字的内容必须放在format最后面

3.对应元素映射

print('第一个:{0[0]},第二个:{0[1]},第三个:{0[2]}'.format(('aaa','bbb','ccc')))
结果
第一个:aaa,第二个:bbb,第三个:ccc
print('第一个:{0[0]},第二个:{1[1]},第三个:{0[2]}'.format(('aaa','bbb','ccc'),('111','222')))
结果
第一个:aaa,第二个:222,第三个:ccc

列表

1.格式：

​ 用[ ]括起来的一组元素，元素之间以’,'间隔

​ 可以存储多种数据类型

2.特点：

​ 是有序的，元素可以重复，是一个可变类型

3.创建：

• 创建空列表:

  l=[ ]

• 创建多元素列表：

  l=[1,1,2,3,‘aa’,{ },(1,2),[‘a’,‘b’]]

• 类型强转:

  str1='hello'
  li=list(str1)
  print(li,type(li))
  结果
  ['h', 'e', 'l', 'l', 'o'] <class 'list'>

4.简单操作

#####拼接#####
li1=[1,2,3]
li2=[7,7,7]
print(li1+li2)
结果：
>[1, 2, 3, 7, 7, 7]
#####重复#####
li1=[1,2,3]
print(li1*3)
结果
[1, 2, 3, 1, 2, 3, 1, 2, 3]
#####切片#####
>>> li=['a','b','c','d','e','f','g','h']
>>> li[1:5:2]  #取指定范围指定步长
['b', 'd']
>>> li[::-1]   #取反
['h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']

5.常见操作

• 增删改查

  增：append()、extend()、insert()

>>> li1=['name','age']
>>> li2=['city','college']
>>> li1.append(li2) 
>>> li1
['name', 'age', ['city', 'college']]
>>> li1.extend(li2)  #在一个列表(li1)末尾导入另一个列表(li2) 用li1=li1+li2效果相同
>>> li1
['name', 'age', ['city', 'college'], 'city', 'college']
>>> li1.insert(0,'country')	#在指定索引位置插入元素
>>> li1
['country', 'name', 'age', ['city', 'college'], 'city', 'college']  

​ 删：pop() 、clear()、remove()、del

>>> li=[0,1,2,3,4,5,6,7,8,9]
>>> li.pop()	#取出最后一个元素返回该值，并在原列表中删除该值
9
>>> li
[0, 1, 2, 3, 4, 5, 6, 7, 8]  #删除元素后的列表
>>> li.pop(1)     #取出指定索引位置的元素返回该值，并在原列表中删除该值
1
>>> li
[0, 2, 3, 4, 5, 6, 7, 8] #删除元素后的列表
>>> li.remove(2)   #从左开始删除第一个指定的元素（只删除一个）
>>> li
[0, 3, 4, 5, 6, 7, 8]  #删除元素后的列表
>>> li.clear()      #将列表所有元素清除，列表将变成一个空列表
>>> li
[]
>>> del li       #将列表整个删除，列表(li)将消失再调用该列表(li)会报错
>>> li
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    li
NameError: name 'li' is not defined

改：直接根据索引

li=[1,1,1,1,1,1]
>>> li[1]=2  #改指定索引位置的元素
>>> li
[1, 2, 1, 1, 1, 1]
>>> li[2:]=3,4,5,6  #改指定范围的元素
>>> li
[1, 2, 3, 4, 5, 6]
#注：索引不能超出列表自身范围，即不能通过索引来为列表添加新的元素

遍历：

#####元素遍历#####
>>> li[2:]=3,4,5,6
>>> li
[1, 2, 3, 4, 5, 6]
>>> li=['a','b','c']
>>> for i in li:
	print(i)	
a
b
c
#####索引遍历#####
>>> li=['a','b','c']
>>> for i in range(len(li)):
	print(li[i],end=' ')
    
a b c 
#####枚举遍历#####
enumerate()  #对于的迭代对象，将其组成一个索引序列，利用该序列，得到索引即对应值
li=['a','b','c']
>>> for i ,j in  enumerate(li):
	print(i,j)
	
0 a
1 b
2 c

• 计数：count(),查找某元素的次数

• 反转：reverse(),将整个列表反转

• 排序:sort(),将列表排序

  >>> li=[1,1,2,35,7,1]
  >>> li.count(1)   #统计元素(1)出现的次数
  3
  >>> li.reverse() #反转
  >>> li
  [1, 7, 35, 2, 1, 1]
  >>> li.sort()   #排序，升序（必须是同种数据类型）
  >>> li
  [1, 1, 1, 2, 7, 35]
  >>> li.sort(reverse=True)  #排序，降序（必须是同种数据类型）
  >>> li
  [35, 7, 2, 1, 1, 1]

6列表解析式(生成式)

格式：[表达式 for 迭代元素 in 可迭代对象 (其他条件)]

实现原理：

迭代[可迭代对象]中的每一个元素，每迭代一次的结果赋值给对应的迭代元素，再通过表达式的运算得到一个新的值，最后通过所有表达式计算的值(可以再通过其他条件筛选)以一个列表的形式返回。

li=[x for x in range(10)]
>>> li
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> li=[x for x in range(10) if x%2==0]
>>> li
[0, 2, 4, 6, 8]
>>> sr='今天是晴天'
>>> li=[ord(x) for x in sr]
>>> li
[20170, 22825, 26159, 26228, 22825]

赋值与拷贝

赋值：对对象的引用

>>> ls=[1,2,3,4]
>>> lf=ls
>>> print(id(ls),id(lf))
60164536 60164536

拷贝：浅拷贝与深拷贝

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

  三种实现方法：

  切片操作[:]

  工厂函数 list(li)

  copy模块内的copy函数

la=[1,2,3,'a']
#####切片操作[:]#####
lb=la[:]
print(id(la),id(lb))
print(la==lb)
print(la is lb)
结果
21644752 21645912
True
False
#####copy函数#####
import copy
lb=copy.copy(la)
print(id(la),id(lb))
print(la==lb)
print(la is lb)
结果
56305144 56241928
True
False
#####工厂函数#####
lb=list((la))
print(id(la),id(lb))
print(la==lb)
print(la is lb)
结果
21972432 23277360
True
False

• 深拷贝

import copy
la=[1,2,3,'a']
lb=copy.deepcopy(la)
print(id(la),id(lb))
print(la==lb)
print(la is lb)

浅拷贝与深拷贝的差别

• 浅拷贝相当于我们只拷贝了一层，修改外层元素，会修改引用，让它们指向另一个位置；修改嵌套列表的元素，列表地址没有发生变化，指向的还是同一个位置。
• 深拷贝拷贝对象的所有元素，包括多层嵌套的元素，因此是开辟了一个新的内存存储区，和数据源没有关系了

>>>import copy
>>>a = [1, 2, 3, 4, ['a', 'b', 'c']]
>>> b = a
>>> c = copy.copy(a)
>>> d = copy.deepcopy(a)
>>> id(a)
19276104
>>> id(b)
19276104
>>> id(c)
19113304
>>> id(d)
19286976
>>> a.append(5)    #操作1对一层数据操作
>>> a[4].append('hello')   #操作2对深层数据操作
>>> a
[1, 2, 0, 4, ['a', 'b', 'c', 'hello'], 5]
>>> b
[1, 2, 0, 4, ['a', 'b', 'c', 'hello'], 5]
>>> c
[1, 2, 3, 4, ['a', 'b', 'c', 'hello']]
>>> d
[1, 2, 3, 4, ['a', 'b', 'c']]

其他

三目运算符

a=1
b=1
a+=2 if a<2 else b-1
print(a,b)
3 1

列表生成式

(与列表.6相似)

a=[1,2,3]
b=['a','b','c']
li=[[i,j] for i in a for j in b]
print(li)
结果
[[1, 'a'], [1, 'b'], [1, 'c'], [2, 'a'], [2, 'b'], [2, 'c'], [3, 'a'], [3, 'b'], [3, 'c']]

元组

特点

有序、元素可以重复，不可更改对象。 符号: ( )

创建方法

• 空元组的创建

• 单元素元祖的创建

>>> tu=()
>>> type(tu)
<class 'tuple'>
>>> tu=('a')
>>> type(tu)
<class 'str'>
>>> type(tu)
<class 'str'>
>>> tu=('a',)  #单元素元元组创建时必须再加一个','不然会默认是字符串
>>> type(tu)
<class 'tuple'>

• 多元素元祖的创建(可以包含多种数据类型)

  tu=(1,2,3)  #创建单元素元组
  tu2=(4,5,6)
  print(tu+tu2)  #元组的拼接
  print(tu*3)    #元组的重复
  print(tu[1:]，tu[0])  #元组的切片及索引
  结果
  (1, 2, 3, 4, 5, 6)
  (1, 2, 3, 1, 2, 3, 1, 2, 3)
  (2, 3) 1

查

切片查、索引查、index（）

>>> tp=(1,2,3,4,5,6,'a','b')
  >>> tp[2:]  #切片查
  (3, 4, 5, 6, 'a', 'b')
  >>> tp[4]   #索引查
  5
  >>> tp.index('a')  
  6
  >>> del tp   #删除整个列表
  >>> tp
  Traceback (most recent call last):
    File "<pyshell#22>", line 1, in <module>
      tp
  NameError: name 'tp' is not defined

注：由于元组为不可变类型，所以不能进行增、删元素的操作。但是可以将整个元组删除del。

>>> tp=(1,2,3,4,5,6,'a','b')
>>> del tp   #删除整个列表
>>> tp
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    tp
NameError: name 'tp' is not defined
tu=(1,2,3)
print(id(tu))
del tu
tu=(1,2,3)
print(id(tu))   ###垃圾回收机制，其他类型有相似效果
结果
23988864
23988864

遍历

元素遍历
索引遍历
枚举遍历 ennumerate

tup=(1,2,3,4,5,'a')
for i in tup:
    print(i,end=' ')
print()
for i in range(len(tup)):
    print(tup[i],end=' ')
print()
for i,j in enumerate(tup):
    print(i,j,'|',end=' ')
结果
1 2 3 4 5 a 
1 2 3 4 5 a 
0 1 | 1 2 | 2 3 | 3 4 | 4 5 | 5 a |