python基础篇{函数}

 python基础学习路线：

   · 数据分析之python基础篇{基础语法}
   · 数据分析之python基础篇{数据类型}
   · 数据分析之python基础篇{控制流语句}
   · 数据分析之python基础篇{函数}
   · 数据分析之python基础篇{模块}
   · 数据分析之python基础篇{文件操作}
   · 数据分析之python基础篇{Pymysql}
   · 数据分析之python基础篇{面向对象}

常用内置函数

  全部的内置函数在这个连接,有一些平时很少会用到,我们只讲一些常用的.

   内置函数

数据类型相关

• type()：函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
• int()：int() 函数用于将一个字符串或数字转换为整型。
• float() ：float() 函数用于将整数和字符串转换成浮点数。
• str() ：str() 函数将对象转化为适于人阅读的形式。
• bool()：bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回 False。
• list() ：list() 方法用于将元组或字符串转换为列表。

   注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

• tuple() ：tuple 函数将可迭代系列（如列表）转换为元组。
• dict() ：dict() 函数用于创建一个字典。
• set()：set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

数学相关

• max() ：最大值
• min() ：最大值
• sum() ：加和

   sum()函数，只允许一个参数，加入要实现多数相加，括号内需要是列表。可以理解为一个列表为一个参数

• abs() ：绝对值
• pow() ：次方
• round() ：四舍五入
• bin() ：将整数转换成二进制
• divmod()： 同时取得整除值和余数值

其他

• input() 获取用户输入
• print() 打印
• id() 查看变量的内存地址
• ord() 将字母转换成对应数字
• chr() 将数字转换成对应字母

逻辑判断相关

• all()：函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。 元素除了是 0、空、FALSE 外都算 TRUE
• any()：函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。 元素除了是 0、空、FALSE 外都算 TRUE。

序列相关

• range() ：生成整数序列
• len() ：计算序列长度
• enumerate()： 枚举序列, 同时返回序列的索引值和储存值
• reversed()： 翻转
• sorted() ：排序
• filter() ：过滤
• map() ：映射

函数

  函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内置函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

  自定义函数的格式如下：

def 函数名(参数列表):
    代码

  比如说：

命名规则:

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
• 任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。函数内容以冒号 : 起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方，不带表达式的 return 相当于返回 None

函数调用

  定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。这个函数的基本结构完成以后，你可以通过函数名调用执行。

def 函数名(参数1，参数2):
    函数运行的代码
# 函数调用
函数名(参数1，参数2)

  比如说：

# 定义函数
def printme( str ):
   # 打印任何传入的字符串
   print (str)
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数"

	运行结果：我要调用用户自定义函数！
	　　　　　再次调用同一函数

# 计算面积函数
def area(width, height):
    return width * height
 
def print_welcome(name):
    print("Welcome", name)
 
print_welcome("Runoob")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))

	运行结果：Welcome Runoob
	         width = 4  height = 5  area = 20

return

  return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。

  举一个例子：假如说定义了一个函数，完成了获取室内温度，那么函数当然应该把温度值返回给调用函数的人，只有调用者拥有了这个返回值，才能够根据当前的温度做适当的调整.这就是函数返回值的作用

def sum( arg1, arg2 ):
   # 返回2个参数的和."
   total = arg1 + arg2
   print ("函数内 : ", total)
   return total
 
# 调用sum函数
total = sum( 10, 20 )
print ("函数外 : ", total)

	运行结果：函数内 :  30
	         函数外 :  30

 return 的一个注意事项

  当函数中的代码运行到 return,则函数向调用它的代码送回返回值, 函数结束.不管函数后面还有什么代码, 都不会再被运行了.

def add2num(a, b):
    c = a+b
    return c
    d = a*b
    print(d)
add2num(1,2)

	运行结果：3

 返回多个值

  有的时候, 我们可能会需要函数同时返回多个值, 这个时候应该如何处理呢?

def divid(a, b):
    shang = a//b
    yushu = a%b 
    return shang, yushu
