关联算法python

⑴ python apriori算法代码怎么实现

classApriori(object):
def__init__(self,filename,min_support,item_start,item_end):
self.filename=filename
self.min_support=min_support#最小支持度
self.min_confidence=50
self.line_num=0#item的行数
self.item_start=item_start#取哪行的item
self.item_end=item_end
self.location=[[i]foriinrange(self.item_end-self.item_start+1)]
self.support=self.sut(self.location)
self.num=list(sorted(set([jforiinself.locationforjini])))#记录item
self.pre_support=[]#保存前一个support,location,num
self.pre_location=[]
self.pre_num=[]
self.item_name=[]#项目名
self.find_item_name()
self.loop()
self.confidence_sup()
defdeal_line(self,line):
"提取出需要的项"
return[i.strip()foriinline.split('')ifi][self.item_start-1:self.item_end]
deffind_item_name(self):
"根据第一行抽取item_name"
withopen(self.filename,'r')asF:
forindex,lineinenumerate(F.readlines()):
ifindex==0:
self.item_name=self.deal_line(line)
break
defsut(self,location):
"""
输入[[1,2,3],[2,3,4],[1,3,5]...]
输出每个位置集的support[123,435,234...]
"""
withopen(self.filename,'r')asF:
support=[0]*len(location)
forindex,lineinenumerate(F.readlines()):
ifindex==0:continue
#提取每信息
item_line=self.deal_line(line)
forindex_num,iinenumerate(location):
flag=0
forjini:
ifitem_line[j]!='T':
flag=1
break
ifnotflag:
support[index_num]+=1
self.line_num=index#一共多少行,出去第一行的item_name
returnsupport
defselect(self,c):
"返回位置"
stack=[]
foriinself.location:
forjinself.num:
ifjini:
iflen(i)==c:
stack.append(i)
else:
stack.append([j]+i)
#多重列表去重
importitertools
s=sorted([sorted(i)foriinstack])
location=list(sfors,_initertools.groupby(s))
returnlocation
defdel_location(self,support,location):
"清除不满足条件的候选集"
#小于最小支持度的剔除
forindex,iinenumerate(support):
ifi<self.line_num*self.min_support/100:
support[index]=0
#apriori第二条规则,剔除
forindex,jinenumerate(location):
sub_location=[j[:index_loc]+j[index_loc+1:]forindex_locinrange(len(j))]
flag=0
forkinsub_location:
ifknotinself.location:
flag=1
break
ifflag:
support[index]=0
#删除没用的位置
location=[ifori,jinzip(location,support)ifj!=0]
support=[iforiinsupportifi!=0]
returnsupport,location
defloop(self):
"s级频繁项级的迭代"
s=2
whileTrue:
print'-'*80
print'The',s-1,'loop'
print'location',self.location
print'support',self.support
print'num',self.num
print'-'*80
#生成下一级候选集
location=self.select(s)
support=self.sut(location)
support,location=self.del_location(support,location)
num=list(sorted(set([jforiinlocationforjini])))
s+=1
iflocationandsupportandnum:
self.pre_num=self.num
self.pre_location=self.location
self.pre_support=self.support
self.num=num
self.location=location
self.support=support
else:
break
defconfidence_sup(self):
"计算confidence"
ifsum(self.pre_support)==0:
print'min_supporterror'#第一次迭代即失败
else:
forindex_location,each_locationinenumerate(self.location):
del_num=[each_location[:index]+each_location[index+1:]forindexinrange(len(each_location))]#生成上一级频繁项级
del_num=[iforiindel_numifiinself.pre_location]#删除不存在上一级频繁项级子集
del_support=[self.pre_support[self.pre_location.index(i)]foriindel_numifiinself.pre_location]#从上一级支持度查找
#printdel_num
#printself.support[index_location]
#printdel_support
forindex,iinenumerate(del_num):#计算每个关联规则支持度和自信度
index_support=0
iflen(self.support)!=1:
index_support=index
support=float(self.support[index_location])/self.line_num*100#支持度
s=[jforindex_item,jinenumerate(self.item_name)ifindex_itemini]
ifdel_support[index]:
confidence=float(self.support[index_location])/del_support[index]*100
ifconfidence>self.min_confidence:
print','.join(s),'->>',self.item_name[each_location[index]],'min_support:',str(support)+'%','min_confidence:',str(confidence)+'%'
defmain():
c=Apriori('basket.txt',14,3,13)
d=Apriori('simple.txt',50,2,6)
if__name__=='__main__':
main()

