Python基础语法回顾

北山啦 发表于 2022/05/13 20:26:28 2022/05/13
【摘要】 由于一年多没有接触python,现在恶补了下python基础语法,为以后的深度学习打下基础。现总结如下,希望对大家有所帮助。Table of Contents1  Python入门1.1  环境搭建1.2  注释1.3  变量1.4  输入输出1.5  数据类型1.6  运算符2  流程控制2.1  条件语句2.2  循环2.3  while嵌套以及他的应用3  数据序列3.1  字符串3....

由于一年多没有接触python,现在恶补了下python基础语法,为以后的深度学习打下基础。现总结如下,希望对大家有所帮助。

在这里插入图片描述

Table of Contents

Python基础学习路线流程图

Python入门

环境搭建

PyCharm是一种Python的集成开发环境,带有一整套可以帮助用户在使用Python语言开发时提高其效率的工具

Anaconda(官方网站)就是可以便捷获取包且对包能够进行管理,同时对环境可以统一管理的发行版本。Anaconda包含了conda、Python在内的超过180个科学包及其依赖项。

注释

注释分为两类:==单行注释== 和 ==多行注释==。

  • 单行注释

只能注释一行内容,语法如下:

# 注释内容
  • 多行注释

可以注释多行内容,一般用在注释一段代码的情况, 语法如下:

"""
	第一行注释
	第二行注释
	第三行注释
"""

'''
	注释1
	注释2
	注释3
'''

快捷键: ==ctrl + /==

变量

定义变量

变量名 =

变量名自定义,要满足==标识符==命名规则。

标识符命名规则是Python中定义各种名字的时候的统一规范,具体如下:

  • 由数字、字母、下划线组成
  • 不能数字开头
  • 不能使用内置关键字
  • 严格区分大小写
False     None    True   and      as       assert   break     class  
continue  def     del    elif     else     except   finally   for
from      global  if     import   in       is       lambda    nonlocal  not       or      pass   raise    return   try      while     with   yield
my_name = '北山啦'
print(my_name)
北山啦

输入输出

输入

在Python中,程序接收用户输入的数据的功能即是输入。

语法:
input(“提示信息”)

  • 当程序执行到input,等待用户输入,输入完成之后才继续向下执行。
  • 在Python中,input接收用户输入后,一般存储到变量,方便使用。
  • 在Python中,input会把接收到的任意用户输入的数据都当做字符串处理。
address = input('请输入您的CSDN博客地址:')
请输入您的CSDN博客地址:https://beishan.blog.csdn.net/
print(f'您输入的密码是{address}')
# <class 'str'>
print(type(address))
您输入的密码是https://beishan.blog.csdn.net/
<class 'str'>

输出

  • 格式化输出
    • 格式化符号
    • f-字符串
  • print的结束符
print('hello Python')

age = 18
print(age)

# 需求:输出“今年我的年龄是18岁”
age = 20
name = '北山啦'
student_id = '01830115'

print('我的名字是%s' % name, end='\n')
print('我的学号是%s' % student_id)
print(f'我的名字是{name},今年{age+1}岁了')
我的名字是北山啦
我的学号是01830115
我的名字是北山啦,今年21岁了
  • %06d,表示输出的整数显示位数,不足以0补全,超出当前位数则按原样输出
  • %.2f,表示小数点后显示的小数位数
weight = 74.22
print(f"{weight}")
print("{:.3f}".format(weight))
74.22
74.220
stu_id = 1
print("{:03d}".format(stu_id))
001

所谓的格式化输出即按照一定的格式输出内容。

==格式化符号==

