python笔记-进阶

目录

目录

参数传递

迭代器/生成器

比较

拷贝

进程VS线程VS协程

并发vs并行

装饰器

函数嵌套

函数装饰器

带参数的装饰器

带自定义参数的装饰器

类装饰器

枚举

上下文管理器



参数传递

Python 中参数的传递既不是值传递,也不是引用传递,而是赋值传递,或者是叫对象的引用传递

赋值或对象的引用传递,不是指向一个具体的内存地址,而是指向一个具体的对象

  • 如果对象是可变的,当其改变时,所有指向这个对象的变量都会改变。
  • 如果对象不可变,简单的赋值只能改变其中一个变量的值,其余变量则不受影响。

迭代器/生成器

迭代器 生成器
说明

实现了__iter__和__next__方法的对象都称为迭代器

迭代协议:

当任何可迭代对象传入到for循环或其他迭代工具中进行遍历时,迭代工具都是先通过iter函数获得与可迭代对象对应的迭代器,然后再对迭代器调用next函数,不断的依次获取元素,并在捕捉到StopIteration异常时确定完成迭代

两种方式:

  • 普通函数使用了 yield 语句返回结果
  • 生成器表达式

对比
  • 迭代器和列表的区别:

列表一次性加载所有元素到内存中,而迭代器是以延迟计算的方式返回元素,等到调用next时才返回元素

  • 所有容器都是可迭代的,例如list、dict、tuple、set等

  • 列表推导式VS生成器表达式:

列表推导式一次性产生所有结果,而生成器表达式等到调用next时才返回元素

  • 生成器是一种特殊的迭代器
特点

  • 迭代器不可回退
  • 文件对象既是迭代器,又是可迭代对象
生成器只能遍历一次
优点
  • 减少内存
  • 提高代码可读性
python笔记-进阶_第1张图片
举例
  • 将可迭代对象--->迭代器:(iter()函数)
L = [2,3,4]
I = iter(L)
  • 读取文件:(一次读一行)
f = open('myfile.txt')
print(next(f))
print(next(f))


-->
hello text file
goodbyt text file
  • 迭代器实现斐波那契数列:
class Fib:
    def __init__(self):
        self.prev = 0
        self.curr = 1

    def __iter__(self):
        return self

    def __next__(self):
        self.curr, self.prev = self.prev + self.curr, self.curr
        return self.curr

fib = Fib()
for i in range(10):
    print(next(fib))

  • 生成器表达式:(使用括号)
g = (x*2 for x in range(10))
  • 生成器实现斐波那契数列:
def fib():
    prev, curr = 0, 1
    while True:
        yield curr
        curr, prev = prev + curr, curr

f = fib()
for i in range(10):
    print(next(f))



 

比较

== is
说明 比较对象之间的值是否相等
  • 比较的是对象的身份标识是否相等,即它们是否是同一个对象,是否指向同一个内存地址
  • 操作符'is'的速度效率,通常要优于'=='
其他 出于对性能优化的考虑,Python 内部会对 -5 到 256 的整型维持一个数组,起到一个缓存的作用,所以这部分数据用is比较,结果为true

拷贝

赋值 浅拷贝 深拷贝
使用 b=a
  • 切片操作:b = a[:]
  • 工厂函数:b = list(a)、b =set(a)...
  • copy 模块中的 copy 函数:b=a.copy()
b=copy.deepcopy(a)
说明
  • python笔记-进阶_第2张图片对象的赋值即对象引用,他们指向同一片内存,b 不过是 a 的别名,是引用,它们的id是一样的
  • 值和地址都是一样的
  • python笔记-进阶_第3张图片浅拷贝会创建新对象,其内容非原对象本身的引用,而是原对象内第一层对象的引用
  • 浅拷贝对于一维列表而言和深拷贝一样,而对于多维列表,修改B的一维内容时A不会变化;而修改高维内容时A也会随之变化
python笔记-进阶_第4张图片包含对象里面的子对象的拷贝,原始对象的改变不会造成深拷贝里任何子元素的改变
举例

import copy
a = [1, 2, 3, 4, ['a', 'b']] #原始对象
 
b = a                       #赋值,传对象的引用
c = copy.copy(a)            #对象拷贝,浅拷贝
d = copy.deepcopy(a)        #对象拷贝,深拷贝
 
a.append(5)                 #修改对象a
a[4].append('c')            #修改对象a中的['a', 'b']数组对象
 
print( 'a = ', a )
print( 'b = ', b )
print( 'c = ', c )
print( 'd = ', d )


# 输出结果
# ('a = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5])
# ('b = ', [1, 2, 3, 4, ['a', 'b', 'c'], 5])
# ('c = ', [1, 2, 3, 4, ['a', 'b', 'c']])
# ('d = ', [1, 2, 3, 4, ['a', 'b']])

进程VS线程VS协程

说明 特点
进程 进程是一个实体,是一个具有独立功能的程序在某个数据集上的一次运行活动
  • 动态性:动态产生、动态消亡
  • 独立性:是系统分配资源和调度的基本单元
  • 并发性:可以和其他进程并发执行
线程 线程是进程中的一个实体,是被系统独立调度和分派的基本单位
  • 同一进程中的多个线程并发执行,这些线程共享进程所拥有的资源
  • 进程是CPU资源分配的基本单位,线程是独立运行和独立调度的基本单位
  • 一个进程包含若干个线程线程的调度与切换比进程快很多
