点击此处​​​​​​​

python教程全解

1.  了解Python

Python是一种解释型（这意味着开发过程中没有了编译这个环节）、面向对象（支持面向对象的风格或代码封装在对象的编程技术）、动态数据类型的交互式（可在命令行中通过Python提示符及直接代码执行程序）高级程序设计语言。

2.  Python标识符

标识符由字母、数字、下划线组成，但不能以数字开头，且区分大小写。

以下划线开头的标识符是有特殊意义的。以单下划线开头 _foo 的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用 from xxximport * 而导入；

以双下划线开头的 __foo 代表类的私有成员；以双下划线开头和结尾的 __foo__ 代表 Python 里特殊方法专用的标识，如__init__() 代表类的构造函数。

Python 可以同一行显示多条语句，方法是用分号 ; 分开。

3.  Python中的保留字符

这些保留字不能用作常数或变数，或任何其他标识符名称。所有 Python的关键字只包含小写字母。

4.  Python的缩进与多行语句写法

4.1  Python中的缩进要求非常严格，必须严格对齐。因为Python的代码块不由{}控制，而是由缩进就可以控制。

4.2  使用斜杠（ \）将一行的语句分为多行显示，如下所示：当然，使用各类括号括起语句之后不需要斜杠换行。

  英文三个双引号用在等式中也可以写多行文本，直接使用和三个单引号作用一样，可以做多行注释。

5.  Python中的不换行与换行输出

Python变量类型

创建变量就意味着会在内存中开辟空间，同时变量必须赋值才会被创建。

1.  Python中的变量赋值

单变量赋值：

counter = 100#赋值整型变量

miles = 1000.0#浮点型

name = “John“#字符串

多变量赋值：

a = b = c= 1 #三个变量的值都为1

a, b, c =1, 2, “john”  #分别为三个变量赋值

2.  Python中的数据类型

Python有五个标准的数据类型：

1.  Numbers（数字）

1）不可改变的数据类型：

当其类型被改变时，将会赋值给一个新的对象。当对变量赋予了数值后，这个对象就会被创建，可通过del语句删除对这些对象的引用。

2）Python支持的数字类型：

int（有符号整型，如0x69，10）；long（长整型[也可以代表八进制和十六进制]，如-4721885298529L，Python用数字后面的L表示长整型）；float（浮点型，如70.2E-12）；complex（复数，如4.53e-7j）。

3）Python数据类型转换：

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 )           将一个整数转换为一个八进制字符串  

4）Python数学函数

5）Python随机数函数

常用于游戏、数学、安全等领域。

6）       Python三角函数

7）       Python数学常量

2.  String（字符串）

由数字、字母、下划线组成。

1）       字符串截取

Python字符串从左至右截取：索引范围（0，长度-1），从右至左截取（-1，字符串开头）。

2）       Python中不存在单字符

Python中即使有单字符，也会被当作字符串处理。

3）       Python转义字符

4）       Python字符串运算

下表实例变量 a 值为字符串 “Hello”，b 变量值为 “Python”：

a='hello'
b='world'
print(a+b)          #helloworld，+号连接字符串
print(a*2)          #hellohello，*号重复字符串
print(a[1])         #e，[]索引字符
print(a[1:4])       #ell，[:]截取字符串
print("h" in a)     #True，in是否包含
print("M" not in a) #True，not in是否不包含
print(r'\n')        #\n，r原始字符串（不解析转义字符）

5）       Python字符串格式化（方便print时定义类型，如C语言中printf字符串时在引号内写%s一样）

    print("My name is %s and weight is %d kg!" % ('Zara', 21) )

输出：

    My name is Zara and weight is 21 kg!

6）使用三引号输出一大串带特殊字符的字符串

当使用三引号将字符串框起来时，就不需要再通过转义字符打很多换行符等符号了，可以直接打换行。对比如下：

这两种输出的结果都是换行的字符串，但是使用单引号时，当转义字符很多时，会很痛苦。

9）       String可使用的内建函数

3.  List（列表）

使用非常频繁，支持数字、字符、字符串甚至列表的集合结构。

1）       增加或删除列表元素

直接重新赋值给根据索引值取出的值，或通过append（）函数来添加。

