Python入门第一天——[小甲鱼]零基础入门学习Python

本文链接：https://blog.csdn.net/qq_42263553/article/details/103439683

1.优点：

跨平台：

Linux
Windows
Mac OS

应用范围

操作系统
WEB
3D动画
云计算

学到什么

Python3的所有常用语法
面向对象
运用模块进行编程
游戏编程
计算机仿真

安装Python

https://www.python.org/downloads/release/python-380/

从IDLE启动Python

输出语句

在这里插入图片描述

计算：

在这里插入图片描述

字符串拼接

在这里插入图片描述

字符串乘法

在这里插入图片描述

字符串加法

在这里插入图片描述

002设计第一个小游戏

点file，new一个新窗口

在这里插入图片描述

语法注意点

没有和之前学过的语言一样，Python不需要变量声明，而且在一些语句里不需要写大括号，只需要写缩进，if语句形式看清楚

在这里插入图片描述

input函数是Python的一个BIF是内置函数的意思。input函数的参数是需要打印的值，input返回的是一个字符串类型的变量，然后我们需要通过int函数转为整形。
BIF：内置函数
- dir(builtins):查看Python内置函数BIF的列表。
- help(BIF名称):用于显示BIF的功能描述。

003变量和字符串

Python没有变量，只有名字
- 使用变量之前需要进行赋值
用python创建字符串时，需要在字符串两边加上引号，可以是单引号或者双引号
- 如果字符串里出现单引号里有单引号怎么办？
  - 可以把外层单引号变成双引号
  - 可以用转义\字符进行
原始字符串
- 当我们需要输入路径的时候，里面会有反斜杠跟字母，可能就出现不同的字符了
  - 可以用两根反斜杠解决
- 但如果一个路径有很多反斜杠呢？
  - 可以两根反斜杠解决
  - 用原始字符串：在字符串前面加一个r
如果希望得到一个跨越多行的字符串，例如

hello

helloworld

hellohelloworldworld
- 这时候我们就可以使用到三重引号字符串

>>> teacher = '小甲鱼'
>>> print(teacher)
小甲鱼
>>> teacher = '老甲鱼'
>>> print(teacher)
老甲鱼
>>> first = 3
>>> second = 8
>>> third = first + second
>>> print(third)
11
>>> myteacher = '小甲鱼'
>>> youteacher = '黑夜'
>>> ourteacher = myteacher + youteacher
>>> print(ourteacher)
小甲鱼黑夜
>>> 5+8
13
>>> '5'+'8'
'58'
>>> "Let's go!"
"Let's go!"
>>> 'Let\'s go!'
"Let's go!"
>>> str="""hello

helloworld

hellohelloworldworld
"""
>>> print(str)
hello

helloworld

hellohelloworldworld

004改进我们的游戏

1.用户输入的数与正确答案进行比较，如果大了或小了都要进行提示。
- 比较操作符：<,<=,>,>=,==,!=
  - ```
  >>> 1==1
  True
  >>> 1<=2
  True
  >>> 1>=3
  False
  >>> 1!=1
  False
```
- 条件分枝语法
  - if语句：和之前语言的差不多，形式发生了一点点变化而已
```
if 条件 :
    条件为true才执行这里语句
else:
    条件为false执行的
```
  - else if语句要分开写，先写else，再在else里嵌套if
    
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MZ23A6ff-1575724188328)(C:\Users\JinWei\AppData\Roaming\Typora\typora-user-images\1575680398041.png)]
第二个改进要求：程序应该多次提供机会给用户猜测，也就是循环执行
- while循环：他的形式也和之前语言也差不多：
  - ```
  while 条件:
      条件为true才执行的语句
```
- and逻辑操作符，可以将任意表达式连接在一起并得到一个布尔类型的值
  - ```
  >>> (5>3) and (3<5)
  True
```
第三个改进的要求：每次运行程序产生的答案是随机的。
- random模块：在其他语言中他是一个方法，我们调用这个方法就可以获得一个随机数，他在python里是一个模块，它里面有个randint()函数，他会返回一个随机的整数。
  - randint()函数：参数是两个整形变量，第一个参数是整形开始的值，第二个参数是end值
  - 通过random.randint(start,end)进行调用

005Python的数据类型

到现在为止知道的类型：

