# 文艺
 obj = open(‘log.txt‘,mode=‘r‘,encoding=‘utf-8‘)
 data = obj.read() 
 obj.close()
 # 二逼
 with open(‘log.txt‘,mode=‘r‘,encoding=‘utf-8‘) as v: 
     data = v.read() 
 # with as 操作完后自动关闭文件

# log.txt 内容:
 ‘‘‘
 再插进去
 ‘‘‘
 with open(‘log.txt‘,mode=‘r‘,encoding=‘utf-8‘) as obj:
     data = obj.read()
 print(data) # 再插进去
 new_data = data.replace(‘再‘,‘第一次‘)
 with open(‘log.txt‘,mode=‘w‘,encoding=‘utf-8‘) as obj:
     obj.write(new_data)
 # log.txt 修改后的内容:
 ‘‘‘
 第一次插进去
 ‘‘‘
 # ps: 上面这种,全部读到内存,如果文件太大,就会撑爆内存

# log.txt 内容:
 ‘‘‘
 第一次插进去
 ‘‘‘
 f1 = open(‘log.txt‘,mode=‘r‘,encoding=‘utf-8‘)
 f2 = open(‘log2.txt‘,mode=‘w‘,encoding=‘utf-8‘)
 for line in f1:
     new_line = line.replace(‘一‘,‘二‘)
     f2.write(new_line)
 f1.close()
 f2.close()
 # log2.txt 内容:
 ‘‘‘
 第二次插进去
 ‘‘‘
 # 简写:
 with open(‘log.txt‘,mode=‘r‘,encoding=‘utf-8‘) as f1, open(‘log2.txt‘,mode=‘w‘,encoding=‘utf-8‘) as f2:
     for line in f1:
         new_line = line.replace(‘一‘, ‘二‘)
         f2.write(new_line)

# 发送邮件封装
 import smtplib
 from email.mime.text import MIMEText
 from email.utils import formataddr
 ?
 def send_email():  # 定义
     msg = MIMEText(‘我爱你‘, ‘plain‘, ‘utf-8‘)
     msg[‘Form‘] = formataddr(["发送人的名字",‘发送人的邮箱‘])
     msg[‘To‘] = formataddr(["被发送人名字","被发送人的邮箱"])
     msg[‘Subject‘] = "主题"
     
     server = smtplib.SMTP("smtp@163.com", 25)
     server.login("发送人的邮箱", "密码")
     server.sendmail("发送人的邮箱", [‘被发送人的邮箱‘, ], msg.as_string())
     server.quit()
 ?
 send_email() # 调用
 # 如果发送不成功,可能是网易开了客户端授权密码,关闭即可 

 def join_list(a1, a2):
     result = []
     result.extend(a1)
     result.extend(a2) # extend 拼接
     print(result) # [11, 22, 33, 44, 55, 66]
 join_list([11, 22, 33], [44, 55, 66])

