Python_基礎_(局部全局變量，函數各類類型)

一，局部變量，全局變量

 1.無global 關鍵字：當函數中無關鍵字 global 時，當局部變量與全局變量命名相同，優先讀取函數中的變量，函數中沒法對全局變量進行修改，但當全局變量的類型爲列表時，可對內部的元素進行操做（例：test.append）。

li = ["1",2,3,4,5] def test(): li.append("hello")    # 對原有的列表進行操做
    # print(li)
 test() print(li) # 輸出 ['1', 2, 3, 4, 5, 'hello']

 

2.有global關鍵字

name = "aaaa"
def test(): global name name = "bbbb" test() print(name) # 輸出 bbbb

 

# 注：

# 下方的程序會產生報錯，在一個函數中既有局部變量，有引用了全局變量（在函數中聲明引用全局變量，應將global放於最上方）
 name = "aaaa"
def test(): name = "cccc"
    global name name = "bbbb" test() print(name) # 報錯
  File "F:/Python_Project/Test/Test.py", line 242
    global name ^ SyntaxError: name 'name' is assigned to before global declaration

 

## 書寫規格 ##

######### 全局變量變量名大寫
######### 局部變量變量名小寫

 二，函數做用域

 

# 當一個函數中返回另外一個函數的函數名，其實際返回的是該函數的地址，能夠直接使用該地址調用該函數

def test1(): print("this is test1()") def test2(): print("this is test2()") return test1    # 返回函數test1()的地址
 res = test2() print(res) res() # 當執行函數test2()時，返回了函數test1()的地址，因此res()代指爲函數test1()

# 執行的結果
this is test2() <function test1 at 0x00000197E46BC378> this is test1()

 

def one(): print("this is one") def two(): print("this is two") def three(): print("this is three") return three return two test_two = one()    # 執行函數one() 返回函數two()的地址
test_three = test_two() # 執行函數two() 返回函數three的地址
test_three()    # 執行函數three)


# 注：上面的三步至關於 one()()()

# 輸出結果
this is one this is two this is three

三，函數嵌套

# nonlocal 指定上一級變量（name 爲函數test1()中的name）
name = "hello"
def test1(): name = "world"
    def test2(): nonlocal name print(name)

 四，遞歸

 編程語言中的定義：函數直接或間接的調用函數自己，則該函數稱爲遞歸函數

再數學中的定義：對於某一函數F(x)，其定義域是集合A，那麼若對於A集合中的某一個值X0，其函數值F(x0)由F(F(x0))決定，那麼就稱F(x)爲遞歸函數

## 如下爲一個遞歸，該遞歸爲一個死循環

def clac(n): print(n) clac(n): clac(10)

 

 

# 遞歸所具備的特性

1.函數的遞歸必須有一個明確的結束條件

2.每次進入更深的一層遞歸時，問題的規模應當比上次遞歸有所減小

def test(n): print(n) if int(n/2) == 0: return n return test(int(n/2)) test(10) # 輸出
10
5
2
1

 

 

五，匿名函數　　關鍵字lambda

# 匿名函數
lambda x:x+1    # x：函數的形參 x+1：爲函數的返回值

# 上方匿名函數對應的普通函數
def calc(x): return x+1 func = lambda x:x+1
print(func(10))    # 至關於執行匿名函數


lambda x,y,z:(x+1,y+1,z+1)    # 在lambda中返回多個值 得加上括號

 

 六，編程方法論

 1.面向過程：

　　面向過程就是分析出解決問題所須要的步驟，而後用函數把這些步驟一步一步實現，使用的時候一個一個依次調用就能夠了。

面向過程實際上是最爲實際的一種思考方式，就算是 面向對象的方法也是含有面向過程的思想。能夠說面向過程是一種基礎的方法。它考慮的是實際地實現。通常的面向過程是從上往下步步求精，因此面向過程最重要的是模塊化的思想方法。對比面向過程，面向對象的方法主要是把事物給對象化，對象包括屬性與行爲。當程序規模不是很大時，面向過程的方法還會體現出一種優點。由於程序的流程很清楚，按着模塊與函數的方法能夠很好的組織。好比拿學生早上起來這件事說明面向過程，粗略的能夠將過程擬爲：

(1)起牀

(2)穿衣

(3)洗臉刷牙

(4)去學校

而這4步就是一步一步地完成，它的順序很重要，你只須要一個一個地實現就好了。而若是是用面向對象的方法的話，可能就只抽象出一個學生的類，它包括這四個方法，可是具體的順序就不必定按照原來的順序。

https://baike.baidu.com/item/%E9%9D%A2%E5%90%91%E8%BF%87%E7%A8%8B/9957246?fr=aladdin

2.面向對象：

　　向對象是一種對現實世界理解和抽象的方法...待補充

3.函數式編程：

　　待補充

七，內置函數

 ### map()函數

