1. 首页
  2. 文章中心
  3. python

机器学习实战1：python基础（个人笔记）

81 阅读 0 评论
我是靠谱客的博主 忧虑老虎，最近开发中收集的这篇文章主要介绍机器学习实战1：python基础（个人笔记），觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

python版本2.0   3.0+可以运行

NOTE: 让python支持中文注释 只要在python开头加

以下代码任意一条即可。

  1. #coding：gbk

  2. #coding：utf-8

  3. #-*-coding：gbk-*-

 

#快速排序函数

#快速排序函数
def quicksort(arr):
    if len(arr)<1:
        return arr
    pivot = arr[len(arr)/2]
    left = [x for x in arr if x<pivot]
    middle = [x for x in arr if x==pivot]
    right = [x for x in arr if x>pivot]
    return quicksort(left)+ middle + quicksort(right)
    
# 快速排序函数调用
quicksort([7,4,6,5,3])

 

t,F=True, False

print(t != F)

 

#字符串变量
stringDemo= "字符串演示"
print(stringDemo)
print("n")
print(stringDemo, len(stringDemo),"world")

#字符串拼接

#字符串拼接
hw= stringDemo+" "+"world"
print(hw)

 

# 按照格式输出字符串（）注意中间那个百分号
hw2= '%s%s%d'%('string 1','string 2',10)
print(hw2)
#首字母大写
h="hello"
# 注意方法有个括号
#注意这个方法不会修改原来变量的值需要用：=来更新一下
h=h.capitalize()
print(h)

 

#首字母大写
h="hello"
# 注意方法有个括号
#注意这个方法不会修改原来变量的值需要用：=来更新一下
h=h.capitalize()
print("使用方法更新h将首字母大写 ",h)
#右对齐打印使用空格站位一共20个符号位
print(h.rjust(20))
#居中打印
print(h.center(20))
#使用子字符串代替特定的字符
print(h.replace('l','(ell)'))
# 输出：He(ell)(ell)o

#删除开头空白字符
print('    wo  rld'.strip())

 # 列表

# 列表
listExample=[1,2,3,4]

print (listExample,listExample[2])

# 打印出列表与   第2+1个元素
# -1相当于反向索引

# 使用append添加索引到末端
# 错误的使用方法-->listExample=listExample.append("bar")此方法返回值为空
# 不能采用更新的方法来更新原有列表
listExample.append("bar")
print(listExample)

# 移除列表末端的元素
listExample.pop()#这个pop是有（）的
print listExample






([1, 2, 3, 4], 3)
[1, 2, 3, 4, 'bar']
[1, 2, 3, 4]

​

# 循环Loops

# 循环Loops
animals=['cat','monkey','rabbit']
for animal in animals:
    print(animal)
#在循环体内访问每个元素的指针 ，可以用内置的枚举（enumerate）函数，注意起始的ID为0
animals=['cat','monkey','rabbit']
for idx,animal in enumerate(animals):
    print('#%d:%s'%(idx+1,animal))#+1是为了消除起始标号为0带来的影响
    
# cat
# monkey
# rabbit
# #1:cat
# #2:monkey
# #3:rabbit

 

列表的解析

# 列表的解析
# （list comprehensions）
# 将列表中的每一个元素用特定的表达式进行转换
nums = [0,1,2,3,4]
squares = []
for x in nums:
    squares.append(x**2)
print(squares)#[0, 1, 4, 9, 16]

# 列表解析的一种简单的写法
# 也即是# （list comprehension）
squares = [x**2 for x in nums]
print(squares)#[0, 1, 4, 9, 16]

# 列表解析的同时可以包含条件语句
nums=[0,1,2,3,4]
even_square = [x**2 for x in nums if x%2==0]
print(even_square)#[0, 4, 16]

字典

# 字典（Dictionary）
# 用来存储键值对的结构（键，值）
# 与Java中的Map结构差不多
d= {'cat':'cute','dog':'furry'}#创建字典  用：表示一对键值对   用，来 分开键值对
print d['cat']
# cute
print 'cat' in d
# True
d['fish']='wet'
print(d['fish'])
# wet
print(d)
# {'fish': 'wet', 'dog': 'furry', 'cat': 'cute'}
print(d.get('cat','N/A'))
# cute
print(d.get('monkey','N/A'))
# N/A
print(d.get('monkey','NNNNNNNNNNN'))
# NNNNNNNNNNN
#移除字典中的元素：使用del函数
del d['fish']
print (d)
# {'dog': 'furry', 'cat': 'cute'}
print(d.get('fish'))
# None
print(d.get('fish','提示信息：没有鱼这种东西'))# 提示信息：没有鱼这种东西

 

字典的迭代

