Python学习笔记2

IDLE中调试程序

使用IDLE打开源文件，点击”run module => debug => debugger”打开调试器窗口。
切换到调试器窗口进行调试。

IDLE中调试窗口

IDLE中的菜单

python中的文件名

py：编写python代码时，得到的是一个以.py为扩展名的文本文件。
.pyo：优化的python字节码文件，同样无法使用文本编辑器直接查看其内容。可以使用“python-o-m py_compile file.py”或“python-oo-m py_compile file.py”进行优化编译。
.pyd：一般是由其他语言编写并编译的二进制文件，常用于实现某些软件工具的python编程接口插件或python动态链接库。

python的解释器

Cpython是安装好python2.7后，获得的官方版本的解释器，是用C语言开发的。
IPython是基于Cpython的交互式解释器，即，Ipython在交互方式上有所增强，在执行python代码的功能和CPython是完全一样的。
PyPy采用JIT技术，对python代码进行动态编译（注意不是解释），所有可以显著提高python代码的执行速度。
Jython是运行在Java平台上的python解释器，可以直接把python代码编译成Java字节码执行。
IronPython和Jython类似，但是其运行在微软.Net平台上，可以直接把python代码编译成.Net的字节码。

python脚本中的import

导入模块：模块为一个文件，可以作为模块的文件类型包括“.py”、“.pyo”、“.pyc”、“.pyd”、“.so”、“.dll”等。
导入包：包是一个目录，使用import导入包，或者from+import来导入包中的部分模块。包目录下包括文件init.py和模块文件、子目录，如果子目录中也有init.py。那么它就是这个包的子包。

python脚本中的import的例子

>>>import math
>>>math.sin(0.5)           #求0.5的正弦
>>>import random
>>>x=random.random()       #获得[0,1)内的随机小数
>>>y=random.random()
>>>n=random.randint(1,100) #获得[1,100]上的随机整数

python中包管理工具

easy_install：
- 位于C:\Python27\Scripts
- easy_install pip,开始安装pip
pip：
- pip是一个安装和管理Python包的工具，方便地下载Python包。
- 不仅下载需要的包，而且会下载依赖包。
- pip install包名称

python脚本中的输入和输出

输入

输入是通过raw_input( )或input( )函数来实现的，input( )的一般格式为：

x = input(“提示：”)
该函数返回输入的对象。可输入数字、字符串和其他对象。
raw_input( )直接读取控制台的输入（任何类型的输入它艘都可以接收）。面对于input( )，它希望能够读取一个合法的python表达式，即你输入字符串的时候必须使用引号将它括起来，否则它会引发一个SyntaxError。

输出

输出是通过print语句来完成的，一般格式为：
- print 对象1，对象2…对象n
- print (字符串常量或字符串变量)
- print (“ %s%s_”%(string1,string2,_stringn))
- print (“ %d%d_”%(整数1,整数2,整数n))
- print (“ %x,%o”%(255,255))

python脚本中的输入和输出的例子

>>> raw_input_A = raw_input("raw_input:")
raw_input:abc
>>> input_A = input("Input:")
Input:abc

Traceback (most recent call last):
  File "<pyshell#20>", line 1, in <module>
    input_A = input("Input:")
  File "<string>", line 1, in <module>
NameError: name 'abc' is not defined
>>> input_A = input("Input:")
Input:"abc"

>>> print 300
300
>>> print 100 + 200
300
>>> print'100 + 200 =',100 + 200
100 + 200 = 300

python程序的性能测试

内存占用测试

from memory_profiler import profile
@profile
def ifPrime(n):
    if n == 2:
        return True
    for i in range(2,int(n**0.5)+2):
        if n%i == 0:
            return False
    return Ture

isPrime(9999999999999999999)

python的对象模型

计算机能处理的远不止数值，还可以处理文本、图形、音频、视频、网页等各种各样的数据，不同的数据，需要定义不同的数据类型。
在python中，一切事物都是对象，程序中存储的所有数据都是对象，对象基于类创建。
class 指自定义类型，type 指内置类型。
实例化：创建特定类型的对象，实例被创建后，其身份和类型不可改变。
- 若对象值可修改，称为可变对象
- 若对象值不可修改，称之为不可变对象
容器：某个对象包含对其他对象的引用，如：列表

python数据类型

Python数据类型

python数据类型的例子

