2小时学完机器学习必备Python基础

打算花几个月学下机器学习，还是打算先过一遍python，虽然很多人说没必要但是觉得磨刀不误砍柴工，毕竟Java基础在那学python基础肯定是极快的。
花了一下午把python基础过了一遍，一部分来自于廖雪峰的官网一部分是网络资源，暂时应该是够用了。由于是直接写代码和注释，所以学起来很方便，基本2-3小时就够了。

主要分为以下几个模块
1、python基础：变量、条件判断、分支循环、常用容器
2、函数的定义与使用
3、python的高级特性
4、函数式编程

一、python基础

# 单行注释
'''
三个单引号是
多行注释
'''

#1、输入输出,写完只会不需要加 ; input()   print() 使用,分割的话那么输出会使用空格拼接
name = input()
print(name)
print("app","le")

#2、运算符  优先级由高到低是 **(取幂) * / % //(向上取整)  + - 实际上都会用()来调整
a = (3+4)//2
b = 2**4
print(a,b)

#补充：数据类型转换int(),float(),str(),bool()
print(int(3.14))
print(float(3))
print(bool(3))
print(str(3))

a = int(2.345)
b = int("123")
c = float(345)
d = float("3.14")
e = str("123") + "abc"
print(a,b,c,d,e)#2 123 345.0 3.14 123abc

'''
3、数据类型和变量 
常用的:整数，浮点数，字符串，布尔值，空值  不需要声明类型
注意：使用除法是区别与java的，会得到确定的数,比如1/3得到0.3333333333333333
布尔类型只有True和False  可以使用and,or和not运算(注意都是小写) 使用跟java是差不多的
空值是py的一个特殊值None，类似于java的null值，不能理解为0哦 可以理解为指向了一块空的内存区域
发现没有,scala一样，直接写不需要跟java那样去定义（这种变量本身类型不固定的语言称之为动态语言，对应的java则是静态语言)
    动态语言即使类型不一样也可以赋值
'''
c = 1/3
print(c)
d = "hello world"
print("I like 'you' ")# 输出I like 'you'
#补充：为了换行方便可以直接使用""" 然后手动换行即可,下面的语句会输出三行分别为aaaa bbbb cccc
print("""
aaaa
bbbb
cccc
""")

print(2 > 3)
print(True and False,True or False)
print(not True)

e = 88
f = "tom"
e = f
print(e)#照样输出tom

'''
4、字符串处理
strip，lstrip，rstrip分别表示去除两端空格，左边空格，右边空格
字符串连接 +,  字符串赋值 =, 计算字符串长度 len(str), 字符串查找 find(), 字符串分割成列表split()
字符串转大小写lower(),upper()   字符串比较> < >= <= ==
'''

a = " aa  ".strip()
a = " aa".lstrip()
a = "  aa  ".rstrip()
print(a)

a = "tom"
b = "jack"
print(a + " and " + b)
l = len(a)
idx = b.find("a")
print(l,idx)# 输出1，下标是0开始

ls = "a,b,c,d".split(",")
print(ls) #['a', 'b', 'c', 'd']

a = "ABCD".lower()
b = "abcd".upper()
print(a,b)
print("aa"=="aa")#True
a = "aa"
b = "bb"
print(a == b)#False

'''
5、列表list和元祖tuple
Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素
可以简单理解为java中的ArrayList或者直接理解为数组即可
根据索引直接获取元素arr[index] 修改也是一样arr[index]=新元素（但是可以倒着取-1表示倒数第一个)
添加和插入使用append() 末尾添加， arr.insert(index，元素)
删除则使用pop，默认删除最后一个，也可以删除指定位置元素

补充:list中元素类型可以是不一样的
'''

#查
stus = ["java","c++",'python',".net"]
print("stus的元素个数是:",len(stus),stus)
print(stus[0],stus[2],stus[-1])
#改
stus[0] = 'scala'
#增
stus.insert(1,'php')
stus.append('matlab')
print(len(stus),stus)
#删  删除最后一个  指定位置删除
stus.pop()
stus.pop(-1)
print(stus)

