Python极速入门教程(主要提供与C/C++语法不同点)
一：列表、元组和字典
Python有6中中内建序列：列表、元组、字符串、unicode字符串、buffer对象、xrange对象。
1 通用序列操作：
（1）都可以通过索引访问
（2）分片：通过冒号相隔的两个索引实现Test[:2],Test[-3:-1],同时也可以设置步长，默认为1但是可以显示设置 Test[1:10:3]步长为3
（3）序列相加：[1,2,3,4]+[1,2]=[1,2,3,4,1,2]
（4）序列乘法：[1]*5=[1,1,1,1,1]，创建为空的序列[None]*10;
（5）成员资格：in的使用：permission=“hello” hin permission True
（6）长度、最小值和最大值：
内建函数len、min和max实现
2 列表
(1)因为字符串是序列我们可以使用list将其转换成列表
>>>list（‘hello’）
[‘h’,’e’,’l’,’l’,’o’]
（2）删除元素
>>>names=[‘Alice’，‘Beth’]
>>>del name[1]
（3） 可以进行分片赋值
（4）列表方法：
append(x):列表末尾追加新元素
count(x):统计x在列表中出现的次数
extend(x[]):一次追加多个值
Index：不存在就会引发异常，获取索引
Insert(index,data):指定位置插入
Pop
Remove（）：移除第一个匹配项
Reverse():反转序列
Sort():对列表排序或者使用sorted函数sorted(序列)
（5）高级排序自定义函数compare并将其传入sort中便可自定义排序规则
3 元组：不可变序列
用逗号隔开自动创建元组
>>1,2,3,4,5
(1,2.3,4,5)
对于只有一个值形成元组记得加逗号，
>>>12,
(12,)
>>>3*(40+2,)
(42,42,42)
(1) tuple 函数(与list函数基本一样：序列做参数转换为元组
>>>tuple([1,2,3])
(1,2,3)
元组的用途：
（1）元组可以在映射中当做键使用而列表则不行
（2）元组做为很多内建函数和方法的返回值存在
4 字典
（1）创建和使用字典
通过dict函数创建：
>>>item=[(‘name’,’gumby’),(‘age’,42)]
>>>d=dict(item)
也可以通过：关键参数
d=dict(name=’guby’,age=42)
(2)基本的一些操作
len(d) :f返回数量
d[k]:返回关联到键k的值
d[k]=v:将值关联到键上
Del d[k]删除键为k的项
K in d 检查d中是否有k的项
（3）字典在字符串格式化的使用
>>>pthonenumber={‘lgf’:’123456’,’alice’:’45454545’}
>>>’lgf number is %(lgf)s’% phonenumber
(4) 字典的方法：
clear：清除所有项 跟x关联的也会被清除
Copy：返回具有相同键值的新字典
Fromkeys：给定的键建立新的字典，每个键默认为None
>>>{}.fromkyes[‘name’,’age’]
Get:获取某个键的值不会产生异常不存在是返回None d.get(‘name’)
Has_key:检测字典是否含有每个键 python3.0中不在使用
Items和iteritems：items将字典项以列表返回没有特殊顺序
>>>d={‘url’:’www.baidu.com.’,’title’:’python’}
>>>d.items()
>>>[(‘title’,’python’)，（’url‘,’www.baidu.com’）]
Iteritems会返回一个列表的迭代器
Kyes和iterkyes：将字典的键以列表形式返回
Pop：获取对应于给定键的值然后将这个键值从字典中移除
Popitem:随机弹出一项若想一个一个出来这个方法很好
Setdefault:能够获取给定键的关联值，setdefault还可以对含有给定键值的情况下设定相应的键值
d={’name‘：’lgf‘}
d.setdefault(‘name’,’lgff’)
Update:用一个字典项跟新另一字典
d={‘url’:’www.topsec.com’,’title’:’python’}
x={‘title’:’topsec’}
d.update(x) 若d存在x项进行覆盖，否则添加
values和itervalues：返回字典中的值
二：控制语句
1 轻量级循环-列表推倒式
>>[x*x for x in range(10) if x%3==0]
[0,9,36,81]
也可以增加for循环部分：
>>[(x,y) for x in range(3) for y in range(3)]
2 pass ,del和exec三人行
(1)pass 什么也不做，可以作为测试分支的占位符
(2)del:删除对象 x=1 del x (不能再使用x并不释放内存，内存的释放交给Python解释器)同时我们也可以将不用的对象赋值为None让解释器删除）
(3)exec和eval执行和求值字符串
exec“print ‘hello world!’”一般不这样用
Exec最有用的地方是可以动态的创建代码字符串同时为了安全起见可以增加一个字典
>> formmath import sqrt
>>scope={}
>> exec ‘sqrt=1’inscope
>> sqrt(4)
eval 用于求值会计算Python表达式(以字符串形式书写)，并且返回结果值
>>eval(raw_input(“enter an arithmetic expression:”))
Enter anarithmetic expression: 6*18*2
42
一些新函数：
chr(n):返回ascii所代表的字符chr(49)=‘1’;
Ord(c):和chr()相反
Zip(seq1,seq2....)：创造使用与并行迭代的新序列
三 抽象之函数
1 函数创建
可以用callable()函数(python 3.0中使用hasattr(func,_call_))可以判断函数是否可以被调用
>>y=math.sqrt
>>callable(y)
True
---------------->定义函数
def hello(name):
return‘hello’+name+’!’
---------------->记录函数
------>在函数的开头写下字符串它就作为函数的一部分存储称为文档字符串
def square(x):
‘Calcylatesthe square of the number x’
returnx*x
文档字符串可以这样访问：
>>square._doc_
2 函数参数
def hello(greeting=”hello”,name=”world”):
printgreeting+name
---->如果有很多想hello这种函数（hello(name,greeting)）当我们调用时如果不指明参数就会调用乱所有我们要指明参数调用
>>hello(greeting=”hello,”name=”lgf”)
3 参数收集
用户可以给函数提供任意多的参数看一下函数定义
def print_params(*params):
print params
我们传参进行函数调用：
>>>print_params(1,2,3)
>>>(1,2,3)
结果打印出了元组，所以我们通过将参数定义为*params可以对参数进行收集（同时也可以和普通参数一起使用def print_params2(title,*params)）
还有一种情况是通过字典进行收集参数的此时的函数定义如下：
def print_params3(**params):
printparams
>>>print_params3(x=1,y=2,z=3)
>>>{‘z’:3,’x’:1,’y’:2}
--------------------------------------------->本节运用小列子
def store(data,*full_names):
forfull_name in full_names:
names=full_name.split()
if len(names)==2:
names.insrt(1,'')
labels='first'.'middle'.'last'
for label.name in zip(labels,names):
people=lookup(data,label,name)
if people:
people.append(full_name)
else:
data[label][name]=[full_name]
--------------->>
调用函数：
>>>store(d,’luke skywalker’,’anakin skywalker’)
>>>lopkup(d,’last’,’skywalker’)
[‘luke skywalker’,’anakin skywalker’]
4 参数收集的反转过程
def add(x,y):return x+y
params=(1,2)
>>>add(*params)
四 与类相关
1 类的定义
Python的定义形式及相关使用：
_meraclass_=type
class Person:
defsetName(self,name):
self.name=name
defgetname(self):
return self.name
defgreet(self):
print "hello,world! i'm %s"%(self.name)
类的使用：
p1=Person()
p1.setName('lgf')
p1.greet()
Python不直接支持私有方式而是靠程序员自己把握在外部进行特性的修改的时机。为了让方法或者属性变成私有的化只要在他的名字前加上双下划线__即可
def __inaccessible(self):
print …..
但是这只是一中实现形式，我们可以通过类名和单项下划线访问：
s._Secretive__inaccessible()
2 命名空间
在python中类可以作为命名空间，对变量起到限制作用，同时类中不一定只有方法和属性
Class C:
Print‘class bengin with c’
3 继承(超类和子类)
class Filter:
def init(self):
self.blocked=[]
def filter(self,sequence):
return[x for x in sequence if x not inself.blocked]
class SPMAFilter(Filter):#声明子类
def init(self):#重写init方法
self.blocked=[‘SPMA’]
通过issubclass()函数来检测一个类是不是另一个类的子类：isssubclass(SPAMFilter,Filter)
Isinstance(),检查一个对象是否是一个类的实例(同时可以使用属性_class_对于python3.x以后版本可以使用 type(s))
如果想知道益智类的基类可以直接使用它的特殊特性_bases_
多个父类的继承形式：
class C(A,B):
…………..
本节涉及到的其他方法：
hasattr(class的实例,’属性方法’),检测实例是否有某属性方法，callable(getattr(对象，属性方法，None))检测属性方法是否能被调用
在python 3.x以后通常使用hasattr(x,’_call_’)代替callable方法
getattr()函数允许提供默认值，setattr用来设置对象特性：
>>>setattr(p1,’name’,’lgf’)
>>>p1.name
Lgf
random.choice(sequence)从非空序列中随机选择元素
五 python之异常
1 异常的引发raise 语句
>>>raiseException(“hyperdriver overload！”)
使用 dir(exceptions)可以查看python内建异常类
常见的有以下：
2创建自己的异常类
确保自己的异常类继承于基类或者其他内建异常类
class SomeCustomException(Exception):pass
3 异常的捕捉
try/except结构
try:
x=raw_input(enter first number:)
y=raw_input(enter second number:)
print x/y
except ZeroDivisionError:
print “second number cant bezero!”
except TypeError:
print “that’s a number was it?” ####不止一个异常（except:这样可以捕获所有异常）
同时我们也可以通过将要捕获的异常以元组形式列出：
except(ZeroDivisionError,TypeError,…….):
print “some errors …..”
防止异常传递导致程序down掉可以通过加入屏蔽机制
class Calculator:
muffld=False
defcalc(self,expr):
try:
return eval(expr)
except ZeroDivisionError:
If self.muffled:
print ‘division by zero is illegal’
else:
raise
4 捕捉对象
一般是想让程序继续运行又想把错误进行记录
except(ZeorDivisionError,TypeError).e####python 3.x 中写成 as e
print e
为except 提供else分分支
while True:
try:
x=raw_input()
y=….
except exception.e:
print …..
else:
break
finally子句在异常中肯定会被执行（一般要做一些异常清理工作
warnings.filterwarnings(action….)过滤警告
-------156
六魔法方法、属性、迭代器
1 在python中创建构造方法只需要将init方法的名字从简单的init修改为魔法版本_init_即可
在子类中调用父类的方法可以通过(父类.方法(self))在python 3.x中可以通过super函数实现（super(子类，self)）
2 成员访问
序列和映射是对象的集合，如果对象不可变需要2个魔法方法如果可变则需要四个
(1) _len_(self)返回集合中所含项目的数量
(2) _getitem_(self,key)返回与所给键对应的值
(3) _setitem_(self,key,value) 按一定的方式存储和key相关的value，只能为可修饰的对象定义该方法
(4) _delitem_(self,key)这个方法在对一部分对象使用del语句时被调用，同时必须删除和元素相关的键 为可修改对象定义的
3 python中的属性机制
使用property实现
__metaclass__type
class Rectangle:
def __init__(self):
self.width=0
self.height=0
def setSize(self,size):
self.width,self.height=size
def getsize(self):
returnself.width,self.height
size=property(getsize,setsize)#设置属性
>>>r.size
(10,5)
4 有关静态方法和类成员方法
早期静态方法和类成员方法的实现：
def semth():
print ‘this is static method’
smeth=staticmethod(smeth)
def cmeth(cls):
print ‘this is a class method of cls’
cmeth=classmethods(cmeth)
python 2.4以后：
@staticmethod +声明方法
@classmethod+声明的方法
5 迭代器
不只是序列和字典可以迭代，其他的实现了__iter__方法的对象也可进行相关的迭代操作
在p3.x中迭代器对象应该实现__next__方法，之前版本实现next方法：
实现含有迭代器的fibs
class fibs:
def __init__(self):
self.a=0
self.b=1
def next(self):
self.a,self.b=self.b,self.a+self.b
def __iter__(self):
return self
内建函数iter可以从可迭代的对象中获取迭代器
it=iter([1,2,3])
>>>it.next()
1
6 生成器的一个例子：
def flatten(nested):
for sublist in nested:
for element in sublist:
yield element ##含有yield语句的函数成为生成器每次产生多个值
在生成器上迭代
>>>nested=[[1,2,3,4],[5,6]]
>>>for num in flatten(nested):
print num
1 2 3 4 5 6
或者使用list(flatten(nested))
使用递归生成器处理多层次嵌套：
def flatten(nested):
try:
# 不要迭代类似字符串的对象
try： nested+‘’
except TypeError: pass
else:raise TypeError
for sublist in nested:
for element in flatten(sublist):
yield element
except TypeError:
yield nested
>>>list(flatten([[[1],2,3],[2,3],4]))字符串的对象不会引发TypeError异常所以nested不能是字符串类型的
总结：生成器在被调用是并不会执行函数中的代码而是返回一个迭代器，return语句意味生成器要停止执行，yield意味着应该生成一个值
python 2.5以后开始为生成器提供新属性，可以使生成器和外部进行交流：
（1） 外部作用于访问生成器的send方法就像访问next方法一样，但前者需要一个参数（发送的消息）
（2） 在内部挂起生成器yield现在则作为表达式而不是语句使用，但生成器重新运行时yield返回一个值也就是外部send方法发送的值，如果next方法被使用，那么yield方法返回none（可以将none作为参数调用，对刚刚启动的生成器使用send方法）
def repeater(value):
while True:
new=(yield value)
if new is not None:value=new
>>>r=repeater(42)
>>>r.next()
42
>>>r.send(“hello”)
hello
monimo
模拟生成器：
python文件和素材操作
1 有关open函数的说明，第一个参数文件路径，第二个mod，第三个参数有关缓冲区
第三个参数说明：
0:无缓冲
1：有缓冲flush和close才会到处读写盘
>1:缓冲区大小
-1：默认缓冲区大小
其他类似C++操作
2 有关管道
cat somefile.txt|python somescritp.py|sort
管道就是将一个命令的标准输出和下一个命令的标准输入连接
3 确保文件被关闭的写法：
# open your filehere
try:
# wirte data to file
finally:
file.close()
python 2.5之前(需要导入：from__future__ import with_statement)
with open(“somefile.txt”)as somefile:
do_something(somefile)
之后直接使用
4 读取文件所有内容
read迭代每个字符：
f=open(filename)
for char in f.read():
#处理
f.close()
readlines迭代
for line inf.readlines();
懒惰行迭代 fileinput
fileinput包含打开文件函数只需要传递文件名
import fileinput
for line infileinput.input(filename):
process(line)
5 文件迭代器
f=open(filename) #for line in open(filename)---------sys.stdin也是可迭代的
for line in f:
#处理
f.close()
八 python充电时刻
1 有关python模块
开发一个简单的模块(hello.py)
假如程序的保存位置C;\python(windows下)接着要告诉解释器在哪儿寻找模块（以window为例）
>>>import sys
>>>sys.path.append(‘c:/python’)#在linux下记得使用完整路径
现在可以导入模块了(导入多次和一次的效果一样)
>>>import hello
hello world!
为了区分导入程序是为运行还是作为导入其他程序我们可以使用_name_（在主程序中包括解释器中变量__name__的值是__main__而在导入模块中这个值被设定为模块的名字）
>>>hello.__name__
Hello
使用条件测试代码的模块：
#hello4.py
Def hello():
Print ‘Helloworld!’
Def test():
Hello()
If __name__==’__main__:’
test()
再次导入模块
>>>import hello4
>>>hello4.hello()
Hello world!
我们可以看到作为模板导入时就像普通模板一样，将他作为程序运行hello函数会被调用，同时也可以运行测试代码
前边的例子中我们通过使用sys.path设置了库目录，但是理想情况下sys.path本身就应该包含正确的库目录，我们可以通过两种方法：一是将模块放入合适的位置二是告诉解释器在哪儿寻找需要的模块
（1）放入正确的位置:
只需要找出python解释器从哪儿查找模块，然后将你自己的文件放置到哪儿
可以使用以下命令查看
>>>importsys.pprint
>>>pprint.pprint(sys.path)
一般放入site_packages最佳
（2）告诉解释器在哪儿寻找这就需要设置系统的环境变量了即在环境变量PYTHONPATH中设置模块所在目录
2 有关包
为了更好的组织好模块，你可以将他们分组为package，当模块存储在文件夹中时，包就是模块所在的目录，为了让python将其作为package对待它必须包含一个命名为__init__py 的文件（模块）
简单的包布局：
3 对模块做的一些探究
（1）使用dir查看模块包含的内容（一般使用列表推导式只展示有用的信息：[ n for n in dir(copy) if not n.startwith(‘_’)]
（2）__all__变量
定义了模块的公有接口 form copy(某个模块) import * 只能导出__all__定义的接口，如果要导出没被__all__定义的接口就要显示的导出比如：
Importcopy
Copy.A
或者使用：from copy import A
(3) help 获取帮助
>>>help(copy.copy)
(4) 文档
>>>print range.__doc__
(5)源代码
一种方法是检查sys.path自己找
第二种：使用__file__
>>>print copy.__file__
C:\python\lib\copy.py
4 常见标准库
Python OS模块说明
python编程时，经常和文件、目录打交道，这是就离不了os模块。os模块包含普遍的操作系统功能，与具体的平台无关。以下列举常用的命令
1. os.name()——判断现在正在实用的平台，Windows 返回 ‘nt'; Linux 返回’posix'
2. os.getcwd()——得到当前工作的目录。
3. os.listdir()——指定所有目录下所有的文件和目录名。例：
以列表的形式全部列举出来，其中没有区分目录和文件。
4. os.remove()——删除指定文件
5. os.rmdir()——删除指定目录
6. os.mkdir()——创建目录
注意：这样只能建立一层，要想递归建立可用：os.makedirs()
7. os.path.isfile()——判断指定对象是否为文件。是返回True,否则False
8. os.path.isdir()——判断指定对象是否为目录。是True,否则False。例： 9. os.path.exists()——检验指定的对象是否存在。是True,否则False.例：
10. os.path.split()——返回路径的目录和文件名。例：
此处只是把前后两部分分开而已。就是找最后一个'/'。看例子：
11. os.getcwd()——获得当前工作的目录（get current workdir)
12. os.system()——执行shell命令。例：
注意：此处运行shell命令时，如果要调用python之前的变量，可以用如下方式：
var=123
os.environ['var']=str(var) //注意此处[]内得是 “字符串”
os.system('echo $var')
13. os.chdir()——改变目录到指定目录
14. os.path.getsize()——获得文件的大小，如果为目录，返回0
15. os.path.abspath()——获得绝对路径。
16. os.path.join(path, name)——连接目录和文件名。
17.os.path.basename(path)——返回文件名
18. os.path.dirname(path)——返回文件路径
19. 获得程序所在的实际目录
import os
import sys
if__name__ == "__main__":
print os.path.realpath(sys.argv[0])
print os.path.split(os.path.realpath(sys.argv[0]))
printos.path.split(os.path.realpath(sys.argv[0]))[0]
执行结果
| 1 2 3 | /home/jihite/ftp/del.py ('/home/jihite/ftp', 'del.py') /home/jihite/ftp |
细节——os.path.spilit()把目录和文件区分开
| 1 2 3 4 5 | >>> import os >>> os.path.split("a/b/c/d") ('a/b/c', 'd') >>> os.path.split("a/b/c/d/") ('a/b/c/d', '') |
1425
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
