ChatGPT API Key

:::info{title="基础部分：企业真题"}
:::

# 1、python实现单例模式

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         14、python实现单例模式
# Description:  单例模式是一个软件的设计模式，为了保证一个类，无论调用多少次产生的实例对象，
# 都是指向同一个内存地址，仅仅只有一个实例（只有一个对象）。实现单例模式的手段有很多种，但总的
# 原则是保证一个类只要实例化一个对象，下一次再实例的时候就直接返回这个对象，不再做实例化的操作。
# 所以这里面的关键一点就是，如何判断这个类是否实例化过一个对象。
# Author:       zhaoyaowei
# Date:         2023/3/29 23:43
# -------------------------------------------------------------------------------

# 方法一：通过模块导入
"""
基本原理：借用了模块导入时的底层原理实现。
当一个模块（py文件）被导入时，首先会执行这个模块的代码，然后将这个模块的名称空间加载到内存。
当这个模块第二次再被导入时，不会再执行该文件，而是直接在内存中找。
于是，如果第一次导入模块，执行文件源代码时实例化了一个类，那再次导入的时候，就不会再实例化。
"""
import threading


# 方法二：通过类绑定方法
class Student:
    """
    @classmethod修饰符对应的函数不需要实例化，
    不需要 self 参数，但第一个参数需要是表示自身类的 cls 参数，
    可以来调用类的属性，类的方法，实例化对象等
    原理：类的绑定方法是第二种实例化对象的方式，
    第一次实例化的对象保存成类的数据属性 _instance，
    第二次再实例化时，在get_singleton中判断已经有了实例对象，
    直接返回类的数据属性 _instance
    """
    _instance = None  # 记录实例化对象, 属性默认为类属性，可直接被类本身调用

    def __init__(self, name, age):  # self: 表示实例化的地址id
        self.name = name
        self.age = age

    # 类方法(不需要实例化类就可以被类本身调用)
    @classmethod
    def get_singleton(cls, *args, **kwargs):  # cls：表示没用被实例化的类本身
        if not cls._instance:
            cls._instance = cls(*args, **kwargs)
        return cls._instance


# 补充：该方式实现的单例模式有一个明显的bug；原因在于若不通过绑定类的方法实例化对象，而是直接通过类名加括号实例化对象，就不是单例模式了
s1 = Student.get_singleton("tom", 2)
s2 = Student.get_singleton("tom", 2)
print(s1, s2, s1 is s2)  # <__main__.Student object at 0x102f80fa0> <__main__.Student object at 0x102f80fa0> True
print(s1.__dict__, s2.__dict__)  # {'name': 'tom', 'age': 2}


# 方法三：通过__new__
class Student:
    """
    原理：和方法2类似，将判断的实现方式，从类的绑定方法中转移到类的__new__中
    思路都是判断类有没有实例，有则直接返回，无则实例化并保存到_instance中。
    __new__ 方法：使用 类名()创建对象时，Python解释器首先会调用object基类提供__new__方法为对象分配空间
    作用有两个：（1）在内存中为对象分配空间 （2）返回对象的引用
    若获取到对象的引用后，将引用作为第一个参数，传递给__init__方法；否则不会调用init
    __init__ 方法：(1)对象初始化 （2）定义实例属性
    """
    _instance = None

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __new__(cls, *args, **kwargs):
        # if cls._instance:
        #     return cls._instance   # 有实例，直接返回
        # else:
        #     cls._instance = super().__new__(cls) # 没有实例，则new一个实例并保存
        #     return cls._instance # 返回给init，再实例化一次

        if not cls._instance:  # 简写
            cls._instance = super().__new__(cls)
        return cls._instance


# 补充：这种方式可以近乎完美地实现单例模式，但是依然不够完美。不完美的地方在于没有考虑到并发的极端情况下，有可能多个线程同一时刻实例化对象。
s1 = Student("tom", 3)
s2 = Student("tom", 3)
print(s1, s2, s1 is s2)  # <__main__.Student object at 0x102de9c40> <__main__.Student object at 0x102de9c40> True
print(s1.__dict__, s2.__dict__)  # {'name': 'tom', 'age': 3}


