# Python語句中一般以新行作為語句的結束符。但是我們可以使用【斜槓（ \）】將一行的語句分為多行顯示，
# 語句中包含 [], {} 或 () 括號就不需要使用多行連線符。
# Python可以在同一行中使用多條語句，語句之間使用【分號(;)】分割
total = item_one + \
        item_two + \
        item_three
days = ['Monday', 'Tuesday', 'Wednesday',
        'Thursday', 'Friday']

# Python可以在同一行中使用多條語句，語句之間使用【分號(;)】分割。
import sys; x = 'runoob'; sys.stdout.write(x + '\n')

# Python 可以使用【引號( ' )、雙引號( " )、三引號( ''' 或 """ ) 】來表示字串
word = 'word'
sentence = "這是一個句子。"
paragraph = """這是一個段落。
包含了多個語句"""

# print 預設輸出是換行的，如果要實現【不換行需要在變數末尾加上逗號】 。
print x,y

counter = 100 # 賦值整型變數
miles = 1000.0 # 浮點型
name = "John" # 字串

二進位制轉換：
int('10',2) 
> 2
bin(10)
> '0b1010'
bin(10)[2:]

ord(c) # c為字元
# 返回值：對應的十進位制整數（ASCll數值）
int(c) # c為字元，轉化為對應的數位

float('-inf') # 最小值
-inf

a = b = c = 1
a, b, c = 1, 2, "john"

all() # 函數用於判斷給定的可迭代引數 iterable 中的所有元素是否都為 TRUE，如果是返回 True，否則返回 False。

# 從左到右索引預設【0開始的】，最大範圍是字串【長度少1】
# 從右到左索引預設【-1開始的】，最大範圍是【字串開頭】
# 第三個引數，引數作用是【擷取的步長】
s = "a1a2···an"   # n>=0

向上取整：math.ceil()
向下取整：math.floor()、整除"//"
四捨五入：round()——奇數向遠離0取整，偶數去尾取整；或言之：奇數進位，偶數去尾
向0取整：int()

tinylist = [123, 'john']
print list[0]            # 輸出列表的第一個元素
print list[1:3]          # 輸出第二個至第三個元素 
print list[2:]           # 輸出從第三個開始至列表末尾的所有元素

# 二維陣列
num_list = [ [0] * 5 for i in range(2)]
dp = [[1]*n] + [[1]+[0] * (n-1) for _ in range(m-1)]

clone_node.neighbors = [self.cloneGraph(n) for n in node.neighbors] 

# 加號 + 是列表連線運運算元，星號 * 是重複操作
print tinylist * 2       # 輸出列表兩次
print list + tinylist    # 列印組合的列表

list.append('Google')   # 使用 append() 新增元素
del list[2]			# 可以使用 del 語句來刪除列表的元素
list.pop(3)			# 指定pop引數，將會刪除該位置的元素；無引數時預設刪除最後一個元素

list.append(sublist) # 參照傳遞
list.append([]+sublist) # 值傳遞
list.append(list(path))

len([1, 2, 3])	3	#長度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	#組合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	#重複
3 in [1, 2, 3]	True	#元素是否存在於列表中
for x in [1, 2, 3]: print x,	1 2 3	#迭代

[::-1] # 陣列反轉

max(list) # 求list的最大值

sum(sp[i] for i in range(n)) #求和
sum(s in jewelsSet for s in stones)

nums.sort() # 排序
score.sort(reverse=True)
list有一個sort方法，list.sort()將list進行排序，返回None
sort(*,key = None,reverse = False)
key是一個函數，這個函數的作用是從list的每個元素中提取用於當作排序依據的屬性
預設是從小到大，即reserve為False的時候，如果reserve為True，排列順序就是從大到小
def f(item):
    return item[1]
list.sort(key = f)
list.sort(key = lambda item:item[0])

sorted(iterable,*,key=None,reverse=False) # 預設正序排列
sorted(dict.items(),key=lambda item:item[0])
res = sorted(hash,key = lambda word:(-hash[word],word)) # 第一個引數 -hash[word] 即單詞出現次數的相反數
# 當詞頻相同時，用第二個引數 word 進行排序，即字母正序排列

列表解析 List Comprehensions
表示式：[expression for iter_val in iterable if cond_expr]
[expression]：最後執行的結果
[for iter_val in iterable]：這個可以是一個多層迴圈
[if cond_expr]：兩個for間是不能有判斷語句的，判斷語句只能在最後；順序不定，預設是左到右。

print[(x,y)for x in [1,2]for y in [3,4]]

for (k1, v1), (k2, v2) in zip(dict_one, dict_two): # 遍歷兩個list或者dict

for item in product([1,2],[10,20]): # 對矩陣做笛卡爾積
    print(item)
for i, j in product(range(m), range(n)):


neighbors = [(1,0), (1,-1), (0,-1), (-1,-1), (-1,0), (-1,1), (0,1), (1,1)]
for neighbor in neighbors:
	r = (row + neighbor[0])
	c = (col + neighbor[1])
for u,v in neighbors:
	
s = [1, 2, 3, 4, 5]
# 從指定索引1開始
for index, value in enumerate(s, 1):

