学习使用turtle在屏幕上绘制图形。

说明：turtle是Python内置的一个非常有趣的模块，特别适合对计算机程序设计进行初体验的小伙伴，它最早是Logo语言的一部分，Logo语言是Wally Feurzig和Seymour Papert在1966发明的编程语言。

1 import turtle
 2 
 3 turtle.pensize(4)
 4 turtle.pencolor('red')
 5 
 6 turtle.forward(100)
 7 turtle.right(90)
 8 turtle.forward(100)
 9 turtle.right(90)
10 
11 turtle.mainloop()

变量和类型

变量名由字母（广义的Unicode字符，不包括特殊字符）、数字和下划线构成，数字不能开头。 用type()检查变量的类型。

  • 整型：Python中可以处理任意大小的整数（Python 2.x中有int和long两种类型的整数，因此在Python 3.x中整数只有int这一种），而且支持二进制（如0b100，换算成十进制是4）、八进制（如0o100，换算成十进制是64）、十进制（100）和十六进制（0x100，换算成十进制是256）的表示法。
  • 浮点型：浮点数也就是小数，浮点数除了数学写法（如123.456）之外还支持科学计数法（如1.23456e2）。
  • 字符串型：字符串是以单引号或双引号括起来的任意文本，比如'hello'和"hello",字符串还有原始字符串表示法、字节字符串表示法、Unicode字符串表示法。
  • 布尔型：布尔值只有True、False两种值。在Python中可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来（例如3 < 5会产生布尔值True，而2 == 1会产生布尔值False）。
  • 复数型：形如3+5j，跟数学上的复数表示一样，唯一不同的是虚部的i换成了j。了解一下就可以了

可以使用Python中内置的函数对变量类型进行转换。

  • int()：将一个数值或字符串转换成整数，可以指定进制。
  • float()：将一个字符串转换成浮点数。
  • str()：将指定的对象转换成字符串形式，可以指定编码。
  • chr()：将整数转换成该编码对应的字符串（一个字符）。
  • ord()：将字符串（一个字符）转换成对应的编码（整数）。
a = int(input('a = '))     # 用input()函数获取键盘输入字符串
b = int(input('b = '))
print('%d %% %d = %d' % (a, b, a % b))    # %%表示百分号

运算符

短路处理： and运算符左边为False的情况下，右边的表达式根本不会执行； or 左边的布尔值为True的情况下，右边的表达式根本不会执行

运算符

描述

[] [:]

下标，切片

**

指数

+ - * / % //

加，减, 乘，除，模，整除

>> <<

右移，左移

& ^ | ~ 

按位与,按位异或，按位或, 按位取反

<=  <  >  >= == !=

小于等于，小于，大于，大于等于,等于，不等于

is / is not

身份运算符

in / not in

成员运算符

not / or /and

逻辑运算符

= += -= *= /= %= //= **= &= `

