第二周总结和复习

第二周总结和复习

函数和模块的使用

函数的作用

要写出高质量的代码首先要解决的就是重复代码的问题。我们可以将需要实现的功能封装到一个称之为“函数”的功能模块中，在需要应用这个功能的地方，我们只要“调用”这个“函数”就可以了。

定义函数

在Python中可以使用def关键字来定义函数，和变量一样每个函数也有一个响亮的名字，而且命名规则跟变量的命名规则是一致的。在函数名后面的圆括号中可以放置传递给函数的参数，这一点和数学上的函数非常相似，程序中函数的参数就相当于是数学上说的函数的自变量，而函数执行完成后我们可以通过return关键字来返回一个值，这相当于数学上说的函数的因变量。

"""
第一个python程序 - 计算最大公约数
Version:0.1
Author:贺松
Date:2018-3-12
"""
def gcd(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


print(gcd(18,12))

"""
第二个python程序 - 判断一个数是不是素数
Version:0.1
Author:贺松
Date:2018-3-12
"""
from math import sqrt


def is_prime(num):

    for factor in range(2,int(sqrt(num) + 1)):
        if num % factor == 0:
            return False
    return True if num != 1 else False

if __name__ == '__main__':
    num = int(input('请输入数字：'))
    print(is_prime(num))

递归

在调用一个函数的过程中，直接或间接地调用了函数本身这个就叫递归

函数的递归调用

1、收敛条件 - 让递归在有限的次数完成或者回溯（如果递归无法在有限次数内收敛就有可能导致RecurisionError）
2、递归公式

"""
第三个python程序 - 判断一个数是不是素数
Version:0.1
Author:贺松
Date:2018-3-12
"""
def f(n):
    # 收敛条件
    if n == 0 or n == 1:
       return 1
    # 递归公式
    return n * f(n - 1)


if __name__ == '__main__':
    print(f(998))

用Python搜索一个变量的方式是从局部作用域到嵌套作用域再到全局作用域
Local - Encolsed - Global - Built-in
如果想改变搜索范围，可以使用global和nonlocal关键字
实际开发时，要减少对全局变量的使用

函数的参数

函数是绝大多数编程语言中都支持的一个代码的“构建块”，但是Python中的函数与其他语言中的函数还是有很多不太相同的地方，其中一个显著的区别就是Python对函数参数的处理。在Python中，函数的参数可以有默认值，也支持使用可变参数，所以Python并不需要像其他语言一样支持函数的重载，因为我们在定义一个函数的时候可以让它有多种不同的使用方式。

用模块管理函数

对于任何一种编程语言来说，给变量、函数这样的标识符起名字都是一个让人头疼的问题，因为我们会遇到命名冲突这种尴尬的情况。最简单的场景就是在同一个.py文件中定义了两个同名函数，由于Python没有函数重载的概念，那么后面的定义会覆盖之前的定义，也就意味着两个同名函数实际上只有一个是存在的。

使用字符串

今天的计算机处理得更多的数据都是以文本信息的方式存在的，而Python表示文本信息的方式是用字符串。所谓字符串，就是由零个或多个字符组成的有限序列。
我们用以下代码来测试字符串的使用

"""
def main():
    str1 = 'hello, world!'
    # 通过len函数计算字符串的长度
    print(len(str1))  # 13
    # 字符串首字母大写
    print(str1.capitalize())  # Hello, world!
    # 字符串变大写
    print(str1.upper())  # HELLO, WORLD!
    # 从字符串中查找子串所在位置
    print(str1.find('or'))  # 8
    print(str1.find('shit'))  # -1
    # 与find类似但找不到子串时会引发异常
    # print(str1.index('or'))
    # print(str1.index('shit'))
    # 检查字符串是否以指定的字符串开头
    print(str1.startswith('He'))  # False
    print(str1.startswith('hel'))  # True
    # 检查字符串是否以指定的字符串结尾
    print(str1.endswith('!'))  # True
    # 将字符串以指定的宽度居中并在两侧填充指定的字符
    print(str1.center(50, '*'))
    # 将字符串以指定的宽度靠右放置左侧填充指定的字符
    print(str1.rjust(50, ' '))
    str2 = 'abc123456'
    # 从字符串中取出指定位置的字符(下标运算)
    print(str2[2])  # c
    # 字符串切片(从指定的开始索引到指定的结束索引)
    print(str2[2:5])  # c12
    print(str2[2:])  # c123456
    print(str2[2::2])  # c246
    print(str2[::2])  # ac246
    print(str2[::-1])  # 654321cba
    print(str2[-3:-1])  # 45
    # 获得字符串修剪左右两侧的空格
    print(str3.strip())

if __name__ == '__main__':
    main()
"""

除了字符串，Python还内置了多种类型的数据结构，如果要在程序中保存和操作数据，绝大多数时候可以利用现有的数据结构来实现，最常用的包括列表、元组、集合和字典。

使用列表

下面的代码演示了如何定义列表、使用下标访问列表元素以及添加和删除元素的操作。

"""
def main():
    list1 = [1, 3, 5, 7, 100]
    print(list1)
    list2 = ['hello'] * 5
    print(list2)
    # 计算列表长度(元素个数)
    print(len(list1))
    # 下标(索引)运算
    print(list1[0])
    print(list1[4])
    # print(list1[5])  # IndexError: list index out of range
    print(list1[-1])
    print(list1[-3])
    list1[2] = 300
    print(list1)
    # 添加元素
    list1.append(200)
    list1.insert(1, 400)
    list1 += [1000, 2000]
    print(list1)
    print(len(list1))
    # 删除元素
    list1.remove(3)
    if 1234 in list1:
        list1.remove(1234)
    del list1[0]
    print(list1)
    # 清空列表元素
    list1.clear()
    print(list1)
    fruits = ['grape', 'apple', 'strawberry', 'waxberry']
    fruits += ['pitaya', 'pear', 'mango']
    # 循环遍历列表元素
    for fruit in fruits:
        print(fruit.title(), end=' ')
    print()
    # 列表切片
    fruits2 = fruits[1:4]
    print(fruits2)
    # fruit3 = fruits  # 没有复制列表只创建了新的引用
    # 可以通过完整切片操作来复制列表
    fruits3 = fruits[:]
    print(fruits3)
    fruits4 = fruits[-3:-1]
    print(fruits4)
    # 可以通过反向切片操作来获得倒转后的列表的拷贝
    fruits5 = fruits[::-1]
    print(fruits5)
    list3 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
    list4 = sorted(list3)
    # sorted函数返回列表排序后的拷贝不会修改传入的列表
    # 函数的设计就应该像sorted函数一样尽可能不产生副作用
    list5 = sorted(list3, reverse=True)
    # 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
    list6 = sorted(list3, key=len)
    print(list3)
    print(list4)
    print(list5)
    print(list6)
    # 给列表对象发出排序消息直接在列表对象上进行排序
    list1.sort(reverse=True)
    print(list3)


if __name__ == '__main__':
    main()
"""

我们还可以使用列表的生成式语法来创建列表，代码如下所示。

"""
import sys


def main():
    f = [x for x in range(1, 10)]
    print(f)
    f = [x + y for x in 'ABCDE' for y in '1234567']
    print(f)
    # 用列表的生成表达式语法创建列表容器
    # 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
    f = [x ** 2 for x in range(1, 1000)]
    print(sys.getsizeof(f))  # 查看对象占用内存的字节数
    print(f)
    # 请注意下面的代码创建的不是一个列表而是一个生成器对象
    # 通过生成器可以获取到数据但它不占用额外的空间存储数据
    # 每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)
    f = (x ** 2 for x in range(1, 1000))
    print(sys.getsizeof(f))  # 相比生成式生成器不占用存储数据的空间
    print(f)
    for val in f:
        print(val)


if __name__ == '__main__':
    main()
"""

除了上面提到的生成器语法，Python中还有另外一种定义生成器的方式，就是通过yield关键字将一个普通函数改造成生成器函数。

"""
第四个python程序 - 斐波拉切数列
Version:0.1
Author:贺松
Date:2018-3-12
"""
def fibonacci():
    f = [1,1]
    for index in range(2,20):
        val = f[index - 1] + f[index - 2]
        f.append(val)
        print(f)
    print(f)
    f2 = f[18:]
    f3 = f[::-1]
    print(f2)
    print(f3)
    f.reverse()
    print(f)

def fib(n):
    a,b = 0,1
    for _ in range(n):
        a,b = b,a + b
        yield a

if __name__ == '__main__':
    fibonacci()

使用元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改，在前面的代码中我们已经不止一次使用过元组了。顾名思义，我们把多个元素组合到一起就形成了一个元组，所以它和列表一样可以保存多条数据。下面的代码演示了如何定义和使用元组。

"""
def main():
    # 定义元组
    t = ('张三', 28, True, '四川成都')
    print(t)
    # 获取元组中的元素
    print(t[0])
    print(t[3])
    # 遍历元组中的值
    for member in t:
        print(member)
    # 重新给元组赋值
    # t[0] = '王大锤'  # TypeError
    # 变量t重新引用了新的元组原来的元组将被垃圾回收
    t = ('王大锤', 20, True, '云南昆明')
    print(t)
    # 将元组转换成列表
    person = list(t)
    print(person)
    # 列表是可以修改它的元素的
    person[0] = '李小龙'
    person[1] = 25
    print(person)
    # 将列表转换成元组
    fruits_list = ['apple', 'banana', 'orange']
    fruits_tuple = tuple(fruits_list)
    print(fruits_tuple)


if __name__ == '__main__':
    main()
"""

使用元组需要注意的地方

1、元组中的元素是无法修改的，事实上我们在项目中尤其是多线程环境（后面会讲到）中可能更喜欢使用的是那些不变对象（一方面因为对象状态不能修改，所以可以避免由此引起的不必要的程序错误，简单的说就是一个不变的对象要比可变的对象更加容易维护；另一方面因为没有任何一个线程能够修改不变对象的内部状态，一个不变对象自动就是线程安全的，这样就可以省掉处理同步化的开销。一个不变对象可以方便的被共享访问）。所以结论就是：如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组，当然如果一个方法要返回多个值，使用元组也是不错的选择。
2、元组在创建时间和占用的空间上面都优于列表。

使用集合

Python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算。

"""
def main():
    set1 = {1, 2, 3, 3, 3, 2}
    print(set1)
    print('Length =', len(set1))
    set2 = set(range(1, 10))
    print(set2)
    set1.add(4)
    set1.add(5)
    set2.update([11, 12])
    print(set1)
    print(set2)
    set2.discard(5)
    # remove的元素如果不存在会引发KeyError
    if 4 in set2:
        set2.remove(4)
    print(set2)
    # 遍历集合容器
    for elem in set2:
        print(elem ** 2, end=' ')
    print()
    # 将元组转换成集合
    set3 = set((1, 2, 3, 3, 2, 1))
    print(set3.pop())
    print(set3)
    # 集合的交集、并集、差集、对称差运算
    print(set1 & set2)
    # print(set1.intersection(set2))
    print(set1 | set2)
    # print(set1.union(set2))
    print(set1 - set2)
    # print(set1.difference(set2))
    print(set1 ^ set2)
    # print(set1.symmetric_difference(set2))


if __name__ == '__main__':
    main()
"""

使用字典

字典是另一种可变容器模型，类似于我们生活中使用的字典，它可以存储任意类型对象，与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。下面的代码演示了如何定义和使用字典。

"""
def main():
    dict1 = {'name':'张三','age':38,'gender':True}
    # 通过键可以获取字典中对应的值
    print(dict1['name'])
    print(dict1['age'])
    print(dict1)
    dict1['name'] = '王大锤'
    print(dict1)
    # 对字典进行遍历(遍历的其实是键再通过键取对应的值)
    for x in dict1:
        print(x,'--->',dict1[x])
     # 更新字典中的元素   
    dict1.update(height=174,fav=['吃','喝'])
    print(dict1)
    # 删除字典中的元素
    print(dict1.pop('age'))
    print(dict1)
    print(dict1.popitem())

if __name__ == '__main__':
    main()

"""

"""
第五个python程序 - 跑马灯小程序
Version:0.1
Author:贺松
Date:2018-3-12
"""
import os
import time


def main():
    content = '欢迎来成都学习…………'
    while True:
        # 清理屏幕上的输出
        os.system('cls')
        print(content)
        # 休眠1毫秒
        time.sleep(1)
        content = content[1:] + content[0]


if __name__ == '__main__':
    main()

"""
第六个python程序 - 生成验证码
Version:0.1
Author:贺松
Date:2018-3-12
"""
import random


def generate_code(code_len=4):

    all_chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
    last_pos = len(all_chars) - 1
    code = ''
    for _ in range(code_len):
        index = random.randint(0, last_pos)
        code += all_chars[index]
    return code

"""
第七个python程序 - 设计一个函数返回传入的列表中最大和第二大的元素的值。
Version:0.1
Author:贺松
Date:2018-3-12
"""
def max2(x):
    m1, m2 = (x[0], x[1]) if x[0] > x[1] else (x[1], x[0])
    for index in range(2, len(x)):
        if x[index] > m1:
            m2 = m1
            m1 = x[index]
        elif x[index] > m2:
            m2 = x[index]
    return m1, m2

"""
第八个python程序 - 计算指定的年月日是这一年的第几天
Version:0.1
Author:贺松
Date:2018-3-12
"""
def is_leap_year(year):
    if (year % 4 == 0) and (year % 100 != 0) or year % 400 == 0:
        return True
    else:
        return False


def which_day(year, month, date):
    """
    计算传入的日期是这一年的第几天

    :param year:一个整数
    :param month: 一个整数
    :param day: 一个整数
    :return: 第多少天

    """
    days_of_month = [
        [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
        [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    ][is_leap_year(year)]
    total = 0
    for index in range(month - 1):
        total += days_of_month[index]
    return total + date


if __name__ == '__main__':
    print(which_day(2018, 1, 8))

"""
第九个python程序 - 双色球选号
Version:0.1
Author:贺松
Date:2018-3-12
"""
from random import randrange, randint


def display(balls):
    """
    输出列表中的双色球号码
    """
    for index, ball in enumerate(balls):
        if index == len(balls) - 1:
            print('|', end=' ')
        print('%02d' % ball, end=' ')
    print()


def random_select():

    red_balls = [x for x in range(1, 34)]
    selected_balls = []
    for _ in range(6):
        index = randrange(len(red_balls))
        selected_balls.append(red_balls[index])
        del red_balls[index]
    selected_balls.sort()
    selected_balls.append(randint(1, 16))
    return selected_balls


def main():
    n = int(input('机选几注: '))
    for _ in range(n):
        display(random_select())


if __name__ == '__main__':
    main()

"""
第十个python程序 - 约瑟夫环问题
Version:0.1
Author:贺松
Date:2018-3-12
"""
"""

《幸运的基督徒》
有15个基督徒和15个非基督徒在海上遇险，为了能让一部分人活下来不得不将其中15个人扔到海里面去，
有个人想了个办法就是大家围成一个圈，由某个人开始从1报数，报到9的人就扔到海里面，
他后面的人接着从1开始报数，报到9的人继续扔到海里面，直到扔掉15个人。
由于上帝的保佑，15个基督徒都幸免于难，问这些人最开始是怎么站的，哪些位置是基督徒哪些位置是非基督徒。

"""


def main():
    persons = [True] * 30
    counter, index, number = 0, 0, 0
    while counter < 15:
        if persons[index]:
            number += 1
            if number == 9:
                persons[index] = False
                counter += 1
                number = 0
        index += 1
        index %= 30
    for person in persons:
        print('基' if person else '非', end='')


if __name__ == '__main__':
    main()

面向对象编程基础

通俗点理解：面向对象编程相对于面向过程编程和函数式编程来说，看的更长远，实现功能相对更简单。
面向对象：对象就是物体，这种编程思想就是设定一个有一定功能的物体，然后利用这个物体的功能做你想做的事情。
面向过程：你想干嘛，就直接写个功能，然后做你想做的事情。

类和对象

简单的说，类是对象的蓝图和模板，而对象是类的实例。这个解释虽然有点像用概念在解释概念，但是从这句话我们至少可以看出，类是抽象的概念，而对象是具体的东西。在面向对象编程的世界中，一切皆为对象，对象都有属性和行为，每个对象都是独一无二的，而且对象一定属于某个类（型）。当我们把一大堆拥有共同特征的对象的静态特征（属性）和动态特征（行为）都抽取出来后，就可以定义出一个叫做“类”的东西。

定义类

在Python中可以使用class关键字定义类，然后在类中通过之前学习过的函数来定义方法，这样就可以将对象的动态特征描述出来，代码如下所示。

class Student:

    def __init__(self,name,age):
        self.__name = name
        self.__age = age

    def study(self,course):
        print('%s正在学习%s' % (self.__name,(course)))

    def watch_av(self):
        if self.__age >= 18:
            print('%s正在观看影视' % self.__name)
        else:
            print('%s,我们推荐你运动' % self.__name)

def main():
    stu1 = Student('王大锤',38)
    stu1.__name = '张大锤'
    stu1.study('Python程序设计')
    stu2 = Student('李大锤',16)
    stu2.study('HTML网页设计')
    stu2.watch_av()

if __name__ == '__main__':
    main()

"""
第十一个python程序 - 定义一个类描述数字时钟
Version:0.1
Author:贺松
Date:2018-3-12
"""
class Clock(object):
    """数字时钟"""

    def __init__(self, hour=0, minute=0, second=0):
        """
        构造器

        :param hour: 时
        :param minute: 分
        :param second: 秒
        """
        self._hour = hour
        self._minute = minute
        self._second = second

    def run(self):
        """走字"""
        self._second += 1
        if self._second == 60:
            self._second = 0
            self._minute += 1
            if self._minute == 60:
                self._minute = 0
                self._hour += 1
                if self._hour == 24:
                    self._hour = 0

    def __str__(self):
        """显示时间"""
        return '%02d:%02d:%02d' % \
               (self._hour, self._minute, self._second)


def main():
    clock = Clock(23, 59, 58)
    while True:
        print(clock)
        sleep(1)
        clock.run()


if __name__ == '__main__':
    main()

"""
第十二个程序 - 定义一个类描述平面上的点并提供移动点和计算到另一个点距离的方法。
Version:0.1
Author:贺松
Date:2018-3-12
"""
from math import sqrt


class Point(object):

    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def move_to(self, x, y):
        self.x = x
        self.y = y

    def move_by(self, dx, dy):
        self.x += dx
        self.y += dy

    def distance_to(self, other):
        dx = self.x - other.x
        dy = self.y - other.y
        return sqrt(dx ** 2 + dy ** 2)

    def __str__(self):
        return '(%s, %s)' % (str(self.x), str(self.y))


def main():
    p1 = Point(3, 5)
    p2 = Point()
    print(p1)
    print(p2)
    p2.move_by(-1, 2)
    print(p2)
    print(p1.distance_to(p2))


if __name__ == '__main__':
    main()