学好一门编程语言是十分不容易的,但是如果学会了,它的实用性是很强的,下面我为大家整理了学好一门编程语言的办法,大家可以参考借鉴。
如何学好一门编程语言?
一、多总结
多总结才能加深理解、增强记忆。举例,Go 中有 slice、map、channal 类型,它们都可以用 make 生成实例,但 slice 和 map 还可以用以下形式初始化,也是编程规范中建议的初始化方式:
colors := map[string]string{}
slice := []int{}
但注意了,channal 则没有这样的语法:msg := chan string{}
上面两句是生成实例,表示空集合,但下面两句则表示实例不存在,值为 nil
var colors map[string]string
var slice []int
另外,结构体指针 slice 还可以象下面这样初始化,结构体实例不用明确地指定类型(使用了类型推导)、不用明确地取地址运算(&)。
type Product struct {
name string
price float64
}
products := []*Product{{"Spanner", 3.99}, {"Wrench", 2.49}, {"Screwdriver", 1.99}}
看到没有,如果不经常总结,这一圈学下来会把你整的稀里糊涂的。
二、多比较
学一门新语言一定要与你之前已经熟悉的语言经常作比较,找出它们的相同与不同,这样才能加深记忆和理解,否则学完之后脑子里会一片混乱,搞不清谁是谁非了。
就拿数组来说吧,在 Java、Scala、Go 中定义、实例化、赋值是不一样的。
//Java
int[] arr//定义数组,不可以指定数组长度
arr = new int[5]//创建数组对象(实例化),指定数组长度
arr[1] = 8//赋值
//Scala
val arr = new Array[Int](5) //数组在Scala里用的是泛型类,构造函数参数指定数组大小
arr(1) = 8 //赋值,注意用的是括弧
//Go
arr := [5]int{} //创建数组,初始化5个元素都为0,注意如果不指定数组长度,则是另外一种类型Slice
arr[1] = 8 //赋值
再比如 Map 在 Scala 与 Go 语言里定义、初始化、访问也是不同的,作了以下比较后印象会非常深刻,把它们记下来,这样以后使用就不会搞混了。
//Scala
val capital = Map("France" ->"Paris", "Japan" ->"Tokyo")
println(capital.get("France"))
//Go
capital := map[string]string{"France": "Paris", "Japan": "Tokyo"}
fmt.Println(capital["France"])
Go 同时给多个变量赋值在 Scala 里可以用模式匹配做到,如下:
//Scala(使用样本类的模式匹配)
case class Tao(name: String, age: Int)
val Tao(myName, myAge) = Tao("taozs", 18)
println(myName)
println(myAge)
//Go
myName, myAge := "taozs", 18
fmt.Println(myName)
fmt.Println(myAge)
//Scala(使用元组的模式匹配)
val (myNumber, myString) = (123, "abe")
println(myNumber)
println(myString)
//Go
myNumber, myString := 123, "abe"
fmt.Println(myNumber)
fmt.Println(myString)
以下是 Scala 和 Go 定义和实现函数的区别:
//Scala
val increase: Int =>Int = (x: Int) =>x + 1
println(increase(8))
//Go
var increase func(int) int = func(x int) int { return x + 1 }
fmt.Println(increase(8))
除了在 Scala 和 Go 里都可以类型推导外,在 Scala 里还可以这样定义函数:
//Scala
val increase = (_: Int) + 1
为方便自己将来随时查阅,可以建立下面这样的对比表格,描述不一定要求规范,自己能看懂就行。
三、转变思维方式,
学会用这门语言去思考
学会用语言去思考是关键。如果你以前是学 C 的,转学 Java,你一定要改变以前面向过程的思维,学会用面向对象的思维去分析问题以前学 Java 的,转学 Scala 则要学会用函数式的编程思维解决问题。
举一个函数式编程的例子,以下是 Java 语言常用的 for 循环,循环变量从 1 到 10 执行 10 次循环体:
// 命令式编程
for (int i = 1i <10i++) {
// 此处是循环体做10次
}
这被称为命令式编程 (Imperative Programming),但学了 Scala 的函数式编程 (Functional Programming) 后,解决同样的问题,我们可以换一种思维:构建 1 到 10 的列表序列,针对列表中的`每个元素分别执行函数,如下:
//函数式编程
val autoList = (1 to 10).map(i =>/*此处是函数体,针对1到10的每一个分别调用 1次*/)
已经习惯了 Java 编程的,对 Scala 的函数式编程、样本类、模式匹配、不可变对象、隐式转换等需要一个逐步适应的过程,要渐渐学会用它们思考和解决问题。
再举个 Scala 与 Go 思维方式不同的例子,要实现对一个字符串里的每个字符加 1 的操作,Scala 里可以这样:
"abc".map(cc =>cc + 1)
"abc"是一个字符串对象,调用它的方法 map,这是纯面向对象的思维,但在 Go 里就要转变为面向过程的思维:
name := "abc"
second := strings.Map(func(x rune) rune {
return x + 1
}, name)
注意,这里的 strings 是包 (package),调用它的公共函数 Map,被人操作的对象 name 字符串作为函数参数传入。Go 提供的函数 len、cap、append、 等其实都是面向过程的,虽然 Go 也提供有面向对象的支持,已经习惯了面向对象编程的,刚开始学 Go 语言需要特别留意这一点。
四、多看开源代码
学一门语言就是学一种思维方式,如今 GitHub 上可下载的开源代码海量级,通过看别人的代码,学习别人是如何解决问题的,养成用该语言思考的习惯,另外还能学习到一些非常有用的技巧,比如我在看一个 Go 语言性能测试框架代码时看到有以下写法:
func main() {
defer profile.Start().Stop()
...
}
这个意思是指刚进入程序时执行 Start( ) 函数,程序退出前调用 Stop( ) 函数,非常好的技巧啊!可以用于需要在程序执行前和程序完成后分别执行一段逻辑的场景。再看 Start( ) 函数是怎么实现的:
func Start(options ...func(*Profile)) interface {
Stop()
} {
...
return &prof
}
该函数返回了一个实现了含有 Stop( ) 函数接口的对象,如此才能在调用 Start 调用后连调 Stop。
五、优先学会使用代码分析工具
代码分析的工具包括静态检查、测试、测试覆盖率分析、性能分析(内存、CPU)、调试工具等,工具的价值在于它可以有效帮我们发现代码问题,这在我们刚开始学一门编程语言时意义尤其重大。
例如,以下这句 Java 赋值语句估计没有哪本教科书会告诉你有性能问题:
String sb = new String(“Hello World”)
以下这段 Java 代码你也不一定能意识到有多线程问题:
synchronized public void send(authuserPacket pkt, Thread t, String flowNo) throws IOException
{
logger.info("start")
//连接不可用,直接抛出异常,等待接收线程连接服务器成功
if (!this.avaliable)
{
try
{
//如果连接不可用,则等待2S,然后重新检测
Thread.sleep(2000)
}
... ...
如果我们及时用 FindBugs 工具检查就会发现上面这些问题,进而你会去分析研究为什么,如此,你对这门语言的了解也会越来越多。
另外,Go 语言自带的 vet/test/cover/pprof/trace 都是非常有用的工具,一边学一边使用这些工具分析代码,能加深对语言的理解。
六、多练习、多实践
就象学自然语言一样,如果只知道语法不去练是没有任何效果的,只有反复地练习,慢慢才能变成自己的一项技能。书本上的例子代码最好能从头到尾亲自敲一遍,多运行、多尝试,另外再找一些题目来练习,如能有机会参与项目开发则更好啦,勤动手、勤实践是最好的学习方法。
其它的方法还有:
做好笔记,把学习中遇到的关键点和自己的思考记下来,便于后面复习和对比
复习,学习一定要重复、重复、再重复
学习贵在坚持,每天学一点(比如坚持每天学 1 小时),日积月累。
如何部署Golang应用安装supervisord
# 通过载入程式 ez_setup.py 来安装。这个载入程式会联网下载最新版本setuptools来安装,同时也可以更新本地的setuptools。
wget :peak.telemunity./dist/ez_setup.py
sudo python ez_setup.py
# 更新setuptools:
sudo python ez_setup.py -U setuptools
# 安装supervisor
easy_install supervisor
# 生成配置档案
echo_supervisord_conf >/etc/supervisord.conf
# 编辑配置档案
vim /etc/supervisord.conf
# 进入vim后找到最后两行,开启注释(取消前面的分号),
# [include]
# files = supervisor.d/*.ini
# 将所有的supervisor配置都放到 /etc/supervisor.d目录
mkdir /etc/supervisor.d
建立 supervisor 对应程式的配置档案
其中的一些路径需要换成自己对应的,这里将 zankbo 这个web 应用放在了对应的使用者目录下
通过在生产伺服器上设定environment可以在程式里判断是线上还是开发模式,如 zankbo 的 debug判断
当然也可已在启动命令处加入引数,如 mand = /home/zankbo/gopath/src/zankbo/zankbo -d 来关闭Debug模式。
if os.Getenv("APP_NAME") == "ZANKBO_PRODUCT" {
beego.RunMode = "prod"
}
vim /etc/supervisor.d/zankbo.ini
# 写入
[program:zankbo]
directory = /home/zankbo/gopath/src/zankbo
environment=APP_NAME="ZANKBO_PRODUCT"
mand = /home/zankbo/gopath/src/zankbo/zankbo
autostart = true
startsecs = 5
user = zankbo
redirect_stderr = true
stdout_logfile = /home/zankbo/log/zankbo.log
建立对应的使用者
useradd zankbo
# 将使用者加入到zankbo使用者组,Nginx以使用者执行
usermod -a -G zankbo
# 更改使用者家目录使用者组的许可权,使Nginx可以访问
chmod g+rx /home/zankbo
部署Go环境
其中的目录为,go:Go安装目录 gopath:Go工作目录,下面有src、pkg、bin三个目录 log:日志资料夹
[zankbo@MyCloudServer ~]$ pwd
/home/zankbo
[zankbo@MyCloudServer ~]$ vim .bashrc
# 设定Go环境变数,在.bashrc档案末尾写下如下内容
export GOROOT=$HOME/go
export GOPATH=$HOME/gopath
export PATH=$PATH:$GOROOT/bin:$GOPATH/bi
# 切换到使用者家目录
[root@MyCloudServer ~]# su - zankbo
[zankbo@MyCloudServer ~]$ ls
go gopath log
将专案程式码放到gopath/src下面,如我的播客专案:
[zankbo@MyCloudServer ~]$ tree -L 2 gopath/src/
gopath/src/
├── github.
│ ├── astaxie
│ ├── beego
│ ├── go-sql-driver
│ ├── howeyc
│ ├── jacobsa
│ ├── *** artystreets
│ └── wendal
└── zankbo
├── admin
├── blog
├── build_pkg.sh
├── mon
├── conf
├── controllers
├── dbstruct.mwb
├── main.go
├── models
├── static
├── views
└── zankbo
汇入专案sql档案到资料库
在专案资料夹执行build
[zankbo@MyCloudServer zankbo]$ pwd
/home/zankbo/gopath/src/zankbo
[zankbo@MyCloudServer zankbo]$ go build
会在专案下生成与包名对应的可执行档案,这里为:zankbo,build的时候可能会遇到错误,比如mysql的密码之类的,可根据提示排错。
通过supervisor 来启动服务
# supervisorctl start zankbo
配置Nginx
server {
listen 80
server_name zankbo. zankbo.
root /home/zankbo/gopath/src/zankbo
error_log logs/zankbo..error.log warn
location /static/ {
root /home/zankbo/gopath/src/zankbo
location ~ .*\.(js|css)$ {
aess_log off
expires 1d
}
location ~ .*\.(gif|jpg|jpeg|png|bmp|swf)$ {
gzip off
aess_log off
expires 3d
}
}
location / {
proxy_pass :127.0.0.1:8080
}
}
如何部署thinkphp 应用1、首先在官方网站下载ThinkPHP最新版本。
2、下载后的压缩档案解压到WEB目录(或者任何目录都可以),框架的目录结构为:
├─ThinkPHP.php 框架入口档案
├─Common 框架公共档案
├─Conf 框架配置档案
├─Extend 框架扩充套件目录
├─Lang 核心语言包目录
├─Lib 核心类库目录
│ ├─Behavior 核心行为类库
│ ├─Core 核心基类库
│ ├─Driver 内建驱动
│ │ ├─Cache 内建快取驱动
│ │ ├─Db 内建资料库驱动
│ │ ├─TagLib 内建标签驱动
│ │ └─Template 内建模板引擎驱动
│ └─Template 内建模板引擎
└─Tpl 系统模板目录
注意,框架的公共入口档案ThinkPHP.php是不能直接执行的,该档案只能在专案入口档案中呼叫才能正常执行,这是很多新手很容易犯的一个错误。
3、接下来先在WEB根目录下面建立一个app子目录(这个就是app就是专案名),然后在该目录下面建立一个index.php档案,新增一行简单的程式码:
require '/ThinkPHP框架所在目录/ThinkPHP.php'
这行程式码的作用就是载入ThinkPHP框架的入口档案ThinkPHP.php,这是所有基于ThinkPHP开发应用的第一步。然后,在浏览器中访问这个入口档案。
如何部署应用到was上websphere的预设使用记忆体应该是256的 你的38的war包部署 不应该出现记忆体崩掉的问题呀。
部署系统也很简单么,就是打成war包,记得打war包得时候要检查web.xml的格式 websphere很在意这个东东的。
然后一步一步的部署就可以了。was慢 但是不会你那么慢得。可以贴error出来看看
如何部署python3 的应用mod_python,这是apache内建的模组,很严重的依赖于mod_python编译使用的python版本,和apache配套使用,不推荐
cgi,这个太old,不推荐,而且nginx不支援cgi方式,只能用ligd或者apache
fastcgi ,这个是目前流行最广的做法,通过flup模组来支援的,在nginx里对应的配置指令是 fastcgi_pass
spawn-fcgi,这个是fastcgi多程序管理程式,ligd安装包附带的,和
flup效果一样,区别是flup是
python程式码级引入,spawn-fcgi是外部程式。spawn-fcgi用途很广,可以支援任意语言开发的代
码,php,python,perl,只要你程式码实现了fastcgi介面,它都可以帮你管理你的程序
scgi,全名是Simple Common Gateway Interface,也是cgi的替代版本,scgi协议很简单,我觉得和fastcgi差不多,只是没有怎么推广开来,nginx对应的配置指令是scgi_pass,你想用就用,flup也支援。
,nginx使用proxy_pass转发,这个要求后端appplication必须内建一个能处理高并发的 server,在python的web框架当中,只能选择tornado.
python程式设计师喜欢发明轮子,tornado除了是一个web framework之外,它还可以单独提供高效能
server,所以,如果你采用其他python框架写程式码,比如说bottle,也一样可以通过import
tornado 来启动一个高效能的
server,同样的可以采用协议和nginx一起来部署。扩充套件开来,python包里面能处理高并发的
server还有很多,比如说gevent,也可以被其他框架引用来支援方式部署。
现实当中,用java来做web程式,通常就用和nginx配合,应用伺服器选择tomcat或者jetty
uwsgi,包括4部分组成,
nginx从0.8.4开始内建支援uwsgi协议,uwsgi协议非常简单,一个4个位元组header+一个body,body可以是很多协议的
包,比如说,cgi等(通过header里面栏位标示),我曾经做个一个小规模的效能对比测试,结果表明,uwsgi和fastcgi相比,效能
没有太明显的优势,也可能是资料集较小的原因
uwsgi的特点在于自带的程序控制程式.它是用c语言编写,使用natvie函式,其实和spawn-fcgi/php-fpm类似。所以uwsgi可以支援多种应用框架,包括(python,lua,ruby,erlang,go)等等
uwsgi协议
web server内建支援协议模组
application伺服器协议支援模组
程序控制程式
Gunicorn,和uwsgi类似的工具,从rails的部署工具(Unicorn)移植过来的。但是它使用的协议是 WSGI,全称是Python Web Server Gateway Interface ,这是python2.5时定义的官方标准(PEP 333 ),根红苗正,而且部署比较简单,:gunicorn./ 上有详细教程
mod_wsgi,apache的一个module,也是支援WSGI协议,:code.google./p/modwsgi/
如何部署简单python + flask应用python是一款应用非常广泛的指令码程式语言,谷歌公司的网页就是用python编写。python在生物资讯、统计、网页制作、计算等多个领域都体现出了强大的功能。python和其他指令码语言如java、R、Perl 一样,都可以直接在命令列里执行指令码程式。
所需工具:
python3.4
flask
nginx
gunicorn
supervisor
系统环境:
Ubuntu 14.04LTS
我们先写一个最基本的flask应用:
demo.py
from flask import Flask
app = Flask(**name**)
@app.route('\')
def index():
return 'Hello World.'
if __name__ == __main__:
app.run()
执行这个py档案,开启浏览器访问127.0.0.1:5000就能看到显示Hello World的页面 .
如果让这个flask引用监听来自公网ip的请求,理论上你跑此程式的机器就相当于一个伺服器了,然而这个伺服器并不完美,所以我们需要nginx和gunicorn来增加它的功能,让它真刀真枪上生产环境的时候能按要求执行。
flask自带的WSGI框架效能很差劲,只能适用于开发环境除错使用。我们用专业一点的gunicorn(还有很多其他优秀的框架)替代flask自带的WSGI框架。
配置完后,通过命令’/usr/local/bin/gunicorn -b127.0.0.1:5000‘启动应用。开启浏览器访问127.0.0.1:5000,同样能够得到返回页面
然而gunicorn也仅仅是一个python的WSGI框架而已,要让它真正处理来自网际网路的各类访问功能还是有点欠缺,这时候就需要用到大名鼎鼎的nginx 伺服器来替gunicorn遮风挡雨了。
Ubuntu下安装nginx可以用命令
sudo apt-get install nginx
安装后需要进行下配置:
cd /etc/nginx/sites-available
sudo vi test (test为配置名称,可以根据自己专案进行命名)
test档案的配置为:
server {
listen 80# 监听80埠
location / {
proxy_pass :127.0.0.1:5000# 代理本机127.0.0.1:5000的服务
}
location /static {
alias /home/ubuntu/myproject/myblog/app/static# 负载均衡
}
}
cd ..
cd sites-enable
sudo ln -s ../sites-available/lwhile . (建立软连结,别漏掉最后的.)
sudo service nginx reload
sudo service nginx restart
这样nginx的基本配置档案就写好了 接下来我们配置程序管理工具supervisor supervisor可以在后面启动你的python程序,这样很方便
1.cd /etc/supervisor/conf.d
2.sudo vi test.conf (test为档名)
[program:test]
mand = /usr/local/bin/gunicorn -b127.0.0.1:5000 /home/ubuntu/myproject/test.py
3.sudo supervisorctl
4.reload
5.start test
如果一切正常,做完这所有步骤之后,现在公网的ip访问你的主机,就可以开启你的flask应用了
python是一款应用非常广泛的指令码程式语言,谷歌公司的网页就是用python编写。python在生物资讯、统计、网页制作、计算等多个领域都体现出了强大的功能。python和其他指令码语言如java、R、Perl 一样,都可以直接在命令列里执行指令码程式。工具/原料
python;CMD命令列;windows作业系统
方法/步骤
1、首先下载安装python,建议安装2.7版本以上,3.0版本以下,由于3.0版本以上不向下相容,体验较差。
2、开启文字编辑器,推荐editplus,notepad等,将档案储存成 .py格式,editplus和notepad支援识别python语法。
指令码第一行一定要写上 #!usr/bin/python
表示该指令码档案是可执行python指令码
如果python目录不在usr/bin目录下,则替换成当前python执行程式的目录。
3、编写完指令码之后注意除错、可以直接用editplus除错。除错方法可自行百度。指令码写完之后,开启CMD命令列,前提是python 已经被加入到环境变数中,如果没有加入到环境变数,请百度
4、在CMD命令列中,输入 “python” + “空格”,即 ”python “;将已经写好的指令码档案拖拽到当前游标位置,然后敲回车执行即可。
public class Test1 {
public static void main(String[] args) {
FourElements e1 = new FourElements(1, 2, 3, 4D)
FourElements e2 = new FourElements(11, 22, 33, 44d)
FourElements e3 = e1.calculate(e2)
System.out.println("After calcualting, the result is: " + e3.toString())
}
}
class FourElements{
private double a, b, c, d
public FourElements(double a, double b, double c, double d){
this.a = a
this.b = b
this.c = c
this.d = d
}
public FourElements calculate(FourElements element2){
double newA = this.a + element2.getA()
double newB = this.b - element2.getB()
double newC = this.c * element2.getC()
double newD = this.d / element2.getD()
return new FourElements(newA, newB, newC, newD)
}
public double getA() {
return a
}
public double getB() {
return b
}
public double getC() {
return c
}
public double getD() {
return d
}
public String toString(){
return "a = " + a + ", b = " + b + ", c = " + c + ", d = " + d
}
}