Python复习

常用操作符

**表示平方，//表示地板除法，/表除法
优先级：+ - 之类是一元操作符，逻辑运算符 and or not叫二元操作符，not or and 的优先级是不同的：not > and > or

特殊：双目操作符比左边的优先级高比右边操作符低

>>> -3**2

-9

>>> -(3**2)

-9
>>> 4**-2

0.0625

>>> 4**(-2)

0.0625

分支和循环

assert后面若是假则程序自爆

列表

列表里可以放不同类型的数据

增添元素
append()为列表增加元素，每次输入一个
extend([])扩张原理是用一个列表扩张另一个列表，所以参数应该是列表
insert（x，y），x是位置，y是增添的元素

删除元素
remove()与append同理
del语句 例如：del list
pop()从列表中取出一个元素并返回，在pycharm里看不到，里面加数字就和del同理

列表切片
列表切片拷贝是‘真’拷贝，之后切片的列表改变，拷贝后的不改变
列表直接赋给另一个列表是‘假’拷贝，原列表改变，拷贝后的也改变
列表可以进行比较和运算

元组就是不能修改的列表
tuple = (1,‘asw’)
元组的创建：
1.tuple = (1,)
注意要是元组里就一个元素要加 ‘ ，’，若是tuple = (1),则它认为tuple是一个整形
2.tuple = 1,
有‘ ，‘就可以认为tuple是一个元组
注意：元组一定要注意逗号

函数文档
def function():
'被单引号括起来的就是函数文档内容’
查看文档：function.doc

函数式编程重要语法结构：闭包
表现形式定义：如果在一个内部函数里对外部作用域（但不是在全局作用域）的变量进行引用，那内部函数就被认为是闭包。
调用：

1.
def funa(x):
    '打印这里'
    def funb(y):
        print('闭包+',x)
        return x*y
    return  funb
print(funa.__doc__)
i=funa(8)                             #这里i的类型是一个函数类型
print(i(5))

2.
def funa(x):
    '打印这里'
    def funb(y):
        print('闭包+',x)
        return x*y 
    return  funb
print(funa.__doc__)
print(funa(8)(5))

若直接调用funb(8)则会报错

使用变量时注意事项：

def funa():
    '打印这里'
    x=5
    def funb():
        x * = x               #这里想对x进行平方，但是在外面的x=5在funb()的外部作用域，会被屏蔽，所以x相当于没被定义
        return x
    return  funb
funa()
 该程序无法运行！

解决方案：
python3之前方案：容器类型不会被屏蔽

def funa():
    '打印这里'
    x = [5]
    def funb():
        x[0] *= x[0]
        return x[0]
    return  funb
print(funa()())

python3解决方案：关键字 nonlocal

def funa():
    '打印这里'
    x = 5
    def funb():
        nonlocal x
        x *= x
        return x
    return  funb
print(funa()())

运行结果：

类和对象

对象 = 属性 + 方法
描述一个对象：静态的成为属性，动态的称为方法
做类是为了达到量产对象的效果

#类对象：
class Tirtle:                               #python中类名是以大写字母开头
	#属性
	color = 'green'
	weight = 10
	legs = 4
			
	#方法
	def climb():
	    print("我在努力爬...")
	def run():
	    print('我跑可快了')

面向对象一般叫OO=Object Oriented
OO的特征:
1.封装
2.继承：子类自动共享父类之间数据和方法的机制
3.多态：不同对象对同一方法响应不同的行动

self

class Ball:
    def setname(self,name):
        self.name = name
    def kick(self):
        print('我叫%s，谁踢得我！'%self.name)

a = Ball()
a.setname('球A')
b = Ball()
b.setname('球B')
c = Ball()
c.setname('球C')
a.kick()
c.kick()

结果：

self就像门牌号，创建类时候第一个参数记得加self

面向对象编程

python的魔法方法

1. _init_(self)

class Ball:
    def __init__(self,name):             #这句语句打出在调用的时候就必须传入参数，不能如c=Ball()这样
        self.name = name
    def kick(self):
        print('我叫%s，谁踢得我！'%self.name)

b = Ball('土豆')
b.kick()

公有和私有

私有：name magling 名字改编/名字重整
在python中定义私有变量只需要在变量名或函数名前加上‘__’两个下划线，那么这个函数或变量就变为私有的了
若要引用私有变量，则在函数内部引用，或者：_类名__变量名（第一个单划线，第二个双划线）

class Plane:
        ___name = '波音747'
    def get(self):
        return self.___name
print(d.get())
print（d._Plane__name)

父类和子类

继承

class DerivedClassName(BaseClassName):
      子类              基类、父类或超类

调用例子：

class Father:
    def say(self):
        print("调用父类")
class Son(Father):
    pass
x = Father()
x.say()
c = Son()
c.say()
#结果都是打印调用父类

若父类和子类中有函数名一样：

class Father:
    def say(self):
        print("调用父类")
class Son(Father):
    def say(self):
        print("调用子类")
x = Father()
x.say()
c = Son()
c.say()
#子类不会被影响

调用未绑定的父类方法：

class Father:
    def __init__(self):
        print("调用父类")
class Son(Father):
    def __init__(self):
        Father.__init__(self)      #此语句将父类初始化传递给子类，但子类下面还是会运行
        print("调用子类")
x = Father()

c = Son()

结果：

经测试，想要调用类里的变量，只能调用属性里的变量，而且不能修改，方法里的变量无法调用，除了_init_里的变量，想查看类里的内容可以用_dict_，会以字典的方式输出
创建一个对象（实例化）过程是创建一个对象空间，把这个空间地址赋给对象

class Father:
    def __init__(self):
        self.x = 5
    def cal(self):
        print(self.x)
class Son(Father):
    def __init__(self):
        Father.__init__(self)
        self.x = 6             #进行完继承后执行此语句x还是变成了6
    def cal(self):
        print(self.x)
b = Father()
B=b.cal()
c = Son()
C=c.cal()

结果：

super方法：

class Father:
    def __init__(self):
        self.x = 5
    def cal(self):
        print(self.x)
class Son(Father):
    def __init__(self):
        super()._init_()             #不用给基类名字，自动寻找
    def cal(self):
        print(self.x)
c = Son()
C=c.cal()

多继承：
只需要在（）里放入想要继承的n个父类即可
### Python的魔法方法

构造和析构

1.__new__(cls[,...]):实例化时候第一个被调用的方法
传入的是对象，传入的参数都会传入init（）里，平时极少重写
当继承一个不可变类型时，又需要进行修改，就需要重写new(）
2.__del__(self)
当对象被销毁时调用，注意只有所有对它的引用都被del之后才会启动垃圾回收机制，也就是调用该方法
实测在实例化时就被调用了。。。。。。

简单定制

import time as t

class Mytimer:
    #开始计时
    def start(self):
        self.start = t.localtime()
        print("计时开始")
    def stop(self):
        self.stop = t.localtime()
        self.__call()
        print('计时结束')
    #内部方法计算运行时间
    def __call(self):
        self.lasted = []
        self.prompt = '总共运行了'
        for index in range(6):
            self.lasted.append(self.stop[index]-self.start[index])
            self.prompt += str(self.lasted[index])
        print(self.prompt)
t1 = Mytimer()
t1.start()
x = input('\n结束计时请按1')
if x:
    t1.stop()

                       结果：