1.基础知识
01.注释：.# 号右侧的文字
001.定义：解释信息，给读者看或者备忘的作用
002.快捷键：crtl+/(注释或取消注释)
02.print 打印输出，内建函数/方法--------共享工具箱中的工具
001.默认以换行结尾，为了不以换行结尾可以
print('a',end='')
print('b',end='')
print('c',)
输出：abc
002.以空格结尾
print('a',end=' ')
print('b',end=' ')
print('c',)
输出：a b c
03.转义字符：反斜杠加字符组合表示特殊含义
\' 表示'
\\ 表示\
\n 表示换行
\t 表示制表符
字符结尾用\ 表示连接下一行的字符，两行物理行实际是一行逻辑行
str3="This is the first sentence. \
This is the second sentence."
print(str3)
输出：This is the first sentence. This is the second sentence.
04.输出原始字符串：把转义字符拆成\+普通字符
001.输出原始的转义字符
#错误方法：输出的是换行
str4="Newlines are indicated by \n"
print(str4)
输出：
Newlines are indicated by
#正确方法：输出的是\n
str4=r"Newlines are indicated by \n"
print(str4)
输出：
Newlines are indicated by \n
05.input 从终端读入字符串---共享工具箱中的工具
result=input(argument)
#方法1
result=input('从终端读入一串字符串：')
print('终端读出的数据是：'+result)
#方法2
str5='从终端读入一串字符串：'
result=input(str5)
print('终端读出的数据是：'+result)
#方法3
result=input()
print('终端读出的数据是：'+result)
06.dir函数---共享工具箱中的工具
返回对象定义的名列表，若对象是模块，则包括函数类定义的函数、变量与类
001.创建一个新的变量
# 给出当前模块的属性名称
>>> dir()
['__builtins__', '__doc__','__name__', '__package__']
# 创建一个新的变量 'a'
>>> a = 5
>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'a']
# 删除或移除一个名称
>>> del a
>>> dir()
['__builtins__', '__doc__', '__name__', '__package__']
2.变量的理解
01.变量：申请一块合适的空间，存储变量中的值
变量----------------------------------1栋储物大厦或储物塔（容器）
变量类型（不同变量类型不同功能） --------- ---- 房间所在楼层（按楼层区分类型，不同楼层有不同的工具包）
变量名称 ------------------------------------- 新建一个房间命名
数据（值）------------------------------------往房间里面存放东西
001.变量赋值，不需要类型声明
如：str=1
str1='字符'
02. 数据类型： 6个标准的数据类型------六个基础楼
001.Numbers(数字)-----------第一层
002.String(字符串)-------------第二层
003.List（列表）---------------第三层
004.Tuple(元组)----------------第四层
005.Set（集合）---------------第五层
006.Dictionary(字典)----------第六层
007.通过类创建我们自己的类型（自定义数据类型）-----第N层
重点：序列----把字符串、列表、元组统称为序列，都可以通过下标切片，可以通过索引来获取对应的数据，序列可以进行合并操作
03.标识符命名----给房间命名
001.首字母必须为字母或下划线
002.其他部分可以是字母、数字、下划线
003.字母区分大小写
004.命名规范（根据自己的操作习惯）：
·项目名全部小写
·包名全部小写----python文件名称全部小写
·类名首字母大写，如果类名由多个单词组成，每个单词的首字母都要大写
·变量名、方法名首字母小写，如果名称由多个单词组成，每个单词的首字母都要大写。
·常量名全部大写
3.数据类型大解析---各个楼层参观
01.数字（Numbers）：分为整数（Intergers）和浮点数（Floats）
001.如：52.3E-4 表示 52.3 * 10^-4
02.字符串：字符串序列，一串词汇，要变更内容只能重新复制，不允许在原变量值的基础上进行新增、删减、编辑
001.单引号：使用单引号来指定字符串，表示对应的变量是字符串类型
·如：‘你好，世界！’ 'hello every body !!!'
·引号中的字符原样保留，包括空格和制表符
·引号中的转义字符，按照转义内容输出
002.双引号----------“””或‘’‘
·双引号和单引号的机制一样，没有区别
003.三引号
·指定多行字符串
·三引号中的单引号或双引号原样输出，转义字符按照转义内容输出
004.引号嵌套
·都是双引号时，前加转义字符 \
print("print(str+\"你好\")")
·都是单引号时，前加转义字符 \
print('print(str+\'你好\')')
·单引号中嵌套双引号法
print('print(str+"你好")')
·双引号嵌套单引号
print("print(str+'你好')")
005.字符串常用方法：format-----字符串楼层常用工具，字符串.方法
·字符串.format(变量1，变量2)
# format中的参数可以直接用字符串,也可以用变量
print('是谁，{}是我'.format('你'))
str1='你'
str2='我'
print('{}是谁，{}是我'.format(str1,str2))
·format中有{}数<=format中参数个数
#错误写法：print('{}是谁，{}是我'.format('你'))
print('{}是谁，我是我'.format('你'))
·{}没有标记下标，自动按顺序匹配
print('{}是谁，{}是我'.format('你','我'))
·{}下标从0开始
#错误写法：print('{1}是谁，{2}是我'.format('你','我'))
#正确写法
print('{0}是谁，{1}是我'.format('你','我'))
print('{1}是谁，{0}是我'.format('你','我'))
·也可以按照参数格式化
#错误写法：print('{str1}是谁，{str2}是我'.format(str1,str2))
#正确写法
print('{str1}是谁，{str2}是我'.format(str1='你',str2='我'))
print('{str2}是谁，{str1}是我'.format(str1='你',str2='我'))
· 参数可以具体化
#1.规定小数点后几位
print("{0:.6f}".format(1/3))
·规定字符串位数按什么填充，居中显示
print('{0:~^20}'.format('hello'))
006. 字符串简单操作
·+ 合并两个字符串
print('你好','吗？') 输出：你好 吗？
print('你好'+'吗？') 输出：你好吗？
·*复制字符串为多份并连接成为一个新的字符串
print('哈'*10)
输出：哈哈哈哈哈哈哈哈哈哈
007.访问子字符串-----字符串楼层，一个房间存储一串字符，一个房间有多个抽屉，每个字符存放在单个抽屉里面，抽屉与抽屉之间空气隔离
str1='Hello world!'
print(str1[0])#下标从0开始，表示第一个
print(str1[5])#显示空格
print(str1[2:7])#从第3个字母到第6个字母
008.Python字符串相关内建函数----共享工具箱中关于字符串的常用工具，以字符串为参数
03.列表
001.概念：用于保存一系列有序项目的集合，类似于购物清单、任务清单，可以删除、新增和编辑、搜索，是一种可变的数据类型
002.创建一个列表-------列表楼层新建房间用[]隔开，字符楼层新建房间用''隔开，元组楼层新建房间用（）隔开，集合楼层新建房间用{}隔开，字典楼层新建房间也用{}隔开
list1=[1,2,3,4]
list2=['a','b','d','d']
print(list1) 输出内容：[1,2,3,4]
print(list2) 输出内容：['a','b','d','d']
·字符原样输出，包括[]和转义字符
003.访问一个列表---列表串楼层，一个房间存储一串数据，一个房间有多个抽屉，每个数据存放在单个抽屉里面，抽屉与抽屉之间用逗号‘，’隔离，其中逗号也是列表中的一份子
list[0]
list[1:3]
示例：
list1=[1,2,3,4]
print(list1)
list2=['a','b','c','d']
print(list2)
print('list2[0]:',list2[0])
print('list2[1:3]:',list2[1:3])
输出：
[1, 2, 3, 4]
['a', 'b', 'c', 'd']
list2[0]: a
list2[1:3]: ['b', 'c']
004.更新列表-----更改抽屉里面的值
给列表元素赋新的值
list2=['a','b','c','d']
print(list2)
list2[1]='更新值'
print(list2)
输出：
['a', 'b', 'c', 'd']
['a', '更新值', 'c', 'd']
005.删除列表数据----删掉一个抽屉
del 元素
示例：
list2=['a','b','c','d']
print(list2)
del list2[1]
print(list2)
输出：
['a', 'b', 'c', 'd']
['a', 'c', 'd']
006.列表脚本操作符
+ 合并两个列表，即放到同一个房间里面
示例：
list2=['a','b','c','d']
list1=[1,2,3]
print(list1+list2)
输出：
[1, 2, 3, 'a', 'b', 'c', 'd']
* 列表复制输出
示例：
list2=['a','b','c','d']
list1=[1,2,3]
print(list1*2)
输出：
[1, 2, 3, 1, 2, 3]
007.列表的使用
for x in [1, 2, 3]: print(x, end=" ") 迭代输出列表中的内容
示例：
list2=['a','b','c','d']
for i in list2:
print('i的值是',i)
输出：
i的值是 a
i的值是 b
i的值是 c
i的值是 d
示例：
list2=['a','b','c','d']
for i in list2:
print(i,end=' ')
输出：
a b c d
008.列表嵌套
示例：
a=['a','b','c','d']
b=[1,3,5]
c=[a,b]
print(c)
#错误写法print(a[1]+b[2])-----a[1]得到的是字符串元素，b[2]得到的是数字元素，两者不能合并
print(a[1],b[2])
x=c[0][3]#列表第1个元素，第一个子列表的第4个元素
print(x)
输出：
[['a', 'b', 'c', 'd'], [1, 3, 5]]
b 5
d
009.列表相关函数---共享工具箱中与列表有关的函数，以列表为参数
| 序号 | 函数 |
| 1 | 列表元素个数 |
| 2 | 返回列表元素最大值 |
| 3 | 返回列表元素最小值 |
| 4 | 将元组转换为列表 |
示例：
a=['a','b','aec333','d']
b=[1,6,5]
print(max(a))
print(max(b))
输出：
d
6
010.列表的方法------列表楼层专属工具，列表.方法（）
| 序号 | 方法 |
| 1 | 在列表末尾添加新的对象 |
| 2 | 统计某个元素在列表中出现的次数 |
| 3 | 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 4 | 从列表中找出某个值第一个匹配项的索引位置 |
| 5 | 将对象插入列表 |
| 6 | 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 7 | 移除列表中某个值的第一个匹配项 |
| 8 | 反向列表中元素 |
| 9 | list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序 |
| 10 | 清空列表 |
| 11 | 复制列表 |
04.元组：将多个对象保存到一起，近似列表，但是不可以编辑、删除，和字符串类型一样是不可变的数据类型----元组楼层
001.除了不允许更新、删除，其他都和列表一致，包括内建函数和元组方法
05.集合（set）-简单对象的无序集合---set把有序列表改成无序列表------集合楼层的数据是通过共享工具set把列表数据转换而来
001.如何得到一个集合变量
bri1=set(['a','b','c']) #无序显示
print(bri1)
bri2=set([1,2,3])
print(bri2)
# print(bri1+bri2) #set不允许合并
print(bri1,bri2)
print('a' in bri1)
结果：
{'b', 'c', 'a'}
{1, 2, 3}
{'b', 'c', 'a'} {1, 2, 3}
True
002.集合不允许访问、更新、删除及合并
06.字典：类似于一个地址簿，键值：地址，键值的类型为不可变数据类型，地址可以为可变数据类型，字典本身是可变数据类型------字典楼层的新建房间用{}隔开
001.字典的定义----字典房间的抽屉通过逗号隔开，抽屉又分成两部分，一一对应的关系，一个地址只能是不可变数据类型（字符型、数字、元组、集合），一个是内容可以为任意数据类型
示例：
zidian={'字符串':'你好啊',4:'数字',(1,2):[1,'e',4]}
print(zidian)
print(zidian['字符串'])
print(zidian[(1,2)])
输出：
{'字符串': '你好啊', 4: '数字', (1, 2): [1, 'e', 4]}
你好啊
[1, 'e', 4]
·每个键和值通过冒号对应，每队键值之间用逗号隔开
·键值必须是不变的:数值、字符串、元组（不能更新、删除），值可以为任何对象
002.访问字典
print(‘zidian['字符串']值是：',zidian['字符串'])
003.修改字典
访问字典，给字典赋予新值
004.删除字典
·示例：
zidian={'字符串':'你好啊',4:'数字',(1,2):[1,'e',4]}
print(zidian)
print(zidian['字符串'])
print(zidian[(1,2)])
del zidian[4]
print(zidian)
zidian.clear() #清空字典
print(zidian)
del zidian
# print(zidian) #这样删除后，系统引发异常
输出：
{'字符串': '你好啊', 4: '数字', (1, 2): [1, 'e', 4]}
你好啊
[1, 'e', 4]
{'字符串': '你好啊', (1, 2): [1, 'e', 4]}
{}
005.注意项
·不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
·键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
·print(dict1+dict3) #两个字典类型不允许合并
·#字典通过键值访问，通过下标访问出错
006.字典内置函数---与字典相关共享工具，以字典为参数
| 序号 | 函数及描述 |
| 1 | len(dict) 计算字典元素个数，即键的总数。 |
| 2 | str(dict) 输出字典以可打印的字符串表示。 |
| 3 | type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。 |
007.字典专属方法----字典楼层相关工具，字典.方法（）
| 序号 | 函数及描述 |
| 1 | |
| 2 | |
| 3 | |
| 4 | |
| 5 | |
| 6 | |
| 7 | |
| 8 | |
| 9 | |
| 10 |
4.运算符与表达式
01.操作数1 运算符 操作数2
a + b
02.算术运算符
+
注意：+ 连接两个字符串
-
*
注意：
*复制字符串为多份并连接成为一个新的字符串
print('哈'*10)
输出：哈哈哈哈哈哈哈哈哈哈
/
//整除，向下靠近除数的整数
9//2=4
-9
%取余
** 幂，返回x的y次幂
注意，print赋参数值格式
#正确写法
print('a/b=',c)
#错误写法：print('a/b='+c),这里与java要区分开来
03.关系运算符
==
!=
>
<
>=
<=
04.赋值运算符
=
+=
-=
*=
/=
//=
%=
**=
05.逻辑运算符
and 与 a and b,若a为真，则值为b，若a为假，则值为false 1 and 0 非0为true，0为false
or 或 a or b,若a为真，则值为a，若a为假，则值为b
not 非 not a ，若a为真，则值为false，若a为假，则值为true
06.位运算符
07.成员运算符
08.身份运算符
09.运算符优先级
10.占位符（格式字符串%）---先把位置占了，告诉这是**数据类型，后面的值直接填充到占位符的位置
%s 字符串占位符
%d 整型占位符
%f 浮点占位符
{}空白占位符，可以填充任意类型的数值
{具体序号}序号占位符，参数列表会按序号的位置进行一一对应
举例：
num='helloworld'
print('%s is base'%num)
输出：helloworld is base
5.控制流
01.if语句
001.if..elif..else
number=100
guess=int(input('请猜一个数字：'))
if guess==number:
print('恭喜你，你猜中了！！！')
elif guess<number:
print('猜小了，请继续')
else:
print('猜大了，请继续')
print('done')
输出：
请猜一个数字：100
恭喜你，你猜中了！！！
done
02.while语句
001.循环语句
number=100
bianliang=True#True首字母一定要大写，写成true报错
while bianliang:
guess=int(input('请输入一个数据:'))
if guess==number:
bianliang=False;#False首字母一定要大写，写成false报错
print('停止猜测')
elif guess<number:
print('猜小了，继续猜')
else:
print('猜大了，请继续')
#当变量不为true的时候，执行else的代码块
else:
print('这里起的作用是啥')
print('执行下一条语句')
03.for...in..----遍历语句，从列表中或者元组中一个一个取出抽屉里面的数据
for i in range(1,6,2):#1,3,5 间距是2
print('你好',i)
else:
print('退出循环')
输出：
你好 1
你好 3
你好 5
退出循环
04.break 退出循环，直接退出循环条件
6.函数
01.函数定义：可重复使用的程序片段------理解为：可以共享的工具
示例：
def sayHello():
print('helloworld!')
sayHello()
sayHello()
输出：
helloworld!
helloworld!
02.函数的参数------把函数当作一个抓娃娃机，输入的是银币，执行函数的过程是抓娃娃的过程，输出的有返回值类似于抓到了娃娃，没有返回值类似于没抓到娃娃
函数的参数与变量类似，在我们调用函数的时候已被定义，在执行的时候已经赋值完成
形参：在定义函数时给的变量名
实参：在调用函数时赋给变量的值
示例：
def biJiao(a,b):
if(a>b):
print(a,'是较大值')
elif(a==b):
print('两个值相等')
else:
print(b,'是较大值')
biJiao(3,7)
biJiao(4,4)
biJiao(8,3)
#另一种方法
x=5
y=9
biJiao(x,y)
输出：
7 是较大值
两个值相等
8 是较大值
9 是较大值
03.局部变量
在函数中定义的变量，与函数外的变量名称相同也不会有关联，作用域就在本函数代码块中
示例：
def zuoyongyu(x):
print('x is ',x)
x=2
print('把参数的值转换成其他数值',x)
zuoyongyu(x)
print('x的值仍然是',x)
输出：
x is 10
把参数的值转换成其他数值 2
x的值仍然是 10
04.全局变量 global语句
声明该变量为全局变量
05.默认参数值
示例：
def func(x,y=6):
print(x*y)
func(5)
func(5,1)
输出：
30
5
06.关键字参数
示例：
def func(x,y=6,z=7):
print(x*y*z)
func(5)
func(5,1)
func(25,z=7)
func(z=7,x=5)
func(y=1,x=3)
func(6,z=1,y=2)
输出：
210
35
1050
210
21
12
07.可变参数
*param 从此处开始到结束的所有位置参数 1，2，3,汇集成一个元祖
**param 从此处开始到结束时的关键字参数 jack=1123,john=233,汇集成一个字典
示例：
def func(a,*param,**param1):
print('a',a)
for i in param:
print('遍历元组：',i)
for j,k in param1.items():#遍历字典中的键和值
print(j,'\t',k)
func(10,1,2,3,i=1123,j=145,k='4io')#1，2，3组成元祖，i=1123,j=145,k='4io'组成字典
输出：
a 10
遍历元组： 1
遍历元组： 2
遍历元组： 3
i 1123
j 145
k 4io
08.return----类似于返回值，转到的娃娃
001.示例
def func1(x,y):
if(x>y):
return x
elif x==y:
print('x==y')
#默认 return None
else:
return y
str=func1(3,3)
print(str)
输出
x==y
None
09.pass
def func():
pass
func()
输出：空
作用：在编写代码时，只写框架思路如何实现还么有想好，先占位，为了运行不报错，加pass
010.DocSrtings文档字符串
文档字符串所约定的是一串多行字符串，其中第一行以某一大写字母开始，以句号结束。
第二行为空行，后跟的第三行开始是任何详细的解释说明。 在此强烈建议你在有关你所有非
凡功能的文档字符串中都遵循这一约定
011.Python函数指针(别名)----------也可以是简称，比如娃娃机简称WJ
def function():
print('HelloWorld')
foo=function
foo()
输出：
HelloWorld
7.类---新建一个楼层
01.类的定义-----如何新建楼层
class LouCeng:
def louCengTool(self,a,b):-------self自动带入，表示该类的方法，就是说该楼层的工具
print（‘hello new LouCeng’）
str=LouCeng()-------新建楼层中的一个房间
print(str)-----输出的是：<__main__.lei object at 0x00000000021124A8> #类存储地址
str.louCengTool(1,2)
02.__init__方法
001.python不少类的名称有特殊意义
002.__init__方法：类的对象被实例化（Instantiated）时立即运行。这一方法可以对任何你想
进行操作的目标对象进行初始化（Initialization）操作
不会显式地调用 __init__ 方法
示例
class teshu:
def __init__(self, name):#__init__名称改成别的名称，程序运行报错TypeError: teshu() takes no arguments
self.name=name
def sayhell(self):
print('hello ',self.name)
shil = teshu('Swaroop')#初始化参数__init__方法中的参数name
shil.sayhell()
输出：
hello Swaroop
03.@classmethod +函数
001.定义：classmethod修饰的函数不需要实例化，不需要self参数，但第一个参数需要是表示自身类的cls参数，可以来调用类的属性，类的方法，实例化对象等
04.类的私有方法、类的保护方法、类的公共方法---------不同的工具，有私密工具，也有只给子类和自身用的工具，有供所有人用的工具
001._xxx "单下划线 " 开始的成员变量叫做保护变量，意思是只有类对象（即类实例）和子类对象自己能访问到这些变量，需通过类提供的接口进行访问；不能用'from module import *'导入-----------只能给本身类新建的房间和本身子女类新建的房间使用，子类也可以重载这类方法
002.__xxx 类中的私有变量/方法名 （Python的函数也是对象，所以成员方法称为成员变量也行得通。）," 双下划线 " 开始的是私有成员，意思是只有类对象自己能访问，连子类对象也不能访问到这个数据。------------只能给本身类使用，子类可以重载这类方法，覆盖方法
003.__xxx__ 系统定义名字，前后均有一个“双下划线” 代表python里特殊方法专用的标识，如 __init__() 代表类的构造函数。
示例：
class Person:
def __init__(self,name,age):
self.name=name
self.age=age
print('这是类的构造函数')
def __private(self):
print('这是类的私有方法') #只能在类内部使用，但可以重载
def _protect(self):
print('这是类的保护方法')
self.__private() #只能在类内部使用
def public(self):
print('这是类的共用方法')
person=Person('张三',20)
# person.__private() #不可以在类定义外部使用私有方法
person._protect()
person.public()
class Women(Person):
def __init__(self,name,age,face):
Person.__init__(self,name,age) #构造函数的继承
self.face=face
print(self.face)
self._protect()
def __private(self):
# Person.__private(self) 私有变量不能继承
print('这是子类的私有方法') #私有变量的重载
def _protect(self):
print('这是子类的保护方法') #保护变量的重载
self.__private()
def public(self):
Person.public(self) #父类的继承
print('这是子类的共用方法')
women=Women('李四',18,'漂亮')
women._protect() #调用子类的保护方法
women.public() #调用子类的共用方法
输出：
这是类的构造函数
这是类的保护方法
这是类的私有方法
这是类的共用方法
这是类的构造函数
漂亮
这是子类的保护方法
这是子类的私有方法
这是子类的保护方法
这是子类的私有方法
这是类的共用方法
这是子类的共用方法8.模块
01.定义：一个模块可以被其他程序导入并运用其功能，被引用的模块，应该与引用程序防止在同一个目录下，或者放置在sys.path所列出的目录下，.py文件都可以是一个模块-----可以理解为引他人之石，拿来主义
02.import和from..import 和from..import *的区别
001.调用的时候还是要加上 调用：模块.函数
002.from..import 具体函数 导入具体的函数 调用：具体函数
003.from..import * 导入所有函数和变量 调用：具体函数
03.举例：os.system（command）
001.command 要执行的命令，相当于在Windows的cmd窗口中输入的命令。如果要向程序或者脚本传递参数，可以使用空 格分隔程序及多个参数。
002.示例：
import os
os.system('ping www.baidu.com')
os.system('cls')
输出：
���� Ping www.a.shifen.com [14.215.177.39] ���� 32 �ֽڵ�����:
���� 14.215.177.39 �Ļظ�: �ֽ�=32 ʱ��=5ms TTL=55
���� 14.215.177.39 �Ļظ�: �ֽ�=32 ʱ��=5ms TTL=55
9.异常
01.错误
001.NameError: name 'rint' is not defined
002.SyntaxError: invalid syntax 语法错误
02.异常
001.举例
示例：
str=input('somet')
输出：
somet^D （键盘输入Ctrl+d）
Traceback (most recent call last):
File "C:/Users/niedujuan/PycharmProjects/untitled/y菜单ichang.py", line 1, in <module>
str=input('somet')
EOFError: EOF when reading a line
03.处理异常
001.try...except...except
示例：
try:
text=input('输入一些内容：')
except EOFError:
print('这是一个EOFError异常')
except KeyboardInterrupt:
print('这是你取消了操作')
else:
print('你输入了：{}'.format(text))
print(text)
输出：
输入一些内容：fdsk^D
这是一个EOFError异常
002.至少有一句 except 字句与每一句 try 字句相关联
04.抛出异常
class zidingyiyichang(Exception):
def __init__(self,x,y):
Exception.__init__()
self.x=x
self.y=y
try:
text=input('请输入一些内容')
except EOFError:
print('这是一个EOFError异常')
except zidingyiyichang as ex: #as,表示代替前面的一个对象，类似于简称，前一个对象的别称
print('{}+{}'.format(ex.x,ex.y))
else:
print('没有抛出异常')
05.try...finally 文件关闭之前一定会执行finally中的内容
import time
f = None
try:
f =open('input.txt')
# 我们常用的文件阅读风格
while True:
line = f.readline()
if len(line) == 0:
break
print(line, end='')
sys.stdout.flush()
print("Press ctrl+c now")
# 为了确保它能运行一段时间
time.sleep(2) #每打印一行后插入2s休眠
except IOError:
print("Could not find file poem.txt")
except KeyboardInterrupt:
print("!! You cancelled the reading from the file.")
finally:
if f:
f.close()
print("(Cleaning up: Closed the file)")
06.with语句
001.Python的with语句是提供一个有效的机制，让代码更简练，同时在异常产生时，清理工作更简单 有一些任务，可能事先需要设置，事后做清理工作。对于这种场景，Python的with语句提供了一种非常方便的处理方式。一个很好的例子是文件处理，你需要获取一个文件句柄，从文件中读取数据，然后关闭文件句柄。 如果不用with语句，代码如下：
file = open("/tmp/foo.txt") data = file.read() file.close()
这里有两个问题。一是可能忘记关闭文件句柄；二是文件读取数据发生异常，没有进行任何处理。下面是处理异常的加强版本：
file = open("/tmp/foo.txt") try: data = file.read() finally: file.close()
虽然这段代码运行良好，但是太冗长了。这时候就是with一展身手的时候了。除了有更优雅的语法，with还可以很好的处理上下文环境产生的异常。下面是with版本的代码：
with open("/tmp/foo.txt") as file: data = file.read()
07.常见错误异常
001.exception IndexError索引错误异常
002.exception KeyError 键错误异常
003.exception NameError 名字错误异常
004.exception TypeError类型错误异常
005.exception ValueError值错误异常
006.exception ZeroDivisionError零除异常
007.SyntaxError: invalid syntax 语法错误
008.IndentationError:unindent does not match any outer indentation level 缩进错误
009.AttributeError:引包错误
10.JSON 教程
01.JSON：JavaScript 对象表示法（JavaScript Object Notation）
02.JSON 是存储和交换文本信息的语法。类似 XML。
03.JSON 比 XML 更小、更快，更易解析。
04.一个典型的json例子
{
"公司"："加油宝",
“员工”：[
{''姓氏''："赵"，"名字"："江"}，
{''姓氏''："赵"，"名字"："江"}，
{''姓氏''："赵"，"名字"："江"}，
]
}
001.数据在“名称”：“值”中
002.数据由,隔开
003.花括号保存对象
004.方括号保存数组
05.JSON 文件
001.JSON 文件的文件类型是 ".json"
002.JSON 文本的 MIME 类型是 "application/json
06.python字典格式美化成json格式
import json
jsonstr1={'name':'张三','age':18,'身高':180}
jsonstr2=((1,2),(2,3),('你','好','吗？'))
print(jsonstr1)
print(jsonstr2)
print(json.dumps(jsonstr1))
print(json.dumps(jsonstr1,ensure_ascii=False))
print(json.dumps(jsonstr1,ensure_ascii=False,indent=2))
print(json.dumps(jsonstr2))
print(json.dumps(jsonstr2,ensure_ascii=False))
print(json.dumps(jsonstr2,ensure_ascii=False,indent=2))
输出：
452
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
