4.27 今天继续学习了Java的继承、多态等等，同时学到了几个好用的快捷键，下面总结一下（ps:继承其实就是共性抽取）：
1.快捷键 在idea的开发环境中，可以用这个快捷方式弹出一个交互界面，可以帮助我们直接构造方法、创建setter、getter等等，感觉挺好用的。
如果要对构造方法合并表示，可以直接全选：（好吧确实有点傻，但我确实不知道）
批量修改：对相同的变量名统一修改
搜索想要找的类，方法等等：
idea环境中自动纠错：
自动显示参数
2.java知识点 <1>final 修饰符
修饰方法：方法不能重写，是最终方法
修饰类： 类不能被继承，是最终类
修饰变量：叫做常量，只能被赋值一次
<2>权限修饰符的使用规则
成员变量私有
方法公开
特例：如果方法中的代码是抽取到其他代码中的共性代码，这个方法一般也私有。
<3>抽象 作用：抽取共性时，无法确定方法体，就把方法定义为抽象的。
抽象方法：将共性的方法抽取到父类之后，由于每一个子类执行的内容不一样，所以在父类中不能确定具体的方法体，该方法就可以定义为抽象方法。
抽象方法没有方法体
1 public abstract 返回值类型 方法名（参数列表）;
抽象类：如果一个类中存在抽象方法，那么这个类必须声明为抽象类
1 public abstract class 类名{};
注意事项：
抽象类不能实例化，即不能创建对象；
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类；
可以有构造方法（作用：创建子类方法时给属性进行赋值）；
抽象类的子类要么重写抽象类中的所有抽象方法，要么是抽象类，多用第一种。
4.29 昨天参加了一个Python训练项目，本来想测试一下成绩提交是不是正常的，但是没料到成绩直接上了排行榜。。。啊啊啊啊我其实还没接触过Python。。。
if if … elif … elif … 序列可以当作其它语言中 switch 或 case 语句的替代品。
内置函数 range() 用于生成等差数列：
1 2 3 4 5 6 7 8 list(range(5, 10)) [5, 6, 7, 8, 9] list(range(0, 10, 3)) [0, 3, 6, 9] list(range(-10, -100, -30)) [-10, -40, -70]
要按索引迭代序列，可以组合使用 range() 和 len()：
1 2 3 4 5 6 7 8 9 a = ['Mary', 'had', 'a', 'little', 'lamb'] for i in range(len(a)): print(i, a[i]) 0 Mary 1 had 2 a 3 little 4 lamb
break和contiune break 语句将跳出最近的一层 for 或 while 循环:
1 2 3 4 5 6 7 8 9 10 for n in range(2, 10): for x in range(2, n): if n % x == 0: print(f"{n} equals {x} * {n//x}") break 4 equals 2 * 2 6 equals 2 * 3 8 equals 2 * 4 9 equals 3 * 3
continue 语句将继续执行循环的下一次迭代:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 for num in range(2, 10): if num % 2 == 0: print(f"Found an even number {num}") continue print(f"Found an odd number {num}") Found an even number 2 Found an odd number 3 Found an even number 4 Found an odd number 5 Found an even number 6 Found an odd number 7 Found an even number 8 Found an odd number 9
高级数据 切片 [start:end:step] step默认1
1 2 3 4 5 6 jing=[1,2,8,90,'啊哈哈',True] print(jing[0:3]) print(jing[-1]) print(jing[:]) print(jing[3:6]) print(jing[0:6:2])
运行效果：
1 2 3 4 5 [1, 2, 8] True [1, 2, 8, 90, '啊哈哈', True] [90, '啊哈哈', True] [1, 8, '啊哈哈']
（目前的编程练习中，感觉python和Java有相似之处，都出现了
1 for ... in ... //目前的理解是把第二个空中的数据结构里的每个元素赋值给第一个空中的索引
不好，这玩意不叫索引，索引应该是和Java里数组下标一样
总之就是 for i in w 的意思就是返回 w 中的每个 i
列表的 * 增删查改 * 方法 增 1.extend和attend
前者方法的参数必须是一个可迭代对象，新的内容是追加到原列表最后一个元素后面
后者方法一次添加一个列表。
二者都把新内容加在原列表后面。
1 2 3 4 5 6 practice=['唱','跳','rap'] practice.append('篮球') print(practice) practice.extend(['鸡','坤']) print(practice)
运行效果
1 2 ['唱', '跳', 'rap', '篮球'] ['唱', '跳', 'rap', '篮球', '鸡', '坤']
2.insert 可以直接在列表任何一个位置插入，有两个参数
insert(a:插入点的前一个元素索引，b:元素内容)
删 1.remove
remove(删除元素内容)
如果存在多个匹配的元素，只删除第一个（下标最小的）
指定元素不存在会直接报错
2.clear 清除列表中所有元素，返回一个空列表
改和查完了再说，这里不多说了 元组(特性：不可修改) 1 2 3 4 5 6 7 8 9 10 11 12 s=('w',1,'啦啦啦',2) print(s.index(1)) a=(1,3,7,9,4) t=(2,3,4) w=a,t print(a*3) print(a+t) print(w) print([each*2 for each in t])
运行效果
1 2 3 4 5 6 1 (1, 3, 7, 9, 4, 1, 3, 7, 9, 4, 1, 3, 7, 9, 4) (1, 3, 7, 9, 4, 2, 3, 4) ((1, 3, 7, 9, 4), (2, 3, 4)) [4, 6, 8]
元组只含一个元素时，要这样写（元素,）
1 2 3 4 5 t=(1,4,8) #把1，4，8打包到元组 x,y,z=t #把元组t解包到x,y,z print(x) print(y) print(z)
运行效果
打包和解包在数组，字符串等等同样适用
这也是python多重赋值的原理
元组不可变，但是如果元组中的元素指向一个可变的列表，那么内容依旧可以改
此后笔记记录的内容仅含有关键字，剩余内容看官方文档补足
is 和 in
列表，元组，字符串相互转换关键字list(),tuple(),str()
字典
函数 关键字函数 收集函数 1 2 3 def myfunc(a,*b,**c): print(a,b,c) myfunc(1,34,5,6,74,3,5,x=1,y=4)
一个星号表示数据打包到元组，两个星号表示数据打包到字典
1 1 (34, 5, 6, 74, 3, 5) {'x': 1, 'y': 4}
星号在形参上调用是参数的打包，实参上调用是参数的解包
1 2 3 4 args=(1,2,3,4) def myfunc(a,b,c,d): print(a,b,c,d) myfunc(*args)
这里args前不用星号解包的话会直接报错
运行效果：
1 2 3 4 kwargs= {'a':1,'b':2,'c':3,'d':4} def myfunc(a,b,c,d): print(a,b,c,d) myfunc(**kwargs)
运行效果
嵌套函数 nonlocal语句可以实现内部函数值修改外部函数值 1 2 3 4 5 6 7 8 9 def funA(): x=34 def funB(): nonlocal x x=45 print("in funB:x=",x) funB() print("in funA:x=",x) funA()
运行效果
1 2 in funB:x= 45 in funA:x= 45
LEGB 规则 L>E>G>B
匿名函数
lambda 函数通常只包含一行代码，这使得它们适用于编写简单的函数。
1 lambda arguments: expression
lambda: Python 的关键字，用于定义 lambda 函数。
arguments: 参数列表，可以包含零个或多个参数，但必须在冒号(:)前指定。
expression: 一个表达式，用于计算并返回函数的结果。
装饰器 装饰器本质上是一个接收函数作为输入并返回一个新的包装过后的函数的对象。
（这玩意目前看不懂，先过了）
数据结构 列表 在这里不看具体函数，有个用列表当栈使用的例子：
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 34 35 36 37 class Stack: def __init__(self): self.stack = [] def push(self, item): self.stack.append(item) def pop(self): if not self.is_empty(): return self.stack.pop() else: raise IndexError("pop from empty stack") def peek(self): if not self.is_empty(): return self.stack[-1] else: raise IndexError("peek from empty stack") def is_empty(self): return len(self.stack) == 0 def size(self): return len(self.stack) # 使用示例 stack = Stack() stack.push(1) stack.push(2) stack.push(3) print("栈顶元素:", stack.peek()) # 输出: 栈顶元素: 3 print("栈大小:", stack.size()) # 输出: 栈大小: 3 print("弹出元素:", stack.pop()) # 输出: 弹出元素: 3 print("栈是否为空:", stack.is_empty()) # 输出: 栈是否为空: False print("栈大小:", stack.size()) # 输出: 栈大小: 2
实现队列 用deque实现
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 from collections import deque # 创建一个空队列 queue = deque() # 向队尾添加元素 queue.append('a') queue.append('b') queue.append('c') print("队列状态:", queue) # 输出: 队列状态: deque(['a', 'b', 'c']) # 从队首移除元素 first_element = queue.popleft() print("移除的元素:", first_element) # 输出: 移除的元素: a print("队列状态:", queue) # 输出: 队列状态: deque(['b', 'c']) # 查看队首元素（不移除） front_element = queue[0] print("队首元素:", front_element) # 输出: 队首元素: b # 检查队列是否为空 is_empty = len(queue) == 0 print("队列是否为空:", is_empty) # 输出: 队列是否为空: False # 获取队列大小 size = len(queue) print("队列大小:", size) # 输出: 队列大小: 2
用列表实现
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 34 35 36 37 class Queue: def __init__(self): self.queue = [] def enqueue(self, item): self.queue.append(item) def dequeue(self): if not self.is_empty(): return self.queue.pop(0) else: raise IndexError("dequeue from empty queue") def peek(self): if not self.is_empty(): return self.queue[0] else: raise IndexError("peek from empty queue") def is_empty(self): return len(self.queue) == 0 def size(self): return len(self.queue) # 使用示例 queue = Queue() queue.enqueue('a') queue.enqueue('b') queue.enqueue('c') print("队首元素:", queue.peek()) # 输出: 队首元素: a print("队列大小:", queue.size()) # 输出: 队列大小: 3 print("移除的元素:", queue.dequeue()) # 输出: 移除的元素: a print("队列是否为空:", queue.is_empty()) # 输出: 队列是否为空: False print("队列大小:", queue.size()) # 输出: 队列大小: 2
集合 下面是集合的各种操作
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 >>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'} >>> print(basket) # 删除重复的 {'orange', 'banana', 'pear', 'apple'} >>> 'orange' in basket # 检测成员 True >>> 'crabgrass' in basket False >>> # 以下演示了两个集合的操作 ... >>> a = set('abracadabra') >>> b = set('alacazam') >>> a # a 中唯一的字母 {'a', 'r', 'b', 'c', 'd'} >>> a - b # 在 a 中的字母，但不在 b 中 {'r', 'd', 'b'} >>> a | b # 在 a 或 b 中的字母 {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'} >>> a & b # 在 a 和 b 中都有的字母 {'a', 'c'} >>> a ^ b # 在 a 或 b 中的字母，但不同时在 a 和 b 中 {'r', 'd', 'b', 'm', 'z', 'l'}
模块 from a import b 语句 这个声明不会把整个 a 模块导入到当前的命名空间中，它只会将 a 里的 b 函数引入进来。
1 2 import numpy as np # 将 numpy 模块别名设置为 np from math import sqrt as square_root # 将 sqrt 函数别名设置为 square_root
正则表达式 re.match函数 re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match() 就返回 None。
1 2 3 函数语法： re.match(pattern, string, flags=0)
pattern 匹配的正则表达式
string 要匹配的字符串。
flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
老实了，求放过，改天再约
文件 ____name__和__main__的使用 在 Python 中，常见的做法是在模块的末尾添加以下代码块：
实例
1 2 3 if __name__ == "__main__": #这里的代码只有在模块作为主程序运行时才会执行 main()