python语法

发布时间：2019-08-27 07:59:46编辑：auto阅读（1600）

python数据类型：（按特征划分）

数字类型：
×××：布尔形、长整型L、标准×××
非×××：双精度型、复数、decimal（不是内建类型）
序列类型：
字符串（str）
元组（tuple）
列表（list）
映像类型：
字典（dict）
集合类型：
可变集合（set）
不可变集合（frozenset）

python数据类型（按可变性划分）

可哈希的，不可变数据类型：
数字类型
不可变集合（frozenset）
字符串（str）
元组（tuple）
可变数据类型：
字典（dict）
列表（list）
可变集合（set）

python中引号的作用：

‘ ‘
“ “
''' '''

单引号和双引号基本没区别，同样的作用；双引号可以内嵌单引号。三引号作为大段文字的注释。

python的编解码

ASCII
Unicode
UTF-8

python模块

import moduleName：导入一个模块
from module import functionName：从一个模块中导入一个方法
import moduleName asnewModuleName：把一个模块重新命名

python用户交互：

使用内置函数：raw_input()，该函数接收一个字符串。

input()，该函数接收一个数字类型

python流程控制：

if … else …
split
strip
len()
for variable in range(1, 10):
while True:
break
continue

python练习：登录测试账号。

要求：输入用户名密码；认证成功后显示欢迎信息；输错三次后锁定

python的基本语法、数据类型、导入模块、流程控制。

python文件处理：

读文件：代码展示

f= file(‘filename.txt’, ‘r’)

forline in f.readlines():

line= line.strip(‘\n’).split(‘:’)

printline

文件处理模式：

r：以只读模式打开文件

w：以只写模式打开文件

a：以追加模式打开文件

r+b：以读写模式打开

w+b：以写读模式打开

a+b：以追加及读模式打开

python字符串处理：

str.find(substring,[start [,end]]) #可指范围查找子串，返回索引值，否则返回-1

str.rfind(substring,[start [,end]]) #反向查找

str.index(substring,[start [,end]]) #同find，只是找不到产生valueerror异常

str.rindex(substring,[start [,end]]) #同上反向查找

str.count(substring,[start [,end]]) #返回找到子串的个数

str.lowercase()

str.capitalize()首字母大写

str.lower()转小写

str.upper()转大写

str.swapcase()大小写互换

str.split(str,‘ ‘)将string转list，以空格分割

str.join(list,’ ’)将list转string，以空格分割

len(str)字符串长度

cmp(“myfriend”, str) 字符串比较。第一个大返回1

max(‘abcxyz’)寻找字符串中最大的字符

min(‘abcxyz’)寻找字符串中最小的字符

python中的列表：

list的方法：

list.append(var)追加元素

list.insert(index,var)

list.pop(var)返回最后一个元素，并从list中删除

list.remove(var)删除第一次出现的该元素

list.count(var)该元素在列表中出现的个数

list.index(var)该元素的位置，无则抛异常

list.extend(list2)追加list2，到list上。合并

list.sort()排序

list.reverse()元素顺序反转

list[1:]片段操作符，用于子list的提取

[1,2]+[3,4]为[1,2,3,4]。同extend()

[2]*4为[2,2,2,2]

dellist[1] 删除指定下标的元素

dellist[1:3] 删除指定下表范围的元素

list= list1 list是list1的别名，内存地址相同，对list操作就是对list1的操作

list= list2[:] 生成list2的一个copy

python元组：

tuple：常量数组

tuple= (‘a’, ‘b’, ‘c’, ‘d’)

可以用list的[],:操作符提取元素，就是不能直接修改元素

little case：shopping。

初始化金钱数，商品种类、价格，选择购买商品，直到钱不够，退出时打印已购买的商品和剩余金额。

开发文件替换小程序：

使用方法：

./pythonFile.py‘source string’ ‘replace string’filename.txt

./pythonFile.py‘source string’ ‘replace string’filename.txt --bak filename.txt.bak

python字典DICT：

dict.get(key,0) 同dict[key]，多了个没有则返回默认值，0。[]没有则抛出异常

dict.has_key(key)有该键返回True，否则False

dict.keys()返回字典键的列表

dict.values()以列表的形式返回字典中的值，返回值的列表中可包含重复元素

dict.items()将所有的字典项以列表方式返回，这些列表中的每一项都来自于(键，值)，但是项在返回时并没有特殊的顺序

dict.update(dict2)增加合并字典

dict.popitem()得到一个pair，并从字典中删除它，已空则抛出异常

dict.clear()清空字典，同del dict

dict.copy()拷贝字典

