# 元组
# 元组不可修改
# 定义元组
t1 = (1,"Hello",True)
t2 = () # 空类型
t3 = tuple() # 空元组
print(f"t1的数据类型为:{type(t1)}")
print(f"t1的数据类型为:{type(t2)}")
print(f"t1的数据类型为:{type(t3)}")
t4 = ("hello",) # 如果没有逗号，t4就是str类型
t5 = ((1,2,3),(4,5,6))
t5[1][2] # 得到6
# index查找操作
t6 = ("itheima","itcast","itheima","python")
index = t6.index("itheima")
print(index)
# count统计数量
num = t6.count("itheima")
# len数量
num = len(t6)
# 元组遍历
index = 0
while index < num:
    print(t6[index])
    index+=1
for element in t6:
    print(element)
# 元组中有list，那么list中的值可以修改
t11 = (1,2,["itheima","itcast"])
t11[2][0] = "it"
print(t11)

# 字符串str
# 字符串无法修改
my_str = 'itheima and itcast'
value = my_str[2]
value2 = my_str[-16]
# 字符串的index操作
index = my_str.index("and")
print(index)
# 字符串替换 ，会得到一个新字符串
my_str = my_str.replace("it","ahahahah")
print(my_str)
# 字符串的分割
my_str = "hello python itheima itcast"
new_my_str = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到：{new_my_str},类型是{type(new_my_str)}")
# 字符串.strip()字符串规整操作 去除前后空格
my_str = "  itheima and itcast   "
print(my_str.strip()) # 不传入参数，就是去除首尾空格
# 传参
my_str = "12itheima and itcast2121"
print(my_str.strip("12"))# 去除1和2
# count 和 len 也是适用的

# 列表，元组，字符串都可以视为序列
my_list = [0,1,2,3,4,5,6,7]
# 对list进行切片，从1开始，到4结束，步长为1
result = my_list [1:4]
print(result)
my_tuple = (0,1,2,3,4,5,6,7)
#对turple进行操作，从头开始到最后结束
result2 = my_tuple[:]
print(result2)
#对str进行切片，从头开始，到最后结束，步长为2
my_str = "0123456789"
result3 = my_str[::2]
print(result3)

# 对str进行切片，从头开始到末尾结束，步长为-1
my_str = "0123456789"
result4 = my_str[::-1]  #倒序
print(result4)
# 对列表进行切片，从3开始，到1结束，步长为-1
my_list = [1,2,3,4,5,6,7]
result5 = my_list[3:1:-1]
print(result5)
# 对元组进行切片，从头开始到结尾结束，步长为-2
my_tuple = (0,1,2,3,4,5,6,6,7)
result6 = my_tuple[::-2]
print(result6)

# 集合
# 允许修改
my_set = {"传智教育","ieheima","黑马程序员","itheima","ieheima","黑马程序员","itheima"}
my_set_empty = {} # 空
print(my_set) # 有去重操作，没有顺序
# 添加新元素
my_set.add("Python")
print(my_set)
# 移除元素
my_set.remove("Python")
print(my_set)
# 随机取出一个元素
result = my_set.pop()
print(result)
# 清空集合
my_set.clear() #清空
# 取2个集合的差集
set1 = {1,2,3}
set2 = {1,5,6}
set3 = set1.difference(set2)
print(set3)
# 消除两个集合中相同的元素
set1.difference_update(set2)
print(set1)
# 集合合并
set1 = {1,2,3}
set2 = {1,5,6}
ser3 = set1.union(set2)
print(ser3)
# 数量len
num = len(ser3)
print(num)
# 集合的遍历
for element in set1:
    print (element)

# 字典 {key:value,key:value,......} 键值对
my_dict = {"Rookie" : 99,"TheShy":88,"ning":77}
#定义空字典:
my_dict2 = {}
my_dict3 = dict()
#定义重复的key，会覆盖，输出后边的
print(my_dict["Rookie"])
# 嵌套
stu_score_dict = {
    "王力宏":{
        "yuwen":66,
        "shuxue":88
    },
    "周杰伦":{
        "yuwen":88,
        "shuxue":88
    },
    "林俊杰":{
        "yuwen":88,
        "shuxue":58
    }
}
print(stu_score_dict["周杰伦"]["yuwen"])
print(stu_score_dict["林俊杰"]["yuwen"])
# 字典的新增元素和更新元素
my_dict = {"周杰伦":99,"林俊杰":88,"张学友":77}
# 新增
my_dict["张信哲"] = 66
print(my_dict)
# 更新
my_dict["周杰伦"] = 33
print(my_dict)
# 删除元素
score = my_dict.pop("周杰伦")
print(my_dict)
print(score)
# 清空
my_dict.clear()
# 拿到keys
my_dict = {"周杰伦":99,"林俊杰":88,"张学友":77}
keys = my_dict.keys()
print(keys)
# 遍历
for key in keys:
    print(key)
    print(my_dict[key])
