[Python知识库]Python - 100天从新手到大师-

（1）历史

1994第一个正式版本发布。2000年10月16日：Python 2.0发布，2008年12月3日：Python 3.0发布

（2）海归绘图turtle

1.abs()函数如何实现的？

摘自文档的一段代码：

from turtle import *
#设定笔画颜色和填充颜色
color('red', 'yellow')
begin_fill()
while True:
    forward(200)
    #转向170度，每个角都是10度。
    left(170)
    #这里abs()函数，对应的实现是类内定义的__abs__()函数
    #直到回到原点（坐标为0,0）时，结束。一共重复了36次。
    if abs(pos()) < 1:
        break
end_fill()
done()

画出的图是：

abs（）对应的类内实现：

（3）语言元素

1.计算机五大组件

1. 运算器、控制器、存储器、输入设备和输出设备

2.冯诺依曼结构

存储设备与中央处理器分开，二是提出了将数据以二进制方式编码。
提到了玛雅文明，其采用二十进制。导致有什么纪元的太阳纪，传成世界末日。

3.变量命名

受保护的实例属性用单个下划线开头。
ord()和chr()正相反，都是字符相关。

4.占位符语法打印

#
print('%d + %d = %d' % (a, b, a + b))

闰年必须是4的倍数但不是100或者400的倍数。奇怪。

（4）循环结构

1.range()用法

这可以用来对偶数求和：

"""
用for循环实现1~100之间的偶数求和

Version: 0.1
Author: 骆昊
"""

sum = 0
for x in range(2, 101, 2):
    sum += x
print(sum)

显然，这比用if判断的好多了：

"""
用for循环实现1~100之间的偶数求和

Version: 0.1
Author: 骆昊
"""

sum = 0
for x in range(1, 101):
    if x % 2 == 0:
        sum += x
print(sum)

2.while用法-猜数字

一般是事先不知道循环多少次的时候用。

"""
猜数字游戏

Version: 0.1
Author: 骆昊
"""
import random

answer = random.randint(1, 100)
counter = 0
while True:
    counter += 1
    number = int(input('请输入: '))
    if number < answer:
        print('大一点')
    elif number > answer:
        print('小一点')
    else:
        print('恭喜你猜对了!')
        break
print('你总共猜了%d次' % counter)
if counter > 7:
    print('你的智商余额明显不足')

这个猜数字的小游戏也很好玩。用了二分法。

3.打印9-9乘法表

#作者是我自己
for i in range(1,10):
    for j in range(1,i+1):
        print(f"{i}*{j}={i*j}",end='\t')
    print()
 

4.判断质数

import math
num = int(input("number"))
end = int(math.sqrt(num))
for i in range(2, end + 1):
    if num % i == 0:
        print(f'No,factor is {i}')
        exit()
print("Yes")

（5）构造程序逻辑

关键是将自然语言，转化为程序设计语言。这需要锻炼。

1.整数翻转

这是我自己写的：

num = 12348
x = num
y=0
while True:
    dig = x % 10
    y *= 10
    y += dig
    x //= 10
    if x ==0:
        break
print(y)

这是大佬写的：

"""
正整数的反转

Version: 0.1
Author: 骆昊
"""

num = int(input('num = '))
reversed_num = 0
while num > 0:
    reversed_num = reversed_num * 10 + num % 10
    num //= 10
print(reversed_num)

高下立见。

2.CRAPS赌博游戏。

真好玩。赌博确实上瘾。这显示每次的钱，很上头。

"""
Craps赌博游戏
我们设定玩家开始游戏时有1000元的赌注
游戏结束的条件是玩家输光所有的赌注

Version: 0.1
Author: 骆昊
"""
from random import randint

money = 1000
while money > 0:
    print('你的总资产为:', money)
    needs_go_on = False
    while True:
        debt = int(input('请下注: '))
        if 0 < debt <= money:
            break
    first = randint(1, 6) + randint(1, 6)
    print('玩家摇出了%d点' % first)
    if first == 7 or first == 11:
        print('玩家胜!')
        money += debt
    elif first == 2 or first == 3 or first == 12:
        print('庄家胜!')
        money -= debt
    else:
        needs_go_on = True
    while needs_go_on:
        needs_go_on = False
        current = randint(1, 6) + randint(1, 6)
        print('玩家摇出了%d点' % current)
        if current == 7:
            print('庄家胜')
            money -= debt
        elif current == first:
            print('玩家胜')
            money += debt
        else:
            needs_go_on = True