## 第一種例子
num_l = [1,2,3,4,5] def add_one(x): x = x + 1
    return x def map_test(func,array): ret = [] for i in array: res = func(i)   # 調用函數add_one() 後返回計算後的值
        ret.append(res) # 將獲得的值追加到列表ret中
    return ret print(map_test(add_one,num_l))  # 傳入執行自加一的函數 傳入源列表

# 結果 [2, 3, 4, 5, 6]

## 第二種寫法 利用抽象函數
num_l = [1,2,3,4,5] def map_test(func,array): ret = [] for i in array: res = func(i)  # 利用抽象函數進行計算
        ret.append(res) # 將獲得的值追加到列表ret中
    return ret print(map_test(lambda x:x+1,num_l))  # 利用抽象函數 傳入源列表
print(map_test(lambda x:x-1,num_l)) # 結果
[2, 3, 4, 5, 6] [0, 1, 2, 3, 4] ## 第三種寫法 利用map函數
 num_l = [1,2,3,4,5] res = map(lambda x:x+1,num_l) print(list(res)) ### 在python3.5中此時獲得的是一個可迭代對象 <map object at 0x000001EA24F68240> ### 在python2.7中直接獲得的是一個列表[2, 3, 4, 5, 6, 7, 8]

# 將一個字符串轉成大寫形式，列表
msg = "helloworld"
print(list(map(lambda x:x.upper(),msg))) # 輸出['H', 'E', 'L', 'L', 'O', 'W', 'O', 'R', 'L', 'D']

### filter()函數

## 過濾掉末尾以 sb 結尾的字符串

### 第一種寫法
name = ['aaaa_sb','bbbb_sb','cccc_sb','dddd'] def end_filter(n): return n.endswith("sb") def filter_test(func,array): res = [] for p in array: if not func(p): res.append(p) return res print(filter_test(end_filter,name)) # 輸出['bbbb']


### 第二種寫法
name = ['aaaa_sb','bbbb_sb','cccc_sb','dddd'] def filter_test(func,array): res = [] for p in array: if not func(p): res.append(p) return res print(filter_test(lambda x:x.endswith("sb"),name)) # 輸出['bbbb']

### 第三種寫法 利用filter函數
name = ['aaaa_sb','bbbb_sb','cccc_sb','dddd'] print(list(filter(lambda x:not x.endswith('sb'),name))) # 輸出['bbbb']

### reduce

# 在Python2種能夠直接使用該函數
# 咋Python3種得導入該模塊
from functools import reduce(重模塊functools種導入函數reduce )

### 第一種寫法

from functools import reduce num_list = [1,2,3,4,5] def reduce_test(func,array): res = array.pop(0) for num in array: res = func(res,num) return res print(reduce_test(lambda x,y:x+y,num_list)) print(reduce_test(lambda x,y:x*y,num_list)) ### 第二種寫法 利用reduce函數
print(reduce(lambda x,y:x+y,num_list)) print(reduce(lambda x,y:x*y,num_list))

總結：

map：對原有的數據進行加工，處理列表中的每一個元素，獲得的結果是一個「列表」（迭代器的形式），該列表的個數及位置與原來同樣
filter：對數據進行過濾（遍歷序列中的每一個元素，判斷每一個元素獲得布爾值，若是爲True則留下來）
reduce：對原有的數據進行壓縮(相加 相乘)

其它內置函數：

abs()   # 取絕對值
 all() # 對序列中的元素進行布爾運算（0，None，空字符串爲假），序列中的元素一個爲假 則爲假
 any() # 序列中的元素有一個爲真 則爲真
 bool() # 判斷布爾值（0，None，空字符串 爲False）其他的爲True
 hex() # 十進制轉十六進制
 oct() # 十進制轉八進制
 bin() # 將十進制轉爲二進制
 bytes() # 將一個字符串轉成字節的形式
