[https://www.runoob.com/python/att-time-strftime.html](https://www.runoob.com/python/att-time-strftime.html)





把datetime对象变成各式各样的字符串~~~~~~~
```python
from datetime import datetime
time = datetime.now()
print(time)
print(time.replace(minute=0, second=0, microsecond=0))
print(time.strftime("%Y-%m-%d nihao %H:%M:%S"))
print(time.strftime("%j")) # 今天是今年的第几天 001到366
print(time.strftime("%w")) # 今天是星期几 星期日是第0天 0到6
time1 = datetime(2020, 1, 1)
print(time1.strftime("%j")) # 今天是今年的第几天 001到366 
```

2020-12-07 14:25:57.538141

2020-12-07 14:00:00

2020-12-07 nihao 14:25:57

342

1

001

把字符串提取解析出datetime对象~~~~~

[https://www.runoob.com/python/att-time-strptime.html](https://www.runoob.com/python/att-time-strptime.html)
```python
import datetime
t=datetime.datetime.strptime('2013-12-30T13:00+08:00', "%Y-%m-%dT%H:%M+08:00")
print(t)
```

python datetime 时间处理

一般的字典





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


构造：
```python
from collections import defaultdict
dict1 = defaultdict(int)
dict2 = defaultdict(set)
dict3 = defaultdict(str)
dict4 = defaultdict(list)
```

defaultdict接受一个函数作为参数。如果字典里没有找到key，用这个函数构造一个对象返回。

题目：

[https://www.nowcoder.com/practice/03ba8aeeef73400ca7a37a5f3370fe68?tpId=37&tags=&title=&diffculty=0&judgeStatus=0&rp=1](https://www.nowcoder.com/practice/03ba8aeeef73400ca7a37a5f3370fe68?tpId=37&tags=&title=&diffculty=0&judgeStatus=0&rp=1)

python：

```python
from collections import defaultdict
while True:
 try:
 zd=defaultdict(list)
 arr = input().split()
 words = arr[1 : 1+int(arr[0])]
 lookup = arr[-2]
 k = int(arr[-1])
 bro=[]
 #构造字典
 for i in words:
 zd[ "".join(sorted(i))].append(i)
 if "".join(sorted(lookup)) in zd.keys(): #在字典里有
 for i in zd["".join(sorted(lookup))]: #所有相似单词
 if lookup!=i:
 bro.append(i)#相似不相同的才是兄弟单词
 print(len(bro))
 if bro and k-1<len(bro):
 print(sorted(bro)[k-1])#排序所有兄弟单词 找到第k个
 except:
 break
```

传入

```python
5 abc acb ddd fgh hgf abc 1
```

即zd里用abc acb ddd fgh hgf构造

```python
defaultdict(<class 'list'>, 
{
'abc': ['abc', 'acb'], 
'ddd': ['ddd'], 
'fgh': ['fgh', 'hgf']
})
```

python一个defaultdict的典型用法

阅读：





[https://www.cnblogs.com/downey-blog/p/10483216.html](https://www.cnblogs.com/downey-blog/p/10483216.html)

[https://www.cnblogs.com/downey-blog/p/10482955.html](https://www.cnblogs.com/downey-blog/p/10482955.html)

```python
import copy
cop1 = copy.copy(origin)
cop2 = copy.deepcopy(origin)
```

可变类型：列表，字典

不可变类型：int、float、string、tuple

python里万物皆对象。

 参数传递方式和改变取决于参数是可变类型还是不可变类型。

 copy浅层拷贝，不能拷贝子对象。

 deepcopy浅层拷贝。

 

```python
import copy
lst = [[1,2],3]
lst_cp = copy.copy(lst)
print id(lst)
print id(lst_cp)
print id(lst[0])
print id(lst_cp[0])
```

```python
3072042988
3072043404
3072043020
3072043020
```

python 内存模型 形参 实参 参数传递方式

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





## 1 rsplit

rsplit反向分割 从右边分割 1
```python
s = 'das dsa 123'
print(s.rsplit(' ',1))
```

outpuut：`['das dsa', '123']`

## 2 join 将序列中的元素以指定的字符连接生成一个新的字符串

```python
res=[1,2,3]
print("-".join(map(str, res))+"end")
```

## 3 反向遍历字符串
```python
rawstr = input()
res = []
for i in rawstr[::-1]: # 反向遍历
 if int(i) not in res:
 res.append(int(i))
print("".join(map(str,res)))
```

用列表反向

```python
a=list(input())
a.reverse()
print("".join(a))
```

反向遍历
```python
a = input()
res = ""
for i in a[::-1]:
 res += i
print(res)
```

## 4 是否有数字 大小写 长度

```python
while True:
 try:
 line = input()
 a = 0
 b = 0
 c = 0
 d = 0
 flag = True
 for i in line:
 if i.isdigit():
 a = 1
 elif i.islower():
 b = 1
 elif i.isupper():
 c = 1
 else:
 d = 1
 for j in range(len(line) - 3):
 if line.count(line[j:j + 3]) > 1:
 flag = False
 if len(line) > 8 and (a + b + c + d) >= 3 and flag:
 print("OK")
 else:
 print("NG")
 except:
 break
```

## 5 格式化字符串

[https://blog.csdn.net/qq_35085863/article/details/78188286](https://blog.csdn.net/qq_35085863/article/details/78188286)

print(format(1, 'b').rjust(4, '0'))

python 字符串常用操作

[https://docs.python.org/zh-cn/3/library/typing.html#module-typing](https://docs.python.org/zh-cn/3/library/typing.html#module-typing)

typing --- 类型标注支持

这是一个引用




```c
a=[1]
b=[2]
b.append(a)
a[0]=2
print(b)
```

结果[2, [2]]



这是一个浅拷贝。

```c
a=[1]
b=[2]
b.append(a.copy())
a[0]=2
print(b)
```

结果[2, [1]]



对序列使用+或者*

会构建全新序列而不是一个引用
```c
a=[1]
b=[2]
b.append(a*1)
a[0]=2
print(b)
```

结果[2, [1]]


代码：
```c
a=[1]
b=[2]
print(a+b)
```

结果[1, 2]


代码

```c
b=[[1]]*10
b[0]=10
print(b)
```

结果[10, [1], [1], [1], [1], [1], [1], [1], [1], [1]]

python 序列特性 对序列使用+或者* 会构建全新序列而不是一个引用

## 教程：使用Miniconda创建Python环境





Miniconda 是一个轻量级的Anaconda发行版，它提供了最小的安装程序，只包含conda包管理系统和Python。以下是一个详细的教程，教新手如何使用Miniconda创建Python环境。

### 第一步：安装Miniconda

1. **下载Miniconda**：

 - 前往 [Miniconda官网](https://docs.conda.io/en/latest/miniconda.html)。

 - 根据你的操作系统下载适合的安装包（Windows、macOS或Linux）。

2. **安装Miniconda**：

 - Windows用户：运行下载的.exe文件，并按照提示完成安装。

 - macOS和Linux用户：在终端中运行下载的.sh文件，例如：

 ```bash
 bash Miniconda3-latest-MacOSX-x86_64.sh
 ```

 并按照提示完成安装。

### 第二步：配置镜像源（可选）

[https://mirrors.tuna.tsinghua.edu.cn/help/pypi/](https://mirrors.tuna.tsinghua.edu.cn/help/pypi/)

[https://mirrors.tuna.tsinghua.edu.cn/help/anaconda/](https://mirrors.tuna.tsinghua.edu.cn/help/anaconda/)

### 第三步：创建一个新的Python环境

1. **打开终端（或Anaconda Prompt）**：

 - 在Windows上，搜索并打开`Anaconda Prompt`。

 - 在macOS或Linux上，打开终端。

2. **创建环境**：

 使用以下命令创建一个包含指定版本Python的新环境，例如Python 3.8：

 ```bash
 conda create --name myenv python=3.8 -y
 ```

 其中，`myenv`是你新环境的名称，可以替换成你喜欢的名字。

3. **激活环境**：

 创建环境后，需要激活它才能使用：

 ```bash
 conda activate myenv
 ```

 激活成功后，你的终端提示符会显示当前环境的名称，例如：

 ```bash
 (myenv) $
 ```

### 第四步：管理环境

1. **查看所有环境**：

 使用以下命令查看已创建的所有conda环境：

 ```bash
 conda env list
 ```

 这将显示所有环境及其安装位置。

2. **安装包**：

 在激活的环境中安装包，例如安装NumPy：

 ```bash
 conda install numpy
 ```

3. **更新包**：

 更新环境中的包，例如更新所有包：

 ```bash
 conda update --all
 ```

4. **移除包**：

 移除环境中的包，例如移除NumPy：

 ```bash
 conda remove numpy
 ```

5. **停用环境**：

 完成工作后，可以停用当前环境：

 ```bash
 conda deactivate
 ```

6. **删除环境**：

 如果不再需要某个环境，可以将其删除：

 ```bash
 conda remove --name myenv --all
 ```

### 第五步：附加操作（可选）

1. **克隆环境**：

 克隆一个已有环境，可以方便地复制环境：

 ```bash
 conda create --name newenv --clone myenv
 ```

2. **导出和导入环境**：

 导出环境配置：

 ```bash
 conda env export > environment.yml
 ```

 导入环境配置：

 ```bash
 conda env create -f environment.yml
 ```

### 结语

通过以上步骤，你可以轻松地使用Miniconda创建和管理Python环境。这是开发和测试不同项目时非常有用的工具，能够确保各项目的依赖隔离，避免冲突。希望这篇教程对你有所帮助！如果有任何问题，欢迎留言讨论。

【Python】教程：使用Miniconda创建Python环境

# [魔术方法](https://pycoders-weekly-chinese.readthedocs.io/en/latest/issue6/a-guide-to-pythons-magic-methods.html)





<table border="1" class="docutils">

<colgroup>

<col width="33%" />

<col width="35%" />

<col width="33%" />

</colgroup>

<thead valign="bottom">

<tr class="row-odd"><th class="head">魔术方法</th>

<th class="head">调用方式</th>

<th class="head">解释</th>

</tr>

</thead>

<tbody valign="top">

<tr class="row-even"><td>__new__(cls [,...])</td>

<td>instance = MyClass(arg1, arg2)</td>

<td>__new__ 在创建实例的时候被调用</td>

</tr>

<tr class="row-odd"><td>__init__(self [,...])</td>

<td>instance = MyClass(arg1, arg2)</td>

<td>__init__ 在创建实例的时候被调用</td>

</tr>

<tr class="row-even"><td>__cmp__(self, other)</td>

<td>self == other, self &gt; other, 等。</td>

<td>在比较的时候调用</td>

</tr>

<tr class="row-odd"><td>__pos__(self)</td>

<td>+self</td>

<td>一元加运算符</td>

</tr>

<tr class="row-even"><td>__neg__(self)</td>

<td>-self</td>

<td>一元减运算符</td>

</tr>

<tr class="row-odd"><td>__invert__(self)</td>

<td>~self</td>

<td>取反运算符</td>

</tr>

<tr class="row-even"><td>__index__(self)</td>

<td>x[self]</td>

<td>对象被作为索引使用的时候</td>

</tr>

<tr class="row-odd"><td>__nonzero__(self)</td>

<td>bool(self)</td>

<td>对象的布尔值</td>

</tr>

<tr class="row-even"><td>__getattr__(self, name)</td>

<td>self.name # name 不存在</td>

<td>访问一个不存在的属性时</td>

</tr>

<tr class="row-odd"><td>__setattr__(self, name, val)</td>

<td>self.name = val</td>

<td>对一个属性赋值时</td>

</tr>

<tr class="row-even"><td>__delattr__(self, name)</td>

<td>del self.name</td>

<td>删除一个属性时</td>

</tr>

<tr class="row-odd"><td>__getattribute(self, name)</td>

<td>self.name</td>

<td>访问任何属性时</td>

</tr>

<tr class="row-even"><td>__getitem__(self, key)</td>

<td>self[key]</td>

<td>使用索引访问元素时</td>

</tr>

<tr class="row-odd"><td>__setitem__(self, key, val)</td>

<td>self[key] = val</td>

<td>对某个索引值赋值时</td>

</tr>

<tr class="row-even"><td>__delitem__(self, key)</td>

<td>del self[key]</td>

<td>删除某个索引值时</td>

</tr>

<tr class="row-odd"><td>__iter__(self)</td>

<td>for x in self</td>

<td>迭代时</td>

</tr>

<tr class="row-even"><td>__contains__(self, value)</td>

<td>value in self, value not in self</td>

<td>使用 in 操作测试关系时</td>

</tr>

<tr class="row-odd"><td>__concat__(self, value)</td>

<td>self + other</td>

<td>连接两个对象时</td>

</tr>

<tr class="row-even"><td>__call__(self [,...])</td>

<td>self(args)</td>

<td>“调用”对象时</td>

</tr>

<tr class="row-odd"><td>__enter__(self)</td>

<td>with self as x:</td>

<td>with 语句环境管理</td>

</tr>

<tr class="row-even"><td>__exit__(self, exc, val, trace)</td>

<td>with self as x:</td>

<td>with 语句环境管理</td>

</tr>

<tr class="row-odd"><td>__getstate__(self)</td>

<td>pickle.dump(pkl_file, self)</td>

<td>序列化</td>

</tr>

<tr class="row-even"><td>__setstate__(self)</td>

<td>data = pickle.load(pkl_file)</td>

<td>序列化</td>

</tr>

</tbody>

</table>

# [内置函数](https://docs.python.org/zh-cn/3/library/functions.html)

<table class="docutils align-default">

<colgroup>

<col style="width: 21%" />

<col style="width: 18%" />

<col style="width: 20%" />

<col style="width: 20%" />

<col style="width: 22%" />

</colgroup>

<thead>

<tr class="row-odd"><th class="head"></th>

<th class="head"></th>

<th class="head">内置函数</th>

<th class="head"></th>

<th class="head"></th>

</tr>

</thead>

<tbody>

<tr class="row-even"><td><a class="reference internal" href="#abs" title="abs"><code class="xref py py-func docutils literal notranslate">abs()</code></a></td>

<td><a class="reference internal" href="#delattr" title="delattr"><code class="xref py py-func docutils literal notranslate">delattr()</code></a></td>

<td><a class="reference internal" href="#hash" title="hash"><code class="xref py py-func docutils literal notranslate">hash()</code></a></td>

<td><a class="reference internal" href="#func-memoryview"><code class="docutils literal notranslate">memoryview()</code></a></td>

<td><a class="reference internal" href="#func-set"><code class="docutils literal notranslate">set()</code></a></td>

</tr>

<tr class="row-odd"><td><a class="reference internal" href="#all" title="all"><code class="xref py py-func docutils literal notranslate">all()</code></a></td>

<td><a class="reference internal" href="#func-dict"><code class="docutils literal notranslate">dict()</code></a></td>

<td><a class="reference internal" href="#help" title="help"><code class="xref py py-func docutils literal notranslate">help()</code></a></td>

<td><a class="reference internal" href="#min" title="min"><code class="xref py py-func docutils literal notranslate">min()</code></a></td>

<td><a class="reference internal" href="#setattr" title="setattr"><code class="xref py py-func docutils literal notranslate">setattr()</code></a></td>

</tr>

<tr class="row-even"><td><a class="reference internal" href="#any" title="any"><code class="xref py py-func docutils literal notranslate">any()</code></a></td>

<td><a class="reference internal" href="#dir" title="dir"><code class="xref py py-func docutils literal notranslate">dir()</code></a></td>

<td><a class="reference internal" href="#hex" title="hex"><code class="xref py py-func docutils literal notranslate">hex()</code></a></td>

<td><a class="reference internal" href="#next" title="next"><code class="xref py py-func docutils literal notranslate">next()</code></a></td>

<td><a class="reference internal" href="#slice" title="slice"><code class="xref py py-func docutils literal notranslate">slice()</code></a></td>

</tr>

<tr class="row-odd"><td><a class="reference internal" href="#ascii" title="ascii"><code class="xref py py-func docutils literal notranslate">ascii()</code></a></td>

<td><a class="reference internal" href="#divmod" title="divmod"><code class="xref py py-func docutils literal notranslate">divmod()</code></a></td>

<td><a class="reference internal" href="#id" title="id"><code class="xref py py-func docutils literal notranslate">id()</code></a></td>

<td><a class="reference internal" href="#object" title="object"><code class="xref py py-func docutils literal notranslate">object()</code></a></td>

<td><a class="reference internal" href="#sorted" title="sorted"><code class="xref py py-func docutils literal notranslate">sorted()</code></a></td>

</tr>

<tr class="row-even"><td><a class="reference internal" href="#bin" title="bin"><code class="xref py py-func docutils literal notranslate">bin()</code></a></td>

<td><a class="reference internal" href="#enumerate" title="enumerate"><code class="xref py py-func docutils literal notranslate">enumerate()</code></a></td>

<td><a class="reference internal" href="#input" title="input"><code class="xref py py-func docutils literal notranslate">input()</code></a></td>

<td><a class="reference internal" href="#oct" title="oct"><code class="xref py py-func docutils literal notranslate">oct()</code></a></td>

<td><a class="reference internal" href="#staticmethod" title="staticmethod"><code class="xref py py-func docutils literal notranslate">staticmethod()</code></a></td>

</tr>

<tr class="row-odd"><td><a class="reference internal" href="#bool" title="bool"><code class="xref py py-func docutils literal notranslate">bool()</code></a></td>

<td><a class="reference internal" href="#eval" title="eval"><code class="xref py py-func docutils literal notranslate">eval()</code></a></td>

<td><a class="reference internal" href="#int" title="int"><code class="xref py py-func docutils literal notranslate">int()</code></a></td>

<td><a class="reference internal" href="#open" title="open"><code class="xref py py-func docutils literal notranslate">open()</code></a></td>

<td><a class="reference internal" href="#func-str"><code class="docutils literal notranslate">str()</code></a></td>

</tr>

<tr class="row-even"><td><a class="reference internal" href="#breakpoint" title="breakpoint"><code class="xref py py-func docutils literal notranslate">breakpoint()</code></a></td>

<td><a class="reference internal" href="#exec" title="exec"><code class="xref py py-func docutils literal notranslate">exec()</code></a></td>

<td><a class="reference internal" href="#isinstance" title="isinstance"><code class="xref py py-func docutils literal notranslate">isinstance()</code></a></td>

<td><a class="reference internal" href="#ord" title="ord"><code class="xref py py-func docutils literal notranslate">ord()</code></a></td>

<td><a class="reference internal" href="#sum" title="sum"><code class="xref py py-func docutils literal notranslate">sum()</code></a></td>

</tr>

<tr class="row-odd"><td><a class="reference internal" href="#func-bytearray"><code class="docutils literal notranslate">bytearray()</code></a></td>

<td><a class="reference internal" href="#filter" title="filter"><code class="xref py py-func docutils literal notranslate">filter()</code></a></td>

<td><a class="reference internal" href="#issubclass" title="issubclass"><code class="xref py py-func docutils literal notranslate">issubclass()</code></a></td>

<td><a class="reference internal" href="#pow" title="pow"><code class="xref py py-func docutils literal notranslate">pow()</code></a></td>

<td><a class="reference internal" href="#super" title="super"><code class="xref py py-func docutils literal notranslate">super()</code></a></td>

</tr>

<tr class="row-even"><td><a class="reference internal" href="#func-bytes"><code class="docutils literal notranslate">bytes()</code></a></td>

<td><a class="reference internal" href="#float" title="float"><code class="xref py py-func docutils literal notranslate">float()</code></a></td>

<td><a class="reference internal" href="#iter" title="iter"><code class="xref py py-func docutils literal notranslate">iter()</code></a></td>

<td><a class="reference internal" href="#print" title="print"><code class="xref py py-func docutils literal notranslate">print()</code></a></td>

<td><a class="reference internal" href="#func-tuple"><code class="docutils literal notranslate">tuple()</code></a></td>

</tr>

<tr class="row-odd"><td><a class="reference internal" href="#callable" title="callable"><code class="xref py py-func docutils literal notranslate">callable()</code></a></td>

<td><a class="reference internal" href="#format" title="format"><code class="xref py py-func docutils literal notranslate">format()</code></a></td>

<td><a class="reference internal" href="#len" title="len"><code class="xref py py-func docutils literal notranslate">len()</code></a></td>

<td><a class="reference internal" href="#property" title="property"><code class="xref py py-func docutils literal notranslate">property()</code></a></td>

<td><a class="reference internal" href="#type" title="type"><code class="xref py py-func docutils literal notranslate">type()</code></a></td>

</tr>

<tr class="row-even"><td><a class="reference internal" href="#chr" title="chr"><code class="xref py py-func docutils literal notranslate">chr()</code></a></td>

<td><a class="reference internal" href="#func-frozenset"><code class="docutils literal notranslate">frozenset()</code></a></td>

<td><a class="reference internal" href="#func-list"><code class="docutils literal notranslate">list()</code></a></td>

<td><a class="reference internal" href="#func-range"><code class="docutils literal notranslate">range()</code></a></td>

<td><a class="reference internal" href="#vars" title="vars"><code class="xref py py-func docutils literal notranslate">vars()</code></a></td>

</tr>

<tr class="row-odd"><td><a class="reference internal" href="#classmethod" title="classmethod"><code class="xref py py-func docutils literal notranslate">classmethod()</code></a></td>

<td><a class="reference internal" href="#getattr" title="getattr"><code class="xref py py-func docutils literal notranslate">getattr()</code></a></td>

<td><a class="reference internal" href="#locals" title="locals"><code class="xref py py-func docutils literal notranslate">locals()</code></a></td>

<td><a class="reference internal" href="#repr" title="repr"><code class="xref py py-func docutils literal notranslate">repr()</code></a></td>

<td><a class="reference internal" href="#zip" title="zip"><code class="xref py py-func docutils literal notranslate">zip()</code></a></td>

</tr>

<tr class="row-even"><td><a class="reference internal" href="#compile" title="compile"><code class="xref py py-func docutils literal notranslate">compile()</code></a></td>

<td><a class="reference internal" href="#globals" title="globals"><code class="xref py py-func docutils literal notranslate">globals()</code></a></td>

<td><a class="reference internal" href="#map" title="map"><code class="xref py py-func docutils literal notranslate">map()</code></a></td>

<td><a class="reference internal" href="#reversed" title="reversed"><code class="xref py py-func docutils literal notranslate">reversed()</code></a></td>

<td><a class="reference internal" href="#__import__" title="__import__"><code class="xref py py-func docutils literal notranslate">__import__()</code></a></td>

</tr>

<tr class="row-odd"><td><a class="reference internal" href="#complex" title="complex"><code class="xref py py-func docutils literal notranslate">complex()</code></a></td>

<td><a class="reference internal" href="#hasattr" title="hasattr"><code class="xref py py-func docutils literal notranslate">hasattr()</code></a></td>

<td><a class="reference internal" href="#max" title="max"><code class="xref py py-func docutils literal notranslate">max()</code></a></td>

<td><a class="reference internal" href="#round" title="round"><code class="xref py py-func docutils literal notranslate">round()</code></a></td>

<td></td>

</tr>

</tbody>

</table>

python 魔术方法 内置函数

# 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()
```