Apriori(filename, min_support, item_start, item_end)

参数说明

filename:(路径)文件名
min_support:最小支持度
item_start:item起始位置

item_end:item结束位置

importapriori
c=apriori.Apriori('basket.txt',11,3,13)

输出：

⑵ python 关联规则分前项后项吗

学了两天python，想实践下，正好最近在学习数据挖掘，先用python实现下

注：由于后面加了注释，由于编码问题，可能即使是注释，有的环境也不支持汉字的编码，运行报错的话可以将汉字删除后再运行

环境 ubuntu 13.4 python 2

[python]view plain

• importitertools

• import

• '''''

• 定义全局变量k，即支持度计数k,此k也可以在运行程序之前输入，简单改动即可

• '''

• k=2

• '''''

• 存储频繁项集的列表

• '''

• frequenceItem=[]

• '''''

• 从txt文件dataset.txt里获取事务集

• '''

• defgetDataSet(args):

• f=open(args,'r')

• source=f.readlines()

• f.close()

• dataset=[]

• forlineinsource:

• temp1=line.strip(' ')

• temp2=temp1.split(',')

• dataset.append(temp2)

• returndataset

• '''''

• 初步扫描事务集，从事务集里获取候选1项集

• 方法的基本思路是：

• 定义一个集合tmp，将事务集的第一项作为tmp的初始集合

• 然后扫描事务集，将不在tmp里的数据项加入tmp中

• '''

• deffind_item(dataset):

• length=len(dataset)

• foriinrange(0,length):

• ifi==0:

• tmp=set(dataset[i])

• tmp.update(set(dataset[i]))

• candidate=list(tmp)

• candidate.sort()

• returncandidate

• '''''

• 从候选项集里找出频繁项集，其中num代表频繁num+1项集

• 如num为0的为从候选1项集里找出频繁1项集

• 方法基本思路：

• 1、定义一个支持度列表count

• 2、对于每一个候选项，依次扫描事务集，如果该项出现在事务集中就将该项对应的count+1、定义一个支持度列表count+1

• 3、将每一项的count和k（支持度计数）进行比较，将count小于k的项剔除

• '''

• deffind_frequent(candidate,dataset,num):

• frequence=[]

• length=len(candidate)

• count=[]

• foriinrange(0,length):

• count.append(0)

• count[i]=0

• ifnum==0:

• '''''

• 其实不管num为0还是别的值算法应该是一样的，但是由于程序实现上的问题

• num为0的时候选项集是一维列表，其它的时候，候选项集是二维列表，

• 毕竟只是自己写着玩的，python还不熟，牵一发而动全身，懒得改了

• '''

• child=set([candidate[i]])

• else:

• child=set(candidate[i])

• forjindataset:

• parent=set(j)

• ifchild.issubset(parent):

• count[i]=count[i]+1

• forminrange(0,length):

• ifcount[m]>=k:

• frequence.append(candidate[m])

• returnfrequence

• '''''

• 先验定理，剪枝掉不必要的候选n项集

• 方法思路：

• 1、依次取出候选项集里的项

• 2、取出n项集里的n-1项子集

• 3、如果所有的n-1项集不都都是频繁n-1项集的子集，则删除该候选项集

• '''

• defpre_test(candidate,num,frequence):

• r_candidate=.deep(candidate)

• foreachincandidate:

• foreach2initertools.combinations(each,num):

• tmp=(list(each2))

• tag=0

• forjinfrequence:

• ifnum==1:

• if(tmp[0]==j):

• tag=1

• break

• else:

• iftmp==j:

• tag=1

• break

• iftag==0:

• r_candidate.remove(each)

• break

• returnr_candidate

• '''''

• 通过频繁n-1项集产生候选n项集，并通过先验定理对候选n项集进行剪枝

• 方法思路：

• 1、如果是频繁1项集，则通过笛卡尔积产生频繁2项集

• 2、如果不是频繁一项集，采用F（k-1）*F（k-1）方法通过频繁n-1项集产生候选n项集

• 注：F（k-1）*F（k-1）方法在我的另一篇关联算法博客上做了理论上的简单介绍，或者也可以直接参看《数据挖掘导论》

• '''

• defget_candidata(frequence,num):

• length=len(frequence)

• candidate=[]

• ifnum==1:

• foreachinitertools.combinations(frequence,2):

• tmp=list(each)

• tmp3=[]

• tmp3.append(tmp[0])

• tmp3.append(tmp[1])

• candidate.append(tmp3)

• else:

• foriinrange(0,length-1):

• tmp1=.deep(frequence[i])

• tmp1.pop(num-1)

• forjinrange(i+1,length):

• tmp2=.deep(frequence[j])

• tmp2.pop(num-1)

• iftmp1==tmp2:

• tmp3=.deep(frequence[i])

• tmp3.append(frequence[j][num-1])

• candidate.append(tmp3)

• candidate2=pre_test(candidate,num,frequence)

• returncandidate2

• '''''

• main程序

• '''

• if__name__=='__main__':

• dataset=getDataSet('dataset.txt')

• Item=find_item(dataset)

• num=0

• frequenceItem=[]

• '''''

• 通过事务集找到频繁项集，直至频繁n项集为空，则退出循环

• '''

• while1:

• ifnum==0:

• candidate=Item

• else:

• candidate=get_candidata(frequenceItem[num-1],num)

• frequenceItem.append(find_frequent(candidate,dataset,num))

• iffrequenceItem[num]==[]:

• frequenceItem.pop(num)

• break

• num=num+1

• '''''

• 打印出频繁项集

• '''

• foreachinfrequenceItem:

• printeach




目录位置：

⑶ Python购物篮数据（关联分析）

pip install mlxtend

由于已经是csv格式，所以直接输入：

每一行： 一个购物篮

每一列： 购物篮中的商品

先看看pd读的对不对：

然后按行打印：

再将这些存在一个数组中：

1、什么是独热码

独热码，在英文文献中称做 one-hot code, 直观来说就是有多少个状态就有多少比特，而且只有一个比特为1，其他全为0的一种码制，更加详细参加 one_hot code（维基网络） 。在机器学习中对于离散型的分类型的数据，需要对其进行数字化比如说性别这一属性，只能有男性或者女性或者其他这三种值，如何对这三个值进行数字化表达？一种简单的方式就是男性为0，女性为1，其他为2，这样做有什么问题？

使用上面简单的序列对分类值进行表示后，进行模型训练时可能会产生一个问题就是特征的因为数字值得不同影响模型的训练效果，在模型训练的过程中不同的值使得同一特征在样本中的权重可能发生变化，假如直接编码成1000，是不是比编码成1对模型的的影响更大。为了解决上述的问题，使训练过程中不受到因为分类值表示的问题对模型产生的负面影响，引入独热码对分类型的特征进行独热码编码。

        可以这样理解，对于每一个特征，如果它有m个可能值，那么经过独热编码后，就变成了m个二元特征（如成绩这个特征有好，中，差变成one-hot就是100, 010, 001）。并且，这些 特征互斥 ，每次只有一个激活。因此，数据会变成稀疏的。

这样做的好处主要有：

（1）解决了分类器不好处理 属性数据 的问题

（2）在一定程度上也起到了 扩充特征 的作用

                                        M

以下为我摘取的别人的，贴上原文链接https://blog.csdn.net/hellozhxy/article/details/80600845

着名的啤酒与尿布, 这是典型的购物篮问题, 在数据挖掘界叫做频繁项集(Frequent Itemsets).

