python

1,python 使用的pip在cmd中进行查找和安转，安装数据库：pip install mysql 直接安转连接mysql的驱动。

2，数据库查询；

def select_data(database,sql, *args):    try:        database.execute(sql, args)        return database.fetchall()    except:        print("Error:数据查找错误")        return None

调用：

sql_select = 'select * from temp_ecg_testdata where c_level = %s and c_dllLevel = %s'datas = select_data(cursor,sql_select, '紧急','一般')

3，一维数组变成二维指针，在dll中作为参数传递：
ecg_lead_pointer = (ctypes.c_void_p * 2)()ecg_lead_pointer[0] = ctypes.addressof(ecg_lead_s_datas[0])ecg_lead_pointer[1] = ctypes.addressof(ecg_lead_s_datas[1])
向dll中传递ecg_lead_pointer
将二维数组转换为二维指针
c_ecg_lead0_datas = (ctypes.c_int * data_len)()c_ecg_lead1_datas = (ctypes.c_int * data_len)()c_ecg_lead2_datas = (ctypes.c_int * data_len)()c_ecg_lead3_datas = (ctypes.c_int * data_len)()for i in range(data_len):    c_ecg_lead0_datas[i] = ecg_lead_s_datas[0][i]    c_ecg_lead1_datas[i] = ecg_lead_s_datas[1][i]    c_ecg_lead2_datas[i] = ecg_lead_s_datas[2][i]    c_ecg_lead3_datas[i] = ecg_lead_s_datas[3][i]c_lead_data_addr = (ctypes.c_void_p*4)()c_lead_data_addr[0] = ctypes.addressof(c_ecg_lead0_datas)c_lead_data_addr[1] = ctypes.addressof(c_ecg_lead1_datas)c_lead_data_addr[2] = ctypes.addressof(c_ecg_lead2_datas)c_lead_data_addr[3] = ctypes.addressof(c_ecg_lead3_datas)

3，python中括号：小括号，中括号，大括号：
小括号：代表的是元组数据类型，元组是一种不可变序列
中括号：代表list列表数据类型，列表是一种可变的序列，其创建方法简单有特别。
list('python')   ['p','y','t','h','o','n']
大括号：代表dict字典数据类型，字典由键值对组成，冒号分开键和值，逗号隔开组，
dict{'jion':'boy','llili':'girl'}
4，isinstance(names,list) 判断names是不是列表
5，发布python文件：
5.1）首先为模块创建一个文件夹，为文件夹命名为nester(自己根据需要命名)
5.2）在新文件夹中创建一个setup.py的文件
     from distutils.core import setup
     setup(
 name = 'nester',
 version = '1.0.0'
 py_modules = ['nester'] ,将模块的元数据与setup函数的参数关联
 author = 'zhou',
 author = '',
url = ''
description = 'a simple printer of nested lists'
  )
5.3)构建一个发布文件：
在nester文件夹中（就是你创建的文件夹），打开一个终端窗口，键入：python setup.py sdist
5.4)将发布安装到你的python本地副本中：在终端中键入：python setup.py install
5.5)导入模块并使用：import nester  neste.函数名（）；
或者使用 from  nester import 函数
6，向pypi上传代码：将发布传到PyPI ,需要：通过命令行注册PypI。以及通过命令窗口上传。pyton3 setup.py register
  注册完成后，要输入保存的信息：上传发布：python3 setup.py sdist upload
7,判断文件存不存在使用：os.path.exists('*.so')  
8,将字符串中的空格去掉，使用strip();  str.strip():将str中的空格去掉：
9，处理异常的方式：try except finally;或者：with:  with open('*.txt','w') as data;有了with就不需要finally了
10，python提供了一个标准库，名为pickle,它可以加载几乎任何的python数据对象，包括：列表‘
11：一旦数据'腌制'到一个文件中，它将会持久存储，可以在以后的某个日期读入另外一个程序；腌制的数据可以存放在磁盘上
或者数据库中，或者通过网络传输到另一个计算机中。
12，在准备好后，将这个过程反过来，将持久存储的腌制数据解除腌制，在python中的内存中用原来的形式重新创建
数据。