格式符号 转换
==%s== 字符串
==%d== 有符号的十进制整数
==%f== 浮点数
%c 字符
%u 无符号十进制整数
%o 八进制整数
%x 十六进制整数(小写ox)
%X 十六进制整数(大写OX)
%e 科学计数法(小写’e’)
%E 科学计数法(大写’E’)
%g %f和%e的简写
%G %f和%E的简写
  • 格式化符号
    • %s:格式化输出字符串
    • %d:格式化输出整数
    • %f:格式化输出浮点数
  • f-字符串
    • f’{表达式}’
  • 转义字符
    • \n:换行
    • \t:制表符,一个tab键的举例
  • print结束符end

数据类型

我们可以使用type()函数,来查看数据类型

num1 = 1
num2 = 1.1
print(type(num1))
print(type(num2))
print(type('北山啦'))
print(type(True))
<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>

转换数据类型

==转换数据类型的函数==

函数 说明
==int(x [,base ])== 将x转换为一个整数
==float(x )== 将x转换为一个浮点数
complex(real [,imag ]) 创建一个复数,real为实部,imag为虚部
==str(x )== 将对象 x 转换为字符串
repr(x ) 将对象 x 转换为表达式字符串
==eval(str )== 用来计算在字符串中的有效Python表达式,并返回一个对象
==tuple(s )== 将序列 s 转换为一个元组
==list(s )== 将序列 s 转换为一个列表
chr(x ) 将一个整数转换为一个Unicode字符
ord(x ) 将一个字符转换为它的ASCII整数值
hex(x ) 将一个整数转换为一个十六进制字符串
oct(x ) 将一个整数转换为一个八进制字符串
bin(x ) 将一个整数转换为一个二进制字符串

==一些例子==

需求:input接收用户输入,用户输入“1”,将这个数据1转换成整型。

num = input('请输入您的幸运数字:')
print(f"您的幸运数字是{num}")
print(type(num))
print(type(int(num)))

# 1. float() -- 转换成浮点型
num1 = 1
print(float(num1))
print(type(float(num1)))

# 2. str() -- 转换成字符串类型
num2 = 10
print(type(str(num2)))

# 3. tuple() -- 将一个序列转换成元组
list1 = [10, 20, 30]
print(tuple(list1))
print(type(tuple(list1)))


# 4. list() -- 将一个序列转换成列表
t1 = (100, 200, 300)
print(list(t1))
print(type(list(t1)))

# 5. eval() -- 将字符串中的数据转换成Python表达式原本类型
str1 = '10'
str2 = '[1, 2, 3]'
str3 = '(1000, 2000, 3000)'
print(type(eval(str1)))
print(type(eval(str2)))
print(type(eval(str3)))
请输入您的幸运数字:20
您的幸运数字是20
<class 'str'>
<class 'int'>
1.0
<class 'float'>
<class 'str'>
(10, 20, 30)
<class 'tuple'>
[100, 200, 300]
<class 'list'>
<class 'int'>
<class 'list'>
<class 'tuple'>

运算符

  • 算数运算符
  • 赋值运算符
  • 符合赋值运算符
  • 比较运算符
  • 逻辑运算符

算数运算符

  • 算数运算的优先级
    • 混合运算优先级顺序:()高于 ** 高于 * / // % 高于 + -
  • 赋值运算符
    • =
  • 复合赋值运算符
    • +=
    • -=
    • 优先级
      1. 先算复合赋值运算符右侧的表达式
      2. 再算复合赋值运算的算数运算
      3. 最后算赋值运算
  • 比较运算符
    • 判断相等: ==
    • 大于等于: >=
    • 小于等于:<=
    • 不等于: !=
  • 逻辑运算符
    • 与: and,都真才真
    • 或:or,一真则真,都假才假
    • 非:not,取反

7%E8%BF%90%E7%AE%97%E4%BE%8B%E5%AD%90.png

流程控制

条件语句

python中的条件判断共三种:

  • if语句语法
if 条件:
    条件成立执行的代码
  • if…else…
if 条件:
    条件成立执行的代码
else:
    条件不成立执行的代码
  • 多重判断
if 条件1:
    条件1成立执行的代码
elif 条件2:
    条件2成立执行的代码
