【代码】小问题，小技巧。。_隐式地创建副本-优快云博客

本文深入探讨Python的高级编程技巧，包括循环中修改序列、装饰器的正确使用、异常处理、多线程安全问题、进程锁的使用、以及Python抽象类的实现。同时，文章提供了实用的代码示例，如利用装饰器实现缓存、多层字典的初始化、以及列表排序技巧。

pytho的if，for等代码块是没有单独的block作用域的：Python循环语句中的索引变量作用域

若要在循环内部修改正在遍历的序列（例如复制某些元素），建议您首先制作副本。在序列上循环不会隐式地创建副本。切片表示法使这尤其方便:

>>> words = ['cat', 'window', 'defenestrate']
>>> for w in words[:]:  # Loop over a slice copy of the entire list.
...     if len(w) > 6:
...         words.insert(0, w)
...
>>> words
['defenestrate', 'cat', 'window', 'defenestrate']

类似的，如果需要循环删除list元素时，正序遍历删除remove时容易发生越界、漏删的等问题，此时需要使用切片制作副本，但需要额外空间，不如倒序遍历pop删除，

a
[1, 2, 3]
b
[4, 5, 6]
zipped = zip(a, b)
zip(*zipped)
<zip object at 0x0000000003643DC8>
list(zip(*zipped))
[]
zipped = list(zip(a, b))
zip(*zipped)
<zip object at 0x00000000036434C8>
list(zip(*zipped))
[(1, 2, 3), (4, 5, 6)]

装饰器不影响被装饰函数传参，或改变传入参数（第一个）：

def hello(f):
    def name(*args, **kw):
        *args, = ('hello ' + args[0] + '.',)
        # 这里args由元组变成列表，（*args是字符串）但能实现功能
        return f(*args, **kw)
    return name

    
# 添加功能：say 'hello' to 'w', adding '.'
@hello
def f(w):
    print(w)
    
运行结果：
f('world')
hello world.

# 如果是传递两个参数：
@hello
def g(person, content):
    print(person, content)
g('world', content='ok')
hello world. ok

通过赋值给装饰器，wraps保存被装饰函数（或类）的属性，如__name__， __doc__属性

from functools import wraps
def hello(f):
    @wraps(f)
    def name(*args, **kw):
        *args, = ('hello ' + args[0] + '.',)
        return f(*args, **kw)
    return name
    
@hello
def f(w):
    print(w)
    
print(f.__name__)

装饰器带参数（多嵌套一层即可），实现计数器功能

import time
from functools import wraps

# 装饰器工厂
def timer(func=None):
    # 装饰器
    def deco(f):
        @wraps(f)
        # 装饰工具
        def inner(*args, **kw):
            start = time.time()
            if f.__name__ == func:
                f(*args, **kw)
                print('%s cost %.2f s' % (func,float(time.time()-start)))
            return f(*args, **kw)

        return inner
    return deco


@timer(func='fun1')
def fun1():
    time.sleep(0.11)


@timer(func='fun2')
def fun2():
    time.sleep(0.22)


fun1()
fun2()

导入模块__import__

>>> time = __import__('time')
>>> time
<module 'time' (built-in)>

为了暴露某些模块，方便使用，包的__intit__.py文件导入子包子模块（以及方法）

# from .子包 import 子包的模块
from 当前包.子包 import 子包的模块

# from .子包.子包的模块 import 子包的模块的方法
from 当前包.子包.子包的模块 import 子包的模块的方法

from 当前包 import 子模块
from 当前包.子模块 import 子模块的方法

子包导入大包的模块：

from 大包.大包的模块 import 大包的模块的方法

也可以相对导入，但是路径不能到大包之外：

from . .. ... import 模块
from . .. ...模块 import 方法

异常只能捕捉一次，被最近的except捕捉

def f():
    try:
        a = 2/0
    finally:
        pass
    
try:
    f()
except:
    print('return to normal')
    
return to normal

def f():
    try:
        a = 2 / 0
    except Exception as e:
        print(e)
    finally:
        pass
try:
    f()
except:
    print('return to normal')
    
division by zero

重写初始化方法


class A:
    def __init__(self, x):
        self.x = x+1


class B(A):
    def __init__(self, x,  y, z):
        super().__init__(x)
        #  或者是 A.__init__(self,x)
        # self.x = x 这一句代表是否重写父类初始化方法
        self.y = y
        self.z = z


b = B(11, 22, 33)
print(b.x, b.y, b.z)

repr不改变（保护）原字符串内的对象

s = '1+1'

ss = repr(s)
ss
"'1+1'"
eval(ss)
'1+1'
eval(eval(ss))
2

