开发者社区> 技术小阿哥> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

VII Python(6)基础知识(re正则表达式、MySQLdb模块)

简介:
+关注继续查看

正则表达式REregular expression)是一种小型的、高度专业化的编程语言,肉嵌在python中,通过re模块实现;

当发现有问题用正则表达式可解决时,于是将面临两个问题;

RE模式被编译成一系统的字节码,再由匹配引擎(C写的)执行,RE语言相对小型和受限(功能有限,并非所有字符串处理都能用RE完成);

re模块提供了顶级函数调用,常用的有:findall()sub()match()search()subn()split()

 

In [1]: import re

In [2]: re.<TAB>

re.DEBUG        re.L            re.S            re.U            re.compile      re.findall      re.search       re.sub

re.DOTALL       re.LOCALE       re.Scanner      re.UNICODE      re.copy_reg     re.finditer     re.split        re.subn

re.I            re.M            re.T            re.VERBOSE      re.error        re.match        re.sre_compile  re.sys

re.IGNORECASE   re.MULTILINE    re.TEMPLATE     re.X            re.escape       re.purge        re.sre_parse    re.template

In [2]: help(re.search)   #search()方法用于在字符串中搜索模式第一次匹配的位置,若有匹配到返回的是对象的内存地址,若没匹配到则返回空)

search(pattern, string, flags=0)

In [3]: help(re.findall)   #findall()将匹配到的字符串打包为列表)

findall(pattern, string,flags=0)

   Return a list of all non-overlapping matches in the string.

In [4]: help(re.compile)

compile(pattern, flags=0)

   Compile a regular expression pattern, returning a pattern object.

In [5]: help(re.finditer)

finditer(pattern, string,flags=0)

   Return an iterator over all non-overlapping matches in the

   string.  For each match, theiterator returns a match object.

In [6]: help(re.subn)

subn(pattern, repl,string, count=0, flags=0)

   Return a 2-tuple containing (new_string, number).

In [7]: help(re.match)

match(pattern, string,flags=0)

   Try to apply the pattern at the start of the string, returning

    amatch object, or None if no match was found.

 

正则中默认是打开大小写敏感的,可在标志位处使用re.IGNORECASE取消;

正则中不区分数字,全是字符;

正则默认是贪婪模式,在条件符合时尽可能多的匹配,可在.+后加上?进入非贪婪模式即最小匹配范围;

字符匹配(普通字符和元字符):

普通字符(大多数字符一般都会和自身匹配,例如r'test'会和字符串'test'完全匹配);

元字符;

 

元字符(11个):

. ^  $  * +  ?  {} []  \  |  ()

.点(匹配换行符以外的任意字符);

^(匹配行首,字符串的开始位置,除非设置标志位re.MULTILINE,在re.MULTILINE模式里也可匹配字符串中的每个换行);

$(匹配行尾,行尾被定义为要么是字符串尾,要么是一个换行字符后的任何位置);

*(指定前一个字符匹配0次或任意次,贪婪模式,匹配引擎会尝试重复尽可能多的次数,不超过整数界定范围20亿);

+(前一个字符匹配一次或任意次,默认贪婪模式,若要用非贪婪模式(最小匹配模式)+后跟?);

?(匹配前一个字符0次或1次,可理解为它用于标识某事物是可选的);

{m,n}mn是十进制整数,前一个字符至少m次重复,最多n次;忽略m则下边界是0,忽略n则上边界是无穷大(20亿));

[](常用来指定一个字符集,如[abc][a-z],元字符在字符集中不起作用;字符集中开始处使用^,补集匹配不在区间内的字符);

\num\后跟不同的字符表示不同的意义;若当作转义符用可取消元字符本身的意义;\d等同于[0-9]\D等同于[^0-9]\s等同于[\t\n\r\f\v]\S等同于[^\t\n\r\f\v]\w等同于[a-zA-Z0-9_]\W等同于[^a-zA-Z0-9_]

()(分组)

 

注:

*等同于{0,}+等同于{1,}?等同于{0,1};尽量使用*+?这三个符号,因为既美观而且更关键的是正则引擎内部会对这三个符号进行优化,进而执行效率要高,而不要用等同的{0,}{1,}{0,1}

*+区别(*匹配的前一个字符可以是0次,+要至少是一次);

[]中的元字符代表其本身,不具备元字符的功能;

 

