python分隔线参数

A. 日志文件太大，python怎么分割文件，多线程操作

python的多线程为伪多线程，多线程并不能提高文件IO的速度，在读取文件时使用直接读取 for line in open('文件名', 'r') 效率最高，因为此方式为直接读取，不像其它方式要把文件全部加载到内存再读取，所以效率最高。分割时文件时，提前计算好行数，把读取的每固定数量的行数存入新文件，直接读取完成，最后删除旧文件，即可实现文件分割。

示意代码：

line_count=0
index=0
fw=open('part'+str(index)+'.log','w')
forlineinopen('filename.log','r'):
fw.write(line)
line_count+=1
#假设每10000行写一个文件
ifline_count>10000:
fw.close()
index+=1
fw=open('part'+str(index)+'.log','w')
fw.close()

B. 参数n/a什么意思python

Python中函数参数的定义主要有四种方式：

1. F(arg1,arg2,…)

这是最常见的定义方式，一个函数可以定义任意个参数，每个参数间用逗号分割，用这种方式定义的函数在调用的的时候也必须在函数名后的小括号里提供个数相等
的值（实际参数），而且顺序必须相同，也就是说在这种调用方式中，形参和实参的个数必须一致，而且必须一一对应，也就是说第一个形参对应这第一个实参。例如：

代码如下:
def a(x,y):print x,y

调用该函数，a(1,2)则x取1，y取2，形参与实参相对应，如果a(1)或者a(1,2,3)则会报错。

2. F(arg1,arg2=value2,…)

这种方式就是第一种的改进版，提供了默认值，例如：

代码如下:
def a(x,y=3):print x,y

调用该函数，a(1,2)同样还是x取1，y取2，但是如果a(1)，则不会报错了，这个时候x还是1，y则为默认的3。上面这俩种方式，还可以更换参数位置，比如a(y=4,x=3)用这种形式也是可以的。

3. F(*arg1)

上面两种方式是有多少个形参，就传进去多少个实参，但有时候会不确定有多少个参数，则此时第三种方式就比较有用，它以一个*加上形参名的方式来表示这个函
数的实参个数不定，可能为0个也可能为n个。注意一点是，不管有多少个，在函数内部都被存放在以形参名为标识符的元组中。

代码如下:
def a(*x):print x

?123456 >>> a(1,2,3) (1, 2, 3) >>> a(x=1,y=2,z=3) Traceback (most recent call last): File "<stdin>", line 1, in <mole> TypeError: a() got an unexpected keyword argument 'x'
4. F(**arg1)

形参名前加两个*表示，参数在函数内部将被存放在以形式名为标识符的dictionary中，这时调用函数的方法则需要采用arg1=value1,arg2=value2这样的形式。

代码如下:
def a(**x):print x

?123456 >>> a(x=1,y=2,z=3) {'y': 2, 'x': 1, 'z': 3} #存放在字典中 >>> a(1,2,3) #这种调用则报错 Traceback (most recent call last): File "<stdin>", line 1, in <mole> TypeError: a() takes exactly 0 arguments (3 given)

C. Python 有什么奇技淫巧

Python奇技淫巧
当发布python第三方package时, 并不希望代码中所有的函数或者class可以被外部import, 在 __init__.py 中添加 __all__ 属性,

该list中填写可以import的类或者函数名, 可以起到限制的import的作用, 防止外部import其他函数或者类

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

frombaseimportAPIBase
fromclientimportClient
fromdecoratorimportinterface, export, stream
fromserverimportServer
fromstorageimportStorage
fromutilimport(LogFormatter, disable_logging_to_stderr,
enable_logging_to_kids, info)

__all__ = ['APIBase','Client','LogFormatter','Server',
'Storage','disable_logging_to_stderr','enable_logging_to_kids',
'export','info','interface','stream']

with的魔力

with语句需要支持 上下文管理协议的对象 , 上下文管理协议包含 __enter__ 和 __exit__ 两个方法. with语句建立运行时上下文需要通过这两个方法执行 进入和退出 操作.

其中 上下文表达式 是跟在with之后的表达式, 该表示大返回一个上下文管理对象
# 常见with使用场景
withopen("test.txt","r")asmy_file:# 注意, 是__enter__()方法的返回值赋值给了my_file,
forlineinmy_file:
print line

详细原理可以查看这篇文章, 浅谈 Python 的 with 语句

