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)