Python菜鸟编程第三课列表元组

Python菜鸟编程第三课

1.Print()函数补充

语法格式：

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

等价于

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

其中，sep用来在输出中间加入符号。end则是在结尾处加入符号。

demo:

a, b, c, *d = 1, 2, 3, 4, 5, 6
print(a,b,c,d)
print(a,b,c,d,sep="*")
print(a,b,c,d,end="*")

运行结果：
1 2 3 [4, 5, 6]
1*2*3*[4, 5, 6]
1 2 3 [4, 5, 6]*

2.格式化输出

2.1 %格式化

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

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

demo:

print("%d" % 6688)
name = "qqq"
age = 12
print("His name is %s,his age is %d." % (name, age))
print("His name is", name, ",his age is ", age, ".")
print("His name is" + name + ",his age is " + str(age) + ".")

运行结果：
6688
His name is qqq,his age is 12.
His name is qqq ,his age is  12 .# 代码中的","默认是一个空格
His name isqqq,his age is 12.  #第三种输出方式是字符串的拼接，所以需要先把age转换成字符型，而且输出的结果是没有空格的。

练习题：

输出100%

print("%d%%" % 100) #第一个%d 匹配100，第二个%用来转义第三个%

运行结果：
100%

2.2 format格式化

• 位置映射

有几个参数，就需要有几个"{}"

print("Name:{},age:{}".format('qqq', '18'))

运行结果：
Name:qqq,age:18

• 关键字

需要注意的是，关键字的参数需要放在位置参数的后面，否则报错。

demo1:

print("{adress},Name:{},age:{}".format('qqq', '18',adress="Hangzhou"))

运行结果：
Hangzhou,Name:qqq,age:18

demo2:

print("第1个元素是：{0[0]}，第2个元素是：{0[1]}，第3个元素是：{0[2]}，第4个元素是：{1[0]}，第5个元素是：{1[1]}，第6个元素是：{1[2]}".format(
    ('www.', 'google', '.com'), ('www.', 'baidu', '.com')))

运行结果：
第1个元素是：www.，第2个元素是：google，第3个元素是：.com，第4个元素是：www.，第5个元素是：baidu，第6个元素是：.com

3.列表

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

特点：有序，可重复，可变类型。

3.1 列表的创建

l1=[1,"aa",3]
print(l1)

运行结果：
[1, 'aa', 3]

3.2 列表的强转

str1 = 'qwer'
l1 = list(str1)
print(l1)

运行结果：
['q', 'w', 'e', 'r']

3.3 列表的拼接

l1 = [1, 2, 3]
l2 = [4, 5, 6]
l3 = l1 + l2
print(l3)

运行结果：
[1, 2, 3, 4, 5, 6]

3.4 列表的重复

l1 = [1, 2, 3]
print(l1*2)

运行结果：
[1, 2, 3, 1, 2, 3]

3.5 列表的索引

列表的索引与字符串一样。

假如有一个列表l1=[‘P’,‘Y’,‘T’,‘H’,‘O’,‘N’],则对应索引如下。

P	Y	T	H	O	N
0	1	2	3	4	5
-6	-5	-4	-3	-2	-1

demo:

l1=['P','Y','T','H','O','N','usefful']
print(len(l1))
print(l1[0],l1[-1])
print(l1[:5])
print(l1[::-1])
print(l1[6][2])

运行结果：
7
P usefful
['P', 'Y', 'T', 'H', 'O']
['usefful', 'N', 'O', 'H', 'T', 'Y', 'P']
e

3.6 列表元素的增加

这里主要使用append()、extend()

函数名	描述
append()	增加的是作为其中一个元素
extend()	逐个增加，每个都作为一个元素
insert()	按照索引添加

demo:

#append()
l1=[1,2,3]
print(id(l1))
l2=['a','b','c']
l1.append(l2)
print(l1)
print(id(l1))
l1=[4,5,6]
print(id(l1))

#extend()
l1=[1,2,3]
l2=['a','b','c']
l1.extend(l2)
print(l1)

#insert()
l1=[1,2,3]
l2=['a','b','c']
l1.insert(1,l2)
print(l1)

