Python 学习笔记

2022-11-28 12:41:02

文章目录

Python简介
- 优点
- 应用场景
Python下载和安装
Python 基础语法

Python简介

面向对象，面向函数的解释型语言

优点

简单易学，让你专注于解决问题
可移植性，Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）
解释性。不同于c和c++这种编译语言，他不需要编译成0和1这种二进制代码。可以直接从源程序直接运行。
可扩展性，如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分程序用C或C++编写，然后在你的Python程序中使用它们。
丰富的库！Python标准库确实很庞大。它可以帮助你处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。记住，只要安装了Python，所有这些功能都是可用的。这被称作Python的“功能齐全”理念。除了标准库以外，还有许多其他高质量的库，如wxPython、Twisted和Python图像库等等。
规范的代码，Python采用强制缩进的方式使得代码具有极佳的可读性。

应用场景

Web开发，Django框架
操作系统管理、服务器运维的自动化脚本。在很多操作系统里，Python是标准的系统组件。一般说来，Python编写的系统管理脚本在可读性、性能、代码重用度、扩展性几方面都优于普通的shell脚本。
科学计算机器学习，NumPy,SciPy,Matplotlib可以让Python程序员编写科学计算程序。
服务器软件（网络软件）——阿里云，Python对于各种网络协议的支持很完善，因此经常被用于编写服务器软件、网络爬虫。

Python下载和安装

安装anaconda pycharm

Python 基础语法

注释

# 单行注释
'''
多行注释
'''

变量及类型

注意：

method和function的区别：在对象内部的叫method对象外边的叫function
Python中区分大小写

#这叫函数
def fun():
    print("fun")

#这个叫方法
class Person:
    def eat(sel):
        print("person.run")

fun()

Person.eat()

变量定义和使用

if __name__ == '__main__':
    a = 10
    b="adf"
    print(b)
    print(type(b))

布尔值：True False
可以使用and or not运算
空值：None
查看变量类型：type(变量名)

常见类型转换函数

函数	说明
int(x [,base ])	将x转换为一个整数
long(x [,base ])	将x转换为一个长整数
float(x )	将x转换到一个浮点数
complex(real [,imag ])	创建一个复数
str(x )	将对象 x 转换为字符串
repr(x )	将对象 x 转换为表达式字符串
eval(str )	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s )	将序列 s 转换为一个元组
list(s )	将序列 s 转换为一个列表
chr(x )	将一个整数转换为一个字符
unichr(x )	将一个整数转换为Unicode字符
ord(x )	将一个字符转换为它的整数值
hex(x )	将一个整数转换为一个十六进制字符串
oct(x )	将一个整数转换为一个八进制字符串

输入和格式化输出

输入

input()

输入的是str

如果需要int型的就需要转换

format格式化输出

格式化输入一半format函数用的比较多

if __name__ == '__main__':
    s1 = "{}{}".format("aaa", "bbb")
    s2 = "{0}{1}".format("bbb", "aaa")
    s3 = "{1}{0}{1}".format("aaa", "bbb")
    s4 = "网站地址：{url} 网站名称：{name}".format(url="www.kjzg.top", name="泽国科技")
    # 通过字典设置参数
    site = {"name": "泽国科技", "url": "www.kjzg.top"}
    s5 = "网站地址：{url} 网站名称：{name}".format(**site)

    # 通过列表索引来设置参数
    my_list = ['泽国科技', "www.kjzg.top"]
    s6 = "网站名：{0[0]}, 地址 {0[1]}".format(my_list)


    # 通过对象来传递
    class value(object):
        def __init__(self, value):
            self.value = value


    v = value(6)
    print("value={0.value}".format(v))

数字	格式	输出	描述
3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	+3.14	带符号保留小数点后两位
-1	{:+.2f}	-1.00	带符号保留小数点后两位
2.71828	{:.0f}	3	不带小数
5	{:0>2d}	05	数字补零 (填充左边, 宽度为2)
5	{:x<4d}	5xxx	数字补x (填充右边, 宽度为4)
10	{:x<4d}	10xx	数字补x (填充右边, 宽度为4)
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00e+09	指数记法
13	{:>10d}	13	右对齐 (默认, 宽度为10)
13	{:<10d}	13	左对齐 (宽度为10)
13	{:^10d}	13	中间对齐 (宽度为10)

运算符

运算符	描述	实例
+	加	两个对象相加 a + b 输出结果 30
-	减	得到负数或是一个数减去另一个数 a - b 输出结果 -10
*	乘	两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/	除	x除以y b / a 输出结果 2
//	取整除	返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
%	取余（取模）	返回除法的余数 b % a 输出结果 0
**	幂	返回x的y次幂 a**b 为10的20次方，输出结果 100000000000000000000

