Python面试基础整理

1. Python可变类型与不可变类型
   不可变类型：数字、字符串、元组
   可变类型：列表、字典、集合
2. 浅拷贝和深拷贝
   浅拷贝：新旧对象共享一块内存，拷贝父对象，不拷贝对象内部的子对象
   深拷贝：为数据重新开辟一块空间，修改新对象不会改变原对象

import copy
#浅拷贝
arr=[1,2,3,[4,5,6]]
arr2=arr.copy()
arr2[0]=10
arr2[3][0]=40
print(arr)#[1, 2, 3, [40, 5, 6]]
print(arr2)#[10, 2, 3, [40, 5, 6]]
    
arr=[1,2,3,[4,5,6]]
arr3=arr[:]
arr3[0]=10
arr3[3][0]=40
print(arr)#[1, 2, 3, [40, 5, 6]]
print(arr3)#[10, 2, 3, [40, 5, 6]]
    
arr=[1,2,3,[4,5,6]]
arr4=copy.copy(arr)
arr4[0]=10
arr4[3][0]=40
print(arr)#[1, 2, 3, [40, 5, 6]]
print(arr4)#[10, 2, 3, [40, 5, 6]]
    
#深拷贝
arr=[1,2,3,[4,5,6]]
arr5=copy.deepcopy(arr)
arr5[0]=10
arr5[3][0]=40
print(arr)#[1, 2, 3, [4, 5, 6]]
print(arr5)#[10, 2, 3, [40, 5, 6]]

3. Python字符串去重并排序

s='abcabcefefabczzx'
s=list(s)   #转成列表
s=set(s)    #去重
s=list(s)   #转回列表
s.sort()    #排序
s=''.join(s)#转回字符串
print(s)    #输出:abcefxz

4. Python交换两个变量的值

a='abc'
b='cdf'
a,b=b,a
print(a,b) #输出:cdf abc

5. Python提取列表中的数字

s=[123,'a','b',234,2,5,'abc']
s=list(filter(lambda x:type(x)==int,s))
print(s)

6. pip是什么?
   python包管理器/模块管理器
7. pip常用指令
   pip list
   pip install
   pip uninstall
8. 隔离环境的目的
   为了让每个应用有独立的运行环境
