"""
1.函数的声明
def 函数名(参数列表):
函数体

lambda 参数列表: 返回值

(重点)函数声明的时候函数体不会执行！

2.函数调用
函数名() <---> 变量() - 要求变量中存储的地址对应的值是function

调用过程:
回到函数声明的位置
传参 - 保证每个参数都有值
执行函数体
确定返回值
回到函数调用的位置

3.函数的参数
位置参数和关键参数
参数默认值
参数类型说明
不定长参数

4.返回值
怎么确定函数的返回值
怎么获取函数的返回值 - 函数调用表达式

5.全局变量和局部变量
6.函数作为量: 声明函数就是声明一个类型是function的变量，函数名就是变量名
"""
def func1():
return 10

a = 10

func1和a是一样的，都是变量

print(a - 1)
print(func1())

a = [1, 2]
print(a[0])

func1 = 'abc'
print(func1[0])

lambda x: x 和 10是一样的，都是值

num = 10
list1 = [10]

func2 = lambda x: x
list2 = [lambda x: x]

func2(10)
list20

def yt_sums(*num):
"""求多个数的和"""
# num = (1, 2, 3, 4)
sum1 = 0
for x in num:
sum1 += x
return sum1

def yt_product(*num):
sum1 = 1
for x in num:
sum1 *= x
return sum1

print(yt_sums(1, 2, 3))

print(yt_product(2, 4, 6))

def opration(char: str, nums):
# char = '+', nums = (1, 2, 3, 4) nums 相当于 1, 2, 3, 4
if char == '+':
return yt_sums(nums) # yt_sums(1,2,3,4)
else:
return yt_product(nums)

print(opration('+', 1, 2, 3, 4))
print(opration('*', 1, 2, 3, 4))

(了解!)

"""
实际开发的时候，能不用递归就不用
1.什么是递归函数
函数中调用函数本身的函数就是递归函数

2.递归的作用：循环能做的事情递归函数都能做
"""

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

a = 0

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

"""
func2()

0 < 5：  a = 1   func2()

1 < 5 a = 2 func2()

2 < 5    a = 3   func2()

3 < 5 a = 4 func2()

4 < 5    a = 5   func2()

5 < 5

"""
func2()

"""
3.怎么写递归函数：f(n)
第一步：确定临界值 - 循环结束的条件,在临界值的地方要让函数结束！
第二步：找关系 - 找当次循环和上次循环的关系;
找f(n)和f(n-1)的关系
第三步: 假设函数f的功能已经实现，通过f(n-1)来实现f(n)的功能
"""

实现：1+2+3+...+n

a.for循环

n = 20

# sum1 = 0

# for x in range(n+1):

# sum1 += x

# print(sum1)

b.递归

def yt_sum(n):
# 1.找临界值
if n == 1:
return 1

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

"""
yt_sum(4):
n = 4 4==1 return yt_sum(3)+4 ---> return 1+2+3+4
yt_sum(3):
n = 3 3==1 return yt_sum(2)+3 ---> return 1+2+3
yt_sum(2):
n = 2 2==1 return yt_sum(1)+2 ---> return 1+2
yt_sum(1):
n = 1 1==1 return 1
"""
print(yt_sum(4))
print(yt_sum(100))

练习: 求斐波那契数列第n个数

1, 1, 2, 3, 5, 8, 13....

def sequence(n):
# 1.找临界值
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(5))

"""
4.循环能做的事情不能使用递归做！
"""
sum1 = 0
for x in range(10001):
sum1 += x
print(sum1)

def yt_sum(n):
if n == 1:
return 1
return yt_sum(n-1)+n

print(yt_sum(100))

