python基础教程1

时间:2022-07-31 18:41:05

python作为一种编程语言,诞生于1990年左右,算是一门比较年轻的语言(也算是90后吧),它是面向对象的,但不同于JAVA\C#那么严格要求一切皆对象,更接近于C++,是面向过程和面向对象的结合;它是解释型语言,但是也可以编译成 .pyc 跨平台的字节码文件(由类似于JAVA 的 .class 文件,由python虚拟机来执行),.pyc 文件有几个好处,一是可以简单的隐藏源码,二是提高载入速度,三是跨平台。

编译:python -m py_compile test.py 会生成 test.pyc 文件

python -O -m py_compile test.py 会生成 test.pyo 文件,就是 .pyc 的简单优化。

批量编译一个文件夹中所有的 .py 文件,可以使用 python -m compileall dirname

 

在 windows 下执行 .py/.pyc 文件时,默认会有闪现一个dos窗口,如果不要这个窗口,可以将 .py/.pyc 的文件后缀改成 .pyw 即可。

其实这种改动,并没有本质上的区别,真正的区别在于 .py/.pyc 文件默认调用 python.exe 来执行,而 .pyw 文件默认调用 pythonw.exe 执行,仅此而已。(w 表示窗口)

 

python 也有动态链接库,如 linux 下的 .so 或 windows 下的 .dll。

 

可以通过 python -m pdb test.py 来调试python程序,方法基本与gdb相同。

http://www.cnblogs.com/mindsbook/archive/2009/07/19/pdb.html

 

python 的用武之地

由于本人并非python开发者,所知有限,欢迎补充。

1、服务器维护脚本,比 shell 脚本可强大得多。

2、服务端程序

3、胶水程序,如游戏开发中的任务脚本等

4、WEB开发,如 django \web.py 等

5、手游开发,如 cocos-2dx 就有 python 版。

6、桌面应用开发,如 wxpython等等。

7、云,如 openstack

 

 

优点:

1、代码风格优雅(见仁见智了)

2、一次编写,随处运行(这句话不是JAVA的特权)

3、即写即运行

4、由于胶水特性,性能要求高的地方可以使用c/c++来编写。

5、简单易学,所以接下来,不必紧张,请愉快的学习它吧

6、开源 

7、庞大的标准库

 

缺点:

1、tab 与 空格带来的噩梦

2、性能,不过可以通过胶水特性弥补

3、python2 与 3之间的抉择

 

python脚本的第一行一般是特定的,使用 #! 开始,其后紧跟着机器python解释器的路径。在一些LINUX系统上,为了避免硬编码 python 解释器的路径,也可以这样写: #!/usr/bin/env python

 

通过 import 可以导入一个模块,如果那个模块可执行,则执行此模块,但是,多次 import 同个模块,只会执行一次,因为导入是一个开销很大的工作,所以第一次导入时将其编译成字节码,并且运行代码。如果希望可以再次运行模块,可以使用 

import imp
import hello
imp.reload(hello)

python2.6~2.7中,reload 是内置函数,不需要导入,即这样也是可以的:

import hello
reload(hello)

reload函数的返回值是一个python模块对象。

此外,还有一种方法,借助于 exec 函数:

exec(open('hello.py').read())

但这种方法不会导入模块,而是类似于宏替换,把文件中代码粘贴进来一样,如果变量有重名,会造成覆盖。

 

关于 from ... import ...

from 后跟模块名,即可当模块的文件名或文件夹名(文件夹中包括 __init__.py 文件),而 import 后跟模块中的属性名或方法名等。通过 dir(模块名) 可以返回模块中所有的可用的变量名列表

 

IDE

交互式解释器:windows\linux

源码执行:windows\linux

 

与 perl\php\lua\ruby 的对比

最近的语言使用排行榜。

 

python是蟒蛇的意思,如华蟒的由来。

 

不必紧张,请保持愉快,python是一门简单且功能强大的语言。

 

弱类型,但是大小写敏感。

int   long  float  str  bool

字符串是不可变的

 

注释

 

#!/usr/bin/python
#
coding:utf-8

chmod +x test.py

 

分号的用武之地:

python可以不使用分号,唯一必须要使用分号的场所为将多行语句写在同一行的时候,如:

i=3;j=4

 

但推荐一行只写一个语句。将多行写成一行是不被推荐的,但有时却需要把一行写成多行,则需要使用行连接符号 \,如:

print \
i

 

另外,列表、元组可以不需要行连接符号,即可拆成多行书写,如:

mytuple=(3,
4,5,)

 