dictNaNp(dict1,dict2) 比较字典，（优先级为元素个数、键大小、键值大小

dict1= dict2 给dict2取个dict1的别名

dict2= dict.copy() 克隆，另一个拷贝

python中列表与字典的比较：

dict：

查找和插入的速度极快，不会随着key的增加而速度变慢
需要占用大量的内存，内存浪费多。
key不可变
默认无序

list：

查找和插入的时间随着元素的增加而增加
占用空间小，内存浪费少。
通过下标查询
有序

python SET集合

特点：无序；元素不重复

功能：关系测试；去重

set集合运算：

a= set([1, 2, 3, 4])

b= set([3, 4, 5, 6])

a& b 求交集a.intersection(b)

a| b 求并集 a.union(b)

a– b 求差集a.difference(b)

a^ b 求对称差集a.symmetric_difference(b)

a.issubset(b) a是b的子集

a.issuperset(b) a是否包含b

查询员工信息：模糊查询员工信息，显示匹配的条数，匹配字符串高亮显示。

python中目录和python包的区别：就是包下包含一个__init__.py文件，而目录没有。

模块的常用方法：

__name__

__file__

__doc__

python中的不定参数：参数前面带一个或两个*。

def fun(arg)

def fun(*args)

def fun(**args)

dict = {‘k1’:1, ‘k2’:2}

fun(1,2,3,4,)

fun(**dict)=fun(k1=’1’, k2=’2’)

元组和集合只有一个星号，字典是两个星号

yield关键字：

yield的作用：在写多线程的时候，可以用它创建一个线程池。什么时候用，什么时候拿。它是一个生成器，不是一下就给他创建了。它还能保存函数的执行状态。

with关键字：

三元运算：

result = ‘human if 1>3 else ‘animal

result = animal

Lambda表达式：

a = lambda x, y: x+y

print a(4,10)

lambda的作用是：声明一个函数，接收参数，返回参数的运算结果。

lambda是一个匿名函数。

内置函数

help()

dir()

vars()

type()

import temp

reload(temp)

id()

更多：http://www.cnblogs.com/wupeiqi/articles/4276448.html

在使用from file import module的时候多次导入不会执行，只执行第一次导入，如果要想再次导入的话，使用reload(module)再次导入模块。

字符串的格式化占位符：

str = ‘i am {0}’

print s.format(‘alex’)

i am alex

函数的调用：

显示调用函数，直接写出该函数。

隐式调用函数，Function(arg) apply(Function, (arg))

map()函数：遍历每一个序列里面的元素。序列里面的每一个元素当作参数传给第一个function参数。

map(function, sequce, [sequce, …..])

也可以使用lambda表达式：map(lambda arg:arg+10, li) li = [11, 22, 33]

filter() 过滤

reduce() 累加

apply()

zip()

eval()

__import__()

都是对序列里面的函数进行操作，然后返回回来。

反射就是把你的导入工作当作字符串。

反射：用于开发大型程序，随时可以切换数据库的时候。设计模式里面的工厂模式需要用到这个。降低程序的耦合。

通过字符串的形式导入模块：（代码）

temp = ‘mysqlhelper’

model = __import__(temp)

model.cont()

并以字符串的形式执行函数：（代码）

temp = ‘mysqlhelper’

func = ‘count’

model = __import__(temp)

Funciton = getattr(model, func)

常用的模块：

随机数

random：

random(m)

randint(m, n)

randrange(m, n)

MD5加密
hash = hashlib.md5()
hash.update(‘admin’)
hash.hexdigest()
hash.digest()
序列化和json 序列化可以把一个对象和一个列表或字典，通过python特有的方式序列化一下，以二进制的方式加密一下。

import pickle

li = ['alex',11, 22, 'ok', 'sb']

printtype(pickle.dumps(li))

dumpsed =pickle.dumps(li)

print dumpsed

loadsed =pickle.loads(dumpsed)

print loadsed

printtype(loadsed)

pickle.dump(li,open('temp.pk' , 'w'))

printpickle.load(open('temp.pk', 'r'))

import json

j_str =json.dumps(data)

print j_str

withopen(‘file.json’, w’) as fp:

json.dump(data, fp)

RE 正则

六个函数：

compile match search findall group groups

match：只能从你给的字符串的起始位置去匹配

search：在整个字符串，在整个内容里面去匹配

group：输出匹配的结果。

常用格式：

\d匹配数字

次数： * + ? {m} {m,n}

time模块

三种表示方法：

时间戳 1970.1.1之后的秒数
元组包含了：年、日、星期等….time.struct_time
格式化的字符串 2014-11-11 11：11 print time.time()