print('你破产了, 游戏结束!')

3.打印斐波那契数列

f1, f2 = 1,1
for  i  in range(100):
    print(f1,f2,end=' ')
    f1 =f1 + f2
    f2 = f1 + f2

结果：

（5）定义函数

1.可变参数

这个可变参数就是一个列表。

# 在参数名前面的*表示args是一个可变参数
def add(*args):
    total = 0
    for val in args:
        total += val
    return total

2.模块

每个文件就是一个模块。

导入模块时，相当于执行其中的语句。因为其中的函数定义就相当于是语句。因此如果有不希望在导入时执行的代码，需要放到if __name__ == '__main__':中：

def foo():
    pass


def bar():
    pass


# __name__是Python中一个隐含的变量它代表了模块的名字
# 只有被Python解释器直接执行的模块的名字才是__main__
if __name__ == '__main__':
    print('call foo()')
    foo()
    print('call bar()')
    bar()

3.变量作用域

Python查找一个变量时会按照“局部作用域”、“嵌套作用域”、“全局作用域”和“内置作用域”的顺序进行搜索。
要尽量少使用全局变量。因为有个“迪米特法则”：最少知道原则。
golal关键字是指示这个变量为全局作用域中的变量。
本章的关键：以后采用这种方式写代码：

（6）字符串和常用数据结构

1.计算机的诞生

第二次世界大战促使了现代电子计算机的诞生，最初计算机被应用于导弹弹道的计算。主要处理数值数据。但是现在我们想让它处理文本等一系列数据。

2.字母r

即，原样输出文本，不进行转义。（我今天写路径还遇到了这个问题。文件路径中出现了/，我傻傻地将/替换成了\。其实加一个r就直接解决了）

s1 = r'\'hello, world!\''
s2 = r'\n\\hello, world!\\\n'
print(s1, s2, end='')

3.字符串的一些方法

链接

4.列表生成式

即，[]创建的是列表，已经分配内存的列表；而()创建的是生成器。

# 用列表的生成表达式语法创建列表容器
# 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
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)

没想到斐波那契数列也这么有规律：

5.在屏幕上显示跑马灯文字

即：

实现逻辑是每次让打印的字符串变一点就行：

import os
import time


def main():
    content = '北京欢迎你为你开天辟地…………'
    while True:
        # 清理屏幕上的输出
        os.system('cls')  # os.system('clear')
        print(content)
        # 休眠200毫秒
        time.sleep(0.2)
        content = content[1:] + content[0]


if __name__ == '__main__':
    main()

6.《python编程快速上手》

大佬也推荐这本书了。

（7）面向对象

1.面向对象的历史

人和机器的思维方式不一样。机器是顺序执行而已，人了不是这样。因此出现了人类思维和机器思维的不同，导致复杂的工程难以开发。以至于所以在上世纪60年代末期，“软件危机”、"软件工程"等一系列的概念开始在行业中出现。后来引入面向对象的思想（最早出现于Simula语言），是解决了一部分这个问题。但并没有全部解决。

2.什么是面向对象编程

3.对象的方法接受的是消息

def main():
    # 创建学生对象并指定姓名和年龄
    stu1 = Student('骆昊', 38)
    # 给对象发study消息
    stu1.study('Python程序设计')
    # 给对象发watch_av消息
    stu1.watch_movie()
    stu2 = Student('王大锤', 15)
    stu2.study('思想品德')
    stu2.watch_movie()


if __name__ == '__main__':
    main()

大佬在CSDN也有账号。值得一看。

4.如何访问私有方法

在私有方法前面加_Test，变成这样test._Test__bar()就能访问。但是如果直接访问就不可以，比如test.__bar()

class Test:

    def __init__(self, foo):
        self.__foo = foo

    def __bar(self):
        print(self.__foo)
        print('__bar')


def main():
    test = Test('hello')
    
    test._Test__bar()
    print(test._Test__foo)


if __name__ == "__main__":
    main()

（8）面向对象进阶

1.@property装饰器

