Python数据类型底层、推导、生成器、迭代器、装饰器

最新推荐文章于 2024-08-15 01:55:01 发布
最新推荐文章于 2024-08-15 01:55:01 发布
阅读量161 收藏
点赞数
分类专栏： Python 文章标签： python 开发语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42382758/article/details/125866946
版权
本文详细讲解了Python中列表、字典、字符串的底层实现，比较浅拷贝与深拷贝的区别，以及迭代器和装饰器在代码中的应用。通过实例演示列表操作的特性，包括浅拷贝导致的意外行为，以及如何使用深拷贝解决可变类型问题。
摘要由CSDN通过智能技术生成

系列文章：

文章目录

数据类型的底层实现

1、列表的复制

1.1、浅拷贝复制的奇怪现象

对拷贝前后的两个列表进行操作

  1. 对 list_2 进行操作
list_1 = [1, [22, 33, 44], (5, 6, 7), {"name": "Sarah"}]
# 浅拷贝
list_2 = list_1.copy()
list_2.append(55)
print("list_1:  ", list_1) 
#list_1:   [1, [22, 33, 44], (5, 6, 7), {'name': 'Sarah'}]

print("list_2:  ", list_2) 
#list_2:   [1, [22, 33, 44], (5, 6, 7), {'name': 'Sarah'}, 55]
  1. 对 list_2[1] 进行操作
list_1 = [1, [22, 33, 44], (5, 6, 7), {"name": "Sarah"}]
# 浅拷贝
list_2 = list_1.copy()
list_2[1].append(55)
print("list_1:  ", list_1) 
#list_1:   [1, [22, 33, 44, 55], (5, 6, 7), {'name': 'Sarah'}]

print("list_2:  ", list_2)
#llist_2:   [1, [22, 33, 44, 55], (5, 6, 7), {'name': 'Sarah'}]

1.2、列表的底层实现

  1. 新增元素
list_1 = [1, [22, 33, 44], (5, 6, 7), {"name": "Sarah"}]
list_2 = list(list_1) # 浅拷贝  与list_1.copy()功能相同
list_1.append(100)
list_2.append("n")
print("list_1:  ", list_1) 
#list_1:   [1, [22, 33, 44], (5, 6, 7), {'name': 'Sarah'}, 100]

print("list_2:  ", list_2) 
#list_2:   [1, [22, 33, 44], (5, 6, 7), {'name': 'Sarah'}, 'n']
  1. 修改元素
list_1[0] = 10
list_2[0] = 20
print("list_1:  ", list_1) 
#list_1:   [10, [22, 33, 44], (5, 6, 7), {'name': 'Sarah'}, 100]

print("list_2:  ", list_2) 
#list_2:   [20, [22, 33, 44], (5, 6, 7), {'name': 'Sarah'}, 'n']
  1. 对列表型元素进行操作
list_1[1].remove(44)
list_2[1] += [55,66]
print("list_1:  ", list_1) 
# list_1:   [10, [22, 33, 55, 66], (5, 6, 7), {'name': 'Sarah'}, 100]

print("list_2:  ", list_2) 
#list_2:   [20, [22, 33, 55, 66], (5, 6, 7), {'name': 'Sarah'}, 'n']

结果表明：对列表型元素进行操作，两个表的列表型元素都同时改变

  1. 对元组型元素进行操作
list_2[2] += (8,9)
print("list_1:  ", list_1) 
#list_1:   [10, [22, 33, 55, 66], (5, 6, 7), {'name': 'Sarah'}, 100]

print("list_2:  ", list_2) 
#list_2:   [20, [22, 33, 55, 66], (5, 6, 7, 8, 9), {'name': 'Sarah'}, 'n']

元组是不可变的！
对元组类型元素进行操作，两个表是独立的，互不影响
5. 对字典型元素进行操作

list_1[-2]["age"] = 18 
print("list_1:  ", list_1) 
#list_1:   [10, [22, 33, 55, 66], (5, 6, 7), {'name': 'Sarah', 'age': 18}, 100]

print("list_2:  ", list_2) 
#list_2:   [20, [22, 33, 55, 66], (5, 6, 7, 8, 9), {'name': 'Sarah', 'age': 18}, 'n']

