15.元组(低调的元组,不一样的精彩)

2021年9月15日 4点热度 0条评论 来源: 胡老师11452

目录

 

一、元组的创建

二、元组的修改

三、元组的操作

四、元组的解包

五、元组的思考与拾遗

1.为什么有了列表还要元组?

2.空元组的意义

3.具名元组

六、元组练习

1.元组基础练习

2.元组的解包

3.简单分析电影数据

七、第十一课练习参考答案

元组是固定长度(fixed-length)、不可变序列(immutable sequence),主要用于存储异构数据(不同类型、不同意义的数据)。

元组从字面也容易理解它的作用,将元素组合在一起。

一、元组的创建

创建元组最简单的方法是在交互式解释器下输入用逗号分割开的元素,解释器会自动将其解释为一个元组,如1,2 —>(1,2)。如果你将其赋值给一个变量,这个变量也将获得到这个元组。

>>>1,2
(1, 2)

>>>tup = 3,4,5
>>>tup
(3, 4, 5)

>>>words = 'a','b','c'
>>>words
('a', 'b', 'c')

>>>words = (1,2,3),(4,5)
>>>words
((1,2,3),(4,5))

如果是单个元素的元组,除了要放在圆括号里面,还需要在这个元素的后面加上逗号。

# 1个元素只用圆括号括起来而不加逗号,python解释器会默认将其按括号内的数值类型进行解释
>>>numbers = (1)
>>>numbers
1
>>>type(numbers)
<class 'int'>

# 注意括号内的逗号
>>>numbers = (1,)
>>>numbers
(1,)
>>>type(numbers)
<class 'tuple'>

什么时候用圆括号?

以上例子我们发现,只要格式正确,圆括号似乎不是必须的,哪如何分辨何时需要使用圆括号呢?

在大多数其他文档中,括号是可选的。对于初学者,最好的建议是一直使用圆括号,这可能会比弄明白什么时候可以省略圆括号要更简单一些。许多程序员也发现圆括号有助于增加脚本的可读性,因为这样可以使元组更加明确。

In most other contexts, the enclosing parentheses are optional. For beginners, the best advice is that it’s probably easier to use the parentheses than it is to remember when they are optional or required. Many programmers (myself included) also find that parentheses tend to aid script readability by making the tuples more explicit and obvious, but your mileage may vary.

摘自《Learning Python》(页码278页)

你也可以将其他的可迭代序列方便的转换为元组。

>>>tuple([2,3,4])
(2, 3, 4)
>>>tuple('string')
('s', 't', 'r', 'i', 'n', 'g')

二、元组的修改

对于元组的修改主要是鉴于元组可以嵌套其他可变的可迭代序列而进行的操作。

>>>words = ('a','b',['c','d'],'e')
>>>words[2].append('dd') # 向元组内嵌套的列表中插入元素,还可以实现列表支持的其他操作
>>>words
('a', 'b', ['c', 'd', 'dd'], 'e')

# 但是不可以删除嵌套的列表
>>>del words[2]
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: 'tuple' object doesn't support item deletion

不可变类型不可以在原处修改

虽然你不可以在原地修改元组、字符串等不可变对象,但是你可以通过索引、切片、合并等操作来创建一个新的对象,再向后赋值给原引用。

s = (1,2,3,4,5)
s[4] = 6 # Error!
s = s[0:4] + (4,) # OK:(1,2,3,4,6)

三、元组的操作

>>>(1,2,3) + (4,5,6) # 元组的拼接,拼接后生成新的元组
(1, 2, 3, 4, 5, 6)

>>>('a','b') * 3 # 元组的乘法运算,生成新的元组
('a', 'b', 'a', 'b', 'a', 'b')

>>>numbers = (1, 2, 3, 4, 5, 6)
>>>numbers[2] # 元组的索引
3
>>>numbers[3:-1] # 元组的切片
(4, 5)

