目錄
3，運算規則(b,a=a+1,b)跟（b=a+1;a=b;）是不一樣的
（3）可更改(mutable)與不可更改(immutable)對象
（4）正式參數類型( 必需參數, 關鍵字參數, 默認參數, 不定長參數)
1，不同數值類型的 true 和 false
| 類型 | False | True |
| 布爾 | False(與0等價) | True(與1等價) |
| 數值 | 0, 0.0 | 非零的數值 |
| 字符串 | '', ""(空字符串) | 非空字符串 |
| 容器 | [], (), {}, set() | 至少有一個元素的容器對象 |
| None | None | 非None對象 |
2，end 關鍵字
關鍵字end可以用於將結果輸出到同一行，或者在輸出的末尾添加不同的字符
a, b = 0, 0;
while b < 3:
b=a+1;
a=b;
print(b,end=",");
print()
print(b, end=" ");
console:
1,
1 2,
2 3,
3
3，運算規則(b,a=a+1,b)跟（b=a+1;a=b;）是不一樣的
a,b=0,0;#先計算，再賦值
while b < 3:
b,a=a+1,b; print(b,end=","); print(a,end=" ");
print();
a,b=0,0;
while b < 3:
n = b;
b = a + 1;
a = n; print(b,end=","); print(a,end=" ");
print();
a, b = 0, 0;
while b < 3:
b=a+1;
a=b; print(b,end=","); print(a,end=" ");
console:
1,0 1,1 2,1 2,2 3,2
1,0 1,1 2,1 2,2 3,2
1,1 2,2 3,3
4，if 語句
if True:
print(1);
else:
print(2);
console:
1
#求機率
import random
a,i,q,w,e,r,t=True,0,0,0,0,100,100;
while a:
x = random.choice(range(100)); # 0-99的隨機數
y = random.choice(range(200)) # 0-199的隨機數
i=i+1;
if i==t:a=False;
if x == y:
q=q+1;
elif x > y:
w=w+1;
else :
e=e+1;
console:
x等於y的機率： 0.0 x大於y的機率： 0.21 x小於y的機率： 0.79
5,容器總結
1. 有序：list，tuple，str和unicode；
2. 無序：set
3. 無序並且具有 key-value 對：dict
4,都是可以通過 for--in--進行遍歷的 ，
6,Python3 循環語句
Python中的循環語句有 for 和 while。
while w:
print("這是一個While循環");
i=i+1;
if i>10:w=False;
else:
print("退出")
for x in "123":
print(x);
else:
print("退出")
range()函數
如果你需要遍歷數字序列，可以使用內置range()函數。它會生成數列
a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)):
print(i, a[i])
break和continue語句及循環中的else子句
break 語句可以跳出 for 和 while 的循環體。如果你從 for 或 while 循環中終止，任何對應的循環 else 塊將不執行
7,pass 語句
Python pass是空語句，是爲了保持程序結構的完整性。
pass 不做任何事情，一般用做佔位語句
if 2>1:
pass
class MyEmptyClass:
pass
while True:
pass
#pass 代表函數不執行其他操作 或者 類沒有其他成員變量或函數
#這裏如果不做任何處理，直接跳過，但是如果不寫pass，就會語法錯誤
但是可以跟執行語句
if 2>1:
pass
print(1)
class MyEmptyClass:
pass
print(2)
for letter in 'Runoob':
if letter == 'o':
pass
print ('執行 pass 塊')
print ('當前字母 :', letter)
print ("Good bye!")
console:
1
2
當前字母 : R
當前字母 : u
當前字母 : n
執行 pass 塊
當前字母 : o
執行 pass 塊
當前字母 : o
當前字母 : b
Good bye!
8,迭代器
迭代是Python最強大的功能之一，是訪問集合元素的一種方式。
迭代器是一個可以記住遍歷的位置的對象。
迭代器對象從集合的第一個元素開始訪問，直到所有的元素被訪問完結束。迭代器只能往前不會後退。
代器有兩個基本的方法：iter() 和 next()。
字符串，列表或元組對象都可用於創建迭代器
list=[1,2,3,4]
it = iter(list) # 創建迭代器對象
print (next(it),next(it),next(it),next(it)) # 輸出迭代器的下一個元素
for x in iter(list):
print (x, end=" ");
print ();
import sys # 引入 sys 模塊
it = iter(list)
while True:
try:
print(next(it));
except StopIteration:
sys.exit()
console:
1 2 3 4
1 2 3 4
1
2
3
4
StopIteration
StopIteration 異常用於標識迭代的完成，防止出現無限循環的情況，在 __next__() 方法中我們可以設置在完成指定循環次數後觸發 StopIteration 異常來結束迭代。
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
if self.a <= 2:
x = self.a
self.a += 1
return x
else:
raise StopIteration
不加StopIteration 會報錯，不加else 會一直循環輸出None
myclass = MyNumbers();
myiter = iter(myclass);
for x in myiter:
print(x)
9，生成器
在 Python 中，使用了 yield 的函數被稱爲生成器（generator）。
跟普通函數不同的是，生成器是一個返回迭代器的函數，只能用於迭代操作，更簡單點理解生成器就是一個迭代器。
在調用生成器運行的過程中，每次遇到 yield 時函數會暫停並保存當前所有的運行信息，返回 yield 的值, 並在下一次執行 next() 方法時從當前位置繼續運行。
調用一個生成器函數，返回的是一個迭代器對象。
以下實例使用 yield 實現斐波那契數列：
import sys
def fibonacci(n): # 生成器函數 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(5) # f 是一個迭代器，由生成器返回生成
while True:
try:
print(next(f), end=" ")
except StopIteration:
sys.exit()
console:
0 1 1 2 3 5
10,函數
（1）基本用法
函數代碼塊以 def 關鍵詞開頭，後接函數標識符名稱和圓括號 ()。
任何傳入參數和自變量必須放在圓括號中間，圓括號之間可以用於定義參數。
函數的第一行語句可以選擇性地使用文檔字符串—用於存放函數說明。
函數內容以冒號起始，並且縮進。
return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return相當於返回 None。
def hello() :
print("Hello World!")
print(hello());
def hello1():
return "Hello World1!";
print(hello1());
console:
Hello World!
None
Hello World1!
寫一個計算器
def calculator(num1,num2,sign):
ret,str=None,"";
try:
if (sign == "+"):
ret = num1 + num2;
elif (sign == "-"):
ret = num1 - num2;
elif (sign == "*"):
ret = num1 * num2;
elif (sign == "/"):
ret = num1 / num2;
str=num1+sign+num2;
except Exception as e:
str="出錯了"+e;
finally:
print(retStr+" = ",end=" ");
return ret;
print(calculator(1,0,"/"))
print(calculator(1,1,"/"))
console:
division by zero
= None
1 / 1 = 1.0
（2）參數 傳遞
在 python 中，類型屬於對象，變量是沒有類型的。a僅僅是一個對象的引用（一個指針），可以是指向 List 類型對象，也可以是指向 String 類型對象。
def test(a):
print(a,type(a))
print(test(1),test('1'),test(True),test(4.1),test({1,2,3}),test((1,2,3)),test({1:2}),test([1,3,4]));
console:
1 <class 'int'>
1 <class 'str'>
True <class 'bool'>
4.1 <class 'float'>
{1, 2, 3} <class 'set'>
(1, 2, 3) <class 'tuple'>
{1: 2} <class 'dict'>
[1, 3, 4] <class 'list'>
None None None None None None None None
（3）可更改(mutable)與不可更改(immutable)對象
在 python 中，strings, tuples, 和 numbers 是不可更改的對象，而 list,dict 等則是可以修改的對象。
不可變類型：變量賦值 a=5 後再賦值 a=10，這裏實際是新生成一個 int 值對象 10，再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當於新生成了a。
可變類型：變量賦值 la=[1,2,3,4] 後再賦值 la[2]=5 則是將 list la 的第三個元素值更改，本身la沒有動，只是其內部的一部分值被修改了。
python 函數的參數傳遞：
不可變類型：類似 c++ 的值傳遞，如 整數、字符串、元組。如fun（a），傳遞的只是a的值，沒有影響a對象本身。比如在 fun（a）內部修改 a 的值，只是修改另一個複製的對象，不會影響 a 本身。
可變類型：類似 c++ 的引用傳遞，如 列表，字典。如 fun（la），則是將 la 真正的傳過去，修改後fun外部的la也會受影響
python 中一切都是對象，嚴格意義我們不能說值傳遞還是引用傳遞，我們應該說傳不可變對象和傳可變對象。
python 傳不可變對象實例
def ChangeInt( a ):
a = 10
b = 2
ChangeInt(b)
print( b ) # 結果是 2
傳可變對象實例
def changeme(mylist):
"修改傳入的列表"
mylist.append([1, 2, 3, 4])
print("函數內取值: ", mylist)
return
# 調用changeme函數
mylist = [10, 20, 30]
changeme(mylist)
print("函數外取值: ", mylist)
console:
函數內取值: [10, 20, 30, [1, 2, 3, 4]]
函數外取值: [10, 20, 30, [1, 2, 3, 4]]
（4）正式參數類型( 必需參數, 關鍵字參數, 默認參數, 不定長參數)
必需參數
必需參數須以正確的順序傳入函數。調用時的數量必須和聲明時的一樣。
調用printme()函數，你必須傳入一個參數，不然會出現語法錯誤
# 可寫函數說明
def printme( ab):
print(ab);#"打印任何傳入的字符串"
return
# 調用printme函數
printme(1)
關鍵字參數
關鍵字參數和函數調用關係緊密，函數調用使用關鍵字參數來確定傳入的參數值。
使用關鍵字參數允許函數調用時參數的順序與聲明時不一致，因爲 Python 解釋器能夠用參數名匹配參數值。
以下實例在函數 printme() 調用時使用參數名：
def printme(str1,str2):
print(str1+" "+str2)
return
# 調用printme函數
printme(str2="OKOK",str1="今天天氣不錯")
console:
今天天氣不錯 OKOK
默認參數
調用函數時，如果沒有傳遞參數，則會使用默認參數。以下實例中如果沒有傳入 age 參數，則使用默認值：
def day(a=1,b=3):
print("a=",a," b=",b);
day(b=1)
day(1)
console:
a= 1 b= 1
a= 1 b= 3
不定長參數
你可能需要一個函數能處理比當初聲明時更多的參數。這些參數叫做不定長參數，和上述 2 種參數不同，聲明時不會命名。
加了星號 * 的參數會以元組(tuple)的形式導入，存放所有未命名的變量參數。
加了兩個星號 ** 的參數會以字典的形式導入。
def printinfo(arg1, *vartuple):
print("輸出: ",arg1,vartuple)
printinfo(70, 60, 50);printinfo(80)
def printinfo2(arg1, **vartuple):
print("輸出2: ",arg1,vartuple)
printinfo2(70, a=60, b=50);printinfo2(80)
console:
輸出: 70 (60, 50)
輸出: 80 ()
輸出2: 70 {'a': 60, 'b': 50}
輸出2: 80 {}
如果單獨出現星號 * 後的參數必須用關鍵字傳入。
def f(a,b,*,c):
return a+b+c
# print(f(1,2,3))#TypeError: f() takes 2 positional arguments but 3 were given
print(f(1,2,c=3))#6
（5）匿名函數
python 使用 lambda 來創建匿名函數。
所謂匿名，意即不再使用 def 語句這樣標準的形式定義一個函數。
lambda 只是一個表達式，函數體比 def 簡單很多。
lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
lambda 函數擁有自己的命名空間，且不能訪問自己參數列表之外或全局命名空間裏的參數。
雖然lambda函數看起來只能寫一行，卻不等同於C或C++的內聯函數，後者的目的是調用小函數時不佔用棧內存從而增加運行效率。
sum = lambda arg1, arg2: arg1 + arg2
minus = lambda arg1, arg2: arg1 - arg2
print ("相加後的值爲 : ", sum( 10, 20 ))
print ("相減後的值爲 : ", minus( 20, 30 ))
console:
相加後的值爲 : 30
相減後的值爲 : -10
（6）變量作用域
Python 中，程序的變量並不是在哪個位置都可以訪問的，訪問權限決定於這個變量是在哪裏賦值的。
變量的作用域決定了在哪一部分程序可以訪問哪個特定的變量名稱。Python的作用域一共有4種，分別是：
L （Local） 局部作用域
E （Enclosing） 閉包函數外的函數中
G （Global） 全局作用域
B （Built-in） 內建作用域
以 L –> E –> G –>B 的規則查找，即：在局部找不到，便會去局部外的局部找（例如閉包），再找不到就會去全局找，再者去內建中找。
x = int(2.9) # 內建作用域 B
g_count = 0 # 全局作用域 G
def outer():
o_count = 1 # 閉包函數外的函數中 E
def inner():
i_count = 2 # 局部作用域 L
Python 中只有模塊（module），類（class）以及函數（def、lambda）纔會引入新的作用域，
其它的代碼塊（如 if/elif/else/、try/except、for/while等）是不會引入新的作用域的，也就是說這些語句內定義的變量，外部也可以訪問
if True:
msg="123"
print(msg)#123
def a():
msg1="4565";
print(msg1)#NameError: name 'msg1' is not defined
全局變量和局部變量
定義在函數內部的變量擁有一個局部作用域，定義在函數外的擁有全局作用域。
局部變量只能在其被聲明的函數內部訪問，而全局變量可以在整個程序範圍內訪問。調用函數時，所有在函數內聲明的變量名稱都將被加入到作用域中。
total = 0 # 這是一個全局變量
def sum(arg1, arg2):
# 返回2個參數的和."
total = arg1 + arg2 # total在這裏是局部變量.
print("函數內是局部變量 : ", total)
return total
sum(10, 20)
print("函數外是全局變量 : ", total)
console:
函數內是局部變量 : 30
函數外是全局變量 : 0
global 和 nonlocal關鍵字
當內部作用域想修改外部作用域的變量時，就要用到global和nonlocal關鍵字了。
以下實例修改全局變量 num：
num = 1
def fun1():
global num # 需要使用 global 關鍵字聲明
print(num)
num = 123
print(num)
fun1()
print(num)
console:
1
123
123
如果要修改嵌套作用域（enclosing 作用域，外層非全局作用域）中的變量則需要 nonlocal 關鍵字了，如下實例：
def outer():
num = 10
def inner():
# print(num)#SyntaxError: name 'num' is used prior to nonlocal declaration
nonlocal num # nonlocal關鍵字聲明
num = 100
print(num)
inner()
print(num)
outer()
console:
100
100
11，異常
try:
需要執行的操作
except 異常類 as e:
如果發生異常，執行以下代碼
else:
如果沒有發生異常，執行的命令
finally:
無論如何，都要執行的代碼
常見的異常類型：
1. ImportError: 輸入錯誤。
2. IndexError: 索引超出列表範圍。
3. NameError: 嘗試訪問一個沒有申明的變量。
4.SyntaxError: 語法錯誤。
5.TypeError: 傳給函數的參數類型不正確。
6.ValueError: 傳給函數的參數類型正確，但是值不正確。
7.KeyError: 請求一個不存在的字典關鍵字。
8.ZeroDivisionError: 除數爲0。