Python基础二

函数

函数的定义

• 函数是计算机程序中定义并封装起来的独立的代码块，当我们调用函数时，函数可以为我们实现特定的功能

定义函数

• 可以用def关键字后面加函数名定义函数
• 一般情况下用return返回我们需要的函数值
• 写函数的时候可以用三个双引号在函数中加注释，按住ctrl键，可以查看函数的解释
• 参数的默认值：先设定自变量等于某个数字如：x=5为默认值，运行的时候如果传递了参数，就执行参数；没传递参数就执行默认值，在函数中赋默认值的时候，等号两边不应留空格
• 可变参数：如果我们不确定参数有几个时，我们可以用“ *args ”设定多个参数

  # *args设置可变参数
def add(*args):
    total = 0
    for value in args:
        total += value
    return total

函数的调用

• 我们可以用“from 模块名 import 函数名”导入函数，接下来就可以直接根据函数的需要的参数传入参数调用函数
• 如果不同的模块下面有相同名词的函数，我们可以直接 “import 模块名” ,然后根据 “模块名.函数名”调用函数
• 导入模块时可以对模块重新命名，例如：import math as m；math 模块的名称就成了m，以后可以直接用m.sqrt等函数。
• 我们可以用 “ if __name__ == ‘__main__’ ” 来阻止调用函数时执行模块中函数后面的代码

函数中的变量

• 变量的作用域：Python搜索一个变量的方式是从局部作用域到嵌套作用域再到全局作用域再到内置变量；LEGB（local – enclosed – global – build-in）法则
• 如果想改变变量的搜索范围，可以使用global和nonlocal关键字
• 实际开发时，一定要减少对全局变量的使用（迪米特法则：不要和陌生人说话）

递归

• 在函数里，一个函数直接或者间接的调用了自己，就叫做递归调用
• 收敛条件 - 让递归在有限的次数完成或者回溯
• 如果递归无法在有限次数内收敛，就有可能导致RecursionError（栈溢出）

内存

• 内存分为5个部分 栈（stack） 堆（heap） 数据段 只读数据段 代码段
• 最后三段统称为静态区–即 栈-堆-静态区
• 变量–对象的引用–对象的地址–栈;对象–堆–更大的存储空间; id()函数和is运算符–验证身份
• 调用函数，保存现场和恢复现场
• 在进入函数调用之前，要保存当前的执行现场
• 函数的执行现场是保存在一种称为’栈(stack)’的内存空间上
• 栈是一种”先进后出（FILO）”结构，并且栈的速度快，空间小，递归次数多了，容易导致栈溢出

字符串

• 字符串支持索引查找，计算长度，切片等操作
• 字符串不支持修改，增加，删除等操作
• 如果一个字符串是空的，就会默认为bull值 ‘false’## 列表

列表

列表的常规操作

• 列表是用 [] 括起来的有序集合，在列表中可以存放不同的数据类型，也可以存放列表，但是建议列表中一般保存相同类型的数据，以便对列表进行统一操作
• 可以对列表进行CRUD操作，例如用 list[1] = 对列表中的元素进行赋值，可以用append、remove、pop、insert等方法对列表进行修改
• 可以用sort方法对列表进行排序，此方法可以指定关键字‘key= ’,也可以用‘reverse=True’改变顺序，默认升序，也可用函数sorted排序，此方法不改变列表，而是重新创造一个新的列表，这就是函数的好处，没有副作用，我们自己定义函数时，也应该为无副作用的函数

列表生成器、生成式、

• 构建一个列表，可以用 f = list(rang(1, 10))生成一个列表，也可以用列表生成器和列表生成式

def main():
    f = [x + y for x in 'ABCDE' for y in '1234567']# 双重循环的生成式
    print(f)
    f = list(range(1, 10))# 这一种最不常用
    print(f)
    f = [x for x in range(1, 10)]
    # 用列表的生成表达式语法创建列表容器
    # 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
    print(f)
    f = [x ** 2 for x in range(1, 10)]
    # 列表生成器 这里得到的不是一个列表 而是一个生成器对象
    # 通过生成器可以获取到数据 它不占用额外的空间存储数据
    # 每次需要数据的时候就通过生成器取数据 当然这需要花费时间
    print(f)
    f = (x ** 2 for x in range(1, 10))
    print(f)

