三元运算符
代码语言：javascript复制# 统计偶数
if __name__ == '__main__':
pi = [3, 14, 15, 9, 26, 5, 35, 8, 97, 932]
even_count = 0
for i in pi:
even_count = 1 if i % 2 == 0 else 0
assert even_count == 4
# 使用嵌套的三元组表达式统计数字频率，如果是2的倍数加1，如果是4的倍数加2，否则加0
if __name__ == '__main__':
pi = [3, 14, 15, 9, 26, 5, 35, 8, 97, 932]
even_count = 0
for i in pi:
even_count = 2 if i % 4 == 0 else 1 if i % 2 == 0 else 0
assert even_count == 6断言
所谓断言，就是证明，使用 assert 对输入函数输入参数和函数返回结果分别做前校验和后校验
代码语言：javascript复制# 所谓断言，就是证明，使用 assert 对输入函数输入参数和函数返回结果分别做前校验和后校验
def check_param(key_value_map, key):
'''参数校验，断言就是对输入参数的一个证明，这些参数必须符合这些要求
key_value_map: 非空字典
key：非空字符串
'''
#方式1
# assert key_value_map is not None
# assert type(key_value_map) == type({})
# assert key is not None
# assert type(key) == type("")
# 方式2
assert key_value_map is not None and type(key_value_map) == type({})
assert key is not None and type(key) == type("")
# 方式3
assert key_value_map is not None
assert type(key_value_map) == dict
assert key is not None
assert type(key) == str
def get(key_value_map, key):
check_param(key_value_map, key)
return key_value_map.get(key)
def set(key_value_map, key, value):
check_param(key_value_map, key)
key_value_map[key] = value
if __name__ == '__main__':
key_value_map = {}
set(key_value_map, "test", {})
value = get(key_value_map, "test")
print("后校验，返回值必须符合预期")
assert type(value) == type({})
assert value == {}with-as（json文件读写）
代码语言：javascript复制# JSON文件读写
import json
# 实现加载json文件代码
def load_json(file):
with open(file, 'r') as f:
return json.loads(f.read())
# 实现将dict写入json文件的代码
def dump_json(file, obj):
with open(file, 'w') as f:
f.write(json.dumps(obj, indent=2, ensure_ascii=False))
if __name__ == '__main__':
data = {
'test': 1,
}
dump_json('test.json', data)
load_json('test.json')with-as（范围耗时统计类实现）
实现一个范围耗时统计类。 实现了 enter 和 exit 成员的类，可以通过 with as 语法使用，程序进入和离开范围的时候会自动调用 enter 和 exit 方法。
代码语言：javascript复制# 实现一个范围耗时统计类。 实现了 __enter__ 和 __exit__ 成员的类，可以通过 with as 语法使用，
# 程序进入和离开范围的时候会自动调用 __enter__ 和 __exit__ 方法。
import time
# class TimeSpan:
# def __enter__(self):
# self.end = None
# self.start = time.time()
# return self
#
# def __exit__(self, exc_type, exc_val, exc_tb):
# self.end = time.time()
# print('耗时:{}毫秒'.format((self.end-self.start)))
class TimeSpan:
def __enter__(self):
self.end = None
self.start = time.time()
def __exit__(self, exc_type, exc_val, exc_tb):
self.end = time.time()
print('耗时:{}毫秒'.format((self.end-self.start)))
class TimeSpan:
def __enter__(self):
self.start = time.time()
def __exit__(self, exc_type, exc_val, exc_tb):
self.end = time.time()
print('耗时:{}毫秒'.format((self.end-self.start)))
if __name__ == '__main__':
with TimeSpan() as t:
for i in range(0, 1000):
print(i)异常处理
'a.json’文件不存在，下面代码会有异常，请编写异常控制代码，控制异常的最小范围，出现异常正常打印日志和堆栈。
代码语言：javascript复制import json
import traceback
import logging
logger = logging.getLogger(__name__)
def load_json(file):
with open(file, 'r') as f:
return json.loads(f.read())
def test():
try:
ret = load_json('a.json')
return {'err': 'success', 'result': ret}
except Exception as e:
logger.error(f"load json exception:{str(e)}")
logger.error(traceback.format_exc())
return {'err': 'exception'}
if __name__ == '__main__':
test()实现简易的四则运算
Python 的字符串处理, 一个朴实无华的四则运算计算器，批量计算小学生四则运算表达式
代码语言：javascript复制import re
# 实现简易四则运算
def naive_calc(code):
code_lines = [l for l in code.split('n') if l.strip() != '']
for line in code_lines:
ret = re.match("s*(d )([ -*/])(d )s*", line)
left = ret.group(1)
op = ret.group(2)
right = ret.group(3)
if op == ' ':
print('{} {}={}'.format(left, right, int(left) int(right)))
elif op == '-':
print('{}-{}={}'.format(left, right, int(left)-int(right)))
elif op == '*':
print('{}*{}={}'.format(left, right, int(left)*int(right)))
elif op == '/' and right != '0':
print('{}/{}={}'.format(left, right, int(left)/int(right)))
def test():
code = '''
1 2
3 4
5-3
4*3
10/2
'''
naive_calc(code)
if __name__ == '__main__':
test()lambda 表达式
Python 高阶函数编程，使用 lambda 表达式获取key，将list转成dict。
代码语言：javascript复制def list_to_dict(list, key_func):
d = {}
for item in list:
k = key_func(item)
v = item
list = d.get(k)
if list is None:
d[k] = [v]
else:
d[k].append(v)
return d
if __name__ == '__main__':
list = [
{"name": "alice", "age": 100},
{"name": "middle", "age": 100},
{"name": "bob", "age": 200}
]
# 调用 list_to_dict 方法，将 list 转成dict
# 方式一
# def get_key(item):
# return item['age']
# ret = list_to_dict(list, get_key)
# 方式二
# ret = list_to_dict(list, lambda item: item['age'])
# 方式三
get_key = lambda item: item['age']
ret = list_to_dict(list, get_key)
print(ret)文件读写
基本文件读写，写入 “test” 到 “/tmp/test.txt”，再次打开读取
代码语言：javascript复制if __name__ == '__main__':
with open('/tmp/test.txt', 'w') as f:
f.write("test")
with open('/tmp/test.txt', 'r') as f:
print(f.read())一种基于 sha256 的文件分片 hash 计算方式
代码语言：javascript复制import hashlib
def file_piece_sha256(in_file_path, piece_size):
sha256 = hashlib.sha256()
with open(in_file_path, "rb") as in_file:
# 在此实现 hash 计算
while True:
piece = in_file.read(piece_size)
if piece:
sha256.update(piece.hex().encode('utf-8'))
else:
break
return sha256.digest().hex()
if __name__ == '__main__':
ret = file_piece_sha256('file_piece_sha256.py', 128)
print("file hash is: ", ret)常用标准库
Python的标准库(standard library)是Python的一个组成部分，也是Python为的利器，可以让编程事半功倍。 sys, os, math, time, date，json 请在使用的时候查文档，例如日期文档：https://docs.python.org/zh-cn/3/library/datetime.html#datetime.datetime
代码语言：javascript复制# sys, os, math, time, date
# 请在使用的时候查文档，例如日期文档：https://docs.python.org/zh-cn/3/library/datetime.html#datetime.datetime
import sys
import os
import math
import datetime
import time
if __name__ == '__main__':
assert type(sys.argv) == type([])
assert os.path.exists(__file__) == True
assert math.pow(2, 3) == 8
assert type(time.time()) == type(2.3)
assert datetime.now().year >= 2021
# json序列化与反序列化
import json
if __name__ == '__main__':
# 在此实现json序列化和反序列化代码
obj = json.loads(json.dumps({"key": {"items": [1, 2, "test"]}}))
assert obj['key']['items'][2] == "test"字符编解码
二进制只是二进制，取决于怎么编码和解码，unicode 转 utf8
代码语言：javascript复制# 二进制只是二进制，取决于怎么编码和解码，unicode 转 utf8
# -*- coding: UTF-8 -*-
if __name__ == '__main__':
unicode_str = u'二进制只是二进制，取决于怎么编码和解码'
print(unicode_str)
utf8_str = unicode_str.encode('utf-8')
print(utf8_str)
unicode_str_again = utf8_str.decode('utf-8')
assert unicode_str_again == unicode_str本文内容到此结束了， 如有收获欢迎点赞