# 方法三优化版：
class Student:
    _instance = None
    _lock = threading.RLock()  # 加互斥锁方法

    def __new__(cls, *args, **kwargs):
        if cls._instance:  # 如果已经有单例，则不再抢锁，避免IO等待
            return cls._instance

        # 只有第一个抢到锁的线程实例化一个对象，并保存在_instance中，
        # 同一时刻抢锁的其他线程再抢到锁后，不会进入判断if not cls._instance，
        # 直接返回保存在_instance的对象
        with cls._lock:  # 使用with语法，方便抢锁和释放锁
            if not cls._instance:
                cls._instance = super().__new__(cls, *args, **kwargs)
            return cls._instance


# 方法四：函数装饰器
def singleton(cls):
    _instance = {}  # 采用字典，可以装饰多个类实现单例模式

    def inner(*args, **kwargs):
        if cls not in _instance:
            _instance[cls] = cls(*args, **kwargs)
        return _instance.get(cls)

    return inner


# 逻辑：实例化对象时，将类对象作为参数传值给singleton(),再将函数执行完成的返回值反馈回类
@singleton
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # def __new__(cls, *args, **kwargs):  # 将方法3中的重写new搬到了函数装饰器中
    #     if not cls._instance:
    #         cls._instance = super().__new__(cls)
    #     return cls._instance


s1 = Student("tom", 4)
s2 = Student("tom", 4)
print(s1, s2, s1 is s2)  # <__main__.Student object at 0x103119670> <__main__.Student object at 0x103119670> True
print(s1.__dict__, s2.__dict__)  # {'name': 'tom', 'age': 4}


# 方法五：类装饰器
class Singleton:
    """
    原理：在函数装饰器的思路上，将装饰器封装成类。
    程序会实例化一个Student对象，这个对象是SingleTon的对象。
    后面使用的Student本质上使用的是SingleTon的对象。
    所以使用Student('tom', 5)来实例化对象，其实是在调用SingleTon的对象，会触发其__call__的执行
    所以就在__call__中，判断Student类有没有实例对象了。
    """
    _instance = {}

    def __init__(self, cls_name):
        self.name = cls_name

    # 若类定义类__call__方法，则将一个类的实例化对象变成了可调用对象
    # Student('tom', 5) == Student.__call__('tom', 5)
    def __call__(self, *args, **kwargs):
        if self.name not in Singleton._instance:
            Singleton._instance[self.name] = self.name(*args, **kwargs)
        return self._instance.get(self.name)


@Singleton  # 相当于Student = SingleTon(Student),即Student是SingleTon的实例对象
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age


s1 = Student("tom", 5)
s2 = Student("tom", 5)
print(s1, s2, s1 is s2)  # <__main__.Student object at 0x100915550> <__main__.Student object at 0x100915550> True
print(s1.__dict__, s2.__dict__)  # {'name': 'tom', 'age': 5} {'name': 'tom', 'age': 5}

```

# 2、反转一个整数，如-123，-321

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         反转一个整数，如-123，-321
# Description:  
# Author:       zhaoyaowei
# Date:         2023/4/1 20:51
# -------------------------------------------------------------------------------

def reverse_integer1(x):
    if x >= 0:
        # 如果是正数，直接反转
        rev_x = int(str(x)[::-1])
    else:
        # 如果是负数，先反转绝对值，再加上负号
        rev_x = -int(str(abs(x))[::-1])
    return rev_x


def reverse_integer2(x):
    sign = 1 if x >= 0 else -1
    x = abs(x)
    rev_x = int(str(x)[::-1])
    return sign * rev_x


print(reverse_integer2(123))   # 输出：321
print(reverse_integer2(-123))  # 输出：-321
print(reverse_integer2(120))   # 输出：21

```

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

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         设计实现遍历目录与子目录，抓取.pyc文件
# Description:  
# Author:       zhaoyaowei
# Date:         2023/4/1 21:18
# -------------------------------------------------------------------------------

