python基础

1.清屏
ctrl + l
或者
import os
os.system(‘clear’)

2.退出交互
exit()
quit()

3.输入
raw_input()

4.为了简化,Python还允许用r”表示”内部的字符串默认不转义,可以自己试试:

>>> print ‘\\\t\\’
\ \
>>> print r’\\\t\\’
\\\t\\

为了简化,Python允许用”’…”’的格式表示多行内容

5.数据类型
True、False表示布尔值(请注意大小写)
空值是Python里一个特殊的值,用None表示

Python在后来添加了对Unicode的支持,以Unicode表示的字符串用u’…’表示

str.encode(‘utf-8′)
str.decode(‘utf-8′)

#!/usr/bin/env python
# -*- coding: utf-8 -*-
第一行注释是为了告诉Linux/OS X系统,这是一个Python可执行程序,Windows系统会忽略这个注释;
第二行注释是为了告诉Python解释器,按照UTF-8编码读取源代码,否则,你在源代码中写的中文输出可能会有乱码。
格式化
>>> ‘Hello, %s’ % ‘world’
‘Hello, world’
>>> ‘Hi, %s, you have $%d.’ % (‘Michael’, 1000000)
‘Hi, Michael, you have $1000000.’

如果只有一个%?,括号可以省略。普通字符串% 用 %%

6.数组
list
=============================================
classmates = ['Michael', 'Bob', 'Tracy']
classmates.append(‘Adam’)
classmates.insert(1, ‘Jack’)
classmates.pop()
classmates.pop(n)
classmates[1] = ‘Sarah’
classmates.sort()

tuple
=============================================
tuple和list非常类似,但是tuple一旦初始化就不能修改,比如同样是列出同学的名字:
classmates = (‘Michael’, ‘Bob’, ‘Tracy’)
因为tuple不可变,所以代码更安全。如果可能,能用tuple代替list就尽量用tuple。
但是,要定义一个只有1个元素的tuple,如果你这么定义:
>>> t = (1)
>>> t
1
定义的不是tuple,是1这个数!这是因为括号()既可以表示tuple,又可以表示数学公式中的小括号,这就产生了歧义,因此,Python规定,这种情况下,按小括号进行计算,计算结果自然是1。

所以,只有1个元素的tuple定义时必须加一个逗号,,来消除歧义:
>>> t = (1,)
>>> t
(1,)

tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。即指向’a',就不能改成指向’b',指向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的!
>>> t = (‘a’, ‘b’, ['A', 'B'])
>>> t[2][0] = ‘X’
>>> t[2][1] = ‘Y’
>>> t
(‘a’, ‘b’, ['X', 'Y'])

