s[::-1]
''.join(reversed(str(n))  其中reversed返回迭代器对象

float('inf')

a = [1, 2, 3]
b = a
del a

a = [0, 2, 2, 3]
a.remove(2)	#remove只是列表的一个方法
print(a)  # 输出 [0, 2, 3]

s.strip()
s=' '.join(t)
s.replace('  ',' ')		
ls=s.split()	#将字符串分割为单词列表

# 字典的键可以是整数
my_dict = {1: 'one', 2: 'two', 3: 'three'}
# 字典的键可以是字符串
another_dict = {'apple': 3, 'banana': 5, 'orange': 2}
# 字典的键可以是元组
yet_another_dict = {(1, 2): 'tuple_key', (3, 4): 'another_tuple_key'}
# 使用元组作为键
my_dict = {('John', 25): 'value1', ('Alice', 30): 'value2'}

my_dict = {'apple': 10, 'orange': 5, 'banana': 20, 'grape': 7}

sorted_dict = dict(sorted(my_dict.items(), key=lambda x: x[0]))

print(sorted_dict)

def get_key(item):
    return item[0]

names = ['Bob','Tom','alice','Jerry','Wendy','Smith']

# 列表推导式
new=[ name.upper() for name in names]
multiples = [i for i in range(30) if i % 3 == 0]
#字典推导式
dic={name:len(name) for name in names}
# 集合推导式
sett={name.upper() for name in names}
# 元组推导式
tt=(name.lower() for name in names)

import logging

logging.basicConfig(filename="test.log",level=logging.INFO)
logging.debug('debug message')
logging.info("info message")
logging.warn('warn message')
logging.error("error message")
logging.critical('critical message')

# 
import os
import sys
dir(os)
help(sys)
#os 系统交互，环境变量
path='E:\\'
os.name
os.system('mkdir temp.foo')
os.getcwd()
os.listdir(path)
os.path.getmtime(path)
os.stat(path)

#日常的文件和目录管理任务，:
import shutil
shutil.copyfile('temp.txt', 'temp.out')
#shutil.move('temp.pkl', 'temp.move')
#从目录通配符搜索中生成文件列表:
import glob
glob.glob('*py')
#命令行参数
print(sys.argv)
sys.stdin
#字符串正则匹配
import re
re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
# 数学math模块
import math
math.cos(math.pi/4)
math.log(1024,2)
#random提供了生成随机数的工具
import random
random.choice([1,2,3])
random.sample(range(100), 10)
random.random()
random.randrange(6)
#访问 互联网
#用于处理从 urls 接收的数据的 urllib.request
from urllib.request import urlopen
for line in urlopen('http://43.192.14.14'):
    line=line.decode('utf-8')
    print(line)
# requests更加简洁
import requests
res=requests.get('http://42.193.14.14/')
print(res.headers)
# 日期和时间datetime模块
import datetime
current_datetime=datetime.datetime.now()
print(current_datetime)
formatted_datetime = current_datetime.strftime("%Y-%m-%d %H:%M:%S")
print(formatted_datetime)

# 时间模块
import time
current_time = time.time()  # 获取当前时间戳（从1970年1月1日开始的秒数）
print("Current Time:", current_time)
formatted_time = time.ctime(current_time)  # 格式化为可读的时间字符串
print("Formatted Time:", formatted_time)

print("Start")
time.sleep(3)  # 等待3秒
print("End after 3 seconds")


#数据压缩
import zlib
s=b'witch which has which witches wrist watch'
len(s)
t=zlib.compress(s)
len(t)
zlib.crc32(s)
# JSON
import json
data = {
    'no' : 1,
    'name' : 'Runoob',
    'url' : 'http://www.runoob.com'
}
json_str=json.dumps(data)
print(repr(data))
print(json_str)

class  MyIterator:
    def __init__(self,data):
        self.data=data
        self.index=0
    # 返回迭代器自身
    def __iter__(self):
        return self
    # 返回下一个元素
    def __next__(self):
        if self.index<len(self.data):
            result = self.data[self.index]
            self.index += 1
            return result
        else:
            raise StopIteration
my_list=[1,2,3,4]
my_custom_iterator = MyIterator(my_list)
for element in my_custom_iterator:
    print(element)

length=list(map(lambda x:len(x),names))
small=list(filter(lambda x:len(x)>4, names))
product=reduce(lambda x,y:x*y, nums, 1)

knights = {'gallahad': 'the pure', 'robin': 'the brave'}
for k,v in knights.items():
    print(k,v)

for i,v in enumerate(names):
    print(i,v)

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q,a in zip(questions,answers):
    print("Que:{} Ans:{}".format(q, a))

for f in sorted(set(names)):
    print(f)

f=open('temp.txt','w')
f.write(' python open file \n nandwnowdoi')
f.close()

f=open('temp.txt','r')
str=f.read()
ls=f.readlines()
print(str,ls)

import pickle
data1 = {'a': [1, 2.0, 3, 4+6j],
         'b': ('string', u'Unicode string'),
         'c': None}
pkl_file=open('temp.pkl','wb')
pickle.dump(data1, pkl_file)
pkl_file.close()

pkl_file = open('temp.pkl', 'rb')
data2=pickle.load(pkl_file)
pkl_file.close()

def outer_function():
    outer_variable = 10

    def inner_function():
        nonlocal outer_variable
        outer_variable = 20

    inner_function()
    print(outer_variable)

outer_function()

s.add(x)
s.remove( x )
s.clear()

for i in range(6):
    print(i)
    i += 1  # 这一行对循环没有影响

def my_generator():
    yield 1
    yield 2
    yield 3
gen = my_generator()
print(next(gen))  # 输出: 1
print(next(gen))  # 输出: 2
print(next(gen))  # 输出: 3

gen = (x for x in range(1, 4))
print(next(gen))  # 输出: 1
print(next(gen))  # 输出: 2
print(next(gen))  # 输出: 3

def cache(func):
    # 缓存计算结果的字典
    cached_results = {}
    
    # 装饰器的包装函数
    def wrapper(*args, **kwargs):
        # 使用输入参数构建唯一的键
        key = (args, tuple(kwargs.items()))
        
        # 如果缓存中不存在对应键的结果
        if key not in cached_results:
            print('不在缓存中')
            # 调用被装饰的函数，并将结果缓存起来
            cached_results[key] = func(*args, **kwargs)
        
        # 返回缓存中的结果
        return cached_results[key]
    
    # 返回装饰后的函数
    return wrapper
@cache
def add(x, y):
    print("Calculating result...")
    return x + y

result1 = add(2, 3)  # 计算并缓存结果
result2 = add(2, 3)  # 直接从缓存中获取结果，不再计算
result3 = add(4, 5)  # 计算并缓存新的结果

print(result1)  # 输出: 5
print(result2)  # 输出: 5
print(result3)  # 输出: 9

import threading
import time
exitFlag = 0

class MyThread(threading.Thread):
    def __init__(self,threadID,name,delay):
        threading.Thread.__init__(self)
        self.threadID=threadID
        self.name = name
        self.delay = delay
    def run(self):
        print ("开始线程：" + self.name)
        print_time(self.name, self.delay, 5)
        print ("退出线程：" + self.name)
def print_time(threadName, delay, counter):
    while counter:
        if exitFlag:
            threadName.exit()
        time.sleep(delay)
        print ("%s: %s" % (threadName, time.ctime(time.time())))
        counter -= 1
        
# 创建新线程
thread1 = MyThread(1, "Thread-1", 1)
thread2 = MyThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("退出主线程")

import threading
shared=0
mutex=threading.Lock()
def modift_shared():
    global shared
    with mutex:
        # 互斥量保护区
        shared+=1   
threads=[]
for _ in range(5):
    thread=threading.Thread(target=modift_shared)
    thread.start()
    threads.append(thread)
for thread in threads:
    thread.join()
print("Final shared resource value:", shared)

import threading

shared_resource = 0
semaphore = threading.Semaphore(value=2)  # 允许同时两个线程访问

def modify_shared_resource():
    global shared_resource
    with semaphore:
        # 信号量保护的临界区
        shared_resource += 1

# 创建多个线程并启动
threads = []
for _ in range(5):
    thread = threading.Thread(target=modify_shared_resource)
    thread.start()
    threads.append(thread)

# 等待所有线程执行完成
for thread in threads:
    thread.join()

print("Final shared resource value:", shared_resource)

import threading

event = threading.Event()

def wait_for_event():
    print("Thread 1 is waiting for the event.")
    event.wait()
    print("Thread 1 received the event.")

def set_event():
    print("Thread 2 is setting the event.")
    event.set()

# 创建两个线程并启动
thread1 = threading.Thread(target=wait_for_event)
thread2 = threading.Thread(target=set_event)
thread1.start()
thread2.start()

# 等待两个线程执行完成
thread1.join()
thread2.join()

from abc import ABC, abstractmethod 
class Strategy(ABC): 
	@abstractmethod 
	def issue(self, *params): 
		pass

# 使用深度优先搜索（DFS）计算每一层节点的平均值时，需要额外记录每层的节点值和节点数量。
# 节点携带 深度属性
def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
	result=[]
	level_sum=[]
	level_size=[]
	def dfs(root,depth):
		if not root:
			return
		if depth<len(level_size):
			level_size[depth]+=1
			level_sum[depth]+=root.val
		else:
			level_size.append(1)
			level_sum.append(root.val)
		dfs(root.left,depth+1)
		dfs(root.right,depth+1)
	dfs(root,0)
	# 计算每一层的平均值
	for i in range(len(level_sum)):
		result.append(level_sum[i] / level_size[i])
	return result

# 回溯方法：所有路径
def back_paths(root:TreeNode):
    res=[]
    path=[root.val]
    def backtrace(node):
        if not node.left and not node.right:
            res.append(path[:])
            return 
        if node.left:    
            path.append(node.left.val)
            backtrace(node.left)
            path.pop()
        if node.right:
            path.append(node.right.val)
            backtrace(node.right)
            path.pop()
    backtrace(root)
    return res

# 检查路劲和
def hasPathSum( root: [TreeNode], targetSum: int) -> bool:
    res=[]
    # path是到当前node的路径
    def dfs(node,path):
        if not node:
            return 
        
        path.append(node.val)
        if sum(path)==targetSum:
            res.append(path.copy())
        print(node.val,path)
        
        dfs(node.left,path)
        dfs(node.right,path)
        # 返回上层，弹出当前节点， 和回溯的pop如出一辙
        path.pop()
    dfs(root,[])
    return len(res)>0

res = []    # 存放所欲符合条件结果的集合
path = []   # 存放当前符合条件的结果
def backtracking(nums,cond):             # nums 为选择元素列表, cond 为相关条件参数
    if 遇到边界条件:                  # 说明找到了一组符合条件的结果
        res.append(path[:])         # 将当前符合条件的结果放入集合中
        return

    for i in range(len(nums)):      # 枚举可选元素列表
        path.append(nums[i])        # 选择元素
        backtracking(nums)          # 递归搜索
        path.pop()                  # 撤销选择

backtracking(nums,cond)

class MinStack:

    def __init__(self):
        self.stack=[]
        self.min_stack=[]

    def push(self, val: int) -> None:
        self.stack.append(val)
        if not self.min_stack or val<=self.min_stack[-1]:
            self.min_stack.append(val)

    def pop(self) -> None:
        poped=self.stack.pop()
        if poped==self.min_stack[-1]:
            self.min_stack.pop()

    def top(self) -> int:
        return self.stack[-1]

    def getMin(self) -> int:
        return self.min_stack[-1]

输入: temperatures = [73,74,75,71,69,72,76,73]
输出: [1,1,4,2,1,1,0,0]

for i in nums:
	while stack and n>nums[i]:      
		stack.pop()
		if not stack:
            break
		# 比较元素，pop元素，栈顶元素  如下图
	stack.apped()

def maxDepth(self, root: Optional[TreeNode]) -> int:
    if not root:
        return 0
    stack=[(root,1)]
    maxdp=0
    while stack:
        node,depth=stack.pop(0)
        if depth>maxdp:
            maxdp=depth
        if node.right:
            stack.append((node.right,depth+1))
        if node.left:
            stack.append((node.left,depth+1))

    return maxdp

for ele in list:
	for ....:
		dp[ele]=XXXX.

dp[i][j]=max(dp[i-1][j],dp[i-1][j-stone]+stone)

def lastStoneWeightII(stones):
    total_weight = sum(stones)
    target = total_weight 
    dp = [False] * (target + 1)
    dp[0] = True
	# #stone在序列中的情况下，判断dp[i]
    for stone in stones:
        for i in range(target, stone - 1, -1):
            dp[i] = dp[i] or dp[i - stone]

    for i in range(target, -1, -1):
        if dp[i]:
            return total_weight - 2 * i

dp[j] = max(dp[j], dp[j - stone] + stone)

for i in range(n-1,-1,-1):
	for j in range(i,n):

limit=4
weights=[1,3,4]
values=[15,20,30]
m=len(weights)
n=limit+1

dp=[[0]*n for _ in range(m)]

for i in range(m):
    dp[i][0]=0
for j in range(1,n):
    if j>=weights[0]: 
        dp[0][j]=values[0]
        
for i in range(1,m):
    for j in range(1,n):
        dp[i][j]=dp[i-1][j]
        if j-weights[i]>=0:
            dp[i][j]=max(dp[i][j],dp[i-1][j-weights[i]]+values  [i])
print(dp)

import heapq
# 将列表转换为最小堆
heap = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
heapq.heapify(heap)
min_element = heapq.heappop(heap)

#每次选择最小的元素，放在已排序的部分的末尾。
def selection_sort(nums):
    i,j=0,0
    for i in range(len(nums)):
        min_idx=i
        for j in range(i+1,len(nums)):
            if nums[j]<nums[min_idx]:
                min_idx=j
        nums[min_idx],nums[i]=nums[i],nums[min_idx]
    return nums

#依次比较相邻的元素，将较大的元素交换到右侧。
def bubble_sort(nums):
    i,j=0,0
    n=len(nums)
    for i in range(n):
        for j in range(0,n-i-1):
            if nums[j]>nums[j+1]:
                nums[j],nums[j+1]=nums[j+1],nums[j]
    return nums
# 将每个元素插入到已排序的部分的合适位置。
def insert_sort(nums):
    i,j=0,0
    n=len(nums)
    for i in range(1,n):
        j=i-1
        key=nums[i]
        while j>=0 and key<nums[j]:
            nums[j+1]=nums[j]
            j-=1
        nums[j+1]=key
    return nums
#： 通过选择一个基准元素，将数组分为两部分，然后递归地对每部分进行排序。时间复杂度平均为 O(n log n)，最坏情况为 O(n^2)。
def quick_sort(nums):
    if len(nums)<=1:
        return nums
    base=nums[len(nums)//2]
    left=[x for x in nums if x<base]
    middle=[x for x in nums if x==base]
    right=[x for x in nums if x>base]
    return quick_sort(left)+middle+quick_sort(right)
#它将数组分为两半，对每一半递归地进行排序，然后再将两个有序的子数组合并成一个有序的数组。
def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        left_half = arr[:mid]
        right_half = arr[mid:]

        merge_sort(left_half)
        merge_sort(right_half)

        i = j = k = 0

        # 合并两个有序数组
        while i < len(left_half) and j < len(right_half):
            if left_half[i] < right_half[j]:
                arr[k] = left_half[i]
                i += 1
            else:
                arr[k] = right_half[j]
                j += 1
            k += 1

        # 处理剩余的元素
        while i < len(left_half):
            arr[k] = left_half[i]
            i += 1
            k += 1

        while j < len(right_half):
            arr[k] = right_half[j]
            j += 1
            k += 1

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
merge_sort(arr)
print("归并排序结果:", arr)

res=quick_sort([5,2,8,1,4,3,6])

dfs(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本节点所连接的其他节点) {
        处理节点;
        dfs(图，选择的节点); // 递归
        回溯，撤销处理结果
    }
}

from collections import deque # 双端队列

dir = [(0, 1), (1, 0), (-1, 0), (0, -1)] # 创建方向元素

def bfs(grid, visited, x, y):
  
  queue = deque() # 初始化队列
  queue.append((x, y)) # 放入第一个元素/起点
  visited[x][y] = True # 标记为访问过的节点
  
  while queue: # 遍历队列里的元素
  
    curx, cury = queue.popleft() # 取出第一个元素
    
    for dx, dy in dir: # 遍历四个方向
    
      nextx, nexty = curx + dx, cury + dy
      
      if nextx < 0 or nextx >= len(grid) or nexty < 0 or nexty >= len(grid[0]): # 越界了，直接跳过
        continue
        
      if not visited[nextx][nexty]: # 如果节点没被访问过  
        queue.append((nextx, nexty)) # 加入队列
        visited[nextx][nexty] = True # 标记为访问过的节点

def numIslands(self, grid: List[List[str]]) -> int:
      m, n = len(grid), len(grid[0])
      visited = [[False] * n for _ in range(m)]
      dirs = [(-1, 0), (0, 1), (1, 0), (0, -1)]  # 四个方向
      result = 0

      def dfs(x, y):
          for d in dirs:
              nextx = x + d[0]
              nexty = y + d[1]
              if nextx < 0 or nextx >= m or nexty < 0 or nexty >= n:  # 越界了，直接跳过
                  continue
              if not visited[nextx][nexty] and grid[nextx][nexty] == '1':  # 没有访问过的同时是陆地的
                  visited[nextx][nexty] = True
                  dfs(nextx, nexty)
      
      for i in range(m):
          for j in range(n):
              if not visited[i][j] and grid[i][j] == '1':
                  visited[i][j] = True
                  result += 1  # 遇到没访问过的陆地，+1
                  dfs(i, j)  # 将与其链接的陆地都标记上 true

      return result

   def numIslands(self, grid: List[List[str]]) -> int:
        count=0
        m, n = len(grid), len(grid[0])
        directions = [(0, 1), (1, 0), (-1, 0), (0, -1)] # 创建方向元素
        visited=[[False]*n for _ in range(m)] # 记录访问标志
        
        def bfs(grid,visited,x,y): # 对一个陆地节点进行广度遍历，标记链接的陆地
        
            queue=[] # 初始化队列，访问状态
            queue.append((x,y))
            visited[x][y]=True

            while queue:
                curx,cury=queue.pop(0)
                for direct in directions:
                    next_x=curx+direct[0]
                    next_y=cury+direct[1]
                    if next_x<0 or next_x>=m or next_y<0 or next_y>=n: # 越界跳过
                        continue
                    if not visited[next_x][next_y] and grid[next_x][next_y]=='1': # 符合要求的节点处理
                        visited[next_x][next_y]=True
                        queue.append((next_x,next_y))

        for i in range(m):
            for j in range(n):
                if not visited[i][j] and grid[i][j]=='1':
                    count+=1
                    bfs(grid,visited,i,j)
        return count

class Animal:
    def make_sound(self):
        pass
class Dog(Animal):
    def make_sound(self):
        return "Bark"
class Cat(Animal):
    def make_sound(self):
        return "Meow"
# 函数接受 Animal 类型的参数，但可以传入不同的子类对象
def animal_sound(animal):
    return animal.make_sound()
# 创建不同的子类对象
dog = Dog()
cat = Cat()
# 调用 animal_sound 函数，传入不同的子类对象
print(animal_sound(dog))  # 输出: Bark
print(animal_sound(cat))  # 输出: Meow

def mutiply_by(factor):
    def mutiply(x):
        return x*factor
    return mutiply
double=mutiply_by(2)
triple=mutiply_by(3)
print(double(2))
print(triple(2))

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper
@my_decorator   #相当于 say_hello = my_decorator(say_hello)
def say_hello():
    print('hello')
say_hello()

class MyClass:
    @staticmethod
    def my_static_method(arg1, arg2):
        # 静态方法的实现
        pass
# 调用静态方法，不需要创建类的实例
MyClass.my_static_method(value1, value2)

import matplotlib
import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(mat[:,1], mat[:,2],15.0 * np.array(labels), 15.0*np.array(labels))

plt.show()