wget https://repo.anaconda.com/archive/Anaconda3- 2020.02 -Linux-x86_64.sh sh Anaconda3- 2020.02 -Linux-x86_64.sh # 进入命令号 1 按回车 2 yes 3 选择安装目录，这个时候目录不变，回车 需要两分钟 4 安装完之后需要选择什么什么玩意，选择yes 在根目录中会看见一个anaconda的文件夹，进入文件夹可以看到很多目录 cd ~/anaconda3 cd bin 可以很多的文件夹 ./anaconda --version # 查看conda版本号 ./jupyter notebook --no-browser # 在本地运行jupyter #要是抛错Running as root is not recommended. Use --allow-root to bypass. ./jupyter notebook --no-browser --allow-root # 但是这样只能本地访问jupyter，如何实现远程访问呢？ ssh端口转发 # 在本地执行端口转发命令 ssh -N -f -L localhost: 8888 :localhost: 8888 root@{ip地址} >>>password # 本地浏览器执行localhost:8888,就可以看见linux上的jupyter的页面了 执行 print ( 'hello world' ) # jupyter执行命令行 :ifconfig

1-6 Jupyter-notebook的使用演示

进入jupeter浏览器中之后
点击new-->Terminal,显示命令行界面
# 换目录执行jupeter，并把当前目录当做工作目录
/root/anaconda3/bin/jupyter notebook --no-browser --allow-root
第2章 Numpy入门
2-1 数据科学领域5个常用Python库
numpy
scipy
Pandas
Matplotlib
Scikit-learn
Number
数据处理里面最基础的库




    

N维数组（矩阵），快速高效，矢量数学运算
高效的index,不需要循环
开源免费跨平台，运行效率足以和C/Matlab媲美
Scipy
依赖于Numpy
专为科学和工程设计
实现了多种常用科学计算：线性代数，傅里叶变换，信号和图像处理
Pandas
结构化数据分析利器（依赖Numpy）
提供了多种高级数据结构：Time-Series,DataFrame,Panel
强大的数据索引和处理能力
Matplotlib
Python 2D绘图领域使用最广泛的套件
基本能取代Matlab的绘图功能（散点，曲线，柱形等）
通过mplot3d可以绘制精美的3D图
Scikit-learn
机器学习的Python模块
建立在Scipy之上，提供了常用的机器学习算法：聚类，回归
简单易学的API接口
2-2 数学基础回顾之矩阵运算
矩阵：是指1xn或者nx1的矩阵
标量：1x1的矩阵
数组：N维的数组，是矩阵的延伸
矩阵加减运算
相加，相减的两个矩阵必须要有相同的行和列
行和列对应元素相加减
数组乘法(点乘）
清华大学出版的线性代数
 	http://www.wdfxw.net/goDownFiles.aspx?key=92039718
2-3 Array的创建及访问
import munpy as np
# create from python list
list_1 = [1,2,3,4]
array_1 = np.array(list_1)  # 生成一个一维数组
list_2 = [6,7,8,9]
array_2 = np.array([list_1,list_2])  # 创建一个二维数组
print(array_2)
print(array_2.size)  #数组里元素的个数
print(array_2.shape)  # 查看矩阵或数组的维数
print(array_2.dtype)  #数组元素的类型
array_4 = np.arange(1,10,2)  # 使用arange创建数组
print(array_4)  # array([1, 3, 5, 7, 9])
np.zeros(5)  # 全0矩阵 array([0., 0., 0., 0., 0.])
np.zeros([2,3])  # 多维全0矩阵
array([[0., 0., 0.],
       [0., 0., 0.]])
np.eye(5)  # 单位矩阵
array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]])
# 数组的访问
a = np.arange(10)
print(a)  # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
a[2]  # 2
a[1:5]  # array([1, 2, 3, 4])
b = np.array([[1,2,3,4],[5,6,7,8]])  # 矩阵
b[1,0]  # 矩阵取值（第二个数组第一个值）  # 5
c = np.array([[1,2,3],[4,5,6],[7,8,9]])
c[:2,1:]  # 第一个元素是行，第二个元素是列
#array([[2, 3],[5, 6]])
2-4 数组与矩阵运算
快速创建数组
import numpy as np
np.random.randn(10)  # 创建一个十维数组，且是动态分布的
array([-0.7512065 ,  0.97527973, -1.24433992,  0.86890475, -0.51251532,
       -0.02522675, -0.40664444,  0.66399272, -0.94669869,  1.52843227])
np.random.randint(10)  # 返回一个10以内的随机整数
np.random.randint(10, size=(2,3))  #返回一个值在10以内的2x3的数组  
array([[1, 8, 1],
       [6, 1, 8]])
np.random.randint(10,size=20).reshape(4,5)  #返回一个大小为20的4x5的整数随机数组
array([[6, 6, 4, 8, 9],
       [0, 9, 1, 0, 8],
       [6, 2, 6, 1, 3],
       [5, 4, 8, 9, 2]])
数组的运算
a = np.random.randint(10,size=20).reshape(4,5)
b = np.random.randint(10,size=20).reshape(4,5)
# 生成的a,b都是一个元素值小于10，数量为20的一个4x5的多维数组
a+b  # 多维数组相加减就是对应位置元素值相加
a-b  # 多维数组相加减就是对应位置元素值相减
a * b # 多维数组相乘就是对应位置元素值相乘
a / b # 多维数组相乘就是对应位置元素值做除法--有的时候会抛错，是因为如果数学运算中0不能做除数
矩阵的命令其实跟数组差不多
np.mat([[1,2,3],[4,5,6]])  #创建一个矩阵
matrix([[1, 2, 3],
        [4, 5, 6]])
# 数组转化为矩阵
a = np.array([1,2,3])
np.mat(a)  # matrix([[1, 2, 3]])
矩阵的运算
A = np.mat(np.random.randint(10,size=20).reshape(4,5))
B = np.mat(np.random.randint(10,size=20).reshape(4,5))
A+B  # 元素相加
A-B # 元素值相减
# 矩阵的乘法运算要求第一个值得行和第二个值的列数量一致
A = np.mat(np.random.randint(10,size=20).reshape(4,5))
B = np.mat(np.random.randint(10,size=20).reshape(5,4))
A * B
matrix([[ 59, 137,  69,  80],
        [ 77, 174, 124, 142],
        [ 48, 128,  44, 124],
        [ 54, 121, 102,  94]])
