pythonignore

Ⅰ python安裝以後輸入顯示是這樣，求解

首先這個命令不是在python交互環境下運行的，其次需要使用python -V要大寫的V才可以輸出版本號，如下：

其它命令說明：

C:>python --help
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-b : issue warnings about str(bytes_instance), str(bytearray_instance)
and comparing bytes/bytearray with str. (-bb: issue errors)
-B : don't write .pyc files on import; also PYTHONDONTWRITEBYTECODE=x
-c cmd : program passed in as string (terminates option list)
-d : debug output from parser; also PYTHONDEBUG=x
-E : ignore PYTHON* environment variables (such as PYTHONPATH)
-h : print this help message and exit (also --help)
-i : inspect interactively after running script; forces a prompt even
if stdin does not appear to be a terminal; also PYTHONINSPECT=x
-I : isolate Python from the user's environment (implies -E and -s)
-m mod : run library mole as a script (terminates option list)
-O : remove assert and __debug__-dependent statements; add .opt-1 before
.pyc extension; also PYTHONOPTIMIZE=x
-OO : do -O changes and also discard docstrings; add .opt-2 before
.pyc extension
-q : don't print version and right messages on interactive startup
-s : don't add user site directory to sys.path; also PYTHONNOUSERSITE
-S : don't imply 'import site' on initialization
-u : force the binary I/O layers of stdout and stderr to be unbuffered;
stdin is always buffered; text I/O layer will be line-buffered;
also PYTHONUNBUFFERED=x
-v : verbose (trace import statements); also PYTHONVERBOSE=x
can be supplied multiple times to increase verbosity
-V : print the Python version number and exit (also --version)
when given twice, print more information about the build
-W arg : warning control; arg is action:message:category:mole:lineno
also PYTHONWARNINGS=arg
-x : skip first line of source, allowing use of non-Unix forms of #!cmd
-X opt : set implementation-specific option
file : program read from script file
- : program read from stdin (default; interactive mode if a tty)
arg ...: arguments passed to program in sys.argv[1:]

Ⅱ python中ignore需要導入什麼包

是想忽略warning嗎？

這樣：

importwarnings
warnings.filterwarnings("ignore")

望採納。

Ⅲ Python實現count_ignore_case(ls,s)函數。返回不區分大小寫相等的元素的數量

def count_ignore_case(ls,s):
dic={}
for i in s:
dic[i]=0
for x in ls:
for y in x:
if y.lower() in dic:
dic[y.lower()]+=1
return dic

print(count_ignore_case(['Count_ignore_case','ABCabbcdefg'],'abc'))

Ⅳ 如何用python刪除特定文件夾

#!/usr/bin/env python
import os
import shutil

delList = []
delDir = "/home/test"
delList = os.listdir(delDir )

for f in delList:
filePath = os.path.join( delDir, f )
if os.path.isfile(filePath):
os.remove(filePath)
print filePath + " was removed!"
elif os.path.isdir(filePath):
shutil.rmtree(filePath,True)
print "Directory: " + filePath +" was removed!"

shutil是一個高層次的文件操作模塊。True參數表示ignore_errors(忽略拷貝時候的錯誤)。
類似於高級API，而且主要強大之處在於其對文件的復制與刪除操作更是比較支持好。

[附] os模塊(庫)的使用
有關文件夾與文件的查找，刪除等功能 在 os 模塊中實現。

一、取得當前目錄
#1.1
s = os.getcwd()
# s 中保存的是當前的執行目錄(即執行所在的文件夾)
[注意]
如果是要獲得程序運行的當前目錄所在位置，那麼可以使用os模塊的os.getcwd()函數。
如果是要獲得當前執行的腳本的所在目錄位置，那麼需要使用sys模塊的sys.path[0]變數或者sys.argv[0]來獲得

#1.2
import os
import time

folder = time.strftime(r"%Y-%m-%d_%H-%M-%S",time.localtime())
os.makedirs(r'%s/%s'%(os.getcwd(),folder))

二、更改當前目錄

os.chdir( "/root/123")
#將當前目錄設為 "/root/123"
#說明： 當指定的目錄不存在時，引發異常。

