精华内容
下载资源
问答
  • 2020-12-18 00:57:05

    python后端开发工程师 深圳市超频三科技股份有限公司 深圳市超频三科技股份有限公司,超频三,超频三科技,超频三 职责:

    1、负责集成各种维度的数据源,使用各种数据获取技巧,转换、分析、调度、存储数据,为公司业务提供正确稳定的数据;

    2、负责建设高可靠、高并发的分布式系统;

    3、负责提升系统的稳定性,持续迭代更新,保证系统质量和交付及时性;

    4、负责编写相关的技术文档和单元测试,对产品质量负责;

    5、熟练掌握Hadoop生态组件,包括不限于HDFS、Hive、yarn、flink、kafka;

    6、拥有大数据建模经验,在数据建模、数据治理、数据优化、数据挖掘等方向有实际经验;

    7、有良好的逻辑分析能力和沟通能力,快速学习能力,有责任感主动性强,良好的团队合作精神,能适应一定压力的工作;

    任职要求:

    1. 本科以上学历,计算机或软件相关专业。3-5年相关经验;

    2. 英语四级。能够阅读英文文档;

    3. 熟悉Flask框架,熟悉Requests;

    4. 熟悉Python编程语言;

    5. 熟练使用MySQL/MongoDB等数据库;

    6. 熟练使用Mac/Ngnix下常用的CLI指令;

    7. 熟悉使用git进行代码管理者优先;

    8. 有物联网开发、数据挖掘经验优先。

    更多相关内容
  • 如下所示: filename=None  if request.method == 'POST' and request.FILES.get('file'):  from django.core.files.storage import FileSystemStorage...以上这篇python后端接收前端回传的文件方法就是小编分享给大
  • 电极 ![电极图像]( ) 设置 先决条件: npm的节点: ... 要查看您的Python更改,请终止服务器控件+ c并重新启动它。 实时重新加载Python服务器在待办事项列表中 要查看您的Electron更改(JS / HTML / C
  • Python 笔记源码——内含python后端&机器学习等.zip Python 笔记源码——内含python后端&机器学习等.zip Python 笔记源码——内含python后端&机器学习等.zip Python 笔记源码——内含python后端&机器学习等.zip ...
  • 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后端学习路线

    2020-12-03 21:47:46
    下面是小编为您整理的关于python后端学习路线,希望对你有所帮助。python后端学习路线九层之台,起于垒土。想要成为Python开发领域的高端人才,基础知识很重要,而实战经验也很重要。只有将理论知识与实战项目紧密...

    人工智能时代,想要从事编程行业,最佳的学习语言是什么?当然是Python!Python入门简单、功能强大,已成为各大企业首选开发语言,也吸引了无数有志学子投身学习。下面是小编为您整理的关于python后端学习路线,希望对你有所帮助。

    python后端学习路线

    九层之台,起于垒土。想要成为Python开发领域的高端人才,基础知识很重要,而实战经验也很重要。只有将理论知识与实战项目紧密结合,将现有知识与潮流技术融会贯通,你才能站在技术链的顶端。

    以下就是Python学习路线,分为10大阶段。

    第一阶段为Python语言基础,主要学习Python最基础知识,如Python3、数据类型、字符串、函数、类、文件操作等。阶段课程结束后,学员需要完成Pygame实战飞机大战、2048等项目;

    第二阶段为Python语言高级,主要学习Python库、正则表达式、进程线程、爬虫、遍历以及MySQL数据库;

    第三阶段为Python全栈工程师前端,主要学习HTML、CSS、JavaScript、jQuery等前端知识,学员需要完成网页界面设计实战;

    第四至第五阶段为Python全栈工程师后端,主要学习Django、 Flask以及Tornado,学员需要完成对应的实战项目;

    第六阶段为Linux基础,主要学习Linux相关的各种命令,如文件处理命令、压缩解压命令、权限管理以及Linux Shell开发等;

    第七阶段为Linux运维自动化开发,主要学习Python开发Linux运维、Linux运维报警工具开发、Linux运维报警安全审计开发、Linux业务质量报表工具开发、Kali安全检测工具检测以及Kali 密码破解实战;

    第八阶段为Python数据分析,主要学习numpy数据处理、pandas数据分析、matplotlib数据可视化、scipy数据统计分析以及python 金融数据分析;

    第九阶段为Python大数据,主要学习Hadoop HDFS、python Hadoop MapReduce、python Spark core、python Spark SQL以及python Spark MLlib;

    第十阶段为Python机器学习,主要学习KNN算法、线性回归、逻辑斯蒂回归算法、决策树算法、朴素贝叶斯算法、支持向量机以及聚类k-means算法。

    如何成为python工程师的正确学习路线

    内Python人才缺口高达40万,部分领域如人工智能、大数据开发人才稀缺, 年薪二十万都招不到人。据职友集数据显示,与Python有关的招聘职位共30851 条,分别来自47家招聘网站。但是岗位的缺乏并不意味着企业对于其专业知识的掌握就降低了要求,所以只有扎实的Python编程技术才能在职场上占据一席之地。

    通过学习Python课程,可以掌握以下编程和相关技术:

    Python语言基础;Python语言高级;Python全栈工程师前端;

    Python全栈工程师后端;Python全栈工程师后端高级;

    Linux基础;Linux运维自动化开发;Python数据分析;

    Python大数据;Python机器学习。

    1-python基础及高级

    2-数据库与版本控制等

    3-前端与移动端开发

    4-数据爬虫

    5-web服务器开发

    6-shell和自动化运维等

    7-数据挖掘与人工智能

    掌握这8个爬取网站常用技巧

    python作为一门高级编程语言,它的定位是优雅、明确和简单。我学用python差不多一年时间了,用得最多的还是各类爬虫脚本:写过抓代理本机验证的脚本,写过论坛中自动登录自动发贴的脚本,写过自动收邮件的脚本,写过简单的验证码识别的脚本。

    这些脚本有一个共性,都是和web相关的,总要用到获取链接的一些方法,故累积了不少爬虫抓站的经验,在此总结一下,那么以后做东西也就不用重复劳动了。

    2.使用代理服务器

    这在某些情况下比较有用,比如IP被封了,或者比如IP访问的次数受到限制等等。

    3.伪装成浏览器访问

    某些网站反感爬虫的到访,于是对爬虫一律拒绝请求。这时候我们需要伪装成浏览器,这可以通过修改http包中的header来实现:

    4、页面解析

    对于页面解析最强大的当然是正则表达式,这个对于不同网站不同的使用者都不一样,就不用过多的说明。

    5.验证码的处理

    碰到验证码咋办?这里分两种情况处理:

    google那种验证码, 没办法。

    简单的验证码:字符个数有限,只使用了简单的平移或旋转加噪音而没有扭曲的,这种还是有可能可以处理的,一般思路是旋转的转回来,噪音去掉,然后划分单个字符,划分好了以后再通过特征提取的方法(例如PCA)降维并生成特征库,然后把验证码和特征库进行比较。这个比较复杂,这里就不展开了,具体做法请弄本相关教科书好好研究一下。

    6. gzip/deflate支持

    现在的网页普遍支持gzip压缩,这往往可以解决大量传输时间,以VeryCD的主页为例,未压缩版本247K,压缩了以后45K,为原来的1/5。这就意味着抓取速度会快5倍。

    然而python的urllib/urllib2默认都不支持压缩,要返回压缩格式,必须在request的header里面写明'accept-encoding',然后读取response后更要检查header查看是否有'content-encoding'一项来判断是否需要解码,很繁琐琐碎。如何让urllib2自动支持gzip,defalte呢?

    7、多线程并发抓取

    单线程太慢的话,就需要多线程了,这里给个简单的线程池模板这个程序只是简单地打印了1-10,但是可以看出是并发的。

    虽然说Python的多线程很鸡肋,但是对于爬虫这种网络频繁型,还是能一定程度提高效率的。

    8. 总结

    阅读Python编写的代码感觉像在阅读英语一样,这让使用者可以专注于解决问题而不是去搞明白语言本身。Python虽然是基于C语言编写,但是摒弃了C中复杂的指针,使其变得简明易学。并且作为开源软件,Python允许对代码进行阅读,拷贝甚至改进。这些性能成就了Python的高效率,有"人生苦短,我用Python"之说,是一种十分精彩又强大的语言。

    python web后端开发工程师的面试总结

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

    之前一直通过CSDN以及其他几家技术博客/论坛吸收大家的经验,在感激之余,也想输出点什么,造福大家,因此就有了这篇水文,希望大家能够多多吸取我的经验教训,早日找到一份自己满意的工作!

    面试的几家:北京的两家创业公司,规模均在40-50人之间;果壳(止步于电话面,拉钩投的);知乎(止步于电话面,论坛发帖后的内推);爱奇艺(拉钩上投的);杭州的网易(同学内推)。

    面试这一轮下来,最大的感受就一个:平时一定要坚持每天都码点代码。就算再烂的项目,也要坚持上传github。。真的,只要你能坚持一周有5天以上都能持续上传Git,半年下来,面试官绝对对你刮目相看。

    其他感受:不同的公司着重点都不一样,不过真的就如这篇博文的博主所说,木桶原理,哪块都不能少。我就是因为平时只关注做自己的小博客系统,而没做其他的部分,导致爱奇艺倒在了手写代码上面…哎,忧伤。。平时多刷刷leetcode,看看剑指offer/面试金典,都是套路啊~~

    面试这几家公司所遇到的面试/笔试题,目前还能记住的如下。虽然可能绝大部分都是基础,但希望大家不要只是看看就过去了,最好还是假装你被问到这个问题,你来把答案说出来或写出来:(不按公司分了)

    python语法以及其他基础部分

    可变与不可变类型;

    浅拷贝与深拷贝的实现方式、区别;deepcopy如果你来设计,如何实现;

    __new__() 与 __init__()的区别;

    你知道几种设计模式;

    编码和解码你了解过么;

    列表推导list comprehension和生成器的优劣;

    什么是装饰器;如果想在函数之后进行装饰,应该怎么做;

    手写个使用装饰器实现的单例模式;

    使用装饰器的单例和使用其他方法的单例,在后续使用中,有何区别;

    手写:正则邮箱地址;

    介绍下垃圾回收:引用计数/分代回收/孤立引用环;

    多进程与多线程的区别;CPU密集型适合用什么;

    进程通信的方式有几种;

    介绍下协程,为何比线程还快;

    range和xrange的区别(他妹的我学的py3…);

    由于我有C/C++背景,因此要求用C来手写:将IP地址字符串(比如“172.0.0.1”)转为32位二进制数的函数。

    算法排序部分

    手写快排;堆排;几种常用排序的算法复杂度是多少;快排平均复杂度多少,最坏情况如何优化;

    手写:已知一个长度n的无序列表,元素均是数字,要求把所有间隔为d的组合找出来,你写的解法算法复杂度多少;

    手写:一个列表A=[A1,A2,…,An],要求把列表中所有的组合情况打印出来;

    手写:用一行python写出1+2+3+…+10**8 ;

    手写python:用递归的方式判断字符串是否为回文;

    单向链表长度未知,如何判断其中是否有环;

    单向链表如何使用快速排序算法进行排序;

    手写:一个长度n的无序数字元素列表,如何求中位数,如何尽快的估算中位数,你的算法复杂度是多少;

    如何遍历一个内部未知的文件夹(两种树的优先遍历方式)

    网络基础部分

    TCP/IP分别在模型的哪一层;

    socket长连接是什么意思;

    select和epoll你了解么,区别在哪;

    TCP UDP区别;三次握手四次挥手讲一下;

    TIME_WAIT过多是因为什么;

    http一次连接的全过程:你来说下从用户发起request——到用户接收到response;

    http连接方式。get和post的区别,你还了解其他的方式么;

    restful你知道么;

    状态码你知道多少,比如200/403/404/504等等;

    数据库部分

    MySQL锁有几种;死锁是怎么产生的;

    为何,以及如何分区、分表;

    MySQL的char varchar text的区别;

    了解join么,有几种,有何区别,A LEFT JOIN B,查询的结果中,B没有的那部分是如何显示的(NULL);

    索引类型有几种,BTree索引和hash索引的区别(我没答上来这俩在磁盘结构上的区别);

    手写:如何对查询命令进行优化;

    NoSQL了解么,和关系数据库的区别;redis有几种常用存储类型;

    Linux部分

    讲一下你常用的Linux/git命令和作用;

    查看当前进程是用什么命令,除了文件相关的操作外,你平时还有什么操作命令;

    (因为我本人Linux本身就很水,只会基本的操作,所以这部分面试官也基本没怎么问。。反正问了就大眼瞪小眼呗)

    django项目部分

    都是让简单的介绍下你在公司的项目,不管是不是后端相关的,主要是要体现出你干了什么;

    你在项目中遇到最难的部分是什么,你是怎么解决的;

    你看过django的admin源码么;看过flask的源码么;你如何理解开源;

    MVC / MTV;

    缓存怎么用;

    中间件是干嘛的;

    CSRF是什么,django是如何避免的;XSS呢;

    如果你来设计login,简单的说一下思路;

    session和cookie的联系与区别;session为什么说是安全的;

    uWSGI和Nginx的作用;

    (我发现基本不问django实现细节相关的东西。。或者问也问的很少,哎,之前准备的方向完全错了)

    洋洋洒洒写了一个小时,发现还是有很多细节问题都已经忘了。。哎,自己的笔记做的还是不行。不过这些问题如果你能都答上来,起码我觉得你应该可以去试试面试初级web后端了。。good luck!

    展开全文
  • Python后端工程师之2022年5月技术栈大盘点

    千次阅读 多人点赞 2022-03-21 13:58:55
    Python后端工程师之2022年3月盘点 此次盘点抛开人工智能领域和桌面应用领域不论,就web后端进行讨论: 后端开发技术栈: 开发:基于Python虚拟环境进行标准开发。 web框架:flask、tornado、fastapi 路由:设计多级...

    Python后端工程师之2022年5月盘点

    盘点就web后端进行讨论:

    后端开发技术栈:

    开发:基于Python虚拟环境进行标准开发。
    web框架:flask、tornado、fastapi
    路由:设计多级路由配置,严格规范业务开发结构 
    信息传输安全:基于非对称加密RSA的交换密钥保证前后端	信息传输安全(HTTPS证书)
    登录验证安全:采用jwt做签名验证,jwt+redis做sso单点登录 
    用户密码安全:哈希不可逆加密SHA2+随机盐+固定盐 
    系统权限控制:RBAC模型,可根据业务需求对RBAC0,1,2,3进行拓展使用 
    ORM:sqlalchemy以及对其的二次封装,alembic对数据库进行版本控制以及库表推送 
    数据库:mysql、postgresql、oracle等根据业务需使用 
    缓存数据库:redis缓存数据库,cacheout基于本地内存的数据库
    性能:代码角度:以进程、协程提高服务器性能
         部署角度:以nginx做反向代理服务器实现负载均衡、动静分离,(根据不同场景选择负载均衡方法,如加权轮询,ip哈希 ,加权随机,最小连接)
         数据库角度:使用缓存数据库 避免大型数据、常用数据的额外资源消耗、以连接池为基础,避免数据库连接的资源消耗
    系统日志:Logging
    部署:基于Linux内核使用docker进行项目部署、测试、上线
    

    架构思想:根据项目所属类型将公共模块高度抽象,设计后端通用架构实现项目开发的标准化,致力于将客户业务需求压 缩至唯一变量,以达到节约时间成本、高效开发的目的。

    Python后端技术要点,这里不再讲最基础的。

    装饰器的深入理解
    基础数据类型之栈堆概念
    生产者、消费者队列(deque双端队列)、优先级队列(heaq)
    线程、进程、线程池、进程池、协程
    面对高并发、IO阻塞的处理
    异步编程概念的理解
    单例模式、工厂模式
    pandas库的基础运用
    random库的基础运用
    math库的基础运用
    字典的底层实现原理
    类的底层实现原理,类的自带函数
    理解元编程

    算法基础
    适度掌握如下几门算法或更多:
    二分法 递归算法 动态规划 贪婪算法 回溯算法 排序算法 搜索算法 哈希算法 分治算法 字符串匹配算法
    双指针算法

    编程的美,代码和系统应具有如下特征:

    1、代码和系统的可部署性、可测试性、性能、安全性、可拓展性、可读性、可修改性
    2、写最少的代码,最巧妙的代码
    3、函数应具有相当高的健壮性,鲁棒性,内聚性适中
    4、模块之间耦合性适中
    5、代码编写应具有层次感

    欢迎一键三连,点赞评论加关注。留言你喜欢的内容部分,博主会持续更新博文进行详解

    展开全文
  • 安装 pip install -r requirements.txt 跑 python main.py
  • Python后端框架最火的就是Django和flask,我也写过这两个框架的系列文章,感兴趣的可以去看看。就拿flask来说: from flask import Flask app = Flask(__name__) @app.route("/hello", methods=["GET"])...
  • Python后端开发工程师面试

    千次阅读 2020-12-08 23:42:37
    如果系统中需要很多个Python版本,如何进行Python版本的管理 5. 如何实现一个全局变量?(除了global,还可以通过单例模式) 数据库相关 1. 数据库的数据是实时更新的吗?每点击一次,数据库数据修改一次? 2. Redis hash...
  • 前端: 测试表单 名字 : 年龄 : 密码: 性别: 男 女 提交表单: python服务器 # coding=utf8 from flask import Flask, request, jsonify import json app = Flask(__name__) @app.route("/get/sum", methods=[...
  • Python后端工程师面试题目有哪些?下面就跟着小编一起赶紧来看看吧! 面试是公司挑选职工的一种重要方法。它给公司和应招者提供了进行双向交流的机会,能使公司和应招者之间相互了解,从而双方都可更准确做出聘用与否...
  • python后端开发面试题

    千次阅读 2021-02-22 19:52:51
    目录 一:简述你对Restful风格的理解: 1: 协议 : 2:域名: 3:版本: 4:路径: 5:请求方式(6种): 6: 请求参数: 7: 状态码: 二:概述python的内存管理机制: 三: cookie 与 Session的区别: 四:你了解web...
  • python后端开发学习内容有哪些?

    千次阅读 2021-04-06 16:36:16
    python后端开发学习内容有哪些? 【导语】Python是一个强大的面向对象的程序设计语言,在人工智能领域,在网络爬虫、服务器开发、3D游戏、网络编程、数据分析、Web开发、运维、测试等多个领域都有不俗的表现,但学习...
  • 想从事Python后端开发的你,不知道如何入门和学习,但首先必须知道什么是“Python后端开发”。 1、什么是“Python后端开发” 刚开始接触软件行业的你,以前可能经常会被人问到:“你以后想走前端还是后端呢?”这...
  • 2-3 Python后端技术栈

    2021-05-30 21:34:55
    二、后端技术栈 python语言基础 1.语言特点 2.语法基础 3.高级特性 算法与数据结构 1.常用算法和数据结构 2.分析时间/空间复杂度 3.实现常见数据结构和算法 编程范式 1.面向对象编程 2.常用设计模式 3.函数式编程 ...
  • Python后端接口模板 xxx设计接口: 请求方法(GET、POST、PUT、DELETE) 请求地址:127.0.0.1:8000/test/aaa 请求参数(如路径参数、查询字符串、表单、JSON等) 响应数据(如HTML、JSON等) 请求方式:GET 选项 ...
  • 我的小号,平时写一些小技巧,欢迎关注~大家好,我是K哥。相信学Python的朋友大多数都会Django和Flask两个框架。K哥之前也写过这两个框架的系列文章,感兴趣的可以去公众号阅读。今...
  • 编程之JAVA后端开发与python后端开发的区别及类的方法技巧[图] 今天总算闲了一会,趁着这个闲暇来写篇文章。 今天我想以个人观点来简单说说Java后端开发和Python后端开发的区别。 Java&PythonBackEnd 公众号老粉...
  • 前言上一节中,我们强烈推荐Python作为web开发的主要编程语言。接下来,我们将开始一步步安装和配置Python项目开发环境,并使用VSCode作为IDE工具,快速上手Python的WEB开发之旅。最新消息:2018 IEEE顶级编程语言...
  • python 后端数据保存在数据库 form 字典,且里面的value的类型应该与model里面的设置一样 通过序列化完成 form = {'best_estimator': char} best_estimator = SVMParamsSerializer(data=form) if best_estimator....
  • python后端开发

    千次阅读 2019-08-02 09:46:19
    学习python多线程的缺点进程,线程和协程进程,协程的上下文切换线程和进程的实现方式如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...
  • python和javascript是轮子王语言,容易上手出机会,tornado开发代码量介于bottle和django之间,简单易用,异步特征,引入web和ioloop就可以用,如下: # -*- coding:utf8 - import tornado.web import tornado....
  • python项目后端环境配置
  • 主要看你的后端Python做的什么样的服务接口了,如果是HTTP的API方式,那就非常简单了,JS创建XMLHTTPREQUEST对象的话就能实现传说中的ajax通讯了,能够GET或者POST数据到服务器端并取回结果:另外个人建议你使用...
  • 30分钟玩转Python后端Flask

    千次阅读 多人点赞 2020-07-14 17:12:56
    30分钟玩转Python后端 什么是Flask? Flask是一个用Python编写的Web应用程序框架。 它由 Armin Ronacher 开发,他领导一个名为Pocco的国际Python爱好者团队。 Flask基于Werkzeug WSGI工具包和Jinja2模板引擎。两者...
  • 将search_get接口加入后端访问路径 path('search-get/', search.search_get), 很简单就能看出,这里先判断GET请求中是否存在字段‘q’, 存在的话将字段q读出来让http返回。 看下效果 再来整理POST接口代码 以前说过...
  • 最近在写后端接口,实现前端小程序用户登录时,需要使用前端发来的code获取用户的openid和session_key,并且返回3rd_session,搜了一些资料,最终实现了功能。 首先说结论:向微信服务器发送请求用的url要用拼接的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 212,486
精华内容 84,994
关键字:

python后端