Lesson4---Python语言基础（2）

4.1 内置数据结构

4.1.1 序列数据结构（sequence）

成员是有序排列的
每个元素的位置称为下标或索引
通过索引访问序列中的成员
Python中的序列数据类型有字符串、列表、元组
“abc” ≠ “bac”

4.1.1.1 创建列表和元组

Python中的列表和元组，可以存放不同类型的数据。甚至是Python对象。
列表（list）：使用方括号[]表示。[1, 2, 3]

lst_1 = [1, 2, 3]
lst_2 = [4]
lst_3 = [[1, 2, 3], [4, 5, 6]]

lst_mix = [160612, "张明", 18, [92, 76, 85]]
lst_empty = []

元组（tuple）：元组使用小括号()表示。(1,2,3)
元组一经定义，元组的内容不能改变

>>>tup_1 = (1, 2, 3)

>>>tup_empty = ()#这是一个空的元组
>>>tup_empty
()

>>>t1 = (1)#写成这种形式会产生歧义，因为小括号既可以表示元组也可以表示数学运算中的小括号，因此Python规定，这种形式按照小括号进行计算，计算结果为1
>>>t2 = (1,)#如果想表示为元组，需要在后面加上一个，逗号，表示元组
>>>print("t1 = ",t1,type(t1))
t1 = 1 <class 'int'>
>>>print("t2 = ",t2, type(t2))
t2 = (1,) <class 'tuple'>

4.1.1.2 索引（下标）
索引是有方向的

-6，-5，-4，-3，-2，-1 逆向索引
P y t h o n
0 1 2 3 4 5 正向索引

示例

# 字符串索引
>>>str py = "Python"
>>>print(str_py[0])
p
>>>print(str_py[-1])
n

对于列表也是一样的

# 列表索引
>>>1st = [1, 2, 3]
>>>print(1st_1[1])
2
>>>print(1st_1[-2])
2

4.1.1.3 切片

切片就是一次性从序列中获取多个元素，得到序列的子集
[开始位置：结束位置] 切片不包括结束位置的元素
开始位置省略，从序列中第一个元素开始
结束位置省略，取到序列中的最后一个元素
开始和结束位置都缺省的话，就是取到全部元素

例如：

# 字符串切片
>>>str_py = Python"
>>>print(str_py(1:5))
'ytho'
>>>print(str_py[1:])
'ython'
>>>print(str_py[:5])
'Pytho'

列表的切片也是一样的

# 列表切片
>>>list1 = [1, 2, 3]
>>>list1[2:]
[3]

4.1.1.4 打印----print()
print(序列数据结构名称) 输出整个序列

>>>1st_1 = [1, 2, 3]
>>>print(1st_1)
[1, 2, 3] #打印整个列表

>>>tup_1 = (1, 2, 3)
>>>print(tup_1)
(1, 2, 3) #打印整个元组

>>>print(1st_1[0]) #打印列表中的元素
1

4.1.1.5 获取序列的长度——len（序列名称）

#获取字符串的长度
>>>len("Python")
6
>>>str = "Python"
>>>len(str)
6

#获取一维列表的长度
>>>1st_1 = [1, 2, 3]
>>>len(1st_1)
3

#获取二维列表的长度
>>>1st_3 = [[1,2,3],[4,5,6]]#是两个一维元素的二维列表
>>>len(1st_3)
2

#获取混合列表的长度
>>>1st_mix = [160612, "张明", 18, [92, 76, 85]]
>>>len(1st_mix)
4

#获取元组的长度
>>>tup_1 = (1, 2, 3)
>>>len(tup_1)
3

4.1.1.6 更新列表：向列表中添加元素

4.1.1.6.1 append()函数，列表尾加元素

# 向列表中追加元素
>>>1st_1 = [1, 2, 3]
>>>1st_1.append(4)
>>>1st_1
[1, 2, 3, 4]

4.1.1.6.2 insert()函数，指定位置
第一个参数是指定位置x，在第x个位置后面插入元素
第二个元素是要插入的元素

#向列表中追加元素
>>>1st_1 = [1, 2, 3]
>>>1st_1.insert(1,5)
[1, 5, 2, 3]

4.1.1.7 更新列表：合并列表

4.1.1.7.1 extend()函数，将列表加在表尾

#合并列表
>>>1st_1 = [1, 2, 3]
>>>1st_2 = [4]
>>>1st_1.extend(1st_2)
>>>1st_1
[1,2,3,4]

4.1.1.7.2 "+"运算符，可以自由组合

