Python第七天（从入门到精通）

最新推荐文章于 2024-06-14 02:02:23 发布

西瓜瓜尓

最新推荐文章于 2024-06-14 02:02:23 发布

阅读量1k

点赞数 30

分类专栏： # Python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/l5261_1625/article/details/138975617

版权

Python 专栏收录该内容

7 篇文章 2 订阅

订阅专栏

文章目录

Python第7天

Python第7天

Python容器的分类

字符串
列表
元组
字典
集合

容器-字符串

基本操作

定义

name1 = 'Tom'    #该方式内部不能再包含单引号
name2 = "Rose"   #该方式内部可以包含单引号
str1 = '''I am Tom, 
        nice to meet you! '''  #该方式内部可以包含单引号

str2 = """ I am Rose, 
        nice to meet you! """  #该方式内部可以包含单引号

下标/索引的概念

在这里插入图片描述

1、将字符串存入内存中，这些字符串的每个字符是连续存放的，是挨着的
2、为了更加方便的去访问字符串中的每一个字符，python将每一个字符都进行了编号，编号从0开始
3、字符串中每个字符的编号被称为下标，索引，或者角标
4、之所以设计索引或者角标是为了以后能够快速的找到某个字符
5、如果一个字符串长度是n，则下标的范围是：0 到 n- 1
6、最后一个元素的索引也可以-1

代码1-访问每个元素

name = 'abcde'

print('------------使用下标访问---------------')
print(name[0])
print(name[1])
print(name[2])
print(name[3])
print(name[4])


print('------------使用for访问每个元素---------------')
for x in name:
    print(x)

print('------------使用for访问下标获取元素---------------')
for i in range(0,5):  # i是数字，当做索引
    print(name[i])

print('------------使用for访问下标获取元素2---------------')
for i in range(0, len(name)):  # 通过len获取字符串的长度，也就是字符串中字符的个数
    print(name[i])

切片

格式

#包含起始索引，不包含结束索引， 步长表示一次跳几个字符，如果步长为1表示一个一个截取，如果步长为2则就是一次跳过一个
字符串[起始索引:结束索引:步长]    #步长不写的话，默认就是1

代码1

card_id = '430421200112236789'

#截取出生年份
print(card_id[6:10:1])


name = 'abcdefghijk'
print(name[2:5:1]) # cde
print(name[2:5])   # cde  步长默认是1
print(name[2:7:2]) # ceg

print(name[:7:1])  # abcdefg  起始索引不写表示从0开始
print(name[2::])  # cdefghijk  结束索引不写，表示截取到最后
print(name[2:])  # cdefghijk  结束索引不写，步长不写，表示截取到最后

print(name[:-1])  # abcdefghij从开头截取到倒数第二个（-1表示倒数第一个）
print(name[:-3])  # abcdefgh 从开头截取到倒数第四个（-3表示倒数第三个）
print(name[-6:-3])  # fgh 从倒数第六个截取到倒数第四个

print(name[::-1])  #  kjihgfedcba 如果步长为-1，则将字符串翻转
print('-----------')
print(name[8:2:-1])  # ihgfed 从索引为8的字符开始截取到索引为3(不包含2)
print(name[8:2:-2])  # ige 将最后一个元素当做索引为0的元素，从右向左开始输出


file1 = 'ldlkdkl.txt'
file2 = 'a.py'

#判断文件是否是txt结尾
if file1[-3:] == 'txt':
    print('文件是txt')

代码2

s = 'Hello World!'

print(s[4])  # o 通过索引访问
print(s)     #  Hello World!
print(s[:])  #  Hello World!
print(s[1:]) #  ello World!
print(s[:5]) #  Hello
print(s[:-1]) # Hello World
print(s[-4:-1]) # rld
print(s[1:5:2]) #  el

方法

find方法

特点

 #在大串中查找是否包含某个子串，可以指定查找的区间，这个区间是包头不包尾
 #查到之后会返回该子串在大串中第一次出现的索引，如果没有找到则返回-1
字符串序列.find(子串, 开始位置下标, 结束位置下标)

操作

mystr = "abchelloworldandhellopythonhelloaaa"

rs1 = mystr.find('hello')  #在整个字符串中查找hello第一次出现的索引
print(rs1)

rs2 = mystr.find('hello',2,7)  #在索引为 2 - 6 之间查找是否包含hello,注意不包含索引7
print(rs2)

rs2 = mystr.find('hello',5)  #在索引为 2 -最后 之间查找是否包含hello,注意不包含索引7
print(rs2)

index方法

特点

#作用和find相同，只是如果没有找到子串，则报错
字符串序列.index(子串, 开始位置下标, 结束位置下标)

操作

print('------------index--------------')

rs1 = mystr.index('hello')  #在整个字符串中查找hello第一次出现的索引
print(rs1)

rs2 = mystr.index('hello',2,7)  #在索引为 2 - 6 之间查找是否包含hello,注意不包含索引7
print(rs2)

replace方法

特点

字符串序列.replace(旧子串, 新子串, 替换次数)

#1、功能是将字符串中的旧字符串替换为新字符串，默认是全部替换
#2、如果你指定了替换次数n，则会替换前n个子串
#3、替换之后，原来的字符串并没有发生变化，会发生新的字符串

操作

print('------------replace--------------')


str1 = '你好，我是写作小帮，有任何写作的问题，都可以向我提问，我们一起提高写作能力。'
print(str1)

str2 = str1.replace('写作','编程')  # 全部替换
print(str2)

str3 = str1.replace('写作','编程',2) # 替换前2个

print('------------先查找再替换--------------')
str1 = '你好，我是写作小帮，有任何写作的问题，都可以向我提问，我们一起提高写作能力'

rs1 = str1.find('写作')  #先查找
if rs1 != -1:
    str2 = str1.replace('写作','写代码')
    print('替换后的字符串:'+str2)
else:
    print('没有找到你要替换的内容')

split方法

特点

字符串序列.split(分割字符, num)
#1、功能是对字符串按照分隔符进行切割，默认是全部切割，指定num参数之后，可以切割前num次
#2、切割之后原字符串不变，返回切割后的内容
#3、split切割时，如果不指定分隔符，默认的分隔符是一切的空白符：一个空格，多个空格，\n、 \t

操作

print('------------split--------------')

str1 = '2024-12-24'

print(str1.split('-'))
print(str1.split('-',1))


str1 = '2024/12/24'
print(str1.split('/'))

print('-----------------------')
str1 = '2024                    12           24'
print(str1.split(' '))       # 只能切一个空格
print(re.split(' +',str1))   # 正则表达式，+表示一个空格或者多个空格都能切

endswith和startswith方法

特点

endswith:以什么结尾     字符串.endswith(子串)
startswith：以什么开头  字符串.startswith(子串)

操作

print('--------------------------')
str_file = 'abc.png.txt'

# 该方法用来判断是否以某个字符串结尾
# 如果匹配成功则返回True，否则返回False
rs1 = str_file.endswith('.png')
if rs1:
    print('该文件是以.png结尾')
else:
    print('该文件不是以.png结尾')
    
    
print('--------------------------')
str1 = 'helloworldpython'
str1.endswith()
if str1.startswith('hello'):
    print('字符串以hello开头')
else:
    print('字符串不以hello开头')

练习

# 练习题1：输入一个字符串，打印所有偶数位上的字符(下标是0，2，4，6…位上的字符)
str1 = input('请输入一个字符串:') #abcdefghijk
print(str1[::2])

print('-----------------------------')
for  i in range(0, len(str1)):
    if i % 2 == 0:
        print(str1[i])

print('-----------------------------')
# 练习题2：给定一个文件名，判断其尾部是否以".png"结尾
str_file = 'abc.png.txt'
if str_file[-4:] == '.png':
    print('该文件是以.png结尾')
else:
    print('该文件不是以.png结尾')

print('--------------------------')

str_file = 'abc.png.txt'
rs1 = str_file.find('.png',-4)  #表示从倒数第4个开始查到最后，看是否包含.png
if rs1 != -1:
    print('该文件是以.png结尾')
else:
    print('该文件不是以.png结尾')


print('--------------------------')
str_file = 'abc.png.txt'

# 该方法用来判断是否以某个字符串结尾
# 如果匹配成功则返回True，否则返回False
rs1 = str_file.endswith('.png')
if rs1:
    print('该文件是以.png结尾')
else:
    print('该文件不是以.png结尾')

容器-列表

语法

列表名称 = [数据1, 数据2, 数据3, 数据4, ...]
解释：
 列表名称: list1、list2、list_student...
 列表的标记符号是中括号
 列表中可以同时存放任何类型的数据
    
    
#列表是可变的，也就是列表中的数据是可以被修改的

操作

定义列表

# 1、定义一个空列表
#空列表必须有[]
list1 = []
print(list1)

# 2、定义一个有内容列表,类型一致
#如果列表中只存放一个类型的数据，则类似其他语言的数组
list2 = ['刘备', '关羽', '张飞']
print(list2)

# 3、定义一个有内容列表,类型不一致
list3 = ['刘备', 32, False, 120.5]
print(list3)

# 4、定义一个嵌套列表
#List列表和其他容器包括自己可以无限的嵌套
list4 = [['刘备', 32, False, 120.5],['关羽', 33, True, 130.5]]

下标/索引

概念