time.mktime(time.localtime())

time.gmtime() 可加时间戳参数

time.localtime() 可加时间戳参数

time.strptime(‘2014-11-11’, ‘%Y-%m-%d’)

time.strftime(‘%Y-%m-%d’) 默认当前时间

time.strftime(‘%Y-%m-%d’, time.localtime()) 默认当前时间

time.asctime()

time.asctime(time.localtime())

time.ctime(time.time())

sys 模块

sys.argv 命令行参数list，第一个元素是程序本身路径

sys.exit(n) 退出程序，正常退出时exit(0)

sys.version 获取python解释程序的版本信息

sys.maxint 最大的int值

sys.maxunicode 最大的unicode值

sys.path 返回模块的搜索路径，初始化时使用pythonpath

sys.platform 返回操作系统平台名称

sys.stdout.write(‘please:’)

val = sys.stdin.readline()[:-1]

print val

OS 模块

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径

os.chdir(“dirname”) 改变当前脚本工作目录；相当于shell下cd

os.curdir 返回当前目录；(‘.’)

os.pardir 获取当前目录的父目录字符串名：(‘..’)

os.makedirs(‘dirname1/dirname2’) 可生成多曾递归目录

os.removedirs(‘dirname1’) 若目录为空，则删除，并递归到上一

os.mkdir(‘dirname’) 生成单级目录，相当于shell中mkdir dirname

os.rmdir(‘dirname’) 删除单级空目录，若目录不为空则无法删除，

os.listdir(‘dirname’)

os.remove()

os.rename(“oldname”, “newname”)

os.stat(‘path/filename’)

os.sep

os.linesep

os.pathsep

os.name

os.system(“bash command”)

os.environ

os.path.abspath(path)

os.path.split(path)

os.path.dirname(path)

os.path.basename(path)

os.path.exists(path)

os.path.isabs(path)

os.path.isfile(path)

os.path.isdir(path)

os.path.join(path1[,path2…..])

os.path.getatime(path)

os.path.getmtime(path)

装饰器（示例代码）

def foo():

print ‘foo’

def foo():

print ‘before dosth’

print ‘foo’

print ‘after’

def foo():

print ‘foo’

def wrapper(func):

print ‘before’

func()

print ‘after’

wrapper(foo)

装饰器
面向对象编程
异常处理
断言

First. 装饰器——也是一个函数，通过这个函数装饰另一个函数。

def outer(fun):

def wrapper():

fun()

return wrapper

@outer

def fun1():

print ‘hello’

#后面还有无穷个函数。

func1()

@outer相当于@outer=outer(func1) func1没有括号就代表这个函数，func1()带有括号就代表执行了这个函数，结果不一样的。

如果被调用的fun1函数带有参数，该参数放在defwrapper(arg)里面。带有参数的代码：

def outer(fun):

def wrapper(arg):

fun(arg)

return wrapper

@outer

def fun1():

print ‘hello’, arg

#后面还有无穷个函数。

func1(‘alex’)

如果func1有返回值的：

def outer(fun):

def wrapper(arg):

result = fun(arg)

return result

return wrapper

@outer

def fun1():

print ‘hello’, arg

return ‘eric’

#后面还有无穷个函数。

request= func1(‘alex’)

printrequest

second. 面向对象：

类就是一个抽象

实例化一个类就是一个对象，对象里面有属性和方法。

类里面的__init__方法，就是一个对象的初始化。相当于java中的构造函数。

定义一个类：

class Person:

name = ‘这是一个人’

def __init__(self, name):

self.name = name

pp= Person(‘alex’)

printpp.name

printPerson.name

self代表的就是一个实例化对象。就像上面的代码，self就代表的pp这个对象。

定义在类里面的属性，属于类的，不属于对象，直接可以使用使用类名.属性名调用，如：上段代码中的Person.name。

属于类的字段称为静态字段。通过self调用的称为动态字段（比如说：在__init__中调用的字段）。

类不能直接访问对象的属性，对象可以直接访问类的属性。

在一个类中定义静态方法的办法：直接在方法上面添加@staticmethod，去掉方法中的self。因为self代表的是一个对象。

在类中定义的静态方法可以使用类来调用，也可以使用对象来调用。

对象的属性：在类中定义一个方法，在该方法上添加@property，就把该方法变成了对象的一个属性。访问的方式：对象名.属性名 pp.property 后面没有小括号。

这个静态方法什么时候用：

Python中的私有方法和私有字段：都是以双下划线__ 开头的。

私有方法

也是通过在内部定义一个公有的方法，该公有的方法调用该私有方法，在外部调用该公有的方法间接的访问该私有方法。