>>>1st_1 = [1,2,3]
>>>1st_2 = [4]
>>>1st_3 = 1st_1 + 1st_2
>>>1st_3
[1,2,3,4]

4.1.1.8 更新列表：删除列表中的元素

4.1.1.8.1 del语句

>>>lst_1 = [1,2,3,4]
>>>del lst_1[1]# 删除下标为1的元素
>>>lst_1
[1,3,4]

4.1.1.9 更新列表：排序

4.1.1.9.1 sort()函数：对列表中的元素排序

4.1.1.9.2 reverse()函数：对列表中的元素倒排序

>>>lst_1 = [2,3,1,4]
>>>lst_1.sort()#将lst_1中的元素按从小到大的顺序排列
>>>lst_1
[1,2,3,4]

>>>lst_1.reverse() #将lst_1中的元素原地逆序
>>>lst_1
[4,3,2,1]

由于元组一经定义之后就不能更改，因此元组不支持更新操作

4.1.1.10 遍历列表中的元素

#遍历列表中的元素
>>>lst_1 = [1,2,3,4]
>>>for i in lst_1:
	print(i, end=" ")
1 2 3 4

4.1.2 字典和集合

4.1.2.1 字典（Dictionary）

每个字典元素都是一个键/值对（key/value）
键：关键字
值：关键字对应的取值
语文：80 数学：85
字典是一种表示映射关系的数据结构

4.1.2.1.1 创建字典
{键:值, 键:值, 键:值, …}

键：数字/字符串
值：任意Python对象/数据类型

>>>dic_score = {"语文":80, "数学":85, "英语":78, "体育":90}#字符串关键字为键，数字为值
>>>dic_employ = {"name":"Mary", "age":26}
>>>dic_employ = {"name":{"first":"Mary", "last":"Smith"}, "age":26}#字典支持嵌套定义

4.1.2.1.2 打印字典、访问字典中的元素

>>>dic_score = {"语文":80, "数学":85, "英语":78, "体育":90}
>>>print(dic_score)
{"语文":80, "数学":85, "英语":78, "体育":90}

>>>print(dic_score["语文"])
80

>>>len(dic_score)#使用len()函数可以得到字典的长度
4

4.1.2.1.3 判断字典中是否存在元素–in运算符

>>>dic_student = {'name':'张明', 'sex':'男', 'age':18, 'score':98}
>>>'sex' in dic_student
True

4.1.2.1.4 遍历字典元素

keys()：返回字典中所有的关键字
values()：返回字典中所有的值
items()：返回字典中所有的键值对

例子：遍历字典中所有的键

>>>dic_student = {'name':'张明', 'sex':'男', 'age':18, 'score':98}
>>>for key in dic_student.keys():
		print(key, end=" ")
age name score sex

字典中各个元素是无序的，所有每次打印出来的结果可能是不同的

例子：遍历字典中所有的键对值

>>>dic_student = {'name':'张明', 'sex':'男', 'age':18, 'score':98}
>>>for item in dic_student.items():
		print(item)#没有设置end参数，默认为换行符，每次输出都换行
('age',18)
('name','张明')
('score',98)
('sex','男')

4.1.2.1.5 格式化输出

>>>dic_student = {'name':'张明', 'sex':'男', 'age':18, 'score':98}
>>>for key,val in dic_student.items():
		print("dic_student[%s] = "%(key), val) #%s输出变量key，然后输出第二项val
dic_student[name] =  张明
dic_student[sex] =  男
dic_student[age] =  18
dic_student[score] =  98

4.1.2.1.6 更新字典：添加元素、修改指定元素的取值、合并字典

可以通过赋值语句向字典中添加一个字典元素，修改指定元素的取值

>>>dic_student = {'name':'张明','sex':'男','age':18}

>>>dic_student['score'] = 98
>>>print(dic_student)
{'name':'张明','sex':'男','age':18,'score': 98}

>>>dic_student['score'] = 90
>>>print(dic_student)
{'name':'张明','sex':'男','age':18,'score': 90}

4.1.2.1.7 合并字典

将另一个字典的元素追加到字典中

>>>dic_student = {'name':'张明','sex':'男','age':18}
>>>dic_contact = {'tel':13104415887,'email':'zhm@gmail.com'}

>>>dic_student.update(dic_contact)

>>>print(dic_student)
{'name':'张明','sex':'男','age':18,'tel':13104415887,'email':'zhm@gmail.com'}

4.1.2.1.8 删除字典中元素

pop(指定元素的关键字)
clear() #清空字典中的所有的元素
del语句 #删除指定元素或字典本身

