python基础 - 函数

def (arg1, arg2, ...argN):
    statements
    return 

当返回值数 = 0; 返回None
当返回值数 = 1; 返回object
当返回值数 > 1; 返回tuple

# python 函数的参数传递：
　　不可变类型参数“通过值”传递：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
   可变类型参数通过“指针”传递：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
   python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

Python传递不可变对象实例：

#!/usr/bin/env python
#-*- coding:utf-8 -*-
def change(a):
    a = 5
    print(a)  ## 结果输出为 5
b = 20
change(b)
print(b)  ## 结果为20

实例int对象2 指向他的变量是b, 在传递给change函数时，按传值的方式复制了变量b, a和b都指向了同一个int对象类型， 在a = 5时 则是新生成了一个int值对象为10， 并让a指向它。

Python传递可变对象实例：

#!/usr/bin/env python
#-*- coding:utf-8 -*-
def change1(a):
    a.append("Python")
    print(a)

L = ["C", "C++", "JAVA"]
change1(L)
print(L)

#输出结果为：
    [‘C‘, ‘C++‘, ‘JAVA‘, ‘Python‘]
    [‘C‘, ‘C++‘, ‘JAVA‘, ‘Python‘]

# name 叫做函数func的形式参数，简称：形参
def func(name):
    print name

# ######### 执行函数 ######### 
#  ‘linux‘ 叫做函数func的实际参数，简称：实参
func(‘linux‘)

# 1. 在执行函数指定实参时，指定参数名传入参数，不需要按顺序

#!/usr/bin/env python
#-*- coding:utf-8 -*-
def printinfo(name, age):
    "打印任何传入的字符串"
    print("Name:%s" % name)
    print("Age:%d" % age)
    return

# 调用printinfo函数
printinfo(age=50, name="gg")

 1 #!/usr/bin/env python
 2 #-*- coding:utf-8 -*-
 3 def personalinfo(name, age, address="Beijing"):
 4     print("name: %s\tage: %d\taddress: %s" % (name, age, address))
 5 
 6 personalinfo("xiaoming", 25)
 7 personalinfo("kiki", 28, "Zhengzhou")
 8 #结果：
 9 name: xiaoming    age: 25    address: Beijing
10 name: kiki    age: 28    address: Zhengzhou

def functionname([formal_args,] *var_args_tuple ):
   "函数_文档字符串"
   function_suite
   return [expression]
其中“*” 的变量名会存放所有未命名的变量参数。 如

#!/usr/bin/env python
#-*- coding:utf-8 -*-
def printinfo1(name, *info):
    print(name)
    print(info)
    return
?
printinfo1("xiaoming")
printinfo1("xm", "kiki", "coco", "cici", "yoo")
infolist = ["kiki", "coco", "cici", "yoo"]
printinfo1("xiaoming", *infolist) # 加“*”将列表值传入至函数中
?
#结果: 
xiaoming
()
xm
(‘kiki‘, ‘coco‘, ‘cici‘, ‘yoo‘)
xiaoming
(‘kiki‘, ‘coco‘, ‘cici‘, ‘yoo‘)

def person(name, age, **kw):
    print(‘name:‘, name, ‘age:‘, age, ‘other:‘, kw)
    函数person除了必选参数name和age外，还接受关键字参数kw。在调用该函数时，可以只传入必选参数
    >>> person(‘Michael‘, 30)
    name: Michael age: 30 other: {}
关键字参数kw，是将dict 的所有k,v用关键字参数传入函数的中， kw 将获取一个dict.   

#!/usr/bin/env python
#-*- coding:utf-8 -*-
def person(name, age, **info):
    print("name:", name, "age:", age, ‘other:‘, info)
?
person("kk", 28, address="bj", phone="xxxx123", mail="xx@oo.com")
person("zc", 29, **{"address": "bj", "phone": "xxxx123", "mail": "xx@oo.com"})
?
#结果：
name: kk age: 28 other: {‘address‘: ‘bj‘, ‘phone‘: ‘xxxx123‘, ‘mail‘: ‘xx@oo.com‘}
name: zc age: 29 other: {‘address‘: ‘bj‘, ‘phone‘: ‘xxxx123‘, ‘mail‘: ‘xx@oo.com‘}

参数定义的顺序必须是：普通参数、默认参数、可变参数、命名关键字参数和关键字参数。
def f1(a, b, c=0, *args, **kw):
    print(‘a =‘, a, ‘b =‘, b, ‘c =‘, c, ‘args =‘, args, ‘kw =‘, kw)

# 根据变量的作用域，可以将变量分为全局变量和局部变量。
定义在函数内部的变量拥有一个局部的作用域
在函数外的变量拥有全局作用域
?
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。
?
全局变量：
1. 全局变量是位于模块文件内部的顶层的变量名；
2. 全局变量如果在函数内部被赋值的话，必须经过声明；
3. "全局变量名"在函数内部不经过声明也可以被引用。