知道具体原理, 我们可以自定义支持上下文管理协议的类, 类中实现 __enter__ 和 __exit__ 方法
#!/usr/bin/env python
# -*- coding: utf-8 -*-

classMyWith(object):

def__init__(self):
print"__init__ method"

def__enter__(self):
print"__enter__ method"
returnself# 返回对象给as后的变量

def__exit__(self, exc_type, exc_value, exc_traceback):
print"__exit__ method"
ifexc_tracebackisNone:
print"Exited without Exception"
returnTrue
else:
print"Exited with Exception"
returnFalse

deftest_with():
withMyWith()asmy_with:
print"running my_with"
print"------分割线-----"
withMyWith()asmy_with:
print"running before Exception"
raiseException
print"running after Exception"

if__name__ =='__main__':
test_with()

执行结果如下:
__init__ method
__enter__ method
running my_with
__exit__ method
ExitedwithoutException
------分割线-----
__init__ method
__enter__ method
running before Exception
__exit__ method
ExitedwithException
Traceback(most recent call last):
File"bin/python", line34,in<mole>
exec(compile(__file__f.read(), __file__, "exec"))
File"test_with.py", line33,in<mole>
test_with()
File"test_with.py", line28,intest_with
raiseException
Exception

证明了会先执行 __enter__ 方法, 然后调用with内的逻辑, 最后执行 __exit__ 做退出处理, 并且, 即使出现异常也能正常退出

filter的用法

相对 filter 而言, map和rece使用的会更频繁一些, filter 正如其名字, 按照某种规则 过滤 掉一些元素
#!/usr/bin/env python
# -*- coding: utf-8 -*-

lst = [1,2,3,4,5,6]
# 所有奇数都会返回True, 偶数会返回False被过滤掉
print filter(lambda x: x % 2!=0, lst)

#输出结果
[1,3,5]

一行作判断

当条件满足时, 返回的为等号后面的变量, 否则返回else后语句
lst = [1,2,3]
new_lst = lst[0]iflstisnotNoneelseNone
printnew_lst

# 打印结果
1

装饰器之单例

使用装饰器实现简单的单例模式

# 单例装饰器
defsingleton(cls):
instances = dict() # 初始为空
def_singleton(*args, **kwargs):
ifclsnotininstances:#如果不存在, 则创建并放入字典
instances[cls] = cls(*args, **kwargs)
returninstances[cls]
return_singleton

@singleton
classTest(object):
pass

if__name__ =='__main__':
t1 = Test()
t2 = Test()
# 两者具有相同的地址
printt1, t2

staticmethod装饰器

类中两种常用的装饰, 首先区分一下他们

普通成员函数, 其中第一个隐式参数为 对象
classmethod装饰器 , 类方法(给人感觉非常类似于OC中的类方法), 其中第一个隐式参数为 类
staticmethod装饰器 , 没有任何隐式参数. python中的静态方法类似与C++中的静态方法
#!/usr/bin/env python
# -*- coding: utf-8 -*-

classA(object):

# 普通成员函数
deffoo(self, x):
print "executing foo(%s, %s)"% (self, x)

@classmethod# 使用classmethod进行装饰
defclass_foo(cls, x):
print "executing class_foo(%s, %s)"% (cls, x)

@staticmethod# 使用staticmethod进行装饰
defstatic_foo(x):
print "executing static_foo(%s)"% x

deftest_three_method():
obj = A()
# 直接调用噗通的成员方法
obj.foo("para")# 此处obj对象作为成员函数的隐式参数, 就是self
obj.class_foo("para")# 此处类作为隐式参数被传入, 就是cls
A.class_foo("para")#更直接的类方法调用
obj.static_foo("para")# 静态方法并没有任何隐式参数, 但是要通过对象或者类进行调用
A.static_foo("para")

if__name__=='__main__':
test_three_method()

# 函数输出
executing foo(<__main__.Aobject at0x100ba4e10>, para)
executing class_foo(<class'__main__.A'>,para)
executing class_foo(<class'__main__.A'>,para)
executing static_foo(para)
executing static_foo(para)

property装饰器

定义私有类属性

将 property 与装饰器结合实现属性私有化( 更简单安全的实现get和set方法 )
#python内建函数
property(fget=None, fset=None, fdel=None, doc=None)

fget 是获取属性的值的函数, fset 是设置属性值的函数, fdel 是删除属性的函数, doc 是一个字符串(like a comment).从实现来看，这些参数都是可选的

