《数据分析和数据挖掘》第一期 扫二维码继续学习 二维码时效为半小时

(0评价)
价格: 899.00元
class Bird(object):
    have_feather=True
    way_of_reproduction='egg'
    def move(self,dx,dy):
        position=[0,0]
        position[0]=position[0]+dx
        position[1]=position[1]+dy
        return position

summer=Bird()
print='after move:',summer.move(5,8)

#!/usr/bin/env python
class Bird(object):
    have_feather=True
    way_of_reproduction='egg'
    def move(self,dx,dy):
        position=[0,0]
        position[0]=position[0]+dx
        position[1]=position[1]+dy
        return position

class Chicken(Bird):
    way_of_move='walk'
    possible_in_KFC=True

class Swan(Bird):
    way_of_move='fly'
    possible_in_KFC=Fasle

summer=Chicken()
print summer.have_feather
print summer.move(5,8)

 

[展开全文]
#! /usr/bin/env python
class Human(object):
    laugh='hahaha'   ##在类下面加入属性定义,属性名为laugh
    def show_laugh(self):
        print self.laugh
    def laugh_10th(self):
        for i in range(10):
            self.show_laugh()

xiaoming=Human()
xiaoming.laugh_10th()
        

通过self增加对象属性

#! /usr/bin/env python
class Human(object):
    laugh='hahaha'   ##在类下面加入属性定义,属性名为laugh
    def __init__(self,name):
        self.name=name   ##name为对象的属性,假如是类的属性应该定义在def的外面,在引用的时候也应该通过类属性来引用,传入值name赋值给对象的属性,类是一组事物共性的抽象,对象是类的实例化。
        print('__init__ is called! ')
    def show_name(self):
        print('My name is :'+ self.name)
    def show_laugh(self):
        print self.laugh
    def laugh_10th(self):
        for i in range(10):
            self.show_laugh()

xiaoming=Human('xiaoming')
xiaoming.show_name()

 

 

 

[展开全文]
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import time ,MySQLdb

##连接
conn=MySQLdb.connect(host="localhost",user="root",passwd="root",db="test",charset="utf-8")
cursor=conn.cursor()

##删除表
sql="drop table if exists user"
cursor.execute(sql)

##创建
sql="create tabel if not exists user(name varchar(128) primary key,created int(10))"
cursor.execute(sql)

##写入
sql="insert into user(name ,created) values(%s,%s)"
param=("aaa",int(time.time()))
n=cursor.execute(sql,param)
print 'insert',n

##写入多行
sql="insert into user(name,created) values(%s,%s)"
param=(("bbb",int(time.time())),("ccc",33),("ddd",44))
n=cursor.executmany(sql,param)
print 'insertmany',n
##更新,注意,param中传入元组要有逗号,不加逗号会有类型错误
sql="update user set name=%s where name='aaa' "
param=("zzz",)
n=cursor.execute(sql,param)
print 'update',n

##查询
n=cursor.execute("select * from user")
for row in cusor.fecthall():
    print row
    for r in  row:
        print r
 ##删除 MySQL的占位符是%s
sql="delete from user where name=%s"
param=("bbb",)
n=cursor.execute(sql,param)
print 'delete',n
##查询
n=cursor.execute("select * from user")
print cursor.fetchall()

cursor.close()
##提交
conn.commit()
##关闭
conn.close()

 

[展开全文]
#! /usr/bin/env python
#coding=utf-8

import sqlite3
##.db文件在当前目录下,(若不存在)自动创建
conn=sqlite3.connect("chinahadoop.db")
#获取数据库游标
c=conn.cursor()
#执行创建表的操作
c.execute('''CREATE TABLE category
    (id int primary key,sort int,name text)''')
c.execute('''CREATE TABLE book
    (id int primary key,
     sort int,
     name text,
     price real,
     category int,
     FOREIGN KEY(category)REFERENCES category(id))''')

##保存
conn.commit()

##关闭数据库连接
conn.close()

 

 

 

#!/usr/bin/env python
#coding=utf-8

import sqlite3
## .db文件在当前目录下,(若不存在)自动创建
conn=sqlite3.connect("chinahadoop.db")
#获取数据库游标
c=conn.cursor()
books=[(1,1,'Cook Recipe',3.12,1),
            (2,3,'Python Intro',17.5,2),
            (3,2,'OS Intro',13.6,2),
       ]