整形
- ```
>>> a='520'
>>> b = int(a)
>>> b
520
```
字符串(str方法能将其他数据类型转换为字符串类型)
- ```
>>> a=5.99
>>> b=str(a)
>>> b
'5.99'
```

浮点

>>> a='520'
>>> b = float(a)
>>> b
520.0

布尔：他实际也就是数字0和1
- ```
>>> True + False
1
>>> True+ True
2
```

e记法：也就是科学计数法

>>> 150000000000
150000000000
>>> 1.5e11
150000000000.0

获取变量的类型
- 使用type()方法可以直接获得变量的类型
- 但是官方更加建议我们用isinstance()方法，因为他返回的是一个布尔类型的值，这样我们就可以拿他做健壮性判断
- ```
>>> type(a)
<class 'float'>
>>> type(b)
<class 'str'>

>>> isinstance(a,str)
False
>>> isinstance(a,int)
False
>>> isinstance(a,float)
True
```

006Python之常用操作符

算数操作符

+，-，*， /，%，**，//
大部分和之前的一样

不同的是：

a = b = c = d = 10
a += 1	 结果是10+1 = 11
b -= 1	 结果是10 - 1 = 9
c *= 10  结果是10*10 = 100
d /= 8   结果是10/8 = 1.25

使用单个除号的话，整形类型变量的除法会得到一个浮点型数据
使用两个除号的话，整形类型变量的除法就是和之前一样是一个整数
```
d=10
d//8   结果是10//8 = 1
```
使用两个乘号就是幂运算！
```
a=3
a**2 结果是a的平方 = 9
```

操作符优先级

其他的和C语言优先级差不多
幂运算优先级：比左边优先级低，右边优先级高

-3 ** 2 结果是-9 因为他是先算幂再加负号，平时进行加减乘除运算时负号优先级是最高的。
3 ** -2 结果是0.11111111111  也就是三的负二次方，右边优先级高

逻辑操作符
- and，在C语言中是逻辑与&&
- or，在C中是逻辑或||
- not，在C语言中是取反的作用！
  - ```
  >>> not False
  True
  也就是说False取反之后就是True
```
优先级

007₀₀₈009了不起的分支和循环

if和else的嵌套都是以缩进符来判别的。
三元操作符
- 语法：
  
  a = x if 条件 else y
  
  解释一下就是说如果if条件满足，就让a=x，否则a=y
断言（assert）
- 语法：
  
  assert 布尔
  
  当这个关键字后边的条件为假的时候，程序就自动奔溃并抛出AssertionError的异常
- 举例：
  
  assert 3>4
```
>>> assert 3<4
>>> assert 3>4
Traceback (most recent call last):
  File "<pyshell#11>", line 1, in <module>
    assert 3>4
AssertionError
```
- 作用：一般来说我们可以用断言再程序中置入检查点，当需要确保程序中的某个条件为真时才让程序工作的话，断言assert关键字就非常有用了
while循环
- 条件为真就执行
- 形式：
  
  while 条件：
  
  循环体
for循环
- 他和C语言的for循环不大一样，他就像java里的foreach，内部会自动调用迭代器的next方法。
- 语法：
  
  for 目标 in 表达式：
  
  循环体
  
  前者是迭代容器的元素，后者是需要迭代的容器
- 举例
  - ```
  >>> member = ['小甲鱼','老甲鱼','黑夜','迷途','怡静']
  >>> for each in member:
  	print(each,len(each))
  
  	
  小甲鱼 3
  老甲鱼 3
  黑夜 2
  迷途 2
  怡静 2
```
range（）
- 他是一个BIF，内建函数。作用是生成一个从start参数的值开始，到stop参数的值结束的数字序列。
- 这个BIF有三个参数，第一个参数是迭代的开始位置，第二个参数是迭代的结束位置(不包含)，第三个参数是步长
- 举例
  - ```
  >>> for i in range(2,9):
  	print(i)
  
  	
  2
  3
  4
  5
  6
  7
  8
```
break和continue
- break若用在循环中，就直接跳出这个最大的while，然后往下执行
- continue用在循环中，就执行到了continue就又从程序开始执行一遍

010₀₁₁012列表：一个打了激素的数组

数组我们知道他是把同种类型的数据都放在一起，用下标进行索引。
Python中的列表，可以把各种类型的数据都放进去，可以存列表，对象也可以存。