list(str(n)) # int轉化為字串，轉化為list

next(word for word,f in freq.items() if f==maxFreq) # next()取list第一個值

map(max, grid) # 求每行的最大值
map(max, zip(*grid)) # 求每列的最大值
strs = map(str,nums) # 轉換為list(str)
r1,m1 = map(int, num1[:-1].split('+')) # list(str)轉化為list(int)
list(map(list,numSet))

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 返回一個物件
>>> zipped
<zip object at 0x103abc288>
>>> list(zipped)  # list() 轉換為列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c))              # 元素個數與最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> a1, a2 = zip(*zip(a,b))          # 與 zip 相反，zip(*) 可理解為解壓，返回二維矩陣式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]

# 元組用 () 標識。內部元素用逗號隔開。但是元組不能二次賦值，相當於唯讀列表。
tinytuple = (123, 'john')

# 字典用"{ }"標識。字典由索引(key)和它對應的值value組成。
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"

# 值可以取任何資料型別，但鍵必須是不可變的，如字串，數位或 元組 。 用列表就不行
dict[tuple(count)]

# 以列表返回字典中的所有值
dict.values()
list(dict.values())

for key in dict:
    print (key)

tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}
print dict['one']          # 輸出鍵為'one' 的值
print dict[2]              # 輸出鍵為 2 的值

print tinydict             # 輸出完整的字典
print tinydict.keys()      # 輸出所有鍵
print tinydict.values()    # 輸出所有值
maxFreq = max(freq.values()) # 求value的最大值

tinydict['Age'] = 8 # 更新
tinydict['School'] = "RUNOOB" # 新增

del tinydict['Name']  # 刪除鍵是'Name'的條目
tinydict.clear()      # 清空字典所有條目
del tinydict          # 刪除字典

defaultdict(list)   defaultdict(int) # defaultdict類的初始化函數接受一個型別作為引數，當所存取的鍵不存在的時候，可以範例化一個值作為預設值：

count.get(c, 0) # 預設值為0

items():返回所有（key，value）元組的陣列,類似於‘列表’
[s for s, c in cnt.items() if c == maxCnt] # 遍歷dict

dict排序
sorted(dict.items(),key=lambda item:item[0])

items = [(-val, key) for key, val in count.items()] # 變更為tuple
for val, key in sorted(items): # 遍歷排序後的tuple

parame = {value01,value02,...}
或者
set(value)

s.add( x )

s.update( x ) # 引數可以是列表，元組，字典等

s.remove( x )

s.discard( x )

len(s)

s.clear()

x in s

for key in set:
    print (key)

if num == 3:            # 判斷num的值
    print 'boss'        elif num == 2:
    print 'user'elif num == 1:
    print 'worker'elif num < 0:           # 值小於零時輸出
    print 'error'else:
    print 'roadman'     # 條件均不成立時輸出

i = 1
while i < 10:   
    i += 1
    if i%2 > 0:     # 非雙數時跳過輸出
        continue
    print i         # 輸出雙數2、4、6、8、10
    
i = 1
while 1:            # 迴圈條件為1必定成立
    print i         # 輸出1~10
    i += 1
    if i > 10:     # 當i大於10時跳出迴圈
        break

flag = 1
while (flag): print 'Given flag is really true!'

fruits = ['banana', 'apple',  'mango']
for fruit in fruits:        # 第二個範例
   print ('當前水果: %s'% fruit)

fruits = ['banana', 'apple',  'mango']
for index in range(len(fruits)):
   print ('當前水果 : %s' % fruits[index])

for i in reversed(range(length - 1)): # 逆序

for letter in 'Python':     # 第一個範例
   if letter == 'h':
      break
   print '當前字母 :', letter

for i, ch in enumerate(s):
	if frequency[ch] == 1:
		return i

diff = [(a,b) for a,b in zip(s,goal) if a!=b]

+	字串連線	
>>>a + b
'HelloPython'

*	重複輸出字串	
>>>a * 2
'HelloHello'

[]	通過索引獲取字串中字元	
>>>a[1]
'e'

[ : ]	擷取字串中的一部分	
>>>a[1:4]
'ell'

in	成員運運算元 - 如果字串中包含給定的字元返回 True	
>>>"H" in a
True
not in	成員運運算元 - 如果字串中不包含給定的字元返回 True	
>>>"M" not in a
True

r/R	原始字串 - 原始字串：所有的字串都是直接按照字面的意思來使用，沒有跳脫特殊或不能列印的字元。 原始字串除在字串的第一個引號前加上字母"r"（可以大小寫）以外，與普通字串有著幾乎完全相同的語法。	
>>>print r'\n'
\n
>>> print R'\n'
\n

strs = 'abcd'
for ch in strs:
    print(ch)

strs = 'abcd'
for index in range(len(strs)):
    print(strs[index], end=' ')

res += 'a'*3 # 'aaa'

s.split(" ") # 將字串分割成單詞列表

" ".join(list) # 將單詞列表轉換為字串，以空格分隔

f'{bulls}A{cows}B' # {}計算格式化