name = "你好中國" ret = bytes(name,encoding="utf-8") print(bytes(ret) # 得指定編碼方式 # 輸出的結果爲 '\xe4\xbd\xa0\xe5\xa5\xbd\xe4\xb8\xad\xe5\x9b\xbd'

print(ret.decode("UTF-8")) # 進行解碼（注何種編碼格式編碼,就用各類編碼格式解碼） # 輸出的結果爲 你好中國
 chr() # 按照ASCII碼變進行對應的轉換
ord(97) # 顯示在ASCII碼中對應的字符
 dir() # 打印某個對象中全部的方法 例如dir(all)
 divmod() # divmod(10,3) 輸出的結果爲(3,1),輸出商和餘數
 eval() # 功能一 # 將字符串中的數據結構提取出來
dic = {"name": "henry"}  # 定義一個字典
dic_str = str(dic)  # 將其轉換成字符串的形式
print(dic_str) d = eval(dic_str)  # 將字符串中的字典提取出來
print(d["name"]) # 功能二：將字符串中的表達式進行算術運算
num_list = "1+2+3-4*5/6"
print(eval(num_list)) hash() # 可hash的數據類型爲不可變數據類型，不可hash的數據便可變的數據類型 # 無論所給的字符串有多長，相同數據獲得的哈希數相同(注意每次運行都會獲得一個新的值) # 不能根據獲得的哈希值進行反推獲得原來的字符串 # hash能夠用來判斷文件或數據有沒有被修改過
name = "你好中國"
print(hash(name)) # 7099912592138176852
 help() # 用於打印一個方法的具體使用方法help(all)

print(isinstance(1, int))       # 判斷1是不是int型,返回布爾值
print(isinstance('abc', str))   # 判斷abc是不是str型
print(isinstance([], list))     # 判斷是否爲列表類型
print(isinstance({}, dict))     # 判斷是否爲字典類型
 globals() # 打印全局的全部變量
locals()    # 打印局部變量
 num_list = [1, 2, 3, 4] min(num_list) # 取列表最大值
max(num_list)   # 取列表最小值（傳入的數據類型是一個可迭代類型） # 1.max函數處理的是可迭代的對象，至關於一個for循環取出每一個元素進行比較。注意：不一樣類型元素之間不能進行比較 # 2.每一個元素間進行比較，是從每一個元素的第一個位置一次比較，若是這個位置分出大小後，後面的則不須要進行比肩
 dic = {"name": "hh", "age", 18} max(dic) # 比較的是key
max(dic.values())   # 比較的是value 沒法獲得與Key相對應



# zip(a序列,b序列) a序列與b序列爲一一對應的關係 # 序列包括 列表 元組 字符串 # 元組
print(list(zip(("a", "b", "c"), (1, 2, 3))))  # 輸出的爲 [("a",1),("b",2),("c",3)]
print(list(zip(("a", "b", "c"), (1, 2, 3, 4))))  # 輸出也爲[("a",1),("b",2),("c",3)]
print(list(zip(("a", "b", "c", "d"), (1, 2, 3))))  # 輸出也爲[("a",1),("b",2),("c",3)]

# 字符串
print(zip("hello", "12345")) # [('h', '1'), ('e', '2'), ('l', '3'), ('l', '4'), ('o', '5')]

print(zip(["h", "e", "l", "l", "o"], ["1", "2", "3", "4", "5"])) # [('h', '1'), ('e', '3'), ('l', '2'), ('o', '5')]
 p = {"name": "henry", "age": 18} print(list(zip(p.keys(), p.values()))) # [("name","henry"),("age",18)]

# zip和max配合使用_初級玩法 # 取出一個字典中最大的年紀
>> > age_dic = {'a_age': 18, 'b_age': 30, 'c_age': 10} >> > print(max(zip(age_dic.values(), age_dic.keys()))) # 先用zip將其轉爲元組模式 在進行比較
(30, 'b_age') >> > num_list = ["a1", "a2", "a3", 100] print(max(num_list))  # 會報錯 不一樣的數據類型間不能比較

# zip和max配合使_終極玩法
people = [ {"name": "aaa", "age": 19} {"name": "bbb", "age": 13} {"name": "ccc", "age": 12} {"name": "ddd", "age": 11} ] max(people) # 直接報錯（字典自己無序，多個字典間不能進行比較）
print(max(people, value=lambda dic: dic['age'])) pow(2, 2)  # 至關於求2**2
pow(3, 2, 2)  # 至關於32次方，對2取餘 3**2%2
 recursed() # 將一個序列反轉（對源序列無影響）
 round(2.4)  # 四捨五入
 set() # 將其轉爲集合形式
print(set("hello")) set(['h', 'e', 'l', 'o']) num_list = "hello" s = slice(3, 5)      # 切片
s1 = slice(3, 5,2)  # 定義切片步長
 a = [3, 4, 5, 3, 3, 2, 6] print(sorted(a))   # 對序列進行排序，實質就是進行比較大小，不一樣類型的數據元素之間不能進行排序
 people = [ {"name": "aaa", "age": 19}, {"name": "bbb", "age": 13}, {"name": "ccc", "age": 12}, {"name": "ddd", "age": 11} ] print(sorted(people, key=lambda dic: dic['age']))  # 對字典的集合進行排序 # [{'name': 'ddd', 'age': 11}, {'name': 'ccc', 'age': 12}, {'name': 'bbb', 'age': 13}, {'name': 'aaa', 'age': 19}]
 name_dic = { "python": 1, "java": 2, "C": 3 } print(sorted(name_dic, key=lambda key: name_dic[key])) # ['python', 'java', 'C']
 a = [1, 2, 3, 5] sum(a) # 求和
 type(a) # 查看數據類型 # 根據type判斷數據類型 根據不一樣的數據類型執行不一樣的邏輯
 vars() # 當vars沒有參數時，與locas() 的用法相同，打印局部變量
vars(int)   # 當有參數時，查看某個對象中的全部方法，以字典的形式顯示

其它內置函數