Python version 3.7版本

00.命令行交互

命令行交互

Perl

Python

perl -e      #Unix/Linux/Windows/DOS

直接命令行输入Python回车，就可以编码运行代码

0.变量

区别：Python变量前没有区分是普通变量还是列表（数组）的符号，Perl有区分,$bianliang   @shuzu  %hash

相同：命名要求一致，字母数字下划线

1.print输出

二者通用格式：print（“字符串”）；

Perl：

print（“字符串1”."字符串2".$bianliang(任何变量都可以)."\n"）；     #无自带换行符

Python：

print（“字符串1”+“字符串2”+字符变量1+str（非字符变量2））；  #a="map" 字符变量  a=1非字符变量     #自带换行符

对于列表和字典，print（块1，块2，块3） #可以用逗号隔开一起输出，输出结果为各模块之间是空格

2.注释

二者相同都用#

3.Perl的数组 <=> Python的列表

 

Perl数组(@arr)

Python列表

定义

@shuzu=(1,5,'trek','amil');

@shuzu0=(3..18);  #3到18，步长为1   #创建数值数组

list1=[1,5,'trek','amil']

numbers=list(range(1,6)) #创建数值列表，默认步长为1，数值为[1,6）左闭右开表，即1,2,3,4,5

even_numbers=list(range(2,11,2)) #创建数值列表，步长为2，数值为，2,4,6,8,10

函数range()几乎能够创建任何需要的数字集，eg:5**2=25  平方计算等

字符串互转数组（列表）

#转字符串为数组

$var_names = "google,taobao,runoob,weibo";  @names = split(',', $var_names);

#转数组为字符串

$string2 = join( ',', @names );

str= list('trek')  #['t','r','e','k']  #转字符串为列表

list1``=``[``'ak'``,``'uk'``,``4``]

list2``=``[``str``(i) for i in list1] #使用列表推导式把列表中的单个元素全部转化为str类型

list2 #查看转化后的列表 [``'ak'``, 'uk'``, '4'``]

list3``=``' '``.join(list2) #把列表中的元素放在空串中，元素间用空格隔开

list3 #查看生成的长串 'ak uk 4'

索引

从0开始，索引-1指定为列表最后一个元素，eg:  $shuzu[-1]

$max_index=$#shuzu;  #数组最后一个元素的索引值

从0开始，索引-1指定为列表最后一个元素，eg:list1[-1]

排序

@shuzu = sort(@shuzu);   #数组排序是根据 ASCII 数字值来排序。所以我们在对数组进
行排序时最好先将每个元素转换为小写后再排序  #不改变原数组排序

@shuzu1= sort {lc($a) cmp lc($b)} @shuzu #将每个元素转换为小写后再按字母顺排序，

调整$a与$b位置为倒序排序

@shuzu1= sort {$a <=>$b} @shuzu  #对数字从小到大排序，调整$a与$b位置为从大到

小排序

@shuzu = reverse(@shuzu); #逆序，不改变原列表

sorted(list1) #按字母顺序临时性排序，不改变原列表排序

#必须用这种格式，list1.sorted()行不通

sorted(list1，reverse=True) #按字母倒序临时性排序，不改变原列表排序

#必须用这种格式，list1.sorted()行不通

list1.reverse() #逆序，永久性排序

list1.sort() #按字母顺序永久性排序，无法恢复到原来的排序

#必须用这种格式，sort（list1）行不通

list1.sort(reverse=True) #按字母倒序永久性排序，无法恢复到原来的排序

计算

$size_arr=@shuzu;  #计算数组元素个数

len(list1) #计算列表元素个数

min(numbers)  #求最小值

max(numbers)  #求最大值

sum(numbers)  #求和

输出

print($shuzu[0]);

print(list1[0]);

print(list1[0],list[1])  #结果为：1 5

末尾添加元素

push(@shuzu,"字符串"or变量or数组or1..100) 

list1.append（'tool'）

合并

@numbers = (1,3,(4,5,6));

@arr0=(@shuzu,@shuzu0);

 

末尾删除元素

$num=pop(@shuzu) #弹出数组最后一个元素，并返回它

