python基础练习(100)--练习题

运维神经科主任

已于 2023-04-02 19:05:32 修改

阅读量1k

点赞数 1

分类专栏： # python基础文章标签： python 开发语言运维开发

于 2023-04-02 18:58:35 首次发布

本文链接：https://blog.csdn.net/weixin_57670650/article/details/129915108

版权

python基础专栏收录该内容

5 篇文章 1 订阅

订阅专栏

一.python基础练习(100)

1.1 基础(格式或语法)

"""只记录复杂化的题目和思路"""

003.比较和赋值

--执行如下代码会报错，你知道什么错误吗？
a = 1
b = 2
print(a == b)
#返回的是true和false
print(b == c)
#因为c变量没有被定义,所以无法判断b==c,会抛错false

004.类型错误

"""
修复如下代码，让它的输出是数字1+2结果为3
不要修改前两行，只修改第3行
"""
--源code
a = "1"
#a此处定义的是字符串,无法进行整形的计算
b = 2
print(a + b)

---修复后
a = "1"
b = 2
print(int(a) + b)

005.缩进错误

"""
如下代码想要判断字符串中的字母是不是等于e，等于的话输出这个字母
但是报错了，你知道为什么吗，怎么修复？
"""
for letter in "Hello":
    if letter == "e":
    print(letter)
    #可以看到当前这个打印不在if的缩进块内,if无效可以有俩种修改方式

--修复代码(1)
for letter in "Hello":
    if letter == "e":
        continue
        #continue在if块内,当letter等于e的时候,丢弃e
    print(letter)
    #此处的print在for循环体制内,说明不满足if条件内容哦都会被打印
--修复代码(2)
for letter in "Hello":
    if letter == "e":
       print(letter)
    #将print进行缩进调整,放入if块中

006.不正确的结束

