runoob_python_1

Posted countryboy666

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了runoob_python_1相关的知识,希望对你有一定的参考价值。

#-*-coding:utf-8-*-
‘‘‘
compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。

re.match 尝试从字符串的起始位置匹配一个模式
group(num) groups() 匹配对象函数来获取匹配表达式。



import re

print(re.match(‘www‘,"www.baidu.com").span()) # 在起始位置匹配


line = ‘cat are smarter than dogs‘
# .* 表示任意匹配除换行符(\n\r)之外的任何单个或多个字符
# 匹配括号内的表达式,也表示一个组
# re.match只匹配字符串的开始,如果字符串开始不符合正则表达式,
matchobj = re.match(r‘(.*) are (.*?) .*‘,line,re.M|re.I)
if matchobj:
print(matchobj.group())
print(matchobj.group(2))
else:
print("no match")
#re.search 扫描整个字符串并返回第一个成功的匹配。

#标志位,用于控制正则表达式的匹配方式
print(re.search(‘bai‘,‘wwww.baidu.com‘).span(),re.M|re.I)# (5,8)
print(re.search(‘du‘,‘wwww.baidu.com‘)) #<_sre.SRE_Match object; span=(8, 10), match=‘du‘>




import re

line = ‘cat are smarter than dogs‘
matchobj = re.search(r‘dog‘,line,re.M|re.I)
print(matchobj.group(),matchobj.span()) #group() 返回匹配的字符串,span()返回位置

#检索和替换
re.sub用于替换字符串中的匹配项。
re.sub(pattern, repl, string, count=0, flags=0)

pattern: 正则中的模式字符串。
repl: 替换的字符串,也可为一个函数。
string: 要被查找替换的原始字符串。
count: 模式匹配后替换的最大次数,默认
0
表示替换所有的匹配。
flags: 编译时用的匹配模式,数字形式。



