Python 第二周复习总结

函数

定义函数

定义一个函数以def 关键字开头，后写入函数名和参数，传入的参数可以是一个或者多个，参数可以设置默认值。在缩进后写入函数体，最后用return 语句返回。

# 定义求阶乘的函数 - 将求阶乘的功能抽取出来放到函数中
# 文档注释

def factorial(x):

    '''
    计算阶乘
    :param x: 一个非负整数
    :return: 返回阶乘
    '''
    y = 1
    for num in range(1,x + 1):
        y *= num
    return y

return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

#写两个数 计算2个数的最大公约数的函数 gcd 最大公共因子
def gcd(x,y):
    '''
    计算随机2个数的最大公约数

    :param x: 一个正整数
    :param y: 一个正整数

    :return: X和Y的最大公约数
    '''
    (x,y) = (y,x) if (x > y) else (x,y)
    for factor in range(x,0,-1): #从大到小  倒序
        if x %factor == 0 and y % factor == 0:
            return factor

三元表达式

     number = int(input('请输入一个非负整数：'))

     if is_palindrome(number) and is_prime(number):
         print('%d是回文素数' % number)
     else:
         print('%d不是回文素数' % number)

 and 和 or 运算符都是带短路功能的运算符
 如果and 左边的表达式是False 那么右边的表达式被短路（不执行）
 如果or 左边的表达式是True 那么右边的表达式被短路（不执行）
 所以左右两边的表达式放置的顺序可能会对执行效率产生明显影响

调用函数

调用一个函数，需要知道函数的名称和参数。如函数就在当前模块，则能直接调用。否则需要先引入函数模块。
在同一模块下调用函数，为避免执行其他代码 可以使用：

if __name__ == '__main__':
        main()

如需调用另一模块的多个函数 可以用 * 如：

import combination *  
#调取combination模块的所有函数

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。
局部作用域—-》嵌套作用域 —-》全局作用域 —-》内置作用域 从左往右依次搜索。 —-LEGB

# 在做开发中 应该减少全局变量的使用
#迪米特法则
# 在函数外面定义的 a  是一个全局变量
a = 100
b ='good'
# Python 搜索一个变量的方式是从局部作用域到嵌套作用域再到全局作用域
# Local - Enclosed - Global
def foo():
    #local variable
    # 函数内的局部变量 离开foo 函数变量a 是无法访问的
    b = 'hello'
    global a
    a =200


    def bar():
        nonlocal b
        b = 'good'
        print(a)
        print(b)
    bar()
# 搜寻作用域从 局部作用域（小圈）到
#非局部作用域  再到全局作用域 由近及远

字符串

    str1 = 'hello,world!'
    print(len(str1)) #取长度
    print(str1.capitalize())#首字母大写
    print(str1.upper())#全字母大写
    print(str1.find('or'))#提取or下标 没有用-1表示
    print(str1.startswith('he'))#判定是否用he开头 判定T/F
    print(str1.endswith('d!'))#判断是否用d!结尾 判定T/F
    print(str1.center(50,'*'))#填充居中
    print(str1.rjust(50,' '))#填充居右
    print(str1.ljust(50,'#'))#填充居左
    str2 = 'abc123456'
    print(str2[2])
    #取字符串内元素
    print(str2[2:5])
    #切片  开始索引从0开始数  结束索引从1开始数
    print(str2[-1])
    print(str2[-1:-3:-1])
    #倒着取 -1 是尾数  最后是步长
    print(str2[2::2])
    #从2取到尾 步长为2
    print(str2[:])
    #全取
    print(str2[::2])
    #全取 步长为2  
     print(str2[::-1])
    #倒转全取 
    str3 = '  jackfrued@126.com '
    print(str3.strip()) 
    #去首尾空格

列表生成式和生成器

def num():
    f = [x + y for x in 'ABCDEF' for y in '1234567']
    #生成 一个 由 x = A,B,C... 和 Y = 1,2,3,4.. 字符串相加的表达式  效果如 A1 B2  C7
    print(f)
    f = list(range(1,10))   # 此法不常用

    print(f)
    f = [x for x in range(1,10)] # 列表生成器的生成表达式语法创建列表容器
    #这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
    #生成一个1,9 元素的列表
    print(f)
    f = [x ** 2 for x in range(10)]
    #生成一个元素二次方的列表
    print(f)
    f = [x ** x for x in range (1,10)]
    print(sys.getsizeof(f))
    #生成一个x 的 x 次方的列表
    f = (x + y for x in 'ABCDEF' for y in '1234567')
    print(f)

    print(f)
    f = (x ** x for x in range (1,10))
    #列表生成器 这里得到的不是一个列表 而是一个生成器对象
    #通过生成器可以到数据 它不占用额外的空间存储数据
    #每次需要数据的时候就可以通过生成器取数据 当然这需要这需要花费时间
    print(sys.getsizeof(f))# 占用内存量

    print(f)
    for val in f:
        print(val)

