python 学习笔记

len(str) 判断字符串的字符数量

python 可执行和文件编码

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

字符串格式化

'Hi, %s, you have $%d.' % ('Michael', 1000000)

占位符	替换内容
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

format

'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)

list与tuple的区别
list 数据类型列表 可以随时删除添加和修改其中的元素
tuple 元组 tuple和list非常相似，但是tuple一旦初始化就不能修改

条件语句

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

python 当中只有两种集合遍历
for .. in ..
while condition:

range(n) 生成序列是从0 开始小于 n 的整数

set 值不能重复
dict 键值对

isinstance() 判断变量属于那种类型

if not isinstance(x,(int ,float))

判断x变量是不是int 或者 float类型的变量

异常抛出

raise TypeError('bad operand type')

函数可以返回多个值

import math
def move(x,y):
    a = x + 10
    b = y + 20
    return a,b
x,y = move(10,10)
print(x,y)

函数可以同时返回多个值，但其实就是一个tuple

函数参数

位置参数
默认参数
可变参数
关键字参数
命令关键字参数
参数组合

位置参数

def power(x):
    return x * x
print(power(10))

默认参数

def power(x , n = 2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

print(power(10))
print(power(10,3))

注意：
1.默认参数必须放在位置参数后面，不然Python解释器会报错
2.默认参数必须指向不变对象！

示例如下:

def addEnd(L = []):
    L.append('END')
    return L

print(addEnd())
print(addEnd())
print(addEnd())

def addEndAdvance(L = None):
    if L is None:
        L = []
    else :
        L.append('END')
    return L
print(addEndAdvance())
print(addEndAdvance())
print(addEndAdvance())

可变参数

// 位置参数
def cale(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

//传入list
print(cale([1,2,3,4]))
//传入tuple类型
print(cale((1,2,3,4)))

//可变参数
def caleChangeParams(*numbers):
    sum = 0
    for n in numbers:
        sum =  sum + n * n
    return sum

print(caleChangeParams(1,2,3,4,5))

关键字参数

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

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

person('zzx',22,city='beijing',country='china')
# out
zzx 22 {'city': 'beijing', 'country': 'china'}
[Finished in 0.1s]

命令关键字参数

• 后面的参数视为命令关键字参数，在传入关键字参数的时候关键字被指定

def person(name,age,*,city,country):
    print(name,age,city,country)

print(person('zzx',22,city='wuhan',country='china'))
print(person('zzx',22,city1='wuhan',country2='china')) //这句话将报错

组合参数

def func(*args,**kw):
    print(args,kw)
func('zzx','wuhan',sex='M',school='wtu',city='wh')

高级特性
切片

对经常取指定索引范围的操作，用循环十分繁琐，因此，Python提供了切片（Slice）操作符，能大大简化这种操作。

L = ['A','B','C','D','E','F','G','H','I','J','K','L']
L[0:3]
L[:3]
L[2:3]
L[::3] 每隔3个数去一个数
L[-1:-4] 倒数第一个到倒数第4个
'ABCDEFGHIJKL'[0:3] 字符串营业可以当做list

迭代

test

for item in list|set:
dict 迭代方式
默认迭代key
for k in dict:
迭代value
for value in dict.values():
同时迭代key,和value
for k,v in dict.items()

注意：for循环时，只要作用于一个可迭代对象，for循环就可以正常运行，而我们不太关心该对象究竟是list还是其他数据类型。

判读一个对象是否可以迭代方式：

from collections import Iterable
isinstance('abc',Iterable) True
isinstance([1,2,3],Iterable) True
isinstance(123,Iterable) False

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

L = ['A','B','C','D','E','F','G','H','I','J','K','L']
for i,value in enumerate(L):
    print(i,value)

列表生成式

列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。

//生成1-10的数字
L = list(range(1, 11)) 
//生成1-10每个数的平方和
L = [x * x for x in range(1, 11)] 
//生成偶数的平方列表
L = [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']
//列出当前目录下的所有文件和目录名，可以通过一行代码实现：
import os # 导入os模块，模块的概念后面讲到
[d for d in os.listdir('.')] # os.listdir可以列出文件和目录
['Desktop', 'Documents', 'Downloads', 'Library', ...]
//列表生成式可以使用两个变量生成列表
d = {'x': 'A', 'y': 'B', 'z': 'C' }
[k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']
//把所有的大写变成小写
L = ['Hello', 'World', 'IBM', 'Apple']
[s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']

生成器

性能问题：在Python中，这种一边循环一边计算的机制，称为生成器：generator。

#要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：
g = (x * x for x in range(10)) 
g
<generator object <genexpr> at 0x1022ef630>

注意：
1.generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。
2.generator是可以用for 循环遍历的而且还不用担心StopIteration问题

将函数变成generate

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'
# change ,要把fib函数变成generator，只需要把print(b)改为yield b就可以了
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'
#调用方式
f = fib(6)
next(f)

迭代器

我们已经知道，可以直接作用于for循环的数据类型有以下几种：
一类是集合数据类型，如list、tuple、dict、set、str等；
一类是generator，包括生成器和带yield的generator function。
这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。
可以使用isinstance()判断一个对象是否是Iterable对象：

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(10)), Iterable)
True
>>> isinstance(100, Iterable)
False

而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出StopIteration错误表示无法继续返回下一个值了。

>>> from collections import Iterator
>>> isinstance((x for x in range(10)), Iterator)
True
>>> isinstance([], Iterator)
False
>>> isinstance({}, Iterator)
False
>>> isinstance('abc', Iterator)
False

生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。
把list、dict、str等Iterable变成Iterator可以使用iter()函数：

>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

你可能会问，为什么list、dict、str等数据类型不是Iterator？
这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

注意

小结
凡是可作用于for循环的对象都是Iterable类型；

凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；

集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python的for循环本质上就是通过不断调用next()函数实现的，例如：

for x in [1, 2, 3, 4, 5]:
    pass
#实际上完全等价于：
# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break 

高阶函数

高阶函数英文叫Higher-order function
1.变量可以指向函数
2.函数名也是变量
3.传入函数

def myAbs(x):
    if x > 0:
        return x
    else :
        return -x

def add(x,y,f):
    return f(x)+f(y)

add(-1,-10,f)

注意：
把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。

map

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]

map()传入的第一个参数是f，即函数对象本身。由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。

应用

#将列表中的所有数字转化成字符串
list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', 

reduce

再看reduce的用法。reduce把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

>>> from functools import reduce
>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

filter

Python内建的filter()函数用于过滤序列。
和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

#在一个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]

#filter
阅读: 308863
Python内建的filter()函数用于过滤序列。

和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

例如，在一个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]

把一个序列中的空字符串删掉
def not_empty(s):
    return s and s.strip()

list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
# 结果: ['A', 'B', 'C']

sorted

排序也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序，排序的核心是比较两个元素的大小。如果是数字，我们可以直接比较，但如果是字符串或者两个dict呢？直接比较数学上的大小是没有意义的，因此，比较的过程必须通过函数抽象出来。

#Python内置的sorted()函数就可以对list进行排序：

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

#sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序，例如按绝对值大小排序：

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

返回函数

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function lazy_sum.<locals>.sum at 0x101c6ed90>

闭包

当一个函数返回了一个函数后，其内部的局部变量被新函数所引用

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()
#结果
>>> f1()
9
>>> f2()
9
>>> f3()
9

分析

全部都是9！原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。

注意：返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

改进

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs

>>> f1, f2, f3 = count()
>>> f1()
1
>>> f2()
4
>>> f3()
9

缺点是代码较长，可利用lambda函数缩短代码。

匿名函数

不需要显式地定义函数

lambda x: x * x
-----------------
def f(x):
    return x * x

装饰器

函数也是一个对象，而且函数对象可以被赋值给变量，所以，通过变量也能调用该函数
函数对象有一个name属性，可以拿到函数的名字
代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）

>>> def now():
...     print('2015-3-25')
...
>>> f = now

now.__name__ #'now'

test

test

test

test

test

test

test

test

test

test