小甲鱼Python3笔记

000-愉快的开始

入门容易,学习难,代码量少.

跨平台: Windows, Mac OS, Linux, UNIX.

　　应用领域: 操作系统 WEB 3D动画 企业应用 云计算等等.

001-我和Python的第一次亲密接触

1.安装
2. IDLE 是一个Python Shell:一个通过键入文本与程序交互的途径.
3.print(‘text’), print(5+3), print(123+456), print(‘test’ +’text’ ), print(‘test’ * 8), print(‘test \n’ * 8)
4.上一条语句快捷键:Alt + p 下一条语句快捷键:Alt + n

002-用Python设计第一个游戏

1.在IDLE中Ctrl + N 新建一个编辑器
2.写入一个猜数字的小游戏
3.Tab: 缩进 和 补全
4.Ctrl + S 保存
5.按F5运行
6.缩进很重要! 末尾有冒号,回车后会自动缩进.
7. 一个等号是赋值,两个等号是判断是否等于.
8.流程图
9.BIF == Buile-in functions 内置函数
10.有多少个内置函数在IDLE中:dir(__bulitins__)
11.帮助:help(BIF_Name)

003-变量和字符串

1.变量名就像我们现实社会的名字,把一个值赋值给一个名字时,Ta会存储在内在中,称之为变量(variable),在大多数语言中,都把这种行为称为”给变量赋值”或”把值存储在变量中”.
但是在Python与大多数其他计算机语言的做法不同,他并不是把值存储在变量中,而更像是把名字贴在值上边.所以有些Python程序员会说Python没有”变量”,只有”名字”.
2.变量可以运算:

f = 3

s = 8

t = f + s

print(t)

–> 11

换成字符串也是可以的.

3.使用变量要注意的地方:

(1)在使用变量之前,需要对其先赋值.
(2)变量名可以包括字母,数字,下划线,但变量名不能以数字开头.
(3)字母可以大写或小写,但大小写是不同的.
(4)等号(=)是赋值的意思,是把右面的值赋给左面的变量名,不能写反了
(5)变量名理论可以取任何合法的名字,但尽量要取一个专业点的名字:
4.我们所认知的字符串就是引号内的一切东西,我们也把字符串叫做文本.文本和数字是不同的.

5.要创建一个字符串,就要在字符两边加上引号,可以是单引号或者双引号,但必须成对出现.
6.转义符号用 \ –> ‘Let\’s go!’
7.但是要打印 ‘c:\now’ 文件路径,可以用’c:\\now’也就是用转义来转义\但是这种方法如果有很多的\就不方便
8.对于上面的问题,我们就可以用原始字符串也就是 r ‘ test ‘的方法,但是要注意原始字符串的最后面是不能加上 \ 的解决办法是什么呢(我自己觉得可以字符拼接)
9.长字符串:要得到一个跨越多行的文本可以用三引号.
10.符号一定要用英文标点符号.
004-改进小游戏
1.猜错的时候程序应该给提示
2.只能猜一次,应该多点机会
3.每次运行程序,答案可以是随机的
4.条件分支
(1)比较操作符: >, >=, <, <=, ==, != 反回 True或False 比较操作符左右要加空格
(2)分支语法:
if条件:
条件为真(True)执行的操作
else:
条件为假(False)执行的操作
5.while循环
(1)while 条件:
条件为真(True)执行的操作 (例如:while guess != 8:)
(2)别忘了冒号和缩进.
(3)and逻辑操作符 左右同时为True才为True
6.引入外援: random模块
(1)我们写的每个程序其实就是模块
(2)random模块里有一个函数叫randint()会反回一个随机整数.
例:random.randint(1,10) 生成一到十中的一个随机整数.
(3)导入 import random

005-数据类型

1.字符串运算会拼接字符串
2.整型:python3整型和长整型和在一起了,长度不受限制. Python2里是分开的.
3.浮点型:就是小数,区别就是有没有小数点
4.e记法:就是科学户数法(有正负 负就是往小正就是往大)
A = 0.000000000025
A –> 2.5e-11
b = 150000000000
b –>1.5e11
5..布尔类型:是一种特殊的整型.True Fales可以当成 0和1也可以用来计算.
True +true = 2
True+false = 1
True*false = 0
True/false 会报错, 0 不能做为除数
但是 一般不用来计算.

