函数

解题步骤：1,ack(1,n)=ack(0,ack(1,n-1))+1=ack(1,n-1)+1;由递推式得：ack(1,n)=n+1;2，ack(2,n)=ack(1,ack(2,n-1))=ack(2,n-1)+2; //递推式 由递推式得：ack(2,n)=2n+3;3,ack(3,n)=ack(2,ack(3,n-1))=2*ack(3,n-1)+3; //递推式 即：ack(3,n)+3=2(ack(3,n-1)+3) 得: ack(3,n)+3=(ack(3,1)+3) * 2^(n-1); 又ack(3,1)=2ack(3,0)+3 ack(3,0)=a(2,1)=5 所以ack(3,1)=13; 所以 ack(3,n)=2^(n+3) - 3;所以：ack(3,3)=61;PS：这个是著名的Ackerman（阿克曼）函数，典型的非原始递归的递归函数，m<=3的时候像我上面的递推和计算很简单，但是一旦再大就会很麻烦，甚至计算机会彻底无法计算。可以参考wiki资料了解相关内容：http://zh.wikipedia.org/zh-cn/%E9%98%BF%E5%85%8B%E6%9B%BC%E5%87%BD%E6%95%B8

函数图像以x=1对称开口向上当t>1miny=t²-2t-3当t<0时miny=t²-4当0<=t<=1时miny=-4

求函数y=1/(-x²+2x+3)的值域解：y=/[-(x²-2x-3)]=-1/(x-3)(x+1)故得定义域x≠-1；x≠3.令y"=-(-2x+2)/(-x²+2x+3)²=2(x-1)/(-x²+2x+3)²=0，得驻点x=1；当x<1时y"<0；当x>1时y">0；故x=1是极小点,miny=y(1)=1/(-1+2+3)=1/4.x→-1+limy=+∞；x→-1-limy=-∞；x→3-limy=+∞；x→3+limy=-∞；x→±∞limy=0故值域为(-∞，0)∪[1/4，+∞)；其图像如下：

微信小程序推送服务通知需要收集足够的formid，使用过程中发现如果formid大量失效，在使用递归从redis从获取可用formid的时候会导致栈溢出问题，下面方法是使用php的高阶函数来消除递归，完美解决问题，记录之： <?php class A { public static function factorial($n, $accumulator = 1) { if ($n == 0) { return $accumulator; } return function() use($n, $accumulator) { return self::factorial($n - 1, $accumulator * $n); }; } public static function trampoline($params) { $result = call_user_func_array("self::factorial", $params); while (is_callable($result)) { $result = $result(); } return $result; } public static function run() { var_dump(self::trampoline(array(500))); } } A::run();

库函数：存放在函数库中的函数。库函数具有明确的功能、 入口调用参数和返回值。 Tubro C库函数分为九大类： (1)I/O 函数。包括各种控制台I/O、缓冲型文件I/ O和UNIX式非缓冲型文件I/O操作。 需要的包含文件：stdio.h 例如: getchar，putchar，printf，scanf， fopen，fclose，fgetc，fgets， fprintf，fsacnf，fputc，fputs， fseek，fread，fwrite等。 (2)字符串、内存和字符函数。 包括对字符串进行各种操作和对字符进行操作的函数。 需要的包含文件：string.h、mem.h、ctype. h或string.h 例如：用于检查字符的函数：isalnum，isalpha， isdigit，islower，isspace等。 用于字符串操作函数：strcat，strchr， strcmp，strcpy，strlen，strstr等。 (3)数学函数。包括各种常用的三角函数、双曲线函数、 指数和对数函数等。 需要的包含文件：math.h 例如：sin，cos，exp（e的x次方），log， sqrt（开平方），pow（x的y次方）等。 (4)时间、日期和与系统有关的函数。对时间、 日期的操作和设置计算机系统状态等。 需要的包含文件：time.h 例如：time返回系统的时间； asctime返回以字符串形式表示的日期和时间。 (5)动态存储分配。包括"申请分配"和"释放" 内存空间的函数。 需要的包含文件：alloc.h或stdlib.h 例如：calloc，free，malloc， realloc等。 (6)目录管理。包括磁盘目录建立、查询、改变等操作的函数。 (7)过程控制。包括最基本的过程控制函数。 (8)字符屏幕和图形功能。包括各种绘制点、线、圆、 方和填色等的函数。 (9)其它函数。 在使用库函数时应清楚的了解以下四个方面的内容： ①函数的功能及所能完成的操作 ②参数的数目和顺序，以及每个参数的意义及类型 ③返回值的意义及类型 ④需要使用的包含文件 这是要正确使用库函数的必要条件。