"""
如下代码会报错，你知道为什么吗？怎么修复？
"""
print(type("Hey".replace("ey","i")[-1])
#可以看到少了print对应的()中的结尾括号
##replace函数,字符替换,将HEY中的ey替换为i.输出Hi.[-1]为字符串索引,输出i

1.2 索引和切片

013 复数切片

"""
完成如下代码，获得一个切片，得到最后的3个元素[h, i, j]
"""
letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
print(letters[-3:])
#即-3开始到最后,包含最后字符
#对于这个场景，只能写[-3:]，冒号后面的数字不用写也没法写，这样就包含了列表后面的所有元素

014 步长切片

"""
完成如下代码，获得一个切片，包含元素['a', 'c', 'e', 'g', 'i']
"""
#!/bin/evn python
letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
print(letters[0::2])
#从头开始值末尾,每2个字符切一个

1.3 列表list

015 range函数

"""
编写代码，生成如下数字List，注意要用函数生成
"""
#!/bin/evn python
my_range = range(1,21)
#定义变量为1,20的内容
print (list(my_range))
#将1,20打印为list

016 range推导式

#!/bin/evn python
my_range = range(1,21)
hh = [x*10 for x in my_range]
print (hh)

012 去重set、list

"""
set集合是不允许集合内出现重复字符的,当获取到常规数值后可以通过set进行去从
"""
--方法1
a = ["1", 1, "1", 2]
b = []
#定义空列表
for i in a:
    if i not in b:
        b.append(i)
print(b)

--方法2
a = ["1", 1, "1", 2]
b = set()
#定义空集合
for i in a:
    if i not in b:
        #如果a的值不在b中
        b.add(i)
        #给b进行添加新值
print(b)

--方法3
a = ["1", 1, "1", 2]
a = set(a)
#格式化a的列表内容为集合
print(a)

019 列表排序

"""
完成代码，对列表排序，得到排序后的结果
"""
lista = [20, 40, 30, 50, 10]
new_list = sorted(lista,reverse=True)
print(f"lista is {new_list}")

lista.sort(reverse=True)
print(f"lista is {new_list}")

020 列表去从

#!/bin/env python
l = [['百度', 'BD'], ['京东', 'JD'], ['淘宝', 'TB'], ['百度', 'BD']]
L = []
while(l):
    #根据l的元素个数进行循环
    pop_l = l.pop()
    #pop为在列表l取值,取出后l列表中的pop内容不存在.
    #倒叙取值
    if pop_l in l:
        #如果列表中的内容取出后,还在源l列表中
        continue
        #那么就丢此此数据
    else:
        L.insert(0, pop_l)
        #pop取出的只有一次的元素则在下标0中插入pop的数据
print(L)
#因为pop是倒叙取list中的值,所以列表顺序不变

1.4 字典

022 字典元素加和

"""
完成如下代码，计算key为a和b的值的加和
"""
d = {"a": 1, "b": 2, "c": 3}
print(d["a"] + d["b"])

025 对字典使用函数

"""
计算如下字典的所有value的数字的和
"""
d = {"a": 1, "b": 2, "c": 3}
print(sum(d.values()))

026 字典过滤

"""
移除如下字典中所有value大于1的key:value对
"""
d = {"a": 1, "b": 2, "c": 3}

new_d = {x:y for x,y in d.items() if y <= 1}
#字典推导式,items获取字典内容,如果value小于1,才会被征用写入新的字典
print(new_d)

021 格式化输出

"""
创建一个字典
key是a、b、c，value分别是列表1~10、列表11~20、列表21~30
格式化输出字典
"""
d = {
    "a":list(range(1,11)),
    "b":list(range(11,21)),
    "c":list(range(21,31)),
}
print(d)

029 遍历字典

"""
遍历如下字典
"""
d = {"a": list(range(1, 11)),
     "b": list(range(11, 21)),
     "c": list(range(21,31))
     }
a = d["a"]
b = d["b"]
c = d["c"]
print(f"a has value{a}")
print(f"b has value{b}")
print(f"c has value{c}")

1.5 循环LOOP

030 打印字母a到z

"""
打印字母a到z，每行一个字母
"""
import  string
a = string.ascii_letters
#a为str模块的a-Z
for i in a:
    #for循环遍历字符串获取内容
    print(i)

032 计算1到100数字的和

"""
编写代码，计算从1到100的和，包含1和100
即：1+2+3+4+.....+99+100

效果如下
"""
sum1 = 0
#定义初始数字用来存储每次的加和
for i in range(1,101):
    sum1 += i
    #每次循环sum的值增加i
print(sum1)

033 计算1到100偶数数字和

"""
编写代码，计算从1到100中偶数的数字和
即：2+4+6+2+.....+92+100

效果如下
"""
sum_value = 0
for i in range(1,101):
    if  i % 2 == 0:
        #如果
        sum_value += i
print(sum_value)

034 输出元素和下标

"""
完成如下脚本代码：
"""
a = [1, 2, 3]
for index,item in enumerate(a):
    print(f"Item {item} has index {index}")
解释：
enumerate(a)函数产出数组的（下标index，数值item）数据对
用for index, item in enumerate(a)可以依次取出index和item
在字符串前面加个f符号，里面可以用{item}、{index}的方式访问变量，这叫f-string语法

035 同时遍历多个序列

"""
编写代码，输入如下两个数据：
"""
a = [1, 2, 3]
b = (4, 5, 6)
for i,j in zip(a,b):
    print(f"{i+j} = {i}+{j}")
#解释：
不同的序列（列表、元组都叫序列），可以用zip打包在一起
zip的返回是一各个的元组，里面包含各个序列的对应元素

1.6 函数function

036 编写加速度函数

"""
创建函数，计算加速度，初始和结束的速度为v1和v2，初始和结束的时间为t1和t2
然后，用参数(v1, v2, t1, t2)分别为(0, 10, 0, 20)调用函数，得到结果为：
"""
def speed(v1,v2,t1,t2):
    #定义函数需要传入4个属性
    a = ( v2 - v1 ) / ( t2 - t1 )
    #定义a方法为平均速度
    return a
    #执行函数返回内容,否则默认返回none

print(speed(0,10,0,20))
#调用函数并传入属性

032 方法不存在

import math
print(dir(math))
print(help(math.cos))
print(math.cos(1))
"""
解释：
print(dir(math))可以查看这个模块的所有方法名
print(help(math.cos))可以看到这个方法的注释，看到是计算cosine的
如果在pycharm中，可以按住键盘的ctrl键同时鼠标左键点击math.cos方法名，可以看到这个方法的源代码的注释
"""

039 函数参数数目错误

"""
如下代码报错，你知道为什么吗，怎么修正它？
"""
import math
print(math.pow(2))
### pow() takes exactly 2 arguments (1 given)##
##Pow()接受2个参数(给定1个)

--修正后
"""
如下代码报错，你知道为什么吗，怎么修正它？
"""
import math
print(math.pow(2,2))
#此方法是计算a值的b次方,可以通过查看math函数内置方法翻译的知用法

040 函数调用方式

"""
如下代码会报错，你知道为什么吗，怎么修复？
"""
def foo(a=1, b=2):
    return a + b
#函数体无错误

x = foo - 1
#可以看到调用函数时为加()

--修正后
def foo(a=1, b=2):
    return a + b
x = foo() - 1
print(x)

041 函数计算球的体积

"""
编写函数，计算球的体积
要求函数的参数半径r，有一个默认值10
然后用r=2为参数，调用函数得到结果
"""
--方法1
import  math
def volume(r=10):
    #定义带有默认属性的函数
    return (4 * math.pi * math.pow(r,3)) / 3
    #返回内容为V＝4πR³ /3(圆的体积)
    #math.pow为内置函数计算变量属性r的三次方
hh = volume(2)
print(hh)

--方法2
import math

def volume(r=10):
    return (4 * math.pi * r ** 3) / 3
print(volume(2))
#不用pow内置方法

043 全局变量

"""
如下代码会输出什么内容？为什么呢？
"""
c = 1
def foo():
    #此处函数只是被定义
    return c
    #只有函数被调用时,才会输出以及获取值
c = 3
#此时定义新的c的值
print(foo())
#此处调用函数,则会将最新的c的内容进行输出

044 函数局部变量

"""
如下代码会输出什么内容？为什么呢？
"""
c = 1
def foo():
    c = 2
    #局部已经定义变量内容
    return c
    #优先级最高的为局部变量,所以返回c=2
c = 3
print(foo())

"""
解释：
python的函数，从上往下一行一行执行
函数内可以访问函数外的全局变量，但是局部变量的优先级更高
"""

045 局部变量和全局变量

"""
如下代码的最后一行，会报错说NameError: name 'c' is not defined
怎样修复代码，让代码不报错，并且输出数值1？
"""
def foo():
    c = 1
    return c
foo()
print(c)
##报错:name 'c' is not defined           --变量c没有被定义

--修订后
def foo():
    global c
    #global 全局，将c引入全局变量.方可调用
    c = 1
    return c
foo()  #执行函数内容
print(c)

1.1 字符串String

"""
如下代码让用户输入name和age，然后拼接字符串
但是代码会报错 TypeError
你知道为什么吗？怎么修复？有另一种办法吗？
"""
name = input("Enter name: ")
age = input("Enter age: ")
print("Your name is %s and your age is %s" % name, age)


--修改后
"""
如下代码让用户输入name和age，然后拼接字符串
但是代码会报错 TypeError
你知道为什么吗？怎么修复？有另一种办法吗？
"""
name = input("Enter name: ")
age = input("Enter age: ")
print("Your name is %s and your age is %s" % (name,age))
print(f"Your name is {name} and your age is {age}" )
#解释：
#每个%占位符，在后面的%需要一个变量对应起来，如果多于一个%占位符，后面的%之后需要跟一个元组tuple包含多个变量，所以需要用(name, age)这个元组
#f-string是第二种好用的格式化方式，形如f"Your name is {name}"，在字符串中可以用{变量名}的方式格式化

042 字符串拆分

"""
创建一个函数，以任何一个英文字符串作为入参，返回英文单词的数目
"""
--方法1
l1 = []
#定义空的列表用来接收单词
def count_words(string):
    for i in string:
        #for循环遍历传入的单词
        l1.append(i)
        #每一个都塞入列表中
count_words("dsadasdasd")
print(len(l1))
#打印列表的元素长度

--方法2
def countt_words(string):
    string_list = string.split()
    #定义strlit为传入字符串的split(默认空格分隔)
    return len(string_list)
#返回string——list的长度
print(countt_words("i am good boy!!"))
#返回4个,因为用空格进行了分隔.

049 文件中的英文单词计数

"""
编写函数，传入.txt文件路径作为参数，统计文件中英文单词的数目
提示：
函数的参数是文件路径
读取文件内容，用str.split拆分，用len统计单词个数
返回单词个数
"""
def file(url):
    #定义函数和属性
    with open(f"{url}",encoding="utf-2") as v:
        #打开文件并起别名v
        str = v.read()
        #str来收集文件内容
        str_list = str.split()
        #str_list为空格分隔的内容
        return len(str_list)
    #返回split后的长度
print(file("p049.txt"))
#打印文件为p049.txt的长度

050 多分隔符单词计数

"""
编写函数，传入.txt文件路径作为参数，统计文件中英文单词的数目
注意，不只是空格分割，也可能是逗号分隔
提示：
函数的参数是文件路径，返回的是单词个数
用re.split(",| ", text)可以用多个分隔符拆分字符串

"""
import re
#re是python内置的正则表达式模块，可以实现模式匹配
def file(url):
    with open(f"{url}",encoding="utf-2") as v:
        str = v.read()
        str_list = re.split(r",| ",str)
        #,或者空格进行分隔
        return len(str_list)
print(file("p050.txt"))

#解释
#re是python内置的正则表达式模块，可以实现模式匹配
#模式的意思，例如一个字符串“包含10个数字”、“逗号或者空格作为分隔符”等模式
#re.split的第一个参数，一般都前一个r意思是raw-string，里面如果有反斜线不用多次转义

1.2 循环与文件

051 生成字母文件

#!/bin/evn python
"""
051 生成字母文件
编写代码，生成一个文件p051.txt，每一行是一个英文字母，从a~z
"""
import string
file = "p051.txt"
with open(f"{file}","w",encoding="utf-2") as v:
    str = string.ascii_lowercase
    for i in str:
        v.write(i+"\n")

##第二种
file = "p051.txt"
with open(f"{file}","w",encoding="utf-2") as v:
    for letter in string.ascii_lowercase:
        v.write(letter+"\n")

052 成对字母文件

"""
编写代码，生成文件p052.txt，每一行是两个英文字母的组合：
"""
#!/bin/evn python
"""
052 成对字母文件
编写代码，生成文件p052.txt，每一行是两个英文字母的组合：
"""
import string
file = "p052.txt"
with open(f"{file}","w",encoding="utf-2") as f:
    for i,j in zip(string.ascii_lowercase[::2],string.ascii_lowercase[1::2]):
        #多个数据类型的内容,可以通过zip进行打包访问,::2.以每2个步长的内容获取数据,[1::2]从下标为1开始,每2步获取内容
        f.write(i + j +"\n")

053 成对三字母文件

#!/bin/evn python
"""
053 成对三字母文件
编写代码，生成文件p053.txt，每一行是三个英文字母的组合：
提示：
zip函数可以将多个序列同时打包在一起，不只是2个，可以是3个
注意，26个英文字母，不是21个，不能被3除尽，最后一对只能是yz，需要做下处理
"""
import string
file = "p053.txt"
letters = string.ascii_lowercase + " "
#定义a-z的内容为:a-z" "即生成21个字符,否则不会输出yz
slice1 = letters[0::3]
#定义切片内容1为:每三步切割的内容即a开始
slice2 = letters[1::3]
#从b开始的每三步的内容
slice3 = letters[2::3]
#从c开始的没三步的内容
with open(f"{file}","w",encoding="utf-2") as v:
    for s1,s2,s3 in zip(slice1,slice2,slice3):
        #for循环进行值的遍历获取.zip元素将多个打包在一起
        v.write(s1 + s2 + s3 + "\n")
        #将遍历的内容写入文件

054 每个字母一个文件

#!/bin/evn python
"""
编写代码
1、在当前目录下新建一个目录，名字为 p054
2、给26个英文字母在p054目录下生成一个文件，文件名分别是a.txt、b.txt ~~ z.txt，文件内容分别是字母a、b~~z
"""
import os,sys,string
path = "/root/python3/code_test/p054"
#定义生成的目录的绝对路径,也可相对路径.
if os.path.exists(path):
 #如果目录存在就不会创建
    print("目录已存在,不允许创建.")
else:
    os.makedirs(path)
    #os模块内置函数创建目录
    print(f"目录{path}已创建")
for letter in string.ascii_lowercase:
    #letter进行a-z的赋值
    #string有三个ascii的用法lowercase为a-z,uppercase为A-Z,letters为a-z,A-Z
    with open(f"{path}/{letter}.txt","w",encoding="utf-2") as v:
        #通过for循环打开一个txt写入letter的值
        v.write(letter + "\n")
        #不存在的文件txt会被创建出来
        print(f"文件{letter}.txt已被创建并输入！！")

055 扫描字母文件列表

#!/bin/evn python
"""
编写代码，
1、扫描p054文件夹，里面是a.txt/b.txt~z.txt共26个文件，每个文件的都是对应字母a~z
2、读取每个文件的内容，最终产出一个list，是字母a~z
"""

--第一种方法！！
import os,sys,string
path = "/root/python3/code_test/p054"
if os.path.exists(path):
    #os模块判断path是否存在,返回true和false
    print("目录存在开始扫描！.")
    list=[]
    letter = string.ascii_lowercase
    for i in letter:
          with open(f"{path}/{i}.txt",encoding="utf-2") as v:
                list.append(v.read().strip())
    print(list)
else:
    print("文件或目录不存在！！！")
    exit
    
--第二种方法！！
import glob
path = glob.glob("/root/python3/code_test/p054/*.txt")
#定义path为p054下的所有txt文件.*通配符
#此场景适合找所有的txt文件,任意开头结尾为txt即会被遍历
list=[]
for file in path:
    #file为所有*.txt文件
    with open(file) as v:
      list.append(v.read().strip())
    #strip:清空字符前后空格,默认
print(list)
"""
解释：
glob.glob("p054/*.txt") 可以匹配得到文件列表
f.read()可以读取文件所有内容，.strip()可以去除两边的空格c
"""

--方法3！！
import glob
path = glob.glob("p054\*.txt")
list = []
for file in  path:
    with open(f"{file}") as v:
        for i in v:
            i = i[0]
            #如果文件存在多行或者,换行符等,用for循环进行格式化
            list.append(i)
# print(list)
list = set(list)
#读取的列表用set进行去重
print(list)
#因为列表是无序的所以内容可能顺序不一致

056 满足条件的字母文件

#!/bin/evn python
"""
056 满足条件的字母文件
编写代码，
1、扫描p054文件夹，里面是a.txt/b.txt~z.txt共26个文件，每个文件的都是对应字母a~z
2、如果文件里的内容字母，属于字符串"python"中的字母，则存入结果列表
3、打印结果列表
"""
import glob,os
file_list = glob.glob("/root/python3/code_test/p054/*.txt")
template = "python"
list = []
for file in file_list:
    if os.path.exists(file):
        with open(f"{file}",encoding="utf-2") as v:
            str = v.read().strip()
        if str in template:
            list.append(str)
print(list)

0566 字典嵌套

students = [
    {'学号': 1, '姓名': '乐乐', '年龄': 12, '性别': '男', '成绩': 11},
    {'学号': 2, '姓名': '倩倩', '年龄': 11, '性别': '女', '成绩': 23},
    {'学号': 3, '姓名': '苗苗', '年龄': 13, '性别': '女', '成绩': 92},
    {'学号': 4, '姓名': '旭旭', '年龄': 12, '性别': '男', '成绩': 65},
    {'学号': 5, '姓名': '花花', '年龄': 11, '性别': '男', '成绩': 66},
]
# 统计每个年龄的人数
age = {}
#定义空字典用来收集value
#字典的key是不能重复的,如果出现重复的后边的会替换到前边的”
for i in students:
    #i进行字典内容的赋值
    if  i["年龄"] not in age:
        #如果年龄(12)不在age空字典中
        #此时i获得的内容为12，11，13，12，11
        age[i["年龄"]] = 1
        #那么定义年龄数字key对应的value为1
        #12 = 1
    else:
        age[i["年龄"]] += 1
        #否者年龄的value在基础上加1
        #12 = 1+1
for i,x in age.items():
    print(f"年龄：{i},在大的字典中出现了：{x}次！")

# 统计每个性别的人数
sex = {}
for i in students:
    if  i["性别"] not  in sex:
        sex[i["性别"]] = 1
    else:
        sex[i["性别"]] += 1
print(sex)

# 获取性别为女的学生信息
for i in students:
    if  i["性别"] == "女":
        print(i)
print(" ")

# 获取成绩优异的学生信息
for i in students:
    if  i["成绩"] >= 20:
        print(i)
print(" ")

# 获取年龄是偶数的学生信息
for i in  students:
    if  i["年龄"] % 2 == 0:
        print(i)
print(" ")
# 获取成绩为偶数的学生信息
for i in students:
    if  i["成绩"] % 2 == 0:
        print(i)

1.9 多级字典与JSON

051 多级字典

"""
如下是一个多级字典，也就是说每个字典的KEY的VALUE，也是个数据结构
怎么访问employees的第二个人，得到他的lastName，即 Smith
"""
d = {"employees": [{"firstName": "John", "lastName": "Doe"},
                   {"firstName": "Anna", "lastName": "Smith"},
                   {"firstName": "Peter", "lastName": "Jones"}],
     "owners": [{"firstName": "Jack", "lastName": "Petter"},
                {"firstName": "Jessy", "lastName": "Petter"}]}
#访问第一个key对应的value
print(d["employees"])

#访问value list中的下标为1即中间的字典
print(d["employees"][1])

#访问字典中的key--lastName获取对应value--smith
print(d["employees"][1]["lastName"])

052 修改多级字典

"""
如下是一个多级字典，也就是说每个字典的KEY的VALUE，也是个数据结构
怎么访问 employees 的第二个人，修改他的 lastName
将值从 Smith 改成 Smooth
"""
d = {"employees": [{"firstName": "John", "lastName": "Doe"},
                   {"firstName": "Anna", "lastName": "Smith"},
                   {"firstName": "Peter", "lastName": "Jones"}],
     "owners": [{"firstName": "Jack", "lastName": "Petter"},
                {"firstName": "Jessy", "lastName": "Petter"}]}
d["employees"][1]["lastName"] = "Smooth"
#访问d['employees'][1]['lastName']，是Smith值的位置
#直接加=号，就是给他赋新的值。和普通字典用法一致
print(d["employees"])
#打印字典d中的key为employess的值

059 多级字典加值

"""
如下是一个多级字典，也就是说每个字典的KEY的VALUE，也是个数据结构
怎么给 employees 添加一个人：'firstName': 'Albert', 'lastName': 'Bert'
"""
d = {"employees": [{"firstName": "John", "lastName": "Doe"},
                   {"firstName": "Anna", "lastName": "Smith"},
                   {"firstName": "Peter", "lastName": "Jones"}],
     "owners": [{"firstName": "Jack", "lastName": "Petter"},
                {"firstName": "Jessy", "lastName": "Petter"}]}
d["employees"].append({"firstName":"Albert","lastName":"Bert"})
#因为字典d中的key--employees的value为list,所以直接在employeesvalue下append即可
print(d["employees"])
#打印字典d中的key为employess的值可以看到多出了append追加的值

060 字典变JSON

"""
把如下字典，变成JSON格式，存入一个文件 hh.json
"""

d = {"employees": [{"firstName": "John", "lastName": "Doe"},
                   {"firstName": "Anna", "lastName": "Smith"},
                   {"firstName": "Peter", "lastName": "Jones"}],
     "owners": [{"firstName": "Jack", "lastName": "Petter"},
                {"firstName": "Jessy", "lastName": "Petter"}]}

import json
new_date = json.dumps(d,indent=2)
#dumps将d字典转换为str常规字符串
#indent加了之后会让JSON样式更加缩进美观
print(f"转换后的内容为:{new_date}\n类型为:{type(new_date)}")
with open("hh.json","w",encoding="utf-2") as v:
    v.write(new_date)
    print("文件已经被创建并输入内容！！！")

with open("hh.json",encoding="utf-2") as f:
    hh = f.read()
    hh = json.loads(hh)
    #将json文件中的str读取为python中的数据类型内容
print(f"文件内容为:{hh} \n类型为:{type(hh)}")
print(hh["employees"][1])
#打印读取文件后的hh字典中employees的value列表内容中的下标为1的内容




import json,pprint
with open("hh.json",encoding="utf-2") as v:
    d = json.loads(v.read())
pprint.pprint(d)
#pprint可以实现字典的格式化输出

062 JSON添加数据

"""
完成如下步骤：
用python加载p060.json文件，转成字典
给 employees 添加一个人：
'firstName': 'Albert', 'lastName': 'Bert'
将数据生成json，结果存到 p062.json文件
"""
import json
import os
import time

file = "hh.json"
# 定义json文件路径
if os.path.exists(file):
    # 如果文件存在则执行！！
    print("文件存在,准备读取加入新的值!")
    with open(f"{file}", encoding="utf-2") as v:
        # 打开文件别名为v
        dict1 = json.loads(v.read())
        # 定义变量为json取文件后的数据类型内容
        dict1["employees"].append({"firstName": "Albert", "lastName": "Bert"})
        # 在dict1字典的key--employees中的list值中追加一个新的记录
    data = json.dumps(dict1, indent=2)
    # data变量为将追加进去的dict1的内容进行str转换
    with open(f"{file}", "w", encoding="utf-2") as f:
        f.write(data)
        # 将新的dict已str的方式存入json文件
else:
    print("文件不存在,已退出！！")
    # 如果文件不存在则报错
    exit(11)
    # 赋值退出状态码为11
time.sleep(1)
print("准备读取文件！")
import pprint

with open(f"{file}", encoding="utf-2") as json_data:
    pprint.pprint(json.loads(json_data.read()))
    # 格式化读取文件已数据类型方式展示.pprint输出美观的dict
####选中代码ctrl +alt +l 格式化代码更美观

2.0 循环条件控制

065 渐进式定时打印

"""
实现python代码，输出hello，停顿1秒；输出hello，停顿2秒；输出hello，停顿3秒；
按此一直持续：
"""
import time
sum = 1
#初始化秒数为1,sum为计数器
while True:
    #死循环
    print(f"当前停顿秒数{sum}")
    #打印当前要停顿的秒数
    time.sleep(sum)
    #停顿对应秒数
    print("hello")
    sum += 1
    #结束一次+1秒,下一个hello就会延时1s出现

061 空语句

while True:
    print("Hello")
    if 2 > 1:
        pass
    #pass 是 Python 中的关键字，用来让解释器跳过此处，什么都不做
    #即跳过此处输出fi,继续循环
    print("Hi")
   

---方法2
while True:
    print("Hello")
    if  1 == 1:
        print("Hi")
        #for循环匹配一次后输出Hi,就会回到while循环继续输出
        
        
解释：
pass可以跳过当前语句，但是继续往下执行，也会进入下一次循环
break会忽略当次循环下方语句，直接退出当前循环
continue会忽略当次循环下方语句，依然进入下一个循环

2.1英汉翻译字典

069 英汉翻译

"""
完成如下程序，让用户可以输入一个英文单词，程序给出中文翻译结果
"""
d = {"apple": "苹果", "orange": "桔子", "banana": "香蕉"}


def hh(world):
    #定义函数和函数属性
    return d[world]
#返回字典d[属性的value]
world = input("Enter World:")
#world为交互式输入的因为单子
print(hh(world))
#返回英文对应的中文

010 英汉翻译异常处理

"""
如下程序实现功能，让用户可以输入一个英文单词，程序给出中文翻译结果
修改程序，如果输入的英文单词不在字典中，输出信息“单词不在词典中”
"""
d = {"apple": "苹果", "orange": "桔子", "banana": "香蕉"}

def translate(word):
    return d[word]
while True:
    word = input("Enter World:")
    if  word not in d.keys():
        #如果输入的单词不在字典的key中
        print("word not such！！！")
        #那么就打印没有匹配的内容
    else:
        print(translate(word))
        #如果匹配成功那么返回函数体
        
        
--方法2
d = {"apple": "苹果", "orange": "桔子", "banana": "香蕉"}


def translate(word):
    try:
        # 代码交给try管理
        return d[word]
    except KeyError:
        # 错误类型为key错误
        return f"no such key: {word}"
    # 返回错误信息


world = input("Enter World:")
print(translate(world))
# 不报错才会执行此条件

011 英汉翻译文件词典

"""
如下是英汉翻译词典文件，用python加载词典文件
当用户输入英语单词时，返回中文文字
增加：程序应该处理大小写情况，例如输入Apple也能返回apple的翻译
"""
dict = {}
import os
file = "p011.txt"
if  os.path.exists(f"{file}"):
    print("文件存在！")
    with open(f"{file}",encoding="utf-2") as v:
        for lien in v:
            en,cn = lien.strip().split(",")
            dict[en]=cn
def translate(world):
    try:
        return dict[world]
    except KeyError:
        return "no such wordl!!"
print(translate(input("请输入要查询的单词：").lower()))
#lower将输入内容转小写



--方法2
#!/bin/env python
dict = {}
#定义空字典,用来接收文件中的内容
with open("英汉词典.txt",encoding='utf-2') as fin:
	for i in fin:
		i = i[:-1]
		#通过列表推导式去除换行符,读取文件默认生成的都为列表
		fieds = i.strip().split(",")
		#格式化内容为fieds
		if len(fieds) == 2:
			#fieds按照,号进行分割,那么读取每行文件,那么就会是俩个参数
			en,cn = fieds
			dict[en] = cn
		else:
			continue
	print(f"字典已生成:{dict}")
	#for循环读取文成后,循环次数为文件行数.打印生成的字典
while True:
	key = input("输入你要查询的单词对应的英文:").lower()
	if key == "exit" or key == "quit" or key == "no":
		break
	elif key not in dict.keys():
		#如果要查询的key不在字典的key中则无法拆线呢
		print(f"没有找对{key}这个key!")
	else:
		print(f"你查询的{key}的中文为:{dict[key]}")

2.2 日期时间

012 当前日期时间

from  datetime import datetime
print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))


