软件测试面试中都会问到哪些关于Python的问题？

def foo(num:int) -> None:
print(f"接收到的数字是:{num}")

a: str = "this is string type"

arr = "hello world".split(" ")
new_str = f"{arr[0].capitalize()} {arr[1].capitalize()}"
print(new_str)

"hello world".title()

s1 = "12223".isdigit()
print(s1)
s2 = "12223a".isdigit()
print(s2)
# 结果如下:
# True
# False

s1 = "ilovechina"[::-1]
print(s1)

def strip_function(s1):
    return s1.strip()
s1 = " adabdw "
print(strip_function(s1))

a = "123456"
print(a[-2::])

a = "S".encode("gbk").decode("utf-8", 'ignore')
print(a)

import re
s = "info:xiaoZhang 33 shandong"
res = re.split(r":| ", s)
print(res)

print(" ".join(s.split()))

s = "1,2,3"
print(s.split(","))

print(set(A) & set(B))

print(set(A) ^ set(B))

l = [[1, 2], [3, 4], [5, 6]]
x = [j for i in l for j in i]
print(x)

a = [1, 5, 7, 9]
b = [2, 2, 6, 8]
a.extend(b)
print(a)

import random
    a = [1, 2, 3, 4, 5]
    random.shuffle(a)
    print(a)

{'name':'bob', 'age':18},

{'name':'Carl', 'age':28},

print(sorted(d1, key=lambda x:x["age"]))

  a.update(b)

或者下面字典解包的方式

a = {"A":1, "B":2}
b = {"C":3, "D":4}
print({**a, **b})

d = {'a':'1', 'b':'2'}
print({v:k for k, v in d.items()})

a = ("a", "b")
b = (1, 2)
print(dict(zip(a, b)))

A:{1:0, 2:0, 3:0}
B:{"a":0, "b":0, "c":0}
C:{(1, 2):0, (2, 3):0}
D:{[1, 2]:0, [2, 3]:0}

s = {"A":1, "B":2}
# 方法一:
    dict_new = {value: key for key，value in s.items()}
# 方法二:

    new_s = dict(zip(s.values()，s.keys()))

from itertools import islice
gen = iter(range(10))  # iter()函数用来生成迭代器
# 第一个参数是迭代器，第二个参数起始索引，第三个参数结束索引，不支持负数索引
for i in islice(gen, 0, 4):
print(i)

(i for i in range(3))

abc代表三种情况
    a = b"hello"
    b = bytes("你好", "utf-8")
    c = "你好".encode("utf-8")
    print(a, b, c)

a = (1, 2, 3, [4, 5, 6, 7], 8)
a[2] = 2

a = (1, 2, 3, [4, 5, 6, 7], 8)
a[3][0] = 2

a, b = b, a

# 自定义时间序列化
import json
from datetime import datetime, date

# JSONEncoder 不知道怎么去把这个数据转换成 json 字符串的时候
# ，它就会去调 default()函数,所以都是重写这个函数来处理它本身不支持的数据类型，
# default()函数默#认是直接抛异常的。
class DateToJson(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.strftime('%Y-%m-%d %H:%M:%S')
        elif isinstance(obj, date):
            return obj.strftime('%Y-%m-%d')
        else :
            return json.JSONEncoder.default(self, obj)
        d = {'name': 'cxa', 'data': datetime.now()}
        print(json.dumps(d, cls=DateToJson))

import json
a = json.dumps({"name":"张三"}, ensure_ascii = False)
print(a)

# 文件 A.txt 内容为 ASDCF
# 文件 B.txt 内容为 EFGGTG
with open("A.txt") as f1:
    f1_txt = f1.readline()
with open("B.txt") as f2:
    f2_txt = f2.readline()
f3_txt = f1_txt + f2_txt
f3_list = sorted(f3_txt)
with open("C.txt", "a+") as f:
    f.write("".join(f3_list))
# 输出的文件C的内容为ACDEFFGGGST

import datetime

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

if __name__ == '__main__':
    print(datetime_operate(4))

def mul_operate(num):
    def g(val):
        return num * val
    return g
m = mul_operate(8)
print(m(5))

def strappend(num):
    str = 'first'
    for i in range(num):
    str += str(i)
    return str

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)

