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
‘‘‘
时间: 2024-12-12 13:17:45

python 全栈开发笔记 2的相关文章

python 全栈开发笔记 4

反射 1.通过字符串的形式导入模块 2.通过字符串的形式,去模块中寻找指定函数并执行 ''' def f1(): return 'F1' def f2(): return 'F2' ''' #假设上面的是一个叫user的py文件里面的内容 #import user # user不是一个字符串,是一个文件名,无法通过字符串的形式导入 DO=__import__('user') #通过字符串的形式导入模块,'user'是个字符串,实现了反射的第一个功能. r=DO.f1() print(r) #输出

自学Python全栈开发第一次笔记

我已经跟着视频自学好几天Python全栈开发了,今天决定听老师的,开始写blog,听说大神都回来写blog来记录自己的成长. 我特别认真的跟着这个视频来学习,(他们开课前的保证书,我也写了一份,哈哈哈...)我现在是准大学生,准备学习编程,日后做一个程序员,哈哈哈.听说程序员很苦逼,不过貌似挣得也很多啊.并且我貌似也只喜欢计算机这个方面,所以我想在这个行业发光. 前些天学习了一些Linux一些命令: pwd     查看你当前所在的目录  /root=计算机/E盘 /    是根目录 cd(ch

Python全栈开发【基础三】

Python全栈开发[基础三]  本节内容: 函数(全局与局部变量) 递归 函数 一.定义和使用 函数最重要的是减少代码的重用性和增强代码可读性 1 def 函数名(参数): 2 3 ... 4 函数体 5 ... 6 返回值 函数的定义主要有如下要点: def:表示函数的关键字 函数名:函数的名称,日后根据函数名调用函数 函数体:函数中进行一系列的逻辑计算 参数:为函数体提供数据 返回值:当函数执行完毕后,可以给调用者返回数据. 总结使用函数的好处: 1.减少代码重用 2.保持一致性,易维护

Python全栈开发【第一篇】:初识Python

Python全栈开发[第一篇] 本节内容: Python 的种类 Python 的环境 Python 入门(解释器.编码.变量.input输入.if流程控制与缩进.while循环) if流程控制与while循环练习题 基本数据类型前引 Python 的种类 Cpython Python的官方版本,使用C语言实现,使用最为广泛,CPython实现会将源文件(py文件)转换成字节码文件(pyc文件),然后运行在Python虚拟机上. Jyhton Python的Java实现,Jython会将Pyth

Python全栈开发

Python全栈开发 一文让你彻底明白Python装饰器原理,从此面试工作再也不怕了. 一.装饰器 装饰器可以使函数执行前和执行后分别执行其他的附加功能,这种在代码运行期间动态增加功能的方式,称之为“装饰器”(Decorator),装饰器的功能非常强大,但是理解起来有些困难,因此我尽量用最简单的例子一步步的说明这个原理. 1.不带参数的装饰器 假设我定义了一个函数f,想要在不改变原来函数定义的情况下,在函数运行前打印出start,函数运行后打印出end,要实现这样一个功能该怎么实现?看下面如何用

Python全栈开发【基础二】

Python全栈开发[基础二] 本节内容: Python 运算符(算术运算.比较运算.赋值运算.逻辑运算.成员运算) 基本数据类型(数字.布尔值.字符串.列表.元组.字典) 编码与进制转换 Python 运算符 1.算术运算: 2.比较运算: 3.赋值运算: 4.逻辑运算:  5.成员运算: 基本数据类型 1.数字 int(整型) 1 class int(object): 2 """ 3 int(x=0) -> integer 4 int(x, base=10) -&g

python全栈开发目录

python全栈开发目录 linux命令 初识python python基础数据类型 函数编程.set.深浅拷贝 内置函数 文件操作 装饰器 迭代器和生成器 常用模块 初识类和对象 类和对象(进阶) 反射 异常处理 socket.IO多路复用 线程.进程.协程 HTML CSS JavaScript DOM文档操作 jQuery实例 web框架本质 Tornado mysql基础 mysql进阶 ..... 基本算法 递归--二分法查找 冒泡排序 更多 线程池

Python全栈开发【基础四】

Python全栈开发[基础四] 本节内容: 匿名函数(lambda) 函数式编程(map,filter,reduce) 文件处理 匿名函数 lambda表达式:对于简单的函数,存在一种简便的表示方式,即lambda表达式 1 #这段代码 2 def calc(n): 3 return n**n 4 print(calc(10)) 5 6 #换成匿名函数 7 calc = lambda n:n**n 8 print(calc(10)) 匿名函数主要是和其它函数搭配使用 举例: 1 ########

Python 全栈开发:python列表List

列表 列表是python中经常使用的数据类型,用于存放多个值. 表现形式:在[ ]内用逗号分隔,可以存放n个任意类型的值 eg: #单一类型 users=['yangli','yite','fixd'] #多类型,列表嵌套 users=['room01',['yangli',20,'音乐'],['yite',20,'篮球'],] 列表常用方法 和 函数 方法 函数 常用的操作 eg: len(list) #len(list) 计算列表的长度 ls = ['a','b','c','d'] leng