print(divid(5, 2))
sh, yu = divid(5, 2)
print(sh)
print(yu)

	运行结果：(2, 1)
	          2
	          1

   根据代码，我们不难发现，当return返回多个值，会自动生存元组。

函数参数

  对于大型的项目, 比较长的代码, 即使是代码的编写者也不可能对内部的每个逻辑记得很清楚.这个时候很有可能读不懂代码到底都在写一些什么东西了.但是对于一个封装好的函数, 我们只需要知道函数需要传入的参数, 以及函数输出的结果就可以了, 并不需要了解内不是如何实现这一功能的.就是把函数当成一个黑匣子来看待.这样就大大简化了程序开发的难度, 所以这也是使用函数的一个很便捷的地方.

  以下是调用函数时可使用的正式参数类型：

• 位置参数
• 关键字参数
• 默认参数
• 可变长参数

  定义时小括号中的参数，用来接收参数用的，称为 “形参”
  调用时小括号中的参数，用来传递给函数用的，称为 “实参”

 位置参数

  调用函数时，要按照函数设定的顺序依次传入的参数称为位置参数

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
power(2,4) #位置传参

	运行结果：16

  power(x, n)函数有两个参数：x和n，这两个参数都是位置参数，

  调用函数，除默认参数外 ，你必须要传入其他参数，不然会出现语法错误，比如上面的例子，power(2)就会报错

#可写函数说明
def printme( str ):
   "打印任何传入的字符串"
   print (str)
   return
 
# 调用 printme 函数，不加参数会报错
printme() 

 关键字参数

  使用关键字参数允许函数调用时参数的顺序与声明时不一致， 因为 Python 解释器能够用参数名匹配参数值。

#可写函数说明
def printinfo( name, age ):
   "打印任何传入的字符串"
   print ("名字: ", name)
   print ("年龄: ", age)
   return
 
#调用printinfo函数
printinfo( age=50, name="runoob" ) # 关键字传参

	运行结果：名字:  runoob
	         年龄:  50

 默认参数

  调用函数时，如果没有传递参数，则会使用默认参数。、

def power(x, n=2): # 因为我们最常计算的是2次方, 因此设置默认参数n=2
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
power(3)

	运行结果：9

如果，不想使用默认参数，可以直接在函数调用上进行修改。、

def power(x, n=2): 
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s
power(3,3)

	运行结果：27

 可变长参数

  可变参数, 就是当我们定义函数的时候还不知道具体需要传入多少个参数, 或者参数太长了不方便写.可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。

  加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。

def change_sum(*args): # * 会自动将传入进来的所有参数，打包成一个元组 
    print(args)
