标签：python while 并且 登陆 null 逻辑 动态 containe 映射
函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
面向对象：对函数进行分类和封装，让开发“更快更好更强...”
函数式编程最重要的是增强代码的重用性和可读性
def xx(): print(‘xx‘) # 定义函数，放入内存当中，并不立即执行 #执行函数 xx() #调用函数，这时内存中的函数才开始执行，输出XX
函数的定义主要有如下要点：
函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。
函数的有三中不同的参数：
形参，实参（默认，按照顺序）
指定形参传入实参，可以不按照顺序
#动态参数 一个星号 def f1(*a): print(a,type(a)) li=[1,2,3,4] f1(li) # 输出 ([1, 2, 3, 4],) <class ‘tuple‘> 输出元组会将列表当成一个元素 f1(*li) # 输出 (1, 2, 3, 4) <class ‘tuple‘> 输出元组会将列表的每一个元素当成元组的每一个元素 f1(123) f1(123,[4,5,6],{‘k1‘:‘43n‘},(1,2,3),{1,2,3}) #可传任意多的参数，而且还可以时不同类型的参数 #返回的是元组的类型 #动态参数 两个星号 def f2(**a): print(a,type(a)) f2(k1=123,k2=456) #输出 {‘k1‘: 123, ‘k2‘: 456} <class ‘dict‘> f2(k1=123,k2=456,k3=1212) #输出 {‘k1‘: 123, ‘k2‘: 456, ‘k3‘: 1212} <class ‘dict‘> # 返回的是字典类型，默认输出以键值对的形式 dic={‘k1‘:123} # 也可以将字典直接传进去 f2(**dic) # 但需要再在前面加入两个星号，否则必须要f2(k1=dic) 形式传入 f2(k1=dic) # 上面的两条调用的输出结果分别为 # {‘k1‘: 123} <class ‘dict‘> # 这样可以避免引入额外的参数 ‘k1=‘ # {‘k1‘: {‘k1‘: 123}} <class ‘dict‘> #各种参数组合起来 def f3(p,k1=23,*a,**aa): print(p,type(p)) print(k1,type(k1)) print(a,type(a)) print(aa,type(aa)) f3(11,22,33,44,[00,55,66],k2=456,k3=000) ‘‘‘ 输出结果为：11 <class ‘int‘> p接收 22 <class ‘int‘> 给k1传了值，所以k1的默认值将会被改变 (33, 44, [0, 55, 66]) <class ‘tuple‘> *a 接收住 {‘k2‘: 456, ‘k3‘: 0} <class ‘dict‘> **a接收 ‘‘‘
在函数内部 修改和找到全局变量 要用关键字声明 global(变量) ,全局变量都大写，局部变量都小写
f2=lambda : 123 函数的另一种表达方式 ，函数名f2就是个变量
def f3(a1,a2): return a1+a2 f3=lambda a1,a2:a1+a2 # 对于简单的函数，用一个简单的一句话就能表示
# all() 循环参数，如果每个参数都为真，那么all的返回值为真 print(all([True,False,True])) # 输出False print(all([True,True,True])) #输出True # 0,None,空值都为假的，其他都为真的 # any() 只要一个为真即为真 print(any([True,False,True])) # 输出True #ascii(对象) 对象的类中找__repr__,获取其返回值 # bin()二进制 hex()十六进制 oct()八进制 int ()十进制 print(int(‘0b11‘,base=2)) # 二进制转化为十进制 print(int(‘0o11‘,base=8)) # 八进制转化为十进制 print(int(‘0x11‘,base=16)) # 十六进制转化为十进制 #bytes 字节 bytearray (字节列表) #chr(数字)找到数字对应ascii码 ord(ascii码) 找到ascii码所对应的数字 # 例子 随机验证码 import random temp=‘‘ for i in range(6): num1=random.randrange(0,4) if num1==3 or num1 == 1: red2=random.randrange(0,10) temp += str(red2) else: red1=random.randrange(65,91) c=chr(red1) temp += c print(‘验证码:‘,temp) # callable(f1) 判断f1()是不是可执行的 ,是返回True #compile() 编译 complex() 复数 dir() 查看对象的方法 # divmod() print(divmod(10,3)) # 输出(3,1) 商和余数 # eval() exec() print(eval(‘1+3‘)) #输出4 exec(‘for i in range(10):print(i)‘) #将字符串当成python代码执行，没有返回值 # filter(函数，可迭代的对象) 筛选元素 def f1(x): #筛选偶数 if x%2 == 0: return True ret=filter(f1,[11,22,33,44]) #筛选 等同于 filter(lambda x: x%2==0,[11,22,33,44]) for i in ret: print(i) #输出 22，44 #map() 按照某种规则映射 ret=map(lambda x: x +100,[1,2,3,4]) for i in ret: print(i) # 输出 101，102，103，104 # globals() #获取全部的全局变量 locals()获取全部的局部变量 #hash() 哈希值 帮助快速找到对应的值 #zip() li1=[11,22,33,44] li2=[‘a‘,‘b‘,‘c‘,‘d‘] li3=[‘A‘,‘B‘,‘C‘,‘D‘] r=zip(li1,li2,li3) for i in r: print(i)(11, ‘a‘, ‘A‘) ‘‘‘ 输出 (22, ‘b‘, ‘B‘) (33, ‘c‘, ‘C‘) (44, ‘d‘, ‘D‘) ‘‘‘
字符串和数字不能混在一起排序 ，字符串排序时，字符串中的排序顺序为：数字（正常比较），字母(ascii码)，中文（转化为16进制）
open(文件名，模式，编码)
|
1
|
文件句柄 = open(‘文件路径‘, ‘模式‘) |
打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。
打开文件的模式有：
"+" 表示可以同时读写某个文件
"b"表示以字节的方式操作
注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型
truncate() #截取文件内容，依赖于指针的位置 flush # 将内存的数据刷进硬盘中
f1=open(‘text.txt‘,‘r‘) for line in f1: # 一行一行读直到读完 print(line) f1.close # 每次打开都要close一次 with open(‘text.txt‘,‘r‘) as f: # 自动帮你close() f.read() #同时打开两个文件，读一行写一行，内存的消耗将会降低 with open(‘text.txt‘,‘r‘) as f2,open(‘text1.txt‘,‘w‘) as f3: for line in f2: f3.write(line)
li=[1,123,43,56,78,90,23,34589,234] inp=1 while(inp<len(li)): for i in range(len(li)-inp): if li[i] < li[i+1]: temp=li[i] li[i]=li[i+1] li[i+1]=temp inp += 1 print(li)
def login(username,password): ‘‘‘ 用于用户名密码的验证 username 用户名 password 用户名密码 返回值：True表示登陆成功 返回值: False 表示登录失败 ‘‘‘ with open(‘text.txt‘,‘r‘) as f: for line in f: line=line.strip() #默认strip无参数，移除空格、换行符 #有参数，移除两端指定的值 line_list=line.split(‘$‘) if username == line_list[0] and password == line_list[1]: return True return False def register(username,password): if user_exist(username): return False else: with open(‘text.txt‘,‘a+‘) as f: user_list=‘\n‘+username+‘$‘+password f.write(user_list) return True def user_exist(username): with open(‘text.txt‘,‘r‘) as f: for line in f: line=line.strip() line_list=line.split(‘$‘) if username == line_list[0]: return True return False def user_modif(username,new_password): for i in new_password: if i == ‘@‘ or i == ‘#‘ or i==‘$‘: print(‘你输入得字符不能包含@、#、$‘) return False with open(‘text.txt‘,‘r‘) as f1: lines=f1.readlines() with open(‘text.txt‘,‘w‘) as f2: for line in lines: line_list=line.split(‘$‘) if username == line_list[0]: new_line=line_list[0]+‘$‘+new_password+‘\n‘ f2.write(new_line) else: f2.write(line) return True def user_del(username): with open(‘text.txt‘,‘r‘) as f1: lines=f1.readlines() with open(‘text.txt‘,‘w‘) as f2: for line in lines: line_list=line.split(‘$‘) if username == line_list[0]: continue else: f2.write(line) return True #print(inp) while(True): print(‘欢迎登陆幸福之门系统\n‘) inp=input(‘1:登陆，2:注册,3:修改密码，4：注销账户,5:退出\n‘) if inp == ‘1‘: user=input(‘请输入用户名：‘) pwd=input(‘请输入密码：‘) if login(user,pwd): print(‘登陆成功！‘) else: print(‘登录失败!‘) elif inp == ‘2‘: user=input(‘请输入用户名：‘) pwd=input(‘请输入密码：‘) if register(user,pwd): print(‘注册成功！‘) else: print(‘注册失败！‘) elif inp == ‘3‘: user=input(‘请输入你想修改密码得用户名：‘) password=input(‘请输入原来账户名得密码‘) if login(user,password): new_password=input(‘请输入新的密码‘) if new_password == password: print(‘你输入得密码和原密码相同不用修改！‘) else: if user_modif(user,new_password): print(‘修改成功！‘) else: print(‘修改失败!‘) else: print(‘输入密码错误无法修改!‘) elif inp == ‘4‘: user=input(‘请输入你想注销得用户名：‘) password=input(‘请输入账户名密码‘) if login(user,password): if user_del(user): print(‘注销成功！‘) else: print(‘注销失败！‘) else: print(‘输入密码错误无法注销!‘) elif inp == ‘5‘: break
#函数当作参数传递 def f1(): return ‘F1‘ def f2(arg): print(arg()) # 相当于执行f1(),输出 F1 return ‘F2‘ f2(f1) # f1代指函数,相当于一个变量,是变量就可以当作参数进行传递,f1()执行函数 # 函数名可以当作参数传递 函数名 代指函数内容
让函数在执行之前或执行之后做一些操作,只要函数应用上装饰器，那么函数将会被重新定义，重新定义为装饰器的内层函数。
# 单层不加参数得装饰器 def outer(func): def inner(): print(‘Hello‘) print(‘Hello‘) print(‘Hello‘) print(‘Hello‘) r=func() # 原来的f1的函数= func,func()=f1(),r=null(没有返回值) print(‘End‘) print(‘End‘) print(‘End‘) print(‘End‘) return r return inner # 1.执行outer函数，并且将其下面的函数名，当作参数传进去 @outer #2. 将outer的返回值重新赋值给新的f1，新的f1=outer的返回值 ,新的f1=inner def f1(): # 新的f1()=inner() print(‘F1‘) @outer def f2(): print(‘F2‘) @outer def f3(): print(‘F3‘) f1() #相当于执行 inner(),原来不加装饰器得f1()调用时只会输出F1,加过装饰器之后得f1() #输出得结果为 ‘‘‘ Hello Hello Hello F1 End End End End ‘‘‘ #就相当于在不改变原函数得情况下，给原函数附加一些功能
# 带参数的装饰器(可传任意多的参数,适用多层) def outer(func): def inner(*args,**kwargs):# 可接受任意多、任意形式的参数 print(‘Hello‘) #print(args) r=func(*args,**kwargs) # 接收上面inner()中的参数 #print(kwargs) print(‘End‘) #python内部的优化，自动帮你判断f1函数所需要的参数,无需自己提取 return r return inner # 1.执行outer函数，并且将其下面的函数名，当作参数传进去 @outer #2. 将outer的返回值重新赋值给新的f1，新的f1=outer的返回值 ,新的f1=inner def f1(a): # 新的f1()=inner() print(‘F1‘) print(a) f1(1) # 同样一个装饰既适用一个参数的，也适用多个参数的 @outer def f2(a,b,c): print(a+b+c) f2(1,2,3)
# 多层的装饰器 def outer1(func): def inner(*args,**kwargs): print(‘Hello1‘) r=func(*args,**kwargs) print(‘End1‘) return r return inner #相当于在第一个装饰上又装饰了一下 def outer2(func): def inner(*args,**kwargs): print(‘Hello2‘) r=func(*args,**kwargs) print(‘End2‘) return r return inner @outer1 #（在第一个装饰器外面又装饰了一些东西） # 1.执行outer1函数，并且将其下面的函数名(outer2中的内层函数inner)，当作参数传到outer1中 @outer2 #（内部第一个装饰器） #2. 将outer的返回值重新赋值给(outer2中的内层函数inner) def f1(a,b): print(‘F1‘) print(a+b) f1(1,1) #内部装饰器装饰的结果为 ‘‘‘ Hello2 F1 外面多了一层 Hello2 End2 2 End2 ‘‘‘ #加上外部装饰器装饰的结果为 ‘‘‘ Hello1 外面多了一层 Hello1 End1 Hello2 F1 2 End2 End1 ‘‘‘
标签：python while 并且 登陆 null 逻辑 动态 containe 映射
原文地址：http://www.cnblogs.com/qianse/p/7191725.html
