Python初级教程

Python语言的特点

优点：

- 简单

- 易学

- 免费，开源

- 高层语言

- 可移植性（可再多平台运行）

- 解释性（不需要编译，可直接运行）

- 面向对象

- 可扩展性（缺点：运行效率相对较低，可直接嵌入C或者C++语言）

- 丰富的库

- 规范的代码

缺点：

- 运行速度相对慢

- 目前国内市场较小

- 中文资料匮乏

- 构架太多太乱（侧面说明项目多，人多）

- 列表内容

Python的应用场景

• WEB开发
• 系统管理，服务器运维的自动化脚本
• 科学计算
• 桌面软件
• 服务器软件（网络软件）
• 游戏
• 构思实现，产品早期原型和迭代

Python注释

#（单行注释）注释前加#号，注释后方文档不会被运行。
'''
（多行注释）
在需要注释的文档前后分别加上三个单引号或者双引号
'''

Python字节码

#coding=utf-8 或者 #-*- coding:utf-8 -*- 在py2中需要在文件顶部输入表示文档以utf-8字符解析。
#!usr/bin/env python  这里表示在linux系统下，py文件在顶部直接定位解释器（python的路径）地址，这样在运行的时候可以直接使用 ./文件名.py就可以运行。

注意:路径和文件名不要用中文,以免造成未知错误。

Python变量，Input和Print

变量的定义：

x = 5 #定义了一个变量 x，对应的数据是5.
y = 6 #定义了一个变量 y，对应的数据是6.
z = x + y #定义了一个变量 z ,对应的数据是 x 和 y 的和。
结果是 11.
z = z + x #重新把一个新的数据对应到 z ，对应一个新的数据是之前的 z 和 x 的和。
结果是 16.

注意：变量的定义是先右后左的原则。

注意注意注意：Python中的定义变量是一种标签形式，可以将Python理解为大海，右侧的值是在大海里的生物（是再定义之前就存在的），变量名则是不同的鱼竿，而等号可以理解为鱼线。变量定义的意思是钓到了需要的鱼，在需要的时候拉出来。（使用变量的时候）但是如果长时间不拉杆的话，鱼线就会断掉（Python内部的垃圾回收机制，会将不用的变量删除）。

变量的类型

常用的变量有数字类型，字符串类型，布尔类型，列表，元祖和字典。

数字类型：整数类型 Int，长整型 Long，浮点型 Float，复数 Complex。

字符串类型：字符串 Str。

布尔类型：真 True，假 False。

列表类型：列表 List。

元祖类型：元祖 Tuple。

字典类型：字典 Dictionary。

注意：在Python中，不需要声明变量类型，系统会根据数值来自动进行类型划分。其中：数字类型，字符串类型，元组类型，布尔类型是不可变类型；列表类型，字典类型是可变类型。不可变类型可以作为字典key，不可变类型则不能。

Input 介绍：

i = input('这里可以让用户输入内容') #这里定义了一个变量i,对应是数据是输入框内的数据，也就是说用户输入了什么数据，那么i就会等于所输入的内容。

注意：Python2中的Input和Python3的Input有差别。并且所有输入的内容都是字符串类型。

i = input() #这里是Python3中的写法
i = raw_input() #这里是Python2中的写法

print 介绍

print('输出的内容') #print是用来向用户输出括号内的内容，

name = xiaowang
age = 20
add = '北京'
pirnt('名字是%s,年龄是%s,地址是%s'%(name,age,add))#这里可以一次输出多个值。

注意：格式化输出要一一对应。

Python的if….else..

if 这里是条件设定：
    如果条件满足，这里就会运行
else:
    如果条件没有被满足，就会运行这里。

例如：

i = int(input('这里输入数字'))#int(input())的意思是把输入的内容强制转换成整数类型。
if i<10:
    print('i是一个小于10的数字')
else:
    print('i不是一个小于10的数字')

注意：if 判断条件其实是在判断条件的布尔类型，就是判断条件的真假值，空类型、0和None，表示假的，非0数字表示真。

Python运算符

• = 赋值
• > 大于
• < 小于
• == 等于
• != 不等于
• >=大于等于
• <=小于等于
• or 或者
• and 并且
• not 不包括
• += 加法赋值
• -= 减法赋值
• *= 乘法赋值
• /= 除法赋值
• %= 取模赋值
• **= 幂赋值
• //= 取整除赋值

Python的While循环

n = 1 #定义了变量n = 1。
while n<10: #循环条件如果n<10，就会运行循环代码。
    print(n) #输出当前n的值。
    n = n+1 #给n一个新的数值n+1，重新返回while条件进行判断。

