python in module_module in python

Python 中的模块

module定义

对于可复用的函数集，可以对其进行分组，整合到一个或者若干个.py文件中，而在python中，一个.py文件就叫做一个模块。变量，函数。

module注意点

为了避免命名冲突，python中引入目录组织的方式，这里称之为包(package)

每个包下都会有一个__init__.py文件,这个文件是必须存在的。否则python会把这个目录当作普通目录，而不是一个包。同时__init__.py文件本身是一个模块

module的导入方法

import module_name

import module_name,module2_name

from module_name import func1,func2,func3

from module_name import *

import module_name import func as func_local

由上可知，import实际上路径搜索和搜索路径，导入模块的本质就是把python文件解释一遍。执行__init__.py文件。试图加载某一个模块的时候，如果找不到就会报错。模块的搜索顺序为当前路径\(\rightarrow\)内置模块\(\rightarrow\)第三方库

import sys

sys.path.append('/Users/michael/my_py_scripts')

这种方法是运行时修改，运行结束后失效

常用module

date,datetime,datetime stamp

range

os

sys

shelve

xml

configparser

hashlib,hmac

date,datetime,datetime stamp

from datetime import datetime,tzinfo,timedelta

import time

class GMT1(tzinfo):

def utcoffset(self, dt):

return timedelta(hours=1)

def dst(self,dt):

return timedelta(hours=0)

def tzname(self,dt):

return "Europe/Prague"

timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S")

print(timestamp)

timestamp=time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())

print(timestamp)

timestamp=datetime.now()

print(datetime.strftime(timestamp,"%Y-%m-%d %H:%M:%S"))

#timedelta表示一段时间

year=timedelta(days=365)

another_year= timedelta(weeks=40,days=84,hours=23,minutes=50,seconds=600)

print(year.total_seconds())

print(year==another_year)

timestamp=datetime.now()

#这里将timestamp加上一天时间

timestamp+=timedelta(days=1)

print(timestamp.strftime("%Y-%m-%d %H:%M:%S"))

#两个timedelta的运算

timestamp+=timedelta(days=1)+timedelta(hours=1)

print(timestamp.strftime("%Y-%m-%d %H:%M:%S"))

#除运算，返回float类型

value=timedelta(days=1)/timedelta(hours=2)

print(value)

#在秒级别进行运算，返回integer类型

value=timedelta(days=1)//timedelta(hours=2)

print(value)

#q=t1//t2 r=t%t2 一天和三个小时进行运算，所以这里，第一个应当返回整数8，第二个应当返回0，取余运算的返回类型为timedelta

q,r=divmod(timedelta(days=1),timedelta(hours=3))

print(q,r)

# 返回字符串格式为 [D day[s], ][H]H:MM:SS[.UUUUUU]

print(str(timedelta(days=-1,hours=-1))) #output: -2 days, 23:00:00,这里会自动进行时间的运算

datetimestamp=time(12,10,30,tzinfo=GMT1())

gmt=GMT1()

print(datetimestamp)

Random模块

import random

import collections

from statistics import mean,median,stdev

from random import choices,expovariate,gauss,shuffle

#这里的random()是生成一个0<=x<=1的随机数

print(random.random())

#uniform(2.5,10),生成一个2.5到10之间的一个随机数

print(random.uniform(2.5,10))

#指数分布

print(random.expovariate(1/5))

#区间内随机数

print(random.randrange(1,100))

#(start,end,step)三个参数

print(random.randrange(0,101,2))

#序列随机结果

print(random.choice(['hero','piro','maro']))

#短句随机打乱

deck='ace are split to four'.split()

random.shuffle(deck)

print(deck)

#从一个序列中随机抽样

sequence=['1','3','4','5','7','8','6']

print(random.sample(sequence,k=4))

#类似高中数学里一个袋子里有18个红球，18个黑球，2个绿球。从中随机抽出6个的意思

choice=random.choices(['red', 'black', 'green'], [18, 18, 2], k=6)

print(choice)

deck = collections.Counter(tens=16, low_cards=36)

seen = random.sample(list(deck.elements()), k=20)

print(seen.count('tens') / 20)

trial = lambda: random.choices('HT', cum_weights=(0.60, 1.00), k=7).count('H') >= 5

print(sum(trial() for i in range(10000)) / 10000)

trial = lambda : 2500 <= sorted(random.choices(range(10000), k=5))[2] < 7500

print(sum(trial() for i in range(10000)) / 10000)

data = 1, 2, 4, 4, 10

means = sorted(mean(choices(data, k=5)) for i in range(20))

print(f'样本均值 {mean(data):.1f} 置信水平 90% '

f'interval from {means[1]:.1f} to {means[-2]:.1f}')

drug = [54, 73, 53, 70, 73, 68, 52, 65, 65]

placebo = [54, 51, 58, 44, 55, 52, 42, 47, 58, 46]