加了之后，函数返回的值就成为了类的一个属性。名字就是方法名字。
@property装饰器作用：把一个方法变成属性调用。

class Person(object):

    def __init__(self, name, age):
        self._name = name
        self._age = age

    # 访问器 - getter方法
    @property
    def name(self):
        return self._name

    # 访问器 - getter方法
    @property
    def age(self):
        return self._age

    # 修改器 - setter方法
    @age.setter
    def age(self, age):
        self._age = age

    def play(self):
        if self._age <= 16:
            print('%s正在玩飞行棋.' % self._name)
        else:
            print('%s正在玩斗地主.' % self._name)


def main():
    person = Person('王大锤', 12)
    person.play()
    person.age = 22
    person.play()
    # person.name = '白元芳'  # AttributeError: can't set attribute


if __name__ == '__main__':
    main()

这不是很理解，@getter和@setter。应该就是对应着，能否修改属性的值。

2.__slots__魔法

没看，是为了限制对象绑定的属性的。

3.静态方法和类方法

之前的方法，都是发送给对象消息的方法。但是有时候还没有创建出对象，就需要调用某个方法。比如，算三角形面积的类。首先得判断输入的三个边能否组成三角形，然后再算面积。那么判断函数就是属于类的方法：

from math import sqrt


class Triangle(object):

    def __init__(self, a, b, c):
        self._a = a
        self._b = b
        self._c = c

    @staticmethod
    def is_valid(a, b, c):
        return a + b > c and b + c > a and a + c > b

    def perimeter(self):
        return self._a + self._b + self._c

    def area(self):
        half = self.perimeter() / 2
        return sqrt(half * (half - self._a) *
                    (half - self._b) * (half - self._c))


def main():
    a, b, c = 3, 4, 5
    # 静态方法和类方法都是通过给类发消息来调用的
    if Triangle.is_valid(a, b, c):
        t = Triangle(a, b, c)
        print(t.perimeter())
        # 也可以通过给类发消息来调用对象方法但是要传入接收消息的对象作为参数
        # print(Triangle.perimeter(t))
        print(t.area())
        # print(Triangle.area(t))
    else:
        print('无法构成三角形.')


if __name__ == '__main__':
    main()

4.类方法

类方法的第一个参数约定名为cls，它代表的是当前类相关的信息的对象（类本身也是一个对象，有的地方也称之为类的元数据对象），通过这个参数我们可以获取和类相关的信息并且可以创建出类的对象

Python 类方法和实例方法相似，它最少也要包含一个参数，只不过类方法中通常将其命名为 cls，Python 会自动将类本身绑定给 cls 参数（注意，绑定的不是类对象）。也就是说，我们在调用类方法时，无需显式为 cls 参数传参。

下面代码中，类方法直接实例化了一个对象。cls就相当于Clock。

from time import time, localtime, sleep


class Clock(object):
    """数字时钟"""

    def __init__(self, hour=0, minute=0, second=0):
        self._hour = hour
        self._minute = minute
        self._second = second

    @classmethod
    def now(cls):
        ctime = localtime(time())
        return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)

    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 show(self):
        """显示时间"""
        return '%02d:%02d:%02d' % \
               (self._hour, self._minute, self._second)


def main():
    # 通过类方法创建对象并获取系统时间
    clock = Clock.now()
    while True:
        print(clock.show())
        sleep(1)
        clock.run()


if __name__ == '__main__':
    main()

5.类之间的关系

is-a那种。很复杂，后面再看吧。

6.抽象类

python中没有对抽象类的语法支持，需要额外的abc包。

7.骆昊奥特曼打怪兽

太有意思了。学霸真会玩。拷贝下来代码，以供观赏：

from abc import ABCMeta, abstractmethod
from random import randint, randrange


class Fighter(object, metaclass=ABCMeta):
    """战斗者"""

    # 通过__slots__魔法限定对象可以绑定的成员变量
    __slots__ = ('_name', '_hp')

    def __init__(self, name, hp):
        """初始化方法

        :param name: 名字
        :param hp: 生命值
        """
        self._name = name
        self._hp = hp

    @property
    def name(self):
        return self._name

    @property
    def hp(self):
        return self._hp

    @hp.setter
    def hp(self, hp):
        self._hp = hp if hp >= 0 else 0

    @property
    def alive(self):
        return self._hp > 0

    @abstractmethod
    def attack(self, other):
        """攻击

        :param other: 被攻击的对象
        """
        pass


