python 第六天

递归，阶乘
1*2*3*...7

def func(num):
    if num == 1:
        return 1
    return num * func(num-1)

x = func(7)
print(x)

反射
#利用字符串的形式去对像(模块)中操作(寻找/检查/删除/设置)成员
hasattr    #利用字符串的形式去对像(模块)判断是否存在，存在True，不存在False
getatrr    #利用字符串的形式去对像(模块)中操作(寻找)成员
delattr
setattr

commons.py
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang

def login():
    print(‘炫酷登录页面‘)

def logout():
    print(‘炫酷退出页面‘)

def home():
    print(‘炫酷主页面‘)

index.py
import commons
def run():
    inp = input(‘请输入要访问的url：‘)  
    #hasattr  利用字符串的形式去对像(模块)判断是否存在，存在True，不存在False
    #getatrr  利用字符串的形式去对像(模块)中操作(寻找)成员
    #if hasattr(commons,login): 
    if hasattr(commons,inp):             #去commons判断你输入的是否存在此函数
        func = getattr(commons,inp)         #去commons寻找你输入相同字符函数
        func()
    else:
        print(‘404‘)

if __name__==‘__main__‘:
    run()

结果
    请输入要访问的url：login
    炫酷登录页面

请输入要访问的url：home
    炫酷主页面

请输入要访问的url：logout
    炫酷退出页面

请输入要访问的url：sadfskafjsafd
    404

程序二

----index.py

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang

def run():
    # account/login
    inp = input(‘请输入要访问的url:‘)
    # inp字符串类型 inp = "login"
    # commons.inp() # commons.login
    # 利用字符串的形式去对象（模块）中操作（寻找/检查/删除/设置）成员，反射

m, f = inp.split(‘/‘)        #以/方式输入分隔,前面为模块，后在为函数
    obj = __import__(m)          #以字符串形式调模块
    if hasattr(obj, f):
        func = getattr(obj, f)
        func()
    else:
        print(‘404‘)

if __name__ == ‘__main__‘:
    run()

----manager.py

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang

def order():
    print(‘炫酷的订单页面‘)
   
   
   
   
----commons.py
   
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang

def home():
    print(‘炫酷主页面‘)
   
   
   
----account.py

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang

def login():
    print(‘炫酷登录页面‘)

def logout():
    print(‘炫酷退出页面‘)
   
   
   
结果：
    请输入要访问的url:manager/order           #输入manager/order
    炫酷的订单页面
   
    请输入要访问的url:account/jfkdsjfa
    404

obj = __import__(‘lib.account‘, fromlist=True)    #fromlist=True把lib和account拼接导入，否则查找到lib就停止了
print(obj)
   
#测试程序   
目录结构   
lib
    account.py
    commons.py
    manager.py
index.py

--index.py
def run():
    # account/login
    inp = input(‘请输入要访问的url:‘).strip()
    # inp字符串类型 inp = "login"
    # commons.inp() # commons.login
    # 利用字符串的形式去对象（模块）中操作（寻找/检查/删除/设置）成员，反射

m, f = inp.split(‘/‘)
    # import lib.account
    obj = __import__("lib."+ m, fromlist=True)   #fromlist=True把lib拼接查找函数，否则查找到lib就停止了(调用lib目录模块)
    if hasattr(obj, f):                    #判断obj模块中是否有函数，有否为真，继续，没有报404
        func = getattr(obj, f)            #获取obj模块的函数
        func()                            #执行obj模块的函数
    else:
        print(‘404‘)

if __name__ == ‘__main__‘:
    run()
   
   
   
   
   
--manager.py
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang

def order():
    print(‘炫酷的订单页面‘)
   
   
   
   
--commons.py   
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang

def home():
    print(‘炫酷主页面‘)
   
   
   
--account.py
#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
def login():
    print(‘炫酷登录页面‘)

def logout():
    print(‘炫酷退出页面‘)
       
       
       