注意：n+=1 等同于 n=n+1但是只是结果一样，但是原理不同。n+=1表示忽略过程，直接在当前结果操作，只返回一个值;n = n+1则表示每相加一次就新创建一个结果。逐步相加。简单理解就是n+=1是运算后再返回，n=n+1这是边运算边返回。

循环嵌套，Break和continue

i = 1  #定义变量i
while i<=100: #当i<=100时运行
    if i%2=0: #当i除以2余数为0的时候运行
        print(i,end=' ') #输出i的值 表示只输出偶数,end表示在输出内容的后边加上引号内的字符用来代替默认的换行。
    elif i==50:#当i等于50的时候
        continue #不会执行i等于50的循环。
    elif i==90: #当i等于90时
        break #停止整个循环
    i+=1# i自加1

注意：Break和continue只对所在的循环生效。并且在for循环和while循环中都可以使用。

Python的For循环

name = 'xiaowang' #定义一个变量name是'xiaowang'
for i in name:  #遍历'xiaowang'到变量i，
    print(i)  # 输出i
else: #for循环中也能使用else，for循环完毕后运行
    print('dawang') #输出字符串

注意：for循环中的变量i可以自定义，不是必须要定义成i。

Python字符串

字符串基础

• 字符串的单位是字节。
• 1G=1024M 1M=1024K 1K=1024Byte（字节） 1Byte的最大值是255。
• 字符串存储是拆分后按一个个字符存储。
• 字符串转换：str(not str)
• 字符串长度：len(str)（单位是字节）
• 字符串拼接：第一种使用“+”：str1+str2，第二种使用格式化定义：’%s’%(str1+str2）
• 字符串的下标：按照存储的字符排序，从0开始，使用 str[1] 来获取字符串所对应字符的值，使用 str[-1] 来从后往前进行取值。
• 字符串切片：
  
  1，str[0:10] 从第一个开始到第10个结束（不包括第10位）
  
  2，str[0:-10] 从第一个开始取到倒数第10个结束（不包括倒数第10个）
  
  3，str[2:] 从第三个开始，取值到最后一个。（默认不填写会取到最后）
  
  4，str[2:-1:2] 从第三个开始取到倒数第一个，步长为2。
  
  5，str[-1:0:-1] 从最后一个开始取，到开始第一个结束，第三位 负数表示从右往左取值，正数表示从左往右取。

字符串的常见操作

str = 'hello world'#字符串需要用引号包括。
str.find('w') #查询字符串，返回第一个字符的下标，如果有重复的字符，则会返回第一个字符的下标位置。如果没有则返回-1.
str.count('w') #查询字符串中被查询字符出现的次数。
str.replace('w','WWW'，'1') #将字符串中的w替换为WWW。第三个参数表示要替换的次数，默认位全部修改。
str.split(' ') #将字符串中的‘字符’作为断点进行切割。并且生成列表。默认是按照空格和\t进行切割。
str.capitalize() #将字符串第一个字母大写。
str.title() #将字符串中每一个单词的第一个字幕大写。
str.startswith('w') #判断字符串开头是否是‘w’.
str.endswith('w') #判断字符串结尾是否是‘w'.
str.lower() #将字符串中所有大写改成小写。
str.upper() #将字符串中所有小写改成大写。
str.just('50') #返回一个50个字符的字符串，进行左对齐，并且用空格填补空白
str.center('50') #返回一个50个字符的字符串，居中显示，用空格填补。
str.lstrip() #删除字符串左边空格。
str.strip() #删除字符串中所有空格。
str.partition('wor') #以第一个'wor'字符为中心，左右两侧进行三部分，并且生成一个元祖。
str.splitlines() #以换行符进行切割，并生成一个列表。
str.isalpha() #判断一个字符串是否是纯字符。
str.isdigit() #判断一个字符串是否是纯数字。
str.isalnum() #判断一个字符串是否是纯数字或者纯字母（不能出现符号）
str.isspace() #判断一个字符串是不否是空格。
str.join(' ') #把当前字符串加入空格，生成字符串。
' '.join(str) #把空格中加入字符串，生成字符串。

注意：反向查询需要在方法前添加’r’

Python列表

列表的增删改查

l = ['1',2,3.14,'liebiao','列表'] #列表需要用中括号包括，并且可以存储多种数据类型。
l.append('添加内容') #用来向列表后方添加一个元素。append是一个没有返回值的方法。
l.insert(1,'插入的内容') #用来向列表插入一个元素，第一个参数是列表下标位置，第二个参数是内容。
l.extend(列表) #将两个列表合并为一个列表。
l.pop() #把列表最后一个元素取出并删除。
l.remove('删除的列表元素') #指定要删除的元素，但是只会删除列表内的第一个。
l.sort() #将列表从小到大排序。
l.sort(reverse=Ture) #将列表从大到小排序。
l.reverse() #将列表倒序排列。
del l[1] #删除下标为1的列表元素。
l[0] = 1 #将列表第一个元素修改为整数1。
if p in l:,if p not in l: #关键字进行查询元素是否在列表内。

注意：列表切片操作与字符串操作一致，但是结果返回类型还是列表。列表排序只适用于不可变类型的元素。

Python字典

字典的常见操作

person = {'name':'小王','age':20,'addr':'北京'}#用大括号定义字典，必须以键和值成对出现。
person['phone'] = 10086 #添加键值'phone'，对应的值是 10086.
del person['age'] #删除字典内键为'age'的键值对。
person['name'] = '小李' #修改键值对的内容。
person['name'] #查询键为'name'对应的值。
person.get('name')#查询键为'name'对应的值，但是如果没有值不会报错。
len(person) #查询返回键值对的个数。
person.keys()  #查询字典中的键，Python2以列表形式返回。Python3以对象形式返回。
person.values() #查询字典中的值，Python2以列表形式返回。Python3以对象形式返回。
person.items() #查询字典中的键值对，Python2以元祖形式返回。Python3以对象形式返回。

Python元组

num = (1,2,3,4,5) #用括号和逗号来定义一个元组。
unm = (1,) #如果元组只有一个元素的话，必须再元素后边加上逗号。

注意：元组只能够查询，不能 增删改。

Python集合

a = {1,2,3,2,4,6,2,3,2,1,2,3,4,} #用花括号定义集合。
a = [1,2,3,2,4,6,2,3,2,1,2,3,4,]
c = {1,5,1,6,4,5,6}
b = set(a) #将列表转化为集合。
a&c #取交集，取出俩集合相同的
a|c #取并集，取出俩集合的全部
a-c #取差集，取出俩集合不同的
a^c #取对称差集，取出俩集合独有的

注意：集合的特性是可以去重，将重复的内容删选。集合也支持增删改查。

Python函数

def 函数名(): #用def 用来定义一个函数，函数名和变量名规则一致，后边加括号。
    函数体 #这里放置需要执行的代码。
函数名() #函数名加括号表示执行函数。

注意：简单理解函数就是 定义了一个多个值的 变量。类似于 函数名 = 函数体。使用函数名（）来执行函数中的多个值。

带有参数的函数：

def num(a,b): #定义一个函数，a和b。
    result = a+b #将a,b的和赋值给变量result。
    print('%d+%d=%d'%(a,b,result)) #输出。

注意：参数的数量和传递值的数量必须一致。

函数的return

def num(x,y): #定义函数
    z = x+y #将x+y的和
    return x,y,z #返回z的值给函数。简单可以理解为unm(x,y)=x,y,z
nums = num(x,y) #nums用来接收函数num(x,y)返回值。可以理解为nums = num(x,y)=x,y,z,则nums=(x,y,z)
num1,num2,num3 = num(x,y) #使用三个变量来接收返回值，则表示将元组进行拆分，num1=x,num2=y,num3=z

注意：return可以简单理解的为将函数体运行后的结赋值给函数，如：num()=x,y,z，另外有返回值的函数需要有变量接收。如 inp = input(‘输入函数’)，输入input也是一种带有返回值的函数。如果想一次返回多个值，可以将多个值封装成元组，列表，等。

函数的嵌套

def nums (x,y,z): #定义函数nums，带有三个参数，参数名x,y,z没有任何意义可以是任何变量名，这里只需要注意有多少个参数，参数名可以忽略。
    xyz = x+y+z #定义变量xyz,对应的值是x+y+z，这里x+y+z的值是由用户传入的真实数据。不同于参数名x,y,z。
    return xyz #把变量xyz返回给函数nums。

def nums_2 (xx,yy,zz): #定义函数nums_2，带有三个参数，参数名x,y,z没有任何意义，只需要注意有多少个参数，参数名可以忽略。
    xyz = nums(xx,yy,zz) #定义变量xyz,对应的值是unms(xx,yy,zz)，这里表示把函数nums(xx,yy,zz)的值对应传给xyz,这里的nums(xx,yy,zz)表示接收3个参数。但是参数的值和函数nums_2的参数值一致。
    xyz/2 = xyz/2 #定义变量xyz/2对应的是变量xyz的值除以2
    print ('xyz/2的值是%d'%xyz/2) #输出。

x = 10
y = 20
z = 30
num_2(x,y,z)  #把3个值分别传给nums_2，表示num_2(10,20,30)。

注意：unms(x,y,z)这里的x,y,z只是用来接受参数的坑，可以理解为3个车位。nums_2(xx,yy,zz)这里的xx,yy,zz同样也是一个占位坑，也是3个车位。但是具体停的什么车是看传的数据是什么。

函数的局部变量和全局变量

a = 10   #全局变量
b = 20   #函数外的是全局变量
def unm():
    global a  #使用关键字global来修改全局变量a
    a = 15  #在global关键字下重新定义a，这里影响全局变量
    b = 25  #这里表示局部变量b，如果局部变量和全局变量名有冲突，将会优先使用局部变量。
    print (a,b,c,d) #这里c的值将会使用全局变量中的，如果函数内没有定义局部变量将会使用全局变量。
c = 30 #在函数调用前定义c。只要在函数调用之前定义了变量，就可以使用。
unm() #调用函数，输出a,b,c,d的值。a=15,b=25,c=30,d=Nan(d将会出错)
d = 40 #如果在调用之后定义变量，那么将会无法取到对应的变量，比如 校车发车以后你才到集合点，那么就不能坐上班车。

注意：每个函数是一个单独的个体，不同函数中的局部变量名可以重复，但是在函数外的全局变量则不能重复。当列表和字典是全局变量时，函数内可以直接使用，不需global。

函数的缺省参数（默认参数）和不定长参数

缺省参数（默认参数）

def num(a,b,c=10,d=20):#定义函数，需要有四个参数a和b为需要实参的参数，c和d为缺省参数（默认参数），表示即使没有实参会使用默认参数。
    return a,b,c,d #返回元组a,b,c,d
a,b,c,d = num(10,c=10,b=30)#变量a,b,c,d分别接收参数a,b,c,d的值，num(10,c=10,b=30)表示第一个参数10给了参数a,参数b的值指定为30，c的值指定为10，第四个参数没有填写默认使用缺省参数。

注意：实参的默认传递是按照参数位置进行排序的，如果位置于参数位置不一致，则需要给参数定义实参。

不定长参数

def unm(a,b,*args,**kwargs):#定义一个函数，参数a,b,和*args。*args表示接收形参以外的所有参数。**kwargs表示接受以字典形式结束额外的参数对。
    return a,b,args,kwargs #返回。
a,b,c,d= unm(1,2,3,4,5,6,7,c=8,d=9) #用a,b,c,d接收返回的a,b,args和kwargs。结果a=1,b=2,c=(3,4,5,6,7),d={'c':8,'d':9}

注意：取出args的值可以使用for循环遍历取出使用。如果想要同时接收元组的多个值，可以用元组变量进行接收。

函数的递归

def num(a):  #定义函数
    if a>0:  #判断语句当实参大于0时候运行。
        a += num(a-1) #这里表示当前实参加上实参-1的实参的返回值
        return a #返回实参给调用函数 （这里主要针对的是被调用的函数）
    else:
        return a #返回实参给调用函数 （这里主要针对最后一步调用）
num(100) #实参100，表示100到1之间的总数和。

注意：递归函数必须要有终止条件，否则将会造成死循环。

匿名函数

lambda x,y,z:x+y+z #匿名函数需要用关键字lambda定义。

l = [{'name':'xiaowang','age':20},{'name':'xiaoliu','age':22}] #定义一个列表
l.sort(key=lambda x:x['name']) #按照列表字典内的'name'进行由小到大排序。

注意：使用匿名函数可以将不可变类型的元素按照条件进行排序。

lam = input('这里输入匿名函数：') #定义变量lam用来接收输入框字符串
lam = eval(lam) #用关键字eval来计算字符串lam的值。表示去掉字符串的双引号，并计算结果。
def num(a,b,func) #定义了带有三个参数的函数，但是第三个参数是函数参数。
    c = func(a,b) #用变量c接收参数函数的运算结果。
    return c #返回c给函数。
num(5,6,lam)  #调用函数num，并传入实参，第三个实参表示用户输入的匿名函数。

注意：匿名函数默认是有return结果的函数，需要有变量进行接收。

Python的文件操作

文件的打开方式

file = open('text.txt','r') #表示打开text.txt文件，并且以只读方式打开。（默认模式），文件不存在时报错。
'w' 打开一个文件只用于写入，如果文件已存在则会覆盖之前的内容，如果文件不存在则会创建新文件。
'a' 以追加方式打开文件，如果文件已存在则会在当前内容结尾加入内容，如果文件不存在则会创建新文件。
'rb' 以二进制方式打开一个只读文件。
'wb' 以二进制方式打开一个只写入文件，如果文件存在则覆盖之前内容，如果不存在则会创建新文件。
'ab' 以二进制追加方式打开文件，如果文件已存在则会在当前内容结尾加入内容，如果文件不存在则会创建新文件。
'r+' 打开一个文件用于读写，文件指针将会在文件开头。
'w+' 打开一个文件用于读写，如果文件存在则覆盖之前内容，如果不存在则会创建新文件。
'a+' 打开一个文件用于读写，如果文件已存在则会在当前内容结尾加入内容，如果文件不存在则会创建新文件。
'rb+' 以二进制方式打开一个文件用于读写，文件指针放在文件开头
'wb+' 以二进制方式打开一个文件用于读写，如果文件存在则覆盖之前内容，如果不存在则会创建新文件。
'ab+' 以二进制方式打开一个文件用于读写，如果文件已存在则会在当前内容结尾加入内容，如果文件不存在则会创建新文件。

注意：文件分为文本文件和二进制文件（视图，音频）

文件的操作

file = open('text.txt')
1   file.close() #关闭文件。关闭后文件不能再进行读写操作。
2   file.flush() #刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3   file.fileno() #返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
4   file.isatty() #如果文件连接到一个终端设备返回 True，否则返回 False。
5   file.next() #返回文件下一行。
6   file.read([size]) #从文件读取指定的字节数，如果未给定或为负则读取所有。
7   file.readline([size])读取整行，包括 "\n" 字符。返回字符串。
8   file.readlines([sizeint]) #读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。返回列表。
9   file.seek(2,[0,1,2]) #设置文件当前位置 第一个参数表示向右移动位置的个数，第二个参数表示大体位置，0是开头位置，1是当前位置，2是结尾。
10  file.tell() #返回文件当前位置。
11  file.truncate([size]) #从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后 V 后面的所有字符被删除，其中 Widnows 系统下的换行代表2个字符大小。
12  file.write(str) #将字符串写入文件，没有返回值。
13  file.writelines(sequence) #向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

文件的复制

file_name = input('输入需要复制的文件名：')  #在当前目录下输入需要复制的文件名全称。
old_file = open(file_name,'r') #只读方式打开文件。
new_file = open('复件-'+file_name,'w') #创建新的文件，并在原文件名前添加复件字符。
while Ture:
    old_content = old_file.read(1024) #获取旧文件内容,且一次只读取1024个字节，避免大文件造成崩溃。
    if old_content == 0: #当读取文件长度为0的时候，表示以读取完毕。
        break #退出循环，进行文件写入。
new_content = new_file.write(old_content) #将旧文件内容写入新文件内。
old_file.close() #关闭文件
new_file.close() #关闭文件

Python面向对象、面向过程

面向对象

简要的理解，面向对象即功能模块化，功能独立存在，独立运行，方便维护和修改。比如一辆汽车，由不同的零件组装，这里就可以把零件看作为一个个对象。在代码方面最简单的理解就是面向对象可以引用外部的包，直接使用，但是面向过程就只能自己从头写到尾。

注意:之前的各种方法调用就是面向对象,即不需要去造方法,直接使用.类似于,你只要学会开车就可以了,并不需要知道它是怎么造出来的.

面向过程

面向过程侧重于过程，计算机底层的原理，表示所有的功能都是一体化，简单的例子就是苹果手机电池不能拆掉，整体和手机是一体的，如果要换电池，必须要按照安装的步骤一步一步拆开，然后到达电池的步骤时，再去更换电池，安卓手机则不需要，直接扣开盖子就可换电池，这就类似于最简单的面向过程和面向对象，电池就比作一个对象。

注意:面向过程简单说就是编写函数的过程, 就是为了能够重复,方便的使用一个方法(函数),从而编写函数的过程,叫做面向过程,简单说就是制造一个东西的过程.

注意注意注意:

这里通俗的举一个例子就是说,,农民自己造飞机,完成后开飞机. 他从开始制作飞机,到开上飞机,整个过程就是面向过程.

而老板则是直接去买飞机,并不关心它是怎么造出来的,老板只需要会使用飞机就行了,这是一个面向对象.

最终的目的都是飞机,但是双方的实现方式不一样.

:

Python的类和对象

类

Python中的类是一个模板代码，用来生成实例对象，简单理解可以把类比作模具，然后使用模具创建出来的模型就比作对象。

类的三要素：类的名称，类的属性，类的方法（行为，功能）

对象

对象其实泛指一切的实例，首先通过类创建出来，拥有基本功能，然后根据不同的需要，可以对每个对象进行修改和装饰，通俗的理解，可以把类看作形参，把对象看作实参。面向对象的三要素：封装（就是嵌套），继承，多态（面向对象不同的对象结果不一样）。

class Dog: #定义类使用关键字class
    #属性
    def info(self) #当wangcai=Dog()时，self就是wangcai,当xiaogou=Dog()调用时self就是xiaogou.
        print('%d的年龄是%d'%(self.name,self.age))
wangcai = Dog() #创建一个实例类Dog()赋值给wangcai
xiaogou = Dog() #创建xiaogou
wangcai.name = '旺财' #定义实例类的属性
wangcai.age = 20  #定义实例类的属性
xiaogou.name = '小狗' #定义xiaogou的单独属性
xiaogou.age = 18 #定义xiaogou的单独属性。
wangcai.info() #调用wangcai类的info方法（函数)
xiaogou.info() #调用xiaogou实例类的info方法。

注意：self不是关键字，可以任意设置，但是第一个位置必须是用来接收对象名。右侧的Dog()是实例化对象,左边的变量只是接收引用.

_init_ 方法，_str_ 方法和_del_方法

class Cat:   #定义一个Cat类
    def __init__(self,new_name,new_age): #定义__init__方法，__init__方法是创建类时自动调用的默认函数，当实例类创建的同时会运行__init__方法。这里的new_name，new_age的参数用来接收的是实例类的参数。当tom=Cat('Tom',20)的时候，__init__的实际参数是__init__(tom,'Tom',20)
        self.name = new_name #当tom=Cat('Tom',20)的时候，init方法是__init__(tom,'Tom',20)，则self.name = new_name是tom.name = 'Tom'
        self.age = new_age #当tom=Cat('Tom',20)的时候，init方法是__init__(tom,'Tom',20)，则self.age= new_age是tom.age= 20
    def __str__(self): #__str__方法是默认描述信息的方法，当对象属性定义完成之后，调用输出对象时，会将__str__方法的返回值进行打印，__str__方法只能接收return值。
        return '%s的年龄是:%d'%(self.name,self.age)
    def __del__(self): #__del__方法会在对象引用为0的时候（没有变量指向目标时），（垃圾回收机制）自动删除目标对象，
        print('当实例类被删除的时候会调用__del__方法')

tom = Cat('Tom',20) #当tom类创建的同时，就会调用__init__方法，是系统操作，用户无需操作。
print(tom) #这里会调用__str__方法。
del tom #当删除tom实例对象的时候，就是说变量tom指向Cat('Tom',20)这个类的线断掉，当没有变量指向Cat('Tom',20)的时候，系统会默认调用__del__方法。进行最后的阐述。

注意：如果需要查看一个对象的引用计数可以引用 sys 模块的 sys.getrefcount() 方法。结果会在真实结果的基础上加1，因为当调用sys.getrefcount() 方法时会将变量引用，所以会在原基础加上一次调用sys.getrefcount()方法时的引用数。

例子：

class Home(): #定义房子类
        def __init__(self,new_area,new_addr): #初始化类属性。
                self.area = new_area #定义房子面积
                self.addr = new_addr #定义房子的位置
                self.area_end = new_area  #初始化可用面积
                self.tool =[] #

        def __str__(self):
                return '房子的面积是%d,剩余面积是%d,位置是在%s,放置的家具有%s.'%(self.area,self.area_end,self.addr,str(self.tool))

        def tools(self,beds):
                self.area_end  -= beds.area
                self.tool.append(beds.name)

class Furn():
        def __init__(self,new_area,new_name):
                self.name = new_name
                self.area = new_area

home = Home(90,'北京')
bed = Furn(4,'席梦思')
home.tools(bed)
print(home)

私有属性和私有方法

class test():
    def __init__(self):
        self.__name = 'name'  #定义了私有属性__name = 'name'

    def __chek(self): #定义私有方法。
        print('正在查询..')

    def getname(self): #公有方法。可直接调用
        return self.__name #返回私有属性的值。

    def chek(self, new_username): #公有方法，直接调用
        if self.getname() == new_username: #这里表示如果实参的值等于方法的返回值那么就运行下面的私有方法。
            self.__chek() #如果上方条件成立那么才能调用私有方法。
        else:
            print('查询失败。。')
t = test()
t.chek('name') #传入参数'name'。

注意：私有方法以及私有属性都是以 ‘__’ 双下划线开头的，而且实例类对象无法直接调用，私有方法和属性只能被内部self调用，以保证数据的安全。另外将属性数据保存在方法内部以return形式返回可以保障数据安全，这种方式叫做封装。

类的继承

class Animal: #定义一个类。
    def run(self):
        print('Im,runing....')
    def eat(self):
        print('Im,eating....')
class Dog(Animal): #定义一个类，再类名括号内写入Animal表示继承Animal类，可以直接调用父类中的方法。
    def bark(self):
        print('汪汪汪。。。。')
class Muyangquan(Dog):#定义一个类，继承父类Dog,继承父类的父类Animal。
    def grab(self):
        print('牧羊犬再看羊。。。')
    def eat(self):
        print('牧羊犬在吃草。。。')

muyangquan = Muyangquan() #创建类
muyangquan.run() #调用父类的父类中的run方法。
muyangquan.bark() #调用父类中的bark方法。
muyangquan.eat() #调用子类中的eat方法，当子类中的方法和父类中的方法冲突时，默认将会优先使用自己类中的方法，叫做重写方法。性质和局部变量和全局变量类似。如果仍需要使用父类中的方法，有两种方法：1、Dog.eat(self) #这里是调用父类的eat方法，记得要传参数self。2、(推荐使用)super().eat() #这里也是调用父类的方法。

注意：子类能调用父类及父类的父类中的方法，可以无限的嵌套，但是推荐不超过3层。不能调用同类（其他子类）中的方法。另外私有方法和属性不会被继承，如果需要使用，需要将父类的私有属性和方法封装在公有方法内。

多继承

class A (object): #python3中默认会继承object类。
    pass
class B(A):
    pass
class C(A)
    pass
class D(B,C): # 多继承只需要在继承类的括号内添加类就可以。
    pass

注意：多继承的方法使用路径是 D - B - C - A - Object，如果按照路径搜索到任何一个匹配的方法，那么就会停止搜索。可以使用 cls.mro 来查询当前的继承顺序。

类属性和实例属性

class Num(object):
    num = 0  #定义在类中，方法之外的成为类属性，并且类方法都可以调用，类似于全局变量。
    def __init__(self,new_num):
        self.num = new__num  #定义在方法内，self.开头的都属于实例属性，只有对应的实例可以操作。类似于局部变量。
        Num.num += 1 #调用类属性，需要在类属性前添加类名。

类方法和实例方法

class Test(object):
    num = 0  #定义类属性。

    def __init__(self): #只要方法前没有添@classmethod的都是实例方法。
        self.name = '小黑'
        Test.num += 2 #实例方法操作类属性只能通过类名指向。

    @classmethod
    def add_num(cls): #只要方法前添@classmethod的都是实例方法,类方法的优点是可以使用实例对象调用。
        cls.num += 1  #操作实例属性。

    @staticmethod
    def add_nums(): #静态方法。在方法前加上@staticmethod 关键字用来定义。静态方法可以不用加参数，可以通过类和实例对象调用
        pass 

test = Test()
test.add_num() #可以使用实例对象操作类方法。
Test.add_num() #也可以使用类名操作类方法。
tset.add_nums() #调用静态方法。
print(test.num)

_new_ 方法

class Dog(object):

    def __new__(cls): #__new__方法是用来创建对象的，如果在子类中重写了__new__方法，那么自动创建对象就会失败，如果要重写__new__方法，则必须返回父类的__new__方法。这里的cls参数就是创建对象时使用的变量名的引用。
        return object.__new__(cls)

    def __init__(self):#当__new__方法成功创建对象以后，创建对象才会调用__init__方法。
        pass

单例对象

class Person(object):
    __ins = None  #定义一个私有类属性__ins，值为None.
    def __new__(cls，name): #重新定义__new__方法，为了系统不报错，设置一个参数用来接收实参。
        if cls.__ins == None: # 如果 是第一次定义实例对象，则进行对象创建，并返回
            cls.__ins = object.__new__(cls)
            return cls.__ins
        else: # 如果不是第一次创建实例对象，则返回之前的引用。
            return cls.__ins
    def __init__(self,name): #定义__init__方法，接收name参数。
            self.name = name
A = Person('老王')  #单例对象的意思就是创建一个实例对象，以后的实例对象反复使用之前已创建的实例对象，每次将其覆盖。
print(A.name)
B = Person('老李')
print(B.name)

Python异常处理

try: #当有代码段错误的时候，可以将代码段放到try：和except的处理中。
    print(name) #输出变量，但是变量没有定义
except (NameError,FileNotFoundError): #获取异常，可以在后边加入需要捕获异常的类型，可以一次捕获多个异常，但是需要以元组形式。如果错误类型一致，则会运行之后的代码，不会报错停止。
except Exception as ret:#如果之前的异常没有再范围内，那么这个Exception则会捕获所有异常,as ret表示将返回的异常信息描述赋值给ret.
else: # 如果没有异常时，将会运行else
    print('')
finally: #finnally 表示，无论是否有异常，都将会运行
    print('finally')
    print('捕获异常后运行')

自定义异常

class Short(Exception): #定义一个类，继承异常的基类，exception.
    def __init__(self,lenth,atleast): #初始化类，一个对象参数，一个内容参数，一个对比参数。
        self.lenth = lenth #实例属性
        self.atleast = atleast #实例属性
def main(): #定义函数，注意：函数的开头和类是一致的，并且不需要参数。
    try:
        s = input('请输入') #输入
        if len(s) < 3: #判断输入长度是否符合条件
            raise Short(len(s),3) #如果不符合条件，那么就会定义一个自定义的异常。
    except Short as short:  #将定义的异常引用给变量short。
        print('你输入的长度是%d,最少需要%d'%(short.lenth,short.atleast)) #实例对象调用实例属性。
    else:
        print('没有异常')

注意：如果被调用的函数有异常，那么只要它在被调用的时候进行try就可以捕获到，称为异常的传递。

Python的模块和包

模块的导入

import os #导入整个模块，调用时需要戴上模块名 os.getcwd()，注意当import导入整个模块时，会将模块先执行一遍。
from os import getcwd #导入模块内的函数方法，可以直接调用getcwd()不需要模块名。
from os import getcwd，rename #可以一次导入多个模块方法。
from os import * #使用*号通配符，表示导入所有模块内的方法。如果有些函数不想让被 * 调用，可以在模块内定义一个变量
__all__ = [],将可以使用的函数名和类名以字符串类型放到列表内，再次 * 调用的时候就只能使用列表内的函数和类。
impotr time as t #使用别名来替代模块名。调用时可将time替换为t。time.time 和 t.time 的效果一样。
if __name__ == '__main__': #这里表示如果自己调用自己的时候，那么会运行if的内容，如果是作为模块被别人调用时，那么就不会执行，用来规避被当作模块时的重复调用，可以在测试的时候使用。
    main()

注意：如果使用from import，注意方法名的冲突。模块导入会优先当前路径，然后再去系统内寻找，切记文件名不能和模块名一致。

当模块再调用时被修改，需要重新导入，需要 from imp impor *，然后使用方法reload()方法。

包的介绍

_init_.py文件

包是具有多个模块的文件夹，但是文件夹内必须存在一个 __init__.py文件，否则则会被python视为一个文件夹而不是包，__init__文件表示初始化文件，当导入包时，会自动调用__init__文件。

如果想要以from import方式导入包，那么__init__模块内需要加入 __all__ 方法。将可以被导入的模块添加到列表，但是使用方法是 模块名.函数名。

还可以在 __init__模块内 import 包内的其他的模块。这样在导入包的时候会默认执行__init__模块内的函数，但是py2和py3有差异。
1.py2可以在__init__文件内直接 import 模块。
2.py3需要from . import 模块。表示从当前路径内添加模块。
调用的时候需要 包名.模块名.函数（）来调用

包的发布

如果想要将写好的py文件打包为包，以便于共享的时候，需要在 想要发布的文件同级目录下创建一个 setup.py文件。并写入以下内容。

from distutils.core import setup

setup(name='Distutils', #设置包的名称
      version='1.0', #版本设置
      description='Python Distribution Utilities', #模块描述
      author='Greg Ward', #作者名
      author_email='gward@python.net', #作者的电子邮件
      url='https://www.python.org/sigs/distutils-sig/', #包的主页链接
      packages=['distutils', 'distutils.command'],
     ) #需要打包的模块，以字符串的形式写入模块名。

     以上的内容都是手动填写的，以上的只是例子。

当setup文档完成以后，运行：python3 setup.py build
当创建build文件以后，运行：python3 setup.py sdist
当创建tar.gz文件以后，就完成了包的打包。
当获取包以后，在当前目录下运行：python3 setup.py install进行解包安装，完成后将会安装至系统的packages内，可以在任何位置import。

给程序传参数

import sys #导入sys模块
name = sys.argv[1]  #sys.argv将会以列表形式返回实参，且第一个参数为文件名，第二个参数为用户传入的参数。
print('我的名字是%s'%name)  #输出名称

当再命令符 运行 python 文件名.py 习大大
系统将会‘习大大’传入文件内 并运行，输出结果。