2022.4.4-4.5学习总结

1.判断和循环基础（剩余部分）

#用多个if实现
score2 = int(input('分数'))
if score2 >= 90:print('优秀')
if score2 >=80 and score2 < 90 :print('良好')
if score2 >=70 and score2 < 80 :print('中等')
if score2 >=60 and score2 < 70 :print('差')
if score2 <60: print('不及格')

#if嵌套
# 1. 提示用户输入密码
pwd = '123456'
money = 1000
password = input('请输入密码:')
if password == pwd:
 print('密码正确,登录成功')
 get_money = int(input('请输入要取款的金额:'))
 if money >= get_money:print('取款成功')
 else:print('余额不足')
else:print('密码有误,请再次尝试')
 '''

'''
案例随机出拳
案例中需要电脑随机出拳,即随机出 1 2 3
在 Python 中想要随机获得整数数字可以使用如下方法
1. 导入随机数工具包
import random
2. 使用工具包中的工具产生指定范围内的数字
random.randint(a, b) # 产生[a, b] 之间的随机整数,包含 a b 的

import random # 这行代码习惯性的放在第一行
num = random.randint(1, 3)
print(num)
'''
'''
import random # 1. 自己出拳(石头(1)/剪刀(2)/布(3)) input (player)
player = int(input('请出拳石头(1)/剪刀(2)/布(3):')) # 不要忘了类型转换
computer = random.randint(1, 3)# 2. 电脑随机出拳 (使用随机数模块(工具)完成) (computer)
if (player == 1 and computer == 2) or (player == 2 and computer == 3) or (player == 3# 3. 判断输赢# 3.1 玩家胜利
and computer == 1):
 print('恭喜你获得胜利')# 3.2 平局 player == computer
elif player == computer:
 print('平局')# 3.3 玩家输了 else
else:
 print('输了, 不要放弃, 再来一局')
'''
'''
循环
 1. 设置循环的初始条件 (记录说了几遍 我错了)
i = 0
while i < 5:
print('XXX')
i = i + 1

死循环: 一般是由写代码的人不小心造成的 bug, 代码一直不停的运行下去
无限循环: 写代码的人故意让代码无限制的去执行,代码一直不停的运行下去
无限循环的使用场景: 在书写循环的时候,不确定循环要执行多少次
无限循环的使用一般会在循环中添加一个 if 判断, 当 if 条件成立,使用关键字 break 来终止循环

while True:
重复执行的代码
if 判断条件:
break 关键字的作用就是终止循环, 当代码执行遇到 break,这个循环就不再执行了
重复执行的代码 #

'''
#使用循环求 1-100 之间数字的和
'''
num = 0
i = 1
while i <= 100:
 num += i # 因为每一次 i 的值会变化
 i += 1
print('求和的结果是:', num)
'''
#使用循环求 1-100 之间偶数的和
num = 0
i = 1
while i <= 100:
 if i % 2 == 0:
  num += i
  i += 1
 else:i += 1
print('求和的结果是:', num)

2.循环字符串、列表（理解为主）

'''
循环
for 循环
基本的 for 循环语法:
for循环也可以让指定的代码重复执⾏ (循环)
for循环可以遍历容器中的数据(
 遍历: 从容器中把数据⼀个⼀个取出
 容器: 可以简单理解为盒⼦, 盒⼦中可以存放很多的数据
(字符串 str, 列表 list, 元组 tuple, 字典 dict)
)
for 循环 也可以称为 for 遍历

基本的 for 循环语法:
for 变量名 in 容器:
 重复执⾏的代码
'''
'''
my_str = 'hetunbaobao'  #容器李有多少数据，i就会遍历多少次，for 循环 也可以称为 for 遍历
for i in my_str:   #容器李有多少数据，i就会遍历多少次，i就会变成容器里的数据
    print(i)
