autohotkey更新2018-08-03,9点01
python
;把大写禁用了,因为确实基本不用.`表示删除,caplock+ijkl可以控制光标
SetCapsLockState , AlwaysOff
; caplock表示右,ctrl+caplock切换大小写
CapsLock::SendInput {Right} ;这样改就避免冲突了
CapsLock & l::Send {Right}
CapsLock & i::SendInput {up}
CapsLock & j::SendInput {left}
CapsLock & k::SendInput {down}
:*:;y::print(type()){left 2}
$`::BackSpace
$'::
send {'}
send {'}
send {left}
return
;send最稳的写法是每次send一个字符
$"::
send {"}
send {"}
send {left}
return
:?:;s::SELECT
!b::
run D:\新建文件夹 (4)xin\屏幕亮度调节小工具\屏幕亮度调节小工具.exe - 快捷方式
return
$+[::
send {{}
send {}}
send {left}
return
$+9::
send {(}
send {)}
send {left}
return
$[::
send {[}
send {]}
send {left}
return
:*:;r::return{space}
:*:;i::import{space}
:*:;p::print(){left}
:*:;e::exit(){enter}
:*:;b::break
:*:;c::continue
SetWinDelay, 10
#ClipboardTimeout 2000
;这个版本已经基本修复了输入括号等shift与切换中英文输入法之间的冲突
#s::Suspend ; 给一个热键指定挂起的开关功能。
#o::Pause
:*:;t::15122306087
:*:;b::
send,break
sleep,0.01
send,{Enter}
return
;使用技巧shift是+用多重Send,命令来实现多命令比如下面的按F4来写2维数组,之所以写的这么复杂就是因为剪贴板如果一个代码用多次必然出现bug:
;用()括起来来实现大范围复制:
;因为我括号替换写的不好,最好不要使用剪贴板:
;尽量用send 命令不会出现任何bug:
;写一下这个注释,这里winexist表示存在窗口,那么winclose就关闭,注意这里if括号里面要写return;
;不然他停不下来,继续跑,显然不行;
;这个处理比较麻烦,需要把这个py文件的打开方式的默认程序设置成idle.exe才行.然后写入这个run代码就ok了,总之用autohotkey写代码和快捷键都是锦上添花.:
;窗口命令的注意事项:
;这里面这个写法要注意:1.ifwin不能断开写. 2.后面窗口名字是windows最下排状态栏给的的名字
!q::
IfWinExist,射手影音播放器
{
WinWait,射手影音播放器
WinClose,射手影音播放器
return
}
else
{
run D:\Downloads\c++++++++\经典轻音乐精选\经典轻音乐精选gai.mp3
return
}
^b::Run www.baidu.com
^g::
IfWinExist, GoAgent v3.1.23
{
return
}
else
{
run D:\新建文件夹 (4)xin\goagent-3.0\local\goagent(1).exe
WinWait, GoAgent v3.1.23 ;这个代码是找到窗口
WinMove, 0, 0
;WinMinimize ; 使用上面找到的窗口进行最小化.所以自动实现了打开就最小化
return
}
^w::Run http://cn.bing.com/?FORM=Z9FD1
!p::
IfWinExist, 无标题 - 画图 ;注意这里面的标题名字就是打开程序里面写的标题,注意中间带空格.;这样写就控制了程序开关.
{
WinClose
return
}
else
{
run mspaint
return
}
!j::
IfWinExist, 计算器 ;注意这里面的标题名字就是打开程序里面写的标题,注意中间带空格.;
{
WinClose
return
}
else
{
run calc
return
}
!m::
IfWinExist, 计算器 ;注意这里面的标题名字就是打开程序里面写的标题,注意中间带空格.;
{
WinClose
return
}
else
{
run D:\新建文件夹 (4)xin\新建文件夹\音乐.mpcpl
return
}
!c::
IfWinExist, cmd.exe ;写一下这个注释,这里winexist表示存在窗口,那么winclose就关闭,注意这里if括号里面要写return;
;不然他停不下来,继续跑,显然不行;
{
WinClose,cmd.exe
return
}
else
{
run cmd
return
}
!n::
IfWinExist,语录.txt - 记事本
;不然他停不下来,继续跑,显然不行;
{
WinClose,语录.txt - 记事本
return
}
else
{
run d:\新建文件夹 (4)xin\语录.txt
return
}
!g::
IfWinExist,个人信息16 2 22.txt - 记事本
{
WinClose,个人信息16 2 22.txt - 记事本
return
}
else
{
run d:\新建文件夹 (4)xin\个人信息16 2 22.txt
return
}
!d::run d:\
return
!x::run D:\Downloads\视频区
return
^i::
send input() {enter}
return
:*:;m::[email protected]
^NumpadAdd::SoundSet , +1, WAVE
^NumpadSub::SoundSet , -1, WAVE
F3::
SetKeyDelay, 50
x=%clipboard%
d=.append()
clipboard=%d%
Send ^v
sleep,0.01
Send, {Left}
clipboard=%x%
return
F4::
SetKeyDelay, 50
x=%clipboard%
d=''''''
clipboard=%d%
Send ^v
sleep,0.01
clipboard=%x%
send {left 3}
send {enter}
send {enter}
send {up}
return
F1::
SetKeyDelay, 50
x=%clipboard%
d=for i in range(len()):
clipboard=%d%
Send ^v
sleep,0.01
Send, {Left 3}
clipboard=%x%
return
;使用方法是输入,xun然后空格
:*:lsit::list
:*:braek::break
:*:berak::break
:*:,rr::return{space}
:*:dfe::def
:*:retrun::return
:*:retunr::return
:*:calss::class
:*:slef::self
:*:slfe::self
:*:apend::append
:*:appedn::append
:*:contiune::continue
:*:contnue::continue
;下面为了java扩充的:
:*:;s::
SetKeyDelay, 50
x=%clipboard%
d=System.out.println();
clipboard=%d%
Send ^v
sleep,0.01
Send, {Left 2}
clipboard=%x%
return
!`::
SetKeyDelay, 50
x=%clipboard%
d=●
clipboard=%d%
Send ^v
sleep,0.01
clipboard=%x%
return
:*:'::
SetKeyDelay, 50
x=%clipboard%
d=''
clipboard=%d%
Send ^v
Send {Left}
sleep,0.01
clipboard=%x%
return
:*:;d::
SetKeyDelay, 50
x=%clipboard%
FormatTime, d, LongDate,yyyy-MM-dd,H点mm
;获得系统时间比如今天的时间：2007-10-21。如果需要“年”的话请替换上面的“-”。
clipboard = %d%
;把 d 的值发送到剪贴板，变量是不用声明的，想引用变量的值，就在变量的前后加“%”。第二行的变量是 AHK 自带的变量。
Send ^v
clipboard=%x%
return
^F1::
SetKeyDelay, 50
x=%clipboard%
d=for i in range():
clipboard = %d%
Send ^v
Send {LEFT 2}
clipboard=%x%
return
c语言
$+9::
SendInput {(}
SendInput {)}
SendInput {left}
return
CapsLock::SendInput {Right} ;这样改就避免冲突了
$'::
SendInput {'}
SendInput {'}
SendInput {left}
return
;send最稳的写法是每次send一个字符
$"::
SendInput {"}
SendInput {"}
SendInput {left}
return
:?:;s::SELECT
!b::
run C:\Users\张博\Desktop\屏幕亮度调节小工具\屏幕亮度调节小工具.exe
return
$+[::
send {{}
send {}}
send {left}
return
$[::
send {[}
send {]}
send {left}
return
SetWinDelay, 10
#ClipboardTimeout 2000
;这个版本已经基本修复了输入括号等shift与切换中英文输入法之间的冲突
#s::Suspend ; 给一个热键指定挂起的开关功能。
#o::Pause
:*:;t::15122306087
;使用技巧shift是+用多重Send,命令来实现多命令比如下面的按F4来写2维数组,之所以写的这么复杂就是因为剪贴板如果一个代码用多次必然出现bug:
;用()括起来来实现大范围复制:
;因为我括号替换写的不好,最好不要使用剪贴板:
;尽量用send 命令不会出现任何bug:
;写一下这个注释,这里winexist表示存在窗口,那么winclose就关闭,注意这里if括号里面要写return;
;不然他停不下来,继续跑,显然不行;
;这个处理比较麻烦,需要把这个py文件的打开方式的默认程序设置成idle.exe才行.然后写入这个run代码就ok了,总之用autohotkey写代码和快捷键都是锦上添花.:
;窗口命令的注意事项:
;这里面这个写法要注意:1.ifwin不能断开写. 2.后面窗口名字是windows最下排状态栏给的的名字
!q::
IfWinExist,射手影音播放器
{
WinWait,射手影音播放器
WinClose,射手影音播放器
return
}
else
{
run D:\Downloads\c++++++++\经典轻音乐精选\经典轻音乐精选gai.mp3
return
}
^b::Run www.baidu.com
^g::
IfWinExist, GoAgent v3.1.23
{
return
}
else
{
run D:\新建文件夹 (4)xin\goagent-3.0\local\goagent(1).exe
WinWait, GoAgent v3.1.23 ;这个代码是找到窗口
WinMove, 0, 0
;WinMinimize ; 使用上面找到的窗口进行最小化.所以自动实现了打开就最小化
return
}
^w::Run http://cn.bing.com/?FORM=Z9FD1
!p::
IfWinExist, 无标题 - 画图 ;注意这里面的标题名字就是打开程序里面写的标题,注意中间带空格.;这样写就控制了程序开关.
{
WinClose
return
}
else
{
run mspaint
return
}
!j::
IfWinExist, 计算器 ;注意这里面的标题名字就是打开程序里面写的标题,注意中间带空格.;
{
WinClose
return
}
else
{
run calc
return
}
!m::
IfWinExist, 计算器 ;注意这里面的标题名字就是打开程序里面写的标题,注意中间带空格.;
{
WinClose
return
}
else
{
run D:\新建文件夹 (4)xin\新建文件夹\音乐.mpcpl
return
}
!c::
IfWinExist, cmd.exe ;写一下这个注释,这里winexist表示存在窗口,那么winclose就关闭,注意这里if括号里面要写return;
;不然他停不下来,继续跑,显然不行;
{
WinClose,cmd.exe
return
}
else
{
run cmd
return
}
!n::
IfWinExist,语录.txt - 记事本
;不然他停不下来,继续跑,显然不行;
{
WinClose,语录.txt - 记事本
return
}
else
{
run d:\新建文件夹 (4)xin\语录.txt
return
}
!g::
IfWinExist,个人信息16 2 22.txt - 记事本
{
WinClose,个人信息16 2 22.txt - 记事本
return
}
else
{
run d:\新建文件夹 (4)xin\个人信息16 2 22.txt
return
}
!d::run d:\
return
!x::run D:\Downloads\视频区
return
^i::
send input() {enter}
return
:*:;m::[email protected]
^NumpadAdd::SoundSet , +1, WAVE
^NumpadSub::SoundSet , -1, WAVE
F3::
SetKeyDelay, 50
x=%clipboard%
d=printf("`%d",)`;
clipboard=%d%
Send ^v
sleep,0.01
Send, {Left 2}
clipboard=%x%
return
F4::
SetKeyDelay, 50
x=%clipboard%
d=/**/
clipboard=%d%
Send ^v
sleep,0.01
clipboard=%x%
send {left 2}
send {enter}
send {enter}
send {up}
return
;使用方法是输入,xun然后空格
:*:lsit::list
:*:braek::break
:*:berak::break
:*:,rr::return{space}
:*:dfe::def
:*:retrun::return
:*:retunr::return
:*:calss::class
:*:slef::self
:*:slfe::self
:*:apend::append
:*:appedn::append
:*:contiune::continue
:*:contnue::continue
^F1::
SetKeyDelay, 50
x=%clipboard%
d=while (1)`{`}
clipboard = %d%
Send ^v
Send {LEFT 1}
Send {Enter 2}
Send {up}
clipboard=%x%
return
!`::
SetKeyDelay, 50
x=%clipboard%
d=●
clipboard=%d%
Send ^v
sleep,0.01
clipboard=%x%
return
:*:'::
SetKeyDelay, 50
x=%clipboard%
d=''
clipboard=%d%
Send ^v
Send {Left}
sleep,0.01
clipboard=%x%
return
:*:;d::
SetKeyDelay, 50
x=%clipboard%
FormatTime, d, LongDate,yyyy-MM-dd,H点mm
;获得系统时间比如今天的时间：2007-10-21。如果需要“年”的话请替换上面的“-”。
clipboard = %d%
;把 d 的值发送到剪贴板，变量是不用声明的，想引用变量的值，就在变量的前后加“%”。第二行的变量是 AHK 自带的变量。
Send ^v
clipboard=%x%
return
;`是转义字符
F1::
SetKeyDelay, 50
x=%clipboard%
d=for (int i=1;i<=n;i++) `{`}
clipboard = %d%
Send ^v
Send {left}
Send {enter 2}
Send {up}
clipboard=%x%
return
python模板:
读写模板:
#下面这一段用一个txt来保存input的信息来模拟input.最后提交代码时候删除这一段即可.
a9999=open('1.txt','r')
def input():
return a9999.readline().rstrip('\n')
#结束.
# -*- coding: utf-8 -*-
"""
Created on Fri Jul 20 10:58:02 2018
@author: 张博
"""
'''
读取csv最稳的方法:
f=open(r'C:/Users/old.csv')
data = read_csv(f,header=None)
'''
'''
画图模板:
from matplotlib import pyplot
data=[]
pyplot.plot(data,color='black')
pyplot.show()
'''
'''
获取当前时间:
import datetime
nowTime=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')#现在
nowTime=((nowTime)[:-3])
print(nowTime)
'''
'''
写文件的模板
with open(r'c:/234/wucha.txt','w') as f:
wucha=str(wucha)
f.write(wucha)
'''
'''
手动加断电的方法:raise
'''
'''
excel表格实用技巧:
全选然后选开始-行和列-最适合的列宽.
这样看表格清晰多了!
'''
'''
时间序列画图
from matplotlib import pyplot
#画布大小
pyplot.rcParams['figure.figsize'] = (300, 3) # 设置figure_size尺寸
import matplotlib.dates as mdates
ax=plt.gca()
pyplot.rcParams['image.cmap'] = 'gray' #
xfmt = mdates.DateFormatter('%y-%m-%d %H:%M')
ax.xaxis.set_major_formatter(xfmt)
#下面这个是时间序列的间隔时间
plt.xticks(pd.date_range(data[0][0],data[-1][0],freq='2H'),rotation=90)
#样式
pyplot.plot(data[:,0],data[:,1],color='red',linewidth = 0.7)
pyplot.show()
'''
# -*- coding: utf-8 -*-
"""
Created on Fri Jul 20 10:58:02 2018
#如果跑不了就是编码问题,用记事本另存一下,把编码改成utf-8保存即可.
#利用cmd跑这种画图程序,就能旋转图片了.spyder不能旋转
@author: 张博
"""
'''
读取csv最稳的方法:
f=open(r'C:/Users/old.csv')
data = read_csv(f,header=None)
'''
'''
画图模板:
from matplotlib import pyplot
data=[]
pyplot.plot(data,color='black')
pyplot.show()
'''
'''
获取当前时间:
import datetime
nowTime=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')#现在
nowTime=((nowTime)[:-3])
print(nowTime)
'''
'''
写文件的模板
with open(r'c:/234/wucha.txt','w') as f:
wucha=str(wucha)
f.write(wucha)
'''
'''
手动加断电的方法:raise
'''
'''
excel表格实用技巧:
全选然后选开始-行和列-最适合的列宽.
这样看表格清晰多了!
'''
'''
时间序列画图
from matplotlib import pyplot
#画布大小
pyplot.rcParams['figure.figsize'] = (300, 3) # 设置figure_size尺寸
import matplotlib.dates as mdates
ax=plt.gca()
pyplot.rcParams['image.cmap'] = 'gray' #
xfmt = mdates.DateFormatter('%y-%m-%d %H:%M')
ax.xaxis.set_major_formatter(xfmt)
#下面这个是时间序列的间隔时间
plt.xticks(pd.date_range(data[0][0],data[-1][0],freq='2H'),rotation=90)
#样式
pyplot.plot(data[:,0],data[:,1],color='red',linewidth = 0.7)
pyplot.show()
'''
'''
#画3d
import matplotlib.font_manager as fm
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import pyplot
pyplot.rcParams['figure.figsize'] = (3, 3) # 设置figure_size尺寸
fig=plt.figure()
ax3d=Axes3D(fig) #绘制3D图形
ax3d.scatter(data[:,1],data[:,2],data[:,0],c='r',marker=".")
pyplot.show()
'''
'''
非数值编码
#编码
from sklearn.preprocessing import LabelEncoder
a=a.values #切换成ndarry
encoder = LabelEncoder()
for i in range(5):
a[:,i] = encoder.fit_transform(a[:,i])
'''
'''
#标准化
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler(feature_range=(0, 1))
a = scaler.fit_transform(a)
print(a)
'''
'''
降维可视化:
from sklearn.manifold import TSNE
#data可以是多少维都可以,都能降成2维
tsne=TSNE()
tsne.fit_transform(data) #进行数据降维,降成两维
#a=tsne.fit_transform(data_zs) #a是一个array,a相当于下面的tsne_embedding_
tsne=pd.DataFrame(tsne.embedding_) #转换数据格式
print(tsne)
tsne['聚类类别']=label_pred
print(tsne)
d=tsne[tsne[u'聚类类别']==0]
plt.plot(d[0],d[1],'r.')
d=tsne[tsne[u'聚类类别']==1]
plt.plot(d[0],d[1],'go')
d=tsne[tsne[u'聚类类别']==2]
plt.plot(d[0],d[1],'b*')
d=tsne[tsne[u'聚类类别']==3]
plt.plot(d[0],d[1],'y+')
plt.show()
'''
# -*- coding: utf-8 -*-
"""
Spyder Editor
This is a temporary script file.
"""
# -*- coding: utf-8 -*-
"""
Created on Fri Jul 20 10:58:02 2018
#如果跑不了就是编码问题,用记事本另存一下,把编码改成utf-8保存即可.
#3d图片利用cmd跑这种画图程序,就能旋转图片了.spyder不能旋转
@author: 张博
"""
'''
读取csv最稳的方法:
import pandas as pd
f = open('/Users/michael/gbk.csv', 'r', encoding='gbk', errors='ignore')
data = pd.read_csv(f,header=None)
'''
'''
画图模板:
from matplotlib import pyplot
data=[]
pyplot.plot(data,color='black')
pyplot.show()
'''
'''
获取当前时间:
import datetime
nowTime=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')#现在
nowTime=((nowTime)[:-3])
print(nowTime)
'''
'''
写文件的模板
with open(r'c:/234/wucha.txt','w') as f:
wucha=str(wucha)
f.write(wucha)
'''
'''
手动加断电的方法:raise
'''
'''
excel表格实用技巧:
全选然后选开始-行和列-最适合的列宽.
这样看表格清晰多了!
'''
'''
时间序列画图
from matplotlib import pyplot
#画布大小
pyplot.rcParams['figure.figsize'] = (300, 3) # 设置figure_size尺寸
import matplotlib.dates as mdates
ax=plt.gca()
pyplot.rcParams['image.cmap'] = 'gray' #
xfmt = mdates.DateFormatter('%y-%m-%d %H:%M')
ax.xaxis.set_major_formatter(xfmt)
#下面这个是时间序列的间隔时间
plt.xticks(pd.date_range(data[0][0],data[-1][0],freq='2H'),rotation=90)
#样式
pyplot.plot(data[:,0],data[:,1],color='red',linewidth = 0.7)
pyplot.show()
'''
'''
#画3d
import matplotlib.font_manager as fm
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import pyplot
pyplot.rcParams['figure.figsize'] = (3, 3) # 设置figure_size尺寸
fig=plt.figure()
ax3d=Axes3D(fig) #绘制3D图形
ax3d.scatter(data[:,1],data[:,2],data[:,0],c='r',marker=".")
pyplot.show()
'''
'''
非数值编码
#编码
from sklearn.preprocessing import LabelEncoder
a=a.values #切换成ndarry
encoder = LabelEncoder()
for i in range(5):
a[:,i] = encoder.fit_transform(a[:,i])
'''
'''
#标准化
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler(feature_range=(0, 1))
a = scaler.fit_transform(a)
print(a)
'''
'''
降维可视化:
from sklearn.manifold import TSNE
#data可以是多少维都可以,都能降成2维
tsne=TSNE()
tsne.fit_transform(data) #进行数据降维,降成两维
#a=tsne.fit_transform(data_zs) #a是一个array,a相当于下面的tsne_embedding_
tsne=pd.DataFrame(tsne.embedding_) #转换数据格式
print(tsne)
tsne['聚类类别']=label_pred
print(tsne)
d=tsne[tsne[u'聚类类别']==0]
plt.plot(d[0],d[1],'r.')
d=tsne[tsne[u'聚类类别']==1]
plt.plot(d[0],d[1],'go')
d=tsne[tsne[u'聚类类别']==2]
plt.plot(d[0],d[1],'b*')
d=tsne[tsne[u'聚类类别']==3]
plt.plot(d[0],d[1],'y+')
plt.show()
#map基本用法:另外一个就是reduce,把上一步的结果迭代到写一个.比较花哨.不写了
a=map(str,[1,2,3,4])
b=[print(type(i)) for i in a]
#从下面这个看出来如果列表生成式即List Comprehensions 里面的套用函数是一个无返回值的,那么就返回None
#b的触发效果就是打印这些type,这个写法很方便,比for循环方便多了.
print(b)
'''
'''
#sort基本用法
print(sorted([36, 5, -12, 9, -21], key=abs))
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower))
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True))
#lambda函数:
list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
'''
'''
#装饰器例子:给now函数加一个功能,调用之前打印这个函数的名字.
def log(func):
def wrapper(*args, **kw):
print('call %s():' % func.__name__)
return func(*args, **kw)
return wrapper
@log
def now():
print('2015-3-25')
now()
#偏函数:把一个函数传好参数之后定义为一个新的函数
def int2(x, base=2):
return int(x, base)
print(int2('1011010'))
'''
'''
给实例加一个方法和给类加一个方法:
class Student(object):
pass
s = Student()
def set_age(self, age): # 定义一个函数作为实例方法
self.age = age
from types import MethodType
s.set_age = MethodType(set_age, s) # 给实例绑定一个方法
s.set_age(25) # 调用实例方法
print(s.age)
#下面是给类加一个方法,直接=赋值即可,一上这两种动态加入方法的方法教动态方法.
def set_score(self, score):
self.score = score
Student.set_score = set_score
s.set_score(100)
print(s.score)
#限制实例加入的方法:slot函数,只能加入name和age两个函数
bb
class Student(object):
__slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称
def set_score(self, score):
self.score = score
Student.set_score = set_score
s=Student()
s.set_score(3)
print(s.score)
'''
'''
property函数:
class Student(object):
@property #利用property和 .setter,函数来实现对函数变量的检查.
def score(self):
return self._score
@score.setter
def score(self, value):
if not isinstance(value, int):
raise ValueError('score must be an integer!')
if value < 0 or value > 100:
raise ValueError('score must between 0 ~ 100!')
self._score = value
a=Student()
a.score=324.4
print(a.score)
'''
'''
#json和字典互转
import json
d = dict(name='Bob', age=20, score=88)
print(json.dumps(d))
json_str=json.dumps(d)
print(json.loads(json_str))
print(type(json.loads(json_str)))
'''
'''
总结一下就是，多任务的实现有3种方式：
多进程模式；
多线程模式；
多进程+多线程模式。
'''
'''
多进程
#奇怪用cmd就能跑这个程序,spyder就不行
from multiprocessing import Pool
import os, time, random
def long_time_task(name):
print('Run task %s (%s)...' % (name, os.getpid()))
start = time.time()
time.sleep(random.random() * 3)
end = time.time()
print('Task %s runs %0.2f seconds.' % (name, (end - start)))
if __name__=='__main__':
print('Parent process %s.' % os.getpid())
p = Pool(4) #多个进程的书写用pool管理更方便,不然需要很多的join很烦
for i in range(5):
p.apply_async(long_time_task, args=(i,))
print('Waiting for all subprocesses done...')
p.close() #必须在join前面写上关闭pool
p.join() #表示Pool里面的子进程都跑完了,才开始运行下面的代码.
print('All subprocesses done.')
#用queue来做两个进程之间的通信.
from multiprocessing import Process, Queue
import os, time, random
def write(q):
print('Process to write: %s' % os.getpid())
for value in ['A', 'B', 'C']:
print('Put %s to queue...' % value)
q.put(value)
time.sleep(random.random())
# 读数据进程执行的代码:
def read(q):
print('Process to read: %s' % os.getpid())
while True:
value = q.get(True)
print('Get %s from queue.' % value)
if __name__=='__main__':
# 父进程创建Queue，并传给各个子进程：
q = Queue()
pw = Process(target=write, args=(q,))
pr = Process(target=read, args=(q,))
# 启动子进程pw，写入:
pw.start()
# 启动子进程pr，读取:
pr.start()
# 等待pw结束:
pw.join()
# pr进程里是死循环，无法等待其结束，只能强行终止:
pr.terminate()
'''
'''
#线程之间共用类,用xxx=threading.local()创建.
import threading
# 创建全局ThreadLocal对象: 本质是线程都共享这个类,然后每个线程的对象是这个类的一个对象
#用字典实现的,对象=字典[线程号]
local_school = threading.local()
def process_student():
# 获取当前线程关联的student:
std = local_school.student
print('Hello, %s (in %s)' % (std, threading.current_thread().name))
print(threading.current_thread())
def process_thread(name):
# 绑定ThreadLocal的student:
local_school.student = name
process_student()
t1 = threading.Thread(target= process_thread, args=('Alice',), name='Thread-A')
#比如t1这个线程:先进入process_thread函数,然后进入process_student函数.
#因为local_school是thread.local的资源,所以不同线程之间不共享.
t2 = threading.Thread(target= process_thread, args=('Bob',), name='Thread-B')
t1.start()
t2.start()
t1.join()
t2.join()
'''
'''
用异步IO编程模型来实现多任务是一个主要的趋势。
对应到Python语言，单线程的异步编程模型称为协程，有
了协程的支持，就可以基于事件驱动编写高效的多任务程序。我们会在后面讨论如何编写协程。
'''
'''
对于未知编码的bytes，要把它转换成str，需要先“猜测”编码。猜测的方式是先收集各种编码的
特征字符，根据特征字符判断，就能有很大概率“猜对”。
当然，我们肯定不能从头自己写这个检测编码的功能，这样做费时费力。chardet这个第三方库正好
就派上了用场。用它来检测编码，简单易用。
import chardet
data = '离离原上草，一岁一枯荣'.encode('utf-8')
print(chardet.detect(data))
'''
'''
#python 运维
物理内存(RAM)指的是RAM(即内存条)提供的临时数据存储空间
交换区指Unix/Linux系统前台与后台之间数据交换的场所，即为Unix/Linux系统的虚拟内存
虚拟内存泛指将临时数据存储于磁盘存储器上的技术(简单点说就是划出一部分磁盘作为临时的R
AM)，Windows系统的“虚拟内存”，Linux系统的“交换区”都是虚拟内存
import psutil
print(psutil.cpu_count()) # CPU逻辑数量)
print(psutil.cpu_count(logical=False))# CPU物理核心
print(psutil.cpu_times())
#再实现类似top命令的CPU使用率，每秒刷新一次，累计10次：
for x in range(1):
print(psutil.cpu_percent(interval=1, percpu=True))
print(psutil.virtual_memory())
print(psutil.swap_memory())
print(psutil.disk_partitions())
print(psutil.disk_usage('/'))
print(psutil.disk_io_counters())
print(psutil.net_io_counters() )
print(psutil.net_if_addrs())
print(psutil.pids())
print(psutil.test())
'''
'''
网络通信:
网络通信是两台计算机上的两个进程之间的通信。
端口有什么作用？在两台计算机通信时，只发IP地址是不够的，因为同一台计算机上跑着多个网络
程序。一个TCP报文来了之后，到底是交给浏览器还是QQ，就需要端口号来区分。每个网络程序都向
操作系统申请唯一的端口号，这样，两个进程在两台计算机之间建立网络连接就需要各自的IP地址和
各自的端口号。
#TCP,UDP就是用socket!来实现的.
#TCP编程服务端:
import threading
import socket
import time
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#SOCK_STREAM表示TCP
# 监听端口:
s.bind(('127.0.0.1', 9999)) #跟下面的客户端端口要一致.
s.listen(5)#传入的参数指定等待连接的最大数量：
print('Waiting for connection...')
#每个连接都必须创建新线程(或进程)来处理，否则，单线程在处理连接的过程中，无法接受其他客户端的连接：
def tcplink(sock, addr):
print('Accept new connection from %s:%s...' % addr)
sock.send(b'Welcome!')
while True:
data = sock.recv(1024)
time.sleep(1)
if not data or data.decode('utf-8') == 'exit':
break
sock.send(('Hello, %s!' % data.decode('utf-8')).encode('utf-8'))
sock.close()
print('Connection from %s:%s closed.' % addr)
while True:
# 接受一个新连接:
sock, addr = s.accept()
# 创建新线程来处理TCP连接:
t = threading.Thread(target=tcplink, args=(sock, addr))
t.start()
#TCP配套客户端:
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 建立连接:
s.connect(('127.0.0.1', 9999))
# 接收欢迎消息:
print(s.recv(1024).decode('utf-8'))
for data in [b'Michael', b'Tracy', b'Sarah']:
# 发送数据:
s.send(data)
print(s.recv(1024).decode('utf-8'))
s.send(b'exit')
s.close()
'''
'''
UDP的通信写法:使用UDP协议时，不需要建立连接，只需要知道对方的IP地址和端口号，
就可以直接发数据包。但是，能不能到达就不知道了。
#UDP服务器的写法.
import threading
import socket
import time
#SOCK_DGRAM表示UDP
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 绑定端口:
s.bind(('127.0.0.1', 9999))
print('Bind UDP on 9999...')
while True:
# 接收数据:
data, addr = s.recvfrom(1024)
print('Received from %s:%s.' % addr)
s.sendto(b'Hello, %s!' % data, addr)
#UDP客户端
import threading
import socket
import time
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
for data in [b'Michael', b'Tracy', b'Sarah']:
# 发送数据:
s.sendto(data, ('127.0.0.1', 9999))
# 接收数据:
print(s.recv(1024).decode('utf-8'))
s.close()
'''
'''
数据库
一行记录可以对应一个表.就叫关联性数据库.
import sqlite3
# 如果文件不存在，会自动在当前目录创建:
conn = sqlite3.connect('test.db')
# 创建一个Cursor:
cursor = conn.cursor()
# 执行一条SQL语句，创建user表:
cursor.execute('create table user (id varchar(20) primary key, name varchar(20))')
# 继续执行一条SQL语句，插入一条记录:
cursor.execute('insert into user (id, name) values (\'1\', \'Michael\')')
# 通过rowcount获得插入的行数:
print(cursor.rowcount)
# 关闭Cursor:
cursor.close()
# 提交事务:
conn.commit()
# 关闭Connection:
conn.close()
conn = sqlite3.connect('test.db')
cursor = conn.cursor()
cursor.execute('select * from user where id=?', ('1',))
values = cursor.fetchall()
print(values)
'''
'''
#mysql安装:pip install mysql-connector
import mysql.connector
#默认是没有密码的
conn = mysql.connector.connect(user='root', password='', database='test')
cursor = conn.cursor()
#简历一个叫user的表
cursor.execute('create table user (id varchar(20) primary key, name varchar(20))')
cursor.execute('insert into user (id, name) values (%s, %s)', ['1', 'Michael'])
print(cursor.rowcount)
conn.commit() #提交操作
cursor.close()
cursor = conn.cursor()
cursor.execute('select * from user where id = %s', ('1',))
values = cursor.fetchall()
print(values)
cursor.close()
conn.close()
'''
'''
在Python中，最有名的ORM框架是SQLAlchemy。我们来看看SQLAlchemy的用法。
作用就是读取数据的每一行为一个object对象.
# 导入:
from sqlalchemy import Column, String, create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
# 创建对象的基类:
Base = declarative_base()
# 定义User对象:
class User(Base):
# 表的名字:
__tablename__ = 'user'
# 表的结构:
id = Column(String(20), primary_key=True)
name = Column(String(20))
# 初始化数据库连接:
engine = create_engine('mysql+mysqlconnector://root:@localhost:3306/test')
# 创建DBSession类型:
DBSession = sessionmaker(bind=engine)
#添加操作
# 创建session对象:
session = DBSession()
# 创建新User对象:
new_user = User(id='5', name='Bob')
# 添加到session:
session.add(new_user)
# 提交即保存到数据库:
session.commit()
# 关闭session:
session.close()
#查询操作
# 创建Session:
session = DBSession()
# 创建Query查询，filter是where条件，最后调用one()返回唯一行，如果调用all()则返回所有行:
user = session.query(User).filter(User.id=='5').one()
# 打印类型和对象的name属性:
print('type:', type(user))
print('name:', user.name)
# 关闭Session:
session.close()
'''
'''
异步
看起来A、B的执行有点像多线程，但协程的特点在于是一个线程执行，那和多线程比，协程有何优势？
最大的优势就是协程极高的执行效率。因为子程序切换不是线程切换，而是由程序自身控制，因此，没有
线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。
第二大优势就是不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享
资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。
'''
'''
#协成例子
def consumer():
r = ''
while True:
n = yield r
if not n:
return
print('[CONSUMER] Consuming %s...' % n)
r = '200 OK'
def produce(c):
c.send(None)
n = 0
while n < 5:
n = n + 1
print('[PRODUCER] Producing %s...' % n)
r = c.send(n)
print('[PRODUCER] Consumer return: %s' % r)
c.close()
c = consumer()
#c是生成器他有方法send,发送...到c里面
produce(c)
#上来是用None给c这个生成器,然后生成一个'',
#yield触发后就返回了,之后继续运行procduce,一直到下一个send
#之后又调回到consumer上一次调回的地方,继续跑.所以就判定if....
#最后运行c.close(),把生成器c关闭.不关闭也一样.
#异步io框架,两个任务同时打印同时等待
import threading
import asyncio
@asyncio.coroutine
def hello():
print('Hello world! (%s)' % threading.currentThread())
yield from asyncio.sleep(1)
print('Hello again! (%s)' % threading.currentThread())
loop = asyncio.get_event_loop()
tasks = [hello(), hello()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
'''
os.path.splitext()可以直接让你得到文件扩展名，很多时候非常方便：
>>> os.path.splitext('/path/to/file.txt')
('/path/to/file', '.txt')C模板
#include
#include
#include
#include
#include
#include
#include
using namespace std;
#include
#include
//数组的length函数需要自己实现!
template
int length(T& data)
{
return sizeof(data)/sizeof(data[0]);
}
class Solution {
public:
int removeDuplicates(vector& nums) {
if (nums.empty()) return 0;
int index = 0;
for (int i = 1; i < nums.size(); i++) {
if (nums[index] != nums[i])
nums[++index] = nums[i];
}
return index + 1;
}
};
int main(){
//定义vector
int data[]={2,45,7,8,9,23,4,6,7,8,0};
cout< b;
cout<
Java模板: 读写,for循环,switch,if,random模块.
读写模板:
Scanner scanner = new Scanner(System.in);
System.out.print("第一个数字：num1 = ");
int num1 = scanner.nextInt();
if (num1==num2) {} else {}
switch (num)
{
case 10:
System.out.println(111);
default:
System.out.println(999);
}
while(true){
}
for(int i = 0; i < aa.length; i++){
System.out.println();
}
for(int i = 0; i < aa.length; i++){
for(int j = 0; j < aa[i].length; j++){
System.out.print(aa[i][j] + " ");
}
System.out.println();
}
random模块
import java.util.Random;
int first = new Random().nextInt(fristName.length);
int second = new Random().nextInt(secondName.length);
return fristName[first] + secondName[second];
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
class Person
{
int age=20;
}
Person p2=new Person();
p2.age=30;
{Person p1=new Person();p2=p1;}
{System.out.println(p2.age);}
}
}
用sublime写js
https://blog.csdn.net/lyn167/article/details/51924032
廖雪峰的博客,写的很详细
https://www.liaoxuefeng.com/category/0013738748248885ddf38d8cd1b4803aa74bcda32f853fd000
集合:
#集合
b=set()
'''
1．增加操作 add
2．删除操作(remove,discard,pop)
3．清空(clear)
4．交集&，并集|，差集-，对称差集^，子集(被包含)<=，父集(包含)>=
'''
队列:
#队列
import queue
'''
a=queue.Queue()
queue.qsize() 返回队列的大小
queue.empty() 如果队列为空，返回True,反之False
queue.full() 如果队列满了，返回True,反之False
queue.full 与 maxsize 大小对应
queue.put(item) 写入队列，timeout等待时间
双短队列:
'''
#双端队列
from collections import deque
'''
1. A=deque([]) #创建一个空的双队列
2. A.append(n) #从右边像队列中增加元素 ，n表示增加的元素
3. A.appendleft(n) #从左边像队列中增加元素，n表示增加的元素
4. A.clear() #清空队列
5. A.count(n) #在队列中统计元素的个数，n表示统计的元素
6. A.extend(n) #从右边扩展队列，n表示扩展的队列
7. A.extendleft(n) #从左边扩展队列，n表示扩展的队列
8. A.pop() #从队列的右边删除元素，并且返回删除值
9. A.popleft() #从队列的左边删除元素，并且返回删除值
10. A.remove(n) #从队列中删除指定的值
11. A.reverse() #翻转队列
12. A.rotate(n) #旋转队列，默认时值为1，由右边开始旋转，
负值代表左边旋转，n代表从队列的第一个元素开始，n从1开始计数
'''
OS模块:
Python os模块常用函数详解
os.name #返回当前使用平台的代表字符，Windows用'nt'表示，Linux用'posix'表示
os.getcwd() #返回当前工作目录
os.listdir(path) #返回path目录下所有文件列表
os.path.abspath(path) #返回path的绝对路径
os.rename(old_path_with_name,new_path_with_name) #重命名到一个目录
os.system() #运行shell命令
>>>os.system('cmd') #Windows下打开终端
>>>os.system('ls') #Linux下查看当前目录所有文件
os.path.split(path) #将path的目录和文件名分开为元组
os.path.join(path1,path2,...) #将path1，怕path2，...进行组合，若path2为绝对路径，则会将path1删除
os.path.dirname(path) #返回path中的目录(文件夹部分)，结果不包含'\'
os.path.basename(path) #返回path中的文件名
os.mkdir(path) #创建path目录(只能创建一级目录，如'F:\XXX\WWW'),在XXX目录下创建WWW目录
os.makedirs(path) #创建多级目录(如'F:\XXX\SSS')，在F盘下创建XXX目录，继续在XXX目录下创建SSS目录
os.remove(path) #删除文件(必须是文件)
os.rmdir(path) #删除path目录(只能删除一级目录，如'F:\XXX\SSS'),只删除SSS目录
os.removedirs(path) #删除多级目录(如'F:\XXX\SSS'),必须为空目录，删除SSS、FFF目录
os.chdir(path) #将当前工作目录更改为指定路径path
os.path.getmtime(path) #返回文件或目录的最后修改时间，结果为秒数
os.path.getatime(path) #返回文件或目录的最后访问时间，结果为秒数
os.path.getctime(path) #返回文件或目录得创建时间，结果为秒数
os.path.getsize(path) #返回文件的大小，若是目录则返回0
os.path.exists(path) #判断path是否存在，存在返回True,不存在返回False
os.path.isfile(path) #判断path是否为文件，是返回True,不是返回False
os.path.isdir(path) #判断path是否目录，是返回True，不是返回False
os.sep #返回当前操作系统特定的路径分隔符
os.linesep #返回当前平台使用的行终止符
os.extsep #返回文件名与扩展名的分隔符
os.walk(path) #递归返回path下的目录(包括path目录)、子目录、文件名的三元组
fp=os.popen(cmd) #打开命令cmd或从命令cmd打开管道，返回值是连接到管道的文件对象
rlt=fp.read()或 rlt=fp.readlines() #读取结果
获得文件目录#下面挨个文件层次拼接
base_img_path=os.path.abspath(os.path.join(os.getcwd(), ".."))
base_img_path=os.path.abspath(os.path.join(base_img_path, ".."))
base_img_path=os.path.abspath(os.path.join(base_img_path, "data"))
Randos模块:
#random模块:
random.random()用于生成一个0到1的随机符点数: 0 <= n < 1.0
random.uniform(a, b)，用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。
random.randint(a, b)，用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b
random.randrange([start], stop[, step])，从指定范围内，按指定基数递增的集合中 获取一个随机整数。
random.choice(["JGood", "is", "a", "handsome", "boy"])
random.shuffle(x[, random])，用于将一个列表中的元素打乱。
slice = random.sample(list1, 5) # 从list中随机获取5个元素，作为一个片断返回
pands 用法大全:
pandas用法大全:
https://blog.csdn.net/liufang0001/article/details/77856255
1.合并:concat命令:
1.最实用的按行遍历,做修改:
#修改值必须这么改,把行列都写loc里面才行
for i in range(len(a)):
if a.loc[i,'DD'] in [1,2,8,9,15,16,22,23,29,30]:
a.loc[i,'holiday']=1
1.frames = [df1, df2, df3] 2.result = pd.concat(frames)
2017年09月05日 21:01:40
阅读数：60255
●添加一列:data['C']=None
#pandas 提取多列
data=dataframe[['Sum','holiday']]
一、生成数据表
1、首先导入pandas库，一般都会用到numpy库，所以我们先导入备用：
import numpy as np import pandas as pd
2、导入CSV或者xlsx文件：
df = pd.DataFrame(pd.read_csv('name.csv',header=1)) df = pd.DataFrame(pd.read_excel('name.xlsx'))
3、用pandas创建数据表：
df = pd.DataFrame({"id":[1001,1002,1003,1004,1005,1006], "date":pd.date_range('20130102', periods=6), "city":['Beijing ', 'SH', ' guangzhou ', 'Shenzhen', 'shanghai', 'BEIJING '], "age":[23,44,54,32,34,32], "category":['100-A','100-B','110-A','110-C','210-A','130-F'], "price":[1200,np.nan,2133,5433,np.nan,4432]}, columns =['id','date','city','category','age','price'])
2、数据表信息查看
1、维度查看：
df.shape
2、数据表基本信息(维度、列名称、数据格式、所占空间等)：
df.info()
3、每一列数据的格式：
df.dtypes
4、某一列格式：
df['B'].dtype
5、空值：
df.isnull()
6、查看某一列空值：
df.isnull()
7、查看某一列的唯一值：
df['B'].unique()
8、查看数据表的值：
df.values
9、查看列名称：
df.columns
10、查看前10行数据、后10行数据：
df.head() #默认前10行数据 df.tail() #默认后10 行数据
三、数据表清洗
1、用数字0填充空值：
df.fillna(value=0)
2、使用列prince的均值对NA进行填充：
df['prince'].fillna(df['prince'].mean())
3、清楚city字段的字符空格：
df['city']=df['city'].map(str.strip)
4、大小写转换：
df['city']=df['city'].str.lower()
5、更改数据格式：
df['price'].astype('int')
6、更改列名称：
df.rename(columns={'category': 'category-size'})
7、删除后出现的重复值：
df['city'].drop_duplicates()
8、删除先出现的重复值：
df['city'].drop_duplicates(keep='last')
9、数据替换：
df['city'].replace('sh', 'shanghai')
四、数据预处理
df1=pd.DataFrame({"id":[1001,1002,1003,1004,1005,1006,1007,1008], "gender":['male','female','male','female','male','female','male','female'], "pay":['Y','N','Y','Y','N','Y','N','Y',], "m-point":[10,12,20,40,40,40,30,20]})
1、数据表合并
df_inner=pd.merge(df,df1,how='inner') # 匹配合并，交集 df_left=pd.merge(df,df1,how='left') # df_right=pd.merge(df,df1,how='right') df_outer=pd.merge(df,df1,how='outer') #并集
2、设置索引列
df_inner.set_index('id')
3、按照特定列的值排序：
df_inner.sort_values(by=['age'])
4、按照索引列排序：
df_inner.sort_index()
5、如果prince列的值>3000，group列显示high，否则显示low：
df_inner['group'] = np.where(df_inner['price'] > 3000,'high','low')
6、对复合多个条件的数据进行分组标记
df_inner.loc[(df_inner['city'] == 'beijing') & (df_inner['price'] >= 4000), 'sign']=1
7、对category字段的值依次进行分列，并创建数据表，索引值为df_inner的索引列，列名称为category和size
pd.DataFrame((x.split('-') for x in df_inner['category']),index=df_inner.index,columns=['category','size']))
8、将完成分裂后的数据表和原df_inner数据表进行匹配
df_inner=pd.merge(df_inner,split,right_index=True, left_index=True)
五、数据提取
主要用到的三个函数：loc,iloc和ix，loc函数按标签值进行提取，iloc按位置进行提取，ix可以同时按标签和位置进行提取。
1、按索引提取单行的数值
df_inner.loc[3]
2、按索引提取区域行数值
df_inner.iloc[0:5]
3、重设索引
df_inner.reset_index()
4、设置日期为索引
df_inner=df_inner.set_index('date')
5、提取4日之前的所有数据
df_inner[:'2013-01-04']
6、使用iloc按位置区域提取数据
df_inner.iloc[:3,:2] #冒号前后的数字不再是索引的标签名称，而是数据所在的位置，从0开始，前三行，前两列。
7、适应iloc按位置单独提起数据
df_inner.iloc[[0,2,5],[4,5]] #提取第0、2、5行，4、5列
8、使用ix按索引标签和位置混合提取数据
df_inner.ix[:'2013-01-03',:4] #2013-01-03号之前，前四列数据
9、判断city列的值是否为北京
df_inner['city'].isin(['beijing'])
10、判断city列里是否包含beijing和shanghai，然后将符合条件的数据提取出来
df_inner.loc[df_inner['city'].isin(['beijing','shanghai'])]
11、提取前三个字符，并生成数据表
pd.DataFrame(category.str[:3])
六、数据筛选
使用与、或、非三个条件配合大于、小于、等于对数据进行筛选，并进行计数和求和。
1、使用“与”进行筛选
df_inner.loc[(df_inner['age'] > 25) & (df_inner['city'] == 'beijing'), ['id','city','age','category','gender']]
2、使用“或”进行筛选
df_inner.loc[(df_inner['age'] > 25) | (df_inner['city'] == 'beijing'), ['id','city','age','category','gender']].sort(['age'])
3、使用“非”条件进行筛选
df_inner.loc[(df_inner['city'] != 'beijing'), ['id','city','age','category','gender']].sort(['id'])
4、对筛选后的数据按city列进行计数
df_inner.loc[(df_inner['city'] != 'beijing'), ['id','city','age','category','gender']].sort(['id']).city.count()
5、使用query函数进行筛选
df_inner.query('city == ["beijing", "shanghai"]') !这个是最实用的函数比如:
a=tmp.query('HH == ["1", "2"]' and 'MI == ["1", "2"]') #真正赛选应该用这个函数query.就可以实现复杂赛选
6、对筛选后的结果按prince进行求和
df_inner.query('city == ["beijing", "shanghai"]').price.sum()
七、数据汇总
主要函数是groupby和pivote_table
1、对所有的列进行计数汇总
df_inner.groupby('city').count()
2、按城市对id字段进行计数
df_inner.groupby('city')['id'].count()
3、对两个字段进行汇总计数
df_inner.groupby(['city','size'])['id'].count()
4、对city字段进行汇总，并分别计算prince的合计和均值
df_inner.groupby('city')['price'].agg([len,np.sum, np.mean])
八、数据统计
数据采样，计算标准差，协方差和相关系数
1、简单的数据采样
df_inner.sample(n=3)
2、手动设置采样权重
weights = [0, 0, 0, 0, 0.5, 0.5] df_inner.sample(n=2, weights=weights)
3、采样后不放回
df_inner.sample(n=6, replace=False)
4、采样后放回
df_inner.sample(n=6, replace=True)
5、 数据表描述性统计
df_inner.describe().round(2).T #round函数设置显示小数位，T表示转置
6、计算列的标准差
df_inner['price'].std()
7、计算两个字段间的协方差
df_inner['price'].cov(df_inner['m-point'])
8、数据表中所有字段间的协方差
df_inner.cov()
9、两个字段的相关性分析
df_inner['price'].corr(df_inner['m-point']) #相关系数在-1到1之间，接近1为正相关，接近-1为负相关，0为不相关
10、数据表的相关性分析
df_inner.corr()
九、数据输出
分析后的数据可以输出为xlsx格式和csv格式
1、写入Excel
df_inner.to_excel('excel_to_python.xlsx', sheet_name='bluewhale_cc')
2、写入到CSV
df_inner.to_csv('excel_to_python.csv')
data.to_csv( 'D://DocumentTest//ship6.csv',header=None,index=None) 去掉index后保存
#pandas交换两列
out=pd.concat([y,a],axis=1)
out = out.ix[:, ['index','timestamp','y','yhat','use-for-show']]
#设置column的名字
a.columns=[3,4,5,6,8]
'''
pandas:读csv模板 #解决了路径中有中文的情况
import pandas as pd
from pandas import read_csv
from datetime import datetime
# load data
def parse(x):
return datetime.strptime(x, '%Y %m %d %H')
data = read_csv(r'E:\output_nonghang\out.csv')
f = open(r'C:\Users\张博\Desktop\展示\old.csv')
data = read_csv(f)
print(data)
#data = read_csv(f,header=None)可以读取没有列标的csv
'''
创建dataframe:
df = pd.DataFrame({
'HH':data[1][1:],
'week':new,
'Sum':data[3][1:]
},
columns =['HH','week','Sum'])
丢掉一列:
df.drop(['B', 'C'], axis=1,inplace=True)
拷贝模块:shutil
View Code
Mysql
mysql 用法:
sudo service mysql start 先开启mysql服务,再登录
mysql -u root 登录mysql:
show databases; 查看数据库:
use 数据库名 连接一个数据库:
show tables; 查看数据库中的表:
quit 退出mysql:
create database mysql_shiyan; 创建数据库
CREATE TABLE employee (id int(10),name char(20),phone int(12)); 创建表
INSERT INTO employee(id,name,phone) VALUES(01,'Tom',110110110); 插入数据
INSERT INTO employee VALUES(02,'Jack',119119119);
INSERT INTO employee(id,name) VALUES(03,'Rose');
update person set name ='asdfasd' where id =2; 更新数据
从txt 导入数据:load data local infile "c:/my/data.txt" into table employee;
txt中丢失数据可以用\N来补位.
0 不是null
'' 不是null
用户自定义变量:
SELECT @min_price:=MIN(price),@max_price:=MAX(price) FROM shop;
SELECT * FROM shop WHERE price=@min_price OR price=@max_price;
source c:/MySQL-03-01.sql; 把数据库从文件中加载过来
select * from department 看department 这个table 的所有值
select 函数:
1. from where 条件 > = , and or , in, not in ,like _ %,ordered by ....asc(desc)
2.
COUNT SUM AVG MAX MIN
3.AS
SELECT MAX(salary) AS max_salary,MIN(salary) FROM employee;
4.连接查询,用,即可
SELECT id,name,people_num
FROM employee,department
WHERE employee.in_dpt = department.dpt_name
ORDER BY id;
按行提取:
order by id desc limit 10 按照id的倒序排序 取出前10条
order by id desc limit 0,10 按照id的倒序排序 取出前10条
order by id limit 5,10 按照id的正序排序 从第5条开始取10条
DROP DATABASE test_01; 删除数据库
RENAME TABLE 原名 TO 新名字; 重命名
DROP TABLE 表名字; 删除表
alter table employee add height int(4) default 170 after age; 加一列
alter table employee add height int(4) default 170 first age; 加一列
alter table employee drop test; 删除一列
alter table employee change height shengao int(4) default 170; 从命名一列
update employee set age=21,salary=3000 where name='Tom'; 修改行 如果不加where就把所有人全修改了
delete from employee where name='Tom'; 删除一行
select * into outfile 'C:/ProgramData/MySQL/MySQL Server 5.7/Uploads/out2.txt' from employee; 导出,注意是/这个符号.才对
MYSQL导出数据出现The MySQL server is running with the --secure-file-priv option so it cannot execute this
最好的方法是:http://blog.sina.com.cn/s/blog_59bba95d0102wspc.html
也就是
1.C:\Program Files\MySQL\MySQL Server 5.7中把my.ini 里面的 secure-file-priv =
即可.也就是把等号右边的都删了.
2.重启mysql服务,重新登录mysql账号就都好使了.
备份mysql:
cmd中
C:\Program Files\MySQL\MySQL Server 5.7\bin>mysqldump -u root mysql_shiyan >c:/out/bak.sql -p 即可
注意先进入bin目录运行cmd再输入后面的命令才有效果.
恢复:
source /tmp/SQL6/MySQL-06.sql
Mysql学习笔记和查询
●2018-08-31,16点56 mysql从入门到精通.
https://study.163.com/course/courseLearn.htm?courseId=1005092013#/learn/video?lessonId=1051573486&courseId=1005092013
●版本问题用:5.5 5.6 5.7这3个版本其他不要用
oracle就是甲骨文
●进入就是cmd中进入bin目录然后mysql -uroot -p
表示用root登录,然后用密码登录
如果没有密码直接用mysql -uroot 即可.
●如果进入比较慢,就进入host文件加入127.0.0.1 localhost即可.
●decimal(9,2) 表示总共9为,小数2位的数 叫定点型,
可以精确计算.
●char 是定长的,长度不够的末尾用空格补,varchar不会补空格.
char的存取速度快.但是浪费空间,因为他用空格补了.
●text类型用来存文件
●时间我们用时间戳来存储就是一个int类型,表示距离1970
年的秒数.
●经典例子:
创建银行账户的例子.
create table user2(
id int unsigned not null auto_increment comment '用户id',
user_name varchar(20) not null comment '用户名',
email varchar(50) not null comment '用户邮箱',
age tinyint unsigned not null comment '用户年龄',
fee decimal(10,2) not null default 0.00 comment '用户余额',
created_at timestamp not null comment '注册时间',
primary key(id)
);
修改银行账户的例子:
alter table user modify user_name varchar(50);#改数据类型
alter table user change email user_email;#改列的名字
alter table user add password after user_name;#加一个列
alter table user drop password ;#删除一个列
alter table user rename users; 改表的名字
●解决中文乱码问题:
进入目录的my.ini吧编码改成gbk即可.
●truncate 和 delete的区别:
truncate 是测底删除,把id也删了,再插入元素之后会从1开始
而delete不删除id号,插入后id号会继续加上去.
●老是看cmd的颜色很烦,可以在属性里面改背景色.
●mysql安全问题:
看账户信息.首先用mysql -uroot 来登录.
进入mysql这个数据库,
select uesr,host from user;即可.
限制登录的ip地址.输入下面2行:
delete from user where host='::1';
delete from user where host='localhost';
#最好把127.0.0.1也改了改成自己的ip地址.
flush privileges;
之后登录root用户只能:
mysql -uroot -h自己ip地址 -p;
只能用上面这个方法来连接root用户.
●创建用户:
create user 'teset1'@'127.0.0.1' identified by '123456';
drop user 'teset1'@'127.0.0.1'
●修改root密码:
use mysql;
selectg user,host,password from user;
update user set password=password('admin') where user='root';
flush privileges;
●赋予权限:
grant update,insert,delete on shop.* to 'test'@'127.0.0.1';
revoke update,insert,delete on shop.* to 'test'@'127.0.0.1';
●拼接函数:
select concat_ws('==',user_name,email) as user_name_email from user;
●模糊查询:
select user_name from user where user_name like '%ng';
#上面这个like 用=就没法实现!
●统计个数:
select count(*) from user;
●内连接查询:(一般都用这个)
select student.name,mark.mark from student,mark where mark.stu_id=studnet.id;
等价于
select student.name,mark.mark from student inner join mark where mark.stu_id=studnet.id;
●左连接:(左面的表都列出来,右边的表的项目没有的就写null)
select student.name,mark.mark from student left join mark on mark.stu_id=studnet.id;
●右连接:跟上面相类似
select student.name,mark.mark from student right join mark on mark.stu_id=studnet.id;
●子查询:去嵌套select即可
select id from student where id in (select stu_id from mark);
●技巧:查询总书目数
select id from studnet order by id desc limit 1;
#比count(*)来查询速度快多了,因为id号最大的近似等于总记录书.
select * from student limit 3,2;从第三个往后面取2个
#这个是分页的重要技术
●看引擎:
show create table test;
●改引擎:
alter table test2 engine=innodb;
#引擎的区别:
myisam是表级锁.
innodb是行级的锁,所以innodb效率高.并且崩溃的回复也是innodb效果好!
大数据一般用innodb.
5.6版本和更高版本默认就是innodb
更改全部的引擎:
改my.ini文件即可!.
●看编码和字符集的设置
show table status\G
●编码总结:
gbk 汉字2个字节
utf-8 汉字3个字节
●int(n)表示什么含义,跟大小无关,
只跟zerofill有关,当zerofill启用时候,位数比n少
就会用0填充到n位.
char(3) 表示字符的长度最大是3,否则末尾截断.
字符长度表示英文3个字母,中文也是3个汉字.
char表示char(1).
●查看字符,字节长度的函数
char_length(name)
length(name)
●sql_mode 的设置:
set sql_mode =strict_trans_tables;严格模式
#严格模式是如果超过长度就error,不能插入
set sql_mode =ansi;
ansi模式:宽松的
#宽松模式,超过也能插,自动末尾去掉,报warning.
●事务的使用:
start transaction;
xxxxxxxxxxxxxxxxxx
rollback; (commit;)
#利用面2句话就能把中间的语句xxxxx都rollback回去.
#只有innodb才支持事务,myisam不好使!!
●视图的使用:
create view test_view(name,email) as select name,email from student where id=2;
select * from test_view;
#对于视图用法的说明:
在业务上,一个表里面的数据很多,但是给客户只能看一部分为了
保密.所以建立一个视图,视图里面只是表的部分信息,把视图暴露给客户即可.(同时又避免了重新建立一个子表的空间开销)
●触发器trigger(当一个表变化时候,另外一个表也做一些变化)
delimiter//
create trigger total_num after insert on article for each row
begin
update total_num set num=num+1 where type=1;
end//
delimiter//
create trigger total_num after delete on article for each row
begin
update total_num set num=num-1 where type=1;
end//
●改数据库的端口my.ini里面修改就行了.
推荐修改一个自己知道的端口就行,保证安全不用3306默认.
●看端口是否能ping通
telnet 127.0.0.1 3306
●导入和导出:
cmd下:
mysqldump -uroot -p112233 test account >dump_accout.sql
比用navicat导出速度快.并且导出的文件还小.非常牛逼.
导入:
mysql -uroot -p112233 testdata:时间戳>enum>char>varchar>text
以性别为例子:char(1)不如enum('男','女')不如tinyint
4.够用就行:能用tinyint就用tinyint
5.尽量不使用NULL.因为慢
●索引的优化策略:
1.索引有2种:
btree索引(就是多叉搜索树),哈希索引(缺陷不支持前缀索引,区间索引,哈希冲突)
2.联合索引跟顺序有关.所以需要调研看哪个顺序最常用就设置哪一个.
设置方法:
index c1234(c1,c2,c3,c4)这样就建立了一个联合索引.
看是否用到几个索引.
explain select * from t4 where c1=3 and c2=4 and c4=5 order by c3\G
出现的key_len:就是用个几个长度.
这里面会显示c1,c2因为根据过桥原理,到c3就没有了,所以c4=5
是没法用到索引的.
题目:已经加了索引列还是很慢怎么办?
在实际场景中,一个电商的商品很多,直接在所有商品
中按价格索引的人很少,
所以去掉单独的price列的索引,加上(cat_id,price)符合
索引再查询即可.
联合索引的实际业务:
商城一般是
1.index(cat_id,brand_id)
2.index(cat_id,price)
3.index(cat_id,brand_id,price)
就够了其实只需要2,3因为3包括1了.
3.回行就是读写硬盘,用到索引就不用回行了,否则就用回行
4.聚簇索引innodb,当有大字段时候就会慢,比如加一个
text(3000),主键索引就会慢,但是联合索引不会慢,
因为他不会带这些叶子.
5.ip地址技巧:
倒叙之后建立索引
用伪哈希算法.
crc32是一种哈希算法,把字符串算成32位整数.
经典mysql面试题:
1.求出每一个部门的薪水最高的人员:
select e.deptno,e.ename,t.maxsal,e.sal
#因为下面判断需要e.sal所以需要这里select他
from (
select e.deptno,max(e.sal) as maxsal
from
emp e #这个是把emp表起了个别名叫e
group by
e.deptno #这个分组的必须在前面select里面有
) t
join emp e
on t.deptno=e.deptno
where t.maxsal=e.sal;
sublime3的设置：
setting:
{
"auto_complete": false,
"color_scheme": "Packages/Color Scheme - Default/Breakers.sublime-color-scheme",
"dictionary": "Packages/Language - English/en_US.dic",
"font_face": "Courier New",
//这个字体虽然丑但是可以区分l和I
"font_options":
[
"gdi"
],
"font_size": 20,
"ignored_packages":
[
"Vintage"
],
"save_on_focus_lost": true,
"spell_check": false,
"theme": "Adaptive.sublime-theme",
"update_check": false,
"word_wrap": true
}
key绑定设置:
[
{ "keys": ["ctrl+k"], "command": "run_macro_file", "args": {"file": "res://Packages/Default/Delete Line.sublime-macro"} },
{ "keys": ["ctrl+l"], "command": "run_macro_file", "args": {"file": "res://Packages/Default/Delete Line.sublime-macro"} },
{ "keys": ["ctrl+d"], "command": "duplicate_line" },
{ "keys": ["f5"], "command": "build" },
{ "keys": ["f8"], "command": "build", "args": {"variant": "RunInShell"} },
{ "keys": ["alt+3"], "command": "toggle_comment", "args": { "block": false } },
{ "keys": ["ctrl+q"], "command": "reindent" },
{ "keys": ["alt+q"], "command": "reindent" },//这个很有用,可以直接把python代码里面的空格批量修改成为tab,保证了代码的一致性和美观
]
sublime3的激活:
1.更改hosts文件
windows系统的hosts文件在C:\Windows\System32\drivers\etc 路径下，其他系统请自行百度
在hosts文件中加入下面两行：
127.0.0.1 www.sublimetext.com
127.0.0.1 license.sublimehq.com
2.
----- BEGIN LICENSE -----
sgbteam
Single User License
EA7E-1153259
8891CBB9 F1513E4F 1A3405C1 A865D53F
115F202E 7B91AB2D 0D2A40ED 352B269B
76E84F0B CD69BFC7 59F2DFEF E267328F
215652A3 E88F9D8F 4C38E3BA 5B2DAAE4
969624E7 DC9CD4D5 717FB40C 1B9738CF
20B3C4F1 E917B5B3 87C38D9C ACCE7DD8
5F7EF854 86B9743C FADC04AA FB0DA5C0
F913BE58 42FEA319 F954EFDD AE881E0B
------ END LICENSE ------
sublime3配置java,c++也一样.
View Code
计算机网络概述,谢希民的书,韩立刚讲的视频
计算机网络概述
计算机网络原理精讲视频教程,韩立刚
上网的带宽值得是连接运营商的速度.
信息发送过程:
把自己ip地址,和目标ip地址都写上就是数据包
把mac地址写上就是数据贞.
(记忆:贞就是带上真是的物理地址.)
每一次切换路由器都需要修改发送mac地址和接收mac地址.
(所以每一次都修改贞,但是数据包不变.)
总结:ip地址决定了最后给的地址是哪里,
mac地址决定了下一跳给的是哪个路由器,
经过很多个路由器,每跳一次改一次源mac地址和目标mac地址.
服务器信息发送过程:
1.把信息进行切分
2.把一些块放到队列中
3.把第一个信息块,加上源ip地址,源mac地址,目标ip,目标mac
4.收到了信息,改服务器一个接收到的确认信号.
5.队列中删除信息块1,发送信息块2.
6.信息都收集全了,就把信息拼起来成为一个网页.
osi模型:
应用层:能残生流量的程序
表示层:在传输之前是否进行压缩或者加密处理,编码.
会话层:查看木马
查看netstat -nb 看是连接的网站
传输层:可靠传输,流量控制,不可靠传输
网络层:负责选择最佳路径,规划ip地址.
数据链路层:贞的开始和结束.透明传输 差错校验
物理层:接口标准,电器标准
分层思想:
比如连接dns服务器,不应该给ip而应该给服务器的名称,再解析
这个ip地址.这样就分离了层.这样不在这个网段的也能连这个服务器.
断网诊断:
从低到高进行排查:
1.物理层:看网络连接,查看连接的状态
里面已发送数据包和接收数据包
如果发送的有,接收的没有,就说明水晶头可能坏了.
水晶头一共有8根线,2个接收,2个发送.
2.数据链路层故障 mac地址冲突.
解决方法,改变mac地址即可.(就不会跟别人的mac地址冲突了)
adsl欠费.网速协商无法一致.
3.网络层问题:配置错误ip地址,子网掩码,网关,路由无法连
4.应用层:应用程序代理配置错误.
安全:
1.物理层安全:网线不要的就撤了
2.数据链路层:adsl账号密码.valan交换机端口绑定
3.网络层安全.路由器上对ip地址进行限制.防火墙
4.应用层:应用程序的漏洞.
计算机网络性能:
1.速率:mb/s,一般除以10就差不多了,比如10Mb,就是1mb.
2.带宽是最高速率
3.吞吐量:单位时间内通过的数据量.
一个发送端,一个接收端叫一个信道.
4.发送时延
发送时延=数据块长度(bit)/信道带宽(比特/秒)
当信道带宽太高,就无法识别了,因为波形太密了
光纤会识别率更高.所以光纤的发送速度更快.
光纤和铜线传播速度差不多.
5.传输时延
6.往返时间. ping www.baidu.com可以看
大于2000毫秒会显示请求超时.
局域网一般小于1ms
7.网络利用率:
利用率越接近1,时延越高越接近正无穷.这个通过公式给的.
理解就是利用率越高,越堵塞,所以时延越高.
物理层:
机械特性,电气特性,功能特性,过程特性.
数据通信:
调制解调器:把数字信号和模拟信号互相转化
数据:运输的实体是数据,消息是数据的本质
信号:数据的电气或者电磁表现
(说的都是一个东西的3个表现)
电波的频率和传输距离的关系:
波速=波长×频率
频率越高,能量越大,传的越远.
所以广播电台要先把人的声音频率变高再传播.
基带信号:距离远就是基带信号,原始信号
带通信号,通过调制把信号改成高频的.
方法:调幅或者调频或者调相
编码方法:单机型归零吗,双极性归零吗
单机型不归零码,双极性不归零码
曼侧斯特编码:可以携带时钟信号,且可以
表示没有数据传输.
差分曼侧斯特编码:抗干扰性比曼侧斯特要 强.
奈试准则:没有电磁干扰的情况下,码元的传输速度也有上限.
只适用于数字信号
光纤比铜线块就是因为单位时间的码元多也能识别出来.
香农公式:存在噪音的情况下,降低传输速度也能传输信息.
适用于所有信号.
网线:
电脑和交换机:用直通线
电脑和电脑:交叉线
记忆8网线:
橙白橙 绿白绿 蓝白蓝 棕白棕
光纤的原理是光线在纤芯中全反射
集线器:只起到信号放大和重发的作用
信道复用技术:先复用再分用.
频分复用FDM,也就是用不同频率来区分.用过滤器来拆分.
(例子:打电话:多次频分复用)
时分复用.tdm就是按照顺序排,按照顺序取.
统计时分复用stdm:每家一个来源的数据就加一个标记.
波分复用:就是频分复用
中国广域网用E1电路连接.
ADSL技术:
用电话线的更高频率来传输网络,从而同时也能打电话了
HFC:
利用电视有线线路来上网.
数据链路层:
数据链路层信道类型:点到点,广播
数据链路层的内容叫帧,贞头,贞尾,物理层地址,校验值
透明传输:贞的封装.用字节填充法解决数据里面出现了贞开始符,或者贞结束符这种情况.具体就是用ESC键的asc码来加到哪些伪贞开始符合伪贞结束符.并且如果数据里面如果真有ESC键,那么用2个ESC建的asc码来代表原来的一个esc建.(就是转义
字符)
差错检验:
循环冗余检验法crc
比特填充法:
收尾都定义为5个1,当内容中出现5个1时候,在他后尾添加一个0.
'''
2018-09-05,10点10
应该不止做了10次一样的梦,总是还是现在的时间在读硕士或者博士,然后抽出时间同时回高中重新读高2和高3.起来总是
感觉高考没考好就算了吧,其实这么多年过去内心还是没发下.
总之当年的物理,化学再来一次的化我肯定不管多难的练习题都
要学,不再侥幸的根据往年的高考题来判断这些题目应该考什么.考100的内容一定要多准备到150.做事也一样,不比真正需要的多会很多,总是存在失败的风险.高考真的不是定终身,他定
的是百分之70.找工作基本都看学校就能pass你.希望自己梦里
还是能看开,起码保住发际线.
'''
点到点的协议:ppp,通过电话线连接.(point to point protocal)
韩立刚的ccnc课程能学到如何连接路由器配置网络.
广播类型:CSMA/CD协议
静态划分信道:不用这个方法
动态媒体接入控制:随机接入,碰撞检测:
方法就是电脑通过广播发送给所有电脑,
但是只有目标mac地址匹配的他才接收,
碰撞检测就是,如果2个信号重叠了,就说明
碰撞了,那么每一个计算机就I都等一段时间之后再发信息.
单工就是在同一时间只允许一方向另一方传送信息，而另一方不能向一方传送
全双工(Full Duplex)是指在发送数据的同时也能够接收数据，两者同步进行，这好像我们平时打电话一样，说话的同时也能够听到对方的声音。目前的网卡一般都支持全双工。
半双工(Half Duplex)，所谓半双工就是指一个时间段内只有一个动作发生，举个简单例子，一条窄窄的马路，同时只能有一辆车通过，当目前有两量车对开，这种情况下就只能一辆先过，等到头儿后另一辆再开，这个例子就形象的说明了半双工的原理。早期的对讲机、以及早期集线器等设备都是基于半双工的产品。随着技术的不断进步，半双工会逐渐退出历史舞台.
10mb以太网最短的有效贞是64字节.
100mb以太网最短的有效贞是640字节.
2进制指数退避算法:
1.重传次数是k
2.所有计算机从0到2^k-1这些连续的整数里面选一个
数乘以基本退避时间就是他的等待时间.(基本退避时间就是
2tao,tao是网线的传波单程时间)
为了统一以太网的网线不超过100m,否则这个退避时间就麻烦了!
mac地址前24位代表厂家,后24位厂家自己分配
修改mac地址:
网卡,属性,高级,newworkadress ,修改值.
这个在网络管理里面很有用:
比如网管里面记录mac地址,只有这些mac地址才能登录,
如果mac地址冲突,那么只能把mac地址修改成新的mac地址,
然后登录这个新的mac地址.
ethereal network analyzer抓包工具.
点到点的目标地址头是ff.
网桥能根据mac地址来判断是否让信息通过.
用网桥来连接集线器就能减少冲突.
网桥的口很多直接连电脑,那么他就叫交换机,原理一样
记录mac地址来发送信息.
这就是交换机比集线器厉害的地方.集线器有信息就传输非常傻瓜.
交换机:端口带宽独享,安全,基于mac地址转发,通过
学习构建mac地址表.
cisco packet tracker 软件
数据链路层:
封装成贞:加贞头,加贞尾
透明封装:转义字符
无差错接收
点到点的数据链路层:ppp
广播信道的数据链路层:csma/cd
以太网,集线器,网桥,交换机
网络层:路由器负责在不同网络之间尽力转发数据包,
基于数据包的ip地址转发,不负责丢失重传,也不负责顺序.总之:路由器非常省心.
集线器叫hub
一般设置网络为:
10.0.0.0
255.0.0.0
网关为10.0.0.1,就是路由器的地址!!!!!!!
其他电脑就是10.0.0.2等
路由器里面需要设置路由表.管理员定的或者通过学习.
来指示到目标ip需要经过的下一跳是哪个中间ip.
网络设备和osi参考模型:
发送端:
1.应用层:应用程序准备要传输的文件
2.传输层:将文件分段 并编号 这时候叫段
3.网络层 添加目标ip地址,源ip地址 这时候叫包
4.数据链路层: 两种情况:
使用自己的子网掩码和ip地址,判断自己在哪个网段
使用自己的子网掩码,判断目标地址在哪个网段.
(这个地方要注意是用自己的!,因为只需要判断是否
是自己的网段而已,所以用自己的子网掩码来判断)
如果是一个网段的,arp协议广播解析目标ip地址的mac地址.
如果不是一个网段的.那么就去arp广播网关的ip地址的mac地址.
之后加上自己mac地址,目标mac地址,校验码fcs
这时候叫帧
5.物理层:变成bite流传输.
集线器的作用:只是信号加强.
路由器是3级设备指的是他能看懂
物理层,数据链路层,网络层
交换机是2级设备指的是他能看懂
物理层,数据链路层,
路由器无法中病毒.因为他转发数据,
不跑程序.但是中病毒的电脑会影响路由器
乱发消息
网络层协议
arp将ip地址通过广播,目标mac地址是
12个F.
方法:ping一下网管,然后arp -a
实例:p2p流量终结者,网络执法官.都是
arp欺骗来实现的.
静态的mac地址就是i管理员告诉我的
动态的mac地址就是通过ping通后记录的.
实例:如果服务器ping不同路由器,也上不了网.
但是能ping通本网段的,可能是服务器
里面路由器的mac地址配置的不对.
路由器上也一样,把服务器的mac地址也静态配好,这样
arp欺骗也就欺骗不了了.因为双方都有mac地址时候就不进行
arp广播了.不问了就不能被欺骗了.
方法:arp -s ip地址 mac地址 这样就能静态配置mac地址了.
注意这个要双方都配好.只配一方不行.
重启就不行了.
所以要写要给bat文件开机启动.写下面内容即可.
arp -s ip地址 mac地址
本地连接 点修复 就能清空静态绑定的mac地址.
ICMP协议
ping time 查看延迟
TTL 是数据包的生存周期:
他的使用方法是:每过一个路由器他就减1,如果到0,路由器就扔了这个数据包.
他的目的:是防止包再网络中循环从而防止无限占用带宽.也就是发包给的TTL数表示最多过多少个路由.
通过TTL可以看ping xxx网.xxx网的操作系统.
linux一般发送的是64
windows 128
unix 256
所以ping xxx网返回的ttl如果50多,一般是linux系统.
只是粗略的估计.不准.
ping命令 -t 表示一直ping
-l 200 100.7.1.53 制定ping的时候数据包的大小.
ping 8.8.8.8 -i n 表示第n个路由器的地址
(原理是ttl到0了就会返回主机当前路由.)
qq能上网,网页打不开:dns服务器连不上.
qq能连,是因为他做的时候是按照ip地址连的.
ping -t命令实例:
一个朋友的网间歇性的丢包,看原因是自己服务器问题
还是电信的网有问题?
把朋友的这个局域网内的ip地址多写几个,用-t命令
同时让我的笔记本ping -t他们这些ip地址.
如果同时不响应就说明是电信的问题.
否则就是哪一个电脑的问题.
区分2个ping命令返回错误信息:
请求超时:到了对面,但是对面没法连我的主机.
request timeout
目标不可到达:到不了对面 unreachable
pathping 跟踪数据包路径.计算丢包情况.
功能很强!可以解决很复杂的问题
windows 上跟踪数据包的路径的命令:
tracert 10.7.1.53
路由器上跟踪数据包路径的命令:
traceroute 12.0.0.3
IGMP
点到点
广播
组播=多播
IGMP协议就是internet 组播管理协议.
周期性的检测哪些电脑配置了多播ip
IP数据包结构
版本呢:用来表示TCP/IP协议的版本 v4 或者v6
首部长度:header length:20bytes
区分服务:differentiated service field
表示抓包的优先级.
总长度:网络层:数据包最大 65535字节
数据链路层:数据包最大 1500字节
最大传输单元 MTU
数据包如果不分片数据最大1480字节.
长度大就拆,每一个小块都配ip,到对面再
拼起来.
一种攻击叫泪滴攻击,一直往目标计算机发送损坏的ip包,占用带宽.
标识:Flags用编号Identification来组装这些片.编号一样就拼起来
标志:用来标记是分配还是完整的数据包
1表示后面还有分片.
0表示后面没有分片.
标志字段中间有一位如果是0表示支持分片.
ip数据报首部的协议号:
icmp: 1
igmp: 2
tcp: 6
udp: 17
ipv6 :41
ospf:89
例如:protocol:udp(0x11)
首部检验和:
原理是数据报的首部除了检验和都反码加起来.
得到的结果赋予给检验和.
接收端吧数据包的首部全部都反码加起来
如果是0就correct,否则false.
原理就是a+a=0 (任意a)再二进制反码里面是公理.
还有2个就是源地址,目标地址.
用抓包工具排错.
看局域网里面谁发广播
广播的目标mac地址是12个f
静态路由和动态路由
网络畅通的条件: 有去有回
无网关也能ping通自己的路由器:
因为他们再一个网段里面.
但是这样虽然能ping通路由器,但是没法用路由器
登陆外网.
再之后一个点一个点的查路由表,看有没有
实验:用packet router来模拟实验:
1.配置ip,计算机是一个ip,交换机是一个ip,路由器
之间的线是一个ip.
每一个端口是他在ip的网段的一个ip地址即可
2.之后配路由表.有去有回.
路由器通不通主要看路由表.
只要是不再一个网段的就直接连网关,然后查路由表!!!!!!!!!!!!!!!!!!!!!!
3.配置方法:
ip route 172.15.1.0 255.2255.255.0 172.16.0.2
从这个代码看出.ip如果要连接172.15.1.0这个ip地址
钱3个数字表示的网段,他的下一跳是172.16.0.2
静态路由:
需要管理员告诉路由器所有没有直连的网路吓一跳应该给谁.
静态路由适合于小规模的网络,不能够自动调整路由.
动态路由:
RIP协议
周期性广播路由表 跳数越少越走这个路径 30秒更新一次.最大跳数15跳,超过15跳就视作不可到达.
所以RiP协议不适合大规模网路
ospf协议也是选路由路径的协议:按照带宽来选择
路由.
传输层:
协议:
TCP 需要将要传输的文件分段 传输 建立会话
可靠传输 流量控制
UDP 一个数据包就能够完成数据通信, 不分段
不需要建立会话 不需要流量控制 不可靠传输
域名解析:用UDP
qq聊天:用UDP
qq传文件:用TCP,因为传文件肯定要分段,控制流量,检测可靠.
发邮件:TCP
ftp传文件:TCP
下载考题:TCP
屏幕广播:UDP.因为不建立会话(广播都是UDP)
查看会话 netstat -nb
利用这个命令可以查木马.(看哪个程序建立的会话)
常见协议和端口:
http=tcp+80
https=tcp+443
rdp=tcp+3389
ftp=tcp+21
smtp=tcp+25 发邮件
pop3=tcp+110 收邮件
利用端口来安全:
服务使用 tcp或者udp的端口侦听客户端请求
客户端使用ip地址定位服务器,使用目标端口 定位服务 可以在服务器网卡上设置只开放必要的端口,实现服务器网路安全.
查看端口
netstat -an
如何查看服务监听的端口
netstat -an
netstat -n 查看建立的会话
netstat -nb 查看建立会话的进程
telnet 192.80.100 3389 测试到远程计算机某个端口是否打开.
默认端口都能修改:但是客户端也同时要修改才能联通.迷惑入侵者,使系统更安全.
如何设置windows网络安全:
设置本地连接 TCP/IP筛选就能只让一些端口
才能运行.
端口只具有本地意义:不冲突就可以.
端口:0-65535
数值端口0-1023
等级端口rop 3389
客户端端口49152-65535
#找出已经建立的连接.注意区分大小写.
netstat -n | find "ESTABLISHED"
TCP必须是全双工
因为必须需要反馈.
文件:
如果文件是文本的话,
英文和数字就是1个字符一个字节.
中文就是2或者3
如果是图片,音频的话也是按照8个当成一个字节.来传输
这些都叫字节流的方式.
2018-09-07,20点16
解决鼠标单机经常变双击问题:
进入鼠标设置把双击速度变慢即可.
确认号就是上个数据包最后一个编号+1
窗口大小:window size
表示缓存的大小
TCP如何真实的实现可靠传输:
1.以字节为单位的滑动窗口技术
2.选择性确认:
当出现谋一个数据块丢失时候,告诉
源计算机,发送这个块即可.
往返时间叫RTT
平均往返时间较rtts
超时重传时间应略大于7/8*旧的rtts+
1/8*新的rtts.
TCP的流量控制
就是通过接受端告诉发送端窗口大小即可.
如果为0就让发送端等待不发送.
避免拥塞的算法:
快重传,快恢复.
序列号:就是当前发送的文件的序号
确认好:就是当前需要的文件的序号.
所以a发送序列号x
b收到后就发送确认号x+1
a收到请求后
a发送序列号x+1
反复就这样迭代下去.
TCP3次握手例子:
1.a计算机发送syn=1表示要建立会话
seq=123(随便要给数)
2.b计算机收到后发送syn=1,ACK=1
(标识),seq=987(随便一个数),ack=
124
3.a计算机收到后.发送ACK=1
seq=124,ack=988
TCP4次握手例子:
1.a计算机发送FIN=1,seq=123
2.b计算机发送ACK=1,seq=987,ack=124
3.b计算机发送FIN=1,ACK=1,seq=888,
ack=124
4.a计算机发送ACK=1,seq=124,ack=889
2018-09-08,13点04
下面讲应用层
dns服务作用:
把域名解析成ip地址.
什么是域名:
根
顶级域名:com edu net cn org gov
二级域名: 91xueit
三级域名
91xueit.com 叫2级域名,根据2级域名交钱
www.91xueit.com叫三级域名
nslookup查询dns服务器的地址
如果dns服务器找错了就自动找上一次
重新找dns服务器.
安装自己的dns服务器:
为什么需要自己的dns服务器:
1.解析内网自己的域名
2.节省到internet域名解析的流量.
3.域环境.
DHCP 动态主机配置
dhcp客户端请求ip地址的过程
dhcp服务器必须静态地址
释放租约:
ipconfig/release
跨网段分配ip地址也可以
在路由器上配置一个ip helper address
即可.
FTP协议:
控制连接:默认端口21,用于分送ftp命令
数据连接:默认端口20,用于上传下载数据
FTP服务器端,如果有防火墙,需要再防火墙上开21和20端口,用主动模式才行.
主动模式:ftp客户端告诉ftp服务器使用什么端口监听,ftp服务器的和ftp客户端再这个端口建立来连接, 源端口20
被动模式:ftp服务器打开要给新端口,等待ftp客户端的连接.
看端口是20和21就是主动,否则就是被动
dns设置:
一般设置222.222.222.222
备用:8.8.8.8
一个端口可以同时建立多个会话.
telnet 使用tcp的23端口
rdp协议:
net user administrator a1! 更改用户密码
net user han a1! /add 添加用户
将用户添加到远程桌面组
remote desktop users 组
windows Server 多用户操作系统.
启用远程桌面可以多有用户同时使用服务器
xp和win7单用户操作系统.
网站标识:用不同端口,不同ip地址.
使用web代理服务器访问网站
1.节省内网访问internet的带宽
2.通过web代理绕过防火墙,突破路由器限制
3.使用web代理可以不让服务器查到我ip.
(因为我用的是web代理发的)
邮件建立
1.安装pop3和smtp服务以及dns服务
2.在dns服务器上建立91xueit.com和
51cto.com
建立主机记录mail 192.168.80.100
建立邮件交换记录 mx记录
3.再pop3服务上建立域名 创建游戏
4.配置smtp服务器船舰远程域名*.com语序发送
5.配置outlook express 指明收件的服务器和发邮件使用pop3协议.
搭建再internet上使用的邮件服务器
1.再interntet上注册了域名mx记录
加密技术:
对称加密: 优点效率高
缺点密钥不适合网上传输,难以维护.
数据加密标准des
加密算法
加密密钥
目前的破解速度
52位密码:20分钟破解
128位密码:5*10^18年
非对称加密:密钥对,公钥和私钥
公钥加密私钥解密
或者
私钥加密公钥解密
具体玩法:
a让b,c,d 3个人给他发信息.
a自己通过随机数做一份公钥,私钥对.
把公钥给b,c,d.
自己留着私钥.
b给a发信息公钥加密后也放网上.大家
都能下载.但是只有a用私钥能解密.
所以安全.
综合这2个算法.
内容用对称加密来加密,
而对称加密的加密密钥用
非对称来加密.这样就能又安全又快速了.
合同都是写Y500元.这样就不能在数字
前后加数字了.
数字签名:防止抵赖,能够保证签名之后是否被更改,更改数字签名就失败
文件写完用要给单向散列函数来生成摘要
这个摘要一样就说明没改.
证书办法机构的作用
为企业和用户把案发数字证书 确认这些企业和个人的身份,发布证书吊销列表
企业和个人信任证书颁发机构
http:登陆页面
https:用的ssl来登陆,更安全.叫安全套接字
在应用层和传输层之间加密
在internet上使用的安全协议的端口
imaps tcp: 993
pop3 tcp: 995
smtps tcp: 465
https tcp: 443
IPsec网络层的安全:
鉴别首部:AH authentication header:
只进行了签名
封装安全有效载荷 ESP
即进行了签名也进行了加密.
防火墙就是一种特殊变成的路由器.
网络层防火墙 基于数据包,源地址,目标地址,协议和端口,控制流量
应用层防火墙,数据包,源地址,目标地址,协议端口,用户名,时间段,内容.
防火墙拓扑:
3向外围网,背靠背,单一网卡,边缘
在internet上传输音频和视频
1.音频视频 占用的带宽高,网速要求恒定,延迟低
数据信息,对带宽,网速是都恒定,延迟要求不高
延迟:发送延迟,传送延迟,处理延迟.
延迟对于非交互式的音频视频影响不大
带宽不稳定:用缓存
因特网 提供的音频/视频服务分3类
1.流式streaming 存储音频/视频--一边下载一边播放.
节省客户端的影片空间不用下载
保护视频版权
2.流式实况
3.交互式
IP电话:就是用网络来打电话
比如长途让你先拨19777这种就是先连接到internet上.
无限网络
两个笔记本可以直接用无限网路连接.
就可以访问共享资源.
网络设置里面点建立连接即可.
java笔记
唐大任老师
java程序的分类:
分application 和applet
前者是独立的程序需要虚拟机来运行
后者是潜入在html中的程序,用web浏览器就行.
属性和变量在java的类里面就叫字段
函数 叫方法
其实applet现在都用js,html来替换了,applet没啥用了.
javadoc -d 目录名 xxx.java
自动生成文档
java数据类型划分:
1.基本数据类型,存在栈里面
2.引用数据类型,存在堆里面
java & | 与和或
&& || 短路的与和或
所有的byte,short,char参与算术运算等转化为int
学习java代码:
用javap命令来反汇编,看汇编语言如何处理即可.
java数组
int a[5]是不行的
只能写:
int []a =new int[5]
原因java数组是一个引用类型
只能用new开辟空间然后引用到a
或者
int[]a={3,9,8};
java的数组一经分配空间,其中的每一个元素也被按照成员变量来进行隐式初始化.
例如:int[]a=new int[5];
其中a[3]这些都赋值为0了.
引用类型是null
java的数组是必须定长的.
所以int a[][]=new int[][4];非法
只能写:
int [][]t=new int [3][];
t[0]=new int [2];
t[1]=new int [4];
t[2]=new int [3];
//即必须每一维都写清楚多少维度
方法的名字和參数列表称为方法的签名。注意，方法签名不包含方法的返回类型。
说白了重载跟c++一样.
this的使用:
解决局部变量和域同名的问题
继承是类最重要的特征
字段:
1.字段的继承:自动进行
2.字段的隐藏:重新定义一个同名的就把父类的字段给替换了.
3.字段的添加:直接写
方法:同上
super访问父类的域和方法
1.当覆盖父类的同名方法的时候,如果需要调用父类的方法,就必须用super.
2.当子类在构造方法中,可以用super来调用父类的构造方法.
比如.
student(String name,int age,String school){
super(name,age);
this.school=school;
}
使用时,super()必须放在第一句.
父类对象和子类对象的转换
1.子类对象可以被看做一个其父类的一个对象
2.父类对象不能被当作一个子类的对象的.
3.如果一个方法的形式参数定义的是父类对象,那么调用这个方法的时候,可以调用子类对象作为实际参数.
4.如果父类对象引用指向一个子类的对象,那么这个父类的对象的引用可以强制类型转为子类对象的引用.
具体:
Person p2=new Studnet('zhangyi',18,'THU');
Student s2=(Student ) p2;
Person []manypeople=new Person[100];
manypeople[0]=new Person('Li',18);
manypeople[1]=new Student("wang",18,'PKU')
//数组的本质是引用,最后这句话,需要的是一个people的引用,但是我给他一个studnet这个子类也是可以的.
包package
1.名字空间解决名字冲突
2.同一个包中的各个类可以互相访问.
成员的访问控制符哪些可以访问:
1.private:在同一个类中
2.默认:在同一个类中,在同一个包中
3.protected:在同一个类中,在同一个包中,在不同包中的子类
4.public:同一个类中,同一个包中,不同包中的子类,不同包中的非子类.
类前面要么public要么不写:
1.若用public修饰,那么这个类可以被其他类所访问.
2.若什么也不写,则该类只能被同包中的类访问.
非访问控制符
1.static,静态的.
含义:非实例的,类的
可以通过类来直接访问,也可以通过对象来访问,实际上表示的是全局变量
1.static 属性
比如在类Person中可以定义一个类域为totalNum
class Person{
static long totalNum;
int age;
String Name
}
那么可以用Person.totalNum和p.totalNum来访问
2.static方法.
static方法只能处理本类中的static属性或者调用static方法.
static方法不能访问实例变量不能用this或者super
2.final 不可改变的
final这个类不能被继承
final字段:
表示只读.
一个字段被static final修饰,他表示常量.
比如Math.Pi就是这样的.
3.abstract 不可实例化
抽象方法:只有方法名,没有方法体.
一旦某个类中有抽象方法,这个类必须是抽象类.因为抽象方法无法实例化
引用的3个类型:
数组,类,接口
1.通过接口可以实现不相关类的相同行为,而不需要考虑这些类之间的层次关系.从而实现了多重继承.
2.知道这个的意义在于!!!!!!!!!所以一定要记住对象是一个引用
m是一个对象
n=m
n.addyear()
这些跑完,会发现n和m同时变化了.因为他是一个引用,类似指针的概念,m和n都是这个对象的一个地址.所以n变了就m和n对应的对象都变了.python里面的对象也一样.
比如:
class person():
def __init__(self,name):
self.name=name
a=person('324')
b=a
b.name='99999'
print(a.name)
//输出99999
字段变量和局部变量区别
1.存储位置,字段变量是对象的一个部分,他是放在堆中的,局部变量是放在栈中的
2.生命周期不同
3.初始值不同,字段变量自动赋值,局部变量需要手动赋值
4.两种变量的=传递也不同,
字段变量是地址传递.
局部变量是值传递.
这点跟c跟python都一样
多态:
1.编译时候多态
函数声明不同
2.运行时多态
子类对父类方法的覆盖
动态绑定:虚方法的调用
虚方法调用
自动根据实例来调用这些同名函数,自动选自己这个实例所属于的类的方法.
java中普通方法是虚方法,
但是static,private的方法不是虚方法,
因为一个是类自己的,不可能用子类的,
private也是类自己的,没有子类.
final也一样不能是虚方法,虚化
所以不可能调用虚方法.
构造过程是从最源头的父类开始构造.
static 初始化,是先于实例的初始化
java垃圾回收
自动有一个java虚拟机的垃圾回收线程来完成.
任何对象都有一个引用计数器,如果他的值是0,那么这个对象就可以回收
finalize可以进行析构.
try-with-resources语句.来控制资源析构.
内部类中可以使用外部类的成员
具体:
class A
{
private int s=111;
public class B{
private int s=222;
public void mb(int s){
System.out.println(s);//222
System.out.println(this.s);//222
System.out.println(A.this.s);//111
}
}
}
用static修饰内部类,那么他就是一个外部类
局部类:在方法里面定义的类
不能访问这个方法的局部变量,除非是final局部变量.
匿名类是一种特俗的内部类
lamda函数
比如
Runnable doit=()->System.out.println("aaa");
new Thread(doit).start();
基本类型的包装类
它将基本类型包装成object引用类型
java与指针的关系:
引用实质就是指针
但是他是受控制的,安全的.
因为:
1.会检查空指引
2.没有指针运算*(p+5)
3.不能访问到没有引用的内存
4.自动回收
java里面==的含义
基本类型是值相等
引用类型是引用相等.
Integer m=10;
Integer n=10;
System.out.println(m==n);
//true.因为对象有缓存,装箱操作会保存
-128到127之间的数.缓存里面有的数,只生成一个对象.
Integer m=200;
Integer n=200;
System.out.println(m==n);
//false
String用equals来判断相等
张孝祥:java就业培训教程
非常好的一本书,老师讲的也很好.有视频课程,第一次学java就下载的他的课程.风格就是不说废话,就是干.
java语言编程过程:
java源程序.java----java字节码文件.class----------jvm虚拟机.
windows下的java字节码解释程序-----
windows操作系统.
如何在命令行中快速进入某个目录:
在命令行中,如果目录的名字比较长,可以
值输入目录名中的部分字符,其他字符用*代替.
byte b=129;错误超范围了
float f=3.5;错误,因为小数常量默认用double来存储,占用8个字节,但是float类型只开辟了4个字节.所以错误.
float f=3.5f;正确.
强制类型转换的例子:
int i=266;
b=(byte)i;
结果b=10;//因为byte是1个字节.而266=256+10,256超过一个字节,自动截掉.所以是10
2个经典算法:!!!!!!!!!!!!!非常常用
1.安排新到的学员每6个人一个房间,问需要多少个房间.
答案:(x+5)/6
2.让x的值在0到9之间循环变化
while(true){
x=(x+1)%10;
}
内存分配:非常详细!
java把内存划成2种:栈和堆
函数中定义的一些基本类型变量和对象的引用变量都是在栈中分配,当一段代码块中定义一个变量时候,java就在栈中分配空间,超过作用于之后,java会自动释放掉改变量所分配的内存空间.
堆中放new创建的对象和数组,即使程序运行到这个变量的代码块之外,数组和对象本身占据的内存不会被释放,只有引用计数为0时候才会释放.所以java比c语言占用内存要大.
用例子来说明上述问题:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World");
class Person
{
int age=20;
}
Person p2=new Person();
p2.age=30;
{Person p1=new Person();p2=p1;}
{System.out.println(p2.age);}
}
}
这里面输出20.
在张老师书里面画的很详细.
Person p1=new Person();
这句话运行之后,在栈中生成p1这个门牌号,
在堆中生成Person年龄20这个实体.
在这句话所在的大括号,运行超过这个大括号了.p1这个门牌号就自动析构了.这就是栈.而堆是看引用的,这里面在括号里面把这个实体又给了p2,但是p2的生存周期更长,所以最后仍然可以通过p2来访问这个年龄20的实体.这个实体一直到print年龄后才发生引用计数归0,才从堆中析构.
构造方法一定是public的.
static关键字:
例如所有的中国人都有国家名称,每一个中国人都共享这一个名称.不必为每一个中国人的实例都单独分配一个国家名称的变量.
这时static就够了.这就是静态,他表示的是公共的东西.不随对象而改变,而只是类自身的属性.也可以说是这个类的所有对象的公共的属性.
实例:
比如我们想统计在一个程序中一共产生了多少个类的实例对象,就可以用一个static的属性来记录:
class A{
private static int count =0;
//用private修饰可以保证类外面的不能朽败这个计数.
public A()
{
count=count+1;
}
public void finalize()
{
count=count-1;
}
}
静态方法:
我们有时候希望不用创建对象就可以调用某个方法,那么我们就需要使用静态方法.
静态代码块:
当类被加载时(也就是这个类的构造函数被调用时),静态代码块就被执行,且只被执行一次.也就是说调用多少次构造函数,这个静态代码块都只运行一次.
作用,静态代码块用来对类的属性进行初始化.
单态设计模式:就是采取一定的方法保证在整个软件系统中,对某一个类只能村子一个对象实例.
具体方法是:
public class TestSingle
{
private static final TestSingle onlyOne=new TestSingle();
public static TestSingle getTestSingle(){
return onlyOne;
}
private TestSingle(){}
}
//具体流程是:在外面函数写上 TestSingle a=TestSingle.getTestSingle();
//这样就返回onlyOne,而onlyOne已经初始化了.
//其实是效果是让new 这种构造函数不好使,然后改一个新的构造函数,这个构造函数得到的对象是静态的,所以只能得到一个.
final关键字:
1.final的类不能被继承
2.final的方法不能被子类重写
3.final的变量就是常量,只能被赋值一次.
比如final int x=3;
x=4;//出错
接口:
接口中只包含常量和方法的定义,而没有实现.
写法:
public interface Runner
{
int ID=1;
void run();
}
class Student extends Person implements Runner
{
public void run(){
System.out.println("the student is running");
}
}
interface Flyer
{
void fly();
}
class Bird implementse Runner,Flyer
{
public void run()
{
System.out.println("the bird is running");
}
public void fly()
{
System.out.println("the bird is flying");
}
}
#接口里面的变量都是默认
public static final 的.
所以可以按照下面的方式进行访问
class TestFish
{
public static void main(String args[])
{
Fish f=new Fish();
int j=0;
j=Runner.ID;//正确
j=f.ID;//正确
f.ID=2;//错误,因为默认是final的
}
}
关于object的equals方法.
用equals来比较任何类中2个对象,时候,返回值永远是False,所以需要自己在类中覆盖这个object类的equals方法.才行.(所以需要手动写)
c++笔记
short 2个字节
指针:4个字节
/*考察结构体对齐和填充：
结构体每个成员相对于结构体首地址的偏移量都是成员大小的整数倍，如果不是，编译器会自动在成员间填充。*/
总结:一般是宽4个字节的矩形,不够的就填充上.
struct A {
int a; //4 bytes
char b; //1 bytes
//char pad[3] //3 bytes
int c; //4 bytes
char d; //1 bytes
//char pad[3] //3 bytes
} // total = 16 bytes
以下哪个容器的删除操作会进行内存的移动
正确答案: D 你的答案: B (错误)
map
list
set
vector
给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树.所以哈夫曼树是二叉树,不是二叉平衡树
fwrite和fread 是带缓冲的IO，read和write是不带缓冲的，
父进程open了一个文件，并且通过fork产生一个子进程，以下说法正确的是子进程复制了父进程的文件描述符表
以下可以用来处理哈希表冲突的方法是开放定址法链地址法再哈希法
关于多线程,下面说法正确的是：
当多个线程对某个原子数据进行读写操作时，读操作不用加锁，只用对写操作加锁即可
protected成员不可以被类的调用方访问
public成员可以被派生类访问
private : 私有成员, 在类的内部才可以访问。 protected : 保护成员,该类内部和继承类中可以访问
即:protected,public都不能被累的调用访问.
段错误:通过上面的解释，段错误应该就是访问了不可访问的内存，这个内存区要么是不存在的，要么是受到系统保护的。
这段代码执行后的输出结果是：
char *str = “Thunder Network”;
str[0] = ‘\0’;
printf(“%s\n”, str);
就是段错误
c++程序设计教程:钱能主编,清华大学出版.
笔记
2018-09-17,0点24
用sublime搭建c++环境.
1.下载mingw
由于网站下载过于麻烦，所以大家可以到我的网盘里面去下载该安装包
网址：https://pan.baidu.com/s/1qZYArve 密码：u32s
2.配置环境变量,然后重新启动
3.在sublime中编译选择c++ single即可.
克苏鲁神话
一个字符占有一个内存单元
一个字符的字符串占2个内存单元.
因为他末尾是/0
C++编程中,常量定义都用const,不用#define
sublime运行程序之后的框,只要按esc就自动消失了.
;是空语句就是python的pass语句
我一直认为do...while语句非常闲的,你要do一次你可以直接写while语句外面啊,非要写个do.岂不是显得多打2个字母.
c++不允许函数定义嵌套,即在函数定义中再定义一个函数是非法的!
一个程序将操作系统分配给的内存分成4个区域:
1.代码区:存放程序的代码
2.全局数据区,存放程序的全局数据和静态数据
3.堆区,存放动态数据
4.栈区,存放函数中的数据
在函数外面的变量是全局变量,在程序的每一个函数中都是可以访问的.如果没有赋值就默认是0.
全局变量要写在程序的顶部!!!!!!!!,不然在全局变量之前写的函数不能用这个全局变量.
静态局部变量:
加入static值,只初始化一次!!!!!!!
例子:
#include
using namespace std;
int func2(){
static int m=5;//说白了就是这句话只运行一次!原因是这句话的本质是开内存,但是static是永久存在的,只需要开一次,所以c++就规定这句话只运行一次.
m+=6;
return m;
}
int main()
{
using namespace std;
func2();
func2();
func2();
func2();
func2();
cout<='0'&& ch<='9')?1:0;
}
默认参数的设置:只需要在声明里面写上
如:
void delay(int =1000);
局部作用域:
如果在if语句和switch语句中进行条件测试的表达式中声明标识符,那么该标识符的作用域在该语句中.
在if条件表达式半段之后的语句和else之后的语句为一个语句块,尽管有时候只是一条语句.
在for语句中的第一个表达式中声明的标识符,他的作用域在for语句内.
::s 指的是全局变量s
动态生命期:
这种生命期的程序用malloc()和free() 或者 new和delete 来创建和释放.
具有这种生命周期的变量在内存的堆中.
具体就是开始malloc就生命期开始,用free就生命期结束.
初始化字符数组.
char array[10]="hello";
这种方法.系统自动在数组没有赋值的地方都用'\0'补上.
或者不用写大小也可以.
char array[]="hello";
向函数传递数组:
无论何时,将数组作为参数传给函数,实际上是传的地址.
无穷大用0x3f3f3f3f来替代.这个是acmer的技巧之一.
#include
memset赋值不了1.因为他是按照字节来赋值.
数组里面元素是1.所以他其实是赋值了4次.
所以
memset(ia1,1,50*sizeof(int));
他其实是赋值了1000000010000000100000001
也就是16843009.
负无穷:-0x3f3f3f3f
指针:
指针的工作方式:
指针是一个变量里面存一个地址.
这个地址就是变量x的真实位置这个地址.
这样就表示了这个指针指向x
指针的指针就是二级指针.
允许语句*p=(int)&count;
作用就是把地址强制转化成一个整数传给p的内容.
指针使用前要初始化,要把指针需要的地址赋值给指针
堆操作:
利用堆可以动态的分配内存,不要的时候马上释放掉,这样空间利用率高.
方法.
例子:
#include
using namespace std;
int main()
{
int arraysize=5;
int *array;
cout <<"please input a number of array:\n";
if ((array=new int[arraysize])==NULL)
{cout<<"can't allocate more memory,terminating.\n";
exit(1);
}
for (int count=0;count
using namespace std;
int main()
{
char *p;
p="hello";
cout<
using namespace std;
int main()
{
char buffer1[10]="hello";
char buffer2[10]="hello";
cout<<(buffer1==buffer2);
cout<<("hello"=="hello");
}
从这个例子中看出字符串数组和字符串本身不一样,
字符串数组比较的是数组的地址,而字符串本身比较是比较字符串的书写是否一样.
所以比较字符串数组用:
cout<<(strcmp(buffer1,buffer2)==0);
即可,输出1.就表示字符串相同
修改字符串用
strcpy(buffer2,"hmmmm");
指针数组:数组的元素都是一个指针的数组.
例如:
char * proname[]={"Fortran","C","C++"};
指针数组和二维数组是不同的,因为指针数组里面的指针的内容的长度可以互相不同.但是二维数组必须是一个矩形.
例子:
#include
#include
using namespace std;
void print(char * arr[])
{
while (*arr!=NULL){
cout<<(int)*arr<<" "
<<*arr<
#include
#include
using namespace std;
//把函数指针作为参数使用 func就是函数指针,使用时候跟函数一样.因为函数本质就是地址
double sigma(double(*func)(double),double dl,double du)
{double dt=0.0;
for (double d=dl;d
#include
#include
#include
using namespace std;
int main()
{
int intOne;
int &rint =intOne;//建立别名
intOne=5;
cout<<"intOne:"<
#include
#include
#include
using namespace std;
int main()
{
int intOne;
int & rint =intOne;//建立别名
intOne=5;
cout<<"intOne:"<
#include
#include
#include
using namespace std;
int main()
{
int intOne;
int & rint =intOne;//建立别名
intOne=5;
cout<<"intOne:"<
#include
#include
#include
using namespace std;
int main()
{
int *a;
int *&p=a;
int b=8;
p=&b;
cout<<*p;
}
void 和指针不能建立引用.
因为.void没有类型.引用必须要类型.
数组是一对类型的集合,他不是一个数据类型.所以不能建立引用.
引用本身也不是一个数据类型,所以没有引用的引用.
也不能用NULL来对引用进行赋值,因为引用需要一个具有类型的对象来进行赋值.
引用比指针用起来更简单
省去了很多*的书写.
#include
#include
#include
#include
using namespace std;
void swap(int &rx,int&ry)
{
int tmp;
tmp=rx;
rx=ry;
ry=tmp;
}
int main()
{
int x=5;
int y=56;
swap (x,y);
cout<即可.
#include
#include
#include
#include
using namespace std;
struct Person
{
char name[20];
unsigned long id;
float salary;
};
int main()
{
Person pr1;
Person *p;
p=&pr1;
strcpy(p->name,"david");//字符串不能用=赋值.
p->id=3242;
p->salary=335.0;
cout<name<id<salary<
#include
#include
#include
using namespace std;
class Account
{
public:
virtual void withdrawal(float amount)=0;
};
class Savings:public Account
{
public:
virtual void withdrawal(float amount)
{
cout<<"jianqu100";
}
};
//因为下一行你调用的对象是一个account
//所以account里面必须有withdrawal方法才行.
//所以需要这个纯虚函数.
void func(Account *pA)
{
pA->withdrawal(100.0);
}
int main()
{
Savings s;
func(&s);
}
上面这个代码必须写上纯虚函数.不然只能这样写,这就是纯虚函数的意义.
#include
#include
#include
#include
using namespace std;
class Account
{
};
class Savings:public Account
{
public:
virtual void withdrawal(float amount)
{
cout<<"jianqu100";
}
};
//因为下一行你调用的对象是一个account
//所以account里面必须有withdrawal方法才行.
//所以需要这个纯虚函数.
void func(Savings *pA)
{
pA->withdrawal(100.0);
}
int main()
{
Savings s;
func(&s);
}
模板:
分2种:
函数模板,类模板
函数模板例子:
#include
#include
#include
#include
using namespace std;
template T maxi(T a,T b)
{
return a>b?a:b;
}
int main()
{
cout<
#include
#include
#include
using namespace std;
template T maxi(T a,T b)
{
return b;
}
char maxi(char a ,char b)
{
return a;
}
int main()
{
cout<而已
#include
#include
#include
#include
using namespace std;
template int maxi(T a,T b)
{
return 777;
}
int main()
{
cout<
非常经典的迷宫,字谜题,经典的深度遍历模板
#下面这一段用一个txt来保存input的信息来模拟input.最后提交代码时候删除这一段即可.
a9999=open('1.txt','r')
def input():
return a9999.readline().rstrip('\n')
#结束.
'''
题目是:
5 5 3
hello help high
p a b h m
f h e c p
o i l l h
b g h o n
h x c m l
题意是在字典中找是否有这3个单词.
'''
#这个题目是leetcode79题,当时会做,现在不会了,其实当时也是想了很久才想出来.
'''
算法用普通的迷宫走法是不行的.原因就是找字母比如aaa,我找第三个字母的时候,在第二个字母处把坐标i,j给标记了,那么我找
第三个字母的时候迷宫走法当然不用再走第二个字母了.但是这个题目需要走第二个字母.
我当时的做法是把走的每一步的index记录下来.
'''
a=[5 ,5 ,3]
b=['hello','help','high']
c=[['p','a','b','h','m'],['f','h','e','c','p'],['o','i','l','l','h'],
['b','g','h','o','n'],['h','x','c','m','l']]
#https://www.cnblogs.com/lengender-12/p/6931193.html 这个博客写的很pl
memo={}
def judge(board,i,j,m,n,word,k,memo):
'''
判断从棋盘board的i,j位置开始走,棋盘大小m*n,寻找单词word从k开始是否成立.memo用来记录这个点是否走过
'''
if i<0 or j<0 or i==m or j==n or (i,j) in memo or board[i][j]!=word[k]:
return False;
memo[(i,j)]=1
if k==len(word)-1:
return True
res=judge(board, i + 1, j, m, n, word, k + 1, memo)\
or judge(board, i - 1, j, m, n, word, k + 1, memo)\
or judge(board, i, j + 1, m, n, word, k + 1, memo)\
or judge(board, i, j - 1, m, n, word, k + 1, memo)
memo.pop((i,j))
'''
是不是因为运行到这句的时候,说明已经把word的比k大的开始这些情况都跑过了且一定是false,不然return了.
所以之后不会再需要比较按照i,j这个index了,所以置false,为了返回比k小的情况时候还能继续使用棋盘上的这个点.
'''
return res
out=[]
for word in b:
for i in range(len(a)):
for j in range(a[0]):
if judge(c,i,j,a[0],a[1],word,0,memo):
out.append(word)
print(out)
头条的题目:非常精彩的递归问题!!!!!!!!!
#下面这一段用一个txt来保存input的信息来模拟input.最后提交代码时候删除这一段即可.
a9999=open('1.txt','r')
def input():
return a9999.readline().rstrip('\n')
#结束.
#球问题:
'''
头条第三个题目:
m个红球,k个绿球,v和篮球,排成一行,要求相邻的颜色必须不同.
解答:f1(m,k,v)表示第一个球是红球的时候,的拍法
解答:f2(m,k,v)表示第一个球是绿球的时候,的拍法
解答:f3(m,k,v)表示第一个球是蓝球的时候,的拍法
'''
memo1={}
memo2={}
memo3={}
def f1(m,k,v):
if (m,k,v) in memo1:
return memo1[(m,k,v)]
if m==1 and k==1 and v==1:
return 2
if m==0:
return 0
if v ==0 or k==0:
if 0<=m-(v+k)<=1:
return 1
else:
return 0
memo1[(m,k,v)]=f2(m-1,k,v)+f3(m-1,k,v)
return memo1[(m,k,v)]
def f2(m,k,v):
if (m,k,v) in memo2:
return memo2[(m,k,v)]
if m==1 and k==1 and v==1:
return 2
if k==0:
return 0
if m ==0 or v==0:
if 0<=k-(m+v)<=1:
return 1
else:
return 0
memo2[(m,k,v)]=f1(m,k-1,v)+f3(m,k-1,v)
return memo2[(m,k,v)]
def f3(m,k,v):
if (m,k,v) in memo3:
return memo3[(m,k,v)]
if m==1 and k==1 and v==1:
return 2
if v==0:
return 0
if m ==0 or k==0:
if 0<=v-(m+k)<=1:
return 1
else:
return 0
memo3[(m,k,v)]=f1(m,k,v-1)+f2(m,k,v-1)
return memo3[(m,k,v)]
def f(m,k,v):
return f1(m,k,v)+f2(m,k,v)+f3(m,k,v)
print(f(15,15,15))
经过这个题目:总结动态规划的2个基本思路:
1.加维数来细化分类后递归 2.加函数个数来细化分类后递归(这个题目就是第二个思路)
我又变态的提高到4种颜色的问题,成功跑出1,1,1,2 答案36
#下面这一段用一个txt来保存input的信息来模拟input.最后提交代码时候删除这一段即可.
a9999=open('1.txt','r')
def input():
return a9999.readline().rstrip('\n')
#结束.
#球问题:
'''
头条第三个题目:
m个红球,k个绿球,v和篮球,排成一行,要求相邻的颜色必须不同.
解答:f1(m,k,v)表示第一个球是红球的时候,的拍法
解答:f2(m,k,v)表示第一个球是绿球的时候,的拍法
解答:f3(m,k,v)表示第一个球是蓝球的时候,的拍法
'''
memo1={}
memo2={}
memo3={}
def f1(m,k,v):
if (m,k,v) in memo1:
return memo1[(m,k,v)]
if m==1 and k==1 and v==1:
return 2
if m==0:
return 0
if v ==0 or k==0:
if 0<=m-(v+k)<=1:
return 1
else:
return 0
memo1[(m,k,v)]=f2(m-1,k,v)+f3(m-1,k,v)
return memo1[(m,k,v)]
def f2(m,k,v):
if (m,k,v) in memo2:
return memo2[(m,k,v)]
if m==1 and k==1 and v==1:
return 2
if k==0:
return 0
if m ==0 or v==0:
if 0<=k-(m+v)<=1:
return 1
else:
return 0
memo2[(m,k,v)]=f1(m,k-1,v)+f3(m,k-1,v)
return memo2[(m,k,v)]
def f3(m,k,v):
if (m,k,v) in memo3:
return memo3[(m,k,v)]
if m==1 and k==1 and v==1:
return 2
if v==0:
return 0
if m ==0 or k==0:
if 0<=v-(m+k)<=1:
return 1
else:
return 0
memo3[(m,k,v)]=f1(m,k,v-1)+f2(m,k,v-1)
return memo3[(m,k,v)]
def f(m,k,v):
return f1(m,k,v)+f2(m,k,v)+f3(m,k,v)
print(f(15,15,15))
'''
2018-09-22,15点02
下面开始显得蛋疼.如果是4钟球.那么这个题目如何解答??????
'''
'''
研究发现,需要利用3个球的结果.所以
定义
f14:4种球的时候表示第一个球是红球的时候,的拍法
f24:4种球的时候表示第一个球是白球的时候,的拍法
f34:4种球的时候表示第一个球是绿球的时候,的拍法
f44:4种球的时候表示第一个球是黑球的时候,的拍法
'''
def f14(m,k,v,z):
if m==1 and k==1 and v==1 and z==1:
return 6
if m==0:
return 0
if k==0:
#这时候就退化成为3种球的结果
return f1(m,v,z)#不用讨论k,v,z中2个同时为0的情况了.因为3种球里面分析过了
if v==0:
return f1(m,k,z)
if z==0:
return f1(m,k,v)
return f24(m-1,k,v,z)+f34(m-1,k,v,z)+f44(m-1,k,v,z)
def f24(m,k,v,z):
if m==1 and k==1 and v==1 and z==1:
return 6
if k==0:
return 0
if m==0:
#这时候就退化成为3种球的结果
return f1(k,v,z)#不用讨论k,v,z中2个同时为0的情况了.因为3种球里面分析过了
if v==0:
return f2(m,k,z)
if z==0:
return f2(m,k,v)
return f14(m,k-1,v,z)+f34(m,k-1,v,z)+f44(m,k-1,v,z)
def f34(m,k,v,z):
if m==1 and k==1 and v==1 and z==1:
return 6
if v==0:
return 0
if m==0:
#这时候就退化成为3种球的结果
return f2(k,v,z)#不用讨论k,v,z中2个同时为0的情况了.因为3种球里面分析过了
if k==0:
return f2(m,v,z)
if z==0:
return f3(m,k,v)
return f14(m,k,v-1,z)+f24(m,k,v-1,z)+f44(m,k,v-1,z)
def f44(m,k,v,z):
if m==1 and k==1 and v==1 and z==1:
return 6
if z==0:
return 0
if m==0:
#这时候就退化成为3种球的结果
return f3(k,v,z)#不用讨论k,v,z中2个同时为0的情况了.因为3种球里面分析过了
if k==0:
return f3(m,v,z)
if v==0:
return f3(m,k,z)
return f14(m,k,v,z-1)+f24(m,k,v,z-1)+f34(m,k,v,z-1)
def final4(m,k,v,z):
return f14(m,k,v,z)+f24(m,k,v,z)+f34(m,k,v,z)+f44(m,k,v,z)
print(final4(1,1,1,2))
'''
感觉用了毕生的动态规划功力
'''
算法题:下一个排列,经典算法背一背
'''
题目:下一个排列
'''
#思路是:先从后往前找.比如123,他
#的后2位可以变大,就让后两位做变换.变换方法是:2找到后面比2大的数,跟2位置交换.之后这个位置后面的数做降序排列即可.
def nextPermutation( nums):
"""
:type nums: List[int]
:rtype: void Do not return anything, modify nums in-place instead.
"""
#先找到可以交换的位置.
'''
比如1,3,2 那么i从2,3,1开始找,j每一次从2,3,1开始找.i到1时候,j到2会发现这时候1<2.那么交换1,2之后序列会变大,
之后吧i往后的sorted即可.
'''
for i in range(len(nums)-1,-1,-1):
for j in range(len(nums)-1,i,-1):
if nums[j]>nums[i]:
nums[i],nums[j]=nums[j],nums[i]
out=nums[:i+1]+sorted(nums[i+1:])
return out
return sorted(nums)
print(nextPermutation([1,3,2]))
a=[[0]*n for i in range(n)] #二维数组最快的写法:
leetcode笔记
#下面这一段用一个txt来保存input的信息来模拟input.最后提交代码时候删除这一段即可.
a9999=open('1.txt','r')
def input():
return a9999.readline().rstrip('\n')
#结束.
#coding:utf-8
'''
45. 跳跃游戏 II
'''
memo={}
import sys
sys.setrecursionlimit(1000000) #执行这个代码后，递归深度调整到1000000层，基本上够用了。
def main(arr,start,end):
'''
返回一个int,表示从start位置跳跃到end位置需要多少不走
'''
if (start,end) in memo:
return memo[(start,end)]
if end ==start:
return 0
if arr[start]+start>=end:
memo[(start,end)]=1
return memo[(start,end)]
else:
out=float('inf')
for i in range(start+1,end):
tmp=main(arr,start,i)+main(arr,i,end)
if tmplastpos:
lastpos=maxpos
step+=1
maxpos=max(maxpos,i+nums[i])
return step
print(jump([3,4,1,1,1]))
'''
比如3,4,1,1,1
上来i=0时候,maxpos=3
i=1,maxpos=4, step+1
i=2,maxpos=4
i=3,maxpos=4
i=4,......
i=5 step+1
'''
a=[[1,2,3],[4,5,6],[7,8,9]]
'''
54. 螺旋矩阵
'''
class Solution:
def spiralOrder(self, matrix):
"""
:type matrix: List[List[int]]
:rtype: List[int]
"""
def main(a):
import numpy
a=numpy.array(a)
save=[]
while len(a)!=0:
for i in a[0]:
save.append(int(i))#leetcode 强制类型检查,所以这里要转回int
a=a[1:]
#左转90度
tmp=a.T
tmp=tmp[::-1]
a=tmp
return save
return main(matrix)
a=[8,2,4,4,4,9,5,2,5,8,8,0,8,6,9,1,1,6,3,5,1,2,6,6,0,4,8,6,0,3,2,8,7,6,5,1,7,0,3,4,8,3,5,9,0,4,0,1,0,5,9,2,0,7,0,2,1,0,8,2,5,1,2,3,9,7,4,7,0,0,1,8,5,6,7,5,1,9,9,3,5,0,7,5]
memo={}
def canjump(nums,obj):
if obj in memo:
return memo[obj]
if obj==0:
return True
for i in range(obj):
if ( canjump(nums,i) and nums[i]>=(obj-i))==True:
memo[obj]=True
return True
memo[obj]=False
return False
print(canjump(a,len(a)-1))
print(canjump(a,3))
'''
55. 跳跃游戏
'''
def canjump( nums):
"""
:type nums: List[int]
:rtype: int
"""
step=0
lastpos=0
maxpos=0
for i in range(len(nums)):
if i>maxpos:
return False
maxpos=max(maxpos,i+nums[i])
return True
print(canjump(a))
'''
56. 合并区间
'''
# Definition for an interval.
# class Interval:
# def __init__(self, s=0, e=0):
# self.start = s
# self.end = e
class Solution:
def merge(self, intervals):
"""
:type intervals: List[Interval]
:rtype: List[Interval]
"""
"""
:type intervals: List[Interval]
:rtype: List[Interval]
"""
save=sorted(intervals,key=lambda x:(x.start,x.end))
#这个叫多级排序技巧.用一个tuple来解决多级.当第一个分量一样的时候按照第二个进行排列
out=[]
for i in range(len(save)):
tmp=save[i]
if out==[]:
out.append(tmp)
now_index=0
else:
now_index=len(out)-1
if tmp.start<=out[now_index].end and tmp.end>=out[now_index].end:
out[now_index].end=tmp.end
elif tmp.start<=out[now_index].end and tmp.end
2018-09-28,17点25 做了网易笔试,学到了很多,特别是2分加速的应用!!!!!!!还是编程实例太弱了
#下面这一段用一个txt来保存input的信息来模拟input.最后提交代码时候删除这一段即可.
a9999=open('1.txt','r')
def input():
return a9999.readline().rstrip('\n')
'''
方法做模拟即可
'''
'''
题目:
A和B分钱,B先分m元,A分下面的0.1倍向下取整,
问B最少m取多少能保证B分到>=一般的钱.这个题目没做出来,现在知道应该2分加速
这个技巧.这里面要实现它.因为这个是2分加速的模板!
'''
a=int(input())
print(a)
#二分法第一步做函数
def fun(i,a):
tmp=i
save=a
first=0
second=0
while save>0:
if save//10<1:
break
else:
save-=tmp
first+=save//10
save-=save//10
if first<=a//2:
return True
return False
#二分法第二步:二分循环.
tmp=1
end=a
while (end-tmp)>1:
now=(tmp+end)//2
if fun(now,a)==False:
tmp=(tmp+end)//2
else:
end=(tmp+end)//2
#输出结果
if fun(tmp,a)==True:
print(tmp)
else:
print(end)
#从结果看无论多大数,都秒算,二分加速的威力,但是考试时候只是最后5分钟想到了.之前一直纠结在上下界,或者是否能直接用数学算出来.
#还是太年轻了!!!!!!
经典的二分加速的总结
#下面这一段用一个txt来保存input的信息来模拟input.最后提交代码时候删除这一段即可.
a9999=open('1.txt','r')
def input():
return a9999.readline().rstrip('\n')
'''
方法做模拟即可
'''
'''
题目:
A和B分钱,B先分m元,A分下面的0.1倍向下取整,
问B最少m取多少能保证B分到>=一般的钱.这个题目没做出来,现在知道应该2分加速
这个技巧.这里面要实现它.因为这个是2分加速的模板!
'''
a=int(input())
print(a)
#二分法第一步做函数
def fun(i,a):
start=i
save=a
first=0
second=0
while save>0:
if save//10<1:
break
else:
save-=start
first+=save//10
save-=save//10
if first<=a//2:
return True
return False
#二分法第二步:二分循环.
start=1
end=a
while (end-start)>1:#这个条件很经典,二分都是这个判定来退出循环
now=(start+end)//2
if fun(now,a)==False:
start=(start+end)//2
else:
end=(start+end)//2
#输出结果
if fun(start,a)==True:
print(start)
else:
print(end)
#从结果看无论多大数,都秒算,二分加速的威力,但是考试时候只是最后5分钟想到了.之前一直纠结在上下界,或者是否能直接用数学算出来.
#还是太年轻了!!!!!!
print('继续研究二分法')
'''
继续研究2分法的写法:
有序数组中找元素的index
'''
arr=[1,3,5,6,8,96,324]
target=8
#这个直接写:
start=0
end=len(arr)-1
while (end-start)>1:#这个条件很经典,二分都是这个判定来退出循环
now=(start+end)//2
if arr[now]==target:#每一次不同的二分问题改这里面的if即可.
out=now
break
elif arr[now]>target:
end=(start+end)//2
else:
start=(start+end)//2
print(now)
编程之法书的一些笔记:
#下面这一段用一个txt来保存input的信息来模拟input.最后提交代码时候删除这一段即可.
a9999=open('1.txt','r')
def input():
return a9999.readline().rstrip('\n')
'''
方法做模拟即可
'''
'''
题目:
A和B分钱,B先分m元,A分下面的0.1倍向下取整,
问B最少m取多少能保证B分到>=一般的钱.这个题目没做出来,现在知道应该2分加速
这个技巧.这里面要实现它.因为这个是2分加速的模板!
'''
a=10
print(a)
#二分法第一步做函数
def fun(i,a):
start=i
save=a
first=0
second=0
while save>0:
if save//10<1:
break
else:
save-=start
first+=save//10
save-=save//10
if first<=a//2:
return True
return False
#二分法第二步:二分循环.
start=1
end=a
while (end-start)>1:#这个条件很经典,二分都是这个判定来退出循环
now=(start+end)//2
if fun(now,a)==False:
start=(start+end)//2
else:
end=(start+end)//2
#输出结果
if fun(start,a)==True:
print(start)
else:
print(end)
#从结果看无论多大数,都秒算,二分加速的威力,但是考试时候只是最后5分钟想到了.之前一直纠结在上下界,或者是否能直接用数学算出来.
#还是太年轻了!!!!!!
print('继续研究二分法')
'''
继续研究2分法的写法:
有序数组中找元素的index
'''
arr=[1,3,5,6,8,96,324]
target=8
#这个直接写:
start=0
end=len(arr)-1
while (end-start)>1:#这个条件很经典,二分都是这个判定来退出循环
now=(start+end)//2
if arr[now]==target:#每一次不同的二分问题改这里面的if即可.
out=now
break
elif arr[now]>target:
end=(start+end)//2
else:
start=(start+end)//2
print(now)
#继续用牛客网刷编程题:
'''
因为牛客网上答案详细.
'''
'''
牛牛数星星
'''
'''
链接：https://www.nowcoder.com/questionTerminal/357ffdc995994fd7b9ffbb8971a86e99
来源：牛客网
一闪一闪亮晶晶，满天都是小星星，牛牛晚上闲来无聊，便躺在床上数星星。
牛牛把星星图看成一个平面，左上角为原点(坐标为(1, 1))。现在有n颗星星，他给每颗星星都标上坐标(xi，yi)，表示这颗星星在第x行，第y列。
现在，牛牛想问你m个问题，给你两个点的坐标(a1, b1)(a2，b2)，表示一个矩形的左上角的点坐标和右下角的点坐标，请问在这个矩形内有多少颗星星(边界上的点也算是矩形内)。
输入描述:
第一行输入一个数字n(1≤n≤100000)，表示星星的颗数。
接下来的n行，每行输入两个数xi和yi(1≤xi，yi≤1000)，表示星星的位置。
然后输入一个数字m(1≤m≤100000), 表示牛牛询问问题的个数。
接下来m行，每行输入四个数字a1，b1，a2，b2(1≤a1＜a2≤1000), (1≤b1＜b2≤1000)
题目保证两颗星星不会存在于同一个位置。
'''
'''
这个问题:答案上写是2维前缀和问题.
'''
'''
num=int(input())
if num==0:
print()
stars = [[0]*1001 for i in range(1001)]
for i in range(num):
tmp=[int(i)for i in input().split()]
x=tmp[0]
y=tmp[1]
stars[x][y]=1
#因为这个题目坐标是从1开始的,所以下面从1开始for循环.
for i in range(1,1001):
for j in range(1,1001):
stars[i][j] = stars[i][j] + stars[i-1][j] + stars[i][j-1] - stars[i-1][j-1]
#这里为什么可以直接覆盖原矩阵:因为i,j永远等号右边用的比i,j要小,所以不会丢失数据.
#这个方法节省很多内存空间.
m=int(input())
for i in range(m):
tmp=[int(i)for i in input().split()]
x1=tmp[0]
y1=tmp[1]
x2=tmp[2]
y2=tmp[3]
print (stars[x2][y2] + stars[x1-1][y1-1] - stars[x1-1][y2] - stars[x2][y1-1] )
'''
'''
链接：https://www.nowcoder.com/questionTerminal/fc6996e7aa614116bf401f0cfd33eb23?orderByHotValue=1&questionTypes=000100&page=1&onlyReference=false
来源：牛客网
[编程题]手串
热度指数：344时间限制：1秒空间限制：65536K
算法知识视频讲解
作为一个手串艺人，有金主向你订购了一条包含n个杂色串珠的手串——每个串珠要么无色，要么涂了若干种颜色。为了使手串的色彩看起来不那么单调，金主要求，手串上的任意一种颜色(不包含无色)，在任意连续的m个串珠里至多出现一次(注意这里手串是一个环形)。手串上的颜色一共有c种。现在按顺时针序告诉你n个串珠的手串上，每个串珠用所包含的颜色分别有哪些。请你判断该手串上有多少种颜色不符合要求。即询问有多少种颜色在任意连续m个串珠中出现了至少两次。
输入描述:
第一行输入n，m，c三个数，用空格隔开。(1 <= n <= 10000, 1 <= m <= 1000, 1 <= c <= 50) 接下来n行每行的第一个数num_i(0 <= num_i <= c)表示第i颗珠子有多少种颜色。接下来依次读入num_i个数字，每个数字x表示第i颗柱子上包含第x种颜色(1 <= x <= c)
'''
'''
题意说:一个珠子图了很多颜色.
感觉就是for循环判定即可.
'''
'''
print('新问题')
n,m,c=map(int,input().split())
save=[]
#都放数组里面
for i in range(n):
save.append([int(i) for i in input().split()][1:])
save
#统计的是颜色!从题目上看到color很小,所以for 按照c的值来.
memo={}
#遍历所有珠子,遇到一个颜色就给他的index存到memo字典里面存成一个数组然后
#当这个数组长度大于1时候判断里面是否有index距离小于m.
count=0
for i in range(1,c+1):
tmp=[]#记录颜色i的index.
for j in range(n):
if i in save[j]:
tmp.append(j)
if len(tmp)>=2 :
if tmp[-1]-tmp[-2]m:
n,m=m,n
count=0
for i in range(1,n+1):#让小的开始遍历
s=1
j=2
while j<=i//j:
if i%j**2==0:
s=j**2
j+=1
tmp=i//s
j=m//tmp
count+=int(j**0.5)
print(count)
'''
'''
网上找的别人的算法:
所以如果取到m=12时，我们要先求12有没有因子是完全平方的，如果有，找出因子中最大的完全平方，然后相除计算得到k，这个k就是说明取到的small值是最大平方和因子的k倍。那么在big中还可以取k*1*1, k*2*2, k*3*3….保持<= big值。非常精彩!!!!!!!!!!!!!
并且通过这个题目也知道了,python比java慢了10倍!所以工程还是用java
'''
'''
java版本代码:
import java.util.Scanner;
/**
* Created by Administrator on 2018/3/25 0025.
*/
public class Main1 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int m = 100000;
int n = 100000;
int big = m > n ? m : n;
int small = m < n ? m : n;
int res = 0;
for (int i = 1; i <= small; i++) {
int s = 1;
for (int j = 2; j <= i / j; j++) {
if (i % (j * j) == 0) {
s = j * j;
}
}
int r = i / s;
for (int j = 1; j * j * r <= big; j++) {
res++;
}
}
System.out.println(res);
}
}
'''
'''
链接：https://www.nowcoder.com/questionTerminal/bd7f978302044eee894445e244c7eee6?orderByHotValue=1&questionTypes=000100
来源：牛客网
[编程题]整数中1出现的次数(从1到n整数中1出现的次数)
热度指数：133764时间限制：1秒空间限制：32768K
算法知识视频讲解
求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数(从1 到 n 中1出现的次数)。
'''
'''
链接：https://www.nowcoder.com/questionTerminal/661c49118ca241909add3a11c96408c8?orderByHotValue=1&questionTypes=000100
来源：牛客网
[编程题]合唱团
热度指数：104617时间限制：1秒空间限制：32768K
算法知识视频讲解
有 n 个学生站成一排，每个学生有一个能力值，牛牛想从这 n 个学生中按照顺序选取 k 名学生，要求相邻两个学生的位置编号的差不超过 d，使得这 k 个学生的能力值的乘积最大，你能返回最大的乘积吗？
输入描述:
每个输入包含 1 个测试用例。每个测试数据的第一行包含一个整数 n (1 <= n <= 50)，表示学生的个数，接下来的一行，包含 n 个整数，按顺序表示每个学生的能力值 ai(-50 <= ai <= 50)。接下来的一行包含两个整数，k 和 d (1 <= k <= 10, 1 <= d <= 50)。
挺复杂的一个题目.
'''
'''
#别人的答案.
N = int(input())
A = map(int, input().split())
A=list(A)
K, D = map(int, input().split())
#因为有正反所以分成两部分
dpmax = [[0]*N for i in range(K)]#列出未来将要用到的结果位置,k取行+1时候n取列的时候表示最后取到n时候能拼成的max值.
dpmin = [[0]*N for i in range(K)]#同上
for n in range(N):
dpmax[0][n] = dpmin[0][n] = A[n]#就是在k=1时，取第一个值时
for k in range(1,K):
for pre in range(max(0,n-D),n):#因为有间隔,所以如果间隔大于n,可以全取,反之需从间隔部分之后开始
#pre表示上一个最后一个index,不用2个max,用一个max即可.
dpmax[k][n] = max(dpmax[k][n],dpmax[k-1][pre]*A[n],dpmin[k-1][pre]*A[n])#不断与之前的进行比较获取最大
dpmin[k][n] = min(dpmin[k][n],dpmax[k-1][pre]*A[n],dpmin[k-1][pre]*A[n])#不断与之前进行比较获取最小
print(max([x for x in dpmax[K-1]]))
'''
'''
链接：https://www.nowcoder.com/questionTerminal/6e5207314b5241fb83f2329e89fdecc8?orderByHotValue=1&questionTypes=000100
来源：牛客网
[编程题]机器人的运动范围
热度指数：109920时间限制：1秒空间限制：32768K
算法知识视频讲解
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格(35,37)，因为3+5+3+7 = 18。但是，它不能进入方格(35,38)，因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
'''
'''
# -*- coding:utf-8 -*-
a,b,c=10,1,100
#anser=21
def movingCount( threshold, rows, cols):
# write creturn ode here
flag=[[0]*cols for i in range(rows)]
def dp(rows,cols,m,n,threshold,flag):#数组本质是地址,所以直接写flag即可就是全局变量
#棋盘rows行,cols列,从m,n坐标出发能走多少个格
if m<0 or m>=rows or n<0 or n>=cols or Sum_num(m)+Sum_num(n)>threshold or flag[m][n]==1:
return 0
flag[m][n]=1
return dp(rows,cols,m+1,n,threshold,flag)+dp(rows,cols,m-1,n,threshold,flag)+dp(rows,cols,m,n+1,threshold,flag)+dp(rows,cols,m,n-1,threshold,flag)+1
def Sum_num(a):
count=0
while a!=0:
count+=a%10
a=a//10
return count
return dp(rows,cols,0,0,threshold,flag)
print(movingCount(a,b,c))
'''
'''
链接：https://www.nowcoder.com/questionTerminal/b736e784e3e34731af99065031301bca?orderByHotValue=1&questionTypes=000100&page=4&onlyReference=false
来源：牛客网
[编程题]二叉树中和为某一值的路径
热度指数：255923时间限制：1秒空间限制：32768K
算法知识视频讲解
输入一颗二叉树的跟节点和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中，数组长度大的数组靠前)
'''
'''
python里面函数能直接访问函数外面的变量
但是只是值传递,函数作用完,外面变量的值还是以前的值,
如果要统一加global即可.但是对于数组默认是传地址的.
a=3
def fun(bdsfa):
print(a)
fun(3)
'''
'''
数组拷贝命令
a=b[:]
例子:
a=[1,34,4,5]
b=a[:]
a=[1]
print(b)
'''
class Solution:
def FindPath(self, root, expectNumber):
def subFindPath(root):
if root:
b.append(root.val)
if not root.right and not root.left and sum(b) == expectNumber:
a.append(b[:])
else:
subFindPath(root.left),subFindPath(root.right)
b.pop()#这个root用完了就删除,为了下一轮的新b
a, b = [], []
subFindPath(root)
return a
'''
题目还是要多总结,反复刷.找到做题共性才能提高.形成套路
1.注意变量的取值范围.小的取值范围作为for循环来遍历,大的用作判断语句.这样最好
2.动态规划:分类的条件都是最后一个取什么时候来分类.分类标准都是按照最后一个.
2个拓展:一个是函数变多,一个是维数变高
3.总是写不好的深度遍历.
递归套路都是:1.上来写边界条件,超出地图范围or标记已经做过就直接返回
2.递归分类搜索.
4.尝试是否能2分加速.预处理数组,预处理矩阵.2维前缀和,哈希,这些加速手段
'''
'''
链接：https://www.nowcoder.com/questionTerminal/ef068f602dde4d28aab2b210e859150a?orderByHotValue=1&questionTypes=000100
来源：牛客网
[编程题]二叉搜索树的第k个结点
热度指数：138320时间限制：1秒空间限制：32768K
算法知识视频讲解
给定一棵二叉搜索树，请找出其中的第k小的结点。例如， (5，3，7，2，4，6，8) 中，按结点数值大小顺序第三小结点的值为4。
class Solution:
# 返回对应节点TreeNode
def KthNode(self, pRoot, k):
# write code here
if not pRoot or not k:
return
res = list()
def Traversal(node):
if len(res) >= k or not node:
return
Traversal(node.left)
res.append(node)
Traversal(node.right)
Traversal(pRoot)
if len(res) < k:
return
return res[k-1]
'''
'''
链接：https://www.nowcoder.com/questionTerminal/33ceeced8acc475aa0be9603936890a6?orderByHotValue=1&questionTypes=000100&page=3&onlyReference=true
来源：牛客网
[编程题]A+B和C (15)
热度指数：101503时间限制：1秒空间限制：32768K
算法知识视频讲解
给定区间[-2的31次方, 2的31次方]内的3个整数A、B和C，请判断A+B是否大于C。
输入描述:
输入第1行给出正整数T(<=10)，是测试用例的个数。随后给出T组测试用例，每组占一行，顺序给出A、B和C。整数间以空格分隔。
'''
'''
num=int(input())
for i in range(num):
a,b,c=map(int,input().split())
if a+b>c:
print('Case #'+str(i+1)+': '+'true')
else:
print('Case #'+str(i+1)+': '+'false')
'''
'''
看算法书:编程之法:面试和算法心得.
网上视频太少.还是看书中题目做题写程序实在.
尽量写出题目的最优解
'''
'''
字符串的包含:如何判断出短字符串b中的所有字符是否都在场字符串a中?
'''
def main(a,b):
#用位运算,bitmap来解决问题.
hash=0
for i in range(len(a)):
hash=hash | (1<<(ord(a[i])-97))
for i in range(len(b)):
if hash and (1<<(ord(b[i])-97))==0:
return False
return True
print(main('aaab','abab'))
'''
寻找数组中最小的k个数
'''
'''
方法:
1.首先拿前k个数建立一个大根堆,时间O(k)
2.剩余n-k个数,每一次跟堆的顶比较.如果比堆顶大扔掉,否则,用这个新数替换堆顶.之后维护堆结构.
效率Nlogk
'''
'''
P37,有趣的抽签问题
纸片上数字k1,...kn
带放回的抽4次,问是否存在抽取4次和为m的方案.
'''
'''
荷兰国旗:
红白蓝3中颜色的球若干个,通过两两交换任意2个球,s.t
从做到右的球的颜色依次是红,白,蓝.求一个函数模拟这个过程.
对撞指针即可
'''
def main(arr):#[0,1,2,0]其中0表示红色,1表示白色,2表示蓝色
start=0
end=len(arr)-1
while start<=end :
if arr[start]==0:
start+=1
continue
if arr[end]!=0:
end-=1
continue
else:
arr[start],arr[end]=arr[end],arr[start]
start+=1
end-=1
#类似的把白色也换到前面,只需要跳过已经排好的红色即可
start=0
end=len(arr)-1
while start<=end :
if arr[start]==0:
start+=1
continue
if arr[start]==1:
start+=1
continue
if arr[end]!=1:
end-=1
continue
else:
arr[start],arr[end]=arr[end],arr[start]
start+=1
end-=1
return arr
print(main([2,0,1,0,0,2,1,1,2]))
'''
p58:完美洗牌算法
有一个长度为2n的数组{a1,...an,b1,...bn}
需要一个O(N),空间O(1)的算法,使得数组变成
{a1,b1,....an,bn}
这个算法很复杂
'''
'''
统计出现次数最多的数据
哈希分桶法
'''
'''
下面了解一下B树,
B+树,B*树
平衡多路查找树,就是B树
'''
'''
LCA问题
1.对于二叉搜索树而言.找节点u,v的公共祖先.
1.从root开始,如果root大于u,也大于v,那么root=root.left递归
2.root大于u,小于v,那么返回root
3.root小于u,v那么递归root.right
4.如果root==uorv,返回root
2.对于一般的二叉树而言.
1.对每一个节点建立一个指针,指向他的父节点
2.这样问题就归结为寻找两个单向链表的第一个公共节点.(因为任何一个节点一路父节点找上去一定最后到root.所以任意两个节点必然存在LCA)
'''
'''
rmq问题:即区间最值查询.
'''
#基本的动态规划
def main(arr,ii,jj):
#返回这个区间从i到j的切片里面值最小的那个index
save=[[0]*len(arr) for _ in range(len(arr))]
for i in range(len(arr)):
for j in range(i,len(arr)):
if j==i:
save[i][j]=i
else:
a,b=arr[save[i][j-1]],arr[j]
if a>b:
save[i][j]=j
else:
save[i][j]=save[i][j-1]
return save[ii][jj]
print(main([1,4,7,0,4],0,3))
'''
在线算法和离线算法.
就是在线算法是需要问题是什么那么就算一下这个问题.
一般都是在线
离线是,事先把所有需要问的问题都跑完,存起来,然后问什么直接回答.对于批量询问会快.
'''
'''
首先是预处理数组的方法,可以把效率提升非常多!!!!!!!!!!!思想也容易事先
数组:
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]
2 4 3 1 6 7 8 9 1 7
这个数组长度是10,那么取根号之后是3,所以我们每3个分成一组,每一组中找到
他最小值所在的下表.
使用的时候比如从i到j,那么i到j里面至多只有3个数是不在我们分组里面的.
而在分组里面的直接提取即可.所以划归成了一个根号n的自问题.
这个子问题用动态规划就到了n的数量级.还是实现一下才更好
'''
def main(arr,start,end):
pre=[]
small=int((len(arr))**0.5)
for i in range(len(arr)//small):
tmp=arr[i*small:(i+1)*small]
low=min(tmp)
for ii in range(len(tmp)):
if tmp[ii]==low:
dex=ii+i*small
pre.append(dex)
break
#下面只需要在i,j区间找到所有的pre里面元素,对这根号n个元素比较即可.
#需要找到第一个比i大的区间,和最后一个比j小的区间.经典分房间算法.
xiajie=(start+small-1)//small
shangjie=end//small
bianhao=[]
shuju=[]
for i in range(start,xiajie*small):
bianhao.append(i)
shuju.append(arr[i])
for i in range(xiajie,shangjie):
bianhao.append(pre[i])
shuju.append(arr[pre[i]])
for i in range(shangjie*small,end+1):
bianhao.append(i)
shuju.append(arr[i])
print(bianhao)
print(shuju)
a=min(shuju)
for i in range(len(shuju)):
if shuju[i]==a:
print(i)
return bianhao[i]
print(main([2,4,3,1,6,7,8,9,1,7],0,9))
#结果是3,因为第三个index数据是1是最小的,并且比index=8的1要早.
'''
下面说明这个算法的缺陷!
这个算法每查询一个从i到j的切片,都需要根号n的时间.当查询操作非常多
的时候,会比较慢.
下面的st算法,每一次查询的时间是O(1).
'''
'''
st算法是解决rmq问题的方法.
预处理:[2,4,3,1,6,7,8,9,1,7]还是这个数组
预处理需要记忆:从i到i+2^j这个区间的最小值.
类似线段树方法,一个树,每一个节点放2个值,表示这个节点表示的区间的首尾.
'''
'''
找到数组中初选次数操作一般的数
1.排序后,返回index中间的数 O(NlogN)
2.哈希法:O(N)
3.每一次都删除2个不同的数.这个在投票算法里面很有用
'''
#用try写,每一次取2个数.感觉这个想法虽然简单但是写起来麻烦.
#注意pop操作每一次都把所有index修改了
def main(arr):
try:
left=0
right=1
while 1:
if arr[left]!=arr[right]:
arr.pop(left)
arr.pop(right-1)#因为每一次pop下标就已经都修改了
if right!=1:
right-=1
else:
right+=1
except:
return arr[left]
print(main([1,1,2,2,2,3,2]))
'''
上面的道理实现的机制,用candidate算法来描述才是最正确的方法.
遍历数组的时候保存2个值:一个是candidate用来保存数组中遍历的某一个数,另
一个是times表示遍历的这个数的出现的次数.
算法:
如果下一个数与之前的candidate的数相同,那么times+1
如果下一个数与之前的candidate的数不相同,那么times-1
如果times=0,那么candidate保存下一个数,times=1
'''
def main(arr):
times=1
candidate=arr[0]
for i in range(1,len(arr)):
if arr[i]==candidate:
times+=1
else:
times-=1
if times==0:
candidate=arr[i]
times=1#这个地方赋值有点说法.
return candidate
print(main([1,1,2,2,2,3,2]))
'''
经典问题:最大连续乘积子数组
'''
arr=[-2.5,4,0,3,0.5,8,-1]
def main(arr):
minend=arr[0]
maxend=arr[0]
out=arr[0]
#分别表示以i为结尾的最小的子数组乘积,和最大的子数组乘积.
for i in range(1,len(arr)):
minend=min(minend*arr[i],maxend*arr[i],arr[i])
maxend=max(minend*arr[i],maxend*arr[i],arr[i])
out=max(minend,maxend,out)
return out
print(main(arr))
'''
字符串编辑距离:也是一个经典题目
dp[i][j]表示字符串A从0到i,B从0到j这个子问题的编辑距离
那么分3中情况.
如果A[i]==B[j]那么dp[i][j]==dp[i-1][j-1]
否则:
有几个情况:
比如algy 变成alg.最后一个字母不同,但是我们对每一个字母有3种操作
1.添加,也就是把空格变成一个字母2.修改把一个字母变成另一个字母
3.把一个字母变空格,删除.
algy变alg就是删除.就是最后这个字母是通过删除原字符串得到的.
这时候dp[i][j]=1+dp[i-1][j]
反过来从alg变成algy这时候dp[i][j]=1+dp[i][j-1]
修改就是这时候dp[i][j]=1+dp[i-1][j-1]
综合起来就是dp[i][j]=min(dp[i-1][j]+1,dp[i][j-1],dp[i-1][j-1]+
(A[i]==B[j])?0:1)
这个逻辑是,看B最后这个字母如何来的.做分类讨论即可!分4中
如果是从A最后变过来的那么就是上面最后一种,这个变换方式.
跟A最后的一样就是第三个
从A最后面加一个字母
从A最后面减一个字母 分这4种情况.即可.
'''
def main(a,b):
dp=[[0]*len(b) for i in range(len(a))]
print(dp)
for i in range(len(a)):
dp[i][0]=i
for j in range(len(b)):
print(j)
dp[0][j]=j
for i in range(1,len(a)):
for j in range(1,len(b)):
if a[i]==b[j]:
dp[i][j]=dp[i-1][j-1]
else:
dp[i][j]=min(dp[i-1][j]+1,dp[i][j-1]+1,1+dp[i-1][j-1])
return dp[len(a)-1][len(b)-1]
print(main('abcde','abbbe'))
'''
格子取数:非常精彩的动态规划.在P161.分析的非常负责.应该是看过的研究最深入的动态规划问题!!!!!!!!!!!!!
写起来挺复杂,用文字肯定说不清,
'''
'''
交替字符串.又是一个经典题目.
A,B,C3个字符串,问是否能用A,B分别保持字母相对顺序,来拼成C
dp[i][j]表示c[0...i+j-1]是否可以由a[0...i-1] ,b[0....j-1]拼出来.
'''
def main(a,b,c):
if len(a)+len(b)!=len(c):
return False
dp=[[0]*(len(b)+1) for i in range(len(a)+1)]#补个0,作为空字符初始值
for i in range(len(a)+1):
dp[i][0]=a[:i]==c[:i]
for i in range(len(b)+1):
dp[0][i]=b[:i]==c[:i]
for i in range(1,len(a)+1):
for j in range(1,len(b)+1):
if a[i-1]==c[i+j-1] and b[j-1]==c[i+j-1]:
dp[i][j]=dp[i-1][j] or dp[i][j-1]
elif a[i-1]==c[i+j-1] and b[j-1]!=c[i+j-1]:
dp[i][j]=dp[i-1][j]
elif a[i-1]!=c[i+j-1] and b[j-1]==c[i+j-1]:
dp[i][j]=dp[i][j-1]
else:
dp[i][j]=False
print(dp)
return dp[len(a)][len(b)]
print(main('aabcc','dbbca','accabdbbca'))
'''
simhash算法
'''
'''
如果某一天面试官问你如何设计一个比较两篇文章的相似度的算法.
1.把2片文章先进行分词,然后赛选得到一些特征向量(词汇向量化),之后计算特征向量之间的距离.用距离的大小来比较两篇文章的相似度.
2.通过散列的方式生成每一个文档的信息指纹.
'''
python模板总结
# -*- coding: utf-8 -*-
"""
Created on Fri Jul 20 10:58:02 2018
@author: 张博
"""
'''
读取csv最稳的方法:
f = open(r'C:\Users\张博\Desktop\展示\old.csv')
data = read_csv(f,header=None)
'''
'''
画图模板:
import numpy as np
from matplotlib import pyplot
pyplot.rcParams['figure.figsize'] = (20, 3) # 设置figure_size尺寸
pyplot.rcParams['image.cmap'] = 'gray' #
pyplot.plot(inv_y,color='black',linewidth = 0.7)
pyplot.show()
画3d图像的模板
import matplotlib.font_manager as fm
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import pyplot
pyplot.rcParams['figure.figsize'] = (3, 3) # 设置figure_size尺寸
fig=plt.figure()
ax3d=Axes3D(fig) #绘制3D图形
ax3d.scatter(a[:,1],a[:,2],a[:,6],c='r',marker=".")
ax3d.set_xlabel('X axis')
ax3d.set_ylabel('Y axis')
ax3d.set_zlabel('Z axis')
pyplot.show()
excel表格实用技巧:
全选然后选开始-行和列-最适合的列宽.
这样看表格清晰多了!
'''
'''
#标准化模板
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler(feature_range=(0, 1))
out = scaler.fit_transform(out)
'''
'''
降维可视化模板
from sklearn.manifold import TSNE
tsne=TSNE()
tsne.fit_transform(data) #进行数据降维,降成两维
#a=tsne.fit_transform(data_zs) #a是一个array,a相当于下面的tsne_embedding_
tsne=pd.DataFrame(tsne.embedding_) #转换数据格式
print(tsne)
tsne['聚类类别']=label_pred
print(tsne)
d=tsne[tsne[u'聚类类别']==0]
plt.plot(d[0],d[1],'r.')
d=tsne[tsne[u'聚类类别']==1]
plt.plot(d[0],d[1],'go')
d=tsne[tsne[u'聚类类别']==2]
plt.plot(d[0],d[1],'b*')
d=tsne[tsne[u'聚类类别']==3]
plt.plot(d[0],d[1],'yellow')
plt.show()
'''
'''
获取当前时间:
import datetime
nowTime=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')#现在
nowTime=((nowTime)[:-3])
print(nowTime)
'''
'''
写文件的模板
with open(r'c:/234/wucha.txt','w') as f:
wucha=str(wucha)
f.write(wucha)
'''
'''
手动加断电的方法:raise
输入模板:
def input():
a9999=open('1.txt','r')
return a9999.readline().rstrip('\n')
'''
# #老外的教程:非常详细,最后的多变量,多step模型应该是最终实际应用最好的模型了.也就是这个.py文件写的内容
# #https://machinelearningmastery.com/multivariate-time-series-forecasting-lstms-keras/
#回归
'''
下面开始用xgboost来回归这个多元问题.
'''
import pandas as pd
import tensorflow as tf
f=open(r'C:\Users\zhangbo284\Desktop\data.csv',encoding='utf-8')
# d = pd.read_excel(excel_path, sheetname=None)
#读取excel编码有毛病,其实只需要把excel另存为csv,用read_csv读取即可
data = pd.read_csv(f,header=0)
import xgboost as xgb
data=data.dropna()#扔掉带None的行
#现在的目标是多远回归,最后一列是output,其他列是input
values = data.values
print(values.shape)
print(values[0])
n_train = int(len(values)*0.75)
print(n_train)
train = values[:n_train, :]
test = values[n_train:, :]
print(train.shape)
print(test.shape)
#回归
from matplotlib import pyplot as plt
model = xgb.XGBRegressor(max_depth=17,
# Maximum depth of a tree. Increasing this value will make the model more complex and more likely to overfit.
learning_rate=0.01,
n_estimators=500, silent=True, objective='reg:linear'
,eta=0.4,
#Step size shrinkage used in update to prevents overfitting.
gamma =0.2,
#Minimum loss reduction required to make a further partition on a leaf node of the tree. The larger gamma is, the more conservative the algorithm will be.
min_child_weight =1,
#Minimum sum of instance weight (hessian) needed in a child. If the tree partition step results in a leaf node with the sum of instance weight less than min_child_weight, then the building process will give up further partitioning.,
alpha=0.15,reg_lambda= 1.5,
subsample= 0.9, colsample_bytree= 0.9,
# subsample [default=1]
#Subsample ratio of the training instances. Setting it to 0.5 means that XGBoost would randomly sample half of the training data prior to growing trees. and this will prevent overfitting. Subsampling will occur once in every boosting iteration.
#range: (0,1]
#colsample_bytree [default=1]
#Subsample ratio of columns when constructing each tree. Subsampling will occur once in every boosting iteration.
#range: (0,1]
)
import numpy as np
np.random.shuffle(train)
train_X=train[:,:-1]
train_y=train[:,-1]
print('dayin')
print(train_X.shape)
print(train_y.shape)
test_X=test[:,:-1]
test_y=test[:,-1]
print(test_X.shape)
print(test_y.shape)
train_y=train_y.reshape(-1,1)
test_y=test_y.reshape(-1,1)
print(train_y)
print(test_y)
model.fit(train_X, train_y)
# 对测试集进行预测
ans = model.predict(test_X)
yhat=ans
# 显示重要特征
import xgboost
xgboost.plot_importance(model,height=30)
plt.show()
#计算ans和yhat的mape值
# xgboost.plot_tree(model)
#
# plt.show()
import numpy as np
from matplotlib import pyplot
pyplot.rcParams['figure.figsize'] = (20, 3) # 设置figure_size尺寸
pyplot.rcParams['image.cmap'] = 'gray' #
pyplot.plot(test_y,color='black',linewidth = 0.7)
pyplot.plot(ans ,color='red',linewidth = 0.7)
plt.legend((u'raw', u'predict'),loc='best')
pyplot.show()
print('看一下')
print(ans)
ans=ans.reshape(-1,1)
print(ans)
#mape率
wucha=abs(ans-test_y)/(test_y)
wucha=wucha.mean()
print(wucha)
2018-11-15,14点25 python模板总结:花了几个小时扩充了grid_search模板!
# -*- coding: utf-8 -*-
"""
Created on Fri Jul 20 10:58:02 2018
@author: 张博
"""
'''
读取csv最稳的方法:
f = open(r'C:\Users\张博\Desktop\展示\old.csv')
data = read_csv(f,header=None)
'''
'''
画图模板:
import numpy as np
from matplotlib import pyplot
pyplot.rcParams['figure.figsize'] = (20, 3) # 设置figure_size尺寸
pyplot.rcParams['image.cmap'] = 'gray' #
pyplot.plot(inv_y,color='black',linewidth = 0.7)
pyplot.show()
画3d图像的模板
import matplotlib.font_manager as fm
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import pyplot
pyplot.rcParams['figure.figsize'] = (3, 3) # 设置figure_size尺寸
fig=plt.figure()
ax3d=Axes3D(fig) #绘制3D图形
ax3d.scatter(a[:,1],a[:,2],a[:,6],c='r',marker=".")
ax3d.set_xlabel('X axis')
ax3d.set_ylabel('Y axis')
ax3d.set_zlabel('Z axis')
pyplot.show()
excel表格实用技巧:
全选然后选开始-行和列-最适合的列宽.
这样看表格清晰多了!
'''
'''
#标准化模板
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler(feature_range=(0, 1))
out = scaler.fit_transform(out)
'''
'''
降维可视化模板
from sklearn.manifold import TSNE
tsne=TSNE()
tsne.fit_transform(data) #进行数据降维,降成两维
#a=tsne.fit_transform(data_zs) #a是一个array,a相当于下面的tsne_embedding_
tsne=pd.DataFrame(tsne.embedding_) #转换数据格式
print(tsne)
tsne['聚类类别']=label_pred
print(tsne)
d=tsne[tsne[u'聚类类别']==0]
plt.plot(d[0],d[1],'r.')
d=tsne[tsne[u'聚类类别']==1]
plt.plot(d[0],d[1],'go')
d=tsne[tsne[u'聚类类别']==2]
plt.plot(d[0],d[1],'b*')
d=tsne[tsne[u'聚类类别']==3]
plt.plot(d[0],d[1],'yellow')
plt.show()
'''
'''
获取当前时间:
import datetime
nowTime=datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')#现在
nowTime=((nowTime)[:-3])
print(nowTime)
'''
'''
写文件的模板
with open(r'c:/234/wucha.txt','w') as f:
wucha=str(wucha)
f.write(wucha)
'''
'''
手动加断电的方法:raise
输入模板:
def input():
a9999=open('1.txt','r')
return a9999.readline().rstrip('\n')
'''
'''
设计一个grid search模板,方便套用
xishubiao={'par1':[1,2,3],
'par2':[1,2,3],
'par3':[1,2,3],
'par4':[1,2,3,4]}
# 下面 写的函数用于把xishubiao这个字典来生成最后grid search需要的list
# 下面这个函数hebin的用途就是把xishubiao这个字典里面的东西都转化为可以赋值给函数的一堆字典组成的列表.然后调用时候直接for循环这个列表就可以使用这写grid_search了.对于grid_search更方便了,不用写那么多for循环了.只需要写一个就行了.
def hebin(xishubiao):
import copy #为了不干扰外部变量,所以把调用的都写里面
#算法是类似倒水问题的dp问题
out999=[]#保存最后结果
tmp={}#当前的组合
chang=len(xishubiao.keys())
bianliang=list(xishubiao.keys())
flag=[[0]*len(i) for i in xishubiao.values()]
def search(i):#表示当前便利到bianliang的第i个元素,便利到bianliang[i]的第j个元素.
if i==len(flag):
return
for j in range(len(flag[i])):#这种按照顺序dp的只需要在for循环当前层中写入地柜函数即可!
tmp[bianliang[i]]=xishubiao[bianliang[i]][j]
if i==len(flag)-1:#先把数据放进去,再判断
out999.append(copy.deepcopy(tmp))#因为字典的mutable特性
search(i+1)
tmp.pop(bianliang[i])
search(0)
return out999
print('下面打印所有的xishubiao拼成的组合')
print(len(hebin(xishubiao)))
#下面是测试用例
xishubiao={'a':[1,2,3],
'b':[1,2,3],
'c':[1,2,3],
'd':[1,2,3,4]}
def main(a,b,c,d):
return a+b+c+d
for i in hebin(xishubiao):
print(main(**i))
'''
# #老外的教程:非常详细,最后的多变量,多step模型应该是最终实际应用最好的模型了.也就是这个.py文件写的内容
# #https://machinelearningmastery.com/multivariate-time-series-forecasting-lstms-keras/
#回归
'''
下面开始用xgboost来回归这个多元问题.
'''
import pandas as pd
import tensorflow as tf
f=open(r'C:\Users\zhangbo284\Desktop\data.csv',encoding='utf-8')
# d = pd.read_excel(excel_path, sheetname=None)
#读取excel编码有毛病,其实只需要把excel另存为csv,用read_csv读取即可
data = pd.read_csv(f,header=0)
import xgboost as xgb
data=data.dropna()#扔掉带None的行
#现在的目标是多远回归,最后一列是output,其他列是input
values = data.values
print(values.shape)
print(values[0])
n_train = int(len(values)*0.75)
print(n_train)
train = values[:n_train, :]
test = values[n_train:, :]
print(train.shape)
print(test.shape)
#回归
from matplotlib import pyplot as plt
model = xgb.XGBRegressor(max_depth=17,
# Maximum depth of a tree. Increasing this value will make the model more complex and more likely to overfit.
learning_rate=0.01,
n_estimators=500, silent=True, objective='reg:linear'
,eta=0.4,
#Step size shrinkage used in update to prevents overfitting.
gamma =0.2,
#Minimum loss reduction required to make a further partition on a leaf node of the tree. The larger gamma is, the more conservative the algorithm will be.
min_child_weight =1,
#Minimum sum of instance weight (hessian) needed in a child. If the tree partition step results in a leaf node with the sum of instance weight less than min_child_weight, then the building process will give up further partitioning.,
alpha=0.15,reg_lambda= 1.5,
subsample= 0.9, colsample_bytree= 0.9,
# subsample [default=1]
#Subsample ratio of the training instances. Setting it to 0.5 means that XGBoost would randomly sample half of the training data prior to growing trees. and this will prevent overfitting. Subsampling will occur once in every boosting iteration.
#range: (0,1]
#colsample_bytree [default=1]
#Subsample ratio of columns when constructing each tree. Subsampling will occur once in every boosting iteration.
#range: (0,1]
)
import numpy as np
np.random.shuffle(train)
train_X=train[:,:-1]
train_y=train[:,-1]
print('dayin')
print(train_X.shape)
print(train_y.shape)
test_X=test[:,:-1]
test_y=test[:,-1]
print(test_X.shape)
print(test_y.shape)
train_y=train_y.reshape(-1,1)
test_y=test_y.reshape(-1,1)
print(train_y)
print(test_y)
model.fit(train_X, train_y)
# 对测试集进行预测
ans = model.predict(test_X)
yhat=ans
# 显示重要特征
import xgboost
xgboost.plot_importance(model,height=30)
plt.show()
#计算ans和yhat的mape值
# xgboost.plot_tree(model)
#
# plt.show()
import numpy as np
from matplotlib import pyplot
pyplot.rcParams['figure.figsize'] = (20, 3) # 设置figure_size尺寸
pyplot.rcParams['image.cmap'] = 'gray' #
pyplot.plot(test_y,color='black',linewidth = 0.7)
pyplot.plot(ans ,color='red',linewidth = 0.7)
plt.legend((u'raw', u'predict'),loc='best')
pyplot.show()
print('看一下')
print(ans)
ans=ans.reshape(-1,1)
print(ans)
#mape率
wucha=abs(ans-test_y)/(test_y)
wucha=wucha.mean()
print(wucha)
kmean聚类模板
import pandas as pd
f=open(r'C:\Users\张博\Desktop\世界杯\小组赛.csv')
data =pd. read_csv(f,header=None)
for i in range(len(data)):
tmp=(data.loc[i,4])
if '-' in tmp:
data.loc[i,4]=data.loc[i,4].replace('-',':')
train_data=data
print(data)
a=[
'Argentina',
'Australia',
'Belgium',
'Brazil',
'Colombia',
'Costa_Rica',
'Croatia',
'Denmark',
'Egypt',
'England',
'France',
'Germany',
'Iceland',
'Iran',
'Japan',
'Korea_Republic',
'Mexico',
'Morocco',
'Nigeria',
'Panama',
'Peru',
'Poland',
'Portugal',
'Russia',
'Saudi_Arabia',
'Senegal',
'Serbia',
'Spain',
'Sweden',
'Switzerland',
'Tunisia',
'Uruguay',
]
#算了还是按照球队净进球数量来给他实力值算了.
#[-2,-3,7,4,3,-3,6,1,-4,3,2,-2,-1,0,1,0,-1,-1,-2,-9,0,-3,1,4,-5,0,-2,0,3,1,-3,5]
tmp={}
for i in a:
f=open('C:/Users/张博/Desktop/世界杯/data/'+ i +".csv")
data =pd. read_csv(f,header=None)
data.drop([0,1,2,4,7,8,20,21,22], axis=1,inplace=True)
data.drop([0], axis=0,inplace=True)
data=data.mean(axis=0)
tmp[i]=list(data)
print(tmp) #数据已经都是float了
##回归
#
#model = xgb.XGBRegressor(max_depth=15, learning_rate=0.1,
# n_estimators=1600, silent=True, objective='reg:linear')
#model.fit(train_X, train_y)
#
## 对测试集进行预测
#ans = model.predict(test_X)
#yhat=ans
## 显示重要特征
#import xgboost
#
#xgboost.plot_importance(model,height=30)
#
#plt.show()
print(tmp) #是队伍的各项指标数据
print(train_data[4]) #是队伍的train数据
import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0' #使用 GPU 0
import tensorflow as tf
from keras.backend.tensorflow_backend import set_session
config = tf.ConfigProto()
config.gpu_options.allocator_type = 'BFC' #A "Best-fit with coalescing" algorithm, simplified from a version of dlmalloc.
config.gpu_options.per_process_gpu_memory_fraction = 1.
config.gpu_options.allow_growth = True
set_session(tf.Session(config=config))
from math import sqrt
from numpy import concatenate
from matplotlib import pyplot
from pandas import read_csv
from pandas import DataFrame
from pandas import concat
from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import mean_squared_error
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras import regularizers
model = Sequential()
model.add(Dense(1, activation='tanh',kernel_regularizer=regularizers.l2(0.01),
bias_regularizer=regularizers.l2(0.01)))
#model.add(Dense(1))
from keras import regularizers
from keras import optimizers
out=[]
for i in a:
out.append(tmp[i])
print(out)
import numpy as np
out=np.array(out)
#这个out就是按照字母表排序的各个战队的实力值.
out2=np.eye(32)
print(out[0])
print(train_data)
train1=train_data[:16]
train2=train_data[16:32]
train3=train_data[32:]
print('分割训练数据 ')
print(train1)
print(train2)
print(train3)
y=[-2,-3,7,4,3,-3,6,1,-4,3,2,-2,-1,0,1,0,-1,-1,-2,-9,0,-3,1,4,-5,0,-2,0,3,1,-3,5]
print(len(y))
y=np.array(y)+10
print(y)
print(y.shape)
adam = optimizers.Adam(lr=0.001, clipnorm=.5)
model.compile(loss='mae', optimizer=adam,metrics=['mae'])
print(333333333)
model.fit(out,y)
print(out.shape)
from sklearn.cluster import KMeans
#标准化
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler(feature_range=(0, 1))
out = scaler.fit_transform(out)
data = out
print(data)
#假如我要构造一个聚类数为3的聚类器
estimator = KMeans(n_clusters=2)#构造聚类器
estimator.fit(data)#聚类
label_pred = estimator.labels_ #获取聚类标签
centroids = estimator.cluster_centers_ #获取聚类中心
inertia = estimator.inertia_ # 获取聚类准则的总和
print('得到的聚点')
print(centroids)
print('得到的标签')
print(label_pred)
print(a)
c=(zip(a,label_pred))
for i in c:
print(i[1]==0)
print(222222222222)
c=(zip(a,label_pred))
print('聚类方法得到的16强')
for i in c:
if i[1]==0:
print(i[0])
##画3d
#import matplotlib.font_manager as fm
#import matplotlib.pyplot as plt
#import numpy as np
#from mpl_toolkits.mplot3d import Axes3D
#
#
#
#from matplotlib import pyplot
#pyplot.rcParams['figure.figsize'] = (3, 3) # 设置figure_size尺寸
#
#
#fig=plt.figure()
#
#ax3d=Axes3D(fig) #绘制3D图形
#ax3d.scatter(a[:,1],a[:,2],a[:,6],c='r',marker=".")
#ax3d.set_xlabel('X axis')
#ax3d.set_ylabel('Y axis')
#ax3d.set_zlabel('Z axis')
#pyplot.show()
print('2018-08-11,19点37')
print('下面开始处理球员')
import pandas as pd
f=open(r'C:\Users\张博\Desktop\世界杯\final(2).csv')
data =pd. read_csv(f,header=None)
outt=data[0]
data.drop([0], axis=1,inplace=True)
data.drop([0], axis=0,inplace=True)
print(data)
#标准化
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler(feature_range=(0, 1))
out = scaler.fit_transform(data)
data = out
#假如我要构造一个聚类数为3的聚类器
estimator = KMeans(n_clusters=4)#构造聚类器
estimator.fit(data)#聚类
label_pred = estimator.labels_ #获取聚类标签
centroids = estimator.cluster_centers_ #获取聚类中心
inertia = estimator.inertia_ # 获取聚类准则的总和
print('得到的聚点')
print(centroids)
print('得到的标签')
print(label_pred)
print('球员名单')
print(outt)
#%%
from sklearn.manifold import TSNE
tsne=TSNE()
tsne.fit_transform(data) #进行数据降维,降成两维
#a=tsne.fit_transform(data_zs) #a是一个array,a相当于下面的tsne_embedding_
tsne=pd.DataFrame(tsne.embedding_) #转换数据格式
print(tsne)
#%%
tsne['聚类类别']=label_pred
print(tsne)
d=tsne[tsne[u'聚类类别']==0]
plt.plot(d[0],d[1],'r.')
d=tsne[tsne[u'聚类类别']==1]
plt.plot(d[0],d[1],'go')
d=tsne[tsne[u'聚类类别']==2]
plt.plot(d[0],d[1],'b*')
d=tsne[tsne[u'聚类类别']==3]
plt.plot(d[0],d[1],'yellow')
plt.show()
#%%
print('输出所有球员的归类')
tmp=outt[1:]
tmp=list(tmp)
tsne['球员']=tmp
print(tsne)
python模板更新
2018-11-23,20点26
# -*- coding: utf-8 -*-
"""
Created on Fri Jul 20 10:58:02 2018
@author: 张博
"""
'''
读取csv最稳的方法:
f = open(r'C:/Users/张博/Desktop/展示/old.csv')
data = read_csv(f,header=None)
'''
'''
画图模板:
import numpy as np
from matplotlib import pyplot
pyplot.rcParams['figure.figsize'] = (20, 3) # 设置figure_size尺寸
pyplot.rcParams['image.cmap'] = 'gray' #
pyplot.plot(inv_y,color='black',linewidth = 0.7)
pyplot.show()
画3d图像的模板
import matplotlib.font_manager as fm
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import pyplot
pyplot.rcParams['figure.figsize'] = (3, 3) # 设置figure_size尺寸
fig=plt.figure()
ax3d=Axes3D(fig) #绘制3D图形
ax3d.scatter(a[:,1],a[:,2],a[:,6],c='r',marker=".")
ax3d.set_xlabel('X axis')
ax3d.set_ylabel('Y axis')
ax3d.set_zlabel('Z axis')
pyplot.show()
excel表格实用技巧:
全选然后选开始-行和列-最适合的列宽.
这样看表格清晰多了!
用pandas 读取excel有bug,所以先把.xlsx转化成csv再给python才行.
'''
'''
#标准化模板
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler(feature_range=(0, 1))
out = scaler.fit_transform(out)
'''
'''
降维可视化模板
from sklearn.manifold import TSNE
tsne=TSNE()
tsne.fit_transform(data) #进行数据降维,降成两维
#a=tsne.fit_transform(data_zs) #a是一个array,a相当于下面的tsne_embedding_
tsne=pd.DataFrame(tsne.embedding_) #转换数据格式
print(tsne)
tsne['聚类类别']=label_pred
print(tsne)
d=tsne[tsne[u'聚类类别']==0]
plt.plot(d[0],d[1],'r.')
d=tsne[tsne[u'聚类类别']==1]
plt.plot(d[0],d[1],'go')
d=tsne[tsne[u'聚类类别']==2]
plt.plot(d[0],d[1],'b*')
d=tsne[tsne[u'聚类类别']==3]
plt.plot(d[0],d[1],'yellow')
plt.show()
'''
'''
写文件的模板
with open(r'result.txt','w') as f:
wucha=str(wucha)
f.write(wucha)
'''
'''
手动加断电的方法:raise
输入模板:
def input():
a9999=open('1.txt','r')
return a9999.readline().rstrip('\n')
'''
'''
设计一个grid search模板,方便套用
xishubiao={'par1':[1,2,3],
'par2':[1,2,3],
'par3':[1,2,3],
'par4':[1,2,3,4]}
# 下面 写的函数用于把xishubiao这个字典来生成最后grid search需要的list
# 下面这个函数hebin的用途就是把xishubiao这个字典里面的东西都转化为可以赋值给函数的一堆字典组成的列表.然后调用时候直接for循环这个列表就可以使用这写grid_search了.对于grid_search更方便了,不用写那么多for循环了.只需要写一个就行了.
def hebin(xishubiao):
import copy #为了不干扰外部变量,所以把调用的都写里面
#算法是类似倒水问题的dp问题
out999=[]#保存最后结果
tmp={}#当前的组合
chang=len(xishubiao.keys())
bianliang=list(xishubiao.keys())
flag=[[0]*len(i) for i in xishubiao.values()]
def search(i):#表示当前便利到bianliang的第i个元素,便利到bianliang[i]的第j个元素.
if i==len(flag):
return
for j in range(len(flag[i])):#这种按照顺序dp的只需要在for循环当前层中写入地柜函数即可!
tmp[bianliang[i]]=xishubiao[bianliang[i]][j]
if i==len(flag)-1:#先把数据放进去,再判断
out999.append(copy.deepcopy(tmp))#因为字典的mutable特性
search(i+1)
tmp.pop(bianliang[i])
search(0)
return out999
print('下面打印所有的xishubiao拼成的组合')
print(len(hebin(xishubiao)))
#下面是测试用例
xishubiao={'a':[1,2,3],
'b':[1,2,3],
'c':[1,2,3],
'd':[1,2,3,4]}
def main(a,b,c,d):
return a+b+c+d
for i in hebin(xishubiao):
print(main(**i))
'''
# #老外的教程:非常详细,最后的多变量,多step模型应该是最终实际应用最好的模型了.也就是这个.py文件写的内容
# #https://machinelearningmastery.com/multivariate-time-series-forecasting-lstms-keras/
#回归
2019-07-07,13点48
;把大写禁用了,因为确实基本不用.`表示删除,caplock+ijkl可以控制光标
;经过测试,setkeydelay要设置100才行,否则会偶尔发生粘贴板错误.
SetCapsLockState , AlwaysOff
switchime(ime )
{
if (ime = 1){
DllCall("SendMessage", UInt, WinActive("A"), UInt, 80, UInt, 1, UInt, DllCall("LoadKeyboardLayout", Str,"00000804", UInt, 1))
}else if (ime = 0)
{
DllCall("SendMessage", UInt, WinActive("A"), UInt, 80, UInt, 1, UInt, DllCall("LoadKeyboardLayout", Str,, UInt, 1))
}else if (ime = "A")
{
;ime_status:=DllCall("GetKeyboardLayout","int",0,UInt)
Send, #{Space}
}}
; 切换至sougou switchime(1)
; 切换至英文 switchime(0)
^`:: ;做一个快速进入当前目录cmd的快捷键
switchime(0)
ControlClick, ToolBarWindow323, A ;注意前面这个控件名称是鼠标悬停时候window spy给出的控件名字,不是鼠标点下去给的名字.
; A表示当前激活的窗口
sleep,50
send, cmd
sleep,50
send, {Enter}
sleep,50
return
!x:: ;按alt+x可以切换自学笔记的出现和隐藏
if WinActive("ahk_class Notepad++") {
WinActivate ; Automatically uses the window found above.
WinHide,A
}
else
{
run D:\zhangbo340\Desktop\自学笔记.txt
WinShow,A
}
return ;一个快捷键的结束一定要写上return
;下面我要实现的功能是想在一段话左右加括号,只需要选中这段话之后按下shift+9就行.等号右边的变量需要加双%,其实还是有bug存在
;当剪贴板内容和选择内容相同时候有bug,所以如果你要复制一段话到一个新地方并且加上括号.就先复制话,然后输入括号再粘贴即可.顺序反了就出不来.目前只有这个一个bug
$+9:: ;因为这个shift跟输入法的冲突至今还没解决,只能进入搜狗输入法把切换中英文改成ctrl即可.
SetKeyDelay, 100 ;只要跟剪贴板有关就必须设置这个参数
t=%clipboard%
clipboard=
x=%clipboard%
y=%clipboard%
send {(}
send {)}
send {left}
clipboard=%t%
return
$+[::
SetKeyDelay, 100 ;只要跟剪贴板有关就必须设置这个参数
t=%clipboard%
clipboard=
x=%clipboard%
y=%clipboard%
send {{}
send {}}
send {left}
clipboard=%t%
return
$[::
SetKeyDelay, 100 ;只要跟剪贴板有关就必须设置这个参数
t=%clipboard%
clipboard=
x=%clipboard%
y=%clipboard%
send {[}
send {]}
send {left}
clipboard=%t%
return
$'::
SetKeyDelay, 100 ;只要跟剪贴板有关就必须设置这个参数
t=%clipboard%
clipboard=
x=%clipboard%
y=%clipboard%
send {'}
send {'}
send {left}
clipboard=%t%
return
$"::
SetKeyDelay, 100 ;只要跟剪贴板有关就必须设置这个参数
t=%clipboard%
clipboard=
x=%clipboard%
y=%clipboard%
send {"}
send {"}
send {left}
clipboard=%t%
return
CapsLock & n::SendInput {_}
CapsLock & ,::SendInput {=}
;用;p来替换书写经常不好使,因为输入多个字符替换可能会bug
; caplock表示右,ctrl+caplock切换大小写
;CapsLock::SendInput {Right} ;这样改就避免冲突了
CapsLock & l::Send {Right}
CapsLock & i::SendInput {up}
CapsLock & j::SendInput {left}
CapsLock & k::SendInput {down}
CapsLock & y::send print(type()){left 2}
CapsLock & u::Send {backspace}
CapsLock & o::Send {delete}
CapsLock & h::Send {home}
CapsLock::Send {right}
CapsLock & `;::Send {end} ;加入`表示autohotkey里面的转义字符
CapsLock & m::Send import{space}
;send最稳的写法是每次send一个字符
:?:;s::SELECT
!b::
run D:\zhangbo340\Desktop\gapa.exe
return
!g::
run D:\zhangbo340\Desktop\个人信息.txt
return
CapsLock & r::send return{space}
CapsLock & 7::send ^{Backspace}
CapsLock & 8::send ^{del}
CapsLock & p::send print(){left}
CapsLock & e::send exit(){enter}
CapsLock & c::send continue
SetWinDelay, 10
#ClipboardTimeout 2000
;这个版本已经基本修复了输入括号等shift与切换中英文输入法之间的冲突
#s::Suspend ; 给一个热键指定挂起的开关功能。
CapsLock & t::send 15122306087
CapsLock & f::send 210102198908124112
CapsLock & b::
send,break
return
;使用技巧shift是+用多重Send,命令来实现多命令比如下面的按F4来写2维数组,之所以写的这么复杂就是因为剪贴板如果一个代码用多次必然出现bug:
;用()括起来来实现大范围复制:
;因为我括号替换写的不好,最好不要使用剪贴板:
;尽量用send 命令不会出现任何bug:
;写一下这个注释,这里winexist表示存在窗口,那么winclose就关闭,注意这里if括号里面要写return;
;不然他停不下来,继续跑,显然不行;
;这个处理比较麻烦,需要把这个py文件的打开方式的默认程序设置成idle.exe才行.然后写入这个run代码就ok了,总之用autohotkey写代码和快捷键都是锦上添花.:
;窗口命令的注意事项:
;这里面这个写法要注意:1.ifwin不能断开写. 2.后面窗口名字是windows最下排状态栏给的的名字
#x::Run "C:\Program Files (x86)\NetSarang\Xshell 6\Xshell.exe"
#f::Run "C:\Program Files\Everything\Everything.exe"
!p::
IfWinExist, 无标题 - 画图 ;注意这里面的标题名字就是打开程序里面写的标题,注意中间带空格.;这样写就控制了程序开关.
{
WinClose
return
}
else
{
run mspaint
return
}
!j::run calc
!c::
switchime(0)
run cmd
return
:*:;m::[email protected]
^NumpadAdd::SoundSet , +2, WAVE
^NumpadSub::SoundSet , -2, WAVE
F3::
SetKeyDelay, 100
x=%clipboard%
d=.append()
clipboard=%d%
Send ^v
sleep,0.01
Send, {Left}
clipboard=%x%
return
F4::
SetKeyDelay, 100
x=%clipboard%
d=''''''
clipboard=%d%
Send ^v
sleep,0.01
clipboard=%x%
send {left 3}
send {enter}
send {enter}
send {up}
return
F1::
SetKeyDelay, 100
x=%clipboard%
d=for i in range(len()):
clipboard=%d%
Send ^v
sleep,0.01
Send, {Left 3}
clipboard=%x%
return
;使用方法是输入,xun然后空格
:*:lsit::list
:*:braek::break
:*:berak::break
:*:,rr::return{space}
:*:dfe::def
:*:retrun::return
:*:retunr::return
:*:calss::class
:*:slef::self
:*:slfe::self
:*:apend::append
:*:appedn::append
:*:contiune::continue
:*:contnue::continue
;下面为了java扩充的:
CapsLock & s::
SetKeyDelay, 100
x=%clipboard%
d=System.out.println();
clipboard=%d%
Send ^v
sleep,0.01
Send, {Left 2}
clipboard=%x%
return
:*:'::
SetKeyDelay, 100
x=%clipboard%
d=''
clipboard=%d%
Send ^v
Send {Left}
sleep,0.01
clipboard=%x%
return
:*:;d::
switchime(0)
x=%clipboard%
FormatTime, d, LongDate,yyyy-MM-dd,H点mm
SetKeyDelay, 100
clipboard = %d%
SetKeyDelay, 100
Send ^v
clipboard=%x%
return
^F1::
SetKeyDelay, 100
x=%clipboard%
d=for i in range():
clipboard = %d%
Send ^v
Send {LEFT 2}
clipboard=%x%
return
;下面添加sql快捷键
:*:;sql::
switchime(0)
x=%clipboard%
d=select * from ();
SetKeyDelay, 100
clipboard = %d%
SetKeyDelay, 100
Send ^v
Send {LEFT 2}
Send {ENTER 2}
Send {UP}
clipboard=%x%
return
^b::
run www.baidu.com
return
^g::Run www.google.com
return
;把大写禁用了,因为确实基本不用.`表示删除,caplock+ijkl可以控制光标
;经过测试,setkeydelay要设置100才行,否则会偶尔发生粘贴板错误.
SetCapsLockState , AlwaysOff
; 输入法切换，因为win+空格不好按所以改成ctrl+空格符合习惯。
^space::#space
switchime(ime )
{
if (ime = 1){
DllCall("SendMessage", UInt, WinActive("A"), UInt, 80, UInt, 1, UInt, DllCall("LoadKeyboardLayout", Str,"00000804", UInt, 1))
}else if (ime = 0)
{
DllCall("SendMessage", UInt, WinActive("A"), UInt, 80, UInt, 1, UInt, DllCall("LoadKeyboardLayout", Str,, UInt, 1))
}else if (ime = "A")
{
;ime_status:=DllCall("GetKeyboardLayout","int",0,UInt)
Send, #{Space}
}}
; 切换至sougou 调用这个函数即可switchime(1)
; 切换至英文 调用这个函数即可 switchime(0)
^`:: ;做一个快速进入当前目录cmd的快捷键
switchime(0)
ControlClick, ToolBarWindow323, A ;注意前面这个控件名称是鼠标悬停时候window spy给出的控件名字,不是鼠标点下去给的名字.
; A表示当前激活的窗口
sleep,50
send, cmd
sleep,50
send, {Enter}
sleep,50
return
!x:: ;按alt+x可以切换自学笔记的出现和隐藏
if WinActive("ahk_class Notepad++") {
WinActivate ; Automatically uses the window found above.
WinHide,A
}
else
{
run D:\zhangbo340\Desktop\自学笔记.txt
WinShow,A
}
return ;一个快捷键的结束一定要写上return
;下面我要实现的功能是想在一段话左右加括号,只需要选中这段话之后按下shift+9就行.等号右边的变量需要加双%,其实还是有bug存在
;当剪贴板内容和选择内容相同时候有bug,所以如果你要复制一段话到一个新地方并且加上括号.就先复制话,然后输入括号再粘贴即可.顺序反了就出不来.目前只有这个一个bug
$+9:: ;因为这个shift跟输入法的冲突至今还没解决,只能进入搜狗输入法把切换中英文改成ctrl即可.
SetKeyDelay, 100 ;只要跟剪贴板有关就必须设置这个参数
t=%clipboard%
clipboard=
x=%clipboard%
y=%clipboard%
send {(}
send {)}
send {left}
clipboard=%t%
return
$+[::
SetKeyDelay, 100 ;只要跟剪贴板有关就必须设置这个参数
t=%clipboard%
clipboard=
x=%clipboard%
y=%clipboard%
send {{}
send {}}
send {left}
clipboard=%t%
return
$[::
SetKeyDelay, 100 ;只要跟剪贴板有关就必须设置这个参数
t=%clipboard%
clipboard=
x=%clipboard%
y=%clipboard%
send {[}
send {]}
send {left}
clipboard=%t%
return
$'::
SetKeyDelay, 100 ;只要跟剪贴板有关就必须设置这个参数
t=%clipboard%
clipboard=
x=%clipboard%
y=%clipboard%
send {'}
send {'}
send {left}
clipboard=%t%
return
$"::
SetKeyDelay, 100 ;只要跟剪贴板有关就必须设置这个参数
t=%clipboard%
clipboard=
x=%clipboard%
y=%clipboard%
send {"}
send {"}
send {left}
clipboard=%t%
return
CapsLock & n::SendInput {_}
CapsLock & ,::SendInput {=}
;用;p来替换书写经常不好使,因为输入多个字符替换可能会bug
; caplock表示右,ctrl+caplock切换大小写
;CapsLock::SendInput {Right} ;这样改就避免冲突了
CapsLock & l::Send {Right}
CapsLock & i::SendInput {up}
CapsLock & j::SendInput {left}
CapsLock & k::SendInput {down}
CapsLock & y::send print(type()){left 2}
CapsLock & u::Send {backspace}
CapsLock & o::Send {delete}
CapsLock & h::Send {home}
CapsLock::Send {right}
CapsLock & `;::Send {end} ;加入`表示autohotkey里面的转义字符
CapsLock & m::Send import{space}
;send最稳的写法是每次send一个字符
:?:;s::SELECT
!b::
run D:\zhangbo340\Desktop\gapa.exe
return
!g::
run D:\zhangbo340\Desktop\个人信息.txt
return
CapsLock & r::send return{space}
CapsLock & 7::send ^{Backspace}
CapsLock & 8::send ^{del}
CapsLock & p::send print(){left}
CapsLock & e::send exit(){enter}
CapsLock & c::send continue
SetWinDelay, 10
#ClipboardTimeout 2000
;这个版本已经基本修复了输入括号等shift与切换中英文输入法之间的冲突
#s::Suspend ; 给一个热键指定挂起的开关功能。
CapsLock & t::send 15122306087
CapsLock & f::send 210102198908124112
CapsLock & b::
send,break
return
;使用技巧shift是+用多重Send,命令来实现多命令比如下面的按F4来写2维数组,之所以写的这么复杂就是因为剪贴板如果一个代码用多次必然出现bug:
;用()括起来来实现大范围复制:
;因为我括号替换写的不好,最好不要使用剪贴板:
;尽量用send 命令不会出现任何bug:
;写一下这个注释,这里winexist表示存在窗口,那么winclose就关闭,注意这里if括号里面要写return;
;不然他停不下来,继续跑,显然不行;
;这个处理比较麻烦,需要把这个py文件的打开方式的默认程序设置成idle.exe才行.然后写入这个run代码就ok了,总之用autohotkey写代码和快捷键都是锦上添花.:
;窗口命令的注意事项:
;这里面这个写法要注意:1.ifwin不能断开写. 2.后面窗口名字是windows最下排状态栏给的的名字
#x::Run "C:\Program Files (x86)\NetSarang\Xshell 6\Xshell.exe"
#f::Run "C:\Program Files\Everything\Everything.exe"
!p::
IfWinExist, 无标题 - 画图 ;注意这里面的标题名字就是打开程序里面写的标题,注意中间带空格.;这样写就控制了程序开关.
{
WinClose
return
}
else
{
run mspaint
return
}
!j::run calc
!c::
switchime(0)
run cmd
return
:*:;m::[email protected]
^NumpadAdd::SoundSet , +2, WAVE
^NumpadSub::SoundSet , -2, WAVE
F3::
SetKeyDelay, 100
x=%clipboard%
d=.append()
clipboard=%d%
Send ^v
sleep,0.01
Send, {Left}
clipboard=%x%
return
F4::
SetKeyDelay, 100
x=%clipboard%
d=''''''
clipboard=%d%
Send ^v
sleep,0.01
clipboard=%x%
send {left 3}
send {enter}
send {enter}
send {up}
return
F1::
SetKeyDelay, 100
x=%clipboard%
d=for i in range(len()):
clipboard=%d%
Send ^v
sleep,0.01
Send, {Left 3}
clipboard=%x%
return
;使用方法是输入,xun然后空格
:*:lsit::list
:*:braek::break
:*:berak::break
:*:,rr::return{space}
:*:dfe::def
:*:retrun::return
:*:retunr::return
:*:calss::class
:*:slef::self
:*:slfe::self
:*:apend::append
:*:appedn::append
:*:contiune::continue
:*:contnue::continue
;下面为了java扩充的:
CapsLock & s::
SetKeyDelay, 100
x=%clipboard%
d=System.out.println();
clipboard=%d%
Send ^v
sleep,0.01
Send, {Left 2}
clipboard=%x%
return
:*:'::
SetKeyDelay, 100
x=%clipboard%
d=''
clipboard=%d%
Send ^v
Send {Left}
sleep,0.01
clipboard=%x%
return
:*:;d::
switchime(0)
x=%clipboard%
FormatTime, d, LongDate,yyyy-MM-dd,H点mm
SetKeyDelay, 100
clipboard = %d%
SetKeyDelay, 100
Send ^v
clipboard=%x%
return
^F1::
SetKeyDelay, 100
x=%clipboard%
d=for i in range():
clipboard = %d%
Send ^v
Send {LEFT 2}
clipboard=%x%
return
;下面添加sql快捷键
:*:;sql::
switchime(0)
x=%clipboard%
d=select * from ();
SetKeyDelay, 100
clipboard = %d%
SetKeyDelay, 100
Send ^v
Send {LEFT 2}
Send {ENTER 2}
Send {UP}
clipboard=%x%
return
^b::
run www.baidu.com
return
^g::Run www.google.com
return
;把大写禁用了,因为确实基本不用.`表示删除,caplock+ijkl可以控制光标
;经过测试,setkeydelay要设置100才行,否则会偶尔发生粘贴板错误.
SetCapsLockState , AlwaysOff
; 输入法切换，因为win+空格不好按所以改成ctrl+空格符合习惯。
^space::#space
switchime(ime )
{
if (ime = 1){
DllCall("SendMessage", UInt, WinActive("A"), UInt, 80, UInt, 1, UInt, DllCall("LoadKeyboardLayout", Str,"00000804", UInt, 1))
}else if (ime = 0)
{
DllCall("SendMessage", UInt, WinActive("A"), UInt, 80, UInt, 1, UInt, DllCall("LoadKeyboardLayout", Str,, UInt, 1))
}else if (ime = "A")
{
;ime_status:=DllCall("GetKeyboardLayout","int",0,UInt)
Send, #{Space}
}}
; 切换至sougou 调用这个函数即可switchime(1)
; 切换至英文 调用这个函数即可 switchime(0)
!g::
run D:\zhangbo340\Desktop\个人信息.txt
WinShow,A
WinMaximize,A
return
;通过if else已经完美的利用alt+x 启动笔记和最小化笔记,唤起笔记了.
!x::
If WinActive("ahk_class Vim") {
WinMinimize
}
else If WinExist("ahk_class Vim") {
WinActivate
}
else{
run "C:\Program Files (x86)\Vim\vim81\gvim.exe" -y D:\zhangbo340\Desktop\自学笔记.txt
}
return
;下面我要实现的功能是想在一段话左右加括号,只需要选中这段话之后按下shift+9就行.等号右边的变量需要加双%,其实还是有bug存在
;当剪贴板内容和选择内容相同时候有bug,所以如果你要复制一段话到一个新地方并且加上括号.就先复制话,然后输入括号再粘贴即可.顺序反了就出不来.目前只有这个一个bug
$+9:: ;因为这个shift跟输入法的冲突至今还没解决,只能进入搜狗输入法把切换中英文改成ctrl即可.
SetKeyDelay, 100 ;只要跟剪贴板有关就必须设置这个参数
t=%clipboard%
clipboard=
x=%clipboard%
y=%clipboard%
send {(}
send {)}
send {left}
clipboard=%t%
return
$+[::
SetKeyDelay, 100 ;只要跟剪贴板有关就必须设置这个参数
t=%clipboard%
clipboard=
x=%clipboard%
y=%clipboard%
send {{}
send {}}
send {left}
clipboard=%t%
return
$[::
SetKeyDelay, 100 ;只要跟剪贴板有关就必须设置这个参数
t=%clipboard%
clipboard=
x=%clipboard%
y=%clipboard%
send {[}
send {]}
send {left}
clipboard=%t%
return
$'::
SetKeyDelay, 100 ;只要跟剪贴板有关就必须设置这个参数
t=%clipboard%
clipboard=
x=%clipboard%
y=%clipboard%
send {'}
send {'}
send {left}
clipboard=%t%
return
$"::
SetKeyDelay, 100 ;只要跟剪贴板有关就必须设置这个参数
t=%clipboard%
clipboard=
x=%clipboard%
y=%clipboard%
send {"}
send {"}
send {left}
clipboard=%t%
return
CapsLock & n::SendInput {_}
CapsLock & ,::SendInput {+}
CapsLock & .::SendInput {=}
;用;p来替换书写经常不好使,因为输入多个字符替换可能会bug
; caplock表示右,ctrl+caplock切换大小写
;CapsLock::SendInput {Right} ;这样改就避免冲突了
CapsLock & l::Send {Right}
CapsLock & i::SendInput {up}
CapsLock & j::SendInput {left}
CapsLock & k::SendInput {down}
CapsLock & y::send print(type()){left 2}
CapsLock & u::Send {backspace}
CapsLock & o::Send {delete}
CapsLock & h::Send {home}
CapsLock::Send {right}
CapsLock & `;::Send {end} ;加入`表示autohotkey里面的转义字符
CapsLock & m::Send import{space}
;send最稳的写法是每次send一个字符
:?:;s::SELECT
!b::
run D:\zhangbo340\Desktop\gapa.exe
return
CapsLock & r::send return{space}
CapsLock & 7::send ^{Backspace}
CapsLock & 8::send ^{del}
CapsLock & p::send print(){left}
CapsLock & e::send exit(){enter}
CapsLock & c::send continue
SetWinDelay, 10
#ClipboardTimeout 2000
;这个版本已经基本修复了输入括号等shift与切换中英文输入法之间的冲突
#s::Suspend ; 给一个热键指定挂起的开关功能。
CapsLock & t::send 15122306087
CapsLock & f::send 210102198908124112
CapsLock & b::
send,break
return
;使用技巧shift是+用多重Send,命令来实现多命令比如下面的按F4来写2维数组,之所以写的这么复杂就是因为剪贴板如果一个代码用多次必然出现bug:
;用()括起来来实现大范围复制:
;因为我括号替换写的不好,最好不要使用剪贴板:
;尽量用send 命令不会出现任何bug:
;写一下这个注释,这里winexist表示存在窗口,那么winclose就关闭,注意这里if括号里面要写return;
;不然他停不下来,继续跑,显然不行;
;这个处理比较麻烦,需要把这个py文件的打开方式的默认程序设置成idle.exe才行.然后写入这个run代码就ok了,总之用autohotkey写代码和快捷键都是锦上添花.:
;窗口命令的注意事项:
;这里面这个写法要注意:1.ifwin不能断开写. 2.后面窗口名字是windows最下排状态栏给的的名字
#x::Run "C:\Program Files (x86)\NetSarang\Xshell 6\Xshell.exe"
#f::Run "C:\Program Files\Everything\Everything.exe"
!p::
IfWinExist, 无标题 - 画图 ;注意这里面的标题名字就是打开程序里面写的标题,注意中间带空格.;这样写就控制了程序开关.
{
WinClose
return
}
else
{
run mspaint
return
}
!j::run calc
!c::
switchime(0)
run cmd
return
:*:;m::[email protected]
^NumpadAdd::SoundSet , +2, WAVE
^NumpadSub::SoundSet , -2, WAVE
F3::
SetKeyDelay, 100
x=%clipboard%
d=.append()
clipboard=%d%
Send ^v
sleep,0.01
Send, {Left}
clipboard=%x%
return
F4::
SetKeyDelay, 100
x=%clipboard%
d=''''''
clipboard=%d%
Send ^v
sleep,0.01
clipboard=%x%
send {left 3}
send {enter}
send {enter}
send {up}
return
F1::
SetKeyDelay, 100
x=%clipboard%
d=for i in range(len()):
clipboard=%d%
Send ^v
sleep,0.01
Send, {Left 3}
clipboard=%x%
return
;使用方法是输入,xun然后空格
:*:lsit::list
:*:braek::break
:*:berak::break
:*:,rr::return{space}
:*:dfe::def
:*:retrun::return
:*:retunr::return
:*:calss::class
:*:slef::self
:*:slfe::self
:*:apend::append
:*:appedn::append
:*:contiune::continue
:*:contnue::continue
;下面为了java扩充的:
CapsLock & s::
SetKeyDelay, 100
x=%clipboard%
d=System.out.println();
clipboard=%d%
Send ^v
sleep,0.01
Send, {Left 2}
clipboard=%x%
return
:*:'::
SetKeyDelay, 100
x=%clipboard%
d=''
clipboard=%d%
Send ^v
Send {Left}
sleep,0.01
clipboard=%x%
return
:*:;d::
switchime(0)
x=%clipboard%
FormatTime, d, LongDate,yyyy-MM-dd,H点mm
SetKeyDelay, 100
clipboard = %d%
SetKeyDelay, 100
Send ^v
clipboard=%x%
return
^F1::
SetKeyDelay, 100
x=%clipboard%
d=for i in range():
clipboard = %d%
Send ^v
Send {LEFT 2}
clipboard=%x%
return
;下面添加sql快捷键
:*:;sql::
switchime(0)
x=%clipboard%
d=select * from ();
SetKeyDelay, 100
clipboard = %d%
SetKeyDelay, 100
Send ^v
Send {LEFT 2}
Send {ENTER 2}
Send {UP}
clipboard=%x%
return
^b::
run www.baidu.com
return
^g::Run www.google.com
return