9. pyhton中的注释
   单行#注释，
   多行```注释``，
   """注释"""
10. python2.x和python3.x的区别
    1. 编码
       python2.x默认ASCII 要加# -*- coding：UTF-8
       python3.x默认unicode
    2. print
       print加不加括号的区别
    3. input
       2.x input返回数值类型
       raw_input返回字符串类型
       3.x input返回字符串类型
    4. range
       2.x 返回列表
       3.x 返回迭代器
11. 多行语句用\隔开，或者()
12. 为什么很多人说python弱类型？
    声明不需要指定,表面弱类型,实际很严格
13. python中的数据类型
    在python中常用的数据类型:数值 字符串 列表 元组 字典 集合
    在python中有多少种数据类型:除了以上标准的,还有int long float bool等
14. type()返回的结果是什么?
    如果只有第一个参数，返回对象的类型，如果有三个参数返回新的类型对象
15. isinstance() 与 type() 区别
    type() 不认为子类是一种父类类型，不考虑继承关系
    isinstance() 会认为子类是一种父类类型，考虑继承关系
16. int(1.4)和int('1.4')什么结果?
    int(1.4)结果:1，int('1.4')报错
17. 保留两位小数round(m,2),a=3.1415926保留两位小数

a=3.175
print('%.2f'%a)
b=round(a,2)#四舍五入,小数点后奇数+5不进1，偶数+5进1
print(b)

def num2(n):
    arr = str(n).split('.')
    point = arr[1][0:2]
    num = arr[0] + '.' + point
    return num
    a=num2(1.12212)
    print(a)

18. bool类型

print(bool('False'))#True
print(bool(0))#False
print(bool([1,2]))#True
print(bool([]))#False
print(bool({}))#False
print(bool(None))#False

19. set类型

a={}
b=set()
c={1}
print(type(a))#
print(type(b))#
print(type(c))#

20. repr(x)的区别str(x)
    数值、列表、字典输出相同
    repr(x)便于编译理解,转成表达式字符串
    str(x)便于程序员理解,转成字符串

a='hello\n'
print(str(a))   #hello+换行
print(repr(a))  #'hello\n'
a='1000L'
print(str(a))   #1000L
print(repr(a))  #'1000L'
#1000L长整型

21. 哪些是可变类型,哪些是不可变类型,区别是什么
    可变:列表,字典,集合
    不可变:元组,字符串,数值

arr=[1,2,3,4]
s='abcd'
arr[1]=20
print(arr) #[1, 20, 3, 4]
s[1]='d'   #TypeError: 'str' object does not support item assignment
print(arr)

22. s=r'\n' 字符串前加r与普通字符串几乎相同的语法
23. 切片
    1. 第一个 s[0]
    2. 最后一个 s[-1]
    3. 2-4 s[1:4]
    4. 2-最后 s[a:]
    5. 步长2 s[1:10:2]
    6. 字符串反转 s[::-1]
24. 内建函数
    1. count()统计一个字符串出现的次数
    2. find()检测字符串中是否包含子串,有返回索引值,否则返回-1
    3. replace()替换
25. 去空格

s='  abc def   '
print('**'+s.lstrip()+'**')#**abc def   **
print('**'+s.rstrip()+'**')#**  abc def**
print('**'+s.strip()+'**')#**abc def**
print('**'+s.replace(' ','')+'**')#**abcdef**

import re
s='  abc def   '
s=re.sub(r'\s','',s)
print('**'+s+'**')

26. split()字符串拆分成数组
27. join()数组拼合并成字符串

s1='abc'
s2='123'
s3=['x','y','z']
print(s1.join(s2))
print(s1.join(s3))

28. 判断
    1. isdigit()判断是否是纯数字
    2. isalpha()判断是否是纯字母
    3. isalnum()判断是否是字母或数字
    4. upper()转大写

s1='123'
s2='abc'
s3='abc123'
print(s1.isdigit())#True
print(s2.isalpha())#True
print(s3.isalnum())#True

29. 列举常用的五个模块
    os,re,math,datetime,urllib,request
30. dir()和help()
    dir()不带参数时，返回当前范围内的变量、方法和定义的类型列表
    dir()带参数时，返回参数的属性、方法列表
    help()查看函数或模块用途的详细说明
31. 取整
    floor()向下取整
    ceil()向上取整
    trunc()截断小数位

import math
a=1.345
b=-1.567
print(int(a))#1
print(math.floor(a))#1
print(math.ceil(a))#2
print(int(b))#-1
print(math.floor(b))#-2
print(math.ceil(b))#-1
print(math.trunc(a))#1

32. 随机排序

import random
arr=[1,2,3]
random.shuffle(arr)
print(arr)

33. 列表
    count()判断是否存在
    append()添加元素
    extend()增加集合
    insert()插入元素
    remove()删除一个具体元素
    del 删除一个具体元素
    clear()清空
    append+pop()栈
    append+popleft队列
34. 判断是否存在

s='abcd'
print(s.count('a'))#1找不到不会报错
print(s.index('a'))#0找不到会报错
print(s.find('a'))#0
print('a' in s)#True

35. 列表
    sort()
    reverse()
36. 内置函数
    map
    filter
    reduce
    sorted
37. 列表推导式
    取偶数

arr = [1, 2, 6, 3, 1]
arr2 = [i for i in arr if i % 2 == 0]
print(arr2)

二维转一维

arr=[[1,2,3],[4,5,6],[7,8,9]]
arr2=[]
for i in arr:
    for j in i:
        arr2.append(j)
print(arr2)

arr=[[1,2,3],[4,5,6],[7,8,9]]
arr2=[i for j in arr for i in j]
print(arr2)#[1, 2, 3, 4, 5, 6, 7, 8, 9]

按列取

arr=[[1,2,3],[4,5,6],[7,8,9]]
arr2=[[e[i] for e in arr] for i in range(len(arr))]
print(arr2)#[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

38. 查看地址

arr=[1,2,3]
print(id(arr))

39. 垃圾回收机制
    1. 小对象对象池
       • -5-256
       • 数字字母下划线
       • 长度不能大于20

       import sys
       print(sys.getrefcount(3))
       a=3
       print(sys.getrefcount(3))
       b=3
       print(sys.getrefcount(3))
       

    2. 大对象对象池
       • 作用域内部才等
       • python中引用计数器如果是0,垃圾回收机制把它扫掉
40. 垃圾回收
    c、c++用户自己管理维护内存
    java,c#垃圾回收机制
    python的垃圾回收机制采用引用计数器
    ruby:标记删除
    优点:实时性 处理回收内存时间分摊到平时
    缺点:维护引用计数器耗资源
    垃圾回收机制工作:为新生的对象分配内存,识别垃圾,清理垃圾
41. 字典的遍历

    goods={
    "id":'001',
    "price":20
}
for i in goods:
    print(i)
    #id
    #price
for k,v in goods.items():
    print(k,v)
    # id 001
    #price 20
for k in goods.keys():
    print(k)
    #id
    #price
for v in goods.values():
    print(v)
    #001
    #20

42. get()

goods={
    "id":'001',
    "price":20
}
print(goods.get('id'))#001

43. pop()

goods={
    "id":'001',
    "price":20
}
goods.pop('id')
print(goods)#{'price': 20}

44. 字典的合并

goods={
    "id":'001',
    "price":20
}
goods2={
    "num":9
}
goods.update(goods2)
print(goods)#{'id': '001', 'price': 20, 'num': 9}

45. 字典字符串转换

import json
json.dumps(dict)#字典->字符串
json.loads(str)#字符串->字典

46. 元组
    一旦创建不可改变，但可以切片

arr=(1,2,3)
a,*b=arr
print(type(a))#
print(type(b))#

47. 集合
    不重复

s={1,2,3,3,3,3,3}
print(s)#{1, 2, 3}

添加add()

s={1,2,3}
s.add(4)
print(s)#{1, 2, 3, 4}

移除discard()、remove()、pop()

s={1,2,3}
s.discard(2)
print(s)#{1, 3}
s.discard(4)#移除不存在的元素不会报错

s={1,2,3}
s.remove(2)
print(s)#{1, 3}
s.remove(4)#KeyError: 4

48. 交集、并集
    intersection()
    union()
49. 合并并更新
    update()
50. zip()迭代器

s=['a','b','c']
s2=[1,2,3]
s3=zip(s,s2)
print(list(s3))#[('a', 1), ('b', 2), ('c', 3)]

51. enumerate()

s=['a','b','c']
for (index,item) in enumerate(s):
    print(index,item)
#0 a
#1 b
#2 c
print(list(enumerate(s)))#[(0, 'a'), (1, 'b'), (2, 'c')]

52. 迭代器
    字符串/数组本身没有迭代对象，for循环自动加上迭代器

s='hi cat'
i=iter(s)
print(i.__next__())#h
print(i.__next__())#i
print(i.__next__())#
print(i.__next__())#c
print(i.__next__())#a
print(i.__next__())#t

53. 生成器

• 推导式写成()
• yield

L=[x*x for x in range(10)]
G=(x*x for x in range(10))
print(L[-1])#81
while True:
    try:
        print(G.__next__())
    except StopIteration:
        break

54. 可选参数、关键字参数

def add(a,b=2,*c):
    print(c)
add(1,2,[5,6,7])#([5, 6, 7],)
add(1,2,*[5,6,7])#(5, 6, 7)

def add(a,b=2,*c,**d):
    print(c,d)
add(1,2,*[5,6,7],id='001')#(5, 6, 7) {'id': '001'}
add(1,2,*[5,6,7],**{'id':'001','price':'95'})#(5, 6, 7) {'id': '001', 'price': '95'}

55. lambda

s=[1,2,3,4]
def add(i):
    return i+2
s2=map(add,s)
print(list(s2))#[3, 4, 5, 6]

s2=map(lambda i:i+2,s)
print(list(s2))#[3, 4, 5, 6]

from functools import reduce
s=[1,2,3,4]
s2=reduce(lambda x,y:x*y,list(range(1,6)))
print(s2)

56. Python中global和nonlocal的区别
    global:在函数或其他局部作用域中使用全局变量
    nonlocal:在函数或其他作用域中使用外层(非全局)变量

a=1
def add(x):
    global a
    a=a+1
    global c#局部变量全局化
    c=2
    return x+a
print(add(2))#4
print(c)#2

a=1
def add(x):
    a=2
    def sub():
        global a
        a=a+x
        return a
    return sub()
print(add(200))#201

a=1
def add(x):
    a=2
    def sub():
        nonlocal a
        a=a+x
        return a
    return sub()
print(add(200))#202

57. 查询和替换一个文本字符串
    replace(替换成的字符串,要被替换的字符串,最多替换次数)

a = 'aaabbbccc'
b = a.replace('b','d',3)
print(b) #aaadddccc

re.sub(正则表达式,替换成的字符串,原字符串,替换次数)

import re
s1 = 'aaabbbccc'
print(re.sub(r'b','d',s1,count=1)) #输出:aaadbbccc
#或者
import re
s2 = 'aaabbbccc'
reg = re.compile(r'b')
print(reg.sub('d',s2,count=4))#输出:aaadddccc

58. match()和search()的区别

• match()从字符串的开始匹配，匹配不成功返回None
• search()在字符串内匹配，只找到第一个匹配并返回，匹配不成功返回None

59. __new__() 与__init__()的区别
    __new__作用于__init__()之前
    __init__ 是实例级别的方法，通常用于初始化一个新实例。
    __new__是类级别的方法，通常用于控制生成一个新实例的过程。
60. 列举几种设计模式
    工厂方法模式：定义一个创建对象接口，通过子类来创建对象。
    单例模式：一个类仅有一个实例，例如框架中的数据库连接
61. 闭包
    内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用

def a(s):
    def b(s):
        print(s)
    return b(s)
a('123')

62. 回调
    把函数作为参数传递给另一个函数

def a(s):
    print(s)
def b(func):
    func('123')
b(a)

63. Python字符串的编码与解码
    decode将其他编码转unicode编码
    encode将unicode编码转其他编码

s1='abc'
s2=s1.encode('utf-8') #utf-8编码转unicode编码
print(s2) #输出:b'abc'
s1=s2.decode('utf-8') #unicode编码转utf-8编码
print(s1)#输出:abc

64. 装饰器的作用
    在不改变函数本身的情况下，为函数增加新的功能
65. 列举HTTP请求中的状态码
    200 访问成功
    302 重定向
    404 请求的url不存在
    500 服务器端错误
    505 HTTP版本不受支持
66. Flask蓝图的作用
    使不同的功能模块化
    优化项目结构
    增强可读性，易于维护
67. Python生成随机数

• Python生成随机数
  random.randrange(起始位置,结束位置,步长)

import random
print(random.randrange(10))
print(random.randrange(100,200))
print(random.randrange(300,400,50))

• 在一个范围内,生成不重复的随机数
  s=random.sample(范围,生成数量)

import random
print(random.sample(range(0,5),3))
print(random.sample([1,2,3,4,5],3))

68. import 和 from import的区别
    import 导入整个模块，每次使用模块中的函数时需要确定是哪个模块
    from import 创建 一个副本，导入模块中的函数，可以直接使用
69. Python解释器对模块位置的搜索顺序
    当前主目录、PYTHONPATH下的每个目录、标准第三方链接库、.pth文件
70. 静态方法和类方法的关键字
    静态方法: @staticmethod
    类方法:@classmethod
71. Python主要特点和优点
    可解释
    具有动态特性
    面向对象
    简明简单
    开源
    具有强大的社区支持
72. Python的自省
    运行时能够获得对象的类型。
    如：type() dir() getattr() hasattr() isinstance()
73. Python中的但双下划线
    单下划线用处：解释器中、名称、i18n
    单下划线前缀的名称：受保护的，仅能内部访问
    双下划线前缀的名称：私有的，仅类对象自己能访问（子类也不能访问）
    双下划线开头加结尾：Python系统自带的一些函数和方法