python基础笔记一
计算机基础结构
硬件
1944年，美籍匈牙利数学家冯·诺依曼提出计算机基本结构。
五大组成部分：运算器、控制器、存储器、输入设备、输出设备。
-- 运算器：按照程序中的指令，对数据进行加工处理。
-- 控制器：根据程序需求，指挥计算机的各个部件协调工作。
通常将运算器和控制器集成在中央处理器（CPU）中。
-- 存储器：保存各类程序的数据信息。
内存RAM -- 容量小，速度快，临时存储数据
硬盘HDD -- 容量大，速度慢，永久存储数据
输入设备：外界向计算机传送信息的装置。
例如：鼠标、键盘、扫描仪…
输出设备：计算机向外界传送信息的装置。
例如：显示器、音响、打印机…
软件
操作系统：
-- 管理和控制计算机软件与硬件资源的程序。
-- 隔离不同硬件的差异~~，使软件开发简单化。
-- Windows，Linux，Unix。
应用软件：为了某种特定的用途而被开发的软件。
软件：程序 + 文档。
-- 程序是一组计算机能识别和执行的指令集合。
-- 文档是为了便于了解程序所需的说明性资料。
Python 简介
Python 定义
是一个免费、开源、跨平台、动态、面向对象的编程语言。
# Python程序的执行方式
交互式
在命令行输入指令，回车即可得到结果。
1.打开终端
2.进入交互式：python3
3.编写代码：print(“hello world”)
4.离开交互式：exit()
文件式
将指令编写到.py文件，可以重复运行程序。
1.编写文件。
2.打开终端
3.进入程序所在目录：cd 目录
4.执行程序： python3 文件名
Linux常用命令
1．pwd：查看当前工作目录的路径
2．ls：查看指定目录的内容或文件信息
3．cd：改变工作目录（进入到某个目录）
练习：
1.在指定目录创建python文件.
--目录：/home/tarena/month01
--文件名：exercise01.py
2. 在文件中写入：print(“你好，世界!”)
3. 运行python程序
执行过程
计算机只能识别机器码(1010)，不能识别源代码(python)。
1.由源代码转变成机器码的过程分成两类：编译和解释。
2.编译：在程序运行之前，通过编译器将源代码变成机器码，例如：C语言。
-- 优点：运行速度快
-- 缺点：开发效率低，不能跨平台。
3.解释：在程序运行之时，通过解释器对程序逐行翻译，然后执行。例如Javascript
-- 优点：开发效率高，可以跨平台；
-- 缺点：运行速度慢。
4.python是解释型语言，但为了提高运行速度，使用了一种编译的方法。编译之后得到pyc文件，存储了字节码（特定于Python的表现形式，不是机器码）。
源代码 -- 编译 --> 字节码 -- 解释 --> 机器码
|————1次———|
解释器类型
1.CPython（C语言开发)
2.Jython (java开发)
3.IronPython (.net开发)
数据基本运算
基础知识
pycharm常用快捷键
1.移动到本行开头：home键
2.移动到本行末尾：end键盘
3.注释代码：ctrl + /
4.复制行：ctrl +d
5.选择列：shift + alt + 鼠标左键
6.移动行：shift + alt + 上下箭头
7.智能提示：ctrl + space
8.代码格式化：ctrl+alt+l
注释
给人看的，通常是对代码的描述信息。
1.单行注释：以#号开头。
# print("x")
2.多行注释：三引号开头，三引号结尾。
"""
汇率转换器 exercise01.py
"""
函数
表示一个功能，函数定义者是提供功能的人，函数调用者是使用功能的人。
例如：
1.print(数据) 作用：将括号中的内容显示在控制台中
2.变量 = input(“需要显示的内容”) 作用：将用户输入的内容赋值给变量
"""
函数：功能
语法：
函数名(参数)
"""
# 1. 字面意思:打印(输出／显示)
# 2. 作用：将括号中的内容显示在终端中
# 3. 适用性：显示结果
# print("结果")
# 1. 字面意思:输入
# 2. 作用：将终端中录入的信息输入到程序中
# 3. 适用性：获取数据
# result = input("提示信息")
name = input("请输入姓名：")
print("你好:" + name)
"""
练习1：收银台
获取商品价格
获取购买数量
获取支付金额
显示:应该找回?元.
算法：支付金额 - 价格 × 数量
"""
commodity_price = input("请输入商品价格：")
buy_count = input("请输入购买数量：")
money = input("请输入金额：")
result = float(money) - float(commodity_price) * int(buy_count)
print("应该找回" + str(result) + "元.")
变量
1.定义：关联一个对象的标识符。
2.命名：必须是字母或下划线开头，后跟字母、数字、下划线。
不能使用关键字(蓝色)，否则发生语法错误：SyntaxError: invalid syntax。
3.建议命名：字母小写，多个单词以下划线隔开。
class_name
4.赋值：创建一个变量或改变一个变量关联的数据。
5.语法：变量名 = 数据
变量名1 = 变量名2 = 数据
变量名1, 变量名2, = 数据1, 数据2
"""
变量
程序运行在哪里？ --> 内存
程序在处理什么？ --> 数据
核心价值：在内存中操作数据
语法：
名称 = 数据
名称1,名称2 = 数据1, 数据2
名称1 = 名称2 = 数据1
练习:exercise01
"""
# 赋值号= ： 将右边给到左边
score = 100
score1, score2 = 95, 96
name1 = name2 = "悟空"
"""
画出下列代码内存图：
"""
data01 = "苏大强"
data02 = data01
data01 = "大强"
print(data02)# ?
del 语句
1.语法:
del 变量名1, 变量名2
2.作用：
用于删除变量,同时解除与对象的关联.如果可能则释放对象。
3.自动化内存管理的引用计数：
每个对象记录被变量绑定(引用)的数量,当为0时被销毁。
"""
del
引用计数
练习:exercise02
"""
data01 = 500
data02 = data01
data03 = data02
"""
画出下列代码内存图
"""
name02 = name01 = "八戒"
name03 = name02
del name01
name03 = name02 = "悟空"
核心数据类型
1.在python中变量没有类型，但关联的对象有类型。
2.通过type函数可查看。
空值对象 None
1.表示不存在的特殊对象。
2.作用：占位和解除与对象的关联。
# 1. 空None类型
# -- 占位
name = None
# -- 解除与对象的关联
score = 100
score = None
整形int
1.表示整数，包含正数、负数、0。
如： -5, 100, 0
2.字面值：
十进制：5
二进制：0b开头，后跟1或者1
八进制：0o开头，后跟0~7
十六进制：0x开头，后跟0~9,A~F,a~f
# 2. 整形(整数)int类型
# -- 十进制：逢十进一 0 1 2 3 4 ..9 进位 10
data01 = 10
# -- 二进制：逢二进一 0 1 进位 10 11 100 101 110
data02 = 0b10
# -- 八进制:逢八进一 0 1 2 ...7 进位 10 11
data03 = 0o10
# -- 十六进制:逢十六进一 0 1 2 ...9 a(10)..f(15) 进位 10 11 ..
data04 = 0x10
浮点型float
1.表示小数，包含正数、负数，0.0)。
2.字面值：
小数：1.0 2.5
科学计数法：e/E (正负号) 指数
1.23e-2 (等同于0.0123)
1.23456e5(等同于123456.0)
# 3. 浮点型(小数)float类型
number01 =1.5
print(number01)
number02 =15e-1
number03 = 0.00000000001# 1e-11
print(number03)
字符串str
是用来记录文本信息(文字信息)。
字面值：双引号
"""
字符串
练习：exercise05
"""
# 1. 不可变
name = "悟空"
name = "孙悟空"
print(name) # 创建新字符串对象(孙悟空),替换变量存储的地址。
# 假设可以在原有基础上进行扩充,很可能破坏其他对象内存空间.
# 2. 编码相关函数
# 字 --> 数
print(ord("天"))
# 数 --> 字
print(chr(22825))
# 4. 字符串str类型
message = "我爱编程"
message = "1.5"
"""
古代的秤,一斤十六量.
获取两,显示几斤零几两.
"""
weight_liang = int(input("请输入两："))
jin = weight_liang // 16
liang = weight_liang % 16
print(str(jin) + "斤零" + str(liang) + "两")
布尔bool
用来表示真和假的类型
True 表示真(条件满足或成立)，本质是1
False 表示假(条件不满足或不成立)，本质是0
# 1. 布尔 bool 类型
# 命题：带有判断性质的陈述句
# 我是一个帅哥
# 真/对/成立 True
# 假/错/不成立 False
# 类型转换： bool(数据) 有值true 没值false
print(bool(0)) # False
print(bool(0.0)) # False
print(bool("")) # False
print(bool(None)) # False
数据类型转换
1.转换为整形: int(数据)
2.转换为浮点型:float(数据)
3.转换为字符串:str(数据)
4.转换为布尔:bool(数据)
结果为False：bool(0) bool(0.0) bool(None)
5.混合类型自动升级：
1 + 2.14 返回的结果是 3.14
1 + 3.0 返回结果是: 4.0
"""
类型转换
语法逻辑：
结果 = 类型名(待转类型)
"""
# input函数的结果是str类型
# str ---> int / float
# 适用性：需要对象字符串进行数学运算
# 注意：待转数据必须"像"转换的类型.
number = float("200.5")
print(number)
# int / float ---> str
# 适用性：需要按照某种格式显示计算后的数值
print(str(10.5))
运算符
算术运算符
+ 加法
- 减法
* 乘法
/ 除法：结果为浮点数
// 地板除：除的结果去掉小数部分
% 求余
** 幂运算
优先级从高到低： ()
**
* / % //
+ -
"""
公式：
距离 =初速度 * 时间的一半 + 加速度 × 时间的平方
已知：
距离,时间,初速度
计算：
加速度
加速度 = (距离 - 初速度 * 时间 / 2) / 时间**2
"""
s = float(input("请输入距离："))
t = float(input("请输入时间："))
v0 = float(input("请输入初速度："))
a = (s - v0 * t / 2) / t ** 2
print(a)
"""
练习:时间换算
获取分钟数
获取小时数
获取天数
显示：?天?小时?分钟总共是?秒.
"""
minute = input("请输入分钟数：")
hour = input("请输入小时数：")
day = input("请输入天数：")
result = int(minute) * 60 + int(hour) * 60 * 60 + int(day) * 24 * 60 * 60
print(day + "天" + hour + "小时" + minute + "分钟总共是" + str(result) + "秒.")
# 1. ＋ － * / // % 幂运算**
number01 = 5
number02 = 2
result = number01 + number02 # 7
print(result)
print(number01 ** 2) # 5 的2 次方: 5 * 5
number01 = "5"
number02 = "2"
result = number01 + number02 # 不是数学运算,而是文字拼接52
print(result)
# 需求1：整数的个位数是多少? --> 余数
number = 56
print(number % 10) # 6
# 需求2：70秒是几分钟零几秒? --> 地板除（整数除）
second = 70
print(second // 60) # 分钟
print(second % 60) # 秒
增强运算符
y += x 等同于 y = y + x
y -= x 等同于 y = y - x
y *= x 等同于 y = y * x
y /= x 等同于 y = y / x
y //= x 等同于 y = y // x
y %= x 等同于 y = y % x
y **= x 等同于 y = y ** x
"""
获取一个4位整数 1234
输出每位相加和 1+2+3+4
"""
# # 方法1
# number = int(input("请输入整数："))
# # 个位
# unit01 = number % 10
# # 十位 1234 --> 123 --> 3
# unit02 = number // 10 % 10
# # 百位 1234 --> 12 --> 2
# unit03 = number // 100 % 10
# # 千位 1234 --> 1
# unit04 = number // 1000
# print(unit01 + unit02 + unit03 + unit04)
# 方法2
number = int(input("请输入整数："))
# 个位
result = number % 10
# 十位
result += number // 10 % 10
# 百位
result += number // 100 % 10
# 千位 1234 --> 1
result += number // 1000
print(result)
# 2. 增强运算符 += -= *= /= //= %= **=
# data01 = 6
# 运算后的结果，不影响变量自身
# print(data01 + 1)# 7
# print(data01)# ? 6
data01 = 6
# 运算后的结果，又赋值给了变量自身.
data01 += 1 # data01 = data01 + 1
print(data01)# 7
比较运算符
< 小于
<= 小于等于
> 大于
>= 大于等于
== 等于
!= 不等于
返回布尔类型的值
比较运算的数学表示方式:0 <= x <= 100
# 2. > < >= <= 等于== 不等于!=
# 比较数值大小,结果是bool类型
data01 = 50
data02 = "50"
print(data01 == data02) # false
print(50 != "50") # false
逻辑运算符
与and
表示并且的关系，一假俱假。
示例:
True and True # True
True and False # False
False and True # False
False and False # False
# 3. 与and 或 非
# 判断多个命题关系
# 与and 现象：一假俱假 并且关系（必须满足所有条件）
print(True and True) # True
print(False and True) # False
print(True and False) # False
print(False and False) # False
或or
表示或者的关系，一真俱真
示例:
True or True # True
True or False # True
False or True # True
False or False # False
# 或or 现象：一真俱真 或者关系（满足一个就行）
print(True or True) # True
print(False or True) # True
print(True or False) # True
print(False or False) # False
非 not
表示取反
例如：
not True # 返回False
not False # 返回True
# 非 取反
print(not True) # False
短路运算
一但结果确定，后面的语句将不再执行。
"""
短路逻辑
一但结果确定，后面的语句将不再执行。
价值：尽量将耗时的判断放在后面
"""
# False and ?
result = 1 > 2 and input("请输入") == "a"
# True or ?
result = 1 < 2 or input("请输入") == "a"
# 终端中是否有"请输入"
"""
获取一个年份
如果是闰年输入True，否则输出false
条件：
1. 年份能被4整除但是不能被100整除
2. 年份能被400整除
"""
year = int(input("请输入年份："))
result = year % 4 == 0 and year % 100 != 0 or year % 400 == 0
print(result)
身份运算符
语法:
x is y
x is not y
作用：
is 用于判断两个对象是否是同一个对象,是时返回True,否则返回False。
is not 的作用与is相反
"""
身份运算符
"""
list01 = [100]
list02 = [100]
# 两个变量指向的对象是否同一个
print(list01 is list02)# False
list03 = list01
print(list03 is list01)# True
# 原理：判断变量存储的地址是否相同
print(id(list01))# 140235347048584
print(id(list02))# 140235357765192
print(id(list03))# 140235347048584
优先级
高到低：
算数运算符
比较运算符
快捷运算符
身份运算符
逻辑运算符
语句
行
1.物理行：程序员编写代码的行。
2.逻辑行：python解释器需要执行的指令。
3.建议一个逻辑行在一个物理行上。
4.如果一个物理行中使用多个逻辑行，需要使用分号；隔开。
5. 如果逻辑行过长，可以使用隐式换行或显式换行。
隐式换行：所有括号的内容换行,称为隐式换行
括号包括: () [] {} 三种
显式换行：通过折行符 \ (反斜杠)换行，必须放在一行的末尾，目的是告诉解释器,下一行也是本行的语句。
"""
行
"""
# 1个逻辑行对应1个物理行（建议）
a = 10
b = 20
c = a + b
# 3个逻辑行对应1个物理行（不建议）
a = 10;b = 20;c = a + b
# 1个逻辑行对应多个物理行
# 换行符 \
d = 1 + 2 + \
3 + 4 + 5 + 6 + \
7 + 8 + 9
# 换行符 括号是天然的换行符
e = (1 + 2
+ 3 + 4 +
5 + 6 + 7 +
8 + 9)
pass 语句
通常用来填充语法空白。
选择语句
If elif else 语句
1.作用:
让程序根据条件选择性的执行语句。
2.语法:
if 条件1:
语句块1
elif 条件2:
语句块2
else:
语句块3
3.说明:
elif 子句可以有0个或多个。
else 子句可以有0个或1个，且只能放在if语句的最后。
"""
选择语句
缩进：4个空格
if 条件：
满足条件执行的代码
else:
不满足条件执行的代码
if 条件1：
满足条件1执行的代码
elif 条件2：
不满足条件1,但满足条件2执行的代码
else:
以上条件都不满足执行
# 调试：让程序中断,逐语句执行。
# 目标：审查程序执行过程
# 观察变量取值
# 步骤：
# 1. 加断点(在可能出错的行)
# 2. 开始调试
# 3. 逐语句执行Ｆ８／Ｆ７
# 4. 停止Ctrl + F2
练习：exercise01~05
"""
sex = input("请输入性别：")
if sex == "男":
print("您好，先生！")
elif sex == "女":
print("您好，女士！")
else:
print("性别未知")
"""
修改day02/exercise04练习
显示结果：
应找回...
钱不够
"""
commodity_price = input("请输入商品价格：")
buy_count = input("请输入购买数量：")
money = input("请输入金额：")
result = float(money) - float(commodity_price) * int(buy_count)
if result >= 0:
print("应该找回" + str(result) + "元.")
else:
print("钱不够")
"""
获取季度(春天 夏天 秋天 冬天)
显示相应的月份：
春天：1月2月3月
夏天：4月5月6月
秋天：7月8月9月
冬天：10月11月12月
"""
season = input("请输入季度：")
# if season == "春天":
# print("1月2月3月")
# if season == "夏天":
# print("4月5月6月")
# if season == "秋天":
# print("7月8月9月")
# if season == "冬天":
# print("10月11月12月")
if season == "春天":
print("1月2月3月")
elif season == "夏天":
print("4月5月6月")
elif season == "秋天":
print("7月8月9月")
elif season == "冬天":
print("10月11月12月")
"""
录入4个同学体重,
打印最重的体重。
算法：
假设第一个是最大值
如果第二个大于假设的,则替换假设的.
如果第三个大于假设的,则替换假设的.
如果第四个大于假设的,则替换假设的.
最后输出假设的(最大的)
"""
weight01 = float(input("请输入第一个同学体重："))
weight02 = float(input("请输入第一个同学体重："))
weight03 = float(input("请输入第一个同学体重："))
weight04 = float(input("请输入第一个同学体重："))
max_value = weight01
if max_value < weight02:
max_value = weight02
if max_value < weight03:
max_value = weight03
if max_value < weight04:
max_value = weight04
print(max_value)
"""
获取成绩
判断等级(优秀 良好 及格 不及格 不在范围内0-100)
"""
score = float(input("请输入成绩："))
# if 90 <= score <= 100:
# print("优秀")
# elif 80 <= score < 90:
# print("良好")
# elif 60 <= score < 80:
# print("及格")
# elif 0 <= score < 60:
# print("不及格")
# else:
# print("不在范围内0-100")
if score > 100 or score < 0:
print("不在范围内0-100")
elif 90 <= score:
print("优秀")
elif 80 <= score:
print("良好")
elif 60 <= score:
print("及格")
else:
print("不及格")
"""
获取一个年份,一个月份
打印相应天数
1 3 5 7 8 10 12 --> 31天
2 --> 28(平年) 29(闰年)
4 6 9 11 --> 30天
"""
year = int(input("请输入年份："))
month = int(input("请输入月份："))
if month < 1 or month > 12:
print("月份有误")
elif month == 2:
if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
print("29天")
else:
print("28天")
elif month == 4 or month == 6 or month == 9 or month == 11:
print("30天")
else: # 1 3 5 7 8 10 12
print("31天")
if 语句的真值表达式
if 100:
print("真值")
等同于
if bool(100):
print("真值")
条件表达式
语法：变量 = 结果1 if 条件 else 结果2
作用：根据条件(True/False) 来决定返回结果1还是结果2。
"""
真值表达式
条件表达式
练习:exercise06
"""
# 真值表达式
message = input("请输入")
# if message != "":
if message: # 有值
print("输入了内容")
else:
print("没有输入内容")
# 条件表达式
# if input("请输入性别：") == "男":
# sex_code = 1
# else:
# sex_code = 0
sex_code = 1 if input("请输入性别：") == "男" else 0
# 练习1:
# 获取一个整数,如果是奇数给变量state赋值为"奇数",否则赋值"偶数"
# if int(input("请输入整数：")) % 2 == 1:
# state = "奇数"
# else:
# state = "偶数"
# if int(input("请输入整数：")) % 2:
# state = "奇数"
# else:
# state = "偶数"
state = "奇数" if int(input("请输入整数：")) % 2 else "偶数"
print(state)
# 练习2:
# 获取一个年份,如果是闰年给变量day赋值为29,否则赋值28
year = int(input("请输入年份："))
# 建议
day = 29 if year % 4 == 0 and year % 100 != 0 or year % 400 == 0 else 28
# day = 29 if not year % 4 and year % 100 or not year % 400 else 28
循环语句
while语句
1.作用:
可以让一段代码满足条件，重复执行。
2.语法:
while 条件:
满足条件执行的语句
else:
不满足条件执行的语句
3.说明:
else子句可以省略。
在循环体内用break终止循环时,else子句不执行。
"""
while
练习：exercise07
"""
# 死循环
while True:
str_usd = input("请输入美元:")
result = float(str_usd) * 6.9845
print(str_usd + "美元=" + str(result) + "人民币")
if input("如果输入y则继续：") != "y":
break # 退出循环
"""
改造exercise02.py(季度 --> 月份)
如果输入e键退出,否则循环执行。
调试：体会循环
"""
while True:
season = input("请输入季度：")
if season == "春天":
print("1月2月3月")
elif season == "夏天":
print("4月5月6月")
elif season == "秋天":
print("7月8月9月")
elif season == "冬天":
print("10月11月12月")
if input("请输入e键退出：") == "e":
break
"""
循环计数
1. 在循环以前定义计数器
2. 在循环以内更新计数器
练习:exercise08
"""
# 需求：执行5次
count = 0
while count < 5:
# print("跑圈")
print(count) # 0 1 2 3 4
count += 1
# 练习1：在终端中显示0 1 2
# count = 0
# while count <= 2:
# print(count)
# count += 1
# 练习2：在终端中显示6 7 8 9 10
# count = 6
# while count <= 10:
# print(count)
# count += 1
# 练习3：在终端中显示2 4 6 8
# count = 2
# while count <= 8:
# print(count)
# count += 2
# 练习4：在终端中显示9 8 7 6 5 4 3
# count = 9
# while count >= 3:
# print(count)
# count -= 1
# 练习5：在终端中显示-1 -2 -3 -4 -5 -6
count = -1
while count >= -6:
print(count)
count -= 1
"""
获取一个开始值,再获取一个结束值.
打印中间值
5 10 --> 6 7 8 9
10 5 --> 9 8 7 6
"""
# 精神：顽强的拼搏力和无所畏惧的勇气.
begin = int(input("请输入开始值：")) # 5
end = int(input("请输入结束值：")) # 10
# 行为相同 数据不同
# while begin < end - 1:
# begin += 1
# print(begin)
#
# while begin > end + 1:
# begin -= 1
# print(begin)
dir = 1 if begin < end else -1
while begin != end - dir:
begin += dir
print(begin)
"""
一张纸的厚度是0.01毫米
请计算,对折多少次超过珠穆朗玛峰(8844.43米).
"""
# 数据：厚度、次数
# thickness = 0.01 / 1000
# 算法：*=2 += 1
thickness = 1e-5
count = 0
while thickness <= 8844.43:
thickness *= 2
count += 1
print("第" + str(count) + "次对折后的厚度是" + str(thickness))
print(count)
"""
猜数字游戏：
程序产生1--100之间的随机数.
在终端中重复猜测,直到猜对为止
提示：请输入 大了 小了 终于猜对了
"""
# 准备一个随机数工具
import random
# 生成一个随机数
random_number = random.randint(1, 100)
while True:
input_number = int(input("请输入："))
if input_number > random_number:
print("大了")
elif input_number < random_number:
print("小了")
else:
print("终于猜对了")
break
"""
增加需求：最多只能猜3次,如果超过次数则提示"游戏失败"
"""
# 准备一个随机数工具
import random
# 生成一个随机数
random_number = random.randint(1, 100)
print(random_number)
count = 0
while count < 3:
count += 1
input_number = int(input("请输入："))
if input_number > random_number:
print("大了")
elif input_number < random_number:
print("小了")
else:
print("终于猜对了")
break
else:# 否则：当循环条件不满足时执行(从循环体中通过break退出不执行)
print("游戏失败")
for 语句
1.作用:
用来遍历可迭代对象的数据元素。
可迭代对象是指能依次获取数据元素的对象，例如：容器类型。
2.语法:
for 变量列表 in 可迭代对象:
语句块1
else:
语句块2
3.说明:
else子句可以省略。
在循环体内用break终止循环时,else子句不执行。
"""
for 循环
练习：exercise01
"""
message = "我是齐天大圣孙悟空"
for item in message:
print(item)# "1" --> 1
# 练习：
# 获取一个任意整数 123456
# 输出每位相加和 1+2+3+4+...
str_number = input("请输入任意整数：")
# 1. 循环以前定义变量(存储累加和)
sum_value = 0
for item in str_number:
# 2. 循环以内进行累加
sum_value += int(item)
# 3. 循环以外获取结果
print(sum_value)
range 函数
1.作用:
用来创建一个生成一系列整数的可迭代对象(也叫整数序列生成器)。
2.语法:
range(开始点，结束点，间隔)
3.说明:
函数返回的可迭代对象可以用for取出其中的元素
返回的数字不包含结束点
开始点默认为0
间隔默认值为1
"""
for -- 循环计数
练习:exercise02
"""
# 整数生成器：产生一个范围内的整数
# 开始值 结束值(不包含) 变化量
for item in range(0, 6, 1):
print(item) # 0 1 2 3 4 5
# 结束值(开始值默认为0，变化量默认为1)
for item in range(6):
print(item)
# 开始值,结束值
for item in range(3, 6):
print(item)
# 练习1：在终端中显示0 1 2
for item in range(3):
print(item)
# 练习2：在终端中显示6 7 8 9 10
for item in range(6,11):
print(item)
# 练习3：在终端中显示2 4 6 8
for item in range(2,9,2):
print(item)
# 练习4：在终端中显示9 8 7 6 5 4 3
for item in range(9,2,-1):
print(item)
# 练习5：在终端中显示-1 -2 -3 -4 -5 -6
for item in range(-1,-7,-1):
print(item)
跳转语句
break 语句
1.跳出循环体，后面的代码不再执行。
2.可以让while语句的else部分不执行。
continue 语句
跳过本次，继续下次循环。
"""
continue
练习:exercise04
语句小结：
循环语句：
while :根据条件重复执行(不知道次数)
例如：对折到超过珠穆朗玛则停止
for : 根据次数执行(循环计数)
例如：3道考试题/对折20次
跳转语句：
break：跳出(循环停止)
continue：跳过(循环继续)
备注：如果循环嵌套，跳转语句只对一层起作用.
range 属于可迭代对象,所以获取数据使用for.
"""
# 累加：1--100之间能被3整除的整数
# sum_value = 0
# for number in range(1, 101):
# 满足条件则累加
# if number % 3 == 0:
# sum_value += number
# print(sum_value)
sum_value = 0
for number in range(1, 101):
# 不满足条件则跳过
if number % 3 != 0:
continue # 跳过(当前元素,继续循环)
sum_value += number
print(sum_value)
"""
累加10 -- 80 之间个位不是3/5/9的整数
调试：体会continue的过程
"""
sum_value = 0
for number in range(10, 81):
unit01 = number % 10
# 是他们就跳过
if unit01 == 3 or unit01 == 5 or unit01 == 9:
continue
sum_value += number
print(sum_value)
容器类型
通用操作
数学运算符
1.+：用于拼接两个容器
2.+=：用原容器与右侧容器拼接,并重新绑定变量
3.*：重复生成容器元素
4.*=：用原容器生成重复元素, 并重新绑定变量
5.< <= > >= == !=：依次比较两个容器中元素,一但不同则返回比较结果。
# 1. 算数运算符
# -- +容器元素拼接
name01 = "悟空"
name01 += "八戒"
# -- *容器元素重复多次
name02 = "唐僧"
name02 *= 2
print(name02)
# -- == !=
# 依次比较两个容器中元素,一但不同则返回比较结果。
print("悟空" > "八戒")
成员运算符
1.语法：
数据 in 序列
数据 not in 序列
2.作用：
如果在指定的序列中找到值，返回bool类型。
# 2. 成员运算 in not in
print("我爱" in "我爱你") # true
print("爱我" in "我爱你") # flase
索引index
1.作用：定位单个容器元素
2.语法：容器[整数]
3.说明：
正向索引从0开始，第二个索引为1，最后一个为len(s)-1。
反向索引从-1开始,-1代表最后一个,-2代表倒数第二个,以此类推,第一个是-len(s)。
# 3. 索引:定位单个元素
print(message[1])
print(message[-2])
# 索引越界
# print(message[7])# 报错 IndexError
# print(message[-8])# 报错 IndexError
切片slice
1.作用：
定位多个容器元素。
2.语法：
容器[(开始索引):(结束索引)(:(步长))]
3.说明：
小括号()括起的部分代表可省略
结束索引不包含该位置元素
步长是切片每次获取完当前元素后移动的偏移量
# 4. 切片:定位多个元素
# range( , , )
# [开始索引:结束索引:间隔] 不包含结束索引
print(message[0:4:1]) # 我是齐天
# [:结束索引:]
print(message[:4:]) # 我是齐天
# [:]
print(message[:]) # 我是齐天大圣.
# message[::-1]
print(message[::-1]) # .圣大天齐是我
# [开始索引::]
print(message[3::]) # 天大圣.
# [::间隔]
print(message[::2]) # 我齐大.
# 切片不会越界
print(message[:100]) # 我是齐天大圣.
print(message[3:3]) # 获取空
print(message[1:-2]) # 是齐天大
print(message[1:5:-1]) # 获取空
# 练习：
# -- 打印第一个字符
# -- 打印最后一个字符
# -- 打印中间的字符 len(message)
# -- 打印前3个字符
# -- 打印后4个字符(正向)
# -- 打印:是教主无
# -- 倒序打印所有字符
# -- 尝试...
message = "我是明教教主张无忌"
print(message[0])
print(message[-1])
print(message[len(message) // 2])
print(message[:3])
print(message[-4:])
print(message[1::2])
print(message[::-1])
内建函数
1.len(x) 返回序列的长度
2.max(x) 返回序列的最大值元素
3.min(x) 返回序列的最小值元素
4.sum(x) 返回序列中所有元素的和(元素必须是数值类型)
字符串 str
定义
由一系列字符组成的不可变序列容器，存储的是字符的编码值。
编码
1.字节byte：计算机最小存储单位，等于8 位bit.
2.字符：单个的数字，文字与符号。
3.字符集(码表)：存储字符与二进制序列的对应关系。
4.编码：将字符转换为对应的二进制序列的过程。
5.解码：将二进制序列转换为对应的字符的过程。
6.编码方式：
--ASCII编码：包含英文、数字等字符，每个字符1个字节。
--GBK编码：兼容ASCII编码，包含21003个中文；英文1个字节，汉字2个字节。
--Unicode字符集：国际统一编码，旧字符集每个字符2字节，新字符集4字节。
--UTF-8编码：Unicode的存储与传输方式，英文1字节，中文3字节。
相关函数
1.ord(字符串):返回该字符串的Unicode码。
2.chr(整数):返回该整数对应的字符串。
字面值
单引和双引号的区别
1.单引号内的双引号不算结束符
2.双引号内的单引号不算结束符
# 1. 双引号
name01 = "悟空"
# 单引号
name02 = '悟空'
三引号作用
1.换行会自动转换为换行符\n
2.三引号内可以包含单引号和双引号
3.作为文档字符串
# 三引号(可见即所得)
name03 = '''悟空'''
name04 = """悟空"""
message = '我叫"齐天大圣".'
message = "我叫'齐天大圣'."
message = """我叫'齐"天大"圣'."""
转义字符
1.改变字符的原始含义。
\’ \” \””” \n \\ \t \0 空字符
2.原始字符串：取消转义。
a = r”C:\newfile\test.py”
# 2. 转义字符：改变字符的原始含义。
# \" \' \\
message = "我叫\"齐天大圣\"."
url = "C:\\arogram Files\\bntel\cedia SDK"
# 原始字符串：没有转义字符
url = r"C:\arogram Files\bntel\cedia SDK"
print(url)
# \t 水平制表格
print("我爱\t编程.")
# \n 换行
print("我爱\n编程.")
字符串格式化
1.定义：
生成一定格式的字符串。
2.语法：
字符串%(变量)
"我的名字是%s,年龄是%s" % (name, age)
3.类型码：
%s 字符串 %d整数 %f 浮点数
# 3. 字符串格式化
name = "qtx"
age = 18
score = 95.12345
print("我的名字是%s,年龄是%d,成绩是%.3f" % (name, age, score))
# 根据格式显示字符串
# ?天?小时?分钟
# print(day + "天" + hour + "小时" + minute + "分钟")
day = 1
hor = 2
minute = 3
print("%d天%d小时%d分钟" % (day, hor, minute))
# ?斤零?两
# print(str(jin) + "斤零" + str(liang) + "两")
jin = 3
liang = 2
message = "%d斤零%d两" % (jin, liang)
print(message)
# ?+?=?
# print(str(number01) + "+" + str(number02) + "=?")
number01 = 10
number02 = 5
print("%d+%d=%d" % (number01, number02, number01 + number02))
列表 list
定义
由一系列变量组成的可变序列容器。
基础操作
1.创建列表：
列表名 = []
列表名 = list(可迭代对象)
# 1. 创建
# -- 直接存储数据
list01 = []
list01 = ["悟空", "八戒"]
# -- 将其他可迭代对象存入列表
list02 = list("我是齐天大圣")
2.添加元素：
列表名.append(元素)
列表.insert(索引，元素)
# 2. 增加
# -- 追加(末尾)
list01.append("唐僧")
# -- 插入(在指定)
list01.insert(1, "沙僧")
3.定位元素：
列表名[索引] = 元素
变量 = 列表名[索引]
变量 = 列表名[切片] # 赋值给变量的是切片所创建的新列表
列表名[切片] = 容器 # 右侧必须是可迭代对象，左侧切片没有创建新列表。遍历列表：
正向：
for 变量名 in 列表名:
变量名就是元素
反向：
for 索引名 in range(len(列表名)-1,-1,-1):
列表名[索引名]就是元素
4.删除元素：
列表名.remove(元素)
del 列表名[索引或切片]
深拷贝和浅拷贝
浅拷贝：复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。
深拷贝：复制整个依懒的变量。
"""
深拷贝
优点：
对其中之一的修改，
绝对不影响另外一个.
缺点：
比较占用内存
"""
# 准备深拷贝的工具
import copy
list01 = [
[1,2,3],
[4,5,6]
]
# list02 =list01[:]
# 深拷贝列表
list02 = copy.deepcopy(list01)
list01[0] = "一"
list01[1][0] = "二"
print(list02)#
# 3. 删除
# -- 根据元素
if "八戒2" in list01:
list01.remove("八戒2") # 备注：如果没有元素则报错
# -- 根据位置
# del list01[1]
del list01[1:3]
# 4. 修改
print(list02)
# -- 索引
# list02[0] = "你" # 索引
# -- 切片
# 原理：遍历右侧可迭代对象,将每个元素赋值给左边切片定位的元素
list02[2:3] = [1,2,3,4,5]
print(list02)
# 5. 查询
# -- 索引
print(list02[-1])
# -- 切片
# 原理：切片后返回新列表（拷贝）
print(list02[:])
# -- 循环
for item in list02:
print(item)
# 需求倒序获取所有元素（不建议切片）
# for item in list02[::-1]:
# print(item)
for index in range(len(list02)-1,-1,-1):
print(list02[index])
列表VS字符串
1.列表和字符串都是序列,元素之间有先后顺序关系。
2.字符串是不可变的序列,列表是可变的序列。
3.字符串中每个元素只能存储字符,而列表可以存储任意类型。
4.列表和字符串都是可迭代对象。
5.函数：
将多个字符串拼接为一个。
result = "连接符".join(列表)
将一个字符串拆分为多个。
列表 = “a-b-c-d”.split(“分隔符”)
"""
list --> str
练习:exercise07
"""
# 根据某些逻辑,拼接字符串.
list01 = ["3", "4", "5", "7"]
# str_result = ""
# for item in list01:
# # 每次循环,每次拼接,每次创建新对象
# str_result = str_result + item
# print(str_result)
str_result = "——".join(list01)
print(str_result)
# 在终端中循环录入字符串,如果录入为空，则停止.
# 打印所有录入的内容(一个字符串)
# 核心思想：使用可变对象代替不可变对象,进行频繁操作.
list_result = []
while True:
content = input("请输入内容：")
if content == "":
break
list_result.append(content)
str_result = "".join(list_result)
print(str_result)
"""
str --> list
练习:exercise08
"""
line = "孙悟空-八戒-唐三藏"
list_person = line.split("-")
print(list_person)
"""
将英文语句进行反转
How are you --> you are How
"""
message = "How are you"
list_temp = message.split(" ")
str_result = " ".join(list_temp[::-1])
print(str_result)
列表推导式
1.定义：
使用简易方法，将可迭代对象转换为列表。
2.语法：
变量 = [表达式 for 变量 in 可迭代对象]
变量 = [表达式 for 变量 in 可迭代对象 if 条件]
3.说明:
如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。
"""
列表推导式
根据一个可迭代对象，构建另外一个列表。
练习:exercise09
"""
# 需求1：将list01中每个元素增加10之后,存入list02
list01 = [34, 45, 54, 65, 67, 87]
# list02 = []
# for item in list01:
# list02.append(item + 10)
list02 = [item + 10 for item in list01]
print(list02)
# 需求2：将list01中所有偶数增加10之后,存入list02
# list02 = []
# for item in list01:
# if item % 2 == 0:
# list02.append(item + 10)
list02 = [item + 10 for item in list01 if item % 2 == 0]
# 练习1：使用列表推导式生成1--50之间能被3或者5整除的数字
list01 = [item for item in range(1, 51) if item % 3 == 0 or item % 5 == 0]
print(list01)
# 练习2：使用列表推导式生成5--60之间数字的平方
list02 = [item ** 2 for item in range(5, 61)]
print(list02)
# 练习3：将1970年到2050年之间的闰年存入列表
list03 = []
for year in range(1970, 2051):
if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
list03.append(year)
# list03 = [year for year in range(1970,2051) if year % 4 ==0 and year % 100 !=0 or year % 400 == 0 ]
print(list03)
列表推导式嵌套
1.语法：
变量 = [表达式 for 变量1 in 可迭代对象1 for 变量2 in可迭代对象2]
2.传统写法：
result = []
for r in ["a", "b", "c"]:
for c in ["A", "B", "C"]:
result.append(r + c)
3.推导式写法：
result = [r + c for r in list01 for c in list02]
元组 tuple
定义
1.由一系列变量组成的不可变序列容器。
2.不可变是指一但创建，不可以再添加/删除/修改元素。
基础操作
1.创建空元组：
元组名 = ()
元组名 = tuple()
2.创建非空元组：
元组名 = (20,)
元组名 = (1, 2, 3)
元组名 = 100,200,300
元组名 = tuple(可迭代对象)
3.获取元素：
变量 = 元组名[索引]
变量 = 元组名[切片] # 赋值给变量的是切片所创建的新列表
4.遍历元组：
正向：
for 变量名 in 列表名:
变量名就是元素
反向：
for 索引名 in range(len(列表名)-1,-1,-1):
元组名[索引名]就是元素
# 1. 创建
tuple01 = ()
tuple01 = (4, 545, 5665, 7, 78)
list01 = [54, 5, 56, 67]
# 列表（预留空间） --> 元组（按需分配）
tuple02 = tuple(list01)
# 元组（按需分配） --> 列表（预留空间）
list02 = list(tuple01)
# 特殊
# -- 如果元组只有一个数据,必须在后面添加逗号
tuple03 = (4,)
# -- 小括号可以省略
tuple04 = 4, 5, 6
# -- 可以直接将容器赋值给多个变量
a, b, c = (8, 9, 10)
print(type(tuple04))
# 2. 查询
# -- 索引
print(tuple01[-1]) # 获取最后一个
print(tuple01[2]) # 获取第三个
# -- 切片
# 原理：创建新容器
print(tuple01[-3:]) # 最后三个
# -- 循环
for item in tuple01:
print(item)
for i in range(len(tuple01) - 1, -1, -1):
print(tuple01[i])
作用
1.元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素。
2.元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为占用空间更小。
3.应用：
变量交换的本质就是创建元组：x, y = （y, x ）
格式化字符串的本质就是创建元祖："姓名:%s, 年龄:%d" % ("tarena", 15)
"""
请使用容器的思想,改造下列代码：
统一管理
"""
year = int(input("请输入年份："))
month = int(input("请输入月份："))
# if month < 1 or month > 12:
# print("月份有误")
# elif month == 2:
# if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
# print("29天")
# else:
# print("28天")
# # elif month == 4 or month == 6 or month == 9 or month == 11:
# elif month in (4, 6, 9, 11):
# print("30天")
# else: # 1 3 5 7 8 10 12
# print("31天")
# 将每月天数,存入元组
day_of_second = 29 if year % 4 == 0 and year % 100 != 0 or year % 400 == 0 else 28
days_of_month = (31, day_of_second, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
print(days_of_month[2]) # 三月
print(days_of_month[-1]) # 十二月
"""
获取年、月、日.
计算这是这一年的第几天.
算法：前几个月的总天数 + 当月天数
2019,5,18
31 28 31 30 + 18
"""
year = int(input("请输入年："))
month = int(input("请输入月："))
day = int(input("请输入天："))
day_of_second = 29 if year % 4 == 0 and year % 100 != 0 or year % 400 == 0 else 28
days_of_month = (31, day_of_second, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
# 累加前几个月的总天数
# total_days = 0
# for i in range( month -1 ):# 0 1 2 3
# total_days += days_of_month[i]
total_days = sum(days_of_month[: month - 1])
# 累加当月天数
total_days += day
print("这是一年的第"+str(total_days)+"天")
字典 dict
定义
1.由一系列键值对组成的可变散列容器。
2.散列：对键进行哈希运算，确定在内存中的存储位置，每条数据存储无先后顺序。
3.键必须惟一且不可变(字符串/数字/元组)，值没有限制。
基础操作
1.创建字典：
字典名 = {键1：值1，键2：值2}
字典名 = dict (可迭代对象)
# 1. 创建
dict01 = {}
dict01 = {101: "悟空", 102: "八戒", 103: "唐僧"}
# 列表(格式) --> 字典
# 格式：[(k,v),(k,v)]
dict02 = dict(["悟空", (102, "猪八戒"), [103, "唐僧"]])
# 字典 --> 列表(只保留key)
list01 = list(dict01)
2.添加/修改元素：
语法:
字典名[键] = 数据
说明:
键不存在，创建记录。
键存在，修改值。
# 2. 添加
# --通过键-值
dict01[104] = "沙僧"
# 3. 修改（如果key存在,则为修改,不存在则为添加）
dict01[101] = "孙悟空"
3.获取元素：
变量 = 字典名[键] # 没有键则错误
4.遍历字典：
for 键名 in 字典名:
字典名[键名]
for 键名,值名 in 字典名.items():
语句
# -- 获取所有key
for key in dict01:
print(key)
# --获取所有value
for value in dict01.values():
print(value)
# --获取所有key - value
# for item in dict01.items():
# print(item)# (k,v)
for key,value in dict01.items():
print(key)
print(value)
5.删除元素：
del 字典名[键]
# 4. 删除
# 如果key不存在则报错
if 108 in dict01:
del dict01[108]
"""
在终端中循环录入商品信息(名称,单价)
如果名称为空,停止录入.
-- 打印所有商品信息(一行一个)
格式：xxx的价格是yyy.
-- 如果录入了游戏机,单独打印其价格.
"""
dict_commoditys = {}
while True:
name = input("请输入商品名称：")
if name == "":
break
price = float(input("请输入商品单价："))
dict_commoditys[name] = price
for k, v in dict_commoditys.items():
print("%s的价格是%f." % (k, v))
if "游戏机" in dict_commoditys:
print(dict_commoditys["游戏机"])
"""
在终端中循环录入学生信息(名称,年龄,性别,成绩...)
如果名称为空,停止录入.
-- 打印所有学生信息(一行一个)
格式：xxx的年龄是xxx,性别是xxx,成绩是xxx.
-- 如果录入了"唐僧",单独打印其成绩
核心：数据结构 字典内嵌列表
{
"悟空":[26,"男",86],
"唐僧":[24,"男",90]
}
"""
dict_persons = {}
while True:
name = input("请输入学生姓名：")
if name == "":
break
age = int(input("请输入学生年龄："))
sex = input("请输入学生性别：")
score = float(input("请输入学生成绩："))
dict_persons[name] = [age, sex, score]
for k_name, v_infos in dict_persons.items():
print("%s的年龄是%d,性别是%s,成绩是%f." % (k_name, v_infos[0], v_infos[1], v_infos[2]))
if "唐僧" in dict_persons:
print(dict_persons["唐僧"][2])
"""
在终端中循环录入学生信息(名称,年龄,性别,成绩...)
如果名称为空,停止录入.
-- 打印所有学生信息(一行一个)
格式：xxx的年龄是xxx,性别是xxx,成绩是xxx.
-- 打印最后一个学生的信息
...
核心：数据结构 列表内嵌字典
[
{"name":"悟空", "age":26,"sex":"男","score":86},
{"name":"唐僧", "age":24,"sex":"男","score":90},
]
17:02
总结：
列表：通过索引/切片获取数据,定位元素灵活. 【灵活】
字典：通过key查找值,代码可读性相对较高
(列表不适合存储多类信息，姓名/年龄/性别)
利用空间,换取时间,定义单个元素最快. 【快速】
"""
list_persons = []
while True:
name = input("请输入学生姓名：")
if name == "":
break
age = int(input("请输入学生年龄："))
sex = input("请输入学生性别：")
score = float(input("请输入学生成绩："))
dict_person = {"name":name, "age":age,"sex":sex,"score":score}
list_persons.append( dict_person )
for person in list_persons:
print("%s的年龄是%d,性别是%s,成绩是%f." % (person["name"], person["age"],person["sex"],person["score"]))
# 最后一个学生信息
person = list_persons[-1]
print("%s的年龄是%d,性别是%s,成绩是%f." % (person["name"], person["age"], person["sex"], person["score"]))
字典推导式
1.定义：
使用简易方法，将可迭代对象转换为字典。
2.语法:
{键:值 for 变量 in 可迭代对象}
{键:值 for 变量 in 可迭代对象 if 条件}
字典 VS 列表
1.都是可变容器。
2.获取元素方式不同,列表用索引,字典用键。
3.字典的插入,删除,修改的速度快于列表。
4.列表的存储是有序的,字典的存储是无序的。
集合 set
定义
1.由一系列不重复的不可变类型变量(元组/数/字符串)组成的可变散列容器。
2.相当于只有键没有值的字典(键则是集合的数据)。
集合set
价值1：去重复
价值2：数学运算
基础操作
1.创建空集合：
集合名 = set()
集合名 = set(可迭代对象)
2.创建具有默认值集合：
集合名 = {1, 2, 3}
集合名 = set(可迭代对象)
# 1. 创建
# set01 ={} # 创建字典,不是集合
set01 = {"悟空", "八戒", "唐僧"}
list01 = ["悟空", "八戒", "唐僧", "八戒"]
set02 = set(list01)
print(set02)
3.添加元素：
集合名.add(元素)
# 2. 添加
set01.add("沙僧")
4.删除元素：
集合名.discard(元素)
# 3. 删除
set01.remove("悟空")
# 4. 修改(先删除后添加)
print(set01)
运算
1.交集&：返回共同元素。
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 & s2 # {2, 3}
# 交集
# &
s01 = {1, 2, 3}
s02 = {2, 3, 4}
print(s01 & s02) # {2, 3}
2.并集：返回不重复元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 | s2 # {1, 2, 3, 4}
# 并集
# |
print(s01 | s02) # {1, 2, 3, 4}
3.补集-：返回只属于其中之一的元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s1 - s2 # {1} 属于s1但不属于s2
补集^：返回不同的的元素
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 ^ s2 # {1, 4} 等同于(s1-s2 | s2-s1)
# 补集
# ^
print(s01 ^ s02) # {1, 4}
print(s01 - s02) # {1 }
print(s02 - s01) # {4 }
4.子集<：判断一个集合的所有元素是否完全在另一个集合中
5.超集>：判断一个集合是否具有另一个集合的所有元素
s1 = {1, 2, 3}
s2 = {2, 3}
s2 < s1 # True
s1 > s2 # True
# 子集超集
s03 = {2, 3}
print(s03 < s01)
6.相同或不同== !=：判断集合中的所有元素是否和另一个集合相同。
s1 = {1, 2, 3}
s2 = {3, 2, 1}
s1 == s2 # True
s1 != s2 # False
子集或相同,超集或相同 <= >=
"""
一个公司有如下员工
经理:"曹操","刘备","孙权"
技术员:"曹操","刘备","张飞","关羽"
1. 选择数据结构,存储以上信息.
2. 是经理也是技术的都有谁？
3. 是经理也不是技术的都有谁？
4. 不是经理也是技术的都有谁？
5. 公司总共有多少人?
6. 张飞是经理吗？
"""
dict_persons = {
"经理": {"曹操", "刘备", "孙权"},
"技术员": {"曹操", "刘备", "张飞", "关羽"}
}
print(dict_persons["经理"] & dict_persons["技术员"])
print(dict_persons["经理"] - dict_persons["技术员"])
print(dict_persons["技术员"] - dict_persons["经理"])
print(len(dict_persons["技术员"] | dict_persons["经理"]))
print("张飞" in dict_persons["经理"])
集合推导式
1.定义：
使用简易方法，将可迭代对象转换为集合。
2.语法:
{表达式 for 变量 in 可迭代对象}
{表达式 for 变量 in 可迭代对象 if 条件}
"""
列表 推导式
[处理变量 for 变量 in 可迭代对象 if 条件]
字典 推导式
{处理变量 : 处理变量 for 变量 in 可迭代对象 if 条件}
集合 推导式
{处理变量 for 变量 in 可迭代对象 if 条件}
适用性：
根据可迭代对象,构建容器时.
"""
# 需求1：range(10) --> key:0-9 value: key的平方
dict01 = {item: item ** 2 for item in range(10)}
print(dict01)
# 需求2：range(10) --> key:0-9 value: key的平方
# 只考虑奇数
dict01 = {item: item ** 2 for item in range(10) if item % 2}
print(dict01)
"""
推导式嵌套
练习:exercise08
"""
list_fruits = ["香蕉", "苹果", "哈密瓜"]
list_drinks = ["可乐", "雪碧", "牛奶", "咖啡"]
# list_result = []
# for fruit in list_fruits:
# for drink in list_drinks:
# list_result.append(fruit + drink)
list_result = [fruit + drink for fruit in list_fruits for drink in list_drinks]
print(list_result)
# 色子 1 -- 6
# 色子 1 -- 6
# 色子 1 -- 6
# 将3个色子所有组合数存储到列表中
# list_result = []
# for x in range(1,7):# 1 2
# for y in range(1,7):# 1 2 ..
# for z in range(1,7):#123456 123456
# list_result.append((x,y,z))
list_result = [(x, y, z) for x in range(1, 7) for y in range(1, 7) for z in range(1, 7)]
print(list_result)
# 练习1:["齐天大圣","八戒","唐三藏"]-->key:字符 vlaue:字符长度
# {"齐天大圣":4,"八戒":2,"唐三藏":3}
list_names = ["齐天大圣", "八戒", "唐三藏"]
dict_names = {item: len(item) for item in list_names}
print(dict_names)
# 练习2:["张无忌","赵敏","周芷若"] [101,102,103]
# {"张无忌":101,"赵敏":102,"周芷若":103}
list_names = ["张无忌", "赵敏", "周芷若"]
list_rooms = [101, 102, 103]
dict_infos = {list_names[i]: list_rooms[i] for i in range(len(list_names))}
print(dict_infos)
# 练习3：将练习2的字典,key 与 value 颠倒
# {101:"张无忌",102:"赵敏",103:"周芷若"}
dict_infos2 = {v: k for k, v in dict_infos.items()}
print(dict_infos2)
"""
for for
练习:exercise02
"""
# 外层循环控制行
for r in range(3): # 0 1 2
# 外层循环控制列
for c in range(4): # 0123 0123 0123
print("老王", end=" ")
print() # 换行
"""
4行5列
*****
#####
*****
#####
"""
for r in range(4):
for c in range(5):
if r % 2 !=0:
print("*",end = "")
else:
print("#",end = "")
print()
for r in range(4):
for c in range(5):
if c % 2 !=0:
print("*",end = "")
else:
print("#",end = "")
print()
"""
for for 练习
"""
# 二维列表
list01 = [
[1,2,3,4],
[5,6,7,8],
[9,10,11,12],
]
# -- 打印第三行第二列数据 [行索引][列索引]
print(list01[2][1])
# -- 从右向左，打印第二行数据(一行一个)
for i in range(len(list01[1])-1,-1,-1):
print(list01[1][i])
# -- 从上向下，打印第三列数据(一行一个)
# [0][2] [1][2] [2][2]
for i in range(len(list01)):
print(list01[i][2])
# -- 将二维列表以表格状打印出来
# 1 2 3 4
# for r in range(len(list01)):
# for c in range(len(list01[r])):
# print(list01[r][c],end = " ")
# print()
for line in list01:
for item in line:
print(item,end = " ")
print()
"""
矩阵转置
算法：将list01中每列,存储到list02中每行
"""
list01 = [
[1,2,3,4],
[5,6,7,8],
[9,10,11,12],
]
list02 = []
# list01[0][0]
# list01[1][0]
# list01[2][0]
for c in range(len(list01[0])):
line = []
for r in range(len(list01)):
line.append(list01[r][c])
list02.append(line)
print(list02)
"""
思想：
将第一位元素,与后面元素进行比较,发现更小的则交换
二
三
...
"""
list01 = [4, 54, 5, 6, 7, 8, 3]
# list01[0] list01[1]
# list01[0] list01[2]
# list01[0] list01[3]
# list01[0] list01[4]
# for i in range(1,len(list01)):
# # list01[0] 与 list01[i] 进行比较
# pass
# list01[1] list01[2]
# list01[1] list01[3]
# list01[1] list01[4]
# list01[1] list01[5]
# for i in range(2, len(list01)):
# # list01[1] 与 list01[i] 进行比较
# pass
for r in range(len(list01) - 1): # 0 1
for c in range(r + 1, len(list01)): # 123.. 234..
if list01[r] > list01[c]:
list01[r], list01[c] = list01[c], list01[r]
print(list01)
"""
list01 = [34,8,56,9,8,9]
判断列表中是否具有相同元素True False
思想：
将第一位元素,与后面元素进行比较,发现相同则打印结论
二
三
如果所有元素比较后，也没有发现相同，则打印结论。
"""
list01 = [34, 8, 56, 9, 8, 9]
result = False # 假设结论是没有重复
# 取数据
for r in range(len(list01) - 1):
# 作比较
for c in range(r + 1, len(list01)):
if list01[r] == list01[c]:
result = True
break # 退出一层循环
if result:
break
print(result)
"""
list01 = [34, 8, 56, 9, 8, 9]
删除列表中相同元素（重复元素只保留一个）
要求：不使用集合
算法：
从后向前判断,如果相同元素(从前向后判断),则删除后面的元素.
"""
list01 = [34, 8, 56, 9, 8, 9]
# 取数据
for r in range(len(list01) - 1, -1, -1):
# 作比较
for c in range(r):
if list01[r] == list01[c]:
del list01[r]
break # 如果删除了后面元素,则无需继续用当前元素比较了
print(list01)
函数 function
pycharm快捷键：
Ctrl + P 参数信息（在方法中调用参数）
Ctrl + Q 快速查看文档
Ctrl + Alt + M 提取方法
定义
1.用于封装一个特定的功能，表示一个功能或者行为。
2.函数是可以重复执行的语句块, 可以重复调用。
作用
提高代码的可重用性和可维护性（代码层次结构更清晰）。
定义函数
1.语法：
def 函数名(形式参数):
函数体
2.说明：
def 关键字：全称是define，意为”定义”。
函数名：对函数体中语句的描述，规则与变量名相同。
形式参数：方法定义者要求调用者提供的信息。
函数体：完成该功能的语句。
3.函数的第一行语句建议使用文档字符串描述函数的功能与参数。
调用函数
1.语法：函数名(实际参数)
2.说明：根据形参传递内容。
"""
函数
"""
# 代码的重复,是万恶之源
# 创建函数
def attack():
"""
攻击
"""
print("直拳")
print("勾拳")
print("侧踹")
# 参数：调用者 给 创建者 传递的信息
# 创建者 要求 调用者 提供的信息
def attack_repeat(count): # 形式参数
"""
重复攻击
:param count: int类型的 攻击次数
"""
for __ in range(count):
attack()
# 调用函数
attack()
attack_repeat(3) # 实际参数
attack_repeat(10)
返回值
1.定义：
方法定义者告诉调用者的结果。
2.语法：
return 数据
3.说明：
return后没有语句，相当于返回 None。
函数体没有return，相当于返回None。
"""
函数返回值
语法
函数创建者 给 调用者 传递的结果
"""
def func01():
print("func01执行喽~")
return 100 # return 数据
re = func01()
print(re)
def func02():
print("func02执行喽~")
# return # return后没有数据或者没有return ,默认为None
re = func02()
print(re)
def func03():
print("func03执行喽~")
return # 退出函数
print("func03又执行喽~")
func03()
"""
函数返回值
应用
设计思想：小而精
"""
# 需求：定义函数,两个数值相加.
def add(number01,number02):
"""
两个数值相加
:param number01: 数值1
:param number02: 数值2
:return:数值类型,相加的结果
"""
result = number01 + number02
return result
# 测试
n1 = float(input("请输入第一个数字："))
n2 = float(input("请输入第二个数字："))
re = add(n1,n2)
print("结果是："+str(re))
# 练习1： 定义函数,在终端中打印列表一个元素一行）
# list01 = [43,4,5,78]
# list02 = [76,6,579]
def print_list(list_target):
"""
打印列表,将列表每个元素打印在终端中（一行一个）
:param list_target:list类型,需要打印的列表
"""
for item in list_target:
print(item)
list01 = [43, 4, 5, 78]
list02 = [76, 6, 579]
print_list(list01)
print_list(list02)
# 练习:定义函数,在终端中根据边长打印矩形
# day05/day04_exercse/exercise01
def print_rectangle(lenght, char):
"""
打印矩形
:param lenght:int类型 边长
"""
print(char * lenght)
for __ in range(lenght - 2):
print(char + " " * (lenght - 2) + char)
print(char * lenght)
# 测试
print_rectangle(5, "*")
print_rectangle(10, "$")
"""
改造 day04/exercise01 代码
定义函数,计算整数每位相加和
"""
def each_unit_sum(number):
"""
:param number:
:return:
"""
sum_value = 0
for item in str(number):
sum_value += int(item)
return sum_value
# 测试
print(each_unit_sum(1234))
"""
改造 day03/exercise04 代码
定义函数,根据成绩判断等级.
"""
# def calculate_score_level(score):
# if score > 100 or score < 0:
# return "不在范围内0-100"
# elif 90 <= score:
# return "优秀"
# elif 80 <= score:
# return "良好"
# elif 60 <= score:
# return "及格"
# else:
# return "不及格"
# 因为return 退出函数，所以无需else语句
def calculate_score_level(score):
if score > 100 or score < 0:
return "不在范围内0-100"
if 90 <= score:
return "优秀"
if 80 <= score:
return "良好"
if 60 <= score:
return "及格"
return "不及格"
print(calculate_score_level(95))
可变／不可变类型在传参时的区别
1.不可变类型参数有:
数值型(整数，浮点数,复数)
布尔值bool
None 空值
字符串str
元组tuple
2.可变类型参数有:
列表 list
字典 dict
集合 set
3.传参说明：
不可变类型的数据传参时，函数内部不会改变原数据的值。
可变类型的数据传参时，函数内部可以改变原数据。
"""
函数内存分配
"""
# 将函数创建的代码加载到内存中（代码区）
# 备注：函数不执行
def func01():
a = 1000
# 调用函数在内存中开辟空间（栈帧）
# 备注：存储在函数内部创建的变量
func01()
# 函数执行后栈帧销毁
# 结论：
# 不可变类型的数据传参时，函数内部不会改变原数据的值。
# 可变类型的数据传参时，函数内部可以改变原数据。
def func02(p1, p2):
# 修改栈帧中变量存储的地址
p1 = 100
# 修改列表第一个元素存储的地址
p2[0] = 200
a = 10 # 不可变对象
b = [20] # 可变对象
# 将变量a,b存储的数据地址传入函数
func02(a, b)
print(a) # 10
print(b) # [200]
函数参数
实参传递方式argument
"""
函数参数
实际参数：调用者以何种方式传递数据
位置实参
-- 序列实参
关键字实参
-- 字典实参
位置传参
定义：实参与形参的位置依次对应。
def func01(p1, p2, p3):
print(p1)
print(p2)
print(p3)
# 1. 位置实参：位置
func01(1, 2, 3)
序列传参
定义：实参用*将序列拆解后与形参的位置依次对应。
list01 = ["a", "b", "c"]
# 2. -- 序列实参：拆
func01(*list01)
关键字传参
定义：实参根据形参的名字进行对应。
# 3. 关键字实参:名字
func01(p3=2, p1=1, p2=3)
字典关键字传参
1.定义：实参用**将字典拆解后与形参的名字进行对应。
2.作用：配合形参的缺省参数，可以使调用者随意传参。
# 4. -- 字典实参：拆
dict01 = {"p3": "c", "p1": 1, "p2": "b"}
func01(**dict01)
形参定义方式parameter
"""
形式参数:约束实参
默认形参：可选
位置形参：必选
星号元组形参：合(位置实参)
命名关键字形参：强制使用关键字实参
双星号字典形参：合(关键字实参)
"""
缺省参数
1.语法：
def 函数名(形参名1=默认实参1, 形参名2=默认实参2, ...):
函数体
2.说明：
缺省参数必须自右至左依次存在，如果一个参数有缺省参数，则其右侧的所有参数都必须有缺省参数。
缺省参数可以有0个或多个，甚至全部都有缺省参数。
位置形参
语法：
def 函数名(形参名1, 形参名2, ...):
函数体
# 1. 位置形参：必选
def func01(p1, p2, p3):
print(p1)
print(p2)
print(p3)
星号元组形参
1.语法：
def 函数名(*元组形参名):
函数体
2.作用：
收集多余的位置传参。
3.说明：
一般命名为'args'
形参列表中最多只能有一个
# 3. 星号元组形参: 合(位置实参)
# 备注：以args命名（不叫p1）
def func03(*p1):
print(p1)
func03()
func03(34, 4, 5, 6, 7, 8)
list01 = [43, 54, 5, 6]
func03(*list01) # 拆
命名关键字形参
1.语法：
def 函数名(*, 命名关键字形参1, 命名关键字形参2, ...):
函数体
def 函数名(*args, 命名关键字形参1, 命名关键字形参2, ...):
函数体
2.作用：
强制实参使用关键字传参
# 4. 命名关键字形参：必须使用关键字实参
# 星号后面的形参是命名关键字形参
def func04(*args, p1, p2):
print(args)
print(p1)
print(p2)
func04(1, p1=2, p2=3)
func04(p1=2, p2=3)
# 案例:print
# print(*args, sep=' ', end='\n', file=None)
print("悟空", 25, 100, end=" ", sep="-") # 悟空-25-100
# print("悟空",25,100," ","-")# 悟空-25-100
# p1 位置形参 p2 命名关键字形参
def func05(p1, *, p2):
print(p1)
print(p2)
func05(1, p2=2)
func05(p1=1, p2=2)
双星号字典形参
1.语法：
def 函数名(**字典形参名):
函数体
2.作用：
收集多余的关键字传参
3.说明:
一般命名为'kwargs'
形参列表中最多只能有一个
# 5. 双星号字典形参：合(关键字实参)
# 备注：以kwargs命名
def func06(**kwargs):
print(kwargs)
func06()
func06(a=1, b=2, c=3)
参数自左至右的顺序
位置形参 --> 星号元组形参 --> 命名关键字形参 --> 双星号字典形参
# 1.
def func01(p1, p2):
p1 = ["孙悟空"]
p2[0] = ["猪八戒"]
a = ["悟空"]
b = ["八戒"]
func01(a, b)
print(a) # ['悟空']
print(b) # [['猪八戒']]
# 2.
def func02(p1, p2):
p2[:] = "孙悟空"
p1[:] = p1[::-1]
a = [10, 20, 30]
b = ["a", "b", "c"]
func02(a, b)
print(a)
print(b)
"""
改造day07/exercise04代码
定义 矩阵转置 函数
改造day08/day07_exercise/exercise04代码
定义 方阵转置 函数
"""
def matrix_transpose(list_matrix):
"""
矩阵转置
:param list_matrix:
:return: 新矩阵
"""
list_result = []
for c in range(len(list_matrix[0])):
line = []
for r in range(len(list_matrix)):
line.append(list_matrix[r][c])
list_result.append(line)
return list_result
# 测试
list01 = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
]
print(matrix_transpose(list01))
def square_matrix_transpose(square_matrix):
for c in range(len(square_matrix) - 1):
for r in range(c + 1, len(square_matrix)):
# 3. 修改可变对象
square_matrix[r][c], square_matrix[c][r] = square_matrix[c][r], square_matrix[r][c]
# 3. 无需通过 return 返回结果
# return square_matrix
# 测试
list01 = [
[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[9, 10, 11, 12],
]
# 1. 传入可变对象
# print(square_matrix_transpose(list01))
square_matrix_transpose(list01)
"""
改造day07/exercise07代码
定义 删除列表中相同元素 函数
体会：传入可变对象、修改可变对象、无需返回值
"""
def delete_duplicates(list_target):
"""
:param list_target:
:return:
"""
count = 0
for r in range(len(list_target) - 1, -1, -1):
for c in range(r):
if list_target[r] == list_target[c]:
del list_target[r]
count += 1
break
return count
# 测试
list01 = [34, 8, 56, 9, 8, 9]
print(delete_duplicates(list01))
print(list01)
"""
改造day07/exercise05代码
定义 排序 函数
体会：传入可变对象、修改可变对象、无需返回值
"""
def sort(list_target):
"""
:param list_target:
:return:
"""
for r in range(len(list_target) - 1): # 0 1
for c in range(r + 1, len(list_target)): # 123.. 234..
if list_target[r] > list_target[c]:
list_target[r], list_target[c] = list_target[c], list_target[r]
list01 = [4, 54, 5, 6, 7, 8, 3]
sort(list01)
print(list01)
"""
改造day03/exercise05代码
定义 根据月份计算天数的 函数
"""
def is_leap_year(year):
"""
判断是否为闰年
:param year:
:return:
"""
return year % 4 == 0 and year % 100 != 0 or year % 400 == 0
def get_day_by_month(year, month):
"""
获取天
:param year:
:param month:
:return:
"""
if month < 1 or month > 12:
return 0
if month == 2:
return 29 if is_leap_year(year) else 28
if month == 4 or month == 6 or month == 9 or month == 11:
return 30
return 31
# 练习: 质数:大于１的整数,除了１和自身以外,不能被其他数字整除
# 定义函数,获取指定范围内的所有质数.
# 例如：2 ~ 20
# [2,3,5,7,11,13,17,19]
# def get_primes(begin, end):
# list_result = []
# for number in range(begin, end + 1): # 7
# for item in range(2, number): # 2 3 ...6
# if number % item == 0: # 7 % 2
# # 不是质数
# break
# else:
# # 是质数
# list_result.append(number)
# return list_result
def is_prime(number):
for item in range(2, number):
if number % item == 0: # 7 % 2
return False
return True
def get_primes(begin, end):
# list_result = []
# for number in range(begin, end + 1):
# if is_prime(number):
# list_result.append(number)
# return list_result
return [number for number in range(begin, end + 1) if is_prime(number)]
# 测试
print(get_primes(2, 20))
# 练习:定义函数,根据时,分,秒，计算总秒数.
# 测试：
# 时,分,秒 --> 总秒数
# 时,分 --> 总秒数
# 分 --> 总秒数
# 时,秒--> 总秒数
def get_total_second(hour=0, minute=0, second=0):
return hour * 3600 + minute * 60 + second
# 1时,2分,3秒 --> 总秒数
print(get_total_second(1, 2, 3))
# 1时,2分 --> 总秒数
print(get_total_second(1, 2))
# 2分 --> 总秒数
print(get_total_second(minute=2))
# 1时,3秒--> 总秒数
print(get_total_second(1,second=3))
# 练习:定义函数,数值相加的函数.
# 测试：1,2
# 1,2,5,54,65,6,
def sum_numbers(*args):
# sum_value = 0
# for item in args:
# sum_value += item
# return sum_value
return sum(args)
print(sum_numbers())
print(sum_numbers(1, 2, 3, 54, 4, 56, 6, 7))
作用域LEGB
1.作用域：变量起作用的范围。
2.Local局部作用域：函数内部。
3.Enclosing 外部嵌套作用域 ：函数嵌套。
4.Global全局作用域：模块(.py文件)内部。
5.Builtin内置模块作用域：builtins.py文件。
变量名的查找规则
1.由内到外：L -> E -> G -> B
2.在访问变量时，先查找本地变量，然后是包裹此函数外部的函数内部的变量，之后是全局变量，最后是内置变量。
局部变量
1.定义在函数内部的变量(形参也是局部变量)
2.只能在函数内部使用
3.调用函数时才被创建，函数结束后自动销毁
全局变量
1.定义在函数外部,模块内部的变量。
2.在整个模块(py文件)范围内访问（但函数内不能将其直接赋值）。
global 语句
1.作用：
在函数内部修改全局变量。
在函数内部定义全局变量(全局声明)。
2.语法：
global 变量1, 变量2, …
3.说明
在函数内直接为全局变量赋值，视为创建新的局部变量。
不能先声明局部的变量，再用global声明为全局变量。
nonlocal 语句
1.作用：
在内层函数修改外层嵌套函数内的变量
2.语法
nonlocal 变量名1,变量名2, ...
3.说明
在被嵌套的内函数中进行使用