scala
1 类定义
一个最简的类的定义就是关键字class+标识符，类名首字母应大写。
class User
val user1 = new User
关键字new被用于创建类的实例。User由于没有定义任何构造器，因而只有一个不带任何参数的默认构造器。然而，你通常需要一个构造器和类体。下面是类定义的一个例子：
class Point(var x: Int, var y: Int) {
def move(dx: Int, dy: Int): Unit = {
x = x + dx
y = y + dy
}
override def toString: String =
s"($x, $y)"
}
val point1 = new Point(2, 3)
point1.x // 2
println(point1) // prints (2, 3)
Point类有4个成员：变量x和y，方法move和toString。与许多其他语言不同，主构造方法在类的签名中(var x: Int, var y: Int)。move方法带有2个参数，返回无任何意义的Unit类型值()。这一点与Java这类语言中的void相当。另外，toString方法不带任何参数但是返回一个String值。因为toString覆盖了AnyRef中的toString方法，所以用了override关键字标记。
2 构造器
构造器可以通过提供一个默认值来拥有可选参数：
class Point(var x: Int = 0, var y: Int = 0)
val origin = new Point // x and y are both set to 0
val point1 = new Point(1)
println(point1.x) // prints 1
在这个版本的Point类中，x和y拥有默认值0所以没有必传参数。然而，因为构造器是从左往右读取参数，所以如果仅仅要传个y的值，你需要带名传参。
class Point(var x: Int = 0, var y: Int = 0)
val point2 = new Point(y=2)
println(point2.y) // prints 2
这样的做法在实践中有利于使得表达明确无误。
3 私有成员和Getter/Setter语法
成员默认是公有（public）的。使用private访问修饰符可以在类外部隐藏它们。
class Point {
private var _x = 0
private var _y = 0
private val bound = 100
def x = _x
def x_= (newValue: Int): Unit = {
if (newValue < bound) _x = newValue else printWarning
}
def y = _y
def y_= (newValue: Int): Unit = {
if (newValue < bound) _y = newValue else printWarning
}
private def printWarning = println("WARNING: Out of bounds")
}
val point1 = new Point
point1.x = 99
point1.y = 101 // prints the warning
在这个版本的Point类中，数据存在私有变量_x和_y中。def x和def y方法用于访问私有数据。def x_=和def y_=是为了验证和给_x和_y赋值。注意下对于setter方法的特殊语法：这个方法在getter方法的后面加上_=，后面跟着参数。
主构造方法中带有val和var的参数是公有的。然而由于val是不可变的，所以不能像下面这样去使用。
class Point(val x: Int, val y: Int)
val point = new Point(1, 2)
point.x = 3 // <-- does not compile
不带val或var的参数是私有的，仅在类中可见。
class Point(x: Int, y: Int)
val point = new Point(1, 2)
point.x // <-- does not compile
python
1. 面向对象编程
Python支持面向对象编程
类(class)：现实世界中一些事物的封装 （如：学生）
类：属性 （如：名字，成绩）
类对象
实例对象
引用：通过引用对类的属性和方法进行操作
实例化：创建一个类的具体实例对象 （如：学生张三）
2. 装饰器(decorator)
https://foofish.net/python-decorator.html
Code:
#Python OO example
class Student:
def __init__(self, name, grade):
self.name = name
self.grade = grade
def introduce(self):
print("hi! I'm " + self.name)
print("my grade is: " + str(self.grade))
def improve(self, amount):
self.grade = self.grade + amount
jim = Student("jim", 86)
jim.introduce()
jim.improve(10)
jim.introduce()
def add_candles(cake_func):
def insert_candles():
return cake_func() + " candles"
return insert_candles
def make_cake():
return "cake"
gift_func = add_candles(make_cake)
print(make_cake())
print(gift_func())
def add_candles(cake_func):
def insert_candles():
return cake_func() + " candles"
return insert_candles
def make_cake():
return "cake"
make_cake = add_candles(make_cake)
print(make_cake())
print(gift_func)
def add_candles(cake_func):
def insert_candles():
return cake_func() + " and candles"
return insert_candles
@add_candles
def make_cake():
return "cake"
make_cake = add_candles(make_cake)
print(make_cake())
print(gift_func)
3.OS模块
3.1 os.path() 模块
os.path.abspath(path) 返回绝对路径
os.path.basename(path) 返回文件名
os.path.commonprefix(list) 返回list(多个路径)中，所有path共有的最长的路径
os.path.dirname(path) 返回文件路径
os.path.exists(path) 如果路径 path 存在，返回 True；如果路径 path 不存在，返回 False。
os.path.lexists 路径存在则返回True,路径损坏也返回True
os.path.expanduser(path) 把path中包含的""和"user"转换成用户目录
os.path.expandvars(path) 根据环境变量的值替换path中包含的"{name}"
os.path.getatime(path) 返回最近访问时间（浮点型秒数）
os.path.getmtime(path) 返回最近文件修改时间
os.path.getctime(path) 返回文件 path 创建时间
os.path.getsize(path) 返回文件大小，如果文件不存在就返回错误
os.path.isabs(path) 判断是否为绝对路径
os.path.isfile(path) 判断路径是否为文件
os.path.isdir(path) 判断路径是否为目录
os.path.islink(path) 判断路径是否为链接
os.path.ismount(path) 判断路径是否为挂载点
os.path.join(path1[, path2[, ...]]) 把目录和文件名合成一个路径
os.path.normcase(path) 转换path的大小写和斜杠
os.path.normpath(path) 规范path字符串形式
os.path.realpath(path) 返回path的真实路径
os.path.relpath(path[, start]) 从start开始计算相对路径
os.path.samefile(path1, path2) 判断目录或文件是否相同
os.path.sameopenfile(fp1, fp2) 判断fp1和fp2是否指向同一文件
os.path.samestat(stat1, stat2) 判断stat tuple stat1和stat2是否指向同一个文件
os.path.split(path) 把路径分割成 dirname 和 basename，返回一个元组
os.path.splitdrive(path) 一般用在 windows 下，返回驱动器名和路径组成的元组
os.path.splitext(path) 分割路径，返回路径名和文件扩展名的元组
os.path.splitunc(path) 把路径分割为加载点与文件
os.path.walk(path, visit, arg) 遍历path，进入每个目录都调用visit函数，visit函数必须有3个参数(arg, dirname, names)，dirname表示当前目录的目录名，names代表当前目录下的所有文件名，args则为walk的第三个参数
os.path.supports_unicode_filenames 设置是否支持unicode路径名
4.關於sys
1.導入模塊時：import xxx，默認情況下python解析器会搜索當前目錄已安装的内置模塊和第三方模塊，搜索路徑存放在sys模塊的path中：
路徑
import sys
sys.path.append(’引用模块的地址')
此方法運行時修改，腳本運行完就失效。
另外一种方法是：
把路径添加到系统的环境变量，或把该路径的文件夹放进已经添加到系统环境变量的路径内。环境变量的内容会自动添加到模块搜索路径中。
sys模块包含了与python解释器和它的环境有关的函数，这个你可以通过dir(sys)来查看他里面的方法和成员属性。
下面的两个方法可以将模块路径加到当前模块扫描的路径里：
sys.path.append('你的模块的名称')。
sys.path.insert(0,'模块的名称')
永久添加路径到sys.path中，方式有三，如下：
1）将写好的py文件放到 已经添加到系统环境变量的 目录下 ；
- 在 /usr/lib/python2.6/site-packages 下面新建一个.pth 文件(以pth作为后缀名)
将模块的路径写进去，一行一个路径，如： vim pythonmodule.pth
/home/liu/shell/config
/home/liu/shell/base - 使用PYTHONPATH环境变量
export PYTHONPATH=$PYTHONPATH:/home/liu/shell/config
2.python在安装时，默认的编码是ascii，当程序中出现非ascii编码时，python的处理常常会报这样的错UnicodeDecodeError: 'ascii' codec can't decode byte 0x?? in position 1: ordinal not in range(128)，python没办法处理非ascii编码的，此时需要自己设置将python的默认编码，一般设置为utf8的编码格式。
查询系统默认编码可以在解释器中输入以下命令：
sys.getdefaultencoding()
设置默认编码时使用：
sys.setdefaultencoding('utf8')
可能会报AttributeError: 'module' object has no attribute 'setdefaultencoding'的错误，执行reload(sys)，在执行以上命令就可以顺利通过。
此时在执行sys.getdefaultencoding()就会发现编码已经被设置为utf8的了，但是在解释器里修改的编码只能保证当次有效，在重启解释器后，会发现，编码又被重置为默认的ascii了，那么有没有办法一次性修改程序或系统的默认编码呢。
有2种方法设置python的默认编码：
一个解决的方案在程序中加入以下代码：
import sys
reload(sys)
sys.setdefaultencoding('utf8')
另一个方案是在python的Lib\site-packages文件夹下新建一个sitecustomize.py，内容为：
# encoding=utf8
import sys
reload(sys)
sys.setdefaultencoding('utf8')
此时重启python解释器，执行sys.getdefaultencoding()，发现编码已经被设置为utf8的了，多次重启之后，效果相同，这是因为系统在python启动的时候，自行调用该文件，设置系统的默认编码，而不需要每次都手动的加上解决代码，属于一劳永逸的解决方法。
Python 里面的编码和解码也就是 unicode 和 str 这两种形式的相互转化。编码是 unicode -> str，相反的，解码就
是 str -> unicode。剩下的问题就是确定何时需要进行编码或者解码了.关于文件开头的"编码指示"，也就是 # -- coding: -- 这个语句。Python 默认脚本文件都是 UTF-8 编码的，当文件中有非 UTF-8 编码范围内的字符的时候就要使用"编码指示"来修正. 关于 sys.defaultencoding，这个在解码没有明确指明解码方式的时候使用。比如我有如下代码：
# -*- coding: utf-8 -*-
s = '中文' # 注意这里的 str 是 str 类型的，而不是 unicode
s.encode('gb18030')
这句代码将 s 重新编码为 gb18030 的格式，即进行 unicode -> str 的转换。因为 s 本身就是 str 类型的，因此
Python 会自动的先将 s 解码为 unicode ，然后再编码成 gb18030。因为解码是python自动进行的，我们没有指明解码方式，python 就会使用 sys.defaultencoding 指明的方式来解码。很多情况下 sys.defaultencoding 是
ANSCII，如果 s 不是这个类型就会出错。拿上面的情况来说，我的 sys.defaultencoding 是 anscii，而 s 的编码方式和文件的编码方式一致，是 utf8 的，所以出错了:
UnicodeDecodeError: 'ascii' codec can't decode byte 0xe4 in position
0: ordinal not in range(128)
对于这种情况，我们有两种方法来改正错误：
一是明确的指示出 s 的编码方式
# -*- coding: utf-8 -*-
s = '中文'
s.decode('utf-8').encode('gb18030')
二是更改 sys.defaultencoding 为文件的编码方式
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import sys
reload(sys) # Python2.5 初始化后会删除 sys.setdefaultencoding 这个方法，我们需要重新载入
sys.setdefaultencoding('utf-8')
str = '中文'
str.encode('gb18030')
看完之后,改成这样
print "<p>addr:", form["addr"].value.decode('gb2312').encode('utf-8')
成功通过.
我总结一下为什么要这么写的原因:
1. 当取回来的数据与你当前脚本中声明的编码不一致时就要做编码转换
2.在编码转换时首先要将该数据以自身编码的格式换成unicode码,再将这个unicode按utf8编码
3.为什么我的浏览器会传回gb2312的编码数据到服务器,这应该和客户端的系统编码有关系
5.JSON
JSON 函数，导入:import json。
函数：
json.dumps 将 Python 对象编码成 JSON 字符串
json.loads 将已编码的 JSON 字符串解码为 Python 对象
6.__future__包的使用。
__future__包更多是用来统一版本。
很多代码通常会有这几条。
from __future__ import division
from __future__ import print_function
from __future__ import absolute_import
from __future__ import unicode_literals
python2.x 中没有精确除，例如10/3=3。如果在python2中需要10/3=3.3333，则需要加上from __future__ import division来做精确除。
python2.x中print不带括号，python3.x中带括号，from __future__ import print_function可以统一。
from __future__ import absolute_import绝对引入，没有写这个的时候实际上是相对引入，比如说，你的包结构中有某个类，比如pkg/jieba.py。
如果你在main.py中写import jieba,那么在Python 2.4或之前, Python会先查找当前目录下有没有string.py, 若找到了，则引入该模块，然后你在main.py中可以直接用jieba了。而用from pkg import jieba来引入当前目录下的jieba.py了。
也是为了统一代码版本。
from __future__ import unicode_literals
Python2.x里的字符串用'xxx'表示str，Unicode字符串用u'xxx'表示unicode，而在3.x中，所有字符串都被视为unicode，因此，写u'xxx'和'xxx'是完全一致的。
为了和Python 3.x的代码统一版本，在2.x版本的代码中，可以通过unicode_literals来使用Python 3.x的新的语法，改为默认使用unicode编码, 并取消了前缀u。
8.常用数据清洗。
8.常用数据结构和方法。
8.1 filter,map,reduce
filter(function or None, sequence) -> list, tuple, or string：入参为函数和列表/元组/字符串，返回值为item列表/元组/字符串。
map(function, sequence[, sequence, ...]) -> list：入参是为函数和列表/元组/字符串，返回值为function(item)列表。
reduce(function, sequence, starting_value)：对sequence中的item顺序迭代调用function，如果有starting_value，还可以作为初始值调用。function接收的参数个数只能为2，先把sequence中第一个值和第二个值当参数传给function，再把function的返回值和第三个值当参数传给function，然后只返回一个结果。
reduce(function, sequence[, initial]) -> value：入参是为函数和列表/元组/字符串和初始值，返回值为数值。
#1.lambda用法，冒号之前的是入参，冒号之后的是表达式，返回的值，最简单的函数
print [(lambda x:x*x)(x)for x in range(11)]
#结果：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
print (lambda x:x*x)(3)
#结果：9
g=lambda x:x*x
print g(4)
#结果：16
#2.filter用法:返回执行结果为TRUE的入参（入参是列表字符元组）
print filter(lambda x:x*x-4,range(10))
#结果：[0, 1, 3, 4, 5, 6, 7, 8, 9]
#3.map的用法：对列表入参依次执行函数。入参为列表，有多少个列表，就应该有多少个入参。
print map(lambda x:x*x-4,range(10))
#结果：[-4, -3, 0, 5, 12, 21, 32, 45, 60, 77]
print map(lambda x,y:x*y-4,range(3),[8,9,10])
#结果：[-4, 5, 16]
#4.reduce用法：先把sequence中第一个值和第二个值当参数传给function，再把function的返回值和第三个值当参数传给function,最终返回一个结果值
from functools import reduce
#接收的入参个数只能为2
print reduce(lambda x,y:x*y-4,range(4))
#结果：-40
#计算0到100的和
print reduce(lambda x,y:x+y, range(101))
#结果：5050
print reduce(lambda x,y:x+y, range(101),100)
#结果：5150
当逻辑不是很复杂的时候，可以嵌套起来用
例子：
取出字典的值，filter的结果传给map返回一个列表，拆除子列表合并成一个大列表
dict_list = [{'a':1,'b':1,'c':2},{'a':2,'b':4,'d':2}]
from itertools import chain
list(chain(*list(map(lambda x: x.values(), filter(lambda x: x is not None, dict_list)))))
结果：[1, 1, 2, 2, 4, 2]
chain.from_iterable是迭代器的形式，把元素拆分，例如元素"str"会拆成"s","t","r"。
不能传入不可迭代的格式，例如type。
dict_ = [{'a':'11','b':'1','c':'2'},{'a':'2','b':'4','d':'2'}]
list(chain.from_iterable(dict.values()))
结果：[1,1, 1, 2, 2, 4, 2]
网友评论