malloc函数实际分配的内存块的大小并不是你申请的字节数的大小，这个问题需要阅读 malloc.c 源文件/源代码 是如何实现的。正好这几天也在开始研究这个问题，现摘录一点 mallo.c 源文件/源代码 里的说明给你。//  glibc/malloc/malloc.c/** Vital statistics:  Supported pointer representation:       4 or 8 bytes  Supported size_t  representation:       4 or 8 bytes       Note that size_t is allowed to be 4 bytes even if pointers are 8.       You can adjust this by defining INTERNAL_SIZE_T  Alignment:                              2 * sizeof(size_t) (default)       (i.e., 8 byte alignment with 4byte size_t). This suffices for       nearly all current machines and C compilers. However, you can       define MALLOC_ALIGNMENT to be wider than this if necessary.   Minimum overhead per allocated chunk:   4 or 8 bytes       Each malloced chunk has a hidden word of overhead holding size       and status information.   Minimum allocated size: 4-byte ptrs:  16 bytes    (including 4 overhead)                          8-byte ptrs:  24/32 bytes (including, 4/8 overhead)       When a chunk is freed, 12 (for 4byte ptrs) or 20 (for 8 byte       ptrs but 4 byte size) or 24 (for 8/8) additional bytes are       needed; 4 (8) for a trailing size field and 8 (16) bytes for       free list pointers. Thus, the minimum allocatable size is       16/24/32 bytes.        Even a request for zero bytes (i.e., malloc(0)) returns a       pointer to something of the minimum allocatable size. */简而言之，malloc()分配到的最小内存块的大小是8bytes的倍数，具体在64-bit系统、size_t的大小定义为8bytes（64-bit OS默认；此值可修改)时，分配到的最小内存块的大小是16bytes的倍数，实际再加上还有overhead占用的空间和Alignment（对齐）的要求，其实是32bytes的倍数。所以，就你上面的代码来说，如果是在 64-bit系统、size_t类型（64-bit系统下，默认即 long unsigned int 型）的大小为8个字节的话，那么 malloc(10) 实际分配的内存块的大小是 32 字节。这 32 个字节的内存块，最前面的 10个 字节是 你想得到的，随便你怎么用，最后 8 个字节是存放 overhead 信息的，那么中间还有14个字节，其实也是可以给你随便用的。刚刚测试了一下，虽然 malloc.c 的文档里说 有 8个字节用来存放 overhead 信息，但是我输入了26个字节的数据，也能安全、顺利地 free() 掉指针，直到输入 27 个字节的数据才在 free() 时报错，内存段错误。你可以自己试试。 前两天写了下面这篇文章，顺便推荐你看看：你上面说的，输入了100个字符也没问题，那一方面是超出 malloc 分配的内存块中的可以合法使用的空间之后，后面的内存地址上的值即使被修改了，也因为没有其它用户（系统，或程序，或函数等）使用，所以没有报错；另一方面是，你上面的代码里把 free() 给注释了，如果你 使用 free(a) 的话，肯定会报错。然后，动态内存分配 ，大多数情况下都是给 结构体 之类的混合型数据类型使用的，数组的话，直接定义一个数组就行了，何必麻烦 malloc 呢？ 用完了还得释放。至于说，申请了内存块，最后又释放，白忙活了一阵，其实不是这样的。反过来说，你按一般情况定义一个数组，那么程序退出的时候不也是系统自动把内存空间给回收了吗？ 要不然，内存怎么够用呢？ 大家不同的程序到处乱访问其它程序的数据，还不乱套了啊？希望上面的能帮到你，烦请点采纳，谢谢！

