精华内容
下载资源
问答
  • 原标题:2019 Python后端开发面经总结本人技术栈为Python后端开发,面经如下:python基础部分:1. 迭代器生成器 生成器是如何实现迭代的2. list实现3. import一个包时过程是怎么样的?4. 装饰器实现5. 菱形继承6. ...

    原标题:2019 Python后端开发面经总结

    本人技术栈为Python后端开发,面经如下:

    python基础部分:

    1. 迭代器生成器 生成器是如何实现迭代的

    2. list实现

    3. import一个包时过程是怎么样的?

    4. 装饰器实现

    5. 菱形继承

    6. 内存垃圾回收:分代回收细节

    7. 项目具体

    8. mysql b+树

    9. wsgi

    二面

    1. 堆排序

    2. 比较c语言和Python语言中的异步

    3. epoll

    4. tornado框架

    5. 求二叉树深度

    6. mysql联合索引

    7. wsgi

    8. uwsgi进程模型

    网易互娱(offer)

    一面:

    面试最开始做的笔试题据说需要保密。。就不发了。。

    1. 自我介绍

    2. Python里的eval

    3. Python里的装饰器

    4. 虚拟内存与物理内存区别

    5. Top k问题

    6. 如何用两个栈表示一个队列

    7. 如何判断链表有没有环

    8. epoll

    9. 100个石头,每个人一次可以摸1-5个,甲先摸,问甲有没有必赢的方法;

    10. TCP与UDP的区别

    11. TCP的断开过程

    12. 二叉树的镜像

    工作需求相关面试官建议精通Linux,建议精通socket

    二面:

    1. PythonGIL锁

    2. C++ C 内嵌Python代码

    3. 有没有读Python源码

    4. Python垃圾回收

    5. Python内存泄露

    6. 游戏模型如何确认人身上的胶囊体是否被激光射中(主要就是扯这个题)

    7. 编译原理相关

    滴滴(意向)

    一面:

    1. tcp 三次握手

    2. 如果一个客户端不理会服务端发来的ack,一直重发syn怎么办?(我理解为类似syn洪水攻击)

    3. 拥塞控制 流量控制

    4. socket编程 raw_socket

    5. 从用户态到内核态的汇编级过程

    6. 中断以及系统调用

    7. 不用中间元素交换两个元素的方法,(答:使用异或),又问:不使用异或有什么缺点。。

    8. 亿级元素top k,答:k大小小顶堆,又问:如何多线程改进

    9. 全局变量和局部变量都保存在哪儿

    10. coding:递归翻转链表。。

    二面

    1. 网页相似性比较

    2. LRU(O(1)时间复杂度)

    3. rpc

    4. 多个有序数组合并为一个

    5. 服务感知(客户端如何感知服务端状态)

    三面

    1. 如果地球自转速度降低一半,会怎么样

    2. 项目,讲具体场景实现,情景题

    3. http cookie具体所有相关内容

    4. http传输一个二进制文件的所有过程

    5. coding:顺时针打印数组

    菜鸡一个,运气不错,大家共勉。返回搜狐,查看更多

    责任编辑:

    展开全文
  • 知识储备python 后端工程师每天做什么?网站后台业务逻辑为网站提供API为产品、运营提供后台网站工具,比如后台运营系统。知识储备-上:面试流程、技巧通过不断的面试加深自己的面试经验python语法基础、性能剖析...

    知识储备

    python 后端工程师每天做什么?

    网站后台业务逻辑

    为网站提供API

    为产品、运营提供后台网站工具,比如后台运营系统。

    知识储备-上:

    面试流程、技巧

    通过不断的面试加深自己的面试经验

    python语法基础、性能剖析优化

    算法与数据结构、内置算法、排序……

    编程范式,各种模式(单例模式……)

    操作系统,Linux命令、线程进程,操作系统内存管理、python垃圾回收机制

    学习-下:

    网络编程,网络协议:TCP/IP、UDP、HTTP……,python网络编程、并发网络库

    《计算机网络~自顶向下方法》

    数据库,MySQL基础、索引优化、SQL语句、redis缓存场景、redis数据类型

    Web框架,不同框架对比,WSGI,Web安全(SQL注入、XSS……)、前后端分离、Resful

    系统设计,短网址系统

    面试经验,

    面试流程和环节:

    技术问题

    一面基础

    成绩、课程、在校项目

    二面项目

    三面设计

    非技术问题

    自我介绍

    口头表达能力

    沟通交流能力

    HR面试

    薪资待遇(锚定效应,提出高一点的薪资)

    职业规划

    自我介绍

    python初、中级工程师技能要求

    计算机理论基础

    代码规范、风格良好(代码大全、代码整洁之道)

    靠谱地完成业务需求

    面试准备

    平台决定成长(业务体量)

    【单独再写一篇简历相关的文章】

    面试经历

    通用问题

    mysql优化方式

    数据结构(排序)

    面向对象基础知识(特性)

    专有问题

    django框架、drf

    展开全文
  • Python后端训练-源码

    2021-02-15 21:49:06
    Python后端训练
  • python后端开发面试常见问题 (持续更新)

    万次阅读 多人点赞 2021-03-14 15:21:18
    python后端开发面试常见问题   大家好,我叫亓官劼(qí guān jié ),在GitHub和CSDN中记录学习的点滴历程,时光荏苒,未来可期,一起加油~~ 本篇文章将在GitHub和CSDN上持续更新,主要是Python后端开发的...

    python后端开发面试常见问题

      大家好,我叫亓官劼(qí guān jié ),在GitHub和CSDN中记录学习的点滴历程,时光荏苒,未来可期,一起加油~~

    本篇文章将在GitHub和CSDN上持续更新,主要是Python后端开发的一些常见问题,包括Python的一些基础知识,以及面试中常问的计网,数据库,数据结构等一些算法题,总体覆盖面试的大多数问题。

    本文的GitHub地址为:python-development-interview-FAQ

    CSDN地址为:python后端开发面试常见问题 (持续更新)

    如果有帮助的话,可以在GitHub上点个star,支持下。相对来说GitHub更新要比CSDN上更新更快一些。

    创建了个交流群,如果需要可以加群一起交流,Q群545611263(为了避免广告小号,设置了0.1的付费群),也可以加我V:qiguanjie2015


    Python 基础

    0 说明占位符

    • 本文中不特别标注Python版本的,全部默认为Python3

    1 Python类中的方法类型

    在Python类中有四种方法类型,分别是实例方法、静态方法、类方法和普通方法。

    • 实例方法(即对象方法):需要实例化对象之后才能调用,接受的第一个参数self就是对象本身,必须使用实例化对象才可以访问,不能通过类直接访问.
    • 静态方法:可以通过类名直接调用,不需要传递selfcls;也可以在实例化对象后调用
    • 类方法:可以通过类名调用,也可以在实例化对象后调用。类方法需要一个cls参数,在调用时自动传递
    • 普通方法:和正常的函数一样,可以直接调用,但是在类中不建议写这种方法

    测试示例:

    class A(object):
        # 实例方法(对象方法),需要接收一个形参self,即实例对象自己
        def instance_method_fun(self):
            print("instance_method_fun,self is {}".format(self))
        
        # 类方法,需要接收一个形参cls,在调用时自动传递
        @classmethod
        def classmethod_fun(cls):
            print("classmethod_fun, cls is {}".format(cls))
    
        # 静态方法
        @staticmethod
        def staticmethod_fun():
            print("staticmethod_fun")
    
        # 普通方法
        def common_fun():
            print("common_fun")
    
    # A.instance_method_fun() # 报错:TypeError: instance_method_fun() missing 1 required positional argument: 'self'
    A.classmethod_fun() # 输出:classmethod_fun, cls is <class '__main__.A'>
    A.staticmethod_fun() # 输出:staticmethod_fun
    A.common_fun() # 输出:common_fun  (不建议在类中写普通方法)
    
    
    a = A()
    a.instance_method_fun() # 输出:instance_method_fun,self is <__main__.A object at 0x0000018674E1E588>
    a.classmethod_fun()# 输出:classmethod_fun, cls is <class '__main__.A'>
    a.staticmethod_fun()# 输出:staticmethod_fun
    

    2 Python的参数传递类型

    Python中的参数传递是引用传递,即我们可以对传递对象的属性,但是不能改变传递对象的指针。在Python中有一些对象的值是不可以更改的,例如int,float类型。如果在函数体内修改了不可修改对象的值,Python会在一个新的内存地址上创建一个变量,而不是使用原来的变量;如果在函数体内修改一个可修改对象的值,则在原内存地址操作。

    例如:

    def fun1(x):
        x = x + 1
        print("x:{},id(x):{}".format(x,id(x)))
    
    def fun2(x):
        print("b:{},id(b):{}".format(b,id(b)))
        x.append(2)
        print("b:{},id(b):{}".format(b,id(b)))
    
    a = 1
    print("a:{},id(a):{}".format(a,id(a)))
    fun1(a)
    print("a:{},id(a):{}".format(a,id(a)))
    
    b = []
    print("b:{},id(b):{}".format(b,id(b)))
    fun2(b)
    print("b:{},id(b):{}".format(b,id(b)))
    
    # 输出为:
    # a:1,id(a):1860272240
    # x:2,id(x):1860272272
    # a:1,id(a):1860272240
    # b:[],id(b):2262818473288
    # b:[],id(b):2262818473288
    # b:[2],id(b):2262818473288
    # b:[2],id(b):2262818473288
    

    3 协程

    这个是在前不久的面试中才知道有协程这个概念,其实也可以理解为用户线程,相比较内核线程而言,用户线程更加的灵活,并且减少了进出内核态的消耗,缺点是无法利用多核CPU的并行优势。

    4 Python命名中的单下划线(_)和双下划线(__)

    在Python中,双下划线开头和结尾的命名默认为Python的内部变量/方法,用以区分用户变量。例如场景的__init__(),__dict__,__dir__等。

    单下划线开头的命名默认为私有变量,不会在from a import *中被导入

    双下划线开头,但是没有下划线结尾的命名,Python在解释的时候会默认对其进行重命名为_类名__变量

    class A():
        def __init__(self) -> None:
            self._b = "self._b"
            self.__c = "self.__c"
    a = A()
    print(a._b) # 输出:self._b
    # print(a.__c) # 报错:AttributeError: 'A' object has no attribute '__c'
    print(a.__dict__) # 输出:{'_b': 'self._b', '_A__c': 'self.__c'}
    # 我们发现__c变量被自动重命名为_A__c了
    print(a._A__c) # 输出:self.__c
    

    在Python中,当一个文件夹下有一个__init__.py文件,则Python会识别这个文件夹为一个Python包

    5 python字符串传参 %s和format

    %s和format的区别在于,format可以传递列表、元组等类型,而%s不可以传递元组类型(%s可以传递列表类型),所以在日常使用时,使用format更加方便

    6 python 迭代器和生成器

    迭代器是python十分强大的一个功能,迭代器是一个可以记住遍历位置的对象。例如:

    a = [1,2,3,4]
    it = iter(a) # 获取一个迭代器对象
    print(next(it)) # 遍历下一个位置,输出:1
    print(next(it)) # 遍历下一个位置,输出:2
    

    我们也可以使用迭代器来生成一个我们需要的列表,例如:

    a = [i*i for i in range(1,9)] # 使用迭代器生成一个[1,9)的平方的列表
    print(a) # 输出:[1, 4, 9, 16, 25, 36, 49, 64]
    

    在这里如果我们将外面的[]改为(),a获取的将会是一个生成器,而不是迭代器。在python中,使用yield的函数被称为生成器,生成器返回的是一个迭代器的函数,只能用于迭代操作,在调用生成器运行的过程中,每次遇到 yield 时函数会暂停并保存当前所有的运行信息,返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

    生成器不保留所有的数据信息,而是指记录当前运行的信息。因此生成器就不能直接获取某个下表的值,而是要通过next()或者sent(),亦或是迭代器来依次获取值。

    例如:

    a = (i*i for i in range(1,9)) # 使用生成器生成一个[1,9)的平方的列表
    print(a) # 输出:[1, 4, 9, 16, 25, 36, 49, 64]
    # print(a[2]) # 报错TypeError: 'generator' object is not subscriptable
    it = iter(a) # 获取一个迭代器对象
    print(next(a)) # 输出 1
    print(next(a)) # 输出 4
    print(next(a)) # 输出 9
    print(next(a)) # 输出 16
    print("=================")
    for item in a:
        print(item)
    # 输出:
    # 25
    # 36
    # 49
    # 64
    

    生成器常用场景:例如我们需要生成一个有规律向前推进的列表,或者一个从1到1亿的列表等等,当我们列表中元素数量十分大时,内存会爆栈。但是如何我们元素间是有规律的,则我们可以利用生成器来解决这个问题。

    有需要的话可以参考这篇文章:学点简单的Python之Python生成器

    7 python 装饰器

    装饰器是一个十分常用的东西,经常被用在有切面需求的场景,大家耳熟能详的AOP就是这个,装饰器的主要功能就是为已经存在的函数提供一些可复用的定制化功能。

    装饰器包含很多内容,需要系统的去看,这里不展开。如有需要,可以参考这篇文章:学点简单的Python之Python装饰器与闭包

    8 python 变量中的作用域

    python中变量总是默认本地变量,如果没有,则会创建一个本地变量。在函数中如果要使用全局变量,需要使用gloabl进行声明。例如:

    a = 5
    def fun():
        global a
        a = a + 1
    fun()
    print(a)# 输出:6
    

    9 python 闭包

    python闭包与其他语言的闭包的意思是一样的,即我们在函数定义中引用了函数外定义的变量,并且该函数可以在其定义环境外被执行。简单来说,就是在函数内定义函数,且函数内部定义的函数中使用了外部函数中的变量,且内部函数可以单独的运行。

    这里用语言来描述还是比较的绕,我们可以通过下面这个小例子来更直观的理解:

    # 定义一个函数extern_func
    def extern_func():
        # 在extern_func函数内定义一个空列表list
        list = []
        # 在extern_func函数内定义一个函数inner_func
        def inner_func(name):
            # inner_func函数的功能是在list列表中添加一个name,然后输出list
            list.append(name)
            print(list)
        # exten_func函数的返回值是inner_func的函数体
        return inner_func
    
    # 调用extern_func函数,返回值赋值给ret1,即ret1为inner_func函数体
    ret1 = extern_func()
    ret1('zhangsan')# 调用ret1,在list中添加一个'zhangsan',并输出list
    ret1('lisi')# 调用ret1,在list中添加一个'lisi',并输出list
    
    # 调用extern_func函数,返回值赋值给ret2,即ret2为inner_func函数体
    ret2 = extern_func()
    ret2('wangwu')# 调用ret2,在list中添加一个'wangwu',并输出list
    
    ret1('qiguanjie')# 调用ret1,在list中添加一个'lisi',并输出list
    

    输出为:

    ['zhangsan']
    ['zhangsan', 'lisi']
    ['wangwu']
    ['zhangsan', 'lisi', 'qiguanjie']
    

    我们发现ret1ret2中虽然都是在list中添加一个name并返回,但是ret1ret2是两次调用extern_func( )返回的函数体,他们作用的list是不同的,他们作用的list可以脱离原函数extern_func()而单独使用。这就是函数闭包的简单使用。简而言之就是我们在函数中定义函数,并且使用了外部函数中的部分变量,我们内部的函数在脱离外部函数之后继续执行,且单独作用于外部函数的部分变量。

    闭包一个常见错误:

    我们看下面这个例子

    def func():
        list = []
        for i in range(3):
            def inner_func():
                return i*i
            list.append(inner_func)
        return list
    re1,re2,re3= func()
    print(re1())
    print(re2())
    print(re3())
    

    大家是不是以为三个输出的结果应该是0,1,4?但实际上输出的结果都是4,这是为什么呢?这里我们的i对于inner_func来说是一个外部函数,我们在list中添加是是inner_func的函数体,里面返回的是i*i,但是当我们i变化到2之后,我们才返回list,所以我们输出的三个值才都是4,那如何避免这种情况呢?

    第一种方法,区分变量

    我们使用_i来区分i

    def func():
        list = []
        for i in range(3):
            def inner_func(_i = i):
                return _i*_i
            list.append(inner_func)
        return list
    re1,re2,re3= func()
    print(re1())
    print(re2())
    print(re3())
    

    这里我们在inner_func的参数中定义_i变量,值为当前的i,这时我们将函数体加入list中,就可以保证值不受i值变化的影响,输出为0,1,4。另一种方法就是我们直接在list中存放计算好的值,而不是函数体(这种方法有一定的局限性,和之前的方法就是两种完全不同的方法了):

    def func():
        list = []
        for i in range(3):
            def inner_func():
                return i*i
            list.append(inner_func())
        return list
    re1,re2,re3= func()
    print(re1())
    print(re2())
    print(re3())
    123456789101112
    

    这里我们这里添加到list中的是inner_func(),一旦有()则表明我们这个函数已经运行了,返回的是一个值。

    第二种方法 nonlocal关键字

    那如果我们要在内部函数中使用外部函数中的变量,并进行修改我们应该如何做呢?

    def extern_func(name):
        print('exter_func name is : %s' % name)
        def inner_func():
            name = 'inner_func ' + name
            print('inner_func name is : %s' % name)
        return inner_func
    
    ret = extern_func('qiguanjie')()
    

    如何我们直接修改的话,我们会发现这里编译会报错:UnboundLocalError: local variable 'name' referenced before assignment

    这里报错的意思即我们这里的name变量在使用前未被分配,这就和我们在函数内使用全局变量时要使用globle关键字一样,这里在内部函数中要使用并更改外部函数中的变量,我们需要使用关键字nonlocal,对程序进行修改:

    def extern_func(name):
        print('exter_func name is : %s' % name)
        def inner_func():
            nonlocal name
            name = 'inner_func ' + name
            print('inner_func name is : %s' % name)
        return inner_func
    
    ret = extern_func('qiguanjie')()
    

    此时程序顺利编译,输出结果为:

    exter_func name is : qiguanjie
    inner_func name is : inner_func qiguanjie
    

    10 python lambda函数

    lambda函数即匿名函数,在很多场合都可以使用。lambda 函数比较轻便,即用即仍,很适合需要完成一项功能,但是此功能只在此一处使用,连名字都很随意的情况下。

    例如在sort函数中指定排序的key:

    a = [{"a":13,"b":25,"c":62},{"a":63,"b":215,"c":612},{"a":3,"b":634,"c":216}]
    a.sort(key=lambda x: x['a'])
    print(a) # 输出: [{'a': 3, 'b': 634, 'c': 216}, {'a': 13, 'b': 25, 'c': 62}, {'a': 63, 'b': 215, 'c': 612}]
    a.sort(key=lambda x: x['b'])
    print(a) # 输出: [{'a': 13, 'b': 25, 'c': 62}, {'a': 63, 'b': 215, 'c': 612}, {'a': 3, 'b': 634, 'c': 216}]
    a.sort(key=lambda x: x['c'])
    print(a) # 输出: [{'a': 13, 'b': 25, 'c': 62}, {'a': 3, 'b': 634, 'c': 216}, {'a': 63, 'b': 215, 'c': 612}]
    
    

    11 python中的深拷贝与浅拷贝

    在浅拷贝时,拷贝出来的新对象的地址和原对象是不一样的,但是新对象里面的可变元素(如列表)的地址和原对象里的可变元素的地址是相同的,也就是说浅拷贝它拷贝的是浅层次的数据结构(不可变元素),对象里的可变元素作为深层次的数据结构并没有被拷贝到新地址里面去,而是和原对象里的可变元素指向同一个地址,所以在新对象或原对象里对这个可变元素做修改时,两个对象是同时改变的,但是深拷贝不会这样,这个是浅拷贝相对于深拷贝最根本的区别。

    在深拷贝时,会只拷贝所有元素的值,包括可变对象,也仅拷贝对象中的值,而不是地址。

    import copy
    a = [1,2,3,4,['a','b','c']]
    b = a # 赋值(引用传递)
    c = copy.copy(a)# 浅拷贝
    d = copy.deepcopy(a) # 深拷贝
    
    a.append(5)
    a[4].append('d')
    print("a:{},  id(a):{}, id(a[4]):{}".format(a,id(a),id(a[4])))
    print("b:{},  id(b):{}, id(b[4]):{}".format(b,id(b),id(b[4])))
    print("c:{},     id(c):{}, id(c[4]):{}".format(c,id(c),id(c[4])))
    print("d:{},          id(d):{}, id(d[4]):{}".format(d,id(d),id(d[4])))
    
    # 输出为:
    # a:[1, 2, 3, 4, ['a', 'b', 'c', 'd'], 5],  id(a):1998224934024, id(a[4]):1998224933896
    # b:[1, 2, 3, 4, ['a', 'b', 'c', 'd'], 5],  id(b):1998224934024, id(b[4]):1998224933896
    # c:[1, 2, 3, 4, ['a', 'b', 'c', 'd']],     id(c):1998224936904, id(c[4]):1998224933896
    # d:[1, 2, 3, 4, ['a', 'b', 'c']],          id(d):1998224935752, id(d[4]):1998224957960
    

    12 Python中*args和**kwargs

    *args表示传一个元组给函数,可以同时传递多个参数,这里的args可以替换为其他名称,前面加一个*即可,例如:*para都可以。

    **kwargs表示传一个字典给函数,可以传多个键值对,这里的kwargs同样也可以替换为其他名称,前面有**即可。

    两者的不同如下所示:

    def fun(*args,**kwargs):
      print("args: ",args)
      print("kwargs: ",kwargs)
    
    fun("hello","world","!","this","is","args",a=1,b=2,c=3)
    
    # 输出为:
    # args:  ('hello', 'world', '!', 'this', 'is', 'args')
    # kwargs:  {'a': 1, 'b': 2, 'c': 3}
    

    13 Python中__new____init__的区别

    __new__是静态方法,会返回一个创建的实例

    __init__是实例方法,无返回值

    14 Python中的单例模式

    单例模式是一种特别重要的设计模式,通过单例模式可以保证系统中一个类只有一个实例并且该实例易于被外界访问,方便控制实例个数并节约系统资源。实现单例模式的常用方法如下:

    1 通过import导入

    在Python中使用import来导入一个对象,则是天然的单例模式。因为模块在第一次导入时,会生成 .pyc 文件,当第二次导入时,就会直接加载 .pyc 文件,而不会再次执行模块代码。因此,我们只需把相关的函数和数据定义在一个模块中,就可以获得一个单例对象了。例如:

    # a.py中
    class A(object):
        def fun(self):
            pass
    test_a = A
    
    # b.py中
    from a import test_a
    

    2 使用装饰器

    def Singleton(cls):
        _state = {}
        def _singleton(*args, **kargs):
            if cls not in _state:
                _state[cls] = cls(*args, **kargs)
            return _state[cls]
        return _singleton
    
    
    @Singleton
    class A(object):
        a = 1
        def __init__(self, x=0):
            self.x = x
    
    a1 = A()
    a2 = A()
    
    print("id(a1): ",id(a1))
    print("id(a2): ",id(a2))
    
    print("a1.a: ",a1.a)
    print("a2.a: ",a2.a)
    
    a1.a = 2
    print("a1.a: ",a1.a)
    a2.a = 3
    print("a2.a: ",a2.a)
    
    print("a1.a: ",a1.a)
    
    # 输出为:
    # id(a1):  2973113231736
    # id(a2):  2973113231736
    # a1.a:  1
    # a2.a:  1
    # a1.a:  2
    # a2.a:  3
    # a1.a:  3
    

    3 使用类实现

    使用类实现的时候需要加锁,否则在多线程中无法保证单实例

    import time
    import threading
    class Singleton(object):
        _instance_lock = threading.Lock()
    
        def __init__(self):
            time.sleep(1)
    
        @classmethod
        def instance(cls, *args, **kwargs):
            with Singleton._instance_lock:
                if not hasattr(Singleton, "_instance"):
                    Singleton._instance = Singleton(*args, **kwargs)
            return Singleton._instance
    
    
    def task(arg):
        obj = Singleton.instance()
        print(obj)
    for i in range(10):
        t = threading.Thread(target=task,args=[i,])
        t.start()
    time.sleep(20)
    obj = Singleton.instance()
    print(obj)
    
    # 输出:
    # <__main__.Singleton object at 0x0000022E7C561E80>
    # <__main__.Singleton object at 0x0000022E7C561E80>
    # <__main__.Singleton object at 0x0000022E7C561E80>
    # <__main__.Singleton object at 0x0000022E7C561E80>
    # <__main__.Singleton object at 0x0000022E7C561E80>
    # <__main__.Singleton object at 0x0000022E7C561E80>
    # <__main__.Singleton object at 0x0000022E7C561E80>
    # <__main__.Singleton object at 0x0000022E7C561E80>
    # <__main__.Singleton object at 0x0000022E7C561E80>
    # <__main__.Singleton object at 0x0000022E7C561E80>
    

    4 基于__new__方法实现

    当我们实例化一个对象时,是先执行了类的__new__方法(我们没写时,默认调用object.new),实例化对象;然后再执行类的__init__方法,对这个对象进行初始化,所有我们可以基于这个,实现单例模式

    import threading
    class Singleton(object):
        _instance_lock = threading.Lock()
    
        def __init__(self):
            pass
    
        def __new__(cls, *args, **kwargs):
            if not hasattr(Singleton, "_instance"):
                with Singleton._instance_lock:
                    if not hasattr(Singleton, "_instance"):
                        Singleton._instance = object.__new__(cls)  
            return Singleton._instance
    
    obj1 = Singleton()
    obj2 = Singleton()
    print(obj1)
    print(obj2)
    
    def task(arg):
        obj = Singleton()
        print(obj)
    
    for i in range(10):
        t = threading.Thread(target=task,args=[i,])
        t.start()
    
    # 输出
    # <__main__.Singleton object at 0x0000017B102EA978>
    # <__main__.Singleton object at 0x0000017B102EA978>
    # <__main__.Singleton object at 0x0000017B102EA978>
    # <__main__.Singleton object at 0x0000017B102EA978>
    # <__main__.Singleton object at 0x0000017B102EA978>
    # <__main__.Singleton object at 0x0000017B102EA978>
    # <__main__.Singleton object at 0x0000017B102EA978>
    # <__main__.Singleton object at 0x0000017B102EA978>
    # <__main__.Singleton object at 0x0000017B102EA978>
    # <__main__.Singleton object at 0x0000017B102EA978>
    # <__main__.Singleton object at 0x0000017B102EA978>
    # <__main__.Singleton object at 0x0000017B102EA978>
    

    15 Python中is==的区别

    is是对指针的比较,==是对值的比较。

    a = [1,2,3,4]
    b = [1,2,3,4]
    print(a is b) # 输出 False
    print(a == b) # 输出 True
    

    16 Python3 和Python2的区别

    • Python2的print不用加()而python3需要
    • python2的/表示整除(不加.0的时候),而Python3是除
    • Python3的A / B的返回值类型都是float,而Python2可能是整型
    • python2默认编码是ascii,python3的默认编码是utf-8
    • python3新增了nonlocal关键字,用于实现非局部变量

    等等,这里例举的几个是常见的价格区别。

    17 Python中a += X和a = a + x的区别

    在Python中,a += X和a = a + x的实现机制是不同的,这里分为四种情况。

    • 可变类型
      • a += x:将会在a原地址上进行修改,a的地址不变
      • a = a + x:将会新创建一个对象,名称为a,但是地址与原来的地址不同。
    • 不可变类型
      • a += x:将会新创建一个对象,名称为a,但是地址与原来的地址不同。
      • a = a + x:将会新创建一个对象,名称为a,但是地址与原来的地址不同。

    程序示例:

    a = [1,2,3]
    print("a原地址为:{}".format(id(a)))
    a += [4,5]
    print("进行a += [4,5]操作后的a地址为:{}".format(id(a)))
    a =a + [4,5]
    print("进行a =a + [4,5]操作后的a地址为:{}".format(id(a)))
    
    a = 1
    print("a原地址为:{}".format(id(a)))
    a += 2
    print("进行a += 2操作后的a地址为:{}".format(id(a)))
    a =a + 2
    print("进行a =a + 2操作后的a地址为:{}".format(id(a)))
    

    输出为:

    a原地址为:140591562829000
    进行a += [4,5]操作后的a地址为:140591562829000
    进行a =a + [4,5]操作后的a地址为:140591562984456
    a原地址为:4391820368
    进行a += 2操作后的a地址为:4391820432
    进行a =a + 2操作后的a地址为:4391820496
    

      大家好,我是亓官劼(qí guān jié ),在【亓官劼】公众号、CSDN、GitHub、B站、华为开发者论坛等平台分享一些技术博文,主要包括前端开发、python后端开发、小程序开发、数据结构与算法、docker、Linux常用运维、NLP等相关技术博文,时光荏苒,未来可期,加油~
      如果喜欢博主的文章可以关注博主的个人公众号【亓官劼】(qí guān jié),里面的文章更全更新更快。如果有需要找博主的话可以在公众号后台留言,我会尽快回复消息,其他平台私信回复较慢。
    在这里插入图片描述

    由于学习工作的需要,算法刷题将会逐渐由C++向Python3过度,正在过度中,如实现的不太优美,请见谅。

    本文原创为【亓官劼】(qí guān jié ),请大家支持原创,部分平台一直在恶意盗取博主的文章!!! 全部文章请关注微信公众号【亓官劼】。

    展开全文
  • python软件开发,php软件开发,后端开发,运维自动化系统开发,堡垒机,云管平台,企业it信息化解决方案管理系统开发...前言hello,我是kuls.又已经有一段时间没写原创了,今天总算闲了一会,趁着这个闲暇来写篇文章...

    o55g08d9dv.jpg广告关闭

    腾讯云11.11云上盛惠 ,精选热门产品助力上云,云服务器首年88元起,买的越多返的越多,最高返5000元!

    python软件开发,php软件开发,后端开发,运维自动化系统开发,堡垒机,云管平台,企业it信息化解决方案管理系统开发...

    前言hello,我是kuls.又已经有一段时间没写原创了,今天总算闲了一会,趁着这个闲暇来写篇文章。 今天我想以个人观点来简单说说java后端开发和python后端开发的区别。 java&python backend公众号老粉可能知道公众号以前的名称是javaandpython君,后面才改名为python进击者。 为什么起这个名称? 其实很简单,因为我在...

    pythonweb后端开发不为人知的密码学(高级安全课程)...

    fdzmcw067c.jpeg

    作者 ayocross原文链接:https:blog.csdn.netayocrossarticledetails56509840先介绍下我的情况:通信背景,工作一年多不到两年。 之前一直在做c++的mfc软件界面开发工作。 公司为某不景气的国企研究所。 (喏,我的工作经验很水:1是方向不对; 2是行业有偏差)。 然后目前是在寻找python后端开发这一块的工作,使用...

    k9vio878e1.png

    let,s go python! ?先介绍下我的情况:通信背景,工作一年多不到两年。 之前一直在做c++的mfc软件界面开发工作。 公司为某不景气的国企研究所。 (喏,我的工作经验很水:1是方向不对; 2是行业有偏差)。 然后目前是在寻找python后端开发这一块的工作,使用的框架为django; 之前一直通过csdn以及其他几家技术博客...

    产品是一款服务于人力资源的saas在线服务,面向hr有web androidios 小程序多个客户端,后端采用restful风格api来提供服务。 主要使用python语言,方便快速...来腾讯之前在前公司做了3年的后端开发,经历一款saas产品从0到10(还没有到100, 哈哈哈)的过程,3年间后端的架构逐步演变,在微服务的实践过程中遇到的...

    pgtv6jrtpi.png

    python后端python后端技术栈web请求的流程浏览器负载均衡web框架业务逻辑数据库缓存python语言基础语言特点语法基础高级特性算法与数据结构常用算法和数据结构分析时间、控件复杂度实现常见数据结构和算法编程范式面向对象编程常用设计模式函数式编程操作系统常用linux命令进程、线程内存管理网络编程常用协议tcp、ip...

    pur5veamzk.png

    2.9 python web后端数据结构总结1. 常见的数据结构链表、队列、栈、二叉树、堆2. 使用内置结构实现高级数据结构,比如内置的 listdeque 实现栈3. 可以多看一下 leetcode 或者 《剑指 offer》上的经典题1. 2.10链表链表有单链表、双链表、循环双端链表。 大家要掌握的是如下:1. 如何使用 python 来表示链表结构2...

    mtqw3jzq84.png

    1 python 语言特性python 是动态强类型语言,很多人都误认为是弱类型语言,其实是错误的。 动态是指在运行期确定类型(静态则是在编译期确定类型)。 强类型指的是在没有强制类型转化前,不允许两种不同类型的变量相互操作(也就是不会发生隐式类型转换)。 2.1. 2 python 作为后端语言的优缺点为什么使用 python ?...

    由于python具有快速开发,多人协作,库丰富,社区成熟等优点,国内豆瓣知乎搜狐果壳饿了吗,国外youtuberedditinstagrampinterestbitbucketdisqusdropbox等都相继将其作为主力开发语言,所以完全不用担心它的可靠性与性能问题,因为它已受了时间和大规模用户并发访问的考验2. 很多人以为只要学会某个web框架,能写代码查查...

    www.zhihu.comquestion33398583,如何面试python工程师? 我斗胆回答了一下,http:www.zhihu.comquestion33398583answer59017861 吃午饭的时候我就一直在想这个问题,我觉得重点不是python而是后端工程师,因为python只是系统的一部分,linux基础操作要熟吧,sql要懂吧,消息队列要知道吧,git要熟悉吧...

    python软件开发,后端开发,运维自动化系统开发,堡垒机,云管平台,企业it信息化解决方案管理系统开发...

    之前一直在做c++的mfc软件界面开发工作。 公司为某不景气的国企研究所。 (喏,我的工作经验很水:1是方向不对; 2是行业有偏差)。 然后目前是在寻找python后端开发这一块的工作,使用的框架为django; 之前一直通过csdn以及其他几家技术博客论坛吸收大家的经验,在感激之余,也想输出点什么,造福大家,因此就有了...

    iw98a4u0ti.jpeg

    之前一直在做c++的mfc软件界面开发工作。 公司为某不景气的国企研究所。 (喏,我的工作经验很水:1是方向不对; 2是行业有偏差)。 然后目前是在寻找python后端开发这一块的工作,使用的框架为django; 之前一直通过csdn以及其他几家技术博客论坛吸收大家的经验,在感激之余,也想输出点什么,造福大家,因此就有了...

    awz0iwt3m5.jpeg

    原文标题:一名python web后端开发工程师的面试总结先介绍下我的情况通信背景,工作一年多不到两年。 之前一直在做c++的mfc软件界面开发工作。 公司为某不景气的国企研究所。 (喏,我的工作经验很水:1是方向不对; 2是行业有偏差)。 然后目前是在寻找python后端开发这一块的工作,使用的框架为django; 之前一直...

    q9rj8hwizq.png

    插入数据的时候删除响应缓存,或者设置较短的超时时间。 1.6.4. 12如何解决缓存击穿问题缓存击穿指的是某些非常热点的数据 key 过期,大量请求打到后端...出现隐式类型转换(在 python 这种动态语言查询中需要注意参数类型和 sql查询中的类型是不是一样的,不一样会出现慢查询)3. 没有满足最左前缀原则...

    xxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxx python的uuid模块提供uuid类和函数uuid1(),uuid3(), uuid4(), uuid5() 1.uuid.uuid1(])基于时间戳 使用主机id, 序列号,和当前时间来生成uuid, 可保证全球范围的唯一性. 但由于使用该方法生成的uuid中包含有主机的网络地址, 因此可能危及隐私. 该函数有两个参数, 如果 node 参数未...

    61i2hir3os.png

    前后端分离就是后端只负责提供数据接口,不再渲染模板,前端获取数据并呈现。 它主要有以下几个优点:1. 前后端解耦,接口复用(前端和客户端公用接口),减少开发量2. 各司其职,前后端同步开发,提升工作效率。 定义好接口规范3. 更有利于调试(mock)、测试和和运维部署1. 7.3. 2 什么是 restful它的全称是 ...

    ixnn6oy3hv.png

    如何设计以及如何实现一个后端系统服务的设计1. 8.1. 1 什么是系统设计 systemdesign系统设计是一个定义系统架构、模块、接口和数据满足特定需求的过程...先看一个简单的例子,怎么将 10 进制转化成 2 进制。 口诀就是不断取余,倒叙输出。 python 中 bin 这个函数可以进行转化,但是我们不用,我们傲娇...

    4ri89ffmqf.png

    那么如何识别用户呢? 我们需要在服务端给用户生成一个标识,然后每次让客户端带过去给后端。 这就是我们通常识别用户会话的一个思路。 1.session 一般是...callback = key.data callback(key.fileobj, mask)1. 5. 5 python 并发网络库其实 python 的各种并发网络库底层也是使用了上面提到的 io多路复用。 1.5.5...

    展开全文
  • 宠物酒店python后端
  • 前端: 测试表单 名字 : 年龄 : 密码: 性别: 男 女 提交表单: python服务器 # coding=utf8 from flask import Flask, request, jsonify import json app = Flask(__name__) @app.route("/get/sum", methods=[...
  • python后端面试题

    2018-06-04 15:58:01
    Python后端的常见面试题,共53个。 1. *args, **kwargs是什么意思 2.谈一谈python中的装饰器 3.python的垃圾回收机制以及内存管理 4.Python多线程(multi-threading)。这是个好主意吗? 5.说明os,sys模块不同,并...
  • 今天小编就为大家分享一篇python后端接收前端回传的文件方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • PythonBackend:Python后端开发课程,2021年Spring
  • 关于python后端开发所需的技术栈的总结
  • missionout_backend Python后端可与Missionout App一起使用
  • Django 进度条前端实时更新后端处理进度 – python后端实现进度条
  • Python后端技术栈

    千次阅读 2019-10-22 19:53:26
    Python后端技术栈(一) Happiness is a way of travel. Not a destination. 幸福是一种旅行方式。 不是目的地。 1.导航 1.1Python 语言基础 1.语言特点 2.语法基础 3.高级特性 1.2算法与数据结构 1.常用算法和数据...
  • 然后目前是在寻找Python后端开发这一块的工作,使用的框架为django;之前一直通过CSDN以及其他几家技术博客/论坛吸收大家的经验,在感激之余,也想输出点什么,造福大家,因此就有了这篇水文,希望大家能够多多吸取...
  • 如何面试Python后端工程师?金三银四,三月是个跳槽的好季节,有人忙着找工作,有人忙着招人,作为招招聘企业,如何找到一位靠谱的 Python 后端工程师是最重要的,作为候选人,找到一个心仪的公司是最重要的,只有...
  • _栗昕源的简历_python后端开发_三年_ .pdf
  • 本篇文章旨在通过一段JavaScript来演示如何调用python后端服务的,这是我开发的一个构建测试数据的工具。 第一部分:html 代码部分 第二部分:JavaScript代码部分 第三部分:Python后端代码 @app....
  • python后端开发学习内容有哪些? 【导语】Python是一个强大的面向对象的程序设计语言,在人工智能领域,在网络爬虫、服务器开发、3D游戏、网络编程、数据分析、Web开发、运维、测试等多个领域都有不俗的表现,但学习...
  • Python后端开发面经

    2019-10-04 18:48:07
    python 后端工程师每天做什么? 网站后台业务逻辑 为网站提供API 为产品、运营提供后台网站工具,比如后台运营系统。 知识储备-上: 面试流程、技巧 通过不断的面试加深自己的面试经验 python语法基础、性能...
  • 阿里云钉钉应用python后端开发之安装MySQL数据库 在本系列文章中,项目需要选择MySQL作为默认数据库。 在python后端开发中,可以选择的数据库有PostgreSQL, MariaDB, MySQL, or Oracle等,一般情况下,PostgreSQL是...
  • solar-api:Solar App-使用Flask和Firestore的Python后端API
  • vue前端+Python后端环境配置及前后端访问1、项目需求2、项目初始化3、前后端连接4、vue项目打包5、pycharm 调试 1、项目需求 项目本来是用C#写后端的,但是由于需要对影像作栅格处理,虽然GDAL也支持C#,但是我选择...
  • Python后端开发要求

    2017-08-07 15:44:00
    关于Python后端开发要求 一.对Python有兴趣,熟悉Python(标准库) 最好阅读过源码 了解Python的优化(熟悉pypy更佳) 二.至少至少一门语言(不说“精通”) 起码熟悉其他基本语言 C/C++ Lisp Haskell Scheme ...
  • 主要介绍了3分钟看懂Python后端必须知道的Django的信号机制,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • python后端对接微信支付引言一、流程简述&难点简析二、前期准备三、统一下单四、生成前端所需参数五、总结 注意:原创文章,转载请注明出处。 引言 我从未想到就调两个接口那么难! 前段时间由于项目需要,开发...
  • sa科 聊天机器人的实验性定向服务,请使用SAAE no Telegram或Python后端
  • python 后端数据保存在数据库 form 字典,且里面的value的类型应该与model里面的设置一样 通过序列化完成 form = {'best_estimator': char} best_estimator = SVMParamsSerializer(data=form) if best_estimator....
  • Python 是一种计算机程序设计语言,既可用于前端还可用于后端开发。它是一种动态的、面向对象的脚本语言,最初被设计用于编写自动化脚本(shell),随着版本的不断更新和语言新功能的添加,越来越...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 119,696
精华内容 47,878
关键字:

python后端

python 订阅