三、將一個路徑名分解為目錄名和文件名兩部分
fpath , fname = os.path.split( "你要分解的路徑")
例如：
a, b = os.path.split( "/root/123/test.txt" )
print a
print b

顯示：
/root/123/
test.txt

四、分解文件名的擴展名
fpathandname , fext = os.path.splitext( "你要分解的路徑")

例如：
a, b = os.path.splitext( "/root/123/test.txt" )
print a
print b

顯示：
/root/123/test
.txt

五、判斷一個路徑（ 目錄或文件）是否存在
b = os.path.exists( "你要判斷的路徑")

返回值b： True 或 False

六、判斷一個路徑是否文件
b = os.path.isfile( "你要判斷的路徑")

返回值b： True 或 False

七、判斷一個路徑是否目錄
b = os.path.isdir( "你要判斷的路徑")

返回值b： True 或 False

八、獲取某目錄中的文件及子目錄的列表
L = os.listdir( "你要判斷的路徑")

例如：
L = os.listdir( "/root/123" )
print L

顯示 :
['test.txt', 'test.py','python']
#這裡面既有文件也有子目錄

九、創建子目錄
os.makedirs( path ) # path 是"要創建的子目錄"

例如:
os.makedirs("/root/123")

調用有可能失敗，可能的原因是：
(1) path 已存在時(不管是文件還是文件夾)
(2) 驅動器不存在
(3) 磁碟已滿
(4)磁碟是只讀的或沒有寫許可權

十、刪除子目錄
os.rmdir( path ) # path: "要刪除的子目錄"

產生異常的可能原因:
(1) path 不存在
(2) path 子目錄中有文件或下級子目錄
(3) 沒有操作許可權或只讀

十一、刪除文件
os.remove( filename ) # filename: "要刪除的文件名"

產生異常的可能原因:
(1) filename 不存在
(2) 對filename文件， 沒有操作許可權或只讀。

十二、文件改名
os.name( oldfileName, newFilename)

產生異常的原因：
(1) oldfilename 舊文件名不存在
(2) newFilename 新文件已經存在時，此時，您需要先刪除 newFilename 文件。

Ⅳ python實現mysql插入數據時，判斷是否存在，不存在就插入，重復跳過

