Python基础学习（3）

1.冒泡排序

li1 = [33, 2, 10, 1]print(li1)def bubbleSort(li):    for i in range(1, len(li)):        for j in range(len(li) - i):            if li[j] > li[j + 1]:                temp = li[j]                li[j] = li[j + 1]                li[j + 1] = temp    return linew_list = bubbleSort(li1)print(new_list)

2.装饰器

只要函数应用装饰器，那么函数就被重新定义，重新定义为装饰器的内层函数

1）定义装饰器，函数

2）应用装饰器

3）简单的无参数装饰器应用示例

# 装饰器def outer(func):def inner():print("This is the beggining of the decorator")print("Decorating")print("This is the end of the decorator")result = func() # 执行传入的代码，上面的都是装饰器的内容

print("---------------------------------------")

return resultreturn inner@outerdef f1():    print("Function 1")f1()

"""

1.执行outer函数，并且将其下面的函数名，当作参数

2.将outer的返回值重新赋值给f1 = outer的返回值

"""

4）带有参数的装饰器示例

def outer(func):    def inner(a1, a2):        print("Start")        result = func(a1, a2)        print("End")        return result    return inner@outerdef func1(a1, a2):    return a1 + a2

5）接收任意参数的装饰器示例

def outer(func):    def inner(*args, **kwargs):        print("Start")        result = func(*args, **kwargs)        print("End")        return result    return inner@outerdef func1(a1, a2):    return a1 + a2

把func1函数作为outer的参数去执行outer函数

index的整体放入到内存，当内层函数inner中对func1运行调用它作为一个新的函数

@outer

（1）执行outer函数，将index作为参数传递

（2）将outer的返回值，重新赋值给index

6）装饰器在web框架中的应用：用户权限的验证

3. 正则表达式

字符匹配：普通字符，元字符

1)普通字符：大多数字符和字母都会和自身匹配

例：re.findall("Daemon", "dffDevilMayCryforDaemon")

2)元字符： .  ^  $  *  +  ?  {  }  [  ]  |  (  )  \

. 匹配除了换行符以外的任意一个字符

^ 是否开始就匹配条件，控制开头

$ 是否在结尾匹配条件，控制结尾

* 匹配0到多次

+ 匹配1到多次

? 匹配0到1次

{} 匹配固定的次数，{5}匹配5次，{3,5}匹配3到5次

[] 字符集，"a[bc]de"=> "abde"或"acde"，"[a-z]"匹配小写字母，"[^1-9]"非数字1到9

\ 反斜杠后边跟元字符去除特殊功能；反斜杠后面跟普通字符实现特殊功能；引用序号对应的字组所匹配的字符串

re.search(r"(Bruce)(Wayne)com\2","jointhegroup") # "\2"就相当于"(eric)"

\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_]

\b 匹配一个单词边界，也就是指单词和空格间的位置

‘*’，‘+’和‘？’都是贪婪的。可以在后面加个问号，将策略改为非贪婪，自匹配尽量少的

re.search(r"a(\d+?)","a123") # 非贪婪模式，结果为1

re.search(r"a(\d+)","a123") # 贪婪模式，结果为123

re.search(r"a(\d+?)b","a123b") # 如果前后均有限定条件，则非贪婪模式就不再起作用了

() 将某些字符划为一组,

re.findall(r"(ab)*", "abcde")

re.findall(r"(ab)*", "abcde").group()

3) 函数

(1) match: re.match(pattern, string, flags=0)，从头匹配

flags 编译标志位，用于修改正则表达式的匹配方式，如：是否区别多行匹配等等

(2) search: re.search(pattern, string, flags=0).group，浏览全部字符串，

re.search("\dcom","www.123hao.123com").group()

(3) findall: 

re.findall 以列表形式返回所有匹配的字符串

re.findall 可以获取字符串中所有匹配的字符串

p = re.compile(r"\d+")

print p.findall("1one2two3three4four")

re.findall(r"\w*oo\w*", text) # 获取字符串中，包含"oo"的所有匹配

finditer(): 与findall类似，将匹配到的所有内容都放置在一个列表中

(4) sub, subn:

re.sub(pattern, repl, string, max=0)

re.sub("g.t","have","I get an apple. I got an orange.")

(5) split:

p = re.compile(r"\d+")

p.split("one1two2three3four4")

(6) re.compile(strPattern[, flag]): 可以把正则表达式编译成一个正则表达式对象。

(7) 

r = re.match("h\w+", "Hello World!")

r = re.match("(?P<n1>h)(?P<n2>\w+)","Hello World!") # 增加了?P<n1>将匹配到的结果放到groupdict中，key=n1，value="h"

r.group() # 获取匹配到的所有结果

r.groups() # 获取模型中匹配到的分组结果

r.groupdict() # 获取模型中匹配到的分组结果

4)正则表达式的工作方式

re.I 是匹配对大小写不敏感

re.L 做本地化识别（locale-aware）匹配

re.M 多行匹配，影响^和$

re.S 是.匹配包括换行在内的所有字符

re.findall(".","abc\nde", re.S)

re.U 根据Unicode字符集解析字符。这个标志影响\w, \W, \b等

