day19:常用模块(collections,time,random,os,sys)

1，正则复习，re.S,这个在用的最多，re.M多行模式，这个主要改变^和$的行为，每一行都是新串开头，每个回车都是结尾。re.L 在Windows和linux里面对一些特殊字符有不一样的识别，re.L 是根据当前的操作系统来识别，这个不推荐使用，他就不一样了。正常还是走我们的记得意思，re.U 这个对于ASCII码是一样的，对于中文才使用Unicode，re.X和re.M有点像

import re
ret = re.findall('.*d+','hsd739y8kk  
s99sihf99 g9o3y')
print(ret)
# ['hsd739y8', 's99sihf99 g9o3']
ret = re.findall('.*d+','hsd739y8kk  
s99sihf99 g9o3y',re.S)
print(ret) #注意加了flag换行也给匹配了就
# ['hsd739y8kk  
s99sihf99 g9o3']

2，尖角号必须开头，$符号，必须结尾，不然就是一个错误的正则

3，分组，在正则里面，因为想对多个字符组整体两次约束的，在re模块里面，分组是有优先的(findall,split)

4，|，从左到右匹配，只要匹配上就不继续匹配了，所以应该要把长的放在前面

5，[^],除了分组里面的其他都匹配

6，转义问题，特殊字符，比方说匹配星号要用*这样才能匹配

# 前面加上r 就没有问题了，建议都加上
ret = re.findall('\\s','s')  #正则需要转义，Python也需要转义的
print(ret)
# ['\s']
ret = re.findall(r'\s',r's')
print(ret)
# ['\s']

ret = re.findall('*','*')
print(ret)

ret = re.findall(r'*','*')
print(ret)
# 字符组里面是没有两次这一说的，说以正则里面放在字符组里面的特殊字符可以直接匹配，不需要转义
ret = re.findall('[*]','*')
print(ret)

7，但是字符组里面的减号要注意一下，

# 正则里面，只要是特殊字符就都给转义了，就没有问题
ret = re.findall('[-]','-')
print(ret) #  ['-']

ret = re.findall('[1-9]','12-')
print(ret) # ['1', '2']

ret = re.findall('[1-9]','12-')
print(ret) #['1', '-']

8，正则里面默认是贪婪匹配，量词后面加问号就是非贪婪匹配了，惰性匹配，最常用的.*?abc,一直取，一直到遇到abc为止

9，re模块常用的函数，findall（返回列表），match（从头匹配），search（返回第一个匹配的），split，sub,subn,finditer(明知有很多匹配结果，但是不希望一次全部加载到内存里面，所以返回一个迭代器)，compile，返回编译对象，编译一次，多次使用

10，匹配标签练习题，分组取名，按照序号取分组里面的内容。

# 匹配标签
ret = re.search(r"<(?P<tag_name>w+)>w+</(?P=tag_name)>",r'<h1>hello</h1>')
# 尖角号就是一个字符，利用?P给分组起名字
# 获取的匹配结果可以直接group('名字')拿到对应的值，前面的命名，后面是用了这个分组名，里面的东西要一模一样。
print(ret.group())
print(ret.group('tag_name'))
print(ret.group(1))


ret = re.search(r"<(w+)>w+</1>",r'<h1>hello</h1>') # 这儿的r是必须写的，不1有特殊含义无法完成匹配,建议任何地方都要加上r
print(ret.group())
print(ret.group(1))   # 分组数字，如果不给分组起名字，也可以用序号来找到对应的组，表示要找的内容和前面的组内容一致。
# 匹配的结果，可以用group序号拿到对应的值

11，匹配所有整数，对自己真正想要的东西做分组，强行显示

# 匹配所有数字
ret=re.findall(r"-?d+(?:.d+)?","1-2*(60+(-40.35/5)-(-4*3))")
# ['1', '-2', '60', '-40.35', '5', '-4', '3']
print(ret)

# 匹配整数
ret=re.findall(r"-?d+.d*|(-?d+)","1-2*(60+(-40.35/5)-(-4*3))")  # 利用了分组优先，前面匹配到了，但是也要返回分组，分组是空，
# 分组的机制是由Python决定的，或约束的不是一个字符，是整个前面的，这个是正则决定的，
# ['1', '-2', '60', '', '5', '-4', '3']
print(ret)
ret.remove("")  # 这样就匹配到所有整数了
print(ret)

ret=re.findall(r'abc|efg',r'abc') # ['abc']
print(ret)
# ['1', '-2', '60', '5', '-4', '3']
ret=re.findall(r'abc|(efg)',r'abc')  # ['']  # 没匹配上硬要显示就是空，这个是Python的分组机制决定的
print(ret)

12，一些基本的匹配，匹配邮箱 https://blog.csdn.net/make164492212/article/details/51656638

# 邮箱匹配
# 实例1、只允许英文字母、数字、下划线、英文句号、以及中划线组成
ret = re.findall(r"^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(?:.[a-zA-Z0-9_-]+)+$",'shlisa@126.comh')
print(ret) # 取消分组优先需要
# ['shlisa@126.comh']

ret = re.search(r"^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(?:.[a-zA-Z0-9_-]+)+$",'bdjgiuugishlisa@126.comhkaslhfui')
print(ret.group()) # 取消分组优先需要
# bdjgiuugishlisa@126.comhkaslhfui

# 实例2、名称允许汉字、字母、数字，域名只允许英文域名,同样考虑分组优先的问题
# ^[A-Za-z0-9u4e00-u9fa5]+@[a-zA-Z0-9_-]+(.[a-zA-Z0-9_-]+)+$

13，其他常用的匹配

# 匹配12个月
# ret = re.findall('^(0?[1-9]|1[0-2])$','03')
# print(ret)

# 匹配31天
# ret = re.findall(r'^(?:(?:0?[1-9])|(?:(?:1|2)[0-9])|30|31)$','31')
# print(ret)

# 匹配qq号码，(腾讯QQ号从10000开始)
# ［1,9］[0,9]{4,}

# 匹配浮点数
# ^(-?d+)(.d+)?$   或者  -?d+.?d*

# 匹配汉字
# ^ [u4e00 -u9fa5]{0, }$ 

14，下面将模块，一共六个，collections,time,random,os,sys,序列化，除了collections其他都很重要，collections主要是为了多认识一些数据类型，了解一些数据结构相关的知识

序列化模块非常非常重要的。random用到了才重要

# collections python中的扩展数据类型
# random 随机数模块，抽奖呀，用到了很重要
# os 和操作系统打交道的模块
# sys 和Python解释器打交道的模块
# 序列化模块 Python中的数据类型和str转换的模块

# 自己建立的py文件不要和系统已经有的模块重名，会覆盖掉，模块本质就是一个py文件

15，模块起名最好是re_demo等等，总之不要和模块名字一模一样

16，collection模块，Python额外提供的数据类型namedtuple,deque,Counter,OrderedDict,defaultdict, 计数器了解一下就行，扩展的数据类型

from collections import namedtuple # 看到别人用，自己要认识

p = (1,2) # 之前的元祖来定义一个点的坐标很难看出来是一个坐标，但是用namedtuple就很直观，

# 二维坐标
Point = namedtuple('point',['x','y'])  # 列表里面的值是字符串格式，可命名元祖，除了坐标也可以描述圆
p = Point(1,2)
print(p.x)  # 1
print(p.y)  # 2
print(p) # point(x=1, y=2)

# 三维坐标
Point = namedtuple('point',['x','y','z'])  # 还可以表示三维的，几个都可以，看自己需要几个
p = Point(1,2,1)
print(p.x)  # 1
print(p.y)  # 2
print(p.z)
print(p) # point(x=1, y=2, z=1)

# 花色和数字
card = namedtuple('card',['suits','number'])
c1 = card('Hearts','2')
print(c1) # card(suits='Hearts', number='2')

17,deque双端队列，先来了解下queue，队列是一个链着一个的，但是列表不是链表，列表删第一个应该也很慢

# 列表，元祖
# 字典
# 集合，frozenset
# 字符串
# 堆栈，先进后出
# 队列，先进先出 FIFO first in first out 

import queue  # 一种数据类型
q = queue.Queue()
q.put([1,2,3]) # 放字典也可以，但是不能put一次放多个值，不支持
q.put(5)
q.put(6)
# print(q.get()) # 10 队列，先进先出
# print(q.get()) # 5
# print(q.get()) # 6
# print(q.get()) # 取完了，等在那里，程序不结束，这就是阻塞

print(q.qsize()) # 3

# for i in q :
#     print(i) # TypeError: 'Queue' object is not iterable

18,使用list存储数据的时候，按照索引来访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除的效率很低，deque是为了高效实现插入和删除操作的双向列表，适用于队列和栈

from collections import deque  # 只能从头或者从尾拿，有reverse方法，不能sort
q = deque(['a','b','c'])
q.append('x')  # 从后面放数据
print(q) # deque(['a', 'b', 'c', 'x'])
q.appendleft('y')  # 从前面放数据
print(q)  # deque(['y', 'a', 'b', 'c', 'x'])

deque.pop(q)  # 从后面取数据，返回值是pop出来的元素
print(q) # deque(['y', 'a', 'b', 'c'])
deque.popleft(q)  # 从前面取数据
print(q) # deque(['a', 'b', 'c'])

q.insert(2,'u')  # 插入的位置，插入的元素，可以插队，但是queue不能插队，双端队列可以插队
print(q) # deque(['a', 'b', 'u', 'c'])

19，Ordereddict,有序字典，会按照key插入的顺序排序，不是key本身排序，字典取值很快，但是比存成列表占内存，有序字典比一般的字典更占内存，很长的字典不适合用有序字典

购物车买东西用有序字典比较好

from collections import OrderedDict
d = dict([('a',1),('b',2),('c',3)])  # 字典也可以这样定义的，最不常用的一种方式，不是强转
print(d)  # {'a': 1, 'b': 2, 'c': 3},这种打印的话是随机的，因为key是无序的

od = OrderedDict([('a',1),('b',2),('c',3)])
print(od)  #  OrderedDict([('a', 1), ('b', 2), ('c', 3)])，key是有序的
print(od['a']) # 1
print(od['b']) # 2
print(od.keys()) # odict_keys(['a', 'b', 'c'])

for k in od.items():  # 用起来其实和字典是一样的，只是有序了
    print(k)

20，defaultdict，使用dict时如果key不存在会抛出keyerror，如果希望key不存在时返回一个默认值，那么就可以用defaultdict,以前的dict代码必须要加一次key是否in 字典的判断，代码会比较长

# 第一种写法：
result= {}
result.setdefault("key1",[])
# result["key1"] =[]
# result["key2"] =[]
result.setdefault("key2",[])
for i in li:

    if i < 66:
        result["key1"].append(i)
    else:
        result["key2"].append(i)

print(result)



# 第二种写法：
for i in li:
    if i > 66:
        if "key1" not in result:
            # result.setdefault("key1")
            result["key1"] = []
        result['key1'].append(i)
    else:
        if "key2" not in result:
            # result.setdefault("key1")
            result["key2"] = []
        result['key2'].append(i)

print(result)

from collections import defaultdict
values = [11,22,33,44,55,66,77,88,99,90]

dd = defaultdict(lambda :"N/A" )  # 这儿参数必须是一个callable的
dd['k1'] ='abc'
print(dd['k1'])  # abc
print(dd['k2'])  # N/A  不存在的key的value显示默认值

dd2 = defaultdict(list)
print(callable(list))  # True
print(dd2['k1']) # []

dd2 = defaultdict(dict)
print(callable(dict))  # True
print(dd2['k1']) #  {}

# dd2 = defaultdict(5) # TypeError: first argument must be callable or None
# print(callable(5))
# print(dd2['k1']) #

dd2 = defaultdict(lambda :5) # TypeError: first argument must be callable or None
print(callable(5))  # False
print(dd2['k1']) # 5

values = [11,22,33,44,55,66,77,88,99,90]
dd3 = defaultdict(list)
for value in values:
    if value > 66:
        dd3['k1'].append(value)
    elif value < 66:
        dd3['k2'].append(value)

print(dd3)
# defau

21，Counter，计数器，详细可以参考这个link http://www.cnblogs.com/Eva-J/articles/7291842.html

from collections import Counter
c = Counter('djfhjkalshfajskdhfjksladhfskafhsjkhfdjsahfksjdhfkjshdksjahfaskjh')
print(c)  # 统计每个字母出现了多少次，无序的容器类型，这是一个很鸡肋的功能
# Counter({'h': 11, 'j': 10, 's': 10, 'f': 9, 'k': 9, 'a': 7, 'd': 6, 'l': 2})

22，Python里面表示时间有三种方式，时间戳，格式化的字符串，元祖

# 和时间相关的我们用时间模块，在使用时间模块之前，应该首先导入这个模块
import time
# time.sleep(1) # 秒为单位（线程）推迟指定的时间，单位是秒
# print(time.time()) # ，获取当前的时间戳，也就是从1970年开始经历的所有秒

# 字符串 ---格式化时间：给人看的
# 时间戳 ---float时间：计算机看的
# 结构化时间 --- 元祖：计算用的


# 时间戳
print(time.time()) # 1545578398.396597

# 字符串
print(time.strftime("%Y-%m-%d %X"))    # 2018-12-23 23:19:58
# 打印哪些，什么格式，都是自己指定的
print(time.strftime("%Y-%m-%d %H:%M:%S")) # year month day HOUR MINUTE SECOND  2018-12-23 23:19:58

23，字符串时间的常用格式

# 字符串
print(time.strftime("%Y-%m-%d %X"))    # 2018-12-23 23:19:58  string format time  X:用的不多
print(time.strftime("%y-%m-%d %X"))  # 18-12-23 23:30:08
# 打印哪些，什么格式，都是自己指定的
print(time.strftime("%Y-%m-%d %H:%M:%S")) # year month day HOUR MINUTE SECOND  2018-12-23 23:19:58


# python中时间日期格式化符号：
# 仅针对string format time

# %y 两位数的年份表示（00-99）
# %Y 四位数的年份表示（000-9999）
# %m 月份（01-12）
# %d 月内中的一天（0-31）
# %H 24小时制小时数（0-23）
# %I 12小时制小时数（01-12）
# %M 分钟数（00=59）
# %S 秒（00-59）
# %a 本地简化星期名称
# %A 本地完整星期名称
# %b 本地简化的月份名称
# %B 本地完整的月份名称
# %c 本地相应的日期表示和时间表示
# %j 年内的一天（001-366）
# %p 本地A.M.或P.M.的等价符
# %U 一年中的星期数（00-53）星期天为星期的开始
# %w 星期（0-6），星期天为星期的开始
# %W 一年中的星期数（00-53）星期一为星期的开始
# %x 本地相应的日期表示
# %X 本地相应的时间表示
# %Z 当前时区的名称
# %% %号本身

24，localtime，结构化时间

# 时间元祖：localtime将一个时间戳转换为当前时区的Strut_time
print(time.localtime())
# time.struct_time(tm_year=2018, tm_mon=12, tm_mday=23, tm_hour=23, tm_min=39, tm_sec=1, tm_wday=6, tm_yday=357, tm_isdst=0)

# 小结，时间戳是计算机能够识别的时间；时间字符是人能够看懂的时间；元祖则是用来操作时间的

lt =time.localtime()
print(lt)
# time.struct_time(tm_year=2018, tm_mon=12, tm_mday=23, tm_hour=23, tm_min=39, tm_sec=1, tm_wday=6, tm_yday=357, tm_isdst=0)
print(lt.tm_year)  # 2018 这个模块有个不好的地方就是，不给提示，要自己去敲

25，几种格式之间的转化，时间戳和格式化字符串是不能直接转的

# 时间戳 --> 结构化时间
# time.gmtime(时间戳)  UTC时间，与英国伦敦当地时间一致
# time.localtime(时间戳)  当地时间，对于我们就是北京时间
print(time.gmtime(3000000000))
# time.struct_time(tm_year=2065, tm_mon=1, tm_mday=24, tm_hour=5, tm_min=20, tm_sec=0, tm_wday=5, tm_yday=24, tm_isdst=0)
print(time.localtime(130000000))
# time.struct_time(tm_year=1974, tm_mon=2, tm_mday=13, tm_hour=23, tm_min=6, tm_sec=40, tm_wday=2, tm_yday=44, tm_isdst=0)
print(time.gmtime(time.time()))
# time.struct_time(tm_year=2018, tm_mon=12, tm_mday=23, tm_hour=15, tm_min=50, tm_sec=47, tm_wday=6, tm_yday=357, tm_isdst=0)

# 结构化时间 --> 时间戳
# time.mktime(结构化时间)
print(time.mktime(time.localtime())) # 1545580212.0


# format string --> 结构化时间
print(time.strptime('2000-12.31','%Y-%m.%d'))


# 结构化时间 --> format string
print(time.strftime('%m/%d/%Y %H:%M:%S',time.localtime(300000000)))  # 这个不指定第二个参数，就是给出当前时间的format时间

26,asctime

按照如下结构显示--> %a %b %d %H:%M:%S %Y串
结构化时间，如果不传参数，直接返回当前时间的格式化串
参数可以是结构化时间
print(time.asctime())  # Mon Dec 24 00:20:27 2018  
# 直接用这个函数，时间就会显示成这个格式

27,ctime 参数可以是时间戳，也可以不传参数，返回格式化串，这么格式，就是为了显示我想要的时间格式

print(time.ctime())
# Mon Dec 24 00:24:05 2018

28，time模块计算时间差，datatime模块也可以计算时间差，需要自己计算

true_time = time.mktime(time.strptime("2017-9-11 08:30:00",'%Y-%m-%d %H:%M:%S'))
time_now = time.mktime(time.strptime("2017-9-12 11:23:00",'%Y-%m-%d %H:%M:%S'))
dif_time = time_now -true_time
print(dif_time, time_now,true_time)
struct_time = time.gmtime(dif_time)
# struct_time = time.gmtime(0)
# 之所以减掉，是因为，differ为0是是1970年的，要减掉这些，才是真正的差值。
# time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)
print(struct_time)
print("过去了%d年%d月%d天%d小时%d分钟%d秒" %(struct_time.tm_year-1970,struct_time.tm_mon-1,struct_time.tm_mday-1,
                                  struct_time.tm_hour,struct_time.tm_min,struct_time.tm_sec))

29，随机数模块，random模块,random 提供了一些和随机有关的方法

import random

# 随机小数 返回小数我们用的比较少，场景比较少
print(random.random())    # 0-1 之间的随机的小数
# 0.7816672791174853
print(random.uniform(1,3)) # 大于1小于3的小数
# 1.6544048997218492

# 随机整数，这个用的很多
print(random.randint(1,5)) # 大于等于1且小于等于5之间的小数，包括5
print(random.randrange(1,10,2)) # 大于等于1，且小于10之间的奇数，不包括10

# 随机选择一个返回
print(random.choice([1,'a',[4,5]])) # 1或者'a'或者[4,5]
# 随机选择多个返回，返回的个数为函数的第二个参数
print(random.sample([1,'23',[4,5]],2)) # 列表元素任意2个组合
# 被选择的放在一个列表里面

# 列表打乱顺序
item = [1,4,5,6,7,8,'a','m']
random.shuffle(item) # 打乱次序，类似于洗牌，改变的是原来的列表，不会生成新的
print(item)   # [1, 6, 4, 5, 8, 7, 'm', 'a']

random.shuffle(item)
print(item)  # ['a', 'm', 5, 4, 1, 8, 6, 7]

30，验证码，生成随机验证码

# 0-9
# chr
# [65-90] 数字
# 字母 = chr(数字)
# 随机数字
# 随机选一个[随机数字，随机字母]
# 当然实际的验证码还会有一些噪点，变形，防止被识别，这里不再考虑，也不考虑图片的情况

import random
def v_code():

    code = ''
    for i in range(5):

        num=random.randint(0,9)
        alf1=chr(random.randint(65,90))
        alf2 = chr(random.randint(97, 122))
        add=random.choice([num,alf1,alf2])
        code="".join([code,str(add)])  # 字符串,join函数，用空格来拼接
    return code

print(v_code())

31,os模块，os模块是和操作系统打交道的，os 模块管的范畴就是Python解释器所管的小范围了，整个操作系统的东西，整个范畴，只要提供方法，OS模块都可以来操作，但是是借助操作系统来操作的，目录相关

import os
print(os.getcwd())  # /Users/guolixiao/PycharmProjects/lisa's_practise/boys/part one
os.chdir(r"/Users/guolixiao/PycharmProjects/lisa's_practise/boys/")
print(os.getcwd())
#
os.chdir('..')
print(os.getcwd())

# 很鸡肋的功能
print(os.curdir)  # .  返回当前目录
print(os.pardir)  # ..  当前目录的父目录

os.makedirs('lisa/osdir/os')  # 若目录本身已经存在了再继续创建会报错
os.removedirs('lisa/osdir/os') #
os.removedirs('lisa') #  这样删除不了

os.mkdir(r'lll')  # 文件存在会报错
os.rmdir(r'lll')

print(os.listdir('..'))
os.remove(r'file.txt')
os.rename(r'../file.txt','file1.txt')

32，查看文件的状态，用到了过来查就可以，和Linux的其实很像，以后运维的话，用的会多一些

print(os.stat('file1.txt'))
# os.stat_result(st_mode=33188, st_ino=8609917391, st_dev=16777222, st_nlink=1, st_uid=501, st_gid=20, st_size=75, st_atime=1545659976, st_mtime=1544331960, st_ctime=1545659928)

# stat 结构:
# st_mode: inode 保护模式
# st_ino: inode 节点号。
# st_dev: inode 驻留的设备。
# st_nlink: inode 的链接数。
# st_uid: 所有者的用户ID。
# st_gid: 所有者的组ID。
# st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
# st_atime: 上次访问的时间。
# st_mtime: 最后一次修改的时间。
# st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。

33，

print(os.sep) # 这个主要用来拼路径的，Python代码跨平台用的
print(os.linesep) # 这个用得不太多
print(os.pathsep) # : 这个指得是环境变量里面的路径分割
print(os.name) # posix

# 下面两个重点记忆一下，和exec和eval很像，这样可以拿到系统的一些东西来进行操作
os.system('ls') #  在Python里面执行系统才能认识的命令,没有返回值
ret = os.popen('ls').read() # 有返回值，必须执行read函数才可以
print(ret)

# 区分操作系统能识别的语言和Python解释器能认识的语言

34，os.environ

print(os.environ) # 系统的环境变量，是一个变量，不是一个函数
# environ({'PATH': '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin', 'PYTHONPATH': "/Applications/PyCharm.app/Contents/helpers/pycharm_matplotlib_backend:/Users/guolixiao/PycharmProjects/lisa's_practise", 'SHELL': '/bin/bash', 'PYTHONIOENCODING': 'UTF-8', 'VERSIONER_PYTHON_PREFER_32_BIT': 'no', 'USER': 'guolixiao', 'TMPDIR': '/var/folders/jg/lnc0zl4d40nbc5yjftcjndk80000gn/T/', 'SSH_AUTH_SOCK': '/private/tmp/com.apple.launchd.NN6d5SxVDO/Listeners', 'XPC_FLAGS': '0x0', 'PYTHONUNBUFFERED': '1', 'VERSIONER_PYTHON_VERSION': '2.7', '__CF_USER_TEXT_ENCODING': '0x1F5:0x0:0x0', 'Apple_PubSub_Socket_Render': '/private/tmp/com.apple.launchd.lBXPBkTgVw/Render', 'LOGNAME': 'guolixiao', 'LC_CTYPE': 'en_US.UTF-8', 'XPC_SERVICE_NAME': 'com.jetbrains.pycharm.32068', 'PWD': "/Users/guolixiao/PycharmProjects/lisa's_practise/boys/part one", 'PYCHARM_HOSTED': '1', 'HOME': '/Users/guolixiao', 'PYCHARM_MATPLOTLIB_PORT': '52744', '__PYVENV_LAUNCHER__': '/usr/local/bin/python3.7'})

35，os.path

print(os.path.split(os.getcwd()))
# ("/Users/guolixiao/PycharmProjects/lisa's_practise/boys", 'part one')

print(os.path.join('c:','user','local'))  # 拼接一个目录，不关心是否存在
# # c:/user/local

print(os.path.join('c:admin','user','local'))  # 拼接一个目录，不关心是否存在
# # c:admin/user/local

print(os.path.getsize(os.getcwd()))
# 2368 # 文件准确，文件夹不准确，想获取文件夹大小，循环文件加起来

print(os.path.getsize(os.path.join(os.getcwd(),'file1.txt')))
# 75 # 文件准确，文件夹不准确,这个是准确的

36,盗用老师的笔记，老师所列出的所有方法在所有平台，Windows，Linux，和Mac都可以直接用的

第一组：
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname

第二组
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息

os.system("bash command")  运行shell命令，直接显示
os.popen("bash command).read()  运行shell命令，获取执行结果
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd


os.path
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所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

37，sys模块，可Python解释器交互的模块，参考老师博客 http://www.cnblogs.com/Eva-J/articles/7228075.html#_label6

import sys

sys.exit() # 命令控制程序退出，正常0，错误参数1，表现在程序里是感受不到的，都是退出

print(sys.platform)
# darwin ,这个地方Python解释器对于32位还是64位不是特别准确，返回操作系统平台名称

print(sys.argv) # 命令行参数列表，这样看不出来，一个文件有好几种执行方式，可以用terminal执行,这个和cmd是一样的，只不过
# 是pycharm给我们提供的cmd
# guolixiaos-MacBook-Pro:part one guolixiao$ python3 19.5_sys模块.py  1  2 3 4 5
# ['19.5_sys模块.py', '1', '2', '3', '4', '5']


print(sys.version)
# 返回Python解释器版本，准确的
# 3.7.0 (v3.7.0:1bf9cc5093, Jun 26 2018, 23:26:24)
# [Clang 6.0 (clang-600.0.57)]

print(sys.path) # 从左到右找，与搜索路径有关
# ["/Users/guolixiao/PycharmProjects/lisa's_practise/boys/part one", "/Users/guolixiao/PycharmProjects/lisa's_practise", '/Library/Frameworks/Python.framework/Versions/3.7/lib/python37.zip', '/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7', '/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/lib-dynload', '/Users/guolixiao/Library/Python/3.7/lib/python/site-packages', '/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages', '/Applications/PyCharm.app/Contents/helpers/pycharm_matplotlib_backend']
# 之所以安装了就能导入进来，就是因为sys.path记录了所有的路径
sys.path.clear()
# 如果列表清空了，全部导入不了了就

38，脚本传参，terminal

import sys
# 执行脚本前，给脚本传一些参数，以后这种用的非常多，数据库也是的，后面会接触到的，必须用terminal执行，pycharm执行会报错，真正的脚本
# 不是说必须装一个pycharm才可以用的，肯定是一执行就可以用的
ret = sys.argv
usrname = ret[1]  # 从第2个，索引为1才是真正的参数
pwd = ret[2]

if usrname == 'lisa' and pwd == 'lisa123':
    print('login successfully')
else:
    sys.exit()

print("you can use the calculator now")