python中級中級階段一

時間  2019-11-16
標籤 python 中級 階段 欄目 Python 简体版
原文   原文鏈接

一. 函數python

函數是組織好的，可重複使用的，用來實現單一，或相關聯功能的代碼段。
函數能提升應用的模塊性，和代碼的重複利用率。你已經知道Python提供了許多內建函數，
好比print()express

定義一個函數
你能夠定義一個由本身想要功能的函數，如下是簡單的規則：
函數代碼塊以 def 關鍵詞開頭，後接函數標識符名稱和圓括號()。
任何傳入參數和自變量必須放在圓括號中間。圓括號之間能夠用於定義參數。
函數的第一行語句能夠選擇性地使用文檔字符串—用於存放函數說明。
函數內容以冒號起始，而且縮進。
return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return至關於返回 None。windows

 

語法
def functionname( parameters ):
"函數_文檔字符串"
function_suite
return [expression]數據結構

return 語句
return語句[表達式]退出函數，選擇性地向調用方返回一個表達式。不帶參數值的return語句返回None
。以前的例子都沒有示範如何返回數值，下例便告訴你怎麼作：閉包

函數調用
定義一個函數只給了函數一個名稱，指定了函數裏包含的參數，和代碼塊結構。
這個函數的基本結構完成之後，你能夠經過另外一個函數調用執行，也能夠直接從Python提示符執行。ide

 # 定義函數函數

def printme( str ):
   "打印任何傳入的字符串"
   print str;
   return;
 
# 調用函數
printme("我要調用用戶自定義函數!");
printme("再次調用同一函數");
View Code

參數傳遞分爲:測試

值傳遞:
string tuple number 是不可變
不可變類型：變量賦值 a=5 後再賦值 a=10，這裏實際是新生成一個
int 值對象 10，再讓 a 指向它，而 5 被丟棄，不是改變a的值，至關於新生成了a。ui

關鍵字參數
關鍵字參數和函數調用關係緊密，函數調用使用關鍵字參數來肯定傳入的參數值。
使用關鍵字參數容許函數調用時參數的順序與聲明時不一致，由於 Python 解釋器可以用參數名匹配參數值。
如下實例在函數 printme() 調用時使用參數名：編碼

#可寫函數說明

def printinfo( name, age ):
   "打印任何傳入的字符串"
   print "Name: ", name;
   print "Age ", age;
   return;
 
#調用printinfo函數
printinfo( age=50, name="miki" );
View Code

#可寫函數說明

def printme( str ):
   "打印任何傳入的字符串"
   print str;
   return;
#調用printme函數
printme( str = "My string");
View Code

 

默認參數

調用函數時 若是沒有傳遞參數就是使用默認參數 若是傳遞了參數就不使用默認參數

def ChangeInt( a=1,b=2 ):
  c=a+b
  return c
ChangeInt()
print (c) # 3
View Code

 

def ChangeInt( a=1,b=2 ):
  c=a+b
  return c
ChangeInt(12,10)
print (c) # 22
View Code

要使用默認參數 最好將默認參數放到最後

def ChangeInt( a,b=2 ):
  c=a+b
  return c
ChangeInt(12)
print (c) # 14
View Code

調用函數時，缺省參數的值若是沒有傳入，則被認爲是默認值。下例會打印默認的age，若是age沒有被傳入：
#!/usr/bin/python
# -*- coding: UTF-8 -*-

#可寫函數說明

def printinfo( name, age = 35 ):
   "打印任何傳入的字符串"
   print "Name: ", name;
   print "Age ", age;
   return;
#調用printinfo函數
printinfo( age=50, name="miki" );
printinfo( name="miki" );
以上實例輸出結果：
Name:  miki
Age  50
Name:  miki
Age  35
View Code

不定長參數
你可能須要一個函數能處理比當初聲明時更多的參數。這些參數叫作不定長參數，和上述2種參數不一樣，聲明時不會命名。基本語法以下：

def functionname([formal_args,] *var_args_tuple ):
   "函數_文檔字符串"
    function_suite
   return [expression]

加了星號（*）的變量名會存放全部未命名的變量參數。不定長參數實例以下：# 可寫函數說明

def printinfo( arg1, *vartuple ):
   "打印任何傳入的參數"
   print "輸出: "
   print arg1
   for var in vartuple:
      print var
   return;
