首页 / PYTHON / 小甲鱼Python3笔记
小甲鱼Python3笔记
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了小甲鱼Python3笔记，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含44905字，纯文字阅读大概需要65分钟。
内容图文
000-愉快的开始
入门容易,学习难,代码量少.
跨平台: Windows, Mac OS, Linux, UNIX.
应用领域: 操作系统 WEB 3D动画 企业应用 云计算等等.
001-我和Python的第一次亲密接触
1.安装
- 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.缩进很重要! 末尾有冒号,回车后会自动缩进.
- 一个等号是赋值,两个等号是判断是否等于.
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
语法是: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) –>
创建只有一个元素的元组,反回来的type其实是
init 认为它是一个变通变量
如果要创建一个只有一个元素的元组,temp = (1,)或temp = 1,
在元素的后面加一个逗号.
temp2 = 2,3,4,5 –> type(temp2) –>
创建多个元素的变量,就算没有小括号也会得到元组
所以小括号不是关键,逗号才是关键.
例:
8 * (8) –> 64
8 * (8,) –> (8,8,8,8,8,8,8,8) 因为是元组了
4.更新和删除一个元组
temp = (‘a’,’b’,’c’,)
temp = temp2[:2]+(‘dd’,)+temp[2:]
要删除整个元组可以用 del 语句 : del temp
一般不用 del 语句,因为有内在回收机制
5.元组相关的操作符
拼接
重复
,<
in,not in
and or not
014-字符串
–切片也可有用在字符串上:str1 = ‘123456789’ –>str1[:5] 也可以用索引取出.
–字符串和元组一样也不能随意修改,如果实在想修改,参照上面的元组.
–相关操作符和元组列表基本一样
字符串的方法
captalize — 第一个字符大写
casefold — 把整个字符串改为小写
center(50) — 把字符串居中,并使用空格填充至长度width的新字符串
count(‘str’) — 查找字符串中有几个’str’，还有可选参数 start和end
encode()
endswith(‘x’) — 检查是否是‘x’结束,也有可选参数start和end
expandtabs() — 把’\n’ 的空格转换成默认为8长度'(可指定)’的tab,也有可选参数start和end
find() — 检测括号内容是否包含在字符串中,有,反回索引.否则返回-1,start和end
index() — 跟find方法一样,不过如果括号里的内容不在string中会产生一个异常.
isainum() — 如字符串至少有一个字符并且所有字符都是字母或数字 则反回True,否则返回false
isalpha() — 如客串至少有一个字符并所有字符都是字母则返回True,否同则反回false
isdecima() — 如果字符串只包含十进制数字则返回True,否则返回false
isdigit() — 如果字符串只包含数字则返回True,否则返回false
islower() — 小写,
isnumeric() — 如果字符串中只包含数字字符,则反回True
ispace() — 如果字符串中只包含空格返回True
istitle() — 如果字符串是标题化(首字母大写)返回True
isupper() — 如字符串中至少包含一个区分大小写的字符,并且这些字符都是大写,则返回True
join(sub) –以字符串作为分隔符,插入到sub中所有的字符之间.
ljuest(width) — 返回一个左对齐的客串,并使用空格填充至长度为width的新客串
lower() — 转换字符串中所有大写为小写.
lstrip() — 去年字符串左边的所有空格
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+’叫做实参,因为他是具休的参数值.’)
- 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()
028-文件因为以永恒
1.用open打开文件:
打开的模式有:
‘r’-以只读方式打开文件(默认)
‘w’-以写入的方式打开 文件,会覆盖已存在的文件
‘x’-如果文件已经存在,使用此模式打开将引发异常
‘a’-0双写入模式撕开,如果文件存在,则在末尾追加写入
‘b’-以二进制模式打开文件
‘t’-以文本模式打开(默认)
‘+’-可读写模式(可添加到其他模式中使用)
‘U’-通用换行符支持.
例:
open(‘e:\test.txt’) # 两个\因为要转译(可以用u”),打开方式用了默认所以就不用写
f = open(‘e:\test.txt’) # 赋值给一个对象
2.文件对象的方法:
f.close() 关闭文件
f.read(size = -1) 从文件读取size个字符,当未给定size或给定负值的时候,
读取剩余的所有字符,然后作为字符串返回.指针移动到文件的不可末尾.
f.readline() 以写入模式打开,如果文件存在,则在末尾追加写入
f.write(str) 将字符串str写入文件
f.writelines(seq) 向文件写入字符串序列seq,seq应该是一个返回字符串的可迭代对象.
f.seek(offset,from) 在文件中移动文件指针,从from(0代表文件起始位置,1代表当前位置,2代表文件末尾)偏移offset个字节
f.tell() 返回当前在文件中的位置.
可以用list(f)把文件直接转换成为一个列表.
3.读取文件对象中的内容:
for i in f: (推荐这种方法)
print(i)
4.文件的写入:
打开方式一定要是 ‘a’或’w’
f = open(‘e:\test.txt’,’w’)
f.write(‘xxoo’)
f.close
029-文件:一个任务
例1:
def save_file(goy, girl, count):
file_name_boy = ‘boy_’ + str(count) + ‘.txt’
filr_name_girl = ‘girl’ + str(count) + ‘.txt’
boy_file = open(file_name_body, ‘w’)
girl_file = open(file_name_girl, ‘w’)
boy_file.writelines(boy)
boy_file.writelines(girl)
boy_file.close()
girl_file.close()
def split_file(file_name):
f= open(‘test.txt’)
boy = []
girl = []
count = 1 # 计算
for each_line in f:
if each_line[:6] != ‘====’: # 前6个字符是等号
这里我们进行字符串分割
(role, line_spoken) = each_line.split(‘:’, 1)
if role == ‘小甲鱼’:
boy.append(line_spoken)
if role == ‘小客服’:
girl.append(line_spoken)
else:
文件的保存
save_file(boy, girl, count)
boy = []
boy = []
count += 1
save_file(boy, girl, count)
f.close()
split_file(‘recode.txt’)
030-文件系统:介绍一个高大上的东西
–模块:就是可用代码段的打包,用import引入.是一个包含你所有你定义的函数和变量的文件后缀是.py
–OS(Operating System)模块:操作系统.os模块集成了windows,mac os,linux,unix等等的文件系统模块.非常友好.
1.os模块的函数:先导入 import os
getcwd() 返回当前工作目录
chdir(path) 改变工作目录
listdir(path=’.’) 列举当前目录中的文件名(‘.’表示当前目录,’..’表示上一级目录)
mkdir(path) 创建单层目录,如该目录已存在抛出异常
makedirs(path) 递归创建多层目录,如该目录已存在抛出异常,注意:’e:\a\b’和’e:\a\c’并不冲突
remove(path) 删除文件
rmdir(path) 删除单层目录,如该目录非空则抛出异常
removedirs(path) 递归删除目录,从子目录到父目录逐层尝试删除,遇到目录埋空则抛出异常.
rename(old,new) 将文件old重命名为new
system(command) 运行系统的shell命令
2.支持路径操作中常用到的一些定义,支持所有平台
os.curdir 指代当前目录(‘.’)
os.pardir 指代上一级目录(‘..’)
os.sep 输出操作系统特定的路径分隔符(win下为’\’, linux下为’/’ )
os.linesep 当前平台使用的行符, (win下为 ‘\r’ ‘\n’ , linux 下为 ‘\n’)
os.name 指代当前使用的操作系统(包括:’posix’, ‘nt’, ‘mac’, ‘os2’, ‘ce’, ‘java’)
3.os.path模块中关于路径常用的函数使用方法
basename(path) 去掉目录路径,单独返回文件名
dirname(path) 去掉文件名,单独返回路径
join(path1[,path2[,…]]) 将path1,path2各部分组合成一个路径名
split(path) 分割文件名与路径,返回(f_path,f_name)元组.如果完全使用目录,它也会将最后一个目录作为文件名分离,且不会判断文件或者目录是否存在.
splitext(path) 分离文件名与扩展名,返回(f_name, f_extension)元组
getsize(file) 返回指定文件的尺寸,单位是字节
getatime(file) 返回指定文件最近的访问时间,(浮点型秒数, 可用time模块的gmtime()或localtime函数换算)
getcthime(file) 返回指定文件的创建时间,(浮点型秒数,可用time棋块的gmtime()或localtime函数换算)
getmtime(file) 返回指定文件的最新的修改时间,((浮点型秒数,可用time棋块的gmtime()或localtime函数换算)
下面函数返回True或False
exists(path) 判断指定路径(目录或文件)是否存在
isabs(path) 判断指定路径是否为绝对路径.
isdir(path) 判断指定路径是否存在且是一个目录
isfile(path) 判断指定路径是否存在且是一个文件
islink(path) 判断指定路径是否存在且是一个符号链接
ismount(path) 判断指定路径是否存在且是一个挂载点
samefile(path1, path2) 判断path1和path2丙个路径是否指向同一个文件.
031-永久存储:一缸美味的泡菜
–read或readline方法读出来都是str.还要转换,有时还转换不了(对象函数什么的)
–用pickle模块,把Python所有的对象用二进制方法存储在文件中.存放:picking 读取:unpickling
例:
import pickle
my_list = [1,2,3.14,’a’,[‘list’]]
pickle_file = open(‘my_list.pkl’,’wb’) # 后缀随意 ,写入方式wb
pickle.dump(my_list, pickle_file)
pickle_filr.close()
下面是读取
pickle_file = open(‘my_list.pkl’,’rb’)
my_list2 = pickle.load(pickle_file)
print(my_list2)
如果代码中有很长的内容例如天气,地址信息就可以先腌起来,用的时候从文件中读取就行了,不有写在代码中,使代码那么长.
032-异常处理1 Exception
–把用户想成熊孩子,随时都能搞掉你的代码.写出的代码才能安全稳定.
例:
file_name = input(‘请输入要打开的文件名:’)
f = open(file_name)
print(‘文件的内容是:’)
for each_line in f:
parint(each_line)
用户不会输入扩展名 所以会错误
1.标准异常总结
AssertionError 断言语句(‘assert’)失败 例:my_list = [] assert len(my_list)>0 会报错
AttributeError 尝试访问未知的对象属性例: my_list.lvyang 会报错
EOFError input()读取到EOF却没有接收任何数据
FloatingPointError 浮点计算错误
GeneratorExit generator.close()方法被调用的时候
ImportError 导入用模块失败的时候
IndexError 索引超出序列的范围 # 常用
KeyError 字典中查找一个不存在的关键字 # 常用
KeyboardInterrupt 用户输入中断键(Ctrl+c)
MemoryError 内存溢出(可通过删除对象释放内存)
NameError 尝试访问一个不存在的变量 # 常用
NotImplementedError 尚未实现的方法
OSError 操作系统产生的异常(例如打开一个不存在的文件) # 常用 有很多的子类
OverflowError 数值运算超出最大限制
ReferenceError 弱引用(weak reference)试图访问一个已经被垃圾回收机制回收了的对象
RuntimeError 一般的运行时错误
StopIteration 迭代器没有更多的值
SyntaxError Python的语法错误 # 常用
IndentationError 缩进错误 # 常用
TabError Tab和空格混合使用 # 常用
SystemError Python编译器系统错误
SystemExit Python编译器进程被关闭
TypeError 不同类型间的无效操作 # 常用
UnboundLocalError 访问一个未初始化的本场变量(NameError的子类)
UnicodeError Unicode相关的错误(ValueError的子类)
UnicodeEncodeError Unicode编码时的错误(UnicodeError的子类)
UnicodeDecodeError Unicode解码时的错误(UnicodeError的子类)
UnicodeTranslateError Unicode转换时的错误(UnicodeError的子类)
ValueError 传入无效的参数
ZeroDivisionError 除数为0
033-异常处理2
–捕捉异常,改正它 让代码更健壮,让用户体验更好.
–异常检测 try语句
- try excep语句
try:
检测范围
except Exception[as reason]:
出现异常(Exception)后的处理的代码
例子:
try:
int(‘abc’) # 异常1
sum = 1 +’1′ # 异常2
f = open(‘不存在的文件.txt’) # 异常3
print(f.read)
f.close()
except OSError as reason:
print(‘文件出错了\n原因是:’ + str(reason))
except (TypeErroras, OSError):
print(‘类型出错了\n原因是:’ + str(reason))
except:
print(‘出错了’) # 不管什么异常都说这个 不建议做
!! try语句一旦出现异常,剩下的语句将不会执行.
2.try finally 语句
try:
检测范围
except Exception[as reason]:
出现异常(Exception)后的处理的代码
finally:
无论如何都会被执行的代码
比如说:finally里可以写文件关闭,就不会出现数据丢失.
例:
try:
f = open(‘存在的文件.txt’,’w’)
print(f.write(‘11111’))
sum = 1 + ‘1’ # 错误!
f.close() # 上面出错了 这句没有执行
except OSError as reason:
print(‘文件出错了\n原因是:’ + str(reason))
finally:
f.close() # 无论如何都会执行这句
3.raise语句
–让代码自己引发异常
raise ZeroDivisionError(‘异常’)
034-丰富的else语句及简洁的whith语句
–可以和if搭配:要么怎样,要么不怎样.
–可以和while搭配:干完了能怎样,干不完就别想怎样.
–也可以和try异常处理搭配:没有问题那就干吧.
但是用着太麻烦所以有了with:
try:
with open(‘data.txt’,’w’) as f: # with会自动关闭文件!
for each_line in f :
print(each_line)
except OSError as reason:
print(‘error’)
035-图形用户界面入门 EasyGui
官网
–http://easygui.sourceforge.net (要FQ)
官方教学文档:
-easygui-docs-0.96\tutorial\index.html
小甲鱼翻译的文档:
–http:////bbs.fishc.com/thread-46069-1-1.html
1.安装
–>cmd–>cd Desktop–>cd easygui-docs-0.96–>’c:\python33\python.exe setup.py install(调用python3,运行setup.py,加参数install)’
–>被安装在:python3-lib-site-packages
2.导入
import easygui # 用时要easygui.msgbox()
或
from easygui import * # 用时要msgox() 易导致变量名覆盖重复
或
import easygui as g # 用时 g.msgbox() 推荐用这个.
3.使用easygui
例子:
import easygui as g
import sys
while 1:
g.msgbox(‘欢迎进入第一个界面小游戏’)
msg = ‘想要哪些呢?’
title = ‘小游戏互动’
choices = [‘1′,’2′,’3′,’4’]
choice = g.choicebox(msg, title, choices)
g.msgbox(‘你选择的是:’ + str(choice),’结果’)
msg = ‘你希望重新开始小游戏吗?’
title = ‘请选择’
if g.ccbox(msg, title):
pass
else:
sys.exit(0)
!!建议不要在IDLE上运行EasyGui
EasyGui是运行在Tkinter上并拥有自身的事件循环,而IDLE也是
Tkinter写的一个应用程序并也拥有自身的事件循环.回此当两者
同时运行的时候,有可能会发生冲突,且带来不可预测的结果,因此
如果你发现你的RasyGui程序有这样的问题,请尝试在IDLE外去运
行你的程序
4.修改源代码
choicebox 找到定义位置 root_width 这类的 设置选择界面的大小
PROPORTIONAL_FONT 找到 改字体
036-类和对象
–封装(数据,函数)
–对象也是封闭,模拟真实世界
–从表态分类,从动作分类.,也就是属性和方法.属性+方法=对象
–属性可以理解为变量,方法可能理解为函数.
–类,实例对象. 类就是为了量产对象.
–类命名大写字母开头
OO的特征:OO = Object Oriented 面向对象
1.封闭 ,信息隐蔽技术.
2.继承,继承别的类的方法和属性
3.多态,不同对象对同一方法响应的行动.
37-类和对象1
1.self是什么?
–定义的时候必须写在函数的第一个参数
例:
class Ball:
def setName(self, name):
self.name = name
def kick(self):
print(‘我叫s%,谁踢我…’% self.name)
a = Ball
a.setName(‘1’)
b = Ball
b.setName(‘2’)
c = Ball
c.setName(‘3’)
–>a.kick()
–>b.kick()
–>c.kick()
2.魔法方法
init(self) 构造方法
例:
class Ball:
def init(self, name)
self.name =name
def kick(self):
print(‘我叫s%,谁踢我…’% self.name)
b = Ball(‘222’)
b.kick()
3.公有和私有
–对象的属性和方法都是公有的
例:
class Person:
name = ‘xx’
p = Person()
p.name
私有:
在Python中定义私有变量只需要在变量名或函数名前加上’__’两个下划线,
那么这个函数或变量就会为私有的了.
class Person:
__name = ‘xx’
p = Person()
p.name # 就调用不出来了.须要加上下面的语句
def getName(self):
return self.__name
p.getName() # 这样就可以调用
其实Python把__name改为了p._person__name来存储,所以找不到了.
039-对象:继承
–对于相似的类,就可以继承
语法: class 类名(父类名):
例:
class Parent(object):
def hello(self):
print(‘正在调用父类方法’)
class Child(Parent):
p = Person
p.hello()
c = Child()
c.hello()
!!如果子类中定义与父类同名的方法或属性,则会自动覆盖浆糊对应的方法或属性.
class Child(Parent):
def hello(self):
print(‘正在调用子类的方法…’)
这样就会覆盖掉子类的方法.
例:
import random as r
class Fish:
def init(self):
self.x = r.randint(0, 10)
self.y = r.randint(0, 10)
def move(self):
self.x -= 1
print(‘我的位置是:’,self.x, self.y)
class Goldfish(Fish):
pass
class Carp(Fish):
pass
class Salmon(Fish):
pass
class Shark(Fish):
def init(self):
self.hungry = True
def eat(self):
if self.hungry:
print(‘吃吃吃吃吃~~’)
else:
print(‘我特么不饿~~~’)
开始调用:
fish = Fish()
fish.move()
fish.move()
goldfish = Goldfish()
goldfish.move()
goldfish.move()
shark = Shark()
shark.eat()
shark.eat()
shark.move() # 这样会出错,因为子类的 def__int__(self)覆盖了父类的def__init__方法所以没有坐标了.
所以就要腹用如下方法:
-调用未绑定的父类方法
在__init__下加入:
Fish.__init__(self) # 这就是未绑定的父类方法.这里的self代表shark
-使用super函数
只要写 super().__init__() 就可以了. 这种更方便好用.
好处是不用给出父类的名子
!!#!#!#!#!!这里没听懂!!!!
多重继承:
class Base1:
def foo1(self):
print(‘1’)
class Base2:
def foo2(self):
print(‘2’)
class Base3(Base1, Base2)
pass
c = Base3()
c.foo1
c.foo2
上面就是多重继承,但是如果不是已经明确的了解就不要使用.
多重继承容易导致不可预见的BUG,对于程序来讲不可预的BUG几乎就是致命的.
40-类和对象:拾遗
–现在要求定义一个类,叫水池,水池里要有乌龟和鱼.
–组合:把几下横向的类 组合到一起
class Turtle:
def __init(self, x):
self.num = x
class Fish:
def init(self,x):
self.num = x
class Pool:
def init(self, x, y):
self.turtle = Turtle(x)
self.fish = Fish(y)
def print_num(self):
print(‘水池里共有%d只乌龟,小鱼%d条’%(self.turtle.num, self.fish.num)
下面开始调用:
pool = Pool(1, 10)
pool.print_num()
类,类对象和实例对象:
–是三个不同的物种
class C:
count = 0
a = C()
b = C()
c = C()
a.count –> 0
b.count –> 0
c.count –> 0
c.count += 10 –> c.count –> 10 # 这里更改一下c的值
b.count –> 0 # c的值变了 但是a,b没有变
a.count –> 0
C.count += 100
a.count –> 100
b.count –> 100
c.count –> 10
028-文件因为以永恒1.用open打开文件:打开的模式有:’r’-以只读方式打开文件(默认)’w’-以写入的方式打开 文件,会覆盖已存在的文件’x’-如果文件已经存在,使用此模式打开将引发异常’a’-0双写入模式撕开,如果文件存在,则在末尾追加写入’b’-以二进制模式打开文件’t’-以文本模式打开(默认)’+’-可读写模式(可添加到其他模式中使用)’U’-通用换行符支持.例:open(‘e:\test.txt’) # 两个\因为要转译(可以用u”),打开方式用了默认所以就不用写f = open(‘e:\test.txt’) # 赋值给一个对象2.文件对象的方法:f.close() 关闭文件f.read(size = -1) 从文件读取size个字符,当未给定size或给定负值的时候, 读取剩余的所有字符,然后作为字符串返回.指针移动到文件的不可末尾.f.readline() 以写入模式打开,如果文件存在,则在末尾追加写入f.write(str) 将字符串str写入文件f.writelines(seq) 向文件写入字符串序列seq,seq应该是一个返回字符串的可迭代对象.f.seek(offset,from) 在文件中移动文件指针,从from(0代表文件起始位置,1代表当前位置,2代表文件末尾)偏移offset个字节f.tell() 返回当前在文件中的位置.可以用list(f)把文件直接转换成为一个列表.3.读取文件对象中的内容:for i in f: (推荐这种方法)print(i)4.文件的写入:打开方式一定要是 ‘a’或’w’f = open(‘e:\test.txt’,’w’)f.write(‘xxoo’)f.close
029-文件:一个任务例1:def save_file(goy, girl, count):file_name_boy = ‘boy_’ + str(count) + ‘.txt’filr_name_girl = ‘girl’ + str(count) + ‘.txt’
boy_file = open(file_name_body, ‘w’)girl_file = open(file_name_girl, ‘w’)
boy_file.writelines(boy)boy_file.writelines(girl)
boy_file.close()girl_file.close()def split_file(file_name):f= open(‘test.txt’)boy = []girl = []count = 1 # 计算
for each_line in f:if each_line[:6] != ‘====’: # 前6个字符是等号# 这里我们进行字符串分割(role, line_spoken) = each_line.split(‘:’, 1)if role == ‘小甲鱼’:boy.append(line_spoken)if role == ‘小客服’:girl.append(line_spoken)else:# 文件的保存save_file(boy, girl, count)boy = []boy = []count += 1
save_file(boy, girl, count)
f.close()
split_file(‘recode.txt’)
030-文件系统:介绍一个高大上的东西–模块:就是可用代码段的打包,用import引入.是一个包含你所有你定义的函数和变量的文件后缀是.py–OS(Operating System)模块:操作系统.os模块集成了windows,mac os,linux,unix等等的文件系统模块.非常友好.1.os模块的函数:先导入 import osgetcwd() 返回当前工作目录chdir(path) 改变工作目录listdir(path=’.’) 列举当前目录中的文件名(‘.’表示当前目录,’..’表示上一级目录)mkdir(path) 创建单层目录,如该目录已存在抛出异常makedirs(path) 递归创建多层目录,如该目录已存在抛出异常,注意:’e:\a\b’和’e:\a\c’并不冲突remove(path) 删除文件rmdir(path) 删除单层目录,如该目录非空则抛出异常removedirs(path) 递归删除目录,从子目录到父目录逐层尝试删除,遇到目录埋空则抛出异常.rename(old,new) 将文件old重命名为newsystem(command) 运行系统的shell命令2.支持路径操作中常用到的一些定义,支持所有平台os.curdir 指代当前目录(‘.’)os.pardir 指代上一级目录(‘..’)os.sep 输出操作系统特定的路径分隔符(win下为’\’, linux下为’/’ )os.linesep 当前平台使用的行符, (win下为 ‘\r’ ‘\n’ , linux 下为 ‘\n’)os.name 指代当前使用的操作系统(包括:’posix’, ‘nt’, ‘mac’, ‘os2’, ‘ce’, ‘java’)
3.os.path模块中关于路径常用的函数使用方法basename(path) 去掉目录路径,单独返回文件名dirname(path) 去掉文件名,单独返回路径join(path1[,path2[,…]]) 将path1,path2各部分组合成一个路径名split(path) 分割文件名与路径,返回(f_path,f_name)元组.如果完全使用目录,它也会将最后一个目录作为文件名分离,且不会判断文件或者目录是否存在.splitext(path) 分离文件名与扩展名,返回(f_name, f_extension)元组getsize(file) 返回指定文件的尺寸,单位是字节getatime(file) 返回指定文件最近的访问时间,(浮点型秒数, 可用time模块的gmtime()或localtime函数换算)getcthime(file) 返回指定文件的创建时间,(浮点型秒数,可用time棋块的gmtime()或localtime函数换算)getmtime(file) 返回指定文件的最新的修改时间,((浮点型秒数,可用time棋块的gmtime()或localtime函数换算)下面函数返回True或Falseexists(path) 判断指定路径(目录或文件)是否存在isabs(path) 判断指定路径是否为绝对路径.isdir(path) 判断指定路径是否存在且是一个目录isfile(path) 判断指定路径是否存在且是一个文件islink(path) 判断指定路径是否存在且是一个符号链接ismount(path) 判断指定路径是否存在且是一个挂载点samefile(path1, path2) 判断path1和path2丙个路径是否指向同一个文件.
031-永久存储:一缸美味的泡菜–read或readline方法读出来都是str.还要转换,有时还转换不了(对象函数什么的)–用pickle模块,把Python所有的对象用二进制方法存储在文件中.存放:picking 读取:unpickling例:import picklemy_list = [1,2,3.14,’a’,[‘list’]]pickle_file = open(‘my_list.pkl’,’wb’) # 后缀随意 ,写入方式wbpickle.dump(my_list, pickle_file)pickle_filr.close()# 下面是读取pickle_file = open(‘my_list.pkl’,’rb’)my_list2 = pickle.load(pickle_file)print(my_list2)# 如果代码中有很长的内容例如天气,地址信息就可以先腌起来,用的时候从文件中读取就行了,不有写在代码中,使代码那么长.
032-异常处理1 Exception–把用户想成熊孩子,随时都能搞掉你的代码.写出的代码才能安全稳定.例:file_name = input(‘请输入要打开的文件名:’)f = open(file_name)print(‘文件的内容是:’)for each_line in f:parint(each_line)# 用户不会输入扩展名 所以会错误
1.标准异常总结AssertionError 断言语句(‘assert’)失败 例:my_list = [] assert len(my_list)>0 会报错AttributeError 尝试访问未知的对象属性例: my_list.lvyang 会报错EOFError input()读取到EOF却没有接收任何数据FloatingPointError 浮点计算错误GeneratorExit generator.close()方法被调用的时候ImportError 导入用模块失败的时候IndexError 索引超出序列的范围 # 常用KeyError 字典中查找一个不存在的关键字 # 常用 KeyboardInterrupt 用户输入中断键(Ctrl+c)MemoryError 内存溢出(可通过删除对象释放内存)NameError 尝试访问一个不存在的变量 # 常用NotImplementedError 尚未实现的方法 OSError 操作系统产生的异常(例如打开一个不存在的文件) # 常用 有很多的子类OverflowError 数值运算超出最大限制ReferenceError 弱引用(weak reference)试图访问一个已经被垃圾回收机制回收了的对象RuntimeError 一般的运行时错误StopIteration 迭代器没有更多的值 SyntaxError Python的语法错误 # 常用IndentationError 缩进错误 # 常用TabError Tab和空格混合使用 # 常用SystemError Python编译器系统错误SystemExit Python编译器进程被关闭TypeError 不同类型间的无效操作 # 常用UnboundLocalError 访问一个未初始化的本场变量(NameError的子类)UnicodeError Unicode相关的错误(ValueError的子类)UnicodeEncodeError Unicode编码时的错误(UnicodeError的子类)UnicodeDecodeError Unicode解码时的错误(UnicodeError的子类)UnicodeTranslateError Unicode转换时的错误(UnicodeError的子类)ValueError 传入无效的参数ZeroDivisionError 除数为0
033-异常处理2 –捕捉异常,改正它 让代码更健壮,让用户体验更好.–异常检测 try语句1. try excep语句try:检测范围except Exception[as reason]:出现异常(Exception)后的处理的代码例子:try:int(‘abc’) # 异常1sum = 1 +’1′ # 异常2 f = open(‘不存在的文件.txt’) # 异常3print(f.read)f.close()except OSError as reason:print(‘文件出错了\n原因是:’ + str(reason))except (TypeErroras, OSError):print(‘类型出错了\n原因是:’ + str(reason))except:print(‘出错了’) # 不管什么异常都说这个 不建议做!! try语句一旦出现异常,剩下的语句将不会执行.2.try finally 语句try:检测范围except Exception[as reason]:出现异常(Exception)后的处理的代码finally:无论如何都会被执行的代码比如说:finally里可以写文件关闭,就不会出现数据丢失.例:try:f = open(‘存在的文件.txt’,’w’)print(f.write(‘11111’))sum = 1 + ‘1’ # 错误!f.close() # 上面出错了 这句没有执行except OSError as reason:print(‘文件出错了\n原因是:’ + str(reason))finally:f.close() # 无论如何都会执行这句3.raise语句–让代码自己引发异常raise ZeroDivisionError(‘异常’)
034-丰富的else语句及简洁的whith语句–可以和if搭配:要么怎样,要么不怎样.–可以和while搭配:干完了能怎样,干不完就别想怎样.–也可以和try异常处理搭配:没有问题那就干吧.但是用着太麻烦所以有了with:try:with open(‘data.txt’,’w’) as f: # with会自动关闭文件!for each_line in f :print(each_line)except OSError as reason:print(‘error’)035-图形用户界面入门 EasyGui官网–http://easygui.sourceforge.net (要FQ)官方教学文档:-easygui-docs-0.96\tutorial\index.html小甲鱼翻译的文档:–http:////bbs.fishc.com/thread-46069-1-1.html1.安装–>cmd–>cd Desktop–>cd easygui-docs-0.96–>’c:\python33\python.exe setup.py install(调用python3,运行setup.py,加参数install)’–>被安装在:python3-lib-site-packages2.导入 import easygui # 用时要easygui.msgbox()或from easygui import * # 用时要msgox() 易导致变量名覆盖重复或import easygui as g # 用时 g.msgbox() 推荐用这个.3.使用easygui例子:import easygui as gimport syswhile 1:g.msgbox(‘欢迎进入第一个界面小游戏’)msg = ‘想要哪些呢?’title = ‘小游戏互动’choices = [‘1′,’2′,’3′,’4’]choice = g.choicebox(msg, title, choices)g.msgbox(‘你选择的是:’ + str(choice),’结果’)msg = ‘你希望重新开始小游戏吗?’title = ‘请选择’if g.ccbox(msg, title):passelse:sys.exit(0)!!建议不要在IDLE上运行EasyGuiEasyGui是运行在Tkinter上并拥有自身的事件循环,而IDLE也是Tkinter写的一个应用程序并也拥有自身的事件循环.回此当两者同时运行的时候,有可能会发生冲突,且带来不可预测的结果,因此如果你发现你的RasyGui程序有这样的问题,请尝试在IDLE外去运行你的程序4.修改源代码choicebox 找到定义位置 root_width 这类的 设置选择界面的大小 PROPORTIONAL_FONT 找到 改字体
036-类和对象–封装(数据,函数)–对象也是封闭,模拟真实世界–从表态分类,从动作分类.,也就是属性和方法.属性+方法=对象–属性可以理解为变量,方法可能理解为函数.–类,实例对象. 类就是为了量产对象.–类命名大写字母开头OO的特征:OO = Object Oriented 面向对象1.封闭 ,信息隐蔽技术.2.继承,继承别的类的方法和属性3.多态,不同对象对同一方法响应的行动.
37-类和对象11.self是什么? –定义的时候必须写在函数的第一个参数例:class Ball:def setName(self, name):self.name = namedef kick(self):print(‘我叫s%,谁踢我…’% self.name)a = Balla.setName(‘1’)b = Ballb.setName(‘2’)c = Ballc.setName(‘3’)–>a.kick()–>b.kick()–>c.kick()2.魔法方法__init(self) 构造方法例:class Ball:def init(self, name)self.name =namedef kick(self):print(‘我叫s%,谁踢我…’% self.name)b = Ball(‘222’)b.kick()3.公有和私有–对象的属性和方法都是公有的例:class Person:name = ‘xx’p = Person()p.name私有:在Python中定义私有变量只需要在变量名或函数名前加上’’两个下划线,那么这个函数或变量就会为私有的了.class Person:__name = ‘xx’p = Person()p.name # 就调用不出来了.须要加上下面的语句def getName(self):return self.__namep.getName() # 这样就可以调用
其实Python把__name改为了p._person__name来存储,所以找不到了.
039-对象:继承–对于相似的类,就可以继承语法: class 类名(父类名):例:class Parent(object):def hello(self):print(‘正在调用父类方法’)class Child(Parent):
p = Personp.hello()c = Child()c.hello()!!如果子类中定义与父类同名的方法或属性,则会自动覆盖浆糊对应的方法或属性.class Child(Parent):def hello(self):print(‘正在调用子类的方法…’)# 这样就会覆盖掉子类的方法.
例:import random as rclass fish:def init(self):self.x = r.randint(0, 10)self.y = r.randint(0, 10)def move(self):self.x -= 1print(‘我的位置是:’,self.x, self.y)class Goldfish(Fish):pass
class Carp(Fish):pass
class Salmon(Fish):pass
class Shark(Fish):def init(self):self.hungry = Truedef eat(self):if self.hungry:print(‘吃吃吃吃吃’)else:print(‘我特么不饿~’)开始调用:fish = Fish()fish.move()fish.move()goldfish = Goldfish()goldfish.move()goldfish.move()shark = Shark()shark.eat()shark.eat()shark.move() # 这样会出错,因为子类的 def__int__(self)覆盖了父类的def__init__方法所以没有坐标了.所以就要腹用如下方法:-调用未绑定的父类方法在__init__下加入:Fish.__init__(self) # 这就是未绑定的父类方法.这里的self代表shark-使用super函数只要写 super().__init__() 就可以了. 这种更方便好用.好处是不用给出父类的名子!!#!#!#!#!!这里没听懂!!!!多重继承:class Base1:def foo1(self):print(‘1’)class Base2:def foo2(self):print(‘2’)class Base3(Base1, Base2)passc = Base3()c.foo1c.foo2上面就是多重继承,但是如果不是已经明确的了解就不要使用.多重继承容易导致不可预见的BUG,对于程序来讲不可预的BUG几乎就是致命的.
40-类和对象:拾遗 –现在要求定义一个类,叫水池,水池里要有乌龟和鱼.–组合:把几下横向的类 组合到一起class Turtle:def __init(self, x):self.num = xclass fish:def init(self,x):self.num = xclass Pool:def init(self, x, y):self.turtle = Turtle(x)self.fish = Fish(y)def print_num(self):print(‘水池里共有%d只乌龟,小鱼%d条’%(self.turtle.num, self.fish.num)下面开始调用:pool = Pool(1, 10)pool.print_num()
类,类对象和实例对象:–是三个不同的物种class C:count = 0a = C()b = C()c = C()a.count –> 0b.count –> 0c.count –> 0c.count += 10 –> c.count –> 10 # 这里更改一下c的值b.count –> 0 # c的值变了 但是a,b没有变a.count –> 0C.count += 100 a.count –> 100b.count –> 100c.count –> 10
内容总结
以上是互联网集市为您收集整理的小甲鱼Python3笔记全部内容，希望文章能够帮你解决小甲鱼Python3笔记所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。