转义符 \

 

同一层次的语句必须要有相同的缩进。

不要混用制表符和空格来缩进。

SyntaxError: invalid syntax

 

int/int == int,如 3/2 的结果是1,同 c/c++,如果要得到浮点结果,则两数字至少要有一个是浮点数,如 3.0/2 或 3/2.0 即可。也可以 from __future__ import division ,或以 python -Qnew 的方式启动python交互解释器。

 

关于 import 与 include

 

str 与 repr(``)

input 与 raw_input

原始字符串 r

 

 

 

------------------------------------------------

序列和映射:

列表类似于其它语言中动态可变的数组,如 c++的vector,java的 arraylist ,索引也是从0开始,但不同的是,python的列表索引还可以从反向开始,最后一个元素为-1,倒数第二个为-2……

六种序列:列表、元组、字符串、Unicode字符串、buffer对象和 xrange对象。

元组用作配置文件的情况非常常见。

通用序列操作:

分片操作,如果熟知 go 语言,会有助于理解。

 

字符串是不可变的,更类似于 tuple。

格式化字符串,%s,%d,%f,%%

模板字符串

print 'ab','cd'    会输出 ab cd,中间会自带空格,如果不需要空格  print 'ab','\bcd' 即可,或 print 'ab'+'cd'

 

 

 

i = int()   --> i = 0

b = bool()   --> b = False

 

强制类型转换

 

str\unicode\basestring

print isinstance('a',basestring)  仅适用于 str 和 unicode

 

下面不仅适用于str和unicode,且适用于 UserString ,不过比较慢

def isStringLike(obj):
try:obj+''
except:return False
else: return True

print isStringLike(3)

 

 

 

闭包:

http://blog.csdn.net/marty_fu/article/details/7679297

 

 

dict的 copy 与 deepcopy

 

 

print 语句默认会在输出信息后加上换行符,如果不需要换行,则可以在行尾加上一个逗号,如:

print 'hello,',
print 'world'

 

序列解包:

x,y,z = 1,2,3

x,y = y,x

values = 1,2,3

x,y,z = values

 

 

FALSE:

False/None/0/''/()/[]/{}

比较运算符可以连在一起使用,如 0<age<100

is / is not

and / or 代替 &&/|| ,短路逻辑。没有 & / | 的非短路版本。

 

assert

 

没有类C语言的for循环语句,只有 for ... in 循环,类似于其它语言的 foreach

 

zip 并行迭代。

编号迭代。

翻转 reversed、排序迭代 sorted。

 

循环:while,for,列表推导式

 

其它语言用一个分号表示空语句,python使用 pass

 

exec/eval

命名空间:http://www.cnblogs.com/windlaughing/archive/2013/05/26/3100362.html

 

return 返回None,一般用来表示函数结束

 

默认参数传递是值传递,参数如果是列表,在函数内部操作列表索引,就可达到引用传递的效果,(但如果想整个给列表赋新值,也是不可以的。貌似传进来的参数,不能直接做为左值,否则就是新的变量)如:

def fun(lt):
lt[0]
=3

mylt
= [1,2,3,4]
fun(mylt)
print mylt

 

所以如果想改变参数,可以把值放在列表中。

 

关键字参数和默认值

 

