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
-
-
-
优先级
007008009了不起的分支和循环
-
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就又从程序开始执行一遍
-
010011012列表:一个打了激素的数组
-
数组我们知道他是把同种类型的数据都放在一起,用下标进行索引。
-
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)]
-
-
017018019~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]
-
-
022023024递归
定义:简单说就是函数调用自身的一个过程
-
汉诺塔游戏
-
树结构的定义
-
谢尔宾斯基三角形
-
递归求阶乘
-
示例
-
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')
-