列表的底层存储形式和字符串都是一样的，其也是通过索引下标来对其进行引用的
list1 = ['刘备', '关羽', '张飞', '赵云', '张飞']
正索引: 0 1 2 3 4 
负索引: -1 -2 -3 -4

在这里插入图片描述

操作

# 1、定义列表
list1 = ['刘备', '关羽', '张飞', '赵云', '张飞']

# 2、使用索引来访问
"""
正索引: 0 1 2 3 4 
负索引: -1 -2 -3 -4 
"""
# 列表的名字[下标]
print(list1[0])   # 访问第一个元素
print(list1[4])   # 访问最后一个元素
print(list1[-1])  # 访问最后一个元素 使用 -1

print('---------------------------')
# 3、使用for来遍历列表
# for会将列表中的每一个元素依次的给x
for x in list1:
    print(x)

列表的遍历

概念

1、遍历就是将列表中的元素一个个的输出

代码

# 1、定义列表
list1 = ['刘备', '关羽', '张飞', '赵云', '张飞']

print('------------for遍历-1---------------')
# 2、使用for来遍历列表
# for会将列表中的每一个元素依次的给x
for x in list1:  #x是每一个元素数据，不是索引
    print(x)

print('------------for遍历-2---------------')
for i in range(0, len(list1)):  #i是每一个的索引
    print(list1[i])


print('------------while遍历---------------')
# while遍历可以直接访问到列表中每一个索引
i = 0
while i < len(list1):  # 0 1 2 3 4
    print(list1[i])
    i += 1

列表的切片

介绍

1、列表的切片规则和字符串是一样的
2、截取之后原来的列表不会发生变化，我们可以把截取后的列表存入一个新列表中，方便后期计算

操作


list_name = ['刘备', '关羽', '张飞', '赵云', '郭嘉','曹操','孙权','徐晃','典韦','黄忠']

list_name2 = list_name[2:5:1]  # 我们可以把截取后的列表存入一个新列表中，方便后期计算

print(list_name[2:5:1]) # ['张飞', '赵云', '郭嘉']
print(list_name[2:5])   # ['张飞', '赵云', '郭嘉']
print(list_name[2:7:2]) # ['张飞', '郭嘉','孙权']
print(list_name[:7:1])  # ['刘备', '关羽', '张飞', '赵云', '郭嘉', '曹操', '孙权']
print(list_name[2::])   # ['张飞', '赵云', '郭嘉', '曹操', '孙权', '徐晃', '典韦', '黄忠']
print(list_name[2:])    # ['张飞', '赵云', '郭嘉', '曹操', '孙权', '徐晃', '典韦', '黄忠']
print(list_name[:-1])   # ['刘备', '关羽', '张飞', '赵云', '郭嘉', '曹操', '孙权', '徐晃', '典韦']
print(list_name[:-3])   # 从头到倒数第4个 ['刘备', '关羽', '张飞', '赵云', '郭嘉', '曹操', '孙权']
print(list_name[-6:-3]) # 倒数第6个到倒数第4个   ['郭嘉', '曹操', '孙权']
print(list_name[::-1])  # 倒叙 ['黄忠', '典韦', '徐晃', '孙权', '曹操', '郭嘉', '赵云', '张飞', '关羽', '刘备']
print(list_name[:-3:-1])  # 倒叙 ['黄忠', '典韦', '徐晃', '孙权', '曹操', '郭嘉', '赵云', '张飞', '关羽', '刘备']


print(list_name)

列表的操作-添加

方法

添加元素  ("增"append, extend, insert)

#1、append方法
语法: 列表.append(新的元素) 
 #1.1每次将新的元素追加到原来列表的后边
 #1.2如果添加一个列表，则会将改列表当做一个整体添加

#2、extend方法
语法: 列表.extend(新的元素) 
  #2.1 每次将新的元素追加到原来列表的后边，但是会把任何添加的内容当做一个容器，如果数据是一个序列，则将这个序列的数据逐一添加到列表
  #2.2 该方法可以将两个列表进行合并
  
  
#3、insert方法
语法：列表.insert(索引，新数据)
  #3.1 insert和append、extend不同，insert可以指定添加到列表中的任意位置
  #3.3 insert添加时，添加位置的元素及后边的元素依次向后移，空出一个空位进行添加

在这里插入图片描述

操作

print('---------------append------------------')
# 1、定义列表
list1 = ['刘备', '关羽', '张飞', '赵云', '张飞']


# 2、向列表中追加元素: 曹操
list1.append('曹操')  #已经修改了原来的列表  ['刘备', '关羽', '张飞', '赵云', '张飞'，’曹操‘]
list1.append('孙权')  #已经修改了原来的列表
list1.append(18)  #添加其他类型，已经修改了原来的列表
list1.append(['周瑜','大乔'])  #这种添加会将小列表整体进行添加：['刘备', '关羽', '张飞', '赵云', '张飞', '曹操', '孙权', ['周瑜', '周瑜']]
list1.extend(['诸葛亮','吕布'])  #这种添加会将小列表整体进行添加：['刘备', '关羽', '张飞', '赵云', '张飞', '曹操', '孙权', ['周瑜', '大乔'], '诸葛亮', '吕布']
print(list1)


print('---------------extend------------------')

# 1、定义列表
list1 = ['刘备', '关羽', '张飞', '赵云', '张飞']

# 2、使用extend进行添加
list1.extend('小乔') #['刘备', '关羽', '张飞', '赵云', '张飞', '小', '乔'] 此时，会将小乔当做一个容器，进行拆分，将拆分后的 小  和 乔 分别进行添加
list1.extend(['小乔']) #['刘备', '关羽', '张飞', '赵云', '张飞', '小', '乔','小乔'] 此时，会将小乔当做一个容器，进行拆分，将拆分后的 小  和 乔 分别进行添加

print(list1)

print('---------------extend-列表合并------------------')

list1 = ['刘备', '关羽', '张飞', '赵云']
list2 = ['曹操', '郭嘉', '典韦', '徐晃']

list1.extend(list2)  #['刘备', '关羽', '张飞', '赵云', '曹操', '郭嘉', '典韦', '徐晃']

print(list1)
print(list2)


print('---------------insert------------------')

# 1、定义列表
list1 = ['刘备', '关羽', '张飞', '赵云']

#2、在索引为1的位置添加 曹操
list1.insert(1,'曹操')  # ['刘备', '曹操', '关羽', '张飞', '赵云']
print(list1)

list1.insert(1,['曹操','孙权']) # ['刘备', ['曹操', '孙权'], '曹操', '关羽', '张飞', '赵云']
print(list1)

#如果要添加的索引值超过了列表的最大索引，则会将数据添加到最后
list1.insert(100,'刘协') # ['刘备', ['曹操', '孙权'], '曹操', '关羽', '张飞', '赵云', '刘协']
print(list1)

列表的操作-查找

在这里插入图片描述

index

语法

语法：列表序列.index(数据, 开始位置下标, 结束位置下标)

解释：
 数据：是要查找的内容
 开始位置下标, 结束位置下标：要查找的区间索引，包头不包尾

代码

print('---------------index------------------')
# 1、定义列表
list1 = ['刘备', '关羽', '张飞',['孙权','黄盖'], '赵云','曹操', '郭嘉', '典韦', '徐晃']

"""
语法：列表序列.index(数据, 开始位置下标, 结束位置下标)
"""

# 2、查看列表中是否有赵云
rs1 = list1.index('赵云')  # 如果找到返回第一个索引值，找不到则报错
print(rs1)

# 3、查看列表中是否有孙权
rs1 = list1.index('孙权')  # 找不到，因为index只能看到['孙权','黄盖']这个子列表整体，看不到里边的内容
print(rs1)

# 3、查看列表中是否有['孙权','黄盖']
rs1 = list1.index(['孙权','黄盖'])  # 可以找到
print(rs1)

count

语法

#count()方法：统计指定数据在当前列表中出现的次数
列表序列.count(数据)

#解释：
  数据：你要统计的内容
  该方法返回统计的次数

代码

print('---------------count------------------')

list1 = ['刘备', '关羽', '张飞',['孙权','黄盖','张飞'], '赵云','曹操', '郭嘉', '典韦','张飞', '徐晃']

# 统计list1列表中有几个张飞
print(list1.count('张飞'))    # 2 次

in和not in

语法

数据 in  列表  #判断数据是否在列表中，如果是返回True，否则返回False
数据 not in  列表  #判断数据是否不在列表中，如果是返回True，否则返回False

代码

print('---------------in和not ------------------')
list1 = ['刘备', '关羽', '张飞',['孙权','黄盖','张飞'], '赵云','曹操2', '郭嘉', '典韦','张飞', '徐晃']
list2 = ['刘备', '关羽', '张飞',['孙权','黄盖','张飞'], '赵云','曹操', '郭嘉', '典韦','张飞', '徐晃']

#判断曹操是否在list1中
print('曹操' in list1)  # list1.in('曹操')
#判断曹操是否不在list1中
print('曹操' not in list1)


if '曹操' in list1 and 3 >2:
    print('曹操在列表中')
else:
    print('曹操不在列表中')

列表的操作-删除

在这里插入图片描述

del：一般知道要删除的数据索引，用该方法 ，销毁列表，也可以该方法
pop：一般删除最后一个元素，用该方法, 或者知道索引，也可以用该方法
remove： 知道要删除数据的内容，用该方法
clear： 清空表内容，用该方法