'''

'''
for 做指定次数的循环
for 变量 in range(n):
 重复执⾏的代码
 1.range() 是 Python 中的函数, 作⽤使⽤可以⽣成
[0, n) 之间的整数, 不包含 n 的 , ⼀个有 n 个数字, 所
以这个循环循环 n 次
 2, 想让 for 循环循环多少次,n 就写⼏
 3, 变量的值 也是每次循环从 [0, n) 取出⼀个值, 第⼀
次取得是 0 ,最后⼀次取得是 n-1

range() 变形
# 需求: 使⽤ for 循环获取 5 到 10 之间的数字
for 变量 in range(a, b):
 重复的代码
 
# range(a, b) 作⽤是⽣成 [a, b) 之间的整数数字, 不
包含 b
'''
'''
for i in range(5): # [0 1 2 3 4 ]
 print(i)
print('-' * 30)
'''
# 需求: 使⽤ for 循环获取 5 到 10(包含) 之间的数字
'''
for m in range(5, 11):
 print(m)

'''
'''
break 和 continue
break 和 continue 是 Python 中的两个关键字, 只能在循环
中使⽤
break: 终⽌循环, 即代码执⾏遇到 break, 循环不再执⾏,⽴
即结束
continue: 跳过本次循环. 即代码执⾏遇到 continue,本次循
环剩下的代码不再执⾏, 继续下⼀次循环
'''
'''
# 案例，输入字符串，如果这个字符不是 e, 打印出来
#方法一
result = input('请输⼊⼀个字符串:')
for i in result:
  if i == 'e':  
   continue  
  print(i)
#方法二
for i in result:
 if i!= 'e':
  print(i)
'''

'''
容器: 也可以称为是数据序列, 或者⾼级数据类型, 也是
Python 中的数据类型
容器中可以存放多个数据.
Python 中的数据类型
容器中可以存放多个数据.

字符串是容器, 因为字符串中可以包含多个字符，定义: 使⽤引号(单引号, 双引号, 三引号)引起来的内容就是字
符串
'''
'''''
# 1. 使⽤单引号定义
my_str1 = 'hello'
print(my_str1, type(my_str1))
# 2, 使⽤双引号定义
my_str2 = "hello"
print(my_str2, type(my_str2))
# 3. 使⽤三引号定义
my_str3 = """hello"""
print(my_str3, type(my_str3))

# 4. 字符串本身包含引号 I'm ⼩明
# 4.1 字符串本身包含单引号, 则在定义的时候不能使⽤单引号
# 4.2 字符串本身包含双引号, 则在定义的时候不能使⽤双引号
my_str5 = "I'm ⼩明"
# 5. 字符串本身包含单引号,在定义的时候,我就是想使⽤单引号
# 5.1 使⽤ \ 转义字符,将字符串本身的引号进⾏转义 \' -->
my_str6 = 'I\'m ⼩明'
print(my_str6)
# 5.2 字符串 I\'m ⼩明 \\ --> \
my_str7 = 'I\\\'m ⼩明'
print(my_str7)
# 5.3 字字符串前边加上 r"" 原⽣字符串, 字符串中 的\不会作为转义字符, ⽂件操作会⽤⼀下
my_str8 = r'I\'m ⼩明'
print(my_str8)
my_str9 = r'I\\\'m ⼩明'
print(my_str9)
'''
'''
下标
下标(索引): 就是指字符在字符串中的位置编号, 这个编号就是
下标
这个编号⼀般来说都是从左到右进⾏编号的, 从 0 开始的
(Python 中⽀持负数下标,从右到左进⾏编号的, 从-1 开始)
下标作⽤: 可以使⽤下标获取字符串中某个位置的字符
语法:
字符串[下标] # 获取指定位置的字符
'''
'''
str1 = 'abcdefg'
# 1. 打印字符串中最开始位置的字符
print(str1[0]) # a

