python面试基础_Python面试基础整理

Python可变类型与不可变类型

不可变类型：数字、字符串、元组

可变类型：列表、字典、集合

浅拷贝和深拷贝

浅拷贝：新旧对象共享一块内存，拷贝父对象，不拷贝对象内部的子对象

深拷贝：为数据重新开辟一块空间，修改新对象不会改变原对象

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]]

Python字符串去重并排序

s='abcabcefefabczzx'

s=list(s) #转成列表

s=set(s) #去重

s=list(s) #转回列表

s.sort() #排序

s=''.join(s)#转回字符串

print(s) #输出:abcefxz

Python交换两个变量的值

a='abc'

b='cdf'

a,b=b,a

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

Python提取列表中的数字

s=[123,'a','b',234,2,5,'abc']

s=list(filter(lambda x:type(x)==int,s))

print(s)

pip是什么?

python包管理器/模块管理器

pip常用指令

pip list

pip install

pip uninstall

隔离环境的目的

为了让每个应用有独立的运行环境

pyhton中的注释

单行#注释，

多行```注释``，

"""注释"""

python2.x和python3.x的区别

编码

python2.x默认ASCII 要加# -*- coding：UTF-8

python3.x默认unicode

print

print加不加括号的区别

input

2.x input返回数值类型

raw_input返回字符串类型

3.x input返回字符串类型

range

2.x 返回列表

3.x 返回迭代器

多行语句用\隔开，或者()

为什么很多人说python弱类型？

声明不需要指定,表面弱类型,实际很严格

python中的数据类型

在python中常用的数据类型:数值 字符串 列表 元组 字典 集合

在python中有多少种数据类型:除了以上标准的,还有int long float bool等

type()返回的结果是什么?

如果只有第一个参数，返回对象的类型，如果有三个参数返回新的类型对象

isinstance() 与 type() 区别

type() 不认为子类是一种父类类型，不考虑继承关系

isinstance() 会认为子类是一种父类类型，考虑继承关系

int(1.4)和int('1.4')什么结果?

int(1.4)结果:1，int('1.4')报错

保留两位小数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)

bool类型

print(bool('False'))#True

print(bool(0))#False

print(bool([1,2]))#True

print(bool([]))#False

print(bool({}))#False

print(bool(None))#False

set类型

a={}

b=set()

c={1}

print(type(a))#

print(type(b))#

print(type(c))#

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长整型

哪些是可变类型,哪些是不可变类型,区别是什么

可变:列表,字典,集合

不可变:元组,字符串,数值

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)

s=r'\n' 字符串前加r与普通字符串几乎相同的语法

切片

第一个 s[0]

最后一个 s[-1]

2-4 s[1:4]

2-最后 s[a:]

步长2 s[1:10:2]

字符串反转 s[::-1]

内建函数

count()统计一个字符串出现的次数

find()检测字符串中是否包含子串,有返回索引值,否则返回-1

replace()替换

去空格

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+'**')

split()字符串拆分成数组

join()数组拼合并成字符串

s1='abc'

s2='123'

s3=['x','y','z']

print(s1.join(s2))

print(s1.join(s3))

判断

isdigit()判断是否是纯数字

isalpha()判断是否是纯字母

isalnum()判断是否是字母或数字

upper()转大写

s1='123'

s2='abc'

s3='abc123'

print(s1.isdigit())#True

print(s2.isalpha())#True

print(s3.isalnum())#True

列举常用的五个模块

os,re,math,datetime,urllib,request

dir()和help()

dir()不带参数时，返回当前范围内的变量、方法和定义的类型列表

dir()带参数时，返回参数的属性、方法列表

help()查看函数或模块用途的详细说明

取整

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

随机排序

import random

arr=[1,2,3]

random.shuffle(arr)

print(arr)

列表

count()判断是否存在

append()添加元素

extend()增加集合

insert()插入元素

remove()删除一个具体元素

del 删除一个具体元素

clear()清空

append+pop()栈

append+popleft队列

判断是否存在

s='abcd'

print(s.count('a'))#1找不到不会报错

print(s.index('a'))#0找不到会报错

print(s.find('a'))#0

print('a' in s)#True

列表

sort()

reverse()

内置函数

map

filter

reduce

sorted

列表推导式

取偶数

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]]

查看地址

arr=[1,2,3]

print(id(arr))

垃圾回收机制

小对象对象池

-5-256

数字字母下划线

长度不能大于20

import sys

print(sys.getrefcount(3))

a=3

print(sys.getrefcount(3))

b=3

print(sys.getrefcount(3))

大对象对象池

作用域内部才等

python中引用计数器如果是0,垃圾回收机制把它扫掉

垃圾回收

c、c++用户自己管理维护内存

java,c#垃圾回收机制

python的垃圾回收机制采用引用计数器

ruby:标记删除

优点:实时性 处理回收内存时间分摊到平时

缺点:维护引用计数器耗资源

垃圾回收机制工作:为新生的对象分配内存,识别垃圾,清理垃圾

字典的遍历

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

get()

goods={

"id":'001',

"price":20

}

print(goods.get('id'))#001

pop()

goods={

"id":'001',

"price":20

}

goods.pop('id')

print(goods)#{'price': 20}

字典的合并

goods={

"id":'001',

"price":20

}

goods2={

"num":9

}

goods.update(goods2)

print(goods)#{'id': '001', 'price': 20, 'num': 9}

字典字符串转换

import json

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

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

元组

一旦创建不可改变，但可以切片

arr=(1,2,3)

a,*b=arr

print(type(a))#

print(type(b))#

集合

不重复

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

交集、并集

intersection()

union()

合并并更新

update()

zip()迭代器

s=['a','b','c']

s2=[1,2,3]

s3=zip(s,s2)

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

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')]

迭代器

字符串/数组本身没有迭代对象，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

生成器

推导式写成()

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

可选参数、关键字参数

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'}

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)

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

查询和替换一个文本字符串

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

match()和search()的区别

match()从字符串的开始匹配，匹配不成功返回None

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

__new__() 与__init__()的区别

__new__作用于__init__()之前

__init__ 是实例级别的方法，通常用于初始化一个新实例。

__new__是类级别的方法，通常用于控制生成一个新实例的过程。

列举几种设计模式

工厂方法模式：定义一个创建对象接口，通过子类来创建对象。

单例模式：一个类仅有一个实例，例如框架中的数据库连接

闭包

内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用

def a(s):

def b(s):

print(s)

return b(s)

a('123')

回调

把函数作为参数传递给另一个函数

def a(s):

print(s)

def b(func):

func('123')

b(a)

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

装饰器的作用

在不改变函数本身的情况下，为函数增加新的功能

列举HTTP请求中的状态码

200 访问成功

302 重定向

404 请求的url不存在

500 服务器端错误

505 HTTP版本不受支持

Flask蓝图的作用

使不同的功能模块化

优化项目结构

增强可读性，易于维护

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))

import 和 from import的区别

import 导入整个模块，每次使用模块中的函数时需要确定是哪个模块

from import 创建 一个副本，导入模块中的函数，可以直接使用

Python解释器对模块位置的搜索顺序

当前主目录、PYTHONPATH下的每个目录、标准第三方链接库、.pth文件

静态方法和类方法的关键字

静态方法: @staticmethod

类方法:@classmethod

Python主要特点和优点

可解释

具有动态特性

面向对象

简明简单

开源

具有强大的社区支持

Python的自省

运行时能够获得对象的类型。

如：type() dir() getattr() hasattr() isinstance()

Python中的但双下划线

单下划线用处：解释器中、名称、i18n

单下划线前缀的名称：受保护的，仅能内部访问

双下划线前缀的名称：私有的，仅类对象自己能访问(子类也不能访问)

双下划线开头加结尾：Python系统自带的一些函数和方法