ss = str(s)
ss
'1+1'
eval(ss)
2

__repr__在运算符重载中的应用

class N:
    def __init__(self, v):
        self.v = v

    def __repr__(self):
        return 'N(%s)' % self.v

    def __sub__(self, other):
        for i in other.v:
            if i in self.v[:]:
                self.v = self.v.replace(i, '')
        return N(self.v)


n1 = N('113322')
n2 = N('21')
print(n1-n2)
N(33)

可迭代对象与迭代器的使用，参考《fluent Python 14.3 典型的迭代器》

class Fib:
    def __init__(self, n):
        self.n = n

    # 可迭代对象的__iter__返回迭代器FibIter的实例
    def __iter__(self):
        return FibIter(self.n)


class FibIter:
    def __init__(self, n):
        self.n = n
        self.a = 1
        self.b = 0
        self.i = 1

    # 迭代器的__next__的return每次产出元素，最终StopIteration
    def __next__(self):
        if self.i > self.n:
            raise StopIteration
        self.a, self.b = self.a + self.b, self.a
        self.i += 1
        return self.b

    # 迭代器的__iter__返回迭代器本身
    # 迭代器的__iter__也可以是生成器函数(使用yield产出元素即可)，此时迭代器是生成器对象
    def __iter__(self):
        return self


print(iter(FibIter(6)))
it = iter(Fib(6))
print(next(it))

for i in Fib(6):
    print(i)
print([x for x in Fib(10)])

print(sum(Fib(10)))

旋转显示进度小动画

import sys
import time
ls = ['-','\\','|','/']
while True:
    for i in ls:
        sys.stdout.write(i)
        sys.stdout.flush()
        sys.stdout.write('\r')
        sys.stdout.write(' ')
        time.sleep(0.1)

Python在Window中使用multiprocessing模块
p = Process(target=test) 前面加上 if __name__=="__main__"： 语句，才不会报错

ubuntu安装vim
这编辑器碉堡，当时看到dd,yy,p这些命令，卧槽简直惊为天人，好了不BB了，vi tab，可以看到目前系统中只安装了vi和vim.tiny，那么
安装sudo apt-get install vim-gtk
配置sudo vim /etc/vim/vimrc
Vim入门教程

set nu                     
set tabstop=4                
set shiftwidth=4
set nobackup              
set ruler                  
set autoindent

