Python基础笔记

[基础部分]

Python 是一种解释型的、面向对象的、带有动态语义的高级程序设计语言。输出方式：print “Hello world”

空值是Python里一个特殊的值，用None表示。

关于除法运算：默认只取整数部分的结果：1/2=0.要得到小数：1.0/2 或者 1.0/2.0

幂（乘方）运算：2 ** 4 = 16 表示 2的4次方。

关于长整型数：普通整数不能大于 2147483647也不能小于 -2147483648 ，否则要加L。虚数：用j或者J表示

变量名可以包括字母、数字、下划线，不能以数字开头（同PHP）。

print 语句 [Python3.0中 print是函数，要写print(42)而不是 print 42 ]：

获取用户输入: input(‘words’);

使用 import 导入模块，用“模块.函数”调用：

使用 “from 模块 import 函数”可以直接使用；也可以 foo=math.sqrt赋值，然后 foo(4)得到平方根。

将Python值 转换为 字符串 的三种方法：str 、 repr 、 反引号(``) 。

在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了。如果要表示多行字符串，可以用'''...''’表示。

以Unicode表示的字符串用u'...'表示，比如：print u’中文’，注意: 不加 u ，中文就不能正常显示。

自定义一个求绝对值的函数：def my_abs(x): if x >= 0: return x else: return -x

return None可以简写为return

从模块导入函数，可以使用：① import module ② from module import function ③ from module import *

还可以在语句末尾增加一个as子句： import math as foobar ; foobar.sqrt(4); ===> 结果是 2.0

也可以为函数提供别名： from math import sqrt as foobar ; foobar(4); ===> 结果是 2.0

一次性给多个变量赋值：x,y,z = 1,2,3

链式赋值，将同一个值赋给多个变量： x = y =somefunction()

如果希望执行普通的除法，在程序前面加上： from __future__ import division

使用 import 导入模块，用“模块.函数”调用： import math; math.floor(32.9);

使用 “from 模块 import 函数”可以直接使用：from math import floor; floor(32.9);

 

[数据类型]

Python中基本的数据结构是“序列”。序列分为6种，最主要的两种类型是“列表”和“元组”,其他的序列：字符串、Unicode字符串、buffer对象、xrange对象。

几乎所有的情况下，列表都可以替代元组；除了 在使用元组作为字典的键，此时因为键不可修改，所以不能使用列表。

对序列的操作:索引（indexing）、分片（sliceing）、加（adding）、乘（multiplying）、计算长度、找出最大元素和最小元素、迭代（对序列中的每个元素重复执行某些操作）。

(1)索引:可以通过索引获取元素。-1表示从右边取值。

(2)分片:获取一定范围内的序列（或者字符串），用冒号(:) 分割start和end的范围，例如 tag[1:6]

(3)分片:更大的步长。例如：每隔2取一个数；每隔3取一个数。

(4)序列相加（连接）:必须是相同类型的序列才能连接在一起，用 + 符号连接。

(5)序列的乘法，用 * 符号连接：

(6)检查一个值是否在序列中用in ，返回布尔。

(7)序列的：长度 len()、最小值min()、最大值max()。

 

列表：

list是一种有序的集合，可以随时添加和删除其中的元素。用[]把list的所有元素都括起来，就是一个list对象。

x = ['Adam', 'Lisa', 'Bart’] 正序打印 L[0]，倒序打印 L[-1]

列表方法这样调用： 对象.方法(参数)

count()方法 统计某个元素在列表中出现的次数： x.count(y)

index()方法 从列表中找出某个值第一个匹配项的索引位置: x.index('value')

append()方法 把新的元素添加到 list 的尾部 x.append(y)

insert()方法 把新元素添加到 list 的指定位置 x.insert(1,'xyz')

pop()方法 删除最后一个元素 x.pop()，删除指定位置的元素 x.pop(1)

remove()方法 移除列表中某个值的第一个匹配项 x.remove('value')

reverse()方法 将列表中的元素翻转 x.reverse()

sort()方法 对列表排序 x.sort()

高级排序compare(x,y): x<y返回负数，x>y返回正数，x=y返回0。

 

元组：

tuple是不可变的集合：

t = ('Adam', 'Lisa', 'Bart')

空tuple：t = ()，单元素tuple,直接使用t = (1)，会输出 1；

Python 规定，单元素 tuple 要多加一个逗号”,"：t = (1,)

基本的元组操作：除了创建和访问之外，没有其他太多操作。

 

字符串：

都是不可变的。字符串格式化的操作符（%）

例如：格式化浮点数，使用如下方式： %.3f

字符串方法：

(1) find方法：在一个较长的字符串中查找子字符串，返回子串所在位置的最左端索引，若没找到则返回-1.

x.find(‘y’, start, end) 表示在start和end之间查找。

(2) join 方法：在队列中添加元素，需要添加的队列元素都必须是字符串。

(3) split方法：分割字符串，和join相反。

(4) lower方法：将字符串转换为小写

(5) replace方法：替换字符串

(6) strip方法：去除两侧的空格。

 

映射：

通过键引用值的数据结构，字典是Python中唯一内建的映射类型。

个人理解：Python中的“字典”就像是PHP中的“数组”，或者“json”，就是一个一个的键值对。

创建字典

phonebook = {'zhang':'111', 'wang':'222', 'zhao':'333'}

也可以用用dict函数建立字典：

item = [('name','rx'),('age',27)]

d = dict(item)

字典的操作，与“序列”很类似：

(1)字典的键不一定是整数类型，可以是任何不可变的类型（比如：浮点型、字符串、元组）

(2)字典可以自动添加（类似PHP的数组）

(3)表达式 k in d(d为字典)查找的是键 而不是值，表达式 v in l(l为列表) 查找的是值 而不是索引。

字典方法:

(1)clear方法：清除字典中所有的项，无返回值。

(2)copy方法：返回一个具有相同 key-value 的新字典。

(3)fromkeys方法：使用给定的key建立新的字典，每个key默认对应的value为None。

(4)get方法：一般情况下，访问字典中不存在的项时会出错，但使用get就不会：

(5)has_key方法：检查字典中是否包含给出的key，返回布尔。表达式 d.has_key(k) 相当于 k in d.

(6)items 和 iteritems：将所有的字典项以列表方式返回，但返回时没有特殊的顺序。

(7)keys 和 iterkeys：keys方法将字典中的键以列表的形式返回，iteritems方法返回针对键的迭代器。

(8)pop方法：获得对应于给定键的值，然后将这个key-value从字典中移除。

(9)popitem方法：弹出列表中的随机的项。

(10)setdefault方法：类似get方法。能够获得与给定键相关联的值，还能在字典中不含有给定键的情况下设定相应的键值。

(11)update方法：利用一个字典项更新另外一个字典。提供的字典中的项会被添加到旧的字典中，若有相同的键则会进行覆盖。

(12)values 和 itervalues：以列表的形式返回字典中的值（itervalues返回值的迭代器）。与返回键的列表不同的是，返回值的列表中可以包含重复的元素。

 

[条件判断和循环]

Python中，用冒号(:) 标识语句块的开始，块中的每一个语句都是缩进的，当回退到和已经闭合的块一样的缩进量时，表示当前块结束。

下列值在布尔类型中都表示false：False、None、0、""、()、[]、{} ，其他的则为true。

使用bool函数可以将其他类型转换为布尔：bool('hello') --> True

if ... else ... elif 语句

x is y : 判断x和y是否是同一个对象，注意和 == 对比：

使用 == 判定两个对象是否相等，使用is判定两个对象是否等同（是否是同一个对象）。

in成员资格运算符：

if 'x' in 'xyz':

print True

else:

print False

且/或/非： and/or/not

三元运算符： a if b else c :如果b为真则返回a，否则返回c。

 

while循环：

判断用户是否输入了名字：

while not name or name.isspace()

for循环

说明：如果能使用for循环，则尽量不要使用while循环。

words = ['a','b','c','d']

for x in words:

print x

range的使用（类似于分片）：

range(0.3) --> [0,1,2]

循环遍历字典元素:

d = {'x':1,'y':2,'z':3}

for key in d:

print key,'--->',d[key]

跳出循环:break 和 continue

另外三个语句：pass、 del、 exec

(1)Python中空代码块是非法的，所以需要在语句块中加上pass：

(2)del语句：移除对象。

(3)exec：执行一个字符串。

(4)eval：用于“求值”—— 会计算Python表达式并且返回结果值。

 

[抽象]

内建的callable函数可以判断函数是否可调用

定义函数：def语句，可以设置默认值，可以没有return：

def test(name='default',age=20):

return 'Hello' + name + age

print test('renxing',29)

 

函数的参数中定义元组，需要加*号：

def test(title,*params):

print title

print params

test('hello:','a','b','c')

 

函数的参数中定义字典，加**号：

def test(**params):

print params

test(x=1,y=2,z=3)

结果：{'y': 2, 'x': 1, 'z': 3}

 

 

作用域——内建的vars函数

函数内的变量称为局部变量，全局变量用global表示。

函数可以嵌套：

def foo():

def bar():

print “Hello_world”

 

常用函数整理：

pow(num) 乘方

abs(num) 绝对值

round(num) 四舍五入

help() 提供交互式帮助

input(prompt) 获取用户输入

raw_input(prompt) 获取用户输入，返回的类型是 字符串

repr(object) 返回值的字符串表示形式

str(object) 将值转换为字符串

 

[类和对象]

面向对象的三大特性：继承、封装、多态。

创建类:

class Person:

def setName(self,name):

self.name = name

def getName(self):

return self.name

调用：

foo = Person()

foo.setName('renxing')

print foo.getName()

 

Python并不直接支持私有方式，为了让方法或者特性变为私有（从外部无法访问），只要在函数名前面加上双下划线即可：

class Person:

def __getName():

print 'private function'

 

如果要查看一个类是否是另一个类的子类，使用内建的 issubclass 函数

如果想要知道已知类的基类，可以使用它的特殊特性： __bases__

同样，还能使用 isinstance 方法检查一个对象是否是一个类的实例

如果只想知道一个对象属于哪个类，可以使用 __class__ 特性

__bases__ 复数形式说明了 它的基类可能会多于一个，称为：多重继承。

 

接口和内省：

让对象符合当前的接口，也就是实现当前的方法

与 getattr 相对应的函数是： setattr，用来设置对象的特性

如果要查看对象内所有存储的值，可以使用 __dict__ 特性。

 

魔术方法： __future__ 、__init__ 、 __iter__

构造方法： __init__

析构方法： __del__

 

序列和映射 是对象的集合。如果对象是不可变的，那么需要使用两个魔法方法，如果是可变的则需要使用4个。

__len__(self): 返回集合中所含项目的数量。

__getitem__(self,key): 返回与所给键对应的值。

__setitem__(self,key,value): 按一定的方式存储和key相关的value（只能为可以修改的对象定义这个方法）。

__delitem__(self,key): 此方法在对一部分对象使用del语句时被调用，同时必须删除和元素相关的键。

 

当子类化一个内建类型（如list）的时候，就会间接地将object子类化，就会自动成为新式类，可以使用像super函数这样的特性了。

访问器方法——能够使用getHeight、setHeight这样的名字重绑定一些特性。

 

property 函数

静态方法： @staticmethod ；类成员方法： @classmethod

 

迭代器 __iter__，

具有next方法，不需要任何参数。

(1) 一个实现了 __iter__ 方法饿的对象是可迭代的，一个实现了next方法的对象是迭代器。

(2) 内建函数 iter 可以从可迭代的对象中获得迭代器。

(3) 使用list构造方法可以显式地将迭代器转化为列表

生成器是一种用普通的函数语法定义的迭代器。生成器是一个包含yield关键字的函数。

 

包 ：

基本上就是另外一类模块，而且能包含其他模块。当模块存储在文件中时（扩展名.py），包 就是模块所在的目录。 __init__py文件。

例如有个名为 constants的包，文件 constant/__init__.py包括语句 PI=3.14,那么可以：

import constants;

print constants.PI;

__all__ 变量：

help() 函数：例如 help(copy);

标准库: sys 模块能够访问与Python解释器联系紧密的变量和函数。使用方法：sys.argv;sys.exit;

os模块提供了访问多个操作系统服务的功能。os和它的子模块os.path还包括一些用于检查、构造、删除目录和文件的函数。

fileinput 模块——能够遍历文本文件的所有行。

 

[集合]

使用set创建集合：

set(range(5)) --> set([0,1,2,3,4])

集合元素是无顺序的：

set(['a','b','c']) --> set(['c','a','b'])

计算两个集合的并集，使用union方法，或者 | 运算符。

 

[堆]

堆 是“优先队列”的一种，使用优先队列能够以任意顺序增加对象，并且能在任何时间找到最小的元素。

Python中只有一个包含一些堆操作函数 的模块，叫做 heapq，包含6个函数。

（1）heappush 函数 用于增加堆的项，只能用于通过各种堆函数建立的列表中。

（2）heappop 函数 弹出最小的元素。

（3）heapify 函数 使用任意列表作为参数，并且通过尽可能少的移位操作，将其转换为合法的堆。

（4）heapreplace 函数 弹出堆的最小元素，并且将新元素推入，这样比 调用heappop之后再调用heappush更高效。

 

[双端队列] deque

双端队列——在需要按照元素增加的顺序来移除元素时非常有用。

双端队列通过可迭代对象（比如集合）创建。

 

[time]

time 模块所包含的函数能够实现以下功能：

获得当前时间、操作时间和日期、从字符串读取时间以及格式化时间为字符串。

time.asctime() 将当前时间格式化为字符串

 

[random]

random模块包括返回随机数的函数。

 

[shelve]

shelve是一额简单的数据存储方案，他只有一个函数就是open()，

这个函数接收一个参数就是文件名，然后返回一个shelf对象，

你可以用他来存储东西，就可以简单的把他当作一个字典，

当你存储完毕的时候，就调用close函数来关闭。

 

【文件和素材】

打开文件用open函数，参数'rb'可以用来读取一个二进制文件。

使用f.write(string) 追加写入，使用 f.read() 读取，使用f.close() 关闭文件。

f.readlines() 读取一个文件的所有行，f.readline() 读取一行。

按行操作——在while循环中使用readline。

用readlines 迭代行：

使用 fileinput 实现懒惰行迭代：

可以对文件迭代器执行和普通迭代器相同的操作。比如将它们转换为字符串列表，使用 list(open(filename)); 这样和使用readlines 效果一样。

 

【图形用户界面 GUI 】

最成熟的跨平台Python GUI工具包—— wxPython

 

【安装MySQL-python】

要想使python可以操作mysql 就需要MySQL-python驱动，它是python 操作mysql必不可少的模块。

检查MySQLdb 模块是否可以正常导入：import MySQLdb

python 操作mysql数据库基础：

#coding=utf-8

import MySQLdb

 

#Connect() 方法用于创建数据库的连接，里面可以指定参数：用户名，密码，主机等信息。

#这只是连接到了数据库，要想操作数据库需要创建游标。

conn= MySQLdb.connect(

host='localhost',

port = 3306,

user='root',

passwd='',

db ='rxpython',

)

 

#通过获取到的数据库连接conn下的cursor()方法来创建游标。

#通过游标cur 操作execute()方法可以写入纯sql语句。

#通过execute()方法中写如sql语句来对数据进行操作。

cur = conn.cursor()

 

#创建数据表

cur.execute("create table student(id int ,name varchar(20),class varchar(30),age varchar(10))")

#插入一条数据

cur.execute("insert into student values('2','Tom','3 year 2 class','9')")

#修改查询条件的数据

cur.execute("update student set class='3 year 1 class' where name = 'Tom'")

#删除查询条件的数据

cur.execute("delete from student where age='9'")

#关闭游标

cur.close()

#提交事务

conn.commit()

#关闭数据库连接

conn.close()

 

一次性向数据表中插入多条值：

executemany() 方法可以一次插入多条值，执行单条sql语句,但是重复执行参数列表里的参数,返回值为受影响的行数。

sqli = "insert into student values(%s,%s,%s,%s)"

cur.executemany(sqli,[

('11','zhang','aaaaa','1001'),

('12','wang','bbbbb','1002'),

('13','li','ccccc','1003'),

('14','zhao','ddddd','1004'),

])

 

查询语句：

（1）aa=cur.execute("select * from student"); print aa;

----> 获得的只是表中有多少条数据。

（2）fetchone() 方法可以获得表中的数据，可是每执行一次，游标会从表中的第一条数据移动到下一条数据的位置。

scroll(0,'absolute') 方法可以将游标定位到表中的第一条数据。

（3）获得表中的多条数据并打印出来，使用 fetchmany()