python基础

1.为什么学习Python？
    -- python是一门比较新的语言，崇尚优美、清晰、简单，是一个优秀的使用广泛的语言。

2.通过什么途径学习的Python？
    -- 工作生活中自学成才

3.Python和Java、PHP、C、C#、C++等其他语言的对比？
    -- python是一门动态解释型的强类型定义语言。
    -- python简单易学，入门容易，将来深入学习，可以编写编写非常复杂的程序
    -- python开发效率非常高，拥有强大的第三方库。基本上计算机需要的功能官方库都有对应模块支持。大大降低开发周期。
    -- python是一门高级语言，不需要考虑底层细节
    -- python可移植性强，小心避免依赖系统特性，程序无需修改几乎可在任何系统上运行。
    -- python可扩展性强，如果不想公开自己的代码，部分程序可以用C或C++编写
    -- python可嵌入性强，可以嵌入到C或C++语言中，当脚本运行。

    -- 速度较慢  边解释边执行
    -- 代码不能加密  铭文
    -- 线程不能利用多CPU问题  GIL全局解释器锁使得程序在任何是都都只有一个线程在运行

4.简述解释型和编译型编程语言？
    -- 解释型语言是在程序执行的时候，一行一行的解释成机器语言并逐行执行程序，所以执行速度相对编译型语言较慢。
    -- 编译型语言先把源程序的每一条语句都编译成机器语言，并保存成二进制，然后一次性执行，这样速度很快。

5.Python解释器种类以及特点？
    -- CPython   3.6版本后，用C语言开发的所以叫CPython，也是使用最广泛的解释器。
    -- IPython   基于CPython之上的一个交互式解释器，在交互上有所增强，其内核都一样。
    -- PyPy      采用JIT技术，对代码进行动态编译，显著提高了执行速度。
    -- Jython    运行在Java平台上的python解释器，可以把python代码编译成Java代码执行。
    -- IroPython 和Jython类似，运行在微软.Net平台上的python解释器，编译成.Net代码

6.位和字节的关系？
    -- 8位一个字节
    -- 8bit = 1B

7.b、B、KB、MB、GB 的关系？
    -- 1B = 8b
    -- 1KB = 1024B
    -- 1MB = 1024KB
    -- 1GB = 1024MB

8.请至少列举5个 PEP8 规范（越多越好）。
    -- 缩进用4个空格
    -- 所有行限制的最大字符数是79
    -- 顶层函数和类的定义，前后用两个空行隔开
    -- 导入模块的顺序  标准库-第三方库-本地用用或库
    -- 不在小括号或中括号或大括号后面使用无关的空格
    -- 空格津贴在逗号、冒号、分号之前
    -- 加注释，不能与代码相矛盾，更新代码应优先更新注释
    -- 块注释用一个井号和一个空格
    -- 行内注释，井号要和代码空两个格

9.通过代码实现如下转换：
二进制转换成十进制：v = “0b1111011”

    -- print(int(v, 2))
十进制转换成二进制：v = 18

    -- print(bin(v))
八进制转换成十进制：v = “011”

    -- print(int(v, 8))
十进制转换成八进制：v = 30

    -- print(oct(v))
十六进制转换成十进制：v = “0x12”

    -- print(int(v, 16))
十进制转换成十六进制：v = 87
    -- print(hex(v))

10.请编写一个函数实现将IP地址转换成一个整数。

如 10.3.9.12 转换规则为：
        10            00001010

         3            00000011

         9            00001001

        12            00001100

再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ？

    -- print(int("00001010", 2))
    -- print(int("00000011", 2))
    -- print(int("00001001", 2))
    -- print(int("00001100", 2))

11.python递归的最大层数？
    -- 1000
    可以调整
    import sys
    sys.setrecursionlimit(1500)

12.求结果：
    v1 = 1 or 3

    -- 1
    v2 = 1 and 3

    -- 3
    v3 = 0 and 2 and 1
    -- 0

    v4 = 0 and 2 or 1
    -- 1

    v5 = 0 and 2 or 1 or 4
    -- 1

    v6 = 0 or False and 1
    -- False