>>>numbers.index(3) # 获取元组中某个元素的下标
2

>>>sum(numbers) # 求和
21
>>>max(numbers) # 查找最大值
6
>>>min(numbers) # 查找最小值
1
>>>len(numbers) # 返回元组的长度
6
>>>numbers.count(3) # 查找某个元素出现的次数
1

>>>numbers.__contains__((5)) # 判断元组中是否包含某个元素,返回True或者False
True
>>>numbers.__contains__((7)) # 判断元组中是否包含某个元素,返回True或者False
False

四、元组的解包

在前面我们提到,将元素用逗号分割赋值给一个变量,会生成元组,这一过程我们也可以理解为将多个元素打包在一起,也称为封包。

相反的,我们将一个元组赋值给多个变量的过程,称为解包(unpack)。

平行赋值

元组的维度和大小与变量一致时,称为平行赋值,这时每一个值和每一个变量一一对应。


>>>x,y,z = (1,2,3)
>>>print("x is %i"%x)
x is 1
>>>print("y is %i"%y)
y is 2
>>>print("z is %i"%z)
z is 3

列表和元组都能实现解包操作。 

info_all = [('Tom',19,'videogame'),('Jim',20,'baseball'),('Henry',22,'basketball')]
Tom,Jim,Henry = info_all  # 列表的解包
print(Tom,Jim,Henry)
('Tom', 19, 'videogame') ('Jim', 20, 'baseball') ('Henry', 22, 'basketball')

for name,old,fond in info_all:  # 元组拆包
...     print(name,old,fond)
...     
Tom 19 videogame
Jim 20 baseball
Henry 22 basketball

有时你不太清楚包里到底能有多少个元素时,我们就无法确定准确的变量数量。

>>>a,b,c = range(0,4)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
ValueError: too many values to unpack (expected 3) # 太多值需要解包(可以接收3个)

按照以往的方式,变量与元素的数量不一致会报错,我们使用*和变量组合,使得这个变量升级,成为一个可以接收多个多余元素的超级变量。

a,b,*c = (range(0,4))
a,b,c
(0, 1, [2, 3]) # 超级变量c接收了多余的[2,3]

到目前为止,我们对元组已经有了基本认识,它看起来似乎和列表一样,但由于其不可变性的特征,一些列表中的方法在元组中是不可用的。

对于元组的理解,是不是还有什么遗漏的呢?

五、元组的思考与拾遗

1.为什么有了列表还要元组?

首先,我们可以肯定的是元组来源于数学,在笛卡尔乘积中可以查证到有关元组的描述,这一概念在关系数据中又得到引用。元组(tuple)是关系数据库中的基本概念,关系是一张表,表中的每行(即数据库中的每条记录)就是一个元组,每列就是一个属性。 在二维表里,元组也称为行(百度百科)。Python的创造者最初将元组看作是简单的对象组合。

笛卡尔乘积是指在数学中,两个集合X和Y的笛卡尔积(Cartesian product),又称直积,表示为X × Y,第一个对象是X的成员而第二个对象是Y的所有可能有序对的其中一个成员。笛卡尔乘积代表的是n个集合所有组合的所有可能性。例如集合X中有{a,b},集合Y中有{0,1,2},笛卡尔乘积={(a,0),(a,1),(a,2),(b,0),(b,1),(b,2)},其中像(a,0)这样的每一个元素都称为元组。

摘自《百度百科-笛卡尔乘积》

其次,元组的不可变性提供了某种完整性。这样你可以确保在程序中不会被另一个引用修改,而列表就没有这样的保证了。因此,元组的角色类似于其他语言中的“常数”声明,然而这里的常数概念在Python中是与对象相结合,而不是变量。(在c语言中使用const将某一变量定义为常量,告诉计算机这个变量的值是不可变的。)这种不可变性相比较其他可变对象,更加安全、更易于维护、也更加节省资源。一些内置操作也要求或暗示要使用元组而不是列表。