import re
phone = "2004-959-559 # 这是一个电话号码"
# 删除注释 phone num 2004-959-559
num = re.sub(r‘#.*$‘,‘‘,phone)
print("phone num",num)
# 移除非数字的内容 2004959559
num = re.sub(r‘\D‘,‘‘,phone)
print(num)
#repl 参数是一个函数
# 将匹配的数字乘于 2
def double(matched):
value = int(matched.group(‘value‘))
return str(value*2)
s = ‘A23G4HFD567‘

print(re.sub(‘(?P<value>\d+)‘,double,s))
#compile 函数用于编译正则表达式,生成一个正则表达式( Pattern )对象,供 match() search() 这两个函数使用。
#re.complie(pattern,flag)

pattern: 一个字符串形式的正则表达式
flags
可选,表示匹配模式,比如忽略大小写,多行模式等,具体参数为:
re.I 忽略大小写
re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
re.M 多行模式
re.S 即为 ‘ . ‘ 并且包括换行符在内的任意字符(‘ . ‘ 不包括换行符)
re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
re.X 为了增加可读性,忽略空格和
‘ # ‘ 后面的注释



import re

parttern = re.compile(r‘\d+‘)

m = parttern.match(‘onetwo12‘)
print(m)
m=parttern.match(‘onetwo12‘,6)
print(m) # m is <_sre.SRE_Match object; span=(6, 8), match=‘12‘>
print(m.span(0))
#匹配以字母开头的单词
parttern = re.compile(r‘([a-z]+) ([a-z]+)‘,re.I)
m = parttern.match(‘Hello world wide wed‘)

print(m.span())

#findall在字符串中找到正则表达式所匹配的所有子串,并返回一个列表


parttern = re.compile(r‘\d+‘)
result1= parttern.findall(‘runoob 123 google 246‘)
result2 = parttern.findall(r‘run88oob234google456‘,6,10)
#start stop
print(result1)
print(result2)
#[‘123‘, ‘246‘] [‘23‘]

# re.finditer 在字符串中找到正则表达式所匹配的所有子串,并把它们作为一个迭代器返回。

it = re.finditer(r‘\d+‘,‘12ab34cd56ef‘)
print(type(it))
for match in it:
print(match) #<_sre.SRE_Match object; span=(0, 2), match=‘12‘>
print(match.group())


#re.split 方法按照能够匹配的子串将字符串分割后返回列表
#加括号逗号也被单独分割出来 不加括号只分割单词
m=re.split(‘\W+‘,‘runoob, bookmark, hello‘)
m=re.split(‘(\W+)‘,‘ runoob, bookmark, hello‘,2)#分隔次数,maxsplit=1 分隔一次,默认为 0,不限制次数。
# 匹配括号内的表达式,也表示一个组
print(m)



re.RegexObject

re.compile() 返回 RegexObject 对象。
re.MatchObject

group() 返回被 RE 匹配的字符串。

start() 返回匹配开始的位置
end() 返回匹配结束的位置
span() 返回一个元组包含匹配 (开始,结束) 的位置 re.RegexObject

re.compile() 返回 RegexObject 对象。
re.MatchObject

group() 返回被 RE 匹配的字符串。

start() 返回匹配开始的位置
end() 返回匹配结束的位置
span() 返回一个元组包含匹配 (开始,结束) 的位置



[...] 用来表示一组字符,单独列出:[amk] 匹配 ‘a‘‘m‘‘k‘

re n 匹配n个前面表达式。例如,"o2"不能匹配"Bob"中的"o",但是能匹配"food"中的两个o
e n, 精确匹配n个前面表达式。例如,"o2,"不能匹配"Bob"中的"o",但能匹配"foooood"中的所有o"o1,"等价于"o+""o0,"则等价于"o*"
re n, m 匹配 n m 次由前面的正则表达式定义的片段,贪婪方式

1[ ]:方括号。匹配需要的字符集合,如[1-3][123]都是匹配12或者3

2^:脱字符号。方括号中加入脱字符号,就是匹配未列出的所有其他字符,如[^a]匹配除a以外的所有其他字符。

3\:反斜杠。和python字符串使用规则一样,可以匹配特殊字符本身,如\d表示匹配09的任意一个数字字符,而\\d则表示匹配\d本身。

4*:星号。匹配前一个字符0n次,如pytho*n可以匹配pythnpytoonpythooooon等。还有其它匹配重复字符的如?、+m,n,其中n,m可以灵活使用,它表示匹配n次到m次。

\b 可以匹配的边界包括单词和特殊字符边界
(?<name>exp) 匹配 exp,并捕获文本到名称为 name 的组里,也可以写成 (?‘name‘exp)

但是在Python中,为 (?P<name>exp)


s= ‘2017-11-27‘
m=re.sub(‘(\d4)-(\d2)-(\d2)‘,r‘\2/\3/\1‘,s)
print(m)


parttern=re.compile(r‘(?P<here>[a-z]+) ([a-z]+)‘,re.I)

m = parttern.match(‘Hello world word helo‘)

print(m.group(‘here‘))
print(m.group())

ip =‘192.168.1.1‘
trueIp =re.search(r‘(([01]0,1\d0,1\d|2[0-4]\d|25[0-5])\.)3([01]0,1\d0,1\d|2[0-4]\d|25[0-5])‘,ip)





CGI(Common Gateway Interface),通用网关接口,它是一段程序,运行在服务器上如:HTTP服务器,提供同客户端html页面的接口





print ("Content-type:text/html")
print () # 空行,告诉服务器结束头部
print (‘<html>‘)
print (‘<head>‘)
print (‘<meta charset="utf-8">‘)
print (‘<title>Hello Word - 我的第一个 CGI 程序!</title>‘)
print (‘</head>‘)
print (‘<body>‘)
print (‘<h2>Hello Word! 我是来自菜鸟教程的第一CGI程序</h2>‘)
print (‘</body>‘)
print (‘</html>‘)

import os
import sys
print("\n python path", sys.path)
import pydoc

import socket
import sys



from Pymysql import pymysql

# 打开数据库连接
db = pymysql.connect("localhost", "testuser", "test123", "TESTDB")

# 使用 cursor() 方法创建一个游标对象 cursor
cursor = db.cursor()

# 使用 execute() 方法执行 SQL 查询
cursor.execute("SELECT VERSION()")

# 使用 fetchone() 方法获取单条数据.
data = cursor.fetchone()

print("Database version : %s " % data)

# 关闭数据库连接
db.close()


import sys
print(sys.path)
sys.path.append(‘/home/selen/PyMySQL‘)
print(sys.path)


import pymysql

# 打开数据库连接
db = pymysql.connect("localhost", "testuser", "test123", "TESTDB")

# 使用 cursor() 方法创建一个游标对象 cursor
cursor = db.cursor()

# 使用 execute() 方法执行 SQL 查询
cursor.execute("SELECT VERSION()")

# 使用 fetchone() 方法获取单条数据.
data = cursor.fetchone()

print("Database version : %s " % data)

# 关闭数据库连接
db.close()

#!/usr/bin/python
导入包
import mysql.connector
打开数据库
mydb = mysql.connector.connect(
host =‘localhost‘,
user=‘root‘,
passwd=‘123‘)
print(mydb)
定义游标
mycursor = mydb.cursor()
定义执行语句
#mycursor.execute(‘create database runoob_db‘)

mycursor.execute(‘show databases‘)
for x in mycursor:
print(x)


mycursor.execute(‘use runoob_db‘)
#mycursor.execute("create table sites (name varchar(255),url varchar(255))")
mycursor.execute(‘show tables‘)
for x in mycursor:
print(x)

#mycursor.execute("alter table sites add column id int auto_increment primary key")


sql=‘insert into sites (name ,url)values (%s,%s)‘
val = ("runoob",‘http://www.runoob.com‘)
mycursor.execute(sql,val)
mydb.commit()
print(mycursor.rowconut,‘sucess!‘)


mycursor.execute(‘select * from sites‘)

my=mycursor.fetchall() #查看结果
for x in my:
print(my)

my = mycursor.fetchone() #查看一条数据
print(my)



str1 alter table tablename add column id int auto_inrement priment key
str2 insert into tablename values(%s,%s)(.....)
str3 select * from tablename where columnname like ‘%oo%‘
str4 select * from tablename limit 3 offset 1; second record
str5 update tablename set name = ‘‘ where name = ‘‘
str6 drop table if exists tables;



import socket
import sys

serversocket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
host = socket.gethostname()
port = 9999
serversocket.bind((host,port))

serversocket.listen(5)

while True:
clientsocket,addr = serversocket.accept()
print("connect addr: %s"%str(addr))
msg = ‘welcom to runoob‘+‘\r\n‘
clientsocket.send(msg.encode(‘utf-8‘))
clientsocket.close()

# -*-coding:utf-8-*-

import socket
import sys

clientsocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host = socket.gethostname()
port = 9999

clientsocket.connect((host, 9999))
msg = clientsocket.recv(1024)
clientsocket.close()

print(msg.decode(‘utf-8‘))


import smtplib
from email.mime.text import MIMEText
from email.header import Header

sender = ‘[email protected]
receivers = ‘[email protected]

# 三个参数:第一个为文本内容,第二个 plain 设置文本格式,第三个 utf-8 设置编码
message = MIMEText(‘python test‘, ‘plain‘,‘utf-8‘)
print(type(message))
message[‘From‘] = Header(‘selen‘,‘utf-8‘)
message[‘To‘] =Header(‘Test‘,‘utf-8‘)

subject = ‘python test‘
message[‘Subject‘]=Header(subject,‘utf-8‘)


try:
smtObj=smtplib.SMTP(‘localhost‘)
smtObj.sendmail(sender,receivers,message,as_string())
print("send sucess")
except smtplib.SMTPException:
print(‘send error‘)


import _thread
import time
import threading
def print_time(threadName,delay):
count =0
while count <5:
time.sleep(delay)
count+=1
print(‘%s:%s‘%(threadName,time.ctime(time.time())))
try:
_thread.start_new_thread(print_time,(‘thread-1‘,2))
_thread.start_new_thread(print_time,(‘thread-2‘,3))
except:
print(‘error cannot open thread‘)
while 1:
# pass

time.sleep(1)


print(threading.enumerate())
print(threading.activeCount())
print(threading.currentThread())



import threading
import time

class myThread (threading.Thread):
def __init__(self, threadID, name, counter):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.counter = counter
def run(self):
print ("开启线程: " + self.name)
# 获取锁,用于线程同步
threadLock.acquire()
print_time(self.name, self.counter, 3)
# 释放锁,开启下一个线程
threadLock.release()

def print_time(threadName, delay, counter):
while counter:
time.sleep(delay)
print ("%s: %s" % (threadName, time.ctime(time.time())))
counter -= 1

threadLock = threading.Lock()
threads = []

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()

# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)

# 等待所有线程完成
for t in threads:
t.join()
print ("退出主线程")




#我们可以通过直接从 threading.Thread 继承创建一个新的子类,并实例化后调用 start() 方法启动新线程,即它调用了线程的 run() 方法:


import threading
import time

exitflag = 0

class mythread(threading.Thread):
def __init__(self,threadId,name,delay):
threading.Thread.__init__(self)#父类的构造函数
self.threadID = threadId
self.name = name
self.delay = delay

def run(self):
print("thread start:")
print_time(self.name,self.delay,5)
print("thread stop.")
def print_time(threadName,delay,counter):
while counter:
if exitflag:
threadName.exit()
time.sleep(delay)
print(‘%s,%s‘%(threadName,time.ctime(time.time())))
counter -= 1
#create thread
thread1 = mythread(1,‘Thread-1‘,1)
thread2 = mythread(2,‘Thread-2‘,2)
#start thread

thread1.start()
thread2.start()

thread1.join()
thread2.join()

print(‘exit main thread!‘)

多行缩进: tab
多行左移: shift+tab



import threading
import time

class mythread(threading.Thread):
def __init__(self,threadID,name,delay):
#super().__init__(self)
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.delay = delay

def run(self):
print("thread start:")
threadLock.acquire()
print_time(self.name,self.delay,3)
threadLock.release()
def print_time(threadName,delay,counter):
while counter:
time.sleep(delay)
print(‘%s: %s‘%(threadName,time.ctime(time.time())))
counter -=1

# global
threadLock = threading.Lock()

threads =[]

#create thread

thread1 = mythread(1,‘Thread_1‘,1)
thread2 = mythread(2,‘Thread_2‘,2)



threads.append(thread1)
threads.append(thread2)
for t in threads:
t.start()

for t in threads:
t.join()

print(‘main thread exit!‘)


#线程的优先队列


Queue.qsize()
Queue.get([block[,timeout]]) 获得队列
Queue.put(item)
Queue.task_done() 向任务已经完成的队列发送信号
Queue.join() 等待队列为空

简单理解: 先开启一组线程 在创建一个任务队列,每个线程分别从队列中取出任务


import queue
import threading
import time

exitFlag = 0
class myThread(threading.Thread):
def __init__(self,threadID,name,q):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.q = q #queue
def run(self):
print(‘thread start:‘+self.name)
process_data(self.name,self.q)
print(‘thread exit:‘+self.name)

def process_data(threadName,q):
while not exitFlag:
queueLock.acquire()
if not workQueue.empty():
data = q.get()
time.sleep(1)

print(‘%s process %s‘%(threadName,data))
q.put(data)
queueLock.release()
return

else:
queueLock.release()
#time.sleep(2)

threadList = [‘Thread-1‘,‘Thread-2‘,‘Thread-3‘,‘Thread-4‘,‘Thread-5‘,‘Thread-6‘,‘Thread-7‘,‘Thread-8‘,
‘Thread-9‘,‘Thread-10‘,‘Thread-11‘,‘Thread-12‘,‘Thread-13‘,‘Thread-14‘,‘Thread-15‘,‘Thread-16‘]
nameList = [‘One‘,‘Two‘,‘Three‘]#,‘Four‘,‘Five‘,‘Six‘,‘Seven‘,‘eight‘,‘nine‘]
# get thread.lock
queueLock = threading.Lock()
# 任务队列
workQueue = queue.Queue(19)#指明了队列中能存放的数据个数的上限
print(type(workQueue))
threads = [] # 线程列表
threadID = 1
# 创建并开启线程
for tName in threadList:
thread = myThread(threadID,tName,workQueue)
thread.start()
threads.append(thread)
threadID +=1
#资源
queueLock.acquire()
for word in nameList:
workQueue.put(word)
queueLock.release()

#死循环 等待work队列为空#while not workQueue.empty(): # passwhile True: queueLock.acquire() workQueue.put(‘one‘) queueLock.release() time.sleep(3)exitFlag = 1for t in threads: t.join()print(‘main thread exit‘)XML 指可扩展标记语言(eXtensible Markup Language),标准通用标记语言的子集,是一种用于标记电子文件使其具有结构性的标记语言。XML 被设计用来传输和存储数据。SAX 是一种基于事件驱动的API。利用 SAX 解析 XML 文档牵涉到两个部分: 解析器和事件处理器。解析器负责读取 XML 文档,并向事件处理器发送事件,如元素开始跟元素结束事件。import xml.saxclass MoviesHandler(xml.sax.ContentHandler): def __init__(self): self.CurrentData = ‘‘--------start run:-------(‘\r:^3.0f%[->]:2fs)输出格式为居中,占3位,小数点后0位,:.2f,输出有两位小数的浮点数100%[**************************************************->]5.02s----------result---------import timescale = 50print(‘start run:‘.center(scale//2,‘-‘)) #控制输出样式 宽度25//2 即22 单词剧中,两侧填充start = time.perf_counter() #计时for i in range(scale+1): a = ‘*‘ * i b = ‘.‘* (scale-i) c = (i/scale)*100 dur = time.perf_counter()-start print(‘\r:^3.0f%[->]:.2fs‘.format(c,a,b,dur),end = ‘‘) # \r 将光标移到行首 time.sleep(0.1)print(‘\n‘+‘result‘.center(scale//2,‘-‘))‘‘‘import calendarcal = calendar.month(2019,7)cc = calendar.mdaysprint(cc)

以上是关于runoob_python_1的主要内容,如果未能解决你的问题,请参考以下文章

2-1Python列表元组和字典

1python基础语法

1python基础语法

1Python学习CentOS 7 Linux环境搭建

1python??????

1Python初识