霍格沃兹测试开发学社技术学习笔记之——Python基础笔记(思维导图版本)

[zmmcdvl_8209]

附件中：思维导图
阶段十一-python基础-笔记.zip (4.2 MB)

阶段十一-Python语言和测试框架（1）

1.pycharm环境变量配置和安装

2.基础数据类型

数字

字符串

3.运算符

字符串算数运算符

比较运算符

赋值运算符

逻辑运算符

成员运算符

身份运算符

4.控制流

判断控制语句

循环控制语句

5.数据结构

列表

元组

集合

字典

第1_2小节_python/pycharm安装和配置

1.Python环境安装

推荐Python最新版本

官方下载：https://www.python.org/downloads

安装演示

• mac安装

  • 下载链接：https://www.python.org/downloads/macos/

  • 下载文件：

    • downloads-》macos-》Stable Releases

      • M1芯片

        • macOS 64-bit universal2 installer

      • Inter芯片

        • macOS 64-bit Intel-only installer

      • 左上角Apple-关于本机-概述-芯片：

  • 执行文件：双击安装包，使用默认路径，默认安装

  • 检查安装是否成功：

    • 方式一：

      • 1.进入终端->输入 python3 ->回车
      • 2.输出：Python的版本信息，进入python的编辑页面
      • 3.退出：输入 exit()

    • 方式二：

      • 1.进入终端->输入 python3 -v ->回车
      • 2.输出：Python的版本，进入python的编辑页面
      • 3.退出：输入 exit()

• windows安装

  • 下载链接：https://www.python.org/downloads/windows/

  • 下载文件：

    • downloads-》Windows-》Stable Releases

      • 32位

        • Windows installer (32-bit)

      • 64位

        • Windows installer (64-bit)

      • 我的电脑-右键属性-系统类型：

  • 执行文件：

    • 安装时：

      • 勾选 配置环境变量：

        • Install launcher for users（）

          • 避免后期单独配置环境变量

        • Add Python3.10 to Path

      • Install Now

        • 默认安装

  • 检查安装是否成功：

    • 方式一：

      • 1.进入终端->输入 python ->回车

        • 注意是python 不是python3

      • 2.输出：Python的版本信息，进入python的编辑页面

      • 3.退出：输入 exit()

    • 方式二：

      • 1.进入终端->输入 python -V ->回车

        • 注意 大写V

      • 2.输出：Python的版本，进入python的编辑页面

      • 3.退出：输入 exit()

2.pycharm环境安装和配置

推荐版本：

• 社区版：Community(免费)

官网下载：

• Download PyCharm: Python IDE for Professional Developers by JetBrains

安装演示：

• mac安装

  • 下载链接：Download PyCharm: Python IDE for Professional Developers by JetBrains

  • 下载文件：

    • Community(免费)

      • M1芯片

        • .dmg(Apple Silicom)

      • Inter芯片

        • .dmg(Inter)

      • 左上角Apple-关于本机-概述-芯片：

    • Professional（付费）

  • 执行文件：双击安装包，拖到右侧APP

  • 配置

    • 配置python编译器

      • 左上角：pycharm->aboat paycharm->preferencs->左侧栏搜索框：输入interpreter->pychon Interpreter->

        • 右侧->下拉框右侧选择：本地已经安装的Python版本

        • 设置按钮：add

          • Virtualenv Environment（虚拟环境）

            • New environment
            • Existing environment
            • 如果项目比较多，需要兼容不同版本的类库，建议使用虚拟环境配置

          • System Interpreter（本地安装的环境）

            • 如果项目比较少，需要兼容版本不多，可以使用本地安装的环境

    • 安装第三方库

      • 左上角：pycharm->aboat paycharm->preferencs->左侧栏搜索框：输入interpreter->pychon Interpreter->

        • 右侧->列表：列表中显示已经安装的第三方库

        • +：添加第三方库

          • 搜索框输入：比如 pytest，选择对应的包，选择Install packege

        • -：删除第三方库

      • 也可以使用pip命令，其他章节讲

• Windows安装

  • 下载链接：Download PyCharm: Python IDE for Professional Developers by JetBrains

  • 下载文件：

    • Community(免费)

      • 32位

        • Windows installer (32-bit)

      • 64位

        • Windows installer (64-bit)

      • 我的电脑-右键属性-系统类型：

    • Professional（付费）

  • 执行文件：勾选添加环境变量 add **to path,创建桌面快捷键，安装

  • 配置

    • 配置python编译器

      • 左上角：File->settings->输入interpreter->pychon Interpreter->

        • 右侧->下拉框右侧选择：本地已经安装的Python版本

        • 设置按钮：add

          • Virtualenv Environment（虚拟环境）

            • New environment
            • Existing environment
            • 如果项目比较多，需要兼容不同版本的类库，建议使用虚拟环境配置

          • System Interpreter（本地安装的环境）

            • 如果项目比较少，需要兼容版本不多，可以使用本地安装的环境

      • 第一次安装好之后，new project->

    • 安装第三方库

      • 左上角：pycharm->aboat paycharm->preferencs->左侧栏搜索框：输入interpreter->pychon Interpreter->

        • 右侧->列表：列表中显示已经安装的第三方库

        • +：添加第三方库

          • 搜索框输入：比如 pytest，选择对应的包，选择Install packege

        • -：删除第三方库

      • 也可以使用pip命令，其他章节讲

3.python的基本操作

缩进与空格

• 缩进：展现属于哪个代码块

编写规范

• 注释

  • 快捷键：ctrl+/
  • 输入：#

• 符合规范性，命名要见名知意

• 不要用关键字命名

PEP8编码规范

• https://peps.python.org/pep-0008/
• 不要求全部了解，但是为了代码可读性，可维护性，约定规则。比如类，模块，如何命名

第3_4小节_基本数据类型

1.变量

概念：是一种存储数据的载体，计算机中的变量是实际存在的数据或者说是存储器中存储的数据的一块内存控件

• a = 10
• 内存空间：类似一个抽屉

变量值：可以是可读可修改的

• 打开pycharm->底部python Console->Special Variables 中，可以显示一些数据的变化

  • 声明 a ,赋值为10

  • 定义：

    • 》中输入 a = 10

      • 右侧：显示a = {int}10

        • a=10 已经被存储

  • 读：

    • 》中：输入 a
      • 返回 10

  • 修改：

    • 》中输入 a = 2

      • 右侧：显示a = {int}2

        • a被修改为2 ，已经被存储

