Python学习笔记

[TOC]

第一章 软件的安装

1.本章目标

  • 掌握Python解释器的安装与卸载
  • 掌握PyCharm的安装与卸载

Python解释器是一款用于解释、执行Python代码的应用程序

2.Pycharm的简介

PyCharm是一款Python的集成开发环境，在Windows、MacOS和Linux操作系统中都可以使用带有一整 套可以帮助用户在使用Python语言开发时提高效率的工具

3.Pycharm的优势

语法高亮、智能提示、代码调试、Project管理、解释代码、框架和库 … …

4.Pycharm的版本

image-20251024135554162

第二章 Python编程基础

本章目标

  • 了解什么是计算机程序
  • 了解什么是编程语言
  • 了解编程语言的分类
  • 了解静态语言与脚本语言的区别
  • 掌握IPO程序编写方法
  • 熟练应用输出函数print与输入函数input
  • 掌握Python中的注释与缩进

程序设计语言

1.机器语言

是一种 二进制语言，它直接使用二进制代码表达指令，是计算机硬件可以识别和执行的程序设计语言

2.汇编语言

使用方便助记符与机器语言中的指令一一对应

3.高级语言

是接近自然语言的一种计算机程序设计语言，Python、Java都是高级语言

编译与解释

1.编译型

编译型是指将源代码转换成目标代码的过程，通常源代码是高级语言代码，目标代码是机器语言代码， 执行编译的计算机程序称为编译器（Complier）

image-20251024135748021

2.解释型

解释型是将源代码逐行转换成目标代码的过程，执行解释的计算机程序称为解释器（Interpreter）

image-20251024135811296

1. ＩＰＯ程序编写法

IPO（Input，Process，Output）

输入–>处理（process）–>输出

2. 基本的输出函数print

语法结构：

print（输出内容）

print（ value，…，sep=’ ‘，end=’\n’, file=None ）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#demo 1
print('Hello Python!')
# 示例2-1用print函数进行简单输出
a = 100
b = 50
print(90)
print(a)
print(a * b)
print('北京欢迎你！')
print("北京欢迎你！")
print('''北京欢迎你!''')
print("""北京欢迎你！""")
# 示例2-2不换行一次输出多个数据
print(a, b, '要么出众，要么出局！！！')
# 示例2-3输出ASCII表所对应的字符
print('b')
print(chr(98))
print('C')
print(chr(67))
print(8)
print(chr(56))
print('[')
print(chr(91))
# 示例2-4使用print函数输出中文Unicode码
print(ord('北'))
print(ord('京'))
print(chr(21271), chr(20140))
# 示例2-5使用print函数将内容输出到文件
fp = open('note.txt', 'w')  # 打开文件 w-->write
print('北京欢迎你', file=fp)  # 将“北京欢迎你”输出（写入）到note.txt文件中
fp.close()  # 关闭文件
# 示例2-6多条print函数输出结果一行显示
print('北京', end='-->')
print('欢迎你')  # 没有修改 结束符，所以print之后会有一个空行
# 示例2-7使用连接符连接多个字符串
print('北京欢迎你'+'2023')  # 只能字符串与字符串连接

3. 基本的输入函数input

语法结构：

x=input (‘提示文字’)

注意事项： 无论输入的数据是什么，x的数据类型都是字符串类型

1
2
3
4
5
6
7
8
# 示例2-8 input函数的使用
name = input('请输入你的姓名：')
print('我的姓名是：' + name)
# 示例2-9 输入整数类型的数据
num = input('请输入您的幸运数字：')
print('您的幸运数字是：' + num)  # 连接成功，说明num是字符串类型
num = int(num)  # 使用内置函数int将num转成整数类型
print('您的幸运数字是：', num)

4. Python中的注释

  • 序员在代码中对代码功能解释说明的标注性文字
  • 可以提高代码的可读性
  • 注释的内容将被Python解释器忽略，不被计算机执行

分类:

单行注释，多行注释和中文声明注释

1
2
3
4
5
6
# 示例2-10单行注释
year = input('请输入您的出生年份；')  # 要求从键盘输入出生年份，要是4位的年份，举例：
1990
# 示例2-11多行注释
#coding=utf-8
#中文声明注释一定要写在第一行

5. 代码缩进

  • 是指每行语句开始前的空白区域
  • 用来表示Python程序间的包含和层次关系
  • 类定义，函数定义，流程控制语句以及异常处理语句等行尾的冒号和下一行的缩进表示一个代码块 的开始，而缩进结束，则表示一个代码块的结束
  • 通常情况下采用4个空格作为一个缩进量
1
2
3
4
5
6
7
8
9
10
# 实例2-12 代码缩进
# 一般代码 不需要缩进
print('hello')
print('world')
# 类的定义
class Student:
    pass
# 函数的定义
def fun():
    pass

6. 第二章本章总结

  • 程序设计语言又被称为编程语言
  • 计算机程序是使用编程语言组织起来的一组计算机指令
  • 计算机指令就是指挥机器工作的指示和命令
  • 编程语言可分为机器语言，汇编语言和高级语言
  • 采用编译方式执行语言称为静态语言（eg.Java语言）
  • 采用解释方式执行的语言称为脚本语言（eg.Python语言）
  • IPO指的是输入，处理和输出
  • print()函数完整的语法格式：print（value，…，sep=’ ‘，end=’\n’,file=None）
  • 输入函数input的语法格式为：x=input (‘提示文字’)
  • Python中的注释可分为单行注释，多行注释和中文声明注释
  • Python语言常用严格的“缩进”来表示程序逻辑

第三章 数据类型和运算符

1.保留字与标识符

1.保留字：

指在Python中被赋予特定意义的一些单词，在开发程序时，不可以把这些保留字作为变量，函数，类， 模块和其他对象的名称来使用

image-20251024141056138

1
2
3
4
5
6
7
# 示例3-1查询Python中的保留字
import keyword
print(keyword.kwlist)
print(len(keyword.kwlist))  # 获取保留字的个数
# 示例3-2保留字严格区分大小写
true = '真'
# True='真' # 结果报错

2.Python标识符的命名规则

  • 可以是字符（英文、中文）、下划线“_”和数字，并且第一个字符不能是数字
  • 不能使用Python中的保留字
  • 标识符严格区分大小写
  • 以下划线开头的标识符有特殊意义，一般应避免使用相似的标识符
  • 允许使用中文作为标识符，但不建议使用