else:
    以上条件都不成立执行的代码
age = int(input('请输入他的年龄:\n'))
if age < 18:
    print(f"你输入的年龄是{age},童工")
elif 18 <= age <= 60:
    print("你输入的年龄是{},合法".format(age))
elif age > 60:
    print("你输入的年龄是%d,退休" % age)
请输入他的年龄:
20
你输入的年龄是20,合法

让我们直接用一个猜拳小游戏,来熟悉if条件语句吧

"""
提示:0-石头,1-剪刀,2-布
1. 出拳
玩家输入出拳
电脑随机出拳,使用random库随机生成0,1,2
"""
import random
computer = random.randint(0, 2)
# print(computer)
player = int(input('请出拳:0-石头,1-剪刀,2-布:'))

if (player == 0 and computer == 1) or (player == 1 and computer == 2) or (player == 2 and computer == 0):
    print('玩家获胜')
elif player == computer:
    print('平局')
else:
    print('电脑获胜')
请出拳:0-石头,1-剪刀,2-布:2
电脑获胜

循环

本章节将向大家介绍Python的循环语句,程序在一般情况下是按顺序执行的。

编程语言提供了各种控制结构,允许更复杂的执行路径。

循环语句允许我们执行一个语句或语句组多次,下面是在大多数编程语言中的循环语句的一般形式:

while循环

while 条件:

条件成立执行代码

具体例子:

# 输出5遍博客名
t = 0
while(t < 5):
    print("北山啦")
    t += 1
北山啦
北山啦
北山啦
北山啦
北山啦
# 1-100累加
i = 1
sum = 0
while i <= 100:
    sum += i
    i += 1
print(sum)
5050

1-100的偶数累加和

i = 1
sum = 0
while i <= 100:
    if i % 2 == 0:
        sum += i
    i += 1
print(sum)
2550
i = 0
sum = 0
while i <= 100:
    sum += i
    i += 2
print(sum)
2550

==break和continue==

break和continue是循环中满足一定条件退出循环的两种不同方式。

  • break控制循环流程,即终止此循环

  • continue控制循环流程,即退出当前一次循环而执行下一次循环代码

具体例子如下

# 循环吃5个苹果,吃完了第3个吃饱了,第4和第5个不吃了
i = 1
while i <= 5:
    if i == 4:
        break
    print(f"吃了第{i}个苹果")
    i += 1
吃了第1个苹果
吃了第2个苹果
吃了第3个苹果
i = 1
while i <= 5:
    if i == 3:
        print("吃出了一个大虫子,这个苹果不吃了")
        # 如果使用continue,在continue之前一定要修改计数器,否则进入死循环
        i += 1
        continue
    print(f"吃了第{i}个苹果")
    i += 1
吃了第1个苹果
吃了第2个苹果
吃出了一个大虫子,这个苹果不吃了
吃了第4个苹果
吃了第5个苹果

while嵌套以及他的应用

while嵌套的简单应用

j = 0
while j < 3:
    i = 0
    while i < 3:
        print("CSDN")
        i += 1
    j += 1
    print("北山啦")

CSDN
CSDN
CSDN
北山啦
CSDN
CSDN
CSDN
北山啦
CSDN
CSDN
CSDN
北山啦

一行输出5个星号,重复打印5行

j = 0
while j < 5:
    i = 0
    while i < 5:
        print("*", end='')
        i += 1
    print()
    j += 1

*****
*****
*****
*****
*****

打印三角形

j = 0
while j < 5:
    i = 0
    while i <= j:
        print("*", end='')
        i += 1
    print()
    j += 1

*
**
***
****
*****

九九乘法表

# 九九乘法表
for i in range(1, 10):
    for j in range(1, i+1):
        print(f'{j}*{i}={i*j}\t', end='')
    print()