元组不仅仅是不可变列表,一些关于Python的介绍性文本将元组表示为“不可变列表”,但这低估了他们。元组有两个职责,一是当作不可变的序列使用,二是作为没有字段名的记录使用。

Tuples are not just immutable lists Some introductory texts about Python present tuples as “immutable lists”, but that is short selling them. Tuples do double-duty: they can be used as immutable lists and also as records with no field names. 

摘自《Fluent Python》(页码26). 

 

再次,将元组作为记录,其中每个元素的位置是非常重要的,位置代表了元素所归属的字段名。下面是两个实例:

city = ('shenzheng',2019,13.4,1997,(22.38,14.05))
name,year,pop,area,lat_long = city
print(
"The city's name is %s,\n"%name,
"this year is %i,\n"%year,
"there are %.2f million people,\n"%pop,
"it covers an area of %.2f square kilometers,\n"%area,
"latitude is %.2f,longtitude is %.2f."%(lat_long)
)

输出:
The city's name is shenzheng,
this year is 2019,
there are 13.40 million people,
it covers an area of 1997.00 square kilometers,
latitude is 22.38,longtitude is 14.05.

city中一共包含5个元素,下标从0到4分别对应name(城市名称),year(当前年份),population(人口),area(面积),latitude_longtitude(经纬度是一个坐标对)。

city = [('guangzhou',2019,7434,15.31),
        ('shanghai',2019,6340,24.28),
        ('shenzheng',2019,1997,13.44),
        ('beijing',2019,16410,21.53)]
print('{:15} | {:^9} | {:^9} | {:^9}'.format('', 'year', 'area.', 'pop.'))
fmt = '{:15} | {:9d} | {:9d} | {:9.2f}'
for name, year, area, pop in city:
    print(fmt.format(name, year , area, pop))

输出:
                |   year    |   area.   |   pop.   
guangzhou       |      2019 |      7434 |     15.31
shanghai        |      2019 |      6340 |     24.28
shenzheng       |      2019 |      1997 |     13.44
beijing         |      2019 |     16410 |     21.53

time也是如此,6个元素分别对应年、月、日,时、分、秒。

city = ('shenzheng',2019,13.4,1997,(22.38,14.05))
# (城市名称,年份,人口(百万),面积(平方公里),(纬度,经度))
time = (2020, 12, 20, 12, 20, 33)
#(年,月,日,时,分、秒)

最后,元组在创建时长上的表现远优于列表,以下是分别创建包含1到10000所有整数的元组和列表,发现再测试100次后,平均list处理时长是tuple处理时长的100倍。

import time
average_list_divide_tuple = []
for i in range(100):
    start_time = time.time()
    tup = (x for x in range(1,10001))
    end_time = time.time()
    deltatime_for_tuple = end_time-start_time

    start_time = time.time()
    lst = [x for x in range(1,10001)]
    end_time = time.time()
    deltatime_for_list = end_time-start_time

    average_list_divide_tuple.append(deltatime_for_list/deltatime_for_tuple)

print("测试一百次后,平均list处理时长是tuple处理时长的%f"%(sum(average_list_divide_tuple)/len(average_list_divide_tuple)))


输出:
测试一百次后,平均list处理时长是tuple处理时长的108.820385

2.空元组的意义

对于空元组网上也有相关讨论,这里不做过多议论,目的只为了解,切不必纠结于此。

因为元组是不可变的,如果创建了一个空的元组,是无法像空列表一样向其中添加元素的。因此,它看起来似乎没什么,从数学上理解空元组反映的是“无”的状态,如果你要描述一个空的序列,你就可以用到它。例如不存在符合要求的字段名,返回空元组;或者字段名已遍历完毕,剩余的字段名可返回空元组。

>>>tup1 = ()
>>>tup1
()
>>>type(tup1)
<class 'tuple'>

3.具名元组

