筆記1 python入門學習筆記

目錄

• [TOC]
• 官方手冊
• 菜鳥站手冊位址:
• python的運作方法
• 注釋
• 小技巧:
  • input()接收使用者輸入的内容(預設為字元串)
  • print()
• 運算符
  • is 是判斷兩個辨別符是不是引用自一個對象
  • all和any
• 強制類型轉換
  • type()
  • float()
  • str()
  • int()
• 标準資料類型
• 判斷資料類型
• 清單 集合 元組 字典 的特性介紹
• 各種資料結構的各種操作
• 變量
• 字元串
  • 字元串的拼接
  • 字元串的重複輸出
  • 字元串的換行
  • 字元串的不換行
  • 字元串for循環
  • format() 格式化方法
  • f格式化
  • %格式化
  • 格式化總結
  • 轉義字元
• 清單 (相當于PHP裡的索引數組)
  • 清單的添加
  • 清單的删除
  • 清單的更新 指定清單裡元素的索引下标重新指派
  • 清單截取(切片)與拼接
  • 嵌套清單
  • 清單的指派
• 元組
• 序列
• https://bop.mol.uno/12.data_structures.html
• 字典
  • 為什麼需要字典：
  • 建立字典：
  • 基本操作：
  • 字典常用方法：
  • 周遊字典：
• 直接指派和 copy 的差別
• 淺拷貝和深拷貝的差別
• 函數
• 循環
  • for循環
  • while循環
  • range()函數循環清單
• 判斷if..elif..else
• break與continue的差別
• 資料的推導式
• 拆包

https://docs.python.org/3.7/tutorial/index.html

https://www.runoob.com/python3/python3-basic-operators.html

1. Sublime編輯器執行python代碼,用Ctrl+b
2. cmd黑視窗裡 D:\phpStudy\PHPTutorial\WWW\python>python test.py

確定對子產品, 函數, 方法和行内注釋使用正确的風格

Python中的注釋有單行注釋和多行注釋：

Python中單行注釋以 # 開頭，例如：

三個單引号,或者三個雙引号

'''這是一個區塊連的函數,
		money:交易的金額
		last_value 擷取到數組的最後一個單元(預設值為[1])
		Docstring'''
           

參考手冊:

https://www.runoob.com/python3/python3-comment.html

amount = float(input('請輸入金額: '))

列印輸出

由于我們正在讨論格式問題，就要注意 print 總是會以一個不可見的“新一行”字元（\n）結尾，是以重複調用 print将會在互相獨立的一行中分别列印。為防止列印過程中出現這一換行符，你可以通過 end 指定其應以空白結尾：

print('a', end='')
print('b', end='')
           

輸出結果如下：

ab

或者你通過 end 指定以空格結尾：

print('a', end=' ')
print('b', end=' ')
print('c')
           

a b c

字元串拼接變量的輸出

str2=2 + 3 * 4
a1 ='str 的值是' + str(str2)
a1 ='str 的值是' + str2 #報錯,字元串不和字數拼接
print (a1) #str 的值是14
print ('str 的值是' ,str2) #str 的值是 14
           

a = [20,30]
b = [20,30]
c = a 
if ( a is b ):
   print ("1 - a 和 b 有相同的辨別")
else:
   print ("1 - a 和 b 沒有相同的辨別")
 
if ( a is c ):
   print ("5 - a 和 c 有相同的辨別")
else:
   print ("5 - a 和 c 沒有相同的辨別")

if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的辨別")
else:
   print ("2 - a 和 b 沒有相同的辨別")
 
# 修改變量 b 的值
b = 30
if ( a is b ):
   print ("3 - a 和 b 有相同的辨別")
else:
   print ("3 - a 和 b 沒有相同的辨別")
 
if ( a is not b ):
   print ("4 - a 和 b 沒有相同的辨別")
else:
   print ("4 - a 和 b 有相同的辨別")
           

輸出:

1 - a 和 b 沒有相同的辨別
5 - a 和 c 有相同的辨別
2 - a 和 b 沒有相同的辨別
3 - a 和 b 沒有相同的辨別
4 - a 和 b 沒有相同的辨別
           