note: 数据类型写法按照Python的格式.

一. 目标与定义

1. 问题背景

超市中购物清单中总是有一些项目是被消费者一同购买的. 如果我们能够发现这些 关联规则 (association rules), 并合理地加以利用, 我们就能取得一定成果. 比如我们发现热狗和芥末存在这种关系, 我们对热狗降价促销, 而对芥末适当提价, 结果能显着提高超市的销售额.

2. 目标

找到频繁地 共同 出现在消费者结账小票中项目(比如啤酒和尿布), 来一同促销, 相互拉动, 提高销售额.

3. 定义

支持度support: 其实就是概率论中的频次frequency

支持度阈值support threshhold: 记为s, 指分辨频繁项集的临界值.

频繁项集: 如果I是一个项集(Itemset), 且I的出现频次(i.e.支持度)大于等于s, 那么我们说I是频繁项集.

一元项, 二元项, 三元项: 包含有一种商品, 两种, 三种商品的项集.

4. 关联规则

关联规则: 形式为I->j, 含义是如果I种所有项都出现在某个购物篮的话, 那么j很有可能也出现在这个购物篮中. 我们可以给出相应的confidence值(可信度, 即概率论中的置信度).

其中, 这个关联规则的可信度计算为Confidence = I∪{j} / I, 本身是非常符合直觉和常识的. 比如我们说关联规则{dog, cat} -> and 的可信度为0.6, 因为{dog, cat}出现在了1, 2, 3, 6, 7五个购物篮中, 而and出现在了1,2,7中, 因此我们可以算出Confidence = freq[{dog, cat, and}] / freq[{dog, cat}] = 3/5 = 0.6

注意到, 分子部分的频次总是比分母低, 这是因为{dog, cat} 出现的次数总是大于等于{dog, cat, and}的出现次数.

二. 购物篮与A-Priori算法

1. 购物篮数据表示

我们将有一个文本文件输入, 比如allBills.txt, 或者allBills.csv. 里面每行是一个购物篮.

文件的头两行可能是这样(df.show(2)):

{23, 456, 1001}

{3, 18, 92, 145}

我们假定这是一家大型连锁超市, 比如沃尔玛, 因此这个文本文件是非常大的, 比如20GB. 因此我们无法一次将该文件读入内存. 因此, 算法的主要时间开销都是磁盘IO.

我们同时还假定, 所有购物篮的平均规模是较小的, 因此在内存中产生所有大小项集的时间开销会比读入购物篮的时间少很多.

我们可以计算, 对于有n个项目组成的购物篮而言, 大小为k的所有子集的生成时间约为(n, k) = n! / ((n-k)!k!) = O(n^k/ k!), 其中我们只关注较小的频繁项集, 因此我们约定k=2或者k=3. 因此所有子集生成时间T = O(n^3).

Again, 我们认为 在内存中产生所有大小项集的时间开销会比读入购物篮的时间少很多.

2. Itemset计数过程中的内存使用

我们必须要把整个k,v字典放在内存中, 否则来一个Itemset就去硬盘读取一次字典将十分十分地慢.

此处, 字典是k=(18, 145), v=15这种形式. 此处, 应当注意到, 如果有{bread, milk, orange}这样的String类型输入, 应当预先用一个字典映射成对应的整数值编码, 比如1920, 4453, 9101这样.

那么, 我们最多能用字典存储多少种商品?

先看下我们存储多少个count值.

我们假定项的总数目是n, 即超市有n种商品, 每个商品都有一个数字编号, 那么我们需要(n, 2) = n^2/2 的大小来存储所有的二元组合的count, 假设int是占4个byte, 那么需要(2·n^2)Byte内存. 已知2GB内存 = 2^31 Byte, 即2^31/2 = 2^30 >= n^2 --> n <= 2^15. 也就是说n<33 000, 因此我们说商品种类的最多是33k种.

但是, 这种计算方法存在一个问题, 并不是有10种商品, 那么这10种商品的任意二元组合都会出现的. 对于那些没出现的组合, 我们在字典中完全可以不存储, 从而节省空间.