property有三个方法 getter() , setter() 和 delete() 来指定fget, fset和fdel。 这表示以下这行
classStudent(object):

@property #相当于property.getter(score) 或者property(score)
defscore(self):
returnself._score

@score.setter #相当于score = property.setter(score)
defscore(self, value):
ifnotisinstance(value, int):
raiseValueError('score must be an integer!')
ifvalue <0orvalue >100:
raiseValueError('score must between 0 ~ 100!')
self._score = value

iter魔法

通过yield和 __iter__ 的结合, 我们可以把一个对象变成可迭代的
通过 __str__ 的重写, 可以直接通过想要的形式打印对象
#!/usr/bin/env python
# -*- coding: utf-8 -*-

classTestIter(object):

def__init__(self):
self.lst = [1,2,3,4,5]

defread(self):
foreleinxrange(len(self.lst)):
yieldele

def__iter__(self):
returnself.read()

def__str__(self):
return','.join(map(str, self.lst))

__repr__ = __str__

deftest_iter():
obj = TestIter()
fornuminobj:
printnum
printobj

if__name__ =='__main__':
test_iter()

神奇partial

partial使用上很像C++中仿函数(函数对象).

在stackoverflow给出了类似与partial的运行方式
defpartial(func, *part_args):
defwrapper(*extra_args):
args = list(part_args)
args.extend(extra_args)
returnfunc(*args)

returnwrapper

利用用闭包的特性绑定预先绑定一些函数参数, 返回一个可调用的变量, 直到真正的调用执行
#!/usr/bin/env python
# -*- coding: utf-8 -*-

fromfunctoolsimportpartial

defsum(a, b):
returna + b

deftest_partial():
fun = partial(sum, 2)# 事先绑定一个参数, fun成为一个只需要一个参数的可调用变量
printfun(3)# 实现执行的即是sum(2, 3)

if__name__ =='__main__':
test_partial()

# 执行结果
5

神秘eval

eval我理解为一种内嵌的python解释器(这种解释可能会有偏差), 会解释字符串为对应的代码并执行, 并且将执行结果返回

看一下下面这个例子
#!/usr/bin/env python
# -*- coding: utf-8 -*-

deftest_first():
return3

deftest_second(num):
returnnum

action = { # 可以看做是一个sandbox
"para":5,
"test_first": test_first,
"test_second": test_second
}

deftest_eavl():
condition = "para == 5 and test_second(test_first) > 5"
res = eval(condition, action) # 解释condition并根据action对应的动作执行
printres

if__name__ =='_

exec

exec在Python中会忽略返回值, 总是返回None, eval会返回执行代码或语句的返回值
exec 和 eval 在执行代码时, 除了返回值其他行为都相同
在传入字符串时, 会使用 compile(source, '<string>', mode) 编译字节码. mode的取值为 exec 和 eval
#!/usr/bin/env python
# -*- coding: utf-8 -*-

deftest_first():
print"hello"

deftest_second():
test_first()
print"second"

deftest_third():
print"third"

action = {
"test_second": test_second,
"test_third": test_third
}

deftest_exec():
exec"test_second"inaction

if__name__ =='__main__':
test_exec() # 无法看到执行结果

getattr

getattr(object, name[, default]) Return the value of
the named attribute of object. name must be a string. If the string is
the name of one of the object’s attributes, the result is the value of
that attribute. For example, getattr(x, ‘foobar’) is equivalent to
x.foobar. If the named attribute does not exist, default is returned if
provided, otherwise AttributeError is raised.

通过string类型的name, 返回对象的name属性(方法)对应的值, 如果属性不存在, 则返回默认值, 相当于object.name
# 使用范例
classTestGetAttr(object):

test = "test attribute"

defsay(self):
print"test method"

deftest_getattr():
my_test = TestGetAttr()
try:
printgetattr(my_test,"test")
exceptAttributeError:
print"Attribute Error!"
try:
getattr(my_test, "say")()
exceptAttributeError:# 没有该属性, 且没有指定返回值的情况下
print"Method Error!"

if__name__ =='__main__':
test_getattr()

# 输出结果
test attribute
test method

命令行处理
defprocess_command_line(argv):
"""
Return a 2-tuple: (settings object, args list).
`argv` is a list of arguments, or `None` for ``sys.argv[1:]``.
"""
ifargvisNone:
argv = sys.argv[1:]

