01.recode

1.函數(shù)的調(diào)用

過程：
回到函數(shù)聲明的位置
用實(shí)參給形參賦值(傳參)
執(zhí)行函數(shù)體
獲取返回值
回到函數(shù)調(diào)用的位置

壓棧：
當(dāng)調(diào)用函數(shù)的時(shí)候，系統(tǒng)會(huì)自動(dòng)在棧區(qū)間開辟空間保存函數(shù)調(diào)用過程中產(chǎn)生的數(shù)據(jù)(形參,函數(shù)中聲明的變量)

2.返回值

看有沒有遇到return,遇到了函數(shù)的返回值就是return后面的值，沒有返回值就是None。
函數(shù)調(diào)用表達(dá)式的結(jié)果就是函數(shù)的返回值

3.函數(shù)的參數(shù)

位置參數(shù)和關(guān)鍵字參數(shù): 位置參數(shù)要在關(guān)鍵字參數(shù)的前面

參數(shù)的默認(rèn)值: 參數(shù)名=值
不定長參數(shù): *參數(shù)名; **參數(shù)名
參數(shù)類型說明: 參數(shù)名:類型名
對(duì)函數(shù)的返回值進(jìn)行類型說明: def 函數(shù)名(參數(shù)列表) -> 返回值類型:

4.匿名函數(shù)

函數(shù)名 = lambda 參數(shù)列表:返回值

def func1(a: int) -> int:
    return a**2

func1(10)
print(func1(10))

100

02.變量的作用域

1.變量的作用域

變量在程序中能夠使用的范圍

2.全局變量

a.聲明在函數(shù)或者類的外部的變量都是全局變量
b.全局變量是從聲明開始到整個(gè)py文件結(jié)束，任何位置都可以使用(作用域：從聲明開始到文件結(jié)束)

3.局部變量

a.聲明在函數(shù)或者類的里面的變量都是局部變量
b.局部變量是從聲明開始到函數(shù)結(jié)束，任何位置都可以使用(作用域：從聲明開始到函數(shù)結(jié)束)

===========1.全局變量===========

#全局變量
a = 10

# x和y是全局變量
for x in range(10):
    y = 20
    print(x)

0
1
2
3
4
5
6
7
8
9

print(x, y)

9 20

if True:
    # b是全局變量
    b = 20

print(b)

20

def func1():
    print('函數(shù)中:', a)
    print('函數(shù)中', x, y)


func1()

函數(shù)中: 10
函數(shù)中 9 20

============2.局部變量=============

# num1, num2, aa, xx都是局部變量
def func2(num1, num2):
    print(num1, num2)
    aa = 11
    print(aa)
    for xx in range(5):
        print(xx)
    print(xx)


func2(10, 20)
# print(num1)  # NameError: name 'num1' is not defined
# print(aa)  # NameError: name 'aa' is not defined

11
0
1
2
3
4
4

============3.global的使用==========

global關(guān)鍵字只能在函數(shù)中使用,作用是在函數(shù)中聲明一個(gè)全局變量

語法:
global 變量名
變量名 = 值

# 聲明一個(gè)全局變量a1
a1 = 100


def test1():
    # 聲明一個(gè)局部變量a1
    # a1 = 200
    # print(a1)

    global a1
    a1 = 200
    print(a1)

    # 在函數(shù)中聲明全局變量b1
    global b1
    b1 = 300


test1()
print(a1, b1)

200
200 300

=============4.nonlocal的使用==============

nonlocal關(guān)鍵字只能在函數(shù)中使用
當(dāng)需要在局部的局部中修改局部變量的值，就使用nonlocal

語法：
nonlocal 變量名
變量名 = 值

def func1():
    # 聲明一個(gè)局部變量a2
    a2 = 'abc'

    # python中函數(shù)可以聲明函數(shù)
    def func11():
        nonlocal a2
        a2 = 'python'
        print('func11-a2:', a2)
        # a3的作用域在func11中
        a3 = 111
    func11()
    print('func1-a2:', a2)


func1()

func11-a2: python
func1-a2: python

# 思考？
funtions = []
for x in range(5):
     def func1(a):
         return a*x
     funtions.append(func1)

 t1 = funtions[0]
 t2 = funtions[2]
 print(t1(2))
 print(t2(2))

8
8

03.函數(shù)作為變量

python中，聲明函數(shù)其實(shí)就是聲明一個(gè)類型是function的變量。函數(shù)名就是變量名

函數(shù)名作為變量除了可以用來調(diào)用函數(shù)獲取返回值以外，普通變量能做的它都能做

# 聲明類型是int類型的變量a
a = 10
print(type(a))      # <class 'int'>

# 聲明類型是dict類型的變量b
b = {'a': 12, 'b': 200}
print(type(b))         # <class 'dict'>
print(b['a'])           # 12

