python高级特性

最新推荐文章于 2024-06-17 15:56:35 发布

小代灬

最新推荐文章于 2024-06-17 15:56:35 发布

阅读量92

点赞数

分类专栏： python 文章标签： python

本文链接：https://blog.csdn.net/qq_49564346/article/details/113879231

版权

python 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

# 练习
"""
知识点需求:
    1. 文件操作
    2. 字符串的分割操作
    3. 字典操作
功能需求:词频统计
    1. 读取song.txt文件   with open(filename) as f: content=f.read()
    2. 分析文件中的每一个单词，统计每个单词出现的次数。{"hello":2, "python":1, "java":1}
    - 分析文件中的每一个单词
    content = "hello python hello java"
    words = content.split()
    - 统计每个单词出现的次数- {"hello":2, "python":1, "java":1}
    # words = ['hello', 'python', 'hello', 'java']
    3. 获取出现次数最多的5个单词
"""
# 方法一
with open('doc/song.txt') as f:
    words = f.read().split()
result = {}
for word in words:
     if word in result:
         # result[word] = result[word] + 1
        result[word] += 1
     else:
         result[word] = 1
# # 友好打印信息
import pprint
pprint.pprint(result)

# 方法二
# 1. 加载文件中所有的单词
with open('doc/song.txt') as f:
    words = f.read().split()
# 2. 统计或排序
from collections import  Counter  #直接使用模板
counter = Counter(words)
result = counter.most_common(5)
print(result)

song.txt

在这里插入图片描述

一.生成式

# 1.列表生成式
# 列表生成式就是一个用来生成列表的特定语法形式的表达式。是Python提供的一种生成列表的简洁形式, 可快速生成一个新的list
# 需求: 生成100个验证码(4个字母组成的验证码)
import  string
import  random
codes = []
for count in range(100):
    code = "".join(random.sample(string.ascii_letters, 4))
    codes.append(code)
print(codes)

# 列表生成式优化版
codes = ["".join(random.sample(string.ascii_letters, 4)) for i in range(100)]
print(codes)

# 需求: 找出1-100之间可以被3整除的数。
nums = []
for num in range(1, 101):
    if num % 3 == 0:
        nums.append(num)
print(nums)
# 优化版
nums = [num for num in range(1, 101) if num % 3 == 0]
print(nums)

# 2.集合生成式
result = {i**2 for i in range(10)}
print(result)

# 3.字典生成式
result = {i:i**2 for i in range(10)}
print(result)

二.生成器

(一).什么叫生成器
在Python中,一边循环一边计算的机制,称为生成器:Generator。
(二).什么时候需要使用生成器
性能限制需要用到,比如读取一个10G的文件,如果一次性将10G的文件加载到内存处理的话(read方法),内存肯定会溢出;但使用生成器把读写交叉处理进行,比如使用(readline和readlines)就可以再循环读取的同时不断处理,这样就可以节省大量的内存空间
(三).生成器的特点是什么
解耦. 爬虫与数据存储解耦;
减少内存占用. 随时生产, 即时消费, 不用堆积在内存当中;
可不终止调用. 写上循环, 即可循环接收数据, 对在循环之前定义的变量, 可重复使用;
生成器的循环, 在 yield 处中断, 没那么占 cpu.

# 生成器实现的第一种方法: 将生成式改写成生成器，[]改成()
# 通过for循环， 依次计算并生成每一个元素。
# 如果要一个一个打印出来,可以通过next()函数获得生成器的下一个返回值
nums = (i**2 for i in range(10000))
print(nums)  #<generator object <genexpr> at 0x00000214EEE27270>
for num in nums:  #打印每个元素
	print (num)

# 生成器实现的第2种方法:yield关键字
#   return: 函数遇到return就返回，return后面的代码并不会执行。
#   yield:遇到yield则停止执行代码， 当再次调用next方法时，会从上次停止的地方继续执行，遇到yield停止
def login():
    print('step 1')   # 'step 1'
    yield 1           # output 1
    print('step 2')
    yield  2
    print('step 3')
    yield 3