结论同列表

1.3、引入深拷贝

浅拷贝后：
针对不可变元素（数字、字符串、元组）的操作，两个列表互不影响
针对可变元素（列表、集合、字典）的操作，列表中的元素是有影响的

引入深拷贝
深拷贝将所有层级的相关元素全部复制，完全分开，渭泾分明，避免了上述问题

import copy

list_1 = [1, [22, 33, 44], (5, 6, 7), {"name": "Sarah"}]
list_2 = copy.deepcopy(list_1)
list_1[-1]["age"] = 18
list_2[1].append(55)

print("list_1:  ", list_1) #list_1:   [1, [22, 33, 44], (5, 6, 7), {'name': 'Sarah', 'age': 18}]
print("list_2:  ", list_2) #list_2:   [1, [22, 33, 44, 55], (5, 6, 7), {'name': 'Sarah'}]

2、字典

2.1、快速的查找

import time
ls_1 = list(range(1000000))
# [-10]*500 是初始化值为-10的长度为500的list, 之后使用+ 拼接两个list
# 最终ls_2 长度是500 + 500
ls_2 = list(range(500))+[-10]*500

start = time.time()
count = 0
for n in  ls_2:
    if n in ls_1:
        count += 1
end = time.time()
print("查找{}个元素，在ls_1列表中的有{}个，共用时{}秒".format(len(ls_2), count, end-start))
#查找1000个元素，在ls_1列表中的有500个，共用时3.092348575592041秒

import  time
d = {i: i for i in range(1000000)}
ls_2 = list(range(500))+[-10]*500

start = time.time()
count = 0
for n in ls_2:
    try:
        d[n]
    except:
        pass
    else: count += 1
end = time.time()
print("查找{}个元素，在ls_1列表中的有{}个，共用时{}秒".format(len(ls_2), count,round(end-start)))
# 查找1000个元素，在ls_1列表中的有500个，共用时0秒

2.2、字典的底层实现

字典的创建过程

  1. 第一步：创建一个散列表（稀疏数组N >> n）
    d = {}
  2. 第二步：通过hash() 计算键的散列值
print(hash("python"))
print(hash(1024))
print(hash((1,2)))
-4771046564460599764
1024
3713081631934410656
d["age"] = 18    # 增加键值对的操作，首先会计算键的散列值hash("age")
print(hash("age"))
  1. 第三步根据计算的散列值确定其在散列表中的位置
    极个别时候，散列值会发生冲突，则内部有相应的解决冲突的办法
  2. 在该位置上存入值

键值对的访问过程

d["age"]
  1. 第一步：计算要访问的键的散列值
  2. 第二步：根据计算的散列值，通过一定的规则，确定其在散列表中的位置
  3. 第三步：读取该位置上存储的值
    如果存在，，则返回该值
    如果不存在，则报错 KeyError

小结

  1. 字典数据类型，以空间换时间（空间利用率低），实现类快速地数据查找
  2. 因为散列值对应位置的顺序与键在字典中显示的顺序可能不同，因此表现出字典是无序的
    如果N=n 会产生很多位置冲突

3、字符串

通过紧凑数组实现字符串的存储

  • 数据在内存中是连续存放的，效率高
  • 同为序列类型，列表采用引用数组，而字符串采用紧凑数组

3.1、可变类型与不可变类型

不可变类型：数字、元组、字符串
在生命周期中保持内容不变
当改变了时，会有新的id,实际上创建了一个新的对象

x= 1
y = "Python"
print("x id:", id(x)) #x id: 1447911844144
print("y id:", id(y)) #y id: 1447917164912
x += 2
y += "3.7"
print("x id:", id(x)) #x id: 1447911844208
print("y id:", id(y)) #y id: 1447917208304

元组并不是总是不可变的

t = (1,[2])
print(id(t)) #2524431430976
t[1].append(3) 
print(id(t))#2524431430976
print(t) #(1, [2, 3])

可变类型：列表、字典、集合
id 保持不变，但里面的内容可以变

ls = [1, 2, 3]
d = {"Name": "Sarah", "Age": 18}

