123墨盒和123ⅹL墨盒有啥区别？

Posted 2023-04-05

文件操作

1. 若有一个jsonline格式的文件file.txt，大小约为10K，我们的处理方式为：

def get_lines(): l = [] with open('file.txt', 'rb') as f: for eachline in f: l.append(eachline) return lif __name__ == '__main__': for e in get_lines(): process(e) #处理每一行数据

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

def get_lines(): l = [] with open('file.txt','rb') as f: data = f.readlines(60000) l.append(data) yield l

要考虑的问题有：内存只有4G，无法一次性读入10G文件。而分批读入数据要记录每次读入数据的位置，且分批每次读取得太小会在读取操作上花费过多时间。

模块与包

2.如何输入日期， 判断这一天是这一年的第几天？

import datetimedef 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

数据类型

3.如何反转字符串"aStr"?

print("aStr"[::-1])


4.下面代码的输出结果将是什么？会报错吗？

list = ['a','b','c','d','e']
print(list[10:])


代码将输出[]，并不会产生IndexError 错误。如果尝试用超出成员的个数的index来获取某个列表的成员，那就会报错。例如，尝试获取 list[10] 和之后的成员，会导致IndexError。然而当我们尝试获取列表的切片时，开始的index超过成员个数并不会产生IndexError，而是仅仅返回一个空列表。因为并不会报错，所以这种Bug很难追踪到。

5.请写出一段Python代码，实现删除list里面的重复元素？

l1 = ['b','c','d','c','a','a']l2 = list(set(l1))print(l2)

用list类的sort方法可以保证顺序不变：

l1 = ['b', 'c', 'd', 'c', 'a', 'a']l2 = list(set(l1))l2.sort(key=l1.index)print(l2)

也可以这样写：

l1 = ['b', 'c', 'd', 'c', 'a', 'a']l2 = sorted(set(l1), key=l1.index)print(l2)

也可以用遍历：

l1 = ['b', 'c', 'd', 'c', 'a', 'a']l2 = []for i in l1: if not i in l2: l2.append(i)print(l2)

企业面试题

6.设计实现遍历目录与子目录，抓取.pyc文件

第一种方法：

import osdef getFiles(dir, suffix): res = [] for root, dirs, files in os.walk(dir): for filename in files: name, suf = os.path.splitext(filename) if suf == suffix: res.append(os.path.join(root, filename)) print(res)getFiles("./", '.pyc')

第二种方法：

import osdef pick(obj): try: if obj.[-4:] == ".pyc": print(obj) except: return Nonedef scan_path(ph): file_list = os.listdir(ph) for obj in file_list: if os.path.isfile(obj): pick(obj) elif os.path.isdir(obj): scan_path(obj)if __name__ == '__main__': path = input('输入目录') scan_path(path)

7.如何反转一个整数，例如-123–> -321？

class Solution(object): def reverse(self, x): if -10 < x < 10: return x str_x = str(x) if str_x[0] != "-": str_x = str_x[::-1] x = int(str_x) else: str_x = str_x[1:][::-1] x = int(str_x) x = -x return x if -2147483648 < x < 2147483647 else 0if __name__ == '__main__': s = Solution() reverse_int = s.reverse(-120) print(reverse_int)

Python高级

Python高级包含很多重要的模块，例如函数、类和实例、系统编程、正则表达式、网络编程等等。根据这些高级属性，Python可用于数据科学、网页开发、机器学习等等。

设计模式

8.对设计模式的理解，简述你了解的设计模式？

设计模式是为我们经常会碰到的一些编程问题构建的可重用解决方案，它是总结性和经优化的。一个设计模式并不像一个类或一个库那样能够直接作用于我们的代码，反之，设计模式更为高级，它是一种在特定情形下实现的方法模板。常见的是工厂模式和单例模式。

单例模式应用的场景一般发现在以下条件下：资源共享的情况下，避免由于资源操作时导致的性能或损耗等，如日志文件，应用配置。控制资源的情况下，方便资源之间的互相通信。

9.生成器和迭代器的区别？

迭代器是一个更抽象的概念，任何对象，如果它的类有 next 方法和 iter 方法返回自己本身，它就是可迭代的。对于 string、list、dict、tuple 等这类容器对象，使用for循环遍历是很方便的，for 语句实际上会对容器对象调用 iter() 函数。iter() 会返回一个定义了 next() 方法的迭代器对象，它在容器中逐个访问容器内元素，在没有后续元素时，next()会抛出一个StopIteration异常。

生成器（Generator）是创建迭代器的简单而强大的工具。它们写起来就像是正规的函数，只是在需要返回数据的时候使用yield语句。生成器能做到迭代器能做的所有事，而且因为自动创建iter()和next()方法，生成器显得特别简洁，而且生成器也是高效的，使用生成器表达式取代列表解析可以同时节省内存。除了创建和保存程序状态的自动方法，当发生器终结时，还会自动抛出StopIteration异常。

10.对装饰器的理解，你能写出一个计时器装饰器，它能记录函数的执行时间吗？

装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。

import time def timeit(func): def wrapper(): start = time.clock() func() end = time.clock() print('used:',end-start) return wrapper @timeit def foo(): print('in foo()'foo())

