Python笔记

Python 简介

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

基础知识

Python程序的执行方式

交互式

在命令行输入指令，回车即可得到结果。

1. 打开终端
2. 进入交互式：python3
3. 编写代码：print(“hello world”)
4. 离开交互式：exit()

文件式

将指令编写到.py文件，可以重复运行程序。

1. 编写文件
2. 打开终端
3. 进入程序所在目录：cd 目录
4. 执行程序：python3 文件名

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 + delete
6. 选择列：shift + alt +鼠标左键
7. 移动行：shift + alt + 上下箭头
8. 代码格式化：ctrl+alt+l

注释

给人看的，通常是对代码的描述信息

1. 单行注释：以#号开头
2. 多行注释：三引号开头，三引号结尾

函数

表示一个功能，函数定义者是提供功能的人，函数调用者是使用功能的人。

例如：

1. print(数据) 作用：将括号中的内容显示在控制台中
2. 变量 = input(“需要显示的内容”) 作用：将用户输入的内容赋值给变量

"""练习：判断英文句子成分：I kiss you
"""
subject = input("请输入I kiss you的主语:")
predicate = input("请输入I kiss you的谓语:")
object = input("请输入I kiss you的宾语:")
print("您输入的主语是:" + subject + ",谓语是:" + predicate + ",宾语是:" + object + ".")

变量

关联一个对象的标识符

1. 命名：必须是字母或下划线开头，后跟字母、数字、下划线
   不能使用关键字(蓝色)，否则发生语法错误：SyntaxError: invalid syntax
2. 建议命名：字母小写，多个单词以下划线隔开：
   class_name = “xxx”
3. 赋值：创建一个变量或改变一个变量关联的数据。
4. 语法：
   变量名 = 数据
   变量名1 = 变量名2 = 数据
   变量名1, 变量名2, = 数据1, 数据2

#创建变量
name01 = "悟空"
name02 = "八戒"
#修改变量
name02 = "唐僧"
#相加产生新数据
name03 = name01 + name02
#传递数据地址
name04 = name03

"""画出下列代码内存图,说出终端显示结果
"""
name_of_hubei_province = "湖北"
name_of_hunan_province = "湖南"
name_of_hunan_province = "湖南省"
name_of_hunan_province = name_of_hubei_province
print(name_of_hunan_province)  # 湖北

del 语句

1. 语法:

del 变量名1, 变量名2

1. 作用：
   用于删除变量,同时解除与对象的关联.如果可能则释放对象。
2. 自动化内存管理的引用计数：
   每个对象记录被变量绑定(引用)的数量,当为0时被销毁。

“”"
删除 del
“”"

`name01 = "悟空"`
`name02 = name01 # 创建2个变量,赋同样的值`
`name02 = name01 = "悟空"`
`del name01 # 删除变量,"悟空"存在`
`del name02 # 删除变量,"悟空"不存在(引用计数为0)`
`name02 = "唐僧" # 修改变量,"悟空"不存在(引用计数为0)`

核心数据类型

在python中变量没有类型，但关联的对象有类型。

整形int

1. 表示整数，包含正数、负数、0
   如： -5, 100, 0
2. 字面值：
   十进制：每位用十种状态计数，逢十进一，写法是0~9
   二进制：每位用二种状态计数，逢二进一，写法是0b开头，后跟0或者1
   八进制：每位用八种状态计数，逢八进一，写法是0o开头，后跟0~7
   十六进制：每位用十六种状态计数，逢十六进一，写法是0x开头，后跟0-9,A-F,a-f

浮点型float

1. 表示小数，包含正数、负数，0.0
2. 字面值：
   小数：1.0 2.5
   科学计数法：e/E (正负号) 指数
   1.23e-2 (等同于0.0123)
   1.23456e5(等同于123456.0)

字符串str

1. 是用来记录文本信息(文字信息)
2. 字面值：双引号

布尔bool

1. 用来表示真和假的类型
2. True 表示真(条件满足或成立)，本质是1
3. False 表示假(条件不满足或不成立)，本质是0

#命题：您是总统
result = input("请输入您的职业：")  # "总统"
print(result)  # True
print(type(result))

数据类型转换

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

"""练习：在终端中输入商品单价、购买的数量和支付金额。计算应该找回多少钱。效果：请输入商品单价：5请输入购买数量：3请输入支付金额：20应找回：5.0
"""
#1. 获取数据
price = float(input("请输入商品单价："))
count = int(input("请输入购买数量："))
money = float(input("请输入支付金额："))
#2. 逻辑计算
result = money - price * count
#3. 显示结果
print("应找回：" + str(result))

运算符

算术运算符

加法 +
减法 -
乘法 *
除法 / ：结果为浮点数
整除 // ：除的结果去掉小数部分
求余 %
幂运算 **

优先级从高到低：
()
**
* / % //
+ -

算数运算符
+ - * / // % **
增强运算符:在算数运算符基础上增加了对自身赋值的功能
+= -= *= /= //= %= **=

"""练习2：古代的秤，一斤十六两。在终端中获取两，计算几斤零几两。效果：请输入总两数：100结果为：6斤4两
"""
total_liang = int(input("请输入总两数："))
jin = total_liang // 16
liang = total_liang % 16
print("结果为：" + str(jin) + "斤" + str(liang) + "两")

"""练习2：匀变速直线运动的速度与位移公式：位移 =  初速度 × 时间 + 加速度 * 时间的平方 / 2已知(在终端中录入)：位移、时间、初速度计算：加速度
"""
#(位移 -初速度 × 时间) * 2 / 时间 ** 2 =  加速度
s = float(input("请输入位移："))
v0 = float(input("请输入初速度："))
t = float(input("请输入时间："))
a = (s - v0 * t) * 2 / t ** 2
print(a)

增强运算符

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

"""
练习：在终端中输入一个四位整数，计算每位相加和。例如：录入1234，打印1+2+3+4结果效果：请输入四位整数：1234结果是：10
"""
number = int(input("请输入四位整数："))
unit01 = number % 10  # 个位
#1234　//　10  --> 123  %　10 --> 3
unit02 = number // 10 % 10  # 十位
#1234　//　100 --> 12   %　10 --> 2
unit03 = number // 100 % 10  # 百位
unit04 = number // 1000  # 千位
result = unit01 + unit02 + unit03 + unit04
#建议
result = number % 10
result += number // 10 % 10
result += number // 100 % 10
result += number // 1000
print("结果是：" + str(result))

“”"
变量交换
“”"

bridegroom_name = "武大郎"
bride_name = "潘金莲"
#传统思想：借助第三方变量
#temp = bridegroom_name
#bridegroom_name = bride_name
#bride_name = temp
#交换律思想：a,b=b,a
bridegroom_name, bride_name = bride_name, bridegroom_name
print("交换后的新郎：" + bridegroom_name)
print("交换后的新娘：" + bride_name)

比较运算符

小于 <
小于等于 <=
大于 >
大于等于 >=
等于 ==
不等于 !=
返回布尔类型的值
比较运算的数学表示方式:0 <= x <= 100

逻辑运算符

与and

表示并且的关系，一假俱假

#示例:
True and True   # True
True and False  # False
False and True  # False
False and False # False

或or

表示或者的关系，一真俱真

#示例:
True or True        # True
True or False       # True
False or True       # True
False or False  # False

非 not

表示取反

#例如：
not True   # 返回False
not False  # 返回True
print(True or True)  # True
print(False or True)  # True
print(True or False)  # True
print(False or False)  # False

短路运算

一但结果确定，后面的语句将不再执行。