方案一：使用ignore關鍵字
如果是用主鍵primary或者唯一索引unique區分了記錄的唯一性,避免重復插入記錄可以使用：
insert ignore into table_name(email,phone,user_id) values('[email protected]','99999','9999'),這樣當有重復記
錄就會忽略,執行後返回數字0,還有個應用就是復製表,避免重復記錄：
insert ignore into table(name) select name from table2
方案二：使用Replace
replace的語法格式為：
1. replace into table_name(col_name, ...) values(...)
2. replace into table_name(col_name, ...) select ...
3. replace into table_name set col_name=value, ...
演算法說明：
REPLACE的運行與INSERT很相像,但是如果舊記錄與新記錄有相同的值，則在新記錄被插入之前，舊記錄被刪除，即：
1. 嘗試把新行插入到表中
2. 當因為對於主鍵或唯一關鍵字出現重復關鍵字錯誤而造成插入失敗時：
從表中刪除含有重復關鍵字值的沖突行
再次嘗試把新行插入到表中
舊記錄與新記錄有相同的值的判斷標准就是：表有一個PRIMARY KEY或UNIQUE索引，否則，使用一個REPLACE語句沒有意義
。該語句會與INSERT相同，因為沒有索引被用於確定是否新行復制了其它的行。
返回值：
REPLACE語句會返回一個數，來指示受影響的行的數目。該數是被刪除和被插入的行數的和。
受影響的行數可以容易地確定是否REPLACE只添加了一行，或者是否REPLACE也替換了其它行：檢查該數是否為1（添加）或
更大（替換）。
示例:
eg:(phone欄位為唯一索引)
replace into table_name(email,phone,user_id) values('test569','99999','123')
另外：在 SQL Server 中可以這樣處理：
if not exists (select phone from t where phone= '1')
insert into t(phone, update_time) values('1', getdate())
else
update t set update_time = getdate() where phone= '1'
更多信息請看：http://dev.mysql.com/doc/refman/5.1/zh/sql-syntax.html#replace
方案三：ON DUPLICATE KEY UPDATE
如‍上所寫，你也可以在INSERT INTO.....後面加上 ON DUPLICATE KEY UPDATE方法來實現。
如果您指定了ON DUPLICATE KEY UPDATE，並且插入行後會導致在一個UNIQUE索引
或PRIMARY KEY中出現重復值，
則執行舊行UPDATE。例如，如果列a被定義為UNIQUE，並且包含值1，則以下兩個語句具有相
同的效果：
mysql>INSERT INTO table (a,b,c) VALUES (1,2,3)
->ON DUPLICATE KEY UPDATE c=c+1;
mysql>UPDATE table SET c=c+1 WHERE a=1;
如果行作為新記錄被插入，則受影響行的值為1；如果原有的記錄被更新，則受影響行的值為2。
注釋：如果列b也是唯一列，則INSERT與此UPDATE語句相當：
mysql> UPDATE table SET c=c+1 WHERE a=1 OR b=2 LIMIT 1;
如果a=1 OR b=2與多個行向匹配，則只有一個行被更新。通常，您應該盡量避免對帶有多個唯一關鍵字的表使用ON DUPLICATE KEY子句。
您可以在UPDATE子句中使用VALUES(col_name)函數從INSERT...UPDATE語句的INSERT部分引用列值。
換句話說，如果沒有發生重復關鍵字沖突，則UPDATE子句中的VALUES(col_name)可以引用被插入的
col_name的值。本函數特別適用於多行插入。VALUES()函數只在INSERT...UPDATE語句中有意義，其它時候
會返回NULL。
mysql> INSERT INTO table (a,b,c) VALUES (1,2,3),(4,5,6)
-> ON DUPLICATE KEY UPDATE c=VALUES(a)+VALUES(b);
本語句與以下兩個語句作用相同：
mysql> INSERT INTO table (a,b,c) VALUES (1,2,3)
-> ON DUPLICATE KEY UPDATE c=3;
mysql> INSERT INTO table (a,b,c) VALUES (4,5,6)
-> ON DUPLICATE KEY UPDATE c=9;
當您使用ON DUPLICATE KEY UPDATE時，DELAYED選項被忽略。
示例： 這個例子是我在實際項目中用到的：是將一個表的數據導入到另外一個表中，數據的重復性就得考慮(如下)。
唯一索引為：email
INSERT INTO table_name1(title,first_name,last_name,email,phone,user_id,role_id,status,campaign_id)
SELECT '','','',table_name2.email,table_name2.phone,NULL,NULL,'pending',29
FROM table_name2
WHERE table_name2.status = 1
ON DUPLICATE KEY UPDATE table_name1.status = 'pending'
語句的關鍵地方，都已高亮出來~
再貼一個例子：
insert into class select * from class1
ON DUPLICATE KEY UPDATE class.course = class1.course
其它關鍵：DELAYED 做為快速插入，並不是很關心失效性，提高插入性能。
IGNORE 只關注主鍵對應記錄是不存在，無則添加，有則忽略。
特別說明：在MYSQL中UNIQUE 索引將會對null欄位失效，也就是說(a欄位上建立唯一索引)：

insert into test(a) values(null)
insert into test(a) values(null)
是可以重復插入的（聯合唯一索引也一樣）。

Ⅵ python文件怎麼突然變成這個樣了

你看下這個是python的軟體文件，如果不是，你選擇文件，右擊一下，重新選擇打開這種類型的軟體即可

Ⅶ python encode 不使用ignore怎麼完美解決

這個不用庫吧 直接就可以使用 >>> "sdfsdfsd".encode() b'sdfsdfsd' >>>

Ⅷ 如何使用python處理心音信號