运行结果：
#append()
2565605974600
[1, 2, 3, ['a', 'b', 'c']]
2565605974600
2565626686408

#extend()
[1, 2, 3, 'a', 'b', 'c']

#insert
[1, ['a', 'b', 'c'], 2, 3]

3.7 列表的修改

l1=[1,2,3]
l1[0]='a'
print(l1)
l1[1:5]=['b','c','d']
print(l1)

运行结果：
['a', 2, 3]
['a', 'b', 'c', 'd']

3.8 列表的删除

函数名	描述
pop()	删除指定索引对应的元素,并返回删除的元素。如果不指定索引，默认删除最后一个元素
remove()	移除第一次遇到的指定元素
del	移除元素或列表，清除地址
clear()	移除列表，保留地址，只清空内容
list=[]	清空列表

demo:

#pop()
l1=[1,2,3]
print(l1.pop())
print(l1)

#remove()
l1 = ['a', 'b', 'c', 'a', 'b', 'c']
print(l1.remove('a'))
print(l1)

#del
l1 = ['a', 'b', 'c', 'a', 'b', 'c']
del l1[2]
print(l1)
print(id(l1))
del l1
print(id(l1))

#clear()
l1 = ['a', 'b', 'c', 'a', 'b', 'c']
print(id(l1))
l1.clear()
print(l1)
print(id(l1))

运行结果：
#pop()
3
[1, 2]

#remove
['b', 'c', 'a', 'b', 'c']

#del
['a', 'b', 'a', 'b', 'c']
2465444422216
NameError: name 'l1' is not defined

#clear()
2946766299720
[]
2946766299720

3.9 列表的遍历

( 1 )元素遍历

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

运行结果：
a b c a b c 

( 2 )索引遍历

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

运行结果：
a b c a b c 

( 3 )枚举遍历

使用 enumerate()函数。

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

demo:

l1 = ['a', 'b', 'c', 'a', 'b', 'c']
for i in enumerate(l1):
    print(i,end=' ')
print()
for i in enumerate(l1,2):
    print(i,end=' ')
print()
for index,value in enumerate(l1):
    print(index,value,end='||')

运行结果：
(0, 'a') (1, 'b') (2, 'c') (3, 'a') (4, 'b') (5, 'c') 
(2, 'a') (3, 'b') (4, 'c') (5, 'a') (6, 'b') (7, 'c') 
0 a||1 b||2 c||3 a||4 b||5 c||

3.10 列表的计数

count()

demo:

l1 = ['a', 'b', 'c', 'a', 'b', 'c']
print(l1.count('a'))

运行结果：
2

3.11 列表的反转

l1 = ['a', 'b', 'c', 'a', 'b', 'c']
l1.reverse()
print(l1)

运行结果：
['c', 'b', 'a', 'c', 'b', 'a']

3.12 列表的排序

sort() : 按照ASCII码排序

l1 = ['a', 'b', 'c', 'a', 'b', 'c']
print(l1)
l1.sort()
print(l1)
l1.sort(reverse=True)
print(l1)

运行结果：
['a', 'b', 'c', 'a', 'b', 'c']
['a', 'a', 'b', 'b', 'c', 'c']
['c', 'c', 'b', 'b', 'a', 'a']

练习题：

l1=[‘a’,‘b’,‘c’,‘d’]

l2=[‘c’,‘d’,‘e’,‘f’]

输出两个列表的交集。

l1 = ['a', 'b', 'c', 'd']
l2 = ['c', 'd', 'e', 'f']
l3 = []
for i in l1:
    for j in l2:
        if i == j:
            l3.append(i)
print(l3)

运行结果：
['c', 'd']

练习题：

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

l1 = []

while True:
    str1 = input("请往列表中加入元素，输入q结束：")
    if str1!='q':
        l1.append(str1)
    else:
        print("您最后生成的列表为：")
        print(l1)
        break

运行结果：
请往列表中加入元素，输入q结束：123
请往列表中加入元素，输入q结束：456
请往列表中加入元素，输入q结束：q
您最后生成的列表为：
['123', '456']

