---

1、有一个文件file.txt大小约为10G，但是内存只有4G，如果在只修改get_lines 函数而其他代码保持不变的情况下，应该如何实现? 需要考虑的问题都有那些?

def get_lines():
    with open('file.txt','rb') as f:
        # return f.readlines()
        #分段读取
        while True:
            part=f.read(1024)
            if part:
                yield part
            else:
                return None


if __name__ == '__main__':
    for e in get_lines():
        print(e)

2、交换2个变量的值

a=1
b=2
#方法1
a,b=b,a
print(a,b)

#方法2
c=a
a=b
b=c

#方法3
a=a+b
b=a-b
a=a-b
print(a,b)

3、回调函数

def func(cb):
    #回调
    res=cb(8)
    return res

def callback2(x):
    return x*10

# func(callback)
res2=func(callback2)
print(res2)

4、Python-遍历列表时删除元素的正确做法,

背景

a = [1,2,3,4,5,6,7,8] 
for i in a: 
    if i>5: 
        pass
    else:
            a.remove(i)
            print(a)

运行结果

[2, 3, 4, 5, 6, 7, 8]
[2, 4, 5, 6, 7, 8]
[2, 4, 6, 7, 8]
[2, 4, 6, 7, 8]
[2, 4, 6, 7, 8]

因为删除元素后，整个列表的元素会往前移动，而i却是在最初就已经确定了，是不断增大的，所以并不能得到想要的结果。

解决办法：

遍历在新的列表操作，
删除时在原来的列表操作。

方法1
a=[1,2,3,4,5,6,7]
aa=a[:]
for i in aa:
    if i>4:
        pass
    else:
        a.remove(i)
        print(a)



方法2
a=[1,2,3,4,5,6,7]
for i in range(len(a)-1,-1,-1):
    if a[i]>4:
        pass
    else:
        a.remove(a[i])
        print(a)

5、装饰器的理解、并实现一个计时器记录执行性能

class S2:

    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        start = time.time()
        res = self.func(*args, **kwargs)
        end = time.time()
        print('总时间:', end - start)
        return res


@S2
def func(a, b):
    time.sleep(2)
    return a + b

print(func(3, 4))

6、输入某年某月某日，判断这一天是这一年的第几天

def dayofyear():
    year = input('请输入年份:')
    month = input('请输入月份:')
    day = input('请输入天:')
    date1=datetime.date(year=int(year),month=int(month),day=int(day))
    date2=datetime.date(year=int(year),month=1,day=1)
    return (date1-date2).days+1

r=dayofyear()
print(r)

7、python的内存管理机制以及调优手段

调优手段：
1、使用生成器和迭代器：生成器和迭代器可以按需生成和处理数据，避免一次性加载大量的数据到内存。
2、使用适当的数据结果：选择合适的数据结构可以减轻内存占用。例如，是哟个集合代替列表可以避免重复元素占用额外的内存。
3、及时释放不再使用的对象：手动解除对不再使用的对象的引用，可以加速垃圾回收并释放内存。
4、使用内存分析工具：使用内存分析工具memory_profiler可以帮助我们分析内存使用情况，找到内存占用较大的部分，并进行优化。

8、内存溢出是什么？如何避免

由于内存是有限的，当计算机内存中存在大量的相互（循环）引用计数时，会占用大部分的内存；当新的变量进来时，但是内存不够用了，所以不会去开辟新的内存地址。

原因：
1、内存中加载的数据量过大，如一次从数据库取出过多数据，一般比如数据库查询未做分页处理。
2、对象循环引用
3、代码中存在死循环或者循环产生过多重复的对象实体
4、使用第三方软件的bug，一般引用第三方jar包过多会出现此类问题。
5、启动参数内存值设定的过小，这种可能性很小服务器参数设置一般会出现这类问题

解决：
第一步，修改JVM启动参数，直接增加内存。(-Xms，-Xmx参数一定不要忘记加。)
第二步，检查错误日志，查看“OutOfMemory”错误前是否有其它异常或错误。
第三步，对代码进行走查和分析，找出可能发生内存溢出的位置。

重点排查以下几点：
1.检查对数据库查询中，是否有一次获得全部数据的查询。一般来说，如果一次取十万条记录到内存，就可能引起内存溢出。这个问题比较隐蔽，在上线前，数据库中数据较少，不容易出问题，上线后，数据库中数据多了，一次查询就有可能引起内存溢出。因此对于数据库查询尽量采用分页的方式查询。
2.检查代码中是否有死循环或递归调用。
3.检查是否有大循环重复产生新对象实体。
4.检查List、MAP等集合对象是否有使用完后，未清除的问题。List、MAP等集合对象会始终存有对对象的引用，使得这些对象不能被GC回收。

第四步，使用内存查看工具动态查看内存使用情况

9、迭代器、可迭代对象、生成器

https://blog.csdn.net/YZL40514131/article/details/119990819
https://blog.csdn.net/YZL40514131/article/details/119989244

10、用python代码实现内置max方法

l=[
    {'name':'zs','age':18},
    {'name':'ls','age':19},
    {'name':'ww','age':17}
]
print(max(l,key=lambda x:x['age']))



def my_max(*args,key=None):
    # args=([],)
    args=args[0] if len(args)==1 else args
    if key==None:
        max_=args[0]
        for n in args:
            if n > max_:
                max_=n
        return max_
    else:
        max_=args[0]
        for n in args:
            if key(n)>key(max_):
                max_=n
        return max_



print(my_max([1,2,3,8,5,6]))

print(my_max(l,key=lambda x:x['age']))

11、Python中yield的用法?

https://blog.csdn.net/YZL40514131/article/details/119989244

12、使用lambda函数对list排序foo=[-5,8,0,4,9,-4,-20,-2,8,2,-4],正数从小到大，负数从大到小

foo=[-5,8,0,4,9,-4,-20,-2,8,2,-4]
foo1=sorted(foo,key=lambda x:(x<0,abs(x)))
print(foo1)

[0, 2, 4, 8, 8, 9, -2, -4, -4, -5, -20]

13、题目025：求1+2!+3!+…+20!的和

def fun_tm():

    s=0
    t=1
    for n in range(1,21):
        t=t*n
        s=s+t
    print(s)
fun_tm()

---