13，用dump保存，用load恢复：使用pickle很简单：只需导入所需的模块，然后使用dump()保存数据，以后某个时刻使用
load恢复数据。唯一的要求：：必须使用二进制访问模式打开这些文件；
14，
mikely = data_mik.strip().split(',')  :其中使用的strip()去除data_mik中的空格，使用split(',')将数据转换为以逗号
隔开的字符串。
15，python中的排序：
1）原地排序：原来的数据按指定的方式进行排序，排序后的数据占据原来的位置，原来的顺序丢失。对于列表:使用data.sort()
可以进行原地排序。没有返回值
2）复制排序：按你指定的顺序进行排序，之后返回原数据的一个有序副本，原数据的顺序依然保存，只是对一个副本进行
排序。在python中使用sorted(data)进行复制排序。有返回值
16，列表推导：设计列表推导是为了减少将一个列表转换为另一个列表时所需要的编写的代码量。
clear_list = [转换函数（each_t） for each_t in list]  对list中的每一个元素在中括号中就进行了转换。
比如转换函数为float：可以将list中的字符串均转换为浮点类型
17.集合set(),集合中没有重复的数据，collect = []; collect = set(list);list是个列表。
18，打包代码和数据，定制数据对象
1）字典：python内置的数据结构：允许数字和键而不是数字关联。使内存的数据结构和实际的数据结构保持一致。
也有叫散列，映射或者关联数组。
2）python中字典的定义：palin = dict()，或者使用cleese  = {}(就是使用大括号)  使用type(palin)可以显示类型
通过将键和值关联，向这两个字典分别增加一些数据；这两种的方式在初始化添加值的时候有些不同，使用大括号：
cleese['name'] = 'Jone Cleese'; cleese['occupations'] = ['actor','comedian','writer','file producer']
使用dict()函数的形式：plain = {'name':'Michela','ocupations':['comedian','actor','writer','tv']}
在访问的时候：plain['name'] 就显示对应的值。cleese['ocupation'][-1]使用数字来访问存储在一个特定字典键位置上的列表项，
可以把这认为是索引串链，从右向左，-1表示最后一项;删除字典中的项：del score['晓峰']
3）python可以动态的扩展来存储额外的键值对；与列表不同的是：python不会维持插入的顺序，这会导致一些意外的行为；
关于字典，重点是它会维护关联关系，而不是顺序。
dict_sara = dict()dict_sara = {'nanme':sara.pop(0),'birth':sara.pop(0),'time':str(sorted(set([sanitize(t) for t in sara]))[0:3])}使用字典比使用列表在这里方便多了。