# 字典的迭代
d={'people':2,'cat':4,'spider':8}
for animalSpecie in d:
    leg = d[animalSpecie]
    print(animalSpecie,' have' ,leg,' legs')
# ('cat', ' have', 4, ' legs')
# ('spider', ' have', 8, ' legs')
# ('people', ' have', 2, ' legs')

# 也可以使用iteritem的方式进行迭代

for animalSpecie, leg in d.iteritems():#这里重点是d后面有.iteritems()--->迭代项
    print('%s have %d legs'%(animalSpecie,leg))
# cat have 4 legs
# spider have 8 legs
# people have 2 legs
    
    
# ('cat', ' have', 4, ' legs')
# ('spider', ' have', 8, ' legs')
# ('people', ' have', 2, ' legs')
# cat have 4 legs
# spider have 8 legs
# people have 2 legs

 

字典的解析（轻松构造字典）

#字典的解析（Dictionary Comprehension）
#通过字典解析可以轻松构造字典
nums=[0,1,2,3,4,5,6]
#注意这里是个花括号 {}
even_num_to_square={x:x**2 for x in nums if x%2==0}
print(even_num_to_square)
# {0: 0, 2: 4, 4: 16, 6: 36}

 集合（）Sets
# 集合存放无序的不同的圆度 
# 集合用花括号{}表示，如果将一个序列转换为集合，那么序列中的重复元素将被剔除
# 并且原来的序列会被打散

# 集合（）Sets
# 集合存放无序的不同的圆度 
# 集合用花括号{}表示，如果将一个序列转换为集合，那么序列中的重复元素将被剔除
# 并且原来的序列会被打散
d={'setele1','setele2','setele3','setele4'}
# d= {'cat':'cute','dog':'furry'}#创建字典  用：表示一对键值对   用，来 分开键值对
for idx,element in enumerate(d):
    print('#%d is %s'%(idx,element))
# 0 is setele3
# 1 is setele2
# 2 is setele1
# 3 is setele4
#向集合中添加一个元素
d.add('new1')
for idx,element in enumerate(d):
    print('#%d is %s'%(idx,element))
#0 is setele3
#1 is setele2
#2 is setele1
#3 is new1
#4 is setele4

集合的解析

 

# 集合的解析
from math import sqrt
print ({int(sqrt(x)) for x in range(30)})
# set([0, 1, 2, 3, 4, 5])

 

元祖

Tuples是一种特殊的数据结构 

有序

可以通过键值对索引

可以作为集合中的元素

# 元祖
# Tuples是一种特殊的数据结构 

# 有序

# 可以通过键值对索引

# 可以作为集合中的元素
# 通过元祖键值创建字典
d = {(x,x+1):x for x in range(10)}
print(d[(5,6)])
# 5
t=(5,6)#新建一个元祖
print(d[t])#d通过t来索引获取x的值

函数

# 函数
def sign(x):
    if x>0:
        return 'positive hhh'
    elif x==0:
        return 'zero hhh'
    else:
        return 'negatve hhh'
# print(sign(-33))

for x in [-1,0,1]:
    print sign(x)
#  negatve hhh
# zero hhh
# positive hhh   
# 使用可选参来定义函数 
def hello(name, loud=False):#定义一个函数
    if loud:
        print('Hello,%s ！！！！！！'%(name.upper()))#全部大写
    else:
        print('Hello,%s ~'%name)#全部小写
        
print('使用默认参数 即loud=False')        
hello('leiyuqing')
print('使用自定义参数 即loud=True')
hello('leiyuqing',loud=True)

# 使用默认参数 即loud=False
# Hello,leiyuqing ~
# 使用自定义参数 即loud=True
# Hello,LEIYUQING ！！！！！！

 

# 类
# python中 类的语法很直接
class Greeter:
#      构造函数
#     name

#深坑！！！ init 两边不是_    而是__就是两个下划线的意思！总是报错哈哈哈

# 类
# python中 类的语法很直接
class Greeter:
#      构造函数
#     name
    def __init__(self,name):#深坑！！！ init 两边不是_    而是__就是两个下划线的意思！总是报错哈哈哈
        self.name=name
#         self.name=name#创建一个变量实例
        #实例方法
    def greet(self,loud=False):
        if loud:
            print('Hello,%s ！！！！！！'%(self.name.upper()))#全部大写
        else:
            print('Hello,%s ~'%self.name)#全部小写
            
g=Greeter('leiyuqing')#创建一个Greeter实例
g.greet()#调用实例方法 进行打印
g.greet(loud=True)#调用实例方法，进行打印
# Hello,leiyuqing ~
# Hello,LEIYUQING ！！！！！！

# 关于Numpy
# np是python关于科学计算的核心库，提供高性能的多维数组对象以及相关工具
# 用法和MATLAB类似
import numpy as np