\序号(若序号为单个数字,则是引用序号对应的子组所匹配的字符串,子组的序号从1开始计算;若序号以0开头或是3个字符长度时,那么不会被用于对应的子组,而是用于匹配八进制的数字所表示的ASCII表对应的字符);

\A(等同于^,脱字符);

\Z(等同于$

\b(匹配单词边界,单词被定义为Unicode的字母数字或下划线,注意下划线也是单词的一部分);

\B(与\b相反,匹配非单词边界,例如py\B匹配pythonpy2py3而不匹配py py.py!);

\d(对于Unicode(str类型)模式,匹配任何一个数字,包括[0-9]和其它数字字符,若开启了re.ASCII标志,只匹配[0-9];对于8位模式(bytes类型)匹配[0-9]中任何一个数字);

\D(与\d相反,匹配任何非Unicode的数字,若开启了re.ASCII标志,则相当于匹配[^0-9]);

\s(对于Unicode(str类型)模式,匹配Unicode中的空白字符,包括[\t\n\r\f\v]及其它空白字符,若开启了re.ASCII标志,只匹配[\t\n\r\f\v];对于8位模式(bytes类型),匹配ASCII中定义的空白字符,即[\t\n\r\f\v]);

\S(与\s相反,匹配任何非Unicode中的空白字符,若开启了re.ASCII标志,则相当于匹配[^\t\n\f\r\v]

\w(对于Unicode(str类型)模式,匹配任何以Unicode的单词字符,基本上所有语言字符都可匹配,也包括数字下划线[a-zA-Z0-9],若开启了re.ASCII标志则只匹配[a-zA-Z0-9];对于8位模式(bytes类型),匹配ASCII中定义的字母数字);

\W(与\w相反,匹配任何非Unicode的单词字符,若开启了re.ASCII标志,则相当于[^a-zA-Z0-9]);

 

转义符的特殊情况:

\a \b  \f  \n \r  \t  \u \U  \v  \x  \\

\b(通常用于单词边界,只有在字符类中才表示backspace);

\u\U(只在Unicode模式下才会被识别);

\num(八进制转义是有限制的,如果第1个数字是0,或如果有3个八进制数字,那么就被认为是八进制;其它情况则被认为是子组引用;至于字符串,八进制转义最多只能是3个数字的长度);

 

flags标志位:

ASCII(简写A,使得转义符\w\b\d\s只能匹配ASCII字符);

DOTALL(简写S,使得.点匹配任何符号,包括换行符,无敌状态);

IGNORECASE(简写I,匹配时不区分大小写);

LOCALE(简写L,支持当前的语言设置);

MULTILINE(简写M,多行匹配(要查找的内容为多行),影响^$);

VERBOSE(简写X,启用详细的正则表达式,正则的书写为多行时);

 

编译正则表达式:

re模块提供了一个正则表达式引擎的接口,可将REstring编译成对象并用它们进行匹配;

如果要重复的使用某个正则表达式,可将正则表达式编译成模式对象,使用re.compile()来编译;

若只需查找或匹配一次使用模块级别的方法,如re.findall(r'[A-Z]','string');若要多次使用正则表达式,在循环情况下,就要先编译再进行调用,这样使用更方便;

In [6]: help(re.compile)

compile(pattern, flags=0)

   Compile a regular expression pattern, returning a pattern object.

In [2]: p=re.compile(r'[A-Z]')

In [3]: type(p)

Out[3]: _sre.SRE_Pattern

In [4]: p.search('I love FishC.com')

Out[4]: <_sre.SRE_Match at 0x2bd91d0>

In [5]: p.findall('I love FishC.com')

Out[5]: ['I', 'F', 'C']

In [8]: p.<TAB>

p.findall     p.flags       p.groups      p.pattern     p.search      p.sub        

p.finditer    p.groupindex  p.match      p.scanner     p.split       p.subn 

In [8]: help(p.findall)   #(找到RE匹配的所有子串,将它们作为列表返回)

findall(string[, pos[,endpos]]) --> list.

In [10]: print p   #(编译后的正则表达式为对象,可在该对象上应用以上方法,()中直接跟要查找的字符串)

<_sre.SRE_Pattern object at0x268cc10>

In [23]: help(p.finditer)   #(找到RE匹配的所有子串,将它们作为迭代器返回)

finditer(string[, pos[,endpos]]) --> iterator.

In [24]: help(p.match)   #(决定RE是否在刚开始的位置匹配)

match(string[, pos[,endpos]]) --> match object or None.

In [25]: help(p.search)   #(扫描字符串,找到这个RE匹配的位置)

search(string[, pos[,endpos]]) --> match object or None.

注:

p.match()p.search()若没匹配到,它们将返回None,否则返回MatchObject的实例(内存地址),MatchObject所支持的方法:group()start()end()span();在实际程序中,最常见的做法是将MatchObject保存在一个变量里,检查是否为None

In [6]: m=p.match('I love FishC.com!')

In [7]: m.<TAB> 

m.end       m.expand     m.groupdict  m.lastgroup m.pos        m.regs       m.start     

m.endpos    m.group      m.groups     m.lastindex  m.re        m.span       m.string 

In [7]: help(m.group)   #(返回被RE匹配的字符串)

group([group1, ...]) -> str or tuple.

   Return subgroup(s) of the match by indices or names.

   For 0 returns the entire match.

In [8]: help(m.start)   #(返回匹配刚开始的位置)

start([group=0]) -> int.

   Return index of the start of the substring matched by group.

In [9]: help(m.end)   #(返回匹配结束的位置)

end([group=0]) -> int.

   Return index of the end of the substring matched by group.

In [10]: help(m.span)   #(返回一个元组包含匹配开始、结束的位置)

span([group]) -> tuple.

   For MatchObject m, return the 2-tuple (m.start(group), m.end(group)).

In [20]: p=re.compile(r'[a-z]')

In [21]: m=p.search('I love FishC')

In [22]: m.group()

Out[22]: 'l'

 

举例(match()search()方法在程序中常用来判断是否匹配到):

[root@localhost ~]# vim re_match.py

------------------script start-------------

#!/usr/bin/python2.7

#filename:re_match.py

import re

p=re.compile(r'[a-z]')

m=p.match('string123')

if m:

       print 'Match found:',m.group()

else:

       print 'No match'

--------------script end----------------

[root@localhost ~]# python2.7 re_match.py

Match found: s

 

举例:

In [8]: str1='I love FishC.com!'

In [10]: re.search(r'FishC',str1)

Out[10]: <_sre.SRE_Match at0x24fa648>

In [11]: re.findall(r'FishC',str1)  

Out[11]: ['FishC']

In [12]: re.findall(r'.',str1)   #(点号表示换行符以外的任意字符,此处全部匹配到)

Out[12]:

['I',

 ' ',

 'l',

 'o',

 'v',

 'e',

 ' ',

 'F',

 'i',

 's',

 'h',

 'C',

 '.',

 'c',

 'o',

 'm',

 '!']

In [13]: re.findall(r'Fish.',str1)

Out[13]: ['FishC']

In [14]: re.findall(r'Fish\.',str1)   #(加入转义符表示元字符本身,此处未匹配到内容)

Out[14]: []

In [15]: re.findall(r'\d','I loveFishC.com!123')   #\d表示单个任意数字)

Out[15]: ['1', '2', '3']

In [16]: re.findall(r'\d\d\d','123 456FishC')

Out[16]: ['123', '456']

In [18]: re.findall(r'[aeiou]','string')   #[]创建字符类,仅匹配中括号中的一个字符)

Out[18]: ['i']

In [19]: re.findall(r'[A-Z]','String')   #(正则中默认是打开大小写敏感的,可用re.IGNORECASE取消)

Out[19]: ['S']

In [20]: re.findall(r'[a-z]','Hello')

Out[20]: ['e', 'l', 'l', 'o']

In [21]:re.findall(r'[a-z]','HELLO',re.IGNORECASE)

Out[21]: ['H', 'E', 'L', 'L', 'O']

In [22]: re.findall(r'ab{3}c','abbbc')   #{NUM}表示重复的次数)

Out[22]: ['abbbc']

In [23]: re.findall(r'ab{3,10}c','abbbbc')

Out[23]: ['abbbbc']

In [24]: re.findall(r'[0-255]','188')   #(注意此处表示012后面跟两个5

Out[24]: ['1']

In [25]: re.findall(r'[0-255]','1155')

Out[25]: ['1', '1', '5', '5']

In [28]:re.findall(r'(?<![\.\d])(?:\d{1,3}\.){3}\d{1,3}(?![\.\d])','192.168.1.1')   #(匹配IP

Out[28]: ['192.168.1.1']

In [29]:re.findall(r'(?<![\.\d])(?:\d{1,3}\.){3}\d{1,3}(?![\.\d])','192.168.23.125')

Out[29]: ['192.168.23.125']

In [30]:re.findall(r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$','127.0.0.1')

Out[30]: ['127.0.0.1']

In [31]: re.findall(r'Fish(C|D)','www.FishC.com')   #(若使用分组(),默认仅显示匹配到的分组内的内容)

Out[31]: ['C']

In [33]: re.findall(r'^FishC','FishC.com')

Out[33]: ['FishC']

In [34]: re.findall(r'FishC$','I loveFishC')

Out[34]: ['FishC']

In [35]:re.findall(r'(FishC)\1','FishCFishC')  #\后跟序号1,引用序号对应的子组所匹配的字符串,子组的序号从1开始计算)

Out[35]: ['FishC']

In [36]: re.findall(r'\.','FishC.com')   #\.表示点本身)

Out[36]: ['.']

In [37]: re.findall(r'[.]','FishC.com')   #(中括号中的元字符代表其本身,不具备元字符的功能)

Out[37]: ['.']

In [38]: re.findall(r'[\n]','FishC.com\n')   #(匹配回车符)

Out[38]: ['\n']

In [39]: re.findall(r'[^a-z]','FishC.com')   #[]中的^是取反,若取反^只能放在中括号的最前面)

Out[39]: ['F', 'C', '.']

In [40]: re.findall(r'FishC{3}','FishCCCC')   #{NUM}仅对前面的单个字符做重复)

Out[40]: ['FishCCC']

In [41]: re.findall(r'(FishC){2,5}','FishCFishCFishC')

Out[41]: ['FishC']

In [42]:re.findall(r'<.+>','<html><title>I loveFishC</title></html>')   #(正则默认是贪婪模式,在条件符合时尽可能多的匹配,可在.+后加上?进入非贪婪模式)

Out[42]: ['<html><title>I loveFishC</title></html>']

In [43]:re.findall(r'<.+?>','<html><title>I love FishC</title></html>')

Out[43]: ['<html>', '<title>','</title>', '</html>']

In [46]: re.findall(r'\bFishC\b','FishC.comFishC_com FishC')   #(匹配单词边界,下划线也是单词的一部分)

Out[46]: ['FishC', 'FishC']

In [48]: re.findall(r'py\B','python py2py3')   #(匹配非单词边界)

Out[48]: ['py', 'py', 'py']

In [49]: re.findall(r'py\B','py py. py!')

Out[49]: []

In [18]:re.findall(r'^010-?\d{8}','010-12345678')

Out[18]: ['010-12345678']

In [19]: re.findall(r'ab+','abbbbc')    #(贪婪模式)

Out[19]: ['abbbb']

In [20]: re.findall(r'ab+?','abbbbbc')    #(非贪婪模式,最小匹配)

Out[20]: ['ab']

In [23]: re.findall(r'csvt.net','csvt.net')

Out[23]: ['csvt.net']

In [24]:re.findall(r'csvt.net','csvt\nnet')

Out[24]: []

In [25]:re.findall(r'csvt.net','csvt\nnet',re.S)  #(开启了re.DOTALL使得点号可顶替任何字符,包括换行符)

Out[25]: ['csvt\nnet']

举例(标志位re.Mre.MULTILINE):

In [2]: s='''

  ...: hello csvt

  ...: csvt hello

  ...: hello csvt

  ...: csvt hello

  ...: '''

In [3]: re.findall(r'^csvt',s)   #(不开re.M标志位的情况下,是无法匹配多行的)

Out[3]: []

In [4]: re.findall(r'^csvt',s,re.M)

Out[4]: ['csvt', 'csvt']

举例(标志位re.Xre.VERBOSE,用于正则的书写为多行时):

In [5]: tel=r'''

  ...: \d{3,4}

  ...: -?

  ...: \d{8}

  ...: '''

 

In [6]: re.findall(tel,'010-12345678')

Out[6]: []

In [7]: re.findall(tel,'010-12345678',re.X)

Out[7]: ['010-12345678']

举例(分组):

In [8]:re.findall(r'\w{3,}@\w+(\.com|\.cn)','zzz@csvt.com')   #(当有分组时findall会优先返回查找到的分组中的内容)

Out[8]: ['.com']

In [9]: re.findall(r'\w{3,}@\w+(\.com|\.cn)','zzz@csvt.cn')

Out[9]: ['.cn']

In [10]:re.findall(r'\w{3,}@\w+(\.com|\.cn)','zzz@csvt.org')

Out[10]: []

In [11]:re.match(r'\w+@\w+(\.com|\.cn)','jowin@163.com')

Out[11]: <_sre.SRE_Match at0x22e8198>

In [12]: s='''

   ....: aaa srt hello src=csvt

  ....: yes

  ....: hello src=python hello

  ....: '''

In [13]: re.findall(r'hello src=(.+)',s)   #(查找指定内容中包含hello src=……的内容)

Out[13]: ['csvt', 'python hello']

 


str字符串替换:

In [5]: help(str.replace)

S.replace(old, new[,count]) -> string

In [6]: s='hello csvt'

In [7]: s.replace('csvt','python')

Out[7]: 'hello python'

In [9]: s.replace(r'c..t','python')   #(字符串所支持的方法和操作是不支持re的)

Out[9]: 'hello csvt'

 

 

re.sub()re.subn()(正则中的替换):

In [10]: help(re.sub)

sub(pattern, repl,string, count=0, flags=0)

In [11]: help(re.subn)

subn(pattern, repl,string, count=0, flags=0)

In [13]: re.sub(r'c..t','csvt','caat cvvt ccct')

Out[13]: 'csvt csvt csvt'

In [14]: re.subn(r'c..t','csvt','caat cvvt ccct')   #subn不仅打印替换的内容,还打印替换了几次)

Out[14]: ('csvt csvt csvt', 3)

 

 

str.split()

In [16]: help(str.split)

S.split([sep[,maxsplit]]) -> list of strings

In [17]: ip='192.168.23.128'

In [18]: ip.split('.')

Out[18]: ['192', '168', '23', '128']

 

re.split

In [15]: help(re.split)

split(pattern, string,maxsplit=0, flags=0)

In [20]: re.split(r'[\+\-\*]','1+2-3*4')   #(中括号中的元字符将失去本身的意义,但此例中-表示范围,在不加转义符的前提下,要么-不能放在两个元字符中间,要么将-放到最后即可)

Out[20]: ['1', '2', '3', '4']

In [21]: re.split(r'[+*]','1+2*3')

Out[21]: ['1', '2', '3']

In [22]: re.split(r'[+*-]','1+2-3*4')

Out[22]: ['1', '2', '3', '4']



 

MySQLdb模块(软件包名是MySQL-python-1.2.5.tar.gz):

[root@localhost ~]# yum -y installpython-devel mysql-devel zlib-devel openssl-devel gcc

[root@localhost setuptools-19.6.1]#python2.7 setup.py install   (要先安装setuptools-19.6.1.tar.gz这个模块)

[root@localhost MySQL-python-1.2.5]#python2.7 setup.py install

……

Installed/usr/local/python2.7/lib/python2.7/site-packages/MySQL_python-1.2.5-py2.7-linux-x86_64.egg

Processing dependencies forMySQL-python==1.2.5

Finished processing dependencies forMySQL-python==1.2.5

 

注:通过pythonMySQLdb模块与mysql交互,三步骤:

1)创建连接、创建游标,conn=MySQLdb.connect(user='root',password='secret','host'='IP')cur=conn.cursor()

2)选择库、发送执行指令进行增删改查操作,conn.select_db('DB')cur.execute('mysqlcommand')

3)关闭,cur.close()conn.close()