>>>dic_student = {'name':'张明','sex':'男','age':18}

>>>dic_student.pop('sex')
>>>print(dic_student)
{'name':'张明','age':18}

>>>dic_student.clear()
>>>print(dic_student)
{}

4.1.2.2 集合（set）

集合（set）：由一组无序排列的元素组成

可变集合（set）可以添加、修改和删除其中的元素
不可变集合（frozenset）创建后不能改变
使用大括号{1,2,3,4,5,4,5}

>>>set1 = {1,2,3,4,5,4,5}
>>>print(set1)
{1,2,3,4,5}# 输出的集合中重复的元素被清除了

>>>len(set1)
5

4.1.2.2.1 创建集合

set()
frozenset()

>>>set_2 = set("Python")
>>>print(set_2)
{'P','y','t','h','o','n'}#在集合中是无序的

>>>set_3 = frozenset("Python")
>>>print(set_3)
frozenset({'P','y','t','h','o','n'})

集合中的元素是无序的，因此不能像通过下标来访问，但是不知道为啥这里是有序的。

打印集合、获取集合长度、遍历集合

4.2 函数和模块

4.2.1 函数

实现某种特定功能的代码块
程序简洁、可重复调用、封装性好、便于共享
系统函数和用户自动义函数

4.2.1.1 内置函数

直接加载，任何时候都可以直接调用

输入输出函数：input()、print()
类型转换函数：int()、float()
求取长度函数：len()

Python3.6.2版本，一共提供了68个内置函数

数字运算函数
- 取绝对值函数
- 幂函数
- 四舍五入函数
- 除法取余函数
输入输出函数
类型转换函数
逻辑判断函数
序列操作函数
对象操作函数

4.2.1.1.1 数学运算函数

函数	原型	具体说明
abs()	abs(x)	返回x的绝对值
pow()	pow(x,y)	返回x的y次幂
round()	round(x[, n])	返回浮点数x的四舍五入值，参数n指定保留的小数位数，默认为0
divmod()	divmod(a,b)	返回a除以b的商和余数，返回一个元组，divmod(a,b)返回(a/b,a%b)

>>>abs(-1)
1
>>>pow(2,3)
8
>>>round(3.1415,2)
3.14
>>>round(3.54)
4
>>>divmod(5,3)
(1,2)

4.2.1.1.2 常用Python内置函数

函数	原型	函数	原型
len()	返回长度	list()	转换为列表
max()	返回最大值	help()	显示帮助信息
sum()	返回总和	dir()	显示属性
str()	转换成字符串	type()	显示类型
float()	转换为浮点数	range()	返回一个整型列表
int()	转换为整型表示	open()	打开

4.2.1.2 用户自定义函数

4.2.1.2.1 定义函数
定义函数：函数名、参数和返回值

def 函数名(参数列表):
	函数体

参数列表中是形式参数/形参，可以为空，多个话用逗号分隔
例如：

def add(a, b):
	c = a + b
	return c

返回值可以是任何形式的参数，返回值可以是多个值

def add_mul(a, b):
	add=a+b
	mul=a*b
	return add,mul

也可以没有返回值

def say_hello(your_name):
	print("Hello,%s!"%your_name)

4.2.1.2.2 调用函数

函数名(参数列表)

这里的参数列表是实际参数，即实参，实参的个数、类型要与形参一一对应，并且需要由确认的值。

def add(a, b):
	c = a + b
	return c

>>>add(1,2)
3

通过多元赋值语句，通过获取多个返回值

def add_mul(a, b):#定义函数
	add=a+b
	mul=a*b
	return add,mul

>>>x,y = add_mul(1,2)#调用函数
>>>print("add:",x,";mul:",y)
add:3;mul:2

调用函数时必须要有函数名后面的小括号，即使没有参数也要有

def say_hello(your_name):
	print("Hello,%s!"%your_name)

>>>say_hello()
Hello!

4.2.1.2.3 变量的作用域

局部变量（Local Variable）：在函数中定义的变量，仅在定义它的函数内部有效。
全局变量（Global Variavle）：在函数体之外定义的变量，在定义后的代码中都有效，包括在它之后定义的函数体内

def setNumber():
	a=9
	a=a+1
	print("setNumber:",a)
>>>setNumber()
setNumber:10
>>>print(a)
NameError: name 'a' is not defined

再看，

a = 100	#定义全局变量
def setNumber():# 定义函数
	a=9# 定义局部变量
	a=a+1
	print("setNumber:",a)#打印局部变量
setNumber()#调用函数，打印局部变量
print(a)#打印全局变量