# 調用printinfo 函數
printinfo( 10 );
printinfo( 70, 60, 50 );
View Code

# 可寫函數說明

def printinfo( arg1, *vartuple ):
   "打印任何傳入的參數"
   print "輸出: "
   print arg1
   for var in vartuple:
      print var
   return;
# 調用printinfo 函數
printinfo( 10 );
printinfo( 70, 60, 50 );
View Code

加了星號（*）的變量名會存放全部未命名的變量參數。不定長參數實例以下：# 可寫函數說明

def aa(name,*age): print(name) #張三 for i in age: print(i)#25 28 23 20  aa("張三",25,28,23,20)
View Code

**是表明鍵值對的傳參方式   和*表明的意義同樣

def aa(**name)
   print(name)  #{"a":1,"b":2,"c":3S}
   print(type(name)) #{"class" dict}

aa(a=1,b=2,c=3,d=4)
View Code

匿名函數

python 使用 lambda 來建立匿名函數。
lambda只是一個表達式，函數體比def簡單不少。
lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
lambda函數擁有本身的命名空間，且不能訪問自有參數列表以外或全局命名空間裏的參數。
雖然lambda函數看起來只能寫一行，卻不等同於C或C++的內聯函數，
後者的目的是調用小函數時不佔用棧內存從而增長運行效率。

語法
lambda函數的語法只包含一個語句，以下：
lambda [arg1 [,arg2,.....argn]]:expression

# 可寫函數說明

sum = lambda arg1, arg2: arg1 + arg2;
# 調用sum函數
print "相加後的值爲 : ", sum( 10, 20 )
print "相加後的值爲 : ", sum( 20, 20 )

# 相加後的值爲 :  30
# 相加後的值爲 :  40
View Code

# 偏函數

import functools
# functools模塊用於高階函數：做用與或者返回其它函數的函數。
# 通常來講，對於該模塊，任何可調用對象均可以視爲一個函數。

def int2(str,base=2):
    return int(str,base)
print(int2("11111"))
View Code 
def int2(str,base=2):
    return int(str,base)
print(int2("11111"))

# 把一個參數固定住 造成一個新的函數

int3=functools.partial(int,base=2)
print(int3("111"))
# 進制的換算

# 31
# 7
View Code

變量做用域
一個程序的全部的變量並非在哪一個位置均可以訪問的。訪問權限決定於這個變量是在哪裏賦值的。
變量的做用域決定了在哪一部分程序你能夠訪問哪一個特定的變量名稱。兩種最基本的變量做用域以下：
全局變量

全局變量和局部變量
定義在函數內部的變量擁有一個局部做用域，
定義在函數外的擁有全局做用域。

局部變量只能在其被聲明的函數內部訪問，
而全局變量能夠在整個程序範圍內訪問。調用函數時，全部在函數內聲明的變量名稱

total = 0; # 這是一個全局變量
# 可寫函數說明
def sum( arg1, arg2 ):
   #返回2個參數的和."
   total = arg1 + arg2; # total在這裏是局部變量.
   print "函數內是局部變量 : ", total
   return total;
 
#調用sum函數
sum( 10, 20 );
print "函數外是全局變量 : ", total 


# 把局部變量改爲全局變量
name=111110000000000000000000
def AA():
   global name    #   global  意思就是把局部變量改爲全局變量
   name=2220000
   print(name)

AA()
print(name)
View Code

# 把局部變量改爲全局變量

"""
name=111110000000000000000000

def AA():
   global name    #   global   將全局變量  變成局部變量
   name=2220000
   print(name)   # 2220000
AA()

print(name)   # 2220000
"""

"""一、global---將變量定義爲全局變量。能夠經過定義爲全局變量，實如今函數內部改變變量值。
二、一個global語句能夠同時定義多個變量，如 global x, y, z"""


# 注意： 若是函數的內容global 關鍵字 優先讀取局部變量   只能讀取全局變量 沒法從新賦值
# 
#注意函數中有global 關鍵字 變量本質上就是全局的那個變量  能夠賦值
a='張三'

def aa():
   global a
   print('您好',a)         # 您好 張三
   a='李四'
   print('lover',a)       # lover 李四


def bb():
   a=111111

   print('這是',a)        # 這是 111111

aa()
bb()
View Code

 

二. 閉包裝飾器

