python 怎么指定分配内存 python内存分配函数

转载

AI大梦想家 2024-06-25 12:51:05

文章标签 python 怎么指定分配内存 Python 函数文件操作模块 文章分类 Python 后端开发

1.文件操作

1.1 一般常用的就是r+模式，编码可以是文本形式也可以是二进制形式

1.2 seek,tell,truncate都是针对是字节而read( )则是读取的是字符

1.3 flush( )是用来及时对文件进行修改保存的，以免断电丢失

1.4文件修改有两种形式，第一是占用内存将内容全部读取出来，再去修改，第二种是占据磁盘空间利用两个文件操作

2.函数

1.内置函数

python自带的一些常用的函数，比如sorted( )排序，max( )取最大值等等

2.自定义函数

def func():
    print('我是自定义函数')

A.命名空间

i.内置空间存储python解释器自带的一些内置变量名、内置函数名、内置模块名

ii.全局空间存储全局定义的变量、函数等名字

iii.局部空间存储函数内部的变量、函数等名字

B.作用域链条(LEGB)

L: 局部作用域，比如局部变量在函数执行完毕就自动释放

E：相邻的局部作用域，比如嵌套函数中的内部函数中可以使用其外部函数中的变量

G：全局作用域，比如函数内部可以使用全部变量（只读），若是想修改必须要显式声明为global变量

B：内置作用域，比如解释器自带的一些变量和函数名等

C.形式参数和实际参数（形参和实参）

1.位置参数 args

2.动态位置参数(元组) *args

3.关键字参数 kwargs

4.动态关键字参数（字典） **kwargs

PS:1.传参顺序如上，先位置后关键字，先固定后动态

2.注意位置动态传入时会变成元组，如果想对传入的参数进行修改就不能使用了，因为元组是只读列表

D.匿名函数、嵌套函数、高级函数、递归函数、闭包函数、装饰器函数

1.匿名函数

# 匿名函数
# lambda匿名函数  一般节省代码量一次性使用
print(list(map(lambda x: x*x, [1, 2, 3])))

2.嵌套函数

#嵌套函数就是函数中套着一个函数

def outer():
    print('我是外部函数')

    def inner():
        print('我是内部函数')
    inner()


outer()

3.高级函数

# 高级函数的定义是什么？
# 要么是以一个函数名作为另一个函数的参数
# 要么就是将一个函数名作为返回值
# 函数名作为参数传递

def inner():
    print('我是参数')


def outer(func):
    func()


outer(inner)  # 输出我是参数

# 函数名作为返回值
def outer():
    def inner():
        print('我是返回值')

    return inner


inner = outer()
print(inner)  # 返回的是内部函数的内存地址
inner()  # 输出我是返回值

4.递归函数

# 递归函数（顺便说一下尾递归优化）  递归必须要有一个递归结束语句
# 计算阶乘 如计算15的阶乘

def func(n):
    if n == 1:
        return 1
    return n*func(n-1)


print(func(15))  # 返回15*14*13*12*11*10*9*8*7*6*5*4*3*2*1 ==1307674368000

# 尾递归优化的原理就是：内存的释放
# 即上一次递归的结果不影响下一次递归，这样上一次递归结束就是释放内存
#
def func(n):
    if n == 0:
        return
    func(n-1)
    print(n)


func(15)  # 会依次打印出1,2,3....15

5.闭包函数

# 闭包函数：就是内部函数在被返回后再去调用使用的还是外部函数的变量
n = 12


def outer():
    n = 15

    def inner():
        print(n)

    return inner


inner = outer()
inner()  # 打印的是outer函数中的局部变量15。而不是12

6.装饰器函数

# 装饰器函数：其实就是在原生函数上扩展功能
# 扩展功能函数不带参数
def login(func):
    def inner(arg):
        __name = 'wbj'
        __pwd = '123'
        name = input('请输入你的用户名:>>>').strip()
        pwd = input('请输入你的密码>>>').strip()
        if name == __name and pwd == __pwd:
            print('恭喜你验证通过')
            flag = 1
        if flag:
            func(arg)
    return inner

@login
def user(name):
    print('欢迎{}进入用户系统'.format(name))


@login
def boss(name):
    print('欢迎{}进入boss系统'.format(name))


user('luffy')

# 扩展功能函数带参数

def login(name):
    print('我是{}'.format(name))
    def outer(func):
        def inner(arg):
            __name = 'wbj'
            __pwd = '123'
            name = input('请输入你的用户名:>>>').strip()
            pwd = input('请输入你的密码>>>').strip()
            if name == __name and pwd == __pwd:
                print('恭喜你验证通过')
                flag = 1
            if flag:
                func(arg)

        return inner
    return outer


@login('老板')
def user(name):
    print('欢迎{}进入用户系统'.format(name))


@login('员工')
def boss(name):
    print('欢迎{}进入boss系统'.format(name))


user('luffy')

3.生成器和迭代器

A.生成器

# 两种方式的生成器创建
# 1. 表达式  最多是三元运算 两个步骤需求
# 2. 函数式  可以进行多个步骤需求
# 表达式
b = (i if i < 5 else i*i for i in range(5))
print(b)  # 返回生成器b的内存地址
print(next(b))  # 取生成器中的值

# 函数式  斐波那契数列 1 1 2 3 5 8 13 21 34 55 89 144
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        sign = yield b
        a, b = b, a+b
        n = n + 1
        if sign == '你好':
            print('被我截断')
    return 'done'


f = fib(12)
print(f)  # 返回f生成器的内存地址  注意此时这个函数已经是生成器了
print(next(f))
print(f.send('你好'))
for i in f:
    print(i)
# 总结生成器的使用：next，send，for循环都可以以此得到生成器的值
# next与send用途：都是唤醒程序执行，返回生成器的下一个值
# send可以发送自定义消息，next则是默认发送None消息，for循环可以遍历生成器中的每个数值

B.迭代器

from collections import Iterable
from collections import Iterator

print(isinstance([], Iterable))
print(isinstance('abc', Iterable))
print(isinstance('abc', Iterator))

# str list set dict 是可迭代的对象  但是不是生成器
# 生成器都是迭代器  即都是可迭代的对象
# 迭代器是指可迭代对象可以使用next()函数进行依次访问取值的
print(isinstance(iter('abc'), Iterator))
print(iter('abc'))
a = iter('abc')
print(next(a))
print(list('abc'))