1x1=1	
1x2=2	2x2=4	
1x3=3	2x3=6	3x3=9	
1x4=4	2x4=8	3x4=12	4x4=16	
1x5=5	2x5=10	3x5=15	4x5=20	5x5=25	
1x6=6	2x6=12	3x6=18	4x6=24	5x6=30	6x6=36	
1x7=7	2x7=14	3x7=21	4x7=28	5x7=35	6x7=42	7x7=49	
1x8=8	2x8=16	3x8=24	4x8=32	5x8=40	6x8=48	7x8=56	8x8=64	
1x9=9	2x9=18	3x9=27	4x9=36	5x9=45	6x9=54	7x9=63	8x9=72	9x9=81	
# 九九乘法表
i = 1
while i <= 9:
    j = 1
    while(j <= i):
        print('{}*{}= {}'.format(j, i, i*j), end='\t')
        j += 1
    print('')
    i += 1

1*1= 1	
1*2= 2	2*2= 4	
1*3= 3	2*3= 6	3*3= 9	
1*4= 4	2*4= 8	3*4= 12	4*4= 16	
1*5= 5	2*5= 10	3*5= 15	4*5= 20	5*5= 25	
1*6= 6	2*6= 12	3*6= 18	4*6= 24	5*6= 30	6*6= 36	
1*7= 7	2*7= 14	3*7= 21	4*7= 28	5*7= 35	6*7= 42	7*7= 49	
1*8= 8	2*8= 16	3*8= 24	4*8= 32	5*8= 40	6*8= 48	7*8= 56	8*8= 64	
1*9= 9	2*9= 18	3*9= 27	4*9= 36	5*9= 45	6*9= 54	7*9= 63	8*9= 72	9*9= 81	

使用列表推导式

print('\n'.join(
    ['\t'.join([f"{j}*{i}={i*j}" for j in range(1, i + 1)]) for i in range(1, 10)]))

1*1=1
1*2=2	2*2=4
1*3=3	2*3=6	3*3=9
1*4=4	2*4=8	3*4=12	4*4=16
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

for循环
语法:

for 临时变量 in 序列:

重复执行的代码1

重复执行的代码2

......
str1 = 'CSDN北山啦'
for i in str1:
    print(i)

C
S
D
N
北
山
啦

for…else 之break和continue

# break
str2 = 'https://beishan.blog.csdn.net/'
for i in str2:
    if i == ':':
        break
    print(i)
else:
    print("循环正常结束执行的else代码")

h
t
t
p
s
# continue
str2 = 'https://beishan.blog.csdn.net/'
for i in str2:
    if i == ':':
        continue
    print(i)
else:
    print("循环正常结束执行的else代码")

h
t
t
p
s
/
/
b
e
i
s
h
a
n
.
b
l
o
g
.
c
s
d
n
.
n
e
t
/
循环正常结束执行的else代码

数据序列

我们可以使用==type()==函数来查看数据类型

字符串

字符串是Python中最常见的数据类型,我们一般使用引号来创建字符串。

可以使用单引号,也可以使用三引号

a = 'https://beishan.blog.csdn.net/'
print(type(a))
b = """原创:CSDN北山啦"""
print(type(b))
c = "I'm 北山啦"
print(c)
print(type(c))

<class 'str'>
<class 'str'>
I'm 北山啦
<class 'str'>

在Python中,使用input()接收用户输入。在Python中,使用print()接收用户输入。

==切片==

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。

语法

序列[开始位置下标:结束位置下标:步长]

注意

  	1. 不包含结束位置下标对应的数据, 正负整数均可;
  	2. 步长是选取间隔,正负整数均可,默认步长为1。
name = "abcdefg"

print(name[2:5:1])  # cde
print(name[2:5])  # cde
print(name[:5])  # abcde
print(name[1:])  # bcdefg
print(name[:])  # abcdefg
print(name[::2])  # aceg
print(name[:-1])  # abcdef, 负1表示倒数第一个数据
print(name[-4:-1])  # def
print(name[::-1])  # gfedcba

