1.在机器学习中，为什么我们通常将处理的对象（样本）表示成向量？
便于数学运算
便于编程
可以使同一个算法能够处理不同的任务（对象）
2.一个模型中通常包含无限个函数
3.监督学习的四个步骤：
收集数据，选择模型，定义模型中函数的好坏，找到最好的函数（缺一不可）
在梯度下降法中，根据起点的不同，优化算法很可能只能找到误差的局部最小值。
4.判决树推荐APP
一般我们的判决树属于二叉树，如果一个有用的用户的特征为“白领工作人员”，“蓝领工作人员”，“无工作人员”，则用三叉分是最好的选择。
5.贝叶斯分类器处理垃圾邮件
（1）在朴素贝叶斯垃圾邮件分类器中，用“朴素”这个词，是因为假定不同符号的出现是条件独立的。
（2）在Paul Graham的方法中，不用0.5，而是用0.9来判断一封邮件是否属于垃圾邮件，是为了确保丢到垃圾箱的都是垃圾邮件。
（2）在Paul Graham的方法中，如果将判断是否是垃圾邮件的概率0.9改为0.98，则正常邮件丢到垃圾箱的可能性更小，垃圾邮件不会被丢到垃圾箱的可能性更大。
6.K-means
在k-means聚类中，数据是根据数据到聚类中心的距离打上标签的。
在整数除法中，除法 / 总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，可以使用运算符 // ：
注意：// 得到的并不一定是整数类型的数，它与分母分子的数据类型有关系。
>>> 7//2
3
>>> 7.0//2
3.0
fabs() 方法返回数字的绝对值，如math.fabs(-10) 返回10.0。
fabs() 函数类似于 abs() 函数，但是他有两点区别:
- abs() 是内置函数。 fabs() 函数在 math 模块中定义。
- fabs() 函数只对浮点型跟整型数值有效。 abs() 还可以运用在复数中。
count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
list.count(obj)
统计某个元素在列表中出现的次数
count()方法语法：
str.count(sub, start= 0,end=len(string))
注意与collections.counter对比
删除list中的数据：
del list[2]
remove对比
试一下
| for x in [1, 2, 3]: print(x, end=" ") |
结果：1 2 3 |
迭代 |
extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
extend()方法语法：
list.extend(seq)
注意：list.copy()和直接=赋值的区别：
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
有一句话不太明白
http://www.runoob.com/python3/python3-att-dictionary-copy.html
返回值：
返回一个字典的浅复制。
Dict.copy() 与 copy.copy(dict) 一样属于浅拷贝同理有list.copy()，python2中没有list.copy,看一下py2中有没有
http://www.runoob.com/w3cnote/python-understanding-dict-copy-shallow-or-deep.html
直接赋值，浅拷贝和深拷贝的解析
集合：
a = set('abracadabra')
b = set('alacazam')
print(a)
print(b)
感觉有点陌生
s.add(x) s.update(x)的区别
thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("facebook")
# add中elem不能是set，list等，只能是一个单一的元素
print(thisset)
thisset.update({1,3})
print(thisset)
thisset.update([1,4],[5,6])
print(thisset)
thisset.update("facebook")
print(thisset)
thisset.update({"facebooks"})
print(thisset)
创建一个set
三种方法都可以创建一个set？
a = set([9,4,5,2,6,7,1,8])
b = set((9,4,5,2,6,7,1,8))
c = {9,4,5,2,6,7,1,8}
1.创建一个含有一个元素的集合
>>> my_set = set(('apple',))
2.创建一个含有多个元素的集合
>>> my_set = set(('apple','pear','banana'))
3.如无必要，不要写成如下形式
>>> my_set = set('apple')
>>> my_set1 = set(('apple'))
删除set中的一个元素
s.discard( x ) 删除一个set中没有的元素，不会报错
s.remove( x ) 删除一个set中没有的元素，会报错
在python3 中试一下下面的程序
a, b = 0, 1
while b < 1000:
print(b, end=',') #关键字end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符
a, b = b, a+b
比较陌生：
count = 0
while count < 5:
print (count, " 小于 5")
count = count + 1
else:
print (count, " 大于或等于 5")
比较陌生for。。。else
sites1 = ["Baidu", "Google","Runoob","Taobao"]
sites = []
for site in sites:
if site == "Runoob":
print("菜鸟教程!")
break
print("循环数据 " + site)
else:
print("没有循环数据!")
print("完成循环!")
循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。
比如查找质数的例子
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(n, '等于', x, '*', n//x)
break
else:
# 循环中没有找到元素
print(n, ' 是质数')
没看明白：创建一个迭代器：http://www.runoob.com/python3/python3-iterator-generator.html
生成器
函数：
strings, tuples, 和 numbers 是不可更改(immutable)的对象，而 list,dict 等则是可以修改(mutable)的对象。
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
__name__属性，的用法，还有点不太理解
Pickle模块
下边的程序有点看不明白
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)
def __add__(self, other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2, 10)
v2 = Vector(5, -2)
#不太明白此操作过程
print (v1 + v2)
魔法函数，并不和某一个class挂钩，而是每个class都可以用的
Calss 和 def 都是可调用对象
鸭子类型和多态
class Cat(object):
def say(self):
print "I'm cat"
class Dog(object):
def say(self):
print "I'm dog"
def __getitem__(self, item):
return "boby"
class Duck(object):
def say(self):
print "I'm duck"
class Company():
def __init__(self, employee_list):
self.employee = employee_list
# getitem 使得Company实例可以迭代
def __getitem__(self, item):
return self.employee[item]
# anmial = Cat
# anmial().say()
# 多态继承
# animal_list = [Cat, Dog, Duck]
# for animal in animal_list:
# animal().say()
a = ["boby1", "boby2"]
# b = ["boby2", "boby1"]
# name_tuple = ["boby3", "boby4"]
# name_set = set()
# name_set.add("boby5")
# name_set.add("boby6")
company = Company([1,2,3])
a.extend(company) #extend(self, iterable)
print a
python中的抽象基类不能实例化
抽象基类不是很懂
# 检查某个类是否有某种方法
from collections.abc import Sized
class Company():
def __init__(self, employee_list):
self.employee = employee_list
# getitem 使得Company实例可以迭代
def __len__(self):
return len(self.employee)
com = Company(["boby1", "boby2"])
print hasattr(com, "__len__")
isinstance(com, Sized)
print len(com)
collections 中的abc 与全局的abc 有什么区别
使用isinstance来判断类型
class A:
pass
class B(A):
pass
b = B()
# 尽量使用isinstance 来判断类型
print isinstance(b, B)
print isinstance(b, A)
# "=" and is
print type(b) == B #判断值是否相等
print type(b) is A #判断id是否相同
print type(b) is B
# 类变量和实例变量
class A:
aa=1 #类变量
def __init__(self, x, y):
self.x = x #self表示实例
self.y = y
a = A(2,3)
A.aa=11 #修改类变量
a.aa =100 #在对象上新建一个变量
print a.x, a.y, a.aa #从下往上查找
print A.aa
# print A.x #x是绑定到实例上的
b = A(3,5)
print b.aa
比较陌生for。。。else
sites1 = ["Baidu", "Google","Runoob","Taobao"]
sites = []
for site in sites:
if site == "Runoob":
print("菜鸟教程!")
break
print("循环数据 " + site)
else:
print("没有循环数据!")
print("完成循环!")
循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行,但循环被break终止时不执行。
比如查找质数的例子
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(n, '等于', x, '*', n//x)
break
else:
# 循环中没有找到元素
print(n, ' 是质数')
没看明白：创建一个迭代器：http://www.runoob.com/python3/python3-iterator-generator.html
生成器
函数：
strings, tuples, 和 numbers 是不可更改(immutable)的对象，而 list,dict 等则是可以修改(mutable)的对象。
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
__name__属性，的用法，还有点不太理解
Pickle模块
下边的程序有点看不明白
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)
def __add__(self, other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2, 10)
v2 = Vector(5, -2)
#不太明白此操作过程
print (v1 + v2)
魔法函数，并不和某一个class挂钩，而是每个class都可以用的
Calss 和 def 都是可调用对象
鸭子类型和多态
class Cat(object):
def say(self):
print "I'm cat"
class Dog(object):
def say(self):
print "I'm dog"
def __getitem__(self, item):
return "boby"
class Duck(object):
def say(self):
print "I'm duck"
class Company():
def __init__(self, employee_list):
self.employee = employee_list
# getitem 使得Company实例可以迭代
def __getitem__(self, item):
return self.employee[item]
# anmial = Cat
# anmial().say()
# 多态继承
# animal_list = [Cat, Dog, Duck]
# for animal in animal_list:
# animal().say()
a = ["boby1", "boby2"]
# b = ["boby2", "boby1"]
# name_tuple = ["boby3", "boby4"]
# name_set = set()
# name_set.add("boby5")
# name_set.add("boby6")
company = Company([1,2,3])
a.extend(company) #extend(self, iterable)
print a
python中的抽象基类不能实例化
抽象基类不是很懂
# 检查某个类是否有某种方法
from collections.abc import Sized
class Company():
def __init__(self, employee_list):
self.employee = employee_list
# getitem 使得Company实例可以迭代
def __len__(self):
return len(self.employee)
com = Company(["boby1", "boby2"])
print hasattr(com, "__len__")
isinstance(com, Sized)
print len(com)
collections 中的abc 与全局的abc 有什么区别
使用isinstance来判断类型
class A:
pass
class B(A):
pass
b = B()
# 尽量使用isinstance 来判断类型
print isinstance(b, B)
print isinstance(b, A)
# "=" and is
print type(b) == B #判断值是否相等
print type(b) is A #判断id是否相同
print type(b) is B
# 类变量和实例变量
# 类和实例属性的查找顺序
class D:
pass
class C(D):
pass
class B(D):
pass
class A(B,C):
pass
print A.__mro__
静态方法：@staticmethod
类方法：@classmethod
class Date:
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day
def tommorrow(self):
self.day += 1
#静态方法
@staticmethod
def parse(data_str):
# data_str = "2019-07-31"
year, month, day = tuple(data_str.split("-"))
return Date(int(year), int(month), int(day))
#类方法，静态方法与类方法的区别
@classmethod
def form_string(cls, data_str):
year, month, day = tuple(data_str.split("-"))
return cls(int(year), int(month), int(day))
def __str__(self):
return "{year}/{month}/{day}".format(year = self.year, month = self.month, day = self.day)
class User:
def __init__(self, birthday):
self.__birthday = birthday # 私有属性,外部不能获取，子类也不能获取，只能通过公共的方法来访问
def get_age(self):
return 2018 - self.__birthday.year
if __name__ == "__main__":
data = Date(2019,8, 31)
print data
data.tommorrow()
print data
data_str = "2019-07-31"
# year, month, day = tuple(data_str.split("-"))
data1 = Date.parse(data_str)
print data1
data2 = Date.form_string(data_str)
print data2
user = User(Date(1990, 2, 1))
print user._User__birthday
print user.get_age()
Python的自省机制
# 自省是通过一定的机制查询到对象的内部结构
class Person:
'''
ren
'''
name="user"
class Student(Person):
def __init__(self, school_name):
self.school_name = school_name
if __name__ == "__main__":
user = Student(u"慕课网")
#通过__dict__ 查询属性
print user.__dict__
user.__dict__["school_addr"] = "bj"
print user.school_addr
print user.name
print user.school_name
print dir(user) # 功能发、更强大，列出的更全
print user.__dict__
print Person.__dict__
#supper 的执行顺序同__mro__的执行顺序，而不是单纯的调用父类
- 两数之和
class Solution(object):
def twoSum(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: List[int]
"""
map = {}
res = []
for i in range(len(nums)):
complement = target - nums[i]
if complement in map.keys():
res.extend([map[complement], i])
return res
map[nums[i]] = i
if __name__ == "__main__":
# nums = input()
# target = input()
nums = [2, 7, 11, 15]
target = 26
so = Solution()
print so.twoSum(nums, target)
# 387. 字符串中的第一个唯一字符
class Solution(object):
def firstUniqChar(self, s):
"""
:type s: str
:rtype: int
"""
freq = [0]*26
for c in s:
freq[ord(c)-ord('a')] += 1
for i in range(len(s)):
if freq[ord(s[i])-ord('a')] == 1:
return i
return -1
if __name__ == "__main__":
s = input().strip()
so = Solution()
print so.firstUniqChar(s)
#加括号