13.ascii、unicode、utf-8、gbk 区别？
    -- ascii码 基于拉丁字符的电脑编码系统，主要显示现代英语和西欧语言，最多8位一个字节，即最多256个字符
                ascii码中的内容用1个字节保存、欧洲的字符用2个字节保存，东亚的字符用3个字节保存
    -- unicode 万国码，为了解决ascll码的局限而产生的，一个字符最少由16位表示，也可以是32位，
               统一用2个bytes代表一个字符，可以表达2**16=65556个，称为万国语言，特点：速度快，但浪费空间，
    -- utf_8   是对Unicode编码的压缩和优化 规定1个英文字符用1个字节表示，1个中文字符用3个字节表示，
               特点；节省空间，速度慢，用在硬盘数据传输，网络数据传输，相比硬盘和网络速度，体现不出来的，
    -- gbk     是中文的字符编码，用2个字节代表一个字符，
14.字节码和机器码的区别？
    -- 机器码(machine code)，学名机器语言指令，有时也被称为原生码（Native Code），是电脑的CPU可直接解读的数据。
       机器码是电脑CPU直接读取运行的机器指令，运行速度最快，但是非常晦涩难懂，也比较难编写，一般从业人员接触不到。
    -- 字节码是一种中间状态（中间码）的二进制代码（文件）。需要直译器转译后才能成为机器码。

15.三元运算规则以及应用场景？
    -- 三元运算符就是在赋值变量的时候，可以直接加判断，然后赋值
       三元运算符书写一行，代码非常精炼，执行效率高
       ret = 值1 if 条件 else 值2

16.列举 Python2和Python3的区别？
    -- print  2中被视为一个语句，3中需要一个函数，需要加括号
    -- 整数的除法  2中默认取整数，3中默认整数和小数都显示
       解决办法 2中的整数都改成浮点类型
    -- 默认编码 2中的是ASCII  3中的是Unicode
    -- 2中的是xrange()返回的是生成器，range()返回的是列表
    -- 后续  2.7将在2020年后失去后续的支持 3将继续开发更多功能和修复更多的错误

17.用一行代码实现数值交换：
     
 a = 1
 
     b = 2
    -- a, b = b, a
18.Python3和Python2中 int 和 long的区别？
    -- long是长整形，而3中只有一种整数类型int

19.xrange和range的区别？
    -- 用法一摸一样，2中的是xrange()返回的是生成器，range()返回的是列表

20.文件操作时：xreadlines和readlines的区别？
    -- 二者使用时相同，但返回类型不同，xrangelines返回一个生成器，readlines返回一个列表

21.列举布尔值为False的常见值？
    -- 0
    -- []
    -- ()
    -- {}

22.字符串、列表、元组、字典每个常用的5个方法？
    -- 字符串 capitalize()首字母大写
              swapcase()大小写反转
              title()每个单词的首字母大写
              center(20,"*")内居中，其他位置填充
              count()元素出现的次数
              upper()所有值变大写
              lower()所有值小写
              startswith()检测开头，返回布尔值
              endswith()检测结尾，返回布尔值
              find()寻找元素是否存在，找到返回索引，找不到返回-1
              index()寻找元素是否存在，找到返回索引，找不到报错
              split()正向切割，返回一个列表
              strip()去掉两边的符号
              replace("旧的", "新的", 次数)
              isalnum()由字母和数字组成
              isalpha()只由字母组成
              isdigit()只由数字组成
    -- 列表   索引与切片
              li.insert(索引,元素)按照索引插入元素
              li.append()增加到最后
              li.extend()迭代着增加
              pop()取出列表的最后一位
              del li[1:3]删除指定元素
              clear li清空列表
              li.remove()按照元素删除
              count()元素出现的次数
              index()按照索引查找元素
              sort()排序，必须全是数字
              reverse()反转
    -- 字典   直接增，有则覆盖，没有则增加到后面
              setdefault()有则不修改，没有这增加，值默认为None
              pop()按照key直接删
              popitem()随机删一个，3.6以后默认删最后一个
              dict.clear()清空字典
              dict.updata()覆盖增加
              dict.get()根据key找velue，可以设置返回值
    -- 元祖   upper()变成大写
              join()连接 列表转化成字符串用join
              字符串转化成列表用split

