python使用记录

#2017-7-17
1、用len()函数可以获得list元素的个数;
    len()可以获取字符串长度
    
2、 list正向0开始索引，，逆向-1开始索引;
    也可以把元素插入到指定的位置，比如索引号为1的位置：
    list.insert(索引,元素)
    要删除list末尾的元素，用pop()方法：
    list.pop()
    要删除指定位置的元素，用pop(i)方法，其中i是索引位置
    要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：
    list[i] = ***

3、  只有1个元素的tuple定义时必须加一个逗号(1,)来消除歧义

4、if 判别式 :(注意别少了“:”)
    else/elif
    
5、name = input()返回的数据类型是str！ 
6、for x in ...循环就是把 序列中 每个元素代入变量x，然后执行缩进块的语句;Python提供一个range()函数，可以生成一个整数序列;

7、dict在内部就可以直接计算出Michael对应的存放成绩的“页码”，也就是95这个数字存放的内存地址，直接取出来，所以速度非常快;避免key不存在的错误，有两种办法，一是通过in判断key是否存在;dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value;删除一个key，用dict.pop(key)方法，对应的value也会从dict中删除

8、创建一个set，需要提供一个list不可以放入可变对象，因为无法判断两个可变对象是否相等
    s = set([1, 1, 2, 2, 3, 3])
    s = {1, 2, 3}
    add(key)方法可以添加元素到set中，可以重复添加，但不会有效果
    s.add(4)
    s.remove(4)
    set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作，返回交，并集（合）set()表示空集，只能用len()去判断。
    
9、None是一个特殊的常量;None和任何其他的数据类型比较永远返回False;你可以将None复制给任何变量

10、定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号;
    没有return语句，函数执行完毕后也会返回结果，只是结果为None
    调用的时候，既可以按顺序提供默认参数，比如调用enroll('Bob', 'M', 7)，意思是，除了name，gender这两个参数外，最后1个参数应用在参数age上，city参数由于没有提供，仍然使用默认值。

    也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上(非默认参数也可以)。
    
    定义默认参数要牢记一点：默认参数必须指向不变对象或只有变量名！
    
    定义参数 数目可变的函数:function(*number)参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple;Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去;
    
11、递归：
===> fact(5)
===> 5 * fact(4)
===> 5 * (4 * fact(3))
===> 5 * (4 * (3 * fact(2)))
===> 5 * (4 * (3 * (2 * fact(1))))
===> 5 * (4 * (3 * (2 * 1)))
===> 5 * (4 * (3 * 2))
===> 5 * (4 * 6)
===> 5 * 24
===> 120

在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

12、递归（Iteration）
    如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）
    很多其他数据类型是没有下标的，但是，只要是可迭代对象，无论有无下标，都可以迭代
    因为dict的存储不是按照list的方式顺序排列，所以，迭代出的结果顺序很可能不一样;
    默认情况下，for key in d,dict迭代的是key。
    如果要迭代value，可以用for value in d.values()（应该是字典的一种函数），
    如果要同时迭代key和value，可以用for k, v in d.items()。

    Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：
    for i, value in enumerate(['A', 'B', 'C']):
    ...     print(i, value)

    for循环里，同时引用了两个变量：
     for x, y in [(1, 1), (2, 4), (3, 9)]:
    ...     print(x, y)

13、方法与函数
    方法和对象相关；
    函数和对象无关。
    Java中只有方法，C中只有函数，而C++里取决于是否在类中。

14、循环列表生成:[元素形式，内部“简单 单支 判断语句”]
    L1 = ['Hello', 'World', 18, 'Apple', None]
    l2 = [s.lower() for s in L1 if isinstance(s,str)]
    print(l2)

15、生成器：generator
    在循环的过程中不断推算出后续的元素，这样就不必创建完整的list，从而节省大量的空间。
    把一个列表生成式的[]改成()， g = (x * x for x in range(10))
    就创建了一个generator
    通过next(g)函数获得generator的下一个返回值
    next(g)
    0
    ...也可通过for循环输出（则不需要nex语句）
    