inoremap ( ()<ESC>i
inoremap [ []<ESC>i
inoremap { {}<ESC>i
inoremap ' ''<ESC>i
inoremap " ""<ESC>i

创建进程类

#!/usr/bin/python3

import time
from multiprocessing import Process


class ClockProcess(Process):
    def __init__(self, value):
        Process.__init__(self)
        # 或者写成super(ClockProcess,self).__init__()
        # 或者写成super().__init__()
        # 不能写成super().__init__(v)，因为Process类的初始化不需要参数，__init__(self, group=None, target=None, name=None, args=(), kwargs={})
        # 否则AssertionError: group argument must be None for now
        self.value = value

    def run(self):
        for i in range(10):
            print(time.ctime())
            time.sleep(self.value)

p = ClockProcess(1)
p.start()
p.join()

共享内存字符串

from ctypes import c_char
arr = Array(c_char,b'ab c' )
或者直接：
arr = Array('c',b'ab c' )

进程锁Lock

#!/usr/bin/python3

import time
from random import random
from multiprocessing import Lock


lock = Lock()
def f():
    for i in range(1, 8):
        with lock:
            print('f',i)
        time.sleep(random())

def g():
    for i in range(3, 12):
        with lock:
            print('     g',i)
        time.sleep(random())


p1 = Process(target=f)
p2 = Process(target=g)

p1.start()
p2.start()

p1.join()
p2.join()

将脚本改成自定义命令运行
先改权限chmod 777 ~/PycharmProjects/PJT/hello.py
再加上解释器#!/usr/bin/python3
此时就可以./hello.py直接运行文件了
然后cd /usr/bin/
做软连接sudo ln -s ~/PycharmProjects/PJT/hello.py hello
使用hello命令就可以运行脚本，并使用命令行参数了

tcp server重用端口号（取消内核暂时保留）
tcp.setsocket(SOL_SOCKET, SO_REUSEADDR, 1)
此时tcp.getsocket(SOL_SOCKET, SO_REUSEADDR即为1

关于多线程安全问题的考虑
对于作为全局变量的可变对象，作为Thread类的参数传入，在每个线程中是会产生修改的

from threading import Thread

def f(ls):
    ls += [1]
    print(ls, id(ls))

ls = [11]
for i in range(3):
    thd = Thread(target=f, args=(ls,))
    thd.start()

print(id(ls))
运行结果

[11, 1] 139882005725704
[11, 1, 1] 139882005725704
[11, 1, 1, 1] 139882005725704
139882005725704

对于数字，相对应的，是不会产生修改的，当然这个例子里数字11和12会产生驻留，但是不影响我的展示

from threading import Thread

def f(ls):
    ls += 1
    print(ls, id(ls))

ls = 11
for i in range(3):
    thd = Thread(target=f, args=(ls,))
    thd.start()

print(id(ls))
12 10914720
12 10914720
10914688
12 10914720

threading tcp server这篇文章中，主进程中创建多个子线程，对主进程循环里的每一次tcp.accept()得到的新的套接字描述符cli进行处理，运行结果似乎没问题，那可以说是安全的吗？

Terminator

    Ctrl-Shift-o: 水平分割屏幕
    Ctrl-Shift-e: 垂直分割屏幕 
    Ctrl-Shift-t: 打开新的终端窗口 
    Ctrl-Shift-w: 关闭当前终端窗口 
    Ctrl-Shift-q: 退出Terminator

Socket 之accept与三次握手的关系

vmware虚拟机突然断网，恢复默认网络设置，然后保留了nat模式。
ifconfig 发现没有eth0，于是：
进入root，ifconfig eth0 up，于是有了eth0；
去网络配置文件/etc/network/interfaces增加了
auto eth0 iface eth0 inet dhcp
然后ping百度，好了。

yield用法

def foo():
    for i in range(10):
        x = yield i
        print("value:",x)

g = foo()
a = next(g) 
print(a)

a = g.send('p')
print(a)

a = g.send('q')
print(a)

与C一样，python的sys.exit(0)和os._exit(0)对于缓冲区的刷新是不一样的，为此进行测试如下，你会发现不同，所以fork出来的进程，要根据需要选择exit方式。

要注意print必须加上end=’’，否则换行符会刷新缓冲区。# 标准输出设备在正常情况下是linux中的行缓存的设备（除出错），’\n’正是换行符，所以会换行时清空缓存，写入文件流则没有这个问题。

import os,sys

print('aaa',end='',flush=True)  
print('bbb',end='',flush=False)  # 要注意必须加上end=''，否则换行符会刷新缓冲区
												
#sys.exit(0)
os._exit(0)

idea和vim的配置技巧：
idea vim 如何支持ctrl + c
解决Idea不能实时编译的问题
从一堆字符中匹配出有效的MAC地址：
python
re.findall(r"(([a-f0-9]{2}-){5}[a-f0-9]{2})", "fw%e*f3-e3-33-de-30-33hjs|w-fg.hb")，可以实现[('f3-e3-33-de-30-', '30-')]，可以看到：用search方法调用group和groups的区别

re.search(r"(([a-f0-9]{2}-){5}[a-f0-9]{2})", "fwef3-e3-33-de-30-33hjswfghbds34rhs3 drh%df ftghsdf regfsfwea3-e3-33-de-20-3ehjswegfs").groups()
('f3-e3-33-de-30-33', '30-')

re.search(r"(([a-f0-9]{2}-){5}[a-f0-9]{2})", "fwef3-e3-33-de-30-33hjswfghbds34rhs3 drh%df ftghsdf regfsfwea3-e3-33-de-20-3ehjswegfs").group()
'f3-e3-33-de-30-33'

java版：

		String s = "77-dl-f3-e3-33-de-30-33-sd-77-dl-f3-e3-33-de-30-33-sd";
        String regex = "(([a-f0-9]{2}-){5}[a-f0-9]{2})";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(s);
        while(matcher.find()){
            System.out.println(matcher.group());
        }
        
f3-e3-33-de-30-33
f2-e3-33-de-30-33

python抽象类

import abc

class A(abc.ABC):
    @abc.abstractmethod
    def f(self):
        pass

class B(A):
   def f(self):
       print("b.f()")

b = B()
b.f()

finally语句中返回（或者产生异常），则先执行这两种，而不执行except语句中的return（但是会执行其前面的语句）

def f():
    try:
        a=1
        a/=0
    except Exception as e:
    	print(e)
        return 22
    finally:
        # return 11
        raise Exception

print(f())

java也是

public class Hello {
    public static void main(String[] args){
        int n = f();
        System.out.println(n);
    }
    private static int f() {
        try {
            int a = 1;
            a /= 0;
        } catch (Exception e) {
            System.out.println(e);
            return 22;
        }
        finally {
            return 11;
            // throw new RuntimeException();
        }
    }
}

使用git将项目上传到github（最简单方法）

HTML meta标签总结与属性使用介绍

反射，动态加载类

public class Main {
    public static void main(String[] args) throws Exception {
        Class<?> cls = Class.forName("Point");
//        newInstance: 弱类型。低效率。只能调用无参构造。需要加载类到方法区
//        new: 强类型。相对高效。能调用任何public构造。不需要类加载
        Object obj = cls.newInstance();
        System.out.println(obj);
        System.out.println(new Point());
//        Constructor newInstance有参构造
        Constructor<?> cons = cls.getDeclaredConstructor(new Class[]{int.class, int.class});
        cons.setAccessible(true);
        System.out.println(cons.newInstance(new Object[]{2, 2}));
    }
}

函数调用栈

import sys


def test():
    def testdddd():
        for i in range(3):
            f = sys._getframe(i)
            print(f)

    def funcdddd():
        testdddd()

    def aaaaaaaa():
        funcdddd()

    aaaaaaaa()


if __name__ == '__main__':
    test()


输出：
<frame object at 0x0000020C36EC5210>
<frame object at 0x0000020C352EECF8>
<frame object at 0x0000020C35284A48>

异常信息，写入日志

def haha(a):
    return int(a)
def do():
    try:
        a = "11f"
        b = haha(a)
    except Exception as e:
        with open("test.log", "a") as fp:
            # 换行，并且写入日期和时间
            fp.write(datetime.datetime.now().strftime("\n%Y-%m-%d %H:%M:%S "))
            # sys.exc_info得到错误名etype，错误值value，还有调用栈tb，
            # 由于tb包含了原生的调用栈信息，文件名，行号，方法名，所以不需要logging模块，或flask的日志记录
            # limit不做设置，否则太浅了
            traceback.print_exception(*sys.exc_info(), file=fp)

动态执行文件
先执行import, 再reload,
对于hello.py文件内容的修改, 会动态的执行/加载其中的代码

while True:
    time.sleep(1)
    exec("import hello")
    exec("reload(hello)")

列表中有字典, 按照字典的键/值进行排序

ls = [{"11": "bb"}, {"22": "aa"}]
ls.sort(key=lambda x: list(x.items())[0][0])
ls.sort(key=lambda x: list(x.items())[0][1])

对字典按照键/值排序, 转为元组的列表

d = {'11': 'bb', '22': 'aa'}
sorted(d.items(), key=lambda d: d[0])
sorted(d.items(), key=lambda d: d[1])

闭包的作⽤就是让⼀个变量能够常驻内存. 供后⾯的程序使⽤.
如果你在内部函数中访问了外层函数中的变量. 那么这个变量将不会消亡.将会常驻在内存中.

__file__属性
包名.__file__ 指__init__.py所在路径
模块名.__file__ 指模块.py所在路径

join连接
SELECT * FROM t1 AS a JOIN (SELECT * FROM t2 WHERE company_id=102) AS b ON a.company_id=b.company_id

shell批量操作

for i in  `find . -name "hello*"` ; do ls $i -alh;done;

文件单词统计

首先，我们要清楚 NLP 任务的基本步骤，也就是下面的四步： 
读取文件； 
去除所有标点符号和换行符，并把所有大写变成小写； 
合并相同的词，统计每个词出现的频率，并按照词频从大到小排序； 
将结果按行输出到文件 out.txt。

第一问：你能否把 NLP 例子中的 word count 实现一遍？不过这次，in.txt 可能非常非常大（意味着你不能一次读取到内存中），而 output.txt 不会很大（意味着重复的单词数量很多）。 
提示：你可能需要每次读取一定长度的字符串，进行处理，然后再读取下一次的。但是如果单纯按照长度划分，你可能会把一个单词隔断开，所以需要细心处理这种边界情况。

在这里插入图片描述
展平列表的yield from做法

   def getSmoothList(lst):
        def gen_expand(_list):
            for item in _list:
                if isinstance(item, (list, tuple)):
                    yield from gen_expand(item)
                else:
                    yield item

        return list(gen_expand(lst))


    ls = getSmoothList([(1, 2), [3, 4, [5, 6, (7,)]]])

装饰器实现缓存

两层dict的初始化

    from collections import defaultdict

    dic = defaultdict(dict)
    dic[1][1] = 11
    dic[1][1] = 12
    print(dic[1][1])
    print(dic[1])
    print(dic[2])

依赖，关联，聚合，组合，继承，实现

Golang 1.13: 解决国内 go get 无法下载的问题
go env -w GO111MODULE=on
go env -w GOPROXY=https://goproxy.cn,direct