a = list(str(n)) # int轉成list
a[i-1] = str(int(a[i-1]) - 1) # 操作字元
int("".join(a)) # list轉化為int

isdigit # 函數判斷是否數位
isalpha # 判斷是否字母

print "My name is %s and weight is %d kg!" % ('Zara', 21) 
%s	 格式化字串
%d	 格式化整數
%f	 格式化浮點數位，可指定小數點後的精度

允許一個字串跨多行，字串中可以包含換行符、製表符以及其他特殊字元
 >>> hi = '''hi 
there'''
>>> hi   # repr()
'hi\nthere'
>>> print hi  # str()
hi 
there

string.count(str, beg=0, end=len(string))
# 返回 str 在 string 裡面出現的次數，如果 beg 或者 end 指定則返回指定範圍內 str 出現的次數

string.endswith(obj, beg=0, end=len(string))
# 檢查字串是否以 obj 結束，如果beg 或者 end 指定則檢查指定的範圍內是否以 obj 結束，如果是，返回 True,否則返回 False.

string.find(str, beg=0, end=len(string))
# 檢測 str 是否包含在 string 中，如果 beg 和 end 指定範圍，則檢查是否包含在指定範圍內，如果是返回開始的索引值，否則返回-1

string.format()
# 格式化字串

string.index(str, beg=0, end=len(string))
# 跟find()方法一樣，只不過如果str不在 string中會報一個異常.

string.join(seq)
# 以 string 作為分隔符，將 seq 中所有的元素(的字串表示)合併為一個新的字串

string.replace(str1, str2,  num=string.count(str1))
# 把 string 中的 str1 替換成 str2,如果 num 指定，則替換不超過 num 次.

string.split(str="", num=string.count(str))
# 以 str 為分隔符切片 string，如果 num 有指定值，則僅分隔 num+1 個子字串

#可寫函數說明
def printinfo( name, age = 35 ):
   "列印任何傳入的字串"
   print "Name: ", name
   print "Age ", age
   return
#呼叫printinfo函數
printinfo( age=50, name="miki" )
printinfo( name="miki" )


# 可寫函數說明
def printinfo( arg1, *vartuple ):
   "列印任何傳入的引數"
   print "輸出: "
   print arg1
   for var in vartuple:
      print var
   return
# 呼叫printinfo 函數
printinfo( 10 )
printinfo( 70, 60, 50 )

import copy
l1 = [[1, 2], 3]
l2 = copy.copy(l1)
l3 = copy.deepcopy(l1)
l2.append(4)
l2[0].append(5)
l3[0].append(6)
l1 = [[1, 2, 5], 3]
l2 = [[1, 2, 5], 3, 4]
l3 = [[1, 2, 6], 3]

# 可寫函數說明
sum = lambda arg1, arg2: arg1 + arg2
# 呼叫sum函數
print "相加後的值為 : ", sum( 10, 20 )
print "相加後的值為 : ", sum( 20, 20 )

import support

from fib import fibonacci

from math import *

# 匯入 Phone 包from package_runoob.runoob1 import runoob1from package_runoob.runoob2 import runoob2
 
runoob1()runoob2()

str = input("請輸入：")
print "你輸入的內容是: ", str

fo = open("foo.txt", "w")
print "檔名: ", fo.name
print "是否已關閉 : ", fo.closed
print "存取模式 : ", fo.mode
print "末尾是否強制加空格 : ", fo.softspace

# 開啟一個檔案
fo = open("foo.txt", "w")
str = fo.read(10)
fo.write( "www.runoob.com!\nVery good site!\n")
# 關閉開啟的檔案
fo.close()

import os
os.rename( "test1.txt", "test2.txt" )
os.remove("test2.txt")

os.mkdir("test")
# 將當前目錄改為"/home/newdir"
os.chdir("/home/newdir")
# 給出當前的目錄
print os.getcwd()
# 刪除」/tmp/test」目錄
os.rmdir( "/tmp/test"  )

try:
    正常的操作
   ......................
except:
    發生異常，執行這塊程式碼
   ......................
else:
    如果沒有異常執行這塊程式碼

try:
    fh = open("testfile", "w")
    fh.write("這是一個測試檔案，用於測試異常!!")
except IOError:
    print "Error: 沒有找到檔案或讀取檔案失敗"
else:
    print "內容寫入檔案成功"
    fh.close()

try-finally 語句無論是否發生異常都將執行最後的程式碼。
try:
<語句>
finally:
<語句>    #退出try時總會執行
raise

try:
    fh = open("testfile", "w")
    try:
        fh.write("這是一個測試檔案，用於測試異常!!")
    finally:
        print "關閉檔案"
        fh.close()
except IOError:
    print "Error: 沒有找到檔案或讀取檔案失敗"

class Employee:
   '所有員工的基礎類別'
   empCount = 0
 
   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount
 
   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary
 
"建立 Employee 類的第一個物件"
emp1 = Employee("Zara", 2000)
"建立 Employee 類的第二個物件"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

class A:        # 定義類 A
.....

class B:         # 定義類 B
.....

class C(A, B):   # 繼承類 A 和 B
.....