23.lambda表达式格式以及应用场景？
    -- lambda表达式，通常是在需要一个函数，但又不想费神去命名函数的场合下用，也就是匿名函数
    -- add = lambda a, b = a + b
       print(add(1, 2))
       应用在函数时编程中，应用在闭包中

24.pass的作用？
    -- 空语句 do nothing
    -- 保证格式完整，保证语义完整
    -- 占位语句

25.*arg和**kwarg作用
   -- *args 接收n个位置参数，转化成元组。
   -- **kwargs 接收n个关键字参数，转化成字典。

26.is和==的区别
   -- == 比较的是value 也就是值是否相同。
   -- is 比较的是id 也就是是否是同一个对象。

27.简述Python的深浅拷贝以及应用场景？
   -- 首先我们知道Python的引用跟对象是分离的，
      那我们的直接赋值其实就是对象的引用，也可以理解为对象取一个别名
   -- 浅拷贝
         --对于可变对象而言是创建一个具有相同的类型，相同的值但id不同的对象
            如果有子对象，这些对象和原始对象的子对象是同一个引用。
         --对于不可变对象而言，浅拷贝只拷贝引用。
   -- 深拷贝是拷贝对象，开辟新的内存空间，包括子对象，互不影响。

28.Python垃圾回收机制？
    -- python的GC模块主要运用了"引用计数"来跟踪和回收垃圾。
    -- 在引用计数的基础上，还可以通过"标记清除"解决容器对象可能产生的循环引用问题。
    -- 通过"分代回收"以空间换取时间来进一步提高垃圾回收的效率。

29.Python的可变类型和不可变类型？
    -- 判断是不是可变数据类型，就看value变的时候看其id值是否变化
    -- 可变：列表 字典
    -- 不可变：数字 字符串 元祖 布尔值
30.求结果：

   v = dict.fromkeys(['k1','k2'],[])

   v[‘k1’].append(666)

   print(v)

   v[‘k1’] = 777

   print(v)
求结果：
    -- {'k1': [666], 'k2': [666]}
    -- {'k1': 777, 'k2': [666]}

31、求结果：
def  num():
    return [lambda x:i*x for i in range(4)]
print([ m(2) for m in num()])

[6, 6, 6, 6]

32.列举常见的内置函数？
    -- bin二进制
    -- oct八进制
    -- hex十六进制
    -- print输出
    -- max取最大值
    -- min最小值
    -- len长度

33.filter、map、reduce的作用？
   -- filter 函数是一个筛选函数参数（函数，可迭代对象）
      filter将传入的函数依次作用到序列的每个元素，True则返回 False则不返回。
      list1 = [1,2,3,4,5,6,7,8,9]
      def a(x):
         return x%2==1
      print(filter(a, list1)) # 返回值类型是filter对象 生成器对象
   -- map 函数是一个计算函数 参数（函数，可迭代对象）
      会将可迭代对象的值经过函数计算后返回
      my_map = map(lambda x:x+1, range(10))
      print(list(my_map)) # 返回值类型是map对象 生成器对象
   -- reduce 函数也是一个计算函数 参数（函数，可迭代对象）
      会将可迭代对象的值依次在函数中累计运算 Python3中需要导入
      from functools import reduce
      my_reduce = reduce(lambda x,y:x+y, range(10))
      print(my_reduce) # 返回 计算后结果 45

34.一行代码实现9*9乘法表
    -- print('\n'.join([ ' '.join(["%s*%s=%s" % (x, y, x*y) for y in range(1, 1+x)]) for x in range(1, 10)]))

35.如何安装第三方模块？以及用过哪些第三方模块？
    -- pip install 三方模块名
    -- django  flask jinja2 Pilow scrapy redis django-redis

36.至少列举8个常用模块都有那些？
    -- time re os sys random 序列化模块 hashlib模块 logging模块

37.re的match和search区别？
    -- match()函数只检测字符串开头位置是否匹配，匹配成功才会返回结果，否则返回None
    -- search()函数会在整个字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,
       该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。