逻辑运算符

and or not

比较运算符

逻辑判断和循环

逻辑判断：if elif else
while循环：while 条件：
for循环: for 临时变量 in 列表或者字符串等：
break和continue

字符串

下标索引

if __name__ == '__main__':
    s="abc"
    print(s[1])

切片（分片）

切片的语法

[起始:结束:步长]
选取时左闭右开
步长可以取负数
起始结束不放就是整个字符串

    s="abcdefg"
    print(s[1:6:2])

常见字符串操作

方法	简介	例子
find == java Indexof方法	检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回	mystr.find(str, start=0, end=len(mystr))
index	跟find()方法一样，只不过如果str不在 mystr中会报一个异常.	mystr.index(str, start=0, end=len(mystr))
count	返回 str在start和end之间在 mystr里面出现的次数	mystr.count(str, start=0, end=len(mystr))
replace	把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.	mystr.replace(str1, str2, mystr.count(str1))
split	以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串	mystr.split(str=" ", 2)
capitalize	把字符串的第一个字符大写	mystr.capitalize()
title	把字符串的每个单词首字母大写
startswith	检查字符串是否是以 obj 开头, 是则返回 True，否则返回 False	mystr.startswith(obj)
endswith	检查字符串是否以obj结束，如果是返回True,否则返回 False.	mystr.endswith(obj)
lower	转换 mystr 中所有大写字符为小写	mystr.lower()
upper	转换 mystr 中的小写字母为大写	mystr.upper()
ljust	返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串	mystr.ljust(width)
rjust	返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串	mystr.rjust(width)
center	返回一个原字符串居中,并使用空格填充至长度 width 的新字符串	mystr.center(width)
lstrip	删除 mystr 左边的空白字符	mystr.lstrip()
rstrip	删除 mystr 字符串末尾的空白字符	mystr.rstrip()
strip —java trim	删除mystr字符串两端的空白字符
rfind	类似于 find()函数，不过是从右边开始查找.	mystr.rfind(str, start=0,end=len(mystr) )
rindex	类似于 index()，不过是从右边开始.	mystr.rindex( str, start=0,end=len(mystr))
partition	把mystr以str分割成三部分,str前，str和str后	mystr.partition(str)
rpartition	类似于 partition()函数,不过是从右边开始.	mystr.rpartition(str)
splitlines	按照换行符分隔，返回一个包含各行作为元素的列表	mystr.splitlines()
isalpha	如果 mystr 所有字符都是字母则返回 True,否则返回 False	mystr.isalpha()
isdigit	如果 mystr 只包含数字则返回 True 否则返回 False.	mystr.isdigit()
isalnum	如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False	mystr.isalnum()
isspace	如果 mystr 中只包含空格，则返回 True，否则返回 False.	mystr.isspace()
join	mystr 中每个字符后面插入list的每个元素后面,构造出一个新的字符串	mystr.join(list)

总结

查找字符串：
find：找不到返回-1   ，都是从左边找，右边查找r
index：找不到报错

列表

    l=["a","b","c"]
    print(l)
    print(len(l))

获取最后一个元素可以直接取-1

l=["a","b","c"]
    print(l[-1])

列表操作

添加
a = [1, 2]
b = [3, 4]

函数	描述	例子
append	通过append可以向列表添加元素	a.append(b) [1, 2, [3, 4]]
extend	通过extend可以将另一个集合中的元素逐一添加到列表中	a.extend(b) [1, 2, 3, 4]
insert	insert(index, object) 在指定位置index前插入元素object

修改

修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改

查找

in（存在）,如果存在那么结果为true，否则为false
not in（不存在），如果不存在那么结果为true，否则false

删除

del：根据下标进行删除，其实可以删除所有变量，del L[0]
pop：默认删除最后一个元素，L.pop()
remove：根据元素的值进行删除第一个,L.remove()

排序
sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
枚举（enumerate）
list(enumerate(seasons))

元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
定义一个空的tuple， t = ()
只有1个元素的tuple定义时必须加一个逗号，t=(1,)
Python在显示只有1个元素的tuple时，也会加一个逗号,
如果tuple里面包含可变元素，如列表，则列表中的内容是可以修改的，但不能删除元素

字典

key-value

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
d['Michael']

若访问不存在的键，则会报错

在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值

 age = info.get('age')
 type(age)
 <type 'NoneType'>
 
 age = info.get('age', 18) 
 # 若info中不存在'age'这个键，就返回默认值18