"""
1.什么是模块
在python中一个py文件就是一个模块
a.系统模块(标准库) - python系统提供的模块（安装解释器的时候已经导入到解释器中了,使用的时候在代码中直接导入）
random模块 - 提供随机数
math模块 - 提供数学运算
json库 - 提供json数据相关操作
re模块 - 提供正则表达式相关操作
socket模块 - 提供python套接字编程
time模块 - 提供和时间相关的操作
threading模块 - 提供和线程相关的操作
...

b.自定义模块 - 程序员自己创建的py文件
自己写的模块
别人写的模块 - 第三方库 (需要先下载到解释器中，然后才能再代码中导入)

标准库和第三库一般是通过模块提供变量、函数、类
***直接导入会直接使用init文件
2.怎么使用模块
import 模块名 - 在程序中直接导入指定的模块, 导入后可以使用模块中所有的全局变量(包含了变量、函数和类)
导入后通过"模块名.变量"来使用模块中的内容

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

from 模块名 import * - 在程序中直接导入指定的模块, 导入后可以使用模块中所有的全局变量(包含了变量、函数和类)
导入后直接使用变量,不用在前面加'模块名.'

3.导入模块的实质:
a.不管是使用import还是from-import，导入模块的时候都会执行模块中所有的代码
b.python中一个模块不会重复导入多次。因为导入的时候系统会自动检查当前模块是否已经导入

4.怎么阻止模块中的内容被其他模块执行
将不希望被其他模块执行的代码放在if语句中
如果希望被其他模块使用的代码就放在if语句的外码
(这儿的if语句指的是: if name == 'main')

原理：
每个模块都有一个name属性, 代表模块名。默认情况下它的值是py文件的文件名。
当当前模块正在被执行(直接执行)的时候,模块属性name的值就会变成'main'
"""

1. 系统模块

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

print('=======import model1之前=======')
import model1
import model1
print('=======import model1之后=======')
model1.a = 1000
print(model1.a)
print(model1.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 model2 import *

导入model2，并且可以直接使用里面所有的全局变量

print('aa:', aa)
print(x)
func2()

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

print(model3.a)

print(model3.b)

"""
5.重命名 - 导入模块的时候可以对模块或者模块中的内容重新命名
import 模块名 as 新模块名
from 模块名 import 变量名1 as 新变量名1, 变量名2, 变量名3 as 新变量名3
"""

import model4 as newMode

print(newMode.age)

import threading as TD
name = 100

from model4 import name as yt_name, age as yt_age

print(name)
print(yt_name)
print(yt_age)

"""
1.什么是迭代器(iter)
是python提供的容器型数据类型。
获取迭代器中的元素的时候只能从前往后一个一个的取,而且取了之后这个元素在迭代器中就不存在了

2.迭代器的字面量
迭代器没有指定格式的字面量。迭代器作为容器，里面的元素只能通过其他序列转换，或者通过生成器生成
迭代器中的元素可以是任何类型的数据
"""

将字符串转换成迭代器，迭代器中的元素就是字符串中的每个字符

iter1 = iter('hello')
print(iter1)

将列表转换成迭代器，迭代器中的元素就是列表中的每个元素

iter2 = iter([100, 'shj', (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

"""
index = 0
x = 10 iter4 = True, 'abc', (1, 2) index = 1 if 1 == 2
x = True iter4 = 'abc', (1, 2) index = 2 if 2==2
"""

item = next(iter4)
print(item)
print(next(iter4))

"""
1.什么是生成器
生成器就是迭代器, 迭代器不一定是生成器。

2.生成器怎么产生元素
调用一个带有yield关键字的函数就能得到一个生成器

不带yield的函数: 调用的时候会执行函数体，并且获取返回值
带yield的函数：调用的时候不会执行函数体，也不会获取返回值，而是产生一个生成器(函数调用表达式就是一个生成器)
这个生成器中的元素就是yield关键字后面的值

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

print(func1()) # 100

def func2():
if False:
yield
print('@@@@@@@')
return 100

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

"""

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

生成器获取元素，实质就是去执行生成器对应的函数， 每次执行到yield语句为止，并且会将yield后面的值作为当次获取到的元素;
下次获取元素的时候会接着上次结束的位置往后执行，直到下一个yield为止....
以此类推，直到函数结束。如果执行到函数结束没有遇到yield那么就会报'StopXXXXX'异常

"""
print('=================')
def func3():
print('~~~~')
yield 'abc', 200
print('！！！！！！！')
yield 100

gen1 = func3() # gen1就是一个生成器(生成器就是迭代器)
print(gen1)
re = next(gen1)
print('打印:', re)
print('第一次结束!')
print(next(gen1))

py18091 py18092 py18093 py18094

def creat_num():
num = 1
while True:
yield 'py1809%d' % num
num += 1

num_gen = creat_num()

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

print(students)
print('上了两天的课')

students.append(next(num_gen))
print(students)

students.pop(9)
print(students)

students.append(next(num_gen))
print(students)

iter1 = iter('1234')

print(next(iter1))

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

iter1 = yt_iter('abc')
print(next(iter1))
print(next(iter1))
print(next(iter1))

print(next(iter1))