=^=>>=<<=`

for x in range(101):

break只能终止它所在的那个循环;  continue用来放弃本次循环后续的代码直接让循环进入下一轮。

  • range(101)：产生0到100范围的整数，需要注意的是取不到101。
  • range(1, 101)：产生1到100范围的整数，相当于前闭后开区间。
  • range(1, 101, 2)：产生1到100的奇数，其中2是步长，即每次数值递增的值。
  • range(100, 0, -2)：产生100到1的偶数，其中-2是步长，即每次数字递减的值。

函数

在Python中，函数的参数可以有默认值，也支持使用可变参数，所以Python并不需要像其他语言一样支持函数的重载，

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

 Python查找一个变量时会按照“局部作用域”、“嵌套作用域”、“全局作用域”和“内置作用域”的顺序进行搜索，所谓的“内置作用域”就是Python内置的那些标识符，我们之前用过的input、print、int等都属于内置作用域。

'''用global关键字来指示foo函数中的变量a来自于全局作用域，如果全局作用域中没有a，下面一行代码就会定义变量a并将其置于全局作用域。同理，如果希望函数内部的函数能够修改嵌套作用域中的变量，可以使用nonlocal关键字来指示变量来自于嵌套作用域'''
def foo():
    global a      
    a = 200
    print(a)  # 200

# 只有被Python解释器直接执行的模块的名字才是__main__
if __name__ == '__main__':
    a = 100
    foo()
    print(a)  # 200
  • 将函数视为“一等公民”
  • 函数可以赋值给变量
  • 函数可以作为函数的参数
  • 函数可以作为函数的返回值
  • 高阶函数的用法（filter、map以及它们的替代品）
items1 = list(map(lambda x: x ** 2, filter(lambda x: x % 2, range(1, 10))))    # [1, 9, 25, 49, 81]
items2 = [x ** 2 for x in range(1, 10) if x % 2]
  • 位置参数、可变参数、关键字参数、命名关键字参数
  • 参数的元信息（代码可读性问题）
  • 匿名函数和内联函数的用法（lambda函数）
  • 闭包和作用域问题
  • Python搜索变量的LEGB顺序（Local >>> Embedded >>> Global >>> Built-in）
  • global和nonlocal关键字的作用
    global：声明或定义全局变量（要么直接使用现有的全局作用域的变量，要么定义一个变量放到全局作用域）。
    nonlocal：声明使用嵌套作用域的变量（嵌套作用域必须存在该变量，否则报错）。

 自定义装饰器：

python logo模块 python logo语言_作用域

python logo模块 python logo语言_Python_02

from functools import wraps

def singleton(cls):
    instances = {}

    @wraps(cls)
    def wrapper(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]

    return wrapper

@singleton
class President:
    """总统(单例类)"""
    pass

用装饰器来实现单例模式

from functools import wraps
from threading import RLock

def singleton(cls):
    instances = {}
    locker = RLock()

    @wraps(cls)
    def wrapper(*args, **kwargs):
        if cls not in instances:
            with locker:
                if cls not in instances:
                    instances[cls] = cls(*args, **kwargs)
        return instances[cls]

    return wrapper

 

 

类和对象

 PEP 8要求： 受保护实例属性用单个下划线开头； 私有实例属性用两个下划线开头

封装、继承和多态

class Test:
    NUM = 11  # 静态变量
    def __init__(self, foo):
        self.__foo = foo

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

def main():
    test = Test('hello')
    Test.NUM
    test.__bar()    # AttributeError: 'Test' object has no attribute '__bar'
    test._Test__bar()    # Test._Test__bar(test) 也可通过类调用对象方法但要传入对象作为参数。
    print(test._Test__foo)

if __name__ == "__main__":
    main()

@property装饰器

@staticmethod

@classmethod

__slots__： 只对当前类的对象生效，对子类并不起任何作用

@abstractmethod

python logo模块 python logo语言_字符串_03

python logo模块 python logo语言_Python_04


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 main():
    person = Person('王大锤', 12)
    person.age = 22
    # person.name = '白元芳'  # AttributeError: can't set attribute


@property


@staticmethod

def is_valid(a, b, c)

@classmethod

def now(cls):  # 通过cls可获取和类相关信息并创建出类对象

cls("foo")

# 限定Person对象只能动态绑定_name, _age和_gender属性

__slots__ = ('_name', '_age', '_gender')

 抽象方法 --> 抽象类

  1. 实例方法：可获取类属性、构造函数定义的变量，属于 method 类型。只能通过实例化调用。
  2. 静态方法：不能获取类属性、构造函数定义的变量，属于 function 类型。两种调用方式：类.方法名 ，实例化调用。
  3. 类方法 ：可获取类属性，不能获取构造函数定义的变量，属于 method 类型。两种调用方式：类.方法名 ，实例化调用。

类和类之间的关系有三种：is-a、has-a和use-a关系。

  • is-a:  继承或泛化
  • has-a: 关联，比如部门和员工的关系，汽车和引擎的关系都属于关联关系；关联关系如果是整体和部分的关联，那么我们称之为聚合关系；如果整体进一步负责了部分的生命周期（整体和部分是不可分割的，同时同在也同时消亡），那么这种就是最强的关联关系，我们称之为合成关系。
  • use-a: 依赖，比如司机有一个驾驶的行为（方法），其中（的参数）使用到了汽车，那么司机和汽车的关系就是依赖关系。

 继承： 方法重写

def __init__(self, name, age, title):
        super().__init__(name, age)
        self._title = title

对象的复制（深复制/深拷贝/深度克隆和浅复制/浅拷贝/影子克隆）

垃圾回收、循环引用和弱引用

 　　　　Python使用了自动化内存管理，这种管理机制以引用计数为基础，同时也引入了标记-清除和分代收集两种机制为辅的策略。

  • 引用计数+1： 对象被创建、被引用、作为函数参数、作为元素存在容器中；
  • 引用计数-1： 对象别名被显示销毁、被赋予新对象、离开作用域、所在容器被销毁或从容器中删除对象。
  • 垃圾回收：调用gc.collect()、gc模块的计数器达到阀值、程序退出。

引用计数可能会导致循环引用问题，而循环引用会导致内存泄露——解决：引入“标记-清除”和“分代收集”。创建对象时，对象被放在第一代中，如果在第一代的垃圾检查中对象存活了下来，该对象就会被放到第二代中，同理在第二代的垃圾检查中对象存活下来，该对象就会被放到第三代中。