python基础学习

函数

1.

print(L[0][0], L[1][1], L[-1][-1], sep=’\n’) 像这样在print里面最后加sep=’\n’可以起到换行的作用，而且换行后面有空格

2.

list列表使用[]括起来。其中元素可以删改，tuple元组使用()，其中不可以删改，都可以在其中进行嵌套

3.

条件函数if内部代码只需要缩进两行就可以了，不用{}

4.

age = 20
if age >= 6:
   print('teenager')
elif age >= 18:
   print('adult')
else:
   print('kid')

其中最后结果只会显示teenager，if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else

5.

input()函数输入的值作为字符串，不能参加比较，可以用int（）、float（）函数进行转变

6.

Python的循环有两种，一种是for…in循环，依次把list或tuple中的每个元素迭代出来

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

第二种循环是while循环，只要条件满足，就不断循环，条件不满足时退出循环。比如我们要计算100以内所有奇数之和，可以用while循环实现：

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

7.

python中的字典dict与js中的json表达方式极为相似，采用键值对形式表达用{}括起每一个key对应一个value，要删除一个key，用pop(key)方法

8.

set相对于dict只有key，相当于一个无序无重复数字的集合，&表示并集，|表示合集，

9.

replace()函数只能改变值，不能改变变量，要改变只有重新定义变量

>>> a = 'abc'
>>> b = a.replace('a', 'A')
>>> b
       'Abc'
>>> a
        'abc'

10.

在print函数中逗号起分割作用，涉及几个变量时，必须加，分割，不会显示
abs（）转化绝对值
str（）转化字符串
int（）转化整数
hex（）转化十六进制
len（）返回字符串的字符数

11.

pass语句可以在定义函数中作为占位符，def定义函数也要用：引起内部函数，结束定义函数用return返回值，import math语句表示导入math包

12.

自定义函数必选参数在前，默认参数在后，要修改默认参数的值，要把对应变量写出来复制，单写值无法改变变量，定义默认参数要牢记一点：默认参数必须指向不变对象！

13.

在函数中我们还可以设置可变参数，可变参数就是传入的参数个数是可变的，只是在参数前面加了一个*号，省去了在执行函数时再写一遍list、tuple，也就是说可变参数就是可以把列表中的元素提取出来作为可变元素。还有就是关键字参数，允许你传入多个值，还可以用关键字参数调用已有的list;；而命名关键字参数则可以限制自定义参数的名称

def person(name,age,**kw):
    print('name:',name,'age:',age,"other:",kw)
person('jason',19,city='chengdu')
>>>name: jason age: 19 other: {'city': 'chengdu'}

def person(name, age, *, city, job):
    print(name, age, city, job)
person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

便于理解：

def f1(a, b, c=0, *args, **kw):
     print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw) 
def f2(a, b, c=0, *, d, **kw):
     print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
>>> f1(1, 2) 
     a = 1 b = 2 c = 0 args = () kw = {}
 >>> f1(1, 2, c=3)
     a = 1 b = 2 c = 3 args = () kw = {}
 >>> f1(1, 2, 3, 'a', 'b') 
     a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
 >>> f1(1, 2, 3, 'a', 'b', x=99)
     a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
 >>> f2(1, 2, d=99, ext=None) 
     a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

14.

加强记忆，python与C语言不一样! 语句结束不加分号，输入用input（）且输入值为字符串，输出用print（），不用提前定义数据类型，Python是弱类型语言进行递归函数时就要防止栈溢出，在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。

15.

关于切片，表达形式L[m，n]，意思是从列表或元组L中提取出第m+1个元素到n-1个元素的切片，如果第一个索引是0，还可以省略为L[：n]，切片也可以取负数，从后面取元素，倒数第一个元素的索引是-1,正着数则是以两个数的间隔做区分，比如0就在第一个元素以前，1在第一第二个元素中间，所以n要减1

L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
print(L[-3:])
>>>['Tracy', 'Bob', 'Jack']

16.

迭代：给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，对于字典的迭代，很可能并没有按照列出的顺序，因为dict的存储不是按照list的方式顺序排列

for ch in 'ABC':
...     print(ch)
>>>A
      B
      C

17.

赋值语句：a, b = b, a + b
相当于：t = (b, a + b) # t是一个tuple
a = t[0]
b = t[1]

18.

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回

>>> def f(x):
...     return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]

19.

两个import语义有差异

import datetime
print(datetime.datetime.now())

是引入整个datetime包

from datetime import datetime
print(datetime.now())

是只引入datetime包里的datetime类
所以import之后前者是datetime这个包可见 后者是datetime.datetime这个类可见

20.

filter()接收一个函数和一个序列，用于过滤序列
例如，在一个list中，删掉偶数，只保留奇数，可以这么写：

def is_odd(n):
    return n % 2 == 1
list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]

21.sorted()函数对list进行排序