#!/usr/bin/env python
#-*- coding:utf-8 -*-
total = 0  # 这是一个全局变量
# 可写函数说明
def sum(arg1, arg2):
    # 返回2个参数的和."
    total = arg1 + arg2  # total在这里是局部变量. "使用的全局变量名"
    print("函数内是局部变量 : ", total)
    return total
?
# 调用sum函数
sum(10, 20)
print("函数外是全局变量 : ", total)
?
结果：
函数内是局部变量 :  30
函数外是全局变量 :  0

如果想修改一个全局变量：
错误示例：
money = 100
def shoping():
   g_price = 20
   money -= g_price
   print(money)
shoping()
?
会提示错误：UnboundLocalError: local variable ‘money‘ referenced before assignment
    
修改后：
money = 100
def shoping():
    global money
    g_price = 20
    money -= g_price
    print(money)
shoping()
结果为：80

# 匿名函数
f = lambda x: x*x
f(4)
16
关键字lambda表示匿名函数，冒号前面的x表示函数参数。
# 返回函数
def foo():
    name="kc"
    def bar():
        name="ll"
        def tt():
            print(name)
        return tt
    return bar
?
foo()()()

# map()函数
    map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。
如：
    s = map(lambda x: x*2, [1,2,3,4,5])
    print(list(s)) ## 结果为：[2,4,6,8,10]
    由于结果r是一个Iterator，Iterator是惰性序列，因此通过list()函数让它把整个序列都计算出来并返回一个list。
# reduce() 函数

　　需要导入：from functools import reduce

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

##引出reduce 函数示例：
-----------------------------------------------------------------------
初始：
l = [3, 2, 10, 2]
# lambda x, y: x * y
def reduce_test(arr):
    res = 1
    for i in arr:
        res *= i
    return res
?
print(reduce_test(l))
这样写太局限，只能算两个数的乘法
--------------------------------------------------------------------------------
修改：
 l = [3, 2, 10, 2]
 def reduce_test(func, arr):
     res = arr.pop(0)
     for i in arr:
         res = func(res, i)
     return res
?
 print(reduce_test(lambda x, y: x*y, l))
 print(reduce_test(lambda x, y: x+y, l))
 print(reduce_test(lambda x, y: x/y, l))
 print(reduce_test(lambda x, y: x%y, l))
--------------------------------------------------------------------------------
再修改：
l = [3, 2, 10, 2]
def reduce_test(func, arr, init_n=None):
    if init_n is None:
        res = arr.pop(0)
    else:
        res = init_n
    for i in arr:
        res = func(res, i)
    return res
?
print(reduce_test(lambda x, y: x*y, l, 100))
--------------------------------------------------------------------------------
#!/usr/bin/env python
#-*- coding:utf-8 -*-
from functools import reduce    
def add(x, y):
    return x + y
l = reduce(add, [1, 2, 3, 34, 44, 54, 65, 5])
print(l)  ##结果： 208

## 1.将数字列表转换为整数，如[14,59,1,3,2] 转为1459132
?
#!/usr/bin/env python
#-*- coding:utf-8 -*-
from functools import reduce
def fm(x, y):
    return x * 10 + y
s = reduce(fm, [12,3,4,9,88])
print(s)  ##结果：123578
?
## 2. 将str转为int
#!/usr/bin/env python
#-*- coding:utf-8 -*-
from functools import reduce
digits1 = {‘0‘: 0, ‘1‘: 1, ‘2‘: 2, ‘3‘: 3, ‘4‘: 4, ‘5‘: 5, ‘6‘: 6, ‘7‘: 7, ‘8‘: 8, ‘9‘: 9}
def str2int(strings1):
    def fh(x, y):
        return x * 10 + y
    def char2int(s1):
        return digits1[s1]
    return reduce(fh, map(char2int, strings1))
?
result = str2int("76887612")
print(result)

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
filter函数的语法：
    filter(function, iterable) 第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
    Python3.x 返回迭代器对象，

#功能相近的函数：
mList = ["as_sfas","axjks_python", ‘python‘, "linx", ‘nihao‘]
def show(s):
    return s.endswith("python")
def filter_test(func, arr):
    new_l = []
    for i in arr:
        if not func(i):
            new_l.append(i)
    return new_l
res = filter_test(show, mList)
print(res)
?
或者输入： filter_test(lambda n: n.endswith("python"), mList)
?
使用filter() 函数：
print(list(filter(lambda x: not x.endswith("python"), mList)))  结果和上述一样
?
## 示例1
def is_odd(n):
    eturn n % 2 == 1
res1 = list(filter(is_odd, [1, 3, 2, 4, 6, 21, 32, 45, 76]))
print(res1) ## 结果：[1, 3, 21, 45]