当元组作为记录被使用时,它似乎看起来还是缺少了些东西,那就是字段的名称。我们可以将它转换为字典,提高数据的可读性。

city = [('guangzhou',7434,15.31),
        ('shanghai',6340,24.28),
        ('shenzheng',1997,13.44),
        ('beijing',16410,21.53)]
print(city[0])
for i in city[0]:  # 没有特别说明,你能知道7434和15.31是什么吗?
    print(i)

shanghai = dict(name = 'shanghai',area = 6340,pop = 24.28) # 创建字典,提高数据的可读性
print(shanghai)
print(shanghai['name'],shanghai['area'])

输出:
('guangzhou', 7434, 15.31)
guangzhou
7434
15.31
{'name': 'shanghai', 'area': 6340, 'pop': 24.28}
shanghai 6340

此外,我们还可以使用具名元组(namedtuple)。

namedtuple是collections库中的函数,也是一个工厂函数,它可以用来构建一个带字段名的元组和一个有名字的类。

from collections import namedtuple # import namedtuple
city = namedtuple('city',['name','area','pop']) # 生成一个city类,其中包含两个参数,一个是类的名称,另一个是类的各个字段名。后者可以是有多个字符串组成的可迭代对象,或者是有空格分隔开的字段名组成的字符串。具名元组可以通过字段名或者位置来获取一个字段的信息。

guangzhou = city(name = 'guangzhou',area = 7434,pop = 15.31)  # 生成一个实例
print(type(guangzhou),guangzhou) # 输出这个实例
print(guangzhou[0],guangzhou[2]) # 通过下标来获得值
print(guangzhou.name,guangzhou.pop) # 通过字段名称来获得值
print(guangzhou._fields) # 获得这个类的所有属性
dict_guangzhou = guangzhou._asdict() # 生成一个字典
print(dict_guangzhou['name'],dict_guangzhou['area']) # 根据key来获得value
print(type(dict_guangzhou),dict_guangzhou)

输出:
<class '__main__.city'>  city(name='guangzhou', area=7434, pop=15.31)
guangzhou 15.31
guangzhou 15.31
('name', 'area', 'pop')
guangzhou 7434
<class 'dict'> {'name': 'guangzhou', 'area': 7434, 'pop': 15.31}



citys = [('guangzhou',7434,15.31),
        ('shanghai',6340,24.28),
        ('shenzheng',1997,13.44),
        ('beijing',16410,21.53)]

dict_of_citys = []
namedtuple_of_citys = []
for tup in citys:
    tuple_to_namedtuple = city._make(tup)  # 使用city类的_make方法,将元组全部转为具名元组
    namedtuple_of_citys.append(tuple_to_namedtuple)
    dict_of_citys.append(tuple_to_namedtuple._asdict()) # 将具名元组转为字典
print(namedtuple_of_citys)
print(dict_of_citys)

输出:
[city(name='guangzhou', area=7434, pop=15.31), city(name='shanghai', area=6340, pop=24.28), city(name='shenzheng', area=1997, pop=13.44), city(name='beijing', area=16410, pop=21.53)]

[{'name': 'guangzhou', 'area': 7434, 'pop': 15.31}, {'name': 'shanghai', 'area': 6340, 'pop': 24.28}, {'name': 'shenzheng', 'area': 1997, 'pop': 13.44}, {'name': 'beijing', 'area': 16410, 'pop': 21.53}]

六、元组练习

1.元组基础练习

1.创建一个元组,里面包含1到5之间的所有整数,并将其赋值给变量tup1,输出tup1的值。
2.创建一个元组,里面包含1个元素‘tuple’,并将其赋值给变量tup2,输出tup2的值。
3.创建一个元组,里面包含1到50之间的所有奇数,并将其赋值给变量tup3,输出tup3的值。
4.输出tup3中的第7位。
5.输出tup3中的第12到17位。
6.输出tup3中的后8位。
7.将tup3的后10位删除,并保存为tup4。
8.将tup4中第5位修改为[77,88,99],并保存为tup5。
9.输出88,99
10.在tup5中的99后面新增100。

