實際開發的時候，能不用遞歸就不用遞歸

1.什么是遞歸函數

函數中調用函數本身的函數就是遞歸函數

2.遞歸的作用：循環能做的事情遞歸函數都能做

a = 0


def func2():
    print('======')
    global a
    if a < 5:
        a += 1
        func2()


func2()

3.怎么寫遞歸函數：f(n)

第一步：確定臨界值 - 循環結束的條件，在臨界值的地方要讓函數結束！
第二步：找關系 - 找當次循環和上次循環的關系；
找f(n)和f(n-1)的關系
第三步：假設函數f的功能已經實現，通過f(n-1)來實現f(n)的功能

實現：1+2+3+...+n

# for循環實現
# n = 20
# sum1 = 0
# for x in range(n+1):
#     sum1 += x
# print(sum1)

遞歸實現

def gyh_sum(n):
    # 1.找臨界值
    if n == 1:
        return 1

    # 2.找關系
    """找gyh_sum(n)和gyh_sum(n-1)的關系
       gyh_sum(n):1+2+3+...+n
       gyh_sum(n-1):1+2+3+...+n-1
       gyh_sum(n) = gyh_sum(n-1)+n
    """
    return gyh_sum(n - 1) + n


print(gyh_sum(100))

練習：求斐波那契數列第n個數

# 1, 1, 2, 3, 5, 8, 13....
def sequence(n):
    # 找臨界值
    if n == 1 or n == 2:
        return 1
    # 2.f(n)和f(n-1)
    """f(n) = f(n-1) + f(n-2)"""
    return sequence(n-1) + sequence(n-2)


print(sequence(20))

4.循環能做的事情不能使用遞歸做！

sum1 = 0
for x in range(100001):
    sum1 += x
print(sum1)


# def gyh_sum(n):
#     if n == 1:
#         return 1
#     return gyh_sum(n - 1) + n
#
#
# print(gyh_sum(100))

1.什么是模塊

在python中一個py文件就是一個模塊
a.系統模塊(標準庫) - python系統提供的模塊(安裝解釋器的時候已經導入到解釋器中了，使用的時候在代碼中直接導入)
random模塊 - 提供隨機數
math模塊 - 提供數學運算
json庫 - 提供json數據相關的操作
re模塊 - 提供正則表達式相關操作
socket模塊 - 提供python套接字編程
time模塊 - 提供和時間相關的操作
threading模塊 - 提供和線程相關的操作
...

b.自定義模塊 - 程序員自己創建的py文件
自己寫的模塊
別人寫的模塊 - 第三方庫(需要先下載到解釋器中，然后才能在代碼中導入)

標準庫和第三方庫一般是通過模塊提供變量、函數、類

import random
print(random.randint(10, 100))

2.怎么使用模塊

import 模塊名 - 在程序中直接導入指定的模塊，導入后可以使用模塊中所有的全局變量(包含了變量、函數、類)
導入后通過 模塊名.變量 來使用模塊中的內容

from 模塊名 import 變量1, 變量2 - 在程序中導入指定的模塊，導入后只能使用import后面的變量
導入后直接使用變量，不用在前面加 模塊名.

from 模塊名 import * - 在程序中導入指定模塊，并且可以直接使用里面所有的全局變量( * 為通配符)
導入后直接使用變量，不用再前面加 模塊名.

3.導入模塊的實質：

a.不管是使用import還是from - import,導入模塊的時候都會執行模塊中所有的代碼
b.python中一個模塊不會重復導入多次。因為導入的時候系統會自動檢查當前模塊是否已經導入

print('=======import model1之前=======')
import module1
import module1
print('=======import model1之后=======')
module1.a = 1000
print(module1.a)
print(module1.fun1())

# print('=========from model2 import之前=========')
# from model2 import aa, x
# print('=========from model2 import之后=========')
# print('aa:', aa)
# print(x)
# # print(model2.func2())   # 不能是用model2中除了aa和x的內容

aa = 'hello'
from module2 import *
# 導入model2，并且可以直接使用里面所有的全局變量
print('aa:', aa)
print(x)
func2()

print('==============import model3================')
import module3

# print(model3.a)
# print(model3.b)

模塊1：

print('model1開始')
a = 100
print('model1:', a)


def fun1():
    b = 200
    print('test1中的func1被調用', b)

fun1()

print('model1結束')

模塊2：

print('model2開始')
aa = 'abc'

for x in range(1000):
    print(x)


def func2():
    print('model2中的func2被調用')


func2()


print('model2結束')

模塊3：

# 其他函數的聲明
print('if外面的語句')


# 這兒就是程序的入口
def main():
    print('這兒的代碼不會被導入')


print('model3:', __name__)

# 寫在這個if語句中的代碼不會被別的模塊執行。
if __name__ == '__main__':
    print('if里面的語句')
    main()

