2020年Python最新面试题：Python基础

1. 什么是 Python?使用 Python 有什么好处?

计算机编程语言的种类就如同世界上的语言一样多，例如 Python、R、C、C++、C#、Java、JavaScript、Go、SHELL、PHP 和 MATLAB等，其中，Python 是一种解释型、面向对象、动态数据类型的高级程序设计语言。Python 在编写时无须定义变量类型，在运行时变量类型强制固定，属于强类型语言。Python 无须编译,可以在解释器环境直接运行。

Python 这门编程语言，由 Guido van Rossum 于1989年底发明，第一个公开发行版发布于 1991 年，Python 源代码遵循 GPL(GNU General Public License) 协议。Python 有对象、模块、线程、进程、异常处理和自动内存管理等，Python 语言简洁、方便、易扩展，而且有许多自带的模块且开源，Python 可应用于多平台，包括 Windows、Linux 和 Mac操作系统等。总体来说，Python 有如下几个特点：

1. Python 是一种解释型语言，因此，Python 代码在运行之前不需要编译。
2. Python 是动态类型语言，在声明变量时，不需要指定变量的类型。
3. Python 适合面向对象的编程，因为它支持通过组合与继承的方式定义类。
4. 编写 Python 代码比较容易，但是运行速度比编译语言通常要慢。
5. Python 用途广泛，常被用作 胶水语言，可帮助其他语言和组件改善运行状况。
6. 程序员使用 Python 可以专注于算法和数据结构的设计，而不用处理底层的细节。

2. Python中常用的关键字有哪些?

Python 关键字不能把它们用作任何标识符名称，关键字是区分大小写的。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字，如下所示：

3. Python 2.x和Python 3.x版本有哪些主要的区别?

Python 的3.x 版本相对于 Python 的早期版本，是一次较大的升级。为了不给系统带入过多的负担， Python 3.x 在设计时没有考虑向下兼容，即 Python3.x 和 Python2.x 是不兼容的。许多针对早期 Python 版本设计的程序都无法在 Python 3.x 上正常执行。为了照顾现有的程序，Python 2.6 作为一个过渡版本， 基本使用了 Python 2.x 的语法和库，同时也考虑了向 Python 3.x 的迁移，支持部分 Python3.x 的语法与函数。

目前最新的 Python 程序建议使用 Python 3.x 版本的语法。Python 3.x 的变化主要体现在以下几个方面：

(1) print 函数

在 Python 3.x中，print 语句没有了，取而代之的是 print 函数。在 Python 2.6 和 Python 2.7里，以下三种形式是等价的：

(2) Unicode

Python 2.x 默认使用 ASCII 编码，所以 Python 2.x 默认是不支持中文的，且变量命名只能用英文。Python 3.x 默认使用 UTF-8 的编码，所以 Python 3.x 默认是支持中文的，且变量命名能够使用中文。如果在 Python 文件中不指定头信息 # -*-coding:utf-8-*-.，那么在 Python 2.x 中默认使用 ASCII 编码，在 Python 3.x中默认使用 UTF-8 编码。由于 Python 3.x源码文件默认使用 UTF-8 编码，这就使得以下代码是合法的：

Python 2.x：

Python 3.x：

(3) 除法运算

Python中的除法与其他语言相比显得非常高端，它有一套很复杂的规则。Python 中的除法有两个运算符：/和//。在Python 2.x中，对于/算法，整数相除的结果是一个整数，它会把小数部分完全忽略掉，浮点数除法会保留小数点的部分，得到一个浮点数的结果。在Python 3.x中，/除法不再这么做了，整数相除的结果也会是浮点数。

而对于 // 除法，这种除法被称为 floor 除法，它会对除法的结果自动进行一个 floor 操作，在 Python 2.x 和 Python 3.x 中是一致的。

需要注意的是，// 并不是舍弃小数部分，而是执行 floor 操作。如果要截取整数部分，那么需要使用 math 模块的 trunc 函数。

(4) 八进制字面量表示

在 Python 3.x 中，表示八进制字面量的方式只有一种，那就是 0o1000，而 Python 2.x 中的 01000 形式已经不能使用了。

(5) 不等运算符

在 Python 2.x 中，不等于 可以有两种写法，分别是 != 和 <> 在 Python 3.x 中去掉了 <> 只有 != 一种写法。

(6) 去掉了 repr 表达式 ``