一.如何相互转换?
有BIF : int() str() float()
int():转化为整数, a = ‘520’ b = int(a) b –> 520
也可以把浮点型转换为整数,但是python会把后面的数直接砍掉,不会四舍五入.
不能用 a=’string’这种让int转换

float: a = ‘520’或者a=520 b = int(a) b –> 520.0

str(): 转换为字符串.

不能用BIF当变量名.

二. 如何获得类型的信息(判断)
type():  括号内写要判断的内容.会返回括号内的类型.

isinstance() :有两个参数 一个是用来判断的变量,一个是想要确定的类型
它会返回一个布尔值,如果符合判断,为True 反之为Flase
a = ‘string’
isinstance(a,str)
–> True

isinstance(123456,str)
–> Float

更加建议用 isinstance()

006-常用操作符
+ : a= a+3 可以写做 a+=3   |  b = 3 b-=1 b –> 2
–
*
/
% : 求余数 5%2 –> 1 |11%2 –>1
** : 幂,也就是多少次方
// : 地板除 10//8 –> 1 | 3.0//2 –>1.0

例:
a = b = c = d = 10 –> a=10 b=10 c=10 d=10
a +=1 a–>11
b -=3 b–>7
c*=10 c–>100
d /=8 d–>1.25

伏优先级问题:最先括号,先乘除,再加减.
-3 * 2 + 5 / -2 -4
–> (-3)*2 + 5/(-2) -4
–> ((-3)*2)+(5/(-2)) -4
比较操作符(<,>)比逻辑操作符优先级高
3<4 and 4<5
(3<4) and (4<5)
必要的时候多加括号,增加代码的可读性.

幂运算比左面的高比右面的低
-3 **2 (正常来说 -3 * -3 应该等于 9)
–> -(3 ** 2)
–> -9

逻辑操作符
and 左面都为真 才为真
or 左或右为真 就为真.
not 左右都为假 就为真.

统计一下:

最高 ** 但有特殊性
然后 正负号
然后 * / //
然后 + –
然后 < > <= >= == !=
然后 not and or

007-支和循环1

一. 游戏的组成和架构(打飞机游戏)
1.进入游戏就是进入一个大循环:只要不死直出飞机
2.分支 条件发生改变 进入另一个胡同昊
3.飞机都一样,所以都是一个对象复制出来的.
框架:
1.加载背景音乐
2.播放音乐 单曲循环
3.我方飞机诞生

小飞机间隔变量 = 0
while True
if 用户是否点了关闭 退出
break

间隔 += 1
if 间隔 == 50:
间隔 = 0
小飞机诞生
小飞机移动一个位置 从上往下
屏幕刷新

if 用户鼠标移动
我方飞机中必位置 = 用户鼠标位置
屏幕刷新

if 我方飞机与小飞机发生肢体冲突
我方挂,播放撞击音乐
修改我方飞机图案
打印game ove
淡出停止背景音乐

008-分支和循环2

90分以上为A,80-90分为B,60-80为C,60以下为D
写一个程序,当用户输入分数,自动转换为ABCD的形式打印.

答案:用if elif else 语句实现!

悬挂else? 在Python中是不可能的.

条件表达式(三元操作符,三目操作符)
几元操作符,是指这个操作符有多少个操作数
例如 a = 1 这里的 = 左右有两个操作数,所以它就是一个二元操作符.
-1 减号当做负号时他就是一个一元操作符.
small = x if x<y else y 这就是一个三元操作符.
语法是:x if条件 else y
当条件满足时,把x的值给了small,不成立时把y值给了small

断言(assert)
assert是关键字, 称为断言
当这个关键字后边的条件为假的时候,程序自动崩溃
并抛出AssertionError的异常
例子: assert 3>4
一般来说我们可以用它再程序中转入检查点,
当需要确保程序中的某个条件一定为真才能让程序
正常工作的话,assert关键字就非常有用了.
tips: 这一般用来测试程序用.

009-分支和循环3

while循环:条件为真,一直循环.
while 条件:
循环体

for 循环,计算器循环:
for 目标 in 表达式(列表,元组):
循环体
例子:
a = ‘lvyang’
for i in a:
print(i, end=’ ‘) # 注意这里的print end语句 表示输出用什么结尾