命名规则：

• 变量名由字母(广义的Unicode字符，不包括特殊字符)、数字、和下划线构成，数字不能开头

  • T_1 = 0

    • 正确

  • 1_T = 0

    • 不可以

      • 报错

  • int_a = 1

    • 正确

• 大小写敏感(大写的‘A’和小写的‘a’是两个不同的变量)

  • A = 5
  • a = 6

• 不要跟关键字(有特殊含义的单词)和系统保留字(如函数、模块等名字)冲突。

  • 比如：for ,int ,python等这些关键字，不可以设置为变量

2.数字

常用数字类型

• int

  • 整型：1 ，0 ，-1

    • 》int_a = 1

• float

  • 浮点型:1.0 1.222 -1.22

    • 》float_a = 1.0

• 查看当前变量是什么数据类型：

  • 》type(int_a)

    • 返回：<class ‘int’>

      • 当前变量是int类型

  • 》type(float_a)

    • 返回：<class ‘float’>

      • 当前变量是float类型

常用运算符

• 赋值

  • =

• 加、减、乘、除

  • 符号：+ - * /
  • 》9+9
    • 返回：18

• 取余/取模

  • %

    • 》11%9
      • 返回：2

• 取整

  • //

    • 》5//2
      • 返回：2

• 乘方

  • **

    • 》3**2
      • 返回：9

• 修改运算优先级

  • ()

常用比较运算符

• 等于

  • ==

    • 返回值：布尔值 True / False

    • 》 3 == 2

      • 返回：False

    • 》2 == 2

      • 返回：True

• 不等于

  • ！=

• 大于

  符号：>

• 小于

  • <

• 大于等于

  符号：>=

• 小于等于

  • <=

赋值运算符

• 赋值

  • =

    • a = 1

      • 右边的值赋值给左边

    • a,b = 1,2

      • 多变量赋值

        • a = 1
        • b = 2

• 加法赋值

  • +=

    • a = a+1

      • a +=1

        • 自增操作

• 减法赋值

  • -=

    • 自减操作

• 乘方赋值

  • *=

• 除法赋值

  • /=

• 取余/取模赋值

  • %=

• 幂赋值

  • **=

    • 》 a =2

    • 》a **=3

      • 返回：2的3次方 8

• 取整赋值

  • //=

逻辑运算符

• and

  • x and y

    • x为真，并且有未真，返回才为真

      • 返回值：布尔值 True / False

    • 》a ,b = True,False

      • 注意首字母大写

      • 》print(a and b)

        • 返回：False

• or

  • x or y

    • x ,y 其中一个为真，返回则为真

• not

  • not x

    • x 为假，返回则为真

成员运算符

• in

  • 在指定的序列中找到值返回True,否则返回False

    • list_a = [‘a’,‘b’,‘c’]

    • str_a = ‘abcdef’

    • print(‘a’ in list_a)

      • 返回：True

    • print(‘a’ in str_a)

      • 返回：True

  • in 的右边 是一个系列：比如字符串，列表，元组

• not in

  • 在指定的序列中没有找到值返回True,否则返回False

    • list_a = [‘a’,‘b’,‘c’]

    • print('b’not in list_a)

      • 返回：False

身份运算符

• is

  • 判断两个表是否是不是引用自一个对象

    • 》a ,b = [‘1’],[‘1’]

      • 》‘a’ is ‘b’

        • 返回：False

      • 》‘a’ == ‘b’

        • 返回：True

    • 两者区别：

      • == 只判断左右两边的变量的值是否相等
      • is:判断左右两边值的变量的内存地址是否相等

    • 如何查看变量的内存地址？)

      • python函数id()

        • 》id(a)

          • 返回：56230080

        • 》id(b)

          • 返回：66894144

    • 可变的数据类型，即使看着一样，但是内存地址是不同的

      • 不可变的数据类型，如果看着一样，内存地址也一样

• is not

  • 判断两个表是否是不是引用自不同对象

    • is not:判断左右两边值的变量的内存地址是否不相等

第5小节_字符串基本操作

1.使用场景

数据提取之后的通用格式

• 日志

  • 二次封装

• Excel

第三方数据信息

• 转换，提取，二次修改

2.字符串定义

单行

• ’abcdef‘

多行

• str_b = “”“ddd
  www
  qqq
  “””

  • print(str_b)

    • 返回：

      • ddd
        www
        qqq

3.常用特殊字符

\n

• 换行符：打印换行

  • str_a = ‘abcdef\nhijklmn’

    • print(str_a)

      • 返回：

        • abcdef
          hijklmn

\

• 转义符：打印有特殊含义的字符

  • str_a = ‘abcdef\nhijklmn’

    • print(str_a)

      • 返回：

        • abcdef\nhijklmn

4.字符串格式化符号

%c

• 格式化字符及其ASCII码

  • 在原来的位置上，把不同类型的值 转化为字符串

%s

• 格式化字符串

  • str_c = 'my name is %s '% “sihan”

    • 在原来的位置上，把字符串类型的值 转化为字符串

%d

• 格式化整型

  • str_c = 'my age is %d '% 11

    • 在原来的位置上，把整型类型的值 转化为字符串

%u

• 格式化无符号整型

%o

• 格式化无符号八进制数

%x

• 格式化无符号十六进制数

%X

• 格式化无符号十六进制数(大写)

%f

• 格式化浮点数字，可指定小数点后的精度

%e

• 用科学计数法格式化浮点数

%p

• 用十六进制数格式化变量的地址

5.字符串之format

1.不设置指定位置，按默认顺序

• str_d =“my number is {}{}”.format(“1111”,“2222”)

  • print(str_d)

    • 返回：my number is 11112222

• str_1 = ‘my number is {}{}’
  str_2=str_1.format(“1111”,“2222”)
  print(str_2)

  • 返回：my number is 11112222

2.设置指定位置

• str_e =“my number is{1}{0}”.format(“1111”,“2222”)

  • print(str_e)

    • 返回：my number is 22221111

3.通过名称传递变量

• str_f =“我的名字是{name}，今年{age}岁”.format(name=“小明”,age=“6”)

  • print(str_f)

    • 返回：我的名字是小明，今年6岁

6.字符串之f(常用)

f"{变量名}":

python3.6.5之后，使用f"{变量名}"这种方式

name = “小明”

age = 6
print(f"我的名字是{name},今年{age}岁")