16、可迭代的“函数” yield
    函数定义中包含yield语句，那么这个函数就不再是一个普通函数，而是一个generator函数
    generator和函数的执行流程不一样。
    函数是顺序执行，遇到return语句或者最后一行函数语句就返回。
    generator的函数，在每次调用next()的时候执行，遇到yield语句返回（返回yield后的值），再next()时,继续从上次返回的yield语句处继续执行（也就是函数执行只是中断了一下，可以返回继续执行）
    
###*********************************我是分割线**************************************************************    
#2017-07-18 15:15:42

1、 一类是集合数据类型，如list、tuple、dict、set、str等, 这些可以直接作用于for循环的对象统称为可迭代对象：Iterable
    一类是generator，生成的迭代对象：可以被next()函数调用，并不断返回下一个值的对象称为迭代器：Iterator
    Iter()可以将list ,tuple，dict..转换成可迭代对象
    
2、函数式编程就是，将函数作为参数传参！

3、map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的        
    Iterator返回。 r = map(f函数, [1, 2, 3, 4, 5, 6, 7, 8, 9])，结果r是一个Iterator
    Iterator是一种惰性序列：仅在需要的时候才会去调用它的body
    通过list()函数让它把整个序列都计算出来并返回一个list。list(r)

4、reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

5、 def char2num(s):
        return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
    {}是一个字典L，L[key]取字典中的value
    
6、s=''.join(s)；s=['s','b','c']zifu列表连接成字符串
   函数中还可以定义函数
   
7、filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
    list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
    filter()这个高阶函数，注意到filter()函数返回的是一个Iterator，也就是一个惰性序列

8、常数并不能直接转乘Iterable,可以先转str,

9、key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序（也就是按照key转换后的值与默认“从小到大”的顺序，对list排序，这里好像没有True or Flase的问题，函数完成的只是转换，有默认的顺序）

10、sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序(key估计是其默认参数，所以更改是要写出变量名。)sorted([36, 5, -12, 9, -21], key=abs)

11、

10、正则表达式，         
    （1）、[]匹配字符集，使用其中一个字符
    （2）、s=r"^**",匹配行首;(其在[]中，'除了')
            s=r"**$",匹配行尾;(其在[]中，'无意')
            
    （3）>>> s（当使用''''''输入字符串时，实际存储是下面）
'\nhello\nslie\nseif\nejf\naef\nef\ne\nf\n\nge\nge\ng\n\n'
        这种情况下，行首匹配只能管第一行，可用多行匹配参数fimtall(*,*,re.M)
    （4）
        \d    匹配任意十进制数，相当于 [0-9]
        \D    匹配任意非数字字符，相当于 [^0-9]
        \s    匹配任意空白字符，相当于 [ \t\n\r\f\v]
        \S    匹配任意非空白字符，相当于 [^ \t\n\r\f\v]
        \w    匹配任意数字和字母，相当于 [a-zA-Z0-9_]
        \W    匹配任意非数字和字母的字符，相当于 [^a-zA-Z0-9_]
        +    匹配前一个字符或子表达式一次或多次
        *    匹配前面的字符或者子表达式0次或多次   
        {n}    匹配前一个字符或子表达式n次
        {m,n}    匹配前一个字符或子表达式至少m次至多n次
        ?    匹配前一个字符或子表达式0次或1次重复
        
    （5）编译后还是要使用re调用方法，re.
        pattern1 = re.compile(p1)#同样是编译
        matcher1 = re.search(pattern1,key)#同样是查询
        
     （6）方法：
     findall()找到 RE匹配的所有子串，并把它们作为一个列表返回 
                import re;
                s=r"";
                re.findall(s,"")
     （7）分组：
        用 ()  表示的就是要提取的分组（Group），
        如果正则表达式中定义了组，就可以在Match对象上用group()方法提取出子串来
        group(0)永远是原始字符串，group(1)、group(2)……表示第1、2、……个子串
        >>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345')
        >>> m.group(0)
        '010-12345'
        >>> m.group(1)
        '010'
        >>> m.group(2)
        '12345'
        
        
11、返回函数，感觉挺难，应该是没有接触过的原因

12、关键字lambda表示匿名函数，因为函数没有名字，不必担心函数名冲突,
map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])冒号前面的x表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