身份运算符

语法:
x is y
x is not y
作用：
is 用于判断两个对象是否是同一个对象,是时返回True,否则返回False。
is not 的作用与is相反

优先级

高到低：
算数运算符
比较运算符
增强运算符
身份运算符
逻辑运算符

语句

行

1. 物理行：程序员编写代码的行。
2. 逻辑行：python解释器需要执行的指令。
3. 建议一个逻辑行在一个物理行上。
4. 如果一个物理行中使用多个逻辑行，需要使用分号；隔开。
5. 如果逻辑行过长，可以使用隐式换行或显式换行。
   隐式换行：所有括号的内容换行,称为隐式换行
   括号包括: () [] {} 三种
   显式换行：通过折行符 \ (反斜杠)换行，必须放在一行的末尾，目的是告诉解释器,下一行也是本行的语句。

#3个物理行 3个逻辑行 (建议)
a = 1
b = 2
c = a + b
#1个物理行 3个逻辑行(使用分号隔开多条命令)
a = 1;b = 2;c = a + b
#3个物理行 1个逻辑行(使用折行符在多个物理行下达一条命令)
a = 1+2+\3+4+\5+6
#通过括号(小中大)自动换行
a = (1+2+3+4+5+6)

选择语句

If elif else 语句

1. 作用:
   让程序根据条件选择性的执行语句。
2. 语法:

if 条件1:语句块1
elif 条件2:语句块2
else:语句块3

1. 说明:
   elif 子句可以有0个或多个。
   else 子句可以有0个或1个，且只能放在if语句的最后。

选择语句
让语句有选择性的执行
if 条件:
满足条件执行的语句
else:
不满足条件执行的语句
调试Debug
让程序中断,逐语句审查程序执行过程与实际取值.
1. 加断点(在可能出错的行)
2. 开始调试(点击Debug按钮)
3. 按F8逐语句执行,看变量取值

"""
练习1：如果满足 职位是高管 或者 年薪大于50000的 条件 则显示“娶你”否则显示”继续努力 ”
"""
if (input("请输入职位：") == "高管" orint(input("请输入身高：")) > 500000):print("娶你")
else:print("继续努力")

# 练习2:
# 在终端中输入性别
# 打印"您好先生"  "您好女士"  "未知"
sex = input("请输入性别：")
if sex == "男":print("您好先生")
elif sex == "女":print("您好女士")
else:print("未知")

"""
练习3：
在终端中输入课程阶段数,显示课程名称1 显示 Python语言核心编程2 显示 Python高级软件技术3 显示 Web 全栈4 显示 网络爬虫5 显示 数据分析、人工智能
"""
course = input("请输入课程编号：")
if course == "1":print("Python语言核心编程")
elif course == "2":print("Python高级软件技术")
elif course == "3":print("Web 全栈")
elif course == "4":print("网络爬虫")
elif course == "5":print("数据分析、人工智能")

# 练习4：
#     在终端中录入4个同学身高,打印最高的值.
#     算法：
#         170    160    180    165
#         假设第一个就是最大值
#         使用假设的和第二个进行比较, 发现更大的就替换假设的
#         使用假设的和第三个进行比较, 发现更大的就替换假设的
#         使用假设的和第四个进行比较, 发现更大的就替换假设的
#         最后，假设的就是最大的.
#   效果：
# 请输入第1个同学身高:170
# 请输入第2个同学身高:160
# 请输入第3个同学身高:180
# 请输入第4个同学身高:165
# 最高的同学:180
height01 = int(input("请输入第1个同学身高："))
height02 = int(input("请输入第2个同学身高："))
height03 = int(input("请输入第3个同学身高："))
height04 = int(input("请输入第4个同学身高："))
max_value = height01
if max_value < height02:max_value = height02
if max_value < height03:max_value = height03
if max_value < height04:max_value = height04
print("最高的同学:" + str(max_value))

# 练习5：
#       根据心理年龄与实际年龄，打印智商等级。
#       智商IQ = 心理年龄MA 除以 实际年龄CA 乘以 100
#     天才：140以上（包含）
#     超常：120-139之间（包含）
#     聪慧：110-119之间（包含）
#     正常：90-109之间（包含）
#     迟钝：80-89之间（包含）
# 低能：80以下
#写法一：
ma = int(input("请输入心理年龄："))
ca = int(input("请输入实际年龄："))
iq = ma / ca * 100
# 连续区间的判断：建议只考虑单边
if 140 <= iq:print("天才")
elif 120 <= iq:  # 程序能执行到本行,说明一定小于140print("超常")
elif 110 <= iq:print("聪慧")
elif 90 <= iq:print("正常")
elif 80 <= iq:print("迟钝")
else:print("低能")
#写法二：
# 下列写法,适合不连续的区间
# if iq >= 140:
#     print("天才")
# elif 120 <= iq < 140: # el与iq < 140都在表达小于140
#     print("超常")
# elif 110 <= iq < 120:
#     print("聪慧")
# elif 90 <= iq < 110:
#     print("正常")
# elif 80 <= iq < 90:
#     print("迟钝")
# else:
#     print("低能")

# 练习6：
#     在终端中输入月份，打印相应的天数.
#     1 3 5 7 8 10 12 有 31天
#     2 有 29天
#     4  6  9  11 有 30天
# 超过月份提示月份有误
# 效果：
# 请输入月份:10
# 31天
month = int(input("请输入月份："))
if 1 <= month <= 12:if month == 2:print("28天")elif month == 4 or month == 6 or month == 9 or month == 11:print("30天")else:print("31天")
else:print("月份有误")

if 语句的真值表达式

if 100:print("真值")
#等同于
if bool(100):print("真值")

# 练习：在终端中输入一个整数，如果是奇数为变量state赋值"奇数",否则赋值"偶数"。
# 效果：
#   请输入数字:6
# state变量存储的是：偶数
#写法一：
# if int(input("请输入整数:")) % 2:
#     state = "奇数"
# else:state = "偶数"
state = "奇数" if int(input("请输入整数:")) % 2 \else "偶数"
print(state)

条件表达式

语法：

变量 = 结果1 if 条件 else 结果2

作用：根据条件(True/False) 来决定返回结果1还是结果2。
“”"
条件表达式
变量 = 满足条件的值 if 条件 else 不满足条件的值
“”"

# 根据一个条件,为变量赋值
# if input("请输入性别:") == "男":
#     value = 1
# else:
#     value = 0
value = 1 if input("请输入性别:") == "男" else 0
print(value)

# 练习：在终端中输入一个年份，如果是闰年为变量day赋值29,否则赋值28。
#       闰年条件：年份能被4整除但是不能被100整除
#                 年份能被400整除
# 效果：
#   请输入年份:2020
# 2020年的2月有29天
year = int(input("请输入年份："))if year % 4 == 0 and year % 100 != 0 or \year % 400 == 0:day = 29
else:day = 28

循环语句

while语句

while 循环计数1. 开始2. 结束3. 间隔

# 计数器
count = 0
while count < 5:print("跑圈" + str(count))  # 0 1 2 3 4count += 1

1. 作用:
   可以让一段代码满足条件，重复执行。
2. 语法:

while 条件:满足条件执行的语句
else:不满足条件执行的语句

1. 说明:
   else子句可以省略。
   在循环体内用break终止循环时,else子句不执行。

“”"
while 循环
当满足条件时执行循环体
执行后再判断条件,如果还满足则继续执行…
while True:
循环体
if 退出条件:
break # 跳出循环
“”"