创建列表

跟创建变量差不多，用中括号括起来，用逗号隔开就可以

举例

>>> member
['小甲鱼', '老甲鱼', '黑夜', '迷途', '怡静']

>>> mix = [1,'小甲鱼',3.14,False,[1,2,3]]
>>> mix
[1, '小甲鱼', 3.14, False, [1, 2, 3]]

创建一个空列表
- 举例
  - ```
  >>> empty = []
```

往列表中添加单个元素（append方法是列表对象的方法）

举例

>>> member.append('nihao')
>>> member
['小甲鱼', '老甲鱼', '黑夜', '迷途', '怡静', 'nihao']
>>> len(member)
6

往列表中添加多个元素（extend方法，有两个参数，但得用列表括起来）

举例

>>> member.extend(['hello','world'])
>>> member
['小甲鱼', '老甲鱼', '黑夜', '迷途', '怡静', 'nihao', 'hello', 'world']

往列表中插入一个元素（inset方法，第一个参数是要插入的位置，第二个参数是要插入的数据）

举例

>>> member.insert(0,'aaaa')
>>> member
['aaaa', '小甲鱼', '老甲鱼', '黑夜', '迷途', '怡静', 'nihao', 'hello', 'world']
>>>

从列表中获取元素

举例

>>> member[0]
'aaaa'
>>> temp = member[3]
>>> temp

从列表中删除元素（remove方法，参数就是要删除的元素值）

举例

>>> member.remove('nihao')
>>> member
['aaaa', '小甲鱼', '老甲鱼', '黑夜', '迷途', '怡静', 'hello', 'world']
>>>

从列表中删除元素（通过del语句）

举例

>>> member[1]
'小甲鱼'
>>> del member[1]
>>> member
['aaaa', '老甲鱼', '黑夜', '迷途', '怡静', 'hello', 'world']
>>>

del语句还可以删除列表，直接在del语句后加上列表名

从列表中删除元素（使用pop方法弹出列表的元素，弹出也就是显示给你看然后删除）
- 不加参数默认是列表中的最后一个元素，参数加上就是弹出列表中指定序号的元素
- 举例
  - ```
  >>> member.pop()
  'hello'
  >>> member.pop(1)
  '老甲鱼'
  >>> member
  ['aaaa', '黑夜', '迷途', '怡静']
  >>> 
```
从列表中分片（可以从列表中获取多个值）
- 语法：
  
  列表名[start位置,end位置]
  
  start位置和end位置不填默认就是最开始和最后的位置
- 举例
  - ```
  >>> member[1:3]
  ['黑夜', '迷途']
  >>> member[:3]
  ['aaaa', '黑夜', '迷途']
  >>> member[:]
  ['aaaa', '黑夜', '迷途', '怡静']
```
- 他的作用就是可以用于列表的拷贝，有时候我们只想要列表中间的几个元素，就可以这么进行分片然后赋值。
  - ```
  >>> member2 = member[1:3]
  >>> member2
  ['黑夜', '迷途']
```

列表的操作符

比较操作符

列表的比较

>>> list1 = [123]
>>> list2 = [456]
>>> list1>list2
False

如果有多个元素，默认从第0个元素进行比较
>>> list1=[123,456]
>>> list2=[456,123]
>>> list1>list2
False
>>>

逻辑操作符

>>> (list1 <list2) and(list1 == list3)
True

连接操作符（用加号可以进行连接，但是最好还是通过方法进行连接）
- ```
>>> list4 = list1+list2
>>> list4
[123, 456, 456, 123]
```
重复操作符（乘号如果和类似列表的东西在一起运算就会变成一个重复操作符）
- ```
>>> list3
[123, 456]
>>> list3 *3
[123, 456, 123, 456, 123, 456]
```

成员关系操作符**（in和not in就是成员操作符）**

>>> 123 in list1
True
>>> 123 not in list1
False

>>> list5 = [123,['小甲鱼','牡丹'],456]
>>> '小甲鱼' in list5
False

访问列表中的列表的值，就像访问数组一样
>>> '小甲鱼' in list5[1]
True
>>> '小甲鱼' in list5[1][0]
True