13、函数对象有一个__name__属性，可以拿到函数的名字：
 def now():
    print('2015-3-25')

 now.__name__
 
14、装饰器，也是一个没有接触过的东西

#2017-07-19 13:31:48
1、 模块就是一个.py文件,引入文件，就要具体到.py文件，包名指向__init__.py文件，只引入包名，mean引入包中的__init__.py
    使用模块还可以避免函数名和变量名冲突,尽量不要与内置函数名字冲突.
    为了避免模块名冲突，Python又引入了按目录来组织模块的方法，称为包（Package）。
    每一个包目录下面都会有一个__init__.py的文件，否则，Python就把这个目录当成普通目录，而不是一个包
    __init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，而它的模块名就是mycompany。
    自己创建模块时要注意命名，不能和Python自带的模块名称冲突。

2、Python模块的标准文件模板（编写一个hello的模块：）：

    任何模块代码的第一个字符串都被视为模块的文档注释
    使用__author__变量把作者写进去
    导入sys模块后，就有了变量sys指向该模块，利用sys，就可以访问sys模块的所有功能
    sys模块argv变量，用list存储了命令行的所有参数，第一个参数是该.py文件的名称
    运行python3 hello.py获得的sys.argv就是['hello.py']
    这种__name__，只有运行主文件是本文件时才执行，最常见的就是运行测试
    
    
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

' a test module '  

__author__ = 'Michael Liao' 

import sys 

def test():

    args = sys.argv
    if len(args)==1:
        print('Hello, world!')
    elif len(args)==2:
        print('Hello, %s!' % args[1])
    else:
        print('Too many arguments!')


if __name__=='__main__':
    test()
    
3、 正常的函数和变量名是公开的（public），可以被直接引用，比如：abc，x123，PI等
    __xxx__这样的变量是特殊变量，可以被直接引用，但是有特殊用途
    _xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用，比如_abc，__abc等
    
4、当我们试图加载一个模块时，Python会在指定的路径下搜索对应的.py文件，如果找不到，就会报错：
    默认情况下，Python解释器会搜索当前目录、所有已安装的内置模块和第三方模块，搜索路径存放在sys模块的path变量中
    sys.path
['', '/Library/Frameworks/Python.framework/Versions/3.4/lib/python34.zip', '/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4', '/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/plat-darwin', '/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/lib-dynload', '/Library/Frameworks/Python.framework/Versions/3.4/lib/python3.4/site-packages']

5、面向对象思想：
    
    5.1假设我们要处理学生的成绩表，为了表示一个学生的成绩，面向过程的程序可以用一个dict表示：

    std1 = { 'name': 'Michael', 'score': 98 }
    std2 = { 'name': 'Bob', 'score': 81 }
    而处理学生成绩可以通过函数实现，比如打印学生的成绩：

    def print_score(std):
        print('%s: %s' % (std['name'], std['score']))
    
    
    5.2如果采用面向对象的程序设计思想，我们首选思考的不是程序的执行流程，而是Student这种数据类型应该被视为一个对象，这个对象拥有name和score这两个属性（Property）。如果要打印一个学生的成绩，首先必须创建出这个学生对应的对象，然后，给对象发一个print_score消息，让对象自己把自己的数据打印出来。

    class Student(object):

        def __init__(self, name, score):
            self.name = name
            self.score = score

        def print_score(self):
            print('%s: %s' % (self.name, self.score))
            
            
6、目前不准备设计python类思想的编程！c++还没搞熟，，，，，，
    and、or、not是python提供的逻辑操作符
    只要不为0的值都会转化为bool类型，所以abc直接与bool比较，没法比较，但是if 'abc' ==> if bool('abc')
    if(条件)
    print('abc == True','abc' == True)
    if 'abc':
        print('abc == True')
        
7、即使文件已经关闭，但f还是拥有这个文件的句柄，所以转换为bool类型为 True    
    f=open("Iter.py")

    f.close() 
    if f:
        print(True)
    else:
        print(False)

