码迷,mamicode.com
首页 > 编程语言 > 详细

python基础 - 函数

时间:2020-11-12 13:49:53      阅读:8      评论:0      收藏:0      [点我收藏+]

标签:另一个   code   返回值   last   err   michael   comment   plain   model   

 

一、函数

1.1 def语句

def语句一般格式如下:

def <name>(arg1, arg2, ...argN):
    statements
    return <value>

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

1.2 函数参数传递

# 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.3 作用域

变量的作用域

# 根据变量的作用域,可以将变量分为全局变量和局部变量。
定义在函数内部的变量拥有一个局部的作用域
在函数外的变量拥有全局作用域
?
局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。调用函数时,所有在函数内声明的变量名称都将被加入到作用域中。
?
全局变量:
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

global语句

global语句包含了关键字global,其后跟着一个或多个有逗号分开的变量名。

如果想修改一个全局变量:
错误示例:
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

1.4 递归函数

 

1.5 匿名函数 与返回函数

# 匿名函数
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()()()

1.6 map/reduce

# 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)

1.7 filter

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]

二、Python内置函数

>>> 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)   # 字符串 编码 
        bzkchang
        >>> 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 "<stdin>", line 1, in <module>
    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}]
   

 


   

 

 

python基础 - 函数

标签:另一个   code   返回值   last   err   michael   comment   plain   model   

原文地址:https://www.cnblogs.com/kaic/p/13796819.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!