cde
cde
abcde
bcdefg
abcdefg
aceg
abcdef
def
gfedcba

==字符串常用操作==

字符串的常用操作方法有查找、修改和判断三大类。

查找:find()、index()、count()

find():检测某个子串是否包含在这个字符串中,如果在返回这个子串开始的位置下标,否则则返回-1。

index():检测某个子串是否包含在这个字符串中,如果在返回这个子串开始的位置下标,否则则报异常。

count():返回某个子串在字符串中出现的次数

修改:replace()、split()、join()

  • split():按照指定字符分割字符串。
字符串序列.split(分割字符, num)

注意:num表示的是分割字符出现的次数,即将来返回数据个数为num+1个。

  • join():用一个字符或子串合并字符串,即是将多个字符串合并为一个新的字符串。
字符或子串.join(多字符串组成的序列)

capitalize():将字符串第一个字符转换成大写。

title():将字符串每个单词首字母转换成大写。

lower():将字符串中大写转小写。

upper():将字符串中小写转大写。

strip():删除字符串两侧空白字符。lstrip()、rstrip()

center():返回一个原字符串居中对齐,并使用指定字符(默认空格)填充至对应长度 的新字符串,语法和ljust()相同。

判断:startswith()、endwith()、isalpha()、isdigit()

这样的函数有很多,需要用的时候自己百度即可,熟悉最常见的例如:join()、split()即可。

列表

列表是最常用的Python数据类型,它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

name_list = ['欢迎', '关注', '北山啦']
print(name_list[0])
print(name_list[1])
print(name_list[2])

欢迎
关注
北山啦

==常见的函数==

index()、count()、len()

name_list = ['欢迎', '关注', '北山啦']
print(name_list.index('北山啦'))
print(name_list.count('北山啦'))c
print(len(name_list))

2
1
3

==判断是否存在==

in:判断指定数据在某个列表序列,如果在返回True,否则返回False

not in:判断指定数据不在某个列表序列,如果不在返回True,否则返回False

name_list = ['欢迎', '关注', '北山啦']
print('欢迎' in name_list)
print('Lilys' in name_list)

True
False
print('北山' not in name_list)
print('Lilys' not in name_list)

True
True

常用操作方法

  • index()
  • len()
  • append()
  • extend()
  • insert()
  • del()
  • pop()
  • clear()
  • remove()

同时列表也有reverse()、sort()这样的函数

import random
teachers = ['zhangzk', 'dfbdaf', 'dfad', 'dfa', 'etw', 'dfa', 'dgdag']
offices = [[], [], []]
for name in teachers:
    num = random.randint(0, 2)
    offices[num].append(name)
print(offices)

[['dfbdaf', 'dfa'], ['zhangzk', 'dfa', 'dgdag'], ['dfad', 'etw']]
[i for j in offices for i in j]

['dfbdaf', 'dfa', 'zhangzk', 'dfa', 'dgdag', 'dfad', 'etw']
for name in offices:
    for i in name:
        print(i, end=' ')

etw dgdag dfad dfa zhangzk dfbdaf dfa 

元组

一个元组可以存储多个数据,元组内的数据是不能修改的

元组特点:定义元组使用==小括号==,且==逗号==隔开各个数据,数据可以是不同的数据类型。

t1 = (10, 20, 30)
t2 = (10,)
print(type(t1))
print(type(t2))

<class 'tuple'>
<class 'tuple'>

如果定义的元组只有一个数据,那么这个数据后面也好添加逗号,否则数据类型为唯一的这个数据的数据类型

t2 = (10,)
print(type(t2))  # tuple

t3 = (20)
print(type(t3))  # int

t4 = ('hello')
print(type(t4))  # str

<class 'tuple'>
<class 'int'>
<class 'str'>

常用方法和list类似:index()、len()、count()

字典

字典特点:

  • 符号为大括号
  • 数据为键值对形式出现
  • 各个键值对之间用逗号隔开

