python外壳，代码结构

1.1 True与False

以下集中在判断时为False，其余都是True

类型	值
布尔值	False
null类型	None
整数	0
浮点数	0.0
空字符串	''
空Tuples	()
空Lists	[]
空Dictionaries	{}
空Set	set()

1.2循环

使用break可以跳出循环
使用continue可以跳过次循环的后续，进行下一次循环
使用else可以判断沒有使用break时的情況。

使用zip()可以对多组Object同时进行循环迭代!!

days = ['Monday', 'Tuesday', 'Wednesday']
fruits = ['banana', 'orange', 'peach']
drinks = ['coffee', 'tea', 'beer']
desserts = ['tiramisu', 'ice cream', 'pie', 'pudding']
print('原方法：')
for i in range(len(days)):
    print(days[i], ": drink", drinks[i], "- eat", fruits[i], "- enjoy", desserts[i])

print('\nzip()用法：')
for day, fruit, drink, dessert in zip(days, fruits, drinks, desserts):
    print(day, ": drink", drink, "- eat", fruit, "- enjoy", dessert)

原方法：
Monday : drink coffee - eat banana - enjoy tiramisu
Tuesday : drink tea - eat orange - enjoy ice cream
Wednesday : drink beer - eat peach - enjoy pie

zip()用法：
Monday : drink coffee - eat banana - enjoy tiramisu
Tuesday : drink tea - eat orange - enjoy ice cream
Wednesday : drink beer - eat peach - enjoy pie

english = 'Monday', 'Tuesday', 'Wednesday'

french = 'Lundi', 'Mardi', 'Mercredi'

print('转换成list包tuple')
print(list( zip(english, french) ))
print('转换成Dictionarie')
print(dict( zip(english, french) ))

转换成list包tuple
[('Monday', 'Lundi'), ('Tuesday', 'Mardi'), ('Wednesday', 'Mercredi')]
转换成Dictionarie
{'Monday': 'Lundi', 'Tuesday': 'Mardi', 'Wednesday': 'Mercredi'}

1.3Comprehensions 推导式

list推导式 

listObj = [expression for item in iterable if condition]

print([number for number in range(1,6) if number % 2 == 1])  #[1, 3, 5]

rows = range(1,4)
cols = range(1,3)
cells = []
for row in rows:
    for col in cols:
        cells.append((row, col))
与一下代码等价
cells = [(r,c) for r in range(1, 4) for c in range(1, 3)]

dictionary推导式 

dictionaryObj = { key_expression : value_expression for expression in iterable if condition}

# 计算一个单字里字母的出现的次数
# 使用Set排除重复字母
word = 'letters'
letter_counts = {letter: word.count(letter) for letter in set(word) if letter.lower() not in 'aeiou'}
print(letter_counts)  #{'t': 2, 'l': 1, 's': 1, 'r': 1}

set推导式

set_Obj = {expression for expression in iterable if condition}

print({number for number in range(1,6) if number % 3 == 1})  #{1, 4}

generator推导式 

tuples没有推导式的用法，使用()包起來是generator推导式的用法
简单来说就是可以产生像是range()的Object，亦表示可以直接对齐迭代

记住!!!generator只能使用一次!!!

number_thing = (number*3-2 for number in range(1, 6))
print((1,))  #(1,)
print(number_thing)  #<generator object <genexpr> at 0x7ff1e00276d0>
for number in number_thing:
    print(number)#正常输出
# 或者转为list使用
number_list = list(number_thing)
print(number_list)  #[]
print('因为只能使用一次，所以上面这边找不到东西了')
number_thing = (number*3-2 for number in range(1, 6))
number_list = list(number_thing)
print(number_list)#正常输出

1.4 Function函数

不一定要return，但有return一定要有变量接住他，或是使用他。若此function沒有return则返回None

位置参数与关键字参数

要把参数传进function中有两种方法，位置参数与关键字参数，示例如下 (如果同时出现，则以位置参数优先)

可以在定义函数时，设定默认值，若使用function时沒有填入改参数，則使用默认值，有的话则覆盖。

# 特別注意!!!!若把空list当做默认值会发生意料之外的事情
def buggy(arg, result=[]):
    result.append(arg)
    print(result)
# 第一次使用时OK
buggy('a')  #['a']
# 第二次使用时就会残存上次的结果
buggy('b')  #['a','b']
# 可以使用以下方法修改function
def works(arg):
    result = []
    result.append(arg)
    print(result)
def nonbuggy(arg, result=None):
    if result is None:
        result = []
    result.append(arg)
    print(result)
works('a') #['a']
works('b')  #['b']
nonbuggy('a')  #['a']
nonbuggy('b')  #['b']

使用*与**收集位置参数和关键字参数

*收集的参数会以Tuples储存，**收集的参数会以Dictionary储存