re.X 该标志通过给予你更灵活的格式以便你讲正则表达式写的 

5)一旦匹配成功，就是一个match object对象，而match object对象的操作方式如下：

group() 返回被RE酦醅的字符串

group(m,n) 返回组号为n，m所匹配的字符串

a = "123,abc456"

re.search("([0-9*])([a-z*])([0-9*])",a).group(0) # 123abc456

re.search("([0-9*])([a-z*])([0-9*])",a).group(1) # 123

re.search("([0-9*])([a-z*])([0-9*])",a).group(0) # abc

re.search("([0-9*])([a-z*])([0-9*])",a).group(0) # 456

start() 返回匹配开始的位置

end() 返回匹配结束的位置

span() 返回一个元祖包含匹配（开始，结束）的位置

用正则表达式计算复杂算式：

import reorigin = "1 - 2 * ((60 - 30 + (-40.0 / 5) * (9 - 2 * 5 / 3 + 7 / 3 * 99 / 4 * 2998 + 10 * 568 / 14)) - (-4 * 3) / (16 -3 * 2))"while "(" in origin or ")" in origin:    origin = re.split("\(([^()]+)\)", origin, 1)    origin[1] = str(eval(origin[1]))    origin = ''.join(origin)    print originresult = str(eval(origin))print result

4. Python常用模块

模块分为三种：自定义模块、第三方模块、内置模块

1) time模块

(1) time.clock() # 返回处理器时间，3.3开始废弃

(2) time.process_time() # 返回处理器时间，3.3开始废弃

(3) time.time() # 返回当前系统时间戳

(4) time.ctime() # 输出Mon Jan 26 00:00:00 2016，当前系统时间

(5) time.ctime(time.time()) # 将时间戳转为字符串格式

(6) time.gmtime(time.time()) # 将时间戳转换成struct_time格式

(7) time.localtime(time.time()) # 将时间戳转换成struct_time格式，但返回本地时间

(8) time.mktime(time.localtime()) # 与time.localtime()功能相反，将struct_time格式转回成时间戳格式

(9) time.strftime("%Y-%m-%d %H-%m-%d", time.gmtime()) # 将struct_time格式转成指定的字符串格式

(10) time.strptime("2016-01-18", "%Y-%m-%d") # 将字符串格式转换成struct_time格式

2) sys模块

(1) sys.argv # 命令行参数List，第一个元素是程序本身路径

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

(3) sys.version # 获取Python解释程序的版本信息

(4) sys.maxint # 最大的int值

(5) sys.path # 返回模块的搜索路径，初始化时使用Python Path环境变量的值

sys.path.append("D:")

(6) sys.platform # 返回操作系统平台名称

(7) sys.stdout.write("Please: ")  # 输出相关

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

(8) sys.stdin # 输入相关

(9) sys.stderr # 错误相关

3) datetime模块

(1) datetime.date.today # 输出格式

(2) datetime.date.fromtimestamp(time.time()) # 2016-01-16 将时间戳转成日期格式

(3) datetime.datetime.now # 输出2016-01-26 19:04:30

(4) datetime.datetime.now().timetuple() # 返回struct_time格式

(5) datetime.datetime.now().replace(2014,9,12) # 输出2014-09-12 19:06:23，返回当前时间，但指定的值被替换

(6) datetime.datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M") # 将字符串转换成日期格式

(7) datetime.datetime.now() + datetime.timedelta(days=10)  # 比现在加10天

(8) datetime.datetime.now() + datetime.timedelta(days = -10) # 比现在减10天

(9) datetime.datetime.now() + datetime.timedelta(hours = -10) # 比现在减10小时

(10) datetime.datetime.now() + datetime.timedelta(seconds = 120) # 比现在多120秒

模拟进度条练习：

# -*- coding:utf-8 -*-import sys,timefor i in range(101):    sys.stdout.write('\r') # 每一次清空原行    sys.stdout.write("%s%% | %s" % (str(i), "*" * i))    sys.stdout.flush() # 强制刷新至屏幕    time.sleep(0.3)

4) pickle模块，可以把python中的任何数据类型转化成字符串，但只能在Python中支持

pickle模块提供了四个功能：dumps, dump, loads, load

(1) pickle.dumps 将数据通过特殊的形式转换为只有python语言认识的字符串

data = {"k1":123,"k2":456}

pickle_string = pickle.dumps(data)

(2) pickle.dump 将数据通过特殊的形式转换为只有python语言认识的字符串并写入文件

with open("pickle_store1", "w") as fp:

pickle.dump(data,fp)

(3) pickle.loads(file.read()) 将数据读取出来

(4) pickle.load(file) 将数据读取出来写入文件

5) json模块，与pickle用法一样，但只能转化列表、字典、简单的变量与字符串，可以跨多个语言使用

6) os模块，用以提供系统级别的操作：

(1) os.getcwd() # 获取当前工作目录，及当前Python脚本工作的目录路径

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

(3) os.curdir # 返回当前目录

(4) os.pardir # 获取当前目录的父目录字符串名

(5) os.makedirs("dir1/dir2") # 可生成多层递归目录

