python手册学习笔记1

笔记1

> http://www.pythondoc.com/pythontutorial3/controlflow.html

• 参数传递 Python中sys.argv的用法

调用解释器时，脚本名和附加参数传入一个名为 sys.argv 的字符串列表。你可以获取这个列表经过执行 import sys，列表的长度大于等于1；没有给定脚本和参数时，它至少也有一个元素：sys.argv[0] 此时为空字符串。脚本名指定为 '-' （表示标准输入）时， sys.argv[0] 被设定为 '-'，使用 -c 指令 时，sys.argv[0] 被设定为 '-c'。使用 -m 模块 参数时，sys.argv[0] 被设定为指定模块的全名。-c 指令 或者 -m 模块 以后的参数不会被 Python 解释器的选项处理机制所截获，而是留在 sys.argv 中，供脚本命令操做。

*test.py*
import sys
print(sys.argv)
print(sys.argv[1]

>>>python test.py -c -m
...['test.py','-c','-m']
...-c

• 字符串替换

Python replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，若是指定第三个参数max，则替换不超过 max 次。

str.replace(old, new[, max])

• old -- 将被替换的子字符串。
• new -- 新字符串，用于替换old子字符串。
• max -- 可选字符串, 替换不超过 max 次

a = 'hello world'
b = a.replace('world','python')
print(b)

...hello python

• enumerate() 函数

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，通常用在 for 循环当中。

enumerate(sequence, [start=0])

• sequence -- 一个序列、迭代器或其余支持迭代对象。
• start -- 下标起始位置。

a = ['abc','def','ghi']
b = list(enumerate(a))
print(b)
for i,j in enumerate(a):
    print(i,j)

...[(0, 'abc'), (1, 'def'), (2, 'ghi')]
...0 abc
...1 def
...2 ghi

实际上enumerate就是个可迭代对象，可用如下方法实现：

def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

• 循环中的 else 子句

循环能够有一个 else 子句；它在循环迭代完整个列表（对于 for ）或执行条件为 false （对于 while ）时执行，但循环被 break 停止的状况下不会执行。如下搜索素数的示例程序演示了这个子句:

for n in range(2, 10):
     for x in range(2, n):
         if n % x == 0:
            print(n, 'equals', x, '*', n//x)
            break
     else:
         print(n, 'is a prime number')

...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

• 文档字符串

函数体的第一行语句能够是可选的字符串文本，这个字符串是函数的文档字符串，或者称为 docstring。（更多关于 docstrings 的信息请参考 文档字符串） 有些工具经过 docstrings 自动生成在线的或可打印的文档，或者让用户经过代码交互浏览；在你的代码中包含 docstrings 是一个好的实践，让它成为习惯吧。

def test():
    '''
    doc test
    '''   
    print('test')
    
print(test.__doc__)

... doc test

• 函数变量

函数 调用 会为函数局部变量生成一个新的符号表。确切的说，全部函数中的变量赋值都是将值存储在局部符号表。变量引用首先在局部符号表中查找，而后是包含函数的局部符号表，而后是全局符号表，最后是内置名字表。所以，全局变量不能在函数中直接赋值（除非用 global 语句命名），尽管他们能够被引用。

函数引用的实际参数在函数调用时引入局部符号表，所以，实参老是 传值调用 （这里的 值 老是一个对象 引用 ，而不是该对象的值）。 一个函数被另外一个函数调用时，一个新的局部符号表在调用过程当中被建立。

一个函数定义会在当前符号表内引入函数名。函数名指代的值（即函数体）有一个被 Python 解释器认定为 用户自定义函数 的类型。 这个值能够赋予其余的名字（即变量名），而后它也能够被当作函数使用。这能够做为通用的重命名机制:

def test():
    print('test')

>>>test
...<function test at 10042ed0>
>>>f = test
>>>f
...test

----------
a = 100
def test(n):
    a = 200
    print('test%d%d'%(n,a))
test(3)
print (a)

...test3200
...100

----------
a = 100
def test(n):
    global a
    a = 200
    print('test%d%d'%(n,a))
test(3)
print (a)

...test3200
...200

• 函数的位置参数与关键字参数

• 位置参数：调用函数时根据函数定义的参数位置来传递参数

def test(a,b=100,c='haha'):
    print(a,b,c)
test(2)# positional argument

...2 100 haha

• 关键字参数：用于函数调用，经过“键-值”形式加以指定。可让函数更加清晰、容易使用，同时也清除了参数的顺序需求,在函数调用中，关键字的参数必须跟随在位置参数的后面。传递的全部关键字参数必须与函数接受的某个参数相匹配，它们的顺序并不重要。这也包括非可选参数。任何参数都不能够屡次赋值。

正确的调用
test(2,b=50) # 1 positional, 1 keyword
test(a=5,c='hahaha')# 2 keyword arguments

错误的调用
test(b=50)
test(c='hahha',5)
test(5,a=10)

• 可变参数

引入一个形如name 的参数时，它接收一个字典，该字典包含了全部未出如今形式参数列表中的关键字参数。这里可能还会组合使用一个形如 name 的形式参数，它接收一个元组，包含了全部没有出如今形式参数列表中的参数值（ name 必须在 name 以前出现）。

def test(a,*b,**c):
    print(a)
    print(b)
    print(c)
test('a','dsad','dasdad',k='weqeq',y='werrq')

...a
...('dsad', 'dasdad')
...{'k': 'weqeq', 'y': 'werrq'}

• 参数列表的分拆

另有一种相反的状况: 当你要传递的参数已是一个列表，但要调用的函数却接受分开一个个的参数值。这时候你要把已有的列表拆开来。例如内建函数 range() 须要要独立的 start，stop 参数。你能够在调用函数时加一个 * 操做符来自动把参数列表拆开:

a = [1,10]
b = range(*a)
print(list(b))

...[1, 2, 3, 4, 5, 6, 7, 8, 9]

以一样的方式，可使用 ** 操做符分拆关键字参数为字典:

tmp = {'a':10,'b':20}
def test(a,b):
    print(a,b)
test(**tmp)

...10 20

• 匿名函数

lambda表达式，一般是在须要一个函数，可是又不想费神去命名一个函数的场合下使用，也就是指匿名函数。

def get_y(a,b):
     return lambda x:ax+b
y1 = get_y(1,1)

>>>y1(1)
...2

• 获取对象属性并执行

getattr() 是 python 的内建函数，getattr(object,name) 就至关于object.name可是这里 name 能够为变量

def test(a,b):
    '''
    dsadad
    '''
    print(a,b)
def get(n):
    for i in dir(n):
        print(getattr(test,i))
get(test)

• 函数注解

函数注解在定义函数的时候对参数和返回值添加注解

• a: int 这种是注解参数
• c: str = 5 是注解有默认值的参数
• -> tuple 是注解返回值。

def test(a: int, b: "it's b", c: str = 5) -> tuple:
    return a, b, c
print(test.__annotations__)

...{'a': int, 'b': "it's b", 'c': str, 'return': tuple}