同时, 别忘了我们同样也得存储key = (i, j), 这是至少额外的两个整数.

那么我们到底具体怎么存储这些计数值?

可以采用三元组的方式来构造字典. 我们采用[i, j, count]形式来存储, 其中i代表商品种类1, j代表商品种类2, 前两个值代表key, 后面的value就是count, 是这个二元组合下的计数.

现在, 让我们注意到我们(1)假定购物篮平均大小较小, 并(2)利用三元组(2个key的)字典和(3)不存储没出现组合优势. 假设有100k = 10^5种商品, 有10million=10^7个购物篮, 每个购物篮有10个项, 那么这种字典空间开销是(10, 2) · 10^7 = 45 x 10^7 x 3= 4.5x10^8x3 = 1.35x10^9 个整数.  这算出来约为4x10^8 Byte = 400MB, 处于正常计算机内存范围内.

3. 项集的单调性

如果项集I是频繁的, 那么它的所有子集也都是频繁的. 这个道理很符合常识, 因为{dog, cat} 出现的次数总是大于等于{dog, cat, and}的出现次数.

这个规律的推论, 就是严格地, 我们频繁一元组的个数> 频繁二元组的个数 > 频繁三元组的个数.

4. A-Priori算法

我们通过Itemset计数中内存使用的部门, 已经明确了我们总是有足够的内存用于所有存在的二元项集(比如{cat, dog})的计数. 这里, 我们的字典不存放不存在于购物篮中的任何二元项集合, 而且频繁二元组的数目将会大于三元频繁三元组> ...

我们可以通过单边扫描购物篮文件, 对于每个购物篮, 我们使用一个双重循环就可以生成所有的项对(即二元组). 每当我们生成一个项对, 就给其对应的字典中的value +1(也称为计数器). 最后, 我们会检查所有项对的计数结果,并且找出那些>=阈值s的项对, 他们就是频繁项对.

1) A-Priori算法的第一遍扫描

在第一遍扫描中, 我们将建立两个表. 第一张表将项的名称转换为1到n之间的整数, 从而把String类型这样的key转为空间大小更小的int类型.  第二张表将记录从1~n每个项在所有购物篮中出现的次数. 形式上类似

table 0(name table): {'dolphin': 7019, 'cat': 7020}  //dict形式, 其实也可以做成list形式 [['dolphin', 7019], ['cat', 7020]]

table 1(single-item counter table): {7019: 15, 7020: 18}  //dict形式, 其实也可以做成数组形式A[7019] = 2, A[7020] = 18

2) 第一遍扫描完的处理

第一遍扫描完后, 我们会按照自己设定的阈值s, 对整个table 1再进行一次mapping, 因为我们只关注最后counter值大于等于阈值的项目, 而且不关心其counter值具体多少. 因此, mapping策略是:

对凡是counter<s的, 一律把counter设成0; 对于counter>=s的, 按照次序, 把其设置成1~m的值(总共有m个满足要求的项)

3) 第二遍扫描

第二遍扫描所做的事有三:

(1) 对每个购物篮, 在table 1中检查其所有的商品项目, 把所有为频繁项的留下来建立一个list.

(2) 通过一个双重循环生成该list中的所有项对.

(3) 再走一次循环, 在新的数据结构table 2(dict或者list)中相应的位置+1. 此时的效果是dicta = {48: {13: 5}, 49: {71, 16}} 或者 lista [ [48, 13, 5],[49, 71, 16], ... ]

注意此时内存块上存储的结构: table1(name table), table2(single-item counter table), table3(double-item counter table)

5. 推广: 任意大小频繁项集上的A-Priori算法

我们对上面这个算法进行推广.

从任意集合大小k到下一个大小k+1的转移模式可以这么说:

(1) 对每个购物篮, 在table 1中检查其所有的商品项目, 把所有为频繁项的留下来建立一个list.

(2) 我们通过一个k+1重循环来生成该list中的所有(k+1)元组

