python 面试相关(基础100道)

python 面试相关(基础100道)

基础试题10道

1. 一行代码实现1-100之和
    print(sum(range(1,101)))
    
2. 如何在函数内部修改全局变量
    a = 1
    def fun1():
        global a#利用global声明后可进行修改
        a=2
        print(a)
    fun1()
    print(a) 

3. 列出5个python标准库
    (1): os 操作系统相关库
    (2): sys 命令行
    (3): re 正则相关库
    (4): math 数学运算库
    (5): datetime 处理日期时间
    (6): random 随机数相关库
    
4. 字典如何删除键和合并两个字典
    dic1 = {1:'a',2:'b',3:'c'}
    dic2 = {4:'d',5:'e',6:'f'}
    del dic1[1]#按照键删除
    print(dic1)
    dic1.update(dic2)
    print(dic1)#更新字典,将另一个字典里的值更新到字典中,如果键相同,以后面的字典为主

5. python 的GIL
    (1):GIL是全局解释器锁,同一进程中如果有多个线程,一个线程在运行python程序时
        会占用python解释器,并加了一把锁GIL,使得其他线程无法运行,只有等该线程运
        行完毕之后才会运行.如果线程遇到i/o操作,就会解开锁,使得其他线程开始运行,
        因此在python中,多线程运行时是有先后顺序的,并不是同时运行的,如果想要让多
        个任务同时执行需要开启多进程.但是多进程中每个进程都会被系统分配资源,相当
        于每个进程都有一个python解释器,所有能实现多个任务同时执行,但是会使系统资
        源消耗过大.
        
6. python实现列表去重
    lst = [1,2,3,45,6,7,8,9,2,3,3,45,21,1]
    print(list(set(lst)))#转成集合数据类型,自动去重,然后再转回来
    
7.fun(*args,**kwargs)中的*args,**kwargs什么意思?
    def fun1(*args,**kwargs):#*args,接受多个非键值对参数,**kwargs接受多个键值对参数
        print(args)
        print(kwargs)
    def fun2(*a,**b):#args,kwargs只是用来接受的数据的形参,主要的是*和**
        print(a)
        print(b)
    fun1(1,2,3,a='1',b=2,)
    fun2(1,2,3,a='1',b=2,)
    
8. python2和python3的range(100)的区别:
    python2返回的是列表,python返回的是迭代器,节约内存

9. 一句话解释什么样的语言能够使用装饰器?
    函数可以作为传递参数的语言,可以使用装饰器

10. python内建数据类型
    (1): 数字 int
    (2): 字符串 str
    (3): 列表 list
    (4): 集合 set
    (5): 元组 tuple
    (6): 字典 dict
    (7): 布尔 bool

基础试题10道

1. 简述面向对象中的__new__和__init__的区别
	(1): __init__是初始化方法,当实例化对象后就被默认调用执行了,可以接受参数
    (2): __new__至少有一个参数cls, 代表当前类, 此参数在实例化时由python解释器自动识别
    (3): __new__必须要有返回值,返回实例化出来的实例,如果要自行实现__new__时可以return
        父类(super(当前类,cls)),
    (4): __init__有一个参数self,就是__new__返回的实例,__init__在__new__的基础上可以完成一些
        其他初始化操作,且不需要返回值
    (5): 如果__new__创建的是当前类的实例,会自动调用执行__init__方法,如果是其他类则不会,
    class My(object):
        def __new__(cls, *args, **kwargs):
            print(cls)
            print(object.__new__(cls))
            return object.__new__(cls)
        def __init__(self):
            print(self)
    my = My()
    print(my)
    输出:
        <class '__main__.My'>
        <__main__.My object at 0x000002048E39EBA8>
        <__main__.My object at 0x000002048E39EBA8>
        <__main__.My object at 0x000002048E39EBA8>

        进程已结束,退出代码0
        
2.简述with方法打开处理文件帮我们做了什么?
    类似:
        f = open('demo1.txt','r',encoding='utf8')
        try:
            f.read()
        except:
            pass
        finally:
            f.close()
    打开文件操作时经常发生意外,with方法就像利用了try,except,finally,无论如何都会自动关闭文件

3. 列表[1,2,3,4,5],请使用map()函数输出[1,4,9,16,25],并使用列表推导式取出大于10的函数,最终输出[16,25]
    print([x for x in list(map(lambda x: x*x,[1,2,3,4,5])) if x>10])
    
4. python中生成随机整数,随机小数,0-1小数
    (1): 随机整数 random.randint(1,100)
    (2): 随机小数 numpy.random.randn(5)
    (3): 0-1小数 random.random()

5. 为了避免转义加上那个字母表示原始字符串
    r, 表示需要原始字符串,不需要转义
    
6. <div class='nam'>中国</div>,用正则匹配出标签里的内容,其中class的类名是不确定的
    import re
    str = "<div class='nam'>中国</div>"
    res = re.findall(r'>(.+?)</div>',str)
    print(res)
    