num = [‘a’,’bccc’,’bcf’,’dd’,’e’,’f’]
for each in num:
print(each,len(each)

range():
语法:range([strat,]stop[, step=1])
有三个参数,其中用中括号括起来的两个表示这两个参数是可选的.
-step=1 表示第三个参数的默认值是1.如果你不主动设置step就是1.
-rang这个BIF的作用是生成一个从start参数的值开始到stop参数的值
结束的数字序列.
range()是经常和for in一起的:
range(5)–> range(0,5)
list(range(5)) –> [0,1,2,3,4]
例子:
for i in range(5):
或
for i in range(2,9):
或
for i in range(1,10,2): –>第三个参数step是步长的意思.

两个关键的语句:break 和continue
break:终止循环,并跳出循环体.
continue:终止本轮循环,并开始下一轮循环,注意,它在开始下一轮循环之前它会测试
下一轮循环的条件.只有下一轮循环为True的时候,它才会开始下一轮循环.如果不会的话
它会退出循环.

010-列表

所有类型都可以装进去.
一,创建列表三种方式
1.创建一个普通列表:
member = [‘xx’,’oo’,’dd’,’cc’]
也可以 num = [1,2,3,4]
2.创建一个混合列表:
mix = [1,’ddd’,3.14,[1,2,3]] 也可以在里面添加一个列表.
3.创建一个空列表
empty = []

二,向列表添加元素
1.append()方法 :member.append(‘oooxxx’) 只能添加一个元素. 添加到列表的尾部.
len(member)–>反回列表的长度
.后面是方法 属于列表对象
2.extend()扩展,用一个列表扩展另一个列表.
member.extend([‘东奔西走’,12345,’大发寻’]) 把一个列表追加一列表的末尾.
3.insert()方法:有两个参数,第一个代表在列表中的位置,第二个参数插入的元素.
会在第一个参数指定的位置,插入元素.
member.insert(1,’jj’)
位置是从0算起的,如果想放在第一个位置要写0

011-列表2
一.从列表中获取元素
1.member[0]获取第一个
member[1]获取第一个
想给member列表的第一和第二个元素调换位置
temp = member[0] 把第一的元素放在一个临时变量里
member[0]=member[1] 把第一个元素改成第二个元素
member[1]=temp 把临时变量添加到第二个元素位置.
二.从列表删除元素
1.remove()
member.remove(‘oo’) 参数是要删除元素的名字
如果没有给定的参数就会报错
2.del
它不是列表的方法,是一个语句.
del member[1] 把第一个元素删除.
del member 把整个列表删除.
3.pop()
member.pop() 会删除最后一个元素,并反回删除元素的内容.
我们可的把删除的内容赋值 name = member.pop() 这样
pop()有一个参数,member.pop(索引)
三.列表切片(slice)
一次需要获取多个元素.得到原列表的一个copy
member[:]
member[1:3]
member[:3]
member[2:]
member[:-1]

012-列表3
一.比较操作符
例:
ist1 = [123]
list2 = [234]
list1 > list2
例:
list1 = [123,456]
list2 = [234,123]
list1 > list2
tips:列表是从第0个元素开始比较的,如果第0个赢了那就赢了,不考虑后面的元素.
例:
list3 = list1 = [123,456]
(list1 < list2) and(list1 == list3) –>True
例:
list4 = list1 +list2
但是一般不要用,一般要用list.extend()更为规范.
例:
list1 + ‘大’ –>报错
+号左右的对象的类型必须是一样的.
例:
list1 * 3
例:
list3*=3 或 list3 *= 5
例:
123 in list3 –>True
‘233’ not in list3 –>false
例:
列表里的列表可不可以呢?
lists = [123,[‘人’,’从’],456]
‘人’ in lists –>false
可以这样
‘人’ in lists[1] –> True
lists[1][1] –>’从’

二.列表的BIF : dir(list)可以查到
1.count 计算列表中参数出现的次数.
list3.count(123)
2.index 索引,反回参数在列表中的位置.
list3.index(123)

list3.index(123,3,7) 后面的参数可以指定要找的范围.
3.reverse() 原地翻转.
list3.reverse()
4.sort() 用指定的方式对列表进行排序.
默认是从小到大
list6 = [4,3,2,5,9,23,32,0]
list6.sort() –>从小到大排
sort(reverse = false) –> list6.sort(reverse=True)
5.列表的copy
赋值不等于copy
复制粘贴,快捷方式的区别.
很容易出现错误.!

013-元组(tuple)

—里面的参数,不可改变,在使用时和列表非常相似

1.创建:tuple1 = (1,2,3,4,5,6,7,8)
创建一个空元组: tuple2 = ()
2.访问:tuple1[1]也可以 tuple1[5:] 或 tuple1[:5]
也可以copy一个列表 tuple2 = tuple1[:]
3.元组里的元素不可以修改
注意: temp =(1) –> temp –> type(temp) –> <class ‘init’>
创建只有一个元素的元组,反回来的type其实是
init 认为它是一个变通变量
如果要创建一个只有一个元素的元组,temp = (1,)或temp = 1,
在元素的后面加一个逗号.

temp2 = 2,3,4,5 –> type(temp2) –> <class ‘tuple’>
创建多个元素的变量,就算没有小括号也会得到元组

所以小括号不是关键,逗号才是关键.

例:
8 * (8) –> 64
8 * (8,) –> (8,8,8,8,8,8,8,8) 因为是元组了

4.更新和删除一个元组
temp = (‘a’,’b’,’c’,)
temp = temp2[:2]+(‘dd’,)+temp[2:]
tip:要删除某一个元素是不可能的,只可以用上面的方法重组
要删除整个元组可以用 del 语句 : del temp
一般不用 del 语句,因为有内在回收机制
5.元组相关的操作符
+ 拼接
* 重复
>,<
in,not in
and or not

014-字符串
–切片也可有用在字符串上:str1 = ‘123456789’ –>str1[:5] 也可以用索引取出.
–字符串和元组一样也不能随意修改,如果实在想修改,参照上面的元组.
–相关操作符和元组列表基本一样

字符串的方法
1. captalize — 第一个字符大写
2. casefold — 把整个字符串改为小写
3. center(50) — 把字符串居中,并使用空格填充至长度width的新字符串
4. count(‘str’) — 查找字符串中有几个’str’，还有可选参数 start和end
5. encode()
6. endswith(‘x’) — 检查是否是‘x’结束,也有可选参数start和end
7. expandtabs() — 把’\n’ 的空格转换成默认为8长度‘(可指定)’的tab,也有可选参数start和end
8. find() — 检测括号内容是否包含在字符串中,有,反回索引.否则返回-1,start和end
9. index() — 跟find方法一样,不过如果括号里的内容不在string中会产生一个异常.
10. isainum() — 如字符串至少有一个字符并且所有字符都是字母或数字 则反回True,否则返回false
11. isalpha() — 如客串至少有一个字符并所有字符都是字母则返回True,否同则反回false
12. isdecima() — 如果字符串只包含十进制数字则返回True,否则返回false
13. isdigit() — 如果字符串只包含数字则返回True,否则返回false
14. islower() — 小写,
15. isnumeric() — 如果字符串中只包含数字字符,则反回True
16. ispace() — 如果字符串中只包含空格返回True
17. istitle() — 如果字符串是标题化(首字母大写)返回True
18. isupper() — 如字符串中至少包含一个区分大小写的字符,并且这些字符都是大写,则返回True
19. join(sub) –以字符串作为分隔符,插入到sub中所有的字符之间.
20. ljuest(width) — 返回一个左对齐的客串,并使用空格填充至长度为width的新客串
21. lower() — 转换字符串中所有大写为小写.
22. lstrip() — 去年字符串左边的所有空格
23. partition(sub) — 找到
太多了 跳~
/t 就是一个tab

015-字符串格式化 format
例1: ‘{0} love {1},{2}’.format(‘lv’,’ren’,’zhen’) 位置参数
例2: ‘{w} love {t},{y}’.format(w=’lv’,t=’ren’,y=’zhen’) 关键字参数
例3: ‘{0} love {t},{y}’.format(‘lv’,t=’ren’,y=’zhen’) 位置和关键字一起用,但是一定要位置在关键字之前
例4: ‘{{0}}’.format(‘打印’) –> {0} 要打印{} 就用这种方法 大括号转义大括号
例5: ‘{0:.1f}{1}’.format(2.688,’GB’) :冒号表示格式化符号的开始,保留一位小数四舍五入.
格式化操作符:
1.格式化字符及ascii码 ‘%c %c %c’ %(97, 98, 99): –> a b c
2.格式化字符串 ‘%s’ % ‘abc’:
3.格式化整数 ‘d’
4.格式化无符号八进制数 %o
5.格式化无符号十六进制数 %x
6.格式化无符号十六进制数(大写) %x
7.格式化定点数,可指定小数点后的精度 %f (默认精确到6位)
8.用科学计数法格式化定点数 %e
9.和%e一样,用科学计数法格式化定点数 %E
10.%g 根据值的大小决定使用%f或%e
11.%G 作用同%g 根据值的大小 决定使用%f或者%e
格式化操作辅助命令:
m.n m是显示 最小部宽度,n是小数点后面的位数 %5.1f 或 %.2e %27.658
– 用于左对齐
+ 在正数前面显示加号
# 在八进制数前百显示(‘ 0′)在十六进制数前面显示’0x’或’0X’ 用于直接告诉你显示的是多少进制
0 显示的数字前面用0代替空格.

字符串转义字符含义
\’ 单引号
\” 双引号
\a 发出系统响铃声
\b 退格符
\n 换行符
\t 横向制表符 tab
\v 纵向制表符
\r 回车符
\f 换页符
\o 八进制数代表的字符
\x 十六进制数代表的字符
\0 表示一个空字符
\\ 反斜杠

016-序列!
1.列表.元组和字符串的共同点
都可以通过索引得到每一个元素
默认索引值总是从0开始
可能切片
有很多共同的操作符 * + 等
2.序列的BIF
list() 把可迭代对象转换成列表
list()空列表
list(iterahle)带一个迭代器参数
tuple() 把可迭代对象转换为元组
和list()一样
str() 把对象转换为字符串
len() 反回长度
max() 反回序列或者参数中的最大值 如果参数是字符串就是比较ascii码
min() 和max()相返 反回最小值
–使用max()和min()方法必须保证参数中的数据类型是统一的
sum(iterable[,start=0]) 反回序列iterable和可选参数start的总和 也只能整数或浮点数
sorted() 排序 和list的sort是一样的.
reversed() 比list的reverse多了个d.会反回一个个迭代器对象. 翻转
enumerate() 枚举 生成每个元素的索引和值的元组 [(0,’a’),(0,’b’)]
zip() 反回由个个参数 a = [1,2,3,4,5,6,7,8] b=[4,5,6,7,8] zip(a,b) –>[(1,4),(2,5),(3,6),(4,7),(5,8)]
017.函数-Python的乐高积木
–函数 对象 模块
def MyFirstFunction():
print(‘hello.world!’)
print(‘这是第一个函数!’)
运行时会把def直接抛进内存,在调用的时候就会往上寻找,然后执行.如果没有找到就会报错

参数功能:
def MySecondFunction(name):
print(name+’我爱你’)
调用的时候 加入参数就可以了

多个参数用逗号隔开就可以了,支持很多参数(尽量不要太多,写好文档)
def add(num1, num2):
result = num1 + num2
print(result)

函数反回:
用关键字return 就可以了
def add(num1, num2):
return(num1 + num2)

18-函数 灵活即强大(参数)
一. 形参(parameter)和实参(argument)
1.函数定义过程中的name是叫形参(因为他只是一个形式,表示占据一个参数位置)
print(‘传递进来的’+name+’叫做实参,因为他是具休的参数值.’)
2. MyFirstFunction(‘hehe’)
传递进来的小甲鱼叫做实参,因为ta是具体的参数值.
二.函数文档 给函数写文档!会做为函数的一部分存储起来.
MyFirstFunction.__doc__
就可以调出函数的说明.也可以用help()来查看
三.关键字参数
为了怕搞错顺序
def SaySome(name, words):
print(name+’>>>’+words)
就是在调用的时候写上参数的名字: SaySome(name = ”, words = ‘ ‘)
四.默认参数
定义函数时给参数一个默认值. name = ” , words = ”
如果给定参数则使用给定的参数.
五.收集参数(可变参数)
在参数前面加上*号就可以了
def test(*params): # 加了*号就可以给定很多参数
print(‘参数的长度是:’, len(params))
print(‘第二个参数是:’, params[1])
!!如果在收集参数后面还要加参数就要使用关键字参数,并为关键字参数设置默认参数.
否则参数就都进入到收集参数中了,就会报错
print()BIF的第一个参数就是收集参数.后面的参数也都有默认值

19.函数-我的地盘听我的
一.函数与过程
–Python严格来说只有函数没有过程.
def hello():
print(‘hello world’)
temp = hello()
print(temp) –> None
type(temp) –> class’NoneType’
二.反回函数
可以返回多个值(可以反回一个列表,也可以用逗号隔开会反回一个元组.)

三.变量的作用域(局部变量*(Local Variable),全局变量(Global Variable))
1.局部变量:
def discounts(price, rate):
final_price = price * rate
old_price = 88 # 这里试图修改全局变量.
print(‘修改后old_price的值是:’, old_price)
old_price = float(input(‘请输入原价:’))
rate = float(input(‘请输入折扣率:’))
new_price = discounts(old_price, rate)
print(‘修改后的old_price的值是:’, old_price)
print(‘打折后的价格是:’,new_price)
在函数外面找不到函数内定义的参数,变量,函数,参数内的变量作用域只在函数中
2.全局变量
在函数在面定义的变量就是全局变量.他们的作用域就是整个代码块.也就是说在函数内也是可以访问的
使用全局变量要千万小心,在def中尽量不要修改全局变量
因为如果在函数中试图修改全局变量的话Python会自动创建一个新的局部变量,名字和全局变量是一样的(屏蔽保护机制)
所以会出现当时改了是改了,但是在外面的话重新访问会还是改之前的内容.
20.函数-内嵌函数和闭包.
一.Global关键字可以更改全局变量(尽量不要用!!!)
二.内嵌函数 函数内部创建另一个函数
例子
def fun1():
print(‘fun1 runing….’)
def fun2():
print(‘fun2 runing ….’)
fun2()
使用内嵌函数后,只有fun1可以调用fun2.
三.闭包(编程范式)天才程序员使用的语言
def funx(x):
def funy(y):
return x*y
return funy
i = funx(8) –>function –> i(5) –> 40或者也可以funx(8)(5)
如果在一个内部函数里,对在外部作用域在变量进行了引用,那么这个内部函数就是一个闭包.

def fun1():
x = 5
def fun2():
x*=x
return x
return fun2()
调用后会错误,因为fun2在调用x的时候等同于要更改全局变量.所以就会错误,如何解决呢?:
def fun1():
x = [5]
def fun2():
x[0]*=x[0]
return x[0]
这各解决方式就是把数据存放在容器中.就可使用了.
还有一个关键字:nonlocal 使用的方法和上面的一样.

21.函数-lambda表达式(匿名函数)
一.lambda表达式
def ds(x):
return 2 * x + 1
可以写为: x:2*x+1
那么两个参数呢?:
def add(x, y):
return x+y
可以写为: lambda x,y:x+y
lambda表达式的重要作用:
1.Python在写一些执行脚本时,使用lambda就可以省下定义函数过程,
比如说我们只是需要写个简单的脚本来管理服务器时间,我们就不需要
专门定义一个函数然后再写调用,使用lambda就可以使得代码更加精简.
2.对于一些比较抽象并且整个程序执行下来只需要调用一两次的函数,
有时候给函数起个名字也是上比较头疼的问题,使用lambda就不需要考虑
命名的问题了.
3.简化代码的可读性,由于普通的屌丝函数阅读经常要跳到开关def定义部分,
使用lambda函数可以省去这样的步骤.
二.两个牛逼的BIF
1.filter()过滤器. 用法:filter(function or None, iterable)
例子:
filter(None,[1,0,false,True]) –> fun –>[1,True] 返回为真的内容.
筛选奇数的过滤器:
def add(x):
return x % 2
temp = range(10)
show = filter(odd, temp)
list(show)–>[1,3,5,7,9]
给合上面内容可以写为:
list(filter(lambda x:x%2,range(10)))
2.map() 映射 参数(函数,迭代)
list(map(lambda x:x*2,range(10)))

22-递归
–普通程序员使用迭代,天才程序员使用递归.(在恰当的地方使用递归.)
–必须掌握但是不要总用.它是一个台阶,须要掌握,但是有危险性.而且它很消耗时间和空间.
–Python默认递归深度是100层(可调) import sys –> sys.setrecursionlimit(10000000)
例子:
def recursion():
return recursion()
会一直调用 错误
例子:(正确)
写一个阶乘的函数:
非递归版本:
def factorial(x):
result = x
for i in range(1,x):
result *= i
return result
递归版本:
def factorial(x):
if n == 1:
return 1
else:
return n *factorial(n-1)
1.调用函数自身 2.设定了函数自身的反回值.

递归详解:
factorial(5) = 5 * factorial(4)
factorial(4) = 4 * factorial(3)
factorial(3) = 3 * factorial(2)
factorial(2) = 2*factorial(1)
factorial(1) = 19 (return)
1.汉诺塔
2.树结构定义
3.谢尔宾斯基三角形.
递归略 以后补

25-字典1
–字典不是序列类型,是映射类型.映射,建立关系
–键(key)
–值(value)
每一对键值组合称为:项
brand = [‘李宁’,’耐克’,’阿迪’]
slogan = [‘一切皆有可能’,’just do it’,’impossible is nonthing’]
–>print(‘阿迪口号:’slogan[brand.index[‘阿迪’]] 麻烦
用字典:
dict1 = {‘李宁’:’一切皆有可能’,’耐克’:’just do it’,’阿迪’:’impossible is nonthing’}
print(‘李宁的口号是:’,dict1[‘李宁’])

dict2 = {1:’one’,2:’two’,3:’three’}
–>dict2[2]

dict3 = {} 空字典
或 dict() 创建空字典
dict()简单用法: dict5 = dict(((‘f’,70),(‘c’,67),(‘s’,115)))
用对应关系创建字典.
dict6 = dict(吕洋=’哈哈’) 前面的key不能加引号

直接给字典里的键赋值,如果存在改变,如果不存在创建.
dict7[‘吕洋’] = ‘哈哈哈哈哈哈’

26- 字典2
字典的内建方法:
1.fromkeys()
dict1() = {}
dict1.fromkeys((1,2,3))
dict1.fromkeys((1,2,3),’number’)
dict1.fromkeys((1,2,3),(‘1′,’2′,’3′)错的 不会自动赋值
dict1.fromkeys((1,3),’数字’)错的 不能批量修改,而是重新创建一个新字典
2.访问字典的方法 key,values,items
dict1 = dict.fromkeys(range(32),’赞’)
for eachkey in dict1.keys():
print(eachkey) 会自动打出key values同理

for eachitem in dict1.items():
print(eachitem)
用元组把 key和values
3.key是否在dict中
get方法
dict1.get(32) 如果没有会返回None
dict1.get(32,’目有’) 如果没有会返回 目有

也可以用成员操作符:
32 in dict1 –> Flase
31 in false –> True

4.清空 dict
dict1.clear()
5.copy方法 浅拷贝
a = {1:’one’,2:’two’}
b = a.copy()
c = a
id(a)
id(b)
id(c)
浅拷贝和直接赋值不一样
c[3]=’tree’
c
a
b
6.pop() 和 popitem()
a.pop(2)
a.popitem()

7.找不到自动添加
a.setdefault(‘哈哈’)
8.update 用一个字典或映射关系去更新另一个字典
b={‘i’:1}
a.update(b)

27-集合 无序!,去重 不能索引
num = {}
type(num) –>’dict’
num2 ={1,2,3,4,5}
type(num2) –> ‘set’

num2 = {1,1,1,1,1,2,2,2,,2,,2}
–> {1,2}
1.创建的两种方法
用{} 把数字 括起来.
set() : set1 = set([1,1,1,1,2,2,2,2,2,2])
2.如何访问set中的值
for 打印
in 方法 1 in num1
3.num2.add(9) 添加
4.num2.remove(9) 删除

frozen 冻结的,设置一个不可变set
num3 = frozeset([1,2,3,666])
这种set不能添加

28-文件-想输出.
1.打开文件
使用 open 打开文件.
help()