print('全部都给收集器')
def print_args(*args):
    print('Positional argument tuple:', args)
print_args() #()
print_args(1,2,3) #(1,2,3)
print('\n混合位置参数使用，剩下的都给收集器')
def print_more(required1, required2, *args):
    print('Need this one:', required1)
    print('Need this one too:', required2)
    print('All the rest:', args)
print_more('cap', 'gloves', 'scarf', 'monocle', 'mustache wax') 
#Need this one: cap
#Need this one too: gloves
#All the rest: ('scarf', 'monocle', 'mustache wax')

def print_kwargs(**kwargs):

    print('Keyword arguments:', kwargs)
print_kwargs(wine='merlot', entree='mutton', dessert='macaroon')
#Keyword arguments: {'wine': 'merlot', 'entree': 'mutton', 'dessert': 'macaroon'}

function说明文字

为了提高代码的可读性，可以对自行定义出的函数加上说明文字，他人在使用时就可以使用help叫出文字。

def echo(anything):
    'echo returns its input argument'
    return anything
def print_if_true(thing, check):
    '''
Prints the first argument if a second argument is true.
The operation is:
1. Check whether the *second* argument is true.
2. If it is, print the *first* argument.
    '''
    if check:
        print(thing)
help(echo)
print('--------------------------------')
help(print_if_true)
print('\n仅叫出文字↓')
print(echo.__doc__)
print('--------------------------------')
print(print_if_true.__doc__)
#Help on function echo in module __main__:
#echo(anything)
#   echo returns its input argument
#--------------------------------
#Help on function print_if_true in module __main__:
#print_if_true(thing, check)
#    Prints the first argument if a second argument is true.
   
 #   The operation is: 
 #  1. Check whether the *second* argument is true.   
 #   2. If it is, print the *first* argument.
#仅叫出文字↓
echo returns its input argument
--------------------------------
Prints the first argument if a second argument is true.
The operation is:
1. Check whether the *second* argument is true.
2. If it is, print the *first* argument.
#

一等公民：function

在python的设计中，function是一级公民。
换句话说python是Object导向的语言，所有的东西都是Object，连function也是。所以说function可以当成参数传入其他function，也可以将function当成结果回传。

def run_something(func, a, b):
    print(func(a, b))
def add(a, b):
    return a + b
run_something(add, 2, 3)  #5
test = add
test(3,5)  #8

内部函数

function内部可以再定义function

def outer(a, b):
    def inner(c, d):
        return c + d
    return inner(a, b)
print(outer(4, 7))  #11

闭包

可以动态生成函數，可用来记录外部传入的变量

def knights2(saying):
    def inner2():
        return "We are the knights who say: '%s'" % saying
    return inner2
a = knights2('XDD')
print(a())  #We are the knights who say: 'XDD'

lambda()

当想要传入一个小function作为使用时，却又不想定义出来，可以使用匿名函数。

def edit_story(words, func):
    for word in words:
        print(func(word))
stairs = ['thud', 'meow', 'thud', 'hiss']
def enliven(word):
    return word.capitalize() + '!'
# 原做法
edit_story(stairs, enliven)
print('-----')
# 匿名函数做法
edit_story(stairs, lambda word: word.capitalize() + '!')

Generators生成器

生成器是用来创建一个序列object，但是又不用需要事前把整个序列存入内存中，会随着每次执行而改变数值，每次循环生成器时，它会记录上一次调用的位置，并返回下一个值，这一点和普通的函数是不一样的，一般函數都不记录前一次调用用，而且都会在函数的第一行开始执行。內建的range()就是一种生成器。

# 自制range函数
def my_range(first=0, last=10, step=1):
    number = first
    while number < last:
        yield number
        number += step
ranger = my_range(1, 5)
for x in ranger:
    print(x)
print('------')
print(my_range)
for x in my_range(1, 5):
    print(x)

Namespace 与Scope 命名空间与作用域

在主程序main()中的变量称为全局变量，可以在函数中调用，但不能改变它。在函数内出现与全局变量相同名称的变量则是另一个不同的变量，则可以改变值。

animal = 'fruitbat'
def print_global():
    print('inside print_global:', animal)
print('可以在函数内调用全部变量。')
print_global()
def change_and_print_global():
#    print('inside change_and_print_global:', animal)
    animal = 'wombat'
print('但无法改变他，会出错。')
# 可以尝试取消注释试试
change_and_print_global()
def change_and_print_global():
    animal = 'wombat'
    print('inside change_and_print_global:', animal)
print('\n若要在函数内使用相同名称的变量，且需不同于全局变量，必须先赋值方可使用。')
change_and_print_global()
print('\n若是在函数内想改变全局变量则使用 global即可')
def change_and_print_global():
    global animal
    animal = 'wombat'
    print('inside change_and_print_global:', animal)
change_and_print_global()
print('\n外面的同时也会被改变', animal)