arr = [34,3.14,"python",True,None,stus]
print(arr)

'''
6、另一种有序列表叫元组：tuple。
tuple和list非常类似，但是tuple一旦初始化就不能修改
所以没有增删改的方法，其他跟list一样操作
注意list使用[]，列表使用()
定义一个空的tuple直接使用()，但是定义只有一个元素的tuple使用(34)是表示34这个数，因为()可以认为
是数学中的括号，可以使用(34,)来避免产生歧义，输出是(34,)

补充：需要注意这里的"不变"，是指引用不变
'''

tup = ("java","c++","python")
print(tup)


t = (34)
print(t) #输出34而不是(34)
t=(34,)
print(t)

t = (1,2,[3,4])
#t[0]=3 输出会出错
t[2][1] = 7
print(t) #(1, 2, [3, 7])

'''
7、条件判断if, if not, elif, else  每个关键字后面接:（java是接())
如果判断条件只有个变量x,只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False。
'''
a = 1

if a > 1:
    print("大了")
elif a < 1:
    print("小了")
else:
    print("猜对了")

if a :
    print("同样是对了")
else:
    print("猜错了")

'''
8、循环
第一种 for：for x in 列表(list,tuple等)，依次将列表中元素取出来赋值给x
补充:Python提供一个range()函数，ran(5)生成的是0-4的整数可以生成一个整数序列，
再通过list()或者tuple()函数可以转换为list或者tuple
在循环中使用range也是可以的，但是习惯上会转为便于操作的list或者tuple
range(start,end, step)

第二种 while: while 判断条件 :

循环常配合一些关键字进行控制，常用的就是break，continue，pass（跳过）
'''
stus = ["java","c++",'python',".net"]
for x in stus:
    print(x)#输出4行
lan = ("java","c++","python")
for x in lan:
    print(x)

a = tuple(range(10))
print(range(10))#range(0, 10)
print(a)#(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

sum = 0;
for x in range(0,10,2):
    sum += x
print(sum)

#while循环

sum = 0;
num = 100;
while num >= 0:

    num = num - 1
    if num % 2 == 0:
        continue
    sum += num
    if num >= 30:
        break
print(sum)

'''
9、字典dict和集合set
dict，也就是Java中的map，键值对的存储形式，查找速度快，当做HashMap使用即可，操作也类似 {}
set，也当做HashSet用，两者都是不存在重复元素，无序的（内部存储顺序和放入顺序无关） set(list)
    也就是说创建set的时候需要先创建list或tuple等
'''

#dict的使用

#查询，根据key去查询dict[key]
dic = {"name":"Tom","age":18,"gender":"male"} #{'name': 'Tom', 'age': 18, 'gender': 'male'}
print(dic)
print(dic["name"],dic["age"],dic["gender"])
# 注意：上面的查询查询不到会报错  可以使用get并且赋默认值，类似java的map.getOrDefault()
v = dic.get("aaa","不存在")
print(v)


#添加和修改 dict[key] = value
dic["name"] = "Jack"
dic["height"] = 180
print(dic)#{'name': 'Jack', 'age': 18, 'gender': 'male', 'height': 180}

#删除 dict.pop(key)
dic.pop("height")
print(dic)

#取全部的key，value，键值对  类似java的keySet,values,entrySet
dic.keys()
dic.values()
dic.items()

s = set([1,2,3,4])
print(s)
s = set((2,3,4))
print(s)
s= set(range(1,10,2))
print(s)

#set的增删add,remove  注意：没有根据索引查询和修改
s.remove(3)
s.add(100)
print(s)

#set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作
s=set([1,2,3,4,5])
s2=set([3,4,5,6,7])
print(s & s2)#{3, 4, 5}
print(s | s2)#{1, 2, 3, 4, 5, 6, 7}

