0718列表、元组

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(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

等价于

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

demo:

>>> a,b,c,*d = 1,2,3,4,5,6
>>> a
1
>>> b
2
>>> c
3
>>> d
[4, 5, 6]
>>> print(a,b,c,d)
1 2 3 [4, 5, 6]
>>> print(a,b,c,d,sep="#")
1#2#3#[4, 5, 6]
>>> for i in range(5):
...     print(i)
...
0
1
2
3
4
>>> for i in range(5):
...     print(i,end=" ")
...
0 1 2 3 4 >>>
>>> for i in range(5):
...     print(i,end="#")
...
0#1#2#3#4#>>>

格式化字符串

%号格式化

占位符

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

%格式化字符串 用%匹配参数，注意个数一一对应

print("%d%%" % 100)      #  %% 转译出%
100%

format格式化

(1)位置映射

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

Tom:18
name:Tom,age:18

(2)关键字映射

print("{address}，name:{},age:{}".format("Tom",18,address = '后面关键字必须在最后'))

后面关键字必须在最后，name:Tom,age:18

(3)元素访问

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

列表

列表由方括号括起来的[],每个元素以逗号分隔；

可以储存不同的数据类型数据

• 特点
  • 有序
  • 可重复
  • 可变类型

1.创建空列表

li = []
print(type(li))

2.创建多元素列表

li = [1,2,3,"abc",[4,5,6],['A']]

3.强转

sr = "abc"
li = list(sr)
print(li)

['a', 'b', 'c']

4.拼接

li1 = ["I"]
li2 = ["Love"]
li3 = ["Python"]

print(li1+li2+li3)

['I', 'Love', 'Python']

5.重复

li = ["啊啊"]
print(li * 3)

['啊啊', '啊啊', '啊啊']

6.索引(偏移) [] 切片[:] [::]

li = ["z","u","c","c","zucc",["very","nice"]]
print(len(li))
print(li[0],li[-4])
print(li[:3])
print(li[::-1])
print(li[4][3])
print(li[5][1])

6
z c
['z', 'u', 'c']
[['very', 'nice'], 'zucc', 'c', 'c', 'u', 'z']
c
nice

7.增删改查

7.1增

• append()
• extend()
• insert()

li = [1,2]
print(id(li))
li1 = ['z','u','c','c']
li.append(li1)
print(li,id(li))

1766771992584
[1, 2, ['z', 'u', 'c', 'c']] 1766771992584

li = [1,2]
li1 = ['z','u','c','c']
li.extend(li1)
print(li)

[1, 2, 'z', 'u', 'c', 'c']

li = [1,2]
li1 = ['z','u','c','c']
li.insert(0,li1)
print(li)

[['z', 'u', 'c', 'c'], 1, 2]

7.2改

li = ['z','u','c','c',['i','love'],'you']
li[1] = 'z'
li[4:6] = [['very'],'nice']
print(li)

['z', 'z', 'c', 'c', ['very'], 'nice']

7.3删除

• pop() ，返回被删除的元素

  • 如果不指定索引，默认删除最后一个元素

  • 删除指定索引对应元素

li = ['z','u','c','c',['i','love'],'you']
print(li.pop())
print(li)
you
['z', 'u', 'c', 'c', ['i', 'love']]

li = ['z','u','c','c',['i','love'],'you']
print(li.pop(1))
print(li)
u
['z', 'c', 'c', ['i', 'love'], 'you'] 

• remove()，移除第一次遇到的指定元素

li = ['z','u','c','c',['i','love'],'you']
li.remove('c')
print(li)

['z', 'u', 'c', ['i', 'love'], 'you']

• del

li = ['z','u','c','c',['i','love'],'you']
del li[2:5]
print(li)

['z', 'u', 'you']
#若 del li    则name 'li' is not defined

• clear()，清空

li = ['z','u','c','c',['i','love'],'you']
li.clear()
print(li)

[]

7.4遍历

• 索引，切片
• 遍历
  • 元素遍历
  • 索引遍历
  • 枚举遍历
    • enumerate()， 对于一个可迭代的/可便利的对象（如列表，字符串），将其组成一个索引序列，利用它，我们可以同时获得索引和值

li = ['z','u','c','c',['i','love'],'you']
for i in li:
    print(i)

    
z
u
c
c
['i', 'love']
you

li = ['z','u','c','c',['i','love'],'you']
for i in range(len(li)):
    print(li[i])
    
z
u
c
c
['i', 'love']
you

li = ['z','u','c','c',['i','love'],'you']
for index,value in enumerate(li):
    print(index,value)

0 z
1 u
2 c
3 c
4 ['i', 'love']
5 you

8.堆和栈

9.其他操作

9.1计数，count(),查找元素出现的次数

9.2反转，reverse()

li = ['z','u','c','c',['i','love'],'you']
print(li)
li.reverse()
print(li)

['z', 'u', 'c', 'c', ['i', 'love'], 'you']
['you', ['i', 'love'], 'c', 'c', 'u', 'z']

9.3排序，sort(),列表内需要是同一种数据类型

li = [['i','love'],['a'],['z']]
print(li)
li.sort()
print(li)

[['i', 'love'], ['a'], ['z']]
[['a'], ['i', 'love'], ['z']]

#输出两个列表的交集

li1 = ['a','b','c','d']
li2 = ['c','d','e','f']
li = []
for i in li1:
    if i in li2:
        li.append(i)
print(li)

['c', 'd']

9.4赋值与拷贝

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

    • 切片[:]

    • 工厂函数list (li)

    • copy模块内的copy函数

la = [1,2,3,4,5,6,7,'a',['b1','b2']]
lb = la
lb2 = la[:]
print(id(la))
print(id(lb2))

import copy
lb_copy = copy.copy(la)
print(id(la))
print(id(lb_copy))
la.append('text')
print(la)
print(lb_copy)
la[8][1] = 'c'
print(la)
print(lb)

2152543679240
2152543680904
2152543679240
2152543680648
[1, 2, 3, 4, 5, 6, 7, 'a', ['b1', 'b2'], 'text']
[1, 2, 3, 4, 5, 6, 7, 'a', ['b1', 'b2']]
[1, 2, 3, 4, 5, 6, 7, 'a', ['b1', 'c'], 'text']
[1, 2, 3, 4, 5, 6, 7, 'a', ['b1', 'c'], 'text']

浅拷贝相当于我们只拷贝了一层，修改外层元素，会修改引用，让她们指向另一个位置；修改嵌套列表的元素，列表地址没有发生变化，指向还是一个位置。所以修改内部嵌套内容会同时变化。

• 深浅拷贝

  • 深拷贝

import copy
la = [1,2,3,4,5,6,7,'a',['b1','b2']]
lb_deepcopy = copy.deepcopy(la)
print(la,id(la))
print(lb_deepcopy,id(lb_deepcopy))
la[8][1]= 'c'
print(la)
print(lb_deepcopy)

[1, 2, 3, 4, 5, 6, 7, 'a', ['b1', 'b2']] 2706895534472
[1, 2, 3, 4, 5, 6, 7, 'a', ['b1', 'b2']] 2706895534280
[1, 2, 3, 4, 5, 6, 7, 'a', ['b1', 'c']]
[1, 2, 3, 4, 5, 6, 7, 'a', ['b1', 'b2']]

深拷贝拷贝所有对象，包括嵌套元素，创建一个全新的地址，所以修改原内部嵌套内容不会发生连变

列表生成式

用来生成列表的特定的语法形式

格式：

[表达式 for 迭代元素 in 可迭代对象]

实现原理

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

print([x for x in range(10) if x%2==0])
[0, 2, 4, 6, 8]

sr = '城市学院'
print([ord(x) for x in sr])
[22478, 24066, 23398, 38498]

li = [22478, 24066, 23398, 38498]
print([chr(x) for x in li])
['城', '市', '学', '院']

带过滤功能格式：

[exp for iter_val in iter if if_condtion]

相当于：

li = []
for iter_val in iter:
    if if_condtion
        li.append(iter_val)
print(li)

name = ["1","2","3"]
subject = ["4","5","6"]
li = []
for i in name:
    for j in subject:
        li.append([i,j])
print(li)


print([[i,j] for i in name for j in subject])

[['1', '4'], ['1', '5'], ['1', '6'], ['2', '4'], ['2', '5'], ['2', '6'], ['3', '4'], ['3', '5'], ['3', '6']]
[['1', '4'], ['1', '5'], ['1', '6'], ['2', '4'], ['2', '5'], ['2', '6'], ['3', '4'], ['3', '5'], ['3', '6']]

元组

• 有序
• 可重复
• 不可更改

符号使用 ()

定义：由小括号括起来的(),每个元素以逗号分隔；

1.创建空元组

tp = ()
print(type(tp))

2.创建单元素元组

单元素之后必须加逗号！

tp = ('123',)
print(type(tp))

<class 'tuple'>

3.创建多元素元组

4.拼接

tp = ('123','a','b','c','d')
tp1 = ('456',)
print(tp+tp1)

('123', 'a', 'b', 'c', 'd', '456')

5.重复

tp = ('123','a','b','c','d')
tp1 = ('456',)
print(tp*3)

('123', 'a', 'b', 'c', 'd', '123', 'a', 'b', 'c', 'd', '123', 'a', 'b', 'c', 'd')

6.索引（偏移） 切片[:]

tp = ('123','a','b','c','d')
tp1 = ('456',)
tp2 = ('123','a','b','c',['ccc','bbb'])
print(tp+tp1)
print(tp*3)
print(tp[2])
print(tp[::-1])
tp2[4][0] = 'aaa'
print(tp2[4][0])
print(tp2)


('123', 'a', 'b', 'c', 'd', '456')
('123', 'a', 'b', 'c', 'd', '123', 'a', 'b', 'c', 'd', '123', 'a', 'b', 'c', 'd')
b
('d', 'c', 'b', 'a', '123')
aaa
('123', 'a', 'b', 'c', ['aaa', 'bbb'])

7.查删

• 使用index和切片查

tp = ('123','a','b','c',['ccc','bbb'])
print(tp.index('123'))
0

tp2 = ('123','a','b','c',['ccc','bbb'])

print(tp2[2:3])
('b',)

• 整体删除

tp = ('123','a','b','c',['ccc','bbb'])
del tp

8.判断

tp = ('123','a','b','c',['ccc','bbb'])
print('a' in tp)

True

9.最大值，最小值

tp1 = ('a','b','c','d')
print(max(tp1),min(tp1))

d a

10.遍历

• 元素遍历

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

a
b
c
d

• 索引遍历

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

a
b
c
d

• 枚举enumerate

tp1 = ('a','b','c','d')
for index,value in enumerate(tp1):
    print(index,value)

0 a
1 b
2 c
3 d