# 2. 打印最后⼀个位置的数据
print(str1[-1]) # g
# 3. 打印倒数第⼆个位置的字符
print(str1[-2]) # f
# 打印下标为 2 的数据
print(str1[2]) # c
# 获取字符串中字符的个数(获取字符串的⻓度)
# len(字符串) # length(⻓度)
num = len(str1)
print(num)
# ⻓度-1 的下标位置是最后⼀个字符
print(str1[num-1]) # g 最后⼀个字符,倒数第⼀个
print(str1[len(str1)-1]) # g 最后⼀个字符,倒数第⼀个
'''
'''
切⽚: 可以获取字符串中多个字符(多个字符的下标是有规律的,
等差数列)
语法:
字符串[start:end:step]
start 是开始位置的下标, end 是结束位置的下标(注意,不能取
到这个位置的字符) step 步长,等差数列的差值, 所取的相邻字
符下标之间的差值,默认是 1, 可以不写
例: [1:5:1] # 1 2 3 4
[1:5:2] # 1 3
[1:5:3] # 1 4
[1:5:4] # 1

切⽚会得到⼀个字符串, 即可以获取字符串中的多个字符
'''
'''
str1 = 'abcdefg'
# 1. 获取 abc 字符
print(str1[0:3:1]) # abc
# 1.1 如果步长是 1 可以不写, 最后⼀个冒号也不写
print(str1[0:3]) # abc
# 1.2 如果开始位置为 0 ,可以不写, 但是冒号必须有
print(str1[:3]) # abc
# 2. 获取 efg 字符
print(str1[4:7]) # efg
print(str1[-3:7]) # efg
# 2.1 如果最后⼀个字符也要取, 可以不写, 但是冒号必须有
print(str1[4:]) # efg
# 2.2 如果开始和结束都不写, 获取全部内容, 但是冒号必须有
print(str1[:]) # abcdefg
# 3. 获取 aceg # 0 2 4 6, 所以步⻓为 2
print(str1[0:7:2]) # aceg
print(str1[::2]) # aceg
# 4. 特殊应用, 步长为负数, 开始和结束不写,意思全变, ⼀般不用管,只有⼀种使用场景
# 反转(逆置) 字符串 字符串[::-1]
print(str1[::-1]) # gfedcba
'''
'''
字符串的查找⽅法 find
字符串.find(sub_str, start, end) 
 作⽤: 在字符串中查找是否存在 sub_str 这样的字符串
 sub_str: 要查找的⼩的字符串
 start: 开始位置, 从哪个下标位置开始查找, ⼀般不写,默
认是 0
 end: 结束位置, 查找到哪个下标结束, ⼀般不写,默认是
len()
 返回(代码执⾏之后会得到什么, 如果有返回,就可以使⽤变
量保存):
 1. 如果在字符串中找到了 sub_str , 返回 sub_str
第⼀次出现的正数下标(sub_str 中第⼀个字符在⼤字符串中的
下标)
 2. 如果没有找到,返回 -1
'''
'''
str1 = "and itcast and itheima and Python"  # 在字符串中查找 and
num = str1.find('and')
print(num) # 0  # 在字符串中查找 第⼆个 and 出现的下标, 从第⼀次出现的后⼀位开始找
num1 = str1.find('and', num+1)
print(num1) # 11
# 在字符串中查找 第三个 and 出现的下标, 从第⼆次出现的后⼀位开始找
num2 = str1.find('and', num1+1)
print(num2) # 23
# 在字符串中查找 第四个 and 出现的下标, 从第三次出现的后⼀位开始找
num3 = str1.find('and', num2+1)
print(num3) # -1

'''
'''
字符串.replace(old_str, new_str, count) # 将字符串中old_str 替换为 new_str
- old_str: 被替换的内容
- new_str: 替换为的内容
- count: 替换的次数, ⼀般不写,默认是全部替换
- 返回: 替换之后的完整的字符串, 注意: 原来的字符串没有发⽣改变
'''
'''