import os
import fnmatch


def find_pyc_files(dir_path):
    pyc_files = []
    for root, dirs, files in os.walk(dir_path):
        for file in files:
            if fnmatch.fnmatch(file, '*.pyc'):
                pyc_files.append(os.path.join(root, file))
    return pyc_files


print(os.getcwd())
pyc_files = find_pyc_files('/Users/zhaoyaowei/Desktop/project/InterviewQuestions/Python基础')
print(pyc_files)


```

Python面试题汇总（四）

:::info{title="基础部分：数据类型"}
:::


# 1、现有字典 d= {'a':24,'g':52,'i':12,'k':33}请按value值进行排序?

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         5、现有字典 d= {'a':24,'g':52,'i':12,'k':33}请按value值进行排序?
# Description:  
# Author:       zhaoyaowei
# Date:         2023/3/12 20:52
# -------------------------------------------------------------------------------
from operator import itemgetter

d = {'a': 24, 'g': 52, 'i': 12, 'k': 33}
new_list = sorted(d.items(), key=lambda x: x[1])
# d.iteritems() 在3.x中已废弃；
# itemgetter函数获取的不是值，而是定义了一个函数，通过该函数作用到对象上才能获取值
new_list1 = sorted(d.items(), key=itemgetter(1))
print(new_list1)

# 附录
"""
（1）字典常见用法：
    dict.keys()：以列表返回一个字典所有的键。
    dict.values()：以列表返回字典中的所有值。
    dict.items()：以列表返回可遍历的(键, 值) 元组数组。
    
（2）sorted() -全局性的Python内置函数，可对所有可迭代类型进行排序，返回新list，原有列表不变
    原型：sorted(iterable, cmp=None, key=None, reverse=False)，cmp比较函数在3.x已取消
    用法和sort()类似

    sort() -一般是列表的Python内置函数，返回None，直接修改原有列表
    原型：sort（fun，key，reverse=False），fun一般是归并算法，可忽略；key可指定一个函数
    list1 = [(2,'zhao',23),(12,'yao',14),(23,'wei',90)]  
    list1.sort() --默认key排序，即按照元组中第一个元素进行排序  
    list1.sort(key=lambda x:(x[1])) --使用匿名表达式重写key函数排序   
    list1.sort(key=lambda x:(x[2],x[0])) --先按照下标2排序，下标2相同，则按照下标0
    list1.sort(key=itemgetter(1)) --使用operator模块中的itemgetter函数   
    list1.sort(key=itemgetter(2,0)) --类比lambda中的排序方法 
    
    补充：
    a.字典中混合list排序: 根据mydict的value结构[n,m]中的m按照从小到大的顺序排列
    mydict = { 'Li'   : ['M',7],
               'Zhang': ['E',2],
               'Wang' : ['P',3],
               'Du'   : ['C',2],
               'Ma'   : ['C',9],
               'Zhe'  : ['H',7] }
    sorted(mydict.iteritems(), key=lambda (k,v): operator.itemgetter(1)(v))
    
    b.列表中混合dict排序：针对list中的字典元素按照rating和name进行排序的实现方法
    >>> game_result = [
    { "name":"Bob", "wins":10, "losses":3, "rating":75.00 },
    { "name":"David", "wins":3, "losses":5, "rating":57.00 },
    { "name":"Carol", "wins":4, "losses":5, "rating":57.00 },
    { "name":"Patty", "wins":9, "losses":3, "rating": 71.48 }]
    sorted(game_result , key=operator.itemgetter("rating","name"))

    
（3）扩展：Python的4种排序算法  https://zhuanlan.zhihu.com/p/383453416   

    参考资料：https://blog.51cto.com/u_14246112/3141437
"""

```