(6) os.removedirs("dirname1") # 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，以此类推

(7) os.mkdir("dirname") # 生成单级目录；相当于shell中mkdir dirname

(8) os.rmdir("dirname") # 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname

(9) os.listdir("dirname") # 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

(10) os.remove() # 删除一个文件

(11) os.rename("oldname", "newname") # 重命名文件/目录

(12) os.stat("path/filename") # 获取文件/目录信息

(13) os.sep # 操作系统特定的路径分隔符，win下为“\\”,Linux下为“/”

(14) os.linesep # 当前平台使用的行终止符，win下为“\t\n”，Linux下为“\n”

(15) os.pathsep # 用于分割文件路径的字符串

(16) os.name # 字符串指示当前使用平台。win为"nt"，Linux为“posix”

(17) os.system("bash command") # 运行shell命令，直接显示

(18) os.environ # 获取系统环境变量

(19) os.path.abspath(path) # 返回path规范化的绝对路径

(20) os.path.split(path) # 将path分割成目录和文件名二元组返回

(21) os.path.dirname(path) # 返回path的目录。其实就是os.path.split(path) 的第一个元素

(22) os.path.basename(path) # 返回path最后的文件名。如何path以/或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素

(23) os.path.exists(path) # 如果path存在，返回True；如果path不存在，返回False

(24) os.path.isabs(path) # 如果path是绝对路径，返回True

(25) os.path.isfile(path) # 如果path是一个存在的文件，返回True，否则返回False

(26) os.path.isdir(path) # 如果path是一个存在的目录，返回Treu，否则返回False

(27) os.path.join(path[, path[, ···]]) # 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略

(28) os.path.getatime(path) # 返回path所指向的文件或者目录的最后存取时间

(29) os.path.getmtime(path) # 返回path所指向的文件或目录的最后修改时间

 

5. hashlib：用于加密相关的操作，代替了md5模块和sha模块，主要提供SHA1，SHA224，SHA256，SHA384，SHA512，MD5算法

1) MD5不可逆，无法进行反解

import hashlibhash = hashlib.md5()hash.update(bytes("123"))print(hash.hexdigest())print(hash.digest())

2) SHA1

import hashlibhash = hashlib.sha1()hash.update(bytes("456"))print(hash.hexdigest())print(hash.digest())

3) SHA256

import hashlibhash = hashlib.sha256()hash.update(bytes("789"))print(hash.hexdigest())print(hash.digest())

4) SHA384

import hashlibhash = hashlib.sha384()hash.update(bytes("789"))print(hash.hexdigest())print(hash.digest())

5) SHA512

import hashlibhash = hashlib.sha512()hash.update(bytes("789"))print(hash.hexdigest())print(hash.digest())

6) 对密码进行加密的练习

import hashlibdef md5(arg):    code = hashlib.md5("sad;fj;k")    code.update(bytes(arg))    return code.hexdigest()def register(user,pwd):    with open("db", "a") as f:        temp = user + "|" + md5(pwd)        f.write(temp)def login(user,pwd):    with open("db", "r") as f:        for line in f:            u,p = line.strip().split("|")            if u == user and p == md5(pwd):                return Truei = raw_input("1.登录；2.注册")if i == "2":    user = raw_input("用户名： ")    pwd = raw_input("密码： ")    register(user,pwd)elif i == "1":    user = raw_input("用户名： ")    pwd = raw_input("密码： ")    if login(user,pwd):        print "登陆成功"    else:        print "登录失败"

6. 字符串格式化

Python的字符串格式化有两种方式：百分号方式，format方式

1) 百分号方式

% [(name)][flags][width].[precision]typecode

(1) (name) 可选，用于选择指定的key

s = "Hello %(n1)s" % {"n1" : "World"}

(2) flags 可选，可供选择的值有：

+ 右对齐：正数前加正好，负号前加负号，例：s = "Hello %(n1)+10s" % {"n1" : "World"}

- 左对齐：正数前无符号，负数前加负号

空格 右对齐：正数前加空格，负数前加负号

0 右对齐：正数前无符号，负数前加负号；用0填充空白处

(3) width 可选，占有宽度

(4) .precision 可选，小数点后保留的位数，例：s = "Hello %.3f" % (1.2563)

(5) typecode 必选

s 获取传入对象的__str__方法的返回值，并将其格式化到指定位置

r 获取传入对象的__repr__方法的返回值，并将其格式化到指定位置

c 整数：将数字转换成其unicode对应的值，10进制范围为0 <= i <= 1114111: 字符： 将字符添加到指定位置

o 将整数转换成八进制表示，并将其格式化到指定位置

x 将证书转换成十六进制表示，并将其格式化到指定位置

d 将整数、浮点数转换成十进制表示，并将其格式化到指定位置

e 将证书、浮点数转换成科学计数法，并将其格式化到指定位置

E 将证书、浮点数转换成科学计数法，并将其格式化到指定位置

f 将整数、浮点数转换成浮点数表示，并将其格式化到指定位置

F 同上

g 自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位用科学计数法），并将其格式化到指定位置

G 自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位用科学计数法），并将其格式化到指定位置