一、概述
簡史
- 1989：Guido van Rossum
- 2008：python3.0 誕生
- 2014：宣布2.7支持到2020
- 2017：AI元年，Python崛起
環境
anaconda + pycharm
Python3.6
二、變量類型
- 數字類型 Number
- 字符串類型 str
- 列表 list
- 元組 tuple
- 字典 Dictionary
- 集合 set
- 數字類型 Number
- 數字類型沒有大小限制
- 整數
- 浮點數
- 復數 complex
- 布爾值(布爾值可以跟數字直接操作)
字符串類型 str
表示方法：
- 單引號
- 雙引號
- 三引號（三個單引號或者三個雙引號）
- 單雙引號交錯使用
- 格式化(利用百分號（%）) %d: 整數 %s: 字符串
利用format函數
s = "{}新手".format("Python")
None
表示什么都沒有
如果函數沒有返回值，可以返回 None
用來占位
三、內置數據結構
1.list(列表）
# 1, 創建空列表
l1 = []
# 2. 創建帶值的列表
l2 = [100]
# 3. 創建列表，帶多個值
l3 = [2,3,1,4,6,4,6]
# 4. 使用list()
l4 = list()
列表常用操作
訪問
使用下標操作（索引）
列表的位置是從0開始
分片操作
對列表進行任意一段的截取
l[:]
注意截取的范圍，包含左邊的下標值，不包含右邊的下標值
標值可以為空，如果不寫，左邊下標值默認為0， 右邊下標值為最大數加一，即表示截取到最后一個數據
分片可以控制增長幅度，默認增長幅度為1
# 打印從下標1開始的數字，每次隔一個
print(l[1:6:2])
下標可以超出范圍，超出后不在考慮多余下標內容
下標值，增長幅度可以為負數,為負數，表明順序是從右往左,規定： 數組最后一個數字的下標是-1
分片操作是生成一個新的list
- del: 刪除命令
- 使用加號鏈接兩個列表
- 使用乘號操作列表(相當于把n個列表接在一起)
- 成員資格運算
- 鏈表的遍歷
# for in list
a = [1,2,3,4,5]
# 挨個打印a里邊的元素
for i in a:
print(i)
# range
# in 后面的變量要求是可以可迭代的內容
for i in range(1,10):
print(i)
# 雙層列表循環
# a 為嵌套列表，或者叫雙層列表
a = [["one", 1], ["two", 2], ["three", 3] ]
for k,v in a:
print(k, "--", v)
# 雙層列表循環變異
# a 為嵌套列表，或者叫雙層列表
a = [["one", 1, "eins"], ["two", 2,"zwei"], ["three", 3,"drei"] ]
# 這個例子說明，k，v,w的個數應該跟解包出來的變量個數一致
for k,v,w in a:
print(k, "--", v, "--",w)
- 列表內涵: list content
# for 創建
a = ['a', 'b', 'c']
# 用list a創建一個list b
# 下面代碼的含義是，對于所有a中的元素，逐個放入新列表b中
b = [i for i in a]
# 對a中所有元素乘以10，生成一個新list
a = [1,2,3,4,5]
# 用list a創建一個list b
# 下面代碼的含義是，對于所有a中的元素，逐個放入新列表b中
b = [i*10 for i in a]
# 還可以過濾原來list中的內容病放入新列表
# 比如原有列表a， 需要把所有a中的偶數生成新的列表b
a = [x for x in range(1,35)] #生成從1到34的一個列表
# 把a中所有偶數生成一個新的列表 b
b = [m for m in a if m % 2 == 0]
# 列表生成式可以嵌套
# 由兩個列表a，b
a = [i for i in range(1,4)] # 生成list a
b = [i for i in range(100,400) if i % 100 == 0]
# 列表生成是可以嵌套,此時等于兩個for循環嵌套
c = [ m+n for m in a for n in b]
# 上面代碼跟下面代碼等價
for m in a:
for n in b:
print(m+n, end=" ")
# 嵌套的列表生城市也可以用條件表達式
c = [ m+n for m in a for n in b if m+n < 250]
- 關于列表的常用函數
len:求列表長度
a = [x for x in range(1,100)]
print(len(a))
max:求列表中的最大值
b = ['man', 'film', 'python']
print(max(b))
min
list：將其他格式的數據轉換成list
# 把range產生的內容轉換成list
print(list(range(12, 19)))
append 插入一個內容, 在末尾追加
a = [ i for i in range(1,5)]
a.append(100)
insert: 制定位置插入
# insert(index, data), 插入位置是index前面
a.insert(3, 666)
del 刪除
pop，從對位拿出一個元素，即把最后一個元素取出來
last_ele = a.pop()
remove:在列表中刪除指定的值的元素(如果被刪除的值沒在list中，則報錯)
clear:清空
reverse:翻轉列表內容，原地翻轉
a = [ 1,2,3,4,5]
a.reverse()
extend:擴展列表，兩個列表，把一個直接拼接到后一個上
a = [ 1,2,3,4,5]
b = [6,7,8,9,10]
a.extend(b)
count:查找列表中指定值或元素的個數
a_len = a.count(8)
copy: 拷貝，此函數是淺拷貝
b = a.copy()
2.tuple(元組)
# 創建空元組
t = ()
# 創建一個只有一個值的元組
t = (1,)
t = 1,
# 創建多個值的元組
t = (1,2,3,4,5)
t = 1,2,3,4,5
# 使用其他結構創建
l = [1,2,3,4,5]
t = tuple(l)
元組的特性
- 是序列表，有序
- 元組數據值可以訪問，不能修改
- 元組數據可以是任意類型
- list所有特性，除了可修改外，元組都具有
- 元組的函數
len: 獲取元組的長度
max, min:最大最小值
count: 計算制定數據出現的次數
index:求制定元素在元組中的索引位置
3.set(集合)
# 集合的定義
s = set()
# 此時，大括號內一定要有值，否則定義出的是一個dict
s = {1,2,3,4,5,6,7}
# 如果只是用大括號定義，則定義的是一個dict類型
d = {}
集合的特征
- 集合內數據無序，即無法使用索引和分片
- 集合內部數據元素具有唯一性，可以用來排除重復數據
- 集合內的數據，str, int, float, tuple,冰凍集合等，即內部只能放置可哈希數據
- 集合序列操作
- 成員檢測(in,not in)
- 遍歷
# for 循環
s = {4,5,"i"}
for i in s:
print(i, end=" ")
# 帶有元組的集合遍歷
s = {(1,2,3), ("just", "for", "fun"), (4,5,6)}
for k,m,n in s:
print(k, "--", m, "--", n)
for k in s:
print(k)
- 集合的內涵
# 普通集合內涵
# 以下集合在初始化后自動過濾掉重復元素
s = {23,223,545,3,1,2,3,4,3,2,3,1,2,4,3}
# 普通集合內涵
ss = {i for i in s}
# 帶條件的集合內涵
sss = {i for i in s if i % 2 == 0}
# 多循環的集合內涵
s1 = {1,2,3,4}
s2 = {"just", "for", "fun"}
s = {m*n for m in s2 for n in s1}
s = {m*n for m in s2 for n in s1 if n ==2}
- 集合函數
len, max, min
set:生成一個集合
add：向集合內添加元素
clear
copy
remove:移除制定的值，直接改變原有值，如果要刪除的值不存在，報錯
discard:移除集合中指定的值，跟 remove 一樣，但是入股要刪除的話，不報錯
pop 隨機移除一個元素
函數
- intersection: 交集
- difference:差集
- union: 并集
- issubset: 檢查一個集合是否為另一個子集
- issuperset: 檢查一個集合是否為另一個超集
數學操作 s1 = {1,2,3,4,5,6}
s2 = {5,6,7,8,9}
s_1 = s1 - s2
s_2 = s1 + s2
frozen set:冰凍集合
不可以進行任何修改的集合
# 創建
s = frozenset()
4.dict(字典)
沒有順序的組合數據，數據以鍵值對形式出現
# 字典的創建
# 創建空字典1
d = {}
# 創建空字典2
d = dict()
# 創建有值的字典， 每一組數據用冒號隔開， 每一對鍵值對用逗號隔開
d = {"one":1, "two":2, "three":3}
# 用dict創建有內容字典1
d = dict({"one":1, "two":2, "three":3})
# 用dict創建有內容字典2
# 利用關鍵字參數
d = dict(one=1, two=2, three=3)
#
d = dict( [("one",1), ("two",2), ("three",3)])
字典的特征
- 字典是序列類型，但是是無序序列，所以沒有分片和索引
- 字典中的數據每個都有鍵值對組成，即kv對
- key: 必須是可哈希的值，比如int,string,float,tuple, 但是，list,set,dict 不行
- value: 任何值
字典常見操作
# 訪問數據
d = {"one":1, "two":2, "three":3}
# 注意訪問格式
# 中括號內是鍵值
print(d["one"])
d["one"] = "eins"
# 刪除某個操作
# 使用del操作
del d["one"]
# 成員檢測， in， not in
# 成員檢測檢測的是key內容
d = {"one":1, "two":2, "three":3}
if 2 in d:
print("value")
if "two" in d:
print("key")
if ("two",2) in d:
print("kv")
# 按key來使用for循環
d = {"one":1, "two":2, "three":3}
# 使用for循環，直接按key值訪問
for k in d:
print(k, d[k])
# 上述代碼可以改寫成如下
for k in d.keys():
print(k, d[k])
# 只訪問字典的值
for v in d.values():
print(v)
# 注意以下特殊用法
for k,v in d.items():
print(k,'--',v)
字典生成式
d = {"one":1, "two":2, "three":3}
# 常規字典生成式
dd = {k:v for k,v in d.items()}
# 加限制條件的字典生成式
dd = {k:v for k,v in d.items() if v % 2 == 0}
字典相關函數
len, max, min, dict
str(字典): 返回字典的字符串格式
clear: 清空字典
items: 返回字典的鍵值對組成的元組格式
keys:返回字典的鍵組成的一個結構
values: 同理，一個可迭代的結構
get: 根據制定鍵返回相應的值
d = {"one":1, "two":2, "three":3}
print(d.get("on333"))
# get默認值是None，可以設置
print(d.get("one", 100))
: 使用指定的序列作為鍵，使用一個值作為字典的所有的鍵的值
l = ["eins", "zwei", "drei"]
# 注意fromkeys兩個參數的類型
# 注意fromkeys的調用主體
d = dict.fromkeys(l, "oops")
四、表達式
運算符
- 算數運算符
- 比較或者關系運算符
- 賦值運算符
- 邏輯運算符
- 位運算
- 成員運算
- 身份運算符
- 算數運算符
- 加 +
- 減 -
- 乘 *
- 除 /
- 取余 %
- 取商(地板除) //
- 冪運算 **
??Python 沒有自增自減運算符
比較運算符
比較的結果是布爾值（True/False）
賦值運算符
- =
- += （-=， ×=， /=, //=, %=, **=）
邏輯運算符
結果如果是0則為False， 否則為True
短路
Python 中沒有異或運算
成員運算符
用來檢測某一個變量是否是另一個變量的成員
身份運算符
- is: 用來檢測兩個變量是否是同一個變量
- is not: 兩個變量不是同一個變量
運算符的優先級
括號具有最高優先級
** 指數 (最高優先級)
~ + - 按位翻轉, 一元加號和減號 (最后兩個的方法名為 +@ 和 -@)
* / % // 乘，除，取模和取整除
+ - 加法減法
\>> << 右移，左移運算符
& 位 'AND'
^ | 位運算符
<= < > >= 比較運算符
<> == != 等于運算符
= %= /= //= -= += *= **= 賦值運算符
is is not 身份運算符
in not in 成員運算符
not or and 邏輯運算符
五、程序結構
順序
分支
基本語法 # 表達式后面的冒號不能少
# 用縮進來表示同一個代碼塊
if 條件表達式：
語句1
語句2
語句3
..
雙向分支 # if 和 else 一個層級，其余語句一個層級
if 條件表達式:
語句1
語句2
else:
語句1
語句2
多路分支 if 條件表達式：
語句1
.
elif 條件表達式：
語句1
elif 條件表達式：
語句1
..
else:
語句1
.
Python 沒有 switch-case 語句
循環
for 循環
for 變量
in 序列：
語句1
語句2
range
生成一個數字序列
范圍:
[m,n) # 打印 1～10
for i in range(1,11):
print(i)
for-else
當for循環結束的時候，會執行else語句
else語句可選
while 循環
while 條件表達式：
語句塊
#另外一種表達方法
while 條件表達式：
語句塊1
else：
語句塊2
循環之break,continue,pass
break： 無條件結束整個循環，簡稱循環猝死
continue：無條件結束本次循環，從新進入下一輪循環
pass：表示略過，通常用于站位，沒有跳過功能
六、函數
def關鍵字
代碼縮進 # 定義
def func():
print("這是一個函數")
# 調用
func()
函數的參數和返回值
參數： 負責給函數傳遞一些必要的數據或者信息
- 形參（形式參數）： 在函數定義的時候用到的參數沒有具體值，只是一個占位的符號，成為形參
- 實參（實際參數）： 在調用函數的時候輸入的值
返回值： 函數的執行結果
- 使用 return 關鍵字
- 如果沒有 return ，默認返回一個 None
- 函數一旦執行 return 語句，則無條件返回，即結束函數的執行
# return語句的基本使用
# 函數打完招呼后返回一句話
def hello(person):
print("{0}, 你腫么咧".format(person))
print("Sir, 你不理額額就走咧")
return "我已經跟{0}打招呼了，{1}不理我".format(person, person)
p = "明月"
rst = hello(p)
print(rst)
# 定義一個函數，打印一行九九乘法表
def printLine(row):
for col in range(1, row+1):
# print函數默認任務打印完畢后換行
print( row * col, end=" ")
print("")
# 九九乘法表
# version 2.0
for row in range(1,10):
printLine(row)
參數詳解
- 參數分類
- 普通參數
- 默認參數
- 關鍵字參數
- 收集參數
- 普通參數
參見上例
定義的時候直接定義變量名
調用的時候直接把變量或者值放入指定位置
def 函數名（參數1， 參數2，
.):
函數體
# 調用
函數名（value1, value2,
.)
默認參數
形參帶有默認值
調用的時候，如果沒有對相應形參賦值，則使用默認值
def func_name(p1=v1, p2=v2
.):
func_block
#調用1
func_name()
# 調用2
value1 = 100
value2 = 200
func_name(value1,value2)
關鍵字參數
def func(p1=v1, p2=v2
..):
func_body
# 調用函數：
func(p1=value1, p2=value2
.)
收集參數
把沒有位置，不能和定義時的參數位置相對應的參數，放入一個特定的數據結構中
def func(*args):
func_body
# 按照list使用方式訪問args得到傳入的參數
# 調用：
func(p1, p2, p3,
..)
收集參數混合調用的順序問題
收集參數，關鍵字參數，普通參數可以混合使用
使用規則就是，普通參數和關鍵字參數優先
定義的時候一般找普通參數，關鍵字參數，收集參數 tuple，收集參數 dict
返回值
函數和過程的區別
- 有無返回值
- 需要用return顯示返回內容，
- 如果沒有返回，則默認返回None
遞歸函數
python對遞歸深度有限制，超過限制報錯
# 斐波那契額數列
# 一列數字，第一個值是1， 第二個也是1， 從第三個開始，每一個數字的值等于前兩個數字出現的值的和
# 數學公式為： f(1) = 1, f(2) = 1, f(n) = f(n-1) + f(n-2)
# 例如： 1,1，2，3,5,8,13.。。。。。。。。
# n表示求第n個數子的斐波那契數列的值
def fib(n):
if n == 1:
return 1
if n == 2:
return 1
return fib(n-1) + fib(n-2)
print(fib(3))
print(fib(10))
漢諾塔問題
規則：
每次移動一個盤子
任何時候大盤子在下面，小盤子在上面
方法：
n=1： 直接把A上的一個盤子移動到C上， A->C
n=2:
把小盤子從A放到B上， A->B
把大盤子從A放到C上， A->C
把小盤子從B放到C上， B->C
n=3:
把A上的兩個盤子，通過C移動到B上去， 調用遞歸實現
把A上剩下的一個最大盤子移動到C上， A->C
把B上兩個盤子，借助于A，挪到C上去， 調用遞歸
n = n：
把A上的n-1個盤子，借助于C，移動到B上去，調用遞歸
把A上的最大盤子，也是唯一一個，移動到C上，A->C
把B上n-1個盤子，借助于A，移動到C上， 調用遞歸
def hano(n, a, b, c):
'''
漢諾塔的遞歸實現
n：代表幾個盤子
a：代表第一個塔，開始的塔
b：代表第二個塔，中間過渡的塔
c：代表第三個塔, 目標塔
'''
if n == 1:
print(a, "-->", c)
return None
'''
if n == 2:
print(a, "-->", b)
print(a, "-->", c)
print(b, "-->", c)
return None
'''
# 把n-1個盤子，從a塔借助于c塔，挪到b塔上去
hano(n-1, a, c, b)
print(a, "-->", c)
# 把n-1個盤子，從b塔，借助于a塔，挪到c塔上去
hano(n-1,b, a, c)
a = "A"
b = "B"
c = "C"
n = 1
hano(n, a, b, c)
n = 2
hano(n, a, b, c)
n = 3
hano(n, a, b, c)
查找函數幫助文檔
用 help 函數
help(print)
使用
__doc__ def stu(name, age):
'''
這是文檔的文字內容
:param name: 表示學生的姓名
:param age: 表示學生的年齡
:return: 此函數沒有返回值
'''
pass
print(help(stu))
print("*" * 20)
print(stu.__doc__)
七、變量作用域
分類：按照作用域分類
- 全局(global): 在函數外部定義
- 局部（local)：在函數內部定義
LEGB原則
- L（Local）局部作用域
- E（Enclosing function locale）外部嵌套函數作用域
- G（Global module）函數定義所在模塊作用域
- B（Buildin）： python內置魔抗的作用域
提升局部變量為全局變量(使用global)
def fun():
global b1
b1 = 100
print(b1)
print("I am in fun")
# b2的作用范圍是fun
b2 = 99
print(b2)
fun()
print(b1)
globals, locals函數
可以通過globals和locals顯示出局部變量和全局變量
# globals 和 locals
# globals 和 locals 叫做內建函數
a = 1
b = 2
def fun(c,d):
e = 111
print("Locals={0}".format(locals()))
print("Globals={0}".format(globals()))
fun(100, 200)
eval()函數
把一個字符串當成一個表達式來執行， 返回表達式執行后的結果
eval(string_code, globals=None, locals=None)
exec()函數
跟eval功能類似， 但是，不返回結果
exec(string_code, globals=None, locals=None)
posted on 2018-06-03 19:24
Ying-er 閱讀(837)
評論(0) 編輯 收藏 所屬分類:
Python 、
喵