print("ls id:", id(ls)) #ls id: 2864434660288
print("d id:", id(d)) #d id: 2864434589056
ls += [4, 5]
d_2 = {"Sex": "female"}
d.update(d_2)    # 把d_2中的元素更新到d中
print("ls id:", id(ls)) #ls id: 2864434660288
print("d id:", id(d)) #d id: 2864434589056

4、列表操作的几个例子

4.1、删除列表中特定的元素

  1. 法1 存在运算删除法
alist = ["d", "d", "d", "2", "2", "d" ,"d", "4"]
s = "d"
while True:
    if s in alist:
        alist.remove(s)
    else:
        break
  1. 法2 一次性遍历元素执行删除
alist = ["d", "d", "d", "2", "2", "d" ,"d", "4"]
s = "d"
for i in alist:
    if i == s:
        alist.remove(s) # remove（s） 删除列表中第一次出现的该元素
print(alist) #['2', '2', 'd', 'd', '4']

解决方法：使用负向索引

alist = ["d", "d", "d", "2", "2", "d" ,"d", "4"]
s = "d"
for i in range(-len(alist),0):
    if alist[i] == s:
        alist.remove(alist[i])
print(alist) #['2', '2', '4']

4.2、多维列表的创建

print([0]*10) #[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
print([[0]*10]*3)
# [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]

ls[0][0] = 1
print(ls)
# [[1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#  [1, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
#  [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]]

ls = [[0]*10 for i in range(3)]
print(ls)
# [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
#  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
#  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
ls[0][0]=1
print(ls)
# [[1, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
#  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
#  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]

4.4 列表推导

解析语法的基本结构—以列表解析为例（也称为列表推导）

[expression for value in iterable if conditihon]
三要素：表达式、可迭代对象、if条件（可选）
执行过程

  1. 从可迭代对象中拿出一个元素
  2. 通过if条件（如果有的话），对元素进行筛选。
    若通过筛选，则把元素传递给表达式
    若未通过，则进入步骤1，进入下一次迭代
  3. 将传递给表达式的元素，带入表达式进行处理，产生一个结构
  4. 将步骤3产生的结果作为列表的一个元素进行存储
  5. 重复步骤1-4直到迭代对象迭代结束，返回新创建的列表

等价于如下过程：

# 等价于如下代码
result = []
for value in iterale:
    if condition:
        result.append(expression)

【例】求20以内奇数的平方

squares = []
for i in range(1,21):
    if i%2 == 1 :
        squares.append(i**2)
print(squares) #[1, 9, 25, 49, 81, 121, 169, 225, 289, 361]

squares= [i**2 for i in range(1,21) if i%2==1]
print(squares) #[1, 9, 25, 49, 81, 121, 169, 225, 289, 361]

支持多变量

x = [1,2,3]
y = [1,2,3]

result = [i*j for i,j in zip(x,y)]
print(result)

支持嵌套循环

colors = ["black", "white"]
sizes = ["S", "M", "L"]
tshirts = ["{} {}".format(color, size) for color in colors for size in sizes]
print(tshirts)
#['black S', 'black M', 'black L', 'white S', 'white M', 'white L']

4.5 字典推导

解析语法构造字典（字典推导）

squares = {i: i**2 for i in range(5)}
for k, v in squares.items():
    print(k, ":", v,end=",")#0 : 0,1 : 1,2 : 4,3 : 9,4 : 16,

4.6集合推导

squares = {i**2 for i in range(5)}
print(squares)#{0, 1, 4, 9, 16}

4.7 生成器表达式

squares = (i**2 for i in range(10))
print(squares) #<generator object <genexpr> at 0x00000204790BF0B0>

colors = ["black", "white"]
sizes = ["S", "M", "L"]
tshirts = ("{} {}".format(color , size) for color in colors for size in sizes)
print(tshirts) #<generator object <genexpr> at 0x000002EF6451F0B0>
for tshirt in tshirts:
    print(tshirt)
# black S
# black M
# black L
# white S
# white M
# white L

4.8条件表达式

expr1 if condition else expr2
【例】将变量n的绝对值赋值给变量x

n = -10
if n >= 0:
    x = n
else: x = -n
print(x) #10

n = -10
x = n if n >= 0 else  -n
print(x) #10

条件表达式和解析语法简单实用、运行速度相对更快一些