在 Python 2.x 中反引号相当于 repr 函数 (返回一个对象的 string 格式) 的作用。在 Python 3.x 中去掉了 ``这种写法，只允许使用 repr 函数，这样做的目的是为了使代码看上去更清晰。

(7) 打开文件

在 Python 2.x 中使用 file(…) 或者 open(…) ，而在 Python 3.x 中只能使用 open(…)

(8) 数据类型

Python 3.x 去除了 long 类型，现在只有一种整型 int，但它的行为与 2.x 版本的 long 相同。还新增了 bytes 类型，对应于 2.x 版本的八位串，定义一个 bytes 字面量的方法如下：

str 对象和 bytes 对象可以使用 .encode() 和 .decode() 方法相互转化。

(9) input 和 raw_input 函数

在 Python 2.x 中，raw_input 会将所有输入的数据当作字符串看待，返回值为字符串类型。而 input 输入时必须是一个合法的 Python 表达式，格式与 Python 中的代码一样，其返回值与输入的数据类型相同。如果是 Python 2.x 版本，那么 input 和 raw_input 都可以使用。如果是 Python 3.x 版本，那么只能使用 input。因此，建议都使用 input 函数。

(10) map、filter 和 reduce

在 Python2.x 的交互模式下输入map和filter，可以看到它们两者的类型是 built-in function(内置函数)

它们输出的结果类型都是列表：

但是在 Python3.x 中发生了变化：

首先它们从函数变成了类，其次，它们的返回结果也从列表变成了一个可迭代的对象，可以尝试使用 next 函数来进行手工迭代：

对于比较高端的 reduce 函数，它在 Python3.x中已经不属于 built-in function，而是被挪到了 functools 模块当中。

(11) xrange函数

xrange 可以生成序列。在 Python3.x 中取消了 xrange 函数，而使用 range 完全代替了 xrange 函数。在 Python 3.x 中调用 xrange 函数会报错。

在 Python2.x 中 xrange() 函数用法与 range() 函数完全相同，所不同的是生成的不是一个列表，而是一个生成器。

4. Python 中有哪些常见的运算符?

Python 语言支持的运算符包括算术运算符、比较(关系)运算符、赋值运算符、位运算符、逻辑运算符、成员运算符和身份运算符。

(1) Python 算术运算符

假设变量 a 为 10，变量 b 为21，各种算术运算符的功能如下表所示：

(2) Python 比较运算符

以下假设变量 a 为 10，变量 b 为20：

运算符	描述	实例
==	等于，比较对象是否相等	(a==b)返回False
!=	不等于，比较对象是否不相等	(a!=b)返回True
>	大于，返回 a 是否大于b	(a>b)返回False
<	小于，返回 a 是否小于b。	(a<b)返回True
>=	大于等于，返回 a 是否大于等于 b	(a>=b)返回False
<=	小于等于，返回 a 是否小于等于 b	(a<=b)返回True

所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量 True 和 False 等价。注意：这些变量名的大写与小写含义不一样，要区分。

(3) Python 赋值运算符

以下假设变量 a 为 10，变量 b 为 20：

运算符	描述	实例
=	简单的赋值运算符	c=a+b 将 a+b 的运算结果赋值为c
+=	加法赋值运算符	c+=a 等效于 c=c+a
-=	减法赋值运算符	c-=a 等效于 c=c-a
*=	乘法赋值运算符	c*=a 等效于 c=c*a
/=	除法赋值运算符	c/=a 等效于 c=c/a
%=	取模赋值运算符	c%=a 等效于 c=c%a
**=	幂赋值运算符	c**=a 等效于 c=c**a
//=	取整除赋值运算符	c//=a 等效于 c=c//a

(4) Python 位运算符

按位运算符是把数字看作二进制来进行计算的。Python 中的按位运算法则如下：

下表中变量 a 为 60、b 为 13，二进制格式如下：

a = 0011 1100
b = 0000 1101
---------------------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011

(5) Python 逻辑运算符

Python 语言支持逻辑运算符，以下假设变量 a 为 10，b 为 20：

优先级： not>and>or
对于 a or b 来说，如果 a 为真，那么值为 a，否则为b；对于 a and b 来说，如果 a 为真，那么值为 b，否则为 a。例如：

(6) Python 成员运算符

除了以上的一些运算符之外，Python 还支持成员运算符 in 和 not in

(7) Python 身份运算符

身份运算符用于比较两个对象的存储单元。

5. 运算符 is 与 == 有什么区别?