38.什么是正则的贪婪匹配？
    -- 贪婪匹配:正则表达式一般趋向于最大长度匹配，也就是所谓的贪婪匹配          
    -- 非贪婪匹配：就是匹配到结果就好，就少的匹配字符          
    -- 默认是贪婪模式；在量词后面直接加上一个问号？就是非贪婪模式

39.求结果：
 a. [ i % 2 for i in range(10) ]
 b. ( i % 2 for i in range(10) )
    -- [0, 1, 0, 1, 0, 1, 0, 1, 0, 1]    %表示取余数  / 表示除  // 表示取商的整数  * 表示乘以  ** 表示幂运算
    -- b的结果是一个生成器

40.求结果：
 a. 1 or 2
 b. 1 and 2
 c. 1 < (2==2)
 d. 1 < 2 == 2
    -- 1
    -- 2
    -- False
    -- True

41.def func(a,b=[]) 这种写法有什么坑？
    -- b = [] 参数陷阱，因为[]是可变数据类型

42.如何实现 “1,2,3” 变成 [‘1’,’2’,’3’] ?
    -- a = "1,2,3"
       print(a.split(','))

43.如何实现[‘1’,’2’,’3’]变成[1,2,3] ?
    -- a = ['1', '2', '3']
       print(','.join(a))

44.比较： a = [1,2,3] 和 b = [(1),(2),(3) ] 以及 b = [(1,),(2,),(3,) ] 的区别？
    -- a是一个列表，里面的1,2,3都是int类型
    -- b是一个列表，里面的元素都是int类型
    -- c是一个列表，里面的元素都是元祖类型

45.如何用一行代码生成[1,4,9,16,25,36,49,64,81,100] ?
    -- print([i*i for i in range(1,11)])

