蟒蛇常用的机器学习库
numpy的：科学计算库
熊猫：数据分析处理库
matplotlib：数据可视化库
scikit学习：机器学习库
①插入，追加，延伸区别？
都是往列表中添加元素：
追加（）：整体添加，不能拆分，每次只能加入一个，可添加各种类型
延伸（）：拆分添加，字符串也会被拆开
插入（）：按坐标添加，同时传入坐标和值，不拆分
li=list(y)
li.append([6,3])#self:对自身对象的引用
li.append(3)
l=li.append("fds")
print(l)#返回值为空
print(li,type(y))
c=li.count(3)#[]中的3不被发现
print(c)
li.extend([7,8,9])#拆开加入
li.extend("abc")#拆开加入
print(li)
li.insert(9,10)#(索引，值)按下标插入
li.insert(0,[1,2])#不拆分
print(li)②弹出，删除，del区别？
弹出（）：按下标删除，返回被删除的元素，无参数时删除最后元素，下标可为负值
删除（）：按值删除，返回无
德尔（）：按下标删除或直接删除列表，无返回值
x=[1,2,3,4]#坐标从-4到3
print(x)
# 安索引删除
del x[1]
del x[-1]#最后一个元素，-2倒数第二个……
# del x #删除x
# 垃圾回收：gc.collect()
print(x[1])
# pop
p=li.pop()#有返回值,删除最右面元素
print(p)
p=li.pop(-2)#(坐标)
print(p)
c=li.remove(10)#(值/没有报错)无返回值，重复值删除第一个
print(c,li)③计数，索引区别？
list.count（X）是用来统计列表元素X的个数
list.index（X）是用来返回X元素在列表中第一次出现的位置下标
c=li.count(3)#[]中的3不被发现
print(c)
i=li.index(3)#从左向右找，返回第一个3的下标。没有则报错 * is not in list
print(i)④反向，反向，排序，排序区别？
排序，排序：排序默认升序。
逆转，逆转：乱序
sort：sort（）是可变对象（字典，列表）的方法，无参数，无返回值，sort（）会改变可变对象，因此无需返回值 .sort（）方法是可变对象独有的方法或者属性，而作为不可变对象如元组，字符串是不具有这些方法的，如果调用将会返回一个异常。
排序：排序（）是蟒的内置函数，并不是可变对象（列表，字典）的特有方法，分类（）函数需要一个参数（参数可以是列表，字典，元组，字符串），无论传递什么参数，都将返回一个以列表为容器的返回值，如果是字典将返回键的列表。
反向（）与排序的使用方式一样，而反转（）与排序（）的使用方式相同。
c=li.reverse()
print(c,li)
import random
ll=list(range(10,20))
random.shuffle(ll)#乱序
print(ll)
ll.sort()#升序排序
print(ll)
ll.sort(reverse=True)#降序排序
print(ll)
import random
#待排序列表
xli=list(random.randint(1,20) for i in range(1,6))
#调用sorted
# yli=sorted(xli)
# print(xli,yli)
#reversed的方法返回是list_reverseiterator对象
yli=reversed(xli)
print(xli,list(yli))#[3, 2, 15, 13, 2] [2, 13, 15, 2, 3]⑤使用map和reduce计算1..10的阶乘，并统计和（转7）
ll=list(range(1,11))
def jc(l):
if l== 1:
return 1
return l*jc(l-1)
print(list(map(jc,ll)),sum(list(map(jc,ll))))
# 阶乘reduce
from functools import reduce
for n in range(1,11):
print(reduce(lambda x,y:x*y,range(1,n+1)))6.sum（），拉链（）
zip函数的原型为：zip([iterable, …])
参数iterable为可迭代的对象，并且可以有多个参数。该函数返回一个以元组为元素的列表，其中第 i 个元组包含每个参数序列的第 i 个元素。返回的列表长度被截断为最短的参数序列的长度。只有一个序列参数时，它返回一个1元组的列表。没有参数时，它返回一个空的列表。
有多个参数时
la=[8,12,5,6]
lb=[8,12,5,6]
print(la is lb)#false
print(la==lb)#true
lia=list(range(1,3))
lib=list(range(4,8))
print(sum(lia))#求和
#拉链操作
c=zip(lia,lib)
print(c)
print(type(c),list(c))运行结果：
False
True
3
<zip object at 0x00000000021E90C8>
<class 'zip'> [(1, 4), (2, 5)]
当没有参数的时候
import numpy as np
zz=zip()
print(zz)
输出：[]当只有一个参数的时候
import numpy as np
a=[1,2,3]
zz=zip(a)
print(zz)
输出：[(1,), (2,), (3,)]当多个参数长度不同的时候
import numpy as np
a=[1,2,3]
b=[1,2,3,4]
c=[1,2,3,4,5]
zz=zip(a,b,c)
print(zz)
输出：[(1, 1, 1), (2, 2, 2), (3, 3, 3)]zip() 和 * 操作符一起操作可以用来 unzip 一个列表，看下面的代码：
import numpy as np
a=[1,2,3]
b=[4,5,6]
c=[7,8,9]
zz=zip(a,b,c)
print(zz)
x,y,z=zip(*zz)
print(x)
print(y)
print(z)
输出：
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
(1, 2, 3)
(4, 5, 6)
(7, 8, 9)7.map,reduce,filter
#map(函数或lambda,集合)，作用将集合中每一个元素以参数的形式传递给第一个函数并返回计算后结果，形成新集合Map对象；
#lambda是关键字 ，后面的x表示参数，参数之间使用逗号分隔；冒号后的表达式计算后返回的结果，lambda表达式，无函数名称的函数，目标简化代码，和map函数结合更紧密；
reduce函数将集合中元素从左到右依次累计操作
filter函数：通过将集合中每一个元素传递给第一个参数作为实参，如果函数计算后返回True，则将该元素存在filter对象中，否则舍弃该元素；
语法：返回filter对象=filter(lambda表达式或函数,数据集)
注意：函数和lambda表达式的参数个数是一个
lf=list(range(1,4))
def ok(l):
return l**3
print(list(map(ok,lf)));
map(lambda :ok(),lf)
print(list(map(lambda l:ok(l),lf)))
# map() 会根据提供的函数对指定序列做映射。
#
# 第一个参数 function
# 以参数序列中的每一个元素调用 function 函数，
# 返回包含每次 function 函数返回值的新列表。
import random
li=[random.randint(1,10) for i in range(5)]
print(sum(li))
from functools import reduce
def sum(x,y):
return x+y
z=reduce(sum,li)#从左到右叠加处理
print(z)
#得到100之内所有的素数；
li=list(range(2,101))
#判断该数是否是素数,如果该函数返回True，该数就是素数
def isnum(n):
iflag=True
for i in range(2,n):
if(n%i==0):
iflag=False
break
return iflag
#得到2-100的素数
y=filter(isnum,li)
#将filter对象转换成List
ylist=list(y)
print(ylist)8.6列表推导式
基本语法：
[表达式A for变量in可迭代的对象[if表达式]]
该列表推导式，将每次循环中表达式A，通过if表达式的判断返回True之后（如果有如果表达式），
将表达式甲存储到列表中;
#执行原理首先执行当次for循环，将当次循环对应3*x（x的值来自循环本身），然后将3*x存储到列表中
xli=[3*x for x in range(6)]
#结果[0, 3, 6, 9, 12, 15]
print(xli)
