pathon基础

 

Python与其他语言的区别：

Python不能开发APP

python是解释型语言，解释一句执行一句

Python特点

1. python是完全面向对象的语言
2. python有非常强大的标准库
3. python有大量第三方模块
4. python是开源的

缺点：

运行速度慢

国内市场规模小

中文资料匮乏

安装：

官网：https://www.python.org/

linux安装教程：http://www.cnblogs.com/yhongji/p/9383857.html

1. 判断是否安装成功：在cmd输入python

idea集成python环境：https://blog.csdn.net/csolo/article/details/78664701

python源程序基本概念：

python源程序就是一个特殊格式的文本文件，可以用任意文本编辑器做python的开发

python的文件扩展名通常都是.py

第一个python程序

在文本编辑器中输入以下程序，并保存为hello.py

print("hello python")

在cmd中用python执行： python D:\test\hello.py

 

常见Bug：

1、名称错误

NameError: name 'pirnt' is not defined

2、语法错误

SyntaxError: invalid syntax

3、缩进错误

IndentationError: unexpected indent

记住每行代码前不要增加空格

4、编码错误

SyntaxError: Non-ASCII character '\xe4' in file

 

python2.0和python3.0介绍

python2.0默认不支持中文

python3支持中文：python3 D:\test\hello.py

python3.0没有向下兼容

python2.7版本是过渡版本，基本使用2.0版本，兼容部分3.0语法和函数

 

linux自带python2，但是没有pip2，所以需要自己下载，命令 yum install python-pip

 

执行python的三种方式：

• 解释器:

python 文件路径

python2.0是不会自动补全的

python3 文件路径

python3.0会自动补全（Tab）

其他解释器：

CPython:官方版本的C语言实现

Jython：可以运行在java平台

IronPython：可以运行在.net

PyPy:python实现的支持JIT即时编译

• 交互式:ipython

1、python shell

直接在终端中运行解释器，而不输入要执行的文件名

在python的Shell中直接输入Python代码，会立即看到程序执行结果

输入exit()退出解释器或按住CTRL+D

缺点：不能保存代码，不适合太大程序

2、ipython

ipython：是一个python的交互式shell，比默认的python shell好用得多，yum install ipython

ipython支持：自动补全，自动缩进，支持bashshell命令，内置许多很有用的功能和函数

需要安装

推出ipython：exit 或CTRL+D

• 集成开发环境:Pycharm,eclipse.idea

 

python命名规则：

小写字母，数字下划线，且不能以数字开始

 

学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。

 

python注释：

单行注释：#

后面一般跟一个空格

或

代码后与注释之间至少两个空格

多行注释：三个连续引号

""" 这是注释"""

 

中文编码

在文件开头加入 # -*- coding: UTF-8 -*- 或者 #coding=utf-8 

运算符

算术运算符

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

在python中 * 还可以用于字符串，计算结果就是字符串指定次数

比较运算符

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 true.
<>	不等于 - 比较两个对象是否不相等	(a <> b) 返回 true。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。	(a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

赋值运算符

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

逻辑运算符

 

变量赋值

Python 中的变量赋值不需要类型声明。

counter = 100

多个变量赋值

a = b = c = 1 多个变量相同

a, b, c = 1, 2, "john"

删除变量

del name

标准数据类型

• Numbers（数字）

• int（有符号整型）
• long（长整型[也可以代表八进制和十六进制]）
• float（浮点型）
• complex（复数）

• String（字符串）
• List（列表）

list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]

• Tuple（元组）

元组是另一个数据类型，类似于 List（列表）。

元组用 () 标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )

• Dictionary（字典）

字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用"{ }"标识。字典由索引(key)和它对应的值value组成。

dict = {} dict['one'] = "This is one" dict[2] = "This is two" tinydict = {'name': 'john','code':6734, 'dept': 'sales'}

python 3中将int与long整合为int

用type函数查看变量类型

变量格式化输出：

