python面试8---操作类题目

1.Python 交换两个变量的值

a, b = b, a

2.在读文件操作的时候会使用 read、readline 或者 readlines，简述它们各自的作用
read()是读取自定义大小，若不传参数，则读取所有文档所有内容
readline是读取一行
readlines是读取所有行，返回一个列表，列表中的元素为每行数据

3.json 序列化时，可以处理的数据类型有哪些？如何定制支持 datetime 类型？
字符串、数字（整数和浮点数）、字典、列表、布尔值、None。使用strftime将datetime格式化为标准字符串类型即可

4.json 序列化时，默认遇到中文会转换成 unicode，如果想要保留中文怎么办？
使用json.dumps函数时，添加参数ensure_ascii=False，如果想显示的更美观，可以添加indent=2参数，会在每个key值前添加两个空格。

5.有两个磁盘文件 A 和 B，各存放一行字母，要求把这两个文件中的信息合并(按字母顺序排列)，输出到一个新文件 C 中。

1.读取A，B文件中的内容
2.将字符串转换成列表，然后排序，之后在转换成字符串
string = "string"
list1 = list(string)
list1.sort()
string = "".join(list1)
print(string)
3.写入C中

6.如果当前的日期为 20190530，要求写一个函数输出 N 天后的日期，(比如 N 为 2，则输出 20190601)
这个题目考察的是 datetime 里的 timedelta 方法的使用，参数可选、默认值都为 0：datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0) 通过这个参数可以指定不同的日期类型进行加减操作，这里我们需要改的是 days

import datetime

def datetime_operate(n: int):
    now = datetime.datetime.now()  # 获取当前时间
    print(now)
    _new_date = now + datetime.timedelta(days=n)  # 获取指定天数后的新日期
    new_date = _new_date.strftime("%Y-%m-%d %H:%M:%S")  # 转换为指定的输出格式
    return new_date
    
if __name__ == '__main__':
    print(datetime_operate(4))

7.写一个函数，接收整数参数 n，返回一个函数，函数的功能是把函数的参数和 n 相乘并把结果返回

def mul_operate(num):
    def g(val):
        return num * val

    return g

m = mul_operate(8)
print(m(5))

8.下面代码会存在什么问题，如何改进？

def strappend(num)：
	str=‘first’
	for i in range(num)：
		str+=str(i)
	return str

首先不应该使用 Python 的内置函数 str 作为变量名这里我把它改为了 s,另外在Python,str 是个不可变对象，每次迭代都会生成新的存储空间，num 越大，创建的 str 对象就会越多，内存消耗越大。使用 yield 改成生成器即可, 还有一点就是命名规范的位置，函数名改为_分割比较好，完整的代码如下:

def str_append(num):
    s = 'first'
    for i in range(num):
        s += str(i)
        yield s

if __name__ == '__main__':
    for i in str_append(3):
        print(i)

9.一行代码输出 1-100 之间的所有偶数

print([i for i in range(1, 101) if i % 2 == 0])

10.一行代码输出 1-100 之间的所有偶数之和

print(sum(map(lambda x: x, [i for i in range(1, 101) if i % 2 == 0])))

11.with 语句的作用，写一段代码
文件使用后自动关闭、线程中锁的自动获取和释放等

with open("file_name", 'w') as f:
    pass

12.python 字典和 json 字符串相互转化方法

dict-->json: json.dumps(dict)
json-->dict: json.loads(json)

13.请写一个 Python 逻辑，计算一个文件中的大写字母数量

with open(file_name, 'r') as f:
    count = 0 
    for i in f.read():
        if i.isupper():
            count += 1
    print('大写字母数量为%d'%count)

14.请写一段 Python连接 Mongo 数据库，然后的查询代码

from pymongo import MongoClient
client = MongoClient(host='127.0.0.1',port=27017)
collection = client[db名][集合名]

t = collection.find_one({"name":"test10005"})
t = collection.find({"name":"test10005"})

