第五章-组合数据类型的生成式_lst=[expression for item in range]-CSDN博客

本文链接：https://blog.csdn.net/2303_79449572/article/details/135881770

本文详细介绍了Python中的序列操作、切片、列表生成式、元组、字典、集合、enumerate函数、生成器、__next__方法以及它们的区别和使用。还涵盖了如何从键盘输入列表和处理字典中的键值对，以及生成器对象的工作原理。

摘要由CSDN通过智能技术生成

组合数据类型的补充

之前是手写笔记,感觉好多东西都没有记到,这里补回来,所以这里的知识点会比较跳跃

序列包括字符串,列表,元组,字典,集合,但是组合数据类型不包括字符串

序列操作

切片操作的语法结构

序列[start: end : step]

start:切片开始的索引(包含)(省略的话从0开始)

end:切片结束的索引(不包含)(省略的话,会一致持续到序列结束)

step:步长(默认为1)(可以理解为从start开始的跳过的空格数)

序列[0: 5: 2](跳两个空格)

0 1 2 3 4 5 6 7 8 9
H e l l o W o r l d

读取时为0H 2l 4o不读5W

0	1	2	3	4	5	6	7	8	9
H	e	l	l	o	W	o	r	l	d

序列的共有操作

只要是序列就可以用的操作

列表生成式

1、语法结构

lst=[expression for item in range]

lst=[expression for item in range if condition]

代码实例：

import random
lst=[ item for item in range[1,11]]
print(lst)
lst=[item*item for item in range(1,11)]
print(lst)
lst=[random.randint(1,100) for _ in range(10)]
print(lst)

# 从列表中选择符合要求的元素组成新列表
lst=[i for i in range(1,10) if i%2==0]
print(lst)

2、从键盘输入列表

csdn@深度学习炼丹师-CXD

首先介绍两个函数
input().split(): 将字符串空格为标志分割成多个字符串。
map(int,字符序列): 将分割出来的字符序列转换成整型序列。

list1 = list(map(int, input("请输入一组数值(用空格隔开)：").split()))
print(list1, type(list1))
for i in range(len(list1)):
    print(list1[i], type(list1[i]))
print(list1[0]+list1[1])

代码结果：

请输入一组数值(用空格隔开)：12 34 56 67
[12, 34, 56, 67] <class 'list'>
12 <class 'int'>
34 <class 'int'>
56 <class 'int'>
67 <class 'int'>
46

AI见解(个人感觉更容易理解)

要从键盘上输入一个列表，你可以使用 input() 函数接收用户的输入使用 split() 函数将输入的字符串按照空格分割成多个元素。然后，你可以使用列表推导式将这些元素转换为合适的类型并创建一个新的列表。以下是一个示例代码:
user_input = input("请输入列表元素，以空格分隔：")
input_list = [int(x) for x in user_input.split()]
print(input_list)
在上述示例中，我们假设你要输入的是整数列表。如果你要输入的是其他类型的数据，比如字符串或浮点数，只需相应地修改列表推导式中的类型转换函数即可。

另外需要注意的是，这种方法只适用于输入的元素之间以空格分隔的情况。如果你希望以其他方式分隔元素，比如逗号或分号，需要在 split() 函数中指定分隔符。例如，如果你希望以逗号分隔元素，可以使用 split(",")

3 二维列表

1 创建二维列表

lst=[
    ['city','面积']
    ['beijing',44]
    ['shanhai',55]
    ['tianjin',66]
]
print(lst)

结果:

[['city', '面积'], ['beijing', 44], ['shanhai', 55], ['tianjin', 66]]

2 遍历二维列表

使用到双层循环:

#上面代码的延续
for row in lst:# 行
    for item in row: # 列
        print(item,end='\t')
    print()

外层控制行数,内层控制列数

3 二维列表生成式

以四行五列为例:

lst=[[j for j in range(5)]for i in range(4)]

for row in lst:
    for item in row:
        print(item,end='\t')
    print()

# 列表中的元素是列表的意思,i在外层控制行数,j在内层控制列数

结果:

元组

1 元组遍历

与列表可以说是一模一样

tup=('a0','b','c')

for item in tup:
    print(item)

这里再补充一个用索引的方式:(列表,字符串,元组都可以用)
t=('a','b','c')

for i in range(len(t)):
    print(t[i])

1.3enumerate函数

使用enumerate()函数:

可以获取索引和索引所对应的元素
tup=('a0','b','c')

for index,item in enumerate(tup):
    print(index,'---->',item)

enumerate() 函数是 Python 内置的一个函数，用于将可迭代对象（如列表、元组或字符串）组合为一个索引序列。它返回一个枚举对象，其中包含了原始可迭代对象中的每个元素以及对应的索引值。

enumerate() 函数的语法如下：
enumerate(iterable, start=0)
ps.”start”是要写出来的

参数说明：

iterable: 必需，表示要进行枚举的可迭代对象，如列表、元组、字符串等。
start: 可选，表示开始计数的索引值，默认为 0。

下面是一个使用 enumerate() 函数的示例代码：
pythonCopy Codefruits = ['apple', 'banana', 'orange']