# 概念: 是一個閉包 把一個函數當作參數返回一個替代的函數 本質上就是一個返回函數的函數

 # 簡單的函數裝飾器

def fun1():
 print("哈哈哈哈哈哈name")

def fun2():
   print("啦啦啦啦啦啦啦")
   fun1()
fun2()
View Code

 # 概念: 是一個閉包  把一個函數當作參數返回一個替代的函數 本質上就是一個返回函數的函數

# 簡單的函數裝飾器

# def fun1():

#  print("哈哈哈哈哈哈name")

# def fun2():
#    print("啦啦啦啦啦啦啦")
#    fun1()
# fun2()
View Code 
def fun1():
    print("111111111111111111")
def outer(func):
    def inner():
       print("222222222222222222")
       func()
    return inner
    # f是函數func1的增強版本
f=outer(fun1)
f()      

# 222222222222222222
# 111111111111111111
View Code 
def fun1():
    print("111111111111111111")
def outer(func):
    def inner():
       print("222222222222222222")
       func()
    return inner
    # f是函數func1的增強版本
f=outer(fun1)
f()      

# 222222222222222222
# 111111111111111111
View Code 
# 概念: 是一個閉包  把一個函數當作參數返回一個替代的函數 本質上就是一個返回函數的函數


# 簡單的函數裝飾器
def fun1():
 print("哈哈哈哈哈哈name")
def fun2():
   print("啦啦啦啦啦啦啦")
   fun1()
fun2()




# def say(age):
#     print(age)
# say(-10) #-10
# def outer(func):
#     def inner(age):
#          if age<0:
#            age=0
#          func(age)
#     return inner
# s=outer(say)
# s(-10)       #0            


概念: 是一個閉包  把一個函數當作參數返回一個替代的函數 本質上就是一個返回函數的函數
View Code

通常裝飾器

# 概念: 是一個閉包  把一個函數當作參數返回一個替代的函數 本質上就是一個返回函數的函數
# 簡單的函數裝飾器


# def fun1():
#  print("哈哈哈哈哈哈name")



# def fun2():
#    print("啦啦啦啦啦啦啦")
#    fun1()
# fun2()



def outer(func):
    def inner(*args,**kwargs):
         #添加功能
         print("***************")
             
         func(*args,**kwargs)
    return inner
# @至關於say=outer(say)
@outer     
def say(name,age): #函數參數最後不要超過7個
    print(name ,age)            
say("張三",1000)
# ***************
# 張三 1000
# 


def say(name ,age):  # 函數參數最後不要超過7個
   print(name ,age)
say("張三", 1000)
def outer(func):
   def inner(*args ,**kwargs):
      # 添加功能
      print("***************")

      func(*args ,**kwargs)
   return inner
# @outer  
aa=outer(say)
aa("扣扣",25)
# 張三 1000
# ***************
# 扣扣 25
View Code 
# 概念: 是一個閉包  把一個函數當作參數返回一個替代的函數 本質上就是一個返回函數的函數
# 簡單的函數裝飾器


def fun1():
 print("哈哈哈哈哈哈name")
def fun2():
   print("啦啦啦啦啦啦啦")
   fun1()
fun2()



# def say(age):
#     print(age)
# say(-10) #-10
# def outer(func):
#     def inner(age):
#          if age<0:
#            age=0
#          func(age)
#     return inner
# s=outer(say)
# s(-10)       #0            


概念: 是一個閉包  把一個函數當作參數返回一個替代的函數 本質上就是一個返回函數的函數




def outer(func):
    def inner(age):
         if age<0:
           age=0
         func(age)
    return inner

# @至關於say=outer(say)
@outer
def say(age):
    print(age)

say(-10)
View Code

 

三. 異常處理

捕捉異常可使用try/except語句。
try/except語句用來檢測try語句塊中的錯誤，從而讓except語句捕獲異常信息並處理。
若是你不想在異常發生時結束你的程序，只需在try裏捕獲它。

try:
<語句> #運行別的代碼
except <名字>：
<語句> #若是在try部份引起了'name'異常
except <名字>，<數據>:
<語句> #若是引起了'name'異常，得到附加的數據
else:
<語句> #若是沒有異常發生

格式:
try :
語句1
except 錯誤代碼 as e:

語句2

except 錯誤代碼 as e:

語句3

......
except 錯誤代碼 as e:

語句n
else:

語句e

注意 else 無關緊要