三大神器

1、生成器

ls = [i**2 for i in range(1,100001)]
for i in ls:
    pass

缺点：占用大量内存

生成器

  • List item采用惰性计算方式
  • 无需一次性存储海量数据
  • 一边执行一边计算，只计算每次需要的值
  • 实际上一直在执行next()操作，直到无值可取

1.1生成器表达式

  • 海量数据，不需存储
squares = (i**2 for i in range(100000))
for i in squares:
    pass
  • 求0~100的和

无需显示存储全部数据，节省内存

sum((i for i in range(101))) #5050

1.2 生成器函数—yield

  • 生产斐波那契数列
    数列前两个元素为1,1 之后的元素为其前两个元素之和
def fib(max):
    n ,a, b = 0, 1, 1
    while n < max:
        print(a)
        a, b = b, a + b
        n += 1
fib(5)
1
1
2
3
5

构造生成器函数
在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句继续执行

def fib(max):
    n ,a, b = 0, 1, 1
    while n < max:
        yield a
        a, b = b, a + b
        n += 1
print(fib(5)) #<generator object fib at 0x000001FEF92CF0B0>
for i in  fib(5):
    print(i)
1
1
2
3
5

2.迭代器

1、可迭代对象

可迭代对象：可直接作用于for循环的对象统称为可迭代对象：Iterable
(1) 列表、元组、字符串、字典、集合、文件

from collections.abc import Iterable
# Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated since Python 3.3, and in 3.10 it will stop working
print(isinstance([1, 2, 3],Iterable)) #True
print(isinstance((1, 2, 3),Iterable)) #True
print(isinstance({1, 2, 3},Iterable)) #True
print(isinstance("123",Iterable)) #True
print(isinstance({1:1, "2":2},Iterable)) #True

(2) 生成器

from collections.abc import  Iterable
squares = (i**2 for i in range(5))
print(isinstance(squares, Iterable)) #True

生成器不但可以用于for循环，还可以被next()函数调用

from collections.abc import  Iterable
squares = (i**2 for i in range(5))
print(next(squares)) 
print(next(squares))
print(next(squares))
print(next(squares))
print(next(squares))
print(next(squares))
0
1
4
9
16

直到没有数据可取，抛出StopIteration

print(next(squares))
Traceback (most recent call last):
  File "E:\code\deeplea\pytorchlearn\ForTest\test.py", line 8, in <module>
    print(next(squares))
StopIteration

2、迭代器

可以被next()函数调用并不断返回下一个值，直到没有数据可取的对象称为迭代器: Iterator
可以使用 isinstance() 判断一个对象是否是Iterator对象
注意 可迭代对象：Iterable 用 isinstance([1, 2, 3],Iterable)判断
迭代器：Iterator 用 isinstance([1, 2, 3], Iterator)
（1）生成器都是迭代器

from collections.abc import Iterator
sequares = (i**2 for i in range(5))
print(isinstance(sequares, Iterator)) #True

（2）列表、元组、字符串、字典、集合不是迭代器Iterator，但它们是可迭代对象Iterable

from collections.abc import  Iterator

print(isinstance([1, 2, 3], Iterator)) #False

可以通过 iter(Iterable) 创建迭代器

print(isinstance(iter([1, 2, 3]),Iterator)) #True

for item in Iterable 等价于:
先通过iter()函数获取可迭代对象Iterable的迭代器，然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration异常后循环结束。
（3）zip enumetate 等itertools里的函数都是迭代器

from collections.abc import Iterator

x = [1, 2]
y = ["a", "b"]
print(zip(x ,y)) #<zip object at 0x0000019095162E00>
for i in zip(x, y):
    print(i)
print(isinstance(zip(x, y),Iterator)) #True

from collections.abc import Iterator

numbers = [1, 2]
print(enumerate(numbers)) #<enumerate object at 0x000001AF415C2E00>
for i in enumerate(numbers):
    print(i)
    # (0, 1)
    # (1, 2)
print(isinstance(enumerate(numbers),Iterator)) #True

（4）文件是迭代器

with open("测试文件.txt", "r", encoding = "utf-8") as f:
    print(isinstance(f, Iterator))#True