注:增删改查只用传递一次即可,而查询要两次(先用cur.execute('select * from table')传送再用cur.fetchone()查看记录),fetchone()每次查看一条记录并有指针的移动,可用cur.scroll(0,'absolute')将指针移到刚开始处;

注:查询也可合并cur.fetchmany(cur.execute('select * form table')

 

In [1]: import MySQLdb

In [2]: MySQLdb.<TAB>

MySQLdb.BINARY                                  MySQLdb.Timestamp

MySQLdb.Binary                                  MySQLdb.TimestampFromTicks

MySQLdb.Connect                                  MySQLdb.Warning

MySQLdb.Connection                               MySQLdb.apilevel

MySQLdb.DATE                                     MySQLdb.connect

MySQLdb.DATETIME                                MySQLdb.connection

MySQLdb.DBAPISet                                MySQLdb.constants

MySQLdb.DataError                                MySQLdb.debug

MySQLdb.DatabaseError                            MySQLdb.escape

MySQLdb.Date                                    MySQLdb.escape_dict

MySQLdb.DateFromTicks                           MySQLdb.escape_sequence

MySQLdb.Error                                   MySQLdb.escape_string

MySQLdb.FIELD_TYPE                              MySQLdb.get_client_info

MySQLdb.IntegrityError                           MySQLdb.paramstyle

MySQLdb.InterfaceError                           MySQLdb.release

MySQLdb.InternalError                            MySQLdb.result

MySQLdb.MySQLError                              MySQLdb.server_end

MySQLdb.NULL                                     MySQLdb.server_init

MySQLdb.NUMBER                                  MySQLdb.string_literal

MySQLdb.NotSupportedError                       MySQLdb.test_DBAPISet_set_equality

MySQLdb.OperationalError                        MySQLdb.test_DBAPISet_set_equality_membership

MySQLdb.ProgrammingError                        MySQLdb.test_DBAPISet_set_inequality

MySQLdb.ROWID                                   MySQLdb.test_DBAPISet_set_inequality_membership

MySQLdb.STRING                                  MySQLdb.thread_safe

MySQLdb.TIME                                    MySQLdb.threadsafety

MySQLdb.TIMESTAMP                                MySQLdb.times

MySQLdb.Time                                     MySQLdb.version_info

MySQLdb.TimeFromTicks                           

In [2]: help(MySQLdb.connect)

Connect(*args, **kwargs)

   Factory function for connections.Connection.

In [5]: conn.<TAB>

conn.DataError               conn.close                  conn.get_host_info           conn.set_character_set

conn.DatabaseError           conn.commit                  conn.get_proto_info          conn.set_server_option

conn.Error                   conn.converter               conn.get_server_info         conn.set_sql_mode

conn.IntegrityError          conn.cursor                  conn.info                    conn.show_warnings

conn.InterfaceError          conn.cursorclass             conn.insert_id               conn.shutdown

conn.InternalError           conn.default_cursor          conn.kill                    conn.sqlstate

conn.NotSupportedError       conn.dump_debug_info         conn.literal                 conn.stat

conn.OperationalError        conn.encoders                conn.messages                conn.store_result

conn.ProgrammingError        conn.errno                   conn.next_result             conn.string_decoder

conn.Warning                 conn.error                   conn.open                    conn.string_literal

conn.affected_rows           conn.errorhandler            conn.ping                    conn.thread_id

conn.autocommit              conn.escape                  conn.port                    conn.unicode_literal

conn.begin                   conn.escape_string           conn.query                   conn.use_result

conn.change_user             conn.field_count             conn.rollback                conn.warning_count

conn.character_set_name      conn.get_autocommit          conn.select_db              

conn.client_flag             conn.get_character_set_info  conn.server_capabilities 

In [5]: help(conn.cursor)

cursor(self,cursorclass=None) method of MySQLdb.connections.Connection instance

   Create a cursor on which queries may be performed. The

   optional cursorclass parameter is used to create the

   Cursor. By default, self.cursorclass=cursors.Cursor is

   used.

In [6]: help(conn.select_db)

select_db(...)

   Causes the database specified by db to become the default

   (current) database on the connection specified by mysql. In subsequent

   queries, this database is the default for table references that do not

   include an explicit database specifier.

In [8]: cur.<TAB>

cur.DataError          cur.NotSupportedError  cur.connection         cur.fetchmany          cur.scroll

cur.DatabaseError      cur.OperationalError   cur.description        cur.fetchone           cur.setinputsizes

cur.Error              cur.ProgrammingError   cur.description_flags  cur.lastrowid          cur.setoutputsizes

cur.IntegrityError     cur.Warning            cur.errorhandler       cur.messages          

cur.InterfaceError     cur.arraysize          cur.execute            cur.nextset           

cur.InternalError      cur.callproc           cur.executemany        cur.rowcount          

cur.MySQLError         cur.close              cur.fetchall           cur.rownumber   

In [32]: help(cur.execute)

execute(self, query,args=None) method of MySQLdb.cursors.Cursor instance

   Execute a query.

In [33]: help(cur.executemany)

executemany(self, query,args) method of MySQLdb.cursors.Cursor instance

   Execute a multi-row query.

In [34]: help(cur.fetchone)

fetchone(self) method ofMySQLdb.cursors.Cursor instance

   Fetches a single row from the cursor. None indicates that

    no more rows are available.

In [35]: help(cur.fetchmany)

fetchmany(self,size=None) method of MySQLdb.cursors.Cursor instance

   Fetch up to size rows from the cursor. Result set may be smaller

   than size. If size is not defined, cursor.arraysize is used.

In [36]: help(cur.scroll)

scroll(self, value,mode='relative') method of MySQLdb.cursors.Cursor instance

   Scroll the cursor in the result set to a new position according

   to mode.

 

 

In [4]:conn=MySQLdb.connect(user='root',passwd='chai',host='127.0.0.1')

In [7]: cur=conn.cursor()

 

In [8]: conn.select_db('webgame')

In [27]: cur.execute('insert into temp1(accountid,nickname,serverid) value (1,"jowin",14115)')

Out[27]: 1L

In [28]: sqli='insert into temp1(accountid,nickname,serverid) values (%s,%s,%s)'

In [29]: cur.execute(sqli,(2,'snow',14116))

Out[29]: 1L

In [31]:cur.executemany(sqli,[(3,'maisie',14117),(4,'emilia',14118),(5,'lsaac',14119)])

Out[31]: 3L

In [37]: cur.execute('select * from temp1')

Out[37]: 5L

In [38]: cur.fetchone()   #(每查询一条有指针的移动)

Out[38]: (1L, 'jowin', 14115L)

In [39]: cur.fetchone()

Out[39]: (2L, 'snow', 14116L)

In [40]: cur.fetchone()

Out[40]: (3L, 'maisie', 14117L)

In [41]: cur.fetchone()

Out[41]: (4L, 'emilia', 14118L)

In [42]: cur.fetchone()

Out[42]: (5L, 'lsaac', 14119L)

In [43]: cur.fetchone()

In [44]: cur.scroll(0,'absolute')   #(将指针移到开始位置)

In [45]: cur.fetchmany(5)

Out[45]:

((1L, 'jowin', 14115L),

 (2L,'snow', 14116L),

 (3L,'maisie', 14117L),

 (4L,'emilia', 14118L),

 (5L,'lsaac', 14119L))

In [47]: cur.fetchmany(cur.execute('select* from temp1'))   #(查询两步合为一步)

Out[47]:

((1L, 'jowin', 14115L),

 (2L,'snow', 14116L),

 (3L,'maisie', 14117L),

 (4L,'emilia', 14118L),

 (5L,'lsaac', 14119L))

 

In [48]: cur.close()

In [49]: conn.close()



本文转自 chaijowin 51CTO博客,原文链接:http://blog.51cto.com/jowin/1791578,如需转载请自行联系原作者

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Python re 正则表达式 数据匹配提取 基本使用
模式字符串使用特殊的语法来表示一个正则表达式: 字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。 多数字母和数字前加一个反斜杠时会拥有不同的含义。 标点符号只有被转义时才匹配自身,否则它们表示特殊的含义。 反斜杠本身需要使用反斜杠转义。 正则表达式通常都包含反斜杠"\\"以及小括号"\(\)",模式元素(如 r'\t',等价于 '\\t')匹配相应的特殊字符。
0 0
python——正则表达式(re模块)
python——正则表达式(re模块)
0 0
python re模块正则表达式详解(2)
python re模块正则表达式详解(2)
0 0
python re模块正则表达式详解(1)
python re模块正则表达式详解(1)
0 0
re库:Python中正则表达式的处理与应用(二)
re库:Python中正则表达式的处理与应用(二)
0 0
re库:Python中正则表达式的处理与应用(一)
re库:Python中正则表达式的处理与应用(一)
0 0
Python基础——re表达式中re.sub()的用法
Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。
0 0
Python 正则匹配:re库的使用
正则表达式是一种描绘字符串的匹配模式,可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。 学会了正则表达式,我们就可以定向查找网页中的某些内容了,快去结合爬虫练练手吧。
0 0
【Python基础篇013】第壹章模块大全之《re模块》
【Python基础篇013】第壹章模块大全之《re模块》
0 0
Python编程:re正则库基本使用
Python编程:re正则库基本使用
0 0
文章
问答
文章排行榜
最热
最新
相关电子书
更多
给运维工程师的Python实战课
立即下载
Python 脚本速查手册
立即下载
ACE 区域技术发展峰会:Flink Python Table API入门及实践
立即下载