str1 = 'good good study'
# 1, 将 str1 中 所有的 g 改为 G
str2 = str1.replace('g', 'G')
print('str1:', str1) # str1: good good study
print('str2:', str2) # str2: Good Good study
# 2. 将 str1 中第⼀个 good 改为 GOOD
str3 = str1.replace('good', 'GOOD', 1)
print('str3:', str3) # str3: GOOD good study
# 3. 将 str1 中第⼆个 good 改为 GOOD
# 3.1 先将全部的 good --> GOOD
str4 = str1.replace('good', "GOOD")
# 3.2 再将第⼀个 GOOD --> good
str4 = str4.replace('GOOD', 'good', 1)
print('str4:', str4) # str4: good GOOD study
'''
'''
字符串.split(sep, maxsplit) # 将字符串按照 sep 进⾏分割(拆分)
- sep, 字符串按照什么进⾏拆分, 默认是空⽩字符(空格, 换
⾏\n, tab键\t)
- max_split, 分割次数,⼀般不写, 全部分割
- 返回: 将⼀个字符串拆分为多个,存到列表中
- 注意: 如果 sep 不写, 想要指定分割次数 则需要按照如下⽅
式使⽤
字符串.split(maxsplit=n) # n 是次数
'''
'''
str1 = "hello world and itcast and itheima and Python"
# 1. 将 str1 按照 and 字符进⾏拆分
result1 = str1.split('and')
print(result1) # ['hello world ', ' itcast ', 'itheima ', ' Python']
# 2, 将 str1 按照 and 字符进⾏拆分, 拆分⼀次
result2 = str1.split('and', 1)
print(result2) # ['hello world ', ' itcast anditheima and Python']
# 3. 按照空⽩字符进⾏切割
result3 = str1.split()
print(result3) # ['hello', 'world', 'and','itcast', 'and', 'itheima', 'and', 'Python']
# 4. 按照空⽩字符进⾏切割, 拆分⼀次
result4 = str1.split(maxsplit=1)
print(result4)
'''
'''
字符串.join(列表) # 括号中的内容主要是列表,可以是其他
容器
# 作⽤: 将字符串插⼊到列表中每相邻的两个数据之间, 组成⼀
个新的字符串
- 列表中的数据使⽤使⽤ 逗号隔开的
- 注意点: 列表中的数据必须都是字符串, 否则会报错
'''
'''
list1 = ['good', 'good', 'study']
# 1. 将 列表中的字符串使⽤空格连起来
str1 = ' '.join(list1)
print(str1) # good good study
# 2. 将 列表中的字符串使⽤ and 连起来
str2 = ' and '.join(list1)
print(str2) # good and good and study

'''
'''
列表
列表 list, 是使⽤最多的⼀种容器(数据类型)
列表中可以存储多个数据, 每个数据之间使⽤逗号隔开
列表中可以存放任意类型的数据
'''
'''
# 1. 类实例化的⽅式(不常⽤)
# 1.1 定义空列表(没有任何数据的列表)
# 变量 = list()
list1 = list()
print(type(list1), list1) # <class 'list'> []
# 1.2 类型转换 list(容器) 将其他的容器转换为列表
# 转换字符串会将字符串中的每个字符作为⼀个数据存⼊到列表中
list2 = list('hello')
print(type(list2), list2) # <class 'list'> ['h','e', 'l', 'l', 'o']
# 2, 直接使⽤ [] 进⾏定义(常⽤)
# 2.1 定义空列表
my_list = []
print(my_list) # []
# 2.2 定义⾮空列表
my_list1 = [1, '⼩明', 3.14, False]
print(my_list1) # [1, '⼩明', 3.14, False]
'''

'''
列表⽀持下标和切⽚操作, 使⽤⽅法和字符串中的使⽤⽅法⼀致
区别: 列表的切⽚得到的是列表
'''
'''
list1 = ['⼩明', 18, 1.71, True]
# 获取第⼀个数据,名字
print(list1[0])
# 获取最后⼀个数据
print(list1[-1])
# 第⼀第⼆个数据
print(list1[0:2]) # ['⼩明', 18]
# 列表⻚⽀持 len() 求⻓度的, 求数据元素个数
print(len(list1)) # 4
'''
'''
查找 - 查找列表中数据下标的⽅法
在列表中没有 find ⽅法, 想要查找数据的下标,使⽤的
index() ⽅法
列表.index(数据, start, end) 使⽤和 find ⽅法⼀样, 同
时在字符串中也有 index ⽅法
区别: 返回, index() ⽅法,找到返回第⼀次出现的下标, 没有
找到代码直接报错，没有-1