4.怎么阻止模塊中的內容被其他模塊執行

將不希望被其他模塊執行的代碼放在if語句中
如果希望被其他模塊使用的代碼就放在if語句的外面

(這兒的if語句指的是：if name == 'main')

原理：
每個模塊都有一個name屬性代表模塊名，默認情況下它的值是py文件的文件名。
當當前模塊正在被執行(直接執行)的時候，模塊屬性name的值就會變成main

寫在這個if語句中的代碼不會被別的模塊執行。

# 其他函數的聲明

# 這兒就是程序的入口
# def main():
#     print('這兒的代碼不會被導入')
#
#
# if __name__ == '__main__':
#     main()

5.重命名 - 導入模塊的時候可以對模塊或者模塊中的內容重新命名

import 模塊名 as 新模塊名
from 模塊名 import 變量名1 as 新變量名1, 變量名2, 變量名3 as 新變量名3

# import module4 as newMode
# print(newMode.age)

name = 100

from module4 import name as gyh_name, age as gyh_age

print(name)
print(gyh_name)
print(gyh_age)

模塊4：

name = '小明'
age = 18


def show_info():
    print(name, age)


if __name__ == '__main__':
    pass

1.什么是迭代器(iter)

是python提供的容器型數據類型

獲取迭代器中的元素的時候只能從前往后一個一個的取，而且取了之后這個元素在迭代器中就不存在了

list1 = [1, 2, 3, 4]
print(list1[0])
print(list1[1])
print(list1[0])

2.迭代器的字面量

迭代器沒有指定格式的字面量。迭代器作為容器，里面的元素只能通過其他序列轉換，或者通過生成器生成
迭代器中的元素可以是任何類型的數據

# 將字符串轉換成迭代器，迭代器中的元素就是字符串中的每個字符
iter1 = iter('hello')
print(iter1)

# 將列表轉換成迭代器，迭代器中的元素就是列表中的每個元素
iter2 = iter([100, 'shi', (10, 20), [1, 2], True, {'name': '小花'}, lambda x: x])
print(iter2)

3.獲取元素

(迭代器中的元素只支持查，不支持增刪改)
迭代器是通過next函數獲取單個元素，for - in 遍歷一個一個獲取每一個元素。
不管哪種方式獲取，已經獲取過的元素，在迭代器中就不存在

iter3 = iter('hello')

# 1.next
"""
next(迭代器)  ->  獲取迭代器中最新的數據(最頂層)
"""
print(iter3)
print(next(iter3))
print(next(iter3))
print(next(iter3))
print(next(iter3))
print(next(iter3))
# print(next(iter3))    # 報  StopIteration  異常，因為在這兒迭代器中的數據已經取完了
print(iter3)

iter3 = iter('123456')
print(next(iter3))

# 通過for - in取迭代器中的元素和next效果一樣，元素還是會從迭代器中取出
for x in iter3:
    print('x:', x)

# print(next(iter3))

練習：看打印結果

iter4 = iter([10, True, 'abc', (1, 2)])

index = 0
for x in iter4:
    index += 1
    if index == 2:
        break

print(next(iter4))
print(next(iter4))

1.什么是生成器

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

2.生成器怎么產生元素

調用一個帶有yield關鍵字的函數就能得到一個生成器

不帶yield的函數：調用的時候會執行函數體，并且獲取返回值
帶yield的函數：調用的時候不會執行函數體，也不會獲取返回值，而是產生一個生成器(函數調用表達式就是一個生成器)
這個生成器中的元素就是yield關鍵字后面的值

def func1():
    print('====')
    return 100


print(func1())   # 100

print('=====================')


def func2():
    yield
    print('====')
    return 100


print(func2())    # <generator object func2 at 0x00CBAB70>

3.生成器的元素

生成器中的元素也是通過next或者for - in

生成器獲取元素，實質就是去執行生成器對應的函數,每次執行到yield語句為止，并且會將yield后面的值作為當次獲取到的元素
下次獲取元素的時候會接著上次結束的位置完后執行，直到下一個yield為止...
以此類推，直到函數結束。如果執行到函數結束沒有遇到yield那么就會報 StopIteration 異常

def func3():
    print('----')
    yield 100
    print('!!!!!!!!!!')
    yield 'abc'


gen1 = func3()   # gen1就是一個生成器(生成器就是迭代器)
print(gen1)
print(next(gen1))
print('第一次結束')
print(next(gen1))


# py1809001  py1809002  py1809003
def create_num():
    num = 1
    while True:
        yield 'py1809%d' % num
        num += 1


num_gen = create_num()

students = []
for _ in range(10):
    students.append(next(num_gen))

print(students)


def gyh_iter(seq):
    for x in seq:
        yield x


iter1 = gyh_iter('1235')
print(next(iter1))
print(next(iter1))
print(next(iter1))
print(next(iter1))