# 2、字典推导式

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         6_字典推导式
# Description:  推导式（Compression）也叫解析式，可以从一个数据序列构建另一个新的数据序列的结构体。
# Author:       zhaoyaowei
# Date:         2023/3/14 22:04
# -------------------------------------------------------------------------------


iterable = {}
d = {key: value for (key, value) in iterable}


# 附录： 1、列表推导式
"""
 语法：new_list = [表达式 for 变量 in 可迭代对象 if 条件 == True]
 或者 [ 表达式(可含变量1和变量2) for 变量1 in 可迭代对象1 for 变量2 in 可迭代对象2 ...]

 示例1：求(x, y)，其中x是0-5之间的偶数，y是0-5之间的奇数组成的元祖列表
    [(x,y) for x in range(5) if x%2==0 for y in range(5) if y%2==1] 
    # [(0, 1), (0, 3), (2, 1), (2, 3), (4, 1), (4, 3)]
 
 示例2：求M中3, 6, 9组成的列表
    M = [[1,2,3], [4,5,6], [7,8,9]] 
    [row[2] for row in M]   # [3, 6, 9] 
    # 或者用下面的方式 
    [M[row][2] for row in (0, 1, 2)]  # [3, 6, 9]

 示例3：过滤掉长度小于等于3的字符串列表，并将剩下的转换成大写字母
    names = ['Bob','Tom','alice','Jerry','Wendy','Smith'] 
    [name.upper() for name in names if len(name)>3] 
    # ['ALICE', 'JERRY', 'WENDY', 'SMITH']
    
 示例4：生成间隔5分钟的时间列表序列
    ["%02d:%02d"%(h,m) for h in range(0, 24) for m in range(0, 60, 5)]

 示例5：复杂点的列表推导式
    # in后面跟其他可迭代对象,如字符串
    list_c = [7 * c for c in "python"]
    # ['ppppppp', 'yyyyyyy', 'ttttttt', 'hhhhhhh', 'ooooooo', 'nnnnnnn']
     
    # 带if条件语句的列表推导式
    list_d = [d for d in range(6) if d % 2 != 0]
    # [1, 3, 5]
     
    # 多个for循环
    list_e = [(e, f * f) for e in range(3) for f in range(5, 15, 5)]
    # [(0, 25), (0, 100), (1, 25), (1, 100), (2, 25), (2, 100)]
     
    # 嵌套列表推导式,多个并列条件
    list_g = [[x for x in range(g - 3, g)] for g in range(22) if g % 3 == 0 and g != 0]
    # [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11], [12, 13, 14], [15, 16, 17], [18, 19, 20]

    # 三变量列表推导式
    List6=[(x,y) for x in range(-2,2) for y in [0,1]]
    List7=[x+y+z for x in range(-2,2) for y in range(3) for z in [0,1]]
    # [(-2, 0), (-2, 1), (-1, 0), (-1, 1), (0, 0), (0, 1), (1, 0), (1, 1)]
    # [-2, -1, -1, 0, 0, 1, -1, 0, 0, 1, 1, 2, 0, 1, 1, 2, 2, 3, 1, 2, 2, 3, 3, 4]
    
 示例6：生成generator, 只需要将列表推导式的[]改成()即可得到生成器；
    multiples = (i for i in range(30) if i%3 == 0)
    print(type(multiples))   # <type 'generator'>,返回值类型是generator
    print(list(multiples))   # 输出列表
    
"""