3.Python标识符的命名规范

  • 模块名尽量短小，并且全部使用小写字母，可以使用下划线分割多个字母。

    例如：grame_main

  • 包名尽量短小，并且全部使用小写字母，不推荐使用下划线。

    例如：com.ysjpython , 不推荐使用com_ysjpythonb

  • 类名采用单词首字母大写形式（Pascal风格）。

    例如：MyClass

  • 模块内部的类采用 “_” + Pascal 风格的类名组成，

    例如：在MyClass中的内部类 _InnerMyClass _

  • 函数、类的属性和方法的命名，全部使用小写字母，多个字母之间使用下划线分隔

  • 常量命名时采用全部大写字母，可以使用下划线

  • 使用单下划线 “_” 开头的模块变量或函数是受保护的，在使用 “from xxx import *” 语句从模块中导入时，这些模块变量或函数不能被导入

  • 使用双下划线 “__” 开头的实例变量或方法是类私有的

  • 以双下划线开头和结尾的是Python的专用标识，

    例如：__ init __()表示初始化函数

2.变量与常量

1.变量的语法结构

变量名=value

举例： luck_number=8
（栈内存） （堆内存）

1
2
3
4
5
6
7
8
9
10
11
12
13
# 示例3-3变量的定义和使用
luck_number = 8  # 创建一个整型变量luck_number，并为其赋值为8
my_name = 'xxx'  # 字符串类型的变量
print('luck_number的数据类型是：',type(luck_number))
print(my_name,'的幸运数字是：',luck_number)
# Python动态修改变量的数据类型，通过赋不同类型的值就可以直接修改
luck_number='北京欢迎你'
print('luck_number的数据类型是：',type(luck_number))  # <class 'str'>
# 在Python中允许多个变量指向同一个值
no=number=1024
print(no,number)
print(id(no)) # id()查看对象的内存地址 2799143989456
print(id(number)) # 2799143989456

2.变量命名应遵循以下几条原则

  • 变量名必须是一个有效的标识符
  • 变量名不能使用Python中的保留字
  • 慎用小写字母i（挨）和大写字母O
  • 应选择有意义的单词作为变量名

3.常量

常量就是在程序运行过程中，值不允许改变的量，全部使用大写字母和下划线命名。

1
2
3
# 示例3-4常量的定义
pi=3.1415926 # 定义了一个变量
PI=3.1415926 # 定义了一个常量

3.数值类型

1.整数类型

整数类型表示的数值是没有小数部分的数值，包括正整数、负整数和0

image-20251024141701735

1
2
3
4
5
6
7
8
9
# 示例3-5整数的四种表示形式
num=987 # 默认是十进制，表示整数
num2=0b1010101 #　使用二进制表示整数
num3=0o765 # 使用八进制表示整数
num4=0x87ABF # 使用十六进制表示整数
print(num)
print(num2)
print(num3)
print(num4)

2.浮点数类型

浮点数类型表示带有小数点的数值，由整数部分和小数部分组成

注意事项： 两个浮点类型的数在进行运算时，有一定的概率运算结果后会增加一些“不确定的”尾数 Python中的复数与数学中的复数形式完全一致，由实部和虚部组成

image-20251024141744741

在Python中实数部分使用**.real表示，虚数部分使用.imag**表示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 示例3-6浮点数类型的使用
height = 187.6  # 身高
print(height)
print(type(height))  # type()查看height这个变量的数据类型
x = 10
y = 10.0
print('x的数据类型:', type(x))  # int
print('y的数据类型:', type(y))  # float
x = 1.99E1413
print('科学记数法:', x, 'x的数据类型：', type(x))
print(0.1 + 0.2)  # 不确定的尾数问题0.30000000000000004
print(round(0.1 + 0.2, 1))  # 0.3
# 示例3-7复数类型的使用
x = 123 + 456j
print('实数部分：', x.real)  # 实数部分： 123.0
print('虚数部分：', x.imag)  # 虚数部分： 456.0

3.字符串类型

字符串类型连续的字符序列，可以表示计算机所能识别的一切字符

字符串的界定符：单引号、双引号、三引号

image-20251024141822557

image-20251024141829434

原字符：使转义字符失效的字符，r或R

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 示例3-8字符串类型的使用
city = '天津'
address = '天津市宝坻区香江大街3号'
print(city)
print(address)
# 多行字符串
info = '''地址：天津市宝坻区香江大街3号
   收件人：zjh
   手机号：18800000000
'''
info2="""地址：天津市宝坻区香江大街3号
   收件人：zjh
   手机号：18800000000
"""
print(info)
print('--------------------')
print(info2)
#示例3-9转义字符的使用
print('北京')
print('欢迎你')
print('--------------')
print('北京\n欢迎你')  # 遇到\n即换行，可以连续多行
print('北\n京\n欢\n迎\n你')
print('--------------')
print('北京\t欢迎你')
print('hello\toooooo')  # hello是5个字符，一个制表位是8个字符 8-5=3
print('hellooooooo')
print('老师说：\'好好学习，天天向上\'')
print('老师说：\"好好学习，天天向上\"')
# 原字符，使转义字符失效的符号r或R
print(r'北\n京\n欢\n迎\n你')
print(R'北\n京\n欢\n迎\n你')

字符串又被称为有序的字符序列，对字符串中某个字符的检索称为索引

image-20251024141900935

对字符串中某个子串或区间的检索称为切片

切片的语法结构

字符串或字符串变量[N:M]

1
2
3
4
5
6
7
8
9
10
# 示例3-10字符串的索引和切片
s = 'HELLOWORLD'
print(s[0], s[-10])  # 序号0和序号-10表示的是同一个字符
print('北京欢迎你'[4])  # 获取字符串中索引为4
print('北京欢迎你'[-1])
print('--------------------')
print(s[2:7])  # 从2开始到7结束，不包含7 正向递增
print(s[-8:-3])  # 反向递减
print(s[:5])  # 默认N从0开始
print(s[5:])  # M 默认是切到字符串的结尾

常用的字符串操作

image-20251024142020014

1
2
3
4
5
6
7
8
#示例3-11字符串类型的操作
x = '2022年'
y = '北京冬奥会'
print(x + y)  # 连接两个字符
print(x * 10)  # 对x这个字符串的内容复制10次
print(10 * x)
print('北京' in y)  # True
print('上海' in y)  # False

4.布尔类型

  • 用来表示“真”值或“假”值的数据类型
  • 在Python中使用标识符True或False标示布尔类型的值
  • True表示整数1，False表示整数0

布尔值为False的情况如下

  • False或者是None
  • 数值中的0，包含0，0.0，虚数0
  • 空序列，包含空字符串、空元组、空列表、空字典、空集合
  • 自定义对象的实例，该对象的__bool__()方法返回False或__len__()方法返回0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 示例3-12布尔类型的使用