46.一行代码实现删除列表中重复的值 ?
    -- from functools import reduce
    -- ids = [1,4,3,3,4,2,3,4,5,6,1]
    -- print(reduce(lambda x,y:x if y in x else x + [y], [[], ] + ids)) 这个保证顺序
    -- print(list(set(ids))  这个不保证顺序

47.如何在函数中设置一个全局变量 ?
    -- 在函数内的变量名前添加global

48.logging模块的作用？以及应用场景？
    -- 可以通过设置不同的日志等级，在release版本中输出重要消息，而不及显示大量的调试信息。
    -- print将所有信息都输出到标准输出中，严重营销开发者从标准输出中查看其它数据。
    -- logging则可以由开发者决定信息输出到什么地方，以及怎么输出。

49.请用代码简答实现stack 。
class Stack(object):
    def __init__(self):
        self.stack = []

    def push(self, value): # 进栈
        self.stack.append(value)

    def pop(self):  # 出栈
        if self.stack :
            self.stack.pop()
        else:
            raise LookupError("stack is empty")

    def is_empty(self):  # 如果栈为空
        return bool(self.stack)

    def top(self):
        # 取出目前stack中最新的元素
        return self.stack[-1]

50.常用字符串格式化哪几种？
    -- format 和%s占位符

51.简述 生成器、迭代器、可迭代对象 以及应用场景？
    -- Python可迭代对象（Iterable）
       Python中经常使用for来对某个对象进行遍历，此时被遍历的这个对象就是可迭代对象，像常见的list,tuple都是。
       如果给一个准确的定义的话，就是只要它定义了可以返回一个迭代器的__iter__方法，
       或者定义了可以支持下标索引的__getitem__方法(这些双下划线方法会在其他章节中全面解释)，那么它就是一个可迭代对象。
    -- Python迭代器（iterator）
       迭代器是通过next()来实现的，每调用一次他就会返回下一个元素，当没有下一个元素的时候返回一个StopIteration异常，
       所以实际上定义了这个方法的都算是迭代器。
    -- 生成器（Generators）
       生成器是构造迭代器的最简单有力的工具，与普通函数不同的只有在返回一个值的时候使用yield来替代return，
       然后yield会自动构建好next()和iter()。
    -- 使用场景
       生成器最佳应用场景是：你不想同一时间将所有计算出来的大量结果集分配到内存当中，特别是结果集里还包含循环。
       比方说，循环打印1000000个数，我们一般会使用xrange()而不是range()，
       因为前者返回的是生成器，后者返回的是列表（列表消耗大量空间）。

52.用Python实现一个二分查找的函数。
l = [1, 2, 3, 4, 5, 6, 7, 8]


def er(l, low, high, val):

    if low <= high:
        mid = (low + high) // 2
        if l[mid] == val:
            return mid
        elif l[mid] > val:
            low = low
            high = mid - 1
            return er(l, low, high, val)

        else:
            low = mid + 1
            high = high
            return er(l, low, high, val)
    else:
        return None


ret = er(l,0, len(l) - 1, 7)
print(ret)

53.谈谈你对闭包的理解？
    -- 闭包就是能够读取其他函数内部变量的函数，可以成为定义在函数内部的函数，闭包是内部函数和外部函数之间沟通的桥梁

54.os和sys模块的作用？
    -- os是python标准库中用于访问操作系统功能的模块，其提供了值用可移植的方法来使用操作系统的功能。它提供了一系列的访问操作系统的接口便于编写跨平台的作用。
    -- sys提供访问由python解释器提供和维护的变量以及与解释器进行交互的的函数。用于操控解释器运行时的环境。

55.如何生成一个随机数？
    -- 使用random模块
       import  random
       print(random.random())  大于0，小于1的随机小数
       print(random.random(1，10))  大于等于1小于等于10的随机整数


56.如何使用python删除一个文件？
    -- 使用os模块的remove()或unlink()删除文件

57.谈谈你对面向对象的理解？
    -- 面向对象就是将程序模块化、实例化。将具体事物的特性属性和这些特性属性实现的一些动作的具体方法放到一个类中，这就是封装。
       然后还有继承，继承就是子类使用弗雷德属性和方法不用自己重写一遍。
       多态就是多种形态包括重载和重写，子类继承了父类的功能，但是自己内部重新写了这个功能，那么自己的功能就覆盖了父类的功能。

58.Python面向对象中的继承有什么特点？
    -- 在基类中构造的init方法不会自动调用，需要在派生类的构造中亲自调用，有别于C#
    -- 当调用基类的方法时需要加上基类的类名作为前缀，且需要带上self参数变量，却别与类中调用普通函数不需要调用self参数
    -- python总是先找字类的对应方法，找不到再去基类找

59.面向对象深度优先和广度优先是什么？
    -- 继承的时候深度优先是先找父类，纵向查找优先，
    -- 继承的时候横向优先

60.面向对象中super的作用？
    -- 用于调用父类的一个方法
    -- super是用来解决多继承问题的，当单继承时直接用类名调用父类方法，但是多继承时就不行了。
    -- A.mro()
    -- A.__mro__

61.是否使用过functools中的函数？其作用是什么？
    -- from functools import wraps  装饰器修复，显示被装饰函数的名字

62.列举面向对象中带爽下划线的特殊方法，如：__new__、__init__
    -- __init__  初始化对象，当一个对象被实例化时自动触发
       __new__  对象实例化前自动触发，通过传递参数判断对象是否被创建或其他
       __del__  当一个对象没被任何引用时触发，回收内存
       __call__  将对象当作函数调用时触发

63.如何判断是函数还是方法？
from types import MethodType,FunctionType

class Foo(object):
    def fetch(self):
        pass
print(isinstance(Foo.fetch,MethodType))    # False
print(isinstance(Foo.fetch,FunctionType))  # True

obj = Foo()
print(isinstance(obj.fetch,MethodType))    # True
print(isinstance(obj.fetch,FunctionType))  # False

# MethodType方法类型
# FunctionType函数类型

64.静态方法和类方法区别？
    -- 静态方法和类方法都可以通过实例和类调用
    -- 静态方法不需要传参数，静态方法不能继承，可认为是全局函数
    -- 类方法第一个参数是cls类参数

65.列举面向对象中的特殊成员以及应用场景
    -- 魔术方法 用于在某一时刻调用时

66.1、2、3、4、5 能组成多少个互不相同且无重复的三位数
    -- 5*4*3
n = 0
for i in range(1,5):
    for x in range(1, 5):
        for z in range(1, 5):
            if i != x and i != z and x != z:
                n += 1
                print(n)
                print(i, x, z)
67.什么是反射？以及应用场景？
    -- 是用字符串类型的名字去操作变量
       a = A()
       getattr(a,'name') == a.name
       setattr()
       delattr(a,'name')

68.metaclass作用？以及应用场景？
    -- 元类就是创建类这种对象的东西

69.用尽量多的方法实现单例模式。
    -- 1 使用模块：python的模块就是天然的单利模式。当模块第一次导入时，会生成一个文件，当再次导入时，还是使用这一个文件。
         具体用法就是在一个文件中写一个类，然后导入到另一个文件中。
    -- 2 使用装饰器：
            def Singleton(cls):
                _instance = {}
                def _singleton(*args, **kwargs):
                    if cls not in _instance:
                        _instance[cls] = cls(*args, **kwargs)
                    return _instance[cls]
                return _singleton
            @Singleton
            class A(object):
                a = 1
                def __init__(self, x=0):
                    self.x = x
            a1 = A(1)
            a2 = A(3)
    -- 3 实用类：
            class Singleton(object):
                _instance = None
                def __new__(cls, *args, **kwargs):
                    if not cls._instance:
                        cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
                    return cls._instance
            class Myclass(Singleton):
                a = 1
            mc1 = Myclass()
            mc2 = Myclass()
            mc3 = Myclass()
            print(mc1)
            print(mc2)
            print(mc3)
            打印出来的结果是一样的
            主要目的是确保某一个类只有一个实例存在
            但是以上方法在多线程中就失效了，加上锁就能解决，加锁降低速度，但是保证数据安全
    -- 4 基于__new__方法实现：我们知道，当我们实例化一个对象时，是先执行了类的__new__方法（我们没写时，默认调用object.__new__），实例化对象；
                              然后再执行类的__init__方法，对这个对象进行初始化，所有我们可以基于这个，实现单例模式

    -- 5 基于metaclass方式实现：
        以后再补充
   -- https://www.cnblogs.com/huchong/p/8244279.html

70.装饰器的写法以及应用场景。
def deco(func):
    def warpper(*args, **kwargs):
        print(‘start‘)
        func(*args, **kwargs)
        print(‘end‘)
    return warpper

@deco
def myfunc(parameter):
    print("run with %s" % parameter)

myfunc("something")

71.异常处理写法以及如何主动跑出异常（应用场景）
try:
    pirnt('123')
except:
    print('456')

72.什么是面向对象的mro
    -- 类的继承顺序
       字类永远在父类的前面
       如果继承多个父类，按括号中的顺序出现
       如果多个类同时继承了一个父类，孙子类中只会选取第一个父类中的父类的该方法

73.isinstance作用以及应用场景？
    -- 检测一个数据是否由指定的类型创建
    -- isinstance(object, classinfo)检查是否obj是否是类 cls 的对象

74.写代码并实现：
Given an array of integers, return indices of the two numbers such that they add up to a specific target.You may assume that each input would
have exactly one solution, and you may not use the same element twice.
Example:

          Given nums = [2, 7, 11, 15], target = 9,
           
Because nums[0] + nums[1] = 2 + 7 = 9,

           return [0, 1]


75.json序列化时，可以处理的数据类型有哪些？如何定制支持datetime类型？
    -- 数组和对象
Number 在JavaScript中的双精度浮点格式
String 双引号的反斜杠转义的Unicode
Boolean    true 或 false
Array  值的有序序列
Value  它可以是一个字符串，一个数字，真的还是假（true/false），空(null )等
Object 无序集合键值对
Whitespace 可以使用任何一对中的令牌
null   empty

76.json序列化时，默认遇到中文会转换成unicode，如果想要保留中文怎么办？
    -- json.dumps(jsonData,ensure_ascii=False);

77.什么是断言？应用场景？


78.有用过with statement吗？它的好处是什么？

79.使用代码实现查看列举目录下的所有文件。
import os
for i in os.listdir():
    print(i)

80.简述 yield和yield from关键字。
yield 的作用就是把一个函数变成一个生成器， 带有yield的函数不再是一个普通的函数。python解释器会将其视为一个generator