lambda 内置函数 递归

时间:2021-09-17 19:02:29

1.lambda表达式

def f1():
    return 123
f2 = lambda :123

def f3(a1, a2):
    return a1+a2
f4 = lambda a1,a2:a1+a2


-----------------------------------
2. 内置函数
    1, abs() 绝对值
    2, all() 循环参数,每个元素都为真,那么all的返回值为真
         假:0,None,空值:"",[],(),{}
    3, any() 只要有一个真,则为真
    4, ascii() eg:返回[]
    5, bin() #二进制     oct()#八进制   int()#十进制   hex()#十六进制  十进制

转化

        i = int('0b11', base=2)  #2进制转化为十进制
        print (i)
3

        i = int('11', base=8)  #8进制转化为十进制
        print (i)


        i = int('0xe', base=16)  #十六进制转化为十进制
        print (i)


    6, bool()    bytearray()   bytes()

生成随机验证码:
import random

temp = ""
for i in range(6):
    num = random.randrange(0,4)
    if num == 3 or num == 1:
        rad2 = random.randrange(0, 10)
        temp = temp + str(rad2)
    else:
        rad1 = random.randrange(65,91)
        c1 = chr(rad1)
        temp = temp + c1

print (temp)


    7, callable()



3.open()  文件操作

一.打开文件
二.操作文件
三.关闭文件

r,只读模式(默认)
w,只写模式(不可读,不存在则创建,存在则清空内容)
x,只写模式(不可读,不存在则创建,存在则报错)
a,追加模式(可读,不存在则创建,存在则只追加内容)

rb,只读,二进制方式打开,字节方式打开,

open(文件名,模式,编码)

f = open('ha.log',"r")   #默认只读模式 "r"
data = f.read()
f.close()
print (data)


f = open('ha.log',"r")   #默认只读模式 "r"
f.write()
f.close()
报错


-------------------------------------------------------------
冒泡排序
li = [33, 2, 10, 1]
for j in range(1,len(li)):
    for i in range(len(li) - j):
        if li[i] > li[i + 1]:
            temp = li[i]
            li[i] = li[i + 1]
            li[i + 1] = temp

print (li)


----------------------------------------------------------------
递归
def f5(depth, a1, a2):
    if depth == 10:
        return a1
    a3 = a1 + a2
    r = f5(depth + 1,a2, a3)
    return r

ret = f5(1, 0, 1)
print (ret)

-------------------------------------------------------------------
装饰器------outer()
封闭开放原则

-------------------------------------------------------------------
正则表达式





------------------------------------------------------------------
time模块
import time
import datetime

time.sleep(2)

#时间戳 从1970.1.1开始到现在一共过去了多少秒  unix系统诞生的时间
print(time.time())

#返回当前系统时间
print(time.ctime())


------------------------------------------------------------
sys模块

import sys
print(sys.argv)

import getpass


------------------------------------------------------------
1.主文件
    调用函数前,必须加 if __name__ == "__main__":

2.__file__
    #当前文件的路径
    #C:\Python35\python.exe
    sys.path
    os.path.join
    os.path.dirname

3.json模块
    loads -> 内部必须是双引号
    dumps
    load
    dump


4.如何安装第三方模块
    pip3
        pip3 install XXXXX
    源码
        下载,解压
        进入目录 python setup.py install


5.requests
    res = requests.get("")
    res.encoding = 'utf-8'
    result = res.text

6.XML
    两种解析方式
        解析一个字符
        解析一个文件路径

    两种都能读取

    两种方式:
        都能修改(内存数据)
        重新写入

    对于某个节点操作:
        tag
        attrib
        find
        iter
        set
        get

----------------------------------------------------------------------
生成器 迭代器

生成器:一次不全部创建,执行next的时候再创建,再执行next的时候再生成下一个,省内存
       
迭代器:具有访问能力的东西,for循环实现

--------------------------------------------------------------------
一.反射
    通过字符串的形式,导入模块
    通过字符串的形式,去模块中寻找指定函数,并执行


#根据字符串的形式去某个模块中寻找东西
#根据字符串的形式去某个模块中判断东西是否存在
#根据字符串的形式去某个模块中设置东西
#根据字符串的形式去某个模块中删除东西

#根据字符串的形式去对象(某个模块)中操作其成员

getattr
hasattr
setattr
delattr


扩展:
    import 模块

    a = __import__("模块名")
    a = __import__('lib.test.com', fromlist = True)

-----------------------------------------------------------------
二. 面向对象基础
C#  Java:只能用面向对象编程
Ruby  Python: 函数编程  + 面向对象

1.面向过程编程
2.函数式编程,def 函数
    def fetch(backend):
        pass

    def add_record(backend, record):
        pass

    fetch("www.oloboy.org")
    add_record("www.oloboy.org",XXXXX)

3.面向对象编程,类,def 函数
    calss Oldboy:
    
    def fetch(self, backend):
        pass    

    def add_record(self, backend, record):
        pass

    obj = Oldboy()
    obj.fetch("www.oloboy.org")
    obj.add_record("www.oloboy.org",xxxxxx)

==========================================================

1.面向对象不是所有情况都适用
    多个函数共用参数的时候,封装到对象里面 适用

2.面向对象编程
    a.定义类
        class Foo:
            def 方法1(self, bb):
                pss
    b.根据类创建对象(创建一个Foo类的实例)
        使用对象去执行类中的方法
3.self,形式参数,代指执行方法的对象,python内部传递
    obj = Foo()
    obj.fetch('bb') ==> self:obj, backend:"bb"

    obj1 = Foo()
    obj1.fetch('bb') ==> self:obj1, backend:"bb"