x = True
print(x)
print(type(x))
print(x + 10)  # 11   -->1+10
print(False + 10)  # 10-->0+10
print('-------------------')
print(bool(18))  # 测试一下整数18的布尔值True
print(bool(0), bool(0.0))  # False
# 总结，非O的整数的布尔值都是True
print(bool('北京欢迎你'))  # True
print(bool(''))  # False
# 所有非空字符串的布尔值都是True
print(bool(False))

5.数据类型之间的转换

  • 类型转换–>（1）隐式转换 （2）显示转换

    image-20251024142148150

image-20251024142156346

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#示例3-13数据类型之间的转换
x = 10
y = 3
z = x / y  # 执行除法运算的时候，将运算的结果赋值给z
print(z, type(z))  # 隐式转换，通过运算隐式的转了结果的类型
# float类型转成int类型，只保留整数部分
print("float类型转成int类型：", int(3.14))
print("float类型转成int类型：", int(3.9))
print("float类型转成int类型：", int(-3.14))
print("float类型转成int类型：", int(-3.9))
# 将int转成float类型
print('将int转成float类型：', float(10))
# 将str转成int类型
print(int('100') + int('200'))
# 将字符串转成int或float时报错的情况
# print(int('18a')) # ValueError: invalid literal for int() with base 10: 
'18a'
# print(int('3.14')) # ValueError: invalid literal for int() with base 10: 
'3.14'
# print(float('45a.987')) # ValueError: could not convert string to float: 
'45a.987'
# chr()ord()一对、
print(ord('张'))  # 张在unicode表中对应的整数值
print((chr(24352)))  # 24352整数在unicode表中对应的字符是什么
# 进制之间的转换操作，十进制与其他进制之间的转换
print('十进制转成十六进制：', hex(23452))
print('十进制转成八进制：', oct(23452))
print('十进制转成二进制：', bin(23452))

4.eval函数

1.eval函数：

  • Python中的内置函数
  • 用于去掉字符串最外侧的引号，并按照Python语句方式去掉引号后的字符串
  • eval（）函数经常和input（）函数一起使用

2.eval的语法格式

变量=eval（字符串）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 示例3-14eval函数的使用
s = '3.14+3'
print(s, type(s))
x = eval(s)  # 使用eval函数去掉s这个字符串中左右的引号，执行加法运算
print(x, type(x))
# eval函数经常与input()函数一起使用，用来获取用户输入的数值
age = eval(input('请输入您的年龄：'))  # 将字符串类型转成了int类型，相当于int(age)
print(age, (type(age)))
height = eval(input('请输入您的身高：'))
print(height, type(height))
hello = '北京欢迎你'
print(hello)
print(eval('hello'))  # 输出了“北京欢迎你”
# print(eval('北京欢迎你')) #NameError: name '北京欢迎你' is not defined

5.算术运算符

算术运算符：用于处理四则运算的符号

image-20251024142339587

算数运算符的优先级由高到低的是：

第一级：**

第二级：*、/、%、//

第三级：+、-

