ChaseDream

标题: 打基础~ [打印本页]
作者: 珍妮王小钰    时间: 2019-2-6 03:16
标题: 打基础~
78 tongji
85 概率

87 python：
SAS有online tutorial可以高效自学，SQL有SQLZOO可以练手https://www.1point3acres.com/bbs/thread-138105-1-1.htmlDA要求的Python和CS的不太一样。要用熟Pandas, Numpy，Matplotlib, SciKit-Learn这几个包
正在上edX的6001网课，讲算法的，用的Python，针对的是python和CS零基础的，很多练习和作业，感觉设计的特别好，听了一个月下来，感觉进步很大。
https://zhuanlan.zhihu.com/p/24546514

Udacity上的CS101. 里边内容都是用Python教的。没一个知识点都紧跟着Python coding练习。我学下来感觉还是非常好的。如果有一定基础可以看看Learn Python the hard way。里边的code example我觉得还是非常好的！





建议R的学习者查看DataCamp上的练习和教程。
对于Python学习者的建议是，尝试用《笨办法学Python》学习的同时看视频做练习。建议初学者查看Rodeo（被称为“Python到数据科学IDE”）。
Python入门的话推荐edx上MIT的那门6001x，打基础不错。


edX MIT 6001x and 60002xhttps://www.edx.org/course/introduction-to-computer-science-and-programming-using-python-0
https://www.edx.org/course/introduction-to-computational-thinking-and-data-science-2

作者: 珍妮王小钰    时间: 2019-2-7 07:17
ML:Multinomial distribution Classification
• What is mood of person in current minute? M={Happy, Sad}• Measure his/her actions every ten seconds: A={Cry, Jump, Laugh, Yell}
Data (D): {LLJLCY, JJLYJL, CCLLLJ,JJJJJJ}Bias (??): Probability table

LLJLCY： happy? .5X.5X.3X.5X.1=  sad?:

10分:  
beta分布介绍

相信大家学过统计学的都对 正态分布 二项分布 均匀分布 等等很熟悉了，但是却鲜少有人去介绍beta分布的。

用一句话来说，beta分布可以看作一个概率的概率分布，当你不知道一个东西的具体概率是多少时，它可以给出了所有概率出现的可能性大小。

简单的解释：

https://www.cnblogs.com/shixisheng/p/7197623.html?utm_source=itdadao&utm_medium=referral

MAP /MLE:

极大似然假设与贝叶斯估计的区别：
最大似然估计只考虑某个模型能产生某个给定观察序列的概率。而未考虑该模型本身的概率。这点与贝叶斯估计区别。
Map与ML的区别：
最大后验估计是根据经验数据获得对难以观察的量的点估计。与最大似然估计类似，但是最大的不同时，最大后验估计的融入了要估计量的先验分布在其中。故最大后验估计可以看做规则化的最大似然估计。
极大后验MAP什么时候等于极大似然ML
不知道关于假设的任何概率，所有的hi假设拥有相同的概率，then MAP is Maximum Likelihood (hML极大似然假设），如果数据量足够大，最大后验概率和最大似然估计趋向于一致。
Map和朴素贝叶斯有什么关系
If independent attribute condition is satisfied, then vMAP = vNB 如果独立的属性条件是满足的vmap=vNB

、请描述极大似然估计 MLE 和最大后验估计 MAP 之间的区别。请解释为什么 MLE 比 MAP更容易过拟合。
MLE：取似然函数最大时的参数值为该参数的估计值，ymle=argmax[p(x|y)]；MAP：取后验函数（似然与先验之积）最大时的参数值为该参数的估计值，ymap=argmax[p(x|y)p(y)]。因为MLE 只考虑训练数据拟合程度没有考虑先验知识，把错误点也加入模型中，导致过拟合。




作者: 珍妮王小钰    时间: 2019-2-7 08:29

即使学过机器学习的人，对机器学习中的MLE(极大似然估计)、MAP(最大后验估计)以及贝叶斯估计(Bayesian)仍有可能一知半解。对于一个基础模型，通常都可以从这三个角度去建模，比如对于逻辑回归（logistics Regression）来说：

MLE: logistics Regression

MAP: Regularized Logistics Regression

Bayesian: Bayesian Logistic Regression#

-----------------------------

multiple multi-variate probabli:

# acts=4  tunes=5 weather=7

how many??:

# prob  entries= 4x5x7=140

# params= (of classes)2x139(likeli 1 class)+ (2-1)prior=279

features: acts , tunes ,weahter

#params= classesx Πi（values featuresj)-1


params to estimate likelihood: 2x(4-1)+2X(5-1)+2X(7-1)

                                                #classnumber#actvals  tunes  weather

benefit of naive bayes: very fast learning and classifying.



作者: 珍妮王小钰    时间: 2019-2-11 13:14
87:数据类型~~

往下：shift+tab 执行
不动：ctrl+回车。

type(1.2-1): float(int,,,)  7%2 1  10%2 0
type("q") str                 ('a')  ("hello'qin'...")  里面有‘ “用 三 引号”””。。。。“”“里面可换行噢。
print("\”\b”)
=””b

int("1")+1
2

bool:
type(TRue):
1<2+1
true
(1<2)+1:
1

变量：

tip: a,b=1,2赋值
for 循环
a+=1
a=a+1(计算逻辑是等号的右边先计算）（1+1=2被重新赋值到a)



PYthon 三大数据结构。
作者: 珍妮王小钰    时间: 2019-2-12 00:33
列表 增删查改(索引[],Append\)
list=

num=[1,2,3]
num
out: [1,2,3]
sum(num)
out:6
len(num)
out:3(个组合的集合

slice #查
num[0]
out:1
num[2]=num[len(num)-1]
out:3
num[-1]倒数第一个
num[-2]倒数第二个（2）
num[0:1]
num[0:2]
output：[1,2]
num[0:3]
output：[1,2,3]

num[0:]
[1,2,3]
num[1:]
[2,3]

num[:2]
[1,2]

num[-2:]
[2,3]

slice求和： num[0]+num[1]

#shift+tab : L.insert(index,object)
增#插入的索引位置，插入的值
num insert()
num.insert(1,4)
num
[1,4,2,3]
num.insert(4,5)不如 num.append(6)好
.append()尾巴只能一个，而这样可以多个: num+[8,9]

删：num.pop(1)
num
out:
num.pop()默认删除最后一个

改：
num[3]=4(把位置的东东改）num[4]=5

二维：
b=[[1,2],[3,4]]
--------------
name=['','','']
sex=['','','']
age=[12,14,15]
#嵌套：
info=[name,sex,age]
info
out:[['','',''],[],[]]
info[0][1]# name里面的第一个'XX'

row=[0]*3
row
out:[0,0,0]
[row]*4
put:[[0,0,0],[0,0,0],[0,0,0],[0,0,0]]
列表

list.append(var)  #列表尾添加
list.insert(index,var)        #列表插入
list.extend(list1)        #列表连接

list.remove(var)        #删除var
list.pop(var)                #删除最后一个

list.count(var)                #计算个数

list.index(var)                #找到第一个就返回索引

list.sort()                #排序，assic首字母来排序
list.reverse()                #倒序






作者: 珍妮王小钰    时间: 2019-2-12 14:20
#set集合化(&)去重功能      a=[1,2,3,3,4]

      set(a)
       out:{1,2,3,4}
------------------
#这样可以索引
       list(set(a))[1] )
#&交集，|并集

&   |
     set(a)&set(b)
     out:{2,3}
      set(a)|set(b)
     out: {1，2，3，4}
#差集
set(a) -set(b)
out1)
set(b) -set(a)
out：(4)
[1,2]>a out: false
--------------------------------------
字典：
a={'name':'yangxi','age':18}
a.keys()
out:dict_keys(['name', 'age'])
但： a.keys()[]会报错
list(a.keys())
out:['name', 'age']
list(a.values())


Out[7]:['yangxi', 18]
------------------
a.items()


Out[9]:
dict_items([('name', 'yangxi'), ('age', 18)])list(a.items())out:[('name', 'yangxi'), ('age', 18)]# 元组不可修改list(a.items())[0][1]out:'yangxi'list(a.items())[0]out'name', 'yangxi')list(a.items())[0][1]out:'yangxi'a.get('nam',1)获取！单纯查找out1


1











a.get('name',1)















out: 'yangxi'



a.setdefault('sex','female')查找后给赋值
'female'aout；{'name': 'yangxi', 'age': 18, 'sex': 'female'}字典 set{a}$set{b}字典d.get(key,0)  #同d[key]d.has_key(key)        #有该键值返回true,否则falsed.keys()        #返回字典键值列表d.values()        #列表的形式返回字典的值，返回时候无顺序d.update(dict2)                #增加合并字典d.setdefault('stuid',1123)d.pop(key)d.popitem()                #得到一个pair,并从字典中删除它，已空则抛出异常d.clear()         #清空字典，同del dictd.copy()        #拷贝字典d.cmp(dict1,dict2)        #比较字典，（优先级为元素个数，键大小，键值大小）第一个大返回1，小-1，一样0d.items()   #变成列表，每个元素为一个元组








作者: 珍妮王小钰    时间: 2019-2-12 15:02
a=10
if a >10:
  print('more than 10')
elif a==10:
  print('equal to 10')
else :
  print('less than 10')
作者: 珍妮王小钰    时间: 2019-2-19 01:37
a=10
if a >10:
  print('more than 10')
elif a==10:
  print('equal to 10')
else :
  print('less than 10')---------------------------
a=10
if a >10:
  print('more than 10')
elif a>8:
  print('more than 8')
elif a>6 :
  print('more than 6')
out: more than 8.
--------------------------------------
if a>10:
    print('more than 10')
    if a%2==0:
        print('ou')
    else:
        print('no')
else:
    print('less than 10')


count=0
while count<10:
    print('the num is:',count)
    count=count+1#输出然后累加

--->out:
the num is: 0the num is: 1the num is: 2the num is: 3the num is: 4the num is: 5the num is: 6the num is: 7the num is: 8the num is: 9
count=0while count<10:
   count=count+1   
   print('the num is:',count)
--->out:
the num is: 1the num is: 2the num is: 3the num is: 4the num is: 5the num is: 6the num is: 7the num is: 8the num is: 9the num is: 10

冒号： 是属于block控制模块下面的。

count=0while count<10:
   count=count+1   
   print('the num is:',count)
   if count==5:
    空格break
--->out:
the num is: 1the num is: 2the num is: 3the num is: 4the num is: 5

count=0
while count<10:
   count=count+1   
   print('the num is:',count)
   if count==5:continue



the num is: 1the num is: 2the num is: 3the num is: 4the num is: 5the num is: 6the num is: 7the num is: 8the num is: 9the num is: 10




Break是粗暴的终止，而continue是过滤掉中间一步
count=0
while count<10:
   count=count+1   
   if count==5:
        continue（5时候跳过了执行下面）
   print('the num is:',count)
--->out:

the num is: 1the num is: 2the num is: 3the num is: 4the num is: 6the num is: 7the num is: 8the num is: 9the num is: 10


while里面:count=count+1/2 按1，2 累加
for i in range(1,10):
    print(i)
123456789






作者: 珍妮王小钰    时间: 2019-2-19 23:34
for i in range(10):
    print(i)
0123456789

for i in range(1,10):
    print(i)
123456789

for i in range(5,10):    print(i)56789


shift + tab ~~~~~~~~~~~~~~~range(start,stop[, step])

for i in range(5,20,2):
  空格print (i)

5791113151719

a=1for i in range(10):    a=a+i    print(a)1247111622293746
列表循环!a=['a','b','c']for i in a:      print(i)abca[0],a[1],a[2]-->out: ('a', 'b', 'c')进阶：拼接a=['a','b','c']b='str:'for i in a:      print(b,i)
字典循环!dict={'a':1,'b':3,'c':'abc'}dict.keys()-->out: dict_keys(['a', 'b', 'c'])dict.values()-->out: dict_values([1, 3, 'abc'])for k in dict.keys():    print(k)
abcfor k in dict.values():    print(k)
13abc
for k in dict.items():    print(k)
('a', 1)('b', 3)('c', 'abc')
for k in dict.items():    print(k[0])元组的第一个元素abc
for k in dict.items():    print(k[1])元组的第二个元素13abc------------dict.items()out:dict_items([('a', 1), ('b', 3), ('c', 'abc')])
改进~~for 在python 是多值循环。for k,v  in dict.items():    print(k)    print(v)out:a1b3cabc再改进~~for k,v  in dict.items():    print(k,v)out：a 1b 3c abc










作者: 珍妮王小钰    时间: 2019-2-19 23:58
list=[]
for i in range(1,101):
    list.append(i)


改进版！！
list=[i for i in range(1,101)]
list
--------
list=[]
for i in range(1,101):
    if i%2== 0:

空格！！list.append(i)
list
------------
list=[i for i in range(1,101)if i%2==0]
list
out：[2,
4, 6, 8,，，，100]list=[i**2 for i in range(1,101)if i%2==0]----------------------------------------------list=['str'+str(i) for i in range(1,101)if i%2==0]list'str2', 'str4', 'str6', 'str8', 'str10', 'str12', 'str14', 'str16', 'str18',,,'str100'list=['str'+str(i) for i in range(1,101)if (i%2==0)&(i%3==0)]
['str6', 'str12', 'str18', 'str24', 'str30',,,,
作者: 珍妮王小钰    时间: 2019-3-4 13:28
python 变量：
1.python不用事先声明变量，赋值过程中就包含了变量声明和定义过程。
2. 用‘=’赋值，左边是变量名，右边是变量的值。


List []有序的可变（可以修改）集合的容器。
左开右闭：
【0】第一个
【2：5】
【2：】三个开始

元组（）
不可变的列表。

字典{}
key- value的集合，无序的容器

print dict_a.keys()
print dict_a.values()

print dict_a.items()


运算符：
+=
-=
*=
/=
%=
**=
//=
----------------------------------------------------------
python  语句：
if
elif a==2:
print "a==2"
else:
print "a !=1 and a!=2"

for 用来遍历容器，或者执行重复性的代码。
遍历容器

list_a= [1,2,"test'"]
for i in list_a:
   print i
运行结果
1
2
test

执行重复性代码
for i in range(0,10):
   print i
运行结果
0
1
2
....
9

while
a=1
while a!=10:
   print a
   a+=1


for a in range(1,10):
  print a

break 语句：
list_a= [1,2,"test'"]
for i in list_a:
   print i

   if i ==2:
     break
从2跳出循环。
#[0,10]
但不能跳出多个循环：
for i in range(0,10):
    print i
for i in range(0,10):
    for j in range(0,10)
        print i,j
        if j==5：
           break

continue 直接进行下一次循环。(break是直接跳出整个循环;continue会走下一个循环）

list_a= [1,2,"test'"]
for i in list_a:
   print i

   if i ==2:
      continue

   print"~~~~"








作者: 珍妮王小钰    时间: 2019-3-5 05:55
数据结构：
List:
python 内置的一种数据结构；有序；可更改（添加，删除）
声明
game=['dota','dota','lol']
game
['dota','dota','lol']

获取列表长度：
1 len(game)
2 3
获取元素：
game[0]
'dota'
game[2]
'lol'

增删查改

增加元素
末尾追加
game.append('wow')
game[3]
'wow'
game
['dota','dota','lol','wow']

删除元素
删除末尾的元素
game.pop()  
不写就默认删除最后一个。
‘wow'
game
['dota','dota','lol']
改元素
game[0]='dota2'
game
['dota2','dota','lol']

tuple:
python 内置的一种数据结构；有序；不可更改（安全）；在赋值的时候决定所有元素


声明
game=（'dota','war3','lol'）
game
（'dota','war3','lol'）
声明完后不用更改，安全
获取列表长度：
len(game)
  3

获取元素：
game[0]
'dota'
game[2]
'lol'



dict:
python内置的一种数据结构；无序；可更改
类似于C++语言的map,存键值对，有很快的查找速度。比如根据身份证号查找某个热难道名字，根据学号查找学生成绩单。用List遍历也可以得到结果，但是太慢了，list就好像你在小区找人，一家家敲门。dict就好像你直接按照地址找。
dict用空间换时间，占内存大，但查找插入速度很快不会随着元素数量增加而增加。list是时间换空间的例子。不会占用大量内存，但随着元素数量增加，查找时间会变很长。
声明
name={1:'alan', 2:'bob', 3:'lucy'}
查找
name[1]
'alan'
name[2]
'bob'
为了避免出现报错情况我们一般要事先判断一下这个key是否在dict里面:
5 in name
false.
2 in name
true
也可以用get方法取，如果key不存在，会返回None或者自己定义的默认值。
name.get(5)
name.get(5,'default')
"default"没找到
增加
name[5]='sam"
name
{1:'alan', 2:'bob', 3:'lucy',5:'sam'}
删除
name.pop(1)
’alan'
name
{ 2:'bob', 3:'lucy'}
name.pop(5)
‘sam'
name
{1:'alan', 2:'bob', 3:'lucy'}
len（name)
3(三个键值对）
name.key()
[1,2,3]
name.values()
['alan', 'bob','lucy]
name.items()
[(1,'alan'),(2,"bob'），（3，“lucy')]












作者: 珍妮王小钰    时间: 2019-3-6 05:52
set:
python内置数据结构；无序；可更改
set可以视为没有value的dict,只存key,一般用做去重或者集合求交，求并等。
声明
girls_1=set(['lucy','lily'])
girls_2=set(['lily','anna'])           
求并，交
girls_1&girls_2
set(["lily'])
girls_1|girls_2      
set(['lily','lucy','anna']
增加元素
girls_1.add('marry')
girls_1
set(['marry','lily','lucy'])
删除元素
girls_1.remove('lucy']
girls_1
set(['marry','lily'])

python 函数
函数是可重复调用的代码短，能提高代码的复用率。
定义格式
#无参数
def print_hello():
    print"hello"
print_hello()--hello
#带参数
def print_str(s)
print s
return s*2
print_str("fuck")
--fuckfuck

#带默认参数
def print_default(s='hello'):
   print s
print_default()
print_default("default")
-hello
-default
#不定长参数
def print_args(s,*arg):
  print s
  for a in arg:
     print a
return

print_args("hello")
print_args("hello","world","1")
*"world","1" 存放在arg里。
-hello
-hello
world
1

#参数次序可以变
def print_two(a,b):
   print a,b

print_two(a="a", b="b")
print_two(b="b",a ="a"
a b
a b


















作者: 珍妮王小钰    时间: 2019-3-17 07:20
标题: SDE打基础~
https://www.zhihu.com/question/57449577 笨办法才是好方法。每个代码敲三遍，第一步抄；第二遍保留框架 注释自己默写，第三从头到尾白板一遍。 |把学到的整理成博客。
https://zhuanlan.zhihu.com/gaihangcs 改行CS
G: 基本功，综合能力（灵活）


eX: 一个笔记本电脑4g  1TB data， 怎么找到所有的数据？？给你一万台1g XXXdata（用mapreduce 找到data所有pair）算法+系统设计。 考problem solving的能力。two sum: 30~35 女生，口红裙子 找ID

---------------------------------
part 1 系统CS理论知识
part2 扎实的一线公司coding skills
part3 工业界项目-> Outstanding Resume
         New: 第四个月，三个工业界大项目
part4. 面试软实力
part5. Referral +职业发展 平台。

作者: 珍妮王小钰    时间: 2019-3-18 03:47
简介
面向对象是我们经常能听到的术语，即class，类。事实上，主角是两个，一个是类，一个是类实例。人类，是一个类，我们每一个人是一个人类的实例。而类之间又有一些关系，例如，我们既是人类，也是动物，更细化来讲，我们是哺乳类动物，灵长类，类似于集合的概念，哺乳动物属于动物，而在面向对象中我们通常称哺乳动物是动物的子类。而对于动物这个类来说，会自带一些属性，例如：年龄、体重。也会有一些方法：生殖、呼吸。而不同种类的动物（即动物类的各种子类）可能会有不同的属性或方法，像胎生、卵生，像鸟类的飞行的方法和豹子奔跑的方法。
定义
用关键字class去定义一个类，如果没有指定父类，默认继承object类。
这样，我们定义个了一个Human，人类。
类属性
为什么要叫类属性呢，因为这个属性是和类绑定的，并不是和实例绑定的。胎生这个属性是全人类共有的，并不是某个人特殊拥有的属性。
实例属性
我们首先实例化了一个人类human_a，然后给这个人类设置了一个实例属性name，name这个属性独立于其他的人类，是和实例绑定的，所以叫实例属性。#实例属性是针对某个实例的。 例属性可以在实例创建后任意时间设置。
类方法
运行结果：
类的方法可以看做是一种类属性，而传入的第一个参数self，表示调用这个类方法的实例。像上面的例子，human_a调用了walk这个类方法，human_a的名字是alan，所以运行的结果就是alan is walking。
访问控制
从上面的例子来看，我们可以在外部随意更改name这个属性，如果不想让外部直接访问到，则在属性名字前加两个下划线__name，这样从外部就无法直接访问了。如果还是想访问，可以再加个get的接口。
如果还是想更改__name字段，可以再加上一个set接口
可能有人会有疑问，为何要这么“画蛇添足”呢？其不然，这样会增强代码的健壮性，直接暴漏属性可能会带来意想不到的后果，通过接口的方式可以加以控制，例如，我们可以通过set接口去限定name的长度。
这样就不会出现name过长的情况。
继承
最开始的简介里说到，哺乳动物是动物的一种，用面向对象的属于来说，哺乳动物是动物的子类，子类拥有父类的属性、方法，即继承。同时又可以拥有父类没有的属性和方法，即多态。
还是以人类为例，通常来说，人类又可以分为男人和女人（当然也有别的，23333）
来，我们看下这个男人，多了一个新的属性，__has_wife(是否已婚)。我们写到了Man的构造函数里。其实通常并不这么写构造函数，假如Human里有很多属性、很多初始化步骤，我们Man继承的时候难不成要复制粘贴一遍Human的构造函数？当然不是啦，通常会这么写。
super(Man, self).__init__(name)等价于调用了父类Human的构造函数，就不用再复制粘贴一遍了。
既然有男人，那就再来个女人吧。
我们都道，男人和女人是不一样的，通常男人都自带抽烟、喝酒、烫头，啊。。。并没有烫头。
当然，女人也自带逛街、化妆等天赋技能。
好了，观众朋友们，有没有感觉到这种继承的优越性。可以很清晰地看到，男人和女人都有一些相同的属性，也有一些各自不同的方法。如果哪天人类有了别的方法、属性，直接在Human类更改，男人和女人也会自动继承。如果想再设计一个双性人这个类，那直接从Human继承就可以了，对男人和女人不会有任何影响。这就是面向对象的优越性啊！

作者: 珍妮王小钰    时间: 2019-3-28 07:30
del del(x[1])

The ; sign is used to place commands on the same line.
# Same line
command1; command2


# Separate lines
command1
command2

although you've changed areas_copy, the change also takes effect in the areas list. That's because areas and areas_copy point to the same list.If you want to prevent changes in areas_copy from also taking effect in areas, you'll have to do a more explicit copy of the areas list. You can do this with list() or by using [:]# Create list areas
areas = [11.25, 18.0, 20.0, 10.75, 9.50]

# Create areas_copy
areas_copy = list(areas)

# Change areas_copy
areas_copy[0] = 5.0

# Print areas
print(areas)

作者: 珍妮王小钰    时间: 2019-3-29 02:16
# string to experiment with: place
place = "poolhouse"

# Use upper() on place: place_up
place_up = place.upper()

# Print out place and place_up
print(place)
print(place_up)

# Print out the number of o's in place
print(place.count('o'))





欢迎光临 ChaseDream (https://forum.chasedream.com/) Powered by Discuz! X3.3