通过del 语句删除列表项，如：dellist1[2]

2）       列表的脚本操作符

和对字符串的操作类似。

3）       列表的截取

4）       Python中列表的函数及方法

 Python包含以下函数:

Python包含以下方法:

4.  Tuple（元组）

1）与列表的区别

类似列表，但列表用[ ]标识，元组用()标识，并且列表元素可二次赋值，但元组元素不能。

2）元组的创建

创建空元组：tuple（） 。

创建只有一个元素的元组：tuple（a，），必须要在元素后加逗号。

3）元素的访问

虽然创建时用（）包含，但是在访问单个元素时，与列表一样，通过[ 索引号 ]来访问。

4）删除元组

元组中的单个元素不能被删除，但是元组可以通过del语句整个删除。

5）元组运算符（同列表）

6）任意无符号的对象，以逗号隔开，默认为元组（无关闭分隔符）

7）元组内置函数

5.  Dictionary（字典）

1）       与列表的差别

列表是有序的对象集合，字典是无序的对象结合。字典中的元素通过Key来获取，而列表中的元素通过位移来获取。

2）       字典的定义

下面是两种定义字典的方法，两种方法都与列表的定义方法类似。

dict = {}

dict[‘one‘] =“This is one“

dict[2] =“This is two“

tinydict = {
‘name‘:‘john‘,‘code‘:6734,‘dept‘:‘sales‘}

3）       数据类型的转换

Python运算符

Python支持以下八种运算符：

1.  算数运算符

假设a=10，b=20

2.  比较运算符

3.  Python赋值运算符

4.  Python位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

5.  Python逻辑运算符

6.  Python成员运算符

7.  Python身份运算符（判断引用的对象）

1） is与==的区别

==判断两者是否完全相等，而is判断两个对象引用的对象是否是同一个。

8.  Python运算符优先级

Python语句

1.  条件语句

Python不支持switch语句，因此判断结果对应多种执行方式时，只能用elif来做。

num = 5
if num ==3:         #判断num的值
    print('boss')
elif num ==2:
    print('user')
elif num ==1:
    print('worker')

2.  循环语句

Python中没有do while循环。

循环控制语句：

1）pass语句在函数中的作用

当你在编写一个程序时，执行语句部分思路还没有完成，这时你可以用pass语句来占位，也可以当做是一个标记，是要过后来完成的代码。比如下面这样：

def iplaypython():
    pass

定义一个函数iplaypython，但函数体部分暂时还没有完成，又不能空着不写内容，因此可以用pass来替代占个位置。

2）pass语句在循环中的作用

pass也常用于为复合语句编写一个空的主体，比如说你想一个while语句的无限循环，每次迭代时不需要任何操作，你可以这样写：

while True:
    pass

以上只是举个例子，现实中最好不要写这样的代码，因为执行代码块为pass也就是空什么也不做，这时python会进入死循环。

3）pass语句用法总结

1、空语句，什么也不做
2、在特别的时候用来保证格式或是语义的完整性

4）While循环（可在循环中使用else语句）

# continue 和 break用法

i=1
while i<10:
    i+= 1
    if i%2>0:  # 非双数时跳过输出
        continue
    print(i)  # 输出双数2、4、6、8、10

i = 1
while 1:  # 循环条件为1必定成立
    print(i)  # 输出1~10
    i+= 1
    if i>10:  # 当i大于10时跳出循环
        break

在循环中使用else语句，即当条件不满足之后，结束循环，执行else语句

count = 0
while count <5:
    print(count," is less than 5")
    count = count +1
else:
    print(count," is not less than 5")

5）for循环（可在循环中使用else语句）

可以通过直接取值迭代，也可以通过序列索引迭代

取值迭代：

for letter in 'Python':  # 逐个输出字符串中的字符
    print('当前字母 :', letter)

fruits = ['banana', 'apple', 'mango']
for fruit in fruits:  # 逐个输出列表中的元素
    print('当前水果 :', fruit)
print("Good bye!")

索引迭代：

fruits = ['banana','apple','mango']
#通过len（）函数获得列表的长度，通过range（）函数获得了一个值不超过长度-1的索引序列
for index in range(len(fruits)):
    print('当前水果 :',fruits[index])
    print("Good bye!")