>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36] 

str.lower表示忽略大小写，reverse=True表示反向排序

从这几个函数理解高阶函数的意义就是能够利用其他函数对元素进行处理

22.

匿名函数lamba，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数

>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

23.

python2.x中print是一个语句，不用加括号，而在3.x中，print变成了一个函数，要加括号，其中的分隔符用sep定义，结束符用end定义，格式符用%定义，后加元组（）

print "%f, % s" % (3.4, "Hello World!")  
3.400000, Hello World! 

模块

1.

#!/usr/bin/env python3
  # -*- coding: utf-8 -*-
' a test module '

第1行和第2行是标准注释，第1行注释可以让这个hello.py文件直接在Unix/Linux/Mac上运行，第2行注释表示.py文件本身使用标准UTF-8编码，第3行是一个字符串，表示模块的文档注释，任何模块代码的第一个字符串都被视为模块的文档注释
import sys
导入模块，导入sys模块后，我们就有了变量sys指向该模块，利用sys这个变量，就可以访问sys模块的所有功能，要引用该模块内的函数用sys.函数名（）

2.

作用域：在一个模块中，我们可能会定义很多函数和变量，但有的函数和变量我们希望给别人使用，有的函数和变量我们希望仅仅在模块内部使用。在Python中，是通过_前缀来实现的。类似_xxx和__xxx这样的函数或变量就是非公开的（private），不应该被直接引用，比如_abc，__abc等；

3.

包：在文件系统中，包就是一个文件夹，模块就是一个.py文件，区分包与普通文件夹在于每一个包下面都有一个—init—.py文件，并且每一层都有，不同的包里面的同名函数用包名.函数名区分

4.

如果我们只是应用包里的某些函数，可以使用from math import pow, sin, log来导入

5.

try:
   	 from cStringIO import StringIO
    except ImportError:
    	from StringIO import StringIO

上述代码先尝试从cStringIO导入，如果失败了（比如cStringIO没有被安装），再尝试从StringIO导入。这样，如果cStringIO模块存在，则我们将获得更快的运行速度，如果cStringIO不存在，则顶多代码运行速度会变慢，但不会影响代码的正常执行。try 的作用是捕获错误，并在捕获到指定错误时执行 except 语句。

6.

第三方模块载入在py2.7以后已经自带了pip，可以利用piip下载第三方模块，并且IDEpcharm中自带pip。import载入模块时，遇到未下载第三方模块会提醒你下载

面向对象

1.

面向对象编程可以看成是不同对象的相互调用，基本思想为类和实例，必须牢记类是抽象的模板，比如Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。

2.

类通过关键字class定义，类名以大写字母开头，紧接着是(object)，表示该类是从哪个类继承下来的。有了类就可以创建具体的实例，实例用类名＋（）

class Person(object):
    pass  #pass能够创建一个最简单的类
xiaoming = Person()
xiaohong = Person()
print xiaoming
print xiaohong
print xiaoming==xiaohong
>>><__main__.Person object at 0x7fb705015450>  #结果中出现的__main__意思是，调用模块本身
	<__main__.Person object at 0x7fb704f54ad0>
	False # 说明两个实例并不相同

关于为什么要继承object类[https://www.zhihu.com/question/19754936]

3.

实例的属性使用实例,属性表示，在定义 Person 类时，可以为Person类添加一个特殊的init()方法，当创建实例时，init()方法被自动调用，我们就能在此为每个实例都统一属性

class Person(object):
    def __init__(self, name, gender, birth):
        self.name = name
        self.gender = gender
        self.birth = birth

init() 方法的第一个参数必须是 self（也可以用别的名字，但建议使用习惯用法），后续参数则可以自由指定，和定义函数没有任何区别

4.

关于访问限制，在属性前面加上__，如__job该属性就无法被外部访问到，而__job__作为特殊属性可以被外部访问，_job也可以被外部访问

5.

实例属性每个实例各自拥有，互相独立，而类属性有且只有一份，该类下的实例都可以使用类属性，在内部函数中调用类属性，需要使用类名.类属性名，当实例属性和类属性重名时，实例属性优先级高，它将屏蔽掉对类属性的访问

class Person(object):
    address = 'Earth'  #定义类属性
    def __init__(self, name):   #定义实例属性
        self.name = name

6.

class Student(object):
    ...
    def set_score(self, score):
        if 0 <= score <= 100:
            self.__score = score
        else:
            raise ValueError('bad score')  #可以对参数做检查，避免传入无效的参数

7.

方法就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据

8.

在面向对象的程序设计中，当我们定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class），对于前面的类，括号里面的object就是他们的父类，子类继承父类全部功能

9.

加强记忆，一种类的实例可以应用这个类里面的函数

class Timer(object):
    def run(self):
        print(' Timer is  Start...')
dog=Timer()
dog.run()   #实例dog应用了Timer类中的Run函数