1. all相當于and并且
2. any相當于or或者

test_list = [1,2,3,4,-5]
test = [el > 0 for el in test_list] #[True, True, True, True, False]
print(all(test)) #False   
print(any(test)) #True   
           

列印數值類型

将字元串的數字轉為浮點型

将數字轉為字元串

将浮點型轉為整型

a = 12.5
a = int(12.5)
print(a) #輸出:12 向下取整
           

Python3 中有六個标準的資料類型：

Number（數字）

String（字元串）

List（清單）

Tuple（元組）

Set（集合）

Dictionary（字典）

Python3 的六個标準資料類型中：

不可變資料（3 個）：Number（數字）、String（字元串）、Tuple（元組）。 # 數字無
可變資料（3 個）：List（清單）、Dictionary（字典）、Set（集合）。     # 列字集
           

類型可以看成一個對象.

help()

後連按加回車 可以檢視類型下面的函數

如:

• help(str)
• help(list)

a = {1,2}
# if isinstance(a,str):
# if isinstance(a,int):
# if isinstance(a,list):
if isinstance(a,):
	print(True)
else:
	print(False)
           

# animal = ['pig','dog','cat','dog','pig'] #清單
# animal = {'pig','dog','cat','dog','pig'} #集合
# animal = ('pig','dog','cat','dog','pig') #元組
# animal = {'name':'lisi','age':28,'weight':120} #字典
           

類型	特性	符号
清單	可編輯 有序 允許重複	[]
集合	可編輯 無序 不可重複	{}
	不可編輯 有序 可重複	()
	無序 可編輯 值:可重複 鍵:不可重複 鍵值對形式

	清單推導		索引
	可以
			不可以

1. 變量可以了解為一個空盒子,向變量指派可以了解為向空盒子子裡存東西,向變量重新指派可以了解為把盒子裡原有的東西拿出來,放入新的東西
2. 聲明變量前不需加任何聲明.php前需要加$,JavaScript前需要加var,python不需要
3. 變量分為

   局部變量

   和

   全局變量

   ,局部變量可以通過global轉為全局變量

   

   

#變量的指派(也叫拆包)
list = ('wangwu',28)
name,age=list
print(name,age) #wangwu 28


#定義global全局變量
name = 'lisi'
def get_name():
    global name
    name = input('please input your are name:')
    
get_name() #運作函數局部變量就會通過global轉為全局變量

print(name) #輸出的是input裡您輸入的值
           

a= 'hello'
b='word'
c = a + b
print ("值為：", c) # 'helloword'
           

str='la' * 3
print (str) #lalala
           

方法一.用三個單引号或者三個雙引号

str= '''asdfasdfasdf
asdfasdfasdfdfasdf
asdfasdfasdfdfasdf
'''
print (str)
           

輸出

asdfasdfasdf
asdfasdfasdfdfasdf
asdfasdfasdfdfasdf
           

方法二.用

\n

符号換行

'This is the first line\nThis is the second line'
           

This is the first line
This is the second line
           

str= "This is the first sentence. \
This is the second sentence."
print (str)
           

This is the first sentence. This is the second sentence.
           

st = 'abcdefg'
for s in st :
    print(s)
           

a
b
c
d
e
f
g
           

name = 'lisi'
age = '28'

# new_str = 'I am '+ name +' and I am '+ age +' years old.'
# new_str = 'I am {} and I am {} years old.'.format(name, age)
# new_str = 'I am {0} and I am {1} years old. I like my name {0}'.format(name, age) #用索引可以重複調用
# new_str = 'I am {name} and I am {age} years old.' #變量不會解析
# new_str = 'I am {name} and I am {age} years old.'.format(name = name, age = age)
# print(new_str)

funds = 123.456
# new_str = 'Funds: {0:f}'.format(funds)
# <:居右  >:居左  ^:居中 0是點位符,冒号後面的是要輸出的符号, 10是共計輸出多少位, 
# f是轉為浮點數(預設保留小數點後四位),f前可以指定小數點後保留多少位,
new_str2 = 'Funds:|{0:-^10.2f}|'.format(funds)

