【python】面试基础知识点
1、解释型和编译型语言的区别
2、数据类型的常用方法
3、简述 Python 中的字符串编码
4、打印九九乘法表
5、面向对象中__new__ 和 __init__ 区别
6、实现二分法查找函数
7、字符串格式化方式
8、实现一个简单的 API
9、实现一个斐波那契数列
10、冒泡排序
11、快速排序
python基础测试100题
1、解释型和编译型语言的区别
编译型语言：把做好的源程序全部编译成二进制的可运行程序。然后，可直接运行这个程序。如：C，C++
解释型语言：把做好的源程序翻译一句，然后执行一句，直至结束！如：Python，
（Java 有些特殊，java程序也需要编译，但是没有直接编译称为机器语言，而是编译称为字节码，然后用解释方式执行字节码。）
2、数据类型的常用方法
一、format 格式化函数
str.format()函数是一种格式化字符串函数，此函数可以快速处理各种字符串。
它通过{}和:来代替%。
字符串类型格式化采用format()方法，基本使用格式是：
<模板字符串>.format(<逗号分隔的参数>)
调用format()方法后会返回一个新的字符串，参数从0 开始编号。
1、通过关键字
print('{name}在{option}'.format(name="谢某人"，option="写代码"))
结果：谢某人在写代码
2、通过位置
print('name={} path={}'.format('zhangsan', '/')
结果：name=zhangsan path=/
print('{1}在{0}'.format('写代码','谢某人'))
或
print('{0}在{1}'.format('谢某人','写代码'))
结果：谢某人在写代码
3、填充和对齐^<>分别表示居中、左对齐、右对齐，后面带宽度
print('{:^30}'.format("zhangsan")) # 居中
print('{:>30}'.format("zhangsan")) # 右对齐
print('{:<30}'.format("zhangsan")) # 左对齐
30：字段长度（最左到最右之间的长度）
4、精度控制 :.nf
print('{:.2f}'.format(3.14159))
结果：3.14
保留两位小数，两位后四舍五入
print('{:.5f}'.format(3.14))
结果：3.14000
保留5位小数，不足补0.
进制转化，b o d x 分别表示二、八、十、十六进制
print('{:b}'.format(20))
print('{:o}'.format(20))
print('{:d}'.format(20))
print('{:x}'.format(20))
结果：
10100
24
20
14
5、 千位分隔符：:,
print('{:,}'.format(100000000))
print('{:,}'.format(123456.123456))
结果：
100,000,000
123,456.123456
二、join函数
可以用来连接字符串，将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串。
list1 = ['1','2','3','4']
s = "-"
s = s.join(list1)
print(s)
输出：
1-2-3-4
用空字符连接
list1 = ['g','e','e','k', 's']
print("".join(list1))
输出：
geeks
三、replace函数
String.replace(old,new,count) 将字符串中的 old 字符替换为 New 字符，count 为替换的个数
mystr4 = ‘luobodazahui-haha’
print(mystr4.replace(‘haha’, ‘good’))
output
luobodazahui-good
四、split函数
切割字符串,得到一个列表。
mystr5 = ‘luobo,dazahui good’
以空格分割
print(mystr5.split())
以h分割
print(mystr5.split(‘h’))
以逗号分割
print(mystr5.split(’,’))
output
[‘luobo,dazahui’, ‘good’]
[‘luobo,daza’, ‘ui good’]
[‘luobo’, ‘dazahui good’]
列表：
切片
同字符串
append 和 extend
向列表中国添加元素
mylist1 = [1, 2]
mylist2 = [3, 4]
mylist3 = [1, 2]
mylist1.append(mylist2)
print(mylist1)
mylist3.extend(mylist2)
print(mylist3)
outout
[1, 2, [3, 4]]
[1, 2, 3, 4]
删除元素
del：根据下标进行删除
pop：删除最后一个元素
remove：根据元素的值进行删除
mylist4 = [‘a’, ‘b’, ‘c’, ‘d’]
del mylist4[0]
print(mylist4)
mylist4.pop()
print(mylist4)
mylist4.remove(‘c’)
print(mylist4)
output
[‘b’, ‘c’, ‘d’]
[‘b’, ‘c’]
[‘b’]
元素排序
sort：是将list按特定顺序重新排列，默认为由小到大，参数 reverse=True 可改为倒序，由大到小。
reverse：是将list逆置。
mylist5 = [1, 5, 2, 3, 4]
mylist5.sort()
print(mylist5)
mylist5.reverse()
print(mylist5)
output
[1, 2, 3, 4, 5]
[5, 4, 3, 2, 1]
字典：
清空字典
dict.clear()
dict1 = {‘key1’:1, ‘key2’:2}
dict1.clear()
print(dict1)
output
{}
指定删除
使用 pop 方法来指定删除字典中的某一项
dict1 = {‘key1’:1, ‘key2’:2}
d1 = dict1.pop(‘key1’)
print(d1)
print(dict1)
output
1
{‘key2’: 2}
遍历字典
dict2 = {‘key1’:1, ‘key2’:2}
mykey = [key for key in dict2]
print(mykey)
myvalue = [value for value in dict2.values()]
print(myvalue)
key_value = [(k, v) for k, v in dict2.items() ]
print(key_value)
output
[‘key1’, ‘key2’]
[1, 2]
[(‘key1’, 1), (‘key2’, 2)]
4. fromkeys
用于创建一个新字典，以序列中元素做字典的键，value 为字典所有键对应的初始值
keys = [‘zhangfei’, ‘guanyu’, ‘liubei’, ‘zhaoyun’]
dict.fromkeys(keys, 0)
output
{‘zhangfei’: 0, ‘guanyu’: 0, ‘liubei’: 0, ‘zhaoyun’: 0}
3、简述 Python 中的字符串编码
计算机在最初的设计中，采用了8个比特（bit）作为一个字节（byte）的方式。一个字节能表示的最大的整数就是255（二进制11111111=十进制255），如果要表示更大的整数，就必须用更多的字节。
最早，计算机只有 ASCII 编码，即只包含大小写英文字母、数字和一些符号，这些对于其他语言，如中文，日文显然是不够用的。后来又发明了Unicode，Unicode把所有语言都统一到一套编码里，这样就不会再有乱码问题了。当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。UTF-8 是隶属于 Unicode 的可变长的编码方式。
在 Python 中，以 Unicode 方式编码的字符串，可以使用 encode() 方法来编码成指定的 bytes，也可以通过 decode() 方法来把 bytes 编码成字符串。
4、打印九九乘法表
for i in range(1,10):
for j in range(1,i+1):
print("%s*%s = %s"%(i,j,i*j),end="; ")
print()
5、面向对象中__new__ 和 init 区别__new__是在实例创建之前被调用的，因为它的任务就是创建实例然后返回该实例对象，是个静态方法。
__init__是当实例对象创建完成后被调用的，然后设置对象属性的一些初始值，通常用在初始化一个类实例的时候。是一个实例方法。
1、__new__至少要有一个参数 cls，代表当前类，此参数在实例化时由 Python 解释器自动识别。
2、__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以 return 父类（通过 super(当前类名, cls)）__new__出来的实例，或者直接是 object 的__new__出来的实例。
3、__init__有一个参数 self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值。
4、如果__new__创建的是当前类的实例，会自动调用__init__函数，通过 return 语句里面调用的__new__函数的第一个参数是 cls 来保证是当前类实例，如果是其他类的类名，；那么实际创建返回的就是其他类的实例，其实就不会调用当前类的__init__函数，也不会调用其他类的__init__函数
6、实现二分法查找函数
二分查找要求对象必须有序，其基本原理如下：
1.从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；
2.如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。
3.如果在某一步骤数组为空，则代表找不到。
# 二分法查找
# 从列表test = [1,5,8,16,24,48,59,80]
def erfen(list_number,n):
begin = 0;
end = len(list_number)-1;
while begin <= end:
mid = (begin + end)//2;
if n > list_number[mid]:
begin = mid + 1;
else:
if n < list_number[mid]:
end = mid -1;
else:
print("第%s个数:"% (mid+1));
break;
test = [1,5,8,16,24,48,59,80,90];
print("总数列为：",test);
a = int(input("请输入查找的数："));
erfen(test,a);
7、字符串格式化方式
- 使用 % 操作符
print("This is for %s" % "Python")
print("This is for %s, and %s" %("Python", "You"))
output
This is for Python
This is for Python, and You
- str.format
在 Python3 中，引入了这个新的字符串格式化方法。
print("This is my {}".format("chat"))
print("This is {name}, hope you can {do}".format(name="zhouluob", do="like"))
output
This is my chat
This is zhouluob, hope you can like
- f-strings
在 Python3-6 中，引入了这个新的字符串格式化方法。
name = "luobodazahui"
print(f"hello {name}")
output
hello luobodazahui
#一个复杂些的例子：
def mytest(name, age):
return f"hello {name}, you are {age} years old!"
people = mytest("luobo", 20)
print(people)
output
hello luobo, you are 20 years old!
8、实现一个简单的 API
使用 flask 构造 web 服务器
from flask import Flask, request
app = Flask(__name__)
@app.route('/', methods=['POST'])
def simple_api():
result = request.get_json()
return result
if __name__ == "__main__":
app.run()
9、实现一个斐波那契数列 斐波那契数列:又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……
在数学上，斐波纳契数列以如下被以递归的方法定义：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=2，n∈N*）
a,b = 1,1
lst = [1]
n = int(input("请输入第n个数："))
for i in range(n-1):
lst.append(b)
a,b = b,a+b #关键在这句
print("第%s个数为:%s"%(n,a))
print(lst)
def fpnq(n):
i = 3;
j = 1;
b = 1;
# a = 2;
if n == 0:
print("cuowu");
elif n == 1:
print("1");
elif n == 2:
print("1,1")
else:
while(i <= n):
if i ==3:
print("1,1",end=',')
j,b = b,j+b;
# a = j + b;
# j = b;
# b = a;
print(b, end=',');
i = i + 1;
fpnq(10);
10、冒泡排序
# 冒泡排序 arr = [9,7, 4, 3, 67, 34, 1, 8,42]
arr = [9,7, 4, 3, 67, 34, 1, 8,42];
print("排序前的数列：",arr);
def maopao(arr):
n = len(arr);
for i in range(0,n-1):
for j in range(0,n-1-i):
if arr[j] > arr[j+1]:
arr[j],arr[j+1] = arr[j+1],arr[j];
maopao(arr);
print("排序后的数列：",arr);
11、快速排序
快排的思想：首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序，之后再递归排序两边的数据。
挑选基准值：从数列中挑出一个元素，称为"基准"（pivot）;
分割：重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（与基准值相等的数可以到任何一边）。在这个分割结束之后，对基准值的排序就已经完成;
递归排序子序列：递归地将小于基准值元素的子序列和大于基准值元素的子序列排序。
list1 = [9, 7, 4, 3, 67, 34, 1, 8, 42]; def partition(arr, low, high): i = (low - 1) # 最小元素索引 pivot = arr[high] for j in range(low, high): # 当前元素小于或等于 pivot if arr[j] <= pivot: i = i + 1 arr[i], arr[j] = arr[j], arr[i] arr[i + 1], arr[high] = arr[high], arr[i + 1] return (i + 1) def quicksort(arr, low, high): if low < high: pi = partition(arr, low, high) quicksort(arr, low, pi - 1) quicksort(arr, pi + 1, high) quicksort(list1, 0, len(list1) - 1) print(list1)
#面试##Python##程序员##后端#
类似资料：