二、函数的定义与使用

#1、函数的调用
a = max([1,2,3,4,100])
b = min(1,3,4,6)
c = pow(2,4)
d = abs(-10)
print(a,b,c,d)

#不是说python中一切皆对象吗，那么将abs当做对象，将它赋给变量my_abs,然后再使用my_abs
my_abs = abs #注意：只要变量名
print(my_abs(-89))

#2、定义函数:定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:
#如果你已经把my_abs()的函数定义保存为demo2.py文件了，那么，
# 可以在该文件的当前目录下启动Python解释器，用from demo2 import my_abs来导入my_abs()函数，
#注意：要写完整路径名，我这里就是from src.base_demo.demo2 import  my_abs


#定义一个计算绝对值的函数，和一个什么也不做的函数
def my_abs(num) :
    if num > 0:
        return  num
    else:
        return -num
print(my_abs(-8))

#pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，
# 就可以先放一个pass，让代码能运行起来。
def blank(a):
    pass

#注意：参数检查：当传入了不恰当的参数时，内置函数abs会检查出参数错误，当传入了不恰当的参数时，内置函数abs会检查出参数错误，

def my_abs2(num):
    if not isinstance(num,(int,float)):
        raise TypeError("参数类型错误") #抛出异常,线程中断
    if num > 0:
        return  num
    else:
        return -num
#print(my_abs2("aaa"))

#补充：python支持返回多个参数  使用逗号隔开

import math

def robot(a,b,c = 0):
    x = a*b + math.cos(c)
    y = a*b - math.cos(c)
    return x, y
x,y = robot(3,4) #函数定义的时候指定了默认值，当然也可以重新设置
print(x,y)

'''
3、函数的参数
分为默认参数
可变参数
关键字参数
命名关键字参数
组合参数
'''

def func(name,age=18,like="sleep"):
    print(name,age,like)
func("tom")

#3.1 默认参数的坑
def add_end(lst=[]):
    lst.append("end")
    return lst
print(add_end([1,2,3]))#[1, 2, 3, 'end']
print(add_end(["a","b","c"]))#['a', 'b', 'c', 'end']
print(add_end())#['end']
#到这里都没问题，但是下面连续不带参数的调用就出问题了
print(add_end())
print(add_end())
print(add_end())
'''
['end', 'end']
['end', 'end', 'end']
['end', 'end', 'end', 'end']
'''
#原因就是Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，
# 因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，
# 则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了
#注意：定义默认参数要牢记一点：默认参数必须指向不变对象！


#3.2 可变参数   计算平方和

#使用下面这种方法我们每次需要传入一个list或者tuple等
def sq(num):
    sum = 0;
    for x in num:
        sum += x*x;
    return sum;
print(sq([1,2,3,4]))
print(sq((1,2,3,4,5)))

#使用下面的方法(变量前加*)，那么我们就不需要也不能传入list或者tuple了，传入的参数会自动转为tuple
def sq2(*num) :
    sum = 0;
    for x in num:
        sum += x*x;
    return sum;
print(sq2(1,2,3,4))
print(sq2(1,2,3,4,5))

#如果我们有了list或者tuple但是想调用sq该怎么办呢? 前面加*即可
lst = [1,2,3,4,5]
print(sq2(*lst))

def person(id,name,**kw) :
    print("id:",id,"name:",name,"other:",kw)
person(1,"Lucy")
person(1,"Lucy", city="Beijing",age = 16)


#3.3 关键字参数  注意：含参数名 **参数名
#关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

def inf(name,age,**o) :
    print("name:",name)
    print("age:",age)
    print(o)

inf("tom",18)
inf("tom",28,city="Peking",sex="male")

#和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去

dic = {"city":"Peking","sex":"male","height":180}
inf("tom",18,city=dic["city"],sex=dic["sex"])
inf("tom",18,**dic)