列表的其他方法
- 使用dir(list)进行查看
- count方法
  - 计算count方法的参数在列表中出现的次数
  - ```
  >>> list3
  [123, 456]
  >>> list3.count(123)
  1
```
- index方法（可以带一个参数或多个参数）
  - 一个参数的index方法：返回参数在列表中的位置
  - ```
  >>> list3.index(123)
  0
```
- 三个参数的index方法：返回第一个参数在列表中以第二个参数为起始位置，第三个参数为结束位置中出现的位置
- reverse方法（把列表中的所有元素进行逆排序）
  - ```
  >>> list3.reverse()
  >>> list3
  [456, 123]
```
- sort方法（从小到大对列表进行排序）
  - ```
  >>> list3.sort()
  >>> list3
  [123, 456]
```
- 从大到小排序：可以先用sort方法进行从小到大排，再用reverse方法进行逆排序
- 带参数的sort方法（第一个参数是排序的条件）
  - ```
  >>> list3.sort(reverse=True)
  >>> list3
  [456, 123]
```

列表拷贝的补充

重申一遍：Python的变量就像一个标签，就一个名字而已

看程序解释

>>> list6 = [1,2,3,4,5,6]  #创建了一个列表list6
>>> list7 = list6[:]  #使用拷贝方法将list6的所有元素拷贝给list7
>>> list7  #输出list7发现和list6一样
[1, 2, 3, 4, 5, 6]
>>> list8 = list6  #在这里把list6列表用list8来表示
>>> list8  #输出list8自然和list6一样
[1, 2, 3, 4, 5, 6]
>>> list6.reverse() #对list6进行逆排序
>>> list6  #输出
[6, 5, 4, 3, 2, 1] #list6也确实进行了逆排序
>>> list8  #但我们输出list8的时候他会随着list6的变化而变化，因为list8只是个名字，他实际还是指向list6的，如果是进行拷贝的话，他就是一个新的列表，如果用等号就只是多了一个标签而已
[6, 5, 4, 3, 2, 1]

013元组：戴上了枷锁的列表

元组和列表是非常相似的
这节课主要讨论元组和列表到底有什么不同
- 列表可以随意修改元素，对元素进行增删改查。而元组是不可以随意插入或删除一个元素的

创建一个元组

>>> tulpe1=(1,2,3,4,5,6,7,8)
>>> tulpe1
(1, 2, 3, 4, 5, 6, 7, 8)

访问元组和访问列表元素是一样的

>>> tulpe1[1]
2
>>> tulpe1[:]
(1, 2, 3, 4, 5, 6, 7, 8)

修改元组（报错）

>>> tulpe1[1] = 3
Traceback (most recent call last):
  File "<pyshell#116>", line 1, in <module>
    tulpe1[1] = 3
TypeError: 'tuple' object does not support item assignment

创建一个空元组（和创建一个空列表相似）
- ```
>>> type(temp)
<class 'tuple'>
```
更新和删除一个元组
- 不能直接对元组进行操作，只能通过拼接的方式然后构成一个新的元组这样
- ```
>>> temp = temp5[:2] + ('kk',)+temp5[2:]
>>> temp
('aaaa', '老甲鱼', 'kk', '黑夜', '迷途', '怡静', 'hello', 'world')
```
- 删除元素也是可以通过如上切片的方式进行
- 删除整个元素可以使用del语句，但我们一般很少去使用del这个语句，因为python和java一样也是有虚拟机在运行的，他也自己带有gc垃圾回收机制，当没有任何标签指向这个元组或者列表的时候他就会自己释放掉
- ```
>>> del temp
>>> temp
Traceback (most recent call last):
  File "<pyshell#127>", line 1, in <module>
    temp
NameError: name 'temp' is not defined
```

014字符串的各种内置方法

字符串组合
- 之前说过使用切片的方式对列表或元组进行拼接时，并没有真正意义上的对字符串进行修改，只是用名字去代替他而已，不用他的话垃圾回收机制会自动回收掉。要想对其真正修改需要用字符串的方法。
  - ```
  >>> str1 = 'i love stury'
  >>> str1
  'i love stury'
  >>> str1[5]
  'e'
  >>> str1[:6]+"插入的字符串"+str1[6:]
  'i love插入的字符串 stury'
  >>> str1
  'i love stury'
```

字符串内建函数