对象类型	例子
数字	1234，3.14，3+4j
字符串	‘swfu’，”I’m student”，”Python”
日期	2012-08-25
列表	[1,2,3]
字典	{1:’food’,2:’taste’,3:’import’}
元组	(2,-5,6)
文件	f=open(‘data.dat’,’r’)
集合	set(‘abc’),{‘a’,’b’,’c’}
布尔型	True,False
空类型	None
编程单元类型	函数、模块、类

数字常量

浮点数又称小数，如15.0、0.37、-11.2、1.2e2、314.15e-2
复数是由实部和虚部构成的数，如3+4j、0.1-0.5j

>>> a=3+4j
>>> b=5+6j
>>> c=a+b
>>> c
(8+10j)
>>> c.real  #复数的实部
8.0
>>> c.imag  #复数的虚部
10.0

布尔类型

在计算机语言中表达两种相反的结果，把结果肯定的用“True”表示，把结果否定的用“False”来表示。
布尔类变量只有二种可能值：True或者False

1 2	b = 100<101 print(b)

b是布尔类型变量，运行此段程序，将输出True

字符串

用单引号或双引号括起来的符号系列称为字符串，如’abc’、’123’、’中国’、”Python”
空串表示为’’或””
转义字符可表示特殊字符，如’\n’是换行符、’\x41’、’\101’、’A’都表示字符A
三引号表示的字符串可以换行，因此可以用来表示超长字符串，或给程序加较长的注释。

字符串的下标

字符串中字符的位置从左到右以下标0开始，从右到左以下标-1开始。

S	T	F	D	E	N	O	X	Y	Z
0	1	2	…	…	…	…	…	-2	-1

>>> a="hello"
>>> a[0]
'h'
>>> a[-1]
'o'

字符串的截取

截取有两种方法：

一种是索引 s[index]，取出一个字符；
另一种是切片 s[[start]:[end]]，取出多个字符

>>> s = 'abcdef'
>>> s[1:3]  #取出位置为1到位置为2的字符，不包括3
'bc'
>>> s[:3]   #取出从头至位置2的字符
'abc'
>>> s[4:]   #取出从位置4开始的所有字符
'ef'
>>> s[:]    #取出全部字符
'abcdef'

字符串的查找

在字符串中查找一个子串，返回子串的位置，成功返回下标，失败返回-1

语法格式为：

s.find(sub[,start][,end])

>>> s = 'apple,peach,banana,peach,pear'
>>> s.find('peach',7)
19
>>> s.find('peach',7,20)
-1

字符串的分割

通过指定分隔符对字符串进行分割，返回分割后的字符串列表

语法格式为：

str.split(str = “”,num = string.count(str))

参数：

str：分隔符，默认所有的空格符，包括空格、换行(\n)、制表符(\t)等
num：分割次数

>>> s = 'apple,peach,banana,pear'
>>> li = s.split(',')
>>> li
['apple', 'peach', 'banana', 'pear']

字符串的连接

将序列中的元素以制定的字符连接生成一个新的字符串

语法格式为：

str.join(sequence)

参数：要连接的元素列表

>>> li = ['apple','peach','banana','pear']
>>> sep = ','
>>> s = sep.join(li)
>>> s
'apple,peach,banana,pear'

字符串的转换小写字母

转换字符串中所有大写字符为小写

语法格式为：

str.lower( )

参数：无

返回将字符串中所有大写字符转化为小写后生成的字符串

>>> s="What's Your Name?"
>>> s2=s.lower()
>>> s2
"what's your name?"

字符串的替换

把字符串中的old（旧字符串）替换成new（新字符串）

语法格式：

str.replace(old,new[,max])

参数：

old：将被替换的子字符串
new：新字符串，用于替换old子字符串
max：可选字符串，替换不超过max次

>>> s = 'hello world'
>>> print s
hello world
>>> s2 = s.replace('hello','hi')
>>> print s2
hi world

字符串两端删除字符

移除字符串头尾指定的字符（默认为空格）

语法格式为：

str.strip([chars])

参数：

chars：移除字符串头尾指定的字符

返回移除字符串头尾指定的字符生成的新字符串

>>> s = 'abc '
>>> s2 = s.strip()
>>> s2
'abc'

字符串结束符判断

判断字符串是否以指定后缀结尾，如果以指定后缀结尾，返回True，否则返回False

语法格式为：

str.endswith(suffix[,start[,end]])

参数：

suffix：一个字符串或者是一个元素
start：字符串中的开始位置
end：字符中结束位置