强制访问私有方法的办法是：对象调用这个类的私有方法。具体是：

对象名._类名__私有方法名()。objName._class__privateFunctionName()

私有字段

在类中定义了私有字段，外部是不能访问的，只能通过在内部定义函数访问这个私有字段，外部调用该函数间接的访问该私有字段。

访问私有字段代码：

@property

def Thailand(self):

return self.__Thailand __Thailand是之前定义的一个私有字段。

objName.Thailand 调用该对象的这个方法来访问私有字段。

私有字段一般用在不让别人改，但是可以访问的情况下。

对象的属性的只读和可改写：它们使用的装饰器不一样。代码：

（只读的）

@property

defThailand(self):

return self.__Thailand

（可改写的）推荐使用私有字段的操作方式：

classClassName(object):

def __init__(self, __Thailand)

@Thailand.setter 还得让这个类继承object

def Thailand(self, value):

self.__Thailand = value 把__Thailand这个私有字段改写成了value这个值了

析构函数：就是python解释器在销毁对象的时候，我们可以干点啥，就可以写在这个析构函数里面。就是这个__del__

__call__方法：就是创建对象的时候，调用类中的__call__方法，在对象中使用对象名加上()即可。

classFoo():

def __call__(self):

print ‘我就是__call__方法。’

f1= Foo()

f1() --à直接调用对象中的__call__方法。

Foo()()的效果就等于 f1=Foo() f1()，这两步

继承：

在创建子类的时候在子类名后面的括号里写上父类的名字，就继承了父类。

方法的重写（override）：发生在类的继承中，子类重写父类的方法。

方法的重载（overload）：发生在本类中，两个重名的函数，根据参数的不同，而重载

子类调用父类的构造函数（也就是父类的__init__函数）：两种方法：

显示调用：Father.__init__(self)
隐式调用：super(son,self).__init__() 此种方法需要申明父类继承自object

继承自object的类称为新式类，未继承自object的类称为经典类。

多继承：如果在多继承中，多个父类含有同一函数的话，就从最左边的父类找到该函数并执行。

抽象类：代码如下：

from abc import ABCMeta, abstractmethod

class Bar:

__metaclass__ = ABCMeta

@abctractmethod

def fun(self): pass

class Foo(Bar):

def __init__(self):

print‘__init__’

Foo()

python中的接口：没明确讲解。

Third. python中的异常处理：

使用的是

try:

xxxxxxx

except Exception, e:

xxxxxx

else:

print ‘没有出错。’

finally:

print ‘这里的代码无论如何都会执行。’

自定义的异常类：

class MyException(Exception):

def__init(self, msg):

self.error= msg

def__str__(self, *args, **kwargs):

returnself.error

主动触发异常：使用raise关键字

raiseMyException(‘自定义错误’)

为什么要主动触发异常：

Fourth. 断言

python中的断言：assert(1 == 1)

python操作mysql数据库
socket

python操作mysql数据库。

首先使用connect函数连接mysql，使用cursor获一个句柄，使用execute执行一条mysql语句，fetchall获得该数据库里面数据表的所有数据，然后关闭句柄和连接。

把sql语句定义为一个字符串变量，把里面的值使用格式化字符串的形式传递一个%s，如：

sql = “insert into userinfo values(%s, %s) 这里面的占位符只能是%s.

params = (‘bababa’, ‘M’)

reCount = cur.execute(sql, params)

涉及到数据库增删改的时候需要调用commit()方法。

connect.commit()

完整的代码：

importMySQLdb

connect =MySQLdb.connect(host=’localhost’, user=’root’, passwd=’root’, db=’dbname’)

current =connect.cursor()

sql = “insertinto tname(col1, col2, …) values(%s, %s, …)”

params =(‘val1’, ‘val2’)

reCount =cur.execute(sql, params)

data =cur.fetchall() 获取所有数据

conn.commit() 与事务相关

conn.rollback() 与事务相关

cur.close()

connect.close()

print reCount

print data

获取mysql的id值的函数：lastrowid

python项目的三层架构思想

数据访问层，业务逻辑层，应用层。

socket编程：

使用：异步、多线程、socket 处理多个请求的服务端。

SocketServer：把异步，多线程做了处理。

用socketserver和不用socketserver的区别：

使用socketserver不会有阻塞，处理多个请求，可以多个客户端连接。
不使用socketserver效果相反。

在之后的所有socket编程都使用socketserver库。

线程
进程
ftp服务器
paramiko库

ftp服务器就是使用socketserver库建立一个ftp服务器数据的传输。

