今日目录：
1. set
2. 函数
3. 内置函数
4. 文件操作
5. 三元运算
6. lambda表达式
7. 全局变量
一. set
set是Python基本数据类型中的一种，主要特性是： 无序、不重复的序列，基本功能包括关系测试(如父集子集等)、消除重复的元素等。set集合还支持difference(差集)、intersection(交集)、union(联合)、sysmmetric difference(对称差集)等数学运算。学习set还是按照两步骤来：1.创建 2.功能
1. 创建set集合
>>> s = set(\'daniel\') >>> s {\'d\', \'n\', \'e\', \'l\', \'i\', \'a\'} >>> type(s) <class \'set\'>
或者：
>>> s1 = {\'a\',\'b\',\'c\',}
>>> s1
{\'a\', \'c\', \'b\'}
>>> type(s1)
<class \'set\'>
注意如果要创建一个空集合，必须使用set()了，s={} 默认的是字典类型，需要使用s=set()才行
>>> s1 = {} >>> type(s1) <class \'dict\'> >>> s1 = set() >>> type(s1) <class \'set\'> >>>
可以试着尝试下传入一个列表进去：
>>> l1 = [1,2,3,4,5,5,4,3,2,1,1,2,3,4,5] >>> s4 = set(l1) >>> s4 {1, 2, 3, 4, 5} #可以看到set的不重复特性
2. 操作方法
add 往set里添加元素
>>> s1 {1, 2, 3, 4, 5} >>> s1.add(6) >>> s1 {1, 2, 3, 4, 5, 6} #add()方法一次只能接受一个参数，也就是只能添加一个元素到set里 >>> s1.add(7,8,9) #一次加3个会报错 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: add() takes exactly one argument (3 given) #通过字符串形式添加，看能否一次添加多个 >>> l3=\'789abc\' >>> s1.add(l3) >>> s1 {1, 2, 3, 4, 5, 6, \'789abc\'} #也是把一个字符串当成一个参数来添加
clear 清空set
>>> s1 {1, 2, 3, 4, 5, 6, \'789abc\'} >>> s1.clear() >>> s1 set()
copy 复制
>>> s1 {1, 2, 3, 4, 5, 6, \'789abc\'} >>> s2 = s1.copy() >>> id(s1) 139851744274920 >>> id(s2) 139851744275368
difference 取差集
>>> s1 = {1,3,4,5,}
>>> s2 = {3,1,7,9}
>>> s1.difference(s2) #A里有的元素，B里没有的元素
{4, 5}
intersection 取交集
>>> s1 = {1,3,4,5,}
>>> s2 = {3,1,7,9}
>>> s1.intersection(s2) #A和B都有的元素
{1, 3}
symmetric_difference 对称差集
>>> s1 = {1,3,4,5,}
>>> s3 = {11,22,3,4}
>>> s1.symmetric_difference(s3) #A中有，B没有，B有，A没有的元素
{1, 5, 11, 22}
difference_update intersection_update symmetric_difference_update 这三个放在一起说，主要是带update会更新原始数据：
>> s1 {1, 3, 4, 5} >>> s2 {9, 1, 3, 7} >>> s1.difference_update(s2) >>> s1 #s1的值已经变成了s1和s2的交集的结果 {4, 5} >>> s2 #s2的值没变 {9, 1, 3, 7} #intersection_update >>> s2 {9, 1, 3, 7} >>> s3 {3, 4, 11, 22} >>> s2.intersection_update(s3) >>> s2 #s2的值变成两个交集的结果 {3} >>> s3 #s3不变 {3, 4, 11, 22} #symmetric_difference_update >>> s3 {3, 4, 11, 22} >>> s4 {3, 44, 11, 22, 55} >>> s3.symmetric_difference_update(s4) >>> s3 #取两个集合的对称差集写入到s3中了 {4, 55, 44} >>> s4 #s4不变 {3, 44, 11, 22, 55}
discard 如果set中存在某元素，就删除
>>> s1 {4, 5} >>> s1.discard(60) #set中没有60元素，所以没返回任何消息 >>> s1 {4, 5} >>> s1.discard(5) #set中有元素5，所以，元素被删除 >>> s1 {4}
pop 删除元素,set是无序的，因此也是随机删除元素，但是会返回删除的这个元素值，pop的特性，在Python的数据类型中都是这种，删除后会返回这个删除元素；
>>> s4 {3, 44, 11, 22, 55} >>> s4.pop() 3 >>> s4.pop(55) >>> s4.pop() 44
remove 删除指定的元素，必须要返回一个值
>>> s4 {11, 22, 55} >>> s4.remove(44) #由于set中没有44元素，所以报错 Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 44 >>> s4.remove(55) #删除55元素 >>> s4 {11, 22}
issubset 是否是子集，是为True，否为False
>>> s3 {4, 55, 44} >>> s4 {33, 11, 44, 22, 55} >>> s3.issubset(s4) #s3不是s4的子集，返回为False False >>> s4.issubset(s3) False >>> s5 = {11,22,33} >>> s5.issubset(s4) #s5是s4的子集，返回True True
issuperset 是否是父集，是为True，否为False
>>> s4 {33, 11, 44, 22, 55} >>> s5 {33, 11, 22} >>> s4.issuperset(s5) #s4是s5的父集合，返回True True
union 联合，数据可以是字符串、list、dict、int任意类型，并且会把元素拆开，去重之后添加到set中，但是，如果需要保存的话，应该赋值给一个变量
>>> l1 = [1,2,3,4,5,] #创建一个列表 >>> s3 #查看s3以前元素 {4, 55, 44} >>> s3.union(l1) #将l1中的每一个元素遍历，并加入到sets中打印出来 {1, 2, 3, 4, 5, 44, 55} >>> s3 #s3中的元素还是没有变，所以如需保存，应该赋值给变量 {4, 55, 44} >>> str1=\'daniel\' #创建一个字符串 >>> s3.union(str1) #union会将字符串拆分，去重后加入set打印 {4, \'l\', 44, \'i\', 55, \'a\', \'n\', \'e\', \'d\'} >>> t1 = (3,4,5,6,) #tuple一样 >>> s3.union(t1) {3, 4, 5, 6, 44, 55} >>> t1 = (3,4,5,6,99,0,234,441,34,) >>> s3.union(t1) {0, 34, 3, 4, 5, 6, 99, 234, 44, 55, 441} >>> d1 = {\'k1\':\'v1\',\'k2\':\'v2\',\'k3\':[1,3,3,4,55,]} #字典默认会遍历所有key然后加入到set打印 >>> s3.union(d1) {\'k3\', \'k2\', 4, 55, 44, \'k1\'}
update，和union一样，都是扩充/添加元素到set，唯一不同的是update会写入原有集合中，而union不会
>>> s1=\'daniel\' #先创建一个字符串 >>> s2 = {\'a\',\'b\',\'c\'} #含有abc元素的set >>> s2 {\'a\', \'c\', \'b\'} >>> s2.update(s1) #加入元素s1 >>> s2 {\'l\', \'c\', \'b\', \'i\', \'a\', \'n\', \'e\', \'d\'} #结果是直接写入到s2的set中 >>> l1 = [1,2,23,4,5,6,] >>> s2 {\'l\', \'c\', \'b\', \'i\', \'a\', \'n\', \'e\', \'d\'} >>> s2.update(l1) >>> s2 {1, 2, 4, \'l\', \'c\', 5, 6, \'b\', \'i\', 23, \'a\', \'n\', \'e\', \'d\'}
isdisjoin 判断两个set中是否有交集，有返回True，否则返回False
>>> s2 {1, 2, 4, \'l\', \'c\', 5, 6, \'b\', \'i\', 23, \'a\', \'n\', \'e\', \'d\'} >>> s3 {4, 55, 44} >>> s2.isdisjoint(s3) False
3. 练习题
寻找差异
#需求: #如下数据，假设是一个CMDB，老的数据库中的数据(内存槽位): old_dic = { \'#1\': 8, \'#2\': 4, \'#4\': 2, } #新采集的数据， new_dic = { \'#1\': 4, \'#2\': 4, \'#3\': 2, } # 槽位1，槽位2值发生变化需要更新数据到老的数值 # 槽位4发生变化，已经移除，需要删除数据 # 槽位3发生变化，新增槽位，需要插入记录
old_dic = { \'#1\': 8, \'#2\': 4, \'#4\': 2, } new_dic = { \'#1\': 4, \'#2\': 4, \'#3\': 2, } #将新老数值的key值取出，并转换成set类型 old_dic1 = set(old_dic.keys()) new_dic1 = set(new_dic.keys()) #A和B取差集，找到要删除的槽位 print(\'要删除的槽位是: %s\' %old_dic1.difference(new_dic1)) #A和B取交集，找到需要更新的槽位 print(\'要更新的槽位是: %s\' %old_dic1.intersection(new_dic1)) #B和A取差集，找到要插入的槽位 print(\'要增加的槽位为: %s\' %new_dic1.difference(old_dic1))
二. 函数
函数说白了就是一组代码集合，用于在程序中反复调用，解决代码重复编写的问题。两天的作业中，基本上都是堆积代码实现的，第二天的购物车程序更是码了近400行，根据作业需求逻辑从上到下一步一步码代码，一个打印功能就写了四处代码，而且一旦修改重复功能的话，所有的地方都要修改。这个是面向过程的编程方式。如果用到函数的话，代码首先变的很简洁，另外，review代码的人也比较容易看懂代码，毕竟程序不是一个人来编写的，即便是一个人编写的，过几天作者都有可能忘记自己写的代码段的功能了，所以函数式编程+良好的注释是一个很好的习惯和修养。
如下一个实例，验证用户登录身份，1：登录程序 2: 注册用户，如果用到面向过程编程的话，代码看起来是介样子的：
user_input_num = input(\'1. 登录程序 2.注册用户\').strip() if user_input_num == \'1\': user_input_name = input(\'请输入用户名:\').strip() user_input_pass = input(\'请输入密码:\').strip() with open(\'user.db\',\'r\') as f: for line in f: if user_input_name == line.strip().split()[0] and user_input_pass == line.strip().split()[1]: print(\'登录成功\') break else: print(\'登录失败,用户名或者密码错误\') if user_input_num == \'2\': user_input_name = input(\'请输入用户名:\').strip() user_input_pass = input(\'请输入密码:\').strip() with open(\'user.db\',\'r+\') as f: for line in f: if user_input_name == line.strip().split()[0]: print(\'用户名太抢手,已经被注册啦\') else: user_info = \'\n\' + user_input_name + \' \' + user_input_pass f.write(user_info) print(\'%s,恭喜你,注册成功\' %user_input_name)
而使用函数式编程是这样的：
def login(username,password): \'\'\' 用户登录程序 :param username:接受用户输入的用户名 :param password: 接受用户输入的密码 :return: True:表示认证成功,False:表示认证失败 \'\'\' #with open(\'user.db\',\'r\') as f: f = open(\'user.db\',\'r\') for line in f.readlines(): if line.strip().split()[0] == username and line.strip().split()[1] == password: return True else: return False def registry(user,passwd): \'\'\' 用户注册函数 :param user: 接受用户传入注册用的用户名 :param passwd: 接受用户传入的注册密码 :return: 如果用户不存在,并且写入用户名到文件成功后返回True,否则返回False \'\'\' with open(\'user.db\',\'r+\') as f: for line in f: if user == line.strip().split()[0]: return True else: info = \'\n\' + user + \' \' + passwd f.write(info) return False def main(): user_select = input(\'1:登录程序, 2:注册用户\').strip() if user_select == \'1\': username = input(\'请输入用户名:\').strip() password = input(\'请输入密码:\').strip() r = login(username,password) if r: print(\'登录成功\') else: print(\'登录失败,用户名或密码错误\') if user_select == \'2\': user_input_name = input(\'请输入用户名:\').strip() passwd_input = input(\'请输入密码:\').strip() R = registry(user_input_name,passwd_input) if R: print(\'用户名太抢手,已经被注册了!\') else: print(\'注册成功!\') if __name__ == \'__main__\': main()
好吧，这个例子不太明显，因为代码量少，看看我写的第二天的作业购物车程序例子吧:
#!/usr/bin/env python3 # -*- coding: utf-8 -*- # Author: DBQ(Du Baoqiang) \'\'\' Author: DBQ Blog: http://www.cnblogs.com/dubq/articles/5497639.html Github: https://github.com/daniel-vv/ops \'\'\' import time import sys import os import pickle import getpass def User_Input_salary(): \'\'\' 定义一个函数,用于接收用户输入工资金额 \'\'\' Flag = False while not Flag: User_salary = input(\'请输入您预消费的金额(元):\').strip() if User_salary.isdigit(): User_salary=int(User_salary) Flag = True if User_salary >= 200000: print(\'-\'*50) print(\'\033[34;1m卧槽,碉堡了,土豪,我们朋友吧~\033[0m\') print(\'-\'*50) else: print(\'抱歉,您输入的 \033[31;1m%s \033[0m不是一个合法的工资/金额\'%User_salary) return User_salary def Deny_user(username): \'\'\'定义一个写入用户信息到黑名单的函数,在后面的时候调用直接将锁定用户信息写入到锁文件中去\'\'\' with open(\'db/locked.db\',\'a+\') as f: print(\'\033[1;31m抱歉,用户 %s 输入次数太多, 已被锁定,请联系管理员解锁!\' %username) f.write(\'%s\n\' %username) #定义一个字典,用于下面验证用户身份,账户名密码通过key:value的形式存储在字典中 user_list = { \'tom\':\'123\', \'jerry\':\'123\', \'jack\':\'123\', } def username(): \'\'\' 定义一个函数,用于接收用户输入用户名密码的验证 如果用户名在锁定文件locked.db中,直接返回给用户已被锁定,退出程序 判断用户输入是否是同一用户输入三次错误尝试,如果是,则锁定用户,否则三次之后退出程序; \'\'\' Flag = False Count = 0 Lock_count = 1 user_name = \'\' while Count < 3: User_input_name = input(\'请输入您的用户名: \').strip() if User_input_name: User_input_name = str(User_input_name) User_input_pass = getpass.getpass(\'请输入您的密码: \').strip() with open(\'db/locked.db\',\'r\') as f: for i in f: if User_input_name == i.strip(): print(\'\033[31;1m您的用户已经被锁定,请联系管理员解锁!\033[0m\') exit(0) if User_input_name == user_name: Lock_count += 1 else: user_name = User_input_name Lock_count -= 1 for user,passwd in user_list.items(): if User_input_name == user and User_input_pass == passwd: #判断用户名和密码认证是否成功 print(\'\033[32;1m欢迎登陆 %s\033[0m\'.center(50,\'#\') %User_input_name) Flag = True break if Flag: break else: print(\'用户名或密码不正确,请重新输入\') #print(User_input_name) #print(User_input_pass) Count += 1 ##if User_input_name if Flag: break else: if Lock_count == 2: Deny_user(User_input_name) exit(0) #user_info.remove(User_input_name) #if len(data) != 0: #del user_info[User_input_name] #return User_input_name,user_info,User_salary #else: #return User_input_name return User_input_name ##定义商品列表 commodity_list = { \'家电类\':{ \'西门子冰箱\':4998, \'美的空调\':3912, \'微波炉\':1248, \'饮水机\':328, \'乐视 Max70\':9979, \'小米电视 \':4199, \'洗衣机\':3328, \'格力空调\':2889, \'MacBook Pro\':10899, \'高压力锅\':399, \'电磁炉\':198, \'净水器\':1999, \'滤水壶\':599, }, \'图书类\':{ \'小姨多鹤\':37.9, \'向着光明那方\':29.9, \'百年孤独\':39.9, \'了不起的盖茨比\':21.8, \'扶桑(严歌苓)\':32.8, \'陆犯焉识\':39.8, \'孩子你慢慢来\':25.8, \'鱼羊野史套装\':146.8, \'明朝那些事儿\':166.7, \'活着(余华作品)\':15.6, \'皮囊(蔡崇达)\':21.8, \'目送(龙应台)\':23.8, \'三体(国内最牛x科幻)\':188, \'失乐园\':33.0, }, \'衣服类\':{ \'棒球帽\':99, \'T恤\':199, \'皮带\':299, \'Adidas鞋\':899, \'Nike鞋\':899, \'Puma鞋\':768, \'皮鞋\':699, \'Lee牛仔裤\':409, \'内裤\':49, \'运动袜\':29, \'休闲西服上\':499, \'七分裤\':249, \'休闲家居服\':199, \'匡威双肩包\':269, \'仿古蛤蟆镜\':298, \'鞋垫\':38, }, \'手机类\':{ \'iPhone 6s 16G\':4987, \'iPhone 6s 64G\':5688, \'iPhone 6sP 16G\':6088, \'iPhone 6sP 64G\':6888, \'锤子坚果\':899, \'小米Max\':1999, \'Samsung S7\':5688, \'华为P9\':3688, \'魅族MX5\':1999, \'Nexus6\':3300, }, \'汽车类\':{ \'宝马 7\':1200000, \'宝马 5\':660000, \'宝马 3\':380000, \'Tesla ModelS\':790000, \'速腾\':160000, \'迈腾\':210000, \'甲壳虫\':250000, \'高尔夫\':180000, \'卡罗拉\':130000, \'迈锐宝\':150000, \'凯美瑞\':210000, }, \'烟酒类\':{ \'玉溪\':22, \'中华\':45, \'利群\':14, \'南京\':13, \'芙蓉王\':19, \'白沙\':10, \'苁蓉\':13, \'云烟\':11, \'长白山\':11, \'老白汾\':398, \'白玉汾酒\':198, \'玫瑰汾酒\':298, \'五粮液\':499, \'衡水老白干\':198, \'茅台\':399, \'梦之蓝\':398, \'郎酒\':398, \'天之蓝\':298, }, } user_shopping_db = \'db/user_shopping.db\' shopp_car = \'{0} {1} {2} {3} {4}\' #user_file = open(user_shopping_db,\'rb\') data = open(user_shopping_db,\'rb\').read() if len(data) != 0: user_data = len(pickle.load(open(user_shopping_db,\'rb\'))) user_info = pickle.load(open(user_shopping_db,\'rb\')) else: user_data = 0 user_shopping = {} #定义一个空字典,用于存储用户的购物车信息 Flag = False #定义标志位,用于进入循环 User_flag = False #定义一个用户标志位,用于判断用户是否有认证,防止后面循环会要求用户反复认证 while not Flag: #进入循环主题 if not User_flag: #根据定义用户标志位来判断 user = username() #将上面定义函数实例化,并赋值给user变量 if user_data != 0: #判断变量非空进入下面验证,取出用户上一次登录程序 for i in user_info.keys(): if user == i: id = 1 for k,v in user_info.items(): if user == k: #shopp_car = \'{0} {1} {2} {3} {4}\' print(\'\033[32;1m欢迎您, %s, 您上一次的余额为 %s\033[0m\'%(k,user_info[user][\'salary\'])) print(\'购物车的内容如下\'.center(70,\'-\')) print(\'\033[34;1m序列 宝贝名 数量 小计 购买时间\033[0m\') #先打印title User_salary = user_info[user][\'salary\'] del user_info[user][\'salary\'] for k1,v1 in user_info[user].items(): if user != k1: print(shopp_car.format(id,k1,v1[0],v1[1],v1[2],)) id +=1 #continue else: print(\'-\'*70) #if input(\'按下任意键继续...\'):pass #del user_info[user] user_shopping = user_info else: User_salary = User_Input_salary() pass else: User_salary = User_Input_salary() #实例化用户输入消费金额函数并复制给变量 print(\'~Bingo, 欢迎 [ %s ] 来到 DBQ 的百货店,请选择您需要的宝贝以及数量,祝您购物愉快~\'.center(70,\'#\')%user) for id,keys in enumerate(commodity_list.keys()): #进入三级菜单 print(id,keys) User_id = input(\'\033[33;1m请选择您感兴趣的分类 Q/q(退出程序) C/c(检查购物车)\033[0m\').strip() if User_id == \'q\' or User_id == \'Q\': #判断是Q/q,退出程序 print(\'欢迎下次再来 [ %s ], bye!\'%user) Flag = True break if User_id == \'c\' or User_id == \'C\': #如果是c/C,检查用户购物车,如果购物车为空,提示用户为空 if len(user_shopping) != 0: #判断如果用户购物车不为空是显示购物车信息 print(\'购物车\'.center(70)) print(\'-\'*70) print(\'\033[34;1m序列 宝贝名 数量 小计 购买时间\033[0m\') #先打印title product_index = 1 #定义一个序列ID user_consume = 0 #定义一个值为0的用户消费金额初始值,用于下面累加用户此次消费总金额 #print(user_shopping) for value in user_shopping[user].keys(): #print(value) #print(shopp_car.format(product_index,index,value[1][0],value[0][1],value[0][2],)) print(shopp_car.format(product_index,value,user_shopping[user][value][0],user_shopping[user][value][1],user_shopping[user][value][2],)) user_consume += user_shopping[user][value][1] #自增用户消费金额 product_index += 1 #序列ID自增 print(\'-\'*70) print(\'\033[34;1m亲爱的用户[ %s ], 共消费 [ %s ]元, 您的余额 [ %s ]元\033[0m\'%(user,user_consume,User_salary)) if input(\'\033[31;1m 按下任意键继续...\033[0m\'):pass else: #如果购物车为空,提示用户购物车为空,并返回商品列表 print(\'-\'*50) print(\'抱歉,你还未购买任何宝贝,购物车里空到不行不行的~\') print(\'-\'*50) if User_id.isdigit() and int(User_id) < len(commodity_list.keys()): product = list(commodity_list.keys())[int(User_id)] #将字典转换为有序列表 while not Flag: for id2,key2 in enumerate(commodity_list[product].items()): #进入商品明细,供用户选择序号购买 print(id2,key2) print(\'#\'*70) User_id2 = input(\'\033[33;1m请选择您需要的宝贝序列添加到购物车: Q/q(退出程序) B/b(返回) C/c(检查购物车)\033[0m\'.center(30,\'#\')).strip() if User_id2.isdigit() and int(User_id2) < len(commodity_list[product]): #print(commodity_list[product][int(User_id2)]) product1 = list(commodity_list[product].keys())[int(User_id2)] price = int(commodity_list[product][product1]) print(\'您已经选择了宝贝\033[32;1m %s \033[0m, 宝贝价格(元):\033[32;1m %s \033[0m\'%(product1,price)) product_num = input(\'请输入你欲购买的宝贝\033[32;1m %s \033[0m数量:\'%product1).strip() if product_num.isdigit() and product_num and int(product_num) != 0: product_num = int(product_num) price *= product_num if price <= User_salary: User_salary -= price product_time = time.strftime(\'%Y-%m-%d %H:%M:%S\',time.localtime()) #返回当前购买时间给一个变量 #if product1 not in user_shopping.get(user): #判断如果用户购买的商品不在购物车中直接setdefault值为新商品信息 if not user_shopping.get(user): #user_shopping[user]= #user_shopping[user] = [{product1,[product_num,price,product_time,]}] user_shopping[user] = {product1:[product_num,price,product_time,]} else: #如果存在购物车中,更新现有信息 #print(user_shopping[user][product1][0][0]) user_shopping[user].setdefault(product1,[product_num,price,product_time,]) print(user_shopping) product_num += user_shopping[user][product1][0] #累加商品数量 print(user_shopping[user][product1][0]) price += user_shopping[user][product1][1] #累加商品金额 user_shopping[user][product1][0] = product_num #重新修改购物车中的值 user_shopping[user][product1][1] = price user_shopping[user][product1][2] = product_time #user_shopping[product_id] = [product1,product_num,price,product_time] #打印购买成功信息,包括用户购买商品\金额以及余额 print(\'恭喜你,成功购买宝贝\033[32;1m %s \033[0m数量\033[32;1m %s \033[0m,\' \ \'此次消费\033[32;1m %s (元) \033[0m, 余额:\033[32;1m %s \033[0m\' \ %(product1,product_num,price,User_salary)) print(\'#\'*70) continue else: #输入用户余额不足,提示用户充值 pay = input(\'\033[31;1m抱歉,您的余额[ %s ],宝贝价格[ %s ],余额不足,不能购买此宝贝,是否充值? (y/Y)\033[0m\'%(User_salary,price)).strip() if pay and pay == \'y\' or pay == \'Y\': #输入y/Y为确认充值 pay_money = input(\'请输入要充值的金额:\').strip() #充值金额 if pay_money.isdigit() and int(pay_money) != 0: #如果是数字而且充值金额不能为0 User_salary += int(pay_money) #用户余额+=新充值金额,并赋值给余额变量 time.sleep(1) print(\'-\'*50) print(\'充值成功,账户最新余额:\033[31;1m [ %s ] 元\033[0m\'%User_salary) #打印充值成功 if User_salary >= 200000: #如果用户充值金额大于等于20W,绝对是土豪身份 print(\'\033[34;1m卧槽,碉堡了,土豪,我们朋友吧~\033[0m\') print(\'-\'*50) if input(\'按下任意键继续...\'):pass continue else: #如果输入一个非y/Y值,提示用户没有选择充值,而后进入商品详单列表 print(\'抱歉,您没有选择充值\') continue else: #print(\'\033[31;1m输入数量不可用!\033[0m\') if input(\'\033[31;1m抱歉,您输入数量的不可用!按下任意键继续...\033[0m\'):pass continue if User_id2 == \'q\' or User_id2 == \'Q\': #输入Q/q,退出程式 #user_shopping[user].setdefault(user,User_salary) #退出之前将用户名和用于余额信息写入字典用于下一次登录判断 user_shopping[user].setdefault(\'salary\',User_salary) with open(user_shopping_db,\'wb\') as f: #f.write(str(user_shopping.items())) pickle.dump(user_shopping,f) print(\'欢迎下次再来 [ %s ], bye!\'%user) time.sleep(1) Flag = True break if User_id2 == \'c\' or User_id2 == \'C\': #允许用户输入c/C查看购物车信息 print(\'购物车\'.center(70)) print(\'-\'*70) print(\'\033[34;1m序列 宝贝名 数量 小计 购买时间\033[0m\') #先打印title product_index = 1 #定义一个序列ID user_consume = 0 #定义一个值为0的用户消费金额初始值,用于下面累加用户此次消费总金额 #print(user_shopping) for value in user_shopping[user].keys(): #print(value) #print(shopp_car.format(product_index,index,value[1][0],value[0][1],value[0][2],)) print(shopp_car.format(product_index,value,user_shopping[user][value][0],user_shopping[user][value][1],user_shopping[user][value][2],)) user_consume += user_shopping[user][value][1] #自增用户消费金额 product_index += 1 #序列ID自增 print(\'-\'*70) print(\'\033[34;1m亲爱的用户[ %s ], 共消费 [ %s ]元, 您的余额 [ %s ]元\033[0m\'%(user,user_consume,User_salary)) if input(\'\033[32;1m 按下任意键继续...\033[0m\'):pass if User_id2 == \'b\' or User_id2 == \'B\': #输入b/B,返回上一级 User_flag = True break else: #print(\'\033[31;1m您输入的宝贝序列不可用!!!\033[0m\') continue #pass #print(product1) #print(price) else: if not User_id: print(\'\033[31;1m您输入的宝贝序列不可用!!!\033[0m\') User_flag = True continue else: User_flag = True
如果要修改一个功能非常费劲，可如果用到函数式编程的话，代码可读性等等一大堆好处就来了
还没时间重写啦
1.函数的组成：
def f1(a,b): pass return # def 定义函数的关键字 # f1 函数名，可以是任何字符串合法的字符，但不能是Python内部保留字 # a,b 参数，主要为函数体提供数据 # () 固定搭配 # pass 函数体 # return 返回值，默认情况下如果不显式指定return值的话，Python会返回为None，这和其他语言不太一样；
2.返回值
定义了一个函数，在程序里引用，所以函数应该将执行的结果返回一个参数，好让调用者继续执行下面的逻辑。还是那个登陆程序的例子，可以用汉字写出来看看：
def 登陆函数(等待用户传入用户名,密码): pass 打开文件,赋值给一个变量,并且循环遍历文件内容 if 如果用户名和文件中的用户名匹配,并且提供的密码和文件中的密码匹配 #打印登陆成功 return True 返回一个True 如果验证失败 return False def 主函数(): 用户输入序列,选择是登陆还是注册用户 如果是登陆 提示用户输入用户名\密码 R = 调用上面登陆函数(用户输入用户名,密码) 调用登陆函数, 并将结果复制给变量R if R为True 打印登陆成功 else 否则 打印用户名密码验证失败: ...
主函数()
3. 参数
函数参数的作用有多大，不用多言了吧，总之太重要了。如果没有参数的话，函数将会变的很不灵活
函数中有几种不同的参数:
1. 普通参数
#定义一个函数f1，接受用户传入参数name，而后在函数体内打印用户输入的值。name叫做形式参数 >>> def f1(name): ... print(name) ... #调用函数，并传入一个值，这里的值daniel叫做实际参数； >>> f1(\'daniel\') daniel
2. 默认参数
#定义一个函数f2，接受用户输入两个形式参数，并给形式参数指定一个默认值 >>> def f2(name,job=\'devops\'): ... print(name,job) ... #调用函数，并使用默认参数，‘devops’ >>> f2(\'daniel\') daniel devops
3. 指定参数
#定义一个函数f3，接受用户输入两个形参，并给定age一个默认参数为18 >>> def f3(name,age=18): ... print(\'Name: %s, Age: %s\'%(name,age)) ... #调用参数，明确指定一个age参数为17 >>> f3(\'daniel\',17) Name: daniel, Age: 17
4. 动态参数
动态参数有两种，一种是一个*，一种是 **
* 默认接受N个参数，并将用户传入的实际参数放到元组里面,默认情况下都用 *args表示形参
#定义一个函数f4, 接受形参*args >>> def f4(*args): ... print(args) ... print(type(args)) ... print(*args) ... print(type(*args)) ... #定义一个列表l1 >>> l1=[1,2,3,4,5,] #调用函数，将l1赋值给函数 >>> f4(l1) ([1, 2, 3, 4, 5],) #默认方式是将一个列表当做整体元素包含在元组内 <class \'tuple\'> [1, 2, 3, 4, 5] #在函数体内打印*args是转换成原有的数据类型 <class \'list\'> #再定义一个t1的元组，一个name的字符串，一个t2的字典 >>> t1=(5,4,3,2,1,) >>> name=(\'daniel\') >>> t2 = {\'k1\':\'v1\',\'k2\':\'v2\'} #重新定义函数 >>> def f4(*args): ... print(args) ... print(type(args)) ... print(*args) ... #调用函数，并把字典、列表、元组、字符串都复制进去，看看变化 >>> f4(l1,t1,name,t2) #默认函数体里打印args，是把添加的任意个元组当成元组内的一个元素 ([1, 2, 3, 4, 5], (5, 4, 3, 2, 1), \'daniel\', {\'k2\': \'v2\', \'k1\': \'v1\'}) <class \'tuple\'> #在函数体内打印*args，是将用户传入的实体参数还原为本来的数据类型，即字符串就是字符串，而字典还是字典... [1, 2, 3, 4, 5] (5, 4, 3, 2, 1) daniel {\'k2\': \'v2\', \'k1\': \'v1\'} #还有一个玩法，可以在调用函数传入实体参数的时候，在前面加* >>> f4(*l1,*t1,*name,*t2) #这个玩法，在默认函数体内打印传入形参值，会是遍历传入的参数，而后赋值给元组内 (1, 2, 3, 4, 5, 5, 4, 3, 2, 1, \'d\', \'a\', \'n\', \'i\', \'e\', \'l\', \'k2\', \'k1\') <class \'tuple\'> #而*args是会还原原有的数据类型，去掉元组，个人感觉没卵用； 1 2 3 4 5 5 4 3 2 1 d a n i e l k2 k1
** 传值的时候必须指定一个key和value，默认是字典类型；默认使用 **kwargs表示形参
#定义函数f5，接受用户传入形参**kwargs def f5(**kwargs): print(kwargs) print(type(kwargs)) #调用函数时，第一种赋值方式 f5(Name=\'daniel\',Age=18,Job=\'IT\') {\'Name\': \'daniel\', \'Job\': \'IT\', \'Age\': 18} <class \'dict\'> #定义一个字典t1 t1 = {\'Name\':\'daniel\',\'Age\':18,\'Job\':\'IT\'} #调用函数第二种赋值方式，实在实参前面加** f5(**t1) {\'Age\': 18, \'Name\': \'daniel\', \'Job\': \'IT\'} <class \'dict\'>
5. 万能参数
直白来说，就是两种动态参数的组合，需要注意的是两种动态参数组合使用时，*必须放在第一个位置，否则会报错
#定义函数f6，接受形参*args，**kwargs，在函数体内打印两个值，和数据类型 def f6(*args,**kwargs): print(args,kwargs) print(type(args)) print(type(kwargs)) #调用函数，前面是*，后面是** f6(\'我是谁?\',\'几年几岁?\',\'做什么工作?\',Name=\'Daniel\',Age=18,Job=\'IT\') (\'我是谁?\', \'几年几岁?\', \'做什么工作?\') {\'Age\': 18, \'Name\': \'Daniel\', \'Job\': \'IT\'} <class \'tuple\'> <class \'dict\'> #也可以这么玩： t1 = {\'Name\':\'daniel\',\'Age\':18,\'Job\':\'IT\'} f6(\'我是谁?\',\'几年几岁?\',\'做什么工作?\',**t1) (\'我是谁?\', \'几年几岁?\', \'做什么工作?\') {\'Name\': \'daniel\', \'Age\': 18, \'Job\': \'IT\'} <class \'tuple\'> <class \'dict\'> #尝试下把**放在前面: t1 = {\'Name\':\'daniel\',\'Age\':18,\'Job\':\'IT\'} f6(**t1,\'我是谁?\',\'几年几岁?\',\'做什么工作?\') f6(**t1,\'我是谁?\',\'几年几岁?\',\'做什么工作?\') ^ SyntaxError: positional argument follows keyword argument unpacking #直接报语法错误: #在函数体内把**kwargs放在前面试下： def f6(**kwargs,*args): print(args,kwargs) print(type(args)) print(type(kwargs)) #执行还是报错语法错误 def f6(**kwargs,*args): ^ SyntaxError: invalid syntax
三. Python内嵌函数
内置函数主要是使用比较频繁的或者是元操作，所以Python通过内置函数的方式提供
四. 文件操作
在Python3里提供了open函数来对文件操作，Python2中有file函数 。
1. open()函数语法
使用open函数的语法：
file object = open(file_name [, access_mode][, buffering])
file object： 文件句柄，在后面通过此句柄对该文件操作等等；
file_name: 文件名称，如果不在当前目录下，需要制定绝对/相对路径
access_mode： 打开模式，表示允许对文件操作的权限等
buffering：如果值为0，就不会有寄存。如果为1，访问文件时会寄存。如果值设定大于1的整数，说明这就是寄存区的大小。如果取负值，寄存区的缓冲大小则为系统默认。
2. 打开文件模式:
- r 以只读方式打开文件，文件指针将会放在文件开头的位置，这也是默认的模式；
-
r 只读模式
#以只读模式打开文件，赋值给文件句柄f >>> f = open(\'test.txt\',\'r\') # 写入数据尝试，报错，是只读的，不允许写！ >>> f.write(\'abc\') Traceback (most recent call last): File "<stdin>", line 1, in <module> io.UnsupportedOperation: not writable # 查看文件指针位置，可以看到在文件开头的位置； >>> f.tell() 0 # 读取文件内容 >>> f.readline() \'abc\n\'
- w 以只写入的方式打开文件，如果文件存在内容，会清空文件后，再打开，文件指针在开头的位置。如果文件不存在，则创建新文件；
-
w 只写模式
#至写入模式 >>> f = open(\'test.txt\',\'w\') #查看文件指针，在文件首部 >>> f.tell() 0 #不允许读 >>> f.read() Traceback (most recent call last): File "<stdin>", line 1, in <module> io.UnsupportedOperation: not readable #写入文件1，2，3，会覆盖之前文件里的abc内容，并返回当前的文件指针位置 >>> f.write(\'1,2,3\') 5 #验证下文件指针位置 >>> f.tell() 5 #结束后一定不要忘记关闭文件 >>> f.close()
- a 打开文件以追加的模式，如果该文件存在，文件指针会放到文件末尾的位置，也就是说新的内容会将被写入到文件的末尾。如果文件不存在，创建新文件来写入。
-
a 追加模式
# 追加方式 >>> f = open(\'test.txt\',\'a\') # 文件指针在文件末尾的位置，即旧内容后面 >>> f.tell() 5 #读文件报错 >>> f.read() Traceback (most recent call last): File "<stdin>", line 1, in <module> io.UnsupportedOperation: not readable # 写入文件后，返回写入内容后指针后移的位置，并非实际指针位置 >>> f.write(\'abc\') 3 # 查看文件指针，还是在文件最尾部 >>> f.tell() 8 # 关闭文件 >>> f.close()
- x Python3里新添加的模式，以只写入的方式打开文件，文件内容如果存在会报错，否则则创建新文件。一般建议，写入时使用x而不用w；
-
x 只写模式
# 先查看下文件test.txt里的内容 >>> f = open(\'test.txt\',\'r\') >>> f.read() \'1,2,3abc\' >>> f.close() # 以x模式打开文件，直接报错文件存在，错误代码17 >>> f = open(\'test.txt\',\'x\') Traceback (most recent call last): File "<stdin>", line 1, in <module> FileExistsError: [Errno 17] File exists: \'test.txt\' # 重新打开一个不存在的文件： >>> f = open(\'test1.txt\',\'x\') #指针模式在文件首部 >>> f.tell() 0 # 写入5个字符，文件指针在5的位置 >>> f.write(\'abcde\') 5 # 返回指针位置 >>> f.tell() 5 # 在写入内容123，返回指针移动位置 >>> f.write(\'123\') 3 # 返回指针位置，8 >>> f.tell() 8 # 一定不要忘记关闭文件句柄 >>> f.close()
上面的这些模式都是要么只读、要么只写入，如果添加一个 “+”，就表示可以同时读写了：
- r+ 读写模式打开文件，文件指针会在开头的位置；
-
r+ 读写模式
#读写模式 >>> f = open(\'test1.txt\',\'r+\') # 默认文件指针在文件首部 >>> f.tell() 0 # 读取文件内容 >>> f.read() \'abcde123\' #文件指针跑到文件尾部去了 >>> f.tell() 8 # 写入，就成了尾部追加了 >>> f.write(\'新增加\') 3 # 一个汉字三个三个指针 >>> f.tell() 17 # 再读取，已经空了，因为文件指针已经走到最后面了 >>> f.read() \'\' # 用seek将指针调整到文件头部 >>> f.seek(0) 0 # 在读取 >>> f.read() \'abcde123新增加\' >>> f.close()
- w+ 写读模式打开文件，如果文件里有内容，就会覆盖，否则的话，会创建新文件，使用场景还是不多；
-
w+ 写读模式
#W+模式 >>> f = open(\'test1.txt\',\'w+\') # 默认文件句柄在文件首部 >>> f.tell() 0 # 写入文件 >>> f.write(\'w+模式\') 4 #获取指针位置 >>> f.tell() 8 #后面已经无内容了，所以为空 >>> f.read() \'\' # 重置文件指针到首部 >>> f.seek(0) 0 # 读取文件内容，看到源文件内容已经被清空了 >>> f.read() \'w+模式\' >>> f.close()
- a+ 写读模式打开文件，如果存在，文件指针会放在文件的结尾。文件打开时会是追加模式，如果不存在会创建新的文件；
-
a+ 写读模式
# a+模式 >>> f = open(\'test1.txt\',\'a+\') # 默认文件指针在文件尾部 >>> f.tell() 8 # 所以读取为空 >>> f.read() \'\' # 写入a+模式内容 >>> f.write(\'a+模式内容\') 6 # 返回指针位置 >>> f.tell() 22 # 将指针重置到开始位置 >>> f.seek(0) 0 # 读取，可以看到上一步w+的内容还在 >>> f.read() \'w+模式a+模式内容\' >>> f.close()
- x+ 写读模式打开文件，
-
x+写读模式
# x+模式，如果文件存在就会报错文件已经存在 >>> f = open(\'test1.txt\',\'x+\') Traceback (most recent call last): File "<stdin>", line 1, in <module> FileExistsError: [Errno 17] File exists: \'test1.txt\' #打开一个不存在的文件 >>> f = open(\'test2.txt\',\'x+\') #模式文件指针在文件首部 >>> f.tell() 0 # 写入文件内容 >>> f.write(\'x+模式\') 4 #返回文件指针 >>> f.tell() 8 #在写入 >>> f.write(\'balabala\') 8 #读取为空，文件指针在尾部 >>> f.read() \'\' #重置指针 >>> f.seek(0) 0 >>> f.read() \'x+模式balabala\' #关闭文件 >>> f.close()
以"b"表示以二进制的方式操作，需要注意的是以"b"方式打开文件是字节类型，写入时也需要提供自己类型，反之一样。
- rb 二进制读模式打开文件，文件指针会放在文件的开头。
-
rb 二进只读模式
#先用wb模式写入一个二进制文件 >>> f = open(\'test2.txt\',\'wb\') #定义一个中文字符串 >>> s1 = \'我是谁?\' #写入时，使用utf-8编码 >>> f.write(s1.encode(\'utf-8\')) 10 >>> f.tell() 10 #关闭文件 >>> f.close() #用rb模式打开一个文件 >>> f = open(\'test2.txt\',\'rb\') #试着用默认编码读取，看到是b(二进制格式) >>> f.read() b\'\xe6\x88\x91\xe6\x98\xaf\xe8\xb0\x81?\' >>> f.tell() 10 #重置指针到文件首部 >>> f.seek(0) 0 # 将f.read() 复制给一个变量 >>> r = f.read() # 而后使用decode将字符编码使用utf-8 >>> print(r.decode(\'utf-8\')) 我是谁? >>> f.close()
- rb+ 二进制只读模式打开文件，文件指针会放在文件的开头。
-
rb+ 读写二进制模式
# rb+模式 >>> f = open(\'test2.txt\',\'rb+\') >>> s = \'巴拉巴阿\' # 文件指针在文件首部 >>> f.tell() 0 #写入内容，并使用utf-8编码 >>> f.write(s.encode(\'utf-8\')) 12 # 返回文件指针 >>> f.tell() 12 # 重置指针 >>> f.seek(0) 0 >>> s = f.read() # 使用decode utf-8 编码读取文件 >>> print(s.decode(\'utf-8\')) 巴拉巴阿 >>> f.tell() 12 >>> f.seek(0) 0 # 直接读取显示无法显示 >>> f.read() b\'\xe5\xb7\xb4\xe6\x8b\x89\xe5\xb7\xb4\xe9\x98\xbf\'
- wb 二进制的只写模式打开文件，如果文件存在会清空文件，否则创建新文件。
-
wb 二进只写模式
#用wb模式写入一个二进制文件 >>> f = open(\'test2.txt\',\'wb\') #文件指针默认在文件首部，会清空原有文件 >>> f.tell() 0 #定义一个中文字符串 >>> s1 = \'我是谁?\' #写入时，使用utf-8编码 >>> f.write(s1.encode(\'utf-8\')) 10 >>> f.tell() 10 #关闭文件 >>> f.close()
- wb+ 二进制写读模式，如果文件存在会覆盖文件，否则会创建新文件。
-
wb+ 二进制写读模式
# wb+模式还是会清空文件 >>> f = open(\'test2.txt\',\'wb+\') # 默认文件指针位置在首部 >>> f.tell() 0 >>> s = f.read() >>> print(s.decode(\'utf-8\')) >>> s1 = \'这模式怎么又清空文件啦？\' >>> f.write(s1.encode(\'utf-8\')) 36 >>> f.tell() 36 >>> f.seek(0) 0 >>> s = f.read() >>> print(s.decode(\'utf-8\')) 这模式怎么又清空文件啦？ >>> f.close()
- xb 二进制只写，如果文件存在报错？否则创建新文件?
-
xb 二进制只写模式
# 文件存在还是会报错 >>> f = open(\'test2.txt\',\'xb\') Traceback (most recent call last): File "<stdin>", line 1, in <module> FileExistsError: [Errno 17] File exists: \'test2.txt\' # 如果不存在的话，操作和wb一样 >>> f = open(\'test2.txt\',\'xb\') Traceback (most recent call last): File "<stdin>", line 1, in <module> FileExistsError: [Errno 17] File exists: \'test2.txt\' >>> f = open(\'test3.txt\',\'xb\') >>> s = \'这是xb二进制只写入模式，是python3新增\' >>> f.tell() 0 >>> f.write(s.encode(\'utf-8\')) 51 >>> f.tell() 51 >>> f.seek(0) 0 # 不允许读取 >>> f.read() Traceback (most recent call last): File "<stdin>", line 1, in <module> io.UnsupportedOperation: read >>> f.close()
- xb+ 二进制写读模式打开文件，如果存在覆盖，否则创建新文件。
-
xb+ 二进制写读模式
# 如果存在文件，会报错 >>> f = open(\'test3.txt\',\'xb+\') Traceback (most recent call last): File "<stdin>", line 1, in <module> FileExistsError: [Errno 17] File exists: \'test3.txt\' >>> f = open(\'test4.txt\',\'xb+\') >>> f.tell() 0 >>> s = \'这是xb+二进制写读模式，是python3新增特性\' # 可写入 >>> f.write(s.encode(\'utf-8\')) 55 # 也可读写 >>> s1 = f.read() >>> print(s1.decode(\'utf-8\')) 这是xb+二进制写读模式，是python3新增特性 >>> f.close()
- ab 二进制追加模式打开文件，如果存在文件，文件指针在末尾，文件打开时会是追加模式，新内容在旧内容之后，如果文件不存在，创建新文件来写入。
-
ab 二进制只写模式
# ab，二进制只写模式 >>> f = open(\'test4.txt\',\'ab\') # 默认文件指针在文件尾部 >>> f.tell() 55 # 不允许读 >>> f.read() Traceback (most recent call last): File "<stdin>", line 1, in <module> io.UnsupportedOperation: read >>> s = \'\n这是ab模式输入的内容\' # 在文件尾部添加内容 >>> f.write(s.encode(\'utf-8\')) 30 # 关闭文件 >>> f.close()
- ab+ 二进制写读模式打开，如果存在文件，文件指针在末尾，如果不存在，创建新文件。
-
ab+ 二进制写读模式
>>> f = open(\'test4.txt\',\'ab+\') >>> f.tell() 85 >>> s = \'\n这是ab+添加的内容\' >>> f.write(s.encode(\'utf-8\')) 25 >>> f.tell() 110 >>> f.seek(0) 0 #也可以使用for循环逐行读取，并复制给s，而后使用decode进行解码 >>> for line in f: ... s = line ... print(s) ... b\'\xe8\xbf\x99\xe6\x98\xafxb+\xe4\xba\x8c\xe8\xbf\x9b\xe5\x88\xb6\xe5\x86\x99\xe8\xaf\xbb\xe6\xa8\xa1\xe5\xbc\x8f\xef\xbc\x8c\xe6\x98\xafpython3\xe6\x96\xb0\xe5\xa2\x9e\xe7\x89\xb9\xe6\x80\xa7\n\' b\'\xe8\xbf\x99\xe6\x98\xafab\xe6\xa8\xa1\xe5\xbc\x8f\xe8\xbe\x93\xe5\x85\xa5\xe7\x9a\x84\xe5\x86\x85\xe5\xae\xb9\n\' b\'\xe8\xbf\x99\xe6\x98\xafab+\xe6\xb7\xbb\xe5\x8a\xa0\xe7\x9a\x84\xe5\x86\x85\xe5\xae\xb9\' >>> f.seek(0) 0 >>> for line in f: ... s = line ... print(line.decode(\'utf-8\').strip()) ... 这是xb+二进制写读模式，是python3新增特性 这是ab模式输入的内容 这是ab+添加的内容
3. 操作方法
还记得上面的每次打开文件后都需要close()吧，一个文件被打开后，可以使用方法来查看各种文件的信息
closed 如果返回为True表示文件已关闭，否则为False
>>> f.closed False >>> f.close() >>> f.closed True
mode 查看文件打开的模式
>>> f = open(\'test4.txt\',\'ab+\') >>> f.mode \'ab+\'
name 文件名
>>> f.name \'test4.txt\'
raw 查看文件句柄详细信息
>>> f.raw <_io.FileIO name=\'test4.txt\' mode=\'ab+\'>
encoding 查看编码
>>> f.encoding \'UTF-8\'
close 关闭文件句柄
>>> f.close()
read 读取指定字节数据，如果不指定值，则返回整个文件内容
>>> f.read() \'1,2,3abc\' >>> f.read(3) \'1,2\'
readline 仅读取一行数据，可以指定读取的字节数
# 文件内容三行 >>> f.read() \'1,2,3abc\nABC\nDEF\' >>> f.seek(0) 0 # 一次只读取一行内容 >>> f.readline() \'1,2,3abc\n\' >>> f.tell() 9 >>> f.seek(0) 0 # 可以指定读取的字节数 >>> f.readline(3) \'1,2\'
readlines 读取所有数据，并根据换行符保存内容至列表
>>> f.seek(0) 0 # 全部放在列表中 >>> f.readlines() [\'1,2,3abc\n\', \'ABC\n\', \'DEF\'] >>> f.seek(0) 0 #对列表可做进一步操作 >>> f.readlines()[0] \'1,2,3abc\n\'
readable 文件是否可读，可读返回True，否则返回False
>>> f = open(\'test.txt\',\'r+\') >>> f.readable() True >>> f.close() >>> f = open(\'test.txt\',\'a\') >>> f.readable() False
write 写内容（字符串）
>>> f.write(\'balbalbalallla\') 14 >>> f.seek(0) 0 >>> f.read() \'1,2,3abc\nABC\nDEFbalbalbalallla\'
writelines 写内容，(列表)
#写入字符串，也OK >>> f.writelines(\'这是啥我也不知道\') >>> f.tell() 54 >>> f.read() \'\' >>> f.seek(0) 0 >>> f.read() \'1,2,3abc\nABC\nDEFbalbalbalallla这是啥我也不知道\' # write写字符串也ok >>> s1 = \'daniel\' >>> f.write(s1) 6 >>> f.writelines(s1) >>> f.seek(0) 0 >>> f.read() \'1,2,3abc\nABC\nDEFbalbalbalallla这是啥我也不知道danieldaniel\' #来试下列表 >>> l1 = [\'i\',\'am\',\'is\',\'supperman\'] # write失败 >>> f.write(l1) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: must be str, not list # writelines没问题 >>> f.writelines(l1) >>> f.seek(0) 0 >>> f.readlines() [\'1,2,3abc\n\', \'ABC\n\', \'DEFbalbalbalallla这是啥我也不知道danieldanieliamissupperman\'] >>> f.seek(0) 0 >>> f.read() \'1,2,3abc\nABC\nDEFbalbalbalallla这是啥我也不知道danieldanieliamissupperman\' #来试下元组 >>> t1 = (\'a\',\'b\',\'c\',\'d\') >>> f.write(t1) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: must be str, not tuple # writelines 是ok的 >>> f.writelines(t1) >>> f.seek(0) 0 >>> f.read() \'1,2,3abc\nABC\nDEFbalbalbalallla这是啥我也不知道danieldanieliamissuppermanabcd\' #测试下字典 >>> d1 = {\'k1\':\'v1\',\'k2\':\'v2\'} >>> f.write(d1) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: must be str, not dict # writelines 还是ok的 >>> f.writelines(d1) >>> f.seek(0) 0 >>> f.read() \'1,2,3abc\nABC\nDEFbalbalbalallla这是啥我也不知道danieldanieliamissuppermanabcdk1k2\'
writable 是否可写，可写返回True，否则返回False
>>> f.writable()
True
tell 返回当前指针位置
>>> f.tell()
0
seek 移动指针位置
>>> f.read() \'1,2,3abc\nABC\nDEF\' >>> f.seek(3) 3 >>> f.read() \',3abc\nABC\nDEF\'
seekable 指针是否可读,是： True， 否：False, Python3新增
>>> f.seekable()
True
fileno 返回一个文件的文件描述符，可以用在os模块的read方法等一些底层的操作
>>> f.fileno()
3
isatty 判断文件是否连接在一个终端设备，是：true，否：False
>>> f.isatty()
False
truncate 截断文件，截取的字节通过参数提供，默认为当前指针位置
>>> f.tell() 0 #看下所有文件内容 >>> f.read() \'1,2,3abc\nABC\nDEFbalbalbalallla这是啥我也不知道danieldanieliamissuppermanabcdk1k2\' #再把指针指向开始位置 >>> f.seek(0) 0 # 截取三个字符 >>> f.truncate(3) 3 #查看文件指针 >>> f.tell() 0 # 查看文件 >>> f.read() \'1,2\' >>> f.read() \'\' >>> f.seek(0) 0 >>> f.read() \'1,2\' >>> f.seek(0) 0 #如果不提供参数，从当前默认的指针位置开始截取，当前为开始位置，所以清空文件内容 >>> f.truncate() 0 >>> f.read() \'\' >>> f.seek(0) 0 >>> f.read()
flush 刷写文件内部缓存，直接把缓冲区的数据立即写入文件，而不是被动的等待缓冲区写入。
>>> f.flush()
buffer = property(lambda self: object(), lambda self, v: None, lambda self: None) # default closed = property(lambda self: object(), lambda self, v: None, lambda self: None) # default encoding = property(lambda self: object(), lambda self, v: None, lambda self: None) # default errors = property(lambda self: object(), lambda self, v: None, lambda self: None) # default line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None) # default name = property(lambda self: object(), lambda self, v: None, lambda self: None) # default newlines = property(lambda self: object(), lambda self, v: None, lambda self: None) # default _CHUNK_SIZE = property(lambda self: object(), lambda self, v: None, lambda self: None) # default _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
4. 管理上下文
上面的文件操作，打开操作完成之后每次都需要关闭文件，为了避免忘记，可以通过(with)管理上下文：
with open(\'test.txt\',\'r+\') as f: #打开test.txt文件以r+模式，并别名为f，操作完成后内部会自动关闭并释放文件资源 pass
另外在python2.7以后，with也支持同事打开两个文件来操作：
with open(\'test.txt\',\'r\') as f1, open(\'test2.txt\',\'w\') as f2: pass
五. 三元运算
三元运算又叫三目运算，主要是一些简单if else语句的缩写；先写判断条件 而后进入判断 最后条件不满足的操作：
>>> a = 1 >>> print(\'这是条件为真打印的结果\') if a == 1 else \'这是条件为假打印的结果\' 这是条件为真打印的结果 >>> a = 0 >>> print(\'这是条件为真打印的结果\') if a == 1 else \'这是条件为假打印的结果\' 这是条件为假打印的结果
>>> a = 1 if b != 3 else 4 >>> a 4
# 如果条件成立那么 a = 1 ,否则 a = 4
六. lambda表达式
Python lambda 实在python中使用lambda来创建匿名函数，而用def创建的方法是有函数名称的。看看lambda的精简格式吧：
lambda args: print(args)
#一个参数 >>> info = lambda a: a**3 >>> type(info) <class \'function\'> >>> info(2) 8 >>> info(4) 64 #两个参数 >>> m = lambda a,b: a*b >>> m(2,3) 6 >>> m(19,13) 247 #三个参数 >>> m = lambda x,y,z: (x-y)*z >>> m(3,2,1) 1 >>> m(3,2,2) 2 >>> m(3,2,3) 3 >>> m(3,3,3) 0 >>> m(3,22,3) -57
七. 全局变量
全局变量遵循名称全部大写的规范,即：
NAME = \'daniel\'
AGE = 18
JOB = \'IT\'
全局变量在所有的作用域都可以读；
NAME = {\'Name\':\'Daniel\'} def f1(): age = 18 print(NAME,age) print(id(NAME)) def f2(): age = 19 print(NAME,age) print(id(NAME)) def f3(): age = 17 print(NAME,age) print(id(NAME)) f1() f2() f3()
全局变量可以在函数里可读，也可以写，但是更改要在函数里使用global声明，不过不建议这么做！
#全局变量 NAME = {\'Name\':\'Daniel\'} def f1(): age = 18 print(NAME,age) print(id(NAME)) def f2(): age = 19 NAME=\'F2\' print(NAME,age) print(id(NAME)) def f3(): age = 17 print(NAME,age) print(id(NAME)) f1() f2() f3() 执行结果，在f2函数是修改了NAME值，但是这只是一个名字叫NAME的一个局部变量而已； {\'Name\': \'Daniel\'} 18 4321829832 F2 19 4323767664 {\'Name\': \'Daniel\'} 17 4321829832
NAME = {\'Name\':\'Daniel\'}
def f1():
age = 18
print(NAME,age)
print(id(NAME))
def f2():
age = 19
global NAME
NAME=\'F2\'
print(NAME,age)
print(id(NAME))
def f3():
age = 17
print(NAME,age)
print(id(NAME))
f1()
f2()
f3()
#执行结果
{\'Name\': \'Daniel\'} 18
4321829832
F2 19
4323767664
F2 17
4323767664
全局变量如果是列表类型，在函数里可以增、删、修改,但是不能重新赋值，否则将会重新开辟一个内存地址，在函数里定义了一个同名的局部变量而已。
#NAME = {\'Name\':\'Daniel\'} NAME=[\'a\',\'b\',\'c\',] def f1(): age = 18 print(NAME,age) print(id(NAME)) def f2(): age = 19 NAME[1] = \'B\' del NAME[0] NAME.append(\'D\') print(NAME,age) print(id(NAME)) def f3(): age = 17 print(NAME,age) print(id(NAME)) f1() f2() f3() #执行结果 [\'a\', \'b\', \'c\'] 18 4315828296 [\'B\', \'c\', \'D\'] 19 4315828296 [\'B\', \'c\', \'D\'] 17 4315828296
在python中，strings, tuple, 和number 是不可更改的对象，而list,dict等则是可以修改的对象。
Python中所有的参数(自变量)在python里都是按引用传递的，如果在函数里修改了参数，那么在调用这个参数的函数里，原始的参数也就改变了。
l1 = [10,20,30] def f1(value): value.append([1,2,3,4,5,]) print(\'函数内的引用值: %s\' %value) f1(l1) print(\'函数外列表值: %s\' %l1) #执行结果： 函数内的引用值: [10, 20, 30, [1, 2, 3, 4, 5]] 函数外列表值: [10, 20, 30, [1, 2, 3, 4, 5]]
传入的函数和在末尾追加的内容是同一个引用，所以结果是一样的。