【python】面试基础知识点

【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、字符串格式化方式

1. 使用 % 操作符

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

1. 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

1. 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##程序员##后端#