190道Python3基础题以及解答
python基础
- 190道Python：
- 1..谈谈对 Python 和其他语言的区别
- 2 简述解释型和编译型编程语言
- 3 Python 的解释器种类以及相关特点？
- 4 Python3 和 Python2 之间的区别？
- 5.Python3 和 Python2 中 int 和 long 区别？
- 6.xrange 和 range 的区别？
- 7.什么是 PEP8?
- 8.了解 Python 之禅么？
- 9.了解 docstring 么？
- 10.了解类型注解么？
- 11.例举你知道 Python 对象的命名规范，例如方法或者类等
- 12.Python 中的注释有几种？
- 13.如何优雅的给一个函数加注释？
- 14.如何给变量加注释？
- 15.Python 代码缩进中是否支持 Tab 键和空格混用。
- 16.是否可以在一句 import 中导入多个库?
- 17.在给 Py 文件命名的时候需要注意什么?
- 18.例举几个规范 Python 代码风格的工具
- 19.列举 Python 中的基本数据类型？
- 20.如何区别可变数据类型和不可变数据类型
- 21.将"hello world"转换为首字母大写"Hello World"
- 22.如何检测字符串中只含有数字?
- 23.将字符串"ilovechina"进行反转
- 24.Python 中的字符串格式化方式你知道哪些？
- 25.有一个字符串开头和末尾都有空格，比如“ adabdw ”,要求写一个函数把这个字符串的前后空格都去掉。
- 26.获取字符串”123456“最后的两个字符。
- 27.一个编码为 GBK 的字符串 S，要将其转成 UTF-8 编码的字符串，应如何操作？
- 28. (1)s="info：xiaoZhang 33 shandong"，用正则切分字符串输出['info', 'xiaoZhang', '33', 'shandong'\](2) a = "你好 中国 "，去除多余空格只留一个空格。
- 29. (1)怎样将字符串转换为小写 (2)单引号、双引号、三引号的区别？
- 30.已知 AList = [1,2,3,1,2],对 AList 列表元素去重，写出具体过程。
- 31.如何实现 "1,2,3" 变成 ["1","2","3"]
- 32.给定两个 list，A 和 B，找出相同元素和不同元素
- 33.[[1,2],[3,4],[5,6]]一行代码展开该列表，得出[1,2,3,4,5,6]
- 34.合并列表[1,5,7,9]和[2,2,6,8]
- 35.如何打乱一个列表的元素？
- 36.字典操作中 del 和 pop 有什么区别
- 37.按照字典的内的年龄排序
- 38.请合并下面两个字典 a = {"A":1,"B":2},b = {"C":3,"D":4}
- 39.如何使用生成式的方式生成一个字典，写一段功能代码。
- 40.如何把元组("a","b")和元组(1,2)，变为字典{"a":1,"b":2}
- 41.Python 常用的数据结构的类型及其特性？
- 42.如何交换字典 {"A"：1,"B"：2}的键和值？
- 43.Python 里面如何实现 tuple 和 list 的转换？
- 44.我们知道对于列表可以使用切片操作进行部分元素的选择，那么如何对生成器类型的对象实现相同的功能呢？
- 45.请将[i for i in range(3)]改成生成器
- 46.a="hello"和 b="你好"编码成 bytes 类型
- 47.下面的代码输出结果是什么？
- 48.下面的代码输出的结果是什么?
- 49.Python 交换两个变量的值
- 51.json 序列化时，可以处理的数据类型有哪些？如何定制支持 datetime 类型？
- 52.json 序列化时，默认遇到中文会转换成 unicode，如果想要保留中文怎么办？
- 53.有两个磁盘文件 A 和 B，各存放一行字母，要求把这两个文件中的信息合并(按字母顺序排列)，输出到一个新文件 C 中。
- 54.如果当前的日期为 20190530，要求写一个函数输出 N 天后的日期，(比如 N 为 2，则输出 20190601)。
- 55.写一个函数，接收整数参数 n，返回一个函数，函数的功能是把函数的参数和 n 相乘并把结果返回。
- 56.下面代码会存在什么问题，如何改进？
- 57.一行代码输出 1-100 之间的所有偶数。
- 58.with 语句的作用，写一段代码？
- 59.python 字典和 json 字符串相互转化方法
- 60.请写一个 Python 逻辑，计算一个文件中的大写字母数量
- 61. 请写一段 Python连接 Mongo 数据库，然后的查询代码。
- 62.说一说 Redis 的基本类型。
- 63. 请写一段 Python连接 Redis 数据库的代码。
- 64. 请写一段 Python 连接 MySQL 数据库的代码。
- 65.了解 Redis 的事务么？
- 66.了解数据库的三范式么？
- 67.了解分布式锁么？
- 68.用 Python 实现一个 Reids 的分布式锁的功能。
- 69.写一段 Python 使用 Mongo 数据库创建索引的代码。
- 70.函数装饰器有什么作用？请列举说明？
- 71.Python 垃圾回收机制？
- 72.魔法函数 __call__怎么使用?
- 73.如何判断一个对象是函数还是方法？
- 74.@classmethod 和@staticmethod 用法和区别
190道Python：
https://mp.weixin.qq.com/s?__biz=MzIyMjYyMzg3MA==&mid=2247490226&idx=1&sn=8803cbd62b95f0d4001fa2aac881f152&chksm=e82bfba3df5c72b588ee7eacc685335543e5f56051dab784a8883832aaf4dfc0ec3f6bb39f77&scene=0&xtrack=1#rd
1…谈谈对 Python 和其他语言的区别
# Python是一门语法简洁优美,功能强大无比,应用领域非常广泛,具有强大完备的第三方库的一门
# 弱类型的可移植,可扩展,可嵌入的解释型编程语言
# Python和Java相比:
# Python比Java要简单.Python是函数为一等公民的语言,而Java是类为一等公民的语言.Python是弱类型语言,而Java是强类型语言.
# Python和C相比
# 对于使用:
# Python的类库齐全并且使用简洁,很少代码实现的功能用C可能要很复杂
# 对于速度:
# Python的运行速度相较于C,绝对是很慢了.Python和CPython解释器都是C语言编写的
2 简述解释型和编译型编程语言
# 解释型就是边解释边执行
# 编译型就是编译后执行
3 Python 的解释器种类以及相关特点？
# CPython
# c语言开发的 使用最广的解释器
# IPython
# 基于cpython之上的一个交互式计时器 交互方式增强 功能和cpython一样
# PyPy
# 目标是执行效率 采用JIT技术 对python代码进行动态编译，提高执行效率
# JPython
# 运行在Java上的解释器 直接把python代码编译成Java字节码执行
# IronPython
# 运行在微软 .NET 平台上的解释器，把python编译成. NET 的字节码
4 Python3 和 Python2 之间的区别？
首先两者是不兼容的。3没有兼容2，其次两者的最关键的是类库和模块不一样。
5.Python3 和 Python2 中 int 和 long 区别？
python2中有long类型
python3中没有long类型，只有int类型
6.xrange 和 range 的区别？
range([start,] stop[, step])，根据start与stop指定的范围以及step设定的步长，生成一个序列。
比如：
>>> range(5)
[0, 1, 2, 3, 4]
>>> range(1,5)
[1, 2, 3, 4]
>>> range(0,6,2)
[0, 2, 4]
xrange 用法与 range 完全相同，所不同的是生成的不是一个list对象，而是一个生成器。
>>> xrange(5)
xrange(5)
>>> list(xrange(5))
[0, 1, 2, 3, 4]
>>> xrange(1,5)
xrange(1, 5)
>>> list(xrange(1,5))
[1, 2, 3, 4]
>>> xrange(0,6,2)
xrange(0, 6, 2)
>>> list(xrange(0,6,2))
[0, 2, 4]
示例可以知道：要生成很大的数字序列的时候，用xrange会比range性能优很多，因为不需要一上来就开辟一块很大的内存空间。
xrange 和 range 这两个基本上都是在循环的时候用。
for i in range(0, 100):
print i
for i in xrange(0, 100):
print i
这两个输出的结果都是一样的，实际上有很多不同，range会直接生成一个list对象：
a = range(0,100)
print type(a)
print a
print a[0], a[1]
输出结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
0 1
而xrange则不会直接生成一个list，而是每次调用返回其中的一个值：
a = xrange(0,100)
print type(a)
print a
print a[0], a[1]
输出结果：
xrange(100)
0 1
所以xrange做循环的性能比range好，尤其是返回很大的时候。尽量用xrange吧，除非你是要返回一个列表。
7.什么是 PEP8?
1 缩进。4个空格的缩进（编辑器都可以完成此功能），不使用Tap，更不能混合使用Tap和空格。
2 每行最大长度79，换行可以使用反斜杠，最好使用圆括号。换行点要在操作符的后边敲回车。
3 类和top-level函数定义之间空两行；类中的方法定义之间空一行；函数内逻辑无关段落之间空一行；其他地方尽量不要再空行。
4 模块导入的顺序：按标准、三方和自己编写顺序依次导入，之间空一行。
5 不要在一句import中多个库，比如import os, sys不推荐
6 避免不必要的空格
7 注释必须要有
8 函数命名要遵循规范
10 尽可能使用‘is’‘is not’取代‘==’，比如if x is not None 要优于if x。
11 使用基于类的异常，每个模块或包都有自己的异常类，此异常类继承自Exception。
12 异常中try的代码尽可能少。
作者：python之禅 链接：https://www.jianshu.com/p/155910fa30b1 来源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。
8.了解 Python 之禅么？
>>> import this
Beautiful is better than ugly.
# 优美胜于丑陋（Python以编写优美的代码为目标）
Explicit is better than implicit.
# 明了胜于晦涩（优美的代码应当是明了的，命名规范，风格相似）
Simple is better than complex.
# 简洁胜于复杂（优美的代码应当是简洁的，不要有复杂的内部实现）
Complex is better than complicated.
# 复杂胜于凌乱（如果复杂不可避免，那代码间也不能有难懂的关系，要保持接口简洁）
Flat is better than nested.
# 扁平胜于嵌套（优美的代码应当是扁平的，不能有太多的嵌套）
Sparse is better than dense.
# 间隔胜于紧凑（优美的代码有适当的间隔，不要奢望一行代码解决问题）
Readability counts.
# 可读性很重要（优美的代码是可读的）
Special cases aren't special enough to break the rules.
Although practicality beats purity.
# 即便假借特例的实用性之名，也不可违背这些规则（这些规则至高无上）
Errors should never pass silently.
Unless explicitly silenced.
# 不要包容所有错误，除非你确定需要这样做（精准地捕获异常，不写except:pass风格的代码）
In the face of ambiguity, refuse the temptation to guess.
# 当存在多种可能，不要尝试去猜测
There should be one-- and preferably only one --obvious way to do it.
# 而是尽量找一种，最好是唯一一种明显的解决方案（如果不确定，就用穷举法）
Although that way may not be obvious at first unless you're Dutch.
# 虽然这并不容易，因为你不是 Python 之父（这里的Dutch是指Guido）
Now is better than never.
Although never is often better than *right* now.
# 做也许好过不做，但不假思索就动手还不如不做（动手之前要细思量）
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
# 如果你无法向人描述你的方案，那肯定不是一个好方案；反之亦然（方案测评标准）
Namespaces are one honking great idea -- let's do more of those!
# 命名空间是一种绝妙的理念，我们应当多加利用（倡导与号召）
9.了解 docstring 么？
在软件工程中，其实编码所占的部分是非常小的，大多是其它的事情，比如写文档。文档是沟通的工具。
在python中，比较推崇在代码中写文档，代码即文档，比较方便，容易维护，直观，一致。
代码写完，文档也出来了。其实Markdown也差不多这种思想，文本写完，排版也完成了。
看看PEP 0257中对docstring的定义：
A docstring is a string literal that occurs as the first statement in
a module, function, class, or method definition. Such a docstring
becomes the __doc__ special attribute of that object.
简单来说，就是出现在模块、函数、类、方法里第一个语句的，就是docstring。会自动变成属性__doc__。
def foo():
""" This is function foo"""
1
2
可通过foo.__doc__访问得到’ This is function foo’.
---------------------
版权声明：本文为CSDN博主「mattkang」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/handsomekang/article/details/46830083
10.了解类型注解么？
先看代码
def add(x: int, y: int) -> int:
return x + y
没用过类型注解(Type Annotations)的同学可能咋一看有点迷糊，其实上面这段代码和下面这个代码是一样的。
def add(x, y):
return x + y
类型注解介绍
我们知道 Python 是一种动态语言，变量以及函数的参数是不区分类型。
Python解释器会在运行的时候动态判断变量和参数的类型，这样的好处是编写代码速度很快，很灵活，但是坏处也很明显，不好维护，可能代码写过一段时间重新看就很难理解了，因为那些变量、参数、函数返回值的类型，全都给忘记了。
而且当你在读别人的代码的时候，也无法一眼看出变量或者参数的类型，经常要自己推敲，这样给学习带来了很大的障碍。
所以Python3里有了这个新特性，可以给参数、函数返回值和变量的类型加上注解，不过这个仅仅是注释而已，对代码的运行来说没有任何影响，变量的真正类型还是会有Python解释器来确定，你所做的只是在提高代码的可读性，仅此而已。
看代码
def add(x: int, y: int) -> int:
return x + y
def area_calculation(radius: float) -> float:
# 变量类型注解需要 py3.6 以上版本
# Var Type Annotations need python 3.6 and later
pi: float = 3.1415926
return radius * radius * pi
if __name__ == '__main__':
print(add(1, 2))
print(add.__annotations__)
print(area_calculation(2))
print(area_calculation.__annotations__)
运行结果：
3
{'x': , 'y': , 'return': }
12.5663704
{'radius': , 'return': }
这里调用了函数的__annotations__属性，通过这个属性可以看到参数和返回值类型的注解。
测试注解的正确性
前面说了，这个注解仅仅起到了注释的作用，不会影响代码的执行，所以即使你类型注解写错了，程序运行的时候还是会按照正确的类型去运行。
然后，Python提供了一个工具方便我们测试代码里的类型注解正确性，mypy
首先安装：
pip install mypy
使用测试：
mypy filename.py
如果没有错误则没有输出，如果有错误则会有相应输出，如
$ mypy demo.py
demo.py:14: error: Incompatible return value type (got “float”, expected “int”)
作者：画星星高手 链接：https://www.jianshu.com/p/72bfd33e41af 来源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。
11.例举你知道 Python 对象的命名规范，例如方法或者类等
Google Python命名规范
module_name, 模块
package_name, 包
ClassName, 类
method_name, 方法
ExceptionName, 异常
function_name, 函数
GLOBAL_VAR_NAME, 全局变量
instance_var_name, 实例
function_parameter_name, 参数
local_var_name. 本变量
12.Python 中的注释有几种？
1.python单行注释符号(#)
2.批量、多行注释符号。多行注释是用三引号''' '''包含的
3.python中文注释方法，开头声明保存编码的格式：
#coding=utf-8
或者：
#coding=gbk
13.如何优雅的给一个函数加注释？
**为函数添加文档注释**
注释尽管在程序中不是必须的，但却是必要的。如果没有注释，那么程序就很难被别人读懂，甚至果断时间，自己都看不明白自己写的程序。Python语言支持单行注释和多行注释，前者使用井号（#）表示，后者使用三个单引号或双引号将多行注释内容括起来。对于函数来说，还可以使用另外一种注释：文档注释。
不管单行注释还是多行注释，在程序编译后，这些注释都会被编译器去掉，也就是说，无法再程序中通过代码来动态获取单行注释和多行注释的内容。而文档注释作为程序的一部分一起存储，通过代码可以动态获取这些注释。文档注释有一个重要的作用，就是让函数、类等Python元素具有描述功能。通过一些工具，可以为所有添加了文档注释的函数和类生成文档。很多编程语言的API帮助信息就是这么做的。
为函数添加文档注释，需要在函数头（包含def关键字的那一行）的下一行用一对单引号或双引号将注释括起来。
def add (x,y):
"计算两个数的和"
return x + y
在上面的代码中，“计算两个数的和”就是add自定义函数的文档注释。可以使用"doc"函数属性获取add函数的文档注释。要注意，"doc"中’doc’的两侧分别是两个下划线（_）。
def add (x,y):
"计算两个数的和"
return x + y
print(add.__doc__)
#输出结果：计算两个数的和
#也可以直接使用help函数获取函数的文档注释
help(add)
输出结果：
计算两个数的和
Help on function add in module __main__:
add(x, y)
计算两个数的和
---------------------
版权声明：本文为CSDN博主「python进阶之路」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_45086637/article/details/90759102
14.如何给变量加注释？
变量的声明同一行加上#的注释
15.Python 代码缩进中是否支持 Tab 键和空格混用。
混用Tab和空格是指相邻的两句的缩进需要统一使用tab或统一使用空格，不能混用
python中不提倡使用tab缩进
不同编辑器对于TAB的解释是不同的，有的编辑器tab是4个字符宽，有的8个字符宽。
如果有的地方用TAB，有的地方用空格，在不同的地方，原本对齐的代码就可能会不对齐。
空格永远都是一样的。
对于一些细致排版缩进来说（比如说想把每一行的注释都对齐），用空格也更加精确。
有时候IDE会自动帮你将Tab键展开为为空格，对于普通编辑器来说，一般都不会这样做。
16.是否可以在一句 import 中导入多个库?
支持，但是不提倡
17.在给 Py 文件命名的时候需要注意什么?
1.模块名和包名采用小写字母并且以下划线分隔单词的形式；
如:regex_syntax,py_compile,_winreg
2.类名或异常名采用每个单词首字母大写的方式；
如：BaseServer,ForkingMixIn,KeyboardInterrupt
3.全局或者类常量，全部使用大写字母，并且以下划线分隔单词；
如：MAX_LOAD
4.其余变量命名包括方法名，函数名，普通变量名则是采用全部小写字母，并且以下划线分隔单词的形式命名。
如：my_thread
5.以上的内容如果是内部的，则使用下划线开头命名。
如：init,new
————————————————
版权声明：本文为CSDN博主「追_梦_者」的原创文章，遵循CC 4.0
by-sa版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/IT_DREAM_ER/article/details/51999302
18.例举几个规范 Python 代码风格的工具
VSCODE、PyCharm
19.列举 Python 中的基本数据类型？
元祖tuple、数字、字符串、列表List、集合Set、字典Dict
20.如何区别可变数据类型和不可变数据类型
数据类型 可变/不可变
整型 不可变
字符串 不可变
元组 不可变
列表 可变
集合 可变
字典 可变
21.将"hello world"转换为首字母大写"Hello World"
arr = "hello world".split(" ")
new_str = f"{arr[0].capitalize()} {arr[1].capitalize()}"
22.如何检测字符串中只含有数字?
(str).isdigit()
23.将字符串"ilovechina"进行反转
s1 = “ilovechina”[：：-1]
24.Python 中的字符串格式化方式你知道哪些？
-
最传统的用%格式化字符串
name = “Kobe”
age = “40”
“Hello, %s. You are %s.” % (name, age)
‘Hello, Kobe. You are 40.’ -
string.format ()
从python2.6诞生的方法
该方法是对%-formatting的改进。它使用正常的函数调用语法，并且可以通过对要转换为字符串的对象的__format __（）方法进行扩展。
使用大括号{ }来作为占位符，不区分格式。name = “Kobe”
age = “40”
“Hello,{}. You are {}”.format(name,age)
‘Hello,Kobe. You are 40’ -
f-string
python3.6诞生的新方法
该方法叫做“F字符串方法”，又称为“格式化字符串文字”。F字符串是开头有一个f的字符串文字，以及包含表达式的大括号将被其值替换。表达式在运行时进行渲染，然后使用__format__协议进行格式化。name = ‘kobe’
f’his name is {name}’
‘his name is kobe’
25.有一个字符串开头和末尾都有空格，比如“ adabdw ”,要求写一个函数把这个字符串的前后空格都去掉。
Python中有三个去除头尾字符、空白符的函数，它们依次为:
strip： 用来去除头尾字符、空白符(包括\n、\r、\t、’ ‘，即：换行、回车、制表符、空格)
lstrip：用来去除开头字符、空白符(包括\n、\r、\t、’ ‘，即：换行、回车、制表符、空格)
rstrip：用来去除结尾字符、空白符(包括\n、\r、\t、’ '，即：换行、回车、制表符、空格)
从字面可以看出r=right，l=left，strip、rstrip、lstrip是开发中常用的字符串格式化的方法。
函数：
# 正则匹配
def reSpace(s):
import re
if s.startswith(' ') or s.endswith(' '):
return re.sub(r"^(\s+)|(\s+)$", "", s)
return s
#递归的方法
def trimSpace(s):
if s[0] == " ":
return trimSpace(s[1:])
elif s[-1] == " ":
return trimSpace(s[:-1])
else:
return s
26.获取字符串”123456“最后的两个字符。
#获取字符串最后两个字符
def getLastTwo(s):
return s[-2:]
27.一个编码为 GBK 的字符串 S，要将其转成 UTF-8 编码的字符串，应如何操作？
str.encode("GBK")
str.encode("UTF-8")
28. (1)s=“info：xiaoZhang 33 shandong”，用正则切分字符串输出[‘info’, ‘xiaoZhang’, ‘33’, ‘shandong’](2) a = "你好 中国 "，去除多余空格只留一个空格。
def reStr1(s):
import re
return re.split(r'[\s\:\：]+', s)
#a = "你好 中国 "，去除多余空格只留一个空格。
def wipeSpace(s):
import re
l = re.split(r'\s+', s)
return " ".join(l)
29. (1)怎样将字符串转换为小写 (2)单引号、双引号、三引号的区别？
(1)s2.upper()
(2)
单引号和双引号平时使用时候，是没有太多区别的。但是在定义字符串时候，可以单双引号混用来避免转义问题。
三引号作用：
-可以作为格式化输出
>>> str1 = """List of name:
... Hua Li
... Chao Deng
... """
>>> print(str1)
List of name:
Hua Li
Chao Deng
- 三引号可以作为多行注释。单双引号都可以。
30.已知 AList = [1,2,3,1,2],对 AList 列表元素去重，写出具体过程。
list(set(list)) --先将列表转化为set，再转化为list就可以实现去重操作
31.如何实现 “1,2,3” 变成 [“1”,“2”,“3”]
str.split(",")
32.给定两个 list，A 和 B，找出相同元素和不同元素
转换为求两个list的差集（不同元素），交集（相同元素）
交集：list(set(a).intersection(set(b))
差集：l = list(set(b).difference(set(a))) + list(set(a).difference(set(b)))
并集：list(set(a).union(set(b)))
33.[[1,2],[3,4],[5,6]]一行代码展开该列表，得出[1,2,3,4,5,6]
l1 = [[1,2],[3,4],[5,6]]
l = [j for t in l1 for j in t]
34.合并列表[1,5,7,9]和[2,2,6,8]
直接用+
35.如何打乱一个列表的元素？
import random
l = [1,2,3,4,5,6]
random.shuffle(l)
print(l)
36.字典操作中 del 和 pop 有什么区别
del 可以删除指定key的键值对，并且没有返回。用法：del dict[key]； 也可以使用del来清空整个字典
pop是从字典中取走指定key的键值对，并且返回键值。是字典的一个方法。用法：dict.pop(key)
37.按照字典的内的年龄排序
字典的排序：
- 1 sorted
先看一下，直接用sorted()排序的情况。
dict1={‘a’:2,‘e’:3,‘f’:8,‘d’:4}
dict2 = sorted(dict1)
print(dict2)
结果：
[‘a’, ‘d’, ‘e’, ‘f’]
sorted()默认是对字典的键，从小到大进行排序
- 2 、对键反向排序
对键进行反向（从大到小）排序
dict1={'a':2,'e':3,'f':8,'d':4}
dict2 = sorted(dict1,reverse=True)
print(dict2)
结果：[‘f’, ‘e’, ‘d’, ‘a’]
像这种对键进行排序，往往是为了得到 值（value）
拿到键最大，对应的值，如：
print(dict1[dict2[0]])#结果为8
当然我们也可以先拿到所有的key，然后再对key排序
dict1={'a':2,'e':3,'f':8,'d':4}
list1= sorted(dict1.keys(),reverse=True)
print(list1) # 结果：['f', 'e', 'd', 'a']
- 3、对值排序
同样，用dict1.values()得到所有的values，然后对value排序
dict1={'a':2,'e':3,'f':8,'d':4}
list1= sorted(dict1.values())
print(list1) #结果：[2, 3, 4, 8]
设值reverse=True 进行反向排序
也可以用dict1.items()，得到包含键，值的元组
由于迭代对象是元组，返回值自然是元组组成的列表
这里对排序的规则进行了定义，x指元组，x[1]是值，x[0]是键
dict1={'a':2,'e':3,'f':8,'d':4}
list1= sorted(dict1.items(),key=lambda x:x[1])
print(list1)
结果：
[(‘a’, 2), (‘e’, 3), (‘d’, 4), (‘f’, 8)]
对键进行排序：
dict1={'a':2,'e':3,'f':8,'d':4}
list1= sorted(dict1.items(),key=lambda x:x[0])
print(list1)
结果：
[(‘a’, 2), (‘d’, 4), (‘e’, 3), (‘f’, 8)]
-
4 itemgetter
from operator import itemgetter
d = {“a”:8,“b”:4,“c”:12}
print(sorted(d.items(),key=itemgetter(0),reverse=True))
print(sorted(d.items(),key=itemgetter(1),reverse=True))
结果：
[(‘c’, 12), (‘b’, 4), (‘a’, 8)]
[(‘c’, 12), (‘a’, 8), (‘b’, 4)]
itemgetter(0)，获取key
itemgetter(1)，获取value
————————————————
版权声明：本文为CSDN博主「飞奔的帅帅」的原创文章，遵循CC 4.0 by-sa版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/ustbbsy/article/details/79637594
38.请合并下面两个字典 a = {“A”:1,“B”:2},b = {“C”:3,“D”:4}
#(1)字典的update()方法
def dictMerge1():
a = {"A":1,"B":2}
b = {"C":3,"D":4}
a.update(b)
print(a)
#(2)字典的dict(d1, **d2)方法和（**d1,**d2）方法
def dictMerge2():
a = {"A":1,"B":2}
b = {"C":3,"D":4}
c = dict(a, **b)
d = {**a, **b}
print(c)
print(d)
39.如何使用生成式的方式生成一个字典，写一段功能代码。
# 字典生成式
# dict_1.items()
list4 = [('name','zhangsan'),('age',22),('phone',110)]
# for 循环遍历列表，将列表中小元组的key和value取出，作为字典中的key：value
dict_1 = {key:value for key,value in list4}
print (dict_1)
————————————————
版权声明：本文为CSDN博主「LD_Murcielago」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/ld_murcielago/article/details/79232565
40.如何把元组(“a”,“b”)和元组(1,2)，变为字典{“a”:1,“b”:2}
把元组(“a”,“b”)和元组(1,2)，变为字典{“a”:1,“b”:2}
a, b = ("a","b"), (1,2)
z = zip(a, b)
z
[("a", 1), ("b", 2)]
-------------------
c = dict(z)
c
Out[8]: {'a': 1, 'b': 2}
优化代码
=============================
dict(zip(("a","b"), (1,2)))
-----------------------------------
Out[4]: {'a': 1, 'b': 2}
总结
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
zipped = zip(a,b) # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
zip(a,c) # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
zip(zipped) # 与 zip 相反，zipped 可理解为解压，返回二维矩阵式
[(1, 2, 3), (4, 5, 6)]
41.Python 常用的数据结构的类型及其特性？
https://www.runoob.com/python3/python3-list.html
42.如何交换字典 {“A”：1,“B”：2}的键和值？
三种方式交换键值对（前提：值唯一）：
1.
mydict={"a":1,"b":2,"c":3}
mydict_new={}
for key,val in mydict.items():
mydict_new[val]=key
2.
mydict={"a":1,"b":2,"c":3}
mydict_new=dict([val,key] for key,val in mydict.items())
3.利用zip运算符：
mydict={"a":1,"b":2,"c":3}
mydict_new=dict(zip(mydict.values(),mydict.keys()))
————————————————
版权声明：本文为CSDN博主「高启航」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/u010614988/article/details/49337031/
43.Python 里面如何实现 tuple 和 list 的转换？
list(tup)
tuple(list)
44.我们知道对于列表可以使用切片操作进行部分元素的选择，那么如何对生成器类型的对象实现相同的功能呢？
调用itertools模块下的islice方法
class Fib():
def __init__(self):
self.a, self.b = 1, 1
def __iter__(self):
while True:
yield self.a
self.a, self.b = self.b, self.a + self.b
def callFib():
n = 0
for x in Fib():
n += 1
print(x)
if n == 30:
break
from itertools import islice
for x in islice(Fib(), 10, 20):
print(x)
45.请将[i for i in range(3)]改成生成器
(i for i in range(3))
46.a="hello"和 b="你好"编码成 bytes 类型
mystr = "hello"
mybyte = mystr.encode(encoding = "utf-8") #str转bytes
mystr1 = mybyte.decode() #bytes转str
47.下面的代码输出结果是什么？
3
48.下面的代码输出的结果是什么?
4
49.Python 交换两个变量的值
a = 10
b = 20
#不需要中间变量，一步搞定
a, b = b, a
#50.在读文件操作的时候会使用 read、readline 或者 readlines，简述它们各自的作用
1）read([size])方法从文件当前位置起读取size个字节，若无参数size，则表示读取至文件结束为止，输出的结果是字符串对象
2）readline()：每次读出一行内容，所以，读取时占用内存小，比较适合大文件，输出的结果也是一个字符串对象。
3）readlines()：读取整个文件所有行，保存在一个列表(list)变量中，每行作为一个元素，但读取大文件会比较占内存。
总结：read和readline返回的是字符串，而readlines返回的是列表，其中每行是作为列表的一个元素。
51.json 序列化时，可以处理的数据类型有哪些？如何定制支持 datetime 类型？
1、可以处理的数据类型是 string、int、list、tuple、dict、bool、null
2、自定义时间序列化转换器
import json
from json import JSONEncoder
from datetime import datetime
class ComplexEncoder(JSONEncoder):
def default(self, obj):
if isinstance(obj, datetime):
return obj.strftime('%Y-%m-%d %H:%M:%S')
else:
return super(ComplexEncoder,self).default(obj)
d = { 'name':'alex','data':datetime.now()}
print(json.dumps(d,cls=ComplexEncoder))
# {"name": "alex", "data": "2018-05-18 19:52:05"}
52.json 序列化时，默认遇到中文会转换成 unicode，如果想要保留中文怎么办？
import json
a=json.dumps({"ddf":"你好"},ensure_ascii=False)
print(a) #{"ddf": "你好"}
53.有两个磁盘文件 A 和 B，各存放一行字母，要求把这两个文件中的信息合并(按字母顺序排列)，输出到一个新文件 C 中。
with open "xx/A" as A:
content_a = A.readlines()
with open "xx/B" as B:
content_b = B.readlines()
content_c = sorted(content_a+content_b)
C=open( "xx/C",w)
result =c.write(content_c)
A.close()
B.close()
C.close()
54.如果当前的日期为 20190530，要求写一个函数输出 N 天后的日期，(比如 N 为 2，则输出 20190601)。
def toDate(n):
if type(n) is not int:
return;
from datetime import date
from datetime import timedelta
date2 = date.today() + timedelta(days=n)
print(date2.strftime("%Y%m%d"))
toDate(2)
toDate(29)
55.写一个函数，接收整数参数 n，返回一个函数，函数的功能是把函数的参数和 n 相乘并把结果返回。
def lazy_mul(n):
def mul(m):
return m*n
return mul
56.下面代码会存在什么问题，如何改进？
无法编译通过。
将函数内的str变量换为其他名称即可
57.一行代码输出 1-100 之间的所有偶数。
print(list(even for even in range(100) if (even%2 == 0 )))
58.with 语句的作用，写一段代码？
with open(r'c:\test.txt', 'r') as f:
data = f.read()
59.python 字典和 json 字符串相互转化方法
在Python中自带json库。通过import json导入。
在json模块有2个方法，
loads()：将json数据转化成dict数据
dumps()：将dict数据转化成json数据
load()：读取json文件数据，转成dict数据
dump()：将dict数据转化成json数据后写入json文件
dict字典转json数据.
import json
def dict_to_json():
dict = {}
dict['name'] = 'many'
dict['age'] = 10
dict['sex'] = 'male'
print(dict) # 输出：{'name': 'many', 'age': 10, 'sex': 'male'}
j = json.dumps(dict)
print(j) # 输出：{"name": "many", "age": 10, "sex": "male"}
if __name__ == '__main__':
dict_to_json()
对象转json数据
import json
def obj_to_json():
stu = Student('007', '007', 28, 'male', '13000000000', '[email protected]')
print(type(stu)) #
stu = stu.__dict__ # 将对象转成dict字典
print(type(stu)) #
print(stu) # {'id': '007', 'name': '007', 'age': 28, 'sex': 'male', 'phone': '13000000000', 'email': '[email protected]'}
j = json.dumps(obj=stu)
print(j) # {"id": "007", "name": "007", "age": 28, "sex": "male", "phone": "13000000000", "email": "[email protected]"}
if __name__ == '__main__':
obj_to_json()
json数据转成dict字典
import json
def json_to_dict():
j = '{"id": "007", "name": "007", "age": 28, "sex": "male", "phone": "13000000000", "email": "[email protected]"}'
dict = json.loads(s=j)
print(dict) # {'id': '007', 'name': '007', 'age': 28, 'sex': 'male', 'phone': '13000000000', 'email': '[email protected]'}
if __name__ == '__main__':
json_to_dict()
json数据转成对象
import json
def json_to_obj():
j = '{"id": "007", "name": "007", "age": 28, "sex": "male", "phone": "13000000000", "email": "[email protected]"}'
dict = json.loads(s=j)
stu = Student()
stu.__dict__ = dict
print('id: ' + stu.id + ' name: ' + stu.name + ' age: ' + str(stu.age) + ' sex: ' + str(
stu.sex) + ' phone: ' + stu.phone + ' email: ' + stu.email) # id: 007 name: 007 age: 28 sex: male phone: 13000000000 email: [email protected]
if __name__ == '__main__':
json_to_obj()
json的load()与dump()方法的使用
dump()方法的使用
import json
def dict_to_json_write_file():
dict = {}
dict['name'] = 'many'
dict['age'] = 10
dict['sex'] = 'male'
print(dict) # {'name': 'many', 'age': 10, 'sex': 'male'}
with open('1.json', 'w') as f:
json.dump(dict, f) # 会在目录下生成一个1.json的文件，文件内容是dict数据转成的json数据
if __name__ == '__main__':
dict_to_json_write_file()
load()的使用
import json
def json_file_to_dict():
with open('1.json', 'r') as f:
dict = json.load(fp=f)
print(dict) # {'name': 'many', 'age': 10, 'sex': 'male'}
if __name__ == '__main__':
json_file_to_dict()
60.请写一个 Python 逻辑，计算一个文件中的大写字母数量
import os
os.chdir(r'C:\Users\Administrator\Desktop') #os.chdir切换到指定目录
with open('a.txt') as today:
count=0
for i in today.read():
if i.isupper():
count+=1
print(count)
61. 请写一段 Python连接 Mongo 数据库，然后的查询代码。
import pymongo
db_configs = {
'type': 'mongo',
'host': '地址',
'port': '端口',
'user': 'spider_data',
'passwd': '密码',
'db_name': 'spider_data'
}
class Mongo():
def __init__(self, db=db_configs["db_name"], username=db_configs["user"],
password=db_configs["passwd"]):
self.client = pymongo.MongoClient(f'mongodb://{db_configs["host"]}:db_configs["port"]')
self.username = username
self.password = password
if self.username and self.password:
self.db1 = self.client[db].authenticate(self.username, self.password)
self.db1 = self.client[db]
def find_data(self):
# 获取状态为0的数据
data = self.db1.test.find({"status": 0})
gen = (item for item in data)
return gen
if __name__ == '__main__':
m = Mongo()
print(m.find_data())
62.说一说 Redis 的基本类型。
redis是一个key-value存储系统，和Memcache类似，它支持存储的value类型相对更多，包括string(字符串)，list(链表)，set(集合)，zset(有序集合)，hash(哈希类型)。这些数据类型都支持push/pop，add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在次基础上，redis支持各种不同方式的排序，与memcached一样，为了保证效率，数据都是缓冲在内存中。区别是redis会周期性的把更新的数据写入磁盘或把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。
备注：默认redis有16个数据库，即db0~db15， 一般存取数据如果不指定库的话，默认都是存在db0中。
Redis支持五种数据类型：string（字符串），hash（哈希），list（列表），set（集合）及zset(sorted set：有序集合)。
其他参考：python3使用Redis
63. 请写一段 Python连接 Redis 数据库的代码。
import redis # 导入redis模块，通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库
r = redis.Redis(host='localhost', port=6379, decode_responses=True) # host是redis主机，需要redis服务端和客户端都启动 redis默认端口是6379
r.set('name', 'junxi') # key是"foo" value是"bar" 将键值对存入redis缓存
print(r['name'])
print(r.get('name')) # 取出键name对应的值
print(type(r.get('name')))
64. 请写一段 Python 连接 MySQL 数据库的代码。
#导入pymysql的包
import pymysql
try:
#获取一个数据库连接，注意如果是UTF-8类型的，需要制定数据库
conn=pymysql.connect(host='localhost',user='pythontab',passwd='pythontab',db='pythontab',port=3306,charset='utf8')
cur=conn.cursor()#获取一个游标
cur.execute('select * from user')
data=cur.fetchall()
for d in data :
#注意int类型需要使用str函数转义
print("ID: "+str(d[0])+' 用户名： '+d[1]+" 注册时间： "+d[2])
cur.close()#关闭游标
conn.close()#释放数据库资源
except Exception :print("查询失败")
65.了解 Redis 的事务么？
Redis 事务可以一次执行多个命令， 并且带有以下三个重要的保证：
批量操作在发送 EXEC 命令前被放入队列缓存。
收到 EXEC 命令后进入事务执行，事务中任意命令执行失败，其余的命令依然被执行。
在事务执行过程，其他客户端提交的命令请求不会插入到事务执行命令序列中。
一个事务从开始到执行会经历以下三个阶段：
开始事务。
命令入队。
执行事务。
66.了解数据库的三范式么？
1．第一范式(确保每列保持原子性)
第一范式是最基本的范式。如果数据库表中的所有字段值都是不可分解的原子值，就说明该数据库表满足了第一范式。
2．第二范式(确保表中的每列都和主键相关)
第二范式在第一范式的基础之上更进一层。第二范式需要确保数据库表中的每一列都和主键相关，而不能只与主键的某一部分相关（主要针对联合主键而言）。也就是说在一个数据库表中，一个表中只能保存一种数据，不可以把多种数据保存在同一张数据库表中
3．第三范式(确保每列都和主键列直接相关,而不是间接相关)
第三范式需要确保数据表中的每一列数据都和主键直接相关，而不能间接相关。
67.了解分布式锁么？
分布式锁
68.用 Python 实现一个 Reids 的分布式锁的功能。
链接
69.写一段 Python 使用 Mongo 数据库创建索引的代码。
链接
70.函数装饰器有什么作用？请列举说明？
装饰器
python装饰器本质上就是一个函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外的功能，装饰器的返回值也是一个函数对象（函数的指针）。
实质： 是一个函数。
参数：是你要装饰的函数名（并非函数调用）。
返回：是装饰完的函数名（也非函数调用）。
作用：为已经存在的对象添加额外的功能。
特点：不需要对对象做任何的代码上的变动。
python装饰器有很多经典的应用场景，比如：插入日志、性能测试、事务处理、权限校验等。装饰器是解决这类问题的绝佳设计。
装饰器最大的作用就是对于我们已经写好的程序，我们可以抽离出一些雷同的代码组建多个特定功能的装饰器，这样我们就可以针对不同的需求去使用特定的装饰器，这时因为源码去除了大量泛化的内容而使得源码具有更加清晰的逻辑。
def log(func):
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper
@log
def now():
print('2015-3-25')
调用：
now()
输出：
call now():
2015-3-25
函数对象有一个__name__属性，可以拿到函数的名字。
调用now()函数，不仅会运行now()函数本身，还会在运行now()函数前打印一行日志。
把@log放到now()函数的定义处，相当于执行了语句：
now = log(now)
wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。
71.Python 垃圾回收机制？
python采用的是引用计数机制为主，标记-清除和分代收集两种机制为辅的策略
引用计数机制的优点：
简单
实时性：一旦没有引用，内存就直接释放了。不用像其他机制等到特定时机。实时性还带来一个好处：处理回收内存的时间分摊到了平时。
引用计数机制的缺点：
维护引用计数消耗资源
循环引用
list1 = []
list2 = []
list1.append(list2)
list2.append(list1)
list1与list2相互引用，如果不存在其他对象对它们的引用，list1与list2的引用计数也仍然为1，所占用的内存永远无法被回收，这将是致命的。
对于如今的强大硬件，缺点1尚可接受，但是循环引用导致内存泄露，注定python还将引入新的回收机制。(标记清除和分代收集)
原理链接
72.魔法函数 __call__怎么使用?
先来看一下常见的魔法方法：
__doc__ 类(实例).__doc__ 类的描述信息 '''class des'''
__module__ 类(实例).__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
__call__ 类(实例)调用时（加括号）执行
__dict__查看类或实例的所有属性结果 为字典
__str__打印对象时执行
_call__
在Python中，函数其实是一个对象：
>>> f = abs
>>> f.__name__
'abs'
>>> f(-123)
123
由于 f 可以被调用，所以，f 被称为可调用对象。
所有的函数都是可调用对象。
一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()
73.如何判断一个对象是函数还是方法？
用内置的isinstance 来判断
from types import MethodType,FunctionType
print(isinstance(Work.show,FunctionType))
print(isinstance(Work.show,MethodType))
print(isinstance(work.show,FunctionType))
print(isinstance(work.show,MethodType))
结果：
True
False
False
True
74.@classmethod 和@staticmethod 用法和区别
面向对象中，最关键的是类，类中包含着各样的方法。
类的静态方法、普通方法、类方法
静态方法: 用 @staticmethod 装饰的不带 self 参数的方法叫做静态方法，类的静态方法可以没有参数，可以直接使用类名调用。
普通方法: 默认有个self参数，且只能被对象调用。
类方法: 默认有个 cls 参数，可以被类和对象调用，需要加上 @classmethod 装饰器。和静态方法比较类似，Python还可以在类中定义类方法，类方法的第一个参数约定名为cls，它代表的是当前类相关的信息的对象（类本身也是一个对象，有的地方也称之为类的元数据对象），通过这个参数我们可以获取和类相关的信息并且可以创建出类的对象 所以需要需要使用类的一些成员的时候，可以定义该方法为类方法。静态方法的定义甚至可以定义为该方法不属于该类，只能放在一起便于编码管理和查看。
抽象方法： @abstractmethod 修饰，方法主体可以是pass
Python 中的接口如何实现？
76.Python 中的反射了解么?
77.metaclass 作用？以及应用场景？
78.hasattr() getattr() setattr()的用法
79.请列举你知道的 Python 的魔法方法及用途。
80.如何知道一个 Python 对象的类型？
81.Python 的传参是传值还是传址？
82.Python 中的元类(metaclass)使用举例
83.简述 any()和 all()方法
84.filter 方法求出列表所有奇数并构造新列表，a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
85.什么是猴子补丁？
86.在 Python 中是如何管理内存的？
87.当退出 Python 时是否释放所有内存分配？
正则表达式
88.使用正则表达式匹配出
www.baidu.com
中的地址a=“张明 98 分”，用 re.sub，将 98 替换为 100
89.正则表达式匹配中(.)和(.?)匹配区别？
90.写一段匹配邮箱的正则表达式
其他内容
91.解释一下 python 中 pass 语句的作用？
92.简述你对 input()函数的理解
93.python 中的 is 和==
94.Python 中的作用域
95.三元运算写法和应用场景？
96.了解 enumerate 么？
97.列举 5 个 Python 中的标准模块
98.如何在函数中设置一个全局变量
99.pathlib 的用法举例
100.Python 中的异常处理，写一个简单的应用场景
101.Python 中递归的最大次数，那如何突破呢？
102.什么是面向对象的 mro
103.isinstance 作用以及应用场景？
104.什么是断言？应用场景？
105.lambda 表达式格式以及应用场景？
106.新式类和旧式类的区别
107.dir()是干什么用的？
108.一个包里有三个模块，demo1.py, demo2.py, demo3.py，但使用 from tools import *导入模块时，如何保证只有 demo1、demo3 被导入了。
109.列举 5 个 Python 中的异常类型以及其含义
110.copy 和 deepcopy 的区别是什么？
111.代码中经常遇到的*args, **kwargs 含义及用法。
112.Python 中会有函数或成员变量包含单下划线前缀和结尾，和双下划线前缀结尾，区别是什么?
113.w、a+、wb 文件写入模式的区别
114.举例 sort 和 sorted 的区别
115.什么是负索引？
116.pprint 模块是干什么的？
117.解释一下 Python 中的赋值运算符
118.解释一下 Python 中的逻辑运算符
119.讲讲 Python 中的位运算符
120.在 Python 中如何使用多进制数字？
121.怎样声明多个变量并赋值？
待续…