print(new_str2) #Funds:|--123.46--|

print(f"{'lisi':-^20}") #--------lisi--------

           

更多例子:

https://bop.mol.uno/07.basics.html

name ='tongpan'
# age = 28
# person = {'name':'tongpan', 'age':28}
# new_str = f"I am {person['name']} and I am {person['age']+2} years old." 
# <:居右  >:居左  ^:居中 0是點位符,冒号後面的是要輸出的符号, 10是共計輸出多少位, 
# f是轉為浮點數(預設保留小數點後四位),f前可以指定小數點後保留多少位,
# new_str = f"|{name:-^20}|" #|------tongpan-------|
# new_str = f"|{name:->20}|" #|-------------tongpan|
new_str = f"|{name:-<20}|" #|tongpan-------------|
# pi = 3.1415926
# new_str = f"{pi:.3f}" # 3.142 保留三位小數,四舍五入
print(new_str)
           

1. 列印單個變量

# 整形：%d
 # 字元串類型：%s
 # 浮點類型： %f (幾位小數就寫幾f 如:12.45 %2f)

 # 字元串變量類型的格式化
 name = 'zhiliao'
 print('my name is %s'%name)

 # 整形變量的格式化
 age = 2147483648
 print('my age is %d'%age)

 # 浮點類型變量的格式化
 price = 18.9
 print("apple's price is %f"%price)
 print("apple's price is %.2f"%price)
           

1. 列印多個變量

name = 'zhiliao'
 age = 18
 gender = 'boy'
 # 元組
 print('my name is %s,my age is %d,gender is %s'% (name,age,gender))
           

1. 其他列印方式：

# 如果想字元串的末尾列印一個變量，那麼可以采用以下方式
 age = 18
 print('my age is',age)

 # 如果是其他資料類型，使用%s的方式進行格式化
 # 那麼其實，Python是首先将這個資料轉換為字元串
 # 再進行格式化。
 age = 18
 print('my age is %s'%age)
           

name = 'lisi'
age = 20
gender =  '男'
# str1 = 'my name is %s,age is %d,gender is %s'% (name,age,gender) #my name is lisi,age is 20,gender is 男
# str1 = 'my name is {},age is {},gender is {}'.format(name,age,gender) #my name is lisi,age is 20,gender is 男
str1 = f'my name is {name},age is {age},gender is {gender}' #my name is lisi,age is 20,gender is 男
print(str1)  

info = {}
info['name']=name
info['age']=age
info['gender']=gender
# str2 = 'my name is %s,age is %d,gender is %s'% (info['name'],info['age'],info['gender']) #my name is lisi,age is 20,gender is 男
# str2 = 'my name is {},age is {},gender is {}'.format(info['name'],info['age'],info['gender']) #my name is lisi,age is 20,gender is 男
str2 = f"my name is {info['name']},age is {info['name']},gender is {info['gender']}" #my name is lisi,age is 20,gender is 男
print(str2)

print(info['name']) #lisi
print(info['age'])  #20
# print(info['color'])  #20 報異常
           

new_str = '\I\m tongp\a\n'
'
"
\
\n
\a
\t
\b 
\f  
\N 
\v 
\ooo 
\xhh 
\Uxxxxxx
\uxxxx
print(new_str)
           

手冊:

https://www.runoob.com/python3/python3-string.html

參考菜鳥手冊

https://www.runoob.com/python3/python3-list.html

• 相當裡php裡的數組
• 序列中的每個元素都配置設定一個數字 - 它的位置(索引)，第一個索引是0，第二個索引是1，依此類推。

list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5, 6, 7 ];
 
print ("list1[0]: ", list1[0]) #list1[0]:  Google 
print ("list2[1:5]: ", list2[1:5]) #list2[1:5]:  [2, 3, 4, 5]
           

清單相當于php中的一維數組,裡面元素是有序的,可以重複的.

1. 向清單的最後面追加單中繼資料

清單的追加(向數組的右邊追加)

append()

方法

list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新後的清單 : ", list1) #['Google', 'Runoob', 'Taobao', 'Baidu']
           

1. 向數組後面拼接元素

