Python学习笔记(二）函数

函数其实就是我们叫的方法、api

常用的Python内置函数：

函数	作用	参数
abs()	绝对值	正负小数
max()	最大值	任意多个，逗号隔开
len()	元素长度	str、list、dict、set等

暂时知道这些，后面再补

数据类型转换

Python内置的常用函数还包括数据类型转换函数，比如int()函数可以把其他数据类型转换为整数：

1. 整数
   int(‘123’)
   123
   int(12.34)
   12
2. 浮点
   float(‘12.34’)
   12.34
3. 字符串
   str(1.23)
   ‘1.23’
   str(100)
   ‘100’
4. 布尔
   bool(1)
   True
   bool(’’)
   False

定义函数

在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回，不像java还要修饰符。

def  函数名(参数) :
     函数体（就是自己要做的一些神操作）
     返回值,返回值2（多个返回值逗号隔开）
a=111。。。     
和def对齐的代码，就表示它已经不属于函数了      

空函数

def 函数名(参数):
     pass

pass让这个函数先搁置，没有返回东西啥的，都不报错

报TypeError，基本都是参数错误，要不类型不对，要不数量不对

递归

如果一个函数在内部调用自身本身，这个函数就是递归函数。

def test(n):
    n=n+1
    return test(n) #调用本身

这就是个递归函数，而且是个死递归，我们给他加个条件，让他跳出递归返回值

def test(n):
    n=n+1
    if(n<10):
       return test(n) 
    return n #和if对齐，说明到这里已经不属于if的部分了
a =  test(0)   #调用函数
print(a)

切片

L = [0,1,2,3,4,5,6,7,8,9,10]
L[A:B:C]
A表示从下标A开始切，不写则默认从0
B表示下标A开始切，切到下标为B-1的元素
C表示在切出来的元素中每隔C个取一个
L[-D:]
表示切倒数D个元素
L[:] 得到的就是和原来一样的，复制一个

切片同样支持tuple和字符串

迭代

迭代其实就是通过for循环，把list、tuple、dict里的元素，一个一个取出来
list、tuple这种有下标的没啥说的，一个例子就懂了

for value in list:
    print(value)

value 就是取出来的元素，第一次for循环就是取下标为零的这个元素，第二次取下标为1的，以此类推，直到把list的所有元素都取出来后，跳出for循环，tuple同理。

那么dict这种key-value对的怎么迭代呢

1. 把每个key遍历出来

for key in dict:
    print(key)

2. 把每个value遍历出来

for value in d.values();
      print(value)

3. 同时把key和value都遍历出来

for k, v in d.items():
  print(k)
  print(v)

最后一个小问题，如果要对list实现类似Java那样的下标循环怎么办？Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：

for i, value in enumerate(['A', 'B', 'C']):
        print(i, value)

i就是下标，value遍历出来的值

for x, y in [(1, 1), (2, 4), (3, 9)]:
       print(x, y)

这种就比较神奇了

列表生成式

range
用法：list(range(A, B)) 生成一段自然数，从A到B

例如：
list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

1. 如果要生成一个有规律的数字列表，就可以用这个了
   比如：

L = [x * x for x in range(1, 11)

得到[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

2. 如果得到所有偶数的平方

L = [x * x for x in range(1, 11) if x % 2 == 0]

得到 [4, 16, 36, 64, 100]

for前面是对遍历出来的值做运算，for后面可以加一些条件判断,也可以写多重for循环

做个练习：
我们都知道java的冒泡排序是两个for循环做的，那么我们现在用Python做一下 （脑子有坑的想法）
如下：

L = [2, 4, 3, 1, 9, 5, 8, 6, 7, 12]


def test(l):
    if L[l] > L[l + 1]:
        a = L[l]
        L[l] = L[l+1]
        L[l + 1]=a


L2 = [l for i in range(0, len(L) + 1) for l in range(0, len(L) - i - 1)]

for l in L2:
    test(l)

print(L)

做这个练习的时候发现，函数必须在调用前创建，否则会找不到函数报错

生成器

如果列表元素可以按照某种算法推算出来，那么我们可以将这个算法封装成一个函数，需要多少元素，就生成元素多少
一边循环一边计算的机制，称为生成器：generator。

要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：

 L = [x * x for x in range(10)]
 g = (x * x for x in range(10))

创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator。

生成器可以通过next()函数获得下一个返回值：next(g)
这种傻瓜式的取值，我们就不讨论了，因为生成器也可以迭代，一个for循环加一个跳出for循环的if判断就可以了

下面我写一个简单的生成器：

def fib(): 
    a=0
    while True :
        yield(a)
        a=a+1       
   

上面就是一个可以生成0～无穷尽的generator。

函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回括号里的东西，再次执行时从上次返回的yield语句处继续执行。

那么怎么使用呢，之前说了for循环加if

a=0
for b in fib():
   print(b)
   if a==10:
      break
   a=a+1  

迭代器

可以直接作用于for循环的对象统称为可迭代对象：Iterable。
可以使用isinstance()判断一个对象是否是Iterable对象。
L=[1,2,3,4]

isinstance(L, Iterable) #返回True

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。
可以使用isinstance()判断一个对象是否是Iterator对象：

isinstance(fib(), Iterator) #返回True

把list、dict、str等Iterable变成Iterator可以使用iter()函数：

isinstance(iter(L), Iterator) #返回True

小葵花哥哥课堂开讲啦：

其实我们使用的for循环都是通过next获取下一个元素的哦！
那么for循环其实就是隐性的使用了iter()函数