查文档

>>> str2 = 'xiaowei'
>>> str.capitalize()
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    str.capitalize()
TypeError: descriptor 'capitalize' of 'str' object needs an argument
>>> str2.capitalize()
'Xiaowei'
>>> str2.casefold()
'xiaowei'
>>> str2.center(20)
'      xiaowei       '
>>> str2.count('xi')
1
>>> str2.endswith(' ')
False
>>> str2
'xiaowei'
>>> str2.endswith('wei')
True
>>> str3 = 'My\tname\tis\tJW'
>>> str3.expandtabs()
'My      name    is      JW'
>>> str3.find('j')
-1
>>> str3.find('xiao')
-1
>>> str3.find('J')
11
>>> str4 = "i  love myhome..   "
>>> str4.lstrip()
'i  love myhome..   '
>>> str4 = "   i  love myhome..   "
>>> str4.lstrip()
'i  love myhome..   '
>>>

参考博文：https://blog.csdn.net/weixin_43158056/article/details/92798114

在这里插入图片描述

015字符串：格式化

也是Python的内建函数字符串

格式化符号含义

举例

>>> "{0} love {1}.{2}".format("I","Jw","Heihei")
'I love Jw.Heihei'
>>> "{a} love {b}.{c}".format(a="I",b="Jw",c="Heihei")
'I love Jw.Heihei'
>>> >>> "{a} love {b}.{c}".format(a="I",b="Jw",c="Heihei")
'I love Jw.Heihei'
KeyboardInterrupt
>>> >>> "{a} love {b}.{c}".format(a="I",b="Jw",c="Heihei")
'I love Jw.Heihei'
KeyboardInterrupt
>>> "{0} love {a}.{b}".format("I",a="Jw",b="Heihei")
'I love Jw.Heihei'
#可以用字符代替，但用数字表示的必须卸载fomat参数前面
>>> "{a} love {b}.{0}".format(a="I",b="Jw","Heihei")
SyntaxError: positional argument follows keyword argument
>>> "{a} love {b}.{0}".format("I",a="Jw",b="Heihei")
'Jw love Heihei.I'

#冒号表示格式化的开始
>>> '{0:.1f}{1}'.format(27.658,'GB')
'27.7GB'

在这里插入图片描述

>>> '%c %c %c' % (97,98,99) #%就表示格式化，就好像C语言中的printf("%c",99)
'a b c'
....

在这里插入图片描述

格式化操作符辅助指令
- ```
>>> '%5.1f' % 27.658
' 27.7'
```
字符串转义字符含义

016序列

列表、元组和字符串的共同点
- 1.都可以通过索引得到每一个元素
- 2.默认索引值总是从0开始
- 3.可以通过分片的方法得到一个范围内的元素的集合
- 有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）
我们把它们统称为：序列！下面介绍有关序列的常用BIF（内建方法）
序列的BIF内置方法
- list([iterable])方法：可以把一个可迭代对象转换为列表。
  - 他分有参数和无参数两种，没有参数的话就是一个创建一个空的list。有参数的话参数只能是一个可迭代对象
  - 他的实现原理就是先对可迭代对象（列表、字符串、元组）进行迭代，然后做成一个新的列表返回
  - 使用help(list)对其进行查看这个内置函数
  - 举例
  - ```
  #使用list方法创建一个空列表
  >>> a = list()
  >>> a
  []
  
  #使用list方法把可迭代对象——字符串变成列表
  >>> b = "I Love FishC.com"
  >>> b = list(b)
  >>> b
  ['I', ' ', 'L', 'o', 'v', 'e', ' ', 'F', 'i', 's', 'h', 'C', '.', 'c', 'o', 'm']
  
  #使用list方法把可迭代对象——元组变成列表
  >>> c = (1,1,2,3,4,5,6,8,9)
  >>> c = list(c)
  >>> c
  [1, 1, 2, 3, 4, 5, 6, 8, 9]
```
- tuple([iterable])方法：把一个可迭代对象转换为元组。
  - 和list差不多
- str(obj)方法：把obj对象转换为字符串。
  - 和上面的也差不多