元组（tuple）

• 元组是用（）括起来的一组有序数列,元组里面也可以存放不同的数据，但是tuple不支持修改等操,可以进行切片
• 由于tuple不支持数据修改，所以用tuple存放的数据更安全

集合（set）

• 类似于数学上的集合，set中的元素是没有序列和没有重复的对象的集合，所以不能对集合进行类似于列表的索引运算,但可以在集合中添加不同的对象，添加集合已有的相同对象无效，也可以删除集合中的对象，改变集合中的对象
• 所以集合可以进行交，并等运算

def main():
    set1 = {1, 1, 2, 2, 3, 3, 4, 4, 7, 9, 10} # 集合中重复对象，只保留一个，所以set1 ==[1,2,3,4,7,9,10]
    print(set1)
    set1.add(5) #在集合中添加对象
    print(set1)
    set1.add(5) #重复添加无效
    print(set1)
    set2 = {1, 2, 3, 3, 4, 4, 5, 5, 11, 23}
    set3 = set1.intersection(set2)
    set3 = set1 & set2 #交集
    print(set3)
    set3 = set1.union(set2)
    set3 = set1 | set2 #并集
    print(set3)
    set3 = set1.difference(set2) # 差集：set1 对 set2 作差运算
    print(set3)
    set3 = set2.difference(set1) #差集：set2 对 set1 作差运算
    set3 = set2 - set1 #差集：set2 对 set1 作差运算
    print(set3)
    set3 = set1.symmetric_difference(set2) #对称差运算（对称差集）
    set3 = set1 ^ set2 #对称差运算
    print(set3)
    for val in set2:
        print(val)
    set4 = {1, 2}
    print(set1.issuperset(set4)) #超集： set1是否是set4的超集
    print(set2 <= set1)
    print(set2.issubset(set1)) #子集：ste2是否是 set1的子集
    print(set2 >= set1)
    print(set1.issubset(set2)) #子集：set1是否是 set2的子集
    list1 = [1, 2, 3]
    c = list1.pop(1)
    print(c)
    print(list1)

字典（dict）

• 字典是类似于集合的一组无序对象的集合
• 但是字典中的每一个key有对应的值,并且key不能重复
• 可以利用key更改和删除key中的对象,可以利用 in 判断key是否在dict中；也可以get方法获得key对应的value，如果key不在返回none或者返回自己指定的值；可以用pop方法删除key

面向对象

关于对象

• 
  
• 一切皆为对象
• 对象都是有属性和行为
  

说明：
属性是静态特征
行为是动态特征

• 对象都是独一无二的

定义类

• 
  
• 类是对象的蓝图和模板 有了类就可以创建对象
• 定义类需要做两件事： 数据抽象和行为抽象
  
  1. 数据抽象 — 抽取对象的共同的静态特征（找名词）– 属性
  2. 行为抽象 – 抽取对象共同的动态特征（找动词）– 方法
  3. 定义类的关键字 - class - 类名（每个单词的首字母大写）
     

说明：
我们定义一个类实际上是把数据和操作的函数绑定到一起
形成一个逻辑上的整体 这个整体就叫对象
而且将来任何时候想使用这种对象时直接复用这个类就可以了

    # step1.定义类
class Student(object):

    # 构造方法（构造器/构造子 - construction)
    # 调用该方法的时候不是直接使用该方法的名字，而是使用类的名字
    def __init__(self, name, age):
        # 给对象绑定属性
        self._name = name
        self._age = age

     # 我们定义一个方法就代表对象可以接收这个消息
     # 对象的方法的第一个参数都是统一写成 self
     # 它代表了接收消息的对象 - 对象.方法(参数)
     def study(self, course):
        print('%s正在学习%s' % (self._name, course))

def main():
     # Step.2 调用构造方法创建学生对象
     # 实际上是调用student类中的__init__方法
     stu1 = Student('y.w', 24)
     # Step.3 给对象发消息
     # 通过给对象发消息，让对象完成某些工作，
     # 解决任何问题都是通过让对象去做事情
     stu1.study('Python程序设计')


if __name__ == '__main__':
    main()