for index, fruit in enumerate(fruits):
    print(index, fruit)
输出结果：
1 banana
2 orange
在上述示例中，enumerate() 函数遍历了列表 fruits，并返回了每个元素的索引和对应的值。这样我们就可以同时获得元素的值和索引，然后在循环中进行相应的操作。

除了在循环中使用 enumerate()，你还可以将其结果转换成列表或字典，以便后续使用。例如：
pythonCopy Codefruits = ['apple', 'banana', 'orange']
enum_list = list(enumerate(fruits))
enum_dict = dict(enumerate(fruits))

print(enum_list)
print(enum_dict)
输出结果：
Copy Code[(0, 'apple'), (1, 'banana'), (2, 'orange')]
{0: 'apple', 1: 'banana', 2: 'orange'}
这样，你就可以根据需要使用 enumerate() 函数来处理可迭代对象，并获得元素的索引和值。

2 元组生成式

元组生成式的结果是一个生成器对象,需要转化成元组或者列表才能看到内容.

t=(i for i in range(10))
print(t)

结果是:

<generator object <genexpr> at 0x00000285C4196D40>

2.1 生成器对象

生成器对象是一种延迟计算的序列，它会在需要时逐个产生值。这与列表、元组等容器对象不同，后者会在创建时就将所有的元素都存储在内存中。

生成器对象的优点在于它可以大大减少内存的使用。当处理大量数据时，使用生成器对象可以避免一次性读取所有数据到内存中，而是逐个读取并处理每个元素，从而节省内存空间。

以下为AI分析上面例子之后得出分析

在 Python 中，当使用生成器表达式时，会创建一个生成器对象。生成器表达式是一种简洁的语法形式，用于创建生成器对象。

在你的例子中，t = (i for i in range(10)) 是一个生成器表达式，它使用了圆括号来表示。生成器表达式由一个表达式和一个迭代器组成，它会逐个产生表达式的值。在这种情况下，表达式是 i，迭代器是 range(10)，它会产生从 0 到 9 的整数。

当我们执行 print(t) 时，实际上是打印了生成器对象 t 的字符串表示。生成器对象的字符串表示通常以 <generator object> 开头，后面跟着一些标识符和内存地址信息。

生成器对象并不会立即执行，而是在需要时进行惰性计算。这意味着在执行 print(t) 时，并没有对生成器对象进行迭代运算¹，而是只打印了它的类型和地址信息。

如果我们需要获取生成器对象的元素，可以通过迭代它来逐个获取。例如，使用 for 循环或将生成器对象转换为列表：
pythonCopy Codet = (i for i in range(10))
for x in t:
    print(x)
或者
pythonCopy Codet = (i for i in range(10))
result = list(t)
print(result)
这样，我们才能真正看到生成器对象产生的值。所以，生成器对象在打印时显示为 <generator object> 是正常的行为，因为它只是一个符号，表示这是一个生成器对象，并不会立即执行其中的逻辑

2.2 next方法

先上不用__next__方法实例:

t=(i for i in range(10))
print(t)
#转换成某种类型后看生成器对象
t=tuple(t)
print(t)
#迭代运算看生成器对象
for item in t:
    print(item)

结果:

<generator object <genexpr> at 0x00000271F9476D40>
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
0
1
2
3
4
5
6
7
8
9

而在使用__next__方法之前需要将遍历操作注释掉,如果不这样做,使用__next__方法是获取不到元素的,因为他已经遍历过一遍了,遍历过一遍后对象就不存在元素了²

同时t=tuple(t)也要注释掉,否则t就是一个元组类型了,不是生成器对象

next实例:

t=(i for i in range(5))
print(t)
'''#转换成某种类型后看生成器对象
t=tuple(t)
print(t)
#迭代运算看生成器对象
for item in t:
    print(item)'''
for i in range(len(t))
	print(t.__next__())

结果:

 for i in range(len(t)):
                   ^^^^^^
TypeError: object of type 'generator' has no len()

就是说,生成器不属于序列,没有len()函数,

改为:

t=(i for i in range(5))
print(t)
'''#转换成某种类型后看生成器对象
t=tuple(t)
print(t)
#迭代运算看生成器对象
for item in t:
    print(item)'''
for i in range(5)
	print(t.__next__())
t=tuple(t)
print(t)

结果:

<generator object <genexpr> at 0x000001D65B316D40>
0
1
2
3
4
()

也就是说__next__是一个一个的将生成器对象里面的元素取出来

元组和列表的区别

请添加图片描述

字典

字典的访问与遍历

请添加图片描述

1 字典中d[key]与d.get(key)的区别:

如果key不存在,d[key]会报错,而d.get(key)会输出默认值³

实例:

Dict={'1':a,'2':b,'3':c}

print(Dict.get('4'))
print(Dict.get('4','这是修改默认值的操作'))
print(Dict['4'])

结果:

None
这是修改默认值的操作
Traceback (most recent call last):
  File "D:\Python项目\pythonProject1\chap2\project02.py", line 40, in <module>
    print(Dict['4'])
          ~~~~^^^^^
KeyError: '4'

2 字典遍历

先介绍一下dict.items()方法:

在 Python 中，字典（dictionary）是一种无序、可变的数据类型，用于存储键值对。而字典的 items() 方法是用来返回字典中所有键值对的视图对象。

items() 方法以列表的形式返回一个包含字典所有键值对的视图对象。每个键值对都表示为一个元组，其中第一个元素是键，第二个元素是对应的值。这个视图对象是动态的，即当字典中的键值对发生变化时，它会相应地更新。

下面是一个示例，演示如何使用 items() 方法获取字典中的所有键值对：
my_dict = {'a': 1, 'b': 2, 'c': 3}
items = my_dict.items()
print(items)
for key, value in items:
    print(key, value)
输出结果：
dict_items([('a', 1), ('b', 2), ('c', 3)])
a 1
b 2
c 3
在这个例子中，我们调用了 items() 方法获取字典 my_dict 中所有的键值对，并将其赋值给变量 items。然后，我们使用 for 循环遍历 items，并分别将键和值赋值给变量 key 和 value。最后，我们打印出每个键值对的键和值。

需要注意的是，字典的 items() 方法返回的是一个视图对象,前缀 dict_items 就是是由 Python 解释器自动生成的，用于表示一个字典视图对象。它的作用是提醒我们这是一个字典的视图对象，而不是一个普通的列表或其他数据类型。这意味着它不会占用额外的内存来存储所有的键值对，而是在需要时动态生成。如果你希望将其转换为列表，可以使用 list() 函数进行转换，如 list(my_dict.items())。

使用 items() 方法可以方便地遍历字典中的所有键值对，并对它们进行处理或操作

字典生成式

1 range()次数限制

代码理解:
impor random

d={i:random.randint(1,100) for i in range(5)}
print(d)
ps.一般先写for i in range(次数),然后才写前面的键:值 需要注意的是要用花括号括起来

结果:

{0: 58, 1: 18, 2: 56, 3: 28, 4: 82}

2 使用zip()函数映射键值

代码理解:

lst1=[1001,1002,1003]
lst2=['a','b','c']
d={key:value for key,value in zip(lst1,lst2)}
print(d)

结果:

{1001: 'a', 1002: 'b', 1003: 'c'}

集合

集合的遍历操作

使用enumerate()函数(按ctrl键后再点击可跳转)

代码演示:
s={'我','是','集合'}

for index,item in enumerate(s):
   print(index,'对应',item)
j结果:
0 对应 是
1 对应 我
2 对应 集合
在 Python 中，集合（set）是一种无序的、可变的数据类型，它不支持通过索引来访问元素。因此，在集合中，并不存在所谓的索引，也就不存在集合的索引。

在代码中，enumerate() 函数会遍历集合 s 中的所有元素，并为每个元素生成一个索引值和对应的元素值，这些索引值是从 0 开始递增的整数，用于表示元素在集合中的顺序。

因此，在 for 循环中使用 enumerate() 函数时，index 变量实际上是用于表示当前元素在集合中的位置，而不是所谓的索引值。你可以使用 index 变量来获得当前元素在集合中的位置，但不能将其当作集合的索引来使用。所以每次运行代码后,结果中的0,1,2对应的元素会不一样

集合生成式

集合的生成式与列表的相似:

set={expression for item in range}

set={expression for item in range if condition}

括号记得是花括号,不是方括号

代码实例:

import random

s={random.randint(1,100) for i in range(4)}
print(s)
在这里需要注意的是randint()的括号中要有范围限定,否则会出现一下的情况:
TypeError: Random.randint() missing 2 required positional arguments: 'a' and 'b'
如果是没有括号会出现:
{<bound method Random.randint of <random.Random object at 0x0000025C536223A0>>}
是因为你在打印函数或方法的对象本身，而不是调用该函数或方法后返回的结果。

有条件限制时:

import random

s={random.randint(1,100) for i in range(10) if i%2==0}
print(s)

结果:

{73, 22, 55, 26, 93}

组合数据类型的区别:

ndom

s={random.randint(1,100) for i in range(4)}
print(s)
在这里需要注意的是`randint()`的括号中要有范围限定,否则会出现一下的情况:
TypeError: Random.randint() missing 2 required positional arguments: ‘a’ and ‘b’
如果是没有括号会出现:
{<bound method Random.randint of <random.Random object at 0x0000025C536223A0>>}
是因为你在打印函数或方法的对象本身，而不是调用该函数或方法后返回的结果。

有条件限制时:

import random

s={random.randint(1,100) for i in range(10) if i%2==0}
print(s)

结果:

{73, 22, 55, 26, 93}

组合数据类型的区别:

在这里插入图片描述

迭代运算是指在程序中对一个可迭代对象进行逐个访问的过程。
可迭代对象是指实现了迭代器协议的对象，例如列表、元组、字符串等。 ↩︎
这是因为生成器对象在遍历完所有元素之后会进入停止状态，此时再调用 __next__ 方法会引发 StopIteration 异常(StopIteration 异常是一个内置异常类，用于表示迭代器对象已经达到末尾，没有更多的元素可供迭代,也就是所谓的对象的元素没了) ↩︎
d.get(key,默认值) ↩︎