# 方法1
    print([i for i in range(1, 101) if i & 0x1 == 0])
# 方法2:测试发现方法二效率更高
    print(list(range(2, 101, 2)))

# 一般访问文件资源时我们会这样处理:
    f = open(
        'c:\test.txt', 'r')
    data = f.read()
    f.close()
# 这样写没有错，但是容易犯两个毛病:
# 1. 如果在读写时出现异常而忘了异常处理。
# 2. 忘了关闭文件句柄
# 以下的加强版本的写法:
    f = open('c:\test.txt', 'r')
    try:
        data = f.read()
    finally:
        f.close()
# 以上的写法就可以避免因读取文件时异常的发生而没有关闭问题的处理了。代码长了一些。
# 但使用 with 有更优雅的写法:
    with open(r'c:\test.txt', 'r') as f:
        data = f.read()
# with 的实现
    class Test:
        def __enter__(self):
            print('__enter__() is call!')
            return self
        def dosomething(self):
            print('dosomethong!')
        def __exit__(self, exc_type, exc_value, traceback):
            print('__exit__() is call!')
            print(f'type:{exc_type}')
            print(f'value:{exc_value}')
            print(f'trace:{traceback}')
            print('__exit()__ is call!')
    with Test() as sample:
        pass
# 当对象被实例化时，就会主动调用__enter__()方法，任务执行完成后就会调用__exit__()方法，
# 另外，注意到，__exit__()方法是带有三个参数的(exc_type, exc_value, traceback),
# 依据上面的官方说明:如果上下文运行时没有异常发生，那么三个参数都将置为 None,
# 这里三个参数由于没有发生异常，的确是置为了 None, 与预期一致.
# 修改后不出异常了
    class Test:
        def __enter__(self):
            print('__enter__() is call!')
            return self
        def dosomething(self):
            x = 1 / 0
            print('dosomethong!')

        def __exit__(self, exc_type, exc_value, traceback):
            print('__exit__() is call!')
            print(f'type:{exc_type}')
            print(f'value:{exc_value}')
            print(f'trace:{traceback}')
            print('__exit()__ is call!')
            return True
    with Test() as sample:
        pass

dic = {'a': 123, 'b': "456", 'c': "liming"}
json_str = json.dumps(dic)
print(json_str)
dic2 = json.loads(json_str)
print(dic2)

# '{"a": 123, "b": "456", "c": "liming"}'
# {'a': 123, 'b': '456', 'c': 'liming'}

我们再来看一个特殊的例子
    import json
    dic = {'a': 123, 'b': "456", 'c': "liming"}
    dic_str = json.loads(str(dic).replace("'", "\""))
    print(dic_str)

   with open('A.txt') as fs:
    count = 0
    for i in fs.read():
    if i.isupper():
    count += 1
    print(count)

# -_- coding: utf-8 -_-
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())

from redis import StrictRedis, ConnectionPool
redis\_url = "redis://:xxxx@112.27.10.168:6379/15"
pool = ConnectionPool.from\_url(redis\_url, decode\_responses=True)
r = StrictRedis(connection\_pool=pool)

conn = pymysql.connect(host='localhost',
                   port=3306, user='root',
                   passwd='1234', db='user', charset='utf8mb4')  # 声明mysql连接对象
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)  # 查询结果以字典的形式
cursor.execute('sql语句字符串')  # 执行sql语句
conn.close()  # 关闭链接

