Python入门学习笔记

PYTHON 教程 ： http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000

---

输入输出 ：

Linux下直接输入python，即进入Python编译界面

>>> print 'hello,world'                             输出，多行的时候使用 ''' 代替 "
hello, world
>>> name = raw_input('please enter your name: ')    输入，raw_input得到的是字符串，要转换的话需要强制转换 ： int(raw_input())

please enter your name:

>>> name

Michael

---

Python基础：
# print absolute value of an integer:
a = 100                                            对缩进有严格要求，对大小写敏感
if a >= 0:
    print a
else:
    print -a

 

字符串：

字符串的转义：如'，转义加反斜杠 \'，Python还允许用 r'' 来表示 '' 的内容不转义

print '''line1

line2

line3'''                                                                              ​使用'''.....'''来表示多行内容

java是静态语言，Python是动态语言

a = 33

a = 'abc'                                                                            在Python中，变量a可以不指定类型，随意赋值，java就不行

10 / 3  --> 3                                                                       整数除法

10.0 / 3 --> 3.3333                                                            浮点数除法，得出的就是浮点数

10 % 3 --> 1                                                                      取余也是%

 

字符串转换

%s                                                                                      用于字符串，但是任意的数值都可以转换成字符串

%d、%f、%x                                                                      分别用于整数、浮点数、十六位进制数

                                                    如果字符串里面有%，需要再加一个%来转义，即 %% = %​

字符串的其他操作

str.find(substr)                    查找子字串的索引值，没有则返回-1，还能指定位置 find(substr, start, end)

                                            从右往左查找：rfind()

substr = str[0:3]                  切割字符串，实际字符串也是一个list，可以用list的方法                                               

​

---

List列表 和 Tuple 元组:

列表 List：

>>> p = ['asp', 'php']

p[0]  --> 'asp'                                                                   索引也是从0开始，倒数的从-1开始 .

p.append('dd') --> ['asp', 'php', 'dd']                                    添加元素

p.insert(1, 'jack')  -->['asp', 'jack', 'php', 'dd']                        插入元素

p.pop( )  -->'php'                                                                pop( )，删除最后一个元素，或pop(-1)

len(p)  --> 2                                                                        长度 

 

元组 Tuple：                                                                     tuple 也是一种list, 和 list 非常相似，但是 tuple 一旦初始化就不能修改

# tuple 不可变，代码更安全，但是要从一开始就确定元素，能用tuple的尽量用tuple代替list

# 这时候，要是list作为tuple的一个元素，list内容是可以改变的，因为tuple存放的不过不过是list的地址

>>> t = (2, 4)                                                                     注意，是括号

---

条件判断和循环：

age = 3                                    

if age >= 18:                                 注意冒号 ：

    print 'your age is',age                   缩进的两行内容都是执行的

    print 'adult'

# elif 是 else if 的缩写

 

names = ['Tom', 'Marry', 'Jay']               

for name in names:                            for...in... 循环遍历

    print name

range(5) --> [0,1,2,3,4]                      range 生成 [0, 5) 的序列

---

Dict 字典 和 Set 集合：

dict 全称 dictionary，相当于map

>>> d = {1:a, 2:b, 3:c}                       key : value ，大括号

>>> d[1]                                      取出，也可以用get : d.get(1)，如果key不存在则返回None，key in dict 也可以判断key是否存在于dict

a

>>> d[1] = 1                                  放入

>>> d.pop(1)                                  删除key为1的键值对

# key 必须为不可变对象

 

Set 集合，存储的元素不重复

>>> s = set([1, 2, 3])                        借助list放入，加入list中有重复元素，set会自动过滤掉重复元素

>>> s.add(4)                                  添加

>>> s.remove(4)                               删除

---

函数：

Python 的内置函数 https://docs.python.org/2/library/functions.html#abs

def my_abs(x):

    if not isinstance(x, (int, float)):        isinstance是内置函数，类型检查

        raise TypeError('bad operand type')    抛出参数错误异常

    if x >= 0:

        return x                               返回结果，无结果可以写 return None

    else:

        return -x

x, y = move(10, 30)                            这里的move函数返回两个值，实际上是一个tuple，在语法上，返回一个tuple可以省略括号

 

默认参数

def my_method(x, y, z=4, m=5):                 这里的方法可以这样调用：my_method(1, 2), my_method(1, 2, 3), my_method(1, 2, m=6)

    ...                                        # 注意，必选参数在前，默认参数在后 ，而且默认参数必须指向不可变对象！！  

 

可变参数        

def calc(*numbers):                            *numbers  是可变参数，参数传0个，1个，3个都行

    sum = 0                       

    for n in numbers:                           numbers接收到的是一个tuple

        sum = sum + n;                         #如果已经有一个tuple或者list需要传入，可以这么调用 calc(*args)

    return sum

 

关键字参数：

def person(name, age, **kw):                   **kw 是关键字参数，这些参数会自动组装成一个dict

    print 'name:', name, 'age:', age, 'other:', kw

>>> preson('Tom', 25, gender='M', job='Engineer')          #这里的kw可以不输，也可以输多个，要是传入一个dict，就可以这么传 **kw

name: Tom age: 25 other: {'gender':'M', 'job':'Engineer'}   输出的就是一个dict

---

高级特性：

切片：

L = ['age', 'gender', 'name', 'addr']             

L[:3] 或者 L[0:3] -> ['age', 'gender', 'name']   开始的0的话，可以不写，取的是[0,3），不包括3

L[-2:] 或者       -> ['name', 'addr']            按顺序取后面两个

L[:4:2]           -> ['age', 'name']             前四个数，每2个取一个

L[::2]            -> ['age', 'name']             所有数，每2个取一个

L[:]              -> ['age', 'gender', 'name', 'addr']   所有数

# 字符串 和 tuple 也是list，因此也可以使用切片

 

迭代：

dict = {'a':1, 'b:2', 'c':3}

for key in dict   -->  a, b, c                    dict 默认迭代的是key

for value in dict.itervalues()                    itervalues()方法可以迭代dict的value

for k, v in dict.iteritems()                      iteritems()方法可以同时迭代dict的key和value

# 只要是可迭代对象，就可以用for...in，判断迭代对象 ： isinstance('abc', Iterable) （需要先导入 from Collections import Iterable）

# 判断一个对象是否List、tuple、dict还可以用这种方法 type(x) == list，type取的是类型

for i, value in enumerate(['A', 'B', 'C'])        使用enumerate 方法打印序号 i

    print i, value

0 A

1 B

2 C

 

列表生成式：

for x in range(1,11) --> [1...10]省略写            用range生成1到10的列表

[x * x for x in range(1,11) if x % 2 == 0]        列表里面写逻辑，生成的元素 x*x 要放到前面

    --> [4, 16, 36, 64, 100]

[m + n for m in 'ABC' for n in 'XYZ']             得出AX、AY这样的 3*3 个组合

>>> import os

>>> [d for d in os.listdir('.')]                  os.listdir可以列出文件和目录，如果目录有中文，用os.listdir(u'/中文')

>>> L = ['Hello', 'Mine']

>>> [s.lower() for s in L]                        输出L，但是里面的全部变成小写，非字符串没有 lower() 方法

# 拓展：把含有字符串和数字的列表改成小写，可以这么写 [s.lower() if isinstance(s, str) else s for s in L]

 

生成器：

>>> g = (x * x for x in range(10))                生成器与列表的区别，前者是 (), 后者是 []

>>> g.next()                                                                         生成器保存的实际是 算法，  每次调用 next() 方法可以打印下一个值，直到最后一个抛错

# 一旦生成器建成后，基本不会使用 next() 方法，而是用迭代 for...in

>>> def func():                                    生成器的另一种产生方法，带有yield的函数

...    n = 20;                                    生成器执行next()方法时，每次在yield处返回，下一个next()时，继续从上次记录位置执行

...    while(n > 0):

...        yield n

...        n = n -1

 

---

函数式编程：

高阶函数：

>>> def f(x):                                     这里定义一个函数

...    return x*x

...

>>> map(f, [1,2,3,4,5])                           这里map()作为高阶函数，接收函数作为参数的函数称为高阶函数

[1,4,9,16,25]                                     这里的f，写f是指函数对象本身，写f(1)时是调用函数，并期待返回1

>>> def fn(x, y):

...    return x + y                               这里的fn函数实现了累加

...

>>> reduce(fn, [1,2,3,4,5])                       reduce()高阶函数，里面的fn()函数需要两个参数

15

# map(int, '12345') --> [1, 2, 3, 4, 5]，因为字符串也是一个序列

 

排序算法：

>>> sorted([10, 2, 3])                            sorted()也是一个高阶函数，默认按小到大排序

[2, 3, 10]

>>> def cmp(x, y):                                 这里定义一个倒序的函数，要想字母排序倒序可以自己定义

...    if(x > y):

...        return -1

...    elif (x < y):

...        return 1

...    return 0

>>> sorted([10, 2, 3], cmp)                        cmp作为函数名传入就可以实现倒序了

[10, 3, 2]