zip()函数，max()和min()，built-in function，import模块，read()，readlines()，write()，writelines()，with..as..文件处理方式

zip()函数：将可迭代对象作为参数，将对象中的对应元素打包成一个个元组。

#map()普通的输出例子
print(list(zip(('a','n','c'),(1,2,3))))
print(list(zip(('a','n','c'),(1,2,3,4))))
print(list(zip(('a','n','c','d'),(1,2,3))))

p={'name':'alex','age':18,'gender':'none'}
print(list(zip((p.keys,p.values))))

age = {'a':10,'b':3,'c':34,'d':4}
print(max(age.values()))
print(max(age.keys()))

#max遍历可迭代对象，首先比较第一个对象，如果无比较大小，再比较第二个大小
l = [
    ('e',5),
    ('b',1),
    ('a',3),
    ('d',2),
]
print('情况一',max(l))
#不同数据类型之间不能比较
# l1 = ['a10','a11000','a20',100]
# print('情况二',list(max(l1)))
l = {
    'e':5,
    'b':1,
    'a':3,
    'd':2
}
print('情况二',list(max(zip(l.values(),l.keys()))))

 max，min函数高级用法

# max最终版，min同理
people=[
    {'name':'alex','age':1000},
    {'name':'wupei','age':10000},
    {'name':'yuanhao','age':9000},
    {'name':'linhaifeng','age':18},
]
# list2 = []
# for item in people:
#     list2.append(item['age'])
# 上面for循环代码等同于如下代码：key=lambda dic:dic['age']
# print(max(list2))
#首先遍历people,把取到的每个字典依次赋值给dic,做逻辑运算取到key字(即dic['age])，最后再比较大小
print(max(people,key=lambda dic:dic['age'])) #people后的key关键字不能变！

读取和关闭文件用法（open()和close()）

使用with..as..读取某文件内容并赋值给另一个文件（如果文件不存在，新建一个文件）

结合文件使用复习删除列表中某一元素的三种方法

def test():
    msg = 'ddfdfdfdggg'
    print(locals())
    print(vars())
import yuyukun #先导入外部PY文件（直接导入文件名），后引用(方法1)
yuyukun.module1()

module_name = 'yuyukun' #先导入外部PY文件(字符串形式)，后引用（方法2）
m = __import__(module_name)
m.module()

f = open('奉大荒','r',encoding='utf-8')  #计算机中默认编码方式为GBK，没有encoding说明则默认
print(f.readable())
print(f.readlines())
data=f.read()
print(data)
f.close()

f = open('gbk1',encoding='GBK') #python寻找系统的编码
print(f.readlines())

f=open('gbk1','w')
f.write('i am superman\n')
f.write('i am dying to regain my sense of confidence\n')
f.writelines(['','',''])
f.write(3)

f=open('gbk1','a')
f.write('\n不删除原来数据，把新数据写到文件最后，哦也！！')
f=open('gbk1','r+')
f.read()
f.write('abc')

f=open('gbk1','r')
data = f.readlines()
print(data)
f.close()

dst_f = open('xxxx','w')
for i in data:
    if i.startswith(''):
        i=['ietls7777']
    dst_f.writelines(i)
dst_f.close()
# with A as B 打开A文件并赋值个B
with open('a.txt','w') as fine:
    fine.write('')
    print(fine)

# with A as B, C as D： 同时打开两个文件，并用\分行，防止代码过长
# 从源文件gbk1中读到数据，copy到新的文件中
with open('a.txt','r',encoding='utf-8') as src_r,\
        open('gbk1','w') as dst_w:
    data = src_r.readlines() #data在readlines后是一个列表
    dst_w.writelines(data)
    print(data)  #列表形式
with open('gbk1','a',encoding='gbk') as data:
    data.writelines('最后一行加数据')
    print(data)

#复习删除列表中某一行的操作，三种方法
with open('gbk1','r+',encoding='gbk') as add:
    endline = add.readlines()
    print(endline)
    endline.remove('123\n')
    print(endline)

#利用del[索引数] 函数删除指定索引数的元素
with open('gbk1','r',encoding='gbk') as add:
    endline = add.readlines()
    print(endline)
    del endline[1]
    print(endline)

#利用pop()方法弹出元素，当（）内无索引数时默认弹出最后一个元素；
with open('gbk1','r',encoding='gbk') as add:
    endline = add.readlines()
    print(endline)
    endline.pop(1)
    print(endline)

文件操作的练习

# 内置函数作业
#         =====================作业一
        #用map来处理字符串列表啊,把列表中所有人都变成sb,比方alex_sb
        name=['alex','wupeiqi','yuanhao']
name=['alex','wupeiqi','yuanhao']
print(list(map(lambda x:x+'_sb',name)))
        #用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾
        # >>> l=[{'name':'alex'},{'name':'y'}]
l=[{'name':'alex'},{'name':'y'}]
print(l[1].values())
print(list(map(lambda dic:dic['name']+'_sb',l)))

        # =====================作业二
        # 用filter来处理,得到股票价格大于20的股票名字
shares={
        'IBM':36.6,
        'Lenovo':23.2,
        'oldboy':21.2,
        'ocean':10.2,
        }
print(list(filter(lambda key:shares[key]>20,shares)))

        # =====================作业三
        #如下，每个小字典的name对应股票名字，shares对应多少股，price对应股票的价格
from functools import reduce
portfolio = [
        {'name': 'IBM', 'shares': 100, 'price': 91.1},
        {'name': 'AAPL', 'shares': 50, 'price': 543.22},
        {'name': 'FB', 'shares': 200, 'price': 21.09},
        {'name': 'HPQ', 'shares': 35, 'price': 31.75},
        {'name': 'YHOO', 'shares': 45, 'price': 16.35},
        {'name': 'ACME', 'shares': 75, 'price': 115.65}
]
        # 1:map来得出一个包含数字的迭代器，数字指的是：购买每支股票的总价格
res = list(map(lambda dic:round(dic['shares']*dic['price'],2),portfolio))
print(res)
        # 2:基于1的结果，用reduce来计算，购买这些股票总共花了多少钱
sum = reduce(lambda x,y:x+y,res,0)
print(sum)
        # 3：用filter过滤出，单价大于100的股票有哪些
p = list(filter(lambda dic:dic['price']>100,portfolio))
print(p) #过滤出来整个字典
res1 = map(lambda x:print(x['name'],end=' '),p)
list(res1)

补充内置函数sorted()
l = [3,2,1,5,7] #排序是同类型之间比较大小
print(list(reversed(sorted(l))))
portfolio = [
        {'name': 'IBM', 'shares': 100, 'price': 91.1},
        {'name': 'AAPL', 'shares': 50, 'price': 543.22},
        {'name': 'FB', 'shares': 200, 'price': 21.09},
        {'name': 'HPQ', 'shares': 35, 'price': 31.75},
        {'name': 'YHOO', 'shares': 45, 'price': 16.35},
        {'name': 'ACME', 'shares': 75, 'price': 115.65}
]
print(sorted(portfolio,key=lambda t:t['price']))

name_dic={
    'alex':200,
    'wupeiqi':300,
    'yuanhao':900
}
print(sorted(name_dic)) #key中元素进行大小比较
print(sorted(zip(name_dic.values(),name_dic.keys())))
print(sorted(name_dic,key=lambda key:name_dic[key])) #字典中一级元素取value方法，1.xxx[key]; 2.xxx['对应key名字']