import redis
import sys
def run():
try:
    conn = redis.StrictRedis('192.168.80.41')
    # Python中redis事务是通过pipeline的封装实现的
    pipe = conn.pipeline()
    pipe.sadd('s001', 'a')
    sys.exit()
    # 在事务还没有提交前退出，所以事务不会被执行。
    pipe.sadd('s001', 'b')
    pipe.execute()
    pass

except Exception as err:
    print(err)
    pass
if **name** == "**main**":
run()

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

import time
import redis
from conf.config import REDIS\_HOST, REDIS\_PORT, REDIS\_PASSWORD
class RedisLock:
def __init__(self):
    self.conn = redis.Redis(host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD, db=1)
    self._lock = 0
    self.lock_key = ""
@staticmethod
def my_float(timestamp):
"""
Args:
    timestamp:
Returns:
    float或者0
   如果取出的是None，说明原本锁并没人用，getset已经写入，返回0，可以继续操作。
"""
    if timestamp:
        return float(timestamp)
    else:
        # 防止取出的值为None，转换float报错
        return 0
@staticmethod
def get_lock(cls, key, timeout=10):
    cls.lock_key = f"{key}_dynamic_lock"
    while cls._lock != 1:
        timestamp = time.time() + timeout + 1
        cls._lock = cls.conn.setnx(cls.lock_key, timestamp)
        # if 条件中，可能在运行到or之后被释放，也可能在and之后被释放
        # 将导致 get到一个None，float失败。
        if cls._lock == 1 or (
                time.time() > cls.my_float(cls.conn.get(cls.lock_key)) and
                time.time() > cls.my_float(cls.conn.getset(cls.lock_key, timestamp))):
            break
        else:
           time.sleep(0.3)
@staticmethod
def release(cls):
   if cls.conn.get(cls.lock_key) and time.time() < cls.conn.get(cls.lock_key):
        cls.conn.delete(cls.lock_key)
def redis\_lock\_deco(cls):
def _deco(func):
    def __deco(*args, **kwargs):
        cls.get_lock(cls, args[1])
       try:
            return func(*args, **kwargs)
        finally:
            cls.release(cls)
    return __deco
return _deco
@redis\_lock\_deco(RedisLock())
def my\_func():
print("myfunc() called.")
time.sleep(20)
if **name** == "**main**":
my_func()

# -_- coding: utf-8 -_-
# @Time : 2018/12/28 10:01 AM
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())

from functools import wraps
def log(label):
def decorate(func):
    @wraps(func)
    def _wrap(*args, **kwargs):
        try:
            func(*args, **kwargs)
            print("name", func.__name__)
        except Exception as e:
            print(e.args)
    return _wrap
return decorate
@log("info")
def foo(a, b, c):
print(a + b + c)
print("in foo")
decorate=decorate(foo)
if **name** == '**main**':
foo(1, 2, 3)
decorate()

class Bar:
def __call__(self, *args, **kwargs):
   print('in call')
if **name** == '**main**':
b = Bar()
b()

from types import MethodType, FunctionType
class Bar:
def foo(self):
    pass
def foo2():
pass
def run():
print("foo 是函数", isinstance(Bar().foo, FunctionType))
print("foo 是方法", isinstance(Bar().foo, MethodType))
print("foo2 是函数", isinstance(foo2, FunctionType))
print("foo2 是方法", isinstance(foo2, MethodType))
if **name** == '**main**':
run()
'''
foo是函数,False
foo是方法,True
foo2是函数,True
foo2是方法,False
'''

def iget\_no\_of\_instance(ins\_obj):
return ins_obj.__class__.no_inst
class Kls(object):
no_inst = 0
def __init__(self):
    Kls.no_inst = Kls.no_inst + 1
ik1 = Kls()
ik2 = Kls()
print(iget\_no\_of\_instance(ik1))

class Kls(object):
def __init__(self, data):
    self.data = data
@staticmethod
def check_ind():
    return (IND == 'ON')
def do_reset(self):
    if self.check_ind():
        print('Reset done for:', self.data)
