python三元表达式、迭代器、推导式、生成式_三元推导式

【一】三元表达式

（1）定义表达：

• result = 为真时的结果 if 条件判断 else 为假的结果
• 必须要有接受的对象

（2）作用

• 起到了缩减代码行数的作用
• 看着很简洁

（3）代码演示

a = 1
b = 2
# 普通方式
if a > b:
    result = a
else:
    result = b
print(result)

#三元表达式
result = a if a > b else b
print(result)
1
2
3
4
5
6
7
8
9
10
11
12
'
运行
运行

# 在元组中的用法
a, b = 1, 2
print(("tom", "lucy")[a < b])

# 在字典中的用法
a, b = 1, 2
print({True: "tom", False: "lucy"}[a < b])


# 三元运算符嵌套
a, b = 2, 3
print("a=b" if a == b else "a>b" if a > b else "a<b")

1
2
3
4
5
6
7
8
9
10
11
12
13
'
运行
运行

【二】迭代器

• 迭代器是用来迭代取值的工具， 迭代是重复反馈过程的活动
  • 通常目的是为了逼近所需要的目标或结果，每一次对过程的重复称为一次迭代
  • 而每一次迭代得到的结果作为下次迭代的初始值，单纯的重复并不是迭代
• 迭代器是Python提供的一种统一的、不依赖于索引的迭代取值方式，只要存在多个“值”，无论序列类型还是非序列类型都可以按照迭代器的方式取值

# 不是迭代过程
while True:
    print("hello")
    
# 是迭代过程
list1 = [1, 2, 3]
n = 0
while n < len(list1):
	print(list1[n])
    n += 1

1
2
3
4
5
6
7
8
9
10
11

【1】可迭代对象（iterable）

• 内置有__iter__方法的对象都是可迭代对象

int1 = 1	
int1.__iter__()			# 报错

float1 = 1.1
float1.__iter__()		# 报错

bool1 = True
bool1.__iter__()		# 报错

str1 = "tom"
str1.__iter__()			# <str_iterator object>

list1 = list("tom")
list1.__iter__()		# <list_iterator object>

set1 = set("tom")
set1.__iter__()			# <set_iterator object>

tuple1 = tuple("tom")
tuple1.__iter__()		# <tuple_iterator object>

dict1 = {"tom": "18"}
dict1.__iter__()		# <dict_iterator object>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

• 可迭代对象： 元组、字典、列表、集合、字符串
• 非可迭代对象：整型、布尔、浮点

【2】迭代器对象

• 调用obj.__iter__()方法，返回的结果就是一个可迭代对象（iterator）
• 迭代器对象是内置有iter和next方法的对象
  • 迭代器对象.iter()方法得到的仍然是迭代器本身
  • 迭代器.next()方法就会计算出迭代器中的下一个值

（1）获取迭代器对象的两种方式

str1 = "tom"

# __iter__()
str1_iter = str1.__iter__()

# iter()
str1_iter = iter(str1)
1
2
3
4
5
6
7
'
运行
运行

（2）迭代器对象取值的两种方式

str1 = "tom"
str1_iter = iter(str1)

# __next__()
value = str1.__next__()
print(value)				# t

# next()
value = next(str1)
print(value)				# o
1
2
3
4
5
6
7
8
9
10

（3）迭代器对象有哪些

• 字符串、列表、元组、集合、字典

# 字符串
str1 = 'tom'
str1_iter = iter(str1)		# <str_iterator object at>
value = next(str1_iter)		# t

# 列表
list1 = list('tom')
list1_iter = iter(list1)		# <list_iterator object at>
value = next(list1_iter)		# t

# 元组
tuple1 = tuple('tom')
tuple1_iter = iter(tuple1)		# <tuple_iterator object at>
value = next(tuple1_iter)		# t

# 集合
set1 = set('tom')
set1_iter = iter(set1)		# <set_iterator object at>
value = next(set1_iter)		# t

# 字典
dict1 = {'tom': "20"}
dict1_iter = iter(dict1)		# <dict_iterator object at>
value = next(dict1_iter)		# tom
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
'
运行
运行

【3】迭代器的优缺点

• 优点：惰性计算、支持无限序列、内存效率高、可迭代对象的抽象

• 缺点：只能单向前进、不支持索引、代码相对复杂、不易于复制

【三】推导式

（1）定义表达

• [表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]]
• {表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]}
• 后面的条件表达式可以没有

（2）作用

• 快速生成指定列表、集合等
• 书写简单、简洁
• 执行效率高

（3）代码演示

• 列表推导式

# 快速生成列表
number_list = [i for i in range(3)]
print(number_list)
# [0, 1, 2]

# 查看两个字符串的不同
a = "hello python"
b = "pycharm"
difference = [i for i in a if i not in b]
print(difference)
# ['e', 'l', 'l', 'o', ' ', 't', 'o', 'n']