#!/bin/env python
import datetime
print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
"""
datetime是内置的日期时间处理模块
datetime.now()返回当前的时间对象
datetime.now().strftime可以将时间对象格式化
"""

013 输入年龄计算出生年月

"""
编写Python代码，用户可以输入年龄数字，程序打印生日年份
"""
from datetime import datetime
age = input("请输入你的年龄：")
age = int(age)
#age必须为int类型
year_age = datetime.now().year - age
#year_age为当前年份减去输入的年龄为出生的年份
print("你的出生年份是：",year_age)

014 计算活了多少天

"""
编写Python代码，用户可以输入生日，程序打印活了多少天
"""
import  datetime
birthday = input("输入你的出生日期,用-分隔:")
#交互输入出生的日期
birthday_date = datetime.datetime.strptime(birthday, "%Y-%m-%d")
#将输入的内容进行格式化可以将字符串转换成日期对象
curr_time = datetime.datetime.now()
#定义当前的时间
live_day = curr_time - birthday_date
#当前时间减去生日
print(f"你已经在地球上出现了{live_day.days}天！！！")
#.days只要天不要秒

015 计算今天明天昨天的日期

"""
编写代码，输出今天、昨天、明天、一周前的日期
可以编写个函数实现
如果今天是2022-05-14，输出形如：
"""
"""
提示：
datetime.datetime.now()得到当前日期对象
datetime.timedelta(days=days)可以得到一个时间间隔对象
日期对象和间隔对象的加法和减法，得到结果对象
"""
import datetime

def diff_days(days):
    pdate_obj = datetime.datetime.now()
    #定义现在
    time_gap = datetime.timedelta(days=days)
    #定义时间间隔对象days=为固定内置函数
    pdate_result = pdate_obj - time_gap
    #返回结果为今天减去传入的天数days
    return pdate_result.strftime("%Y-%m-%d")
#返回内容为年月日

print(f"今天为:{diff_days(0)}")
#0为和当前间隔时间为0即为当天
print(f"昨天为:{diff_days(1)}")
#1为今天时间基础-1
print(f"明天为:{diff_days(-1)}")
#-1为今天时间基础+1
print(f"一周前的日期为:{diff_days(1)}")
#今天时间减1

016 输出间隔内的所有日期

#!/bin/env python
import datetime

def get_date_range(begin_date, end_date):
    date_list = []
    #定义空的集合,用来存时间
    while begin_date <= end_date:
        #如果开始时间小于结束时间进入循环
        begin_date_object = datetime.datetime.strptime(begin_date, "%Y-%m-%d")
        #strptime是将一个（时间）字符串解析为时间的一个类型对象。
        #将输入的开始时间进行格式化,格式化为是后方定义形式
        days1_timedelta = datetime.timedelta(days=1)
        #定义时间间隔对象为1天.
        begin_date = (begin_date_object + days1_timedelta).strftime("%Y-%m-%d")
        #strftime是转换为特定格式输出.只要年月日不要时分秒
        #开始时间加一天
        date_list.append(begin_date)
        #将每次获取的开始时间追加到列表中
    return date_list
    #返回列表内容

begin_date = "2023-01-01"
end_date = datetime.datetime.now().strftime("%Y-%m-%d")
#最后时间为年月日不精确至秒数
date_list = get_date_range(begin_date, end_date)
print(date_list)
#返回的为定义的开始时间到今天


>>>>>>>>>>>>>>>>>Python中的时间函数strftime与strptime对比<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
#!/bin/env python 
import datetime
begin_date_object = datetime.datetime.strptime("2022/02/11", "%Y/%m/%d")
#strptime：将字符串解析为给定格式的日期时间对象。字符串=>日期时间对象，解析字符串.解析结果为默认的date数据类型格式
print(begin_date_object)
###输出结果为:2022-02-11 00:00:00

#strftime函数：将给定格式的日期时间对象转换为字符串。日期时间对象=>字符串，控制日期时间对象的输出格式
#!/bin/env python
import datetime
dt=datetime.datetime(2023, 2, 20, 16, 30)
print(dt.strftime("%Y-%m-%d %H:%M"))
2023-02-20 16:30
#此函数会将给定的字符内容或者约定的格式进行格式化.
print (dt.strftime("%Y-%m-%d"))
2023-02-20

#strftime控制格式化输出，strpttime将字符转换为时间对象,需要声明输入格式

#strft处理已经是数据格式的对象内容,转换为定义的时间格式内容
#stpft处理不是数据格式的对象内容,按照指定对应formart转换时间格式内容

2.3 用户名和密码检测

011 用户名检测器

#!/bin/env python
"""
编写Python代码，要求用户输入用户名，进行检测：
1、用户名至少6位；
2、文件名不能在文件p011_users.txt中存在
"""
import os
file = "p011_users.txt"
if os.path.exists(file):
    while True:
        pass
        username = input("请输入用户名:")
        with open(f"{file}",encoding="utf-2") as v:
            users = [name.strip() for name in f.readlines() if name.strip()]
            #users为按行读取的文件内容,并清空前后字符串
            #并去除空行

        if len(username) < 6:
            print("你输入账户长度小于6位,请重新输入！")
            continue

        if username in users:
            print("用户名已存在,请重新输入！")
            continue
        else:
            print("新用户验证通过")
            break
else:
    print("文件不存在,无法校验！！")
    #文件不存在则退出
    exit(11)
 
----方法2
#!/bin/env python
"""
编写Python代码，要求用户输入用户名，进行检测：
1、用户名至少6位；
2、文件名不能在文件p011_users.txt中存在
"""
import os
file = "p011_users.txt"
if os.path.exists(file):
	list = []
	with open(f"{file}",encoding="utf-2") as f:
		for i in f:
			i = i.strip()
			#此时i读取的f中的每一行内容
			if len(i) > 0:
				#如果字符长度大于0
				list.append(i)
				#则追加到列表中
else:
	print("用户文件不存在！")
	exit(11)
while True:
	username = input("请输入你的用户名:")
	if username == "exit" or username == "quit":
		exit(12)
	elif len(username) < 6:
		print("用户名长度不够,至少为六位！")
		continue
	elif username in list:
		print("用户名已存在")
		continue
	else:
		print(f"{username}用户已创建！")

012 随机密码生成器

#!/bin/env python
"""
编写Python代码，用户输入密码位数，给出一个随机密码生成
"""
"""
提示：
python自带的string模块，提供多种字符集合，
小写字母：string.ascii_lowercase；
大写字母：string.ascii_uppercase；
数字：string.digits；
标点符号：string.punctuation
random是随机数模块，random.sample可以从序列中随机得到几个字符的列表
"""
import string,random
worlds = string.ascii_lowercase + string.ascii_uppercase + string.digits + string.punctuation
len = int(input("请输入密码位数："))
chosen = random.sample(worlds,len)
#sample中的len必须为int类型
#print(chosen)                 #默认chosen会变为一个列表.
#random.sample可以从序列中随机得到几个字符的列表
psd = "".join(chosen)
#""为空内容,chosen为对应新增序列内容,结合时不加任何内容
#将列表内容结合,总结不做任何字符的改动.列表结合
print(f"密码为：{psd}")

019 密码强度检测器

#!/bin/env python
"""
编写Python代码，需要用户一直输入密码，直到满足如下条件才退出循环：
至少包含一个数字；
至少包含一个大写字母；
密码至少6位数；

实现效果如下，如果不满足条件会一直循环：
"""
while True:
    print("*" * 20);print("密码至少六位数,至少包含一个大写字母和一个数字")
    pwd = input("请输入密码:")
    have_number = any([i.isdigit() for i  in pwd])
    have_upper = any([i.isupper() for i in pwd])
    #isupper是否包含大写字母,isdigit是否包含数字
    #any后方元素命中一个则为true

    if have_upper and have_number and len(pwd) >= 6:
        print("密码校验成功！")
        break
    else:
        print("密码校验失败！")
        continue
#解释：
#any这个方法，参数可以是一个list/set等序列，如果任何一个元素为True，那么any返回True
#如果通过校验，则break退出循环；否则打印信息，继续下一次循环；

020 详细错误密码检测器

#!/bin/env python
"""
编写Python代码，需要用户一直输入密码，直到满足如下条件才退出循环：
至少包含一个数字；
至少包含一个大写字母；
密码至少6位数；
"""
while True:
    msgs = []
    pwd = input("请输入密码:")
    if not any([i.isdigit() for i in pwd]):
        #如果遍历pwd中不存在数字,那么any返回false.
        msgs.append("需要至少一个数字")
        #any为false则追加一个msgs至列表中.
    if not any([i.isupper() for i in pwd]):
        #如果pwd中不存在大写字母
        msgs.append("需要至少一个大写字母")
        #any为fasle追加报错至列表中
    if len(pwd) < 6:
        msgs.append("需要至少6个字符")
    if len(msgs) == 0:
        #列表为空.说明没有报错
        print("密码检测通过！")
        break
    else:
        #如果没有break退出,那么输出报错原因
        print("密码验证失败,原因如下:")
        for message in msgs:
            print("*",message)
            #输出报错原因后,重回循环,列表清空
>>>>解释：
#msgs为出错信息列表，任何一个检测不通过，就放进msgs;
#如果msgs为空，说明所有检测通过；如果不为空，则有多条检测不通过，会挨个输出

2.4 文件处理统计

021 文件内容乘数字

"""
新建文件p021.txt，将如下内容粘贴到文件中
编写代码，给每个数字乘以2，结果输出到p021_output.txt
"""
with open("p021.txt",encoding="utf-2") as read,open("p021_output.txt", "w") as out:
    for line in read:
        #按行读取数据,即进行6次循环
        if "x,y" in line:
            #第一次循环会拿到第一行即x,y
            out.write(line)
            #那么就写入到文件中
        else:
            #第二行开始没有x,y则执行else中的内容
            x,y = line.strip().split(",")
            #strip将末尾的换行符去除
            x = int(x) * 2
            y = int(y) * 2
            out.write(f"{x},{y}\n")

022 计算最大值最小值平均值

"""
输入一个成绩文件，计算成绩的最大值最小值平均值

文件名：p022.txt，自己复制如下内容进去即可：
"""
def compute_score():
    scores = []
    with open("p022.txt",encoding="utf-2") as v:
        for line in v:
            #按行读取数据
            fields = line.strip().split(",")
            #strip情况换行符,split按照,号进行内容的读取
            scores.append(int(fields[2]))
            #列表追加fields列表中索引为2的内容
        max_score = max(scores)
        min_score = min(scores)
        avg_score = sum(scores) / len(scores)
        return max_score,min_score,avg_score
        #调用函数返回三个对应值的内容
max_score,min_score,avg_score = compute_score()
#定义三个值来取函数返回的三个值,one by one
print(f"最高分:{max_score}")
print(f"最低分:{min_score}")
print(f"平均分:{avg_score}")

023 文件合并

"""
用python编写代码，把这两个txt拼接在一个文件，存入p023.txt
"""
with open("po23.txt","w",encoding="utf-2") as out:
    #打开要写入的新的文件
    for name in ["p023_xiaomei.txt", "p023_xiaohua.txt"]:
        #for循环遍历读取的文件
        with open(name,encoding="utf-2") as fin:
            #打开读取文件
            for line in fin:
                #line进行按行读取
                out.write(line)
                #每一行写入新的文件中

024 文件交集

--方法1
"""
用python编写代码，计算两个人的爱好的交集
提示：set集合，有方法叫做 intersection，可以直接计算交集
"""
list = []
new_data = []
for name in ["p024_xiaomei.txt","p024_xiaohua.txt"]:
    #循环读取两个文件
    with open(name,encoding="utf-2") as f:
        #打开循环的俩个文件
        for line in f:
            #按行读取文件内容
            line = line.strip()
            #清楚换行符
            fieds = line.split()
            #用空格分隔
            list.append(fieds[1])
            #因为读取出的数据是列表的形式,1为爱好.直接追加至列表中
while list:
    #根据list的内容进行循环,list为两个文件的内容
    pop_l = list.pop()
    #在list列表中进行pop
    if pop_l not in list:
        continue
        #如果取出的值不在列表中说明是差集则丢弃
    else:
        new_data.insert(0,pop_l)
        ##否则取出的值还存在与list为并集
print(new_data)

--方法2
"""
用python编写代码，计算两个人的爱好的交集
提示：set集合，有方法叫做 intersection，可以直接计算交集
"""
def get_aihao(fname):
    aihao = []
    with open(fname,encoding="utf-2") as f:
        for line in f:
            line = line.strip()
            aihao.append(line.split()[1])
            #爱好为追加按行读取的文件内容列表索引为1的内容
        return aihao
xiaomei = get_aihao("p024_xiaomei.txt")
#定义xiaomei为执行函数和文件路径
xiaohua = get_aihao("p024_xiaohua.txt")
for i in set(xiaomei).intersection(set(xiaohua)):
    #直接将xiaomei获取的值转换为set集合可以去
    #intersection俩个集合进行比较,获取交集
  print(i)

025 每种爱好的喜欢人数

"""
输入一个（姓名，爱好）文件，计算每个爱好的人数

文件名：p025.txt，自己复制如下内容进去即可，姓名和爱好是空格分割的：
"""
like_count = {}
#定义空字典,用来去重和统计
with open("p025.txt",encoding="utf-2") as f:
    for line in f:
        fieds = line[:-1]
        #fieds为f的文件内容,即每一行的完整内容
        sname ,likes = fieds.split()
        #名字和爱好进行拆包获取值
        like_list = likes.split(",")
        #爱好为likes的,号拆包值
        for like in like_list:
            #爱好遍历每一个拆包的球类运动
            if  like not in like_count:
                #如果这个球类没有在字典中,遍历字典获取的是单个字符串
                like_count[like] = 1
                #如果没有则为第一次
            else:
                like_count[like] += 1
                #负责在计数的基础上+1
for key,value in like_count.items():
    print(key,value)

026 实现文件的关联

"""
有两个文件：
文件1：成绩文件，列为（学号、成绩）
文件2：学生信息文件，列为（学号，姓名）
关联两个文件，得到（学号、姓名、成绩），结果存入 p026.txt
"""
grade_dict = {}
with open("p026_grade.txt",encoding="utf-2") as read:
    for line in read:
        fieds = line[:-1]
        #格式化字符,去除换行符
        id,grade = fieds.strip().split(",")
        grade_dict[id] = grade
    print(grade_dict)

file = open("p026.txt",'w',encoding="utf-2")
with open("p026_student.txt",encoding="utf-2") as st_read:
    for line in st_read:
        id,sname = line.strip().split(",")
        #id,name通过循环进行拆解
        grade = grade_dict[id]
        #grade为通过上方gradetxt获取的字典,来获取此时grade的值,id对应的value
        #id为此时的student文件获取的id
        file.write(f"{id},{sname},{grade}\n")
        #通过拆解的id,name和上方生成的gradde字典获取grade来生成新的文件
file.close()
#因为不是运用了with的方法,所以需要手动关闭文件