# 聲明類型是function類型的變量c
c = lambda x: x*x
print(type(c))         #   <class 'function'>
c(10)


# # 聲明類型是function類型的變量d
def d(x):
    def e():
        print('abc')
    e()
    return x*x


print(type(d))             #   <class 'function'>
d(10)                # abc

1.讓一個(gè)變量給另外一個(gè)變量賦值

# 聲明一個(gè)列表變量list1
list1 = [1, 2, 3]
# 使用列表變量list1給list2賦值
list2 = list1
# 將list2當(dāng)成列表來用
print(list2[0])         # 1


# 聲明一個(gè)函數(shù)變量func11
def func11():
    print('我是函數(shù)')

#  使用函數(shù)變量func11給ff賦值
ff = func11
# 將ff當(dāng)成函數(shù)來用
ff()           # 我是函數(shù)

2.將變量作為列表的元素或者字典的值

# 聲明列表變量list1
list1 = [100, 200, 300]
# 將列表變量list1作為列表list2的元素
list2 = [list1, 100]
print(list2[0][0])               #  100


# 聲明一個(gè)函數(shù)變量func2
def func2():
    print('我是函數(shù)2')
# 將函數(shù)變量func2作為列表list2的元素
list2 = [func2, 100]
print(list2[0]())             #  我是函數(shù)2  
                                  # None

3.作為函數(shù)的參數(shù)

將函數(shù)1作為實(shí)參，傳遞給函數(shù)2；這兒的函數(shù)2就是一個(gè)高階函數(shù)(實(shí)參高階函數(shù))

def test(x):
    # x = func3
    print('test:', x)
    if not isinstance(x, int):
        x()

# 聲明一個(gè)int類型的變量a
a = 10
# 將變量a作為test的實(shí)參
test(a)

# 聲明一個(gè)fucntion類型的變量func3
def func3():
    print('我是函數(shù)3')
test(func3)

test: 10
test: <function func3 at 0x021B5540>
我是函數(shù)3

3.1 sort函數(shù)

def sort(key=None, reverse=False)
key - 確定排序的時(shí)候以什么值為標(biāo)準(zhǔn)來排序(默認(rèn)情況下，以列表的元素的大小為標(biāo)準(zhǔn)來排序);
需要傳一個(gè)函數(shù)，函數(shù)需要一個(gè)參數(shù)和一個(gè)返回值。這兒的參數(shù)是列表的元素
reverse - 是否降序排序, 需要傳一個(gè)bool值

# list2.sort(reverse=True)
"""
[1, 34, 20, 89, 8]  -> [1, 8, 20, 34, 89]
index = 0   [1, 34, 20, 89, 8]
index = 1   [1, 8, 34 ,89, 20]
index = 2   [1, 8, 20, 89, 34]
...
"""

def yt_sort(list1, key=None):
    # list1 = my_list2; key = get_age
    if key == None:
        # 直接對(duì)列表元素進(jìn)行排序
        for index in range(len(list1)):
            for index2 in range(index+1, len(list1)):
                current = list1[index]
                behind = list1[index2]
                if behind < current:
                    list1[index], list1[index2] = list1[index2], list1[index]
    else:
        for index in range(len(list1)):
            for index2 in range(index+1, len(list1)):
                current = key(list1[index])
                behind = key(list1[index2])
                if behind < current:
                    list1[index], list1[index2] = list1[index2], list1[index]


my_list = [1, 34, 20, 89, 8]
yt_sort(my_list)
# my_list.sort()
print(my_list)

my_list2 = [
    {'name': '張三', 'age': 18},
    {'name': '李四', 'age': 30},
    {'name': '王五', 'age': 10}
]
# my_list2.sort() # TypeError: '<' not supported between instances of 'dict' and 'dict'
# yt_sort(my_list2) # TypeError: '<' not supported between instances of 'dict' and 'dict'


def get_age(x):
    return x['age']


yt_sort(my_list2, get_age)
print(my_list2)


my_list2 = [
    {'name': '張三', 'age': 18, 'score': 90},
    {'name': '李四', 'age': 30, 'score': 80},
    {'name': '王五', 'age': 10, 'score': 89}
]

# 取最大年齡對(duì)應(yīng)的字典
max_age = max(my_list2, key=lambda x: x['age'])
print(max_age)

# 取最大成績對(duì)應(yīng)的字典
max_score = max(my_list2, key=lambda x: x['score'])
print(max_score)

test: <function func3 at 0x021B5540>
我是函數(shù)3
[1, 8, 20, 34, 89]
[{'name': '王五', 'age': 10}, {'name': '張三', 'age': 18}, {'name': '李四', 'age': 30}]
{'name': '李四', 'age': 30, 'score': 80}
{'name': '張三', 'age': 18, 'score': 90}