while True:number = int(input("请输入数字："))if number > 0:print("正数")elif number < 0:print("负数")else:print("零")if input("请输入q键退出:") == "q":break

#练习1：
#让下列代码重复执行，输入y继续(不输入y则退出)sex = input("请输入性别:")if sex == "男":print("您好先生")elif sex == "女":print("您好女士")else:print("未知")
while True:sex = input("请输入性别:")if sex == "男":print("您好先生")elif sex == "女":print("您好女士")else:print("未知")if input("输入y继续") != "y":break

#练习2：
#在终端中显示0  1  2  3
#在终端中显示2  3  4  5  6
#在终端中显示1  3  5  7
#在终端中显示8  7  6  5  4
#在终端中显示-1  -2  -3  -4  -5
count = 0
while count < 4:print(count)count += 1count = 2
while count < 7:print(count)count += 1count = 1
while count < 8:print(count)count += 2count = 8
while count > 3:print(count)count -= 1count = -1
while count > -6:print(count)count -= 1

"""练习3：在终端中循环录入5个成绩,最后打印平均成绩(总成绩除以人数)效果：请输入成绩：98请输入成绩：83请输入成绩：90请输入成绩：99请输入成绩：78平均分：89.6
"""
count = 0
total_score = 0
while count < 5:count += 1total_score += int(input("请输入成绩："))
print("平均分：" + str(total_score / 5))

"""练习4：一张纸的厚度是0.01毫米请计算，对折多少次超过珠穆朗玛峰(8844.43米)数据： 厚度      次数算法：厚度*=2   次数+=1
"""
# thickness = 0.01 / 1000
# thickness = 0.00001
thickness = 1e-5
count = 0
while thickness <= 8844.43:thickness *= 2count += 1print("第"+str(count)+"次对折的高度是："+str(thickness))
print("总共对折" + str(count) + "次")

"""练习5：程序产生1个,1到100之间的随机数。让玩家重复猜测,直到猜对为止。每次提示：大了、小了、恭喜猜对了,总共猜了多少次。
"""
# 准备一个随机数工具
import random
# 产生一个随机数
random_number = random.randint(1, 100)
count = 0
while True:count += 1input_number = int(input("请输入数字："))if input_number > random_number:print("大了")elif input_number < random_number:print("小了")else:print("恭喜猜对了,总共猜了" + str(count) + "次。")break

for 语句

1. 作用:
   用来遍历可迭代对象的数据元素。
   可迭代对象是指能依次获取数据元素的对象，例如：容器类型。
2. 语法:

for 变量列表 in 可迭代对象:语句块1
else:语句块2

1. 说明:
   else子句可以省略。
   在循环体内用break终止循环时,else子句不执行。

"""for 循环for 变量 in 可迭代对象 :
"""
message = "我是孙悟空"
for item in message:print(item)# item = "a" # 修改变量item,不影响message

"""练习:在终端中输入任意整数，计算累加和."1234" -> "1" -> 累加 1
"""
sum_value = 0
for item in input("请输入任意整数："):sum_value += int(item)
print(sum_value)

range 函数

1. 作用:
   用来创建一个生成一系列整数的可迭代对象(也叫整数序列生成器)。
2. 语法:
   range(开始点，结束点，间隔)
3. 说明:
   函数返回的可迭代对象可以用for取出其中的元素
   返回的数字不包含结束点
   开始点默认为0
   间隔默认值为1

"""练习：在终端中累加 0  1  2  3在终端中累加 2  3  4  5  6在终端中累加 1  3  5  7在终端中累加 8  7  6  5  4在终端中累加 -1  -2  -3  -4  -5
"""
sum_value = 0
for item in range(4):sum_value += item
print(sum_value)sum_value = 0
for number in range(2, 7):sum_value += number
print(sum_value)sum_value = 0
for element in range(1, 8, 2):sum_value += element
print(sum_value)sum_value = 0
for i in range(8, 3, -1):sum_value += i
print(sum_value)sum_value = 0
for i in range(-1, -6, -1):sum_value += i
print(sum_value)

跳转语句

break 语句

1. 跳出循环体，后面的代码不再执行。
2. 可以让while语句的else部分不执行。

continue 语句

跳过本次，继续下次循环。

# 练习：累加10 -- 60之间，个位不是3/5/8的整数和。
sum_value = 0
for number in range(10, 61):unit = number % 10# 满足条件 累加if unit != 3 and unit != 5 and unit != 8:sum_value += number
print(sum_value)  # 1255sum_value = 0
for number in range(10, 61):unit = number % 10# 不满足条件 跳过if unit == 3 or unit == 5 or unit == 8:continuesum_value += number
print(sum_value)  # 1255

容器类型

通用操作

数学运算符

1. +：用于拼接两个容器
2. +=：用原容器与右侧容器拼接,并重新绑定变量
3. *：重复生成容器元素
4. *=：用原容器生成重复元素, 并重新绑定变量
5. < <= > >= == !=：依次比较两个容器中元素,一但不同则返回比较结果。

#拼接两个容器元素
name03 = name01 + name02
print(name03)  # 悟空八戒#重复容器中的元素
name04 = name01 * 20
print(name04)  # 悟空悟空#依次比较两个容器中元素,一但不同则返回比较结果。
print(name01 > name02)#成员运算符
#True
print("悟空" in "花果山水帘洞齐天大圣孙悟空")
print("水帘" in "花果山水帘洞齐天大圣孙悟空")
#False
print("大圣齐天" in "花果山水帘洞齐天大圣孙悟空")
print("水洞" in "花果山水帘洞齐天大圣孙悟空")

"""for 循环for 变量 in 可迭代对象 :
"""
message = "我是孙悟空"
for item in message:print(item)# item = "a" # 修改变量item,不影响message

"""练习：在终端中获取一个整数，作为边长，打印矩形
"""
number = int(input("请输入整数："))
print("*" * number)for __ in range(number - 2):print("*%s*" % (" " * (number - 2)))print("*" * number)

成员运算符

1. 语法：
   数据 in 序列
   数据 not in 序列
2. 作用：
   如果在指定的序列中找到值，返回bool类型。

索引index

1. 作用：定位单个容器元素。
2. 语法：容器[整数]
3. 说明：
   正向索引从0开始，第二个索引为1，最后一个为len(s)-1。
   反向索引从-1开始,-1代表最后一个,-2代表倒数第二个,以此类推,第一个是-len(s)。

"""索引
"""
message = "我是花果山水帘洞美猴王齐天大圣"
print(message[0])  # 我
print(message[4])  # 山
print(message[-4])  # 齐
# print(message[1.5]) # 编号必须是整数
# print(message[100]) # IndexError
# print(message[-100]) # IndexError
print(len(message))  # 字符串长度
# 通过正向索引定位最后一个元素
print(message[len(message) - 1])
# 通过反向索引定位第一个元素
print(message[-len(message)])
# 定位第三个、第五个、倒数第二个、倒数第四个
print(message[2])
print(message[4])
print(message[-2])
print(message[-4])
# 定位 "山"  "王"
print(message[4])
print(message[-5])

切片slice

1. 作用：
   定位多个容器元素。
2. 语法：
   容器[开始索引:结束索引:步长]
3. 说明：
   结束索引不包含该位置元素
   步长是切片每次获取完当前元素后移动的偏移量
   开始、结束和步长都可以省略

