python一维数组定义

❶ python包含不同长度的list的一维数组用0填充统一长度

matrix=[[1],
[1,2],
[1,2,3],
[1,2,3,4],
[1,2,3,4,5],
[3,4,5],
[2,3,4,5],
]
#现在需要将矩阵中所有的列表长度对齐到最长的列表的长度5，末尾全部用0填充
max_len=max((len(l)forlinmatrix))
new_matrix=list(map(lambdal:l+[0]*(max_len-len(l)),matrix))
print(new_matrix)

❷ Python中定义一个a[100][100]的二维数组怎么写，输出a[i][j]元素应该怎么写

摘要 一维数组只有一个下标，称为一维数组，其数组元素也称为单下标变量。在实际问题中有很多量是二维的或多维的，因此python允许构造多维数组。那么python如何定义二维数组呢?一起来了解下吧：

❸ python 数组和列表的区别

Python没有数组：
1.
只有元组(tuple)和列表(list)；
2.
元组一旦创建不可改变，例如：aa=tuple(1,2,3)；
3.
元组不能追加(append)元素，弹出(pop)元素等；
4.
只能对元组中的元素进行索引aa[0]，不能对其中的元组进行赋值aa[0]=8；
5.
使用元组的好处在于对元组进行操作更为高效，适合存放一组常量；
6.
而上述的众多不可以，使用列表list是可以的。

❹ 用Python3实现表达式求值

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(top<MAX) { 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"，那么结束程序，否则继续循环。 完整的程序代码如下： #include<stdio.h> #include<conio.h> #include<stdlib.h> #define ERR -1 #define MAX 100 /*定义堆栈的大小*/ int stack[MAX]; /*用一维数组定义堆栈*/ int top=0; /*定义堆栈指示*/ int push(int i) /*存储运算数,入栈操作*/ { if(top<MAX) { 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(a>47) a=atoi(&a); if(b>47) 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!

❺ python中向一维数组添加元素的方法

供参考：

old_array=['','']
new_array=['magnet:?xt=urn:btih:'+iforiinold_array]
print(new_array)

❻ python数组求和

在数组和矩阵中使用sum: 对数组b和矩阵c,代码b.sum()，np.sum(b),c.sum(),np.sum(c)都能将b、c中的所有元素求和并返回单个数值。

但是对于二维数组b，代码b.sum(axis=0)指定对数组b对每列求和，b.sum(axis=1)是对每行求和，返回的都是一维数组（维度降了一维）。

而对应矩阵c，c.sum(axis=0)和c.sum(axis=1)也能实现对列和行的求和，但是返回结果仍是二维矩阵。

# 定义函数，arr 为数组，n 为数组长度，可作为备用参数，这里没有用到。

def_sum(arr,n):

# 使用内置的 sum 函数计算。

return(sum(arr))

# 调用函数

arr=[]

# 数组元素

arr=[12,3,4,15]

# 计算数组元素的长度

n=len(arr)

ans=_sum(arr,n)

# 输出结果

print('数组元素之和为',ans)

(6)python一维数组定义扩展阅读：

python数组使用：

python 数组支持所有list操作，包括 .pop、.insert 和 .extend。另外，数组还提供从文件，读取和存入文件的更快的方法，列如如 .frombytes 和 .tofile，如下所示我们定义一个数组。

from array import arrayarr=array('d',(a for a in range(5)))print(arr)。

arr=array('d',(a for a in range(5)))从这个代码中可以看出，一个数组的定义需要传入的不只是值还有类型。

可以是(must be c, b, B, u, h, H, i, I, l, L, f or d)。

❼ python 怎么把字典的值变为一维数组

一、创建字典
字典由键和对应值成对组成。字典也被称作关联数组或哈希表。基本语法如下：
复制代码代码如下:
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
也可如此创建字典：
复制代码代码如下:
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };
注意：
每个键与值用冒号隔开（:），每对用逗号，每对用逗号

❽ 什么是数组的维度，python 的ndim的使用