创建字典

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}  # 有数据的字典
dict2 = {}  # 创建空字典
dict3 = dict()  # 创建空字典
print(type(dict1))

<class 'dict'>

字典的常见操作

  • 增加

如果key存在则修改这个key对应的值;如果key不存在则新增此键值对

dict1 = {'name': '北山啦', 'age': 20, 'gender': '男'}
dict1['name'] = 'Rose'
print(dict1)

{'name': 'Rose', 'age': 20, 'gender': '男'}
dict1['id'] = 110
print(dict1)

{'name': 'Rose', 'age': 20, 'gender': '男', 'id': 110}
  • 删除

del、clear

dict1 = {'name': '北山啦', 'age': 20, 'gender': '男'}
# del(dict1)
del dict1['gender']
print(dict1)

{'name': '北山啦', 'age': 20}
dict1.clear()
print(dict1)  # 清空字典

{}
  • 修改

写法:字典序列[key] = 值

注意:如果key存在则修改这个key对应的值 ;如果key不存在则新增此键值对。

dict1 = {'name': '北山啦', 'age': 20, 'gender': '男'}
dict1['age'] = 22
print(dict1)

{'name': '北山啦', 'age': 22, 'gender': '男'}
  • 查找

如果查找的key存在,则返回对应的值,否则报错

dict1 = {'name': '北山啦', 'age': 20, 'gender': '男'}
print(dict1['name'])
print(dict1['id'])

北山啦




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

KeyError                                  Traceback (most recent call last)

C:\Users\ADMINI~1\AppData\Local\Temp/ipykernel_1196/2064109912.py in <module>
      1 dict1 = {'name':'北山啦','age':20,'gender':'男'}
      2 print(dict1['name'])
----> 3 print(dict1['id'])



KeyError: 'id'

字典当中常用的函数

get()

  • 语法
字典序列.get(key, 默认值)

注意:如果当前查找的key不存在则返回第二个参数(默认值),如果省略第二个参数,则返回None。

  • 快速体验
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.get('name'))  # Tom
print(dict1.get('id', 110))  # 110
print(dict1.get('id'))  # None

keys()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.keys())  # dict_keys(['name', 'age', 'gender'])

values()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.values())  # dict_values(['Tom', 20, '男'])

items()

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
print(dict1.items())  # dict_items([('name', 'Tom'), ('age', 20), ('gender', '男')])

==字典当中的循环遍历==

dict1 = {'name': '北山啦', 'age': 20, 'gender': '男'}
for key in dict1.keys():
    print(key)

name
age
gender
for value in dict1.values():
    print(value)

北山啦
20
男
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for item in dict1.items():
    print(item)

('name', 'Tom')
('age', 20)
('gender', '男')
dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}
for key, value in dict1.items():
    print(f'{key}:{value}')

name:Tom
age:20
gender:男

集合

创建集合使用{}set(), 但是如果要创建空集合只能使用set(),因为{}用来创建空字典。

集合的特点:

  1. 集合可以去掉重复数据;
  2. 集合数据是无序的,故不支持下标
s1 = {10, 20, 30, 40, 50}
print(s1)

s2 = {10, 30, 20, 10, 30, 40, 30, 50}
print(s2)

s3 = set('abcdefg')
print(s3)

s4 = set()
print(type(s4))  # set

s5 = {}
print(type(s5))  # dict

{50, 20, 40, 10, 30}
{50, 20, 40, 10, 30}
{'a', 'd', 'b', 'e', 'f', 'g', 'c'}
<class 'set'>
<class 'dict'>

常见操作

  • 增加数据
    • add() #追加单一的数据
    • update() #追加序列
  • 删除数据
    • remove()
    • discard()
s1 = {10, 20, 30, 40, 50}
s1.add(100)  # 集合是可变的类型
print(s1)

