20145238 —《Java程序设计》—第5周学习总结
20145238 《Java程序设计》第5周学习总结
教材学习内容总结
第八章异常处理
8.1.1使用try、catch
·教材范例用户连续输入整数，输入0结束后显示输入数的平均值(代码如下)
import java.util.Scanner;
public class Average {
public static void main(String[] args) {
Scanner console = new Scanner(System.in);
double sum = 0;
int count = 0;
while(true) {
int number = console.nextInt();
if(number == 0) {
break;
}
sum += number;
count++;
}
System.out.printf("平均 %.2f%n", sum / count);
}
}
·运行结果如下：
·如果用户不小心将30输入为3o则会出现如下结果
原因是Scanner对象nextInt（）方法将用户输入的下一字符串直接定义为int型，，不符合对象预期，因此本章同学try以及catch代表错误对象后做一些处理。
import java.util.*;
public class Average2 {
public static void main(String[] args) {
try {
Scanner console = new Scanner(System.in);
double sum = 0;
int count = 0;
while (true) {
int number = console.nextInt();
if (number == 0) {
break;
}
sum += number;
count++;
}
System.out.printf("平均 %.2f%n", sum / count);
} catch (InputMismatchException ex) {
System.out.println("必須輸入整數");
}
}
}
·运行结果如下：
若输入30错为3o则运行结果如下：
·若nextInt发生了(InputMismatchException ex)的错误，执行流程就会跳到catch区块，还可继续下一个循环流程：
·运行结果如下：
·若编程过程中出现了“unrepored exception IOException must be Caught or declare to be thrown···”
解决：使用try、catch打包System.in.read（），声明throws java.io.IOException。
·使用
public class Average4 {
public static void main(String[] args) {
double sum = 0;
int count = 0;
while(true) {
int number = nextInt();
if(number == 0) {
break;
}
sum += number;
count++;
}
System.out.printf("平均 %.2f%n", sum / count);
}
static Scanner console = new Scanner(System.in);
static int nextInt() {
String input = console.next();
while(!input.matches("\\d*")) {
System.out.println("請輸入數字");
input = console.next();
}
return Integer.parseInt(input);
}
}
·如果父类异常对象在子类异常前被捕捉，则catch子类异常对象的区块将永远不会被执行。
·catch括号中列出的异常不得有继承关系，否则会发生编译错误。
·在catch区块进行完部分错误处理之后，可以使用throw（注意不是throws）将异常再抛出。如：
import java.io.*;
import java.util.Scanner;
public class FileUtil {
public static String readFile(String name) throws FileNotFoundException {
StringBuilder text = new StringBuilder();
try {
Scanner console = new Scanner(new FileInputStream(name));
while(console.hasNext()) {
text.append(console.nextLine())
.append('\n');
}
} catch (FileNotFoundException ex) {
ex.printStackTrace();
throw ex;
}
return text.toString();
}
}
·操作对象异常无法使用try、catch处理时，可由方法的客户端一句当时调用的环节信息进行处理，使用throw声明会抛出的异常类型或父类。
·如果使用继承时，父类某个方法声明throws某些异常，子类重新定义该方法时可以：不声明throws任何异常。throws父类该方法中声明的某些异常。throws父类该方法中声明异常的子类。
throws父类方法中未声明的其他异常。throws父类方法中声明异常的父类。在多重方法调用下，异常发生点可能是在某个方法之中，若想得知异常发生的根源，以及多重方法调用下的堆栈传播，可以利用异常对象自动收集的堆栈追踪来取得相关信息，例如调用异常对象的printStackTrace()。
public class StackTraceDemo {
public static void main(String[] args) {
try {
c();
} catch(NullPointerException ex) {
ex.printStackTrace();
}
}
static void c() {
b();
}
static void b() {
a();
}
static String a() {
String text = null;
return text.toUpperCase();
}
}
·在使用throw重抛异常时，异常的追踪堆栈起点，仍是异常的发生根源，而不是重抛异常的地方！
public class StackTraceDemo2 {
public static void main(String[] args) {
try {
c();
} catch(NullPointerException ex) {
ex.printStackTrace();
}
}
static void c() {
try {
b();
} catch(NullPointerException ex) {
ex.printStackTrace();
throw ex;
}
}
static void b() {
a();
}
static String a() {
String text = null;
return text.toUpperCase();
}
}
·如果想要让异常堆栈七点为重抛异常的地方，可以使用fillInstackTrance（）方法:
public class StackTraceDemo3 {
public static void main(String[] args) {
try {
c();
} catch(NullPointerException ex) {
ex.printStackTrace();
}
}
static void c() {
try {
b();
} catch(NullPointerException ex) {
ex.printStackTrace();
Throwable t = ex.fillInStackTrace();
throw (NullPointerException) t;
}
}
static void b() {
a();
}
static String a() {
String text = null;
return text.toUpperCase();
}
}
·何时使用断点？
断言客户端调用方法前，已经准备好某些前置条件（通常在private方法之中）
断言客户端调用方法后，具有方法承诺的结果。
断言对象某个时间点下的状态。
使用断言取代批注。
断言程序流程中绝对不会执行到的程序代码部分。
8.2
FileUtil中通过Scanner搭配FileInputStream来读取文档，实际上Scanner对象有close方法，可以关闭Scanner相关资源与搭配的FileInputSream.断言是判定程序中的某个执行点必然是或不是某个状态，所以不能当作像if之类的判断式来使用，assert不应当作程序执行流程的一部分。
若想最后一定要执行关闭资源的动作，try、catch语法可以搭配finally，无论try区块中有无发生异常，若撰写有finally区块，则finally区块一定会被执行。
import java.io.*;
import java.util.Scanner;
public class FileUtil {
public static String readFile(String name) throws FileNotFoundException {
StringBuilder text = new StringBuilder();
Scanner console = null;
try {
console = new Scanner(new FileInputStream(name));
while (console.hasNext()) {
text.append(console.nextLine())
.append('\n');
}
} finally {
if(console != null) {
console.close();
}
}
return text.toString();
}
}
·若程序撰写先return。而且有finally区块，那么这个区块会先执行，然后再讲返回值返回。
public class FinallyDemo {
public static void main(String[] args) {
System.out.println(test(true));
}
static int test(boolean flag) {
try {
if(flag) {
return 1;
}
} finally {
System.out.println("finally...");
}
return 0;
}
}
·尝试关闭资源语法：想要尝试自动关闭资源的对象，是撰写在try之后的括号中，如果无须catch处理任何异常，可以不用撰写，也不用撰写finally自行尝试关闭资源。
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class FileUtil2 {
public static String readFile(String name) throws FileNotFoundException {
StringBuilder text = new StringBuilder();
try(Scanner console = new Scanner(new FileInputStream(name))) {
while (console.hasNext()) {
text.append(console.nextLine())
.append('\n');
}
}
return text.toString();
}
}
·尝试关闭资源语法可套用的对象，必须操作java.lang.AutoCloseable接口
public class AutoClosableDemo {
public static void main(String[] args) {
try(Resource res = new Resource()) {
res.doSome();
} catch(Exception ex) {
ex.printStackTrace();
}
}
}
class Resource implements AutoCloseable {
void doSome() {
System.out.println("作一些事");
}
@Override
public void close() throws Exception {
System.out.println("資源被關閉");
}
}
·尝试关闭资源语法也可以同时关闭两个以上的对象资源，只要中间以分号分隔
import static java.lang.System.out;
public class AutoClosableDemo2 {
public static void main(String[] args) {
try(ResourceSome some = new ResourceSome();
ResourceOther other = new ResourceOther()) {
some.doSome();
other.doOther();
} catch(Exception ex) {
ex.printStackTrace();
}
}
}
class ResourceSome implements AutoCloseable {
void doSome() {
out.println("作一些事");
}
@Override
public void close() throws Exception {
out.println("資源Some被關閉");
}
}
class ResourceOther implements AutoCloseable {
void doOther() {
out.println("作其它事");
}
@Override
public void close() throws Exception {
out.println("資源Other被關閉");
}
}
第九章Collection与Map
9.1
·JavaSE中提供了满足各种需求的API，收集对象的行为，都定义在java.collection中，既能收集对象也能驱逐对象。
·如果手机是具有索引顺序，可以使用数组。
·List是一种Collection，作用是收集对象，并以索引的方式保留手机的对象顺序
import java.util.Arrays;
public class ArrayList<E> {
private Object[] elems;
private int next;
public ArrayList(int capacity) {
elems = new Object[capacity];
}
public ArrayList() {
this(16);
}
public void add(E e) {
if(next == elems.length) {
elems = Arrays.copyOf(elems, elems.length * 2);
}
elems[next++] = e;
}
public E get(int index) {
return (E) elems[index];
}
public int size() {
return next;
}
}
·ArrayListArrayList特性：数组在内存中会是连续的线性空间，根据索引随机存取时速度快，如果操作上有这类需求时，像是排序，就可使用ArrayList，可得到较好的速度表现。
·LinkedList在操作List接口时，采用了链接（Link）结构。
public class SimpleLinkedList {
private class Node {
Node(Object o) {
this.o = o;
}
Object o;
Node next;
}
private Node first;
public void add(Object elem) {
Node node = new Node(elem);
if(first == null) {
first = node;
}
else {
append(node);
}
}
private void append(Node node) {
Node last = first;
while(last.next != null) {
last = last.next;
}
last.next = node;
}
public int size() {
int count = 0;
Node last = first;
while(last != null) {
last = last.next;
count++;
}
return count;
}
public Object get(int index) {
checkSize(index);
return findElemOf(index);
}
private void checkSize(int index) throws IndexOutOfBoundsException {
int size = size();
if(index >= size) {
throw new IndexOutOfBoundsException(
String.format("Index: %d, Size: %d", index, size));
}
}
private Object findElemOf(int index) {
int count = 0;
Node last = first;
while(count < index) {
last = last.next;
count++;
}
return last.elem;
}
}
·在收集过程中若有相同对象，则不再重复收集，如果有这类需求，可以使用Set接口的操作对象。
import java.util.*;
public class WordCount {
public static void main(String[] args) {
Scanner console = new Scanner(System.in);
System.out.print("請輸入英文：");
Set words = tokenSet(console.nextLine());
System.out.printf("不重複單字有 %d 個：%s%n", words.size(), words);
}
static Set tokenSet(String line) {
String[] tokens = line.split(" ");
return new HashSet(Arrays.asList(tokens));
}
}
·HashSet的操作概念是，在内存中开设空间，每个空间会有个哈希编码。;Queue继承自Collection，所以也具有Collection的add()、remove()、element()等方法，然而Queue定义了自己的offer()、poll()与peek()等方法，最主要的差别之一在于：add()、remove()、element()等方法操作失败时会抛出异常，而offer()、poll()与peek()等方法操作失败时会返回特定值。
;如果对象有操作Queue，并打算以队列方式使用，且队列长度受限，通常建议使用offer()、poll()与peek()等方法。LinkedList不仅操作了List接口，与操作了Queue的行为，所以可以将LinkedList当作队列来使用。
import java.util.*;
interface Request {
void execute();
}
public class RequestQueue {
public static void main(String[] args) {
Queue requests = new LinkedList();
offerRequestTo(requests);
process(requests);
}
static void offerRequestTo(Queue requests) {
// 模擬將請求加入佇列
for (int i = 1; i < 6; i++) {
Request request = new Request() {
public void execute() {
System.out.printf("處理資料 %f%n", Math.random());
}
};
requests.offer(request);
}
}
// 處理佇列中的請求
static void process(Queue requests) {
while(requests.peek() != null) {
Request request = (Request) requests.poll();
request.execute();
}
}
}
·运行结果如下：
·使用ArrayDeque来操作容量有限的堆栈：
import java.util.*;
import static java.lang.System.out;
public class Stack {
private Deque elems = new ArrayDeque();
private int capacity;
public Stack(int capacity) {
this.capacity = capacity;
}
public boolean push(Object elem) {
if(isFull()) {
return false;
}
return elems.offerLast(elem);
}
private boolean isFull() {
return elems.size() + 1 > capacity;
}
public Object pop() {
return elems.pollLast();
}
public Object peek() {
return elems.peekLast();
}
public int size() {
return elems.size();
}
public static void main(String[] args) {
Stack stack = new Stack(5);
stack.push("Justin");
stack.push("Monica");
stack.push("Irene");
out.println(stack.pop());
out.println(stack.pop());
out.println(stack.pop());
}
}
·运行结果如下：
·队列的前端与尾端进行操作，在前端加入对象与取出对象，在尾端加入对象与取出对象，Queue的子接口Deque就定义了这类行为；java.util.ArrayDeque操作了Deque接口，可以使用ArrayDeque来操作容量有限的堆栈。泛型语法：类名称旁有角括号<>，这表示此类支持泛型。实际加入的对象是客户端声明的类型
import java.util.Arrays;
public class ArrayList<E> {
private Object[] elems;
private int next;
public ArrayList(int capacity) {
elems = new Object[capacity];
}
public ArrayList() {
this(16);
}
public void add(E e) {
if(next == elems.length) {
elems = Arrays.copyOf(elems, elems.length * 2);
}
elems[next++] = e;
}
public E get(int index) {
return (E) elems[index];
}
public int size() {
return next;
}
}
·匿名类语法来说，Lambda表达式的语法省略了接口类型与方法名称，->左边是参数列，而右边是方法本体；在Lambda表达式中使用区块时，如果方法必须有返回值，在区块中就必须使用return。interator()方法提升至新的java.util.Iterable父接口。
·Collections的sort（）方法要求被排序的对象必须操作java.lang.Comparable接口，这个接口有个compareTo（）方法必须返回大于0、等于0或小于0的数；Collections的sort（）方法有另一个重载版本，可接受java.util.Comparator接口的操作对象，如果使用这个版本，排序方式将根据Comparator的compare（）定义来决定。
import java.util.*;
class StringComparator implements Comparator<String>
{
@Override
public int compare(String s1, String s2)
{
return -s1.compareTo(s2);
}
}
public class Sort5
{
public static void main(String[] args)
{
List<String> words = Arrays.asList("B", "X", "A", "M", "F", "W", "O");
Collections.sort(words, new StringComparator());
System.out.println(words);
}
}
·收集对象并进行排序；
import java.util.*;
public class Sort {
public static void main(String[] args) {
List numbers = Arrays.asList(10, 2, 3, 1, 9, 15, 4);
Collections.sort(numbers);
System.out.println(numbers);
}
}
·程序运行截图；
·程序2
import java.util.*;
class Account {
private String name;
private String number;
private int balance;
Account(String name, String number, int balance) {
this.name = name;
this.number = number;
this.balance = balance;
}
@Override
public String toString() {
return String.format("Account(%s, %s, %d)", name, number, balance);
}
}
public class Sort2 {
public static void main(String[] args) {
List accounts = Arrays.asList(
new Account("Justin", "X1234", 1000),
new Account("Monica", "X5678", 500),
new Account("Irene", "X2468", 200)
);
Collections.sort(accounts);
System.out.println(accounts);
}
}
·程序运行结果：
解决方法
1.操作Comparable
import java.util.*;
class Account2 implements Comparable<Account2> {
private String name;
private String number;
private int balance;
Account2(String name, String number, int balance) {
this.name = name;
this.number = number;
this.balance = balance;
}
@Override
public String toString() {
return String.format("Account2(%s, %s, %d)", name, number, balance);
}
@Override
public int compareTo(Account2 other) {
return this.balance - other.balance;
}
}
public class Sort3 {
public static void main(String[] args) {
List accounts = Arrays.asList(
new Account2("Justin", "X1234", 1000),
new Account2("Monica", "X5678", 500),
new Account2("Irene", "X2468", 200)
);
Collections.sort(accounts);
System.out.println(accounts);
}
}
2.操作Comparator
import java.util.*;
public class Sort4 {
public static void main(String[] args) {
List words = Arrays.asList("B", "X", "A", "M", "F", "W", "O");
Collections.sort(words);
System.out.println(words);
}
}
·在java的规范中，与顺序有关的行为，通常要不对象本身是Comparable，要不就是另行指定Comparator对象告知如何排序；若要根据某个键来取得对应的值，可以事先利用java.util.Map接口的操作对象来建立键值对应数据，之后若要取得值，只要用对应的键就可以迅速取得。常用的Map操作类为java.util.HashMap与java.util.TreeMap，其继承自抽象类java.util.AbstractMap。
·Map也支持泛型语法，如使用HashMap的范例：
import java.util.*;
import static java.lang.System.out;
public class Messages
{
public static void main(String[] args)
{
Map<String, String> messages = new HashMap<>();
messages.put("Justin", "Hello！Justin的訊息！");
messages.put("Monica", "給Monica的悄悄話！");
messages.put("Irene", "Irene的可愛貓喵喵叫！");
Scanner console = new Scanner(System.in);
out.print("取得誰的訊息：");
String message = messages.get(console.nextLine());
out.println(message);
out.println(messages);
}
}
·如果使用TreeMap建立键值对应，则键的部分则会排序，条件是作为键的对象必须操作Comparable接口，或者是在创建TreeMap时指定操作Comparator接口的对象。如：
import java.util.*;
public class Messages2
{
public static void main(String[] args)
{
Map<String, String> messages = new TreeMap<>();
messages.put("Justin", "Hello！Justin的訊息！");
messages.put("Monica", "給Monica的悄悄話！");
messages.put("Irene", "Irene的可愛貓喵喵叫！");
System.out.println(messages);
}
}
Properties类继承自Hashtable，HashTable操作了Map接口，Properties自然也有Map的行为。虽然也可以使用put（）设定键值对应、get（）方法指定键取回值，不过一般常用Properties的setProperty（）指定字符串类型的键值，getProperty（）指定字符串类型的键，取回字符串类型的值，通常称为属性名称与属性值。
·如果想取得Map中所有的键，可以调用Map的keySet（）返回Set对象。由于键是不重复的，所以用Set操作返回是理所当然的做法，如果想取得Map中所有的值，则可以使用values（）返回Collection对象。如：
import java.util.*;
import static java.lang.System.out;
public class MapKeyValue
{
public static void main(String[] args)
{
Map<String, String> map = new HashMap<>();
map.put("one", "一");
map.put("two", "二");
map.put("three", "三");
out.println("顯示鍵");
map.keySet().forEach(key -> out.println(key));
out.println("顯示值");
map.values().forEach(key -> out.println(key));
}
}
·如果想同时取得Map的键与值，可以使用entrySet（）方法，这会返回一个Set对象，每个元素都是Map.Entry实例。可以调用getKey（）取得键，调用getValue（）取得值。如：
import java.util.*;
public class MapKeyValue2
{
public static void main(String[] args)
{
Map<String, String> map = new TreeMap<>();
map.put("one", "一");
map.put("two", "二");
map.put("three", "三");
foreach(map.entrySet());
}
static void foreach(Iterable<Map.Entry<String, String>> iterable)
{
for(Map.Entry<String, String> entry: iterable)
{
System.out.printf("(鍵 %s, 值 %s)%n",
entry.getKey(), entry.getValue());
}
}
}
教材学习中的问题和解决过程
第八章的学习是异常处理，就是我们平时编程过程中会出现的小问题都有了详细的解答。通过本章的学习我知道了使用try、catch语法，JVM会尝试tyr中的代码如果错误便能跳过错误点，比对catch中声明的类型；
并且还了解了很多模块问题出现问题所提示的结果显示，以后的编程中可能会有各种各样的问题，但通过本章的学习了解到了很多问题出现的原因，下次编程若出现，便可以很快地检查对应区域代码，收获颇多。
代码调试中的问题和解决过程
代码调试问题和解决在上个片段以及说明。
其他（感悟、思考等，可选）
前几章大量的敲代码工作让同学们的学习都留于形式，只想着完成作业而对代码的理解少之又少。又认真参考了娄老师积极主动敲代码这篇博客，感觉学好java的方法不是“敲”代码，而是“修改”代码，敲好代码以后如果不理解代码的能，可以通过修改代码来具体体会其真正含义。
进步来源于发现问题和解决问题，如果大家不去主动思考，简单机械的完成作业，那学习便失去了意义。
代码托管
学习进度条
| 代码行数（新增/累积） | 博客量（新增/累积） | 学习时间（新增/累积） | 重要成长 | |
|---|---|---|---|---|
| 目标 | 5000行 | 30篇 | 400小时 | |
| 第一周 | 200/200 | 2/2 | 20/20 | |
| 第二周 | 300/500 | 2/4 | 18/38 | |
| 第三周 | 500/1000 | 3/7 | 22/60 | |
| 第四周 | 300/1300 | 2/9 | 30/90 |
参考资料
20145238 —《Java程序设计》—第5周学习总结的更多相关文章
- 20145238-荆玉茗 《Java程序设计》第一周学习总结
20145238 <Java程序设计>第一周学习总结 教材学习内容总结 Java三大平台:由于java领域的应用越来越广,根据不同级别的应用开发区分了不同的应用版本,后正式更名为Java ...
- 20145213《Java程序设计》第九周学习总结
20145213<Java程序设计>第九周学习总结 教材学习总结 "五一"假期过得太快,就像龙卷风.没有一点点防备,就与Java博客撞个满怀.在这个普天同庆的节日里,根 ...
- 20145213《Java程序设计》第二周学习总结
20145213<Java程序设计>第二周学习总结 教材学习内容总结 本周娄老师给的任务是学习教材的第三章--基础语法.其实我觉得还蛮轻松的,因为在翻开厚重的书本,一股熟悉的气息扑面而来, ...
- 20145213《Java程序设计》第一周学习总结
20145213<Java程序设计>第一周学习总结 教材学习内容总结 期待了一个寒假,终于见识到了神秘的娄老师和他的Java课.虽说算不上金风玉露一相逢,没有胜却人间无数也是情理之中,但娄 ...
- 21045308刘昊阳 《Java程序设计》第九周学习总结
21045308刘昊阳 <Java程序设计>第九周学习总结 教材学习内容总结 第16章 整合数据库 16.1 JDBC入门 16.1.1 JDBC简介 数据库本身是个独立运行的应用程序 撰 ...
- 20145330孙文馨 《Java程序设计》第一周学习总结
20145330孙文馨 <Java程序设计>第一周学习总结 教材学习内容总结 刚开始拿到这么厚一本书说没有压力是不可能的,开始从头看觉得很陌生进入不了状态,就稍微会有一点焦虑的感觉.于是就 ...
- 20145337 《Java程序设计》第九周学习总结
20145337 <Java程序设计>第九周学习总结 教材学习内容总结 数据库本身是个独立运行的应用程序 撰写应用程序是利用通信协议对数据库进行指令交换,以进行数据的增删查找 JDBC可以 ...
- 20145337 《Java程序设计》第二周学习总结
20145337 <Java程序设计>第二周学习总结 教材学习内容总结 Java可分基本类型与类类型: 基本类型分整数(short.int.long).字节(byte).浮点数(float ...
- 20145218《Java程序设计》第一周学习总结
20145218 <Java程序设计>第一周学习总结 教材学习内容总结 今天下午看了Java学习的视频,感觉很是新奇,之前觉得Java学起来是艰难枯燥的,但通过第一章的学习觉得如果自己可以 ...
- 《Java程序设计》第九周学习总结
20145224 <Java程序设计>第九周学习总结 第十六章 整合数据库 JDBC入门 ·数据库本身是个独立运行的应用程序 ·撰写应用程序是利用通信协议对数据库进行指令交换,以进行数据的 ...
随机推荐
- linux下lua运行环境安装
1.下载安装包: [root@H0f ~]# wget http://www.lua.org/ftp/lua-5.2.4.tar.gz http://www.lua.org/ftp/lua-5 ...
- 转 python中%s与%d
https://blog.csdn.net/SuperCreators/article/details/81393977 pythn print格式化输出. %r 用来做 debug 比较好,因为它会 ...
- 转 [Error]EOL while scanning string literal
https://blog.csdn.net/orangleliu/article/details/38943749 项目中有个定时任务,每天取到一些表数据传到一个外部接口,但是最近总是有异常,今天查了 ...
- git使用标准
git 使用规范 团队开发中,要遵循一个合理.清晰的git使用流程非常重要的.否则每个人提交一堆杂乱我长的commit,项目很快就变得难以协调和维护 第一步:创建新分支 首先,每一次开发新功能,都应该 ...
- Linux配置SSH免密码登录
CentOS配置SSH免密码登录为例说明:SSH远程登录的安全外壳协议有两种身份认证机制: - 用户名+密码 -密钥登录 环境准备 host1:192.168.0.10host2:192.168.0. ...
- springMVC初探视图解析器——InternalResourceViewResolver
springmvc在处理器方法中通常返回的是逻辑视图,如何定位到真正的页面,就需要通过视图解析器. springmvc里提供了多个视图解析器,InternalResourceViewResolver就 ...
- Django开发常见问题
1.Django设置中文,和时区.静态文件指向 #========================================================== # 设置时区 注意注释上面的:L ...
- dict 增删改查
# dict # 数据类型划分: 可变数据类型,不可变数据类型 # 不可变数据类型: 元组 bool int str set (又被称为可哈希) # 可变数据类型: list dict (又被称为不可 ...
- python 获取当前时间及前一天时间
import datetime from pandas.tseries.offsets import Day now_time =datetime.datetime.now()#获取当前时间 yes_ ...
- sqlserver 2012 部署详解
01,下载 官网下载: https://www.microsoft.com/zh-cn/download/details.aspx?id=29066 02,安装 检查系统环境配置 成功了就继续,其他的 ...