字典常见操作

修改
字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改
添加
变量名[‘键’] = 数据
删除

del info[‘name’] 删除指定元素
del info 删除整个字典
clear() 清空字典

字典常见函数

函数	描述
len()	测量字典中，键值对的个数
keys == map.keySet()	返回一个包含字典所有KEY的列表
values	返回一个包含字典所有value的列表
items	返回一个包含所有（键，值）元祖的列表

字典遍历

# 遍历字典的key（键）
for key in dict.keys():
	print key
#遍历字典的value（值）
for value in dict.values()
	print value
#遍历字典key-value（键值对）
d = {"a": 111, "b": 222}
for key, value in d.items():
    print("key={0},value={1}".format(key, value))

注意：

dict内部存放的顺序和key放入的顺序是没有关系的
和list比较，dict有以下几个特点：
- 查找和插入的速度极快，不会随着key的增加而变慢；
- 需要占用大量的内存，内存浪费多。
- 而list相反：查找和插入的时间随着元素的增加而增加；占用空间小，浪费内存很少。
- 所以，dict是用空间来换取时间的一种方法。
- dict的key必须是不可变对象

可变类型与不可变类型

可变类型，值可以改变：
列表 list
字典 dict
set （没有value的字典）
不可变类型，值不可以改变：
数值类型 int, long, bool, float
字符串 str
元组 tuple

Set集合

类型	表示	描述
列表（list）	a=[]	先后顺序，有下标位[index],可以重复，可变类型
元组(tuple)	a=()	有先后顺序，有下标位，元素可以重复，不可变（只能查）
字典(dict)	a={key:value}	没有先后顺序，没有下标，key不可重复，value可以，可变
集合（set）	a=set()	没有先后顺序，没有下标，不可重复，可变类型

注意：使用set，可以快速的完成对list中的元素去重复的功能

函数

定义调用传参

定义：def 函数名(参数1，参数2): 代码
调用：函数名(参数1，参数2)
缺省参数：调用函数时，缺省参数的值如果没有传入，则被认为是默认值。

def printinfo( name, age = 35 ):# 打印任何传入的字符串
print"Name: ", name 
print"Age ", age # 调用printinfo函数

不定长参数：有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。

def functionname([formal_args,] *args, **kwargs):"函数_文档字符串" 
	function_suite 
	return [expression]

加了星号（*）的变量args会存放所有未命名的变量参数，args为元组；而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。

def fun(a, b, *args, **kwargs):
     """可变参数演示示例"""
    print"a =", a 
    print"b =", b 
    print"args =", args 
    print"kwargs: "
    for key, value in kwargs.items(): 
    print key, "=", value 

fun(1, 2, 3, 4, 5, m=6, n=7, p=8) # 注意传递的参数对应 
a = 1 
b = 2 
args = (3, 4, 5) 
kwargs: p = 8 m = 6 n = 7

Python中函数参数是引用传递（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量自身；而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。

返回值

函数返回值：return
python中我们可以返回多个值

>>> def divid(a, b):
... shang = a//b 
... yushu = a%b 
... return shang, yushu 
... 
>>> sh, yu = divid(5, 2) 
>>> sh 5
>>> yu 1
#本质是利用了元组

如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错

a = 10

def halo():
    global a
    a = 20

if __name__ == '__main__':
    print(a)
    halo()
    print(a)
    
10
20

递归函数

递归函数：注意递归边界

def halo(n):
    if n == 1:
        return 1
    return n * halo(n - 1)

匿名函数

匿名函数：lambda。这种函数得名于省略了用def声明函数的标准步骤。
匿名函数的用处
- 作为方法的参数
- 作为内置函数的参数

lambda [arg1 [,arg2,.....argn]]:
	expression

sum = lambda arg1, arg2: arg1 + arg2 #调用sum函数
print"Value of total : ", sum( 10, 20 ) 
print"Value of total : ", sum( 20, 20 )

I/O操作

打开

open(文件名，访问模式)
f = open('d:\nata\test.txt', 'w')

访问模式	说明
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w	打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
w+	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

关闭

f = open('test.txt', 'w') # 关闭这个文件 
f.close()

写数据

f = open('test.txt', 'w')
f.write('hello world, i am here!') 
f.close()

读数据

read(num) 读取num个字节的数据不加num就是直接读取所有数据。如果使用读了多次，那么后面读取的数据是从上次读完后的位置开始的
readlines() 按照行的读取方式直接返回一个列表

文件定位读写