7. python 中的断言
    a=1
    print(1)
    assert (a==2)#如果不成立报错,成立继续执行
    print(2)

8. 数据表中student中有id, name,score,city字段,其中name中的名字可有重复,需要消除重复行,请写sql语句
    select distinct name from student

9. 请写出10个常用的linux命令
    (1):cd 切换工作目录
    (2):pwd 显示工作路径
    (3):ls 查看目录中的文件
    (4):ls -F 查看目录中的文件
    (5):ls -l 显示文件和目录的详细信息
    (6):ls -a 显示隐藏文件
    (7):mk 创建文件夹
    (8):rm 删除文件夹
    (9):find 搜索文件
    (10):date 显示日期

10. python2 和python3 的区别
    (1):print时2不需要小括号也行,只需要加空格即可,在3必须加
    (2):在2中range返回的是列表,在3返回的这是迭代器
    (3):在2中的编码是ASCII码,在3中则是utf8
    (4):在2中unicode表示字符串序列,str表示字节序列,在3中则是str表示字符串序列,byte表示字节序列
    (5):在2中为了正常显示中文,需要引入coding声明,在3中不需要
    (6):在2中的输入函数是raw_input(),在3中则是input()函数

基础试题10道

1. 列出python中可变的数据类型和不可变的数据类型,并简述其原理.
    (1): 不可变数据类型: 数值型, 字符串型str ,和元组tuple
    (2): 不可变数据类型,即不能修改变量值,如果修改,相当于创建了一个新对象,
         而原来的对象不会改变,对于相同值的对象,其实内存中也只有一个,用内置
         方法id()可以进行查看
    (3): 可变的数据类型:列表list和字典dict
    (4): 对于可变的数据类型,修改操作并不会创建一个新对象,而是对原来对象的值
         直接进行操作,且变量引用的地址不会改变,但是不同的对象可以有相同的值,
         并且在内存中有两个对象,
    (5): 可变的数据类型进行引用时会有两中方法浅拷贝(不创建新对象,或者只创建表
         层新对象)和深拷贝(完全创建新对象)
         
2. s = 'abcbcbcddefjjh',去重后按照从小到大顺序排列
    s = 'abcbcbcddefjjh'
    lst = list(set(s))
    lst.sort()
    res = ''.join(lst)
    print(res)    

3. 用lambda函数实现两个数相乘
    fun = lambda x,y:x*y
    print(fun(3,4))
4. 字典根据键从小到大排列
    dic ={'name':'lihua','aeg':12,'city':'beijing','tel':'10086'}
    res = dict(sorted(dic.items(),key=lambda x:x[0]))
    print(res)
5. 统计字符串中每个单词出现的次数s = 'abcbcbcddefjjh',
        
    from collections import Counter

    def fun1(Str):
        res = {}
        for ele in Str:
            if ele not in res:
                res[ele] = 1
            else:
                res[ele] += 1
        return res

    def fun2(Str):#利用collections库的Counter方法,按多到少顺序输出
        res = Counter(Str)
        return res

    str1 = 'abcbcbcddefjjh'
    print(fun1(str1))

    print(fun2(str1))

6. 字符串中Str = 'not foound 404 小明 12 北京',利用正则去掉英文和数字,输出'小明 北京'
    import re
    Str = 'not foound 404 小明 12 北京'
    res = re.sub(r'[0-9,a-zA-Z,]+\s','',Str)
    print(res)

7. 求出列表中所有奇数,并且构造新列表,lst = [1,2,3,4,5,6,7,8,9]
    def fun1(lst):
        return [x for x in lst if x%2!=0]
    def fun2(lst):#filter返回迭代器
        return list(filter(lambda x:x%2!=0, lst))


    lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    print(fun1(lst))
    print(fun2(lst))

8. 列表推导式求出列表中所有奇数,并且构造新列表,lst = [1,2,3,4,5,6,7,8,9]
    def fun1(lst):
        return [x for x in lst if x%2!=0]
9. 正则re.complie作用
    (1): re.complie是将正则表达式编译成一个对象,加快速度,并能够重复使用

10. a = (1, )和a = (1)和a = ('1')分别是什么类型数据
    a1 = (1, )
    a2 = (1)
    a3 = ('1')
    print(type(a1),type(a2),type(a3),)
    
    <class 'tuple'> <class 'int'> <class 'str'>

基础试题10道

1. 两个列表[1,2,3,4]和[5,6,7,8,9]合并成一个
    lst1 = [1,2,3,4]
    lst2 = [5,6,7,8,9]
    lst1.extend(lst2)#逐个添加,append是整体添加
    print(lst1)

2. 用python删除文件,和用linux 命令删除文件
    (1): python  os.remove(文件名)
    (2): linux  rm 文件名

3. log日志中, 我们需要用时间戳记录error ,warning 等发生的时间,请用datetime模块打印当前的时间戳
    import datetime
    # res = datetime.datetime.now() #2020-06-16 17:14:05.398528
    res = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') #2020-06-16 17:15:50
    res = datetime.datetime.now().isoweekday() # 2(周几)
    print(res)

4. 数据库优化查询的方法
    外键,索引,联合查询,选择特定字段
    
5. 请列出你会的任意一种统计图(条形图,折线图)绘制的开源库,第三方也行
    (1): pyecharts
    (2): matplotlib

6. 写一串自定义异常代码
    def fn(N):
        try:
            if N>2:
                raise Exception('数字大于二')
        except Exception as e:
            print(e)

    fn(3)

7. 正则表达式匹配中, (.*)和(.*?)匹配区别?

    (1): (.*)是贪婪匹配,会把满足正则的尽可能向后匹配
    (1): (.*?)是非贪婪匹配,会把满足正则的尽可能少匹配

8. 简述 Django的orm
    (1): orm 全称为object-relation mapping,意为对象-映射关系
    (2): 实现了数据模型与数据库的解耦, 通过简单的配置就可以轻松更换数据库
    (3): orm 操作的本质上会根据对接的数据库引擎,翻译成对应的sql语句
    (4): 所有使用Django开发的项目迁移数据库时,只需要更换数据库引擎即可,而不需要修改代码
    
9. [[1,2],[2,3],[3,4]] ,展开列表
    lst = [[1,2],[2,3],[3,4]]
    print([i for ele in lst for i in ele ])
    
10. x = 'abc' ,y = 'cde' ,z = ['e','f','g'],分别求x.join(y)和x.join(z)返回的结果
    x = '111'
    y = '222'
    z = ['3','3','3']
    print(x.join(y))
    print(x.join(z))

    结果:
        211121112
        311131113
    结论:
    join方法是以前面的字符串为连接体,将后面的可迭代对象中的每个元素拼接到一起

基础试题10道

1. 举例说明异常模块中的try except else finally 的相关意义
    (1): try except else,如果try except 没有捕获到异常就会执行else语句
    (2): try except finally 无论是否捕获到异常都会执行finally语句

2. python中交换两个变量的值
    (1): 如下
        a,b = 1,2
        print(a,b)
        a,b =b,a
        print(a,b)
    (2):结果
        1 2
        2 1
        
3. 举例说明zip()函数的用法
    (1): zip函数在运算时,会以一个或者多个序列(可迭代对象)为参数,返回一个元组,
         且该元组的数据为这些可迭代对象中的并排元素,返回时遵循木桶效应,以最短
         的序列为基准.
         
    (2): zip 参数可以接受多类型可迭代对像,如下
            print([i for i in zip(range(7),range(6),range(5))])
            #输出[(0, 0, 0), (1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)]
            print([i for i in zip('abcdefg','1234','ABCDE')])
            #输出[('a', '1', 'A'), ('b', '2', 'B'), ('c', '3', 'C'), ('d', '4', 'D')]
            print([i for i in zip([1,2,3],['a','b','c'],['A','B','C','D'])])
            #输出[(1, 'a', 'A'), (2, 'b', 'B'), (3, 'c', 'C')]
4. 写一串正则表达式,将字符串a = '4apples'中的数字和字母加一个空格
    import re
    ret = re.sub(r'\d+',str(re.findall(r'\d+',"a = '4apples'")[0])+' ',"a = '4apples'")
    print(ret)

5. 写出几条常用的sql语句
    (1): show databases; 显示所有数据库
    (2): use database 数据库名; 进入到某个数据库
    (3): show tanles ; 显示数据库中所有表
    (4): desc 表名; 显示表的结构
    (5): select * from 表名 ; 查看表中所有数据
    (6): delete from 表名 where name = 'lihua'(条件),根据条件删除数据
    (7): update 表名 set name = 'lihua',age = '12'(数据;数据....) where id = 5(条件),根据条件更新数据
    (8): create database 数据库名; 新建数据库
    (9): create table 表名(字段 类型[长度] ,字段 类型[长度](如 id char[20])) ,新建表
    (10): insert into 表名(字段1,字段2) values(value1,value2) ,向表中插入数据

6. str1 = 'python' ,和str2 = '你好',编译成bytes类型
    str1 = 'python'
    str2 = '你好'
    print(b'python',type(b'python'))#b'python' <class 'bytes'>,字母可以字节b''即可
    print(str1.encode('utf8'),type(str1.encode('utf8')))#b'python' <class 'bytes'>
    print(str2.encode('utf

7. [1,2,3] + [4,5,6]的结果是什么
    print([1,2,3] + [4,5,6])#列表相加即合并,[1, 2, 3, 4, 5, 6]
    print((1,2,3) + (4,5,6))#元组相加也是,(1, 2, 3, 4, 5, 6)
    
8. 提高Python运行效率方法:
    (1): 尽量使用迭代器,节约内存
    (2): 尽量使用局部变量,检索速度快
    (3): 循环代码优化
    (4): 核心模块使用Cpython 或者 pypy,提高效率
    (5): 合理使用多线程,多进程,协程
    (6): 多个if else 语句时,发生次数较多的放在前面,减少判断次数
    
9. 简述mysql和redis的区别
    (1): mysql ,关系型数据库,数据保存在磁盘中,检索时有io操作,访问速度慢
    (2): redis , 内存型非关系数据库, 数据保存在内存中,检索速度快
    
10. 遇到bug如何处理

    (1): 细节上的错误可以直接print(),查看输出结果查找问题
    (2): 库或者框架,可以查找官方文档
    (3): 对于bug,可以进行管理与分类总结,用teambin 等等管理工具进行记录,然后一条条修改

基础试题10道

1. 正则匹配'date = 2020-6-18'
    import re
    str1 = '%daterange=2020-6-18%'
    print(re.findall(r'=(.+)%',str1))
2. list = [2,1,4,3,6,5],从小到大排序,不使用排序函数
    lst = [2,1,3,1,12,1,4,7,3,6,5,1,21]
    N = len(lst)
    while N>0:#冒泡,最大的向后移动
        for i in range(N-1):
            if lst[i]>lst[i+1]:
                lst[i],lst[i+1] = lst[i+1],lst[i]
        N-=1
    print(lst)
3. 写一个单列模式
    class New(object):
        __instance = None
        def __new__(cls, name, age):
            if not cls.__instance:
                cls.__instance = object.__new__(cls)
            return cls.__instance
        def __init__(self,name, age):
            self.name = name
            self.age =age
    a = New('小明',12)
    b = New('小红',10)
    print(id(a),id(b))#2803218705152 2803218705152,id相同
    print(a.name,b.name)#输出均为小红,说明对象只有一个
    
4. 保留两位小数
    print('%.4f'%(1/3))#利用%.4f格式化
    print('{:.4f}'.format(1/3))#利用format
    print(round(1/3,4))#使用round
    
5. 求三个方法打印结果
    def fn(key,value,dic={}):
        dic[key] = value
        print(dic)
    fn('a',1)
    fn('b',2)
    fn('c',3,{})
    fn('d',4,)
    # {'a': 1}
    # {'a': 1, 'b': 2}
    # {'c': 3}
    # {'a': 1, 'b': 2, 'd': 4}#如果不传如新字典,就会将数据加入到函数默认字典中
    
6. 列出常见的状态码和意义
    (1): 200 OK , 请求正常处理完毕
    (2): 204 No Content , 请求处理成功,没有实体的主题返回
    (3): 206 Partial Content , GET范围请求以成功处理
    (4): 301 Moved Permanently , 永久重定向,资源已永久分配新URL
    (5): 202 Found , 临时重定向 ,资源以临时分配新URL
    (6): 303 See Other 临时重定向, 期望使用GET定向获取
    (7): 304 Not Modified ,发送的附带请求条件未满足
    (8): 307 Temporary Redirect 临时重定向,POST 不会变成GET
    (9): 400 Bad Request 请求报文语法错误或者参数错误
    (10): 401 Unauthorized 需要通过HTTP认证,或者认证失败
    (11): 403 Forbidden 请求资源被拒绝
    (12): 404 Not Found 无法找到请求资源(服务器无理由拒绝)
    (13): 500 Internal Server Unavailable 服务器故障或者Web应用故障
    (14): 503 Service Unavailable 服务器超负载或者停机维护

7. 分别从前端,后端,数据库阐述web项目性能优化
    (1): 前端优化
        1. 减少http请求 ,例如制作精灵图
        2. html 和 css 放在页面上部,JavaScript放在页面下,因为js加载比较慢,
           所以优先加载html , css 以防页面显示不全,性能差,影响用户体验
    (2): 后端优化
        1. 缓存存储读写次数高,变化少的数据,比如网站信息首页,商品信息等.
           应用程序读取数据时,一般是先从缓存中读取数据,如果读不到,再访问
           磁盘数据库,并将数据再次缓存
        
        2. 异步方式 ,如果有耗时操作,可以采用异步 ,比如celery
        3. 代码优化,避免循环和多次判断,将最可能发生的if语句放在最前
    (3): 数据库优化
        1. 如果有条件,数据可以存放redis ,读取速度快
        2. 建立索引和外键等
        
8. 使用pop 和 del 删除字典中的键值对
    dic = {'a':1,'b':2,'c':2}
    print(dic)#{'a': 1, 'b': 2, 'c': 2}
    dic.pop('a')
    print(dic)#{'b': 2, 'c': 2}
    del dic['b']
    print(dic)#{'c': 2}
 
9. 列出常见的mysql 数据存储引擎
    (1): nnoDB：支持事务处理，支持外键，支持崩溃修复能力和并发控制。如果需要对事务的
         完整性要求比较高（比如银行），要求实现并发控制（比如售票），那选择InnoDB有很大的
         优势。如果需要频繁的更新、删除操作的数据库，也可以选择InnoDB，因为支持事务的提交
         (commit）和回滚（rollback）。

    (2): MyISAM：插入数据快，空间和内存使用比较低。如果表主要是用于插入新记录和读出
         记录，那么选择MyISAM能实现处理高效率。如果应用的完整性、并发性要求比 较低，也可
         以使用。

    (3):MEMORY：所有的数据都在内存中，数据的处理速度快，但是安全性不高。如果需要很快的读
        写速度，对数据的安全性要求较低，可以选择MEMOEY。它对表的大小有要求，不能建立太大的表。
        所以，这类数据库只使用在相对较小的数据库表。

10. 合并['a','b','c'],[1,2,3],为[('a', 1), ('b', 2), ('c', 3)]和{'a': 1, 'b': 2, 'c': 3}

    lst1 = ['a','b','c']
    lst2 = [1,2,3]
    print(list(zip(lst1,lst2)))#[('a', 1), ('b', 2), ('c', 3)]
    print(dict(list(zip(lst1,lst2))))#{'a': 1, 'b': 2, 'c': 3}
    print([(lst1[i],lst2[i]) for i in range(min(len(lst1),len(lst1)))])#[('a', 1), ('b', 2), ('c', 3)]
    print(dict([(lst1[i],lst2[i]) for i in range(min(len(lst1),len(lst1)))]))#{'a': 1, 'b': 2, 'c': 3}        

基础试题10道

1. 简述同源策略

    (1): 同源策略需要同时满足以下三点要求
         1. 协议相同
         2. 域名相同
         3. 端口相同
    (2): 只要不满足任意一个要求,就不符合同源策略,就会出现跨域
         1. http://abc.com 和 https://abc.com不同源,---协议不同
         2. http://abc.com 和 https://cde.com不同源,---域名不同
         3. http://abc.com 和 https://abc.com:8080不同源,--端口不同

2. 简述cookie 和 session 的区别
    (1): session在服务端,cookie在客户端(浏览器端)
    (2): session 的运行依赖session id ,而session id 存在与cookie,如果浏览器禁用了cookie
         同时session也会失效,存储session时,键与cookie中的sessionid相同值则是开发人员设置
         的键值对信息,进行了base64编码,过期时间由开发人员设置.
    (3): cookie的安全性比session差

3. 简述多进程,多线程
    (1): 多进程
        1. 操作系统进行资源分配和调度的基本单位,多个进程之间相互独立
        2. 稳定性好,如果一个进程崩溃,不影响其他进程
        3. 一个进程可以包含多个线程
        4. 进程消耗资源大,开启的进程数量有限制
    (2): 多线程
        1. cpu进行资源分配和调度的基本单位,线程是进程的一部分是比进程更小的能独立运行的基
           本单位,同一个进程下的多个线程共享该进程的所有资源.
        2. 如果是i/o操作密集,则多线程执行效率高,缺点是一个线程的崩溃,会造成进程的崩溃
    (3):应用
        1. i/o密集用多线程,用户输入,或者sleep时,可以切换到其他线程执行,减少等待时间
        2. cpu密集用多进程,因为python中有全局解释器锁(GIL),不能利用cpu多核优势
        
4. 简述any() 和all() 方法
    print(all([1,2,3,0]))# all ,迭代器中所有元素都为真返回True,否则返回False
    print(any([[],(),0,False,'',{},None]))#any , s迭代器中有一个为真就返回True,否则返回False

5. 常见的异常都有什么
    (1): IOError ,输入输出异常
    (2): AttributeError ,试图访问一个对象没有的属性
    (3): ImportError ,无法引入包或者模块 
    (4): IndentationError ,语法错误,代码没有对齐
    (5): IndexError , 下标超出索引
    (6): KeyError , 访问字典中不存在的键
    (7): SyntaxError , python代码逻辑语法出错,无法执行
    (8): NameError , 使用一个还未赋予对象的变量
    
6. copy , 和 deepcopy的区别
    (1):复制不可变数据类型时,copy和deepcopy一样,如(数值,字符串,元组),和=效果一样,对象的id不变
    (2): 复制的值是可变对象时,浅拷贝有两种情况
        1. 复制的对象中无复杂的子对象如列表嵌套列表,此时原来的值即使改变也不会影响
           浅复制的值,相当于新建了一个对象
        2. 复制的对象中有复杂的子对象,此时浅复制的对象和原来对象中子对象id相同,改变任意一个会互相影响
    (3): 深拷贝,deepcopy,完全复制并建立一个新对象,包括所有复杂的子对象
    
    
7. 常用的魔方方法
    1. 什么是魔方方法
        魔方方法指的是python内部已经包含的,被双下滑线包围的方法,这些方法在特定的操作下被自动调用
    2. 常用的魔方方法
        (1): __new__(cls, *args, **kwargs): ,实例化对象时调用的第一个方法,只接受第一个参数cls
            并把其他参数传给 __init__(self) ,并且此方法必须返回一个对象
        (2): __init__(self) , 初始化类被调用
        (3): __del__(self) ,del 对象 ,或者对像被销毁时调用(程序结束,所有指针被销毁)
        (4): __call__(self)  ,允许一个类的实例像函数一样被调用,对象()
        (5): __len__(self) , len(),
        (6): __repr__(self) ,repr()
        (7): __str__(self) , str()
        (8): __hash__(self) ,hash()
        (9): __bool__(self) ,bool()
        (10): __format__(self) ,format()
8. 通过命令行执行python脚本时(print(sys.argv)),会输出什么数据
    1. python demo.py 1 2
    2. 输出['demo.py','1','2']

9. 将[i for i in range(3)]改成生成器
    (1): 生成器是特殊的迭代器
    (2): 第一种方法
        lst = (i for i in range(3))
        print(type(lst))
    (3): 第二种
        def fn1():
            for i in range(3):
                yield i
        print(type(fn1()))
10. 去掉字符中的空格'a b c'和' abc '
    str1 = 'a b c'
    str2 = ' abc '
    print(str1.replace(' ', ''))
    print(str2.replace(' ', ''))#或者print(str2.strip(' '))

基础试题10道

1. 用sort 和 sorted 对列表排序 lst = [3,-1,1,-2,2,-3]
    #------------sort----------------
    lst = [3,-1,1,-2,2,-3]
    lst.sort()#从小到大
    print(lst)#[-3, -2, -1, 1, 2, 3]
    lst.sort(reverse=True)#从大到小
    print(lst)#[3, 2, 1, -1, -2, -3]
    #------------sorted----------------
    lst = [3,-1,1,-2,2,-3]
    res = sorted(lst)#同lst.sort(),从小到大
    print(res)
    res = sorted(lst,reverse=True)#同lst.sort(reverse=True),从大到小
    print(res)

2. 对列表使用lambda函数排序 lst = [3,-1,1,-2,2,-3],从小到大
    lst = [3,-1,1,-2,2,-3]
    res = sorted(lst,key=lambda x:x)
    print(res)

3. 对列表使用lambda函数排序 lst = [3,-1,1,-2,2,-3],正数从小到大,负数从大到小
    lst = [3,-1,1,-2,2,-3]
    res = sorted(lst,key=lambda x:(x<0,abs(x)))#同lst.sort(),从小到大
    print(res)
 
4. 对列表嵌套字典排序 lst = [{'name':'c','age':2},{'name':'d','age':1},{'name':'b','age':3},{'name':'a','age':4},]
   分别根据name,和age排序
    lst = [{'name':'c','age':2},{'name':'d','age':1},{'name':'b','age':3},{'name':'a','age':4},]
    res = sorted(lst,key=lambda x:x['name'])#根据name,逆序res = sorted(lst,key=lambda x:x['name'],reverse=True)
    print(res)
    #[{'name': 'a', 'age': 4}, {'name': 'b', 'age': 3}, {'name': 'c', 'age': 2}, {'name': 'd', 'age': 1}]
    res = sorted(lst,key=lambda x:x['age'])#根据age,,逆序res = sorted(lst,key=lambda x:x['age'],reverse=True)
    print(res)
    #[{'name': 'd', 'age': 1}, {'name': 'c', 'age': 2}, {'name': 'b', 'age': 3}, {'name': 'a', 'age': 4}]
    
5. 对列表嵌套元组排序 lst = [('d',1),('b',3),('c',2),('a',4),]分别根据字母,和数字排序
    lst = [('d',1),('b',3),('c',2),('a',4),]
    res = sorted(lst,key=lambda x:x[0])#根据字母,逆序res = sorted(lst,key=lambda x:x[0],reverse=True)
    print(res)
    #[('a', 4), ('b', 3), ('c', 2), ('d', 1)]
    res = sorted(lst,key=lambda x:x[1])#根据数字,逆序res = sorted(lst,key=lambda x:x[1],reverse=True)
    print(res)
    #[('d', 1), ('c', 2), ('b', 3), ('a', 4)]
    
6. 对列表嵌套列表排序 lst = [['d',1],['b',3],['c',2],['a',4],], 数字相同怎么排
    lst = [['d',1],['b',2],['c',2],['a',4],]
    res = sorted(lst,key=lambda x:(x[1],x[0]))#数字相同根据字母排序
    print(res)

    
7. 字典排序 dic = {'name':'c','name':'d','name':'b','name':'a',},使用zip
    dic = {'8':'c','9':'d','6':'b','7':'a',}
    res = zip(dic.keys(),dic.values())
    #------------------根据键--------------------
    ret = sorted(res,key=lambda x:x[0])#根据键排序
    print(dict(ret))#{'6': 'b', '7': 'a', '8': 'c', '9': 'd'}
    #------------------根据值--------------------
    res = zip(dic.keys(),dic.values())
    ret = sorted(res,key=lambda x:x[1])#根据值排序
    print(dict(ret))#{'7': 'a', '6': 'b', '8': 'c', '9': 'd'}

8. 字典排序 dic = {'name':'c','name':'d','name':'b','name':'a',},不使用zip        
    dic = {'8':'c','9':'d','6':'b','7':'a',}
    #------------------根据键--------------------
    ret = sorted(dic.items(),key=lambda x:x[0])#根据键排序
    print(dict(ret))#{'6': 'b', '7': 'a', '8': 'c', '9': 'd'}
    #------------------根据值--------------------
    ret = sorted(dic.items(),key=lambda x:x[1])#根据值排序
    print(dict(ret))#{'7': 'a', '6': 'b', '8': 'c', '9': 'd'}
    
9. 列表推导式,字典推导式,生成器
    #------------------列表推导式--------------------
    lst = [x for x in range(5)]
    print("type:%s\nlst:%s"%(type(lst),lst))
    # type:<class 'list'>
    # lst:[0, 1, 2, 3, 4]
    #------------------字典推导式--------------------
    lst = dict([(str(x),x) for x in range(5)])
    print("type:%s\nlst:%s"%(type(lst),lst))
    # type:<class 'dict'>
    # lst:{'0': 0, '1': 1, '2': 2, '3': 3, '4': 4}
    #--------------------生成器----------------------
    lst = (x for x in range(5))
    print("type:%s\nlst:%s"%(type(lst),lst))
    # type:<class 'generator'>
    # lst:<generator object <genexpr> at 0x000001A5A99209E8>

10. 根据列表中字符串长度排序  lst = ['endswith','abs','append','name',]      
     
    lst = ['endswith','abs','append','name',]
    res = sorted(lst,key=lambda x:len(x))
    print(res)#['abs', 'name', 'append', 'endswith']

基础试题10道

1. sql 注入解决方法
    (1): 当以字符串格式化书写方式的时候,如果用户输入的有 +sql语句,后面的sql语句就会执行,删除数据库的等
    (2): 解决方式,通过传参方式解决sql注入,在函数execute('select * from where name=%s',arg)
    
2. str1 = 'name:LiHua 12 北京',用正则切割字符串输出所有元素
    (1): 
        import re
        str1 = 'name:LiHua 12 北京'
        ret = re.split(r':| ',str1)
        print(ret)   
    (2):
        import re
        str1 = 'name:LiHua 12 北京'
        ret = re.split(r'[: ]',str1)
        print(ret)
3. 正则匹配163.com,邮箱地址
    import re
    data = ['xaioming@163.com','xaioming@163.com123','xaioming@qq.com']
    for ele in data:
        if re.findall(r"[\w]{4,20}@163.com$", ele):
            print(re.findall(r"[\w]{4,20}@163.com$", ele))

4. 递归求和

    def fun(N):
        if N == 1:
            return 1
        else:
            res = N + fun(N-1)
        return res
    print(fun(100))           

5. python 字典和josn字符串相互转化的方法
    import json
    dict_data = {'name':'liahua','age':12,'adress':'beijing'}
    json_data = json.dumps(dict_data)
    print(type(json_data))#<class 'str'>
    dict_data = json.loads(json_data)
    print(type(dict_data))#<class 'dict'>

6. 而MyISAM 与 InnoDB 区别?
    (1): InnoDB 支持事务,而MyISAM不支持,事务是一种高级处理方式,InnoDB中
         如增删改出错可以还原,而MyISAM 不可以
    (2): MyISAM适合查询以及插入为主的应用,InnoDB适合频繁修改以及安全性高的应用
    (3): InnoDB中支持外键,而MyISAM不支持
    (4): 对于自增长的字段,InnoDB中必须包含只有该字段的索引,但是在MyISAM可以和其他
         字段一起建立联合索引
    (5): 清空表时,InnoDB是一行一行删除,效率低,而MyISAM会重建表

7. 统计字符串中某字符出现的次数
    str1 = 'ababacdcdcdc'
    print(str1.count('ab'))

8. 字符串大小写转换
    print('Ab'.lower())#ab
    print('Ab'.upper())#AB
    print('Ab'.swapcase())#aB
9.用两种方法去空格
    print('a b c'.replace(' ',''))
    print(''.join('a b c'.split()))
    
10. 正则匹配不是以4和7结尾的手机号
    import re
    data_list = ['12781240893','10086', '127812408915','10010']
    for data in data_list:
        if re.findall(r'^1\d{9}[0-3,5-6,8-9]{1}$', data):
            print(re.findall(r'^1\d{9}[0-3,5-6,8-9]{1}$', data))        

基础试题10道

1. 简述python引用技术机制
    (1): python垃圾回收主要以引用计数为主,标记-清除和分代清除为辅的机制,其中标记-清除和
         分代回收主要是为了处理循环引用的难题
    (2): 引用技术算法
        1. 有一个变量保存对象引用后,该对象引用计数会加一
        2. 用del 删除对象时,如果引用计数为1,就会直接被删除,否则会将引用计数减一
    (3):如下所示,只有删除最后一个引用是才会彻底清除
        1. 代码:
            class Person(object):
                def __init__(self,name,age):
                    self.name = name
                    self.age = age
                def __del__(self):
                    print('删除对象:%s'%self.name)
            person1 = Person('小明',12)
            person2 = person1
            person3 = person1
            print("删除对象:%s" %person1)
            del person1
            print("删除对象:%s" %person2)
            del person2
            print("删除对象:%s" %person3)
            del person3
        2. 结果:
            删除对象:<__main__.Person object at 0x000001485D4FECC0>
            删除对象:<__main__.Person object at 0x000001485D4FECC0>
            删除对象:<__main__.Person object at 0x000001485D4FECC0>
            删除对象:小明
            
2. int(1.4) 和 int('1.4')
    (1): int(1.4) 输出1
    (2): int('1.4') 报错
    (3): 想把字符串形式小数转为int,需要先转成float如int(float('1.4'))
3. 列举3条以上PEP8编码规范
    (1): PEP8 (Python Enhancement Proposal), python增强提案,针对python语言编订的代码风格指南
    (2): 顶级定义之间空两行如函数和类定义
    (3): 方法定义,类定义与第一个方法之间都应该空一行
    (4): 三引号注释
    (5): 使用Pycharm ,Eclipses一般使用4个空格缩进
    
4. 用正则匹配第一个url,html = '<a href="https://pro.fanyi.so.com/quic?src=fanyiweb&amp;from=22&amp;
   to=21&amp;cont=person" target="_blank" class="human-translate">人工翻译</a>'
    (1): 
        import re
        html = '<a href="https://pro.fanyi.so.com/quic?src=fanyiweb&amp;from=22&amp;to=21&amp;cont=person" target="_blank" class="human-translate">人工翻译</a>'
        print(re.findall(r' href="(.+?)"',html))

5. 用正则匹配中文
    import re
    html = '<a href="https://pro.fanyi.so.com/quic?src=fanyiweb&amp;from=22&amp;to=21&amp;cont=person" target="_blank" class="human-translate">人工翻译</a>'
    print(re.findall(r'[\u4e00-\u9fa5]+',html))#['人工翻译']
    
6. 乐观锁和悲观锁
    (1): 乐观锁, 每次拿数据认为别人不会修改,不上锁,只在更新时判断此期间别人是否更新了该数据,
         乐观锁适用于多读的应用类型,这样可以提高吞吐量
    (2): 悲观锁,每次拿数据时都会认为别人会修改,都会上锁,这样别人要操作数据时,只能等他操作完
         传统数据库用到很多锁机制,表锁,行锁,读锁,写锁等,在操作之前先上锁.
         
7. 文件打开模式区别
    (1): r , 只读模式,文件指针在文件开头
    (2): w , 只写模式,文件存在覆盖文件,不存在创建
    (3): a , 追加模式,文件存在追加文件,文件指针在文件结尾,不存在创建,
    (4): rb , 以二进制形式(字节)只读
    (5): wb , 以二进制形式(字节)只写
    (6): ab , 以二进制形式(字节)只追加
    (7): r+ , 打开一个文件用于读写,文件指针在文件开头
    (8): w+ , 打开一个文件用于读写,文件存在覆盖文件,不存在创建
    (9): a+ , 打开一个文件用于读写,文件存在追加文件,文件指针在文件结尾,不存在创建,
    (10): rb+,wb+,ab+,以二进制形式(字节)打开文件,功能一样

8. linux 命令重定向> 和 >>
    (1): linux 允许将命令执行结果重新定向到一个文件,将本应该在终端显示的内容,输出/追加
         到指定文件中.
    (2): > ,表示输出,会覆盖原来文件
    (3): >> ,表示追加,会将内容追加到已有文件的末尾.
    (4): 如 python Hello > 1.txt, 或者 python Hello >> 1.txt,
    
9. 正则匹配,匹配 html = '<html><h1>Hello Python</h1></html>'
    import re
    html = '<html><h1>Hello Python</h1></html>'
    print(re.match(r'<(.+)><(.+)>.+</\2></\1>',html).group())#按照分组
    
10. python 传参数是传值还是传址?
    (1): python函数参数传递是引用传递(不是传值),对于不可变的数据类型函数执行时不会影响变量本身
         对于可变类型(list,dict,等),函数的执行会改变传递过来的参数