杂记

cookie和session
http://wenku.baidu.com/view/8bc2c33cb307e87100f69658.html?re=view


数据相关

Platforms:
Zillabyte (Big data made easy)
Hadoop (opensource software from Apache)
Hortonworks (enterprise Hadoop distribution)
Cloudera (Hadoop distribution)
Amazon Elastic MapReduce (EMR) (Hadoop in the cloud

Visualization:
Tableau (basic data visualization)
ZingChart (paid solution, more powerful)
D3.js (Javascript library for doc manipulation)
Neo4J (graph database)

Languages:
Python (data science libraries like NumPy and SciPy.org)
R (for statistical computing and basic visualization)
Linux系统中是通过ssh服务实现的远程登录功能,默认ssh服务端口号为 22。 Window系统上 Linux 远程登录客户端有SecureCRT, Putty, SSH Secure Shell等,本文以Putty为例来登录远程服务器。 —— wrapper 包装..比如把一些现成的东西 自己加些新的功能再用一样.. —————

注意变量和函数参数(形参和实参)的区别

形参是函数的占位符,实参是填充物,可以是一个实体,也可以是变量指代物,变量名和参数名建议一致的.


Docker 简明教程
http://kb.cnblogs.com/page/536115/


列表推导式,列表解析式,([] —–> ()生成器表达式), 式,就是expression

从一个基本的可迭代对象(可以用for的),推导出另一个可迭代对象o

任何列表表达式,都可以用map函数实现


生成器 ,函数 yield
迭代器, 类的方法有魔法方法iter ,next

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
In [13]: class Fibs:
...: def __init__(self,n=10):
...: self.a=0
...: self.b=1
...: self.n=n
...: def __iter__(self): # 有了__iter__ ,实例可以被for,而且返回的还是self,依旧可以被for
...: return self
...: def __next__(self): # 这次 self 到下次self ,自动出发next函数
...: if self.a<self.n:
...: self.a,self.b=self.b,self.a+self.b
...: return self.a
...: else:
...: raise StopIteration
In [14]: fib=Fibs()
In [15]: for i in fib:
...: print (i)
1
1
2
3
5
8
13

命名空间和作用域
命名空间是是对象和对象名的一种映射
作用域是对对象操作的效力范围

缩进表现的层级关系是作用域,整个文件也是一个作用域(对应模块)
调用作用域内的函数和方法都用.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
模块
In [16]: import random
In [17]: random.randint(1,22)
Out[17]: 15
函数
In [24]: def function():
...: a=1
...: return a
In [25]: function.__name__
Out[25]: 'function'
In [26]: function.__init__
Out[26]: <method-wrapper '__init__' of function object at 0x7f9c431f90d0>
In [10]: class Myclass:
...: 'A simple example class'
...: i=12345
...: def f(self):
...: return 'hello world'
In [11]: Myclass.i
Out[11]: 12345
In [12]: Myclass.f
Out[12]: <function __main__.Myclass.f>
In [13]: Myclass.f()
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-13-9ff063a0dd28> in <module>()
----> 1 Myclass.f()
TypeError: f() missing 1 required positional argument: 'self'
In [27]: Myclass.f(a)
Out[27]: 'hello world'
等效于
In [14]: a=Myclass()
In [15]: a.f()
实力对象作为函数self的第一个参数
Out[15]: 'hello world'

map

1
2
3
4
5
6
7
8
9
10
In [1]: def foo(a,b,c):
...: return a+b+c
In [2]: map(foo,[1,2,3],[2,3,4],[4,5,6])
Out[2]: <map at 0x7f917353ac50>
In [3]: q=map(foo,[1,2,3],[2,3,4],[4,5,6])
In [4]: list(q)
Out[4]: [7, 10, 13]

pytenv

http://www.jianshu.com/p/a23448208d9a


python2和python3静态方法

python2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
In [1]: class Myclass:
...: i=1235
...: def f():
...: return 'gggg'
In [2]: Myclass.f()
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-2-9ff063a0dd28> in <module>()
----> 1 Myclass.f()
TypeError: unbound method f() must be called with Myclass instance as first argument (got nothing instead)
In [3]: class Myclass:
...: i=1235
...: @staticmethod
...: def f():
...: return 'gggg'
In [4]: Myclass.f()
Out[4]: 'gggg'
python3

In [2]: class Myclass:
…: i=12345
…: def f():
…: return ‘gggg’

In [3]: Myclass.f()
Out[3]: ‘gggg’

In [4]: class Myclass:
…: i=12345
…: def f():
…: return ‘gggg’

In [5]: Myclass.f()
Out[5]: ‘gggg’

1
2
3
4
5
6
-----------------------------------------
闭包函数
lexical词汇的,closure闭合的,也叫工厂函数
外部函数为内部函数提供运行环境,而且生成的这个内函数可以继续使用这个变量

def f1(x):
def f2(y):
return x+y
return f2

1
2
3
4
5
6
7
8
9
f2被f1closure起来,f1提供给f2词汇lexical,x
注意闭包和装饰器的区别,闭包是生产一个函数,装饰器是在调用原来的函数前先做点别的事情.
------
实例方法,静态方法,类方法
(类方法和静态方法有特定的应用场景,一般用于统计类的属性,创建了多少实例等)

class Multi:

#实例方法
def imeth(self,x):
    print x
#静态方法
@staticmethod
def smeth(x):
    print x
#类方法
def cmeth(cls,x):
    print x

#实例方法

instance=Multi()
instance.imeth(1)
或者
Multi.imeth(instance,1)

#静态方法

Multi.smeth(1)
instance.smeth(1)

#类方法
Multi.cmeth(1)
instance.cmeth(1)


多重继承的时候,如果被继承的父类的方法或者属性具有相同,传统类,按着绝对深度搜索

也可以明确指定继承谁的方法 run=Father.run


Property

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
In [10]: class newprops:
...: def getage(self):
...: return self._age
...: def setage(self,value):
...: print ('set age:',value)
...: self._age=value
In [11]: x=newprops()
In [12]: x.age=26
In [13]: x.age
Out[13]: 26
In [14]: x._age
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-14-d7ed5295a631> in <module>()
----> 1 x._age
AttributeError: 'newprops' object has no attribute '_age'
In [15]: x.setage(26)
set age: 26
In [16]: x._age
Out[16]: 26
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
In [6]: class newprops:
...: def getage(self):
...: return self._age
...: def setage(self,value):
...: print ('set age:',value)
...: self._age=value
...: age=property(getage,setage,None,None)
In [7]: x=newprops()
In [8]: x.age=26
set age: 26
In [9]: x.age
Out[9]: 26
In [16]: x._age
Out[16]: 26

函数设计

高内聚,一个函数只做一件事
低耦合, 不同函数之间关系要少越好

尽量不使用全局变量
如果函数的参数是如果是可变参数,尽量不要取改变它
函数不要过大


函数内部变量如果找不到,就往上层找,上层找不到再找全局

1
2
3
4
5
6
7
In [3]: x=88
In [4]: def selector():
...: print (x)
In [5]: selector()
88

但是要注意

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
In [3]: x=88
In [4]: def selector():
...: print (x)
...: x=99
In [5]: selector()
UnboundLocalError Traceback (most recent call last)
<ipython-input-5-2c35a205a0ba> in <module>()
----> 1 selector()
<ipython-input-4-9d8ab0e93fae> in selector()
1 def selector():
----> 2 print (x)
3 x=99
UnboundLocalError: local variable 'x' referenced before assignment
1
2
3
4
5
6
7
In [3]: def selector():
...: import __main__
...: print (__main__.x)
...: x=99
In [4]: selector()
88

all= 放置想让人调用的方法

from module import * ,只能导入all

file 模块放置的位置

dict 模块内变量和对应的值


name 如果模块被导入,那么name 就是模块的名字

如果python module.py 这样应用这个模块,那么name 会变成’main‘,即主程序


模块导入注意事项:

1.模块顶层代码的语句次序非常重要,代码定义和调用要分开
2.from 是复制变量名,而不是连接
3.from * 会让变量所属变得模糊
4.reload只会影响import的模块,不会影响from的导入
就说from module import function ,然后你修改了function,即使
你在模块里reload(module)也不会用到新的function
5.reload没有递归性
6.千万注意不要互相导入,即a到入b,b又要导入a


上下文管理

init
new_
delet
getitem

对象使用相应的操作,自动调用xxx_

想使用上下文管理,对象的类必须有进入enter 和出去exit 方法

contextlib库
http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001478651770626de401ff1c0d94f379774cabd842222ff000


方法继承

1
2
3
4
5
6
7
8
9
10
class Super:
def method(self):
print "In super.method"
class Sub(Super):
def method(self):
print 'starting Sub.method'
Super.method(self) # Super.__init__(self,data)
print 'ending Sub.method'


抽象类

子类的继承父类,但是父类的方法确由继承它的子类决定,这样的类叫做抽象类.

(超类 父类 基类) (派生类 子类) 抽象类

被继承的类是对于子类来说,是超类,或者父类

基类,最基本的类,可以让别的类继承它,派生出其他类

派生类,子类

抽象类,只要方法名,确没有实时的方法


构造 new 构造,较少用,可用于修改不可变类型
初始化 init 初始化,只能返回None
析构 del python内置的垃圾回收方法,当所有与实例相关的引用都被delet了,会被自动调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
In [7]: class A():
...: def __init__(self):
...: print "我被调用了"
...: def __del__(self):
...: print " 我被回收了"
In [8]: a=A()
我被调用了
In [9]: b=a
In [10]: del a
In [11]: del b
我被回收了

class A(int):pass

a=A(1)

实例化的时候要传入一个ini类型的数据
不传入的话,相当于调用int(),同理list(),tuple()
实际上就是在class A中没找到new ,就去父类int中找new


在使用魔法方法的时候,注意不要在类中再使用+, - a[1]这样的运算,防止死循环

所谓的魔法方法就是不是显性的调用它,在创建,删除,使用+ - * / [] . 这样的符号时候,自动调用


import random
random.all

random.file

not True and not True ,既不是也不是
== not ( True or True), 有一个是了就不行


容器协议

如果你希望定制的容器是不可变的话,你只需要定义len() 和 getitem方法
如果你希望定义的容器是可变额话,你除了定义len()和getitem方法,你还需要定义setitem() 和delitem方法


getattr()函数

getattr() 访问到一个不存在的属性时的行为

getattribute() 访问属性时的行为
setattr() 设置属性时的行为
delattr() 删除属性时的行为

你可以在创建时可以定义XXX这些魔法方法,可以直接利用
property函数,指定那个现有函数等效于这些函数.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
In [4]: class A():
...: def __init__(self):
...: self.x=1
In [5]: a=A()
In [6]: a.x
Out[6]: 1
In [7]: a.y
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-7-cc7049c6eeec> in <module>()
----> 1 a.y
AttributeError: 'A' object has no attribute 'y'
In [8]: getattr(a,'y','没有这个属性')
Out[8]: '没有这个属性'

描述符

描述符就是将某种特殊类型的类(具有get ,set,delet方法的类)的实例指派给另一个类的属性.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 具有特殊类型的类
class MyDecriptor:
def __get__(self,instance,owner):
print("getting....,self,instance,owner)"
def __set__(self,instance,owner):
print("getting....,self,instance,owner)"
def __delet__(self,instance):
print("getting....,self,instance,owner)"
class Test:
#将上面这个类的实例指派给另一个的属性,这里就是Test类的x属性
x=Mydecriptor()
test=Test()
然后调用属性
test.
这个时候会调用Mydecriptor的set方法

要求效率高并发,用Node.js写异步。
要求分布式高容错,用Go或者Erlang(Elixir)。
要求敏捷开发,快速迭代,用Rails。
要求灵巧轻量,用Python。
再不济要求入手简单上手快招人多,就用PHP。
Java的话留给企业开发吧,大公司必用。


任职要求:1、熟悉Python语言及Flask、Django、SQLAlchmy等常用框架库,有2年以年基于Python的Web后端开发和设计经验,能独立完成功能实现并提供对应单元测试脚本,能灵活运用PyLint等辅助工具保证代码质量;
2、了解WEB和B/S架构服务的相关技术,有RESTFull API开发经验;
3、熟悉OpenStack、CloudStack等开源项目,并以软件研发身份参与过虚拟化、云计算等相关项目优先;
4、2年以上基于Linux系统的开发经验,熟悉Apache或Nginx等工具;
5、有一定的前端开发基础,能基于前端框架组合和定制页面无素;
6、英语阅读能力强,能独立查阅网络技术资料、文档,学习新的框架或解决开发中遇到的问题;
7、有较好的团队合作意识,积极的工作态度和较强的责任心,熟练使用Git管理代码;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
1,web server是监听端口,负责HTTP链接管理、数据收发、HTTP协议实现等底层上的处理。
2,Web框架定义的是单个HTTP请求处理的流程。
3,nginx是反向代理服务器,是一个特殊的web server应用,和web server并不是同级的概念。
Tornado既是web server又是web框架,这两者并不矛盾。
举例来说,你写了一个tornado应用之后,直接把tornado端口跑在8000,这个时候,通过localhost:8000/foo就能访问到你的网页。这里分两步,tornado完成了底部IO事件的监听和数据接受等工作,这是tornado完成了其作为web server的使命。然后你通过按照tornado框架定义的流程,在对应的地方写了个get函数,实现了这个页面的具体内容,这是tornado作为web 框架体现了作用。
那么nginx有什么用?
他是个反向代理,反向代理顾名思义,其作用就是将接收到的HTTP请求按照一定的规则转发给后端其他服务器处理。
比如在你的一台机器上跑了三个tornado应用:foo1,foo2,foo3,端口分别为800080018003,你希望用户可以直接通过80端口来访问这些应用。这个时候你就可以用nginx来达到这个目的了。让nginx跑在80端口,当他接收到请求时,如果是/foo1,就转发给8000端口处理;如果是/foo2,就转发给8001端口处理,foo3类似。
同时也起到了负载均衡的作用
所以,tornado和nginx并没有什么联系。实际上,很多框架都实现了一些简易web server,用于调试。tornado的web server是异步的,以可以处理大量的非活跃长连接著称。所以其web server是他的一个特性feature,在介绍的时候就会提及自己是一个很酷的webserver了。

#Http请求头Accept详解:

http://www.newmediacampaigns.com/blog/browser-rest-http-accept-headers
https://github.com/pallets/flask-website/blob/master/flask_website/views/community.py

1
2
3
4
5
6
7
8
def request_wants_json():
# we only accept json if the quality of json is greater than the
# quality of text/html because text/html is preferred to support
# browsers that accept on */*
best = request.accept_mimetypes \
.best_match(['application/json', 'text/html'])
return best == 'application/json' and \
request.accept_mimetypes[best] > request.accept_mimetypes['text/html']
1
2
3
4
5
6
@mod.route('/poweredby/')
def poweredby():
if request_wants_json():
return jsonify((k, [p.to_json() for p in v])
for k, v in projects.iteritems())
return render_template('community/poweredby.html', projects=projects)

迭代理解

处理某一问题时,函数内要用的某一个变量,可以通过函数自身来确定

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
In [3]: def pow_design(n,e):
...: if n==0 or e ==0:return 1
...: s=pow_design(n,e-1)*n
...: return s
In [4]: pow(2,2)
Out[4]: 4
In [5]: pow(3,3)
Out[5]: 27
In [6]: pow(4,4)
Out[6]: 256
In [7]: pow(5,5)
Out[7]: 3125

if else 和 try except 区别

if 后面是Bool类型的条件,
而try是一种处理尝试,失败会报错

Linux进程好文章

http://www.cnblogs.com/vamei/archive/2012/09/20/2694466.html

In [8]: def foo(a):
…: try:
…: if a+1==2:
…: return 1
…: except TypeError:
…: pass
…: else:
…: return 0
…: return 2
…:
…:
…:

In [9]: foo(1)
Out[9]: 1

In [10]: foo(0)
Out[10]: 0

In [11]: foo(‘a’)
Out[11]: 2

异步 同步 回调

异步调用就是你 喊 你朋友吃饭 ,你朋友说知道了 ,待会忙完去找你 ,你就去做别的了。
回调就是你忙完再取找你朋友
同步调用就是你 喊 你朋友吃饭 ,你朋友在忙 ,你就一直在那等,等你朋友忙完了 ,你们一起去。

文章目录
  1. 1. 数据相关
  2. 2. random.file
  • 容器协议
  • 描述符
  • 迭代理解
  • if else 和 try except 区别
  • Linux进程好文章
  • 异步 同步 回调