python基础复习

‘’’
1.猜拳游戏
玩家： 手动输入
电脑：1.固定 2.随机
2.判断输赢
1.玩家获胜
2.平局
3.电脑获胜
3.知识点：import random --导入随机数模块
random.randint（开始，结束） --创建随机数
‘’’
#导出随机数模块
import random

#1.出拳
#玩家
player = int(input(‘请出拳：0–剪刀，1–石头，2–布：’))
#电脑随机数：
computer = random.randint(0,2)
print(f’电脑出的：{computer}')
#判断输赢
#1.玩家赢
if (player == 0 and computer == 2) or (player == 1 and computer == 0) or (player == 2 and computer == 1):
print(‘玩家获胜，嘿嘿嘿’)
#2.平局
elif (player == computer ):
print(‘平局’)
else :
print(‘电脑获胜，呜呜’)

‘’’
三目运算符，又叫三元运算符：
用来简化代码，if 后的条件，如果成立,则执行if 左边的代码，
如果不成立，则执行右边else后的代码
‘’’
aa = 1
bb = 2

cc = bb - aa if aa < bb else aa - bb
print(cc)

‘’’
while 循环格式

while 条件 ：
‘’’

例如

a = 0
while a <5 :
print(‘媳妇儿，我错了’)

print(‘任务结束’)

#1-100偶数求和

i = 1
result = 0
while i <=100:
if i%2 == 0:
result += i
i += 2
else:
i += 1
print(result)

‘’’
break 和 continue

break是退出整个循环，continue是退出前一个循环,注意，使用continue时一定要在它之前修改计数器
‘’’
#吃苹果例子
i = 1
while i <= 5:
if i == 3:
print(f’吃饱了不吃了’)
i += 1
continue
print(f’吃了第{i}个苹果’)
i += 1

‘’’
while 循环嵌套
实例：每次说三遍“媳妇儿我错了”，然后去刷碗，一套惩罚执行三天
‘’’
j = 0 # j 控制惩罚天数
while j < 3:
i = 0 # i 控制惩罚次数
while i < 3:
print(‘媳妇儿，我错了’)
i += 1
print(‘去把碗刷了’)
print(f’第{j+1}天惩罚结束’)
j += 1

‘’’
while 循环嵌套应用–打印星号
注意：print打印后默认换行，这时要用到 end结束符 这样print(“*”, end = “”)后
将不会换行
‘’’
#打印正方形星号

i = 0 #控制行
while i < 5:
j = 0 # 控制每行星号的个数
while j <5:
print(“*”,end = “”) # print函数会默认换行，需要使用end结束符取消换行
j += 1
print() # 第一行星号个数达到目标后用print换行一次
i += 1

‘’’
打印三角形星号
分析：三角形输出时，每行的星号个数和行号相同
‘’’
i = 1
while i <= 5:
j = 0
while j < i:
print(“*”, end=" ")
j += 1
print()
i += 1

‘’’
while循环嵌套–打印九九乘法表
‘’’
i = 1
while i <=9:
j = 1
while j <= i:
print(f"{j}{i}={ij}",end = " ")
j += 1
print()
i += 1

‘’’
for循环语法
for 临时变量 in 序列 ：
重复执行的代码1
重复执行的代码2
…

break退出循环的方式是满足条件后直接退出，后续全部都不再进行
continue退出循环的方式是退出满足条件的这次的循环，后续循环接着进行

‘’’
#例如 break退出循环
str1 = “abandon”
for i in str1 :
if i == ‘d’:
break
print(i)
#continue退出循环
str1 = “abandon”
for i in str1 :
if i == ‘d’:
continue
print(i)

‘’’
while else 语法：
while 语句正常结束后运行else后的代码

while 条件：
条件成立重复执行的代码
else：
循环正常结束后执行的代码

‘’’
#例如，我说了三次：“媳妇儿我错了”后得到“原谅你了”
i = 1
while i <=3:
print(‘媳妇儿，我错了’)
i +=1
else:
print(‘原谅你了’)

‘’’
for else 语法：
for 临时变量 in 序列:
满足条件执行的代码
else：
for循环正常结束后执行的else的代码

‘’’
#例如
str1 = “abandon”
for i in str1:
print(i)
else:
print(“程序正常结束”)

‘’’
for else 之 break和continue
break是终止循环，则循环没有正常结束，else后代码不执行
continue只结束符合条件的该次循环，下次循环接着进行，则循环正常结束，else后代码可执行。
‘’’
#break
str1 = “abandon”
for i in str1:
if i == “d”:
break
print(i)
else:
print(“程序正常结束”)

#continue
str1 = “abandon”
for i in str1:
if i == “d”:
continue
print(i)
else:
print(“程序正常结束”)

‘’’
字符串内容：
定义字符串有单引号，双引号和三引号，三引号支持回车换行

字符串的查找：(字符串下标从0开始)
find（）：检测某个子串是否包含在这个字符串中，
如果在，就返回这个子串开始的下标，如果没有就返回-1
rfind():和find（）功能相同，但是查找方向为右侧开始
index（）：和find（）用法一样，但是index（）如果没查到是报错，而不是返回-1
rindex（）：和index（）用法一样，但查找方向从右侧开始
语法：
字符串序列.find（‘子串’，开始位置下标，结束位置下标）
下标位置如果不书写，则默认整个字符串
count():统计子串在字符串中出现的次数，子串不存在则返回0
语法：
字符串序列.count（‘子串’，开始位置下标，结束位置下标）
‘’’
#find()
mystr = ‘hello world and luoyu and fengcheng’
print(mystr.find(‘luoyu’))

#index()
mystr = ‘hello world and luoyu and fengcheng’
print(mystr.index(‘luoyu’))

#count
mystr = ‘hello world and luoyu and fengcheng’
print(mystr.count(‘luoyu’))

‘’’
字符串处理—修改
replace（‘原字符串中内容’，‘需要替换的内容’，替换次数）
replace函数有返回值，返回值是修改后的字符串，替换次数不写则表示全部替换，
替换次数超出字符串出现次数时也表示替换所以字符串
‘’’
mystr = ‘hello world and luoyu and fengcheng’
new_str =mystr.replace(‘luoyu’,‘laopo’)
#print(mystr)打印出来后发现mystr字符串没有变化，说明字符串是不可变数据类型
print(new_str)

‘’’
split()–分割，返回一个列表，但是会丢失分割字符
语法：
字符串.split（‘分割字符’，分割次数）分割次数不写则表示全部分割
‘’’
mystr = ‘hello world and luoyu and fengcheng’
list1 = mystr.split(‘and’,2)
print(list1)#输出结果：['hello world ', ’ luoyu ‘, ’ fengcheng’]

‘’’
join()–合并列表里的字符串数据为一个大的字符串
语法：
‘合并字符’.join（列表）
‘’’
mylist = [‘a’,‘b’,‘c’]
new_mylist = ‘嘿嘿’.join(mylist)
print(new_mylist)#输出结果： a嘿嘿b嘿嘿c

‘’’
字符串大小写转换：
1.capitalize（）:将字符串中第一个字母转换成大小
语法：
字符串.capitalize（）
2.title（）：将字符串中每个单词的首字母都转换成大写
语法：
字符串.title（）
3.lower（）：将字符串中所有的大写转小写
语法：
字符串.lower（）
4.upper（）：将字符串中所有小写转大写

‘’’
#例如:capitalize()

mystr = ‘hello world and luoyu and fengcheng’
new_mystr = mystr.capitalize()
print(new_mystr)# Hello world and luoyu and fengcheng

#例如：title()

mystr = ‘hello world and luoyu and fengcheng’
new_mystr = mystr.title()
print(new_mystr)# Hello World And Luoyu And Fengcheng

#例如： lower（）

mystr = ‘hello world And luoyu and Fengcheng’
new_mystr = mystr.lower()
print(new_mystr)# hello world and luoyu and fengcheng

#例如： upper（）
mystr = ‘hello world And luoyu and Fengcheng’
new_mystr = mystr.upper()
print(new_mystr)# HELLO WORLD AND LUOYU AND FENGCHENG

‘’’
字符串操作—删除空格
语法:
字符串.lstrip()
字符串.rstrip()
字符串.strip()
lstrip():删除字符串左侧空白字符
rstrip():删除字符串右侧字符
strip():删除字符串两侧空白字符
‘’’
#lstrip()
mystr = ’ hello world and luoyu and fengcheng ’
new_mystr = mystr.lstrip()
print(new_mystr)#hello world and luoyu and fengcheng

#rstrip()
mystr = ’ hello world and luoyu and fengcheng ’
new_mystr = mystr.rstrip()
print(new_mystr)# hello world and luoyu and fengcheng

#strip()
mystr = ’ hello world and luoyu and fengcheng ’
new_mystr = mystr.strip()
print(new_mystr)#hello world and luoyu and fengcheng

‘’‘字符串对齐
字符串.ljust(长度，‘填充字符’):左对齐
字符串.rjust(长度，‘填充字符’):右对齐
字符串.center(长度，‘填充字符’):中心对齐
若不书写填充字符则默认空格
‘’’

‘’'字符串操作–判断
检测字串符串是否以指定子开头：不写下标默认整个字符串
字符串.startswith(‘子串’，开始位置下标，结束位置下标）

检测字串符串是否以指定子结尾：不写下标默认整个字符串
字符串.endswith(‘子串’，开始位置下标，结束位置下标）
‘’’
#startswith
mystr = ‘hello world and luoyu and fengcheng’
new_mystr = mystr.startswith(‘and’,0,20)
print(new_mystr)

‘’’
字符串操作–判断
语法：
1.字符串.isalpha（）：如果字符串至少有一个字符并且所有字符都是字母则返回True，否则False
2.字符串.isdigit（）：如果字符串只包含数字则返回True，否则False
3.字符串.isalnum（）：如果字符串中只包含字母或数字或两者组合则返回True，否则False
4.字符串.isspace():如果字符串中都是空白则返回True,否则False
‘’’

‘’’
列表的常用操作–查找(列表是可变数据类型)
1.通过下标查找 格式：
print（name_list[i]）,i为需要查询的数据的下标
2.通过函数查找
1.列表序列.index（’数据‘，开始位置下标，结束位置下标）
返回指定数据所在位置的下标，不存在则报错
2.列表序列.count（’数据‘）
统计指定数据在列表中出现的次数
3.len（列表序列）
访问列表长度，即列表中数据的个数
‘’’
#1.index()
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
print(name_list.index(‘fengyu’))# 3

#2.count()
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
print(name_list.count(‘fengyu’))# 1

#3.len()
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
print(len(name_list))# 3

‘’’
列表操作—判断
1.in:判断指定数据在某个列表序列，如果在则返回True，不在则返回False
语法： print（‘指定数据’ in 列表序列）
2.not in：判断指定数据不在某个列表序列，如果不在则返回True，在则返回False

‘’’
#1. in
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
print(‘luoyu’ in name_list)# True

#2. not in
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
print(‘luoyu’ not in name_list)# False

#体验案例：查找用户输入的名字是否已存在：
#创建一个名字列表
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
#用户输入查询的名字
name = input(‘请输入您要搜索的名字’)
#判断
if name in name_list:
print(f’您输入的名字是{name},名字已存在’)
else:
print(f"您输入的名字是{name},名字不存在")

‘’‘列表处理—增加数据
语法：
1.列表序列.append(‘数据’)—列表结尾追加数据,
如果数据是一个序列，则将这个序列整个添加到列表
2.列表序列.extend(‘数据’)—列表结尾追加数据，
如果数据是一个序列，则将这个序列中的数据逐一添加到列表
3.列表序列.insert(位置下标，‘数据’)—指定位置新增数据
如果数据是一个序列，则将这个序列整个添加到列表
‘’’
#1.列表序列.append（‘数据’）
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
name_list.append([‘fengluo’,‘sadsa’])
print(name_list)
#[‘luoyu’, ‘fengcheng’, ‘fengyu’, [‘fengluo’, ‘sadsa’]]

#2.列表序列.extend(‘数据’)
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
name_list.extend([‘fengluo’,‘sadsa’])
print(name_list)

[‘luoyu’, ‘fengcheng’, ‘fengyu’, ‘fengluo’, ‘sadsa’]

#3.列表序列.insert(位置下标，‘数据’)
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
name_list.insert(2,[‘fengluo’,‘sadsa’])
print(name_list)
#[‘luoyu’, ‘fengcheng’, [‘fengluo’, ‘sadsa’], ‘fengyu’]

‘’‘列表处理—删除数据
语法：
1.del（目标） ：可直接删除变量，如自定义的list
del (列表序列[i])： 可删除指定下标序列
2. 列表序列.pop (i):删除指定下标的数据，如果不指定则默认删除最后一个数据，
无论是按指定删除还是删除最后一个数据，pop函数都会返回被删除这个数据
3. 列表序列.remove(‘数据’)：从列表序列中删除指定数据
4. 列表序列.clear()：清空列表
‘’’
#1.del删除指定数据
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
del name_list[0]
print(name_list)# [‘fengcheng’, ‘fengyu’]

#2.列表序列.pop（i）
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
del_name = name_list.pop(1)
print(del_name)# fengcheng
print(name_list)# [‘luoyu’, ‘fengyu’]

#3.列表序列.remove(‘数据’)
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
name_list.remove(‘fengcheng’)
print(name_list)# [‘luoyu’, ‘fengyu’]

#4.列表序列.clear()
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
name_list.clear()
print(name_list)# []

‘’'列表处理—修改
1.修改指定下标的数据
name_list[i] = '数据‘
2.逆序
列表序列.reverse()
3.排序
列表序列.sort(key = None,reverse = False) 括号里不写默认升序， reverse = True 降序
reverse = False 升序

4.复制
列表序列.copy()
‘’’
#1.修改指定下标数据
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
name_list[1] = ‘zhu’
print(name_list)# [‘luoyu’, ‘zhu’, ‘fengyu’]

#2.逆序
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
name_list.reverse()
print(name_list)# [‘fengyu’, ‘fengcheng’, ‘luoyu’]

#3.排序-升序
name_list = [‘1’, ‘5’, ‘9’, ‘8’, ‘2’, ‘7’]
name_list.sort(reverse = False)
print(name_list)# [‘1’, ‘2’, ‘5’, ‘7’, ‘8’, ‘9’]

#4.复制
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
new_list = name_list.copy()
print(new_list)# [‘luoyu’, ‘fengcheng’, ‘fengyu’]

‘’'列表处理—循环遍历

‘’’
#while循环遍历
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
i = 0
while i < len(name_list):
print(name_list[i])
i += 1
#for循环遍历
name_list = [‘luoyu’,‘fengcheng’,‘fengyu’]
for i in name_list:
print(i)

‘’’
列表嵌套：列表序列[][]
指的是在一个列表中包含了其它的子列表
‘’’
name_list = [[‘luoyu’,‘fengcheng’,‘fengyu’],[‘罗宇宝宝’,‘冯城’,‘冯宇’]]
print(name_list[0][0])

‘’‘综合应用–随机分配办公室
需求：
有三个办公室，8位老师，8位老师随机分配到三个办公室
步骤：
1.准备数据；
1.1 准备8为老师的数据；（用列表）
1.2 准备三个办公室；（列表嵌套）
2.随机分配老师到办公室；
随机分配：就是把老实的名字随机写入办公室，等价于办公室列表里追加老师
3.验证是否分配成功
打印办公室详细信息
‘’’
import random
#1. 准备数据
teachers_list = [‘a’,‘b’,‘c’,‘d’,‘e’,‘f’,‘g’,‘h’]
offices_list = [[],[],[]]

#2. 分配老师到办公室–需要取到每个老师-遍历列表
for name in teachers_list:
# 列表追加数据–append extend insert
#只有三个办公室，随机数取3个就行
rnum = random.randint(0,2)
offices_list[rnum].append(name)
print(offices_list)

#为了更贴合实际，给办公室编号：1，2，3
i = 1
#3. 验证是否分配成功
for office in offices_list:
print(f’办公室{i}的人数是{len(office)},老师分别是：')
for name in office:#打印每个办公室的老师，因此还要用一次遍历
print(name,end = " ")
print()
i += 1

‘’’
元组：( , , , )
一个元组可以储存多个数据，但是元组内的数据是不能修改的
若元组内只有一个数据，那么这个数据后也要加一个逗号
例如：t2 = (1,)
‘’’
#1.多个数据元组写法
t1 = (1,2,3)
t2 = (‘aaa’,‘bbb’,‘ccc’)
print(type(t1)) # tuple
print(type(t2)) # tuple
#2.单个数据元组写法
t3 = (1,)
t4 = (‘aaa’,)
print(type(t3)) # tuple
print(type(t4)) # tuple

‘’’
元组常见操作—查找
1.按下标查找
2.通过指定数据查找
index（）
3.统计某个数据在元组中出现的次数
count（）
4.统计元组中数据的个数
len（）
‘’’
#1.下标
t1 = (‘luoyu’,‘fengcheng’,‘fengyu’)
print(t1[0]) # luoyu

#2.制定数据查找–index()函数会返回查找的指定数据的下标，若没查到则报错
t1 = (‘luoyu’,‘fengcheng’,‘fengyu’)
print(t1.index(‘luoyu’)) # luoyu

#3.统计指定数据出现次数
t1 = (‘luoyu’,‘fengcheng’,‘fengyu’)
print(t1.count(‘luoyu’)) # 1

#4.统计元组中数据个数
t1 = (‘luoyu’,‘fengcheng’,‘fengyu’)
print(len(t1)) # 3

‘’’
元组常见操作—数据修改
元组内的直接数据是不能修改的，修改会直接报错，但是元组里的列表里的数据是可以修改的
‘’’
#元组内列表里数据的修改
t1 = (‘fengyu’,[‘luoyu’,‘fengcheng’])
t1[1][1] = ‘fc’
print(t1) # (‘fengyu’, [‘luoyu’, ‘fc’])

‘’’
字典–可变数据类型–字典里面的数据是以键值对形式出现，字典数据和数据顺序没有关系，
即字典不支持下标，后期无论数据如何变化，只需要按照对应的键的名字查找数据即可
特点：1.符合为大括号｛｝
2.数据为键值对形式出现
3.各个键值对之间用逗号，隔开
dict = {‘键1’：‘值1’，‘键2’：‘值2’}
‘’’
‘’’
字典操作—增(修改)–若key存在则修改这个key的值，如果不存在则新增
字典序列[‘key’] = ‘值’
‘’’
dict1 = {‘name1’:‘luoyu’,‘name2’:‘fengcheng’,‘age1’:‘20’,‘age2’:‘21’}
dict1[‘name’] = ‘猪’
print(dict1)#{‘name1’: ‘luoyu’, ‘name2’: ‘fengcheng’, ‘age1’: ‘20’, ‘age2’: ‘21’, ‘name’: ‘猪’}

‘’’
字典操作—删–删除字典或删除字典中指定的键值对

1. del()—删除字典或删除字典中指定的键值对
   2.clear()—清空字典
   ‘’’
   #1.del删除字典
   dict1 = {‘name1’:‘luoyu’,‘name2’:‘fengcheng’,‘age1’:‘20’,‘age2’:‘21’}
   del dict1
   print(dict1)# name ‘dict1’ is not defined

#2.del 删除指定键值对,若删除的key不存在则报错
dict1 = {‘name1’:‘luoyu’,‘name2’:‘fengcheng’,‘age1’:‘20’,‘age2’:‘21’}
del dict1[‘name2’]
print(dict1)#{‘name1’: ‘luoyu’, ‘age1’: ‘20’, ‘age2’: ‘21’}

#clear()清空字典
dict1 = {‘name1’:‘luoyu’,‘name2’:‘fengcheng’,‘age1’:‘20’,‘age2’:‘21’}
dict1.clear()
print(dict1)#{}

‘’'字典操作—查找
1.按key值查找，若该key存在，则返回对应的值，若不存在，则报错
2.用函数查找–
2.1 get（）–如果当前查找的key不存在，则返回默认值，如果不写默认值，则返回None
字典序列.get(key,默认值）
2.2 keys（）
2.3 values（）
2.4 items（）

‘’’
#1.按key值查找
dict1 = {‘name1’:‘luoyu’,‘name2’:‘fengcheng’,‘age1’:‘20’,‘age2’:‘21’}
print(dict1[‘name1’])#luoyu

#2.用get（）查找
dict1 = {‘name1’:‘luoyu’,‘name2’:‘fengcheng’,‘age1’:‘20’,‘age2’:‘21’}
print(dict1.get(‘name1’))# luoyu

#3.用keys（）–查找字典中所有的key，返回一个可迭代对象
dict1 = {‘name1’:‘luoyu’,‘name2’:‘fengcheng’,‘age1’:‘20’,‘age2’:‘21’}
print(dict1.keys())#dict_keys([‘name1’, ‘name2’, ‘age1’, ‘age2’])

#4.values（）–查找字典中所有的值，返回一个可迭代对象
dict1 = {‘name1’:‘luoyu’,‘name2’:‘fengcheng’,‘age1’:‘20’,‘age2’:‘21’}
print(dict1.values())#dict_values([‘luoyu’, ‘fengcheng’, ‘20’, ‘21’])

#5.items（）–查找字典里所有的键值对，返回一个可迭代对象，
# 内部是元组，元组有两个数据
#元组数据1是字典的key，元组数据2是字典的value
dict1 = {‘name1’:‘luoyu’,‘name2’:‘fengcheng’,‘age1’:‘20’,‘age2’:‘21’}
print(dict1.items())#dict_items([(‘name1’, ‘luoyu’), (‘name2’, ‘fengcheng’), (‘age1’, ‘20’), (‘age2’, ‘21’)])

‘’’
字典的循环遍历
1.遍历字典的key
2.遍历字典的value
3.遍历字典的元素
4.遍历字典的键值对（拆包）
‘’’
#1.遍历字典的key
dict1 = {‘name1’:‘luoyu’,‘name2’:‘fengcheng’,‘age1’:‘20’,‘age2’:‘21’}
for key in dict1:
print(key,end = ’ ')# name1 name2 age1 age2
#2.遍历字典的value
dict1 = {‘name1’:‘luoyu’,‘name2’:‘fengcheng’,‘age1’:‘20’,‘age2’:‘21’}
for value in dict1.values():
print(value,end = ’ ')#luoyu fengcheng 20 21

#3.遍历字典的元素
dict1 = {‘name1’:‘luoyu’,‘name2’:‘fengcheng’,‘age1’:‘20’,‘age2’:‘21’}
for item in dict1.items():
print(item,end = ’ ')
#(‘name1’, ‘luoyu’) (‘name2’, ‘fengcheng’) (‘age1’, ‘20’) (‘age2’, ‘21’)

#4.遍历字典的键值对（拆包）
dict1 = {‘name1’:‘luoyu’,‘name2’:‘fengcheng’,‘age1’:‘20’,‘age2’:‘21’}
for key,value in dict1.items():
print(f’{key} = {value}',end = ’ ')#name1 = luoyu name2 = fengcheng age1 = 20 age2 = 21

‘’’
集合–里面不允许有重复数据,且集合没有顺序，是可变类型数据
创建集合可以使用｛｝，也可以使用set（），但是如果要创建空集合只能用set（），
因为｛｝用来建空字典了
‘’’
#1.创建有数据的集合,如果数据重复则报错,set(‘’)创建字典有重复数据会自动去重
s1 = {10,20,30}
s2 = set(‘102030’)
print(type(s1))#<class ‘set’>
print(s2)#{‘3’, ‘2’, ‘0’, ‘1’}

‘’’
集合操作方法–增加
1.集合.add（）–增加单一数据
2.集合.update（）–增加多个数据[]
‘’’
#1集合.add()–若增加数据集合里已存在，则数据不变
s1 = {10,20,30}
s1.add(100)
print(s)#{100, 10, 20, 30}

#2.集合.update()–括号内写列表，即一次性往集合里增添多个数据
s1 = {10,20,30}
s1.update([100,2,3])
print(s1)#{2, 3, 100, 10, 20, 30}

‘’’
集合操作—删除

1. 集合.remove（）–删除集合中指定数据，如果数据不存在则报错
2. 集合.discard（）–删除集合中指定数据，如果数据不存在也不会报错
3. 集合.pop（）—随机删除某个数据，并返回这个数据
   ‘’’
   #1.集合.remove（）–删除的数据不存在则报错
   s1 = {10,20,30}
   s1.remove(10)
   print(s1)# {20, 30}

#2. 集合.discard（）–删除的数据不存在也不会报错
s1 = {10,20,30}
s1.discard(100)
print(s1)# {10, 20, 30}

#3. 集合.pop() --随机删除某个数据，并返回这个数据
s1 = {10,20,30}
s2 = s1.pop()
print(s2)# 10
print(s1)# {20, 30}

‘’’
集合操作—查找

1. in
2. not in
   ‘’’
   #1. in
   s1 = {10,20,30}
   print(20 in s1)#True
   #2. not in
   s1 = {10,20,30}
   print(20 not in s1)#False

‘’’
公共操作：运算符
运算符 描述 支持的容器类别
1. + 合并 字符串，列表，元组
2. * 复制 字符串，列表，元组
3. in 元素是否存在 字符串，列表，元组，字典
4. not in 元素是否不存在 字符串，列表，元组，字典
‘’’
#1.+ 合并
str1 = ‘aa’
str2 = ‘bb’

list1 = [1,2]
list2 = [10,20]

t1 = (1,2)
t2 = (10,20)

dict1 = {‘name1’:‘luoyu’,‘age1’:‘20’}
dict2 = {‘name2’:‘fengcheng’,‘age2’:‘21’}

str = str1 + str2
list = list1 + list2
t = t1 + t2
#dict = dict1 + dict2 会报错–字典不支持合并
print(str)# aabb
print(list)# [1, 2, 10, 20]
print(t)# (1, 2, 10, 20)
#print(dict)—字典不支持合并

#2. * 复制
str1 = ‘a’
list1 = [1,2]
t1 = (1,2)
str = str1 * 5
list = list1 * 5
t = t1 * 5
print(str)# aaaaa
print(list)# [1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
print(t)# (1, 2, 1, 2, 1, 2, 1, 2, 1, 2)

#3. in判断元素存在
#4.not in 判断元素不存在
str = ‘abcd’
list = [1,2]
t = (1,2)
dict = {1:‘a’,2:‘b’,3:‘c’}
print(‘a’ in str)# True
print(0 not in list)# True
print(2 in t)# True
print(‘c’ not in dict.values())# False 字典.values（）会返回所有可迭代的值，c在里面
print(3 in dict.keys())# True 字典.keys（）会返回所有可迭代的key，3在里面

‘’’
公共方法–len（）计算容器中元素个数
–del或del（） 删除
–max（） 返回容器中元素最大值
–min（） 返回容器中元素最小值
–range（start，end，step） 生成从start到end的数字，步长为step，供for循环使用
会返回一个可迭代对象
–enumerate（可遍历对象，start = 0） 函数用于将一个可遍历的数据对象（如列表、元组或字符串）组合为一个索引
序列，同时列出数据和数据下标，一般用在for循环当中
参数start用来设置遍历数据的下标的起始站，默认为0

‘’’
#1.len()
str = ‘abcd’
list = [1,2]
t = (1,2)
s = {10,20,30}
dict = {1:‘a’,2:‘b’,3:‘c’}
print(len(str))# 4
print(len(list))# 2
print(len(t))# 2
print(len(s))# 3
print(len(dict))# 3

#2.del 或del()
list = [1,2]
del list[0]
print(list)#[2]

list = [1,2]
del (list)
print(list)# <class ‘list’>

s = {10,20,30}
del s
print(s)# NameError: name ‘s’ is not defined

#3.max() min()
s = {10,20,30}
print(max(s))# 30

s = {10,20,30}
print(min(s))# 10

#4.range(start,end,step)生成从start到end的数字，步长为step，供for循环使用

不写开始默认为0，步长不写默认为1

for num in range(1,5,1):
print(num)#1 2 3 4

for num in range(0,5,2):
print(num)#0 2 4

#5.enumerate(可遍历对象，start = 0)
#返回结果是元组，元组第一个数据是原迭代对象的数据对应的下标，元组第二个数据是原迭代对象的数据
list = [‘a’,‘b’,‘c’,‘d’,‘e’]
for i in enumerate(list,start = 1):
print(i,end = ’ ')# (1, ‘a’) (2, ‘b’) (3, ‘c’) (4, ‘d’) (5, ‘e’)

‘’’
容器类型转换
1.tuple()–将某个序列转换成元组
2.list()–将某个序列转换成列表
3.set（）–将某个序列转换成集合

‘’’
#1.tuple()
list = [‘a’,‘b’,‘c’,‘d’,‘e’]
s = {1,2,3,4}
print(type(tuple(list)))# <class ‘tuple’>
print(tuple(s))# (1, 2, 3, 4)

#2.list()
s = {1,2,3,4,5}
print(list(s))# [1, 2, 3, 4, 5]

#3.set()
list = [1,2,3,4,5,5]
t = (1,2,3)
print(set(list))# {1, 2, 3, 4, 5},集合有去重功能
print(set(t))# {1, 2, 3}

‘’’
推导式—列表，字典，集合
‘’’
#需求：创建一个0-10有规律的列表
#while循环实现
#准备一个空列表
list1 = []
#书写循环，依次追加数字到空列表list1中
i = 0
while i < 10:
list1.append(i)
i += 1
print(list1)# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#for循环实现
#准备一个空列表
list1 = []
#书写循环，依次追加数字到空列表list1中
for i in range(0,10):
list1.append(i)
i += 1
print(list1)# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#1.列表推导式
list1 = [i for i in range(0,10)]#前一个i是后面个i遍历后返回的值
print(list1)
#1.1带if的列表推导式
#需求：创建0-10的偶数列表
list1 = [i for i in range(0,10) if i%2 == 0]
print(list1)# [0, 2, 4, 6, 8]

#1.2多个for循环实现
#需求：创建列表[(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)]

数据1：1，2

数据2：0，1，2

list = []
for i in range(1, 3):
for j in range(0, 3):
list.append((i, j))
print(list)
#1.2多个for循环实现列表推导式
list = [(i,j) for i in range(1,3) for j in range(0,3)]
print(list)# [(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

#2.字典推导式
#需求：将两个列表合并为一个字典,

两个列表个数不同，len（）统计个数多的会报错越界，len()统计个数少的可运行，内容相同不影响

list1 = [‘name’,‘age’,‘gender’]
list2 = [‘luoyu’,‘20’,‘women’]
dict = {list1[i]:list2[i] for i in range(len(list1))}
print(dict)# {‘name’: ‘luoyu’, ‘age’: ‘20’, ‘gender’: ‘women’}

#提取字典中目标键值对数据
counts = {‘MBP’:268,‘HP’:125,“DELL”:201,‘Lenovo’:199,‘acer’:99}
#需求：提取上述电脑数量大于等于200的字典键值对数据
count1 = {key:value for key,value in counts.items() if value >= 200}
print(count1)# {‘MBP’: 268, ‘DELL’: 201}

#3.集合推导式
#需求：创建一个集合，数据为下方列表的2次方
list1 = [1,1,2]
set1 = {i ** 2 for i in list1}
print(set1)#集合有去重功能 {1, 4}

‘’’
函数–就是将一段具有独立功能的代码块整合到一个整体并命名，
在需要的位置调用这个名称即可完成相应的需求
1.函数的使用步骤：
1.1定义函数：
def 函数名（参数）：
代码1
代码2
…
1.2调用函数：
函数名（参数）
注意：1.在不同的需求中，参数可有可无
2.在python中，函数必须先定义后使用

2.函数的注意事项：
2.1 函数必须先定义，后调用
2.2 函数必须调用后，函数里的代码才会执行
2.3 定义函数时，函数下方缩进的代码并没有执行
2.4 定义函数时参数有多少，调用时就要输入多少，不然会报错丢失参数

3.函数的执行流程：
当调用函数的时候，解释器会回到定义函数的地方去执行函数内的代码，
当这些代码执行完后解释器会回到调用函数的地方继续向下执行

4.函数的参数的作用–使得函数更加的灵活

def add_num1(a,b): # a,b为形参
    result = a + b
    print(result)

add_num1(10,20) # 10和20这种真实数据为实参
#结果为30

5.函数返回值的作用：
在函数使用过程中，如果需要返回结果给用户就需要使用函数返回值

6.函数的说明文档：
help(函数名）的作用就是查看函数的说明文档
函数说明文档的定义方法：
def 函数名（参数）：
“”“说明文档位置”“”
代码1
…
函数说明文档的高级写法：
def 函数名（参数）：
“”“回车”“”
代码1
…

‘’’
#需求：复现ATM机取钱功能
‘’’
1.搭建整体框架（复现需求）

print(‘密码正确，登录成功’)
#显示’选择功能界面‘

print(’查询余额完毕’)
#显示’选择功能界面‘

print(‘取钱成功’)
#显示’选择功能界面‘

2.确定“选择功能“界面内容
2.1 print（’查询余额‘）
2.2 print（’存款‘）
2.3 print（’取款”）

3.封装功能–注意：函数要先定义再调用，因此2，3应该在最开始书写

4.在需要的位置调用函数

‘’’

def sel_func():
print(‘查询余额’)
print(‘存款’)
print(‘取款’)

print(‘密码正确，登录成功’)
sel_func()

print(‘查询余额完成’)
sel_func()

print(‘取款完成’)
sel_func()

4. 函数参数的作用

def add_num1(a, b): # a,b为形参
result = a + b
print(result)

add_num1(10, 20) # 10和20这种真实数据为实参

结果为30

5. 函数返回值的作用

def buy():
return ‘烟’ #return会返回一个结果给函数调用的地方

goods = buy()# 用来接受函数里return返回的数据
print(goods)

5.1函数返回值的应用

#需求：制作一个计算器，计算任意两个数字加法的结果，并返回这个结果
def sum_num(a,b):
return a + b

result = sum_num(1,2)
print(result)

#6.定义函数的说明文档并查看
def sum_num(a,b):
‘’‘求和函数’‘’
return a + b

help(sum_num)# 求和函数

#6.1 说明文档的高级使用
def sum_num(a,b):
‘’’ #此处敲个回车就行
求和函数
:param a: 参数1
:param b: 参数2
:return: 返回值
‘’’
return a + b

help(sum_num)

‘’’
函数嵌套调用–一个函数里面又调用了另一个函数

‘’’
#函数嵌套调用测试
def testa():
print(‘testa start’)
print(‘testa end’)

def testb():
print(‘testb start’)
testa() #调用函数testa（）,到这里后先执行testa（），执行完后回到这里继续进行下面的代码
print(‘testb end’)

testb()
#运行结果：testb start

testa start

testa end

testb end

#函数嵌套应用之打印多条横线图形–数量自定义
def print_line():
print(‘-’ * 20)

def print_lines(num):# 定义形参 num
i = 0
while i < num:
print_line()
i += 1
m = int(input(‘请输入需要打印的条数’))
print_lines(m)# 实参自己输入

‘’’
函数嵌套—计算
1.求三个数之和
2.求三个数的平均值

‘’’
#1.三个数求和
def sum_num(a,b,c):
return a + b + c

result = sum_num(1,2,3)
print(result)

求三个数和的函数

def sum_num(d,e,f):
return d + e + f
#求三个数平均值的函数
def average_num(a,b,c):
sum_result = sum_num(a,b,c)
return sum_result / 3

average = average_num(1,2,3)
print(average)

‘’’
函数二
1.变量作用域：变量生效的范围
1.1 局部变量
指在函数内部定义的变量，仅供函数内部使用
作用：临时保存数据，当函数调用完成后则销毁局部变量
1.2全局变量
在函数体内外都能生效的变量
2.修改全局变量
global 变量 #声明该变量为全局变量
‘’’

‘’’
多函数程序执行–共用全局变量

注意：1.多函数共用全局变量后，函数修改全局变量后对其它函数调用全局变量时有影响

‘’’
#定义全局变量
glo_num = 0

def test1():
global glo_num
#修改全局变量
glo_num = 100

def test2():
#调用test1函数中修改后的全局变量
print(glo_num)

test1() #调用test1修改全局变量
test2()#调用test2打印glo_num 结果：100

‘’’
返回值作为参数传递
‘’’
def test1():
return 50

def test2(num):
print(num)

result = test1() # result用来接受test1的返回值

test2(result)# 返回值作为传递参数

‘’’
函数的多个返回值的写法
return a,b 的多个返回值的写法，默认是元组
注意：
1.return后面可以直接书写 元组 列表 字典 返回多个值
‘’’
def return_num():
return 1,2#有两个返回值

result = return_num()
print(result)# (1, 2)

‘’’
函数参数—位置参数
调用函数时根据函数定义的参数位置来传递参数
注意：传递和定义参数的顺序及个数必须一致，否则会导致数据无意义
‘’’
def user_info(name,age,gender):
print(f’您的名字是{name},年龄是{age},性别是{gender}')

user_info(‘luoyu’,20,‘女’)

‘’’
函数参数—关键字参数
函数调用时，通过“键=值”形式加以指定，能让函数更清晰，容易使用，同时清除了参数的顺序需求
注意：函数调用时，如果有位置参数，则位置参数必须在关键字参数之前，否则报错
‘’’
def user_info(name,age,gender):
print(f’您的名字是{name},年龄是{age},性别是{gender}')

def user_info(name,age,gender):
print(f’您的名字是{name},年龄是{age},性别是{gender}')

user_info(‘luoyu’,gender = ‘女’,age = 20)# 关键字参数

‘’’
函数参数—缺省参数
缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值
注意：1.所有位置参数必须出现在默认参数之前，包括函数定义和调用
2.函数调用时，如果为缺省参数传 值则修改默认参数值，否则使用这个默认值
‘’’
def user_info(name,age,gender = ‘男’):
print(f’您的名字是{name},年龄是{age},性别是{gender}')

user_info(‘luoyu’,gender = ‘女’,age = 20)# 您的名字是luoyu,年龄是20,性别是女
user_info(‘TOM’,age = 21 )# 您的名字是TOM,年龄是21,性别是男

‘’’
函数参数—不定长参数
不定长参数也叫可变参数，用于不确定调用的时候会传递多少个参数(不传参也可以）的场景，
此时可用包裹(packing)位置参数，或者包裹关键字参数来进行参数传递，会显得很方便
1.包裹位置传递
def 函数名（*args）：
代码…
注意：传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组（tuple），args是元组类型
2.包裹关键传递
def 函数名（**kwargs）：
代码…
注意：传进的所有参数都会被kwargs变量收集，它会根据传进参数的位置合并为一个字典（dict）
总结：
无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程。

‘’’
#1.包裹位置参数
def user_info(*args):
print(args)

user_info(‘luoyu’,20)

#2.包裹关键字参数
def user_info(**kwargs):
print(kwargs)
user_info(name = ‘luoyu’,age = 20)

‘’’
拆包—元组
拆包—字典
‘’’
#元组拆包
def return_num():
return 20,21

print(return_num())#测试返回值为元组

num1,num2 = return_num()# 元组拆包过程
print(num1)
print(num2)

‘’’
交换变量值
‘’’
#方法一
a = 10
b = 20
#1.定义中间变量
c = 0
#2.将a的数据储存到c
c = a
#3.将b的数据赋给a
a = b
#4.将a的值赋给b
b = c
print(a)
print(b)

#方法二
a, b = 10, 20
a, b = b, a
print(a)
print(b)

‘’’
引用—在python中，值都是靠引用来传递的
id() 可以用来判断两个变量是否为同一个值的引用
‘’’
#不可变类型–整型，浮点，字符，元组
a, b = 10, 20
b = a
print(id(a)) #2345136712272
print(id(b)) #2345136712272

a = 1
print(b)# 10 int为不可变类型
#因为修改了a的数据，所有系统要为a开辟另外的地址，所以a和b的地址不同了
print(id(a))#2345136711984
print(id(b))#2345136712272

#可变类型–列表，字典，集合
a = [10,20]
b = a

print(id(a))#2067527968000
print(id(b))#2067527968000

a.append(30)
print(b) # 列表为可变类型

print(id(a))#2067527968000
print(id(b))#2067527968000

‘’’
引用当作实参传递
‘’’
def test(a):
print(a)# 访问形参看是否有数据
print(id(a))# 打印形参id值

a += a#  改变形参的值
print(a)#  检测形参的值是否改变
print(id(a))#  打印改变后形参的id，看是否相同

#int：计算前后id值不同
b = 100
test(b)
#列表：计算前后id值相同
c = [1,2]
test©

‘’’
递归—是一种编程思想，非常重要
特点：1.函数内部自己调用自己
2.必须有出口,没有出口会报错超出最大递归深度
应用：
需求：求3以内数字累加和，1 + 2 + 3 = 6
转换思想：6 = 3 + 2以内数字累加和
2以内数字累加和 = 2 + 1 以内数字累加和
1以内数字累加和 = 1
‘’’

def sum_num(num):
#2.出口
if num == 1:
return 1 #这个return的返回值返回到上一代调用的位置
#1. 当前数字 + 当前数字-1的累加和 函数内部自己调用自己
return num + sum_num(num - 1)

result = sum_num(3)
print(result)

‘’’
lambda 表达式,又叫匿名函数—简化代码：
如果一个函数有一个返回值，并且只有一句代码，可是使用lambda简化
语法： lambda 参数列表 ： 表达式
注意：1.lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用
2.lambda表达式能接收任何数量的参数，但只能返回一个表达式的值
3.直接打印lambda的变量名（如下方 fun_num）打印出来的是lambda的内存地址
要取到lambda的返回值需要打印print(变量名（）)

‘’’
def fun1():
return 100

print(fun1())# 100
fun_num = lambda : 100
print(fun_num)# 打印出来是lambda的内存地址
print(fun_num())# 100

#lambda函数实现 a + b
fun1 = lambda a, b : a + b# 语法： lambda 参数列表 ： 表达式
print(fun1(1,2))# 3

‘’’
lambda的参数形式
1.无参数:
fn1 = lambda : 100
print(fn1())
2.一个参数
fn2 = lambda a : a
print(fn2(‘hello world’))# lambda表达式能接收任何数量的参数，但只能返回一个表达式的值
3.缺省参数（默认参数）
fn3= lambda a,b,c = 100: a + b + c
print(fn3(10,20)) # 130 也可以输入默认参数对应位置的数值，从而覆盖默认参数的值
4.可变参数：*args 接收不定长参数，并返回一个元组
fn4 = lambda *args :args
print(fn4(10,20,30))# (10, 20, 30)
5.可变参数：**kwargs 接收不定长的参数，并返回一个字典
fn5 = lambda **kwargs : kwargs
print(fn5(name = ‘fengcheng’,age = 21))# {‘name’: ‘fengcheng’, ‘age’: 21}

‘’’

‘’’
lambda的应用
1.带判断的lambda
2.列表内数据按字典key的值排序
‘’’
#1.带判断的lambda:返回两个数字中大的一个
fn1 = lambda a,b : a if a > b else b
print(fn1(10,20))

#2.列表内数据按字典key的值排序
students = [{‘name’:‘luoyu’,‘age’:20},
{‘name’:‘fc’,‘age’:21},
{‘name’:‘fy’,“age” :19}]
#按name值升序排序
students.sort(key = lambda x:x[‘name’])
print(students)
#运行[{‘name’: ‘fc’, ‘age’: 21},

{‘name’: ‘fy’, ‘age’: 19},

{‘name’: ‘luoyu’, ‘age’: 20}]

#按age值降序排序
students.sort(key = lambda x : x[‘age’],reverse = True)#reverse函数是逆序的意思
print(students)
#运行[{‘name’: ‘fc’, ‘age’: 21},

{‘name’: ‘luoyu’, ‘age’: 20},

{‘name’: ‘fy’, ‘age’: 19}]

‘’’
高阶函数—把函数作为参数传入，这样的函数称为高阶函数，高阶函数是函数式编程的体现
函数式编程就是高阶函数这种高度抽象的编程范式
内置函数体验：
1.abs()函数可以完成对数字求绝对值的计算
2.round()函数可以完成对数字的四舍五入计算

高阶函数体验
‘’’
#1.abs()函数求绝对值
a = abs(-10)
print(a)# 10

#2.round()函数四舍五入
a = round(1.9) # a = round(1.4)
print(a)# 2 print(a) # 1

#高阶函数体验
‘’’
需求：任意两个数字，按照指定要求整理数字后再进行求和运算
‘’’
#只能先绝对值再相加，灵活性较差
def add_num(a,b):
return abs(a) + abs(b)

result = add_num(-1,2)
print(result)# 3

#高阶函数，可根据用户传入的函数计算，灵活性更高
def add_num(a,b,f):
return f(a) + f(b)

result = add_num(-1,2,abs)
print(result)

‘’’
内置高阶函数：
1.map()
语法： map(func,lst),将传入的函数变量func作用到lst变量的每个元素中，并返回一个迭代器
2.reduce()
语法： reduce(func,lst),其中func必须有两个参数。
每次func计算的结果继续和序列的下一个元素做累计计算（不是连乘）
3.filter()—filter:过滤
语法： filter(func,lst)函数用于过滤序列，过滤掉不符合条件的元素，返回一个filter对象
如果要转换成列表，可以使用list（）转换
‘’’
#1.map(func,list)
list1 = [1,2,3,4,5] #1.准备列表数据

def func(x): #2. 准备2次方计算函数
return x ** 2

result = map(func,list1) #3.调用map()

print(result)# 内存地址 <map object at 0x000002AC36C10FA0>
print(list(result))#将数据类型转换为列表检验是否正确 [1, 4, 9, 16, 25]

#2.reduce(func,list)
import functools# 导入功能模块

list1 = [1,2,3,4,5]

def func(a,b):
return a + b

result = functools.reduce(func,list1)# 调用reduce
print(result)# 15

#3.filter(func,lst)
list1 = [1,2,3,4,5]

def func(x):
return x % 2 == 0 # 筛选符合条件的函数

result = filter(func,list1)
print(result)#打印地址 <filter object at 0x000001E36D6B0FA0>
print(list(result))# [2, 4]

‘’’
文件操作—文件操作就是把一些内容（数据）储存存放起来，可
以让程序下一次执行时直接使用，而不必重新制作一份，省时省力

文件操作步骤：
1.打开文件
2.读写等操作
3.关闭文件
注意：可以只打开和关闭文件，不进行读写等操作

打开文件：open()函数
语法：open(‘name’, ‘mode’)
name:是要打开的目标文件名的字符串（可以包含文件所在的具体路径）
mode:设置打开文件的模式（访问模式）：只读，写入，追加等
访问模式：（访问模式只有文件存在且只读的时候可省略）
三个主访问模式：
1.读r：如果文件不存在，则报错,不支持写入,文件指针在开头
2.写w：如果文件不存在，则新建文件，如果文件存在，则打开，
如果写入，则覆盖原内容，文件指针在开头
3.追加a：如果文件不存在，则新建文件，
在原有的内容下追加新的内容,文件指针在结尾，无法读数据
‘’’
‘’’
1.文件操作—读取 read()
语法： 文件对象.read(num)
注意： num表示要从文件中读取的数据的长度（单位是字节），
如果没有传入num，那么就表示读取文件中所有的数据
2.文件操作—readlines()
含义：可以按照行的方式把整个文件中的内容进行一次性读取，
并且返回的是一个列表，其中每一行的数据为一个元素
语法： 文件对象.readlines()
3.文件操作—readline()
含义：一次读取一行内容,继续调用则接着读取下一行
‘’’
#1.读，文件内容如果换行，则底层是有\n的，会有字节占据
f = open(‘Test.py’, ‘r’)#此时文件里数据是 abc
m = f.read(5)# 456
print(m)# abc

4

f.close()

#2.readlines()
f = open(‘Test.py’, ‘r’)
m = f.readlines()
print(m)# [‘hello world\n’, ‘abcdefg\n’, ‘aaa\n’, ‘bbb\n’, ‘ccc’]
f.close()

#3.readline()
f = open(‘Test.py’, ‘r’)
m = f.readline()
n = f.readline()
print(m)# hello world
print(n)# abcdefg
f.close()

‘’’
移动文件指针：seek()函数
语法： 文件对象.seek(偏移量，起始位置)
起始位置：0：文件开头
1：当前位置
2：文件结尾
‘’’
‘’’
文件备份
需求：用户输入当前目录下任意文件名，程序完成对该文件的备份功能（备份文件名为xx[备份]）
步骤：1.接受用户输入的文件名
2.规划一个备份文件名
3.备份文件写入数据（先打开文件，再写入数据，最后关闭文件）
‘’’
#文件备份

#1.接受用户输入的文件名(input输入的数据类型为字符串）
old_name = input(‘请输入您需要备份的文件：’)

#2.规划一个备份文件名–新名字 + [备份] + 后缀

2.1提取文件后缀(从右开始找到点的下标处即可）

2.2找出点的下标index后用字符串的切片提取后缀 字符串.[开始位置下标：结束位置下标:步长]

2.3判断用户输入的文件名是否有效，例如.txt则是无效的

index = old_name.rfind(‘.’)
if index > 0:# 如果index的下标大于0就是有效的
old_name[:index]
postfix = old_name[index:]

2.3组合新名字

new_name = old_name[:index] + ‘[备份]’ + postfix

#3.备份文件写入数据（先打开文件，再写入数据，最后关闭文件）

3.1 打开原文件和备份文件

old_f = open(old_name,‘rb’)
new_f = open(new_name,‘wb’)

3.2原文件读取，备份文件写入

如果不确定目标文件大小，应循环读取写入，当读取出来的数据没有了终止循环

while True:
con = old_f.read()#表示要从文件中读取的数据的长度（单位是字节）
# 不写则表示读取文件中所有的数据
new_f.write(con)
if len(con) == 0:#当读取出来的字节长度为0，说明读取结束
break
#4关闭文件
old_f.close()
new_f.close()

‘’’
文件和文件夹的操作：在python中文件和文件夹的操作要借助os模块里面的相关功能
导入os模块： import os
使用os模块： os.函数名()
1.文件的操作
1.1文件重命名： os.rename(‘目标文件名’，‘新文件名’）
1.2删除文件： os.remove(‘目标文件名’)

2.文件夹操作
2.1创建文件夹： os.mkdir('文件夹名字‘)
2.2删除文件夹： os.rmdir('文件夹名字’)
2.3获取当前目录 os.getcwd() # print(os.getcwd())
2.4改变默认目录路径 os.chdir(目录)
import os
os.chdir(‘aa’)# 改变默认目录路径到aa
os.mkdir(‘bb’)# 成功在aa文件夹里创建bb文件夹
2.5获取某个文件夹下所有文件，返回一个列表：
os.listdir(‘文件夹名’)
2.6文件夹重命名： os.rename('原文件夹名‘，’新文件夹名‘）
2.7删除文件夹： os.remove('目标文件夹名’）

3.应用案例：
需求：批量修改文件名，既可添加指定字符串，又能删除指定字符串。
步骤：1.设置添加删除字符串的标识
2.获取指定目录的所有文件
3.将原有文件名添加/删除指定字符串，构造新名字
4.os.rename(‘新名字’)重命名
‘’’
#1.找到所有文件： 获取文件夹的目录列表—listdir()
import os
file_list = os.listdir()
print(file_list)
#2.构造名字
for i in file_list:
#new_name = ‘Python’ + 原文件i
new_name = ‘Python_’ + i
#3. 重命名
os.rename(i,new_name)

#添加和修改文件名
import os
#构造条件的数据
flag = 1
file_list = os.listdir()
print(file_list)
#2.构造名字
for i in file_list:
if:
#new_name = ‘Python’ + 原文件i
new_name = ‘Python_’ + i
elif flag == 2:
#删除前缀
num = len(‘Python_’)
new_name = i[num:]

#3. 重命名
os.rename(i,new_name)

‘’’
异常捕获
1.捕获常规异常：
基本语法：
try:
可能发生错误的代码
except:
如果出现异常执行的代码
2.捕获指定异常:
try:
可能发生错误的代码
except 异常类型(列如：NameError)：
print(‘出现了变量未定义的异常’)
3.捕获多个异常：
try:
可能发生错误的代码
except 异常类型(异常名1，异常名2，…3)：
print(‘出现了变量未定义的异常’)
4.捕获全部异常：Exception 是一种顶级异常
try:
可能发生错误的代码
except Exception as e:
print('出现异常了‘）

异常else：
try:
可能发生错误的代码
except 异常类型(列如：NameError)：
print(‘出现了变量未定义的异常’)
else:
print('没有出现异常，else下的代码继续执行’）

异常finally:表示无论是否发生异常都要执行–例如关闭文件等
try:
可能发生错误的代码
except 异常类型(列如：NameError)：
print(‘出现了变量未定义的异常’)
else:
print('没有出现异常，else下的代码继续执行’）
finally：
print(‘有没有异常都要执行’)

注意：异常是具有传递性的，当所有函数都没有捕获到异常的时候程序就会报错
即函数1出现异常，函数2调用函数1，然后main主函数里调用函数2，
如果设置异常捕获，则函数不会报错，如果函数没有设置异常捕获，则会报多个错误

‘’’

‘’’
模块：
模块就是一个python文件，里面有类，函数，变量等，我们可以导入模块快速实现某些功能

模块的导入形式：
import 模块名1，模块名2 —导入模块里所有功能
使用方法：模块名.功能名（）
from 模块名 import 类、变量、方法等—只使用该模块里一部分功能
from 模块名 import *—*表示全部的意思
使用方法：功能名（）
import 模块名 as 别名—别名是自己设置的
from 模块名 import 功能名 as 别名

模块使用：
模块名.功能名（）
‘’’