def join_list(a1, a2):
     result = []
     result.extend(a1)
     result.extend(a2)
     return result  # return 返回值; 不写默认return None
 v = join_list([11, 22, 33], [44, 55, 66])
 print(v) # [11, 22, 33, 44, 55, 66]
 ?
 # 练习1.让用户输入一段字符串,计算字符串中有多少A字符的个数,有多少个就在文件a.txt中写多少个‘嘻‘
 def get_char_count(data):
     sum = 0
     for i in data:
         if i == ‘A‘:
             sum += 1
     return sum
 ?
 def write_file(line):
     if len(line) == 0:
         return False
     with open(‘temp.txt‘,mode=‘w‘,encoding=‘utf-8‘) as f:
         f.write(line)
     return True
 ?
 content = input("请输入:")
 count = get_char_count(content)
 write_data = ‘嘻‘ * count
 status = write_file(write_data)
 if status:
     print("写入成功")
    
 # 特殊,返回元组
 def test():
     return 1,‘3‘,[‘43‘,‘ni‘]
 v = test()
 print(v) # (1, ‘3‘, [‘43‘, ‘ni‘])

 # 3.读取文件,将文件的内容构造成指定格式的数据，并返回
 """
 a.log 
     nbchen|23|175
     Chen老大的猫|3|61
 目标：
 a. [‘nbchen|23|175‘,‘Chen老大的猫|3|61‘]并返回
 b. [[‘nbchen‘,‘23‘,‘175‘],[‘Chen老大的猫‘,‘3‘,‘61‘]]
 c. [
     {‘name‘:‘nbchen‘,‘age‘:‘23‘,‘height‘:‘175‘},
     {‘name‘:‘Chen老大的猫‘,‘age‘:‘3‘,‘height‘:‘61‘}
     ]
 """
 ?
 print("开始读取文件")
 def get_str_2_list():
     with open(‘a.log‘,mode=‘r‘,encoding=‘utf-8‘) as f:
         list = []
         for line in f:
             print("每一行的内容%s" % (line, ))
             list.append(line.strip())
     return list
 v = get_str_2_list()
 print("读取的集合：",v,"\n=======================")
 a = v # 第一题
 ?
 def get_list_format(list):
     new_list = []
     for i in range(0,len(list)):
         t = list[i].split(‘|‘)
         print("切割后得到数据:",t)
         new_list.append(t)
     return new_list
 v = get_list_format(v)
 print("格式化的集合：", v , "\n=======================")
 b = v # 第二题
 ?
 def list_format_map(list):
     v = [‘name‘,‘age‘,‘height‘]
     list_dic = []
     for item in range(0,len(list)):
         dic = {}
         print("集合中的每一项:", list[item])
         for i in range(0, len(list[item])):
             print("集合中的子集合的每一项:", list[item][i])
             print("字典的每个key:",v[i])
             dic[v[i]]= list[item][i]
             print("集合中的子集合的每一项映射到字典：",dic)
         list_dic.append(dic)
     return list_dic
 v = list_format_map(v)
 print("格式化后的字典: ",v)
 c = v #  第三题
 ?
 # 耗时：35分钟

 # 默认函数参数按顺序的,
 # 如果想要不按顺序传参,可以指定关键字即可
 def func(a1,a2):
     print(a1,a2) # 2 1
 func(a2=1,a1=2)
 ?
 # 传参和位置传参混用的时候,必须关键字传参在后面,而且，注意顺序
 def func(a1,a2,a3):
     print(a1,a2,a3) # 1 3 4
 func(1,a2=3,a3=4)

# 动态接收位置参数
 def eat(*args):
     print(‘我想吃‘,args)
 eat(‘大米饭‘,‘中米饭‘,‘小米饭‘)  # 收到的结果是一个tuple元祖
 ?
 # 不确定要接收多少个参数的时候,可以用动态参数
 # 动态参数必须放在位置参数,默认参数后面
 ?
 # 最终顺序:
 # 位置参数 > args(动态位置参数) > 默认值参数 > *kwargs(动态默认参数)
 ?
 # 综合使用:
 def func(*args,**kwargs):
     print(args,kwargs)
 func(1,23,5,a=1,b=6)
 func(1,*[23,5],**{a=1,b=6})