Python日期和时间

Python是以时间戳来记录时间的，也就是当前时间距离1970年1月1日过去了多少秒，因此获取时间的方法一般是先获取时间戳，再将时间戳转换为时间元组，再将时间元组转换为不同格式的时间数据。

1.获取时间戳

2.获取时间

什么是时间元组？

很多Python函数用一个元组装起来的9组数字处理时间，也就是struct_time元组：

代码接上，将获取的时间戳转换为时间元组：

3.获取格式化的时间

4.获取更多格式的格式化时间

python中时间日期格式化符号：

·       %y两位数的年份表示（00-99）

·       %Y四位数的年份表示（000-9999）

·       %m月份（01-12）

·       %d月内中的一天（0-31）

·       %H 24小时制小时数（0-23）

·       %I 12小时制小时数（01-12）

·       %M分钟数（00=59）

·       %S秒（00-59）

·       %a本地简化星期名称

·       %A本地完整星期名称

·       %b本地简化的月份名称

·       %B本地完整的月份名称

·       %c本地相应的日期表示和时间表示

·       %j年内的一天（001-366）

·       %p本地A.M.或P.M.的等价符

·       %U一年中的星期数（00-53）星期天为星期的开始

·       %w星期（0-6），星期天为星期的开始

·       %W一年中的星期数（00-53）星期一为星期的开始

·       %x本地相应的日期表示

·       %X本地相应的时间表示

·       %Z当前时区的名称

·       %% %号本身

5.获取某个月的日历

6.Time和Calendar模块的函数及属性

Time模块包含了以下2个非常重要的属性：

7.其他可以处理时间的模块

·       datetime模块

·       pytz模块

·       dateutil模块

Python函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。

函数能提高应用的模块性，和代码的重复利用率。

1.Python函数定义

2.对象创建

在 python 中，类型属于对象，变量是没有类型的：

以上代码中，[1,2,3] 是 List 类型，“Runoob” 是 String 类型，而变量 a 是没有类型，她仅仅是一个对象的引用（一个指针），可以是 List 类型对象，也可以指向 String 类型对象。

3.可更改对象和不可更改对象

在 python 中，strings,tuples, 和 numbers 是不可更改（重新赋值后，原值不再存在）的对象，而 list,dict等则是可以修改（重新赋值后，原来的值依旧存在，依旧可以获取到）的对象。

·       不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。

·       可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。

4.可更改对象和不可更改对象的参数传递

python函数的参数传递：

不可变类型：类似 c++的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a本身。

int2对象指向变量b，而调用changeInt函数时，变量a就是变量b，此时的变量a和变量b都对应int 2对象，但是在之后a被重新赋值为10，此时变量a指向对象int 10，产生了一个新的int型对象，而变量b所指向的对象不变。

可变类型：类似 c++的引用传递，如 列表，字典。如 fun（la），则是将 la真正的传过去，修改后fun外部的la也会受影响

python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

因为上面的代码传递的是可变对象，因此在函数内取值和函数外取值都是同样的结果。

5.调用函数时的参数使用

1）必备参数

必须与函数声明时一致的顺序来传递参数。

2）关键字参数

传参数时可与函数声明的顺序不一样，因为Python解释器可以用参数名来匹配参数值。

3）缺省参数

传入参数时未给参数赋值，则保持默认值。

这里第二句的age没有输入值，则输出默认值35。

4）不定长参数（也就是包含非必备参数的参数定义）

当不确定会传入参数的个数时，可以对可以不输入的参数名前面加“*”号，按顺序输入时进行对应即可。

5.匿名函数（使用lambda创建）

python 使用 lambda来创建匿名函数。

lambda只是一个表达式，函数体比def简单很多。 

lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。

lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数（只能访问自己的命名空间里的参数）。

虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

6.变量作用域

1）全局变量

定义在所有函数外则为全局变量，可在所有代码中使用。

当需要在函数内定义全局变量时，必须用global语句。

2）局部变量

定义在函数内则为局部变量，只能在相应的代码块内使用。

在上面的例子中，在函数内部，total是局部变量，而在外部total是全局变量，局部变量的改变不会改变全局变量的值，因此第一个打印结果是30，而第二个是0。