2.元组的解包

有一批手工制作的箱子,一共50个,他们大小不一。请编程计算这批箱子的总体积和平均体积。
data = [(87, 71, 70), (100, 61, 70), (80, 77, 80), (95, 73, 73), (97, 70, 65), (95, 65, 68), (92, 65, 66), (100, 79, 76), (85, 61, 80), (91, 71, 71), (91, 60, 79), (80, 70, 68), (83, 65, 78), (81, 70, 67), (85, 80, 75), (86, 66, 60), (83, 70, 69), (80, 79, 67), (96, 67, 67), (90, 70, 60), (90, 74, 71), (89, 68, 65), (84, 68, 66), (92, 68, 74), (92, 70, 64), (96, 65, 73), (100, 62, 77), (87, 74, 63), (100, 74, 71), (89, 64, 74), (88, 65, 79), (96, 63, 67), (89, 69, 71), (88, 74, 75), (88, 75, 73), (93, 75, 72), (87, 76, 64), (90, 74, 80), (81, 80, 76), (98, 65, 74), (88, 70, 67), (89, 69, 76), (82, 71, 71), (93, 68, 73), (92, 62, 64), (91, 77, 65), (96, 80, 76), (81, 68, 69), (91, 65, 78), (96, 62, 62)]
data中一共有50个元组,每个元组有3个数值,分别对应长、宽、高。
Your Mission:
1.循环遍历列表中的元组;
2.在循环体内,通过元组解包将三个数值同时分别赋值length,width,height三个变量;
3.计算每个箱子的体积,并将结果存到一个新的列表V中;
4.计算列表V中所有数值的和(即总体积)以及列表V的长度;
5.计算并输出平均体积。

3.简单分析电影数据