list1 = ['Google', 'Runoob', 'Taobao']
n = ['a','b','c']
list1 += n
print(list1) #['Google', 'Runoob', 'Taobao', 'a', 'b', 'c']
           

1. insert()

   函數用于向清單指點任意清單的插入值。

insert()

list.insert(index, obj)

list1 = ['Google', 'Runoob', 'Taobao']
list1.insert(1, 'Baidu')
print ('清單插入元素後為 : ', list1) #['Google', 'baidu', 'Runoob', 'Taobao']
           

1. extend()

   函數用于在清單末尾一次性追加另一個序列中的多個值（用新清單擴充原來的清單）。

extend()方法文法：

list.extend(seq)

list1 = ['Google', 'Runoob', 'Taobao']
list2=list(range(5)) # 建立 0-4 的清單
list1.extend(list2)  # 擴充清單
print ("擴充後的清單：", list1) # ['Google', 'Runoob', 'Taobao', 0, 1, 2, 3, 4]
           

5.extend 與 append 的差別

• extend 與 append 方法的相似之處在于都是将新接收到參數放置到已有清單的後面。
• 而 extend 方法隻能接收 list，且把這個 list 中的每個元素添加到原 list 中。
• 而 append 方法可以接收任意資料類型的參數，并且簡單地追加到 list 尾部。

list1 = ['Google', 'Runoob', 'Taobao']
list1.extend(['a','b'])  # 擴充清單
print (list1) # ['Google', 'Runoob', 'Taobao', 'a', 'b']

list2 = ['Google', 'Runoob', 'Taobao']
list2.append(['a','b'])  # 擴充清單
print (list2) # ['Google', 'Runoob', 'Taobao', ['a', 'b']]
           

https://www.runoob.com/python3/python3-att-list-extend.html

方法一:可以使用 del 語句來删除清單的指定元素，如下執行個體：

list = ['Google', 'Runoob', 1997, 2000]
print ("原始清單 : ", list) #原始清單 :  ['Google', 'Runoob', 1997, 2000]
del list[2]
print ("删除第三個元素 : ", list) #删除第三個元素 :  ['Google', 'Runoob', 2000]
           

方法二:

remove()

描述

remove() 函數用于移除清單中某個值的第一個比對項。

文法

remove()方法文法：

list.remove(obj)

list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.remove('Taobao')
print ("清單現在為 : ", list1) #清單現在為 :  ['Google', 'Runoob', 'Baidu']
list1.remove('Baidu')
print ("清單現在為 : ", list1) #清單現在為 :  ['Google', 'Runoob']
           

方法三:pop(清單索引)

pop(清單索引) 函數用于移除清單中某索引的值

不列索引,預設删除最後一個元素

list = ['Google', 'Runoob', 1997, 2000]
list.pop(2) 
print(list) #['Google', 'Runoob', 2000]
           

你可以對清單的資料項進行修改或更新，如下所示：

指定清單裡元素的索引下标重新指派

list = ['Google', 'Runoob', 1997, 2000]
print ("第三個元素為 : ", list[2]) #第三個元素為 :  1997
list[2] = 2001
print ("更新後的第三個元素為 : ", list[2]) #更新後的第三個元素為 :  2001
           

Python的清單截取與字元串操作類型.

如下所示：

L=['Google', 'Runoob', 'Taobao']

Python 表達式	結果
L[2]	'Taobao'	讀取第三個元素
L[-2]	Runoob'	從右側開始讀取倒數第二個元素: count from the right
L[1:]	['Runoob', 'Taobao']	輸出從第二個元素開始後的所有元素
L[:]	['Google', 'Runoob', 'Taobao']	輸出所有元素

拼接

list1 = ['Google', 'Runoob', 'Taobao']
n = ['a','b','c']
list1 += n
print(list1) #['Google', 'Runoob', 'Taobao', 'a', 'b', 'c']
           

把兩個一維清單嵌套成一個兩維清單

a = ['Google', 'Runoob', 'Taobao']
b = ['a','b','c']
c = [a,b]
print(c) #[['Google', 'Runoob', 'Taobao'], ['a', 'b', 'c']]
           