Python模块

Python 模块(Module)，是一个Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

模块让你能够有逻辑地组织你的Python 代码段。

把相关的代码分配到一个模块里能让你的代码更好用，更易懂。

1.导入模块的三种方法的区别

1）import导入

import support   # 导入模块，并不导入单个函数

# 现在可以调用模块里包含的函数了 ，但是必须通过模块名.函数名的方式调用

support.print_func(“Runoob“)

2）From … import导入

下面的语句可以将模块中的某一部分导入，它只会将里这个部分单个引入到执行这个声明的模块的全局符号表。这个部分可以是某个函数块，也可以是函数块的子函数块。

from modname import name1[, name2[, ... nameN]]

3）From … import * 导入

前两种语句都是导入模块的部分，只是部分导入的位置不同，而使用From …import*则是导入模块的全部项目，尽量少用，太耗内存。

2.命名空间和作用域

变量是拥有匹配对象的名字（标识符）。

命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。每个函数都会有自己的命名空间，当变量出现在函数内部时，Python默认其为局部变量，若存在一个与局部变量重名的全局变量，则由局部变量覆盖全局变量。

Python的命名空间分局部命名空间和全局命名空间。

3.找出模块中所有的模块名、函数名、变量名（dir()函数）

# 导入内置math模块

import math

content = dir(math)

print content;

以上实例输出结果：

['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 

'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 

'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log',

'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 

'sqrt', 'tan', 'tanh']

在这里，特殊字符串变量__name__指向模块的名字，__file__指向该模块的导入文件名。

4.查看全局变量和局部变量命名空间

根据调用地方的不同，globals()和 locals()函数可被用来返回全局和局部命名空间里的名字。

如果在函数内部调用 locals()，返回的是所有能在该函数里访问的命名。

如果在函数内部调用 globals()，返回的是所有在该函数里能访问的全局名字。

两个函数的返回类型都是字典。所以名字们能用 keys() 函数摘取。

5. reload() 函数

当一个模块被导入到一个脚本，模块顶层部分的代码只会被执行一次。

因此，如果你想重新执行模块里顶层部分的代码，可以用 reload() 函数。该函数会重新导入之前导入过的模块。语法如下：在这里，module_name要直接放模块的名字，而不是一个字符串形式。

reload(module_name)

Python I/O函数（不只是文件读写）

1.读取键盘输入

读取输入的行：

str = input("请输入：");
print("你输入的内容是: ", str)

input() 函数可以接受Python表达式的输入，并输出表达式的计算结果

请输入：[x*5 for x in range(2,10,2)]

你输入的内容是:  [10, 20, 30, 40]

2.打开、关闭读写文件

可以用file对象对大多数文件进行操作。

1）打开文件

你必须先用Python内置的open()函数打开一个文件，创建一个file对象，相关的方法才可以调用它进行读写。

file object = open(file_name [, access_mode][, buffering])

·       file_name：file_name变量是一个包含了你要访问的文件名称的字符串值。

·       access_mode：access_mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

·       buffering:如果buffering的值被设为0，就不会有寄存。如果buffering的值取1，访问文件时会寄存行。如果将buffering的值设为大于1的整数，表明了这就是的寄存区的缓冲大小。如果取负值，寄存区的缓冲大小则为系统默认。

·       当文件不存在但通过open函数打开时，如果是写入则会自动创建文件，如果是读取内容则会报错。

2）File对象的属性

文件被打开后就会创建一个File对象。

3）关闭文件

当一个文件对象的引用被重新指定给另一个文件时，Python 会关闭之前的文件（Python会自动地关闭之前的文件对象，这样不那么耗费内存）。用close（）方法关闭文件是一个很好的习惯。

4）读写文件

无论读、写、还是关闭文件，都需要先用open打开文件。

# 写一个文件

fo = open("foo.txt", "wb")

fo.write( "www.runoob.com!\nVery good site!\n");

# 关闭打开的文件

fo.close()

# 读一个文件

fo = open("foo.txt", "r+")

str = fo.read(10);     #这里的参数10表示的是被读取的字节数

print("读取的字符串是 : ", str)

