Python学习笔记

简介

Python,是一种面向对象、直译式计算机编程语言,具有近二十年的发展历史,成熟且稳定。它包含了一组完善而且容易理解的标准库,能够轻松完成很多常见的任务。它的语法简捷和清晰,尽量使用无异义的英语单词,与其它大多数程序设计语言使用大括号不一样,它使用縮进来定义语句块。

与Scheme、Ruby、Perl、Tcl等动态语言一样,Python具备垃圾回收功能,能够自动管理内存使用。它经常被当作脚本语言用于处理系统管理任务和网络程序编写,然而它也非常适合完成各种高级任务。Python虚拟机本身几乎可以在所有的作业系统中运行。使用一些诸如py2exe、PyPy、PyInstaller之类的工具可以将Python源代码转换成可以脱离Python解释器运行的程序。

Python的官方解释器是CPython,该解释器用C语言编写,是一个由社区驱动的自由软件,目前由Python软件基金会管理。

Python支持命令式程序设计、面向对象程序设计、函数式编程、面向侧面程序设计、泛型编程多种编程范式。

适用场景:

  • 网站、后台服务等;
  • 系统管理脚本等;
  • 其他语言的再包装。

缺点:

  • 解释型语言,速度较C等编译型语言慢;
  • 无法加密

基础

简单输出

print 'abcdefg'

简单输入

x = raw_input("plz input something:")

参数传递

sys.argv[0]

数据类型

整数

整数的运算结果永远是精确的!

1,100,-80,0

>>>10 / 3
3

浮点

浮点运算的结果永远是4舍5入的!

1.23,3.14,-0.9

1.23x10^9=1.23e9=12.3e8

0.000012=1.2e-5

>>>10.0 / 3
3.3333333333333333333

字符串

‘abcdefg’

转义 \

'I\'m \"OK\"!'

多字符转义 r'xxx'

>>> print '\\\t\\'
\       \
>>> print r'\\\t\\'
\\\t\\

多行内容 ‘’’xxx’’’

>>> print '''line1
... line2
... line3'''
line1
line2
line3

字符串可以使用 + 连接在一起,使用 * 号重复;

字符串可以用下标索引,第一个字符的索引为0:

word = 'HelpA'
word[4] = 'A' #第5个字符
word[0:2] = 'He' #第1个到第2个字符
word[2:4] = 'lp' #第3个到第4个字符
word[:2] = 'He' #第1个到第2个字符
word[2:] = 'lpA' #除了前2个字符,第3个到第5个
word[1:100] = 'elpA' #太大的索引会被字符串大小所代替
word[10:] = '' #上界比下界小,返回空字符串
word[-1] = 'A' #最后一个字符
word[-2] = 'p' #倒数第2个字符
word[-2:0] = 'pA' #最后2个字符
word[:-2] = 'Hel' #除最后两个字符,第1个到第3个
word[-0] = 'H' # -0=0
word[-100:] = 'HelpA' #越界的负索引会被截断
word[-10] = error #单元素越界索引会报错

字符串不可改变,给字符串的索引位置赋值会报错;

len() 函数返回字符串长度

word = 'HelpA'
len(word) = 5

布尔值

True or False

>>> True
True
>>> False
False
>>> 3 > 2
True
>>> 3 > 5
False

布尔值可以用 andornot 运算。

and 与运算,只有所有都为True,and 结果才是True:

>>> True and True
True
>>> True and False
False
>>> False and False
False

or 或运算,只要其中有一个为True,or 结果就是True:

>>> True or True
True
>>> True or False
True
>>> False or False
False

not 非运算,它是一个单目运算符,把True变成False,False变成True:

>>> not True
False
>>> not False
True

用于条件判断

if age >= 18:
    print 'adult'
else:
    print 'teenager'

空值

none

none不等于0,0有意义,none是特殊的空值.

变量

变量名必须是大小写英文、数字和_的组合,且不能用数字开

a = 1
t_007 = 'T007'
Answer = True

同一变量可以反复赋值

a = 123     #a是整数
print a
a = 'ABC'   #a变为字符串
print a

常量

常量就是不能变的变量,比如常用的数学常数π就是一个常量。在Python中,通常用全部大写的变量名表示常量:

PI = 3.14159265359

字符编码

# -- coding: utf-8 --

格式化

使用 % 格式化字符串,使用%%转义 %%

%d    整数
%f    浮点数
%s    字符串
%x    十六进制整数

列表list

列表写在方括号[]中,通过逗号分隔项,项可以是不同类型数据:

x = ['Apple', 123, True]

有序集合,可以添加删除其中的内容:

>color = ['red', 'green', 'blue']
>print color
'red', 'green', 'blue'    

len() 函数可以获取列表元素的个数:

>len(color)
3

列表同样可以被索引、切片、连接,索引值从 0 开始:

>color[0]
'red'
>color[1]
'green'
>color[2]
'blue'

列表还可以从-1 开始索引;

>color[-1]
'blue'
>color[-2]
'green'
>color[-3]
'red'

列表可以嵌套:

q = [2, 3]
p = [1, q, 4]
len(p) = 3
p(1) = [2, 3]
p[1][0] = 2

append() 函数在列表末尾插入一些项:
p[1].append(‘xtra’)
p = [1, [2, 3, ‘xtra’], 4]
q = [2, 3, ‘xtra’]

