首页 > 代码库 > python 全栈开发笔记 2

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 == 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 全栈开发笔记 2