在了解了linux的信號基礎之 後，Python標准庫中的signal包就很容易學習和理解。signal包負責在Python程序內部處理信號，典型的操作包括預設信號處理函數，暫 停並等待信號，以及定時發出SIGALRM等。要注意，signal包主要是針對UNIX平台(比如Linux, MAC OS)，而Windows內核中由於對信號機制的支持不充分，所以在Windows上的Python不能發揮信號系統的功能。
信號（signal）-- 進程之間通訊的方式，是一種軟體中斷。一個進程一旦接收到信號就會打斷原來的程序執行流程來處理信號。
定義信號名
signal包定義了各個信號名及其對應的整數，比如：
import signal
print(signal.SIGABRT)
print(signal.SIG_DFL)

Python所用的信號名與Linux一致，可以通過$ man 7 signal 查詢
預設信號處理函數
signal包的核心是使用signal.signal()函數來預設(register)信號處理函數，如下所示：
singnal.signal(signalnum, handler)
signalnum為某個信號，handler為該信號的處理函數。我們在信號基礎里提到，進程可以無視信號，可以採取默認操作，還可以自定義操作。當handler為signal.SIG_IGN時，信號被無視(ignore)。當handler為singal.SIG_DFL，進程採取默認操作(default)。當handler為一個函數名時，進程採取函數中定義的操作。

import signal
# Define signal handler function
def myHandler(signum, frame):
print('I received: ', signum)

# register signal.SIGTSTP's handler
signal.signal(signal.SIGTSTP, myHandler)
signal.pause()
print('End of Signal Demo')
# 有問題待測試

在主程序中，我們首先使用signal.signal()函數來預設信號處理函數。然後我們執行signal.pause()來讓該進程暫停以等待信號， 以等待信號。當信號SIGUSR1被傳遞給該進程時，進程從暫停中恢復，並根據預設，執行SIGTSTP的信號處理函數myHandler()。 myHandler的兩個參數一個用來識別信號(signum)，另一個用來獲得信號發生時，進程棧的狀況(stack frame)。這兩個參數都是由signal.singnal()函數來傳遞的。
上面的程序可以保存在一個文件中(比如test.py)。我們使用如下方法運行:
$python test.py
以便讓進程運行。當程序運行到signal.pause()的時候，進程暫停並等待信號。此時，通過按下CTRL+Z向該進程發送SIGTSTP信號。我們可以看到，進程執行了myHandle()函數, 隨後返回主程序，繼續執行。(當然，也可以用$ps查詢process ID, 再使用$kill來發出信號。)
(進程並不一定要使用signal.pause()暫停以等待信號，它也可以在進行工作中接受信號，比如將上面的signal.pause()改為一個需要長時間工作的循環。)
我們可以根據自己的需要更改myHandler()中的操作，以針對不同的信號實現個性化的處理。
定時發出SIGALRM信號
一個有用的函數是signal.alarm()，它被用於在一定時間之後，向進程自身發送SIGALRM信號:

import signal
# Define signal handler function
def myHandler(signum, frame):
print("Now, it's the time")
exit()

# register signal.SIGALRM's handler
signal.signal(signal.SIGALRM, myHandler)
signal.alarm(5)
while True:
print('not yet')

我們這里用了一個無限循環以便讓進程持續運行。在signal.alarm()執行5秒之後，進程將向自己發出SIGALRM信號，隨後，信號處理函數myHandler開始執行。
發送信號
signal包的核心是設置信號處理函數。除了signal.alarm()向自身發送信號之外，並沒有其他發送信號的功能。但在os包中，有類似於linux的kill命令的函數，分別為
os.kill(pid, sid)
os.killpg(pgid, sid)
分別向進程和進程組(見Linux進程關系)發送信號。sid為信號所對應的整數或者singal.SIG*。

實際上signal, pause，kill和alarm都是Linux應用編程中常見的C庫函數，在這里，我們只不過是用Python語言來實現了一下。實際上，Python 的解釋器是使用C語言來編寫的，所以有此相似性也並不意外。此外，在Python 3.4中，signal包被增強，信號阻塞等功能被加入到該包中。我們暫時不深入到該包中。
總結
signal.SIG*
signal.signal()
signal.pause()
signal.alarm()

Ⅸ Python：忽略問題，怎麼解決

python開發中經常遇到報錯的情況，但是warning通常並不影響程序的運行，而且有時特別討厭，下面我們來說下如何忽略warning錯誤。
在說忽略warning之前，我們先來說下如何主動產生warning錯誤，這里用到warnings模塊，看如下代碼：