Array常用函数
import numpy as np
a = np.random.randint(10, size=20).reshape(4,5)
np.unqiue(a)  # 数组里面的唯一值
sum(a)  #将矩阵的所有的列的和重新组合成一个数组
matrix([[21, 16, 24, 17,  9]])
sum(a[0])  # 计算某一行的值
sum(a[:,0])  # 计算某一列的值
A.max()  #查看数组中最大值
a.max(a[0])  # 查看第一行的最大值
a.max(a[：，0])  # 查看第一列的最大值
2-5 Array的input和output
import numpy as np
x = np.arange(10)
# 将数组保存到硬盘
f = open('x.pk1','wb') 
pickle.dump(x,f)
# 读取硬盘中的数组 
f = open('x.pk1','rb')
pickle.load(f)
np.save('one_array',x)  # 将数组序列化到硬盘
np.load('one_array.npy')  # 读取文件
a = np.arange(10)
b = np.arange(20)
np.savez('two_array.npz',a=a,b=b)  # 一个文件保存多个数组
c = np.load('two_array.npz')  # 取数组
c['a']
c['b']
第3章 Pandas入门
3-1 Pandas Series
import numpy as np
import pandas as pd
s1 = pd.Series([1,2,3,4,1])  # 创建一个Series对象
s1  # 两列数据，第一列是索引，第二列是值
0    1
1    2
2    3
3    4
4    1
dtype: int64
s1.values  # 获取值--array([1, 2, 3, 4, 1])
s1.index  # 获取索引--RangeIndex(start=0, stop=5, step=1)
s2 = pd.Series(np.arange(10))  # 传一个数组
s3 = pd.Series({'1':1,'2':2,'3':3})  # 传入一个字典
s3.index
Index(['1', '2', '3'], dtype='object')
s4 = pd.Series([1,2,3,4],index=['A','B','C','D'])
s4.values  # array([1, 2, 3, 4])
s4.index  # Index(['A', 'B', 'C', 'd'], dtype='object')
s4['A']  # 按照字典方式取值
s4[s4>2]  # 返回字典里面值大于2的数据组成一个新的数组
s4.to_dict()  # 将Series对象转化为字典
{'A': 1, 'B': 2, 'C': 3, 'd': 4}
s5 = pd.Series(s4.to_dict())  # Series传入字典重新生成Series对象
index_1 = ['O','A','B','C','D','E']  # 定义一个索引列表
s6 = pd.Series(s5,index=index_1)  # 替换索引
s6  # 发现索引没有对应值的时候，值为NaN
O    NaN
A    1.0
B    2.0
C    3.0
D    NaN
E    NaN
dtype: float64
pd.isnull(s6)  # 判断是否为空
O     True
A    False
B    False
C    False
D     True
E     True
dtype: bool
pd.notnull(s6)  # 判断不为空
O    False
A     True
B     True
C     True
D    False
E    False
dtype: bool
s6.name = 'demo'  # Series指定名字
O    NaN
A    1.0
B    2.0
C    3.0
D    NaN
E    NaN
Name: demo, dtype: float64
s6.index.name='demo index'  # Series的索引指定名字
Index(['O', 'A', 'B', 'C', 'D', 'E'], dtype='object', name='demo index')
s6.index 
Index(['O', 'A', 'B', 'C', 'D', 'E'], dtype='object', name='demo index')
s6.values
array([nan,  1.,  2.,  3., nan, nan])
Jun 2020
Jun 2019
Change
Programming Language
Ratings
Change
1
2
C
17.19%
+3.89%
2
1
Java
16.10%
+1.10%
3
3
Python
8.36%
-0.16%
4
4
C++
5.95%
-1.43%
5
6
C#
4.73%
+0.24%
6
5
Visual Basic
4.69%
+0.07%
7
7
JavaScript
2.27%
-0.44%
8
8
PHP
2.26%
-0.30%
9
22
R
2.19%
+1.27%
10
9
SQL
1.73%
-0.50%
import numpy as np
import pandas as pd
from pandas import Series, DataFrame
# 自动打开一个网页
import webbrowser
link = 'https://www.tiobe.com/tiobe-index/'
webbrowser.open(link)
# 从粘贴板重获取数据存为DataFrame文件
df = pd.read_clipboard()
print(type(df))  # pandas.core.frame.DataFrame
df.columns  # 返回DataFrame所有的列
Index(['Jun 2020', 'Jun 2019', 'Change', 'Programming Language', 'Ratings',
       'Change.1'],
      dtype='object')