做用: 用來檢測try 語句塊的錯誤 從而讓except語句捕獲異常信息並處理

邏輯: 當程序執行到try ---except --else 語句時

1 若是try 語句1 執行出現錯誤 會匹配第一個錯誤碼 若是匹配上就執行 語句

2 若是當try 語句1 執行出現錯誤 沒有匹配的異常 錯誤將會 被提交到上一層的try 語句 或者到程序的最上一層

3 若是當try 語句1 執行沒有出現錯誤 執行else 下的語句e

異常名稱 描述
BaseException 全部異常的基類
SystemExit 解釋器請求退出
KeyboardInterrupt 用戶中斷執行(一般是輸入^C)
Exception 常規錯誤的基類
StopIteration 迭代器沒有更多的值
GeneratorExit 生成器(generator)發生異常來通知退出
StandardError 全部的內建標準異常的基類
ArithmeticError 全部數值計算錯誤的基類
FloatingPointError 浮點計算錯誤
OverflowError 數值運算超出最大限制
ZeroDivisionError 除(或取模)零 (全部數據類型)
AssertionError 斷言語句失敗
AttributeError 對象沒有這個屬性
EOFError 沒有內建輸入,到達EOF 標記
EnvironmentError 操做系統錯誤的基類
IOError 輸入/輸出操做失敗
OSError 操做系統錯誤
WindowsError 系統調用失敗
ImportError 導入模塊/對象失敗
LookupError 無效數據查詢的基類
IndexError 序列中沒有此索引(index)
KeyError 映射中沒有這個鍵
MemoryError 內存溢出錯誤(對於Python 解釋器不是致命的)
NameError 未聲明/初始化對象 (沒有屬性)
UnboundLocalError 訪問未初始化的本地變量
ReferenceError 弱引用(Weak reference)試圖訪問已經垃圾回收了的對象
RuntimeError 通常的運行時錯誤
NotImplementedError 還沒有實現的方法
SyntaxError Python 語法錯誤
IndentationError 縮進錯誤
TabError Tab 和空格混用
SystemError 通常的解釋器系統錯誤
TypeError 對類型無效的操做
ValueError 傳入無效的參數
UnicodeError Unicode 相關的錯誤
UnicodeDecodeError Unicode 解碼時的錯誤
UnicodeEncodeError Unicode 編碼時錯誤
UnicodeTranslateError Unicode 轉換時錯誤
Warning 警告的基類
DeprecationWarning 關於被棄用的特徵的警告
FutureWarning 關於構造未來語義會有改變的警告
OverflowWarning 舊的關於自動提高爲長整型(long)的警告
PendingDeprecationWarning 關於特性將會被廢棄的警告
RuntimeWarning 可疑的運行時行爲(runtime behavior)的警告
SyntaxWarning 可疑的語法的警告
UserWarning 用戶代碼生成的警告

try:
    fh = open("testfile", "w")
    fh.write("這是一個測試文件，用於測試異常!!")
except IOError:
    print "Error: 沒有找到文件或讀取文件失敗"
else:
    print "內容寫入文件成功"
    fh.close()
以上程序輸出結果：
$ python test.py 
內容寫入文件成功
$ cat testfile       # 查看寫入的內容
這是一個測試文件，用於測試異常!!
View Code 
try:
    print(3/1)
except NameError as e:
    print("沒有改變量")
except ZeroDivisionError as e:
     print("除數爲0")
else:
    print("代碼沒有問題了")
print(".....................................")

# 使用except 而不使用 任何的錯誤類型
try:
    print(4/0)
    print(num)
except:
    print("程序出現了異常")
# 使用except帶有多種異常
try:
   print(5/0)
except(NameError,ZeroDivisionError)
View Code

 

格式:
try :
     語句1
except 錯誤代碼 as e:
    語句2
except 錯誤代碼 as e:
    語句3
......
except 錯誤代碼 as e:
    語句n
finally:

    語句f
    
做用 :語句t不管是否有錯誤 都講執行最後的語句



try: 
    print(1/0)
finally:
    print("必須執行我")
View Code

以上例子無論 try 子句裏面有沒有發生異常，finally 子句都會執行。
若是一個異常在 try 子句裏（或者在 except 和 else 子句裏）被拋出，
而又沒有任何的 except 把它截住，那麼這個異常會在 finally 子句執行後再次被拋出。
下面是一個更加複雜的例子（在同一個 try 語句裏包含 except 和 finally 子句）:

格式:

try :
     語句1
except 錯誤代碼 as e:

    語句2

except 錯誤代碼 as e:

    語句3

......
except 錯誤代碼 as e:

    語句n
finally:

    語句f
    
做用 :語句t不管是否有錯誤 都講執行最後的語句f

try: 
    print(1/0)

finally:

    print("必須執行我")
View Code

 

四. 時間函數

協調世界時(英:Coordinated Universal Time ，法:Temps Universel Coordonné)，又稱世界統一時間，世界標準時間，
國際協調時間。英文(CUT)和法文(TUC)的縮寫不一樣，做爲妥協，簡稱UTC。
在中國 來講是 UTC+8

DST
DST是Daylight Saving Time的縮寫，稱爲陽光節約時，在我國稱爲夏時制，
又稱夏令時，是一種爲節約能源而人爲調整地方時間的制度。
有些國家DST的使用時間較長，(如美國長達7個月)跨越了春夏秋等三個季節

 時間表現的形勢:

1 時間戳

以整型 或浮點型表示時間的一個以秒爲單位的時間間隔
這個時間 時間間隔的基礎值是1970年1月1號零點開始算起

2 元組

一種python 的數據結構表示 這個元組有9 個整型內容

year

month

day

hours

minutes

seconds

weekday

julia day

flag(1 或 -1 或0)

 3 格式化字符串 

 

%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 當前時區的名稱
%% %號自己

# 返回當前時間的時間戳 浮點數 形式    不須要參數
import time;  # 引入time模塊

c=time.time()
print(c)  #1528132954.339143


# 將時間戳 轉爲utc時間元組
t=time.gmtime(c)
print(t)            #time.struct_time(tm_year=2018, tm_mon=6, tm_mday=4, tm_hour=17, tm_min=23, tm_sec=27, tm_wday=0, tm_yday=155, tm_isdst=0)


# 將時間戳轉爲本地時間元組
b=time.localtime(c) #time.struct_time(tm_year=2018, tm_mon=6, tm_mday=5, tm_hour=1, tm_min=26, tm_sec=31, tm_wday=1, tm_yday=156, tm_isdst=0)
print(b)


# 將第時間元組 轉成時間戳
m=time.mktime(b)

print(m)   #1528133464.0


# 將時間元組轉換成字符串
s=time.asctime(b)
print(s) #Tue Jun  5 01:33:34 2018


# 將時間戳轉換爲字符

p=time.ctime(c)
print(p)     #  Tue Jun  5 01:35:49 2018


# 將時間元組轉換成給定格式的字符串   若是沒有參數2 默認轉換爲當前時間 
q=time.strftime("%Y-%m-%d %H:%M:%S")

print(q) #2018-06-05 01:40:38


# 將時間元組轉換成給定格式的字符串 參數2爲時間元組 若是沒有參數2 默認轉換爲當前時間  
h=time.strftime("%Y-%m-%d %H:%M:%S",b) 

print(h) #2018-06-05 01:42:48



l=time.strftime("%Y-%m-%d %X",b) 

print(l) #2018-06-05 01:46:40
print(type(l))  #<class 'str'>


# 將時間字符串轉換爲時間元組
w=time.strptime(q,"%Y-%m-%d %X")
print(w) #time.struct_time(tm_year=2018, tm_mon=6, tm_mday=5, tm_hour=1, tm_min=49, tm_sec=59, tm_wday=1, tm_yday=156, tm_isdst=-1)


# 延遲一個時間  整型或者浮點型
# time.sleep(4)


# 返回當前程序的cpu 執行時間
# Unix 系統同時返回所有時間
# windows從第二次開始 都是以第一個調用函數的開始時間戳做爲基數
c1=time.clock()
print(c1)          #1.7104874547148446e-06

 

 

實例 

import time

time.clock()
sum=0

for x in range(10000000):
    sum+=x

print(time.clock())  #3.0864349222241354

# datetime 比time高級了很多 能夠理解爲datetime基於time進行封裝
# 提供了各位使用的函數 date模塊的接口更直觀 更容易

# datetime  比time高級了很多  能夠理解爲datetime基於time進行封裝 
# 提供了各位使用的函數 date模塊的接口更直觀  更容易


# 模塊中的類:

#       datetime   同時又時間日期              

#       timedelta  主要計算時間的跨度

#       tzinfo     時區相關

#       time     只關注時間

#       date  只關注日期


import datetime  # 引入time模塊


# 獲取當前時間
d1=datetime.datetime.now()

print(d1)            #2018-06-05 18:20:22.763177
print(type(d1))     # <class 'datetime.datetime'>



# 獲取指定的時間

d2=datetime.datetime(1999,10,1,10,28,25,123456)
print(d2)  #1999-10-01 10:28:25.123456




# 將時間轉爲字符串
d3=d1.strftime("%Y-%m-%d %X")
print(d3)  #18-06-05 18:26:02         2018-06-05 18:26:30






# 將格式字符串轉爲datetime對象
# 注意的格式要與字符串一致
d4=datetime.datetime.strptime(d3,"%Y-%m-%d %X")

print(d4) #2018-06-05 18:28:44


# dtaetime 時間類型還能夠加減

d5=datetime.datetime(1999,10,1,10,28,25,123456)

d6=datetime.datetime.now()

d7=d6-d5

print(d7)        #6822 days, 8:03:35.068612
print(type(d7))   # <class 'datetime.timedelta'> 
# 能獲取到間隔天數
print(d7.days)  
# 獲取間隔天數覺得的秒數
print(d7.seconds) #29133

 

 # 日曆模塊

 

import calendar

# 日曆模塊

# 使用


# 返回指定某年某月的日曆
print(calendar.month(2017,7))

#      July 2017
# Mo Tu We Th Fr Sa Su
#                 1  2
#  3  4  5  6  7  8  9
# 10 11 12 13 14 15 16
# 17 18 19 20 21 22 23
# 24 25 26 27 28 29 30
# 31


# 返回指定一年的日曆
# print(calendar.calendar(2018))
#                                   2018

#       January                   February                   March
# Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
#  1  2  3  4  5  6  7                1  2  3  4                1  2  3  4
#  8  9 10 11 12 13 14       5  6  7  8  9 10 11       5  6  7  8  9 10 11
# 15 16 17 18 19 20 21      12 13 14 15 16 17 18      12 13 14 15 16 17 18
# 22 23 24 25 26 27 28      19 20 21 22 23 24 25      19 20 21 22 23 24 25
# 29 30 31                  26 27 28                  26 27 28 29 30 31

#        April                      May                       June
# Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
#                    1          1  2  3  4  5  6                   1  2  3
#  2  3  4  5  6  7  8       7  8  9 10 11 12 13       4  5  6  7  8  9 10
#  9 10 11 12 13 14 15      14 15 16 17 18 19 20      11 12 13 14 15 16 17
# 16 17 18 19 20 21 22      21 22 23 24 25 26 27      18 19 20 21 22 23 24
# 23 24 25 26 27 28 29      28 29 30 31               25 26 27 28 29 30
# 30

#         July                     August                  September
# Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
#                    1             1  2  3  4  5                      1  2
#  2  3  4  5  6  7  8       6  7  8  9 10 11 12       3  4  5  6  7  8  9
#  9 10 11 12 13 14 15      13 14 15 16 17 18 19      10 11 12 13 14 15 16
# 16 17 18 19 20 21 22      20 21 22 23 24 25 26      17 18 19 20 21 22 23
# 23 24 25 26 27 28 29      27 28 29 30 31            24 25 26 27 28 29 30
# 30 31

#       October                   November                  December
# Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
#  1  2  3  4  5  6  7                1  2  3  4                      1  2
#  8  9 10 11 12 13 14       5  6  7  8  9 10 11       3  4  5  6  7  8  9
# 15 16 17 18 19 20 21      12 13 14 15 16 17 18      10 11 12 13 14 15 16
# 22 23 24 25 26 27 28      19 20 21 22 23 24 25      17 18 19 20 21 22 23
# 29 30 31                  26 27 28 29 30            24 25 26 27 28 29 30
#                                                     31

# 能夠判斷是否爲閏年    這返回true  不然返回false
print(calendar.isleap(2000))  #True      


# 返回某個月的weekday的第一天和這個月全部天數
print(calendar.monthrange(2017,7))   # (5, 31)   5表示某個月的weekday的第一天       31 表示是31天


# 返回某個月  以每一週爲元素的列表
# print(calendar.monthcalender(2018,7))
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程