"""
有两个文件：
文件1：成绩文件，列为（学号、成绩）
文件2：学生信息文件，列为（学号，姓名）
关联两个文件，得到（学号、姓名、成绩），结果存入 p026.txt
"""
grade_dict = {}
with open("p026_grade.txt",encoding="utf-2") as read_one:
    for line in read_one:
        fieds = line.strip().split(",")
        if  len(fieds) == 2:
            id,grade = fieds
            grade_dict[id] = grade
        else:
            print("文件内容有误！")
            exit(11)
out = open("p026.txt",'w',encoding="utf-2")
with open("p026_student.txt",encoding="utf-2") as new_read:
    for line in new_read:
        fieds = line.strip().split(",")
        if	len(fieds) == 2:
            id,name = fieds
            grade = grade_dict[id]
            #因为俩个表的id是一致的,通过上方输出的字典中的key--id获取对应的成绩,满足输出要求
            out.write(f"{id},{name},{grade}\n")
        else:
            print("文件格式有误,无法拆出对应数字的包！")
            exit(12)
out.close()

2.5 正则表达式

021 判断日期格式

"""
编写函数date_is_right，判断日期是不是 YYYY-MM-DD 的格式
如果是返回True，否则返回False
"""
import  re
##re模块是python独有的匹配字符串的模块，该模块种提供功能基于正则表达式实现的，对于字符串进行模糊匹配找到想要的内容信息，一般用于爬虫或者自动化测试前后端不分离项目
def date_is_right(date):
    return re.match(r"\d{4}-\d{2}-\d{2}",date) is not None
#解释
#match()是从头开始匹配的 如果匹配不到就会返回None 并且匹配到一个就返回后面就不会匹配了re.match会给字符串匹配模式，如果匹配成功返回Match对象，匹配不成功返回None
#\d可以代表0到9的任何一个数字，{2}和{4}表示前面的\d会出现2和4次
#not None:都至为可以匹配,不返回none,则返回true和false.按照前方格式进行匹配
#r代表正则方式

print("2021-05-20", date_is_right("2021-05-20"))
print("202-05-20", date_is_right("2022-05-20"))
print("2021/05-20", date_is_right("2021/05-20"))
print("20210520", date_is_right("20210520"))
print("20a10520", date_is_right("20a10520"))


#!/bin/env python
import re
def data_is_true(date):
        return re.match(r"\d{4}/\d{2}/\d{2}",date) is not None

print("2022/02/22:",data_is_true("2022/02/22"))

022 提取电话号码

import re
text = "白日依19929221222山尽，黄河入45645546462192912海流。欲穷12345千里目，更上15619292345一层楼。"
pattern = r"1\d{10}"
#匹配开头为1后方为数字且为10个数字。
results = re.findall(pattern,text)
#结果为re.findall匹配字符中符合pattern条件的内容,读取为列表
#findall全文匹配
for i in results:
    #循环列表元素(2)
    print(i)
    #打印电话号码
    
#!/bin/env python
import re
text = "白日依19929221222山尽，黄河入45645546462192912海流。欲穷12345千里目，更上15619292345一层楼。"
pattern = re.compile(r"1\d{10}")
#re.compile定义正则匹配方式        --compile(编写)
result = pattern.findall(text)
#findall匹配结果返回列表
for i in result:
	print(i)

029 提取邮箱地址

import  re
context = """
寻隐者12345@qq.com不遇
朝代：唐asdf12dsa#abc.com代
作python666@163.cn者：贾岛
松下问童子，言师python-abc@163com采药去。
只在python_ant-666@sina.net此山中，云深不知处。
python_ant-666@sina.nettasd
"""
pattern = re.compile(r"[a-zA-Z0-9_-]+@[a-zA-Z0-9]+\.[a-zA-Z]{2,3}")
#re.compile可以提前编译正则表达式(定义正则匹配规则).内容为:a-9加特殊字符集合开头,@a-9+.a-Z出现2-3次,因为正常邮箱结尾都为2-3次
results = pattern.findall(context)
#re.findall可以搜索多种匹配模式(全文匹配)
#findall根据pattern指定的正则方法处理context的文本内容
print(results,len(results))

090 多个禁用词替换

"""
如下文字中，有很多不允许使用的词语，包含 最好、最低、绝对
用python将这三个词语，都替换成***字符串
"""
#!/bin/env python
conetxt = """
这个商品很好，质量最好、用起来很不错，并且价格最低，绝对的物美价廉
"""
import re
pattern = re.compile(r"最好|最低|绝对")
result = re.sub(pattern,"****",conetxt)
print(result)

sub(pattern, repl, string, count=0, flags=0)
# pattern：正则模型
# repl   ：要替换的字符串
# string ：要匹配的字符串
# count  ：指定匹配个数
# flags  ：匹配模式

091 给手机号打上马赛克

"""
如下文字中，有一些手机号数字
用python将所有的手机号，只保留开始和结尾数字，中间用******代替
"""
conetxt = """
白日依19929221222山尽，黄河入45645546462192912海流。
欲穷12345千里目，更上15619292345一层楼。
"""
import  re
pattern = r"(1\d)\d{1}(\d{2})"
#pattern方法为给开头1\d进行分组(俩位数),即开头的俩个数字(1\d).中间位数为1位,(\d{2})即尾数为2个数字作为第二个分组
print(re.sub(pattern,r"\1*****\2",conetxt))
#在re.sub的第二个参数，用\1和\2可以引用前面的两个分组
#\1引入pattern中的(1\d)这个分组,\2为第二个分组,中间内容替换为*,针对conetxt文件
#sub函数：替换匹配成功的指定位置字符串
##参考网页：
http://c.biancheng.net/view/1162.html
---python正则


----2.不要多余字符只要电话并打码
#!/bin/env python
conetxt = """
白日依19929221222山尽，黄河入45645546462192912海流。
欲穷12345千里目，更上15619292345一层楼。
"""
import re
old_pattern = re.compile(r"1\d{10}")
#编辑正则表达式1开头后面为0-9{10}共11个数字组成的内容
old_result = old_pattern.findall(conetxt)
#结果为:匹配文本中符合表达式的内容
for i in old_result:
    #取出的值都为list列表,遍历取出的电话号码
    pattern = re.compile(r"(1\d)\d{1}(\d{2})")
    #定义正则分组
    result = re.sub(pattern,r"\1*******\2",i)
    #按照正则表达式,替换字符串为中间内容,复用分组,针对i进行匹配替换
    print(result)

2.6 文件管理

092 扫描目录下所有文件

#!/bin/env python
"""
提供一个目录路径，用python扫描所有的文件，列出文件路径
"""
import os
dir = r"/root/python3/code_test"
#r表示raw-string，那么后面的字符串中反斜线将会是正常的字符而不是转义符号
for root,dirs,files in os.walk(dir):
	#root获取的是当前的目录也就是/root
	#dirs,files为目录下的子目录和文件列表(固定形式).
        for file in files:
        	#files为所有目录下的文件
                fpath = os.path.join(root,file)
                #将目录和文件结合输出,输出绝对路径
                print(fpath)

093 扫描py文件的行数

import os

dir = r"E:\py-资料\py学习\第二章--class类"
for root, dirs, files in os.walk(dir):
    # root为目录,dirs和files为子目录和文件.固定三个元素
    for file in files:
        # 遍历子目录中的文件
        if file.endswith(".py"):
            # 如果文件结尾为.py
            fpath = os.path.join(root, file)
            # 定义文件的输出为目录加文件名
            with open(fpath, encoding="utf-2") as f:
                # 打开找到的文件
                print(f"文件路径为:{fpath}--行数为:{len(f.readlines())}")
                # len(f.readlines())输出为集合,因为默认有换行符,所以列表个数为文件行数！！

094 自动整理文件夹

"""
自己新建一个目录 arrange_dir
自己在文件夹下，手动新建多个“假文件”：
aaa.txt bbb.mp3 ccc.avi ccc.jpg ddd.jpg eee.txt fff.mp3 ggg.jpg hhh.txt iii.mp3
"""
import os
import shutil
dir = "./arrange_dir"
for file in os.listdir(dir):
    #os.listdir列出指定目录下的所有文件
    ext = os.path.splitext(file)[1]
    #os.path.splitexe会将文件名和后缀分开,形成一个元组的数据类型[1]即为后缀
    #例:(kill,.py)
    ext = ext[1:]
    #按照字符串索引进行格式化,只要py
    #例：索引0为.,1-end为1:
    if not os.path.isdir(f"{dir}/{ext}"):
        #如果目录不存在
        os.mkdir(f"{dir}/{ext}")
        #则创建目录
        print(f"{ext}已创建！")
    else:
        print(f"目录{ext},已存在！")
    source_path = f"{dir}/{file}"
    #源路径即为当前目录下的文件
    dest_path = f"{dir}/{ext}/{file}"
    #目标路径为已文件后缀新创目录下
    shutil.move(source_path,dest_path)
    #shutil.move将源文件移动到目录路径下
print("Done")

095 自动压缩文件夹

"""
提供任何一个目录地址，用python实现文件夹的压缩，压缩成zip格式
例如：dir = r"D:\workbench\ant-python-exercises-100p"
则会生成一个文件 r"D:\workbench\ant-python-exercises-100p.zip"
这个压缩文件是对这个目录的压缩结果
"""
import os
import zipfile

def do_zip_compress(dirpath):
    #定义函数体方便调用
  output_name = f"{dirpath}.zip"
    #定义压缩后的名称
  parent_name = os.path.dirname(dirpath)
    #去掉文件名,返回目录名称,如果为多层目录返回前一层
  zip = zipfile.ZipFile(output_name, "w", zipfile.ZIP_DEFLATED)
    #压缩文件为输出的名称,写入,zip_DEFLATED对文件进行压缩
  for root, dirs, files in os.walk(dirpath):
      #查看对应路径下的文件
    for file in files:
      if str(file).startswith("~$"):
          #将获取到的文件名转换为str,startswith判断开头是否为~$的临时文件
        continue
          #如果是则丢弃
      filepath = os.path.join(root, file)
      #文件路径为目录+文件名--绝对路径
      writepath = os.path.relpath(filepath, parent_name)
      #写入路径为filepath和parent_name间的相对路径,因为上方parent已经变成了arrange的上级目录,所以会变成基础练习目录
      zip.write(filepath, writepath)
            #压缩写入为文件和对应路径
  zip.close()
    #关闭压缩

dirpath = r"E:\py-资料\py学习\基础练习100题\arrange_dir"
do_zip_compress(dirpath)
#最后的路径为基础练习100题

2.1 爬虫Requests

096 Requests模块报错

"""
解释：
requests是一个开源库，自己是有get方法的
报错是因为，python本身导入类库时，会先从本地文件导入，它发现了本地文件有一个requests.py就导入了，但是这是我们自己的文件，里面确实没有get方法
如果改完了文件名，报错说requests不存在，则需要自己安装一下代码包
"""

091 来自URL的文件

"""
用Python访问URL：http://antpython.net/static/py100/life_is_great.txt
然后打印文件中的如下内容：
"""
import requests
url = "http://antpython.net/static/py100/life_is_great.txt"
r = requests.get(url)
#get得到对应url中的内容
print(r.text)
#通过text文本输出内容
#解释：
requests是python的开源模块，可以请求URL的结果
requests.get可以访问一个URL
requests.get的结果，有一个属性是text，放置了这个URL的结果内容

092 下载URL的图片

"""
这个URL是一个图片，用python下载图片，存入到本地p092.jpeg：
http://antpython.net/static/pubdatas/webspider/goodimgs/9.jpeg
"""
url = "http://antpython.net/static/pubdatas/webspider/goodimgs/9.jpeg"
import requests
r = requests.get(url)
#获取对应url的内容
with open("p029.jpg","wb") as f:
    f.write(r.content)
    #如果要下载文件，需要用open的wb模式写入文件，写入的时候，用resp.content二进制形式，不能用resp.text

099 给网页提交数据

"""
这是一个网页，里面有一个表单可以提交数据
http://antpython.net/webspider/grade_form
使用python提交一条数据，并且在网页上看到效果：
姓名：蚂蚁099，语文22，数学99，英语66
提示：
可以用chrome浏览器的f12打开network，查看后台请求
表单提交的Url是：http://antpython.net/webspider/grade_form
提交方法是post，数据格式为 sname: xx，yuwen: 66，shxue: 11，yingyu: 22
用requests.post提交即可
"""
url = "http://antpython.net/webspider/grade_form"
import requests
datas = {"name":"蚂蚁099","语文":22,"数学":99,"英语":66}
resp = requests.post(url,data=datas)
#post为上报请求,即交互式,data会上报数据
print(resp.status_code)
#打印post的请求的对应状态码

100 打开百度搜索

"""
编写代码，让用户输入一个词语，代码自动打开浏览器，在百度搜索关键词，展示结果
例如用户输入python，自动打开这个界面
"""
"""
提示：
百度搜索的URL：https://www.baidu.com/s?wd=python 这个wd=python，可以替换关键词
python有个模块webbrowser，用它的webbrowser.open(url)可以直接浏览器打开一个URL
"""
import  webbrowser
querry = input("输入你的问题:")
webbrowser.open(f"https://www.baidu.com/s?wd={querry}")
#webborwser.open打开后方的url,wd替换问题

3.print输出带颜色

1.顺序：显示方式，前景颜色，背景颜色
2.顺序非固定，但尽量按默认书写方式
3.也可以在input中输出使用
4.格式： print('\033[显示方式；前景颜色；背景颜色m ..........\033[0m')


--code
#!/bin/env python
"""
一般不针对显示方式进行调色！
"""
print("\033[4;31;40mhello python!\033[0m")          ##一般不采用,直接前景色即字体颜色即可
print("\033[33mhello python!\033[0m")
print("\033[31mhello python!\033[0m")

3.1 显示方式

意义	显示方式
默认	0
高亮显示	1
下划线	4
闪烁	5
反白显示	1
不可见	2

3.2 颜色

颜色	前景色	背景色
黑色	30	40
红色	31	41
绿色	32	42
黄色	33	43
蓝色	34	44
紫红色	35	45
青蓝色	36	46
白色	31	4

4.模块和包

4.1归属分类

模块还可以分为

#内置模块 ，就是 python 解释器中自带的. 如： osreitertools
#第三方模块， 这些模块需要自己安装，就像是在 Linux 系统中安装软件一样。
#自定义模块， 这个就是自己编写的模块。

4.2自定义模块

有的情况下，是需要自己编写一些模块的，这种就是自定义模块了。
some_mod.py     --模块文件
x = 10

li = ['shark', 12]

def foo():
    return 30

class Person():
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
#此时便自定义了一个py模块文件

4.3调用自定义模块

##方法一:
import some_mod                #同级目录下可直接import,不同目录下需要from目录+import包名。import直接获取软件包默认会获取所有对象
print(some_mod.foo())
hh = some_mod.Person("薛晓强",20)
print(f"\033[34m我的名字是:{hh.name},年龄是{hh.age}!\033[0m")