name=list1.pop()  #删除列表末尾元素，并让你能接着使用此元素 

删除索引位置元素

pop不能；

splice (@array, 2, 1)  #索引2处，替换一个为空，即删除索引2处元素，后边元素自动向前补充

delete $array[2]  #删除数组第3个元素，当index大于数组长度时，函数delete对数组没影响；
delete删除元素后, index后面的元素并不会主动往前移动，该元素删除后，在array还留有一个undef的元素，显然删除得不够干净。

name=list1.pop(2)#删除列表任意索引位置的元素，并让你能接着使用此元素;

list1[2:3]=''  #将索引2处元素替换为空，后边远元素前移

del list1[2]  #删除列表第3个元素

删除指定元素

name=list1.remove(‘tool’) #删除列表中的某个指定元素（如果有重复元素，

只删除索引位置靠前的那个），并返回它可以使用

开头删除元素

$num=shift(@shuzu) #弹出数组第一个值，并返回它。数组的索引值也依次减一

没有对应的类似函数

开头添加元素

unshift(@shuzu,"字符串"or变量or数组or1..100)

#将元素放在数组前面，并返回新数组的元素个数

没有对应的类似函数

索引位置添加元素

splice (@array, 1, 0, "Hello") #在1索引位置插入Hello，其他元素一次后移

list1.insert（0,'tool'）#列表索引0处插入元素，原0,1等都往后移动一位

str1 = ["a","b","c"] ；str1[2:2] = "f"  #插入新的索引2，原索引2依次往后推

print("插入新的索引2结果 :",str1)  #结果：插入新的索引2结果 : ['a', 'b', 'f', 'd', 'e']

修改元素

$shuzu[1]="8" ;#单个位置替换（修改）元素

list1[1]="8" ； #单个位置替换（修改）元素

修改元素（切片|拼接）

splice(@shuzu0, 5, 5, 21..25); #从数组索引值为5（即第6个元素）开始（包含替换

的起始位置）替换5个元素，为21..25； #1个或多个替换（修改）元素

@retval = splice (@array, skipelements, length, @newlist);

拼接函数可以向列表（数组）中间插入元素、删除子列表或替换子列表。

参数skipelements是拼接前跳过的元素数目，length是被替换的元素数，newlist是将要拼接进来的列表。

当newlist的长度大于length时，后面的元素自动后移，反之则向前缩进。

当length=0时，就相当于向列表中插入元素，而形如语句 splice (@array, -1, 0, "Hello");

即向数组末尾添加元素。

当newlist为空时，就相当于删除子列表，这时，如果length为空，就从第skipelements个元素后全部

删除。所以删除最后一个元素则为：splice (@array, -1);这种情况下，返回值为被删去的元素列表。

splice（@array，0,0） #删除数组所有元素

#替换索引2到最后一个索引为'd', 'e'

str1 = ["a","b","c"]；str1[2:] = list("de")

print("替换索引>=2结果 :",str1)  #结果：替换索引>=2结果 : ['a', 'b', 'd', 'e']

#替换索引2-3（索引2-3替换为"g","h","i"，原索引4到最后依次往后推）

str1=['a', 'b', 'f', 'd', 'e']；str1[2:4] = ["g","h","i"]

print(str1)     #结果：['a', 'b', "g","h","i", 'e']

#删除列表所有元素
str1[:] = []

切片

切片，处理列表部分元素，如下

@shuzu2=@shuzu[2,4,6,7,-3,-1]  #数组索引需要指定有效的索引值，可以是正数后负数，

每个索引值使用逗号隔开。

@shuzu3=@shuzu[2..-1] #如果是连续的索引，可以使用 .. 来表示指定范围。#左闭右闭

切片，处理列表部分元素，如下

list2=list1[:]  #等价于list1  #可用于复制列表，因为list2=list1  不是复制，只是同
个列表有两个标签，修改其中任何一个标签，都会更改二者的列表信息；

list2=list1[0:-3]  #左闭右开，切取列表第1位，到倒数第4位

list2=list1[1:] #从列表第2位到最后

list2=list1[:-1] #从列表第1位开始到倒数第2位

元组

 