copy()和直接=指派的差別：

1. 使用=直接指派，是引用指派，更改一個，另一個同樣會變
2. copy() 則顧名思義，複制一個副本，原值和新複制的變量互不影響

例子:

https://www.runoob.com/python3/python3-att-list-copy.html

# 清單的傳值指派 (原清單a資料值改變,不影響指派的新清單b)
a=[0,1,2,3,4,5]
# 清單的傳值指派的幾種方法
# b=a.copy() #copy()函數傳值指派
# b=a[:] #切片傳值指派
b=a[0:] #切片傳值指派
a[0] = 6
print(a)  #[6, 1, 2, 3, 4, 5]
print(b)  #[0, 1, 2, 3, 4, 5]

# 清單的引用指派 (原清單a和新清單c指的是同一個清單在記憶體裡的位址,可以了解為同一個清單起的不同的别名)
# 原清單c資料值改變,新清單b的值也改變
c=[0,1,2,3,4,5]
d=c
c[0] = 6
print(c)  #[6, 1, 2, 3, 4, 5]
print(d)  #[6, 1, 2, 3, 4, 5]
           

Python 的元組與清單類似，不同之處在于元組的元素不能修改。

元組使用小括号，清單使用方括号。

相同之處,它們的元素都是有序的,可以重複的

元組建立很簡單，隻需要在括号中添加元素，并使用逗号隔開即可。

https://www.runoob.com/python3/python3-tuple.html

清單、元組和字元串可以看作序列（Sequence）的某種表現形式，可是究竟什麼是序列，它又有什麼特别之處？

序列的主要功能是資格測試（Membership Test）（也就是 in 與 not in 表達式）和索引操作（Indexing Operations），它們能夠允許我們直接擷取序列中的特定項目。

上面所提到的序列的三種形态——清單、元組與字元串，同樣擁有一種切片（Slicing）運算符，它能夠允許我們序列中的某段切片——也就是序列之中的一部分。

案例（儲存為 ds_seq.py）：

shoplist = ['apple', 'mango', 'carrot', 'banana']
name = 'swaroop'

# Indexing or 'Subscription' operation #
# 索引或“下标（Subscription）”操作符 #
print('Item 0 is', shoplist[0])
print('Item 1 is', shoplist[1])
print('Item 2 is', shoplist[2])
print('Item 3 is', shoplist[3])
print('Item -1 is', shoplist[-1])
print('Item -2 is', shoplist[-2])
print('Character 0 is', name[0])

# Slicing on a list #
print('Item 1 to 3 is', shoplist[1:3])
print('Item 2 to end is', shoplist[2:])
print('Item 1 to -1 is', shoplist[1:-1])
print('Item start to end is', shoplist[:])

# 從某一字元串中切片 #
print('characters 1 to 3 is', name[1:3])
print('characters 2 to end is', name[2:])
print('characters 1 to -1 is', name[1:-1])
print('characters start to end is', name[:])
           

Item 0 is apple
Item 1 is mango
Item 2 is carrot
Item 3 is banana
Item -1 is banana
Item -2 is carrot
Character 0 is s
Item 1 to 3 is ['mango', 'carrot']
Item 2 to end is ['carrot', 'banana']
Item 1 to -1 is ['mango', 'carrot']
Item start to end is ['apple', 'mango', 'carrot', 'banana']
characters 1 to 3 is wa
characters 2 to end is aroop
characters 1 to -1 is waroo
characters start to end is swaroop
           

有時候我們需要存儲一組相關的資料的時候，

比如要存儲一個人的資訊，那麼有username，age，birthday等，

如果這些資訊都存儲在清單中，或者數組中，

比如['username','age','birthday']那麼用起來可能不是很友善。

比較友善的操作是，我直接通過username這個key就可以拿到這個值，

我通過username就可以給這個key設定值，

那麼就可以通過字典的方式實作我們的需求。

字典 可以了解為鍵值對形式的

json格式字元串形式

或者

php中的關聯數組