#输出结果为
setNumber: 10
100

4.2.1.3 函数的参数

4.2.1.3.1 参数的传递

按值传递：形参和实参分别存储，相互独立
在内部函数改变形参的值时，实参的值是不会随之改变的。

4.2.1.3.2参数的默认值
可以为参数指定默认值，函数内部没有定义该函数的话就取它的默认值

def 函数名(参数1=默认值，参数2=默认值...)
	函数体

例如

def add(a,b=2):
	return a+b
print(add(1))#a取值1，b取值默认值2
print(add(2,3))#都设置了值，那么就不取默认值

运行结果：

3
5

当函数有多个默认值时，参数的默认值只能从右往左依次设置，否则将报错

def add(a, b=1, c=2):#正确的
	return a+b+c

def add(a=1, b, c=2):#会报错
	return a+b+c
	
def add(a=1, b=2, c):#会报错
	return a+b+c

4.2.1.3.3 向函数内部批量传递数据

可以使用列表、字典变量作为参数，向函数内部批量传递数据

def sum(list):
	sum=0
	for x in list:
		sum+=x
	return sum

>>>lst_1 = [1,2,3,4,5]
>>>print(sum(lst_1))
15

当使用列表或字典作为函数参数时，在函数内部对列表或字典的元素所做的修改，会改变实参的值

4.2.2 模块、包和库

函数（function）

封装性好、可重复调用
便于共享、程序简洁
系统函数和用户自定义函数

模块（Module）

模块是一个python文件（.py），拥有多个功能相近的函数或类
便于代码复用，提高编程效率，提高了代码的可维护性。
避免函数名和变量名发生冲突。

包（Package）

为了避免模块名冲突，Python引入了按目录来组织模块的方法。
一个包对应一个文件夹，将功能相近的模块（Python文件），放在同一个文件夹下。
在作为包的文件夹下有一个_init_.py文件。

在这里插入图片描述
4. 子包：子目录中也有一个_init_.py文件。请添加图片描述

库（Liberay）
库是具有相关功能的模块或包的集合

4.2.2.1 导入模块/包/库

4.2.2.1.1 导入整个包‘

import 名称 [as 别名]

例如

import numpy as np# 导入numpy函数库，并为它起一个名别np
np.random.random()# 调用numpy库中的random类中的random()函数

4.2.2.1.2 导入包中指定的模块或子包

from 模块/包名称 import 函数名 as 函数别名

from numpy import *# *表示导入numpy函数中的所有函数
random.random()#下面可以直接使用numpy库中的random类，无需库 的名称或者别名作为前缀，但是为了避免混淆，所以最好不要省略

推荐使用第一种导入整个包的方式，因为标准库的random.random()和numpy库中的random.random()不一样

4.2.2.1.3 导入语句的作用域

在程序顶部导入模块，作用域是全局的
在函数的内部导入语句，作用域就是局部的

一般在导入库的时候，一般按照这样的顺序：在这里插入代码片

python 标准库/模块
python 第三方库/模块
自定义模块

4.2.2.2 使用模块/包/库中的函数和变量

模块/包/库名.函数名(参数列表)
模块/包/库名.变量名

例如

>>>import math# 导入math模块
>>>math.pow(2,3)# 计算2的3次幂
8.0

>>>from math import pow, aqrt # 从math的模块中只导入pow和sqrt函数
>>>pow(2,3)
8.0
>>>sqrt(16)
4.0

>>>from math import sqrt as s# 从math模块中导入sqrt函数并重命名为s
>>>s(16)
4.0

4.2.2.3 创建自定义模块

将常用的函数定义放在一个.py文件中
mymodule.py

def print_str(str):#打印字符串
	print(str)

def sum(a,b):
	return a+b# 求和

4.2.2.4 调用自定义模块

>>>import mymodeule as mm# 导入mymodule模块
>>>mm.print_str("Python")# 调用打印函数
Python
>>>mm.sum(2,3)# 调用求和函数
5

当函数较多时，可以按照功能将它们放在不同的模块中。
一个应用程序中可以定义多个模块

4.2.2.5 Pyhton标准库中的模块

Python标准库：是Python自带的开发包
sys模块：提供有关Pyhton运行环境的变量和函数

4.2.2.5.1 sys模块中常用变量

变量	功能
sys.platform	获取当前操作系统
sys.path	获取指定模块搜索路径
sys.path.append()	添加指定模块搜索路径
sys.argv	获取当前正在运行的命令行参数的参数列表
sys.exit(n)	退出应用程序，n=0，正在退出；n=1，异常退出
sys.getdefaultencoding()	获取系统当前编码
sys.setdefaultencoding()	设置系统默认编码
sys.getfilesystemencoding()	获取文件系统使用编码方式，Windows下返回‘mbcs’，mac下返回‘utf-8’