##方法二:
from some_mod import foo,x,Person          #精确获取某个对象                
print(foo())
hh = Person("薛晓强",21)
print(f"\033[34m我的名字是:{hh.name},年龄是{hh.age}!\033[0m")
print(x)
##导入模块时模块的代码会自动被执行一次，在一个程序中多次导入同一个模块，此模块的代码仅会运行一次。

一.python基础练习(100)

1.1 基础(格式或语法)

"""只记录复杂化的题目和思路"""

003.比较和赋值

--执行如下代码会报错，你知道什么错误吗？
a = 1
b = 2
print(a == b)
#返回的是true和false
print(b == c)
#因为c变量没有被定义,所以无法判断b==c,会抛错false

004.类型错误

"""
修复如下代码，让它的输出是数字1+2结果为3
不要修改前两行，只修改第3行
"""
--源code
a = "1"
#a此处定义的是字符串,无法进行整形的计算
b = 2
print(a + b)

---修复后
a = "1"
b = 2
print(int(a) + b)

005.缩进错误

"""
如下代码想要判断字符串中的字母是不是等于e，等于的话输出这个字母
但是报错了，你知道为什么吗，怎么修复？
"""
for letter in "Hello":
    if letter == "e":
    print(letter)
    #可以看到当前这个打印不在if的缩进块内,if无效可以有俩种修改方式

--修复代码(1)
for letter in "Hello":
    if letter == "e":
        continue
        #continue在if块内,当letter等于e的时候,丢弃e
    print(letter)
    #此处的print在for循环体制内,说明不满足if条件内容哦都会被打印
--修复代码(2)
for letter in "Hello":
    if letter == "e":
       print(letter)
    #将print进行缩进调整,放入if块中

006.不正确的结束