Python 中的对象包含三要素：id、type、value。其中，id 用来唯一标识一个对象，type 标识对象的类型，value 是对象的值。

is 判断 a 对象是否就是 b 对象，用于判断两个变量引用对象是否为同一个，是通过 id 来判断的。 == 判断 a 对象的值是否和 b 对象的值相等，是通过 value 来判断的。例如：

6. Python 都有哪些自带的数据类型? 可变类型和不可变类型分别包括哪些?

Python 自带的数据类型分为可变和不可变的类型。

可变数据类型 表示允许变量的值发生变化，如果改变了该数据类型的对应变量的值，那么不会重新分配内存空间。即如果对变量进行 append 或 += 等操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的内存地址也不会变化。对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于相同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。可变的数据类型包括：列表（list)、集合（set）和 字典（dic）。

不可变数据类型 表示不允许变量的值发生变化，如果改变了该数据类型的对应变量的值，那么将重新分配内存空间，相当于是新建了一个对象，不可变数据类型包括：字符串(str)、元组(tuple)和数值(number)。

对于内存中相同的值的对象，在内存中则只有一个对象，内部会有一个引用计数来记录有多少个变量引用这个对象。不可变数据类型对应变量的值更改后其内存地址会发生改变，可变数据类型对应变量的值更改后其内存地址不会发生改变。以下通过实验演示可变和不可变数据类型。

(1) 整型

可以发现，当数据发生改变后，变量的内存地址发生了改变，那么整型就是不可变数据类型。

(2) 字符串

可以发现，当数据发生改变后，变量的内存地址发生了改变，那么字符串就是不可变数据类型。

(3) 元组

可以在元组的元素中存放一个列表，通过更改列表的值来查看元组是属于可变还是不可变。

可以发现，虽然元组数据发生改变，但是内存地址没有发生改变，但是不可以以此来判定元组就是可变数据类型。修改了元组中列表的值，但是因为列表是可变数据类型，所以虽然在列表中更改了值，但是列表的地址没有改变，列表在元组中的地址的值没有改变，所以也就意味着元组没有发生变化。因此，可以认为元组是不可变数据类型。

(4) 集合

集合常用来进行去重和关系运算，集合是无序的。使用大括号或set()函数可以创建集合。需要注意的是，如果想要创建空集合，那么必须使用set()而不是{}，后者用于创建空字典。大括号也不可以创建元素含有字典与列表的集合。

可以发现，虽然集合数据发生改变，但是内存地址没有改变，由此可见集合是可变数据类型。

(5) 列表

列表是 Python 中的基础数据类型之一，其他语言中也有类似于列表的数据类型，例如 js 中叫数组，它是以[]括起来的，每个元素以逗号隔开，里面可以存放各种数据类型。

可以发现，虽然列表数据发生改变，但是内存地址没有改变，由此可见列表也是可变数据类型。

(6) 字典

字典是 Python 中唯一的映射类型，采用键值对(key-value) 的形式存储数据。Python 对 key 通过哈希函数运算，根据计算的结果决定 value 的存储地址，所以字典是无序存储的。但是在 Python3.6 版本后，字典开始是有序的，这是新的版本特征。字典的 key 值可以是整型、字符串或元组等不可变对象，但不能是列表、集合、字典等可变对象。

可以发现，虽然字典数据发生改变，但是内存地址没有改变，由此可见字典也是可变数据类型。

7. 列表、元组、集合、字典的区别有哪些?

列表 (list)：是长度可变有序的数据存储容器，可以通过下标索引取到相应的数据。
元组（tuple)：固定长度不可变的顺序容器，访问效率高，适合存储一些常量数据，可以作为字典的键使用。
集合（set)：无序，元素只出现一次，可以自动去重。
字典（dict)：长度可变的 hash 字典容器。存储的方式为键值对，可以通过相应的键获取相应的值，key 支持多种类型。key 必须是不可变类型且唯一。它们的详细区别如下表所示：

8. 列表和元组的区别有哪些?

序列是 Python 中最基本的数据结构。序列中的每个元素都分配一个数字索引，第一个元素的索引是0，第二个元素的索引是1，依此类推。Python 有 6 个序列的内置类型，但最常见的是列表和元组。

数组在 Python 中被叫作列表，列表和元组是 Python 中重要的内建的序列，列表和元组都具有索引、分片等操作。一般来说，列表是可以替代元组的。但是，为了限制某些元素，就会用元组。列表和元组主要有如下区别：