print("苹果的单价%f元/斤,你买了%f斤，共%f元" % (2.5,4,10))

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 转换为一个列表 set(s) 转换为可变集合 dict(d) 创建一个字典。d 必须是一个序列 (key,value)元组。 frozenset(s) 转换为不可变集合 chr(x) 将一个整数转换为一个字符 unichr(x) 将一个整数转换为Unicode字符 ord(x) 将一个字符转换为它的整数值 hex(x) 将一个整数转换为一个十六进制字符串 oct(x) 将一个整数转换为一个八进制字符串

 

提示用户输入信息

 

if语句

单条件:

if 判断条件： 执行语句…… else： 执行语句……

注意，代码的缩进为一个Tab或者四个空格，不要混用

 

多条件：

if 判断条件1: 执行语句1…… elif 判断条件2: 执行语句2…… elif 判断条件3: 执行语句3…… else: 执行语句4……

 

While语句

while 判断条件： 执行语句……

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

循环使用 else 语句

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

For语句

for iterating_var in sequence: statements(s)

eg: for letter in 'Python': # 第一个实例 print '当前字母 :', letter fruits = ['banana', 'apple', 'mango'] for fruit in fruits: # 第二个实例 print '当前水果 :', fruit

循环使用 else 语句

eg: for num in range(10,20): # 迭代 10 到 20 之间的数字 for i in range(2,num): # 根据因子迭代 if num%i == 0: # 确定第一个因子 j=num/i # 计算第二个因子 print '%d 等于 %d * %d' % (num,i,j) break # 跳出当前循环 else: # 循环的 else 部分 print num, '是一个质数'

 

pass 语句

Python pass 是空语句，是为了保持程序结构的完整性。

pass 不做任何事情，一般用做占位语句。

#!/usr/bin/python # -*- coding: UTF-8 -*- # 输出 Python 的每个字母 for letter in 'Python': if letter == 'h': pass print '这是 pass 块' print '当前字母 :', letter print "Good bye!"

 

函数

def functionname( parameters ): "函数_文档字符串" function_suite return [expression]

应该先定义函数在调用函数

eg: def printme( str ): "打印传入的字符串到标准显示设备上" print str return

函数调用

functionname（parameters）

关键字参数

#可写函数说明 def printme( str ): "打印任何传入的字符串" print str; return; #调用printme函数 printme( str = "My string");

默认参数

#可写函数说明 def printinfo( name, age = 35 ): "打印任何传入的字符串" print "Name: ", name; print "Age ", age; return; #调用printinfo函数 printinfo( age=50, name="miki" ); printinfo( name="miki" );

不定长参数

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

eg: # 可写函数说明 def printinfo( arg1, *vartuple ): "打印任何传入的参数" print "输出: " print arg1 for var in vartuple: print var return; # 调用printinfo 函数 printinfo( 10 ); printinfo( 70, 60, 50 );

匿名函数

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

eg: # 可写函数说明 sum = lambda arg1, arg2: arg1 + arg2; # 调用sum函数 print "相加后的值为 : ", sum( 10, 20 ) print "相加后的值为 : ", sum( 20, 20 )

 

return 语句

# 可写函数说明 def sum( arg1, arg2 ): # 返回2个参数的和." total = arg1 + arg2 print "函数内 : ", total return total; # 调用sum函数 total = sum( 10, 20 );

 

模块

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

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

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

模块能定义函数，类和变量，模块里也能包含可执行的代码。

模块的引入

import module1[, module2[,... moduleN]]

当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support.py，需要把命令放在脚本的顶端：

#!/usr/bin/python

调用模块中的方法

模块名.函数名

 

模块中导入一个指定的部分到当前命名空间中

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

 

把一个模块的所有内容全都导入到当前的命名空间，然而这种声明不该被过多地使用。

from modname import *

 

dir()函数

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__指向该模块的导入文件名。

 

globals() 和 locals() 函数

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

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

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

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

 

Python中的包：

包必须有__init__.py 文件

目录结构 test.py package_runoob |-- __init__.py |-- runoob1.py |-- runoob2.py

 

运行结果