8、默认都是读取文本文件，并且是UTF-8编码的文本文件（应该是按照UTF-8读取，但是内部按照UNICODEING存储）
    要读取二进制文件，用'rb'模式打开文件
    写文件和读文件是一样的，传入标识符'w'或者'wb'表示写文本文件或写二进制文件：
    当我们写文件时，是放到内存缓存起来，只有调用close()方法时，操作系统才保证把没有写入的数据全部写入磁盘
    
    
9、操作文件和目录的函数一部分放在os模块中，一部分放在os.path模块中
    # 查看当前目录的绝对路径:
    os.path.abspath('.')

    创建，不要直接拼字符串，而要通过os.path.join()函数，这样可以正确处理不同操作系统的路径分隔符:
    os.path.join('/Users/michael', 'testdir')
    '/Users/michael/testdir'

    拆分路径时，也不要直接去拆字符串，而要通过os.path.split()函数，这样可以把一个路径拆分为两部分，后一部分总是最后级别的目录或文件名：
    >>> os.path.split('/Users/michael/testdir/file.txt')
    ('/Users/michael/testdir', 'file.txt')

    可以直接让你得到文件扩展名，很多时候非常方便：
    >>> os.path.splitext('/path/to/file.txt')
    ('/path/to/file', '.txt')
    
    这些合并、拆分路径的函数并不要求目录和文件要真实存在，它们只对字符串进行操作
    
10、把'变量'变成可存储或传输的过程称之为序列化（不只是保存数据，还有结构，，，，）
    变量内容从序列化的对象重新读到内存里称之为反序列化
    
    pickle.dumps()方法把任意对象序列化成一个bytes，然后，就可以把这个bytes写入文件。或者用另一个方法pickle.dump()直接把对象序列化后写入一个file-like Object.
    当我们要把对象从磁盘读到内存时，可以先把内容读到一个bytes，然后用pickle.loads()方法反序列化出对象，也可以直接用pickle.load()方法从一个file-like Object中直接反序列化出对象。
    
11、有关操作系统多线程，多进程编程也是没有接触过的东西

**************************************************************************************************
#2017-07-22 14:57:26
1、class Student(object):
    pass
    class后面紧接着是类名，即Student，
    类名通常是大写开头的单词，
    紧接着是(object)，表示该类是从哪个类继承下来的
    
2、 自由地给一个实例变量绑定属性,类中并没有定义，但是实例化后却能添加属性！！！
    类数据属性：定义在类里面但在函数外面的变量，它们都是静态的。
    实例属性：__init__()方法里的变量就是实例属性，这些属性只有被创建时才会被创建
    可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去
    初始化__init__方法的第一个参数永远是self，表示创建的实例本身，就可以把各种属性绑定到self
    
    class Student(object):

    def __init__(self, name, score):
        self.name = name
        self.score = score
     def print_score(self):
        print('%s: %s' % (self.name, self.score))
        
3、 有了__init__方法，在创建实例就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传
    Python解释器自己会传进去
    类中方定义方法，除了第一个参数是self外，其他和普通函数一样。
    要调用一个方法，实例变量上直接调用，除了self不用传递，其他参数正常传入bart.print_score()
    
4、属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private）
  def __init__(self, name, score):
        self.__name = name
        self.__score = score
        
5、Python “没有变量”，有“名字绑定”，一个名字为一个实例（instance）的引用，变量只是大家沿用了更熟悉的概念而已。
   `a = 20` 这句代码里，`a` 只是一个名字（引用），
   真正存在的是：各种类型‘值’，其内存不以变量名而转移，没有引用会消失！

*********************************************************************************************************
#2017-07-23 16:07:30

1、鉴于python 中没有指针引用这类具体类型，想要使用这类功能的时候，对于当个变量来说似乎没有这种功能，因为没有像c、c++    中直接代表变量内存的东西，python有的全部是‘引用’，故对于列表，之类的数据，直接赋值列表名，相当于引用赋值
    
2、除非对饮引用直接操作，才会更改引用指向的值，否则，通过引用获取地址之类的赋值操作不会更改引用的值
    a=1                                                    nums=[1,2,3]
    b=a                                                    a=nums
    b=4(直接修改引用)                                      a[0]=4(通过引用取地址，修改，对于变量a,nums这层的引用没变)
    a=1                                                    nums=[4,2,3]