查找 - 判断是否存在
判断容器中某个数据是否存在可以使⽤ in 关键字
数据 in 容器 # 如果存在返回 True ,如果不存在,返回
False

查找 - 统计出现的次数
统计出现的次数,使⽤的是 count() ⽅法
列表.count(数据) # 返回 数据出现的次数
'''
'''
my_list = [1, 3, 5, 7, 2, 3]
# 找 数据 3 出现的下标
num = my_list.index(3)
print(num) # 1
# 找 数据 4 出现的下标
# num1 = my_list.index(4) # 代码会报错
if 4 in my_list:
 num1 = my_list.index(4)
 print(num1)
else:
 print('不存在数据 4')
# my_list.count(4) 统计 数据 4 出现的次数
if my_list.count(4) > 0:
 num1 = my_list.index(4)
 print(num1)
else:
 print('不存在数据 4')
'''

'''
添加数据的⽅法
尾部添加(最常⽤)
列表.append(数据) # 将数据添加到列表的尾部
返回: 返回的 None(关键字,空), ⼀般就不再使⽤ 变量 来
保存返回的内容
想要查看添加后的列表,需要打印的是列表

指定下标位置添加
列表.insert(下标, 数据) # 在指定的下标位置添加数据,
如果指定的下标位置本来有数据, 原数据会后移
返回: 返回的 None(关键字,空), ⼀般就不再使⽤ 变量 来
保存返回的内容
想要查看添加后的列表,需要打印的是列表

列表合并
列表1.extend(列表2) # 将列表 2 中的所有数据逐个添加
的列表1 的尾部
返回: 返回的 None(关键字,空), ⼀般就不再使⽤ 变量 来
保存返回的内容
想要查看添加后的列表,需要打印的是列表
'''
'''
my_list = []
print(my_list) # []
# 1. 想列表中添加数据 郭德纲
my_list.append('郭德纲')
print(my_list) # ['郭德纲']
# 2. 向列表的尾部添加 郭麒麟
my_list.append('郭麒麟')
print(my_list) # ['郭德纲', '郭麒麟']
# 3. 在下标位置为 1 的位置添加数据 '岳岳
my_list.insert(1, '岳岳')
print(my_list) # ['郭德纲', '岳岳', '郭麒麟']
# 4. 在下标位置为 1 的位置添加数据 于谦
my_list.insert(1, '于谦')
print(my_list) # ['郭德纲', '于谦', '岳岳', '郭麒麟']
# 5. 定义新的列表 list1
list1 = ['孙越', '烧饼']
# 将 list1 中数据逐个添加到 my_list 中
my_list.extend(list1)
print(my_list) # ['郭德纲', '于谦', '岳岳', '郭麒麟','孙越', '烧饼']
# 将 list1 作为⼀个整体添加到 my_list
my_list.append(list1)
print(my_list) # ['郭德纲', '于谦', '岳岳', '郭麒麟','孙越', '烧饼', ['孙越', '烧饼']]
'''

3.明日计划，容器（列表剩余内容，元祖，字典），函数

4.下周计划，python基础课程全部过完，容器，函数，面向对象，文件，异常，模块，unittest框架