for key in my_dict:
    print(key)
# 不能用while
# 统计数量
num = len(my_dict)
print(num)
# 容器的通用功能
# max min len等
# 容器转换
list(my_set)
# 排序
sorted(my_list) # 从小到大排完序会变成list
sorted(my_list,reverse=True) # 从大到小

# 函数的多返回值
def test_return():
    return 1,"sss",True
x,y,z = test_return()
print(x)
print(y)
print(z)
# 函数多种传入参数
def user_info(name,age,gender):
    print(f"您的名字是:{name}，年龄是{age}，性别是{gender}")
user_info('小明',20,'男')
user_info(name = '小王',age = 18,gender = '女')
user_info(age = 55,name = '哈哈哈',gender = '男')
# 缺省默认,但是默认的必须在最后
def user1_info(name,age,gender = '男'):
    print(f"您的名字是:{name}，年龄是{age}，性别是{gender}")
# 不定长参数
# 位置不定长，相当于输入一个元组
def user2_info(*args):
    print(args)
user2_info(1,2,3,'小明','小白')
# 关键字不定长 作为字典存在
def user3_info(**keywords):
    print(f"args的参数类型为：type(keywords),内容是:{keywords}")
user3_info(name = '小王',age = '99',gender = '女')
# 匿名函数
# 定义一个函数，接受另一个函数作为传入数据
def test_func(computer):
    result = computer(1,2)
    print(f"computer参数的类型是:{type(computer)}")
    print(result)
def computer(x,y):
    return x+y
test_func(computer)
# lambda匿名函数,无名字的匿名函数只能临时使用一次
# 函数只能写一行没办法写多行
def test_func(computer):
    result = computer(1,2)
    print(result)
test_func(lambda x,y:x+y) # 传入参数：函数体
# 文件编码 UTF-8 ，GBK ， Big5
# open(name,mode,encoding)
# name:是要打开目标文件名的字符串（也可以包含文件所在的具体路径）
# mode:设置要打开的模式（访问模式）：只读，写入，追加等等
# encoding:编码格式（推荐使用UTF-8）
# r 以只读的方式打开文件，文件的指针将会放在文件的开头。这是默认模式
# w 打开一个文件只用于写入，如果该文件已存在则打开文件，并从开头开始编辑，原有的内容会被删除，如果该文件不存在，创建新文件
# a 打开一个文件用于追加，如果该文件已存在，新的内容将会被写入到已有内容之后，如果文件不存在，创建新文件进行写入
# 打开文件
import time

f = open("D:/测试.txt","r",encoding = "UTF-8") #open函数定义encoding不在第三位，所以用关键字传参
print(type(f))
# 读取文件 - read()
# 文件名.read(num) num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取所有数据
# readlines() : readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素
print(f"读取字节：{f.read()}")
# 如果多次读取read，下一次读取续接在上一个读取之后
lines = f.readlines()
print(lines)
print(type(lines))
# readline() 一次读取一行
line1 = f.readline()
line2 = f.readline()
line3 = f.readline()
print(line1)
print(line2)
print(line3)
# for循环读取文件行
for line in f:
    print(line)
# 文件的关闭
f.close()
# with open 语法操作文件
with open("D:/测试.txt","r",encoding = "UTF-8") as f:
    for line in f:
        print(f)
# time.sleep(3) # 睡眠3秒
f = open("D:/word.txt","r",encoding="UTF-8")
# content = f.read()
# count  = content.count("itheima")
# print(count)
count = 0
for line in f:
    line =  line.strip()
    words = line.split(" ")
    print(words)
    for word in words:
        if word == "itheima":
            count += 1
print(count)
f.close()
# 打开文件，不存在的文件
# f = open("D:/he.txt","w",encoding="UTF-8")
# f.write("Hello,World")
# f.flush()
f = open("D:/he.txt","w",encoding="UTF-8")
f.write("哈哈哈")
f.flush()
# 如果没有文件，那么就会创建一个文件，直接写入。有文件，就会覆盖掉之前的内容
# 只需要把模式换成"a"就行了