4）python允许创建并定义面向对象的类，类可以用来将代码与代码处理的数据相关联。python允许创建并定义面向
对象的类；定义了类，可以用来创建或者实例化数据对象，它会继承类的特性；
5）python使用class创建对象，每个定义的类都有一个特殊的方法，名为__init__();可以通过这个方法控制如何初始化对象。
6）定义一个类时，实际上是在一个定制工厂函数，然后可以在你的代码中使用这个工厂函数创建实例。
7）在类中，每一个方法的第一个参数都是self,python要求每个方法的第一个参数为调用对象实例，
16，继承类：
1）class可以从零创建一个定制类，还允许通过继承现有的其他类来创建一个类，这也包括用list,set，dict提供的python
通过继承创建的这些类成为子类。
18,random :randint()随机产生一个整形的数字；choice:作用是：从一个list中随机挑选出一个元素。
19，list:l[-1]:表示链表的最后一个元素。l[-3]:表示倒数的第三个元素。
20，切片操作符：在[]中提供一对可选数字，a = lworld[3:4];用：分割。开始位置包含在切片中，结束位置不包含在切片中。
21，join;连接字符串；首先要有连接list中所有元素的连接符，然后在调用这个连接符的join方法。join的参数是被连接
的list;
s =';' li =['apple','orange','pear']   fruit = s.join(li)    print(fruit):  结果是：['apple';'orange';'pear']
22,在函数中，如果想给部分的参数提供默认的参数，那么这些参数必须要放在参数的末尾。def func(a,b = 5)
23,raw_input():读取输入端的内容，以字符串的形式进行读取，不管输入的是什么内容；input()：输入的是什么类型，就以什么
类型读入，有自己的特性。字符串要在输入的字符串上加上引号。
24，python中的and or 和C++中的三目运算符相似的使用。  a = True and hello or hi  print(a) a = hello;
b = False and hello or hi  print(b) b = hi. 其中a,b 变成列表会更好，[a],[b]这样就不会报错，因为and or 的用法
是确保前一个为真，利用的是逻辑关系，还不完全是三目运算符的特性。
25,正则表达式：
1）正则表达式是记录文本规则的代码：
2)".":表示除换行符以外的任意字符；
3）""\S":和‘.’是类似的，表示的是不是空白符的任意字符。
4)在很多搜索中，用“？”表示任意一个字符，用"*"：表示任意数量的连续字符。这种被称为通配符；但是在正则表达式
中，任意字符用“.”表示，而“*”表示数量。表示前面的字符可以重复的任意次数（包括0次），只要满足这些条件
都会被表达式配上。
5）“.*?”找到让它匹配最短的就停止。
6)表示任意长度的数字[0-9]* 或者\d*  ;和“*”类似的方法还有：+,表示一个或者更长的；要限定长度用{num},\d{11}
表示11位的数字
7）\w:匹配字母数字下划线  \s:匹配空白符； ^:匹配字符串的开始，$:匹配字符串的结束。
\S：和\s反义，\W:和\w相反，\D:匹配任意非数字的字符；\B:匹配不是单词开头或者结束的位置。
8）[a]的反义是[^a],表示除a以外的任意字符。
9）重复的次数：？表示重复零次或者一次；{n,}表示重复n次或者更多的次数；{n,m}重复n到m次
10,()在正则表达式中：要匹配字符“(”需要使用“\(”,?表示这个括号是可有可无的。
1，python保留字：保留字即关键字，keyword模块。可以输出当前版本的所有的关键字；keyword.kwlist
2，自然字符串：通过在字符串前边加r或者R,如，r'this is a line with \n',这里的\n会显示，不是换行
3，在同一行显示多条语句，语句间使用分号分隔，
4，python可以使用-h参数查看各参数的帮助信息。
5，#!/usr/bin/python3 指向python的路径，告诉操作系统执行这个脚本的时候，调用/usr/bin下的python解释器
，推荐使用#!/usr/bin/env python3;这种用法现在env(环境变量)设置里查找python安装路径，在调用对应路径下的解释器程序完成操作。
6，生成字符串数组
class StruConfiguration(ctypes.Structure):
_fields_= [
("SampleRate",ctypes.c_int),
("MVBitsProportion",ctypes.c_float),
("precision",ctypes.c_int),
("AsystoleTime",ctypes.c_float),
("Leads_arry", ctypes.c_byte * 50)
]
Leads_arry='I|II|V1|V5'.encode("utf-8")
struConfiguration.Leads_arry[:len(Leads_arry)]=Leads_arry[:]
7，python在输出时，要是不想换行，在print中加入end="" 例如；print(x,end ="")
8,python中的六个基本数据类型：
Number(数字)，String(字符串)，List列表)，Tuple(元组)，dictionary(字典)，sets（集合）
9,pyhton3支持int ,float,bool,complex
1)在python3中int表示长整型，type()反应数值的类型，或者instance(2,int)来判断
2）String类型的：print(str*2) 前边的str是字符串，中间的*表示复制当前的字符串，后边的数字表示复制的次数；
3）使用反斜杠转义特殊的字符，如果不想让反斜杠发生转义，可以在字符串前面添加一个r，表示原始字符串
4)反斜杠可以做续行符，表示下一行是上一行的延续，也可以使用‘’‘’...''''或者‘’‘...'''跨越多行
5）python没有单独的字符类型，一个字符就是长度为1 的字符串
6）与c字符串不同，python中字符串不能被改变，像一个索引位置赋值，比如word[0] ='m'会导致出错。
10，LIst
1)列表设计可以使用+ 号 的，print(list1+list2)
2）print(list*2)表示list重复两次输出
3)列表中的元素是可以改变的
11，Tuple:
1)元组和列表类似，不同的是元组的元素不能修改，元组写在小括号里，元素之间用逗号隔开
12，list,string,tuple属于序列
1）元组也可以使用+连接
13，Set
1)可以使用{}或者set()函数创建集合，注意：创建一个空的集合必须用set(),{}表示空字典
14，Dictionary:
1)字典是无序的对象集合，列表是有序的对象集合，字典通过键值对取值，列表通过偏移取值。
15，
python中的函数还可以接收可变长参数，比如以 "*" 开头的的参数名，会将所有的参数收集到一个元组上。
例如：
def test(*args): print(args) return args print(type(test(1,2,3,4)) #可以看见其函数的返回值是一个元组
Python3解释器：
1，python中的幂运算是：**； /是浮点的除法，//是整型的除法
2，python成员运算符
1）in 在指定的序列中找到值返回True,否则返回False,
2)not in 没在指定的序列中
3,is 是判断两个标识符是不是引用自一个对象，类似的：id(x)==id(y):如果引用的是同一个对象，则返回True,否则返回False
is not :
4,is 和==的区别：is用于判断两个变量引用对象是否为同一个，==用于判断引用变量的值是否相等
5，输出数字的进制：二进制：bin() 八进制：oct() 十六进制：hex（）
Nnumber:
1,python支持三种不同的数值类型；整型（没有大小限制），浮点型，复数
2，可以使用16进制或者8进制来表示整数
3，，随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法的效率，并提高程序的安全性
4，这里有数学上应用的一下函数，这里可以一些随机函数的使用，打乱顺序类的函数例如：shuffle(x)等函数
字符串：
1，python不支持单字符类型，单字符类型在python中也作为一个字符串使用。
2，访问字符串可以使用方括号截取字符串，
var = ‘hello world’ print('var[1:5]:',var[1:5])
3,在python3中，所有的字符串都是Unicode字符串
4，字符串的方法
字典
1,删除字典：dict.clear() 或者del dict 这两种删除字典的方法：del dict 操作后，会引发一个异常，del操作后字典就不存在了。
2，字典中不允许一个键出现两次，否则只能记住最后面的键值对，2）键必须不可变，所以可以用数字，字符串或者元组充当，但是列表不行。
3,update() dict2.update(dict) 将dict中的元素更新到dict2中，好像将dict中的元素拷贝到dict2中
4，popitem():方法返回并删除字典中的一对键和值，如果字典已经为空，却调用了此方法，就报出keyError异常
编程：
1，end可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符。
2，在循环语句中：for while都可以有else语句
3，pass:是空语句，是为了保持程序结构的完整性，pass 不做任何事情，一般用作占位语句
迭代器和生成器：
1，迭代器是一个可以记住遍历的位置的对象：迭代器对象从集合的第一个元素开始访问，直到所有元素被访问结束，迭代器只能往前不能后退
2，迭代器有两个基本的方法：iter() 和next()
3,字符串，列表或者元组对象都可以创建迭代器
4，for x in iter(list):
print(x,end= ',')
5, 也可以使用print(next(iter(list))),放在while循环里面
生成器： 使用了yield的函数被称为生成器
1，跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器
2，在调用生成器运行的过程中，每次遇到yield时函数就会暂停并保存当前所有的运行信息，返回yield的值，并在下一次执行next()方法时从当前位置继续执行。
3，不希望list完全输出的时候，使用yield，这时可以使用yield，这样就会使list中的元素一个一个的展现出来。
4，python使用lambda函数来创建匿名函数，所谓的匿名函数，就是不再使用def语句这样的标准形式定义一个函数。lambda的主体是一个表达式，而不是一个代码块，仅仅能在lambda表达式中封装有限的逻辑进去。lambda函数有自己的命名空间，且不能访问自由参数列表之外或者全局命名空间里的参数。虽然lambda函数看起来只能写一行，却不等同于C/C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
5，语法：sum = lambda arg1,arg2:arg1+arg2;
6,变量作用域：L(local) 局部作用域，E(Enclosing):闭包函数外的函数中，G(Global)作用域
B（Built-in）内建作用域
7，python中只有模块，类，以及函数才会引入新的作用域，其他的的不会引入新的函数。
8，函数内的定义的为局部变量，定义在函数外的为全局变量，
9，当内部的作用域想要修改外部的作用域的变量时，就要使用global 和nonlocal关键字
在函数内部修改函数外部的变量，使用global函数，在嵌套函数中修改外边函数中定义的变量，要使用nonlocal
10,把N个关键字参数转换为字典:def fun(country,province,**kwargs);
print(country,province,kwargs), 
> def func(country,province,**kwargs): ... print(country,province,kwargs) ... >>> func("China","Sichuan",city = "Chengdu", section = "JingJiang") China Sichuan {'city': 'Chengdu', 'section': 'JingJiang'} >>> 
数据结构：
1，列表，列表的各种方法
2，将列表当做堆栈使用；用append()方法可以将一个元素添加到堆栈的顶，用不指定索引的pop()方法可以把一个元素从堆栈的顶释放出来
3，将列表当做队列使用；将队列中的第一个加入的元素，第一个取出来。但是使用列表用作这样的目的效率不好，在列表的最后或者弹出元素速度快，然而在列表里插入或者从头部弹出的速度不快。
4， deque: from collections import deque
deque.append()向队列中添加元素 deque.popleft() ：从队列中删除元素
5，列表推导式：【3*x for x in vec】
6,del语句：可以从一个列表中依索引而不是值来删除一个元素，可以从列表中删除一个切割，或者清空整个列表。
也可以使用del删实体变量。
7，dir()函数，可以找到模块定义的所有的名称
输入和输出：
1，输出方式有：表达式语句和print()函数；第三种方法是：使用文件对象的write()方法 ，标准输出用sys.stdout引用，如果希望输出的格式更加多样，可以使用str.format()函数来格式化输出值。如果希望将输出的值转为字符串，可以使用str()或者repr()函数来实现
str()函数返回一个用户易读的表达式，repr():产生一个解释器易读的表达形式
2，字符串的rjust()方法，可以将字符串靠右，并在左边填充空格，
for x in range(1, 11): ... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ') ... # 注意前一行 'end' 的使用 ... print(repr(x*x*x).rjust(4))
字符串允许使'''...''' 格式表示多行的内容，
>>> for x in range(1, 11): ... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
类似的方法，例如：ljust()和center()方法，这些病不会写任何东西，它们仅仅是返回新的字符串。
另一个方法：zfill(),会在数字的右边填充0，
pickle模块：
1， 
python 中的pickle模块实现了基本的数据序列化操作和反序列化操作
通过pickle模块的序列化操作可以将程序中运行的对象信息保存到文件中去，永久存储
通过pickle模块的反序列化操作，可以从文件中创建上一次程序保存的对象
面向对象：
1，类对象支持两种操作：属性引用和实例化
2，很多类都倾向于将对象创建为有初始状态的，因此类中可能会定义一个名为_init__（）的特殊的方法，def __init__(self):
self.data = {} 其中的__init__()可以有参数，通过这个函数传递到实例化操作上
3，self代表实例，而非类；类的方法和普通的函数有个特别的区别：必须有一个额外的第一个参数的名称，惯例是self
4，self代表实例，代表当前对象的地址。self.class则指向类，self不是python的关键字。
5，类的方法使用def定义，与一般的方法不同的是要在函数中添加self,且是第一个参数。self代表类的实例。
继承：
1，class DericedClassName(BaseClass): 注意圆括号中基类的顺序，若是基类中有相同的方法名，而在子类使用时没有指定，python自左至右搜索，即在子类中没有找到时，就去基类中去查找
2,基类和派生类必须在一个作用域中，除了类，还可以使用表达式
3，在进行继承的时候要在在构造函数中调用基类的构造函数
4，可以将父类中的方法进行变换，根据自己的需要进行编写
5，两个下划线，声明为私有属性，不能在类外部直接使用或者直接访问。
标准库：
1，os模块提供了很多与操作系统相关联的函数
import os
2,建议使用import os风格，而非from os import ,这样可以保证随操作系统的不同而有所变化的os.open()不会覆盖内置函数open()
3,针对日常的文件和目录管理任务，mod:shutil模块提供了一个易于使用的高级接口：强大的地方是：在于其对文件的复制和删除操作支持好。
4，shutil.copy(sec,dst)复制一个文件到另一个文件目录下，放回dst的目录，dst可以是一个目录，也可以是一个文件，src必须是一个文件。
5，shutil.copy2(src,dst)在copy上的基础上，在复制文件最后的访问时间与修改的时间也复制过来
6，shutil.copyfile(src,dst)从源src复制到dst中去，src和dst必须是以文件，不能是文件夹
7，shutil.copystat(src,dst)只复制权限，最后访问时间，最后修改时间，不会复制文件内容
8，shutil.copymode(src,dst)只复制权限
9，shutil.copytree(olddir,newdir,True/False):把olddir拷贝一份newdir，如果第3个参数是True，则复制目录时将保持文件夹下的符号连接，如果第3个参数是False，则将在复制的目录下生成物理副本来替代符号连接。
10，shutil.move(src,dst):将路径src处的文件夹移到路径dst，并返回新位置的绝对路径字符串，src可以是一个文件夹，也可以是一个文件。
11，如果dst所指的目录不存在，而src是一个文件，所以程序会默认dst是指的一个没有扩展名的文件，而不是一个文件夹
12,os.unlink(path):将删除path处的文件，成功删除后没有任何的返回，path是一个完整的路径
13，os.rmdir(path):将删除path处的文件夹
14，shutil.rmtree(path)，将删除path处的文件夹，它包含所有的文件和文件夹都被删除。
文件通配符：
1，glob模块提供了一个函数用于从目录通配符搜索中生成的文件列表
命令行参数：
1，通用脚本经常调用命令行参数，这些命令行参数以链表的形式存储于sys模块的argv变量；
错误输出重定向和程序终止；
1，sys还有stdin,stdout和stderr属性，即使在stdout被重定向时，后者也可以用于显示警告和错误信息；大多的脚本的重定向终止都是用sys.exit()
字符串正则匹配：
1，re模块位高级字符串处理提供了正则表达式工具，
数学：
1，math模块为浮点运算提供了对底层C函数库的访问
import math math.cos(math.pi/4)
访问互联网：
用于访问互联网以及处理网络通信协议，其中最简单的两个用于处理urls接受的数据的urlib.request以及用于发送电子邮件的smtplib
1,from urllib.request import urlopen
for line in urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl')
line.decode('utf-8')
日期和时间：
1，datetime模块为日期和时间处理同时提供了简单和复杂的方法，支持日期和时间算法的同时，实现的重点放在更有效的处理和格式化输出
2，from datatime import date
now = date.today()
now.strftime('%m-%d-%y,%d %b %y is a % A on the %d day of %B')
数据压缩；
1，zlib,gzip ,bz2,zipfile以及tarfile
2,import zlib
性能度量“
测试模块；
开发高质量的软件的方法是为每一个函数开发测试代码，并且在开发过程中经常进行测试
doctest模块提供了一个工具，扫描模块并根据程序中内嵌的文档字符串执行测试
import doctest
doctest.testmod() #自动验证嵌入测试
常量：
通常使用全部的大写表示常量
获取字符的整数：使用ord()函数，把编码转换为对应的字符，使用chr();
纯英文的str可以通过用ASCII编码为bytes；中文的可以通过utf-8编码为bytes；将bytes变为str使用decode()方法，通过响应的编码格式转换过去
为了让python解释器读取源码，按utf-8的编码格式，通常在开头的文件上写：
#！/usr/bin/env python3 #-*- coding:utf-8-*-
使用%% 表示一个%
内存监控：
1， 使用的方式是；tracemalloc
在需要开始的地方：
import tracemalloc 
time1 = tracemalloc.take_snapshot()
运行程序
time2 = tracemalloc.take_snapshot()
stats = time2.compare_to(time1,'lineno')
for stat in stats[:20]:
print('stat===========',stat)
2，多进程出现错误，报错，
exit_code = task_process.exitcode
if exit_code != 0:
print("多进程滤波重采样 exit_code:%d" % (exit_code))
3，字符串也是可以迭代的对象：
判断一个对象是不是可迭代的对象：使用collections模块的iterable类型来判断：
from collections import Iterable
isinstance('abc',Iterable)
4，在python中，这种一边循环一边计算的机制，称为生成器， generator
1)将一个列表生成式改元组；generator保存的是算法，每次调用next(g)，就是计算g中的下一个元素的值。
2）在函数定义中包含yield关键字，在调用next()的时候，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行
使用next会在最后的时候报错，因此在使用generator的时候，使用for循环，将其中的值遍历出来
5，list,dict,str，等iterable变成iterator可以使用iter()
python中的iterator对象表示的是一个数据流，iterator对象可以被next（）函数调用并不断返回下一个数据，可以把数据流看做一个有序的序列，但是不能提前知道序列的长度，只能不断的通过next函数获取下一个数据，所以iterator是惰性的 ，只有在需要返回下一个数据的时候，才能计算
6，Iterator甚至可以表示一个无限大的数据流，但是list却不可以存储全体的自然数
7，凡是可作用于for循环的对象都是Iterable类型；
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。
8，函数式编程一个特点是：允许把函数本身作为参数传入另一个函数，还允许返回一个函数；python对函数式编程提供部分支持，由于Python允许使用变量，python不是纯函数是编程语言。
9，高阶函数：
1）函数本身可以赋值给变量，即变量可以指向函数
2）函数名也可以是变量；函数名可以指向一个变量，要恢复原来变量的函数，需要重启python交互环境
3)传入函数：变量可以指向函数，函数的参数可以接收变量，那这个函数就可以接收另一个函数作为参数，这种函数称为高阶函数。
编写高阶函数的作用就是让函数可以接收别的函数。
把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。
10，匿名函数：
lambda:表示匿名函数，前边的x表示函数的参数，后边只能有一个表达式，不用写return,返回值是该表达式的结果
lambda x：x*x
11，装饰器：
1）在函数调用前后，添加功能，又不改变函数的定义，这种动态添加功能的方式成为装饰器
12，偏函数：
1）使用functools.partial：就是把一个函数的某些参数给固定住（就是设置默认参数），返回一个新的函数，
int2 = functools.partial(int ,base = 2):实际上就是固定了int函数的关键字base.
当函数的参数个数太多，需要简化时，使用partial可以创建一个新的函数，这个函数可固定住原函数的部分参数，从而在调用更简单 
13，连接数据库的Mysql:mysql-connector-python;
用于科学计算的：numpy:用于生成文本的：工具Jinja2
14,安装第三方模块：
1）sys.path.append('dir')
2)设置环境变量PYTHONPATH:将环境变量添加到模块搜索路径中。
15，属性中有类属性和实例属性：
类属性是：在类中定义变量，作为类属性
实例属性是；在实例化后定义的属性。
16，正常情况下，定义了一个类class后，创建一个class的实例后，可以给实例绑定任何属性和方法。这是动态语言的灵活性。
1）可以给实例绑定一个方法，但是只有这个实例可以使用，其他的实例不能用
2）可以给类绑定一个方法，这样所有的实例就可以使用了
3）限制实例的属性，使用__slots__:只允许限定的属性可以使用，其他的属性不能使用
4）限制的范围：仅对当前实例起作用，对子类的继承没有作用。除非在子类中也用__slots__
17，使用property可以设置getter函数，使用对应的函数.setter可以获得setter函数，在setter函数中可进行限制函数。只有property修饰的函数是只读函数，二者具备的函数是读写函数
18，
1）StringIO:数据在内存中读写；在内存中读取str;
2)BytesIO:操作的只能是str,操作二进制数据，
19，序列化：pickle()
1）把变量从内存中变成可存储或传输的过程称之为序列化
2)序列化后，就可以把序列化的内存写进磁盘，或者通过网络传输到别的机器上。
3）把变量内容从序列化的对象重新读取到内存里称之为反序列化，即unpacking
20,JSON:
1)在不同的编程语言之间传递对象，就必须把对象序列化为标准格式 。JSON 表示出来是一个字符串，可以被所有的语言读取，也可以方便的存储在磁盘或者通过网络传输。JSON不仅是标准格式，而且比XML要快。在WEB中读取更方便。
2）python中json和dict的转换；
d = dict()
jd= json.dumps(d); dumps返回一个str，内容的标准就是JSON，
3）反序列化，json.loads()或者load()
21,多进程，可以使用Process()这种感觉好写一些
1）要开启较多的子进程，使用进程池，Pool
22,多线程：
1）多任务可以由多进程完成，也可以由一个进程内的多线程完成
23，多进程和多线程最大的不同是：在多进程中，同一个变量，各自有一份拷贝在每个进程中，互不影响，在多线程中，所有变量由线程共享，所以，任何一个变量都可以被任何一个线程修改。线程之间共享数据最大的危险在于多个线程同时改一个变量，把内容改乱了。
24，使用线程要想各个线程之间的变量不相互影响，使用threading.local() 这个可以创建全局变量，单每个线程都只能读写自己的线程的独立副本，互不干扰。
25，分布式进程：
1）：在threading和process中，应当优选process,因为process更稳定，而且process可以分布到多台机器上，而threading只能分布在同一台机器的过个CPU上
2）：python的multiprocessing模块不仅支持多进程，其中的managers子模块还支持把多进程分布在多台机器上。
3）