python 全栈开发笔记 2

函数

函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可

面向对象：对函数进行分类和封装，让开发“更快更好更强...”

函数式编程最重要的是增强代码的重用性和可读性

def  xx():
    print('xx')   # 定义函数，放入内存当中，并不立即执行

#执行函数
xx()  #调用函数，这时内存中的函数才开始执行，输出XX

函数的定义主要有如下要点：

• def：表示函数的关键字
• 函数名：函数的名称，日后根据函数名调用函数
• 函数体：函数中进行一系列的逻辑计算，如：发送邮件、计算出 [11,22,38,888,2]中的最大数等...
• 参数：为函数体提供数据
• 返回值：当函数执行完毕后，可以给调用者返回数据。

返回值

函数是一个功能块，该功能到底执行成功与否，需要通过返回值来告知调用者。

参数

函数的有三中不同的参数：

• 普通参数
• 默认参数:有默认参数一定要放在后面
• 动态参数

形参，实参（默认，按照顺序）

指定形参传入实参，可以不按照顺序

动态参数

#动态参数  一个星号
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(变量)   ,全局变量都大写，局部变量都小写

lambda 表达式

f2=lambda : 123  函数的另一种表达方式 ，函数名f2就是个变量

def f3(a1,a2):
    return a1+a2

f3=lambda a1,a2:a1+a2   #  对于简单的函数，用一个简单的一句话就能表示

python 内置函数

# 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('文件路径', '模式')

打开文件时，需要指定文件路径和以何等方式打开文件，打开后，即可获取该文件句柄，日后通过此文件句柄对该文件操作。

打开文件的模式有：

• r ，只读模式【默认】
• w，只写模式【不可读；不存在则创建；存在则清空内容；】
• x， 只写模式【不可读；不存在则创建，存在则报错】
• a， 追加模式【不可读；   不存在则创建；存在则只追加内容；】

"+" 表示可以同时读写某个文件

• r+， 读写【可读，可写】   :写、追加时指针到最后,f.tell() 获取指针的位置,读,0开始读,写:只要读过(不管都没读完),最后位置追加,如果从特定位置往后写,需要主动seek寻找位置
• w+，写读【可读，可写】 ：写之前先清空，再写之后就可以读了,但需要把指针返回到最初位置f.seek(0)
• x+ ，写读【可读，可写】  :如果文件存在会报错,这是和W+的区别
• a+， 写读【可读，可写】 : 打开的同时把指针移到最后，等待追加,f.seek(0)返回到起始位置

"b"表示以字节的方式操作

• rb  或 r+b
• wb 或 w+b
• xb 或 w+b
• ab 或 a+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 == '':
        user=input('请输入用户名：')
        pwd=input('请输入密码：')
        if login(user,pwd):
            print('登陆成功！')
        else:
            print('登录失败!')
    elif inp == '':
        user=input('请输入用户名：')
        pwd=input('请输入密码：')
        if register(user,pwd):
            print('注册成功！')
        else:
            print('注册失败！')

    elif inp == '':
        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 == '':
        user=input('请输入你想注销得用户名：')
        password=input('请输入账户名密码')
        if login(user,password):
            if user_del(user):
                print('注销成功！')
            else:
                print('注销失败！')
        else:
            print('输入密码错误无法注销!')
    elif inp == '':
        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
'''