# 附录： 2、字典推导式
"""
 语法：new_dict = { 键表达式 : 值表达式 for 变量 in 可迭代对象 if 条件 == True }

 或者 { 键表达式 : 值表达式 for 变量1 in 可迭代对象1 for 变量2 in 可迭代对象2 ...}
 
 用法与列表推导式基本类似
 
 1、在字典中提取或者修改数据，返回新的字典
 # 示例1：获取字典中key值是小写字母的键值对
    dict1 = {"a":10,"B":20,"C":True,"D":"hello world","e":"python教程"}
    dict2 = {key:value for key,value in dict1.items() if key.islower()}
    # {'a': 10, 'e': 'python教程'}
 # 示例2：将字典中的所有key设置为小写
    dict3 = {key.lower():value  for key,value in dict1.items() }
    # {'a': 10, 'b': 20, 'c': True, 'd': 'hello world', 'e': 'python教程'}
 # 示例3：将字典中所有key是小写字母的value统一赋值为'error'
    dict4 = {key:value if key.isupper() else "error" for key,value in dict1.items() }
    # {'a': 'error', 'B': 20, 'C': True, 'D': 'hello world', 'e': 'error'}
 2、在字符串中提取数据，返回新的字典
    cookies = "anonymid=jy0ui55o-u6f6zd; depovince=GW; _r01_=1"
    cookies = {cookie.split("=")[0]:cookie.split("=")[1] for cookie in cookies.split("; ")}
    # {'anonymid': 'jy0ui55o-u6f6zd', 'depovince': 'GW', '_r01_': '1'}
"""

# 附录： 3、集合推导式
"""
 语法：new_set = { 表达式 for 变量 in 可迭代对象 if 条件 == True }
 
 其形式和用法与列表推导式基本一致，二者区别在于
 a. 不使用中括号，使用大括号
 b. 返回值类型是一个set(集合)
 c. 结果中无重复元素
 
 集合推导式与字典推导式相同， 可根据表达式进行区分。以键值对（key：value）的形式，是字典推导式。
 总之，集合推导式就是将列表推导式的[]换成{}，字典推导式就是推导出两个值并构建成键值对的样子。
 
"""

# 附录： 4、元组推导式==生成器
"""
 语法：new_generator = (表达式 for 变量 in 可迭代对象 if 条件 == True)
 
 与列表推导式的用法完全相同，但使用元组推导式生成的结果并不是一个元组，而是一个生成器对象。
 
 获取新元组及其元素：
 方法一：使用tuple()函数，new_tuple= tuple(new_generator)
 方法二：使用 for循环遍历生成器对象： for i in new_generator  == （）
 方法三：使用next() 方法遍历生成器对象 new_generator.__next__()  == （）
 备注：__next__()是生成器对象的实例方法，next(new_generator)是python的内置方法，均可
 方法二和三，遍历后原生成器对象将不复存在

"""

```

# 3、反转字符串

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         7_反转字符串
# Description:  请反转字符串 "AaBbCcDdEeFf"
# Author:       zhaoyaowei
# Date:         2023/3/20 23:21
# -------------------------------------------------------------------------------
from functools import reduce

s = "AaBbCcDdEeFf"
# 分析
"""
Python 提供了两种直接的方法来反转字符串。
由于字符串是序列，且不可变，因此它们是indexable、sliceable和iterable。
所以可使用切片以相反的顺序直接生成给定字符串的副本。
第二个方法是使用内置函数reversed()创建一个迭代器，
该迭代器以相反的顺序生成输入字符串的字符。
"""

# 方法一： 通过切片反转字段串或slice()内置函数模拟切片
# s_string[start:stop:step] 默认值分别是0, len(s_string), 1；step=-1时，从右往左切片。
print(s[::-1])
print(s[slice(None, None, -1)])

# 方法二：使用.join()和反转字符串reversed()
# reversed(序列=tuple, string, list 或 range)返回一个反转的迭代器，直接作为参数传递给.join()
a = (1, 2, 3)
print(reversed(a))  # <reversed object at 0x1059ee100>，next()、__next__()
print(list(reversed(a)))  # [3, 2, 1]
print("".join(reversed(s)))  # fFeEdDcCbBaA

# 方法三：for循环或者while和连接运算法+
# 因字符串不可变，多次创建新字符串，于下次迭代中弃用，此法过于浪费
new_s = ""
for i in s:
    new_s = i + new_s  # 不是 new_s = new_s + i
print(new_s)  # fFeEdDcCbBaA

new_s1 = ""
index = 0
while index < len(s):
    new_s1 = s[index] + new_s1
    index += 1
print(new_s1)  # fFeEdDcCbBaA


# 方法四：使用递归反转字符串
# 需注意，此方法，字符串长度不可超过1000，否则会报错RecursionError
# sys.getrecursionlimit() = 1000，setrecursionlimit()重新设值


def reverse_str(text):
    if len(text) == 1:
        return text
    # 字符串切换，依次递归所有text, 与第一个字符串相加，text[:1]
    return reverse_str(text[1:]) + text[0]


# 方法五：使用reduce()扭转字符串
# 每次遍历s中的2个参数，入参lambda，并将两个字符串以反序连接，最终返回新的字符串值
new_s = reduce(lambda x, y: y + x, s)


```