- len()方法：返回序列的长度
- max()方法：返回序列或者参数集合中的最大值
  - ```
  >>> max(1,2,3,4,5)
  5
```
- min()方法：返回序列或者参数集合中的最小值
- sum(iterable[,start = 0])方法：返回序列iterable和可选参数start的总和
  - ```
  >>> t2 = (1,2,3,4,5)
  >>> sum(t2)
  15
  >>> sum(t2,8)
  23
```
- sorted(iterable)方法：返回一个排序后的列表，实际和list.sort()使用是一样的。
  - ```
  >>> numbers = (-45,-98,98,1,2,9,11,0)
  >>> sorted(numbers)
  [-98, -45, 0, 1, 2, 9, 11, 98]
```
- reversed(iterable)方法：和list.reverse()方法是一样的:把列表中的所有元素进行逆排序
  - 但是直接使用reversed方法返回的是一个迭代器对象，所以我们可以通过list直接转一下
  - ```
  >>> reversed(numbers)
  <reversed object at 0x0000022D38D14520>
  >>> list(reversed(numbers))
  [0, 11, 9, 2, 1, 98, -98, -45]
```
- enumerate(iterable)方法：枚举，他返回的是一个对象，是一个带索引值的元组
  - ```
  >>> enumerate(numbers)
  <enumerate object at 0x0000022D38D25380>
  >>> list(enumerate(numbers))
  [(0, -45), (1, -98), (2, 98), (3, 1), (4, 2), (5, 9), (6, 11), (7, 0)]
```
- zip()方法：返回参数的序列组成的元组
  - ```
  >>> a = [1,2,3,4,5,6,7,8]
  >>> b = [4,5,6,7,8]
  >>> zip(a,b)
  <zip object at 0x0000022D38D25380>
  #元素和元素组成了起来
  >>> list(zip(a,b))
  [(1, 4), (2, 5), (3, 6), (4, 7), (5, 8)]
```

017₀₁₈019~020函数

函数的定义（def关键字）
- 语法：
  
  def MyFunction() :
  
  函数体
- 示例：
  - ```
  >>> def MyFunction():
  	print("这是我写的第一个Pyhon函数")
  
  	
  >>> MyFunction()
  这是我写的第一个Pyhon函数
```
- 当调用函数中，他会往上找def关键字定义的函数名字，然后执行函数体

定义有参函数

括号内加形式参数即可

示例

>>> def MyHavadataFun(name):
	print(name+"呵呵")

	
>>> MyHavadataFun("你好")
你好呵呵

函数的返回值

和C语言一样，用return关键字

示例

>>> def add(num1,num2):
	return num1+num2

>>> add(5,6)
11

函数参数
- 形参和实参

函数文档

用函数名.__doc__来查看该函数的默认属性

用help(函数名)也可查看函数的属性（返回值，参数等进行介绍）
写函数文档的目的就是为了方便别人了解这个函数的具体意义

示例

>>> def MyFristFunction(name):
	'函数定义过程中的name是形参'
	#因为他只是一个形式，表示占据一个位置
	print("传递进来的"+name+"叫做实参，因为他是具体的参数值！")

>>> MyFristFunction("实参")
传递进来的实参叫做实参，因为他是具体的参数值！

>>> MyFristFunction.__doc__
'函数定义过程中的name是形参'

>>> help(MyFristFunction)
Help on function MyFristFunction in module __main__:

MyFristFunction(name)
    函数定义过程中的name是形参

关键字参数

多用于明确传入的参数，有时候函数在调用的时候参数可能会写错位置。
当我们用关键字写明参数的时候，Python就不会用参数顺序去索引，而是根据关键字去索引

示例

>>> def SaySome(name,words):
	print(name+'->'+words)

	
>>> SaySom('小甲鱼','让编程改变世界！')
Traceback (most recent call last):
  File "<pyshell#69>", line 1, in <module>
    SaySom('小甲鱼','让编程改变世界！')
NameError: name 'SaySom' is not defined
>>> SaySome('小甲鱼','让编程改变世界！')
小甲鱼->让编程改变世界！
>>> SaySome('让编程改变世界！','小甲鱼')
让编程改变世界！->小甲鱼
>>> SaySome(words='让编程改变世界！',name='小甲鱼')
小甲鱼->让编程改变世界！

默认参数

当函数定义默认参数时，在调用的时候就算不填参数也不会报错。

示例

>>> def SaySome(name='小甲鱼',words='世界'):
	print(name+'->'+words)

	