data = [('Avatar', 7.9, 'CCH Pounder', 'Joel David Moore', 'Wes Studi'), ("Pirates of the Caribbean: At World's End", 7.1, 'Johnny Depp', 'Orlando Bloom', 'Jack Davenport'), ('Spectre', 6.8, 'Christoph Waltz', 'Rory Kinnear', 'Stephanie Sigman'), ('The Dark Knight Rises', 8.5, 'Tom Hardy', 'Christian Bale', 'Joseph Gordon-Levitt'), ('Star Wars: Episode VII - The Force Awakens', 7.1, 'Doug Walker', 'Rob Walker', nan), ('John Carter', 6.6, 'Daryl Sabara', 'Samantha Morton', 'Polly Walker'), ('Spider-Man 3', 6.2, 'J.K. Simmons', 'James Franco', 'Kirsten Dunst'), ('Tangled', 7.8, 'Brad Garrett', 'Donna Murphy', 'M.C. Gainey'), ('Avengers: Age of Ultron', 7.5, 'Chris Hemsworth', 'Robert Downey Jr.', 'Scarlett Johansson'), ('Harry Potter and the Half-Blood Prince', 7.5, 'Alan Rickman', 'Daniel Radcliffe', 'Rupert Grint'), ('Batman v Superman: Dawn of Justice', 6.9, 'Henry Cavill', 'Lauren Cohan', 'Alan D. Purwin'), ('Superman Returns', 6.1, 'Kevin Spacey', 'Marlon Brando', 'Frank Langella'), ('Quantum of Solace', 6.7, 'Giancarlo Giannini', 'Mathieu Amalric', 'Rory Kinnear'), ("Pirates of the Caribbean: Dead Man's Chest", 7.3, 'Johnny Depp', 'Orlando Bloom', 'Jack Davenport'), ('The Lone Ranger', 6.5, 'Johnny Depp', 'Ruth Wilson', 'Tom Wilkinson'), ('Man of Steel', 7.2, 'Henry Cavill', 'Christopher Meloni', 'Harry Lennix'), ('The Chronicles of Narnia: Prince Caspian', 6.6, 'Peter Dinklage', 'Pierfrancesco Favino', 'Damián Alcázar'), ('The Avengers', 8.1, 'Chris Hemsworth', 'Robert Downey Jr.', 'Scarlett Johansson'), ('Pirates of the Caribbean: On Stranger Tides', 6.7, 'Johnny Depp', 'Sam Claflin', 'Stephen Graham'), ('Men in Black 3', 6.8, 'Will Smith', 'Michael Stuhlbarg', 'Nicole Scherzinger'), ('The Hobbit: The Battle of the Five Armies', 7.5, 'Aidan Turner', 'Adam Brown', 'James Nesbitt'), ('The Amazing Spider-Man', 7.0, 'Emma Stone', 'Andrew Garfield', 'Chris Zylka'), ('Robin Hood', 6.7, 'Mark Addy', 'William Hurt', 'Scott Grimes'), ('The Hobbit: The Desolation of Smaug', 7.9, 'Aidan Turner', 'Adam Brown', 'James Nesbitt'), ('The Golden Compass', 6.1, 'Christopher Lee', 'Eva Green', 'Kristin Scott Thomas'), ('King Kong', 7.2, 'Naomi Watts', 'Thomas Kretschmann', 'Evan Parke'), ('Titanic', 7.7, 'Leonardo DiCaprio', 'Kate Winslet', 'Gloria Stuart'), ('Captain America: Civil War', 8.2, 'Robert Downey Jr.', 'Scarlett Johansson', 'Chris Evans'), ('Battleship', 5.9, 'Liam Neeson', 'Alexander Skarsgård', 'Tadanobu Asano'), ('Jurassic World', 7.0, 'Bryce Dallas Howard', 'Judy Greer', 'Omar Sy'), ('Skyfall', 7.8, 'Albert Finney', 'Helen McCrory', 'Rory Kinnear'), ('Spider-Man 2', 7.3, 'J.K. Simmons', 'James Franco', 'Kirsten Dunst'), ('Iron Man 3', 7.2, 'Robert Downey Jr.', 'Jon Favreau', 'Don Cheadle'), ('Alice in Wonderland', 6.5, 'Johnny Depp', 'Alan Rickman', 'Anne Hathaway'), ('X-Men: The Last Stand', 6.8, 'Hugh Jackman', 'Kelsey Grammer', 'Daniel Cudmore'), ('Monsters University', 7.3, 'Steve Buscemi', 'Tyler Labine', 'Sean Hayes'), ('Transformers: Revenge of the Fallen', 6.0, 'Glenn Morshower', 'Kevin Dunn', 'Ramon Rodriguez'), ('Transformers: Age of Extinction', 5.7, 'Bingbing Li', 'Sophia Myles', 'Kelsey Grammer'), ('Oz the Great and Powerful', 6.4, 'Tim Holmes', 'Mila Kunis', 'James Franco'), ('The Amazing Spider-Man 2', 6.7, 'Emma Stone', 'Andrew Garfield', 'B.J. Novak'), ('TRON: Legacy', 6.8, 'Jeff Bridges', 'Olivia Wilde', 'James Frain'), ('Cars 2', 6.3, 'Joe Mantegna', 'Thomas Kretschmann', 'Eddie Izzard'), ('Green Lantern', 5.6, 'Ryan Reynolds', 'Temuera Morrison', 'Taika Waititi'), ('Toy Story 3', 8.3, 'Tom Hanks', 'John Ratzenberger', 'Don Rickles'), ('Terminator Salvation', 6.6, 'Christian Bale', 'Bryce Dallas Howard', 'Common'), ('Furious 7', 7.2, 'Jason Statham', 'Paul Walker', 'Vin Diesel'), ('World War Z', 7.0, 'Peter Capaldi', 'Brad Pitt', 'Mireille Enos'), ('X-Men: Days of Future Past', 8.0, 'Jennifer Lawrence', 'Peter Dinklage', 'Hugh Jackman'), ('Star Trek Into Darkness', 7.8, 'Benedict Cumberbatch', 'Bruce Greenwood', 'Noel Clarke'), ('Jack the Giant Slayer', 6.3, 'Eddie Marsan', 'Ewen Bremner', 'Ralph Brown')]
data是从IMDB爬取的5000条电影数据集的其中50部电影的数据,并只截取了其中5个字段的数据,这些字段分别是电影名称(movie_name)、IMDB评分(imdb_scores)、第一主演姓名(actor_1_name)、第二主演姓名(actor_2_name)、第三主演姓名(actor_3_name),每部电影的数据存在一个元组中。