# 关于Numpy
# np是python关于科学计算的核心库，提供高性能的多维数组对象以及相关工具
# 用法和MATLAB类似
import numpy as np
 
a= np.array([1,2,3])#创建一维数组
print(type(a))#<type 'numpy.ndarray'>

a[0]=5#改变数组的元素
print(a)#[5 2 3]

#创建秩为2 的数组
b = np.array([[1,2,3],[4,5,6]])
print(b)
# [[1 2 3]
#  [4 5 6]]

# 打印出b的形状shape信息
print(b.shape)#(2, 3)

#索引元素打印
print(b[0,1])#2 第一行第二个

# Numpy提供了大量方法创建数组
a=np.zeros((3,2))
print(a)
# [[0. 0.]
#  [0. 0.]
#  [0. 0.]]
# 创建全部为1 的矩阵（指定尺寸）
b=np.ones((3,2))
print(b)
# [[1. 1.]
#  [1. 1.]
#  [1. 1.]]
#创建指定尺寸的，所有元素相同的矩阵
c=np.full((3,2),88)
print(c)
# [[88 88]
#  [88 88]
#  [88 88]]
# 创建3x3的单位矩阵
d=np.eye((3))
print(d)
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]
# 使用随机数创建3x3的矩阵
e=np.random.random((3,3))
print(e)
# [[0.57703016 0.18892427 0.22221829]
#  [0.59258764 0.46604284 0.35703615]
#  [0.20300843 0.43196674 0.74231142]]

# 数组的索引

# 数组的索引
# 与python的列表类似 np的数组也可以使用切片的语法，因为数组是可以是多维的数组，所以必须为每个维度制定好切片
import numpy as np
#创建秩为2 形状shape为（3，4）的数组
a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])

print(a)
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]
# 取出第一行二列开始的形状为（2，2）的数组
b = a[: 2,1:3]#(行为所有行到第2+1行之前，列为从第1+1列开始到第3+1列之前)
print(b)

# [[2 3]
#  [6 7]]

！！！注意！！！！# 切取出来的子数组实际上是原始数组的的一份浅备份，
# 因此修改子数组，原始数组也将被修改

 

# 切取出来的子数组实际上是原始数组的的一份浅备份，
# 因此修改子数组，原始数组也将被修改
import numpy as np
a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
b = a[: 2,1:3]
print(a)
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]
# 取出第一行二列开始的形状为（2，2）的数组
b = a[: 2,1:3]#(行为所有行到第2+1行之前，列为从第1+1列开始到第3+1列之前)
print(b)

# [[2 3]
#  [6 7]]

# ==============
print('original a:',a[0,1])
b[0,0]=7777
print('AFTER changing b a:',a[0,1])

# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]
# [[2 3]
#  [6 7]]
# ('original a:', 2)
# ('AFTER changing b a:', 7777)

# 整型数组索引
# 在使用切片索引数组时
# 得到的总是原始数组的子数组，整型数组
# 允许我们利用其它数组中的数据  来索引另一个数组  构建一个新的数组

换而言之就是      以数组作为下标  来索引数组   略微抽象

 

print(a[[0,1,2],[0,1,0]])
与
print([a[0,0],a[1,1],a[2,0]])

等效

# 整型数组索引
# 在使用切片索引数组时
# 得到的总是原始数组的子数组，整型数组
# 允许我们利用其它数组中的数据构建一个新的数组

import numpy as np
a = np.array([[1,2],[3,4],[5,6]])
# b = a[: 2,1:3]
print(a)
print('=========')
print(a[[0,1,2],[0,1,0]])
print('equivilent to n')
print([a[0,0],a[1,1],a[2,0]])
# [[1 2]
#  [3 4]
#  [5 6]]
# =========
# [1 4 5]
# equivilent to 

# [1, 4, 5]

# 在Numpy中使用dot来计算内积
#dot可以作为数组对象的实例方法

# 在Numpy中使用dot来计算内积
#dot可以作为数组对象的实例方法
x = np.array([[1,2],[3,4]])
y = np.array([[5,6],[7,8]])
v = np.array([9,10])
w = np.array([11,12])
# 向量内积都将生成219
print(v.dot(w))
print(np.dot(v,w))
print(np.dot(x,v))

print(np.dot(x,y))

print(np.sum(x))

print(np.sum(x,axis=0))#列
print(np.sum(x,axis=1))#行

# 转置是T

# 219
# 219
# [29 67]
# [[19 22]
#  [43 50]]
# 10
# [4 6]
# [3 7]

NOTE：

print(np.sum(x,axis=0))#列
print(np.sum(x,axis=1))#行

 

Python 中的广播机制