# 关闭打开的文件

fo.close()

5）文件内定位

tell()方法告诉你文件内的当前位置（那应该就是告诉你文件指针在哪个位置）；换句话说，下一次的读写会发生在文件开头这么多字节之后。

seek(offset [,from])方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。

# 打开一个文件

fo = open("foo.txt", "r+")

str = fo.read(10);

print("读取的字符串是 : ", str)

# 查找当前位置

position = fo.tell();

print("当前文件位置 : ", position)

# 把指针再次重新定位到文件开头

position = fo.seek(0, 0);

str = fo.read(10);

print("重新读取字符串 : ", str)

# 关闭打开的文件

fo.close()

3.文件File对象的方法

4.文件OS（Python中处理文件和目录的模块）

Python中的异常处理

1.异常类型

2.异常处理

1）try/except语句

捕捉异常通常用try（捕捉错误）/except（处理错误）语句。如果你不想在异常发生时结束你的程序，只需在try里捕获它。异常可带参数，用于说明异常原因

try: fh = open("testfile", "w") fh.write("这是一个测试文件，用于测试异常!!") except (IOError,RuntimeError): # 当出现这两种error中的一种时，执行except后面的操作  print("Error: 没有找到文件或读取文件失败") except Exception as e: # 使用异常基类捕获  print("Error: 出错") else: print("内容写入文件成功") fh.close()

2）try/finally语句

try-finally 语句无论是否发生异常都将执行最后的代码。

try: fh = open("testfile", "w") fh.write("这是一个测试文件，用于测试异常!!") finally: print("Error: 没有找到文件或读取文件失败")

3.自己设置异常（用于bug修改、错误检查）

我们可以使用raise语句自己触发异常

raise语法格式如下：

raise [Exception [, args [, traceback]]]

语句中Exception是异常的类型（例如，NameError）参数是一个异常参数值。该参数是可选的，如果不提供，异常的参数是”None”。

最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。例子如下：

def functionName( level ): if level < 1: raise Exception("Invalid level!", level) # 触发异常后，后面的代码就不会再执行

对于自定义的异常，在使用except语句处理异常时，一定要将Exception中的异常名作为except语句的一个参数。例子如下：

try: #正常逻辑 except "Invalid level!": #触发自定义异常 else: #其余代码

4.自己创建异常类型，用于常见异常复用

一个异常可以是一个字符串，类或对象。

class Networkerror(RuntimeError): # 基于RuntimeError类创建一个新的类  def __init__(self, arg): # 定义一个函数  self.args = arg

try: raise Networkerror("Bad hostname") #抛出一个Networkerror异常 except Networkerror as e: #匹配异常的类型，当出现了Networkerror型异常时，执行该except语句，并传递变量e，变量 e 是用于创建Networkerror类的实例，这里的e应该就是这个异常对象？  print(e.args)

Python内置函数

Python面向对象

1.面向对象技术简介

·       类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例（对象是类实例化之后的结果）。

·       类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

·       数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。

·       方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

·       实例变量：定义在方法中的变量，只作用于当前实例的类。

·       继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟”是一个（is-a）”关系（例图，Dog是一个Animal）。

·       实例化：创建一个类的实例，类的具体对象。

·       方法：类中定义的函数。

·       对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

2.创建类

'所有员工的基类'
class Employee:
    empCount = 0
    def __init__(self, name, salary): #构造函数
        self.name = name            # 添加实例属性
        self.salary = salary        # 添加实例属性
        Employee.empCount += 1      # 修改类属性
    def displayCount(self):         # 添加实例方法
        print("TotalEmployee %d" % Employee.empCount) # 读取类属性

    def displayEmployee(self):      # 添加实例方法
        print("Name:", self.name, ", Salary:", self.salary) # 读取实例属性

·    empCount变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount访问。

·       第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

·       self代表类的实例，self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。Self代表了一件事情，那就是：类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称,按照惯例它的名称是 self。

3.创建实例对象

实例化类其他编程语言中一般用关键字 new，但是在 Python中并没有这个关键字，类的实例化类似函数调用方式。

以下使用类的名称Employee 来实例化，并通过 __init__ 方法接受参数。

