第一阶段

Markdown快捷键

快捷键	作用	快捷键	作用
Ctrl+1	一阶标题	Ctrl+B	字体加粗
Ctrl+2	二阶标题	Ctrl+I	字体倾斜
Ctrl+3	三阶标题	Ctrl+U	下划线
Ctrl+4	四阶标题	Ctrl+T	创建表格
Ctrl+5	五阶标题	Ctrl+K	创建超链接
Ctrl+6	六阶标题	Ctrl+F	搜索
Ctrl+L	选中某句话	Ctrl+E	选中相同格式的文字
Ctrl+D	选中某个单词	Ctrl+H	搜索并替换
Ctrl+Home	返回Typora顶部	Ctrl+End	返回Typora底部
Alt+Shift+5	删除线	Ctrl+Shift+I	插入图片
Ctrl+Shift+【	有序列表	Ctrl+Shift+】	无序列表
两个“ `` ”	小代码块

day01

【十进制 < —— >二进制】>>> bin(十进制)

【二进制< —— >十进制 】>>> int(''二进制'' , 2)

一、Python的理解

三种语言

• 低级语言：

第一代计算机语言：机器语言。
          完全由0，1组成，执行效率高，能够直接被机器识别出来。开发效率低，可移植性差，难理解，难以阅读
第二代计算机语言：汇编语言。特定的符号代表特定的指令。理解起来相对容易，开发效率相对提高

• 高级语言：

更接近自然语言，开发效率提高，更好理解、更好阅读，可移植性强 
【C语言(能够直接操作硬件，对性能要求高，对硬件要求高)、
  java(安卓、大数据，大型WEB开发)
  python（web网站、爬虫、数据分析、数据挖掘、机器学习、深度学习、自动化、运维）
】

二、环境：python3.6+ pycharm

环境的安装路径不要用中文
规范：不用中文，少用符号，尽量有意义

day02

一、变量

1.有事找百度，万事找谷歌
2.注释：单行——#，多行——'''  '''。快捷键：ctrl+/
  注意事项：在多行注释中不能嵌套使用
3.变量名  只能是字母开头 + 不能数字开头 + 不能和关键字(33个)冲突 + 尽量不要用中文 【驼峰体：MyPhoto】
4.python 中的数据类型
数字类型：int 整型，float 浮点型
获取数字类型：
        number = 111
        print(type(number))

查看关键字的命令

import keyword
print(keyword.kwlist)

二、字符串

• 字符串的内容可以包含字母、标点、特殊符号、中文、日文等全世界的所有文字，用单或双引号进行括起来，注意是成对使用

• 注意：不要使用不同的引号包围字符串 单包裹双 双包裹单

• 输入时要求换行，输出时要求不换行

• name = "床前明月光"\
      "疑似地上霜"\
      "举头望明月"\
      "低头思故乡"\
  print(name)
  

  输出时要求换行

  name = """
  床前明月光
  疑似地上霜
  举头望明月
  低头思故乡
  """
  print(name)
  

• 字符串格式化

name = "小猪" 
print('%s在吃饭'%name)        #第一种方式
print('{}在吃饭'.format(name))#第二种方式
print(f'{name}在吃饭')        #第三种方式
print('%s在%s'%('木易','吃饭'))#第四种方式
print('%s在%s'%(name,do_something))#第四种方式的格式

字符串下标和切片

下标

所谓“下标”，就是编号，就好比超市中的存储柜的编号，通过这个编号就能找到相应的存储空间

• 编程中的起始位是0

name = 'abcdef'
print(name[0])
print(name[1])
print(name[2])

#字符串的增删改查
string1 = [1,2,3,4]
string2 = ['a','b','c','d']
print(string1 + string2) #字符串的追加
print(string1.__add__(string2))# 将string2以列表的形式插入string1中
print(string1[1])  #打印字符串中的相关位置的值

切片

切片是指对操作的对象截取其中一部分的操作

切片的语法：[起始:结束:步长]

name = 'abcdef'
print(name[0:3])  # 取 下标0~2 的字符
print(name[0:5:1]) # 取下标0~5 的字符，但中间间隔单位长度为1
print(name[0::1])  #默认从下标0到最后，中间间隔单位长度为1

day03

输出

print(我们需要输出的东西)

注释

说明某段代码的作用，意义

方便我们的阅读

方便我们的调试

• 单行注释

  • 从井号#开始，直到这行结束为止的所有内容都是注释。Python 解释器遇到#时，会忽略它后面的整行内容。

  # 这是单行注释
  

