python時鍾

1. python可以製作時鍾嗎

調試調試，參考參考

import sys
from PyQt4 import QtGui, QtCore
from PyQt4.QtCore import Qt
from PyQt4.QtCore import QPoint
from PyQt4.QtCore import QTimer
from PyQt4.QtCore import QTime
from PyQt4.QtGui import QPainter
from PyQt4.QtGui import QColor
from PyQt4.QtGui import QPolygon
from PyQt4.QtCore import SIGNAL as signal

class Clock(QtGui.QWidget):
'''
classdocs
'''

def __init__(self):
'''
Constructor
'''
super(Clock, self).__init__()
self.hourColor=QColor(127, 0, 127);
self.minuteColor=QColor(0, 127, 127, 191)
self.secondColor=QColor(127, 127,0,120)
self.initUI()
self.timer = QTimer()
self.timer.timeout.connect(self.update)
self.timer.start(30)
self.show()

def handChange(self):

self.side = min(self.width(), self.height())
self.hand=(max(self.side/200,4), max(self.side/100,8), max(self.side/40,30))
self.hourHand=QPolygon([QPoint(self.hand[0],self.hand[1]),QPoint(-self.hand[0],self.hand[1]),QPoint(0,-self.hand[2])])
self.minuteHand=QPolygon([QPoint(self.hand[0],self.hand[1]),QPoint(-self.hand[0],self.hand[1]),QPoint(0,-self.hand[2]*2)])
self.secondHand=QPolygon([QPoint(self.hand[0],self.hand[1]),QPoint(-self.hand[0],self.hand[1]),QPoint(0,-self.hand[2]*3)])

def set_transparency(self, enabled):
if enabled:
self.setAutoFillBackground(False)
else:
self.setAttribute(Qt.WA_NoSystemBackground, False)
#下面這種方式好像不行
# pal=QtGui.QPalette()
# pal.setColor(QtGui.QPalette.Background, QColor(127, 127,10,120))
# self.setPalette(pal)
self.setAttribute(Qt.WA_TranslucentBackground, enabled)
self.repaint()

def initUI(self):

self.setGeometry(300, 300, 300, 200)
self.setWindowTitle('Clock')
self.handChange()
self.rightButton=False
# 下面兩個配合實現窗體透明和置頂
sizeGrip=QtGui.QSizeGrip(self)
self.setWindowFlags(Qt.FramelessWindowHint|Qt.WindowStaysOnTopHint|Qt.SubWindow )
#self.setMouseTracking(True);
self.trans=True

self.set_transparency(True)

quitAction = QtGui.QAction(QtGui.QIcon('quit.png'), '&Quit', self)
self.connect(quitAction,signal("triggered()"),QtGui.qApp.quit)
backAction = QtGui.QAction( '&Back', self)
self.connect(backAction,signal("triggered()"),self.backClicked)
self.popMenu= QtGui.QMenu()
self.popMenu.addAction(quitAction)
self.popMenu.addAction(backAction)

def resizeEvent(self, e):
self.handChange()

def backClicked(self):
if self.trans == True :
self.trans = False
self.set_transparency(False)
else:
self.trans = True
self.set_transparency(True)

def mouseReleaseEvent(self,e):
if self.rightButton == True:
self.rightButton=False
self.popMenu.popup(e.globalPos())

def mouseMoveEvent(self, e):
if e.buttons() & Qt.LeftButton:
self.move(e.globalPos()-self.dragPos)
e.accept()
def mousePressEvent(self, e):

if e.button() == Qt.LeftButton:
self.dragPos=e.globalPos()-self.frameGeometry().topLeft()
e.accept()
if e.button() == Qt.RightButton and self.rightButton == False:
self.rightButton=True

def paintEvent(self, e):
time = QTime.currentTime()
qp = QPainter()

qp.begin(self)
qp.setRenderHint(QPainter.Antialiasing) # 開啟這個抗鋸齒,會很佔cpu的!
qp.translate(self.width() / 2, self.height() / 2)
qp.scale(self.side / 200.0, self.side / 200.0)