>>>import sys
>>>sys.platform
win32
>>>sys.path
...
...
>>>sys.path.append('F:\\myPrograme')#sys.path.append('路径')

在退出Pyhton环境后，使用sys.path.append()函数添加的路径会自动消失

4.2.2.5.2 platform模块中常用变量
获取操作系统的详细信息和与Python有关的信息

函数	功能
plaform.patform()	获取操作系统名及版本信息
platform.system()	获取操作系统类型
platform.version()	获取操作系统的版本信息
platform.procession()	获取计算机的处理器信息
platform.python_build()	获取Python的版本信息，包括Pyhton的主版本，编译版本号和编译时间等信息

4.2.2.5.3 math模块中常用变量

变量和函数	功能
math.e	返回自然对数e的值
math.pi	返回Π的值
math.exp(x)	返回e的x次幂
math.fabs(x)	返回x的绝对值
math.cell(x)	返回大于等于x的最小整数
math.floor(x)	返回小于等于x的最大整数
math.log(x,s)	返回loga(x)，如果不指定参数a，则默认使用e
math.log10(x)	返回log10(x)
math.pow(x,y)	返回x的y次幂
math.sqrt(x)	返回x的开平方

4.2.2.5.4 random模块中常用变量
random模块：生成随机数

函数	功能
random.random()	生成一个0到1的随机浮点数
random.uniform(a,b)	生成一个指定范围内的随机浮点数。其中a是下限，b是上限
random.randint(a,b)	生成一个指定范围内的随机整数。a是下限，b是上限
random.choice(seq)	从序列中随机获取一个元素。参数seq表示一个有序类型，可以是一个列表、元组或者字符串
random.shuffle(x)	将一个列表x中的元素打乱

4.2.2.5.5 小数和分数处理模块

decimal模块：表示和处理小数
fractions模块：表示和处理分数

4.2.2.5.6 时间处理模块

time
datetime
calendar

4.2.3 问答讨论
函数、模块、包和库之间有什么区别和联系？我们使用的tensorflow是哪个级别？

函数是可重复使用的功能块
模块包含函数，用来区别重名变量、函数
包包含模块，用来管理诸多模块
库是功能相关模块的集合

Tensorflow是python的库。

4.3 Python面向对象编程

4.3.1 Python面向对象的编程（1）

面向对象程序设计（Object-oriented programming，OOP）
面向过程的程序设计（Process-oriented programming，POP）
4.3.1.1 类（class）
类（class）：具有相同的属性和方法的对象集合
类分为父类/基类 和 子类/派生类
对象是类的实例
子类继承了父类的全部属性和方法，并且也有自己持有的属性和方法。
继承描述了类之间的层次关系
类和对象并非仅限于具体的事物，它也可以是一种抽象的概念或者规则。

4.3.1.1.1 声明类
说明这个类有哪些属性和方法

class 类名：
	类属性 = 初值
	方法（参数列表）

类属性是类中所有对象共同拥有的属性
它在内存中只存在一个副本
可以通过类名来访问，也可以被类的所有对象访问
在类被定义之后，可以通过类名添加类属性，新增的类属性也被类和所有对象共有。
对于所有的类，都有一组特殊的类属性

类属性	含义
name	类的名字（字符串）
doc	类的文档字符串
bases	类的所有父类组成的元组
dict	类的属性组成的字典
module	类所属的模块
class	类对象的类型

方法其实就是类中的一个函数
参数列表为 (self,参数2,参数3,…)
与普通函数不同之处在于，参数必须有一个参数self，而且是参数列表中的第一个参数
我们知道同一个类可以生成很多个对象，每一个对象都有一个专属的self，代表这个对象自身，当某个对象的方法被调用时，就会将自身的self作为第一个参数传递给这个方法，通知python目前操作的是哪个对象的方法。

class Preson:#一般类名的首字母大写
	money = 10000
	def say_hello(self):
		print("Hello!")

例子

class Preson:#一般类名的首字母大写
	money = 10000
	def say_hello(self):
		print("Hello!")

zhangsan = Preson()
print(zhangsan.money)
zhangsan.say_hello()

输出结果为：

10000
Hello!

4.3.1.1.3 添加对象属性
但是这些属性只属于这个对象

class Preson:#一般类名的首字母大写
	money = 10000
	def say_hello(self):
		print("Hello!")

