python随笔

 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的情况下，右边的表达式根本不会执行

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

类和对象

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

 面向对象有三大支柱：封装、继承和多态

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

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

def main():
    test = Test(‘hello‘)
    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
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可获取和类相关信息并创建出类对象     return cls("foo")	# 限定Person对象只能动态绑定_name, _age和_gender属性 __slots__ = (‘_name‘, ‘_age‘, ‘_gender‘)	抽象方法 --> 抽象类

类和类之间的关系有三种：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