想知道当时的位置用tell()
seek(offset, from)有2个参数
offset:偏移量
from:方向
- 0:表示文件开头
- 1:表示当前位置
- 2:表示文件末尾

文件相关操作

import os

方法	描述
os.name()	判断现在正在实用的平台，Windows 返回 ‘nt’; Linux 返回’posix’
rename(需要修改的文件名, 新的文件名)
os.getcwd()	得到当前工作的目录
os.listdir()	返回指定的文件夹包含的文件或文件夹的名字的列表，不区分文件和文件夹
os.remove()	删除指定文件
os.rmdir()	删除指定目录：该目录不能为空
os.mkdir()	创建一层目录
os.makedirs(x/y/z)	递归建立目录
os.path.isfile()	判断指定对象是否为文件。是返回True,否则False
os.path.isdir()	判断指定对象是否为目录。是True,否则False
os.path.exists()	检验指定的对象是否存在。是True,否则False
os.path.split()	返回路径的目录和文件名
os.system()	执行shell命令
os.chdir()	改变目录到指定目录
os.path.getsize()	获得文件的大小，如果为目录，返回0
os.path.abspath()	获得绝对路径
os.path.join(path, name)	连接目录和文件名
os.path.basename(path)	返回文件名
os.path.dirname(path)	返回文件所在目录

类和对象

特性：继承多态封装
Python3以后的都是新式类
self就是自己
创建对象：对象名 = 类名()

class car():
    def getCarName(self):
        print("aaa")
    def setCarName(self):
        print("bbb")

特殊方法

在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法

特殊方法名	默认的参数	功能描述
init()	self	已经创建了对象，初始化对象回调方法
str()	self	和toString
del()	self	对象回收时候回调
new()	cls	对象创建的回调方法

new()

__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供
__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例
__init__有一个参数self，就是这个__new__返回的实例，__init__在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值
我们可以将类比作制造商，__new__方法就是前期的原材料购买环节，__init__方法就是在有原材料的基础上，加工，初始化商品环节

init()