结果
请输入要访问的url:manager/order
炫酷的订单页面

获得我程序的根目录    （跨目录使用模块）
import sys
import os
#os.path.abspath 获得程序的绝对路径
#os.path.dirname 获取上级目录
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))  #os.path.abspath 获得程序的绝对路径
#print(sys.path)

跨目录导入模块
    base_dir=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))    #定位我程序的根目录
    sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))  #将我的目录追加到sys.path

import os
import sys
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from b import b1 as nb
nb.b()

程序实现
a
---a1.py
    def a():
        print(‘aaa‘)
b
---b1.py
    def b():
        print(‘bbb‘)

c
---test.py
    import os
    import sys
    sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))    # 一层层找
    from b import b1 as nb                        #导入b目录的b1程序,并别名
    nb.b()                                        #执行别名nb.b()  就是b目录中b1.py中的b函数

结果
bbb

当执行脚本时相等，别人调用时不执行(因为脚本名和__main__不相等)
__name__ == ‘__main__‘:

老师博客：
http://www.cnblogs.com/wupeiqi/articles/5501365.html

进度百分比
import sys
import time

def view_bar(num, total):
    rate = float(num) / float(total)
    rate_num = int(rate * 100)
    r = ‘\r%d%%‘ % (rate_num, )
    sys.stdout.write(r)
    sys.stdout.flush()

if __name__ == ‘__main__‘:
    for i in range(0, 100):
        time.sleep(0.1)
        view_bar(i, 100)

进度百分比完整
import sys
import time

def view_bar(num, total):
    rate = num / total
    rate_num = int(rate * 100)
    r1 = ‘\r%s>%d%%‘ %("="*num, rate_num)
    sys.stdout.write(r1)
    sys.stdout.flush()
   
if __name__ == ‘__main__‘:
    # r = ‘ %d%%‘ % (1, )
    # print(r)
    # 0 - 100
    for i in range(0, 101):
        time.sleep(0.1)
        view_bar(i, 100)

重要
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被

os.getcwd()                 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")         改变当前脚本工作目录；相当于shell下cd
os.curdir                   返回当前目录: (‘.‘)
os.pardir                   获取当前目录的父目录字符串名：(‘..‘)
os.makedirs(‘dir1/dir2‘)    可生成多层递归目录
os.removedirs(‘dirname1‘)   若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir(‘dirname‘)         生成单级目录；相当于shell中mkdir dirname
os.rmdir(‘dirname‘)         删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir(‘dirname‘)       列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()                 删除一个文件
os.rename("oldname","new")  重命名文件/目录os.stat(‘path/filename‘)    获取文件/目录信息
os.sep                      操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep                  当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep                  用于分割文件路径的字符串
os.name                     字符串指示当前使用平台。win->‘nt‘; Linux->‘posix‘
os.system("bash command")   运行shell命令，直接显示
os.environ                  获取系统环境变量
os.path.abspath(path)       返回path规范化的绝对路径
os.path.split(path)         将path分割成目录和文件名二元组返回
os.path.dirname(path)       返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path)      返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)        如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)         如果path是绝对路径，返回True
os.path.isfile(path)        如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)         如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)      返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)      返回path所指向的文件或者目录的最后修改时间

#!/usr/bin/env python
#-*- coding:utf-8 -*-
# Author:Minghu Wang
"""
我是注释
"""

print(__doc__)

__cached__
from bin import admin
print(__file__)
print(__package__)
print(admin.__package__)
只有执行当前文件时候，当前文件的特殊变量 __name__ == "__main__"
__name__ == __main__

def run():
    print(‘run‘)

if __name__ == "__main__":
    run()
import os
print(os.pathsep)

hashlib

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

import hashlib

# ######## md5 ########
hash = hashlib.md5()
# help(hash.update)
hash.update(bytes(‘admin‘, encoding=‘utf-8‘))
print(hash.hexdigest())
print(hash.digest())

