# 1 类方法





@classmethod

会把一个方法封装成类方法。

一个类方法把类自己作为第一个实参，就像一个实例方法把实例自己作为第一个实参。请用以下习惯来声明类方法:

```python
class C:
    @classmethod
    def f(cls, arg1, arg2, ...): ...
```

@classmethod 这样的形式称为函数的 decorator -- 详情参阅 函数定义。

$\color{red}{类方法的调用可以在类上进行 (例如 C.f()) 也可以在实例上进行 (例如 C().f())。}$  

 其所属类以外的类实例会被忽略。 如果类方法在其所属类的派生类上调用，则该派生类对象会被作为隐含的第一个参数被传入。

类方法与 C++ 或 Java 中的静态方法不同。 如果你需要后者，请参阅 staticmethod()。

# 2 静态方法

@staticmethod

将方法转换为静态方法。

$\color{red} 静态方法不会接收隐式的第一个参数。$要声明一个静态方法，请使用此语法

```python
class C:
    @staticmethod
    def f(arg1, arg2, ...): ...
```

@staticmethod 这样的形式称为函数的 decorator -- 详情参阅 函数定义。

$\color{red} 静态方法的调用可以在类上进行 (例如 C.f()) 也可以在实例上进行 (例如 C().f())。$

Python中的静态方法与Java或C ++中的静态方法类似。另请参阅 classmethod() ，用于创建备用类构造函数的变体。

像所有装饰器一样，也可以像常规函数一样调用 staticmethod ，并对其结果执行某些操作。比如某些情况下需要从类主体引用函数并且您希望避免自动转换为实例方法。对于这些情况，请使用此语法:

```python
class C:
    builtin_open = staticmethod(open)
```

想了解更多有关静态方法的信息，请参阅 标准类型层级结构 。


# 3 区别

- 构造不同：类方法需要把类自己作为第一个实参cls，静态方法不会接收隐式的第一个参数，实例方法把实例自己作为第一个实参self；

- 实例方法需要创造实例后才能调用，而其它两种可以直接依靠类进行调用，创造实例后依旧可以使用类方法和静态方法；

- java类的构造函数可以重载，python 类方法用在模拟java定义多个构造函数的情况；

- python的静态方法用途和java一样，旨在类和实例都能调用，创建实例后，不会另行创建一个新的静态方法，用的是父类的；

- 静态方法应用场景 ：如果在方法中不需要访问任何实例方法和属性，纯粹地通过传入参数并返回数据的功能性方法，那么它就适合用静态方法来定义，它节省了实例化对象的开销成本，往往这种方法放在类外面的模块层作为一个函数存在也是没问题的，而放在类中，仅为这个类服务。

- 类方法使用场景：1、作为工厂方法创建实例对象，例如内置模块 datetime.date 类中就有大量使用类方法作为工厂方法，以此来创建date对象。2、如果希望在方法裡面调用静态类，那么把方法定义成类方法是合适的，因为要是定义成静态方法，那么你就要显示地引用类A，这对继承来说可不是一件好事情。

```python
# coding:utf-8
class Foo(object):
    """类三种方法语法形式"""
    x,y = 10,14
    def instance_method(self):
        pass
    @staticmethod
    def static_method_averag(*mixes):
        return sum(mixes) / len(mixes)
    @classmethod
    def class_method(cls):
        return cls.static_method_averag(cls.x,cls.y)
foo = Foo()
# 调用关系
# foo.instance_method()
# foo.static_method_averag(1,2,3)
# foo.class_method()
# print('----------------')
# Foo.static_method_averag(1,2,3)
# Foo.class_method()
# print('----------------')
# 内存关系
print(Foo.static_method_averag is  foo.static_method_averag)  #静态方法不会动
print(Foo.class_method is  foo.class_method)
print(Foo.instance_method is  foo.instance_method)  #实例化后 实例绑定这个方法
```


参考：