qp.setPen(QtCore.Qt.NoPen)
qp.setBrush(self.hourColor)
qp.save()
qp.rotate(30.0 * ((time.hour() + time.minute()/ 60.0)))
qp.drawConvexPolygon(self.hourHand)
qp.restore()

qp.setPen(self.hourColor)
for i in range(12):
qp.drawLine(88, 0, 96, 0)
qp.rotate(30.0)

qp.setPen(QtCore.Qt.NoPen)
qp.setBrush(self.minuteColor)
qp.save()

qp.rotate(6.0 * ((time.minute() + (time.second()+time.msec()/1000.0) / 60.0)))
qp.drawConvexPolygon(self.minuteHand)
qp.restore()

qp.setPen(self.minuteColor)
for i in range(60):
if (i % 5) is not 0:
qp.drawLine(92, 0, 96, 0)
qp.rotate(6.0)

qp.setPen(QtCore.Qt.NoPen)
qp.setBrush(self.secondColor)
qp.save()
qp.rotate(6.0*(time.second()+time.msec()/1000.0))
qp.drawConvexPolygon(self.secondHand)
qp.restore()
qp.end()
if __name__ == '__main__':
app = QtGui.QApplication(sys.argv)
clock = Clock()
sys.exit(app.exec_())

2. python問題 求解

#python6.6
classClock:
def__init__(self,hour,minute,second):
self.h=hour
self.m=minute
self.s=second

defprintTime(self):
#{:+0填充+右對齊+固定寬度2+數據類型整數}
print("{:>2d}:{:0>2d}:{:0>2d}".format(self.h,self.m,self.s))

deftest():
hs=[8,9,10]
ms=[30,45,5]
ss=[0,15,49]

c1=Clock(hs[0],ms[0],ss[0])
c2=Clock(hs[1],ms[1],ss[1])
c3=Clock(hs[2],ms[2],ss[2])
c1.printTime()
c2.printTime()
c3.printTime()


if__name__=="__main__":
test()

我測試沒問題。

3. 用Python中threading模塊怎麼實現線程間時鍾同步

用一個全局變數來保存這個時鍾。其實線程直接訪問這個全局的變數來獲取時鍾信息。

4. python怎麼修改linux系統時間

1、修改系統時間。 linux系統時鍾有兩個，一個是硬體時鍾，即BIOS時間，就是我們進行CMOS設置時看到的時間，另一個是系統時鍾，是linux系統Kernel時間。當Linux啟動時，系統Kernel會去讀取硬體時鍾的設置，然後系統時鍾就會獨立於硬體運作。

5. python time.clock 和time.time的區別

一，兩個函數的文檔：

1，time.time():

time.time()

Return
the time in seconds since the epoch as a floating point number. Note
that even though the time is always returned as a floating point number,
not all systems provide time with a better precision than 1 second.
While this function normally returns non-decreasing values, it can
return a lower value than a previous call if the system clock has been
set back between the two calls.

time.time()

返回從紀元（1970.1.1）至今的秒數。雖然這個函數的返回值永遠為浮點數，但並不是所有系統提供的秒數都會精確到小數點以後。一般情況下這個函數的返回值不會小於它上一次被調用的返回值，除非系統時鍾在兩次調用之間發生了重置。

2，time.clock():

time.clock()

On
Unix, return the current processor time as a floating point number
expressed in seconds. The precision, and in fact the very definition of
the meaning of 「processor time」, depends on that of the C function of
the same name, but in any case, this is the function to use for
benchmarking Python or timing algorithms.
On Windows, this
function returns wall-clock seconds elapsed since the first call to this
function, as a floating point number, based on the Win32 function QueryPerformanceCounter(). The resolution is typically better than one microsecond.

time.clock()

在Unix 中，將當前的處理器時間以浮點數的形式返回，單位為秒。它的精確度（准確地說是「處理器時間」的精確度）取決於同名的C函數，無論如何，這個函數是python關於時間計算的標尺。