>>> dir(__builtins__) 可以查看内置函数
?
# 1. all()函数
    用于判断给定的可迭代对象中的元素是否都为true， 是返回True， 否返回False
    元素除了是 0、空、None、False 外都算 True。
    函数等价于：
    def all_test(iterable):
    for e in iterable:
        if not e:
            return False
    return True
    语法：all(iterable)
# 2. any()函数 用于判断给定的可迭代参数 iterable 是否全部为 False， 是返回False， 一个为True，则为True
# 3. bin(number) 转为二进制
# 4. bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
# 5. bytes() 
     bytes(iterable_of_ints) -> bytes
     bytes(string, encoding[, errors]) -> bytes
     bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
     bytes(int) -> bytes object of size given by the parameter initialized with null bytes
     bytes() -> empty bytes object
    
        >>> bytes("zkchang", encoding=‘utf-8‘)   # 字符串 编码 
        b‘zkchang‘
        >>> bytes("中国", encoding=‘utf-8‘)# 字符串 编码 
        b‘\xe4\xb8\xad\xe5\x9b\xbd‘
        >>> bytes("中国", encoding=‘utf-8‘).decode()  ## 解码
        ‘中国‘
        ## 用什么编码， 就用什么解码
            >>> bytes("中国",encoding=‘gbk‘)
            b‘\xd6\xd0\xb9\xfa‘
            >>> bytes("中国",encoding=‘gbk‘).decode(‘gbk‘)
            ‘中国‘
# chr() 转化为Ascii码  ord()函数功能与chr() 相反
    >>> chr(1)
    ‘\x01‘
    >>> chr(110)
    ‘n‘
# divmod() 函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组(a // b, a % b)。
    >>> divmod(10,3)
    (3, 1)
# eval() 函数用来执行一个字符串表达式，并返回表达式的值
    eval(expression[, globals[, locals]])
        expression -- 表达式。
        globals -- 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
        locals -- 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
    >>> eval(‘3*4‘)
    12
    >>> g = {‘num‘:2}
    >>> eval(‘num + 2‘,g)
    4
    >>> g = {‘num1‘:2}
    >>> l = {‘num2‘:4}
    >>> eval(‘num1+num2‘,g,l)
    6
# hash() 用于获取取一个对象（字符串或者数值等）的哈希值。
    可哈希的数据类型为不可变数据类型
    >>> hash([1,2,3])
    Traceback (most recent call last):
      File "", line 1, in 
    TypeError: unhashable type: ‘list‘
    >>> hash((1,2,3))
    529344067295497451
    
# hex() 转换为十六进制
    >>> hex(10)
    ‘0xa‘
# oct() 转换为八进制
?
#  isinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。
    isinstance(object, classinfo)
    >>>a = 2
    >>> isinstance (a,int)
    True
?
# iter() 函数用来生成迭代器。
    iter(object[, sentinel])
# globals() 打印全局变量   
  locals() 打印局部变量
    print(__file__)  打印所在文件的路径
    
# max()
    max(...)
    max(iterable, *[, default=obj, key=func]) -> value
    max(arg1, arg2, *args, *[, key=func]) -> value
# min()
    min(...)
    min(iterable, *[, default=obj, key=func]) -> value
    min(arg1, arg2, *args, *[, key=func]) -> value
    
    people = [
        {"name": "xiaoming", "age": 20},
        {"name": "ront", "age": 21},
        {"name": "root", "age": 39},
        {"name": "ss", "age": 90}
    ]
?
    print(max(people, key=lambda dic: dic["age"]))  # 结果：{‘name‘: ‘ss‘, ‘age‘: 90}
    
## reversed() 取反 
    >>> l = [4,2,5,6,91,2]
    >>> list(reversed(l))
    [2, 91, 6, 5, 2, 4]
   
## round()  四舍五入
    >>> round(4.7)
    5
## sorted 排序， 用户和max() min() 函数相似
    people = [
        {"name": "xiaoming", "age": 20},
        {"name": "ront", "age": 21},
        {"name": "root", "age": 39},
        {"name": "ss", "age": 90}
    ]
?
    print(max(people, key=lambda dic: dic["age"]))
    print(sorted(people, key=lambda dic: dic["age"]))
    print(sorted(people, key=lambda dic: dic["age"], reverse=True))
    结果：
    {‘name‘: ‘ss‘, ‘age‘: 90}
    [{‘name‘: ‘xiaoming‘, ‘age‘: 20}, {‘name‘: ‘ront‘, ‘age‘: 21}, {‘name‘: ‘root‘, ‘age‘: 39}, {‘name‘: ‘ss‘, ‘age‘: 90}]
    [{‘name‘: ‘ss‘, ‘age‘: 90}, {‘name‘: ‘root‘, ‘age‘: 39}, {‘name‘: ‘ront‘, ‘age‘: 21}, {‘name‘: ‘xiaoming‘, ‘age‘: 20}]