Python之路【第八篇】:Python

1、最大的好处就是大大提高了代码的可维护性。
2、编写代码不必从零开始。当一个模块编写完成，就可以被其他地方调用。我们在编写程序的时候，也经常饮用其他模块，包括Python内置的模块和来自第三方的模块。

1、python标准库
2、第三方模块
3、应用程序自定义模块

import module1,[module2[,...moduleN]]

import sys
print(sys.path)

运行结果如下：
['G:\\python_s3\\day21', 'G:\\python_s3', 'C:\\Python35\\python35.zip', 'C:\\Python35\\DLLs', 'C:\\Python35\\lib', 'C:\\Python35', 'C:\\Python35\\lib\\site-packages', 'D:\\Program Files (x64)\\pycharm软件安装\\config\\PyCharm 2018.3\\helpers\\pycharm_matplotlib_backend']

from modname import name1[,name2[, ... nameN]]

from modname import *

1、import test
2、from test import add

1、如果不同的人编写的模块名相同怎么办？为了避免模块名冲突，Python又引入了按目录来组织模块的方法，成为包(Package)。
举个例子：一个abc.py的文件就是一个名字叫abc的模块，一个simon.py的文件就是一个叫simon的模块。
现在，假设我们的abc和simon这两个模块名字和其他模块起冲突了，于是我们可以通过包来组织模块，从而避免冲突。方法就是选择一个顶层包名：


2、引入了包以后，只要顶层的包名不与别人冲突，那所有模块都不会与别人冲突。现在，view.py模块的名字就变成了hello_django.app01.views，类似的，manage.py的模块名则是hello_django.manage。

请注意，每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录(文件夹)，而不是一个包。__init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，而它的模块名就是对应包的名字。

#1--------------------------------
在node1中import hello是找不到的，有人说可以找到呀，那是因为你的pycharm为你把myapp这一层路径加入到了sys.path里面，所以可以找到，然而程序一旦在命令行运行，则报错。有同学问那怎么办？简单啊，自己把这个路径加进去不就OK啦：


import sys,os
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR) #临时修改
import hello
hello.hello1()

#2、--------------
if __name__=='__main__':
    print('ok')

##-------------cal.py
def add(x,y):
 
    return x+y
##-------------main.py
import cal      #from module import cal
 
def main():
 
    cal.add(1,2)
     
##--------------bin.py
from module import main
 
main.main()

# from module import cal 改成 from . import cal同样可以，这是因为bin.py是我们的执行脚本，
# sys.path里有bin.py的当前环境。即/Users/simon/Desktop/whaterver/project/web这层路径，
# 无论import what ,  解释器都会按这个路径找。所以当执行到main.py时，import cal会找不到，因为
# sys.path里没有/Users/simon/Desktop/whaterver/project/web/module这个路径，而
#  from  module/.  import cal 时，解释器就可以找到了。

