Python入门学习笔记

输入输出 ：

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)                               删除
函数：
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]
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/fatcat132006/p/4017755.html