df.Change  # 获取df中某一列的数据（本次是选择Change）
# 根据表头过滤数据，生成新的dateframe
df_new = DataFrame(df,columns=['Jun 2020', 'Jun 2019', 'Change'])  
df["Jun 2019"]  # 通过字典的方式访问数据
# 新添加一个column的话，一列值都是NaN
df_new = DataFrame(df,columns=['Change', 'Programming Language', 'Ratings','new_column'])  
df_new['new_column'] = range(10)  # 为这新添加的一列所有元素赋值
df_new['new_column'] = np.arange(10)  # 使用数组赋值
df_new['new_column'] = pd.Series(np.arange(10))  # 使用Series对象赋值
# 使用Series为某一列指定行数赋值
df_new['new_column'] = pd.Series([100,200],index=[1,2]) 
3-3 深入理解Series和Dataframe
data = {
	'Country': ['Belgium','India','Brazil'],
    'Capital':['Brussels','New Belhi','Brasilia'],
	'Population':[11190846,1303171035,207847528]
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
# Series
# 创建一个Series对象
s1 = pd.Series(data['Country'], index=['A','B','C'])
A    Belgium
B      India
C     Brazil
dtype: object
# 为Series对象添加名字
s1.name='Country'  
s1.values  
array(['Belgium', 'India', 'Brazil'], dtype=object)
s1.index
Index(['A', 'B', 'C'], dtype='object')
DataFrame




    

df1 = DataFrame(data)  # DataFrame直接传入字典
cap = df1['Capital']
# 一个DataFrame是由多个Series组成的
type(cap)  
df1.iterrows()  # DataFrame的生成器对象
[i for i in df1.iterrows()]  #  循环生成器取值
使用series对象生成DataFrame
# 生成3个Series对象
s1 = Series(data['Country'])
s2 = Series(data['Capital'])
s3 = Series(data['Population'])
# 通过series对象生成DataFrame，并添加columns
df_new = DataFrame([s1,s2,s3], index=['Country','Capital','Population'])
# 翻转行列
df_new = df_new.T
print(df_new)
3-4 Pandas-Dataframe-IO操作
pandas.pydata.org/pandas-docs…
import numpy as np
import pandas as pd 
from pandas import Series,DataFrame
import webbrowser
link = 'https://pandas.pydata.org/pandas-docs/version/0.20/io.html'
webbrowser.open(link)  # 从浏览器中打开链接
df1 = pd.read_clipboard()  # 从粘贴板读
df1.to_clipboard()  # 将df1写入到粘贴板
df1.to_csv("df1.csv")  # 将dataFrame文件写入到本地csv
!more df1.csv  # 查看csv文件
df2 = pd.read_csv('df1.csv')  # csv的读取
df1.to_json()  # 将 dataframe数据转化为json格式
pd.read_json(df1.to_json())  # 将json格式数据读取为dataframe格式
df1.to_html('df1.html')  # 将dataframe转为html
df1.to_excel('df1.xlsx')  # 将dataframe数据转存为excel
pd.read_excel('df1.xlsx')  # 从excel中读取数据
3-5 DataFrame的Selecting和indexing
import pandas as pd
import numpy as np
from pandas import Series,DataFrame
imdb = pd.read_csv('movie_metadata.csv')  # 读取csv文件
imdb.shape  # 显示（行，列）,是一个元组
imdb.head() # 返回前五行，口号里面可以写行数
imdb.tail()  # 默认但会后五行，之定义的话在括号里填写数字
# 以python字典key的方式
imdb['director_facebook_likes']  # 返回某个column下面的数据
imdb[['director_name','director_name']]  # 返回多个column的数据
sub_df = imdb[['director_name','movie_title','imdb_score']]  # 读取指定列
sub_df.iloc[10:20,0:]    # iloc指定行列，','前面是行切片，后面是列切片
tmp_df = imdb[['director_name','movie_title','imdb_score']].iloc[10:20,0:2]  #  iloc获取10行两列
tmp_df.iloc[2:4,:]  # 获取两行数据
tmp_df.loc[15:17,:'director_name']  # loc指定行，截止列
注：带有i就是基于索引的
3-6 Series和Dataframe的Reindexing
reindex Series
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
s1 = Series([1,2,3,4], index=['A','B','C','D'])  # 生成一个Series对象
s1.reindex(index=['G','A','B','C','D','F','E'])  # 更新索引，不存在值得索引值为NaN
# 更新索引，并且索引对应的值为NaN的话，赋值为10
s1.reindex(index=['G','A','B','C','D','F','E'],fill_value=10)
s2 = Series(['A','B','C'], index=[1,5,10])  # 创建一个Series对象
s2.reindex(index=range(15),method='ffill')  # 索引变成15个，索引向左填充
reindex dataframe
df1 = DataFrame(np.random.rand(25).reshape([5,5]))  # 生成一个5x5的随机小数DataFrame对象
df1 = DataFrame(np.random.rand(25).reshape([5,5]),index= ['A','B','D','E','F'],columns=['c1','c2','c3','c4','c5']) # 生成一个5x5的随机小数DataFrame对象,指定索引和column
df1.reindex(index=['A','B','C','D','E','F'])  # 更新行索引，不存在填充NAN
df1.reindex(columns=['a1','a2','c1','c2'])  # 更新列索引，不存在NaN
df1.reindex(index=['A','B','C','D','E','F'],columns=['a1','a2','c1','c2'])  # 添加行，列的索引
s1.drop('A')  # Series删除一个index
df1.drop('A',axis=0)  #Dataframe删除索引为1的一行
df1.drop('c1',axis=1)  #DataFrame删除column为c1的一列
3-7 谈一谈NaN
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
n = np.nan  # 定义域个NaN数据
type(n)  #float 是一个浮点型数据
m = 1
print(m+n)  # nan,任何数和nan相加还是nan
#定义一个含有NaN数据的Series
s1 = Series([1,2,np.nan,4,5],index=['A','B','C','D','E'])  
s1.isnull()   # 判断是否为NaN
s1.notnull()
s1.dropna()  # 把NaN数据删除掉
# 列表套列表生成DataFrame对象
dframe = DataFrame([[1,2,3],[np.nan,5,6],[7,np.nan,9],[np.nan,np.nan,np.nan]])  
dframe.isnull()
dframe.notnull()
dframe.dropna(axis=0,how='any')    # 删除有NaN的行
dframe.dropna(axis=1,how='any')    # 删除有NaN的列
# 当how='all'的时候，对应行、列都为NaN的时候才删除
删除NaN和NaN的替换
dframe2 = DataFrame([[1,2,3,n],[2,n,5,6],[n,7,n,9],[1,n,n,n]])  # 定义一个4X4的DataFrame对象
dframe2.dropna(thresh=2)  # 大于等于几个非NaN的值得行就留下
dframe2.fillna(value=1)  # 把所有的NaN改成1
dframe2.fillna(value={0:0,1:1,2:2,3:3})  # 字典里面key=列，value=值，把第几列的NaN替换成value
3-8 多级Index
s1 = Series(np.random.randn(6), index=[['1','1','1','2','2','2'],['a','b','c','a','b','c']])  # 常见一个多级index的Series对象
s1['1']['a']  # 2.371817008763328,去index对应的值
s1[:,'a']  # 忽略一级index，直接去二级的index
1    2.371817
2    0.782539
dtype: float64
s1.unstack()  # 拥有多级index的Series通过unstack变成DataFrame
	a	b	c
1	0.487468	1.150074	-1.077194
2	1.068546	-0.459993	-0.131780
df2 = DataFrame([s1['1'],s1['2']])  # 通过两个Series创建DataFrame
	a	b	c
0	0.487468	1.150074	-1.077194
1	1.068546	-0.459993	-0.131780
s2 = df2.T.unstack()  # 将DataFrame变成多级index的Series
df = DataFrame(np.arange(16).reshape(4,4))
# 多级index的DataFrame
df = DataFrame(np.arange(16).reshape(4,4), index=[['a','a','b','b'],[1,2,1,2]],columns=[['BJ','TJ','SH','WH'],[1,2,1,2]])
type(df['BJ'][1])  # df['BJ'][1]
3-9 Mapping和Replace
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
df1 = DataFrame({'城市':['北京','上海','广州'],'人口':[1000,2000,3000]})  # 通过字典创建一个DataFrame
	城市	人口
0	北京	1000
1	上海	2000
2	广州	3000
df1['GDP'] = Series([0.1,0.2,0.3])  # 添加一个Column并且赋值
df1['GDP'] = df1['城市'].map({'北京':1,'上海':2,'广州':3})  # 添加columns和数据
# Replace
s1 = Series(np.arange(10))
0    0
1    1
2    2
3    3
dtype: int64
s1.replace(to_replace=3,value=np.nan)  # 将第三个值替换成NaN
0    0.0
1    1.0
2    2.0
3    NaN
dtype: float64
s1.replace([1,2,3],[10,20,30])  # 同时替换多个值
s1.replace([1,2,3],[10,20,30])  # 同时替换多个值
第4章 Pandas玩转数据
4-1 DataFrame的简单数学计算
Series的运算




    

import numpy as np
import pandas as pd
from pandas import Series,DataFrame
s1 = Series([1,2,3], index=['A','B','C'])
s2 = Series([4,5,6,7], index=['B','C','D','E'])
s1+s2  # 两个Series之间相加，是按照index来的，有因为NaN跟任何数运算都是NaN，所以会出现下述结果
A    NaN
B    6.0
C    8.0
D    NaN
E    NaN
dtype: float64
DataFrame的运算
df1 = DataFrame(np.arange(9).reshape(3,3), index=['A','B','C'], columns=['BJ','SH','WH'])
df2 = DataFrame(np.arange(4).reshape(2,2), index=['A','B'], columns=['BJ','SH'])
df1+df2  # 对应行列位置的数据相加，如果一方为NaN对应数据之和也为NaN
	BJ	GZ	SH
A	0.0	NaN	2.0
B	5.0	NaN	7.0
C	NaN	NaN	NaN
df3 = DataFrame([[1,2,3],[4,5,np.nan],[7,8,9]],index=['A','B','C'], columns=['c1','c2','c3'])
df3.max()  # 每一个column的最大值
df3.sum()# 按照column求和
df3.min()  # 每一个column的最小值
# 注：在括号中加上axis=1就是按照index使用上述方法运算求值
df3.describe()  #  一个dataframe的详细运算信息（按照column来的）
4-2 Series和DataFrame的排序
Series排序
s1 = Series(np.random.randn(10))  # 生成一个值随机的Series
s1.sort_values(ascending=False)  #  series根据value排序，ascending默认为True，降序排列，False为升序排列
s1.sort_index(ascending=True)  # 根据index排序,ascending默认为True，降序排列，False为升序排列
DataFrame排序
df1 = DataFrame(np.random.arange(40).reshape(8,5), columns=['A','B','C','D','E'])
df1['A'].sort_values()  # 获取A这一列的数据，是一个Series，然后根据value排序
df2 = df1.sort_values('A')  # 根据A这一列的数据排序，其他列对应变化
df2.sort_index(ascending=False)  # 根据索引排序，ascending表示正序还是倒叙
df2[['A','B']]  # 获取dataframe指定column，生成一个新的DataFrame
# https://www.kaggle.com/karrrimba/movie-metadatacsv
1 保留imdb_score,director_name,movie_title这几个column
2 使用imdb_score排序，倒序
3 使用一行代码
# code
df = pd.read_csv('movie_metadata.csv')[['imdb_score','director_name','movie_title']].sort_values('imdb_score',ascending=False)
df.iloc[:20,:]  # 取前20条数据
# 或者df.head(20)
4-3 重命名Dataframe的index
df1 = DataFrame(np.random.randn(9).reshape(3,3), index=['BJ','SH','GZ'], columns=['A','B','C'])
# 1直接将索引使用一个新的Series覆盖
df1.index = Series(['bi','sh','gz'])  
# 2使用map遍历每一个index,使之大写，然后覆盖原值
df1.index = df1.index.map(str.upper)  
# 3使用rename修改
df1.rename(index=str.lower,columns=str.lower)  
# 4 使用rename传入字典
df1.rename(index={'BJ':'beijing'}, columns={'A':'a'})
# rename中可以写一个自己定义的函数，然后索引元素一次作用，生成一个新的Series对象
df1.rename(index=lambda x:x+'_ABC') 
4-4 DataFrame的merge操作
df1 = DataFrame({'key':['A','y','z'],'data_set_1':[1,2,3]})
df2 = DataFrame({'key':['A','B','C'],'data_set_2':[4,5,6]})
#  how就是数据库中的内连接，左连接和右连接，外连接，on就是按照那个column做合并
pd.merge(df1,df2,how='left',on='key')  
4-5 Concatenate和Combine
arr1 = np.arange(9).reshape(3,3)
arr2 = np.arange(9).reshape(3,3)
np.concatenate([arr1,arr2])  # 连接两个矩阵，增加行数
np.concatenate([arr1,arr2],axis=1)  # 连接链两个矩阵，在同一行的数据追加
# concat
s1 = Series([1,2],index=['X','Y'])
s2 = Series([3,4], index=['A','B'])
pd.concat([s1,s2])  #  合并两个矩阵,生成一个新的Series
pd.concat([s1,s2], axis=1)  # 生成一个Dataframe
df1 = DataFrame(np.random.randn(9).reshape(3,3), columns=['X','Y','Z'])
df2 = DataFrame(np.random.randn(3,3),columns=['X','Y','A'])
pd.concat([df1,df2])  # 两个dataframe结合
#combine
s1 = Series([1,np.nan,3,np.nan], index=['A','B','C','D'])
s2 = Series([np.nan,2,np.nan,4], index=['A','B','C','D'])
s1.combine_first(s2)  # 使用combine合并两个Series
df1 = DataFrame(
        'A':[1,np.nan,2,np.nan],
        'B':[3,np.nan,4,np.nan],
        'C':[5,np.nan,6,np.nan],
df2 = DataFrame(
        'A':[np.nan,2,np.nan,1],
        'X':[np.nan,3,np.nan,4],
        'Y':[np.nan,5,np.nan,6],
df1.combine_first(df2)  # 结合两个dataframe，类似于数据库的外连接
4-6 通过apply进行数据预处理
批量改变dataframe中的一列或者一行
# 创建一个dataframe数据
df = DataFrame({
    'time':[int(time.time()),int(time.time()),int(time.time()),int(time.time()),int(time.time())],
    'data':['Symbol:APPL Seqno:0 Price:1623','Symbol:APPL Seqno:0 Price:1623','Symbol:APPL Seqno:0 Price:1623','Symbol:APPL Seqno:0 Price:1623','Symbol:APPL Seqno:1 Price:1623',]
df.to_csv('apply_demo.csv')  # 写入到csv文件
pd.read_csv('apply_demo.csv')  # 读取csv文件
df['A']=Series(['a']*5)  # 添加一个column，并且赋值为a
df['A'] = df['A'].apply(str.upper)  # 使用apply将A这个column的value变成大写
# 写一个方法
def foo(line):
    r = [i.split(':')[1] for i in line.strip().split(' ')]
    return Series([i.split(':')[1] for i in df['data'][0].strip().split(' ')])
df_tmp = df['data'].apply(foo)  # 将dataframe中的一列取出来序列化成新的dataframe
# 使用rename将datafram中的column重命名
df_tmp = df_tmp.rename(columns={0:'Symbol',1:'Seqno',2:'Price'})  
df_new = df.combine_first(df_tmp)  # 合并两个dataframe
# 删除datafram中的column
del df_new['data']
del df_new['a']
df_new.to_csv('homework/demo_duplicate.cvs')
4-7 通过去重进行数据清洗
df = pd.read_csv('demo_duplicate.csv')
del df['Unnamed: 0']  # 删除dataframe中的一列数据
df['Seqno'].duplicated()  # 查看一列数据中的数据是否唯一,是一个Series数据
df['Seqno'].unique()  #  取一列数据中的去重后的数据组成一个新的数组
df.size  #  查看DataFrame的大小
len(df)  # 查看DataFrame数据的长度
df['Seqno'].unique()  # 使用unique根据Seqno去重得到一个array
df['Seqno'].drop_duplicates()  # 去除重复 ，一个Series格式的数据
# 根据字段去重,keep默认为first,表示保留第一个，last就是保留最后一个
df.drop_duplicates(['Seqno'], keep='last')  
4-8 时间序列操作基础
from datetime import datetime
s = datetime(2017,9,14)  # 创建一个时间类型的数据
# 创建以一个DataFrame的时间类型数据
date_list = [
    datetime(2016,9,1),
    datetime(2016,9,2),
    datetime(2018,8,8),
    datetime(2017,11,18),
    datetime(2018,11,23)
# 生成了一个Series
s1 = Series(np.random.rand(5),index=date_list)
s1[0]  # 0.3924387445867362
s1[datetime(2016,9,1)]  #  0.3924387445867362
s1['2016-9-1']
2016-09-01    0.392439
dtype: float64
s1['20160901']
2016-09-01    0.392439
dtype: float64
s1['2016-9']
# freq写‘W-MON’是严格按照周一开始的数据
date_list_new = pd.date_range('2000-01-01',periods=100,freq='5H')  # 产生一段时间以内的datetime类型的数据
s2 = DataFrame(np.random.randn(100),index=date_list_new)
4-9 时间序列数据的采样和画图
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
t_range = pd.date_range('2016-01-01','2016-12-31')  # 生成一个时间类型的索引
s1 = Series(np.random.randn(len(t_range)), index=t_range)  # 生成一个Series
s1['2016-01'].mean()  #計算2016-01月份的平均值
s1_month = s1.resample('M').mean()  # 將s1按照月份重新取樣，獲取平均值
s1.resample('H').ffill()  # 按照小时取样
下面展示画图




    

# 下面展示画图
t_range = pd.date_range('2016-01-01','2016-12-31', freq='H')  # 创建时间索引
# 创建一个dataFrame数据
stock_df = DataFrame(index=t_range)  
# 添加一个column,并设置随机值，大小是t_range的长度
stock_df['BABA']=np.random.randint(80,160, size=len(t_range))  
stock_df['TENCENT'] = np.random.randint(30,50, size=len(t_range))
stock_df.plot() # 将dataframe变成图
析入门与实践
我们看到这个图片上面由于数据较多，折线较密集
weekly_df= DataFrame()  # 创建一个新的DataFrame数据
weekly_df['BABA'] = stock_df['BABA'].resample('W').mean()  # 按照周平均值取样
weekly_df['TENCENT'] = stock_df['TENCENT'].resample('W').mean()  # 按照周平均值取样
weekly_df.plot()
4-10 数据分箱技术Binning
score_list = np.random.randint(25,100,size=20)  # 生成一个25-100的随机数组
bins=[0,59,70,80,100]  # 一个分段数组
score_cat=pd.cut(score_list,bins)  # 进行数据分箱
pd.value_counts(score_cat)  # 只用pd.value_counts进行分组和个数显示
(0, 59]      7
(70, 80]     6
(80, 100]    4
(59, 70]     3
dtype: int64
# 对DataFrame数据进行分箱
df = DataFrame()
df['socre'] = score_list
# 实例化学生姓名（随机取三个字符）
df['student'] = [pd.util.testing.rands(3) for i in range(20)]  
# 将score分箱并且赋值给新的column
df['Categories ']=pd.cut(df['socre'],bins,labels=['Low','OK','Good','Great'])  
df.sort_values('socre',ascending=False)  # 根据分数排序
4-11 数据分组技术GroupBy
df1 = pd.read_csv('city_wearther.csv')
g = df1.groupby(df1['city'])  # 按照city分組
g  # 是一个DataFrameGroupBy对象
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x7fcf906c5910>
g.groups  # 查看分組詳情
{'BJ': Int64Index([0, 1, 2, 3, 4, 5], dtype='int64'),
 'GZ': Int64Index([14, 15, 16, 17, 18, 19], dtype='int64'),
 'SH': Int64Index([6, 7, 8, 9, 10, 11, 12, 13], dtype='int64')}
df_bj= g.get_group('BJ')  # 使用'BJ'分组，生成一个新的Dataframe对象
df_bj.mean()  # 求dataframe平均值
temperature    10.000000
wind            2.833333
dtype: float64
df1.mean()  # 求分组的平均值
temperature    7.10
wind           3.35
dtype: float64
# list之后就是列表包含元组，元祖的第一个值就是groupby_name,第二个值是dataframe
list(g)  # 强制类型转换成列表
dict(list(g))  # g可以前置装换成字典，key是groupby_name ,value就是dataframe数据
# 循环字典
for k,v in dict(list(g)).items():
    print(k,v)
4-12 数据聚合技术Aggregation
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
df = pd.read_csv('city_wearther.csv')
g = df.groupby('city')  # 使用city对数据进行分组
g.describe()  # 查看数据详情
g.get_group('BJ')  #查看BJ分组的DataFrame数据
g.agg('max')  # 聚合查询最大值
# 该方法就是最大值减去最小值
def foo(attr):
    return attr.max()-attr.min()
g.agg(foo)
	temperature	wind
BJ	22	3
GZ	35	4
SH	30	3
g_new = df.groupby(['city','wind'])  # 使用两个字段进行分组
g_new.groups  # 分组展示
g.groups  # 查看所有分组
g_new.get_group(('BJ',2))  # 查看该分组下数据
# 循环分组结果
for (name_1,name_2), group in g_new:
    print((name_1,name_2), group)
4-13 透视表
为了更好地展示数据，临时的将表结构进行变更
df.pivot_table
import pandas as pd
import numpy as np
from pandas import Series,DataFrame
df = pd.read_excel('sales-funnel.xlsx')
# index就是索引，可以传多个值
# values就是保留的字段，默认为None
pd.pivot_table(df, index=['Manager','Rep'], values=['Price'])  # aggfun透视表，aggfunc='mean'表示求平均值
# aggfunc就是聚合查询
# columns就是二级column
pd.pivot_table(df, index=['Manager','Rep'], values=['Price','Quantity'],aggfunc='sum',columns=['Product'],fill_value=0) 
4-14 分组和透视功能实战
projects.fivethirtyeight.com/flights/
第5章 绘图和可视化之Matplotlib
5-1 Matplotlib介绍
为什么用Python画图？
GUI太复杂
Excel太头疼
Python简单，免费（sorry Matlab）
什么是matplotlib?
一个Python包
用于2D绘图
非常强大和流行
有很多扩展
hello world in matplotlib
import matplotlib .pyplot as plt
import numpy as np
%matplotlib inline
# 从0到100两倍的pi间隔取数
x = np.linspace(0,2*np.pi,100)
y = np.sin(x)
plt.plot(x,y)
Matplotlib Architecture
Matplotlib的架构
backend:主要处理把图显示到哪里和画到哪里
Artist:图像显示成什么样
scripting:pyplot ,python语法和API
5-2 matplotlib简单绘图之plot
import numpy as np
import matplotlib.pyplot as plt
a = [1,2,3]
b=[4,5,6]
# 传入一个列表，x=index,y=list
# 传入两个列表，x=list1,y=list2
plt.plot(a,b)
plt.show()  # 显示图像
#在jupyter中提供了一个Magical function（魔法函数）
%matplotlib inline
%timeit np.arange(10)  # 模范函数，计算执行时间
plt.plot(a,b,'r--')  # 设置线条的颜色和样式
c=[10,8,6]
d=[1,8,3]
plt.plot(a,b,c,d)  # 画一组线
#也可以执行两组线的风格和颜色
plt.plot(a,b, 'r--', c,d, 'g+')
t = np.arange(0.0,2.0,0.1)
s = np.sin(t*np.pi)	
# 设置右上角线条说明
plt.plot(t,s,'r--',label='aaaa')
plt.plot( t*2,s,'b--',label='bbbb')
# 设置label
plt.xlabel('this is x')
plt.ylabel('this is y')
# 设置标题
plt.title('this is title')
plt.legend()  #配合说明使用
5-3 matplotlib简单绘图之subplot
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0.0, 5.0)  # 生成50个数据，间隔为0.1
y1 = np.sin(np.pi*x)
y2 = np.sin(np.pi*x*2)
plt.plot(x,y1,'b--',label='sin(pi*x)')
plt.ylabel('y1 value')
plt.plot(x,y2,'r--', label='sin(pi*2x)')
plt.ylabel('y2 value')
plt.xlabel('x value')
plt.title('thsi is x-y value')
plt.legend()
# subplot  子图
# 把整个图进行切分
plt.subplot(2,1,1)  # 两行一列的数据，取第一个
plt.plot(x,y1,'b--')
plt.ylabel('y1')
plt.subplot(2,1,2)  # 两行一列的数据，取第二个
plt.plot(x,y2,'r--')
plt.ylabel('y2')
plt.xlabel('x')
还有下面这种方式画子图，两行两列，第几个
另外一种画子图的方式
figure,ax = plt.subplots(2,2)  # 将画布分为2x2的布局
ax[0][0].plot(x,y1)  # 第一行的第一列
ax[0][1].plot(x,y2)  # 第一行的第二列
5-4 Pandas绘图之Series
import pandas as pd
import numpy as np
from pandas import Series,DataFrame
import matplotlib.pyplot as plt
 # cumsum中每一项都是前面几项累加的和
s1 = Series(np.random.randn(1000)).cumsum() 
s2 = Series(np.random.randn(1000)).cumsum()
# kind: bar柱状 line折线
# grid显示方格
# label图例
s1.plot(kind='line',grid=True,label='S1',title='this is Series',style='r--')
s2.plot(label='S2')
plt.legend()  # 配合label使用
# 通过子图画Series数据
fig,ax = plt.subplots(2,1)
ax[0].plot(s1)
ax[1].plot(s2)
fig,ax = plt.subplots(2,1)
# 通过设置ax指定画板，并且可以设置样式和label
s1.plot(ax=ax[0],label='S1',style='r--')
s2.plot(ax=ax[1],label='S2',style='b')
# 设置数据样式,可以截取数据
fig,ax = plt.subplots(2,1)
s1[0:10].plot(ax=ax[0],label='S1',kind='bar')
s2.plot(ax=ax[1],label='S2',kind='line')
5-5 Pandas绘图之DataFrame
import pandas as pd
import numpy as np
from pandas import Series,DataFrame
import matplotlib.pyplot as plt
# 设置一个10行四列的值在1,10之间的随机DataFrame数据
df = DataFrame(
    np.random.randint(1,10,40).reshape(10,4),
    columns=['A','B','C','D']
# kind:line折线图，bar柱形图，barh横向柱形图
df.plot(kind='barh')
# stacked表示同一个索引下的所有的column堆叠在一起显示
df.plot(kind='bar',stacked=True)
# kind='area'填充的线形图
df.plot(kind='area')
df.iloc[5].plot()  # 第五行的取值,得到一个Series数据，并画图
# 按照行来画df中所有Series的图
for i in df.index:
    df.iloc[i].plot(label=str(i))
plt.legend()
# dataframe按照列来画图
for i in df.columns:
    df[i].plot(label=str(i))
plt.legend()
# df.plot默认按照行来画图，使用T转置
df.T.plot()
5-6 直方图和密度图
import pandas as pd
import numpy as np
from pandas import Series,DataFrame
import matplotlib.pyplot as plt
s = Series(np.random.randn(1000))
plt.hist(s,rwidth=0.9)  # 直方图
plt.hist(s,rwidth=0.9,bins=20,color='r')
s.plot(kind='kde')  # kind='kde'就是密度图，在取值范围内的密度
39.png)




    

第6章 绘图和可视化之Seaborn
Seaborn是对Matplotlib的进一步封装，其强大的调色功能和内置的多种多样的绘图模式，使之成为当下最流行的数据科学绘图工具。本章将介绍Seaborn的基本使用，以及和matplotlib的功能对比。
6-1 seaborn介绍
Seaborn- Powerful Matplotlib Extension  :强大的Matplotlib扩展
statistical data visualization  统计数据可视化
Seaborn的优势在哪里？
简单，快捷的可视化工具包
鸢尾花长度散点图
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
iris = pd.read_csv('iris.csv')
#获取Name这一列的唯一数据，是一个数组
iris.Name.unique()  #array(['Iris-setosa', 'Iris-versicolor', 'Iris-virginica'], dtype=object)
# 将name和颜色组成一个字典
color_map = dict(zip(iris.Name.unique(), ['blue','green','red']))
matplotlib画图
# matplotlib画图
#for species,group in iris.groupby('Name'):
#    print(species,group)
for species,group in iris.groupby('Name'):
    plt.scatter(
        group['PetalLength'],group['SepalLength'],
        color=color_map[species],
        alpha=0.3,edgecolor=None,
        label=species
plt.legend(frameon=True,title='Name')  # 輔助顯示label
plt.xlabel('petalLength')  #x轴label名
plt.ylabel('sepalLength')  # y轴label名
使用seaborn画图
sns.lmplot('PetalLength','SepalLength',iris,hue='Name',fit_reg = False)
6-2 seaborn实现直方图和密度图
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame
%matplotlib inline
# 导入seaborn
import seaborn as sns
s1 = Series(np.random.randn(1000))  # 生成一个随机的Series
# matplotlib实现直方图
plt.hist(s1)
# Series实现密度图
s1.plot(kind='kde')
# kde 就是是否画密度图
# rug 是否在支撑轴上绘制加固图,就是下方出现的小数线，反应数值密度
sns.distplot(s1,hist=True,kde=True,rug=True)  # 根据数据画直方图和密度图
seaborn直接画图
# seaboen.kdeplot参数
# shade 是否填充
# color 颜色
sns.kdeplot(s1,shade=True,color='green')
plt.hist(s1)  # 画直方图
sns.rugplot(s1)  # 实现密度
6-3 seaborn实现柱状图和热力图
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt
import seaborn as sns
#为了每次自动出现图片
%matplotlib inline  
获取一些试验的数据，采用下面的方法实现
# 获取线上数据进行试验
# name in ['tips','flights','exercise','titanic']
df = sns.load_dataset('flights')
Michael Waskom的github，上面有很多的csv文件实例
github.com/mwaskom/sea…
# 利用透视表来重置df数据
df = df.pivot(index='month',columns='year', values='passengers')
# 非常方便的看一年的数据
生成热力图--sns.heatmap
# 使用sns.heatmap生成热力图
# 参数展示
# annot就是展示参数的时候使用的|
sns.heatmap(df,annot=True,fmt='d')  
df.plot(kind='area') #面积图
s = df.sum()  # 默认将对应列的所有行数据相加，编程一个Series数据
sns.barplot(x=s.index,y=s.values)  # 使用sns.barplot传x,y数据成柱状图
# 使用matplotlib画一个柱状图
s.plot(kind='bar')
6-4 seaborn图形显示效果的设置
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from pandas import Series,DataFrame
import seaborn as sns
%matplotlib inline
# 生成一个0到14的等差数列，数量是一百个
x = np.linspace(0,14,100)
y1 = np.sin(x)
y2 = np.sin(x+1)*1.25
def sinplot():
    plt.plot(x,y1,color='red',)
    plt.plot(x,y2,label='blue')
sinplot()
# seaborn自定义的五种风格,主题
style=['darkgrid','dark','white','whitegrid','tricks']
sns.set_style(style[0],{'grid.color': 'blue'})  # 设置主题，并更改主题相关
sinplot()
# 当前主题下的参数
sns.axes_style()
sns.set()   #seaborn恢复默认参数
plotting_context()and set_context()
context = ['paper','notebook','poster']  # 上下文环境
# 通过更改context可以实现改变context
# 使用rc={'grid.linewidth':3.0}可以实现网格线的微调
sns.set_context(context[1],rc={'grid.linewidth':3.0}) 
sns.plotting_context()#显示当前的context
sns.set()  # 恢复默认值
6-5 seaborn强大的调色功能
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt
%matplotlib inline
# 实现一个画图的方法
def sinplot():
    x = np.linspace(0,14,100)
    plt.figure(figsize=(8,6))  # 调整图像的大小
    for i in range(4):
        plt.plot(x, np.sin(x+i)*(i+0.75),label='sin(x+{})*({}+0.75)'.format(i,i))
    plt.legend()
import seaborn as sns
sinplot()  # 运行之后会发现颜色发生变化
# 调色板
sns.color_palette()  #RGB 每一个tuple就是rgb，三原色
# sns.palplot()将调色板中的值绘制为水平数组。
# sns.palplot(sns.color_palette())
# 传输组，tuple,
sns.palplot([(0.2980392156862745, 0.4470588235294118, 0.6901960784313725)])
# seaborn自带的集中调色板参数
pal_style=['deep','muted','pastel','bright','dark','colorblind']
# seaborn自带的几种调色板
sns.palplot(sns.color_palette(pal_style[4]))
# 给图画设置色板
sns.set_palette(sns.color_palette(pal_style[4]))
# 临时更改画板色板的方法
# 在with下执行的画图颜色就根据with后定义的来显示，外面的代码就不会按照with里面的样式了
with sns.color_palette('dark'):
    sinplot()
# 默认色板的颜色有6种，但是我需要更多地怎么办呢？
pal2 = sns.color_palette('hls',8)  # 生成有8种颜色风格的色板
sns.palplot(pal2)  # 显示八种颜色的色板
seaborn官网消息讲述色板博文
seaborn.pydata.org/tutorial/co…
第7章 数据分析项目实战
通过前六章的学习，我们基本上掌握了数据分析领域里主要工具的使用，本章将通过一个股票市场的分析实战项目，和大家一起用学过的知识去分析数据，进而得到有用的信息。
7-1 实战准备
数据分析数据源
# B 站全站视频信息爬虫
  https://github.com/chenjiandongx/bili-spider 
# 数据分析和挖掘有哪些公开的数据来源？
 https://www.zhihu.com/question/19969760 
# kaggle-机器学习都会用的网站
 https://www.kaggle.com/ 
# google上直接搜索
google public data
# 亚马逊公开数据源
https://registry.opendata.aws/
7-2 股票市场分析实战之数据获取
雅虎上面获取股票数据
finance.yahoo.com/
使用工具去抓取股票的信息
pandas-datareader
安装pandas-datareader
# linux中切换到文件夹
/root/anaconda3/bin
# pip 安装pandas_datareader
pip install pandas_datareader
# pandas_datareader官网
https://pandas-datareader.readthedocs.io/en/latest/
阿里巴巴股票数据的获取
import pandas_datareader as pdr
# 获取阿里巴巴股票数据
alibaba = pdr.get_data_yahoo('BABA')  
alibaba.head()
alibaba.shape  # （行，列）的数量
alibaba.tail()  # 最后五条数据
alibaba.describe()  # 基本信息
alibaba.info  # 看基本信息
7-3 股票市场分析实战之历史趋势分析
# 基本信息
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
# 股票数据的读取
import pandas_datareader as pdr
# 可视化
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
# time
from datetime import datetime
从雅虎上获取阿里巴巴和亚马逊的股票数据
start = datetime(2015,9,20)
end = datetime(2017,11,30)
alibaba = pdr.get_data_yahoo('BABA',start=start,end=end)
amazon = pdr.get_data_yahoo('AMZN',start=start,end=end)
df直接画图
alibaba['Adj Close'].plot(legend=True)  # 股票价格走势图
alibaba['Volume'].plot(legend=True)  # 股票交易量走势
# 两个公司的股票价格放到一张图中，比较价格
alibaba['Adj Close'].plot()
amazon['Adj Close'].plot()
# 一段时间内股票价格的差值画图
alibaba['high-low'] = alibaba['High']-alibaba['Low']  # 添加一个column,反应当天股票的最高价-最低价
alibaba['high-low'].plot()
# daily return  每天的变化情况
# pct_change 就是当前元素与先前元素相差百分比
alibaba['daily-return'] = alibaba['Adj Close'].pct_change()  
alibaba['daily-return'].plot()  
# 以英寸为单位的元组(宽、高)
# linestyle改变线的风格
# marker:标记，o表示一个点,没个数据点显示一个加粗的点，取值比较明显
alibaba['daily-return'].plot(figsize=(10,4),linestyle='--',marker='o')  
alibaba['daily-return'].plot(kind='hist')  # 画一个直方图
seaborn来画图
# distplot画直方图和密度图
# dropna是忽略Series的NaN数据
# bins就是将所有的数据进行分段，然后画图
# color就是图所包含的颜色
sns.distplot(alibaba['daily-return'].dropna(),bins=100,color='purple')
7-4 股票市场分析实战之风险分析
# 基本信息
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
# 股票数据的读取
import pandas_datareader as pdr
# 可视化
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
# time
from datetime import datetime
start = datetime(2018,1,1)
company=['AAPL','GOOG','MSFT','AMZN','FB']
# 获取这五家公司的Adj Close组成一个DataFrame
top_tech_df = pdr.get_data_yahoo(company,start=start)['Adj Close']
top_tech_dr = top_tech_df.pct_change()  # pct_change是当前元素与先前元素相差百分比
top_tech_df.plot()  # 五家公司价格走势图
top_tech_df[['AAPL','FB','MSFT']].plot()  # 苹果，facebook,微软三家公司股价的走势
sns.jointplot('AMZN','GOOG',top_tech_dr,kind='scatter')  # kind='scatter'散点图
sns.pairplot(top_tech_dr.dropna())  # 根据x坐标和y坐标画散点图
vips.pct_change().quantile(0.2)
写在后面：
机器学习和数据分析我们在工作和日常中都可以使用到的
在后面的学习过程中，我们可以去kaggle中找到相关案例，然后练习
www.kaggle.com/kernels
  
分类：




    
 人工智能
 
 
   
相关推荐
 
  
        骆昊的技术专栏
        Python
      
 
   从零开始学Python第12课：常用数据结构之集合
 
Python 中的集合类型是一种无序容器，不允许有重复运算，由于底层使用了哈希存储，集合中的元素必须是hashable类型。集合与列表最大的区别在于集合中的元素没有顺序、所以不能够通过索引运算访问元素
 
 1038
 
 
        昨天下雨了
      
 
   免费AI编程工具- AWS CodeWhisperer安装（IDEA）
 
一、介绍 CodeWhispere介绍：可以根据IDE中的注释或者现有的一些提示、代码，来生成代码段或者建议。支持多种编程语言，可以和常用的IDE进行无缝集成。和GitHub Copilot和Curs
 
 63
 
 
        DS小龙哥
      
 
   基于STM32设计的实时心率检测仪
 
PulseSensor 是一款用于脉搏心率测量的光电反射式模拟传感器。可以将其佩戴于手指、耳垂、手腕等处，通过杜邦线--导线将引脚连接到单片机，可将采集到的模拟信号传输给单片机，单片机配置ADC。
 
 379
 





    
 
        天天不吃饭啊
        Python
      
 
   揭秘PC端爬虫工程师必备的网络请求技巧，让你轻松采集所需数据
 
网络请求是爬虫工程师采集数据的重要手段之一。在PC端爬虫中，网络请求通常使用HTTP协议进行通信，通过发送HTTP请求获取目标网站的数据。 爬虫工程师需要掌握HTTP协议的基本知识，包括HTTP请求和
 
 392
 
 
        字节跳动数据平台
      
 
   火山引擎 DataLeap：从短视频 APP 实践来看，如何统一数据指标口径？
 
短视频正在成为越来越多人发现世界的窗口，其背后的创作者生态建设是各大短视频 APP 不可忽视的重要组成部分。 为了激励更多优质内容生产，某短视频 APP 经常面向创作者主办投稿活动，而在复盘投稿数据过
 
 755
 
 
      
 
   安卓平台下的即时通讯技术深入解析【实时聊天应用开发实战】
 
摘要： 本文将详细介绍如何使用安卓开发技术实现一个实时聊天应用。我们将通过构建一个基于安卓平台的聊天应用，演示如何处理用户注册、登录、消息发送和接收等关键功能。文章将涵盖安卓开发的各个方面，包括用户界
 
 153
 
 
        数据存储张
      
 
   初识SPDK，从SPDK的软件架构到使用实操
 
相信很多做存储的同学都听说过SPDK，它是Intel开发的一套开源存储栈。SPDK的全称为存储高性能开发包（Storage Performance Development Kit），从名称可以看出SP
 
 214
 
 
      
 
   初识Dapr




    
 
Dapr 是一个可移植的、事件驱动的运行时，它使任何开发人员能够轻松构建出弹性的、无状态和有状态的应用程序。
 
 57
 
 
        啊vvvv
        Redis
      
 
   Redis中的哈希结构（Dict）
 
前言 哈希结构是一个在计算机中非常常见的结构。哈希结构可以让我们在O(1)时间复杂度查找元素并且对其操作，并且增删改查性能并不会随着数据量的增多而改变。反而数据量的增大，会出现两个关键问题，一个是哈希
 
 119
 
 
        梦想橡皮擦
        Python
      
 
   都 2022 年了，你真的会用 Python 的 pip 吗？
 
携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第9天，点击查看活动详情 ⛳️ 写文的原因 学习 Python 的过程中，经常会使用 pip 命令去安装第三方模块，但细细琢磨下来，
 
 1491
 
 
        阿里云云原生
      
 
   Koordinator 最佳实践系列：精细化 CPU 编排
 
本文主要介绍当不同类型工作负载混合部署在同一个节点上时，Koordinator 如何帮助负载之间（在线和在线、在线和离线）协同地共享 CPU 资源。
 
 603
 
 
        also_lucky
      
 
   cookie&session（上）
 
在日常生活中，从拨通电话到挂断电话之间的一连串的你问我答的过程就是一个会话。Web应用中的会话过程类似于生活中的打电话过程，它指的是一个客户端（浏览器）与Web服务器之间连续发生的一系列请求和响应过程
 
 251
 
 
        华为云开发者联盟
      
 
   Kubernetes 集群管理：Kurator or Kubespray
 
Kubespray 和 Kurator 就是这类开源工具的典型代表。本篇文章将对这两款工具进行比较。
 
 131
 
 
        蜀山剑客李沐白
        Linux
      
 
   Linux 挂载磁盘详解及实操步骤
 
Linux中挂载磁盘是一项重要的操作，可以用于扩展存储空间，管理数据文件，备份和存储重要文件等。本文将详细介绍Linux系统中挂载磁盘的相关概念、步骤和实际操作指南。
 
 293
 
 
          
 
 
  
 
 
友情链接：
 

        geturl 调用js
        get方式传送json数据
        android adblock plus java过滤算法
        mysql 不停机迁移
        js 获取顺序数字
    勇哥的ID
        python开发 @ Never give up