使用and or 返回函数结果

>>> 3 and 2
2
>>> 3 or 2
3

空值

空值是Python里一个特殊的值，用None表示

字符编码问题

https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431664106267f12e9bef7ee14cf6a8776a479bdec9b9000
搞清楚了ASCII、Unicode和UTF-8的关系

数据类型

屏幕快照 2018-06-12 下午3.05.41.png 屏幕快照 2018-06-13 下午7.20.17.png

关键参数 位置参数

屏幕快照 2018-06-12 下午3.31.52.png

sum(iterable, start=0, /)

list()接受字符串后，字符串会被自动 拆分 @匪夷所思

list是个工厂方法的工具类

>>> list(1,2,4,5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: list() takes at most 1 argument (4 given)
>>> list('1234')
['1', '2', '3', '4']

列表推导式

屏幕快照 2018-06-12 下午5.11.55.png

>>> list(i**2 for i in range(5))
[0, 1, 4, 9, 16]
>>> list(2**i for i in range(5))
[1, 2, 4, 8, 16]
>>> sum(2**i for i in range(5))
31
>>> sum(map(lambda x:2**x ,range(5)))
31
>>> list(map(lambda x:2**x ,range(5)))
[1, 2, 4, 8, 16]

>>> vec = [[1,3],[4,6],[7,9]]
[[1, 3], [4, 6], [7, 9]]
>>> list(num for item in vec for num in item)
[1, 3, 4, 6, 7, 9]


>>> list([x+y for x in range(5) ]for y in range(2))
[[0, 1, 2, 3, 4], [1, 2, 3, 4, 5]]
>>> list(x+y for x in range(5) for y in range(2))
[0, 1, 1, 2, 2, 3, 3, 4, 4, 5]
>>> list(y for x in range(5) for y in range(x))
[0, 0, 1, 0, 1, 2, 0, 1, 2, 3]

屏幕快照 2018-06-12 下午6.17.53.png 推导式的嵌套执行顺序，无中括号情况下是从左到右代表由外到内，有中括号情况下，代表括号的在内，

切片

屏幕快照 2018-06-13 下午7.14.59.png

元组

集合

字典

序列解包

屏幕快照 2018-06-13 下午9.18.07.png

函数

函数的嵌套定义、可调用对象、修饰器

闭包

函数对象成员的动态性

参数 位置参数 默认值参数 关键参数

关键参数 要看下记忆能力对应的代码是 一个 类内部的静态变量么？

屏幕快照 2018-06-14 下午6.08.28.png

标注函数参数和返回值类型

屏幕快照 2018-06-14 下午7.35.48.png

变量作用域

全局变量，局部变量。
在函数内修改全局变量时，必须要先在函数内声明global，否则Python就处理为同名局部变量。

nonlocal变量

lambda表达式

屏幕快照 2018-06-14 下午7.57.14.png

lambda

列表生成器 和 迭代器 有什么不同？

generator

屏幕快照 2018-06-19 下午5.28.09.png

yield 生成器

https://liam0205.me/2017/06/30/understanding-yield-in-python/
https://www.jianshu.com/p/d09778f4e055

第一个next() 从生成器第一行代码运行到，遇到yield 并返回 yield后的数值并暂停！！
第二个next() 从上一次暂停的地方开始，yield返回永远是 None（如果用send()则可以修改返回值） ,继续运行，并遇到下一个yield！！

def func():
    x = 1
    while True:
        y = (yield x)
        x += y

geniter = func()
geniter.next()  # 1
geniter.send(3) # 4
geniter.send(10)# 14

>>> def f123():
...     print("emit 0")
...     yield 1
...     print("emit 1")
...     yield 2
...     print("emit 2")
... 
>>> for x in f123():
...     print(x)
...     print(10*'-')
... 
emit 0
1
----------
emit 1
2
----------
emit 2

>>> def f12():
...     a = (yield 1)
...     print(a)
...     b = (yield 2)
...     print(b)
... 
>>> 
>>> a = f12()
>>> a.__next__()
1
>>> a.__next__()
None
2
>>> a.__next__()
None


>>> a = f12()
>>> a.__next__()
1
>>> a.send(111)
111
2

偏函数

函数柯里化

https://segmentfault.com/a/1190000008263193
柯里化通常也称部分求值，其含义是给函数分步传递参数，每次传递参数后,部分应用参数，并返回一个更具体的函数接受剩下的参数，中间可嵌套多层这样的接受部分参数函数，逐步缩小函数的适用范围，逐步求解,直至返回最后结果。

with的作用

http://linbo.github.io/2013/01/08/python-with

面向对象

修饰符

屏幕快照 2018-06-15 上午11.50.50.png

动态的特性 实例属性 和 类属性的不同

可以动态的为实例新增 属性或者方法。

从上面的例子可以看出，在编写程序的时候，千万不要对实例属性和类属性使用相同的名字，因为相同名称的实例属性将屏蔽掉类属性，但是当你删除实例属性后，再使用相同的名称，访问到的将是类属性。

>>> class Student(object):
...     name = 'Student'
...
>>> s = Student() # 创建实例s
>>> print(s.name) # 打印name属性，因为实例并没有name属性，所以会继续查找class的name属性
Student
>>> print(Student.name) # 打印类的name属性
Student
>>> s.name = 'Michael' # 给实例绑定name属性
>>> print(s.name) # 由于实例属性优先级比类属性高，因此，它会屏蔽掉类的name属性
Michael
>>> print(Student.name) # 但是类属性并未消失，用Student.name仍然可以访问
Student
>>> del s.name # 如果删除实例的name属性
>>> print(s.name) # 再次调用s.name，由于实例的name属性没有找到，类的name属性就显示出来了
Student

实例属性属于各个实例所有，互不干扰；
类属性属于类所有，所有实例共享一个属性； 相当于 该类的静态变量
不要对实例属性和类属性使用相同的名字，否则将产生难以发现的错误。

对参数值校验使用 @property 注解

 def width(self,value):
  self._width = value # 注意是  _width 带有 『_』，否则存在死循环


class Screen(object):
 @property 
 def width(self):
  self._width
 
 @width.setter
 def width(self,value):
  if value>100 : value = 100
  self._width = value

 @property 
 def height(self):
  self._height
 
 @height.setter
 def height(self,value):
  if value > 100 : value = 100
  self._height = value

 @property
 def resolution(self):
  return self._height * self._width

class内置函数

闭包 变量作用域解释

http://www.cnblogs.com/xiaohuochai/p/5731641.html

迭代

如何判断一个对象是可迭代对象呢？方法是通过collections模块的Iterable类型判断：

>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

如果要对list实现类似Java那样的下标循环怎么办？Python内置的enumerate函数可以把一个list变成索引-元素对

装饰器

相当于AOP

偏函数

当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。

疑问

函数有哪些入参？可以只传入部分入参? 还有关键参数、位置参数
列表和元组和集合有什么不一样？

方式四 针对矩阵内每个元素判断赋值

np.where(a > 0, a, 0)
array([[0, 0, 0, 2, 1],
[0, 0, 0, 3, 3],
[0, 0, 3, 0, 3],
[0, 0, 0, 1, 0],
[0, 3, 1, 3, 0]])

arange

DE = np.array([[1,2],[3,4]])
print (str(type(DE)) + "  " +  str(DE.shape))

DE = np.arange(0,5)
print (str(type(DE)) + "  " +  str(DE.shape))

# range的话返回一个list

<class 'numpy.ndarray'>  (2, 2)
<class 'numpy.ndarray'>  (5,)

https://jingyan.baidu.com/article/e6c8503c1e89d6e54f1a188c.html

ravel 和 flatten 区别

关于降低维度的方式

DE = np.array([[1,2],[3,4]])
print (str(type(DE)) + "  " +  str(DE.shape))

#深Copy
print(DE.flatten())

#浅Copy
print(DE.ravel())

NDE = DE.ravel()
NDE[0] = 100
print (DE)
print (NDE)

<class 'numpy.ndarray'>  (2, 2)
[1 2 3 4]
[1 2 3 4]
[[100   2]
 [  3   4]]
[100   2   3   4]

labels.ravel()
Reshaping will also work:labels=labels.reshape((N,))
Come to think of it, so will calling squeeze:labels=labels.squeeze()

https://blog.csdn.net/liuweiyuxiang/article/details/78220080

I think scikit-learn expects y to be a 1-D array. Your labels variable is 2-D - labels.shape is (N, 1). The warning tells you to use labels.ravel(), which will turn labels into a 1-D array, with a shape of (N,).
Reshaping will also work:labels=labels.reshape((N,))
Come to think of it, so will calling squeeze:labels=labels.squeeze()

I guess the gotcha here is that in numpy, a 1-D array is different from a 2-D array with one of its dimensions equal to 1.