package_runoob 初始化 I'm in runoob1 I'm in runoob2

 

日期和时间

Python 的 time 模块下有很多函数可以转换常见日期格式。如函数time.time()用于获取当前时间戳（以秒为单位的浮点数）

#!/usr/bin/python # -*- coding: UTF-8 -*- import time; # 引入time模块 ticks = time.time() print "当前时间戳为:", ticks 结果输出： 当前时间戳为: 1459994552.51

获取当前时间

从返回浮点数的时间戳方式向时间元组转换，只要将浮点数传递给如localtime之类的函数

#!/usr/bin/python # -*- coding: UTF-8 -*- import time localtime = time.localtime(time.time()) print "本地时间为 :", localtime 结果输出： 本地时间为 : time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=3, tm_sec=27, tm_wday=3, tm_yday=98, tm_isdst=0)

格式化日期

ime.strftime(format[, t])

#!/usr/bin/python # -*- coding: UTF-8 -*- import time # 格式化成2016-03-20 11:45:39形式 print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) # 格式化成Sat Mar 28 22:24:24 2016形式 print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()) # 将格式字符串转换为时间戳 a = "Sat Mar 28 22:24:24 2016" print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y")) 结果输出： 2016-04-07 10:25:09 Thu Apr 07 10:25:09 2016 1459175064.0

获取某月日历

#!/usr/bin/python # -*- coding: UTF-8 -*- import calendar cal = calendar.month(2016, 1) print "以下输出2016年1月份的日历:" print cal

输出结果：

以下输出2016年1月份的日历: January 2016 Mo Tu We Th Fr Sa Su 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

 

列表

list1 = ['physics', 'chemistry', 1997, 2000]

访问列表中的值

list1[0] 或 list2[1:5]

更新列表

list.append('Google') ## 使用 append() 添加元素

删除列表元素

del list1[2]

列表长度，列表重复，列表组合，列表是否存在元素，迭代

列表截取

Python 表达式	结果	描述
L[2]	'Taobao'	读取列表中第三个元素
L[-2]	'Runoob'	读取列表中倒数第二个元素
L[1:]	['Runoob', 'Taobao']	从第二个元素开始截取列表

列表函数&方法

序号	函数
1	cmp(list1, list2) 比较两个列表的元素
2	len(list) 列表元素个数
3	max(list) 返回列表元素最大值
4	min(list) 返回列表元素最小值
5	list(seq) 将元组转换为列表

 

序号	方法
1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj) 统计某个元素在列表中出现的次数
3	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj) 将对象插入列表
6	list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj) 移除列表中某个值的第一个匹配项
8	list.reverse() 反向列表中元素
9	list.sort(cmp=None, key=None, reverse=False) 对原列表进行排序

元组

tup1 = ('physics', 'chemistry', 1997, 2000) tup2 = (1, 2, 3, 4, 5 ) tup3 = "a", "b", "c", "d" #任意无符号的对象，以逗号隔开，默认为元组

元组中只包含一个元素时，需要在元素后面添加逗号：tup1 = (50,)

访问元组

tup1[0] 或 tup2[1:5]

修改元组

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

tup1 = (12, 34.56) tup2 = ('abc', 'xyz') # 以下修改元组元素操作是非法的。 # tup1[0] = 100 # 创建一个新的元组 tup3 = tup1 + tup2 print tup3 输出：(12, 34.56, 'abc', 'xyz')

删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组

tup = ('physics', 'chemistry', 1997, 2000) print tup del tup print "After deleting tup : " print tup 但是：实例元组被删除后，输出变量会有异常信息，输出如下 ('physics', 'chemistry', 1997, 2000) After deleting tup : Traceback (most recent call last): File "test.py", line 9, in print tup NameError: name 'tup' is not defined

元组计算元素个数、连接、复制、元素是否存在、迭代

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	True	元素是否存在
for x in (1, 2, 3): print x,	1 2 3	迭代

元组索引，截取

Python 表达式	结果	描述
L[2]	'SPAM!'	读取第三个元素
L[-2]	'Spam'	反向读取，读取倒数第二个元素
L[1:]	('Spam', 'SPAM!')	截取元素