#3.4、命名关键字参数  个人觉得没什么软用
#如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数
def person(id,name,city,age) :
    print(id,name,city,age)
person(1,"Xj","成都",23)

def person2(id,name,*,city,age) :
    print(id,name,city,age)
person2(1,"Xj",city="成都",age=23)#必须写明name,age否则运行类型错误

#如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了
def person3(id,name,lst,city,age) :
    print(id,name,lst,city,age)
lst = ["java","c++","scala","python"]
person3(1,"Jack",lst,"Peking",18)

def person4(id,name,*lst,city,age) :
    print(id,name,lst,city,age)
person4(2,"Tom",*lst,city="成都",age=23)

#3.5、参数组合
def person5(id,name,*lst,city,age,**m) :
    print(id,name,lst,city,age,m)
person5(1,"Lucene",*[1,2,3,4],city="成都",age=18,**{"height":180,"width":20})

#4、递归函数  略：多刷点leetcode

三、高级特性

#高级特性


#1切片  python没有提供substring,但是提供了切片  左闭右开
#1.1、list切片
lst = list(range(100))
a = lst[:2]  #初始位置到下标为2的位置  左闭右开
b = lst[1:3] #下标1到3位置， 左闭右开
c = lst[:10:2]   #取前十个  每两个取一个
d = lst[-10:]  #取后十个
e = lst[-3:-1]
f = lst[:] #什么都不写  相当于复制
g = lst[::5] #每5个取一个
print(g)
#1.2、tuple也可以用切片操作，只是操作的结果仍是tuple
tup = (range(100))
print(tup[:50:2])
#1.3、字符串切片
s = "abcde"
print(s[0]) #输出a
print(s[:2])  #输出ab


'''
2、迭代
如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）
在Python中，迭代是通过for ... in来完成的，而很多语言比如C语言，迭代list是通过下标完成的
Python的for循环抽象程度要高于C的for循环，因为Python的for循环不仅可以用在list或tuple上，还可以作用在其他可迭代对象上
当我们使用for循环时，只要作用于一个可迭代对象，for循环就可以正常运行
'''

#2.1、迭代dict 默认迭代的是key
dic = {"name":"Tom","age":18,"sex":"male"}
for key in dic:
    print(key,dic[key])
for v in dic.values() :
    print(v)
for i in dic.items() :
    print(i) #比如('name', 'Tom')
for k,v in dic.items():
    print(k,v)

#2.2、迭代字符串string
s = "abcd"
for c in s :
    print(c)

#那么，如何判断一个对象是可迭代对象呢？方法是通过collections模块的Iterable类型判断
from collections import Iterable
def ite(itm):
    if isinstance(itm,Iterable):
        for x in itm:
            print(x)
    else:
        print("不可迭代")
ite("1234")
ite(123)

'''
如果要对list实现类似Java那样的下标循环怎么办？Python内置的enumerate函数可以把
一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身
注意：使用了后迭代了就没了，需要重新设置
'''

e = enumerate(["java","c","python"])
for x in e :
    print(x,x[0],x[1]) #比如输出(0, 'java') 0 java  可以将x理解为一个dic中的对象

#需要重新设置  取出也行
e = enumerate(["java","c","python"])
for k,v in e :
    print(k,v)

#3、列表生成式
#是Python内置的非常简单却强大的可以用来创建list的生成式

#3.1、要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
lst = list(range(1,11))
print(lst)

#3.2、如果要生成1-10的平方组成的列表呢  暴力点可以使用循环
L = []
for x in lst :
    L.append(x*x)
L=[]
#但是也可以使用列表生成式
L = [i*i for i in lst]
print(L)
#还可以加条件判断呢   也可以多重循环（不习惯）
L = [i*i for i in lst if i % 2 == 0]
print(L)

'''
4、生成器 generator
通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。
而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅
需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了
那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省大量的空间。
在Python中，这种一边循环一边计算的机制，称为生成器：generator
'''

#4.1、创建方式 1 只要把一个列表生成式的[]改成()
L = (i*i for i in lst if i % 2 == 0)
print(L)  # <generator object <genexpr> at 0x0342A6C0>
l = list(L)
print("======",l)
#如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值,最后没了会抛出异常
print(next(L))
print(next(L))
print(next(L))
#正确操作就是使用for循环
for x in L:
    print(x)

#4.2、创建方式 2
#下面了解下generate函数的奥义 yield
def my_func(end) :
    n = 0;
    while n < end:
        print(n)
        n = n + 1

my_func(10)

#上面的函数和generator仅一步之遥。要把my_sum函数变成generator，只需要把print(b)改为yield n

def my_func2(end) :
    n = 0;
    while n < end :
        yield n
        n = n + 1

L = my_func2(10)
print(L) #<generator object my_func2 at 0x01A99720>
for x in L:
    print(x)

'''
如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator
这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者
最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield
语句返回，再次执行时从上次返回的yield语句处继续执行.举个简单的例子，定义一个generator，
依次返回数字1，3，5
'''

def odd() :
    print("Step1")
    yield 1
    print("Step2")
    yield 2
    print("Step3")
    yield 3
g = odd()
print(next(g))
print(next(g))
print(next(g))

'''
5、迭代器
我们已经知道，可以直接作用于for循环的数据类型有以下几种
一类是集合数据类型，如list、tuple、dict、set、str等
一类是generator，包括生成器和带yield的generator function
一类是generator，包括生成器和带yield的generator function
一类是generator，包括生成器和带yield的generator function
'''
from collections import *
lst = [1,2,3,4]
print(isinstance(lst,Iterable))
gis = (x for x in lst) #第一个x不能少
print(isinstance(gis,Iterable))

'''
而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，
直到最后抛出StopIteration错误表示无法继续返回下一个值了
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator
可以使用isinstance()判断一个对象是否是Iterator对象
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator
把list、dict、str等Iterable变成Iterator可以使用iter()函数
'''
print(isinstance(lst,Iterator)) #false
print(isinstance(gis,Iterator))

lst = iter(lst)
print(isinstance(lst,Iterator))
print(next(lst))
print(next(lst))

四、函数式编程

#函数式编程

#1、高阶函数
#既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，
# 这种函数就称之为高阶函数

'''
1.1、map-reduce
map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，
并把结果作为新的Iterator返回
reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，
reduce把结果继续和序列的下一个元素做累积计算,效果是reduce(f, [x1, x2, x3, x4])
= f(f(f(x1, x2), x3), x4)
'''

def sq(x):
    return x * x;

it = map(sq,[1,2,3,4])
for x in it :
    print(x)
for x in map(str,[1,2,3,4]): #数字转字符串
    print(x)

from functools import reduce

def my_red(x,y):
    return x*10 + y
a = reduce(my_red,[1,2,3,4])
print(a)

'''
1.2、filter
Python内建的filter()函数用于过滤序列，和map()不同的是，filter()把传入的函数依次作用于每个元素，
然后根据返回值是True还是False决定保留还是丢弃该元素，例如，在一个list中，删掉偶数，只保留奇数
返回的也是惰性的Iterator
'''

#过滤掉偶数
def odd(x) :
    return x % 2 == 0
lst = list(filter(odd,[1,2,3,4,5,6]))
print(lst)

'''
1.3、sorted
直接利用sorted函数进行排序,传入的是个iterable(一共可以传入三个参数序列，函数，是否反转)
此外，sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序
默认字符串排序按照首字母，"Z"是小于"a"的
不区分大小写进行倒排
'''
lst = sorted([4,5,1,-10,2])
print(lst)
lst = sorted([4,5,1,-10,2],key=abs)
print(lst)
strs = sorted(["Z","d","a","C"])
print(strs)
strs = sorted(["Z","d","a","C"],key=str.lower,reverse=True)
print(strs)