zhangsan = Preson()

zhangsan.major = "computer"
print("zhangsan's major is",zhangsan.major)

输出结果为

zhangsan's major is computer

4.3.1.1.4 删除对象

del 对象名

例子

del zhangsan# zhangsan对象就不存在了，再次访问就会出错

4.3.2 Python面向对象的编程（2）

类（class）：对具有相同属性和方法的一组对象的描述，它定义了所有对象所共有的属性和方法。
对象（object）：是类中的一个具体的实例（instance）
属性（attribute）：是类和对象中的变量

类属性：定义在类的内部，方法的外部。是类中所有对象共同拥有的属性。
实例属性：也叫做成员变量，在每个对象中都有自己的副本

方法（method）：在类中所定义的函数，它描述了对象能执行的操作。

实例方法（成员函数）：只能通过对象调用

4.3.2.1 构造函数和析构函数

构造函数：在创建对象时，用来完成初始化操作。当创建对象时，系统自动调用构造函数。可以把对成员变量赋初值的语句写在构造函数中。
构造函数的名称是__init__(self,参数2,参数3,...)
析构函数：在清除函数时，回收和释放对象所占用的资源。
析构函数的名称是__del__()
下面看一个使用构造函数和析构函数的例子：

下面看一个使用构造函数和析构函数的例子：

class Person:
    def __init__(self,name,age,gender="男"):
        self.name = name
        self.age = age
        self.gender = gender
    def __del__(self):
        print("Bye bye--from",self.name)
    def printInfo(self):
        print("姓名： ",self.name,"年龄： ",self.age,"性别： ",self.gender)
    
zhangsan = Person("张三",18)
lisi = Person("李四",19,"女")

zhangsan.printInfo()
lisi.printInfo()

del zhangsan
del lisi

输出结果为

姓名：  张三 年龄：  18 性别：  男
姓名：  李四 年龄：  19 性别：  女
Bye bye--from 张三
Bye bye--from 李四

使用构造函数可以更加灵活的为成员变量赋初值。
构造函数和析构函数是可以省略的

4.3.2.2 静态方法和类方法

4.3.2.2.1 类方法

class 类名:
	@classmethod
	def 类方法名(cls,...):#第一个参数必须是当前类对象class，代表定义这个类方法的类，通过它传递类的属性和方法
		方法体

可以通过类名或对象名调用。
不能访问实例属性，但是可以访问类属性。
类方法就是将类本身作为对象操作的方法

4.3.2.2.2 静态方法

class 类名:
	@staticmethod
	def 类方法名():# 没有self和cls参数，其他的随意
		方法体

可以通过类名或对象名来调用
不能访问实例属性，也不能直接访问类属性。但是可以通过类名引用类属性。
就是类中的函数而已，静态方法是一个独立的单独的函数，仅仅托管与某个类的空间中，便于使用和维护，托管的类类似于一个函数工具库。

4.3.2.3 公有变量和私有变量

公有变量：可以在类的外部访问
保护变量：只能允许其本身和子类进行访问
私有变量：不允许在类的外部访问，只有类对象自己能访问
__xxx : 私有变量
_xxx : 保护变量
__xxx__ : 专有变量，方法，比如__init__,__del__,__name__,__doc__,...

4.3.2.4 继承（inheritance）

子类能够继承父类中所有非私有的成员变量和成员函数

class 子类名(父类名)
	类属性 = 初值
	方法(参数列表)

例子：

class Preson():
    money = 10000
    def say_hello(self):
        print("Hello!")

class Teacher(Preson):
    pass#是一条空语句，表示什么都不做

amy = Teacher()

print(amy.money)
amy.say_hello()

输出结果为：

10000
Hello!

4.3.3 小结

4.3.3.1 方法

实例方法/成员函数：只能通过对象名调用，第一个参数必须是self
构造函数和析构函数
类方法：可以通过类名或对象名调用，第一个参数必须是”cls“，类方法不能访问实例属性，但是可以访问类属性，其实就是将类本身作为对象操作的方法
静态方法：通过类名或对象名调用，没有”self“或”cls“参数。
4.3.3.2 成员变量
公有变量、保护变量、私有变量

4.3.3.3 继承
继承：是子类自动的共享父类中的属性和方法的机制。

4.4 文件

4.4.1 打开文件

文件对象 = open(文件名, 访问模式)

绝对路径：从盘符开始的路径

D:\C++lianxi
D:\Game
E:\study