# 4、将字符串 "k:1 |k1:2|k2:3|k3:4"，处理成字典 {k:1,k1:2,...}

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         8_将字符串 "k:1 |k1:2|k2:3|k3:4"，处理成字典 {k:1,k1:2,...}
# Description:  
# Author:       zhaoyaowei
# Date:         2023/3/22 00:01
# -------------------------------------------------------------------------------

s = "k:1 |k1:2|k2:3|k3:4"
# 方法一：字典推导式
d1 = {k: int(v) for i in s.strip().split("|") for k, v in (i.split(":"),)}
# for循环
d2 = {}
for i in s.strip().split("|"):
    k, v = i.split(":")
    d2[k] = int(v)
print(d1, d2)

```

# 5、请按alist中元素的age由大到小排序

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         9_请按alist中元素的age由大到小排序
# Description:  alist = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]
# Author:       zhaoyaowei
# Date:         2023/3/25 17:18
# -------------------------------------------------------------------------------

alist = [{'name': 'a', 'age': 20}, {'name': 'b', 'age': 30}, {'name': 'c', 'age': 25}]

# 方法一：
# 参考第5题
result_list = sorted(alist, key=lambda x: x["age"], reverse=True)

# 方法二：
# sort() 函数的key参数用来指定排序时使用的比较规则，
# 这里使用 lambda 表达式 key=lambda x:x['age'] 来指定按照字典元素的 age 值进行排序。
# 因为需要按从大到小排序，所以 reverse 参数设为 True。整个排序过程是在原来alist数据结构上进行的，
# 所以排序结果会直接反映在alist列表中。
alist.sort(key=lambda x: x['age'], reverse=True)

print(result_list, alist)

```

# 6、下面代码的输出结果将是什么？

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         10_下面代码的输出结果将是什么？
# Description:  
# Author:       zhaoyaowei
# Date:         2023/3/25 17:38
# -------------------------------------------------------------------------------

lst = ['a', 'b', 'c', 'd', 'e']
print(lst[10:])  # []
print(lst[10])  # IndexError: list index out of range

# 切片时，是对原始列表进行切片复制，超出范围，则为空，不会报错。切片时是对list进行浅拷贝
# 但是注意：当访问索引超出其长度的列表中元素时，无法返回值且报下标越界错误

```


# 7、写一个列表生成式，产生一个公差为11的等差数列

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         11_写一个列表生成式，产生一个公差为11的等差数列
# Description:  
# Author:       zhaoyaowei
# Date:         2023/3/25 18:21
# -------------------------------------------------------------------------------


lst1 = [i*11 for i in range(10)]
lst2 = [i for i in range(0, 100, 11)]

print(lst1, lst2)

```

# 8、给定两个列表，怎么找出他们相同的元素和不同的元素？

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         12_给定两个列表，怎么找出他们相同的元素和不同的元素？
# Description:  list1 = [1,2,3] list2 = [3,4,5]
# Author:       zhaoyaowei
# Date:         2023/3/25 18:28
# -------------------------------------------------------------------------------

list1 = [1, 2, 3]
list2 = [3, 4, 5]
# 方法一：集合(set)
set1 = set(list1)
set2 = set(list2)
print(set1 & set2)  # 交集  {3}  在 set1 和 set2 中
print(set1 ^ set2)  # 补集  {1, 2, 4, 5}  在 set1 或 set2 中，但不同时在
print(set1 | set2)  # 并集  {1, 2, 3, 4, 5}  在 set1 或 set2 中
print(set1 - set2)  # 差集  {1, 2}  在 set1 中，但不在 set2 中