4.类+括号  => 自动执行类中的__int__方法;创建了一个对象
    在__init__方法中执行具体封装的操作
    __init__有一个特殊名字:构造方法

    ==> 初始化

    __del__ 解释器销毁对象时候自动调用, 特殊的名: 析构方法

=========================结果===========================
封装:
    使用场景:当同一类型的方法具有相同参数时,直接封装到对象即可.
    使用场景:把类当做模板,创建多个对象(对象内封装的数据可以不一样)

5.派生类可以继承基类中所有的功能

6.派生类和积累同时存在,优先找派生类

7.python类可以同时继承多个类(C#/Java不可以)
    优先:自己,左边,右边

==========================结果==========================
继承:
    多继承
    顺序见图    
8.多态    
    多种形态
    python本身支持多态

    扩展:    
        重载,函数名相同,参数个数不同(Python不支持)
        重写,派生类中重新实现基类中的方法


三大特性: 封装.继承.多态

======================================================================
补充:
    查找源码的过程(self.xxxx(),从底层开始找)
    执行父类的构造方式:
        super(当前类,self).init()
        父类.__init__(self.xxx)

一.面向对象的进阶
    成员
        ####类,对象 ==>静态字段,静态方法, 普通字段,类的方法####
        # 规范:

        # 通过类访问有:静态字段,静态方法,类方法(静态方法特殊)
        # 通过对象访问:普通字段,类的方法

    成员修饰符
        #除了自己,谁也不好使
        #__私有

    面向对象中一些常用特殊方法  
        __init__   
        __call__   
        __xxxxxitem__
        __dict__
        __iter__
        __str__

        __metaclass__
        __new__        

成员:
    字段   静态字段(每个对象都有一份) 普通字段(每个对象都不同的数据)

    方法   静态方法(无需使用对象封装的内容) 类方法 普通方法


二. 异常处理
    try:
        xxx
    except Execption as e:
        print(e)


    try:
        xxx
    except Execption as e:
        xxx
    eles:
        xxx
    finally:
        xxx

三.单例模式










================================================================================
四.网络编程
    Socket (TCP  IP)  套接字

    服务端
        1.运行起来  ip,端口 port,  等待别人来连接
    客户端
    客户端
    客户端

服务端收连接,客户端发连接:
----------------------------------------------------------------------
服务端:
import socket

sk = socket.socket()
sk.bind(('127.0.0.1', 9999,))
sk.listen(5)
# 接收客户端的请求

#连接,客户端的地址信息
while True:
    conn, address = sk.accept()   #accept阻塞
    print (conn,address)


客户端:
import socket

obj = socket.socket()

obj.connect(('127.0.0.1', 9999))

obj.close()
----------------------------------------------------------------------



服务端收连接,客户端发连接;
服务端发送消息,客户端接收消息,客户端发送消息,服务端回复消息
----------------------------------------------------------------------
服务端:
import socket

sk = socket.socket()
sk.bind(('127.0.0.1', 9999,))
sk.listen(5)
# 接收客户端的请求

#连接,客户端的地址信息
while True:
    conn, address = sk.accept()   #accept阻塞
    conn.sendall(bytes('欢迎致电老男孩',encoding = 'utf-8'))
    while True:
        ret_bytes = conn.recv(1024)
        ret_str = str(ret_bytes, encoding = 'utf-8')
        if ret_str == 'q':
            break
        conn.sendall(bytes(ret_str + "好", encoding = 'utf-8'))
    # print (address, conn)





客户端:
import socket

obj = socket.socket()

obj.connect(('127.0.0.1', 9999))

#阻塞
ret_bytes = obj.recv(1024)
ret_str = str(ret_bytes, encoding = 'utf-8')
print (ret_str)
while True:
    inp = input("请输入要发送的内容:")
    if inp == 'q':
        obj.sendall(bytes(inp, encoding = 'utf-8'))
        break
    else:
        obj.sendall(bytes(inp, encoding='utf-8'))
        ret = str(obj.recv(1024),encoding = 'utf-8')
        print (ret)

obj.close()
------------------------------------------------------------------------------



服务端收连接,客户端发连接;
客户端向服务器端传文件,服务器端接收到文件,文件传输上传功能
----------------------------------------------------------------------
服务端:
import socket

sk = socket.socket()
sk.bind(('127.0.0.1', 9999,))
sk.listen(5)
# 接收客户端的请求

#连接,客户端的地址信息
while True:
    conn, address = sk.accept()   #accept阻塞
    conn.sendall(bytes("欢迎登录系统", encoding='utf-8'))
    # 先接收文件大小,然后再开始接收文件
    file_size = str(conn.recv(1024), encoding='utf-8')
#解决粘包问题,做一次发送回应的交互
    conn.sendall(bytes("ack", encoding='utf-8'))

    print (file_size)
    total_size = int(file_size)
    has_recv = 0
    f = open('new.jpg', 'wb')
    #接收文件内容,直到获取完毕
    while True:
        if total_size == has_recv:
            break
        data = conn.recv(1024)
        f.write(data)
        has_recv += len(data)

    f.close()



客户端:
import socket
import os

obj = socket.socket()

obj.connect(('127.0.0.1', 9999))

#阻塞
ret_bytes = obj.recv(1024)
ret_str = str(ret_bytes, encoding = 'utf-8')
print (ret_str)

#发送当前文件大小
size = os.stat('t.jpg').st_size
obj.sendall(bytes(str(size), encoding = 'utf-8'))

#解决粘包问题,做一次发送回应的交互
obj.recv(1024)

#发送文件
with open('t.jpg', 'rb') as t:
    for line in t:
        obj.sendall(line)

obj.close()