# 如果函数里面有yield关键字，函数的返回值就是一个生成器
g = login()
print(next(g))
print(next(g))

(四)生成器、迭代器与可迭代对象关系
在这里插入图片描述

三.闭包

(一).什么是闭包?如何实现闭包?
闭包就是指有权访问另一个函数作用域中的变量的函数。
创建闭包最常见方式，就是在一个函数内部创建另一个函数。
(二).常见形式: 内部函数使用了外部函数的临时变量，且外部函数的返回值是内部函数的引用。闭包的一个常用场景就是装饰器。

# import  time
# start_time = time.time()  # 时间戳:从1970年1.1到现在经历的秒数
# time.sleep(2)
# end_time = time.time()    # 时间戳:从1970年1.1到现在经历的秒数
# print(end_time-start_time)


# 闭包:
#   1. 函数里面嵌套函数
#   2. 外部函数的返回值是内部函数的引用
#   3. 内部函数可以使用外部函数的变量
def timeit(name):
    def wrapper():
        print('wrapper ' + name)
    print('timeit')
    return wrapper

in_fun = timeit(name='test')  #in_fun实质上就是wrapper函数
in_fun()
# timeit
# wrapper test

四.装饰器

(一)装饰器的实现
装饰器指的是工具，而程序中的函数就是具备某一功能的工具，所以装饰器指的是为被装饰器对象添加额外功能的工具/函数
装饰器的实现必须遵循两大原则：
1.封闭: 对已经实现的功能代码块封闭。不修改被装饰对象的源代码
2.开放: 对扩展开发

# 1. 装饰器: 用来装饰函数的工具。
# 2. 功能: 在不改变源代码的情况下， 添加额外功能(eg: 计算运行时间, 记录日志，权限判断)的工具.
# 3. 如何实现装饰器? 基于闭包的

import time
def timeit(f):      # f=add
    def wrapper(x, y):
        start = time.time()
        result = f(x, y)   # f实质上是add函数
        end = time.time()
        print("函数运行的时间为: %.4f" %(end-start))
        return  result
    return wrapper

@timeit   # 1. 语法糖， add=timeit(add),使用装饰器
def add(x, y):
    return x + y

result = add(1, 3)
print(result)

"""
装饰器的万能模板:
def 装饰器名称(f):
    @wraps(f)  # 保留被装饰函数的属性信息和帮助文档
    def wrapper(*args, **kwargs):
        # 执行函数之前做的事情
        result = f(*args, **kwargs)
        # 执行函数之后做的事情
        return  result
    return  wrapper
"""

# 需求: 计算函数的运行时间
import  time
from functools import  wraps
def timeit(f):
    """计时器的装饰器"""
    @wraps(f)  # 保留被装饰函数的属性信息和帮助文档
    def wrapper(*args, **kwargs):
        """wrapper内部函数"""
        start = time.time()
        result = f(*args, **kwargs)
        end = time.time()
        print(f"函数{f.__name__}运行时间为{end-start}秒")
        return  result
    return  wrapper

@timeit
def login():
    """login desc"""
    print('login....')
    
print(help(login))

在这里插入图片描述

# 爬取图片
@timeit  #使用前面的计时器装饰器
def crawl():
    import  requests
    url = 'https://images.techhive.com/images/article/2013/09/linux-penguin-100055693-large.jpg'
    content = requests.get(url).content
    with open('doc/python.jpg', 'wb') as f:
        f.write(content)
        print("下载图片成功")
        
crawl()

在这里插入图片描述
(二)有参装饰器
无参装饰器只套了两层，有参装饰器: 套三层的装饰器;在装饰器外层嵌套一层