1. 列表是可以修改的，而元组却不能修改。如果要增添和删除元素，只能用列表。元组被称为只读列表，即数据可以被查询，但不能被修改。若元组一旦被定义，则其长度和内容都是固定的，不能被修改，即不能对元组进行更新、增加和删除的操作。
2. 列表用 [] 表示，元组用 () 表示。
3. 列表不能作为字典的 key，而元组可以。
4. 如果元组中仅有一个元素，那么需要在元素后加上逗号。

9. Python 中有哪些常见的数据类型转换函数?

Python 提供了将变量或值从一种类型转换成另一种类型的内置函数，内置函数封装了各种转换函数，可以使用目标类型关键字强制类型转换，例如，int 函数能够将符合数学格式数字型字符串转换成整数。常见的类型转换函数如下所示：

函数	描述
int(x[,base])	将 x 转换为一个整数
float(x)	将 x 转换到一个浮点数
complex(real[,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效 Python 表达式，并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典，d 必须是一个序列(key,value) 元组
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

10. 列表、元组、集合及字典之间如何相互转换?

# -*- coding: UTF-8 -*-
"""
@author:AmoXiang
@file:2.列表、元组、集合及字典之间如何相互转换.py
@time:2020/11/10
"""
# 1.列表元组转换为其他类型
# 列表转集合(去重)
list1 = [6, 7, 7, 8, 8, 9]
print(set(list1))  # {8, 9, 6, 7}
# 两个列表转字典
list1 = ['key1', 'key2', 'key3']
list2 = ['1', '2', '3']
print(dict(zip(list1, list2)))  # {'key1': '1', 'key2': '2', 'key3': '3'}
# 嵌套列表转字典
list3 = [['key1', 'value1'], ['key2', 'value2'], ['key3', 'value3']]
# {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
print(dict(list3))
# 列表，元组转字符串
list2 = ['a', 'a', 'b']
print("".join(list2))  # aab
tuple1 = ('a', 'a', 'b')
print("".join(tuple1))  # aab
print("------------------------------------------------------------")
# 2.字典转换为其他类型
# 字典转换为其他类型
dic1 = {'a': 1, 'b': 2}
print(str(dic1))  # "{'a': 1, 'b': 2}"
print(type(str(dic1)))  # <class 'str'>
# 字典 key和value互转
dic2 = {'a': 1, 'b': 2, 'c': 3}
# {1: 'a', 2: 'b', 3: 'c'}
print({value: key for key, value in dic2.items()})
print("------------------------------------------------------------")
# 3.字符串转换为其他类型
# 字符串转列表
s = "aabbcc"
print(list(s))  # ['a', 'a', 'b', 'b', 'c', 'c']
# 字符串转元组
print(tuple(s))  # ('a', 'a', 'b', 'b', 'c', 'c')
# 字符串转集合
print(set(s))  # {'a', 'b', 'c'}
# 字符串转字典
dic2 = eval("{'name': 'Amo', 'age': 18}")
print(dic2)  # {'name': 'Amo', 'age': 18}
print(type(dic2))  # <class 'dict'>
# 切分字符串
a = "a b c"
print(a.split(' '))  # ['a', 'b', 'c']

11. 真题

1. 1 or 2、1 and 2、1 < (2==2)、1 < 2 == 2 分别输出什么?

2. 以下代码的运行结果是什么?

   value = "B" and "A" or "C"
   print(value)
   

3. 用 4、9、2、7 四个数字，可以使用 +、-、*、和/，每个数字使用一次，使表达式的结果为 24，表达式是什么?

4. any() 和 all()方法有什么区别?

5. Python 中有什么元素为假?

6. 在 Python 中是否有三元运算符 “?:” ?

7. 如何声明多个变量并赋值?

8. 以下程序是否会报错?

   v1 = {}
   v2 = {3:5}
   v3 = {[11,23]:5}
   v4 = {(11,23):5}
   

9. a = (1,)，b = (1)，c = (“1”) 分别是什么类型的数据?

10. 使用 for 循环分别遍历列表、元组、字典和集合。

11. 99 的八进制表示是多少?

12. 请写出十进制转二进制、八进制、十六进制的程序。

欢迎大家在评论区打出真题的答案，也可以进行讨论，答案下期揭晓，编写不易，请手留余香。

本文地址：https://blog.csdn.net/xw1680/article/details/109569378