######## sha1 ########
hash = hashlib.sha1()
hash.update(bytes(‘admin‘, encoding=‘utf-8‘))
print(hash.hexdigest())

# ######## sha256 ########
hash = hashlib.sha256()
hash.update(bytes(‘admin‘, encoding=‘utf-8‘))
print(hash.hexdigest())

# ######## sha384 ########
hash = hashlib.sha384()
hash.update(bytes(‘admin‘, encoding=‘utf-8‘))
print(hash.hexdigest())

# ######## sha512 ########
hash = hashlib.sha512()
hash.update(bytes(‘admin‘, encoding=‘utf-8‘))
print(hash.hexdigest())

以上加密算法虽然依然非常厉害，但时候存在缺陷，
即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。
#Md5加码
import hashlib
obj = hashlib.md5(bytes(‘kfdsjfkjsafkj‘,encoding=‘utf-8‘))    #第二次加密码，防止撞库
obj.update(bytes(‘123‘,encoding=‘utf-8‘))                        #给字节123加密码
result = obj.hexdigest()                                      #输出md5值                   
print(result)

结果
f4d91bff1af010c7161ce872447977b5

       
re        
正则表达式       
    字符：
    . 匹配除换行符以外的任意字符
    \w 匹配字母或数字或下划线或汉字
    \s 匹配任意的空白符
    \d 匹配数字
    \b 匹配单词的开始或结束
    ^ 匹配字符串的开始
    $ 匹配字符串的结束

次数：
    * 重复零次或更多次
    + 重复一次或更多次
    ? 重复零次或一次
    {n} 重复n次
    {n,} 重复n次或更多次
    {n,m} 重复n到m次
    分组：
        去已经匹配到的数据中再提取数据
       
       
       
# match，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None       
# search,浏览整个字符串去匹配第一个，未匹配成功返回None
# findall，获取非重复的匹配列表；如果有一个组则以列表形式返回，且每一个匹配均是字符串；如果模型中有多个组，则以列表形式返回，且每一个匹配均是元祖；
# sub，替换匹配成功的指定位置字符串
# split，根据正则匹配分割字符串

s="web site is http://www.python.com"       
       
#search  匹配查找，直到找到第一个匹配为止，即不向下查找，匹配任意位置
re.search(‘w{3}\..*\..{2,4}‘,s)
a=re.search(‘w{3}\..*\..{2,4}‘,s)
a.group()
a=re.search(‘(w{3})\.(.*\.)(.{2,4})‘,s) #分组抽取
a.group(1)  #回显组1
a.group(2)
a.group(3)

#match  匹配开始，只从开头查找匹配
s="aaa   www.python.com"
a=re.match(‘(w{3})\.(.*\.)(.{2,4})‘,s)   #无法匹配，因为不是以www开头
print(a)
print(a.group())  #显示所有组

s="www.python.com"
a=re.match(‘(w{3})\.(.*\.)(.{2,4})‘,s)   #无法匹配，因为不是以www开头
print(a)
print(a.group())  #显示所有组

结果
<_sre.SRE_Match object; span=(0, 14), match=‘www.python.com‘>
www.python.com

#re.findall – 所有匹配对象
xx=‘fdsafa  abc djfdksaf fdskjfsjalf abc  sdkfjsalf abc‘
a = re.findall(‘abc‘,xx)  #abc全部回显
print(a)

结果
[‘abc‘, ‘abc‘, ‘abc‘]

#search ,  match , findall 综合例子
import re
s="foo bar foo abc foo"           #以foo开头
a = re.match(‘foo‘,s).group()      #可以查找到，因为以foo开头
b = re.search(‘foo‘,s).group()     #可以匹配，因为有foo字符
c = re.findall(‘foo‘,s)            #可以匹配所有

print(a)
print(b)
print(c)

结果
foo
foo
[‘foo‘, ‘foo‘, ‘foo‘]