練習(xí)：要求將按列表中元祖的第二個(gè)元素，獲取最大值。

my_list3 = [('z', 10), ('b', 30), ('c', 20)]
print(max(my_list3, key=lambda item: item[1]))

('b', 30)

4.變量作為函數(shù)的返回值

返回值是函數(shù)的函數(shù)，也叫高階函數(shù)(返回值高階函數(shù))

def test2(n):
    sum1 = 1
    for x in range(1, n+1):
        sum1 *= x
    return sum1


re = test2(5) + 10
print(re)

130

def get_operation(char):
    # char = '+'
    """
    根據(jù)不同的符號(hào)返回不同的功能(函數(shù)功能的描述)
    :param char: 運(yùn)算符符號(hào)
    :return: 不同運(yùn)算符對(duì)應(yīng)的功能的函數(shù)
    """
    if char == '+':
        # 求和的功能
        def sum(*args, **kwargs):
            # args = (10,20,30)
            """求多個(gè)數(shù)的和"""
            sum1 = 0
            for item1 in args:
                sum1 += item1
            for key in kwargs:
                sum1 += kwargs[key]
            print('yt')
            return sum1

        return sum
    elif char == '*':
        def mul(*args, **kwargs):
            sum1 = 1
            for item1 in args:
                sum1 *= item1
            for key in kwargs:
                sum1 *= kwargs[key]
            return sum1

        return mul
    elif char == '-':
        def diff(*args):
            """求多個(gè)數(shù)的差"""
            # (10, 20, 30)
            sum1 = args[0]
            for index in range(1, len(args)):
                sum1 -= args[index]
            return sum1

        return diff
    else:
        print('暫時(shí)不支持這個(gè)運(yùn)算符')
        return None


# re是一個(gè)函數(shù)
re = get_operation('+')
# re(10, 20, 30) - 調(diào)用函數(shù)獲取返回值
print(re(10, 20, 30))  # 60  = 10+20+30

# get_operation('*')  - 這個(gè)整體是一個(gè)函數(shù)
# get_operation('*')(1, 2, 3)  - 調(diào)用求乘積的那個(gè)函數(shù)，并且獲取返回值
re = get_operation('*')(1, 2, 3)
print(re)


# 10 - 20 - 30
print(get_operation('-')(100, 20, 30))

yt
60
6
50

04.迭代器

1.什么是迭代器(iter)

迭代器是python中的容器類的數(shù)據(jù)類型，可以同時(shí)存儲(chǔ)多個(gè)數(shù)據(jù)。
取迭代器中的數(shù)據(jù)只能一個(gè)一個(gè)的取，而且取出來的數(shù)據(jù)，在迭代器就不存在了

2.迭代器中數(shù)據(jù)的來源

a.將其他序列轉(zhuǎn)換成迭代器
b.使用生成式、生成器去產(chǎn)生數(shù)據(jù)

1.將數(shù)據(jù)轉(zhuǎn)換成迭代器

所有的序列都可以轉(zhuǎn)換成迭代器

#將字符串轉(zhuǎn)換成迭代器
iter1 = iter('abcd')
print(iter1)

iter2 = iter([1, 10, 100, 1000])
print(iter2)

iter3 = iter({'name': '小明', 'age': 20})
print(iter3)

<str_iterator object at 0x0050C310>
<list_iterator object at 0x006A38B0>
<dict_keyiterator object at 0x00697F00>

2.獲取迭代器中的元素

a.
next(迭代器) / 迭代器.next() - 取出迭代器中第一個(gè)元素(已經(jīng)取出來的元素再也回不到迭代器中了)

print(next(iter1))
print(next(iter1))
print(next(iter1))
print(next(iter1))
# print(next(iter1))   # 當(dāng)?shù)魇强盏臅r(shí)候，使用next獲取元素，會(huì)出現(xiàn)StopIteration異常

print(iter2.__next__())
print(next(iter2))

a
b
c
d
1
10

b.通過for循環(huán)取出迭代器中每個(gè)元素

for x in iter2:
    print('==:', x)

# print(next(iter2))   # 出現(xiàn)異常StopIteration，因?yàn)閒or循環(huán)已經(jīng)將這個(gè)迭代器中的元素取完了

==: 100
==: 1000

05.生成器

1.什么是生成器

生成器就是迭代器；迭代器不一定是生成器

調(diào)用帶有yield關(guān)鍵字的函數(shù)，拿到的結(jié)果就是一個(gè)生成器。生成器中元素就是yield關(guān)鍵字后邊的值

2.生成器怎么產(chǎn)生數(shù)據(jù)