#插入操作
c.execute("INSERT INTO category VALUES(1,1,'kitchen')")
##使用占位符  在sqlite用问号作为占位符,在mysql里为%s  
c.execute("INSERT INTO category VALUES(?,?,?)",(2,2,'computer'))
#执行多条命令
c.executemany('INSERT INTO book VALUES(?,?,?,?,?)',books)   

##保存操作
conn.commit()

##关闭数据库连接
conn.close()

 

#!/usr/bin/env python
#coding=utf-8

import sqlite3
conn=sqlite3.connect("chinahadoop.db") 
c=conn.cursor()
#取出一条记录,循环器,迭代器
c.execute('SELECT name FROM category ORDER BY sort')
print(c.fetchone())
print(c.fetchone())

#取出多条记录,放在List中
c.execute('SELECT * FROM book WHERE book.category=1')   
print(c.fetchall())
##迭代遍历记录
for row in c.execute('SELECT name,price FROM book ORDER BY sort'):
    print(row)

 

 

 

#!/usr/bin/env python
#coding=utf-8

import sqlite3
conn=sqlite3.connect("chinahadoop.db") 
c=conn.cursor()
#更新某条记录
c.execute('UPDATE book SET price=? WHERE id=?',(999,1))
##删除记录
c.execute('DELETE   FROM book WHERE id=2')   


##删除整张表
c.execute('DROP TABLE book')

##保存更改
conn.commit()
##关闭连接
conn.close()

 

[展开全文]
#!/usr/bin/env python
# coding=utf-8

class Me(object):
    def test(self):
        print "hello!"
    def new_test():
        print "New Hello!"

me=Me()

print hasattr(me,"test")  ###检查me对象是否有test属性
print getattr(me,"test")  ###返回test属性
print setattr(me,"test","new_test")  ##将test属性设置为new_test
print delattr(me,"test")  ##删除test属性
print isinstance(me,Me) ##me对象是否为Me类生成的对象
print issubclass(Me,object)  ##me类是否为object类的子类

 

[展开全文]
#! /usr/bin/env python
#coding=utf-8

a=1
def change_integer(a):
    a=a+1
    pass #***pass表示占位,不执行具有操作。
    return a
###参数传值 ,在内存中a为2份
print change_integer(a)
print a

b=[1,2,3]
def change_list(b):
    b[0]=b[0]+1
    return b

print change_list(b)
print b
###参数传地址

动态类型:变量不需要声明类型,写出变量名,(重新)指向任意类型。

变量名是对象的引用,变量名不是对象本身。

引用指向内存中对象。

 

 

[展开全文]
f=open('test.txt')  ##f为文件对象,也为循环对象,默认有next函数
f.next()
f.next()
f.next()  ##error
a=[1,2,3]
a.next()   ###list对象没有next属性
b=iter(a)
b.next()
b.next()
b.next()
b.next() ##error 停止迭代

可用循环对象的地方也可以用迭代器。

#!/usr/bin/env python

def gen():
    a=10
    yield a
    a=a*10
    yield a
    yield 1000
 for i in gen():
    print i

L=[x**2 for x in range(3)]   ##表推导语法表达式,方括号改为圆括号即为生成器

G=(x**2 for x in range(3))
G
G.next()
G.next()

 

[展开全文]
#!/usr/bin/env python
#coding=utf-8

from sys import getrefcount

a=[1,2,3]
print(getrefcount(a))
b=[a,a]
print(getrefcount(a))

a="hello"

b="hello"

id(a)

id(b)

a=3

b=3

id(a)

id(b)

结果也是相同

##a和b是指向"hello" 对象的指针,结果相同,a和b指向同一个字符串对象,都在相同的地址下面。

长字符串值不相等

a="hello world!"

b="hello world!"

id(a)

id(b)

#结果不等。

#!/usr/bin/env python
#coding=utf-8

class from_obj(object):
    def __init__(self,to_obj):
        self.to_obj=to_obj

b=[1,2,3]
a=from_obj(b)   #对象引用对象
print(id(a.to_obj))
print(id(b))

越老的对象回收可能性越小

#!/usr/bin/env python
#coding=utf-8

a=[]
b=[a]
a.append(b)

del a
del b
##在内存中a和b的对象还在,因为a和b互相引用对方
## a和b循环引用对方,形成引用环的问题

 

 

 

[展开全文]
#! /usr/bin/env python
#coding=utf-8

##计算平方和
def square_sum(a,b):
    print("input",a,b)
    return a**2+b**2

##计算平方差
def square_diff(a,b):
    print("input",a,b)
    return a**2-b**2

print(square_sum(3,4))
print(square_diff(3,4))

 

 

#! /usr/bin/env python
#coding=utf-8


##使用包装函数,装饰器,类似闭包,注意区别
def deco(F):            ##F表示可调用对象 __call__
    def new_F(a,b):
        print("input",a,b)
        return F(a,b)
    return new_F


##计算平方和
@deco
def square_sum(a,b):
    return a**2+b**2

##计算平方差
@deco
def square_diff(a,b):
    return a**2-b**2

print(square_sum(3,4))
print(square_diff(3,4))

装饰器的本质,接收一个函数对象,可调用对象,返回可调用对象。

#! /usr/bin/env python
#coding=utf-8


##新的包装层,含有参数的装饰器
def pre_str(pre=''):
    ##旧的装饰器   
    def decorator(F):        
        def new_F(a,b):
            print(pre + "input", a, b)
            return F(a,b)
        return new_F
    return decorator


##计算平方和
@pre_str('hi + ')
def square_sum(a,b):
    return a**2+b**2

##计算平方差
@pre_str('hi - ')
def square_diff(a,b):
    return a**2-b**2

print(square_sum(3,4))
print(square_diff(3,4))

包含类的装饰器

#!/usr/bin/env python
## coding=utf-8


## 新的包装层,含有参数的装饰器
def decorator(aClass):     ###定义装饰器,接受对象为参数
    class newClass:        
        def __init__(self,age):
            self.total_display =0
            self.wrapped       =aClass(age)
        def display(self):
            self.total_display +=1
            print("total display",self.total_display)
            self.wrapped.display()  ##装饰器传入对象,又传入参数age,对象属性为wrapped,调用函数display
    return newClass

@decorator
class Bird:
    def __init__(self,age):
        self.age=age
    def display(self):
        print("My age is",self.age)

eagleLord=Bird(5)

for i in range(3):
    eagleLord.display()

 

类的装饰器和函数的装饰器异曲同工,目的进一步包装函数包装类。

 

 

[展开全文]
#! /usr/bin/env python
#coding=utf-8

def line_conf():
    def line(x):
        return 2*x+1
    return line  ##返回函数对象,把子函数作为对象返回

my_line=line_conf()
print(my_line(5))

 

 

#! /usr/bin/env python
#coding=utf-8

def line_conf():
    b=15
    def line(x):
        return 2*x+1
    return line  ##返回函数对象,把子函数作为对象返回
b=5
my_line=line_conf()
print(my_line(5))
## 内部实现25

 

 

#! /usr/bin/env python
#coding=utf-8

def line_conf():
    b=15
    def line(x):
        return 2*x+1
    return line  ##返回函数对象,把子函数作为对象返回
b=5
my_line=line_conf()
print(my_line.__closure__)   ##闭包属性,为一个元组tuple
print(my_line.__closure__[0].cell_contents)  ##访问元组的第0号元组中的cell_contents
###闭包中的第0号元素是闭包中的环境变量

 

 

#! /usr/bin/env python
#coding=utf-8
 
def line_conf(a,b):       ###从外部传入参数a和b
    def line(x):
        return a*x+b
    return line  ##返回函数对象,把子函数作为对象返回

line1=line_conf(1,1)
line2=line_conf(4,5)
print(line1(5),line2(5))

 

[展开全文]
#!/usr/bin/env python

#without context manager
f=open("new.txt","w")
print(f.closed)   ##whether the file is closed
f.write("Hello World")
f.close()
print(f.closed)
##True
#!/usr/bin/env python

#with context mangager

with open("new.txt","w") as f:
    print(f.closed)
    f.write("Hello World")
print(f.closed)
##结果 第一个为False,第二个为True

 

文件对象低层实现

#! /usr/bin/env python
#coding:utf-8
#customized object
class VOW(object):
    def __init__(self,text):
        self.text=text
    def __enter__(self):
        self.text="enter: "+self.text  ##添加前缀
        return self                    ##这里返回对象
    def __exit__(self,exc_type,exc_value,traceback):
        self.text=self.text+"now__exit__!"   ##添加后缀

with VOW("你好") as myvow:                 ##with as 上下文管理器之内,返回对象赋给myvow
    print(myvow.text)

print(myvow.text)  ###with as 上下文管理器之外调用__exit__函数

 

 

 

 

 

 

[展开全文]

 

数据类型

 

类别  序数  区间  比例值(%)

 

 

数据如何产生 

 

离散无序

离散有序