def func():
     print(123)
 v1 = func
 func()
 v1()
 ?
 # 也可以放到列表[]里面,还可以放到集合{}里面,但是也注意去重的效果。
 func_list = [func,func,func]
 for item in func_list:
     item()
     
 # 也可以放到字典{}里面
 def func():
     print(‘1‘)
 dic = {‘k1‘:func,‘k2‘:func}
 dic[‘k1‘]()
 ?
 # 函数名可以当做变量使用,当前参数传递

 def test1():
     print(‘test1‘)
 def test2():
     print(‘test2‘)
 def test3():
     print(‘test3‘)
 def test4():
     print(‘test4‘)
 info = {
     ‘f1‘: test1,
     ‘f2‘: test2,
     ‘f3‘: test3,
     ‘f4‘: test4
 }
 choice = input("请选择要选择功能:")
 function_name = info.get(choice)
 if function_name:
     function_name()
 else: 
     print("输入错误")

 # 关键: 函数是由谁创建的,就从哪里开始找
 """
 name = ‘nbchen‘
 def base():
     print(name) # nbchen
 def func():
     name = ‘陈老大的猫‘
     base()
 func()
 """
 ?
 """
 name = ‘nbchen‘
 def func():
     name = ‘陈老大的猫‘
     def base():
         print(name)  # 陈老大的猫
     base()
 func()
 """

 ‘‘‘
 info = []
 def func():
     print(item)
 for item in range(10):
     info.append(func)
 info[0]() 
 # 9
 ‘‘‘
 ?
 info = []
 def func(i):
     def inner():
         print(i)
     return inner
 for item in range(10):
     info.append(func(item))
 info[0]() # 0

def func(a1,a2):
     return a1 + a2
 # 使用lambda
 func = lambda a1,a2 : a1 + a2 # 默认将运算的结果return回来
 func = lambda : 100 # 无参,返回100
 func1 = lambda x1: x1 * 100
 func2 = lambda *args,**kwargs: len(args)+len(kwargs)
 ?
 print(func()) # 100
 print(func1(2)) # 200
 print(func2(1, 2, 3)) # 3

 # 1字节等于8位
 # IP:192.168.17.151  ->  01010101. 00101010 . 00101011 . 00101011
 ?
 # 1.请将ip = "192.168.17.151"中的每个十进制数转换成二进制并通过,连接起来生成一个新的字符串
 ip = "192.168.17.151"
 ip_list = ip.split(‘.‘) # [‘192‘,‘168‘,‘17‘,‘151‘]
 result = []
 for item in ip_list:
     result.append(bin(int(item)))
 print(‘,‘.join(result))
 ?
 # 2.请将ip= "192.168.17.151"中的每个十进制数转换成二进制：
 # 0010101010101010010101010 -> 十进制的值

 import hashlib
 ?
 USER_LIST= []
 ?
 def get_md5(data):
     obj = hashlib.md5()
     obj.update(data.encode(‘utf-8‘))
     return obj.hexdigest()
 ?
 def register():
     print(‘**********用户注册**********‘)
     while True:
         user = input(‘请输入用户名:‘)
         if user ==‘N‘:
             return
         pwd = input(‘请输入密码:‘)
         temp = {‘username‘:user,‘password‘:get_md5(pwd)}
         USER_LIST.append(temp)
 ?
 def login():
     print(‘**********用户登录**********‘)
     user = input(‘请输入用户名:‘)
     pwd = input(‘请输入密码:‘)
 ?
     for item in USER_LIST:
         if item[‘username‘] == user and item[‘password‘]== get_md5(pwd):
             return True
 ?
 register()
 print(USER_LIST)
 result = login()
 if result:
     print(‘登录成功‘)
 else:
     print(‘登录失败‘)
 ?
 # import getpass 模块作用： 终端输入密码不显示

import time
 ?
 # 计算函数执行时间
 # 装饰器的编写
 def get_time(arg):
     def inner():
         start_time = time.time() # 执行之前
         v = arg()
         end_time = time.time() # 执行之后之间
         print(end_time - start_time) # 计时
         return v
     return inner
 ?
 @get_time # 装饰器的应用
 def func():
     time.sleep(2) # 睡一下,执行时间
     print(123)
 ?
 func()

 # 格式
 vals = [i for i in ‘alex‘]
 # 变量 = [for循环的变量 for循环一个可迭代对象]
 ?
 # 例子
 v1 = [i+100 for i in range(10)] # [100,101,....]
 ?
 # 面试题
 def num():
     return [lambda x:i*x for i in range(4)]
 # num() -> [函数,函数,函数,函数]
 print([m(2) for m in num()]) # [6, 6, 6, 6]
 # 完整的格式
 v = [i for i in 可跌代对象]
 v = [i for i in 可跌代对象 if 条件] # 可筛选