> For the complete documentation index, see [llms.txt](https://liuyujie0136.gitbook.io/sci-tech-notes/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://liuyujie0136.gitbook.io/sci-tech-notes/python/python-tips.md).
# Python使用技巧
* [Python使用技巧](#python使用技巧)
* [VS Code 相关技巧](#vs-code-相关技巧)
* [缩进快捷键](#缩进快捷键)
* [同时编辑多行](#同时编辑多行)
* [Python更换pip源(pypi镜像) - 清华大学开源软件镜像站](#python更换pip源pypi镜像---清华大学开源软件镜像站)
* [Python计算排列数与组合数](#python计算排列数与组合数)
* [编写函数计算组合数](#编写函数计算组合数)
* [使用第三方模块scipy计算排列组合的具体数值](#使用第三方模块scipy计算排列组合的具体数值)
* [使用阶乘的方式求组合数](#使用阶乘的方式求组合数)
* [使用itertools列出排列组合的全部情况](#使用itertools列出排列组合的全部情况)
* [附：MATLAB计算排列组合数](#附matlab计算排列组合数)
* [Python中`if __name__ == '__main__':`的作用和原理](#python中if-__name__--__main__的作用和原理)
* [作用](#作用)
* [原理](#原理)
* [修改Python IDLE初始默认文件打开/保存路径的方法](#修改python-idle初始默认文件打开保存路径的方法)
* [Biopython教程与手册](#biopython教程与手册)
* [Python教程系列-王的机器](#python教程系列-王的机器)
* [Python基础教程-C语言中文网](#python基础教程-c语言中文网)
* [Python中统计列表元素的出现次数并降序排序](#python中统计列表元素的出现次数并降序排序)
* [Python有序字典(OrderedDict)与普通字典(dict)](#python有序字典ordereddict与普通字典dict)
* [无序字典（普通字典）](#无序字典普通字典)
* [有序字典](#有序字典)
* [Python `gzip`模块](#python-gzip模块)
* [编写压缩文件](#编写压缩文件)
* [读取压缩文件](#读取压缩文件)
* [17 Statistical Hypothesis Tests in Python](#17-statistical-hypothesis-tests-in-python)
* [Normality Tests](#normality-tests)
* [Shapiro-Wilk Test](#shapiro-wilk-test)
* [D’Agostino’s K^2 Test](#dagostinos-k2-test)
* [Anderson-Darling Test](#anderson-darling-test)
* [Correlation Tests](#correlation-tests)
* [Pearson’s Correlation Coefficient](#pearsons-correlation-coefficient)
* [Spearman’s Rank Correlation](#spearmans-rank-correlation)
* [Kendall’s Rank Correlation](#kendalls-rank-correlation)
* [Chi-Squared Test](#chi-squared-test)
* [Stationary Tests](#stationary-tests)
* [Augmented Dickey-Fuller Unit Root Test](#augmented-dickey-fuller-unit-root-test)
* [Kwiatkowski-Phillips-Schmidt-Shin](#kwiatkowski-phillips-schmidt-shin)
* [Parametric Statistical Hypothesis Tests](#parametric-statistical-hypothesis-tests)
* [Student’s t-test](#students-t-test)
* [Paired Student’s t-test](#paired-students-t-test)
* [Analysis of Variance Test (ANOVA)](#analysis-of-variance-test-anova)
* [Repeated Measures ANOVA Test](#repeated-measures-anova-test)
* [Nonparametric Statistical Hypothesis Tests](#nonparametric-statistical-hypothesis-tests)
* [Mann-Whitney U Test](#mann-whitney-u-test)
* [Wilcoxon Signed-Rank Test](#wilcoxon-signed-rank-test)
* [Kruskal-Wallis H Test](#kruskal-wallis-h-test)
* [Friedman Test](#friedman-test)
* [Further Reading](#further-reading)
* [Python循环删除列表元素常见错误与正确方法](#python循环删除列表元素常见错误与正确方法)
* [常见错误一:使用固定长度循环删除列表元素](#常见错误一使用固定长度循环删除列表元素)
* [常见错误二:正序循环遍历删除列表元素](#常见错误二正序循环遍历删除列表元素)
* [正确的方法一:倒序循环遍历](#正确的方法一倒序循环遍历)
* [正确的方法二:遍历拷贝的list，操作原始的list](#正确的方法二遍历拷贝的list操作原始的list)
* [Python汉字拼音转换工具——`pypinyin`](#python汉字拼音转换工具pypinyin)
* [安装](#安装)
* [基本使用](#基本使用)
* [高级使用](#高级使用)
## VS Code 相关技巧
### 缩进快捷键
1. 向左缩进: `Ctrl + [`
2. 向右缩进: `Ctrl + ]`
### 同时编辑多行
1. `Alt + Shift`: 竖列选择这种模式下只可以选择竖列，不可以随意插入光标。所以只限制于同一列且不间隔的情况下。
2. `Shift + Ctrl`: 竖列选择 `Ctrl+Click`，选择多个编辑位点。这种模式下不仅可以选择竖列，同时还可以在多个地方插入光标。
## Python更换pip源(pypi镜像) - [清华大学开源软件镜像站](https://mirrors.tuna.tsinghua.edu.cn/)
1. 临时使用（注意，simple 不能少, 是 https 而不是 http）
```
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple some-package
```
2. 设为默认（升级 pip 到最新版本后进行配置）
```
pip install pip -U
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
```
3. 如果您到 pip 默认源的网络连接较差，可临时使用本镜像站来升级 pip
```
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pip -U
```
## Python计算排列数与组合数
### 编写函数计算组合数
```python
def Combinatorial(n,i):
'''设计组合数'''
#n>=i
Min=min(i,n-i)
result=1
for j in range(0,Min):
#由于浮点数精度问题不能用//
result=result*(n-j)/(Min-j)
return result
if __name__ == '__main__':
print(int(Combinatorial(45,2)))
```
### 使用第三方模块scipy计算排列组合的具体数值
```python
from scipy.special import comb, perm
#计算排列数
A=perm(3,2)
#计算组合数
C=comb(45,2)
print(A,C)
```
### 使用阶乘的方式求组合数
```python
import math
def factorial_me(n):
'''建立求阶乘的函数'''
result = 1
for i in range(2, n + 1):
result = result * i
return result
def comb_1(n,m):
# 直接使用math里的阶乘函数计算组合数
return math.factorial(n)//(math.factorial(n-m)*math.factorial(m))
def comb_2(n,m):
# 使用自己的阶乘函数计算组合数
return factorial_me(n)//(factorial_me(n-m)*factorial_me(m))
def perm_1(n,m):
# 直接使用math里的阶乘函数计算排列数
return math.factorial(n)//math.factorial(n-m)
def perm_2(n,m):
# 使用自己的阶乘函数计算排列数
return factorial_me(n)//factorial_me(n-m)
if __name__ == '__main__':
print(factorial_me(6))
print(comb_1(45,2))
print(comb_2(45,2))
print(perm_1(45,2))
print(perm_2(45,2))
```
### 使用itertools列出排列组合的全部情况
```python
from itertools import combinations, permutations
# 列举排列结果[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]
print(list(permutations([i for i in range(1,4)],2)))
#列举组合结果[(1, 2), (1, 3), (2, 3)]
print(list(combinations([1,2,3],2)))
```
### 附：MATLAB计算排列组合数
1. 求n的阶乘
```matlab
factorial(n)
gamma(n+1)
v='n!'; vpa(v)
```
2. 求组合数
```matlab
combntns(x,m) #列举出从n个元素中取出m个元素的组合，其中x是含有n个元素的向量
nchoosek(n,k) #从n个元素中取k个元素的所有组合数
nchoosek(x,m) #从向量x中取m个元素的组合
```
3. 求排列数
```matlab
perms(x) #给出向量x的所有排列
prod(n:m) #求排列数：m*(m-1)*(m-2)*…*(n+1)*n (m>n)
prod(1:2:2n-1) #求(2n-1)!!
prod(2:2:2n) #求(2n)!!
prod(A) #对矩阵A的各列求积
prod(A,dim) #dim=1(默认); dim=2: 对矩阵A的各行求积（等价于(prod(A'))'）
```
4. 累积求积函数cumprod()
```matlab
cumprod(n:m) #输出一个向量[n n*(n+1) n(n+1)(n+2) … n(n+1)(n+2)…(m-1)m]
cumprod(A) #A为矩阵, 输出同维数的矩阵，按列累积求积
cumprod(A,dim) #A为矩阵, dim=1(默认, 同上); dim=2: 按行累积求积
```
5. 使用 `format rat` 命令即可使输出结果转化为分数形式
## Python中`if __name__ == '__main__':`的作用和原理
### 作用
一个python文件通常有两种使用方法，第一是作为脚本直接执行，第二是 `import` 到其他的 python 脚本中被调用（模块重用）执行。因此 `if __name__ == 'main':` 的作用就是控制这两种情况执行代码的过程，在 `if __name__ == 'main':` 下的代码只有在第一种情况下（即文件作为脚本直接执行）才会被执行，而 import 到其他脚本中是不会被执行的。举例说明：新建 `test.py` ，内容如下：
```python
# test.py
print('this is one')
if __name__ == '__main__':
print('this is two')
```
直接执行 `test.py`，结果如下，可见 `if __name__=="__main__":` 语句之前和之后的代码都被执行。
```python
this is one
this is two
```
下面尝试 `import` 执行。在同一文件夹新建名称为 `import-test.py` 的脚本，内容如下。执行之，结果仅为`this is one`。
```python
# import-test.py
import test
```
### 原理
每个python模块（python文件，也就是此处的 test.py 和 import-test.py）都包含内置的变量 `__name__`，当该模块被直接执行的时候，`__name__` 等于文件名（包含后缀`.py` ）；如果该模块 `import` 到其他模块中，则该模块的 `__name__` 等于模块名称（不包含后缀`.py`）。 而 `__main__` 始终指当前执行模块的名称（包含后缀`.py`）。进而当模块被直接执行时，`__name__ == '__main__'` 结果为真。
为了进一步说明，我们在 `test.py` 脚本的 `if __name__=="__main__":` 之前加入 `print(__name__)`，即将 `__name__` 打印出来。结果如下：直接执行时输出为`__main__`，`import` 执行时输出为`test`。
## 修改Python IDLE初始默认文件打开/保存路径的方法
找到桌面或者开始菜单里的Python IDLE快捷方式，或者直接打开安装目录下的pythonw\.exe。右击之，选择“属性”，在属性窗口中可对“起始位置”进行修改，即可更改默认文件打开/保存路径。
## Biopython教程与手册
>
## Python教程系列-王的机器
>
## Python基础教程-C语言中文网
>
`print()`函数详细语法: `print(value, ..., sep='', end='\n', file=sys.stdout, flush=False)`
## Python中统计列表元素的出现次数并降序排序
```python
from collections import Counter
ls = ['a', 'b', 'c', 'c', 'd', 'b', 'a', 'a', 'c', 'c']
counted_ls = Counter(ls)
sorted_ls_with_count = sorted(counted_ls.items(), key=lambda x: x[1], reverse=True)
```
## Python有序字典(OrderedDict)与普通字典(dict)
### 无序字典（普通字典）
```python
my_dict = dict()
my_dict["name"] = "lowman"
my_dict["age"] = 26
my_dict["girl"] = "Tailand"
my_dict["money"] = 80
my_dict["hourse"] = None
for key, value in my_dict.items():
print(key, value)
```
输出：
```
money 80
girl Tailand
age 26
hourse None
name lowman
```
可以看见，遍历一个普通字典，返回的数据和定义字典时的字段顺序是不一致的。**注意**: Python3.6改写了dict的内部算法，Python3.6版本以后的dict是有序的，所以也就无须再关注dict顺序性的问题
### 有序字典
```python
import collections
my_order_dict = collections.OrderedDict()
my_order_dict["name"] = "lowman"
my_order_dict["age"] = 45
my_order_dict["money"] = 998
my_order_dict["hourse"] = None
for key, value in my_order_dict.items():
print(key, value)
```
输出：
```
name lowman
age 45
money 998
hourse None
```
有序字典可以按字典中元素的插入顺序来输出。**注意**: 有序字典的作用只是记住元素插入顺序并按顺序输出。如果有序字典中的元素一开始就定义好了，后面没有插入元素这一动作，那么遍历有序字典，其输出结果仍然是无序的，因为缺少了有序插入这一条件，所以此时有序字典就失去了作用，所以有序字典一般用于动态添加并需要按添加顺序输出的时候。
## Python `gzip`模块
> Python gzip module provides a very simple way to compress and decompress files and work in a similar manner to GNU programs gzip and gunzip.
### 编写压缩文件
```python
import gzip
import io
import os
output_file_name = 'jd_example.txt.gz'
file_mode = 'wb'
with gzip.open(output_file_name, file_mode) as output:
with io.TextIOWrapper(output, encoding='utf-8') as encode:
encode.write('We can write anything in the file here.\n')
print(output_file_name,
'contains', os.stat(output_file_name).st_size, 'bytes')
os.system('file -b --mime {}'.format(output_file_name))
```
### 读取压缩文件
```python
import gzip
import io
read_file_name = 'jd_example.txt.gz'
file_mode = 'rb'
with gzip.open(read_file_name, file_mode) as input_file:
with io.TextIOWrapper(input_file, encoding='utf-8') as dec:
print(dec.read())
# i = io.TextIOWrapper(gzip.open(input_gz, "rb"), encoding='utf-8')
# use this code will return an object "i" just like commom "open" does,
# so you can use "i.readline()" or "for line in i" and so on
```
## 17 Statistical Hypothesis Tests in Python
>
> By [Jason Brownlee](https://machinelearningmastery.com/author/jasonb/) on August 15, 2018 in [Statistics](https://machinelearningmastery.com/category/statistical-methods/)
### Normality Tests
This section lists statistical tests that you can use to check if your data has a Gaussian distribution.
#### Shapiro-Wilk Test
Tests whether a data sample has a Gaussian distribution.
Assumptions
* Observations in each sample are independent and identically distributed (iid).
Interpretation
* H0: the sample has a Gaussian distribution.
* H1: the sample does not have a Gaussian distribution.
Python Code
```python
# Example of the Shapiro-Wilk Normality Test
from scipy.stats import shapiro
data = [0.873, 2.817, 0.121, -0.945, -0.055, -1.436, 0.360, -1.478, -1.637, -1.869]
stat, p = shapiro(data)
print('stat=%.3f, p=%.3f' % (stat, p))
if p > 0.05:
print('Probably Gaussian')
else:
print('Probably not Gaussian')
```
More Information
* [A Gentle Introduction to Normality Tests in Python](https://machinelearningmastery.com/a-gentle-introduction-to-normality-tests-in-python/)
* [scipy.stats.shapiro](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.shapiro.html)
* [Shapiro-Wilk test on Wikipedia](https://en.wikipedia.org/wiki/Shapiro%E2%80%93Wilk_test)
#### D’Agostino’s K^2 Test
Tests whether a data sample has a Gaussian distribution.
Assumptions
* Observations in each sample are independent and identically distributed (iid).
Interpretation
* H0: the sample has a Gaussian distribution.
* H1: the sample does not have a Gaussian distribution.
Python Code
```python
# Example of the D'Agostino's K^2 Normality Test
from scipy.stats import normaltest
data = [0.873, 2.817, 0.121, -0.945, -0.055, -1.436, 0.360, -1.478, -1.637, -1.869]
stat, p = normaltest(data)
print('stat=%.3f, p=%.3f' % (stat, p))
if p > 0.05:
print('Probably Gaussian')
else:
print('Probably not Gaussian')
```
More Information
* [A Gentle Introduction to Normality Tests in Python](https://machinelearningmastery.com/a-gentle-introduction-to-normality-tests-in-python/)
* [scipy.stats.normaltest](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.normaltest.html)
* [D’Agostino’s K-squared test on Wikipedia](https://en.wikipedia.org/wiki/D%27Agostino%27s_K-squared_test)
#### Anderson-Darling Test
Tests whether a data sample has a Gaussian distribution.
Assumptions
* Observations in each sample are independent and identically distributed (iid).
Interpretation
* H0: the sample has a Gaussian distribution.
* H1: the sample does not have a Gaussian distribution.
Python Code
```python
# Example of the Anderson-Darling Normality Test
from scipy.stats import anderson
data = [0.873, 2.817, 0.121, -0.945, -0.055, -1.436, 0.360, -1.478, -1.637, -1.869]
result = anderson(data)
print('stat=%.3f' % (result.statistic))
for i in range(len(result.critical_values)):
sl, cv = result.significance_level[i], result.critical_values[i]
if result.statistic < cv:
print('Probably Gaussian at the %.1f%% level' % (sl))
else:
print('Probably not Gaussian at the %.1f%% level' % (sl))
```
More Information
* [A Gentle Introduction to Normality Tests in Python](https://machinelearningmastery.com/a-gentle-introduction-to-normality-tests-in-python/)
* [scipy.stats.anderson](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.anderson.html)
* [Anderson-Darling test on Wikipedia](https://en.wikipedia.org/wiki/Anderson%E2%80%93Darling_test)
### Correlation Tests
This section lists statistical tests that you can use to check if two samples are related.
#### Pearson’s Correlation Coefficient
Tests whether two samples have a linear relationship.
Assumptions
* Observations in each sample are independent and identically distributed (iid).
* Observations in each sample are normally distributed.
* Observations in each sample have the same variance.
Interpretation
* H0: the two samples are independent.
* H1: there is a dependency between the samples.
Python Code
```python
# Example of the Pearson's Correlation test
from scipy.stats import pearsonr
data1 = [0.873, 2.817, 0.121, -0.945, -0.055, -1.436, 0.360, -1.478, -1.637, -1.869]
data2 = [0.353, 3.517, 0.125, -7.545, -0.555, -1.536, 3.350, -1.578, -3.537, -1.579]
stat, p = pearsonr(data1, data2)
print('stat=%.3f, p=%.3f' % (stat, p))
if p > 0.05:
print('Probably independent')
else:
print('Probably dependent')
```
More Information
* [How to Calculate Correlation Between Variables in Python](https://machinelearningmastery.com/how-to-use-correlation-to-understand-the-relationship-between-variables/)
* [scipy.stats.pearsonr](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.pearsonr.html)
* [Pearson’s correlation coefficient on Wikipedia](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient)
#### Spearman’s Rank Correlation
Tests whether two samples have a monotonic relationship.
Assumptions
* Observations in each sample are independent and identically distributed (iid).
* Observations in each sample can be ranked.
Interpretation
* H0: the two samples are independent.
* H1: there is a dependency between the samples.
Python Code
```python
# Example of the Spearman's Rank Correlation Test
from scipy.stats import spearmanr
data1 = [0.873, 2.817, 0.121, -0.945, -0.055, -1.436, 0.360, -1.478, -1.637, -1.869]
data2 = [0.353, 3.517, 0.125, -7.545, -0.555, -1.536, 3.350, -1.578, -3.537, -1.579]
stat, p = spearmanr(data1, data2)
print('stat=%.3f, p=%.3f' % (stat, p))
if p > 0.05:
print('Probably independent')
else:
print('Probably dependent')
```
More Information
* [How to Calculate Nonparametric Rank Correlation in Python](https://machinelearningmastery.com/how-to-calculate-nonparametric-rank-correlation-in-python/)
* [scipy.stats.spearmanr](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.spearmanr.html)
* [Spearman’s rank correlation coefficient on Wikipedia](https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient)
#### Kendall’s Rank Correlation
Tests whether two samples have a monotonic relationship.
Assumptions
* Observations in each sample are independent and identically distributed (iid).
* Observations in each sample can be ranked.
Interpretation
* H0: the two samples are independent.
* H1: there is a dependency between the samples.
Python Code
```python
# Example of the Kendall's Rank Correlation Test
from scipy.stats import kendalltau
data1 = [0.873, 2.817, 0.121, -0.945, -0.055, -1.436, 0.360, -1.478, -1.637, -1.869]
data2 = [0.353, 3.517, 0.125, -7.545, -0.555, -1.536, 3.350, -1.578, -3.537, -1.579]
stat, p = kendalltau(data1, data2)
print('stat=%.3f, p=%.3f' % (stat, p))
if p > 0.05:
print('Probably independent')
else:
print('Probably dependent')
```
More Information
* [How to Calculate Nonparametric Rank Correlation in Python](https://machinelearningmastery.com/how-to-calculate-nonparametric-rank-correlation-in-python/)
* [scipy.stats.kendalltau](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.kendalltau.html)
* [Kendall rank correlation coefficient on Wikipedia](https://en.wikipedia.org/wiki/Kendall_rank_correlation_coefficient)
#### Chi-Squared Test
Tests whether two categorical variables are related or independent.
Assumptions
* Observations used in the calculation of the contingency table are independent.
* 25 or more examples in each cell of the contingency table.
Interpretation
* H0: the two samples are independent.
* H1: there is a dependency between the samples.
Python Code
```python
# Example of the Chi-Squared Test
from scipy.stats import chi2_contingency
table = [[10, 20, 30],[6, 9, 17]]
stat, p, dof, expected = chi2_contingency(table)
print('stat=%.3f, p=%.3f' % (stat, p))
if p > 0.05:
print('Probably independent')
else:
print('Probably dependent')
```
More Information
* [A Gentle Introduction to the Chi-Squared Test for Machine Learning](https://machinelearningmastery.com/chi-squared-test-for-machine-learning/)
* [scipy.stats.chi2\_contingency](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.chi2_contingency.html)
* [Chi-Squared test on Wikipedia](https://en.wikipedia.org/wiki/Chi-squared_test)
### Stationary Tests
This section lists statistical tests that you can use to check if a time series is stationary or not.
#### Augmented Dickey-Fuller Unit Root Test
Tests whether a time series has a unit root, e.g. has a trend or more generally is autoregressive.
Assumptions
* Observations in are temporally ordered.
Interpretation
* H0: a unit root is present (series is non-stationary).
* H1: a unit root is not present (series is stationary).
Python Code
```python
# Example of the Augmented Dickey-Fuller unit root test
from statsmodels.tsa.stattools import adfuller
data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
stat, p, lags, obs, crit, t = adfuller(data)
print('stat=%.3f, p=%.3f' % (stat, p))
if p > 0.05:
print('Probably not Stationary')
else:
print('Probably Stationary')
```
More Information
* [How to Check if Time Series Data is Stationary with Python](https://machinelearningmastery.com/time-series-data-stationary-python/)
* [statsmodels.tsa.stattools.adfuller API](https://www.statsmodels.org/dev/generated/statsmodels.tsa.stattools.adfuller.html).
* [Augmented Dickey–Fuller test, Wikipedia](https://en.wikipedia.org/wiki/Augmented_Dickey%E2%80%93Fuller_test).
#### Kwiatkowski-Phillips-Schmidt-Shin
Tests whether a time series is trend stationary or not.
Assumptions
* Observations in are temporally ordered.
Interpretation
* H0: the time series is trend-stationary.
* H1: the time series is not trend-stationary.
Python Code
```python
# Example of the Kwiatkowski-Phillips-Schmidt-Shin test
from statsmodels.tsa.stattools import kpss
data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
stat, p, lags, crit = kpss(data)
print('stat=%.3f, p=%.3f' % (stat, p))
if p > 0.05:
print('Probably Stationary')
else:
print('Probably not Stationary')
```
More Information
* [statsmodels.tsa.stattools.kpss API](https://www.statsmodels.org/stable/generated/statsmodels.tsa.stattools.kpss.html#statsmodels.tsa.stattools.kpss).
* [KPSS test, Wikipedia](https://en.wikipedia.org/wiki/KPSS_test).
### Parametric Statistical Hypothesis Tests
This section lists statistical tests that you can use to compare data samples.
#### Student’s t-test
Tests whether the means of two independent samples are significantly different.
Assumptions
* Observations in each sample are independent and identically distributed (iid).
* Observations in each sample are normally distributed.
* Observations in each sample have the same variance.
Interpretation
* H0: the means of the samples are equal.
* H1: the means of the samples are unequal.
Python Code
```python
# Example of the Student's t-test
from scipy.stats import ttest_ind
data1 = [0.873, 2.817, 0.121, -0.945, -0.055, -1.436, 0.360, -1.478, -1.637, -1.869]
data2 = [1.142, -0.432, -0.938, -0.729, -0.846, -0.157, 0.500, 1.183, -1.075, -0.169]
stat, p = ttest_ind(data1, data2)
print('stat=%.3f, p=%.3f' % (stat, p))
if p > 0.05:
print('Probably the same distribution')
else:
print('Probably different distributions')
```
More Information
* [How to Calculate Parametric Statistical Hypothesis Tests in Python](https://machinelearningmastery.com/parametric-statistical-significance-tests-in-python/)
* [scipy.stats.ttest\_ind](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.ttest_ind.html)
* [Student’s t-test on Wikipedia](https://en.wikipedia.org/wiki/Student%27s_t-test)
#### Paired Student’s t-test
Tests whether the means of two paired samples are significantly different.
Assumptions
* Observations in each sample are independent and identically distributed (iid).
* Observations in each sample are normally distributed.
* Observations in each sample have the same variance.
* Observations across each sample are paired.
Interpretation
* H0: the means of the samples are equal.
* H1: the means of the samples are unequal.
Python Code
```python
# Example of the Paired Student's t-test
from scipy.stats import ttest_rel
data1 = [0.873, 2.817, 0.121, -0.945, -0.055, -1.436, 0.360, -1.478, -1.637, -1.869]
data2 = [1.142, -0.432, -0.938, -0.729, -0.846, -0.157, 0.500, 1.183, -1.075, -0.169]
stat, p = ttest_rel(data1, data2)
print('stat=%.3f, p=%.3f' % (stat, p))
if p > 0.05:
print('Probably the same distribution')
else:
print('Probably different distributions')
```
More Information
* [How to Calculate Parametric Statistical Hypothesis Tests in Python](https://machinelearningmastery.com/parametric-statistical-significance-tests-in-python/)
* [scipy.stats.ttest\_rel](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.ttest_rel.html)
* [Student’s t-test on Wikipedia](https://en.wikipedia.org/wiki/Student%27s_t-test)
#### Analysis of Variance Test (ANOVA)
Tests whether the means of two or more independent samples are significantly different.
Assumptions
* Observations in each sample are independent and identically distributed (iid).
* Observations in each sample are normally distributed.
* Observations in each sample have the same variance.
Interpretation
* H0: the means of the samples are equal.
* H1: one or more of the means of the samples are unequal.
Python Code
```python
# Example of the Analysis of Variance Test
from scipy.stats import f_oneway
data1 = [0.873, 2.817, 0.121, -0.945, -0.055, -1.436, 0.360, -1.478, -1.637, -1.869]
data2 = [1.142, -0.432, -0.938, -0.729, -0.846, -0.157, 0.500, 1.183, -1.075, -0.169]
data3 = [-0.208, 0.696, 0.928, -1.148, -0.213, 0.229, 0.137, 0.269, -0.870, -1.204]
stat, p = f_oneway(data1, data2, data3)
print('stat=%.3f, p=%.3f' % (stat, p))
if p > 0.05:
print('Probably the same distribution')
else:
print('Probably different distributions')
```
More Information
* [How to Calculate Parametric Statistical Hypothesis Tests in Python](https://machinelearningmastery.com/parametric-statistical-significance-tests-in-python/)
* [scipy.stats.f\_oneway](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.f_oneway.html)
* [Analysis of variance on Wikipedia](https://en.wikipedia.org/wiki/Analysis_of_variance)
#### Repeated Measures ANOVA Test
Tests whether the means of two or more paired samples are significantly different.
Assumptions
* Observations in each sample are independent and identically distributed (iid).
* Observations in each sample are normally distributed.
* Observations in each sample have the same variance.
* Observations across each sample are paired.
Interpretation
* H0: the means of the samples are equal.
* H1: one or more of the means of the samples are unequal.
Python Code
Currently not supported in Python.
More Information
* [How to Calculate Parametric Statistical Hypothesis Tests in Python](https://machinelearningmastery.com/parametric-statistical-significance-tests-in-python/)
* [Analysis of variance on Wikipedia](https://en.wikipedia.org/wiki/Analysis_of_variance)
### Nonparametric Statistical Hypothesis Tests
#### Mann-Whitney U Test
Tests whether the distributions of two independent samples are equal or not.
Assumptions
* Observations in each sample are independent and identically distributed (iid).
* Observations in each sample can be ranked.
Interpretation
* H0: the distributions of both samples are equal.
* H1: the distributions of both samples are not equal.
Python Code
```python
# Example of the Mann-Whitney U Test
from scipy.stats import mannwhitneyu
data1 = [0.873, 2.817, 0.121, -0.945, -0.055, -1.436, 0.360, -1.478, -1.637, -1.869]
data2 = [1.142, -0.432, -0.938, -0.729, -0.846, -0.157, 0.500, 1.183, -1.075, -0.169]
stat, p = mannwhitneyu(data1, data2)
print('stat=%.3f, p=%.3f' % (stat, p))
if p > 0.05:
print('Probably the same distribution')
else:
print('Probably different distributions')
```
More Information
* [How to Calculate Nonparametric Statistical Hypothesis Tests in Python](https://machinelearningmastery.com/nonparametric-statistical-significance-tests-in-python/)
* [scipy.stats.mannwhitneyu](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.mannwhitneyu.html)
* [Mann-Whitney U test on Wikipedia](https://en.wikipedia.org/wiki/Mann%E2%80%93Whitney_U_test)
#### Wilcoxon Signed-Rank Test
Tests whether the distributions of two paired samples are equal or not.
Assumptions
* Observations in each sample are independent and identically distributed (iid).
* Observations in each sample can be ranked.
* Observations across each sample are paired.
Interpretation
* H0: the distributions of both samples are equal.
* H1: the distributions of both samples are not equal.
Python Code
```python
# Example of the Wilcoxon Signed-Rank Test
from scipy.stats import wilcoxon
data1 = [0.873, 2.817, 0.121, -0.945, -0.055, -1.436, 0.360, -1.478, -1.637, -1.869]
data2 = [1.142, -0.432, -0.938, -0.729, -0.846, -0.157, 0.500, 1.183, -1.075, -0.169]
stat, p = wilcoxon(data1, data2)
print('stat=%.3f, p=%.3f' % (stat, p))
if p > 0.05:
print('Probably the same distribution')
else:
print('Probably different distributions')
```
More Information
* [How to Calculate Nonparametric Statistical Hypothesis Tests in Python](https://machinelearningmastery.com/nonparametric-statistical-significance-tests-in-python/)
* [scipy.stats.wilcoxon](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.wilcoxon.html)
* [Wilcoxon signed-rank test on Wikipedia](https://en.wikipedia.org/wiki/Wilcoxon_signed-rank_test)
#### Kruskal-Wallis H Test
Tests whether the distributions of two or more independent samples are equal or not.
Assumptions
* Observations in each sample are independent and identically distributed (iid).
* Observations in each sample can be ranked.
Interpretation
* H0: the distributions of all samples are equal.
* H1: the distributions of one or more samples are not equal.
Python Code
```python
# Example of the Kruskal-Wallis H Test
from scipy.stats import kruskal
data1 = [0.873, 2.817, 0.121, -0.945, -0.055, -1.436, 0.360, -1.478, -1.637, -1.869]
data2 = [1.142, -0.432, -0.938, -0.729, -0.846, -0.157, 0.500, 1.183, -1.075, -0.169]
stat, p = kruskal(data1, data2)
print('stat=%.3f, p=%.3f' % (stat, p))
if p > 0.05:
print('Probably the same distribution')
else:
print('Probably different distributions')
```
More Information
* [How to Calculate Nonparametric Statistical Hypothesis Tests in Python](https://machinelearningmastery.com/nonparametric-statistical-significance-tests-in-python/)
* [scipy.stats.kruskal](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.kruskal.html)
* [Kruskal-Wallis one-way analysis of variance on Wikipedia](https://en.wikipedia.org/wiki/Kruskal%E2%80%93Wallis_one-way_analysis_of_variance)
#### Friedman Test
Tests whether the distributions of two or more paired samples are equal or not.
Assumptions
* Observations in each sample are independent and identically distributed (iid).
* Observations in each sample can be ranked.
* Observations across each sample are paired.
Interpretation
* H0: the distributions of all samples are equal.
* H1: the distributions of one or more samples are not equal.
Python Code
```python
# Example of the Friedman Test
from scipy.stats import friedmanchisquare
data1 = [0.873, 2.817, 0.121, -0.945, -0.055, -1.436, 0.360, -1.478, -1.637, -1.869]
data2 = [1.142, -0.432, -0.938, -0.729, -0.846, -0.157, 0.500, 1.183, -1.075, -0.169]
data3 = [-0.208, 0.696, 0.928, -1.148, -0.213, 0.229, 0.137, 0.269, -0.870, -1.204]
stat, p = friedmanchisquare(data1, data2, data3)
print('stat=%.3f, p=%.3f' % (stat, p))
if p > 0.05:
print('Probably the same distribution')
else:
print('Probably different distributions')
```
More Information
* [How to Calculate Nonparametric Statistical Hypothesis Tests in Python](https://machinelearningmastery.com/nonparametric-statistical-significance-tests-in-python/)
* [scipy.stats.friedmanchisquare](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.kruskal.html)
* [Friedman test on Wikipedia](https://en.wikipedia.org/wiki/Friedman_test)
### Further Reading
This section provides more resources on the topic if you are looking to go deeper.
* [A Gentle Introduction to Normality Tests in Python](https://machinelearningmastery.com/a-gentle-introduction-to-normality-tests-in-python/)
* [How to Use Correlation to Understand the Relationship Between Variables](https://machinelearningmastery.com/how-to-use-correlation-to-understand-the-relationship-between-variables/)
* [How to Use Parametric Statistical Significance Tests in Python](https://machinelearningmastery.com/parametric-statistical-significance-tests-in-python/)
* [A Gentle Introduction to Statistical Hypothesis Tests](https://machinelearningmastery.com/statistical-hypothesis-tests/)
## Python循环删除列表元素常见错误与正确方法
>
### 常见错误一:使用固定长度循环删除列表元素
```python
# 使用固定长度循环pop方法删除列表元素
num_list_1 = [1, 2, 2, 2, 3]
for i in range(len(num_list_1)):
if num_list_1[i] == 2:
num_list_1.pop(i)
else:
print(num_list_1[i])
print("num_list_1:", num_list_1)
# IndexError: list index out of range
```
原因是在删除list中的元素后，list的实际长度变小了，但是循环次数没有减少，依然按照原来list的长度进行遍历，所以会造成索引溢出
### 常见错误二:正序循环遍历删除列表元素
不能删除连续的情况
```python
# 正序循环遍历删除列表元素
num_list_2 = [1, 2, 2, 2, 3]
for item in num_list_2:
if item == 2:
num_list_2.remove(item)
else:
print("item", item)
print("num_list_2", num_list_2)
print("after remove op", num_list_2)
# item 1
# num_list [1, 2, 2, 2, 3]
# num_list [1, 2, 2, 3]
# num_list [1, 2, 3]
# after remove op [1, 2, 3]
```
当符合条件，删除元素\[2]之后，后面的元素全部往前移，但是索引并不会随着值向前移动而变化，而是接着上一个位置向后移动。这样就会漏掉解
### 正确的方法一:倒序循环遍历
```python
# 倒序循环遍历删除列表元素
num_list_3 = [1, 2, 2, 2, 3]
for item in num_list_3[::-1]:
if item == 2:
num_list_3.remove(item)
else:
print("item", item)
print("num_list_3", num_list_3)
print("after remove op", num_list_3)
# item 3
# num_list_3 [1, 2, 2, 2, 3]
# num_list_3 [1, 2, 2, 3]
# num_list_3 [1, 2, 3]
# num_list_3 [1, 3]
# item 1
# num_list_3 [1, 3]
# after remove op [1, 3]
```
### 正确的方法二:遍历拷贝的list，操作原始的list
原始的list是num\_list，那么其实，num\_list\[:]是对原始的num\_list的一个拷贝，是一个新的list，所以，我们遍历新的list，而删除原始的list中的元素，则既不会引起索引溢出，最后又能够得到想要的最终结果。此方法的缺点可能是，对于过大的list，拷贝后可能很占内存。那么对于这种情况，可以用倒序遍历的方法来实现。
```python
# 遍历拷贝的list，操作原始的list
num_list_4 = [1, 2, 2, 2, 3]
for item in num_list_4[:]:
if item == 2:
num_list_4.remove(item)
else:
print("item", item)
print("num_list_4", num_list_4)
print("after remove op", num_list_4)
# item 1
# num_list_4 [1, 2, 2, 2, 3]
# num_list_4 [1, 2, 2, 3]
# num_list_4 [1, 2, 3]
# num_list_4 [1, 3]
# item 3
# num_list_4 [1, 3]
# after remove op [1, 3]
```
## Python汉字拼音转换工具——`pypinyin`
>
### 安装
```bash
pip install pypinyin
```
### 基本使用
```python
from pypinyin import pinyin, lazy_pinyin, Style
pinyin('中心')
# [['zhōng'], ['xīn']]
pinyin('中心', heteronym=True) # 启用多音字模式
# [['zhōng', 'zhòng'], ['xīn']]
pinyin('中心', style=Style.FIRST_LETTER) # 设置拼音风格
# [['z'], ['x']]
# TONE2 在相应字母的后面显示音调
pinyin('中心', style=Style.TONE2, heteronym=True)
# [['zho1ng', 'zho4ng'], ['xi1n']]
# TONE3 拼音的最后显示音调
pinyin('中心', style=Style.TONE3, heteronym=True)
# [['zhong1', 'zhong4'], ['xin1']]
lazy_pinyin('中心') # 不考虑多音字的情况
# ['zhong', 'xin']
lazy_pinyin('战略', v_to_u=True) # 不使用 v 表示 ü
# ['zhan', 'lüe']
# 使用 5 标识轻声
lazy_pinyin('衣裳', style=Style.TONE3, neutral_tone_with_five=True)
# ['yi1', 'shang5']
```
使用命令行一键识别拼音：
```bash
python -m pypinyin 音乐
# yīn yuè
```
### 高级使用
详见参考链接