del方法

语法

del 列表[要删除的数据索引] # 将索引对应元素的数据删除
del 列表  # 将整个列表销毁,列表不存在

操作

print('---------------del------------------')
# 1、定义列表
list1 = ['刘备', '关羽', '张飞',['孙权','黄盖'], '赵云','曹操', '郭嘉', '典韦', '徐晃']

# 2、在list1列表删除典韦
del list1[-2]  # 删除list1中索引为1位元素
# del list1[100]  # 索引下标越界
print(list1)

# 3、在list1列表删除内嵌的列表：['孙权','黄盖']
del list1[3]
print(list1)

print('-----------')
# 4、将整个列表销毁
del list1
print(list1)  # 报错，因为列表已经被删除

pop方法

语法

列表序列.pop()    # 弹出列表最后一个数据，并返回
列表序列.pop(下标) # 弹出（获取）指定索引的数据，并将数据返回

#pop其实是弹栈或者出栈，是一种先进后出的数据结构

代码

print('---------------pop------------------')
"""
列表.pop(索引)
"""
# 1、定义列表
list1 = ['刘备', '关羽', '张飞',['孙权','黄盖'], '赵云','曹操', '郭嘉', '典韦', '徐晃']

print(list1.pop())   #  取出最后一个元素，并返回 ，原列表会被修改
print(list1.pop(1))  #  取出索引为1元素, 并返回 ，原列表会被修改

print(list1)  # 原列表少了被取出的元素

remove方法

语法

列表.remove(要删除的数据) # 在列表中删除指定的数据，但是只能删除第一次遇到的数据

代码

print('---------------remove------------------')
"""
列表.remove(要删除的数据)
该方法没有返回值
"""
# 1、定义列表
list1 = ['刘备', '关羽', '张飞',['孙权','黄盖'], '赵云','曹操', '郭嘉', '关羽', '徐晃']
print(list1)

# 2、在list1列表中删除关羽
list1.remove('关羽')
print(list1)

# 3、在list1列表中删除 ['孙权','黄盖']
list1.remove(['孙权','黄盖'])
print(list1)

# 4、删除一个不存在的元素
if '诸葛亮' in list1:  # 判断 诸葛亮是否存在，如果存在则删除，否则不存在，删除则报错
    list1.remove('诸葛亮')

clear方法

语法

列表.clear()  #将列表的内容清空，留下空列表 []

代码

print('---------------remove------------------')
"""
列表.clear()
"""
# 1、定义列表
list1 = ['刘备', '关羽', '张飞',['孙权','黄盖'], '赵云','曹操', '郭嘉', '关羽', '徐晃']

# 2、清空list1列表
list1.clear()
print(list1)

列表的操作-修改

修改操作

语法

列表[索引] = 新值 #将指定索引的值修改为新值


列表序列.reverse()：将字符串翻转


列表序列.sort(  reverse=False)
注意：reverse表示排序规则，reverse = True降序， reverse = False升序（默认)

代码

print('-----------------根据索引修改---------------------')
# 1、定义列表
list1 = ['刘备', '关羽', '张飞',['孙权','黄盖'], '赵云','曹操', '郭嘉', '典韦', '徐晃']
print(list1)

# 2、将张飞修改为张苞
list1[2] = '张苞'
print(list1)

# 3、将['孙权','黄盖'] 改为 ['孙坚','黄盖']

list1[3] = ['孙坚','黄盖']
print(list1)

print('-----------------反转---------------------')
"""
列表名.reverse()
"""

# 1、定义列表
list1 = ['刘备', '关羽', '张飞',['孙权','黄盖'], '赵云','曹操', '郭嘉', '典韦', '徐晃']
print(list1)

# 2、对以上列表进行翻转
list1.reverse()
print(list1)

print('--------------------------------------')
"""
列表序列.sort(reverse=False)
注意：reverse表示排序规则，reverse = True降序， reverse = False升序（默认）
      列表中一般是数字和字母
"""
# 1、定义列表
list1 = [34,524,56,77,12,66,22]
print(list1)

# 2、对列表进行排序-升序
list1.sort()  # 默认是升序
print(list1)

list1.sort(reverse=False)  # 指定升序
print(list1)

# 3、对列表进行排序-降序
list1.sort(reverse=True)  # 指定降序序
print(list1)

# 4、对有英文字母的列表进行排序-升序
# 如果是英文排序，则按照单词在字典中出现的先后顺序来排
# 两个单词如果前边一样一样，哪个短，哪个在前边
list1 = ['student','hello','123','zero','aba','door','23','about','teachr','female','abandon']
list1.sort(reverse=False)  # 指定升序
print(list1)

列表的嵌套

概念

列表的嵌套可以理解为一个大列表中嵌套了小列表

代码

list1 = [
    ['刘备','关羽','张飞'], # 这个小列表名字是：list1[0]
    ['宝玉','黛玉','宝钗'], # 这个小列表名字是：list1[1]
    ['宋江','智深','武松','门庆'], # 这个小列表名字是list1[2]
    ['悟空','悟净','悟能']  # 这个小列表名字是：list1[3]
]

# 访问智深
print(list1[2][1])

# 将 悟净 修改为 八戒
list1[3][1] = '八戒'
print(list1)

print('---------------对嵌套的列表进行遍历-----------------------')

for x in list1: # x是大列表中包含的每一个小列表 ['刘备','关羽','张飞']
    for name in  x: # name是小列表中每一个元素
        print(name)


print('--------------------------------------')


list1 = [
    ['刘备',['关羽','诸葛'],'张飞'], # list1[0]
    ['宝玉','黛玉','宝钗'], # list1[1]
    ['宋江','智深','武松','门庆'], # list1[2]
    ['悟空','悟净','悟能']  # list1[3]
]

#访问 诸葛
print(list1[0][1][1])

容器-元组

概念

1、在python中列表的内容是可以修改的   list1 =  [1,2,3]
2、在python中元组的内容不可修改      tuple1 = (1,2,3)
3、在python中元组的关键字是：tuple

元组的定义

元组的名字 = (元素值1,元素值2...)

# 1、定义元组
t1  = (10,20,30)
t2  = ('刘备',20,True)

# 2、定义空元组
t3 = ()
t4 = tuple() #醒目

# 3、定义只有一个元素的元组
t5 = (10)  # 这个不是元组，是int类型
print(type(t5))  # <class 'int'>

t6 = (10,) # 这个是元组,必须加,
print(type(t6))  # <class 'tuple'>

元组的操作-索引访问

在这里插入图片描述

如果元组嵌套列表，则小列表中的内容可以修改，但是该列表的整体不可以修改

# 1、定义元组
#列表和元组之间可以无限的嵌套
t1 = ('刘备',['孙权','黄盖','陆逊','吕蒙'], '关羽',(1,2,3) ,'张飞', '赵云','曹操', '郭嘉', '典韦', '徐晃')

# 2、根据索引来查找 关羽
print(t1[2])
# 3、根据索引来查找 陆逊
print(t1[1][2])

# 4、尝试去将刘备修改为刘禅
t1[0] = '刘禅'   #不支持 报错

# 5、尝试去将孙权修改为孙坚
t1[1][0] = '孙坚' # 支持 可以修改
print(t1)

# 6、尝试去将索引为1的列表改为其他列表
t1[1] = ['司马懿','司马昭']  #不支持 报错
print(t1)

# 7、元组切片
# 元组的切片和列表相同
t1 = ('刘备','张飞', '赵云','曹操', '郭嘉', '典韦', '徐晃')

print(t1[2:5:1])     # ('赵云', '曹操', '郭嘉')
print(t1[-2:-5:-1])  # ('典韦', '郭嘉', '曹操')

# 1、定义元组
t1 = ('刘备','张飞', '赵云','曹操', '郭嘉', '典韦', '徐晃','曹操','曹操')

# 2、在列表中查找曹操，并返回第一次出现对应的索引,找不到就报错
print(t1.index('曹操'))

# 3、统计曹操在元组中出现的次数
print(t1.count('曹操'))

# 4、统计元组的长度
print(len(t1))

print('-----------字符串-------------')
str1 = "hello"
str2 = "world"

# 拼接字符串
print(str1 + str2)
# 将字符串进行复制10份
print(str1 * 10)

print('-----------列表-------------')

list1 =  ['刘备', '关羽', '张飞']
list2 =  ['曹操', '郭嘉', '典韦']

# 拼接列表
list3 = list1 + list2
print(list1 + list2)

# 将列表进行复制10份
print(list1 * 10)


print('-----------元组-------------')

t1 = ('刘备', '关羽', '张飞')
t2 = ('曹操', '郭嘉', '典韦')

# 拼接元组
t3 = t1 + t2
print(t1 + t2)

# 将元组进行复制10份
t4 = t1 * 10
print(t1 * 10)

容器-字典

概念

在这里插入图片描述

1、python中的字典的关键字： dict(dictionary)
2、python中的字典用的是{}
3、python中的字段元素是一个个键值对,键值对之间用逗号分隔，键和值之间用冒号
4、python中的键一般是字符串
5、python中字典一般是根据键找值
6、python中的字段键值对的顺序无所谓，因为我们根据键找值，而不是根据下标来找
7、python的字典中没有下标的概念

定义