WINDOWS中，第一次調用，返回的是進程運行的實際時間。而第二次之後的調用是自第一次調用以後到現在的運行時間。（實際上是以WIN32上QueryPerformanceCounter()為基礎，它比毫秒錶示更為精確）

二，用法及總結
1，在Windows中，time.clock()更精確；
2，這兩個函數不可以混合使用；

6. Python語言寫秒錶計時器的GUI的方法

tk就是最基礎的，一些好的你需要wxpython或qt。數字時鍾倒是可以實現

7. 用python，turtle繪制數字，如繪制260這三個數字，同時要求每個數字填不同的顏色

1、雙擊打開pycharm開發工具，在已新建的項目中新建python文件，輸入文件名稱。

8. python 時鍾嘀嗒數獲取

你可以試下下面的方式來取得當前時間的時間戳：
import time
print time.time()
輸出的結果是：
1279578704.6725271
但是這樣是一連串的數字不是我們想要的結果，我們可以利用time模塊的格式化時間的方法來處理：
time.localtime(time.time())
用time.localtime()方法，作用是格式化時間戳為本地的時間。
輸出的結果是：
time.struct_time(tm_year=2010, tm_mon=7, tm_mday=19, tm_hour=22, tm_min=33, tm_sec=39, tm_wday=0, tm_yday=200, tm_isdst=0)
現在看起來更有希望格式成我們想要的時間了。
time.strftime('%Y-%m-%d',time.localtime(time.time()))
最後用time.strftime()方法，把剛才的一大串信息格式化成我們想要的東西，現在的結果是：
2010-07-19
time.strftime裡面有很多參數，可以讓你能夠更隨意的輸出自己想要的東西：
下面是time.strftime的參數：
strftime(format[, tuple]) -> string
將指定的struct_time(默認為當前時間)，根據指定的格式化字元串輸出
python中時間日期格式化符號：
%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 當前時區的名稱
%% %號本身

9. 為什麼在python中是ioc / di不常見

1. 其實我不認為直接投資/ IoC是在Python。什麼是卻是直接投資/ IoC。
想想看：什麼是一個DI容器呢？它可以讓你
連線連成應用程序...
...在
我們有「接線合」及「
腳本
動態
所以，一個DI容器不過是一個解釋的動態腳本語言。實際上，另一種方式是：一個典型的Java / .NET的DI容器不過是一個蹩腳的解釋器一個非常糟糕的動態腳本語言與對接醜陋，往往基於XML的語法。
當你在Python程序，你為什麼會想要一個醜陋的，壞的腳本語言，當你有一個美麗的 CodeGo.net，輝煌的腳本語言在您的處置？其實，這是一個更普遍的問題：當您在幾乎任何語言進行編程，為什麼你想，當你有Jython和IronPython的在您的處置一個醜陋的，壞的腳本語言？
因此，要概括一下：DI / IOC的做法是一樣重要的在Python中，因為它是在Java中，對於完全相同的原因。該DI / IOC的但是，是建立在語言和經常如此輕巧的消失。 （這里有一個比喻：在組裝，子程序調用是一個相當大的交易-你要保存你的局部變數和寄存器保存返回地址的指令指針更改為你所呼叫的子程序，安排它跳回你的子程序當它完成時，把那裡的被叫方可以找到他們，等IOW：在組裝，「子程序調用」是一種設計模式，和之前有類似的Fortran語言，其中有建於子程序調用，人們建立自己的自己的「子程序你會說，子程序調用是」在Python中，只是你不'子程序
BTW：對於什麼樣子採取DI其邏輯的例子來看看吉rad的Bracha的新話編程語言以及他的著作的主題：
構造函數是有害的
注入死刑
禁止對導入（續）
2.
部分原因是模塊系統工作在Python的方式。你可以得到一種「單身」free的，只是從一個模塊中導入它。定義一個對象的實際實例中的一個模塊，然後任何客戶端端代碼可以導入並真正得到一個工作，全面構建/填充對象。
這是相對於Java的，在那裡你不導入對象的實際情況。你總是有自己實例化它們，（排序的IoC / DI樣式的方法）。您可以減輕不必自己所擁有的靜態（或實際工廠類）實例化一切的trouble，但你仍然招致實際創建新的每項資源開銷
3.
使得Django的控制反轉的。例如，資料庫伺服器被選中的配置文件，然後提供相應的資料庫封裝實例的資料庫客戶端端。
不同的是，Python有一流的類型。數據類型，包括類，都是自己的對象。如果你想要一個特定的類，只是這個類。例如：
if config_dbms_name == 'postgresql':
import psycopg
self.database_interface = psycopg
elif config_dbms_name == 'mysql':
...

