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()