>>> SaySome()
小甲鱼->世界

收集参数

示例

>>> def SaySome(*params):
	print("参数的长度是：",len(params));
	print("第二个参数为：",params[1]);

>>> SaySome(1,"小甲鱼","hello","3.14","5.28")
参数的长度是： 5
第二个参数为： 小甲鱼

>>> def SaySome(*params,exp = 8):
	print("参数的长度是：",len(params));
	print("第二个参数为：",params[1]);
	
>>> SaySome(1,"小甲鱼","hello","3.14","5.28",exp=20)
参数的长度是： 5
第二个参数为： 小甲鱼

其实他是根据你输入的参数打包成一个元组，然后放到这个叫params的元组里

返回值
- python的函数都会返回一些东西，不像C语言和其他语言，没有return返回值就无法进行接收。
- 在Python里，如果没有写rerturn返回，那么他久默认返回None，这个None他是NoneType类型
- 示例
  - ```
  >>> def hello():
  	print("我没有定义返回值")
  
  >>> temp = hello()
  我没有定义返回值
  >>> temp
  >>> print(temp)
  None
  >>> type(temp)
  <class 'NoneType'>
```

再谈谈返回值

在Python中他是动态分配类型，没有像C语言那样返回值是整形就必须用一个整形变量去接收。他可以任意接收然后再判读类型。

示例

>>> def back():
	return [1,'小甲鱼',3.14]

>>> back()
[1, '小甲鱼', 3.14]

#如果没有指定返回为列表，他就默认返回元组.
>>> def back():
	return 1,'小甲鱼',3.14

>>> back()
（1, '小甲鱼', 3.14）

函数变量的作用域问题
- **在函数里面定义的变量和参数都是局部变量，他只在函数里面起作用。**他是使用栈进行存储，执行完函数之后这些局部变量就会出栈
- 全局变量作用域是整个程序。但在函数内部访问全局变量时，最好不要去试图对全局变量进行修改，因为当我们对全局变量在函数内部赋值的时候，编译器会认为这是你定义的一个新的名字一样的局部变量，所以这个局部变量又会进栈。但如果真的想在函数内部修改全局变量的值，那也是有办法的。下个知识点再讲。
- 示例
global关键字
- 上个知识点关于函数函数变量的作用域问题遗留：在函数内部访问全局变量时，最好不要去试图对全局变量进行修改，因为当我们对全局变量在函数内部赋值的时候，编译器会认为这是你定义的一个新的名字一样的局部变量（屏蔽），所以这个局部变量又会进栈。
- 我们可以通过一个global关键字来解决
  
  对我们想要修改的全局变量在局部变量前加上global关键字即可。
- 示例
  - ```
  >>> count = 5
  >>> def MyFun():
  	count = 10
  	print(count)
  	
  >>> MyFun()
  10
  >>> print(count)
  5
  >>> def MyFun():
  	global count
  	count = 10
  	print(count)
  
  >>> MyFun()
  10
  >>> 
  >>> print(count)
  10
```

Python支持函数的嵌套定义

示例

>>> def fun1():
	print("fun1()正在被调用")
	def fun2():
		print("ffun2()正在被调用")
	fun2()

	
>>> fun1()
fun1()正在被调用

闭包

如果在一个内部函数里引用外部函数的变量，就称这个内部函数是闭包。而内部函数和外部函数也相当于局部变量和全局变量的关系，内部函数不能直接访问外部函数的成员。但是可以通过列表的形式，因为列表不是存储在栈中。也可以使用nonlocal关键字使得内部函数可以访问外部函数的变量

示例

>>> def funX(x):
	def funY(y):
		return x * y
	return funY

>>> i = funX(8) #因为这里返回的是一个function
>>> type(i) #查看类型
<class 'function'>
>>> i(8)#所以需要对function这样调用才可以
64
>>> funX(8)(5)#也可以直接这样调用
40

#作用域问题：
>>> def Fun1():
	x = 5
	def Fun2():
		x *= x
		return x
	return Fun2()

>>> i = Fun1()  #这样无法进行访问，因为内部函数不能直接访问外部函数得成员，会报错
Traceback (most recent call last):
  File "<pyshell#32>", line 1, in <module>
    i = Fun1()
  File "<pyshell#31>", line 6, in Fun1
    return Fun2()
  File "<pyshell#31>", line 4, in Fun2
    x *= x