# 需求: 计算函数的运行时间
import  time
from functools import  wraps
def timeit(args='seconds'):  #传参,默认参数
    def desc(f):
        """计时器的装饰器"""
        @wraps(f)  # 保留被装饰函数的属性信息和帮助文档
        def wrapper(*args, **kwargs):
            """wrapper内部函数"""
            start = time.time()
            result = f(*args, **kwargs)
            end = time.time()
            if args == 'seconds':
                print(f"函数{f.__name__}运行时间为{end-start}秒")
            elif args == 'minutes':
                print(f"函数{f.__name__}运行时间为{(end-start)/60}分钟")
            return  result
        return  wrapper
    return  desc

@timeit(args='minutes')  # timeit()  @desc===> login=desc(login)
def login():
    """login desc"""
    print('login....')

(三)多个装饰器

def is_login(f):
    def wrapper1(*args, **kwargs):
        print('is_login, 用户是否登录')
        result = f(*args, **kwargs)
        return  result
    return  wrapper1

def is_permission(f):
    def wrapper2(*args, **kwargs):
        print('is_permission, 用户是否有权限')
        result = f(*args, **kwargs)
        return  result
    return  wrapper2

# 规则: 先装饰,再执行.被装饰的顺序是从下到上,执行装饰器内容是从上到下
@is_login           # show_hosts=is_login(wrapper2)   show_hosts=wrapper1
@is_permission      # 装饰顺序:show_hosts = is_permission(show_hosts) show_hosts=wrapper2
def show_hosts():
    print("显示所有的云主机")

show_hosts()
"""
执行顺序
--: show_hosts()
1). wrapper1()
2). wrapper2()
3). show_hosts()
"""

五.内置高阶函数

函数式编程的一个特点就是,允许把函数本身作为参数传入另一个函数,还允许返回一个函数

# 1. map函数
# map() 会根据提供的函数对指定序列做映射
result = map(lambda x: x ** 2, [1, 2, 4, 5])
print(list(result))  #[1, 4, 16, 25]
# 当序列多于一个时，map可以并行（注意是并行）地对每个序列执行
result = map(lambda x, y: x + y, [1, 2, 3], [4, 5, 6])
print(list(result))  #[5, 7, 9]

# 2. reduce函数
# reduce() 函数会对参数序列中元素进行累积
from functools import reduce
# (((1+2)+3)+4)+5=reduce result
result = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
print(result)  #15

# 练习: 求1*2*..10的结果， 用reduce和匿名函数实现
result = reduce(lambda x,y: x*y, range(1, 11))
print(result)  #3628800

# 3. filter:
# filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表
# 筛选所有的偶数
result = filter(lambda x: x % 2 == 0, [1, 2, 4, 5, 8])
print(list(result))  #[2, 4, 8]

# 筛选所有的奇数
result = filter(lambda x: x % 2 != 0, [1, 2, 4, 5, 8])
print(list(result))   #[1, 5]

# 4. sorted:
# sorted() 函数对所有可迭代的对象进行排序操作。返回重新排序的列表
result = sorted([1, 29, 2, 3])
print(result)  #[1, 2, 3, 29]

# reverse: 排序规则，True 降序 ，False 升序（默认）
result = sorted([0, 29, 2, 0], reverse=True)
print(result)  #[29, 2, 0, 0]

# key: 主要是用来进行比较的元素，只有一个参数
result = sorted([0, 8, 9, 0, 16], key=lambda x:0 if x==0 else 1)
print(result)  #[0, 0, 8, 9, 16]

python排序sort（）和sorted（）的区别是什么
1.排序对象不同: sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。
2.返回值不同:
(1)list 的 sort 方法返回的是对已经存在的列表进行操作，无返回值，
(2)内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作

小代灬

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python高级特性

# 练习"""知识点需求: 1. 文件操作 2. 字符串的分割操作 3. 字典操作功能需求:词频统计 1. 读取song.txt文件 with open(filename) as f: content=f.read() 2. 分析文件中的每一个单词，统计每个单词出现的次数。{"hello":2, "python":1, "java":1} - 分析文件中的每一个单词 content = "hello python hello java"
复制链接

扫一扫