（5）迭代器是可耗尽的

squares = (i**2 for i in range(3))
for square in squares:
    print(square)
# 0
# 1
# 4

for square in squares:
    print(square) #无输出

（6）range() 不是迭代器

from collections.abc import Iterator
numbers  = range(10)
print(isinstance(numbers,Iterator)) #False
print(len(numbers)) ## 有长度
print(numbers[0]) # 可索引
print(9 in numbers) # 可存在计算
next(numbers) # 不可被next()调用 TypeError: 'range' object is not an iterator

不会被耗尽

for number in numbers:
    print(number) #有输出
    
for number in numbers:
    print(number) #有输出

可以称range() 为懒序列，它是一种序列，但是并不包含任何内存中的内容，而是通过计算来回答问题

3.装饰器

1、需求的提出
（1）需要对已开发上线的程序添加某些功能
（2）不能对程序中函数的源代码进行修改
（3）不能改变程序中函数的调用方式

2、函数对象
函数是Python中的第一类对象
（1）可以把函数赋值给变量
（2）对该变量进行调用，可实现原函数的功能

def square(x):
    return x**2
print(type(square)) #<class 'function'>
pow_2 = square #可以理解给这个函数起了个别名
print(pow_2(5)) #25
print(square(5)) #25

可以将函数作为参数进行传递

3、高阶函数
（1）接受函数作为参数
（2）或者返回一个函数
满足上述条件之一的函数称为高阶函数

def square(x):
    return x**2

def pow_2(fun):
    return  fun

f = pow_2(square)
print(f(8)) #64

print(f == square) #True

4、嵌套函数
在函数内部定义一个函数

def outer():
    print("outer is running")

    def inner():
        print("inner is running")

    inner()

outer()
# outer is running
# inner is running

5、闭包

def outer():
    x = 1
    z = 10
    
    def inner():
        y = x+100
        return y, z
        
    return inner


f = outer()                # 实际上f包含了inner函数本身+outer函数的环境
print(f)
<function outer.<locals>.inner at 0x000001BE11B1D730>

print(f.__closure__)         # __closure__属性中包含了来自外部函数的信息
for i in f.__closure__:
    print(i.cell_contents)
(<cell at 0x000001BE0FDE06D8: int object at 0x00007FF910D59340>, <cell at 0x000001BE0FDE0A98: int object at 0x00007FF910D59460>)
1
10

res = f()
print(res)
(101, 10)

闭包：延伸了作用域的函数
如果一个函数定义在另一个函数的作用域内，并且引用了外层函数的变量，则该函数称为闭包，闭包是由函数及其相关的引用环境组合而成的实体（即：闭包=函数+引用环境）

  • 一旦在内层函数重新定义了相同名字的变量，则变量称为局部变量
def outer():
    x = 1

    def inner():
        # nonlocal  x
        x = x+100  #显示代码有误：不能解析x
        return x

    return inner

f = outer
f()

def outer():
    x = 1

    def inner():
        nonlocal  x
        x = x+100
        return x

    return inner

f = outer
f()

6、一个简单的装饰器
嵌套函数实现

import time
def timer(func):
    def inner():
        print("inner run")
        start = time.time()
        func()
        end = time.time()
        print("{} 函数运行用时{:.2f}秒".format(func.__name__, (end-start)))

    return inner

def f1():
    print("f1 run")
    time.sleep(1)

# f1 包含inner() 和timer的环境，如传递过来的参数
f1 = timer(f1) 
f1()
# inner run
# f1 run
# f1 函数运行用时1.01秒

语法糖

import time
def timer(func):
    def inner():
        print("inner run")
        start = time.time()
        func()
        end = time.time()
        print("{} 函数运行用时{:.2f}秒".format(func.__name__, (end-start)))

    return inner

@timer #相当于实现类f1 = timer(f1)
def f1():
    print("f1 run")
    time.sleep(1)

f1()
# inner run
# f1 run
# f1 函数运行用时1.01秒

7、装饰有参函数

import time

def timer(func):
    def inner(*args, **kwargs):
        print("inner run")
        start = time.time()
        func(*args, **kwargs)
        end = time.time()
        print("{} 函数运行用时{:.2f}秒".format(func.__name__, (end - start)))

    return inner