不可变的列表=》“元组”“tuple”，元组比列表更简单的数据结构，如下

tuple1=(250,50)  #tuple1[0]=400 不允许，会报错

tuple1=(400,50)  #给元组变量赋值是合法的，不会报错，之前元素被覆盖

唯一元素数组（列表）

 

每个元素都唯一的列表=》集合  set(list1),不改变原列表

4.for循环

Perl：

for( $a = 0; $a < 10; $a = $a + 1 ){

　　print "a 的值为: $a\n";

}

遍历一维哈希：

foreach my $key(sort {$hash{$b}<=>$hash{$a}}  keys %hash){      #对value值按照数字大小进行逆序排序

　　print $key."t".$hash{$key}."n";

}

遍历二维哈希：使用$hash{$key1}{$key2}=$value;

foreach my $key1(sort keys %hash){    #首先对key1进行排序

　　foreach my $key2(sort {$hash{$key1}->{$b}<=>$hash{$key1}->{$a}}  keys  %{$hash{$key1}}){      #对value值按照数字大小进行逆序排序

　  #foreach my $key2(sort {$a<=>$b}  keys %{$hash{$key1}}){                                                              #对key2按照数字大小进行排序,正顺序排序

　　　　print $key1."t".$key2."t".$hash{$key1}->{$key2}."n";

　　}

}

Python：

for list_v in list1:    #遍历列表

　　print(list_v);

　　#break       #退出while循环，不再运行循环中余下代码

　　#continue  #终断单次循环，进入下一个循环

print("thank you,everyone\n");

列表解析

squares=[value**2 for value in range(1,11)]    #[1,4,9,16,25,36,49,64,81,100]

for key1,value1 in alien.items():      #遍历字典所有键值对

　　print("\nKey: "+ key1)