1. 字典的每個鍵值(key=>value)對用冒号(:)分割，每個對之間用逗号(,)分割，整個字典包括在花括号({})中 ,

   格式如下所示：

   d = {key1 : value1, key2 : value2 }

2. 字典是另一種可變容器模型，且可存儲任意類型對象。
3. 鍵必須是唯一的，但值則重複。
4. 值可以取任何資料類型，但鍵必須是不可變的，如字元串，數字或元組。
5. 元素是無序的

一個簡單的字典執行個體：

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

#方法一:
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };

#方法二:
info = {}
info['name']=name
info['age']=age
info['gender']=gender

#輸出
print(info) #{'name': 'lisi', 'age': 20, 'gender': '男'}
print(info['name']) #lisi
print(info['age'])  #20
# print(info['color'])  #20 報異常

# 也可以指定一個，在沒有擷取到這個值時候的預設值
print(info.get('color','red')) #red

方法三:使用dict函數：
person = dict(username='zhiliao',age=18) #{'username': 'zhiliao', 'age': 18}
print(person)
           

• len(d)：傳回字典的鍵值對的長度。
• d[k]：擷取k這個key對應的值。
• d[k] = v：設定鍵為k的值為v，如果字典中不存在鍵為k的這一項，那麼自動的添加進去。
• del d[k]：删除d這個字典中鍵為k的這一項資料。
• k in d：檢查d這個字典中是否包含鍵為k的這一項。
• 字典中的鍵可以是任意的不可變類型，比如：浮點類型、整形、長整形、字元串或者元組。

1. clear：清除字典中所有的項。

   a = {'username':'zhiliao','age':18}
   print(a) #{'username': 'zhiliao', 'age': 18}
   a.clear()
   print(a) #{}
              

2. get：通路字典中那個鍵對應的那個值。這個方法不會抛出異常。

   a = {'username':'zhiliao','age':18}
   username = a.get('username')
   print(username) #print(city) 
   
   city = a.get('city') # 擷取到的是一個None。
   print(city) #None
   
   # 也可以指定一個，在沒有擷取到這個值時候的預設值
   city = a.get('city','changsha') 
   print(city) #changsha
   
   # city = a['city'] 
   # print(city) # 抛出異常
              

3. pop：用來獲得對應于給定鍵的值，然後将這個鍵和值的項從字典中删除。會傳回這個值。

   d = {'x':1,'y':2}
   b=d.pop('x')
   print(b) # 1
   print(d) # {'y': 2}
              

4. popitem：随機的移除字典中的一項。因為字典是無序的，是以是随機的。

   d= {'name': '菜鳥教程', 'alexa': 10000, 'url': 'www.runoob.com'}
   a=d.popitem() # 随機彈出一個值
   print(d) # {'name': '菜鳥教程', 'alexa': 10000}
   print(a) #('url', 'www.runoob.com')
              

5. update：用一個字典更新另外一個字典，如果碰到相同的鍵，則會覆寫。

   a = {'url':'http://www.baidu.com/','title':"baidu"}
   b = {"url":"http://www.google.com/",'new_value':"new_value"}
   a.update(b)
   print(a) #{'url': 'http://www.google.com/', 'title': 'baidu', 'new_value': 'new_value'}
              

6. setdefault：如果字典中包含有給定鍵，則傳回該鍵對應的值，否則傳回為該鍵設定的值。

7. key in dict

   if k in dict：判斷某個鍵是否在字典中存在。

   dict = {'Name': 'Runoob', 'Age': 7}
   
   # 檢測鍵 Age 是否存在
   if  'Age' in dict:
       print("鍵 Age 存在")
   else :
       print("鍵 Age 不存在")
    
   # 檢測鍵 Sex 是否存在
   if  'Sex' in dict:
       print("鍵 Sex 存在")
   else :
       print("鍵 Sex 不存在")
    
   # not in
    
   # 檢測鍵 Age 是否存在
   if  'Age' not in dict:
       print("鍵 Age 不存在")
   else :
       print("鍵 Age 存在")
       
   # 以上執行個體輸出結果為：
   
   # 鍵 Age 存在
   # 鍵 Sex 不存在
   # 鍵 Age 存在    
   
              