insert() 函数在指定位置插入元素;

color.insert(1,white)
print color
'red', 'white', 'green', 'blue'

pop() 函数可以删除列表末尾的元素:

color.pop()
print color
'red', 'white', 'green'

pop() 函数还可以删除列表指定位置的元素:

color.pop(1)
print color
'red', 'green', 'blue'

替换列表中的元素,可以给指定索引位置赋值:
color[1] = ‘white’
print color
‘red’, ‘white’, ‘blue’

一个元素都没有的列表是空列表,长度为0:
color = []
len(color)
0

元组tuple

元组写在小括号中(),与列表类似,但是元组中的元素一旦初始化就不能再更改!

color = ('red', 'green', 'blue')
print color
('red', 'green', 'blue')

元组可以通过索引取值,但是不能使用apend insert这类方法改变元素;

因为tuple不可变,所以代码更安全。如果可能,能用tuple代替list就尽量用tuple

在定义只有一个元素的元组时,必须带上,逗号,否则会与数学计算产生歧义:

x = (1)
print x
1

x = (1,)
print x
(1,)

元组的不可变是指元组的指向位置不可变,如果元组中嵌套了列表,通过改变列表中的元素,元组是可以被改变的:

c = ['A', 'B']
x = ('a', 'b', c)
print x
x = ('a', 'b', ['A', 'B'])
x[2][0] = 'X'
x[2][1] = 'Y'
x
('a', 'b', ['X', 'Y'])

条件判断

if语句执行顺序是从上往下,如果在某个判断上是True,则立即执行对应的语句,并忽略剩下的elif和else语句.

if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

循环

for in循环

for a in A:
    print a

while循环

while a > 0:
    print a

dict

字典,使用key:value存储数据,查找速度快,内部无序,key必须是不可变对象.

查找:

S = {"a":1, "b":2, "c":3}
S[a]
1

赋值:

S[a] = 1
S[a]
1

pop(key)可以删除key:

S.pop[a]
1
S
{"b":2, "c":3}

dict中的key值是唯一的,后赋值会覆盖前赋值:

S[a] = 1
S[a]
1

S[a] = 10
S[a]
10

dict中的key值不存在时,查询会报错:

S[d]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: '的'

inget方法可以确认key是否存在:

d in S
False                #key不存在,返回False

S.get(d)           #key不存在,返回None
S.get(d, -1)      #key不存在,可以指定值
-1

dict特点:

  • 内存消耗大
  • key值必须是不可变对象(字符串 整数可作为key,list由于是可变对象,不能作为key)

set

set和dict类似,是key的集合,但不储存value.

S = set([a, b, c, b, c])
S
set([a, b, c])                      #重复元素会自动过滤

add(key) 添加元素:

S.add(d)
S
set([a, b, c, d])

remove(key) 删除元素:

S.remove(d)
S
set([a, b, c])

& 交集操作,| 并集操作:

S1 = set([a, b, c])
S2 = set([b, c, d])
S1 & S2
set([b, c])
S1 | S2
set([a, b, c, d])

函数

函数调用

python内置了很多函数,可以 int() 形式调用;

函数名其实就是指向一个函数对象的引用,可以把函数名赋给一个变量,相当于给这个函数起了一个“别名”:

a = int      # 变量a指向函数int
a(12.34)   # 通过a调用int函数
12

自定义函数

自定义函数使用 def 函数名(参数): 语句,接函数体,使用 return 返回函数值:

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

空函数

def nop():
    pass      #pass起占位符的作用

默认参数

def power(x, n=2):      #2是默认参数,不想使用的话在调用函数时需要明确指出n的值
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

power(5)
25

power(5, 2)
25

power(5, 3)
125

当有多个默认参数时,按顺序赋值;若想打乱顺序,需要明确指出参数名;

默认参数必须指向不可变对象;

如果默认参数为空,需用 none 指明.

可变参数

可变参数就是传入的参数个数是可变的,可以是1个、2个到任意个,还可以是0个。

可变参数以 *开头

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

calc(1,2)
5

使用可变参数,参数接受到的是一个元组tuple;

不使用可变参数,参数需要接收一个list或tuple,调用也较复杂;

def calc(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

calc([1,2])
5

如果要在已有的list或tuple基础上调用可变参数,只需在list或tuple前加上 *

nums = [1, 2, 3]
calc(*nums)
14

关键字参数

关键字参数使用 **定义,允许你传入0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict。

def person(name, age, **kw):
    print 'name:', name, 'age:', age, 'other:', kw

person('Michael', 30)                                    #只定义必须参数,未定义可选参数
name: Michael age: 30 other: {}

person('Bob', 35, city='Beijing')                      #定义一个关键字参数
name: Bob age: 35 other: {'city': 'Beijing'}
person('Adam', 45, gender='M', job='Engineer')                       #定义两个关键字参数
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

同样可以在已有dict基础上调用关键字参数:

kw = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **kw)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

参数组合

必选参数、默认参数、可变参数和关键字参数,可以组合使用;

参数定义的顺序必须是:必选参数、默认参数、可变参数和关键字参数。

def func(a, b, c=0, *args, **kw):
    print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw

递归函数

自己调用自己的函数,即递归函数.

高级特性

未完待续

参考: 廖雪峰的官方网站