# 嵌套循环
a = [1, 2, 3]
b = [1, 2, 3]
class_list = [i * j for i in a for j in b]
print(class_list)
# [1, 2, 3, 2, 4, 6, 3, 6, 9]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
'
运行
运行

• 字典推导式

# 快速生成字典
info_list = [["tom", 18], ["lucy", 12]]
info_dict = {key: value for key, value in info_list}
print(info_dict)
# {'tom': 18, 'lucy': 12}

# 不建议使用循环嵌套
class_dict = {f"{i}年级": f"{j}班" for i in range(1, 4) for j in range(1, 4)}
print(class_dict)
# {'1年级': '3班', '2年级': '3班', '3年级': '3班'}			#字典特性，键值唯一
1
2
3
4
5
6
7
8
9
10
'
运行
运行

• 集合推导式

# 快速生成集合
set1 = {i for i in range(1, 3)}
print(set1)
# {1, 2}
1
2
3
4
'
运行
运行

【四】生成式（生成器表达式）

• 上面你也许会思考为什么没有元组推导式呢
• 因为推导式外面是圆括号时，这是生成器表达式

（1）定义表达

• （表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]）
• 生成器是一种特殊的迭代器
• yield关键字
• next关键字

（2）作用

• 迭代器：生成器函数返回一个迭代器对象，可以使用for循环进行迭代，逐个访问生成的元素。这避免了一次性生成大量数据并占用大量内存的问题。
• 惰性计算：生成器仅在需要时生成值，即在迭代过程中按需计算。这对于处理大型数据集或无限序列非常有用，因为可以逐步生成元素，而不是一次性生成全部元素。
• 节省内存：由于生成器按需生成元素，因此在处理大型数据集时可以节省内存。它只在迭代过程中存储当前生成的元素，而不会一次性存储所有数据。
• 控制流程：生成器可以通过使用yield语句来控制生成元素的流程。可以根据条件判断、循环等控制结构来决定是否生成下一个元素。
• 协程支持：生成器函数可以与协程一起使用，实现异步编程和并发处理。

（3）代码解释

• （表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]）

number_list = (i for i in range(3))
print(number_list, type(number_list))
for i in number_list:
    print(i**i**i)
# <generator object <genexpr> at 0x000001FBAA212B90> <class 'generator'>
# 0
# 1
# 16
1
2
3
4
5
6
7
8
'
运行
运行

• yield关键字
  • yield和return
  • return语句用于从函数中返回一个值（可以是字典等，非必须一个元素），并立即结束函数的执行。
  • yield语句定义生成器函数。当函数执行到yield语句时，函数暂停，并将yield后面的表达式作为当前迭代的值返回，在当生成器调用next()或使用for循环时，函数从暂停的位置继续开始运行，直到遇见下一个yield

def function_yield():
    yield "Hello"
    yield "python"
    
# for循环
for info in function_yield():
    print(info)
# next()函数
info = function_yield()
print(info)
print(next(info))
print(info)
print(next(info))
next(info)              # 报错，因为已经下一个yield了
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• next关键字和close关键字

def eat(name):
    print("开始吃东西了")
    while True:
        food = yield
        print(f"{name}吃了{food}," + ('很好吃' if len(food) == 3 else '一般般'))

eat = eat("tom")
print(type(eat))            # generator
eat.__next__()              # 前进到yield关键字暂停
# next(eat)
# eat.send(None)
# print(type(eat))          # generator
eat.send("土豆丝")
eat.send("鸳鸯火锅")
eat.close()                 # 退出循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
'
运行
运行

（4）试题

• 斐波那契数列生成器

def fibonacci_generator(n):
    if n <= 0:
        return
    if n == 1:
        yield 1
        return
    if n == 2:
        yield 1
        yield 1
        return

    a, b = 1, 1
    yield a
    yield b
    for _ in range(n - 2):
        a, b = b, a + b
        yield b

fibonacci_list = fibonacci_generator(10)
for i in fibonacci_list:
    print(i)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
'
运行
运行

• 素数生成器

def prime_generator():
    yield 2
    list1 = [2]
    i = list1[0]
    while True:
        i += 1
        flag = True
        for num in list1:
            if int(i / num) == i/num:
                flag =False
        if flag:
            yield i
            list1.append(i)
            
gen = prime_generator()

# 生成并打印前10个素数
for _ in range(10):
    print(next(gen))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
'
运行
运行

from itertools import count

def prime_generator():
    primes = [2]
    yield 2

    for i in count(start=3, step=2):
        is_prime = all(i % prime != 0 for prime in primes if prime * prime <= i)
        if is_prime:
            primes.append(i)
            yield i

gen = prime_generator()

# 生成并打印前10个素数
for _ in range(10):
    print(next(gen))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
'
运行
运行