在Python中，通常有这几种方式来表达时间：
1、时间戳(timestamp):通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”,返回的是float类型。
2、格式化的时间字符串
3、元祖(struct_time):struct_time元祖共有9个元素：(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

import time

#1、time():  返回当前时间的时间戳
print(time.time())

运行结果如下：
C:\Python35\python3.exe G:/python_s3/day21/example.py
1555996405.5020845

#2、localtime(secs):  将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。
print(time.localtime())

运行结果如下：
C:\Python35\python3.exe G:/python_s3/day21/example.py
time.struct_time(tm_year=2019, tm_mon=4, tm_mday=23, tm_hour=13, tm_min=18, tm_sec=9, tm_wday=1, tm_yday=113, tm_isdst=0)

#3、gmtime([secs])和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区(0时区)的struct_time。
print(time.gmtime())

运行结果如下：
C:\Python35\python3.exe G:/python_s3/day21/example.py
time.struct_time(tm_year=2019, tm_mon=4, tm_mday=23, tm_hour=5, tm_min=21, tm_sec=25, tm_wday=1, tm_yday=113, tm_isdst=0)

#4、mktime(t):  将一个struct_time转化为时间戳
print(time.mktime(time.localtime())) #

运行结果如下：
C:\Python35\python3.exe G:/python_s3/day21/example.py
1555998160.0

#5、asctime([t]):  把一个表示时间的元祖或者struct_time表示为这种形式：'Tue Apr 23 13:45:49 2019'

#如果没有参数，将会将time.localtime()作为参数传入。
print(time.asctime())

运行结果如下：
C:\Python35\python3.exe G:/python_s3/day21/example.py
Tue Apr 23 13:45:49 2019


#6、ctime([secs]):  把一个时间戳(按秒计算的浮点数)转化为time.asctime()的形式。如果参数未给或者为None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。

print(time.ctime())  #Tue Apr 23 14:02:45 2019

print(time.ctime(time.time()))  #Tue Apr 23 14:03:50 2019


#7、strftime(format[,t])  #把一个代表时间的元祖或者struct_time(如由time.localtime()和time.gmtime()返回)  转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个元素过界，ValueError的错误将会被抛出。

print(time.strftime("%Y-%m-%d %X",time.localtime()))  #2019-04-23 14:11:12


#8、time.strptime(string[, format])  #把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作。

print(time.strptime('2019-04-23 14:15:07', '%Y-%m-%d %X'))

输出结果为：
time.struct_time(tm_year=2019, tm_mon=4, tm_mday=23, tm_hour=14, tm_min=15, tm_sec=7, tm_wday=1, tm_yday=113, tm_isdst=-1)

#在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。

#9、sleep(sesc)
print(time.sleep(3))   #线程推迟指定的时间运行，单位为秒。


#10、clock

# 这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是"进程时间"，它是用秒表示的浮点数(时间戳)。而在windows中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间，即两次时间差。

import random

ret=random.random()
# ret=random.randint(1,3)  #[1,3]
# ret=random.randrange(1,3)  #[1,3]
# ret=random.choice([11,22,33,44,55])
# ret=random.sample([11,22,33,44,55],2)
# ret=random.uniform(1,4)
# print(ret)
# ret=[1,2,3,4,5]
# random.shuffle(ret)
# print(ret)

item=[1,3,5,7,9]
random.shuffle(item)
print(item)

import random
def v_code():

    ret=""
    for i in range(5):
        num=random.randint(0,9)
        alf=chr(random.randint(65,122))

        s=str(random.choice([num,alf]))
        ret+=s
    return ret
print(v_code())

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

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

os.cudir  #返回当前目录：(' . ')

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

os.makedirs('dirname1/dirname2')  #可生成多层递归目录

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

os.mkdir('dirname')  #生成单级目录，相当于linux中mkdir dirname

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

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

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

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

os.stat('path/filename')   #获取文件/目录信息
例：
print(os.stat("sss.py"))
C:\Python35\python3.exe G:/python_s3/day22/os_test.py
os.stat_result(st_mode=33206, st_ino=11821949021847676, st_dev=2159804260, st_nlink=1, st_uid=0, st_gid=0, st_size=10, st_atime=1556025329, st_mtime=1556025329, st_ctime=1556025302)

os.sep   #输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"

os.linesep  #输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"

os.pathsep   #输出用于分隔文件路径的字符 win下为; ,Linux下为：

os.name   #输出字符串指示当前使用平台。win-->'nt'; Linux-->'posix'

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

os.environ   #获取系统环境变量
例：
print(os.environ)
environ({'FP_NO_HOST_CHECK': 'NO', 'PUBLIC': 'C:\\Users\\Public', 'PYCHARM': 'D:\\Program Files (x64)\\pycharm软件安装\\config\\PyCharm 2018.3\\bin;', 'COMPUTERNAME': 'DELL-PC', 'PYTHONPATH': 'G:\\python_s3;D:\\Program Files (x64)\\pycharm软件安装\\config\\PyCharm 2018.3\\helpers\\pycharm_matplotlib_backend', 'PYCHARM_HOSTED': '1', 'PYCHARM_MATPLOTLIB_PORT'

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

os.path.split(path)   #将path分割成目录和文件名二元组返回
例：
print(os.path.split(r"G:\python_s3\day22\sss.py"))
输出结果：
('G:\\python_s3\\day22', 'sss.py')

os.path.dirname(path)   #返回path的目录。其实就是os.path.split(path)的第一个元素
例：
print(os.path.dirname(r"G:\python_s3\day22\sss.py"))
输出结果：
G:\python_s3\day22

os.path.basename(path)   #返回path最后的文件名，如果path以/ 或 \结尾，那么就会返回空值。即os.path.split(path) 的第二个元素
例：
print(os.path.basename(r"G:\python_s3\day22\sss.py"))
输出结果：
sss.py

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,paht2[,  ...])   #将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
例：
a="G:\python_s3\day22"
b="sss.py"

print(os.path.join(a,b))
输出结果：
G:\python_s3\day22\sss.py

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

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

#1、sys.argv            命令行参数List,第一个元素是程序本身路径
#2、sys.exit(n)         退出程序，正常退出时exit(0)
#3、sys.version        获取Python解释程序的版本信息
#4、sys.maxint         最大的Int值
#5、sys.path            返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
#6、sys.platform       返回操作系统平台名称
#7、sys.stdout.write("please:")    #标准输出，引出进度条的例子，注意，在py3上不行，可以用print代替
#8、sys.stdout.flush()        #刷新缓存

##进度条
import time,sys
for i in range(10):
    sys.stdout.write('#')
    time.sleep(1)
    sys.stdout.flush()

输出结果：
C:\Python35\python3.exe G:/python_s3/day22/sys_test.py
##########

dic='{"name":"simon"}'
f=open('hello','w')
f.write(dic)

f_read=open('hello','r')
data=f_read.read()
print(type(data)) #读到的文件内容是字符串<class 'str'>
data=eval(data) #将字符串转成字典
print(data['name']) #读取字典name对应的值

输出结果为：
C:\Python35\python3.exe G:/python_s3/day22/json&pickle.py
<class 'str'>
simon

#1、通过eval处理，只能讲字符串转成字典
dic='{"name":"simon"}'
# f=open('hello','w')
# f.write(dic)

f=open('hello','r')
data=f.read()
print(type(data)) #读到的文件内容是字符串<class 'str'>
data=eval(data)      ##将字符串转成字典
print(data["name"])  #读取字典name对应的值

打印：
<class 'str'>
simon

#2、通过json模块处理python字典
import json
dic={"name":"simon"}   #----------->{"name":"simon"}-------'{"name":"simon"}'

dic_str=json.dumps(dic)
print(dic_str)   #{"name": "simon"}
print(type(dic_str))   #<class 'str'>
f=json.loads(dic_str)  #将json字符串通过loads转成字典的过程
print(f)  #{'name': 'simon'}
print(type(f))  #<class 'dict'>
print(f["name"])  #simon

打印：
{"name": "simon"}
<class 'str'>
{'name': 'simon'}
<class 'dict'>
simon

#2、通过json模块处理python数字
i=8    
i=json.dumps(i)  #无论是字典、字符串、列表、整型，json.dumps都会把无论是单引号还是双引号多会转成双引号，然后加单引号变成json字符串
print(i)
p=json.loads(i)
print(type(p))
打印：
8
<class 'str'>
<class 'int'>

#3、通过json模块处理字符串
s='hello'              #----------->"hello"----------->'"hello"'，json.dumps都会把无论是单引号还是双引号都会转成双引号，然后加单引号变成json字符串
s=json.dumps(s)
print(s)
p=json.loads(s) #通过json.loads将dumps后的json字符串转为json支持的数据类型
print(p)
print(type(p))

打印：
"hello"
hello
<class 'str'>

#4、通过json模块处理列表
l=[1,2,3]              #----------->"[1,2,3]"
l=json.dumps(l)
print(l)
print(type(l))
p=json.loads(l)
print(p)  #转成json的列表类型
print(type(p))

打印：
[1, 2, 3]
<class 'str'>
[1, 2, 3]  #处理后的json列表
<class 'list'>

#5、对于文件的操作dumps方法可以用dump替代
f_read=open("new_hello","r")
data=json.loads(f_read.read())   #等价于data=json.load(f_read)
print(data)
print(type(data))
print(data["name"])

#注意点：
import json
#dct="{'1':111}"#json 不认单引号
#dct=str({"1":111})#报错,因为生成的数据还是单引号:{'one': 1}

dct='{"1":"111"}'
print(json.loads(dct))

#conclusion:
#        无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要dumps的数据才能loads

注意点

#--------------------pickle------------------
import pickle

dic={'name':'william','age':24,'sex':'male'}
print(type(dic))  #<class 'dict'>

j=pickle.dumps(dic)
print(type(j))   #<class 'bytes'>

f = open('序列化对象_pickle','wb')  #注意是w是写入str，wb是写入bytes，j是'bytes'
f.write(j)       #------------------------等价于pickle.dump(dic,f)
# pickle.dump(dic,f)
f.close()

#----------------------------反序列化

f = open('序列化对象_pickle','rb')
data = pickle.loads(f.read())  #等价于data=pickle.load(f)

print(data['age'])  #24

import shelve

f = shelve.open(r'shelve')  #目的：将一个字典放入文本 f={}

# f['stu1_info']={'name':'simon','age':'18'}
# f['stu2_info']={'name':'simonn','age':'20'}
# f['school_info']={'website':'baidu.com','city':'beijing'}
#
#
# f.close()

print(f.get('stu1_info')['age'])   #18

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

xml数据

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)
 
#遍历xml文档
for child in root:
    print(child.tag, child.attrib)
    for i in child:
        print(i.tag,i.text)
 
#只遍历year 节点
for node in root.iter('year'):
    print(node.tag,node.text)
#---------------------------------------

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
 
#修改
for node in root.iter('year'):
    new_year = int(node.text) + 1
    node.text = str(new_year)
    node.set("updated","yes")
 
tree.write("xmltest.xml")
 
 
#删除node
for country in root.findall('country'):
   rank = int(country.find('rank').text)
   if rank > 50:
     root.remove(country)
 
tree.write('output.xml')

import xml.etree.ElementTree as ET
 
 
new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = '33'
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = '19'
 
et = ET.ElementTree(new_xml) #生成文档对象
et.write("test.xml", encoding="utf-8",xml_declaration=True)
 
ET.dump(new_xml) #打印生成的格式

import re
ret=re.findall('si..n','qwerwrsimonreorerge') #['simon']
print(ret)

ret=re.findall('^s...n','simonreorserpnerge') #['simon']
print(ret)

ret=re.findall('s...n','simonreorserpnerge') #['simon', 'serpn']
print(ret)

ret=re.findall('s...n$','simonreorserpnergesrren') #['srren']
print(ret)

ret=re.findall('^s*','sssasdfgdsjjuresssss')  #['sss'],*:表示0到无穷次  +：表示1到无穷次
print(ret)

ret=re.findall('alex*','asdfhfalexxx')  #
print(ret) #['alexxx']

ret=re.findall('alex+','asdfhfalexxx')  #[1,+oo]
print(ret)  #['alexxx']

ret=re.findall('alex*','asdfhfale')  #['ale']
print(ret)

ret=re.findall('alex+','asdfhfale')  #[]
print(ret)

ret=re.findall('simon?','asdhfsimonnn')  #[0,1],?:表示匹配0到1个
print(ret) #['simon']

ret=re.findall('simon{1,3}','asdhfsimonnnnnn')  #['simonnn'] 贪婪匹配
print(ret)

ret=re.findall('abc*?','abcccccc')
print(ret)  #['ab']

##---------------------------字符集[]
ret=re.findall('www[simon  baidu]','wwwbaidu')
print(ret)

ret=re.findall('x[yz]','xyuuuu')
print(ret)

ret=re.findall('x[yz]','xyuuxzuu') #['xy', 'xz']
print(ret)

ret=re.findall('x[yz]p','xypuuxzpuu') #['xyp', 'xzp']
print(ret)

ret=re.findall('x[y,z]p','xypuuxzpux,pu') #['xyp', 'xzp', 'x,p']
print(ret)

ret=re.findall('q[a*z]','xypuuxzpqaa') #['qa']
print(ret)

ret=re.findall('q[a-z]*','quouuiuni') #['quouuiuni']
print(ret)

ret=re.findall('q[a-z]*','quouuiuni9') #['quouuiuni']
print(ret)

ret=re.findall('q[0-9]*','q8910uouuiuni9') #['q8910']
print(ret)

ret=re.findall('q[0-9]*','q8910uouuiuniq9') #['q8910', 'q9']
print(ret)

ret=re.findall('q[^a-z]*','q821') #['q821']
print(ret)

\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  匹配一个特殊字符边界，比如空格 ，&，＃等

import re
print(re.findall("^I","hello I am LIST"))
print(re.findall(r"I\b","hello I am LIST")) #['I']
print(re.findall("I\\b","hello I am LIST")) #['I']

print(re.findall(r"c\\l","abc\lerwt")) #['c\\l']
print(re.findall("c\\\\l","abc\lerwt")) #['c\\l']

m = re.findall(r'(ad)+','add')
print(m)

ret=re.search('(?P<id>\d{2})/(?P<name>\w{3})','23/com')
print(ret.group()) # 23/com
print(ret.group('id')) #23

ret=re.search("(?P<name>[a-z]+)\d+","123simon27zhurui24william45").group()
print(ret) #simon27

ret=re.search("(?P<name>[a-z]+)\d+","123simon27zhurui24william45").group('name')
print(ret) #simon

ret=re.search("(?P<name>[a-z]+)(?P<age>\d+)","123simon27zhurui24william45").group('age') #.group是固定格式
print(ret) #27

ret=re.search('(ab)|\d','rabhdg8sdgrui') #ab
print(ret.group()) 

import re

#方法1
print(re.findall("s","simon zhu"))   #['s']，返回所有满足匹配条件的结果，放在列表里

#方法2
ret=re.search("(?P<name>[a-z]+)(?P<age>\d+)","123simon27zhurui24william45").group('age') #函数会在字符串内查找模式匹配，只找到第一个匹配然后返回一个包含匹配信息的对象，该对象可以通过调用group()方法得到匹配的字符串，如果字符串没有匹配，则返回None
print(ret) #27

#方法3
print(re.match("\d+","23simon24zhurui23will78")) #同search,不过尽在字符串开始处进行匹配

#方法4
ret=re.split("[ab]","abcd") #先按'a'分割得到' ' 和'bcd'，在对' '和'bcd'分别按'b'分割
print(ret) #['', '', 'cd']

#方法5
 ret=re.sub('\d','abc','simon7zhurui9',1)
print(ret) #simonabczhurui9

ret=re.subn('\d','abc','alvin5yuan6')
print(ret)#('alvinabcyuanabc', 2)

#方法6
obj=re.compile('\d{3}')
ret=obj.search('abc123eeee')
print(ret.group())#123

ret=re.finditer('\d','ds3sy4784a')
print(ret)        #<callable_iterator object at 0x10195f940>
print(next(ret).group())
print(next(ret).group())

ret=re.findall('www.(baidu|oldboy).com','www.oldboy.com')
print(ret)#['oldboy']     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可
 
ret=re.findall('www.(?:baidu|oldboy).com','www.oldboy.com')
print(ret)#['www.oldboy.com']


ret=re.findall("www\.(baidu|163)\.com","fddsfsfdwww.baidu.comrerggetbbvfd")
print(ret) #['baidu']

ret=re.findall("www\.(?:baidu|163)\.com","fddsfsfdwww.baidu.comrerggetbbvfd")
print(ret) #['www.baidu.com']

import re

print(re.findall("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>"))
print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>"))
print(re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>"))

#匹配出所有的整数
import re

#ret=re.findall(r"\d+{0}]","1-2*(60+(-40.35/5)-(-4*3))")
ret=re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")
ret.remove("")

print(ret)