def set_db(self):
   if self.check_ind():
        self.db = 'New db connection'
        print('DB connection made for: ', self.data)
ik1 = Kls(12)
ik1.do\_reset()
ik1.set\_db()

class Person():
def __init__(self):
    self.name = "liming"
    self.age = 12
def show(self):
    print(self.name)
    print(self.age)
def set_name(self):
    setattr(Person, "sex", "男")
def get_name(self):
    print(getattr(self, "name"))
    print(getattr(self, "age"))
    print(getattr(self, "sex"))
def run():
if hasattr(Person, "show"):
    print("判断 Person 类是否含有 show 方法")
    Person().set_name()
    Person().get_name()
if **name** == '**main**':
run()

class Singleton(type):
def __init__(self, *args, **kwargs):
    print("in __init__")
   self.__instance = None
    super(Singleton, self).__init__(*args, **kwargs)
def __call__(self, *args, **kwargs):
    print("in __call__")
   if self.__instance is None:
        self.__instance = super(Singleton, self).__call__(*args, **kwargs)
    return self.__instance
class Foo(metaclass=Singleton):

pass  # 在代码执行到这里的时候，元类中的__new__方法和__init__方法其实已经被执行了，而不是在 Foo 实例化的时候执行。且仅会执行一次。
foo1 = Foo()
foo2 = Foo()
print(foo1 is foo2)

a = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
print(list(filter(lambda x: x % 2 == 1, a)))

def post():
print("this is post")
print("想不到吧")
class Http():
@classmethod
def get(self):
    print("this is get")
def main():
Http.get = post  # 动态的修改了 get 原因的功能，
if **name** == '**main**':
main()
Http.get()

import re
source = "<html><h1>www.baidu.com</h1></html>"
pat = re.compile("<html><h1>(.\*?)</h1></html>")
print(pat.findall(source)0)

import re
s = "张明 98 分"
print(re.sub(r"\d+", "100", s))

import re
s = "<html><div>文本 1</div><div>文本 2</div></html>"
pat1 = re.compile(r"\<div>(.\*?)\</div>")
print(pat1.findall(s))
pat2 = re.compile(r"\<div>(.\*)\</div>")
print(pat2.findall(s))
# 输出
# '文本 1', '文本 2'
# '文本 1</div><div>文本 2'

r"^a-zA-Z0-9+a-zA-Z0-9\_.+-+@a-zA-Z0-9-+.a-zA-Z0-9-.+$"