@timer
def f1(n):
    print("f1 run")
    time.sleep(n)

f1(2)
# inner run
# f1 run
# f1 函数运行用时2.00秒

装饰函数有返回的情况

import time

def timer(func):
    
    def inner(*args, **kwargs):
        print("inner run")
        start = time.time()
        res = func(*args, **kwargs)
        end = time.time()
        print("{} 函数运行用时{:.2f}秒".format(func.__name__, (end - start)))
        return  res

    return inner

@timer
def f1(n):
    print("f1 run")
    time.sleep(n)
    return "wake up"

res = f1(2)
print(res)
# inner run
# f1 run
# f1 函数运行用时2.00秒
# wake up

8、带参数的装饰器
装饰器本身要传递一些额外参数

  • 需求：有时需要统计绝对时间，有时需要统计绝对时间的2倍
宁然也
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python中的推导式、生成器
景天科技苑
01-10 1187
通过一行循环判断遍历出一些列数据的方法叫做推导式 推导式comprehensions（又称解析式），是Python的一种独有特性。 推导式是可以从一个数据序列构建另一个新的数据序列的结构体。
Python学习之-迭代器和生成器
Summer的博客
04-04 1934
在Python中，迭代器（Iterator）和生成器（Generator）是实现迭代协议的对象，用于遍历集合中的元素。它们之间有联系，但也有一些关键的差异。迭代器和生成器都允许你对一系列数据进行迭代，但生成器提供了一种更简便，内存高效的方式来实现迭代器的功能。当你需要一个简单的迭代器并且不想实现类时，生成器是一个非常好的选择。适用场合包括处理大数据流、文件处理、网络通信等等。
Python迭代器和生成器
岳来的博客
08-22 692
Python迭代器和生成器
【python】迭代器、生成器、装饰器
sinat_41752325的博客
09-19 1117
python中 迭代器/生成器/装饰器介绍
Python中的迭代器与生成器提高性能的秘密武器
一键难忘的博客
03-18 2433
在Python编程中，迭代器和生成器是提高性能和减少内存消耗的重要工具。它们不仅简化了代码结构，而且在处理大型数据集时具有明显的优势。本文将介绍迭代器和生成器的概念，以及它们如何成为Python中的秘密武器，提高程序的效率。
【Python】高级语法：推导式、迭代器、生成器、装饰器、上下文管理器
黎明总是如期而至
06-20 1048
我辈李想：文章原创，转载时请务必加上、作者信息和本声明。
3.0 Python 迭代器与生成器
CSDN
08-12 1万+
当我们需要处理一个大量的数据集合时，一次性将其全部读入内存并处理可能会导致内存溢出。此时，我们可以采用迭代器`Iterator`和生成器`Generator`的方法，逐个地处理数据，从而避免内存溢出的问题。 迭代器是一个可以逐个访问元素的对象，它实现了`python`的迭代协议，即实现了`__iter__()`和`__next__()`方法。通过调用`__next__()`方法，我们可以逐个访问迭代器中的元素，直到所有元素都被访问完毕，此时再次调用`__next__()`方法会引发`StopIterati
Python：列表推导式、生成器、迭代器
weixin_44330955的博客
08-02 448
1. 列表推导式 列表推导式是通过旧的列表通过公式推导出新的列表 还有集合推导式、字典推导式，与列表推导式类似 格式为： [表达式 for 变量 in 旧列表] [表达式 for 变量 in 旧列表 if条件] # 过滤掉长度小于或等于3的人名 names = ['tom','lily','abc','jack','steven'] result = [name for name in names if len(name) > 3] print(result) #['lily', 'jack', .
python之迭代器和生成器全解--包含实现原理及应用场景
热门推荐
yifengchaoran的专栏
02-20 13万+
在日常提升Python基本功的时候，可能会被Python的迭代器和生成器搞晕，之前在学习和使用时，本来for in 循环体和enumerate函数用的飞起，觉得自己已经彻底了解了Python的迭代特性，但接触了迭代器和生成器后，突然感觉懵逼，大概率会被可迭代、迭代器、生成器等概念搞的不知所向，本文就是结合日常项目应用，对Python的迭代概念进行系统性的全面解析，包括其底层实现原理，还有一些常见的应用，希望能帮助更多人，同时也算作给自己梳理思路了。 一、基本概念 二、迭代器 三、生成器 四、基本应用
全面理解Python中的迭代器
南风以南
04-29 2601
迭代是一种重复获取数据集合中元素的过程，一次只获取一个元素，直到遍历完所有元素。在Python中，迭代通常用于遍历序列（如列表、元组）或任何可迭代对象。自定义迭代器允许我们创建自己的数据结构并以迭代方式访问其内容。在Python中，最常见的方式是通过生成器函数来实现。生成器函数是一种特殊的迭代器，使用yield语句暂停和恢复函数的执行。# 使用自定义迭代器print(num)itertools模块包含了许多有用的迭代器函数，如count()cycle()chain()等。例如，count()break。
一篇文章弄懂Python中的可迭代对象、迭代器和生成器
09-18
在Python编程语言中，了解可迭代对象、迭代器和生成器是至关重要的，因为它们构成了Python数据处理的核心机制。这篇文章将深入探讨这三个概念，并通过示例代码帮助理解它们的工作原理。 首先，**可迭代对象**是指...
Python列表推导式与生成器用法分析
09-20
Python列表推导式与生成器是Python编程中常用的两种构造数据结构和处理数据的方法。列表推导式是一种简洁且功能强大的方式，用于从其他列表快速生成新列表；生成器则是一种特殊的迭代器，它不会一次性生成所有数据，...
简单了解python 生成器 列表推导式 生成器表达式
09-18
Python中的生成器是一种高效的数据处理方式，它允许程序员在运行时动态生成序列，而不必将所有数据一次性存储在内存中。生成器本质上是迭代器，但它们由用户自定义，可以根据需要生成新的值。 生成器有两种主要的...
python 生成器和迭代器的原理解析
09-18
Python中的生成器和迭代器是两种非常重要的编程工具，它们在处理大数据集或节省内存方面具有显著优势。本文将深入解析这两种概念，并提供详细的实例来帮助理解。 首先，生成器（Generator）是一种特殊的迭代器，它...
解析Python中的生成器及其与迭代器的差异
09-21
生成器是Python中一种特殊的迭代器，它允许我们以一种非常高效的方式来处理数据。与传统的列表和其他集合相比，生成器最大的特点在于它能够“按需”生成数据，而不是一次性将所有数据都加载到内存中。这种特性使得...
【Python】入门到放弃之第九章《字典》
最新发布
MP13537560060的博客
08-15 627
这是本系列的第九章节内容，《字典》。在Python中，字典（Dictionary）是一种内置的数据结构，用于存储键值对（key-value pairs）。字典是可变的，意味着你可以在创建字典后添加、删除或修改其中的元素。字典的键（key）必须是唯一的，并且是不可变的（即，它们必须是不可变数据类型，如字符串、数字或元组，但不能是列表或字典等可变类型）。字典的值（value）则可以是任何数据类型，包括列表、元组、字典等。以上，就是Python中字典的全部内容。
【python学习】深入解析 `jq` 库：JSON 处理的利器
m0_54007171的博客
08-13 398
jq库是 Python 对流行的命令行工具jq的封装。它允许你直接在 Python 中使用jq的查询语言来处理 JSON 数据。借助jq，你可以轻松地对 JSON 数据进行过滤、选择、转换、聚合等操作，极大地简化了代码复杂度。
GraphRAG：复杂查询的知识图谱新框架
YeJuliaLi的博客
08-14 830
微软最近发布了名为 GraphRAG（Graphs + Retrieval Augmented Generation）的创新 RAG 框架，这是一个将文本提取、语义网络分析，与大语言模型（LLM）的提示和总结功能结合在一起的端到端系统，用于深入理解文本数据集。在对私有数据中的复杂文本信息进行文档分析时，GrahRAG 使用 LLM 生成的知识图谱来大幅提高问答性能。这里的私有数据集是指 LLM 没...
【Markdown】Markdown 中的语言简称
EleganceJiaBao的博客
08-12 981
以下是常见编程语言、脚本语言、标记语言等在 Markdown 中的语言简称以及相应的示例：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值