Python3课件知识点整理

第一章:Python及基础语法

一.Python简介

Python是一种跨平台的计算机程序设计语言。 
是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，
越多被用于独立的、大型项目的开发。

二.Python应用领域

Python是一种解释型脚本语言，可以应用于以下领域：
Web 和 Internet开发
科学计算和统计
人工智能
桌面界面开发
软件开发
后端开发
网络爬虫

三.Python发展历程

Python的创始人为荷兰人吉多·范罗苏姆 （Guido van Rossum）。
1989年圣诞节期间，在阿姆斯特丹，Guido为了打发圣诞节的无趣，
决心开发一个新的脚本解释程序，作为ABC 语言的一种继承。
之所以选中Python（大蟒蛇的意思）作为该编程语言的名字，
是取自英国20世纪70年代首播的电视喜剧《蒙提.派森的飞行马戏团》
（Monty Python's Flying Circus）。

四.特点

1. 简单：

Python是一种代表简单主义思想的语言。阅读一个良好的Python程序就感觉像是在读英语一样。它使你能够专注于解决问题而不是去搞明白语言本身。
易学：Python极其容易上手，因为Python有极其简单的说明文档。
速度快：Python 的底层是用 C 语言写的，很多标准库和第三方库也都是用 C 写的，运行速度非常快。

2. 免费、开源：

Python是FLOSS（自由/开放源码软件）之一。使用者可以自由地发布这个软件的拷贝、阅读它的源代码、对它做改动、把它的一部分用于新的自由软件中。FLOSS是基于一个团体分享知识的概念。
高层语言：用Python语言编写程序的时候无需考虑诸如如何管理你的程序使用的内存一类的底层细节。

3. 可移植性：

由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。这些平台包括Linux、Windows、FreeBSD、Macintosh、Solaris、OS/2、Amiga、AROS、AS/400、BeOS、OS/390、z/OS、Palm OS、QNX、VMS、Psion、Acom RISC OS、VxWorks、PlayStation、Sharp Zaurus、Windows CE、PocketPC、Symbian以及Google基于linux开发的android平台。

4. 解释性：

一个用编译性语言比如C或C++写的程序可以从源文件（即C或C++语言）转换到一个你的计算机使用的语言（二进制代码，即0和1）。这个过程通过编译器和不同的标记、选项完成。
运行程序的时候，连接/转载器软件把你的程序从硬盘复制到内存中并且运行。而Python语言写的程序不需要编译成二进制代码。你可以直接从源代码运行 程序。
在计算机内部，Python解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。这使得使用Python更加简单。也使得Python程序更加易于移植。

5. 面向对象：

Python既支持面向过程的编程也支持面向对象的编程。在“面向过程”的语言中，程序是由过程或仅仅是可重用代码的函数构建起来的。在“面向对象”的语言中，程序是由数据和功能组合而成的对象构建起来的。

6. 可扩展性：

如果需要一段关键代码运行得更快或者希望某些算法不公开，可以部分程序用C或C++编写，然后在Python程序中使用它们。

7. 可嵌入性：

可以把Python嵌入C/C++程序，从而向程序用户提供脚本功能。

8. 丰富的库：

Python标准库确实很庞大。它可以帮助处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。这被称作Python的“功能齐全”理念。除了标准库以外，还有许多其他高质量的库，如wxPython、Twisted和Python图像库等等。

9. 规范的代码：

Python采用强制缩进的方式使得代码具有较好可读性。而Python语言写的程序不需要编译成二进制代码。

10. 缺点

单行语句和命令行输出问题：很多时候不能将程序连写成一行，如import sys;for i in sys.path:print i。而perl和awk就无此限制，可以较为方便的在shell下完成简单程序，不需要如Python一样，必须将程序写入一个.py文件。
独特的语法
这也许不应该被称为局限，但是它用缩进来区分语句关系的方式还是给很多初学者带来了困惑。即便是很有经验的Python程序员，也可能陷入陷阱当中。
运行速度慢：这里是指与C和C++相比。

五.开发工具

●IDLE：Python内置IDE (随python安装包提供)
●PyCharm [9] ：详见百度百科PyCharm，由著名的JetBrains公司开发，带有一整套可以帮助用户在使用Python语言开发时提高其效率的工 具，比如调试、语法高亮、Project管理、代码跳转、智能提示、自动完成、单元测试、版本控制。此外，该IDE提供了一些高级功能，以用于支持Django框架下的专业Web开发。
●Komodo和Komodo Edit：后者是前者的免费精简版
●Spyder：安装Anaconda自带的高级IDE
●PythonWin：ActivePython或pywin32均提供该IDE，仅适用于Windows
●SPE（Stani’s Python Editor）：功能较多的自由软件，基于wxPython
●Ulipad：功能较全的自由软件，基于wxPython；作者是中国Python高手limodou
●WingIDE：可能是功能最全的IDE，但不是自由软件(教育用户和开源用户可以申请免费key)
●Eric：基于PyQt的自由软件，功能强大。全名是：The Eric Python IDE
●DrPython
●PyScripter：使用Delphi开发的轻量级的开源Python IDE， 支持Python2.6和3.0。
●PyPE：一个开源的跨平台的PythonIDE。
●bpython： 类Unix操作系统下使用curses库开发的轻量级的Python解释器。语法提示功能。
●eclipse + pydev插件：方便调试程序
●emacs：自带python支持，自动补全、refactor等功能需要插件支持
●Vim: 最新7.3版编译时可以加入python支持，提供python代码自动提示支持
●Visual Studio 2003 + VisualPython：仅适用Windows，已停止维护，功能较差
●SlickEdit
●Visual Studio 2010 + Python Tools for Visual Studio
●TextMate
●Netbeans IDE
●Sublime
●ipython
另外，诸如Notepad++、EditPlus、UltraEdit等通用的程序员文本编辑器软件也能对Python代码编辑提供一定的支持，比如代码自动着色、注释快捷键等，但是否够得上集成开发环境的水平，尚有待评估。

(本课件知识点整理代码使用Visual Studio 2019)

六.Python中的注释

注释:给程序员看的,用来解释说明代码的,相当于做笔记
#:单行注释 可以注释掉#以后的当前行
'''或""":多行注释 可以注释多行

七.第一个程序

''' 
    python 里面不需要程序的入口main方法 函数