# initialize the parser object:
parser = optparse.OptionParser(
formatter=optparse.TitledHelpFormatter(width=78),
add_help_option=None)

# define options here:
parser.add_option( # customized description; put --help last
'-h','--help', action='help',
help='Show this help message and exit.')

settings, args = parser.parse_args(argv)

# check number of arguments, verify values, etc.:
ifargs:
parser.error('program takes no command-line arguments; '
'"%s" ignored.'% (args,))

# further process settings & args if necessary

returnsettings, args

defmain(argv=None):
settings, args = process_command_line(argv)
# application code here, like:
# run(settings, args)
return0# success

if__name__ =='__main__':
status = main()
sys.exit(status)

读写csv文件
# 从csv中读取文件, 基本和传统文件读取类似
importcsv
withopen('data.csv','rb')asf:
reader = csv.reader(f)
forrowinreader:
printrow
# 向csv文件写入
importcsv
withopen('data.csv','wb')asf:
writer = csv.writer(f)
writer.writerow(['name','address','age'])# 单行写入
data = [
( 'xiaoming ','china','10'),
( 'Lily','USA','12')]
writer.writerows(data) # 多行写入

各种时间形式转换

只发一张网上的图, 然后差文档就好了, 这个是记不住的

字符串格式化

一个非常好用, 很多人又不知道的功能
>>>name ="andrew"
>>>"my name is {name}".format(name=name)
'my name is andrew'

D. split在python中的用法

split在python中的用法如下所示：

工具：win10电脑。

软件：python

版本：1.32。

1、打开pycharm，新建python。具体方法如下图所示：

E. python数据分割

str='124,ad,"33,412"'
st=''
foriinstr:
i=i.strip('"')
st+=i
stt=''.join(st)
sttt=''.join(stt[0:9]+stt[10:])
list=sttt.split(',')
print(list)

结果：['124', 'ad', '33412']

F. python中分割字符串

imkow正解，直接转list最好，否则自己写list comprehension其实隐含的还是把字符串当list用，多此一举

G. python: split的用法，在后面的括号不同，输出的也不一样，大神能不能帮忙解释一下下面的例子。

split的第一个参数是分隔符。
如果省略第一个参数，默认把所有的空格、制表符、回车符当作分隔符，并过滤掉空串。这个也是你第一种写法的效果。

line.split(‘\t''\n')

'\t'和'\n'是两个字符串，会自动进行拼接，形成'\t\n'作为分隔符。而在你输入的字符串中，不包含这样的字串，所以就分割的结果就是原串。

split(‘\t')

以'\t'作为分隔符，分割的结果就是第三种写法。

split不支持同时使用多种字符做分隔符，如果想实现这样的效果，可以用re，例如：
>>> a
'wowofbfwjowoefbwfoweojbwoefja'
>>> import re

>>> re.split('[ab]', a)
['wowof', 'fwjowoef', 'wfoweoj', 'woefj', '']

H. python split

楼主你好！

python中的split()不带任何参数是个很好用的特性：忽略具体的空格数来分割字符串。

请看一下代码：

handle_string='HelloWhatYourName'
printhandle_string.split()

运行结果：

['Hello', 'What', 'Your', 'Name']

不难发现这样调用的结果是不会考虑字符串中字母间空格的具体数量的，假如按一下代码：

handle_string='HelloWhatYourName'
printhandle_string.split('')

则运行结果（即按单个空格来分割）：

['Hello', 'What', '', 'Your', '', '', 'Name']

在Linux系统下，当你抓取一下工具显示的据数据时，往往这些工具为了美观，会用空格符来进行排版。此时要读取数据，用split()就会显得特别方便。

望采纳，谢谢！

I. python 如何读取竖线分隔符的文本

data
=
pd.read_csv('test.txt',sep
=
'|',dtype
=
'str')
以上代码意思是:
1,读取本工作路径下的test.txt文件
2,使用’|’分割不同的列
3,所有列数据类型为字符串’str’

J. python 分割列表的几种方法

def groups(L1,len1):
groups=zip(*(iter(L1),)*len1)
L2=[list(i) for i in groups]
n=len(L1) % len1
L2.append(L1[-n:]) if n !=0 else L2
return L2

L1=[23,26,8,9, 'AB', 'CDEF']
print(groups(L1,3)