15.说一说 Redis 的基本类型
Redis 支持五种数据类型： string（字符串） 、 hash（哈希）、list（列表） 、 set（集合） 及 zset(sorted set： 有序集合)

16.请写一段 Python连接 Redis 数据库的代码

1.连接并且操作
r = redis.Redis(host='192.168.220.144', port=6379)
r.set('name', 'John')
print(r.get('name'))  # b'John'

2.连接池
pool = redis.ConnectionPool(host='192.168.220.144', port=6379)
r = redis.Redis(connection_pool=pool)
r.set('age', 22)
print(r.get('age'))  # b'22'

3.管道
pool = redis.ConnectionPool(host='192.168.220.144', port=6379, db=2)
r = redis.Redis(connection_pool=pool)
pipe = r.pipeline(transaction=True)
pipe.set('name', 'John')
pipe.set('age', 22) 
pipe.execute()

17.请写一段 Python连接Mysql数据库的代码

conn = pymysql.connect(host='localhost', port=3306, user='root', passwd='1234', database='user', charset='utf8')  # 声明mysql连接对象
cs1 = conn.cursor()
cs1 .execute(sql语句字符串)  # 执行sql语句
cs1.close()
conn.close()  # 关闭链接

18.了解Redis的事务么
简单理解，可以认为 redis 事务是一些列 redis 命令的集合，并且有如下两个特点： 1.事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。 2.事务是一个原子操作：事务中的命令要么全部被执行，要么全部都不执行。 一般来说，事务有四个性质称为ACID，分别是原子性，一致性，隔离性和持久性。 一个事务从开始到执行会经历以下三个阶段：开始事务、命令入队、执行事务

19.了解数据库的三范式么
经过研究和对使用中问题的总结，对于设计数据库提出了一些规范，这些规范被称为范式 一般需要遵守下面3范式即可: 第一范式（1NF）：强调的是列的原子性，即列不能够再分成其他几列。 第二范式（2NF）：首先是 1NF，另外包含两部分内容，一是表必须有一个主键；二是没有包含在主键中的列必须完全依赖于主键，而不能只依赖于主键的一部分。 第三范式（3NF）：首先是 2NF，另外非主键列必须直接依赖于主键，不能存在传递依赖。即不能存在：非主键列 A 依赖于非主键列 B，非主键列 B 依赖于主键的情况。

20.了解分布式锁么
分布式锁是控制分布式系统之间的同步访问共享资源的一种方式。
对于分布式锁的目标，我们必须首先明确三点：
①任何一个时间点必须只能够有一个客户端拥有锁。
②不能够有死锁，也就是最终客户端都能够获得锁，尽管可能会经历失败。
③错误容忍性要好，只要有大部分的Redis实例存活，客户端就应该能够获得锁。 分布式锁的条件 互斥性：分布式锁需要保证在不同节点的不同线程的互斥 可重入性：同一个节点上的同一个线程如果获取了锁之后，能够再次获取这个锁。 锁超时：支持超时释放锁，防止死锁 高效，高可用：加锁和解锁需要高效，同时也需要保证高可用防止分布式锁失效，可以增加降级。 支持阻塞和非阻塞：可以实现超时获取失败，tryLock(long timeOut) 支持公平锁和非公平锁
分布式锁的实现方案 1、数据库实现（乐观锁） 2、基于zookeeper的实现 3、基于Redis的实现（推荐）

21.用 Python 实现一个 Reids 的分布式锁的功能

SETNX lock.foo <current Unix time + lock timeout + 1>

22.写一段 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 add_index(self):
        """
          通过create_index添加索引
        """
        self.db1.test.create_index([('name', pymongo.ASCENDING)], unique=True)

    def get_index(self):
        """
          查看索引列表
        """
        indexlist=self.db1.test.list_indexes()
        for index in indexlist:
            print(index)

if __name__ == '__main__':
    m = Mongo()
    m.add_index()
    print(m.get_index())