"创建 Employee类的第一个对象"
emp1 = Employee("Zara",2000)
"创建 Employee类的第二个对象"
emp2 = Employee("Manni",5000)

4.操作对象属性

下面是读取对象属性的实例：

'所有员工的基类'
class Employee:
    empCount = 0
    def __init__(self, name, salary): #构造函数
        self.name = name            # 添加实例属性
        self.salary = salary        # 添加实例属性
        Employee.empCount += 1      # 修改类属性
    def displayCount(self):         # 添加实例方法
        print("TotalEmployee %d" % Employee.empCount) # 读取类属性

    def displayEmployee(self):      # 添加实例方法
        print("Name:", self.name, ", Salary:", self.salary) # 读取实例属性


# "创建 Employee 类的第一个对象"
emp1 =Employee("Zara",2000)
# "创建 Employee 类的第二个对象"
emp2 =Employee("Manni",5000)
emp1.displayEmployee()
emp2.displayEmployee()
print("TotalEmployee %d" %Employee.empCount)

以下函数还可以对属性进行读取之外的操作：

·       getattr(obj,name[, default]) :访问对象的属性。

·       hasattr(obj,name):检查是否存在一个属性。

·       setattr(obj,name,value):设置一个属性。如果属性不存在，会创建一个新属性。

·       delattr(obj,name) :删除属性。

5.Python内置的类属性

·       __dict__ :类的属性（包含一个字典，由类的数据属性组成）

·       __doc__ :类的文档字符串

·       __name__:类名

·       __module__:类定义所在的模块（类的全名是’__main__.className’，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）

·       __bases__ :类的所有父类构成元素（包含了一个由所有父类组成的元组）

6.类的继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

在python中继承中的一些特点：

·       1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。

·       2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数

·       3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

如果在继承元组中列了一个以上的类，那么它就被称作”多重继承” 。

class Parent:
    # 定义父类
    parentAttr =100
    def __init__(self):
        print("调用父类构造函数")
    def parentMethod(self):
        print('调用父类方法')
    def setAttr(self,attr):
        Parent.parentAttr =attr
    def getAttr(self):
        print("父类属性 :",Parent.parentAttr)
 
class Child(Parent):
    # 定义子类
    def __init__(self):
        print("调用子类构造方法")  #无论子类还是父类，都要单独写一次_init_
    def childMethod(self):
        print('调用子类方法')
    def getAttr (self):
        print('重写父类方法，因为父类方法不能满足需求')

c = Child()  #实例化子类
c.childMethod()#调用子类的方法
c.parentMethod()#调用父类方法
c.setAttr(200)  #再次调用父类的方法 -设置属性值
c.getAttr()#再次调用父类的方法 -获取属性值

你可以使用issubclass()或者isinstance()方法来检测，一个类或对象是否为其他类或对象的子类。

·       issubclass() –布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)

·       isinstance(obj, Class)布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。

7.运算符重载

Python同样支持运算符重载，实例如下：

class Vector:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def __str__(self):
        return 'Vector(%d, %d)' % (self.a, self.b)
    def __add__(self, other):
        return Vector(self.a + other.a, self.b + other.b)
        

v1 = Vector(2, 10)
v2 = Vector(5, -2)
print(v1 + v2)

以上代码执行结果如下所示:

Vector(7, 8)

8.类的私有属性及方法

1）类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用是self.__private_attrs。

2）类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用self.__private_methods

3）实例

class JustCounter:
    __secretCount = 0
    # 私有变量
    publicCount = 0
    # 公开变量
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print(self.__secretCount)  # 在内部使用私有化属性，不会产生错误

counter = JustCounter()
counter.count()
counter.count()
print(counter.publicCount)
print(counter.__secretCount)
# 报错，实例不能访问私有变量

9.单下划线、双下划线、头尾双下划线说明：

·       __foo__:定义的是特列方法，类似 __init__() 之类的。

·       _foo:以单下划线开头的表示的是 protected类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *

·       __foo:双下划线的表示的是私有类型(private)的变量,只能是允许这个类本身进行访问了。

今天的文章python基础系列教程——python基础语法全解分享到此就结束了，感谢您的阅读，如果确实帮到您，您可以动动手指转发给其他人。