python

Posted 2020-11-09 lihangfei

练习代码：

（1）https://gitee.com/pythonbigdata/pythonTest01/blob/master/Test/Def.py(变量函数的使用，以及大数据中需要使用的三个函数大数据)

（2）https://gitee.com/pythonbigdata/pythonTest01/blob/master/Test/Class.py(对类属性的使用以及调用)

#全局变量放在函数体外，局部变量放在函数体内，如果在函数体内使用全局变量(global)关键字

#可变类型的不用写global，为全局变量，不可变类型的需要global关键字

#当返回值为多个是，自动组装成为元组,或用多个变量接受

#使用reduce需要导入模块 from functools import reduce

#map的两种使用方式

#Python中方法也是一个对象

# 可以直接使用 tt为对象，tt(x)为调用方法

 

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段
2.语法：
def 函数名（参数列表）:
 函数体
 return XXX
可以返回多个值，返回的多个值组成一个元组，返回值加上一对中括号，则返回一个列表
函数分为定义和调用函数
练习：定义一个函数，实现两个数字的加、减、乘、除
3.可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
python 函数的参数传递：
不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
4.以下是调用函数时可使用的正式参数类型：
必需参数
关键字参数：关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict 字典
例：# 关键字参数:**kw
def person(name,age,**kw):
    print(‘name:‘,name,‘age:‘,age,‘other:‘,kw)
person(‘Frank‘,‘37‘)
person(‘Frank‘,‘37‘,city=‘Shanghai‘)
person(‘Frank‘,‘37‘,gender=‘M‘,job=‘Engineer‘)
也可以写成下面的简约形式：
extra = {‘city‘: ‘Beijing‘, ‘job‘: ‘Engineer‘}
person(‘Jack‘, 24, **extra)
注意kw获得的dict是extra的一份拷贝，对kw的改动不会影响到函数外的extra。
默认参数:(缺省参数)缺省参数必须写在后面,可以不指定参数名，但是顺序要保证，否则要指定参数名
#可写函数说明
def printinfo( name, age = 35 ):
 "打印任何传入的字符串"
 print ("名字: ", name);
 print ("年龄: ", age);
 return;
 
#调用printinfo函数
printinfo( age=50, name="runoob" );
print ("------------------------")
printinfo( name="runoob" );
不定长参数(可变参数):
可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple

def calc(numbers):
 sum = 0
 for n in numbers:
 sum = sum + n * n
 return sum
但是调用的时候，需要先组装出一个list或tuple：

>>> calc([1, 2, 3])
14
>>> calc((1, 3, 5, 7))
84
如果利用可变参数，调用函数的方式可以简化成这样：

>>> calc(1, 2, 3)
14
>>> calc(1, 3, 5, 7)
84
所以，我们把函数的参数改为可变参数：

def calc(*numbers):
 sum = 0
 for n in numbers:
 sum = sum + n * n
 return sum
定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数：

>>> calc(1, 2)
5
>>> calc()
0
如果已经有一个list或者tuple，要调用一个可变参数怎么办？可以这样做：

>>> nums = [1, 2, 3]
>>> calc(nums[0], nums[1], nums[2])
14
这种写法当然是可行的，问题是太繁琐，所以Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：

>>> nums = [1, 2, 3]
>>> calc(*nums)
14
*nums表示把nums这个list的所有元素作为可变参数传进去。这种写法相当有用，而且很常见。
参数组合
在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用，除了可变参数无法和命名关键字参数混合。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数/命名关键字参数和关键字参数。

比如定义一个函数，包含上述若干种参数：

def f1(a, b, c=0, *args, **kw):
 print(‘a =‘, a, ‘b =‘, b, ‘c =‘, c, ‘args =‘, args, ‘kw =‘, kw)

def f2(a, b, c=0, *, d, **kw):
 print(‘a =‘, a, ‘b =‘, b, ‘c =‘, c, ‘d =‘, d, ‘kw =‘, kw)
最神奇的是通过一个tuple和dict，你也可以调用上述函数：