import re
plt = re.compile(r"^a-zA-Z0-9+a-zA-Z0-9\_.+-+@a-zA-Z0-9-+.a-zA-Z0-9-.+$")
b = plt.findall('adas+fefe.we@qq.com.cn')
print(b)
网上找了个验证邮件地址的通用正则表达式(符合RFC5322标准）
(?:a-z0-9!#$%&'\*+/=?^\_`{|}~-+(?:.a-z0-9!#$%&'\*+/=?^\_`{|}~-+)_|"(?:\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f|\\x01-\x09\x0b\x0c\x0e-\x7f)_")@(?:(?:a-z0-9?.)+a-z0-9?|[(?:(?:250-5|20-4|01?0-9?).){3}(?:250-5|20-4|01?0-9?|a-z0-9-\*a-z0-9:(?:\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f|\\x01-\x09\x0b\x0c\x0e-\x7f)+)])

def foo():
pass

a = 2
b = 5
# 普通写法
if a > b:
val = True
else :
val = False
# 改为三元运算符后
val = a if a > b else b
print(val)  # 5

from string import ascii\_lowercase
s = ascii\_lowercase
for index, value in enumerate(s):
print(index, value)

n = 0
def foo():
global n
n = 100
foo()
print(n)
x = 0

from pathlib import Path， PurePath
p = Path('.')
# 列出子目录
for x in p.iterdir():
print(f"path:{x},is_dir:{x.is_dir()}")
# 路径拼接
> p = PurePath('/etc')
> p / 'init.d' / 'apache2'
PurePosixPath('/etc/init.d/apache2')
> q = PurePath('bin')
> '/usr' / q
PurePosixPath('/usr/bin')

try:
1 / 0
except ZeroDivisionError as e:
print(e.args)

import sys
sys.setrecursionlimit(1500)  # set the maximum depth as 1500

print(isinstance(True, int))

# assert(）方法，断言成功，则程序继续执行，断言失败，则程序报错
# 断言能够帮助别人或未来的你理解代码，
# 找出程序中逻辑不对的地方。一方面，
# 断言会提醒你某个对象应该处于何种状态，
# 另一方面，如果某个时候断言为假，
# 会抛出 AssertionError 异常，很有可能终止程序。
def foo(a):
    assert a == 2, Exception("不等于 2")
    print("ok", a)
if __name__ == '__main__':
    foo(1)

a = ('a', 1), ('b', 2), ('c', 3), ('d', 4)
a\_1 = list(map(lambda x:x0, a))

import pprint
pprint.pprint("this is pprint")

a = 7
a += 1
print(a)
a -= 1
print(a)
a \*= 2
print(a)
a /= 2
print(a)
a \*\*= 2
print(a)
a //= 3
print(a)
a %= 4
print(a)

print(False and True)  # False
print(7 < 7 or True)  # True
print(not 2 == 2)  # False

a = 0011
1100
b = 0000
1101
-----------------
a & b = 0000
1100
a | b = 0011
1101
a ^ b = 0011
0001
~a = 1100
0011
enter
image
description
here

# 对变量 a,b,c 声明并赋值
a, b, c = 1, 2, 3

AList = 1, 2, 3
BSet = {1, 2, 3}

def binary\_search(arr, target):
n = len(arr)
left = 0
right = n - 1
while left <= right :
mid = (left + right) // 2
if arr[mid] < target:
    left = mid + 1
elif arr[mid] > target:
    right = mid - 1
else :
    print(f"index:{mid},value:{arr[mid]}")
    return True
return False
if **name** == '**main**':
l = [1, 3, 4, 5, 6, 7, 8]
binary_search(l, 8)

"""
通过 new 函数实现简单的单例模式。
"""
class Book:
def __new__(cls, title):
    if not hasattr(cls, "_ins"):
        cls._ins = super().__new__(cls)
        print('in __new__')
    return cls._ins
def __init__(self, title):
    print('in __init__')
    super().__init__()
    self.title = title
if **name** == '**main**':
b = Book('The Spider Book')
b2 = Book('The Flask Book')
print(id(b))
print(id(b2))
print(b.title)
print(b2.title)

def fibonacci(num):
a, b = 0, 1
l = [a, b]
for i in range(num):
    a, b = b, a + b
    l.append(b)
return l
if **name** == '**main**':
print(fibonacci(10))

"""
从头扫到尾，只要当前元素值与下标不同，就做一次判断,numbersi与 numbers[numbersi]，相等就认为找到了重复元素，返回 true,否则就交换两者，继续循环。直到最后还没找到认为没找到重复元素。
"""
# -_- coding:utf-8 -_-
class Solution:
def duplicate(self, numbers):
    if numbers is None or len(numbers) <= 1:
        return False
    use_set = set()
    duplication = {}
    for index, value in enumerate(numbers):
        if value not in use_set:
            use_set.add(value)
        else:
            duplication[index] = value
    return duplication
if **name** == '**main**':
s = Solution()
d = s.duplicate([1, 2, -3, 4, 4, 95, 95, 5, 2, 2, -3, 7, 7, 5])
print(d)

def find\_single(l :list):
result = 0
for v in l:
    result ^= v
    if result == 0:
        print("没有落单元素")
    else :
        print("落单元素", result)
if **name** == '**main**':
l = [1, 2, 3, 4, 5, 6, 2, 3, 4, 5, 6]
find_single(l)

def bubble\_sort(arr):
n = len(arr)
for i in range(n - 1):
    for j in range(n - i - 1):.
        if arr[j] > arr[j + 1]:
            arr[j], arr[j + 1] = arr[j + 1], arr[j]
if **name** == '**main**':
l = [1, 2, 3, 4, 5, 55, 6, 3, 4, 5, 6]
bubble_sort(l)
print(l)

def quick\_sort(arr, first, last):
if first >= last:
return
mid_value = arr[first]
low = first
high = last
while low < high:
    while low < high and arr[high] >= mid_value:
        high -= 1  # 游标左移
        arr[low] = arr[high]
while low < high and arr[low] < mid_value:
    low += 1
    arr[high] = arr[low]
    arr[low] = mid_value
quick\_sort(arr, first, low - 1)
quick\_sort(arr, low + 1, last)
if **name** == '**main**':
l = [1, 2, 3, 4, 5, 55, 6, 3, 4, 5, 6]
quick_sort(l, 0, len(l) - 1)
print(l)

"""
对应于该图的拓扑排序。每一个有向无环图都至少存在一种拓扑排序。
"""
import pysnooper
from typing import Mapping
@pysnooper.snoop()
def topological\_sort(graph:Mapping):
# in\_degrees = {'a': 0, 'b': 0, 'c': 0, 'd': 0, 'e': 0, 'f': 0}
in_degrees = dict((u, 0) for u in graph)
for u in graph:
    for v in graph[u]:  # 根据键找出值也就是下级节点
        in_degrees[v] += 1  # 对获取到的下级节点的入度加 1
# 循环结束之后的结果: {'a': 0, 'b': 1, 'c': 1, 'd': 2, 'e': 1, 'f': 4}
Q = [u for u in graph if in_degrees[u] == 0]  # 入度为 0 的节点
in_degrees_zero = []
while Q:
    u = Q.pop()  # 默认从最后一个移除
    in_degrees_zero.append(u)  # 存储入度为 0 的节点
    for v in graph[u]:
        in_degrees[v] -= 1  # 删除入度为 0 的节点，以及移除其指向
        if in_degrees[v] == 0:
        Q.append(v)
return in_degrees_zero
if **name** == '**main**':
# 用字典的键值表示图的节点之间的关系，键当前节点。值是后续节点。
graph_dict = {
        'a': 'bf',  # 表示 a 指向 b 和 f
        'b': 'cdf',
        'c': 'd',
        'd': 'ef',
        'e': 'f',
        'f': ''}
t = topological_sort(graph_dict)
print(t)

"""
二进制加法
"""
def binary\_add(a:str, b: str):
return bin(int(a, 2) + int(b, 2))[2:]
if **name** == '**main**':
num1 = input("输入第一个数，二进制格式:\n")
num2 = input("输入第二个数，二进制格式:\n")
print(binary_add(num1, num2))

"""
有一组“+”和“-”符号，要求将“+”排到左边，“-”排到右边，写出具体的实现方法。
如果让+等于 0，-等于 1 不就是排序了么。
"""
from collections import deque
from timeit import Timer
s = "++++++----+++----"
# 方法一
def func1():
new_s = s.replace("+", "0").replace("-", "1")
result = "".join(sorted(new_s)).replace("0", "+").replace("1", "-")
return result
# 方法二
def func2():
q = deque()
left = q.appendleft
right = q.append
for i in s:
    if i == "+":
        left("+")
    elif i == "-":
        right("-")
# 方法三
def func3():
data = list(s)
start_index = 0
end_index = 0
count = len(s)
while start_index + end_index < count:
    if data[start_index] == '-':
        data[start_index], data[count - end_index - 1] = data[count - end_index - 1], data[start_index]
        end_index += 1
    else :
        start_index += 1
return "".join(data)
if **name** == '**main**':
timer1 = Timer("func1()", "from __main__ import func1")
print("func1", timer1.timeit(1000000))
timer2 = Timer("func2()", "from __main__ import func2")
print("func2", timer2.timeit(1000000))
timer3 = Timer("func3()", "from __main__ import func3")
print("func3", timer3.timeit(1000000))
# 1000000 测试结果
# func1 1.39003764
# func2 1.593012875
# func3 3.3487415590000005
# func1 的方式最优，其次是 func2

"""单链表反转"""
class Node:
def __init__(self, val=None):
    self.val = val
    self.next = None
class SingleLinkList:
def __init__(self, head=None):
    """链表的头部"""
    self._head = head
def add(self, val:int):
"""
给链表添加元素
:param val: 传过来的数字
:return:
"""
    # 创建一个节点
    node = Node(val)
    if self._head is None:
        self._head = node
    else :
        cur = self._head
    while cur.next is not None:
        cur = cur.next  # 移动游标
        cur.next = node  # 如果 next 后面没了证明以及到最后一个节点了
def traversal(self):
if self._head is None:
    return
else :
    cur = self._head
    while cur is not None:
    print(cur.val)
    cur = cur.next
def size(self):
"""
获取链表的大小
:return:
"""
count = 0
if self._head is None:
    return count
else :
    cur = self._head
    while cur is not None:
    count += 1
    cur = cur.next
    return count
def reverse(self):
"""单链表反转思路:
让 cur.next 先断开即指向 none，指向设定 pre 游标指向断开的元素，然后cur.next 指向断开的元素，再把开始 self._head 再最后一个元素的时候.
:return:
"""
if self._head is None or self.size() == 1:
    return
else :
    pre = None
    cur = self._head
    while cur is not None:
        post = cur.next
        cur.next = pre
        pre = cur
        cur = post
        self._head = pre  # 逆向后的头节点
if **name** == '**main**':
single_link = SingleLinkList()
single_link.add(3)
single_link.add(5)
single_link.add(6)
single_link.add(7)
single_link.add(8)
print("对链表进行遍历")
single_link.traversal()
print(f"size:{single_link.size()}")
print("对链表进行逆向操作之后")
single_link.reverse()
single_link.traversal()

# Definition for singly-linked list.
class ListNode:
def __init__(self, x):
    self.val = x
    self.next = None
class Solution:
def getIntersectionNode(self, headA, headB):
"""
:tye head1, head1: ListNode
:rtye: ListNode
"""
if headA is not None and headB is not None:
    cur1, cur2 = headA, headB
while cur1 != cur2:
    cur1 = cur1.next if cur1 is not None else headA
    cur2 = cur2.next if cur2 is not None else headB
return cur1

from queue import Queue
# 使用 2 个队列实现
class MyStack:
def __init__(self):
    """
    Initialize your data structure here.
    """
    # q1 作为进栈出栈，q2 作为中转站
    self.q1 = Queue()
    self.q2 = Queue()
def push(self, x):
    """
    Push element x onto stack.
    :type x: int
    :rtype: void
    """
    self.q1.put(x)
def pop(self):
    """
    Removes the element on top of the stack and returns that element.
    :rtype: int
    """
    while self.q1.qsize() > 1:
        self.q2.put(self.q1.get())  # 将 q1 中除尾元素外的所有元素转到 q2 中
        if self.q1.qsize() == 1:
            res = self.q1.get()  # 弹出 q1 的最后一个元素
            self.q1, self.q2 = self.q2, self.q1  # 交换 q1,q2
    return res
def top(self):
    """
    Get the top element.
    :rtype: int
    """
    while self.q1.qsize() > 1:
        self.q2.put(self.q1.get())  # 将 q1 中除尾元素外的所有元素转到 q2 中
        if self.q1.qsize() == 1:
            res = self.q1.get()  # 弹出 q1 的最后一个元素
            self.q2.put(res)  # 与 pop 唯一不同的是需要将 q1 最后一个元素保存到 q2 中
            self.q1, self.q2 = self.q2, self.q1  # 交换 q1,q2
    return res
def empty(self):
    """
    Returns whether the stack is empty.
    :rtype: bool
    """
    return not bool(self.q1.qsize() + self.q2.qsize())  # 为空返回 True，不为空返回 False
# 使用 1 个队列实现
class MyStack2(object):
    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.sq1 = Queue()
    def push(self, x):
    """
    Push element x onto stack.
    :type x: int
    :rtype: void
    """
        self.sq1.put(x)
    def pop(self):
        """
        Removes the element on top of the stack and returns that element.
        :rtype: int
        """
        count = self.sq1.qsize()
        if count == 0:
            return False
        while count > 1:
            x = self.sq1.get()
            self.sq1.put(x)
            count -= 1
        return self.sq1.get()
def top(self):
    """
    Get the top element.
    :rtype: int
    """
    count = self.sq1.qsize()
    if count == 0:
        return False
    while count:
        x = self.sq1.get()
        self.sq1.put(x)
        count -= 1
    return x
def empty(self):
    """
    Returns whether the stack is empty.
    :rtype: bool
    """
    return self.sq1.empty()
if __name__ == '__main__':
    obj = MyStack2()
    obj.push(1)
    obj.push(3)
    obj.push(4)
    print(obj.pop())
    print(obj.pop())
    print(obj.pop())
    print(obj.empty())

# -_- coding:utf-8 -_-
from heapq import \*
class Solution:
def __init__(self):
    self.maxheap = []
    self.minheap = []
def Insert(self, num):
    if (len(self.maxheap) + len(self.minheap)) & 0x1:  # 总数为奇数插入最大堆
        if len(self.minheap) > 0:
            if num > self.minheap[0]:  # 大于最小堆里的元素
                heappush(self.minheap, num)  # 新数据插入最小堆
                heappush(self.maxheap, -self.minheap[0])  # 最小堆中的最小插入最大堆
                heappop(self.minheap)
            else :
                heappush(self.maxheap, -num)
        else :
            heappush(self.maxheap, -num)
    else :  # 总数为偶数 插入最小堆
        if len(self.maxheap) > 0:  # 小于最大堆里的元素
            if num < -self.maxheap[0]:
                heappush(self.maxheap, -num)  # 新数据插入最大堆
                heappush(self.minheap, -self.maxheap[0])  # 最大堆中的最大元素插入最小堆
                heappop(self.maxheap)
            else :
                heappush(self.minheap, num)
        else :
            heappush(self.minheap, num)
def GetMedian(self, n=None):
    if (len(self.maxheap) + len(self.minheap)) & 0x1:
        mid = self.minheap[0]
    else :
        mid = (self.minheap[0] - self.maxheap[0]) / 2.0
    return mid
if **name** == '**main**':
s = Solution()
s.Insert(1)
s.Insert(2)
s.Insert(3)
s.Insert(4)
print(s.GetMedian())

class TreeNode:
def __init__(self, x):
    self.val = x
    self.left = None
    self.right = None
class Solution:
count = 0
nodeVal = 0
def kthSmallest(self, root, k):
    """
    :type root: TreeNode
    :type k: int
    :rtype: int
    """
    self.dfs(root, k)
    return self.nodeVal
def dfs(self, node, k):
    if node != None:
        self.dfs(node.left, k)
        self.count = self.count + 1
    if self.count == k:
        self.nodeVal = node.val
        # 将该节点的左右子树置为 None,来结束递归，减少时间复杂度
        node.left = None
        node.right = None
        self.dfs(node.right, k)

from lxml import html
source = '''
< div class ="nam" > < span > 中国 < / span > < / div >
'''
root = html.fromstring(source)
\_content = root.xpath("string(//div@class='nam')")
if \_content and isinstance(\_content, list):
content = _content[0]
elif isinstance(\_content, str):
content = _content
print(content)