线程：python中的多线程：

使用threading.Thread模块。常用的方法有：

–start

–getName()

–setName()

–isDaemon()

–setDaemon()

–join(timeout)主线程启动了子线程后，一直等到子线程执行结束，再执行主线程的其他东西。加了timeout后，就是主线程等到timeout时间后或者子线程执行结束，再执行主线程。

–run()

使这个线程与某件事情建立关系，使用target传递参数。

t1= Thread(target=function, args=(1, ))

target=function,这个是传递的某个方法，args=(1,)) args是传递该方法中的参数，参数传递完毕后需要接一个逗号，

代码示例：

defFoo(arg, v):

foritem in range(100):
printitem

time.sleep(1)

print‘before’

t1= Thread(target=Foo, args=(‘ddfdfdffd’,11, ))

t1.setDaemon(True)

t1.start()

自建线程类：新建类继承Thread

classMyThread(Thread):

defrun(self):

print‘I am a thread.’

执行线程，其实就是调用了Thread类中的run方法。

线程安全的问题，使用锁的功能：线程锁，能很好的保护线程安全。

线程安全：队列

队列：先进先出

线程栈：后进先出

多线程的使用：python不是一个线程安全语言，需要自己控制。

生产者消费者模型：生产者生产一个放到队列或者栈里面，然后消费者从队列或栈里面取一个。
线程安全的问题：使用线程锁

lock = threading.Lock()定义一个锁

lock.acquire()获取锁给需要加锁的代码加锁。

加锁的代码执行完后要释放锁：lock.release()

python中防止死锁：定义锁的时候使用递归锁。

lock = threading.Rlock()

信号量：同时执行的线程几个。

samp = threading.BoundedSemaphore(n)

异步：

paramiko模块的使用：sshlinux主机批量管理。

ssh的rsa原理：使用非对称加密。

公钥：在服务器端做加密。

私钥：在客户端做解密。

多进程
Paramiko
审计开发
select异步模型

进程：使用multiprocessing模块的Pool类。

多进程多线程可以绕过GlobalInterpreter Lock（全局解释器锁）

多进程示例代码：

frommultiprocessing import Pool

deff(x):

returnx*x

if__name__ == ‘__main__’:

p= Pool(5)

print(p.map(f,[1,2,3]))

创建多个子进程的方法2，示例代码：

frommultiprocessing import Process

importos

definfo(title):

ifhasattr(os, ‘getppid’):

print‘parent process:’, os.getppid()

print‘process id:’, os.getpid()

if__name__ == ‘__main__’:

info(‘mainline’)

p= Process(target = f, args = (‘bbbbb’, ))

p.start()

p.join()

进程间通信：使用队列。

frommultiprocessing import Process,Queue

进程间同步：加上锁，使用Manager()方法。也可以使用Value和Array

进程池：通过Pool创建多进程。

python异步：select vs poll&epoll 异步IO

审计工具：web工具：shellinabox

第8天的主要内容：实战练习：python开发一个类似nagios的监控软件。

python的 socket 开源框架：twistedmatrix

主题：使用PYTHON开发类Nagios监控软件

知识点：

1. 使用Reids发布\订阅功能做服务器和客户端的通信通道

2. 利用面向对象思想开发监控模板

3. 实现监控项目插件化，允许用户自行开发监控插件

需求：

1. 每个客户端需要监控的服务不同
2. 每个服务的监控间隔不同
3. 允许模板的形式批量修改监控指标
4. 不同设备的监控阀值不同
5. 可自定最近n分钟内hit\max\avg\last\... 指标超过阈值
6. 报警策略、报警等级、报警自动升级
7. 历史数据的存储和优化
8. 跨机房、区域代理服务器

1000*20=20000 总指标，没5分钟一次，

1hour = 24W

1day = 576W *4Byte、

Cpu :iowait 20 idle 80 system 30 user 50

What the client side has to know before itcan invoke a plugin?

Answer: plugin_name \ interval \service name

python web框架 Django

Controller：该模型里面存放的是一组对业务逻辑的描述代码。

Model：该模型里面存放的是一组对数据库进行操作的代码。

View：该模型里面存放的是一组html文件。

http://www.cnblogs.com/wupeiqi/articles/4491246.html

创建django程序，使用IDE创建一个django application，并配置运行参数。

关键字：

上一篇： python 调试

下一篇： python cookie



搜索

热门推荐

最新文章

博主信息

姓名：Run
职业：谜
邮箱：383697894@qq.com
定位：上海 · 松江

扫我打开

友情链接

百度 淘宝 腾讯 慕课网 CSDN 博客园 51cto博客