1. 周遊字典中所有的key：使用keys方法，這個方法将所有的鍵以清單的方式傳回。

   a = {"url":"www.baidu.com",'title':"baidu"}
   for x in a.keys():
       print x
              

2. 周遊字典中所有的key：使用iterkeys方法，這個方法将傳回一個疊代器，用來周遊所有的鍵的。

   a = {"url":"www.baidu.com",'title':"baidu"}
   for x in a.iterkeys():
       print x
              

3. 周遊字典中所有的value：使用values方法，這個方法将所有的值以清單的方式傳回。

   a = {"url":"www.baidu.com",'title':"baidu"}
   for x in a.values():
       print x
              

4. 周遊字典中所有的value：使用itervalues方法，這個方法将傳回一個疊代器，用來周遊所有的值。

   a = {"url":"www.baidu.com",'title':"baidu"}
   for x in a.itervalues():
       print x
              

5. 周遊字典中所有的鍵值對：使用items方法，這個方法将所有的鍵和值以清單的方式傳回。

   a = {"url":"www.baidu.com",'title':"baidu"}
   for key,value in a.items():
       print key
       print value
              

6. 周遊字典中所有的鍵值對：使用iteritems方法，這個方法将傳回一個疊代器，用來周遊所有的鍵和值。

   a = {"url":"www.baidu.com",'title':"baidu"}
   for key,value in a.iteritems():
       print key
       print value
              

https://www.runoob.com/python3/python3-dictionary.html

可以通過以下執行個體說明：

dict1 = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict2 = dict1.copy()
print ("新複制的字典為 : ",dict2) #新複制的字典為 :  {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

dict1 =  {'user':'runoob','num':[1,2,3]}
dict2 = dict1          # 淺拷貝: 引用對象
dict3 = dict1.copy()   # 淺拷貝：深拷貝父對象（一級目錄），子對象（二級目錄）不拷貝，還是引用
 
# 修改 data 資料
dict1['user']='root'
dict1['num'].remove(1) 
 
# 輸出結果
print(dict1) #{'user': 'root', 'num': [2, 3]}
print(dict2) #{'user': 'root', 'num': [2, 3]}
print(dict3) #{'user': 'runoob', 'num': [2, 3]}
           

https://www.runoob.com/w3cnote/python-understanding-dict-copy-shallow-or-deep.html

def 自定義一函數

def test():
	print('My name is haima')
test() #My name is haima
           

詳情:

https://bop.mol.uno/10.functions.html

https://www.runoob.com/python3/python3-function.html

blockchian = [[[1], 12.0], [[[1], 12.0], 13.0], [[[[1], 12.0], 13.0], 14.0]]
for block in blockchian:
	'''這是一個區塊連的函數,
		money:交易的金額
		last_value 擷取到數組的最後一個單元(預設值為[1])
		Docstring'''
	print(block)
           

while True:
    print('請輸入數字:')
    print('1:繼續交易')
    print('2:列印目前區塊鍊')
    print('q:退出目前操作')
    userChoice_num = get_userChoice_num()
    if userChoice_num == '1':
        money = get_input_money()
        add_value(money,get_last_value())
    elif userChoice_num == '2':
        print_blockchian()
    elif userChoice_num == 'q':
        break #continue
    else:
        print('請輸入清單裡的數字!')
           

range()

函數循環清單

也可以使range以指定數字開始并指定不同的增量(甚至可以是負數，有時這也叫做'步長'):

for i in range(0, 10, 3) :
    print(i)
           

列印結果:

0
3
6
9
           

手冊參考

https://www.runoob.com/python3/python3-loop.html

```python
if userChoice_num == '1':
    money = get_input_money()
    add_value(money,get_last_value())
elif userChoice_num == '2':
    print_blockchian()
elif userChoice_num == 'q':
    break #continue
else:
    print('請輸入清單裡的數字!')
    
    
    
value = int(input('請輸入你的值,輸入整形:'))

if value == 1:
    print('今天是星期一')
elif value == 2:
    print('今天是星期二')
elif value == 3:
    print('今天是星期三')
elif value == 4:
    print('今天是星期四')
elif value == 5:
    print('今天是星期五')
elif value == 6:
    print('今天是星期六')
elif value == 7:
    print('今天是星期日')
else:
    print('請輸入1-7的整數')  
```
           

