中长发变短发详细盘发教程
“江左梅宗主夫人”通过精心收集，向本站投稿了8篇中长发变短发详细盘发教程，下面是小编为大家推荐的中长发变短发详细盘发教程，欢迎大家分享。
篇1：中长发变短发详细盘发教程
在头顶的部分，抓一小部分头发扎起来，不要太紧，稍微有点拱形会更加好看。
拿出黑色的海绵盘发器，就算发量少也不怕哦。
将头发全部放进海绵盘发器的中间，不要有散落的发丝呢。
将它们全放进去之后，向上往头皮内开始包裹住。
包裹好之后，用黑色的夹子，固定好避免头发散开。
这样简单的盘发就完成了哦，弄不太好的美眉们，可以多放点耐心，多试几次，熟能生巧呢。
在戴上个美美的发饰，完工。喜欢的美眉可以收藏起来，慢慢琢磨哦。
[中长发变短发详细盘发教程]
篇2：六个护发妙招 让你短发快速变长发
1、多摄取锌
头发主要是由一种叫做角蛋白的蛋白质构成的，而锌是合成角蛋白必不可少的元素。所以要想让头发长得更快，可以在生活中多吃含锌丰富的食物，比如豆制品、坚果、牡蛎、蛤蜊等。不过每天摄取锌的质量最好不要超过10克，否则会对免疫力产生副作用。
2、按摩头皮
头皮紧绷、毛孔堵塞等都会阻碍头发的生长，所以要想让头发快速长长，可以在洗头的时候用指尖轻轻地按摩头皮。这样不仅可以促进头部的血液循环，还能缓解日常工作的疲劳感，对于健康特别有好处。
3、按摩穴位
有助于头发生长的穴位主要有以下两个，一个是位于两耳廓尖端连线与头部前后正中线的交叉点的百会穴，另一个是位于后头骨正下方凹处，即颈部突起的肌肉外侧凹处的天柱穴，常常按摩这两个穴位可以有助于头发的生长。
4、使用吹风机时避免热风
吹风机的热风会加速头皮毛孔分泌油脂和汗液，不利于头发的生长。所以平常在使用吹风机时，当头发快干的时候，最好切换成冷风使用。
5、不要累积太多压力
心理压力对于头发生长也会起到阻碍作用吗？当然，压力一旦累积，就会阻碍全身的血液循环，而头皮的血液循环也会影响头发的生长。因此在平常的生活中最好要找到一个适合自己的舒缓压力的方法，这也是为了自己的健康着想。
6、睡得好
日常的生活习惯也会影响到头发的生长，人体分泌的生长激素也与头发生长密切相关，晚上最好在10点到凌晨2点之间入睡，这样一直到早上起床，生长激素的分泌就可以达到峰值。
篇3：word中输入“√”和“×” 的详细教程
方法一：输入法输入
我们日常使用的电脑拼音输入法其实都可以快速的打出勾号和叉号，一些智能拼音输入法可以根据我们打的字来判断我们需要的符号，下面就以百度输入法为例，
输入“打勾”或者“对”时我们就可以看到有个“√”的选项。
同理我们在输入“叉”或者“错”时就会出现“×”的选项 另外我们还可以直接使用输入法的符号快捷输入v+1然后在出现的列表中找到自己要的符号，方法二：word中使用符号输入打开word，然后选择工具栏中的插入，在插入栏中我们可以看到一个符号的选项，选择这个我们就能在这里面找到自己想要的符号了。
篇4：Python中正则表达式的详细教程
作者：崔庆才 字体：[增加 减小] 类型：
这篇文章主要介绍了Python中正则表达式的详细教程,正则表达式是Python学习进阶当中的重要内容,需要的朋友可以参考下
1.了解正则表达式
正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑，
正则表达式是用来匹配字符串非常强大的工具，在其他编程语言中同样有正则表达式的概念，Python同样不例外，利用了正则表达式，我们想要从返回的页面内容提取出我们想要的内容就易如反掌了。
正则表达式的大致匹配过程是：
1.依次拿出表达式和文本中的字符比较，
2.如果每一个字符都能匹配，则匹配成功；一旦有匹配不成功的字符则匹配失败。
3.如果表达式中有量词或边界，这个过程会稍微有一些不同。
2.正则表达式的语法规则
下面是Python中正则表达式的一些匹配规则，图片资料来自CSDN
3.正则表达式相关注解
（1）数量词的贪婪模式与非贪婪模式
正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字 符；非贪婪的则相反，总是尝试匹配尽可能少的字符。例如：正则表达式”ab*”如果用于查找”abbbc”，将找到”abbb”。而如果使用非贪婪的数量 词”ab*?”，将找到”a”。
注：我们一般使用非贪婪模式来提取。
（2）反斜杠问题
与大多数编程语言相 同，正则表达式里使用””作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符””，那么使用编程语言表示的正则表达式里将需要4个反 斜杠””：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。
Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r””表示。同样，匹配一个数字的”d”可以写成r”d”。有了原生字符串，妈妈也不用担心是不是漏写了反斜杠，写出来的表达式也更直观勒。
4.Python Re模块
Python 自带了re模块，它提供了对正则表达式的支持。主要用到的方法列举如下
#返回pattern对象re.compile(string[,flag]) #以下为匹配所用函数re.match(pattern, string[, flags])re.search(pattern, string[, flags])re.split(pattern, string[, maxsplit])re.findall(pattern, string[, flags])re.finditer(pattern, string[, flags])re.sub(pattern, repl, string[, count])re.subn(pattern, repl, string[, count])
在介绍这几个方法之前，我们先来介绍一下pattern的概念，pattern可以理解为一个匹配模式，那么我们怎么获得这个匹配模式呢？很简单，我们需要利用re.compile方法就可以。例如
pattern = re.compile(r‘hello‘)
在参数中我们传入了原生字符串对象，通过compile方法编译生成一个pattern对象，然后我们利用这个对象来进行进一步的匹配。
另外大家可能注意到了另一个参数 flags，在这里解释一下这个参数的含义：
参数flag是匹配模式，取值可以使用按位或运算符‘|‘表示同时生效，比如re.I | re.M。
可选值有：
? re.I(全拼：IGNORECASE): 忽略大小写（括号内是完整写法，下同）
? re.M(全拼：MULTILINE): 多行模式，改变‘^‘和‘$‘的行为（参见上图）
? re.S(全拼：DOTALL): 点任意匹配模式，改变‘.‘的行为
? re.L(全拼：LOCALE): 使预定字符类 w W b B s S 取决于当前区域设定
? re.U(全拼：UNICODE): 使预定字符类 w W b B s S d D 取决于unicode定义的字符属性
? re.X(全拼：VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。
在刚才所说的另外几个方法例如 re.match 里我们就需要用到这个pattern了，下面我们一一介绍。
注：以下七个方法中的flags同样是代表匹配模式的意思，如果在pattern生成时已经指明了flags，那么在下面的方法中就不需要传入这个参数了。
（1）re.match(pattern, string[, flags])
这个方法将会从string（我们要匹配的字符串）的开头开始，尝试匹配pattern，一直向后匹配，如果遇到无法匹配的字符，立即返回 None，如果匹配未结束已经到达string的末尾，也会返回None。两个结果均表示匹配失败，否则匹配pattern成功，同时匹配终止，不再对 string向后匹配。下面我们通过一个例子理解一下
__author__ = ‘CQC‘# -*- coding: utf-8 -*- #导入re模块import re # 将正则表达式编译成Pattern对象，注意hello前面的r的意思是“原生字符串”pattern = re.compile(r‘hello‘) # 使用re.match匹配文本，获得匹配结果，无法匹配时将返回Noneresult1 = re.match(pattern,‘hello‘)result2 = re.match(pattern,‘helloo CQC!‘)result3 = re.match(pattern,‘helo CQC!‘)result4 = re.match(pattern,‘hello CQC!‘) #如果1匹配成功if result1: # 使用Match获得分组信息 print result1.groupelse: print ‘1匹配失败！‘ #如果2匹配成功if result2: # 使用Match获得分组信息 print result2.group()else: print ‘2匹配失败！‘ #如果3匹配成功if result3: # 使用Match获得分组信息 print result3.group()else: print ‘3匹配失败！‘ #如果4匹配成功if result4: # 使用Match获得分组信息 print result4.group()else: print ‘4匹配失败！‘
运行结果
hellohello3匹配失败！hello
匹配分析
1.第一个匹配，pattern正则表达式为‘hello‘，我们匹配的目标字符串string也为hello，从头至尾完全匹配，匹配成功。
2.第二个匹配，string为helloo CQC，从string头开始匹配pattern完全可以匹配，pattern匹配结束，同时匹配终止，后面的o CQC不再匹配，返回匹配成功的信息。
3.第三个匹配，string为helo CQC，从string头开始匹配pattern，发现到 ‘o‘ 时无法完成匹配，匹配终止，返回None
4.第四个匹配，同第二个匹配原理，即使遇到了空格符也不会受影响。
我们还看到最后打印出了result.group()，这个是什么意思呢？下面我们说一下关于match对象的的属性和方法
Match对象是一次匹配的结果，包含了很多关于此次匹配的信息，可以使用Match提供的可读属性或方法来获取这些信息。
属性：
1.string: 匹配时使用的文本。
2.re: 匹配时使用的Pattern对象。
3.pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
4.endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
5.lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组，将为None。
6.lastgroup: 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组，将为None。
方法：
1.group([group1, …]):
获得一个或多个分组截获的字符串；指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名；编号0代表整个匹配的子串；不填写参数时，返回group(0)；没有截获字符串的组返回None；截获了多次的组返回最后一次截获的子串。
2.groups([default]):
以元组形式返回全部分组截获的字符串，
相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代，默认为None。
3.groupdict([default]):
返回以有别名的组的别名为键、以该组截获的子串为值的字典，没有别名的组不包含在内。default含义同上。
4.start([group]):
返回指定的组截获的子串在string中的起始索引（子串第一个字符的索引）。group默认值为0。
5.end([group]):
返回指定的组截获的子串在string中的结束索引（子串最后一个字符的索引+1）。group默认值为0。
6.span([group]):
返回(start(group), end(group))。
7.expand(template):
将匹配到的分组代入template中然后返回。template中可以使用id或g、g引用分组，但不能使用编号0。id与g是等价的；但10将被认为是第10个分组，如果你想表达1之后是字符‘0‘，只能使用g0。
下面我们用一个例子来体会一下
# -*- coding: utf-8 -*-#一个简单的match实例 import re# 匹配如下内容：单词+空格+单词+任意字符m = re.match(r‘(w+) (w+)(?P.*)‘, ‘hello world!‘) print “m.string:”, m.stringprint “m.re:”, m.reprint “m.pos:”, m.posprint “m.endpos:”, m.endposprint “m.lastindex:”, m.lastindexprint “m.lastgroup:”, m.lastgroupprint “m.group():”, m.group()print “m.group(1,2):”, m.group(1, 2)print “m.groups():”, m.groups()print “m.groupdict():”, m.groupdict()print “m.start(2):”, m.start(2)print “m.end(2):”, m.end(2)print “m.span(2):”, m.span(2)print r“m.expand(r‘g gg‘):”, m.expand(r‘2 13‘) ### output #### m.string: hello world!# m.re: # m.pos: 0# m.endpos: 12# m.lastindex: 3# m.lastgroup: sign# m.group(1,2): (‘hello‘, ‘world‘)# m.groups(): (‘hello‘, ‘world‘, ‘!‘)# m.groupdict(): {‘sign‘: ‘!‘}# m.start(2): 6# m.end(2): 11# m.span(2): (6, 11)# m.expand(r‘2 13‘): world hello!
（2）re.search(pattern, string[, flags])
search方法与match方法极其类似，区别在于match()函数只检测re是不是在string的开始位置匹配，search()会扫描整个string查找匹配，match只有在0位置匹配成功的话才有返回，如果不是开始位置匹配成功的话，match()就返回None。同样，search方法的返回对象同样match()返回对象的方法和属性。我们用一个例子感受一下
#导入re模块import re # 将正则表达式编译成Pattern对象pattern = re.compile(r‘world‘)# 使用search()查找匹配的子串，不存在能匹配的子串时将返回None# 这个例子中使用match()无法成功匹配match = re.search(pattern,‘hello world!‘)if match: # 使用Match获得分组信息 print match.group()### 输出 #### world
（3）re.split(pattern, string[, maxsplit])
按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，不指定将全部分割。我们通过下面的例子感受一下。
import re pattern = re.compile(r‘d+‘)print re.split(pattern,‘one1two2three3four4‘) ### 输出 #### [‘one‘, ‘two‘, ‘three‘, ‘four‘, ‘‘]
（4）re.findall(pattern, string[, flags])
搜索string，以列表形式返回全部能匹配的子串。我们通过这个例子来感受一下 import re pattern = re.compile(r‘d+‘)print re.findall(pattern,‘one1two2three3four4‘) ### 输出 #### [‘1‘, ‘2‘, ‘3‘, ‘4‘]
（5）re.finditer(pattern, string[, flags])
搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。我们通过下面的例子来感受一下
import re pattern = re.compile(r‘d+‘)for m in re.finditer(pattern,‘one1two2three3four4‘): print m.group(), ### 输出 #### 1 2 3 4
（6）re.sub(pattern, repl, string[, count])
使用repl替换string中每一个匹配的子串后返回替换后的字符串。
当repl是一个字符串时，可以使用id或g、g引用分组，但不能使用编号0。
当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。
count用于指定最多替换次数，不指定时全部替换。
import re pattern = re.compile(r‘(w+) (w+)‘)s = ‘i say, hello world!‘ print re.sub(pattern,r‘2 1‘, s) def func(m): return m.group(1).title() + ‘ ‘ + m.group(2).title() print re.sub(pattern,func, s) ### output #### say i, world hello!# I Say, Hello World!
（7）re.subn(pattern, repl, string[, count])
返回 (sub(repl, string[, count]), 替换次数)。
import re pattern = re.compile(r‘(w+) (w+)‘)s = ‘i say, hello world!‘ print re.subn(pattern,r‘2 1‘, s) def func(m): return m.group(1).title() + ‘ ‘ + m.group(2).title() print re.subn(pattern,func, s) ### output #### (‘say i, world hello!‘, 2)# (‘I Say, Hello World!‘, 2)
5.Python Re模块的另一种使用方式
在上面我们介绍了7个工具方法，例如match，search等等，不过调用方式都是 re.match，re.search的方式，其实还有另外一种调用方式，可以通过pattern.match，pattern.search调用，这样 调用便不用将pattern作为第一个参数传入了，大家想怎样调用皆可。
函数API列表
match(string[, pos[, endpos]]) | re.match(pattern, string[, flags])search(string[, pos[, endpos]]) | re.search(pattern, string[, flags])split(string[, maxsplit]) | re.split(pattern, string[, maxsplit])findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags])finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags])sub(repl, string[, count]) | re.sub(pattern, repl, string[, count])subn(repl, string[, count]) |re.sub(pattern, repl, string[, count])
具体的调用方法不必详说了，原理都类似，只是参数的变化不同。小伙伴们尝试一下吧~
小伙伴们加油，即使这一节看得云里雾里的也没关系，接下来我们会通过一些实战例子来帮助大家熟练掌握正则表达式的。
篇5：在MySQL中实现二分查找的详细教程
这篇文章主要介绍了在MySQL中实现二分查找的详细教程,来自计算机研究生考试原题,需要的朋友可以参考下
给定一个升序排列的自然数数组，数组中包含重复数字，例如：[1,2,2,3,4,4,4,5,6,7,7]，问题：给定任意自然数，对数组进行二分查找，返回数组正确的位置，给出函数实现。注：连续相同的数字，返回第一个匹配位置还是最后一个匹配位置，由函数传入参数决定。
我为什么会出这道题目？
二分查找在数据库内核实现中非常重要
在数据库的内核实现中，二分查找是一个非常重要的逻辑，几乎99%以上的SQL语句(所有索引上的范围扫描/等值查询/Unique查询等)，都会使用到二分查找进行数据的定位。
考虑一个数据库表t1(a int primary key, b int)，表上的b字段有一个B+树索引，表中记录的b字段取值，就是题目中的[1,2,2,3,4,4,4,5,6,7,7]序列。此时，给定以下的两条查询语句，就是使用到了不同的二分查找逻辑：
SQL1：
select * from t1 where b > 4;
SQL2：
select * from t1 where b >= 4;
针对SQL1，索引的二分查找，就需要跳过所有的4，从最后一个4之后开始返回所有记录；针对SQL2，二分查找就需要定位到第一个4，然后顺序读取所有记录。
除此之外，针对数据库中其他的查询逻辑，二分查找还需要附带更多的功能，例如：
SQL3：
select * from t1 where b < 2;
SQL4：
select * from t1 where b <= 2;
由于数据库索引同时支持反向扫描，因此SQL3、SQL4的语句，都可以使用索引反向扫描。反向扫描时，SQL3需要定位到索引中的第一个2；而SQL4，则需要定位到索引的最后一个2，然后开始反向返回满足查询条件的索引记录。
二分查找在程序设计中，是一个十分基础并且易错的功能
第一个真正正确的二分查找算法，在第一个二分查找实现之后的，才被发表出来。通过Google，输入Binary Search或者是二分查找关键字，有大量的相关的文章或者博客讨论此话题。
二分查找实现，需要注意的问题
本文不准备详细介绍一个正确的二分查找应该是如何实现的，毕竟现在网上有着大量的正确版本。接下来，根据批改试卷过程中发现的一些问题，做一些简单的分析，希望对大家实现一个有效的二分查找算法，甚至是一个数据库内可用的二分查找算法，有所帮助。
问题一：是否检查参数的有效性
大量的试卷，在给出此问题的解决算法时，直接拿着low，high参数开始进行计算，但是却没有检查low/high参数。low/high是否相同，数组中是否存在记录？low/high构成的区间是否有效？代码的鲁棒性不足。
在数据库的二分查找实现中，一般是对一个索引页面进行二分查找。索引页面中有可能根本不存在用户的记录(索引页面中的记录全部被删除，又没有与兄弟页面合并时)，此时，low/high均为0，此时如果根据low/high计算出来的mid进行记录的读取，就存在逻辑错误。
问题二：二分查找中值的计算
这是一个经典的话题，如何计算二分查找中的中值？试卷中，大家一般给出了两种计算方法：
算法一： mid = (low + high) / 2
算法二： mid = low + (high C low)/2
乍看起来，算法一简洁，算法二提取之后，跟算法一没有什么区别。但是实际上，区别是存在的。算法一的做法，在极端情况下，(low + high)存在着溢出的风险，进而得到错误的mid结果，导致程序错误。而算法二能够保证计算出来的mid，一定大于low，小于high，不存在溢出的问题。
回到数据库二分查找，数据库的一个索引页面(大小一般是8k或者是16k)，能够存储的索引记录是有限的，因此肯定不会出现(low + high)溢出的风险。这也是为什么InnoDB中的中值，采用的就是算法一的实现。但是，作为一个严谨的程序设计人员，还是推荐使用算法二，将任何潜在的风险，扼杀于摇篮之中。
问题三：递归实现二分查找
超过一半的试卷，使用了递归调用的方式实现二分查找。不能说递归实现有错，而是在于实现效率问题。总所周知，递归调用存在着压栈/出栈的开销，其效率是比较低下的。而以数据库这样一个极端优化代码效率，提供快速查询响应的系统来说，效率是第一位的。不建议使用递归方式实现二分查找，至少在数据库内核实现中是不允许使用的。据我所知，所有的开源数据库系统，例如：InnoDB，PostgreSQL都未采用递归方式实现二分查找。
问题四：如何查找第一个/最后一个等值
回到题目，要求根据传入的参数不同，返回第一个/最后一个等值项。在本文的背景部分，我也解释了此问题对应的数据库查询(>，>=查询需求是不同的)。在试卷中，超过80%的同学的答案都是先进行二分查找，待定位到相同值之后，再根据传入的flag(用户需求：flag = 1，返回第一个等值项；flag = 0，返回最后一个等值项)，进行顺序遍历，直至定位到满足条件的项。
同样，不能说这个实现是错的，但是也存在着性能问题。性能性能性能，永远是数据库内核实现考虑的重点之一(相信也是所有应用程序的一个指标)。数据库中，除了主键索引/Unique索引能够保证键值唯一之外，很多二级辅助索引都是存在相同键值的，有时相同键值的项会超过千项(考虑一个用户的订单，或者是购买记录)。
假设一个索引页面，保存着400项记录，均为相同键值。此时，使用先二分查找，后顺序遍历的算法，二分查找只能使用一次，顺序遍历199次，最终对比了200次。效率非常之低。当然，我也欣喜的看到另外一小部分同学的做法(我期待看到的算法)，用flag来纠正每次比较的最终结果，
例如：比较相等(相等用0表示，大于为1，小于为-1)，但是flag = 1，则返回纠正后的比较结果为1，需要移动二分查找的high到mid，继续二分(反之，若flag = 0，则返回纠正后的结果为-1，需要移动二分查找的low到mid，继续二分)。如此一来，等值仍旧可以进行二分查找，最终的对比只需要9次，远远小于200次。
此问题，进一步引出了下一个问题，数据库中如何实现一个通用的，更为复杂的二分查找算法？
问题五：数据库中的二分查找实现举例
数据库中的二分查找，更为复杂，需要实现一个通用型的二分查找算法，使用于各种不同的SQL查询场景。
InnoDB针对不同的SQL语句，总结出四种不同的Search Mode，分别为：
#define PAGE_CUR_G 1 >查询
#define PAGE_CUR_GE 2 >=，=查询
#define PAGE_CUR_L 3 <查询>
#define PAGE_CUR_LE 4 <=查询
然后根据这四种不同的Search Mode，在二分查找碰到相同键值时进行调整。例如：若Search Mode为PAGE_CUR_G或者是PAGE_CUR_LE，则移动low至mid，继续进行二分查找；若Search Mode为PAGE_CUR_GE或者是PAGE_CUR_L，则移动high至mid，继续进行二分查找。
我们的TNT引擎，采用了与InnoDB不同的方案，但是也实现了相同的功能。TNT引擎针对相同键值的调整总结为下图，在此我就不做解释了，大家可以尝试着自己进行分析。
/* 操作符 includeKey forward compare result: 1 0 -1 */
=============================================================================
>= 1 1 | 1 -1 -1
= 1 1 | 1 -1 -1
> 0 1 | 1 1 -1
< 0 0 | 1 -1 -1
<= 1 0 | 1 1 -1
=============================================================================
篇6：ps画笔存储到画笔的下拉列表中的详细教程
ps的画笔怎么存储到画笔的下拉列表中？在我们平时使用软件的时候通常的情况下，我们会把直接下载的画笔直接安装到软件的界面中，要是把下载的画笔都存储在画笔的面板中的话，它会降低软件的打开速度，下面分享解决办法
在我们平时使用软件的时候通常的情况下，我们会把直接下载的画笔直接安装到软件的界面中，要是把下载的画笔都存储在画笔的面板中的话，它会降低软件的打开速度，如果想要把画笔也像软件自带的那样把它存储到画笔的下拉菜单中要怎么做？
1、如果我们每次都把下载好的画笔直接存储到画笔的列表中，这样的话虽然方便我们随时调来使用，但是如果在那里存储的画笔多了，在一定程序上也会降低软件打开的速度。可以看到这里的力笔太多了，打开软件也有点慢，所以要把它进行一个编组，把一些放到画笔的列表中去。
2、要把它存储到画笔的列表中，首先要把我们的画笔存储一下，然后再放到安装目录的画笔文件中。在画笔右上角点击设置，在下拉菜单中点击打开预设管理器。
3、在打开的预设管理器中按着键盘上的ctrl键点击你要添加的画笔，这里我就选择白云的效果画笔。选中之后，点击存储设置，如果电脑上保存的有这个效果也用存储就可以。这里存储一下。
4、存储之后在弹出的面板中你可以把它保存一个位置，这里为了方便就把它放在桌面上，点击保存，接着再点击画笔管理器完成。就把白云的画笔效果存储在了桌面上了。
5、存储完成之后，接下来就要找到软件安装目录，首先右键点击软件的属性。平时如果我们想要快速的找到软件的安装位置的话，最快速的方法就是对通过在它的软件上右键点击，然后再通过属性去一步步的查找。
6、在属性的对话框中找到打开文件位置并打开。（在打开的属性对话框中，我们可以看到它的界面中有目标，在目标中我们通过键盘上的方向键也可以找到它文件夹所在的文件所在的位置）
7、然后在打开的面板中找到Presets的文件夹，
双击打开Presets文件夹后，在它弹出的面板列表中找到Brushes的文件。这个就是画笔笔刷的文件夹所在位置。
8、双击打开这个画笔的文件夹，就可以看到一些画笔的列表。这些就是软件画笔的存储列表。这些都是一些不同类型的画笔效果。
9、我们刚才所打开安装目录中的一些画笔效果。就是这些在photoshop画笔的下拉列表中所显示的画笔效果。
10、接下来就需要复制我们的刚才保存在桌面上的白云画笔。点击右键把它复制一下。
11、复制好之后，把它粘贴到打开的软件安装目录中的画笔文件中。也就是Brushes的文件夹中。粘贴完成之后，可以在我们的画笔笔刷的列表中看到我们刚才粘贴进来的白云画笔。
12、完成之后，我们如果软件是打开的话，要先把软件关闭一下，如果软件是打开着的话，你没有进行一个关闭你去查看你所复制的画笔效果的时候，它是不显示的。这里就需要把它关闭后，然后再进行打开。当你打开画笔的界面，点击设置右上角的下拉三角，你就可以看到你刚才存储的白云画笔已经在下拉列表中了。
13、既然下拉列表中有了白云的画笔，我们就可以把画笔面板中的白云画笔删除了。我们再打开预设管理器，按着键盘上的ctrl键，我们可以同时择多个画笔。选中白云的画笔后，点击删除。之后点击完成。
14、这样把其它类型的画笔也用这个方法存储在安装目录的列表中，存储之后再把画笔面板中的删除，这样软件的运行速度也会快许多。
注意事项：把画笔存储到菜单的下拉列表中，这样画笔面板中的画笔少了可以缩短打开软件的速度，定期删除一些重复的画笔。希望这会对您有所帮助！如果您觉得还可以，请投票支持一下！
篇7：Python中使用Beautiful Soup库的超详细教程
作者：崔庆才 字体：[增加 减小] 类型：
这篇文章主要介绍了Python中使用Beautiful Soup库的超详细教程,示例代码基于Python2.x版本,极力推荐!需要的朋友可以参考下
1. Beautiful Soup的简介
简单来说，Beautiful Soup是python的一个库，最主要的功能是从网页抓取数据，官方解释如下：
Beautiful Soup提供一些简单的、python式的函数用来处理导航、搜索、修改分析树等功能。它是一个工具箱，通过解析文档为用户提供需要抓取的数据，因为简单，所以不需要多少代码就可以写出一个完整的应用程序。
Beautiful Soup自动将输入文档转换为Unicode编码，输出文档转换为utf-8编码。你不需要考虑编码方式，除非文档没有指定一个编码方式，这时，Beautiful Soup就不能自动识别编码方式了。然后，你仅仅需要说明一下原始编码方式就可以了。
Beautiful Soup已成为和lxml、html6lib一样出色的python解释器，为用户灵活地提供不同的解析策略或强劲的速度。
废话不多说，我们来试一下吧~
2. Beautiful Soup 安装
Beautiful Soup 3 目前已经停止开发，推荐在现在的项目中使用Beautiful Soup 4，不过它已经被移植到BS4了，也就是说导入时我们需要 import bs4 。所以这里我们用的版本是 Beautiful Soup 4.3.2 (简称BS4)，另外据说 BS4 对 Python3 的支持不够好，不过我用的是 Python2.7.7，如果有小伙伴用的是 Python3 版本，可以考虑下载 BS3 版本。
如果你用的是新版的Debain或Ubuntu,那么可以通过系统的软件包管理来安装，不过它不是最新版本，目前是4.2.1版本
sudo apt-get install Python-bs4
如果想安装最新的版本，请直接下载安装包来手动安装，也是十分方便的方法。在这里我安装的是 Beautiful Soup 4.3.2
Beautiful Soup 3.2.1Beautiful Soup 4.3.2
下载完成之后解压
运行下面的命令即可完成安装
sudo python setup.py install
如下图所示，证明安装成功了
然后需要安装 lxml
sudo apt-get install Python-lxml
Beautiful Soup支持Python标准库中的HTML解析器,还支持一些第三方的解析器，如果我们不安装它，则 Python 会使用 Python默认的解析器，lxml 解析器更加强大，速度更快，推荐安装。
3. 开启Beautiful Soup 之旅
在这里先分享官方文档链接，不过内容是有些多，也不够条理，在此本文章做一下整理方便大家参考。
官方文档
4. 创建 Beautiful Soup 对象
首先必须要导入 bs4 库
from bs4 import BeautifulSoup
我们创建一个字符串，后面的例子我们便会用它来演示
html = “”“
The Dormouse‘s story
Once upon a time there were three little sisters; and their names were,Lacie andTillie;and they lived at the bottom of a well.
...
”“”创建 beautifulsoup 对象
soup = BeautifulSoup(html)
另外，我们还可以用本地 HTML 文件来创建对象，例如
soup = BeautifulSoup(open(‘index.html‘))
上面这句代码便是将本地 index.html 文件打开，用它来创建 soup 对象
下面我们来打印一下 soup 对象的内容，格式化输出
print soup.prettify
The Dormouse‘s story
Once upon a time there were three little sisters; and their names were , Lacie and Tillie ;and they lived at the bottom of a well.
...
以上便是输出结果，格式化打印出了它的内容，这个函数经常用到，小伙伴们要记好咯。
5. 四大对象种类
Beautiful Soup将复杂HTML文档转换成一个复杂的树形结构,每个节点都是Python对象,所有对象可以归纳为4种:
Tag
NavigableString
BeautifulSoup
Comment
下面我们进行一一介绍
（1）Tag
Tag 是什么？通俗点讲就是 HTML 中的一个个标签，例如
上面的 title a 等等 HTML 标签加上里面包括的内容就是 Tag，下面我们来感受一下怎样用 Beautiful Soup 来方便地获取 Tags
下面每一段代码中注释部分即为运行结果
print soup.title#
The Dormouse‘s story
我们可以利用 soup加标签名轻松地获取这些标签的内容，是不是感觉比正则表达式方便多了？不过有一点是，它查找的是在所有内容中的第一个符合要求的标签，如果要查询所有的标签，我们在后面进行介绍。
我们可以验证一下这些对象的类型
print type(soup.a)# 对于 Tag，它有两个重要的属性，是 name 和 attrs，下面我们分别来感受一下 name print soup.nameprint soup.head.name#[document]#head soup 对象本身比较特殊，它的 name 即为 [document]，对于其他内部标签，输出的值便为标签本身的名称。 attrs print soup.p.attrs#{‘class‘: [‘title‘], ‘name‘: ‘dromouse‘} 在这里，我们把 p 标签的所有属性打印输出了出来，得到的类型是一个字典。 如果我们想要单独获取某个属性，可以这样，例如我们获取它的 class 叫什么 print soup.p[‘class‘]#[‘title‘] 还可以这样，利用get方法，传入属性的名称，二者是等价的 print soup.p.get(‘class‘)#[‘title‘] 我们可以对这些属性和内容等等进行修改，例如 soup.p[‘class‘]=“newClass”print soup.p# The Dormouse‘s story 还可以对这个属性进行删除，例如 del soup.p[‘class‘]print soup.p# The Dormouse‘s story 不过，对于修改删除的操作，不是我们的主要用途，在此不做详细介绍了，如果有需要，请查看前面提供的官方文档 （2）NavigableString 既然我们已经得到了标签的内容，那么问题来了，我们要想获取标签内部的文字怎么办呢？很简单，用 .string 即可，例如 print soup.p.string#The Dormouse‘s story 这样我们就轻松获取到了标签里面的内容，想想如果用正则表达式要多麻烦。它的类型是一个 NavigableString，翻译过来叫 可以遍历的字符串，不过我们最好还是称它英文名字吧。 print type(soup.p.string)# 来检查一下它的类型 print type(soup.p.string)# （3）BeautifulSoup BeautifulSoup 对象表示的是一个文档的全部内容.大部分时候,可以把它当作 Tag 对象，是一个特殊的 Tag，我们可以分别获取它的类型，名称，以及属性来感受一下 print type(soup.name)# （4）Comment Comment 对象是一个特殊类型的 NavigableString 对象，其实输出的内容仍然不包括注释符号，但是如果不好好处理它，可能会对我们的文本处理造成意想不到的麻烦。 我们找一个带注释的标签 print soup.aprint soup.a.stringprint type(soup.a.string) 运行结果如下 Elsie a 标签里的内容实际上是注释，但是如果我们利用 .string 来输出它的内容，我们发现它已经把注释符号去掉了，所以这可能会给我们带来不必要的麻烦。 另外我们打印输出下它的类型，发现它是一个 Comment 类型，所以，我们在使用前最好做一下判断，判断代码如下 if type(soup.a.string)==bs4.element.Comment: print soup.a.string 上面的代码中，我们首先判断了它的类型，是否为 Comment 类型，然后再进行其他操作，如打印输出。 6. 遍历文档树 （1）直接子节点 要点：.contents .children 属性 .contents tag 的 .content 属性可以将tag的子节点以列表的方式输出 print soup.head.contents #[ 输出方式为列表，我们可以用列表索引来获取它的某一个元素 print soup.head.contents[0]# 它返回的不是一个 list，不过我们可以通过遍历获取所有子节点。 我们打印输出 .children 看一下，可以发现它是一个 list 生成器对象 print soup.head.children# 我们怎样获得里面的内容呢？很简单，遍历一下就好了，代码及结果如下 for child in soup.body.children: print child The Dormouse‘s story Once upon a time there were three little sisters; and their names were,Lacie andTillie;and they lived at the bottom of a well. ... （2）所有子孙节点 知识点：.descendants 属性 .descendants .contents 和 .children 属性仅包含tag的直接子节点，.descendants 属性可以对所有tag的子孙节点进行递归循环，和 children类似，我们也需要遍历获取其中的内容。 for child in soup.descendants: print child 运行结果如下，可以发现，所有的节点都被打印出来了，先生最外层的 HTML标签，其次从 head 标签一个个剥离，以此类推。 The Dormouse‘s story Once upon a time there were three little sisters; and their names were,Lacie andTillie;and they lived at the bottom of a well. ... The Dormouse‘s story Once upon a time there were three little sisters; and their names were,Lacie andTillie;and they lived at the bottom of a well. ... The Dormouse‘s story Once upon a time there were three little sisters; and their names were,Lacie andTillie;and they lived at the bottom of a well. ... （3）节点内容 知识点：.string 属性 如果tag只有一个 NavigableString 类型子节点,那么这个tag可以使用 .string 得到子节点。如果一个tag仅有一个子节点,那么这个tag也可以使用 .string 方法,输出结果与当前唯一子节点的 .string 结果相同。 通俗点说就是：如果一个标签里面没有标签了，那么 .string 就会返回标签里面的内容。如果标签里面只有唯一的一个标签了，那么 .string 也会返回最里面的内容。例如 print soup.head.string#The Dormouse‘s storyprint soup.title.string#The Dormouse‘s story 如果tag包含了多个子节点,tag就无法确定，string 方法应该调用哪个子节点的内容, .string 的输出结果是 None print soup.html.string# None （4）多个内容 知识点： .strings .stripped_strings 属性 .strings 获取多个内容，不过需要遍历获取，比如下面的例子 for string in soup.strings: print(repr(string)) # u“The Dormouse‘s story” # u‘nn‘ # u“The Dormouse‘s story” # u‘nn‘ # u‘Once upon a time there were three little sisters; and their names weren‘ # u‘Elsie‘ # u‘,n‘ # u‘Lacie‘ # u‘ andn‘ # u‘Tillie‘ # u‘;nand they lived at the bottom of a well.‘ # u‘nn‘ # u‘...‘ # u‘n‘ .stripped_strings 输出的字符串中可能包含了很多空格或空行,使用 .stripped_strings 可以去除多余空白内容 for string in soup.stripped_strings: print(repr(string)) # u“The Dormouse‘s story” # u“The Dormouse‘s story” # u‘Once upon a time there were three little sisters; and their names were‘ # u‘Elsie‘ # u‘,‘ # u‘Lacie‘ # u‘and‘ # u‘Tillie‘ # u‘;nand they lived at the bottom of a well.‘ # u‘...‘ （5）父节点 知识点： .parent 属性 p = soup.pprint p.parent.name#body content = soup.head.title.stringprint content.parent.name#title （6）全部父节点 知识点：.parents 属性 通过元素的 .parents 属性可以递归得到元素的所有父辈节点，例如 content = soup.head.title.stringfor parent in content.parents: print parent.name titleheadhtml[document] （7）兄弟节点 知识点：.next_sibling .previous_sibling 属性 兄弟节点可以理解为和本节点处在统一级的节点，.next_sibling 属性获取了该节点的下一个兄弟节点，.previous_sibling 则与之相反，如果节点不存在，则返回 None 注意：实际文档中的tag的 .next_sibling 和 .previous_sibling 属性通常是字符串或空白，因为空白或者换行也可以被视作一个节点，所以得到的结果可能是空白或者换行 print soup.p.next_sibling# 实际该处为空白print soup.p.prev_sibling#None 没有前一个兄弟节点，返回 Noneprint soup.p.next_sibling.next_sibling# Once upon a time there were three little sisters; and their names were#,#Lacie and#Tillie;#and they lived at the bottom of a well. （8）全部兄弟节点 知识点：.next_siblings .previous_siblings 属性 通过 .next_siblings 和 .previous_siblings 属性可以对当前节点的兄弟节点迭代输出 for sibling in soup.a.next_siblings: print(repr(sibling)) # u‘,n‘ # Lacie # u‘ andn‘ # Tillie # u‘; and they lived at the bottom of a well.‘ # None （9）前后节点 知识点：.next_element .previous_element 属性 与 .next_sibling .previous_sibling 不同，它并不是针对于兄弟节点，而是在所有节点，不分层次 比如 head 节点为 The Dormouse‘s story 那么它的下一个节点便是 title，它是不分层次关系的 print soup.head.next_element# （10）所有前后节点 知识点：.next_elements .previous_elements 属性 通过 .next_elements 和 .previous_elements 的迭代器就可以向前或向后访问文档的解析内容,就好像文档正在被解析一样 for element in last_a_tag.next_elements: print(repr(element))# u‘Tillie‘# u‘;nand they lived at the bottom of a well.‘# u‘nn‘# ... 7.搜索文档树 （1）find_all( name , attrs , recursive , text , **kwargs ) find_all() 方法搜索当前tag的所有tag子节点,并判断是否符合过滤器的条件 1）name 参数 name 参数可以查找所有名字为 name 的tag,字符串对象会被自动忽略掉 A.传字符串 最简单的过滤器是字符串.在搜索方法中传入一个字符串参数,Beautiful Soup会查找与字符串完整匹配的内容,下面的例子用于查找文档中所有的标签 soup.find_all(‘b‘)# [The Dormouse‘s story] print soup.find_all(‘a‘)#[, Lacie, Tillie] B.传正则表达式 如果传入正则表达式作为参数,Beautiful Soup会通过正则表达式的 match() 来匹配内容.下面例子中找出所有以b开头的标签,这表示和标签都应该被找到 import refor tag in soup.find_all(re.compile(“^b”)): print(tag.name)# body# b C.传列表 如果传入列表参数,Beautiful Soup会将与列表中任一元素匹配的内容返回.下面代码找到文档中所有标签和标签 soup.find_all([“a”, “b”])# [The Dormouse‘s story,# Elsie,# Lacie,# Tillie] D.传 True True 可以匹配任何值,下面代码查找到所有的tag,但是不会返回字符串节点 for tag in soup.find_all(True): print(tag.name)# html# head# title# body# p# b# p# a# a E.传方法 如果没有合适过滤器,那么还可以定义一个方法,方法只接受一个元素参数 [4] ,如果这个方法返回 True 表示当前元素匹配并且被找到,如果不是则反回 False 下面方法校验了当前元素,如果包含 class 属性却不包含 id 属性,那么将返回 True: def has_class_but_no_id(tag): return tag.has_attr(‘class‘) and not tag.has_attr(‘id‘) 将这个方法作为参数传入 find_all() 方法,将得到所有 标签: soup.find_all(has_class_but_no_id)# [ The Dormouse‘s story Once upon a time there were... ... 2）keyword 参数 注意：如果一个指定名字的参数不是搜索内置的参数名,搜索时会把该参数当作指定名字tag的属性来搜索,如果包含一个名字为 id 的参数,Beautiful Soup会搜索每个tag的”id”属性 soup.find_all(id=‘link2‘)# [Lacie] 如果传入 href 参数,Beautiful Soup会搜索每个tag的”href”属性 soup.find_all(href=re.compile(“elsie”))# [Elsie] 使用多个指定名字的参数可以同时过滤tag的多个属性 soup.find_all(href=re.compile(“elsie”), id=‘link1‘)# [three] 在这里我们想用 class 过滤，不过 class 是 python 的关键词，这怎么办？加个下划线就可以 soup.find_all(“a”, class_=“sister”)# [Elsie,# Lacie,# Tillie] 有些tag属性在搜索不能使用,比如HTML5中的 data-* 属性 soup.find_all(“a”, class_=“sister”)# [Elsie,# Lacie,# Tillie] 但是可以通过 find_all() 方法的 attrs 参数定义一个字典参数来搜索包含特殊属性的tag data_soup.find_all(attrs={“data-foo”: “value”})# [foo!] 3）text 参数 通过 text 参数可以搜搜文档中的字符串内容.与 name 参数的可选值一样, text 参数接受 字符串 , 正则表达式 , 列表, True soup.find_all(text=“Elsie”)# [u‘Elsie‘] soup.find_all(text=[“Tillie”, “Elsie”, “Lacie”])# [u‘Elsie‘, u‘Lacie‘, u‘Tillie‘] soup.find_all(text=re.compile(“Dormouse”))[u“The Dormouse‘s story”, u“The Dormouse‘s story”] 4）limit 参数 find_all() 方法返回全部的搜索结构,如果文档树很大那么搜索会很慢.如果我们不需要全部结果,可以使用 limit 参数限制返回结果的数量.效果与SQL中的limit关键字类似,当搜索到的结果数量达到 limit 的限制时,就停止搜索返回结果. 文档树中有3个tag符合搜索条件,但结果只返回了2个,因为我们限制了返回数量 soup.find_all(“a”, limit=2)# [Elsie,# Lacie] 5）recursive 参数 调用tag的 find_all() 方法时,Beautiful Soup会检索当前tag的所有子孙节点,如果只想搜索tag的直接子节点,可以使用参数 recursive=False . 一段简单的文档: 代码如下: The Dormouse‘s story ... 是否使用 recursive 参数的搜索结果: soup.html.find_all(“title”)# [ （2）find( name , attrs , recursive , text , **kwargs ) 它与 find_all() 方法唯一的区别是 find_all() 方法的返回结果是值包含一个元素的列表,而 find() 方法直接返回结果 （3）find_parents() find_parent() find_all() 和 find() 只搜索当前节点的所有子节点,孙子节点等. find_parents() 和 find_parent() 用来搜索当前节点的父辈节点,搜索方法与普通tag的搜索方法相同,搜索文档搜索文档包含的内容 （4）find_next_siblings() find_next_sibling() 这2个方法通过 .next_siblings 属性对当 tag 的所有后面解析的兄弟 tag 节点进行迭代, find_next_siblings() 方法返回所有符合条件的后面的兄弟节点,find_next_sibling() 只返回符合条件的后面的第一个tag节点 （5）find_previous_siblings() find_previous_sibling() 这2个方法通过 .previous_siblings 属性对当前 tag 的前面解析的兄弟 tag 节点进行迭代, find_previous_siblings() 方法返回所有符合条件的前面的兄弟节点, find_previous_sibling() 方法返回第一个符合条件的前面的兄弟节点 （6）find_all_next() find_next() 这2个方法通过 .next_elements 属性对当前 tag 的之后的 tag 和字符串进行迭代, find_all_next() 方法返回所有符合条件的节点, find_next() 方法返回第一个符合条件的节点 （7）find_all_previous() 和 find_previous() 这2个方法通过 .previous_elements 属性对当前节点前面的 tag 和字符串进行迭代, find_all_previous() 方法返回所有符合条件的节点, find_previous()方法返回第一个符合条件的节点 注：以上（2）（3）（4）（5）（6）（7）方法参数用法与 find_all() 完全相同，原理均类似，在此不再赘述， 8.CSS选择器 我们在写 CSS 时，标签名不加任何修饰，类名前加点，id名前加 #，在这里我们也可以利用类似的方法来筛选元素，用到的方法是 soup.select()，返回类型是 list （1）通过标签名查找 print soup.select(‘title‘) #[ （2）通过类名查找 print soup.select(‘.sister‘)#[, Lacie, Tillie] （3）通过 id 名查找 print soup.select(‘#link1‘)#[] （4）组合查找 组合查找即和写 class 文件时，标签名与类名、id名进行的组合原理是一样的，例如查找 p 标签中，id 等于 link1的内容，二者需要用空格分开 print soup.select(‘p #link1‘)#[] 直接子标签查找 print soup.select(“head > title”)#[ （5）属性查找 查找时还可以加入属性元素，属性需要用中括号括起来，注意属性和标签属于同一节点，所以中间不能加空格，否则会无法匹配到。 print soup.select(“head > title”)#[ 同样，属性仍然可以与上述查找方式组合，不在同一节点的空格隔开，同一节点的不加空格 print soup.select(‘p a[href=“example.com/elsie”]‘)#[] 好，这就是另一种与 find_all 方法有异曲同工之妙的查找方法，是不是感觉很方便？ 总结 本篇内容比较多，把 Beautiful Soup 的方法进行了大部分整理和总结，不过这还不算完全，仍然有 Beautiful Soup 的修改删除功能，不过这些功能用得比较少，只整理了查找提取的方法，希望对大家有帮助！小伙伴们加油！ 熟练掌握了 Beautiful Soup，一定会给你带来太多方便，加油吧！ 1、点击上方功能区中的“数据”按钮，在展开的选项卡中选择“筛选”，再在“筛选”的选项卡中选择“自动筛选”。 【中长发变短发详细盘发教程】相关文章：篇8：Excel表格中对指定的数据进行筛选的详细教程
文档为doc格式
