python - 是程序喵哇

python安装

3的版本---企业基本都是使用此版本

3.7版本

3.10版本（最高版本）

2的版本---框架（rf)

安装和变量的配置

1、下载好指定版本后--双击安装即可

2、3版本--path选项（自动配置环境变量）

winds10系统--新建（一个空位就是一个变量）

winds7系统--集合（末尾加上;分号后面加你的变量）

2版本--必须自己手动配置环境变量

建议--自己配置

安装配置完成后--验证

dos窗口中：C:\Users\Administrator>python

Python 3.7.7 (tags/v3.7.7:d7c567b08f, Mar 10 2020, 10:41:24) [MSC v.1900 64 bit (AMD64)] on win32

Type "help", "copyright", "credits" or "license" for more information.

2、prcharm安装--客户端

2019版本--不需要破译码

20,21,22都是需要破译码

3、使用

1、先创建一个新的文件夹--存储你所有的项目

2、在创建项目

3、项目-包-目录-多种格式的文件

.py文件--模块

项目--有N个目录-有N个包-包或者目录中-N个文件(模块）-

有N个变量，类，方法，函数等

1、python3--可以不需要

python2--新创建的文件中打头：#coding=utf-8 字符集编码格式

2、输出 print

python3--print(1)

python2--print 1

3、中文

python3--可以直接对中文进行输出不需要转译（特殊情况需要）print('多测师')

python2--中文需要转译后才能进行输出 print u'多测师'

一、python中的输出语句：print()

self:对象本身、实例方法5

*args：可变长元组、可以接收0个或多个参数

sep=' '：代表的是输出多个内容的分隔符、默认值为空格

end='\n'：代表的是输出内容后的结尾符、默认值为\n(备注：\n代表的是换行符)

file=None：代表的是文件对象、可以将输出的内容写入到文件对象中

'实例1：直接输出单个内容'

print('令狐冲去北京砍柴') #运行结果位：令狐冲去北京砍柴

'实例2：同时输出多个内容'

print('张三','李四') #运行结果位：张三李四

'实例3：同时输出多个内容且自定义sep参数值'

print('张三','李四',sep='♥') #运行结果为：张三♥李四

'实例4：多个print同时执行且自定义end参数值'

'end取默认值'

print('张三')

print('李四')

运行结果为：张三

李四

'end取自定义值'

print('张三',end='')

print('李四')

运行结果为：

张三李四

'实例5：直接输出变量'

str1 = '张三'

print(str1) #运行结果为：张三

二、python中的格式化输出

'%s :字符串 (采用str()的显示)'

str1 = '令狐冲'

print('%s去北京砍柴'%(str1)) #备注：%s相当于是占位符

'运行结果为：令狐冲去北京砍柴'

'%c :单个字符'

str1 = '令'

str2 = '令狐冲'

print('%c去北京砍柴'%(str1)) #运行结果为：令去北京砍柴

print('%c去北京砍柴'%(str2)) #运行结果为：报错

'%d:十进制整数'

num1 = 5

print('令狐冲砍了%d吨柴'%(num1)) #运行结果为：令狐冲砍了5吨柴

'%i :十进制整数'

num1 = 5

print('令狐冲砍了%i吨柴'%(num1)) #运行结果为：令狐冲砍了5吨柴

'%o:八进制整数'

num1 = 8

print('result is %o'%(num1)) #运行结果为：result is 10

'%x:十六进制整数'

num1 = 10

print('result is %x'%(num1)) #运行结果为：result is a

print('result is %X'%(num1)) #运行结果为：result is A

'%f:浮点数'

num1 = 88

print('result is %f'%(num1)) #运行结果为：result is 88.000000

'%% :字符"%'

num1 = 5

print('令狐冲砍的柴占全北京的%i%%'%(num1))

'运行结果为：令狐冲砍的柴占全北京的5%'

'实例1：'

user = '张三'

num = 10

print('尊敬的%s用户,您的余额已不足%s元'%(user,num))

'运行结果为：尊敬的张三用户,您的余额已不足10元'

'实例2：'

user = '张三'

num = 10

print('尊敬的%s用户,您的余额已不足%s元'%(user,user))

'运行结果为：尊敬的张三用户,您的余额已不足张三元'

三、python中的注释

注释的作用：

1、被注释的代码将不会被运行

2、增强代码的可读性

注释的方法：

1、#号注释：注释单行

2、段落注释：选中被注释的代码+ctrl+/===》段落注释

3、单引号注释

4、双引号注释

5、三引号注释

四、python中的输入函数：input

user = input('请输入您的账号：')

if user == '张三':

print('会员用户')

else:

print('渣渣')

注意点：

1、在python里面一个等于是赋值、两个等于是恒等

2、if条件后面需要接冒号，if条件成立后执行的代码块需要空一格tab键

3、input函数会将所有输入的内容转换成字符串存储

user = input('请输入您的账号：')

if user == 'duoceshi':

pwd = input('请输入您的密码：')

print(type(pwd)) #运行结果为：

pwd = int(pwd)

print(type(pwd)) # 运行结果为：

if pwd == 123456:

print('登录成功')

else:

print('登录失败')

else:

print('请输入正确的账号')

整型转换成字符串：str()

num = 1

print(type(num)) #运行结果为：

num = str(num)

print(type(num)) #运行结果为：

字符串转换成整型：int()

str1 = '1'

print(type(str1)) #运行结果为：

str1 = int(str1)

print(type(str1)) #运行结果为：

五、python中的变量命名规则

1、变量是由数字、字母、下划线组成

2、不能以数字开头、数字开头直接报错

3、建议不要使用关键字、或者函数进行命名

备注：使用关键字命名则直接报错、使用函数命名不会报错但会导致该函数失效

4、建议不要使用大写字母开头、在python中大写字母一般用来定义类

5、下滑线开头的变量一般为保护变量、私有变量

单下划线：只能允许其本身与子类进行访问

双下划线：类本身进行访问了，连子类也不可以

'正确的命名'

user = '张三'

user1 = '李四'

user_1 = '王五'

'错误的命名'

1user = '张三'

user% = '王五'

1_user = '李四'

if = '赵六' #备注：关键字命名

特殊含义命名

User = '张三' #备注：大写字母用来定义类

_user = '李四' #备注：单下划线用来定义保护变量

__user = '王五' #备注：双下划线用来定义私有变量

str = '赵六' #备注：以函数进行命名

六、Python常见的运算操作：算数运算符

a = 2

b = 5

print(a+b) #运行结果为：7

print(a-b) #运行结果为：-3

print(a*b) #运行结果为：10

print(a/b) #运行结果为：0.4

print(b%a) #运行结果为：1 备注：取余数

print(a**b) #运行结果为：32 备注：代表的是a的b次方

print(a//b) #运行结果为：0 备注：取商的整数部分

七、Python常见的运算操作：赋值运行符

a = 1

b = 2

a+=b #相当于a=a+b 运行结果为：3

a-=b #相当于a=a-b 运行结果为：-1

a*=b #相当于a=a*b 运行结果为：2

a/=b #相当于a=a/b 运行结果为：0.5

a%=b #相当于a=a%b 运行结果为：1

a**=b #相当于a=a**b 运行结果为：1

a//=b #相当于a=a//b 运行结果为：0

print(a)

题目：将变量a和b的值进行互换

第一种方法

a = 1

b = 2

c = a

a = b

b = c

print(a) #运行结果为：2

print(b) #运行结果为：1

第二种方法：

a = 1

b = 2

a,b=b,a

print(a)

print(b)

八、Python常见的运算操作：比较运行符

a = 1

b = 2

print(a==b) #运行结果为：False

print(a!=b) #运行结果为：True

print(a>b) #运行结果为：False

print(a<b) #运行结果为：True

print(a>=b) #运行结果为：False

print(a<=b) #运行结果为：True

print(a>b and a<b) #运行结果为：False

print(a>b or a<b) #运行结果为：True

九、Python常见的运算操作：逻辑运行符

'逻辑与(and):当and左右为数值类型时'

'备注：在python中数值为0则为False'

'实例1：'

a = 1

b = 2

print(a and b) #运行结果为：2

'实例2：'

a = 1

b = 2

print(b and a) #运行结果为：1

'实例2：'

a = 0

b = 1

print(a and b) #运行结果为：0

'逻辑与(and):当and左右为非数值类型时'

'备注：在python中非数值类型值为空则为False'

'实例1：'

str1 = '张三'

str2 = '李四'

print(str1 and str2) #运行结果为：李四

print(str2 and str1) #运行结果为：张三

'实例2：'

str1 = ''

str2 = '张三'

print(str1 and str2) #运行结果为：空

print(str2 and str1) #运行结果为：空

'逻辑与(and):当and左右为条件时'

a = 1

b = 2

print(a>b and a<b) #运行结果为：False

print(a!=b and a<b) #运行结果为：True

'逻辑或(or):当or左右为数值类型时'

'实例1：'

a = 1

b = 2

print(a or b) #运行结果为：1

print(b or a) #运行结果为：2

'实例2：'

a = 0

b = 1

print(a or b) #运行结果为：1

print(b or a) #运行结果为：1

'逻辑或(or):当or左右为非数值类型时'

'实例1：'

str1 = ''

str2 = '张三'

print(str1 or str2) #运行结果为：张三

print(str2 or str1) #运行结果为：张三

'实例2：'

str1 = '张三'

str2 = '李四'

print(str1 or str2) #运行结果为：张三

print(str2 or str1) #运行结果为：李四

'逻辑或(or):当or左右为条件时'

a = 1

b = 2

print(a>b or a<b) #运行结果为：True

print(a!=b or a<b) #运行结果为：True

print(a>b or a>=b) #运行结果为：False

'逻辑非(not):'

a = 1

b = 2

print(not a and b) #运行结果为：False

print(not(a>b) and a<b) #运行结果为：True

十、python遍历

for in 遍历字符串，列表，元组，字典

range()函数 for in range()

python中所有的标点符号：英文

for i in range() 必须要给参数：数字整形

for i in range(5) 1个值表示是位数：0 1 2 3 4

for i in range(1,5) 2个值表示：起始和结束值 1起始 5是结束

1 2 3 4（不包含结束值）

for i in range(1,5,2)3个值表示：起始和结束值和隔位

1 3

隔位值--必须从1开始不能为0 1不隔位2才隔位 '''

for i in range(5): #遍历5 位数后面加一个英文的冒号

print(i,end='') #01234 python3 end=''横向显示 python2 ，逗号

for j in range(1,5): #遍历1-5起始到结束

print(j,end='') #1234

for i in range(1,5,2):#起始结束各位

print(i,end='') #13

a ='dcs' #定义一个字符串

num =len(a) #统计字符串位数，然后赋值给Num变量

print(num)#打印变量得到结果 3

for i in range(len(a)):

print(i,end='') #012

a='dcs' #定义一个字符串

for i in a:#通过for循环来遍历这个字符串

print(i)#打印结果

l=[1,2,3,4]#定义一个列表

for j in l:#通过for循环来遍历这个列表

print(j)#打印结果

t=(1,2,3) #定义一个元组

for i in t:#通过for循环来遍历这个元组

print(i)#打印结果

d ={'name':'zhang','age':18}#定义一个字典

for l in d:#遍历字典

print(l)#打印结果

十一、while

条件满足才会进入到循环体中

条件不满足就退出循环体

如果条件一直满足就一直循环-死循环 '''

# 死循环

a =1 #定义一个变量

while a<=5: #条件它是一直满足，所以无限次循环

print('第：%d循环'%a)

# 满足条件后退出循环体

num=1

while num<=5:

print('第:%d次循环'%num)

num +=1

二进制：0 0 0 0 0 0 0 0 :0表示假，错，NO，不存在，否

1 1 1 1 1 1 1 1 :1表示真，对，OK，存在，是

二进制格式：8个位

128 64 32 16 8 4 2 1

0000 0001 =1

0000 0010 =2

0000 0011 =3

0000 0100 =4

0000 0101 =5 '''

按位与 &

a =5 #0000 0101

c =3 #0000 0011

print(a &c) #两真为真，一真一假，一假一真，两两假为假

按位或|

a =5 #0000 0101

c =3 #0000 0011

print(a|c) #两真为真，一真一假为真，一假一真为真，两两假为假

按位异^

a =5 #0000 0101

c =3 #0000 0011

print(a^c) #两真为假，两假为假，一真一假为真，一假一真为真

取反~

print(~5) #-6

print(~6)#-7

print(~-7)#6

向左右移动

>>右移动 <<左移动

a =5 #0000 0101

0000 0101 =5

00 0000 01 =1 01

print(a>>2) #1

a1 =5 #0000 0101

0000 0101 =5

00 20 =00 010100

print(a1<<2) #20

l =[1,2,3,4,5]

print(7 in l)

print(7 not in l)

十二、python--索引

正向：0 1 2 3...

反向：..-4-3-2-1 (索引的具体值是根据你的元素个数来匹配）

01234567 正

a ='duoceshi'

87654321 -反

索引是非常实用，后期也会经常应用

切片和索引的结合

切片--[] 中括号表示

l=[] #列表

[] 切片

---------------切片的使用规则--------------

第一：1个值

[5] 切片索引--具体的索引值 5

range(5)位数 01234

第二：2个值

[1:5] 起始，结束不包含结束 1234

range(1,5)起始，结束不包含结束 1234

第三：3个值

[1:5:2]起始，结束，隔位，隔位不能为0默认1，隔位1必须从2开始以此类推

range(1,5,2)起始，结束，隔位，隔位不能为0默认1，隔位1必须从2开始以此类推'''

01234567 正

a ='duoceshi'

87654321 -反

'''面试题常问的问题：如何对字符串中的元素实现反转输出'''

print(a[::-1]) #ihsecoud 反转输出

print(a[3])#c

print(a[-3]) #s

print(a[1:5]) #uoce

print(a[:5]) #duoce 前后没有给具体的索引系统默认所有

print(a[1:]) #uoceshi

print(a[:]) #duoceshi

print(a[1:5:2]) #uc

print(a[::2]) #doeh

print(a[-5:-1]) #cesh 反向取值

print(a[-5:-1:2]) #cs 隔位取值

十三、python中的数据类型：字符串，列表，元组，字典

字符串

字符串定义：'' "" 单引号或者双引号

字符串类型：str

123 --整形int

'123' --字符串str

在语法结构中除了整形不需要加引号其它参数都需要加引号

print(123)

print('12ab#@多')

-----------------------------

类型查看--type

a =123

print(type(a)) #<class 'int'>

a1 ='123'

print(type(a1)) #<class 'str'>

a2 ="123"

print(type(a2)) #<class 'str'>

字符串中常用的函数

capitalize()改变字符串首字母小写为大写

a ='duoceshi'

a1 =a.capitalize()

print(a1) #Duoceshi

print(a.capitalize())#Duoceshi

count() 统计字符串中指定元素出现的次数

a ='duoceshi'

a1 =a.count('d')

print(a1) #1

print(a.count('d')) #1

''.join()拼接

a ='duoceshi'

a1 ='*'.join(a)

print(a1) #d*u*o*c*e*s*h*i

print(' '.join(a)) #d u o c e s h i

split分割，返回的是列表，对于返回的列表可以通过join实现组合拼接

a ='duoceshi'

a1 =a.split('c') #把字符串中的c这个元素进行分割掉

print(a1) #['duo', 'eshi'] 分割后返回的是一个列表

# print(type(a1)) #<class 'list'>

print(''.join(a1)) #duoeshi 返回的列表可以通过join实现链接

有一个字符串：duo_ceshi 对此字符串实现：duoCeshi输出

a ='duo_ceshi'

a1 =a.split('_')#分割掉多余的

# print(a1) #['duo', 'ceshi']

print(a1[0]+a1[1].capitalize()) #duoCeshi

strip()删除开头结果的元素

a ='duoceshi'

a1=a.strip('di') #删除字符串中开头和结尾的元素

print(a1) #uocesh

lstrip()只能删除左边开头字符串，不能删除右边

a2 ='duoceshi'

a3 =a2.lstrip('di')

print(a3)

rstrip()只能删除右边开头的字符，不能删除左边

a4 ='duoceshi'

a5 =a4.rstrip('di')

print(a5)#duocesh

startswith判断开头字符是否匹配，返回布尔值

a ='duoceshi'

print(a.startswith('d')) #True

print(a.startswith('u')) #False

endswith判断字符串结尾是否匹配，返回布尔值

a1 ='duoceshi'

print(a1.endswith('d')) #False

print(a1.endswith('i')) #True

find取指定元素的索引值：左边第一个

rfind取指定元素的索引值：右边第一个

a ='duocueushi'

print(a.find('u')) #1

print(a.rfind('u'))#6

replace()替换元素

a ='duocueushi'

print(a.replace('u','多')) #d多oc多e多shi

print(a.replace('u','测',2)) #d测oc测eushi 换具体的个数

print(a.replace(a,'小钱')) #小钱

print(a.replace(a,'duoCeshi'))

uppder把字符串中所有的小写字母变为大写字母

a ='duocueushi'

a1=a.upper()

print(a1) #DUOCUEUSHI

lower把字符串中所有的大写字母变为小写字母

a2 ='DUOCUEUSHI'

a3=a.lower()

print(a3) #duocueushi

isdigit()判断是否全部为数字

a ='duocueushi'

print(a.isdigit())#False

a1 ='123456'

print(a1.isdigit()) #True

a2 ='12ad'

print(a2.isdigit()) #False

isalpha()判断是否全部为字母，返回布尔值

a ='duocueushi'

print(a.isalpha())#True

a1 ='123456'

print(a1.isalpha()) #Fals

a2 ='12ad'

print(a2.isalpha()) #Fals

isalnum()判断是否为数字，字母，数字+字母，字母+数字组合，返回布尔值

a1= '12345'

print(a1.isalnum()) #True

a2='asdfsd'

print(a2.isalnum()) #True

a3='12asdf'

print(a3.isalnum())#True

a4='asd@#'

print(a4.isalnum()) #False

isupper()判断是否全为大写字母，返回布尔值

a='asdfdsaf'

print(a.isupper()) #False

a1='SDFDAS'

print(a1.isupper()) #True

a2='asdfASDF'

print(a2.isupper()) #False

a3='asdf123'

print(a3.isupper())#False

a4='ASDF123'

print(a4.isupper()) #True

islower()判断是否全部为小写字母，返回布尔值

a='asdfdsaf'

print(a.islower()) #True

a1='SDFDAS'

print(a1.islower()) #False

a2='asdfASDF'

print(a2.islower()) #False

a3='asdf123'

print(a3.islower())#True

a4='ASDF123'

print(a4.islower()) #False

python数据类型--列表

列表定义--[]中括号

列表类型--list （字符串str 整形int)

列表中的元素逗号分割的每个集合都是一个组合只能表示是1个对于的索引位

l =[1,22,'duoceshi']

数据类型是支持切片索引：字符串,列表

l=[] #定义空列表

l =[1,2,3,'hello']#定义一个列表

print(type(l)) #打印类型 <class 'list'>

print(l)#查看结果[1, 2, 3, 'hello']

l1 =list('123') #通过类型直接定义列表

print(type(l1)) #<class 'list'>

print(l1) #['1', '2', '3']

a ='456'#定义一个字符串

l2 =list(a)#把字符串通过list转换成为列表

print(l2) #['4', '5', '6']

通过切片和所有来更改列表中的元素

l =[1,2,3,'hello']#定义一个列表

l[3]='小钱' #更改指定索引的元素通过切片索引来完成

print(l) #[1, 2, 3, '小钱']

# l[4]='大钱'

# print(l) 列表中的位数不能超过

append()添加元素

l =[1,2,3,'hello']#定义一个列表

l.append('大钱')#添加，往指定的列表中添加一个元素默认放在末尾

print(l)#[1, 2, 3, 'hello', '大钱']

l1 =[]#定义一个空列表

print(l1) #[]

st ='' #定位一个空字符串

print(st)

insert在指定索引添加一个元素

l =[1,2,3,'hello']#定义一个列表

l.insert(1,'小钱')

print(l) #[1, '小钱', 2, 3, 'hello']

extend拼接

l =[1,2,3,'hello']#定义一个列表

l1 =[4,5,6]#定义一个列表

l.extend(l1) #把两个列表进行拼接成为1个列表

print(l) #[1, 2, 3, 'hello', 4, 5, 6]

remove删除指定的元素

l =[1,2,3,'hello']#定义一个列表

l.remove(2)

print(l)#[1, 3, 'hello']

del删除可以结合切片索引来完成

l =[1,2,3,'hello']#定义一个列表

# del l #删除整个列表

# print(l) #返回没有此命名命名的列表存在

del l[3]

print(l) #[1, 2, 3]

index()通过元素来得到元素的索引值

l =[1,2,3,'hello']#定义一个列表

l1=l.index('hello')

print(l1) #3

sort()升序把列表中的元素实现小到大排序

l =[5,2,1,3,6]#定义一个列表

l.sort() #把列表中的元素从小到大的排序

print(l) #[1, 2, 3, 5, 6]

sorted结合reverse=True 降序 reverse=False升序

l =[5,2,1,3,6]#定义一个列表

print(sorted(l,reverse=True)) #[6, 5, 3, 2, 1]

print(sorted(l,reverse=False)) #[1, 2, 3, 5, 6]

面试题目：字符串反转，列表的反转

l =[5,2,1,3,6]#定义一个列表

如何对列表进行反转输出字符串[::-1]反转

l.reverse()

print(l) #[6, 3, 1, 2, 5]

pop()删除末尾的元素，或者结合索引来删除索引的元素

l =[5,2,1,3,6]#定义一个列表

# l.pop() #默认删除末尾的元素

# print(l) #[5, 2, 1, 3]

l.pop(1)#也可以结合索引来删除指定索引的元素

print(l) #[5, 1, 3, 6]

字符串：a ='duoceshi'

python数据类型===元组

1、元组定义--()小括号

2、元组类型--tuple

字符串 --str

列表类型--list

3、元组是不可变--一旦定义好一个元组后，这个元组中的元素是不能直接做增删改操作

字符串，列表定义好后是可以做增删改操作

元组更安全

4、定义元组的时候如果说只有一个元素，一定要在元素的后面加上一个逗号否则他就不是元组而是元素的类型

(1) --他是整形 ('1')--他是字符串 (1,)--他是元组

5、如果要对元组中的元素做增删改操作如何实现？

答：可以先把元组通过类型转换成为列表，然后再通过调用列表中的函数来实现增删改操作，

完成操作后再通过元组的类型把列表转换回元组即可。

6、元组和列表的区别？

答：1、定义不同，元组是小括号，列表是中括号

2、类型不同，元组是tuple，列表是list

3、元组定义后是不可直接更改元素，列表定义后是可以通过函数来直接更改

4、元组更安全

5、如果元组中只有一个元素但是没有加逗号，他就不是元组

但是列表同样只有一个元素的时候它还是列表

7、元组也是支持切片索引，元组中逗号分割的都是唯一的元素和索引'''

t =()#定义一个空的元组

print(type(t)) #<class 'tuple'> 类型是元组类型

print(t) #()因为没有元素所以返回为空

t1 =(1,2,'hello',2)

print(type(t1)) #<class 'tuple'>

print(t1) #(1, 2, 'hello')

t2 =(1)

print(type(t2)) #<class 'int'>整形

t3 =('1')

print(type(t3)) #<class 'str'>字符串

t4 =(1,)

print(type(t4)) #<class 'tuple'>元组

t5 =(1,2,3,4,'hello') #元组是写保护

t5[1]='小钱' #所以你直接去更改是不允许

t5.pop()

l =list(t5) #通过列表的类型来把t5这个元组先转换成为列表

print(type(l)) #<class 'list'>

print(l) #[1, 2, 3, 4, 'hello']

l[1]='小钱'

print(l) #[1, '小钱', 3, 4, 'hello']

t =tuple(l) #通过元组的类型把列表转换为元组

print(type(t)) #<class 'tuple'>

print(t) #(1, '小钱', 3, 4, 'hello')

字典

字典定义--{} 大括号，花括号

字典类型--dict（字典类型）

元组类型--tuple

字符串 --str

列表类型--list

字典---分为键值(组合)

键在字典中--唯一的存在（有约束）

值在字典中--可以唯一也可以不唯一（没约束）

多个键值对用,逗号分割

键值对格式：'name':'lisi','age':18 (非整形需要加引号）

字典中是可以存在N个键值对'''

d ={} #定义一个空字典

print(type(d)) #<class 'dict'>

print(d) #{}

d1 ={'name':'zhang'} #1组键值对

d2 ={'name':'lisi','age':18} #多组键值对

d3 ={'':'lisi'} #键为空，有值

d4 ={'':''} #都为空

d5 ={'name':''} #键有值，值为空

d6 ={'name':} #注意如果没有值的时候一定要加上引号，否则会报异常

有两个列表把这两个拼凑组合成为字典且列表的索引对应的值要相同

l =['a','b','c']

l1 =[1,2,3]

l2 =zip(l,l1) #通过zip函数来实现对列表进行拼接返回一个个的元组

for i in l2:

print(i)

d =dict(l2) #直接通过字典的类型来把元组转换为字典

print(d) #{'a': 1, 'b': 2, 'c': 3}