数组的维度就是一个数组中的某个元素，当用数组下标表示的时候，需要用几个数字来表示才能唯一确定这个元素，这个数组就是几维。numpy中直接用 * 即可表示数与向量的乘法，参考python 2.7的一个例子：inport numpy as np a = np.array([1,2,3,4]) # 向量 b = 5 # 数 print a*b ++++++++++++ [5,10,15,20]

❾ python如何定义数组

Python数组还有一个变态的使用方法，就是调用时可以不按参数顺序，对于我们掌握怎样正确创建Python数组是很有帮助的，而且也可从中学到不少编程技巧，例如委托和模板方法。希望大家一起研究下。在ubuntu中，更加是必须的一种脚本引擎，所以有必要去学习一下，这里的文章只针对有一定编程基础，最好是比较熟悉php或javascript的用户，如果没任何基础的新手建议找更详细的教程去学习。Python数组的变量是不需要定义的，这方面和php一样，它比javascript还是宽松，不过它是用缩进作为段落标识的，作为习惯了C语言风格语法的人，可能一开始会很不习惯使用。但细一想，其实也是很正常，很合理的。虽然Python在面向过程/面向对象方面也是很宽松，但实际上一般的程序都是一个主入口。然后不断调用其它类库或函数，所以用缩进的方式并无不妥，那样一方面要求用户写代码时要规范，另一方面反向省去了多余的{}。与C语言风格相比，Python主要语法特点而下：变量、字符串在python中，所有变量都是对象，数组其实是一个链表，并且可以进行相应的链表操作。对于普通数据类型，定义/赋值方法都是一样的，这里不作介绍，python的字符串方面有些特别，这里介绍一下。python对字符串用 [']["] 括起含义是一样的，同样对特殊字符使用 [\] 进行转义不过它有一个很特别的语法就是：[''']三引号，它用于括起分多行的字符串，实际是这也可以作为它的多行注解，如：#!/usr/bin/python #python source class python: def Hello(self): print 'Hello' def count(n): in=0 while(in<=n): inin=in+1 print in //buile by G++ or VC++ //C++ Source #include <iostream> int main() { class python { public: void Hello(void) { cout<<"Hello"<<endl; } void count(int n) { int in=0; while(in<=n) { inin=in+1; cout<<in<<endl; } } }; return 0; } python数组实际不是数组，而是一个list对象，如果要参考它的用法，可以参考这个对象的方法。需要注意的是，python数组实际是一个链表，因此定义后不能像php之类语言一样，直接在后面追加元素，而是需要用操作链表的方法操作。在上述例子中：如果用 arr[2] = 'ccccc' 可以改变第三个元素的值，但如果用 arr[3] = 'dddd' 增加一个元素是会指错的，应该用：arr.append('ddddd') 或 arr.insert(任意位置, 'dddd') 增加元素。对于多维数组，定义方式为： arr = [[]] * 3 它定义的是：[[], [], []]，也可以用 arr = [[] for i in range(3)] 对于数组和字符串等常用操作，后面会有一章专门介绍，这里就不在列举更多的使用方法。python数组实际不是数组，而是一个list对象，如果要参考它的用法，可以参考这个对象的方法。需要注意的是，python数组实际是一个链表，因此定义后不能像php之类语言一样，直接在后面追加元素，而是需要用操作链表的方法操作。在上述例子中：如果用 arr[2] = 'ccccc' 可以改变第三个元素的值，但如果用 arr[3] = 'dddd' 增加一个元素是会指错的，应该用：arr.append('ddddd') 或 arr.insert(任意位置, 'dddd') 增加元素。对于多维数组，定义方式为： arr = [[]] * 3 它定义的是：[[], [], []]，也可以用 arr = [[] for i in range(3)] 对于数组和字符串等常用操作，后面会有一章专门介绍，这里就不在列举更多的使用方法。

❿ python 中Data[1][0]/100是什么意思

将Data中第2行的第一个值除以100