快速入门_快速入门:十分钟学会python - CSDN
精华内容
参与话题
  • 快速入门

    2020-10-02 18:21:59
    快速入门快速入门快速入门 1 CSS入门 1.1 初识CSS 1.1.1 概述 在学习了基本HTML标签和样式后,接下来学习前端开发的第二门技术。 我们发现,虽然标签的属性可以调整一些样式,但是效果不够理想,而我们更愿意把样式...

    快速入门

    1 CSS入门

    1.1 初识CSS

    1.1.1 概述

    在学习了基本HTML标签和样式后,接下来学习前端开发的第二门技术。

    我们发现,虽然标签的属性可以调整一些样式,但是效果不够理想,而我们更愿意把样式编写在<style> 标签中,让页面设计更美观更丰富,实际上,这是通过CSS实现的。那么什么是CSS呢?

    如果说,HTML是网页的"素颜",那么CSS就是页面的"美妆师",它就是让网页的外观更漂亮!

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UTbIOinv-1601634116973)(assets/css1.jpg)]

    CSS (层叠样式表——Cascading Style Sheets,缩写为 CSS),简单的说,它是用于设置和布局网页的计算机语言。会告知浏览器如何渲染页面元素。例如,调整内容的字体,颜色,大小等样式,设置边框的样式,调整模块的间距等。

    所谓层叠 : 是指样式表允许以多种方式规定样式信息。可以规定在单个元素中,可以在页面头元素中,也可以在另一个CSS文件中,规定的方式会有次序的差别(讲解引入时说明)。

    所谓样式:是指丰富的样式外观。拿边框距离来说,允许任何设置边框,允许设置边框与框内元素的距离,允许设置边框与边框的距离等等。

    • CSS发展简史【了解】
      • CSS1:1994 年,Hkon Wium Lie 最初提出了 CSS 的想法,联合当时正在设计 Argo 的浏览器的Bert Bos,他们决定一起合作设计 CSS,于是创造了 CSS 的最初版本。1996 年 12 月,W3C 推出了 CSS 规范的第一版本。
      • CSS2:1998 年,W3C 发布了 CSS 的第二个版本,目前的主流浏览器都采用这标准。CSS2 的规范是基于 CSS1 设计的,包含了 CSS1 所有的功能,并扩充和改进了很多更加强大的属性。
      • CSS3:2005 年 12 月,W3C 开始 CSS3 标准的制定,并遵循模块化开发,所以没有固定的发布时间,而是一段时间发布一些特性模块。

    图片了解资料:

    https://www.cnblogs.com/LO-ME/p/3651140.html

    1.1.2 CSS的组成

    CSS是一门基于规则的语言 — 你能定义用于你的网页中特定元素的一组样式规则。这里面提到了两个概念,一是特定元素,二是样式规则。对应CSS的语法,也就是选择器(selects声明(eclarations

    • 选择器:指定将要添加样式的 HTML元素的方式。可以使用标签名,class值,id值等多种方式。
    • 声明:形式为属性(property):值(value),用于设置特定元素的属性信息。
      • 属性:指示文体特征,例如font-sizewidthbackground-color
      • 值:每个指定的属性都有一个值,该值指示您如何更改这些样式。

    格式:

    选择器 {
        属性名:属性值;
        属性名:属性值;
        属性名:属性值;
    }
    

    举例:

    h1 {
        color: red;
        font-size: 5px;
    }
    

    视频老师了解资料

    格式简介:语法由一个 选择器(selector)起头。 它 选择(selects) 了我们将要用来添加样式的 HTML元素。 在这个例子中我们为一级标题添加样式。

    接着输入一对大括号{ }。 在大括号内部定义一个或多个形式为 属性(property):值(value);声明(eclarations)。每个声明都指定了我们所选择元素的一个属性,之后跟一个我们想赋给这个属性的值。

    冒号之前是属性,冒号之后是值。不同的CSS 属性(properties) 对应不同的合法值。在这个例子中,我们指定了 color 属性,它可以接受许多 颜色值(lor values)。 还有 font-size 属性, 它可以接收许多 size units 值。

    1.2 入门案例

    1. 在初始页面的<body>标签中,加入一对<h1> 标签。<h1>标签规定的固定的标题样式。

      <!DOCTYPE html>
      <html>
        <head>
          <meta charset="utf-8">
          <title>页面标题</title>
        </head>
        <body>
            <h1>今天开始变漂亮!!!</h1>
        </body>
      </html>
      
      
    2. <head>标签中加入一对<style> 标签中,表示准备应用样式。

      <!DOCTYPE html>
      <html>
      <head>
          <meta charset="utf-8">
          <title>页面标题</title>
          <!-- 加入style标签 -->
          <style>
            
          </style>
      </head>
      <body>
      <h1 color="red">今天开始变漂亮!!!</h1>
      </body>
      </html>
      
      
    3. 编写样式

         <style>
              h1{
                  color: red;  /* 设置颜色为红色*/
                  font-size:100px; /* 设置字体大小为100像素*/
              }
          </style>
      
    4. 打开浏览器查看,文字的颜色和大小都发生改变,应用了新的样式,效果如图:

    1.3 Chrome开发者工具

    • 打开开发者工具

      打开浏览器,点击键盘F12键,显示开发者工具窗口。

    • 查看开发者工具

      演示选择元素

      演示修改样式

    1.4 总结

    CSS是对HTML的补充,指定页面如何展示的语言。

    CSS的主要部分有:

    1. 选择器:用来选择页面元素的方式。
    2. 声明:用来设置样式,格式属性名:值

    在学习CSS时,要抓住两个方面:

    1. 掌握多种选择器,能够灵活的选择页面元素。
    2. 掌握样式的声明,能够使用多种属性来设置多样的效果。
    展开全文
  • ARCore快速入门--简介

    千次阅读 2018-05-23 18:09:44
    简介 ARCore 是一套用来创建AR(augmented reality) App的SDK。...它可以在现下多种流行开发平台中使用. 它本身封装了一套本地API,通过它可以实现一些最基础的AR效果:比如 手势监听、世界的定义、灯光识别 等 通俗来...

    develop_hero

    简介

    ARCore 是一套用来创建AR(augmented reality) App的SDK。 官方网站是https://developers.google.com/ar/develop/。它可以在现下多种流行开发平台中使用. 它本身封装了一套本地API,通过它可以实现一些最基础的AR效果:比如 手势监听世界的定义灯光识别 等 通俗来讲就是在用户视觉(主要是Camera)的基础上,覆盖一些3D模型,这些模型可以是 世界 事物 或者 各种角色。 熟悉IOS的童鞋可以把它理解为Apple的 ARKit .

    ARCore 的原理主要是集成了设备Camera中的 加速传感器 陀螺仪 上下文识别信息 等功能。首先它从Camera环境中甄别出一些可视的特征, 并通过手势追踪、传感器传来的坐标位移等,进而实现了一个现实世界与虚拟事物的一个映射功能。

    效果

    具体实现效果可以参考一下图片:
    viro_black_panther_marker_demo
    如图所示:
    在现实世界的画廊里,通过手机摄像头扫描“黑豹”的logo图,就会从屏幕中跳出一个虚拟的“黑豹”模型。而这个模型在屏幕中是真实存在的,即使你把Camera移到别的地方,然后重新将镜头转回 你会发现“黑豹”还是在那里

    准备工作

    在开始真正的ARCore开发工作之前,需要做一些准备工作

    Android Studio

    要进行ARCore开发,必须使用Android Studio3.1或者更高。需要下载的可以在官网上下载https://developer.android.com/studio/

    Android SDK Platform

    对于Android SDK Platform 必须使用7.0或者往后的版本,这个可以在Android Studio中进行安装或更新。
    具体步骤:Tools -> SDK Manager -> SDK Platform 然后选中Show Package DetailsS,安装Android SDK Platform 27, 然后点击OK即可
    SDK Platform

    ARCore SDK

    虽然不是必需的,但是还是强烈建议将ARCore的SDK下载下来,因为SDK的samples中的几个例子还是很有参考价值的。具体下载如下:

    1. 官网下载 ARCore SDK for Android
    2. Github上下载:
      git clone https://github.com/google-ar/arcore-android-sdk.git
      git clone https://github.com/google-ar/sceneform-android-sdk.git

    可以看到有两个SDK,一个是ARCore SDK另一个是Sceneform SDK. 前者可以理解为通用版SDK,使用此版本需要强大的OpenGL知识做后盾。如果你对OpenGL不是很熟 甚至是一无所知 则可以考虑使用后者SDK中的API

    一台支持ARCore的设备

    由于这点牵涉的篇幅可能较长,所以准备另起一篇。请参考下一篇在模拟器(Emulator)上运行AR应用

    展开全文
  • PyTorch 深度学习:60分钟快速入门

    万次阅读 多人点赞 2017-11-29 21:57:00
    ddd

    此教程为翻译官方地址

    Github 地址
    简书地址
    CSDN地址

    作者:Soumith Chintala

    本教程的目标:

    • 深入理解PyTorch张量库和神经网络
    • 训练一个小的神经网络来分类图片

    这个教程假设你熟悉numpy的基本操作。

    注意

    请确保torchtorchvision包已经安装。

    一、PyTorch 是什么

    他是一个基于Python的科学计算包,目标用户有两类

    • 为了使用GPU来替代numpy
    • 一个深度学习援救平台:提供最大的灵活性和速度

    开始

    张量(Tensors)

    张量类似于numpy的ndarrays,不同之处在于张量可以使用GPU来加快计算。

    from __future__ import print_function
    import torch

    构建一个未初始化的5*3的矩阵:

    x = torch.Tensor(5, 3)
    print(x)

    输出 :

    1.00000e-10 *
     -1.1314  0.0000 -1.1314
      0.0000  0.0000  0.0000
      0.0000  0.0000  0.0000
      0.0000  0.0000  0.0000
      0.0000  0.0000  0.0000
    [torch.FloatTensor of size 5x3]

    构建一个随机初始化的矩阵

    x = torch.rand(5, 3)
    print(x)

    输出:

    0.2836  0.6710  0.5146
     0.8842  0.2821  0.7768
     0.3409  0.0428  0.6726
     0.1982  0.6950  0.6040
     0.0272  0.6586  0.3555
    [torch.FloatTensor of size 5x3]

    获取矩阵的大小:

    print(x.size())

    输出:

    torch.Size([5, 3])

    注意

    torch.Size实际上是一个元组,所以它支持元组相同的操作。

    操作

    张量上的操作有多重语法形式,下面我们一加法为例进行讲解。

    语法1

    y = torch.rand(5, 3)
    print(x + y)

    输出:

    0.9842  1.5171  0.8148
     1.1334  1.6540  1.5739
     0.9804  1.1647  0.4759
     0.6232  0.2689  1.0596
     1.0777  1.1705  0.3206
    [torch.FloatTensor of size 5x3]

    语法二

    print(torch.add(x, y))

    输出:

    0.9842  1.5171  0.8148
     1.1334  1.6540  1.5739
     0.9804  1.1647  0.4759
     0.6232  0.2689  1.0596
     1.0777  1.1705  0.3206
    [torch.FloatTensor of size 5x3]

    语法三:给出一个输出向量

    result = torch.Tensor(5, 3)
    torch.add(x, y, out=result)
    print(result)

    输出:

    0.9842  1.5171  0.8148
     1.1334  1.6540  1.5739
     0.9804  1.1647  0.4759
     0.6232  0.2689  1.0596
     1.0777  1.1705  0.3206
    [torch.FloatTensor of size 5x3]

    语法四:原地操作(in-place)

    # 把x加到y上
    y.add_(x)
    print(y)

    输出:

    0.9842  1.5171  0.8148
     1.1334  1.6540  1.5739
     0.9804  1.1647  0.4759
     0.6232  0.2689  1.0596
     1.0777  1.1705  0.3206
    [torch.FloatTensor of size 5x3]

    注意

    任何在原地(in-place)改变张量的操作都有一个’_’后缀。例如x.copy_(y), x.t_()操作将改变x.

    你可以使用所有的numpy索引操作。

    print(x[:, 1])

    输出:

    1.5171
    1.6540
    1.1647
    0.2689
    1.1705
    [torch.FloatTensor of size 5]

    稍后阅读

    这里描述了一百多种张量操作,包括转置,索引,数学运算,线性代数,随机数等。

    numpy桥

    把一个torch张量转换为numpy数组或者反过来都是很简单的。

    Torch张量和numpy数组将共享潜在的内存,改变其中一个也将改变另一个。

    把Torch张量转换为numpy数组

    a = torch.ones(5)
    print(a)

    输出:

    1
     1
     1
     1
     1
    [torch.FloatTensor of size 5]
    b = a.numpy()
    print(b)
    print(type(b))

    输出:

    [ 1.  1.  1.  1.  1.]
    <class 'numpy.ndarray'>

    通过如下操作,我们看一下numpy数组的值如何在改变。

     2
     2
     2
     2
     2
    [torch.FloatTensor of size 5]
    
    [ 2.  2.  2.  2.  2.]

    把numpy数组转换为torch张量

    看看改变numpy数组如何自动改变torch张量。

    [ 2.  2.  2.  2.  2.]
    
     2
     2
     2
     2
     2
    [torch.DoubleTensor of size 5]

    所有在CPU上的张量,除了字符张量,都支持在numpy之间转换。

    CUDA张量

    使用.cuda函数可以将张量移动到GPU上。

    # let us run this cell only if CUDA is available
    if torch.cuda.is_available():
        x = x.cuda()
        y = y.cuda()
        x + y

    **脚本总运行时间:**0.003秒

    Python源码

    Jupyter源码

    二、Autograd: 自动求导(automatic differentiation)

    PyTorch 中所有神经网络的核心是autograd包.我们首先简单介绍一下这个包,然后训练我们的第一个神经网络.

    autograd包为张量上的所有操作提供了自动求导.它是一个运行时定义的框架,这意味着反向传播是根据你的代码如何运行来定义,并且每次迭代可以不同.

    接下来我们用一些简单的示例来看这个包

    变量(Variable)

    autograd.Variableautograd包的核心类.它包装了张量(Tensor),支持几乎所有的张量上的操作.一旦你完成你的前向计算,可以通过.backward()方法来自动计算所有的梯度.

    你可以通过.data属性来访问变量中的原始张量,关于这个变量的梯度被计算放入.grad属性中

    Variable

    对自动求导的实现还有一个非常重要的类,即函数(Function).

    变量(Variable)和函数(Function)是相互联系的,并形成一个非循环图来构建一个完整的计算过程.每个变量有一个.grad_fn属性,它指向创建该变量的一个Function,用户自己创建的变量除外,它的grad_fn属性为None.

    如果你想计算导数,可以在一个变量上调用.backward().如果一个Variable是一个标量(它只有一个元素值),你不必给该方法指定任何的参数,但是该Variable有多个值,你需要指定一个和该变量相同形状的的grad_output参数(查看API发现实际为gradients参数).

    import torch
    from torch.autograd import Variable

    创建一个变量:

    x = Variable(torch.ones(2, 2), requires_grad=True)
    print(x)

    输出:

    Variable containing:
     1  1
     1  1
    [torch.FloatTensor of size 2x2]

    在变量上执行操作:

    y = x + 2
    print(y)

    输出:

    Variable containing:
     3  3
     3  3
    [torch.FloatTensor of size 2x2]

    因为y是通过一个操作创建的,所以它有grad_fn,而x是由用户创建,所以它的grad_fn为None.

    print(y.grad_fn)
    print(x.grad_fn)

    输出:

    <torch.autograd.function.AddConstantBackward object at 0x7faa6f3bdd68>
    None

    在y上执行操作

    z = y * y * 3
    out = z.mean()
    
    print(z, out)

    输出:

    Variable containing:
     27  27
     27  27
    [torch.FloatTensor of size 2x2]
     Variable containing:
     27
    [torch.FloatTensor of size 1]

    梯度(Gradients)

    现在我们来执行反向传播,out.backward()相当于执行out.backward(torch.Tensor([1.0]))

    out.backward()

    输出outx的梯度d(out)/dx:

    print(x.grad)

    输出:

    Variable containing:
     4.5000  4.5000
     4.5000  4.5000
    [torch.FloatTensor of size 2x2]

    你应该得到一个值全为4.5的矩阵,我们把变量out称为o,则o=14izi,zi=3(xi+2)2,zi|xi=1=27,因此oxi=32(xi+2),oxi=92=4.5

    我们还可以用自动求导做更多有趣的事!

    x = torch.randn(3)
    x = Variable(x, requires_grad=True)
    
    y = x * 2
    while y.data.norm() < 1000:
        y = y * 2
    
    print(y)

    输出:

    Variable containing:
     682.4722
    -598.8342
     692.9528
    [torch.FloatTensor of size 3]
    gradients = torch.FloatTensor([0.1, 1.0, 0.0001])
    y.backward(gradients)
    
    print(x.grad)

    输出:

    Variable containing:
      102.4000
     1024.0000
        0.1024
    [torch.FloatTensor of size 3]

    稍后阅读:

    关于VariableFunction的文档在http://pytorch.org/docs/autograd.

    以上脚本的总的运行时间为0.003秒.

    Python源码

    Jupyter源码

    三、神经网络

    可以使用torch.nn包来构建神经网络.

    你已知道autograd包,nn包依赖autograd包来定义模型并求导.一个nn.Module包含各个层和一个faward(input)方法,该方法返回output.

    例如,我们来看一下下面这个分类数字图像的网络.

    mnist

    convnet

    他是一个简单的前馈神经网络,它接受一个输入,然后一层接着一层的输入,知道最后得到结果.

    神经网络的典型训练过程如下:
    1. 定义神经网络模型,它有一些可学习的参数(或者权重);
    2. 在数据集上迭代;
    3. 通过神经网络处理输入;
    4. 计算损失(输出结果和正确值的差距大小)
    5. 将梯度反向传播会网络的参数;
    6. 更新网络的参数,主要使用如下简单的更新原则:

    weight = weight - learning_rate * gradient

    定义网络

    我们先定义一个网络

    import torch
    from torch.autograd import Variable
    import torch.nn 
    import torch.nn.functional as F
    
    class Net(nn.Module):
        def __init__(self):
            super(Net, self).__init__()
            # 1 input image channel, 6 output channels, 5*5 square convolution
            # kernel
    
            self.conv1 = nn.Conv2d(1, 6, 5)
            self.conv2 = nn.Conv2d(6, 16, 5)
            # an affine operation: y = Wx + b
            self.fc1 = nn.Linear(16 * 5 * 5, 120)
            self.fc2 = nn.Linear(120, 84)
            self.fc3 = nn.Linear(84, 10)
    
        def forward(self, x):
            # max pooling over a (2, 2) window
            x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
            # If size is a square you can only specify a single number
            x = F.max_pool2d(F.relu(self.conv2(x)), 2)
            x = x.view(-1, self.num_flat_features(x))
            x = F.relu(self.fc1(x))
            x = F.relu(self.fc2(x))
            x = self.fc3(x)
            return x
    
        def num_flat_features(self, x):
            size = x.size()[1:] # all dimensions except the batch dimension
            num_features = 1
            for s in size:
                num_features *= s
            return num_features
    net = Net()
    print(net)

    输出:

    Net (
      (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))
      (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))
      (fc1): Linear (400 -> 120)
      (fc2): Linear (120 -> 84)
      (fc3): Linear (84 -> 10)
    )

    你只需定义forward函数,backward函数(计算梯度)在使用autograd时自动为你创建.你可以在forward函数中使用Tensor的任何操作.

    net.parameters()返回模型需要学习的参数

    params = list(net.parameters())
    print(len(params))
    for param in params:
        print(param.size())

    输出:

    10
    torch.Size([6, 1, 5, 5])
    torch.Size([6])
    torch.Size([16, 6, 5, 5])
    torch.Size([16])
    torch.Size([120, 400])
    torch.Size([120])
    torch.Size([84, 120])
    torch.Size([84])
    torch.Size([10, 84])
    torch.Size([10])

    forward的输入和输出都是autograd.Variable.注意:这个网络(LeNet)期望的输入大小是32*32.如果使用MNIST数据集来训练这个网络,请把图片大小重新调整到32*32.

    input = Variable(torch.randn(1, 1, 32, 32))
    out = net(input)
    print(out)

    输出:

    Variable containing:
    -0.0536 -0.0548 -0.1079  0.0030  0.0521 -0.1061 -0.1456 -0.0095  0.0704  0.0259
    [torch.FloatTensor of size 1x10]

    将所有参数的梯度缓存清零,然后进行随机梯度的的反向传播.

    net.zero_grad()
    out.backward(torch.randn(1, 10))

    注意

    1. torch.nn 只支持小批量输入,整个torch.nn包都只支持小批量样本,而不支持单个样本
    2. 例如,nn.Conv2d将接受一个4维的张量,每一维分别是sSamples * nChannels * Height * Width(样本数*通道数*高*宽).
    3. 如果你有单个样本,只需使用input.unsqueeze(0)来添加其它的维数.

    在继续之前,我们回顾一下到目前为止见过的所有类.

    回顾

    • torch.Tensor-一个多维数组
    • autograd.Variable-包装一个Tensor,记录在其上执行过的操作.除了拥有Tensor拥有的API,还有类似backward()的API.也保存关于这个向量的梯度.
    • nn.Module-神经网络模块.封装参数,移动到GPU上运行,导出,加载等
    • nn.Parameter-一种变量,当把它赋值给一个Module时,被自动的注册为一个参数.
    • autograd.Function-实现一个自动求导操作的前向和反向定义,每个变量操作至少创建一个函数节点,(Every Variable operation, creates at least a single Function node, that connects to functions that created a Variable and encodes its history.)

    现在,我们包含了如下内容:

    • 定义一个神经网络
    • 处理输入和调用backward

    剩下的内容:

    • 计算损失值
    • 更新神经网络的权值

    损失函数

    一个损失函数接受一对(output, target)作为输入(output为网络的输出,target为实际值),计算一个值来估计网络的输出和目标值相差多少.

    nn包中有几种不同的损失函数.一个简单的损失函数是:nn.MSELoss,他计算输入(个人认为是网络的输出)和目标值之间的均方误差.

    例如:

    out = net(input)
    target = Variable(torch.arange(1, 11))  # a dummy target, for example
    criterion = nn.MSELoss()
    
    loss = criterion(out, target)
    print(loss)

    输出:

    Variable containing:
     38.1365
    [torch.FloatTensor of size 1]

    现在,你反向跟踪loss,使用它的.grad_fn属性,你会看到向下面这样的一个计算图:

    input -> conv2d -> relu -> maxpool2d -> conv2d -> relu -> maxpool2d
          -> view -> linear -> relu -> linear -> relu -> linear
          -> MSELoss
          -> loss

    所以, 当你调用loss.backward(),整个图关于损失被求导,图中所有变量将拥有.grad变量来累计他们的梯度.

    为了说明,我们反向跟踪几步:

    print(loss.grad_fn)  # MSELoss
    print(loss.grad_fn.next_functions[0][0])  # Linear
    print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU

    输出:

    <torch.autograd.function.MSELossBackward object at 0x7fb3c0dcf4f8>
    <torch.autograd.function.AddmmBackward object at 0x7fb3c0dcf408>
    <AccumulateGrad object at 0x7fb3c0db79e8>

    反向传播

    为了反向传播误差,我们所需做的是调用loss.backward().你需要清除已存在的梯度,否则梯度将被累加到已存在的梯度.

    现在,我们将调用loss.backward(),并查看conv1层的偏置项在反向传播前后的梯度.

    输出(官网的例子)

    conv1.bias.grad before backward
    Variable containing:
     0numpy
     0
     0
     0
     0
     0
    [torch.FloatTensor of size 6]
    
    conv1.bias.grad after backward
    Variable containing:
    -0.0317
    -0.1682
    -0.0158
     0.2276
    -0.0148
    -0.0254
    [torch.FloatTensor of size 6]

    本人运行输出

    conv1.bias.grad before backward
    None
    conv1.bias.grad after backward
    Variable containing:
     0.0011
     0.1170
    -0.0012
    -0.0204
    -0.0325
    -0.0648
    [torch.FloatTensor of size 6]

    不同之处在于backward之前不同,官网示例的梯度为0,而实际运行出来却是None.

    现在我们已知道如何使用损失函数.

    稍后阅读

    神经网络包包含了各种用来构成深度神经网络构建块的模块和损失函数,一份完整的文档查看这里

    唯一剩下的内容:

    • 更新网络的权重

    更新权重

    实践中最简单的更新规则是随机梯度下降(SGD).

    weight=weightlearning_rategradient

    ![]

    我们可以使用简单的Python代码实现这个规则.

    learning_rate = 0.01
    for f in net.parameters():
        f.data.sub_(f.grad.data * learning_rate)

    然而,当你使用神经网络是,你想要使用各种不同的更新规则,比如SGD,Nesterov-SGD,Adam, RMSPROP等.为了能做到这一点,我们构建了一个包torch.optim实现了所有的这些规则.使用他们非常简单:

    import torch.optim as optim
    
    # create your optimizer
    optimizer = optim.SGD(net.parameters(), lr=0.01)
    
    #in your trainning loop:
    optimizer.zero_grad()  # zero the gradient buffers
    output = net(input)
    loss = criter(output, target)
    loss.backward()
    optimizer.setp() # does the update

    脚本总运行时间: 0.367秒

    Python源码

    Jupyter源码

    四、训练一个分类器

    你已经看到如何去定义一个神经网络,计算损失值和更新网络的权重.

    你现在可能在思考.

    关于数据

    通常,当你处理图像,文本,音频和视频数据时,你可以使用标准的Python包来加载数据到一个numpy数组中.然后把这个数组转换成torch.*Tensor.

    • 对于图像,有诸如Pillow,OpenCV包.
    • 对于音频,有诸如scipy和librosa包
    • 对于文本,原始Python和Cython来加载,或者NLTK和SpaCy是有用的.

    对于视觉,我们创建了一个torchvision包,包含常见数据集的数据加载,比如Imagenet,CIFAR10,MNIST等,和图像转换器,也就是torchvision.datasetstorch.utils.data.DataLoader.

    这提供了巨大的便利,也避免了代码的重复.

    在这个教程中,我们使用CIFAR10数据集,它有如下10个类别:’airplane’,’automobile’,’bird’,’cat’,’deer’,’dog’,’frog’,’horse’,’ship’,’truck’.这个数据集中的图像大小为3*32*32,即,3通道,32*32像素.

    cifar10

    训练一个图像分类器

    我们将一次按照下列顺序进行:

    1. 使用torchvision加载和归一化CIFAR10训练集和测试集.
    2. 定义一个卷积神经网络
    3. 定义损失函数
    4. 在训练集上训练网络
    5. 在测试机上测试网络

    1. 加载和归一化CIFAR0

    使用torchvision加载CIFAR10是非常容易的.

    import torch
    import torchvision
    import torchvision.transforms as transforms

    torchvision的输出是[0,1]的PILImage图像,我们把它转换为归一化范围为[-1, 1]的张量.

    transform = transforms.Compose(
        [transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    
    trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                            download=True, transform=transform)
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
                                              shuffle=True, num_workers=2)
    
    testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                           download=True, transform=transform)
    testloader = torch.utils.data.DataLoader(testset, batch_size=4,
                                             shuffle=False, num_workers=2)
    
    classes = ('plane', 'car', 'bird', 'cat',
               'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

    输出:

    Files already downloaded and verified
    Files already downloaded and verified

    为了好玩,我们展示一些训练图像.

    import matplotlib.pyplot as plt
    import numpy as np
    
    # functions to show an image
    
    def imshow(img):
        img = img / 2 + 0.5     # unnormalize
        npimg = img.numpy()
        plt.imshow(np.transpose(npimg, (1, 2, 0)))
        plt.show()
    
    
    # get some random training images
    dataiter = iter(trainloader)
    images, labels = dataiter.next()
    
    # show images
    imshow(torchvision.utils.make_grid(images))
    # print labels
    print(' '.join('%5s' % classes[labels[j]] for j in range(4)))

    输出:

    truck   cat   car plane

    sphx_glr_cifar10_tutorial_001

    2. 定义一个卷积神经网络

    从之前的神经网络一节复制神经网络代码,并修改为接受3通道图像取代之前的接受单通道图像.

    from torch.autograd import Variable
    import torch.nn as nn
    import torch.nn.functional as F
    
    
    class Net(nn.Module):
        def __init__(self):
            super(Net, self).__init__()
            self.conv1 = nn.Conv2d(3, 6, 5)
            self.pool = nn.MaxPool2d(2, 2)
            self.conv2 = nn.Conv2d(6, 16, 5)
            self.fc1 = nn.Linear(16 * 5 * 5, 120)
            self.fc2 = nn.Linear(120, 84)
            self.fc3 = nn.Linear(84, 10)
    
        def forward(self, x):
            x = self.pool(F.relu(self.conv1(x)))
            x = self.pool(F.relu(self.conv2(x)))
            x = x.view(-1, 16 * 5 * 5)
            x = F.relu(self.fc1(x))
            x = F.relu(self.fc2(x))
            x = self.fc3(x)
            return x
    
    
    net = Net()

    3. 定义损失函数和优化器

    我们使用交叉熵作为损失函数,使用带动量的随机梯度下降.

    import torch.optim as optim
    
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

    4. 训练网络

    这是开始有趣的时刻.我们只需在数据迭代器上循环,听歌数据输入给网络,并优化.

    for epoch in range(2):  # loop over the dataset multiple times
    
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            # get the inputs
            inputs, labels = data
    
            # wrap them in Variable
            inputs, labels = Variable(inputs), Variable(labels)
    
            # zero the parameter gradients
            optimizer.zero_grad()
    
            # forward + backward + optimize
            outputs = net(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
    
            # print statistics
            running_loss += loss.data[0]
            if i % 2000 == 1999:    # print every 2000 mini-batches
                print('[%d, %5d] loss: %.3f' %
                      (epoch + 1, i + 1, running_loss / 2000))
                running_loss = 0.0
    
    print('Finished Training')

    输出:

    [1,  2000] loss: 2.191
    [1,  4000] loss: 1.866
    [1,  6000] loss: 1.696
    [1,  8000] loss: 1.596
    [1, 10000] loss: 1.502
    [1, 12000] loss: 1.496
    [2,  2000] loss: 1.422
    [2,  4000] loss: 1.370
    [2,  6000] loss: 1.359
    [2,  8000] loss: 1.321
    [2, 10000] loss: 1.311
    [2, 12000] loss: 1.275
    Finished Training

    5. 在测试集上测试网络

    我们在整个训练集上训练了两次网络,但是我们需要检查网络是否从数据集中学习到东西.

    我们通过预测神经网络输出的类别标签并根据实际情况进行检测.如果预测正确,我们把该样本添加到正确预测列表.

    第一步,显示测试集中的图片一遍熟悉图片内容.

    dataiter = iter(testloader)
    images, labels = dataiter.next()
    
    # print images
    imshow(torchvision.utils.make_grid(images))
    print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))

    sphx_glr_cifar10_tutorial_002

    输出:

    GroundTruth:    cat  ship  ship plane

    现在我们来看看神经网络认为以上图片是什么?

    outputs = net(Variable(images))

    输出是10个标签的能量.一个类别的能量越大,神经网络越认为他是这个类别.所以让我们得到最高能量的标签.

    _, predicted = torch.max(outputs.data, 1)
    
    print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
                                  for j in range(4)))

    输出:

    Predicted:    cat  ship   car plane

    这结果看起来非常的好.

    接下来让我们看看网络在整个测试集上的结果如何.

    correct = 0
    total = 0
    for data in testloader:
        images, labels = data
        outputs = net(Variable(images))
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum()
    
    print('Accuracy of the network on the 10000 test images: %d %%' % (
        100 * correct / total))

    输出:

    Accuracy of the network on the 10000 test images: 55 %

    结果看起来好于偶然,偶然的正确率为10%,似乎网络学习到了一些东西.

    那在什么类上预测较好,什么类预测结果不好呢.

    class_correct = list(0. for i in range(10))
    class_total = list(0. for i in range(10))
    for data in testloader:
        images, labels = data
        outputs = net(Variable(images))
        _, predicted = torch.max(outputs.data, 1)
        c = (predicted == labels).squeeze()
        for i in range(4):
            label = labels[i]
            class_correct[label] += c[i]
            class_total[label] += 1
    
    
    for i in range(10):
        print('Accuracy of %5s : %2d %%' % (
            classes[i], 100 * class_correct[i] / class_total[i]))

    输出:

    Accuracy of plane : 60 %
    Accuracy of   car : 46 %
    Accuracy of  bird : 44 %
    Accuracy of   cat : 35 %
    Accuracy of  deer : 38 %
    Accuracy of   dog : 43 %
    Accuracy of  frog : 57 %
    Accuracy of horse : 76 %
    Accuracy of  ship : 71 %
    Accuracy of truck : 74 %

    接下来干什么?

    我们如何在GPU上运行神经网络呢?

    在GPU上训练

    你是如何把一个Tensor转换GPU上,你就如何把一个神经网络移动到GPU上训练.这个操作会递归遍历有所模块,并将其参数和缓冲区转换为CUDA张量.

    net.cuda()

    请记住,你也必须在每一步中把你的输入和目标值转换到GPU上:

    inputs, labels = Variable(inputs.cuda()), Variable(target.cuda())

    为什么我们没注意到GPU的速度提升很多?那是因为网络非常的小.

    实践:尝试增加你的网络的宽度(第一个nn.Conv2d的第2个参数, 第二个nn.Conv2d的第一个参数,他们需要是相同的数字),看看你得到了什么样的加速.

    实现的目标:

    • 深入了解了PyTorch的张量库和神经网络.
    • 训练了一个小网络来分类图片.

    在多GPU上训练

    如果你希望使用所有GPU来更大的加快速度,请查看选读:数据并行

    接下来做什么?

    **脚本总运行时间:**3:24.484

    Python源码

    Jupyter源码

    五、数据并行(选读)

    作者:Sung KimJenny Kang

    在这个教程里,我们将学习如何使用DataParallel来使用多GPU.

    PyTorch非常容易的就可以使用GPU,你可以用如下方式把一个模型防盗GPU上:

    model.gpu()

    然后你可以复制所有的张量到GPU上:

    mytensor = mytensor.gpu()

    请注意,只调用mytensor.gpu()并没有复制张量到GPU上。你需要把它赋值给一个新的张量并在GPU上使用这个张量。

    在多GPU上执行前向和反向传播是自然而然的事。然而,PyTorch默认将只是用一个GPU。你可以使用DataParallel让模型并行运行来轻易的让你的操作在多个GPU上运行。

    model = nn.DataParallel(model)

    这是这篇教程背后的核心,我们接下来将更详细的介绍它。

    导入和参数

    导入PyTorch模块和定义参数。

    import torch
    import torch.nn as nn
    from torch.autograd import Variable
    from torch.utils.data import Dataset, DataLoader
    
    # Parameters and DataLoaders
    input_size = 5
    output_size = 2
    
    batch_size = 30
    data_size = 100

    虚拟数据集

    制作一个虚拟(随机)数据集,你只需实现__getitem__.

    class RandomDataset(Dataset):
    
        def __init__(self, size, length):
            self.len = length
            self.data = torch.randn(length, size)
    
        def __getitem__(self, index):
            return self.data[index]
    
        def __len__(self):
            return self.len
    
    rand_loader = DataLoader(dataset=RandomDataset(input_size, 100),
                             batch_size=batch_size, shuffle=True)

    简单模型

    作为演示,我们的模型只接受一个输入,执行一个线性操作,然后得到结果。然而,你能在任何模型(CNN,RNN,Capsule Net等)上使用DataParallel

    我们在模型内部放置了一条打印语句来检测输入和输出向量的大小。请注意批等级为0时打印的内容。

    class Model(nn.Module):
        # Our model
    
        def __init__(self, input_size, output_size):
            super(Model, self).__init__()
            self.fc = nn.Linear(input_size, output_size)
    
        def forward(self, input):
            output = self.fc(input)
            print("  In Model: input size", input.size(),
                  "output size", output.size())
    
            return output

    创建一个模型和数据并行

    这是本教程的核心部分。首先,我们需要创建一个模型实例和检测我们是否有多个GPU。如果我们有多个GPU,我们使用nn.DataParallel来包装我们的模型。然后通过model.gpu()(看代码实际是model.cuda())把模型放到GPU上。

    运行模型

    现在我们可以看输入和输出张量的大小。

    for data in rand_loader:
        if torch.cuda.is_available():
            input_var = Variable(data.cuda())
        else:
            input_var = Variable(data)
    
        output = model(input_var)
        print("Outside: input size", input_var.size(),
              "output_size", output.size())

    输出:

    In Model: input size torch.Size([30, 5]) output size torch.Size([30, 2])
    Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
      In Model: input size torch.Size([30, 5]) output size torch.Size([30, 2])
    Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
      In Model: input size torch.Size([30, 5]) output size torch.Size([30, 2])
    Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
      In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
    Outside: input size torch.Size([10, 5]) output_size torch.Size([10, 2])

    结果

    当我们对30个输入和输出进行批处理时,我们和期望的一样得到30个输入和输出,但是如果你有多个GPU,你得到如下的结果。

    2个GPU

    如果你有2个GPU,你将看到:

    # on 2 GPUs
    Let's use 2 GPUs!
        In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
        In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
    Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
        In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
        In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
    Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
        In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
        In Model: input size torch.Size([15, 5]) output size torch.Size([15, 2])
    Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
        In Model: input size torch.Size([5, 5]) output size torch.Size([5, 2])
        In Model: input size torch.Size([5, 5]) output size torch.Size([5, 2])
    Outside: input size torch.Size([10, 5]) output_size torch.Size([10, 2])

    3个GPU

    Let's use 3 GPUs!
        In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
        In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
        In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
    Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
        In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
        In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
        In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
    Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
        In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
        In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
        In Model: input size torch.Size([10, 5]) output size torch.Size([10, 2])
    Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
    Outside: input size torch.Size([10, 5]) output_size torch.Size([10, 2])

    8个GPU

    Let's use 8 GPUs!
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
    Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
    Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([4, 5]) output size torch.Size([4, 2])
        In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
    Outside: input size torch.Size([30, 5]) output_size torch.Size([30, 2])
        In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
        In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
        In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
        In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
        In Model: input size torch.Size([2, 5]) output size torch.Size([2, 2])
    Outside: input size torch.Size([10, 5]) output_size torch.Size([10, 2])

    总结

    DataParallel自动的划分数据,并将作业发送到多个GPU上的多个模型。在每个模型完成作业后,DataParallel收集并合并结果返回给你。

    更多信息请看这里:

    http://pytorch.org/tutorials/beginner/former_torchies/parallelism_tutorial.html

    **脚本总运行时间:**0.0003秒

    Python源码

    Jupyter源码

    展开全文
  • Python 快速入门实战教程

    万次阅读 多人点赞 2019-07-17 14:48:02
    课程介绍 2017年末,Python 在国务院《新一代人工智能发展规划的通知》中被列入教学大纲,一时风头无两。Python 因其在人工智能领域的先天优势,深受欢迎,不难预见,它在未来将大有可为。两年前,因项目需要,作者...

    课程介绍

    2017年末,Python 在国务院《新一代人工智能发展规划的通知》中被列入教学大纲,一时风头无两。Python 因其在人工智能领域的先天优势,深受欢迎,不难预见,它在未来将大有可为。两年前,因项目需要,作者首次接触 Python,从此便一发不可收,基于 Python 完成了多个项目的开发。一路走来,深感书本与实践脱离之痛,市面上种类繁多的编程辅导书,大都力求面面俱到,动辄数百页,难免令初学者望而生畏。鉴于此,作者推出了本达人课,试图以一种对话的形式,带领读者走进 Python。

    本课程是一个系列的 Python 教程,目标是带领读者快速掌握 Python 要义,进而上手实战。

    课程从 Python 开发环境搭建开始,随后介绍了 Python 的基础知识和基本概念,包括列表、元组、字符串、字典以及各种语句。

    然后,循序渐进地介绍了一些相对高级的主题,包括抽象、异常、文件、GUI,网络编程,爬虫等。

    此后,探讨了如何将 Python 与数据库、网络、Java 语言、Shell 脚本等工具结合使用。

    最后,课程将结合实际应用场景带领读者完成两个小程序的设计和实现。

    本课程是作者在学习工作中总结而成,内容循序渐进,语言表述生动,可读性强,认真读完这个系列文章,有助于初学者夯实基础,同时又能帮助程序员提升技能。

    点击购买,查看课程全文

    作者介绍

    应书澜,毕业于 C9 高校,研发出身,曾在阿里巴巴、上海电气、浙能集团、华为等企业的重要项目中担任技术负责人和设计师,现专注于中间件技术。

    课程内容

    导读:Python 简史

    在正式学习 Python 之前,我们应该对以下内容有所了解。

    Python 读音

    Python(英国发音:/ˈpaɪθən/ 美国发音:/ˈpaɪθɑːn/),是一种面向对象的解释型计算机程序设计语言,由荷兰人 Guido van Rossum 于1989年发明,第一个公开发行版发行于1991年。

    Python 命名

    Python 命名的由来颇具感性色彩,1989年圣诞节期间,在阿姆斯特丹,Guido 为了打发圣诞节的无趣,决心开发一个新的脚本解释程序,作为 ABC 语言的一种继承。之所以选中 Python(意为大蟒蛇)作为该编程语言的名字,是因为他是一个叫 Monty Python 的喜剧团体的爱好者。

    Python 特点

    若有人问我 Python 最大的特点是什么,我会毫不犹豫的告诉他:简单易学,功能强大。作为一款纯粹的自由软件,Python 有很多优点:

    1. 简单,基于“优雅”、“明确”、“简单”的设计哲学,Python 设计时尽量使用其它语言经常使用的标识符号和英文单词,优秀的 Python 程序具有如同英文般的易读性,这使得学习 Python 变得容易;
    2. 高级,Python 是一种高层次的编程语言,与 Java,C/C++ 相比,Python 距离真实的机器更远,它使你能够专注于解决问题而无需考虑诸如如何管理你的程序使用的内存一类的底层实现细节;
    3. 易移植,正因为脱离了底层细节的约束,Python 非常易于移植,无需修改便可以在各个平台运行,包括:Linux、Windows、FreeBSD、Macintosh、Solaris、AROS 等等。
    4. 解释性,Python 在执行时,首先会将 .py 文件中的源代码编译成 Python 的 Byte Code(字节码),然后再由 Python Virtual Machine(Python 虚拟机)来执行这些编译好的 Byte Code。用户不需要担心如何编译程序,如何确保连接装载正确的库等等。
    5. 强大而丰富的库:Python 具有丰富和强大的库,它可以帮助你处理各种工作,包括数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV 文件、密码系统、GUI、Tk 等标准库。除此以外,还有许多高质量的库,如十分经典的科学计算扩展库:NumPy、SciPy 和 matplotlib。
    6. 面向对象,Python 既支持面向过程的编程也支持面向对象的编程。在“面向过程”的语言中,程序是由过程或仅仅是可重用代码的函数构建起来的。在“面向对象”的语言中,程序是由数据和功能组合而成的对象构建起来的。与其他主要的语言如 C++ 和 Java 相比,Python 以一种非常强大又简单的方式实现面向对象编程:Python 是完全面向对象的语言,函数、模块、数字、字符串都是对象,并且完全支持继承、重载、派生、多继承,有益于增强源代码的复用性。Python 支持重载运算符和动态类型。
    7. 可扩充,Python 提供了丰富的 API 和工具,以便程序员能够轻松地使用 C 语言、C++、Cython 来编写扩充模块。Python 编译器本身也可以被集成到其它需要脚本语言的程序内。因此,很多人还把 Python 作为一种“胶水语言”(Glue Language)使用。使用 Python 将其他语言编写的程序进行集成和封装。

    Python 发展

    Python 诞生至今已经成为最受欢迎的程序设计语言之一。自2004年以后,Python 的使用率一直呈线性增长。根据 TIOBE 编程语言社区发布的2018年1月排行榜,Python 已经超过 C# 跃居热门编程语言的第四位。

    由于 Python 语言的简洁性、易读性以及可扩展性,在国外用 Python 做科学计算的研究机构日益增多,一些知名大学已经采用 Python 来教授程序设计课程。例如卡耐基梅隆大学的编程基础、麻省理工学院的计算机科学及编程导论就使用 Python 语言讲授。众多开源的科学计算软件包都提供了 Python 的调用接口,例如著名的计算机视觉库 OpenCV、三维可视化库 VTK、医学图像处理库 ITK。而 Python 专用的科学计算扩展库就更多了,例如十分经典的科学计算扩展库:NumPy、SciPy 和 Matplotlib,它们分别为 Python 提供了快速数组处理、数值运算以及绘图功能。因此 Python 语言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数据、制作图表,甚至开发科学计算应用程序。

    Python 前景

    未来是人工智能的时代,有理由相信 Python 将发挥更大的作用。经过多年的演进,人工智能发展进入了新阶段。为抢抓人工智能发展的重大战略机遇:

    • 2017年7月20日,国务院印发了《新一代人工智能发展规划》,提出了面向2030年我国新一代人工智能发展的指导思想、战略目标、重点任务和保障措施。
    • 2017年 10 月 11 日,教育部考试中心发布了“关于全国计算机等级(NCRE)体系调整”的通知,决定自 2018 年 3月起,在计算机二级考试加入了“Python 语言程序设计”科目。
    • 2018年1月16日上午,教育部召开新闻发布会,介绍了《普通高中课程方案和语文等学科课程标准(2017年版)》的有关情况,在此次“新课标”改革中,正式将人工智能、物联网、大数据处理划入新课标,这也就意味着今年秋季入学的高中生,将要开始学习 Python 了。

    学习 Python

    当前,Python 已经成为人工智能领域最流行的编程语言,而人工智能的火热又反过来促进了 Python 的发展。在国家层面力量的大力推动下,Python 普及的速度定将大大加快,无论是作为辅助工具还是跟随时代步伐,学习 Python 都是很有意义的。

    两年前,因项目需要,作者首次接触 Python,从此便一发不可收,基于 Python 完成了一系列项目的开发。一路走来,深感书本与实践脱离之痛,市面上种类繁多的编程辅导书,大都力求面面俱到,动辄数百页,难免令初学者望而生畏。鉴于此,作者写了本课程,试图以一种简明的形式,带领读者走近 Python。

    第01课:Python 开发环境搭建及预备知识

    特别说明

    如果读者已经搭建了 Python 开发环境,可跳过本章第一部分,但需要注意,本课程列举的实例代码中部分有中文注释,有些集成开发环境可能不支持中文注释,因此,运行本课程实例时请注意将注释去掉。另外,如果读者觉得搭建开发环境比较繁琐,可采用 Python 自带的 IDLE 作为开发环境,安装方法请访问:《Python3入门笔记》

    Python 开发环境搭建

    开发 Python 的 IDE 有很多,本文介绍基于 Eclipse+PyDev+Python 搭建开发环境的方法。

    • Eclipse 简介

    Eclipse 是一款基于 Java 的可扩展开发平台。其官方下载中包括 J2EE 方向版本、Java 方向版本、C/C++ 方向版本、移动应用方向版本等诸多版本。除此之外,Eclipse 还可以通过安装插件的方式进行诸如 Python、Android、PHP 等语言的开发。本文将要介绍的就是使用 Eclipse 与 PyDev 插件,安装 Python 开发环境的方法。

    • 环境

    OS:Windows 7

    Python:3.6.2

    Java:8u31

    Win7 32位,Mac OS 操作系统同下述安装方法。

    软件下载

    Eclipse 下载

    我们可以进入 Eclipse 官网下载界面下载 Eclipse 软件。在该页面,可以看到针对不同开发需求的 Eclipse 版本,本文采用的是 Eclipse IDE for Java and DSL Developers。目前,最新的版本是 Eclipse Oxygen.2 (4.7.2) Release,为2017年10月放出的版本。另外,还需要注意的是,需要根据自己的操作系统选择正确的系统位数(32/64bits)。

    PyDev 离线下载

    我们可以在 PyDev 项目下载页面看到一些有价值的信息:

    1. Eclipse、Java、PyDev 的版本对应关系;
    2. Eclipse 在线安装 PyDev 的 URL;
    3. 离线安装 PyDev 下载地址(Get zip releases),点击可以进入 SourceForge 的下载页面。本文介绍离线下载方法。

    enter image description here

    Eclipse 安装

    这里要注意,Eclipse 安装需要 Java 环境,如果还没有安装 Java 环境,请先去下载安装 JDK(点击这里)。

    Eclipse 实际上是一个基于 OSGI 框架的软件,在 Windows 系统上无需安装,只需要将其解压,双击打开 eclipse.exe 即可。在 Mac OS 上则有所不同,需要双击 .dmg 文件安装。在第一次运行时,会要求你输入工作路径,你可以自定义也可以接受默认路径。

    PyDev 插件安装

    Eclipse 插件的安装方式有离线和在线两种,本文介绍在线安装方法。

    打开 Eclipse,选择“Help”->“Install New Software”。在弹出的对话框中,点击 Add 按钮,添加新的安装源,如下图所示。

    enter image description here

    在 Location 处填写安装源的网址:http://www.pydev.org/updates/(很多博客中写的是http://pydev.org/updates),这个地址并非一成不变,因此,最好到官网确认一下。确认方法在上面“软件下载”小节中已有说明。

    此外,需取一个名字填写在 Name 处,比如我这里写的是 PyDev。把“connect all update sites during install to find required software”的勾选去掉,否则在安装新插件时会联网寻找所有可能的更新站点搜索,导致安装时间不可预估,并可能导致安装失败。确定后可以看到一个 Pending 过程,然后得到如下图所示的插件,一般来说,我们只需选择 PyDev 即可,这里我两个都安装了(不推荐):

    enter image description here

    勾选后,点击 Next 进行安装。不过,由于网络的原因,这种方法安装 PyDev 极有可能失败,提示网络连接错误等。

    Python 安装

    Python 的安装比较简单,前往 Python 官网下载安装包。进入官网之后,官网会根据你的计算机操作系统推荐 Python 安装包的版本,如下图所示,你可以根据推荐下载最新的安装包,需要注意的是,Python 目前有 Python2 和 Python3 两个大版本,差异显著,本课程基于 Python3 编写,因此,请读者选择 Python3.X 安装包,具体内容安装步骤可参考博文《Python3 入门笔记——Windows 安装与运行》

    enter image description here

    PyDev 插件配置

    安装好 PyDev 插件后,并不能正常使用,还需要配置 Python 的解释器。

    打开Eclipse,选择“Window” -> “Preferences”(如果是 Mac,则同时按下 Command 和 键唤出 Preference),找到“PyDev”,选择其中的“Interpreter” –> “Python”。点击“New”,添加一个系统里已有的 Python 解释器的路径(根据自己安装的路径确定)。确定后会经过短暂的处理,得到它的 Libraries、Buildins 等。当然,还可以根据自己的编程习惯对 PyDev 进行一些其他的配置,这里就不再说了。

    enter image description here

    创建一个 Python 项目

    前面就已经配置好了 Python 的开发环境,下面新建一个项目,来测试一下,确实可以运行。

    点击“File” -> “New” -> “Other”,找到“PyDev”,选择“PyDev Project”,点击“Next”。取一个项目名称,比如 helloPython,此外,还可以选择 Python 的语言版本和解释器版本,如下图所示:

    enter image description here

    点击“Finish”,完成项目创建。然后你会进入 PyDev 视图,进行 Python 开发。这里,我们就写一个最简单的程序,进行测试。右键项目的 src 目录,选择“New” -> “PyDev Package”,创建一个 Python 包,此处也命名为 helloPython。再右键该 package,“New” -> “PyDev Module”,此处也命名为 helloPython。双击打开 helloPython.py,添加如下代码。

    if __name__ == '__main__':     print("hello world!")  

    右键项目,选择“Run As” -> “Python Run”,或 Ctrl+F11 运行项目。此时,可以在下方的 Console 窗口,看到项目的运行结果:hello world!。

    Python 预备知识

    编程语言

    编程语言(Programming Language),是用来定义计算机程序的形式语言。它是一种被标准化的交流技巧,用来向计算机发出指令。计算机语言让程序员能够准确地定义计算机所需要使用的数据,并精确地定义在不同情况下所应当采取的行动。

    解释

    上面的定义读起来比较晦涩,下面我通俗的解释一下。

    在人类发展史上,一般将文字的出现视为文明的标志,无论是汉语,英语还是法语,它们都是人类交流沟通的工具。文字使得人类之间的沟通和交流变得有章可循,极大的提高了信息传播的效率。自计算机诞生之后,人们一直希望给计算机赋予语言的特性,使计算机像人一样的沟通,而编程语言则可看作人与计算机之间“交流沟通”的工具,它使得人类和计算机之间的高效交流得以实现。

    高级编程语言

    在实践中,人们意识到人和计算机直接“交流”相当困难,计算机能够直接理解的语言是0和1构成的机器码,而这种机器码并不符合人类的认知习惯,因此,高级编程语言应运而生。

    何为高级呢?指的是符合人类的理解习惯和思维方式,远离计算机底层。高级编程语言(如 Java,Python)使得人们能够以相对容易的方式将期望计算机执行的指令表达成文。但是,这种高级语言写成的“文章”,计算机是无法直接理解的,因此,还需要一个“翻译”,将人们编写的高级语言按照规则翻译成计算机能够理解的机器语言。根据编程语言的不同,这里的“翻译”也有显著区别。关于人与计算机之间的“交流”,简略的示意图如下:

    enter image description here

    与 Java 和 C++ 差别显著

    学习过 C/C++、Java 的读者一定还记得定义变量的方法,如下例子,定义 a、b、c、d 四个变量,其数值类型分别为 int、double、long、float,定义变量的时候,我们需要“显式”的声明变量的类型,以便在内存中为该变量开辟空间,不同的数据类型占用的内存空间是不同的,所以必须要声明。

    int a;double b;long c;float d;

    与 C++ 和 Java 不同,Python 中变量没有类型,更谈不上声明变量类型,变量只是对象的引用,而 Python 的所有类型都是对象,包括函数、模块、数字、字符串、列表、元组、字典等等。

    如下所示,定义变量 a 并赋值,同一个变量在同一段程序中三次被赋值不同的类型,之所以能如此操作,就是因为变量没有类型,它可以指向任何类型,单从这一点来看,Python 与 C++、Java 差别是很明显的。

    # -*- coding: UTF-8 -*a = 12print("a=", a)a = "ABCDE"print("a=", a)a = 1 + 4jprint("a=", a)

    执行结果:a= 12a= ABCDEa= 1+4j

    本课程实例的说明

    为了便于读者更好的理解,本课程列举了很多程序实例,其中部分程序涉及中文注释,另外,为了直观的展现程序执行的结果,课程中的实例大量使用 print 语句将结果打印到控制台,便于读者观察。

    关于本课程的实例风格,这里举一个简单的例子:

    # -*- coding: UTF-8 -*#自定义函数,求两个数的和def add(a, b):    return a + b;#直接调用内建函数pow(x,y),计算x的y次方print('10的3次方 = %d' %pow(10,3))print('1 + 2 = %d' %add(1,2))执行结果:10的3次方 = 10001 + 2 = 3

    特别说明

    上面例子中,有两点需要解释一下。

    • # -*- coding: UTF-8 -*

    Python 默认是以 ASCII 作为编码方式的,如果在自己的 Python 源码中包含了中文(或者其他非英语系的语言),即使你把自己编写的 Python 源文件以 UTF-8 格式保存了,运行时仍可能会报错:SyntaxError: Non-ASCII character '\xe5' in file XXX.py on line YY, but no encoding declared;

    解决办法:在每一个包含中文或其它语言注释的 Python 脚本文件的第一行,加入以下声明:

    # -*- coding: UTF-8 -*-
    • #

    “#”表示注解,在代码中输入它的时候,它右边的所有内容都将被忽略,注解是极为有用的,不仅有助于别人理解自己的代码,也可以提示自己。

    通过命令运行 Python 脚本

    上面的例子中,我们运行 Python 脚本都是通过 Eclipse IDE(集成开发环境)完成的,事实上运行程序的方法很多,对于 Python 语言而言,我们可以直接以命令的方式运行。

    Windows 系统

    进入 Python 脚本 test.py 所在路径下,键入命令:Python test.py。

    注意:Python 首字母大写。

    Linux 或 Unix 系统:

    进入 Python 脚本 test.py 所在路径下,键入命令:python test.py。

    注意:Python 首字母小写。

    第02课:数字和运算符

    数字

    Python 提供了三种数字类型,即 int(整型),float(浮点型),complex(复数)。

    1. int:通常被称为整型或者整数,如100、99、1、3都属于整型;
    2. float:浮点数包含整数和小数部分,如3.1415,12.578712;
    3. complex:复数包含实数部分和虚数部分,形如 a+bj,其实部和虚部都是浮点类型。

    需要注意的是,Python3 已经废弃了 Python2 的 Long(长整型),在 Python3 中,int 的大小没有限制,可以作为 Long 使用。

    数字类型转换

    Python 的三种数字类型可以进行相互转换,转换方式为:数字类型+圆括号,如下实例:

    a = 123b = 3.1415926print("int(b)=",int(b))print("float(a)=",float(a))print("complex(a)=",complex(a))print("complex(a,b)=",complex(a,b))

    执行结果:

    int(b)= 3float(a)= 123.0complex(a)= (123+0j)complex(a,b)= (123+3.1415926j)

    常用的数学函数

    Python 提供了丰富的数学函数以降低编程实现的难度,本节将介绍一些常用的函数。

    import math#求绝对值:abs(x)print("abs(-12)=",abs(-12))#向上取整:ceil(x)print("ceil(3.1415)=",math.ceil(3.1415))#向下取整:floor(x)print("floor(3.678)=",math.floor(3.678))#四舍五入:round(x)print("round(3.678)=",round(3.678))#乘方运算:pow(x,y),x的y次方print("pow(3,4)=",pow(3,4))#求平方根:sqrt(x)print("sqrt(144)=",math.sqrt(144))

    执行结果:

    abs(-12)= 12ceil(3.1415)= 4floor(3.678)= 3round(3.678)= 4pow(3,4)= 81sqrt(144)= 12.0

    运算符

    计算机的最基本用途之一就是执行数学运算,作为一门计算机语言,Python 也提供了一套丰富的运算符来满足各种运算需求。

    Python 运算符大致可分为7种,即算术运算符、比较运算符、赋值运算符、逻辑运算符、位运算符、成员运算符以及身份运算符。

    算术运算符

    对算术运算,大家并不陌生,常用的加减乘除就是算术运算。不过,在编程语言里,算术运算的符号特殊一些,Python 中的算术运算有7种:加(+)、减(-)、乘( * )、除(/)、取模(%)、幂运算( ** )和取整预算(//)。以下通过实例演示算术运算符的用法。

    #初始化测试数据X = 24Y = 5Z = 0#分别进行7种算术运算Z = X + Y print("X + Y =", Z)Z = X - Y print("X - Y =", Z)Z = X * Y print("X * Y =", Z)Z = X / Y print("X / Y =", Z)Z = X % Y print("X % Y =", Z)Z = X ** Y print("X ** Y =", Z)Z = X // Y print("X // Y =", Z)

    执行结果:

    X + Y = 29X - Y = 19X * Y = 120X / Y = 4.8X % Y = 4X ** Y = 7962624X // Y = 4

    比较运算符

    比较无处不在,大于、小于、等于、不等于……和 C/C++、Java 等编程语言一样,Python 也提供了6种比较运算符:>(大于),<(小于),==(等于),!=(不等于),>=(大于等于),<=(小于等于)。比较运算的结果是一个布尔值,True 或者 False,如下实例:

    #初始化测试数据X = 24Y = 5#分别进行7种比较运算print("X == Y:", X == Y)print("X != Y:", X != Y)print("X > Y:", X > Y)print("X < Y:", X < Y)print("X >= Y:", X >= Y)print("X <= Y:", X <= Y)

    执行结果:

    X == Y: FalseX != Y: TrueX > Y: TrueX < Y: FalseX >= Y: TrueX <= Y: False

    赋值运算

    在前文的实例中已经用到赋值运算,如 X = 25,就是一个最简单的赋值运算,“=”就是最简单的赋值运算符。将简单的赋值运算与算术运算结合,Python 形成了丰富的赋值运算符:+=、-=、=、/=、%=、*=、//=。实例如下:

    #初始化测试数据X = 2Y = 3#分别进行7种赋值运算Y = X print("Y = X, Y =", Y)Y += X print("Y += X, Y =", Y)Y -= X print("Y -= X, Y =", Y)Y *= X print("Y *= X, Y =", Y)Y /= X print("Y /= X, Y =", Y)Y **= X print("Y **= X, Y =", Y)Y //= X print("Y //= X, Y =", Y)

    执行结果:

    Y = X, Y = 2Y += X, Y = 4Y -= X, Y = 2Y *= X, Y = 4Y /= X, Y = 2.0Y **= X, Y = 4.0Y //= X, Y = 2.0

    逻辑运算

    所谓逻辑运算,就是:与、或、非。Python 中3种逻辑运算符分别为:and(与),or(或),not(非),逻辑运算的结果是布尔值:True 或者 False。

    1. A and B:当 A 为 False 时,运算结果为 False;否则返回 B 的值;
    2. A or B:当 A 为 True 时,运算结果为 A 的值,否则返回 B 的值;
    3. not A:当 A 为 True 时,返回 False,否则返回 True。

    如下实例:

    #初始化测试数据X = 2Y = 3Z = 5#分别执行3种逻辑运算print("X>Y and X<Z :", X>Y and X<Z)print("X<Y and Z :", X<Y and Z)print("X>Y or Z :", X>Y or X<Z)print("X<Y or Z :", X<Y or Z)print("X or X<Z :", X or X<Z)print("not X :", not X)print("not X<Y :", not X<Y)

    执行结果:

    X>Y and X<Z : FalseX<Y and Z : 5X>Y or Z : TrueX<Y or Z : TrueX or X<Z : 2not X : Falsenot X<Y : False

    位运算

    程序中的所有数在计算机内存中都是以二进制的形式储存的。位运算就是直接对整数在内存中的二进制位进行操作。Python 中有6种位运算符:

    1. &:按位与运算符,参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0;
    2. |:按位或运算符,只要对应的二个二进位有一个为1时,结果位就为1;
    3. ^:按位异或运算符,当两对应的二进位相异时,结果为1;
    4. ~:按位取反运算符,对数据的每个二进制位取反,即把1变为0,把0变为1;
    5. >>:右移动运算符,把 >> 左边的运算数的各二进位全部右移若干位,>> 右边的数指定移动的位数;
    6. <<:左移动运算符,运算数的各二进位全部左移若干位,由 << 右边的数指定移动的位数,高位丢弃,低位补0。

    举个例子:a=21,b=6,将两个数转换为二进制形式进行位运算。

    a = 0001 0101b = 0000 0110a&b = 0000 0100a|b = 0001 0111a^b = 0001 0011~a = 1110 1010a<<2 = 01010100a>>2 = 0000 0101

    成员运算

    除了上文介绍的5种运算符,Python 还支持成员运算符。介绍成员运算符之前,我们需要提前了解一个概念:数据结构,如字符串、列表、元组、字典。在接下来的章节中我们将详细介绍这些基础的数据结构。字符串、列表、字典,它们就像一个集合,其中包含若干元素,这些元素就是集合的成员;对于一个给定的元素,它有可能在一个给定的集合中,也可能不在,Python 中采用成员运算符来判断元素是否属于成员,成员运算的结果为布尔值,True 或者 False。

    如下实例:

    #初始化一个字符串和列表temp1 = "ABCDEFG"temp2 = [4,2,3,5,8,9]a = "CDE"b = 5c = "CDF"print("a in temp1?", a in temp1)print("b in temp2?", b in temp2)print("c in temp1?", c in temp1)

    执行结果:

    a in temp1? Trueb in temp2? Truec in temp1? False

    身份运算符

    身份运算符用于比较两个标识符所引用对象的存储单元,计算结果为布尔值,包含两个运算符:is 和 is not,分别用于判断两个标识符是否引用自一个对象。关于存储单元的比较,涉及到对内存模型的理解,本节不做详述,留到后面章节介绍。

    第03课:字符串、列表和栈

    第04课:元组、字典、集合与队列

    第05课:条件、循环及其它语句

    第06课:抽象之函数

    第07课:抽象之类

    第08课:错误和异常

    第09课:模块和标准库

    第10课:文件和流

    第11课:数据库与网络编程

    第12课:图形用户界面

    第13课:实战之用 Python 写一个抢票软件

    第14课:实战之用 Python 写一个简易爬虫

    阅读全文: https://gitchat.csdn.net/column/5ad56a79af8f2f35290f6535?utm_source=blog0717_ysl

    展开全文
  • 快速入门Web前端开发

    万次阅读 多人点赞 2018-09-30 09:06:40
    入门标准 入门标准很简单,就一条:达到能参与 Web 前端实际项目的开发水平。请注意,是实际项目,这就需要了解如今的实际项目开发都用了哪些技术栈。HTML/CSS/JavaScript 这三大基础技术栈肯定是需要掌握的,但要...
  • HTML快速入门

    千次阅读 2018-07-17 10:11:13
    一旦入门后,你可以从网上找到更多更详细的资料来继续学习。 什么是HTML HTML是英文Hyper Text Mark-up Language(超文本标记语言)的缩写,它规定了自己的语法规则,用来表示比"文本"更丰富的意义,比如...
  • Spring入门第一讲——Spring框架的快速入门

    万次阅读 多人点赞 2019-09-03 20:34:58
    Spring的概述什么是Spring据度娘所载: Spring是一个开源框架,Spring是于2003年兴起的一个轻量级的Java开发框架,由Rod Johnson创建。简单来说,Spring是一个分层的JavaSE/EEfull-stack(一站式)轻量级开源框架。...
  • Spring Boot -01- 快速入门篇(图文教程)

    万次阅读 多人点赞 2018-11-28 13:31:59
    Spring Boot -01- 快速入门篇 今天开始不断整理 Spring Boot 2.0 版本学习笔记,大家可以在博客看到我的笔记,然后大家想看视频课程也可以到【慕课网】手机 app,去找【Spring Boot 2.0 深度实践】的课程,令人开心...
  • JavaWeb快速入门(一)——新建JavaWeb项目

    万次阅读 多人点赞 2020-10-08 16:22:32
    今天是暑期实训的第三天,上午继续昨天未讲完的任务java,比如:java的异常处理、java的集合等其它java常用知识,具体讲解链接如下。下午开始将JavaWeb服务器端程序开发,包含:处理请求和展示返回回来的数据。...
  • 小猪的C语言快速入门系列(一)

    万次阅读 多人点赞 2017-10-12 16:39:43
    教程会把 C语言入门 的核心内容做关键知识点的提纯,去除一些笼统的废话,配以思维导图与经典例子, 相信可以让初学者更快的上手C语言。另外笔者只是大学学过下C基础的东西, 不是专业选手,如果本教程有什么纰漏...
  • Hibernate入门第一讲——Hibernate框架的快速入门

    万次阅读 多人点赞 2019-09-03 20:07:18
    Hibernate框架介绍什么是Hibernate我们可以从度娘上摘抄这样有关Hibernate的介绍: Hibernate是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装,它将POJO与数据库表建立映射关系,是一个全...
  • 快速入门51单片机

    千次阅读 多人点赞 2019-08-04 20:17:25
    有些学生觉得单片机很难学其实掌握入门方法也不难 开发环境搭建,不用多说,看网上教程 拿到51单片机该如何做? 首先打开看51单片机的管脚分布,51单片机是8个引脚一组,为什么是8个一组呢? 因为它是8位...
  • Maven入门指南 :Maven 快速入门及简单使用前言 Maven是一个Java语言编写的开源项目管理工具,是Apache软件基金会的顶级项目。主要用于项目构建,依赖管理,项目信息管理。 maven项目在编译、测试、打包里,会需要从...
  • 小猪的C语言快速入门系列(五)

    万次阅读 多人点赞 2017-10-24 14:06:51
    小猪的C语言快速入门系列(五)标签: C语言本节引言:上一节我们C语言 复合数据类型 中的 数组 进行了解读,本节我们会继续来学习 复合数据类型中的 指针,指针可是C语言的灵魂;利用指针可以表示与使用复杂的 数据...
  • c语言快速入门

    万次阅读 多人点赞 2020-06-04 20:03:39
    该c语言是针对学生学习的哦(考研/升本/接本等等) 专接本c语言基础知识讲解 该视频为本人录制。
  • IntelliJ IDEA 快速入门指南

    万次阅读 多人点赞 2016-07-03 17:19:48
    本节内容:- 运行你的第一个Java应用程序- 熟悉主界面- 智能编码- 简单的项目配置- 构建您的项目- 运行和调试应用程序- 运行测试- 部署你的应用到服务器上- 定制一切- 找到适合你的方式- 从Eclipse或NetBeans的迁移-...
  • SpringMVC快速入门第一讲——SpringMVC介绍与入门

    万次阅读 多人点赞 2019-11-19 09:15:08
    SpringMVC介绍SpringMVC是什么?SpringMVC和Struts2都属于表现层的框架,它是Spring框架的一部分,我们可以从Spring的整体结构中看得出来: SpringMVC处理流程SpringMVC处理流程如下...SpringMVC入门程序本系列教程使
  • 小猪的C语言快速入门系列(四)

    万次阅读 多人点赞 2017-10-16 15:09:08
    小猪的C语言快速入门系列(四)标签: C语言本节引言:经过前面三节的学习,我们对于C语言有了一点基本的了解, 假如现在要你根据下面的题目写一个这样的代码应该不难吧:题目: 输入五个学生的成绩,然后求出总和和...
  • Apache Shiro 快速入门教程,shiro 基础教程

    万次阅读 多人点赞 2017-03-31 13:39:44
    第一部分 什么是Apache Shiro 1、什么是 apache shiro : Apache Shiro是一个功能强大且易于使用的Java安全框架,提供了认证,授权,加密,和会话管理 如同 Spring security 一样都是是一个权限安全框架,但是...
  • 小猪的C语言快速入门系列(八)

    万次阅读 2017-10-17 16:34:10
    小猪的C语言快速入门系列(八)标签: C语言本节引言:本节讲解的是C语言中的位运算与文件,相信这两章对于部分童鞋来说是陌生的, 因为很多大学的老师都会选择跳过这两个知识点,其实这两个知识点也是非常 重要的,...
1 2 3 4 5 ... 20
收藏数 301,938
精华内容 120,775
关键字:

快速入门