Python入门学习笔记（三）——序列、函数

Python学习（三）

目录

Python学习（三）

Python之序列

Python之函数

---

Python之序列

 列表，元组和字符串的共同点：

1. 都可以通过索引得到每一个元素
2. 默认索引值从0开始
3. 可以通过分片的方法得到一个范围内的元素的集合
4. 有很多共同的操作符（重复操作符，拼接操作符，成员关系操作符）

• list()把可迭代对象转化为列表：

>>>a = list()

>>>a

[ ]

>>>b = ‘love’

>>>b = list(b)

>>>b

[‘I’,‘o’,‘v’,’e’]

>>>c = (1,1,2,3,5,8)

>>>c = list(c)

>>>c

[1,1,2,3,5,8]

• tuple()把可迭代对象转化为元组
• str(obj)把obj对象转换为字符串
• len(sub)返回sub的长度
• max()返回序列或参数集合中的最大值（比较的是ASCII码），要保证比较的元素类型是相同的，否则报错。

>>>max(1,2,3,4,5)
5

>>>max(b)
V

>>>numbers = [1,76]
>>>max(numbers)
76

>>>tuple1 = (1,2,3,9,0)
>>>max(tuple1)
9

• min()返回参数中的最小值
• sum(iterable,start)返回序列iterable和可选参数start的总和,

 >>>tuple2 = (3.1,2.3,3.4)
 >>>sum(tuple2)
 8.8

 >>>sum(tuple2,2)
 10.8

• sorted(numbers)从小到大排序
• reversed(numbers)反转，但是返回的是迭代器对象

>>>list(reversed(numbers))

[76,1]

• enumerate(numbers)返回一个枚举对象

>>>list(enumerate(numbers))

[(0,1),(1,76)]

• zip()返回有各个参数组成的序列

>>>a = [1,2,3,4,5,6,7,8]

>>>b = [4,5,6,7,8]

>>>zip(a,b)
返回一个对象，强制转化为列表

>>>list(zip(a,b))

[(1,4),(2,5),…(5,8)]

 

Python之函数

      

 >>>def MyFirstFunction():

         print(‘this is the first function!’)

         print(‘I am so exiceted!’)

>>>MyFirstFunction() #调用函数，编译器会往上找函数定义，然后从上往下编译
打印内容……

• 参数：

       >>>def MySecondFunction(name):



                     print(name + ‘, I love you’)

       >>>MySecondFunction(‘mm’)

       mm,I love you

• 返回值：

       >>>def add(num1,num2):

                  return num1 + num2

       >>>print(add(1,2))

       3

• 形参和实参：同其他编程语言
• 函数文档：

 用单引号括起来，与注释不同：

 可以用函数名.__doc__命令查看函数文档

 help(函数名)也会显示文档内容，注释不显示

• 关键字参数

              >>>def SaySome(name,words):

                         print(name + ‘->’ + words)

              >>>SaySome(name = ‘a’,words = ‘b’)

• 默认参数

              >>>def SaySome(name = ‘a’,words = ‘b’)

                            print(name + ‘->’ + words)
                
                # 给参数赋默认值

• 收集参数

              >>>def test(*params)

                            print(‘参数的长度是’,len(params))

                            print(‘第二个参数是’,params[1])

              >>>test(1,’hmz’,3.14,5,6,7,8) #任意多的参数

              参数的长度是：7

              第二个参数是：hmz

              #如果后面还有其他参数，要用关键字参数

              >>>def test(*params,exp)

                            print(‘参数的长度是’,len(params),exp)

                            print(‘第二个参数是’,params[1])

              >>>test(1,’hmz’,3.14,5,6,7,exp = 8)

              参数的长度是：6 8

              第二个参数是：hmz

• 函数与过程

       一般的，有返回值的叫函数，没有的叫过程；但是python中只有函数，没有过程，因为如果没有指定返回值 ，python默认返回一个None。