• 多行注释

  • 三对英文的引号可以是单引号或者双引号

• 多行注释指的是一次性注释程序中多行的内容（包含一行）

  """
  这是多行注释
  """
  

注意事项：

**不要嵌套**

给一行代码加说明的时候， 放在右边

  给一段代码说明，放在上面

变量

菜篮子 ：临时存储东西

程序就是用来处理数据的，而变量就是用来存储数据的

变量（Variable）可以看成一个小箱子，专门用来“盛装”程序中的数据。每个变量都拥有独一无二的名字，通过变量的名字就能找到变量中的数据。

从底层看，程序中的数据最终都要放到内存（内存条）中，变量其实就是这块内存的名字。

在编程语言中，将数据放入变量的过程叫做赋值（Assignment）。Python 使用等号=作为赋值运算符，具体格式如下：

变量名 = 变量值
name = value

name 表示变量名；
value 表示值，也就是要存储的数据。

如何使用变量

直接用变量名就可以了

注意，变量是标识符的一种，它的名字不能随便起，要遵守 Python 标识符命名规范，还要避免和 Python 内置函数以及 Python 保留字重名。

1. 变量名只能是 字母、数字或下划线的任意组合
2. 变量名的第一个字符不能是数字
3. 关键字不能声明为变量名
   不建议使用中文
   见名知义
4. 查看关键字

import keyword
print(keyword.kwlist)

命名风格：

+ 驼峰体
+ 下划线连接

## 数据类型

我们学习变量是为了让计算机能够像人一样去记忆事物的某种状态，而变量的值就是用来存储事物状态的，很明显事物的状态分成不同种类的（比如人的年龄，身高，职位，工资等等），所以变量值也应该有不同的类型

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）

数字类型

• int整型
  • 整数
• float浮点型
  • 在编程语言中，小数通常以浮点数的形式存储
• 通常每隔三个数字添加一个下划线，类似于英文数字中的逗号。下划线不会影响数字本身的值

查看数据类型

type(你要看的)
number = 111
print(type(number))

字符串类型

字符串是 Python 中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串。

创建字符串很简单，只要为变量分配一个值即可

若干个字符的集合就是一个字符串（String）。Python 中的字符串必须由双引号" "或者单引号' '包围，具体格式为：

"字符串内容"
'字符串内容'

字符串的内容可以包含字母、标点、特殊符号、中文、日文等全世界的所有文字

注意事项：

• 不要使用不同的引号包围字符串 单包裹双 双包裹单
• 对引号进行转义 在引号前面添加反斜杠\就可以对引号进行转义

"""
长字符串
"""

字符串拼接

切片

切片是指对操作的对象截取其中一部分的操作

切片的语法：[起始:结束:步长]

name = 'abcdef'
print(name[0:3])  # 取 下标0~2 的字符

格式化字符串的多种方式

name = '木易'
print('%s在吃饭'%name)
#了解即可
print('{}在吃饭'.format(name))  
print(f'{name}在吃饭')

name = '    abcdefg    '  
print(name.strip())  # 去除左右两边的空格
print(name.lstrip())  # 去除左右左边的空格
print(name.rstrip())  # 去除左右右边的空格

# 转换大小写
print(name.upper())   # 全部转大写
name = 'ABCDEFG'
print(name.lower())   # 全部转小写
name = 'hello world'
print(name.title())  # 将每一个单词的第一个字母变为大写，其他变为小写

file = '老杨.jpg'
print(file.startswith('老杨')) # 判断是不是老杨开始的
print(file.endswith('g'))      # 判断是不是g开始的

布尔类型  只有两个值    注意大小写
True  真  对的
False 假   错的

输入

input(提示信息)

运算符

算术运算符