'''

"""
    一般在其他语言中要想执行
    都必须有程序的入口main方法
"""
print("Hello World!")#输出一句HelloWorld
age = 10;
ages = + \
    20;  #语句换行要使用\来连接
print("age的值为:",age,"\nages的值为:",ages);
    #缩进不一致会导致报错
    #print("age的值为:",age,"\nages的值为:",ages);

八.python 与 其他语言不同

其他语言使用{}来表示代码块
而python使用缩进的空格数来表示
同一个代码块必须包含相同的缩进空格数

九.多行语句注意事项

Python通常一行写完一条语句,如果语句过长要换行
我们需要使用\来实现多行语句连接
在[],{},()中的多行语句,不需要

第二章:变量和数据类型

一.变量

可变的值 格式为 变量名 = 值
Python 命名规则：
1.标识符是由字母（A~Z 和 a~z）、下划线和数字组成，但第一个字符不能是数字。
2.标识符不能和 Python 中的保留字相同。
3.Python中的标识符中，不能包含空格、@、% 以及 $ 等特殊字符。

二.数据类型

这里所说的类型是内存中对象的类型,实际使用中不需要声明类型

1.数字类型4种 ：整数、布尔型、浮点数和复数。

	int (整数)
		Python 3.x 只用 int 一种类型存储整数，
		但是 Python 2.x 会使用 long 类型来存储较大的整数。
	bool (布尔) 
		python2中没有 是用0表示false的 
	float (浮点数) 
	complex (复数)
		复数由实部（real）和虚部（imag）构成，在 Python 中，
		复数的虚部以j或者J作为后缀，具体格式为：
		 1 + 2j、 1.1 + 2.2j

	可以使用isinstance(变量,类型)或type(变量)来判断数据类型

2.字符串类型
	若干个字符的集合就是一个字符串（String）。
	Python 中的字符串必须由双引号" "或者单引号' '包围
	"字符串内容"      '字符串内容'

	字符串换行 需要加 \  表达式的换行也一样

	python长字符串 和 注释类似
		使用三个单引号或者双引号可以对多行内容进行注释，
		这其实是 Python 长字符串的写法。所谓长字符串，
		就是可以直接换行（不用加反斜杠\）书写的字符串。
		如果内容不赋值给变量那就是注释
	 注意:在长字符串中放置单引号或者双引号不会导致解析错误。

	原始字符串:使内容保持原有的样子使转义字符不转义
	 字符串的开头加上r前缀，就变成了原始字符串

3.bytes 类型
	bytes 是 Python 3.x 新增的类型，在 Python 2.x 中是不存在的。
	bytes类型以字节序列的形式（二进制形式）来存储数据

4.数据类型转换
	常用数据类型转换函数
	函 数			作 用
	int(x)		将 x 转换成整数类型
	float(x)	将 x 转换成浮点数类型
	complex(real，[,imag])	创建一个复数
	str(x)		将 x 转换为字符串
	repr(x)		将 x 转换为表达式字符串
	eval(str)	计算在字符串中的有效 Python 表达式，并返回一个对象
	chr(x)		将整数 x 转换为一个字符
	ord(x)		将一个字符 x 转换为它对应的整数值
	hex(x)		将一个整数 x 转换为一个十六进制字符串
	oct(x)		将一个整数 x 转换为一个八进制的字符串

	需要注意的是，在使用类型转换函数时，提供给它的数据必须是有意义的。
		例如，int() 函数无法将一个非数字字符串转换成整数：

#变量的定义
a = 10
b = 5.5
c = True
d = 4+3j
print("a=",a,"b=",b,"c=",c,"d=",d)

#变量值的修改
a = 20
print("a修改后的值为:",a)

#类型测试
print(isinstance(a,int))
print(isinstance(b,float))
print(isinstance(c,bool))
print(isinstance(d,complex))
print(type(a))
print(type(b))
print(type(c))
print(type(d))

#数字分隔符_
e = 1_234_567_89
print("数字分隔符不会影响数字本身的值:",e)

#小数浮点数
f1 = 12.5
print("f1的值为:: ", f1)
f2 = 0.34557808421257003
#根据浮点数的长度和大小适当的舍去
print("f2的值为:: ", f2)
f3 = 0.0000000000000000000000000847
#根据浮点数的长度采用科学计数法
print("f3的值为:: ", f3)
f4 = 345679745132456787324523453.45006
print("f4的值为:: ", f4)
#即舍去了一部分又采用了科学计数
f5 = 12e4
print("f5的值为:: ", f5)
#结果看似整数但依然是小数类型
f6 = 12.3 * 0.1
print("f6的值为:: ", f6)
#结果很明显是 1.23，但是 print 的输出却不精确
#因为小数在内存中是以二进制形式存储的,
#小数点后面的部分在转换成二进制时很有可能是一串无限循环的数字，
#无论如何都不能精确表示
#所以小数的计算结果一般都是不精确的。

#布尔类型注意事项
#布尔类型可以当做整数来对待，
#即 True 相当于整数值 1，False 相当于整数值 0
#实际应用中不要这么用
b1 = True
print("True+1的结果为:",b1+1)

#字符串
str1 = "HelloWorld"
print("str1的值为:",str1)
str2 = 'HelloWorld'
print("str2的值为:",str2)

#字符串中包含引号的情况
#str3 = 'I'm a boy' #会导致语法错误
#在引号前面添加反斜杠\就可以对引号进行转义
str3 = 'I\'m a boy'
print("str3的值为:",str3)
#或使用不同的引号
str4 = "I\'m a boy"
print("str4的值为:",str4)
str5 = 'bool类型中"True"是关键字'
print("str5的值为:",str5)

#字符串换行
str6 = "字符串换行的话需要加\
才可以,斜杠要放在上一行"
print("str6的值为:",str6)

#长字符串
"""这里的内容如果被赋值给变量那么就相当于是注释"""
str7 = """赋值给变量后就成了字符串"""
print("str7长字符串内容输出:",str7)

#原始字符串
str8 = "D:\work\test\next.txt"
print("str8的值为:",str8)
#以上内容被转义了
str9 = r"D:\work\test\next.txt"
print("str9的值为:",str9)
#如果输出D:\work\test\形式
str10 = "D:\work\test\\"
print("str10的值为:",str10)
#以上这样还是对导致转义
str11 = r"D:\work\test""\\"
print("str11的值为:",str11)

#bytes类型(字节串)
#通过b前缀将字符串转换成 bytes
bt1 = b'http://www.baidu.com'
print("bt1结果为: ", bt1)
print(bt1[12])   #得到底几个  从0开始
print(bt1[7:20]) #得到从几到几
#为 bytes() 方法指定字符集
bt2 = bytes('JAVA语言是主流的语言', encoding='UTF-8')
print("bt2结果为: ", bt2)
#通过 encode() 方法将字符串转换成 bytes
bt3 = "JAVA语言是主流的语言".encode('UTF-8')
print("bt3结果为: ", bt3)
#通过 decode() 方法将 bytes 转换成字符串
bt4 = bt3.decode('UTF-8')
print("bt4结果为: ", bt4)

#数据类型转换
str12 = "123"
int(str12) #转换成功
print("str12的值为:",str12)
str13 = "123岁"
#int(str13) #转换失败
#print("str13的值为:",str13)

第三章:输入输出函数

一.输出函数print()

1.格式
print(value,value...,sep='',end='\n',file=sys.stdout,flush=False)
各个参数含义见代码演示

2.Python 转换说明符
转换说明符				解释
%d、%i			转换为带符号的十进制整数
%o				转换为带符号的八进制整数
%x、%X			转换为带符号的十六进制整数
%e				转化为科学计数法表示的浮点数（e 小写）
%E				转化为科学计数法表示的浮点数（E 大写）
%f、%F			转化为十进制浮点数
%g				智能选择使用 %f 或 %e 格式
%G				智能选择使用 %F 或 %E 格式
%c				格式化字符及其 ASCII 码
%r				使用 repr() 函数将表达式转换为字符串
%s				使用 str() 函数将表达式转换为字符串

3.指定最小输出宽度
	%10d 表示输出的整数宽度至少为 10；
	%20s 表示输出的字符串宽度至少为 20。

4.指定对其方式
	Python 支持的标志
	标志		说明
	-		指定左对齐
	+		表示输出的数字总要带着符号；正数带+，负数带-。
	0		表示宽度不足时补充 0，而不是补充空格。

5.指定小数精度
	%m.nf %.nf
	m 表示最小宽度，n 表示输出精度，.是必须存在的。

name = "张三"
age = 30
#同时输出多个变量和字符串 默认以空格分开多个变量
print("姓名是:",name,"年龄是:",age)
#指定分隔符
print("姓名是:",name,"年龄是:",age,sep='*')
#设置end 参数，指定输出之后不再换行
print(age,'\t',end="")
print(age,end="\n")
#file 参数指定print()函数的输出目标,默认值为sys.stdout
f = open("demo.txt","w")#打开文件以便写入
print('床前明月光',file=f)
print('疑似地上霜',file=f)
f.close()  #写入后关闭
#print()函数的flush参数用于控制输出缓存，
#该参数一般保持为 False 即可，这样可以获得较好的性能。

#Python 转换说明符
name = "小明"
age = 28
url = "http://www.baidu.com/"
#输出时用%来分隔不在用,
print("%s已经%d岁了，它的网址是%s" % (name, age, url))

#指定输出宽度
n = 1234567
#小于指定宽度左对齐
print("输出至少5位:%5d" % n)
#大于指定宽度空格补齐
print("输出至少10位:%10d" % n)

#指定对齐方式
n = 123456
# %09d 表示最小宽度为9，左边补0
print("输出至少9位不足补0:%09d" % n)
# %+9d 表示最小宽度为9，带上符号
print("输出至少9位带符号:%+9d" % n)

f = 140.5
# %-+010f 表示最小宽度为10，左对齐，带上符号
print("输出至少10位左对齐带符号不足补0:%-+010f" % f)

s = "Hello"
# %-10s 表示最小宽度为10，左对齐
print("输出至少10位左对齐:%-10s结束" % s)

#指定小数精度
f = 3.141592653
# 最小宽度为8，小数点后保留3位
print("最小宽度为8保留3位小数:%8.3f" % f)
# 最小宽度为8，小数点后保留3位，左边补0
print("最小宽度为8保留3位小数不足补0:%08.3f" % f)
# 最小宽度为8，小数点后保留3位，左边补0，带符号
print("最小宽度为8保留3位小数不足补0带符号:%+08.3f" % f)

二.输入函数input()

str = input(提示信息可不写)
接收的内容为字符串类型
我们可以使用 Python 内置函数将字符串转换成想要的类型，比如：
int(str) 将字符串转换成 int 类型；
float(str) 将字符串转换成 float 类型；
bool(str) 将字符串转换成 bool 类型。

关于 Python 2.x
Python 2.x 中情况就不一样了。Python 2.x 共提供了两个输入函数，
分别是 input() 和 raw_input()：
Python 2.x raw_input() 和 Python 3.x input() 效果是一样的
Python 2.x input() 它要求用户输入的内容必须符合 Python 的语法，
稍有疏忽就会出错，通常来说只能是整数、小数、复数、字符串等。

Python 2.x input() 要求用户在输入字符串时必须使用引号包围，
这有违 Python 简单易用的原则，所以 Python 3.x 取消了这种输入方式。

#字符串输入演示
a = input("请输入年龄: ")
print("接收到的a类型为:",type(a))
print("您输入的年龄为:",a)

#字符串的+被视为连接符
i = input("请输入一个数:")
j = input("请输入第二个数:")
print("您输入的数为:",i+j)
#将字符串转换成想要的类型
print("i+j的结果为:",int(i)+int(j))

第四章:运算符

一.算术运算符

	+	 -	 *	 /	 //	整除（只保留商的整数部分）	7 // 2	3
	%	取余，即返回除法的余数	7 % 2	1
	**	幂运算/次方运算，即返回 x 的 y 次方	2 ** 4	16，即 24

	Python 2.x 只提供了一种除法运算，就是/，
	它的行为和大部分编程语言中/的行为是一样的：
	当/两边都是整数时，结果始终是整数；
	如果不能除尽，就直接舍弃小数部分。
	当/两边有一个是小数时，结果始终是小数；
	如果恰好除尽，小数部分就是 0。

#正常加法运算
a=1
b=2
print("a为%d,b为%d,a+b=%d"%(a,b,a+b))
#字符串时+为连接符
c="JA"
d="VA"
print("c+d结果为:",c+d)
print("a-b结果为:",a-b)
print("a*b结果为:",a*b)
a=23 
b=5
print("a/b结果为:",a/b)
#整除只保留整数部分
print("a//b结果为:",a//b)
print("a%b结果为:",a%b)
a=2
print("a的次方为:",a**5)

二.关系运算符

> < >= <= != ==
is(判断对象是否相同) isnot(判断对象是否不相同)
== 和 is的区别
==比较两个值是否相等
is比较两个对象是否相等

print("89是否大于100：", 89 > 100)
print("24*5是否大于等于76：", 24*5 >= 76)
print("86.5是否等于86.5：", 86.5 == 86.5)
print("34是否等于34.0：", 34 == 34.0)
print("False是否小于True：", False < True)
print("True是否等于True：", True < True)

#== 和 is的区别
import time  #引入time模块
t1 = time.gmtime() # gmtime()用来获取当前时间
t2 =  time.gmtime()
print(t1 == t2) #输出True
print(t1 is t2) #输出False

三.逻辑运算符

and于   or或   not非
在 Python 中，and 和 or 不一定会计算右边表达式的值，
有时候只计算左边表达式的值就能得到最终结果。
另外，and 和 or 运算符会将其中一个表达式的值作为最终结果，
而不是将 True 或者 False 作为最终结果。

i = True
j = False
k = True
print("i and j结果为:",i and j)
print("i or j结果为:",i or j)
print("not k结果为:",not k)
a = 1
b = 2
c = 3
print("a>b and b<c结果为:",a>b and b<c)
print("a>b or b<c结果为:",a>b or b<c)
print("not a>b结果为:",not a>b)
print(100 and 200)
print(45 or 0)
print(False and 100)
print(True and 100)
print(True or 100)
print(False or 100)

四.赋值运算符

== += -= *= /= %= 

a = 1
b = 2
c = 3
c += b
print("c的值为:",c)
c -= a
print("c的值为:",c)
c *= a
print("c的值为:",c)
c /= a
print("c的值为:",c)
c %= a
print("c的值为:",c)

五.位运算符

&   |  ^(异或)  ~(非) <<左移  >>右移

"""位运算符
		&(按位与)  |(或)  ^(异或)  ~(非)  <<(左移)  >>(右移)  >>>(无符号右移)
       二进制
       	十进制转换二进制
       13 二进制    1101
       2048   1024   512   256  128  64  32  16  8  4  2  1 权 次方
       	                                      1  1  0  1
       60                               1   1  1   1   0  0  
       154						  1    0   0   1  1  0  1  0
       685                         1010101101
       1250                        10011100010
       243                         11110011
       684                         1010101100
 """
a=60;
b=13;
c=0;
print('2进制',bin(3))
print('16进制',hex(17))
print('8进制',oct(9))
print("60二进制为:",bin(60))#111100
print("13二进制为:",bin(13))#001101
c = a & b;          #相对应的位都为1是结果为1
print(c);#12
print("12二进制为:",bin(c));# 001100
c = a | b;			#相对应的位只要有一个为1结果为1
print(c);#61
print("61二进制为:",bin(c));# 111101
c = a ^ b;			#相对应的位相同为0 不同1
print(c);#49
print("49二进制为:",bin(c));# 110001
c = ~a;				#相对应的位取反
print(c);#-61
print("-61二进制为:",bin(c));# 000011
c = a<<2;
print(c);#240
print("240二进制为:",bin(c));# 11110000	
c = a>>2;
print(c);#15
print("15二进制为:",bin(c));# 0001111

六.三目运算符

c = 成立结果 if 条件 else 不成立结果

a = 2
b = 3
c = a if a>b else b
print(c)

第五章:流程控制

一.流程控制(分支语句)

if else条件语句  if如果   else否则

1. if 语句

   if 条件 : 条件成立后要做的事
   需求:如果满18输出欢迎光临
   

2. if else 语句

   if 条件 : 条件成立后要做的事
   else : 条件不成立要做的事
   需求:如果满18输出欢迎光临,否则输出禁止入内
   

#如果满18输出欢迎光临
age = int(input("请输入你的年龄："))
if age >= 18 :
    print("欢迎光临") 

print("=========================")

if age >= 18 :
    print("欢迎光临")
else :
    print("禁止入内")

1. if elif else 语句

   if 条件1 : 条件1成立后要做的事
   elif 条件2 : 条件2成立后要做的事
   ...
   else : 条件都不成立要做的事
   

#判断春1 2 3 夏4 5 6 秋7 8 9 冬10 11 12
month = int(input("请输入月份："))
print("=====第一种=====")
if month>=1 and month<=3:
    print("春")
elif month>=4 and month<=6:
    print("夏")
elif month>=7 and month<=9:
    print("秋")
elif month>=10 and month<=12:
    print("冬")
else:
    print("输入错误")

print("=====第二种=====")
if month==1 or month==2 or month==3:
    print("春")
elif month==4 or month==5 or month==6:
    print("夏")
elif month==7 or month==8 or month==9:
    print("秋")
elif month==10 or month==11 or month==12:
    print("冬")
else:
    print("输入错误")

print("=====第三种=====")
if month>=10:
    if month<=12:
        print("冬")
    else:
        print("不能大于12")
elif month>=7:
    print("秋")
elif month>=4:
    print("夏")
elif month>=1:
    print("春")
else:
    print("输入错误")

第六章:循环

一.while循环

while 条件：
	重复去做的事

i= 0
while i<5:
    print("我执行了")
    i+=1

print("=====无限循环=====")
#接收用户输入的值转换为int类型
i=int(input("请输入i的值:")) 
while i==1:
    print("无限执行")
else:
    print("条件不成立执行我")
    

二.for循环

for 临时变量 in 字符串|列表|元组|字典|集合：
	代码块

range()函数:从0开始生成数列

#定义一个列表
languages = ["C", "C++", "Perl", "Python"] 
for ls in languages:
       print(ls)

print("========================")
#range()函数 用于生成数列 从0开始
for i in range(5):
    print(i)

print("========================")
#指定生成区间
for i in range(5,10) :
    print(i)

print("========================")
#指定增量
for i in range(0, 10, 2) :
    print(i)

三.循环嵌套

for i in range(1,5):
    print("=====我是外层循环:",i)
    for j in range(1,5):
        print("我是内层循环:",j)

四.break和continue

break:跳出当前循环
continue;跳出当次循环

pass 语句:用来占位 什么都不做

#模拟50层电梯运行8 9层同一家只停8不停9
#40层以上私人住宿此电梯不上去
for i in range(1,50):
    if i==9:
        continue
    elif i==40:
        break
    print(i)

print("=================")
i=0
while i<5:
    if i==2:
        pass
        print("执行了pass块")
    print(i)
    i+=1

第七章:列表,元祖,字典,集合

一.序列

1.概念:Python 中最基本的数据结构。

字符串也是一种常见的序列，它也可以直接通过索引访问字符串内的字符。

所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，
可通过每个值所在位置的编号（称为索引从0开始）访问它们。
在使用负值作为列序中各元素的索引值时，是从 -1 开始，而不是从 0 开始。

str="Python语言"
print(str[0],"==",str[-8])
print(str[7],"==",str[-1])

2.序列切片
切片操作是访问序列中元素的另一种方法，它可以访问一定范围内的元素，
通过切片操作，可以生成一个新的序列。
序列名[开始索引 : 结束索引 : 隔几个取一次元素]
	str="Python语言"
	#取索引区间为[0,2]之间（不包括索引2处的字符）的字符串
	print(str[:2])
	#隔 1 个字符取一个字符，区间是整个字符串
	print(str[::2])
	#取整个字符串，此时 [] 中只需一个冒号即可
	print(str[:])

3.序列相加(将两个序列进行连接)
	两侧序列类型要相同
	str="今年上5年级"
	print("我是"+"张三"+str)

4.序列相乘
	Python 中，使用数字 n 乘以一个序列会生成新的序列，
	其内容为原来序列被重复 n 次的结果。例如：
	str="我是三好学生"
	print(str*3)

	比较特殊的是，列表类型在进行乘法运算时，
	还可以实现初始化指定长度列表的功能。
	例如如下的代码，将创建一个长度为 5 的列表，
	列表中的每个元素都是 None，表示什么都没有。
	#列表的创建用 []，后续讲解列表时会详细介绍
	list = [None]*5
	print(list)

5.内置函数
	函数	功能
	len()	计算序列的长度，即返回序列中包含多少个元素。
	max()	找出序列中的最大元素。注意，对序列使用 sum() 函数时，
	做加和操作的必须都是数字，不能是字符或字符串，
	否则该函数将抛出异常，因为解释器无法判定是要做连接操作
	（+ 运算符可以连接两个序列），还是做加和操作。
	min()	找出序列中的最小元素。
	list()	将序列转换为列表。
	str()	将序列转换为字符串。
	sum()	计算元素和。
	sorted()	对元素进行排序。
	reversed()	反向序列中的元素。
	enumerate()	将序列组合为一个索引序列，多用在 for 循环中。


6.在 Python 中，序列类型包括字符串、列表、元组、集合和字典，
但比较特殊的是，集合和字典不支持索引、切片、相加和相乘操作。

#序列正负值索引
str="Python语言"
print(str[0],"==",str[-8])
print(str[7],"==",str[-1])

#序列切片
str="Python语言"
#取索引区间为[0,2]之间（不包括索引2处的字符）的字符串
print(str[:2])
#隔 1 个字符取一个字符，区间是整个字符串
print(str[::2])
#取整个字符串，此时 [] 中只需一个冒号即可
print(str[:])

#序列相加
str="今年上5年级"
print("我是"+"张三"+str)

#序列相乘
str="我是三好学生 "
print(str*3)

#内置函数
str="abcdefg"
print("c" in str)       #包含
print("h" not in str)   #不包含

二.列表 list 有序序列(添加顺序)

列表:用[]括起来的一组元素 它的类型时list

可以通过 type([1,"你好"]) 来验证
数组看做是一个集装箱，列表就是一个工厂的仓库
列表会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔。
列表内的项目不必全是相同的类型。

#列表的创建
test = []  #空列表
num = [1, 2, 3, 4, 5, 6, 7, 8, 9]
name = ["张三", "李四"]
address = ["兰州", "上海", "北京"]
message = ["张三",30,60.5]

#使用索引访问列表中的某个元素
print(num[1])  #使用正数索引
print(num[-2])  #使用负数索引
#使用切片访问列表中的一组元素
print(num[3: 8])  #使用正数切片
print(num[3: 8: 2])  #指定步长
print(num[-6: -1])  #使用负数切片

#删除列表
print(message)
#实际开发中并不经常使用 del 来删除列表，
#因为 Python 自带的垃圾回收机制会自动销毁无用的列表
del message
#print(message) #删除后输出报错 提示没有定义这个列表

#使用+连接多个列表
print(name+address)

#append()方法添加元素
print(test)
test.append(1)
print(test)
#extend()方法添加元素
test.extend("2")
print(test)
#test.extend(2)#可以是元素,列表,元组等 不能是数字
#print(test) #添加数字所以报错

#insert()方法插入元素
test.insert(1,3) #指定索引位置
print(test)

#del 删除单个列表元素
#使用正数索引
print(num)
del num[2] #从前删
print(num)
#使用负数索引
del num[-2] #从后删
print(num)
del num[1: 3] #删除丛几到几
print(num)
num.pop(1) #根据索引值删
print(num)
num.pop() #删最后一个
print(num)
num.remove(1)#根据元素删
print(num)
num.clear()#清空
print(num)

#修改
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(nums)
nums[1] =22  #使用正数索引
nums[-3] = 77  #使用负数索引
print(nums)
nums[2: 4] = [33, 44]#修改元素值
print(nums)
nums[5:5] = [10,11,12]#元素超出则为插入
print(nums)
#步长为2，为第1、3个元素改值
nums[0: 3: 2] = [111, 333]
print(nums)

#查找元素
#listname.index(元素, 开始索引, 结束索引)
#开始结束索引可不写 不写为查整个列表
nums = [2, 2, 3, 4, 5, 6, 7, 8, 2]
#检索列表中的所有元素
print( nums.index(2) )
#检索3~7之间的元素
print( nums.index(5, 3, 7) )
#检索4之后的元素
print( nums.index(7, 4) )
#检索一个不存在的元素
#print( nums.index(55) ) #报错

#统计出现的次数
print("2出现了%d次" % nums.count(2))

三.元祖 tuple 有序序列(添加顺序)

元组是不可变序列。

元组操作与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ( )，列表使用方括号 [ ]

#当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号,
#否则 Python 解释器会将它视为字符串
#最后加上逗号
a =("我是元祖中一个元素",)
print(type(a))
print(a)
#最后不加逗号
b = ("我是元祖中一个元素")
print(type(b))
print(b)

#元祖不可修改但可以重新赋值
tup = (100,200,300,400)
print(tup)
#对元组进行重新赋值
tup = ('元素1',"元素2")
print(tup)

四.字典 dict

key-value的形式(键值对) 无序序列

字典（dict）是一种无序的、可变的序列，它的元素以“键值对（key-value）”
的形式存储。相对地，列表（list）和元组（tuple）都是有序的序列，
它们的元素在底层是挨着存放的。
a = {'one': 1, 'two': 2, 'three': 3}  #a是一个字典类型
type(a)#可通过type()查看类型
<class 'dict'>
格式:变量 = {'key':'value1', 'key2':'value2', ..., 'keyn':valuen}
其中key是唯一的

还可以使用 dict 字典类型提供的 fromkeys() 方法创建带有默认值的字典，具体格式为：
变量 = dict.fromkeys(list，value=None)

#创建字典
dict1 = {} #一个空字典
dict2 = {1:"asd",2:"sdf",3:"asd",1:"bhj"} #键是唯一的
print("字典2=",dict2)

#使用字符串作为key
dict3 = {'数学': 95, '英语': 92, '语文': 84}
print("字典3=",dict3)

#使用不同类型的键值
dict4 = {1:"P","2":"y",3:3,'t':4}
print("字典4=",dict4)

#使用元组和数字作为key
dict5 = {(20, 30): 'great', 30: [1,2,3]}
print("字典5=",dict5)

#使用fromkeys()方法 创建字典
#元组使用小括号( )，列表使用方括号[ ]
#列表作为key
list1 = ['语文', '数学', '英语']
dict6 = dict.fromkeys(list1, 60)
print("字典6=",dict6)

#键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
#dict7 = {['name']: '张三', 'age': 30}
#print(dict7)

#获取字典中元素个数
print("dict3字典长度=",len(dict3))
#输出字典
print("输出dict3字典:",str(dict3))
#通过键获取值
print("dict2字典中key为1的值=",dict2[1])
#print("dict2字典中key为4的值=",dict2[4])#没有则跑抛出异常

#使用get方法获取
print("dict2字典中key为2的值=",dict2.get(2))
print("dict2字典中key为4的值=",dict2.get(4,"该键不存在"))

#使用setdefault方法获取
print("dict2字典中key为2的值=",dict2.setdefault(2))
print("字典2=",dict2)#key存在那么直接返回该key对应的value
print("dict2字典中key为4的值=",dict2.setdefault(4))
print("字典2=",dict2)#key不存在那么先为该key设置默认值然后再返回该key对应的值
print("dict2字典中key为5的值=",dict2.setdefault(5,'opq'))
print("字典2=",dict2)#key不存在还可以设置指定的默认值

#判断是否存在
print("dict6中是否存在数学:",'数学' in dict6) # True

#获取内容
print("dict6的key=",dict6.keys())
print("dict6的value=",dict6.values())
print("dict6的key-value=",dict6.items())
#list可将获取的字典的内容转换为列表
print("转换为列表:",list(dict6.items()))

#向字典中添加元素
dict8 = {1:'a',2:'b',4:'d',5:'e'}
print("dict8的值=",dict8)
dict8[3]='c'
print("dict8的值=",dict8)
#修改元素值
dict8[1]='d'
print("dict8的值=",dict8)
del dict8[2] # 通过键删除
print("删除键为2的dict8的字典:",dict8)
dict8.pop(1);# 通过pop方法指定键删除
print("删除键为1的dict8的字典:",dict8)
dict8.popitem();# 通过popitem方法随机删除一个键值对
print("随机删除的dict8的字典:",dict8)
dict8.clear()     # 清空字典
print("清空dict8的字典:",dict8)
del(dict8)#删除字典
#print(dict8)#报错 已被删除提示字典不存在

#使用 for in 循环遍历它们的返回值
for k in dict3.keys():
    print(k,end=' ')
print("\n---------------")
for v in dict3.values():
    print(v,end=' ')
print("\n---------------")
for k,v in dict3.items():
    print("key:",k," value:",v)

#copy() 方法复制字典
dict9 = {'one': 1, 'two': 2, 'three': [1,2,3]}
dict10 = dict9.copy()
#向 a 中添加新键值对，由于b已经提前将 a 所有键值对都深拷贝过来，
#因此 a 添加新键值对，不会影响 b。
dict9['four']=100
print("字典9=",dict9)
print("字典10=",dict10)
#由于 b 和 a 共享[1,2,3]（浅拷贝），因此移除 a 中列表中的元素，也会影响 b。
dict9['three'].remove(1)
print("字典9=",dict9)
print("字典10=",dict10)

#update()方法更新字典
#如果被更新的字典中己包含对应的键值对，那么原 value 会被覆盖；
#如果被更新的字典中不包含对应的键值对，则该键值对被添加进去。
dict11 = {'one': 1, 'two': 2, 'three': 3}
dict11.update({'one':11, 'four': 22})
print("字典11=",dict11)

五.集合 set

元素唯一 和字典类似 将元素放在{}里 相邻元素逗号隔开

只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，
无法存储列表、字典、集合这些可变的数据类型，
否则 Python 解释器会抛出 TypeError 错误

set —— 可变集合。集合中的元素可以动态的增加或删除。
frozenset —— 不可变集合。集合中的元素不可改变。

#frozenset集合（set集合的不可变版本）
两种情况下可以使用 fronzenset：
	当集合的元素不需要改变时，我们可以使用 
		fronzenset 替代 set，这样更加安全。
	有时候程序要求必须是不可变对象，这个时候也要使用 
		fronzenset 替代 set。比如，字典（dict）的键（key）
		就要求是不可变对象。

#无法存储列表、字典、集合这些可变的数据类型
#set1 = {{'a':1}} #存储字典dict{key:value}
#set1 = {[1,2,3]} #存储列表list[value,value]
#set1 = {{1,2,3}} #存储集合set{value,value}

#创建集合
set1 = {1,'a',1,(1,2,3),'a'}#元祖tuple(value,value)
print("set1:",set1)#元素唯一

#利用set()创建集合  无序的(这里的顺序指的是添加顺序)
set2 = set([1,3,2,4,5])#列表
print("set2:",set2)
set3 = set((1,5,3,4,2))#元祖
print("set3:",set3)
set4 = set("abdce")    #字符串
print("set4:",set4)

set5 = {1,2,3}
print("set5:",set5)
set5.add(4)#添加元素
print("set5:",set5)
set5.remove(4)#删除元素
print("set5:",set5)

#set无序所以无法利用下标访问元素
#使用循环取出元素
for s in set5:
    print(s,end=' ')
print()#用来换行

#删除集合del()
del(set5)
#print("set5:",set5)#集合已删除 不存在

#集合做交集& 并集| 差集- 对称差集^ 运算
set6 = {1,2,3}
print("set6:",set6)
set7 = {3,4,5}
print("set7:",set7)
print("交集:",set6&set7)#取两集合公共的元素
print("并集:",set6|set7)#取两集合全部的元素
print("差集:",set6-set7)#一个集合中另一集合没有的元素
print("对称差集:",set6^set7)#集合 A 和 B 中不属于 A&B 的元素

#frozenset集合（set集合的不可变版本）
set8 = frozenset() #创建一个不可变的空集合。
lists = [1,2] #列表类型
dicts = {1:"a",2:"b"} #字典类型
tuples = (1,2,3) #元组类型
strs = "厉害了，我的国" #字符串
set9 = set([1,2,3]) #可变集合
 
#将列表，字典，元组，字符串 可变集合 转化为不可变集合
set10 = frozenset(lists)
set11 = frozenset(dicts) 
set12 = frozenset(tuples)
set13 = frozenset(strs)
set14 = frozenset(set9) #将可变集合转换为不可变集合s6
print(set8)
print(set10)
print(set11)
print(set12)
print(set13)
print(set14)

六.迭代器

迭代器有两个基本的方法：iter() 和 next()。
列表,元组,字符串,集合对象都可用于创建迭代器

lists = [1,2] #列表类型
tuples = (1,2,3) #元组类型
strs = "厉害了，我的国" #字符串
sets = {1,2,3} #可变集合
dicts = {1:"a",2:"b"} #字典类型

#依次迭代 发现字典不可以只能输出key
it = iter(sets) # 创建迭代器对象
for x in it:
    print (x, end=" ")
print()

#使用next()得到元素
it = iter(lists)    # 创建迭代器对象
for i in range(1,3):
        print(next(it),end=" ")
print()

第八章:方法(函数)

一.方法(函数)

函数是一组指令的集合 就是封装好的处理问题的一系列逻辑
Python有很多内建函数比如常用的print()等
我们也可以自定义函数

语法:
def 函数名（参数列表）:
	函数体

#定义函数
def printHello():
    print("hello")
#调用函数
printHello()

#定义一个计算长方形面积的函数
def area(c,k):         #这里定义的参数称为形参
    return c*k
#调用函数
print("长方形的面积为:",area(3,5)) #这里定义的参数称为实参

#匿名函数lambda关键字声明
sum = lambda num1, num2: num1 + num2
# 调用sum函数
print ("相加后的值为:",sum(10,20))

第九章:类和对象

一.类

用class来修饰类
格式:
	class 类名：
	多个（≥0）类属性...
	多个（≥0）类方法...
用来表示人类  class People: 
				name="张三"
				age=30
				phone="110"
				def eat:
					print("")

#定义一个人类
class People:
    # 下面定义了一个类属性
    name = '豆豆'
    age = 30
    phone = '110'
    # 下面定义了函数 
    # self在定义类的方法时是必须有的
    def eat(self):
        print("正在吃饭")

    def sleep(self,name):
        print(name,"正在睡觉")

#创建类的对象
p = People()
#访问对象的属性
print("名字为:",p.name)
print("年龄为:",p.age)
print("电话为:",p.phone)
#修改对象的属性
p.name = '小小'
print("修改后的名字为:",p.name)
#调用对象的方法
p.eat()
p.sleep(p.name)

二.构造方法

__init__ 方法
	格式为:
		def __init__(self,...):
		代码块
	创建对象时系统自动调用

#定义一个人类
class People:
    #定义一个构造方法并提供name和age属性
    def __init__(self, name, age):
        self.name = name
        self.age = age

#构造方法规定了对象创建的形式必须要有name和age参数
#p = People() #这样创建没有给参数 会报错
p = People("张三",30)
#访问对象的属性
print("名字为:",p.name)
print("年龄为:",p.age)
#修改对象的属性
p.name = '小小'
print("修改后的名字为:",p.name)

三.类方法(不常用)

和实例方法(普通方法)最大的不同在于，
类方法需要使用＠classmethod修饰符进行修饰
Python 类方法和实例方法相似，它最少也要包含一个参数，
只不过类方法中通常将其命名为 cls 用来绑定类本身

class Student:
    #类构造方法，也属于实例方法
    def __init__(self):
        self.name = "学生"
        self.age = 20
    #下面定义了一个类方法
    @classmethod
    def info(cls):
        print("正在调用类方法",cls)

#使用类名直接调用类方法
Student.info()
#使用类对象调用类方法(不推荐)
stu = Student()
stu.info()

四.静态方法(不常用)

静态方法没有类似 self、cls 这样的特殊参数，
因此 Python 解释器不会对它包含的参数做任何类或对象的绑定。
也正因为如此，类的静态方法中无法调用任何类属性和类方法。
静态方法需要使用＠staticmethod修饰

class User:
    @staticmethod
    def info(name,add):
        print(name,add)

#静态方法可以使用类名直接调用
User.info("张三","甘肃")
#使用类对象调用静态方法(不推荐)
clang = User()
clang.info("李四","兰州")

五.封装

Python 类中的变量和函数，不是公有的类似public就是私有的类似private
	这 2 种属性的区别如下：
	public：公有属性的类变量和类函数，在类的外部、类内部以及子类中，都可以正常访问；
	private：私有属性的类变量和类函数，只能在本类内部使用。

但是，Python 并没有提供 public、private 这些修饰符。

而默认情况下类中的变量和方法都是公有（public）的
如果以双下划线“__”开头，则该变量或函数为私有的,等同于 private。
还可以用单下划线“_”开头,初学者不建议。
		
封装对于开发者和使用者都有好处
	对于开发者：
		能让数据得到保护 从而更加的安全
				
	对于使用者：
		能够让使用者将自己的精力集中在核心业务逻辑上
				
对于属性  如果把属性设置成了private的  那其他类以及外界就访问不到了
	如果我们还想要让外界去访问 那么我们就要给每一个属性提供一对
	公共的专门用来访问每一个属性的方法 getter  setter
				
	getter主要目的是为了给得到一个属性的值 提供一个统一的方法  
		如果你修改了这个属性的值 那么所有通过getter方法得到的
		这个属性的值都会被修改 从而降低了代码之间的耦合
					
	setter主要目的是为了让类的开发者拿回主动权 
				让开发者来决定使用者是否可以修改某个属性
				         
对于方法 一个类可能会有很多个方法但是只有一部分是核心的方法
	而其他的方法可能是为核心的方法提供服务的 这样的我们就可以把核心的方法
    都定义成public公共的 而那些为核心方法提供服务的方法就可以定义成private的

class Students :
    #定义构造方法 定义name 和 age属性参数
    def __init__(self,name,age):
        self.__name = name
        self.__age = age
    #定义getter方法
    def getName(self):
        return self.__name
    #定义setter方法
    def setName(self, name):
        if len(name) < 3:
            raise ValueError('名字必须大于3！')
        self.__name = name #为私有的name属性赋值
    #有了get set方法后之后访问这个属性就可以用getset方法进行访问
    #但是如果还是习惯于对象.属性的形式访问就可以使用property方法实现
    #将name相关的方法进行配置下次就又可以直接使用对象.属性访问了
    name = property(getName, setName)

#创建对象
stus = Students("哎哎哎",20)
#将name用property装配后直接使用对象.属性访问
print(stus.name)
#print(stus.age) #没有提供getter setter方法的私有属性提示不存在
#print(stus.__age)#没有提供getter setter方法的私有属性提示不存在
print(stus._Students__age)#但可以使用这种方式去访问
#说明python在设置私有属性的时候，只是把属性的名字换成了其他的名字。

六.继承

存在与两个类之间的一种关系
	形成继承关系的两个类 他们之间是一种is a 的关系（是一个什么什么）
	被继承继承的那个类可以看做是父类 （子承父业）
        子类继承父类那么也就同时继承了父类所有的方法和属性
        注意：私有的属性和方法 无权访问
                   对象调用方法  调用的永远是对象的方法  new 出来的是谁是就是对象
          
         如果父子类中有同名的属性或方法  父类的属性会被隐藏
         如果想要去访问父类的方法或属性就要在前面加super().
         
1.单继承
	class 子类(父类):
		<statement-1>
		.
		.
		.
		<statement-N>

class Animal:
       __name = "动物" #定义私有的属性name
       age = 5
       gender = "母"
       def eat(self):
           print("动物吃饭的方法")

       def run(self):
           print("动物走路的方法")

class Bird(Animal):  #鸟继承动物
    def sleep(self):
        print("鸟正在睡觉")

class Dog(Animal):  #狗也继承动物
    gender = "公"
    def eat(self):  #重写了父类的方法
        print("狗正在吃肉")
    
    def show(self):
        super().eat() #调用父类的eat方法

bd = Bird()
#私有属性或方法无权访问
#print("鸟的名字是:",bd.name) #会报错 name 不存在
#print("鸟的名字是:",bd.__name)#会报错 __name 不存在
#可以这样反问但不建议
print("可以通过这种形式强制访问:",bd._Animal__name)
print("鸟的年纪为:",bd.age)#继承得到的属性
print("鸟的性别是:",bd.gender)#继承得到的属性
bd.eat()#继承得到的方法
bd.run()#继承得到的方法
bd.sleep()#访问自己的方法

dg = Dog()
print("狗的年纪为:",dg.age)#继承得到的属性
print("狗的性别是:",dg.gender)#访问的是自己的属性
dg.run()#继承得到方法
dg.eat()#访问的是自己的方法
dg.show()#通过super()可以访问到父类的方法

多继承
同时拥有多个父类
class 子类(父类,父类):
			<statement-1>
			.
			.
			.
			<statement-N>

class Animals:
       age = 5
       def ams(self):
           print("我是动物s的方法")

class Animal:
       gender = "公"
       def am(self):
           print("我是动物的方法")

class Bird(Animals,Animal):  #鸟继承动物s和动物
    gender = "母"
    def bd(self):
        print("我是鸟的方法")

    def show(self):
        print("访问父类的属性:",super().gender)

bd = Bird()
print("鸟的年纪为:",bd.age)#继承得到的属性
print("鸟的性别是:",bd.gender)#继承得到的属性
bd.ams()#继承得到Animals的方法
bd.am()#继承得到Animal的方法
bd.bd()#访问自己的方法
bd.show()#通过方法访问父类的属性

七.多态

一个事物的多种形态(一个对象总有多种称呼他的形式)

对象调用方法  调用的时对象的方法

当我们使用多态的时候要明白 对象是客观存在的 不会因为它的称呼变了  本身就发生变化
	
1.Python中本没有重载函数，如果我们在同一命名空间中定义的多个函数是同
名的，最后一个将覆盖前面的各函数，也就是函数的名称只能是唯一的。	

2.方法的重写
	方法的重写是发生在有继承关系的子类中
	重写方法的目的是因为父类给子类提供的方法已经不满足现实的状况了 也就是说过时了
	那么这个时候子类要去重写父类的方法主要目的就是为了得到新的解决问题的方案

class Animal:
    def eat(self):
        print("动物吃东西的方法")
class Cat(Animal):                                 
    def eat(self):
        print("猫吃鱼")

class Dog(Animal):                               
    def eat(self):
        print("狗吃肉")

class Sheep(Animal):                                
    def eat(self):
        print("羊吃草")

a = Animal()
a.eat()

a = Cat()
a.eat()

a = Dog()
a.eat()

a = Sheep()
a.eat()

第十章:异常处理

一.异常

1.编程中经常会遇到一些语法错误或运行时错误
	语法错误，也就是解析代码时出现的错误,
		代码不符合规则时就会出现语法错误
		print("格式") 写成了 print "错误格式"

	运行时错误，即程序在语法上都是正确的，
		但在运行时发生了错误10/0零不能做分母 
		代码解析没有报错 但执行报错

2.在 Python 中，我们这种运行时产生错误的情况叫做异常Exceptions
	常见的异常有:
	BaseException	所有异常的基类
	SystemExit	解释器请求退出
	KeyboardInterrupt	用户中断执行(通常是输入^C)
	Exception	常规错误的基类
	StopIteration	迭代器没有更多的值
	GeneratorExit	生成器(generator)发生异常来通知退出
	StandardError	所有的内建标准异常的基类
	ArithmeticError	所有数值计算错误的基类
	FloatingPointError	浮点计算错误
	OverflowError	数值运算超出最大限制
	ZeroDivisionError	除(或取模)零 (所有数据类型)
	AssertionError	断言语句失败
	AttributeError	对象没有这个属性
	EOFError	没有内建输入,到达EOF 标记
	EnvironmentError	操作系统错误的基类
	IOError	输入/输出操作失败
	OSError	操作系统错误
	WindowsError	系统调用失败
	ImportError	导入模块/对象失败
	LookupError	无效数据查询的基类
	IndexError	序列中没有此索引(index)
	KeyError	映射中没有这个键
	MemoryError	内存溢出错误(对于Python 解释器不是致命的)
	NameError	未声明/初始化对象 (没有属性)
	UnboundLocalError	访问未初始化的本地变量
	ReferenceError	弱引用(Weak reference)试图访问已经垃圾回收了的对象
	RuntimeError	一般的运行时错误
	NotImplementedError	尚未实现的方法
	SyntaxError	Python 语法错误
	IndentationError	缩进错误
	TabError	Tab 和空格混用
	SystemError	一般的解释器系统错误
	TypeError	对类型无效的操作
	ValueError	传入无效的参数
	UnicodeError	Unicode 相关的错误
	UnicodeDecodeError	Unicode 解码时的错误
	UnicodeEncodeError	Unicode 编码时错误
	UnicodeTranslateError	Unicode 转换时错误
	Warning	警告的基类
	DeprecationWarning	关于被弃用的特征的警告
	FutureWarning	关于构造将来语义会有改变的警告
	OverflowWarning	旧的关于自动提升为长整型(long)的警告
	PendingDeprecationWarning	关于特性将会被废弃的警告
	RuntimeWarning	可疑的运行时行为(runtime behavior)的警告
	SyntaxWarning	可疑的语法的警告
	UserWarning	用户代码生成的警告

二.异常处理

try:
	有可能出现异常的代码
except (异常类型):
	出现此异常的解决方案 异常类型可有可无也可以有多个
except :
	出现其他异常时的解决方案
else:
	没有出现异常
finally:
	不管是否出现异常都执行

print()
print("=====try-except=====")

try:
    c = 2 / 0
    print("结果是：", c )
except (ValueError, ArithmeticError):
    print("程序发生了数字格式异常、算术异常之一")
except :
    print("未知异常")
print("程序继续运行")

print()
print("==========获取异常相关信息==========")
print()

try:
    2/0
except Exception as e:
    # 访问异常信息
    print("错误描述字符串:",e.args)
    print("异常信息:",str(e))
    print("较全的异常信息:",repr(e))

print()
print("=====try-except-else =====")
print()

try:
    result = 2 / int(input('请输入除数:'))
    print("结果为:",result)
except ValueError:
    print('必须输入整数')
except ArithmeticError:
    print('算术错误，除数不能为 0')
else:
    print('没有出现异常')
print("继续执行")

print()
print("=====try-except-finally =====")
print()

try:
    print(20/0)
except:
    print("发生异常！")
else:
    print("执行 else 块中的代码")   
finally : #无论是否发生异常finally中的代码必须执行
    print("执行 finally 块中的代码")

三.创建异常

使用raise关键字
	raise:
		该语句引发当前上下文中捕获的异常
		（比如在 except 块中），或默认引发 RuntimeError 异常。
	raise 异常类名称：
		表示引发执行类型的异常。
	raise 异常类名称(描述信息)：
		在引发指定类型的异常的同时，附带异常的描述信息。

try:
    a = input("输入一个数：")
    #判断用户输入的是否为数字
    #isdigit()方法判断字符串是否都为数字组成
    if(not a.isdigit()): #如果不是
        #raise #默认引发 RuntimeError 异常
        #raise ValueError #引发执行类型的异常
        raise ValueError("a 必须是数字")#引发执行类型的异常带描述信息
except ValueError as e:
    print("引发异常：",repr(e))

第十二章:文件

一.文件操作

1.open()方法用于打开一个文件，并返回文件对象

如果该文件无法被打开，会抛出 OSError。
使用open()方法结束后一定要记得关闭文件对象即调用close()方法。
open(file,mode='r',buffering=-1,encoding=None,errors=None,newline=None,closefd=True,opener=None)
参数说明:
file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

2.open 函数支持的文件打开模式

# 以默认方式打开文件
f = open('test.txt')
# 输出文件是否已经关闭
print(f.closed)
# 输出访问模式
print(f.mode)
#输出编码格式
print(f.encoding)
# 输出文件名
print(f.name)

二.文件读写

with 关键字
with open("write.txt") as f:
在打开文件时，很多人通常直接用open('file')
使用 with 关键字可以使文件操作发生异常时也能正确关闭文件
当然也可使用异常处理的finally语句
close()函数是专门用来关闭已打开文件的

read()函数可读模式（r、r+、rb、rb+）打开的文件 
	按字节或字符读取文件中的内容。
readline()函数可读模式(r、rb、r+、rb+)打开的文件 
	用于读取文件中的一行，包含最后的换行符“\n”
readlines()函数可读模式(r、rb、r+、rb+)打开的文件 
	用于读取文件中的所有行

#使用with关键字
with open("write.txt") as f:  
    print(f.readlines())
f.close()

write()函数可写模式(r+、w、w+、a 或 a+)打开的文件 
	写入字符串
writelines()函数可写模式(r+、w、w+、a 或 a+)打开的文件 
	可写入字符串列表

flush()函数，它可以实现将缓冲区的数据写入文件中。

#使用try finally语句
try:
   f = open("write.txt","a")#追加模式写入
   f.writelines("我要写入一行数据");
except :
   print("发生了异常")
finally:
   f.close()
print("写入成功")