计算机基础结构

硬件

1944年，美籍匈牙利数学家冯·诺依曼提出计算机基本结构。
五大组成部分：运算器、控制器、存储器、输入设备、输出设备。
-- 运算器：按照程序中的指令，对数据进行加工处理。-- 控制器：根据程序需求，指挥计算机的各个部件协调工作。
通常将运算器和控制器集成在中央处理器（CPU）中。-- 存储器：保存各类程序的数据信息。内存RAM -- 容量小，速度快，临时存储数据 硬盘HDD -- 容量大，速度慢，永久存储数据输入设备：外界向计算机传送信息的装置。例如：鼠标、键盘、扫描仪…
输出设备：计算机向外界传送信息的装置。  例如：显示器、音响、打印机…

软件

操作系统：

 -- 管理和控制计算机软件与硬件资源的程序。-- 隔离不同硬件的差异~~，使软件开发简单化。-- Windows，Linux，Unix。

应用软件：为了某种特定的用途而被开发的软件。

软件：程序 + 文档。

-- 程序是一组计算机能识别和执行的指令集合。-- 文档是为了便于了解程序所需的说明性资料。

Python 简介

Python 定义

是一个免费、开源、跨平台、动态、面向对象的编程语言。

# Python程序的执行方式

交互式

在命令行输入指令，回车即可得到结果。1.打开终端2.进入交互式：python33.编写代码：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.py2. 在文件中写入：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 +d5.选择列：shift + alt + 鼠标左键6.移动行：shift + alt + 上下箭头7.智能提示：ctrl + space8.代码格式化：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 = 100score1, score2 = 95, 96name1 = 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  没值falseprint(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.141 + 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 * 5number01 = "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)# ? 6data01 = 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    # TrueTrue and False    # FalseFalse 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 yx is not y
作用：
is 用于判断两个对象是否是同一个对象,是时返回True,否则返回False。is not 的作用与is相反

"""身份运算符
"""
list01 = [100]
list02 = [100]# 两个变量指向的对象是否同一个
print(list01 is list02)# Falselist03 = 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:语句块1elif 条件2:语句块2else:语句块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 12print("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.9845print(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 4count += 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 910     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 += dirprint(begin)

"""一张纸的厚度是0.01毫米请计算,对折多少次超过珠穆朗玛峰(8844.43米).
"""# 数据：厚度、次数
# thickness = 0.01 / 1000
# 算法：*=2   += 1thickness = 1e-5
count = 0
while thickness <= 8844.43:thickness *= 2count += 1print("第" + 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 += 1input_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 可迭代对象:语句块1else:语句块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 = 0for 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:continuesum_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 copylist01 = [[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 == "":breaklist_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,1831 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 += dayprint("这是一年的第"+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 == "":breakprice = 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 == "":breakage = 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 == "":breakage = 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  # Trues1 > s2  # True

# 子集超集
s03 = {2, 3}
print(s03 < s01)

6.相同或不同== !=：判断集合中的所有元素是否和另一个集合相同。s1 = {1, 2, 3}s2 = {3, 2, 1}s1 == s2  # Trues1 != 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   0123print("老王", 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] 进行比较
#     passfor r in range(len(list01) - 1):  # 0       1for 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 = Truebreak  # 退出一层循环if result:breakprint(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 ,默认为Nonere = func02()
print(re)def func03():print("func03执行喽~")return # 退出函数print("func03又执行喽~")func03()

"""函数返回值应用设计思想：小而精
"""
# 需求：定义函数,两个数值相加.def add(number01,number02):"""两个数值相加:param number01: 数值1:param number02: 数值2:return:数值类型,相加的结果"""result = number01 + number02return 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/exercise01def 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 = 0for 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] = 200a = 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 = 0for 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 += 1breakreturn 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       1for 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 == 0def get_day_by_month(year, month):"""获取天:param year::param month::return:"""if month < 1 or month > 12:return 0if month == 2:return 29 if is_leap_year(year) else 28if month == 4 or month == 6 or month == 9 or month == 11:return 30return 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_resultdef is_prime(number):for item in range(2, number):if number % item == 0:  # 7  % 2return Falsereturn Truedef get_primes(begin, end):# list_result = []# for number in range(begin, end + 1):#     if is_prime(number):#         list_result.append(number)# return list_resultreturn [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_valuereturn 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.说明
在被嵌套的内函数中进行使用

python基础笔记一相关推荐

1. Python基础 笔记(一) Python的介绍

   Python基础 笔记(一) Python的介绍 您好! 欢迎来到木易巷! 接下来,让我们一起来了解Python,走进Python~ 1.编程语言 编程语言(programming language) ...

2. Python 基础笔记

   Python 基础笔记 内置函数 print() 打印输出 type() 数据类型查询 isinstance() 判断数据是否是已知类型 input() 接受键盘输入 range() 函数 forma ...

3. python基础笔记，超详细，包含面向对象基础，爬虫实战【持续更新中...】

   前言: 本笔记中的函数和方法同义,面向python3 本笔记部分概念及代码由newbing搜集整理得出 本笔记适合有一定其他编程语言基础的同学,因为笔记中省略了部分基础概念(比如整型,浮点型等基本数据 ...

4. python基础笔记（二）

   <黑马>python笔记~二 前言 一.配套视频 二.python基础初级 三.python基础中级 四.python基础高级 目录 python基础中级(列表.元组.字典.字符串) 01 ...

5. 霍格沃兹测试开发学社技术学习笔记之——Python基础笔记

   # 阶段十一-Python语言和测试框架(1) ## 1.pycharm环境变量配置和安装 ## 2.基础数据类型 数字 字符串 ## 3.运算符 字符串算数运算符 比较运算符 赋值运算符 逻辑运算符 ...

6. 廖雪峰Python基础笔记

   python 1.第一个python程序 交互模式(>>>)退出用exit() 打印使用print()函数,打印的内容可以用单引号或者双引号括起来,但是不能够混用 命令行模式,可以输 ...

7. Python基础笔记（1-1）

   笔记来源小甲鱼零基础入门 (笔记都做了!求求你多复习吧!干点儿人应该干的事儿!) 文章目录 一. 000. 愉快的开始 - 002. 设计第一个游戏 1. Python的应用范围 2. Python的 ...

8. python基础笔记_python基础学习笔记（九）

   python异常 python用异常对象(exception object)来表示异常情况.遇到错误后,会引发异常.如果异常对象并未被处理或捕捉,程序就会用所谓的 回溯(Traceback, 一种错误 ...

9. [PYTHON]python 基础笔记(1)

   最近一直在研究python... 自学了一段时间,感觉对我这种本身脑子转不过弯的人来是真心是个不错的选择.. 以下是自己学习总结的笔记,有需要的朋友可以用来参考. 系统版本: Centos6.3 x6 ...

10. Python基础笔记——函数

    函数 1,函数是组织好的,可重复使用的,用来实现独立功能的代码段. 2,函数能提高应用的模块性,可以提高程序代码的重用率.(主要是因为懒,并且节省空间) 3,把代码封装到函数里,当需要使用时在调用出来 ...

最新文章

1. Vue安装支持SCSS插件
2. java中double类型精度丢失问题及解决方法
3. monodroid发布的最新版本
4. android 挂载 nfs工具,Android 挂载 NFS
5. Java虚拟机内存分配策略
6. Servlet规范定义的Servlet 生命周期
7. asp.net(c#) 将dbf转换为xls或wps，并将数据的列名改成中文；并判断本机是否安装office2003,2007和wps2007,2010...
8. 【kafka】Group coordinator xx is unavailable or invalid, will attempt rediscovery
9. [转]Vue Cli3 + VS Code 愉快调试
10. HTTP请求中文乱码解决办法
11. Windows cmd常用命令
12. overleaf/latex 使用IEEE tran模板同名作者用横线替代
13. 服务器临时文件定时清理,定时/开机自动清理Win10临时文件夹的技巧
14. 性能测试，CPU使用率CPU负载率理解
15. 紫阳的日常——第一章 拒绝访问的高考成绩
16. UEFI+GPT引导实践篇 (UEFI引导安装64位Win7/Win8)
17. 中国激光直接成型LDS级树脂市场发展态势及项目投资建议报告2022-2028年
18. Win10 虚拟桌面的使用
19. 零基础学python-2.24 一些常用函数
20. 独孤思维：长期稳妥的赚钱方法

热门文章

1. 蓝桥 星期一 JAVA
2. MSBUILD : error MSB4132: The tools version “2.0“ is unrecognized. Available tools versions are “4.0“
3. 乔布斯去世业界地震 生前事迹全回顾
4. DZ论坛+克米模板3.5版本全解密+教程
5. JS高级的学习(二)
6. linux gcc strip命令简介
7. 指针式万用表使用与原理
8. 安卓如何使用layout布局的弹出框AlertDialog
9. 老毛桃重启计算机没反应,老毛桃怎么用
10. QQ拼音直接提权WIN8