python语法部分

2023-01-31 02:01:12 python 语法

https://pypi.python.org/pypi #模块网站

#!/usr/bin/env Python #在环境变量env中找Python
#coding: utf8
1.自动补全
配置环境：创建以下文件
vim /usr/local/bin/tab.py
输入：
import readline
import rlcompleter
readline.parse_and_bind('tab:complete')
存储后设置 SPYTHONSTARTUP
vim ~/.bash_profile 增加以下内容
再最后的export PATH前加
PYTHONSTARTUP=/usr/local/bin/tab.py
export PATH PYTHONSTARTUP
保存后修改可执行权限
chmod +x /usr/local/bin/tab.py
source ~/.bash_profile(马上生效)
验证
echo SPYTHONSTARTUP（有值即可）
补全
#source /python_note/tab.sh 即可

关键字查询： improt keyWord
keyword.kwlist
循环获取 I %s %(ine for line in data)
思路：根据功能分函数，函数先写框架

cmp 比较大小
list('abcd') >>>['a','b','c','d']
int 可转进制 int('10',base=2) base指定进制数
abs 返回绝对值
divmod(10,3) >>>(3,1) 可得商和余
pow 指数运算，即几次方
round 四舍五入 round(5.0/3,2)
hex 16进制数
oct 8进制
bin 2进制
ord ACCII码
chr 转为ACCII编码
range(5) 生成0～5的列表
from random improt randint
randint(1,100) 随机生成一个（1，100）内的数
enumerate 返回元组（下标，元素）用list(enumerate(1,2))
reversed (反转序列) 也可 [::-1]
sorted 排序
string.letters (字母大小写列表)
string.digits (数字列表)
%15s%5s%('name','ager') 格式对齐
%-15s%-5s%('name','ager')左对齐
%s%s%(-10,'name',-5,'ager') *占位 -10和-5
string.centen(48) 居中字符串
string.capitalize() 首字母大写
string.ljust(40,#) 左对齐
string.rjust(40,#)右对齐
string.count('l') 统计l出现次数
string.endswith('o') 是否以O结尾
string.startswith('e') 是否e开头
string.islower 是否小写,有任一大写则返回flase
string.isupper 是否大写,有任一小写则返回flase
string.isdigit 是否数字
string.isacpha 是否字母
string.isalnum 是否数字和字母
string.strip 去除字符串两端的空白，可加参数去除指定
string.strip('!') 去除两端!字符串，不去除中间
string.lstrip() 去除左端空白
string.rstrip() 去除右端空白,
** string.rstrip('\r\n') 去除右端\r,\n,\r\n
string.vpper 小写转大写
string.sqlit('.') 以.切割字符串，返回列表
string.replace('o','a') 把o替换为a
improt subprocess 执行系统命令模块
subprocess.call('ls -l /home',shell=True)
string.Template() 字符串模块
data=f.read().decode('gb1803')
f.write(date.encode('utf8'))

列表切片增加：
alist=[10,11,12,13,'zh','li',30]
alist[5:5]=['ww','zl'] (列表中间插入)
alist=[10,11,12,13,'zh','ww','zl','li',30]
列表删除
del alist[-1] 删除最后一项
alist.pop() 删除最后一项并返回删除项
alist.pop(3) 删除下标3的项
alist.remove(12) 根据值删除，相同值时只删第一个
alist.count(10) 统计10出现次数
alist.extend() 拆分元素增加
alist.index('new') 返回元素的下标，多个时只返回第一个，无则报错
alist.insert(0,200) 向下标0插入200
alist.reverse() 反转列表
alist.sort() 排序，默认升序排列
random.shuffle(alist) 打乱排序
alist.sort(reversed=True) 排序时反转
alist.len() 获取长度
alist.max() 获取最大值
alist.min() 最小值

字符串拼接
str_list=['h','e','o']
'.'.join(str_list) #以.号连接
输出'h.e.o'

多用列表，效率高
字典
adict['name'] 字典访问
for key in adict:
print "%s:%s" %(key,adict[key]) 字典循环
"(name)s:%(age)s"% adict 获取值
adict.pop(key) 弹出健
adict.popitem() 随机弹
adict.setdefault('mail','bobcatudo') 有则不变更
adict.keys() 返回健
adict.values() 返回值
adict.items() 返回健和值
adict.update(bdict) 字典相加

多if 判断多个条件时某些值时用字典
cmds = {'0'：push_it,'1':pop_it,'2':view_it}
choice=raw_input(prompt).strip()[0] #去掉输入的空格并获取第一个值
cmds[choice]() #用字典匹配获取对应的值得调用函数

元组
tuple()
创建单元组时要在后面加,
a=('10',)
元组不可变，但元组中的列表可以变
atuple=(1,[],2)
atuple[1].append(10)
atuple[1].append（20）
结果是 atuple=(1,[10,20],2)

max() 返回最大
mint() 返回最小

alist=['hello','word']
enumerate(alist) 返回函数对象
list(enumerate(alist))

集合：集合可以去重 set(['1','2'])
判断： big=x if x>y else y

生成器表达式：不真正创建列，返回一个生成器，使用时才生成
（expr for iter_var in iterable if (ond_expr)）
print "\r" # \r不换行，后面加，连接。
%c 数字转化为ACCII
%s 先转化为字符串后
%d 整数类型，只留整数
% d 前面留空格兼容负数
%05d 前面空格补0
%+5d 正数前面显示+号
%f 浮点数
%5.3f 宽度为5，小数为3位
%i int
%e 科学计数法
%o 8进制数
%#o 显示前缀

花括号格式化
" {} is {} yesas old".fORMat('bob','23')
推荐用花括号格式化
" {0[0]} is {0[1]} yesas old".format(alist)
第一列左对齐宽度为8，第二列为宽度5左对齐，<左对齐， >有对齐
" {0：8s} is {1:<5d} yesas old".format('bob','23')

字符串模版
ori_txt='HI ${name},I WILL SEE YOU ${day}'
t=string.Template(ori_txt)
t.substitute(name='bob',day='tomorrow')

调用系统命令建议使用 subprocess
subprocess.call('ls /home', shell=True)

字典：{} 花括号，无序。

dict工厂函数br/>dict((['name','bob'],['age','23'],['email','bob@qq.com']))
输出： {'age':23,'name':bob,'email':'bob@qq.com'}

{}.fromkeys(('tom','bob','alice'),7) #值固定为7时可以批量创建
输出：{'bob':7,'alice':7,'tom':7}
adict['key'] 访问字典
adict.pop['key'] 删除字典
del adict['key'] 删除字典
adict.popitem() 随机删除值并返回删除的值
adict.clear 清除字典

adict ={'age':7,'name':'bob'}
'%(name)s:%(age)s' % adict

a=adict.copy() 深复制，值互不影响
clist=alist[:] 列表复制，值互不影响
adict.get('key') 取出值，不存在返回none
adict.get('key',23) 取出值，不存在返回23
adict.get('key','nout found') 取出值，不存在返回not found
adict.setdefault('age',20) 设置值，存在则不改变.
adict.keys() 获取key的列表
adict.items() 获取值和key的列表
adict.values()获取值的列表

bdict={'age':23,'name':'bob','emil':'qq@ww.com'}
{value:key for key,value in bdict.items()} #key和value对换,注意value有相同值时会丢项目

adict.update（bdict）更新字典，可以把bdict合并到adict里

隐藏密码输入
import getpass
getpass.getpass("password")

集合
aset= set ('abc')
bset= set ('cde')
aset & base 等于 set([c]) 交集
aset ｜ base 等于 set([a b c d e]) 交集
aset - bset 等于 set ([a b]) 差补，即a里有，b里没有，可以做2个文件的比较差异。

set.add() 添加成员
set.remove() 移除成员
set.update() 批量添加成员

批量执行命令,判断每一个语句结果
commands = [
'mkdir /tmp/adb',
'echo hello > /tmp/abc/myfile.txt',
'cat /tmp/abc/myfile.txt'
]

def fun0():

def fun1():

def fun2():

func_dict = {0:func0,1:func1,2:func2}

for i in range(len(commands)):
ret_val=subprocess.call(commands[i],shell=True)
if ret_val !=0:
fun_dict[i]()
break

迭代器
myiter= iter('abc')
myiter.next()
到最后会报错

for 循环可以便利所有类型。
生成器表达式,使用时才生成，节省内存
('172.168.1.%s' %s i for i in range(1,255))

文件处理
.readline() #以/n 结束为一行

flush() 立即同步到文件

\r #回车不换行，即在同一行中

os
os.sep # /
os.curdir #.
os.pardir #..
os.linesep #\n
os.mknod('test.txt') #创建空文件
os.symlink('/etc/host','zhuji') #快捷方式
os.chmod('test.txt',0644) #0代表8进制，需写。

cPickle（C语言写的，数度快），Pickle模块存储对象类型，方便取出。
adict={'name':'bob'}
f=open('/tmp.tx','w')
cPickle.dump(adict,f) #保存字典到文本
cPickle.load(f) #读取文件中的数据

错误：
keyboardinterrupt ：用户中断执行
EOFError ：没有内健输入，到达EOF标记，
ioError ：输入输出操作失败

分析可能产生异常的位置再加try
一个try 可以有多个
except 如：
except (keyboardinterrupt,eoferror) #多个错误类型用（）包含
except(valueError)
except valueerror ,e : # e保存错误信息
BaseException 所有异常
keyboardinterrupt #用户中断即ctrl+c 取消
eoferror 没有内健输入即ctrl+d
IOError 输入/输出操作失败 ,打开不存在的文件
try：
except:
else: #没报错才执行
finally: #都执行

with 可以简化代码
如：
with open('/etc/fstab') as fs:
print fs.readline()
不必用fs.clock 关闭邮件

定义异常
if not 0 <age<150:
raise ValueError , "age out of rang" #必须为已知异常
断言异常
assert 0<age<150 ,"age out of rang" #不在0和150之间，就弹异常

fun()
b=fun #等于b引用fun的空间

def fun (age,name='bob') #默认参数=需放后面
print '%s:%s' (name,age)

函数参数组
def get_args(*arge)
print args

get_args(10,20,30)

def get_kwargs(**kwargs): #字典接受数据
print jiejiw
get_kwargs(name='jj',age=23)

info=['bob',23]
get_info(*info) #代表传入列表的2个参数

info_dict={'name':'bob','aee':34}
get_info(**info_dict) #拆开字典，传入值

choice('+-') 随机选择一项

匿名函数
a= lambda x,y:x+y #定义匿名函数
a(20,30)

字典使用匿名函数
mcds={'+': lambda x,y:x+y,'-':lambda x,y:x-y}

num_list=[randint(1,100) for i in range(10)]
filter(函数，序列) ，函数或许序列的作为参数，函数结果为真保留，为假过滤
print filter(lambda x:x%2,num_list)

map(lambda x:x*2,num_list) #获取序列的值
reduce(lambda x,y:x+y,num_list) #统计序列中的和，将第一个序列和第二个相加，结果在和第三个相加

vim 自动缩进
set ai

时间
data=time.strftime("%Y-%m-%d")

检查文件
md5sum

global #定义全局变量

偏函数
def add(x,y):
return x+y

import functools
add10=functools.partial(add,10) #可以固定X值的模式,第一个参数时函数，第二个参数没指定y=10时，按顺序赋值

add10(3) #等于13

递归

例子：排序，弹出列表最后一个值和列表每项比较，小的放小列表，大的放大列表，最后放回小+弹出的值+大，如果列表为空或1时，返回列表
def sou(alist):
if len(alist) == 0 or len(alist) == 1:
return alist
num = alist.pop()
l = []
m = []

for i in alist:
    if i < num:
        l.append(i)
    else:
        m.append(i)

return sou(l) + [num] + sou(m)

if name == 'main':
alist = [random.randint(1, 100) for i in range(10)]
print alist
print sou(alist)

闭包
若内部变量想在内部的内部可以使用，则需为可变对象

def count(start=0):
count=[start]
def incr():
counter[0]+=1
return counter[0]
return incr #闭包返回的是函数
if name=='main':
a=count()
b=count(10)
print a()
print a()
print b()

装饰器

mport time
def deco(fun):
def timeit():
start=time.time()
ret_val=fun()
end=time.time()
return ret_val,end-start
return timeit #放回函数
@deco #装饰器，将loop当deco的参数运行
def loop():
result=[]
for i in range(1,11):
result.append(i)
time.sleep(0.3)
return result

if name == 'main':
print loop()

hashlib 模块,作文件校验。
m=hashlib.md5('hello world!')
m.hexdigest()

tarfile 直接访问tar文件

tar=tarfile.open('2.tar.gz','w:gz') #创建tar文件
tar.add('day01') #压缩文件
tar.close()

tar=tarfile.open('day01.tar.gz','r:') #自动识别压缩方式
tar.extractall('/tmp/') #指定解压位置

os.walk 获取文件夹下文件列表
for path,foler,files in os.walk('/etc/')
for each_file in files:
os.path.join(path,each_file)

testcase/增量备份.py

class ClassName(object): #object 是基类或父类
count=0

ClassName.count #引用类

mc=ClassName()
mc.count

mc.name='tom'

mc.dist
name:tom 只显示实例的属性

构造器函数
init 调用类时，先执行

class MyClass(object):
def init(self,name): #绑定方法，需先实例化才能调用，self是变量名，可自己设，如下a=..
self.name=name #实例的属性,外部需调用此属性时，要绑定此属性
def display_name(self):
print name #显示bob
if name=='main':
a=MyClass('bob') #实例对象化对象时，会把实例对象传给self, 即a给self，因此只传一个参数即可
print a.name # 显示bob
a.display_name()
b=MyClass('alice')
b.display_name()

绑定方法
class Hotel(object):
def init(self,room,cf=1.0,bf=15):
self.room=room
self.cf=cf
self.bf=bf
def calc_all(self,days=1):
return (self.roomself.cf+self.bf) days
if name == 'main':
stroom=Hotel(200)
print stroom.calc_all()
print stroom.calc_all(2)

bigroom=Hotel(300)
print stroom.calc_all()
print stroom.calc_all(2)
#非绑定方法
print Hotel.calc_all(stroom)

继承类：
addbook.py

class AddrBook(object):
def init(self,name,phone):
self.name=name
self.phone=phone
def get_phone(self):
return self.phone

def updata_phone(self,newphone):
    self.phone=newphone
    print '%s  updata phone %s' %(self.name,self.phone)

if name == 'main':
bob=AddrBook('bob','1333333')
alis=AddrBook('alis','144444')
print bob.get_phone()
bob.updata_phone('155555')
print bob.get_phone()

email.py

import addbook
class EmplAddrBook(addbook.AddrBook): #继承上一个类
def init(self,name,phone,email):

    super(EmplAddrBook,self).__init__(name,phone)  #super 方法继承
    self.email=email

def get_email(self):
    return self.email

if name == 'main':br/>tom=EmplAddrBook('tom','13666','tom@de.cn')
print tom.get_phone()
print tom.get_email()
父类和子类有同名方法时，会调用子类

组合：

class UserInfo(object):
def init(self,phone,email):
self.phone=phone
self.email=email

def get_phone(self):
    return self.phone

def updata_phone(self,newphone):
    self.phone=newphone
    return self.phone

    def get_email(self):
    return self.email

def updata_email(self,newemail):
    self.email=newemail
    return self.email

class AddrBook(object):
def init(self,name,phone,email):
self.name=name
self.info=UserInfo(phone,email) #引用上一个类定义的属性

if name == 'main':br/>bob=AddrBook('bob','1231332','bob@tt')
print bob.info.get_phone()
bob.info.updata_email('bob@udif')

多重继承
class A(object):
def get_name(self):
print 'in a'
def start(self):
print '' 20

class B(object):
def display_name(self):
print 'in b'
def start(self):
print '#' * 20

class C(A,B):
pass
if name == 'main':
c=C()
c.display_name() #继承所有父类的方法
c.get_name()
c.start() #先在A中查找，有就打印了

issubclass(B,A) #判断B是否A的子类
isinstance(b,B) #判断b是否B的实例
hasattr() #判断一个对象是否另一个特定的属性
getattr() #获得一个对象的属性
setattr() #设置一个对象的属性
delattr() #删除一个对象的属性

私有化
class A(object):
def init(self):
self.name='bob' #开头的是私有化
def get_name(self):
return self.__name

a =A()
a.get_name()

class Books(object):
def init(self,title,author):
self.title=title
self.author=author
def str(self): #字符串初始化，比下面更易读
return self.title
def repr(self):
return self.title #字符串初始化，
def call(self): #方法调用
print '%s is jiw %s'%(self.title,self.author)

if name == 'main':
py_book=Books('sss','wew')
print py_book
py_book()

正则：

. 匹配任意字符
[..x-y..] 匹配字符组里的任意字符
[^..x-y..] 匹配不再字符组里的任意字符
\d 匹配任意数字【0-9】
\D 非数字字符
\w 匹配任意数字字母下划线【0-9a-zA-Z】
\W 非数字字母下划线
\s 匹配空白字符【\r\v\f\t\n】
\S 非空白字符

literal 匹配字符串的值
re1|rel2 匹配re1或re2

匹配前面出现的零次或多次
匹配前面出现的一次或多次
? 匹配前面出现的零次或一次
{M,N} 匹配前面出现至少M次，最多N次

^ 匹配字符串的开始
$ 匹配字符串的结尾
\b 匹配字符串的边界 #egrep '\btom\b' ,只匹配 tom
() 对正则表达式分组
\nn 匹配已保存的子组

import re

a=re.match('查找内容'，'查找目标') #正则查找,但只匹配开始，隐含有^
re.search('查找内容'，'查找目标') #正则查找,仅匹配一个
a.group() #获取查找内容

c=re.findall('the','apple the,teh the 22') #查找所有，结果放入列表，可以直接输出
print c

c=re.finditer('the','apple the ,teh the 22') #返回一个迭代器对象
for i in c:
print i.group() #打印迭代器内容

IP地址正则表达式
([0-9]{1,3}.){3}[0-9]{1,3}

Mac地址匹配加符号
%/(..)(..)(..)(..)$/\1:\2:\:3\/g

complie 大量匹配时用，可以提高效率
patt=re.compile('foo')
m=patt.match('food')
print m.group()

split 分隔符切割
mylist=re.split('.|-','hello-world.data')
print mylist

import re
z='firefox'
dica={}
data=open('access_log')
for i in data:
m=re.search(z,i)
if m:
ip=m.group()
dica[ip]=dica.get(ip,0)+1
print dica

sub
re.sub() #替换某一个字符
re.sub('X','MR','Hi X ,nice to meet you')

data='my phone number is :1588888696'
m= re.search('.+(\d+)',data)
print m.groups() #获取了（）里的值

贪婪匹配，即最长匹配，即可能多的匹配
m=re.search('.+?(\d+)',data) #?阻止贪婪匹配
m.groups()
('1588888696')

Socket函数与方法：
创建tcp服务器
创建TCP服务器的主要步奏：
1.创建服务器套接字：s=socket.socket()
2.绑定地址到套接字：s.bind()
3.启动监听:s.listen()
4.接受客户连接:s.accept()
5.与客户端通信：recv()/send()
6.关闭套接字：s.close()

import socket

host='' #空串表示所有地址
port=1234
addr=(host,port)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #网络的tcp的套接字
s.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #套接字选项，允许程序退出后立即可以执行，1是允许
s.bind(addr)

s.listen(1) #为一个程序提供服务
while True: #持续链接
cli_sock,cli_addr = s.accept() #返回一个套接字元组和地址,yum -y install telnet
print "Client connected from:",cli_addr #telnet 127.0.0.1 1234
while True:
cli_sock.send(" i c u \r \n")
data= cli_sock.recv(1024) #每次接受1024字节数据
if data.strip() == '' :
break
print data

cli_sock.close()

s.close()

==================================
爬取图片

import urllib2
html=urllib2.urlopen('Http://www.baidu.com/a.jpg')
data=html.read()
html.close

with open('a.jpg','w') as fobj:
fobj.write(data)

分析apache访问日志
编写一个apche日志分析脚本
1.统计每个客户端的访问apache服务器的次数
2.将统计信息通过字典的方式显示出来
3.分别统计客户端时firefox和msie的访问次数
4.分别使用函数式编程和面向对象编程的方式实现
import re

def count_patt(fname,patt):
result={}
cpatt=re.compile(patt)

with open(fname) as fobf:
    for line in fobf:
        m=cpatt.search(line)    #全句查找
        if m:
            key=m.group()
            result[key]=result.get(key,0)+1  #获取字典的值，没有则用0
return result

def quick_sort(str_list):
if len(str_list)==0 or len(str_list) ==1:
return str_list
middle=str_list.pop()
smaller=[]
large=[]
for item in str_list:
if item[-1] < middle[-1]:
smaller.append(item)
else:
large.append(item)
return quick_sort(large) +[middle]+quick_sort(smaller)

if name == 'main':
log_file='access_log-2016077'
ip='^(\d+.){3}\d+'
br='Firefox|MSIE'
print count_patt(log_file,ip)
print count_patt(log_file,br)

a=count_patt(log_file,ip)
print a
print quick_sort(a.items())

多线程：
import threading

import subprocess,threading
def myiping(ip):
a=subprocess.call('ping -c2 -i0.1 %s &>/dev/null' % ip,shell=True)
if a:
print '%s is down'%ip
else:
print '%s is up'%ip

net=['172.40.55.%s' %i for i in range(1,255)]

for i in net:
t=threading.Thread(target=myiping,args=[i]) #target是函数名，args是参数
t.start()

利用多线程实现ssh并发访问
import paramiko

host = '192.168.4.100'
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(host, username='root', password='123456')
ssh.exec_command('touch /hh22.txt')
stdin,stdout,stderr=ssh.exec_command('ls /') #将结果赋值给3个变量

print stdout.read() #获取输出结果

4 案例4：利用多线程实现ssh并发访问
4.1 问题

编写ssh客户端脚本，主要要求如下：

在文件中取出所有远程主机IP地址
在shell命令行中接受远程服务器IP地址文件、远程服务器密码以及在远程主机上执行的命令
通过多线程实现在所有的远程服务器上并发执行命令
方案

python的paramiko模块可以实现ssh客户端的功能，使用起来也比较简单。但是当服务器非常多的时候，每台服务器上执行完全相同的简单操作，也会花费大量的时间。

通过ssh加上多线程，可以实现并发访问。为了将程序写的灵活性更强，把要执行的命令以位置参数的方式来提供。
4.2 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写脚本

[root@py01 bin]# vim remote_comm.py
#!/usr/bin/env python
import paramiko
import os
import sys
import threading
def remote_comm(host, password, comm):
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(host, username='root', password=password)
    stdin, stdout, stderr = ssh.exec_command(comm)
    out = stdout.read()
    err = stderr.read()
    if out:
        print "[%s:out]: %s" % (host, out),
    if err:
        print "%s:Error: %s", (host, err),
    ssh.close()
if __name__ == '__main__':
    if len(sys.argv) != 4:
        print "Usage: %s ipfile password 'comm'" % sys.argv[0]
        sys.exit(1)
    ipfile = sys.argv[1]
    if not os.path.isfile(ipfile):
        print "No such file: %s" % ipfile
        sys.exit(2)
    password = sys.argv[2]
    comm = sys.argv[3]
    with open(ipfile) as fobj:
        for line in fobj:
            ip = line.strip()
            t = threading.Thread(target=remote_comm, args=(ip, password, comm))
            t.start()

xinetd:
yum -y install xinetd

vim /etc/xinetd.d/pyserver
service pyserver
{
flags = NAMEINARGS
type = UNLISTED
socket_type = stream
port = 21345
protocol = tcp
wait = no
user = root
server = /root/lgh/ex1.py
server_args = /root/lgh/ex1.py
}

vim /root/lgh/ex1.py
#!/usr/bin/env python
import sys

sys.stdout.write('sdfe')
sys.stdout.flush() #刷新缓存

父进程
os.fork()

celery 框架

import os
import time

pid=os.fork()
print pid
if pid:
print "in par"
time.sleep(15)
print "par ext"
else:
print "in chi"
for i in range(5):
print time.ctime()
time.sleep(1)
print "ch exit"

父进通过os.wait()来得到子进程是否终止信息

python3.0
依赖
yum -y install GCc gcc-c++ opensll-devel libffi-devel readline-devel

https://www.python.org/ftp/python/3.6.1/

字符串直接是UNICOOK

去除回车
print(line,end='')
输入：
input

5/3 直接返回浮点
5//3 返回整数

异常
except IndexError as e #2用逗号，3用as

raise valueerror,'valll.' #2用逗号
raise valueerror('xxxxx') #3用括号

range() 和2版本的xrange()一样。

adict.keys 返回对象，不是列表。

整数统一了，没长整数

8进制数改成0o11

3也有可变集和和不可变集和
{} 是可变集和
frozenset([])是不可变集和。

数据库
模块 Mysql-python 1.2.5 py2.7
mysqlpy 2.1.7 py3.0

pip3 install PyMySQL 安装组建

插入数据
import pymysql

conn=pymysql.connect(
host='127.0.0.1',
user='root',
port=3306,
passwd='123456',
db='test'
charset='utf8'
)

cursor=conn.cursor() #游标，获取SQL结果
sql1="insert into depar(dep_name) values(%s)"
result=cur.execute(sql1,('deve',)) #后面是元组，单元组要加逗号
print(result)
conn.commit()
cur.close() #关闭游标
conn.close() #关闭数据库

执行后放回1 是影响1行。

import pymysql

conn=pymysql.connect(
host='127.0.0.1',
user='root',
port=3306,
passwd='123456',
db='test'
charset='utf8'
)

cursor=conn.cursor() #游标，获取SQL结果
sql1="insert into depar(dep_name) values(%s)"
data=[('hr',),('op',),('财务',)]
result=cur.executemany(sql1,data) #多个数据
print(result)
conn.commit()
cur.close() #关闭游标
conn.close() #关闭数据库

import pymysql

conn=pymysql.connect(
host='127.0.0.1',
user='root',
port=3306,
passwd='123456',
db='test'
charset='utf8'
)

cursor=conn.cursor() #游标，获取SQL结果
sql1="insert into depar(dep_name) values(%s,%s)"
data=[('hr','aa'),('op','bb'),('财务','cc')]
result=cur.executemany(sql1,data) #多个数据
print(result)
conn.commit()
cur.close() #关闭游标
conn.close() #关闭数据库

sql1="insert into salary(date,emp_id,basic,extra) values(%s,%s,%s,%s)"
data=(time.strftime('%Y-%m-%d'),1,10000,5000)
result=cur.execute(sql1,data) #多个数据

查询
import pymysql

conn=pymysql.connect(
host='127.0.0.1',
user='root',
port=3306,
passwd='123456',
db='test'
charset='utf8'
)

cursor=conn.cursor() #游标，获取SQL结果
sql1="select * from departments"
result=cur.fetchone() #获取一条数据
result2=cur.fetchmany(2) #获取2条数据
cur.scroll(1,mode="ralative") #相对当前位置移动
result3=cur.fetchmany(2) #获取2条数据
result3=cur.fetchall() #获取全部数据
print(result)
conn.commit()
cur.close() #关闭游标
conn.close() #关闭数据库

移动游标获取数据
cur.scroll(1,mode="ralative") #相对当前位置移动
cur.scroll(2,mode="absolute") #相对查询结果位置移动

更新

sql1="updata salary set dep=%s where dep=%s"
result=cur.execute(sql1,('oppp','op')) #多个数据

删除

sql1="delete from salary where dep=%s"
result=cur.execute(sql1,('oppp',)) #多个数据

SQLalchemy
连接数据库

安装
pip3 install SQLalchemy

连接
数据库类型+驱动://user:password@host/dbname[?key=value...] #[?连接参数]

from sqlalchemy import create_engine
engine=create_engine('mysql+pymysql://root:123456@localhost/dbtest',encoding='utf8',echo=True)

声明映射
当使用ORM的时候，配置过程从描述数据库表开始
通过自定义类映射相应的表
通过声明系统实现类映射
首先通过声明系统，定义基类
from sqlalchemy.ext.declarative import declarative_base
Base=declarative_base() #声明基类

创建映射类
一旦创建了基类，就可以创建自定义映射类了

from sqlalchemy import Column,Integer,String
class Departments(Base):
tablename='departments'
dep_id=Column(Integer,primary_key=True)
dep_name=Column(String(20))
def repr(self):
return "<Department(dep_name='%s')>"% self.dep_name
#repr是可选项输出类的信息，可print(Base)查看

创建架构
类构建完成后，表的信息将被写入到表的元数据（metadata）
print(Departments.tablename) #查看

创建表
if name == 'main':
Base.metadata.create_all(engine)

创建映射类的实例
创建实例时，并不会真正在表中添加记录
dep_dev=Departments(dep_name='developments') #创建会话后才插入数据
print(dep_dev.dep_name)
print(dep_dev.dep_id)

创建会话类
ORM访问数据库的句柄被称做Session
from sqlalchemy.orm import sessionmaker
Session=sessionmaker(bind=engine)

如果在创建session前还未创建engine，操作如下
Session=sessionmaker()
Session.configure(bind=engine) #创建engine后执行

添加新对象
会话类的实例对象用于绑定到数据库
实例化类的对象，并不打开任何连接
当实例初次使用，它将从Engine维护的连接池中获得一个连接
当所有的事务均被commit或会话对象被关闭时，连接结束
session=Session()
session.add(dep_dev)
session.commit()
print(str(dep_dev.dep_id))
session.close()

添加新对象
。可以创建多个实例，批量添加记录
。如果有中文，注意engine的参数
engine=create_engine('mysql+pymysql://root:123456@localhost/dbtest?charset=utf8',encoding='utf8',echo=True)

Base.metadata.create_all(engine)
dep_hr=Departments(dep_name='hr')
dep_op = Departments(dep_name='op')
dep_finance = Departments(dep_name='财务')
dep_xz = Departments(dep_name='行政')
Session=sessionmaker(bind=engine)
session=Session()
session.add_all([dep_hr,dep_op,dep_xz])  #多行用[]
session.commit()
session.close()

ORM映射关系也可用于表间创建外键约束
from sqlalchemy import Column,Integer,String,ForeignKey
class Employees(Base):
tablename='employees'

emp_id=Column(Integer,primary_key=True)
name=Column(String(20))
genda = Column(String(10))
phone = Column(String(11))
dep_id=Column(Integer,ForeignKey（'departments.dep_id'))
def __repr__(self):
    return "<Employees(name='%s')>" % self.name

日期
from sqlalchemy import Column,Integer,String,ForeignKey,Date

class salary(Base):
tablename='salary'

id=Column(Integer,primary_key=True)
date=Column(Date)  #日期应用
emp_id=Column(Integer,ForeignKey('employees.emp_id'))
basic=Column(Integer)
extra = Column(Integer)

日期插数据
from datetime import date

date1=date(2017,1,1)
bob1=Salary(date=date1,emp_id=4,basic=1000,extra=3000)

基本查询
通过作用于session的query()函数创建查询对象
query()函数可以接收多种参数
Session=sessionmaker(bind=engine)
session=Session()
for instance in session.query(Departments).order_by(Departments.dep_id):
print(instance.dep_id,instance.dep_name)
使用ORM描述符进行查询
返回值是元组
for name,phone in session.query(Employees.name,Employees.phone ): #多字段
print(name,phone)
使用命名元组(即为元组下标命名，方便引用)
查询对象返回的是一个命名元组
名称是类的名字，或是类中属性的名字
for row in session.query(Departments,Departments.dep_name)
print(row.Departments,row.dep_name)

修改显示字段名
显示的字段名可以通过label()函数进行修改
for row in session.query(Departments.dep_name.label('部门')):
    print(row.部门)
使用别名
可以为经常使用的类定义别名
from sqlalchemy.orm import sessionmaker,aliased
new_emp=aliased(Employees)
for row in session.query(new_emp,new_emp.name,new_emp.phone).all():
    print(row.name,row.phone)

排序
通过order_by()函数可以实现按指定字段排序
 for instance in session.query(Departments).order_by(Departments.dep_id):
    print(instance.dep_id,instance.dep_name)

提取部分数据
通过“切片”的方式，实现部分数据的提取
 new_emp=aliased(Employees)
 for row in session.query(new_emp,new_emp.name,new_emp.phone).order_by(new_emp.emp_id)[2:4]:
    print(row.name,row.phone)

结果过滤
通过filter()函数实现结果过滤
new_emp=aliased(Employees)
for row in session.query(new_emp,new_emp.name,new_emp.phone).filter(new_emp.name=='bob'):
    print(row.name,row.phone)

filter()函数可以叠加使用
new_sal=aliased(Salary)
for row in session.query(new_sal,new_sal.emp_id,new_sal.basic,new_sal.extra).filter(new_sal.extra >=2000).filter(new_sal.extra<10000):
    print(row.emp_id)

    常用过滤操作符
    相等
      query.filter(Employees.name=='john')
    不相等
      query.filter(Employees.name!='john')
    模糊查询
      query.filter(Employees.name.like('j%'))
    in
      query.filter(Employees.name.in_(['j','b']))
    not in
      query.filter(~Employees.name.in_(['j','b']))
    字段为空
      query.filter(Employees.name.is_(None))
    字段不为空
      query.filter(Employees.name.isnot(None))
    多重条件AND
     from sqlalchemy import and_
       query.filter(and_(new_sal.basic>=10000,new_sal.extra>=2000))
    多重条件or
     from sqlalchemy import or_
       query.filter(or_(new_sal.basic>=10000,new_sal.extra>=2000))
    查询对象返回值
    all()返回列表
    first()返回结果中的第一条记录
    one()取出所有记录，如果不是一条记录则抛出异常
    Scalar()调用one(),返回第一列的值

     new_sal=aliased(Salary)
     query= session.query(new_sal)
     print(query.all())

    聚合
    通过count()方法，统计行数
     new_sal=aliased(Salary)
     query= session.query(new_sal).filter(new_sal.extra<10000)
     print(query.count())

    多表查询
     通过join() 方法实现多表查询

    new_emp=aliased(Employees)
    new_dep=aliased(Departments)
    query=session.query(new_emp.name,new_dep.dep_name).join(new_dep,new_emp.dep_id==new_dep.dep_id)
    result=query.all()
    print(result)

    通过会话的update()方法更新
    query=session.query(Departments).filter(Departments.dep_id==8)
    query.update({Departments.dep_name:'运营'})
    session.commit()

    通过会话的字段赋值更新
    dep_yy=session.query(Departments).get(8) #get主键
    dep_yy.dep_name='运营'
    session.commit()

    删除记录
    通过会话的delete()方法进行记录删除
    dep_yy=session.query(Departments).get(8) #get主键
    session.delete(dep_yy)
    session.commit()

session.close()

相关文章