>>> args = (1, 2, 3, 4)
>>> kw = {‘d‘: 99, ‘x‘: ‘#‘}
>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = () kw = {‘d‘: 99, ‘x‘: ‘#‘}
>>> args = (1, 2, 3)
>>> kw = {‘d‘: 88, ‘x‘: ‘#‘}
>>> f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {‘x‘: ‘#‘}
所以，对于任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。
return xxx,xxx,xxx
将返回一个元组
调用函数时返回几个值也可以用几个变量接收
def f3(a,b,c=0,d=None):
    print(c,d)
f3(1,2,d=5)#命名参数
def f4(a,b):
 a,b=11,12
    return a,b#当返回多个值时，自动组成一个元组
c,d=f4(1,2)#也可以使用多个变量接收


小结
Python的函数具有非常灵活的参数形态，既可以实现简单的调用，又可以传入非常复杂的参数。
默认参数一定要用不可变对象，如果是可变对象，程序运行时会有逻辑错误！
要注意定义可变参数和关键字参数的语法：
*args是可变参数，args接收的是一个tuple；
**kw是关键字参数，kw接收的是一个dict。
变量作用域：
全局变量与局部变量的作用域不同
生命周期不同
全局变量:
g_a=10
def test2():
    global g_a#告诉程序这里是一个全局变量
 g_a=20
    print(g_a)
def test3():
    print(g_a)
test2()
test3()
当全局变量和局部变量同名时，局部变量优先
局部变量
当列表和字典作为全局变量时，不用加global
匿名函数：
python 使用 lambda 来创建匿名函数
语法：lambda [arg1 [,arg2,.....argn]]:expression
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
sum(1,2)
def XXX(arg1,arg2):
 return arg1+arg2 
sum=XXX(10,20)
# 调用sum函数
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )

def add(a,b,fun):
    print(fun(a,b))
add(11,22,lambda arg1, arg2: arg1 - arg2)

# 定义函数（普通方式）
def func(arg):
 return arg + 1
  
# 执行函数
result = func(123)
  
# ###################### lambda ######################
# 定义函数（lambda表达式）
my_lambda = lambda arg : arg + 1
# 执行函数
result = my_lambda(123)
三个重要的大数据用到的函数：

fliter过滤条件满足的话才输出
>>> foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
>>> print filter(lambda x: x % 3 == 0, foo)
[18, 9, 24, 12, 27]

#map的两种使用方式

#Python中方法也是一个对象

# 可以直接使用 tt为对象，tt(x)为调用方法

>>> print map(lambda x: x * 2 + 10, foo)
[14, 46, 28, 54, 44, 58, 26, 34, 64]

#使用reduce做数字统计
>>> print reduce(lambda x, y: x + y, foo)

139 

三个重要的大数据用到的函数：
>>> foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
>>> print filter(lambda x: x % 3 == 0, foo)
[18, 9, 24, 12, 27]
>>> print map(lambda x: x * 2 + 10, foo)
[14, 46, 28, 54, 44, 58, 26, 34, 64]
>>> print reduce(lambda x, y: x + y, foo)
139
python map()
map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回。
举例说明，比如我们有一个函数f(x)=x%2，要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现
#使用lambda函数
案例1：
print map(lambda x: x % 2, range(7))
[0, 1, 0, 1, 0, 1, 0]
案例2：
li = [11, 22, 33]
new_list = map(lambda a: a + 100, li)
python filter():对于序列中的元素进行筛选，最终获取符合条件的序列
li = [11, 22, 33]
new_list = filter(lambda arg: arg > 22, li)
例如，要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，要编写一个判断奇数的函数：
def is_odd(x):
 return x % 2 == 1
然后，利用filter()过滤掉偶数：
>>>filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
结果：
[1, 7, 9, 17]
利用filter()，可以完成很多有用的功能，例如，删除 None 或者空字符串：
def is_not_empty(s):
 return s and len(s.strip()) > 0
>>>filter(is_not_empty, [‘test‘, None, ‘‘, ‘str‘, ‘ ‘, ‘END‘])
结果：
[‘test‘, ‘str‘, ‘END‘]
注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。
当rm为空时，默认删除空白符（包括‘\n‘, ‘\r‘, ‘\t‘, ‘ ‘)，如下：


>>> a = ‘ 123‘
>>> a.strip()
‘123‘


>>> a = ‘\t\t123\r\n‘
>>> a.strip()
‘123‘


练习：
请利用filter()过滤出1~100中平方根是整数的数，即结果应该是：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
方法：
import math
def is_sqr(x):
 return math.sqrt(x) % 1 == 0
print filter(is_sqr, range(1, 101))
结果：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
python reduce():对于序列内所有元素进行累计操作
li = [11, 22, 33]
result = reduce(lambda arg1, arg2: arg1 + arg2, li)
python中的reduce
 python中的reduce内建函数是一个二元操作函数，他用来将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给reduce中的函数 func()（必须是一个二元操作函数）先对集合中的第1，2个数据进行操作，得到的结果再与第三个数据用func()函数运算，最后得到一个结果。
如：
 def myadd(x,y):  
 return x+y  
 sum=reduce(myadd,(1,2,3,4,5,6,7))  
 print sum  
#结果就是输出1+2+3+4+5+6+7的结果即28
当然，也可以用lambda的方法，更为简单：
 sum=reduce(lambda x,y:x+y,(1,2,3,4,5,6,7))  
 print sum 
reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。 


例如，编写一个f函数，接收x和y，返回x和y的和：


def f(x, y):
 return x + y
调用 reduce(f, [1, 3, 5, 7, 9])时，reduce函数将做如下计算：


先计算头两个元素：f(1, 3)，结果为4；
再把结果和第3个元素计算：f(4, 5)，结果为9；
再把结果和第4个元素计算：f(9, 7)，结果为16；
再把结果和第5个元素计算：f(16, 9)，结果为25；
由于没有更多的元素了，计算结束，返回结果25。
上述计算实际上是对 list 的所有元素求和。虽然Python内置了求和函数sum()，但是，利用reduce()求和也很简单。


reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100，计算：
reduce(f, [1, 3, 5, 7, 9], 100)
结果将变为125，因为第一轮计算是：


计算初始值和第一个元素：f(100, 1)，结果为101。


练习：
Python内置了求和函数sum()，但没有求积的函数，请利用reduce()来求积：
输入：[2, 4, 5, 7, 12]
输出：2*4*5*7*12的结果


方法：
def prod(x, y):
 return x*y
print reduce(prod, [2, 4, 5, 7, 12])
结果：
>>>3360
python中自定义排序函数:
Python内置的 sorted()函数可对list进行排序：


>>>sorted([36, 5, 12, 9, 21])
[5, 9, 12, 21, 36]
但 sorted()也是一个高阶函数，它可以接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。




sorted()也可以对字符串进行排序，字符串默认按照ASCII大小来比较：


>>> sorted([‘bob‘, ‘about‘, ‘Zoo‘, ‘Credit‘])
[‘Credit‘, ‘Zoo‘, ‘about‘, ‘bob‘]
‘Zoo‘排在‘about‘之前是因为‘Z‘的ASCII码比‘a‘小。
.sort()排序方法
shus.sort()对原有列表进行排序，改变原来列表的顺序，无返回值
print(shus)就是改变后的列表
sorted()排序函数
排序时不影响原数据，产生新的排序数据
print(sorted(shus))排序后的结果
print(shus)还是原结果


练习：
对字符串排序时，有时候忽略大小写排序更符合习惯。请利用sorted()高阶函数，实现忽略大小写排序的算法。


输入：[‘bob‘, ‘about‘, ‘Zoo‘, ‘Credit‘]


>>> a = [‘bob‘, ‘about‘, ‘Zoo‘, ‘Credit‘]
>>> print(sorted(a, key=str.lower))


结果：
[‘about‘, ‘bob‘, ‘Credit‘, ‘Zoo‘]