系统编程

11.介绍一下你了解的进程。

程序运行在操作系统上的一个实例，就称之为进程。进程需要相应的系统资源：内存、时间片、pid。创建进程：首先要导入multiprocessing中的Process；创建一个Process对象；创建Process对象时，可以传递参数。

p = Process(target=XXX, args=(tuple,), kwargs=key: value)target = XXX # 指定的任务函数，不用加()args = (tuple,)kwargs = key: value # 给任务函数传递的参数

使用start()启动进程 结束进程 给子进程指定函数传递参数Demo


import osfrom mulitprocessing import Processimport timedef pro_func(name, age, **kwargs): for i in range(5): print("子进程正在运行中，name=%s,age=%d,pid=%d" % (name, age, os.getpid())) print(kwargs) time.sleep(0.2)if __name__ == "__main__": # 创建Process对象 p = Process(target=pro_func, args=('小明', 18), kwargs='m': 20) # 启动进程 p.start() time.sleep(1) # 1秒钟之后，立刻结束子进程 p.terminate() p.join()

12.谈谈你对多进程、多线程、以及协程的理解，项目是否用？

进程：一个运行的程序（代码）就是一个进程，没有运行的代码叫程序，进程是系统资源分配的最小单位，进程拥有自己独立的内存空间，所有进程间数据不共享，开销大。线程: cpu调度执行的最小单位，也叫执行路径，不能独立存在，依赖进程存在，一个进程至少有一个线程，叫主线程，而多个线程共享内存可以极大地提高了程序的运行效率。协程: 是一种用户态的轻量级线程，协程的调度完全由用户控制，协程拥有自己的寄存器上下文和栈。协程调度时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，直接操中栈则基本没有内核切换的开销，可以不加锁的访问全局变量，所以上下文的切换非常快。

关于系统编程还有很多问题，例如：

参考技术A 最佳答案区别就在于：1.连供的打印效果超垃圾，而且市面上几乎都是假的。就算是真的，他的墨汁材料都是次的，很容易就把喷头堵了，损坏打印机使用寿命；2.原装比较有质量... 参考技术B 一个是加大，一个是没加大的区别。墨盒规格大小不一样。 参考技术C 这个123墨盒更好用的，买的人更多的，功能更多 参考技术D 然后三万和和123 xl墨盒有什么区别？那肯定有区别了，他们都是用英文代替的，肯定有一定的不同的

使用 SQL 创建 2 个带有条件的累积和“墨盒”

【中文标题】使用 SQL 创建 2 个带有条件的累积和“墨盒”

【英文标题】：Creating 2 "cartridges" of cumulative sum with conditions using SQL

【发布时间】：2020-10-25 09:31:28

【问题描述】：

我需要根据值类型创建2个累积和，例如：

我有 2 种类型的进货单位的值：A 和 B。我也有出货单位的记录。

如果我们有足够的“A”型库存，则应从 A 型中取出，如果没有，则应从 B 型中取出。所以基本上我需要创建“A 库存”和“B 库存”列下图，代表当前每种类型的余额。

我尝试使用累积和，但我遇到了条件问题...有没有办法在不使用循环的情况下编写此查询？ （垂直数据库）

下表中的 A_stock 和 B_stock 是我需要创建的最终结果

ID  Type    In      OUT     A stock B stock  Order_id
1   A       100     0       100     0        1
1   B       50      0       100     50       2
1   A       100     0       200     50       3
1   -       0       -200    0       50       4
1   -       0       -10     0       40       5
1   B       50      0       0       90       6
1   A       40      0       40      90       7
1   -       0      -20      20      90       8
2   A       30      0       30      0        1
2   B       20      0       30      20       2
2   A       10      0       40      20       3
2   -       0       -20     20      20       4

【问题讨论】：

您的问题似乎表明您的行是有序的。但是，SQL 表代表无序 数据集。除非您明确有一个带有排序的列，否则没有排序。

正如@GMB 指出的那样，您需要一个排序列开始。但是，其次 - 由于以下结果取决于之前发生的任何事情（1. 运行总和；2. 基于先前运行总和和余额的结果的决定），您将需要一个递归查询。而RECURSIVE WITH 子句在 Vertica 中不存在（还没有？）。解决方法是在WITH 子句中编写尽可能多的公用表表达式，因为您期望迭代是必要的。这可能会变得丑陋。

@marcothesane，是的，你当然是对的，要明确的是，我确实有办法对结果进行排序（在示例中添加了排序列）不幸的是我认为你是对的，我没有没有递归查询就没有办法做到这一点......

【参考方案1】：

你可以使用窗口函数——但你需要一个定义行顺序的列，我假设ordering_id：

select t.*,
    sum(case when type = 'A' then in + out else 0 end) over(partition by id order by ordering_id) a_stock,
    sum(case when type = 'B' then in + out else 0 end) over(partition by id order by ordering_id) b_stock
from mytable t

这假设您想要以每id 为基础的股票；如果不是这样，只需从over() 子句中删除partition 子句。

【讨论】：

您没有考虑type 列中带有NULL 的行——那些从库存中拿走某些东西并且开始出现决策问题的行，@GMT ...