协程 协程是一种比线程更加轻量级的存在,协程不被操作系统内核管理,协程是完全由程序控制的

协程不需要多线程的锁机制,因为只有一个线程,不存在变量冲突

并发vs并行

说明 适用场景
并发 同一时刻,只有一个线程/任务在执行,线程和任务相互切换进行 适用io操作频繁的场景
并行 多个进程同时进行 适用cpu计算复杂的场景

如果是 I/O bound,并且 I/O 操作很慢,需要很多任务 / 线程协同实现,那么使用 Asyncio 更合适。

如果是 I/O bound,但是 I/O 操作很快,只需要有限数量的任务 / 线程,那么使用多线程就可以了。

如果是 CPU bound,则需要使用多进程来提高程序运行效率。

装饰器

函数嵌套

装饰器可以嵌套使用,执行顺序从里到外


@decorator1
@decorator2
@decorator3
def func():
    ...

执行顺序等价于:
decorator1(decorator2(decorator3(func)))

函数装饰器

带参数的装饰器


def decorator_a(func):
    def wrapper(message):
        print('wrapper of decorator')
        func(message)
    return wrapper


@decorator_a
def greet(message):
    print(message)


greet('hi')

# 输出
wrapper of decorator
hi

带自定义参数的装饰器


def repeat(num):
    def decorator_a(func):
        def wrapper(*args, **kwargs):
            for i in range(num):
                print('wrapper of decorator')
                func(*args, **kwargs)
        return wrapper
    return decorator_a


@repeat(4)
def greet(message):
    print(message)

greet('hello world')

# 输出:
wrapper of decorator
hello world
wrapper of decorator
hello world
wrapper of decorator
hello world
wrapper of decorator
hello world

类装饰器

类装饰器主要依赖于函数__call__(),每当你调用一个类的示例时,函数__call__()就会被执行一次

eg:


class Count:
    def __init__(self, func):
        self.func = func
        self.num_calls = 0

    def __call__(self, *args, **kwargs):
        self.num_calls += 1
        print('num of calls is: {}'.format(self.num_calls))
        return self.func(*args, **kwargs)

@Count
def example():
    print("hello world")

example()

# 输出
num of calls is: 1
hello world

example()

# 输出
num of calls is: 2
hello world

...

函数被装饰以后,它的元信息会改变,为了解决这个问题,我们使用内置的装饰器@functools.wrap,帮助保留原函数的元信息

eg:


import functools

def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print('wrapper of decorator')
        func(*args, **kwargs)
    return wrapper
    
@my_decorator
def greet(message):
    print(message)

greet.__name__

# 输出
'greet'

枚举

定义:

from enum import Enum

@unique
class Role(Enum):
    father = 1
    mother = 2
    sister = 3
 

使用:


#调用枚举成员的 3 种方式
print(Role.father)
print(Role['father'])
print(Role(1))

-->
Role.father
Role.father
Role.father


#调取枚举成员中的 value 和 name
print(Role.father.value)
print(Role.father.name)

-->
1
father


#遍历枚举类中所有成员的 2 种方式
for role in Role:
    print(Role)

-->
Role.father
Role.mother
Role.sister

注意事项:

  • 枚举类中各个成员的值,不能在类的外部做任何修改
  • Python 枚举类中各个成员必须保证 name 互不相同,但 value 可以相同
  • 借助 @unique 装饰器,这样当枚举类中出现相同值的成员时,程序会报 ValueError 错误

上下文管理器

作用:防止资源泄露,释放系统资源,提高系统安全性

使用场景:文件的打开关闭、数据库的连接关闭、使用释放锁

用法:with 语句(有了with语句,就不用写关闭代码了)

打开文件

with open('test.txt', 'w') as f: 
    f.write('hello')

等同于


f = open('test.txt', 'w')
try:
    f.write('hello')
finally:
    f.close()

实现:

        基于类的上下文管理器:

用类来创建上下文管理器时,必须保证这个类包括方法”__enter__()”和方法“__exit__()”。其中,方法“__enter__()”返回需要被管理的资源,方法“__exit__()”里通常会存在一些释放、清理资源的操作


class FileManager:
    def __init__(self, name, mode):
        print('calling __init__ method')
        self.name = name
        self.mode = mode 
        self.file = None
        
    def __enter__(self):
        print('calling __enter__ method')
        self.file = open(self.name, self.mode)
        return self.file


    def __exit__(self, exc_type, exc_val, exc_tb):
        print('calling __exit__ method')
        if self.file:
            self.file.close()
            
with FileManager('test.txt', 'w') as f:
    print('ready to write to file')
    f.write('hello world')
    
## 输出
calling __init__ method
calling __enter__ method
ready to write to file
calling __exit__ method

        基于生成器的上下文管理器:

使用基于生成器的上下文管理器时,我们不再用定义“__enter__()”和“__exit__()”方法,但请务必加上装饰器 @contextmanager


from contextlib import contextmanager

@contextmanager
def file_manager(name, mode):
    try:
        f = open(name, mode)
        yield f
    finally:
        f.close()
        
with file_manager('test.txt', 'w') as f:
    f.write('hello world')

1、pipfile中引包,*表示任意版本的包,为防止兼容性问题,最好指定包版本,不用通配符

2、若pipfile文件中指定安装某插件报错,可尝试在jenkinsfile中强制安装

参考:https://blog.csdn.net/sinat_38682860/article/details/108681726?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-4.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-4.control

你可能感兴趣的:(python,python)