再後來的代碼可以通過書面表單創建一個資料庫介面：
my_db_connection = self.database_interface()
# Do stuff with database.

取而代之的樣板工廠的函數，Java和C ++的需要，Python做它與普通的代碼一行或兩行。這是函數性命令式編程的力量。
4.
在我看來，這樣的事情依賴注入是一個剛性的，當代碼過於沉重的主體輕易改變，你會發現自己不得不挑了小部分，定義介面為他們，然後讓人們改變行為症狀通過該插入這些介面的對象。這一切都很好，但最好避免在首位那種。
這也是一個靜態類型語言的症狀。當你要表達抽象的唯一工具是繼承，那麼這就是幾乎什麼無處不在。話雖如此，C ++是非常類似的，但從來沒有拿起迷戀建設者和介面無處不在的Java開發人員做了。這是很容易得到過度旺盛能夠以靈活且可擴展的，很少真正的好處寫了太多的通用代碼的成本的夢想。我認為這是一個文化的東西。
通常情況下，我認為Python的人來選擇合適的工具來完成工作，這是一個連貫的和簡單的整體，而不是一個真正的工具（一個可能的插件），可以做什麼，但提供了可能的配置排列讓人眼花繚亂。還是有可互換的零件在必要時，但不需要定義固定介面，由於鴨打字和語言的相對簡單的靈活性大表單主義。
5.
避風港'的Python在好幾年，但我會說，它更多的是與它是一個動態類型的語言比什麼都重要。舉個簡單的例子，在Java中，如果我想測試寫信給標准輸出適當地我DI和傳遞任何的PrintStream捕捉寫入的文字並進行驗證。當我在Ruby中我的工作，但是，我可以動態替換「看跌期權」的方法在標准輸出做驗證，留出來的圖片。如果我創建一個抽象的唯一原因是測試類，「它（認為文件系統操作或Java中的時鍾），那麼直接投資/ IoC創建的解決方案。
6.
我回來「約爾格・W米塔格」回答：「DI / IOC的Python是如此輕巧的消失」。
要備份此看一看在Martin Fowler的例子移植從Java到Python：Python的：Design_Patterns：Inversion_of_Control
正如您可以從上面的鏈接，一個「容器」在Python中看到可以寫成8行代碼：
class Container:
def __init__(self, system_data):
for component_name, component_class, component_args in system_data:
if type(component_class) == types.ClassType:
args = [self.__dict__[arg] for arg in component_args]
self.__dict__[component_name] = component_class(*args)
else:
self.__dict__[component_name] = component_class

7.
IoC和ruby，這是我的想法，為什麼它沒有被廣泛流傳
更新：
我不支持那個網站了，鏈接不工作，但可以在這里閱讀
8.
其實，這是很容易寫出足夠干凈的代碼與DI（我不知道，會不會被/ Python的停留，然後，但無論如何:)），例如我其實perefer這樣編碼：
def polite(name_str):
return "dear " + name_str
def rude(a):
return name_str + ", you, moron"
def greet(name_str, call=polite):
print "Hello, " + call(name_str) + "!"

_
>>greet("Peter")
Hello, dear Peter!
>>greet("Jack", rude)
Hello, Jack, you, moron!

是的，這可以看作是函數/類只是一個簡單的表單，但它確實工作。所以，也許Python的默認附帶的電池足夠在這里了。
P.S.我也貼這種幼稚的做法一個更大的示例在動態評估在Python簡單的布爾邏輯。

10. 用python如何爬取網上的鍾表圖片

需要訓練一個鍾表的識別模型