发表于 | 分类于

序

周末参加了2天的Tableau培训，发现这个东西做可视化分析还是很方便的，用户体验也很好。
Tableau-handbook-01-01

也听了很多大师的介绍，受益良多。不管怎样，要开始学些这个Tableau了。之前也有做过IBM Cognos的开发，2个产品对比一下，从直观上来看，就是Tableau的可视化效果好很多，而且还融合了一些分析功能，挺不错的。
很久之前就知道了Tableau其实，只是一直都没有去研究她。学习的一开始呢，先是模仿，熟练掌握了Tableau之后，就可以任意发挥了。Tableau入门的话，官方就有很多的资料，挺全的，还有视频教程。

阅读全文 »

发表于 | 分类于

前几天学习了下Beautiful Soup的使用，本来想多写些内容的，但是发现，官方的介绍实在太详细了，每种方法基本都覆盖到了，

直接看官方的例子就足够了，而且还有一个中文版的，这里的话，就简单实践下，介绍几个常用的方法和一些小经验。

官方文档：https://www.crummy.com/software/BeautifulSoup/bs4/doc/

这里，我们就简单的解析下博客专栏，https://blog.hellobi.com/

这里的话，没有做太多的限制，我们直接解析就可以

1. 分析网页

我们再Firefox中，使用 Firebug很方便

bs-handbook-02-02

这里的话，文档结构也很清晰，很适合我们练习

阅读全文 »

发表于 | 分类于

上一回，我们介绍了，常用的单查询SQL，这里，我们介绍下，怎样进行关联查询，就是join的使用
数据库使用表信息：
t_class

t_student

t_student表存有t_class表的id，获取学生所属的班级信息

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
# -*- coding: utf-8 -*-
from sqlalchemy import MetaData, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Date, or_, and_
from sqlalchemy import ForeignKey
from sqlalchemy.orm import relationship
from sqlalchemy import text, func
from sqlalchemy.orm import sessionmaker
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
Base = declarative_base()
engine = create_engine('postgresql://postgres:shishi@localhost:5432/postgres')
Session = sessionmaker(bind=engine)
session = Session()
class StuClass(Base):
    __tablename__ = 't_class'
    id = Column(Integer,primary_key=True)
    class_name = Column(String(10))
    def __repr__(self):
        return "<StuClass(id='%s', name='%s')>" % (self.id, self.class_name)
class Student(Base):
    __tablename__ = 't_student'
    id = Column(Integer , primary_key=True)
    stu_name = Column(String(10))
    class_id = Column(Integer , ForeignKey('t_class.id'))
    stuClass = relationship("StuClass")
    def __repr__(self):
        return "<Student(id='%s', stu_name='%s', class_id='%s', class_name='%s')>" % (self.id, self.stu_name,self.class_id,self.stuClass.class_name)
#使用filter定义2张表的关系
for stu, stuc in session.query(Student, StuClass).filter(Student.class_id == StuClass.id).all():
    print stu,stuc
#使用join需要ForeignKey
for x in session.query(Student).join(StuClass).filter(StuClass.id == 803).all():
    print x

下面，我们再写一个统计班级人数的SQL

用SQLAlchemy来写的话，是这样的

1
2
for rs in session.query(StuClass.class_name,func.count('*').label('stu_count')).join(Student).group_by(StuClass.class_name).order_by(StuClass.class_name).all():
    print('班级:' + rs[0] + ' 人数：' + str(rs[1]))

image.png

好了，同样的功能，我们换成子查询练习下

1
2
3
4
5
 select a.class_name,b.num from t_class a
left join (
    select class_id , count(1) num from t_student group by class_id
)b on b.class_id = a.id
order by a.class_name

那SQLAlchemy是这样滴：

1
2
3
4
 sub = session.query(Student.class_id,func.count('*').label('num')).group_by(Student.class_id).subquery()
for sc,num in session.query(StuClass,sub.c.num).outerjoin(sub, StuClass.id == sub.c.class_id).order_by(StuClass.class_name).all():
    print sc,num

今天暂时先到这里，后面的话，官网上例子挺全的，大家可以自行练习下，后续也会再整理

发表于 | 分类于

今天简单看了看Python中的面向对象的一些教程，简单记录下，和Java中还是有很多类似的
看的是这个博客：访问限制

比如我们定义一个Student类
一个init构造函数，初始化2个属性，一个名字，一个成绩；
还有一个打印函数，输出学生的名字和成绩