只要函數(shù)中有yield關(guān)鍵字，調(diào)用函數(shù)不會(huì)再執(zhí)行函數(shù)體獲取返回值，而是創(chuàng)建一個(gè)生成器。
當(dāng)獲取生成器的元素的時(shí)候,才會(huì)執(zhí)行函數(shù)的函數(shù)體,執(zhí)行到y(tǒng)ield語句為止，并且將yield后面的值作為結(jié)果返回；
并且保存當(dāng)前執(zhí)行的位置。
獲取下一個(gè)元素的時(shí)候，就從上次結(jié)束的位置接著往下去執(zhí)行函數(shù)，直到函數(shù)結(jié)束或者遇到y(tǒng)ield為止;
如果遇到y(tǒng)ield就將yield后面的值作為結(jié)果返回，并且保存當(dāng)前執(zhí)行的位置。如果函數(shù)結(jié)束了，就出現(xiàn)StopIteration異常

生成器對(duì)應(yīng)的函數(shù)，執(zhí)行完成遇到y(tǒng)ield的次數(shù)，決定了生成器能產(chǎn)生的數(shù)據(jù)的個(gè)數(shù)

def func1():
    print('abc')
    yield 123
    print('!!!!!!')
    yield 100


re = func1()
print(re)

# next(re) - 執(zhí)行re對(duì)應(yīng)的函數(shù)的函數(shù)體,將yield關(guān)鍵字后邊的值作為結(jié)果
print('===:', next(re))
# print('===:', next(re))
# print('===:', next(re))

<generator object func1 at 0x00537EA0>
abc
===: 123

def numbers():
    for x in range(101):
        yield x
        print('next', x)


gener = numbers()
print(next(gener))
print(next(gener))
print(next(gener))

0
next 0
1
next 1
2

寫一個(gè)生成器可以無限產(chǎn)生學(xué)號(hào)

def creat_id():
    num = 0
    while True:
        yield 'stu'+str(num)
        num += 1

gener_id = creat_id()
print(next(gener_id))
for x in range(10):
    print(next(gener_id))

print(next(gener_id))

stu0
stu1
stu2
stu3
stu4
stu5
stu6
stu7
stu8
stu9
stu10
stu11

練習(xí)：寫一個(gè)生成器，可以不斷產(chǎn)生斐波那契數(shù)列：1，1，2，3，5，8，13，21....

def sequence(n):
    pre_1 = 0
    pre_2 = 1
    for _ in range(n):
        yield pre_2
        pre_1, pre_2 = pre_2, pre_1+pre_2


gen = sequence(10)
print(next(gen))
print(next(gen))
print(next(gen))
print(next(gen))
for x in gen:
    print('for:', x)

1
1
2
3
for: 5
for: 8
for: 13
for: 21
for: 34
for: 55

06.homework

0.寫一個(gè)匿名函數(shù)，判斷指定的年是否是閏年

# 閏年：能夠被4整除但是不能被100整除?；蛘吣軌虮?00整除
isleapyear = lambda year: (year % 4 == 0 and year % 100 != 0) or year % 400 == 0
print(isleapyear(2012))
print(isleapyear(2008))
print(isleapyear(2018))
print(isleapyear(2000))

True
True
False
True

1.寫一個(gè)函數(shù)將一個(gè)指定的列表中的元素逆序( 如[1, 2, 3] -> [3, 2, 1])(注意:不要使 表自帶的逆序函數(shù))

def reverse(list1: list):
    length = len(list1)
    for index in range(length//2):
        list1[index], list1[length-1-index] = list1[length-1-index], list1[index]


my_list = [1, 2, 3]   # index = 0  list1[index] = list1[len(list1)-index-1]
reverse(my_list)
print(my_list)

[3, 2, 1]

2.寫一個(gè)函數(shù)，提取出字符串中所有奇數(shù)位上的字符

def get_substr(str1: str):
    strstr = ''
    for index in range(len(str1)):
        if index & 1:
            strstr += str1[index]
    return strstr


print(get_substr('abcdefg'))

bdf

3.寫一個(gè)函數(shù)，統(tǒng)計(jì)指定列表中指定元素的個(gè)數(shù)(不用列表自帶的count方法)

def get_count(list1, item):
    count = 0
    for x in list1:
        if x == item:
            count += 1
    return count


print(get_count([1, 23, 3, 4, 4, 23], 4))

2

7.寫一個(gè)函數(shù)，能夠?qū)⒅付ㄗ址械闹付ㄗ哟鎿Q成指定的其他子串(不能使用字符串的replace方法)

例如: func1('abcdaxyz', 'a', '//') - 返回: '//bcd//xyz'

def replace(str1: str, old, new):
    # 先切割
    str_list = str1.split(old)

    strstr = str_list[0]
    for index in range(1, len(str_list)):
        strstr += '+'+str_list[index]

    return strstr


print(replace('abcabchasjhsabchjshdjfabcsjhdfjhabc123', 'abc', '+'))

++hasjhs+hjshdjf+sjhdfjh+123