-
Java面试题大全（2020版）
2019-11-26 11:59:06发现网上很多Java面试题都没有答案，所以花了很长时间搜集整理出来了这套Java面试题大全，希望对大家有帮助哈~ 本套Java面试题大全，全的不能再全，哈哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别？...展开全文发现网上很多Java面试题都没有答案，所以花了很长时间搜集整理出来了这套Java面试题大全，希望对大家有帮助哈~
本套Java面试题大全，全的不能再全，哈哈~
博主已将以下这些面试题整理成了一个Java面试手册，是PDF版的。
关注博主的微信公众号：Java团长，然后回复“面试手册”即可获取~
一、Java 基础
1. JDK 和 JRE 有什么区别？
- JDK：Java Development Kit 的简称，java 开发工具包，提供了 java 的开发环境和运行环境。
- JRE：Java Runtime Environment 的简称，java 运行环境，为 java 的运行提供了所需环境。
具体来说 JDK 其实包含了 JRE，同时还包含了编译 java 源码的编译器 javac，还包含了很多 java 程序调试和分析的工具。简单来说：如果你需要运行 java 程序，只需安装 JRE 就可以了，如果你需要编写 java 程序，需要安装 JDK。
2. == 和 equals 的区别是什么？
== 解读
对于基本类型和引用类型 == 的作用效果是不同的，如下所示：
- 基本类型：比较的是值是否相同；
- 引用类型：比较的是引用是否相同；
代码示例：
String x = "string"; String y = "string"; String z = new String("string"); System.out.println(x==y); // true System.out.println(x==z); // false System.out.println(x.equals(y)); // true System.out.println(x.equals(z)); // true代码解读：因为 x 和 y 指向的是同一个引用，所以 == 也是 true，而 new String()方法则重写开辟了内存空间，所以 == 结果为 false，而 equals 比较的一直是值，所以结果都为 true。
equals 解读
equals 本质上就是 ==，只不过 String 和 Integer 等重写了 equals 方法，把它变成了值比较。看下面的代码就明白了。
首先来看默认情况下 equals 比较一个有相同值的对象，代码如下：
class Cat { public Cat(String name) { this.name = name; } private String name; public String getName() { return name; } public void setName(String name) { this.name = name; } } Cat c1 = new Cat("王磊"); Cat c2 = new Cat("王磊"); System.out.println(c1.equals(c2)); // false输出结果出乎我们的意料，竟然是 false？这是怎么回事，看了 equals 源码就知道了，源码如下：
public boolean equals(Object obj) { return (this == obj); }原来 equals 本质上就是 ==。
那问题来了，两个相同值的 String 对象，为什么返回的是 true？代码如下：
String s1 = new String("老王"); String s2 = new String("老王"); System.out.println(s1.equals(s2)); // true同样的，当我们进入 String 的 equals 方法，找到了答案，代码如下：
public boolean equals(Object anObject) { if (this == anObject) { return true; } if (anObject instanceof String) { String anotherString = (String)anObject; int n = value.length; if (n == anotherString.value.length) { char v1[] = value; char v2[] = anotherString.value; int i = 0; while (n-- != 0) { if (v1[i] != v2[i]) return false; i++; } return true; } } return false; }原来是 String 重写了 Object 的 equals 方法，把引用比较改成了值比较。
总结 ：== 对于基本类型来说是值比较，对于引用类型来说是比较的是引用；而 equals 默认情况下是引用比较，只是很多类重新了 equals 方法，比如 String、Integer 等把它变成了值比较，所以一般情况下 equals 比较的是值是否相等。
3. 两个对象的 hashCode()相同，则 equals()也一定为 true，对吗？
不对，两个对象的 hashCode()相同，equals()不一定 true。
代码示例：
String str1 = "通话"; String str2 = "重地"; System.out.println(String.format("str1：%d | str2：%d", str1.hashCode(),str2.hashCode())); System.out.println(str1.equals(str2));执行的结果：
str1：1179395 | str2：1179395
false
代码解读：很显然“通话”和“重地”的 hashCode() 相同，然而 equals() 则为 false，因为在散列表中，hashCode()相等即两个键值对的哈希值相等，然而哈希值相等，并不一定能得出键值对相等。
4. final 在 java 中有什么作用？
- final 修饰的类叫最终类，该类不能被继承。
- final 修饰的方法不能被重写。
- final 修饰的变量叫常量，常量必须初始化，初始化之后值就不能被修改。
5. java 中的 Math.round(-1.5) 等于多少？
等于 -1，因为在数轴上取值时，中间值（0.5）向右取整，所以正 0.5 是往上取整，负 0.5 是直接舍弃。
6. String 属于基础的数据类型吗？
String 不属于基础类型，基础类型有 8 种：byte、boolean、char、short、int、float、long、double，而 String 属于对象。
7. java 中操作字符串都有哪些类？它们之间有什么区别？
操作字符串的类有：String、StringBuffer、StringBuilder。
String 和 StringBuffer、StringBuilder 的区别在于 String 声明的是不可变的对象，每次操作都会生成新的 String 对象，然后将指针指向新的 String 对象，而 StringBuffer、StringBuilder 可以在原有对象的基础上进行操作，所以在经常改变字符串内容的情况下最好不要使用 String。
StringBuffer 和 StringBuilder 最大的区别在于，StringBuffer 是线程安全的，而 StringBuilder 是非线程安全的，但 StringBuilder 的性能却高于 StringBuffer，所以在单线程环境下推荐使用 StringBuilder，多线程环境下推荐使用 StringBuffer。
8. String str="i"与 String str=new String("i")一样吗？
不一样，因为内存的分配方式不一样。String str="i"的方式，java 虚拟机会将其分配到常量池中；而 String str=new String("i") 则会被分到堆内存中。
9. 如何将字符串反转？
使用 StringBuilder 或者 stringBuffer 的 reverse() 方法。
示例代码：
// StringBuffer reverse StringBuffer stringBuffer = new StringBuffer(); stringBuffer.append("abcdefg"); System.out.println(stringBuffer.reverse()); // gfedcba // StringBuilder reverse StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append("abcdefg"); System.out.println(stringBuilder.reverse()); // gfedcba10. String 类的常用方法都有那些？
- indexOf()：返回指定字符的索引。
- charAt()：返回指定索引处的字符。
- replace()：字符串替换。
- trim()：去除字符串两端空白。
- split()：分割字符串，返回一个分割后的字符串数组。
- getBytes()：返回字符串的 byte 类型数组。
- length()：返回字符串长度。
- toLowerCase()：将字符串转成小写字母。
- toUpperCase()：将字符串转成大写字符。
- substring()：截取字符串。
- equals()：字符串比较。
11. 抽象类必须要有抽象方法吗？
不需要，抽象类不一定非要有抽象方法。
示例代码：
abstract class Cat { public static void sayHi() { System.out.println("hi~"); } }上面代码，抽象类并没有抽象方法但完全可以正常运行。
12. 普通类和抽象类有哪些区别？
- 普通类不能包含抽象方法，抽象类可以包含抽象方法。
- 抽象类不能直接实例化，普通类可以直接实例化。
13. 抽象类能使用 final 修饰吗？
不能，定义抽象类就是让其他类继承的，如果定义为 final 该类就不能被继承，这样彼此就会产生矛盾，所以 final 不能修饰抽象类，如下图所示，编辑器也会提示错误信息：
14. 接口和抽象类有什么区别？
- 实现：抽象类的子类使用 extends 来继承；接口必须使用 implements 来实现接口。
- 构造函数：抽象类可以有构造函数；接口不能有。
- main 方法：抽象类可以有 main 方法，并且我们能运行它；接口不能有 main 方法。
- 实现数量：类可以实现很多个接口；但是只能继承一个抽象类。
- 访问修饰符：接口中的方法默认使用 public 修饰；抽象类中的方法可以是任意访问修饰符。
15. java 中 IO 流分为几种？
按功能来分：输入流（input）、输出流（output）。
按类型来分：字节流和字符流。
字节流和字符流的区别是：字节流按 8 位传输以字节为单位输入输出数据，字符流按 16 位传输以字符为单位输入输出数据。
16. BIO、NIO、AIO 有什么区别？
- BIO：Block IO 同步阻塞式 IO，就是我们平常使用的传统 IO，它的特点是模式简单使用方便，并发处理能力低。
- NIO：New IO 同步非阻塞 IO，是传统 IO 的升级，客户端和服务器端通过 Channel（通道）通讯，实现了多路复用。
- AIO：Asynchronous IO 是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO ，异步 IO 的操作基于事件和回调机制。
17. Files的常用方法都有哪些？
- Files.exists()：检测文件路径是否存在。
- Files.createFile()：创建文件。
- Files.createDirectory()：创建文件夹。
- Files.delete()：删除一个文件或目录。
- Files.copy()：复制文件。
- Files.move()：移动文件。
- Files.size()：查看文件个数。
- Files.read()：读取文件。
- Files.write()：写入文件。
二、容器
18. java 容器都有哪些？
常用容器的图录：
19. Collection 和 Collections 有什么区别？
- java.util.Collection 是一个集合接口（集合类的一个顶级接口）。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式，其直接继承接口有List与Set。
- Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。
20. List、Set、Map 之间的区别是什么？
21. HashMap 和 Hashtable 有什么区别？
- hashMap去掉了HashTable 的contains方法，但是加上了containsValue（）和containsKey（）方法。
- hashTable同步的，而HashMap是非同步的，效率上逼hashTable要高。
- hashMap允许空键值，而hashTable不允许。
22. 如何决定使用 HashMap 还是 TreeMap？
对于在Map中插入、删除和定位元素这类操作，HashMap是最好的选择。然而，假如你需要对一个有序的key集合进行遍历，TreeMap是更好的选择。基于你的collection的大小，也许向HashMap中添加元素会更快，将map换为TreeMap进行有序key的遍历。
23. 说一下 HashMap 的实现原理？
HashMap概述： HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
HashMap的数据结构： 在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。
当我们往Hashmap中put元素时,首先根据key的hashcode重新计算hash值,根绝hash值得到这个元素在数组中的位置(下标),如果该数组在该位置上已经存放了其他元素,那么在这个位置上的元素将以链表的形式存放,新加入的放在链头,最先加入的放入链尾.如果数组中该位置没有元素,就直接将该元素放到数组的该位置上。
需要注意Jdk 1.8中对HashMap的实现做了优化,当链表中的节点数据超过八个之后,该链表会转为红黑树来提高查询效率,从原来的O(n)到O(logn)
24. 说一下 HashSet 的实现原理？
- HashSet底层由HashMap实现
- HashSet的值存放于HashMap的key上
- HashMap的value统一为PRESENT
25. ArrayList 和 LinkedList 的区别是什么？
最明显的区别是 ArrrayList底层的数据结构是数组，支持随机访问，而 LinkedList 的底层数据结构是双向循环链表，不支持随机访问。使用下标访问一个元素，ArrayList 的时间复杂度是 O(1)，而 LinkedList 是 O(n)。
26. 如何实现数组和 List 之间的转换？
- List转换成为数组：调用ArrayList的toArray方法。
- 数组转换成为List：调用Arrays的asList方法。
27. ArrayList 和 Vector 的区别是什么？
- Vector是同步的，而ArrayList不是。然而，如果你寻求在迭代的时候对列表进行改变，你应该使用CopyOnWriteArrayList。
- ArrayList比Vector快，它因为有同步，不会过载。
- ArrayList更加通用，因为我们可以使用Collections工具类轻易地获取同步列表和只读列表。
28. Array 和 ArrayList 有何区别？
- Array可以容纳基本类型和对象，而ArrayList只能容纳对象。
- Array是指定大小的，而ArrayList大小是固定的。
- Array没有提供ArrayList那么多功能，比如addAll、removeAll和iterator等。
29. 在 Queue 中 poll()和 remove()有什么区别？
poll() 和 remove() 都是从队列中取出一个元素，但是 poll() 在获取元素失败的时候会返回空，但是 remove() 失败的时候会抛出异常。
30. 哪些集合类是线程安全的？
- vector：就比arraylist多了个同步化机制（线程安全），因为效率较低，现在已经不太建议使用。在web应用中，特别是前台页面，往往效率（页面响应速度）是优先考虑的。
- statck：堆栈类，先进后出。
- hashtable：就比hashmap多了个线程安全。
- enumeration：枚举，相当于迭代器。
31. 迭代器 Iterator 是什么？
迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。
32. Iterator 怎么使用？有什么特点？
Java中的Iterator功能比较简单，并且只能单向移动：
(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。
(2) 使用next()获得序列中的下一个元素。
(3) 使用hasNext()检查序列中是否还有元素。
(4) 使用remove()将迭代器新返回的元素删除。
Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。
33. Iterator 和 ListIterator 有什么区别？
- Iterator可用来遍历Set和List集合，但是ListIterator只能用来遍历List。
- Iterator对集合只能是前向遍历，ListIterator既可以前向也可以后向。
- ListIterator实现了Iterator接口，并包含其他的功能，比如：增加元素，替换元素，获取前一个和后一个元素的索引，等等。
三、多线程
35. 并行和并发有什么区别？
- 并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。
- 并行是在不同实体上的多个事件，并发是在同一实体上的多个事件。
- 在一台处理器上“同时”处理多个任务，在多台处理器上同时处理多个任务。如hadoop分布式集群。
所以并发编程的目标是充分的利用处理器的每一个核，以达到最高的处理性能。
36. 线程和进程的区别？
简而言之，进程是程序运行和资源分配的基本单位，一个程序至少有一个进程，一个进程至少有一个线程。进程在执行过程中拥有独立的内存单元，而多个线程共享内存资源，减少切换次数，从而效率更高。线程是进程的一个实体，是cpu调度和分派的基本单位，是比程序更小的能独立运行的基本单位。同一进程中的多个线程之间可以并发执行。
37. 守护线程是什么？
守护线程（即daemon thread），是个服务线程，准确地来说就是服务其他的线程。
38. 创建线程有哪几种方式？
①. 继承Thread类创建线程类
- 定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。
- 创建Thread子类的实例，即创建了线程对象。
- 调用线程对象的start()方法来启动该线程。
②. 通过Runnable接口创建线程类
- 定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
- 创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
- 调用线程对象的start()方法来启动该线程。
③. 通过Callable和Future创建线程
- 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。
- 创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。
- 使用FutureTask对象作为Thread对象的target创建并启动新线程。
- 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。
39. 说一下 runnable 和 callable 有什么区别？
有点深的问题了，也看出一个Java程序员学习知识的广度。
- Runnable接口中的run()方法的返回值是void，它做的事情只是纯粹地去执行run()方法中的代码而已；
- Callable接口中的call()方法是有返回值的，是一个泛型，和Future、FutureTask配合可以用来获取异步执行的结果。
40. 线程有哪些状态？
线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。
- 创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。
- 就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。
- 运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。
- 阻塞状态。线程正在运行的时候，被暂停，通常是为了等待某个时间的发生(比如说某项资源就绪)之后再继续运行。sleep,suspend，wait等方法都可以导致线程阻塞。
- 死亡状态。如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪
41. sleep() 和 wait() 有什么区别？
sleep()：方法是线程类（Thread）的静态方法，让调用线程进入睡眠状态，让出执行机会给其他线程，等到休眠时间结束后，线程进入就绪状态和其他线程一起竞争cpu的执行时间。因为sleep() 是static静态的方法，他不能改变对象的机锁，当一个synchronized块中调用了sleep() 方法，线程虽然进入休眠，但是对象的机锁没有被释放，其他线程依然无法访问这个对象。
wait()：wait()是Object类的方法，当一个线程执行到wait方法时，它就进入到一个和该对象相关的等待池，同时释放对象的机锁，使得其他线程能够访问，可以通过notify，notifyAll方法来唤醒等待的线程。
42. notify()和 notifyAll()有什么区别？
- 如果线程调用了对象的 wait()方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。
- 当有线程调用了对象的 notifyAll()方法（唤醒所有 wait 线程）或 notify()方法（只随机唤醒一个 wait 线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。也就是说，调用了notify后只要一个线程会由等待池进入锁池，而notifyAll会将该对象等待池内的所有线程移动到锁池中，等待锁竞争。
- 优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中，唯有线程再次调用 wait()方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了 synchronized 代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。
43. 线程的 run()和 start()有什么区别？
每个线程都是通过某个特定Thread对象所对应的方法run()来完成其操作的，方法run()称为线程体。通过调用Thread类的start()方法来启动一个线程。
start()方法来启动一个线程，真正实现了多线程运行。这时无需等待run方法体代码执行完毕，可以直接继续执行下面的代码； 这时此线程是处于就绪状态， 并没有运行。 然后通过此Thread类调用方法run()来完成其运行状态， 这里方法run()称为线程体，它包含了要执行的这个线程的内容， Run方法运行结束， 此线程终止。然后CPU再调度其它线程。
run()方法是在本线程里的，只是线程里的一个函数,而不是多线程的。 如果直接调用run(),其实就相当于是调用了一个普通函数而已，直接待用run()方法必须等待run()方法执行完毕才能执行下面的代码，所以执行路径还是只有一条，根本就没有线程的特征，所以在多线程执行时要使用start()方法而不是run()方法。
44. 创建线程池有哪几种方式？
①. newFixedThreadPool(int nThreads)
创建一个固定长度的线程池，每当提交一个任务就创建一个线程，直到达到线程池的最大数量，这时线程规模将不再变化，当线程发生未预期的错误而结束时，线程池会补充一个新的线程。
②. newCachedThreadPool()
创建一个可缓存的线程池，如果线程池的规模超过了处理需求，将自动回收空闲线程，而当需求增加时，则可以自动添加新线程，线程池的规模不存在任何限制。
③. newSingleThreadExecutor()
这是一个单线程的Executor，它创建单个工作线程来执行任务，如果这个线程异常结束，会创建一个新的来替代它；它的特点是能确保依照任务在队列中的顺序来串行执行。
④. newScheduledThreadPool(int corePoolSize)
创建了一个固定长度的线程池，而且以延迟或定时的方式来执行任务，类似于Timer。
45. 线程池都有哪些状态？
线程池有5种状态：Running、ShutDown、Stop、Tidying、Terminated。
线程池各个状态切换框架图：
46. 线程池中 submit()和 execute()方法有什么区别？
- 接收的参数不一样
- submit有返回值，而execute没有
- submit方便Exception处理
47. 在 java 程序中怎么保证多线程的运行安全？
线程安全在三个方面体现：
- 原子性：提供互斥访问，同一时刻只能有一个线程对数据进行操作，（atomic,synchronized）；
- 可见性：一个线程对主内存的修改可以及时地被其他线程看到，（synchronized,volatile）；
- 有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序，该观察结果一般杂乱无序，（happens-before原则）。
48. 多线程锁的升级原理是什么？
在Java中，锁共有4种状态，级别从低到高依次为：无状态锁，偏向锁，轻量级锁和重量级锁状态，这几个状态会随着竞争情况逐渐升级。锁可以升级但不能降级。
锁升级的图示过程：
49. 什么是死锁？
死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。是操作系统层面的一个错误，是进程死锁的简称，最早在 1965 年由 Dijkstra 在研究银行家算法时提出的，它是计算机操作系统乃至整个并发程序设计领域最难处理的问题之一。
50. 怎么防止死锁？
死锁的四个必要条件：
- 互斥条件：进程对所分配到的资源不允许其他进程进行访问，若其他进程访问该资源，只能等待，直至占有该资源的进程使用完成后释放该资源
- 请求和保持条件：进程获得一定的资源之后，又对其他资源发出请求，但是该资源可能被其他进程占有，此事请求阻塞，但又对自己获得的资源保持不放
- 不可剥夺条件：是指进程已获得的资源，在未完成使用之前，不可被剥夺，只能在使用完后自己释放
- 环路等待条件：是指进程发生死锁后，若干进程之间形成一种头尾相接的循环等待资源关系
这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之 一不满足，就不会发生死锁。
理解了死锁的原因，尤其是产生死锁的四个必要条件，就可以最大可能地避免、预防和 解除死锁。
所以，在系统设计、进程调度等方面注意如何不让这四个必要条件成立，如何确 定资源的合理分配算法，避免进程永久占据系统资源。
此外，也要防止进程在处于等待状态的情况下占用资源。因此，对资源的分配要给予合理的规划。
51. ThreadLocal 是什么？有哪些使用场景？
线程局部变量是局限于线程内部的变量，属于线程自身所有，不在多个线程间共享。Java提供ThreadLocal类来支持线程局部变量，是一种实现线程安全的方式。但是在管理环境下（如 web 服务器）使用线程局部变量的时候要特别小心，在这种情况下，工作线程的生命周期比任何应用变量的生命周期都要长。任何线程局部变量一旦在工作完成后没有释放，Java 应用就存在内存泄露的风险。
52.说一下 synchronized 底层实现原理？
synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性。
Java中每一个对象都可以作为锁，这是synchronized实现同步的基础：
- 普通同步方法，锁是当前实例对象
- 静态同步方法，锁是当前类的class对象
- 同步方法块，锁是括号里面的对象
53. synchronized 和 volatile 的区别是什么？
- volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
- volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的。
- volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性。
- volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
- volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化。
54. synchronized 和 Lock 有什么区别？
- 首先synchronized是java内置关键字，在jvm层面，Lock是个java类；
- synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁；
- synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ；b 线程执行过程中发生异常会释放锁)，Lock需在finally中手工释放锁（unlock()方法释放锁），否则容易造成线程死锁；
- 用synchronized关键字的两个线程1和线程2，如果当前线程1获得锁，线程2线程等待。如果线程1阻塞，线程2则会一直等待下去，而Lock锁就不一定会等待下去，如果尝试获取不到锁，线程可以不用一直等待就结束了；
- synchronized的锁可重入、不可中断、非公平，而Lock锁可重入、可判断、可公平（两者皆可）；
-
Lock锁适合大量同步的代码的同步问题，synchronized锁适合代码少量的同步问题。
55. synchronized 和 ReentrantLock 区别是什么？
synchronized是和if、else、for、while一样的关键字，ReentrantLock是类，这是二者的本质区别。既然ReentrantLock是类，那么它就提供了比synchronized更多更灵活的特性，可以被继承、可以有方法、可以有各种各样的类变量，ReentrantLock比synchronized的扩展性体现在几点上：
- ReentrantLock可以对获取锁的等待时间进行设置，这样就避免了死锁
- ReentrantLock可以获取各种锁的信息
- ReentrantLock可以灵活地实现多路通知
另外，二者的锁机制其实也是不一样的:ReentrantLock底层调用的是Unsafe的park方法加锁，synchronized操作的应该是对象头中mark word。
56. 说一下 atomic 的原理？
Atomic包中的类基本的特性就是在多线程环境下，当有多个线程同时对单个（包括基本类型及引用类型）变量进行操作时，具有排他性，即当多个线程同时对该变量的值进行更新时，仅有一个线程能成功，而未成功的线程可以向自旋锁一样，继续尝试，一直等到执行成功。
Atomic系列的类中的核心方法都会调用unsafe类中的几个本地方法。我们需要先知道一个东西就是Unsafe类，全名为：sun.misc.Unsafe，这个类包含了大量的对C代码的操作，包括很多直接内存分配以及原子操作的调用，而它之所以标记为非安全的，是告诉你这个里面大量的方法调用都会存在安全隐患，需要小心使用，否则会导致严重的后果，例如在通过unsafe分配内存的时候，如果自己指定某些区域可能会导致一些类似C++一样的指针越界到其他进程的问题。
四、反射
57. 什么是反射？
反射主要是指程序可以访问、检测和修改它本身状态或行为的一种能力
Java反射：
在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法
Java反射机制主要提供了以下功能：
- 在运行时判断任意一个对象所属的类。
- 在运行时构造任意一个类的对象。
- 在运行时判断任意一个类所具有的成员变量和方法。
- 在运行时调用任意一个对象的方法。
58. 什么是 java 序列化？什么情况下需要序列化？
简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存object states，但是Java给你提供一种应该比你自己好的保存对象状态的机制，那就是序列化。
什么情况下需要序列化：a）当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
b）当你想用套接字在网络上传送对象的时候；
c）当你想通过RMI传输对象的时候；59. 动态代理是什么？有哪些应用？
动态代理：
当想要给实现了某个接口的类中的方法，加一些额外的处理。比如说加日志，加事务等。可以给这个类创建一个代理，故名思议就是创建一个新的类，这个类不仅包含原来类方法的功能，而且还在原来的基础上添加了额外处理的新类。这个代理类并不是定义好的，是动态生成的。具有解耦意义，灵活，扩展性强。
动态代理的应用：
- Spring的AOP
- 加事务
- 加权限
- 加日志
60. 怎么实现动态代理？
首先必须定义一个接口，还要有一个InvocationHandler(将实现接口的类的对象传递给它)处理类。再有一个工具类Proxy(习惯性将其称为代理类，因为调用他的newInstance()可以产生代理对象,其实他只是一个产生代理对象的工具类）。利用到InvocationHandler，拼接代理类源码，将其编译生成代理类的二进制码，利用加载器加载，并将其实例化产生代理对象，最后返回。
五、对象拷贝
61. 为什么要使用克隆？
想对一个对象进行处理，又想保留原有的数据进行接下来的操作，就需要克隆了，Java语言中克隆针对的是类的实例。
62. 如何实现对象克隆？
有两种方式：
1). 实现Cloneable接口并重写Object类中的clone()方法；
2). 实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆，代码如下：
import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; public class MyUtil { private MyUtil() { throw new AssertionError(); } @SuppressWarnings("unchecked") public static <T extends Serializable> T clone(T obj) throws Exception { ByteArrayOutputStream bout = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(bout); oos.writeObject(obj); ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray()); ObjectInputStream ois = new ObjectInputStream(bin); return (T) ois.readObject(); // 说明：调用ByteArrayInputStream或ByteArrayOutputStream对象的close方法没有任何意义 // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源，这一点不同于对外部资源（如文件流）的释放 } }下面是测试代码：
import java.io.Serializable; /** * 人类 * @author nnngu * */ class Person implements Serializable { private static final long serialVersionUID = -9102017020286042305L; private String name; // 姓名 private int age; // 年龄 private Car car; // 座驾 public Person(String name, int age, Car car) { this.name = name; this.age = age; this.car = car; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Car getCar() { return car; } public void setCar(Car car) { this.car = car; } @Override public String toString() { return "Person [name=" + name + ", age=" + age + ", car=" + car + "]"; } }/** * 小汽车类 * @author nnngu * */ class Car implements Serializable { private static final long serialVersionUID = -5713945027627603702L; private String brand; // 品牌 private int maxSpeed; // 最高时速 public Car(String brand, int maxSpeed) { this.brand = brand; this.maxSpeed = maxSpeed; } public String getBrand() { return brand; } public void setBrand(String brand) { this.brand = brand; } public int getMaxSpeed() { return maxSpeed; } public void setMaxSpeed(int maxSpeed) { this.maxSpeed = maxSpeed; } @Override public String toString() { return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]"; } }class CloneTest { public static void main(String[] args) { try { Person p1 = new Person("郭靖", 33, new Car("Benz", 300)); Person p2 = MyUtil.clone(p1); // 深度克隆 p2.getCar().setBrand("BYD"); // 修改克隆的Person对象p2关联的汽车对象的品牌属性 // 原来的Person对象p1关联的汽车不会受到任何影响 // 因为在克隆Person对象时其关联的汽车对象也被克隆了 System.out.println(p1); } catch (Exception e) { e.printStackTrace(); } } }注意：基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，可以检查出要克隆的对象是否支持序列化，这项检查是编译器完成的，不是在运行时抛出异常，这种是方案明显优于使用Object类的clone方法克隆对象。让问题在编译的时候暴露出来总是好过把问题留到运行时。
63. 深拷贝和浅拷贝区别是什么？
- 浅拷贝只是复制了对象的引用地址，两个对象指向同一个内存地址，所以修改其中任意的值，另一个值都会随之变化，这就是浅拷贝（例：assign()）
- 深拷贝是将对象及值复制过来，两个对象修改其中任意的值另一个值不会改变，这就是深拷贝（例：JSON.parse()和JSON.stringify()，但是此方法无法复制函数类型）
六、Java Web
64. jsp 和 servlet 有什么区别？
- jsp经编译后就变成了Servlet.（JSP的本质就是Servlet，JVM只能识别java的类，不能识别JSP的代码，Web容器将JSP的代码编译成JVM能够识别的java类）
- jsp更擅长表现于页面显示，servlet更擅长于逻辑控制。
- Servlet中没有内置对象，Jsp中的内置对象都是必须通过HttpServletRequest对象，HttpServletResponse对象以及HttpServlet对象得到。
- Jsp是Servlet的一种简化，使用Jsp只需要完成程序员需要输出到客户端的内容，Jsp中的Java脚本如何镶嵌到一个类中，由Jsp容器完成。而Servlet则是个完整的Java类，这个类的Service方法用于生成对客户端的响应。
65. jsp 有哪些内置对象？作用分别是什么？
JSP有9个内置对象：
- request：封装客户端的请求，其中包含来自GET或POST请求的参数；
- response：封装服务器对客户端的响应；
- pageContext：通过该对象可以获取其他对象；
- session：封装用户会话的对象；
- application：封装服务器运行环境的对象；
- out：输出服务器响应的输出流对象；
- config：Web应用的配置对象；
- page：JSP页面本身（相当于Java程序中的this）；
- exception：封装页面抛出异常的对象。
66. 说一下 jsp 的 4 种作用域？
JSP中的四种作用域包括page、request、session和application，具体来说：
- page代表与一个页面相关的对象和属性。
- request代表与Web客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多个Web组件；需要在页面显示的临时数据可以置于此作用域。
- session代表与某个用户与服务器建立的一次会话相关的对象和属性。跟某个用户相关的数据应该放在用户自己的session中。
- application代表与整个Web应用程序相关的对象和属性，它实质上是跨越整个Web应用程序，包括多个页面、请求和会话的一个全局作用域。
67. session 和 cookie 有什么区别？
- 由于HTTP协议是无状态的协议，所以服务端需要记录用户的状态时，就需要用某种机制来识具体的用户，这个机制就是Session.典型的场景比如购物车，当你点击下单按钮时，由于HTTP协议无状态，所以并不知道是哪个用户操作的，所以服务端要为特定的用户创建了特定的Session，用用于标识这个用户，并且跟踪用户，这样才知道购物车里面有几本书。这个Session是保存在服务端的，有一个唯一标识。在服务端保存Session的方法很多，内存、数据库、文件都有。集群的时候也要考虑Session的转移，在大型的网站，一般会有专门的Session服务器集群，用来保存用户会话，这个时候 Session 信息都是放在内存的，使用一些缓存服务比如Memcached之类的来放 Session。
- 思考一下服务端如何识别特定的客户？这个时候Cookie就登场了。每次HTTP请求的时候，客户端都会发送相应的Cookie信息到服务端。实际上大多数的应用都是用 Cookie 来实现Session跟踪的，第一次创建Session的时候，服务端会在HTTP协议中告诉客户端，需要在 Cookie 里面记录一个Session ID，以后每次请求把这个会话ID发送到服务器，我就知道你是谁了。有人问，如果客户端的浏览器禁用了 Cookie 怎么办？一般这种情况下，会使用一种叫做URL重写的技术来进行会话跟踪，即每次HTTP交互，URL后面都会被附加上一个诸如 sid=xxxxx 这样的参数，服务端据此来识别用户。
- Cookie其实还可以用在一些方便用户的场景下，设想你某次登陆过一个网站，下次登录的时候不想再次输入账号了，怎么办？这个信息可以写到Cookie里面，访问网站的时候，网站页面的脚本可以读取这个信息，就自动帮你把用户名给填了，能够方便一下用户。这也是Cookie名称的由来，给用户的一点甜头。所以，总结一下：Session是在服务端保存的一个数据结构，用来跟踪用户的状态，这个数据可以保存在集群、数据库、文件中；Cookie是客户端保存用户信息的一种机制，用来记录用户的一些信息，也是实现Session的一种方式。
68. 说一下 session 的工作原理？
其实session是一个存在服务器上的类似于一个散列表格的文件。里面存有我们需要的信息，在我们需要用的时候可以从里面取出来。类似于一个大号的map吧，里面的键存储的是用户的sessionid，用户向服务器发送请求的时候会带上这个sessionid。这时就可以从中取出对应的值了。
69. 如果客户端禁止 cookie 能实现 session 还能用吗？
Cookie与 Session，一般认为是两个独立的东西，Session采用的是在服务器端保持状态的方案，而Cookie采用的是在客户端保持状态的方案。但为什么禁用Cookie就不能得到Session呢？因为Session是用Session ID来确定当前对话所对应的服务器Session，而Session ID是通过Cookie来传递的，禁用Cookie相当于失去了Session ID，也就得不到Session了。
假定用户关闭Cookie的情况下使用Session，其实现途径有以下几种：
- 设置php.ini配置文件中的“session.use_trans_sid = 1”，或者编译时打开打开了“--enable-trans-sid”选项，让PHP自动跨页传递Session ID。
- 手动通过URL传值、隐藏表单传递Session ID。
- 用文件、数据库等形式保存Session ID，在跨页过程中手动调用。
70. spring mvc 和 struts 的区别是什么？
- 拦截机制的不同
Struts2是类级别的拦截，每次请求就会创建一个Action，和Spring整合时Struts2的ActionBean注入作用域是原型模式prototype，然后通过setter，getter吧request数据注入到属性。Struts2中，一个Action对应一个request，response上下文，在接收参数时，可以通过属性接收，这说明属性参数是让多个方法共享的。Struts2中Action的一个方法可以对应一个url，而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了，只能设计为多例。
SpringMVC是方法级别的拦截，一个方法对应一个Request上下文，所以方法直接基本上是独立的，独享request，response数据。而每个方法同时又何一个url对应，参数的传递是直接注入到方法中的，是方法所独有的。处理结果通过ModeMap返回给框架。在Spring整合时，SpringMVC的Controller Bean默认单例模式Singleton，所以默认对所有的请求，只会创建一个Controller，有应为没有共享的属性，所以是线程安全的，如果要改变默认的作用域，需要添加@Scope注解修改。
Struts2有自己的拦截Interceptor机制，SpringMVC这是用的是独立的Aop方式，这样导致Struts2的配置文件量还是比SpringMVC大。
- 底层框架的不同
Struts2采用Filter（StrutsPrepareAndExecuteFilter）实现，SpringMVC（DispatcherServlet）则采用Servlet实现。Filter在容器启动之后即初始化；服务停止以后坠毁，晚于Servlet。Servlet在是在调用时初始化，先于Filter调用，服务停止后销毁。
- 性能方面
Struts2是类级别的拦截，每次请求对应实例一个新的Action，需要加载所有的属性值注入，SpringMVC实现了零配置，由于SpringMVC基于方法的拦截，有加载一次单例模式bean注入。所以，SpringMVC开发效率和性能高于Struts2。
- 配置方面
spring MVC和Spring是无缝的。从这个项目的管理和安全上也比Struts2高。
71. 如何避免 sql 注入？
- PreparedStatement（简单又有效的方法）
- 使用正则表达式过滤传入的参数
- 字符串过滤
- JSP中调用该函数检查是否包函非法字符
- JSP页面判断代码
72. 什么是 XSS 攻击，如何避免？
XSS攻击又称CSS,全称Cross Site Script （跨站脚本攻击），其原理是攻击者向有XSS漏洞的网站中输入恶意的 HTML 代码，当用户浏览该网站时，这段 HTML 代码会自动执行，从而达到攻击的目的。XSS 攻击类似于 SQL 注入攻击，SQL注入攻击中以SQL语句作为用户输入，从而达到查询/修改/删除数据的目的，而在xss攻击中，通过插入恶意脚本，实现对用户游览器的控制，获取用户的一些信息。 XSS是 Web 程序中常见的漏洞，XSS 属于被动式且用于客户端的攻击方式。
XSS防范的总体思路是：对输入(和URL参数)进行过滤，对输出进行编码。
73. 什么是 CSRF 攻击，如何避免？
CSRF（Cross-site request forgery）也被称为 one-click attack或者 session riding，中文全称是叫跨站请求伪造。一般来说，攻击者通过伪造用户的浏览器的请求，向访问一个用户自己曾经认证访问过的网站发送出去，使目标网站接收并误以为是用户的真实操作而去执行命令。常用于盗取账号、转账、发送虚假消息等。攻击者利用网站对请求的验证漏洞而实现这样的攻击行为，网站能够确认请求来源于用户的浏览器，却不能验证请求是否源于用户的真实意愿下的操作行为。
如何避免：
1. 验证 HTTP Referer 字段
HTTP头中的Referer字段记录了该 HTTP 请求的来源地址。在通常情况下，访问一个安全受限页面的请求来自于同一个网站，而如果黑客要对其实施 CSRF
攻击，他一般只能在他自己的网站构造请求。因此，可以通过验证Referer值来防御CSRF 攻击。2. 使用验证码
关键操作页面加上验证码，后台收到请求后通过判断验证码可以防御CSRF。但这种方法对用户不太友好。
3. 在请求地址中添加token并验证
CSRF 攻击之所以能够成功，是因为黑客可以完全伪造用户的请求，该请求中所有的用户验证信息都是存在于cookie中，因此黑客可以在不知道这些验证信息的情况下直接利用用户自己的cookie 来通过安全验证。要抵御 CSRF，关键在于在请求中放入黑客所不能伪造的信息，并且该信息不存在于 cookie 之中。可以在 HTTP 请求中以参数的形式加入一个随机产生的 token，并在服务器端建立一个拦截器来验证这个 token，如果请求中没有token或者 token 内容不正确，则认为可能是 CSRF 攻击而拒绝该请求。这种方法要比检查 Referer 要安全一些，token 可以在用户登陆后产生并放于session之中，然后在每次请求时把token 从 session 中拿出，与请求中的 token 进行比对，但这种方法的难点在于如何把 token 以参数的形式加入请求。
对于 GET 请求，token 将附在请求地址之后，这样 URL 就变成 http://url?csrftoken=tokenvalue。
而对于 POST 请求来说，要在 form 的最后加上 <input type="hidden" name="csrftoken" value="tokenvalue"/>，这样就把token以参数的形式加入请求了。4. 在HTTP 头中自定义属性并验证
这种方法也是使用 token 并进行验证，和上一种方法不同的是，这里并不是把 token 以参数的形式置于 HTTP 请求之中，而是把它放到 HTTP 头中自定义的属性里。通过 XMLHttpRequest 这个类，可以一次性给所有该类请求加上 csrftoken 这个 HTTP 头属性，并把 token 值放入其中。这样解决了上种方法在请求中加入 token 的不便，同时，通过 XMLHttpRequest 请求的地址不会被记录到浏览器的地址栏，也不用担心 token 会透过 Referer 泄露到其他网站中去。
七、异常
74. throw 和 throws 的区别？
throws是用来声明一个方法可能抛出的所有异常信息，throws是将异常声明但是不处理，而是将异常往上传，谁调用我就交给谁处理。而throw则是指抛出的一个具体的异常类型。
75. final、finally、finalize 有什么区别？
- final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值。
- finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法finally代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码。
- finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，该方法一般由垃圾回收器来调用，当我们调用System的gc()方法的时候，由垃圾回收器调用finalize(),回收垃圾。
76. try-catch-finally 中哪个部分可以省略？
答：catch 可以省略
原因：
更为严格的说法其实是：try只适合处理运行时异常，try+catch适合处理运行时异常+普通异常。也就是说，如果你只用try去处理普通异常却不加以catch处理，编译是通不过的，因为编译器硬性规定，普通异常如果选择捕获，则必须用catch显示声明以便进一步处理。而运行时异常在编译时没有如此规定，所以catch可以省略，你加上catch编译器也觉得无可厚非。
理论上，编译器看任何代码都不顺眼，都觉得可能有潜在的问题，所以你即使对所有代码加上try，代码在运行期时也只不过是在正常运行的基础上加一层皮。但是你一旦对一段代码加上try，就等于显示地承诺编译器，对这段代码可能抛出的异常进行捕获而非向上抛出处理。如果是普通异常，编译器要求必须用catch捕获以便进一步处理；如果运行时异常，捕获然后丢弃并且+finally扫尾处理，或者加上catch捕获以便进一步处理。
至于加上finally，则是在不管有没捕获异常，都要进行的“扫尾”处理。
77. try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？
答：会执行，在 return 前执行。
代码示例1：
/* * java面试题--如果catch里面有return语句，finally里面的代码还会执行吗？ */ public class FinallyDemo2 { public static void main(String[] args) { System.out.println(getInt()); } public static int getInt() { int a = 10; try { System.out.println(a / 0); a = 20; } catch (ArithmeticException e) { a = 30; return a; /* * return a 在程序执行到这一步的时候，这里不是return a 而是 return 30；这个返回路径就形成了 * 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40 * 再次回到以前的路径,继续走return 30，形成返回路径之后，这里的a就不是a变量了，而是常量30 */ } finally { a = 40; } // return a; } }执行结果：30
代码示例2：
package com.java_02; /* * java面试题--如果catch里面有return语句，finally里面的代码还会执行吗？ */ public class FinallyDemo2 { public static void main(String[] args) { System.out.println(getInt()); } public static int getInt() { int a = 10; try { System.out.println(a / 0); a = 20; } catch (ArithmeticException e) { a = 30; return a; /* * return a 在程序执行到这一步的时候，这里不是return a 而是 return 30；这个返回路径就形成了 * 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40 * 再次回到以前的路径,继续走return 30，形成返回路径之后，这里的a就不是a变量了，而是常量30 */ } finally { a = 40; return a; //如果这样，就又重新形成了一条返回路径，由于只能通过1个return返回，所以这里直接返回40 } // return a; } }执行结果：40
78. 常见的异常类有哪些？
- NullPointerException：当应用程序试图访问空对象时，则抛出该异常。
- SQLException：提供关于数据库访问错误或其他错误信息的异常。
- IndexOutOfBoundsException：指示某排序索引（例如对数组、字符串或向量的排序）超出范围时抛出。
- NumberFormatException：当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。
- FileNotFoundException：当试图打开指定路径名表示的文件失败时，抛出此异常。
- IOException：当发生某种I/O异常时，抛出此异常。此类是失败或中断的I/O操作生成的异常的通用类。
- ClassCastException：当试图将对象强制转换为不是实例的子类时，抛出该异常。
- ArrayStoreException：试图将错误类型的对象存储到一个对象数组时抛出的异常。
- IllegalArgumentException：抛出的异常表明向方法传递了一个不合法或不正确的参数。
- ArithmeticException：当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，抛出此类的一个实例。
- NegativeArraySizeException：如果应用程序试图创建大小为负的数组，则抛出该异常。
- NoSuchMethodException：无法找到某一特定方法时，抛出该异常。
- SecurityException：由安全管理器抛出的异常，指示存在安全侵犯。
- UnsupportedOperationException：当不支持请求的操作时，抛出该异常。
- RuntimeExceptionRuntimeException：是那些可能在Java虚拟机正常运行期间抛出的异常的超类。
八、网络
79. http 响应码 301 和 302 代表的是什么？有什么区别？
答：301，302 都是HTTP状态的编码，都代表着某个URL发生了转移。
区别：
- 301 redirect: 301 代表永久性转移(Permanently Moved)。
- 302 redirect: 302 代表暂时性转移(Temporarily Moved )。
80. forward 和 redirect 的区别？
Forward和Redirect代表了两种请求转发方式：直接转发和间接转发。
直接转发方式（Forward），客户端和浏览器只发出一次请求，Servlet、HTML、JSP或其它信息资源，由第二个信息资源响应该请求，在请求对象request中，保存的对象对于每个信息资源是共享的。
间接转发方式（Redirect）实际是两次HTTP请求，服务器端在响应第一次请求的时候，让浏览器再向另外一个URL发出请求，从而达到转发的目的。
举个通俗的例子：
直接转发就相当于：“A找B借钱，B说没有，B去找C借，借到借不到都会把消息传递给A”；
间接转发就相当于："A找B借钱，B说没有，让A去找C借"。
81. 简述 tcp 和 udp的区别？
- TCP面向连接（如打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接。
- TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP尽最大努力交付，即不保证可靠交付。
- Tcp通过校验和，重传控制，序号标识，滑动窗口、确认应答实现可靠传输。如丢包时的重发控制，还可以对次序乱掉的分包进行顺序控制。
- UDP具有较好的实时性，工作效率比TCP高，适用于对高速传输和实时性有较高的通信或广播通信。
- 每一条TCP连接只能是点到点的;UDP支持一对一，一对多，多对一和多对多的交互通信。
- TCP对系统资源要求较多，UDP对系统资源要求较少。
82. tcp 为什么要三次握手，两次不行吗？为什么？
为了实现可靠数据传输， TCP 协议的通信双方， 都必须维护一个序列号， 以标识发送出去的数据包中， 哪些是已经被对方收到的。 三次握手的过程即是通信双方相互告知序列号起始值， 并确认对方已经收到了序列号起始值的必经步骤。
如果只是两次握手， 至多只有连接发起方的起始序列号能被确认， 另一方选择的序列号则得不到确认。
83. 说一下 tcp 粘包是怎么产生的？
①. 发送方产生粘包
采用TCP协议传输数据的客户端与服务器经常是保持一个长连接的状态（一次连接发一次数据不存在粘包），双方在连接不断开的情况下，可以一直传输数据；但当发送的数据包过于的小时，那么TCP协议默认的会启用Nagle算法，将这些较小的数据包进行合并发送（缓冲区数据发送是一个堆压的过程）；这个合并过程就是在发送缓冲区中进行的，也就是说数据发送出来它已经是粘包的状态了。
②. 接收方产生粘包
接收方采用TCP协议接收数据时的过程是这样的：数据到底接收方，从网络模型的下方传递至传输层，传输层的TCP协议处理是将其放置接收缓冲区，然后由应用层来主动获取（C语言用recv、read等函数）；这时会出现一个问题，就是我们在程序中调用的读取数据函数不能及时的把缓冲区中的数据拿出来，而下一个数据又到来并有一部分放入的缓冲区末尾，等我们读取数据时就是一个粘包。（放数据的速度 > 应用层拿数据速度）
84. OSI 的七层模型都有哪些？
- 应用层：网络服务与最终用户的一个接口。
- 表示层：数据的表示、安全、压缩。
- 会话层：建立、管理、终止会话。
- 传输层：定义传输数据的协议端口号，以及流控和差错校验。
- 网络层：进行逻辑地址寻址，实现不同网络之间的路径选择。
- 数据链路层：建立逻辑连接、进行硬件地址寻址、差错校验等功能。
- 物理层：建立、维护、断开物理连接。
85. get 和 post 请求有哪些区别？
- GET在浏览器回退时是无害的，而POST会再次提交请求。
- GET产生的URL地址可以被Bookmark，而POST不可以。
- GET请求会被浏览器主动cache，而POST不会，除非手动设置。
- GET请求只能进行url编码，而POST支持多种编码方式。
- GET请求参数会被完整保留在浏览器历史记录里，而POST中的参数不会被保留。
- GET请求在URL中传送的参数是有长度限制的，而POST么有。
- 对参数的数据类型，GET只接受ASCII字符，而POST没有限制。
- GET比POST更不安全，因为参数直接暴露在URL上，所以不能用来传递敏感信息。
- GET参数通过URL传递，POST放在Request body中。
86. 如何实现跨域？
方式一：图片ping或script标签跨域
图片ping常用于跟踪用户点击页面或动态广告曝光次数。
script标签可以得到从其他来源数据，这也是JSONP依赖的根据。方式二：JSONP跨域
JSONP（JSON with Padding）是数据格式JSON的一种“使用模式”，可以让网页从别的网域要数据。根据 XmlHttpRequest 对象受到同源策略的影响，而利用 <script>元素的这个开放策略，网页可以得到从其他来源动态产生的JSON数据，而这种使用模式就是所谓的 JSONP。用JSONP抓到的数据并不是JSON，而是任意的JavaScript，用 JavaScript解释器运行而不是用JSON解析器解析。所有，通过Chrome查看所有JSONP发送的Get请求都是js类型，而非XHR。
缺点：
- 只能使用Get请求
- 不能注册success、error等事件监听函数，不能很容易的确定JSONP请求是否失败
- JSONP是从其他域中加载代码执行，容易受到跨站请求伪造的攻击，其安全性无法确保
方式三：CORS
Cross-Origin Resource Sharing（CORS）跨域资源共享是一份浏览器技术的规范，提供了 Web 服务从不同域传来沙盒脚本的方法，以避开浏览器的同源策略，确保安全的跨域数据传输。现代浏览器使用CORS在API容器如XMLHttpRequest来减少HTTP请求的风险来源。与 JSONP 不同，CORS 除了 GET 要求方法以外也支持其他的 HTTP 要求。服务器一般需要增加如下响应头的一种或几种：
Access-Control-Allow-Origin: * Access-Control-Allow-Methods: POST, GET, OPTIONS Access-Control-Allow-Headers: X-PINGOTHER, Content-Type Access-Control-Max-Age: 86400跨域请求默认不会携带Cookie信息，如果需要携带，请配置下述参数：
"Access-Control-Allow-Credentials": true // Ajax设置 "withCredentials": true方式四：window.name+iframe
window.name通过在iframe（一般动态创建i）中加载跨域HTML文件来起作用。然后，HTML文件将传递给请求者的字符串内容赋值给window.name。然后，请求者可以检索window.name值作为响应。
- iframe标签的跨域能力；
- window.name属性值在文档刷新后依旧存在的能力（且最大允许2M左右）。
每个iframe都有包裹它的window，而这个window是top window的子窗口。contentWindow属性返回<iframe>元素的Window对象。你可以使用这个Window对象来访问iframe的文档及其内部DOM。
<!-- 下述用端口 10000表示：domainA 10001表示：domainB --> <!-- localhost:10000 --> <script> var iframe = document.createElement('iframe'); iframe.style.display = 'none'; // 隐藏 var state = 0; // 防止页面无限刷新 iframe.onload = function() { if(state === 1) { console.log(JSON.parse(iframe.contentWindow.name)); // 清除创建的iframe iframe.contentWindow.document.write(''); iframe.contentWindow.close(); document.body.removeChild(iframe); } else if(state === 0) { state = 1; // 加载完成，指向当前域，防止错误(proxy.html为空白页面) // Blocked a frame with origin "http://localhost:10000" from accessing a cross-origin frame. iframe.contentWindow.location = 'http://localhost:10000/proxy.html'; } }; iframe.src = 'http://localhost:10001'; document.body.appendChild(iframe); </script> <!-- localhost:10001 --> <!DOCTYPE html> ... <script> window.name = JSON.stringify({a: 1, b: 2}); </script> </html>方式五：window.postMessage()
HTML5新特性，可以用来向其他所有的 window 对象发送消息。需要注意的是我们必须要保证所有的脚本执行完才发送 MessageEvent，如果在函数执行的过程中调用了它，就会让后面的函数超时无法执行。
下述代码实现了跨域存储localStorage
<!-- 下述用端口 10000表示：domainA 10001表示：domainB --> <!-- localhost:10000 --> <iframe src="http://localhost:10001/msg.html" name="myPostMessage" style="display:none;"> </iframe> <script> function main() { LSsetItem('test', 'Test: ' + new Date()); LSgetItem('test', function(value) { console.log('value: ' + value); }); LSremoveItem('test'); } var callbacks = {}; window.addEventListener('message', function(event) { if (event.source === frames['myPostMessage']) { console.log(event) var data = /^#localStorage#(\d+)(null)?#([\S\s]*)/.exec(event.data); if (data) { if (callbacks[data[1]]) { callbacks[data[1]](data[2] === 'null' ? null : data[3]); } delete callbacks[data[1]]; } } }, false); var domain = '*'; // 增加 function LSsetItem(key, value) { var obj = { setItem: key, value: value }; frames['myPostMessage'].postMessage(JSON.stringify(obj), domain); } // 获取 function LSgetItem(key, callback) { var identifier = new Date().getTime(); var obj = { identifier: identifier, getItem: key }; callbacks[identifier] = callback; frames['myPostMessage'].postMessage(JSON.stringify(obj), domain); } // 删除 function LSremoveItem(key) { var obj = { removeItem: key }; frames['myPostMessage'].postMessage(JSON.stringify(obj), domain); } </script> <!-- localhost:10001 --> <script> window.addEventListener('message', function(event) { console.log('Receiver debugging', event); if (event.origin == 'http://localhost:10000') { var data = JSON.parse(event.data); if ('setItem' in data) { localStorage.setItem(data.setItem, data.value); } else if ('getItem' in data) { var gotItem = localStorage.getItem(data.getItem); event.source.postMessage( '#localStorage#' + data.identifier + (gotItem === null ? 'null#' : '#' + gotItem), event.origin ); } else if ('removeItem' in data) { localStorage.removeItem(data.removeItem); } } }, false); </script>注意Safari一下，会报错：
Blocked a frame with origin “http://localhost:10001” from accessing a frame with origin “http://localhost:10000“. Protocols, domains, and ports must match.
避免该错误，可以在Safari浏览器中勾选开发菜单==>停用跨域限制。或者只能使用服务器端转存的方式实现，因为Safari浏览器默认只支持CORS跨域请求。
方式六：修改document.domain跨子域
前提条件：这两个域名必须属于同一个基础域名!而且所用的协议，端口都要一致，否则无法利用document.domain进行跨域，所以只能跨子域
在根域范围内，允许把domain属性的值设置为它的上一级域。例如，在”aaa.xxx.com”域内，可以把domain设置为 “xxx.com” 但不能设置为 “xxx.org” 或者”com”。
现在存在两个域名aaa.xxx.com和bbb.xxx.com。在aaa下嵌入bbb的页面，由于其document.name不一致，无法在aaa下操作bbb的js。可以在aaa和bbb下通过js将document.name = 'xxx.com';设置一致，来达到互相访问的作用。
方式七：WebSocket
WebSocket protocol 是HTML5一种新的协议。它实现了浏览器与服务器全双工通信，同时允许跨域通讯，是server push技术的一种很棒的实现。相关文章，请查看：WebSocket、WebSocket-SockJS
需要注意：WebSocket对象不支持DOM 2级事件侦听器，必须使用DOM 0级语法分别定义各个事件。
方式八：代理
同源策略是针对浏览器端进行的限制，可以通过服务器端来解决该问题
DomainA客户端（浏览器） ==> DomainA服务器 ==> DomainB服务器 ==> DomainA客户端（浏览器）
来源：blog.csdn.net/ligang2585116/article/details/73072868
87.说一下 JSONP 实现原理？
jsonp 即 json+padding，动态创建script标签，利用script标签的src属性可以获取任何域下的js脚本，通过这个特性(也可以说漏洞)，服务器端不在返货json格式，而是返回一段调用某个函数的js代码，在src中进行了调用，这样实现了跨域。
九、设计模式
88. 说一下你熟悉的设计模式？
89. 简单工厂和抽象工厂有什么区别？
简单工厂模式：
这个模式本身很简单而且使用在业务较简单的情况下。一般用于小项目或者具体产品很少扩展的情况（这样工厂类才不用经常更改）。
它由三种角色组成：
- 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，根据逻辑不同，产生具体的工厂产品。如例子中的Driver类。
- 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。由接口或者抽象类来实现。如例中的Car接口。
- 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现，如例子中的Benz、Bmw类。
来用类图来清晰的表示下的它们之间的关系：
抽象工厂模式：
先来认识下什么是产品族： 位于不同产品等级结构中，功能相关联的产品组成的家族。
图中的BmwCar和BenzCar就是两个产品树（产品层次结构）；而如图所示的BenzSportsCar和BmwSportsCar就是一个产品族。他们都可以放到跑车家族中，因此功能有所关联。同理BmwBussinessCar和BenzBusinessCar也是一个产品族。
可以这么说，它和工厂方法模式的区别就在于需要创建对象的复杂程度上。而且抽象工厂模式是三个里面最为抽象、最具一般性的。抽象工厂模式的用意为：给客户端提供一个接口，可以创建多个产品族中的产品对象。
而且使用抽象工厂模式还要满足一下条件：
- 系统中有多个产品族，而系统一次只可能消费其中一族产品
- 同属于同一个产品族的产品以其使用。
来看看抽象工厂模式的各个角色（和工厂方法的如出一辙）：
- 抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
- 具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
- 抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
- 具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
十、Spring / Spring MVC
90. 为什么要使用 spring？
1.简介
- 目的：解决企业应用开发的复杂性
- 功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能
- 范围：任何Java应用
简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。
2.轻量
从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。
3.控制反转
Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。
4.面向切面
Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。
5.容器
Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。
6.框架
Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。
所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。
91. 解释一下什么是 aop？
AOP（Aspect-Oriented Programming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。
而AOP技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。
使用“横切”技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理。Aop 的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。正如Avanade公司的高级方案构架师Adam Magee所说，AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离。”
92. 解释一下什么是 ioc？
IOC是Inversion of Control的缩写，多数书籍翻译成“控制反转”。
1996年，Michael Mattson在一篇有关探讨面向对象框架的文章中，首先提出了IOC 这个概念。对于面向对象设计及编程的基本思想，前面我们已经讲了很多了，不再赘述，简单来说就是把复杂系统分解成相互合作的对象，这些对象类通过封装以后，内部实现对外部是透明的，从而降低了解决问题的复杂度，而且可以灵活地被重用和扩展。
IOC理论提出的观点大体是这样的：借助于“第三方”实现具有依赖关系的对象之间的解耦。如下图：
大家看到了吧，由于引进了中间位置的“第三方”，也就是IOC容器，使得A、B、C、D这4个对象没有了耦合关系，齿轮之间的传动全部依靠“第三方”了，全部对象的控制权全部上缴给“第三方”IOC容器，所以，IOC容器成了整个系统的关键核心，它起到了一种类似“粘合剂”的作用，把系统中的所有对象粘合在一起发挥作用，如果没有这个“粘合剂”，对象与对象之间会彼此失去联系，这就是有人把IOC容器比喻成“粘合剂”的由来。
我们再来做个试验：把上图中间的IOC容器拿掉，然后再来看看这套系统：
我们现在看到的画面，就是我们要实现整个系统所需要完成的全部内容。这时候，A、B、C、D这4个对象之间已经没有了耦合关系，彼此毫无联系，这样的话，当你在实现A的时候，根本无须再去考虑B、C和D了，对象之间的依赖关系已经降低到了最低程度。所以，如果真能实现IOC容器，对于系统开发而言，这将是一件多么美好的事情，参与开发的每一成员只要实现自己的类就可以了，跟别人没有任何关系！
我们再来看看，控制反转(IOC)到底为什么要起这么个名字？我们来对比一下：
软件系统在没有引入IOC容器之前，如图1所示，对象A依赖于对象B，那么对象A在初始化或者运行到某一点的时候，自己必须主动去创建对象B或者使用已经创建的对象B。无论是创建还是使用对象B，控制权都在自己手上。
软件系统在引入IOC容器之后，这种情形就完全改变了，如图3所示，由于IOC容器的加入，对象A与对象B之间失去了直接联系，所以，当对象A运行到需要对象B的时候，IOC容器会主动创建一个对象B注入到对象A需要的地方。
通过前后的对比，我们不难看出来：对象A获得依赖对象B的过程,由主动行为变为了被动行为，控制权颠倒过来了，这就是“控制反转”这个名称的由来。
93. spring 有哪些主要模块？
Spring框架至今已集成了20多个模块。这些模块主要被分如下图所示的核心容器、数据访问/集成,、Web、AOP（面向切面编程）、工具、消息和测试模块。
更多信息：howtodoinjava.com/java-spring-framework-tutorials/
94. spring 常用的注入方式有哪些？
Spring通过DI（依赖注入）实现IOC（控制反转），常用的注入方式主要有三种：
- 构造方法注入
- setter注入
- 基于注解的注入
95. spring 中的 bean 是线程安全的吗？
Spring容器中的Bean是否线程安全，容器本身并没有提供Bean的线程安全策略，因此可以说spring容器中的Bean本身不具备线程安全的特性，但是具体还是要结合具体scope的Bean去研究。
96. spring 支持几种 bean 的作用域？
当通过spring容器创建一个Bean实例时，不仅可以完成Bean实例的实例化，还可以为Bean指定特定的作用域。Spring支持如下5种作用域：
- singleton：单例模式，在整个Spring IoC容器中，使用singleton定义的Bean将只有一个实例
- prototype：原型模式，每次通过容器的getBean方法获取prototype定义的Bean时，都将产生一个新的Bean实例
- request：对于每次HTTP请求，使用request定义的Bean都将产生一个新实例，即每次HTTP请求将会产生不同的Bean实例。只有在Web应用中使用Spring时，该作用域才有效
- session：对于每次HTTP Session，使用session定义的Bean豆浆产生一个新实例。同样只有在Web应用中使用Spring时，该作用域才有效
- globalsession：每个全局的HTTP Session，使用session定义的Bean都将产生一个新实例。典型情况下，仅在使用portlet context的时候有效。同样只有在Web应用中使用Spring时，该作用域才有效
其中比较常用的是singleton和prototype两种作用域。对于singleton作用域的Bean，每次请求该Bean都将获得相同的实例。容器负责跟踪Bean实例的状态，负责维护Bean实例的生命周期行为；如果一个Bean被设置成prototype作用域，程序每次请求该id的Bean，Spring都会新建一个Bean实例，然后返回给程序。在这种情况下，Spring容器仅仅使用new 关键字创建Bean实例，一旦创建成功，容器不在跟踪实例，也不会维护Bean实例的状态。
如果不指定Bean的作用域，Spring默认使用singleton作用域。Java在创建Java实例时，需要进行内存申请；销毁实例时，需要完成垃圾回收，这些工作都会导致系统开销的增加。因此，prototype作用域Bean的创建、销毁代价比较大。而singleton作用域的Bean实例一旦创建成功，可以重复使用。因此，除非必要，否则尽量避免将Bean被设置成prototype作用域。
97. spring 自动装配 bean 有哪些方式？
Spring容器负责创建应用程序中的bean同时通过ID来协调这些对象之间的关系。作为开发人员，我们需要告诉Spring要创建哪些bean并且如何将其装配到一起。
spring中bean装配有两种方式：
- 隐式的bean发现机制和自动装配
- 在java代码或者XML中进行显示配置
当然这些方式也可以配合使用。
98. spring 事务实现方式有哪些？
- 编程式事务管理对基于 POJO 的应用来说是唯一选择。我们需要在代码中调用beginTransaction()、commit()、rollback()等事务管理相关的方法，这就是编程式事务管理。
- 基于 TransactionProxyFactoryBean 的声明式事务管理
- 基于 @Transactional 的声明式事务管理
- 基于 Aspectj AOP 配置事务
99. 说一下 spring 的事务隔离？
事务隔离级别指的是一个事务对数据的修改与另一个并行的事务的隔离程度，当多个事务同时访问相同数据时，如果没有采取必要的隔离机制，就可能发生以下问题：
- 脏读：一个事务读到另一个事务未提交的更新数据。
- 幻读：例如第一个事务对一个表中的数据进行了修改，比如这种修改涉及到表中的“全部数据行”。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入“一行新数据”。那么，以后就会发生操作第一个事务的用户发现表中还存在没有修改的数据行，就好象发生了幻觉一样。
- 不可重复读：比方说在同一个事务中先后执行两条一模一样的select语句，期间在此次事务中没有执行过任何DDL语句，但先后得到的结果不一致，这就是不可重复读。
100. 说一下 spring mvc 运行流程？
Spring MVC运行流程图：
Spring运行流程描述：
1. 用户向服务器发送请求，请求被Spring 前端控制Servelt DispatcherServlet捕获；
2. DispatcherServlet对请求URL进行解析，得到请求资源标识符（URI）。然后根据该URI，调用HandlerMapping获得该Handler配置的所有相关的对象（包括Handler对象以及Handler对象对应的拦截器），最后以HandlerExecutionChain对象的形式返回；
3. DispatcherServlet 根据获得的Handler，选择一个合适的HandlerAdapter；（附注：如果成功获得HandlerAdapter后，此时将开始执行拦截器的preHandler(...)方法）
4. 提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)。 在填充Handler的入参过程中，根据你的配置，Spring将帮你做一些额外的工作：
- HttpMessageConveter： 将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息
- 数据转换：对请求消息进行数据转换。如String转换成Integer、Double等
- 数据根式化：对请求消息进行数据格式化。 如将字符串转换成格式化数字或格式化日期等
- 数据验证： 验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中
5. Handler执行完成后，向DispatcherServlet 返回一个ModelAndView对象；
6. 根据返回的ModelAndView，选择一个适合的ViewResolver（必须是已经注册到Spring容器中的ViewResolver)返回给DispatcherServlet ；
7. ViewResolver 结合Model和View，来渲染视图；
8. 将渲染结果返回给客户端。
101. spring mvc 有哪些组件？
Spring MVC的核心组件：
- DispatcherServlet：中央控制器，把请求给转发到具体的控制类
- Controller：具体处理请求的控制器
- HandlerMapping：映射处理器，负责映射中央处理器转发给controller时的映射策略
- ModelAndView：服务层返回的数据和视图层的封装类
- ViewResolver：视图解析器，解析具体的视图
- Interceptors ：拦截器，负责拦截我们定义的请求然后做处理工作
102. @RequestMapping 的作用是什么？
RequestMapping是一个用来处理请求地址映射的注解，可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。
RequestMapping注解有六个属性，下面我们把她分成三类进行说明。
value， method：
- value：指定请求的实际地址，指定的地址可以是URI Template 模式（后面将会说明）；
- method：指定请求的method类型， GET、POST、PUT、DELETE等；
consumes，produces
- consumes：指定处理请求的提交内容类型（Content-Type），例如application/json, text/html；
- produces：指定返回的内容类型，仅当request请求头中的(Accept)类型中包含该指定类型才返回；
params，headers
- params： 指定request中必须包含某些参数值是，才让该方法处理。
- headers：指定request中必须包含某些指定的header值，才能让该方法处理请求。
103. @Autowired 的作用是什么？
未完待续......
欢迎大家关注我的公众号：Java团长，后续面试题更新之后可以在第一时间获取~
-
Java语言特点
2019-06-30 19:37:45但是有些情况下性能是很要紧的，为了支持这些情况，Java设计者制作了“及时”编译程序，它能在运行时把Java字节码翻译成特定CPU（中央处理器）的机器代码，也就是实现全编译了。Java字节码格式设计时考虑到这些...展开全文
文章目录
Java语言是简单的
- Java语言的语法与C语言和C++语言很接近，从某种意义上讲，它是由C和C++演变而来，使得大多数程序员很容易学习和使用。
- 对C++来说进行了简化和一定的提高，如：使用接口代替了复杂的多重继承以及取消了指针，还通过实现垃圾自动回收机制，大大简化了程序员的资源释放管理工作。
- 提供了丰富的类库和API文档，以及第三方开发包工具包，还有大量的基于Java的开源项目，帮助程序设计人员参考学习，JDK就是开放的源代码之一，读者可以通过分析项目的源代码，来提高自己的编程水平。
Java语言是面向对象的
面向对象就是Java语言的基础，也是Java语言的重要特性。面向对象是指以对象为基本单元，包含属性和方法。对象的状态用属性表达，对象的行为用方法表达。
面向对象技术使得应用程序的开发变得简单易用，节省代码。总之，Java语言是一个纯面向对象的程序设计语言。
Java语言是分布式的
- 分布性主要包括两大方面，分别是操作分布和数据分布，其中操作分布指的是在多个不同的主机上布置相关操作，数据分布是将数据分别存放在多个网络中不同的主机上，借助的是URL（统一资源定位符）访问网络对象，访问方式和访问本地系统相似。
- Java语言具有一个强大的，易于使用的网络能力，这是非常适合于分布式计算程序的。
- Java语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口(java.net)，它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI(远程方法激活)机制也是开发分布式应用的重要手段。
Java语言是多线程的
多线程机制使应用程序在同一时间并行执行多项任务，Java语言提供多线程之间的同步机制，这些相应的同步机制可以很好的保证不同线程，能够正确的共享数据。多线程机制使程序具有更好的交互性和实时性。
Java语言是高性能的
- Java是一种先编译后解释的语言，所以它不如全编译性语言快。但是有些情况下性能是很要紧的，为了支持这些情况，Java设计者制作了“及时”编译程序，它能在运行时把Java字节码翻译成特定CPU（中央处理器）的机器代码，也就是实现全编译了。Java字节码格式设计时考虑到这些“及时”编译程序的需要，所以生成机器代码的过程相当简单，它能产生相当好的代码。
- 与那些解释型的高级脚本语言相比，Java的确是高性能的。事实上，Java的运行速度随着JIT(Just-In-Time）编译器技术的发展越来越接近于C++。
Java语言是跨平台的
- 所谓的跨平台性，是指软件可以不受计算机硬件和操作系统的约束而在任意计算机环境下正常运行。这是软件发展的趋势和编程人员追求的目标。之所以这样说，是因为计算机硬件的种类繁多，操作系统也各不相同，不同的用户和公司有自己不同的计算机环境偏好，而软件为了能在这些不同的环境里正常运行，就需要独立于这些平台。
- 在Java语言中，Java自带的虚拟机很好地实现了跨平台性。Java源代码经过编译后生成二进制的字节码是与平台无关的，Java虚拟机在执行字节码时，把字节码解释成具体平台上的机器指令执行。这就是Java的能够Write once, run anywhere(一次编译，到处运行)的原因。Java虚拟机提供了一个字节码到底层硬件平台及操作系统的屏障，使得Java语言具备跨平台性。
Java语言是可移植的
可移植性来源于跨平台性性，另外，Java还严格规定了各个基本数据类型的长度。Java系统本身也具有很强的可移植性，Java编译器是用Java实现的，Java的运行环境是用ANSI C实现的。
Java语言是安全的
在Java语言中删除了类似于C语言中的指针和内容释放等语法，有效的避免了非法操作内存，代码要经过校验之后才能够运行，所以未经允许的Java程序不可能出现损害系统平台的行为，最大的好处就是，Java可以编写防病毒和可修复的系统，Java通常被用在网络环境中，为此，Java提供了一个安全机制以防恶意代码的攻击，从而可以提高系统的安全性。
Java语言是健壮的
Java语言的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。对指针的丢弃是Java的明智选择。Java的安全检查机制使得Java更具健壮性。
Java语言是动态的
- Java语言的设计目标之一是适应于动态变化的环境。Java程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类，这也有利于软件的升级。
- Java中的类有一个运行时刻的表示，能进行运行时刻的类型检查。
-
《Python程序设计与算法基础教程（第二版）》江红 余青松 全部章节的课后习题，上机实践，课后答案，案例...
2019-09-25 22:11:19若认可本篇博客，希望给一个点赞、收藏 并且，遇到了什么问题，请在评论区留言，我会及时回复的 这本书对Python的知识点的描述很详细，而且排版看的很舒服 几个例题： 假装自己从零开始学，将一些有代表性、有意思的...展开全文（还在更新中…） 这篇博客花费了我的大量时间和精力，从创作到维护；若认可本篇博客，希望给一个点赞、收藏
并且，遇到了什么问题，请在评论区留言，我会及时回复的
这本书对Python的知识点的描述很详细，而且排版看的很舒服
- 几个例题： 假装自己从零开始学，将一些有代表性、有意思的例题抽取出来
- 部分复习题： 遇到有意思的复习题，我会拿出来，并且进行分析
- 上机实践： 全部上机实践题的解题思路
文章目录
第一章 Python概述
几个例题
一：Python3.7.4下载
python3.7.4下载地址：https://www.python.org/downloads/release/python-374/
页面最下面：
下载，安装完python后：出现的四个玩意：Python 3.7 Module Docs，IDLE，Python 3.7 Manuals，Python 3.7（64-bit）
-
Python 3.7 Module Docs（64-bit）
点击之后，会出现一个网页（将我下载的Python3.7.4文件夹中包含的模块都列了出来,页面不止这么点，还可以往下拉）
-
IDLE（Python 3.7 64-bit）
一个Python编辑器，Python内置的集成开发工具
-
Python 3.7 Manuals（64-bit）
Python 3.7 开发手册 -
Python 3.7（64-bit）
控制台中运行Python
二：更新pip和setuptools包，安装NumPy包，安装Matplotlib包
以下三个命令都是在控制台（windows中的cmd）中运行
更新pip和setuptools包
- pip用于安装和管理Python扩展包
- setuptools用于发布Python包
python -m pip install -U pip setuptools安装NumPy
Python扩展模块NumPy提供了数组和矩阵处理，以及傅立叶变换等高效的数值处理功能
python -m pip install NumPy安装Matplotlib包
Matplotlib是Python最著名的绘图库之一，提供了一整套和MATLAB相似的命令API，既适合交互式地进行制图，也可以作为绘图控件方便地嵌入到GUI应用程序中
python -m pip install Matplotlib三：使用IDLE打开和执行Python源文件程序
首先：
有一个.py文件test.py
使用IDLE打开.py文件的两种方式：
- 右键test.py---->Edit With IDLE---->Edit With IDLE 3.7（64-bit）
- 打开IDLE，然后File---->Open（或者
ctrl+O）选择.py文件
运行
Run---->Run Module（或者
F5）
就会出现这个界面，执行结果显示在这个界面中
补充一点：
如果在IDLE中编辑.py文件，记得修改后要保存（ctrl+s），再运行（F5）
四：使用资源管理器运行hello.py
hello.py文件在桌面
import random print("hello,Python") print("你今天的随机数字是：",random.choice(range(10)))#输出在0-9之间随机选择的整数 input()- 在桌面打开PowerShell（还有两种输入方式：
python hello.py或者.\hello.py）
- 或者在桌面打开cmd, 就输入
hello.py或者python hello.py
补充：上述两种命令中的
hello.py都是相对路径，因为文件在桌面，而且我是在桌面打开cmd，所以文件路劲可以这么简简单单的写。如果文件存储位置和cmd打开位置不一样，请使用绝对路径五：命令行参数示例hello_argv.py
hello_argv.py文件在桌面
import sys print("Hello,",sys.argv[1]) #这样写也行： #print("Hello,"+sys.argv[1])- 在桌面打开PowerShell（还有两种输入方式：
python hello_argv.py 任意输入或者./hello_argv.py 任意输入）
- 或者在桌面打开cmd，就输入
hello_argv.py 任意输入或者python hello_argv.py 任意输入
补充：以图中第一个命令举例，
hello_argv.py即sys.argv[0]；Python即sys.argv[1]第二章 Python语言基础
选择题：1、3、7、8
1. 在Python中，以下标识符合法的是
A. _ B. 3C C. it’s B. str 答案：A
- 标识符的第一个字符必须是字母，下划线（_）；其后的字符可以是字母、下划线或数字。
- 一些特殊的名称，作为python语言的保留关键字，不能作为标识符
- 以双下划线开始和结束的名称通常具有特殊的含义。例如
__init__为类的构造函数，一般应避免使用
B：以数字开头，错误
C：使用了'，不是字母、下划线或数字
D：str是保留关键字3. 在下列Python语句中非法的是
A. x = y =1 B. x = (y =1) C. x,y = y,x B. x=1;y=1 答案：B，C
7. 为了给整型变量x，y，z赋初值10，下面Python赋值语句正确的是
A. xyz=10 B. x=10 y=10 z=10 C. x=y=z=10 B. x=10，y=10，z=10 答案：C
- 分号
;用于在一行书写多个语句 - python支持链式赋值
A：赋值对象是xyz
B：分号;用于在一行书写多个语句，而不是' '（即空格）
D：分号;用于在一行书写多个语句，而不是,8. 为了给整型变量x，y，z赋初值5，下面Python赋值语句正确的是
A. x=5;y=5;z=5 B. xyz=5 C. x,y,z=10 B. x=10，y=10，z=10 答案：A
Pytho能支持序列解包赋值，但是变量的个数必须与序列的元素个数一致，否则会报错
B：赋值对象是xyz
C：序列解包赋值，变量的个数必须与序列的元素个数一致，否则会报错
D：分号;用于在一行书写多个语句，而不是,思考题：9
9.下列Python语句的输出结果是
def f():pass print(type(f()))结果：
<class 'NoneType'>NoneType数据类型包含唯一值None，主要用于表示空值，如没有返回值的函数的结果
上机实践：2~6
2. 编写程序，输入本金、年利率和年数，计算复利（结果保留两位小数）
money = int(input("请输入本金：")) rate = float(input("请输入年利率：")) years = int(input("请输入年数：")) amount = money*((1+rate/100)**years) print(str.format("本金利率和为：{0:2.2f}",amount))运行：
请输入本金：1000 请输入年利率：6.6 请输入年数：10 本金利率和为：1894.843. 编写程序，输入球的半径，计算球的表面积和体积（结果保留两位小数）
import math r = float(input("请输入球的半径：")) area = 4 * math.pi * r**2 volume = 4/3*math.pi*r**3 print(str.format("球的表面积为：{0:2.2f}，体积为：{1:2.2f}",area,volume))运行：
请输入球的半径：666 球的表面积为：5573889.08，体积为：1237403376.704. 编写程序，声明函数getValue(b,r,n)，根据本金b，年利率r和年数n计算最终收益v
money = int(input("请输入本金：")) rate = float(input("请输入年利率(<1)：")) years = int(input("请输入年数：")) def getValue(b,r,n): return b*(1+r)**n print(str.format("本金利率和为：{0:2.2f}",getValue(money,rate,years)))运行：
请输入本金：10000 请输入年利率(<1)：0.6 请输入年数：6 本金利率和为：167772.165. 编写程序，求解一元二次方程x2-10x+16=0
from math import sqrt x = (10+sqrt(10*10-4*16))/2 y = (10-sqrt(10*10-4*16))/2 print(str.format("x*x-10*x+16=0的解为：{0:2.2f}，{1:2.2f}",x,y))运行：
x*x-10*x+16=0的解为：8.00，2.006. 编写程序，提示输入姓名和出生年份，输出姓名和年龄
import datetime sName = str(input("请输入您的姓名：")) birthday = int(input("请输入您的出生年份：")) age = datetime.date.today().year - birthday print("您好！{0}。您{1}岁。".format(sName,age))运行：
请输入您的姓名：zgh 请输入您的出生年份：1999 您好！zgh。您20岁。案例研究：使用Pillow库处理图像文件
https://blog.csdn.net/Zhangguohao666/article/details/102060722
通过此案例，进一步了解Python的基本概念：模块、对象、方法和函数的使用
第三章 程序流程控制
几个例题
一：编程判断某一年是否为闰年
闰年：年份能被4整除但不能被100整除，或者可以被400整除。
口诀：四年一闰，百年不闰，四百必闰代码一：
y = int(input("请输入要判断的年份：")) if((y % 4 == 0 and y % 100 != 0) or y % 400 == 0): print("是闰年") else: print("不是闰年")代码二（使用calendar模块的isleap()函数来判断）：
from calendar import isleap y = int(input("请输入要判断的年份：")) if(isleap(y)):print("闰年") else:print("不是闰年")二：利用嵌套循环打印九九乘法表
九九乘法表：
for i in range(1,10): s = "" for j in range(1,10): s += str.format("%d * %d = %02d " %(i, j, i*j)) print(s)
下三角：
for i in range(1,10): s = "" for j in range(1,i+1): s += str.format("%d * %d = %02d " %(i, j, i*j)) print(s)
上三角：
for i in range(1,10): s = "" for k in range(1,i): s += " " for j in range(i,10): s += str.format("%d * %d = %02d " %(i, j, i*j)) print(s)
三：enumerate()函数和下标元素循环示例
Python语言中的for循环直接迭代对象集合中的元素，如果需要在循环中使用索引下标访问集合元素，则可以使用内置的enumerate()函数
enumerate()函数用于将一个可遍历的数据对象（例如列表、元组或字符串）组合为一个索引序列，并返回一个可迭代对象，故在for循环当中可直接迭代下标和元素
seasons = ["Spring","Summer","Autumn","Winter"] for i,s in enumerate(seasons,start=1): #start默认从0开始 print("第{0}个季节：{1}".format(i,s))运行：
第1个季节：Spring 第2个季节：Summer 第3个季节：Autumn 第4个季节：Winter四：zip()函数和并行循环示例
如果需要并行遍历多个可迭代对象，则可以使用Python的内置函数zip()
zip()函数将多个可迭代对象中对应的元素打包成一个个元组，然后返回一个可迭代对象。如果元素的个数不一致，则返回列表的长度与最短的对象相同。
利用运算符
*还可以实现将元组解压为列表evens = [0,2,4,6,8] odds = [1,3,5,7,9] for e,o in zip(evens,odds): print("{0} * {1} = {2}".format(e,o,e*o))运行：
0 * 1 = 0 2 * 3 = 6 4 * 5 = 20 6 * 7 = 42 8 * 9 = 72五：map()函数和循环示例
如果需要遍历可迭代对象，并使用指定函数处理对应的元素，则可以使用Python的内置函数map()
map(func,seq1[,seq2,...])- func作用于seq中的每一个元素，并将所有的调用结果作为可迭代对象返回。
- 如果func为None，该函数的作用等同于zip()函数
计算绝对值：
>>> list(map(abs, [-1, 0, 7, -8])) [1, 0, 7, 8]计算乘幂：
>>> list(map(pow, range(5), range(5))) [1, 1, 4, 27, 256]计算ASCII码：
>>> list(map(ord, 'zgh')) [122, 103, 104]字符串拼接（使用了匿名函数lambda）：
>>> list(map(lambda x, y: x+y, 'zgh', '666')) ['z6', 'g6', 'h6']选择题：1、2、3
1. 下面的Python循环体的执行次数与其他不同的是
A.
i = 0 while(i <= 10): print(i) i = i + 1B.
i = 10 while(i > 0): print(i) i = i - 1C.
for i in range(10): print(i)D.
for i in range(10,0,-1): print(i)答案：A
A：[0,10] 执行11次
B：[10,1] 执行10次
C：[0,9) 执行10次
D：[10,0) 执行10次2. 执行下列Python语句将产生的结果是
x = 2; y = 2.0 if(x == y): print("Equal") else: print("Not Equal")A. Equal B. Not Equal C. 编译错误 D. 运行时错误 答案：A
Python中的自动类型转换：
- 自动类型转换注意针对Number数据类型来说的
- 当2个不同类型的数据进行运算的时候,默认向更高精度转换
- 数据类型精度从低到高:bool int float complex
- 关于bool类型的两个值：True 转化成整型是1；False 转化成整型是0
int类型的2转化为float类型的2.0
3. 执行下列Python语句将产生的结果是
i= 1 if(i): print(True) else: print(False)A. 输出1 B. 输出True C. 输出False D. 编译错误 答案：B
在Python中，条件表达式最后被评价为bool值True或False。
如果表达式的结果为数值类型（
0），空字符串（""），空元组（()），空列表（[]），空字典（{}），其bool值为False，否则其bool值为True填空题：6
6. 要使语句for i in range(_,-4,-2)循环执行15次，则循环变量i的初值应当为
答案：26或者25
一开始我给的答案是26，经过评论区 亻的提醒：
>>> a = 0 >>> for i in range(26, -4, -2): a+=1 >>> print(a) 15 >>> a = 0 >>> for i in range(25, -4, -2): a+=1 >>> print(a) 15这种题目有一个规律：
for i in range(x,y,z):
若循环中没有break或者continue语句，
执行次数的绝对值：result = (x-y)÷z但实际上没有这么简单：
- 如果步长为 -1或者1，那么答案只有一个
- 如果步长为 -2或者2，那么答案有两个
- 如果步长为 -3或者3，那么答案有三个
- …
通过公式算出 x 之后，
- 如果步长为2，还要计算 (x ± 1) - z × (result-1) 的值，然后再经过琐碎的判断即可
- 如果步长为3，还要计算 (x ± 2) - z × (result-1) 的值，…
- …
虽然看着麻烦，但实际上是很好理解的
思考题：3~6
3. 阅读下面的Python程序，请问程序的功能是什么？
from math import sqrt n = 0 for m in range(101,201,2): k = int(sqrt(m)) for i in range(2, k+2): if m % i == 0:break if i == k + 1: if n % 10 == 0:print() print('%d' % m,end = " ") n += 1输出101到200之间的素数
每行输出10个，多余换行运行：
101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199素数（质数）是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。
4. 阅读下面的Python程序，请问输出的结果使什么？
n = int(input("请输入图形的行数：")) for i in range(0, n): for j in range(0, 10 - i):print(" ", end=" ") for k in range(0, 2 * i + 1):print(" * ", end=" ") print("\n")输出的是一个金字塔
运行：
请输入图形的行数：4 * * * * * * * * * * * * * * * *5. 阅读下面的Python程序，请问输出的结果使什么？程序的功能是什么？
for i in range(100,1000): n1 = i // 100 n2 = i // 10 % 10 n3 = i % 10 if(pow(n1, 3) + pow(n2, 3) + pow(n3, 3) == i):print(i, end=" ")输出三位数中所有的水仙花数
运行：
153 370 371 407水仙花数 是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身
6. 阅读下面的Python程序，请问输出的结果使什么？程序的功能是什么？
for n in range(1,1001): total = 0; factors = [] for i in range(1, n): if(n % i == 0): factors.append(i) total += i if(total == n):print("{0} : {1}".format(n, factors))输出1到1000的所有完数，并输出每个完数的所有因子
运行：
6 : [1, 2, 3] 28 : [1, 2, 4, 7, 14] 496 : [1, 2, 4, 8, 16, 31, 62, 124, 248]完数 所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身
上机实践：2~14
2. 编写程序，计算1=2+3+…+100之和
- 使用for循环（递增）：
total = 0 for i in range(101): total += i print(total)- 使用求和公式：
>>> (1 + 100) * 100 /2 5050.0- 使用累计迭代器itertools.accumulate
>>> import itertools >>> list(itertools.accumulate(range(1, 101)))[99] 50503. 编写程序，计算10+9+8+…+1之和
- 使用for循环（递增）：
total = 0 for i in range(11): total += i print(total)- 使用for循环（递减）：
total = 0 for i in range(10,0,-1): total += i print(total)- 使用求和公式：
>>> (1 + 10) * 10 / 2 55.0- 使用累计迭代器itertools.accumulate
>>> import itertools >>> list(itertools.accumulate(range(1,11)))[9] 554. 编写程序，计算1+3+5+7+…+99之和
- 使用for循环（递增）：
total = 0 for i in range(1,100,2): total += i print(total)- 使用求和公式：
>>> (1 + 99) * 50 /2 2500.0- 使用累计迭代器itertools.accumulate
>>> import itertools >>> list(itertools.accumulate(range(1,100,2)))[49] 25005. 编写程序，计算2+4+6+8+…+100之和
- 使用for循环（递增）：
total = 0 for i in range(2,101,2): total += i print(total)- 使用求和公式：
>>> (2 + 100) * 50 / 2 2550.0- 使用累计迭代器itertools.accumulate
>>> import itertools >>> x = list(itertools.accumulate(range(2,101,2))) >>> x[len(x)-1] 25506. 编写程序，使用不同的实现方法输出2000~3000的所有闰年
代码一：
for y in range(2000,3001): if((y % 4 == 0 and y % 100 != 0) or y % 400 == 0): print(y,end = ' ')代码二（使用calendar模块的isleap()函数来判断）：
from calendar import isleap for y in range(2000,3001): if(isleap(y)):print(y,end = " ")运行：
2000 2004 2008 2012 2016 2020 2024 2028 2032 2036 2040 2044 2048 2052 2056 2060 2064 2068 2072 2076 2080 2084 2088 2092 2096 2104 2108 2112 2116 2120 2124 2128 2132 2136 2140 2144 2148 2152 2156 2160 2164 2168 2172 2176 2180 2184 2188 2192 2196 2204 2208 2212 2216 2220 2224 2228 2232 2236 2240 2244 2248 2252 2256 2260 2264 2268 2272 2276 2280 2284 2288 2292 2296 2304 2308 2312 2316 2320 2324 2328 2332 2336 2340 2344 2348 2352 2356 2360 2364 2368 2372 2376 2380 2384 2388 2392 2396 2400 2404 2408 2412 2416 2420 2424 2428 2432 2436 2440 2444 2448 2452 2456 2460 2464 2468 2472 2476 2480 2484 2488 2492 2496 2504 2508 2512 2516 2520 2524 2528 2532 2536 2540 2544 2548 2552 2556 2560 2564 2568 2572 2576 2580 2584 2588 2592 2596 2604 2608 2612 2616 2620 2624 2628 2632 2636 2640 2644 2648 2652 2656 2660 2664 2668 2672 2676 2680 2684 2688 2692 2696 2704 2708 2712 2716 2720 2724 2728 2732 2736 2740 2744 2748 2752 2756 2760 2764 2768 2772 2776 2780 2784 2788 2792 2796 2800 2804 2808 2812 2816 2820 2824 2828 2832 2836 2840 2844 2848 2852 2856 2860 2864 2868 2872 2876 2880 2884 2888 2892 2896 2904 2908 2912 2916 2920 2924 2928 2932 2936 2940 2944 2948 2952 2956 2960 2964 2968 2972 2976 2980 2984 2988 2992 29967. 编写程序，计算Sn=1-3+5-7+9-11…
代码一：
n = int(input("项数：")) total = 0 flag = True for i in range(1,2*n,2): if(flag): total += i flag = False else: total -= i flag = True print(total)代码二：
n = int(input("项数：")) total = 0 x = 2 for i in range(1,2*n,2): total += pow(-1,x)*i x += 1 print(total)运行：
项数：10 -108. 编写程序，计算Sn=1+1/2+1/3+…
n = int(input("项数：")) total = 0.0 for i in range(1,n+1): total += 1/i print(total)运行：
项数：10 2.92896825396825389. 编写程序，打印九九乘法表。要求输入九九乘法表的各种显示效果（上三角，下三角，矩形块等方式）
矩形块：
for i in range(1,10): s = "" for j in range(1,10): s += str.format("%d * %d = %02d " %(i, j, i*j)) print(s)
下三角：
for i in range(1,10): s = "" for j in range(1,i+1): s += str.format("%d * %d = %02d " %(i, j, i*j)) print(s)
上三角：
for i in range(1,10): s = "" for k in range(1,i): s += " " for j in range(i,10): s += str.format("%d * %d = %02d " %(i, j, i*j)) print(s)
10. 编写程序，输入三角形的三条边，先判断是否可以构成三角形，如果可以，则进一步求三角形的周长和面积，否则报错“无法构成三角形！”
from math import sqrt a = float(input("请输入三角形的边长a：")) b = float(input("请输入三角形的边长b：")) c = float(input("请输入三角形的边长c：")) if(a < b): a,b = b,a if(a < c): a,c = c,a if(b < c): b,c = c,b if(a < 0 or b < 0 or c < 0 or b+c <= a): print("无法构成三角形！") else: h = (a+b+c)/2 area = sqrt(h*(h-a)*(h-b)*(h-c)) print("周长：{0}，面积：{1}".format(a+b+c,area))运行：
请输入三角形的边长a：4 请输入三角形的边长b：3 请输入三角形的边长c：5 周长：12.0，面积：6.011. 编写程序，输入x，根据如下公式计算分段函数y的值。请分别用单分支语句，双分支语句结构以及条件运算语句等方法实现
y = (x2-3x)/(x+1) + 2π + sinx （x≥0 ）
y = ln(-5x) + 6√(|x|+e4) - (x+1)3 (x<0)单分支语句：
import math x = float(input("请输入x：")) if(x >= 0): y = (x*x - 3*x)/(x+1) + 2*math.pi + math.sin(x) if(x < 0): y = math.log(-5*x) + 6 * math.sqrt(abs(x) + math.exp(4)) - pow(x+1,3) print(y)双分支语句：
import math x = float(input("请输入x：")) if(x >= 0): y = (x*x - 3*x)/(x+1) + 2*math.pi + math.sin(x) else: y = math.log(-5*x) + 6 * math.sqrt(abs(x) + math.exp(4)) - pow(x+1,3) print(y)条件运算语句：
import math x = float(input("请输入x：")) y = ((x*x - 3*x)/(x+1) + 2*math.pi + math.sin(x)) if(x >= 0) \ else (math.log(-5*x) + 6 * math.sqrt(abs(x) + math.exp(4)) - pow(x+1,3)) print(y)运行一：
请输入x：666 668.2715406628656运行二：
请输入x：-666 294079794.174483312. 编写程序，输入一元二次方程的3个系数a、b、c，求ax2+bx+c=0方程的解
import math a = float(input("请输入系数a：")) b = float(input("请输入系数b：")) c = float(input("请输入系数c：")) delta = b*b -4*a*c if(a == 0): if(b == 0): print("无解") else: print("有一个实根：",-1*c/b) elif(delta == 0): print("有两个相等实根：x1 = x2 = ", (-1*b)/(2*a)) elif(delta > 0): print("有两个不等实根：x1 = {0}，x2 = {1}".format\ ((-1*b +math.sqrt(delta))/2*a,(-1*b -math.sqrt(delta))/2*a)) elif(delta < 0): print("有两个共轭复根：x1 = {0}，x2 = {1}".format\ (complex( (-1*b)/(2*a),math.sqrt(delta*-1)/(2*a)),complex( (-1*b)/(2*a),-1*math.sqrt(delta*-1)/(2*a))))运行一：
请输入系数a：0 请输入系数b：0 请输入系数c：10 无解运行二：
请输入系数a：0 请输入系数b：10 请输入系数c：5 有一个实根： -0.5运行三：
请输入系数a：1 请输入系数b：8 请输入系数c：16 有两个相等实根：x1 = x2 = -4.0运行四：
请输入系数a：1 请输入系数b：-5 请输入系数c：6 有两个不等实根：x1 = 3.0，x2 = 2.0运行五：
请输入系数a：5 请输入系数b：2 请输入系数c：1 有两个共轭复根：x1 = (-0.2+0.4j)，x2 = (-0.2-0.4j)13. 编写程序，输入整数n（n≥0）,分别利用for循环和while循环求n!
- for循环
n = int(input("请输入n：")) if(n == 0): total = 1 if(n > 0): total = 1 for i in range(n,0,-1): total *= i print(total)- while循环
n = int(input("请输入n：")) if(n == 0): total = 1 if(n > 0): total = 1 while(n >= 1): total *= n n -= 1 print(total)- 补充一个：使用累计迭代器itertools.accumulate
>>> import itertools, operator >>> n = int(input('请输入n：')) 请输入n：7 >>> x = list(accumulate(range(1, n+1), operator.mul)) >>> x[len(x)-1] 504014. 编写程序，产生两个0~100（包含0和100）的随机整数a和b，求这两个整数的最大公约数和最小公倍数
- 现有知识点解决方法
import random a = random.randint(0,100) b = random.randint(0,100) sum = a*b print(a) #输出原来的a，b print(b) if(a < b): a,b = b,a while(a%b != 0): a,b = b,a%b print("最大公约数：{0}，最小公倍数：{1}".format(b,sum/b))- 补充：使用生成器（generate）函数：yield
>>> def func(a, b): if(a < b): a,b = b,a while(a%b != 0): a,b = b,a%b yield b >>> import random >>> if __name__ == '__main__': a = random.randint(0,100) b = random.randint(0,100) sum = a*b print(a,b) t = list(iter(func(a, b))) gcd = t[len(t)-1] print("gcd = {0}, mcm = {1}".format(gcd, sum/gcd)) 29 65 gcd = 1, mcm = 1885.0- 补充：使用math模块中的
gcd(x,y)函数
>>> import random >>> import math >>> if __name__ == '__main__': a = random.randint(0,100) b = random.randint(0,100) sum = a*b print(a,b) gcd = math.gcd(a,b) print("gcd = {0}, mcm = {1}".format(gcd, sum/gcd)) 29 48 gcd = 1, mcm = 1392.0案例研究：使用嵌套循环实现图像处理算法
https://blog.csdn.net/Zhangguohao666/article/details/103935185
通过图像处理算法案例，深入了解Python数据结构和基本算法流程
第四章 常用内置数据类型
几个例题
一：Python内置数据类型概述
Python中一切皆为对象，而每个对象属于某个数据类型
Python的数据类型包括：
- 内置的数据类型
- 模块中定义的数据类型
- 用户自定义的类型
四种内置的数值类型：int，float，bool，complex
- int
与其他计算机语言有精度限制不同，Python中的整数位数可以为任意长度（只受限于计算机内存）。
整型对象是不可变对象。 - float
与其他计算机语言中的double和float对应
Python的浮点类型的精度和系统相关 - bool
- complex
当数值字符串中包含虚部j（或J）时即复数字面量
序列数据类型：str，tuple，bytes，list，bytearray
序列数据类型表示若干有序数据.
不可变序列数据类型：
- str（字符串）
表示Unicode字符序列，例如：“zgh666”
在Python中没有独立的字符数据类型，字符即长度为1的字符串 - tuple（元组）
表示任意数据类型的序列，例如：(“z”,“g”,“h”,6,6,6) - bytes（字节序列）
表示字节（8位）序列数据
可变序列数据类型：
- list（列表）
表示可以修改的任意类型数据的序列，比如：[‘z’,‘g’,‘h’,6,6,6] - bytearray（字节数组）
表示可以修改的字节（8位）数组
集合数据类型：set，frozenset
集合数据类型表示若干数据的集合，数据项目没有顺序，且不重复
- set（集）
例如：{1，2，3} - frozenset（不可变集）
字典数据类型：dict
字典数据类型用于表示键值对的字典
例如：{1:"zgh", 2:666}NoneType，NotImplementedType，EllipsisType
- NoneType数据类型包含唯一值None，主要用于表示空值，如没有返回值的函数的结果
- NotImplementedType数据类型包含唯一值NotImplemented，在进行数值运算和比较运算时，如果对象不支持，则可能返回该值
- EllipsisType数据类型包含唯一值Ellipsis，表示省略字符串符号
...
其他数据类型
Python中一切对象都有一个数据类型，模块、类、对象、函数都属于某种数据类型
Python解释器包含内置类型，
例如：
代码对象Code objects
框架对象Frame objects
跟踪对象Traceback objects
切片对象Slice objects
静态方法对象Static method objects
类方法对象Class method objects二：整型字面量示例
Python3.7支持使用下划线作为整数或者浮点数的千分位标记，以增强大数值的可阅读性。
二进制、八进制、十六进制则使用下划线区分4位标记1_000_000_000 #输出1000000000 0xff_ff_ff_ff #输出4294967295 0x_FF_FF_FF_FF #输出4294967295三：字符串字面量示例
两个紧邻的字符串，如果中间只有空格分隔，则自动拼接位一个字符串
'zgh' '666' #输出'zgh666' 'zgh' + "666" #输出'zgh666'四：转义字符示例
转义字符后跟Unicode编码也可以表示字符
\ooo八进制Unicode码对应的字符\xhh十六进制Unicode码对应的字符
'\101' #输出'A' '\x41' #输出'A'使用r’‘或者R’'的字符串称为原始字符串，其中包含的任何字符都不进行转义
s = r'换\t行\t符\n' s #输出：'换\\t行\\t符\\n' print(s) #输出：换\\t行\\t符\\n五：字符串的格式化
一：
"student number：{0}，score_average：{1}".format(2,100) #输出：'student number：2，score_average：100'二：
str.format("student number：{0}，score_average：{1}",2,100) #输出：'student number：2，score_average：100'三（兼容Python2的格式，不推荐使用）：
"student number：%4d，score_average：%2.1f" %(2,100) #输出：'student number： 2，score_average：100.0'六：字符串示例，格式化输出字符串堆积的三角形
str.center()方法用于字符串两边填充str.rjust()方法用于字符串右填充
print("1".center(20)) #一行20个字符，居中对齐 print(format("121","^20")) #一行20个字符，居中对齐 print("1".rjust(20,"*")) #一行20个字符，右对齐，加* print(format("121","*>20")) #一行20个字符，右对齐，加*运行：
1 121 *******************1 *****************121选择题：11
11. 关于Python字符串，下列说法错误的是
A. 字符即长度为1的字符串
B. 字符串以/0标识字符串的结束
C. 用户既可以用单引号，也可以用双引号创建字符串
D. 用三引号字符串中可以包含换行回车等特殊字符答案：B
Python中字符串不是用\0来判断字符串结尾，
每个字符串都存有字符串的长度，通过计数来判断是否到达结尾。虽然在c语言中\0就是来判断字符串的结尾;
填空题：4、7、8、9、10、13、21
4. Python表达式3 ** 2 ** 3的值为
答案：6561
表达式中，相同优先级的运算，从右往左
7. Python语句print(pow(-3,2),round(18.67,1),round(18.67,-1))的输出结果是
答案：9 18.7 20.0
pow()幂运算
round()四舍六入，五留双8. Python语句print(round(123.84,0),round(123.84,-2),floor(15.5))的输出结果是
答案：124.0 100.0 15
补充：floor()是math模块中的方法，向下取整
9. Python语句print(int(‘20’,16),int(‘101’,2))的输出结果是
答案：32 5
注意：int(x,y)是指将y进制的数值x转化为10进制数
10. Python语句print(hex(16),bin(10))的输出结果是
答案：0x10 0b1010
hex(x)将十进制数x转化为十六进制，以字符串形式输出
bin(x)将十进制数x转化为二进制，以字符串形式输出13. Python语句print(gcd(12,16),divmod(7,3))的输出结果是
答案：4 (2,1)
gcd()是math模块中的函数，求最大公约数
divmod()是内置函数，返回商和余数21. Python语句序列 x=True;y=False;z=False;print(x or y and z) 的运行结果是
答案：True
and优先级比or高
思考题：5
5. 阅读下面的Python程序，请问输出结果是什么？
from decimal import * ctx = getcontext() ctx.prec = 2 print(Decimal('1.78'))#1.78 print(Decimal('1.78') + 0)#1.8 ctx.rounding = ROUND_UP print(Decimal('1.65') + 0)#1.7 print(Decimal('1.62') + 0)#1.7 print(Decimal('-1.45') + 0)#-1.5 print(Decimal('-1.42') + 0)#-1.5 ctx.rounding = ROUND_HALF_UP print(Decimal('1.65') + 0)#1.7 print(Decimal('1.62') + 0)#1.6 print(Decimal('-1.45') + 0)#-1.5 ctx.rounding = ROUND_HALF_DOWN print(Decimal('1.65') + 0)#1.6 print(Decimal('-1.45') + 0)#-1.4上机实践：2~14
2. 编写程序，格式化输出杨辉三角
杨辉三角即二项式定理的系数表，各元素满足如下条件：第一列及对角线上的元素均为1；其余每个元素等于它上一行同一列元素与前一列元素之和
我使用了一个更加精妙的规律
比如第一行为1
第二行：01 + 10 = 11
第三行：011 + 110 = 121
第四行：0121 + 1210 = 1331
。。。def generate(numRows): l1 = [1] n = 0 while n < numRows: print(str(l1).center(66)) l1 = [sum(t) for t in zip([0] + l1, l1 + [0])] #利用zip函数算出每一行 如第二行 zip([0,1],[1,0])=[1,1],以此类推 n += 1 a=int(input("请输入行数")) generate(a)运行：
请输入行数4 [1] [1, 1] [1, 2, 1] [1, 3, 3, 1]3. 输入直角三角形的两个直角边，求三角形的周长和面积，以及两个锐角的度数。结果保留一位小数
import math a = float(input("请输入直角三角形的直角边a：")) b = float(input("请输入直角三角形的直角边b：")) c = math.sqrt(a*a+b*b) p = a + b + c area = 0.5*a*b print("三角形的周长：{0:1.1f}，面积：{1:1.1f}".format(p,area)) sina = a/c sinb = b/c a_degree = round(math.asin(sina) * 180 / math.pi,0) b_degree = round(math.asin(sinb) * 180 / math.pi,0) print("三角形直角边a的度数：{0}，b的度数：{1}".format(a_degree,b_degree))运行：
请输入直角三角形的直角边a：3 请输入直角三角形的直角边b：4 三角形的周长：12.0，面积：6.0 三角形直角边a的度数：37.0，b的度数：53.04. 编程产生0~100（包含0和100）的三个随机数a、b、c，要求至少使用两种不同的方法，将三个数按从小到大的顺序排序
方法一：
import random a = random.randint(0, 100) b = random.randint(0, 100) c = random.randint(0, 100) print(str.format("原始值：{0}，{1}，{2}", a, b, c)) if(a > b): a,b = b,a if(a > c): a,c = c,a if(b > c): b,c = c,b print(str.format("增序：{0}，{1}，{2}", a, b, c))方法二（使用内置函数max、min、sum）：
import random a = random.randint(0, 100) b = random.randint(0, 100) c = random.randint(0, 100) print(str.format("原始值：{0}，{1}，{2}", a, b, c)) maxx = max(a, b, c) minx = min(a, b, c) median = sum([a, b, c]) - minx - maxx print(str.format("增序：{0}，{1}，{2}", minx, median, maxx))方法三（使用内置函数sorted）：
>>> import random >>> a = random.randint(0,100) >>> b = random.randint(0,100) >>> c = random.randint(0,100) >>> print("init value: {0} , {1} , {2}".format(a,b,c)) init value: 17 , 6 , 59 >>> sorted([a,b,c]) [6, 17, 59]5. 编程计算有固定工资收入的党员每月所缴纳的党费。
工资基数3000元及以下者，交纳工资基数的0.5%
工资基数3000~5000元者，交纳工资基数的1%
工资基数在5000~10000元者，交纳工资基数的1.5%
工资基数超过10000元者，交纳工资基数的2%salary = float(input("请输入有固定工资收入的党员的月工资：")) if salary <= 3000: dues = salary*0.005 elif salary <= 5000: dues = salary*0.01 elif salary <= 10000: dues = salary*0.15 else: dues = salary*0.02 print("交纳党费：",dues)运行：
请输入有固定工资收入的党员的月工资：10001 交纳党费： 200.026. 编程实现袖珍计算器，要求输入两个操作数和一个操作符（+、-、*、/、%），根据操作符输出运算结果。注意/和%运算符的零异常问题
a = float(input("请输入操作数（左）：")) b = float(input("请输入操作数（右）：")) operator = input("请输入操作符（+、-、*、/、%）：") if(b == 0 and (operator == '/' or operator == '%')): print("分母为零，异常！") else: if operator == '+': result = a+b elif operator == '-': result = a-b elif operator == '*': result = a*b elif operator == '/': result = a/b elif operator == '%': result = a%b print("{0} {1} {2}= {3}：".format(a,operator,b,result))运行：
请输入操作数（左）：10 请输入操作数（右）：5 请输入操作符（+、-、*、/、%）：+ 10.0 + 5.0= 15.0：7. 输入三角形的3条边a、b、c，判断此3边是否可以构成三角形。若能，进一步判断三角形的性质，即为等边、等腰、直角或其他三角形
a = float(input("请输入三角形的边a：")) b = float(input("请输入三角形的边b：")) c = float(input("请输入三角形的边c：")) if(a > b): a,b = b,a if(a > c): a,c = c,a if(b > c): b,c = c,b result = "三角形" if(not(a>0 and b>0 and c>0 and a+b>c)): result = '此三边无法构成三角形' else: if a == b == c: result = '等边三角形' elif(a==b or a==c or b==c): result = '等腰三角形' elif(a*a+b*b == c*c): result = '直角三角形' print(result)运行：
请输入三角形的边a：3 请输入三角形的边b：4 请输入三角形的边c：5 直角三角形8. 编程实现鸡兔同笼问题
已知在同一个笼子里共有h只鸡和兔，鸡和兔的总脚数为f，其中h和f由用户输入，求鸡和兔各有多少只？要求使用两种方法：一是求解方程；二是利用循环进行枚举测试
h = int(input("请输入总头数：")) f = int(input("请输入总脚数：")) def fun1(h,f): rabbits = f/2-h chicken = h-rabbits if(chicken < 0 or rabbits < 0): return '无解' return chicken,rabbits def fun2(h,f): for i in range(0,h+1): if(2*i + 4*(h-i) == f):return i,h-i return '无解' if(h>0 and f>0 and f % 2 == 0): if fun1(h,f)=='无解': print("无解") else: print("方法一：鸡：{0}，兔：{1}".format(fun1(h,f)[0],fun1(h,f)[1])) print("方法二：鸡：{0}，兔：{1}".format(fun2(h,f)[0],fun2(h,f)[1])) else: print('输入的数据无意义')运行：
请输入总头数：100 请输入总脚数：100 无解9. 输入任意实数x，计算ex的近似值，直到最后一项的绝对值小于10-6为止
ex = 1 + x + x2/2 + x3/3! + x4/4! + … + xn/n!
x = int(input("请输入任意实数：")) e = 1 i = 1 t = 1 a = 1 while(a >= 10e-6): t *= i a = pow(x,i)/t e += a i += 1 print(e)运行：
请输入任意实数：1 2.7182815255731922我发现了在Python中
10e-6和pow(10,-6)是有差别的，将上述代码中的10e-6改为pow(10,-6)，输出结果会有细微的差别运行：
请输入任意实数：1 2.718281801146384510. 输入任意实数a（a>=0），用迭代法求x=√a，要求计算的相对偏差小于10-6
求平方根的公式：
Xn+1 = 0.5(Xn + a/Xn)
import math a = int(input("请输入任意实数a(>=0)：")) x = a / 2 y = (x + a/x) / 2 while(abs(y-x) >= pow(10,-6)): x = y y = (x + a/x) / 2 print(y)运行：
请输入任意实数a(>=0)：2 1.41421356237309511. 即有一个数，用3除余2，用5除余3，用7除余2，请问0~1000中这样的数有哪些？
我国古代有位大将，名叫韩信。他每次集合部队，只要求部下先后按1-3，1-5，1-7报数，然后再报告一下各队每次报数的余数，他就知道到了多少人。他的这种巧妙算法被人们称作“鬼谷算”，也叫“隔墙算”，或称为“韩信点兵”，外国人还称它为“中国余数定理”。
for i in range(0,1001): if((i % 3 == 2 )and (i % 5 == 3) and (i % 7 == 2)): print(i, end=" ")运行：
23 128 233 338 443 548 653 758 863 96812. 一球从100米的高度自由下落，每次落地后反弹回原高度的一半，再落下。求小球在第10次落地时共经过多少米?第10次反弹多高
规律：
第一次下落时的高度：100
第二次下落时的高度（第一次反弹的高度）：50
第三次下落时的高度（第二次反弹的高度）：25
…n = 10 h_down = 100 h_up = 0 sum = 0 for i in range(1,n+1): sum += h_down+h_up h_down = h_up = h_down/2 print("小球在第十次落地时共经过：{0}米，第十次反弹高度：{1}米".format(sum,h_up))运行：
小球在第十次落地时共经过：299.609375米，第十次反弹高度：0.09765625米13. 猴子吃桃问题
猴子第一天摘下若干个桃子，当天吃掉一半多一个；第二天接着吃了剩下的桃子的一半多一个；以后每天都吃了前一天剩下的桃子的一半多一个。到第八天发现只剩一个桃子了。请问猴子第一天共摘了多少个桃子？
这是一个递推问题
某天所剩桃子数x
后一天所剩桃子数y = x - (x/2+1) = x/2-1则x = 2(y+1)
result = 1 for i in range(8,0,-1): print("第{0}天桃子数：{1}".format(i,result)) result = 2*(result+1)运行：
第8天桃子数：1 第7天桃子数：4 第6天桃子数：10 第5天桃子数：22 第4天桃子数：46 第3天桃子数：94 第2天桃子数：190 第1天桃子数：38214. 计算Sn = 1+11+111+…+111…111（最后一项是n个1）。n是一个随机产生的1~10（包括1和10）中的正整数
import random n = random.randint(1,10) x = 1 s = 0 for i in range(1,n+1): s += x x = 10*x+1 print("n = {0}，sn = {1}".format(n,s))运行：
n = 6，sn = 123456random.randint(a, b)
- 生成指定范围内的整数
- 范围：[a, b]
案例研究：科学计算和数据分析
https://blog.csdn.net/Zhangguohao666/article/details/103941448
通过Python科学计算和数据分析库的安装和基本使用，了解使用Python进行科学计算的基本方法
第五章 序列数据类型
几个例题
一：Python中内置的序列数据类型
- 元组也称为定值表，用于存储固定不变的表
- 列表也称为表，用于存储其值可变的表
- 字符串是包括若干字符的序列数据，支持序列数据的基本操作
- 字节序列数据是包括若干字节的序列。Python抓取网页时返回的页面通常为utf-8编码的字节序列。
字节序列和字符串可以直接相互转换（字节编码和解码）：
>>> s1 = b'abc' >>> s1 b'abc' >>> s1.decode("utf-8") abc >>> s2 = "中国" >>> s2.encode("utf-8") b'\xe4\xb8\xad\xe5\x9b\xbd'二：序列的切片操作示例
>>> s = 'zgh666' >>> s[0] 'z' >>> s[2] 'h' >>> s[:3] 'zgh' >>> s[1:3] 'gh' >>> s[3:6] '666' >>> s[3:55] '666' >>> s[::-1] '666hgz' >>> s[3:2] '' >>> s[:] 'zgh666' >>> s[::2] 'zh6'三：序列的连接和重复操作
- 通过连接操作符
+可以连接两个序列，形成一个新的序列对象 - 通过重复操作符
*可以重复一个序列n次 - 连接操作符和重复操作符也支持复合赋值运算，即：
+=，*=
>>> x = 'zgh' >>> y = '666' >>> x + y 'zgh666' >>> x *2 'zghzgh' >>> x += y >>> x 'zgh666' >>> y *= 3 >>> y '666666666'四：序列的成员关系操作
- in
- not in
- s.count(x)
x在s中出现的次数 - s.index(x)
x在s中第一次出现的下标
>>> s = "zgh666" >>> 'z' in s True >>> 'g' not in s False >>> s.count('6') 3 >>> s.index('6') 3五：序列的排序操作
sorted(iterable,key=None,reverse=False)
>>> sorted(s) [1, 3, 5, 9] >>> sorted(s,reverse=True) [9, 5, 3, 1] >>> s = 'zGhZgH' >>> sorted(s) ['G', 'H', 'Z', 'g', 'h', 'z'] >>> sorted(s,key=str.lower) ['G', 'g', 'h', 'H', 'z', 'Z'] >>> sorted(s,key=str.lower,reverse=True) ['z', 'Z', 'h', 'H', 'G', 'g']六：序列的拆分
- 变量个数与序列长度相等
若变量个数与序列的元素个数不一致，将导致ValueError
>>> data = (118,'zgh',(100,100,100)) >>> sid,name,(chinese,english,math) = data >>> sid 118 >>> name 'zgh' >>> chinese 100 >>> english 100 >>> math 100- 变量个数与序列长度不等
如果序列长度未知，可以使用*元组变量，将多个值作为元组赋值给元组变量。在一个赋值语句中，*元组变量只允许出现一次，否则将导致SyntaxError
>>> first,second,third,*middles,last = range(10) >>> first 0 >>> second 1 >>> third 2 >>> middles [3, 4, 5, 6, 7, 8] >>> last 9 >>> first,*middles,last = sorted([58,60,60,100,70,70]) >>> sum(middles)/len(middles) 65.0- 使用临时变量
_
如果只需要部分数据，序列的其它位置可以使用临时变量_
>>> record = ['zgh','858990471@qq.com','17354364147','15272502101'] >>> name,_,*phone = record >>> name 'zgh' >>> phone ['17354364147', '15272502101']七：使用元组字面量，tuple创建元组实例对象的实例
>>> t1 = 1,2,3 >>> t1 (1, 2, 3) >>> t2 = (4,5,6) >>> t2 (4, 5, 6) >>> t3 = (9,) >>> t3 (9,)如果元组中只有一个项目，后面的逗号不能省略。
Python解释器把(1)解释为整数1，将(1,)解释为元组
>>> t1 = tuple() >>> t1 () >>> t2 = tuple("zgh666") >>> t2 ('z', 'g', 'h', '6', '6', '6') >>> t3 = tuple(['z','g','h']) >>> t3 ('z', 'g', 'h')八：使用列表字面量，list创建列表实例对象的实例
>>> l1 = [] >>> l1 [] >>> l2 = ['zgh666'] >>> l2 ['zgh666'] >>> l3 = [(1,2,3)] >>> l3 [(1, 2, 3)]>>> l1 = list() >>> l1 [] >>> l2 = list(b'zgh666') >>> l2 [122, 103, 104, 54, 54, 54] >>> l3 = list(b'aAbBcC') >>> l3 [97, 65, 98, 66, 99, 67]补充：列表是可变对象，故用户可以改变列表对象中元素的值，也可以通过
del删除某元素九：列表解析表达式示例
使用列表解析表达式可以简单，高效地处理一个可迭代对象，并生成结果列表
>>> [(i,i**2) for i in range(10)] [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49), (8, 64), (9, 81)] >>> [i for i in range(10) if i%2==0] [0, 2, 4, 6, 8] >>> [(x,y,x*y) for x in range(1,4) for y in range(1,4) if x>=y] [(1, 1, 1), (2, 1, 2), (2, 2, 4), (3, 1, 3), (3, 2, 6), (3, 3, 9)]选择题：4、5、7、11、12
4. Python语句序列“a = (1,2,3,None,(),[]);print(len(a))”的运行结果是
>>> a = (1,2,3,None,(),[]) >>> len(a) 65. Python语句序列“nums = set([1,2,2,3,3,3,4]);print(len(nums))”的运行结果是
>>> nums = set([1,2,2,3,3,3,4]) >>> nums {1, 2, 3, 4} >>> len(nums) 47. Python语句序列“s1=[4,5,6];s2=s1;s1[1]=0;print(s2)”的运行结果是
Python中变量（如s1，s2）存储在栈中，存放的是地址
[4,5,6]存储在堆中s1 = [4,5,6]即s1存储指向堆中[4,5,6]的地址
s2 = s1地址赋值，即s2和s1都指向同一个地址
所以对列表进行修改，两者的显示都会发生变化>>> s1 = [4,5,6] >>> s2 = s1 >>> s1[1] = 0 >>> s1 [4, 0, 6] >>> s2 [4, 0, 6]11. Python语句序列“s={‘a’,1,‘b’,2};print(s[‘b’])”的运行结果是
A. 语法错 B. ‘b’ C. 1 D. 2 答案：A
通过值访问集合是没有意义的，语法也不支持
>>> s ={'a',1,'b',2} >>> print(s['b']) Traceback (most recent call last): File "<pyshell#29>", line 1, in <module> print(s['b']) TypeError: 'set' object is not subscriptable补充：集合set是无序不重复的，是无法通过下标访问的
12. Python语句print(r"\nGood")的运行结果是
A. 新行和字符串Good B. r"\nGood" C. \nGood D. 字符r、新行和字符串Good 答案：C
>>> print(r"\nGood") \nGoodr""声明原始字符串填空题：1、5、6、12、13、14
1. Python语句序列“fruits = [‘apple’,‘banana’,‘bear’];print(fruits[-1][-1])”的运行结果是
注意：
fruit[-1]是字符串’bear’
所以：fruit[-1][-1]即'bear[-1]'>>> fruits = ['apple','banana','pear'] >>> fruits[-1] 'pear' >>> fruits[-1][-1] 'r'5. Python语句 print(’%d%%%d’%(3/2,3%2)) 的运行结果是
>>> print('%d%%%d'%(3/2,3%2)) 1%16. Python语句序列“s = [1,2,3,4];s.append([5,6]);print(len(s))”的运行结果是
答案：5
注意append()和extend()函数的区别
s.append(x)将对象x追加到s尾部
s.extend(x)将序列x追加到s尾部append
>>> s = [1,2,3,4] >>> s.append([5,6]) >>> s [1, 2, 3, 4, [5, 6]] >>> len(s) 5extend
>>> s = [1,2,3,4] >>> s.extend([5,6]) >>> s [1, 2, 3, 4, 5, 6] >>> len(s) 612
>>> s =('a','b','c','d','e') >>> s[2] 'c' >>> s[2:3] ('c',) >>> s[2:4] ('c', 'd') >>> s[1::2] ('b', 'd') >>> s[-2] 'd' >>> s[::-1] ('e', 'd', 'c', 'b', 'a') >>> s[-2:-1] ('d',) >>> s[-99:-5] () >>> s[-99:-3] ('a', 'b') >>> s[::] ('a', 'b', 'c', 'd', 'e') >>> s[1:-1] ('b', 'c', 'd')13
>>> s = [1,2,3,4,5,6] >>> s[:1] = [] >>> s [2, 3, 4, 5, 6] >>> s[:2] = 'a' >>> s ['a', 4, 5, 6] >>> s[2:] = 'b' >>> s ['a', 4, 'b'] >>> s[2:3] = ['x','y'] >>> s ['a', 4, 'x', 'y'] >>> del s[:1] >>> s [4, 'x', 'y']14
>>> s = ['a','b'] >>> s.append([1,2]) >>> s ['a', 'b', [1, 2]] >>> s.extend('34') >>> s ['a', 'b', [1, 2], '3', '4'] >>> s.extend([5,6]) >>> s ['a', 'b', [1, 2], '3', '4', 5, 6] >>> s.insert(1,7) >>> s ['a', 7, 'b', [1, 2], '3', '4', 5, 6] >>> s.insert(10,8) >>> s ['a', 7, 'b', [1, 2], '3', '4', 5, 6, 8] >>> s ['a', 7, 'b', [1, 2], '3', '4', 5, 6] >>> s.remove('b') >>> s ['a', 7, [1, 2], '3', '4', 5, 6] >>> s[3:] =[] >>> s ['a', 7, [1, 2]] >>> s.reverse() >>> s [[1, 2], 7, 'a'] >>>思考题：2、3、5
2. 阅读下面的Python语句，请问输出结果是什么？
n = int(input('请输入图形的行数：')) for i in range(n,0,-1): print(" ".rjust(20-i),end=' ') for j in range(2*i-1):print(" * ",end=' ') print('\n') for i in range(1,n): print(" ".rjust(19-i),end=' ') for j in range(2*i+1):print(" * ",end=' ') print('\n')运行一：
请输入图形的行数：1 *运行二：
请输入图形的行数：2 * * * * * * *运行三：
请输入图形的行数：3 * * * * * * * * * * * * * * * * *3. 阅读下面的Python语句，请问输出结果是什么？
n = int(input('请输入上（或下）三角行数：')) for i in range(0,n): print(" ".rjust(19-i),end=' ') for j in range(2*i+1):print(" * ",end=' ') print('\n') for i in range(n-1,0,-1): print(" ".rjust(20-i),end=' ') for j in range(2*i-1):print(" * ",end=' ') print('\n')运行：
请输入上（或下）三角行数：4 * * * * * * * * * * * * * * * * * * * * * * * * *5. 阅读下面的Python语句，请问输出结果是什么？
先看这三句：
>>> names1 = ['Amy','Bob','Charlie','Daling'] >>> names2 = names1 >>> names3 = names1[:]毫无疑问，此时names1,names2,names3的值都是[‘Amy’,‘Bob’,‘Charlie’,‘Daling’]
但是>>> id(names1) 2338529391368 >>> id(names2) 2338529391368 >>> id(names3) 2338529391560names1和names2指向同一个地址
而names3指向另一个地址然后：
>>> names2[0] = 'Alice' >>> names3[1] = 'Ben' >>> names1 ['Alice', 'Bob', 'Charlie', 'Daling'] >>> names2 ['Alice', 'Bob', 'Charlie', 'Daling'] >>> names3 ['Amy', 'Ben', 'Charlie', 'Daling']最后：
>>> sum = 0 >>> for ls in(names1,names2,names3): if ls[0] == 'Alice': sum+=1 if ls[1] == 'Ben':sum+=2 >>> print(sum) 4上机实践：2~6
2. 统计所输入字符串中单词的个数，单词之间用空格分隔
s = input("请输入字符串：") num = 0 for i in s: if((i >= 'a' and i <= 'z') or (i >= 'A' and i <= 'Z')): num += 1 print("其中的单词总数：",num)运行：
请输入字符串：zgh666 ZGH6 其中的单词总数： 63. 编写程序，删除一个list里面重复元素
方法一：利用set集合不重复的性质（但结果不能保证原来的顺序）
l = [1,2,2,3,3,3,4,5,6,6,6] s = set(l) l = list(s) print(l)运行：
[1, 2, 3, 4, 5, 6]方法二：既可以去除重复项，又可以保证原来的顺序
def unique(items): items_existed = set() for item in items: if item not in items_existed: yield item items_existed.add(item) if __name__ == '__main__': a = [1, 8, 5, 1, 9, 2, 1, 10] a1 = unique(a) print(list(a1))运行结果：
[1, 8, 5, 9, 2, 10]对代码的分析：
- 可以看出，
unique()函数返回的并不是items_existed，而是利用了yield
在函数定义中，如果使用yield语句代替return返回一个值，则定义了一个生成器函数（generator）
生成器函数是一个迭代器，是可迭代对象，支持迭代a1 = unique(a)这个函数返回的实际上是一个可迭代对象
若print(a1)得到的会是：<generator object unique at 0x0000016E23AF4F48>- 所以，要得到去掉重复后的列表的样子，需要将可迭代对象a1放在
list()中
运行：
4. 编写程序，求列表[9,7,8,3,2,1,55,6]中的元素个数、最大值、最小值，以及元素之和、平均值。请思考有几种实现方法？
内置函数：
s = [9,7,8,3,2,1,55,6] print("元素个数：{0}，最大值：{1}，最小值：{2}，和：{3}，平均值：{4}".\ format(len(s),max(s),min(s),sum(s),sum(s)/len(s)))直接访问元素列表（for i in s…）：
s = [9,7,8,3,2,1,55,6] sum = 0 max = s[0] min = s[0] length = 0 for i in s: sum += i length += 1 if(i > max): max = i if(i < min): min = i print("元素个数：{0}，最大值：{1}，最小值：{2}，和：{3}，平均值：{4}".\ format(length,max,min,sum,sum/length))间接访问列表元素（for i in range(0,len(s))…）：
s = [9,7,8,3,2,1,55,6] sum = 0 max = s[0] min = s[0] length = len(s) for i in range(0,length): sum += s[i] if(s[i] > max): max = s[i] if(s[i] < min): min = s[i] print("元素个数：{0}，最大值：{1}，最小值：{2}，和：{3}，平均值：{4}".\ format(length,max,min,sum,sum/length))正序访问（i=0;while i<len(s)…）：
s = [9,7,8,3,2,1,55,6] sum = 0 max = s[0] min = s[0] length = len(s) i = 0 while(i < length): sum += s[i] if(s[i] > max): max = s[i] if(s[i] < min): min = s[i] i += 1 print("元素个数：{0}，最大值：{1}，最小值：{2}，和：{3}，平均值：{4}".\ format(length,max,min,sum,sum/length))反序访问（i=len(s)-1;while i>=0…）：
s = [9,7,8,3,2,1,55,6] sum = 0 max = s[0] min = s[0] length = len(s) i = length-1 while(i >= 0): sum += s[i] if(s[i] > max): max = s[i] if(s[i] < min): min = s[i] i -= 1 print("元素个数：{0}，最大值：{1}，最小值：{2}，和：{3}，平均值：{4}".\ format(length,max,min,sum,sum/length))while True：…break
s = [9,7,8,3,2,1,55,6] sum = 0 max = s[0] min = s[0] length = len(s) i = 0 while(True): if(i > length-1): break sum += s[i] if(s[i] > max): max = s[i] if(s[i] < min): min = s[i] i += 1 print("元素个数：{0}，最大值：{1}，最小值：{2}，和：{3}，平均值：{4}".\ format(length,max,min,sum,sum/length))运行：
元素个数：8，最大值：55，最小值：1，和：91，平均值：11.3755. 编写程序，将列表[9,7,8,3,2,1,5,6]中的偶数变成它的平方，奇数保持不变
l = [9,7,8,3,2,1,5,6] for i,value in enumerate(l): if(value % 2 == 0):l[i] = value**2 print(l)运行：
[9, 7, 64, 3, 4, 1, 5, 36]6. 编写程序，输入字符串，将其每个字符的ASCII码形成列表并输出
s = input("请输入一个字符串：") l = list() for i in s: l.append(ord(i)) print(l)运行：
请输入一个字符串：zgh666 [122, 103, 104, 54, 54, 54]案例研究：猜单词游戏
https://blog.csdn.net/Zhangguohao666/article/details/103948234
通过猜单词游戏的设计和实现，帮助读者了解使用Python系列数据类型和控制流程
第六章 输入和输出
几个例题
一：运行时提示输入密码
输入密码时，一般需要不明显，则可以使用模块getpass，以保证用户输入的密码在控制台中不回显
import getpass username = input("user:") password = getpass.getpass("password:") if(username == 'zgh' and password == '666'): print('logined!') else: print('failed!') input()#为了看到输出结果。因为执行完毕后，控制台会立马关闭注意：上面这个代码，如果使用IDLE执行，会因为安全问题而执行失败
但是，在控制台中执行就没问题，看输出结果（可以看到，输入的密码不会显示出来）：
user:zgh password: logined!二：重定向标准输出到一个文件的示例
这种重定向由控制台完成，而与Python本身无关。
格式：
程序 > 输出文件其目的是将显示屏从标准输出中分离，并将输出文件与标准输出关联，即程序的执行结果将写入输出文件，而不是发送到显示屏中显示
首先准备一个test.py文件（代码如下）
import sys,random n = int(sys.argv[1]) for i in range(n): print(random.randrange(0,100))然后在PowerShell中：
python test.py 100 > scores.txt
记住，切记，一定要注意：千万能省略python，这样写./test.py 100 > scores.txt会出现问题，生成的scores文件中会没有任何内容！！！（原因未知）然后在当前目录下，100个[0,100)范围内的的整数生成在scores.txt文件中了
三：重定向文件到标准输入
格式：
程序 < 输入文件其目的是将控制台键盘从标准输入中分离，并将输入文件与标准输入关联，即程序从输入文件中读取输入数据，而不是从键盘中读取输入数据
准备一个average.py文件（代码如下）
import sys total =0.0 count = 0 for line in sys.stdin: count += 1 total += float(line) avg = total/count print("average:",avg)然后问题总是不期而至，
在PowerShell中：python average.py < scores.txt，会报错，PowerShell会提示你：“<”运算符是为将来使用而保留的。
很无奈，我只能使用cmd了，然后得出结果四：管道
格式：
程序1 | 程序2 | 程序3 | … | 程序4其目的是将程序1的标准输出连接到程序2的标准输入，
将程序2的标准输出连接到程序3的标准输入，以此类推例如：
打开cmd，输入python test.py 100 | average.py，其执行结果等同于上面两个例子中的命令使用管道更加简洁，且不用创建中间文件，从而消除了输入流和输出流可以处理的数据大小的限制，执行效率更高
五：过滤器
-
使用操作系统实用程序more逐屏显示数据
-
使用操作系统实用程序sort排序输出数据
more和sort都可以在一个语句中使用
填空题：1、2
print(value, ..., sep = ' ', end = '\n', file = sys.stdout, flush = False)- sep（分隔符，默认为空格）
- end（换行符，即输入的末尾是个啥）
- file（写入到指定文件流，默认为控制台sys.stdout）
- flush（指定是否强制写入到流）
1
>>> print(1,2,3,4,5,sep='-',end='!') 1-2-3-4-5!2
>>> for i in range(10): print(i,end=' ') 0 1 2 3 4 5 6 7 8 9例题及上机实践：2~5
2. 尝试修改例6.2编写的命令行参数解析的程序，解析命令行参数所输入边长的值，计算并输出正方形的周长和面积
argparse模块用于解析命名的命令行参数，生成帮助信息的Python标准模块
例6.2：解析命令行参数所输入的长和宽的值，计算并输出长方形的面积
import argparse parser = argparse.ArgumentParser() parser.add_argument('--length', default = 10, type = int, help = '长度') parser.add_argument('--width', default = 5, type = int, help = '宽度') args = parser.parse_args() area = args.length * args.width print('面积 = ', area) input()#加这一句是为了可以看到输出结果
输出：面积 = 50
如果在执行这个模块时，加入两个命令行参数
输出：面积 = 36
基本上看了上面这个例子后，就可以理解argparse的用法了
本题代码：
import argparse parser = argparse.ArgumentParser() parser.add_argument('--length', default = 10, type = int, help = '长度') args = parser.parse_args() area = args.length ** 2 perimeter = 4 * args.length print('面积 = {0}，周长 = {1}'.format(area,perimeter)) input()#加这一句是为了可以看到输出结果在PowerShell中输入
.\test.py
不给命令行参数，输出是以默认值来计算的
输出：面积 = 100，周长 = 40给命令行参数：
.\test.py --length 1
输出：面积 = 1，周长 = 43. 尝试修改例6.8编写读取并输出文本文件的程序，由命令行第一个参数确认所需输出的文本文件名
f = open(file, mode = 'r' , buffering = -1, encoding = None)- file是要打开或创建的文件名，如果文件不在当前路径，需指出具体路径
- mode是打开文件的模式，模式有：
‘r’（只读）
‘w’（写入，写入前删除就内容）
‘x’（创建新文件，如果文件存在，则导致FileExistsError）
‘a’（追加）
‘b’（二进制文件）
‘t’（文本文件，默认值）
‘+’（更新，读写） - buffering表示是否使用缓存（缓存为-1，表示使用系统默认的缓冲区大小）
- encoding是文件的编码
例6.8：读取并输出文本文件
import sys filename = sys.argv[0]#就读取本文件，骚的呀皮 f = open(filename, 'r', encoding = 'utf-8') line_no = 0 while True: line_no += 1 line = f.readline() if line: print(line_no, ":", line) else: break f.close()输出（代码输出的就是本python文件）：
1 : import sys 2 : 3 : filename = sys.argv[0]#就读取本文件，骚的呀皮 4 : f = open(filename, 'r', encoding = 'utf-8') 5 : 6 : line_no = 0 7 : while True: 8 : line_no += 1 9 : line = f.readline() 10 : if line: 11 : print(line_no, ":", line) 12 : else: 13 : break 14 : f.close() 15 :本题代码：
对例题代码进行些许修改就可以了，首先将上例中的第二个语句改为：
filename = sys.argv[0]，再考虑下面怎么进行准备一个用来测试的文件test.txt：
对于这个文件要注意一点（你们很可能回出现这个问题！！！），win10默认创建的文本文件的字符编码是ANSI
代码怎么写，有两种：
- 将test.txt文本文件的编码修改为utf-8，代码如上所说
记事本方式打开test.txt文件，点击文件，点击另存为，看到下方的编码（修改为utf-8） - test.txt就用默认的ANSI编码方式，再将上例代码的第三个语句修改为
f = open(filename, 'r', encoding = 'ANSI')
在PowerShell中输入：
./test.py test.txt
输出：1 : 大家好 2 : 我是Zhangguohao666 3 : 如果本文章对大家有帮助，请点赞支持一下 4 : 还有： 5 : 如果发现了什么问题，请在评论区指出，我会积极改进4. 尝试修改例6.9编写利用with语句读取并输出文本文件的程序，由命令行第一个参数确认所需输出的文本文件名
为了简化操作，Python语言中与资源相关的对象可以实现上下文管理协议，可以使用with语句，确保释放资源。
with open(file,mode) as f:例6.9：利用with语句读取并输出文本文件
import sys filename = sys.argv[0] line_no = 0 with open(filename, 'r', encoding = 'utf-8') as f: for line in f: line_no += 1 print(line_no, ":", line) f.close()基本上，看这个例子，就可以上手with语句了
本题代码：
还是上一题准备的文本文件，
代码一（文本文件的编码为默认的ANSI）：import sys filename = sys.argv[1] line_no = 0 with open(filename, 'r', encoding = 'ANSI') as f: for line in f: line_no += 1 print(line_no, ":", line) f.close()代码二（将文本文件的编码修改为utf-8）：
import sys filename = sys.argv[1] line_no = 0 with open(filename, 'r', encoding = 'utf-8') as f: for line in f: line_no += 1 print(line_no, ":", line) f.close()本题的输出，我再不要脸的放一次吧：
1 : 大家好 2 : 我是Zhangguohao666 3 : 如果本文章对大家有帮助，请点赞支持一下 4 : 还有： 5 : 如果发现了什么问题，请在评论区指出，我会积极改进5. 尝试修改例6.12编写标准输出流重定向的程序，从命令行第一个参数中获取n的值，然后将0-n，0-n的2倍值，2的0-n次幂的列表打印输出到out.log文件中
例6.12：从命令行第一个参数中获取n的值，然后将0-n，2的0-n次幂的列表打印输出到out.log文件中
- 标准输入流文件对象：sys.stdin，
默认值为sys.__stdin__ - 标准输出流文件对象：sys.stdout，
默认值为sys.__stdout__ - 错误输出流文件对象（标准错误流文件对象）：sys.stderr
默认值为sys.__stderr__
书中给的代码是这样的：
import sys n = int(sys.argv[1]) power = 1 i = 0 f = open('out.log', 'w') sys.stdout = f while i <= n: print(str(i), ' ', str(power)) power = 2*power i += 1 sys.stdout = sys.__stdout__如果使用的编辑器是PyCharm（现在大多数编辑器会帮你对代码进行优化和处理一些隐患），运行书中的这个代码没有问题。
但是：
若使用的编辑器是python自带的IDLE，运行这个代码有问题！第一：out.log文件会生成，但是没有东西
（发现文件关闭不了（就是×不掉），
确定是文件没关闭（f.close()）的原因）第二：控制台没有输出’done’语句（估计是IDLE编辑器处理不了
__stdout__这个值）经过研究后，发现（基于IDLE编辑器）：
如果在上面的代码中加入f.close()后，该输入的东西都成功输入进out.log文件了，
但是，
还有一个问题
控制台依旧没有输出’done’语句
经过一步步的断点调试（就是手动写print）
发现sys.stdout = sys.__stdout__不会执行然后进行改动后，就可以了，代码如下：
（既然__stdout__不好使，就使用中间变量）import sys n = int(sys.argv[1]) power = 1 i = 0 output = sys.stdout f = open('out.log', 'w') sys.stdout = f while i <= n: print(str(i), ' ', str(power)) power = 2*power i += 1 f.close() sys.stdout = output print('done!')#这一句是用来检测上面的代码是否成功执行问题虽然解决，但是原因没有彻底弄清楚，求助。。。。。。
本题代码：
import sys n = int(sys.argv[1]) power = 1 i = 0 output = sys.stdout f = open('out.log', 'w') sys.stdout = f while i <= n: print(str(i), ' ', str(2*i), ' ', str(power)) power = 2*power i += 1 f.close() sys.stdout = output print('done!')#这一句是用来检测上面的代码是否成功执行比如时输入的命令行参数是6
输出：
案例研究：21点扑克牌游戏
https://blog.csdn.net/Zhangguohao666/article/details/103948545
通过21点扑克牌游戏的设计和实现，了解使用Python数据类型、控制流程和输入输出
第七章 错误和异常处理
Python语言采用结构化的异常处理机制捕获和处理异常
而我感觉，Python在这方面的知识点其实和Java的差不多
几个例题
一：程序的错误和异常处理
- 语法错误
指源代码中的拼写错误，这些错误导致Python编译器无法把Python源代码转换为字节码，故也称之为编译错误
- 运行时错误
在解释执行过程中产生的错误
例如：
- 程序中没有导入相关的模块，NameError
- 程序中包括零除运算，ZeroDivisionError
- 程序中试图打开不存在的文件，FileNotFoundError
- 逻辑错误
程序可以执行（程序运行本身不报错），但执行结果不正确。
对于逻辑错误，Python解释器无能为力，需要用户根据结果来调试判断大部分由程序错误而产生的错误和异常一般由Python虚拟机自动抛出。另外，在程序中如果判断某种错误情况，可以创建相应的异常类的对象，并通过raise语句抛出
>>> a = -1 >>> if(a < 0): raise ValueError("数值不能为负数") Traceback (most recent call last): File "<pyshell#9>", line 1, in <module> if(a < 0): raise ValueError("数值不能为负数") ValueError: 数值不能为负数 >>>在程序中的某个方法抛出异常后，Python虚拟机通过调用堆栈查找相应的异常捕获程序。如果找到匹配的异常捕获程序（即调用堆栈中的某函数使用try…except语句捕获处理），则执行相应的处理程序（try…except语句中匹配的except语句块）
如果堆栈中没有匹配的异常捕获程序，则Python虚拟机捕获处理异常，在控制台打印出异常的错误信息和调用堆栈，并中止程序的执行
二：try …except…else…finally
try: 可能产生异常的语句 except Exception1: 发生Exception1时执行的语句 except (Exception2,Exception3): 发生Exception2或Exception3时执行的语句 except Exception4 as e: 发生Exception4时执行的语句，Exception4的实例是e except: 捕获其他所有异常 else: 无异常时执行的语句 finally: 不管异常发生与否都保证执行的语句except语句可以写多个，但是要注意一点：系统是自上而下匹配发生的异常，所以用户需要将带有最具体的（即派生类程度最高的）异常类的except写在前面
三：创建自定义异常，处理应用程序中出现的负数参数的异常
自定义异常类一般继承于Exception或其子类。自定义异常类的名称一般以Error或Exception为后缀
>>> class NumberError(Exception): def __init__(self,data): Exception.__init__ (self,data) self.data = data def __str__(self): return self.data + '：非法数值（<0）' >>> >>> def total(data): total = 0 for i in data: if i < 0: raise NumberError(str(i)) total += 1 return total >>> >>> data1 = (44, 78, 90, 80, 55) >>> print("sum: ",total(data1)) sum: 5 >>> >>> data2 = (44, 78, 90, 80, -1) >>> print("sum: ",total(data2)) Traceback (most recent call last): File "<pyshell#24>", line 1, in <module> print("sum: ",total(data2)) File "<pyshell#18>", line 4, in total if i < 0: raise NumberError(str(i)) NumberError: -1：非法数值（<0） >>>四：断言处理
用户在编写程序时，在调试阶段往往需要判断代码执行过程中变量的值等信息：
- 用户可以使用print()函数打印输出结果
- 也可以通过断点跟踪调试查看变量
- 但使用断言更加灵活
assert语句和AssertionError
断言的声明：
assert <布尔表达式>
即：if __debug__: if not testexpression: raise AssertionErrorassert <布尔表达式>,<字符串表达式>
即：if __debug__: if not testexpression: raise AssertionError(data)
字符串表达式（即data）是断言失败时输出的失败消息
__debug__也是布尔值，Python解释器有两种：调试模式和优化模式- 调试模式：
__debug__ == True - 优化模式：
__debug__ == False
在学习中，对于执行一个py模块（比如test.py）我们通常在cmd中这么输入
python test.py，而这默认是调试模式。
如果我们要使用优化模式来禁用断言来提高程序效率，我们可以加一个运行选项-O，在控制台中这么输入python -O test.py看一下断言的示例吧，理解一下用法：
a =int(input("a: ")) b =int(input("b: ")) assert b != 0, '除数不能为零' c = a/b print("a/b = ", c)cmd出场：
输入正确数值时：
输入错误数值时：
禁用断言，并且输入错误数值时：
案例研究：使用调试器调试Python程序
https://blog.csdn.net/Zhangguohao666/article/details/103948568
了解使用Python调试器调试程序的方法
第八章 函数和函数式编程
一些知识点总结和几个例题
Python中函数的分类：
- 内置函数
在程序中可以直接使用 - 标准库函数
Python语言安装程序同时会安装若干标准库，例如math、random等 - 第三方库函数
Python社区提供了许多其它高质量的库，在下载、安装这些库后，通过import语句可以导入库 - 用户自定义函数
- 函数名为有效的标识符（命名规则为全小写字母，可以使用下划线增加可阅读性，例如
my_func()） - 函数可以使用return返回值
如果函数体中包含return语句，则返回值，
否则不返回，即返回值为空（None），无返回值的函数相当于其它编程语言中的过程
调用函数之前程序必须先执行def语句，创建函数对象
- 内置函数对象会自动创建
- import导入模块时会执行模块中的def语句，创建模块中定义的函数
- Python程序结构顺序通常为
import语句>函数定义>全局代码
一：产生副作用的函数，纯函数
打印等腰三角形
n = int(input("行数：")) def print_star(n): print((" * " * n).center(50)) for i in range(1, 2*n, 2): print_star(i)输出：
行数：5 * * * * * * * * * * * * * * * * * * * * * * * * *上面代码中的
print_star()是一个产生副作用的函数，其副作用是向标准输出写入若干星号- 副作用：例如读取键盘输入，产生输出，改变系统的状态等
- 在一般情况下，产生副作用的函数相当于其它程序设计语言中的过程，可以省略return语句
定义计算并返回第n阶调和数（1+1/2+1/3+…+1/n）的函数，输出前n个调和数
def harmonic(n): total = 0.0 for i in range(1, n+1): total += 1.0/i return total n = int(input("n：")) print("输出前n个调和数的值：") for i in range(1, n+1): print(harmonic(i))输出：
n：8 输出前n个调和数的值： 1.0 1.5 1.8333333333333333 2.083333333333333 2.283333333333333 2.4499999999999997 2.5928571428571425 2.7178571428571425上面代码中的
harmonic()是纯函数纯函数：给定同样的实际参数，其返回值唯一，且不会产生其它的可观察到的副作用
注意：编写同时产生副作用和返回值的函数通常被认为是不良编程风格，但有一个例外，即读取函数。例如，
input()函数既可以返回一个值，又可以产生副作用（从标准输入中读取并消耗一个字符串）二：传递不可变对象、可变对象的引用
- 实际参数值默认按位置顺序依次传递给形式参数。如果参数个数不对，将会产生错误
在调用函数时：
- 若传递的是不可变对象（例如：int、float、bool、str对象）的引用，则如果函数体中修改对象的值，其结果实际上是创建了一个新的对象
i = 1 def func(i,n): i += n return i print(i)#1 func(i,10) print(i)#1执行函数
func()后，i依旧为1，而不是11- 若传递的是可变对象（例如：list对象）的引用，则在函数体中可以直接修改对象的值
import random def shuffle(a): n = len(a) for i in range(n): r = random.randrange(i,n) a[i],a[r] = a[r],a[i] a = [1,2,3,4,5] print("初始：",a) shuffle(a) print("调用函数后：",a)输出：
初始： [1, 2, 3, 4, 5] 调用函数后： [1, 5, 4, 3, 2]三：可选参数，命名参数，可变参数，强制命名参数
可选参数
- 在声明函数时，如果希望函数的一些参数是可选的，可以在声明函数时为这些参数指定默认值
>>> def babbles(words, times=1): print(words * times) >>> babbles('Hello') Hello >>> >>> babbles("Hello", 2) HelloHello >>>注意到一点：必须先声明没有默认值的形参，然后再声明有默认值的形参，否则报错。 这是因为在函数调用时默认是按位置传递实际参数的。
怎么理解上面那句话呢？
默认是按位置传递实际参数（如果有默认值的形参在左边，无默认值的形参在右，那么在调用函数时，你的实参该怎么传递呢？）
命名参数
- 位置参数：当函数调用时，实参默认按位置顺序传递形参
- 命名参数（关键字参数）：按名称指定传入的参数
参数按名称意义明确
传递的参数与顺序无关
如果有多个可选参数，则可以选择指定某个参数值
基于期中成绩和期末成绩，按照指定的权重计算总评成绩
>>> def my_sum(mid_score, end_score, mid_rate = 0.4): score = mid_score*mid_rate + end_score*(1-mid_rate) print(format(score,'.2f')) >>> my_sum(80,90) 86.00 >>> my_sum(mid_score = 80,end_score = 90) 86.00 >>> my_sum(end_score = 90,mid_score = 80) 86.00 >>>可变参数
- 在声明函数时，可以通过带星号的参数（例如：
def func(* param)）向函数传递可变数量的实参，调用函数时，从那一点后所有的参数被收集为一个元组 - 在声明函数时，可以通过带双星号的参数（例如：
def func(** param)）向函数传递可变数量的实参，调用函数时，从那一点后所有的参数被收集为一个字典
利用带星的参数计算各数字的累加和
>>> def my_sum(a,b,*c): total = a+b for i in c: total += i return total >>> print(my_sum(1,2)) 3 >>> print(my_sum(1,2,3,4,5,6)) 21利用带星和带双星的参数计算各数字的累加和
>>> def my_sum(a,b,*c,**d): total = a+b for i in c: total += i for key in d: total += d[key] return total >>> print(my_sum(1,2)) 3 >>> print(my_sum(1,2,3,4)) 10 >>> print(my_sum(1,2,3,4,male=1,female=2)) 13强制命名参数
- 在带星号的参数后面声明参数会导致强制命名参数（Keyword-only），然后在调用时必须显式使用命名参数传递值
- 因为按位置传递的参数默认收集为一个元组，传递给前面带星号的可变参数
>>> def my_sum(*, mid_score, end_score, mid_rate = 0.4): score = mid_score*mid_rate + end_score*(1-mid_rate) print(format(score,'.2f')) >>> my_sum(mid_score=80,end_score=90) 86.00 >>> my_sum(end_score=90,mid_score=80) 86.00 >>> my_sum(80,90) Traceback (most recent call last): File "<pyshell#47>", line 1, in <module> my_sum(80,90) TypeError: my_sum() takes 0 positional arguments but 2 were given >>>四：全局语句global示例，非局部语句nonlocal示例，输出局部变量和全局变量
- 在函数体中可以引用全局变量，但是要为定义在函数外的全局变量赋值，需要使用global语句
pi = 2.1415926 e = 2.7182818 def my_func(): global pi pi = 3.14 print("global pi = ", pi) e = 2.718 print("local e = ", e) print('module pi = ', pi) print('module e = ', e) my_func() print('module pi = ', pi) print('module e = ', e)输出：
module pi = 2.1415926 module e = 2.7182818 global pi = 3.14 local e = 2.718 module pi = 3.14 module e = 2.7182818- 在函数体中可以定义嵌套函数，在嵌套函数中如果要为定义在上级函数体的局部变量赋值，可以使用nonlocal
def outer_func(): tax_rate = 0.17 print('outer function tax rate is ',tax_rate) def inner_func(): nonlocal tax_rate tax_rate = 0.01 print('inner function tax rate is ',tax_rate) inner_func() print('outer function tax rate is ',tax_rate) outer_func()输出：
outer function tax rate is 0.17 inner function tax rate is 0.01 outer function tax rate is 0.01- 输出局部变量和全局变量
- 内置函数
locals()，局部变量列表 - 内置函数
globals()，全局变量列表
五：获取和设置最大递归数
在sys模块中，函数
getrecursionlimit()和setrecursionlimit()用于获取和设置最大递归次数>>> import sys >>> sys.getrecursionlimit() 1000 >>> sys.setrecursionlimit(666) >>> sys.getrecursionlimit() 666 >>>六：三个有趣的内置函数：eval()、exec()、compile()
eval
- 对动态表达式进行求值，返回值
eval(expression, globals=None, locals=None)
expression是动态表达式的字符串
globals和locals是求值时使用的上下文环境的全局变量和局部变量，如果不指定，则使用当前运行上下文
>>> x = 2 >>> str_func = input("请输入表达式：") 请输入表达式：x**2+2*x+1 >>> eval(str_func) 9 >>>exec
- 可以执行动态表达式，不返回值
exec(str, globals=None, locals=None)
>>> exec("for i in range(10): print(i, end=' ')") 0 1 2 3 4 5 6 7 8 9 >>>compile
- 编译代码为代码对象，可以提高效率
compile(source, filename, mode)
source为代码语句的字符串；如果是多行语句，则每一行的结尾必须有换行符\n
filename为包含代码的文件
mode为编码方式，可以为'exec'（用于语句序列的执行），可以为'eval'（用于表达式求值），可以为'single'（用于单个交互语句）
>>> co = compile("for i in range(10): print(i, end=' ')", '', 'exec') >>> exec(co) 0 1 2 3 4 5 6 7 8 9 >>>七：map()，filter()
- map(f, iterable,…)，将函数
f应用于可迭代对象，返回结果为可迭代对象
示例1：
>>> def is_odd(x): return x%2 == 1 >>> list(map(is_odd,range(5))) [False, True, False, True, False] >>>示例2：
>>> list(map(abs,[1,-2,3,-4,5,-6])) [1, 2, 3, 4, 5, 6] >>>示例3：
>>> list(map(str,[1,2,3,4,5])) ['1', '2', '3', '4', '5'] >>示例4：
>>> def greater(x,y): return x>y >>> list(map(greater,[1,5,7,3,9],[2,8,4,6,0])) [False, False, True, False, True] >>>- filter(f, iterable)，将函数
f应用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素，返回结果为可迭代对象
示例1（返回个位数的奇数）：
>>> def is_odd(x): return x%2 == 1 >>> list(filter(is_odd, range(10))) [1, 3, 5, 7, 9] >>>示例2（返回三位数的回文）：
>>> list(filter(is_palindrome, range(100, 1000))) [101, 111, 121, 131, 141, 151, 161, 171, 181, 191, 202, 212, 222, 232, 242, 252, 262, 272, 282, 292, 303, 313, 323, 333, 343, 353, 363, 373, 383, 393, 404, 414, 424, 434, 444, 454, 464, 474, 484, 494, 505, 515, 525, 535, 545, 555, 565, 575, 585, 595, 606, 616, 626, 636, 646, 656, 666, 676, 686, 696, 707, 717, 727, 737, 747, 757, 767, 777, 787, 797, 808, 818, 828, 838, 848, 858, 868, 878, 888, 898, 909, 919, 929, 939, 949, 959, 969, 979, 989, 999] >>>八：Lambda表达式和匿名函数
匿名函数广泛应用于需要函数对象作为参数、函数比较简单并且只使用一次的场合
格式：
lambda arg1,arg2... : <expression>其中，
arg1、arg2等为函数的参数，<expression>为函数的语句，其结果为函数的返回值示例1（计算两数之和）：
>>> f = lambda x,y : x+y >>> type(f) <class 'function'> >>> f(1,1) 2 >>>示例2（返回奇数）：
>>> list(filter(lambda x:x%2==1, range(10))) [1, 3, 5, 7, 9] >>>示例3（返回非空元素）：
>>> list(filter(lambda s:s and s.strip(), ['A', '', 'B', None, 'C', ' '])) ['A', 'B', 'C'] >>>补充：
strip()用来去除头尾字符、空白符（\n,\r,\t,’’,即换行、回车、制表、空格）lstrip()用来去除开头字符、空白符rstrip()用来去除结尾字符、空白符
再补充一点：
\n到下一行的开头\r回到这一行的开头
示例4（返回大于0的元素）：
>>> list(filter(lambda x:x>0, [1,0,-2,8,5])) [1, 8, 5] >>>示例5（返回元素的平方）：
>>> list(map(lambda x:x*x, range(10))) [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>>九：operator模块和操作符函数
Python内置操作符的函数接口，它定义了对应算术和比较等操作的函数，用于map()、filter()等需要传递函数对象作为参数的场合，可以直接使用而不需要使用函数定义或者Lambda表达式，使得代码更加简洁
示例1（
concat(x,y)对应于x+y）：>>> import operator >>> a = 'hello' >>>> operator.concat(a, ' world') 'hello world'实例2（
operator.gt对应于操作符>）：>>> import operator >>> list(map(operator.gt, [1,5,7,3,9],[2,8,4,6,0])) [False, False, True, False, True] >>>十：functools.reduce()，偏函数functools.partial()，sorted()
functools.reduce()
functools.reduce(func, iterable[, iterable[, initializer]])- 使用指定的带两个参数的函数
func对一个数据集合的所有数据进行下列操作： - 使用第一个和第二个数据作为参数用
func()函数运算，得到的结果再与第三个数据作为参数用func()函数运算，依此类推，最后得到一个结果 - 可选的
initialzer为初始值
示例：
>>> import functools,operator >>> functools.reduce(operator.add, [1,2,3,4,5]) 15 >>> functools.reduce(operator.add, [1,2,3,4,5], 10) 25 >>> functools.reduce(operator.add, range(1,101)) 5050 >>> >>> functools.reduce(operator.mul, range(1,11)) 3628800偏函数functools.partial()
functools.partial(func, *arg, **keywords)- 通过把一个函数的部分参数设置为默认值的方式返回一个新的可调用（callable）的partial对象
- 主要用于设置预先已知的参数，从而减少调用时传递参数的个数
示例（2的n次方）：
>>> import functools,math >>> pow2 = functools.partial(math.pow, 2) >>> list(map(pow2, range(11))) [1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0, 256.0, 512.0, 1024.0] >>>十一：sorted()
sorted(iterable, *, key=None, reverse=False)- iterable是待排序的可迭代对象
- key是比较函数（默认为None，按自然顺序排序）
- reverse用于指定是否逆序排序
示例1（数值。默认自然排序）：
>>> sorted([1,6,4,-2,9]) [-2, 1, 4, 6, 9] >>> sorted([1,6,4,-2,9], reverse=True) [9, 6, 4, 1, -2] >>> sorted([1,6,4,-2,9], key=abs) [1, -2, 4, 6, 9]示例2（字符串，默认按字符串字典序排序）：
>>> sorted(['Dod', 'cat', 'Rabbit']) ['Dod', 'Rabbit', 'cat'] >>> sorted(['Dod', 'cat', 'Rabbit'], key=str.lower) ['cat', 'Dod', 'Rabbit'] >>> sorted(['Dod', 'cat', 'Rabbit'], key=len) ['Dod', 'cat', 'Rabbit']示例3（元组，默认按元组的第一个元素排序）：
>>> sorted([('Bob', 75), ('Adam', 92), ('Lisa', 88)]) [('Adam', 92), ('Bob', 75), ('Lisa', 88)] >>> sorted([('Bob', 75), ('Adam', 92), ('Lisa', 88)], key=lambda t:t[1]) [('Bob', 75), ('Lisa', 88), ('Adam', 92)]十二：函数装饰器
这玩意就很有意思了，很Java语言中的注解是很相像的
示例1：
import time,functools def timeit(func): def wrapper(*s): start = time.perf_counter() func(*s) end = time.perf_counter() print('运行时间：', end - start) return wrapper @timeit def my_sum(n): sum = 0 for i in range(n): sum += i print(sum) if __name__ == '__main__': my_sum(10_0000)结果：
4999950000 运行时间： 0.013929100000000028怎么理解上面的代码呢？
- 首先，
timeit()返回的是wrapper，而不是执行（没有小括号） @timeit相当于，在调用my_sum()的前一刻，会执行这么个语句：my_sum = timeit(my_sum)
示例2：
def makebold(fn): def wrapper(*s): return "<b>" + fn(*s) + "</b>" return wrapper def makeitalic(fn): def wrapper(*s): return "<i>" + fn(*s) + "</i>" return wrapper @makebold @makeitalic def htmltags(str1): return str1 print(htmltags('Hello'))输出：
<b><i>Hello</i></b>选择题：1~5
1
>>> print(type(lambda:None)) <class 'function'>2
>>> f = lambda x,y:x*y >>> f(12, 34) 4083
>>> f1 = lambda x:x*2 >>> f2 = lambda x:x**2 >>> print(f1(f2(2))) 84
>>> def f1(p, **p2): print(type(p2)) >>> f1(1, a=2) <class 'dict'>5
>>> def f1(a,b,c): print(a+b) >>> nums = (1,2,3) >>> f1(*nums) 3思考题：4~11
4
>>> d = lambda p:p*2 >>> t = lambda p:p*3 >>> x = 2 >>> x = d(x) >>> x = t(x) >>> x = d(x) >>> print(x) 245
>>> i = map(lambda x:x**2, (1,2,3)) >>> for t in i: print(t, end=' ') 1 4 96
>>> def f1(): "simple function" pass >>> print(f1.__doc__) simple function7
>>> counter = 1 >>> num = 0 >>> def TestVariable(): global counter for i in (1, 2, 3) : counter += 1 num = 10 >>> TestVariable() >>> print(counter, num) 4 08
>>> def f(a,b): if b==0 : print(a) else : f(b, a%b) >>> print(f(9,6)) 3 None求最大公约数
9
>>> def aFunction(): "The quick brown fox" return 1 >>> print(aFunction.__doc__[4:9]) quick10
>>> def judge(param1, *param2): print(type(param2)) print(param2) >>> judge(1, 2, 3, 4, 5) <class 'tuple'> (2, 3, 4, 5)11
>>> def judge(param1, **param2): print(type(param2)) print(param2) >>> judge(1, a=2, b=3, c=4, d=5) <class 'dict'> {'a': 2, 'b': 3, 'c': 4, 'd': 5}上机实践：2~5
2. 编写程序，定义一个求阶乘的函数fact(n)，并编写测试代码，要求输入整数n（n>=0）。请分别使用递归和非递归方式实现
递归方式：
def fact(n): if n == 0 : return 1 return n*fact(n-1) n = int(input("请输入整数n（n>=0）：")) print(str(n)+" ! = " + str(fact(n)))非递归方式：
def fact(n): t = 1 for i in range(1,n+1): t *= i return t n = int(input("请输入整数n（n>=0）：")) print(str(n)+" ! = " + str(fact(n)))输出：
请输入整数n（n>=0）：5 5 ! = 1203. 编写程序，定义一个求Fibonacci数列的函数fib(n)，并编写测试代码，输出前20项（每项宽度5个字符位置，右对齐），每行输出10个。请分别使用递归和非递归方式实现
递归方式：
def fib(n): if (n == 1 or n == 2): return 1 return fib(n-1)+fib(n-2) for i in range(1,21): print(str(fib(i)).rjust(5,' '),end = ' ') if i %10 == 0: print()非递归方式：
def fib(n): if (n == 1 or n == 2): return 1 n1 = n2 = 1 for i in range(3,n+1): n3 = n1+n2 n1 = n2 n2 = n3 return n3 for i in range(1,21): print(str(fib(i)).rjust(5,' '),end = ' ') if i %10 == 0: print()输出：
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 67654. 编写程序，利用可变参数定义一个求任意个数数值的最小值的函数min_n(a,b,*c)，并编写测试代码。例如对于“print(min_n(8, 2))”以及“print(min_n(16, 1, 7, 4, 15))”的测试代码
def min_n(a,b,*c): min_number = a if(a < b) else b for n in c: if n < min_number: min_number = n return min_number print(min_n(8, 2)) print(min_n(16, 1, 7, 4, 15))输出：
2 15. 编写程序，利用元组作为函数的返回值，求序列类型中的最大值、最小值和元素个数，并编写测试代码，假设测试代码数据分别为s1=[9, 7, 8, 3, 2, 1, 55, 6]、s2=[“apple”, “pear”, “melon”, “kiwi”]和s3="TheQuickBrownFox"
def func(n): return (max(n),min(n),len(n)) s1=[9, 7, 8, 3, 2, 1, 55, 6] s2=["apple", "pear", "melon", "kiwi"] s3="TheQuickBrownFox" for i in (s1,s2,s3): print("list = ", i) t = func(i) print("最大值 = {0}，最小值 = {1}，元素个数 = {2}".format(t[0], t[1], t[2]))输出：
list = [9, 7, 8, 3, 2, 1, 55, 6] 最大值 = 55，最小值 = 1，元素个数 = 8 list = ['apple', 'pear', 'melon', 'kiwi'] 最大值 = pear，最小值 = apple，元素个数 = 4 list = TheQuickBrownFox 最大值 = x，最小值 = B，元素个数 = 16案例研究：井字棋游戏
https://blog.csdn.net/Zhangguohao666/article/details/103280740
了解Python函数的定义和使用
由于本文的内容太多了，导致了两个很不好的结果，
一是：在网页中打开本篇博客的加载时间太长了，明显的卡顿很影响阅读体验；
二是：本人在对本篇文章进行更新或者修改内容时，卡的要死。
遂，
将本文第八章后面的很多内容拆分到新的文章中，望大家理解
第九章 面向对象的程序设计
第十章 模块和客户端
第十一章 算法与数据结构基础
第十二章 图形用户界面
我对图形用户界面基本无兴趣，无特殊情况，基本不打算碰这方面内容
案例研究：简易图形用户界面计算器
第十三章 图形绘制
与上一章相同，我对于图形绘制的兴趣也基本没有，尝试做了2-7题，就完全没兴趣做下去了
图形绘制模块：tkinter
2. 参考例13.2利用Canvas组件创建绘制矩形的程序，尝试改变矩形边框颜色以及填充颜色
from tkinter import * root = Tk() c = Canvas(root, bg = 'white', width = 130, height = 70) c.pack() c.create_rectangle(10, 10, 60, 60, fill = 'red') c.create_rectangle(70, 10, 120, 60, fill = 'green', outline = 'blue', width = 5)
创建画布对象：
root = Tk()
创建一个Tk根窗口组件rootc = Canvas(root, bg = 'white', width = 130, height = 70)
创建大小为200 * 100、背景颜色为白色的画布c.pack()
调用组件pack()方法，调整其显示位置和大小
绘制矩形：
c.create_rectangle(x0, y0, x1, y1, option, ...)- （x0，y0）是左上角的坐标
- （x1，y1）是右下角的坐标
c.create_rectangle(70, 10, 120, 60, fill = 'green', outline = 'blue', width = 5)
用蓝色边框、绿色填充矩形，边框宽度为5
3. 参考例13.3利用Canvas组件创建绘制椭圆的程序，尝试修改椭圆边框样式、边框颜色以及填充颜色
from tkinter import * root = Tk() c = Canvas(root, bg = 'white', width = 280, height = 70) c.pack() c.create_oval(10, 10, 60, 60, fill = 'green') c.create_oval(70, 10, 120, 60, fill = 'green', outline = 'red', width = 5) c.create_oval(130, 25, 180, 45, dash = (10,)) c.create_oval(190, 10, 270, 50, dash = (1,), width = 2)
绘制椭圆
c.create_oval(x0, y0, x1, y1, option, ...)- （x0，y0）是左上角的坐标
- （x1，y1）是右下角的坐标
c.create_oval(70, 10, 120, 60, fill = 'green', outline = 'red', width = 5)
绿色填充、红色边框，宽度为5c.create_oval(130, 25, 180, 45, dash = (10,))
虚线椭圆
4. 参考例13.4利用Canvas组件创建绘制圆弧的程序，尝试修改圆弧样式、边框颜色以及填充颜色
from tkinter import * root = Tk() c = Canvas(root, bg = 'white', width = 250, height = 70) c.pack() c.create_arc(10, 10, 60, 60, style = ARC) c.create_arc(70, 10, 120, 60, style = CHORD) c.create_arc(130, 10, 180, 60, style = PIESLICE) for i in range(0, 360, 60): c.create_arc(190, 10, 240, 60, fill = 'green', outline = 'red', start = i, extent = 30)
绘制圆弧：
c.create_arc(x0, y0, x1, y1, option, ...)- （x0，y0）是左上角的坐标
- （x1，y1）是右下角的坐标
- 选项start（开始角度，默认为0）和extend（圆弧角度，从start开始逆时针旋转，默认为90度）决定圆弧的角度范围
- 选项start用于设置圆弧的样式
5. 参考例13.5利用Canvas组件创建绘制线条的程序，尝试修改线条样式和颜色
from tkinter import * root = Tk() c = Canvas(root, bg = 'white', width = 250, height = 70) c.pack() c.create_line(10, 10, 60, 60, arrow = BOTH, arrowshape = (3, 4, 5)) c.create_line(70, 10, 95, 10, 120, 60, fill = 'red') c.create_line(130, 10, 180, 10, 130, 60, 180, 60, fill = 'green', width = 10, arrow = BOTH, joinstyle = MITER) c.create_line(190, 10, 240, 10, 190, 60, 240, 60, width = 10)
绘制线条：
c.create_line(x0, y0, x1, y1, ..., xn, yn, option, ...)- （x0，y0）,（x1，y1），…，（xn，yn）是线条上各个点的坐标
6. 参考例13.6利用Canvas组件创建绘制多边形的程序，尝试修改多边形的形状、线条样式和填充颜色
from tkinter import * root = Tk() c = Canvas(root, bg = 'white', width = 250, height = 70) c.pack() c.create_polygon(35, 10, 10, 60, 60, 60, fill = 'red', outline = 'green') c.create_polygon(70, 10, 120, 10, 120, 60, fill = 'white', outline = 'blue') c.create_polygon(130, 10, 180, 10, 180, 60, 130, 60, outline = 'blue') c.create_polygon(190, 10, 240, 10, 190, 60, 240, 60, fill = 'white', outline = 'black')
绘制多边形：
c.create_polygon(x0, y0, x1, y1, ..., option, ...)- （x0，y0）,（x1，y1），…，（xn，yn）是多边形上各个顶点的坐标
7. 参考例13.7利用Canvas组件创建绘制字符串和图形的程序，绘制y = cos(x) 的图形
绘制字符串：
c.create_text(x, y, option, ...)- （x，y）是字符串放置的中心位置
y = sin(x)
from tkinter import * import math WIDTH, HEIGHT = 510, 210 ORIGIN_X, ORIGIN_Y = 2, HEIGHT/2 #原点 SCALE_X, SCALE_Y = 40, 100 #x轴、y轴缩放倍数 ox, oy = 0, 0 x, y = 0, 0 arc = 0 #弧度 END_ARC = 360 * 2 #函数图形画两个周期 root = Tk() c = Canvas(root, bg = 'white', width = WIDTH, height = HEIGHT) c.pack() c.create_text(200, 20, text = 'y = sin(x)') c.create_line(0, ORIGIN_Y, WIDTH, ORIGIN_Y) c.create_line(ORIGIN_X, 0, ORIGIN_X, HEIGHT) #绘制x轴，y轴 for i in range(0, END_ARC+1, 10): arc = math.pi * i / 180 x = ORIGIN_X + arc * SCALE_X y = ORIGIN_Y - math.sin(arc) * SCALE_Y c.create_line(ox, oy, x, y) ox, oy = x, y
y = cos(x)
from tkinter import * import math WIDTH, HEIGHT = 510, 210 ORIGIN_X, ORIGIN_Y = 2, HEIGHT/2 #原点 SCALE_X, SCALE_Y = 40, 100 #x轴、y轴缩放倍数 ox, oy = 0, 0 x, y = 0, 0 arc = 0 #弧度 END_ARC = 360 * 2 #函数图形画两个周期 root = Tk() c = Canvas(root, bg = 'white', width = WIDTH, height = HEIGHT) c.pack() c.create_text(200, 20, text = 'y = cos(x)') c.create_line(0, ORIGIN_Y, WIDTH, ORIGIN_Y) c.create_line(ORIGIN_X, 0, ORIGIN_X, HEIGHT) for i in range(0, END_ARC+1, 10): arc = math.pi * i / 180 x = ORIGIN_X + arc * SCALE_X y = ORIGIN_Y - math.cos(arc) * SCALE_Y c.create_line(ox, oy, x, y) ox, oy = x, y
图形绘制模块：turtle
…
后面章节内容：未完待续…
第十四章 数值日期和时间处理
第十五章 字符串和文本处理
第十六章 文件和数据交换
第十七章 数据访问
第十八章 网络编程和通信
第十九章 并行计算：进程、线程和协程
第二十章 系统管理
-
2019工程伦理慕课答案（2019秋）习题及期末答案
2019-11-08 18:19:53对于不能及时进行处理的工程质量缺陷，应填写质量缺陷备案表，表中应包括哪些信息？（） 缺陷产生的部位和原因 对工程安全性的分析 使用功能和运用影响分析 处理方案和不处理原因分析 文字填空题 ...展开全文下面是第一章~第十章习题答案（下）
第一章习题（下）
单选题 (1/1 point)
下列哪一项不是工程与技术的区别
- 内容和性质
- 目的
- 活动主体
- 任务、对象和思维方式
单选题 (1/1 point)
下列哪一项不是工程活动的特征
- 自主性
- 创造性
- 社会性
- 确定性
多选题 (1points)
下列哪项是工程的完整生命周期中的环节
- 计划
- 设计
- 评估
- 完成
判断题 (1/1 point)
计划、设计、建造、使用和结束构成了工程完整的生命周期
- 正确
- 错误
判断题 (1/1 point)
工程包括哲学、技术、经济、管理、社会、生态、伦理这7个维度。
- 正确
- 错误
You have used 1 of 1 submissions
单选题 (1points)以下哪项不是规范伦理学的立场
- 功利论 功利论
- 义务论
- 契约论
- 存在论
单选题 (1points)
下列哪项不是罗斯为直觉主义义务论提出的道德原则
- 忠诚
- 公平
- 感恩
- 不行恶
单选题 (1/1 point)
下列职业社团名称缩写错误的是
- 美国土木工程师协会（ASCE）
- 电子和电子工程师协会（IEEE）
- 美国机械工程师学会（ABET）
- 美国化学工程师学会（AIChE）
判断题 (1/1 point)
根据伦理规范得到社会认可和被制度化的程度，我们可以把伦理规范分为制度性的伦理规范和描述性的伦理规范两种情况。
- 正确
- 错误
判断题 (1/1 point)
伦理是个体性、主观性的，侧重个体的意识、行为与准则、法则的关系；道德则是社会性和客观性的，侧重社会“共体”。
- 正确
- 错误
多选题 (1/1 point)
当工程实践出现“超越于道德的”的情形时，我们可以通过道德慎思为自己的伦理行为划分优先顺序，审慎地思考和处理存在的几对重要的伦理关系。这几对重要的伦理关系指的是
- 自主与责任
- 效率与公正
- 个人与集体
- 环境与社会
单选题 (1/1 point)
下列哪项不是工程伦理问题的特点
- 历史性
- 社会性
- 复杂性
- 简明性
单选题 (1/1 point)
下列哪项不是处理工程伦理问题的基本原则
- 人道主义
- 功利主义
- 社会公正
- 人与自然和谐发展
判断题 (1/1 point)
工程活动是一种集成多种自然与社会资源,协调多种利益诉求和冲突的社会活动，是一种极其复杂的社会实践,需要众多的行动者参与。
- 正确
- 错误
单选题 (1/1 point)
下列哪项不是依据工程伦理问题的对象来划分伦理问题的？
- 因伦理意识缺失或者对行为后果估计不足导致的问题
- 因工程相关的各方利益冲突所造成的伦理困境
- 工程共同体内部意见不合，或者工程共同体的伦理准则与规范等与其他伦理原则之间不一致导致的问题
- 因工程伦理章程缺乏或者不足而导致的问题
多选题 (1/1 point)
“博帕尔MIC毒气泄漏事件”主要涉及哪几方面的问题
- 企业和政府在维护公共安全和环境安全方面所肩负的责任和各自扮演的角色问题
- 跨国工程活动中发达国家向发展中国家的环境成本转移问题
- 跨国公司的双重技术标准问题
- 如何通过相关法规和制度来保障工程活动中的弱势群体权益的问题
判断题 (1/1 point)
从处理工程与人、社会和自然的关系的三个层面看,处理工程中伦理问题要坚持以下三个基本原则：人道主义———处理工程与人关系的基本原则；社会公正———处理工程与社会关系的基本原则；人与自然和谐发展———处理工程与自然关系的基本原则。
- 正确
- 错误
第二章习题（下）
判断题 (1/1 分数)
从普利高津耗散结构理论的视角来看，工程必然会伴随风险的发生- 正确
- 错误
判断题 (1/1 分数)
在讨论工程设计理念时，只需要工程师代表参与决策- 正确
- 错误
单选题 (1/1 分数)
意外风险的应对通常采取的措施包括风险回避、风险转移等，其中风险转移的目的是？- 降低风险发生的概率
- 降低不利后果的大小
- 在风险发生时将损失分散
- 保护工人的安全
单选题 (1/1 分数)
在制定事故应急预案时,不恰当的做法是？（）- 预防为主,防治结合
- 保留现场，等待救援
- 以人为本,生命第一
- 统一指挥,协同联动
单选题 (1/1 分数)
下列哪项属于工程风险中的技术因素？（）- 自然灾害
- 工程设计理念的缺陷
- 施工质量缺陷
- 控制系统失灵
多选题 (1/1 分数)
工程风险的来源有哪些？（）- 技术因素的不确定性
- 环境因素的不确定性
- 文化因素的不确定性
- 人为因素的不确定性
多选题 (1/1 分数)
对于不能及时进行处理的工程质量缺陷，应填写质量缺陷备案表，表中应包括哪些信息？（）- 缺陷产生的部位和原因
- 对工程安全性的分析
- 使用功能和运用影响分析
- 处理方案和不处理原因分析
文字填空题 (1/1 分数)
操作人员是预防工程风险的核心环节,也是防止工程风险发生的最后一道屏障，必须要加强对操作人员安全意识的教育,时时刻刻以“ ”为行动准则。（四个字）答案：安全第一
判断题 (1/1 分数)
在制度层面,目前公众参与工程主要以网络投票为参与途径。- 正确
- 错误
判断题 (1/1 分数)
公众参与工程风险伦理评估的前提是信息的公开。- 正确
- 错误
单选题 (1/1 分数)
下列工程风险的伦理评估原则中哪项属于预防为主的原则？- 尊重当事人的“知情同意”权
- 要加强安全知识教育,提升人们的安全意识
- 考虑对社会环境和生态环境造成的影响
- 建立并落实安全生产问责机制
单选题 (1/1 分数)
下列属于工程风险的外部评估主体的是（）？- 工程师
- 社会公众
- 工人
- 管理者
单选题 (1/1 分数)
对于可接受风险，以下哪种视角是专家视角（）？- 可接受的风险是这样风险，在可以选择的情况下，伤害的风险至少相等于产生收益的可能性
- 可接受的风险指的是这样风险，它是通过行使自由和知情同意权而自愿认可的，或者它是得到适当赔偿的，并且它是公正地分配的
- 可接受的风险是这样风险，其保护公众免遭伤害的重要性远远超过了使公众获利的重要性
- 采取任何手段，只要让公众自愿接收的风险
判断题 (1/1 分数)
当工程风险发生时,往往不能把全部责任归结于某一个人,而需要工程共同体共同承担- 正确
- 错误
判断题 (1/1 分数)
伦理责任就是法律责任- 正确
- 错误
单选题 (1/1 分数)
下列不属于“职业”的特征是？（）- 理智性
- 长期性
- 自主性
- 非垄断性
单选题 (1满分)
下列哪项不属于工程伦理责任类型？（）- 职业伦理责任
- 社会伦理责任
- 环境伦理责任
- 家庭伦理责任
单选题 (1/1 分数)
下列哪项超出了工程伦理责任类型？（）- 过失-责任
- 赔偿-责任
- 角色-责任
- 义务-责任
第三章习题（下）
判断题 (1/1 point)
由工程的目标价值导向性引出一个重要的伦理问题，这就是工程为什么人服务，为什么目的服务？（）- 正确
- 错误
单选题 (1/1 point)
下列哪一项体现了工程的文化价值？（）- 标志性工程是所属民族的精神纽带
- 工程的“普遍接入”和“普遍服务”
- 工程制造的科学仪器
- 环境保护和生态修复工程
判断题 (1/1 point)
工程社会价值的一个极端表现是其军事价值。（）- 正确
- 错误
单选题 (1/1 point)
工程的（）价值具有非道德性质，这决定了工程的最终价值取决于工程应用于什么目的，即工程的实际价值取决于社会的要求和社会环境。- 工具价值
- 内在价值
- 伦理价值
- 社会价值
多选题 (1/1 point)
工程具有多元的价值，主要包括（）- 科学价值
- 政治价值
- 社会价值
- 文化价值
单选题 (1/1 point)
如何确定什么人可以首先享受到工程成果，或者如何确定人们享受的顺序，这属于工程的（）问题。- 管理问题
- 技术问题
- 资源分配问题
- 制度问题
判断题 (1/1 point)
讨论工程的利益分配可以从宏观和微观两个层面来进行，宏观层面是指企业内部工程项目的活动情况。- 正确
- 错误
单选题 (1/1 point)
产品价格过高，会使得普通大众难以分享工程的好处，妨碍了实现工程成果为更多人（）。- 所及和普惠
- 接受
- 认可
- 理解
判断题 (1/1 point)
工程受益人群的确定由市场来调控，我们把不能获得工程产品和服务的现象，称作“排除”。（）- 正确
- 错误
多选题 (1/1 point)
下列哪些因素会影响工程产品和服务的可及性和普惠性？（）- 用户的经济状况
- 用户的知识水平
- 用户的技术水平
- 用户的能力问题
判断题 (1满分)
“邻避”行为突出反映了工程项目建设的利益—损失分配不公正的问题。（）- 正确
- 错误
单选题 (1/1 point)
“邻避”事件发生的原因很复杂，不一定是现实的危害，而是（）。- 利益分配不公平
- 居民对危害的心理担忧和风险感知
- 利益补偿不合理
- 公众参与不充分
判断题 (1/1 point)
传统的工程观主要考虑企业本身的收益和付出，很少考虑用户为工程付出的代价。（）- 正确
- 错误
单选题 (1/1 point)
一些工程建设引起的大规模的拆迁移民，可能增加社会秩序的不安定因素，这属于工程对（）的影响。- 环境
- 经济
- 社会
- 资源
多选题 (1/1 point)
米切尔认为，利益相关者必须具备以下哪些条件。（）- 创造力
- 影响力
- 合法性
- 紧迫性
文字填空题 (1/1 point)
公正是指，每个人都应获得其应得的权益，对平等的事物平等对待，不平等的事物（）对待。(两个字)
答案：区别单选题 (1满分)
分配公正的基本实现途径是在不同利益与价值追求的个人与团体间的对话的基础上，达成有普遍约束力的（）原则。- 社会公正
- 利益协调
- 分配与补偿
- 道德伦理
判断题 (1/1 point)
吸收利益攸关方参加工程的决策、建设、运营是为了保证补偿公正。（）- 正确
- 错误
多选题 (1/1 point)
美国伦理学家理查德·T.德·乔治将公正分为以下哪些类型？（）- 补偿公正
- 惩罚公正
- 分配公正
- 程序公正
多选题 (1/1 point)
下列哪些属于工程项目社会评价的社会公平指标？（）- 基尼系数
- 恩格尔系数
- 就业率
- 公众参与度
第四章习题（下）
单选题
提出保护资源的目的是为了自然本身的利益，而不是人类的利用，这是（）主义的主张。- 社会保护主义
- 环境保护主义
- 资源保护主义
- 自然保护主义
单选题
()主张把道德关怀的范围从人类扩展到非人类的生命或自然存在物上。- 人类中心主义者
- 非人类中心主义者
- 价值主观论者
- 价值客观论者
判断题
“大地伦理”的提出者利奥波德认为：一件事情当有助于保护自然的和谐、稳定和美丽时，它就是正确的，反之，就是错误的。（）- 正确
- 错误
文字填空题
如果我们承认了自然事物拥有内在价值，我们就认可了自然事物的（），我们就与道德义务维护自然事物。(四个字)
答案：道德权利判断题
认为自然界的价值不依人的存在或人的评价而存在，只要对地球生态系统的完善和健康有益的事物就有价值，是价值客观论者的主要观点。（）- 正确
- 错误
多选题
"尊重自然"的伦理体系包括以下哪几部分？（）- 尊重自然的态度
- 深层生态学
- 生物中心主义
- 人类中心主义
多选题
下列哪些选项属于非人类中心主义思想？（）- 动物解放论
- 动物权利论
- 生物中心主义
- 生态中心主义
文字填空题
对工程活动进行分析、预测和评估，提出预防或者减轻不良环境影响的对策和措施，这是对工程进行（）评价。(四个字)
答案： 环境影响判断题
工程理念是工程活动的出发点和归宿，是工程活动的灵魂。（）- 正确
- 错误
单选题
好的工程会把（）和合人的目的性有机结合起来。- 合工程的目的性
- 合自然的规律性
- 合社会的进步性
- 合技术的发展性
单选题
在权衡人与自然利益的优先秩序上应遵循（）高于基本需要、基本需要高于非基本需要。- 社会需要
- 伦理需要
- 生存需要
- 发展需要
单选题
（）原则是我们对自然环境的首要态度，也是我们行动的首要原则。- 公平性原则
- 整体性原则
- 尊重原则
- 平等性原则
多选题
工程建设对环境产生的影响主要包括（）。- 消耗能源和资源
- 造成的固废污染和水污染
- 噪声和振动影响
- 排出的有害气体威胁人们的健康
单选题
工程共同体的环境伦理主要指，工程过程应切实考虑（）及社会的承受性。- 政府
- 自然生态
- 雇主
- 公众
文字填空题
随着工程对自然的干预和破坏能力越来越巨大、后果越来越危险，工程师需要发展一种新的责任意识，即（）(六个字)
答案：环境伦理责任单选题
工程师的环境伦理责任不只是赋予工程师责任和义务，同时也赋予他相应的（），使得他在必要时及时中止他的责任和义务。- 资源
- 利益
- 自由
- 权利
判断题
对工程师的评价标准不是工程师是否把工作做好了，而是是否做了一项好到工作，既促进了经济发展，又避免了环境遭到破坏。（）- 正确
- 错误
判断题
工程共同体通常由项目投资人、设计者、工程师、工人构成。（）- 正确
- 错误
多选题
下列选项哪些属于工程师的环境伦理责任？（）- 维护人类健康
- 维护自然生态环境
- 忠诚于雇主
- 维护公司的利益
第五章习题（下）
判断题
职业的行为规范强调的是“自我机制”，技术规范强调“社会机制”- 正确
- 错误
文字填空题
工程领域中的“职业”是指“那些涉及高深的专业知识、（）和对公共善协调服务的工作方式”。(四个字)
自我管理单选题
以下哪项是对职业共同体中工程师负责任的职业行为的错误理解？（）- 工程师的责任就是他或她在工程生活中必须履行的角色责任
- 工程师可以对履行特定义务作出回应
- 工程师接受自己的工作职责和社会责任，并自觉地为实现这些义务努力
- 工程师须对行为的危害承担责任，不能为自己行为的功绩要求荣誉
判断题
工程社团是工程职业的生活形态。- 正确
- 错误
单选题
工程职业制度不包括（）- 职业准入制度
- 职业资格制度
- 执业资格制度
- 职业准出制度
单选题
以下哪项是注册工程师执业资格制度的首要环节？（）- 职业实践
- 资格考试
- 高校工程专业教育
- 注册执业管理
多选题
有关职业伦理章程的正确描述是（）- 职业伦理章程一般采用规范和准则的形式
- 职业伦理章程为职业行为提供一种普遍的和协商一致的标准
- 职业伦理章程的主要关注点是促进负责任的职业行为
- 职业伦理章程表达了对职业共同体内从业者的职业行为的期待
判断题
作为职业伦理的工程伦理是一种预防性、规范性的实践伦理- 正确
- 错误
单选题
以下哪项是工程师的首要责任？（）- 公众的安全、健康及福祉
- 雇主的利益
- 客户的利益
- 可持续发展
单选题
以下哪项是工程师最新的职业责任观？（）- 雇主的命令
- 工程师的反叛
- 承担社会责任
- 对自然和生态负责
多选题
以下哪项是对工程师自律的正确理解？（）- 工程师的自律是对职业责任的主动担当
- 自律是工程师对工程-人-自然-社会整体必然存在的一种道德自觉
- 自律使工程师从朦胧未显的工程伦理意识走向明确自主的对责任的担当
- 工程师的自律表现为一种从向善到行善的自觉、自愿与自然的职业精神
判断题
举报是举报者一种最明智之举- 正确
- 错误
单选题
作为职业人员，工程师不能享有以下哪项权利：（）- 在规定范围内从事执业活动
- 对他人执业活动进行解释和辩护
- 接受继续教育
- 在本人执业活动中形成的文件上签字并加盖执业印章
单选题
“工程师遵守甚至超越职业标准的积极责任”属于工程师的哪一种责任？（）- 义务-责任
- 过失-责任
- 角色-责任
- 岗位-责任
单选题
从职业伦理的角度看，工程师的（）美德体现了工程伦理的核心- 诚实可靠
- 忠实服务
- 尽职尽责
- 善良
文字填空题
工程师最综合的美德是（）的职业精神。(三个字)
答案：负责任
判断题
服务是工程师开展职业活动的一项基本内容和基本方式。- 正确
- 错误
单选题
以下哪项不属于工程师的角色冲突？- 工程师与企业雇员
- 工程师与管理者
- 工程师与社会公众
- 工程师与同事
单选题
工程中利益冲突的种类不包括（）- 个体利益之间的冲突
- 个体利益与群体利益之间的冲突
- 个体利益与整体利益之间的冲突
- 群体利益与整体利益之间的冲突
第六章习题（下）
多选题 (1/1 point)
水利工程的影响深远体现在（）- 水利工程对于促进国民经济和社会发展具有全方位的深远影响。
- 水利工程会引起空间大范围的连锁反应。
- 水利工程的影响常常跨越数十年甚至上百年。
- 水利工程对人文和生态环境均产生深远影响。
文字填空题 (1/1 point)
水利工程就是对自然界中的水资源进行有效控制、按需调配、持续利用及（）的工程。（四个字）
答案： 全面保护
判断题 (1/1 point)
我国水资源丰富，人均水资源占有量为世界平均水平的四分之一。- 正确
- 错误
单选题 (1/1 point)
以下哪项是新时期水利工程的崭新内容？- 港口与航道工程
- 水力发电工程
- 河湖环境生态工程
- 水土保持工程
判断题 (1/1 point)
中国水利工程建设经历了工程水利、资源水利和生态水利三个阶段的演变- 正确
- 错误
判断题 (1/1 point)
政府的行政意愿对水利工程建设的影响巨大。- 正确
- 错误
单选题 (1/1 point)
水权的核心是哪项权利？（）- 所有权
- 配置权
- 经营权
- 使用权
多选题 (1/1 point)
水资源公正配置的原则包括（）- 邻近优先
- 尊重历史
- 利益补偿
- 重视生态
单选题 (1/1 point)
以下哪项是对跨地区调水的错误理解？（）- 实施跨地区调水时，水源地的用水需求应该优先得到满足
- 跨地区调水时要统筹兼顾调出和调入流域的用水需要
- 水资源配置向水资源调出区倾斜时很有可能会成为利益驱动下的默认选择
- 在具体工作中，并非总能优先考虑水源地的用水需求和实际利益
单选题 (1/1 point)
以下哪项说法是正确的？- 涉及水资源分配的国际水法条款与国际水条约非常多
- 存在普适的水资源分配法则
- 现有国际水法过多地强调上游国家对水资源地利用
- 通过协商来解决水资源的分配与利用问题常常是唯一可行的途径
判断题 (1/1 point)
在我国，工业用水一直占水资源总量的最大比重。- 正确
- 错误
判断题 (1/1 point)
对水利工程风险进行完全的定量评价是现实的。- 正确
- 错误
判断题 (1/1 point)
我国已建成的水利工程在数量和规模上均居世界第二。- 正确
- 错误
单选题 (1/1 point)
以下哪项不是从人类生存和发展的维度看河流的价值？（）- 政治
- 生态
- 审美
- 文化
单选题 (1/1 point)
以下哪项不是从河流的外在价值观察到的河流生命的特征？（）- 周期性
- 柔性
- 独特性
- 庄严性
判断题 (1/1 point)
水利工程对河流健康生命没有正面的促进作用。- 正确
- 错误
单选题 (1/1 point)
以下哪项是对水利工程对河流健康生命造成巨大冲击的错误表述？（）- 水利工程导致诸多天然美景的消失
- 水利工程破化了河流生态系统的空间连续性
- 水利工程减弱甚至切断了物质和能量沿水流的传递
- 水利工程对河流生态系统的扰动是不可恢复的。
文字填空题 (1满分)
在实践中，通过法律、技术和（）手段，努力维护河流健康生命。(两个字)
答案： 管理单选题 (1/1 point)
以下哪项原则是移民工作成败的核心？（）- 顾全大局
- 公平公正
- 因地制宜
- 可持续发展
单选题 (1/1 point)
以下哪项是对核定补偿标准的错误描述？（）- 无形的损失难以估量
- 要避免同一工程的不同区域、不同群体补偿方面存在不公平的现象
- 要避免不同时间段（主要指可比的相邻时段内）移民补偿存在不公平的现象。
- 与其他行业相比，水利工程补偿标准偏高。
判断题 (1/1 point)
通过努力，水利工程师在职业生涯中可以充分掌握全部的知识。- 正确
- 错误
第七章习题（下）
多选题 (1满分)
生物医药工程伦理问题包括（）- 不可接受的“风险-受益”比
- 环境污染问题
- 学术不端问题
- 公平可及性问题
多选题 (1/1 point)
生物医药工程中造成不可接受的“风险-受益”比的原因包括：（）- 科研人员伦理意识淡薄
- 伦理审查不规范
- 没有把受试者安全放在首位
- 忽视受试者的权益
判断题 (1/1 point)
现有的多数药品是针对成人进行的临床试验，增加了患儿的用药风险- 正确
- 错误
判断题 (1/1 point)
多数制药企业喜欢投资孤儿药品。- 正确
- 错误
多选题 (1满分)
生物医药研发和应用领域的知情同意问题十分突出，表现在（）- 有些生物医药工程技术研发人员有意抹杀了“治疗”与“研究”的区别
- 淡化了临床研究的潜在疗效
- 夸大了可能的风险
- 误导受试者
文字填空题 (1/1 point)
公正原则包括：程序公正、回报公正和（）(四个字)
答案：分配公正多选题 (1/1 point)
生物医药研发和应用应尽量减少的风险包括（）- 对受试人群的身心伤害
- 给受试人群带来的经济负担
- 造成的公共卫生风险
- 造成的生态环境风险
文字填空题 (1/1 point)
自主性是指有行为能力的人在不受干扰的状态下，自愿选择行动方案的意识和（）。(两个字)
答案： 能力单选题 (1满分)
以下哪项可以从"受益最大化原则"从推导出来？（）- 生物医药研发和应用应将预防作为主要目标
- 将工程的社会经济效益放在首位
- 当经济回报、优先权、奖励等与受试者利益冲突时，把受试者的权益放在首位。
- 国家利益始终大于患者健康需要的满足。
单选题 (1满分)
生物医药工程的伦理问题的主要来源不包括（）- 因经济利益冲突而提出的“应该”问题
- 因政治利益冲突而提出的“应该”问题
- 因道德义务冲突而引起的伦理难题
- 因宗教文化冲突而产生的伦理“应该”问题。
单选题 (1/1 point)
伦理审查委员会的基本职能不包括（）- 改变研究方案
- 监督
- 咨询
- 指导
单选题 (1满分)
动物研究的伦理要求实行3R原则不包括（）- 考虑能够不使用动物
- 减少动物使用量及使用中减少动物的痛苦
- 权衡对动物的可能伤害及人类的受益以及动物伦理审查委员会的独立审查。
- 考虑能否循环使用动物
单选题 (1/1 point)
医疗器械临床试验伦理审查要点不包括（）- 试验的科学设计
- 试验的风险和受益
- 平等对待受试者
- 知情同意
判断题 (1/1 point)
基因是有“好”或“坏”、“优”或“劣”之分的。- 正确
- 错误
判断题 (1/1 point)
获知遗传基因信息不一定有利于个人对自己的生活作出理性的安排- 正确
- 错误
多选题 (1/1 point)
基因信息泄露会引发哪些问题：（）- 泄露家族成员的遗传倾向。
- 可能在就学、就业、婚姻等方面受到歧视
- 如果有基因缺陷，有些保险公司可能会拒绝为他们在医疗
- 引发个人的不安和焦虑
单选题 (1/1 point)
- 以下哪项是对基因治疗临床试验的伦理审查的错误表述？（）
- 慎重选择受试者，确立准入和排除的严格标准。
- 筛选程序要公平，并接受审查和监督。
- 要预先进行方案的风险-受益分析
- 有其他替代的有效常规疗法时，也可以使用基因治疗临床方案。
单选题 (1满分)
以下哪项不属于不征求提供者再次同意的条件：（）- 样本是匿名的，不与其他可识别信息相联系
- 样本提供者有机会自由撤回样本
- 不征求再次同意对提供者更有利
- 满足上述条件，就可以不接受伦理审查委员会的审查和批准。
单选题 (1/1 point)
以下哪项是对“治疗”和“研究”的错误理解？（）- 治疗是将已被证明有效的方法用于病人
- 病人从治疗中受益，病人应该付费。
- 研究者无需给予受试者补偿
- 研究如果对受试者造成损害，研究者应予以赔偿。
文字填空题 (1满分)
捐赠器官问题有两种同意方式：自愿捐献和（）(四个字)
答案：推定同意判断题 (1/1 point)
活体器官移植是解决器官供应的根本途径。- 正确
- 错误
多选题 (1/1 point)
以下哪项是对制药工程的正确表述？（）- 制药工程以提升广大患者的健康需求为导向
- 制药工程涉及众多利益主体，各方的角色分工和利益诉求不同，需要协同互助，信守承诺。
- 制药工程受到市场需求、国家政策、研发资金等诸多因素的综合影响。
- 制药企业是制药工程创新的主体，制药工程人员要有企业家精神。
单选题 (1/1 point)
以下哪项是对中国制药企业的社会责任的正确表述？（）- 社会责任履行情况整体较好。
- 新药研发水平相对滞后，资金投入不足，创新能力较低。
- 制药企业或药物研发机构一般会主动公开负面报道。
- 药品质量事故较少。
第八章习题（下）
判断题 (1/1 point)
中国是仅次于美国的第二大二氧化碳排放国- 正确
- 错误
判断题 (1/1 point)
煤电比核电更清洁- 正确
- 错误
单选题 (1/1 point)
我国第一颗原子弹爆炸成功是在哪一年（）- 1950
- 1964
- 1967
- 1971
单选题 (1满分)
核工程应遵循的伦理原则包括- 以人为本原则
- 可持续发展原则
- 生态原则
- 公正原则
多选题 (1/1 point)
核工程应该遵循的伦理原则主要有（）
以人为本原则, 可持续发展原则, 生态原则, 公正原则, - 正确- 以人为本原则
- 可持续发展原则
- 生态原则
- 公正原则
单选题 (1/1 point)
对伦理规范的审查应该在项目建设的什么时期（）- 初期
- 中期
- 运行期
- 后期
判断题 (1/1 point)
“零风险”是可以实现的- 正确
- 错误
多选题 (1/1 point)
风险主要包括哪些要素（）- 事件诱因
- 事件概率
- 事件后果
- 事件过程
判断题 (1满分)
系统的正反馈效应能够维持系统平衡与稳定- 正确
- 错误
多选题 (1/1 point)
公众在核工程中的权利有（）- 知情权
- 决策权
- 参与权
- 讨论权
多选题 (1/1 point)
影响核事故信息公开的主要因素有（）- 政治因素
- 经济因素
- 社会因素
- 个人因素
多选题 (1满分)
核安全基本原则主要有（）- 管理责任
- 纵深防御
- 技术防御
- 公民参与
单选题 (1/1 point)
核安全文化的主导和核心是（）- 系统
- 设备
- 环境
- 人
多选题 (1满分)
放射性废物主要造成的危害有（）- 职业照射
- 公众照射
- 持续急性照射
- 隐性照射
多选题 (1满分)
核电站的环境影响主要包括（）- 放射性污染
- 热污染
- 内陆核电站的影响
- 硫化物污染
判断题 (1/1 point)
工程师可以代替民众进行工程决策- 正确
- 错误
第九章习题（下）
多选题 (1/1 分数)
下列哪几项属于信息技术的特点- 连接能力
- 交互能力
- 渗透特性
- 融合能力
判断题 (1/1 分数)
“互联网+”指以互联网为主的一整套信息技术在经济、社会生活各部门的扩散和应用过程，其本质是传统产业和生产过程的在线化、数据化。- 正确
- 错误
多选题 (1/1 分数)
下列哪几项属于大数据的特点- 数量大
- 类别多
- 增长速度快
- 真实可信
多选题 (1/1 分数)
大数据时代背景下，我们将面临哪些新的、更为集中的伦理挑战- 身份困境
- 隐私边界
- 数据权利
- 数据治理
判断题 (1/1 分数)
大数据与以往数据应用不同之处表现在三方面：可以获得全体数据而非采样数据；允许获取的数据呈现混乱、复杂状态而不再强求干净、精确,即大方向的正确比微观精准更重要；聚焦发现和分析事物的相关性而非因果性。- 正确
- 错误
单选题 (1/1 分数)
下列哪项不是“数字身份”的特点- 多样性
- 可变性
- 允许匿名和假名
- 唯一性
多选题 (1/1 分数)
在计算机和网络应用中，常见的用户身份管理技术有- 用户名+密码+校验码
- 第三方认证,如 U 盾
- 预存的个性化问题
- 生物特征
判断题 (1/1 分数)
人的身份(identity)，用来界定一个人是谁或是什么，具有可识别性、独特性、唯一性。- 正确
- 错误
多选题 (1/1 分数)
由于网络和信息技术的特点，保护数据隐私面临一系列技术和非技术的挑战，下列哪项属于所面临的挑战?- 可信性与可靠性
- 快速扩散性与放大器效应
- 挖掘技术与关联发现
- 身份盗窃与冒用
多选题 (1/1 分数)
大数据时代，收集个人数据包括哪些手段?- 开放API
- Web应用
- 黑客攻击
- 交易（公开或秘密）
判断题 (1/1 分数)
隐私权指自然人享有的私人生活安宁与私人信息依法受保护，不被非法侵扰、知悉、搜集、利用和公开的一种人格权.- 正确
- 错误
判断题 (1/1 分数)
要为大数据创新应用提供高质量的数据基础，必须坚持尊重、公平交易、诚信这三个价值判断原则，谨慎对待各方数据权利- 正确
- 错误
判断题 (1/1 分数)
个人信息是指与特定个人相关联的、反映个体特征的具有可识别性的符号系统,包括个人身份、工作、家庭、财产、健康等各方面的信息- 正确
- 错误
多选题 (1/1 分数)
脱胎于“家国天下”传统社会伦理的中华价值观，表现出了哪些特色- 责任先于自由
- 义务先于权利
- 群体高于个人
- 和谐高于冲突
单选题 (1/1 分数)
数据伦理责任是具有普遍意义的伦理责任在大数据时代的具体化，那么，下列哪项不属于大数据伦理责任的特点？- 自律性
- 强制性
- 广泛性
- 实践性
判断题 (1/1 分数)
大数据创新科技人员的伦理责任主要表现在尊重个人自由、 强化技术保护、严格操作规程、加强行业自律、承担社会责任这五个方面- 正确
- 错误
多选题 (1满分)
- 人际关系虚拟化
- 正当的网络行为
- 平等与公正、知识产权争议
- 全球化信息交互与治理困境
第十章习题（下）
下一个
单选题 (1/1 point)
环境工程是人类为减少工业化生产过程和人类生活过程对环境的影响进行（）的工程手段。- 政策治理
- 经济治理
- 社会治理
- 污染治理
单选题 (1/1 point)
环境问题主要是指由于人类经济和社会活动引起的环境破坏，实质是经济发展与环境保护的冲突，是（）关系的失调。- 经济与社会
- 自然与社会
- 人与自然
- 人与社会
判断题 (1/1 point)
任何物质的创造都会使用资源、消耗资源，在消耗资源的过程中必然会有废弃物的排放。（）- 正确
- 错误
判断题 (1/1 point)
由于环境工程师的工作直接涉及环境保护，相对其他工程师及非环境工作者来说，环境工程师应该负有更加特殊和更加重要的环境伦理责任。- 正确
- 错误
文字填空题 (1/1 point)
环境正义的实现应该以（）为本位，所有公民（不包括后代人和自然体）对大自然都负有环境保护的责任和义务。(四个字)
答案：环境义务单选题 (1/1 point)
现代工业生产活动是人、机器与环境共同存在、相互影响的系统，（）保证了系统的可靠。- 制度管理
- 安全生产
- 科学技术
- 应急防范
单选题 (1/1 point)
公共安全问题主要发生在公共工程运营中，是由于其（）给非工程直接利益相关的社会公众带来的安全问题。- 社会性
- 特殊性
- 风险性
- 公共性
多选题 (1满分)
工程师作为工程设计的主要承担者和执行者，下列哪些工程阶段会面临遵守职业规范和服从雇主命令之间的冲突。- 工程设计阶段
- 工程保养阶段
- 工程建造和生产阶段
- 工程维护阶段
判断题 (1满分)
在企业发生的工伤事故中，70%左右的事故在不同程度上与人的失误有关，而出现这些问题的最根本的原因是环境保护意识薄弱。（）- 正确
- 错误
PS: 实在不懂工伤事故的根本原因为什么是环境保护意识薄弱，找不到逻辑在哪？要么就是答案错了……
判断题 (1/1 point)
所有对社会有价值的存在形式都应得到尊重和保护，每个个体都会对环境产生影响并应承担相应的责任。- 正确
- 错误
单选题 (1/1 point)
企业应保持寻求自身发展与社会经济可持续发展目标的一致性，把（）纳入生产成本中。- 工程代价
- 经济代价
- 社会代价
- 环境代价
单选题 (1/1 point)
环境工程的社会责任是在（）的同时,不阻碍或促进经济的健康发展，以及保护其他社会利益。- 企业管理
- 保护环境
- 工程建设
- 社会生产
多选题 (1/1 point)
环境问题涉及哪些利益相互协调的问题？（）- 社会公共利益
- 政治利益
- 生态利益
- 经济利益
判断题 (1/1 point)
环境工程师可以通过环保工程改善环境，也可能因为采用的技术或实施过程的不合理而破坏环境。（）- 正确
- 错误
单选题 (1/1 point)
现代工程需要广阔的基础知识，因此要求环境工程师必须具备自然科学知识、社会科学知识等基础知识和较高的（）。- 环保意识
- 职业精神
- 专业知识
- 科学态度
单选题 (1/1 point)
环境工程作为调节人与人、人与社会之间关于（）利益关系的工程，其基本原则就是生态整体利益和长远利益高于一切。- 社会发展
- 生态环境
- 经济增长
- 工程管理
多选题 (1/1 point)
下列哪些行为属于不诚实的表现形式？（）- 篡改数据
- 伪造数据
- 修饰拼凑
- 抄袭剽窃
判断题 (1满分)
作为环境保护技术的主体，尽管环境工程师可以通过各种环保工程建设来影响人类社会，但宣传环保知识不属于环境工程师应该承担的责任。（）- 正确
- 错误
判断题 (1/1 point)
有意不传达听众所合理期望的不被省略的信息，是工程师的不诚实行为。（）- 正确
- 错误
最后恭喜大家完成工程伦理慕课的学习！！！
-
025-JVM-虚拟机执行代码的模式:解释执行+及时编译JIT
2020-12-23 21:54:44上一篇：024-JVM-自定义类加载器 ...hotspot什么意思，就是热点探测的意思，就是jit，探测到时热点就编译为native code ，后面再...次数超过这个值就触发及时编译！ 2.默认使用的是什么执行方式？ 混合模式： 3.个模式 -
入门学习Linux常用必会60个命令实例详解doc/txt
2011-06-09 00:08:45所以这个选项当然没有时间参数，但是可以输入一个用来解释的讯息，而这信息将会送到每位使用者。 －F：在重启计算机时强迫fsck。 －time：设定关机前的时间。 －m: 将系统改为单用户模式。 －i：关机时显示系统... -
2021年前端面试题及答案
2020-02-11 19:29:34504 Gateway Timeout 由作为代理或网关的服务器使用，表示不能及时地从远程服务器获得应答。（HTTP 1.1新）505 HTTP Version Not Supported 服务器不支持请求中所指明的HTTP版本。（HTTP 1.1新） 2 websocket和轮询... -
2019最新Web前端经典面试试题及答案-史上最全前端面试题(含答案)
2018-06-15 18:01:14解释css sprites ，如何使用？ CSS Sprites其实就是把网页中一些背景图片整合到一张图片文件中，再利用CSS的“background-image”，“background- repeat”，“background-position”的组合进行背景定位，... -
数据字典
2019-10-25 23:01:30数据字典 数据字典的概念 首先来看一下百度百科对于数据字典的定义： 数据字典是指对数据的数据项、数据结构、数据流、...这里简单解释一下： 首先我们知道，数据流图描述了系统的分解，但是没有对图中各种成分... -
2020届校招浦发银行 信息科技 创新岗 面经及历年汇总~
2019-08-18 18:43:50感觉就是面试官在人工智能这方面不太懂，所以主要是我在解释一些基础性知识 “sql会用吗”（刚刚问了一遍）“不会，不过目前的项目接下来要用，会学” “你平时做的项目主要是人脸识别，那对我们客户端有什么... -
MATLAB希尔伯特黄变换HHT
2019-07-23 20:19:16im为频谱的二维图像，tt为时间序列号（此处划重点，是“序列号”，而不是“序列”，也就是需要除以总长度得到时间序列），ff的注释解释为 “centers of the frequency bins”（频率门的中心值？）。 下面直接给出... -
测试开发需要学习的知识结构
2018-04-12 10:40:58努力成为一个优秀的测试开发从业者，加油！！！ 一些视频链接：我这有一些软件测试的视频，你可以点开看看。转行互联网测试需要哪些技能？ - 假装在测试的回答 - 知乎作为一名软件测试人员，有哪些网站是你应该多多... -
数据可视化是什么，数据可视化怎么做最好？
2019-02-21 22:11:07可视化能将不可见的数据现象转化为可见的图形符号，能将错综复杂、看起来没法解释和关联的数据，建立起联系和关联，发现规律和特征，获得更有商业价值的洞见和价值。 并且利用合适的图表直截了当且清晰而直观地... -
jvm解释执行和即时编译(编译执行)
2018-08-08 23:55:34所谓解释执行就是边翻译为机器码边执行，而即时编译就是先将一个方法中的所有字节码全部编译成机器码之后再执行。前者不需要等待编译，翻译一部分就可以执行一部分，而后者在编译完成后，实际的运行速度更快，在... -
Windows10 下 Anaconda和 PyCharm 的详细的安装教程（图文并茂）
2019-05-28 21:39:00然而，正是由于库的数量庞大，对于管理这些库以及对库作及时的维护成为既重要但复杂度又高的事情。 1、Anaconda介绍 Anaconda 指的是一个开源的 Python 发行版本，其包含了 conda、Python 等180多个科学包及其依赖项... -
python是什么-浅谈
2018-08-23 23:00:42从这点看出，python不像其他语言一样那么晦涩难懂，学习python是一种享受的过程，它能够给你带来及时的正反馈，就像你打王者荣耀一样，杀了人的快感是及时反馈给你的，绝地求生成功吃鸡的快感也是及时反馈给你的。... -
设计模式 | 解释器模式及典型应用
2019-01-13 23:47:54微信原文：设计模式 | 解释器模式及典型应用 博客原文：设计模式 | 解释器模式及典型应用 本文主要介绍解释器模式，在日常开发中，解释器模式的使用频率比较低 解释器模式 解释器模式(Interpreter Pattern)：定义一... -
杭州亚运会和亚残运会赛会志愿者
2021-09-21 20:29:321.赛会现场志愿者在服务时，以下要求不正确的是_______。 A.保持自身的中立态度，不能区别对待咨询者 B.知晓赛会场地的环境布置...C....D....[正确答案]: D 2.抵离迎送志愿者在服务时，以下要求不正确的是_______。...A....B....C....D....A.... -
【Java核心技术卷】Java的解释执行与编译执行
2019-02-28 18:23:16一、编译执行和解释执行的一些基本概念： JVM：一种能够运行Java字节码（Java bytecode）的虚拟机。（下面有更具体的JVM的内容） 字节码：字节码是已经经过编译（.class文件），但与特定机器码无关，需要解释器... -
可解释性神经网络——1.xNN
2020-07-20 17:48:03但其可解释性差也一直是令人所诟病的一点，也就是我们常说的“黑箱问题”。 例如：在识别一段话的语义情境时，计算机直接通过神经网络，给出这段话是积极的还是消极的，并且给出一个百分比作为置信度。但我们并不... -
SSM框架——详细整合教程（Spring+SpringMVC+MyBatis）
2015-03-19 11:44:55使用SSM（Spring、SpringMVC和Mybatis）已经有三个多月了，项目在技术上已经没有什么...以前解决问题的过程和方法并没有及时记录，以后在自己的小项目中遇到我再整理分享一下。这次，先说说三大框架整合过程。个人认 -
软件工程期末复习总结
2016-07-03 15:22:39）采用螺旋模型需要具有相当丰富的风险评估经验和专门知识，在风险较大的项目开发中，如果未能够及时标识风险，势必造成重大损失；（ 2 ）过多的迭代次数会增加开发成本，延迟提交时间。 螺旋模型的使用范围： ... -
电子商务之部分名词解释
2020-01-03 17:47:25电子商务——部分名词解释 目录 电子商务——部分名词解释 （1）电子商务 （2）企业资源计划ERP （3）管理信息系统 （4）人力资源管理 （5）客户关系管理 （6）供应链管理 （7）认证机构 （8）数字证书 ... -
Java、Python分别是解释型还是编译型语言？
2017-01-03 18:28:17python 解释型（函数写在调用前） java 编译型（请求次数多）+解释型（请求次数少） 解释性语言定义： 程序不需要编译，在运行程序的时候才翻译，每个语句都是执行的时候才翻译。这样解释性语言每执行一次就需要逐行... -
基于物品的协同过滤算法实现图书推荐系统
2019-09-14 21:20:245)在python的标准库中，含有多个模块来实现具体的功能，这些几乎包含了所有与操作系统解释器的交互的功能，也就是Python使用者不用手动人工造轮子，因为这些模块可以直接用于已经完全测试过的功能开发。这些已经被... -
JVM解释器和编译器
2019-02-16 17:07:11许多人认为Java是一门解释执行的语言，由虚拟机解释执行class文件字节码。事实是Java是一门解释执行和编译执行并存的语言。JVM解释器让Java程序快速启动，编译器让Java程序高效运行，这是Java长久生存的一大重要原因... -
前端名词解释（持续更新）
2017-04-26 21:53:02前端名词解释 前端名词解释 名词：HTML 解释： HTML 是用来描述网页的一种语言。 HTML拥有很多标签入等。 HTML文档 = 网页，HTML文档包含“标签”和“纯文本”。 HTML的结构决定这个页面稳不稳定，规... -
各种测试名词解释
2020-03-29 15:43:59敏捷测试：敏捷开发的最大特点是高度迭代，有周期性，并且能够及时、持续地响应客户的频繁反馈 灰度测试：灰度测试就是指如果软件要在不久的将来推出一个全新的功能，或者做一次比较重大的改版的话，要先进行一个小... -
操作系统——名词解释
2019-09-14 20:24:59第一章 操作系统引论 操作系统：是一组能有效地组织和管理计算机硬件和软件资源，合理地对各类作业进行调度... 实时系统：是指系统能及时响应外部事件的请求，在规定的时间内完成对该事件的处理，并控制所有实时任... -
python解释型语言的说明
2018-04-22 00:51:26为什么称python为解释型语言？为什么python相比C执行会慢？什么是解释型语言？Python 是怎么实现动态类型的呢？从小白的角度来解释这些问题。首先，大部分语言为编译型或解释型，如C/C++等为编译型，python为解释型...