>>> str="this is a car!!!"
>>> suffix="car!!!"
>>> print str.endswith(suffix)
True
>>> suffix="is"
>>> print str.endswith(suffix,2,4)
True
>>> str="this is a car!!!"
>>> print str.endswith(suffix,2,4)
True

常用字符串处理函数

检测字符串是否由字母和数字组成

语法格式：

str.isalnum( )

参数：无

如果string至少有一个字符并且所有字符都是字母或数字则返回True，否则返回Flase

>>> str="time1125"
>>> print str.isalnum()
True
>>> str="time1125!"
>>> print str.isalnum()

函数	描述
string.count(str,beg=0,end=len(string))	返回str在string里面出现的次数
string.isdigit()	如果string只包含数字则返回True否则返回False
max(str)	返回字符串str中最大的字母
min(str)	返回字符串str中最小的字母
string.rfind(str,beg=0,end=len(string))	类似于find()函数，不过是从右边开始查找
string.rindex(str,beg=0,end=len(string))	类似于index()函数，不过是从右边开始查找
string.startswith(obj,beg=0,end=len(string))	返回字符串是否是以.obj开头，是则返回True，否则返回False。如果返回False和end指定值，则在指定范围内检查

字符串使用的案例

题目：用户输入数字，用逗号分隔，使用python编程求这些数字的和。

分析：用户输入的数字个数是不确定的，可以当作一个字符串来处理。首先，分割数字串，然后，将子串转换成数字，最后，将数字求和。

s=raw_input('Input Numbers separated by comma: ')
li=s.split(',')
print li
sum=0
for x in li:
    sum=sum+float(x)
print'sum=',sum

运行结果为：
Input Numbers separated by comma: 23,2,5,12.3
['23', '2', '5', '12.3']
sum= 42.3

字符串转化为数字

将字符串转化为整数，语法如下：

int(x [,base])，参数x是待转换的字符串，参数base为可选参数，指定转换后整数的进制，默认为10进制。
将字符串转化为长整数，语法如下：

long(x[,base])，参数的含义与int()函数相同。
将字符串或数字转化为浮点数，语法如下：

float(x)，参数x是待转换的字符串或数字。
计算字符串中的有效python表达式，并返回结果。

>>> a="1"
>>> b=int(a)+1
>>> print b
2
>>> 
>>> b="1+2"
>>> print(eval(b))
3

转化为字符串

将数值转化为字符串，语法如下：

str(x)，参数x是待转换的数值
将对象转化为可打印字符串，语法如下：

repr(obj)，参数obj是待转换的对象
将一个整数转化为可对应ASCII的字符，语法如下：

chr(整数)
将一个字符转化为可对应ASCII的字符，语法如下：

ord(字符)
将一个整数转化为一个十六进制字符串，语法如下：

chr(整数)
将一个整数转化为一个八进制字符串，语法如下：

oct(字符)

—

变量

变量存储在内存中的值。这就意味着在创建变量时会在内存中开辟一个空间。与常量不同的是变量的值可以动态变化。
基于变量的数据类型，解释器会分配制定内存，并决定什么数据可以被存储在内存中。
变量可以指定不同的数据类型，这些变量可以存储整数，小数或字符。

变量的命名规则

python的变量命名规则如下：
- 标识符名字的第一个字符必须是字母或下划线(_)；
- 标识符名字的第一个字符后面可以由字母、下划线(_)或数字(0~9)组成；
- 标识符名字是区分大小写的。

变量的赋值

每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。
每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
等号（=）用来给变量赋值。等号（=）运算符左边是一个变量名，等号（=）运算符右边是存储在变量中的值

变量的例子

定义了一个字符串变量a、数值变量b和布尔类型变量c

1
2
3

a="This is a String"
b=2
c=True

多个变量的赋值

创建一个整形对象，值为1，三个变量被分配到相同的内存空间

1
2
3

>>> a=b=c=1
>>> print a,b,c
1 1 1

两个整型对象1和2的分配给变量a和b，字符串对象“iohn”分配给变量c

1
2
3

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

变量的引用

引用：在python中从变量到对象的连接称为引用。

变量拥有自己的存储空间，变量连接到对象是该变量存储了对象单元的内存地址，并没有存储对象的值。

变量的共享引用

共享引用是指多个变量引用同一个对象。下面的语句使两个变量都引用同一个对象3。

1 2	>>> a=3 >>> b=a

删除对象引用

使用del语句删除对象的引用，语法格式为：

del varl[,var2[,var3[…,varN]]]