stdlib.h可以提供一些函数与符号常量，具体如下：常量 NULL, EXIT_FAILURE, EXIT_SUCESS, RAND_MAX, MB_CUR_MAX 函数 atof, atoi, atol, strtod, strtof, strtols, strtol, strtoll, strtoul, strtoull, rand, srand, callc, free, maloc, realloc, abort, atexit, exit, getenv, system, bsearch, qsort, abs, div, labs, ldiv, llabs, tlldiv, mblen, mbtowc, wctomb, mbstowcs, wcstombs

#define MCHR 51......char *p, *buf, **lin;p = buf = (char *)malloc(sizeof(char) * MCHR * n);lin = (char **)malloc(sizeof(char **) * n);int i;for (i=0; i < n; i++,p+=MCHR) { *p = NULL; lin[i] = p;}

行啊，不要只认为动态申请就只有malloc，还有calloc，它就能办到！calloc的用法和malloc一样，就是多了一个参数，你就当它是行数吧，也许它就是为了解决这些才有的！int*a;printf("Inputrow,andcolloumn: ");scanf("%d%d",&row,&col);a=(int*)calloc(row,col*sizeof(int);这样不就行了！现在就可以把当作a[i*col+n](i小于row,(行数），n就是小于col了，即一行的个数的第几个）来用是一样的了，去试试吧，我记得也应该没错，很少用这个啦`其实malloc也行啊a=(int*)malloc(row*col*sizeof(int);这样就分配了这么多个了这么多，然后a[I*col+n]来用好像道理就一样了哦！

void *malloc(     size_t size   );  C里面没有alloc这个函数吧。char *a = (char*) malloc(1024); //申请1024字节int *b = (int *) malloc(1024 * sizeof(int)); //申请1024个整形数据空间功能就是分配给指针变量内存空间。相应的，使用完毕后，要free(a); free(b);来释放所申请的内存空间，否则会产生内存泄露。

id.visible = false?所谓的窗口指的是什么 需要确认一下 //或许你在main.cpp中打开了N个QML窗口 然后想到了隐藏..//这样的窗口 是不显示的ApplicationWindow { title: qsTr("Hello World") width: 640 height: 480 visible: false Rectangle{ anchors.fill: parent color:"red" }}//如下 点击是会 *隐藏* 的 ApplicationWindow { id: root title: qsTr("Hello World") width: 640 height: 480 visible: true Rectangle{ anchors.fill: parent color:"red" MouseArea{ anchors.fill: parent onClicked:{ root.visible = false //或者root.hide() } } }}

是InB=loge（B）

被free释放的的指针将成为野指针，其地址是非法的，所以对他的操作也就非法了，释放完内存后你应该自己手动将他设置为NULL，以供后面的代码段使用该指针

我这个程序实现多项式相加相减相乘，用单链表实现#include<iostream>#include"LinkList.h"using namespace std;//定义单项式class Monomial{public: int coef; int exp; friend bool operator!=(const Monomial,const Monomial);};void print(const Monomial m){ if(m.coef>0) { cout<<"+"<<m.coef; if(m.exp>1) cout<<"x^"<<m.exp; if(m.exp==1) cout<<"x"; } else { cout<<m.coef; if(m.exp>1) cout<<"x^"<<m.exp; if(m.exp==1) cout<<"x"; }}//定义多项式类，多项式为一系列单项式组成class Polynomial:public LinkList<Monomial>{public: Polynomial(); Polynomial(const Polynomial); void AppendMonomial(const Monomial); friend Polynomial operator+(const Polynomial,const Polynomial); friend Polynomial operator-(const Polynomial,const Polynomial); friend Polynomial operator*(const Polynomial,const Polynomial);};Polynomial::Polynomial(){}Polynomial::Polynomial(const Polynomialr):LinkList<Monomial>(r){}void Polynomial::AppendMonomial(const Monomial m){ Append(m);}Polynomial operator+(const Polynomial pa,Polynomial pb){ Polynomial pc; Monomial ma,mb,mc; int i=1,j=1; int la=pa.Length(); int lb=pb.Length(); while(i<=la j<=lb) { pa.GetElem(ma,i); pb.GetElem(mb,j); if(ma.exp<mb.exp) { pc.AppendMonomial(ma); i++; } else if(ma.exp>mb.exp) { pc.AppendMonomial(mb); j++; } else { mc.coef=ma.coef+mb.coef; if(mc.coef!=0) { mc.exp=ma.exp; pc.AppendMonomial(mc); } i++; j++; } } while(i<=la) { pa.GetElem(ma,i); pc.AppendMonomial(ma); i++; } while(j<=lb) { pb.GetElem(mb,j); pc.AppendMonomial(mb); j++; } return pc;}//实现两个多项式的减法Polynomial operator-(const Polynomial pa,Polynomial pb){ Polynomial pc; Monomial ma,mb,mc; int i=1,j=1; int la=pa.Length(); int lb=pb.Length(); while(i<=la j<=lb) { pa.GetElem(ma,i); pb.GetElem(mb,j); if(ma.exp<mb.exp) { pc.AppendMonomial(ma); i++; } else if(ma.exp>mb.exp) { mb.coef=-mb.coef; pc.AppendMonomial(mb); j++; } else { mc.coef=ma.coef-mb.coef; if(mc.coef!=0) { mc.exp=ma.exp; pc.AppendMonomial(mc); } i++; j++; } } while(i<=la) { pa.GetElem(ma,i); pc.AppendMonomial(ma); i++; } while(j<=lb) { pb.GetElem(mb,j); mb.coef=-mb.coef; pc.AppendMonomial(mb); j++; } return pc;}//实现两个多项式的乘法Polynomial operator*(const Polynomial pa,const Polynomial pb){ Polynomial pc; Monomial ma,mb,mc,md,me,mf; int i=1,j=1,k=1; int la=pa.Length(); int lb=pb.Length(); for(i=1;i<=la;i++) { pa.GetElem(ma,i); for(j=1;j<=lb;j++) { pb.GetElem(mb,j); mc.coef=ma.coef*mb.coef; mc.exp=ma.exp+mb.exp; if(i==1 j==1) pc.AppendMonomial(mc); else { pc.GetElem(md,1); pc.GetElem(me,pc.Length()); if(mc.exp<md.exp) pc.Insert(mc,1); else if(mc.exp==me.exp) { if(mc.coef+me.coef==0) {pc.Delete(mc,pc.Length());} else { mf.coef=mc.coef+me.coef; mf.exp=mc.exp; pc.SetElem(mf,pc.Length()); } } else if(mc.exp>me.exp) pc.Insert(mc,pc.Length()+1); else for(k=1;k<pc.Length();k++) { pc.GetElem(md,k); pc.GetElem(me,k+1); if(mc.exp<me.exp mc.exp>=md.exp){ if(mc.exp==md.exp) { if(mc.coef+md.coef==0) {pc.Delete(mc,k);} else { mf.coef=mc.coef+md.coef; mf.exp=mc.exp; pc.SetElem(mf,k); } } else pc.Insert(mc,k+1); } } } } } return pc;}//通过键盘的方式建立起一个多项式void Create(Polynomial p){ Monomial m; int n; cout<<"input the number of monomial of the polynomial "; cin>>n; cout<<"逐项输入 "<<n<<" 项的一元多项式，每一项格式为 ：系数 指数"<<endl; for(int i=0;i<n;i++) { cin>>m.coef>>m.exp; p.AppendMonomial(m); }}int main(){ Polynomial pa,pb; cout<<"----此程序实现一元多项式的相加----"<<endl<<endl; cout<<"input polynomial A"<<endl; Create(pa); cout<<"polynomial A is"<<endl; pa.Traverse(print); cout<<endl; cout<<"input polynomial B"<<endl; Create(pb); cout<<"polynomial B is"<<endl; pb.Traverse(print); cout<<endl<<endl; Polynomial pc; pc=pa+pb; cout<<"after addition between the two polynomial,result is"<<endl; pc.Traverse(print); cout<<endl<<endl; cout<<"现在验证这两个多项式的减法"<<endl; pc=pa-pb; cout<<"polynomial A is"<<endl; pa.Traverse(print); cout<<endl; cout<<"polynomial B is"<<endl; pb.Traverse(print); cout<<endl; cout<<"after submition ,result is "<<endl; pc.Traverse(print); cout<<endl<<endl; cout<<"现在验证这两个多项式的乘法"<<endl; pc=pa*pb; cout<<"polynomial A is"<<endl; pa.Traverse(print); cout<<endl; cout<<"polynomial B is"<<endl; pb.Traverse(print); cout<<endl; cout<<"after multipication,result is "<<endl; pc.Traverse(print); cout<<endl<<endl; cout<<"good job!"<<endl; system("pause"); return 0;}

因为y=-8/x,与y=-x+2相交，所以有-8/x=-x+2，即x²-2x-8=0，解得：x=-2,x=4,所以A（-2,4）B(4,-2),,由于AB与x轴交于C(0,2），所以s△AOB=s△OBC+s△OAC=1/2×2×（4+2）=6.

（1）在 y = 2x-4 中，令 x = 0 得 y = -4 ，因此 B（0，-4），令 y = 0 得 x = 2 ，因此 A（2，0）。（2）SAOB = 1/2*|OA|*|OB| = 1/2*2*4 = 4 。

1

⑴联立方程组：{Y=-X+6{Y=8/X解得：X=2，Y=4，或X=4，Y=2，∴A((2，4)，B(4，2)。⑵过A作AD⊥X轴于D，过B作BC⊥X轴于C，SAOB=SΔOAD+S梯形ABCD-SΔBOC=1/2×4×2+1/2(2+4)×(4-2)-1/2×2×4=6。

由交点:-8/x=-x-2解出此方程,得到X1=-4 或 X2=2代进解析式:Y1=2 或 Y2=-4两坐标分别是(-4,2) (2,-4)(2)在坐标上找出A,O,B三点.过A,B分别作X,Y轴平行线.可得此4线围成的图形是正方形.然后通过面积割补得.正方形面积:6*6=36再减去另外三块面积.右上方有一小正方形面积为2*2=4.左下一大三角形面积为6*6*0.5=18还有2块三角形面积为2*4*0.5=42*4=8所以SAOB=36-18-8-4=6

解：因为B(-2,-4)在y=m/x上，所以-4=m/-2 得：m=8,所以y=8/x又因为A(4,a)在这个函数上，所以有a=8/4，所以a=2又因为这两点都在y=kx+b上，代入得：-4=-2k+b；2=4k+b，解之得：k=1; b=-2所以反比例函数为：y=8/x，一次函数为：y=x-2（2）由一次函数可知：与x轴的交点坐标为：C(2,0)所以SAOB=SOCB+SOCA=1/2×2×4+1/2×2×2=4+2=6

如图写得比较详细希望对你有帮助！

　　Thread.Start()产生的线程在完成任务后，很快被系统所回收。而ThreadPool（线程池）方式下，线程在完成工作后会被保留一段时间以备resue。所以，当需求需要大量线程并发工作的时候，不建议使用ThreadPool方式，因为它会保持很多额外的线程。　　As for the ThreadPool, it is designed to use as few threads as possible while also keeping the CPU busy. Ideally, the number of busy threads is equal to the number of CPU cores. However, if the pool detects that its threads are currently not using the CPU (sleeping, or waiting for another thread), it starts up more threads (at a rate of 1/second, up to some maximum) to keep the CPU busy.

字典是一种通过名字或者关键字引用的得数据结构，其键可以是数字、字符串、元组，这种结构类型也称之为映射。字典类型是Python中唯一内建的映射类型，基本的操作包括如下： (1)len()：返回字典中键—值对的数量； (2)d[k]:返回关键字对于的值； (3)d[k]=v:将值关联到键值k上； (4)del d[k]:删除键值为k的项； (5)key in d:键值key是否在d中，是返回True，否则返回False。 (6)clear函数：清除字典中的所有项 (7)copy函数：返回一个具有相同键值的新字典；deepcopy()函数使用深复制，复制其包含所有的值，这个方法可以解决由于副本修改而使原始字典也变化的问题 (8)fromkeys函数：使用给定的键建立新的字典，键默认对应的值为None (9)get函数：访问字典成员 (10)has_key函数：检查字典中是否含有给出的键 (11)items和iteritems函数:items将所有的字典项以列表方式返回，列表中项来自（键，值），iteritems与items作用相似，但是返回的是一个迭代器对象而不是列表 (12)keys和iterkeys：keys将字典中的键以列表形式返回，iterkeys返回键的迭代器 (13)pop函数：删除字典中对应的键 (14)popitem函数：移出字典中的项 (15)setdefault函数：类似于get方法，获取与给定键相关联的值，也可以在字典中不包含给定键的情况下设定相应的键值 (16)update函数：用一个字典更新另外一个字典 (17) values和itervalues函数：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重复的元素 一、字典的创建 1.1 直接创建字典 d={"one":1,"two":2,"three":3} printd printd["two"] printd["three"] 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= {"three":3,"two":2,"one":1} >>> 1.2 通过dict创建字典 # _*_ coding:utf-8 _*_ items=[("one",1),("two",2),("three",3),("four",4)] printu"items中的内容:" printitems printu"利用dict创建字典，输出字典内容:" d=dict(items) printd printu"查询字典中的内容:" printd["one"] printd["three"] 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= items中的内容: [("one",1), ("two",2), ("three",3), ("four",4)] 利用dict创建字典，输出字典内容: {"four":4,"three":3,"two":2,"one":1} 查询字典中的内容: >>> 或者通过关键字创建字典 # _*_ coding:utf-8 _*_ d=dict(one=1,two=2,three=3) printu"输出字典内容:" printd printu"查询字典中的内容:" printd["one"] printd["three"] 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= 输出字典内容: {"three":3,"two":2,"one":1} 查询字典中的内容: >>> 二、字典的格式化字符串 # _*_ coding:utf-8 _*_ d={"one":1,"two":2,"three":3,"four":4} printd print"three is %(three)s."%d 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= {"four":4,"three":3,"two":2,"one":1} threeis3. >>> 三、字典方法 3.1 clear函数：清除字典中的所有项 # _*_ coding:utf-8 _*_ d={"one":1,"two":2,"three":3,"four":4} printd d.clear() printd 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= {"four":4,"three":3,"two":2,"one":1} {} >>> 请看下面两个例子 3.1.1 # _*_ coding:utf-8 _*_ d={} dd=d d["one"]=1 d["two"]=2 printdd d={} printd printdd 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= {"two":2,"one":1} {} {"two":2,"one":1} >>> 3.1.2 # _*_ coding:utf-8 _*_ d={} dd=d d["one"]=1 d["two"]=2 printdd d.clear() printd printdd 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= {"two":2,"one":1} {} {} >>> 3.1.2与3.1.1唯一不同的是在对字典d的清空处理上，3.1.1将d关联到一个新的空字典上，这种方式对字典dd是没有影响的，所以在字典d被置空后，字典dd里面的值仍旧没有变化。但是在3.1.2中clear方法清空字典d中的内容，clear是一个原地操作的方法，使得d中的内容全部被置空，这样dd所指向的空间也被置空。 3.2 copy函数：返回一个具有相同键值的新字典 # _*_ coding:utf-8 _*_ x={"one":1,"two":2,"three":3,"test":["a","b","c"]} printu"初始X字典：" printx printu"X复制到Y：" y=x.copy() printu"Y字典：" printy y["three"]=33 printu"修改Y中的值，观察输出：" printy printx printu"删除Y中的值，观察输出" y["test"].remove("c") printy printx 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= 初始X字典： {"test": ["a","b","c"],"three":3,"two":2,"one":1} X复制到Y： Y字典： {"test": ["a","b","c"],"one":1,"three":3,"two":2} 修改Y中的值，观察输出： {"test": ["a","b","c"],"one":1,"three":33,"two":2} {"test": ["a","b","c"],"three":3,"two":2,"one":1} 删除Y中的值，观察输出 {"test": ["a","b"],"one":1,"three":33,"two":2} {"test": ["a","b"],"three":3,"two":2,"one":1} >>> 注：在复制的副本中对值进行替换后，对原来的字典不产生影响，但是如果修改了副本，原始的字典也会被修改。deepcopy函数使用深复制，复制其包含所有的值，这个方法可以解决由于副本修改而使原始字典也变化的问题。 # _*_ coding:utf-8 _*_ fromcopyimportdeepcopy x={} x["test"]=["a","b","c","d"] y=x.copy() z=deepcopy(x) printu"输出：" printy printz printu"修改后输出：" x["test"].append("e") printy printz 运算输出： =======RESTART: C:UsersMr_DengDesktop est.py======= 输出： {"test": ["a","b","c","d"]} {"test": ["a","b","c","d"]} 修改后输出： {"test": ["a","b","c","d","e"]} {"test": ["a","b","c","d"]} >>> 3.3 fromkeys函数：使用给定的键建立新的字典，键默认对应的值为None # _*_ coding:utf-8 _*_ d=dict.fromkeys(["one","two","three"]) printd 运算输出： =======RESTART: C:UsersMr_DengDesktop est.py======= {"three":None,"two":None,"one":None} >>> 或者指定默认的对应值 # _*_ coding:utf-8 _*_ d=dict.fromkeys(["one","two","three"],"unknow") printd 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= {"three":"unknow","two":"unknow","one":"unknow"} >>> 3.4 get函数：访问字典成员 # _*_ coding:utf-8 _*_ d={"one":1,"two":2,"three":3} printd printd.get("one") printd.get("four") 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= {"three":3,"two":2,"one":1} 1 None >>> 注：get函数可以访问字典中不存在的键，当该键不存在是返回None 3.5 has_key函数：检查字典中是否含有给出的键 # _*_ coding:utf-8 _*_ d={"one":1,"two":2,"three":3} printd printd.has_key("one") printd.has_key("four") 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= {"three":3,"two":2,"one":1} True False >>> 3.6 items和iteritems函数:items将所有的字典项以列表方式返回，列表中项来自（键，值），iteritems与items作用相似，但是返回的是一个迭代器对象而不是列表 # _*_ coding:utf-8 _*_ d={"one":1,"two":2,"three":3} printd list=d.items() forkey,valueinlist:   printkey,":",value 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= {"three":3,"two":2,"one":1} three :3 two :2 one :1 >>> # _*_ coding:utf-8 _*_ d={"one":1,"two":2,"three":3} printd it=d.iteritems() fork,vinit:   print"d[%s]="%k,v 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= {"three":3,"two":2,"one":1} d[three]=3 d[two]=2 d[one]=1 >>> 3.7 keys和iterkeys：keys将字典中的键以列表形式返回，iterkeys返回键的迭代器 # _*_ coding:utf-8 _*_ d={"one":1,"two":2,"three":3} printd printu"keys方法：" list=d.keys() printlist printu" iterkeys方法：" it=d.iterkeys() forxinit:   printx 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= {"three":3,"two":2,"one":1} keys方法： ["three","two","one"] iterkeys方法： three two one >>> 3.8 pop函数：删除字典中对应的键 # _*_ coding:utf-8 _*_ d={"one":1,"two":2,"three":3} printd d.pop("one") printd 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= {"three":3,"two":2,"one":1} {"three":3,"two":2} >>> 3.9 popitem函数：移出字典中的项 # _*_ coding:utf-8 _*_ d={"one":1,"two":2,"three":3} printd d.popitem() printd 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= {"three":3,"two":2,"one":1} {"two":2,"one":1} >>> 3.10 setdefault函数：类似于get方法，获取与给定键相关联的值，也可以在字典中不包含给定键的情况下设定相应的键值 # _*_ coding:utf-8 _*_ d={"one":1,"two":2,"three":3} printd printd.setdefault("one",1) printd.setdefault("four",4) printd 运算结果： {"three":3,"two":2,"one":1} {"four":4,"three":3,"two":2,"one":1} >>> 3.11 update函数：用一个字典更新另外一个字典 # _*_ coding:utf-8 _*_ d={   "one":123,   "two":2,   "three":3   } printd x={"one":1} d.update(x) printd 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= {"three":3,"two":2,"one":123} {"three":3,"two":2,"one":1} >>> 3.12 values和itervalues函数：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由于在字典中值不是唯一的，所以列表中可以包含重复的元素 # _*_ coding:utf-8 _*_ d={   "one":123,   "two":2,   "three":3,   "test":2   } printd.values() 运算结果： =======RESTART: C:UsersMr_DengDesktop est.py======= [2,3,2,123] >>>

提取括号里的内容？分离文字数字？分离省市区？一个MID函数3秒搞定！ 先来看MID函数的基本用法： 函数定义： 返回文本字符串中从指定位置开始的特定数目的字符 使用格式：MID(text, start_num, num_chars) 参数定义： Text：必需，包含要提取字符的文本字符串。 Start_num：必需，文本中要提取的第一个字符的位置，文本中第一个字符的 start_num 为 1，依此类推。 Num_chars ：必需，指定希望 MID 从文本中返回字符的个数。 说明： 如果 start_num 大于文本长度，则 MID 返回空文本 ("""") 如果 start_num 小于文本长度，但 start_num 加上 num_chars 超过了文本的长度，则 MID 只返回至多直到文本末尾的字符 如果 start_num 小于 1，则 MID 返回错误值 #VALUE! 如果 num_chars 是负数，则 MID 返回错误值 #VALUE! 光说不练假把式，来看几个例子进一步理解： 例1：基本功能演示 ABC 1Excel精选技巧EMID(A1,1,1) 2Excel精选技巧ExMID(A2,1,2) 3Excel精选技巧xMID(A3,2,1) C1公式功能为提取A1单元格的第1个位置开始的1个字符，得到结果E C2公式功能为提取A2单元格的第1个位置开始的2个字符，得到结果Ex C3公式功能为提取A1单元格的第2个位置开始的1个字符，得到结果x 例2：根据省份证号获取生日 AB 13607241990121222341990年12月12日 B1中的公式为：TEXT(MID(A1,7,8),"0000年00月00日") 其中，MID(A1,7,8)是提取A1单元格中的第7个位置开始8个字符，结果为19901212 再用TEXT 函数将其格式化为xxxx年xx月xx日 例3：文本拆分 ABCDEF 1EXCELEXCEL 在B1单元格中输入公式：MID($A$1,COLUMN(A:A),1)，再往右拖拽即可 其中，COLUMN(A:A)往右拖拽得到1、2、3、4、5，结合MID函数，巧妙将文本拆分开来 例4：提取括号内容 富士康精密电子（廊坊）有限公司廊坊 富士康精密电子（深圳）有限公司深圳 尚品宅配（广州）家居股份有限公司广州 公式为：MID(A1,FIND("（",A1)+1,FIND("）",A1)-FIND("（",A1)-1) 其中：FIND函数分别找出左右括号的位置，两个位置相减得到括号内文本的长度，即可用MID提取出左括号开始的N个字符 例5：分离省市区 广东省河源市龙川县广东省河源市龙川县 江西省赣州市上犹县江西省赣州市上犹县 公式为： 分离省：MID(A1,1,FIND("省",A1)) 分离市：MID(A1,FIND("省",A1)+1,FIND("市",A1)-FIND("省",A1)) 分离县：MID(A1,FIND("市",A1)+1,FIND("县",A1)-FIND("市",A1)) 这3个公式以及例4所示的括号内容提取均是一脉相承，可用下列公式统一： mid(String,find("首标识",String)+1,find(尾标识)-find(首标识)) 用于提取两个标识符内的N个字符 例6：分离快递公司与快递单号 圆通12132342324241213234232424 申通1242435545466646412424355454666464 邮政EMS2542352523525325225423525235253252 公式为：MID(A1,MIN(IFERROR(FIND({0,1,2,3,4,5,6,7,8,9},A22),999)),LEN(A1)) 并且用Ctrl+Shift+Enter输入 其工作原理是：找出所有数字的位置→取最小数字位置为起始点→提取右侧数字 例7：提取文本中的连续数字 我的工号是7758258，来撩吧13988888888 公式为： MID(A1,MIN(FIND({0,1,2,3,4,5,6,7,8,9},A28&1234567890)),2*LEN(A1)-LENB(A1)) 其原理是：String&“1234567890”得到： 我的工号是7758258，来撩吧1234567890 然后再分别查找0~9所在的位置，取最小值即得到最左边数字的位置 2*LEN(A1)-LENB(A1)得到连续数字的长度 以最左边数字位置为起始点，连续数字长度为字符长度，即可提取连续数字 关注技巧菌公众号和我一起学习EXCEL吧，有任何疑问，请留言和技巧菌一起探讨吧，若给您带来帮助记得收藏点赞转发哦！