Python(2)—— 元組,字典,公共方法,函數(shù)

一、元組

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)萜髂P停铱纱鎯?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 a

a = ['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:1

str = '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 = 100

def 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_age

my_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é)果為3

def 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)

最后編輯于
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
平臺(tái)聲明:文章內(nèi)容(如有圖片或視頻亦包括在內(nèi))由作者上傳并發(fā)布,文章內(nèi)容僅代表作者本人觀點(diǎn),簡(jiǎn)書(shū)系信息發(fā)布平臺(tái),僅提供信息存儲(chǔ)服務(wù)。