dict (map key-value结构)
=============================================
>>> map = {‘a’:1,’b':2}
>>> map['a']
1
>>> map['c']=3
>>> map
{‘a’: 1, ‘c’: 3, ‘b’: 2}

>>> ‘d’ in map
True
>>> ‘f’ in map
True
>>> ‘dd’ in map
False

//第二个参数指定不存在时的返回值
>>> map.get(‘d’,-1)
4
>>> map.get(‘dd’,-1)
-1
>>> map.get(‘dd’)

>>> map.pop(‘a’)
1
>>> map
{‘c’: 3, ‘b’: 2}
set
=============================================
set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。
要创建一个set,需要提供一个list作为输入集合:

>>> s = set([1, 2, 3])
>>> s
set([1, 2, 3])
>>> s.add(4)
>>> s
set([1, 2, 3, 4])

set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集等操作:

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
set([2, 3])
>>> s1 | s2
set([1, 2, 3, 4])

7.表达式
a.if
age = 3
if age >= 18:
print ‘adult’
elif age >= 6:
print ‘teenager’
else:
print ‘kid’
b.循环
names = ['Michael', 'Bob', 'Tracy']
for name in names:
print name

=============================================
sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
sum = sum + x
print sum

=============================================
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n – 2
print sum
=============================================

原来从raw_input()读取的内容永远以字符串的形式返回.

birth = raw_input(‘birth: ‘)
if birth < 2000:
print ’00前’
else:
print ’00后’

>>> birth
’1982′
>>> ’1982′ < 2000
False
>>> 1982 < 2000
True

birth = int(raw_input(‘birth: ‘))
8.函数
内置函数

https://docs.python.org/2/library/functions.html#abs

定义函数:
def my_abs(x):
if x >= 0:
return x
else:
return -x

如果想定义一个什么事也不做的空函数,可以用pass语句:
def nop():
pass
pass还可以用在其他语句里,如if中
判断类型:
def my_abs(x):
if not isinstance(x, (int, float)):
raise TypeError(‘bad operand type’)
if x >= 0:
return x
else:
return -x

返回多个值:
import math

def move(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y – step * math.sin(angle)
return nx, ny
这样我们就可以同时获得返回值:

>>> x, y = move(100, 100, 60, math.pi / 6)
>>> print x, y

但其实这只是一种假象,Python函数返回的仍然是单一值:
>>> r = move(100, 100, 60, math.pi / 6)
>>> print r
(151.96152422706632, 70.0) //返回的是一个 tuple

类似php的 list($x,$y) = 一个返回array($x,$y) 的函数

默认参数:
=============================================
def power(x, n=2):
pass

我们可以用None这个不变对象来实现:

def add_end(L=None):
if L is None:
L = []
L.append(‘END’)
return L

可变参数:
=============================================
def calc(numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
但是调用的时候,需要先组装出一个list或tuple:

>>> calc([1, 2, 3])
14
>>> calc((1, 3, 5, 7))
84
嫌麻烦 ?想能不能直接写成 calc(1, 2, 3)
函数参数 * 开头
def calc(*numbers):

如果有个现成的list,还要一个个传 像这样?
>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
14
可以简化为 带*传入参数
calc(*nums)

关键字参数:
=============================================
关键字参数允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict。请看示例:

def person(name, age, **kw):
print ‘name:’, name, ‘age:’, age, ‘other:’, kw
函数person除了必选参数name和age外,还接受关键字参数kw。在调用该函数时,可以只传入必选参数:

>>> person(‘Michael’, 30)
name: Michael age: 30 other: {}

在函数调用的时候,Python解释器自动按照参数位置和参数名把对应的参数传进去。
def func(a, b, c=0, *args, **kw):
print ‘a =’, a, ‘b =’, b, ‘c =’, c, ‘args =’, args, ‘kw =’, kw

>>> func(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> func(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> func(1, 2, 3, ‘a’, ‘b’)
a = 1 b = 2 c = 3 args = (‘a’, ‘b’) kw = {}
>>> func(1, 2, 3, ‘a’, ‘b’, x=99)
a = 1 b = 2 c = 3 args = (‘a’, ‘b’) kw = {‘x’: 99}
最神奇的是通过一个tuple和dict,你也可以调用该函数:

>>> args = (1, 2, 3, 4)
>>> kw = {‘x’: 99}
>>> func(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {‘x’: 99}
Python的函数具有非常灵活的参数形态,既可以实现简单的调用,又可以传入非常复杂的参数。

默认参数一定要用不可变对象,如果是可变对象,运行会有逻辑错误!

要注意定义可变参数和关键字参数的语法:

*args是可变参数,args接收的是一个tuple;

**kw是关键字参数,kw接收的是一个dict。

以及调用函数时如何传入可变参数和关键字参数的语法:

可变参数既可以直接传入:func(1, 2, 3),又可以先组装list或tuple,再通过*args传入:func(*(1, 2, 3));

关键字参数既可以直接传入:func(a=1, b=2),又可以先组装dict,再通过**kw传入:func(**{‘a’: 1, ‘b’: 2})。

使用*args和**kw是Python的习惯写法,当然也可以用其他参数名,但最好使用习惯用法。

注释:
单行 #开头

多行
”’
注释内容
”’

导入文件:fun.py
import fun
from fun import *
9.
list或tuple切片
>>> list = ['a','b','c','d']
>>> list[0:3]
['a', 'b', 'c']
>>> list[0:3:2]
['a', 'c']
>>> list[:3]
['a', 'b', 'c']
>>> list[-1:]
['d']
>>> list[-3:2]
['b']

>>> l = range(5)
>>> l
[0, 1, 2, 3, 4]

默认情况下,dict迭代的是key。
map迭代:
d = {‘a’: 1, ‘b’: 2, ‘c’: 3}
输出key
for key in d:print key
输出val
for val in d.itervalues():print val
输出key,value
for key,val in d.iteritems():print key,val

list 迭代:list迭代的是val
list = ['a', 'b', 'c', 'd']
输出val
for key in list:print key (同map输出key)

如果要对list实现类似Java那样的下标循环怎么办?Python内置的enumerate函数可以把一个list变成索引-元素对,这样就可以在for循环中同时迭代索引和元素本身:
>>> for key,val in list:print key,val

Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
ValueError: need more than 1 value to unpack

>>> for key,val in enumerate(list):print key,val

0 a
1 b
2 c
3 d

还可以这样 我去!
>>> for x, y in [(1, 1), (2, 4), (3, 9)]:print x,y

1 1
2 4
3 9
要整体怎么办?
>>> for x, y in enumerate([(1, 1), (2, 4), (3, 9)]):print x,y

0 (1, 1)
1 (2, 4)
2 (3, 9)

当我们使用for循环时,只要作用于一个可迭代对象,for循环就可以正常运行,而我们不太关心该对象究竟是list还是其他数据类型。
那么,如何判断一个对象是可迭代对象呢?方法是通过collections模块的Iterable类型判断:

>>> from collections import Iterable
>>> isinstance(‘abc’, Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False
列表生成(采用表达式的结果作为元素) [表达式|for 结构|过滤条件]

>>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

还可以使用两层循环,可以生成全排列:

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

>>> d = {‘x’: ‘A’, ‘y’: ‘B’, ‘z’: ‘C’ }
>>> [k + '=' + v for k, v in d.iteritems()]
['y=B', 'x=A', 'z=C']

运用列表生成式,可以快速生成list,可以通过一个list推导出另一个list,而代码却十分简洁。

使用内建的isinstance函数可以判断一个变量是不是字符串:

>>> x = ‘abc’
>>> y = 123
>>> isinstance(x, str)
True
>>> isinstance(y, str)
False
生成器 ,列表生成是 [], 这个是 ()
>>> g = (x for x in range(10))
>>> g
<generator object <genexpr> at 0x104feab40>

>>> g.next()
0
>>> g.next()
1

如果推算的算法比较复杂,用类似列表生成式的for循环无法实现的时候,还可以用函数来实现。

def func():
for x in range(10):
yield x

test = func()
test.next()

要理解generator的工作原理,它是在for循环的过程中不断计算出下一个元素,并在适当的条件结束for循环。对于函数改成的generator来说,遇到return语句或者执行到函数体最后一行语句,就是结束generator的指令,for循环随之结束。

高阶函数

a.map/reduce : 类似php的 array array_map ( callback $callback , array $arr1 [, array $... ] )

把方法作用于每个元素
>>> def f(x):
… return x * x

>>> map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
[1, 4, 9, 16, 25, 36, 49, 64, 81]

把前面的结果向后传递
reduce的用法。reduce把一个函数作用在一个序列[x1, x2, x3...]上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算,其效果就是:
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

比方说对一个序列求和,就可以用reduce实现:(当然可以用sum(list)直接求元素总和)
>>> def add(x, y):
… return x + y

>>> reduce(add, [1, 3, 5, 7, 9])
25
结合map 和 reduce 的 字符串转整形函数 str2int(s)
lambda 匿名函数

def char2num(s):
return {’0′: 0, ’1′: 1, ’2′: 2, ’3′: 3, ’4′: 4, ’5′: 5, ’6′: 6, ’7′: 7, ’8′: 8, ’9′: 9}[s]

def str2int(s):
return reduce(lambda x,y: x*10+y, map(char2num, s))

b.排序
sorted(list, reversed_cmp=”) 类似于php的 usort()

c.函数作为返回值(闭包)
我们来实现一个可变参数的求和。通常情况下,求和的函数是这样定义的:

def calc_sum(*args):
ax = 0
for n in args:
ax = ax + n
return ax
但是,如果不需要立刻求和,而是在后面的代码中,根据需要再计算怎么办?可以不返回求和的结果,而是返回求和的函数!

def lazy_sum(*args):
def sum():
ax = 0
for n in args:
ax = ax + n
return ax
return sum
当我们调用lazy_sum()时,返回的并不是求和结果,而是求和函数:

>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function sum at 0x10452f668>
调用函数f时,才真正计算求和的结果:

>>> f()
25
在这个例子中,我们在函数lazy_sum中又定义了函数sum,并且,内部函数sum可以引用外部函数lazy_sum的参数和局部变量,当lazy_sum返回函数sum时,相关参数和变量都保存在返回的函数中,这种称为“闭包(Closure)”的程序结构拥有极大的威力。

请再注意一点,当我们调用lazy_sum()时,每次调用都会返回一个新的函数,即使传入相同的参数:

>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False
f1()和f2()的调用结果互不影响。

d.匿名函数
>>> f = lambda x: x * x
>>> f
<function <lambda> at 0x10453d7d0>
>>> f(5)
25

def build(x, y):
return lambda: x * x + y * y

>>> build(1,2)
<function <lambda> at 0x10a731c08>

>>> build(1,2)()
5

e.函数装饰器
联想到 钩子,又或者是java中类的对象的属性是对象,下面又有属性 $this->xx->yy->zz()
def log(func):
def wrapper(*args, **kw):
print ‘call %s():’ % func.__name__
return func(*args, **kw)
return wrapper

观察上面的log,因为它是一个decorator,所以接受一个函数作为参数,并返回一个函数。我们要借助Python的@语法,把decorator置于函数的定义处:

@log
def now():
print ’2013-12-25′

>>> now()
call now():
2013-12-25

由于log()是一个decorator,返回一个函数,所以,原来的now()函数仍然存在,只是现在同名的now变量指向了新的函数,于是调用now()将执行新函数,即在log()函数中返回的wrapper()函数。

@functools.wraps(func) 保持 func 的__name__ 不变成 wrapper

f.偏函数:
functools.partial就是帮助我们创建一个偏函数的,不需要我们自己定义int2(),可以直接使用下面的代码创建一个新的函数int2:

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2(’1000000′)
64
>>> int2(’1010101′)
85

包:
==========================================================================================
每一个包目录下面都会有一个__init__.py的文件,这个文件是必须存在的,否则,Python就把这个目录当成普通目录,而不是一个包。

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

‘ a test module ‘

__author__ = ‘Michael Liao’

import sys

def test():
args = sys.argv
if len(args)==1:
print ‘Hello, world!’
elif len(args)==2:
print ‘Hello, %s!’ % args[1]
else:
print ‘Too many arguments!’

if __name__==’__main__’:
test()

把一个非纯方法的文件导入 如 import hello 不会执行输出
hello.test()
hello.test() chen
这样调用才会输出

别名
导入模块时,还可以使用别名,这样,可以在运行时根据当前环境选择最合适的模块。
try:
import json # python >= 2.6
except ImportError:
import simplejson as json # python <= 2.5

作用域
_xxx和__xxx这样的函数或变量就是非公开的(private)

b.模块搜索路径

>>> import sys
>>> sys.path
['', '/Library/Python/2.7/site-packages/pycrypto-2.6.1-py2.7-macosx-10.9-intel.egg', '/Library/Python/2.7/site-packages/PIL-1.1.7-py2.7-macosx-10.9-intel.egg', ...]
>>> sys.path.append(‘/Users/michael/my_py_scripts’)

e.兼容控制 __future__
你想在Python 2.7的代码中直接使用Python 3.x的结果。

from __future__ import unicode_literals

版本2.x 默认地板除
>>> 10 / 3
3

版本3.x
from __future__ import division
10 / 3 = 3.33333333333
10.0 / 3 = 3.33333333333
10 // 3 = 3 //地板除
面向对象
==========================================================================================

class Student(object):

def __init__(self, name, score):
self.name = name //self.__name = name
self.score = score

def print_score(self):
print ‘%s: %s’ % (self.name, self.score)

def get_name(self):
return self.__name

def get_score(self):
return self.__score

def set_score(self, score):
if 0 <= score <= 100:
self.__score = score
else:
raise ValueError(‘bad score’)

bart = Student(‘Bart Simpson’, 59)

和普通的函数相比,在类中定义的函数只有一点不同,就是第一个参数永远是实例变量self,并且,调用时,不用传递该参数。除此之外,类的方法和普通函数没有什么区别,所以,你仍然可以用默认参数、可变参数和关键字参数。

不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name,所以,仍然可以通过_Student__name来访问__name变量

但是强烈建议你不要这么干,因为不同版本的Python解释器可能会把__name改成不同的变量名。

继承
class DerivedClassName(modname.BaseClassName):
class DerivedClassName(Base1, Base2, Base3):

异常 except 和 raise

序列化
python包安装
python setup.py install

$pip install pil –allow-external pil –allow-unverified pil

 

 

关于 Administrator

爱拼才会赢!
此条目发表在 Python 分类目录,贴了 标签。将固定链接加入收藏夹。

发表评论

电子邮件地址不会被公开。 必填项已用 * 标注

*

您可以使用这些 HTML 标签和属性: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>