# 1、定义字典
"""
语法： 字典名 = {键:值,键：值....}
字典中的键不能重复，否则后边的值会替换掉前边的值
"""
d1 = {'name': '刘备','name':'刘禅', 'age': 18, 'sex': '男', 'address': '河北'}
d2 = {}      # 空字典
d3 = dict()  # 空字典

print(d1)
print(d2)
print(d3)

# 2、字典的嵌套
d4 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北','firends':{'name':'刘璋','age':19}}
print(d4)


d5 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北','dest_city':['北京','广州','纽约']}
print(d5)

d6 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北','dest_city':('北京','广州','纽约')}
print(d6)


list1 = [{'name': '刘备', 'age': 18},{'name':'刘璋','age':19}]
print(list1)


t1 = ({'name': '刘备', 'age': 18},{'name':'刘璋','age':19})
print(t1)

操作-增加和修改

语法

字典名字[键] = 值

特点

如果这个键存在，则修改原来的值，如果键不存在，则添加新的减值对

操作

# 1、定义字典
"""
语法： 字典名 = {键:值,键：值....}
字典中的键不能重复，否则后边的值会替换掉前边的值
"""
d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}

# 2、向字典中添加一个新的键值对 , 键不存在
print(d1)

# 3、向字典中添加一个新的键值对 , 键存在将河北修改为河南
d1['address'] = '河南'
print(d1)

# 4、修改字典嵌套中的容器数据
#将北京修改为上海
d2 = {'name': '刘备', 'sex': '男', 'address': '河北','dest_city':['北京','广州','纽约']}
d2['dest_city'][0] = '上海'
print(d2)

# 5、修改字典嵌套中的容器数据
#将刘璋修改为刘表
d3 = {'name': '刘备', 'address': '河北','firends':{'name':'刘璋','age':19}}
d3['firends']['name'] = '刘表'
print(d3)


# 6、修改字典嵌套中的容器数据
#将刘璋修改为刘表
list4 = [{'name': '刘备', 'age': 18},{'name':'刘璋','age':19}]
list4[1]['name']  = '刘表'
print(list4)

操作-删除和清空

语法

#删除
del 字典名[键名]  

#清空
字典名.clear

特点

del操作和列表类似，只是这里不能用索引，要用键名 ,如果要删除的键不存在，则报错

操作


print('------------删除和清空------------')

d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}

# 删除 age这个键值对
del d1['age']
print(d1)

# 删除 firends这个键值对
d2 = {'name': '刘备', 'address': '河北','friends':{'name':'刘璋','age':19}}
del d2['friends']
print(d2)

# 清空d1
d1.clear()
print(d1)

# 销毁字典d1
del d1
print(d1)

操作-查询

在这里插入图片描述

根据键获取值

语法

#方式1
字典名字[键]

#方式2
字典名.get(键,默认值)  #根据键获取值，如果键不存在，则返回默认值

代码

print('------------查询-根据键获取值------------')
# 1、定义字典

d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}

# 2、根据name的键获取对应的值

# 方式1 - 键存在
print(d1['name'])

# 方式2 - 键存在
print(d1.get('name'))

# 方式3 - 键不存在,没有默认值，则返回None
print(d1.get('city'))

# 方式4 - 键不存在,有默认值，则返回默认值
print(d1.get('city','北京'))

获取所有的键和值

语法

字典名.keys()   #获取字典所有的键，将这些键存入封装列表并返回
字典名.values() #获取字典所有的值，将这些键存入封装列表并返回

代码

print('------------查询-获取所有的键------------')
d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}

# 获取所有的键,返回一个封装好的列表:
list1 = d1.keys()
print(list1) # d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}


print('------------查询-获取所有的值------------')
d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}

# 获取所有的值,返回一个封装好的列表:
list1 = d1.values()
print(list1)

获取键值对-items

语法

字典名.items()   #获取字典所有的键值对，返回一个封装列表中，列表中存放的是元组

代码

d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}
print(d1.items()) # dict_items([('name', '刘备'), ('age', 18)])

#我们可以使用强制，将返回的列表转为普通列表(脱马甲)
list(d1.items())

操作-遍历

print('------------对字典进行遍历------------')
# 1、定义字典
d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}

print('--------方式1--------')
for key in d1.keys(): #获取所有的键 dict_keys(['name', 'age', 'sex', 'address', 'phone'])
    print(f'{key}----{d1.get(key)}')

print('--------方式2--------')
list1 = list(d1.keys())  #获取所有的键，并强转成列表，脱去马甲
for key in list1:
    print(f'{key}----{d1.get(key)}')


print('--------方式3--------')
for key in d1:  # 如果直接对字典遍历，则可以直接获取key
    print(f'{key}----{d1.get(key)}')
    
    
print('--------方式4--------')

d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}
print(d1.items()) # dict_items([('name', '刘备'), ('age', 18)])

list1 = list(d1.items())  # [('name', '刘备'), ('age', 18)]
for x in list1: # x就是一个元组:('name', '刘备')
    print(f'{x[0]}----{x[1]}')

print('--------方式5--------')
d1 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北', 'phone': '138'}
for key,value in d1.items(): # dict_items([('name', '刘备'), ('age', 18)])
    print(f'{key}----{value}')

在这里插入图片描述

容器-集合

概念

1、python中的集合关键字：set
2、python集合中的元素不能重复，数据存入的顺序和取出的顺序不能保持一致
3、python中集合的样例：s1 = {10, 20, 30, 40, 50}

操作

定义集合

# 1、定义一个空集合
s1 = set()
print(type(s1))

# 2、定义一个非空集合

# 2.1 列表中的元素可以重复，而且数据存入的顺序的和取出的顺序是一致的
list1 = ['刘备', '关羽', '张飞', '赵云', '张飞']
print(list1)

# 2.1 集合中的元素不可以重复，自动去重，而且数据存入的顺序的和取出的顺序是不一致的
set1 = {'刘备', '关羽', '张飞', '赵云', '张飞'}
print(set1)

添加元素

语法

集合名字.add(值)     # 一次只能添加一个值
集合名字.update(值)  # 一次可以添加一个列表，或者一个集合 ，或者一个元组

代码

# 5、向集合添加元素
print('---------add---------')
set1 = set()
set1.add('刘备')
set1.add('关羽')
set1.add('曹操')
print(set1)

print('---------update---------')
set1 = {1,4,5}

set1.update([1,2,8])
set1.update({1,2,9})
set1.update((1,2,10))

删除元素

概念

集合名字.remove(要删除的元素)  # 如果删除的元素不存在，则报错
集合名字.discard(要删除的元素) # 如果删除的元素不存在，则返回None

代码

print('---------删除----------')
# 6、从集合删除张飞
set1 = {'刘备', '关羽', '张飞', '赵云', '张飞'}
set1.remove('张飞')
set1.discard('关羽')
print(set1)

修改元素

概念

集合中没有提供专门的修改方法，如果要对元素进行修改，则需要先删除，再添加

代码

# 先删除，再插入
set1 = {'刘备', '关羽', '张飞', '赵云', '张飞'}
set1.discard('张飞')  # discard删除数据时，如果数据不存在，则不会报错，remove会报错
set1.add('张苞')
print(set1)

查询元素

概念

集合由于是乱序的，所以集合中不能使用下标来访问，但是可以遍历

代码

print('---------查询----------')
set1 = {'刘备', '关羽', '赵云', '张飞'}

for x in set1:
    print(x)

在这里插入图片描述

容器的公共方法

在这里插入图片描述

操作

# 1、定义容器
list1 = [23,45,12,4,34]
tuple1 = (23,45,12,4,34)
set1 = {23,45,12,4,34}
dict1 = {12: '刘备', 34: 18, 4: '男', 45: '河北', 23: '138'}
dict2 = {'name': '刘备', 'age': 18, 'sex': '男', 'address': '河北'}


print('----------------max和min------------------')
# 2、求容器最大值
print(max(list1))
print(max(tuple1))
print(max(set1))
print(max(dict1))  #字典求最大值，返回的是键的最大值

print('----------------range------------------')
for i in range(0,10,2):
    print(i)  # 0 2 4 6 8

print('--------------enumerate-列表---------------')
# 3、调用enumerate函数来操作容器
"""
返回的值：
(0, 23)
(1, 45)
(2, 12)
(3, 4)
(4, 34)

enumerate会把容器元素加上索引存入一个二元组返回
"""
for x in enumerate(list1):  #(0, 23)
    print(x)

for index,value in enumerate(list1):  #(0, 23)
    print(f'{index}----{value}')

print('--------------enumerate-元组---------------')
for index,value in enumerate(tuple1):  #(0, 23)
    print(f'{index}----{value}')

print('--------------enumerate-集合(意义不大)---------------')

for index,value in enumerate(set1):  #
    print(f'{index}----{value}')

print('--------------enumerate-字典---------------')
"""
0----name
1----age
2----sex
3----address

如果是字典，则只给键加索引
"""
for index,value in enumerate(dict2):  #
    print(f'{index}----{value}')

容器推导式

列表推导式

语法

变量名 = [表达式 for 变量 in 列表]
变量名 = [表达式 for 变量 in 列表 if 条件]
变量名 = [表达式 for 变量 in 列表 for 变量 in  列表]
变量名 = [表达式 for 变量 in 列表 for 变量 in  列表 if 条件]

特点

1、列表推导式最终的目的是得到一个数字序列的列表
2、列表推导式是对代码的一种简化，也可以用普通代码来实现