"""
如下代码会报错，你知道为什么吗？怎么修复？
"""
print(type("Hey".replace("ey","i")[-1])
#可以看到少了print对应的()中的结尾括号
##replace函数,字符替换,将HEY中的ey替换为i.输出Hi.[-1]为字符串索引,输出i

1.2 索引和切片

013 复数切片

"""
完成如下代码，获得一个切片，得到最后的3个元素[h, i, j]
"""
letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
print(letters[-3:])
#即-3开始到最后,包含最后字符
#对于这个场景，只能写[-3:]，冒号后面的数字不用写也没法写，这样就包含了列表后面的所有元素

014 步长切片

"""
完成如下代码，获得一个切片，包含元素['a', 'c', 'e', 'g', 'i']
"""
#!/bin/evn python
letters = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
print(letters[0::2])
#从头开始值末尾,每2个字符切一个

1.3 列表list

015 range函数

"""
编写代码，生成如下数字List，注意要用函数生成
"""
#!/bin/evn python
my_range = range(1,21)
#定义变量为1,20的内容
print (list(my_range))
#将1,20打印为list

016 range推导式

#!/bin/evn python
my_range = range(1,21)
hh = [x*10 for x in my_range]
print (hh)

012 去重set、list

"""
set集合是不允许集合内出现重复字符的,当获取到常规数值后可以通过set进行去从
"""
--方法1
a = ["1", 1, "1", 2]
b = []
#定义空列表
for i in a:
    if i not in b:
        b.append(i)
print(b)

--方法2
a = ["1", 1, "1", 2]
b = set()
#定义空集合
for i in a:
    if i not in b:
        #如果a的值不在b中
        b.add(i)
        #给b进行添加新值
print(b)

--方法3
a = ["1", 1, "1", 2]
a = set(a)
#格式化a的列表内容为集合
print(a)

019 列表排序

"""
完成代码，对列表排序，得到排序后的结果
"""
lista = [20, 40, 30, 50, 10]
new_list = sorted(lista,reverse=True)
print(f"lista is {new_list}")

lista.sort(reverse=True)
print(f"lista is {new_list}")

020 列表去从

#!/bin/env python
l = [['百度', 'BD'], ['京东', 'JD'], ['淘宝', 'TB'], ['百度', 'BD']]
L = []
while(l):
    #根据l的元素个数进行循环
    pop_l = l.pop()
    #pop为在列表l取值,取出后l列表中的pop内容不存在.
    #倒叙取值
    if pop_l in l:
        #如果列表中的内容取出后,还在源l列表中
        continue
        #那么就丢此此数据
    else:
        L.insert(0, pop_l)
        #pop取出的只有一次的元素则在下标0中插入pop的数据
print(L)
#因为pop是倒叙取list中的值,所以列表顺序不变

1.4 字典

022 字典元素加和

"""
完成如下代码，计算key为a和b的值的加和
"""
d = {"a": 1, "b": 2, "c": 3}
print(d["a"] + d["b"])

025 对字典使用函数

"""
计算如下字典的所有value的数字的和
"""
d = {"a": 1, "b": 2, "c": 3}
print(sum(d.values()))

026 字典过滤

"""
移除如下字典中所有value大于1的key:value对
"""
d = {"a": 1, "b": 2, "c": 3}

new_d = {x:y for x,y in d.items() if y <= 1}
#字典推导式,items获取字典内容,如果value小于1,才会被征用写入新的字典
print(new_d)

021 格式化输出

"""
创建一个字典
key是a、b、c，value分别是列表1~10、列表11~20、列表21~30
格式化输出字典
"""
d = {
    "a":list(range(1,11)),
    "b":list(range(11,21)),
    "c":list(range(21,31)),
}
print(d)

029 遍历字典

"""
遍历如下字典
"""
d = {"a": list(range(1, 11)),
     "b": list(range(11, 21)),
     "c": list(range(21,31))
     }
a = d["a"]
b = d["b"]
c = d["c"]
print(f"a has value{a}")
print(f"b has value{b}")
print(f"c has value{c}")

1.5 循环LOOP

030 打印字母a到z

"""
打印字母a到z，每行一个字母
"""
import  string
a = string.ascii_letters
#a为str模块的a-Z
for i in a:
    #for循环遍历字符串获取内容
    print(i)

032 计算1到100数字的和

"""
编写代码，计算从1到100的和，包含1和100
即：1+2+3+4+.....+99+100

效果如下
"""
sum1 = 0
#定义初始数字用来存储每次的加和
for i in range(1,101):
    sum1 += i
    #每次循环sum的值增加i
print(sum1)

033 计算1到100偶数数字和

"""
编写代码，计算从1到100中偶数的数字和
即：2+4+6+2+.....+92+100

效果如下
"""
sum_value = 0
for i in range(1,101):
    if  i % 2 == 0:
        #如果
        sum_value += i
print(sum_value)

034 输出元素和下标

"""
完成如下脚本代码：
"""
a = [1, 2, 3]
for index,item in enumerate(a):
    print(f"Item {item} has index {index}")
解释：
enumerate(a)函数产出数组的（下标index，数值item）数据对
用for index, item in enumerate(a)可以依次取出index和item
在字符串前面加个f符号，里面可以用{item}、{index}的方式访问变量，这叫f-string语法

035 同时遍历多个序列

"""
编写代码，输入如下两个数据：
"""
a = [1, 2, 3]
b = (4, 5, 6)
for i,j in zip(a,b):
    print(f"{i+j} = {i}+{j}")
#解释：
不同的序列（列表、元组都叫序列），可以用zip打包在一起
zip的返回是一各个的元组，里面包含各个序列的对应元素

1.6 函数function

036 编写加速度函数

"""
创建函数，计算加速度，初始和结束的速度为v1和v2，初始和结束的时间为t1和t2
然后，用参数(v1, v2, t1, t2)分别为(0, 10, 0, 20)调用函数，得到结果为：
"""
def speed(v1,v2,t1,t2):
    #定义函数需要传入4个属性
    a = ( v2 - v1 ) / ( t2 - t1 )
    #定义a方法为平均速度
    return a
    #执行函数返回内容,否则默认返回none

print(speed(0,10,0,20))
#调用函数并传入属性

032 方法不存在

import math
print(dir(math))
print(help(math.cos))
print(math.cos(1))
"""
解释：
print(dir(math))可以查看这个模块的所有方法名
print(help(math.cos))可以看到这个方法的注释，看到是计算cosine的
如果在pycharm中，可以按住键盘的ctrl键同时鼠标左键点击math.cos方法名，可以看到这个方法的源代码的注释
"""

039 函数参数数目错误

"""
如下代码报错，你知道为什么吗，怎么修正它？
"""
import math
print(math.pow(2))
### pow() takes exactly 2 arguments (1 given)##
##Pow()接受2个参数(给定1个)

--修正后
"""
如下代码报错，你知道为什么吗，怎么修正它？
"""
import math
print(math.pow(2,2))
#此方法是计算a值的b次方,可以通过查看math函数内置方法翻译的知用法

040 函数调用方式

"""
如下代码会报错，你知道为什么吗，怎么修复？
"""
def foo(a=1, b=2):
    return a + b
#函数体无错误

x = foo - 1
#可以看到调用函数时为加()

--修正后
def foo(a=1, b=2):
    return a + b
x = foo() - 1
print(x)

041 函数计算球的体积

"""
编写函数，计算球的体积
要求函数的参数半径r，有一个默认值10
然后用r=2为参数，调用函数得到结果
"""
--方法1
import  math
def volume(r=10):
    #定义带有默认属性的函数
    return (4 * math.pi * math.pow(r,3)) / 3
    #返回内容为V＝4πR³ /3(圆的体积)
    #math.pow为内置函数计算变量属性r的三次方
hh = volume(2)
print(hh)

--方法2
import math

def volume(r=10):
    return (4 * math.pi * r ** 3) / 3
print(volume(2))
#不用pow内置方法

043 全局变量

"""
如下代码会输出什么内容？为什么呢？
"""
c = 1
def foo():
    #此处函数只是被定义
    return c
    #只有函数被调用时,才会输出以及获取值
c = 3
#此时定义新的c的值
print(foo())
#此处调用函数,则会将最新的c的内容进行输出

044 函数局部变量

"""
如下代码会输出什么内容？为什么呢？
"""
c = 1
def foo():
    c = 2
    #局部已经定义变量内容
    return c
    #优先级最高的为局部变量,所以返回c=2
c = 3
print(foo())

"""
解释：
python的函数，从上往下一行一行执行
函数内可以访问函数外的全局变量，但是局部变量的优先级更高
"""

045 局部变量和全局变量

"""
如下代码的最后一行，会报错说NameError: name 'c' is not defined
怎样修复代码，让代码不报错，并且输出数值1？
"""
def foo():
    c = 1
    return c
foo()
print(c)
##报错:name 'c' is not defined           --变量c没有被定义

--修订后
def foo():
    global c
    #global 全局，将c引入全局变量.方可调用
    c = 1
    return c
foo()  #执行函数内容
print(c)

1.1 字符串String

"""
如下代码让用户输入name和age，然后拼接字符串
但是代码会报错 TypeError
你知道为什么吗？怎么修复？有另一种办法吗？
"""
name = input("Enter name: ")
age = input("Enter age: ")
print("Your name is %s and your age is %s" % name, age)


--修改后
"""
如下代码让用户输入name和age，然后拼接字符串
但是代码会报错 TypeError
你知道为什么吗？怎么修复？有另一种办法吗？
"""
name = input("Enter name: ")
age = input("Enter age: ")
print("Your name is %s and your age is %s" % (name,age))
print(f"Your name is {name} and your age is {age}" )
#解释：
#每个%占位符，在后面的%需要一个变量对应起来，如果多于一个%占位符，后面的%之后需要跟一个元组tuple包含多个变量，所以需要用(name, age)这个元组
#f-string是第二种好用的格式化方式，形如f"Your name is {name}"，在字符串中可以用{变量名}的方式格式化

042 字符串拆分

"""
创建一个函数，以任何一个英文字符串作为入参，返回英文单词的数目
"""
--方法1
l1 = []
#定义空的列表用来接收单词
def count_words(string):
    for i in string:
        #for循环遍历传入的单词
        l1.append(i)
        #每一个都塞入列表中
count_words("dsadasdasd")
print(len(l1))
#打印列表的元素长度

--方法2
def countt_words(string):
    string_list = string.split()
    #定义strlit为传入字符串的split(默认空格分隔)
    return len(string_list)
#返回string——list的长度
print(countt_words("i am good boy!!"))
#返回4个,因为用空格进行了分隔.

049 文件中的英文单词计数

"""
编写函数，传入.txt文件路径作为参数，统计文件中英文单词的数目
提示：
函数的参数是文件路径
读取文件内容，用str.split拆分，用len统计单词个数
返回单词个数
"""
def file(url):
    #定义函数和属性
    with open(f"{url}",encoding="utf-2") as v:
        #打开文件并起别名v
        str = v.read()
        #str来收集文件内容
        str_list = str.split()
        #str_list为空格分隔的内容
        return len(str_list)
    #返回split后的长度
print(file("p049.txt"))
#打印文件为p049.txt的长度

050 多分隔符单词计数

"""
编写函数，传入.txt文件路径作为参数，统计文件中英文单词的数目
注意，不只是空格分割，也可能是逗号分隔
提示：
函数的参数是文件路径，返回的是单词个数
用re.split(",| ", text)可以用多个分隔符拆分字符串

"""
import re
#re是python内置的正则表达式模块，可以实现模式匹配
def file(url):
    with open(f"{url}",encoding="utf-2") as v:
        str = v.read()
        str_list = re.split(r",| ",str)
        #,或者空格进行分隔
        return len(str_list)
print(file("p050.txt"))

#解释
#re是python内置的正则表达式模块，可以实现模式匹配
#模式的意思，例如一个字符串“包含10个数字”、“逗号或者空格作为分隔符”等模式
#re.split的第一个参数，一般都前一个r意思是raw-string，里面如果有反斜线不用多次转义

1.2 循环与文件

051 生成字母文件

#!/bin/evn python
"""
051 生成字母文件
编写代码，生成一个文件p051.txt，每一行是一个英文字母，从a~z
"""
import string
file = "p051.txt"
with open(f"{file}","w",encoding="utf-2") as v:
    str = string.ascii_lowercase
    for i in str:
        v.write(i+"\n")

##第二种
file = "p051.txt"
with open(f"{file}","w",encoding="utf-2") as v:
    for letter in string.ascii_lowercase:
        v.write(letter+"\n")

052 成对字母文件

"""
编写代码，生成文件p052.txt，每一行是两个英文字母的组合：
"""
#!/bin/evn python
"""
052 成对字母文件
编写代码，生成文件p052.txt，每一行是两个英文字母的组合：
"""
import string
file = "p052.txt"
with open(f"{file}","w",encoding="utf-2") as f:
    for i,j in zip(string.ascii_lowercase[::2],string.ascii_lowercase[1::2]):
        #多个数据类型的内容,可以通过zip进行打包访问,::2.以每2个步长的内容获取数据,[1::2]从下标为1开始,每2步获取内容
        f.write(i + j +"\n")

053 成对三字母文件

#!/bin/evn python
"""
053 成对三字母文件
编写代码，生成文件p053.txt，每一行是三个英文字母的组合：
提示：
zip函数可以将多个序列同时打包在一起，不只是2个，可以是3个
注意，26个英文字母，不是21个，不能被3除尽，最后一对只能是yz，需要做下处理
"""
import string
file = "p053.txt"
letters = string.ascii_lowercase + " "
#定义a-z的内容为:a-z" "即生成21个字符,否则不会输出yz
slice1 = letters[0::3]
#定义切片内容1为:每三步切割的内容即a开始
slice2 = letters[1::3]
#从b开始的每三步的内容
slice3 = letters[2::3]
#从c开始的没三步的内容
with open(f"{file}","w",encoding="utf-2") as v:
    for s1,s2,s3 in zip(slice1,slice2,slice3):
        #for循环进行值的遍历获取.zip元素将多个打包在一起
        v.write(s1 + s2 + s3 + "\n")
        #将遍历的内容写入文件

054 每个字母一个文件

#!/bin/evn python
"""
编写代码
1、在当前目录下新建一个目录，名字为 p054
2、给26个英文字母在p054目录下生成一个文件，文件名分别是a.txt、b.txt ~~ z.txt，文件内容分别是字母a、b~~z
"""
import os,sys,string
path = "/root/python3/code_test/p054"
#定义生成的目录的绝对路径,也可相对路径.
if os.path.exists(path):
 #如果目录存在就不会创建
    print("目录已存在,不允许创建.")
else:
    os.makedirs(path)
    #os模块内置函数创建目录
    print(f"目录{path}已创建")
for letter in string.ascii_lowercase:
    #letter进行a-z的赋值
    #string有三个ascii的用法lowercase为a-z,uppercase为A-Z,letters为a-z,A-Z
    with open(f"{path}/{letter}.txt","w",encoding="utf-2") as v:
        #通过for循环打开一个txt写入letter的值
        v.write(letter + "\n")
        #不存在的文件txt会被创建出来
        print(f"文件{letter}.txt已被创建并输入！！")

055 扫描字母文件列表

#!/bin/evn python
"""
编写代码，
1、扫描p054文件夹，里面是a.txt/b.txt~z.txt共26个文件，每个文件的都是对应字母a~z
2、读取每个文件的内容，最终产出一个list，是字母a~z
"""

--第一种方法！！
import os,sys,string
path = "/root/python3/code_test/p054"
if os.path.exists(path):
    #os模块判断path是否存在,返回true和false
    print("目录存在开始扫描！.")
    list=[]
    letter = string.ascii_lowercase
    for i in letter:
          with open(f"{path}/{i}.txt",encoding="utf-2") as v:
                list.append(v.read().strip())
    print(list)
else:
    print("文件或目录不存在！！！")
    exit
    
--第二种方法！！
import glob
path = glob.glob("/root/python3/code_test/p054/*.txt")
#定义path为p054下的所有txt文件.*通配符
#此场景适合找所有的txt文件,任意开头结尾为txt即会被遍历
list=[]
for file in path:
    #file为所有*.txt文件
    with open(file) as v:
      list.append(v.read().strip())
    #strip:清空字符前后空格,默认
print(list)
"""
解释：
glob.glob("p054/*.txt") 可以匹配得到文件列表
f.read()可以读取文件所有内容，.strip()可以去除两边的空格c
"""

--方法3！！
import glob
path = glob.glob("p054\*.txt")
list = []
for file in  path:
    with open(f"{file}") as v:
        for i in v:
            i = i[0]
            #如果文件存在多行或者,换行符等,用for循环进行格式化
            list.append(i)
# print(list)
list = set(list)
#读取的列表用set进行去重
print(list)
#因为列表是无序的所以内容可能顺序不一致

056 满足条件的字母文件

#!/bin/evn python
"""
056 满足条件的字母文件
编写代码，
1、扫描p054文件夹，里面是a.txt/b.txt~z.txt共26个文件，每个文件的都是对应字母a~z
2、如果文件里的内容字母，属于字符串"python"中的字母，则存入结果列表
3、打印结果列表
"""
import glob,os
file_list = glob.glob("/root/python3/code_test/p054/*.txt")
template = "python"
list = []
for file in file_list:
    if os.path.exists(file):
        with open(f"{file}",encoding="utf-2") as v:
            str = v.read().strip()
        if str in template:
            list.append(str)
print(list)

0566 字典嵌套

students = [
    {'学号': 1, '姓名': '乐乐', '年龄': 12, '性别': '男', '成绩': 11},
    {'学号': 2, '姓名': '倩倩', '年龄': 11, '性别': '女', '成绩': 23},
    {'学号': 3, '姓名': '苗苗', '年龄': 13, '性别': '女', '成绩': 92},
    {'学号': 4, '姓名': '旭旭', '年龄': 12, '性别': '男', '成绩': 65},
    {'学号': 5, '姓名': '花花', '年龄': 11, '性别': '男', '成绩': 66},
]
# 统计每个年龄的人数
age = {}
#定义空字典用来收集value
#字典的key是不能重复的,如果出现重复的后边的会替换到前边的”
for i in students:
    #i进行字典内容的赋值
    if  i["年龄"] not in age:
        #如果年龄(12)不在age空字典中
        #此时i获得的内容为12，11，13，12，11
        age[i["年龄"]] = 1
        #那么定义年龄数字key对应的value为1
        #12 = 1
    else:
        age[i["年龄"]] += 1
        #否者年龄的value在基础上加1
        #12 = 1+1
for i,x in age.items():
    print(f"年龄：{i},在大的字典中出现了：{x}次！")

# 统计每个性别的人数
sex = {}
for i in students:
    if  i["性别"] not  in sex:
        sex[i["性别"]] = 1
    else:
        sex[i["性别"]] += 1
print(sex)

# 获取性别为女的学生信息
for i in students:
    if  i["性别"] == "女":
        print(i)
print(" ")

# 获取成绩优异的学生信息
for i in students:
    if  i["成绩"] >= 20:
        print(i)
print(" ")

# 获取年龄是偶数的学生信息
for i in  students:
    if  i["年龄"] % 2 == 0:
        print(i)
print(" ")
# 获取成绩为偶数的学生信息
for i in students:
    if  i["成绩"] % 2 == 0:
        print(i)

1.9 多级字典与JSON

051 多级字典

"""
如下是一个多级字典，也就是说每个字典的KEY的VALUE，也是个数据结构
怎么访问employees的第二个人，得到他的lastName，即 Smith
"""
d = {"employees": [{"firstName": "John", "lastName": "Doe"},
                   {"firstName": "Anna", "lastName": "Smith"},
                   {"firstName": "Peter", "lastName": "Jones"}],
     "owners": [{"firstName": "Jack", "lastName": "Petter"},
                {"firstName": "Jessy", "lastName": "Petter"}]}
#访问第一个key对应的value
print(d["employees"])

#访问value list中的下标为1即中间的字典
print(d["employees"][1])

#访问字典中的key--lastName获取对应value--smith
print(d["employees"][1]["lastName"])

052 修改多级字典

"""
如下是一个多级字典，也就是说每个字典的KEY的VALUE，也是个数据结构
怎么访问 employees 的第二个人，修改他的 lastName
将值从 Smith 改成 Smooth
"""
d = {"employees": [{"firstName": "John", "lastName": "Doe"},
                   {"firstName": "Anna", "lastName": "Smith"},
                   {"firstName": "Peter", "lastName": "Jones"}],
     "owners": [{"firstName": "Jack", "lastName": "Petter"},
                {"firstName": "Jessy", "lastName": "Petter"}]}
d["employees"][1]["lastName"] = "Smooth"
#访问d['employees'][1]['lastName']，是Smith值的位置
#直接加=号，就是给他赋新的值。和普通字典用法一致
print(d["employees"])
#打印字典d中的key为employess的值

059 多级字典加值

"""
如下是一个多级字典，也就是说每个字典的KEY的VALUE，也是个数据结构
怎么给 employees 添加一个人：'firstName': 'Albert', 'lastName': 'Bert'
"""
d = {"employees": [{"firstName": "John", "lastName": "Doe"},
                   {"firstName": "Anna", "lastName": "Smith"},
                   {"firstName": "Peter", "lastName": "Jones"}],
     "owners": [{"firstName": "Jack", "lastName": "Petter"},
                {"firstName": "Jessy", "lastName": "Petter"}]}
d["employees"].append({"firstName":"Albert","lastName":"Bert"})
#因为字典d中的key--employees的value为list,所以直接在employeesvalue下append即可
print(d["employees"])
#打印字典d中的key为employess的值可以看到多出了append追加的值

060 字典变JSON

"""
把如下字典，变成JSON格式，存入一个文件 hh.json
"""

d = {"employees": [{"firstName": "John", "lastName": "Doe"},
                   {"firstName": "Anna", "lastName": "Smith"},
                   {"firstName": "Peter", "lastName": "Jones"}],
     "owners": [{"firstName": "Jack", "lastName": "Petter"},
                {"firstName": "Jessy", "lastName": "Petter"}]}

import json
new_date = json.dumps(d,indent=2)
#dumps将d字典转换为str常规字符串
#indent加了之后会让JSON样式更加缩进美观
print(f"转换后的内容为:{new_date}\n类型为:{type(new_date)}")
with open("hh.json","w",encoding="utf-2") as v:
    v.write(new_date)
    print("文件已经被创建并输入内容！！！")

with open("hh.json",encoding="utf-2") as f:
    hh = f.read()
    hh = json.loads(hh)
    #将json文件中的str读取为python中的数据类型内容
print(f"文件内容为:{hh} \n类型为:{type(hh)}")
print(hh["employees"][1])
#打印读取文件后的hh字典中employees的value列表内容中的下标为1的内容




import json,pprint
with open("hh.json",encoding="utf-2") as v:
    d = json.loads(v.read())
pprint.pprint(d)
#pprint可以实现字典的格式化输出

062 JSON添加数据

"""
完成如下步骤：
用python加载p060.json文件，转成字典
给 employees 添加一个人：
'firstName': 'Albert', 'lastName': 'Bert'
将数据生成json，结果存到 p062.json文件
"""
import json
import os
import time

file = "hh.json"
# 定义json文件路径
if os.path.exists(file):
    # 如果文件存在则执行！！
    print("文件存在,准备读取加入新的值!")
    with open(f"{file}", encoding="utf-2") as v:
        # 打开文件别名为v
        dict1 = json.loads(v.read())
        # 定义变量为json取文件后的数据类型内容
        dict1["employees"].append({"firstName": "Albert", "lastName": "Bert"})
        # 在dict1字典的key--employees中的list值中追加一个新的记录
    data = json.dumps(dict1, indent=2)
    # data变量为将追加进去的dict1的内容进行str转换
    with open(f"{file}", "w", encoding="utf-2") as f:
        f.write(data)
        # 将新的dict已str的方式存入json文件
else:
    print("文件不存在,已退出！！")
    # 如果文件不存在则报错
    exit(11)
    # 赋值退出状态码为11
time.sleep(1)
print("准备读取文件！")
import pprint

with open(f"{file}", encoding="utf-2") as json_data:
    pprint.pprint(json.loads(json_data.read()))
    # 格式化读取文件已数据类型方式展示.pprint输出美观的dict
####选中代码ctrl +alt +l 格式化代码更美观

2.0 循环条件控制

065 渐进式定时打印

"""
实现python代码，输出hello，停顿1秒；输出hello，停顿2秒；输出hello，停顿3秒；
按此一直持续：
"""
import time
sum = 1
#初始化秒数为1,sum为计数器
while True:
    #死循环
    print(f"当前停顿秒数{sum}")
    #打印当前要停顿的秒数
    time.sleep(sum)
    #停顿对应秒数
    print("hello")
    sum += 1
    #结束一次+1秒,下一个hello就会延时1s出现

061 空语句

while True:
    print("Hello")
    if 2 > 1:
        pass
    #pass 是 Python 中的关键字，用来让解释器跳过此处，什么都不做
    #即跳过此处输出fi,继续循环
    print("Hi")
   

---方法2
while True:
    print("Hello")
    if  1 == 1:
        print("Hi")
        #for循环匹配一次后输出Hi,就会回到while循环继续输出
        
        
解释：
pass可以跳过当前语句，但是继续往下执行，也会进入下一次循环
break会忽略当次循环下方语句，直接退出当前循环
continue会忽略当次循环下方语句，依然进入下一个循环

2.1英汉翻译字典

069 英汉翻译

"""
完成如下程序，让用户可以输入一个英文单词，程序给出中文翻译结果
"""
d = {"apple": "苹果", "orange": "桔子", "banana": "香蕉"}


def hh(world):
    #定义函数和函数属性
    return d[world]
#返回字典d[属性的value]
world = input("Enter World:")
#world为交互式输入的因为单子
print(hh(world))
#返回英文对应的中文

010 英汉翻译异常处理

"""
如下程序实现功能，让用户可以输入一个英文单词，程序给出中文翻译结果
修改程序，如果输入的英文单词不在字典中，输出信息“单词不在词典中”
"""
d = {"apple": "苹果", "orange": "桔子", "banana": "香蕉"}

def translate(word):
    return d[word]
while True:
    word = input("Enter World:")
    if  word not in d.keys():
        #如果输入的单词不在字典的key中
        print("word not such！！！")
        #那么就打印没有匹配的内容
    else:
        print(translate(word))
        #如果匹配成功那么返回函数体
        
        
--方法2
d = {"apple": "苹果", "orange": "桔子", "banana": "香蕉"}


def translate(word):
    try:
        # 代码交给try管理
        return d[word]
    except KeyError:
        # 错误类型为key错误
        return f"no such key: {word}"
    # 返回错误信息


world = input("Enter World:")
print(translate(world))
# 不报错才会执行此条件

011 英汉翻译文件词典

"""
如下是英汉翻译词典文件，用python加载词典文件
当用户输入英语单词时，返回中文文字
增加：程序应该处理大小写情况，例如输入Apple也能返回apple的翻译
"""
dict = {}
import os
file = "p011.txt"
if  os.path.exists(f"{file}"):
    print("文件存在！")
    with open(f"{file}",encoding="utf-2") as v:
        for lien in v:
            en,cn = lien.strip().split(",")
            dict[en]=cn
def translate(world):
    try:
        return dict[world]
    except KeyError:
        return "no such wordl!!"
print(translate(input("请输入要查询的单词：").lower()))
#lower将输入内容转小写



--方法2
#!/bin/env python
dict = {}
#定义空字典,用来接收文件中的内容
with open("英汉词典.txt",encoding='utf-2') as fin:
	for i in fin:
		i = i[:-1]
		#通过列表推导式去除换行符,读取文件默认生成的都为列表
		fieds = i.strip().split(",")
		#格式化内容为fieds
		if len(fieds) == 2:
			#fieds按照,号进行分割,那么读取每行文件,那么就会是俩个参数
			en,cn = fieds
			dict[en] = cn
		else:
			continue
	print(f"字典已生成:{dict}")
	#for循环读取文成后,循环次数为文件行数.打印生成的字典
while True:
	key = input("输入你要查询的单词对应的英文:").lower()
	if key == "exit" or key == "quit" or key == "no":
		break
	elif key not in dict.keys():
		#如果要查询的key不在字典的key中则无法拆线呢
		print(f"没有找对{key}这个key!")
	else:
		print(f"你查询的{key}的中文为:{dict[key]}")

2.2 日期时间

012 当前日期时间

from  datetime import datetime
print(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))


