数据容器的通用操作
通用 for 循环 便历容器（字典是遍历Key）
max 容器内最大元素
min( ) 容器内最小元素
len( ) 容器元素个数
list( ) 转换为列表
tuple( ) 转换为元组
str( ) 转换为字符串
set( ) 转换为集合
sorted(序列, reverse = True) 排序，reverse = True表示降序，得到一个排好序的列表
my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
# max最大元素
print(f"my_list容器中的最大元素是{max(my_list)}")
print(f"my_tuple容器中的最大元素是{max(my_tuple)}")
print(f"my_str容器中的最大元素是{max(my_str)}")
print(f"my_set容器中的最大元素是{max(my_set)}")
print(f"my_dict容器中的最大元素是{max(my_dict)}")
# min最小元素
print(f"my_list容器中的最小元素是{min(my_list)}")
print(f"my_tuple容器中的最小元素是{min(my_tuple)}")
print(f"my_str容器中的最小元素是{min(my_str)}")
print(f"my_set容器中的最小元素是{min(my_set)}")
print(f"my_dict容器中的最小元素是{min(my_dict)}")
# len()元素个数
print(f"my_list容器元素个数是{len(my_list)}")
print(f"my_tuple容器元素个数是{len(my_tuple)}")
print(f"my_str容器元素个数是{len(my_str)}")
print(f"my_set容器元素个数是{len(my_set)}")
print(f"my_dict容器元素个数是{len(my_dict)}")
# 容器转列表
print(f"容器my_list转换为列表为{list(my_list)}")
print(f"容器my_tuple转换为列表为{list(my_tuple)}")
print(f"容器my_str转换为列表为{list(my_str)}")
print(f"容器my_set转换为列表为{list(my_set)}")
print(f"容器my_dict转换为列表为{list(my_dict)}")
# 容器转元组
print(f"容器my_list转换为元组为{tuple(my_list)}")
print(f"容器my_tuple转换为元组为{tuple(my_tuple)}")
print(f"容器my_str转换为元组为{tuple(my_str)}")
print(f"容器my_set转换为元组为{tuple(my_set)}")
print(f"容器my_dict转换为元组为{tuple(my_dict)}")
# 容器转字符串
print(f"容器my_list转换为字符串为{str(my_list)}")
print(f"容器my_tuple转换为字符串为{str(my_tuple)}")
print(f"容器my_str转换为字符串为{str(my_str)}")
print(f"容器my_set转换为字符串为{str(my_set)}")
print(f"容器my_dict转换为字符串为{str(my_dict)}")
# 容器转集合
print(f"容器my_list转换为集合为{set(my_list)}")
print(f"容器my_tuple转换为集合为{set(my_tuple)}")
print(f"容器my_str转换为集合为{set(my_str)}")
print(f"容器my_set转换为集合为{set(my_set)}")
print(f"容器my_dict转换为集合为{set(my_dict)}")
# 容器转字典
# print(f"容器my_list转换为字典为{dict(my_list)}")
# print(f"容器my_tuple转换为字典为{dict(my_tuple)}")
# print(f"容器my_str转换为字典为{dict(my_str)}")
# print(f"容器my_set转换为字典为{dict(my_set)}")
print(f"容器my_dict转换为字典为{dict(my_dict)}")
# 进行容器的排序
my_list = [3, 1, 2, 5, 4]
my_tuple = (3, 1, 2, 5, 4)
my_str = "bdcefga"
my_set = {3, 1, 2, 5, 4}
my_dict = {"key3": 1, "key1": 2, "key2": 3, "key5": 4, "key4": 5}
print(f"容器my_list排序的结果是{sorted(my_list)}")
print(f"容器my_tuple排序的结果是{sorted(my_tuple)}")
print(f"容器my_str排序的结果是{sorted(my_str)}")
print(f"容器my_set排序的结果是{sorted(my_set)}")
print(f"容器my_dict排序的结果是{sorted(my_dict)}")
print(f"容器my_list排序的结果是{sorted(my_list,reverse=True)}")
print(f"容器my_tuple排序的结果是{sorted(my_tuple,reverse=True)}")
print(f"容器my_str排序的结果是{sorted(my_str,reverse=True)}")
print(f"容器my_set排序的结果是{sorted(my_set,reverse=True)}")
print(f"容器my_dict排序的结果是{sorted(my_dict,reverse=True)}")
字符串大小比较的方式
1、字符串如何比较
从头到尾，一位位进行比较，其中一位大，后面就无需比较了。
2、单个字符之间如何确定大小？
通过ASCII码表，确定字符对应的码值数字来确定大小
演示字符串大小比较
# abc 比较 abd
print(f"abd大于abc的结果是{'abd'>'abc'}")
# a 比较 ab
print(f"ab大于a的结果是{'ab'>'a'}")
# a 比较 A
print(f"a大于A的结果是{'a'>'A'}")
# key1 比较 key2
print(f"Key2大于Key1的结果是{'Key2'>'Key1'}")
abd大于abc的结果是True
ab大于a的结果是True
a大于A的结果是True
Key2大于Key1的结果是True
函数的多返回值
按照返回值的顺序，写对应顺序的多个变量接收即可
变量之间用逗号隔开
支持不同类型的数据 return
# 演示多个变量，接收多个返回值
def test_return():
return 1,'hello',True
x,y,z = test_return()
print(x)
print(y)
print(z)
---------------------
1
hello
True
函数的多种参数使用形式
位置参数：调用函数时根据函数定义的参数位置来传递参数
关键字参数：函数调用时通过 “键=值” 形式传递参数
传递的参数和定义的参数的顺序及个数必须一致
注意：函数调用时，如果有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序
不定长参数：也叫可变参数，用于不确定调用的时候回传递多少个参数（不传参也可以）
作用：当调用函数时不确定参数个数时，可以使用不定长参数
不定长参数的类型：1、位置传递 2、关键字传递
单个*号（args）传递参数表示数量随意，通过逗号分隔开，传递进去以后他会作为元组存在。
两个**号（kwargs）传递参数表示数量随意，但是要以字典的形式传递，即key=value的形式，传递进去后作为字典存在
# 演示多种传参的形式
def user_info(name,age,gender):
print(f"姓名是{name},年龄是{age},性别是{gender}")
# 位置参数---默认使用形式
user_info('小明',20,'男')
# 关键字参数
user_info(name='小王',age=11,gender='女')
user_info(age=10,gender='女',name ='潇潇')
user_info('甜甜',age=9,gender='女')
# 缺省参数（默认值）
def user_info(name,age,gender):
print(f"姓名是{name},年龄是{age},性别是{gender}")
user_info('小天',13,'男')
# 不定长 --位置不定长 *号
# 不定长定义的形式参数会作为元组存在，接收不定长数量的参数传入
def user_info(*args):
print(f"args参数的类型是{type(args)},内容是{args}")
# 不定长 - 关键字不定长，**号 数量随意，但是传递的时候要是key-value的形式传递
def user_info(**kwargs):
print(f"args参数的类型是{type(kwargs)},内容是{kwargs}")
user_info(age1=1,age2=2,age3=3,name1='小明',name2='男孩')
-----------------------------------------------------------------------------------------------------------------------
姓名是小明,年龄是20,性别是男
姓名是小王,年龄是11,性别是女
姓名是潇潇,年龄是10,性别是女
姓名是甜甜,年龄是9,性别是女
姓名是小天,年龄是13,性别是男
args参数的类型是<class 'dict'>,内容是{'age1': 1, 'age2': 2, 'age3': 3, 'name1': '小明', 'name2': '男孩'}
函数作为参数传递
1、函数本身可以作为参数，传入另一个函数中进行使用
2、将函数传入的作用在于：传入计算逻辑，而非传入数据
# 演示函数作为参数传递
# 定义一个函数，接收另一个函数作为传入参数
def test_func(compute):
result = compute(1,2)
print(f"compute参数的类型是{type(compute)}")
print(f"计算结果是{result}")
#定义一个函数，准备作为参数传入另一个函数
def compute(x,y):
return x+y
#调用，并传入函数
test_func(compute)
---------------------------------------------------------
compute参数的类型是<class 'function'>
计算结果是3
lambda匿名函数
函数的定义中
def 关键字，可以定义带有名称的函数
lambda 关键字，可以定义匿名函数（无名称）
有名称的函数，可以基于名称重复使用
无名称的匿名函数，只可临时使用一次
匿名函数定义语法：
lambda 传入参数:函数体（一行代码）
lambda 是关键字，表示匿名函数
传入参数表示匿名函数的形式参数，如x,y表示接收2个形式参数
函数体，就是函数的执行逻辑，要注意：只能写一行，无法写多行代码
def test_func(compute):
result = compute(1,2)
print(result)
#方法1 def
def compute(x,y):
return x+y
test_func(compute)
#方法2 lambda函数
test_func(lambda x,y:x+y)
----------------------------------------------
3
3
文件编码概念
1、什么是编码？
编码就是一种规则集合，记录了内容和二进制间进行相互转换的逻辑
编码有许多种，我们最常用的是UTF-8编码
2、为什么需要使用编码？
计算机只认识0和1，所以需要将内容翻译成0和1才能保存在计算机中
同时也需要编码，将计算机保存的0和1，反向翻译回可以识别的内容
文件的读取操作
1、操作文件需要通过open函数打开文件得到文件对象
2、文件对象有如下读取方法：
read( )
readline( )
readlines( )
for line in 文件对象
3、文件读取完成后，要使用文件对象.close( )方法来关闭文件对象，否则文件会被一直占用
# 打开文件
# f = open("D:/1.txt","r", encoding="UTF-8")
# print(type(f))
# 读取文件
# print(f"读取10个字节的结果是{f.read(10)}")
# print(f"read方法读取全部内容的结果是{f.read()}")
print("------------------------------------")
# 读取文件 -- readLines()
# lines = f.readlines() # 读取文件的全部行，封装到列表中
# print(f"lines对象的内容是{lines}")
# 读取文件 -- readline()
# line1 = f.readline()
# line2 = f.readline()
# line3 = f.readline()
# print(f"第1行数据是{line1}")
# print(f"第2行数据是{line2}")
# print(f"第3行数据是{line3}")
# for 循环读取文件行
# for line in f:
# print(f"每一行数据是{line}")
# 文件的关闭
# f.close()
with open("D:/1.txt","r",encoding="UTF-8") as f:
for line in f:
print(f"每一行数据是{line}")
文件读取的课后练习讲解
f = open("D:/1.txt",'r',encoding='UTF-8')
content = f.read()
count = content.count("itheima")
print(f"文本文件1.txt中有{count}个itheima")
--------------------------------------------------------------
文本文件1.txt中有6个itheima
文件的写出操作
1、写入文件使用open函数的“w”模式进行写入
2、写入的方法有
write( )，写入内容
flush( )，刷新内容到硬盘中
3、注意事项
w模式，文件不存在，会创建新文件
w模式 ，文件存在，会清空原有内容
close( )方法，带有flush( )方法
f = open("D:/1.txt",'w',encoding='UTF-8')
f.write("lqd棒棒！")
f.flush()
f.close()
文件的追加写入操作
1、追加写入文件使用open函数的 ‘a’ 模式进行写入
2、追加写入的方法有（和w模式一致）：
write( ) ，写入内容
flush( )，刷新内容到硬盘中
3、注意事项
a模式，文件不存在，会创建新文件
a模式，文件存在，会在原有内容后面继续写入
可以使用 “\n” 来写出换行符
f = open("D:/1.txt",'a',encoding='UTF-8')
f.write("lqd棒棒！")
f.close()
文件操作的综合案例
fr = open("D:/1.txt",'r',encoding='UTF-8')
fw = open("D:/1.txt",'w',encoding='UTF-8')
for line in fr:
line = line.strip()
if line.split(",")[4] == " ":
continue
fw.write('line')
fw.write('\n')
fr.close()
fw.close()
异常的捕获
1、为什么要捕获异常
在可能发行异常的地方进行捕获，当异常的时候，提供解决方式，而不是任由其导致程序无法进行
2、捕获异常的语法
3、如何捕获所有异常
异常的种类多种多样，如果想要不管什么类型的异常都能捕获到，那么使用：
except
except Exception
try:
f = open("D:/2.txt",'r',encoding='UTF-8')
except:
f = open("D:/2.txt",'w',encoding='UTF-8')
else:
print("没有异常出现")
finally:
f.close()
print("结束咯")
异常的传递性
异常是有传递性的，当函数func1中发生异常，并且没有捕获处理这个异常的时候，异常会传递到函数func2中，当func2也没有捕获处理这个异常时，main会捕获这个异常，这就是异常的传递性。
当所有函数都灭有捕获异常的时候，程序就会报错
def func1():
print("func1开始执行")
num = 1 / 0
print("func1结束执行")
def func2():
print("func2开始执行")
func1()
print("func2结束执行")
try:
func2()
except Exception as e:
print(f"出现异常了,异常的信息是{e}")
--------------------------------------------------------
func2开始执行
func1开始执行
出现异常了,异常的信息是division by zero
模块的概念和导入
1、什么是模块
python模块是一个python文件，以 .py 结尾，模块能定义函数，类和变量，模块里也能包含可执行的代码。
买两块的作用，python中有很多各种不同的模块，每一个模块都可以帮助我们快速的实现一些功能，比如实现和时间相关的功能就可以使用time模块，我们可以认为一个模块就是一个工具包，每一个工具包都有各种不同的工具供我们使用进行实现各种不同的功能
大白话：模块就是一个Python文件，里面有类、函数、变量等，我们可以拿过来用（导入模块去使用）
2、模块的导入方式
[from 模块名] import [模块 | 类 | 变量 | 函数 | * ] [as 别名]
常用的组合形式如：
import 模块名
from 模块名 import 类、变量、方法
from 模块名 import *
import 模块名 as 别名
from 模块名 import 功能名 as 别名
注意事项：
from可以省略，直接import即可
as别名可以省略
通过 ’ . ’ 来确定层级关系
模块的导入一般写在代码文件的开头位置
from 直接写功能名
import 时写全，文件名或者模块名.功能名
# 使用import导入time模块使用sleep功能（函数）
import time # 导入Python内置的time模块（time.py这个代码文件）
print("你好")
time.sleep(5) # 通过. 就可以使用模块内部的全部功能（类、函数、变量）
print("我好")
# 使用from导入time的sleep功能（函数）
from time import sleep
print("你好")
sleep(5)
print("我好")
# 使用 * 导入time模块的全部功能
from time import * # *表示全部的意思
print("你好")
sleep(5)
print("我好")
# 使用as给特定功能加上别名
import time as t
print("你好")
t.sleep(5)
print("我好")
from time import sleep as sl
print("你好")
sl(5)
print("我好")
自定义模块并导入
新建一个python文件，命名.py文件，并且定义函数
模块名字实际是文件名
1、如何自定义模块并导入？
在python代码文件中正常写代码即可，通过import、from关键字和导入python内置模块一样导入即可使用
2、main_变量的功能是？
if_name == “main”表示，只有当程序是直接执行的才会进入if内部，如果是被导入的，则if无法进入
python中的内置变量_name_ ，在当前python文件下，如果运行的话，会直接把内置变量的值设置为_main_
即if_name_ == “main”表示true，即可以实现在当前文件下测试函数的实现功能又能实现在外面文件中导入这个文件时，不会去运行里面所写的代码。
3、注意事项
不同模块、同名的功能，如果都能被导入，那么后导入的会覆盖先导入的；
__all__变量可以控制导入模块的时候，在要导入的文件中，* 代表导入具体的功能；
若在模块文件中开头处写：all = [“testA”]，下面有两个函数testA和testB时，在另一个文件中只可以调用testA函数；
如果不写__all__变量，这个*表示所有功能都能被导入进去；
from 包.文件名 import 功能1
from 包.文件名 import 功能2
调用直接功能1( ) 功能2( )
"""
演示自定义模块
"""
# 导入自定义模块使用
import my_module1
from my_module1 import test
test(1, 2)
# 导入不同模块的同名功能
from my_module1 import test
from my_module2 import test
test(1, 2)
# __main__变量
from my_module1 import test
# __all__变量
from my_module1 import *
test_a(1, 2)
# test_b(2, 1)
自定义Python包
通过import 或者from 的方式导入
在__int__.py文件中输入__all__=[“模块名”] 可以控制在test.py下的指向，如果写了， 指的是特定模块；如果没写，* 指的是所有模块；
from 包
演示Python的包
# 创建一个包
# 导入自定义的包中的模块，并使用
# import my_package.my_module1
# import my_package.my_module2
#
# my_package.my_module1.info_print1()
# my_package.my_module2.info_print2()
# from my_package import my_module1
# from my_package import my_module2
# my_module1.info_print1()
# my_module2.info_print2()
# from my_package.my_module1 import info_print1
# from my_package.my_module2 import info_print2
# info_print1()
# info_print2()
# 通过__all__变量，控制import *
from my_package import *
my_module1.info_print1()
my_module2.info_print2()
安装第三方包
第三方包（非Python官方）
科学计算中常用的：numpy包
数据分析中常用的：pandas包
大数据计算中常用的：pyspark包、apache-flink包
图形可视化常用的：matplotlib、pyecharts
人工智能常用的：tensorflow
由于是第三方，所以Python没有内置，我们需要安装才可以导入
安装第三方包：pip install 包名称
如果安装速度很慢，可以使用以下命令：
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称
是清华大学提供的一个网站，可供pip程序下载
也可以通过PyCharm中安装—解释器设置—+号—输入想要安装的包–如果慢，可以在选项后面写 -i https://pypi.tuna.tsinghua.edu.cn/simple，点击installPackage,点击以后变灰色，表示他在后台默默运行中
异常—模块—包综合讲解
演示异常、模块、包的综合案例练习
# 创建my_utils 包， 在包内创建：str_util.py 和 file_util.py 2个模块，并提供相应的函数
file_util.py
def print_file_info(file_name):
f = open(file_name,“r”,encoding=“UTF-8”)
content = f.read()
print(content)
f = None
try:
print_file_info(“D:/1.text”)
except Exception as e:
print(“出错了，没有那个文件”)
f = open(“D:/1.text”,“a”,encoding=“UTF-8”)
f.write(“黑马程序员”)
content= f.read()
print(content)
finally:
if f:
f.close()
def append_to_file(file_name,data):
f = open(file_name,“a”,encoding=“UTF-8”)
f.write(data)
f.write(“\n”)
f.close()
if name == ‘main’:
print_file_info(“D:/2.txt”)
append_to_file(“D:/2.txt”,“lqd”)
str_util.py
def str_reverse(s):
print(f"反转字符串的结果是{sorted(s,reverse=True)}“)
print(f"反转字符串的结果是{s[::-1]}”)
def substr(s,x,y):
“”“”
功能是将字符串反转
:param x:切片开始下标
:param y:切片终止下标
“”"
print(f"字符串s根据传入的下标{x}和{y}切片后用得到的结果是{s[x:y]}")
if name == ‘main’:
str_reverse(“lqdshilinwudi”)
substr(“lqdwudi”,0,8)