1
2
3
4
5
6
7
8
9
# 示例3-15算数运算符的使用
print('加法',1+1)
print('减法',1-1)
print('乘法',2*3)
print('除法',10/2)
print('整除',10//3)
print('取余',10%3)
print('幂运算',2**4) # 2*2*2*2
print(10/0) # ZeroDivisionError: division by zero

6.赋值运算符

image-20251024142422789

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# 示例3-16赋值运算符的使用
x = 20  # 直接赋值，直接将20赋值给左侧的变量x
y = 10
x = x + y  # 将x+y的和赋值给x，x的值为30
print(x)  # x的值是30
x += y  # 40 相当于x=x+y
x -= x - y  # 相当于x=x-y
print(x)  # 30
x *= y
print(x)  # 300
x /= y
print(x)  # 30.0 发生了类型转换 x的数据类型为float类型
print(type(x))  # <class 'float'>
x %= 2  # 相当于x=x%2
print(x)  # 0.0
z = 3
y //= z  # 相当于y=y//z
print(y)  # 3
y **= 2  # 相当于y=y**2
print(y)  # 9
# Python支持链式赋值
a = b = c = 100  # 相当于执行 a=100 b=100 c=100
print(a, b, c)
# Python支持系列解包赋值
a, b = 10, 20  # 相当于执行了a=10 b=20
print(a, b)
print('----如何交换两个变量的值呢？----')
a, b = b, a  # 将b的值赋给a，将a的值赋给b
print(a, b)

7.比较运算符

image-20251024142447404

1
2
3
4
5
6
7
# 示例3-17比较运算符的使用
print('98大于90吗？',98>90)
print('98小于90吗？',98<90)
print('98等于90吗？',98==90)
print('98不等于90吗？',98!=90)
print('98大于等于90吗？',98>=90)
print('98小于等于90吗？',98<=90)

8.逻辑运算符

image-20251024142503907

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 示例3-18逻辑运算符的使用
print(True and True)
print(True and False)
print(False and False)
print(False and True)
print('-'*30)
print(8 > 7 and 6 > 5)  # True
print(8 > 7 and 6 < 5)  # False
print(8 < 7 and 10 < 0)  #False,10/0并没有运算，当第一个表达式的结果为False，直接得
结果，不会计算and右侧的表达式了
print('-'*30)
print(True or True)
print(True or False)
print(False or False) #False
print(False or True)
print('-'*30)
print(8>7 or 10/0) #True,表达式结果为True时，or的右侧表达式根本不执行运算符
print('-'*30)
print(not True) #False
print(not False) #True
print(not (8>7))

9.位运算符

1.位运算符：

把数字看作二进制数来进行计算的

image-20251024142531892

image-20251024142534282

image-20251024142540337

2.“左移位”运算（<<）

是将一个二进制数向左移动指定的位数，左边（高位端）溢出的位被丢弃，右边（低位端）的空位用0补充

image-20251024142601879

3.“右移位”运算（<<）

将一个二进制数向右移动指定的位数，右边（低位端）溢出的位被丢弃，左边（高位端）的空位端，如 果最高位是0（正数）左侧空位填0，如果最高位是1（负数），左侧空位填1。

image-20251024142619061

4.运算符的优先级

image-20251024142629337

10.第三章本章总结

  • 保留字是Python已经被赋予特定意义的一些单词，保留字严格区分大小写
  • 标识符可用来给变量、函数、类、模块和其他对象命名
  • 标识符的命名规则：
    • 可以是字母（包含中文）、数字、下划线，第一个字符不能是数字
    • 不能是Python中的保留字
    • 标识符严格区分大小写
    • 以下划线开头的标识符有特殊意义，不能随便使用
    • 允许使用中文作为标识符，但不建议使用
  • 变量的语法结构： 变量名=value
  • 整数类型有四种表示形式：二进制、八进制、十进制和十六进制
  • 浮点数可以使用内置函数round()限定运算结果需要保留的小数位数
  • 字符串又称为不可变字符序列，可根据索引检索元素，也可根据索引引进行切片操作
  • 布尔类型有两种取值True和False
  • 常用的数据类型转换函数为int()、float()和str()
  • 内置函数eval()可接字符串转换成真实的数据类型
  • 算术运算符：+、-、＊、/、//、%、**
  • 赋值运算符：=、+=、-=、*=、/=、//=、%=、**=
  • 比较运算符：>、>=、<、<=、==、!=
  • 逻辑运算符：and、or、not 位运算符：&、|、Λ、~、<<、>>

第四章 程序的流程控制

1.本章目标

  • 了解程序的描述方式
  • 了解程序的组织结构
  • 掌握顺序结构
  • 掌握循环结构for与while
  • 掌握程序跳转语句break和continue
  • 掌握pass空语句

2.程序描述的方式

1.自然语言

自然语言就是使用人类语言、直接描述程序

image-20251024142909937

2.流程图

流程图是用一系列图形、流程线和文字说明描述程序的基本操作和控制流程主要适用于较短的算法

image-20251024142930308

image-20251024142933427

3.伪代码

伪代码是介于自然语言和编程语言之间的一种算法描述语言，如果程序比较小，可以直接使用代码描述

image-20251024142956721

3.程序的组织结构

image-20251024143008574

1.顺序结构

顺序结构按程序语句的自然顺序，从上到下，依次执行每条语句的程序

image-20251024143024439

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 示例4-1顺序结构的语句
# 赋值运算符的顺序 从右到左
name='张三'
age=20
a=b=c=d=100 # 链式赋值
a,b,c,d='room'# 字符中分解值
print(a)
print(b)
print(c)
print(d)
print('---------输入/输出语句也是典型的顺序结构----------')
name=input('请输入您的姓名:')
age=eval(input('请输入您的年龄：'))
luck_number=eval(input('请输入您的幸运数字：'))
print('姓名：',name)
print('年龄：',age)
print('幸运数字：',luck_number)

2.选择结构

选择结构也称分支结构，是按照条件选择执行不同的代码段

1.单分支结构if的语法结构

if 表达式：

​ 语句块

image-20251024143102285

执行流程：

如果表达式的值为True，就执行语句快，如果表达式的值为False，就跳过语句块，继续执行后面的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 示例4-2单分支结构if
number = eval(input('请输入您的6位中奖号码：'))
# 使用if语句
if number == 987654:  # 等值判断
    print('恭喜您，中奖了!')
if number != 987654:
    print('您未中本期大奖')
print('-----以上if判新的表达式，是通过比较运算符计算出来的，结果是布尔值类型----')
n = 98  # 赋值操作
if n % 2:  # 98%2的余数是0，0的布尔值是FaLse，非0的布尔值为True
    print(n, '是奇数')  # 由于98%2的余数是0，所以该行代码不执行
if not n % 2:  # 98%2的余数是0，0的布尔值是FaLse，not FaLse的结采为True
    print(n, '为偶数')
print('------判断一个字符串是否是空字符串----')
x = input('请输入一个字符串：')
if x:  # 在Python中一切皆对象，每个对象都有一个布尔值，而非空字符串的布尔值为True，空字
符串的布尔值为False
    print('x是一个非空字符串')
if not x:  # 空字符中的布尔值为False,取反，not FaLse的结采为True
    print('x是一个空字符串')
print('----表达式也可以是一个单纯的布尔型变量------')
flag = eval(input('请输入一个布尔类型的值：True或False'))
if flag:
    print('flag的值为True')
if not flag:
    print('flag的值为False')
print('-----使用if语句时，如果语句块中只有一句代码，可以将语句块直接写在冒号的后面------
')
a = 10
b = 5
if a > b: max = a  # 语句块只有一句，赋最大值
print('a和b的最大值为：',max)

2.双分支结构if…else…语法结构

if 表达式：

​ 语句1

else：

​ 语句2

image-20251024143155181

执行流程:

如果表达式的值为True，就执行语句1，否则就执行语句2

1
2
3
4
5
6
7
8
9
10
11
# 双分支结构if…else…
number = eval(input('请输入您的6位中奖号码：'))
# if…else…
if number == 987654:
    print('恭喜您中奖了!')
else:
    print('您未中本期大奖')
print('------以上代码可以使用条件表达式进行简化---')
result='恭喜您中奖了!' if number == 987654 else '您未中本期大奖'
print(result)
print('恭喜您中奖了!' if number == 987654 else '您未中本期大奖')

3.多分支语法结构

if 表达式1：

​ 语句块1

elif 表达式2：

​ 语句块2

elif 表达式n：

 语句块n

else:

​ 语句块n+1

image-20251024143306529

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 示例4-4多分支结构的使用
score=eval(input('请输入您的成绩：'))
# 多分支结构
if score<0 or score>100:
    print('成绩有误！')
elif 0<=score<60:
    print('E')
elif 68<=score<70:
    print('D')
elif 70<=score<80:
	 print('C')
elif 80<=score<=90:
    print('B')
else:
    print('A')

单分支结构、双分支结构和多分支结构在实际开发中是可以互相嵌套使用的，内层的分支结构将作为外 层分支结构的语句块使用

image-20251024143331562

1
2
3
4
5
6
7
8
9
10
11
12
# 示例4-5嵌套if的使用
answer=input('请问您喝酒了吗？')
if answer=='y': #answer的值为y表示喝酒了
    proof=eval(input('请输入酒精含量：'))
    if proof<20:
        print('构不成酒驾，祝你一路平安')
    elif proof<80: # 20<=proof<80
        print('已构成酒驾，请不要开车')
    else:
        print('已构成醉驾，请不要开车车！')
else:
    print('你走吧，没你啥事儿！')

在使用and连接多个判断条件时，只有同时满足多个条件，才能执行if后面的语句块。

image-20251024143346814

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 示例4-6使用and连接多个选择条件
user_name=input('请输入你的用户名：')
pwd=input('请输入你的密码：')
if user_name=='aaaa' and pwd=='888888':
    print('登录成功！')
else:
    print('用户名或密码不正确')
    
# 示例4-7使用or连接多个选择条件   
score=eval(input('请输入您的成绩：'))
if score<0 or score>100:
    print('成绩无效！')
else:
    print('您的成绩为',score)
    
#示例4-8Python3.11新特性-模式匹配
score = input('请输入成绩等级：')
match score:
    case 'A':
        print('优秀')
    case 'B':
        print('良好')
    case 'C':
        print('中等')
    case 'D':
        print('及格')
    case 'E':
        print('不及格')

3.循环结构

在Python中循环结构分两类，一类是遍历循环for，一类是无限循环while

1.遍历循环for的语句结构

image-20251024143448996

image-20251024143451861

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 示例4-9遍历for循环的使用
# 遍历字符串
for i in 'hello':
    print(i)
# range函数，Python中的内置函数，产生一个[n,m)的整数序列，包含n，但是不包含m
for i in range(1, 11):
    # print(i)
    if i % 2 == 0:
        print(i, '是偶数')
# 计算1-10之间的累加和
s = 0  # 用于存储累加和
for i in range(1, 11):
    s += i  # 相当于 s=s+i
print('1-10之间的累加和为：', s)
print('-----------100到999之间的水仙花数-------------')
'''
153=3*3*3+5*5*5+1*1*1
'''
for i in range(100, 1000):
    sd = i % 10  # 获取个位上的数字   假设   153%10--> 3
    tens = i // 10 % 10  # 获取十位上的数字   153//10-->15   15%10=5
    hundred = i // 100  # 获取百位上的数字 153//100-->1
    # 判断
    if sd**3+tens**3+hundred**3==i:
        print(i)
        
        
# 示例4-10遍历循环扩展形式
s=0 # 用于存储累加和
for i in range(1,11):
    s+=i
else:
    print('1-10之间的累加和为：',s)

2.无限循环while的语句结构

image-20251024143515507

image-20251024143521133

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# 示例4-11无限循环while的使用
# (1)初始化变量
answer=input('今天上课吗？y/n')
while answer=='y': #　（2）条件判断
    print('好好学习，天天向上') # （3）语句块
    # （4）改变变量
    answer=input('今天要上课吗？y/n')
# 1-100之间的累加和
s=0 # 存储累加和
i=1 # (1)初始化变量
while i<=100: # （2）条件判断
        s+=i # (3)语句块
        # (4) 改变变量
        i+=1 #　相当于i=i+1
print('1-100之间的累加和为：',s)
# 示例4-12无限循环while的扩展形式
# 1-100之间的累加和
s=0 # 存储累加和
i=1 # (1)初始化变量
while i<=100: # （2）条件判断
        s+=i # (3)语句块
        # (4) 改变变量
        i+=1 #　相当于i=i+1
else:
    print('1-100之间的累加和为：',s)
 
# 示例4-13使用无限循环模拟用户登录    
#(1)初始化变量
i=0
while i<3: # (2)条件判断
    # (3)语句块
    user_name=input('请输入您的用户名：')
    pwd=input('请输入您的密码：')
    # 登录操作，if…else…
    if user_name=='zjh' and pwd=='888888':
        print('系统正在登录，请稍候~')
        # 需要改变循环变量，目的，退出循环
        i=8 # 第三行 判断 i<3,8<3 False退出while循环
    else:
        if i<2:
            print('用户名或密码不正确，你还有',2-i,'次机会')
            i+=1 # 相当于i=i+1   #(4)改变变量
# 单分支的判断
if i==3: #　当用户名或密码输入三次不正确的时候，循环执行结束了，i的最大值为3
    print('对不起，三次均输入错误！')

循环结构也可以互相嵌套，在一个循环结构中嵌套另一个完整的循环结构就称为嵌套循环

image-20251024143542939

在嵌套循环中通常用于输出一些图形，例如长方形、三角形、菱形等

image-20251024143549895

4.程序跳转语句

1.break

程序跳转语句break用于跳（退）出循环结构，通常与if一起搭配使用

1.无限循环语法结构

image-20251024144256435

image-20251024144300266

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 示例4-18跳转语句break在while循环中的使用
s=0 # 存储累加和
i=1 # （1）初始化变量
while i<11: # （2）条件判断
    #（3）语句块
    s+=i
    if s>20:
        print('累加和大于20的当前数是：',i)
        break
    i+=1 # （4）改变变量
print('--------------------')
i=0 # 统计登录的次数 （1）初始化变量
while i<3: # （2）条件判断
    # （3）语句块
    user_name=input('请输入用户名：')
    pwd=input('请输入密码：')
    if user_name=='zjh' and pwd=='888888':
       print('系统正在登录，请稍候……')
       break
    else:
        if i<2:
            print('用户名或密码不正确，你还有',2-i,'次机会')
    # (4)改变变量
    i+=1
else: # while…else…
    print('三次均输入错误！')

2.遍历循环语法结构

image-20251024144328503

image-20251024144331155

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 示例4-19break在for循环中的使用
for i in 'hello':
    if i=='e':
        break
    print(i)
print('-----------------------')
for i in range(3):
    # （3）语句块
    user_name = input('请输入用户名：')
    pwd = input('请输入密码：')
    if user_name == 'zjh' and pwd == '888888':
        print('系统正在登录，请稍候……')
        break
    else:
        if i < 2:
            print('用户名或密码不正确，你还有', 2 - i, '次机会')
else: # for…else…
    print('三次均输入错误！')

3.continue

continue的作用是用于跳过本次循环的后续代码，而继续执行

下一次循环操作，continue在循环中通常也是与if一起搭配使用

1.无限循环语法结构

image-20251024144447164

image-20251024144450435

image-20251024144531346

2 . 遍 历 循 环 语 法 结 构

image-20251024144545975

1
2
3
4
5
6
7
8
9
# 示例4-21continue在for循环中的使用
s=0
for i in range(1,101):
    if i%2==1: #奇数
        i+=1
        continue # 不再执行后面的代码了
    # 累加求和的代码
    s+=i
print('1-100之间的偶数和：',s)

5.空语句pass

pass是Python中的保留字

在语法结构中只起到占位符的作用，使语法结构完整，不报错

一般可用在if、for、while、函数的定义、类的定义中

1
2
3
4
5
6
7
# 示例4-22空语句pass
if True:
    pass
while True:
    pass
for i in range(10):
    pass

6.本章总结

  • 程序的描述方式有三种：自然语言、流程图和伪代码 (代码）
  • 程序的组织结构有三种：顺序结构、选择结构（分支结构）、循环结构
  • 选择结构分单分支结构(if)、双分支结构(if….else…)和多分支结构(if…elif…else…）
  • Python3.11新特征模式匹配match…case…结构
  • 循环结构有两种：遍历循环for和无限循环while
  • if结构可以互相嵌套，循环结构也可以互相嵌套，建议最多不超过三层
  • break和continue只能用在循环结构中，break用于退出整个循环结构，continue用于结束本次循环 而进入下一次循环。
  • 空语句pass起到占位符的作用，使用语法结构完整、不报错

第五章 数据组合类型

1.本章目标

  • 了解序列和索引的相关概念
  • 掌握序列的相关操作
  • 掌握列表的相关操作
  • 掌握元组的相关操作
  • 掌握字典的相关操作
  • 掌握集合的相关操作

2.序列和索引

1.定义

序列是一个用于存储多个值的连续空间，每个值都对应一个整数的编号，称为索引、

image-20251024160219446

1
2
3
4
5
6
7
8
9
10
# 示例5-1使用索引检索字符串中的元素
# 正向递增索引
s='helloworld'
for i in range(0,len(s)):
    print(i,s[i],end='\t\t')
print('\n--------------------------------------')
# 反向递减
for i in range(-10,0):
    print(i,s[i],end='\t\t')
print('\n',s[9],s[-1])

2.切片的语法操作

image-20251024160239009

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 示例5-2序列的切片操作
s='HelloWorld'
# 切片操作
s1=s[0:5:2] # 索引从0开始，到5结束（不包含5），步长为2
print(s1)
# 省略了开始位置，start默认从0开始
print(s[:5:1])
# 省略开始位置start，省略步长step，步长默认为1
print(s[:5:])
# 省略结束位置
print(s[0::1]) # stop,默认到序列的最后一个元素（包含最后一个元素）
print(s[5::])
print(s[5:]) # 12行代码与13行代码功能相同，省略了结束，省略了一个步长
# 更改一下步长，步长更改为2
print(s[0:5:2])
# 省略开始位置，省略结束位置，只写步长
print(s[::2]) # 分别获取0,2,4,6,8索引位置上的元素
# 步长为负数
print(s[::-1]) # 可以使用哪句代码替换嗯
print(s[-1:-11:-1])

3.序列的相加操作

image-20251024160255292

image-20251024160313528

image-20251024160321478

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 示例5-3序列的相加相乘操作
s='Hello'
s2='World'
print(s+s2) #产生一个新的字符串序列
# 序列的相乘操作
print(s*5)
print('_'*40)
# 示例5-4序列的相关操作符和函数的使用
s='helloworld'
print('e在helloworld中存在吗？',('e' in s)) # in的使用
print('v在helloworld中存在吗？',('v' in s))
# not in 的使用
print('e在helloworld中不存在吗？',('e' not in s)) # not in 的使用
print('v在helloworld中不存在吗？',('v' not in s))
# 内置函数的使用
print('len():',len(s))
print('max():',max(s))
print('min():',min(s))
# 序列对象的方法，使用序列的名称，打点调用
print('s.index():',s.index('o')) # o在s中第一次出现的索引位置 4
# print('s.index():',s.index('v')) # ValueError: substring not found,报错的原
因是v在字符串中根本不存在，不存在所以找不到
print('s.count():',s.count('o')) # 统计o在字符串s中出现的次数

3.列表类型

1.列表定义

是指一系列的按特定顺序排列的元素组成。

是Python中内置的可变序列

在Python中使用[]定义列表，元素与元素之间使用英文的逗号分隔

列表中的元素可以是任意的数据类型

2.列表的创建方式有两种

(1)使用[]直接创建列表

语法结构如下：

列表名=[element1,element2,……elementN]

(2)使用内置函数list()创建列表

语法结构如下：

列表名=list(序列)

3.列表的删除

语法结构如下：

del 列表名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 示例5-5列表的创建与删除
# 使用[]直接创建列表
lst = ['hello', 'world', 98, 100, 5]
print(lst)
# 可以使用内置的函数list()创建列表
lst2 = list('helloworld')
lst3 = list(range(1, 10, 2))  # 从1开始，到10结束，步长为2，不包含10
print(lst2)
print(lst3)
# 列表是序列中的一种，对序列的操作符，运算符，函数均可以使用
print(lst +lst2 +lst3)  # 序列中的相加操作
print(lst * 3)  # 序列的相乘操作
print(len(lst))
print(max(lst3))
print(min(lst3))
print(lst2.count('o'))  # 统计o的个数
print(lst2.index('o'))  # o在列表lst2中第一次出现的位置
# 序列的删除操作
lst4=[10,20,30]
print(lst4)
#　删除列表
del lst4
#print(lst4) # NameError: name 'lst4' is not defined. Did you mean: 'lst'?

4.enumerate函数的使用语法结构

for index，item in enumerate(lst):

输出index和item

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 示例5-6列表的遍历操作
lst = ['hello', 'world', 'python', 'php']
# 使用遍历循环for遍历列表元素
for item in lst:
    print(item)
# 使用for循环，range()函数,len函数，根据索引进行遍历
for i in range(0, len(lst)):
    print(i, '-->', lst[i])
# 第三种遍历方式 enumerate()函数
for index, item in enumerate(lst):
    print(index, item)  # index是序号，不是索引
# 手动修改序号的起始值
for index, item in enumerate(lst, start=1):
    print(index, item)
print('------------')
for index, item in enumerate(lst, 1):
    print(index, item)

5.列表的相关操作方法

image-20251024160602016

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# 示例5-7列表的相关操作
lst = ['hello', 'world', 'python']
print('原列表：',lst,id(lst))
# 增加元素的操作
lst.append('sql')
print('增加元素之后：',lst,id(lst))
# 使用insert（index,x）在指定的index位置上插入元素x
lst.insert(1,100)
print(lst)
# 列表元素的删除操作
lst.remove('world')
print('删除元素之后的列表：',lst,id(lst))
# 使用pop（index）根据索引将元素取出，然后再删除
print(lst.pop(1))
print(lst)
# 清除列表中所有的元素clear（）
# lst.clear()
# print(lst,id(lst))
# 列表的反向
lst.reverse() # 不会产生新的列表，在原列表的基础上进行的
print(lst)
# 列表的拷贝，将产生一个新的列表对象
new_lst=lst.copy()
print(lst,id(lst))
print(new_lst,id(new_lst))
# 列表元素的修改操作
# 根据索引进行修改元素
lst[1]='mysql'
print(lst)

6.列表排序的两种方式

1.列表对象的sort方法

lst.sort(key=None,reverse=False)

key——>表示排序的规则

reverse——>表示排序方式（默认升序）

2.内置函数sorted()

sorted(iterable,key=None,reverse=False)

iterable——>表示的是排序的对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# 示例5-8列表的排序操作
lst=[4,56,3,78,40,56,89]
print('原列表：',lst)
# 排序，默认是升序
lst.sort() # 排序是在原列表的基础上进行的，不会产生新的列表对象
print('升序：',lst)
# 排序，降序
lst.sort(reverse=True)
print('降序：',lst)
print('----------------------------')
lst2=['banana','apple','Cat','Orange']
print('原列表：',lst2)
# 升序排序，先排大写，再排小写
lst2.sort()
print('升序：',lst2)
# 降序排序，先排小写，后排大写
lst2.sort(reverse=True)
print('降序：',lst2)
# 忽略大小写进行比较
lst2.sort(key=str.lower)
print(lst2)
# 示例5-9列表的排序sorted
lst = [4, 56, 3, 78, 40, 56, 89]
print('原列表：', lst)
# 排序
asc_lst = sorted(lst)
print('升序：', asc_lst)
print('原列表：', lst)
# 降序
desc_sorted = sorted(lst, reverse=True)
print('降序：', desc_sorted)
print('原列表：', lst)
lst2 = ['banana', 'apple', 'Cat', 'Orange']
print('原列表：', lst2)
# 忽略大小写进行排序
new_lst2 = sorted(lst2, key=str.lower)
print('原列表：', lst2)
print('排序后的列表：', new_lst2)

7.列表生成式的语法结构

lst=[expression for item in range]

lst=[expression for item in range if condition]

1
2
3
4
5
6
7
8
9
10
11
# 示例5-10列表生成式的使用
import random
lst = [item for item in range(1, 11)]
print(lst)
lst = [item * item for item in range(1, 11)]
print(lst)
lst = [random.randint(1, 100) for _ in range(10)]
print(lst)
# 从列表中选择符合条件的元素组成新的列表
lst = [i for i in range(10) if i % 2 == 0]
print(lst)

8.二维列表

1.二维列表：表格数据

image-20251024160745487

2.二维列表的遍历

image-20251024160758420

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 示例5-11二维列表的遍历与列表生成式
# 创建二维列表
lst=[
   ['城市','环比','同比'],
   ['北京',102,103],
   ['上海',104,504],
   ['深圳',100,39]
]
print(lst)
# 遍历二维列表使用双层for循环
for row in lst: # 行
    for item in row: # 列
        print(item,end='\t\t')
    print() # 换行
# 列表生成式生成一个4行5列的二维列表
lst2=[[j for j in range(5)] for i in range(4)]
print(lst2)

4.元组类型

1.元组定义

是Python中内置的不可变序列

在Python中使用()定义元组，元素与元素之间使用英文的逗号分隔

元组中只有一个元素的时候，逗号也不能省略

2.元组的创建方式有两种

1.使用()直接创建元组

语法结构如下：

元组名=（element1，element2,……,elementN）

2.使用内置函数tuple()创建元组

语法结构如下：

元组名=tuple(序列)

3.删除元组

del 元组名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
# 示例5-12元组的创建与删除
# 使用小括号创建元组
t=('hello',[10,20,30],'python','world')
print(t)
# 使用内置函数tuple()创建元组
t=tuple('helloworld')
print(t)
t=tuple([10,20,30,40])
print(t)
print('10在元组中是否存在：',(10 in t))
print('10在元组中是否不存在：',(10 not in t))
print('最大值：',max(t))
print('最小值：',min(t))
print('len：',len(t))
print('t.index：',t.index(10))
print('t.count：',t.count(10))
# 如果元组中只有一个元素
t=(10)
print(t,type(t))
# 如果元组中只有一个元素，逗号不能省
y=(10,)
print(y,type(y))
# 元组的删除
del t
# print(t)
# 示例5-13元组元素的访问与遍历
t=('python','hello','world')
#　根据索引访问元组
print(t[0])
t2=t[0:3:2] # 元组支持切片操作
print(t2)
# 元组的遍历
for item in t:
    print(item)
# for+range()+len()
for i in range(len(t)):
    print(i,'-->',t[i])
print('--------------------')
# 使用enumerate()
for index,item in enumerate(t):
    print(index,'-->',item)
for index,item in enumerate(t,start=11): #　序号从11开始
    print(index,'-->',item)
# 示例5-14元组生成式
t=(i for i in range(1,4))
print(t)
# t=tuple(t)
# print(t)
# 遍历
# for item in t:
#     print(item)
print(t.__next__())
print(t.__next__())
print(t.__next__())
t=tuple(t)
print(t)

4.元组和列表的区别

image-20251024160935390

5.字典类型

1.字典定义

字典类型是根据一个信息查找另一个信息的方式构成了“键值对”，它表示索引用的键和对应的值构成的成 对关系

image-20251024160951067

2.字典的创建方式

1.使用{}直接创建字典

d={key1:value1,key2:value2……}

2.使用内置函数dict()创建字典

(1)通过映射函数创建字典

zip(lst1,lst2)

image-20251024161030732

(2)使用参数创建字典

语法结构如下： dict(key=value1,key2=value2……)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 示例5-15字典的创建与删除
# （1）创建字典
d = {10: 'cat', 20: 'dog', 30: 'pet', 20: 'zoo'}
print(d)  # key相同时，value值进行了覆盖
# （2）zip函数
lst1 = [10, 20, 30, 40]
lst2 = ['cat', 'dog', 'pet', 'zoo', 'car']
zipobj = zip(lst1, lst2)
print(zipobj)  # <zip object at 0x000001CB59561580>
# print(list(zipobj)) # [(10, 'cat'), (20, 'dog'), (30, 'pet'), (40, 'zoo')]
d=dict(zipobj)
print(d) # {10: 'cat', 20: 'dog', 30: 'pet', 40: 'zoo'}
# 使用参数创建字典
d=dict(cat=10,dog=20) # 左侧cat是key，右侧的是value
print(d)
t=(10,20,30)
print({t:10}) # t是key，10是value，元组是可以作为字典中的key
# lst=[10,20,30]
# print({lst:10}) # TypeError: unhashable type: 'list'
# 字典属于序列
print('max:',max(d))
print('min:',min(d))
print('len:',len(d))
# 字典的删除
del d
# print(d) # NameError: name 'd' is not defined

注意事项：

字典中的key是无序的，Python3.5及其之前的版本字典的key在输出时无序，但是从Python3.6版本之后 Python解释器进行了处理所以才会看到输出的顺序与添加的顺序“一致”

3.字典元素的取值

d[key] 或 d.get(key)

4.字典元素的遍历

(1)遍历出key与value的元组

for element in d.items(): pass

(2)分别遍历出key和value

for key,value in d.items():

​ pass

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 示例5-16字典元素的访问和遍历
d={'hello':10,'world':20,'python':30}
# 访问字典中的元素
# （1）使用d[key]
print(d['hello'])
# （2）d.get(key)
print(d.get('hello'))
# 二者之间是有区别的，如果key不存在，d[key]报错，d.get(key)可以指定默认值
# print(d['java']) # KeyError: 'java'
print(d.get('java')) # None
print(d.get('java','不存在'))
# 字典的遍历
for item in d.items():
    print(item) # key=value组成的一个元素
# 在使用for循环遍历时，分别获取key,value
for key,value in d.items():
    print(key,'-->',value)

5.字典的相关操作方法

image-20251024161201492

image-20251024161207523

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 示例5-17字典的相关操作方法
d={1001:'李梅',1002:'王华',1003:'张峰'}
print(d)
#　向字典中添加元素
d[1004]='张丽丽' # 直接使用赋值运算符向字典中添加元素
print(d)
# 获取字典中所有的key
keys=d.keys()
print(keys) # dict_keys([1001, 1002, 1003, 1004])
print(list(keys))
print(tuple(keys))
# 获取字典中所有的value
values=d.values()
print(values) # dict_values(['李梅', '王华', '张峰', '张丽丽'])
print(list(values))
print(tuple(values))
#　如果将字典中的数据转成key-value的形式，以元组的方式进行展现
lst=list(d.items())
print(lst)
d=dict(lst)
print(d)
#　使用pop函数
print(d.pop(1001))
print(d)
print(d.pop(1008,'不存在'))
# 随机删除
print(d.popitem())
print(d)
#　清空字典中所有的元素
d.clear()
print(d)
# Python中一切皆对象，每个对象都有一个布尔值
print(bool(d)) # False

6.字典生成式

d={key:value for item in range}

d={key:value for key,value in zip(lst1,lst2)}

1
2
3
4
5
6
7
8
9
# 示例5-18字典生成式
import random
d={item :random.randint(1,100) for item in range(4)}
print(d)
# 创建两个列表
lst=[1001,1002,1003]
lst2=['陈梅梅','王一一','李丽丽']
d={key:value for key,value in zip(lst,lst2)}
print(d)

6.集合类型

1.集合定义

Python中的集合与数学中集合的概念一致

Python中的集合是一个无序的不重复元素序列

集合中只能存储不可变数据类型

在Python中集合使用{}定义

与列表、字典一样，都是Python中的可变数据类型

2.集合的创建方式有两种

(1)使用{}直接创建集合 语法结构如下：

s={element1,element2,……elementN}

(2)使用内置函数set()创建集合 语法结构如下：

s=set(可迭代对象)

3.集合的删除

语法结构如下：

del 集合名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# 示例5-19集合的创建与删除
# {}直接创建集合
s = {10, 20, 30, 40}
print(s)
# 集合只能存储不可变数据类型
# s={[10,20],[30,40]} # TypeError: unhashable type: 'list'
# print(s)
# 使用set()创建集合
s = set()  # 创建了一个空集合，空集合的布尔值是False
print(s)
s = {}  # 创建的是集合还是字典呢？
print(s,type(s)) # <class 'dict'>
s=set('helloworld')
print(s)
s2=set([10,20,30])
print(s2)
s3=set(range(1,10))
print(s3)
# 集合属于序列的一种
print('max:',max(s3))
print('min:',min(s3))
print('len:',len(s3))
print('9在集合中存在吗？',(9 in s3))
print('9在集合中不存在吗？',(9 not in s3))
#　集合的删除操作
del s3
# print(s3) # NameError: name 's3' is not defined

4.集合类型的操作符

image-20251024161406403

1
2
3
4
5
6
7
8
9
10
11
12
#　示例5-20集合的操作符
A={10,20,30,40,50}
B={30,50,88,76,20}
# 交集操作
print(A&B)
# 并集操作
print(A|B)
# 差集操作
print(A-B)
print(B-A)
# 补集操作
print(A^B)

5.集合的相关操作方法

image-20251024161431308

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 示例5-21集合的相关操作
s={10,20,30}
# 向集合中添加元素
s.add(100)
print(s)
# 删除元素
s.remove(20)
print(s)
# 清除集合中所有元素
# s.clear()
# print(s)
# 集合的遍历操作
for item in s:
    print(item)
# 使用enumerate()函数
for index,item in enumerate(s):
    print(index,'-->',item)
# 集合的生成式
s={i for i in range(1,10) if i%2==1}
print(s)

6.列表、元组、字典、集合的区别

image-20251024161457181

7 . P y t h o n 3 . 1 1 新 特 性

1 . 结 构 模 式 匹 配

image-20251024161532421

2.字典合并 运 算 符|

image-20251024161618826

3 . 同 步 迭 代

image-20251024161636130

image-20251024161643204

8.本章总结

  • 序列结构主要有列表、元组、集合、字典和字符串
  • 正向递增索引取值范围[0,N-1]，反向递减索引取值范围[-1,-N]
  • 切片操作语法结构：序列名 [start ： end : step]
  • 创建列表的方式：(1)使用[]直接创建 (2)使用内置函数list()创建
  • 列表的相关操作方法：
    • 添加方法：append()和insert()
    • 删除方法：clear()、remove()、pop()
    • 列表元素的排序：sort()和内置函数sorted()
    • 其它方法：reverse()和copy()
  • 创建元组的方式：（1）使用()直接创建（2）使用内置函数tuple()创建
  • 创建字典的方式：（1）使用{}直接创建（2）使用内置函数dict()
  • 使用内置函数dict()创建字典的两种方式：
    • 通过映射函数zip(lst1,Ist2)创建字典
    • 通过给定关键字创建字典dict(key1=value1,key2=value2……)
  • 字典的相关操作方法：
    • 查询方法:get()、keys()、values()和items()
    • 删除方法:pop()、popitem()和clear()
  • 创建集合的方式：（1）使用{}直接创建（2）使用内置函数set()创建
  • 集合的相关操作方法：
    • 添加方法：add
    • 删除方法：remove()和clear()
  • 列表、字典、集合都是Python中的可变数据类型，元组是Python中的不可变数据类型
  • 列表、元组、字典和集合的遍历都可以通过for循环实现
  • 列表、元组、字典和集合的删除都可以使用语句del来实现
Python
#Python
Python学习笔记
http://example.com/2025/10/27/P y t h o n 学 习 笔 记/
作者
Piggy Sprint
发布于
2025年10月27日
许可协议