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 = ''' Friends CGI Demo

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即可

 

你可能感兴趣的:(Python)