代码

# 1、创建一个0-9的列表
list1 = [0,1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list1)

print('-----------------------------')
# 2、使用循环来实现
list1 = []
for i in range(10):
    list1.append(i)
print(list1)


print('-------------列表生成式-0-9----------------')
list1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list1)

print('---------------------------')
list1 = [ i*2 for i in range(10)]
print(list1)

print('-------------列表生成式-0-9偶数----------------')

list1 = [0,2,4, 6,8]
print(list1)
print('---------------------------')
list1 = [ i for i in range(0,10,2)]
print(list1)

print('-----------用代码演示----------------')
list1 = []
for i in range(0,10,2):
    list1.append(i)


print('---------------------------')
#1、先for取出i， 2、拿到i去if判断  3、满足满足条件的值给前边i，然后加入列表
list1 = [ i for i in range(0,10) if i %2 == 0 ]
print(list1)

print('-----------用代码演示----------------')
list1 = []
for i in range(0,10):
    if i %2 == 0:
        list1.append(i)

print('-------------列表生成式-(1,0)(1,1)----------------')

list1 = [(i, j) for i in range(3) for j in range(3) if i % 2 ==0 and j % 2 ==0 ]
print(list1)

print('-----------用代码演示----------------')
list1 = []
for i in range(3):
    for j in range(3):
        if i % 2 == 0 and j % 2 == 0:
            list1.append((i,j))

print(list1)

字典推导式

语法

字典名 = {键表达式:值表达式   for 变量 in 容器 }

特点

1、字典推导式最终的目的是得到一个字典
2、字典推导式是对代码的一种简化，也可以用普通代码来实现

代码

list1 = ['name', 'age', 'gender']
list2 = ['Tom', 20, 'man']

print('---------用代码来实现-------------')
dict1 = {}
for i in range(0,len(list1)):
    dict1[list1[i]] = list2[i]
print(dict1)

print('---------用字典推导式来实现-------------')

dict1 = {list1[i]:list2[i] for i in range(0,len(list1))}
print(dict1)

集合推导式

语法

变量名 = {表达式 for 变量 in 列表}
变量名 = {表达式 for 变量 in 列表 if 条件}
变量名 = {表达式 for 变量 in 列表 for 变量 in  列表}
变量名 = {表达式 for 变量 in 列表 for 变量 in  列表 if 条件}

特点

#集合推导式跟列表推导式非常相似，唯一区别在于用 { } 代替 [ ]
1、集合推导式最终的目的是得到一个数字序列的集合
2、集合推导式是对代码的一种简化，也可以用普通代码来实现
3、集合生成之后会自动去重

代码


# 1、创建一个0-9的列表
list1 = {0,1, 2, 3, 4, 5, 6, 7, 8, 9}
print(list1)


print('-------------列表生成式-0-9----------------')
list1 =  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
print(list1)

print('---------------------------')
list1 = {i for i in range(10)}
print(list1)

print('-------------列表生成式-0-9偶数----------------')
list1 = {0,2,4, 6,8}
print(list1)

print('---------------------------')
list1 = { i for i in range(0,10,2)}
print(list1)

print('---------------------------')
#1、先for取出i， 2、拿到i去if判断  3、满足满足条件的值给前边i，然后加入列表
list1 = { i for i in range(0,10) if i %2 == 0 }
print(list1)


print('-------------列表生成式-(1,0)(1,1)----------------')

list1 = {(i, j) for i in range(3) for j in range(3) if i % 2 ==0 and j % 2 ==0 }
print(list1)

Python的函数

概念

1、函数是一个封装好的，实现特定功能的一段代码，我们可以给这段代码起一名字，以后用的时候，直接使用名字调用即可
2、函数在有些语言中又被称为方法，函数：function，方法：method
  Python中：函数和方法是不用的
  有些语言：函数就是方法，方法就是函数
3、函数体现了代码的封装性和复用性
4、在封装函数时，尽量让一个函数做的事情越少越好，这样复用性越强

函数定义

有参数，有返回值

def 函数名(参数):  #形参（形式参数）
    函数体
    ...
    return 返回值

# 1、函数的定义-有参数有返回值
# 1.1 定义函数：求两个数的和
def add(num1, num2):
    sum = num1 + num2
    return sum


# 1.2调用函数-方式1
print('-------方式1--------')
result = add(10, 20)
print(f'两个数的和是：{result}')

result = add(-330, 478)
print(f'两个数的和是：{result}')
print('-------方式2--------')
# 1.2调用函数-方式2
print(add(10, 20))
print(add(-330, 478))

有参数，无返回值

def 函数名(参数):  #形参（形式参数）
    函数体
    ...

# 1、函数的定义-有参数无返回值
# 1.1 定义函数：求两个数的和，直接打印，不返回
def add(num1, num2):
    sum = num1 + num2
    print(f'两个数的和是：{sum}')


# 2、调用函数
print('---------方式1----------')
add(10, 20)

print('---------方式2----------')
print(add(10, 20))  #这种调用是错误的，因为函数没有返回值

无参数，无返回值

def 函数名():  
    函数体
    ...

# 1、函数的定义-无参数无返回值
# 1.1 定义函数：打印3次helloworld

def print_hello():
    print('Hello World')
    print('Hello World')
    print('Hello World')

# 2、调用函数
print('---------方式1----------')
print_hello()

print('---------方式2----------')
#print(print_hello())  #这样调用不可以，因为函数没有返回值

无参数，有返回值

def 函数名():  
    函数体
    ...
    return 返回值

# 1、函数的定义-无参数有返回值
# 1.1 定义函数：产生1-100之间的随机数返回
import random

def get_random_int():
    random_num = random.randint(1,100)
    return random_num

# 2、调用函数
print('---------方式1----------')
num = get_random_int()
print(f'得到的随机数是：{num}')

print('---------方式2----------')
print(get_random_int())

函数的操作

代码1

# 定义一个函数，传入num，就输出num次的hello world
def my_print(num):
    for i  in range(num):
        print('Hello Word')

# 调用函数
print('-----------------------------')
my_print(3)
print('-----------------------------')
my_print(30)

代码2

# 求一个列表的最大值

def get_list_max_value(list_name): # list_name = [2,3,1,5]
    max_value = list_name[0]
    for x in list_name:
        if x > max_value:
            max_value = x
    return max_value


 # 调用函数
list_name = [2, 3,34, 1, 5]

print('---------方式1----------')
max_value = get_list_max_value(list_name)

print(f'列表的最大值是：{max_value}')

print('---------方式2----------')
print(f'列表的最大值是：{get_list_max_value(list_name)}')

函数的说明文档

解释

我们可以在定义函数时，给函数编写一个说明书，和注释类似
注释的话必须要看到函数的定义源码，如果你不想让别人看到源代码还想让别人知道你函数的用法，则可以使用文档说明

语法

def 函数名（参数）:
    """
     函数的文档说明
    """
    函数体

def add(num1, num2):
    """
    该函数求两个数的和
    :param num1: 第一个参数
    :param num2: 第二个参数
    :return:  返回和
    """
    sum = num1 + num2
    return sum

查看文档注释
```
help(函数名)
```

函数的参数

形参和实参

形参

# 定义函数时同时定义了接收用户数据的参数a和b，a和b是形参 
def add(a, b): 
      result = a + b 
      print(result)

实参

add(10,20)  #在这里10和20是实际参数

函数的返回值

描述

1、一个函数可以通过return来返回值
2、如果一个函数没有返回值，则通过return可以让函数提前返回结束

操作1-返回两个值

# 求一个列表的最大值和最小值，并返回

def get_list_max_value(list_name): # list_name = [2,3,1,5]
    # 把第一个数当最大值
    max_value = list_name[0]
    min_value = list_name[0]

    for x in list_name:
        #如果遍历的数比最大值还大，就赋给最大值
        if x > max_value:
            max_value = x

        if x < min_value:
            min_value = x

    # 函数默认返回的是一个元组:(min_value,max_value)
    return min_value,max_value



list1 = [44,556,667,7,8,8,234,455]

print('-----------------方式1-------------------')
min_value,max_value = get_list_max_value(list1)
print(f'最大值：{max_value}')
print(f'最小值值：{min_value}')

print('-----------------方式2-------------------')
result = get_list_max_value(list1)  #<class 'tuple'>
print(type(result))
print(f'最小值：{result[0]}')
print(f'最大值：{result[1]}')

print('-----------------方式3-------------------')
print(f'最小值：{get_list_max_value(list1)[0]}')
print(f'最大值：{get_list_max_value(list1)[1]}')

操作2-没有返回值，使用return

#对手机号进行加密
def iphone_jiami(iphone):
    if len(iphone) != 11:  #如果手机号长度不是11位，则直接返回
        return
    print('对手机号进行脱敏1')
    print('对手机号进行脱敏2')
    print('对手机号进行脱敏3')

iphone_jiami()

函数的嵌套调用

一个函数可以在内部继续调用其他函数，当调用函数时会进入到另一个函数，执行完之后，返回到原来调用的位置

def testA():
    print('---- testA start----')
    testB()
    print('---- testA end----')

def testB():
    print('---- testB start----')
    print('这里是testB函数执行的代码...(省略)...')
    print('---- testB end----')

testA()

# 1、定义函数，打印一条横线
def print_line():
    print('-'*40)  #---------------------------