练习题：

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

import random
l1 = []
for i in range(30):
    num = random.randint(0, 10)
    l1.append(num)
l2=[]
for i in range(11):
    cnum=l1.count(i)
    l2.append((i,cnum))
print("统计结果为：")
print(l2)

运行结果：
[(0, 2), (1, 3), (2, 7), (3, 3), (4, 4), (5, 1), (6, 0), (7, 4), (8, 2), (9, 3), (10, 1)]

3.13 列表的赋值与深浅拷贝

• 赋值是对对象的引用。

demo:

l1 = [1, 2, 3, 4, 5, 'qwe0', ['a', 'v']]
l2 = l1
print(l1)
print(l2)
print(id(l1))
print(id(l2))

运行结果：
[1, 2, 3, 4, 5, 'qwe0', ['a', 'v']]
[1, 2, 3, 4, 5, 'qwe0', ['a', 'v']]
1901601982664
1901601982664

l1、l2指向的是同一个内存地址。所以id不会改变，即使改变了其中某个元素，地址也不会改变。当改变l1或者l2中某个元素，对应的另一个列表的值也会发生改变。

l2[2]=2222
print(l1)
print(l2)

运行结果：
[1, 2, 2222, 4, 5, 'qwe0', ['a', 'v']]
[1, 2, 2222, 4, 5, 'qwe0', ['a', 'v']]

• 浅拷贝

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

三种实现方法：

• 切片操作
• 工厂函数list
• copy模块内的copy函数

demo:

l1 = [1, 2, 3, 4, 5, 'qwe0', ['a', 'v']]
l2 = l1[:]
print(l1)
print(l2)
print(id(l1))
print(id(l2))

import copy
l2_copy=copy.copy(l1)
print(id(l2_copy))
l1.append(6)
print(l1)
print(l2_copy)

#注意，这里l1中最后一个元素是列表形式，当其中某一元素发生变化，来l2_copy中也要相应发生改变。因为浅拷贝只是拷贝了一层。
l1[6][1]=(6)
print(l1)
print(l2_copy)
print(l1[-1],id(l1[-1]))
print(l2_copy[-1],id(l2_copy[-1]))

运行结果：
[1, 2, 3, 4, 5, 'qwe0', ['a', 'v']]
[1, 2, 3, 4, 5, 'qwe0', ['a', 'v']]
2364913838792
2364913839240

2166089215560
[1, 2, 3, 4, 5, 'qwe0', ['a', 'v'], 6]
[1, 2, 3, 4, 5, 'qwe0', ['a', 'v']]

#注意，从这里可以看到l1与l2_copy中的嵌套元素所指向的地址是同一个地址
[1, 2, 3, 4, 5, 'qwe0', ['a', 6]]
[1, 2, 3, 4, 5, 'qwe0', ['a', 6]]
['a', 'v'] 1707180778056
['a', 'v'] 1707180778056

浅拷贝相当于我们只拷贝了一层，修改外层元素，会修改引用，让他们指向另一个地址。

修改嵌套列表的元素，列表地址没有发生变化，指向的还是同一个地址。

• 深拷贝

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

demo:

import copy
l1 = [1, 2, 3, 4, 5, 'qwe0', ['a', 'v']]
l2_decopy = copy.deepcopy(l1)
print(l1, id(l1))
print(l1[-1],id(l1[-1]))
print(l2_decopy, id(l2_decopy))
print(l2_decopy[-1],id(l2_decopy[-1]))
l1[6][1] = 6
print(l1)
print(l2_decopy)

运行结果：
[1, 2, 3, 4, 5, 'qwe0', ['a', 'v']] 2105216690952
['a', 'v'] 2105195848264
[1, 2, 3, 4, 5, 'qwe0', ['a', 'v']] 2105216691400
['a', 'v'] 2105216691528  #这里可以看到，深拷贝以后，l1与l2_decopy的嵌套列表所指向的地址并不一样。所以说，深拷贝以后与原先数据没有任何关系了。
[1, 2, 3, 4, 5, 'qwe0', ['a', 6]]
[1, 2, 3, 4, 5, 'qwe0', ['a', 'v']]