元组内置函数

Python元组包含了以下内置函数

序号	方法及描述
1	cmp(tuple1, tuple2) 比较两个元组元素。
2	len(tuple) 计算元组元素个数。
3	max(tuple) 返回元组中元素最大值。
4	min(tuple) 返回元组中元素最小值。
5	tuple(seq) 将列表转换为元组。

字典

字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 

d = {key1 : value1, key2 : value2 }

访问字典里的值

d['key1']

修改字典

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'} dict['Age'] = 8 # 更新 dict['School'] = "RUNOOB" # 添加

删除字典元素

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'} del dict['Name'] # 删除键是'Name'的条目 dict.clear() # 清空词典所有条目 del dict # 删除词典

字典内置函数&方法

序号	函数及描述
1	cmp(dict1, dict2) 比较两个字典元素。
2	len(dict) 计算字典元素个数，即键的总数。
3	str(dict) 输出字典可打印的字符串表示。
4	type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。

 

序号	函数及描述
1	dict.clear() 删除字典内所有元素
2	dict.copy() 返回一个字典的浅复制
3	dict.fromkeys(seq[, val]) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
4	dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
5	dict.has_key(key) 如果键在字典dict里返回true，否则返回false
6	dict.items() 以列表返回可遍历的(键, 值) 元组数组
7	dict.keys() 以列表返回一个字典所有的键
8	dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2) 把字典dict2的键/值对更新到dict里
10	dict.values() 以列表返回字典中的所有值
11	pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
12	popitem() 随机返回并删除字典中的一对键和值。

字符串

Python字符串更新

你可以对已存在的字符串进行修改，并赋值给另一个变量(原来的字符串不变)

var1 = 'Hello World!' print "更新字符串 :- ", var1[:6] + 'Runoob!'

Python字符串运算符

操作符	描述	实例
+	字符串连接	>>>a + b 'HelloPython'
*	重复输出字符串	>>>a * 2 'HelloHello'
[]	通过索引获取字符串中字符	>>>a[1] 'e'
[ : ]	截取字符串中的一部分	>>>a[1:4] 'ell'
in	成员运算符 - 如果字符串中包含给定的字符返回 True	>>>"H" in a True
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	>>>"M" not in a True
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母"r"（可以大小写）以外，与普通字符串有着几乎完全相同的语法。	>>>print r'\n' \n >>> print R'\n' \n

Python三引号

python中三引号可以将复杂的字符串进行复制:

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）。

errHTML = '''

ERROR

%s

'''

Unicode 字符串

u'Hello World !'

 

打开和关闭文件

打开文件：

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

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

 

File对象的属性:

属性	描述
file.closed	返回true如果文件已被关闭，否则返回false。
file.mode	返回被打开文件的访问模式。
file.name	返回文件的名称。
file.softspace	如果用print输出后，必须跟一个空格符，则返回false。否则返回true。

 

#!/usr/bin/python # -*- coding: UTF-8 -*- # 打开一个文件 fo = open("foo.txt", "w") print "文件名: ", fo.name print "是否已关闭 : ", fo.closed print "访问模式 : ", fo.mode print "末尾是否强制加空格 : ", fo.softspace

 

关闭文件

File 对象的 close（）方法刷新缓冲区里任何还没写入的信息，并关闭该文件

fileObject.close()

 

读写文件：

write()方法

write()方法可将任何字符串写入一个打开的文件。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。

write()方法不会在字符串的结尾添加换行符('\n')：

fileObject.write(string)

 

read()方法

read（）方法从一个打开的文件中读取一个字符串。需要重点注意的是，Python字符串可以是二进制数据，而不是仅仅是文字。

fileObject.read([count])

#!/usr/bin/python # -*- coding: UTF-8 -*- # 打开一个文件 fo = open("foo.txt", "r+") str = fo.read(10) print "读取的字符串是 : ", str # 关闭打开的文件 fo.close()

 

文件定位