我的当前目录是D:\jupyter\example
那么\python\file.txt就是表示D:\jupyter\example\python\file.txt
如果要表示当前目录的上行目录，使用…表示，即…\file.txt在绝对路径中就是D:\jupyter\file.txt
获取当前路径

import os
print(os.getcwd())

参数"访问模式"的可取值

访问模式	执行操作
‘r’	以只读方式打开文件
‘w’	以写入方式打开文件，回覆盖已经存在的文件
‘a’	以写入方式打开文件，在末尾追加写入
‘+’	以可读写的方式打开文件（不能单独使用，加在其他方式的后面）
‘b’	以二进制模式打开文件
‘t’	以文本模式打开文件（默认）

可以混合使用，比如：

访问模式	执行操作
‘rb’	二进制读写模式
‘wb’	二级制写模式
‘ab’	二进制追加模式

下面看一个例子：

#首先要在目录下创建一个文件
f = open("D:\lianxi\shendu\myfile.txt")#没有提示说明已经被打开了
#f = open("D:/lianxi/shendu/myfile.txt")
f = open("mypython.txt",'w')#如果在工作路径下找不到这个文件，就会自动创建它
#如果打开以后想要删除这个文件，就会出现错误提示，以为该文件已经在python中打开

4.4.2 关闭文件

文件对象.close()

例如上述：

f.close()#释放文件，要及时关闭，写入操作之后要立刻关闭文件，否则可能没有保存

4.4.3 读取文件的内容

4.3.3.1 read()方法

文件对象.read()

例如，针对前面创建的文件

>>>f = open("mypython.txt")
>>>f.read()
'Python3.0'

但是如果是针对一段一段的文字

>>> f = open("The Zen of Python.txt")
>>> f.read()
'wo shi ni ba ba\nwo shi ni ye ye \nwo bu shi ni ba ba\ndui de'

这里对于换行符也被读出来了

4.3.3.2 readline()方法

该方法每次只读取文件中的一行

>>> f = open("The Zen of Python.txt")
'wo shi ni ba ba\nwo shi ni ye ye \nwo bu shi ni ba ba\ndui de'
>>> f.readline()
'wo shi ni ba ba\n'
>>> f.readline()
'wo shi ni ye ye \n'
>>> f.readline()
'wo bu shi ni ba ba\n'
>>> f.readline()
'dui de'
>>> f.readline()
''

4.3.3.3 指定读取字节数

文件对象.read(字节数)
文件对象.readline(字节数)

例如

>>> f = open("The Zen of Python.txt")
>>> f.readline()
'wo shi ni ba ba\n'
>>> f.readline(6)
'wo shi'
>>> f.read(15)
' ni ye ye \nwo b'
>>> f.readline(100)
'u shi ni ba ba\n'

4.3.3.4 import this文本例子

>>>import this

4.4.4 向文件中写入数据

write(写入内容)

在使用write()函数之前，要确保open()函数的访问模式，是支持写入的。否则会出错
写入成功之后，会返回写入的字符数，是一个整数

f = open("myfile.txt",'w')
f.write("Hello, World!")
f.close()

4.4.5 一个完整的文件读写

>>> f = open("myfile.txt",'w')
>>> f.write("Hello!")
6
>>> f.close()
>>> f = open("myfile.txt")
>>> f.read()
'Hello!'
>>> f.close()
>>> f = open("myfile.txt",'a')
>>> f.write("World!")
6
>>> f.close()
>>> f = open("myfile.txt")
>>> f.read()
'Hello!World!'
>>> f.close()
>>> f = open("myfile.txt",'w')
>>> f.write("Python3.0")
9
>>> f.close()
>>> f = open("myfile.txt")
>>> f.read()
'Python3.0'
>>> f.close()

4.5 异常处理

异常：程序运行时的错误，对应一个Python对象。

4.5.1 try-except语句

try:
	语句块
except 异常1 as 错误原因:
	出现异常1后的处理代码
except 异常2 as 错误原因:
	出现异常2后的处理代码

错误原因是一个标识符
在程序运行时，解释器尝试解释try语句块中的所有代码
如果执行完之后没有异常发生，就会忽略except后面的所有代码。
而当某个except指定的异常发生后，会忽略try语句块中剩余的语句，直接跳转到异常处理代码中执行

例子：

try:
	aList = [0,1,2]
	print(aList[3])
	print("try语句块继续执行中......")
except IndexError as e:
	print(e)
	print("异常已处理")
print("程序继续执行中......")

运行结果：

list index out of range
异常已处理
程序继续执行中......

4.5.2 Python中常见的异常