123456

import warningsdef fxn(): warnings.warn("deprecated", DeprecationWarning)with warnings.catch_warnings(): warnings.simplefilter("ignore") fxn()

這樣就產生了warning錯誤
那麼如何來控制警告錯誤的輸出呢？很簡單

12

import warningswarnings.filterwarnings("ignore")

這樣就忽略了警告錯誤的輸出。很簡單吧~~
又有人要問如何忽略命令行下警告錯誤的輸出呢？也非常簡單：
python -W ignore yourscript.py
這樣就OK了

Ⅹ 利用python對外部程序進行操作

代碼如下 復制代碼

object_id_list=[1, 3, 88, 99]
f=open(『mylist』, 「w」)
for id in object_id_list:
f.writelines(str(id))
f.close() #只有輸入這一句之後才會真正寫入到文件中
cat mylist
138899% # 最後有一個%表示沒有換行
>>> object_id_list=[1, 3, 88, 99]
>>> f=open(『mylist』, 「w」)
>>> for id in object_id_list:
… f.writelines(str(id) + 『＼n』)
…
>>> f.close()
➜ ~ cat mylist
1
3
88
99

例子2
代碼如下 復制代碼

def processFile(inputFile, outputFile): #定義一個函數
fin = open(inputFile, 'r') #以讀的方式打開文件
fout = open(outputFile, 'w') #以寫得方式打開文件
for eachLine in fin: #讀取文件的每一行
line = eachLine.strip().decode('utf-8', 'ignore') #去除每行的首位空格，並且將文件編碼轉換成Unicode編碼
outStr = line #我沒對讀入的文本進行處理，只是直接將其輸出到文件
fout.write(outStr.strip().encode('utf-8') + 'n') #去除首位的空格，並轉回到utf-8編碼，然後輸出
fin.close() #關閉文件
fout.close()
processFile('myinputFile.txt', 'myoutputFile.txt') #調用該函數對文件進行處理

注意：1、由於Python能夠很方便的對Unicode編碼進行處理，所以最好先轉換成Unicode編程進行處理；

2、由於讀入文本後進行處理，可能會在文本末尾加上空格，所以寫入文件的時候，最好先用strip()函數清除一下首位的空格；
我使用的是Linux環境，程序寫完之後，輸入：python test.py 就能執行該程序了。

讀文件
讀文本文件
input = open('data', 'r')
#第二個參數默認為r
input = open('data')

讀二進制文件
input = open('data', 'rb')

讀取所有內容
file_object = open('thefile.txt')
try:
all_the_text = file_object.read( )
finally:
file_object.close( )

讀固定位元組
file_object = open('abinfile', 'rb')
try:
while True:
chunk = file_object.read(100)
if not chunk:
break
do_something_with(chunk)
finally:
file_object.close( )

讀每行
list_of_all_the_lines = file_object.readlines( )
如果文件是文本文件，還可以直接遍歷文件對象獲取每行：
for line in file_object:
process line

3.寫文件
寫文本文件
output = open('data', 'w')

寫二進制文件
output = open('data', 'wb')

追加寫文件
output = open('data', 'w+')

寫數據
file_object = open('thefile.txt', 'w')
file_object.write(all_the_text)
file_object.close( )

寫入多行
file_object.writelines(list_of_text_strings)
注意，調用writelines寫入多行在性能上會比使用write一次性寫入要高。
在處理日誌文件的時候，常常會遇到這樣的情況：日誌文件巨大，不可能一次性把整個文件讀入到內存中進行處理，例如需要在一台物理內存為 2GB 的機器上處理一個 2GB 的日誌文件，我們可能希望每次只處理其中 200MB 的內容。
在 Python 中，內置的 File 對象直接提供了一個 readlines(sizehint) 函數來完成這樣的事情。以下面的代碼為例：
file = open('test.log', 'r')sizehint = 209715200 # 200Mposition = 0lines = file.readlines(sizehint)while not file.tell() - position < 0: position = file.tell() lines = file.readlines(sizehint)
每次調用 readlines(sizehint) 函數，會返回大約 200MB 的數據，而且所返回的必然都是完整的行數據，大多數情況下，返回的數據的位元組數會稍微比 sizehint 指定的值大一點（除最後一次調用 readlines(sizehint) 函數的時候）。通常情況下，Python 會自動將用戶指定的 sizehint 的值調整成內部緩存大小的整數倍。
file在python是一個特殊的類型，它用於在python程序中對外部的文件進行操作。在python中一切都是對象，file也不例外，file有file的方法和屬性。下面先來看如何創建一個file對象：