__init__()方法，在创建一个对象时默认被调用，不需要手动调用
__init__(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么__init__(self)中出了self作为第一个形参外还需要2个形参，例如__init__(self,x,y)
__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去

str()

当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据

class Car:
	def __init__(self, newWheelNum, newColor): 
		self.wheelNum = newWheelNum 
		self.color = newColor 
	def __str__(self): 
		msg = "嘿，我的颜色是" + self.color + "我有" + str(self.wheelNum) + "个轮胎..."
		return msg 
	def move(self): 
		print('车在跑，目标:夏威夷') 
BMW = Car(4, "白色") 
print(BMW)

del()

当删除一个对象时，python解释器会默认调用__del__()

用del删除对象

class Car:
    def __init__(self, newWheelNum, newColor):
        self.wheelNum = newWheelNum
        self.color = newColor

    def __str__(self):
        msg = "嘿，我的颜色是" + self.color + "我有" + str(self.wheelNum) + "个轮胎..."
        return msg

    def __del__(self):
        print("我被删除了")


if __name__ == '__main__':
    BMW = Car(4, "白色")
    del BMW

私有属性

属性名前面加了2个下划线’__’，则表明该属性是私有属性，否则为公有属性（方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）

如果有一个对象，当需要对其进行修改属性时，有2种方法

对象名.属性名 = 数据 ---->直接修改
对象名.方法名() ---->间接修改

为了更好的保存属性安全，即不能随意修改，一般的处理方式为
将属性定义为私有属性
添加一个可以调用的方法，供调用

class Car:
    __name = ""

    def setName(self, name):
        self.__name = name

    def getName(self):
        print(self.__name)


if __name__ == '__main__':
    BMW = Car()
    BMW.setName("BMW")
    BMW.getName()

继承

# 定义一个父类，如下:
class Cat(object):
    def __init__(self, name, color="白色"):
        self.name = name
        self.color = color
    def run(self):
        print("%s--在跑" % self.name)
        
# 定义一个子类，继承Cat类，如下:
class Bosi(Cat):
    def setNewName(self, newName):
        self.name = newName
    def eat(self):
        print("%s--在吃" % self.name)

多继承

当两个父类的方法名一致时，子类调用继承时前面那个

# 定义一个父类
class A:
    def printA(self): 
        print('----A----') 
# 定义一个父类
class B:
    def printA(self): 
        print('----B----') 
# 定义一个子类，继承自A、B
class C(A,B):
    def printC(self): 
        print('----C----') 
if __name__ == '__main__':
    c=C()
    c.printA()
#结果是——A——

重写

所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法

多态

定义时的类型和运行时的类型不一样
多态的概念是应用于Java和C#这一类强类型语言中

class F1(object):
    def show(self):
        print('F1.show')


class S1(F1):
    def show(self):
        print('S1.show')


class S2(F1):
    def show(self):
        print('S2.show')


# 由于在Java或C#中定义函数参数时，必须指定参数的类型# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类# 而实际传入的参数是：S1对象和S2对象
def Func(obj):
    """Func函数需要接收一个F1类型或者F1子类的类型"""
    print(obj.show())




if __name__ == '__main__':
    s1_obj = S1()
    Func(s1_obj)  # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show

类属性和实例属性

和C++，java中类的静态成员变量类似

类方法实例方法静态方法

类方法用修饰器@classmethod来标识其为类方法
静态方法修饰器@staticmethod来进行修饰

方法类别	语法	描述
类方法	@classmethod	第一个形参cls。默认传递
静态方法	@staticmethod	没有默认传递的形参
对象方法（成员方法）	def 方法名	第一个形参self ，默认传递

实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。

class People(object): 
    country = 'china'
    #类方法，用classmethod来进行修饰  
    @classmethod
    def getCountry(cls):
        return cls.country

class People(object):
    country = 'china'

	# 静态方法
    @staticmethod 
    def getCountry():
        return People.country

设计模式

单例模式

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，单例模式是一种对象创建型模式。

def__new__(cls, age, name):
#如果类数字能够__instance没有或者没有赋值
#那么就创建一个对象，并且赋值为这个对象的引用，保证下次调用这个方法时
#能够知道之前已经创建过对象了，这样就保证了只有1个对象
	If not cls.__instance: 
		cls.__instance = object.__new__(cls) 
	return cls.__instance

工厂模式

异常

try:是异常捕获开始代码，try放在特别关心的那段代码前面
    pass:如果这行代码出现了异常，那么后面的代码不会运行
    pass2
    pass3
except 异常的类型 as ex: 捕获某种类型的异常
except....多个except。按照顺序依次比对类型
else：没有异常时执行
finally：不管有没有异常都会执行

try…except…

捕获异常

try:
	print('-----test--1---') 
	open('123.txt','r') 
	print('-----test--2---') 
except IOError: 
#pass 表示实现了相应的实现，但什么也不做
#except (IOError,NameError): #如果想通过一次except捕获到多个异常可以用一个元组的方式
# errorMsg里会保存捕获到的错误信息 
	print(errorMsg) 
	pass
else: 
#如果没有补货到异常执行else
	print('没有捕获到异常，真高兴')

获取异常的信息描述

try…finally…

如果一个段代码必须要执行，即无论异常是否产生都要执行，那么此时就需要使用finally。比如文件关闭，释放锁，把数据库连接返还给连接池等

import time

try:
    f = open('test.txt')
    try:
        while True:
            content = f.readline()
            if len(content) == 0:
                break
            time.sleep(2)
            print(content)
    except TypeError as ex:  # 如果在读取文件的过程中，产生了异常，那么就会捕获到#比如 按下了 ctrl+c
        pass
    finally:
        f.close()
        print('关闭文件')
except:
    print("没有这个文件")

自定义异常

可以用raise语句来引发一个异常
异常/错误对象必须有一个名字，且它们应是Error或Exception类的子类

class ShortInputException(Exception): '''自定义的异常类'''


def __init__(self, length, atleast):
    # super().__init__()
    self.length = length
    self.atleast = atleast


def main():
    try:
        s = input('请输入 --> ')
        if len(s) < 3:  # raise引发一个你定义的异常
            raise ShortInputException(len(s), 3)
    except ShortInputException as result:  # x这个变量被绑定到了错误的实例
        print('ShortInputException: 输入的长度是 %d,长度至少应是 %d' % (result.length, result.atleast))
    else:
        print('没有异常发生.')

模块

就是jar包

导入模块

import
from modname import name1[, name2[, … nameN]]
from … import *

当你导入一个模块，Python解析器对模块位置的搜索顺序是：

当前目录
如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录。
如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/
模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。

安装模块

pip install

定义模块

在Python中，每个Python文件都可以作为一个模块，模块的名字就是文件的名字。

from PyFile import method

列表推导式

所谓的列表推导式，就是指的轻量级循环创建列表：

a = [i for i in range(1,10)]

在循环的过程中使用if 来确定列表中元素的条件

a = [i for i in range(1,10) if i%2==0]

2个for循环

a=[(i,j) for i in range(1,5) for j in range(6,10)]

3个for循环

a= [(x,y,z) for x in range(2) for y in range(2) for z in range(2)]

码农公寓