广播机制提供了强大的功能，从而能语序Numpy在不同形状的数组中执行数学操作，我们经常会遇到小数组和大数组想成的情况，比兔图片数据矩阵与权重矩阵，利用广播机制可以提高代码的质量与运算效率，例如在矩阵的每一行中都加上一个常数向量，可以按照以下代码进行操作：

 

# 广播机制
import numpy as np
#矩阵的每一行加上向量v将结果保存在矩阵y中
x = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
v = np.array([1,0,1])
y = np.empty_like(x)#创建一个与想形状相同的空矩阵。
#使用显式的循环完成上述操作。
for i in range(4):
    y[i,:]=x[i,:]+v
print(y)
# [[ 2  2  4]
#  [ 5  5  7]
#  [ 8  8 10]
#  [11 11 13]]

# 这样的操作是可行的，但是如果x变得特别大，用显式的循环特别耗时间
# 于是乎就有以下这种操作
# 操作的本质是将向量v拷贝多次后，垂直堆叠形成矩阵vv  
# 然后对矩阵x与矩阵vv进行按照元素求和的操作 
# 也可以实现同样的效果

# 这样的操作是可行的，但是如果x变得特别大，用显式的循环特别耗时间
# 于是乎就有以下这种操作
# 操作的本质是将向量v拷贝多次后，垂直堆叠形成矩阵vv  
# 然后对矩阵x与矩阵vv进行按照元素求和的操作 
# 也可以实现同样的效果
vv = np.tile(v,(4,1))#拷贝4次向量v堆叠起来
print(vv)
# [[1 0 1]
#  [1 0 1]
#  [1 0 1]
#  [1 0 1]]

#不需要过多的修饰，直接是两个np类型的对象加起来
# 里面就已经因含有广播机制了：

x = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
v = np.array([1,0,1])
y = x+v

#Numpy的广播机制允许我们在不出按键多次向量v的备份的情况下执行该计算
# 如下列代码所示
import numpy as np
x = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
v = np.array([1,0,1])
y = x+v
#不需要过多的修饰，直接是两个np类型的对象加起来
# 里面就已经因含有广播机制了
print (y)

# [[ 2  2  4]
#  [ 5  5  7]
#  [ 8  8 10]
#  [11 11 13]]

# Python绘图工具 Matplotlib
# 使用以下命令*********可以将绘图结果嵌入到notebook中来：
%matplotlib inline

# Python绘图工具 Matplotlib
import matplotlib.pyplot as plt
# 使用以下命令*********可以将绘图结果嵌入到notebook中来：
%matplotlib inline
# 绘制
x = np.arange(0,3*np.pi,0.1)
y_sin = np.sin(x)
# 使用pyplot绘制坐标点
y_cos = np.cos(x)
plt.plot(x,y_sin,x,y_cos)
# 添加标题等内容
plt.xlabel('x axis label')
plt.ylabel('y axis label')
plt.title('sin and cos' story ')
plt.grid()
plt.legend(['sine','cosine'])

 

绘制子图

 

# 绘制子图
plt.subplot(2,1,1)
# 绘制
x = np.arange(0,3*np.pi,0.1)
y_sin = np.sin(x)
# 使用pyplot绘制坐标点
y_cos = np.cos(x)
plt.plot(x,y_sin,x,y_cos)
# 添加标题等内容
plt.xlabel('x axis label')
plt.ylabel('y axis label')
plt.title('sin and cos' story ')
plt.grid()
plt.legend(['sine','cosine'])
plt.subplot(2,1,2)

# 绘制
x = np.arange(0,3*np.pi,0.1)
y_sin = np.sin(x)
# 使用pyplot绘制坐标点
plt.plot(x,y_sin)
# 添加标题等内容
plt.xlabel('x axis label')
plt.ylabel('y axis label')
plt.title('sin')
plt.grid()
plt.legend(['sine'])

 

 

 

最后

以上就是忧虑老虎为你收集整理的机器学习实战1：python基础（个人笔记）的全部内容，希望文章能够帮你解决机器学习实战1：python基础（个人笔记）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
点赞(54)

相关文章

Groovy使用小结
Groovy使用小结
教程– GPar，使并行系统对Groovy和Java友好
教程– GPar，使并行系统对Groovy和Java友好
java和groovy的混用java和groovy的混用
java和groovy的混用java和groovy的混用
Unmi 学习 Groovy 之多线程
Unmi 学习 Groovy 之多线程
机器学习实战1：python基础（个人笔记）
机器学习实战1：python基础（个人笔记）
java整合groove实战—xml文件解析
java整合groove实战—xml文件解析
Groovy中each、find跳出循环
Groovy中each、find跳出循环
Jenkins parallel并行构建Jenkins parallel并行构建
Jenkins parallel并行构建Jenkins parallel并行构建

评论列表共有 0 条评论

立即
投稿
返回
顶部