顺序连续

 

 

概率

排列组合

 

[展开全文]

特殊的属性称之为特性。关键字 @property

#!/usr/bin/env python
class Bird(object):
    feather=True
##表示所有的鸟都有共同的属性,羽毛

class Chicken(Bird):
    fly=False
    def __init__(self,age):
        self.age=age


class chicken(Bird):
    fly=False
    def __init__(self,age):
        self.age=age
    def ___getattr__(self,name):
        if name=='adult':
            if self.age>1.0 return True
            else:return False
        else:raise AttributeError(name)
##类的属性为fly 或者feather,对象的属性为age

summer=chicken(2)
print(summer.adult)
summer.age=0.5
print(summer.adult)
print(summer.male)


 #__getattr__函数处理访问属性不存在的问题

##鸡继承了鸟的属性,父类为bird

chick=Chicken(2)
#生成chick对象,年龄是2

print(Bird.__dict__)
print(Chicken.__dict__)
print(chick.___dict_)
##类和对象同时调用特殊方法,特殊方法通过__dict__来管理。
print('---------------------')  ##打印分割线
chick.__dict__['age']=3
print(chich.___dict_['age'])
chick.age=10
print(chick.age)

对象的属性通过字典系统来管理的,而且是分层的。

通过字典属性系统访问属性,直接赋值,同理也可以通过对象名.属性名 来直接修改。

./property.py

#!/usr/bin/env python
class num(object):
    def __init__(self,value):
        self.value=value
    def getNeg(self):
        return -self.value
    def setNeg(self,value):
        self.value=-value
    def delNeg(self):
        print('value also deleted')
        del self.value
    neg=property(getNeg,setNeg,delNeg,"I'm negative")

x=num(1.1)
print(x.neg)
x.neg=-22
print(x.value)
print(num.neg.__doc__)
del x.neg

 

 

[展开全文]
class A(object):
    def __call__(self,a):   ##call为特殊方法
        return a+10

b=A()
print b

python既是面向对象又是面向函数的编程语言,称之为多范式,多范式的实现依赖于特殊方法,dir查看对象包含的特殊方法。

dir(tuple)

dir(list) __init__,__add__,__class__

'nihao'+'beijing' <=>'nihao'.__add__('beijing')

##填入了特殊方法。相当于运算符的低层实现。

1.1*8<==>1.1.__mul__(8)

其他运算符的实现也是基于同样的方法

对象.特殊方法

len()函数计算序列中元素个数

len([1,2,3,4,5]) <==>[1,2,3,4,5].__len__()

a=[1,2,3,4,5]

a[3]<==>a.__getitem__(3)

a[0]=9 ##把9赋给a[0]

对应低层实现为

a.__setitem__(0,9)

第一个参数为index,第二个参数为value

特殊函数实现机理。

在python中函数本身也是对象。

obeject是一切类的父类。

在类A中实现特殊函数__call__,那么这个类的对象就是函数对象。声明类A的对象,本身是一个函数对象,赋给b,b就是函数对象。

函数对象可以作为参数传递给其他函数

>>map(b,[1,2,3,4,5,6])

依次作用每个元素

 

 

 

 

 

 

 

 

 

 

[展开全文]

__init__内容可以是空的。但一定要有,告诉python解释器,这是一个模块包,里面包含了很多模块。

rm -f *c##删除字节码文件

模块名.函数名 来调用函数。

在命令行中执行python时,下面表达式永远成立

if __name__=='__main__':

    test()

##test函数会得到执行,测试模块自身能否执行,完成对本模块的测试。

[root@alex]#python module_example.py

会执行,而进入python交互式环境,module_example.test()则不会执行。

 

 

 

 

 

 

 

[展开全文]

print sys.path ##查看所有路径

sys.path.append('需要添加的地址')

#只在当前交互式环境有效。

永久添加用 ,添加到profile里面

解释型语言,类似java,执行前编译为字节码文件,.pyc为字节码文件。

[展开全文]

anaconda=>python套件

模块:.py文件

 

cd ..\..  #切换到C盘根目录 

d:    #切换到D盘

[展开全文]

1.数据:对象属性的描述,一切可以被记录的

描述对象的过程就是将对象抽象为若干个可以度量的属性

量化的过程--数学建模

量化的属性--变量

2.数据的类型

是否有序,数值/类别,连续/离散

3.什么是模型

变量与变量之间的关系x,y

定量:线性模型中的系数

定性:找到合适的模型描述x,y的关系

[展开全文]