https://www.runoob.com/python3/python3-conditional-statements.html

break

與

continue

的差別

break

終止本次循環

continue

跳過目前操作,執行下一次循環

例子一:

list = [1,2,3,4,5]
newlist = [li*2 for li in list]
print(newlist) #[2, 4, 6, 8, 10]

#加if條件篩選出符合條件的元素再做操作
list = [1,2,3,4,5]
newlist = [li*2 for li in list if li % 2==0]
print(newlist) #[4, 8]

list = [1,2,3,4,5]
items = [1,3]
newlist = [el*2 for el in list if el in items]
print(newlist) #[2, 6]

numb = [1, 2, 3, 4, 5, 6, 7]
num = '-'.join([str(v*2) for v in numb]) #join是把清單數組裡的每一個值循環出來,用-号連接配接轉為字元串
print(num) #輸出:2-4-6-8-10-12-14
           

例子二:

字典的清單推導

方法一(隻能拿到鍵):
animal = {'name':'tongpan', 'age':28, 'weight':120}
print([el for el in animal]) #['name', 'age', 'weight']

方法二(鍵,值都能拿到):
animal = {'name':'tongpan', 'age':28, 'weight':120}
a = animal.items() #items把字典轉為這種形式dict_items([('name', 'tongpan'), ('age', 28), ('weight', 120)])
for k,v in a:
    print(k,v)
    print('---------------------')
    
# 列印結果
# name tongpan
# ---------------------
# age 28
# ---------------------
# weight 120
# ---------------------


list1 = [('name','lisi'),('age',18),('gender','man')]
# 循環清單裡的元組,拿到元組的k和v,再存為字典
zidian = {key:value for (key,value) in list1}
print(zidian) #{'name': 'lisi', 'age': 18, 'gender': 'man'}


list1 = [('name','lisi'),('age',18),('gender','man')]
print([key for (key,value) in list1]) #['name', 'age', 'gender']
print([value for (key,value) in list1]) #['lisi', 18, 'man']



           

例子三:

list0 = [('name','lisi','red'),('age',18,'prink'),('gender','man','purple')]
list1 = [('name','lisi'),('age',18),('gender','man')]
# 循環清單裡的元組,拿到元組的k和v,再存為别的類型的
list_a = [vv for (key,value,vv) in list0] 
list_c = {vv for (key,value,vv) in list0} 
list_b = {value:vv for (key,value,vv) in list0}
list_d = [vv for (key,value,vv) in list0 if vv=='red']
list2 = {key for (key,value) in list1} 
list3 = {value for (key,value) in list1}
list_e = ' '.join(str(vv) for (key,value,vv) in list0) #red prink purple

print(list_a) #['red', 'prink', 'purple']
print(list_c) #{'red', 'purple', 'prink'}
print(list_b) #{'lisi': 'red', 18: 'prink', 'man': 'purple'}
print(list_d) #['red']

print(list2) #{'gender', 'name', 'age'}
print(list3) #{'lisi', 18, 'man'}
print(list_e) #red prink purple
           

例子四:

abc= [('name','lisi','red'),('age',18,'prink'),('gender','man','purple')]
#key目前的索引(腳标),value是目前的值
for (key,value) in enumerate(abc):
    print(key,value)
           

0 ('name', 'lisi', 'red')
1 ('age', 18, 'prink')
2 ('gender', 'man', 'purple')
           

aa = {'name':'tongpan', 'age':28, 'weight':120}
# 能拿到目前元素的索引(腳标:index)
for (index,key) in enumerate(aa):
    print(index,key,aa[key])

for key in aa:
    print(key,aa[key])
           

0 name tongpan
1 age 28
2 weight 120
name tongpan
age 28
weight 120
           

test_list = [1,2,3,4,-5]
#拆包 就是批量指派 變量的數量要和list裡的元素個數對上
a,b,c,d,e=test_list 
print(a,b,c,d,e) #1 2 3 4 -5