Your Mission:
1.循环遍历列表中的元组。
2.在循环时,你要完成以下子任务:
(1)完成对每个元组的解包,将元组的第1项赋给name, 第2项赋给scores, 其余的赋给actors;(希望你还记得怎么使用*)
(2)接下来将(name,scores)存入到movies_scores的列表中
(3)将actors中的内容存入到movies_actors的列表中。(你要判断一下append、insert、extend哪个最适合用来完成此任务)
*记住,这些都是在循环中完成的。
3.Boss级的任务来了,你准备好了吗?
(1)我需要你帮助我找到movies_scores中评分最高的前10部电影(仅用1行代码)。以下是你应该得到的结果(这些电影我都超爱,怪不得评分这么高,嘿嘿~):
[('The Dark Knight Rises', 8.5), ('Toy Story 3', 8.3), ('Captain America: Civil War', 8.2), ('The Avengers', 8.1), ('X-Men: Days of Future Past', 8.0), ('Avatar', 7.9), ('The Hobbit: The Desolation of Smaug', 7.9), ('Tangled', 7.8), ('Skyfall', 7.8), ('Star Trek Into Darkness', 7.8)]

(2)此外,我还希望知道这50部电影中,谁出演过的电影数最多,将参演电影数最多的前10位演员及参演电影的数量一并输出。以下是你应该得到的结果:(这题稍微有点超纲,会用到之后章节字典中的一些知识,你可以在网上检索相关技巧)
[('Johnny Depp', 5), ('Robert Downey Jr.', 4), ('Rory Kinnear', 3), ('James Franco', 3), ('Scarlett Johansson', 3), ('Orlando Bloom', 2), ('Jack Davenport', 2), ('Christian Bale', 2), ('J.K. Simmons', 2), ('Kirsten Dunst', 2)]

Enjoy it! 希望你玩的开心~~!

七、第十一课练习参考答案

1.有1,2,3,4四个数字,可以组成多少种互不相同且无重复数字的三位数?并请输出这些数字。

numbers = []
for x in range(1,5):
    for y in range(1,5):
        for z in range(1,5):
            if x != y and y != z and z != x and "%d%d%d"%(x,y,z) not in numbers:
                numbers.append("%d%d%d"%(x,y,z))
print(numbers,"\n",len(numbers))

2.找出从101到200之间有多少个素数?并请输出这些数字。

countby_isprime = 0
for i in range(101,201):
    isprime = True
    for j in range(2,i):
        if i % j == 0:
            isprime = False
            break
    if isprime:
        print(i)
        countby_isprime += 1
    else:
        pass

print("从101到200一共有%i个素数"%countby_isprime)

3.输出如下图所示的菱形。

n = 5
for row in range(1,n + 1):
    if row <= (n + 1)/2:
        print("\t" * (n + 1 - row),end="\t")
        for j in range((2 * row - 1)):
            print("*",end="\t")
        print("\n")
    else:
        print("\t" * row,end="\t")
        for j in range(2 * (n + 1 - row) - 1):
            print("*",end="\t")
        print("\n")

 

    原文作者:胡老师11452
    原文地址: https://blog.csdn.net/qq_40407729/article/details/110943421
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系管理员进行删除。