000-愉快的开始

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

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

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

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

1.安装

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.缩进很重要! 末尾有冒号,回车后会自动缩进.

1. 一个等号是赋值,两个等号是判断是否等于.

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:]

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+’叫做实参,因为他是具休的参数值.’)

1. 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语句

1. 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