• 返回值

       Python可以返回多个值

       >>>def back():

                     Return 1,’hmz’,3.14

       >>>back()

       (1,’hmz’,3.14)

• 函数变量的作用域

       局部变量（Local Variable）：

只在局部生效，在执行时被存储在栈中，执行结束清空

       全局变量（Global Variable）：

在函数外定义，在整个代码段均生效，但是不要在函数内部试图修改它。

因为在Python中，如果在函数内试图修改全局变量，Python会在栈中重新创建一个新的同名字的变量代替，也就是创建了一个新的同名字的局部变量。但在函数外，该全局变量的值不发生改变。

              >>>count = 5

              >>>def MyFun():

                            count = 10

                            print(count)

              >>>MyFun()

              10 #在函数中修改全局变量，本质会创建一个新的局部变量，名字相同

              >>>print(count)

              5 #全局变量值不变

如果想在函数里修改全局变量—>global 关键字

              >>>count = 5

              >>>def MyFun():

                            global count

              count = 10

                            print(count)

              >>>MyFun()

              10

              >>>print(count)

              10

             

• 内嵌函数      

       >>>def fun1():

                     print(‘fun1正在被调用……’)

                     def fun2():

                            print(‘fun2正在被调用……’)

                     fun2()

       >>>fun1()

       #两句话都打印，说明python支持函数嵌套。

• 闭包

       如果在一个内部函数里，对外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就会被认为是闭包 。

       >>>def FunX(x):

                     def FunY(y):

                            return x * y

                     return FunY

       >>>i = FunX(8) #i是一个函数类型，function

       >>>i(5)

       40

       >>>FunX(8)(5)

       40

       #闭包不能在函数外直接被调用



       >>>def Fun1():

                     x = 5

                     def Fun2():

                            x *= x

                            return x

                     return Fun2()

       >>>Fun1()

       #异常，返回Fun2()，在调用Fun2的时候，找不好x

       #在3.x的版本中，解决方法如下：

              >>>def Fun1():

                     x = 5

                     def Fun2():

                            nonlocal x #强制声明不是局部变量。

                            x *= x

                            return x

                     return Fun2()

              >>>Fun1()

              25

• Lambda表达式：

>>>def ds(x):

         Return 2 * x + 1

>>>ds(5)

11

>>>lambda x : 2 * x + 1 返回一个函数类型

>>>g = lambda x : 2 * x + 1

>>>g(5)

11

两个参数：

              >>>def add(x, y):

                     return x + y

              >>>add(3,4)

              7

              >>>g = lambda x, y : x + y

              >>>g(3, 4)

              7

       Python写一个写执行脚本的时候，使用lambda就可以省下定义函数过程，比如说我们只是需要写个简单的脚本来管理服务器时间，我们就不需要专门定义一个函数然后在写调用，使用lambda就可以使得代码更加精简。

     对于一些比较抽象并且整个程序执行下来只需要调用一两次的函数，有时候给函数起个名字也是比较头疼的问题，使用lambda就不需要考虑命名的问题了。

       简化代码的可读性，由于普通的函数阅读经常要跳到开头的def定义部分，使用lamvda函数可以省去这样的步骤。

• 两个BIIF：

filter()

filter(function or None, iterable)—>filter object

Return ann iterator yielding those items of iterable for which function(item) is true.If function is None ,return the items that are true.

>>>filter(None, [1,0,False,True])

#强制转化为列表输出：

>>>list(filter(None, [1,0,False,True]))

[1,True]#过滤器



>>>def odd(x):

               Return x % 2

>>>temp = range(10)

>>>show = filter(odd,temp)

>>>list(show)

[1,3,5,7,9]

或者：

>>>list(fiilter(lambda x : x % 2, range(10)))

[1,3,5,7,9]

map()

>>>list(map(lambda x : x * 2, range(10)))

[0,2,4,6,8,10,12,14,16,18]