189 8069 5689
include malloc.h #include stdio.h #include ctype.h//判断是否为字符的函数的头文件 #define maxsize 100 typedef int elemtype; typedef struct sqstack sqstack;//由于sqstack不是一个类型 而struct sqstack才是 char ch[7]=;//把符号转换成一个字符数组 int f1[7]=;//栈内元素优先级 int f2[7]=;//栈外的元素优先级 struct sqstack { elemtype stack[maxsize]; int top; }; void Initstack(sqstack *s) { s-top=0; } void Push(sqstack *s,elemtype x) { if(s-top==maxsize-1) printf("Overflow\n"); else { s-top++; s-stack[s-top]=x; } } void Pop(sqstack *s,elemtype *x) { if(s-top==0) printf("underflow\n"); else { *x=s-stack[s-top]; s-top--; } } elemtype Gettop(sqstack s) { if(s.top==0) { printf("underflow\n"); return 0; } else return s.stack[s.top]; } elemtype f(char c) { switch(c) { case '+': return 0; case '-': return 1; case '*': return 2; case '/': return 3; case '(': return 4; case ')': return 5; default: return 6; } } char precede(char c1,char c2) { int i1=f(c1); int i2=f(c2);//把字符变成数字 if(f1[i1]f2[i2])//通过原来设定找到优先级 return ''; else if(f1[i1]f2[i2]) return ''; else return '='; } int Operate(elemtype a,elemtype theta,elemtype b) { int sum; switch(theta) { case 0: sum=a+b; break; case 1: sum=a-b; break; case 2: sum=a*b; break; default: sum=a/b; } return sum; } EvaluateExpression() { char c; int i=0,sum=0; int k=1,j=1;//设置了开关变量 elemtype x,theta,a,b; sqstack OPTR,OPND; Initstack(OPTR); Push(OPTR,f('#'));//0压入栈 Initstack(OPND); c=getchar(); if(c==ch[2]||c==ch[3]||c==ch[5]||c==ch[6])//先对＋和-的情况忽略和左括号的情况 { printf("错误1 \n"); k=0; return 0; } if(c==ch[0]) c=getchar();//如果是＋，把它覆盖 if(c==ch[1]) { j=0; c=getchar();//也把－号覆盖 } while(c!='#'||ch[Gettop(OPTR)]!='#') { if(isdigit(c)) { sum=0; while(isdigit(c)) { if(!j) { sum=sum*10-(c-'0');//实现了数字串前面有负号（之前是：sum=-(sum*10)-(c-'0')结果是－12＋13＝21） } else sum=sum*10+(c-'0'); c=getchar(); } Push(OPND,sum);//如果还是数字先不压栈，把数字串转化成十进制数字再压栈 j=1; } else if(k) { switch(precede(ch[Gettop(OPTR)],c)) { case'': Push(OPTR,f(c));//把它们整型化 c=getchar(); if(c==ch[0]||c==ch[1]||c==ch[2]||c==ch[3]||c==ch[5]||c=='\n')//要除去下个是‘（’的情况 也把以运算符归到这里来 { printf("出错2\n"); k=0; return 0;//加了开关变量和返回0的值使程序更以操作 } break; case'=': Pop(OPTR,x); c=getchar(); if(c==ch[0]||c==ch[1]||c==ch[2]||c==ch[3]||c==ch[5]||c=='\n')//把ch[6]的情况也忽略了但此时并没有注意到右括号后面右运算符的情况 { printf("出错2\n"); k=0; return 0; } break; case'': Pop(OPTR,theta); Pop(OPND,b); Pop(OPND,a);//注意这里是谁先出栈 Push(OPND,Operate(a,theta,b)); break; } } }//在这里判断是否以运算符结束是不对的 return(Gettop(OPND)); } main() { int result; printf("输入你的算术表达式：\n"); result=EvaluateExpression(); printf("结果是 :%d\n",result); return 0; } : 本计算器利用堆栈来实现。 1、定义后缀式计算器的堆栈结构 因为需要存储的单元不多，这里使用顺序栈，即用一维数组来模拟堆栈： #define MAX 100 int stack[MAX]; int top=0; 因此程序中定义了长度为MAX的一维数组，这里MAX用宏定义为常数100，我们可以修改宏定义而重新定义堆栈的大小。 整型数据top为栈顶指示，由于程序开始时堆栈中并无任何数据元素，因此top被初始化为0。 2、存储后缀式计算器的运算数 我们定义了堆栈stack[MAX]后，就可以利用入栈操作存储先后输入的两个运算数。 下面看一下是如何实现的： int push(int i) /*存储运算数，入栈操作*/ { if(topMAX) { stack[++top]=i; /*堆栈仍有空间，栈顶指示上移一个位置*/ return 0; } else /*堆栈已满，给出错误信息，返回出错指示*/ { printf("The stack is full"); return ERR; } } 我们在调用函数push时，如果它的返回值为0，说明入栈操作成功；否则，若返回值为ERR(在程序中说明为-1)，说明入栈操作失败。 3、从堆栈中取出运算数 当程序中读完了四则运算符后，我们就可以从堆栈中取出已经存入的两个运算数，构成表达式，计算出结果。取出运算数的函数采用的正是出栈算法。在本例中，实现该算法的函数 为pop(): int pop(); /*取出运算数，出栈操作*/ { int var; /*定义待返回的栈顶元素*/ if(top!=NULL) /*堆栈中仍有数据元素*/ { var=stack[top--]; /*堆栈指示下移一个位置*/ return var; } else /*堆栈为空，给出错误信息，并返回出错返回值*/ printf("The stack is cmpty!\n"); return ERR; } 同样，如果堆栈不为空，pop()函数返回堆栈顶端的数据元素，否则，给出栈空提示，并返回错误返回值ERR。 4、设计完整的后缀式计算器 有了堆栈存储运算数，后缀式计算器的设计就很简单了。程序首先提示用户输入第一个运算数，调用push()函数存入堆栈中；而后提示用户输入第二个运算数，同样调用push()函数存入堆栈中。接下来，程序提示用户输入+,-,*,/四种运算符的一种，程序通过switch_case结构判断输入运算符的种类，转而执行不同的处理代码。以除法为例，说明程序的执行流程： case '/': b=pop(); a=pop(); c=a/b; printf("\n\nThe result is %d\n",c); printf("\n"); break; 程序判断用户输入的是除号后，就执行上述代码。首先接连两次调用pop()函数从堆栈中读出先前输入的运算数，存入整型数a和b中；然后执行除法运算，结果存入单元c中。这时需要考虑究竟谁是被除数，谁是除数。由于开始我们先将被除数入栈，根据堆栈“先进后出”的原则，被除数应该是第二次调用pop()函数得到的返回值。而除数则是第一次调用pop()函数得到的返回值。 最后程序打印出运算结果，并示提示用户是否继续运行程序： printf("\t Continue?(y/n):"); l=getche(); if(l=='n') exit(0); 如果用户回答是"n"，那么结束程序，否则继续循环。 完整的程序代码如下： #includestdio.h #includeconio.h #includestdlib.h #define ERR -1 #define MAX 100 /*定义堆栈的大小*/ int stack[MAX]; /*用一维数组定义堆栈*/ int top=0; /*定义堆栈指示*/ int push(int i) /*存储运算数,入栈操作*/ { if(topMAX) { stack[++top]=i; /*堆栈仍有空间，栈顶指示上移一个位置*/ return 0; } else { printf("The stack is full"); return ERR; } } int pop() /*取出运算数，出栈操作*/ { int var; /*定义待返回的栈顶元素*/ if(top!=NULL) /*堆栈中仍有元素*/ { var=stack[top--]; /*堆栈指示下移一个位置*/ return var; /*返回栈顶元素*/ } else printf("The stack is empty!\n"); return ERR; } void main() { int m,n; char l; int a,b,c; int k; do{ printf("\tAriothmatic Operate simulator\n"); /*给出提示信息*/ printf("\n\tPlease input first number:"); /*输入第一个运算数*/ scanf("%d",m); push(m); /*第一个运算数入栈*/ printf("\n\tPlease input second number:"); /*输入第二个运算数*/ scanf("%d",n); push(n); /*第二个运算数入栈*/ printf("\n\tChoose operator(+/-/*//):"); l=getche(); /*输入运算符*/ switch(l) /*判断运算符，转而执行相应代码*/ { case '+': b=pop(); a=pop(); c=a+b; printf("\n\n\tThe result is %d\n",c); printf("\n"); break; case '-': b=pop(); a=pop(); c=a-b; printf("\n\n\tThe result is %d\n",c); printf("\n"); break; case '*': b=pop(); a=pop(); c=a*b; printf("\n\n\tThe result is %d\n",c); printf("\n"); break; case '/': b=pop(); a=pop(); c=a/b; printf("\n\n\tThe result is %d\n",c); printf("\n"); break; } printf("\tContinue?(y/n):"); /*提示用户是否结束程序*/ l=getche(); if(l=='n') exit(0); }while(1); } : #include stdio.h #include conio.h #include malloc.h #include stdlib.h #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 typedef int Status; #define STACK_INIT_SIZE 100 //初始分配量 #define STACKINCREMENT 10 //存储空间的分配增量 typedef char ElemType; typedef ElemType OperandType; //操作数 typedef char OperatorType; typedef struct { ElemType *base; ElemType *top; int stacksize; }SqStack; Status InitStack(SqStack S) { //构造一个空栈S S.base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType)); if(!S.base) exit (OVERFLOW); S.top = S.base; S.stacksize = STACK_INIT_SIZE; return OK; } Status GetTop(SqStack S){ ElemType e; if (S.top == S.base) return ERROR; e = *(S.top-1); return e; } Status Push (SqStack S,ElemType e) { //插入元素e为新的栈顶元素 if (S.top - S.base = S.stacksize){ S.base = (ElemType *) realloc ( S.base, (S.stacksize + STACKINCREMENT) * sizeof(ElemType)); if(!S.base) exit (OVERFLOW); S.top = S.base + S.stacksize; S.stacksize += STACKINCREMENT; } *S.top++ = e; return OK; } Status Pop (SqStack S,ElemType e){ //若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR if(S.top == S.base) return ERROR; e = * --S.top; return OK; } char In(char c,char OP[]) { if(c=35 c=47) return 1; else return 0; } char OP[8]=; int m[7][7]={1,1,2,2,2,1,1, 1,1,2,2,2,1,1, 1,1,1,1,2,1,1, 1,1,1,1,2,1,1, 2,2,2,2,2,0,-1, 1,1,1,1,-1,1,1, 2,2,2,2,2,-1,0};//1 2 0 = -1 不存在 char Precede(char i,char j) { int a,b; char *p; for(p=OP,a=0;*p!='\0';p++,a++) if(*p==i) break; for(p=OP,b=0;*p!='\0';p++,b++) if(*p==j) break; if(m[a][b]==1) return ''; else if(m[a][b]==2) return ''; else if(m[a][b]==0) return '='; else return 'O'; } char Operate(char a,char theta,char b) { if(a47) a=atoi(a); if(b47) b=atoi(b); switch(theta) { case '+': return a+b; break; case '-': return a-b; break; case '*': return a*b; break; case '/': return a/b; break; } } OperandType EvaluateExpression() { SqStack OPTR,OPND; OperandType a,b,c; OperatorType theta; InitStack(OPTR); Push(OPTR,'#'); InitStack(OPND); c=getchar(); while (c!='#' || GetTop(OPTR)!='#') { if (!In(c,OP)) else switch(Precede(GetTop(OPTR),c)) { case '' : Push(OPTR,c); c = getchar(); break; case '=' : Pop(OPTR,c); c = getchar(); break; case '' : Pop(OPTR,theta); Pop(OPND,b); Pop(OPND,a); Push(OPND,Operate(a,theta,b)); break; } } return GetTop(OPND); } void main() { printf("(以#为结束符)\n"); printf("请输入：\n"); int a; a=(int)EvaluateExpression(); printf("%d",a); getch(); } : ls都正确 : C++ In Action这本书里面有表达式求值的详细项目分析. : 数据结构的书里面都有的,仔细看一下 : studyall123的只能对0到9的数字运算才有效,对于10以上的数字就不行!不知道有没有更好的方法! : 现在的人，连google一下都懒啊 : 实际上是按照逆波兰式的顺序让输入的表达式入栈，再根据运算符优先级来计算。 : lenrning!
让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：国际域名空间、虚拟空间、营销软件、网站建设、莱山网站维护、网站推广。
函数的递归调用
递归问题是一个说简单也简单，说难也有点难理解的问题.我想非常有必要对其做一个总结.
首先理解一下递归的定义，递归就是直接或间接的调用自身.而至于什么时候要用到递归，递归和非递归又有那些区别？又是一个不太容易掌握的问题，更难的是对于递归调用的理解.下面我们就从程序+图形的角度对递归做一个全面的阐述.
我们从常见到的递归问题开始:
1 阶层函数
#include iostream
using namespace std;
int factorial(int n)
{
if (n == 0)
{
return 1;
}
else
{
int result = factorial(n-1);
return n * result;
}
}
int main()
{
int x = factorial(3);
cout x endl;
return 0;
}
这是一个递归求阶层函数的实现。很多朋友只是知道该这么实现的，也清楚它是通过不断的递归调用求出的结果.但他们有些不清楚中间发生了些什么.下面我们用图对此做一个清楚的流程:
根据上面这个图，大家可以很清楚的看出来这个函数的执行流程。我们的阶层函数factorial被调用了4次.并且我们可以看出在调用后面的调用中，前面的调用并不退出。他们同时存在内存中。可见这是一件很浪费资源的事情。我们该次的参数是3.如果我们传递10000呢。那结果就可想而知了.肯定是溢出了.就用int型来接收结果别说10000，100就会产生溢出.即使不溢出我想那肯定也是见很浪费资源的事情.我们可以做一个粗略的估计:每次函数调用就单变量所需的内存为:两个int型变量.n和result.在32位机器上占8B.那么10000就需要10001次函数调用.共需10001*8/1024 = 78KB.这只是变量所需的内存空间.其它的函数调用时函数入口地址等仍也需要占用内存空间。可见递归调用产生了一个不小的开销.
2 斐波那契数列
int Fib(int n)
{
if (n = 1)
{
return n;
}
else
{
return Fib(n-1) + Fib(n-2);
}
}
这个函数递归与上面的那个有些不同.每次调用函数都会引起另外两次的调用.最后将结果逐级返回.
我们可以看出这个递归函数同样在调用后买的函数时，前面的不退出而是在等待后面的结果，最后求出总结果。这就是递归.
3
#include iostream
using namespace std;
void recursiveFunction1(int num)
{
if (num 5)
{
cout num endl;
recursiveFunction1(num+1);
}
}
void recursiveFunction2(int num)
{
if (num 5)
{
recursiveFunction2(num+1);
cout num endl;
}
}
int main()
{
recursiveFunction1(0);
recursiveFunction2(0);
return 0;
}
运行结果:
1
2
3
4
4
3
2
1
该程序中有两个递归函数。传递同样的参数，但他们的输出结果刚好相反。理解这两个函数的调用过程可以很好的帮助我们理解递归:
我想能够把上面三个函数的递归调用过程理解了，你已经把递归调用理解的差不多了.并且从上面的递归调用中我们可以总结出递归的一个规律：他是逐级的调用，而在函数结束的时候是从最后面往前反序的结束.这种方式是很占用资源，也很费时的。但是有的时候使用递归写出来的程序很容易理解，很易读.
为什么使用递归:
1 有时候使用递归写出来的程序很容易理解，很易读.
2 有些问题只有递归能够解决.非递归的方法无法实现.如:汉诺塔.
递归的条件:
并不是说所有的问题都可以使用递归解决，他必须的满足一定的条件。即有一个出口点.也就是说当满足一定条件时，程序可以结束，从而完成递归调用，否则就陷入了无限的递归调用之中了.并且这个条件还要是可达到的.
递归有哪些优点:
易读，容易理解，代码一般比较短.
递归有哪些缺点:
占用内存资源多，费时，效率低下.
因此在我们写程序的时候不要轻易的使用递归，虽然他有他的优点，但是我们要在易读性和空间，效率上多做权衡.一般情况下我们还是使用非递归的方法解决问题.若一个算法非递归解法非常难于理解。我们使用递归也未尝不可.如:二叉树的遍历算法.非递归的算法很难与理解.而相比递归算法就容易理解很多.
对于递归调用的问题，我们在前一段时间写图形学程序时，其中有一个四连同填充算法就是使用递归的方法。结果当要填充的图形稍微大一些时，程序就自动关闭了.这不是一个人的问题，所有人写出来的都是这个问题.当时我们给与的解释就是堆栈溢出。就多次递归调用占用太多的内存资源致使堆栈溢出，程序没有内存资源执行下去，从而被操作系统强制关闭了.这是一个真真切切的例子。所以我们在使用递归的时候需要权衡再三.
操作创建一个很短的回调函数，但又不想用 def 去写一个单行函数， 而是希望通过某个快捷方式以内联方式来创建这个函数。
当一些函数很简单，仅仅只是计算一个表达式的值时，可以使用 lambda 表达式来实现。比如：
使用lambda表达式跟下面定义的函数效果是一样的：
lambda 表达式，典型的使用场景是排序或数据reduce等：
尽管 lambda 表达式允许定义简单函数，但是它的使用是有限制的。只能指定单个表达式，它的值就是最后的返回值。
-:标记返回函数注释,信息作为.__annotations__属性提供,__annotations__属性是字典。键return是用于在箭头后检索值的键。但是在Python中3.5，PEP 484 - Type Hints附加了一个含义：-用于指示函数返回的类型。它似乎也将在未来版本中强制执行。
eg:
def test() - [1, 2, 3, 4, 5]:
pass
print(test.__annotations__)
输出：
{'return': [1, 2, 3, 4, 5]}
python的常用内置函数
1.abs() 函数返回数字的绝对值
abs(-40)=40
2. dict() 函数用于创建一个字典
dict()
{} #创建一个空字典类似于u={},字典的存取方式一般为key-value
例如u = {"username":"tom", "age":18}
3. help() 函数用于查看函数或模块用途的详细说明
help('math')查看math模块的用处
a=[1,2,3,4]
help(a)查看列表list帮助信息
4.dir()获得当前模块的属性列表
dir(help)
['__call__', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
5.min() 方法返回给定参数的最小值 /参数可以为序列
a= min(10,20,30,40)
a
10
6. next() 返回迭代器的下一个项目
it = iter([1, 2, 3, 4, 5])
next(it)
1
next(it)
2
7. id() 函数用于获取对象的内存地址
a=12
id(a)
1550569552
8.enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
a=["tom","marry","leblan"]
list(enumerate(a))
[(0, 'tom'), (1, 'marry'), (2, 'leblan')]
9. oct() 函数将一个整数转换成8进制字符串
oct(15)
'0o17'
oct(10)
'0o12'
10. bin() 返回一个整数 int 或者长整数 long int 的二进制表示
bin(10)
'0b1010'
bin(15)
'0b1111'
11.eval() 函数用来执行一个字符串表达式，并返回表达式的值
eval('2+2')
4
12.int() 函数用于将一个字符串会数字转换为整型
int(3)
3
int(3.6)
3
int(3.9)
3
int(4.0)
4
13.open() 函数用于打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写
f=open('test.txt')
14.str() 函数将对象转化为适于人阅读的形式
str(3)
'3'
15. bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False
bool()
False
bool(1)
True
bool(10)
True
bool(10.0)
True
16.isinstance() 函数来判断一个对象是否是一个已知的类型
a=5
isinstance(a,int)
True
isinstance(a,str)
False
17. sum() 方法对系列进行求和计算
sum([1,2,3],5)
11
sum([1,2,3])
6
18. super() 函数用于调用下一个父类(超类)并返回该父类实例的方法。super 是用来解决多重继承问题的，直接用类名调用父类方法
class User(object):
def__init__(self):
class Persons(User):
super(Persons,self).__init__()
19. float() 函数用于将整数和字符串转换成浮点数
float(1)
1.0
float(10)
10.0
20. iter() 函数用来生成迭代器
a=[1,2,3,4,5,6]
iter(a)
for i in iter(a):
... print(i)
...
1
2
3
4
5
6
21.tuple 函数将列表转换为元组
a=[1,2,3,4,5,6]
tuple(a)
(1, 2, 3, 4, 5, 6)
22.len() 方法返回对象（字符、列表、元组等）长度或项目个数
s = "playbasketball"
len(s)
14
a=[1,2,3,4,5,6]
len(a)
6
23. property() 函数的作用是在新式类中返回属性值
class User(object):
def __init__(self,name):
self.name = name
def get_name(self):
return self.get_name
@property
def name(self):
return self_name
24.type() 函数返回对象的类型
25.list() 方法用于将元组转换为列表
b=(1,2,3,4,5,6)
list(b)
[1, 2, 3, 4, 5, 6]
26.range() 函数可创建一个整数列表，一般用在 for 循环中
range(10)
range(0, 10)
range(10,20)
range(10, 20)
27. getattr() 函数用于返回一个对象属性值
class w(object):
... s=5
...
a = w()
getattr(a,'s')
5
28. complex() 函数用于创建一个复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数
complex(1,2)
(1+2j)
complex(1)
(1+0j)
complex("1")
(1+0j)
29.max() 方法返回给定参数的最大值，参数可以为序列
b=(1,2,3,4,5,6)
max(b)
6
30. round() 方法返回浮点数x的四舍五入值
round(10.56)
11
round(10.45)
10
round(10.45,1)
10.4
round(10.56,1)
10.6
round(10.565,2)
10.56
31. delattr 函数用于删除属性
class Num(object):
... a=1
... b=2
... c=3.
.. print1 = Num()
print('a=',print1.a)
a= 1
print('b=',print1.b)
b= 2
print('c=',print1.c)
c= 3
delattr(Num,'b')
print('b=',print1.b)
Traceback (most recent call last): File "", line 1, inAttributeError: 'Num' object has no attribute 'b'
32. hash() 用于获取取一个对象（字符串或者数值等）的哈希值
hash(2)
2
hash("tom")
-1675102375494872622
33. set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
a= set("tom")
b = set("marrt")
a,b
({'t', 'm', 'o'}, {'m', 't', 'a', 'r'})
ab#交集
{'t', 'm'}
a|b#并集
{'t', 'm', 'r', 'o', 'a'}
a-b#差集
{'o'}
数学相关
abs(a) : 求取绝对值。abs(-1)
max(list) : 求取list最大值。max([1,2,3])
min(list) : 求取list最小值。min([1,2,3])
sum(list) : 求取list元素的和。 sum([1,2,3]) 6
sorted(list) : 排序，返回排序后的list。
len(list) : list长度,len([1,2,3])
divmod(a,b): 获取商和余数。 divmod(5,2) (2,1)
pow(a,b) : 获取乘方数。pow(2,3) 8
round(a,b) : 获取指定位数的小数。a代表浮点数，b代表要保留的位数。round(3.1415926,2) 3.14
range(a[,b]) : 生成一个a到b的数组,左闭右开。range(1,10) [1,2,3,4,5,6,7,8,9]
类型转换
int(str) : 转换为int型。int('1') 1
float(int/str) : 将int型或字符型转换为浮点型。float('1') 1.0
str(int) : 转换为字符型。str(1) '1'
bool(int) : 转换为布尔类型。 str(0) False str(None) False
bytes(str,code) : 接收一个字符串，与所要编码的格式，返回一个字节流类型。bytes('abc', 'utf-8') b'abc' bytes(u'爬虫', 'utf-8') b'xe7x88xacxe8x99xab'
list(iterable) : 转换为list。 list((1,2,3)) [1,2,3]
iter(iterable)： 返回一个可迭代的对象。 iter([1,2,3]) list_iterator object at 0x0000000003813B00
dict(iterable) : 转换为dict。 dict([('a', 1), ('b', 2), ('c', 3)]) {'a':1, 'b':2, 'c':3}
enumerate(iterable) : 返回一个枚举对象。
tuple(iterable) : 转换为tuple。 tuple([1,2,3]) (1,2,3)
set(iterable) : 转换为set。 set([1,4,2,4,3,5]) {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) {1,2,3}
hex(int) : 转换为16进制。hex(1024) '0x400'
oct(int) : 转换为8进制。 oct(1024) '0o2000'
bin(int) : 转换为2进制。 bin(1024) '0b10000000000'
chr(int) : 转换数字为相应ASCI码字符。 chr(65) 'A'
ord(str) : 转换ASCI字符为相应的数字。 ord('A') 65
相关操作
eval****() : 执行一个表达式，或字符串作为运算。 eval('1+1') 2
exec() : 执行python语句。 exec('print("Python")') Python
filter(func, iterable) : 通过判断函数fun，筛选符合条件的元素。 filter(lambda x: x3, [1,2,3,4,5,6]) filter object at 0x0000000003813828
map(func, *iterable) : 将func用于每个iterable对象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) [6,8,10]
zip(*iterable) : 将iterable分组合并。返回一个zip对象。 list(zip([1,2,3],[4,5,6])) [(1, 4), (2, 5), (3, 6)]
type()：返回一个对象的类型。
id()： 返回一个对象的唯一标识值。
hash(object)：返回一个对象的hash值，具有相同值的object具有相同的hash值。 hash('python') 7070808359261009780
help()：调用系统内置的帮助系统。
isinstance()：判断一个对象是否为该类的一个实例。
issubclass()：判断一个类是否为另一个类的子类。
globals() : 返回当前全局变量的字典。
next(iterator[, default]) : 接收一个迭代器，返回迭代器中的数值，如果设置了default，则当迭代器中的元素遍历后，输出default内容。
reversed(sequence) ： 生成一个反转序列的迭代器。 reversed('abc') ['c','b','a']