可变参数 */**,前者用元组,表示可变的位置参数,jj后者用字典,表示可变的关键字参数

 

globals()["i"]  来引用全局变量 i

kkk

 

一些有意思的函数:

map/filter/reduce/sum/apply

 

关于 Unicode / utf-8 / ascii 编码:

http://blog.renren.com/share/68464/3096404244

http://wenku.baidu.com/link?url=2EE55MZiNreqM_fdh44k7o8fKweZ1GhPzotnL3nPRXytXJsXJhzkAOY91zUxAJZiVtj3Rrao6E7d-xnIz_owai7sx24L7KgJK1X52P-Rw1_

http://blog.163.com/longsu2010@yeah/blog/static/173612348201173115733728/

 

import types

dir(types) 可以查看所有类型

import exceptions

dir(exceptions)  可以查看所有异常

dir(dict) 可以查看所有字典方法与属性

help(dict)  可以查看所有字典方法 (详细)

help(dict.pop)  可以查看指定方法或属性

 

x,y,z = 1,2,3

这种赋值称为多元赋值,左边当作元组,右边也当作元组。等同于 (x,y,z) = (1,2,3)

 

面向对象:

class A(object):
count
= 0

def __init__(self,name):
self.name
= name
self.
__class__.count += 1
print '__init__'
print 'count:',self.__class__.count

def __del__(self):
print '__del__'
self.
__class__.count -= 1

def msg(self):
print self.name

@staticmethod
def get_count1():
print 'staticmethod:',A.count

@classmethod
def get_count2(cls):
print 'classmethod:',cls.count

class B(A):
def __init__(self,name,age):
super(self.
__class__,self).__init__(name)
self.age
= age

def msg(self):
print self.name,self.age

a1
= A('a1')
a1.msg()
del a1
a2
= A('a2')
a2.msg()
print '----------------'
b1
= B('b1',18)
b1.msg()
A.get_count2()
A.get_count2()

@classmethod 的第一个参数是 cls,因此可以访问类变量,或是用作类工厂,而 @staticmethod 除了自身代码是位于类里面之外,对类的情况一无所知;@staticmethod 只适用于不想定义全局函数的情况。两者能做的事几乎一样,区别是更明晰的暴露使用意图,为了有更好的编程风格。

 

新式类和旧式类

python的新式类是2.2版本引进来的,我们可以将之前的类叫做经典类或者旧类。

为什么要在2.2中引进new style class呢?官方给的解释是:

为了统一类(class)和类型(type)。

在2.2之前,比如2.1版本中,类和类型是不同的,如a是ClassA的一个实例,那么a.__class__返回 ‘ class    __main__.ClassA‘ ,type(a)返回总是<type 'instance'>。而引入新类后,比如ClassB是个新类,b是ClassB的实例,b.__class__和type(b)都是返回‘class '__main__.ClassB' ,这样就统一了。

引入新类后,还有其他的好处,比如更多的内置属性将会引入,描述符的引入,属性可以来计算等等。

为了向前兼容,默认情况下用户定义的类为经典类,新类需要继承自所有类的基类 object 或者继承自object的新类。

值得注意的地方是,虽然使用的是最新的python(2.7),但是一些特性不会在旧式类起作用。
所以,为了确保自己使用的是新式类,有以下方法:
  1. 把这个赋值语句放在类模块代码的最前面 __metaclass__ = type(前面有提过)。
  2. 自己的类都从内建类object直接或者间接地继承。
如果不需要兼容旧式类,旧版本的类,那么就保持都是新式类。
当然,在Python3里面,不存在这些问题了,因为所有的类都是object类的子类(隐式)。

 

类实现迭代器如下: 

#coding:utf-8
class Odd(object):
val,i
= 1,1
def __init__(self,num,count=0):
self.num
= num
self.count
= count
def next(self):
if self.__class__.val > self.num:
raise StopIteration #只能使用这句才能退出循环
if self.count != 0 and self.__class__.i > self.count:
raise StopIteration
ret
= self.__class__.val
self.
__class__.val += 2
self.
__class__.i += 1
return ret

def __iter__(self):
return self

#print list(Odd(100,3))
#
for item in Odd(100,3):print item
while True:
try:
print Odd(100,3).next()
except StopIteration:
break

 

 关于生成器,也是一种特殊的迭代器

#coding:utf-8
def odd(num,count=0):
val,i
= 1,1
while val <= num:
yield val
val
+= 2
i
+= 1
#生成器退出的三种情况:
#1、执行到函数末尾,如此处的 val>num 时
#2、执行到 return 语句
#3、抛出 StopIteration 异常
if count != 0:
if i>count:
return
#raise StopIteration

for i in odd(100):
print(i)
print list(odd(100,3))
fun
= odd(100,4)
while True:
try:
print fun.next()
except StopIteration:
break

 

将一段字符串中指定字符替换成指定字符:

s1 = '1234'
s2
= '5678'
s
= '10203040'

print ''.join(dict(zip(list(s1),list(s2))).get(c,c) for c in s)

import string
print string.translate(s,string.maketrans(s1,s2))

import re
print re.sub('.',lambda m: dict(zip(list(s1),list(s2))).get(m.group(),m.group()),s)

 

第三种方法,目前暂不熟练。

 

 

try...except...else...finally

else子句是当没有捕捉到异常时执行的语句,表示正常运行。

finally是不管有没有捕捉到异常都必然执行的语句

如果 except 后面没有跟上指定异常(或异常元组),则默认为全捕捉,这是很危险的,因为它也会捕捉语法或书写方面的异常,如 AttributeError 、 IndentationError 和SyntaxError。

 

不同于C/C++,python的赋值语句不能做为表达式,即没有返回值。

python3.2教程:

http://docspy3zh.readthedocs.org/en/latest/tutorial/index.html