>>> a=5
>>> b=a
>>> print a,b
5 5
>>> del b
>>> print a,b
5

Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    print a,b
NameError: name 'b' is not defined

—

python的运算符

运算符是可以操纵操作数值的结构。
运算符是程序设计语言的最基本元素，它是构成表达式的基础。
如在10+20=30中，10和20称为操作数，+称为运算符。

python运算符的分类

算数运算符
赋值运算符
位运算符
比较运算符
逻辑运算符
字符串运算符
成员运算符
身份运算符

python中的算数运算符

算数运算符	描述	例子
+	相加运算	1+2的结果是3
-	相减运算	100-1的结果是99
*	乘法运算	2*2的结果是4
/	除法运算	4/2的结果是2
%	求模运算	10%3的结果是1
**	幂运算，x**y返回x的y次幂	2**3的结果是8
//	整除运算，返回商的整数部分	9//2的结果是4

python中的赋值运算符

赋值运算符	描述	例子
=	直接赋值	x=3，将3赋值到变量x中
+=	加法赋值	x+=3，等同于x=x+3
-=	减法赋值	x-=3，等同于x=x-3
*=	乘法赋值	x=3，等同于x=x3
/=	除法赋值	x/=3，等同于x=x/3
%=	取模赋值	x%3，等同于x=x%3
**=	幂赋值	x=3，等同于x=x3
//=	整除赋值	x//=3，等同于x=x//3

python中的位运算符

位运算符	描述
&	按位与运算。相当于”*”；都是1则为1，否则为0
\		按位或运算。相当于”+”；都是0则为0，否则为1
^	按位异或运算。0^0=0;1^0=1;0^1=1;1^1=0
~	按位非运算
<<	位左移运算，即所有位左移
>>	位右移运算，即所有位向右移

python中的比较运算符

比较运算符	描述
=	等于运算符。返回True或False
!=	不等运算符。返回True或False
<>	不等运算符，与!=相同
<	小于运算符
>	大于运算符
<=	小于等于运算符
>=	大于等于运算符

python中的逻辑运算符

逻辑运算符	描述
and	逻辑与运算符。例如：a and b，当a和b都为True时等于True；否则等于False
or	逻辑或运算符。例如：a or b，当a和b至少有一个为True时等于True；否则等于False
not	逻辑非运算符。例如：not a，当a等于True时，表达式等于False；否则等于True

python中的字符串运算符

字符串运算符	描述
+	字符串连接
*	重复输出字符串
[]	获取字符串中指出索引位置的字符，索引从0开始
[start,end]	截取字符串中的一部分，从索引位置start开始到end结束
in	成员运算符，如果字符串中包含给定的字符则返回True
not in	成员运算符，如果字符串中不包含给定的字符返回True
r或者R	指定原始字符串。原始字符串是指所有的字符串都是直接按照字面意思来使用，没有转义字符、特殊字符或不能打印的字符。原始字符串的第一个引号前加上字母“r”或“R”

python中的字符串运算符的例子

b = "hello";
a = b + "world!";
print(a);
print(a*2);
print(r"hello\nworld!");

python中成员和身份运算符

成员运算符	描述
in	如果在指定的序列中找到值返回True，否则返回False
not in	如果在指定的序列中没有找到值返回True，否则返回False

身份运算符	描述
is	is 是判断两个标识符是不是引用自一个对象
is not	is not 是判断两个标识符是不是引用自不同对象

python中的运算符优先级

运算符	描述
**	指数运算的优先级最高
~、+、-	逻辑非和正/负运算符。注意这里的“+”“-”不是加减运算符
*、/、%、//	乘、除、取模、取整除
+、-	加和减
>>、<<	位右移运算和左移运算
&	按位与运算
^、\		按位异或和按位或运算
>、==、!=	大于、等于、不等于
%=、/=、//=、-=、+=、=、*=	赋值运算符
is、is not	身份运算符
in、not in	成员运算符
not、or、and	逻辑运算符

—

python中的表达式的分类

表达式	描述
x+y、x-y	加法减法
x*y、x/y、x//y、x%y	乘法/重复，除法，求整商，余数/格式化
x**y	幂运算
x<y、x<=y、x>y、x>=y	大小比较，集合的包含关系比较
x==y、x!=y	相等比较，不等比较
x or y	逻辑或（只有x为假才会计算）
x and y	逻辑与（只有x为真才会计算）
not x	逻辑非
x in y、x not in y	成员与集合的关系
x is y、x is not y	对象实体测试

