一、元組
1、元組的定義：
元組, 英文為 **tuple**， Python的元組與列表類(lèi)似，不同之處在于**元組的元素不能修改**。元組使用小括號(hào)，列表使用方括號(hào)。元組創(chuàng)建很簡(jiǎn)單，只需要在括號(hào)中添加元素，并使用逗號(hào)隔開(kāi)即可。my_tuple = ('et', 77, 99.9, True)
2、訪問(wèn)元組元素
my_tuple = ('et', 77, 99.9, True)
print(my_tuple[0])
3、修改元組，元組不可以修改，會(huì)報(bào)錯(cuò)
my_tuple[0] = 'hello' —— 報(bào)錯(cuò)
4、 獲取元素索引值和數(shù)量
count, index：index和count與字符串和列表中的用法相同
a = ('a', 'b', 'c', 'a', 'b')
ret1 = a.index('a', 1, 3)? # 注意是左閉右開(kāi)區(qū)間，會(huì)報(bào)錯(cuò)，因?yàn)樵娴?:3位沒(méi)有a
ret2 = a.index('a', 1, 4)
ret3 = a.count('b')
ret4 = a.count('d')
# 元組和列表相比: 列表是可變的, 元組是不可變的
# 定義一個(gè)空元組
my_tuple = ()
print(type(my_tuple))
# 特例:
# 如果元組中只有一個(gè)元素
# 如下寫(xiě)法是錯(cuò)誤的:? <class 'int'>
my_tuple2 = (1)
print(type(my_tuple2))
# 如下寫(xiě)法才是正確的:? <class 'tuple'>
my_tuple3 = (1,)
print(type(my_tuple3))
# 元組也可以通過(guò)下標(biāo)獲取元組中的元素
my_tuple4 = (1, 3.14, True, 'Hello')
# 獲取3.14
value = my_tuple4[1]
print(value)
# 因?yàn)樵M是不可改變的 不可以修改元素 或者刪除元素
# 我們是否可以根據(jù)index和count獲取某個(gè)元素的位置和個(gè)數(shù)
index = my_tuple4.index(3.14)
print(index)
# 獲取某個(gè)元素的個(gè)數(shù)
count = my_tuple4.count(3.14)
print(count)
# for循環(huán)遍歷:
for value in my_tuple4:
? ? print(value)
# while循環(huán)遍歷:
index = 0
length = len(my_tuple4)
while index < length:
? ? value = my_tuple4[index]
? ? print(value)
? ? index += 1
二、字典
python中的字典規(guī)定則是 一對(duì)一:my_dict = {'name':'班長(zhǎng)'}
字典是另一種可變?nèi)萜髂Ｐ停铱纱鎯?chǔ)任意類(lèi)型對(duì)象。字典的每個(gè)鍵值 key? =>? value對(duì)? 用冒號(hào) : 分割；每個(gè)鍵值對(duì)之間用逗號(hào) , 分割；整個(gè)字典包括在花括號(hào) {} 中 ,格式如下所示：
字典的格式:d = {key1 : value1, key2 : value2, ... }
說(shuō)明：
- 字典和列表一樣，也能夠存儲(chǔ)多個(gè)數(shù)據(jù), 且數(shù)據(jù)類(lèi)型沒(méi)有要求
- 列表中找某個(gè)元素時(shí)，是根據(jù)下標(biāo)進(jìn)行的
- 字典中找某個(gè)元素時(shí)，是根據(jù)'名字'（就是冒號(hào):前面的那個(gè)值，例如上面代碼中的'name'）
- 字典的每個(gè)元素由2部分組成，鍵:值。例如 'name':'班長(zhǎng)' ,'name'為鍵，'班長(zhǎng)'為值
1、根據(jù)鍵--->訪問(wèn)值
my_dict = {'name':'班長(zhǎng)', 'id':100, 'sex':'f', 'address':'地球亞洲中國(guó)北京'}
my_dict['name']
**需要注意**:：若訪問(wèn)不存在的鍵，則會(huì)報(bào)錯(cuò)
在我們不確定字典中是否存在某個(gè)鍵而又想獲取其值時(shí)，可以使用get方法，還可以設(shè)置默認(rèn)值：
my_dict = {'name': '班長(zhǎng)'}
age = my_dict.get('age') #使用get方法,如果沒(méi)有當(dāng)前的key,則返回None
print(age)結(jié)果:
None我們也可以設(shè)置一個(gè)默認(rèn)值,如果沒(méi)有當(dāng)前的key值時(shí),? 則返回默認(rèn)參數(shù):
my_dict = {'name': '班長(zhǎng)'}
age = my_dict.get('age','age值沒(méi)有')
print(age)結(jié)果:
age值沒(méi)有# 三個(gè)元素(鍵值對(duì)) ，則len()返回3
print(len(my_dict))#定義一個(gè)特殊 (空字典)
my_dict1 = {}
print(len(my_dict1))
# <class 'dict'>
print(type(my_dict1))
my_dict2 = dict()
print(type(my_dict2))
# 鍵值1: 實(shí)值1 統(tǒng)稱(chēng)為 鍵值對(duì) key value 也稱(chēng)之為元素
# 鍵值數(shù)據(jù)類(lèi)型的選擇: 必須是不可變的
# 鍵值 的名字不能重復(fù)(才能完成1對(duì)1 通過(guò)一個(gè)key 獲取key 的value)，value可以重復(fù)
# 字典的key 一般都是使用字符串
# 字典的value 沒(méi)有規(guī)定 (可以重復(fù)的)
2、 字典的常用操作01:
1)? 修改元素
> 字典的每個(gè)元素中的數(shù)據(jù)是可以修改的，只要通過(guò)key找到，即可修改，# 字典是無(wú)序的 可變的
my_dict = {'name':'班長(zhǎng)', 'id':100, 'sex':'f', 'address':'地球亞洲中國(guó)北京'}
new_id = input('請(qǐng)輸入新的學(xué)號(hào):')
my_dict['id'] = int(new_id)
print('修改之后的id為: %d' % my_dict['id'])
?2) 添加元素
> 我們?cè)谛薷囊粋€(gè)字典時(shí), 如果當(dāng)前的key值不存在, 不會(huì)報(bào)錯(cuò), 而是進(jìn)行了增加,? 會(huì)在原有的字典中再次增加一個(gè).
my_dict[key] = value
# 如果使用上面的格式 如果這個(gè)key不存在 添加一組鍵值對(duì)
#如果使用上面的格式 如果這個(gè)key存在 會(huì)吧key原來(lái)的value的值進(jìn)行覆蓋
例如:
my_dict = {'name':'meihao'}
my_dict['age1'] = 101
print(my_dict)
3)? 刪除元素
> 對(duì)字典進(jìn)行刪除操作，有一下幾種：
del刪除指定的元素：# 刪除鍵值對(duì) 格式: del 字典名[key]
my_dict = {'name':'班長(zhǎng)', 'sex':'f', 'address':'地球亞洲中國(guó)北京'}
print('刪除前: %s' % my_dict['name'])
del my_dict['name']
print('刪除后: %s' % my_dict['name']) ——報(bào)錯(cuò)
clear清空整個(gè)字典，my_dict.clear()? ?等價(jià)于 my_dict = {} 或者 my_dict = dict()
my_dict = {'name':'monitor', 'sex':'f', 'address':'China'}
print('清空前: %s' % my_dict)
my_dict.clear()
print('清空后: %s' % my_dict)
結(jié)果:
清空前: {'name': 'monitor', 'sex': 'f', 'address': 'China'}
清空后: {}
3、字典的常用操作02:
1)? len(o)，o代表object，對(duì)象?
> 該方法為python內(nèi)置方法,可以返回傳入對(duì)象的長(zhǎng)度
dict = {'name': 'zhangsan', 'sex': 'm'}
length = len(dict)
print(length)
結(jié)果: 2
2)? keys(self) ，self代表沒(méi)有參數(shù)
> 返回一個(gè)包含字典所有key值的列表方法,? 我們可以把該方法轉(zhuǎn)為列表
例如:
my_dict = {'name':'monitor', 'sex':'f', 'address':'China'}
keys = my_dict.keys()
print(keys)
結(jié)果:dict_keys(['name', 'sex', 'address']) ——?# dict_keys(['name', 'sex', 'address'])其實(shí)就是列表類(lèi)型 dict_keys
把該方法轉(zhuǎn)為列表:
my_dict = {'name':'monitor', 'sex':'f', 'address':'China'}
keys1 = list(my_dict.keys())
print(keys1)
結(jié)果:['name', 'sex', 'address']
3)? values(self)
>? 返回一個(gè)包含字典所有value的列表方法, 該列表方法可以轉(zhuǎn)換為列表
例如:
my_dict = {'name': 'zhangsan', 'sex': 'm'}
values = my_dict.values()
print(values)
結(jié)果:dict_values(['zhangsan', 'm'])
將列表方法轉(zhuǎn)化為列表:
my_dict = {'name': 'zhangsan', 'sex': 'm'}
values1 = list(my_dict.values())
print(values1)
結(jié)果:['zhangsan', 'm']
4)? items(self)
> 返回一個(gè)列表,該列表由元組組成,元組又是由key ---> value的鍵值對(duì)組成
例如:?最外層是一個(gè)列表 每個(gè)元素是一個(gè)元組 (元素1(key), 元素2(value))
my_dict = {'name': 'zhangsan', 'sex': 'm'}
items = my_dict.items()
print(items)
items1 = list(items)
print(items1)
結(jié)果:dict_items([('name', 'zhangsan'), ('sex', 'm')])，[('name', 'zhangsan'), ('sex', 'm')]
5)? 字典的遍歷
> 通過(guò)for ... in ...
> 我們可以遍歷字符串、列表、元組、字典等(**注意python語(yǔ)法的縮進(jìn)**)
# 定義一個(gè)字典：my_dict = {"name": "小紅", "age": 22, "no": "009"}
# 遍歷-key
for key in my_dict.keys():
????print(key)# 遍歷value
for value in my_dict.values():
????print(value)# 遍歷items
for item in my_dict.items():
????print(item[0])
????print(item[1])# 通過(guò)設(shè)置兩個(gè)臨時(shí)變量
for key, value in my_dict.items():
????print("key:", key)
????print("value:", value)
### 可以獲取索引值的遍歷形式:
# 如果想使用元素和下標(biāo)索引 請(qǐng)使用enumerate(列表名)
# 定義一個(gè)列表
my_list = list("abcd")
# 不僅要獲取列表中的元素 而且需要知道這個(gè)元素下標(biāo)索引
for i, value in enumerate(my_list):
? ? print(i,value)
print('---------------------')
my_tuple = ('1234')
for i, value in enumerate(my_tuple):
? ? print(i,value)
print('----------------------')
my_dict = {'name':'meihao','age':'12345'}
for i, item in enumerate(my_dict.items()):
? ? print(i, item)
print('----------------------')
my_dict = {'name':'meihao','age':'12345'}
for i, key in enumerate(my_dict.keys()):
? ? print(i, key)
print('----------------------')
my_dict = {'name':'meihao','age':'12345'}
for i, value in enumerate(my_dict.values()):
? ? print(i, value)
print('----------------------')
三、公共方法和總結(jié)
1、關(guān)于開(kāi)閉區(qū)間的總結(jié)
1）隨機(jī)數(shù)
# 取值范圍: [x,? y]
random.randint(x, y)?
2）范圍
# 取值范圍 [x, y)
range(x, y)
3）切片 --->? 字符串中，列表，元組也可以切片
# 取值范圍[x, y)
'a'[x: y: 步長(zhǎng)]
2、數(shù)據(jù)類(lèi)型是否可變:
不可變的:int? float? bool? str? 元組
可變的:列表? 字典
3、公共方法
運(yùn)算符
| 運(yùn)算符 | Python 表達(dá)式? ? ? | 結(jié)果? ? ? ? ? ? ? ? ? ? ? ? | 描述? ? ? ? ? | 支持的數(shù)據(jù)類(lèi)型? ? ? ? ? |
| +? ? ? ? ? | [1, 2] + [3, 4]? ? ? ? ?| [1, 2, 3, 4]? ? ? ? ? ? ? ? | 合并? ? ? ? ? | 字符串、列表、元組? ? ? |
| *? ? ? ? ? ?| ['Hi!'] * 4? ? ? ? ? ? ? ? | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 復(fù)制? ? ? ? ? | 字符串、列表、元組? ? ? |
| in? ? ? ? ?| 3 in (1, 2, 3)? ? ? ? ? ?| True? ? ? ? ? ? ? ? ? ? ? ? | 元素是否存在? | 字符串、列表、元組、字典 |
| not in? ?| 4 not in (1, 2, 3)? ? ?| True? ? ? ? ? ? ? ? ? ? ? ? | 元素是否不存在 | 字符串、列表、元組、字典 |
4、python內(nèi)置函數(shù)
| 序號(hào) | 方法? ? ? | 描述? ? ? ? ? ? ? ? |
| 1? ? | len(item) | 計(jì)算容器中元素個(gè)數(shù)? |
| 2? ? | max(item) | 返回容器中元素最大值 |
| 3? ? | min(item) | 返回容器中元素最小值 |
| 4? ? | del(item) | 刪除變量? ? ? ? ? ? |
> **注意：len在操作字典數(shù)據(jù)時(shí)，返回的是鍵值對(duì)個(gè)數(shù)。**
max1 = max("hello itcast")? —— 結(jié)果是t，字母表里t這里最大
max3 = max({"a":1, "b":2}) —— 結(jié)果是b，對(duì)比的是鍵的大小，字母表里b比a大
max4 = max({"a":10, "b":2})—— 結(jié)果是b，對(duì)比的是鍵的大小 ，字母表里b比a大
max5 = max({"c":10, "b":12})—— 結(jié)果是c，對(duì)比的是鍵的大小 ，字母表里c比b大
> del有兩種用法，一種是del加空格，另一種是del()
a = 1
del aa = ['a', 'b']
del a[0]a = ['a', 'b']
del(a)
# 列表
# 注意順序
# my_list1 = [1, 2]
# my_list2 = [3, 5]
# ret1 = my_list2 + my_list1
# 字符串
# name = "小明"
# 占位符
# print("我叫%s" % name)
# ret = "我叫" + name
# ret1 = "我叫%s" % name
# print(ret1)
# 類(lèi)型不統(tǒng)一 使用str()轉(zhuǎn)類(lèi)型
# name = "小明"
# age = 18
# ret2 = "我叫" + name + "年齡" + str(age)
# print(ret2)
# 元組
# ret3 = (1, 4) + (6, 9)
# print(ret3)
# 運(yùn)算符 *
# 字符串
# my_str = "=="*20
# print(my_str)
# 列表
# my_list = ["hello", "world"]*10
# print(my_list)
# 元組
# my_tuple = (11,)*5
# print(my_tuple)
# in
#字符串
# my_name = "world"
# if "l" in my_name:
#? ? print("存在")
# 元組
# my_tuple = (1, 3, 5)
# if 1 in my_tuple:
#? ? print("存在")
# 字典
# my_dict = {"name": "小紅", "age": 22, "no": "009"}
# 使用in 在字典中其實(shí)是判斷的是key存不存在
# if "name" in my_dict:
#? ? print("存在")
# 就是想查看值到底有沒(méi)有
# if "小紅" in my_dict.values():
#? ? print("存在")
# del用法總結(jié)
# 可以配合列表使用
# my_list = [1, 2, 3]
# del my_list[1]
# 可以配合字典
# my_dict = {"name": "小紅", "age": 22, "no": "009"}
# del my_dict["age"]
# 可以提前銷(xiāo)毀一個(gè)對(duì)象
# 在程序沒(méi)有結(jié)束的時(shí)候 程序員提前殺死了這個(gè)對(duì)象 提前釋放內(nèi)存
# num = 10
# del num
# print(num)
# NameError: name 'num' is not defined
# 監(jiān)聽(tīng)當(dāng)程序結(jié)束后 python會(huì)執(zhí)行一個(gè)方法 del num 告知系統(tǒng)回收內(nèi)存
## 練習(xí)1:- 統(tǒng)計(jì)字符串中，各個(gè)字符的個(gè)數(shù)- 比如："hello world"
# 字符串統(tǒng)計(jì)的結(jié)果為： h:1 e:1 l:3 o:2 d:1 r:1 w:1str = 'hello world'
my_list = []
for c in str:
? ? if c != ' ' and c not in my_list:
? ? ? ? my_list.append(c)
? ? ? ? count = str.count(c)
? ? ? ? print('%s:%d' % (c,count),end=")
四、函數(shù)
1. 函數(shù)的了解,所有面向?qū)ο蟮恼Z(yǔ)言都有三大特點(diǎn)：封裝，繼承，多態(tài)
>? 函數(shù)是組織好的，可重復(fù)使用的，用來(lái)實(shí)現(xiàn)單一，或相關(guān)聯(lián)功能的代碼段。
> 函數(shù)的好處: 函數(shù)能提高應(yīng)用的模塊性，和代碼的重復(fù)利用率。你已經(jīng)知道Python提供了許多內(nèi)建函數(shù)，比如print()。但你也可以自己創(chuàng)建函數(shù)，這被叫做用戶(hù)自定義函數(shù)。
針對(duì)經(jīng)常重復(fù)使用,且代碼段很長(zhǎng)的程序,我們可以使用函數(shù)將代碼段進(jìn)行封裝, 哪里需要,直接調(diào)用封裝好的函數(shù)名即可,不用重復(fù)寫(xiě)代碼.
* 函數(shù)的出現(xiàn)解決了多次重復(fù)書(shū)寫(xiě)某一部分代碼的問(wèn)題
* 函數(shù)往往是某個(gè)功能的集合
* 這里的函數(shù)不要和我們數(shù)學(xué)中的函數(shù)聯(lián)系起來(lái).
* 函數(shù)就是個(gè)代碼塊.具有對(duì)立的功能.也可以理解為一個(gè)對(duì)象.
2、 函數(shù)的定義和調(diào)用
1) 定義函數(shù)
函數(shù)定義的簡(jiǎn)單規(guī)則：
- 函數(shù)代碼塊以 **def** 關(guān)鍵詞開(kāi)頭，后接函數(shù)標(biāo)識(shí)符名稱(chēng)和小括號(hào) **()**。
- 函數(shù)內(nèi)容以冒號(hào)開(kāi)始，并且必須要縮進(jìn)。
一般格式如下:
def 函數(shù)名（）:
函數(shù)體
2) 調(diào)用函數(shù)
> 定義了函數(shù)之后，就相當(dāng)于有了一個(gè)具有某些功能的代碼，想要讓這些代碼能夠執(zhí)行，需要調(diào)用它
> 調(diào)用函數(shù)很簡(jiǎn)單，通過(guò) **函數(shù)名()** 即可完成調(diào)用
- 每次調(diào)用某個(gè)函數(shù)時(shí)，該函數(shù)體都會(huì)從頭開(kāi)始執(zhí)行
- 當(dāng)這個(gè)函數(shù)中的代碼執(zhí)行完畢后，意味著調(diào)用結(jié)束
- 函數(shù)的定義一定要在函數(shù)調(diào)用之前.否則會(huì)找不到函數(shù)
3、函數(shù)的文檔說(shuō)明
> 給函數(shù)添加一些注釋, 解釋說(shuō)明當(dāng)前函數(shù)的主要功能, 參數(shù)作用, 返回值情況.
給函數(shù)添加文檔說(shuō)明:
def 函數(shù)名(a, b):
????"""
????這里可以書(shū)寫(xiě)該函數(shù)的主要作用
? ? :param a: 第一個(gè)參數(shù)介紹
? ? :param b: 第二個(gè)參數(shù)介紹
????:return:? 返回值的介紹
????"""
如果我們使用python內(nèi)置函數(shù)help() 就可以發(fā)現(xiàn)剛剛定義的函數(shù)文檔內(nèi)容了.? help(func_name) ——? 里面的函數(shù)名不能加小括號(hào)，因?yàn)檫@里不是要調(diào)用函數(shù)
4、函數(shù)參數(shù)一:
> 定義一般函數(shù)的時(shí)候我們可能用不到函數(shù)的參數(shù),? 但是有些問(wèn)題需要外部給內(nèi)部的函數(shù)傳值, 就需要函數(shù)能夠接受參數(shù)
> 讓函數(shù)能夠接收參數(shù)是對(duì)函數(shù)進(jìn)行的擴(kuò)展.
定義一個(gè)帶有參數(shù)的函數(shù),格式如下:
def 函數(shù)名(參數(shù)1, 參數(shù)2, ...):
????函數(shù)體
# 調(diào)用帶有參數(shù)的函數(shù)時(shí)，需要在小括號(hào)中，傳遞數(shù)據(jù)
#add2num是一個(gè)自定義函數(shù)
add2num(11, 22)
5、函數(shù)的返回值
“返回值”: 就是程序中的函數(shù)執(zhí)行完成后，返回回來(lái)的數(shù)據(jù).
* 其中:? 一個(gè)函數(shù)可以有返回值也可以沒(méi)有返回值,這個(gè)要看業(yè)務(wù)需求
* 返回值可以是多種多樣的,? 任何類(lèi)型都有可能
* 函數(shù)返回?cái)?shù)據(jù)的時(shí)候用的關(guān)鍵字是? return
* 函數(shù)調(diào)用后,如果有返回值, 我們可以定義一個(gè)變量來(lái)進(jìn)行接收.
# 定義一個(gè)帶有返回值的函數(shù)
def func():
????print('你好,這里是函數(shù)內(nèi)部')
????return '函數(shù)調(diào)用完成'
也可以寫(xiě)成這樣:
# 定義一個(gè)帶有返回值的函數(shù)
def func(a, b):
????print('你好,這里是函數(shù)內(nèi)部')
????return a + b也可以寫(xiě)成這樣:
def func():
????print('你好,這里是函數(shù)內(nèi)部')
????return True也可以寫(xiě)成這樣: (下面的代碼是函數(shù)的遞歸調(diào)用)
def deep(num):
?????print(num)
?????if num == 20:
?????????return
?????num += 1
?????return deep(num)
?deep(1)
結(jié)果是什么? 結(jié)果為 1 到 20 的所有數(shù)字# return 當(dāng)成跳出函數(shù)的方式來(lái)使用,而不是用它返回內(nèi)容
def func(a):
????if a < 0:
?????????print('請(qǐng)傳入正確的參數(shù).')
?????????return
????return a + 1
總結(jié):
* 函數(shù)可以有返回值,也可以沒(méi)有
* 函數(shù)的返回值自定
* 程序讀取到return 關(guān)鍵字后,? 就會(huì)退出當(dāng)前的函數(shù)體, 即 return之后的代碼將不會(huì)執(zhí)行
* 如果return 后面有內(nèi)容, 則返回return后面的內(nèi)容,? 如果單獨(dú)寫(xiě)一個(gè)return, 即 return后面沒(méi)有寫(xiě)明返回內(nèi)容,則返回None,? 但是函數(shù)體的執(zhí)行到此仍然結(jié)束, 不再往下執(zhí)行.
* 有時(shí)候,我們會(huì)把 return 當(dāng)成跳出當(dāng)前函數(shù)的方式來(lái)使用,? 而不是用它返回內(nèi)容.
* 一個(gè)函數(shù)中可以有多個(gè)return語(yǔ)句，但是只要有一個(gè)return語(yǔ)句被執(zhí)行到，那么這個(gè)函數(shù)就會(huì)結(jié)束，因此后面的return是沒(méi)什么用處的
* 一個(gè)函數(shù)中想要同時(shí)返回多個(gè)數(shù)據(jù), 不能夠靠寫(xiě)多個(gè)return來(lái)實(shí)現(xiàn).? 我們可以在函數(shù)的return 后面, 直接返回一個(gè)元組, 列表 或者 字典等.
如果return后面想要返回元組, 可以不用加 ( ) python返回多個(gè)值時(shí), 默認(rèn)就是元組格式:
def func():
? ??return 1, 2, 3?result = func()
print(result)
print(type(result))(1, 2, 3)
<class 'tuple'>
6. 四種類(lèi)型的函數(shù)
1)? 無(wú)參數(shù)，無(wú)返回值的函數(shù)
此類(lèi)函數(shù)，不能接收參數(shù)，也沒(méi)有返回值，一般情況下，打印提示燈類(lèi)似的功能，使用這類(lèi)的函數(shù)
2) 無(wú)參數(shù)，有返回值的函數(shù)
?此類(lèi)函數(shù)，不能接收參數(shù)，但是可以返回某個(gè)數(shù)據(jù)，一般情況下，像采集數(shù)據(jù)，用此類(lèi)函數(shù)
3) 有參數(shù)，無(wú)返回值的函數(shù)
此類(lèi)函數(shù)，能接收參數(shù)，但不可以返回?cái)?shù)據(jù)，一般情況下，對(duì)某些變量設(shè)置數(shù)據(jù)而不需結(jié)果時(shí)，用此類(lèi)函數(shù)
4) 有參數(shù)，有返回值的函數(shù)
此類(lèi)函數(shù)，不僅能接收參數(shù)，還可以返回某個(gè)數(shù)據(jù)，一般情況下，像數(shù)據(jù)處理并需要結(jié)果的應(yīng)用，用此類(lèi)函數(shù)
7、函數(shù)的嵌套使用
def testB():
????print('---- testB start----')
????print('這里是testB函數(shù)執(zhí)行的代碼...(省略)...')
????print('---- testB end----')def testA():
????print('---- testA start----')
????testB()
????print('---- testA end----')testA()
總結(jié)：
> 一個(gè)函數(shù)里面又調(diào)用了另外一個(gè)函數(shù)，這就是所謂的函數(shù)嵌套調(diào)用
>? 如果函數(shù)A中，調(diào)用了另外一個(gè)函數(shù)B，那么先把函數(shù)B中的任務(wù)都執(zhí)行完畢之后才會(huì)回到上次 函數(shù)A執(zhí)行的位置
> 一個(gè)函數(shù)中可以嵌套無(wú)數(shù)個(gè)函數(shù).
> 函數(shù)可以連著進(jìn)行嵌套,? 即 a函數(shù)嵌套于 b函數(shù), b函數(shù)又嵌套于 c函數(shù), c函數(shù)又.......
8、局部變量
> 函數(shù)內(nèi)部定義的變量,是局部變量，局部變量的作用域(使用范圍)在函數(shù)的內(nèi)部 函數(shù)的外部無(wú)法使用,形參也是局部變量
在函數(shù)內(nèi)部定義的局部變量名可以和其他函數(shù)中的局部變量名相同 是不沖突的
- 局部變量的作用，為了臨時(shí)保存數(shù)據(jù)需要在函數(shù)中定義變量來(lái)進(jìn)行存儲(chǔ)
- 當(dāng)函數(shù)調(diào)用時(shí)，局部變量被創(chuàng)建，當(dāng)函數(shù)調(diào)用完成后這個(gè)變量就不能夠使用了
9、全局變量
> 如果一個(gè)變量，既能在一個(gè)函數(shù)中使用，也能在其他的函數(shù)中使用，這樣的變量就是全局變量
總結(jié)1:
- 在函數(shù)外邊定義的變量叫做`全局變量`
- 全局變量能夠在所有的函數(shù)中進(jìn)行訪問(wèn)
相同名字的全局和局部變量
# 定義一個(gè)全局變量
a = 100def func1():
????a = 300
????print('------func1----修改前---a = %d ' %? a)
????a = 200
????print('------func1----修改后---a = %d ' %? a)def func2(): #函數(shù)內(nèi)部的a首先在函數(shù)內(nèi)部找，如果內(nèi)部沒(méi)有，就找函數(shù)外部的a
????print('------func2-----a = %d ' % a)# 調(diào)用函數(shù)
func1()
func2()結(jié)果:
------func1----修改前---a = 300
------func1----修改后---a = 200
------func2-----a = 100總結(jié)2:
- 當(dāng)函數(shù)內(nèi)出現(xiàn)局部變量和全局變量相同名字時(shí)，函數(shù)內(nèi)部中的 `變量名 = 數(shù)據(jù)` 此時(shí)理解為定義了一個(gè)局部變量，而不是修改全局變量的值
修改全局變量
>? 函數(shù)中使用全局變量時(shí)可否進(jìn)行修改呢？
# 定義一個(gè)全局變量
a = 100
def func1():
????global a # 把外部的a拿進(jìn)來(lái)
????print('------func1----修改前---a = %d ' %? a)
????a = 200
????print('------func1----修改后---a = %d ' %? a)def func2():
????print('------func2-----a = %d ' % a)# 調(diào)用函數(shù)
func1()
func2()結(jié)果:
------func1----修改前---a = 100
------func1----修改后---a = 200
------func2-----a = 200總結(jié)3:
- 如果在函數(shù)中出現(xiàn)`global 全局變量的名字` 那么這個(gè)函數(shù)中即使出現(xiàn)和全局變量名相同的`變量名 = 數(shù)據(jù)` 也理解為對(duì)全局變量進(jìn)行修改，而不是定義局部變量
- 如果在一個(gè)函數(shù)中需要對(duì)多個(gè)全局變量進(jìn)行修改
# 可以使用一次global對(duì)多個(gè)全局變量進(jìn)行聲明
global a, b
# 還可以用多次global聲明都是可以的
global a
global b
10、函數(shù)參數(shù)(二)
1)? 位置參數(shù)
> 位置參數(shù)是指我們調(diào)用函數(shù)時(shí)傳入的函數(shù)值和定義函數(shù)時(shí)的參數(shù)是一一對(duì)應(yīng)的.
# 定義一個(gè)函數(shù)
def my_func1(a, b):
? ? print(a + b)
# 函數(shù)的調(diào)用 -> 位置參數(shù)調(diào)用函數(shù)
# 使用位置參數(shù)調(diào)用函數(shù) 需要注意實(shí)參的位置
# 實(shí)參的位置和形參的位置要一一對(duì)應(yīng)
# TypeError: my_func1() missing 1 required positional argument: 'b'
# 如果實(shí)參傳入的少一個(gè)實(shí)參 會(huì)報(bào)錯(cuò)
2)? 關(guān)鍵字參數(shù)
> 我們調(diào)用函數(shù)的時(shí)候可以指定要傳遞的參數(shù)名稱(chēng), 直接把實(shí)參傳遞給對(duì)應(yīng)的形參.
# 通過(guò)指定形參名字的形式,把實(shí)參直接傳遞給對(duì)應(yīng)的形參.
def func(a, b):
????result = a + b
????print(result)# 可以這樣調(diào)用關(guān)鍵字參數(shù)
func(a = 10, b = 20)# 或者這樣:
func(b = 20, a = 10)結(jié)果:
30
30
def my_print(name, age, no):
????print("我的名字:%s" % name)
????print("我的年齡:%d" % age)
????print("學(xué)號(hào):%s" % no)# 調(diào)用-> 位置參數(shù)：my_print("小明", 20)
# 調(diào)用函數(shù)的時(shí)候使用的是函數(shù)的形參名： my_print(age=22, name="老王")
# 調(diào)用函數(shù)的時(shí)候 使用了位置和關(guān)鍵字參數(shù)混合
# 如果混合使用 需要叫位置參數(shù)在前 關(guān)鍵字參數(shù)再后
# 如果某個(gè)參數(shù)使用了關(guān)鍵字參數(shù) 后面的都需要使用關(guān)鍵字參數(shù)：my_print("小明", age=20, no="007")
3) 缺省參數(shù)
> 缺省參數(shù)就是指的默認(rèn)值參數(shù), 即如果我們調(diào)用函數(shù)的時(shí)候沒(méi)有傳入該參數(shù), 那么就直接使用該缺省參數(shù).
總結(jié)：
- 在形參中默認(rèn)有值的參數(shù)，稱(chēng)之為缺省參數(shù)
- 注意：帶有默認(rèn)值的參數(shù)一定要位于參數(shù)列表的最后面, 否則報(bào)錯(cuò)
# 如果執(zhí)行函數(shù)的時(shí)候提供實(shí)參 那么函數(shù)的形參使用實(shí)參
# 如果執(zhí)行函數(shù)的時(shí)候沒(méi)有提供實(shí)參 那么形參將使用默認(rèn)值(缺省參數(shù))
# 在定義函數(shù)的時(shí)候某個(gè)形參使用了缺省參數(shù) 那么后面的形參 都需要用缺省參數(shù)
def my_print(name, age=20, no="001")
4)? 函數(shù)返回多個(gè)數(shù)據(jù)的方式
# 列表
def deal_name_age(name, age):
?????# 處理后 姓名:小明? 年齡:22
????new_name = "姓名:%s" % name
????new_age = "年齡:%d" % age
????return [new_name, new_age]# 變量為列表
ret = deal_name_age("小明", 22)
print(ret[0])
print(ret[1])# 字典
def deal_name_age(name, age):
????# 處理后 姓名:小明? 年齡:22
????new_name = "姓名:%s" % name
????new_age = "年齡:%d" % age
????return {"name":new_name, "age":new_age}my_dict = deal_name_age("小明", 22)
print(my_dict["name"])
print(my_dict["age"])# 元組
def deal_name_age(name, age):
????# 處理后 姓名:小明? 年齡:22
????new_name = "姓名:%s" % name
????new_age = "年齡:%d" % age
????# 如果在函數(shù)內(nèi)部 使用return 返回值1 返回值2,... 默認(rèn)就是元組類(lèi)型 不需要寫(xiě)小括號(hào)
????return new_name, new_agemy_tuple = deal_name_age("小明", 22)
print(type(my_tuple))
print(my_tuple[0])
print(my_tuple[1])
11、拆包
拆包:? 對(duì)于函數(shù)中的多個(gè)返回?cái)?shù)據(jù), 去掉元組, 列表 或者字典 直接獲取里面數(shù)據(jù)的過(guò)程.
1) 對(duì)列表進(jìn)行拆包
my_list = [1, 3.14, "hello", True]
num, pi, my_str, my_bool = my_list# 或者
num, pi, my_str, my_bool = [1, 3.14, "hello", True]
2) 對(duì)元組進(jìn)行拆包
my_tuple = (1, 3.14, "hello", True)
num, pi, my_str, my_bool = my_tuple
3) 對(duì)字典進(jìn)行拆包
my_dict = {"name":"老王", "age": 19}
ret1, ret2 = my_dict
# 得到的是key? 字典是無(wú)序的
4)? 用拆包的形式定義變量
# # 變量名和值是一一對(duì)應(yīng)
num1, num2, num3, num4 = 10, 20, 30, 3.14
5)? 函數(shù)返回元組時(shí)直接拆包
對(duì)元組拆包:
def get_my_info():
????high = 178
????weight = 100
????age = 18
????return high, weight, age
# 這一步叫做拆包:
my_high, my_weight, my_age = get_my_info()也可以對(duì)列表或者元組拆包:
def function1():
????return [1, 2, 3]def function2():
????return {"key1": 1, "key2": 2, "key3": 3}# 調(diào)用函數(shù),獲取里面的數(shù)據(jù)
num1, num2, num3 = function1()
print(num1, num2, num3)
總結(jié)：
- 拆包時(shí)要注意，需要拆的數(shù)據(jù)的個(gè)數(shù)要與變量的個(gè)數(shù)相同，否則程序會(huì)異常
- 除了對(duì)元組拆包之外，還可以對(duì)列表、字典等拆包
- 對(duì)字典拆包后獲取的是字典的key值, 而不是value值
交換兩個(gè)變量的值:a = 1,? b = 2.? ? ? 怎樣把 a,? b 的值交換?
### 1)? 方法一:> 定義一個(gè)變量c
a = 1
b = 2
c = 0
c = a
a = b
b = c### 2) 方法二:> 加法運(yùn)算:
a = 1
b = 2
a = a + b
b = a - b
a = a - b?### 3) 方法三:> 異或運(yùn)算，異或運(yùn)算只能在二進(jìn)制時(shí)進(jìn)行，不能對(duì)十進(jìn)制進(jìn)行
# 異或運(yùn)算就是相同的值得0，不同的值得1，如 1111 XOR 0101=1010。
# 兩個(gè)二進(jìn)制數(shù)進(jìn)行邏輯或運(yùn)算時(shí)，要是有一個(gè)為1，則結(jié)果為1，只有兩個(gè)數(shù)全為0結(jié)果才為0 ，如 1010 OR 1101=1111
a = 1? #十進(jìn)制的1是二進(jìn)制的1，因?yàn)榉?進(jìn)1的話，還沒(méi)到2
b = 2 #十進(jìn)制的2是二進(jìn)制的10
a = a ^ b
b = a ^ b? # a^b = a^b^b=a^0=a
a = a ^ b? # a^b = a^a^b = 0^b = b### 4) 方法四:> 拆包
a = 1
b = 2
a, b = b, a### 5) 方法五:
a = 1
b = 2
if a > b:
? ? num = a-b
? ? a -= num
? ? b += num
else:
? ? num = b-a
? ? a += num
? ? b -= num
五、匿名函數(shù)
> 用lambda關(guān)鍵詞能創(chuàng)建小型匿名函數(shù)。這種函數(shù)省略了用def聲明函數(shù)的標(biāo)準(zhǔn)步驟。
> lambda表達(dá)式，通常是在**需要一個(gè)函數(shù)，但是又不想費(fèi)神去命名一個(gè)函數(shù)**的場(chǎng)合下使用，也就是指**匿名函數(shù)**。
lambda函數(shù)的語(yǔ)法只包含一個(gè)語(yǔ)句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
例如:
sum = lambda arg1, arg2: arg1 + arg2 —— arg1，arg2是形參# 調(diào)用sum函數(shù)
print("Value of total : %d" % sum( 10, 20 ))
print("Value of total : %d"% sum( 20, 20 ))
應(yīng)用場(chǎng)合
1)? 函數(shù)作為參數(shù)傳遞
例如:
def func(a, b, opt)
????print('a:%d' % a)
????print('b:%d' % b)
????print('result:%d' % opt(a, b))func(1, 2, lambda x, y : x + y)
結(jié)果:
a:1
b:2
result:3
2)? 作為內(nèi)置函數(shù)的參數(shù)
list = [
????{"name": "zhangsan", "age": 18},
????{"name": "lisi", "age": 19},
????{"name": "wangwu", "age": 17}
????]
# key:可選參數(shù), 如果指定了該參數(shù)會(huì)使用該參數(shù)的方法進(jìn)行排序。
list.sort(key = lambda x: x['name'])
print(list)
list.sort(key= lambda x: x['age'])
print(list)按name排序:
[{'name': 'lisi', 'age': 19}, {'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}]按 age 排序:
[{'name': 'wangwu', 'age': 17}, {'name': 'zhangsan', 'age': 18}, {'name': 'lisi', 'age': 19}]add = lambda x, y : x+y
add(1,2)? # 結(jié)果為3def func(a,b):
????return lambda x:ax+b
f = func(1,1)
f(1) # 結(jié)果為2
總結(jié):
* lambda函數(shù)也叫匿名函數(shù), 即? 函數(shù)沒(méi)有具體的名稱(chēng).
* lambda? x, y : x + y 中:? lambda是關(guān)鍵字.? x, y 是函數(shù)的兩個(gè)形參.? ? x + y是函數(shù)的返回值.
? * 上面的式子可以寫(xiě)成:
? * def? func( x,? y ):? ? return x + y
* 匿名函數(shù)的可以作為參數(shù), 傳遞到另一個(gè)函數(shù)中.
def first(x, y):
????return? x + y
def second(x, y, opt):
????print(x)
????print(y)
????result = opt(x, y)
????print(result)
second(22, 33, first)
* 上面的代碼可以用匿名函數(shù)實(shí)現(xiàn):
def second(x, y, opt):
????print(x)
????print(y)
????result = opt(x, y)
????print(result)
second(22, 33, lambda x, y: x + y)