1
2
3
4
5
6
7
8
9
10
11
12
13
class Student(object):
    def __init__(self, name, score):
        "initial student"
        self.name = name
        self.score = score
    def print_score(self):
        "print student info"
        print '%s : %s' %(self.name, self.score)
s1 = Student('lufei' , 99)
s1.print_score()

了解Java的同学都知道，我们一般定义实体类的话，一般都是private，然后定义get、set方法，
如果只是上面的代码，我们就可以随便的调用name和score了
我们需要加上限制

1
2
3
4
def __init__(self, name, score):
    "initial student"
    self.__name = name
    self.__score = score

我们在变量前面加上“__”就可以了

如果我们要引用的话，就会报错了，同样的，我们也可以加上get、set方法来使用

1
2
3
4
5
6
7
8
9
10
def get_name(self):
        return self.__name
def set_name(self,name):
    self.__name=name
print s1.get_name()
s1.set_name('libai')
print s1.get_name()

原文还有很多其他内容，大家可以自行看看，我就简单记录这些

发表于 | 分类于

好了，在前面，我们大概了解了SQLAlchemy的使用，日常，我们可能经常会使用些复杂点儿的查询，我们先练习下

#1. common filter
这里，官方都有介绍，我们主要参考这里：http://docs.sqlalchemy.org/en/rel_1_1/orm/tutorial.html
里面讲的都很清楚，我们这里简单练习下
首先是基本的脚本，后面，我们直接写query
数据库表：

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
# -*- coding: utf-8 -*-
from sqlalchemy import MetaData, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Date
from sqlalchemy.orm import sessionmaker
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
Base = declarative_base()
class Book(Base):
    __tablename__ = 't_book'
    id = Column(Integer,primary_key=True)
    name = Column(String(10),primary_key=True)
    publish_date = Column(Date,primary_key=True)
    def __repr__(self):
        return "<Book(id='%s', name='%s'" % (self.id, self.name)
engine = create_engine('postgresql://postgres:shishi@localhost:5432/postgres')
Session = sessionmaker(bind=engine)
session = Session()

我们一般的过滤的话，要使用filter这个函数

1
2
3
4
5
6
7
8
9
10
11
print '----：equals'
for book in session.query(Book).filter(Book.id==190):
    print book
print '----：not equals' 
for book in session.query(Book).filter(Book.name != 'Java'):
    print book
print '----：like'
for book in session.query(Book).filter(Book.name.like('白%')):
    print book

常用的SQL中，我们还有and，or
我们需要引入其他类
from sqlalchemy import or_, andprint ‘—-：or’for book in session.query(Book).filter(or(Book.name.like(‘白%’),Book.id == 191)):print bookprint ‘—-：and’for book in session.query(Book).filter(and_(Book.name.like(‘白%’),Book.id == 191)):print book

2. 自定义SQL

这里，我们使用text，来自定义自己的sql

1
2
3
4
5
6
7
8
9
from sqlalchemy import or_, and_
print '----：or'
for book in session.query(Book).filter(or_(Book.name.like('白%'),Book.id == 191)):
    print book  
print '----：and'
for book in session.query(Book).filter(and_(Book.name.like('白%'),Book.id == 191)):
    print book

在SQL中，我们经常会使用参数传递，这里也是可以的

1
2
3
print '-----: param'
for book in session.query(Book).filter(text("id=:p_id_1 or id=:p_id_2")).params(p_id_1=192,p_id_2=193).order_by(text("id asc")).all():
    print book

到这里，自定义SQL貌似还不够灵活，不能像在数据库中随便写SQL那样，下面，我们再试试另一种方式

1
2
3
4
5
print '-----: custom'
for book in session.query(Book).\
        from_statement(text("select *from t_book where id = :p_id_1 or id = :p_id_2 ")).\
        params(p_id_1=190, p_id_2=191).all():
    print book

这下，我们就可以随便写我们的SQL了，

3.聚合函数

我们先看看count

1
2
3
4
5
6
7
8
9
from sqlalchemy import func
print '----: count'
print session.query(func.count('*')).select_from(Book).scalar()
print session.query(func.count(Book.id)).scalar()
print '----: group by'
for rs in session.query(func.count(Book.id) , Book.name).group_by(Book.name).all():
    print rs[1]+' count： '+str(rs[0])