• Python基础
  • 1、文件操作
    • 1.1、有一个jsonline格式的文件file.txt大小约为10K
    • 1.2、补充缺失的代码？
  • 2、模块与包
    • 2.1输入日期，判断这一天是这一年的第几天？
    • 2.2打乱一个排好序的list对象 alist？
  • 3、数据类型
    • 3.1、现有字典 d={‘a’:24，‘g’:52，‘i’:12，‘k’:33}请按value值进行
    • 3.2、字典推导式？
    • 3.3、请反转字符串“aStr”?
    • 3.4、将字符串"k:1|k1:2|k2:3|k3:4"，处理成字典：{k:1， k1:2， ...
    • 3.5、请按alist中元素的age由大到小排序
    • 3.6下面代码的输出结果将是什么？
    • 3.7、写一个列表生成式，产生一个公差为11的等差数列
    • 3.8、给定两个列表，怎么找出他们相同的元素和不同的元素?
    • 3.9、请写出一段Python代码实现删除一个list里面的重复元素?
    • 3.10、给定两个list A ,B，请用找出 A ,B中相同与不同的元素
• 4、企业面试题
  • 4.1、Python新式类和经典类的区别？
  • 4.2、python中内置的数据结构有几种？
  • 4.3、Python如何实现单例模式？请写出两种实现方法
  • 4.4、反转一个整数，例如-123-->-321,Python语言实现
  • 4.5、设计实现遍历目录与子目录，抓取.pyc文件
  • 4.6、一行代码实现1-100之和
  • 4.7、Python-遍历列表时删除元素的正确做法
  • 4.8、字符串的操作题目
  • 4.9、可变类型和不可变类型
  • 4.10、is和==有什么区别？
  • 4.11、求出列表所有奇数并构造新列表
  • 4.12、用一行python代码写出1+2+3+10248
  • 4.13、Python中变量的作用域？（变量查找顺序）
  • 4.14、字符串”123″转换成123，不使用内置api，例如int（）
  • 4.15、Given an array of integers
  • 4.16、python代码实现删除一个list里面的重复元素
  • 4.17、统计一个文本中单词频次最高的10个单词？
  • 4.18、请写出一个函数满足以下条件
  • 4.19、使用单一的列表生成式来产生一个新的列表
  • 4.20、用一行代码生成[1,4,9,16,25,36,49,64,81,100]
  • 4.21、输入某年某月某日，判断这一天是这一年的第几天？
  • 4.22、两个有序列表，l1,l2，对这两个列表进行合并不可使用extend
  • 4.23、给定一个任意长度数组，实现一个函数
  • 4.23、写一个函数找出一个整数数组中，第二大的数
  • 4.24、阅读一下代码他们的输出结果是什么？
  • 4.25、统计一段字符串中字符出现的次数
  • 4.26、super函数的具体用法和场景
• 二、Python高级
  • 1、元类
    • 1.1、Python中类方法、类实例方法、静态方法有何区别？
    • 1.2、super函数的具体用法和场景？
    • 1.3、历一个object的所有属性，并print每一个属性名？
    • 1.4、写一个类，并让它尽可能多的支持操作符？
    • 1.5、介绍Cpython，Pypy Cpython Numba各有什优缺点
    • 1.6、请描述抽象类和接口类的区别和联系？
    • 1.7、Python中如何动态获取和设置对象的属性？
  • 2、内存管理与垃圾回收机制
    • 2.1、哪些操作会导致Python内存溢出，怎么处理？
    • 2.2、关于 Python内存管理,下列说法错误的是(B)
    • 2.3、Python的内存管理机制及调优手段？
    • 2.4、内存泄露是什么？如何避免？
  • 3、函数
    • 3.1、python常见的列表推导式？
    • 3.2、简述read、readline、readlines的区别？
    • 3.3、什么是Hash（散列函数）？
    • 3.4、python函数重载机制？
    • 3.5、写一个函数找出一个整数数组中，第二大的数
    • 3.6、手写一个判断时间的装饰器
    • 3.7、使用Python内置的filter()方法来过滤？
    • 3.8、编写函数的4个原则
    • 3.9、函数调用参数的传递方式是值传递还是引用传递？
    • 3.10、如何在function里面设置一个全局变量
    • 3.11、对缺省参数的理解 ？
    • 3.12、Mysql怎么限制IP访问？
    • 3.13、带参数的装饰器?
    • 3.14、为什么函数名字可以当做参数用?
    • 3.15、Python中pass语句的作用是什么？
    • 3.16、有这样一段代码，print c会输出什么，为什么？
    • 3.17、交换两个变量的值？
    • 3.18、map函数和reduce函数？
    • 3.19、回调函数，如何通信的?
    • 3.20、Python主要的内置数据类型都有哪些？ print dir( ‘a ’) 的输出？
    • 3.21、map(lambda x:xx，[y for y in range(3)])的输出？
    • 3.22、 hasattr() getattr() setattr() 函数使用详解？
    • 3.23、一句话解决阶乘函数？
    • 3.24、什么是lambda函数？ 有什么好处？
    • 3.25、递归函数停止的条件？
    • 3.26、下面这段代码的输出结果将是什么？请解释。
    • 3.27、什么是lambda函数？它有什么好处？写一个匿名函数求两个数的
  • 4、设计模式
    • 4.1、对设计模式的理解，简述你了解的设计模式？
    • 4.2、请手写一个单例
    • 4.3、单例模式的应用场景有哪些？
    • 4.4、Python 如何实现单例模式？请写出两种实现方法？
    • 4.5、对装饰器的理解 ，并写出一个计时器记录方法执行性能的装饰器？
    • 4.6、解释一下什么是闭包?
    • 4.7、函数装饰器有什么作用？
    • 4.8、生成器、迭代器的区别？
    • 4.9 X是什么类型？
    • 4.10、请用“一行代码”实现将1-N的整数列表以3为单位分组
    • 4.11、Python中yield的用法？
  • 5、面向对象
    • 5.1、Python中的可变对象和不可变对象？
    • 5.2、
    • 5.3、Python的魔法方法
    • 5.4、面向对象中怎么实现只读属性?
    • 5.5、谈谈你对面向对象的理解？
  • 6、正则表达式
    • 6.1、请写出一段代码用正则匹配出ip？
    • 6.2、a = “abbbccc”，用正则匹配为abccc,不管有多少b，就出现一次？
    • 6.3、Python字符串查找和替换？
    • 6.4、 用Python匹配HTML g tag的时候，<.> 和 <.*?> 有什么区别
    • 6.5、正则表达式贪婪与非贪婪模式的区别？
    • 6.6、写出开头匹配字母和下划线，末尾是数字的正则表达式？
    • 6.7、正则表达式操作
    • 6.8、请匹配出变量A 中的json字符串。
    • 6.9、怎么过滤评论中的表情？
    • 6.10、简述Python里面search和match的区别
    • 6.11、请写出匹配ip的Python正则表达式
    • 6.12、Python里match与search的区别？
  • 7、系统编程
    • 7.1、进程总结
    • 7.2、谈谈你对多进程，多线程，以及协程的理解，项目是否用？
    • 7.3、Python异步使用场景有那些？
    • 7.4、多线程共同操作同一个数据互斥锁同步？
    • 7.5、什么是多线程竞争？
    • 7.6、请介绍一下Python的线程同步？
    • 7.7、解释一下什么是锁，有哪几种锁?
    • 7.8、什么是死锁呢？
    • 7.9、多线程交互访问数据，如果访问到了就不访问了
    • 7.10、什么是线程安全，什么是互斥锁？
    • 7.11、说说下面几个概念：同步，异步，阻塞，非阻塞?
    • 7.12、什么是僵尸进程和孤儿进程？怎么避免僵尸进程?
    • 7.13、Python中的进程与线程的使用场景?
    • 7.14、线程是并发还是并行，进程是并发还是并行？
    • 7.15、并行（parallel）和并发（concurrency）？
    • 7.16、IO密集型和CPU密集型区别？
  • 8、网络编程
    • 8.1、怎么实现强行关闭客户端和服务器之间的连接?
    • 8.2、简述TCP和UDP的区别以及优缺点?
    • 8.3、简述浏览器通过WSGI请求动态资源的过程?
    • 8.4、描述用浏览器访问www.baidu.com的过程
    • 8.5、Post和Get请求的区别?
    • 8.6、cookie 和session 的区别？
    • 8.7、列出你知道的HTTP协议的状态码，说出表示什么意思？
    • 8.8、请简单说一下三次握手和四次挥手？
    • 8.9、说一下什么是tcp的2MSL？
    • 8.10、为什么客户端在TIME-WAIT状态必须等待2MSL的时间？
    • 8.11、说说HTTP和HTTPS区别？
    • 8.12、谈一下HTTP协议以及协议头部中表示数据类型的字段？
    • 8.13、HTTP请求方法都有什么？
    • 8.14、使用Socket套接字需要传入哪些参数 ？
    • 8.15、HTTP常见请求头？
    • 8.16、七层模型？
    • 8.17、url的形式？
  • 三、Web
    • 1、Flask
      • 1.1、对Flask蓝图(Blueprint)的理解？
      • 1.2、Flask和Django路由映射的区别？
    • Django
      • 2.1、什么是wsgi,uwsgi,uWSGI？
      • 2.3、CORS和CSRF的区别？
      • 2.4、Session、Cookie、JWT的理解
      • 2.5、简述Django请求生命周期
      • 2.6、什么是wsgi,uwsgi,uWSGI？
      • 2.7、Django 、Flask、Tornado的对比
      • 2.8、用的restframework完成api发送时间时区
      • 2.9、nginx,tomcat,apache 都是什么?
      • 2.10、请给出你熟悉关系数据库范式有那些，有什么作用
      • 2.11、简述QQ登陆过程
      • 2.12、post和get 的区别？
      • 2.13、项目中日志的作用
      • 2.14、django中间件的使用？
      • 2.15、谈一下你对uWSGI和 nginx的理解？
      • 2.16、Python中三大框架各自的应用场景？
      • 2.17、有过部署经验？用的什么技术？可以满足多少压力？
      • 2.18、Django中哪里用到了线程?哪里用到了协程?哪里用到了进程？
      • 2.19、有用过Django REST framework 吗？
      • 2.20、对cookie与session的了解？他们能单独用吗？
    • 爬虫
      • 1.1、试列出至少三种目前流行的大型数据库
      • 1.2、列举您使用过的Python网络爬虫所用到的网络数据包?
      • 1.3、列举您使用过的Python网络爬虫所用到的解析数据包？
      • 1.4、爬取数据后使用哪个数据库存储数据的，为什么？
      • 1.5、你用过的爬虫框架或者模块有哪些？优缺点？
      • 1.6、写爬虫是用多进程好？还是多线程好？
      • 1.7、常见的反爬虫和应对方法？
      • 1.8、解析网页的解析器使用最多的是哪几个?
      • 1.9、需要登录的网页，如何解决同时限制ip，cookie,session
      • 1.10、验证码的解决?
      • 1.11、使用最多的数据库，对他们的理解？
      • 1.12、编写过哪些爬虫中间件？
      • 1.13、“极验”滑动验证码如何破解？
      • 1.14、爬虫多久爬一次，爬下来的数据是怎么存储？
      • 1.15、cookie过期的处理问题？
      • 1.16、动态加载又对及时性要求很高怎么处理？
      • 1.17、HTTPS有什么优点和缺点？
      • 1.18、HTTPS是如何实现安全传输数据的？
      • 1.19、TTL，MSL，RTT各是什么？
      • 1.20、谈一谈你对Selenium和PhantomJS了解
      • 1.21、平常怎么使用代理的 ？
      • 1.22、存放在数据库(redis、mysql等)。
      • 1.23、怎么监控爬虫的状态?
      • 1.24、描述下scrapy框架运行的机制？
      • 1.25、谈谈你对Scrapy的理解？
      • 1.26、怎么样让 scrapy 框架发送一个 post 请求（具体写出来）
      • 1.27、怎么监控爬虫的状态 ？
      • 1.28、怎么判断网站是否更新？
      • 1.29、图片、视频爬取怎么绕过防盗连接
      • 1.30、你爬出来的数据量大概有多大？大概多长时间爬一次？
      • 1.31、用什么数据库存爬下来的数据？部署是你做的吗？怎么部署？
      • 1.32、增量爬取
      • 1.33、爬取下来的数据如何去重，说一下scrapy的具体的算法依据。
      • 1.34、Scrapy的优缺点?
      • 1.35、怎么设置爬取深度？
      • 1.36、scrapy和scrapy-redis有什么区别？为什么选择redis数据库？
      • 1.37、分布式爬虫主要解决什么问题？
      • 1.38、什么是分布式存储？
      • 1.39、你所知道的分布式爬虫方案有哪些？
      • 1.40、scrapy-redis，有做过其他的分布式爬虫吗？
• 五、数据库
  • 1、MySQL
    • 1.1、主键 超键 候选键 外键
    • 1.2、视图的作用，视图可以更改么？
    • 1.3、drop,delete与truncate的区别
    • 1.4、索引的工作原理及其种类
    • 1.5、连接的种类
    • 1.6、数据库优化的思路
    • 1.7、存储过程与触发器的区别
    • 1.8、悲观锁和乐观锁是什么？
    • 1.9、你常用的mysql引擎有哪些?各引擎间有什么区别?
  • 2、Redis
    • 2.1、Redis宕机怎么解决?
    • 2.2、redis和mecached的区别，以及使用场景
    • 2.3、Redis集群方案该怎么做?都有哪些方案?
    • 2.4、Redis回收进程是如何工作的
  • 3、MongoDB
    • 3.1、MongoDB中对多条记录做更新操作命令是什么？
    • 3.2、MongoDB如何才会拓展到多个shard里？
• 六、测试
  • 1、编写测试计划的目的是
  • 2、对关键词触发模块进行测试
  • 3、其他常用笔试题目网址汇总
  • 4、测试人员在软件开发过程中的任务是什么
  • 5、一条软件Bug记录都包含了哪些内容？
  • 6、简述黑盒测试和白盒测试的优缺点
  • 7、请列出你所知道的软件测试种类，至少5项。
  • 8、Alpha测试与Beta测试的区别是什么？
  • 9、举例说明什么是Bug？一个bug report应包含什么关键字？
• 数据结构
  • 1.1、数组中出现次数超过一半的数字-Python版
  • 1.2、求100以内的质数
  • 1.3、无重复字符的最长子串-Python实现
  • 1.4、通过2个5/6升得水壶从池塘得到3升水
  • 1.5、什么是MD5加密，有什么特点？
  • 1.6、什么是对称加密和非对称加密
  • 1.7、冒泡排序的思想？
  • 1.8、快速排序的思想？
  • 1.9、如何判断单向链表中是否有环？
  • 1.10、你知道哪些排序算法（一般是通过问题考算法）
  • 1.11、斐波那契数列
  • 1.12、如何翻转一个单链表？
  • 1.13、青蛙跳台阶问题
  • 1.14、两数之和 Two Sum
  • 1.15、搜索旋转排序数组 Search in Rotated Sorted Array
  • 1.16、Python实现一个Stack的数据结构
  • 1.17、写一个二分查找
  • 1.18、set 用 in 时间复杂度是多少，为什么？
  • 1.19、列表中有n个正整数范围在[0，1000]，进行排序；
  • 1.20、面向对象编程中有组合和继承的方法实现新的类
• 八、人工智能
  • 1.1、找出1G的文件中高频词
  • 1.2、一个大约有一万行的文本文件统计高频词
  • 1.3、怎么在海量数据中找出重复次数最多的一个？
  • 1.4、判断数据是否在大量数据中

文件操作

1.1 有一个jsonline格式的文件爱file.txt 大小约为10K

    def get_lines():
        l = []
        with open('file.txt','rb) as f:
            for eachline in f:
                l.append(eachline)
            return l

    if __name__ == '__main__':
        for e in get_lines():
            process(e) #处理每一行数据

现在要处理一个大小为10G的文件，但是内存只有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文件，需要分批读入分批读入数据要记录每次读入数据的位置。分批每次读取数据的大小，太小会在读取操作花费过多时间。

1.2 补充缺失的代码

    def print_directory_contents(sPath):
    """
    这个函数接收文件夹的名称作为输入参数
    返回该文件夹中文件的路径
    以及其包含文件夹中文件的路径
    """
    import os
    for sChild in os.listdir(sPath):
        sChildPath = os.path.join(sPath,sChild)
        if os.path.isdir(sChildPath):
            print_directory_contents(sChildPath)
        else:
            print(sChildPath)

模块与包

2.1 输入日期， 判断这一天是这一年的第几天？

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

2.2 打乱一个排好序的list对象alist？

    import random
    alist = [1,2,3,4,5]
    random.shuffle(alist)
    print(alist)

数据类型

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

    sorted(d.items(),key=lambda x:x[1])

3.2 字典推导式

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

3.3 请反转字符串 "aStr"?

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

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

    str1 = "k:1|k1:2|k2:3|k3:4"
    def str2dict(str1):
        dict1 = {}
        for iterms in str1.split('|'):
            key,value = iterms.split(':'):
                dict1[key] = value
        return dict1

3.5 请按alist中元素的age由小到大排序

    alist = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]
    def sort_by_age(list1):
        return sorted(alist,key=lambda x:x['age'],reverse=True)

3.6 下面代码的输出结果将是什么？

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

代码将输出[],不会产生IndexError错误，就像所期望的那样，尝试用超出成员的个数的index来获取某个列表的成员。例如，尝试获取list[10]和之后的成员，会导致IndexError。然而，尝试获取列表的切片，开始的index超过了成员个数不会产生IndexError，而是仅仅返回一个空列表。这成为特别让人恶心的疑难杂症，因为运行的时候没有错误产生，导致Bug很难被追踪到。

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

    print([x*11 for x in range(10)])

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

    list1 = [1,2,3]
    list2 = [3,4,5]
    set1 = set(list1)
    set2 = set(list2)
    print(set1 & set2)
    print(set1 ^ set2)

3.9 请写出一段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)