(3) 对每个k+1元组, 我们生成其的(k+1 choose k)个k元组, 并检查这些k元组是否都在之前的table k中. (注意到k=1的时候, 这步与(1)是重复的, 可以省略)

(4)再走一次循环, 在新的数据结构table k+1(dict或者list)中相应的位置+1. 此时的效果是k=2, k+1=3, 生成dicta = {48: {13: {19: 4}}, 49: {71: {51: 10}},  ... } 或者 生成lista [ [48, 13, 19, 4],[49, 71, 51, 10], ... ]

注意, 在进入下一次扫描前, 我们还需要额外把counter中值小于s的元组的计数值都记为0.

模式总体是:C1 过滤后 L1 计数后 C2 置零后 C2' 过滤后 L2 计数后 C3 置零后 C3' ......

END.

生成的商品种类为set形式：转成list形式

第一张表：把项名称转换为1~n的整数：

至于数数，大神说，你就用collections.Counter就好：哈？

哈哈，可爱的wyy，开始分析吧~噜噜噜啦啦啦~噜啦噜啦噜~

生成全零矩阵：

换成zeros:

统计每一列的和，即每种商品的购买总数：

每一行列:

第一行：

建立一个新的只含有频繁一项集的购物篮矩阵：

频繁二项集：

⑷ Python主要内容学的是什么

这是Python全栈开发+人工智能课程大纲：
阶段一：Python开发基础
Python全栈开发与人工智能之Python开发基础知识学习内容包括：Python基础语法、数据类型、字符编码、文件操作、函数、装饰器、迭代器、内置方法、常用模块等。
阶段二：Python高级编程和数据库开发
Python全栈开发与人工智能之Python高级编程和数据库开发知识学习内容包括：面向对象开发、Socket网络编程、线程、进程、队列、IO多路模型、Mysql数据库开发等。
阶段三：前端开发
Python全栈开发与人工智能之前端开发知识学习内容包括：Html、CSS、JavaScript开发、Jquery&bootstrap开发、前端框架VUE开发等。
阶段四：WEB框架开发
Python全栈开发与人工智能之WEB框架开发学习内容包括：Django框架基础、Django框架进阶、BBS+Blog实战项目开发、缓存和队列中间件、Flask框架学习、Tornado框架学习、Restful API等。
阶段五：爬虫开发
Python全栈开发与人工智能之爬虫开发学习内容包括：爬虫开发实战。
阶段六：全栈项目实战
Python全栈开发与人工智能之全栈项目实战学习内容包括：企业应用工具学习、CRM客户关系管理系统开发、路飞学城在线教育平台开发等。
阶段七：数据分析
Python全栈开发与人工智能之数据分析学习内容包括：金融量化分析。
阶段八：人工智能
Python全栈开发与人工智能之人工智能学习内容包括：机器学习、数据分析 、图像识别、自然语言翻译等。
阶段九：自动化运维&开发
Python全栈开发与人工智能之自动化运维&开发学习内容包括：CMDB资产管理系统开发、IT审计+主机管理系统开发、分布式主机监控系统开发等。
阶段十：高并发语言GO开发
Python全栈开发与人工智能之高并发语言GO开发学习内容包括：GO语言基础、数据类型与文件IO操作、函数和面向对象、并发编程等。

⑸ Python培训需要学习哪些内容

Python培训课程大同小异，整理如下：
Python语言基础：主要学习Python基础知识，如Python3、数据类型、字符串、函数、类、文件操作等。
Python语言高级：主要学习Python库、正则表达式、进程线程、爬虫、遍历以及MySQL数据库。
Pythonweb开发：主要学习HTML、CSS、JavaScript、jQuery等前端知识，掌握python三大后端框架(Django、 Flask以及Tornado)。
Linux基础：主要学习Linux相关的各种命令，如文件处理命令、压缩解压命令、权限管理以及Linux Shell开发等。
Linux运维自动化开发：主要学习Python开发Linux运维、Linux运维报警工具开发、Linux运维报警安全审计开发、Linux业务质量报表工具开发、Kali安全检测工具检测以及Kali 密码破解实战。
Python爬虫：主要学习python爬虫技术，掌握多线程爬虫技术，分布式爬虫技术。
Python数据分析和大数据：主要学习numpy数据处理、pandas数据分析、matplotlib数据可视化、scipy数据统计分析以及python 金融数据分析;Hadoop HDFS、python Hadoop MapRece、python Spark core、python Spark SQL以及python Spark MLlib。
Python机器学习：主要学习KNN算法、线性回归、逻辑斯蒂回归算法、决策树算法、朴素贝叶斯算法、支持向量机以及聚类k-means算法。