#!/bin/env python
import datetime
print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
"""
datetime是内置的日期时间处理模块
datetime.now()返回当前的时间对象
datetime.now().strftime可以将时间对象格式化
"""

013 输入年龄计算出生年月

"""
编写Python代码，用户可以输入年龄数字，程序打印生日年份
"""
from datetime import datetime
age = input("请输入你的年龄：")
age = int(age)
#age必须为int类型
year_age = datetime.now().year - age
#year_age为当前年份减去输入的年龄为出生的年份
print("你的出生年份是：",year_age)

014 计算活了多少天

"""
编写Python代码，用户可以输入生日，程序打印活了多少天
"""
import  datetime
birthday = input("输入你的出生日期,用-分隔:")
#交互输入出生的日期
birthday_date = datetime.datetime.strptime(birthday, "%Y-%m-%d")
#将输入的内容进行格式化可以将字符串转换成日期对象
curr_time = datetime.datetime.now()
#定义当前的时间
live_day = curr_time - birthday_date
#当前时间减去生日
print(f"你已经在地球上出现了{live_day.days}天！！！")
#.days只要天不要秒

015 计算今天明天昨天的日期

"""
编写代码，输出今天、昨天、明天、一周前的日期
可以编写个函数实现
如果今天是2022-05-14，输出形如：
"""
"""
提示：
datetime.datetime.now()得到当前日期对象
datetime.timedelta(days=days)可以得到一个时间间隔对象
日期对象和间隔对象的加法和减法，得到结果对象
"""
import datetime

def diff_days(days):
    pdate_obj = datetime.datetime.now()
    #定义现在
    time_gap = datetime.timedelta(days=days)
    #定义时间间隔对象days=为固定内置函数
    pdate_result = pdate_obj - time_gap
    #返回结果为今天减去传入的天数days
    return pdate_result.strftime("%Y-%m-%d")
#返回内容为年月日

print(f"今天为:{diff_days(0)}")
#0为和当前间隔时间为0即为当天
print(f"昨天为:{diff_days(1)}")
#1为今天时间基础-1
print(f"明天为:{diff_days(-1)}")
#-1为今天时间基础+1
print(f"一周前的日期为:{diff_days(1)}")
#今天时间减1

016 输出间隔内的所有日期

#!/bin/env python
import datetime

def get_date_range(begin_date, end_date):
    date_list = []
    #定义空的集合,用来存时间
    while begin_date <= end_date:
        #如果开始时间小于结束时间进入循环
        begin_date_object = datetime.datetime.strptime(begin_date, "%Y-%m-%d")
        #strptime是将一个（时间）字符串解析为时间的一个类型对象。
        #将输入的开始时间进行格式化,格式化为是后方定义形式
        days1_timedelta = datetime.timedelta(days=1)
        #定义时间间隔对象为1天.
        begin_date = (begin_date_object + days1_timedelta).strftime("%Y-%m-%d")
        #strftime是转换为特定格式输出.只要年月日不要时分秒
        #开始时间加一天
        date_list.append(begin_date)
        #将每次获取的开始时间追加到列表中
    return date_list
    #返回列表内容

begin_date = "2023-01-01"
end_date = datetime.datetime.now().strftime("%Y-%m-%d")
#最后时间为年月日不精确至秒数
date_list = get_date_range(begin_date, end_date)
print(date_list)
#返回的为定义的开始时间到今天


>>>>>>>>>>>>>>>>>Python中的时间函数strftime与strptime对比<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
#!/bin/env python 
import datetime
begin_date_object = datetime.datetime.strptime("2022/02/11", "%Y/%m/%d")
#strptime：将字符串解析为给定格式的日期时间对象。字符串=>日期时间对象，解析字符串.解析结果为默认的date数据类型格式
print(begin_date_object)
###输出结果为:2022-02-11 00:00:00

#strftime函数：将给定格式的日期时间对象转换为字符串。日期时间对象=>字符串，控制日期时间对象的输出格式
#!/bin/env python
import datetime
dt=datetime.datetime(2023, 2, 20, 16, 30)
print(dt.strftime("%Y-%m-%d %H:%M"))
2023-02-20 16:30
#此函数会将给定的字符内容或者约定的格式进行格式化.
print (dt.strftime("%Y-%m-%d"))
2023-02-20

#strftime控制格式化输出，strpttime将字符转换为时间对象,需要声明输入格式

#strft处理已经是数据格式的对象内容,转换为定义的时间格式内容
#stpft处理不是数据格式的对象内容,按照指定对应formart转换时间格式内容

2.3 用户名和密码检测

011 用户名检测器

#!/bin/env python
"""
编写Python代码，要求用户输入用户名，进行检测：
1、用户名至少6位；
2、文件名不能在文件p011_users.txt中存在
"""
import os
file = "p011_users.txt"
if os.path.exists(file):
    while True:
        pass
        username = input("请输入用户名:")
        with open(f"{file}",encoding="utf-2") as v:
            users = [name.strip() for name in f.readlines() if name.strip()]
            #users为按行读取的文件内容,并清空前后字符串
            #并去除空行

        if len(username) < 6:
            print("你输入账户长度小于6位,请重新输入！")
            continue

        if username in users:
            print("用户名已存在,请重新输入！")
            continue
        else:
            print("新用户验证通过")
            break
else:
    print("文件不存在,无法校验！！")
    #文件不存在则退出
    exit(11)
 
----方法2
#!/bin/env python
"""
编写Python代码，要求用户输入用户名，进行检测：
1、用户名至少6位；
2、文件名不能在文件p011_users.txt中存在
"""
import os
file = "p011_users.txt"
if os.path.exists(file):
	list = []
	with open(f"{file}",encoding="utf-2") as f:
		for i in f:
			i = i.strip()
			#此时i读取的f中的每一行内容
			if len(i) > 0:
				#如果字符长度大于0
				list.append(i)
				#则追加到列表中
else:
	print("用户文件不存在！")
	exit(11)
while True:
	username = input("请输入你的用户名:")
	if username == "exit" or username == "quit":
		exit(12)
	elif len(username) < 6:
		print("用户名长度不够,至少为六位！")
		continue
	elif username in list:
		print("用户名已存在")
		continue
	else:
		print(f"{username}用户已创建！")

012 随机密码生成器

#!/bin/env python
"""
编写Python代码，用户输入密码位数，给出一个随机密码生成
"""
"""
提示：
python自带的string模块，提供多种字符集合，
小写字母：string.ascii_lowercase；
大写字母：string.ascii_uppercase；
数字：string.digits；
标点符号：string.punctuation
random是随机数模块，random.sample可以从序列中随机得到几个字符的列表
"""
import string,random
worlds = string.ascii_lowercase + string.ascii_uppercase + string.digits + string.punctuation
len = int(input("请输入密码位数："))
chosen = random.sample(worlds,len)
#sample中的len必须为int类型
#print(chosen)                 #默认chosen会变为一个列表.
#random.sample可以从序列中随机得到几个字符的列表
psd = "".join(chosen)
#""为空内容,chosen为对应新增序列内容,结合时不加任何内容
#将列表内容结合,总结不做任何字符的改动.列表结合
print(f"密码为：{ps}")

019 密码强度检测器

#!/bin/env python
"""
编写Python代码，需要用户一直输入密码，直到满足如下条件才退出循环：
至少包含一个数字；
至少包含一个大写字母；
密码至少6位数；

实现效果如下，如果不满足条件会一直循环：
"""
while True:
    print("*" * 20);print("密码至少六位数,至少包含一个大写字母和一个数字")
    pwd = input("请输入密码:")
    have_number = any([i.isdigit() for i  in pwd])
    have_upper = any([i.isupper() for i in pwd])
    #isupper是否包含大写字母,isdigit是否包含数字
    #any后方元素命中一个则为true

    if have_upper and have_number and len(pwd) >= 6:
        print("密码校验成功！")
        break
    else:
        print("密码校验失败！")
        continue
#解释：
#any这个方法，参数可以是一个list/set等序列，如果任何一个元素为True，那么any返回True
#如果通过校验，则break退出循环；否则打印信息，继续下一次循环；

020 详细错误密码检测器

#!/bin/env python
"""
编写Python代码，需要用户一直输入密码，直到满足如下条件才退出循环：
至少包含一个数字；
至少包含一个大写字母；
密码至少6位数；
"""
while True:
    msgs = []
    pwd = input("请输入密码:")
    if not any([i.isdigit() for i in pwd]):
        #如果遍历pwd中不存在数字,那么any返回false.
        msgs.append("需要至少一个数字")
        #any为false则追加一个msgs至列表中.
    if not any([i.isupper() for i in pwd]):
        #如果pwd中不存在大写字母
        msgs.append("需要至少一个大写字母")
        #any为fasle追加报错至列表中
    if len(pwd) < 6:
        msgs.append("需要至少6个字符")
    if len(msgs) == 0:
        #列表为空.说明没有报错
        print("密码检测通过！")
        break
    else:
        #如果没有break退出,那么输出报错原因
        print("密码验证失败,原因如下:")
        for message in msgs:
            print("*",message)
            #输出报错原因后,重回循环,列表清空
>>>>解释：
#msgs为出错信息列表，任何一个检测不通过，就放进msgs;
#如果msgs为空，说明所有检测通过；如果不为空，则有多条检测不通过，会挨个输出

2.4 文件处理统计

021 文件内容乘数字

"""
新建文件p021.txt，将如下内容粘贴到文件中
编写代码，给每个数字乘以2，结果输出到p021_output.txt
"""
with open("p021.txt",encoding="utf-2") as read,open("p021_output.txt", "w") as out:
    for line in read:
        #按行读取数据,即进行6次循环
        if "x,y" in line:
            #第一次循环会拿到第一行即x,y
            out.write(line)
            #那么就写入到文件中
        else:
            #第二行开始没有x,y则执行else中的内容
            x,y = line.strip().split(",")
            #strip将末尾的换行符去除
            x = int(x) * 2
            y = int(y) * 2
            out.write(f"{x},{y}\n")

022 计算最大值最小值平均值

"""
输入一个成绩文件，计算成绩的最大值最小值平均值

文件名：p022.txt，自己复制如下内容进去即可：
"""
def compute_score():
    scores = []
    with open("p022.txt",encoding="utf-2") as v:
        for line in v:
            #按行读取数据
            fields = line.strip().split(",")
            #strip情况换行符,split按照,号进行内容的读取
            scores.append(int(fields[2]))
            #列表追加fields列表中索引为2的内容
        max_score = max(scores)
        min_score = min(scores)
        avg_score = sum(scores) / len(scores)
        return max_score,min_score,avg_score
        #调用函数返回三个对应值的内容
max_score,min_score,avg_score = compute_score()
#定义三个值来取函数返回的三个值,one by one
print(f"最高分:{max_score}")
print(f"最低分:{min_score}")
print(f"平均分:{avg_score}")

023 文件合并

"""
用python编写代码，把这两个txt拼接在一个文件，存入p023.txt
"""
with open("po23.txt","w",encoding="utf-2") as out:
    #打开要写入的新的文件
    for name in ["p023_xiaomei.txt", "p023_xiaohua.txt"]:
        #for循环遍历读取的文件
        with open(name,encoding="utf-2") as fin:
            #打开读取文件
            for line in fin:
                #line进行按行读取
                out.write(line)
                #每一行写入新的文件中

024 文件交集

--方法1
"""
用python编写代码，计算两个人的爱好的交集
提示：set集合，有方法叫做 intersection，可以直接计算交集
"""
list = []
new_data = []
for name in ["p024_xiaomei.txt","p024_xiaohua.txt"]:
    #循环读取两个文件
    with open(name,encoding="utf-2") as f:
        #打开循环的俩个文件
        for line in f:
            #按行读取文件内容
            line = line.strip()
            #清楚换行符
            fieds = line.split()
            #用空格分隔
            list.append(fieds[1])
            #因为读取出的数据是列表的形式,1为爱好.直接追加至列表中
while list:
    #根据list的内容进行循环,list为两个文件的内容
    pop_l = list.pop()
    #在list列表中进行pop
    if pop_l not in list:
        continue
        #如果取出的值不在列表中说明是差集则丢弃
    else:
        new_data.insert(0,pop_l)
        ##否则取出的值还存在与list为并集
print(new_data)

--方法2
"""
用python编写代码，计算两个人的爱好的交集
提示：set集合，有方法叫做 intersection，可以直接计算交集
"""
def get_aihao(fname):
    aihao = []
    with open(fname,encoding="utf-2") as f:
        for line in f:
            line = line.strip()
            aihao.append(line.split()[1])
            #爱好为追加按行读取的文件内容列表索引为1的内容
        return aihao
xiaomei = get_aihao("p024_xiaomei.txt")
#定义xiaomei为执行函数和文件路径
xiaohua = get_aihao("p024_xiaohua.txt")
for i in set(xiaomei).intersection(set(xiaohua)):
    #直接将xiaomei获取的值转换为set集合可以去
    #intersection俩个集合进行比较,获取交集
  print(i)

025 每种爱好的喜欢人数

"""
输入一个（姓名，爱好）文件，计算每个爱好的人数

文件名：p025.txt，自己复制如下内容进去即可，姓名和爱好是空格分割的：
"""
like_count = {}
#定义空字典,用来去重和统计
with open("p025.txt",encoding="utf-2") as f:
    for line in f:
        fieds = line[:-1]
        #fieds为f的文件内容,即每一行的完整内容
        sname ,likes = fieds.split()
        #名字和爱好进行拆包获取值
        like_list = likes.split(",")
        #爱好为likes的,号拆包值
        for like in like_list:
            #爱好遍历每一个拆包的球类运动
            if  like not in like_count:
                #如果这个球类没有在字典中,遍历字典获取的是单个字符串
                like_count[like] = 1
                #如果没有则为第一次
            else:
                like_count[like] += 1
                #负责在计数的基础上+1
for key,value in like_count.items():
    print(key,value)

026 实现文件的关联

"""
有两个文件：
文件1：成绩文件，列为（学号、成绩）
文件2：学生信息文件，列为（学号，姓名）
关联两个文件，得到（学号、姓名、成绩），结果存入 p026.txt
"""
grade_dict = {}
with open("p026_grade.txt",encoding="utf-2") as read:
    for line in read:
        fieds = line[:-1]
        #格式化字符,去除换行符
        id,grade = fieds.strip().split(",")
        grade_dict[id] = grade
    print(grade_dict)

file = open("p026.txt",'w',encoding="utf-2")
with open("p026_student.txt",encoding="utf-2") as st_read:
    for line in st_read:
        id,sname = line.strip().split(",")
        #id,name通过循环进行拆解
        grade = grade_dict[id]
        #grade为通过上方gradetxt获取的字典,来获取此时grade的值,id对应的value
        #id为此时的student文件获取的id
        file.write(f"{id},{sname},{grade}\n")
        #通过拆解的id,name和上方生成的gradde字典获取grade来生成新的文件
file.close()
#因为不是运用了with的方法,所以需要手动关闭文件