observed_diff = mean(drug) - mean(placebo)

n = 10000

count = 0

combined = drug + placebo

for i in range(n):

shuffle(combined)

new_diff = mean(combined[:len(drug)]) - mean(combined[len(drug):])

count += (new_diff >= observed_diff)

print(f'{n} label reshufflings produced only {count} instances with a difference')

print(f'at least as extreme as the observed difference of {observed_diff:.1f}.')

print(f'The one-sided p-value of {count / n:.4f} leads us to reject the null')

print(f'hypothesis that there is no difference between the drug and the placebo.')

average_arrival_interval = 5.6

average_service_time = 5.0

stdev_service_time = 0.5

num_waiting = 0

arrivals = []

starts = []

arrival = service_end = 0.0

for i in range(20000):

if arrival <= service_end:

num_waiting += 1

arrival += expovariate(1.0 / average_arrival_interval)

arrivals.append(arrival)

else:

num_waiting -= 1

service_start = service_end if num_waiting else arrival

service_time = gauss(average_service_time, stdev_service_time)

service_end = service_start + service_time

starts.append(service_start)

waits = [start - arrival for arrival, start in zip(arrivals, starts)]

print(f'Mean wait: {mean(waits):.1f}. Stdev wait: {stdev(waits):.1f}.')

print(f'Median wait: {median(waits):.1f}. Max wait: {max(waits):.1f}.')

os模块

import os

#Executing a shell command

os.system()

#Get the users environment

os.environ()

#Returns the current working directory.

os.getcwd()

#Return the real group id of the current process.

os.getgid()

#Return the current process’s user id.

os.getuid()

#Returns the real process ID of the current process.

os.getpid()

#Set the current numeric umask and return the previous umask.

os.umask(mask)

#Return information identifying the current operating system.

os.uname()

#Change the root directory of the current process to path.

os.chroot(path)

#Return a list of the entries in the directory given by path.

os.listdir(path)

#Create a directory named path with numeric mode mode.

os.mkdir(path)

#Recursive directory creation function.

os.makedirs(path)

#Remove (delete) the file path.

os.remove(path)

#Remove directories recursively.

os.removedirs(path)

#Rename the file or directory src to dst.

os.rename(src, dst)

#Remove (delete) the directory path.

os.rmdir(path)

Sys模块

import sys

print('Version info:')

print()

print('sys.version =', repr(sys.version))

print('sys.version_info =', sys.version_info)

print('sys.hexversion =', hex(sys.hexversion))

print('sys.api_version =', sys.api_version)

print('This interpreter was built for:', sys.platform)

print('Name:', sys.implementation.name)

print('Version:', sys.implementation.version)

print('Cache tag:', sys.implementation.cache_tag)

if sys.flags.bytes_warning:

print('Warning on bytes/str errors')

if sys.flags.debug:

print('Debuging')

if sys.flags.inspect:

print('Will enter interactive mode after running')

if sys.flags.optimize:

print('Optimizing byte-code')

if sys.flags.dont_write_bytecode:

print('Not writing byte-code files')

if sys.flags.no_site:

print('Not importing "site"')

if sys.flags.ignore_environment:

print('Ignoring environment')

if sys.flags.verbose:

print('Verbose mode')

print('Default encoding :', sys.getdefaultencoding())

print('File system encoding :', sys.getfilesystemencoding())

class ExpressionCounter:

def __init__(self):

self.count = 0

self.previous_value = self

def __call__(self, value):

print()

print(' Previous:', self.previous_value)

print(' New :', value)

print()

if value != self.previous_value:

self.count += 1

sys.ps1 = '({:3d})> '.format(self.count)

self.previous_value = value

sys.__displayhook__(value)

print('installing')

sys.displayhook = ExpressionCounter()

print('Interpreter executable:')

print(sys.executable)

print('\nInstallation prefix:')

print(sys.prefix)

Shelve

import shelve

d = shelve.open(filename) # open -- file may get suffix added by low-level

# library

d[key] = data # store data at key (overwrites old data if

# using an existing key)

data = d[key] # retrieve a COPY of data at key (raise KeyError

# if no such key)

del d[key] # delete data stored at key (raises KeyError

# if no such key)

flag = key in d # true if the key exists

klist = list(d.keys()) # a list of all existing keys (slow!)

# as d was opened WITHOUT writeback=True, beware:

d['xx'] = [0, 1, 2] # this works as expected, but...

d['xx'].append(3) # *this doesn't!* -- d['xx'] is STILL [0, 1, 2]!

# having opened d without writeback=True, you need to code carefully:

temp = d['xx'] # extracts the copy

temp.append(5) # mutates the copy

d['xx'] = temp # stores the copy right back, to persist it

# or, d=shelve.open(filename,writeback=True) would let you just code

# d['xx'].append(5) and have it work as expected, BUT it would also

# consume more memory and make the d.close() operation slower.

d.close() # close it