⑹ 什么是数据挖掘中的关联分析

FineBI数据挖掘的结果将以字段和记录的形式添加到多维数据库中，并可以在新建分析时从一个专门的数据挖掘业务包中被使用，使用的方式与拖拽任何普通的字段没有任何区别。
配合FineBI新建分析中的各种控件和图表，使用OLAP的分析人员可以轻松的查看他们想要的特定的某个与结果，或是各种各样结果的汇总。

⑺ python中有哪些简单的算法

Python中的基础算法有以下几种：
基础加减乘除算法：
加法>>> 2 + 2；
减法>>> 2 - 2；
乘法>>> 2 * 2；
除法>>> 2 / 2。
整除运算：
第一种>>> 2 / 3 整型与整型相除，获取整数，条件是除数被除数都是整数；
第二种>>> 2 // 3 双斜杠整除算法，只获取小数点前的部分整数值。
冥运算：
例子1：>>> 2 ** 3；
例子2； >>> -2 ** 3；
例子3： >>> (-2) ** 3

⑻ python中有哪些简单的算法

算法都是第三方库才有的
如果要自带的，只有排序了，是timsort

⑼ python中有哪些简单的算法

你好：
跟你详细说一下python的常用8大算法：
1、插入排序
插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外(让数组多一个空间才有插入的位置)，而第二部分就只包含这一个元素(即待插入元素)。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。
2、希尔排序
希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
3、冒泡排序
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
4、快速排序
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
5、直接选择排序
基本思想：第1趟，在待排序记录r1 ~ r[n]中选出最小的记录，将它与r1交换；第2趟，在待排序记录r2 ~ r[n]中选出最小的记录，将它与r2交换；以此类推，第i趟在待排序记录r[i] ~ r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。
6、堆排序
堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。
7、归并排序
归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
归并过程为：比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。
8、基数排序
基数排序(radix sort)属于“分配式排序”(distribution sort)，又称“桶子法”(bucket sort)或bin sort，顾名思义，它是透过键值的部分资讯，将要排序的元素分配至某些“桶”中，借以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。

⑽ 以就业为目的自学python，要学习哪些内容

优就业的Python课程一共设置了5大阶段，主要学习内容如下
第一阶段：Python核心编程——Python语言基本介绍、面向对象编程、Linux操作系统、文件系统与用户管理、进程管理与服务配置、Shell编程与bash，源文件编译、版本控制、MySQL使用、MySQL进阶等。
第二阶段：全栈开发——HTML、CSS、JavaScript、jQuery、 BootStrap、Vue、Web开发基础、数据库操作、FLask配置、Django认识、Models、Templates、Views、Tornado框架进阶、ElasticSearch等。
第三阶段：网络爬虫——爬虫与数据、Scrapy框架、Scrapy框架与信息实时抓取、定时爬取与邮件监控、NoSQL数据库、Scrapy-Redis框架、百万量数据采集等。
第四阶段：人工智能——数据分析、pyechart模块动态可视化、词云、分类算法、聚类算法、回归类算法、关联算法、卷积神经网络、TensorFlow+PaddlePaddle、图像识别等。
第五阶段：就业指导——最后就业指导分为面试就业指导、专业技术指导两方面。
因为优就业Python课程内容会不定期更新，课程时长也会对应有所调整，就目前来看Python的学习时间是在5个月左右。Python课程设置时长是和学习内容紧密相关的，相对而言，课程内容涉及越广、内容越多，学习时间也会长。