***********************************************************************************************************
#2017-07-24 15:24:58
1、str()函数直接对数字列表转换，会将[] ,也当成字符串元素转换

**********************************************************************************************************
#2017-07-25 15:15:45
1、python 全局变量，使用:global声明变量，在声明的区域内可以使用外部的全局变量
name='lhf'
def change_name():
    #global name
    name='帅了一比'
    print('change_name',name)
change_name()
print(name)


2、递归中的“类似静态变量”2
class Solution(object):
    def __init__(self, ways=0):
        self.ways = ways
    def climbStairs(self, n):    
        if n-1==0:
            self.ways=self.ways+1
        if n-2==0:
            self.ways=self.ways+1
        if n-1 > 0:
            self.climbStairs(n-1)
        if n-2 > 0:
            self.climbStairs(n-2)
        return self.ways
**********************************************************************************************************
#2017-07-28 15:49:31
1、递归函数的编写：要搞清楚返回值的类型，以及怎么样使用返回值 
2、递归真正有价值的是从返回处开始的，（从最后一层返回）
3、子叶节点不是数，是其子叶为None的二叉树
4、满足条件可终止的递归：    
    def layerroots(self):
        for i in self.roots:
           
        if self.last == None:
            self.layerroots()
            
            
            
***********************************************************************************************************
#2017-08-25 21:10:29
动态地改变Python搜索路径：（只能先设置路径，再导入包这一种操作吗）,也许因为路径只能使用字符串处理的原因，import 不能含有字符串
模块必须处于Python搜索路径中才能被导入，但你不想设置个永久性的大路径，因为那样可能会影响性能，所以，你希望能够动态地改变这个路径。
sys.path是个列表，所以在末尾添加目录是很容易的，用sys.path.append就行了。当这个append执行完之后，新目录即时起效，以后的每次import操作都可能会检查这个目录。
如同解决方案所示，可以选择用sys.path.insert(0,…，这样新添加的目录会优先于其他目录被import检查。

**********************************************************************************************************
在python 中对图像的通道操作
http://www.voidcn.com/article/p-otstjfet-z.html

*****************************************************************************************************
#2017-10-24 22:49:22
python cv2显示保存热点图
cv2.applyColorMap(data,cv2.COLORMAP_HOT)

****************************************************************************************************
利用增加纬度的方式单通道边三通道，每个元素扩展至三个数
data4=np.dstack((data1,data2,data3))

****************************************************************************************************
numpy中的数据类型转换，不能直接改原数据的dtype!  只能用函数astype()

*************************************************************************************************
#np多维矩阵存储方式
    #当其仅作为数据存储时，可继续按照数组形式理解，分页存储[页索引][行索引][行中，具体一个]
    #当其使用轴向函数时，立体理解好点，越往后的轴，所包含的“元素”越具体：0轴一个元素，一个面；1轴，一个元素，一行。。。
    #这都是最值的索引函数，取0轴索引最值，取1轴索引最值，取2轴索引最值，输出与其垂直的平面形状，
    print(np.argmax(a, axis=2))
    print(a.shape)
    
    
    
****************************************************************************************************
#np.pad补边（输入矩阵，范围，方式，值）：
#范围每个（）
#描述一个维度有几个（）意味着填补几个维度，此维度整体扩充，（前补几个，后补几个）
#填补这么多（1275,1110,3）
padded_I = np.pad(I, offset_3d, 'constant', constant_values=(0))


*****************************************************************************************************
np.transpose((2,0,1))
#（2,0,1）是shape列表的索引，
#例shape(10,10,3)>shape(3,10,10) 
#按照上面转换，整体形状转变
#元素也照此变化到新的位置，此时将索引视为一个列表，（2,0,1）就是其索引， a[0][1][2]->a[2][0][1]
#最后的效果就是图片数据重构的感觉，
#不会造成通道交换，因为整体变换，通道那一维的索引整体变化，相对不变

#还有一个只交换行内元素的位置，a[...,[2,1,0]],用于图片通道交换，[2,1,0]同上


******************************************************************************************************
#前者返回垂直轴面的最大值，后者返回最大值的索引
ens_segscore = np.amax(ens_score, axis=2)
ens_segmask = np.argmax(ens_score, axis=2)