　　print(Value: " + value1)

for key1 in alien.keys():                   #遍历字典中的所有键

#for key1 in alien:                           #遍历字典中的所有键，遍历字典时，默认遍历所有的键

　　print(key1.title())

for key1 in sorted(alien.keys()):      #按顺序遍历字典中的所有键

　　print(key1.title())

for  value1 in alien.values():           #遍历字典中所有值，没有删除重复，都列出

　　print(value1.title())

for  value1 in set（alien.values()）:           #遍历字典中所有值，删除重复，值唯一，set（集合）类似于列表

　　print(value1.title())

注意：for能遍历列表，但不能修改列表，否则Python难以跟踪其中元素；

5.if条件判断

注意：Perl和Python都是只要一个在if整体模块中，只要有一个if 或者elsif|elif判断是真，下边的条件判断就会跳过去，不在运行；

Perl：

if(条件判断){

}

if(条件判断){

}else{    #可省略

}

if(条件判断){

}elsif（条件判断）{

}else{    #可省略

}

条件判断常用：

True         #布尔值

not True   #布尔值

! True       #布尔值

False       #布尔值

数字 0、字符串 '0' 、 "" 、空数组list ()  和 undef 为 false

> ; >= ; < ; <= ; ==；!=；<=>比较，返回0或者 1或者 -1；    #数值比较大小     ==    #判断是否相等；  ！=  #判断是否不相等；

bt ; be ; lt ;  le ; eq ; ne ; cmp比较，返回0或者 1或者 -1；    #字符串比较大小

=~  #匹配

&& #且

||  #或者

Python：

if 条件判断：

　　执行语句1

　　执行语句2

if 条件判断：

　　执行语句

else：             #可省略

　　执行语句

if 条件判断：

　　执行语句

elif 条件判断：

　　执行语句

else：             #可省略

　　执行语句

条件判断常用：

bianliang1=True  #直接布尔值

bianliang2=False #直接布尔值

列表为空，即list1=[],则 if list1 ：  判断为False

==    #判断是否相等；  #区分字母大小  #适用于字符串、数值

!=     #判断是否不等；  #区分字母大小  #适用于字符串、数值

car=“Audi”; car.lower()=="audi"  #都转化为小写，再比较；

< ; <=; >; >=; ==；!= ; #比较数值大小

4 % 3 == 1  #求模运算符%，两个数相除返回余数

and  #且

or     #或

list1=['1','buht','4'];   "buht" in list1  #True  #判断某元素是否在列表中

list1=['1','buht','4'];   "8" not in list1  #True  #判断某元素是否在列表中

6.Perl的哈希hash<=> Python字典

Perl：

%data= ('google'=>'google.com', 'runoob'=>'runoob.com', 'taobao'=>'taobao.com');

print "\$data{'google'} = $data{'google'}\n";

print "\$data{'runoob'} = $data{'runoob'}\n";

print "\$data{'taobao'} = $data{'taobao'}\n";

一个键对应一个值，值可以是Perl中任何对象（eg:数字、字符串、数组、哈希hash）；所有的键之间必须唯一，所有的值可不唯一；

$data{'google1'} = 'google1.com';   #添加键值对 

%data=()  #创建空哈希

$data{'google'} = 'google1.com';   #修改哈希中的值 

delete $data{'taobao'};    # 删除哈希中的元素（键值对）

Python：

alien_0={'color':'green','points':5}   #定义字典，方式1

alien_0={　　　　　　　　           #定义字典，方式2，多了个最后的逗号，大括号位置必须这样放，注意缩进格式固定

　　'color':'green',

　　'points':5，

　　}

print("alien_0['color'] = "+alien_0['color']);

print("alien_0['points'] = "+alien_0['points']);

print(alien_0['color'],alien_0['points'])  #结果为：green 5

一个键对应一个值，值可以是Python中任何对象（eg:数字、字符串、列表、字典）；所有的键之间必须唯一，所有的值可不唯一；

alien_0['x_position']=0    #添加键值对   #键值对的添加顺序跟添加顺序不同，因为字典关注的是键值关联关系

alien_0={}                       #创建空字典

alien_0['color']='yellow'   #修改字典中的值，由green变yellow

del alien_0['color']          #删除键值对

#嵌套

#嵌套-字典列表（列表中嵌套字典）------------------------------>经常需要在列表中包含大量的字典，而其中每个字典都包含特定对象的众多信息

alien_0={'color':'green','points':5}

alien_1={'color':'yellow','points':7}

alien_2={'color':'red','points':8}

aliens=[alien_0,alien_1,alien_3]

for alien in aliens:

　　print(alien)

#嵌套-列表字典（字典中嵌套列表）------------------------------->每当需要在字典中将一个键关联到多个值时，都可以在字典中嵌套一个列表【即，字典是键值一对一，值用列表，就相当于键值一对多】

pizza={                                                            #一个物体，对应多个方面的信息

　　‘crust’：‘thick’，　　　　　　　　　　   #披萨皮厚薄

　　‘toppings’:['mushrooms','extra cheese'],   #披萨配料

　　}

#嵌套-字典字典（字典中嵌套字典） -------------------------------->内部嵌套的众多字典，一般结构都相同，因为，这样使得后续的处理（eg:for循环）简单，否则会很复杂

users ={

　　'A':{

　　　　'first':'albert',

　　　　'last':'einstein',

　　　　'loacation':'paris',

　　　　},

　　'B':{

　　　　'first':'marie',

　　　　'last':'curie'

　　　　'location':'princeton',

　　　　},

　　}

7.指引用户输入、获取用户输入

Perl：

获取用户命令行输入:

$input=     
@ARGV#命令行输入的东西，按空格分开，一次存入数组

输出：

print STDOUT << "EOF"; #EOF 是一个标记的名字，自定义标记名称

Python：

message = input（"Tell me something,and I will repeat it back to you: "）  #将获取内容存储为字符串；#冒号后面，包含一个空格，可将提示与用户输入分开，让用户清楚的知道其输入始于何处

print(message)

message = int（message） #如果message获取的内容是数值，则可以用int（）转为数值

8.while循环

Perl：

Python：

while 条件判断：

　　执行语句

　　#break       #退出while循环，不再运行循环中余下代码

　　#continue  #终断单次循环，进入下一个循环

while能遍历列表同时修改列表；for能遍历列表，但不能修改列表，否则Python难以跟踪其中元素；

while能将列表和字典结合起来使用，可收集、存储并组织大量输入，供以后查阅和显示；

9.python函数