3.10 给定两个list A，B ,请用找出A，B中相同与不同的元素

    A,B 中相同元素： print(set(A)&set(B))
    A,B 中不同元素:  print(set(A)^set(B))

企业面试题

4.1 python新式类和经典类的区别？

a. 在python里凡是继承了object的类，都是新式类 b. Python3里只有新式类 c. Python2里面继承object的是新式类，没有写父类的是经典类 d. 经典类目前在Python里基本没有应用

4.2 python中内置的数据结构有几种？

a. 整型 int、 长整型 long、浮点型 float、 复数 complex b. 字符串 str、 列表list、 元祖tuple c. 字典 dict 、 集合 set

4.3 python如何实现单例模式?请写出两种实现方式?

第一种方法:使用装饰器

    def singleton(cls):
        instances = {}
        def wrapper(*args, **kwargs):
            if cls not in instances:
                instances[cls] = cls(*args, **kwargs)
            return instances[cls]
        return wrapper
    @singleton
    class Foo(object):
        pass
    foo1 = Foo()
    foo2 = Foo()
    print foo1 is foo2 #True

第二种方法：使用基类 New 是真正创建实例对象的方法，所以重写基类的new 方法，以此保证创建对象的时候只生成一个实例

    class Singleton(object):
        def __new__(cls,*args,**kwargs):
            if not hasattr(cls,'_instance'):
                cls._instance = super(Singleton,cls).__new__(cls,*args,**kwargs)
            return cls._instance
        
    class Foo(Singleton):
        pass
    
    foo1 = Foo()
    foo2 = Foo()

    print foo1 is foo2 #True

第三种方法：元类，元类是用于创建类对象的类，类对象创建实例对象时一定要调用call方法，因此在调用call时候保证始终只创建一个实例即可，type是python的元类

    class Singleton(type):
        def __call__(cls,*args,**kwargs):
            if not hasattr(cls,'_instance'):
                cls._instance = super(Singleton,cls).__call__(*args,**kwargs)
            return cls._instance

    class Foo(object):
        __metaclass__ = Singleton
    
    foo1 = Foo()
    foo2 = Foo()
    print foo1 is foo2 #True

4.4 反转一个整数，例如-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 0
    if __name__ == '__main__':
        s = Solution()
        reverse_int = s.reverse(-120)
        print(reverse_int)

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

第一种方法：

    import os

    def 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 os
    
    def pick(obj):
        try:
            if obj.[-4:] == ".pyc":
                print(obj)
            except:
                return None
        
    def 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)

4.6 一行代码实现1-100之和

    count = sum(range(0,101))
    print(count)