3.14 列表解析式、生成式

格式：

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

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

demo:

l1=[]
for i in range(10):
    l1.append(i)
print(l1)
print([x for x in range(10)])

运行结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

带过滤功能的格式：

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

demo:

print([x for x in range(10) if x%2==0])

运行结果：
[0, 2, 4, 6, 8]

练习题：

name=[‘Tom’,‘Jack’,‘Bob’]

subject=[‘Python’,‘Java’,‘C’,‘C++’]

使用生成式来使以上两个列表组合起来。

name=['Tom','Jack','Bob']
subject=['Python','Java','C','C++']
print([[x,y] for x in name for y in subject])

运行结果：
[['Tom', 'Python'], ['Tom', 'Java'], ['Tom', 'C'], ['Tom', 'C++'], ['Jack', 'Python'], ['Jack', 'Java'], ['Jack', 'C'], ['Jack', 'C++'], ['Bob', 'Python'], ['Bob', 'Java'], ['Bob', 'C'], ['Bob', 'C++']]

4. 元组

特点：有序、可以重复、不可更改

4.1 元组的创建

t1 = (1, 2, 3)
print(t1)
print(type(t1))
t2=('abc')
print(type(t2))
t3=('abc',)
print(type(t3))

运行结果：
(1, 2, 3)
<class 'tuple'>
<class 'str'> #单元素元组的创建需要加上一个','，否则类型视为str
<class 'tuple'>

4.2 元组的拼接

t1 = (1, 2, 3)
t2 = ('a', 'b', 'c')
t3 = t1 + t2
print(t3)

运行结果：
(1, 2, 3, 'a', 'b', 'c')

4.3 元组的重复

t1 = (1, 2, 3)
t4=t1*2
print(t4)

运行结果：
(1, 2, 3, 1, 2, 3)

4.4 元组的索引

元组的索引与列表相同。

t1 = (1, 2, 3)
print(t1.index(2))

运行结果：
1

4.5 元组的修改与删除

元组不可修改，但是假如元组中嵌套了列表，那么可以修改列表中的元素。

t1 = (4, 5, 6, ['a', 'b', 'c'])
print(t1)
t1[3][1] = 'qq'
print(t1)

运行结果：
(4, 5, 6, ['a', 'b', 'c'])
(4, 5, 6, ['a', 'qq', 'c'])

元组不能增加，也不能删除某个元素。只能删除整个元组。

t1 = (4, 5, 6, ['a', 'b', 'c'])
del t1
print(t1)

运行结果：
NameError: name 't1' is not defined

4.6 元组的判断

t1 = (4, 5, 6, ['a', 'b', 'c'])
print(4 in t1)

运行结果：
True

• 最大值与最小值

t2 = ('a', 'b', 'c')
print(max(t2), min(t2))

运行结果：
c a

4.7 元组的遍历

元组的遍历，与列表一样。

( 1 )元素遍历

demo:

for i in t2:
    print(i, end=" ")

运行结果：
a b c

( 2 )索引遍历

demo:

for i in range(len(t2)):
    print(t2[i],end=' ')

运行结果：
a b c 

( 3 )枚举遍历

demo:

for i in enumerate(t2):
    print(i,end=" ")
print()
for i in enumerate(t2,1):
    print(i, end=" ")
print()
for index,value in enumerate(t2):
    print(index,value,end='||')

运行结果：
(0, 'a') (1, 'b') (2, 'c') 
(1, 'a') (2, 'b') (3, 'c') 
0 a||1 b||2 c||

4.8 元组的嵌套

简单来讲，就是元组中的元素也是元组。

demo:

t1=(('a','b','c'),(1,2,3),('qqq',456,'www'))
print(t1)
print(t1[2][2])

运行结果：
(('a', 'b', 'c'), (1, 2, 3), ('qqq', 456, 'www'))
www

4.9 元组的计数

元组的计数也是使用count()函数。

demo:

t2=('a','a','c','c','d')
print(t2.count('a'))

运行结果：
2

博主qq:1031748759.欢迎批评指正！！！