[https://zhuanlan.zhihu.com/p/28010894](https://zhuanlan.zhihu.com/p/28010894)

[https://docs.python.org/zh-cn/3/index.html](https://docs.python.org/zh-cn/3/index.html)

python 类方法 静态方法 实例方法

python编程常见问题：





[https://docs.python.org/zh-cn/3/faq/programming.html#programming-faq](https://docs.python.org/zh-cn/3/faq/programming.html#programming-faq)

本文想对此做一些摘要。


# 1 作用域问题（当你对作用域中的变量进行赋值时，该变量将成为该作用域的局部变量，并在外部作用域中隐藏任何类似命名的变量）

**当你对作用域中的变量进行赋值时，该变量将成为该作用域的局部变量，并在外部作用域中隐藏任何类似命名的变量。**

解决：

使用 global 、nonlocal 去显式声明变量的作用域。

代码1
```python
a=1
def func():
    a=2
    print(a)
func()
print(a)
```

代码1执行结果：

```python
2
1
```

代码2

```python
a=1
def func():
    print(a)
    a=2
func()
print(a)
```

代码2执行结果出现错误：

```python
UnboundLocalError: local variable 'a' referenced before assignment
```

[https://www.runoob.com/python/python-functions.html](https://www.runoob.com/python/python-functions.html)

匿名函数

python 使用 lambda 来创建匿名函数。

lambda只是一个表达式，函数体比def简单很多。

lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

**lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。**

虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

语法

lambda函数的语法只包含一个语句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

# 2  如何跨模块共享全局变量（规范方法是创建一个特殊模块）

在单个程序中跨模块共享信息的规范方法是创建一个特殊模块（通常称为config或cfg）。只需在应用程序的所有模块中导入配置模块；然后该模块可用作全局名称。因为每个模块只有一个实例，所以对模块对象所做的任何更改都会在任何地方反映出来。 例如：

config.py:

```python
x = 0   # Default value of the 'x' configuration setting
```

mod.py:

```python
import config
config.x = 1
```

main.py:

```python
import config
import mod
print(config.x)
```

请注意，出于同样的原因，使用模块也是实现Singleton设计模式的基础。

# 3 好习惯：函数不使用可变对象作为默认值，除非用于缓存结果值技巧

这种类型的缺陷通常会惹恼新手程序员。考虑这个函数

```python
def foo(mydict={}):  # Danger: shared reference to one dict for all calls
    ... compute something ...
    mydict[key] = value
    return mydict
```

第一次调用此函数时，mydict 包含一项。第二次，mydict 包含两项，因为当 foo() 开始执行时， mydict 中已经有一项了。

函数调用经常被期望为默认值创建新的对象。 但实际情况并非如此。 默认值会在函数定义时一次性地创建。 如果对象发生改变，就如本示例中的字典那样，则对函数的后续调用将会引用这个被改变的对象。

按照定义，不可变对象例如数字、字符串、元组和 None 因为不可变所以是安全的。 对可变对象例如字典、列表和类实例的改变则可能造成迷惑。

由于这一特性，在编程中应遵循的一项好习惯是不使用可变对象作为默认值。 而应使用 None 作为默认值和函数中的值，检查值为 None 的形参并创建相应的列表、字典或其他可变对象。 例如，不要这样写:

```python
def foo(mydict={}):
    ...
```

而要这样写:

```python
def foo(mydict=None):
    if mydict is None:
        mydict = {}  # create a new dict for local namespace
```

这一特性有时会很有用处。 当你有一个需要进行大量耗时计算的函数时，一个常见技巧是将每次调用函数的参数和结果值缓存起来，并在同样的值被再次请求时返回缓存的值。 这称为“记忆”，具体实现方式可以是这样的:
```python
# Callers can only provide two parameters and optionally pass _cache by keyword
def expensive(arg1, arg2, *, _cache={}):
    if (arg1, arg2) in _cache:
        return _cache[(arg1, arg2)]
    # Calculate the value
    result = ... expensive computation ...
    _cache[(arg1, arg2)] = result           # Store result in the cache
    return result
```

你也可以使用包含一个字典的全局变量而不使用参数默认值；这完全取决于个人偏好。

# 4 使用函数参数列表中的 * 和 ** 说明符收集参数;这会将位置参数作为元组，将关键字参数作为字典。

# 5 深拷贝浅拷贝与可变不可变对象之间的事情

下面的x和y指向同一不可变对象，执行 y = x 并不会为列表创建一个副本，只是一个引用。
```python
x=5
y=x
```

下面这代码的操作的x和y就是指向不同对象的，因为x=x+1这句话分两步，第一步计算x+1得出的6是一可变对象，只能创建新的对象出来。
```python
x=5
y=x
x=x+1
```

某些操作 (例如 y.append(10) 和 y.sort()) 是改变原对象，而看上去相似的另一些操作 (例如 y = y + [10] 和 sorted(y)) 则是创建新对象。 

通常在 Python 中 (以及在标准库的所有代码中) 会改变原对象的方法将返回 None 以帮助避免混淆这两种不同类型的操作。

 因此如果你错误地使用了 y.sort() 并期望它将返回一个经过排序的 y 的副本，你得到的结果将会是 None，这将导致你的程序产生一个容易诊断的错误。

但是，还存在一类操作，不同的类型执行相同的操作会有不同的行为：那就是增强赋值运算符。 例如，+= 会原地改变列表，但不会改变元组或整数 (a_list += [1, 2, 3] 与 a_list.extend([1, 2, 3]) 一样都会改变 a_list，而 some_tuple += (1, 2, 3) 和 some_int += 1 则会创建新的对象)。

换而言之：

如果我们有一个可变对象 (list, dict, set 等等)，我们可以使用某些特定的操作来改变它，所有指向它的变量都会显示它的改变。

如果我们有一个不可变对象 (str, int, tuple 等等)，所有指向它的变量都将显示相同样的值，但凡是会改变这个值的操作将总是返回一个新对象。

如果你想知道两个变量是否指向相同的对象，你可以使用 is 运算符，或内置函数 id()。



```python
import copy
a=[1,2,3,4]
b=copy.copy(a)
b[0]=0
print(id(a)==id(b))
# 引用
a=[1,2,3,4]
b=a
b[0]=0
print(id(a)==id(b))
a=[1,2,3,4]
b=a[:]
b[0]=0
print(id(a)==id(b))
a=[1,2,3,4]
b=a[0:3]
b[0]=0
print(id(a)==id(b))
a={"d":12,"r":23}
b=copy.copy(a)
b["d"]=0
print(id(a)==id(b))
a={"d":12,"r":23}
b=a.copy()
b["d"]=0
print(id(a)==id(b))
# 引用
a={"d":12,"r":23}
b=a
b["d"]=0
print(id(a)==id(b))
```

结果

```python
False
True
False
False
False
False
True
```

# 6 编写带输出参数的函数

通过返回一个结果元组:

```python
def func2(a, b):
    a = 'new-value'        # a and b are local names
    b = b + 1              # assigned to new objects
    return a, b            # return new values
x, y = 'old-value', 99
x, y = func2(x, y)
print(x, y)                # output: new-value 100
```

这几乎总是最清晰明了的解决方案。

# 7 使用嵌套作用域，或者使用可调用对象创建高阶函数

使用嵌套作用域
```python
def linear(a, b):
    def result(x):
        return a * x + b
    return result
print(linear(1,2)(3))
```

使用可调用对象

```python
class linear:
    def __init__(self, a, b):
        self.a, self.b = a, b
    def __call__(self, x):
        return self.a * x + self.b
print(linear(1,2)(3))
```

可调用对象方式的缺点是速度略慢且生成的代码略长。 但是，请注意一组可调用对象能够通过继承来共享签名:

```python
class linear:
    def __init__(self, a, b):
        self.a, self.b = a, b
    def __call__(self, x):
        return self.a * x + self.b
class exponential(linear):
    # __init__ inherited
    def __call__(self, x):
        return self.a * (x ** self.b)
print(exponential(1,2)(2))
```

对象可以封装多个方法的状态:

```python
class counter:
    value = 0
    def set(self, x):
        self.value = x
    def up(self):
        self.value = self.value + 1
    def down(self):
        self.value = self.value - 1
count = counter()
inc, dec, reset = count.up, count.down, count.set
```

# 8 使用dir()可以获得类的属性和方法

```python
class counter:
    value = 0
    def set(self, x):
        self.value = x
    def up(self):
        self.value = self.value + 1
    def down(self):
        self.value = self.value - 1
print(dir(counter))
```

返回

```python
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'down', 'set', 'up', 'value']
```

# 9 逗号在 Python 中不是运算符，"a" in "b", "a"是("a" in "b"), "a"

# 10 三目 “？：” small = x if x < y else y

# 11 函数参数列表中的斜杠（/）是什么意思？函数参数列表中的斜杠表示在它之前的形参是仅限位置形参。

在形参列表末尾的斜杠意味着两个形参都是仅限位置形参。 因此，附带关键字参数调用 divmod() 将会导致报错:

```python
>>>
>>> divmod(x=3, y=4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: divmod() takes no keyword arguments
```

# 12 十六进制和八进制整数表示  0x22  0o22

# 13 字符串转换为数字用eval()不安全

用自带的int() float()，eval()太慢，而且eval()能执行python表达式不安全。

# 13 如何修改字符串？

无法修改，因为字符串是不可变对象。 在大多数情况下，你应该使用你想要的各种部分来构造一个新字符串。 但是，如果你想要一个可以原地修改 Unicode 数据的对象，可尝试使用 io.StringIO 对象或 array 模块:

```python
>>>
>>> import io
>>> s = "Hello, world"
>>> sio = io.StringIO(s)
>>> sio.getvalue()
'Hello, world'
>>> sio.seek(7)
7
>>> sio.write("there!")
6
>>> sio.getvalue()
'Hello, there!'
>>> import array
>>> a = array.array('u', s)
>>> print(a)
array('u', 'Hello, world')
>>> a[0] = 'y'
>>> print(a)
array('u', 'yello, world')
>>> a.tounicode()
'yello, world'
```

# 14 如何使用字符串调用函数/方法？

有多种技巧可供选择。

最好的做法是使用一个将字符串映射到函数的字典。 这一技巧的主要优势在于字符串不必与函数名称一致。 这也是用于模拟其他语言中 case 结构的主要技巧:

```python
def a():
    pass
def b():
    pass
dispatch = {'go': a, 'stop': b}  # Note lack of parens for funcs
dispatch[get_input()]()  # Note trailing parens to call function
```

使用内置函数 getattr()

```python
import foo
getattr(foo, 'bar')()
请注意 getattr() 可用于任何对象，包括类、类实例、模块等等。
在标准库中多次使用了这个技巧，例如:
class Foo:
    def do_foo(self):
        ...
    def do_bar(self):
        ...
f = getattr(foo_instance, 'do_' + opname)
f()
```

使用 locals() 或 eval() 来解析出函数名:

```python
def myFunc():
    print("hello")
fname = "myFunc"
f = locals()[fname]
f()
f = eval(fname)
f()
```

注意：使用 eval() 速度慢而且危险。 如果你不能绝对掌控字符串的内容，别人将能传入可被解析为任意函数直接执行的字符串。

# 15 将多个字符串连接在一起的最有效方法是什么？

str 和 bytes 对象是不可变的，因此将多个字符串连接在一起效率很低，因为每个连接都会创建一个新对象。在一般情况下，总运行时间是总字符串长度的二次方。

要连接多个 str 对象，通常推荐的用法是将它们放入一个列表中并在结尾处调用 str.join() ：
```python
my_strings="abcdefg"
chunks = []
for s in my_strings:
    chunks.append(s)
print(chunks)
result = ''.join(chunks)
print(result)
```

# 16 如何以相反的顺序迭代序列？

使用 reversed() 内置函数，这是Python 2.4中的新功能:

```python
for x in reversed(sequence):
    ...  # do something with x ...
```

这不会修改您的原始序列，而是构建一个反向顺序的新副本以进行迭代。

在 Python 2.3 里，您可以使用扩展切片语法:

```python
for x in sequence[::-1]:
    ...  # do something with x ...
```

# 17 如何从列表中删除重复项？

有关执行此操作的许多方法的详细讨论，请参阅 Python Cookbook:

https://code.activestate.com/recipes/52560/

如果您不介意重新排序列表，请对其进行排序，然后从列表末尾进行扫描，删除重复项：

```python
if mylist:
    mylist.sort()
    last = mylist[-1]
    for i in range(len(mylist)-2, -1, -1):
        if last == mylist[i]:
            del mylist[i]
        else:
            last = mylist[i]
```

如果列表的所有元素都可以用作设置键（即：它们都是 hashable ），这通常会更快:

```python
mylist = list(set(mylist))
```

这会将列表转换为集合，从而删除重复项，然后返回到列表中。

如果序列时不可哈希的，想要去除重复项，需要对上述代码稍作修改：

```python
# example2.py
#
# Remove duplicate entries from a sequence while keeping order
def dedupe(items, key=None):
  seen = set()
  for item in items:
    val = item if key is None else key(item)
    if val not in seen:
      yield item
      seen.add(val)
if __name__ == '__main__':
  a = [ 
    {'x': 2, 'y': 3},
    {'x': 1, 'y': 4},
    {'x': 2, 'y': 3},
    {'x': 2, 'y': 3},
    {'x': 10, 'y': 15}
    ]
  print(a)
  print(list(dedupe(a, key=lambda a: (a['x'],a['y']))))
```

# 18 如何创建多维列表？

可以使用列表推导式:

```python
w, h = 2, 3
A = [[None] * w for i in range(h)]
```

# 19 如何按其他列表中的值对一个列表进行排序？

将它们合并到元组的迭代器中，对结果列表进行排序，然后选择所需的元素。

```python
>>>
>>> list1 = ["what", "I'm", "sorting", "by"]
>>> list2 = ["something", "else", "to", "sort"]
>>> pairs = zip(list1, list2)
>>> pairs = sorted(pairs)
>>> pairs
[("I'm", 'else'), ('by', 'sort'), ('sorting', 'to'), ('what', 'something')]
>>> result = [x[1] for x in pairs]
>>> result
['else', 'sort', 'to', 'something']
```

最后一步的替代方案是:

```python
>>>
>>> result = []
>>> for p in pairs: result.append(p[1])
```

如果你觉得这个更容易读懂，那么你可能更喜欢使用这个而不是前面的列表推导。然而，对于长列表来说，它的速度几乎是原来的两倍。为什么？首先， append() 操作必须重新分配内存，虽然它使用了一些技巧来避免每次都这样做，但它仍然偶尔需要这样做，而且代价相当高。第二，表达式 "result.append" 需要额外的属性查找。第三，必须执行所有这些函数调用会降低速度。

# 20 实例方法、静态方法和类方法区别及其应用场景

[https://blog.csdn.net/helloxiaozhe/article/details/79940321](https://blog.csdn.net/helloxiaozhe/article/details/79940321)

```python
# coding:utf-8
class Foo(object):
    """类三种方法语法形式"""
    def instance_method(self):
        print("是类{}的实例方法，只能被实例对象调用".format(Foo))
    @staticmethod
    def static_method():
        print("是静态方法")
    @classmethod
    def class_method(cls):
        print("是类方法")
foo = Foo()
foo.instance_method()
foo.static_method()
foo.class_method()
print('----------------')
Foo.static_method()
Foo.class_method()
```

python 编程常见问题

所有生成器都是迭代器，因为生成器完全实现了迭代器接 口。不过，根据《设计模式：可复用面向对象软件的基础》一书的定义，迭代器用于从集合中取出元素；而生成器用于“凭空”生成元 素。通过斐波纳契数列能很好地说明二者之间的区别：斐波纳契数列中的数有无穷个，在一个集合里放不下。不过要知道，在 Python 社区中，大多数时候都把迭代器和生成器视作同一概念。





在 Python 中，所有集合都可以迭代。在 Python 语言内部，迭代器用于

支持：

> - for 循环

> - 构建和扩展集合类型

> - 逐行遍历文本文件

> - 列表推导、字典推导和集合推导

> - 元组拆包

> - 调用函数时，使用 * 拆包实参


把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。


参考：

Ramalho L. Fluent python: Clear, concise, and effective programming[M]. " O'Reilly Media, Inc.", 2015.

[https://www.runoob.com/python3/python3-iterator-generator.html](https://www.runoob.com/python3/python3-iterator-generator.html)

python 迭代器与生成器

修改库里文件





![在这里插入图片描述](/static/img/images/02530.png)

```python
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import os
import sys
import glob
from PyPDF2 import PdfFileMerger, PdfFileReader, PdfFileWriter
def merger_pdf():
    pdf_writer = PdfFileWriter()
    for name in glob.glob(r"E:\Cheats\*.pdf"):
        pdf_reader = PdfFileReader(name)
        for page in range(pdf_reader.getNumPages()):
            pdf_writer.addPage(pdf_reader.getPage(page))
    with open("merges.pdf", "wb") as output_file:
        pdf_writer.write(output_file)
if __name__ == '__main__':
    merger_pdf()
```

或者

```python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
'''
   #文件名：pdfmerge.py
   本脚本用来合并pdf文件，输出的pdf文件按输入的pdf文件名生成书签
   使用示例如下：
   python pdfmerge.py -p "D:\pdf-files" -o "merged-out.pdf" -b True'
   示例说明：
   要合并的pdf文件所在的路径： D:\pdf-files
   合并后的pdf文件的输出文件名：merged-out.pdf
   是否从pdf文件中导入书签的值：True
'''
import os, sys, codecs
from argparse import ArgumentParser, RawTextHelpFormatter
from PyPDF2 import PdfFileReader, PdfFileWriter, PdfFileMerger
def getfilenames(filepath='',filelist_out=[],file_ext='all'):
    # 遍历filepath下的所有文件，包括子目录下的文件
    for fpath, dirs, fs in os.walk(filepath):
        for f in fs:
            fi_d = os.path.join(fpath, f)
            if  file_ext == 'all':
                filelist_out.append(fi_d)
            elif os.path.splitext(fi_d)[1] == file_ext:
                filelist_out.append(fi_d)
            else:
                pass
    return filelist_out
def mergefiles(path, output_filename, import_bookmarks=False):
    # 遍历目录下的所有pdf将其合并输出到一个pdf文件中，输出的pdf文件默认带书签，书签名为之前的文件名
    # 默认情况下原始文件的书签不会导入，使用import_bookmarks=True可以将原文件所带的书签也导入到输出的pdf文件中
    merger = PdfFileMerger()
    filelist = getfilenames(filepath=path, file_ext='.pdf')
    if len(filelist) == 0:
        print("当前目录及子目录下不存在pdf文件")
        sys.exit()
    for filename in filelist:
        f = codecs.open(filename, 'rb')
        file_rd = PdfFileReader(f)
        short_filename = os.path.basename(os.path.splitext(filename)[0])
        if file_rd.isEncrypted == True:
            print('不支持的加密文件：%s'%(filename))
            continue
        merger.append(file_rd, bookmark=short_filename, import_bookmarks=import_bookmarks)
        print('合并文件：%s'%(filename))
        f.close()
    out_filename=os.path.join(os.path.abspath(path), output_filename)
    merger.write(out_filename)
    print('合并后的输出文件：%s'%(out_filename))
    merger.close()
if __name__ == "__main__":
    description="\n本脚本用来合并pdf文件，输出的pdf文件按输入的pdf文件名生成书签\n使用示例如下："
    description=description+'\npython pdfmerge.py -p "D:\pdf-files" -o "merged-out.pdf" -b True'
    description=description+'\n\n'+"示例说明："
    description=description+'\n'+"要合并的pdf文件所在的路径： D:\pdf-files"
    description=description+'\n'+"合并后的pdf文件的输出文件名：merged-out.pdf"
    description=description+'\n'+"是否从pdf文件中导入书签的值：True"
    # 添加程序帮助，程序帮助支持换行符号
    parser = ArgumentParser(description=description, formatter_class=RawTextHelpFormatter)
    # 添加命令行选项
    parser.add_argument("-p", "--path",
                        dest="path",
                        default=".",
                        help="PDF文件所在目录")
    parser.add_argument("-o", "--output",
                        dest="output_filename",
                        default="merged.pdf",
                        help="合并PDF的输出文件名",
                        metavar="FILE")
    parser.add_argument("-b", "--bookmark",
                    dest="import_bookmarks",
                    default="False",
                    help="是否从pdf文件中导入书签，值可以是'True'或者'False'")
    args = parser.parse_args()
    #try:
    mergefiles(args.path, args.output_filename, args.import_bookmarks)
    #except:
    #    print('Error to merge pdf file:')
    #    print(sys.exc_info()[0],sys.exc_info()[1])
```

python 合并pdf

代码




```python
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import tkinter
import http.client
import time
def get_webservertime(host):
    conn = http.client.HTTPConnection(host)
    conn.request("GET", "/")
    r = conn.getresponse()
    ts = r.getheader('date')  # 获取http头date部分
    # 将GMT时间转换成北京时间
    ltime = time.strptime(ts[5:25], "%d %b %Y %H:%M:%S")
    ttime = time.localtime(time.mktime(ltime) + 8 * 60 * 60)
    dat = "%u-%02u-%02u" % (ttime.tm_year, ttime.tm_mon, ttime.tm_mday)
    tm = "%02u:%02u:%02u" % (ttime.tm_hour, ttime.tm_min, ttime.tm_sec)
    return tm
def tick():
    global time1
    # 获取时间
    time2 = get_webservertime('www.taobao.com')
    # 如果时间发生变化，代码自动更新显示的系统时间
    if time2 != time1:
        time1 = time2
        clock.config(text=time2)
        # calls itself every 200 milliseconds
        # to update the time display as needed
        # could use >200 ms, but display gets jerky
    clock.after(200, tick)
win = tkinter.Tk()
win.title("获取淘宝服务器时间")
time1 = ''
clock = tkinter.Label(win, font=('times', 100, 'bold'), bg='green')
clock.grid(row=0, column=1)
tick()
win.mainloop()
```

效果

![在这里插入图片描述](/static/img/images/02657.png)

PYTHON 获取淘宝服务器时间 显示在tkinter的UI

代码





```
import numpy as np
def normalization(x):
    """"
    归一化到区间{0,1]
    返回副本
    """
    _range = np.max(x) - np.min(x)
    return (x - np.min(x)) / _range
def standardization(x):
    """"
     将输入x 正态标准化  (x - mu) / sigma   ~   N(0,1)
     返回副本
    """
    mu = np.mean(x, axis=0)
    sigma = np.std(x, axis=0)
    return (x - mu) / sigma
YUAN = np.random.randint(3, 70, size=5)
a = normalization(YUAN)
b = standardization(YUAN)
print(YUAN, "normalization:", a)
print(YUAN is a)
print(YUAN, "standardization:", b)
print(YUAN is b)
```

结果

    [33 50 60 12 32] normalization: [0.4375     0.79166667 1.         0.         0.41666667]

    False

    [33 50 60 12 32] standardization: [-0.26647587  0.76308999  1.36871697 -1.53829253 -0.32703857]

    False

**sklearn.preprocessing.scale 能沿某个轴标准化**
```
import numpy as np
from sklearn import  preprocessing
def standardization(x):
    """"
     将输入x 正态标准化  (x - mu) / sigma   ~   N(0,1)
     返回副本
    """
    mu = np.mean(x, axis=0)
    sigma = np.std(x, axis=0)
    return (x - mu) / sigma
YUAN = np.random.randint(3, 70, size=5)
a = standardization(YUAN)
b = preprocessing.scale(YUAN)
print(YUAN, "normalization:", a)
print(YUAN, "preprocessing.scale:", b)
print(a == b)
```

结果

```
[ 8 14 64 51 61] normalization: [-1.32656065 -1.07468204  1.02430632  0.47856935  0.89836702]
[ 8 14 64 51 61] preprocessing.scale: [-1.32656065 -1.07468204  1.02430632  0.47856935  0.89836702]
[ True  True  True  True  True]
```

numpy 归一化 与 标准化

**代码**




```
import numpy as np
def NormMinandMax(npdarr, min=0, max=1):
    """"
    将数据npdarr 归一化到[min,max]区间的方法
    返回 副本
    """
    arr = npdarr.flatten()
    Ymax = np.max(arr)  # 计算最大值
    Ymin = np.min(arr)  # 计算最小值
    k = (max - min) / (Ymax - Ymin)
    last = min + k * (arr - Ymin)
    return last
YUAN = np.random.randint(3, 70, size=5)
print(np.max(YUAN),np.min(YUAN))
print(YUAN, NormMinandMax(YUAN,4,6))
```

结果

    64 5

    [34  7 63 64  5] [4.98305085 4.06779661 5.96610169 6.         4.        ]

numpy 将数据npdarr 归一化到[min,max]区间的方法

numpy教程：





[https://numpy.org/devdocs/user/quickstart.html#array-creation](https://numpy.org/devdocs/user/quickstart.html#array-creation)

https://numpy.org/devdocs/user/index.html



# **1、创建数组**



```python
import numpy as np
a = np.arange(15).reshape(3, 5) #np.arange
a = np.arange( 10, 30, 5 ) 
start:可忽略不写，默认从0开始;起始值
stop:结束值；生成的元素不包括结束值
step:可忽略不写，默认步长为1；步长
dtype:默认为None，设置显示元素的数据类型
a = np.array([2,3,4]) #列表导入
b = np.array([(1.5,2,3), (4,5,6)])  #多维
c = np.array( [ [1,2], [3,4] ], dtype=complex ) #显式给出类型
a =  np.zeros( (3,4) )
a =  np.ones( (2,3,4), dtype=np.int16 ) 
a =  np.empty( (2,3) )
# shape和矩阵a一样的 全0矩阵b
b =  np.zeros_like(a)
# np.linspace函数
a =  np.linspace( 0, 2, 9 )                 # 9 numbers from 0 to 2
>>> u = np.eye(2) # unit 2x2 matrix; "eye" represents "I"
>>> u
array([[ 1.,  0.],
       [ 0.,  1.]])
# 服从“0~1”均匀分布的随机样本值。随机样本取值范围是[0,1)，不包括1
a =  np.random.rand(3,2)
array([[ 0.14022471,  0.96360618],  #random
       [ 0.37601032,  0.25528411],  #random
       [ 0.49313049,  0.94909878]]) #random
# 返回服从正态分布X ~ N(3, 6.25)  来源于 (x-mu)/sigma ~ N(0,1)
# np.random.randn(2, 4)返回标准正态分布
a =  6.25 * np.random.randn(2, 4) + 3
# 返回随机的整数，位于半开区间 [low, high) 
a =   np.random.randint(5, size=(2, 4)) #区间[0, 5) 
a =   np.random.randint(3，5, size=(2, 4)) #区间[3, 5) 
# ranf = random = sample = random_sample 返回在半开区间 [0.0, 1.0)
np.random.random((3, 2))
```



# 2、排列



```python
np.random.shuffle(arr) #洗牌
```



# 3、形状



```python
a.ravel()：# 引用  返回的是视图  (3,)
         # 修改引用 就是修改原数据
a.flatten()：# 深拷贝  返回副本  (3,)
a.squeeze()：# 删除一条维度  (3,)或者(3, 1)
a.reshape((3,4))
```



# 4、堆叠

**np.vstack() #在竖直方向上堆叠**

**np.hstack() #在水平方向上平铺**

```python
>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.hstack((a,b))
array([1, 2, 3, 2, 3, 4])
>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[2],[3],[4]])
>>> np.hstack((a,b))
array([[1, 2],
       [2, 3],
       [3, 4]])
```





# 4、拼接

**np.concatenate **沿着现有的轴连接一系列数组。

```python
>>> a = np.array([[1, 2], [3, 4]])
>>> b = np.array([[5, 6]])
>>> np.concatenate((a, b), axis=0)
array([[1, 2],
       [3, 4],
       [5, 6]])
>>> np.concatenate((a, b.T), axis=1)
array([[1, 2, 5],
       [3, 4, 6]])
>>> np.concatenate((a, b), axis=None)
array([1, 2, 3, 4, 5, 6])
```



# 5、拆分

**numpy.array_split(ary, indices_or_sections, axis=0) 拆分，不均等就报错****

```python
>>> x = np.arange(8.0)
>>> np.array_split(x, 3)
    [array([ 0.,  1.,  2.]), array([ 3.,  4.,  5.]), array([ 6.,  7.])]
```

**numpy.split(ary, indices_or_sections, axis=0)  拆分， 可接受列表**

```python
>>> x = np.arange(9.0)
>>> np.split(x, 3)
[array([ 0.,  1.,  2.]), array([ 3.,  4.,  5.]), array([ 6.,  7.,  8.])]
>>> x = np.arange(8.0)
>>> np.split(x, [3, 5, 6, 10])
[array([ 0.,  1.,  2.]),
 array([ 3.,  4.]),
 array([ 5.]),
 array([ 6.,  7.]),
 array([], dtype=float64)]
```

# 7、奇淫技巧

7.1 矩阵赋值技巧

代码
```
sequences=[[1,2],[8,2]]
import numpy as np
results = np.zeros((len(sequences), 10))
for i, sequence in enumerate(sequences):
    results[i, sequence] = 1.
    print(i,sequence)
print(results)
```

结果

0 [1, 2]

1 [8, 2]

[[0. 1. 1. 0. 0. 0. 0. 0. 0. 0.]

 [0. 0. 1. 0. 0. 0. 0. 0. 1. 0.]]

 要点

 矩阵results的某一行的某些索引进行赋值。

 results[0,[1,2,5]]=1 表示把第0的第1、2、5处的值换成1

Numpy 基础操作

这是让大模型翻译论文的提示词：




```bash
# 翻译规则

## 翻译规则1
请在翻译这篇学术论文时，严格保留所有专业术语的原始英文表述，不要尝试将它们翻译成中文，而不是专业术语的部分，需要翻译为中文。保持所有文章引用格式和内容的完整无误。对于众所周知的国际组织、专业学会名称及其发布的标准、协议等，也应维持其英文原名。在翻译过程中，请注重上下文的流畅性和逻辑性，同时确保技术术语的一致性。

## 翻译规则2
markdown公式的单行公式样式是这样（两个$符号中间就是公式）：$Y = [y_1, y_2, \ldots, y_m]$
如果想居中一行显示就是这个公式样式(前后都有2个$$)：
$$
Y = [y_1, y_2, \ldots, y_m]
$$
翻译过程中的公式要按照markdown公式给我输出。

## 翻译规则3
文章本身是英文内容，除了应该遵守翻译规则1，其余的翻译后的内容应该是中文。

## 翻译规则4
学术论文的公式有时候是错误的或者不全，请你修改调整好。

## 翻译规则5
学术论文的标题是二级标题(##)开始，Abstract也是二级标题。比如1.就是二级标题，1.1、1.2就是三级标题。

## 翻译规则6
不准省略翻译，我给你的所有内容都需要翻译为中文。

# 翻译任务开始
现在请你翻译这个学术论文内容，按“翻译规则”翻译为中文文章：
```


LangGPT范式：

```bash
# Role: 学术论文翻译助手

## Profile
- author: LangGPT
- version: 1.0
- language: 中文/英文
- description: 专注于学术论文的精准翻译，遵循特定规则处理专业术语、公式和结构，确保内容准确无误。

## Skills
1. 熟悉学术翻译规则，能准确区分并处理专业术语、非专业术语及特定引用格式。
2. 掌握markdown公式排版规则，能按需求输出单行及居中公式。
3. 具备修改和修正错误公式的能力，确保译文内容的准确性和完整性。
4. 擅长处理学术结构，包括标题和层次设置，确保翻译符合学术写作规范。

## Background(可选项)
在学术论文的翻译过程中，保留原文的专业性与逻辑性至关重要。学术论文翻译助手不仅能准确翻译非专业内容，还能保留并处理原文中的专业术语及结构，为用户提供符合学术标准的译文。

## Goals(可选项)
1. 提供精确的学术翻译，严格遵循特定规则处理术语和格式。
2. 保证公式正确性与markdown格式输出，为用户提供易于使用的译文。
3. 通过清晰的标题层次和全面翻译，实现完整准确的学术内容转化。

## OutputFormat(可选项)
用户提供原文后，学术论文翻译助手将按翻译规则生成结构化译文，确保准确性和符合学术规范。

## Rules
1. 保留所有专业术语的英文表述，仅将非专业术语部分翻译为中文，并保持引用格式及内容的完整。
2. 按markdown公式格式输出，单行公式使用$符号包裹，居中公式使用$$符号包裹。
3. 确保除专业术语外的所有内容翻译为中文，必要时对不完整或错误的公式进行修正。
4. 学术论文的标题和Abstract需使用二级标题格式，标题层次须符合学术写作规范。
5. 确保完整翻译所有提供内容，不得省略任何部分。

## Workflows
1. 确认并理解用户提供的学术论文内容和翻译需求。
2. 遵循翻译规则，保留专业术语，处理格式并确保准确性。
3. 输出符合markdown格式的译文并修正所有不完整或错误的公式。
4. 提供最终译文，确保其符合用户的翻译需求和学术规范。

## Init
请提供您需要翻译的学术论文内容，学术论文翻译助手将按上述规则生成符合标准的译文。

```

ChatGPT翻译论文的提示词Prompt

在当前的人工智能应用中，正确和有效地构建提示词（Prompt）对于引导大型语言模型（如GPT-4等）生成期望的输出至关重要。这篇博客将深入探讨提示词工程的必要性、设计原则，并通过具体示例阐释如何实际应用这些原则。





### 为什么重视Prompt的培训？

在与语言模型的交互中，提示词起着至关重要的作用。一个好的提示可以精确引导模型输出用户所期望的答案或内容，而一个不恰当的提示则可能导致输出偏离目标，甚至产生毫无相关的信息。例如，如果给模型的提示是“描述一朵花”，模型可能输出任何类型的花的描述；但如果提示为“描述一朵位于阿尔卑斯山脉中的野生雏菊”，则输出将更具体、更符合期望。

### Prompt设计原则

#### 1. 明确性与结构化
有效的提示词需要具有高度的明确性和结构化。这意味着在构建提示时，需要清晰地指示模型所需要执行的任务，以及期望的输出格式。例如，如果我们需要一个关于全球变暖影响的报告，一个结构化的提示可能是：“编写一个1000字的报告，详细说明全球变暖对北极地区的影响，包括气温变化、冰层融化速度及其对野生动物的影响。”

#### 2. 角色设定与背景信息
通过设定特定的角色和背景，可以使模型更好地聚焦于特定类型的任务。例如，“作为一名历史学家，分析罗马帝国的兴衰原因。”这种设定帮助模型在一个明确的知识背景下进行思考，从而产生更加深入和专业的内容。

#### 3. 约束与技能描述
清楚地描述模型在回答过程中需要遵循的约束条件和所需的技能，可以帮助模型在正确的方向上发展其回答。例如，“在不提及任何现代科技的情况下，描述19世纪的伦敦。”

### 实际应用案例

让我们通过一个具体的例子来说明如何应用上述设计原则来构建有效的Prompt：

#### 场景：企业需要一份报告，分析其新产品在市场上的潜在表现。

#### Prompt构建过程：
- **角色设定**：作为一名市场分析师，
- **背景信息**：具有五年消费电子领域经验，
- **任务描述**：编写一份报告，分析产品X在全球市场的推广潜力，
- **结构化输出**：报告需要包括市场需求、目标用户群、预计销售量、竞争对手分析和推广策略建议，
- **约束条件**：报告中不得使用任何未公开的敏感信息，
- **技能描述**：能够处理和分析大量市场数据，并据此提供实际可行的建议。

这个Prompt利用了明确的角色设定和详尽的任务描述来引导模型，通过具体的结构化要求使得输出内容更加有序且符合实际需求。

### 总结

构建有效的Prompt不仅仅是为了提高模型的输出质量，更是一种确保模型能够准确理解并执行用户任务的方法。随着人工智能技术的不断进步，Prompt Engineering作为一门专业技能，其重要性在未来将会持续增长。通过学习和实践上述提示词设计原则，用户和开发者可以显著提高与语言模型的互动质量，更好地利用这些先进技术来解决实际问题。