# 2、定义函数，打印指定的行数
def print_nums(num):
    for i in range(num):
        print_line()


# 调用函数
print_nums(10)  # 打印10行
print_nums(20)  # 打印20行

局部变量和全局变量

局部变量

概念

在函数内部定义的变量称为局部变量，只能在函数内部调用，对函数外部不起作用

代码

# 1、定义局部变量
def func1():
    a = 123   # 局部变量：该变量只能在函数的内部使用
    print(f'函数内部:{a}')


func1()
print(f'函数外部:{a}') # 在函数的外部不能访问函数内部的局部变量

全局变量

概念

在函数外部定义的变量称为全局变量，可以在函数定义之后任何位置调用，定义之前不能使用

代码

# 定义全局变量
a = 888

def func1():
    print(f'函数内部:{a}')


func1()
print(f'函数外部:{a}') # 在函数的外部不能访问函数内部的局部变量

global关键字

概念

如果在函数的内部，你想修改全局变量，则需要做声明: global a，这样可以告诉解释器，这里的a不是我自己局部的变量，而是全局变量a

代码

a = 100

def testA():
      print(a)


def testB():
      global a  # global用来声明这里的a不是我自己局部的变量，而是全局变量a
      a = 200   # 如果不加global，则python认为你这里的a是局部的a，和全局a没有关系
      print(a)


testA()
testB()

print(f'主代码：a={a}')

函数返回多个值

概念

1、python的函数既可以返回一个值，也可以一次返回多个值
2、python的函数返回多个值时，可以返回：列表、元组、字典、集合

代码

# 函数返回多个值- 返回元组
def func1():
    return 1, 2

# 函数返回多个值- 返回列表
def func2():
    return [1,2]

# 函数返回多个值- 返回字典
def func3():
    return {'name':'刘备','age':18}


# 函数返回多个值- 返回集合
def func4():
    return {1,2,3}


print(func1())
print(func2())
print(func3())
print(func4())

函数的参数类型

位置参数

概念

位置参数就是传参时必须按照参数的位置和个数给出实参，如果参数的个数和形参不一致，则直接报错

代码

def func(name,age):
    print(f'{name}---{age}')

func('刘备',18)

关键字参数

概念

1、关键字传参是通过参数的名字来进行，和参数的顺序无关：参数名  = 实参值
2、关键词传参不用按照参数的顺序
3、如果有多个参数，前边使用位置传参，后边可以使用关键字传参
4、如果有多个参数，一旦前边使用了关键字传参，则后边必须也全部使用关键字传参

在这里插入图片描述

代码

# 关键字传参

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

user_info('Rose',20, '女')
user_info('Rose',age=20, gender='女')

user_info('小明',gender='男',age=16)
user_info('小明',gender='男')  # 这里没有给age赋值，会报错


user_info('刘备',19,gender='男')  # 可以
user_info(name='刘备',19,'男')    # 报错

默认值参数

概念

1、为参数提供默认值，调用函数时可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）
2、默认值参数的后边都必须是默认值参数

代码

print('------------默认值传参-------------')
def user_info1(name='张三', age=19, gender='男'):
    print(f'您的名字是{name}年龄是{age}，性别是{gender}')

user_info1()  # 一个参数不给
user_info1('刘备')  # 给一个参数
user_info1('刘备',10)  # 给2个参数
user_info1('刘备',10,'女')  # 给3参数

user_info1(age=17)  # 关键字参数


def user_info1(name='张三', age=19, gender=None):
    print(f'您的名字是{name}年龄是{age}，性别是{gender}')


def user_info2(name, age=19, gender='男'):
    print(f'您的名字是{name}年龄是{age}，性别是{gender}')

def user_info3(name, age, gender='男'):
    print(f'您的名字是{name}年龄是{age}，性别是{gender}')

不定长传参

位置传参

概念

语法：def 函数名(*参数名)
      函数体
    
#解释：
 1、对于不定长参数，你可以不传入参数，也可以传入1个、2个...n个参数
 2、对于不定长参数，你传入的参数会被封装到元组中

代码

print('-----------------------------')
#传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是位置传递

def user_info(*args):
	print(args)

user_info('TOM')
user_info('TOM'，18)

print('-----------------------------')
def add(*tuple1):
    sum = 0
    for x in tuple1:
       sum += x
    print(f'sum ={sum}')

add()
add(1)
add(1,2)
add(1,2,3)

print('------------不定长传参-位置传参2-------------')
# 如果变参放前边，则必须使用关键字num传参
def add2(*tuple1,num):
    sum = 0
    for x in tuple1:
       sum += x
    print(f'sum ={sum}')

add2(num = 888)
add2(1,num = 888)
add2(1,2,num = 888)
add2(1,2,3,num = 888)

print('------------不定长传参-位置传参3-------------')
# 如果变参放后边，则前边的参数会默认给位置参数，剩下的参数给变参

def add2(num,*tuple1):
    sum = 0
    for x in tuple1:
       sum += x
    print(f'sum ={sum}')

# add2()
add2(1)
add2(1,2)
add2(1,2,3)

关键字传参-**

概念

# 一颗星传入的参数是单个值：  func1('刘备',18,'男')
# 参数传入之后，会自动封装成元组
def func1(*args):

# 两颗星传入的参数是键值对（关键字传参）：func2(name='刘备',age=18,gender='男')
# 参数传入之后，会自动封装成字典
def func2(**args) :

代码

print('---------*---------')
def func1(*args):
    print(args)

func1('刘备',18,'男')

print('---------**---------')

def func1(**kwargs):
    print(kwargs)

func1(name='刘备',age=18,gender='男',slgkslsdgkllksdg='ksdklsdgklsdglkglk')

拆包

print('---------元组拆包---------')

def func1():
    return  123,5

print('------------方式1-----------------')
# 将元组中的每一个元素依次的给  max_value  和   min_value
max_value, min_value = func1()

print('------------方式2-----------------')
result = func1()
max_value = result[0]
min_value = result[1]

print('---------字典拆包---------')

dict1 = {'name':'刘备','age':18,'gender':'男'}
# 将字典中的所有key，依次的赋值给ret1,ret2,ret3
ret1,ret2,ret3 = dict1

print(ret1)
print(ret2)
print(ret3)

交换两个数的值

a,b = 10,20
a,b = b,a

三目运算符

语法

# 1、变量的值是由if条件来决定
# 2、如果条件成立，则把值1的值赋给变量，如果条件不成立，则把值2的赋给变量
变量 = 值1 if 条件 else 值2

代码

a = 10
b = 20
print('-----------方式1-普通写法------------')
max_value = a
if a > b:
    max_value = a
else:
    max_value = b

print(max_value)

print('-----------方式2-三目写法------------')
# 求两个数的最大值：如果 a > b 则把a的值赋值给max_value，否则把b的值赋值给max_value
max_value = a if a > b else b
print(max_value)

引用

概念

a = 10 # a是变量名 ，a代表了一个地址，指向了保存10的这片空间 ，a可以理解为引用

id(变量)：用来获取变量指向的地址值

操作

a = 10
b = a
c = a

d = 10

print(id(a))  #  通过id函数获取a指向的位置
print(id(b))  #  通过id函数获取b指向的位置
print(id(c))  #  通过id函数获取c指向的位置
print(id(d))  #  通过id函数获取d指向的位置


# 如果多个变量赋同样的值，则指向的是同一片空间

在这里插入图片描述

a = 10
b = a
c = a

d = 10

print(id(a))  #  通过id函数获取a指向的位置
print(id(b))  #  通过id函数获取b指向的位置
print(id(c))  #  通过id函数获取c指向的位置
print(id(d))  #  通过id函数获取d指向的位置


b = 20

print(id(b))  #  通过id函数获取b指向的位置

在这里插入图片描述

print('---------------------------------------------')
def func(data):
    print("data:", id(data))

num = 10
print("num:", id(num))  # 这里num的地址和形参data的地址指向的同一片空间（10这个数字的空间）
func(num)

在这里插入图片描述

文件IO操作

文件类型

普通文本文件

你用记事本右键可以直接打开，并看懂内容的都是文本文件

二进制文件

视频文件、音频文件、图像文件、可执行文件

打开文件

语法

文件对象名 = open(文件的路径名,文件打开模式，文件的编码)
# 文件对象名以后就代表文件，对文件进行操作就直接使用文件对象名即可
# 文件编码用来操作文本文件

打开模式

只读

# 文本文件 
r  
#二进制文件
rb

只写

# 文本文件
w   如果文件不存在，则创建新的文件，如果文件存在，则清空文件内容
a  如果文件不存在，则创建新的文件，如果文件存在，则把文件指针移动文件末尾，追加写入

# 二进制文件
wb   如果文件不存在，则创建新的文件，如果文件存在，则清空文件内容
ab  如果文件不存在，则创建新的文件，如果文件存在， 则不会清空文件内容，文件指针移动文件末尾

读写

#文本文件
r+ 
w+
a+

#二进制文件
rb+ 
wb+
ab+

读取文件操作

方法

read()      #  一次将文件内容全部读取
read(5)     # 一次读取指定的长度，长度指的是字符
readline()  # 一次读取一行
readlines() # 一次读取所有行

代码

# 1、打开一个文件
#  encoding='utf8' 读取文件使用utf-8
#  r表示只读
f1 = open('E:/file_dir/test1.txt','r', encoding='utf8')  #  / 只需要一个’


