目录
1、python面向对象
class Hero:
def info(self):
print("鲁班，鲁班，小子鲁班", self)
luban = Hero()
luban.info()
print("lu=ban id:", id(luban))
luban.name = "鲁班"
luban.skill = "嘴炮"
print("英雄:{},技能:{}".format(luban.name, luban.skill))
1.1、魔法方法
class Hero:
# 魔法方法，类似于构造函数
def __init__(self, name, skill, permAge):
self.name = name
self.skill = skill
self.permAge = permAge
def __del__(self):
print("销毁释放，阵亡")
def info(self):
print("英雄【{}】，使用了【{}】，造成了【{}】%的伤害".format(self.name, self.skill, self.permAge))
# 指定该文件的入口位置，在其它py文件中是不会访问到该代码段。
if __name__ == "__main__":
luban = Hero("鲁班", "嘴炮", "13")
luban.info()
1.2 单继承
代码一：
class Luban:
def __init__(self, name):
self.name = name
self.skill = "嘴炮"
self.level = 30
def attack(self):
print("英雄{}使用了最强技能{}，有{}%概率造成一击必杀".format(self.name, self.skill, self.level))
class luban(Luban):
def attack(self):
print("英雄{}使用了普通技能{}，有造成{}%伤害".format(self.name, self.skill, self.level))
def oldattack(self):
# Luban.__init__(self, self.name)
Luban.attack(self)
if __name__ == "__main__":
lu7 = luban("鲁班七号")
lu7.attack()
lu7.oldattack()
代码二：
class Luban:
def __init__(self, name):
self.name = name
self.skill = "嘴炮"
self.level = 30
def attack(self):
print("英雄{}使用了最强技能{}，有{}%概率造成一击必杀".format(self.name, self.skill, self.level))
class luban(Luban):
def __init__(self, name, skill, permAge):
self.name = name
self.skill = skill
self.permAge = permAge
def attack(self):
print("英雄{}使用了普通技能{}，有造成{}%伤害".format(self.name, self.skill, self.permAge))
def oldattack(self):
Luban.__init__(self, self.name)
Luban.attack(self)
if __name__ == "__main__":
lu7 = luban("鲁班七号", "嘴炮2", "13")
lu7.attack()
lu7.oldattack()
1.3多继承
# 多继承时，在基类初始化顺序中，先初始化的将被后初始化的基类成员覆盖
#与继承顺序无关
#python中成员默认共有，成员私有化，在变量前加两根下划线。内体中定义。
class Luban:
def __init__(self, name):
self.name = name
self.skill = "嘴炮"
self.level = 30
def attack(self):
print("英雄{}使用了最强技能{}，有{}%概率造成一击必杀".format(self.name, self.skill, self.level))
class Space:
def __init__(self, name):
self.name = name
self.skill = "嘴炮"
self.level = 30
def attack(self):
print("英雄:{}使用了技能:{}，造成{}%伤害".format(self.name, self.skill, self.level))
# 多继承时，在基类初始化顺序中，先初始化的将被后初始化的基类成员覆盖
# 与继承顺序无关
class Lu7(Space, Luban):
def __init__(self):
Space.__init__(self, "鲁班")
Luban.__init__(self, "鲁班大师")
self.__na = "sdfs"
def set_na(self, ba):
self.__na = ba
def get_na(self):
return self.__na
if __name__ == "__main__":
lu7 = Lu7()
lu7.attack() # 调用的是后初始化的基类成员
lu7.set_na("hello") #设置私有成员属性
print(lu7.get_na()) #获取私有成员属性
##
class Lu7: def __init__(self): self.__na = "sdfs" @property # 说明下面函数，可以像成员变量一样，点号访问 def value_get(self): return self.__na @value_get.setter def value(self, ba): self.__na = ba if __name__ == "__main__": lu7 = Lu7() lu7.value = "hello" print(lu7.value_get)
2、异常
def func(x, y):
return x / y
if __name__ == "__main__":
try:
x = int(input("x:"))
y = int(input("y:"))
func(x, y)
except BaseException as e:
print(e)
3、线程
from time import ctime, sleep
import threading
def music(name):
for i in range(50):
print("music: {},{}".format(name, ctime()))
sleep(1)
def study(name):
for i in range(50):
print("study:{},{}".format(name, ctime()))
sleep(1)
if __name__ == "__main__":
t1 = threading.Thread(target=music, args=("hello ",))
t2 = threading.Thread(target=study, args=("xuexi",))
//线程开始
t1.start()
t2.start()
//阻塞等待线程结束
t1.join()
t2.join()
print("now time {}".format(ctime()))
3.1 线程锁
from time import ctime, sleep
import threading
def music(name, lock):
while True:
with lock: #离开语句自动解锁
print("music: {},{}".format(name, ctime()))
sleep(1)
def study(name, lock):
while True:
with lock:
print("study:{},{}".format(name, ctime()))
sleep(1)
if __name__ == "__main__":
lock1 = threading.Lock() #定义一把锁
t1 = threading.Thread(target=music, args=("hello ", lock1))
t2 = threading.Thread(target=study, args=("xuexi", lock1))
t1.start()
t2.start()
t1.join()
t2.join()
print("now time {}".format(ctime()))
3.2 线程同步
from time import ctime, sleep
import threading
def music(name, sem1, sem2):
while True:
sem2.acquire()
print("music: {},{}".format(name, ctime()))
sleep(1)
sem1.release()
def study(name, sem1, sem2):
while True:
sem1.acquire()
print("study:{},{}".format(name, ctime()))
sleep(1)
sem2.release()
if __name__ == "__main__":
sem1 = threading.Semaphore(1)
sem2 = threading.Semaphore(0)
t1 = threading.Thread(target=music, args=("hello ", sem1, sem2))
t2 = threading.Thread(target=study, args=("xuexi", sem1, sem2))
t1.start()
t2.start()
t1.join()
t2.join()
print("now time {}".format(ctime()))
4、进程
from time import ctime, sleep
from multiprocessing import Process, Pipe
def music(name, wfd):
while True:
print("music: {},{}".format(name, ctime()))
wfd.send("gfsggf")
sleep(1)
wfd.send([1, 2, 3, 4, 5])
sleep(1)
def study(name, rfd):
while True:
str1 = rfd.recv()
print("study:{}".format(str1))
print("study:{},{}".format(name, ctime()))
if __name__ == "__main__":
rfd, wfd = Pipe() # 创建管道
t1 = Process(target=music, args=("hello", wfd))
t2 = Process(target=study, args=("xuexi", rfd))
t1.start()
t2.start()
t1.join()
t2.join()
print("now time {}".format(ctime()))
4.1 消息队列
from time import ctime, sleep
from multiprocessing import Process, Queue
def music(name, q):
while True:
print("music: {},{}".format(name, ctime()))
q.put("Sdsasdsa")
sleep(1)
def study(name, q):
while True:
str1 = q.get()
print("study:{}".format(str1))
print("study:{},{}".format(name, ctime()))
if __name__ == "__main__":
q = Queue()
t1 = Process(target=music, args=("hello", q))
t2 = Process(target=study, args=("xuexi", q))
t1.start()
t2.start()
t1.join()
t2.join()
print("now time {}".format(ctime()))
5、套接字
import socket
# 定义套接字对象
socketfd = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
# 设置端口重用
socketfd.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑定本地ip、端口
socketfd.bind(("0.0.0.0", 9876))
socketfd.listen(5)
while True:
print("等待中，接收客户端。")
confd, addr = socketfd.accept()
print("clent:", addr)
while True:
print("等待中，接收数据。。。。。。")
str1 = confd.recv(120)
print(str1)
5.1 服务器类
from socketserver import TCPServer, StreamRequestHandler
# 从 socketserver 模块导入 tcp服务类，stream处理客户端请求类
# 该封装好的tcp服务器处理客户端请求，必须有StreamRequestHandler类中 handler方法进行处理
class myreqest(StreamRequestHandler):
# 重写基类handker方法，当客户端 连接成功，系统会自动调用该函数 处理客户端请求
# 当客户端的请求处理完成，会自动断开连接
def handle(self) -> None:
while True:
buf = self.request.recv(1024)
print(buf)
if buf.decode() == "quit":
break
if __name__ == "__main__":
# 创建TCPserver就是，在创建 头层皮服务器.指定服务器地址，和请求类
server = TCPServer(("0.0.0.0", 9523), myreqest)
print("server init sucess.")
# 永久阻塞等待新客户端连接,
# 可以同时连接多个，但是只能处理一个客户端。其它数据在缓存区
server.serve_forever()
5.2 http搭建
from http.server import HTTPServer, CGIHTTPRequestHandler
if __name__ == "__main__":
http = HTTPServer(("", 8080), CGIHTTPRequestHandler)
print("starting", str(http.server_port))
print("staring: ", str(http.server_port))
http.serve_forever()
实验：浏览器输入：localhost8080
5.3 串口编程
import serial.tools.list_ports
import serial
def findValible():
ports = list(serial.tools.list_ports.comports())
if len(ports) == 0:
print("系统无可用串口")
else:
for i in ports:
print(i)
if __name__ == "__main__":
# 查看系统可用串口
findValible()
ser = serial.Serial(port="COM1", baudrate=115200)
while True:
# buf = input("输入：")
# ser.write(buf.encode())
# ser.flush()
list1 = ser.readlines(3)
for i in list1:
print(i.decode())
6、其它库
1、数学库 numpy
1.1创建数组
import numpy as np # 同构生成 numpy 的一维数组 a = np.arange(1, 10, 2) print(a) print(a.shape) # 打印numpy数组形状 print(a.ndim) # 打印numpy数组的轴数 print(a[2]) # 访问元素 list1 = [1, 2, 3, 4, 5, 16, 6, 343, 7, 87] a = np.array(list1) # array方法把liet列表同构为数组 print(a) print(a.shape) print(a.ndim) print(a[3]) list2 = [[1, 2, 3], [4, 5, 6], [2, 3, 3]] a = np.array(list2) # 将一个列表，所有元素同构成一个二维数组 print(a) print(a.shape) print(a.ndim) print(a[2][2]) a = np.arange(0, 20, 1).reshape(4, 5) # 将一个列表直接同构为二维数组 print(a) print(a.shape) print(a.ndim) print(a[2][2]) print(a[2]) print(a.size)
1.2 运算
import numpy as np a = np.array([[1, 2], [3, 4]]) b = np.array([[2, 3], [7, 2]]) c = a * b # 对应元素向乘 print(c) c = a + b # 对应元素向加 print(c) c = a - b # 对应元素向减 print(c) print(c.sum()) # 所有元素相加 print(c.min()) # 求矩阵中最小元素 print(c.max()) # 求矩阵中最大元素 print(c.sum(axis=1)) #各行元素相加 print(c.sum(axis=0)) #各列元素相加
1.3 索引切片
import numpy as np a = np.arange(10) print(a) print(a.shape) print(a[-1], a[a.size - 1]) # 最后一个元素 print(a[1:5]) print(a[1::2]) b = np.arange(20).reshape(4, 5) print(b) print(b.shape) print(b[1][1], b[1][1:-1]) # 数组访问形式 # 每个轴都有自己的索引，【第一轴索引，第二轴索引】 print(b[1, 1]) # 第一轴长为1，第二轴长为1 print(b[1, 1:-1]) # 第一轴长1，第二轴长切片1到末尾 print(b[1:3, 1:-1]) c = np.arange(24).reshape(4, 3, 2) print(c) print(c[0:2, 0:2, 0:1])
2、matplotlib库
1、
import numpy as np import matplotlib.pyplot as plt #直线两点（1，3），（13，7） x = np.array([1,13]) #两点x坐标同构为数组 y = np.array([3,7]) plt.plot(x,y) #绘制直线 plt.plot(x,y,scalex=5,scaley=3) #坐标比例 plt.show() #显示窗口 x = np.array([6]) y = np.array([6]) plt.scatter(x,y,s=50,c="r",marker="*") #绘制点，s面积，c颜色，m形状 plt.show()
2、
import numpy as np
import matplotlib.pyplot as plt
# x= np.arange(0,4*np.pi,0.1)
# y= np.sin(x)
#
# plt.plot(x,y)
# plt.show()
x1 = np.random.normal(0,300,2000)
y1 = np.random.normal(0,300,2000)
plt.scatter(x1,y1,c="r")
plt.show()
x1 = np.random.normal(0,300,2000)
y1 = np.random.normal(0,300,2000)
plt.scatter(x1[0:1000],y1[0:1000],c="r",marker="o") #前1000点红色
plt.scatter(x1[1000:2000],y1[1000:2000],c="b",marker="o")#后1000点蓝色
plt.show()
3、多界面绘制
一个窗口，多个子图 import numpy as np import matplotlib.pyplot as plt x = np.array([1,4,6,9,13,19]) y = np.array([9,3,6,2,32,42]) #指定子图位置,两行两列，第一幅图 plt.subplot(221) plt.plot(x,y,c="r") #指定子图位置，两行两列，第二幅图 plt.subplot(222) plt.plot(x,y,c="b") #指定子图位置，两行两列，第3幅图 plt.subplot(223) plt.plot(x,y,c="g") #指定子图位置，两行两列，第4幅图 plt.subplot(224) plt.plot(x,y,c="y") plt.show()
4、绘制3d图
import numpy as np import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D #创建窗口 fig = plt.figure() #窗口中 创建3d绘图对象 ax = Axes3D(fig) #创建 x，y坐标 数组 x = np.arange(-4,4,0.25) y = np.arange(-4,4,0.25) #网格化处理 x,y = np.meshgrid(x,y) #计算某个点的 到原点的距离为半径 R=np.sqrt(x**2+y**2) #以半径为基准点，求sin（）值,作为点的z坐标 z = np.sin(R) #绘制3d图 ax.plot_surface(x,y,z,color="r",rstride=1,cstride=1,cmap="hot") plt.show()
7、opencv
7.1 打开并显示图片
import cv2
#读取本地文件
img = cv2.imread("1.jpg")
print(type(img))
print(img)
print(img.shape)
#显示图片
cv2.imshow("xh",img)
#阻塞等待任意按键 退出
cv2.waitKey(0)
#退出时销毁窗口
cv2.destroyAllWindows()
7.2 图片变换
由于img是彩色图片，人工智能需要灰度图片，所以需要转换
import cv2
#读取本地文件
img = cv2.imread("1.jpg")
print(type(img))
print(img)
print(img.shape)
# #显示图片
# cv2.imshow("xh",img)
#转为灰度图片
gr =cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
print(gr.shape)
# cv2.imshow("2",gr)
#改变大小
gr = cv2.resize(gr,(480,640))
cv2.imshow("2",gr)
#阻塞等待任意按键 退出
cv2.waitKey(0)
#退出时销毁窗口
cv2.destroyAllWindows()
7.3 抠图
import cv2
#读取本地文件 307.370 411 93
img = cv2.imread("1.jpg")
cv2.imshow("xh",img)
#抠图
eyes = img[370:370+93,307:307+411,:]
cv2.imshow("3",eyes)
#保存图片到本地
cv2.imwrite("eyes.jpg",eyes)
cv2.waitKey(0)
cv2.destroyAllWindows()
7.4 操作摄像头
import cv2
cap = cv2.VideoCapture(0)
if not cap.isOpened():
print("打开失败")
exit(0)
while True:
#读取一帧图片
ret,img= cap.read()
cv2.imshow("1",img)
#判断按下的按键是否为27（Esc），如果不是则等待5ms
if cv2.waitKey(5) ==27:
break
cv2.destroyAllWindows()
import cv2
cap = cv2.VideoCapture(0)
if not cap.isOpened():
print("打开失败")
exit(0)
while True:
#读取一帧图片
ret,img= cap.read()
#参数：text= 显示文本,org=(240,320) 文本位置,fontFace=cv2.FONT_HERSHEY_SIMPLEX 文本样式 ,fontScale=2 文字缩放,color=(0,170,0) 颜色,thickness=2 线条缩放
cv2.putText(img,text="hello",org=(240,320),fontFace=cv2.FONT_HERSHEY_SIMPLEX,fontScale=2,color=(30,170,0),thickness=2)
#绘制矩形框：pt1、pt2，对角线坐标
cv2.rectangle(img,pt1=(270,190),pt2=(370,290),color=(0,0,255),thickness=1)
cv2.imshow("1",img)
#判断按下的按键是否为27（Esc），如果不是则等待5ms
if cv2.waitKey(5) ==27:
break
cv2.destroyAllWindows()
7.5 opencv 人脸检测
opencv 人脸检测，实验opencv 提供人脸检测 模型
import cv2
path = "D:\\Anaconda3\\envs\\tf\\Library\\etc\\haarcascades\\haarcascade_frontalface_default.xml"
# 将本地模型文件加载到项目
model = cv2.CascadeClassifier(path)
cap = cv2.VideoCapture(0)
if not cap.isOpened():
print("打开失败")
exit(0)
while True:
ret,img= cap.read()
#由于该模型，要求图片必须是灰度图片，因此需要转灰度图片
gr = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
#将灰度图片送入模型检测,返回列表元素为，每个人脸的位置信息【x，y，w，h】
facelist = model.detectMultiScale(gr)
if len(facelist) <0:
print("未检测到人脸")
cv2.waitKey(100)
break
print(facelist)
for i in facelist:
x,y,w,h = i
cv2.rectangle(img, pt1=(x, y), pt2=(x+w, y+h), color=(0, 0, 255), thickness=1)
cv2.putText(img, text="hello", org=(x, y), fontFace=cv2.FONT_HERSHEY_SIMPLEX, fontScale=2,
color=(30, 170, 0), thickness=2)
cv2.imshow("1",img)
#判断按下的按键是否为27（Esc），如果不是则等待5ms
if cv2.waitKey(5) ==27:
break
cv2.destroyAllWindows()
人工智能理论
1、机器学习
1.1、基础
从数据中自动分析，获得规律（模型），并利用规律对未知数据进行预测。 学习框架： scikit、theano、飞桨
1910
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
