创建一个




```c
conda config --add channels r
```

conda 找不到 .condarc

原文[https://www.cnblogs.com/xiaomengceshi/p/13663964.html](https://www.cnblogs.com/xiaomengceshi/p/13663964.html)





1、从一个序列中随机选取一个元素返回：

  random.choice(sep)

2、用于将一个列表中的元素打乱

  random.shuffle(sep)

 3、在sep列表中随机选取k个元素返回

   random.sample(seq, k) 

4、随机返回a到b之间的一个整数

 　 random.randint(a,b)

5、随机返回0到1之间的浮点数

  random.random()

6、从指定范围内，按指定基数递增的集合中 获取一个随机数

  random.randrange([start], stop[, step]) 

 7、随机返回a到b之间的一个浮点数

random.uniform(a, b)

python中生成随机整数（random模块）

## 基本操作





Series是一列，一般情况下别用，尽量转到DataFrame.
```python
import numpy as np
import pandas as pd
s = pd.Series([1, 3, 5, np.nan, 6, 8])
print(s)
s = pd.Series([1, 3, 5, None, 6, 8])
print(s)
```

选取Series中的一个数据，[]里面的是Series的index，如果idnex不对下面这句话就会报错：

```python
s[1]
```

```python
s = pd.Series([1, 3, 5, np.nan, 6, 8])
print(s.values)
print(s.to_dict())
```

Series转DataFrame：
```python
s.to_frame()
```

DataFrame转Series，不用转，直接选取某一列就是Series，下面的df3就是Series：
```python
df3=df['A']
```

DataFrame

读取数据：

```python
import numpy as np
import pandas as pd
df = pd.DataFrame({'A': 1.,
                   'B': pd.Timestamp('20130102'),
                   'C': pd.Series(1, index=list(range(4)), dtype='float32'),
                   'D': np.array([3] * 4, dtype='int32'),
                   'E': pd.Categorical(["test", "train", "test", "train"]),
                   'F': 'foo',
                   'G': [pd.Timestamp('2021-06-28 01:00:00'), pd.Timestamp('2021-06-28 02:00:00'),
                         pd.Timestamp('2021-06-28 03:00:00'), pd.Timestamp('2021-06-28 04:00:00'), ],
                   'H': [2, 30, 23, 12],
                   'I': ["123", "98", "23", "2"],
                   'X': [1, 2, None, np.nan]})
```

DataFrame广播性质

```python
df['G'] = 123  # 新增一列
df['A'] = 456  # 原来同名列被替代
print(df)
```

给某一列一个列表，列表长度要足够分配。
```python
df['A'] = [2,3,4,5] 
```

查看所有列是什么对象：
```python
df.dtypes
```

得到所有的列名：

```python
list(df.columns)
```

选择某些子列组成新的DataFrame，不用copy就容易引起警告，df=df[['B','C','A']]这样写注销掉之前的df也是可以无警告的：
```python
df2=df[['B','C','A']].copy()
```

更新所有的列名，长度需要相等,下面长度会报错：
```python
df2.columns=["TIME",'fl','vl']
```

根据列名删除某一列：

```python
df2.pop('C')
```

选取某一行某一列的某个数值，iloc重载了[]运算符，直接选第0行第1列：

```python
df.iloc[0,1]
```

iloc不便于给人看，最好是用loc：

```python
df.loc[0,'B']
```

此时赋值也是可以的：

```python
df.loc[0,'A']=10
```

loc还有更大的作用，下面2句话等价，都是选取满足条件的行：

```python
df.loc[df['E']=='test']
df.loc[df['E']=='test',:]
```

选取满足多个条件的那些行，注意区别&运算 和 | 运算 ：

```python
df.loc[(df['E']=='test')&(df['A']==1)]
df.loc[(df['E']=='test')|(df['A']==1)]
```

当然，可以进一步选择，在满足条件的一行里面进一步选某一列或者多列：

```python
df.loc[df['E']=='test','A']  # 结果是一个series
```

多个条件取值：
```python
df.loc[(df['E']=='test')&(df['A']==1),'B'].values[0] # 条件筛选-->某一列-->第一个数值
```

遍历每一行，如果是要依靠for循环去修改每一行的数值，那最好用apply而不是这种方式：

```python
for index, row in df.iterrows():
    print(index) # 输出每行的索引值
```

重置index
```python
df.reset_index(drop=True)   # drop=True 会丢弃之前的index
```

某一列的元素组成一个集合：

```python
df['A'].unique()  # 某一列不重复的数值
```




## 中级操作


将DataFrame变回python数据结构，我最常用参数是records，配合函数方便我往数据库写数据：
```python
df.to_dict(orient='records')
```

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

根据某一列的数值生成另一列：

```python
df['D']=df['G'].apply(lambda x:str(x)[0:10])
```

根据某两列的数值生成另一列，根据某几列的数值生成另一列同理：

```python
df['E']=df[['C','A']].apply(lambda x:x['A']+x['C'],axis=1)
```

df['D']此时是字符串，将字符串转换为日期：

```python
df['D']=pd.to_datetime(df['D'])
```

删除某一行，传入行index：

```python
df=df.drop(0)
```

删除数值满足条件的行
```python
df = df.drop(df[df['B']>2.6].index)
df = df.drop(df[df['B'].isin([np.nan])].index)
```

删除所有含有空值的行，any表示某一行有空值就会删除整行，all表示整行都是空值才删除整行：
```python
df.dropna(axis=0, how='any', inplace=True)
df=df.dropna(axis=0, how='any')
```

删除所有含有空值的列，any表示某一列有空值就会删除整列，all表示整列都是空值才删除整列：
```python
df.dropna(axis=1, how='any', inplace=True)
df=df.dropna(axis=1, how='any')
```

整张表都有哪些是空值，哪些不是：
```python
df.isnull()
```

判断表是不是存在空值，哪怕有一个空值都会返回True：
```python
np.any(df.isnull())
```

判断表是不是每个元素都是空值：
```python
np.all(df.isnull())
```

填充空值，如何填充空值：

将所有空值填充为0：

```python
df.fillna(0)
```

在列里面，从后面向前面填充，最后一行空值还是会是空：
```python
df.fillna(method=‘bfill’)
```

在列里面，从前面向后面填充，第一行空值还是会是空：
```python
df.fillna(method=‘ffill’)
```

横向填充，从前面向后面填充，第一列空值还是会是空：
```python
df.fillna(method=‘ffill’,axis=1)
```

处理空值的另一种方式，插值，线性插值，前向，竖着填充。

```python
df.interpolate(method=‘linear’, limit_direction=‘forward’, axis=0)
```



## 高级操作


pandas 表里所有负数赋为空值，消除所有负数：

[https://blog.csdn.net/x1131230123/article/details/117003108](https://blog.csdn.net/x1131230123/article/details/117003108)


关联性分析,相关性系数计算：
```python
data.corr()  #相关系数矩阵，即给出了两个物品之间的相关系数
data.corr()[u'A物品']  #只显示A物品与其他菜式的相关系数
data[u'A物品'].corr(data[u'B物品'])  #计算A物品与B物品的相关系数
```



print('series通过索引进行排序：'

print(series.sort_index())

print('series通过值进行排序:'

print(series.sort_values())

print('dataframe根据行索引进行降序排序（排序时默认升序，调节ascending参数）)：'

print(frame.sort_index(ascending=False))

print('dataframe根据列索引进行排序：')

print(frame.sort_index(axis=1))

print('dataframe根据值进行排序：')

print(frame.sort_values(by='a'))

print('通过多个索引进行排序：')

print(frame.sort_values(by=['a','c']))


2列转换成字典关系：

```python
bind_adcode = city_df[['bind', 'adcode']].set_index('bind').to_dict()['adcode']
```

去重

```
df= df.drop_duplicates(subset="device_no", keep='first', inplace=False)
```


## 进一步学习

学习了基本操作后，进一步巩固就多看官网api：

[https://pandas.pydata.org/docs/reference/io.html](https://pandas.pydata.org/docs/reference/io.html)

pandas cook book myself 白话文教程

[https://www.cnblogs.com/haoabcd2010/p/10614509.html](https://www.cnblogs.com/haoabcd2010/p/10614509.html)




```python
import time
from concurrent import futures
from concurrent.futures import ThreadPoolExecutor
def display(args):
    print(time.strftime('[%H:%M:%S]', time.localtime()), end=' ')
    print(args)
def task(n):
    """只是休眠"""
    display('begin sleep {}s.'.format(n))
    time.sleep(n)
    display('ended sleep {}s.'.format(n))
def do_many_task_inorder():
    """多线程
    按任务发布顺序依次等待完成
    """
    tasks = [5, 4, 3, 2, 1]
    with ThreadPoolExecutor(max_workers=3) as executor:
        future_list = [executor.submit(task, arg) for arg in tasks]
        display('非阻塞运行')
        for future in future_list:
            display(future)
        display('统一结束(有序)')
        for future in future_list:
            display(future.result())
def do_many_task_disorder():
    """多线程执行
    先完成先显示
    """
    tasks = [5, 4, 3, 2, 1]
    with ThreadPoolExecutor(max_workers=3) as executor:
        future_list = [executor.submit(task, arg) for arg in tasks]
        display('非阻塞运行')
        for future in future_list:
            display(future)
        display('统一结束(无序)')
        done_iter = futures.as_completed(future_list)  # generator
        for done in done_iter:
            display(done)
if __name__ == '__main__':
    do_many_task_inorder()
    do_many_task_disorder()
```

python 线程池 ThreadPoolExecutor 用法

https://blog.csdn.net/lwgkzl/article/details/82145387





split()不带参数即可
```python
def test_filter():
    str = "aa     bbbbb         ccc  d"
    str_list = str.split()
    print str_list
```

数据之间空格不一样 python 两种方法分割python多空格字符串

`__call__()`方法作用在于：





类-->实例化-->实例也能当成一个可调用对象

net = Net() #类的实例

out = net(input)  #实例也能当成一个可调用对象

```python
import torch
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # 输入图像channel：1；输出channel：6；5x5卷积核
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.conv2 = nn.Conv2d(6, 16, 5)
        # an affine operation: y = Wx + b
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
    def forward(self, x):
        # 2x2 Max pooling
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # 如果是方阵,则可以只使用一个数字进行定义
        x = F.max_pool2d(F.relu(self.conv2(x)), 2)
        x = x.view(-1, self.num_flat_features(x))
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x
    def num_flat_features(self, x):
        size = x.size()[1:]  # 除去批处理维度的其他所有维度
        num_features = 1
        for s in size:
            num_features *= s
        return num_features
net = Net()
print(net)
params = list(net.parameters())
print(len(params))
print(params[0].size())  # conv1's .weight
input = torch.randn(1, 1, 32, 32)
out = net(input)
print(out)
```

文章：

[http://c.biancheng.net/view/2380.html](http://c.biancheng.net/view/2380.html)

```python
class CLanguage:
    # 定义__call__方法
    def __call__(self,name,add):
        print("调用__call__()方法",name,add)
clangs = CLanguage()
clangs("C语言中文网","http://c.biancheng.net")
```

> Python 中，凡是可以将 () 直接应用到自身并执行，都称为可调用对象。可调用对象包括自定义的函数、Python 内置函数以及本节所讲的类实例对象。


文章：

[https://blog.csdn.net/Yaokai_AssultMaster/article/details/70256621](https://blog.csdn.net/Yaokai_AssultMaster/article/details/70256621)

Python __call__()方法 __init__()方法

# Pandas DataFrame to List of Dictionaries:





[https://stackoverflow.com/questions/29815129/pandas-dataframe-to-list-of-dictionaries/29816143#29816143](https://stackoverflow.com/questions/29815129/pandas-dataframe-to-list-of-dictionaries/29816143#29816143)

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

```python
df.to_dict('records')
```

# Convert list of dictionaries to a pandas DataFrame:

[https://stackoverflow.com/questions/20638006/convert-list-of-dictionaries-to-a-pandas-dataframe](https://stackoverflow.com/questions/20638006/convert-list-of-dictionaries-to-a-pandas-dataframe)

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

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


[https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_sql.html#pandas.read_sql](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_sql.html#pandas.read_sql)

[https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_sql_table.html#pandas.read_sql_table](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_sql_table.html#pandas.read_sql_table)

List of Dictionaries vs Pandas DataFrame 字典列表 vs pandas dataframe

[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
```