print(6+5)
print(6-5)
print(6*5)   # 乘法
print(1/1)   # 他的结果永远是小数
print(6//5)  # 整除  取整数部分  取模
print(6**5)  # 幂运算

赋值运算符

• 复合赋值运算符

比较运算符

初学 Python，大家可能对 is 比较陌生，很多人会误将它和 == 的功能混为一谈，但其实 is 与 == 有本质上的区别，完全不是一码事儿。

== 用来比较两个变量的值是否相等，而 is 则用来比对两个变量引用的是否是同一个对象

逻辑运算符

成员运算符

只有in ,not in 两个，用来测试数据中是否包含指定的成员

序列

所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。

为了更形象的认识序列，可以将它看做是一家旅店，那么店中的每个房间就如同序列存储数据的一个个内存空间，每个房间所特有的房间号就相当于索引值。也就是说，通过房间号（索引）我们可以找到这家旅店（序列）中的每个房间（内存空间）。

在 Python中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持以下几种通用的操作，但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

列表【增删改查】

从形式上看，列表会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔

列表中的元素，个数没有限制，只要是 Python 支持的数据类型就可以

列表可以存储整数、小数、字符串、列表元组等任何类型的数据，并且同一个列表中元素的类型也可以不同

• 创建列表
  • 使用[]直接创建列表
  • 使用 list() 函数创建列表
• 删除列表
  • 对于已经创建的列表，如果不再使用，可以使用del关键字将其删除
  • 实际开发中并不经常使用 del 来删除列表，因为 Python 自带的垃圾回收机制会自动销毁无用的列表，即使开发者不手动删除，Python 也会自动将其回收

列表添加元素

实际开发中，经常需要对 Python列表进行更新，包括向列表中添加元素、修改表中元素以及删除元素

• 列表是序列的一种，所以也可以使用+进行连接，这样就相当于在第一个列表的末尾添加了另一个列表
• append() 方法用于在列表的末尾追加元素
• extend() 和 append() 的不同之处在于：extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中
• append() 和 extend() 方法只能在列表末尾插入元素，如果希望在列表中间某个位置插入元素，那么可以使用 insert() 方法

name = ['c++','java','python']
name.append('php')
print(name)

name = ['c++','java','python']
name.extend('php')
print(name)

name = ['c++','java','python']
name.insert(2,'php')
print(name)

列表删除元素的方式

• 根据目标元素所在位置的索引进行删除，可以使用 del 关键字或者 pop() 方法
• 根据元素本身的值进行删除，可使用列表（list类型）提供的 remove() 方法
• 将列表中所有元素全部删除，可使用列表（list类型）提供的 clear() 方法

name = ['c++','java','python']
del name[2]        #对列表中的位置进行删除
name.pop(0)        #对指定下标进行删除
name.remove('c++')  #对指定元素进行删除
name.clear()#清除列表中 的内容
print(name)

列表修改元素的方式

• 修改单个元素
• 修改一组元素

name = ['c++','java','python']
# del name[0]
# name.insert(0,'c--')
name[0] = 'c--'
name[0:2] = [1,2]
print(name)

列表查找元素的方式

• count() 方法用来统计某个元素在列表中出现的次数

• index() 方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致 ValueError 错误，所以在查找之前最好使用 count() 方法判断一下

  print(list)
  count = list.count('P')#统计元素出现的个数
  print(count)
  print(list.index('P')) #查找该元素出现的位置
  

range()快速初始化数字列表

print(list(range(7)))

元祖

元组（tuple）是 Python 中另一个重要的序列结构，和列表类似，元组也是由一系列按特定顺序排序的元素组成

元组和列表（list）的不同之处在于：

• 列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；
• 而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列
• 元组也可以看做是不可变的列表，通常情况下，元组用于保存无需修改的内容

tuple 元组是一个只读版本的 list 列表，元组要比列表更加轻量级，所以从总体上来说，元组的性能速度要由于列表

1. 从形式上看，元组的所有元素都放在一对小括号( )中，相邻元素之间用逗号,分隔
2. 从存储内容上看，元组可以存储整数、实数、字符串、列表、元组等任何类型的数据，并且在同一个元组中，元素的类型可以不同

创建元祖

1. 使用()直接创建

2. 使用tuple()函数创建元祖

   tuple = (1,2,3,4,5)
   print(tuple)
   print(type(tuple))
   

字典

Python 字典（dict）是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储。相对地，列表（list）和元组（tuple）都是有序的序列，字典类型是 Python 中唯一的映射类型。“映射”是数学中的术语，简单理解，它指的是元素之间相互对应的关系，即通过一个元素，可以唯一找到另一个元素。字典中，习惯将各元素对应的索引称为键（key），各个键对应的元素称为值（value），键及其关联的值称为“键值对”

man = {'qiaoqiao':'美女','路太长':'18岁'}
print(man)
print(type(man))
print(man['qiaoqiao'])

字典添加键值对

为字典添加新的键值对很简单，直接给不存在的 key 赋值即可

字典修改键值对

Python 字典中键（key）的名字不能被修改，我们只能修改值（value）

字典中各元素的键必须是唯一的，因此，如果新添加元素的键与已存在元素的键相同，那么键所对应的值就会被新的值替换掉，以此达到修改元素值的目的

#字典 键：值  dict
man = {'c':"学过",'c++':'没学过'}
print(man)
print(man.pop('c'))    #查找键为“c”的值
print(man['c++'])      #同上
print(man.items())  #打印自己的元素
print(type(man))

set集合

Python中的集合，和数学中的集合概念一样，用来保存不重复的元素，即集合中的元素都是唯一的，互不相同。集合是无序的，集合中的元素是唯一的，集合一般用于元组或者列表中的元素去重

从形式上看，和字典类似，Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔

添加元素

set 集合中添加元素，可以使用 set 类型提供的 add() 方法实现

删除元素

删除现有 set 集合中的指定元素，可以使用 remove() 方法

如果我们不想在删除失败时令解释器提示 KeyError 错误，还可以使用 discard() 方法，此方法和 remove() 方法的用法完全相同，唯一的区别就是，当删除集合中元素失败时，此方法不会抛出任何错误

访问集合

由于集合中的元素是无序的，因此无法向列表那样使用下标访问元素。Python 中，访问集合元素最常用的方法是使用循环结构，将集合中的数据逐一读取出来

#集合 set
set = {1,2,3,4}
print(set)
print(type(set))
set.add(5)   #集合中追加元素
print(set)

day04

流程控制

前面我们看到的代码都是顺序执行的，也就是先执行第1条语句，然后是第2条、第3条……一直到最后一条语句，这称为顺序结构。

但是对于很多情况，顺序结构的代码是远远不够的，比如一个程序限制了只能成年人使用，儿童因为年龄不够，没有权限使用。这时候程序就需要做出判断，看用户是否是成年人，并给出提示。

在 Python中，可以使用 if else 语句对条件进行判断，然后根据不同的结果执行不同的代码，这称为选择结构或者分支结构。

• 单分支

  if 表达式:
      代码
  if 3>2:
      print(666)
  

True   1  
False  0

缩进

注意：tab不要和空格混合使用

• 双分支

if 表达式:  
    代码
else:  
    代码
name = input('请输入用户名')
if name == '木易':
    print('登录成功')
else:
    print('登录失败')

多分支

如果 表达式:
    代码
或者如果  表达式：
    代码
或者如果  表达式：
    代码
或者：
    代码
age = int(input('请输入用户名'))
if age == 18:
    print(666)
elif age==28:
    print(777)
elif age == 38:
    print(88)
else:
    print(999)

pass占位符

不起到实际的作用，仅用于占位

a = 3
b = 2
if a>b:
    if a==3:
        print(666)

if a>b and a == 3:
    print(666)

循环结构

while 表达式:
    代码
else:
    代码

a = 0
while a<5:
    print(666)
    a+=1
else:
    print(777)

while循环

a = 0
while a <10:
    a +=1
    pass

break

退出当前循环

for循环

for 循环，它常用于遍历字符串、列表、元组、字典、集合等序列类型，逐个获取序列中的各个元素

for 迭代变量 in 字符串|列表|元组|字典|集合：
    代码块

迭代变量用于存放从序列类型变量中读取出来的元素，所以一般不会在循环中对迭代变量手动赋值；代码块指的是具有相同缩进格式的多行代码（和 while 一样），由于和循环结构联用，因此代码块又称为循环体

a = [1,2,3,4,5,6]
b = '桥桥是班花'
c = {'name':'木易','age':18}
for i in c:
    print(c[i])
for i,j in c.items():
    print(j)


for x in range(10):
    print(666)

无论是 while 循环还是 for 循环，其后都可以紧跟着一个 else 代码块，它的作用是当循环条件为 False 跳出循环时，程序会最先执行 else 代码块中的代码

跳出循环

在执行 while 循环或者 for 循环时，只要循环条件满足，程序将会一直执行循环体，不停地转圈。但在某些场景，我们可能希望在循环结束前就强制结束循环,Python提供了 2 种强制离开当前循环体的办法

• 使用 continue 语句，可以跳过执行本次循环体中剩余的代码，转而执行下一次的循环
• 只用 break 语句，可以完全终止当前循环

random模块

可以产生指定范围的随机数，字符串等

import random   # 导入模块
a = random.choice('ABCDEFG')  # 参数也可以是一个列表
s = 'ABCDEFG'
b = random.sample(s,3)   # 从数据源中随机抽取3个值
c = random.randint(50,100) # 打印随机数
print(a)  #随机打印一个字母
print(b)
print(c)

string 字符串

import string  # 导入模块
a = string.ascii_letters    # 所有字母
b = string.ascii_uppercase  # 大写字母
c = string.ascii_lowercase  # 小写字母
d = string.punctuation      # 特殊字符
e = string.digits           # 数字
print(a)
print(b)
print(c)
print(d)
print(e)

python推导式

#循环体for  推导式
for x in range(10):
    print(x)

# 列表推导式，利用range区间、元组、列表、字典、和集合等数据类型，快速生成一个满足要求的列表
# [表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]]
a = [x for x in range(9)]
print(a)

day05

字符和编码

字符串类型、文本文件的内容都是由字符组成的，但凡涉及到字符的存取，都需要考虑字符编码的问题。

人类在与计算机交互时，用的都是人类能读懂的字符，如中文字符、英文字符、日文字符等

而计算机只能识别二进制数，毫无疑问，由人类的字符到计算机中的数字，必须经历一个过程

翻译的过程必须参照一个特定的标准，该标准称之为字符编码表，该表上存放的就是字符与数字一一对应的关系。

字符编码中的编码指的是翻译或者转换的意思，即将人能理解的字符翻译成计算机能识别的数字

字符编码的发展经历了三个重要的阶段

1.一家独大

现代计算机起源于美国，所以最先考虑仅仅是让计算机识别英文字符，于是诞生了ASCII表

阶段二：诸侯割据、天下大乱

为了让计算机能够识别中文和英文，中国人定制了GBK，每个国家都各自的字符，为让计算机能够识别自己国家的字符外加英文字符，各个国家都制定了自己的字符编码表，此时,美国人用的计算机里使用字符编码标准是ASCII、中国人用的计算机里使用字符编码标准是GBK、日本人用的计算机里使用字符编码标准是Shift_JIS

阶段三：分久必合

unicode于1990年开始研发，1994年正式公布，具备两大特点：

#1. 存在所有语言中的所有字符与数字的一一对应关系,即兼容万国字符

#2. 与传统的字符编码的二进制数都有对应关系

文件操作

使用文件的目的：

就是把一些存储存放起来，可以让程序下一次执行的时候直接使用，而不必重新制作一份，省时省力

应用程序运行过程中产生的数据最先都是存放于内存中的，若想永久保存下来，必须要保存于硬盘中。应用程序若想操作硬件必须通过操作系统，而文件就是操作系统提供给应用程序来操作硬盘的虚拟概念，用户或应用程序对文件的操作，就是向操作系统发起调用，然后由操作系统完成对硬盘的具体操作。

在python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件

open(文件名，访问模式)

示例如下：

    f = open('test.txt', 'w','utf-8')

关闭文件 close()

写数据 write()

读数据 read()

对文件的操作

1. 打开文件
    open(文件名，打开的模式，[可选：编码格式])
    选择要操作的文件是什么
    操作的模式       r  w  a  文本类型
    二进制包含文本类型  rb wb ab  二进制文件   图片  音频  视频
    r read 读取，读取的前提是需要有这份文件

    -  有这份文件，就更改文件内容
    -   没有这份文件，就创建这份文件
      -  w write 创建写 覆盖写，如果没有文件，会覆盖原有的再创建
      -  a append 追加写，不会覆盖原有的内容，在后面加入内容，没有就创建

        2. 操作文件

    - write
    - read
      -     readlines  打印所有行
      -     readline  打印一行
      -     键盘敲烂，月薪过万

        3. 关闭文件

# 文件的操作
f =open('作业.txt','r',encoding='utf-8') #打开文件全名，加后缀名，只有文本类型的需要加编码模式
data = f.read()  #打开模式：读read，写write，追加写append，覆盖写w
f.close()  #关闭文件
print(data)

# 复制
'''f1 = open('2.jpg','rb')
data = f.read()
f1.close()'''

# 将内容写入
f1 = open('2.jpg','wb')
f.write(data)
f.close()

'''练习1
f2 = open('index.txt','w',encoding='utf-8')
f2.write('写入的内容')
f2.close()
'''
'''练习2
需求：输入文件的名字，然后程序自动完成对文件进行备份
读取文件的内容
将内容写成文件
思路 
file_name = input('请输入文件的名字')
oldfile = open(file_name,'rb')
data = oldfile.read()
oldfile.close()
newfile = open('备份.txt','wb')
newfile.write(data)
newfile.close()
'''
提取文件的后缀名，
# rfind：返回字符串最后一次出现的位置(从右向左查询)。如果没有匹配项则返回-1

简化写法

第一种方法，可能会忘记关闭文件

f = open('作业.txt','w+',encoding='utf-8')
f.write('1234567')
f.close()

简化后如下：自动关闭

with open('作业.txt','w+',encoding='utf-8') as f:
    f.write('123456')

文件夹的操作：

file_name = input('请输入文件名')
f = open(file_name,'r',encoding='utf-8')
data = f.read()
data1 = f.readlines()
data2 = f.readline()
f.close()
f = open('备份','w',encoding='utf-8')
f.write(data)
f.close()

day06

函数

什么是函数
为什么要用函数

以前的代码缺点：冗余，可读性很差，维护性太差
Python 提供了一个功能，即允许我们将常用的代码以固定的格式封装（包装）成一个独立的模块，
只要知道这个模块的名字就可以重复使用它，这个模块就叫做函数（Function）。

比如，在程序中定义了一段代码，这段代码用于实现一个特定的功能。
问题来了，如果下次需要实现同样的功能，难道要把前面定义的代码复制一次？
如果这样做实在太傻了，这意味着每次当程序需要实现该功能时，都要将前面定义的代码复制一次。
正确的做法是，将实现特定功能的代码定义成一个函数，
每次当程序需要实现该功能时，只要执行（调用）该函数即可。

其实，函数的本质就是一段有特定功能、可以重复使用的代码，
这段代码已经被提前编写好了，并且为其起一个“好听”的名字。
在后续编写程序过程中，如果需要同样的功能，直接通过起好的名字就可以调用这段代码

写代码 ：不要重复造轮子
    同样的代码  考虑封装
    用循环   用函数

内置函数：

print   input   int  str   type

自定义函数

函数语法

def 函数名(参数1,参数2,...):
    """文档描述"""
    函数体
    return 值
调用函数：
    函数名()

函数的使用分为定义阶段与调用阶段，定义函数时只检测语法，看是否有语法错误SyntaxError
不执行函数体代码，函数名加括号即函数调用，只有调用函数时才会执行函数体代码

调用函数也就是执行函数。
如果把创建的函数理解为一个具有某种用途的工具，那么调用函数就相当于使用该工具。
调用函数很简单的，通过 函数名(参数) 即可完成调用

函数的说明
help(函数名)
print(函数名.doc)

函数的参数

形参和实参
形参：在定义函数时，函数名后面括号中的参数就是形式参数，简称形参，
形参的值是不确定的，只是用来占位
实参：在调用函数时，函数名后面括号中的参数称为实际参数，也就是函数的调用者给函数的参数
真正参与运算
实参和形参的区别，就如同剧本选主角，剧本中的角色相当于形参，而演角色的演员就相当于实参

形参和实参的关系：
1.在调用阶段，实参(变量值)会绑定给形参(变量名)
2.这种绑定关系只能在函数体内使用
3.实参和形参的绑定关系在函数调用时生效，函数调用结束后解除绑定关系
实参是传入的值，但值可以是以下形式
形式一：
func(1,2)
形式二：
a= 1
b = 2
func(a,b)
形式三：
func(int('1'),2)

函数的返回值
函数一旦遇到return 就不往下面执行了
返回值就是函数执行的结果，并不是所有的函数都必须要有返回值，开发中根据需求去定到底是否需要返回值
通常情况下，一个函数只有一个返回值，实际上 Python 也是如此，
只不过 Python 函数能以返回列表或者元组的方式，将要返回的多个值保存到序列中，
从而间接实现返回多个值的目的。

因此，实现 Python 函数返回多个值，有以下 2 种方式：
    1. 在函数中，提前将要返回的多个值存储到一个列表或元组中，然后函数返回该列表或元组；
    2. 函数直接返回多个值，之间用逗号（ , ）分隔，Python 会自动将多个值封装到一个元组中，
    其返回值仍是一个元组

函数遇到return就返回，不会继续往下运行，默认返回None
如果一个函数没有返回值，则表示返回None

def lao():
    print('从前有座道馆')
    print('山里有座庙')
    print('庙里有个老和尚')
    print('老和尚对小和尚说')
    print('山下的女人是老虎')

age  = int(input('请输入年龄'))
if age<5:
    for  x  in range(10):
        lao()
elif 5<age<10:
    for x in range(3):
        lao()

命名规范：

1. 只能是字母，数字，下划线
2. 不能数字开始
3. 不能和关键字冲突
尽量不要用中文   驼峰法  下划线连接法
顾名思义

def 函数名(): 标识符 命名规范 变量
函数体
如何调用：
函数名()

函数在定义的时候做的事情：检测语法
调用函数：函数名()

函数名 ： 要执行的函数里面的代码的内存地址
内存地址()
怎么看内存地址 id() 方便我么

最基本的定义 调用
有一定的编程基础

"""

# def index():
# """
# 自动生成的
# :return:
# """
# for a in range(5):
# print('*'*(5-a))
# index()
# print(id(index))  #  查看index 的内存地址
# 2434115317544()  不可以
# 文档描述   函数的注释  方便我们知道这个函数到底是干嘛用的
# help(index)
# print(index.__doc__)
# 需求：一个函数 用来打印两个数的相乘的结果
# 需要得到他的结果是什么？
# def index(a,b):
# c = a*b
# print(c)
# return 30
# print(11)
# print(22)
#
# a = index(4,5)
# print(a)

函数 一旦看到个return 返回

函数 工厂：做事情 参数：原材料 返回值 服装成品 return

服装工厂 在使用的时候传给他的 可以返回 也可以不返回

当你自己没有return 返回的时候 Python会默认给你返回 None 空值 空

位置参数

按照顺序来，多一个，少一个都不行 依次进行

位置参数，有时也称必备参数，指的是必须按照正确的顺序将实际参数传到函数中，
换句话说，调用函数时传入实际参数的数量和位置都必须和定义函数时保持一致
实参和形参数量必须一致
在调用函数，指定的实际参数的数量，必须和形式参数的数量一致（传多传少都不行），
否则 解释器会抛出 TypeError 异常，并提示缺少必要的位置参数

关键字参数

可以不用按照顺序来 可以指定顺序 指哪打拿

关键字参数是指使用形式参数的名字来确定输入的参数值。通过此方式指定函数实参时，
不再需要与形参的位置完全一致，只要将参数名写正确即可
默认参数
在调用函数时如果不指定某个参数，解释器会抛出异常。
为了解决这个问题，Python 允许为参数设置默认值，即在定义函数时，直接给形式参数指定一个默认值。
这样的话即便调用函数时没有给拥有默认值的形参传递参数，该参数可以直接使用定义函数时设置的默认值

默认参数

不指定的时候就按照默认的值来进行 指定一个默认值

顺序问题：

    位置参数  关键字参数   默认参数

可变参数

    *args
    *args 表示创建一个名为 args 的空元组，该元组可接受任意多个外界传入的非关键字实参
    **kwargs
    **kwargs 表示创建一个名为 kwargs 的空字典，该字典可以接收任意多个以关键字参数赋值的实际参数

def index(a,b,c,*d):
    print(a,b,c)
index(1,c=9,b=6)


def index(*args,**kwargs):
    print(args)
    print(kwargs)
list1 =[1,2,3,34,5]
index(a = 1,b =2)
index(list1)
dict1 = {'a':10,'b':20}
index(*dict1)

函数的返回值
函数一旦遇到return 就不往下面执行了
返回值就是函数执行的结果，并不是所有的函数都必须要有返回值，开发中根据需求去定到底是否需要返回值
通常情况下，一个函数只有一个返回值，实际上 Python 也是如此，
只不过 Python 函数能以返回列表或者元组的方式，将要返回的多个值保存到序列中，
从而间接实现返回多个值的目的。

因此，实现 Python 函数返回多个值，有以下 2 种方式：
    1. 在函数中，提前将要返回的多个值存储到一个列表或元组中，然后函数返回该列表或元组；
    2. 函数直接返回多个值，之间用逗号（ , ）分隔，Python 会自动将多个值封装到一个元组中，
    其返回值仍是一个元组

函数遇到return就返回，不会继续往下运行，默认返回None
如果一个函数没有返回值，则表示返回None

命名空间(Namespace)是从名称到对象的映射，大部分的命名空间都是通过 Python 字典来实现的。
命名空间提供了在项目中避免名字冲突的一种方法。各个命名空间是独立的，没有任何关系的，所以一个命名空间中不能有重名，但不同的命名空间是可以重名而没有任何影响。
我们举一个计算机系统中的例子，一个文件夹(目录)中可以包含多个文件夹，每个文件夹中不能有相同的文件名，但不同文件夹中的文件可以重名。

作用域：
内建名称空间
伴随python解释器的启动/关闭而产生/回收，因而是第一个被加载的名称空间，用来存放一些内置的名字，比如内建函数名
全局名称空间
伴随python文件的开始执行/执行完毕而产生/回收，是第二个被加载的名称空间，文件执行过程中产生的名字都会存放于该名称空间中
局部名称空间
伴随函数的调用/结束而临时产生/回收，函数的形参、函数内定义的名字都会被存放于该名称空间中
名称空间的加载顺序是：内置名称空间->全局名称空间->局部名称空间，而查找一个名字，必须从三个名称空间之一找到，查找顺序为：局部名称空间->全局名称空间->内置名称空间

作用域
就是变量的有效范围，就是变量可以在哪个范围以内使用。
有些变量可以在整段代码的任意位置使用，有些变量只能在函数内部使用，
有些变量只能在 for 循环内部使用。变量的作用域由变量的定义位置决定，
在不同位置定义的变量，它的作用域是不一样的

局部变量

在函数内部定义的变量，它的作用域也仅限于函数内部，出了函数就不能使用了，
我们将这样的变量称为局部变量

要知道，当函数被执行时，Python 会为其分配一块临时的存储空间，
所有在函数内部定义的变量，都会存储在这块空间中。
而在函数执行完毕后，这块临时存储空间随即会被释放并回收，
该空间中存储的变量自然也就无法再被使用。函数的参数也属于局部变量，只能在函数内部使用

全局变量

    除了在函数内部定义变量，Python 还允许在所有函数的外部定义变量，
    这样的变量称为全局变量

    和局部变量不同，全局变量的默认作用域是整个程序，
    即全局变量既可以在各个函数的外部使用，也可以在各函数内部使用

要在函数内修改全局名称空间中名字的值，则需要用到global关键字

注意：
函数名重名，会覆盖
函数名可以当成变量名

def index(a,b=5):
    print('a 是 %s'%a)
    print('b 是 %s'%b)
    print(a*b)
    c = a*b
    return  c

    return 1,2,3
    return a*b

name = 7
age = 77
a,b,c = index(a=name,b=age)
print(a,b,c)

函数名：要执行的函数里面的代码内存地址

例：
def foo():
    print(666)
foo()

查看内存地址

a = 1
print(id(a))
def foo():
    print(666)
print(id(foo))

day08

函数的说明
    help(函数名)
    print(函数名.__doc__)

匿名函数

用来表达一个简单的函数，函数调用的次数很少，基本上就是调用一次
用lambda关键字能创建匿名函数，这种函数省略了用def 声明函数的标准步骤
lambda 参数列表:表达式
1.给它定义一个名字(使用的少)

   index = lambda a,b:a+b
   print(index(2,3))

 2.把这个函数当做参数传给另一个函数使用

调用匿名函数
# 方式一：
res = (lambda x,y:x+y)(1,2)
print(res)

# 方式二：
func = lambda x,y:x+y
res = func(1,2)
print(res)

# 匿名函数用于临时调用一次的场景：更多的是将匿名与其他函数配合使用

高阶函数

1、一个函数作为另一个函数的参数

def index(a):
    print('index')
    print(a)
def foo(a):
    print('foo')
    a(1)
foo(index)

2、一个函数作为另一个函数的返回值

def index():
    print('index')
def foo():
    print('foo')
    return index   #不加括号，只写函数名
a = foo()
a()

3、 一个函数内部在定义一个函数

闭包

如果在一个内部函数里，对在外部作用域(但不是全局作用域)的变量进行引用
那么内部函数就被认为是闭包

嵌套函数，内部函数调用外部函数的变量

def outer():
    x = 1
    def inner():
        y = x
    return inner

修改外部作用域的变量

   def outer():
        x = 10
        def inner():
            nonlocal x     #相当于一个global x,将局部变量升级为全局变量
            x +=1
            print(x)
        return inner
    outer()()

函数的递归调用：

是函数嵌套调用的一种特殊形式
具体是指，在调用一个函数的过程中又直接或者间接的调用到本身

递归函数：就是函数内部自己调用自己
递归最重要的就是找到出口(停止的条件)
递归最大的层级是1000层

import sys
    # 查看层级
    sys.getrecursionlimit()
    # 设置层级
    sys.setrecursionlimit()
    index = [1,[2,[3,[4]]]]
def foo(list1):
    for x in list1:
        if type(x) == list:
            foo(x)
        else:
            print(x)
foo(index)