IOError：输入/输出异常；基本是无法打开文件
ImportError：无法导入模块或包；基本是路径问题或名称错误
IndentationError：缩进错误；代码可能没有正确的对齐
NameError：没有声明、或初始化对象
KeyError：试图访问字典中不存在的键
AttributeError：试图访问一个对象没有的属性
TypeError：类型不匹配
ValueError：传入一个调用者不期望的值，即使值的类型是正确的
Exception：所有非系统退出类异常

4.5.3 Python异常类的继承关系

在这里插入图片描述
但是通常不会向右边那样做，因为那样会捕获到程序员意想不到的错误

4.5.4 finally子句

try:
	语句块
except 异常 as 错误原因:
	出现异常后的处理代码
finally:
	语句块

无论异常是否发生，是否捕捉都会执行的代码。
如果try中没有出现任何的错误，会跳过except语句块，执行finally语句块中的内容
如果出现异常，会先执行异常的处理代码，然后执行finally中的语句块
无论如何都会被执行的内容，因此常被用来关闭资源，清零的工作

例如：

try:
    print("try语句块开始")
    f = open('test.txt')
    print(f.read())
    print("try语句块结束")
except IOError as e:
    print("except子句")
    print(e)
finally:
    print("finally子句")
    f.close()

假定该目录下，存在text.txt，且内容仅一个1，不存在文件text1.txt
则，打开test.txt时，输出为

try语句块开始
1
try语句块结束
finally子句

则，打开tes1.txt时，输出为

try语句块开始
except子句
[Errno 2] No such file or directory: 'test1.txt'
finally子句
Traceback (most recent call last):
  File "first.py", line 11, in <module>
    f.close()
NameError: name 'f' is not defined

4.6 上下文管理器

4.6.1 访问文件

f = open("mypython.txt")
print(f.read())
f.close()

运行结果：

Pyhton3.0

4.6.2 异常处理

为了避免找不到语句而中断执行，使用异常处理语句改善

try:
	f = open("mypython.txt")
	print(f.read())
except IOError as e:
	print(e)
finelly:
	f.close()

运行结果，假如没有mypython.txt文件，程序出现错误也不会停止：

[Errno 2] No such file or directory: 'mypython.txt'

4.6.3 with语句

为了简化代码，对资源操纵后的清除工作

with open("mypython.txt") as f:#首先打开文件，将对象返回给f
	print(f.read())#并打印出内容
	# with语句执行完，会自动关闭文件

with语句执行完，会自动关闭文件
代码更加的简洁
无论是否出现异常，都会释放资源
可以替换try except语句

4.6.4 上下文管理器

使用了上下文管理器，使用了上下文管理器，就会按照规定的顺序退出，即使发生异常依然成立
实现__enter__()方法和__exit__()方法、

class A():
	def __init__(self,val_a):
		self.a = val_a
	def __enter__(self):
		print("class A's __enter__function.")
	def __exit__(self,exc_type,exc_val,exc_tb):
	print("class A's __exit__function.")

上述可以使用with语句来访问它

with 上下文管理器表达式 [as 变量]:
	语句块

上下文管理器表达式 可以是一个对象，也可以是一个函数，对象必须是上下文管理器对象，函数也必须返回一个上下文管理器对象

with open("mypython.txt") as f:
	print(f.read())

在with语句块执行前，首先会执行__enter__()方法，as是可选的，如果选择了，就把enter语句的返回值赋给它，否则就会丢弃返回值。
在这个文件操作的例子中，enter方法返回一个文件对象，并将其赋给f，在with语句结束时，无论是否出现异常，都会调用__exit__()方法，因此可以将释放清楚的操作写在这里
__exit__()方法有三个参数；如果with语句块正常结束，那么这三个参数都是none；如果发生异常，那么这三个参数的值分别是异常的类、实例、跟踪记录
可以把分配资源的操作写在__enter__()方法
可以把释放资源的操作写在__exit__()方法

例子：

class File():#是一个上下文管理器
	def __init__(self,filename,mode):#首先，声明文件类，filename文件名，mode访问方式
		print("执行__init__()方法")
		self.filename = filename
		self.mode = mode
	def __enter__(self):
		print("执行__enter__()方法")
		self.f = open(self.filename,self.mode)# 打开文件
		return self.f#返回文件对象
	def __exit__(self, *args):
		print("执行__exit__方法")
		self.f.close()#关闭文件


with File('mypython.txt','r') as f:
	print(f.read())

执行结果：

执行__init__()方法
执行__enter__()方法
Python3.0
执行__exit__方法

采用这种方法，即使执行过程中出现异常，exit语句也会被执行，文件也会被关闭。