• 返回：我的名字是小明,今年6岁
• 使用方便，只要在字符串前面添加f，变量使用{}括起来

7.字符串常用API之join(合并)

join：

列表拼接成一个字符串

apple = [‘a’,‘p’,‘p’,‘l’,‘e’]

• print(‘’.join(apple))

  • 输出：apple

• print(‘//’.join(apple))

  • 每个字母中间，使用特殊字符分开
  • 输出 ：a//p//p//l//e

8.字符串常用API之split(分割)

split：

根据规定的内容，对字符串进行切分，那么该内容会被清除

apple = ‘a//p//p//l//e’

• print(apple.split(“//”))

  • 输出：[‘a’, ‘p’, ‘p’, ‘l’, ‘e’]

• print(apple.split(“l”))

  • 输出：[‘a’, ‘p’, ‘p’, ‘e’]

9.字符串常用API之replace(替换)

replace：

把后面的值，替换为前面的值

str_3 = “my name is 小明”

print(str_3.replace(“小明”,“小花”))

• 输出：my name is 小花

10.字符串常用API之strip(去掉收尾空格)

strip：

去掉内容开始和结尾的空格

str_3 = " my name is 小明 "

print(str_3.strip())

• 输出：my name is 小明

第6小节_运算符(和四重复)

1.运算符的作用

Python基础语法的内容

通常表示不同数据或变量之间的关系

2.算数运算符

+ - * /

• 加 减 乘 除

% ** //

• 取余 幂 取整

建议打开pycharm下方的 pychon console 进行操作，比较方便，直观

3.比较运算符(和四重复)

==

• 等于

  • 判断符号两边的值之间的关系
  • 返回值：布尔值 True / False

> <

• 大于，等于

>= <=

• 大于等于，小于等于

！=

• 不等于

4.赋值运算符(和四重复)

赋值

• =

  • a = 1

    • 右边的值赋值给左边

  • a,b = 1,2

    • 多变量赋值

      • a = 1
      • b = 2

加法赋值

• +=

  • a = a+1

    • a +=1

      • 自增操作

减法赋值

• -=

乘方赋值

• *=

除法赋值

• /=

取余/取模赋值

• %=

幂赋值

• **=

  -》a =2

  • 》a **=3

    • 返回：2的3次方 8

取整赋值

• //=

5.逻辑运算符(和四重复)

and

• x and y

  • x为真，并且有未真，返回才为真

    • 返回值：布尔值 True / False

  • 》a ,b = True,False

    • 注意首字母大写

    • 》print(a and b)

      • 返回：False

or

• x or y

  • x ,y 其中一个为真，返回则为真

not

• not x

  • x 为假，返回则为真

6.成员运算符(和四重复)

in

• 在指定的序列中找到值返回True,否则返回False

  • list_a = [‘a’,‘b’,‘c’]

  • str_a = ‘abcdef’

  • print(‘a’ in list_a)

    • 返回：True

  • print(‘a’ in str_a)

    • 返回：True

• in 的右边 是一个系列：比如字符串，列表，元组

not in

• 在指定的序列中没有找到值返回True,否则返回False

  • list_a = [‘a’,‘b’,‘c’]

  • print('b’not in list_a)

    • 返回：False

7.身份运算符(和四重复)

is

• 判断两个表是否是不是引用自一个对象

  • 》a ,b = [‘1’],[‘1’]

    • 》‘a’ is ‘b’

      • 返回：False

    • 》‘a’ == ‘b’

      • 返回：True

  • 两者区别：

    • == 只判断左右两边的变量的值是否相等
    • is:判断左右两边值的变量的内存地址是否相等

  • 如何查看变量的内存地址？)

    • python函数id()

      • 》id(a)

        • 返回：56230080

      • 》id(b)

        • 返回：66894144

  • 可变的数据类型，即使看着一样，但是内存地址是不同的

    • 不可变的数据类型，如果看着一样，内存地址也一样

is not

• 判断两个表是否是不是引用自不同对象

  • is not:判断左右两边值的变量的内存地址是否不相等

第7_8小节_控制流

1.控制流-判断

分支判断

• 顺序结构：一条一条语句顺序执行
• 分支结果：在某个判断条件后，选择一条分支去执行

if条件语句

• str_3 = " my name is 小明 "

• if 'a’in str_3:
  print(“true”)
  else:
  print(“false”)

  • 输出：true
  • 主要：缩进

else判断语句

• if 'M’in str_3:
  print(“true”)
  else:
  print(“false”)

  • 输出：false

elif多重条件

• food = ‘banana’
  if food ==‘apple’:
  print(“苹果”)
  elif food ==‘banana’:
  print(“香蕉”)
  elif food ==“orange”:
  print(“橘子”)
  else:
  print(“其他水果”)

  • 输出：香蕉
  • elif:后面需要增加条件

分支嵌套

• food = ‘apple’
  color = ‘red’
  if food ==‘apple’:
  print(“苹果”)
  if color ==‘red’:
  print(“红苹果”)

  • 输出：苹果
    红苹果

条件语句+逻辑运算符(and,or,not)

• food = ‘apple’
  color = ‘red’
  if food ==‘apple’ and color ==‘red’:
  print(“红苹果”)

  • 输出：红苹果

三目运算符

• 传统写法

  • a ,b= 20,10
    if a>b:
    h = ‘a大于b’
    else:
    h = ‘a小于b’
    print(h)

    • 输出：a大于b

• 三目写法

  • h = ‘a 大于b’ if a>b else ‘a小于b’
    print(h)

    • 输出：a大于b

  • 赋值语句放在最前面 if判断条件 else 其他值

2.控制流-循环

循环语句允许我们执行一个语句或语句组多次

python 提供for循环和while循环

循环的作用

• 封装重复性操作
• python最重要的基础语法之一

for -in循环

• 使用场景：明确知道循环执行的次数或者要对一个容器进行迭代(后面会讲到)

• range函数：

  • range(101)：可以产生一个0到100的整数序列

    • 传入的是 结束数值，遵循前闭后开的原则

  • range(1,100)：可以产生1到99的整数序列

    • 传入（开始数值，结束数值），遵循前闭后开的原则

  • range(1,100,2):可以产生1到99的奇数序列，其中2是步长

    • 传入（开始数值，结束数值，步长），遵循前闭后开的原则

• 练习

  • for i in [1,2,3]:
    print(i)

    • [1,2,3]就相当于是一个容器：元组，字符串，字典，可迭代元素

    • 输出：

      • 1
        2
        3

  • for i in range(1,10,2):
    print(i)

    • 输出

      • 1
        3
        5
        7
        9

while循环

• 使用条件

  • 满足条件，进入循环

  • 需要设置好循环结束条件

    • 避免死循环

• 案例

  • count =0
    while count<5:
    print(count)
    count+=1

    • 输出：

      • 0
        1
        2
        3
        4

break-跳出整个循环体

• 在满足什么条件下，跳出循环

  • 节省内存

• 练习-while+break

  • count =0
    while count<5:
    print(count)
    count+=1
    if count ==3:
    break

    • 当count ==3时，跳出循环

    • 输出：

      • 0
        1
        2

• 练习-for+break

  • for i in range(1,10,2):
    if i >6:
    break
    print(i)

    • 当i >6时，跳出循环

    • 输出：

      • 1
        3
        5

continue-跳出当前轮次循环

• 在满足什么条件下，跳出当前次循环

• 练习-while+continue

  • count =0
    while count<5:
    if count ==3:
    count += 1.1
    continue
    print(count)
    count += 1

    • 当count ==3时，跳出本次循环

      • continue 后面的语句不再执行，进入下一轮循环

    • continue 之前，需要更新变量的值，否则会进入死循环

    • 输出：

      • 0
        1
        2
        4

• 练习-for+continue

  • for i in range(1,5):
    if i ==3:
    continue
    print(i)

    • 当i ==3时，跳出本次循环

    • 输出：

      • 1
        2
        4

pass-不影响代码的执行逻辑

• 没有实质性含义，通常占位使用

• 不影响代码的执行逻辑

• 案例

  • print(‘A’)
    pass
    print(‘B’)

    • 输出：

      • A
        B

for循环-实例

• 计算1~100求和

  • 使用分支结构时间1~100之间的偶数求和

    • sum = 0
      for i in range(1,101):
      if i%2 == 0:
      sum += i
      print(sum)

      • 对值取余，如果余为0，这是偶数

  • 不使用分支结构时间1~100之间的偶数求和

    • sum = 0
      for i in range(0,101,2):
      sum +=i
      print(sum)

      • 使用range中的步长

while循环-实例

• 猜数字游戏

  • 计算机出一个1-100之间的随机数由人来猜，

    • 计算机根据人才的数字分别

      • 给出提示大一点/小一点/猜对了

  • 代码：

    • import random

computer_num= random.randint(1,100)
while True:
people_num=int(input(“请输入数字”))
if computer_num>people_num:
print(“大一点”)
elif computer_num<people_num:
print(“小一点”)
else:
print(‘猜对了’)
break

#产生随机数函数random，不是python内置的函数，所以需要导入库
#输入函数input返回值是str类型，和int类型比较时，需要转换为int类型

课后练习

• 计算1~100求和

  • 使用分支结构时间1~100之间的奇数求和

    • sum = 0
      for i in range(1,101):
      if i%2 != 0:
      sum += i
      print(sum)

• 对值取余，如果余为0，这是偶数

• 不使用分支结构时间1~100之间的奇数求和

  • sum = 0
    for i in range(1,101,2):
    sum +=i
    print(sum)

    • 使用range中的步长

• 使用while语句实现1-100之间的奇数求和

  • i ,sum = 1,0
    while i <101:
    if i%2 != 0:
    sum +=i
    print(sum)
    i +=1

第9小节_数据结构-列表

1.常用数据结构

list列表

tuple元组

set集合

dict字典

2.如何选择

1.如果需要有序方式呈现数据

• list列表、tuple元组

2.不需求顺序而追求唯一性

• set集合

3.数据结构非常关键， 需要很方便的描述和查找对象，

• dict字典
• 比如测试用例的详细信息，包括用例编号、标题、优先级、预期结果等等

第10小节_列表

1.目标

认识列表数据结构
理解它的概念和特点
了解如何创建列表并访问其中的元素
掌握列表的方法包括怎么添加、修改、删除元素以及对元素进行排序和反转
了解如何操作复杂的嵌套列表
理解和运用列表的推导式

2.列表定义与使用

列表是有序的可变元素，使用中括号包围，元素之间都和分隔

特点

• 列表是动态的，可以随时扩展和收缩
• 列表是异构的，可以同时存放不同类型的对象
• 列表允许出现重复元素

从0 开始

• 0—1—2（索引）

• a—b—c（值）

创建方法

• 1.通过构造函数创建

  • 通过构造函数创建
    list1 = list() #空列表
    list2 = list(‘abcdefg’)#字符串
    list3 = list((1,2,3))#数字
    list4 = list(({1,2},{3,4}))#集合
    list5 = list(({‘a’:7},{‘b’:8}))
    print(type(list1),list1)

    • 输出：

      • <class ‘list’>
        <class ‘list’> [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’]
        <class ‘list’> [1, 2, 3]
        <class ‘list’> [{1, 2}, {3, 4}]
        <class ‘list’> [{‘a’: 7}, {‘b’: 8}]

        • 注意：值的外侧多加一对()

          • list3 = list(1,2,3)#数字
          • 代码报错：Traceback (most recent call last):
            File “E:/资料zmm/jmeter/theninthday/member_1.py”, line 154, in 《module》
            list3 = list(1,2,3)#数字
            TypeError: list expected at most 1 argument, got 3

• 2.中括号创建并填充

  • 中括号创建并填充元素

  • list1 = #空列表
    list2 = [1,2,3]#直接填充对象
    print(type(list1),list1)

    • 输出

      • 《class ‘list’》
      • 《class ‘list’》 [1, 2, 3]

• 3.列表推导式

  • 列表推导式 列出偶数
    li1 = [i for i in range(1,10) if i%2 ==0]
    print(type(li1),li1)

    • 输出

      • 《class ‘list’》 [2, 4, 6, 8]

列表索引：取单个元素

• 默认正向索引，编号从0开始。

  • li1 = [‘a’,‘b’,‘c’,‘d’]
    print(li1[0])
    print(li1[3])

    • 输出

      • a
      • b

• 支持反向索引，编号从-1开始

  • print(li1[-1])
    print(li1[-2])

    • 输出

      • d
      • c

列表切片：取多个元素

• 切片[start:stop:step]

  • 遵循前闭后开的原则

    • start值：只是开始索引值，如果没有指定，默认开始值为0
    • stop值：指示到哪个索引值结束，但不包括这个索引值。如果没有指定，取列表允许的最大索引指
    • step值：步长值指示每一步大小，如果没有指定，则默认步长值为1
    • 三个值都是可选的，非必填的

• 练习

  • #列表切片
    li2 = [10,20,30,40,50,60]
    print(li2[1:4:2])#不省略
    print(li2[1:4])#省略步长
    print(li2[:4])#省略开始，和步长
    print(li2[3::])#省略结束和步长 print(li2[3:])
    print(li2[::2])#省略开始和结束
    print(li2[::-1])#倒序排

    • 注意：切片时,，每个值之间使用冒号 :

列表运算符（* +）：

• 重复：使用* 运算符，可以重复生成列表元素

  • li2 = [‘apple’]*3
    print(li2)

    • 输出

      • [‘apple’, ‘apple’, ‘apple’]

• 合并：使用+运算符，可以将两个列表合二为一

  • li3 = [‘pear’,‘orange’]
    li4 = [‘banana’]
    print(li3+li4)

    • 输出

      • [‘pear’, ‘orange’, ‘banana’]

成员检测：in 、not in

• in：检查一个对象是否在列表汇总，如果在返回True ,否则返回 False

  • li2 = [1,2,3,4,5]
    print(1 in li2)
    print(10 in li2)

    • 输出

      • True
        False

        • 1在li2中，返回True

• not in：检查一个列表是否不包含某个元素。如果不在，返回True。否则反正返回False

  • print(1 not in li2)
    print(10 not in li2)

    • 输出

      • False
        True

3.列表常用方法

添加方法

• append()

  • 方法名

    • append(item):将一个对象item添加到列表的末尾

  • 入参

    • 对象：item

      • 比如：数字，浮点数，字符串，列表，字典，元组，集合 都可以

  • 是否必填

    • 必填

  • 默认值

    • 无

  • 返回值

    • None

  • 练习

    • li3 =
      li3.append(1)
      li3.append(‘abcd’)
      li3.append((3.14,1.23))
      li3.append([10,20,30])
      print(len(li3),li3)

      • 输出

        • 4 [1, ‘abcd’, (3.14, 1.23), [10, 20, 30]]

• extend()

  • 方法名

    • extend(iterable):将一个可迭代对象的所有元素，添加到列表末尾

      • 可迭代对象：可以作用于for循环来进行遍历的对象

  • 入参

    • 可以迭代的对象 iterable

      • 比如：字符串，列表，集合，元组，字典

  • 是否必填

    • 必填

  • 默认值

    • 无

  • 返回值

    • None

  • 练习：

    • li3 =
      li3.append(‘hello’)
      li3.extend(“hello”)
      li3.extend([10,20])
      li3.extend(({‘a’:3},{‘b’:5}))
      print(len(li3),li3)

      • 输出：

        • 1 [‘hello’]

        • 6 [‘hello’, ‘h’, ‘e’, ‘l’, ‘l’, ‘o’]

          • append 和extend的区别

        • 10 [‘hello’, ‘h’, ‘e’, ‘l’, ‘l’, ‘o’, 10, 20, {‘a’: 3}, {‘b’: 5}]

• insert()

  • 方法名

    • insert(index,item):将一个对象插入到指定的索引位置

    • 原来索引位置及后面的元素后移一位

      • 在第几个所索引处插入值

  • 入参

    • index：索引值，item:一个对象

  • 是否必填

    • 必填

  • 默认值

    • 无

  • 返回值

    • None

  • 练习

    • lis3 = [1,2,3,4]
      lis3.insert(1,‘a’)
      print(lis3)

      • 输出：

        • [1, ‘a’, 2, 3, 4]

删除方法

• pop()

  • 方法名

    • pop(index)或者pop()
    • 弹出并返回所指定索引的元素

  • 入参

    • index:索引值
    • 注意：如果索引值不正确，或者列表已经为空，则引发IndexError错误

  • 是否必填

    • 非必填

  • 默认值

    • 不填，默认返回最后一个索引的值

  • 返回值

    • 指定索引值：返回指定索引的元素
    • 未指定索引：则返回末尾元素

  • 练习

    • lis3 = [‘a’,‘b’,‘c’]
      print(lis3)
      print(lis3.pop(1))
      print(lis3)

      • [‘a’, ‘b’, ‘c’]
        b
        [‘a’, ‘c’]

    • print(lis3.pop())

      • c

    • 越界报错练习

      • print(lis3.pop(3))

        • IndexError: pop index out of range

    • 空列表练习

      • lis4 =
        print(lis4.pop())

        • IndexError: pop from empty list

• remove()

  • 方法名

    • remove(intem)
    • 移除列表中第一个等于item的元素

  • 入参

    • 指定元素item
    • 注意：目标元素必须存在，否则会报错 ValueError

  • 是否必填

    • 子主题 1

  • 默认值

    • None

  • 返回值

    • None

  • 练习

    • lis3 = [‘a’,‘b’,‘c’,‘d’]
      lis3.remove(‘b’)
      print(lis3)

      • [‘a’, ‘c’, ‘d’]

    • 不存在报错练习

      • lis3.remove(‘e’)
        print(lis3)

        • ValueError: list.remove(x): x not in list

排序方法

• sort()

  • 方法名

    • sort(key=None,reverse=False)
    • 对列表进行原地排序，只使用<来进行各项间比较

  • 入参

    • key:指定带有一个参数的函数。用于从每个列表元素中提取比较键
    • reverse：默认值为False，表示升序；为True表示降序

  • 是否必填

    • key：非必填
    • reverse：非必填

  • 默认值

    • reverse:默认是False，代表升序

  • 返回值

    • None

  • 练习

    • 升序

      • li1 = [5,3,6,7,1,2]
        li1.sort()
        print(li1)

        • [1, 2, 3, 5, 6, 7]

    • 降序

      • li1 = [5,3,6,7,1,2]
        li1.sort(reverse=True)
        print(li1)

        • [7, 6, 5, 3, 2, 1]

      • 和列表切片达到一样的效果：

        • print(li2[::-1])#倒序排

    • 特殊规则(字符串长度)

      • li1 = [‘abce’,‘desbf’,‘ddesa’,‘lk’]
        li1.sort(key=len)
        print(li1)

        • [‘lk’, ‘abce’, ‘desbf’, ‘ddesa’]

• reverse()

  • 方法名

    • reverse()：将列表中断元素顺序反转

  • 入参

    • 无

  • 是否必填

    • 无

  • 默认值

    • 无

  • 返回值

    • None

  • 练习

    • li1 = [5,3,6,7,1,2]
      li1.reverse()
      print(li1)

      • [2, 1, 7, 6, 3, 5]

4.列表嵌套

是指在列表中存放列表

• 定义

  • li2 = [[1,5,2,1,4,5,],[‘a’,‘c’,‘b’]]
    print(type(li2),li2)
    print(len(li2),li2)

列表中常用方法都适用于嵌套列表

• 索引

  • print(li2[1][2]) #打印出索引为1中的索引为2的元素

• 追加

  • #嵌套追加
    li2[1].append(‘f’)
    print(li2)

5.列表推导式(推荐使用，提高效率)

是指循环穿件列表，相当于for 循环创建列表的简化版

语法：[x for x in li if x …]

练习：

• 1.将1-10 中所有偶数平方后组成新的列表

• #普通做法

  • li2 =
    for i in range(1,11):
    if i%2 ==0:
    li2.append(i**2)
    print(li2)
    • [2, 4, 6, 8, 10]

• #列表推导式

  • li1= [x**2 for x in range(1,11) if x%2 ==0 ]
    print(li1)
    • [2, 4, 6, 8, 10]

第11小节_元组

1.目标

认识元组数据结构
理解概念和特点
了解如何创建元素
掌握元组的方法
熟悉元组和列表的异同

2.作用

保证对象维持不变

不能随意被其他人或这其他地方的代码所修改

3.元组

类似于列表的不可变扽有序集合

4.元组定义与使用

定义：

• 是有序的不可变对象集合

  • 类似一个常量

• 使用小括号包围，各个对象之间使用逗号分隔

• 是异构的，可以包含多种数据类型

创建：

• 使用逗号分隔

  • 单元素

    • t6 = 1,
      print(t6)

      • (1,)

        • 注意：当一个元组里只有一个元素时，末尾的都好一定不能丢

  • 多元素

    • t1 = 1 , 2 , 3
      print(type(t1))
      print(t1)

      • <class ‘tuple’>
        (1, 2, 3)

• 通过小括号填充

  • t2 = (1,2,3,4)
    print(t2)
    t3 = (‘a’,‘b’,‘c’)
    print(t3)

    • (1, 2, 3, 4)
      (‘a’, ‘b’, ‘c’)

• 通过构造方法 tuple(iterable)

  • t4 = tuple()
    print(type(t4),t4)

    • <class ‘tuple’> ()

  • 字符串

    • t5 = tuple(‘hello’)
      print(t5)

      • (‘h’, ‘e’, ‘l’, ‘l’, ‘o’)

  • 列表

    • t5 = tuple([1,3,2])
      print(t5)

      • (1, 3, 2)

  • 报错练习：

    • t5 = tuple(1,3,2)
      print(t5)

      • TypeError: tuple expected at most 1 argument, got 3

    • 注意：tuple(iterable),只能有一个参数

索引：

• 可以通过索引值来访问对应的元素

  • t5 =(‘abc’,‘def’,‘deg’)

  • print(t5)

    • (‘abc’, ‘def’, ‘deg’)

• 正向索引，默认编号从0开始

  • print(t5[1])

    • def

• 反向索引，默认编号从-1开始

  • print(t5[-1])

    • deg

切片：

• 切片[start:stop:step]

  • 遵循前闭后开到原则

• 三个值都是可选 ，非必填

• start:

  • 指示开始索引指，如果没有指定，则默认开始指为0

• stop:

  • 指示到哪个索引值结束，但不包括这个结束索引值。如果没有定义，则取列表允许的最大索引值

• step:

  • 步长值指示每一步大小，如果没有指定，则默认步长为1

• 练习：

  • tup1 = tuple(“hello”)

  • print(tup1)

    • (‘h’, ‘e’, ‘l’, ‘l’, ‘o’)

  • print(tup1[0:3:2])

    • (‘h’, ‘l’)

  • print(tup1[::2])

    • (‘h’, ‘l’, ‘o’)

      • 注意：没有设置结束索引，最后一个值也会被打印出来

  • 反转

    • print(tup1[::-1])

      • (‘o’, ‘l’, ‘l’, ‘e’, ‘h’)

        • 子主题 1

5.元组常用方法

因为元组是不可变的，所以不支持新增，修改，删除等操作

查索引：index(值)

• 定义：index(iterable)返回与目标元素相匹配的首个元素的索引

• 入参：元组中的值

• 是否必填

  • 必填

• 返回值：

  • 入参在元组中，

    • 返回与目标元素相匹配的首个元素的索引

  • 入参不在元组中，会报错

    • ValueError: tuple.index(x): x not in tuple

  • 不填入参，会报错

    • TypeError: index expected at least 1 argument, got 0

  • 如果入参，在元组中出现多次，返回第一次出现的索引

• 练习：

  • up1 = tuple(‘hello’)

  • print(tup1)

  • print(tup1.index(‘s’))

    • 报错

      • 入参不在元组中

  • print(tup1.index())

    • 报错

      • 不能没有入参

  • print(tup1.index(‘h’))

    • 0

  • print(tup1.index(‘l’))

    • 2

      • 出现2次’l‘，但是值返回第一次出现的索引

查次数：count()

• 定义：count(item):返回某个元素出现的测试

• 入参：对象item,元组中的值

• 是否必填

  • 必填

• 返回值

  • 次数

• 练习：

  • tup1 = tuple(‘hello’)
    print(tup1.count(‘l’))

    • 2

      • 字母’l‘出现了2次

  • 参数不能为空

    • 报错

      • TypeError: tuple.count() takes exactly one argument (0 given)

解包：平行赋值

• 元组解包：把一个可迭代对象里的元素，一并赋值到由对应的变量组成的元组中

• 传统赋值

• 解包赋值

  • a, b, c, d = (1, 2, 3, ‘aaaa’)
    print(a,b,c,d)

    • 1 2 3 aaaa

  • 注意：= 两边的个数是相等的

6.元组和列表

相同点

• 都是有序的
• 都是异构的，能够包含不同类型的对象
• 都支持索引和切片

区别

• 声明方式不同，元组使用(),列表使用
• 列表是可变的，元组是不可变的

第12小节_集合

1.作用

比如快速消除重复的元素

2.目标

认识集合数据结构

理解它的概念和特点

了解如何创建集合

熟悉集合中常用的方法

熟悉集合的并集、交集、差集操作

理解集合推导式的用法

3.集合定义和使用

定义：无序的唯一对象集合

用大括号{}包围，对象互相之间使用逗号分隔

集合是异构的，可以包括不同类型的数据

特点

• 唯一性

  • 集合中的元素，不能重复

• 无序性

  • 不会按照你输入的顺序，进行排序

• 伸缩性

  • 集合是动态的，可以随时添加或删除元素

创建集合

• 通过使用{}填充元素

  • set1 = {1,2,3,3}
    print(set1,type(set1))

    • {1, 2, 3} <class ‘set’>
    • 去重

• 通过构造函数set(iterable)

  • 字符串，列表，元组，集合，字典

  • set2 = set(“庄馨月爱妈妈”)
    print(set2,type(set2))

    • {‘月’, ‘馨’, ‘妈’, ‘爱’, ‘庄’} <class ‘set’>

  • set3 = set([2,2,1,4,5,3])
    print(set3,tyep(set3))

    • {1, 2, 3, 4, 5} <class ‘set’>

  • set4 = set()
    print(set4,type(set4))

    • set() <class ‘set’>

• 通过集合推导式

  • set5 ={i for i in range(5) if i%2 == 0}
    print(set5,type(set5))

    • {0, 2, 4} <class ‘set’>

4.集合常用方法

成员检测

• 和列表，元组，字典一样，

• in

  • 判断元素是否在集合中存在

    • set6 = set(“hello”)
      print(‘s’ in set6)

      • False

        • #字母‘s’不在set6中

• not in

  • 判断元素是否在集合中不存在

    • set7 = set(“hello”)
      print(‘s’ not in set6)

      • True

添加

• add():单个

  • 定义：add(item):将单个对象添加到集合中

  • 入参：对象item

  • 是否必填

    • 必填

  • 返回值

    • None

  • 练习：

    • set7 = {1,2,3}
      set7.add(5)
      set7.add(‘hello’)
      print(set7)

      • {1, 2, 3, 5, ‘hello’}

    • 参数不能为空

      • 报错

        • TypeError: set.add() takes exactly one argument (0 given)

• update()：多个

  • 定义：update(iterable)批量添加来自可迭代对象中的所有元素

  • 入参：可迭代对象iterable

  • 是否必填

    • 必填

  • 返回值

    • None

  • 练习：

    • set8 = {1,2,3}
      set8.update([6,5,4,“hello”,“小月月”])
      print(set8)

      • {1, 2, 3, 4, 5, 6, ‘hello’, ‘小月月’}

删除

• remove():删除元素必须存在

  • 定义：remove(item)从集合中移除置顶元素item

  • 入参：指定元素值

    • 若指定元素不在集合中，会报错

  • 是否必填

    • 必填

  • 返回值

    • None

  • 练习：

    • set9 = {1,3,2}
      set9.remove(3)
      print(set9)

      • {1, 2}

        • 数字3被删除

    • set9 = {1,3,2}
      set9.remove(4)
      print(set9)

      • KeyError: 4

        • 4不在集合中，报错

• discard()：删除任何元素

  • 定义：discard(item)从集合中移除指定对象item

  • 入参：指定对象值

    • 若指定元素不在集合中，不会报错

  • 是否必填

    • 必填

  • 返回值

    • None

  • 练习：

    • set9 = {1,3,2}
      set9.discard(3)
      print(set9)

      • {1, 2}

        • 数字3被删除

    • set9 = {1,3,2}
      set9.discard(4)
      print(set9)

      • {1, 2, 3}

        • 4不在集合中，但是不会报错

• pop()：随机移除

  • 定义：pop()随机从集合中移除并返回一个元素

  • 入参：无

  • 返回值

    • 被移除的元组

      • 如果集合为空则会引发KeyError

  • 练习：

    • set10 = {1,2,3,4}
      print(set10.pop())
      print(set10)

      • 1

        • 删除元素 1

      • {2, 3, 4}

    • set ={}
      set.pop()

      • TypeError: pop expected at least 1 argument, got 0

• clear()

  • 定义:clear()清空集合，移除所有元素

  • 入参：无

  • 返回值

    • None

  • 练习：

    • #clear()清空
      set11 = {1,3,4,2}
      set11.clear()
      print(set11)

      • set()

集合运算

• 交集运算

  • intersection()

    • 操作符：&

      • 属于a,又属于b

• 并集运算

  • union()

    • 操作符：|

      • 属于a,或属于b

• 差集运算

  • difference()

    • 操作符：-

      • 属于a,但不属于b

• 练习

  • a = {1,3,4}
    b = {2,3,5}

    • 交集

      • print(a.intersection(b))
        print(a&b)

        • 输出：3

    • 并集

      • print(a.union(b))
        print(a|b)

        • {1, 2, 3, 4, 5}

    • 差集

      • print(a.difference(b))
        print(a-b)

        • {1, 4}

5.集合推导式

类似列表的推导式，同样集合支持集合推导式

语法：{i for i in … if …}

练习：

• set12 = { str for str in “hello” if str in “hgwziloveyou”}
  print(set12)

  • {‘o’, ‘h’, ‘e’, ‘l’}

第13小节_字典

1.字典是什么？

又叫哈希表，映射

存放键值对集合

特性在于解释器会通过键去查找对应的值，效率比较高

2.学习目标

字典定义与使用

字典常用方法

字典推导式

实例

3.字典定义

字典是无序的键值对集合

字典用大括号{}包围

每个键/值对之间用一个逗号分隔

• 键：

  • 一般是不可变的，比如一个字符串，数值
  • 在同一个字典层级内，键必须是唯一的

• 值：

  • 可以是python对象，比如字符串，列表，元组，集合，字典等等

• 可以是多个键值对

各个键与值之间用一个冒号分隔

字典是动态的

4.创建字典

使用大括号{}填充键值对

• dict1 = {“name”:“月月”,“age”:4}
  print(dict1,type(dict1))

  • {‘name’: ‘月月’, ‘age’: 4} <class ‘dict’>

通过构造方法dict()

• dict2 = dict([(“name”,“馨馨”),(“age”,6)])
  print(dict2,type(dict2))

  • 键值使用逗号隔开
  • {‘name’: ‘馨馨’, ‘age’: 6} <class ‘dict’>

使用字典推导式

• dict3 ={k:v for k,v in [(“name”,“xinxin”),(“age”,6)] }
  print(dict3,type(dict3))

  • 键值使用逗号隔开
  • {‘name’: ‘xinxin’, ‘age’: 6} <class ‘dict’>

5.字典使用

访问元素

• 与字典也支持中括号记法[key]

  • key:必须存在

    • dict1 = {“name”:“月月”,“age”:4}
      print(dict1[“name”])

      • 月月

  • key:不存在

    • print(dict1[“nam”])

      • KeyError: ‘nam’

• 字典使用键来访问其对应的值

• 访问时对应的key必须要存在

操作元素

• 语法：dict[key] = value

• 添加元素

  • 键不存在

• 修改元素

  • 键已经存在

• 实例：

  • dict1 = {“name”:“月月”,“age”:4}

  • dict1[“name”]=“阳光”

    • 修改元素

      • 键已经存在

  • dict1[“address”]=“深圳”

    • 添加元素

      • 键不存在

  • print(dict1)

    • {‘name’: ‘阳光’, ‘age’: 4, ‘address’: ‘深圳’}

嵌套字典

• 字典的值可以是字典对象

• 实例

  • dict2 = {“name”:“月月”,“age”:4,“course”:{“magic”:100,“python”:80,“english”:90}}

    • 字典中的value的类型是字典

  • print(dict2)

    • {‘name’: ‘月月’, ‘age’: 4, ‘course’: {‘magic’: 100, ‘python’: 80, ‘english’: 90}}

  • 获取课程magic的分数

    • print(dict2[“course”][“magic”])

      • 100

  • 修改课程Python的分数

    • dict2[“course”][“python”]=99

      • {‘name’: ‘月月’, ‘age’: 4, ‘course’: {‘magic’: 100, ‘python’: 99, ‘english’: 90}}

    • print(dict2)

6.字典方法

keys()

• 获取字典中所有的 键

  • 入参：无

  • 返回：由字典键组成的一个新的视图对象

  • 什么视图对象：

    • 1.视图对象提供字典条目的一个动态视图，意味着当字典发生改变时，视图也会相应的改变，

    • 2.字典视图可以被迭代以产生对应的数据，并支持成员检测

      • 可以使用in 或not in来判断某个元素是否在其中

  • 实例：

    • dict2 = {“name”:“月月”,“age”:4,“course”:{“magic”:100,“python”:80,“english”:90}}

    • print(dict2.keys())

      • 输出：dict_keys([‘name’, ‘age’, ‘course’])

values()

• 获取字典中所有的 值

  • 入参：无

  • 返回：由字典键组成的一个新的视图对象

  • 实例：

    • print((dict2.values()))

      • 输出:dict_values([‘月月’, 4, {‘magic’: 100, ‘python’: 80, ‘english’: 90}])

items()

• 获取字典中所有 键值对

  • 入参：无

  • 返回：由字典键组成的一个新的视图对象

  • 实例：

    • print(dict2.items())

      • 输出：dict_items([(‘name’, ‘月月’), (‘age’, 4), (‘course’, {‘magic’: 100, ‘python’: 80, ‘english’: 90})])

  • 转换成list列表对象，方便查看结果

    • print(list(dict2.keys()))

      • [‘name’, ‘age’, ‘course’]

    • print(list((dict2.values())))

      • [‘月月’, 4, {‘magic’: 100, ‘python’: 80, ‘english’: 90}]

    • print(list(dict2.items()))

      • [(‘name’, ‘月月’), (‘age’, 4), (‘course’, {‘magic’: 100, ‘python’: 80, ‘english’: 90})]

get(key)

• 获取字典中某个键的值

  • 定义：get(key)

  • 入参：key:字典的值

  • 是否必传：必传

  • 返回：如果key存在字典中，返回key关联的value值；如果key不存在，则返回None

  • 此方法的好处是无需担心key是否存在，永远都不会引发KeyError错误

  • 实例：

    • key：存在

      • dict2 = {“name”:“月月”,“age”:4,“course”:{“magic”:100,“python”:80,“english”:90}}
        print(dict2.get(“name”))
        print(dict2.get(“age”))

        • 月月
          4

    • key:不存在

      • print(dict2.get(“address”))

        • None

update(dict)

• 更新字典中某个键的值

  • 定义：update(dict)

  • 使用来自dict的键/值对更新字典，覆盖原有的键和值

    • 如果原来的键存在，就是修改
    • 如果原来的键不存在，就是增加

  • 入参：dict:字典对象，必传

  • 返回：None

  • 实例：

    • dict2 = {“name”:“月月”,“age”:4,“course”:{“magic”:100,“python”:80,“english”:90}}

    • dict2.update({“age”:5,“hobby”: “读书”})

    • print(dict2)

      • {‘name’: ‘月月’, ‘age’: 5, ‘course’: {‘magic’: 100, ‘python’: 80, ‘english’: 90}, ‘hobby’: ‘读书’}

        • #修改：age :5 增加hobby：读书

pop(key)

• 删除某个键值

  • 定义：pop(key)

  • 删除指定key的键值对，并返回对应value值

  • 入参：key 必传

  • 返回：如果key存在于字典中，则将其移除，并返回value值；如果key不存在字典中，则会引发KeyError

  • 实例：

    • dict2 = {“name”:“月月”,“age”:4,“course”:{“magic”:100,“python”:80,“english”:90}}

    • val = dict2.pop(“age”)

    • print(val)

      • 4

    • print(dict2)

      • {‘name’: ‘月月’, ‘course’: {‘magic’: 100, ‘python’: 80, ‘english’: 90}}

    • dict2.pop(“hobby”)

      • key不存在，报错KeyError: ‘hobby’

7.字典推导式

可以从任何键值对作为元素的可迭代对象中构建出字典

实例

• 题目1：给定一个字典对象{‘a’:1,‘b’:2,‘c’:3}找到其中所有大于1的键值对，同时value值进行平方运算

• dic1 = {‘a’:1,‘b’:2,‘c’:3}
  dic2 = {k:v**2 for k,v in dic1.items() if v > 1}
  print(dic2)

  • {‘b’: 4, ‘c’: 9}

• 题目2：给定一个字典对象，请使用字典推导式，将它的key和value分别进行交换，也就是key变成值，值变成key

• dic1 = {‘a’:1,‘b’:2,‘c’:3}
  dic2 = {v:k for k,v in dic1.items()}
  print(dic2)

  • {1: ‘a’, 2: ‘b’, 3: ‘c’}

[dongliang (栋梁)]

同学，以文章形式发表出来