Python Note
EECS课程前期学习Python的笔记
***self.p=float(p)***，注意用float改变精度，防止精度损失
- range函数
1 | for _a in range(3): |
- 字符串
- 列表
1 | lst=[1,2,3,4,5,6,7,8] |
- 可变
- 错误举例，
remove之后L1的元素个数变化，2的索引变成了0，但是迭代的e仍然为1（从0变过来），导致2没有被计算
- print输出函数
1 | print('hello',6) |
+用于连接字符串，不可用于连接数字和字符串，首尾直接相连，不自动添加空格
，里面默认分隔符，自带空格，无论混合输出还是字符串连接
- 字典
- copy
实例中 dict2 其实是 dict1 的引用（别名），所以输出结果都是一致的，dict3 父对象进行了深拷贝，不会随dict1 修改而修改，子对象是浅拷贝所以随 dict1 的修改而修改。
1 |
|
- 键值对储存数据，逗号分隔，无序序列
1 | scores={'zhangsan':100,'lisi':78} |
字典是根据key查找value所在的位置
字典元素获取和添加
1 | scores.get()#找不到时返回None |
- key的判断
1 | print('l' in h)#in/not in判断 |
- 字典视图
1 | values=h.values() |
- 字典元素遍历
1 | for item in h:#item用于遍历键，get用于取值 |
- 字典的特点
1 | d={'name':'zhangsan','name':'lisi','name':'liu'} |
- 字典生成式
1 | itemd=['a','b','c'] |
- 总结
- 分支结构
注：两个float相等的比较：
1.直接 == 比较
2.abs相减比较
3.isclose函数比较
1 | import math |
- 循环结构
break会打破当前循环，并直接跳回上一级循环；continue跳过本次循环，并继续这级循环
1 | b=1 |
穷举法
近似思想
二分查找
- 元组
内置数据结构之一，不可变序列：没有增删改操作，如元组、字符串
可变序列：可以对序列执行增删改操作，对象地址不发生改变，如字典、列表
字典大括号{}，列表中括号[]，元组小括号（）
1 | bsg=[12,23,432,32] |
- 元组的创建
1 | t=('a','d','wd') |
- 为什么要设计成不可变序列
a.多任务环境下，同时操作对象时不需要加锁
b.程序中尽量使用不可变序列
注意：
a.若元组中对象本身是不可变对象，则不能再引用其他对象
b.若元组中的对象是可变对象，则可变对象的引用不允许改变，但是数据可以改变
1 | s=(1,2,[1,23]) |
- 元组的遍历
1 | hd=('hello','world',98) |
- 作用
- 集合
可变类型序列，是没有value的字典{key:value}
- 集合的创建方式
1 | s={'d',789,'sddsa',789,789}#集合不允许重复,且是无序存储 |
- 集合相关操作
1 | s={12,23,432,234,34} |
- 集合间的关系
1 | s1={1,2,3,4,5} |
- 集合的数据操作
1 | #交集 |
- 集合生成式
1 | #列表生成式 |
- 列表、字典、元组、集合
| 数据结构 | 是否可变 | 是否重复 | 是否有序 | 定义符号 |
|---|---|---|---|---|
| list | 可变 | 可重复 | 有序 | [] |
| tuple | 不可变 | 可重复 | 有序 | () |
| dict | 可变 | key不可重复/value可重复 | 无序 | {key:value} |
| set | 可变 | 不可重复 | 无序 | {} |
- 函数
函数会额外创建一个空间用于储存内部的数据，被调用时在其中创建一个新的空间给变量，优先使用内部变量（局部变量）
- 函数的创建
注意写完后进行输入输出注释，方便他人使用黑盒子
注意函数名和变量名不可以相同，否则程序可能无法分辨而出错
1 | def 函数名([输入参数],[参数],[参数]):#其中输入参数为形式参数 |
- 函数调用
1 | 函数名([实际参数]) |
- 函数的返回值
1 | ''' |
- 默认值参数
1 | '''如果没有给b传值，则b默认为10，否则其为传递的值''' |
- 函数的参数定义
1 | '''个数可变的位置参数：用*定义可变的位置形参 |
变量的作用域
局部变量
函数体内定义的变量
- 全局变量
函数体外定义的变量
1 | def fun3(): |
例1中函数重新定义了x=1在自己开辟的内存中，改变x的值为改变局部变量的值，未改变外部x的值，仍为5；例2只访问了x的数值，未进行改变，也未在自己的函数空间内生成x局部变量；例3，函数内部未定义x，但是尝试改变全局变量会报错（只可以访问，不可以改变）
面向对象
面向对象：事物比较复杂，使用简单的线性思维无法解决
面向过程：事物比较简单，可以使用线性思维去解决
- 类与对象
类：数据类型
对象：包含数据（变量，称为特征）和代码（函数，称为方法）的自定义数据结构
- 类的创建
1 | class Student:#student为类名，首字母大写 |
- 对象的创建（类的实例化）
1 | #Student为类对象,stu1为实例对象 |
- 类属性，类方法，静态方法的使用方式
1 | #类属性的使用方式 |
- 绑定添加属性和方法
1 | class St: |
- 总结
编程思想：
面向对象
面向过程
类对象（class）：
类属性
类方法
静态方法
实例方法
（可以类名传入对象调用Student.eat(stu1)，也可以对象名.调用stu1.eat()）
实例对象：
类名（）创建实例对象
动态绑定属性
动态绑定方法
面向对象的三大特征
封装：将属性和方法包装到类对象中；如果不希望该属性在类对象的外部被访问，前边使用两个’_’
1
2
3
4
5
6
7
8
9
10
11
12
13
14m=seFast.StateEstimator(cellSSM)
print '123',m
m.start()
print '123',m
###seFast.StateEstimator(cellSSM)仍然是一个class，即使传了参数cellSSM也不是一个实例，上面的地址前后一致，下方的地址前后不一致
print seFast.StateEstimator(cellSSM)
seFast.StateEstimator(cellSSM).start()
print seFast.StateEstimator(cellSSM).start()
print seFast.StateEstimator(cellSSM)
return seFast.StateEstimator(cellSSM)1
2
3
4
5
6
7
8
9
10
11
12class Student:
def __init__(self,name,age):
self.name=name
self.__age=age
def show(self):
print(self.name,self.__age)
stu1=Student('bsgbsg7',19)
print(dir(stu1))
#print(stu1.name,stu1.__age)
print(stu1._Student__age)
stu1.show()：继承：
1
2
3
4
5
6class 子类类名（父类1，父类2...）:
pass
'''
如果一个类没有继承任何类，则默认继承object
定义子类时，必须在其构造函数中调用父类的构造函数
'''1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34class Student:
def __init__(self,name,age):
self.name=name
self.__age=age
def show(self):
print(self.name,self.__age)
stu1=Student('bsgbsg7',19)
print(dir(stu1))#dir用于查看所有属性和方法
#print(stu1.name,stu1.__age)
print(stu1._Student__age)
stu1.show()
class Pro(object):
def __init__(self,name,age):
self.name=name
self.age=age
def info(self):
print(self.name,self.age)
class Student(Pro):
def __init__(self,name,age,number):
super().__init__(name,age)
self.number=number
class Teacher(Pro):
def __init__(self,name,age,year):
super().__init__(name,age)
self.year=year
stu1=Student('bsgbsg',12,2)
tea1=Teacher('nds',19,29)
stu1.info()
tea1.info()
1
2class C(A,B):
pass方法重写
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15class Student(Pro):
def __init__(self,name,age,number):
super().__init__(name,age)
self.number=number
def info(self):#方法重写，可以类比变量作用域理解
super().info()#希望调用父类中的方法
print('学号：',self.number)
class Teacher(Pro):
def __init__(self,name,age,year):
super().__init__(name,age)
self.year=year
def info(self):
super().info()
print('教龄：',self.year)object类
是所有类的父类，所有类都有object的属性和方法
1
2
3
4
5
6
7
8
9
10class Student():
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self):
return '我的名字是{0}，今年{1}岁了'.format(self.name,self.age)
stu=Student('zhangsan',20)
print(dir(stu))
print(stu)#默认调用__str__()方法，返回内存地址；重写后输出自己写的东西，经常用于返回对象的描述
print(type(stu))多态：提高程序得到可扩展性和可维护性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20class Animal(Object):
def eat(self):
print('eat')
class Dog(Animal):
def eat(self):#重写了父类中的方法
print('狗')
class Cat(Animal):
def eat(self):
print('猫')
class Per:
def eat(self):
print('人')
def eat(animal):
animal.eat()#调用该对象的eat方法
eat(Per())#即使Per没有继承父类，但只要有eat方法就可以使用特殊属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32class Student():
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self):
return '我的名字是{0}，今年{1}岁了'.format(self.name,self.age)
stu=Student('zhangsan',20)
print(dir(stu))
print(stu)#默认调用__str__()方法，返回内存地址；重写后输出自己写的东西，经常用于返回对象的描述
print(type(stu))
'''对象.__dict__返回一个字典，查看对象属性'''
class A:
pass
class B:
pass
class C(A,B):
def __init__(self,name,age):
self.name=name
self.age=age
c=C('bsgbsg7',19)
print(c.__dict__)#返回实例对象的属性
print(C.__dict__)#返回类对象的属性和方法，方法只在类对象中，实例对象只可以调用
print(c.__class__)#x.__class__输出对象所属于的类
print(C.__bases__)#C类与父类的元素，C只可以是类，不可以是实例对象
print(C.__base__)#输出一个，谁写在前面输出谁
print(C.__mro__)#类的层次结构
print(A.__subclasses__())#A的子类列表，注意后面还有个括号特殊方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25a=20
b=18
c=a+b
d=a.__add__(b)
print(c,d)
class Student:
def __init__(self,name):
self.name=name
'''+运算对应__add__()方法'''
def __add__(self,other):
return self.name+other.name
'''len()函数对应__len__()方法'''
def __len__(self):
return len(self.name)
stu1=Student('bsg')
stu2=Student('bsg7')
stu3=stu1+stu2
print(stu3)#通过修改Student类中的add特殊方法使量对象可以相加
s=stu1.__add__(stu2)
print(s)
print(len(stu1),stu1.__len__())
1
2
3
4
5
6
7
8
9
10
11class Student:
def __init__(self,name,age):
self.name=name
self.age=age
def __new__(cls, *args, **kwargs):
obj=super().__new__(cls)
return obj
st=Student('bsgbsg',19)
print(st.__class__)#<class '__main__.Student'>加速递归
本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 Bsgbsg7's World！
wechat
评论