列表

一种有序的集合，可进行的操作包括索引，切片，加，乘，检查列表中的元素。

def foo():
    f = [100,200,300,50000]
    for index,val in enumerate(f):# 枚举 F列表中 对应其 下标（index）和值(val)的元素
        print(index,':',val)
        # CRUD 操作  Create Read Update Delete 新增阅读更新删除
    f.append(123) #添加 元素 123到列表的末尾

    print(f2)
    print(f)
    f.insert(3,400) # 插入元素400 到下标3的位置上
    print(f)
    if 300 in f:
        f.remove(300)# 如果300这个元素在列表中  删除（remove） 300 合适知道元素 不知道下标情况
    print(f)
    del f[4]
    # 删除操作，如果500在容器里才会执行语句，如果不在 会报错
    # 会先判断值是否在列表中
    print(f)
    f.pop()
    print(f)# 删除下标位为n的元素 或默认删除最后一个元素
    f.extend([800,900]) #2个列表相加为一个列表
    print(f)
    f.append([700,600])  #2个列表相加 把后面的列表变成一个变量元素加入列表内
    print(f)
    # f.clear()  删掉全部
    f.index(200,0,4)
    print(f)
    f.reverse() #反转列表  reverse 相反的
    print(f)
    f =f [::-1] #用切片反转 列表
    print(f)
    f.upper()

if __name__ == '__main__':
    main()

类和对象

定义类的关键字- class - 类名（每个单词首字母大写），类是对象的蓝图和模板，是抽象的 ，有了类就可以创建对象。 对象的特征一切皆为对象，对象可以归属到某个类，对象独一无二。定义类需要做两件事：数据抽象和行为抽象。
数据抽象 - 抽取对象共同的静态特征（找名词） -属性
行为抽象 - 抽取对象共同的动态特征（找动词） -方法

class Student(object):  
    def __init__(self,name,age):
        #step1：定义类
        #给对象绑定属性 name , age
        #init 初始化 设定静态特征
        #构造方法（构造器/ 构造子 - constructor）
        #调用该方法的时候，不是直接使用方法的名字 ，而是使用类的名字
        self.name = name    #添加成 self.__name  可以隐藏  无法更改name
        self.age = age      #添加成 self._name  一个下划线 可以保护 实际开发很少加2个下划线


    def study(self,course):

        #我们定义一个方法就代表对象可以接收这个消息
        # 对象的方法的第一个参数都是统一写成self
        #它代表了接收消息的对象
        #对象.消息（参数）
        #函数写到类下面，叫方法，是学生对象的动态特征，就是学生的行为
        print('%s正在学习%s' % (self.name,course))
        #只有赋值self的变量才能在整个类下面使用  不然只能在当前函数（方法）下调用 如 course
        ## 传什么参数，就表达学什么   #self就是stu1对象

    def watch_av(self):
        if self.age >= 18:
            print('%s正在观看岛国爱情动作片' % self.name)
        else: print('%s, 我们推荐你看《熊出没》。'% self.name)
        #watchAv  驼峰命名法 两种写法都行

    def __str__(self):
        return '%s : %d' % (self.name, self.age)   #把对象改成字符串 如果下面有print 就调用这个函数 没有就不用


def main():

    # step.2 调用构造方法  创建学生对象
    # 实际调用的是Student类中的
    # 有了类才可以造对象   有了对象 才可以让对象干事情
    stu1 = Student('阿大',38) #前面stu 是引用 后面是对象 引用在栈上

    stu1.study('Python程序设计')
    #step3 .给对象发消息
    #通过给对象发消息让对象完成某些工作
    #解决任何问题都市是通过让对象去做事情
    stu2 = Student('王大锤',16)

    stu2.study('HTML网页设计')
    stu2.watch_av()

    print(stu2)





if __name__ == '__main__':
    main()

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