Pythonのベースノート3

先進的な機能

コードは良くありませんが、より良いです。より複雑なコードではない、より良い、より良い簡単です。開発効率が高い、コードが少ないです。

1.スライス

スライス（スライス）オペレータ、または要素は非常に一般的な部分であるタプルのリストを取ります。
リスト

L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack']
L[0:3]
L[1:3]
L[-1]
L[-2:]

L=list(range(100) #0-99
L[:10] #前10
L[-10:] #后10
L[10:20]
L[:10:2] #前10，每两个取一个
L[::5] #所有数中每5个取一个

タプル

(0,1,2,3,4,5)[:3]  #得到的也是一个tuple(0,1,2) 

弦

'ABCDEFG'[:3]  #ABC
'ABCDEFG'[::2] #ACEG

文字列傍受機能を特化したRとPerlとは異なり、Pythonはスライシング操作によって完了させることができる、柔軟な使用は、サイクル数を減らすことができます。

2.反復反復

反復するforループA

d={'a':1, 'b':2, 'c':3}
for key in d: #字典默认迭代key 
    print(key) #无序

#迭代值
for value in d.values():  #括号不可少
    print(value)
#迭代键和值
for k,v in d.items():

オブジェクトが反復できるかどうかを判断

from collections import Iterable
isinstance('abc',Iterable) #字符串可迭代
isinstance([1,2,3],Iterable) #list可迭代
isinstance(123,Iterable) #整数不可迭代

添字（要素インデックス）反復ループを達成

for i, value in enumerate(['a','b','c']):
    print(i, value)

しばらく変数サイクルの数

for x,y,z in [(1,2,3),(2,3,1),(2,1,3)]:
    print(x,y,z)

任意のオブジェクトは、私たちのカスタムデータ型を含め、forループの反復に基づいて行動することができ、彼らはあなたがforループを使用することができ、繰り返しの条件を満たしていなければなりません。

3.リスト式

list(range(1,11))  #1..10

[x*x for x in range(1,11)]

[x*x for x in range(1,11) if x % 2 ==0]

[m+n for m in 'abc' for n in 'xyz']

アプリケーション

#列出当前目录所有文件和目录名
import os
[d for d in os.listdir('.')]

#两个变量生成list
d={'x':1, 'y':2, 'z':3}
[k + '=' +v  for k,v in d.items()]

#所有list字符串小写    
L=["aBC","Word"]
[s.lower() for s in L if isinstance(s,str)==True] #列表中只能都为str

4.ジェネレータジェネレータ

計算を循環させながら。
ビルダーの作成：

g=(x*x for x in range(10))  #()而非[]
g
next(g)
next(g)
...... #一个个打印出来，直到最后一个元素

for n in g: #可迭代
    print(n)

関数は、発電機を用いて実装されます。通常の関数コールの戻りの直接の結果は、ジェネレータ関数呼び出しはジェネレータオブジェクトを返します。

#斐波那契数列
def fib(max):
    n,a,b = 0,0,1
    while n < max:
        yield b  #yield关键字
        a,b = b,a+b
        n = n+1
    return 'done'
    
for n in fib(6):
    print(n)  #不会返回return的值
    
#return的值包含在StopIteration错误的value中：
g=fib(6)
while True:
    try:
        x=next(g)
        print('g:',x)
    except StopIteration as e:
        print('Generator return value:', e.value)
        break

演習：発電機を書き、パスカルの三角形の出力は、次の行に続きます

# _*_ coding: utf-8 _*_
def triangles():
    L=[1]
    yield L
    while True:
        #两端都是1，中间是上两个相邻数之和
        L=[1]+[L[x]+L[x+1] for x in range(len(L)-1)]+[1]
        yield L

5.イテレータ

イテラブル（反復処理可能）：ループのための1つが（発電機及び発電機機能の収率で）発生器である、クラスがデータ・タイプ（リスト/タプル/ dictの/設定/ STR）の集合であり、オブジェクトに直接作用することができます

#判断对象是否为Iterable对象,以下都为True
from collections import Iterable
isinstance([],Iterable)
isinstance({},Iterable)
isinstance('abc',Iterable)
isinstance((x for x in range(10)),Iterable)

それは次の（）関数の呼び出しであると次の目標値に連続的に呼ばれるイテレータイテレータを返すことができます。

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

Builderは、イテレータオブジェクト、リスト/辞書/ STRイテラブルが、ではなくイテレータです。しかし、彼らはイテレータを取得するためにITER（）関数とすることができます。

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

イテレータオブジェクトは不活性であるデータストリームであり、次のステップは、次の関数によってのみ要求に応じて計算されます。

関数型プログラミング

関数型プログラミングは、抽象プログラミングパラダイムではなくても、純粋な関数型プログラミング変数（Pythonはない）の高いレベルです。これは他の関数へのパラメータとして関数自体を許可することを特徴とする、関数はまた戻ることができます。

1.高階関数

変数は関数を指すことができます

x=abs(-10) #赋值
x

f=abs  #赋函数
f
f(-10)

関数パラメータを渡します

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

add(-5,6,abs)

マップ/削減
マップ（機能、反復処理可能）

def f(x):
    return x*x

r=map(f,[1,2,3,4])
list(r)

#简写
list([map(str,[1,2,3,4]))

低減（F、[X1、X2、X3）= F（F（X1、X2）、X3）

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

マップやと一緒に減らします：

#字符串转化为整数函数
from functools import reduce
digits={'0':0,'1':1,'2':2,'3':3}
def str2int(s):
    def fn(x,y):
        return x*10+y
    def char2num(s):
        return digits[s]
    return reduce(fn, map(char2num,s))
    
str2int('123')

機能の上にさらにラムダ関数によって単純化することができます。

from functools import reduce
digits={'0':0,'1':1,'2':2,'3':3}
def char2num(s):
    return digits[s]
def str2int(s):
    return reduce(lambda x,y: x*10+y, map(char2num,s))

フィルター
濾過配列、修飾されたふるい要素から配列

def is_odd(n):
    return n % 2 == 1

list(filter(is_odd,[1,2,3,4,5])) #1,3,5

フィルタと物理の全体数（プライム）のスクリーニング：

#先构造一个从3开始的奇数序列
def _odd_iter():
    n=1
    while True:
        n=n+2
        yield n

#然后定义一个筛选函数
def _not_divisible(n):
    return lambda x: x%n > 0

#最后定义一个生成器，不断返回下个素数
def primes():
    yield 2
    it = _odd_iter() #初始序列
    while True:
        n=next(it) #返回第一个数
        yield n
        it = filter(_not_divisible(n),it) #构造新序列
        
#打印1000内的素数
for n in primes():
    if n < 1000:
        print(n)
    else:
        break

バックいくつかのスクリーニング：

def is_palindrome(n):
    return str(n)==str(n)[::-1]

output = filter(is_palindrome, range(1, 1000))
print('1~1000:', list(output))

ソート
ソートアルゴリズム

sorted([3,5,-23,4,-8])
sorted([3,5,-23,4,-8], key=abs) #按绝对值排序

sorted(['bob', 'about', 'Zoo', 'Credit']) #默认ASCII码['Credit', 'Zoo', 'about', 'bob']
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower) #['about', 'bob', 'Credit', 'Zoo']

sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True) #反向 ['Zoo', 'Credit', 'bob', 'about']   

）（ソート使用してソートキーマッピング機能の実現です。

2.リターン機能

関数は、結果として、値を返します

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

f=lazy_sum(1,2,5,7)
f #返回的是函数
f() #返回结果

#每次调用都会返回一个新的函数，即使参数相同也不一样
f1=lazy_sum(1,2,5,7)
f2=lazy_sum(1,2,5,7)
f1==f2  #False，f1()和f2()的调用结果互不影响。

クロージャ
の実施形態では、機能lazy_sumも機能和を定義し、内部機能サム参照外部関数lazy_sumパラメータおよびローカル変数、場合lazy_sumリターン機能和され、関連パラメータおよび変数は、関数によって返さに格納されていますこのプログラムの構造は、「閉鎖（閉鎖）」と呼ばれています。

リターンがどのループ変数または変数後続の変更を参照していない機能が発生：リターン・クロージャがあることを覚えておいてください。

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

f1, f2, f3 = count()
#f1()f2()f3()都是9，因为返回的函数引用了变量i，但它并非立刻执行，等到3个函数都返回时，它们所引用的变量i已经变成了3。

あなたはループ変数を参照して、関数を作成しなければならない場合、関数のループ変数パラメータの現在の値をバインドします：

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

3.無名関数

キーワードラムダは、無名関数を表し、

list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

#赋值变量
f = lambda x: x * x
f
f(5)

#作为返回值
def build(x, y):
    return lambda: x * x + y * y

4.デコレータ

関数も変数とコールに割り当てることができるオブジェクトです。

def now():
    print('2019-1-1')
f=now
f()

利用できる機能の__name__プロパティ関数オブジェクト名：

now.__name__  #now
f.__name__  #now

パフォーマンス機能を増やしたい、だけでなく、関数の定義を変更したくない、実行するためのコードの間に、このダイナミックな増加の機能は、「デコレータ（デコ）」と呼ばれています。

基本的にデコレータはリターン高階関数の関数です。

#定义一个能打印日志的装饰器：函数作为参数并返回函数
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

@log  #把装饰器置于函数的定义处，相当于now = log(now)
def now():
    print('2019-1-1')
    
now() #调用函数，会打印日志

あなたはログテキストをカスタマイズしたい場合は、高階関数を返すためにデコレータを記述する必要があります。

def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator
    
#三层嵌套的装饰器调用：
@log('execute')  #相当于now = log('execute')(now)
def now():
    print('2015-3-25')

完全なデコレータの書き込み：

import functools

def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
    
#带参数的装饰器：
import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

オブジェクト指向の装飾的なパターンは、Pythonのデコレータの機能を実装することができ、それはクラスによって実装することができ、相続や組成によって実現する必要があります。

部分関数

Functools部分関数モジュールが用意されています。簡単に呼び出すときになるように、あまりにもの引数の数が、ある一定のパラメータ（すなわち、設定されたデフォルト値）に新しい機能を作成することができたとき。

#自定义函数
def int2(x,base=2): #默认转化二进制
    return int(x,base)

#使用偏函数
import functools
int2 = functools.partial(int, base=2) #实际上固定了int()函数的关键字参数base
int2('10010')
int2('10010', base=10)

max2 = functools.partial(max, 10) #10会作为*args的一部分自动加到左边
max2(5, 6, 7) #相当于max2(10,5, 6, 7)