UnboundLocalError: local variable 'x' referenced before assignment
##解决方案1.外部函数成员使用列表的方式，因为列表不存储在栈中
>>> def funX():
	x = [5]
	def funY():
		x[0] *= x[0]
		return x[0]
	return funY

>>> funX()()
25
##解决方案2.使用nonlocal关键字声明内部函数的那个变量，使用方法与global关键字一样
>>> def funX():
	x = 5
	def funY():
		nonlocal x
		x *= x
		return x
	return funY

>>> funX()()
25

021lambda表达式

Python允许使用lambda表达式来创建匿名函数
冒号前面是原函数的参数，可以是多个的，冒号的后面是原函数的返回值
匿名的，我们可以用任意变量去接收，然后直接调用，当不使用这个函数时，垃圾回收机制会自动将其进行回收
作用：
- 1.Python写一些执行脚本时，使用lambda就可以省下定义函数的过程，比如说我们只是需要写个简单的脚本管理服务器时间，我们就不需要专门定义一个函数然后再写调用，使用lambda就可以是的我们的代码更加精简。
- 2.不需要考虑命名问题
- 3.简化代码的可读性

示例

>>> ds(5)
11
>>> g = lambda x: 2 * x + 1 #冒号前面是原函数的参数，冒号的后面是原函数的返回值
>>> g(5)
11

#多个参数
>>> s = lambda x,y: x+y
>>> s(3,4)
7

两个实用的BIF

filter()过滤器：第一个参数是一个函数或者None，第二个参数是一个可迭代的对象，返回的是一个对象，他的作用就是把第一个参数中任何非true的内容过滤掉

示例

>>> list(filter(None,[1,0,False,True]))
[1, True]
>>> def odd(x):
	return x % 2

>>> temp = range(10)
>>> show = filter(odd,temp)
>>> show
<filter object at 0x0000020CEE53CB20>
>>> list(show)
[1, 3, 5, 7, 9]

#用lambda表达式可以写成这样
>>> list(filter(lambda x:x%2,range(10)))
[1, 3, 5, 7, 9]

map()映射：第一个参数是一个函数或者None，第二个参数是一个可迭代的对象，返回的是一个对象，他的作用是把第二个参数中每次迭代的值通过第一个参数进行加工，得到加工后的序列
- 示例
  - ```
  >>> list(map(lambda x:x*2,range(10)))
  [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
```

022₀₂₃024递归

定义：简单说就是函数调用自身的一个过程

汉诺塔游戏
树结构的定义
谢尔宾斯基三角形

递归求阶乘

示例

def test(n):
    result = n
    for i in range(1,n):
        result *= i

    return result

number = int(input("请输入一个正整数："))
result = test(number)
print("%d 的阶乘是：%d" % (number,result))

def test(n):
    if n==1:
        return 1
    else:
        return n*test(n-1)

number = int(input("请输入一个正整数："))
result = test(number)
print("%d 的阶乘是：%d" % (number,result))

裴波那契数列的迭代实现

在这里插入图片描述

def fab(n):
    n1 = 1
    n2 = 1
    n3 = 1

    if n<1 :
        print("输入有误")
        return -1

    while (n-2)>0:
        n3 = n2 + n1
        n1 = n2
        n2 = n3
        n -= 1


    return n3

result = fab(20)
if result != -1:
    print("总共有%d对兔崽子诞生！" % result)

裴波那契数列的递归实现

def fab(n):

    if n<1 :
        print("输入有误")
        return -1
    if (n==1) or (n==2):
        return 1
    else :
        return fab(n-1) + fab(n-2)

result = fab(20)
if result != -1:
    print("总共有%d对兔崽子诞生！" % result)

递归汉诺塔实现

def hanoi(n,x,y,z):
    if (n==1):
        print(x," --> ",z)
    else:
        hanoi(n-1,x,z,y)#将前n-1个盘子从x移动到y行
        print(x," --> ",z)#将最底下的最后一个盘子从x移动到z上
        hanoi(n-1,y,x,z)#将y行的n-1个盘子移动到z上

n = int(input("请输入汉诺塔的层数："))
hanoi(n,'X','Y','Z')