change_sum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

	 运行结果：(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

# 进一步
def total_sum2(*args):
    a = 0
    for i in args:
        a += i
    print(a)
total_sum2(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

	运行结果：55

# 可写函数说明
def printinfo( arg1, *vartuple ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vartuple)
 
# 调用printinfo 函数
printinfo( 70, 60, 50 )

	运行结果：输出：
	         70
	         (60, 50)

  **参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。

  
# 可写函数说明
def printinfo( arg1, **vardict ):
   "打印任何传入的参数"
   print ("输出: ")
   print (arg1)
   print (vardict)
# 调用printinfo 函数
printinfo(1, a=2,b=3)

	运行结果：输出: 
	         1
	         {'a': 2, 'b': 3}

def test(**kwarges):
    print(kwarges)
test(qqqq=100,abc='nihao',c=[1,2,3])

	运行结果：{'qqqq': 100, 'abc': 'nihao', 'c': [1, 2, 3]}

def fun(a, b, *args, **kwargs):
    """可变参数演示示例"""
    print ("a =", a)
    print ("b =", b) 
    print ("args =", args)
    print ("kwargs: ",kwargs)
    print("kwargs: ")
    for key, value in kwargs.items():
        print (key, "=", value)
fun(1, 2, 3, 4, 5, m=6, n=7, p=8)

	运行结果：a = 1
	         b = 2
	         args = (3, 4, 5)
	         kwargs:  {'m': 6, 'n': 7, 'p': 8}
	         kwargs: 
	         m = 6
	         n = 7
	         p = 8

全局变量与局部变量

 局部变量

  就是在函数内部定义的变量

a = 200 # 全局变量
def test1():
    a = 300 #局部变量
    print("在test1中a=", a)
    
def test2():
    a = 400 #局部变量
    print("在test2中a=", a)
    
test1()
test2()
print(a)

	运行结果：在test1中a= 300
             在test2中a= 400
             200

  不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
  局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储，这就是它的作用

 全局变量

  如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量， 全局变量能够在所有的函数中进行访问

def test1():
    print(a)

def test2():
    b = 1000
    
    print(a+b)

# 调用函数
test1()
test2()

	运行结果：100
	         1100

 全局变量和局部变量名字相同问题

# 定义全局变量
a = 100
def test1():
    a = 300
    print("test1中a是: ", a)
def test2():
    print("test2中a是: ", a)
test1()
test2()
print(a)

	运行结果：test1中a是:  300
	         test2中a是:  100
	         100

  根据上面的代码，我就可以发现，全局变量可以直接在函数体里直接使用。但是局部变量不可以在函数体外使用。 且如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量

 修改全局变量

a = 1
def f():
    a += 1   # 在函数内部可以去使用全局变量，但是不能修改全局变量
    print (a)

f()

  这样代码会报错。在函数内部可以去使用全局变量，但是不能修改全局变量,除非，使用global可修改全局变量

# 定义全局变量
a = 100
def test1():
    global a# 要改变全局变量a
    a = 300
    print("test1中a是: ", a)
def test2():
    print("test2中a是: ", a)
test1()
test2()
print(a)

	运行结果：test1中a是:  300
	         test2中a是:  300
	         300

  如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错

 可变类型的全局变量

  可变类型主要是指列表

li = [1,2,3]  # 可变的数据类型可以不用声明，就可以修改
def f2():
    li.append(4)
    print (li)
f2()

	运行结果：[1, 2, 3, 4]

# 可写函数说明
def changeme( mylist ):
   "修改传入的列表"
   mylist.append([1,2,3,4])
   print ("函数内取值: ", mylist)
   return
 
# 调用changeme函数
mylist = [10,20,30]
changeme( mylist )
print ("函数外取值: ", mylist)

	运行结果：函数内取值:  [10, 20, 30, [1, 2, 3, 4]]
	         函数外取值:  [10, 20, 30, [1, 2, 3, 4]]

练习

  练习一：定义一个函数，完成前2个数完成加法运算，然后对第3个数，进行减法；然后调用这个函数

def calculation(a,b,c):
    d = a + b
    e = d - c
    return e 
calculation(9,7,8)

  练习二：完成一个函数, 功能和abs相同

def absolute():
    a = float(input('请输入一个数字：'))
    if a <= 0:
        a = -a
    return a
absolute()

  练习三：完成一个函数功能和sum相同

def summe(x_list):
    n = 0
    for i in x_list:
        n += i
    return n
summe([1,2,3])

  练习四：函数功能: 可以根据输入分数来输出不同的等级学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。

def level(i):
    if i >= 90:
        return 'A'
    elif 60 < i < 89:
        return 'B'
    elif i <= 60:
        return 'C'
i = float(input('请输入分数：'))
level(i)

  练习五：写函数，检查传入列表的长度，如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

L = [4, 5, 6, 7, '3434']
L1 = [3, 4]
def cal_list_lenth(x):
    if len(x) > 2:
        return x[0:2]
    else:
        return x 

  练习六：写函数，检查传入字典的每一个value的长度,如果大于2，那么仅保留前两个长度的内容，并将新内容返回给调用者。

dic = {"k1": "v1v1", "k2": [11,22,33,44], 'k3':'gogogo'}
def get_the_dic(x):
    for i, j in x.items():
        if len(j) > 2:
            x[i] = j[0:2]
    return x
get_the_dic(dic)

  练习七：给定一组数字a，b，c……，请计算$a^2+b^2+c^2+\dots \dots$

def pingfang(*args):
    n = 0
    for i in args:
        n += (i**2)
    return n
pingfang(3,4)