s="xxx bar foo abc foo"   #不以foo开头测试
re.match(‘foo‘,s).group()   #会报错，无法匹配，因为不是以foo开头
re.search(‘foo‘,s).group()  #可以匹配，因有foo字符

#多重选择匹配
import re
s="web site is http://www.python.com "
a=re.search(‘(w{3})\.(.*\.)(.{cn|com|org|net})‘,s)
print(a.group())

结果
www.python.com

#re.compile 将正则表达式编译成对象，使用对象进行匹配

例子：
# encoding: UTF-8
import re
pattern = re.compile(r‘hello‘) # 将正则表达式编译成Pattern对象
match = pattern.match(‘hello world!‘)   # 使用Pattern匹配文本，获得匹配结果，无法匹配时将返回None
if match:
      print(match.group()) # 使用Match获得分组信息
### 输出 ###
hello

#re.sub 匹配替换

import re
s = ‘100 BROAD‘
a=re.sub(‘ROAD$‘, ‘RD.‘, s)
print(a)

结果
100 BRD.

import re
k = ‘100 BRROAD  ROAD‘
a = re.sub(‘\\bROAD$‘,‘RD.‘,k)    #有边界匹配替换
print(a)

结果
100 BRROAD  RD.

import re
s = ‘100 BRROAD  ROAD‘
a = re.sub(r‘\bROAD$‘,‘RD.‘,s)   #r为原始字符串，字符串中的所有字符都不转义
b = re.sub(r‘\bROAD\b‘,‘RD.‘,s)  #只匹配两个\b中间字符

print(a)
print(b)

结果
100 BRROAD  RD.
100 BRROAD  RD.

       
正则综合练习

re.findall(‘alex‘,‘jsfjsfalexkjfkdslajfla‘)    
re.findall(‘al.x‘,‘jsfjsfaltxkjfkdslajfla‘)    #.x单个匹配

import re
origin = "hasaabc dfuojqw halaabc m098u2934l"
# r = re.match("h\w+", origin)
# r = re.match("h(\w+)", origin)
r = re.findall("h(\w+)a(ab)c", origin)
print(r)
print(r.group())     # 获取匹配到的所有结果
print(r.groups())    # 获取模型中匹配到的分组结果
print(r.groupdict()) # 获取模型中匹配到的分组结果

# 无分组
origin = "hello alex bcd alex lge alex acd 19"
r = re.split("alex", origin, 1)
print(r)

r = re.split("a(le)x", origin, 1)
print(r)

结果
[‘hello ‘, ‘ bcd alex lge alex acd 19‘]
[‘hello ‘, ‘le‘, ‘ bcd alex lge alex acd 19‘]

分组
    去已经匹配到的数据中再提取数据
# 有分组，给分隔字符整个加括号
import re
origin = "hello alex bcd alex lge alex acd 19"
r1 = re.split("(alex)", origin, 1)    #用alex做分隔并取其值
print(r1)
r2 = re.split("(al(ex))", origin, 1)   #取分隔字符中的值
print(r2)

结果
[‘hello ‘, ‘alex‘, ‘ bcd alex lge alex acd 19‘]
[‘hello ‘, ‘alex‘, ‘ex‘, ‘ bcd alex lge alex acd 19‘]

时间： 2024-08-27 13:21:10

python 第六天的相关文章

python第六天

今天学习第一模块的最后一课课程--函数: python的第一个函数: 1 def func1(): 2 print('第一个函数') 3 return 0 4 func1() 函数可返回各种数据类型: 同时返回多种类型时,将是返回一元组: 1 def func2(): 2 return 1,"二",[3,'4'],{'五':'六','七':8}#返回多种数据类型 3 data=func2() 4 print(data) 函数参数的调用: 1,位置调用:编写时需要一一对应,如果少了,或是

python第六天：一些常用函数，面向对象入门