python中的逻辑组合表达式

成绩score在90~100或者50~60之间

90 <= score <= 100 or 50 <= score <= 60

—

python中的语句

语句是一段可执行代码，不一定有返回值。
语句块是一组语句：
- 通过放置空格来缩进语句创建语句块，语句块中的每一行必须是同样的缩进量。
- Python语言利用缩进表示语句块的开始和退出（Off-side规则），而非使用花括号或者某种关键字。
- 增加缩进表示语句块的开始，而减少缩进则表示语句块的推出。

python中的赋值语句

赋值语句是python中最简单、最常用的语句。
通过赋值语句可以定义变量并为其赋初始值。
Python中创建一个变量，不需要声明其类型。

python中的序列赋值语句

可以把赋值运算符右侧的一系列值，依次赋给左侧的变量。

a,b=4,5
print(a,b)
a,b=(6,7)
print(a,b)
a,b="AB"
print(a,b)
((a,b),c)=('AB','CD')   #嵌套序列赋值
print(a,b,c)

运行结果：
(4, 5)
(6, 7)
('A', 'B')
('A', 'B', 'CD')

python中的扩展序列赋值语句

在序列赋值中，赋值运算符左侧的变量个数和右侧值的个数总是相等的。如果不相等，Python就报错。Python中使用带有星号的名称，如*j，实现了扩展序列赋值。

i,*j=range(3)
print(i,j)

运行结果：
0,[1,2]

python中的增强赋值语句

增强赋值语句是从C语言借鉴而来，实质上是基本赋值语句的简写。通常来说，增强赋值语句的运行会更快一些。将变量x增加y赋给变量x，基本赋值语句为：

x = x+y

增强赋值语句则为：

x+=y

相应的，还有：+=、*=、-=等

python中的条件语句

条件语句是根据条件表达式的值是True/非零还是False/零做出决策，控制代码块的执行。

python中的条件语句中的逻辑判断类型

两个对象之间的关系：==、!=、<、>、>=、<=

注：!=还可以表示成：<>

成员测试：in、not in

python中的断言语句

在没完善一个程序之前，不知道程序在哪里会出错，与其让它在运行时崩溃，不如在出现错误条件时就崩溃，这时候就需要assert断言语句。
断言语句的语法是：

assert expression[,reason]
当判断表达式expression为真时，什么都不做；如果表达式为假，则抛出异常。
assert语句一般用于开发程序时对特定必须满足的条件进行验证，仅当debug为True时有效。当Python脚本以-o选项编译为字节码文件时，assert语句将被移除以提高运行速度。

python中的上下文管理语句

使用with自动关闭资源，可以在代码块执行完毕后还原进入该代码块时的现场。
无论何种原因跳出with块，无论是否发生异常，总能保证文件被正确关闭，资源被正确释放。
with语句的语法如下：

with context_expr[as var]: with块

python中的异常语句

当python检测到一个错误时，解释器就会指出当前流已无法继续执行下去，这时候就出现了异常。异常是指因为程序出错而在正常控制流以外采取的行为。
异常分为两个阶段：第一阶段是引起异常发生的错误；第二阶段是检测并处理阶段。

python中的内置异常

异常类名	描述
Exception	所有异常的基类
NameError	尝试访问一个没有声明的变量
ZeroDivisionError	除数为0
SyntaxError	语法错误
IndexError	索引超出序列范围
KeyError	请求一个不存在的字典关键字
IOError	输入输出错误（比如你要读的文件不存在）
AttributeError	尝试访问未知的对象属性
ValueError	传给函数的参数类型不正确
EOFError	发现一个不期望的

python中的捕获异常

try子句中的代码块放置可能出现异常的语句，except子句中的代码块处理异常。

捕获异常的例子

>>> a_list=['China','America','England','France']
>>> try:
  print a_list[4]
except IndexError:
  print'列表元素的下标越界'

运行结果是：
列表元素的下标越界

引入循环结构，可以实现重复输入字符串序号，直到检测序号不越界而输出相应的字符串。

a_list=['Chian','America','England','France']
print'请输入字符串的序号'
while True:
    n=input()
    try:
        print a_list[n]
    except IndexError:
        print'列表元素的下标越界，请重新输入字符串的序号'
    else:
        break;

运行结果：
请输入字符串的序号
1
America

python中的捕获所有异常

任何情况下都需要执行的语法格式：

try:
    ...
finally:
    ...   #无论如何都会执行