tell()方法告诉你文件内的当前位置, 换句话说，下一次的读写会发生在文件开头这么多字节之后。

seek（offset [,from]）方法改变当前文件的位置。Offset变量表示要移动的字节数。From变量指定开始移动字节的参考位置。

如果from被设为0，这意味着将文件的开头作为移动字节的参考位置。如果设为1，则使用当前的位置作为参考位置。如果它被设为2，那么该文件的末尾将作为参考位置。

#!/usr/bin/python # -*- coding: UTF-8 -*- # 打开一个文件 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()

 

重命名文件

引入 os模块

os.rename(current_file_name, new_file_name)

删除文件

引入 os模块

os.remove(file_name)

创建目录

os.mkdir("newdir")

改变当前的目录

os.chdir("newdir")

删除目录

os.rmdir('dirname')

 

面向对象

类

class ClassName: '类的帮助信息' #类文档字符串 class_suite #类体

#!/usr/bin/python # -*- coding: UTF-8 -*- class Employee: '所有员工的基类' empCount = 0 def __init__(self, name, salary): self.name = name self.salary = salary Employee.empCount += 1 def displayCount(self): print "Total Employee %d" % Employee.empCount def displayEmployee(self): print "Name : ", self.name, ", Salary: ", self.salary

• empCount 变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount 访问。
• 第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
• self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

 

创建实例对象

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

注意变量前面没有类型，且后面创建的时候没有new

访问属性

您可以使用点号 . 来访问对象的属性。使用如下类的名称访问类变量:

emp1.displayEmployee()

Python内置类属性

• __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
• __doc__ :类的文档字符串
• __name__: 类名
• __module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
• __bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

#!/usr/bin/python # -*- coding: UTF-8 -*- class Employee: '所有员工的基类' empCount = 0 def __init__(self, name, salary): self.name = name self.salary = salary Employee.empCount += 1 def displayCount(self): print "Total Employee %d" % Employee.empCount def displayEmployee(self): print "Name : ", self.name, ", Salary: ", self.salary print "Employee.__doc__:", Employee.__doc__ print "Employee.__name__:", Employee.__name__ print "Employee.__module__:", Employee.__module__ print "Employee.__bases__:", Employee.__bases__ print "Employee.__dict__:", Employee.__dict__

输出：

Employee.__doc__: 所有员工的基类 Employee.__name__: Employee Employee.__module__: __main__ Employee.__bases__: () Employee.__dict__: {'__module__': '__main__', 'displayCount': , 'empCount': 0, 'displayEmployee': , '__doc__': '\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb', '__init__': }

 

继承

class SubClassName (ParentClass1[, ParentClass2, ...]): ...

#!/usr/bin/python # -*- coding: UTF-8 -*- 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 "调用子类构造方法" def childMethod(self): print '调用子类方法' c = Child() # 实例化子类 c.childMethod() # 调用子类的方法 c.parentMethod() # 调用父类方法 c.setAttr(200) # 再次调用父类的方法 - 设置属性值 c.getAttr() # 再次调用父类的方法 - 获取属性值

 

• issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)
• isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。

方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法：

#!/usr/bin/python # -*- coding: UTF-8 -*- class Parent: # 定义父类 def myMethod(self): print '调用父类方法' class Child(Parent): # 定义子类 def myMethod(self): print '调用子类方法' c = Child() # 子类实例 c.myMethod() # 子类调用重写方法 输出：调用子类方法

 

基础重载方法

__init__ ( self [,args...] )

构造函数

简单的调用方法: obj = className(args)

__cmp__ ( self, x )

对象比较

简单的调用方法 : cmp(obj, x)

__str__( self )

用于将值转化为适于人阅读的形式

简单的调用方法 : str(obj)

 

类属性与方法

类的私有属性

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

类的方法

在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数

类的私有方法

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

 

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

• __foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。
• _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
• __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

 

 

使用idea创建Python程序

1、在idea的Setting中添加插件Python即可

2、创建Python项目

3、添加模块

4、写完之后右键运行.py即可