上节回顾 yield的表达式用法→协程函数 只要函数内有yield关键字,函数名得到的结果就是生成器,表达式形式的生成器就是在整个生成的过程中使用send传值. 面向过程 面向过程的是编程范式的一种,是流水线式的编程范式,一般来说逻辑比较清晰,但是可扩展性差,牵一发而动全身. 匿名函数 匿名函数定义的时候要使用关键字lambda,格式如下 lambda val:val1,其中val是传的参数,val1是返回值. 递归函数   递归调用:在函数的调用过程中,直接或者间接的调用本身的话就是递归函数.

Python第六天(字符串转换)

Python字符串转换 int函数将字符串转换为数字 str函数将数字转换为字符串 >>> int('100') 100 >>> str(100) '100' repr函数可以将一个对象转换为其他字符串形式,然后这些返回的 对象将作为代码的字符串 内置的函数可以把浮点数转换为字符串 或者把字符串转化为浮点数 >>> str(1.1) '1.1' >>> float('1.1') 1.1000000000000001 字符串代码转换 o

python第六天面向对象的编程

类和实例: 定义 class  类名(父类名):  其中object是所有类的祖先类 __int__方法(两个下划线)表示把属性绑定到类上,如下把name.score等属性绑上去 注意类中所有方法的第一个参数都是self表示对象本身,调用的时候不需要传递这个参数 class Student(object): def __init__(self, name, score): self.name = name self.score = score 限制访问:如果在实例的变量前加上两个下划线,那么此变

python第六天，元组

Python的元组与列表类似,不同之处在于元组的元素不能修改. 元组使用小括号,列表使用方括号. 元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可. tup1 = ('physics', 'chemistry', 1997, 2000) tup2 = (1, 2, 3, 4, 5 ) tup3 = "a", "b", "c", "d" 创建空元组 tup1 = () tps: 元组中只包含一个元素时,需要在元素后面添

Python第六天(字符串格式化表达式)

字符串格式化表达式 格式化字符串 在%操作符的左侧放一个需要进行格式化的字符串,以%开头 在%操作符的右侧放一个对象,这些对象就是左边进行格式化字符串转换的字符 >>> 'I am %s I am %d old!' % ('wuang',22) 'I am wuang I am 22 old!' 字符串格式化代码 s 字符串 rs,使用repr,不是str c 字符 d 十进制 i整数 u 无号 o  八进制 x 十六进制 Xx,打印大写 e 浮点指数 E e,打印大写 f  浮点十进制

Python第六天-----面向对象

说面向对象之前,我们有必要提一下我们的老朋友函数,函数作为面向对象之前的产物,从诞生的那天注定了他的不平凡,早在C语言中根本没有面向对象这种概念,但是依旧C语言活的好好的.所以面向对象并不是必须的,面向对象的存在只是为了简化过程. 我们不妨考虑一下,假设我们不知道面向对象,而此时我们需要写人,此时采用传统函数式编程,我们需要考虑人有多少属性,例如:人有头.胳膊腿等等等等.按照传统函数式的方法我们只能定义字典来去实现 people1 = { "head":1, "eyes&qu

Python第六天(字符串-索引和分片)

索引和分片 >>> wu = 'wuang' >>> wu[0] 'w' >>> wu[1] 'u' >>> wu[1:] 'uang' >>> wu[1:3] 'ua' >>> wu[-1] 'g' >>> wu[:-1] 'wuan' 索引: wu[i] 第一个元素的偏移为0 [0]:第一个元素 [-1]:最后一个元素 分片wu[i:j] 上边界(i)不包含 如果i没给出,默认

Python第六天(字符串修改)

字符串修改 >>> wu 'wuang' >>> wu = wu[:2] + 'zhang' >>> wu 'wuzhang' >>> wu 'wuzhang' 直接使用replace修改替换 >>> wu = wu.replace('uzh','u') >>> wu 'wuang' >>> 'zhangsAn'.replace('A','a') 'zhangsan' 替换一次 &