file(name[, mode[, buffering]])
file()函數用於創建一個file對象，它有一個別名叫open()，可能更形象一些，它們是內置函數。來看看它的參數。它參數都是以字元串的形式傳遞的。name是文件的名字。
mode是打開的模式，可選的值為r w a U，分別代表讀（默認） 寫 添加支持各種換行符的模式。用w或a模式打開文件的話，如果文件不存在，那麼就自動創建。此外，用w模式打開一個已經存在的文件時，原有文件的內容會被清空，因為一開始文件的操作的標記是在文件的開頭的，這時候進行寫操作，無疑會把原有的內容給抹掉。由於歷史的原因，換行符在不同的系統中有不同模式，比如在 unix中是一個n，而在windows中是『rn』，用U模式打開文件，就是支持所有的換行模式，也就說『r』 'n' 'rn'都可表示換行，會有一個tuple用來存貯這個文件中用到過的換行符。不過，雖說換行有多種模式，讀到python中統一用n代替。在模式字元的後面，還可以加上+ b t這兩種標識，分別表示可以對文件同時進行讀寫操作和用二進制模式、文本模式（默認）打開文件。
buffering如果為0表示不進行緩沖;如果為1表示進行「行緩沖「;如果是一個大於1的數表示緩沖區的大小，應該是以位元組為單位的。
file對象有自己的屬性和方法。先來看看file的屬性。

closed #標記文件是否已經關閉，由close()改寫
encoding #文件編碼
mode #打開模式
name #文件名
newlines #文件中用到的換行模式，是一個tuple
softspace #boolean型，一般為0，據說用於print
file的讀寫方法：

F.read([size]) #size為讀取的長度，以byte為單位
F.readline([size])
#讀一行，如果定義了size，有可能返回的只是一行的一部分
F.readlines([size])
#把文件每一行作為一個list的一個成員，並返回這個list。其實它的內部是通過循環調用readline()來實現的。如果提供size參數，size是表示讀取內容的總長，也就是說可能只讀到文件的一部分。
F.write(str)
#把str寫到文件中，write()並不會在str後加上一個換行符
F.writelines(seq)
#把seq的內容全部寫到文件中。這個函數也只是忠實地寫入，不會在每行後面加上任何東西。
file的其他方法：

F.close()
#關閉文件。python會在一個文件不用後自動關閉文件，不過這一功能沒有保證，最好還是養成自己關閉的習慣。如果一個文件在關閉後還對其進行操作會產生ValueError
F.flush()
#把緩沖區的內容寫入硬碟
F.fileno()
#返回一個長整型的」文件標簽「
F.isatty()
#文件是否是一個終端設備文件（unix系統中的）
F.tell()
#返迴文件操作標記的當前位置，以文件的開頭為原點
F.next()
#返回下一行，並將文件操作標記位移到下一行。把一個file用於for ... in file這樣的語句時，就是調用next()函數來實現遍歷的。
F.seek(offset[,whence])
#將文件打操作標記移到offset的位置。這個offset一般是相對於文件的開頭來計算的，一般為正數。但如果提供了whence參數就不一定了，whence可以為0表示從頭開始計算，1表示以當前位置為原點計算。2表示以文件末尾為原點進行計算。需要注意，如果文件以a或a+的模式打開，每次進行寫操作時，文件操作標記會自動返回到文件末尾。
F.truncate([size])
#把文件裁成規定的大小，默認的是裁到當前文件操作標記的位置。如果size比文件的大小還要大，依據系統的不同可能是不改變文件，也可能是用0把文件補到相應的大小，也可能是以一些隨機的內容加上去。