print('---------一次全部读取---------')
# 2、从文件读取数据 - 全部读取
str1 = f1.read()
print(str1)

print('---------一次读取指定的长度---------')
# 3、从文件读取数据 - 读取一部分
# 将文件指针移动到文件开头，否则上次读完之后，文件指针在文件末尾，什么都读取不到
f1.seek(0)
str1 = f1.read(5)  # 读取5个字符
print(str1)


print('--------一次读取一行----------')
f1.seek(0)
str1 = f1.readline()  # 一次读取一行数据,会 读取每行末尾的换行符
str2 = f1.readline()  # 一次读取一行数据
print(str1)
print(str2)

print('--------一次读取所有行并存入列表----------')
f1.seek(0)
list_str1 = f1.readlines() #['锄禾日当午\n', '汗滴禾下土\n', '谁知盘中餐\n', '粒粒皆辛苦']
print(list_str1)

for x in list_str1:  #去除末尾的换行符
    print(x.replace('\n',''))


print('--------关闭文件----------')
f1.close()  # 当一个文件不用的时候，可以及时的关闭来释放资

写入文件

方法
```
 write(要写入的内容)
```

代码

# 1、打开一个文件
#  encoding='utf8' 读取文件使用utf-8
#  w表示只写
f1 = open('E:/file_dir/test1.txt','w', encoding='utf8')  #  / 只需要一个’

print('----------向文件写入数据---------------')
# f1.write('我爱你中国')
# f1.write('\n')
# f1.write('我爱你黑马')
# f1.write('\n')

print('----------向文件写入数据---------------')
# 和readlines刚好相反，将列表中的内容可以写入文件
f1.writelines(['锄禾日当午\n', '汗滴禾下土\n', '谁知盘中餐\n', '粒粒皆辛苦'])

复制操作

代码1-复制文本

# 1、打开源文件
f1_src = open('E:\\file_dir\\test1.txt','r',encoding='utf8')

# 2、打开目标文件
f2_dest = open('E:\\file_dir\\test2.txt','w',encoding='utf8')

# 3、读取源文件
f1_content = f1_src.read()

# 4、写入目标文件
f2_dest.write(f1_content)

# 3、关闭文件
f1_src.close()
f2_dest.close()

代码2-复制任何文件

# 1、打开源文件
f1_src = open('E:\\file_dir\\a.wmv','rb')  # 复制图片和视频要加b

# 2、打开目标文件
f2_dest = open('E:\\file_dir\\b.wmv','wb') # 复制图片和视频要加b

# 3、读取源文件
f1_content = f1_src.read()

# 4、写入目标文件
f2_dest.write(f1_content)

# 3、关闭文件
f1_src.close()
f2_dest.close()

代码3-封装函数


# 定义函数
def copy_file(src_path,dest_path):
    # 1、打开源文件
    f1_src = open(src_path,'rb')  # 复制图片和视频要加b

    # 2、打开目标文件
    f2_dest = open(dest_path,'wb') # 复制图片和视频要加b

    # 3、读取源文件
    f1_content = f1_src.read()

    # 4、写入目标文件
    f2_dest.write(f1_content)

    # 3、关闭文件
    f1_src.close()
    f2_dest.close()


# 调用函数
copy_file('E:\\file_dir\\test1.txt','E:\\file_dir\\test2.txt')

```python
#文本文件
r+ 
w+
a+

#二进制文件
rb+ 
wb+
ab+
```

Python的异常

概念

1、我们写完的代码，不管你测试的再怎么精细，也有可能会存在某些bug，如果这些bug不管的话，就会因为某一个bug整个程序的崩溃
2、我们可以通过对异常进行处理，将异常造成的影响降到最低，但是大多数只是把异常温馨的暴露出来，后续开发人员还需要根据异常的原因来彻底解决异常

捕获异常

语法

try:
    可能发生异常的代码
expect:
     发生了异常，代码会执行这里，相当于捕捉了异常，可以给出一个异常的提醒，或者解决方法，一旦异常被捕捉，则程序会继续向下执行，不会导致程序的崩溃
        
finally:
    不管有没有异常，这里的代码总会执行，一般用来进行资源的释放（关闭文件）
    
    
# 异常的捕获本质上是将程序从崩溃的边缘来回倒正常状态

操作

代码1

# 1、以下代码如果文件不存在，则会发生异常：FileNotFoundError
try:
    file1 = open('E:\\file_dir\\aaa.txt','r')
except:
    # 3、发生异常，会执行员以下代码，程序回到正常状态
    print('文件必须创建才能打开')


# 2、程序回到主代码
print('拜拜！')

如果 except 后边没有指定异常的类型，则可以捕捉所有的异常

代码2

try:
    print(name)
    file1 = open('E:\\file_dir\\aaa.txt','r')
    print(1/0)
except NameError:  # 这里只能捕捉NameError异常，其他异常不管,如果发生了其他异常，代码崩溃
    print('完了！')
finally:  # finally一般用来释放资源，不管有没有异常，这里都会执行
    file1.close()

print('主代码')

如果 except 指定异常的类型，则只能捕捉指定的异常，其他异常不管，如果发生了其他异常，代码崩溃

代码3

try:
    # print(name)
    # file1 = open('E:\\file_dir\\aaa.txt','r')
    print(1/0)
except(NameError,FileNotFoundError,ZeroDivisionError):  # 这里可以捕捉指定的三个异常，其他异常不管,如果发生了其他异常，代码崩溃
    print('完了！')


print('主代码')

如果 except 指定多个异常的类型，则只要这些异常中任意一个发生异常，就会捕捉，其他异常不管，如果发生了其他异常，代码崩溃

代码4

print('xxx')
print('xxx')
try:
    print(name)  # 这句话发生异常，try剩余的代码不再执行，而是直接跳到except位置
    file1 = open('E:\\file_dir\\aaa.txt','r')
    print(1/0)
except NameError:  # 如果发生变量没有定义异常，则在这里被捕捉
    print('完了，变量没有定义！')
except FileNotFoundError:  # 如果发生文件没有创建异常，则在这里被捕捉
    print('完了，文件没有创建！')
except ZeroDivisionError:  # 如果发生除数为零常，则在这里被捕捉
    print('完了，你除数为零了！')
    
finally:  # finally一般用来释放资源，不管有没有异常，这里都会执行
  try:
      file1.close()  #由于文件没有打开成功，file1是没有值的，所以这里也会爆异常，做个异常处理
   except:
      pass
    
print('主代码1')
print('主代码2')

代码中可以写多个except，则发生异常时，python会自动的去匹配的异常，只要有一个匹配成功，则就不会匹配其他异常

代码5

print('xxx')
print('xxx')
try:
    print(name)  # 这句话发生异常，try剩余的代码不再执行，而是直接跳到except位置
    file1 = open('E:\\file_dir\\aaa.txt','r')
    print(1/0)
except Exception as e:  # Exception是类  e是对象
    print(e)  # 我们可以打印异常信息，来发现异常的原因 
    print('真不给力')
finally:  # finally一般用来释放资源，不管有没有异常，这里都会执行
  try:
      file1.close()  #由于文件没有打开成功，file1是没有值的，所以这里也会爆异常，做个异常处理
   except:
      pass

    
print('主代码1')
print('主代码2')

如果 except 后边加了Exception as e，一旦发生异常，则会将异常信息保存e对象中，你可以打印e对象里获取异常信息

代码6-with open

print('--------------open打开文件-方式1------------------------')
try:
    file1 = open('E:\\file_dir\\bbb.txt', 'r')
    print(1 / 0)
except Exception as e:  # Exception是类  e是对象
    print(e)  # 我们可以打印异常信息，来发现异常的原因
    print('真不给力')
finally:  # finally一般用来释放资源，不管有没有异常，这里都会执行
    try:
        file1.close()  #由于文件没有打开成功，file1是没有值的，所以这里也会爆异常，做个异常处理
    except:
        pass

print('主代码1')
print('主代码2')

print('--------------open打开文件-方式2------------------------')
#以下代码使用with open，文件使用完之后自动关闭，不用手动使用close
try:
    with open('E:\\file_dir\\bbb.txt', 'r+') as file1:
        file1.write('xxxx')
except Exception as e:  # Exception是类  e是对象
    print(e)  # 我们可以打印异常信息，来发现异常的原因
    print('真不给力')

print('--------------open打开文件-方式3------------------------')

#如果打开多个文件有好几种方式
try:
    with open('E:\\file_dir\\bbb.txt', 'r+') as file1:
        with open('E:\\file_dir\\ccc.txt', 'r+') as file2:
            with open('E:\\file_dir\\ddd.txt', 'r+') as file3:
                file1.write('xxxx')
                file2.write('xxxx')
                file3.write('xxxx')
except Exception as e:  # Exception是类  e是对象
    print(e)  # 我们可以打印异常信息，来发现异常的原因
    print('真不给力')

print('--------------open打开文件-方式4------------------------')
#如果打开多个文件有好几种方式
try:
    with open('E:\\file_dir\\bbb.txt', 'r+') as file1:
        file1.write('xxxx')

    with open('E:\\file_dir\\ccc.txt', 'r+') as file2:
        file2.write('xxxx')

    with open('E:\\file_dir\\ccc.txt', 'r+') as file3:
        file3.write('xxxx')