class Ultraman(Fighter):
    """奥特曼"""

    __slots__ = ('_name', '_hp', '_mp')

    def __init__(self, name, hp, mp):
        """初始化方法

        :param name: 名字
        :param hp: 生命值
        :param mp: 魔法值
        """
        super().__init__(name, hp)
        self._mp = mp

    def attack(self, other):
        other.hp -= randint(15, 25)

    def huge_attack(self, other):
        """究极必杀技(打掉对方至少50点或四分之三的血)

        :param other: 被攻击的对象

        :return: 使用成功返回True否则返回False
        """
        if self._mp >= 50:
            self._mp -= 50
            injury = other.hp * 3 // 4
            injury = injury if injury >= 50 else 50
            other.hp -= injury
            return True
        else:
            self.attack(other)
            return False

    def magic_attack(self, others):
        """魔法攻击

        :param others: 被攻击的群体

        :return: 使用魔法成功返回True否则返回False
        """
        if self._mp >= 20:
            self._mp -= 20
            for temp in others:
                if temp.alive:
                    temp.hp -= randint(10, 15)
            return True
        else:
            return False

    def resume(self):
        """恢复魔法值"""
        incr_point = randint(1, 10)
        self._mp += incr_point
        return incr_point

    def __str__(self):
        return '~~~%s奥特曼~~~\n' % self._name + \
            '生命值: %d\n' % self._hp + \
            '魔法值: %d\n' % self._mp


class Monster(Fighter):
    """小怪兽"""

    __slots__ = ('_name', '_hp')

    def attack(self, other):
        other.hp -= randint(10, 20)

    def __str__(self):
        return '~~~%s小怪兽~~~\n' % self._name + \
            '生命值: %d\n' % self._hp


def is_any_alive(monsters):
    """判断有没有小怪兽是活着的"""
    for monster in monsters:
        if monster.alive > 0:
            return True
    return False


def select_alive_one(monsters):
    """选中一只活着的小怪兽"""
    monsters_len = len(monsters)
    while True:
        index = randrange(monsters_len)
        monster = monsters[index]
        if monster.alive > 0:
            return monster


def display_info(ultraman, monsters):
    """显示奥特曼和小怪兽的信息"""
    print(ultraman)
    for monster in monsters:
        print(monster, end='')


def main():
    u = Ultraman('骆昊', 1000, 120)
    m1 = Monster('狄仁杰', 250)
    m2 = Monster('白元芳', 500)
    m3 = Monster('王大锤', 750)
    ms = [m1, m2, m3]
    fight_round = 1
    while u.alive and is_any_alive(ms):
        print('========第%02d回合========' % fight_round)
        m = select_alive_one(ms)  # 选中一只小怪兽
        skill = randint(1, 10)   # 通过随机数选择使用哪种技能
        if skill <= 6:  # 60%的概率使用普通攻击
            print('%s使用普通攻击打了%s.' % (u.name, m.name))
            u.attack(m)
            print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))
        elif skill <= 9:  # 30%的概率使用魔法攻击(可能因魔法值不足而失败)
            if u.magic_attack(ms):
                print('%s使用了魔法攻击.' % u.name)
            else:
                print('%s使用魔法失败.' % u.name)
        else:  # 10%的概率使用究极必杀技(如果魔法值不足则使用普通攻击)
            if u.huge_attack(m):
                print('%s使用究极必杀技虐了%s.' % (u.name, m.name))
            else:
                print('%s使用普通攻击打了%s.' % (u.name, m.name))
                print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))
        if m.alive > 0:  # 如果选中的小怪兽没有死就回击奥特曼
            print('%s回击了%s.' % (m.name, u.name))
            m.attack(u)
        display_info(u, ms)  # 每个回合结束后显示奥特曼和小怪兽的信息
        fight_round += 1
    print('\n========战斗结束!========\n')
    if u.alive > 0:
        print('%s奥特曼胜利!' % u.name)
    else:
        print('小怪兽胜利!')


if __name__ == '__main__':
    main()

（9）图形用户界面和游戏开发

1.效果

主要讲了pygame

（10）文件和异常

1.