# 方法二：列表推导式
common_list = [i for i in list1 if i in list2]
different_list = [i for i in list1 + list2 if i not in common_list]
print(common_list)
print(different_list)

```

# 9、请写出一段python代码实现删除list里面的重复元素？

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         13_请写出一段python代码实现删除list里面的重复元素？
# Description:  l1 = ['b','c','d','c','a','a']
# Author:       zhaoyaowei
# Date:         2023/3/25 19:01
# -------------------------------------------------------------------------------

l1 = ['b', 'c', 'd', 'c', 'a', 'a']
# 方法一：集合(set)
print(list(set(l1)))
# 方法二：for循环
l2 = []
for i in l1:
    if i not in l2:
        l2.append(i)
print(l2)

```

Python面试题汇总（三）

:::info{title="基础部分：模块与包"}
:::

# 1、输入日期，判断是这一天是这一年的第几天

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         3_输入日期，判断是这一天是这一年的第几天
# Description:  如：输入"2023-3-12"，输出"2023-3-12是2023年的第71天"
# Author:       zhaoyaowei
# Date:         2023/3/12 14:26
# -------------------------------------------------------------------------------
import datetime


def get_days():
    """
    方法一：
    需考虑年份是否为闰年，月份是否大于2
    :return: 示例：2023-3-12是2023年的第71天
    """
    s = input("请输入日期, 格式为yyyy-mm-dd:")
    year, month, day = map(int, s.split("-"))

    # 默认根据平年月份计算天数
    months = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]

    # 判断输入月份是否正确
    if 1 <= month <= 12:
        total = months[month-1]
        total += day

        leap = 0
        if (year % 400 == 0) or (year % 4 == 0 and year % 100 != 0):
            leap = 1

        # 判断输入日期是否正确
        days = [31, 28 + leap, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
        if day > days[month-1]:
            print("输入的日期错误")
        else:
            # 若为闰年且月份大于2，则天数增加一天
            if month > 2 and leap == 1:
                total += 1
            print(f"{s}是{year}年的第{total}天")
    else:
        print("输入的月份错误")


def get_days1():
    """
    方法二：采用python的内置模块datetime
    :return: 示例：2023-3-12是2023年的第71天
    """
    s = input("请输入日期, 格式为yyyy-mm-dd:")
    year, month, day = map(int, s.split("-"))

    date1 = datetime.date(year, month, day)
    date2 = datetime.date(year, 1, 1)
    # 计算天数差，若date2传餐（year, 12, 31）,则最终无需+1
    total = (date1 - date2).days + 1
    print(f"{s}是{year}年的第{total}天")


if __name__ == '__main__':
    get_days1()

```
# 2、打乱一个排好序的list对象alist?

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         4_打乱一个排好序的list对象alist?
# Description:  alist = [1,2,3,4,5]
# Author:       zhaoyaowei
# Date:         2023/3/12 19:41
# -------------------------------------------------------------------------------
import random

alist = [1, 2, 3, 4, 5]
# 方法一：不会生成新的列表，仅打乱原列表的次序
random.shuffle(alist)
print(alist)

# 方法二：
blist = random.sample(alist, len(alist))
print(blist)


# 附录：
"""
random库用于生成随机数
一、随机种子seed()
    （1）seed(a=None) 初始化给定的随机数种子，默认为当前系统时间 
        random.seed(10) #产生种子10对应的序列
二、随机整数
    （1）randint(a, b)	生成一个[a, b]之间的整数，左闭右闭
    （2）randrange(a)    生成[0, a)之间的随机整数，左闭右开
    （3）randrange(a, b, step)    生成[a, b)之间以setp为步长的随机整数，左闭右开
三、随机浮点数
    （1）random()     生成一个[0.0, 1.0)之间的随机浮点数
    （2）uniform(a, b)    生成[a, b]之间的随机浮点数 
四、序列函数
    （1）choice(seq)    从序列seq中随机选择一个元素
    （2）choices(seq,weights=None, k)    对序列类型进行k次重复采样，可设置权重，权重小的说明被取到的概率更小
        choices(['a', 'b', 'c'], [4,4,2], k=10) # 这里的[4,4,2]就是每个元素分别对应的权重 
    （3）shuffle(seq)	将序列seq中元素随机排列，返回打乱后的序列
    （4）sample(pop, k)    从pop类型中随机选取k个元素，返回列表，k <= len(list) 
"""

```

Python面试题汇总（二）

:::info{title="基础部分：文件操作"}
:::

# 1、有1个json格式的文件file.txt大小约为10k


```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         1_getline
# Description:  题目：有1个json格式的文件file.txt大小约为10k
# Author:       zhaoyaowei
# Date:         2023/3/11 15:25
# -------------------------------------------------------------------------------
import os
from mmap import mmap


def get_lines():
    """
    初级：读取整个文件的数据
    :return:
    """
    with open("file.txt", "r") as f:
        return f.readlines()


def get_lines_optimize():
    """
    进阶：比如待处理文件大小为10G，但内存只有4G，如何优化
    理解yield：使用yield的函数被称作生成器函数(generator function).
    生成器方法：next()--执行下一步、send()--可传入值，再执行下一步
    对比return：
        1. return直接返回结果，程序终止运行，并销毁局部变量
        2. yield会产生1个断点，暂停挂起函数，并且返回某个值，返回后不再继续往下运行
        3. 有yield的函数返回1个可迭代的生成器generator对象，并不会执行函数代码，直至对其调用next()
           可以使用for循环(自动调用next())、或者调用next()、send()方法
    :return:
    """
    a = []
    with open("file.txt", "r") as f:
        data = f.readlines(60000)
    a.append(data)
    yield a


def get_lines_super(filepath):
    """
    高级：进阶方法资源消耗和性能不友好，可继续优化，采用mmap模块
    mmap：一种虚拟内存映射文件方法。fileno-文件描述符号;length=0,映射整个文件。mmap操作字节，不是字符串。
    :return:
    """
    with open(filepath, 'r+') as f:
        m = mmap(f.fileno(), 0)
        index = 0
        for i, char in enumerate(m):
            if char == b'\n':
                yield m[index:i+1].decode()
                index = i + 1


def process(line):
    print(f"处理数据:{line}")


if __name__ == '__main__':
    # 读取整个文件的数据，并处理
    for e in get_lines():
        process(e)
    # 大文件分批优化处理，采用yield
    for e in get_lines_optimize():
        process(e)

    # 高级处理, mmap
    fp = os.getcwd() + '/file.txt'
    for e in get_lines_super(fp):
        process(e)

```
# 2、获取文件夹的层级文件夹和文件

```python
# -*- coding: utf-8 -*-#
# -------------------------------------------------------------------------------
# Name:         2_获取文件夹的层级文件夹和文件
# Description:  
# Author:       zhaoyaowei
# Date:         2023/3/12 13:39
# -------------------------------------------------------------------------------
import os


def get_directory_content(spath):
    """
    :param spath: 文件夹路径
    :return: 该文件夹中文件的路径以及其包含文件夹中文件的路径
    """
    # listdir返回path指定的文件夹包含的文件或文件夹的名字的列表
    for s_child in os.listdir(spath):
        # 路径拼接文件路径
        s_child_path = os.path.join(spath, s_child)
        # 判断子文件格式是否为文件夹，是，则递归；否则，打印文件路径
        if os.path.isdir(s_child_path):
            get_directory_content(s_child_path)
        else:
            print(s_child_path)


if __name__ == '__main__':
    spath = "/Users/zhaoyaowei/Desktop/project/InterviewQuestions/Python基础"
    get_directory_content(spath)

```