{50, 20, 100, 40, 10, 30}
s1.update([30, 40, 50, 60, 70])
s1  # 集合可以去掉重复数据

{10, 20, 30, 40, 50, 60, 70}
s1.remove(10)

s1

{20, 30, 40, 50, 60, 70}
s1.discard(10)  # 没有该数据不会报错,remove会报错
s1

{20, 30, 40, 50, 60, 70}

公共方法

  • 运算符

    • in / not in
    运算符 描述 支持的容器类型
    + 合并 字符串、列表、元组
    * 复制 字符串、列表、元组
    in 元素是否存在 字符串、列表、元组、字典
    not in 元素是否不存在 字符串、列表、元组、字典
  • 公共方法

    • len()
    • del()
    • range()
    • enumerate()
    函数 描述
    len() 计算容器中元素个数
    del 或 del() 删除
    max() 返回容器中元素最大值
    min() 返回容器中元素最小值
    range(start, end, step) 生成从start到end的数字,步长为 step,供for循环使用
    enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中。
  • 数据类型转换

    • tuple()
    • list()
    • set()

    利用相应的函数即可实现数据类型转化

  • 语法

enumerate(可遍历对象, start=0)

注意:start参数用来设置遍历数据的下标的起始值,默认为0。

list1 = ['a', 'b', 'c', 'd', 'e']
for i in enumerate(list1, 1):
    print(i)

(1, 'a')
(2, 'b')
(3, 'c')
(4, 'd')
(5, 'e')
for index, char in enumerate(list1, start=1):
    print(f'下标是{index}, 对应的字符是{char}')

下标是1, 对应的字符是a
下标是2, 对应的字符是b
下标是3, 对应的字符是c
下标是4, 对应的字符是d
下标是5, 对应的字符是e

推导式

  • 列表推导式
  • 字典推导式
  • 集合推导式

==列表推导式==

# while实现
list1 = []
i = 0
while i < 10:
    list1.append(i)
    i += 1
print(list1)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# for循环实现
list1 = []
for i in range(10):
    list1.append(i)
print(list1)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
list1 = [i for i in range(10)]
print(list1)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

带if的列表推导式

# 创建0-10的偶数列表
list1 = [i for i in range(0, 11, 2)]
print(list1)

[0, 2, 4, 6, 8, 10]
list1 = [i for i in range(0, 11) if i % 2 == 0]
print(list1)

[0, 2, 4, 6, 8, 10]

多个for循环实现列表推导式

list1 = []
for i in range(1, 3):
    for j in range(3):
        list1.append((i, j))
print(list1)

[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
list1 = [(i, j) for i in range(1, 3) for j in range(3)]
print(list1)

[(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

列表推导式解包

a = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
b = [x for b in a for x in b]
print(b)

[1, 2, 3, 1, 2, 3, 1, 2, 3]

==字典推导式==

快速合并列表为字典或者体取字典中目标数据

dict1 = {i: i**2 for i in range(1, 5)}
print(dict1)

{1: 1, 2: 4, 3: 9, 4: 16}

合并列表为字典

list1 = ['name', 'age', 'gender']
list2 = ['beishan', 20, 'man']

dict1 = {list1[i]: list2[i] for i in range(len(list1))}
print(dict1)

{'name': 'beishan', 'age': 20, 'gender': 'man'}

提取字典中目标数据

counts = {'MBP': 268, 'HP': 125, 'DELL': 201, 'Lenovo': 199, 'acer': 99}
count1 = {key: value for key, value in counts.items() if value >= 200}
print(count1)

{'MBP': 268, 'DELL': 201}

==集合推导式==

list1 = [1, 1, 2]
set1 = {i**2 for i in list1}
print(set1)

{1, 4}

到这里就结束了,如果对你有帮助,欢迎点赞关注评论,你的点赞对我很重要

在这里插入图片描述

【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区),文章链接,文章作者等基本信息,否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件至:cloudbbs@huaweicloud.com进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容。
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。