"""练习：字符串： content = "我是京师监狱狱长金海。"打印第一个字符、打印最后一个字符、打印中间字符打印字前三个符、打印后三个字符命题：金海在字符串content中命题：京师监狱不在字符串content中通过切片打印“京师监狱狱长”通过切片打印“长狱狱监师京”通过切片打印“我师狱海”倒序打印字符
"""
content = "我是京师监狱狱长金海。"print(content[0])
print(content[-len(content)])print(content[len(content) - 1])
print(content[-1])print(content[5])
print(content[len(content) // 2])print(content[:3])
print(content[-3:])print("金海" in content)
print("京师监狱" not in content)print(content[2:-3])
print(content[-4:1:-1])
print(content[::3])
print(content[::-1])

内建函数

1. len(x) 返回序列的长度
2. max(x) 返回序列的最大值元素
3. min(x) 返回序列的最小值元素
4. sum(x) 返回序列中所有元素的和(元素必须是数值类型)

字符串 str

由一系列字符组成的不可变序列容器，存储的是字符的编码值

"""字符串编码
"""
#字 --> 数
number = ord("a")
print(number)  # 97#数 --> 字
chrt = chr(97)
print(chrt)  # a

编码

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：在终端中录入一个内容,循环打印每个文字的编码值。
"""
for itme in input("请输入一个内容："):number = ord(itme)print(number)

"""练习：循环录入编码值打印文字，直到输入空字符串停止。
"""
while True:str_number = input("请输入编码值：")if str_number == "":breakprint(chr(int(str_number)))

字面值

单引和双引号的区别

1. 单引号内的双引号不算结束符
2. 双引号内的单引号不算结束符

三引号作用

1. 换行会自动转换为换行符\n
2. 三引号内可以包含单引号和双引号
3. 作为文档字符串

转义字符

1. 改变字符的原始含义。
   \’ \” \””” \n \ \t \0 空字符
2. 原始字符串：取消转义。
   a = r”C:\newfile\test.py”

字符串格式化

1. 定义：
   生成一定格式的字符串。
2. 语法：
   字符串%(变量)
   “我的名字是%s,年龄是%s” % (name, age)
3. 类型码：
   %s 字符串 %d整数 %f 浮点数

"""字符串字面值
"""
#1. 各种写法
content01 = "字面值"
content02 = '字面值'
#可见即所得
content03 = '''字面值'''
content03 = """
字面
值"""
print(content03)#2. 引号冲突
content04 = '我是"孙悟空"。'
content05 = "我是'孙悟空'。"
content06 = """我是'孙'悟"空"。"""#3. 转义符:改变原始含义的特殊字符
#\"  \'   \\   \n换行  ...
content07 = "我是\"孙悟空\"。"
content08 = "我是\n孙悟空。"
url = "c:\\a\\b\c\d.txt"
#原始字符 r"字符串"
url = r"c:\a\b\c\d.txt"
print(content08)#4. 字符串格式化
subject = "I"
predicate = "kiss"
object = "you"
#print("主语是:" + subject + ",谓语是:" + predicate + ",宾语是:" + object + ".")
print("主语是:%s,谓语是:%s,宾语是:%s." % (subject, predicate, object))cure_rate = 99.5
#print("治愈比例为" + str(cure_rate) + "%")
print("治愈比例为%s%%" % (cure_rate))#%f 用于控制小数精度
money = 1.23245124
print("金额是:%.2f元" % money) # 金额是:1.23元#%d 用于控制整数位数
second = 6
print("秒：%.2d"%(second)) #秒：06

"""练习：根据下列文字，提取变量，使用字符串格式化打印信息湖北确诊67802人,治愈63326人,治愈率0.9970秒是01分零10秒
"""
region = "湖北"
confirmed = 67802
cure = 63326
cure_rate = 0.99
print("%s确诊%s人,治愈%s人,治愈率%.2f" % (region, confirmed, cure, cure_rate))second = 70
print("%s秒是%.2d分零%.2d秒" % (second, second // 60, second % 60))

列表 list

定义

由一系列变量组成的可变序列容器。

基础操作

1. 创建列表：

列表名 = []
列表名 = list(可迭代对象)

1. 添加元素：

列表名.append(元素)
列表.insert(索引，元素)

3. 定位元素：
列表名[索引] = 元素
变量 = 列表名[索引] # 赋值单个给变量不会创建新列表
变量 = 列表名[切片] # 赋值给变量的是切片所创建的新列表
列表名[切片] = 容器 # 右侧必须是可迭代对象，左侧切片没有创建新列表。遍历列表：

 正向：for 变量名 in 列表名:变量名就是元素反向：for 索引名 in range(len(列表名)-1,-1,-1):列表名[索引名]就是元素

1. 删除元素：
   列表名.remove(元素)
   del 列表名[索引或切片]
   

# 练习1：
#   创建地区列表、新增列表、现有列表，至少存储3行信息
list_region = ["香港", "上海", "新疆"]
list_new = [15, 6, 0]
list_now = [393, 61, 49]
# 练习2：
#    向以上三个列表追加数据第4行数据
list_region.append("四川")
list_new.append(0)
list_now.append(27)
#    在第1个位置插入第5行数据
list_region.insert(0,"台湾")
list_new.insert(0,0)
list_now.insert(0,19)print(list_region)
print(list_new)
print(list_now)
"""练习3：打印香港疫情信息(xx地区新增xx人现存xx人)将地区列表后2个元素修改为 ["XJ","SC"]打印地区列表元素(一行一个)倒序打印新增列表元素(一行一个)
"""
list_region = ["香港", "上海", "新疆"]
list_new = [15, 6, 0]
list_now = [393, 61, 49]print("%s地区新增%d人现存%s人" % (list_region[0], list_new[0], list_now[0]))
print(f"{list_region[0]}地区新增{list_new[0]}人现存{list_now[0]}人")list_region[-2:] = ["XJ", "SC"]
print(list_region)for region in list_region:print(region)for i in range(len(list_new) - 1, -1, -1):print(list_new[i])
"""练习4：在地区列表中删除“新疆”在新增列表中删除第1个元素在现有列表中删除前2个元素
"""
list_region = ["香港", "上海", "新疆"]
list_new = [15, 6, 0]
list_now = [393, 61, 49]list_region.remove("新疆")
del list_new[0]
del list_now[:2]print(list_region)
print(list_new)
print(list_now)

"""练习5：八大行星："水星" "金星" "地球" "火星" "木星" "土星" "天王星" "海王星"-- 创建列表存储4个行星：“水星” "金星" "火星" "木星"-- 插入"地球"、追加"土星" "天王星" "海王星"-- 打印距离太阳最近、最远的行星(第一个和最后一个元素)-- 打印太阳到地球之间的行星(前两个行星)-- 删除"海王星",删除第四个行星-- 倒序打印所有行星(一行一个)
"""
list_planet = ["水星", "金星", "火星", "木星"]
list_planet.insert(2, "地球")
# list_planet.append("土星")
# list_planet.append("天王星")
# list_planet.append("海王星")
# list_planet += ["土星", "天王星", "海王星"]
list_planet[len(list_planet):] = ["土星", "天王星", "海王星"]print(list_planet[0])
print(list_planet[-1])
print(list_planet[:2])list_planet.remove("海王星")
del list_planet[3]for i in range(len(list_planet) - 1, -1, -1):print(list_planet[i])

深拷贝和浅拷贝

浅拷贝：复制过程中,只复制一层变量,不会复制深层变量绑定的对象的复制过程。
深拷贝：复制整个依懒的变量。

#练习1：画出下列代码内存图
list01 = ["北京", "上海"]
list02 = list01
list01[0] = "广州"
list03 = list01[:]
list03[-1] = "深圳"
print(list01)#?`#练习2：画出下列内存图
list01 = ["北京", "上海", "深圳"]
list02 = list01
list01.insert(0,"天津")
del list01[1]
print(list02)# ?#练习3：画出下列内存图
import copy
list01 = ["北京",["上海","深圳"]]
list02 = list01
list03 = list01[:]
list04 = copy.deepcopy(list01)
list04[0] = "北京04"
list04[1][1] = "深圳04"
print(list01) # ?
list03[0] = "北京03"
list03[1][1] = "深圳03"
print(list01) # ?
list02[0] = "北京02"
list02[1][1] = "深圳02"
print(list02) # ?

列表与字符串转换

1. 列表转换为字符串：
   result = “连接符”.join(列表)

"""练习：在终端中,循环录入字符串,如果录入空则停止.停止录入后打印所有内容(一个字符串)
"""
result = []
while True:content = input("请输入内容：")if content == "":breakresult.append(content)
result = "_".join(result)
print(result)

1. 字符串转换为列表：
   列表 = “a-b-c-d”.split(“分隔符”)

"""练习：将下列英文语句按照单词进行翻转.转换前：To have a government that is of people by people for people转换后：people for people by people of is that government a have To
"""
message = "To have a government that is of people by people for people"
list_temp = message.split(" ")
message = " ".join(list_temp[::-1])
print(message)

列表推导式

定义

使用简易方法，将可迭代对象转换为列表。

语法

变量 = [表达式 for 变量 in 可迭代对象]
变量 = [表达式 for 变量 in 可迭代对象 if 条件]

说明

如果if真值表达式的布尔值为False,则可迭代对象生成的数据将被丢弃。

"""练习：生成10--30之间能被3或者5整除的数字[10, 12, 15, 18, 20, 21, 24, 25, 27]生成5 -- 20之间的数字平方[25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361]
"""
# result = []
# for item in range(10,31):
#     if item % 3 ==0 or item % 5 ==0:
#         result.append(item)result = [item for item in range(10,31)if item % 3 ==0 or item % 5 ==0]
print(result)result = [item ** 2 for item in range(5,21)]
print(result)

列表推导式嵌套

1. 语法：

变量 = [表达式 for 变量1 in 可迭代对象1 for 变量2 in可迭代对象2]

1. 传统写法：

result = []
for r in  ["a", "b", "c"]:for c in ["A", "B", "C"]:result.append(r + c)

1. 推导式写法：

result = [r + c for r in list01 for c in list02]

"""列表推导式嵌套
"""
list01 = ["香蕉", "苹果", "哈密瓜"]
list02 = ["牛奶", "咖啡", "雪碧", "可乐"]
# result = []
# for r in list01:
#     for c in list02:
#         result.append(r + c)
result = [r + c for r in list01 for c in list02]
print(result)

元组 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：
name = "张无忌"
names = ["赵敏", "周芷若"]
tuple01 = ("张翠山", name, names)
name = "无忌哥哥"
tuple01[2][0] = "敏儿"
print(tuple01)  # ?

"""练习2：根据月日,计算是这一年的第几天.公式：前几个月总天数 + 当月天数例如：5月10日计算：31  29  31  30 + 10
"""
month = int(input("请输入月份："))  # 5
day = int(input("请输入日："))  # 10day_of_month = (31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
# result = 0
# for i in range(month - 1):
#     result += day_of_month[i]
result = sum(  day_of_month[:month - 1]  )
result += day
print(result)

作用

1. 元组与列表都可以存储一系列变量，由于列表会预留内存空间，所以可以增加元素。
2. 元组会按需分配内存，所以如果变量数量固定，建议使用元组，因为占用空间更小。
3. 应用：
   变量交换的本质就是创建元组：x, y = （y, x ）
   格式化字符串的本质就是创建元祖：“姓名:%s, 年龄:%d” % (“tarena”, 15)

字典 dict

定义

1.   由一系列键值对组成的可变散列容器。
2.  散列：对键进行哈希运算，确定在内存中的存储位置，每条数据存储无先后顺序。
3.  键必须惟一且不可变(字符串/数字/元组)，值没有限制。

基础操作

1. 创建字典：
   字典名 = {键1：值1，键2：值2}
   字典名 = dict (可迭代对象)
2. 添加/修改元素：
   语法:

字典名[键] = 数据

说明:
键不存在，创建记录。
键存在，修改值。
3. 获取元素：
变量 = 字典名[键] # 没有键则错误
4. 遍历字典：
for 键名 in 字典名:
字典名[键名]
for 键名,值名 in 字典名.items():
语句
5. 删除元素：
del 字典名[键]

"""练习1：创建字典存储香港信息、字典存储上海信息、字典存储新疆信息
"""
dict_HongKong = {"region": "香港","new": 15,"now": 393,"total": 4801,"cure": 4320,"death": 88
}dict_shanghai = {"region": "上海","new": 6,"now": 61,"total": 903,"cure": 835,"death": 7
}dict_xingjiang = {"region": "新疆","new": 0,"now": 49,"total": 902,"cure": 850,"death": 3
}# 练习2：
# 在终端中打印香港的现有人数
print(dict_HongKong["now"])
# 在终端中打印上海的新增和现有人数
print(dict_shanghai["new"])
print(dict_shanghai["now"])
# 新疆新增人数增加1
dict_xingjiang["new"] += 1"""练习3：删除香港现有人数信息删除新疆新增人数信息删除上海的新增和现有信息
"""
del dict_HongKong["now"]
del dict_xingjiang["new"]
del dict_shanghai["new"], dict_shanghai["now"]"""练习4：在终端中打印香港字典的所有键(一行一个)在终端中打印上海字典的所有值(一行一个)在终端中打印新疆字典的所有键和值(一行一个)在上海字典中查找值是61对应的键名称
"""
for key in dict_HongKong:print(key)for value in dict_shanghai.values():print(value)for key, value in dict_xingjiang.items():print(key)print(value)for key, value in dict_shanghai.items():if value == 61:print(key)break

字典推导式

定义：

使用简易方法，将可迭代对象转换为字典。

语法:

{键:值 for 变量 in 可迭代对象}
{键:值 for 变量 in 可迭代对象 if 条件}

"""练习1：将两个列表，合并为一个字典姓名列表["张无忌","赵敏","周芷若"]房间列表[101,102,103]{101: '张无忌', 102: '赵敏', 103: '周芷若'}练习2：颠倒练习1字典键值{'张无忌': 101, '赵敏': 102, '周芷若': 103}
"""
list_name = ["张无忌", "赵敏", "周芷若"]
list_room = [101, 102, 103]
# result = {}
# for i in range(len(list_name)):
#     key = list_room[i]
#     value = list_name[i]
#     result[key] = value
result = {list_name[i]: list_room[i] for i in range(len(list_name))}
print(result)# new_result = {}
# for key, value in result.items():
#     new_result[value] = key
new_result = {value: key for key, value in result.items()}
print(new_result)

集合 set

定义

由一系列不重复的不可变类型变量(元组/数/字符串)组成的可变散列容器。
相当于只有键没有值的字典(键则是集合的数据)。

基础操作

1. 创建空集合：
   集合名 = set()
   集合名 = set(可迭代对象)

2. 创建具有默认值集合：
   集合名 = {1, 2, 3}
   集合名 = set(可迭代对象)

3. 添加元素：
   集合名.add(元素)

4. 删除元素：
   集合名.discard(元素)
   运算

5. 交集&：返回共同元素。
   s1 = {1, 2, 3}
   s2 = {2, 3, 4}
   s3 = s1 & s2 # {2, 3}

6. 并集：返回不重复元素
   s1 = {1, 2, 3}
   s2 = {2, 3, 4}
   s3 = s1 | s2 # {1, 2, 3, 4}

7. 补集-：返回只属于其中之一的元素
   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)

1. 子集<：判断一个集合的所有元素是否完全在另一个集合中

2. 超集>：判断一个集合是否具有另一个集合的所有元素
   s1 = {1, 2, 3}
   s2 = {2, 3}
   s2 < s1 # True
   s1 > s2 # True

3. 相同或不同== !=：判断集合中的所有元素是否和另一个集合相同
   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(dict_persons["技术"] ^ dict_persons["经理"])
# 并集
print(len(dict_persons["技术"] | dict_persons["经理"]))

集合推导式

1. 定义：
   使用简易方法，将可迭代对象转换为集合。
2. 语法:

{表达式 for 变量 in 可迭代对象}
{表达式 for 变量 in 可迭代对象 if 条件}

容器综合训练

"""
编辑代码，打印效果如下图：******######******######
"""
#4行 6列
for r in range(4):  # 0     1     2     3for c in range(6):if r % 2 == 0:print("*", end="")else:print("#", end="")print()

"""练习2：二维列表list01 = [[1, 2, 3, 4, 5],[6, 7, 8, 9, 10],[11, 12, 13, 14, 15],]1. 将第一行从左到右逐行打印2. 将第二行从右到左逐行打印3. 将第三列行从上到下逐个打印4. 将第四列行从下到上逐个打印5. 将二维列表以表格状打印先根据需求写死代码再根据规律写活代码
"""
list01 = [[1, 2, 3, 4, 5],[6, 7, 8, 9, 10],[11, 12, 13, 14, 15],
]for item in list01[0]:print(item)# print(list01[1][4])
# print(list01[1][3])
# print(list01[1][2])
# print(list01[1][1])
# print(list01[1][0])
for c in range(len(list01[1]) - 1, -1, -1):print(list01[1][c])# print(list01[0][2])
# print(list01[1][2])
# print(list01[2][2])
for r in range(len(list01)):print(list01[r][2])# print(list01[2][3])
# print(list01[1][3])
# print(list01[0][3])
for r in range(len(list01)-1,-1,-1):print(list01[r][3])# 可读可写
for r in range(len(list01)):for c in range(len(list01[r])):print(list01[r][c],end = "\t")print()# 只读
for line in list01:for item in line:print(item,end = "\t")print()

"""练习3：多个人的多个爱好dict_hobbies = {"于谦": ["抽烟", "喝酒", "烫头"],"郭德纲": ["说", "学", "逗", "唱"],}1.打印于谦的所有爱好(一行一个)2.计算郭德纲所有爱好数量3.打印所有人(一行一个)4.打印所有爱好(一行一个)
"""
dict_hobbies = {"于谦": ["抽烟", "喝酒", "烫头"],"郭德纲": ["说", "学", "逗", "唱"],
}print(dict_hobbies["于谦"])
print(len(dict_hobbies["郭德纲"]))for key in dict_hobbies:print(key)for value in dict_hobbies.values():for item in value:print(item)

 """练习5：对数字列表进行降序排列排列（大 --> 小）"""
list01 = [54, 56, 7, 78, 8]
for r in range(len(list01) - 1):for c in range(r + 1, len(list01)):if list01[r] < list01[c]:list01[r], list01[c] = list01[c], list01[r]
print(list01)

"""
1.打印所有商品信息,
格式：商品编号xx,商品名称xx,商品单价xx.2. 打印所有订单中的信息,
格式：商品编号xx,购买数量xx.3. 打印所有订单中的商品信息,格式：商品名称xx,商品单价:xx,数量xx.4. 查找数量最多的订单(使用自定义算法,不使用内置函数)
5. 根据购买数量对订单列表降序(大->小)排列
"""# 商品字典
dict_commodity_infos = {1001: {"name": "屠龙刀", "price": 10000},1002: {"name": "倚天剑", "price": 10000},1003: {"name": "金箍棒", "price": 52100},1004: {"name": "口罩", "price": 20},1005: {"name": "酒精", "price": 30},
}# 订单列表
list_orders = [{"cid": 1001, "count": 1},{"cid": 1002, "count": 3},{"cid": 1005, "count": 2},
]
# 1.打印所有商品信息,
# 格式：商品编号xx,商品名称xx,商品单价xx.
for key, value in dict_commodity_infos.items():print(f'商品编号{key},商品名称{value["name"]},商品单价{value["price"]}.')# 2. 打印所有订单中的信息,
# 格式：商品编号xx,购买数量xx.
for item in list_orders:print("商品编号%s,购买数量%s." % (item["cid"], item["count"]))# 3. 打印所有订单中的商品信息,
#    格式：商品名称xx,商品单价:xx,数量xx.
for item in list_orders:# item["cid"]  --> 1001cid = item["cid"]# dict_commodity_infos[1001] --> 商品信息commodity = dict_commodity_infos[cid]# commodity = dict_commodity_infos[item["cid"]]print(f"商品名称{commodity['name']},商品单价:{commodity['price']},数量{item['count']}.")# 4. 查找数量最多的订单(使用自定义算法,不使用内置函数)
max_value = list_orders[0]
for i in range(1, len(list_orders)):if max_value["count"] < list_orders[i]["count"]:max_value = list_orders[i]
print(max_value)# 5. 根据购买数量对订单列表降序(大->小)排列
for r in range(len(list_orders) - 1):for c in range(r + 1, len(list_orders)):if list_orders[r]["count"] < list_orders[c]["count"]:list_orders[r], list_orders[c] = list_orders[c], list_orders[r]
print(list_orders)

函数 function

pycharm快捷键

Ctrl + P 参数信息（在方法中调用参数）
Ctrl + Q 快速查看文档

定义

用于封装一个特定的功能，表示一个功能或者行为。
函数是可以重复执行的语句块, 可以重复调用。

作用

提高代码的可重用性和可维护性（代码层次结构更清晰）。

定义函数

1. 语法：

def 函数名(形式参数):函数体

1. 说明：
   def 关键字：全称是define，意为”定义”。
   函数名：对函数体中语句的描述，规则与变量名相同。
   形式参数：方法定义者要求调用者提供的信息。
   函数体：完成该功能的语句。
2. 函数的第一行语句建议使用文档字符串描述函数的功能与参数。
   调用函数
3. 语法：函数名(实际参数)
4. 说明：根据形参传递内容。

"""函数 - 入门价值：减少代码的重复语法：def 函数名(?):函数体函数名()
"""
# 代码的重复是万恶之源
"""
# 做法(变化) + 用法
print("直拳")
print("摆拳")
print("勾拳")
print("肘击")
# ...
# 做法(变化) + 用法
print("直拳")
print("摆拳")
print("勾拳")
print("肘击")
"""# 定义函数-做法(变化)
def attack():print("直拳")print("摆拳")print("勾拳")print("肘击")print("鞭腿")# 用法
attack()
# ...
# 用法
attack()

练习1： 定义函数,在终端中打印一维列表.
list01 = [5, 546, 6, 56, 76, ]
for item in list01:
print(item)

list02 = [7,6,879,9,909,]
for item in list02:
print(item)

练习2：创建函数,在终端中打印矩形.

number = int(input(“请输入整数:”)) # 5
for row in range(number):
if row == 0 or row == number - 1:
print("" * number)
else:
print("%s*" % (" " * (number - 2)))
返回值

1. 定义：
   方法定义者告诉调用者的结果。
2. 语法：
   return 数据
3. 说明：
   return后没有语句，相当于返回 None。
   函数体没有return，相当于返回None。

练习1：创建计算治愈比例的函数
confirmed = int(input(“请输入确诊人数:”))
cure = int(input(“请输入治愈人数:”))
cure_rate = cure / confirmed * 100
print(“治愈比例为” + str(cure_rate) + “%”)

练习2：定义函数,根据总两数,计算几斤零几两.:
提示：使用容器包装需要返回的多个数据
total_liang = int(input(“请输入两:”))
jin = total_liang // 16
liang = total_liang % 16
print(str(jin) + “斤零” + str(liang) + “两”)

练习3：创建函数,根据课程阶段计算课程名称.
number = input(“请输入课程阶段数：”)
if number == “1”:
print(“Python语言核心编程”)
elif number == “2”:
print(“Python高级软件技术”)
elif number == “3”:
print(“Web全栈”)
elif number == “4”:
print(“网络爬虫”)
elif number == “5”:
print(“数据分析、人工智能”)

练习4：创建函数,计算梯形面积.
top_base = float(input(“请输入上底：”))
bottom_base = float(input(“请输入下底：”))
height = float(input(“请输入高：”))
result = (top_base + bottom_base) * height / 2
print(“梯形面积是：” + str(result))

练习5：创建函数,计算IQ等级
ma = int(input(“请输入你的心里年龄：”))
ca = int(input(“请输入你的实际年龄：”))
iq = ma / ca * 100
if 140 <= iq:
print(“天才”)
elif 120 <= iq:
print(“超常”)
elif 110 <= iq:
print(“聪慧”)
elif 90 <= iq:
print(“正常”)
elif 80 <= iq:
print(“迟钝”)
else:
print(“低能”)
练习6：创建函数,根据年龄计算人生阶段
age = int(input(“请输入年龄：”))
if age <= 6:
print(“童年”)
elif age <= 17: # 程序能执行到本行,说明age一定大于6
print(“少年”)
elif age <= 40:
print(“青年”)
elif age <= 65:
print(“中年”)
else:
print(“老年”)
练习7：创建函数,根据年月日计算这是这一年的第几天.
如果2月是闰年,按29天计算
　　　 平年 28
month = int(input(“请输入月:”))
day = int(input(“请输入日:”))
days_of_month = (31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
total_days = sum(days_of_month[:month - 1])
total_days += day
print(f"{month}月{day}日是第{total_days}天.")

year = int(input(“请输入年份:”))
if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
day = 29
else:
day = 28

可变／不可变类型在传参时的区别

1. 不可变类型参数有:
   数值型(整数，浮点数)
   布尔值bool
   None 空值
   字符串str
   元组tuple
2. 可变类型参数有:
   列表 list
   字典 dict
   集合 set
3. 传参说明：
   不可变类型的数据传参时，函数内部不会改变原数据的值。
   可变类型的数据传参时，函数内部可以改变原数据。

练习1：画出下列代码内存图，并写出打印结果。
def func01(p1, p2):
p1 = “孙悟空”
p2[“八戒”] += 50
a = “悟空”
b = {“八戒”: 100}
func01(a, b)
print(a) # ?
print(b) # ?

练习2：画出下列代码内存图，并写出打印结果。
def func01(p1, p2):
p1 = [100, 200]
p2[:] = [300, 400]

a = [10, 20]
b = [30, 40]
func01(a, b)
print(a) # ?
print(b) # ?

练习3：根据下列代码，创建降序排列函数。

list01 = [5, 15, 25, 35, 1, 2]
for r in range(len(list01) - 1):
for c in range(r + 1, len(list01)):
if list01[r] < list01[c]:
list01[r], list01[c] = list01[c], list01[r]
print(list01)

练习4：定义函数，将列表中大于某个值的元素设置为None参数                           结果

[34, 545, 56, 7, 78, 8] -10-> [None,None,None,7,None,8]
[34, 545, 56, 7, 78, 8] -100-> [34, None, 56, 7, 78, 8]
函数参数
实参传递方式argument
位置传参
定义：实参与形参的位置依次对应。
序列传参
定义：实参用*将序列拆解后与形参的位置依次对应。
关键字传参
定义：实参根据形参的名字进行对应。
字典关键字传参

1. 定义：实参用**将字典拆解后与形参的名字进行对应。
2. 作用：配合形参的缺省参数，可以使调用者随意传参。
   形参定义方式parameter
   缺省形参
3. 语法：
   def 函数名(形参名1=默认实参1, 形参名2=默认实参2, …):
   函数体
4. 说明：
   缺省参数必须自右至左依次存在，如果一个参数有缺省参数，则其右侧的所有参数都必须有缺省参数。
   缺省参数可以有0个或多个，甚至全部都有缺省参数。
   练习：
   定义函数,根据小时、分钟、秒,计算总秒数
   调用：提供小时、分钟、秒
   调用：提供分钟、秒
   调用：提供小时、秒
   调用：提供分钟
   位置形参
   语法：
   def 函数名(形参名1, 形参名2, …):
   函数体
   命名关键字形参
5. 语法：
   def 函数名(args, 命名关键字形参1, 命名关键字形参2, …):
   函数体
   def 函数名(, 命名关键字形参1, 命名关键字形参2, …):
   函数体
6. 作用：
   强制实参使用关键字传参
   不定长形参
   星号元组形参
7. 语法：
   def 函数名(*元组形参名):
   函数体
8. 作用：
   可以将多个位置实参合并为一个元组
9. 说明：
   一般命名为’args’
   形参列表中最多只能有一个
   练习：定义数值累乘的函数
   双星号字典形参
10. 语法：
    def 函数名(**字典形参名):
    函数体
11. 作用：
    可以将多个关键字实参合并为一个字典
12. 说明:
    一般命名为’kwargs’
    形参列表中最多只能有一个
    参数自左至右的顺序
    位置形参 --> 星号元组形参 --> 命名关键字形参 --> 双星号字典形参

练习：说出程序执行结果.
def func01(list_target):
print(list_target)# ?
def func02(*args):# 三合一
print(args)# ?
def func03(args,**kwargs):# 三合一
print(args)# ?
print(kwargs)# ?
def func04(p1,p2,,p4,**kwargs):
print(p1)# 10
print(p2)# 20
print(p4)# 30
print(kwargs)# {p5 : 40}

func01([1,2,3])
func02(*[1,2,3])# 一拆三
func03(1,2,3,a=4,b=5,c=6)
func04(10,20,p4 = 30,p5 = 40)
作用域LEGB

1. 作用域：变量起作用的范围。

2. Local局部作用域：函数内部。

3. Enclosing 外部嵌套作用域 ：函数嵌套。

4. Global全局作用域：模块(.py文件)内部。

5. Builtin内置模块作用域：builtins.py文件。
   变量名的查找规则

6. 由内到外：L -> E -> G -> B

7. 在访问变量时，先查找本地变量，然后是包裹此函数外部的函数内部的变量，之后是全局变量，最后是内置变量。
   局部变量

8. 定义在函数内部的变量(形参也是局部变量)

9. 只能在函数内部使用

10. 调用函数时才被创建，函数结束后自动销毁
    全局变量

11. 定义在函数外部,模块内部的变量。

12. 在整个模块(py文件)范围内访问（但函数内不能将其直接赋值）。
    global 语句

13. 作用：
    在函数内部修改全局变量。
    在函数内部定义全局变量(全局声明)。

14. 语法：
    global 变量1, 变量2, …

15. 说明
    在函数内直接为全局变量赋值，视为创建新的局部变量。
    不能先声明局部的变量，再用global声明为全局变量。
    nonlocal 语句

16. 作用：
    在内层函数修改外层嵌套函数内的变量

17. 语法
    nonlocal 变量名1,变量名2, …

18. 说明
    在被嵌套的内函数中进行使用

    练习：根据下列代码，创建函数。

商品字典

dict_commodity_infos = {
1001: {“name”: “屠龙刀”, “price”: 10000},
1002: {“name”: “倚天剑”, “price”: 10000},
1003: {“name”: “金箍棒”, “price”: 52100},
1004: {“name”: “口罩”, “price”: 20},
1005: {“name”: “酒精”, “price”: 30},
}

订单列表

list_orders = [
{“cid”: 1001, “count”: 1},
{“cid”: 1002, “count”: 3},
{“cid”: 1005, “count”: 2},
]

1.定义函数，打印所有商品信息,

for cid, info in dict_commodity_infos.items():
# print(f"商品编号{cid},商品名称{info[‘name’]},商品单价{info[‘price’]}.")
print(“商品编号%d,商品名称%s,商品单价%d.” % (cid, info[“name”], info[“price”]))

2. 定义函数，打印单价大于10000的商品信息,

for order in list_orders:
if info[“price”]>10000:
# print(f"商品编号{cid},商品名称{info[‘name’]},商品单价{info[‘price’]}.")
print(“商品编号%d,商品名称%s,商品单价%d.” % (cid, info[“name”], info[“price”]))

3. 定义函数，查找数量最多的订单(使用自定义算法,不使用内置函数)

max_value = list_orders[0]
for i in range(1, len(list_orders)):
if max_value[“count”] < list_orders[i][“count”]:
max_value = list_orders[i]
print(max_value)

4. 定义函数，根据购买数量对订单列表降序(大->小)排列

for r in range(len(list_orders) - 1):
for c in range(r + 1, len(list_orders)):
if list_orders[r][“count”] < list_orders[c][“count”]:
list_orders[r], list_orders[c] = list_orders[c], list_orders[r]
print(list_orders)

On my way，Python相关推荐

1. 面试前赶紧看了5道Python Web面试题，Python面试题No17

   目录 本面试题题库,由公号:非本科程序员 整理发布 第1题: Flask中的请求上下文和应用上下文是什么? 第2题:django中间件的使用? 第3题: django开发中数据做过什么优化? 第4题: ...

2. python任意输入一个正整数、判断该数是否为素数_Python编程判断一个正整数是否为素数的方法，python素数...

   Python编程判断一个正整数是否为素数的方法,python素数 本文实例讲述了Python编程判断一个正整数是否为素数的方法.分享给大家供大家参考,具体如下: import string impor ...

3. angular 字符串转换成数字_蓝盟IT外包，Python算法的一般技术和嵌入式库|python|字符串|key|算法|调用...

   近年来,随着python着火,python也开始受到很多程序员的喜爱. 很多程序员已经开始使用python作为第一语言. 最近在python上刷问题时,我想去找python的刷问题常用库api和刷问题 ...

4. 零基础学习Python需要注意的几个点，Python培训机构排名

   俗话说的好万事开头难,不管你做任何事情,开头的确很较难的,学Python编程也是如此,因此刚开始学Python编程的同学们,就要多借鉴过来人的经验,少走弯路,本文小编就为大家分享几个Python编程小 ...

5. 第三百三十八节，Python分布式爬虫打造搜索引擎Scrapy精讲—深度优先与广度优先原理...

   第三百三十八节,Python分布式爬虫打造搜索引擎Scrapy精讲-深度优先与广度优先原理 网站树形结构 深度优先 是从左到右深度进行爬取的,以深度为准则从左到右的执行(递归方式实现)Scrapy默认 ...

6. 再见，Python！你好，Go语言

   链客,专为开发者而生,有问必答! 此文章来自区块链技术社区,未经允许拒绝转载. AI 前线导读:Go 语言诞生于谷歌,由计算机领域的三位宗师级大牛 Rob Pike.Ken Thompson 和 Ro ...

7. 搞机器学习，Python和R哪个更合适？

   [编者按]如果你正想构建一个机器学习项目,但却纠结于如何选择编程语言,这篇文章将是你所需要的.这篇文章不仅帮助你理解Python和R这两种语言的区别,还有助于你了解各个语言多方面的优势. 作者 | M ...

8. 真没想到，Python还能实现5毛特效

   来源 | ZackSock(ID:ZackSock) 图源 | 视觉中国 Python牛已经不是一天两天的事了,但是我开始也没想到,Python能这么牛.前段时间接触了一个批量抠图的模型库,而后在一些 ...

9. 黑科技抗疫，Python开发者大集结！

   2020年初,突如其来的新型冠状病毒肺炎打乱了所有人的节奏,但社会各界迅速团结起来,为抗击疫情贡献出自己的力量.除了捐款捐物外,很多科技公司运用5G.大数据.AI.云计算等新互联网技术,以科技的手段助 ...

10. TIOBE 1月编程语言排行榜：C语言再度「C 位」出道，Python惜败

    整理 | 屠敏 来源 | CSDN(ID:CSDNnews) [导读]在 2020 年初雪来临之际,TIOBE 官方在最新发布的 1 月编程语言榜单中为我们最终揭开了「 2019 年度编程语言」的神秘 ...

最新文章

1. [解决]CXF wsdl2java 生成代码存在的一些问题
2. matlab练习程序（简单图像融合）
3. 光流 | 使用Horn-Schunck方法进行光流估计（附代码）
4. 动态规划训练13 [Catch That Cow poj3278]
5. 2020-08-14 光纤通信第三章知识点整理
6. 怎样让计算机恢复到桌面上,如何把电脑桌面恢复成原样.怎么办？
7. linux切换sid,linux – 将sid字段添加到ps -f输出
8. Ubuntu网络配置相关相关
9. Unity网络：在局域网P2P网络中利用UDP广播实现保活/心跳
10. 华为Mate30 Pro高清渲染图曝光：后置四摄+挖孔全面屏
11. 在自己的电脑上搭建服务器（可供对外访问）
12. 区块链 用户身份权限模式 方案
13. 多屏系统上播放幻灯片的设想
14. 2021年4月中国旅游行业网络关注度分析报告
15. linux窗口死,Linux系统入门学习：Linux 上 Wireshark 界面僵死解决
16. 空气炸锅如何挑选研究
17. linux复制文件跳过相同,Linux中拷贝目录跳过指定文件的方法
18. 微软75亿美元收购ZeniMax及其旗下工作室；KPS同意21亿美元收购Garrett全部资产 | 美通企业日报...
19. wamp环境变量配置php,WAMP环境配置-PHP安装
20. 天作之合：水果与朗姆酒

热门文章

1. 纷杂的Spring-boot-starter: 1 应用 日志 和 spring- boot- starter- logging
2. Linux 设备树的解释 - DTB文件格式【转】
3. Jzoj3467 最长上升子序列
4. 【hdu1556】Color the ball——树状数组
5. HDU 5145 NPY and girls （莫队分块离线)
6. Visual Studio配置（4）：项目属性页-VC++目录
7. Ngnix 安装、信号量、虚拟主机配置
8. Java——全局变量与局部变量的区别
9. express 手册
10. [转载] 七龙珠第一部——第114话 悟空的愿望 卡林大人好为难