"""
有两个文件：
文件1：成绩文件，列为（学号、成绩）
文件2：学生信息文件，列为（学号，姓名）
关联两个文件，得到（学号、姓名、成绩），结果存入 p026.txt
"""
grade_dict = {}
with open("p026_grade.txt",encoding="utf-2") as read_one:
    for line in read_one:
        fieds = line.strip().split(",")
        if  len(fieds) == 2:
            id,grade = fieds
            grade_dict[id] = grade
        else:
            print("文件内容有误！")
            exit(11)
out = open("p026.txt",'w',encoding="utf-2")
with open("p026_student.txt",encoding="utf-2") as new_read:
    for line in new_read:
        fieds = line.strip().split(",")
        if	len(fieds) == 2:
            id,name = fieds
            grade = grade_dict[id]
            #因为俩个表的id是一致的,通过上方输出的字典中的key--id获取对应的成绩,满足输出要求
            out.write(f"{id},{name},{grade}\n")
        else:
            print("文件格式有误,无法拆出对应数字的包！")
            exit(12)
out.close()

2.5 正则表达式

021 判断日期格式

"""
编写函数date_is_right，判断日期是不是 YYYY-MM-DD 的格式
如果是返回True，否则返回False
"""
import  re
##re模块是python独有的匹配字符串的模块，该模块种提供功能基于正则表达式实现的，对于字符串进行模糊匹配找到想要的内容信息，一般用于爬虫或者自动化测试前后端不分离项目
def date_is_right(date):
    return re.match(r"\d{4}-\d{2}-\d{2}",date) is not None
#解释
#match()是从头开始匹配的 如果匹配不到就会返回None 并且匹配到一个就返回后面就不会匹配了re.match会给字符串匹配模式，如果匹配成功返回Match对象，匹配不成功返回None
#\d可以代表0到9的任何一个数字，{2}和{4}表示前面的\d会出现2和4次
#not None:都至为可以匹配,不返回none,则返回true和false.按照前方格式进行匹配
#r代表正则方式

print("2021-05-20", date_is_right("2021-05-20"))
print("202-05-20", date_is_right("2022-05-20"))
print("2021/05-20", date_is_right("2021/05-20"))
print("20210520", date_is_right("20210520"))
print("20a10520", date_is_right("20a10520"))


#!/bin/env python
import re
def data_is_true(date):
        return re.match(r"\d{4}/\d{2}/\d{2}",date) is not None

print("2022/02/22:",data_is_true("2022/02/22"))

022 提取电话号码

import re
text = "白日依19929221222山尽，黄河入45645546462192912海流。欲穷12345千里目，更上15619292345一层楼。"
pattern = r"1\d{10}"
#匹配开头为1后方为数字且为10个数字。
results = re.findall(pattern,text)
#结果为re.findall匹配字符中符合pattern条件的内容,读取为列表
#findall全文匹配
for i in results:
    #循环列表元素(2)
    print(i)
    #打印电话号码
    
#!/bin/env python
import re
text = "白日依19929221222山尽，黄河入45645546462192912海流。欲穷12345千里目，更上15619292345一层楼。"
pattern = re.compile(r"1\d{10}")
#re.compile定义正则匹配方式        --compile(编写)
result = pattern.findall(text)
#findall匹配结果返回列表
for i in result:
	print(i)

029 提取邮箱地址

import  re
context = """
寻隐者12345@qq.com不遇
朝代：唐asdf12dsa#abc.com代
作python666@163.cn者：贾岛
松下问童子，言师python-abc@163com采药去。
只在python_ant-666@sina.net此山中，云深不知处。
python_ant-666@sina.nettasd
"""
pattern = re.compile(r"[a-zA-Z0-9_-]+@[a-zA-Z0-9]+\.[a-zA-Z]{2,3}")
#re.compile可以提前编译正则表达式(定义正则匹配规则).内容为:a-9加特殊字符集合开头,@a-9+.a-Z出现2-3次,因为正常邮箱结尾都为2-3次
results = pattern.findall(context)
#re.findall可以搜索多种匹配模式(全文匹配)
#findall根据pattern指定的正则方法处理context的文本内容
print(results,len(results))

090 多个禁用词替换

"""
如下文字中，有很多不允许使用的词语，包含 最好、最低、绝对
用python将这三个词语，都替换成***字符串
"""
#!/bin/env python
conetxt = """
这个商品很好，质量最好、用起来很不错，并且价格最低，绝对的物美价廉
"""
import re
pattern = re.compile(r"最好|最低|绝对")
result = re.sub(pattern,"****",conetxt)
print(result)

sub(pattern, repl, string, count=0, flags=0)
# pattern：正则模型
# repl   ：要替换的字符串
# string ：要匹配的字符串
# count  ：指定匹配个数
# flags  ：匹配模式

091 给手机号打上马赛克

"""
如下文字中，有一些手机号数字
用python将所有的手机号，只保留开始和结尾数字，中间用******代替
"""
conetxt = """
白日依19929221222山尽，黄河入45645546462192912海流。
欲穷12345千里目，更上15619292345一层楼。
"""
import  re
pattern = r"(1\d)\d{1}(\d{2})"
#pattern方法为给开头1\d进行分组(俩位数),即开头的俩个数字(1\d).中间位数为1位,(\d{2})即尾数为2个数字作为第二个分组
print(re.sub(pattern,r"\1*****\2",conetxt))
#在re.sub的第二个参数，用\1和\2可以引用前面的两个分组
#\1引入pattern中的(1\d)这个分组,\2为第二个分组,中间内容替换为*,针对conetxt文件
#sub函数：替换匹配成功的指定位置字符串
##参考网页：
http://c.biancheng.net/view/1162.html
---python正则


----2.不要多余字符只要电话并打码
#!/bin/env python
conetxt = """
白日依19929221222山尽，黄河入45645546462192912海流。
欲穷12345千里目，更上15619292345一层楼。
"""
import re
old_pattern = re.compile(r"1\d{10}")
#编辑正则表达式1开头后面为0-9{10}共11个数字组成的内容
old_result = old_pattern.findall(conetxt)
#结果为:匹配文本中符合表达式的内容
for i in old_result:
    #取出的值都为list列表,遍历取出的电话号码
    pattern = re.compile(r"(1\d)\d{1}(\d{2})")
    #定义正则分组
    result = re.sub(pattern,r"\1*******\2",i)
    #按照正则表达式,替换字符串为中间内容,复用分组,针对i进行匹配替换
    print(result)

2.6 文件管理

092 扫描目录下所有文件

#!/bin/env python
"""
提供一个目录路径，用python扫描所有的文件，列出文件路径
"""
import os
dir = r"/root/python3/code_test"
#r表示raw-string，那么后面的字符串中反斜线将会是正常的字符而不是转义符号
for root,dirs,files in os.walk(dir):
	#root获取的是当前的目录也就是/root
	#dirs,files为目录下的子目录和文件列表(固定形式).
        for file in files:
        	#files为所有目录下的文件
                fpath = os.path.join(root,file)
                #将目录和文件结合输出,输出绝对路径
                print(fpath)

093 扫描py文件的行数

import os

dir = r"E:\py-资料\py学习\第二章--class类"
for root, dirs, files in os.walk(dir):
    # root为目录,dirs和files为子目录和文件.固定三个元素
    for file in files:
        # 遍历子目录中的文件
        if file.endswith(".py"):
            # 如果文件结尾为.py
            fpath = os.path.join(root, file)
            # 定义文件的输出为目录加文件名
            with open(fpath, encoding="utf-2") as f:
                # 打开找到的文件
                print(f"文件路径为:{fpath}--行数为:{len(f.readlines())}")
                # len(f.readlines())输出为集合,因为默认有换行符,所以列表个数为文件行数！！

094 自动整理文件夹

"""
自己新建一个目录 arrange_dir
自己在文件夹下，手动新建多个“假文件”：
aaa.txt bbb.mp3 ccc.avi ccc.jpg ddd.jpg eee.txt fff.mp3 ggg.jpg hhh.txt iii.mp3
"""
import os
import shutil
dir = "./arrange_dir"
for file in os.listdir(dir):
    #os.listdir列出指定目录下的所有文件
    ext = os.path.splitext(file)[1]
    #os.path.splitexe会将文件名和后缀分开,形成一个元组的数据类型[1]即为后缀
    #例:(kill,.py)
    ext = ext[1:]
    #按照字符串索引进行格式化,只要py
    #例：索引0为.,1-end为1:
    if not os.path.isdir(f"{dir}/{ext}"):
        #如果目录不存在
        os.mkdir(f"{dir}/{ext}")
        #则创建目录
        print(f"{ext}已创建！")
    else:
        print(f"目录{ext},已存在！")
    source_path = f"{dir}/{file}"
    #源路径即为当前目录下的文件
    dest_path = f"{dir}/{ext}/{file}"
    #目标路径为已文件后缀新创目录下
    shutil.move(source_path,dest_path)
    #shutil.move将源文件移动到目录路径下
print("Done")

095 自动压缩文件夹

"""
提供任何一个目录地址，用python实现文件夹的压缩，压缩成zip格式
例如：dir = r"D:\workbench\ant-python-exercises-100p"
则会生成一个文件 r"D:\workbench\ant-python-exercises-100p.zip"
这个压缩文件是对这个目录的压缩结果
"""
import os
import zipfile

def do_zip_compress(dirpath):
    #定义函数体方便调用
  output_name = f"{dirpath}.zip"
    #定义压缩后的名称
  parent_name = os.path.dirname(dirpath)
    #去掉文件名,返回目录名称,如果为多层目录返回前一层
  zip = zipfile.ZipFile(output_name, "w", zipfile.ZIP_DEFLATED)
    #压缩文件为输出的名称,写入,zip_DEFLATED对文件进行压缩
  for root, dirs, files in os.walk(dirpath):
      #查看对应路径下的文件
    for file in files:
      if str(file).startswith("~$"):
          #将获取到的文件名转换为str,startswith判断开头是否为~$的临时文件
        continue
          #如果是则丢弃
      filepath = os.path.join(root, file)
      #文件路径为目录+文件名--绝对路径
      writepath = os.path.relpath(filepath, parent_name)
      #写入路径为filepath和parent_name间的相对路径,因为上方parent已经变成了arrange的上级目录,所以会变成基础练习目录
      zip.write(filepath, writepath)
            #压缩写入为文件和对应路径
  zip.close()
    #关闭压缩

dirpath = r"E:\py-资料\py学习\基础练习100题\arrange_dir"
do_zip_compress(dirpath)
#最后的路径为基础练习100题

2.1 爬虫Requests

096 Requests模块报错

"""
解释：
requests是一个开源库，自己是有get方法的
报错是因为，python本身导入类库时，会先从本地文件导入，它发现了本地文件有一个requests.py就导入了，但是这是我们自己的文件，里面确实没有get方法
如果改完了文件名，报错说requests不存在，则需要自己安装一下代码包
"""

091 来自URL的文件

"""
用Python访问URL：http://antpython.net/static/py100/life_is_great.txt
然后打印文件中的如下内容：
"""
import requests
url = "http://antpython.net/static/py100/life_is_great.txt"
r = requests.get(url)
#get得到对应url中的内容
print(r.text)
#通过text文本输出内容
#解释：
requests是python的开源模块，可以请求URL的结果
requests.get可以访问一个URL
requests.get的结果，有一个属性是text，放置了这个URL的结果内容

092 下载URL的图片

"""
这个URL是一个图片，用python下载图片，存入到本地p092.jpeg：
http://antpython.net/static/pubdatas/webspider/goodimgs/9.jpeg
"""
url = "http://antpython.net/static/pubdatas/webspider/goodimgs/9.jpeg"
import requests
r = requests.get(url)
#获取对应url的内容
with open("p029.jpg","wb") as f:
    f.write(r.content)
    #如果要下载文件，需要用open的wb模式写入文件，写入的时候，用resp.content二进制形式，不能用resp.text

099 给网页提交数据

"""
这是一个网页，里面有一个表单可以提交数据
http://antpython.net/webspider/grade_form
使用python提交一条数据，并且在网页上看到效果：
姓名：蚂蚁099，语文22，数学99，英语66
提示：
可以用chrome浏览器的f12打开network，查看后台请求
表单提交的Url是：http://antpython.net/webspider/grade_form
提交方法是post，数据格式为 sname: xx，yuwen: 66，shxue: 11，yingyu: 22
用requests.post提交即可
"""
url = "http://antpython.net/webspider/grade_form"
import requests
datas = {"name":"蚂蚁099","语文":22,"数学":99,"英语":66}
resp = requests.post(url,data=datas)
#post为上报请求,即交互式,data会上报数据
print(resp.status_code)
#打印post的请求的对应状态码

100 打开百度搜索

"""
编写代码，让用户输入一个词语，代码自动打开浏览器，在百度搜索关键词，展示结果
例如用户输入python，自动打开这个界面
"""
"""
提示：
百度搜索的URL：https://www.baidu.com/s?wd=python 这个wd=python，可以替换关键词
python有个模块webbrowser，用它的webbrowser.open(url)可以直接浏览器打开一个URL
"""
import  webbrowser
querry = input("输入你的问题:")
webbrowser.open(f"https://www.baidu.com/s?wd={querry}")
#webborwser.open打开后方的url,wd替换问题

3.print输出带颜色

1.顺序：显示方式，前景颜色，背景颜色
2.顺序非固定，但尽量按默认书写方式
3.也可以在input中输出使用
4.格式： print('\033[显示方式；前景颜色；背景颜色m ..........\033[0m')


--code
#!/bin/env python
"""
一般不针对显示方式进行调色！
"""
print("\033[4;31;40mhello python!\033[0m")          ##一般不采用,直接前景色即字体颜色即可
print("\033[33mhello python!\033[0m")
print("\033[31mhello python!\033[0m")

3.1 显示方式

意义	显示方式
默认	0
高亮显示	1
下划线	4
闪烁	5
反白显示	1
不可见	2

3.2 颜色

颜色	前景色	背景色
黑色	30	40
红色	31	41
绿色	32	42
黄色	33	43
蓝色	34	44
紫红色	35	45
青蓝色	36	46
白色	31	4

4.模块和包

4.1归属分类

模块还可以分为

#内置模块 ，就是 python 解释器中自带的. 如： osreitertools
#第三方模块， 这些模块需要自己安装，就像是在 Linux 系统中安装软件一样。
#自定义模块， 这个就是自己编写的模块。

4.2自定义模块

有的情况下，是需要自己编写一些模块的，这种就是自定义模块了。
some_mod.py     --模块文件
x = 10

li = ['shark', 12]

def foo():
    return 30

class Person():
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
#此时便自定义了一个py模块文件

4.3调用自定义模块

##方法一:
import some_mod                #同级目录下可直接import,不同目录下需要from目录+import包名。import直接获取软件包默认会获取所有对象
print(some_mod.foo())
hh = some_mod.Person("薛晓强",20)
print(f"\033[34m我的名字是:{hh.name},年龄是{hh.age}!\033[0m")

##方法二:
from some_mod import foo,x,Person          #精确获取某个对象                
print(foo())
hh = Person("薛晓强",21)
print(f"\033[34m我的名字是:{hh.name},年龄是{hh.age}!\033[0m")
print(x)
##导入模块时模块的代码会自动被执行一次，在一个程序中多次导入同一个模块，此模块的代码仅会运行一次。