except Exception as e:  # Exception是类  e是对象
    print(e)  # 我们可以打印异常信息，来发现异常的原因
    print('真不给力')

print('--------------open打开文件-方式5------------------------')
#如果打开多个文件有好几种方式
with open('E:\\file_dir\\bbb.txt', 'r+') as file1, open('E:\\file_dir\\ccc.txt', 'r+') as file2:
    file1.write('xxxx')
    file2.write('xxxx')

代码7-try except else

try:
    # print(name)
    file1 = open('E:\\file_dir\\a.txt','w')
    print(1/1)
except NameError:  # 这里只能捕捉NameError异常，其他异常不管,如果发生了其他异常，代码崩溃
    print('完了！')
else:
    print('else语句')  # 如果try块中没有抛出异常，则执行else块。如果try块中抛出异常，则执行except块，不执行else块。

异常的思考

我们对于异常的态度：我们尽量在写代码的时候，提高写代码的水平，尽量避免有异常，将异常发生的可能性降低，如果一旦发生了异常，使用try except 来包裹把异常暴露出来，下去之后偷偷的修改代码，解决这个异常

import os

print('xxx')
print('xxx')
try:
    #以下代码我们通过修改代码，解决来异常
    name = ''
    print(name)  
    if os.path.exists('E:\\file_dir\\aaa.txt'):  # 判断文件是否存在
        file1 = open('E:\\file_dir\\aaa.txt','r')  # 存在则打开
    else:
        file1 = open('E:\\file_dir\\aaa.txt', 'w')  # 不存在则创建
    a = 1
    b = 0
    if b != 0:
        print(a/b)
except NameError:  # 如果发生变量没有定义异常，则在这里被捕捉
    print('完了，变量没有定义！')
except FileNotFoundError:  # 如果发生文件没有创建异常，则在这里被捕捉
    print('完了，文件没有创建！')
except ZeroDivisionError:  # 如果发生除数为零常，则在这里被捕捉
    print('完了，你除数为零了！')
finally:  # finally一般用来释放资源，不管有没有异常，这里都会执行
    file1.close()
    
print('主代码1')
print('主代码2')

异常的传递性

概念

1、如果一个函数内部发生了异常，没有处理，则会将这个异常传递给他的调用者，如果调用者也没有处理这个异常，异常会被继续上传传递

2、一个代码的异常不管发生在什么位置，最终必须要进行捕捉，否则代码会直接终止

3、你可以在主代码上加一个try expect，不管什么位置发生异常，你都能进行捕获

代码1-在func01捕获异常

def func01():
    print('func01函数开始！')
    try:
        print(1 / 0)
    except:
        print('除数不能为0')
    print('func01函数结束！')

def func02():
    print('func02函数开始！')
    func01()
    print('func02函数结束！')

def main():
    print('main函数开始！')
    func02()
    print('main函数结束！')

main()

你只捕获了func01的异常，如果func02和main也有异常，则无法捕获

代码2–在func02捕获异常

def func01():
    print('func01函数开始！')
    try:
        print(1 / 0)
    except:
        print('除数不能为0')
    print('func01函数结束！')

def func02():
    print('func02函数开始！')
    func01()
    print('func02函数结束！')

def main():
    print('main函数开始！')
    func02()
    print('main函数结束！')

try:
	main()
except:
   print('除数不能为0')

在func01和main中都进行了异常捕获，不管哪里发生异常，都可以进行处理

Python的模块

模块的导入

概念

1、模块就是写好的.py文件，这个py可以python自带的，也可以是别人写的，也可以是你自己写的

模块加载方式

import 模块名  #调用模块中的函数时，，使用功能时候必须加模块名
#-----------------1-------------------
import time
time.sleep(1)


from 模块名 import 功能名   # 你只能使用模块中的导入的功能，使用功能时候不用加模块名
#-------------------2-----------------
from time import sleep,lock

sleep(1)  # 睡眠1秒钟，再醒来
lock()
locltime() # 会报错


from 模块名 import *   # 将模块中所有的功能都进行导入，使用功能时候不用加模块名
#--------------------3----------------
from time import *

sleep(1)  # 睡眠1秒钟，再醒来
lock()
locltime() # 不会报错


import 模块名 as 别名   # 将模块中所有的功能都进行导入，并对模块名起别名,使用功能时候必须加模块别名
#--------------------4----------------
import time as t

t.sleep(1)  # 睡眠1秒钟，再醒来
t.lock()
t.locltime() # 不会报错


from 模块名 import 功能名 as 别名  # 将模块中指定功能导入，并对功能名起别名，使用时需要使用功能别名，不需要加模块名,如果多个模块中出现同名的函数，则可以给函数起别名
#--------------------5----------------
from time import  sleep as s

s(1) # 睡眠1秒钟，再醒来

while True:
    print('Hello World')
    sleep(1)  # 休眠1秒钟，然后再醒来

模块的自定义

定义步骤

1、创建一个py文件就是定义一个模块,该模块中一般用来定义类、函数、变量
2、如果别人想使用这个模块，则可以导入该模块，模块有5中导入方式

操作

代码1-my_module01.py

def test(a, b):
    print(a + b)

# 这个if语句作用是：test函数的调用只有在当前文件执行才起作用，而如果是其他文件调用该模块，则不会执行
if __name__ == '__main__':
    test(10,20)

代码2-01-模块测试.py

from my_module01 import *  #导入模块

test(22,33)    # 调用模块中的函数

多个模块出现同名函数

代码1-my_module01.py

def test(a, b):
    print(a + b)  #加法

if __name__ == '__main__':
    test(10,20)

代码2-my_module02.py

def test(a, b):
    print(a - b)  # 减法


if __name__ == '__main__':
    test(10,20)

代码3-测试代码1

from my_module01 import *  # 加法
from my_module02 import * #  减法

# 如果多个模块出现同名的函数，则后导入的模块会覆盖前边的模块
test1(22,33)  #这里调用的是减法

代码4-测试代码2

from my_module01 import test as test1  # 加法 给函数起别名
from my_module02 import test as test2  # 减法 给函数起别名

# 如果多个模块出现同名的函数，同时调用时，可以给函数起别名
test1(22,33)
test2(22,33)

对模块中函数加限制

概述

1、如果你定义一个模块，这个模块中有多个函数，你可以通过设置__all__ 关键字，来设置你希望外部可以调用的函数，只有加入__all__关键字的函数才能被外部调用
2、这种设置只对 from my_module03 import * 导入起作用

代码1-my_module03.py

__all__ = ['test1','test2']  #外部只能调用test1和test2函数，不能调用test3函数

def test1(a, b):
    print(a + b)

def test2(a, b):
    print(a - b)

def test3(a, b):
    print(a * b)


if __name__ == '__main__':
    test1(10,20)

代码2-测试代码

from my_module03 import *  #导入模块

test1(22,33)  #  可以调用
test2(22,33)  #  可以调用
test3(22,33)  #  不可以调用，出错

Python的包

包的使用

概念

1、包就是一个文件夹，包是用来管理模块的，模块多的话应该放在包里边
2、你可以直接建一个文件夹来当做包，也可以直接创建package包，两者的区别是：package包方式会自动生成一个__init__.py文件，在该文件中可以进行模块的权限控制

在这里插入图片描述

代码1-三个模块

#---------------------my_module文件夹下的my_module01------------------------------
def test1(a, b):
    print(a + b)


if __name__ == '__main__':
    test1(10,20)
#---------------------my_module文件夹下的my_module02------------------------------
def test2(a, b):
    print(a - b)


if __name__ == '__main__':
    test2(10,20)
    
    test1(10,20)
#---------------------my_module文件夹下的my_module03------------------------------
def test2(a, b):
    print(a - b)


if __name__ == '__main__':
    test2(10,20)

代码2-测试模块3

#如果一个模块文件外层还有文件夹或者包，则应该先指定文件夹或者包，再指定模块的名字
# from 文件夹名.模块名 import 函数
from my_module.my_module01 import *
from my_module.my_module02 import *
from my_module.my_module03 import *

test1(10,20)
test2(10,20)
test3(10,20)

init .py文件

概念

`__init__.py`文件中可以添加`__all__ = []`，控制允许导入的模块列表

 #该包下只有my_module01和my_module02可以被导入，只能是 ’ from ... import * ‘ 这种方式
对 'import xxx ’ 这种方式无效

__all__ = ['my_module01','my_module02']

代码-3个模块

在这里插入图片描述

#---------------------my_module2包下的init.py------------------------------
 #该包下只有my_module01和my_module02可以被导入，只能是 ’ from ... import * ‘ 这种方式
__all__ = ['my_module01','my_module02']

#---------------------my_module2包下的my_module01------------------------------
def test1(a, b):
    print(a + b)


if __name__ == '__main__':
    test1(10,20)
#---------------------my_module2包的my_module02------------------------------
def test2(a, b):
    print(a - b)


if __name__ == '__main__':
    test2(10,20)
    
    test1(10,20)
#---------------------my_module2包的my_module03------------------------------
def test2(a, b):
    print(a - b)


if __name__ == '__main__':
    test2(10,20)

代码2-测试

#导入my_module2中的模块，并且会根据init.py中列表进行模块过滤
from my_module2 import *


my_module01.test1(10,20)  # 可以导入
my_module02.test2(10,20)  # 可以导入
my_module03.test3(10,20)  # 不可以导入，报错