01recode

1. 函数的声明

def 函数名（参数列表）：
    函数体

lambda 参数列表：返回值

（重点！）函数声明的时候函数体不会执行！

2. 函数调用

函数名（） <--> 变量（） - 要求变量中存储的地址对应的值是function

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

3. 函数的参数

位置参数和关键字参数
参数默认值
参数类型说明
不定长参数

4. 返回值

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

5. 全局变量和局部变量

6. 函数作为变量：声明函数就是声明一个类型是function的变量，函数名就是变量名

def func1():
    return 10

a = 10
# func1和a是一样的，都是变量

# lambda x: x 和 10 是一样的，都是值
num = 10
list1 = [10]

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

func2(10)
list2[0]('abc')


# *num 在函数作为函数参数的过程中的使用方法
def my_sums(*num):
    sum1 = 0
    for x in num:
        sum1 += x
    return sum1

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

print(my_sums(1, 2, 3, 4, 5, 6))
print(my_product(2, 4, 6))

def operation(char: str, *nums):
    # char = '+',
    if char == '+':
        return my_sums(*nums)
    else:
        return my_product(*nums)

print(operation('+', 1, 3, 4, 5))
print(operation('*', 3, 4, 2, 3))

02 recursionFunction

（了解！）

实际开发的时候，能不用递归就不用

1. 什么是递归函数

函数中调用函数本身的函数就是递归函数

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

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

a = 0

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


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 my_sum(n):
    # 1. 找临界值
    if n == 1:
        return 1

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

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

练习：求斐波那契数列第n个数
1， 1， 2， 3， 5， 8， 13...

def series(n):
    # 1. 找临界值
    if n == 1 or n == 2:
        return 1

    # 2. f(n)和f(n-1)的关系
    return series(n-1) + series(n-2)


print(series(5))

4. 循环能做的事情不能使用递归做！

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


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

03module

因为在本总结中没有写上任何模块，所有本版块内容中的module需要重新在pycharm中建立才能使用。

1. 什么是模块

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

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

标准库和第三方库一般通过模块提供变量、函数、类

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 module1之前===')
import module1
import module1
print('===import module1之后===')
module1.a = 3000
print(module1.a)
print(module1.func1())


from module2 import aa, x

print('aa:', aa)
# print(module2.func2())    # 不能使用module2中除了aa和x的内容， 并且格式错误！


# 导入module2，并且可以直接使用里面所有的全局变量,通配符*
from module2 import *
print(aa)
print(x)
func2()

print('=========import module3===========')
import module3
# print(module3.a)
# print(module3.b)

5. 重命名 - 导入模块的时候可以对模块或者模块中的内容重新命名

import 模块名 as 新模块名
from 模块名 import 变量名1 as 新变量名1, 变量名2， 变量名3 as 新变量名3

import module4 as newModule
print(newModule.age)

import threading as TD
name = 100

from module4 import name as my_name, age as my_age
print(name)
print(my_name)
print(my_age)

04iterator

1. 什么是迭代器（iter）

是python提供的容器型数据类型。
获取迭代器中元素的时候只能从前往后一个一个的取，而且取了之后这个元素在迭代器中就不存在了

2. 迭代器的字面量

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

将字符串转换成迭代器，迭代器中的元素就是字符串中的每个字符
iter1 = iter('hello')
print(iter1)

将列表转换成迭代器，迭代器中的元素就是列表中的每个元素
iter2 = iter([100, 'and', (12, 20), [1, 2], True, {'name': '小花'}, lambda x: x])
print(iter2)

3. 获取元素

（迭代器中的元素只支持查，不支持增删改）
迭代器只能通过next函数获取单个元素，for-in遍历一个一个获取每一个元素。
不管哪种方式获取，已经获取过的元素在迭代器中就不存在

iter3 = iter('hello')

1. next
"""
next(迭代器) -> 获取迭代器中最新的数据（最顶层）
"""

print(next(iter3))
print(next(iter3))
print(next(iter3))
print(next(iter3))
print(next(iter3))
# print(next(iter3))    # 报 'StopIteration'异常，因为迭代器中的数据已经取完了
取完之后，iter3还在，只是里面为空

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

通过for-in取迭代器中的元素和next效果一样，元素还是会从迭代器中取出
for x in iter3:
    print('x:', x)

练习：看打印结果

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

05generator

1. 什么是生成器

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

2. 生成器怎么产生元素

调用一个带有yield关键字的函数就能得到一个生成器

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

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


print(func1())    # 100

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

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

3. 生成器的元素

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

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

print('============border=============')
def func3():
    print('$$$$$$$$$$$$$$$$$$$')
    yield 100, 200, 300
    print('!!!!!!!!!!!!!!!!!!!!')
    yield 'abc'

gen1 = func3()  # gen1就是一个生成器（生成器就是一个迭代器）
print(gen1)
re = next(gen1)
print('打印：', re)
print(next(gen1))


# py18091  py18092  py18093
def create_num():
    num = 1
    while True:
        yield 'py1809%d' % num
        num += 1


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

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

students.pop(4)
print(students)

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


# iter() 迭代器原理
def my_iter(seq):
    for x in seq:
        yield x


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