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))
输出: