Java集合面试题
 
Java 集合框架的基础接口有哪些？
 
Collection ，为集合层级的根接口。一个集合代表一组对象，这些对象即为它的元素。Java 平台不提供这个接口任何直接的实现。 
  
Set ，是一个不能包含重复元素的集合。这个接口对数学集合抽象进行建模，被用来代表集合，就如一副牌。
List ，是一个有序集合，可以包含重复元素。你可以通过它的索引来访问任何元素。List 更像长度动态变换的数组。
 
Map ，是一个将 key 映射到 value 的对象。一个 Map 不能包含重复的 key，每个 key 最多只能映射一个 value 。
一些其它的接口有 Queue、Dequeue、SortedSet、SortedMap 和 ListIterator 。
 
? 为何 Collection 不从 Cloneable 和 Serializable 接口继承？
 
Collection 接口指定一组对象，对象即为它的元素。
 
如何维护这些元素由 Collection 的具体实现决定。例如，一些如 List 的 Collection 实现允许重复的元素，而其它的如 Set 就不允许。
很多 Collection 实现有一个公有的 clone 方法。然而，把它放到集合的所有实现中也是没有意义的。这是因为 Collection 是一个抽象表现，重要的是实现。
 
当与具体实现打交道的时候，克隆或序列化的语义和含义才发挥作用。所以，具体实现应该决定如何对它进行克隆或序列化，或它是否可以被克隆或序列化。在所有的实现中授权克隆和序列化，最终导致更少的灵活性和更多的限制，特定的实现应该决定它是否可以被克隆和序列化。
 
为何 Map 接口不继承 Collection 接口？
 
尽管 Map 接口和它的实现也是集合框架的一部分，但 Map 不是集合，集合也不是 Map。因此，Map 继承 Collection 毫无意义，反之亦然。
 
如果 Map 继承 Collection 接口，那么元素去哪儿？Map 包含 key-value 对，它提供抽取 key 或 value 列表集合( Collection )的方法，但是它不适合“一组对象”规范。
 
? 为何 Map 接口不继承 Collection 接口？
 
尽管 Map 接口和它的实现也是集合框架的一部分，但 Map 不是集合，集合也不是 Map。因此，Map 继承 Collection 毫无意义，反之亦然。
 
如果 Map 继承 Collection 接口，那么元素去哪儿？Map 包含 key-value 对，它提供抽取 key 或 value 列表集合( Collection )的方法，但是它不适合“一组对象”规范。
 
? Collection 和 Collections 的区别？
 
Collection ，是集合类的上级接口，继承与他的接口主要有 Set 和List 。
Collections ，是针对集合类的一个工具类，它提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
 
? 集合框架里实现的通用算法有哪些？
 
Java 集合框架提供常用的算法实现，比如排序和搜索。
 
Collections类包含这些方法实现。大部分算法是操作 List 的，但一部分对所有类型的集合都是可用的。部分算法有排序、搜索、混编、最大最小值。
 
? 集合框架底层数据结构总结
 
1）List
 
ArrayList ：Object 数组。
Vector ：Object 数组。
LinkedList ：双向链表(JDK6 之前为循环链表，JDK7 取消了循环)。
 
2）Map
 
HashMap ： 
  
JDK8 之前，HashMap 由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。
JDK8 以后，在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为 8 ）时，将链表转化为红黑树，以减少搜索时间。
 
LinkedHashMap ：LinkedHashMap 继承自 HashMap，所以它的底层仍然是基于拉链式散列结构即由数组和链表或红黑树组成。另外，LinkedHashMap 在上面结构的基础上，增加了一条双向链表，使得上面的结构可以保持键值对的插入顺序。同时通过对链表进行相应的操作，实现了访问顺序相关逻辑。详细可以查看：《LinkedHashMap 源码详细分析（JDK1.8）》 。
Hashtable ：数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的。
TreeMap ：红黑树（自平衡的排序二叉树）。
 
3）Set
 
HashSet ：无序，唯一，基于 HashMap 实现的，底层采用 HashMap 来保存元素。
LinkedHashSet ：LinkedHashSet 继承自 HashSet，并且其内部是通过 LinkedHashMap 来实现的。有点类似于我们之前说的LinkedHashMap 其内部是基于 HashMap 实现一样，不过还是有一点点区别的。
TreeSet ：有序，唯一，红黑树(自平衡的排序二叉树)。
 
什么是迭代器(Iterator)？
 
Iterator 接口，提供了很多对集合元素进行迭代的方法。每一个集合类都包含了可以返回迭代器实例的迭代方法。迭代器可以在迭代的过程中删除底层集合的元素，但是不可以直接调用集合的 #remove(Object Obj) 方法删除，可以通过迭代器的 #remove() 方法删除。
 
? Iterator 和 ListIterator 的区别是什么？
 
Iterator 可用来遍历 Set 和 List 集合，但是 ListIterator 只能用来遍历 List。
Iterator 对集合只能是前向遍历，ListIterator 既可以前向也可以后向。
ListIterator 实现了 Iterator 接口，并包含其他的功能。比如：增加元素，替换元素，获取前一个和后一个元素的索引等等。
 
? 快速失败（fail-fast）和安全失败（fail-safe）的区别是什么？
 
差别在于 ConcurrentModification 异常：
 
快速失败：当你在迭代一个集合的时候，如果有另一个线程正在修改你正在访问的那个集合时，就会抛出一个 ConcurrentModification 异常。 在 java.util 包下的都是快速失败。
安全失败：你在迭代的时候会去底层集合做一个拷贝，所以你在修改上层集合的时候是不会受影响的，不会抛出 ConcurrentModification 异常。在 java.util.concurrent 包下的全是安全失败的。
 
? 如何删除 List 中的某个元素？
 
有两种方式，分别如下：
 
方式一，使用 Iterator ，顺序向下，如果找到元素，则使用 remove 方法进行移除。
方式二，倒序遍历 List ，如果找到元素，则使用 remove 方法进行移除。
 
? Enumeration 和 Iterator 接口有什么不同？
 
Enumeration 跟 Iterator 相比较快两倍，而且占用更少的内存。
但是，Iterator 相对于 Enumeration 更安全，因为其他线程不能修改当前迭代器遍历的集合对象。同时，Iterators 允许调用者从底层集合中移除元素，这些 Enumerations 都没法完成。
 
对于很多胖友，可能并未使用过 Enumeration 类，所以可以看看 《Java Enumeration 接口》 文章。
 
? 为何 Iterator 接口没有具体的实现？
 
Iterator 接口，定义了遍历集合的方法，但它的实现则是集合实现类的责任。每个能够返回用于遍历的 Iterator 的集合类都有它自己的 Iterator 实现内部类。
 
这就允许集合类去选择迭代器是 fail-fast 还是 fail-safe 的。比如，ArrayList 迭代器是 fail-fast 的，而 CopyOnWriteArrayList 迭代器是 fail-safe 的。
 
Comparable 和 Comparator 的区别?
 
Comparable 接口，在 java.lang 包下，用于当前对象和其它对象的比较，所以它有一个 #compareTo(Object obj) 方法用来排序，该方法只有一个参数。
Comparator 接口，在 java.util 包下，用于传入的两个对象的比较，所以它有一个 #compare(Object obj1, Object obj2) 方法用来排序，该方法有两个参数。
 
详细的，可以看看 《Java 自定义比较器》 文章，重点是如何自己实现 Comparable 和 Comparator 的方法。
 
? compareTo 方法的返回值表示的意思？
 
大于 0 ，表示对象大于参数对象。
小于 0 ，表示对象小于参数对象
等于 0 ，表示两者相等。
 
? 如何对 Object 的 List 排序？
 
对 Object[] 数组进行排序时，我们可以用 Arrays#sort(...) 方法。
对 List<Object> 数组进行排序时，我们可以用 Collections#sort(...) 方法。
 
有哪些关于 Java 集合框架的最佳实践？
 
基于应用的需求来选择使用正确类型的集合，这对性能来说是非常重要的。例如，如果元素的大小是固定的，并且知道优先级，我们将会使用一个 Array ，而不是 ArrayList 。
一些集合类允许我们指定他们的初始容量。因此，如果我们知道存储数据的大概数值，就可以避免重散列或者大小的调整。
总是使用泛型来保证类型安全，可靠性和健壮性。同时，使用泛型还可以避免运行时的 ClassCastException 异常。
在 Map 中使用 JDK 提供的不可变类作为一个 key，这样可以避免 hashcode 的实现和我们自定义类的 equals 方法。
应该依照接口而不是实现来编程。
返回零长度的集合或者数组，而不是返回一个 null ，这样可以防止底层集合是空的。
 
区别
 
List 和 Set 区别？
 
List，Set 都是继承自 Collection 接口。
 
List 特点：元素有放入顺序，元素可重复。
Set 特点：元素无放入顺序，元素不可重复，重复元素会覆盖掉。
 
 
 
注意：元素虽然无放入顺序，但是元素在 Set 中的位置是有该元素的 hashcode 决定的，其位置其实是固定的。
 
 
另外 List 支持 for 循环，也就是通过下标来遍历，也可以用迭代器，但是 Set 只能用迭代，因为他无序，无法用下标来取得想要的值。
 
 
Set 和 List 对比：
 
Set：检索元素效率高，删除和插入效率低，插入和删除不会引起元素位置改变。
List：和数组类似，List 可以动态增长，查找元素效率低，插入删除元素效率，因为可能会引起其他元素位置改变。
 
List 和 Map 区别？
 
List 是对象集合，允许对象重复。
Map 是键值对的集合，不允许 key 重复。
 
Array 和 ArrayList 有何区别？什么时候更适合用 Array？
 
Array 可以容纳基本类型和对象，而 ArrayList 只能容纳对象。
Array 是指定大小的，而 ArrayList 大小是固定的，可自动扩容。
Array 没有提供 ArrayList 那么多功能，比如 addAll、removeAll 和 iterator 等。
 
尽管 ArrayList 明显是更好的选择，但也有些时候 Array 比较好用，比如下面的三种情况。
 
1、如果列表的大小已经指定，大部分情况下是存储和遍历它们
2、对于遍历基本数据类型，尽管 Collections 使用自动装箱来减轻编码任务，在指定大小的基本类型的列表上工作也会变得很慢。
3、如果你要使用多维数组，使用 [][] 比 List 会方便。
 
ArrayList 与 LinkedList 区别？
 
? ArrayList
 
优点：ArrayList 是实现了基于动态数组的数据结构，因为地址连续，一旦数据存储好了，查询操作效率会比较高（在内存里是连着放的）。
缺点：因为地址连续，ArrayList 要移动数据，所以插入和删除操作效率比较低。
 
? LinkedList
 
优点：LinkedList 基于链表的数据结构，地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址。对于新增和删除操作 add 和 remove ，LinedList 比较占优势。LinkedList 适用于要头尾操作或插入指定位置的场景。
缺点：因为 LinkedList 要移动指针，所以查询操作性能比较低。
 
? 适用场景分析：
 
 
当需要对数据进行对随机访问的情况下，选用 ArrayList 。
 
 
当需要对数据进行多次增加删除修改时，采用 LinkedList 。
 
  
 
   
如果容量固定，并且只会添加到尾部，不会引起扩容，优先采用 ArrayList 。
 
  
 
 
当然，绝大数业务的场景下，使用 ArrayList 就够了。主要是，注意好避免 ArrayList 的扩容，以及非顺序的插入。
 
 
? ArrayList 是如何扩容的？
 
直接看 《ArrayList 动态扩容详解》 文章，很详细。主要结论如下：
 
如果通过无参构造的话，初始数组容量为 0 ，当真正对数组进行添加时，才真正分配容量。每次按照 1.5 倍（位运算）的比率通过 copeOf 的方式扩容。
在 JKD6 中实现是，如果通过无参构造的话，初始数组容量为10，每次通过 copeOf 的方式扩容后容量为原来的 1.5 倍。
 
 
 
重点是 1.5 倍扩容，这是和 HashMap 2 倍扩容不同的地方。
 
 
ArrayList 集合加入 1 万条数据，应该怎么提高效率？
 
ArrayList 的默认初始容量为 10 ，要插入大量数据的时候需要不断扩容，而扩容是非常影响性能的。因此，现在明确了 10 万条数据了，我们可以直接在初始化的时候就设置 ArrayList 的容量！
 
这样就可以提高效率了~
 
ArrayList 与 Vector 区别？
 
ArrayList 和 Vector 都是用数组实现的，主要有这么三个区别：
 
 
1、Vector 是多线程安全的，线程安全就是说多线程访问同一代码，不会产生不确定的结果，而 ArrayList 不是。这个可以从源码中看出，Vector 类中的方法很多有 synchronized 进行修饰，这样就导致了 Vector 在效率上无法与 ArrayList 相比。
 
  
 
   
Vector 是一种老的动态数组，是线程同步的，效率很低，一般不赞成使用。
 
  
 
 
2、两个都是采用的线性连续空间存储元素，但是当空间不足的时候，两个类的增加方式是不同。
 
 
3、Vector 可以设置增长因子，而 ArrayList 不可以。
 
 
适用场景分析：
 
 
1、Vector 是线程同步的，所以它也是线程安全的，而 ArrayList 是线程无需同步的，是不安全的。如果不考虑到线程的安全因素，一般用 ArrayList 效率比较高。
 
  
 
   
实际场景下，如果需要多线程访问安全的数组，使用 CopyOnWriteArrayList 。
 
  
 
 
2、如果集合中的元素的数目大于目前集合数组的长度时，在集合中使用数据量比较大的数据，用 Vector 有一定的优势。
 
  
 
   
这种情况下，使用 LinkedList 更合适。
 
  
 
 
HashMap 和 Hashtable 的区别？
 
 
 
Hashtable 是在 Java 1.0 的时候创建的，而集合的统一规范命名是在后来的 Java2.0 开始约定的，而当时其他一部分集合类的发布构成了新的集合框架。
 
 
Hashtable 继承 Dictionary ，HashMap 继承的是 Java2 出现的 Map 接口。
2、HashMap 去掉了 Hashtable 的 contains 方法，但是加上了 containsValue 和 containsKey 方法。
3、HashMap 允许空键值，而 Hashtable 不允许。
【重点】4、HashTable 是同步的，而 HashMap 是非同步的，效率上比 HashTable 要高。也因此，HashMap 更适合于单线程环境，而 HashTable 适合于多线程环境。
5、HashMap 的迭代器（Iterator）是 fail-fast 迭代器，HashTable的 enumerator 迭代器不是 fail-fast 的。
6、HashTable 中数组默认大小是 11 ，扩容方法是 old * 2 + 1 ，HashMap 默认大小是 16 ，扩容每次为 2 的指数大小。
 
一般现在不建议用 HashTable 。主要原因是两点：
 
一是，HashTable 是遗留类，内部实现很多没优化和冗余。
二是，即使在多线程环境下，现在也有同步的 ConcurrentHashMap 替代，没有必要因为是多线程而用 Hashtable 。
 
? Hashtable 的 #size() 方法中明明只有一条语句 “return count;” ，为什么还要做同步？
 
同一时间只能有一条线程执行固定类的同步方法，但是对于类的非同步方法，可以多条线程同时访问。所以，这样就有问题了，可能线程 A 在执行 Hashtable 的 put 方法添加数据，线程 B 则可以正常调用 #size() 方法读取 Hashtable 中当前元素的个数，那读取到的值可能不是最新的，可能线程 A 添加了完了数据，但是没有对 count++ ，线程 B 就已经读取 count 了，那么对于线程 B 来说读取到的 count 一定是不准确的。
 
而给 #size() 方法加了同步之后，意味着线程 B 调用 #size() 方法只有在线程 A 调用 put 方法完毕之后才可以调用，这样就保证了线程安全性。
 
HashSet 和 HashMap 的区别？
 
 
Set 是线性结构，值不能重复。HashSet 是 Set 的 hash 实现，HashSet 中值不能重复是用 HashMap 的 key 来实现的。
 
 
Map 是键值对映射，可以空键空值。HashMap 是 Map 的 hash 实现，key 的唯一性是通过 key 值 hashcode 的唯一来确定，value 值是则是链表结构。
 
  
 
   
因为不同的 key 值，可能有相同的 hashcode ，所以 value 值需要是链表结构。
 
  
 
 
他们的共同点都是 hash 算法实现的唯一性，他们都不能持有基本类型，只能持有对象。
 
 
 
为了更好的性能，Netty 自己实现了 key 为基本类型的 HashMap ，例如 IntObjectHashMap 。
 
 
HashSet 和 TreeSet 的区别？
 
HashSet 是用一个 hash 表来实现的，因此，它的元素是无序的。添加，删除和 HashSet 包括的方法的持续时间复杂度是 O(1) 。
TreeSet 是用一个树形结构实现的，因此，它是有序的。添加，删除和 TreeSet 包含的方法的持续时间复杂度是 O(logn) 。
 
? 如何决定选用 HashMap 还是 TreeMap？
 
对于在 Map 中插入、删除和定位元素这类操作，HashMap 是最好的选择。
然而，假如你需要对一个有序的 key 集合进行遍历， TreeMap 是更好的选择。
 
基于你的 collection 的大小，也许向 HashMap 中添加元素会更快，再将 HashMap 换为 TreeMap 进行有序 key 的遍历。
 
HashMap 和 ConcurrentHashMap 的区别？
 
ConcurrentHashMap 是线程安全的 HashMap 的实现。主要区别如下：
 
 
1、ConcurrentHashMap 对整个桶数组进行了分割分段(Segment)，然后在每一个分段上都用 lock 锁进行保护，相对 于Hashtable 的 syn 关键字锁的粒度更精细了一些，并发性能更好。而 HashMap 没有锁机制，不是线程安全的。
 
  
 
   
JDK8 之后，ConcurrentHashMap 启用了一种全新的方式实现,利用 CAS 算法。
 
  
 
 
2、HashMap 的键值对允许有 null ，但是 ConCurrentHashMap 都不允许。
 
 
队列和栈是什么，列出它们的区别？
 
栈和队列两者都被用来预存储数据。
 
java.util.Queue 是一个接口，它的实现类在Java并发包中。队列允许先进先出（FIFO）检索元素，但并非总是这样。Deque 接口允许从两端检索元素。
栈与队列很相似，但它允许对元素进行后进先出（LIFO）进行检索。 
  
Stack 是一个扩展自 Vector 的类，而 Queue 是一个接口。
 
 
原理
 
HashMap 的工作原理是什么？
 
我们知道在 Java 中最常用的两种结构是数组和模拟指针（引用），几乎所有的数据结构都可以利用这两种来组合实现，HashMap 也是如此。实际上 HashMap 是一个**“链表散列”**。
 
HashMap 是基于 hashing 的原理。
 
HashMap 图解
 
我们使用 #put(key, value) 方法来存储对象到 HashMap 中，使用 get(key) 方法从 HashMap 中获取对象。
当我们给 #put(key, value) 方法传递键和值时，我们先对键调用 #hashCode() 方法，返回的 hashCode 用于找到 bucket 位置来储存 Entry 对象。
 
? 当两个对象的 hashCode 相同会发生什么？
 
因为 hashcode 相同，所以它们的 bucket 位置相同，“碰撞”会发生。
 
因为 HashMap 使用链表存储对象，这个 Entry（包含有键值对的 Map.Entry 对象）会存储在链表中。
 
? hashCode 和 equals 方法有何重要性？
 
HashMap 使用 key 对象的 #hashCode() 和 #equals(Object obj) 方法去决定 key-value 对的索引。当我们试着从 HashMap 中获取值的时候，这些方法也会被用到。
 
如果这两个方法没有被正确地实现，在这种情况下，两个不同 Key 也许会产生相同的 #hashCode() 和 #equals(Object obj) 输出，HashMap 将会认为它们是相同的，然后覆盖它们，而非把它们存储到不同的地方。
 
同样的，所有不允许存储重复数据的集合类都使用 #hashCode() 和 #equals(Object obj) 去查找重复，所以正确实现它们非常重要。#hashCode() 和 #equals(Object obj) 方法的实现，应该遵循以下规则：
 
如果 o1.equals(o2) ，那么 o1.hashCode() == o2.hashCode() 总是为 true 的。
如果 o1.hashCode() == o2.hashCode() ，并不意味 o1.equals(o2) 会为 true 。
 
? HashMap 默认容量是多少？
 
默认容量都是 16 ，负载因子是 0.75 。就是当 HashMap 填充了 75% 的 busket 是就会扩容，最小的可能性是（16 * 0.75 = 12），一般为原内存的 2 倍。
 
? 有哪些顺序的 HashMap 实现类？
 
LinkedHashMap ，是基于元素进入集合的顺序或者被访问的先后顺序排序。
TreeMap ，是基于元素的固有顺序 (由 Comparator 或者 Comparable 确定)。
 
? 我们能否使用任何类作为 Map 的 key？
 
我们可以使用任何类作为 Map 的 key ，然而在使用它们之前，需要考虑以下几点：
 
 
1、如果类重写了 equals 方法，它也应该重写 hashcode 方法。
 
 
2、类的所有实例需要遵循与 equals 和 hashcode 相关的规则。
 
 
3、如果一个类没有使用 equals ，你不应该在 hashcode 中使用它。
 
 
4、用户自定义 key 类的最佳实践是使之为不可变的，这样，hashcode 值可以被缓存起来，拥有更好的性能。不可变的类也可以确保hashcode 和 equals 在未来不会改变，这样就会解决与可变相关的问题了。
 
  
 
   
比如，我有一个 类MyKey ，在 HashMap 中使用它。代码如下：
 
  
 
//传递给MyKey的name参数被用于equals()和hashCode()中
MyKey key = new MyKey('Pankaj'); //assume hashCode=1234
myHashMap.put(key, 'Value');
// 以下的代码会改变key的hashCode()和equals()值
key.setName('Amit'); //assume new hashCode=7890
//下面会返回null，因为HashMap会尝试查找存储同样索引的key，而key已被改变了，匹配失败，返回null
myHashMap.get(new MyKey('Pankaj'));

 
  
那就是为何 String 和 Integer 被作为 HashMap 的 key 大量使用。
 
 
? HashMap 的长度为什么是 2 的幂次方？
 
为了能让 HashMap 存取高效，尽量较少碰撞，也就是要尽量把数据分配均匀，每个链表/红黑树长度大致相同。这个实现就是把数据存到哪个链表/红黑树中的算法。
 
这个算法应该如何设计呢？我们首先可能会想到采用 % 取余的操作来实现。但是，重点来了：
 
取余(%)操作中如果除数是 2 的幂次则等价于与其除数减一的与(&)操作（也就是说 hash % length == hash & (length - 1) 的前提是 length 是 2 的 n 次方；）。
并且，采用二进制位操作 &，相对于 % 能够提高运算效率，
 
这就解释了 HashMap 的长度为什么是 2 的幂次方。
 
HashSet 的工作原理是什么？
 
HashSet 是构建在 HashMap 之上的 Set hashing 实现类。让我们直接撸下源码，代码如下：
 
// HashSet.java

private transient HashMap<E,Object> map;

private static final Object PRESENT = new Object();

 
 
map 属性，当我们创建一个 HashMap 对象时，其内部也会创建一个 map 对象。后续 HashSet 所有的操作，实际都是基于这个 map 之上的封装。
 
 
PRESENT 静态属性，所有 map 中 KEY 对应的值，都是它，避免重复创建。
 
 
OK ，再来看一眼 add 方法，代码如下：
 
// HashSet.java

public boolean add(E e) {
    return map.put(e, PRESENT) == null;
}

 
  
是不是一目了然。
 
 
? HashSet 如何检查重复？
 
 
 
艿艿：正如我们上面看到 HashSet 的实现原理，我们自然可以推导出，HashMap 也是如何检查重复滴。
 
 
如下摘取自 《Head First Java》 第二版：
 
当你把对象加入 HashSet 时，HashSet会先计算对象的hashcode值来判断对象加入的位置，同时也会与其他加入的对象的hashcode值作比较。
 
如果没有相符的 hashcode ，HashSet会假设对象没有重复出现。
但是如果发现有相同 hashcode 值的对象，这时会调用 equals 方法来检查 hashcode 相等的对象是否真的相同。 
  
如果两者相同，HashSet 就不会让加入操作成功。
如果两者不同，HashSet 就会让加入操作成功。
 
 
【详细可以查看java基础系列】

官网帮助文档地址：https://matplotlib.org/tutorials/introductory/pyplot.html 
 
Pyplot简介
 
matplotlib.pyplot 是一个命令风格的函数集合，这使得 matplotlib 工作起来和MATLAB很相似。每一个 pyplot 函数都会使图形发生一些变化，例如：创建一幅图形、在一幅图中创建一个绘图区域、在绘图区域中绘制一些线、使用标签对图形进行修饰，等等。在matplotlib.pyplot中，各种各样的状态通过调用不同的函数被保存下来，因此，matplotlib 能够持续地对例如：当前的图形和绘图区域、并将绘图函数作用到当前轴上（请注意，这里和文档中大多数地方的“轴”指的是图形的坐标系部分，而不是严格数学术语中的多个轴）。
            使用 pyplot 生成一个可视化效果非常快：
 
import matplotlib.pyplot as plt
plt.plot([1,2,3,4])
plt.ylabel('some numbers')
plt.show()
 
 
你可能会觉得很奇怪：为什么X轴取值的范围是 0~3，而Y轴取值的范围是1~4 ？
 
这是因为：如果你只提供 了一个列表或者数组作为 plot() 命令的参数，Matplotlib 就会把这个序列当作是Y轴上的取值，并自动地为你生成 X轴上的值。由于在python中范围是从0开始的，因此在默认情况下，X轴向量会与Y轴向量的长度相同但其取值会从0开始，正如我们所看到的X轴的数据是[0,1,2,3]。
            plot() 是一个多功能的命令，能够接收任意数量的参数，例如：你可以使用如下命令来绘制与X相对的Y的图形。
 
plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
 
 
格式化图形样式
 
plot() 还为每一对参数X和Y提供了一个可选的第三个格式化字符串参数用来指定图形的颜色和线型。该格式化字符串的字母和符号均来自于MATLAB，由一个代表颜色的字符串和一个代表线型的字符串组合而成。默认使用的格式化字符串是’b-‘（表示蓝色实线）。 
            如果想要使用红色的圆点来绘制上例中的图形，你可以这么写：
 
plt.plot([1, 2, 3, 4], [1, 4, 9, 16], 'ro')
plt.axis([0, 6, 0, 20])
plt.show()
 
 
 你可以查看 plot() 的文档来获取关于线的样式和格式化字符串的完整列表。
             上例中的 axis() 命令接收了 [xmin, xmax, ymin, ymax] 列表作为参数来指定了各个轴的视口大小。但如果 Matplotlib 被限制成只能和 list 一起使用 ，那么它在数值处理上将显得几乎毫无用处 。通常，我们都会使用 numpy 数组，事实上，所有的序列都会在 Matplotlib 内部被转化成 numpy 数组。下面的例子展示了如何在一条命令里使用  numpy 数组绘制出几条样式不同的线：
 
import numpy as np

# evenly sampled time at 200ms intervals
t = np.arange(0., 5., 0.2)

# red dashes, blue squares and green triangles
plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^')
plt.show()
 
 
 
 
 补充：在 plot()  中，格式化字符串由颜色、标识符和线型三部分组成，定义格式如下：
 
fmt = '[color][marker][line]'
 
其中，支持的颜色缩写有如下几个：
 
character
color
'b'
blue
'g'
green
'r'
red
'c'
cyan
'm'
magenta
'y'
yellow
'k'
black
'w'
white
标识符定义如下表所示：
 
character
description
'.'
point marker
','
pixel marker
'o'
circle marker
'v'
triangle_down marker
'^'
triangle_up marker
'<'
triangle_left marker
'>'
triangle_right marker
'1'
tri_down marker
'2'
tri_up marker
'3'
tri_left marker
'4'
tri_right marker
's'
square marker
'p'
pentagon marker
'*'
star marker
'h'
hexagon1 marker
'H'
hexagon2 marker
'+'
plus marker
'x'
x marker
'D'
diamond marker
'd'
thin_diamond marker
'|'
vline marker
'_'
hline marker
可以选用的线型有以下四个：
 
character
description
'-'
solid line style
'--'
dashed line style
'-.'
dash-dot line style
':'
dotted line style
 以下是几个格式化字符串的示例：
 
'b'    # blue markers with default shape
'ro'   # red circles
'g-'   # green solid line
'--'   # dashed line with default color
'k^:'  # black triangle_up markers connected by a dotted line
 
使用关键字绘图
 
Matplotlib 允许用户提供带有关键字的数据对象作为参数，一旦提供了带有关键字的数据，就能够直接使用关键字来代替这些变量去生成图形。
            我们可以使用某些命令来获取到这种格式的数据，例如：numpy.recarray 和 pandas.DataFrame  。
 
data = {'a': np.arange(50),
        'c': np.random.randint(0, 50, 50),
        'd': np.random.randn(50)}
data['b'] = data['a'] + 10 * np.random.randn(50)
data['d'] = np.abs(data['d']) * 100

plt.scatter('a', 'b', c='c', s='d', data=data)
plt.xlabel('entry a')
plt.ylabel('entry b')
plt.show()
 
 
使用分类变量绘图
 
使用分类变量来创建图形也是可以的，Matplotlib 允许用户直接把分类变量传递给多个绘图函数，例如：
 
names = ['group_a', 'group_b', 'group_c']
values = [1, 10, 100]

plt.figure(1, figsize=(9, 3))

plt.subplot(131)
plt.bar(names, values)
plt.subplot(132)
plt.scatter(names, values)
plt.subplot(133)
plt.plot(names, values)
plt.suptitle('Categorical Plotting')
plt.show()
 
 
 控制线的属性 
 
线的属性有很多，详情参见  matplotlib.lines.Line2D ，例如你可以设置：线宽、虚线和抗锯齿效果，等等。
            我们可以通过以下几种途径对线的属性进行设置：
            使用关键字参数
 
plt.plot(x, y, linewidth=2.0)
 
使用2D 线实例的set方法
            plot() 命令会返回一个线对象的列表，例如：line1, line2 = plot(x1, y1, x2, y2)。在下面的代码中，我们将假设我们只有一条线即plot() 命令返回的线列表的长度为 1 。我们使用 line, 来获取列表中的第一个元素。
 
line, = plt.plot(x, y, '-')
line.set_antialiased(False) # turn off antialising
 
           使用setp()命令
            下面示例一下如何使用MATLAB风格的命令对一个线列表的多个属性进行设置。很明显地，setp() 能够作用于一个对象列表或者是一个单独的对象。你既可以使用Python 的关键字作为参数也可以使用MATLAB风格的string/value 对作为参数：
 
lines = plt.plot(x1, y1, x2, y2)
# use keyword args
plt.setp(lines, color='r', linewidth=2.0)
# or MATLAB style string value pairs
plt.setp(lines, 'color', 'r', 'linewidth', 2.0)
 
2D 线实例的可用属性见下表：
 
Property
Value Type
alpha
float
animated
[True | False]
antialiased or aa
[True | False]
clip_box
a matplotlib.transform.Bbox instance
clip_on
[True | False]
clip_path
a Path instance and a Transform instance, a Patch
color or c
any matplotlib color
contains
the hit testing function
dash_capstyle
['butt' | 'round' | 'projecting']
dash_joinstyle
['miter' | 'round' | 'bevel']
dashes
sequence of on/off ink in points
data
(np.array xdata, np.array ydata)
figure
a matplotlib.figure.Figure instance
label
any string
linestyle or ls
[ '-' | '--' | '-.' | ':' | 'steps' | ...]
linewidth or lw
float value in points
lod
[True | False]
marker
[ '+' | ',' | '.' | '1' | '2' | '3' | '4' ]
markeredgecolor or mec
any matplotlib color
markeredgewidth or mew
float value in points
markerfacecolor or mfc
any matplotlib color
markersize or ms
float
markevery
[ None | integer | (startind, stride) ]
picker
used in interactive line selection
pickradius
the line pick selection radius
solid_capstyle
['butt' | 'round' | 'projecting']
solid_joinstyle
['miter' | 'round' | 'bevel']
transform
a matplotlib.transforms.Transform instance
visible
[True | False]
xdata
np.array
ydata
np.array
zorder
any number
 如果你想要获取可供设置的线属性的列表，你可以直接调用 setp() 命令并传入一条线或者传入一个线列表作为唯一参数。
 
lines = plt.plot([1, 2, 3])

plt.setp(lines)
  alpha: float
  animated: [True | False]
  antialiased or aa: [True | False]
  ...snip
 
 使用多图形和多轴
 
MATLAB和 pyplot 都有当前图形和当前轴的概念，所有的绘图命令都会被应用到当前轴上。在 Matplotlib 中，gca() 命令用来获取当前轴（一个 matplotlib.axes.Axes 实例），gcf() 命令用来获取当前图形（一个 matplotlib.figure.Figure 实例）。通常情况下，你并不需要考虑这些，因为 Matplotlib 会在后台对它们进行自动处理。
            下面是一个创建了两个子图形的示例脚本：
 
def f(t):
    return np.exp(-t) * np.cos(2*np.pi*t)

t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)

plt.figure(1)
plt.subplot(211)
plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')

plt.subplot(212)
plt.plot(t2, np.cos(2*np.pi*t2), 'r--')
plt.show()
 
 
figure()命令在这儿是一个可选项，因为默认创建的就是 figure(1) ，同样地，在没有手动地指定任何轴的情况下，将默认创建 subplot(111) 。subplot() 命令需要指定行数、列数、图形编号，其中图形编号的取值范围为（1 ~ 行数*列数）。如果行数*列数<10，参数之间的逗号可以省略。因此，subplot(211) 和 subplot(2, 1, 1) 的作用是一样的。
 
你可以创建任意数量的子图形或者坐标系。如果你想要手动去放置一个坐标系可以使用 axes() 命令，并通过  axes([left, bottom, width, height]) 的四个参数（ 0 ~ 1 的小数）来指定坐标系的位置和大小。
 
           手动设置坐标系示例：https://matplotlib.org/gallery/subplots_axes_and_figures/axes_demo.html
            绘制多个子图形示例：
            https://matplotlib.org/gallery/subplots_axes_and_figures/subplot_demo.html
            https://matplotlib.org/gallery/subplots_axes_and_figures/subplots_demo.html
            你可以通过多次调用figure() 方法并传入一个递增的图形编号来创建多个图形。当然，只要你喜欢每一个图形也可以包含多个子图形或者坐标系：
 
import matplotlib.pyplot as plt
plt.figure(1)                # the first figure
plt.subplot(211)             # the first subplot in the first figure
plt.plot([1, 2, 3])
plt.subplot(212)             # the second subplot in the first figure
plt.plot([4, 5, 6])


plt.figure(2)                # a second figure
plt.plot([4, 5, 6])          # creates a subplot(111) by default

plt.figure(1)                # figure 1 current; subplot(212) still current
plt.subplot(211)             # make subplot(211) in figure1 current
plt.title('Easy as 1, 2, 3') # subplot 211 title
plt.show()
 
 
 
 
 
 你可以使用 clf() 命令来清除当前图形或者使用 cla() 命令来清除当前坐标系。 如果你觉得由后台帮你维护图形状态（指当前的图像，图形和坐标系）这种方式比较烦人，无须绝望：这只是对面向对象API的一个瘦状态封装，你可以把它替换掉（参见 Artist tutorial ）。
             如果你是在创建多个图形，你还需要注意另外一件事：图形所占用的内存直到你调用 close() 显式地将其关闭才会全部释放，如果只删除掉图形的引用或者通过窗口管理器销毁掉屏幕上的图像展示窗口，图形所占用的内存是不能完全被释放的，因为pyplot 在 close() 命令被调用之前仍会对其内部引用进行维护。
 
 使用文本
 
使用 text() 命令可以在图形的任意位置添加文本，xlabel()、ylabel()、title() 用来在指定位置添加文本（更多详细案例参见 Text in Matplotlib Plots ）。
 
mu, sigma = 100, 15
x = mu + sigma * np.random.randn(10000)

# the histogram of the data
n, bins, patches = plt.hist(x, 50, density=1, facecolor='g', alpha=0.75)


plt.xlabel('Smarts')
plt.ylabel('Probability')
plt.title('Histogram of IQ')
plt.text(60, .025, r'$\mu=100,\ \sigma=15$')
plt.axis([40, 160, 0, 0.03])
plt.grid(True)
plt.show()
 
 
 
 
所有的文本命令都会返回一个  matplotlib.text.Text  实例，跟前面线的属性设置一样，你可以往文本命令中传入关键字参数或者使用 setp() 命令来自定义文本的属性。
 
t = plt.xlabel('my data', fontsize=14, color='red')
 
            关于文本的属性的更多细节请参见：https://matplotlib.org/tutorials/text/text_props.html
 
 在文本中使用数学表达式 
 
Matplotlib 接收的文本表达式中可以包含 TeX 方程表达式，比如，书写时，需要使用 "$" 符号把TeX表达式包起来：
 
plt.title(r'$\sigma_i=15$')
 
标题字符串前面的”r”字符非常重要：它表示这个字符串是一个原生字符串，不用把里面的反斜杠当作 Python 的转义字符来看待。
            Matplotlib 有一个內建的 TeX 方程式的语法分析器和布局引擎，并带有自己的数学字体（详情参见  Writing mathematical expressions ）。因此你可以不用安装TeX就能够跨平台使用数学表达式，对于那些已经安装了LaTeX和dvipng的用户，你也可以使用LaTex 来格式化你的文字并将输出的文本并入到你要展示的图形或者要保存的脚本中（详情参见 Text rendering With LaTeX）。
 
 注释文本 
 
上面讲到过 text()命令的基本作用是在坐标系的任意位置添加一个文本，而文本通常是用来对图形的某些特征进行注释，annotate() 方法提供了一些非常有用的功能使得注释变得更加容易。对于注释有两个需要考虑的点：使用 xy 参数来代表需要被注释的位置；使用 xytext 参数来指定注释文本的放置位置；这两个参数的取值均为(x,y) 的组合。
 
ax = plt.subplot(111)

t = np.arange(0.0, 5.0, 0.01)
s = np.cos(2*np.pi*t)
line, = plt.plot(t, s, lw=2)

plt.annotate('local max', xy=(2, 1), xytext=(3, 1.5),
             arrowprops=dict(facecolor='black', shrink=0.05),
             )

plt.ylim(-2, 2)
plt.show()
 
 
 
 
在这个基础示例中，xy (箭头提示) 和 xytext(文本位置)都是在数据的坐标系中，这里还有许多其他种类的坐标系可以选择（详情参见  Basic annotation 和 Advanced Annotation），更多示例参见： Annotating Plots。
 
 对数及其他非线性坐标系
 
matplotlib.pylot 除了支持线性坐标系外，也支持对数和分对数等非线性坐标系，当数据的量级跨度比较大时会经常用到这些坐标系，改变一个坐标轴的刻度非常容易：
 
plt.xscale('log')
 
下例中展示了对于同样的数据，当Y轴使用不同刻度时的四个图形：
 
from matplotlib.ticker import NullFormatter  # useful for `logit` scale

# Fixing random state for reproducibility
np.random.seed(19680801)

# make up some data in the interval ]0, 1[
y = np.random.normal(loc=0.5, scale=0.4, size=1000)
y = y[(y > 0) & (y < 1)]
y.sort()
x = np.arange(len(y))

# plot with various axes scales
plt.figure(1)

# linear
plt.subplot(221)
plt.plot(x, y)
plt.yscale('linear')
plt.title('linear')
plt.grid(True)


# log
plt.subplot(222)
plt.plot(x, y)
plt.yscale('log')
plt.title('log')
plt.grid(True)


# symmetric log
plt.subplot(223)
plt.plot(x, y - y.mean())
plt.yscale('symlog', linthreshy=0.01)
plt.title('symlog')
plt.grid(True)

# logit
plt.subplot(224)
plt.plot(x, y)
plt.yscale('logit')
plt.title('logit')
plt.grid(True)
# Format the minor tick labels of the y-axis into empty strings with
# `NullFormatter`, to avoid cumbering the axis with too many labels.
plt.gca().yaxis.set_minor_formatter(NullFormatter())
# Adjust the subplot layout, because the logit one may take more space
# than usual, due to y-tick labels like "1 - 10^{-3}"
plt.subplots_adjust(top=0.92, bottom=0.08, left=0.10, right=0.95, hspace=0.25,
                    wspace=0.35)

plt.show()
 
 
你也可以添加你自定义的刻度，详情参见：Developer's guide for creating scales and transformations

小甲鱼老师零基础入门学习Python全套资料百度云(包括小甲鱼零基础入门学习Python全套视频+全套源码+全套PPT课件+全套课后题及Python常用工具包链接、电子书籍等）请往我的资源（https://download.csdn.net/download/qq_32809093/13099592）查看
 
目录：
 
000 愉快的开始
 001 我和Python的第一次亲密接触
 002 用Python设计第一个游戏
 003 小插曲之变量和字符串
 004 改进我们的小游戏
 005 闲聊之Python的数据类型
 006 Pyhon之常用操作符
 007 了不起的分支和循环
 008 了不起的分支和循环2
 009 了不起的分支和循环3
 010 列表：一个打了激素的数组
 011列表：一个打了激素的数组2
 012列表：一个打了激素的数组3
 013元组：戴上了枷锁的列表
 014字符串：各种奇葩的内置方法
 015字符串：格式化
 016 序列！序列！
 017函数：Python的乐高积木
 018 函数：灵活即强大
 019函数：我的地盘听我的（局部变量与全局变量）
 020函数：内嵌函数和闭包
 021函数：lambda表达式
 022 函数：递归是神马
 023 递归：这帮小兔崽子
 024 递归：汉诺塔
 025 字典：当索引不好用时
 026 字典：当索引不好用时2
 027 集合：在我的世界里，你就是唯一
 028 文件：因为懂你，所以永恒
 029 文件：一个任务
 030 文件系统：介绍一个高大上的东西
 031 永久存储：腌制一缸美味的泡菜(pickle)
 032 异常处理：你不可能总是对的
 033 异常处理：你不可能总是对的2
 034 丰富的else语句及简洁的with语句
 035 图形用户界面入门：EasyGui
 036 类和对象：给大家介绍对象
 037 类和对象：面向对象编程
 038 类和对象：继承
 039 类和对象：拾遗
 040 类和对象：一些相关的BIF
 041 魔法方法：构造和析构
 042 魔法方法：算术运算
 043 魔法方法：算术运算2
 044 魔法方法：简单定制
 045 魔法方法：属性访问
 046 魔法方法：描述符（Property的原理）
 047 魔法方法：定制序列
 048 魔法方法：迭代器
 049 乱入：生成器
 050 模块：模块就是程序
 051 模块：__name__='__main__'、搜索路径和包
 052 模块：像个极客一样去思考
 053 论一只爬虫的自我修养
 054 论一只爬虫的自我修养2：实战
 055 论一只爬虫的自我修养3：隐藏
 
064 GUI的终极选择：Tkinter
 065 GUI的终极选择：Tkinter2
 066 GUI的终极选择：Tkinter3
 067 GUI的终极选择：Tkinter4
 068 GUI的终极选择：Tkinter5
 069 GUI的终极选择：Tkinter6
 070 GUI的终极选择：Tkinter7
 071 GUI的终极选择：Tkinter8
 073 GUI的终极选择：Tkinter10
 074  GUI的终极选择：Tkinter11
 075 GUI的终极选择：Tkinter12
 076 GUI的终极选择：Tkinter13
 077 GUI的终极选择：Tkinter14
 
078 Pygame：初次见面，请大家多多关照
 
 
 
000 愉快的开始
 
python跨平台。
 应用范围：操作系统、WEB、3D动画、企业应用、云计算
 大家可以学到什么：Python3的所有常用语法、面向对象编程思维、运用模块进行编程、游戏编程、计算机仿真
 
Python 是脚本语言
脚本语言(Scripting language)是电脑编程语言，因此也能让开发者藉以编写出让电脑听命行事的程序。以简单的方式快速完成某些复杂的事情通常是创造脚本语言的重要原则，基于这项原则，使得脚本语言通常比 C 语言、C++语言 或 Java 之类的系统编程语言要简单容易。也让脚本语言另有一些属于脚本语言的特性：
 •  语法和结构通常比较简单
 •  学习和使用通常比较简单
 •  通常以容易修改程序的“解释”作为运行方式，而不需要“编译”
 •  程序的开发产能优于运行性能
 一个脚本可以使得本来要用键盘进行的相互式操作自动化。一个 Shell 脚本主要由原本需要在命令行输入的命令组成，或在一个文本编辑器中，用户可以使用脚本来把一些常用的操作组合成一组串行。主要用来书写这种脚本的语言叫做脚本语言。很多脚本
 语言实际上已经超过简单的用户命令串行的指令，还可以编写更复杂的程序。
 
IDLE 是一个 Python Shell，shell 的意思就是“外壳”，基本上来说，就是一个通过键入文本与程序交互的途径！像我们 Windows 那个 cmd 窗口，像 Linux 那个黑乎乎的命令窗口，他们都是 shell，利用他们，我们就可以给操作系统下达命令。同样的，我们可以利用 IDLE 这个 shell 与 Python 进行互动。
 
注：在 Python 中不能把两个完全不同的东西加在一起，比如说数字和文本
 
如果我需要在一个字符串中嵌入一个双引号，正确的做法是：你可以利用反斜杠（\）对双引号转义：\"，或者用单引号引起这个字符串
 
001 我和Python的第一次亲密接触
 
从IDLE启动Python
 
•IDLE是一个Python Shell，shell的意思就是“外壳”，基本上来说，就是一个通过键入文本与程序交互的途径！
 
•我们看到>>>这个提示符，Ta的含义是告诉你，Python已经准备好了，在等着你键入Python指令呢。
 
•好了，大家试试在IDLE里输入：
 
>>>print (“I love fishc.com”)
 
 
•我们尝试点儿新的东西，我们输入
 
>>>print(5+3)
 
 
•或者直接输入
 
>>>5+3
 
 
•不妨在试试计算
 
>>>1234567890987654321*987654321012345678
 
 
•还有我们可以将两个字符串“相加”在一起，这种做法叫做拼接字符串
 
>>>print("well water"+"river")
 
 
•先试试
 
>>> print("I love fishc.com"*2)
 
 
•和
 
>>> print("I love fishc.com\n"* 2)
 
 
002 用Python设计第一个游戏
 
实例1：
 
print("---------我爱鱼C工作室----------")
 temp = input("不妨猜一下小甲鱼现在心里想的是哪个数字:")
 guess = int(temp)
 if guess == 8:
     print("我草，你是小甲鱼心里的蛔虫嘛？！")
     print("哼，猜中了也没有奖励！")
 else:
     print("猜错了，小甲鱼现在心里想的是8！")
     print("游戏结束，不玩啦")
 
 
BIF 就是 Built-in Functions，内置函数。为了方便程序员快速编写脚本程序（脚本就是要编程速度快快快！！！），Python 提供了非常丰富的内置函数，我们只需要直接调用即可，例如 print() 的功能是“打印到屏幕”，input() 的作用是接收用户输入。
 
在 Python 或 IDLE 中，输入 dir(__builtins__) 可以看到 Python 提供的内置方法列表（注意，builtins 前后是两个下划线哦）其中小写的就是 BIF。如果想具体查看某个BIF 的功能，比如 input()，可以在 shell 中输入 help(input)，就会得到这个 BIF 的功能描述。哦，答案应该是 68 个
 
>>> dir(__builtins__)  查看 Python 提供的内置方法列表
 
 
>>> help(input)  查看input的具体使用说明 
 
 
注：
 
只有当标识符已经赋值后（ Python 的变量是不用先声明的）才能在代码中使用，未赋值的标识符直接使用会导致运行时错误
 
缩进是 Python 的灵魂
 
Python 不允许 if 条件中赋值，所以 if c = 1: 会报错！
 
 
 
003 小插曲之变量和字符串
 
插曲之变量
 
•变量名就像我们现实社会的名字，把一个值赋值给一个名字时，Ta会存储在内存中，称之为变量（variable），在大多数语言中，都把这种行为称为“给变量赋值”或“把值存储在变量中”。
 
•不过Python与大多数其他计算机语言的做法稍有不同，Ta并不是把值存储在变量中，而更像是把名字贴在值的上边。
 
•所以有些Python程序员会说“Python”没有“变量”，只有“名字”。
 
 
 
需要注意的地方
 
•在使用变量之前，需要对其先赋值。
 
•变量名可以包括字母、数字、下划线，但变量名不能以数字开头。
 
•字母可以是大写或小写，但大小写是不同的。也就是说fishc和FishC对于Python来说是完全不同的两个名字
 
•等号（=）是赋值的意思，左边是名字，右边是值，不可写反咯。
 
插曲之字符串
 
•到目前为止，我们所认知的字符串就是引号内的一切东西，我们也把字符串叫做文本，文本和数字是截然不同的，咱看例子：>>>5+8
 
>>> '5'+'8'
 
 
•要告诉Python你在创建一个字符串，就要在字符两边加上引号，可以是单引号或者双引号，Python女士表示不挑剔。但必须成对，你不能一边单引号，另一边却花心的用上双引号结尾。
 
•如果字符串中需要出现单引号或双引号怎么办？
 
–例如我想打印字符串：Let’s go!
 
•有两种方法，第一种比较常用，就是使用我们的转义符号（\）对字符串中的引号进行转义：
 
>>> 'Let\'s go!'
 
 
原始字符串
 
•好像反斜杠是一个好东西，但不妨试试打印：
 
>>> str = 'C:\now'
 
 
•我们可以用反斜杠对自身进行转义：
 
>>> str = 'C:\\now'
 
 
•原始字符串的使用非常简单，只需要在字符串前边加一个英文字母r即可(则都会以原始字符串输出)：
 
>>>str = r'C:\now'
 
 
长字符串
 
•如果希望得到一个跨越多行的字符串，例如：
 
我爱鱼C，
 
正如我爱小甲鱼，
 
久久不肯散去……
 
这我们就需要使用到三重引号字符串！
 
 
 
 
004 改进我们的小游戏
 
•第一个改进要求：猜错的时候程序提示用户当前的输入比答案大了还是小了
 
 
与操作and
 
 
 
•第二个改进要求：程序应该提供多次机会给用户猜测，专业点来讲就是程序需要重复运行某些代码。
 
条件分支
 
 
while循环
 
 
实例1：找8
 
temp = input("请输入一个数据：")
 guess = int(temp)
 i=0
 while guess != 8 and i < 3:
     i = i + 1
     temp = input("哎呀，猜错了，请重新输入吧：")
     guess = int(temp)
     if guess == 8:
         print("我草，你是小甲鱼心里的蛔虫嘛？")
         print("哼，猜对了也没有奖励")
     else:
         if guess > 8:
             print("哥，大了大了~~")
         else:
             print("嘿，小了！小了！！")
 print("游戏结束，不玩啦~~")
 
 
•random模块里边有一个函数叫做：randint()，Ta会返回一个随机的整数。
 
实例2：找随机数
 
import random#导入随机数函数
 secret = random.randint(1,5)#随机生成1到5的一个随机数
 temp = input("请输入一个1-5的数据：")
 guess = int(temp)
 i=0
 while guess != secret and i < 6:
     i = i + 1
     guess = int(temp)
     if guess == secret:
         print("我草，你是小甲鱼心里的蛔虫嘛？")
         print("哼，猜对了也没有奖励")
     else:
         if guess > secret:
             print("哥，大了大了~~")
         else:
             print("嘿，小了！小了！！")      
         temp = input("请重新输入吧：")
 print("游戏结束，不玩啦~~")
 
 
 
 
005 闲聊之Python的数据类型
 
Python的一些数值类型：整型、布尔类型（True与False）、浮点型、e记法、复数类型等
 
e记法（e4相当于10的四次方，e-10相当于10的-10次方）
 
 
类型转换
 
 
字符型转换为整型
 
 
其它同上
 
type()函数(可查看变量类型)
 
 
isinstance()函数（用来判断两个输入参数类型是否一致）
 
 
 
 
006 Pyhon之常用操作符
 
算术操作符
 
 
注：python中 \ 为除法， \\ 为整除 ，% 为取余
 
幂运算（3的二次方）
 
 
3的二次方后取负
 
注：先幂运算、然后乘除、后加减、后逻辑
 
3的负二次方
 
 
比较操作符
 
 
逻辑操作符
 
 
 
优先级问题
 
 
007 了不起的分支和循环
 
打飞机游戏框架：
 
加载背景音乐
 
播放背景音乐（设置单曲循环）
 
我方飞机诞生
 
while True:
     if 用户是否点击了关闭按钮：
        推出程序
        
     interval += 1;
     if interval == 50:
        interval = 0;
        小飞机诞生
     小飞机移动一个位置
     屏幕刷新
     
     if 用户鼠标产生移动：
        我方飞机中心位置 = 用户鼠标位置
        屏幕刷新
        
     if 我方飞机与小飞机发生肢体冲突：
        我方挂，播放撞机音乐
        修改我方飞机图案
        打印“Game over"
        停止背景音乐，最好淡出
 
 
 
008 了不起的分支和循环2
 
•现在小甲鱼来考考大家：
 
–按照100分制，90分以上成绩为A，80到90为B，60到80为C，60以下为D，写一个程序，当用户输入分数，自动转换为ABCD的形式打印。
 
score = int(input('请输入一个分数：'))
 if 100 >= score >= 90:
     print('A')
 elif 90 > score >= 80:
     print('B')
 elif 80 > score >= 60:
     print('C')
 elif 60 > score >= 0:
     print('D')
 else:
     print('输入错误！')
 
条件表达式（三元操作符）
 
有了这个三元操作符的条件表达式，你可以使用一条语句来完成以下的条件判断和赋值操作：
 
x, y = 4, 5
 
if x < y:
 
  small = x
 
else:
 
  small = y
 
例子可以改进为
 
small = x if x < y else y    #如果x小于y，则small等于x，否则等于y
 
断言（assert）
 
•assert这个关键字我们称之为“断言”，当这个关键字后边的条件为假的时候，程序自动崩溃并抛出AssertionError的异常。
 
•举个例子：
 
>>> assert 3 > 4
 
 
•一般来说我们可以用Ta再程序中置入检查点，当需要确保程序中的某个条件一定为真才能让程序正常工作的话，assert关键字就非常有用了。
 
 
 
009 了不起的分支和循环3
 
while循环
 
while 条件：
 
                  循环体
 
for循环
 
•虽然说Python是由C语言编写而来的，但是Ta的for循环跟C语言的for循环不太一样，Python的for循环显得更为智能和强大！
 
•语法：
 
for 目标 in 表达式：
 
     循环体
 
每次取FishC中一个字符及空格输出
 
 
range()函数
 
•语法：range( [strat],[stop],[step] )
 
–这个BIF有三个参数，其中用中括号括起来的两个表示这两个参数是可选的。
 
–step=1表示第三个参数的值默认值是1。setp为每步距离
 
–range这个BIF的作用是生成一个从start参数的值开始到stop参数的值结束的数字序列。
 
 
 
 
break语句（结束本层循环）
 
实例：
 
bingo = '小甲鱼是帅哥'
 answer = input('请输入小甲鱼最想听的一句话：')
 
while True:
     if answer == bingo:
         break
     answer = input('抱歉，错了，请重新输入（答案正确才能退出游戏）：')
 
print('哎哟，帅哦~')
 print('您真是小甲鱼肚子里的蛔虫啊^_^')
 
 
continue语句（当前位置结束本次循环，重新开始下次循环）
 
实例：
 
for i in range(10):
     if i%2 != 0:
         print(i)
         continue
     i += 2
     print(i)
 
 
010 列表：一个打了激素的数组
 
列表：一个打了激素的数组
 
 
创建列表
 
•创建一个普通列表
 
 
•创建一个混合列表
 
 
•创建一个空列表
 
 
向列表添加元素
 
 
append()函数向列表末尾添加一个元素
 
 
extend()函数向列表末尾添加多个元素
 
 
insert(n,xxx)函数向列表中第n个元素前插入一个元素
 
注：0表示第一个元素
 
 
011列表：一个打了激素的数组2
 
从列表中获取元素
 
•跟数组一样，我们可以通过元素的索引值（index）从列表获取单个元素，注意，列表索引值是从 0 开始的。
 
 
从列表删除元素
 
 
remove()函数表示从列表中删除某个元素
 
 
del()函数也表示从列表中删除某个元素
 
 
pop()函数从列表中取出最后一个元素
 
 
列表分片（Slice）
 
•利用索引值，每次我们可以从列表获取一个元素，但是我们总是贪心的，如果一次性需要获取多个元素，有没有办法实现呢？利用列表分片，我们可以简单的实现这个要求。
 
member[0:2]表示从第1个元素开始拷贝，一共拷贝两个元素，即member[0]和member[1]
 
列表的拷贝
 
 
012列表：一个打了激素的数组3
 
列表的一些常用操作符
 
•比较操作符
 
 
•逻辑操作符
 
 
•连接操作符
 
 
•重复操作符
 
 
•成员关系操作符
 
 
 
关于分片“拷贝”概念的补充
 
 
>>> dir(list)可查看所有列表的操作函数
 
 
count()函数可计算列表中相同元素个数
 
 
index()函数可索引列表元素
 
 
reverse()将列表中元素倒序
 
 
sort()将列表中元素从小到大排序
 
 
关于分片“拷贝”概念的补充
 
 
 
注：list13=list11相当于多了个指向列表的标签，list12 = list[:]是实实在在的拷贝
 
013元组：戴上了枷锁的列表
 
•由于和列表是近亲关系，所以元组和列表在实际使用上是非常相似的。
 
•我们这节课主要通过讨论元组和列表到底有什么不同来学习元组，酱紫大家就不会觉得老是重复一样的内容。
 
•我们主要从以下几个点来讨论学习：
 
–创键和访问一个元组
 
创建元组（括号可以没有，但逗号一定要有）
 
 
访问元组前两个元素
 
 
–更新和删除一个元组
 
更新一个元组
 
注：其并未对原元组进行修改，而是生成了一个新的元组，并贴上temp名字标签而已。原元组由于标签没有了，则会被自动回收。
 
删除一个元组
 
 
–元组相关的操作符
 
注：元组不允许修改和删除。
 
014字符串：各种奇葩的内置方法
 
 
 
 
 
015字符串：格式化
 
 
 
由于花括号被解释掉，所以不打印后面中文
 
 
字符串格式化符号含义
 
 
将ASCII码97对应的字符输出
 
 
 
格式化整数
 
 
格式化操作符辅助命令
 
 
 
 
 
5表示输出为五位数
 
Python 的转义字符及其含义
 
 
 
 
016 序列！序列！
 
•列表、元组和字符串的共同点
 
–都可以通过索引得到每一个元素
 
–默认索引值总是从0开始
 
–可以通过分片的方法得到一个范围内的元素的集合
 
–有很多共同的操作符（重复操作符、拼接操作符、成员关系操作符）
 
使用list方法
 
 
元组转换为列表
 
注：元组为小括号，列表为中括号。
 
max() 返回序列或者参数集合中的最大值
 
 
min() 返回序列或者参数集合中的最小值
 
sum(iterable[,start=0]) 返回序列iterable和可选参数start的总和
 
 
sorted()将元素从小到大重新排列
 
 
reversed()将元素倒序排列
 
注：元组是不可以修改和删除的，所以不可以直接对元组使用sorted与reversed命令
 
enumerate()将每个元素插入枚举
 
 
zip()返回由各个参数的序列组成的元组
 
 
 
 
017函数：Python的乐高积木
 
定义一个函数和调用
 
 
 
 
 
018 函数：灵活即强大
 
形参和实参
 
>>> def MyFirstFunction(name):
 
  '函数定义过程中的name是叫形参'
 
  #因为Ta只是一个形式，表示占据一个参数位置
 
  print('传递进来的' + name + '叫做实参，因为Ta是具体的参数值！')
 
>>> MyFirstFunction('小甲鱼')
 
传递进来的小甲鱼叫做实参，因为Ta是具体的参数值！
 
关键字参数
 
 
默认参数(即形参中给定默认值，则在未给实参时会以默认值输出)
 
 
收集参数
 
 
 
 
019函数：我的地盘听我的
 
函数与过程
 
再谈谈返回值
 
如果有返回值，函数则返回对应值；如果没有，则返回None
 
可以返回多个值
 
 
019函数：我的地盘听我的（局部变量与全局变量）
 
def discounts(price, rate):
     final_price = price * rate
     old_price = 88 #这里试图修改全局变量
     print('修改后old_price的值是：', old_price)
     return final_price
 
old_price = float(input('请输入原价：'))
 rate = float(input('请输入折扣率：'))
 new_price = discounts(old_price, rate)
 print('修改后old_price的值是：', old_price)
 print('打折后价格是：', new_price)
 
 
global可将局部变量声明为全局变量
 
 
020函数：内嵌函数和闭包
 
内嵌函数
 
 
闭包（closure）
 
 
注：使用nonlocal语句将x强制为不是局部变量
 
021函数：lambda表达式
 
 
 
lambda表达式的作用
 
•Python写一些执行脚本时，使用lambda就可以省下定义函数过程，比如说我们只是需要写个简单的脚本来管理服务器时间，我们就不需要专门定义一个函数然后再写调用，使用lambda就可以使得代码更加精简。
 
•对于一些比较抽象并且整个程序执行下来只需要调用一两次的函数，有时候给函数起个名字也是比较头疼的问题，使用lambda就不需要考虑命名的问题了。
 
•简化代码的可读性，由于普通的屌丝函数阅读经常要跳到开头def定义部分，使用lambda函数可以省去这样的步骤。
 
过滤函数filter可筛选出非零元素
 
 
筛选出奇数
 
注：lambda x:x%2用来判断是否为奇，x为奇则输出1，否则输出0；range(10)可生成0-9的10个整数，filter用来筛选非零元素；如果为偶数，则被筛选掉；如果为奇数，则保留，但输出的是rang(10)产生的原始数，因为lambda只是用来判断是否为奇偶
 
range生成的0-9给了x，x经过2倍运算后再赋值给x
 
022 函数：递归是神马
 
汉诺塔游戏
 
 
树结构的定义
 
 
谢尔宾斯基三角形
 
 
递归求阶乘
 
•写一个求阶乘的函数
 
–正整数阶乘指从1乘以2乘以3乘以4一直乘到所要求的数。
 
–例如所给的数是5，则阶乘式是1×2×3×4×5，得到的积是120，所以120就是4的阶乘。
 
•假设我们n的值传入是5，那么：
 
 
实例：求阶乘
 
def factorial(n):
     result = n
     for i in range(1, n):
         result *= i
 
    return result
 
number = int(input('请输入一个正整数：'))
 result = factorial(number)
 print("%d 的阶乘是：%d"  % (number, result))#格式化为整数类型
 
 
实例2：递归求阶乘
 
def factorial(n):
     if n == 1:
         return 1
     else:
         return n * factorial(n-1)
 
number = int(input('请输入一个正整数：'))
 result = factorial(number)
 print("%d 的阶乘是：%d" % (number, result))
 
 
023 递归：这帮小兔崽子
 
坑爹的兔子
 
 
斐波那契数列的迭代实现
 
我们都知道兔子繁殖能力是惊人的，如下图：
 
 
我们可以用数学函数来定义：
 
 
课间练习：假设我们需要求出经历了20个月后，总共有多少对小兔崽子？（迭代 vs 递归）
 
def fab(n):
     n1 = 1
     n2 = 1
     n3 = 1
 
    if n < 1:
         print('输入有误！')
         return -1
 
    while (n-2) > 0:
         n3 = n2 + n1
         n1 = n2
         n2 = n3
         n -= 1
     
     return n3
 
result = fab(20)
 if result != -1:
     print('总共有%d对小兔崽子诞生！' % result)
 
 
斐波那契数列的递归实现
 
 
递归实现（递归计算时间将拉长）
 
def fab(n):
     if n < 1:
         print('输入有误！')
         return -1
 
    if n == 1 or n == 2:
         return 1
     else:
         return fab(n-1) + fab(n-2)
 
result = fab(35)
 if result != -1:
     print('总共有%d对小兔崽子诞生！' % result)
 
注：迭代计算时间远比递归少，因为递归要循环出入栈
 
024 递归：汉诺塔
 
递归求解汉诺塔
 
 
 
 
•对于游戏的玩法，我们可以简单分解为三个步骤
 
–将前63个盘子从X移动到Y上。
 
–将最底下的第64个盘子从X移动到Z上。
 
–将Y上的63个盘子移动到Z上。
 
•问题一：将X上的63个盘子借助Z移到Y上；
 
•问题二：将Y上的63个盘子借助X移到Z上。
 
 
 
•对于游戏的玩法，我们可以简单分解为三个步骤
 
–将前63个盘子从X移动到Y上。
 
–将最底下的第64个盘子从X移动到Z上。
 
–将Y上的63个盘子移动到Z上。
 
•问题一：将X上的63个盘子借助Z移到Y上；
 
•问题二：将Y上的63个盘子借助X移到Z上。
 
实例：
 
def hanoi(n, x, y, z):
     if n == 1:
         print(x, ' --> ', z)
     else:
         hanoi(n-1, x, z, y) # 将前n-1个盘子从x移动到y上
         print(x, ' --> ', z) # 将最底下的最后一个盘子从x移动到z上
         hanoi(n-1, y, x, z) # 将y上的n-1个盘子移动到z上
 
n = int(input('请输入汉诺塔的层数：'))
 hanoi(n, 'X', 'Y', 'Z')
 
 
025 字典：当索引不好用时
 
映射
 
 
创建和访问字典
 
 
 
>>> dict4 = dict(小甲鱼='让编程改变世界',李宁='一切皆有可能')
 >>> dict4
 {'小甲鱼': '让编程改变世界', '李宁': '一切皆有可能'}
 
>>> dict4['爱迪生'] = '天才是99%的汗水加1%的灵感'
 >>> dict4
 {'小甲鱼': '让编程改变世界', '李宁': '一切皆有可能', '爱迪生': '天才是99%的汗水加1%的灵感'}
 
026 字典：当索引不好用时2
 
fromkey()方法用于创建并返回一个新的字典。它有两个参数，第一个参数是字典的键；第二个参数是可选的，是传入键的值。如果不提供，默认是None
 
>>> dict1 = {}
 >>> dict1.fromkeys((1,2,3))
 {1: None, 2: None, 3: None}
 >>> dict2 = {}
 >>> dict2.fromkeys((1,2,3),"Number")
 {1: 'Number', 2: 'Number', 3: 'Number'}
 >>> dict3 = {}
 >>> dict3.fromkeys((1,2,3),('one','two','three'))
 {1: ('one', 'two', 'three'), 2: ('one', 'two', 'three'), 3: ('one', 'two', 'three')}
 
访问字典的方法有key()、values()和items()
 
key()用于返回字典中的键，value()用于返回字典中所有的值，item()当然就是返回字典中所有的键值对（也就是项）
 
>>> dict1 = dict1.fromkeys(range(5),'赞')
 >>> dict1.keys()
 dict_keys([0, 1, 2, 3, 4])
 >>> dict1.values()
 dict_values(['赞', '赞', '赞', '赞', '赞'])
 >>> dict1.items()
 dict_items([(0, '赞'), (1, '赞'), (2, '赞'), (3, '赞'), (4, '赞')])
 
get()方法提供了更宽松的方式去访问字典项，当键不存在的时候，get()方法并不会报错，只是默默第返回一个None，表示啥都没找到：
 
>>> dict1.get(10)
 >>> dict1.get(4)
 '赞'
 
如果希望找不到数据时返回指定的值，可以在第二个参数设置对应的默认返回值：
 
>>> dict1.get(32,'木有')
 '木有'
 
如果不知道一个键是否在字典中，可以使用成员资格操作符（in 或 not in）来判断
 >>> 31 in dict1
 False
 >>> 4 in dict1
 
clear()可清空一个字典
 
>>> dict1
 {0: '赞', 1: '赞', 2: '赞', 3: '赞', 4: '赞'}
 >>> dict1.clear()
 >>> dict1
 {}
 
copy()方法是复制字典（全拷贝）
 
>>> a = {1:'one',2:'two',3:'three'}
 >>> b = a.copy()
 >>> id(a)
 52448840
 >>> id(b)
 52503624
 >>> a[1] = 'four'
 >>> a
 {1: 'four', 2: 'two', 3: 'three'}
 >>> b
 {1: 'one', 2: 'two', 3: 'three'}
 
pop()是给定键弹出对应的值，popitem()是随机弹出一个项
 
>>> a.pop(2)
 'two'
 >>> a
 {1: 'four', 3: 'three'}
 >>> a.popitem()
 (1, 'four')
 >>> a
 {3: 'three'}
 
setdefault()方法与get()方法相似，但setdefault()在字典中找不到相应的键值时会自动添加
 
>>> a = {1:'one',2:'two',3:'three'}
 >>> a.setdefault(2)
 'two'
 >>> a.setdefault(4)
 >>> a
 {1: 'one', 2: 'two', 3: 'three', 4: None}
 
update()方法可以更新字典
 
>>> a = {1:'one','小白':None}
 
>>> b = {'小白':'狗'}
 >>> a.update(b)
 >>> a
 {1: 'one', '小白': '狗'}
 
027 集合：在我的世界里，你就是唯一
 
字典的表亲--集合（在python3中，如果用大括号括起一堆数字但没有体现映射关系，那么就会认为这堆玩意儿就是个集合）
 
>>> num1 = {}
 >>> type(num1)
 <class 'dict'>
 >>> num2 = {1,3,4}
 >>> type(num2)
 <class 'set'>
 
集合中的元素都是唯一的（集合会自动帮我们把重复的数据清理掉，集合是无序的，所以不能试图去索引集合中的某一个元素）
 
>>> num = {1,2,3,4,5,5,4,3,2,1}
 >>> num
 {1, 2, 3, 4, 5}
 
如何创建一个集合有两种方法：1、直接把一堆元素用大括号括起来；2、用set()
 
•一种是直接把一堆元素用花括号括起来
 
>>> set1 = {'小甲鱼','小鱿鱼','小甲鱼'}
 
•一种是使用set()工厂函数
 
>>> set2 = set(['小甲鱼','小鱿鱼','小甲鱼'])
 >>> set1 == set2
 True
 
课堂搞搞看
 
要求：去掉列表中重复的元素
 
[0, 1, 2, 3, 4, 5, 5, 3, 1]
 
方法一、
 
>>> list1 = [1,2,3,4,5,5,3,1,0]
 
>>> temp = list1[:]
 >>> list1.clear()
 >>> list1
 []
 >>> for each in temp:
     if each not in list1:
         list1.append(each) #append()表示向列表中添加元素
 
方法二、
 
>>> list1 = list(set(list1))
 >>> list1
 [0, 1, 2, 3, 4, 5]
 
#set(list1)先将list1列表转变为集合， list(set(list1))再讲集合转变为列表
 
如何访问集合中的值
 
由于集合中的元素是无序的，所以并不能像序列那样用下标来进行访问，但是可以使用迭代把集合中的数据一个个读取出来
 
•可以使用for把集合中的数据一个个读取出来
 
>>> set1 = {1,2,3,4,5,4,3,2,1,0}
 >>> for each in set1:
     print(each,end = ' ')
 
    
 0 1 2 3 4 5 
 
•也可以通过in和not in判断一个元素是否在集合中已经存在
 
>>> 0 in set1
 True
 >>> 8 in set1
 False
 
使用add()方法可以为集合添加元素，使用remove()方法可以删除集合中已知的元素：
 
>>> set1.add(6)
 >>> set1
 {0, 1, 2, 3, 4, 5, 6}
 >>> set1.remove(5)
 >>> set1
 {0, 1, 2, 3, 4, 6}
 
不可变集合（把元素给froze冰冻起来）(像元组一样不能随意地增加或删除集合中的元素)
 
 
028 文件：因为懂你，所以永恒
 
大多数u程序都是：首先接收输入数据，然后按照要求进行处理，最后输出数据
 
 
虽然当前数据放在内存中存取的速度要比硬盘中快，但一旦断电则会丢失，所以尽量ctrl+s保持到硬盘中
 
 

什么是文件
 
 
打开文件
 
open(file, mode='r', buffering=-1, encoding=None,errors=None, newline=None, closefd=True, opener=None)
 
open()的第一个参数是传入的文件名，第二个参数是指定文件的打开模式
 
 
 
文件对象方法
 
>>> f = open("D:\\python3.3.2\Hello.txt")
 >>> f
 <_io.TextIOWrapper name='D:\\python3.3.2\\Hello.txt' mode='r' encoding='cp936'>
 >>> f.read()
 "A. HISTORY OF THE SOFTWARE\n==========================\n\nPython was created in the early 1990s by Guido van Rossum at Stichting\nMathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands\nas a successor of a language called ABC.  Guido remains Python's\nprincipal author, although it includes many contributions from others.\n\nIn 1995, Guido continued his work on Python at the Corporation for\nNational Research Initiatives (CNRI, see http://www.cnri.reston.va.us)\nin Reston, Virginia where he released several versions of the\nsoftware."
 >>> f.close()
 >>> f = open("D:\\python3.3.2\Hello.txt")
 >>> f.read(5)
 'A. HI'
 >>> f.tell()   #返回当前光标所在文件的位置
 5
 >>> f.readline()
 'STORY OF THE SOFTWARE\n'
将f放入到列表
 
>>> f = open("D:\\python3.3.2\Hello.txt",'w')#w模式写入会覆盖已存在的文件（即原文件内容全部被删除），a模式则在末尾追加写入
 >>> f.write('who are you')          #返回的是写入的字符数
 11
 >>> f.close()
 
 
 
029 文件：一个任务
 
•任务：将文件（record.txt）中的数据进行分割并按照以下规律保存起来：
 
–小甲鱼的对话单独保存为boy_*.txt的文件（去掉“小甲鱼:”）
 
–小客服的对话单独保存为girl_*.txt的文件（去掉“小客服:”）
 
–文件中总共有三段对话，分别保存为boy_1.txt, girl_1.txt，boy_2.txt, girl_2.txt, boy_3.txt, gril_3.txt共6个文件（提示：文件中不同的对话间已经使用“==========”分割）
 
test1：
 
f = open("record.txt")
 
boy = []
 girl = []
 count = 1
 
for each_line in f:
     if each_line[:6] != '======':#判断是否连续读到六个=
         (role,line_spoken) = each_line.split(':',1)#split以:进行字符切割，
         #将切得到的两部分内容依次存放在role与line_spoken中
         if role == '小甲鱼':
             boy.append(line_spoken)#将小甲鱼说的内容添加到列表boy中
         if role == '小客服':
             girl.append(line_spoken)#将小客服说的内容添加到列表girl中
     else:
         file_name_boy = 'boy_' + str(count) + '.txt'
         file_name_girl = 'girl_' + str(count) + '.txt'
 
        boy_file = open(file_name_boy,'w')#以w模式新建一个以file_name_boy命名的txt文件
         girl_file = open(file_name_girl,'w')#并贴上boy_file的标签
 
        boy_file.writelines(boy)#将列表boy中的内容写入到boy_file文件中
         girl_file.writelines(girl)
 
        boy_file.close()#关闭boy_file文件
         girl_file.close()
 
        boy = []#清空列表boy
         girl = []
         count += 1
 
file_name_boy = 'boy_' + str(count) + '.txt'
 file_name_girl = 'girl_' + str(count) + '.txt'
 
boy_file = open(file_name_boy,'w')
 girl_file = open(file_name_girl,'w')
 
boy_file.writelines(boy)
 girl_file.writelines(girl)
 
boy_file.close()
 girl_file.close()#记得关闭文件
 
 
test2：
 
 
 
def save_file(boy,girl,count):
     file_name_boy = 'boy_' + str(count) + '.txt'
     file_name_girl = 'girl_' + str(count) + '.txt'
 
    boy_file = open(file_name_boy,'w')
     girl_file = open(file_name_girl,'w')
 
    boy_file.writelines(boy)
     girl_file.writelines(girl)
 
    boy_file.close()
     girl_file.close()
 
def split_file(file_name):
     f = open(file_name)
 
    boy = []
     girl = []
     count = 1
 
    for each_line in f:
         if each_line[:6] != '======':
             (role,line_spoken) = each_line.split(':',1)#split以:进行字符切割，
             #将切得到的两部分内容依次存放在role与line_spoken中
             if role == '小甲鱼':
                 boy.append(line_spoken)
             if role == '小客服':
                 girl.append(line_spoken)
         else:
             save_file(boy,girl,count)
 
            boy = []
             girl = []
             count += 1
 

     save_file(boy,girl,count)
     f.close()
 
split_file('record.txt')
 
030 文件系统：介绍一个高大上的东西
 
os模块中关于文件/目录常用的函数使用方法
 
>>> import os
 >>> os.getcwd()
 'D:\\python3.3.2\\小甲鱼python\\python程序\\第二十九课'
 
>>> os.listdir('D:\\python3.3.2\\小甲鱼python\\python程序\\第二十九课')
 ['boy_1.txt', 'boy_2.txt', 'boy_3.txt', 'girl_1.txt', 'girl_2.txt', 'girl_3.txt', 'record.txt', 'test.py', 'test2.py']
 
 
 
 
os.path模块中关于路径常用的函数使用方法
 
 
 >>> os.path.getsize('python.exe')  #获取文件的尺寸，返回值以字节为单位
 

031 永久存储：腌制一缸美味的泡菜(pickle)
 
python提供了一个标准的模块pickle，可以非常容易地将列表、字典这类复杂的数据类型存储为文件。它几乎可以把所有python的对象都转化为二进制的形式存放，这个过程称为pickling，从二进制转换回对象的过程称为unpickling
 
pickling过程
 
>>> import pickle
 >>> my_list = [123,3,14,'小甲鱼',['another list']]
 
>>> pickle_file = open('D:\\python3.3.2\小甲鱼python\python程序\第三十节课\my_list.pkl','wb')  #二进制写形式打开文件
 >>> pickle.dump(my_list,pickle_file)
 >>> pickle_file.close()
 
 
unpickling过程       
 
>>> import pickle
 >>> pickle_file = open('D:\\python3.3.2\小甲鱼python\python程序\第三十节课\my_list.pkl','rb')#以二进制读形式打开文件
 >>> my_list = pickle.load(pickle_file)
 >>> print(my_list)
 [123, 3, 14, '小甲鱼', ['another list']]
 
实例：城市天气打包
 
 
>>> pickle_file = open('D:\\python3.3.2\小甲鱼python\python程序\第三十一节课\city_data.pkl','wb')
 >>> pickle.dump(city,pickle_file)
 >>> pickle_file.close()
 
 
032 异常处理：你不可能总是对的
 
实例1：
 
file_name = input('请输入需要打开的文件名:')
 file = open(file_name)
 print('文件的内容是：')
 for each_line in file:
     print(each_line)
 file.close()
 
注：py文件与要打开的文件在同一个文件下则不需要加路径
 
Python标准异常总结
 
 
以下是 Python 内置异常类的层次结构：
 
 
        
 
033 异常处理：你不可能总是对的2
 
try-except语句
 
try:
 
  检测范围
 
except Exception[as reason]:
 
  出现异常（Exception）后的处理代码
 
实例1：
 
try:
     f = open('TE.txt')
     print(f.read())
     f.close()
 except OSError:
     print('文件打开过程中出错了！！！')
 
 
实例2：
 
try:
     f = open('TE.txt')
     print(f.read())
     f.close()
 except OSError as reason:
     print('文件打开出错原因是:\n' + str(reason))
 
 
实例3：
 
try:
     sum = 1 + '1'
     f = open('TE.txt')
     print(f.read())
     f.close()
 except OSError as reason:
     print('文件打开出错原因是:\n' + str(reason))
 except TypeError as reason:
     print('类型出错原因是:\n' + str(reason))
 
 
实例4（多个异常统一处理）：
 
try:
     sum = 1 + '1'
     f = open('TE.txt')
     print(f.read())
     f.close()
 except(OSError, TypeError):
     print('出错了')
 
 
注：try语句一旦检测到异常，剩下的语句将不会被执行
 
try-finally语句
 
try:
 
  检测范围
 
except Exception[as reason]:
 
  出现异常（Exception）后的处理代码
 
finally:
 
  无论如何都会被执行的代码
 
实例5：
 
try:
     f = open('test.txt')
     print(f.read())
     sum = 1 + '1'
 except (OSError,TypeError)as reason:
     print('出错了\n原因是:' + str(reason))
 finally:
     f.close()
 
raise语句可以自己抛出一个异常
 
 
034 丰富的else语句及简洁的with语句
 
丰富的else语句
 
•要么怎样，要么不怎样
 
if 条件：
     条件为真执行
 else：
     条件为假执行      
 
•干完了能怎样，干不完就别想怎样
 
实例1：
 
def showMaxFactor(num):
     count = num // 2#//为整除，判断是素数，只需依次判断当前数num除以1到（num // 2）都不能整除即可
     while count > 1:
         if num % count == 0:#判断是否整除
             print('%d最大的约数是%d' % (num, count))
             break#跳出循环后else并不执行
         count -= 1
     else:#当while循环不成立时，或者理解为while循环完全被执行完了，没有给中途跳出（即break）
         print('%d是素数！' % num)
 
num = int(input('请输入一个数：'))
 showMaxFactor(num)
 
注：else与for语句搭配与while语句相同
 
没有问题？那就干
 
只要try语句块里没有出现任何异常，那么就会执行else语句块里的内容啦
 
实例2：
 
try:#尝试运行以下程序
     print(int('abc'))
 except ValueError as reason:#如果程序有异常时
     print('出错了：' + str(reason))
 else:#程序无异常时
     print('没有任何异常！')
 
 
实例3：
 
try:
     print(int('123'))
 except ValueError as reason:
     print('出错了：' + str(reason))
 else:
     print('没有任何异常！')
 
 
简洁的with语句（with会自动帮你关闭文件）
 
实例4：
 
try:
     with open('test.txt','w') as f:
         for each_line in f:
             print(each_line)
 except (OSError,TypeError) as reason:
     print('出错了\n原因是:' + str(reason))
 
 
035 图形用户界面入门：EasyGui
 
图形用户界面编程，也就是平时常说的GUI（Graphical User  Interface）,python有一个非常简单的GUI工具包：EasyGui
 
GUI的安装
 
 
 
导入方法一：
 
>>> import easygui         #导入EasyGui
 >>> easygui.msgbox('嗨，亦我飞也')
 
 
导入方法二：
 
>>> from easygui import *
 >>> msgbox('嗨，亦我飞也')
 
 
导入方法三（推荐使用）：
 
>>> import easygui as g
 >>> g.msgbox('嗨，亦我飞也')
 
 
显示图片（注：图片需要为GIF格式，且存放在python.exe通目录）
 
>>> easygui.buttonbox(msg='你喜欢以下哪种水果',title='亦我飞也',choices=('草莓','西瓜','芒果'),image='aa.gif')
 
 
实例1：
 
import easygui as g
 import sys
  
 while 1:
     g.msgbox("嗨，欢迎进入第一个界面小游戏")
     msg = "请问你希望在鱼C工作室学习到什么知识呢"
     title="小游戏互动"
     choices=["谈恋爱","编程","OOXX","琴棋书画"]
     choice=g.choicebox(msg,title,choices)
  
     #note that we convert choice to string,in case
     #the user cancelled the choice,and we got None
     g.msgbox("你的选择是:"+str(choice),"结果")
     msg="你希望重新开始小游戏吗?"
     title=" 请选择"
     if g.ccbox(msg,title):  #show a Contiue/Cancel dialog
         pass #user chose Contonue
     else:
         sys.exit(0)  #user chose Cancel
 
 
 
 
 
修改窗口大小（choicebox）
 
 
 
修改文字大小（PROPORTIONAL_FONT）
 
 
036 类和对象：给大家介绍对象
 
给大家介绍对象
 
把乱七八糟的数据扔进列表里，称数据层面的封装
 
把常用的代码段打包成一个函数，称语句层面的封装
 
把数据和代码都封装在一起，称对象层面的封装
 
 
对象 = 属性 + 方法
 
对象可以从静态（属性）与动态（方法）两个特征来描述
 
 
OO（面向对象）的特征
 
 
继承
 
class Turtle: # Python 中的类名约定以大写字母开头
     """关于类的一个简单例子"""
     # 属性
     color = 'green'
     weight = 10
     legs = 4
     shell = True
     mouth = '大嘴'
 
    # 方法
     def climb(self):
         print("我正在很努力的向前爬......")
 
    def run(self):
         print("我正在飞快的向前跑......")
 
    def bite(self):
         print("咬死你咬死你！！")
 
    def eat(self):
         print("有得吃，真满足^_^")
 
    def sleep(self):
         print("困了，睡了，晚安，Zzzz")
 
调用类中的方法：
 
>>> tt = Turtle()     #声明tt对象继承Turtle()
 >>> tt.climb()
 我正在很努力的向前爬......
 >>> tt.bite()
 咬死你咬死你！！
 
定义一个带列表类MyList，将list2对象继承于它，则列表的功能继承它的对象都可以使用
 
>>> class MyList(list):
     pass
 
>>> list2 = MyList()
 
>>> list2.append(5)
 >>> list2.append(6)
 
>>> list2.append(1)
 >>> list2
 [5, 6, 1]
 >>> list2.sort()
 >>> list2
 [1, 5, 6]
 
多态（下例中都调用的名字相同的方法，但实现不一样）
 
>>> class A:
     def fun(self):
         print('我是小A。。。')
 
        
 >>> class B:
     def fun(self):
         print('我是小B。。。')
 
        
 >>> a = A()
 >>> b = B()
 >>> a.fun()
 我是小A。。。
 >>> b.fun()
 我是小B。。。
 
037 类和对象：面向对象编程
 
self是什么？
 
Python的self其实就相当于C++的this指针。由同一个类可以生产无数对象，当一个对象的方法被调用的时候，对象会将自身的引用作为第一个参数传给该方法，那么python就知道需要操作哪个对象的方法了。
 
>>> class Ball:
     def setName(self,name):
         self.name = name
     def kick(self):
         print('我叫%s,该死的，谁踢我。。。' % self.name)
 
        
 >>> a = Ball()
 
>>> a.setName('球A')
 >>> b = Ball()
 
>>> b.setName('球B')
 
>>> a.kick()
 我叫球A,该死的，谁踢我。。。
 >>> b.kick()
 我叫球B,该死的，谁踢我。。。
 
你听说过Python的魔法方法吗？
 
python的这些具有魔法的方法，总是被双下划线所包围，例如__init__()，即构造方法，也称构造函数，这个方法会在对象被创建时自动调用。其实，实例化对象时是可以传入参数的，这些参数会自动传入__init__()方法中，可以通过重写这个方法来自定义对象的初始化操作
 
实例：
 
>>> class Ball():
     def __init__(self,name):
         self.name = name
     def kick(self):
         print('我叫%s,该死的，谁踢我。。。' % self.name)
 
        
 >>> b = Ball('小土豆')
 >>> b.kick()
 我叫小土豆,该死的，谁踢我。。。
 
公有和私有？python内部采用了一种叫 name mangling(名字改编)的技术
 
默认上对象的属性和方法都是公开的，可以直接通过点操作符（.）进行访问：
 
>>> class Person:
     name = '亦我飞也'
 
    
 >>> p = Person()
 >>> p.name
 '亦我飞也'
 
为了实现定义私有变量，只需要在变量名或函数名前加上"__"两个下划线，那么这个函数或变量就会变成私有的了：
 
私有变量不可以直接由外部访问
 
>>> class Person:
     __name = '亦我飞也'
 
    
 >>> p = Person()
 >>> p.__name
Traceback (most recent call last):
   File "<pyshell#65>", line 1, in <module>
     p.__name
 AttributeError: 'Person' object has no attribute '__name'
 
室友变量可以由内部（内部函数）进行访问
 
>>> class Person:
     __name = '亦我飞也'
     def getName(self):
         return self.__name
 
    
 >>> p = Person()
 >>> p.__name
Traceback (most recent call last):
   File "<pyshell#72>", line 1, in <module>
     p.__name
 AttributeError: 'Person' object has no attribute '__name'
 >>> p.getName()
 '亦我飞也'
 
其实，name mangling(名字改编)技术，只是把双下划线开头的变量进行了改名而已。实际上在外部使用“_类名__变量名“即可访问双下划线开头的私有变量了：
 
>>> p._Person__name
 '亦我飞也'
 
038 类和对象：继承
 
继承
 
                  子类                              父类
 
class DerivedClassName(BaseClassName):
 
……
 
实例：一个子类可以继承它的父类的所有属性和方法
 
>>> class Parent:
     def hello(self):
         print('正在调用父类的方法。。。')
 
        

 >>> class Child(Parent):    #子类继承父类
     pass     #直接往下执行
 
>>> p = Parent()
 >>> p.hello()
 正在调用父类的方法。。。
 >>> c = Child()
 >>> c.hello()
 正在调用父类的方法。。。
 
如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法和属性（即子类方法属性改变，父类是不变的）
 
>>> class Child(Parent):
     def hello(self):
         print('正在调用子类的方法')
 
        
 >>> c = Child()
 >>> c.hello()
 正在调用子类的方法
 >>> p.hello()
 正在调用父类的方法。。。
 
实例2：
 
import random as r
 class Fish:
     def __init__(self):
         self.x = r.randint(0,10)
         self.y = r.randint(0,10)
 
    def move(self):
         self.x -= 1
         print('我的位置是：',self.x,self.y)
 

 class Goldfish(Fish):
     pass
 
class Garp(Fish):
     pass
 
class Shark(Fish):
     def __init__(self):
         self.hungry = True
 
    def eat(self):
         if self.hungry:
             print('吃货的梦想就是天天有的吃')
             self.hungry = False
         else:
             print('太撑了，吃不下了！')
 
>>> fish = Fish()
 >>> fish.move()
 我的位置是： -1 10
 >>> fish.move()
 我的位置是： -2 10
 >>> goldfish = Goldfish()
 >>> goldfish.move()
 我的位置是： 2 3
 >>> goldfish.move()
 我的位置是： 1 3
 >>> shark = Shark()
 >>> shark.eat()
 吃货的梦想就是天天有的吃
 >>> shark.eat()
 太撑了，吃不下了！
 >>> shark.move()    #报错原因时因为子类重写构造函数，覆盖了父类D的构造函数
Traceback (most recent call last):
   File "<pyshell#9>", line 1, in <module>
     shark.move()
   File "D:\python3.3.2\小甲鱼python\python程序\第三十八节课\fish.py", line 8, in move
     self.x -= 1
 AttributeError: 'Shark' object has no attribute 'x'
 
注：继承父类属性的子类，其变量值只属于当前子类，是子类的局部变量
 
报错修改部分解决方法一：调用未绑定的父类方法
 
 
>>> shark = Shark()
 >>> shark.move()
 我的位置是： 2 1
 >>> shark.move()
 我的位置是： 1 1
 
报错修改部分解决方法二：使用super函数（super函数会帮我们自动找到基类的方法，而且还自动为我们传入self参数）
 
 
>>> shark = Shark()
 >>> shark.move()
 我的位置是： 1 1
 >>> shark.move()
 我的位置是： 0 1
 
多重继承
 
class DerivedClassName(Base1, Base2, Base3):
 
……
 
实例：子类c同时继承基类Base1和基类Base2
 
>>> class Base1:
     def fool1(self):
         print('我是fool1,我为Base1代言。。。')
 
        
 >>> class Base2:
     def fool2(self):
         print('我是fool2,我为Base2代言。。。')
 
        
 >>> class C(Base1,Base2):
     pass
 
>>> c = C()
 >>> c.fool1()
 我是fool1,我为Base1代言。。。
 >>> c.fool2()
 我是fool2,我为Base2代言。。。
 
039 类和对象：拾遗
 
组合（将需要的类一起进行实例化并放入新的类中）
 
实例：
 
class Turtle:
     def __init__(self,x):
         self.num = x
 
class Fish:
     def __init__(self,x):
         self.num = x
 
class Pool:
     def __init__(self,x,y):
         self.turtle = Turtle(x)
         self.fish = Fish(y)
 
    def print_num(self):
         print('水池里一共有乌龟 %d 条,鱼 %d 条' % (self.turtle.num,self.fish.num))
 
>>> pool = Pool(5,2)
 >>> pool.print_num()
 水池里一共有乌龟 5 条,鱼 2 条
 
•现在要求定义一个类，叫水池，水池里要有乌龟和鱼。
 
类、类对象和实例对象
 
以下例子可见，对实例对象c的count属性赋值后，就相当于覆盖了类对象C的count属性。如果没有赋值覆盖，那么引用的是类对象的count属性
 
>>> a = C()
 >>> b = C()
 >>> c = C()
 >>> print(a.count,b.count,c.count)
 0 0 0
 >>> c.count += 10
 >>> print(a.count,b.count,c.count)
 0 0 10
 >>> C.count += 100
 >>> print(a.count,b.count,c.count)
 100 100 10
 
另外，如果属性的名字跟方法名相同，属性会覆盖方法：
 
>>> class C:
     def x(self):
         print('X-man')
 
        
 >>> c = C()
 >>> c.x()
 X-man
 >>> c.x = 1              #新定义对象c的一个x属性，并赋值为1
 >>> c.x
 1
 >>> c.x()     #可见，方法x()已经被属性x给覆盖了
Traceback (most recent call last):
   File "<pyshell#8>", line 1, in <module>
     c.x()
 TypeError: 'int' object is not callable
 
结论：不要试图在一个类里边定义出所有能想到的特性和方法，应该利用继承和组合机制来进行扩展；用不同的词性命名，如属性名用名词、方法名用动词，并使用骆驼命名法等。
 
到底什么是绑定？
 
实例1：（python严格要求需要有实例才能被调用，即绑定概念）
 
>>> class BB:
     def printBB():        #缺少self，导致无法绑定具体对象
         print('no zuo no die')
 
        
 >>> BB.printBB()
 no zuo no die
 >>> bb = BB()
 >>> bb.printBB()        #出现错误原因是由于绑定机制，自动把bb对象作为第一个参数传入
Traceback (most recent call last):
   File "<pyshell#15>", line 1, in <module>
     bb.printBB()
 TypeError: printBB() takes 0 positional arguments but 1 was given
  
 
•Python严格要求方法需要有实例才能被调用，这种限制其实就是Python所谓的绑定概念。
 
040 类和对象：一些相关的BIF
 
一些相关的BIF
 
issubclass(class, classinfo)  如果第一个参数（class）是第二个参数（classinfo）的一个子类，则返回True，否则返回False
 
>>> class A:
     pass
 
>>> class B(A):
     pass
 
>>> issubclass(B,A)
 True
 >>> issubclass(B,B)   #一个类被认为是其自身的子类
 True
 >>> issubclass(B,object)      # object是所有类的基类
 True
 >>> class C:
     pass
 
>>> issubclass(B,C)
 False
 
isinstance(object, classinfo)  如果第一个参数（object）是第二个参数（classinfo）的实例对象，则返回True，否则返回False
 
>>> issubclass(B,C)       注：第一个参数如果不是对象，则永远返回False
 False
 >>> b1 = B()
 >>> isinstance(b1,B)
 True
 >>> isinstance(b1,C)
 False
 >>> isinstance(b1,A)
 True
 >>> isinstance(b1,(A,B,C))
 True
 
hasattr(object, name)  用来测试一个对象里是否有指定的属性，第一个参数（object）是对象，第二个参数（name）是属性名（属性的字符串名字）
 
>>> class C:
     def __init__(self,x=0):
         self.x = x
 
        
 >>> c1 = C()
 >>> hasattr(c1,'x')    #注意，属性名要用引号括起来
True
 
 
 
getattr(object, name[, default])  返回对象指定的属性值，如果指定的属性不存在，则返回default(可选参数);若没有设置default参数，则抛出异常
 
>>> getattr(c1,'x')
 0
 >>> getattr(c1,'y')
Traceback (most recent call last):
   File "<pyshell#25>", line 1, in <module>
     getattr(c1,'y')
 AttributeError: 'C' object has no attribute 'y'
 
setattr(object, name, value)  可以设置对象中指定属性的值，如果指定的属性不存在，则会新建属性并赋值
 >>> setattr(c1,'y','FishC')
 >>> getattr(c1,'y')
 'FishC'
 
delattr(object, name)  用于删除对象中指定的属性，如果属性不存在，抛出异常。
 
>>> delattr(c1,'y')
 >>> delattr(c1,'Z')
Traceback (most recent call last):
   File "<pyshell#30>", line 1, in <module>
     delattr(c1,'Z')
 AttributeError: Z
 
property(fget=None, fset=None, fdel=None, doc=None)  用来通过属性设置属性，第一个参数是获取属性的方法名，第二个参数是设置属性的方法名，第三个参数是删除属性的方法名
 
>>> class C:
     def __init__(self,size =10):
         self.size = size
     def getSize(self):
         return self.size
     def setSize(self,value):
         self.size = value
     def delSize(self):
         del self.size
     x=property(getSize,setSize,delSize)
 
    
 
>>> c = C()
 >>> c.x         #调用getSize()
 10
 >>> c.x = 12      #调用SetSize()
 >>> c.x
 12
 >>> c.size
 12
 >>> del c.x      #调用DelSize()
 >>> c.size
Traceback (most recent call last):
   File "<pyshell#53>", line 1, in <module>
     c.size
 AttributeError: 'C' object has no attribute 'size'
 
041 魔法方法：构造和析构
 
 
__init__(self[, ...]) 方法是类在实例化成对象的时候首先会调用的一个方法
 
>>> class Rectangle:
     def __init__(self,x,y):
         self.x = x
         self.y = y
     def getPeri(self):
         return (self.x + self.y) * 2
     def getArea(self):
         return self.x * self.y
>>> rect = Rectangle(5,2)
 >>> rect.getPeri()
 14
 >>> rect.getArea()
 10
 
   注：__init__()方法的返回值一定是None 
 
其实，__new__()才是在一个对象实例化时候所调用的第一个方法，它的第一个参数是这个类（cla）,而其他的参数会直接传递给__init__()方法
 
__new__(cls[, ...])
 
>>> class CapStr(str):
     def __new__(cls,string):
         string = string.upper()
         return str.__new__(cls,string)
 
    
 >>> a = CapStr('hello world')
 >>> a
 'HELLO WORLD
 
__del__(self)  当对象将要被销毁的时候，这个方法就会被调用。但要注意，并非del x就相当于调用x.__del__()，__del__()方法是当垃圾回收机制回收这个对象的时候才调用的。
 
>>> class C:
     def __init__(self):
         print('我是__init__方法，我被调用了...')
     def __del__(self):
         print('我是__del__方法，我被调用l...')
 
        
 >>> c1 = C()     #创建对象c1
 我是__init__方法，我被调用了...
 >>> c2 = c1
 >>> c3 = c2
 >>> del c1
 >>> del c2
 >>> del c3   #删除c3时，对象c1才会彻底被删除（即没有标签指向对象c1时，其才会被回收）
 我是__del__方法，我被调用l...
 
042 魔法方法：算术运算
 
python2.2以后，对类和类型进行了统一，做法就是讲int()、float()、str()、list()、tuple()这些BIF转换为工厂函数（类对象）：
 
>>> type(len)
 <class 'builtin_function_or_method'>            #普通的BIF
 >>> type(int)
 <class 'type'>             #工厂函数（类对象），当调用它们的时候，其实就是创建了一个相应的实例对象
 >>> type(dir)
 <class 'builtin_function_or_method'>
 >>> type(list)
 <class 'type'>
 
>>> a = int('123')        #创建一个相应的实例对象a
 >>> b = int('345')
 >>> a + b              #python在两个对象进行相加操作
 468
 
 
举个例子，下面定义一个比较特立独行的类：
 
>>> class New_int(int):
     def __add__(self,other):
         return int.__sub__(self,other)
     def __sub__(self,other):
         return int.__add__(self,other)
 
    
 >>> a = New_int(3)
 >>> b = New_int(5)
 >>> a + b    #两个对象相加，触发 __add__(self,other)方法
 -2
 >>> a - b
 8
 >>>
 
实例2：
 
>>> class New_int(int):
     def __add__(self,other):
         return (int(self) + int(other))       #将self与other强制转换为整型，所以不会出现两个对象相加触发__add__()方法
     def __sub__(self,other):
         return (int(self) - int(other))
 
    
 >>> a = New_int(3)
 >>> b = New_int(5)
 >>> a + b
 8
 
043 魔法方法：算术运算2
 
实例1：
 
>>> class int(int):
     def __add__(self,other):
         return int.__sub__(self,other)
 
    
 >>> a = int(3)
 >>> b = int(2)
 >>> a + b
 1
 
反运算：
 
 
反运算与算术运算符的不同之处是，反运算多了一个'r'，例如 __add__()的反运算对应为 __radd__()
 
>>> a + b
 
这里a是加数，b是被加数，如果a对象的__add__()方法没有实现或者不支持相应的操作，那么python就会自动调用b的__radd__()方法
 
实例：
 
>>> class Nint(int):
     def __radd__(self,other):
         return int.__sub__(self,other)
 
    
 >>> a = Nint(5)
 >>> b = Nint(3)
 >>> a + b      #由于a对象默认有__add__()方法，所以b的__radd__()没有执行
 8
 
实例2：
 
>>> class Nint(int):
     def __radd__(self,other):
         return int.__sub__(self,other)
 
    
 >>> b = Nint(5)
 >>> 3 + b         #由于3无__add__()方法，所以执行b的反运算__radd__(self,other)方法，其中self是b对象
 2
 
注：在重写反运算魔法方法时，一定要注意顺序问题。
 
增量赋值运算：
 
 
比较操作符：
 
 
其它操作符：
 
 
044 魔法方法：简单定制
 
简单定制
 
•基本要求：
 
–定制一个计时器的类
 
–start和stop方法代表启动计时和停止计时
 
–假设计时器对象t1，print(t1)和直接调用t1均显示结果
 
–当计时器未启动或已经停止计时，调用stop方法会给予温馨的提示
 
–两个计时器对象可以进行相加：t1 + t2
 
–只能使用提供的有限资源完成
 
你需要这些资源
 
•使用time模块的localtime方法获取时间
 
–扩展阅读：time 模块详解（时间获取和转换）
 
有关time模块的localtime方法获取时间（参考：
 
https://fishc.com.cn/forum.php?mod=viewthread&tid=51326&extra=page%3D1%26filter%3Dtypeid%26typeid%3D403）
 
•time.localtime返回struct_time的时间格式
 
•表现你的类：__str__ 和 __repr__
 
实例：
 
import time as t   #导入时间模块，调用对象t
 
class Mytimer():
     def __init__(self):
         self.unit = ['年','月','天','小时','分钟','秒']
         self.prompt = "未开始计时"
         self.lasted = []
         self.begin = 0  #属性
         self.end = 0
     def __str__(self):
         return self.prompt
 
    __repr__ = __str__
 
    def __add__(self,other):   #重写加法操作符，运行时间相加
         prompt = "总共运行了"
         result = []
         for index in range(6):
             result.append(self.lasted[index] + other.lasted[index])
             if result[index]:
                 prompt += (str(result[index]) + self.unit[index])
         return prompt
                            
     #开始计时
     def start(self):    #方法，属性名和方法名不能相同
         if not self.stop:
             self.prompt = ("提示：请先调用stop()停止计时！")
         else:
             self.begin = t.localtime()
             print('计时开始...')
 
    #停止计时
     def stop(self):
         if not self.begin:
             print('提示：请先调用start()进行计时！')
         else:
             self.end = t.localtime()
             self._calc()
             print('计时结束！')
 
    #内部方法，计算运行时间
     def _calc(self):
         self.prompt = "总共运行了"
         for index in range(6):
             self.lasted.append(self.end[index] - self.begin[index])
             if self.lasted[index]:
                 self.prompt += (str(self.lasted[index]) + self.unit[index])
         #为下一轮计时初始化变量
         self.begin = 0
         self.end = 0
 
>>> t1 = Mytimer()
 >>> t1.stop()
 提示：请先调用start()进行计时！
 >>> t1.start()
 计时开始...
 >>> t1.stop()
 计时结束！
 >>> t1
 总共运行了4秒
 >>> t2 = Mytimer()
 >>> t2.start()
 计时开始...
 >>> t2.stop()
 计时结束！
 >>> t2
 总共运行了4秒
 >>> t1 + t2
 '总共运行了8秒'        
 
进阶定制
 
•如果开始计时的时间是（2022年2月22日16:30:30），停止时间是（2025年1月23日15:30:30），那按照我们用停止时间减开始时间的计算方式就会出现负数（3年-1月1天-1小时），你应该对此做一些转换。
 
•现在的计算机速度都非常快，而我们这个程序最小的计算单位却只是秒，精度是远远不够的。
 
045 魔法方法：属性访问
 
属性访问
 
•__getattr__(self, name)
 
–定义当用户试图获取一个不存在的属性时的行为
 
•__getattribute__(self, name)
 
–定义当该类的属性被访问时的行为
 
•__setattr__(self, name, value)
 
–定义当一个属性被设置时的行为
 
•__delattr__(self, name)
 
–定义当一个属性被删除时的行为
 
实例1：
 
class C:
     def __getattribute__(self, name):
         print('getattribute')
         # 使用 super() 调用 object 基类的 __getattribute__ 方法
         return super().__getattribute__(name)
 
    def __setattr__(self, name, value):
         print('setattr')
         super().__setattr__(name, value)
 
    def __delattr__(self, name):
         print('delattr')
         super().__delattr__(name)
 
    def __getattr__(self, name):
         print('getattr')
 
>>> c = C()
 >>> c.x
 getattribute
 getattr
 >>> c.x = 1
 setattr
 >>> c.x
 getattribute
 1
 >>> del c.x
 delattr
 >>> setattr(c,'y','Yellow')
 setattr
 
练习要求
 
•写一个矩形类，默认有宽和高两个属性；
 
•如果为一个叫square的属性赋值，那么说明这是一个正方形，值就是正方形的边长，此时宽和高都应该等于边长。
 
实例2：
 
class Rectangle:
     def __init__(self, width=0, height=0):
         self.width = width
         self.height = height
 
    def __setattr__(self, name, value):#一发生赋值操作，则会触发__setattr__()魔法方法
         if name == 'square':#判断name属性是否为正方形
             self.width = value
             self.height = value
         else:
             self.__dict__[name] = value
 
    def getArea(self):
         return self.width * self.height
 
>>> r1 = Rectangle(4,5)
 >>> r1.getArea()
 20
 >>> r1.square = 10
 >>> r1.getArea()
 100
 
046 魔法方法：描述符（Property的原理）
 
描述符
 
•描述符就是将某种特殊类型的类的实例指派给另一个类的属性。
 
•__get__(self, instance, owner)
 
–用于访问属性，它返回属性的值
 
•__set__(self, instance, value)
 
–将在属性分配操作中调用，不返回任何内容
 
•__delete__(self, instance)
 
–控制删除操作，不返回任何内容
 
实例：
 
>>> class MyDecriptor:
     def __get__(self,instance,owner):
         print("getting...",self,instance,owner)
     def __set__(self,instance,value):
         print("setting...",self,instance,value)
     def __delete__(self,instance):
         print("deleting...",self,instance)
 
 
 
>>> class Test:
     x = MyDecriptor()   #取Mydecriptor类的实例指派给Test类的属性x
 
>>> test = Test()
 >>> test.x
 getting... <__main__.MyDecriptor object at 0x00000000033467F0> <__main__.Test object at 0x000000000335EF98> <class '__main__.Test'>
 >>> test
 <__main__.Test object at 0x000000000335EF98>
 >>> test.x = "X-man"
 setting... <__main__.MyDecriptor object at 0x00000000033467F0> <__main__.Test object at 0x000000000335EF98> X-man
 >>> del test.x
 deleting... <__main__.MyDecriptor object at 0x00000000033467F0> <__main__.Test object at 0x000000000335EF98>
 
 
 
实例2：
 
>>> class MyProperty:
     def __init__(self,fget = None,fset = None,fdel = None):
         self.fget = fget
         self.fset = fset
         self.fdel = fdel
     def __get__(self,instance,owner):
         return self.fget(instance)
     def __set__(self,instance,value):
         self.fset(instance,value)
     def __delete__(self,instance):
         self.fdel(instance)
 
        
 >>> class C:
     def __init__(self):
         self._x = None
     def getX(self):
         return self._x
     def setX(self,value):
         self._x = value
     def delX(self):
         del self._x
     x = MyProperty(getX,setX,delX)
 
    
 >>> c = C()
 >>> c.x = "HELLOW"
 >>> c.x
 'HELLOW'
 >>> c._x
 'HELLOW'
 >>> del c.x
 >>> c._x
Traceback (most recent call last):
   File "<pyshell#70>", line 1, in <module>
     c._x
 AttributeError: 'C' object has no attribute '_x'
 
练习要求
 
•先定义一个温度类，然后定义两个描述符类用于描述摄氏度和华氏度两个属性。
 
•要求两个属性会自动进行转换，也就是说你可以给摄氏度这个属性赋值，然后打印的华氏度属性是自动转换后的结果。
 
实例3：
 
ss Celsius:  #摄氏度描述符类
     def __init__(self,value = 26.0):#self为描述符类自身(此为摄氏度描述符类)的实例（此为cel)
         self.value = float(value)
     def __get__(self,instance,owner):#instance是这个描述符的拥有者所在的类的实例（此为temp)
         return self.value
     def __set__(self,instance,value):#owner是这个描述符的拥有者所在的类本身(此为温度类）
         self.value = float(value)
 
class Fahrenheit:   #华氏度描述符类
     def __get__(self,instance,owner):
         return instance.cel * 1.8 +32  #摄氏度转华氏度
     def __set__(self,instance,value):
         instance.cel = ((float)(value)- 32)/ 1.8   #华氏度转摄氏度
         
 class Temperature:   #温度类
     cel = Celsius()   #设置摄氏度属性（描述符类的实例指派给了温度类的属性）
     fah = Fahrenheit()#设置华氏度属性
 
>>> temp = Temperature()
 >>> temp.cel
 26.0
 >>> temp.fah
 78.80000000000001
 >>> temp.fah = 78.8
 >>> temp.cel
 25.999999999999996
 
047 魔法方法：定制序列
 
协议是什么？
 
•协议（Protocols）与其他编程语言中的接口很相似，它规定你哪些方法必须要定义。然而，在Python中的协议就显得不那么正式。事实上，在Python中，协议更像是一种指南。
 
容器类型的协议
 
•如果说你希望定制的容器是不可变的话，你只需要定义__len__()和__getitem__()方法。
 
•如果你希望定制的容器是可变的话，除了__len__()和__getitem__()方法，你还需要定义__setitem__()和__delitem__()两个方法。
 
练习要求
 
•编写一个不可改变的自定义列表，要求记录列表中每个元素被访问的次数。
 
class CountList:  #定义记录列表中每个元素访问次数类
     def __init__(self,*args): #参数是可变类型的
         self.values = [x for x in args]#将args的数据存入列表self.values中
         self.count = {}.fromkeys(range(len(self.values)),0)#创建字典，初试化为0
 
    def __len__(self):  #返回容器中元素的个数
         return len(self.values)#len方法用于返回参数的长度 
     def __getitem__(self,key):  #获取容器中指定元素的行为，key为访问对应的键
         self.count[key] += 1#每访问一次，字典键对应的键值加1
         return self.values[key]
 
>>> c1 = CountList(1,3,5,7,9)
 >>> c2 = CountList(2,4,6,8,10)
 >>> c1[1]  #c1[1]第一次访问
 3
 >>> c2[2]
 6
 >>> c1[1] + c2[2] #c1[1]第二次访问
 9
 >>> c1.count
 {0: 0, 1: 2, 2: 0, 3: 0, 4: 0}
 >>> c2.count
 {0: 0, 1: 0, 2: 2, 3: 0, 4: 0}
 
048 魔法方法：迭代器
 
迭代的意思类似于循环，每一次重复的过程被称为一次迭代的过程，而每一次迭代得到的结果会被用来作为下一次迭代的初始值。提供迭代方法的容器称为迭代器（如序列（列表、元组、字符串）、字典等）。
 
对一个容器对象调用iter()就得到它的迭代器，调用next()迭代器就会返回下一个值。入托迭代器没有值可以返回了，就会抛出异常。
 
•iter()
 
–__iter__()
 
•next()
 
–__next__()
 
实例1：
 
>>> string = "FishC"
 >>> it = iter(string)
 >>> next(it)
 'F'
 >>> next(it)
 'i'
 >>> next(it)
 's'
 >>> next(it)
 'h'
 >>> next(it)
 'C'
 >>> next(it)
Traceback (most recent call last):
   File "<pyshell#8>", line 1, in <module>
     next(it)
 StopIteration
 
一个容器如果是迭代器，那就必须实现__iter__()魔法方法，这个方法实际上就是返回迭代器本身。重点要实现的是__next__()魔法方法，因为它决定了迭代的规则。
 
实例2：
 
>>> class Fibs:
     def __init__(self):
         self.a = 0
         self.b = 1
     def __iter__(self):
         return self
     def __next__(self):
         self.a,self.b = self.b,self.a + self.b
         return self.a
 
    
 >>> fibs = Fibs()
 >>> for each in fibs:
     if each < 20:
         print(each)
     else:
         break
 
    
 1
 1
 2
 3
 5
 8
 13
 
实例3：
 
 
 
>>> class Fibs:
     def __init__(self,n =20):
         self.a = 0
         self.b = 1
         self.n = n
     def __iter__(self):
         return self
     
     def __next__(self):
         self.a,self.b = self.b,self.a + self.b
         if self.a > self.n:
             raise StopIteration
         return self.a
 
    
 >>> fibs = Fibs()
 >>> for each in fibs:
     print(each)
 
    
 1
 1
 2
 3
 5
 8
 13
 
 
 
>>> fibs = Fibs(10)
 >>> for each in fibs:
     print(each)
 
    
 1
 1
 2
 3
 5
 8
 
 
 
049 乱入：生成器
 
所谓协同程序，就是可以运行的独立函数调用，函数可以暂停或者挂起，并在需要的时候从程序离开的地方继续或者重新开始。
 
生成器可以暂时挂起函数，并保留函数的局部变量等数据，然后在再次调用它的时候，从上次暂停的位置继续执行下去。
 
一个函数中如果有yield语句，则被定义为生成器。
 
实例1：
 
>>> def myGen():
     print("生成器被执行了！")
     yield 1   #暂停一次，相当于return，返回1
     yield 2     #暂停一次，相当于return，返回2
 
    
 >>> myG = myGen()
 >>> next(myG)
 生成器被执行了！
 1
 >>> next(myG)
 2
 
像前面介绍的斐波那契的例子，也可以用生成器来实现：
 
>>> def fibs():
     a = 0
     b = 1
     while True:
         a,b = b,a + b
         yield a
 
        
 >>> for each in fibs():
     if each > 100:
         break
     print(each)
 
    
 1
 1
 2
 3
 5
 8
 13
 21
 34
 55
 89
 
列表推导式表达：
 
100以内，能被2整除，但不能被3整除的所有整数
 
>>> a = [i for i in range(100) if not (i % 2) and (i % 3 )]
 >>> a
 [2, 4, 8, 10, 14, 16, 20, 22, 26, 28, 32, 34, 38, 40, 44, 46, 50, 52, 56, 58, 62, 64, 68, 70, 74, 76, 80, 82, 86, 88, 92, 94, 98]
 
字典推导式：
 
10以内是否为偶数
 
>>> a = {i:i % 2 == 0 for i in range(10)}
 >>> a
 {0: True, 1: False, 2: True, 3: False, 4: True, 5: False, 6: True, 7: False, 8: True, 9: False}
 
集合推导式：
 
>>> a = {i for i in [1,2,3,3,4,5,5,5,6,7,7,8]}
 >>> a
 {1, 2, 3, 4, 5, 6, 7, 8}
 
元组生成器推导式：
 
>>> e = (i for i in range(5))
 >>> next(e)
 0
 >>> next(e)
 1
 >>> next(e)
 2
 
050 模块：模块就是程序
 
什么是模块
 
•容器 -> 数据的封装
 
•函数 -> 语句的封装
 
•类 -> 方法和属性的封装
 
•模块 -> 模块就是程序
 
命名空间
 
爱的宣言：世界上只有一个名字，使我这样牵肠挂肚，像有一根看不见的线，一头牢牢系在我心尖上，一头攥在你手中，这个名字就叫做鱼C工作室计算机一班的小花……
 
导入模块
 
•第一种：import 模块名
 
实例1：import导入模块
 
 
实例2：import导入模块
 
 
•第二种：from 模块名 import 函数名(不推荐使用)
 
 
 
•第三种：import 模块名 as 新名字（推荐使用）
 
TemperatureConversion文件：
 
def c2f(cal):
     return cal * 1.8 + 32
 def f2c(fah):
     return (fah - 32)/1.8
 
calc文件：
 
import TemperatureConversion as tc  #tc为取得新名字
 
print("32摄氏度 = %.2f 华氏度\n" % tc.c2f(32))
 print("99华氏度 = %.2f 摄氏度" % tc.f2c(99))
 
 
051 模块：__name__='__main__'、搜索路径和包
 
模块！模块！
 
实例1：为TemperatureConversion添加测试程序（TemperatureConversion被作为程序运行）
 
def c2f(cal):
     return cal * 1.8 + 32
 
def f2c(fah):
     return (fah - 32)/1.8
 
def test():
     print("0摄氏度 = %.2f 华氏度\n" % c2f(0))
     print("0华氏度 = %.2f 摄氏度" % f2c(0))
 
test()
 
 
运行calc文
 
 
当希望TemperatureConversion被调用时作为模块导入时
 
def c2f(cal):
     return cal * 1.8 + 32
 
def f2c(fah):
     return (fah - 32)/1.8
 
def test():
     print("0摄氏度 = %.2f 华氏度" % c2f(0))
     print("0华氏度 = %.2f 摄氏度" % f2c(0))
 
if __name__ == "__main__":#当此文件当做程序运行时，执行test()，否则不执行
     test()
 
运行calc文件
 
 
•if __name__ == ‘__main__’
 
•搜索路径（系统会首先搜索的路径）
 
>>> import sys
 >>> sys.path
 ['D:\\python3.3.2\\小甲鱼python\\python程序\\第五十节课\\Temperature', 'D:\\python3.3.2\\Lib\\idlelib', 'C:\\windows\\system32\\python33.zip', 'D:\\python3.3.2\\DLLs', 'D:\\python3.3.2\\lib', 'D:\\python3.3.2', 'D:\\python3.3.2\\lib\\site-packages']
 
添加搜索路径：
 
>>> import TemperatureConversion
Traceback (most recent call last):
   File "<pyshell#0>", line 1, in <module>
     import TemperatureConversion
 ImportError: No module named 'TemperatureConversion'
 
>>> import sys
 >>> sys.path.append("D:\\python3.3.2\WODE\Temperature")
 >>> sys.path
 ['', 'D:\\python3.3.2\\Lib\\idlelib', 'C:\\windows\\system32\\python33.zip', 'D:\\python3.3.2\\DLLs', 'D:\\python3.3.2\\lib', 'D:\\python3.3.2', 'D:\\python3.3.2\\lib\\site-packages', 'D:\\python3.3.2\\WODE\\Temperature']
 >>> import TemperatureConversion
 >>> TemperatureConversion.f2c(59)
 15.0
 
•包（package）
 
1.创建一个文件夹，用于存放相关的模块，文件夹的名字即包的名字；
 
2.在文件夹中创建一个__init__.py的模块文件，内容可以为空；
 
3.将相关的模块放入文件夹中
 
 
 
052 模块：像个极客一样去思考
 
使用print调用__doc__属性，可以带格式查看这个模块的简介
 
 
使用dir()可以查询到该模块定义了哪些变量、函数和类
 
053 论一只爬虫的自我修养
 
 
Python如何访问互联网？
 
 
 
 
•URL的一般格式为（带方括号[]的为可选项）：
 
protocol :// hostname[:port] / path / [;parameters][?query]#fragment
 
•URL由三部分组成： 
 
–第一部分是协议：http，https，ftp，file，ed2k…
 
–第二部分是存放资源的服务器的域名系统或IP地址（有时候要包含端口号，各种传输协议都有默认的端口号，如http的默认端口为80）。
 
–第三部分是资源的具体地址，如目录或文件名等。
 
054 论一只爬虫的自我修养2：实战
 
import urllib.request
 
response = urllib.request.urlopen('http://placekitten.com/g/500/600')#  返回文件对象response
 cat_imag = response.read()
 
with open('cat_500_600.jpg','wb') as f:
     f.write(cat_imag)
 
 
>>> response.geturl()
 'http://placekitten.com/g/500/600'
 >>> response.info()
 <http.client.HTTPMessage object at 0x00000000034EAA20>
 >>> print(response.info())
 Date: Sat, 27 Jul 2019 02:44:18 GMT
 Content-Type: image/jpeg
 Transfer-Encoding: chunked
 Connection: close
 Set-Cookie: __cfduid=d3cd08233581619b9ef8464ae93f7d5ff1564195458; expires=Sun, 26-Jul-20 02:44:18 GMT; path=/; domain=.placekitten.com; HttpOnly
 Access-Control-Allow-Origin: *
 Cache-Control: public, max-age=86400
 Expires: Sun, 28 Jul 2019 02:44:18 GMT
 CF-Cache-Status: HIT
 Age: 66459
 Vary: Accept-Encoding
 Server: cloudflare
 CF-RAY: 4fcb454ecc35ce6b-LHR
 

 >>> response.getcode()
 200
 
055 论一只爬虫的自我修养3：隐藏
 
修改 headers
 
•通过Request的headers参数修改
 
•
 
•通过Request.add_header()方法修改
 
代理
 
•步骤：
 
1. 参数是一个字典 {‘类型’:‘代理ip:端口号’}
 
proxy_support = urllib.request.ProxyHandler({})
 
 
 
2. 定制、创建一个 opener
 
opener = urllib.request.build_opener(proxy_support)
 
 
 
3a. 安装 opener
 
urllib.request.install_opener(opener)
 
3b. 调用 opener
 
opener.open(url)
 
 
 
064 GUI的终极选择：Tkinter
 
 
 
 
>>> import tkinter   #Tkinter是python默认的GUI库，导入Tkinter模块
 >>> 
 
实例1：
 
import tkinter as tk
 
root = tk.Tk()#创建一个主窗口，用于容纳整个GUI程序
 root.title("FishC Demo")#设置主窗口对象的标题栏
 
#添加一个Label组件，可以显示文本、图标或者图片（此处显示文本）
 theLabel = tk.Label(root,text = "我的第二个窗口程序")
 theLabel.pack()#调用Label组件的pack方法，用于自动调节组件自身尺寸
 
root.mainloop()#执行此语句后，窗口才会显示，程序进入主事件循环
 
 
实例2：
 
import tkinter as tk
 
class App:#创建类App
     def __init__(self,root):#self为指向App类的指针
         #创建一个框架，然后在里面添加一个Button按钮组件，框架用来将复杂布局中按钮分组
         frame = tk.Frame(root)
         frame.pack(side = tk.RIGHT,padx = 10,pady = 10)#调节框架自身尺寸,此处设置为右对齐（右上角为原点），偏移（10,10)
         
         #创建一个按钮组件，fg(foreground)，设置前景色
         #创建一个Button按钮,属性为self.hi_there，属于frame框架，按钮按下时调用self.say_hi方法
         #设置前景色为黑色，背景色为白色
         self.hi_there = tk.Button(frame,text = "打招呼",bg = "black",fg = "white",command = self.say_hi)
         self.hi_there.pack()#自动调节自身尺寸
         
         #say_hi()方法定义实现   
     def say_hi(self):
         print("互联网广大朋友们好，我是亦我飞也！")
         
         
 root = tk.Tk()#创建一个主窗口(toplever的根窗口)，并把它作为参数实例化app对象，用于容纳整个GUI程序,
 app = App(root)#创建类App的一个实例对象app，传入参数为root
 
app.mainloop()#执行此语句后，窗口才会显示，程序进入主事件循环
  
 
 
065 GUI的终极选择：Tkinter2
 
实例1：Label组件显示文字与gif图片
 
#导入tkinter模块的所有内容
 from tkinter import *
 
#创建主窗口
 root = Tk()
 #创建一个文本Label对象,文字为左对齐，离左边边框距离为10
 textLabel = Label(root,
                   text = "您下载的影片含有未成年人限制内容，\n请满18周岁后再点击观看！",
                   justify = LEFT,padx = 10)
 #Label组件为左对齐
 textLabel.pack(side = LEFT)
 
#创建一个图像Label对象
 #用PhotoImage实例化一个图片对象（支持gif格式的图片）
 photo = PhotoImage(file = "18.gif")
 imgLabel = Label(root,image = photo)
 imgLabel.pack(side = RIGHT)
 
mainloop()
  
 
 
实例2：
 
例2：文字显示在图片上
 
#导入tkinter模块的所有内容
 from tkinter import *
 
#创建主窗口
 root = Tk()
 
#创建一个图像Label对象
 photo = PhotoImage(file = "bg.gif")
 #创建一个文本Label对象
 textLabel = Label(root,
                   text = "学Python\n到FishC！",
                   font = ("宋体",20),
                   fg = "white",
                   justify = LEFT,  #文字左对齐
                   image = photo,
                   compound = CENTER, #设置文本和图像的混合模式
                   )
 #文本Label对象偏移，离左窗口与上窗口都为10
 textLabel.pack(side = LEFT,padx =10,pady =10)
 
mainloop()
  
 
 
实例2：Button组件
 
#导入tkinter模块的所有内容
 from tkinter import *
 
def callback():
     var.set("吹吧你，我才不信呢~")
 
#创建主窗口
 root = Tk()
 #设置主窗口对象的标题栏
 root.title("TK")
 
frame1 = Frame(root)#框架1
 frame2 = Frame(root)#框架2
 
#创建一个文本Label对象,文字为左对齐
 var = StringVar()
 var.set("您下载的影片含有未成年人限制内容，\n请满18周岁后再点击观看！")
 textLabel = Label(frame1,
                   textvariable = var, #Button显示一个StringVar的变量
                   justify = LEFT)
 #Label组件为左对齐
 textLabel.pack(side = LEFT)
 
#创建一个图像Label对象
 #用PhotoImage实例化一个图片对象（支持gif格式的图片）
 photo = PhotoImage(file = "18.gif")
 imgLabel = Label(root,image = photo)
 imgLabel.pack(side = RIGHT)
 
#加一个按钮
 theButton = Button(frame2,text = "已满18周岁",command = callback)
 theButton.pack()
 frame1.pack(padx = 10,pady = 10)
 frame2.pack(padx = 10,pady = 10)
 
mainloop()
 
 
066 GUI的终极选择：Tkinter3
 
实例1：Checkbutton 组件
 
from tkinter import *
 
root = Tk()
 #需要一个Tkinter变量，用于表示该按钮是否被选中
 v = IntVar()
 c = Checkbutton(root,text="测试一下",variable = v)
 
c.pack()
 #如果被选中，那么变量v被赋值为1，否则为0
 #可以用个Label标签动态地给大家展示：
 lable = Label(root,textvariable = v)
 lable.pack()
 
mainloop()
 
 
 
实例2：
 
from tkinter import *
 
root = Tk()
 
GIRLS = ["貂蝉","王昭君","西施","杨玉环"]
 v = []
 for girl in GIRLS:
     v.append(girl)
     c = Checkbutton(root,text = girl,variable = v[-1])#-1表示每次取v列表中最后一个元素，即刚加入的那个元素
     c.pack(anchor = W)#W(western)向左对齐
 
mainloop()
 
 
实例3：Radiobutton 组件
 
from tkinter import *
 
root = Tk()
 
v = IntVar()#如果被选中，v被赋值为1，否则为0
 Radiobutton(root,text = "One",variable = v,value = 1).pack(anchor = W)
 #value表示第一个按钮被选中时，v的值赋值给variable
 
Radiobutton(root,text = "Two",variable = v,value = 2).pack(anchor = W)
 
Radiobutton(root,text = "Three",variable = v,value = 3).pack(anchor = W)
 
Radiobutton(root,text = "Four",variable = v,value = 4).pack(anchor = W)
 
mainloop()
 
实例4：循环处理
 
from tkinter import *
 
root = Tk()
 
LANGS = [
     ("Python",1),
     ("Perl",2),
     ("Ruby",3),
     ("Lua",4)]
      
 
v = IntVar()#如果被选中，v被赋值为1，否则为0
 v.set(1)#将1设置为默认值
 for lang,num in LANGS:
     b= Radiobutton(root,text = lang,variable = v,value = num)
     b.pack(anchor = W)
 #value表示第一个按钮被选中时，v的值赋值给variable
 
mainloop()
 
实例5：改成按钮形式
 
from tkinter import *
 
root = Tk()
 
LANGS = [
     ("Python",1),
     ("Perl",2),
     ("Ruby",3),
     ("Lua",4)]
      
 
v = IntVar()#如果被选中，v被赋值为1，否则为0
 v.set(1)#将1设置为默认值
 for lang,num in LANGS:
     b= Radiobutton(root,text = lang,variable = v,value = num,indicatoron = False)
     b.pack(fill = X)#表示横向填充
 #value表示第一个按钮被选中时，v的值赋值给variable
 
mainloop()
 
实例6：LabelFrame 组件
 
from tkinter import *
 
root = Tk()
 
group = LabelFrame(root,text = "最好的脚本语言是？",padx = 10,pady = 10)#按钮相对边框的偏移
 group.pack(padx = 10,pady = 10)#框架相对边框的偏移
 
LANGS = [
     ("Python",1),
     ("Perl",2),
     ("Ruby",3),
     ("Lua",4)]
      
 
v = IntVar()#如果被选中，v被赋值为1，否则为0
 v.set(1)#将1设置为默认值
 for lang,num in LANGS:
     b= Radiobutton(group,text = lang,variable = v,value = num,indicatoron = False)
     b.pack(fill = X)
 #value表示第一个按钮被选中时，v的值赋值给variable
 
mainloop()
 
 
067 GUI的终极选择：Tkinter4
 
实例1：
 
from tkinter import *
 
root = Tk()#创建主窗口
 e = Entry(root)#在主窗口中插入输入框
 e.pack(padx = 20,pady = 20)
 
e.delete(0,END)#清空输入框
 e.insert(0,"默认文本...")#设置输入框内容
 
mainloop()
 
实例2：
 
from tkinter import *
 
def button1_show():
     print("作品：《%s》" % e1.get())#将e1.get()中得到的输入框1的内容格式化为字符串
     print("作者：%s" % e2.get())
 
root = Tk()#创建主窗口
 
Label(root,text = "作品:",padx = 20,pady = 10).grid(row=0,column=0)#第1行第1列,偏移是相对于当前操作组件的相邻x轴或y轴的偏移距离
 Label(root,text = "小甲鱼:").grid(row=1,column=0)#第1行第0列
 

 e1 = Entry(root)#在主窗口中插入输入框,文本框的内容通过e1调用
 e2 = Entry(root)#在主窗口中插入输入框
 e1.grid(row=0,column=1,padx=10)#x方向偏移是相对于"作品"的x方向偏移的；y方向偏移表示此输入框与y方向相邻物体或边框之间偏移的距离(y方向偏移)
 e2.grid(row=1,column=1,padx=10,pady=20)#x方向偏移是相对于"小甲鱼"的x方向偏移的；y方向偏移表示此输入框与y方向相邻上下物体或边框偏移的距离(y方向偏移)
 

 #加两个按钮
 Button1 = Button(root,text = "获取信息",command = button1_show)\
           .grid(row = 2,column = 0,sticky = W,padx = 10,pady=10)#加入反斜杠可实现分行编辑,方位设置为最西边(即靠左)
 Button2 = Button(root,text = "退出",command = root.quit).grid(row = 2,column = 1,sticky = E,padx=10)#方位设置为最东边(即靠右)
 
#注：双击打开文件时退出才有效
 e1.delete(0,END)#清空输入框
 e1.insert(0,"零基础入门学习Python")#设置输入框内容
 
e2.delete(1,END)#清空输入框
 e2.insert(1,"小甲鱼")#设置输入框内容
 
mainloop()
 
 
按下获取信息
 
 
更改输入框数据，然后按下获取信息
 
 
实例2：账号密码设置
 
from tkinter import *
 
def show():
     print("作品：《%s》" % e1.get())#将e1.get()中得到的输入框1的内容格式化为字符串
     print("作者：%s" % e2.get())
     e1.delete(0,END)#清空输入框1
     e2.delete(0,END)#清空输入框2
 
root = Tk()#创建主窗口
 #Tkinter总共提供了三种布局组件的方法：pack()、grid()和place()
 #grid()方法允许你用表格的形式来管理组件的位置
 #row选项代表行，coulumn选项代表列
 #row = 1,column = 2表示第二行第三列（0表示第一行）
 
Label(root,text = "账号:").grid(row=0)#第1行
 Label(root,text = "密码:").grid(row=1)#第2行
 v1 = StringVar()
 v2 = StringVar()
 
e1 = Entry(root,textvariable = v1)#在主窗口中插入输入框,文本框的内容通过e1调用
 e2 = Entry(root,textvariable = v2,show="*")#在主窗口中插入输入框
 e1.grid(row=0,column=1,padx=10,pady=5)#x方向偏移是相对于"作品"的x方向偏移的；y方向偏移表示此输入框与y方向相邻物体或边框之间偏移的距离(y方向偏移)
 e2.grid(row=1,column=1,padx=10,pady=5)#x方向偏移是相对于"小甲鱼"的x方向偏移的；y方向偏移表示此输入框与y方向相邻上下物体或边框偏移的距离(y方向偏移)
 

 #可以使用sticky选项来设置组件的位置
 #使用N、E、S、W以及他们的组合NE、SE、SW、NW来表示方位
 
#加两个按钮
 Button(root,text = "芝麻开门",command = show)\
           .grid(row = 2,column = 0,sticky = W,padx = 10,pady=5)#加入反斜杠可实现分行编辑,方位设置为最西边(即靠左)
 Button(root,text = "退出",command = root.quit).grid(row = 2,column = 1,sticky = E,padx=10)#方位设置为最东边(即靠右)
 
mainloop()
 
 
实例3：验证函数validatecommand
 
from tkinter import *
 
master = Tk()
 
def test():
     if e1.get() == "小甲鱼":
         print("正确！")
         return True
     else:
         print("错误！")
         e1.delete(0, END)
         return False
 
v = StringVar()
 
#focusout表示Entry组件失去焦点的时候验证，调用validatecommand的test函数
 
e1 = Entry(master, textvariable=v, validate="focusout", validatecommand=test)
 e2 = Entry(master)
 e1.pack(padx=10, pady=10)
 e2.pack(padx=10, pady=10)
 
mainloop()
  
 
 
 
实例4：invalidcommand函数
 
from tkinter import *
 
master = Tk()
 
def test():
     if e1.get() == "小甲鱼":
         print("正确！")
         return True
     else:
         print("错误！")
         e1.delete(0, END)
         return False
 
def test2():
     print("我被调用了...")
 
v = StringVar()
 
#focusout表示Entry组件失去焦点的时候验证，调用validatecommand的test函数
 #invalidcommand选项指定的函数只有在validatecommand的返回值为False的时候才被调用
 e1 = Entry(master, textvariable=v, validate="focusout", validatecommand=test,\
            invalidcommand=test2)
 e2 = Entry(master)
 e1.pack(padx=10, pady=10)
 e2.pack(padx=10, pady=10)
 
mainloop()
  
 
 
 
实例5：验证函数提供一些额外的选项
 
validatecommand(f,s1,s2,...)
 
其中，f是验证函数名，s1,s2,s3是额外的选项，这些选项会作为参数一次传给f函数。在此之前，需要调用register()方法将验证函数包装起来。
 
from tkinter import *
 
master = Tk()
 
v = StringVar()
 
def test(content, reason, name):
     if content == "小甲鱼":
         print("正确！")
         print(content, reason, name)
         return True
     else:
         print("错误！")
         print(content, reason, name)
         return False
 
testCMD = master.register(test)
 e1 = Entry(master, textvariable=v, validate="focusout", \
            validat
            ecommand=(testCMD, '%P', '%v', '%W'))
 e2 = Entry(master)
 e1.pack(padx=10, pady=10)
 e2.pack(padx=10, pady=10)
 
mainloop()
  
 
 
实例6：设计一个 计算器
 
from tkinter import *
 #计算函数
 def calc():
     result = int(v1.get())+int(v2.get())#强制转换为整型
     v3.set(result)#将result中的内容放到v3中
 
#创建窗口
 root = Tk()
 #创建窗口中的一个frame框架
 frame = Frame(root)
 #设置框架位置并显示
 frame.pack(padx = 10,pady = 10)
 
v1 = StringVar()
 v2 = StringVar()
 v3 = StringVar()
 
#注意，这里不能使用e1.get()或者v1.get()来获取输入的内容，因为validate选项
 #指定为“key"的时候，有任何输入操作都会被拦截到这个函数中
 #也就是说先拦截，只有这个函数返回True,那么输入的内容才会到变量里去
 #所以要用%P来获取最新的输入框内容
 def test(content):
     if content.isdigit():
         return True
     else:
         return False
 
#创建三个Entry组件
 testCMD = frame.register(test)
 #创建2个输入组件,输入的数据赋值给v1、v2
 e1 = Entry(frame, textvariable=v1,width=10, validate="key",\
            validatecommand=(testCMD, '%P'))
 e2 = Entry(frame, textvariable=v2,width=10, validate="key",\
            validatecommand=(testCMD, '%P'))
 #一个输出组件,设置为只读模式(readonly),v3的数据赋值给textvariable进行输出显示
 e3 = Entry(frame, textvariable=v3,width=10, validate="key",\
            validatecommand=(testCMD, '%P'),state="readonly")
 #位置设置
 e1.grid(row=0,column=0,padx=10,pady=10)
 e2.grid(row=0,column=2,padx=10)
 e3.grid(row=0,column=4,padx=10)
 
#创建两个Label组件
 Label(frame,text="+").grid(row=0,column=1)
 Label(frame,text="=").grid(row=0,column=3)
 
#创建一个按钮，宽度为10
 button=Button(frame,text="计算结果",width=10,command=calc)
 button.grid(row=1,column=2,pady=10)
 
mainloop()
 
068 GUI的终极选择：Tkinter5
 
Listbox组件
 
如果需要提供选项给用户选择，单选可以用Radiobutton组件，多选可以用Checkbutton，如果提供的选项非常多，可以考虑使用Listbox组件。Listbox是以列表的形式显示出来，并支持滚动条操作。
 
实例1：
 
from tkinter import *
 
root = Tk()#创建主窗口
 
theLB = Listbox(root,setgrid = True,selectmode=EXTENDED)#创建一个空列表
 theLB.pack()
 
#往列表里添加数据
 for item in ["鸡蛋","鸭蛋","鹅蛋","李狗蛋"]:
     theLB.insert(END,item)#每次在列表最后插入一个数据
 
#创建一个按钮,ACTIVE表示当前选中的数据
 theButton = Button(root,text="删除",command = lambda x = theLB:x.delete(ACTIVE))
 theButton.pack()
 
#theLB.delete(0,END)删除所有列表数据
 
mainloop()

注：listbox.delete(0,END)可以删除列表中所有项目
 
实例2：添加height选项
 
from tkinter import *
 
root = Tk()#创建主窗口
 
#height=11表示可以显示11个项目
 theLB = Listbox(root,setgrid = True,\
                 selectmode=BROWSE,height=11)#创建一个空列表,选择模式为单选
 theLB.pack()
 
#往列表里添加数据
 for item in range(11):
     theLB.insert(END,item)#每次在列表最后插入一个数据
 
#创建一个按钮,ACTIVE表示当前选中的数据
 theButton = Button(root,text="删除",command = lambda x = theLB:x.delete(ACTIVE))
 theButton.pack()
 
#theLB.delete(0,END)删除所有列表数据
 
mainloop()
 
Scrollbar组件
 
实例1：
 
from tkinter import *
 
root = Tk()#创建主窗口
 
sb = Scrollbar(root)
 sb.pack(side=RIGHT,fill=Y)
 
lb = Listbox(root,yscrollcommand=sb.set)#创建一个空列表
 for i in range(1000):
     lb.insert(END,i)
 lb.pack(side=LEFT,fill=BOTH)
 
sb.config(command = lb.yview)
 
mainloop()
 
事实上，这是一个互联互通的过程。当用户操作滚动条时，滚动条响应滚动并同时通过Listbox组件的yview()方法滚动列表框里的内容；同样，当列表框中可视范围发生改变的时候，Listbox组件通过调用Scrollbar组件的set()方法设置滚动条的最新位置。
 
Scale组件
 
Scale组件主要是通过滑块来表示某个范围内的一个数字，可以通过修改选项设置范围以及分辨率（精度）
 
实例1：
 
from tkinter import *
 
root = Tk()#创建主窗口
 Scale(root,from_=0,to=42).pack()#创建铅锤方向滚动条
 Scale(root,from_=0,to=200,orient=HORIZONTAL).pack()#创建水平方向滚动条
 
mainloop()
 
 
实例2：打印当前位置
 
from tkinter import *
 
def show():
     print(s1.get(),s2.get())#使用get()方法获取当前滑块的位置
 
root = Tk()#创建主窗口
 s1 = Scale(root,from_=0,to=42)#创建铅锤方向滚动条
 s1.pack()
 s2 = Scale(root,from_=0,to=200,orient=HORIZONTAL)#创建水平方向滚动条
 s2.pack()
 
#创建一个按钮
 Button(root,text="获取位置",command=show).pack()
 
mainloop()
 
 
 
实例3：通过resolution选项控制分辨率（步长），通过tickinterval选项设置刻度
 
from tkinter import *
 
def show():
     print(s1.get(),s2.get())#使用get()方法获取当前滑块的位置
 
root = Tk()#创建主窗口
 #tickinterval表示设置刻度，即每隔多少显示一个刻度
 #length表示滚动条的长度所占的像素数
 #resolution用来控制分辨率（步长）
 s1 = Scale(root,from_=0,to=42,tickinterval=5,length=200,\
            resolution=5,orient=VERTICAL)#创建铅锤方向滚动条
 s1.pack()
 s2 = Scale(root,from_=0,to=200,tickinterval=10,\
            length=600,orient=HORIZONTAL)#创建水平方向滚动条
 s2.pack()
 
#创建一个按钮
 Button(root,text="获取位置",command=show).pack()
 
mainloop()
 
 
 
069 GUI的终极选择：Tkinter6
 
Text组件
 
Text(文本)组件用于显示和处理多种任务。虽然该组件的主要目的是显示多行文本，但它常常也被用于作为简单的文本编辑器和网页浏览器使用。
 
实例1：插入内容
 
from tkinter import *
 
root = Tk()
 text = Text(root,width=30,height=2)
 text.pack()
 #INSERT索引表示插入光标当前的位置
 text.insert(INSERT,"I love\n")#光标当前的位置插入
 
#END，对应Text组件的文本缓存区最后一个字符的下一个位置
 text.insert(END,"FishC.com!")
 
mainloop()
 
实例2：插入image对象windows组件
 
from tkinter import *
 
def show():
     print("哟，我被点了一下~")
 
root = Tk()
 text = Text(root,width=30,height=5)
 text.pack()
 
#INSERT索引表示插入光标当前的位置
 text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
 
#创建一个按钮
 b1=Button(root,text="点我点我",command=show)
 text.window_create(INSERT,window=b1)
 
mainloop()
  
 
 
实例3：单击按钮显示一张图片
 
from tkinter import *
 
def show():
     text.image_create(INSERT,image=photo)
 
root = Tk()
 text = Text(root,width=30,height=50)
 text.pack()
 
#INSERT索引表示插入光标当前的位置
 text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
 
photo = PhotoImage(file='fishc.gif')
 
#创建一个按钮
 b1=Button(root,text="点我点我",command=show)
 text.window_create(INSERT,window=b1)
 
mainloop()
 
Indexer用法
 
实例1：“line.column”
 
from tkinter import *
 
root = Tk()
 text = Text(root,width=30,height=5)
 text.pack()
 
#INSERT索引表示插入光标当前的位置
 text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
 #注意，行号从1开始，列号则从0开始
 print(text.get(1.2,1.6))#获取第一行第2列到第一行第六列的数据
 
mainloop()
 
 
实例2：“line.end”
 
行号加上字符串".end"格式表示为该行最后一个字符的位置
 
实例：
 
from tkinter import *
 
root = Tk()
 text = Text(root,width=30,height=5)
 text.pack()
 
#INSERT索引表示插入光标当前的位置
 text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
 #注意，行号从1开始，列号则从0开始
 print(text.get("1.2","1.end"))#获取第一行第2列到第一行第六列的数据
 
mainloop()
 
Mask用法
 
mask（标记）通常是嵌入到Text组件文本中的不可见对象。事实上，Marks是指定字符间的位置，并跟随相应的字符一起移动。
 
实例：Mark事实上就是索引，用于表示位置
 
from tkinter import *
 
root = Tk()
 text = Text(root,width=30,height=5)
 text.pack()
 
#INSERT索引表示插入光标当前的位置
 text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
 #注意，行号从1开始，列号则从0开始
 text.mark_set("here","1.2")#设置光标位置为1.2
 text.insert("here","插")
 
mainloop()
 
 
实例2：如果Mark前面的内容发生改变，Mark的位置也会跟着移动
 
from tkinter import *
 
root = Tk()
 text = Text(root,width=30,height=5)
 text.pack()
 
#INSERT索引表示插入光标当前的位置
 text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
 #注意，行号从1开始，列号则从0开始
 text.mark_set("here","1.2")#设置当前光标位置为1.2
 text.insert("here","插")#执行后当前光标位置（Mark位置）变成了1.3
 text.insert("here","入")
 #text.insert("1.3","入")
 
mainloop()
 
实例3：如果Mark周围的文本被删除了，Mark仍然存在
 
from tkinter import *
 
root = Tk()
 text = Text(root,width=30,height=5)
 text.pack()
 
#INSERT索引表示插入光标当前的位置
 text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
 #注意，行号从1开始，列号则从0开始
 text.mark_set("here","1.2")#设置当前光标位置为1.2
 text.insert("here","插")#执行后当前光标位置变成了1.3
 text.delete("1.0",END)
 text.insert("here","入")#here表示当前Mark的位置,如果Mark左边并没有数据则会插入到最左边
 
mainloop()
 
例4：只有mark_unset()方法可以解除Mark的封印
 
from tkinter import *
 
root = Tk()
 text = Text(root,width=30,height=5)
 text.pack()
 
#INSERT索引表示插入光标当前的位置
 text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
 #注意，行号从1开始，列号则从0开始
 text.mark_set("here","1.2")#设置当前光标位置为1.2
 text.insert("here","插")#执行后当前光标位置变成了1.3
 text.mark_unset("here")
 
text.delete("1.0",END)
 text.insert("here","入")#here表示当前Mark的位置
 
mainloop()
 
默认插入内容是插入到Mark左侧（就是说插入一个字符后，Mark向后移动了一个字符的位置）
 
实例5：插入内容到Mark的右侧
 
from tkinter import *
 
root = Tk()
 text = Text(root,width=30,height=5)
 text.pack()
 
#INSERT索引表示插入光标当前的位置
 text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
 #注意，行号从1开始，列号则从0开始
 text.mark_set("here","1.2")#设置当前Mark位置为1.2
 text.mark_gravity("here",LEFT)
 
text.insert("here","插")#执行后当前Mark位置变成了1.3
 text.insert("here","入")#here表示当前Mark的位置
 
mainloop()
 
 
070 GUI的终极选择：Tkinter7
 
实例1：添加Tags
 
from tkinter import *
 
root = Tk()
 text = Text(root,width=30,height=5)
 text.pack()
 
#INSERT索引表示插入光标当前的位置
 text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
 #注意，行号从1开始，列号则从0开始
 text.tag_add("tag1","1.7","1.12","1.14")#1.7(第一行第八列)到1.12,，与1.14设置Tag样式
 text.tag_config("tag1",background ="yellow",foreground="red")
 
mainloop()
 
实例2：Tags覆盖
 
from tkinter import *
 
root = Tk()
 text = Text(root,width=30,height=5)
 text.pack()
 
#INSERT索引表示插入光标当前的位置
 text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
 #注意，行号从1开始，列号则从0开始
 text.tag_add("tag1","1.7","1.12","1.14")#1.7(第一行第八列)到1.12,，与1.14设置Tag样式
 text.tag_add("tag2","1.7","1.12","1.14")#1.7(第一行第八列)到1.12,，与1.14设置Tag样式
 
text.tag_config("tag1",background ="yellow",foreground="red")
 text.tag_config("tag2",background ="blue")
 
mainloop()
  
 
 
实例2：降低Tag优先级
 
from tkinter import *
 
root = Tk()
 text = Text(root,width=30,height=5)
 text.pack()
 
#INSERT索引表示插入光标当前的位置
 text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
 #注意，行号从1开始，列号则从0开始
 text.tag_add("tag1","1.7","1.12","1.14")#1.7(第一行第八列)到1.12,，与1.14设置Tag样式
 text.tag_add("tag2","1.7","1.12","1.14")#1.7(第一行第八列)到1.12,，与1.14设置Tag样式
 
text.tag_config("tag1",background ="yellow",foreground="red")
 text.tag_config("tag2",background ="blue")
 
text.tag_lower("tag2")#降低tag2的优先级
 
mainloop()
 
实例3：Tags事件绑定
 
from tkinter import *
 import webbrowser#导入网页模块
 
def show_hand_cursor(event):
     text.config(cursor="arrow")
 
def show_arrow_cursor(event):
     text.config(cursor="xterm")
 
def click(event):
     webbrowser.open("http://www.fishc.com")
     
 root = Tk()
 text = Text(root,width=30,height=5)
 text.pack()
 
#INSERT索引表示插入光标当前的位置
 text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
 #注意，行号从1开始，列号则从0开始
 text.tag_add("link","1.7","1.16")#1.7(第一行第八列)到1.16
 #设置蓝色前景色并底部划线
 text.tag_config("link",foreground="blue",underline=True)
 
#当进入绑定文本段时，鼠标样式切换为“arrow"形态
 text.tag_bind("link","<Enter>",show_hand_cursor)
 #当离开绑定文本段时，鼠标样式切换为“xterm"形态
 text.tag_bind("link","<Leave>",show_arrow_cursor)
 #当触发鼠标“左键单击”时，使用默认浏览器打开鱼C网址
 text.tag_bind("link","<Button-1>",click)
 
mainloop()
 
 
实例4：判断内容是否发生改变
 
from tkinter import *
 import hashlib
 
def getSig(contents):
     m = hashlib.md5(contents.encode())
     return m.digest()
 
def check():#检查
     contents = text.get(1.0,END)
     if sig!=getSig(contents):
         print("警报，内容发生变动")
     else:
         print("风平浪静")
     
 root = Tk()
 text = Text(root,width=30,height=5)
 text.pack()
 
#INSERT索引表示插入光标当前的位置
 text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
 #注意，行号从1开始，列号则从0开始
 #获取文本内容
 contents=text.get(1.0,END)
 
sig = getSig(contents)
 
Button(root,text="检查",command=check).pack()
 
mainloop()
 
 
实例5：查找操作（使用search()方法可以搜索Text组件中的内容）
 
from tkinter import *
 import hashlib
 
#将任何格式的索引号统一为元组（行，列）的格式输出
 def getIndex(text,index):
     #split这里以"."拆分字符串，将1.3拆分为字符1和3，然后通过map将字符转换为整型
     return tuple(map(int,str.split(text.index(index),".")))
     
 root = Tk()
 text = Text(root,width=30,height=5)
 text.pack()
 
#INSERT索引表示插入光标当前的位置
 text.insert(INSERT,"I love FishC.com!")#光标当前的位置插入
 
#将任何格式的索引号统一为元组（行、列）的格式输出
 start = 1.0
 while True:
     pos = text.search("o",start,stopindex=END)#从开始到结束全文搜索
     if not pos:
         break
     print("找到了，位置是：",getIndex(text,pos))
     start = pos + "+1c"#将start指向找到的字符位置的下一个字符，以便进行下一次搜索
 
mainloop()
 
Text组件内部有一个栈专门用于记录内容的每次变动，所以每次“撤销”操作就是一次弹栈操作，“恢复”就是再次压栈。
 
实例6：撤销
 
from tkinter import *
 
#将任何格式的索引号统一为元组（行，列）的格式输出
 def show():
     text.edit_undo()
     
 root = Tk()
 text = Text(root,width=30,height=5,undo=True)
 text.pack()
 text.insert(INSERT,"I love FishC")
 
Button(root,text="撤销",command=show).pack()
 
mainloop()
 

 
 
实例7：每次撤销一个字符
 
from tkinter import *
 
def callback(event):
     text.edit_separator()
 
def show():
     text.edit_undo()#执行撤回操作
     
 root = Tk()
 
#autoseparators表示一次完整的操作结束后自动插入“分隔符”，此处设置为False
 text = Text(root,width=30,height=5,autoseparators=False,undo=True,maxundo=10)
 text.pack()
 
text.insert(INSERT,"I love FishC!")
 text.bind('<Key>',callback)#每次有输入就插入一个“分隔符”
 
Button(root,text="撤销",command=show).pack()
 
mainloop()
 
 
071 GUI的终极选择：Tkinter8
 
Canvas（画布）组件
 
一个可以让你随心所欲绘制界面的组件。通常用于显示和编辑图形，可以用它来绘制直线、图形、多边形，甚至是绘制其他组件。
 
实例1：
 
from tkinter import *
 root = Tk()
 #创建canvas对象框，设置其宽度、高度与背景色
 w = Canvas(root,width=200,height=100,background="black")
 w.pack()
 
#画一条黄色的线
 w.create_line(0,50,200,50,fill="yellow")
 #画一条红色的竖线（虚线）
 w.create_line(100,0,100,100,fill="red")
 #中间画一个蓝色的矩形
 w.create_rectangle(50,25,150,75,fill="blue")
 
mainloop()
 
实例2：
 
from tkinter import *
 root = Tk()
 #创建canvas对象框，设置其宽度、高度与背景色
 w = Canvas(root,width=200,height=100,background="black")
 w.pack()
 
#画一条黄色的线（参数为其x、y轴坐标）
 line1 = w.create_line(0,50,200,50,fill="yellow")
 #画一条红色的竖线（虚线）
 line2 = w.create_line(100,0,100,100,fill="red")
 #中间画一个蓝色的矩形
 rect1 = w.create_rectangle(50,25,150,75,fill="blue")
 
w.coords(line1,0,25,200,25)#将line1移动到新的坐标
 w.itemconfig(rect1,fill="red")#重新设置矩形的填充色为红色
 w.delete(line2)#删除线2
 
#创建一个按钮，按下时删除所有图形
 Button(root,text="删除全部",command=(lambda x=ALL:w.delete(x))).pack()
 
mainloop()
 
 
实例3：在Canvas上显示文本
 
from tkinter import *
 root = Tk()
 #创建canvas对象框，设置其宽度、高度与背景色
 w = Canvas(root,width=200,height=100,background="black")
 w.pack()
 
#画一条绿色的斜线（参数为其x、y轴坐标），宽度为三个像素点
 line1 = w.create_line(0,0,200,100,fill="green",width=3)
 #画一条绿色的斜线
 line2 = w.create_line(200,0,0,100,fill="green",width=3)
 #中间画两个矩形
 rect1 = w.create_rectangle(40,20,160,80,fill="blue")
 rect2 = w.create_rectangle(60,30,140,70,fill="yellow")
 #在矩形正中（默认）显示文本，坐标为文本正中坐标
 w.create_text(100,50,text="Hadley")
 
#创建一个按钮，按下时删除所有图形
 Button(root,text="删除全部",command=(lambda x=ALL:w.delete(x))).pack()
 
mainloop()
 
 
实例4：绘制椭圆
 
from tkinter import *
 root = Tk()
 #创建canvas对象框，设置其宽度、高度与背景色
 w = Canvas(root,width=200,height=100,background="white")
 w.pack()
 
#绘制一个虚线的矩形
 w.create_rectangle(40,20,160,80,dash=(4,4))
 #绘制椭圆，粉色填充
 w.create_oval(40,20,160,80,fill="pink")
 #在矩形正中(默认)显示文本，坐标为文本正中坐标
 w.create_text(100,50,text="Hadley")
 
mainloop()
 实例5：绘制圆形
 
from tkinter import *
 root = Tk()
 #创建canvas对象框，设置其宽度、高度与背景色
 w = Canvas(root,width=200,height=100,background="white")
 w.pack()
 
#绘制一个虚线的矩形
 w.create_rectangle(40,20,160,80,dash=(4,4))
 #绘制圆形，粉色填充
 #w.create_oval(40,20,160,80,fill="pink")
 w.create_oval(70,20,130,80,fill="pink")
 #在矩形正中(默认)显示文本，坐标为文本正中坐标
 w.create_text(100,50,text="Hadley")
 
mainloop()
 
实例6：绘制多边形
 
from tkinter import *
 import math as m
 
root = Tk()
 w=Canvas(root,width=200,height=150,background="red")
 w.pack()
 center_x = 100
 center_y = 80
 r = 70
 points = [
     #左上角A
     center_x - int(r*m.sin(2*m.pi/5)),
     center_y - int(r*m.cos(2*m.pi/5)),
     #右上角C
     center_x + int(r*m.sin(2*m.pi/5)),
     center_y - int(r*m.cos(2*m.pi/5)),
     #左下角E
     center_x - int(r*m.sin(m.pi/5)),
     center_y + int(r*m.cos(m.pi/5)),
     #顶点D
     center_x,
     center_y - r,
     #右下角B
     center_x + int(r*m.sin(m.pi/5)),
     center_y + int(r*m.cos(m.pi/5)),
     ]
 #创建多边形方法，会自动按ACEDBA的形式连线，如果构成闭环，则会自动填充
 w.create_polygon(points,outline="green",fill="yellow")
 
w.create_text(100,80,text="Hadley")
 
mainloop()
 
实例7：
 
from tkinter import *
 
root = Tk()
 w=Canvas(root,width=400,height=200,background="white")
 w.pack()
 
def paint(event):#画小圆
     x1,y1 = (event.x - 1),(event.y -1)
     x2,y2 = (event.x + 1),(event.y +1)
     w.create_oval(x1,y1,x2,y2,fill="red")
 
w.bind("<B1 - Motion>",paint)#画布与鼠标进行绑定
 Label(root,text="按住鼠标左键并移动，开始绘制你的理想蓝图吧。。。").pack(side=BOTTOM)
 
mainloop()
 
073 GUI的终极选择：Tkinter10
 
Munu组件
 
Tkinter提供了一个Menu组件，用于实现顶级菜单、下拉菜单和弹出菜单。
 
实例1：创建一个顶级菜单（或称窗口主菜单）
 
from tkinter import *
 
def callback():
     print("被调用了")
     
 root = Tk()
 

 menubar = Menu(root)#创建一个顶级菜单
 menubar.add_command(label="Hello",command=callback)#创建一个顶级菜单对象
 menubar.add_command(label="Quit",command=root.quit)
 
#显示菜单
 root.config(menu=menubar)
 
mainloop()
 
实例2：创建添加到主菜单上的下拉菜单
 
from tkinter import *
 
def callback():
     print("被调用了")
     
 root = Tk()
 
#创建一个顶级菜单
 menubar = Menu(root)
 
#创建下拉菜单filemenu包含内容
 filemenu=Menu(menubar,tearoff=False)#创建一个从属于menubar的子菜单(下拉菜单)filemenu
 filemenu.add_command(label="打开",command=callback)#创建一个下拉菜单对象
 filemenu.add_command(label="保存",command=callback)
 filemenu.add_separator()#插入分隔线
 filemenu.add_command(label="退出",command=root.quit)
 #创建一个顶级菜单对象“文件”,filemenu从属于这个对象（或称将filemenu添加到顶级菜单“文件”中）
 menubar.add_cascade(label="文件",menu=filemenu)
 
#创建另一个下拉菜单editmenu包含内容
 editmenu=Menu(menubar,tearoff=False)#创建一个从属于menubar的子菜单（下拉菜单）editmenu
 editmenu.add_command(label="剪切",command=callback)
 editmenu.add_command(label="拷贝",command=callback)
 editmenu.add_separator()#插入分隔线
 editmenu.add_command(label="粘贴",command=callback)
 #创建一个顶级菜单对象“编辑”,editmenu从属于这个对象（或称将editmenu添加到顶级菜单“编辑”中）
 menubar.add_cascade(label="编辑",menu=editmenu)
 
#显示菜单
 root.config(menu=menubar)
 
mainloop()
 
实例3：创建一个弹出菜单方法
 
from tkinter import *
 
def callback():
     print("被调用了")
     
 root = Tk()
 
def popup(event):
     menu.post(event.x_root,event.y_root)#在此时鼠标位置弹出显示窗口
     
 #创建一个顶级菜单menu
 menu = Menu(root,tearoff=False)
 
#创建顶级菜单menu包含内容
 menu.add_command(label="撤销",command=callback)#创建一个顶级菜单对象
 menu.add_command(label="重做",command=callback)
 #创建一个框架
 frame = Frame(root,width=100,height=100)
 frame.pack()
 
#将鼠标右键与popup方法绑定
 frame.bind("<Button-3>",popup)
 
#显示菜单
 #root.config(menu=menu)
 
mainloop()
 
 
实例4：菜单弹出
 
from tkinter import *
 
def callback():
     print("被调用了")
     
 root = Tk()
 
def popup(event):
     menu.post(event.x_root,event.y_root)#在此时鼠标位置弹出显示窗口
     
 #创建一个顶级菜单menu
 menu = Menu(root,tearoff=True)
 
#创建顶级菜单menu包含内容
 menu.add_command(label="撤销",command=callback)#创建一个顶级菜单对象
 menu.add_command(label="重做",command=callback)
 #创建一个框架
 frame = Frame(root,width=500,height=500)
 frame.pack()
 
#将鼠标右键与popup方法绑定
 frame.bind("<Button-3>",popup)
 
#显示菜单
 #root.config(menu=menu)
 
mainloop()
 
实例5：添加单选组件radiobutton和多选按钮checkbutton
 
from tkinter import *
 
def callback():
     print("被调用了")
     
 root = Tk()
 
#创建一个顶级菜单
 menubar = Menu(root)
 #创建checkbutton关联变量
 openVar = IntVar()
 saveVar = IntVar()
 exitVar = IntVar()
 #创建下拉菜单filemenu包含内容
 filemenu=Menu(menubar,tearoff=True)#创建一个从属于menubar的子菜单(下拉菜单)filemenu
 filemenu.add_checkbutton(label="打开",command=callback,variable=openVar)#创建一个下拉菜单对象
 filemenu.add_checkbutton(label="保存",command=callback,variable=saveVar)
 filemenu.add_separator()#插入分隔线
 filemenu.add_checkbutton(label="退出",command=root.quit,variable=exitVar)
 #创建一个顶级菜单对象“文件”,filemenu从属于这个对象（或称将filemenu添加到顶级菜单“文件”中）
 menubar.add_cascade(label="文件",menu=filemenu)
 
#创建radiobutton关联变量
 editVar = IntVar()
 editVar.set(1)
 
#创建另一个下拉菜单editmenu包含内容
 editmenu=Menu(menubar,tearoff=True)#创建一个从属于menubar的子菜单（下拉菜单）editmenu
 editmenu.add_radiobutton(label="剪切",command=callback,variable=editVar,value=1)
 editmenu.add_radiobutton(label="拷贝",command=callback,variable=editVar,value=2)
 editmenu.add_separator()#插入分隔线
 editmenu.add_radiobutton(label="粘贴",command=callback,variable=editVar,value=3)
 #创建一个顶级菜单对象“编辑”,editmenu从属于这个对象（或称将editmenu添加到顶级菜单“编辑”中）
 menubar.add_cascade(label="编辑",menu=editmenu)
 
#显示菜单
 root.config(menu=menubar)
 
mainloop()
 
 
Menubutton组件（希望菜单按钮出现在其它位置时）
 
Menubutton组件是一个与Menu组件相关联的按钮，它可以放在窗口中的任意位置，并且在被按下时弹出下拉菜单
 
实例1：
 
from tkinter import *
 
def callback():
     print("被调用了")
     
 root = Tk()
 
#创建一个顶级菜单Menubutton按钮，设置为浮起显示（RAISED）
 mb = Menubutton(root,text="点我",relief=RAISED)
 
mb.pack(side=RIGHT)#设置为右中显示
 
#创建下拉菜单filemenu包含内容
 filemenu = Menu(mb,tearoff=False)#创建一个从属于mb的下拉菜单filemenu
 filemenu.add_checkbutton(label="打开",command=callback,selectcolor="yellow")
 filemenu.add_command(label="保存",command=callback)#创建一个下拉菜单对象"保存“
 filemenu.add_separator()
 filemenu.add_command(label="退出",command=root.quit)
 #显示菜单
 mb.config(menu=filemenu)
 
mainloop()
 
 
OptionMenu（选项菜单）组件
 
选项菜单的发明弥补了Listbox组件无法实现下拉列表框的遗憾
 
实例1：
 
from tkinter import *
 
def callback():
     print("被调用了")
     
 root = Tk()
 
variable = StringVar()#创建字符串变量variable
 variable.set("one")#初始值设置为"one"
 w = OptionMenu(root,variable,"one","two","three")
 w.pack()
 
mainloop()
 
 
实例2：多个选项添加到选项菜单中
 
from tkinter import *
 
def callback():
     print("被调用了")
     
 root = Tk()
 
OPTIONS = [
     "Hadley",
     "小土豆",
     "yiwofeiye",
     "RAN"
     ]
 
variable = StringVar()#创建字符串变量variable
 variable.set(OPTIONS[0])#初始值设置为"one"
 w = OptionMenu(root,variable,*OPTIONS)
 w.pack()
 
def callback():
     print(variable.get())
 
Button(root,text="点我",command=callback).pack()
 
mainloop()
  
 
 
074  GUI的终极选择：Tkinter11
 
事件绑定
 
对于每个组件来说，可以通过bind()方法将函数或方法绑定到具体的事件上。当被触发的事件满足该组件绑定的事件时，Tkinter就会带着事件描述去调用handler()方法
 
实例1：捕获单击鼠标位置
 
from tkinter import*
 
root = Tk()
 
def callback(event):
     print("点击位置：",event.x,event.y)
 
frame = Frame(root,width=200,height=200)
 #Button表示鼠标点击事件
 #1代表左键 2代表中间滚轮点击 3代表右键
 frame.bind("<Button-1>",callback)#按键按下时，调用callback方法
 frame.pack()
 
mainloop()
 
 
实例2：捕获键盘事件
 
#捕获单击鼠标的位置
 from tkinter import*
 
root = Tk()
 
def callback(event):
     print("敲击位置：",repr(event.char))#打印当前按下按键的字符
     print(event.char)
 
frame = Frame(root,width=200,height=200)
 #Key为键盘事件
 frame.bind("<Key>",callback)#按键按下时，调用callback方法
 frame.focus_set()#获得焦点
 frame.pack()
 
mainloop()
 
实例3：捕获鼠标在组件上的运动轨迹
 
#当鼠标在组件内移动的整个过程均触发该事件
 
from tkinter import*
 
root = Tk()
 
def callback(event):
     print("当前位置：",event.x,event.y)#打印当前按下按键的字符
 
frame = Frame(root,width=200,height=200)
 frame.bind("<Motion>",callback)#按键按下时，调用callback方法
 frame.pack()
 
mainloop()
 
 
事件序列
 
Tkinter使用一种称为事件序列的机制来允许用户定义事件，用户需要使用bind()方法将具体的事件序列与自定义的方法绑定
 
Event对象（按键名keysym和按键码keycode）
 
实例1：打印当前按下按键的按键名
 
from tkinter import*
 
root = Tk()
 
def callback(event):
     print(event.keysym)#打印当前按下按键的按键名
     print(event.char)
 
frame = Frame(root,width=200,height=200)
 #Key为键盘事件
 frame.bind("<Key>",callback)#按键按下时，调用callback方法
 frame.focus_set()#获得焦点
 frame.pack()
 
mainloop()
 
075 GUI的终极选择：Tkinter12
 
Message组件
 
Message(消息)组件是Label组件的变体，用于显示多行文本信息。Message组件能够自动换行，并调整文本的尺寸使其适应给定得尺寸。
 
实例1：
 
from tkinter import *
 
root = Tk()
 w1 = Message(root,text="这是一则消息",width=100)
 w1.pack()
 w2 = Message(root,text="这是一条骇人听闻的长消息！",width=100)
 w2.pack()
 
mainloop()
 
 
Spinbox组件
 
Entry组件的变体，用于从一些固定的值中选取一个。使用Spinbox组件，可以通过返回或者元组指定允许用户输入的内容。
 
实例1：
 
from tkinter import *
 
root = Tk()
 
#w = Spinbox(root,from_=0,to=10)#指定输入值为0-10
 w = Spinbox(root,value=("Hadley","小土豆","雅馨"))#指定输入
 w.pack()
 
mainloop()
 
PanedWindow组件
 
与Frame类似，都是为组件提供一个框架，但其还允许让用户调整应用程序的空间划分
 
实例1：两窗格
 
from tkinter import *
 
root = Tk()
 
m = PanedWindow(orient = VERTICAL)#设置为上下分布
 m.pack(fill=BOTH,expand=1)#设置为框架覆盖全局
 
top = Label(m,text="top pane")#顶窗格
 m.add(top)
 
bottom = Label(m,text="bottom pane")#底窗格
 m.add(bottom)
 
mainloop()
 
实例2：三窗格
 
from tkinter import *
 
root = Tk()
 
m1 = PanedWindow()#默认为左右分布
 m1.pack(fill=BOTH,expand=1)
 left = Label(m1,text="left pane")#左窗格
 m1.add(left)
 
m2 = PanedWindow(orient=VERTICAL)
 m1.add(m2)
 top=Label(m2,text="top pane")#顶窗格
 m2.add(top)
 bottom = Label(m2,text="bottom pane")#底窗格
 m2.add(bottom)
 
mainloop()
 
实例3：显示“分割线”
 
from tkinter import *
 
root = Tk()
 
#showhandle=True表示显示“手柄”
 #sashrelief=SUNKEN表示分隔线的样式设置为向下凹
 m1 = PanedWindow(showhandle=True,sashrelief=SUNKEN)
 m1.pack(fill=BOTH,expand=1)
 left = Label(m1,text="left pane")
 m1.add(left)
 
m2 = PanedWindow(orient=VERTICAL,showhandle=True,sashrelief=SUNKEN)
 m1.add(m2)
 top=Label(m2,text="top pane")
 m2.add(top)
 bottom = Label(m2,text="bottom pane")
 m2.add(bottom)
 
mainloop()
 
Toplevel组件
 
Topleve（顶级窗口）l组件类似于Frame组件，但其是一个独立的顶级窗口，通常拥有标题栏、边框等部件。通常用在显示额外的窗口、对话框和其他弹出窗口中。
 
实例1：按钮按下创建一个顶级窗口
 
from tkinter import *
 
def create():
     top = Toplevel()#创建一个独立的顶级窗口
     top.title("FishC Demo")
     msg = Message(top,text="I love FishC.com")
     msg.pack()
     
 root = Tk()
 Button(root,text="创建顶级窗口",command=create).pack()
 
mainloop()
 
实例2：Toplevel的窗口设置为50%透明
 
from tkinter import *
 
def create():
     top = Toplevel()
     top.title("FishC Demo")
     top.attributes("-alpha",0.5)#设置为50%透明度
     msg = Message(top,text="I love FishC.com")
     msg.pack()
     
 root = Tk()
 Button(root,text="创建顶级窗口",command=create).pack()
 
mainloop()
 
 
076 GUI的终极选择：Tkinter13
 
布局管理器
 
布局管理器就是管理你的那些组件如何排列的家伙。Tkinter有三个布局管理器，分别是pack、grid和place
 
pack:按添加顺序排列组件
 
grid:按行/列形式排列组件
 
place:允许程序员指定组件的大小和位置

pack
 
实例1：生成一个Listbox组件并将它填充到root窗口
 
from tkinter import *
 
root = Tk()
 listbox = Listbox(root)
 #fill选项是告诉窗口管理器该组件将怎样填充整个分配给它的空间
 #BOTH表示同时横向和纵向扩展；X表示横向；Y表示纵向
 #expand选项是告诉窗口管理器是否将父组件的额外空间也填满（任意拉伸窗口依旧会填满）
 
#默认情况下pack是将添加的组件依次纵向排列
 listbox.pack(fill=BOTH,expand=True)
 for i in range(10):
     listbox.insert(END,str(i))
 
mainloop()
 
实例2：纵向排列，横向填充
 
from tkinter import *
 
root = Tk()
 #fill选项是告诉窗口管理器该组件将怎样填充整个分配给它的空间
 #BOTH表示同时横向和纵向扩展；X表示横向；Y表示纵向
 #expand选项是告诉窗口管理器是否将父组件的额外空间也填满
 
#默认情况下pack的side属性是将添加的组件依次纵向排列
 Label(root, text="red", bg="red", fg="white").pack(fill=X)
 Label(root, text="green", bg="green", fg="black").pack(fill=X)
 Label(root, text="blue", bg="blue", fg="white").pack(fill=X)
 
mainloop()
 
 
实例3：横向排列，纵向填充
 
from tkinter import *
 
root = Tk()
 #fill选项是告诉窗口管理器该组件将怎样填充整个分配给它的空间
 #BOTH表示同时横向和纵向扩展；X表示横向；Y表示纵向
 #expand选项是告诉窗口管理器是否将父组件的额外空间也填满
 
#将pack设置为横向排列
 Label(root, text="red", bg="red", fg="white").pack(side=LEFT)
 Label(root, text="green", bg="green", fg="black").pack(side=LEFT)
 Label(root, text="blue", bg="blue", fg="white").pack(side=LEFT)
 
mainloop()
 
grid
 
使用一个grid就可以简单地实现你用很多个框架和pack搭建起来的效果。使用grid排列组件，只需告诉它你想要将组件放置的位置（行row/列column）。
 
实例1：
 
from tkinter import *
 
root = Tk()
 
#column默认值是0
 #默认情况下组件会居中显示在对应的网格里
 #Label(root,text="用户名").grid(row=0)
 #Label(root,text="密码").grid(row=1)
 #设置sticky=W使Label左对齐
 Label(root,text="用户名").grid(row=0,sticky=W)#左对齐
 Label(root,text="密码").grid(row=1,sticky=W)
 
Entry(root).grid(row=0,column=1)
 Entry(root,show="*").grid(row=1,column=1)
 
mainloop()
 
 
实例2：设置rowspan与columnspan实现跨行和跨列功能
 
from tkinter import *
 
root = Tk()
 
#column默认值是0
 #默认情况下组件会居中显示在对应的网格里
 #Label(root,text="用户名").grid(row=0)
 #Label(root,text="密码").grid(row=1)
 #设置sticky=W使Label左对齐
 #创建Label文本
 Label(root,text="用户名").grid(row=0,sticky=W)
 Label(root,text="密码").grid(row=1,sticky=W)
 #创建输入
 Entry(root).grid(row=0,column=1)
 Entry(root,show="*").grid(row=1,column=1)
 #插入Label图像
 photo = PhotoImage(file="logo.gif")
 #rowspan=2跨两行，边距5
 Label(root,image=photo).grid(row=0,column=2,rowspan=2,padx=5,pady=5)
 #columnspan=3跨三列（默认为居中显示），边距5
 Button(text="提交",width=10).grid(row=2,columnspan=3,pady=5)
 
mainloop()
 
 
place
 
通常情况下不建议使用place布局管理器
 
实例1：将子组件显示在父组件的正中间
 
from tkinter import *
 
def callback():
     print("正中靶心")
 root = Tk()
 #relx和rely指定的是子组件相对于父组件的位置，范围是(00`1.0),0.5则表示一半，正中间
 #anchor=CENTER表示正中显示
 Button(root,text="点我",command=callback).place(relx=0.5,rely=0.5,anchor=CENTER)
 
mainloop()
 
 
实例2：Button组件覆盖Label组件
 
from tkinter import *
 
def callback():
     print("正中靶心")
 root = Tk()
 
photo = PhotoImage(file="logo_big.gif")
 Label(root,image=photo).pack()
 #relx和rely指定的是子组件相对于父组件的位置，范围是(00`1.0),0.5则表示一半，正中间
 Button(root,text="点我",command=callback).place(relx=0.5,rely=0.5,anchor=CENTER)
 
mainloop()
 
 
实例3：
 
from tkinter import *
 
root = Tk()
 
#relx和rely指定的是子组件相对于父组件的位置，范围是(00`1.0),0.5则表示一半，正中间
 #relwidth和relheight选项指定相对父组件的尺寸
 Label(root,bg="red").place(relx=0.5,rely=0.5,relheight=0.75,relwidth=0.75,anchor=CENTER)
 Label(root,bg="yellow").place(relx=0.5,rely=0.5,relheight=0.5,relwidth=0.5,anchor=CENTER)
 Label(root,bg="green").place(relx=0.5,rely=0.5,relheight=0.25,relwidth=0.25,anchor=CENTER)
 
mainloop()
 
 
077 GUI的终极选择：Tkinter14
 
Tkinter提供了三种标准对话框模块，分别是：messagebox、filedialog、colorchooser
 
messagebox(消息对话框)
 
实例1：askokcancel函数
 
from tkinter import *
 
print(messagebox.askokcancel("FishC Demo","发射核弹?"))
 
mainloop()
 
 
 
实例2：askquestion函数
 
 
实例3：asiretrycancel函数
 
 
实例4：askyesno函数
 
 
实例5：showerror函数
 
from tkinter import *
 
#print(messagebox.askokcancel("FishC Demo","发射核弹?"))
 #print(messagebox.askquestion("FishC Demo","买个U盘?"))
 #print(messagebox.askretrycancel("FishC Demo","启动失败，重启?"))
 #print(messagebox.askyesno("FishC Demo","你确定要格式化硬盘吗?"))
 print(messagebox.showerror("FishC Demo","Error!!!"))
 
mainloop()
 
 
实例6：showinfo函数
 
from tkinter import *
 
#options参数可设置为default、icon与parent
 #print(messagebox.askokcancel("FishC Demo","发射核弹?"))
 #print(messagebox.askquestion("FishC Demo","买个U盘?"))
 #print(messagebox.askretrycancel("FishC Demo","启动失败，重启?"))
 #print(messagebox.askyesno("FishC Demo","你确定要格式化硬盘吗?"))
 #print(messagebox.showerror("FishC Demo","Error!!!"))
 messagebox.showinfo("Hadley","Great!!!",icon="info")
 
mainloop()
 
 
实例7：showwarning函数
 
from tkinter import *
 
#options参数可设置为default、icon与parent
 #print(messagebox.askokcancel("FishC Demo","发射核弹?"))
 #print(messagebox.askquestion("FishC Demo","买个U盘?"))
 #print(messagebox.askretrycancel("FishC Demo","启动失败，重启?"))
 #print(messagebox.askyesno("FishC Demo","你确定要格式化硬盘吗?"))
 #print(messagebox.showerror("FishC Demo","Error!!!"))
 #messagebox.showinfo("Hadley","Great!!!",icon="info")
 messagebox.showwarning("Hadley","Warning!!!",icon="warning")
 
mainloop()
 
 
filedialog(文本对话框)
 
当应用程序需要使用打开文件或保存文件的功能时
 
实例1：
 
from tkinter import *
 
root = Tk()
 
def callback():
     #askopenfilename函数用来打开文件
     #asksaveasfilename函数用来保存文件
     fileName = filedialog.askopenfilename()
     print(fileName)
 
Button(root,text="打开文件夹",command=callback).pack()
 
mainloop()
 
 
 
 
实例2：限制打开文件类型
 
from tkinter import *
 
root = Tk()
 
def callback():
     #askopenfilename函数用来打开文件
     #asksaveasfilename函数用来保存文件
     #fileName = filedialog.askopenfilename()
     #限制打开文件类型
     fileName = filedialog.askopenfilename(filetypes=[("PNG",".png"),("GIF",".gif")])
     print(fileName)
 
Button(root,text="打开文件夹",command=callback).pack()
 
mainloop()
 
colorchooser(颜色选择对话框)
 
颜色对话框提供一个让用户选择颜色的界面
 
实例1：
 
from tkinter import *
 
root = Tk()
 
def callback():
     #colorchooser函数用于打开颜色选择对话框
     fileName = colorchooser.askcolor()
     print(fileName)
 
Button(root,text="打开文件夹",command=callback).pack()
 
mainloop()
 
 
对应的RGB值及其对应的16进制值
 
 
078 Pygame：初次见面，请大家多多关照
 
 

测试开发笔记
 
第一章 测试基础 
 1.什么是软件测试 
 2.软件测试的目的、意义（怎么做好软件测试） 
 3.软件生命周期 
 第二章 测试过程 
 1.测试模型 
 H模型
 V模型 
 2.内部测试 
 3外部测试 
 验收测试（在系统测试之后） 
 回归测试 
 4.测试过程（干什么，怎么干） 
 5.各阶段输入、输出标准以及入口、出口准则:（测试阶段过程要素） 
 第三章 测试方法 
 1.测试方法对比 
 2.测试方法组合 
 第四章 软件质量 
 1.什么是软件质量 
 2.质量要素 
 3. 6大特性27个子特性ISO国际标准组织CMM/CMMI（Capability maturity model）能力程度度模型 
 4.CMMI把企业分为5个等级 
 5. CMM与CMMI的区别
 第五章 SQL 
 约束 
 1主键约束 
 2 非空约束 not null 
 3 外键约束 FOREIGN KEY 
 4 默认约束 
 5 检查约束 check 
 6 唯一约束 unique 
 SQL语句 
 创建数据库. 
 表、字段、类型 
 查询 
 批量处理
 视图/虚表 view 
 索引 
 存储过程 procedure 
 事务 transaction 
 触发器 trigger 
 练习 
 一、单表查询练习 
 二、聚合函数练习 
 三、分组查询练习 
 四、嵌套查询练习 
 五、联接查询练习 
 六、外联接查询 
 七、补充提高 
 第六章 C语言 
 C语言中的存储 
 数据类型 
 常量
 结构体 
 条件／分支逻辑 
 Switch 
 If 
 循环 
 For 
 while 
 do…while 
 函数 
 第七章 Windows环境搭建 
 一、名词注解与定义： 
 C/S 
 B/S 
 进销存系统 
 OA系统 
 第八章 需求管理 
 1．什么是需求 
 2． 需求工程在做什么 
 3． ★需求变更 
 4．★需求的跟踪 
 需求跟踪矩阵的作用 
 需求的特点 
 需求工程 
 变更控制流程图 
 第九章 缺陷管理 
 缺陷相关概念 
 缺陷管理相关概念 
 BUG管理基本流程
 BUG单 
 第十章 测试需求分析 
 概念
 ★如何做测试需求分析 
 ★UML统一建模语言（Unified Modeling Language） 
 第十一章 配置管理 
 1.什么是配置管理 
 2.配置管理流程 
 配置管理工具
 SVN操作过程手册 
 一、 如何创建“project”项目版本库 
 二、 如何查看创建的“project”项目版本库 
 三、 在版本浏览器里面，创建文件，并进行检出 
 四、 如何对该项目入基线 
 五、 分支文件进行合并 
 六、 分支冲突的解决 
 第十二章 系统测试 
 概念： 
 分类： 
 功能测试（Function testing中国 Feature testing国际） 
 性能测试（Sercarity testing） 
 安全性测试（Security Testing） 
 安装测试 
 GUI测试（Graphical user interface） 
 可用性测试（Usability testing） 
 异常性测试 
 文档测试 
 备份测试 
 配置测试 
 网络测试 
 第十三章 用例设计 
 等价类 
 练习 
 1.1年龄注册 
 1.2.年龄注册 
 1.3.扩充 
 边界值 
 2.1.年龄 
 2.2.用户名注册 
 2.3.变量命名 
 2.4.进销存价格 
 2.5.Windows文件命名 
 总结 
 边界值 
 第十四章 系统测试执行 
 测试环境搭建文档
 用例执行
 填BUG报告
 第十五章 QC（Quality Center） 
 QC后台： 
 QC前台： 
 Requirements 需求模块 
 Test Plan 测试用例模块 
 Test Lab 测试执行模块 
 第十六章 PYTHON 
 Python的安装 
 Python的集成环境
 数据类型
 运算符
 缩进
 控制语句
 IF条件 
 WHILE循环 
 FOR循环 
 BREAK \ CONTINUE 
 函数 
 定义
 调用
 第十七章 单元测试
 单元测试概念
 单元测试静态测试
 单元测试动态测试
 测试评价准则
 逻辑覆盖率 
 单元测试策略 
 ⑴ 孤立测试 
 ⑵自顶向下的单元测试策略 
 ⑶自底向上的单元测试方法 
 单元测试用例设计（基本路径覆盖法）
 程序控制流图 
 单元测试执行 
 单元测试框架 
 第十八章 集成测试 
 第一阶段总结 
 Test platform 
 Bug的其他说法 
 第二阶段项目笔记 
 一．建立项目JXC 
 二．布置JXC 
 三．配置SVN 
 四．访问SVN 
 进销存项目 
 进销存项目总结 
 测试需求分析 
 1、定义测试范围 
 2、建立需求项 
 3、细化需求项 
 4、需求覆盖率分析 
 判定表 
 3.1.读书选择 
 3.2.Counter 
 3.3：word中的判定表举例 
 3.4.合并判定表 
 3.4.密码修改 
 3.5.进销存 
 3.6.总结 
 因果图 
 4.1.字母判定 
 4.2.自动售货机 
 状态迁移 
 5.1.飞机售票系统 
 5.2.缺陷跟踪 
 流程分析
 6.1.处理流程 
 6.2.系统登录 
 6.3.字母判断 
 6.4.组合查询 
 正交试验 
 7.1.环境搭建 
 7.2.Counter 
 7.3.组合 
 7.4.环境搭建 
 其他 
 输入域 
 输出域 
 异常分析 
 错误猜测
 
第一阶段
 第一章 测试基础
 1.什么是软件测试：
 两个依据（需求、测试用例），两个方法（手工、自动），一个对比（预期结果和实际结果的对比）
 2.软件测试的目的、意义：（怎么做好软件测试）
 初期： 尽量多的发现缺陷生成相关规范
 中期： 尽量早的发现缺陷
 后期： 尽量预防问题：通过以往的经验积累
 控制成本（贯穿始终）尽量少的时间和人力发现更多的缺陷
 3.软件生命周期：软件的产生直到报废或停止使用的生命周期。软件生命周期内有问题定义、可行性分析、总体描述、系统设计、编码、调试和测试、验收与运行、维护升级到废弃等阶段，也有将以上阶段的活动组合在内的迭代阶段，即迭代作为生命周期的阶段。
 
如何尽量多的发现缺陷?
 沟通
 在测试前期与开发沟通 确认测试重点 确认测试的优先级
 了解开发人员技术和业务背景 业务水平 技术水平 代码质量 人员流动性
 在测试结束后
 对已发现的bug进行统计 知道高发概率bug 在新项目中要进行重点测试
 针对代码 代码复杂度
 版本管理
 针对基础测试基础版本要进行充分的测试
 验收前的最后一个版本一定要进行完全重复测试
 测试方法
 黑盒方法 功能问题 无法保证所有的代码逻辑都被执行到 用白盒测试思想补充黑盒测试
 静态测试方法 文档评审 代码走查
 测试过程
 上一阶段为下个阶段提供重点指导
 用户参与的测试或用户反映回来的错误和问题为下次测试的或测试补充的必备内容
 
第二章 测试过程
 1.测试模型
 H模型：
 
H模型图
 优点：
 1 介入早 与开发并行 更早的发现问题
 2 测试过程独立于开发过程 更客观 更主动
 V模型
 
双V模型图
 ㈠需求阶段
 产品经理，项目经理，产品工程师写《需求规格说明书》Software Reqwirment Specaficalion(SRS)
 内容：需求项（业务，主要功能）需求子项，对子项的详细描述
 测试的工作：对需求进行测试和评审A系统测试计划《系统测试计划书》B系统测试计划《系统测试方案书》C系统测试实现《系统测试用例》
 ㈡设计阶段
 开发经理，架构师，开发工程师写出《概要设计说明书》High-level design(HLD)
 内容：系统程序中的模块，子模块和他们之间的关系和接口
 测试的工作：对HLD进行测试和评审A集成测试计划《集成测试计划书》B集成测试设计《集成测试方案书》C集成测试实现《集成测试用例》
 ㈢详细设计阶段
 开发工程师，架构师，写出《详细设计说明书》Low-level desragn(LLD)
 内容：函数 代码 逻辑
 测试工作：对LLD进行测试和评审A单元测试计划《单元测试计划书》B单元测试设计《单元测试方案书》C《单元测试用例》
 ㈣编码阶段
 开发工程师写代码
 优点：介入早，提高测试质量； 分成三个阶段，发现问题更有针对性；测试与开发并行，更好的利用项目资源。
 缺点：项目成本高；技术要求高，对人员要求高；并行工作中，一方未完成就会对整个造成延误。
 适用范围：规模大、软件成熟度高的项目。
 2.内部测试
 测试阶段 测试对象 测试方法 测试目的 经济价值 优点 缺点 必要性 资源
 系统测试
 system testing（ST） 整个系统
 （整个产品） 黑盒测试 验证产品是否符合需求规格说明书 能够保证产品以较高的的质量尽早的上市销售，从而使公司获取利润 1简单
 2技术要求低 1测试介入时间晚，修改成本高
 2有一些问题可能被遗留不会被修改 必须保证 1对被测产品
 2需求规格说明书
 3系统测试工程师
 4需求开发人员
 集成测试
 integration testing（IT） 模块
 子模块
 接口 灰盒测试 验证模块、子模块、接口是否符合
 概要设计说明书 能够帮助更准确的 定位缺陷的所在，从而降低了定位缺陷的成本 定位准确快速 1接口测试有技术要求，技术实现难度大
 2接口太多，数量庞大，做所有接口的集成测试成本高 不是必须做的，
 必须做测试的
 1公共的主要模块
 2核心模块
 3和外界软件接口模块 1被测的产品
 2概要设计说明书
 3集成测试工程师
 4概要设计人员
 单元测试
 unit testing(UT) 函数
 代码
 逻辑 白盒测试 验证函数代码逻辑是否符合详细设计说明书 能够最早的开展测试工作，降低修复成本，防止缺钱被扩大化（注意：加以重视：1公共的模块2全局性的数据结构3重要的使用频率较高的功能4以往项目经常出错的严重问题5复杂度较高的模块6当开发人员业务不熟悉编码不熟练的模块要进行单元测试） 介入时间早，发现问题早，修改成本低。 1技术难度高
 2工作量太大 不是必须的 1开发环境
 2LLD
 3单元测试工程师
 4架构师（详细设计人员）
 3外部测试：
 使用验收测试的原因
 1内部测试只能模拟用户使用却不能代替用户使用
 2由于专业不同业务背景不同无法模拟用户使用的习惯
 3测试人员和用户对产品的理解可能不同
 验收测试：（在系统测试之后）
 α测试：由用户组织一部分人在开发环境下来对产品进行测试 如网游的内侧
 β测试：所有系统使用者都可以参加的测试(在实际使用环境下) 如网游的公测
 分类 测试过程 参与人员 目的 过程主要内容
 针对项目类软件 验收测试 开发人员：提供满足验收要求的软件或系统，或用户需要的相关开发文档
 测试人员：
 1、搭建验收测试环境
 2、准备验收测试用例
 3、准备用户需要的相关测试文档
 4、组织人员进行验收演示
 用户代表：对系统进行一定的试用
 客户代表：签字确认验收是否通过
 行业：负责在验收过程中提出问题并协助用户和客户检查系统是否满足需求 1、检查软件的功能是否与用户最初需求相一致
 2、是客户回款的标志 1、进行验收前准备
 A、准备相关的资料
 B、搭建验收测试环境
 C、指定相关的验收参与人
 2、进行验收演示
 A 、对产品使用进行演示
 B、回答专家、用户的提问
 3、签署验收报告
 针对产品类软件 α测试 开发人员：
 1、提供可以进行α测试的软件
 2、负责修改用户代表发现的问题
 测试人员：
 1、检查或协助用户填写缺陷报告
 2、向用户学习相关的使用关注点
 邀请的用户或客户代表（付费）
 1、按照自己的操作习惯使用软件，提出易用性等方面的问题和改进建议 明确用户的使用体验，提高产品的适用范围和使用质量标准 1、明确进行α测试的版本
 2、邀请潜在用户进行使用体验
 3、针对用户提出的问题进行修复或改进
 β测试 潜在用户：
 1、安装软件并使用
 客服人员：
 记录并反馈用户的问题 提前占领市场 1、发布一个下载地址
 2、用户进行软件下载并使用
 回归测试：
 回归测试可以发生在任何一个阶段
 分为完全回归和选择回归
 回归范围 回归分类 特点 优点 缺点 适用范围
 完全回归 完全重复法 每次回归测试都要执行全部测试用例 回归测试充分，覆盖面广，不容遗漏 工作量大，时间长，成本高 时间充裕且测试资源较充分时，第一次和最后一次做回归测试的时候用这种方法
 选择性回归 覆盖修改法 每次回归测试时只执行发现错误的用例 时间最短，成本最低，简单效率高 回归测试不充分，漏洞较多 时间较紧且人力资源不足时，中间版本的测试轮次可以使用，关联度比较小的模块和功能
 周边影响法 每次回归除了执行发现bug的用例外，还要执行与其相关的用例 在考虑了测试成本的基础上有效提高了回归测试的质量 效率 很难确定影响的周边范围，相关用例定位较困难 适合于全局数据结构被修改或公共模块被修改，或核心算法业务被修改时，公用的模块，关系、关联复杂的模块
 指标达成法 每次回归测试达到规定的语气指标
 就可以停止测试了 所有的测试都可度量 1指标生成需要很长的周期，
 很多的项目区累计经验
 2要有比较稳定的团队这个指标才有意义 成熟度较高的测试团队应用于指标达成法
 （适用度很低，很少有公司使用）
 
分类 步骤 优点
 确定周边
 范围的方法 界面检查法 1明确被修改的功能 简单
 2修改功能的上下游功能 
 3调用修改功能的功能和
 修改功能调用了的功能 
 4和修改功能游相同输入输出的功能 
 5在测试中执行上诉关联的用例 
 代码检查法 1明确被修改的函数和代码 准确，全面
 2在整个系统中检查所有
 调用了修改函数的函数 
 3明确上诉所有函数对应的界面 
 4测试上诉界面测试用例 
 4.测试过程（干什么，怎么干）
 整个系统的内容 需求项（业务、主要功能） 需求项 测试计划 测试需求项 系统测试阶段
 需求子项 测试方案 测试需求子项 
 详细内容 测试用例 具体如何进行测试 
 整个系统的集成 概要设计 概要设计项 测试计划 集成测试阶段
 概要设计子项 测试方案 
 具体内容 测试用例 
 整个系统最小单元 详细设计 函数 测试计划 单元测试
 逻辑 测试方案 
 代码 测试用例
 
5.各阶段输入、输出标准以及入口、出口准则:（测试阶段过程要素）
 系统测试 入口准则 输入文档 输出文档 出口准则
 系统测试计划 开发计划通过评审并入基线
 需求规格说明书通过评审并入基线 开发计划书
 需求规格说明书 系统测试计划书 系统测试计划书通过评审并入基线
 系统测试设计 系统测试计划书通过评审并入基线 需求规格说明书
 开发计划书
 系统测试计划书 系统测试方案书 系统测试方案书通过评审并入基线
 系统测试实现 系统测试方案书通过评审并入基线 需求规格说明书
 系统测试计划书
 系统测试方案书 系统测试用例
 预测试项 系统测试用例、预测试项通过评审并入基线
 系统测试执行 系统测试用例、预测试项通过评审并入基线
 集成测试报告通过评审并入基线 需求规格说明书
 系统测试计划书
 系统测试方案书
 系统测试用例
 预测试项 缺陷报告
 预测试项报告
 系统测试报告 系统测试报告、预测试项报告、缺陷报告通过评审并入基线
 集成测试 入口准则 输入文档 输出文档 出口准则
 集成测试计划 概要设计说明书通过评审并入基线 概要设计说明书 集成测试计划书 集成测试计划书通过评审并入基线
 集成测试设计 集成测试计划书通过评审并入基线 集成测试计划书
 概要设计说明书 集成测试方案书 集成测试方案书通过评审并入基线
 集成测试实现 集成测试方案书通过评审并入基线 集成测试计划书
 集成测试方案书
 概要设计说明书 集成测试用例 集成测试用例通过评审并入基线
 集成测试执行 集成测试用例通过评审并入基线
 单元测试报告通过评审并入基线 集成测试计划书
 集成测试方案书
 集成测试用例
 概要设计说明书 集成测试报告
 缺陷报告 集成测试报告、缺陷报告通过评审并入基线
 单元测试 入口准则 输入文档 输出文档 出口准则
 单元测试计划 详细设计说明书通过评审并入基线 详细设计说明书 单元测试计划 单元测试计划通过评审并入基线
 单元测试设计 单元测试计划通过评审并入基线 详细设计说明书
 单元测试计划书 单元测试方案书 单元测试方案书通过评审并入基线
 单元测试实现 单元测试方案书通过评审并入基线 详细设计说明书
 单元测试计划书
 单元测试方案书 单元测试用例 单元测试用例通过评审并入基线
 单元测试执行 单元测试用例通过评审并入基线 详细设计说明书
 单元测试计划书
 单元测试方案书
 单元测试用例 单元测试报告
 缺陷报告 单元测试报告、缺陷报告通过评审并入基线
 
第三章 测试方法
 测试方法对比
 分类方法 测试方法名称 依据 测试对象 理论上的测试目的 实际工作中的测试目的 测试评估标准 测试环境 测试工作介入点 优点 缺点 适用范围
 按照不同的测试对象划分（黑白灰盒的区别） 黑盒 SRS 整个软件产品 检查软件的功能实现是否与SRS相一致 尽早进行验收，收回开发成本 需求覆盖率 尽量与用户环境相一致 只要功能可以进行操作 简单，测试效率高 1、无法保证所有的代码逻辑都被测试到
 2、后台相关的非界面处理可能会遗漏（文件、数据库）
 3、当前功能与其他功能有联系的部分可能也会被遗漏 适合进行功能、性能等使用和外部特性的测试适用范围广泛，适用所有可见功能
 白盒 LLD 代码逻辑函数 检查代码的逻辑实现是否与LLD相一致 尽早发现问题缺陷，降低缺陷修复成本.便于定位问题 逻辑覆盖率
 语句覆盖
 分支覆盖
 条件覆盖
 分支-条件覆盖
 路径覆盖 开发环境 只要独立的函数或类代码编写完成后 覆盖充分，可以覆盖到每行代码 技术较难
 效率较低
 成本较高 针对核心业务、复杂算法、公共模块、全局数据结构、新增功能
 灰盒 HLD 模块\子模块接口 检查接口实现是否与HLD相一致 逐步集成，降低缺陷定位成本 接口覆盖率 子系统集成尽可能和用户环境一致,模块内部接口以及模块间接口可以在开发环境下进行
 子系统间的接口最后要在与用户环境下测试 进行测试的接口模块已完成 可以提早定位和发现问题 技术最难
 成本最高 公共模块之间的调用，复杂度较高的模块调用、使用频率较高的模块调用
 
特点 分类 优点 缺点 适用范围
 按照是否运行程序划分 静态 不执行程序 1、文档评审
 A、正规检视
 B、技术评审
 C、同行评审
 2、静态分析技术
 A、控制流分析
 可以发现以下缺陷
 1、死循环
 2、执行不到的语句
 3、不存在的语句
 B、数据流分析
 可以发现以下缺陷
 1、变量未定义被使用
 2、变量已定义未使用
 C、信息流分析
 可以帮助开发人员定位缺陷
 1、输入变量与语句的关系
 2、输出变量与语句的关系
 3、输入变量与输出变量的关系 较动态测试时间早,不用写代码 工作量大 重要的功能模块、核心的业务、算法
 公共模块
 动态 执行程序 黑和测试
 动态白盒：插装—在代码中加入print打印语句，检查程序的中间运行结果 复杂，效率高 测试较晚,写代码 所有功能
 
优点 缺点 适用范围
 按照不同的测试手段划分 手工 能够主动的发现bug 重复工作量大，容易引入疲劳缺陷,只能依靠见到的界面 绝大多数的场合
 自动化 可以无限制不断重复,把人从劳动里解放出来，提高劳动效率，提高了测试质量，能发现人不能发现的错误 无法发现脚本中未写明的缺陷 GUI界面稳定
 回归阶段
 需求稳定且功能已实现时才进行脚本的编写
 性能测试工具：提取相关的系统数据，构造并发用户
 测试方法组合
 测试方法组合 典型案例 使用时机 特点
 黑盒
 黑盒静态手工 　 　 　
 黑盒静态自动化 　 　 　
 黑盒动态手工 　 　 　
 黑盒动态自动化功能测试 Mercury的QTP：用于检测应用程序是否能够达到预期的功能及正常运行 
 通过自动录制、检测和回放用户的应用操作 1、能够有效地帮助测试人员对复杂的企业级应用的不同发布版进行测试
 2、提高测试人员的工作效率和质量，确保跨平台的、复杂的企业级应用无故障发布及长期稳定运行
 IBM Rational Robot 是功能测试工具 它集成在测试人员的桌面 IBM Rational TestManager 上，在这里测试人员可以计划、组织、执行、管理和报告所有测试活动，包括手动测试报告。这种测试和管理的双重功能是自动化测试的理想开始。
 Borland SilkTest属于软件功能测试工具 是Borland公司所提出软件质量管理解决方案的套件之一。这个工具采用精灵设定与自动化执行测试，无论是程序设计新手或资深的专家都能快速建立功能测试，并分析功能错误。
 基于Java语言的功能和性能测试工具 JMeter是Apache组织的开放源代码项目 主要针对Java语言 它是功能和性能测试的工具，100%的用java实现
 黑盒动态自动化性能测试 Mercury的LoadRunner：是一种预测系统行为和性能的负载测试工具。 通过以模拟上千万用户实施并发负载及实时性能监测的方式来确认和查找问题 能够对整个企业架构进行测试。通过使用LoadRunner ，企业能最大限度地缩短测试时间，优化性能和加速应用系统的发布周期。
 Microsoft Web Application Stress Tool 是由微软的网站测试人员所开发，专门用来进行实际网站压力测试的一套工具。 功能强大的压力测试工具 您可以使用少量的Client端计算机仿真大量用户上线对网站服务所可能造成的影响
 webload是RadView公司推出的一个性能测试和分析工具 它让web应用程序开发者自动执行压力测试； webload通过模拟真实用户的操作，生成压力负载来测试web的性能。
 白盒
 白盒静态手工 　 　 　
 白盒静态自动化 　 检查语法规范、语法逻辑 　
 白盒动态手工 目前的最流行的单元测试工具是xUnit系列框架 常用的根据语言不同分为JUnit（java），CppUnit（C++），DUnit（Delphi ），NUnit（.net），PhpUnit（Php ）等等。 该测试框架的第一个和最杰出的应用就是由Erich Gamma （《设计模式》的作者）和Kent Beck（XP（Extreme Programming）的创始人 ）提供的开放源代码的JUnit。
 白盒动态自动化 Jtest是parasoft公司推出的一款针对java语言的自动化白盒测试工具，它通过自动实现java的单元测试和代码标准校验，来提高代码的可靠性。parasoft同时出品的还有C++ test，是一款C/C++白盒测试工具 　 　
 灰盒
 灰盒静态手工 　 　 　
 灰盒静态自动化 　 　 　
 灰盒动态手工 　 　 　
 灰盒动态自动化 BMC的APPSight 系统会将问题发生的相关信息完整录制下来，包括问题发生的现场场景、信息及分析等，从而快速切入到问题根源 　
 测试管理工具 是业界第一个基于Web的测试管理系统，它可以在您公司内部或外部进行全球范围内测试的管理。通过在一个整体的应用系统中集成了测试管理的各个部分，包括需求管理，测试计划，测试执行以及错误跟踪等功能，TestDirector极大地加速了测试过程。
 
1自动化测试就是用程序驱动程序的测试
 2黑白灰测试的区别
 测试的对象不一样，对于代码实现逻辑程度不一样（黑盒不需要了解代码实现，白盒需要完全了解代码实现，灰盒需要部分了解代码实现）
 3静态与动态测试的区别
 被测程序执行与否 静态不执行程序包括文档评审静态分析技术代码走读，动态包括黑盒测试和动态分析技术
 4自动化合手工测试的不同
 测试手段不同
 
第四章 软件质量
 1.什么是软件质量
 质量：确定一个实体的特性满足需求的程度
 内部质量：软件研发过程中，评价的软件质量
 外部质量：软件上市后，用户评价的质量
 过程质量：评价软件研发中每个过程的质量
 软件质量的三个层次
 ⑴流程质量，领导关注 ⑵产品质量 测试工程师关注 ⑶使用质量 用户关注
 2.质量要素
 质量铁三角 ： 技术 过程 组织
 3. 6大特性27个子特性ISO国际标准组织CMM/CMMI（Capability maturity model）能力程度度模型
 
质量模型列表
 质量模型特性 子特性 特点 常见测试点 案例说明
 功能性 适合性 合适的功能（用户提出要有哪些功能）功能的必要性 验证功能是否满足需求的要求，检测做没做 打电话、听音乐、发信息
 准确性 正确的功能 需求文档中的预期动作和预期输出，做对没有 信息的发送内容是否正确
 互操作性 和其他软件的互相操作 第三方软件的交互 word文档对打印机驱动程序的操作
 保密安全性 保护信息和数据 保护得到授权的人或者系统能正常访问相关的信息或数据 1、登录的用户名和密码
 2、权限使用
 3、防止DOS攻击（拒绝访问攻击）4、系统数据的保护和加密，如密码的加密
 5、传输加密，如密码的网络传输
 6、防病毒
 7、放溢出，如char与varchar的字符数
 保证未授权的人或系统无法看到相关的信息或数据 
 功能性的依从性 遵循功能性相关的标准、约定或法规 是否符合国家法律规定 如色情网站
 可靠性 成熟性 缺陷尽可能的少 　 　
 容错性 提前考察的异常情况出错问题 整个系统的外部接口 如word打印时，打印机死机出现报错，但不影响word的使用
 易恢复性 失效后恢复原有功能、性能 系统的性能测试 如网游延迟卡死现象。系统提示内存不足。银行系统的心跳监听。灾难备份。
 可靠性的依从性 法律法规 　 灾难备份。
 易用性(CUI测试) 易理解性 （快速理解） 系统交互的信息是否准确、清晰、易懂，指导下一步操作。 系统提示信息是否准确 如网银密码超出位数报错
 易学性 （快速上手） 易用好学 是否有说明书、是否在线帮助、是否有提示信息 msn的帮助手册
 易操作性 （快速做完） 方便快速使用 操作的直观程度，操作步骤、操作动作多少与时间长短 鼠标、gui层数、安装过程
 易测试性 软件可控 提供工具给测试工程师，可以控制系统运行，以达到测试目的 windows的性能工具与服务管理工具
 软件可观察 通过辅助手段可 　
 吸引性 外观 外观 　
 易用性的依从性 法律法规 　 　
 可移植性 适应性 （跨平台、跨语言） 软件产品无需采用有别于为考虑该软件的目的而准备的活动或手段就可能适应不同的指定环境的能力;是否适应其他系统环境 软件、硬件、外设、数据库 微软与苹果的前期竞争。主板与CPU
 易安装性 在指定环境中是否易于安装 主流平台和系统100%测试用例，非主流10% flash安装
 共存性 不同的其他系统能共同运行 1、功能是否能正常运行满足要求
 2、系统性能能满足要求 是否会抢占资源。迅雷和pplive抢占资源。杀毒软件，瑞星和金山不能共存
 易替换性 替代为其他相同功能的产品的能力 升级过后的系统是否会造成系统崩溃 软件升级补丁升级
 可移植性的依从性 法律法规 　 　
 效率-性能 时间效率 规定条件下，软件产品执行其功能时，提供适当的响应和处理时间以及吞吐率的能力 系统的反应时间 提款机取款时间的快慢
 资源效率 在规定条件下，软件产品执行其功能时，使用合适的资源数量和类别的能力 做一件事所占用的系统资源 电器所消耗的电能多少
 效率依从性 法律法规 　 　
 维护性-维护的难易程度与成本 易分析性 软件产品诊断软件中的缺陷或失效原因或识别待修改部分的能力 辅助工具或者日志文件或者常用问题帮助手册 qq异常退出的帮助文件
 易改变性 代码容易被修复或修改 高内聚，低耦合 　
 稳定性 软件产品避免由于软件修改而造成意外结果的能力 长期的监控一个系统的运行情况和系统的资源情况 淘宝的系统监控
 维护性的依从性 法律法规
 
配置管理
 配置工具 有的话 用的工具叫什么名字
 安装------B/S(浏览器)(check in /check out:原理) C/S(客户端)
 
4.CMMI把企业分为5个等级
 
5.CMM与CMMI的区别
 cmmi：是不同cmm的集成，集成并发扬cmm的优点，并借鉴其他模型的优点融入新理论和实际研究成果，不仅能应用于软件领域，而且能应用于系统过程和其他过程领域，Cmmi和cmm最大不同： Cmmi1.1版本包含4个成分：系统工程（SE）、软件工程（SW）、应用集成产品和过程开发（IPPD）、供应商外包管理（SS） Cmmi有2种表示方法： 阶段式 连续式
 
第五章 SQL
 数据库的价值目标:
 数据库的技术(不只是界面 还要知道数据库逻辑 1.要对数据库的设计理解 2.还有数据库对象的关系3.数据库的常见命令)
 常见数据库：MySQL Access(单机) MS-SQL(交互好) Oracle Sybase DB2
 MySQL 小巧 效率高 免费
 后三种Oracle Sybase DB2是大型收费，数据安全和备份好
 数据库作用：组织、存储、处理
 关系型数据库
 第一日:
 关系型数据库
 数据库的作用
 表
 索引
 视图
 存储过程
 触发器
 事务 对象 优缺点 使用范围
 SQL Server具体操作
 建库
 建表
 备份 恢复 操作手册: 建库 建表 备份 恢复
 第二日:
 查询命令
 单表查询
 多表查询
 查询 统计功能测试点
 第三日:
 新增功能 新增功能测试点
 更新命令 修改功能测试点
 删除命令 删除功能测试点
 补:
 存储过程 学会构造大量测试数据
 触发器 了解 看懂 如何测试
 
RDBMS 关系型数据库
 SQL Structured Query Language 结构化查询语言
 C/S Client/Server 客户 服务器
 B/S Browser/Server 浏览器 服务器
 第一天:
 文件类型:文件存储位置改变 程序代码更新 对大量数据量处理不恰当
 数据库的意义”
 1数据的重用(硬盘)
 2检索速度要提高(分类存储)
 3把数据与代码的耦合度降低（数据存放位置与代码无关）
 数据库管理系统 SQLServer
 Oracle
 MySQL
 DB2
 数据库的表结构
 1.数据分类
 2.数据关联
 数据库设计评审点
 1.数据存储是否有重复现象 不同表中是否存在相同字段(该字段既不是主键也不是外键)
 2.是否符合范式要求 同一个表中存在数据重复字段不要超过两个以上 可以保证冗余数据很少
 可以考虑有适当冗余
 3.对于业务有频繁查询要求的数据表 
 4.表间关系是否正确 是否按照业务要求进行了数据关联
 5.数据库字段以及表的设计是否充分 数据字段内容是否涵盖需求要求的所有数据
 数据字段类型 及长度是否符合需求
 
表 基本组成单元 有记录和 字段组成
 表中每一条数据
 存储数据
 数据分类
 字段位置变化 不影响程序
 索引 建立在字段上 可以对字段进行排序 同一张表索引
 更新索引字段值的时候 新增会打乱索引的顺序时
 视图 建立在数据库上 封装查询命令 存储数据 方便查询调用 提示安全性 显示结果固定
 如果在执行事务时没有执行完就实行事务回滚
 事务:是有两条以上的数据库命令组成的原子集合.该事务中的那条命令要么一次性执行成功,要么都不执行,如果在执行过程中执行失败那么该事务就进行回滚,将数据恢复到执行之前的状态
 是否存在某些业务要封装成事务?
 优点:可以保证有关联的数据库操作所对应的关联所需要的完整性和统一性
 缺点:不要将不相关的操作放在同一个事务中,否则会降低执行成功率和效率
 
存储过程 存储过程封装了多条SQL命令,必须存放在数据库服务端
 优点: 减少了网络传输ＳＱＬ命令的压力
 提高了访问的安全性
 ＳＱＬ　命令存放在服务器端执行效率高
 缺点：需要编写和设计调试 它是一段程序 对于大批量的数据较弱 避免分支和循环
 触发器 自动执行 并且只能对一张表中进行触发 当某一张中发生操作时需要同时对其让表的数据进行操作可以考虑创建触发器
 
过程:
 检查ＳＱＬ服务是否启动
 图形界面建库 建表
 企业管理器
 命令行方式
 查询分析
 主键 用一标记该表中的记录 不能重复 不能为空
 外键 通过外键与其他表中的数据进行关联 只能是以存在主键值
 
当前表的数据要被其他表使用时 要有主键
 外键 有主键存在时就要设置对应的外键
 
搭建测试环境时或给用户安装产品
 海达票务处理
 C/B 建立空库hdpw1
 恢复
 安装服务器端
 安装客户端
 admin admin
 
约束：
 1主键约束
 1 主键约束 primary key
 –特点:约束的字段数据，不能为空、不能重复。
 如果插入或者更新的数据为空或者重复将不允许进行操作。
 
–语法：
 1)不命名的主键约束
 create table student
 ( 
 No int primary key,
 Name char(10),
 Sex char(2),
 ruxu datetime
 );
 2)命名的主键约束
 create table student
 ( 
 No int,
 Name char(10),
 Sex char(2),
 ruxu datetime,
 constraint pk_001 primary key(No)
 );
 3)删除主键约束
 –语法：alter table 表名 drop constraint 约束名;
 alter table student drop constraint pk_001;
 4)改主键约束
 –语法：alter table 表名 alter column 字段名 类型 not null;
 –alter table 表名 add constraint 约束名 primary key (字段名);
 alter table student alter column No int not null;
 alter table student add constraint PK_002 primary key(No);
 2 非空约束 not null
 1)增加非空约束
 create table student1
 ( 
 No int not null,
 Name char(10),
 Sex char(2),
 ruxu datetime
 );
 
2)改非空约束
 alter table student1 alter column Name char(10) not null;
 3 外键约束 FOREIGN KEY
 –新增外键关系
 1)非命名的外键约束
 create table grade
 (
 no int foreign key references student(No),-- 字段名 字段类型 foreign key references 主表（主键字段）
 grade float
 );
 2)命名的外键约束
 create table grade
 (
 No int,
 grade float,
 constraint fk_001 foreign key (no) references student(no)
 );
 3)删除外键约束
 alter table grade drop constraint fk_002;
 4)改外键约束
 alter table grade add constraint FK_002 foreign key(no) references student(no) on delete cascade; --当主表进行数据删除时，从表一起删除
 alter table grade add constraint FK_002 foreign key(no) references student(no) on update cascade; --当主表进行数据更新时，从表一起更新
 alter table grade add constraint FK_002 foreign key(no) references student(no) on delete no action; --当主表进行数据删除时，违反了外键约束，拒绝进行删除操作
 alter table grade add constraint FK_002 foreign key(no) references student(no) on update no action; --当主表进行数据更新时，违反了外键约束，拒绝进行更新操作
 4 默认约束
 –default 当 一个字段不填写内为空时，默认插入一条数据
 1)增加default 约束
 create table sex
 (
 id int,
 sex char(2) default ‘男’
 );
 2)改 default 约束
 5 检查约束 check
 –只有满足检查约束的数据才能添加到表中，不满足的加不进来
 1)不命名的检查约束
 create table balance
 (
 id int,
 money float check (money >= 0)
 );
 
2)命名的检查约束
 create table balance
 (
 id int,
 money float,
 constraint CK_001 check (money >= 0)
 );
 3)删除检查约束
 alter table balance drop constraint ck_001;
 
4)改检查约束
 alter table balance add constraint CK_002 check (money >= 0);
 6 唯一约束 unique
 –对于字段输入的内容必须是唯一的，不能重复，但可以为空，多个字段都可以输入唯一约束
 1)不命名唯一约束
 create table tiger
 (
 tig_id int,
 tig_name char(10) unique
 );
 
2)命名唯一约束
 create table tiger
 (
 tig_id int,
 tig_name char(10),
 constraint UN_001 unique(tig_name)
 );
 
3)删除唯一约束
 alter table tiger drop constraint UN_001;
 4)改唯一约束
 alter table tiger add constraint UN_002 unique(tig_name);
 SQL语句
 创建数据库.
 语法：create database 数据库名字;
 数据库名字不能使用数字作为开头。可以使用字母或者_作为开头
 create database _51testing;
 
开辟两块空间，一个是保存日志的，一个是保存表的
 删库 DROP DATABASE 库名；
 单行注释 ——
 多行注释 /* */
 切换数据库
 语法：use 数据库名；
 use _51testing;
 转换当前使用数据库
 备份数据库
 BACKUP DATABASE 库名 TO DISK=’文件名’；
 如BACKUP DATABASE xuanke TO DISK=’d:\test.bak’;
 恢复数据库
 RESTORE DATABASE 库名 FROM DISK=’文件名’;
 如RESTORE DATABASE xuanke FROM DISK=’D:\test.bak’;
 表、字段、类型
 建表
 语法：create table 表名字 ( 字段名 字段类型 字段约束 ， 字段名 字段类型 字段约束 );
 create table tmp
 (
 NO int primarykey,
 NAME char(10)
 );
 字段约束可以没有
 删除表
 语法：drop table 表名
 注意：外键约束
 drop table grade
 建立外键
 Sid INT FOREIGN KEY (sid) REFERENCES student (sid)
 CREATE DATABASE xuanke1;
 USE xuanke1;
 –DROP database xuanke1;
 CREATE TABLE student1
 (sid INT PRImary KEY,
 sname CHAR(20) NOT NULL,
 sex CHAR(2) NOT NULL CHECK(sex IN (‘男’,‘女’)),
 card_id CHAR(20) NOT NULL unique CHECK(len(card_id) = 18),
 calss ChAR(20) NOT NULL,
 major CHAR(20) NOT NULL,
 birth_year INT CHECK(birth_year BETWEEN 1900 And 3000) NOT NULL,
 enrollment DATETIME NOT NULL,
 tel CHAR(20)
 )
 CREATE TABLE course1
 (
 cid INT PRIMARY KEY,
 cname CHAR NOT NULL,
 tname CHAR(20) NOT NULL,
 ctime DATETIME NOT NULL,
 cadress CHAR(20) NOT NULL,
 pre_course_id INT,
 )
 CREATE TABLE student_course1
 (
 sid INT FOREIGN KEY (sid) REFERENCES student1 (sid),
 cid INT FOREIGN KEY (cid) REFERENCES course1 (cid) PRIMARY KEY(sid,cid),
 grade INT
 )
 插入一条记录
 在表中增加数据（insert into）
 语法：
 1对表中所有的字段添加数据：insert into 表名 values (第一个字段的值，第二个字段的值，第三个字段的值…);
 注意1：values 值得个数一定要和表中字段的个数相等，一一对应。
 注意2：values 值得数据类型，必须要和表中字段的数据类型相匹配。int fload 值是数字，如果char 值得字符要用’值’。
 注意： 英文单引号 逗号 ，日期 要加单引号
 
insert into student values (5,‘郑佳祺’,‘男’,‘003’,‘2011-08-23’,‘北京’,‘1979-01-01’);
 insert into student values (6,’’,‘男’,‘003’,‘2011-08-23’,‘北京’,‘1979-01-01’);
 insert into student values (7,‘庞鹏珏’,‘男’,3,‘2011-08-23’,‘北京’,‘1979-01-01’);
 
2对表中指定字段添加数据：insert into 表名(字段1，字段2，字段3) values (值1，值2，值3);
 insert into student(stuid,stname,sex,family) values (8,‘齐倩’,‘女’,‘天津’);
 insert into student(stuid,stname,sex,family,birthday) values (9,‘例子1’,‘女’,‘天津’,’’);
 insert into student(stuid,stname,sex,family,class) values (10,‘例子2’,‘女’,‘天津’,’’);
 insert into student(stuid,stname,sex,family,class) values (11,‘例子3’,‘女’,‘天津’,NULL);
 insert into student(stuid,stname,sex,family,class) values (12,‘例子4’,‘女’,‘天津’,‘NULL’);
 删除数据
 语法：1.delete from 表名
 注意: 删除表中数据时要考虑约束。
 同样用法 truncate table 表名
 delete from grade
 truncate table grade;
 2.delete from 表名 [where 条件]
 delete from student where stname = ‘例子1’;
 1）单一条件
 DELETE FROM student WHERE sid=500;
 2）复合条件
 DELETE FROM student WHERE sex=‘男’ AND major=‘计算机’;
 DELETE FROM student WHERE major=‘计算机’ OR major=‘1’;
 DELETE FROM student WHERE sid BETWEEN 1 AND 500;
 DELETE FROM student WHERE sid>=1 AND sid<=500;
 3）模糊条件
 DELETE FROM student WHERE major LIKE ‘计算机%’; ———— % 通配符（计算机后面任意位任意字符）
 DELETE FROM student WHERE major LIKE ‘%务’;
 DELETE FROM student WHERE class LIKE ‘4%期’;
 DELETE FROM student WHERE class LIKE ‘4_期’; ———— _ 通配符（4后面一位的任意字符）
 DELETE FROM student WHERE sname LIKE ‘[xw]%’; ———— [] 从括号中取任意一个值
 Truncate table student 删除student表记录内容 但是后面不能加条件（不记录日志，速度快）
 更新表数据（修改一条记录）
 更新表数据
 –语法：update 表名 set 字段 = 值，字段2=值[where 条件]
 –注意1：字段类型 和 值得类型 要匹配，主键的值可以被修改
 –注意2：为了保证表数据的完整一直，最好在更新是增加WHERE 条件。
 select * from student
 update student set sex = ‘男’ ;
 update student set sex = ‘女’ where family = ‘天津’
 update student set family = ‘广州’ where family = ‘北京’
 将学号小于50的记录的入学时间更改为2011-5-18
 UPDATE student SET enrollment=‘2011-5-18’ WHERE sid<50;
 将‘计算机’专业的学生转成“计算机科学与技术”
 UPDATE student SET major=‘计算机科学与技术’ WHERE major LIKE ‘计算机’;
 将专业为“信管”开头和“汽车”开头的专业转成“自动化控制”
 UPDATE student SET major=‘自动化控制’ WHERE major LIKE ‘信管%’ OR major LIKE ‘汽车%’;
 将所有省为“北京”和“北京市”的记录统一成“北京”，并将这些记录的班级改成49期
 UPDATE student SET province=‘北京’,class=‘49期’ WHERE province LIKE ‘北京%’;
 将入学时间大于1985-1-1记录的出生时间改为比入学年月早18年
 UPDATE student SET borth_year=year(enrollment)-18 WHERE enrollment > ‘1985-1-1’;
 year() 是求DATE类型的年份
 查询
 简单的查询记录基础语法
 基础语法 select 查询的内容（也就是字段名1，字段名2） from 表名 where 条件
 （用*号可以显示所有字段）
 查询李进峰的所有基本信息
 SELECT * FROM student WHERE sname=‘李进峰’;
 查询李进峰和菲菲的所有基本信息
 SELECT * FROM student WHERE sname=‘李进峰’ OR sname=‘菲菲’;
 SELECT * FROM student WHERE sname IN (‘李进峰’, ‘菲菲’);
 查询所有姓张的同学的所有基本信息
 SELECT * FROM student WHERE sname LIKE ‘张%’;
 查询姓名中有“宇”的同学的所有信息
 SELECT * FROM student WHERE sname LIKE ‘%宇%’;
 查询姓名长度为3，第一个字为“李”最后一个字是“照”的记录
 SELECT * FROM student WHERE sname LIKE ‘李_照’;
 查询所有姓张和姓李的同学的学号和姓名以及出生年月
 SELECT sid,sname,borth_year FROM student WHERE sname LIKE ‘张%’ OR sname LIKE ‘李%’
 SELECT sid,sname,borth_year FROM student WHERE sname LIKE [张李]%’;
 查询姓“杨”并且所在省份为“河北省”的同学的学号
 SELECT sid FROM student WHERE sname LIKE ‘杨%’ AND province=‘河北省’;
 查询”北京”、”湖南”和”河南省”同学的所有信息
 SELECT * FROM student WHERE province=’北京’ OR province=‘湖南’ OR province=‘河南省’
 SELECT sid,sname,borth_year FROM student WHERE province IN (‘北京’, ‘湖南’, ‘河南省’);
 查询姓“”李但是所在省份没有“湖南”字样的同学的省份证号码
 SELECT card_id FROM student WHERE sname LIKE ‘李%’ AND province NOT LIKE ‘%湖南%’
 查询18岁（不含18）以前上学的同学的姓名和电话
 SELECT sname,tel FROM student WHERE year(enrollment)-borth_year<18;
 查询所有大于25岁的人的所有信息
 SELECT * FROM student WHERE year(getdate())-year(enrollment)>25;
 通配符
 使用环境，用于模糊查询，连接符号用Like 而非 =
 
代表全部，所有，没有规定数量和内容。一般用于select 后面 不作为条件
 _ 代表一个字符，一个数据位。中文要用两个__ 。作为条件使用
 % 代表任意的，没有规定数量和内容。作为条件使用
 [值1,值2,值3] 从括号内的任意值。作为条件使用
 select * from student where stname like ‘张%’
 select * from student where stname like ‘[张李]%四’
 运算符。条件
 – = 两边内容相同。
 – > 左边大于右边。
 – < 右边大于左边。
 – >= 左边大于等于右边。
 – <= 右边大于等于左边。
 – <> 或者 != 不等于
 – between A and B 介于 A 和 B 之间，并且 >=a <=b .前面的数要小于后面的数，包含边界数的。
 select * from grade where coursegrade = 80
 select * from grade where coursegrade between 80 and 100
 条件关联
 – 条件1 and 条件2 :要同时满足条件1 和 条件2 是并且的关系。
 – 条件1 or 条件2 :只要满足一个条件就可以 是或的 关系。
 – () :先去执行括号中得条件
 – 字段 in (值1,值2,值3) :字段的内容要满足 值1 或 值2 或 值3
 select * from student where family = ‘北京’ and stname like ‘张%’
 select * from student where family in (‘上海’,‘天津’)
 排序
 –对查询到的结果按照升序或者降序的方式进行排列。
 –语法 order by 字段 排序方式 （desc,asc） asc 可以省略
 –注意：order by 一定要写在所有查询sql 的最后面
 select * from grade order by coursegrade
 聚合函数
 对查询的结果中某个字段进行函数运算
 sum(字段) :求和函数 字段需为数字类型
 avg(字段) :求平均值 字段需为数字类型.不会计算为空的条目。
 min(字段) :最小的值
 max(字段) :最大的值
 count(字段) :统计字段的个数，这里可以使用 * ，统计所有结果的行数。
 distinct(字段) :去重复
 注：聚合函数，不能放在WHERE中，需要放在HAVING里
 – 显示学生的总成绩
 select sum(coursegrade) from grade
 – 显示最高的成绩是多少
 select min(coursegrade) from grade
 select avg(coursegrade) from grade
 select * from grade
 select count(*) from student
 DISTINCT 去除重复行
 SELECT DISTINCT province FROM student;
 
别名AS (Alias)
 as 临时别名
 列别名在WHERE中不能使用 GROUP BY 中不能使用 ORDER BY 中可以
 表别名可以在任何地方使用
 select class, sex, count(sex) as数量 FROM student GROUP BY class,sex ORDER BY class;
 select count(*) as 学生个数 from student
 select stname as 姓名,stuid as 学号from student
 SELECT和ORDER BY 不影响表中数据 所以可以使用别名
 分组里加WHERE和ORDER BY
 
对真空的处理
 查询为空的字段 ： 字段名 is null
 查询 不为空的字段 : 字段名 is not null
 select * from grade
 select * from grade where coursegrade is not null
 
–统计每个课程的选修人数大于2个人的信息
 对课程分组，显示课程和对应的人数
 select couid,count(stuid) from grade group by couid having count(stuid) >2
 –统计<学生选修信息表>，统计每个同学的总成绩
 统计记录条数 count？
 查多少名学生
 SELECT count(*) FROM student
 查有多少种班级
 SELECT count (DISTINCT class) FROM student;
 查入学时间在1990-1-1到2000-12-31的学生个数
 SELECT count(enrollment) FROM student WHERE enrollment BETWEEN ‘1990-1-1’ AND ‘2000-12-31’ ;
 分组查询 GROUP BY
 先对查询内容进行分组、分类，然后在对一个组中的数据进行查询或者运算
 select 查询的内容 from 表名 group by 字段名
 select stuid,sum(coursegrade) from grade group by stuid
 select * from grade
 select stuid,sum(coursegrade) from grade where coursegrade is not null group by stuid
 分组前条件
 在group by 之前使用where 条件去选取数据
 分组后条件
 在 group by 分组后 + having 条件
 select stuid,sum(coursegrade) from grade where coursegrade is not null
 group by stuid having sum(coursegrade) >=200
 –统计<学生信息表>，统计每个班级中每种性别的学生人数
 select * from student
 –统计按照性别分得学生人数
 select sex,count(stuid) from student group by sex
 –统计<学生信息表>，统计每个班级中每种性别的学生人数,两个分组条件
 –统计<grade表>，统计每门课程的平均成绩,并按照成绩降序排序
 select couid,avg(coursegrade) from grade group by couid order by avg(coursegrade) desc
 
RIGHT函数
 取身份证最后5位数
 SELECT right(card_id, 5) FROM student;
 将身份证补齐20位，前面用0补
 SELECT right(‘00’+card_id, 20) FROM student;
 SELECT ‘00’+card_id FROM student;
 LEFT函数
 取身份证的前10位
 SELECT left(card_id, 10) FROM student;
 将学号小于50的电话设置成NULL
 UPDATE student SET tel = NULL WHERE sid< 50;
 将电话为NULL的学生信息查询出来
 SELECT * FROM student WHERE tel IS NULL;
 判断条件是NULL的时候不能用= 要用IS IS NOT
 HAVING
 分组查询中，如果条件中有聚合函数，不能放在WHERE中，需要放在HAVING里
 查询平均出生年>1991的班级信息
 SELECT class,avg(borth_year) FROM student GROUP BY class HAVING avg(borth_year) > 1991 ;
 统计哪些班级男生平均年龄大于20
 SELECT calss FROM student WHERE sex=’男’ GROUP BY class HAVING avg(year(getdate())-borth_year)>20;
 优先级WHERE——GROUP BY——HAVING——PRDER BY
 查询学生的姓名和出生年，年龄最大的放前面
 SELECT sname, borth_year FROM student ORDER BY borth_year ;
 TOP 查询结果去前几个结果
 查询年龄最大的学生信息 年龄最大的前10名
 SELECT TOP 1 sname, borth_year FROM student ORDER BY borth_year ;
 SELECT TOP 10 sname, borth_year FROM student ORDER BY borth_year ;
 查询年龄最小的学生信息 年龄最大的前10名
 SELECT TOP 1 sname, borth_year FROM student ORDER BY borth_year DESC;
 SELECT TOP 10 sname, borth_year FROM student ORDER BY borth_year DESC;
 查询按照学号排序，前50个学生的信息
 SELECT TOP 50 * FROM student ORDER BY sid;
 查询最近入学的10名学生信息
 SELECT TOP 10 * FROM student ORDER BY enrollment DESC;
 关联查询（等值联接）
 内连接 等值连接
 外连接 1、左连 2、右连
 多表关联
 1内连接 等值连接 inner join
 语法 select 内容 from 表1 inner join 表2 on 等值条件
 select * from student inner join grade on grade.stuid = student.stuid
 select grade.couid,couname,coursegrade from grade inner join course on grade.couid = course.couid
 2外连接 outer join
 1）左连 select 内容 from 表1 left outer join 表2 on 条件
 2）右连 select 内容 from 表1 right outer join 表2 on 条件
 select * from grade outer join student on student.stuid = grade.stuid
 注：左连接 以 outer join 左边的表为准，要显示全部的左边表的数据，如果右边表没有关联的数据显示Null 与右边表比较 当右边表没有值时 只取左边表的记录
 select * from student right outer join grade on student.stuid = grade.stuid
 注：右连接 以 outer join 右边的表为准，要显示全部的右边表的数据，如果左边没有关联数据，显示Null
 多表关联
 语法：select 内容 from 表1，表2，表3 where 条件
 select stname,couname,coursegrade from student,course,grade
 where student.stuid = grade.stuid and course.couid= grade.couid and coursegrade >80
 select * from grade
 –所有男同学的平均成绩
 select avg(coursegrade) from student,grade where student.stuid = grade.stuid and sex = ‘男’ and coursegrade is not null
 select * from student
 3子查询，嵌套查询
 –当某一个查询的条件，是在另一个查询的结果集里面时，使用嵌套查询
 –查询李四的成绩。
 select * from grade where stuid = (select stuid from student where stname =‘李四’)
 –查询 张三和李四的成绩
 select * from grade where stuid in
 (select stuid from student where stname =‘张三’ or stname = ‘李四’)
 select * from grade where stuid = (select stuid from student where stname =‘张三’)
 or stuid = (select stuid from student where stname =‘李四’)
 –有考试成绩在 70~90的学生的姓名
 select stname from student where stuid in
 (select stuid from grade where coursegrade between 70 and 90)
 批量处理？
 DECLARE @sid INT 申请一个变量
 DECLARE @card_id CHAR(18)
 SET @sid=1 赋初值
 SET @card_id = ‘000000000000’+right(‘00000’+convert(VARCHAR(6),@sid),6) convert 强制转换数据类型
 PRINT @sid
 PRINT @card_id
 INSERT INTO student2 VALUES (@sid,‘蒋艳梅’,‘女’,‘49期’,‘计算机’,@card_id,1999,‘1999-9-9’,‘1111111’,‘1111’)
 
CREATE PROCEDURE btInsert AS 或者 CREATE PROC btInsert AS --(保存一个过程)
 DECLARE @sid INT
 DECLARE @card_id CHAR(18)
 SET @sid = 1
 WHILE (@sid <= 100000)
 BEGIN
 SET @card_id=’1111111111111’+right(‘00000’+convert(VARCHAR(6),@sid),6)
 INSERT INTO student2 VALUES (@sid,‘蒋艳梅’,‘女’,‘49期’,‘计算机’,@card_id,1999,‘1999-9-9’,‘1111111’,‘1111’)
 SET @sid = @sid +1
 END
 EXECUTE btInsert 或者 EXEC btInsert （执行已经保存的过程）
 视图/虚表 view
 创建视图 create view 视图名 as (SQL)
 create view tiger as (
 select stname,couname,coursegrade from student,grade,course
 where student.stuid = grade.stuid and grade.couid = course.couid)
 –注意1.视图中不保存数据，不保存表结构，不保存表，没有约束。只保存sql 语句。
 –注意2.视图可以当表来使用，可以用视图去建视图。但是，不建议做 增 删 改的操作。
 –注意3.删除视图时,不会影响到原来的基础表。可以直接在视图中使用SELECT
 create view big_tiger as (select stname,coursegrade from tiger )
 delete from big_tiger where coursegrade is null
 删视图
 –语法：drop view 视图名
 drop view big_tiger
 drop view tiger
 
视图的优点
 –1.对于使用sql 不熟练来说。视图是个很简单的查询途径
 –2.对于经常重复的复杂sql，使用视图可以提高查询效率
 –3.可以辅助用于权限管理，提高数据的安全性
 –4.帮助保护表和数据的完整一致性
 
视图的缺点
 –1.降低了查询效率
 –2.增加保存空间
 –3.无法对数据和表进行操作。使得操作测试不方便进行。
 create view cll as (
 select class,count(stuid) as 人数 from student group by class
 )
 select * from cll where 人数 = 2
 
–视图在企业中如何应用
 1.对于测试而言，降低测试的复杂度。例如：复杂 sql 写一次保存视图，以后都直接调用视图。
 2.对于测试而言，降低工作难度。例如：新来的新人可能对表结构不熟悉，对sql 也不熟悉，使用视图可以尽快上手开始工作。
 3.对于开发而言，降低服务器的工作。提高服务器运行效率。例如：如果不用视图，查询语句要在服务器端生成传给数据库。如果使用视图，服务器直接查询视图就可以满足查询功能。
 4.对产品设计和业务人员而言，降低了工作难度，不用学习和使用复杂sql 语言。例如：如果产品或者业务人员想去查询某些指定的数据时，只要让开发或测试人员建一个视图。直接去查询视图就可以了。
 索引
 –索引就像目录，表中对于一个字段的目录结构。如果想操作表中的数据，先在索引字段中找到那一行，然后再去操作那一条数据。
 –注意1：建议索引设置在主键、外键、唯一约束，效率高
 –注意2：索引是应用于查询条件的。经常使用的查询条件字段，应该被设置为索引字段。
 –注意3：一个表中可以有多个索引，索引之间可以交叉字段，一个索引可以有多个字段。
 
索引的优点：
 –1.提高查询效率
 –2.提高了排序效率
 
索引的缺点：
 –1.占用数据库资源
 –2.降低了对数据库增、删、改的效率
 
索引在企业中如何应用：
 –1.页面上如果有很多的查询条件并且需要排序时，建议一一创建索引。
 –2.检查是否主键和外键、唯一约束建立了索引关系。
 –3.在测试过程中应该检查，运行查询条件时是否使用了索引。
 –4.测试中检查，平凡被更新的表，不要设置太多的索引。
 
–建索引
 –语法：create index 索引名 on 表(字段，字段…);
 create index suoyin1 on student(stname,family);
 
–删索引
 –语法：drop index 表名.索引名
 drop index student.suoyin
 存储过程 procedure
 –把一些sql 放在一起执行，并且有逻辑的执行。存储过程。
 –语法1：简单的无参数存储过程。
 – create procedure 存储过程名 as sql语句
 create procedure aa as
 update grade set couid = 6 where couid =1;
 update course set couid = 6 ,couname = ‘生物’ where couid =1;
 
执行存储过程
 –语法 exec 存储过程名
 exec aa;
 
select * from grade;
 select * from course;
 
语法2：有参数的存储过程
 – create procedure 存储过程名 (@参数1 参数类型，@参数2 参数类型…) as sql语句
 create procedure BB (@id int,@NewId int,@name char(10))
 as
 update grade set couid = @NewId where couid = @id;
 update course set couid = @NewId ,couname = @name where couid =@id;
 
执行存储过程
 –语法 exec 存储过程名(参数1，参数2，参数3) 　
 SQL SERVER 参数不加括号
 –注意1.参数的个数和 数据类型必须与定义相一致
 –注意2.存储过程中的sql 是按照顺序执行的
 –注意3.当存储过程中一个sql失败时。不会影响其他sql的执行。
 exec BB 3,13,‘SQL SERVER’
 alter table grade add constraint CH check (couid < 20)
 update grade set couid = 21 where couid = 13;
 exec BB 13,21,‘ORACLE’
 create database bank;
 use bank;
 create table bj_bank
 (
 name char(10),
 money int check(money>=0)
 constraint pk_nanme_bj primary key (name)
 事务 transaction
 把所作的操作放在一组，如果有一个失败就全失败，都成功时候才成功
 事务是存储过程的一个部分，存储过程的一个写法
 – begin transacion 事务名
 – commit transacion 事务名
 – rollback transacion 事务名
 create procedure zz1
 (
 @a_name char(10),
 @b_name char(10),
 @a_money int,
 @b_money int,
 @c_name char(10)
 )
 as
 begin transaction c1 --开始事务c1
 if (select money from bj_bank where name = @a_name) > 0 --判断a账户
 begin
 update bj_bank --从a中减去
 set money=money-@a_money
 where name=@a_name;
 update zs_bank --向c中添加
 set money=money+@a_money
 where name=@c_name;
 commit transaction c1
 end
 else
 rollback transaction c1 --如果判断失败回滚所有操作
 
begin transaction c2 --开始事务c2
 if (select money from bj_bank where name = @b_name) > 0 --判断b账户
 begin
 update bj_bank --从b中减去
 set money=money-@b_money
 where name=@b_name
 update zs_bank --向c中添加
 set money=money+@b_money
 where name=@c_name
 commit transaction c2
 end
 else
 rollback transaction c2 --如果判断失败回滚所有操作
 
update bj_bank set money = 5000 where name = ‘a’;
 update bj_bank set money = 1000 where name = ‘b’;
 update zs_bank set money = 0 where name = ‘c’;
 
exec zz1 a,b,250,600,c
 select * from bj_bank
 union
 select * from zs_bank
 exec zz2 a,b,500,700,c
 exec zz2 a,b,1000,500,c
 
存储过程 zz2 开始
 create procedure zz2
 (
 @a_name char(10),
 @b_name char(10),
 @a_money int,
 @b_money int,
 @c_name char(10)
 )
 as
 begin transaction guopeng
 if (select money - @a_money from bj_bank where name = @a_name) >= 0
 begin
 update bj_bank set money = money - @a_money where name = @a_name;
 update zs_bank set money = money + @a_money where name =@c_name;
 commit transaction guopeng;
 end
 else
 begin
 rollback transaction guopeng;
 end
 begin transaction qiqian
 if (select money - @b_money from bj_bank where name = @b_name) < 0
 begin
 rollback transaction qiqian;
 end
 else
 begin
 update bj_bank set money = money - @b_money where name = @b_name;
 update zs_bank set money = money + @b_money where name =@c_name;
 commit transaction qiqian;
 end
 存储过程zz2 结束
 存储过程循环。大批量的制造测试数据。
 create procedure ww
 (
 @name char(10),
 @money int,
 @count int
 )
 as
 declare @num int;
 set @num = 0;
 while (@num < @count)
 begin
 insert into bj_bank values (@name,@money);
 set @num = @num +1;
 end;
 drop procedure ww
 alter table bj_bank drop constraint pk_nanme_bj
 exec ww ‘王沙’,900,1000000;
 select * from bj_bank where money = 30
 truncate table bj_bank
 
–存储过程在企业中如何应用：
 –1.对于开发、对于测试而言，存储过程简化了工作难度。
 –2.对于开发、测试而言，存储过是可以实现逻辑的。
 –3.对于测试而言，帮助我们大批量的生成测试数据。
 –4.对于测试而言，帮助我们去检查对数据库的操作数据是否符合预期
 –5.对于开发而言，存储过程支持事务，可以做逻辑编程
 
–删除存储过程
 –语法 drop procedure 存储过程名
 drop procedure ww
 触发器 trigger
 当满足触发条件时，执行后面的触发sql，支持事务
 语法： create trigger 触发器名 on 工作表表名 for 触发方式 as sql语句
 触发条件 delete,update 触发条件因数据库而异
 create trigger trigger_student_delete
 on student
 for delete
 as
 delete grade from grade,deleted where grade.stuid = deleted.stuid;
 select * from student
 select * from grade
 delete from student where stuid = 1
 alter table grade drop constraint FK__grade__stuid__7D78A4E7
 练习
 一、单表查询练习
 1、查询<学生信息表>，查询学生"张三"的全部基本信息
 Select * from student where stname=’张三’;
 2、查询<学生信息表>，查询学生"张三"和”李四”的基本信息
 select * from student where stname in (‘张三’,‘李四’)
 3、查询<学生信息表>，查询姓"张"学生的基本信息
 select * from student where stname like ‘张%’;
 4、查询<学生信息表>，查询姓名中含有"四"字的学生的基本信息
 select * from student where stname like ‘%四%’;
 5、查询<学生信息表>，查询姓名长度为三个字，姓“李”，且最后一个字是“强”的全部学生信息。
 select * from student where stname like ‘李_强’;
 6、查询<学生信息表>，查询姓"张"或者姓”李”的学生的基本信息。
 select * from student where stname like ‘张%’ or stname like ‘李%’;
 7、查询<学生信息表>，查询姓"张"并且"所属省份"是"北京"的学生信息
 select * from student where stname like ‘张%’ and family =‘北京’;
 8、查询<学生信息表>，查询"所属省份"是"北京"、”新疆”、”山东”或者"上海"的学生的信息
 select * from student where family in (‘北京’,‘新疆’,‘山东’,‘上海’);
 9、查询<学生信息表>，查询姓"张"，但是"所属省份"不是"北京"的学生信息
 select * from student where family!=‘北京’ and stname like ‘张_’;
 10、查询<学生信息表>，查询全部学生信息，并按照“性别”排序，性别相同的情况下按照“所属省份”排序，所属省份相同的情况下再按照“班级”排序
 select * from student order by sex,family,class; (多个排序条件，用逗号以此分开，先排第一个、再排第二个。。。。)
 11、查询<学生信息表>，查询现有学生都来自于哪些不同的省份
 select distinct (family) from student;
 （注意distinct使用方法）
 12、查询<学生选修信息表>，查询没有填写成绩的学生的学号、课程号和成绩
 select couid,couid,coursegrade from grade where coursegrade is null;
 13、查询<学生选修信息表>，查询全部填写了成绩的学生的选修信息，并按照“成绩”从高到低进行排序
 select * from grade where coursegrade is not null order by coursegrade desc;
 二、聚合函数练习
 1、统计<学生信息表>，统计共有多少个学生
 select count(stname) from student;
 2、统计<学生信息表>，统计年龄大于20岁的学生有多少个
 select count(stname) from student where (year(getdate())-year(birthday))>20;
 3、统计<学生信息表>，统计入学时间在1998年至2000年的学生人数
 select count(stuid) from student where year(enrollment) between 1998 and 2000;
 4、统计<学生选修信息表>，统计学号为"S001"的学生的平均成绩
 select avg(coursegrade) from grade where stuid=‘1’;
 5、统计<学生选修信息表>，统计学号为"S001"的学生的总成绩
 select sum(coursegrade) from grade where stuid=‘1’;
 6、统计<学生选修信息表>，查询课程号为”C001”的课程的最高成绩
 select max(coursegrade) from grade where couid=‘1’;
 7、统计<学生信息表>，查询所有学生中的最大年龄是多少
 select max((year(getdate())-year(birthday))) from student;
 三、分组查询练习
 1、统计<学生选修信息表>，统计每个课程的选修人数
 select count(*) from grade group by couid;
 2、统计<学生选修信息表>，统计每个同学的总成绩
 select sum(coursegrade) from grade group by stuid;
 3、统计<学生信息表>，统计每个班级中每种性别的学生人数，并按照班级排序
 select class,sex,count(stuid) from student group by sex,class order by class;
 4、统计<学生选修信息表>，统计每门课程的平均成绩,并按照成绩降序排序
 select avg(coursegrade) from grade group by couid order by avg(coursegrade) desc;
 5、统计<学生选修信息表>，显示有两门以上课程不及格的学生的学号
 select stuid from grade where coursegrade<60 group by stuid having count(stuid)>2;
 6、统计<学生信息表>，统计每个班级中的最大年龄是多少
 select max(year(getdate())-year(birthday)) from student group by class ;
 四、嵌套查询练习
 1、用子查询实现，查询选修“高等数学”课的全部学生的总成绩
 select sum(coursegrade) from grade where couid=(select couid from course where couname=‘高等数学’);
 2、用子查询实现，统计<学生选修信息表>，显示学号为"S001"的学生在其各科成绩中，最高分成绩所对应的课程
 思考：如果该学号学生有两个课程分数都为最高的100分，查询会有什么结果(显示2个结果)
 select couname from course where couid=(select couid from grade where coursegrade in (select max(coursegrade) from grade where stuid=1)
 3、用子查询实现，查询2班选修"数据库技术"课的所有学生的成绩之和
 select sum(coursegrade) from grade where stuid in(select stuid from student where class=‘002’) and couid=(select couid from course where couname=‘数据库技术’);
 4、用子查询实现，查询3班"张三"同学的"测试管理"成绩
 select coursegrade from grade where stuid in (select stuid from student where class='003’and stname=‘张三’) and couid=(select couid from course where couname=‘测试管理’);
 五、联接查询练习
 1、查询"张三"的各科考试成绩，要求显示姓名、课程号和成绩
 select stname,couid,coursegrade from student inner join grade on student.stuid=grade.stuid and stname=‘张三’;
 或
 select stname,couid,coursegrade from student,grade where student.stuid=grade.stuid and stname=‘张三’;
 2、查询"张三"的各科考试成绩中，哪科没有记录考试成绩，要求显示姓名、课程号和成绩
 select stname,couid,coursegrade from student inner join grade on student.stuid=grade.stuid and stname='张三’and coursegrade is null;
 或
 select stname,couid,coursegrade from student,grade where student.stuid=grade.stuid and stname='张三’and coursegrade is null;
 3、查询"张三"的各门课程成绩，要求显示姓名、课程名称和成绩
 select stname,couname,coursegrade from student,course,grade where student.stuid=grade.stuid and course.couid=grade.couid and stname=‘张三’;
 4、查询3班"张三"的"测试管理"成绩，要求显示姓名、成绩
 select stname,coursegrade from student,course,grade where student.stuid=grade.stuid and course.couid=grade.couid and couname=‘测试管理’ and stname='张三’and class=003;
 5、查询所有2000年以前入学的，各班男生的各科考试平均成绩
 select class,avg(coursegrade) from grade,student where grade.stuid=student.stuid and sex='男’and year(enrollment)<2000 group by class ,couid;
 六、外联接查询
 查询”李坚强”所有课程的成绩，并显示学号、姓名、课程号和成绩，没有成绩记录的学号包括：(‘S009’,‘S010’,‘S011’)
 1、使用右联接
 select grade.stuid,stname,couid,coursegrade from grade right outer join student on student.stuid=grade.stuid and stname=‘李坚强’;
 2、使用左联接
 select grade.stuid,stname,couid,coursegrade from student left outer join grade on student.stuid=grade.stuid and stname=‘李坚强’;
 3、对比等值连接
 select grade.stuid,stname,couid,coursegrade from grade inner join student on student.stuid=grade.stuid and stname=‘李坚强’;
 七、补充提高
 1、查询“张三”比“王三”入学早几年
 select year(enrollment)-(select year(enrollment) from student where stname=‘王三’) from student where stname='张三;
 2、查询所在班级和该班内学生的年龄之和，其中每个人的年龄都大于20岁，每个班的年龄之和大于60岁
 select class,sum(year(getdate())-year(birthday)) from student group by class;
 
第六章 C语言
 ATM机
 1.取钱 2.存钱 3.查询余额 4.转账
 
作业1：存钱、查询、转账的流程图
 
软件模块结构图
 需求：十进制一位数加法
 XX.C ——C语言的源文件
 编译 ——转换成二进制的机器语言
 XX.exe ——可执行文件
 
不需要编译的脚本语言： PHP ASP JSP PYTHON VBS PEER TCL
 需要编译的高级语言： C VC C# Delphi Java .Net
 
注释： // 和/* */
 
作业3：绘制流程图中所有界面
 
C语言 面向过程的语言 执行过程是自上向下 函数
 F10 单步执行 但不进入函数体
 F11 单步执行 进入函数体
 C语言中的存储
 数据类型
 基本数据类型
 1浮点型
 默认小数位是6位，若输出《6位，完成四舍五入
 若赋予的值小数位《5，后边会随机补数
 vc 对于定义的浮点型变量会默认为double类型，因此会产生警告。想没有警告，强制在赋值语句中的数据后加f. 比如，
 float x;
 x=0.33f;
 
数组
 1）一维数据
 定义：数据类型 数组名[长度];
 初始化：1）先定义，后赋值；
 int a[3];
 a[0]=34;
 a[1]=45;
 a[2]=345;
 2) 边定义，边初始化
 float b[2]={4556.234,45.345};
 3) 只给第0个初始化，后边补0
 double c[3]={345.345345};
 访问：下标从0开始遍历数组
 
2）二维数组
 定义：数据类型 数组组[行的长度][列的长度];
 初始化： 1）先定义，后赋值
 
     int a[2][4];
       a[0][0]=3;
       a[0][1]=4;
       a[0][2]=5;
       a[0][3]=6;
       a[1][0]=7;
       a[1][1]=8;
       a[1][2]=9;
       a[1][3]=10;
       2）边定义，变赋值；
         int b[2][4]={{3,4,5,6},{7,8,9,10}};
 
访问： 行和列的下标从0开始遍历数组
 
2字符串
 定义：char 字符串名[长度];
 初始化：先定义，后赋值
 边定义，边赋值
 1)
 char p1[5]=“abcd”; 对 (因为自动补\0占一位）
 char p2[5]=“abcde”; 错
 2)
 char p3[5]={‘a’,‘b’,‘c’,‘d’,’\0’}; 对
 char p4[5]={‘a’,‘b’,‘c’,‘d’,‘0’}; 错
 输出：prinf("%s",p1);
 printf("%c",p1[0]);
 输入：scanf("%s",&p1); /读整个字符串/
 scanf("%c",&p1[2]); /读单个字符/
 注意：赋值的长度小于定义长度时，会逐个补空
 
结构体
 边定义，边初始化： struct 结构体名 {
 数据类型 数组名[长度];
 数据类型 变量名；
 …} 结构体变量名={初始化对应值}
 struct student {
 char name[10];
 int age;
 } s1={“zhangsan”,18};
 访问：结构体变量名.结构体内部定义的变量名。
 printf("%s",s1.name);
 printf("%d",s1.age);
 
结构体数组
 边定义，变初始化：
 struct 结构体名 {
 数据类型 数组名[长度]; /表示长度/
 数据类型 变量名；
 …} 结构体数组变量名[长度]={{初始化对应值1},{初始化对应值2},} /这里的长度表示多少个，相当于表中的记录数/
 
  struct student {
              char name[10]; /*name这个字符串能有效存储字符数9个，还有1位补空*/
          int age;
        } s[2]={{"zhangsan",18},{"lisi",20}};   /*这里的2表示有2条记录*/
 
3运算符
 算数运算符： + - * /(求商） %（取余）
 关系运算符: > < >= <= ==(等于) != (不等于)
 真(非0) 假0
 逻辑运算符
 && (与) || (或) ! (非)
 
常量
 const 数据类型 常量名=值;
 例如，圆周率 const int pi=3.14;
 
变量
 
 
变量是什么？
 
 
先定义，后使用
 标准c
 int x;
 x=3;
 int j;
 j=89;
 
vc
 int x;
 int j;
 x=3;
 j=89;
 
 
使用赋值语句修改变量值
 
 
变量赋予的值由数据类型决定
 
 
变量包含名字、值和地址
 
 
不同的数据类型在计算机中存储的字节大小不一样
 16位 32位
 int 2个字节 4
 long 4 4
 float 4 4
 double 8 8
 char 1 1
 
 
变量的名字
 首字母：字母，下划线
 包含：字母，下划线，%, 数字
 不能使用c语言的保留字
 
 
全局变量和局部变量
 1）局部变量如何定义：在函数中定义的变量都成为局部变量。离开函数（调用完函数），该变量消失。
 2）全局变量如何定义：在main函数上边定义的变量成为全局变量。对所有的函数都生效。
 3）当局部变量和全局变量同名时，实际上修改的是局部变量。
 常量
 常量的定义
 
 
define 常量名 常量值
 
常量名要全用大写字母
 常量没有数据类型
 1.数组
 定义数组
 数据类型 数组名[N] ；
 N 代表数组的个数
 
结构体
 定义
 Struct 结构体名
 {
 变量1
 变量2
 。
 。
 。
 }
 例：
 Struct
 {
 Char name[8];
 Char sex[2];
 Int age;
 Int grade;
 } Stu_49[2]={{“张三”,”男”，18,60},{“李四”,”女”，19,100}}；
 结构体的显示
 Printf(“ %s”,Stu_49[0].name);
 条件／分支逻辑
 Switch
 switch (表达式)
 {
 case 值1: 处理语句1;
 break;
 case 值2:处理语句2;
 break;
 case 值3:处理语句3;
 break;
 。。。。
 
}
注意1：值的数据类型要和表达式返回值的类型要匹配；
注意2：不要忘了使用break退出后续执行；
注意3：表达式要使用括号括起来；
 
条件 只能输入固定的值
 If
 分支结构
 条件
 情况1： 对应流程图，假分支直接指向后续语句，不含有处理语句
 if (条件)
 处理语句1；
 处理语句2；
 …
 
情况2： 对应流程图，处理语句1和处理语句对应真分支，处理3和4对应假分支
 if (条件)
 处理语句1；
 处理语句2；
 …
 else
 处理语句3;
 处理语句4;
 …
 情况3
 If (表达式1)
 if(表达式2)
 语句2；
 Else
 语句3；
 Else
 语句1；
 循环
 For
 循环结构
 定义循环控制变量
 for (控制变量赋初始值;控制变量终止条件;累加（减）器)
 {
 循环体语句;
 }
 
while (条件)
 {
 
循环体语句;
 }
 
do
 {
 循环体语句；
 } while (条件)
 
for(表达式1；满足循环条件；表达式2)
 {
 循环体；
 }
 while
 while (表达式)
 {
 循环体
 }
 do…while
 do
 {
 循环体
 }
 While(表达式)
 申请卡号时，多申请一位 并用\0座位数据的结束
 Do while 在条件不满足时，会执行一次do中的循环体
 有参数有返回值的函数
 错误跟踪 写日志
 函数
 函数：
 
输出函数
 1.1 printf(控制格式,变量);
 控制格式 %d - 整形
 %c - 字符型
 %ld -长整形
 %f -浮点型 （想控制小数位 %.3f)
 %lf --双精度 (想控制小数位 %.5lf)
 1.2 printf(“你想输出的内容”);
输入函数
 scanf(“控制格式”,&变量1,&变量2,…);
 %c
 %d
 %ld
 %f
 %lf
 int x,y;
 x=234;
 y=234;
 scanf("%d%d", &x,&y);
存在的必要性
 1） 职能单一
 2）定位问题
 3）便于使用
 4） 减少代码冗余
项目中只能有一个main函数。否则移除。
函数使用
 先定义(在main函数外定义）-》调用-》申明（在main函数外边申明）
 注意1：定义的函数名、调用的函数名、申明的函数名必须同名
 5.无返回且无形参的函数
 定义：
 void 函数名()
 {
 语句1；
 语句2；
 。。。。。
 }
 调用：
 函数名();
 申明：
 void 函数名();
无返回有形参的函数
 定义：
 void 函数名(形参列表)
 {
 语句1；
 语句2；
 。。。。。
 }
 在这里，形参列表实际上就是变量定义列表，只是因为放在函数定义中就叫叫它形参。
 比如：int x,int y,int z,char m
 调用：
 函数名(实参列表);
 在这里，实参列表的个数和形参列表个数一致；类型一致；实参列表可以相同数据类型的值，也可以是相同数据类型的变量
 申明：
 void 函数名(形参列表);
有返回有形参的函数
 定义
 数据类型 函数名(形参列表)
 {
 语句1；
 语句2；
 。。。。。
 return 值
 }
 在这里，return的值必须和函数名之前的数据类型匹配。
 调用：
 定义一个和函数返回数据类型相同的变量
 变量=函数名(实参列表);
 申明
 数据类型 函数名(形参列表);
函数名在一个程序中不能同名
 程序结构
 #include 语句
 #include <stdio.h>
 函数申明
 main函数
 自己定义的函数
 其他
字节
ascii
 char m;
 m=“k”;
 /* 输出k字符的ascii码*/
 printf(“m=%d\n”,m);
转义
 \ - 转义符
 \n -控制换行
 \t -控制tab键的距离 
 \0 -空
注释
 单行
 跨行 /* 语句 */
 Void 函数名（）
 Void 函数名（参数1，参数2…）
 Int 函数名（）
 Int 函数名（参数1，参数2…）
 注：1调用函数时 传入的参数类型 要和函数参数的类型一致，返回值也是一样
 2对有参数没有返回值的函数测试
 3对没有参数 没有返回值的函数测试
 4 测试main()函数 复制了一个定义为test_main()
 
补充知识：
 1个字节=8位 编码是ASCII码 又叫ANSI（美国标准码）
 用两个字节表示中文 编码是GB2312
 当16位全部占用时 编码是GB18030
 后来同意标准 全部用16位表示 编码用UTF-8 只翻译16位中的低8位
 注： C语言中main（）函数默认是返回int 类型的值
 
第七章 Windows环境搭建
 一、名词注解与定义：
 环境：分为{1、生产环境；2、测试环境；3、开发环境。
 生产环境（也称为：上线环境）是运维人员的工作环境，有时候测试人员也会参与运维的部署工作）。
 测试环境：测试人员为了测试软件在生产环境中的功能和性能的表现，而尽量可能的模拟了一个生产环境来进行软件测试。
 开发环境：就是开发人员编写软件代码的工作环境。
 一个软件要从开发环境——>测试环境——>生产环境这个环境流程。
 问：为什么不在开发环境中进行软件测试，要测试环境中进行？
 答：因为开发环境它具有可变性，其影响测试的准确性，所以为了保证数据独立性和其测试的准确性，软件测试最好在测试环境中进行。
 测试环境-分为：1、硬件环境；2、OS（操作系统）环境；3、软件环境。
 其硬件环境和OS(操作系统)环境都是要根据被测软件的需求来搭建；软件环境包括：被测试软件和一些用户常用软件，主要测试被测软件和常用软件之间的兼容性、冲突。
 搭建：先要根据需求架设硬件环境，再根据需求架设OS系统环境，要保证架设的OS系统是无毒的，最后架设软件环境，卸载无用的软件，确认软件的证件号来保证一些不必要的错误和冲突。
 为什么要保证架设的OS操作系统环境是无毒的？因为病毒可能产生一些和被测软件无关的BUG。解决方法：可安装杀毒软件，重装系统来防止和保证。
 被测软件-分为：1、单机版；2、C/S（client/server）;3、B/S（browser/server）。三种运行模式。
 C/S（client/server）：是分为客户端、服务端和数据库端（如：PPS、QQ需要用户先安装客户端）。其架设的软件会用客户端来分担一部分工作；
 优点：运行速度快、部分数据存放在本地；
 缺点：兼容性差，要根据不同的系统来开发不同的系统版本，成本高和测试成本高。
 B/S（browser/server）：是可以用IE浏览器直接访问和运行的一种模式，不用预先安装客户端（如：网页游戏、网上订票系统等）。
 优点：兼容性好，数据保密性好；
 缺点：运行速度较慢。
 软件要根据不同的运行环境、性能的要求来选择使用C/S架设，还是用B/S架设。
 扩展内容：
 app:应用软件，是安装在OS（操作系统）上面的。
 光的三原色：红。绿。蓝。
 服务器（软件）：
 1、应用服务器：IIS，Weblogic，JBoss;
 2、Web服务器软件:Apache，Nginx，LightHttpd;
 3、数据库服务器：SQL Server，MySQL（Strucrure Query Language），Oracle；
 4、邮件服务器：QMail，Exchange，Lotus；
 5、FTP服务器
 
C/S
 海达票务系统
 1.硬件环境和操作系统（略）
 2.安装SqlServer，安装客户端和服务器端软件
 3.测试数据准备，环境初始化
 DROP DATABASE hdpw1;
 CREATE DATABASE hdpw1;
 RESTORE DATABASE hdpw1 FROM DISK=‘D:\training\doc\win\student\海达票务\hdpw1’;
 4.参数配置
 4.1 Client端配置，和Server端的链接
 4.2 服务器端配置，和数据库的链接
 4.3 数据库端配置（略）
 5.启动整个海达票务系统
 系统更新时，需要更新C和S端，而B/S架构只用更新S端
 B/S
 安装虚拟机：
 1.打开VMWare
 2.新建一个虚拟机
 3.更改光驱加载的ISO
 4.开启电源
 5.将鼠标焦点放到GuestOS里（如何到HostOS？热键）
 6.格式化磁盘
 7.后续安装的步骤
 8.配置网络
 9.安装VMWareTools
 
配置共享文件夹：
 
进销存系统
 1.安装IIS （通过本机IP访问和netstat查看进程是否成功启动）
 
2.把jxc文件夹拷贝到guest
 3.在IIS里新建一个虚拟目录->指向jxc文件夹
 
4.设置jxc文件夹的权限
 
5.启动相关扩展
 
6.启用虚拟目录的父路径
 
7.设置默认首页
 
OA系统
 1.安装JDK
 
2.将Jdk的bin目录追加到环境变量的Path变量里（如：C:\jdk6\bin）
 注：放在path里可以在cmd中输入命令运行，系统将自动定位jdk所在目录
 
3.新建一个系统变量 JAVA_HOME，值为jdk的安装目录（如：C:\jdk6）
 
4.新建一个系统变量 CLASSPATH，（如：.;C:\jdk6\lib\tools.jar;C:\jdk6\lib\dt.jar） . 指当前目录 注：CLASSPATH （java的类库）
 
注： . 表示当前目录 允许jdk查找当前目录
 5.安装Tomcat，解压后运行startup.bat
 通过127.0.0.1:8080 访问，可以看到Tomcat的欢迎页面
 也可以修改conf/server.xml文件，更改Tomcat启动的端口号
 
注：在conf下server.xml中查找8080（默认端口）修改端口号 更改配置后要重启服务器
 用startup.bat启动tomcat
 6.安装MySql
 
7.部署OA的程序，将程序拷贝到tomcat的webapps目录
 
1)先到Mysql里把测试数据导入
 登录mysql mysql -uroot -p
 进入mysql控制命令行，显示如下
 mysql>
 
从硬盘上导入一个sql文件
 
mysql> source c:~~~~~\oa\setup\redmoon.sql （本质是执行Sql文件里的每一个SQL语句）
 2)修改和数据库的连接、日志和缓存参数
 oa/WEB-INF/proxool.xml 改里面的数据库密码即可
 
oa/WEB-INF/log4j.properties 改日志的路径，并创建相应的路径
 
oa/WEB-INF/classes/cache.ccf 改缓存的路径
 
8.重新启动Tomcat
 访问 127.0.0.1/oa
 admin
 111111
 注：参考 windows环境搭建
 补充知识：
 查看服务：
 
MySql相关命令
 show databases 查看有哪些库
 show tables 查看库有哪些表
 
desc 表名 查看表结构
 
浏览器引擎： 1.渲染页面 2.执行客户端脚本JavaScript 3.执行自由控件
 w3school.com.cn学习前端语言的网站
 
Trident IE
 Gecko FireFox
 Presto Opera
 Webkit Safari
 
Cookies 保存用户名 密码 根据浏览器、域名保存 一个浏览器、域名一个Cookies 唯一标识一个客户
 Session 和cookies类似 是服务器端保存的
 Session 和cookies是一一对应的
 TCP/IP分四层 OSI七层
 
应用层传输协议：http pop3 smtp
 传输层协议：tcp udp
 网络层协议：ip arp
 物理层协议：mac pppo
 三次握手
 目的：建立连接
 1.给服务器发送一个包[SYN] 处于send状态
 2.服务器回复一个包[SYN,ACK] 处于receive状态
 3.给服务器返回一个包[ACK] 两边同步待命 准备发送
 
注：参考 网络模型和协议.vsd
 Session/Cookie：Session是存在服务器的，关闭浏览器则删除Cookie存在客户端，可以设置生命周期
 
JAVA环境搭建
 1.安装jdk程序
 2.配置环境变量
 1)增加JAVA_HOME，值为jdk的根目录
 2)修改Path，在后面追加 ;%JAVA_HOME%/bin
 3)增加CLASS_PATH，值为 .;%JAVA_HOME%/lib/tools.jar
 3.运行cmd，检查java版本
 java -version
 4.运行一个java程序
 1)编辑文件 HelloWorld.java，内容为
 public class HelloWorld {
 public static void main(String[] args) {
 System.out.println(“Hello, world!”);
 }
 }
 2) 编译java文件，生成字节码文件
 javac HelloWorld.java
 3) 运行字节码文件
 java HelloWorld
 
安装Tomcat
 
解压至某目录
运行 bin/startup.bat
使用浏览器访问
 http://127.0.0.1:8080
 
安装MySQL
 
运行MySQL安装程序，next
MySQL的配置 
  
编码
密码
服务
 
mysql -uroot -p
 
部署oa
 
将程序文件拷贝到tomcat的webapps目录
初始化测试数据，登录到mysql控制台，运行source命令
 mysql> source c:…\redmoonoa.sql
程序配置 
  
oa程序和数据库的连接配置
 WEB-INF\proxool.xml
 修改用户名和密码
oa的日志配置文件
 log4j.properties
 log4j.appender.R.File=C:/apache-tomcat-7.0.6/webapps/oa/log/oa.log
oa的缓存配置文件
 WEB-INF\classes\cache.ccf
 jcs.auxiliary.DC.attributes.DiskPath=C:/apache-tomcat-7.0.6/webapps/oa/CacheTemp
 
重启一下tomcat
访问
 http://127.0.0.1:8080/oa
 admin
 11111
 
第八章 需求管理
 1．什么是需求
 明确要什么做什么
 2． 需求工程在做什么
 ㈠需求开发：需求获取 需求分析 需求格式化 需求验证
 ㈡需求管理：需求分配 需求评审 需求基线 需求变更 需求跟踪
 3． ★需求变更
 a)为什么要变更：外因：市场，客户。内因：技术不足 缺陷 人员资源
 b)变更影响了什么：SRS HLD LLD SP UI ZI CODE
 c)怎么做变更的控制（需求变更控制目标）：控制项目成本，控制项目风险
 d)需求变更的越早，影响范围越小，变更越晚，影响范围越大
 　 　 原则 方法
 变更控制的目标 降低变更引起的成本 防止随意的变更 通过评审和会议让用户或者企业负责人在变更上签字来确认变更
 尽量早的发生变更 多设计一些产品原形，由用户确认，
 尽量控制变更影响的范围 尽量不变更，如果变更尽量发生在后续版本
 尽量减少变更所引起的反工 当变更的需求稳定后在介入开发和测试
 降低变更引起的风险 高内聚，低耦合 代码内部干的是一件事，函数与函数之间关联尽量小，尽量使变更只影响到局部，而不影响到整个系统
 4．★需求的跟踪
 a)目的(为什么要需求变更跟踪)将和SRS有关的文档统一管理和关联起来，从而可以从任何一点找到其他文档的相关内容
 b)★★★★★输入、输出（RTM）
 ①开发的需求跟踪：SRS HLD LLD
 ②系统的需求跟踪：SRS ST计划 ST方案 ST用例
 ③集成的需求跟踪：HLD IT计划 ITf方案 IT用例
 ④单元的需求跟踪：LLD UT计划 UT方案 UT用例
 输出（RTM）Requirement Tvace Matrix需求跟踪矩阵
 c)每个阶段，跟踪的内容和变更的跟踪.
 SRS编号 SRS名称 系统测试项ID ST描述 ST子项ID ST子项描述 系统测试用例ID 系统测试用例描述
 HLD编号 HLD名称 集成测试项ID IT描述 IT子项ID IT子项描述 集成测试用例ID 集成测试用例描述
 LLD编号 LLD名称 单元测试项ID UT描述 UT子项ID UT子项描述 单元测试用例代码声明 单元测试用例代码描述
 需求跟踪矩阵的作用：
 开发RTM： 保证所有的需求都被设计实现了
 测试RTM： 保证所有的需求都被测试了
 保证可以通过需求，确定需求变更影响的范围,找到所有的成果物（HLD、LLD、系统测试计划…）
 需求的特点：
 只关心想要什么，不关心怎么去做
 需求工程
 
不同阶段的需求变更的影响范围 　 　 　
 　 　 　 　
 需求阶段需求变更影响 　 　 　
 需求规格说明书 系统测试计划 　 　
 开发RTM 系统测试RTM 　 　
 　 　 　 　
 概要设计需求变更影响 　 　 　
 需求规格说明书 概要设计 　 　
 系统测试计划 系统测试方案 系统测试用例 　
 集成测试计划 　 　 　
 开发RTM 系统测试RTM 集成测试RTM 　
 　 　 　 　
 详细设计需求变更影响 　 　 　
 需求规格说明书 概要设计 详细设计 　
 系统测试计划 系统测试方案 系统测试用例 　
 集成测试计划 集成测试方案 集成测试用例 　
 单元测试计划 　 　 　
 开发RTM 系统测试RTM 集成测试RTM 单元测试RTM
 　 　 　 　
 编码以及后期测试阶段需求变更 　 　 　
 需求规格说明书 概要设计 详细设计 编码
 系统测试计划 系统测试方案 系统测试用例 　
 集成测试计划 集成测试方案 集成测试用例 　
 单元测试计划 单元测试方案 单元测试用例 　
 开发RTM 系统测试RTM 集成测试RTM 单元测试RTM
 补充知识：
 1代码编写原则：
 1）．高内聚，低耦合
 2）．可续性高
 3）．查阅代码编写规范
 2在公司中出现以下问题如何解决
 （1）业务背景不同，导致项目延期
 明确需求文档的格式和标准，尽可能细化需求文档
 （2）需求变化频繁
 建立变更控制
 （3）需求相关的代码，用例找不到，找不全
 建立雪球跟踪
 
CR(Changes requirement)需求变更
 CCB(Changes control board)变更控制委员会
 CMO(Configuration management officer)配置管理员
 PM 项目经理
 SWE 软件开发工程师
 STE 软件测试工程师
 QA 质量保证人员
 CI 基线
 
—基线变更流程
 1）项目成员提交CR
 2）CMO将CR状态标识为已提交，并将CR提交给CCB进行签发
 3）CCB召开会议对CR进行评估
 4）未通过CMO将CR状态标识为已拒绝并返回提交人
 5）通过，CMO将CR状态标识为已接受，将CR与要修改的配置项发给项目组成员并开放CI的配置库权限
 6）项目组成员执行更改并进行验证
 7）CCB召开会议对修改进行审核，如果通过将CR状态标识为已验证，发给CMO，否则返回修改人
 8）CMO检查验证CR记录，收回配置权限，将CR状态标识为已关闭，返回提交人
 变更控制流程图
 
第九章 缺陷管理
 缺陷相关概念
 1什么是缺陷：被测得产品部符合需求和用户使用的实际结果，不符合法律法规
 软件：满足某个功能的逻辑体
 系统：硬件、支撑软件、人员、数据等，综合起来满足某个业务需求的集合体
 2什么可以被定义为缺陷：（缺陷的分类）
 ①缺陷（defect）产品设计与需求设计部符合
 ②错误（error）没有定义的或者未知的错误信息
 ③故障（fault）由于一些原因导致产品失效，重新启动调整后可以恢复用户使用
 ④失效（failure）由于一些原因产品失效，无法自行恢复
 3缺陷提出的目的和意义
 对开发：更好发现缺陷现象，重现和定位缺陷，查找原因，保证所有的缺陷都被修复
 对测试：记录和保证BUG完整一致，回归保证所有的 BUG都验证
 提出问题，把问题交给开发去改
 跟踪缺陷，看是否已经修改
 测试报告，统计数据
 缺陷管理相关概念
 1．BUG管理的目的：
 ①.保证每个缺陷都被修改
 ②.保证每个缺陷都被回归
 ③.缺陷的完整性和一致性
 ④.避免纠纷，降低沟通成本
 2缺陷管理的意义：
 ①提高工作效率（BUG分类，状态负责人）
 ②记录唯一的缺陷信息，保证BUG完整一致（通过设置权限实现）
 ③记录中间环节，是BUG可追溯
 ④统计为测试报告提供数据
 3．参与缺陷管理的角色：
 测试工程师：发现和回归BUG
 测试经理：判断BUG的有效性
 开发经理：分配BUG
 开发工程师：修改BUG
 评审：解决矛盾
 4．缺陷的分类（属性）
 ①按模块分类：例如：登录模块，查询模块
 ②按严重级别分类：blocker阻碍的（不修改该BUG之后的开发测试无法执行）
 Critical崩溃（系统部能用）
 major严重的（严重影响功能使用流程）
 anormal一般的（不会影响主要的功能流程）
 minor轻微的（不会2影响业务流程也不影响使用）
 trvival 界面的
 suggestion建议（可用性，易用性，侧重用户体验）
 ③按优先级别分类：P1----P5(同意 BUG可能会变)
 BUG管理基本流程：
 
BUG管理基本流程及相关角色
 1缺陷管理常见流程
 1）BUG回归时没有修改好：测试工程师REOPEN——开发工程师
 2）测试经理认为BUG无效，原因：不是BGU，对需求的理解误差，描述不清楚。BUG不全，重复
 测试工程师NEW----测试经理CAN OPEN-----REJECTED-----测试工程师CLOSED
 3）开发工程师拒绝修改BUG，原因：修复提高项目风险，理解分歧，技术难度大，修复成本高，修改范围广，优先级低
 测试工程师NEW----测试经理OPEN-----开发经理ASSIGNED-----开发工程师CANFIX------开发经理
 4）开发经理拒绝修改或分配BUG，原因：开发与测试已经不同意，偶发，项目风险高，关系进度成败，技术难度大，无法实现，修改成本高，难度大，影响大，影响进度优先级别低
 测试工程师NEW----测试经理OPEN----开发经理ASSIGNED----评审委员会CAN LATER----Y(LATER)-----N开发经理
 5）一般BUG生命周期
 测试工程师NEW----测试经理OPEN—开发经理ASSIGNED----开发工程师fixed----测试工程师CLOSED
 2缺陷状态：
 New新BUG单 Open确认 Reject拒绝 Assigned已分配 Fixed已修复 Reopen回归时未修改正确重新开放 Closed关闭 Later稍后再改 Postpone延迟 Abandon放弃 duplicate重复 verify验证
 测试人员： 无 → New Fixed → Reopen Fixed → Close
 测试组长： New → Open New → Abandon
 开发经理： Open → Reject Open → Postpone Open → Assign
 开发人员： Assign → Fixed
 项目经理： Reject → Passed Reject → Faild Faild → Abandon
 BUG单
 1．BUG单写作准则（5C）：
 correct(准确)每个组成部分的描述准确，不会引起误解
 clear(清晰)每个组成部分的描述清晰，易于理解
 concise(简洁)只包含必不可少的信息，不包括任何多余的内容
 complete(完整) 包含复现改缺陷的完整步骤和其他本质信息
 consistent(一致)按照一致的格式书写全部缺陷报告
 
2．BUG单模板
 
注意：
 1一定可以重现的BUG可以不写“重复几次操作，出现几次，我认为，标题里不能写步骤，不能用主观的话描述，我在 。。。。的，不确定语句：某些好像，禁止使用”之后”，然后之类的语句”之类的话
 2需求规格说明书以外的错误可以当建议报告，不当BUG报告，开发可以改，也可以不改
 3若是随机出现的BUG，要写出操作几次，出现几次
 4若被测软件是跨平台软件，要写上在其他平台下无误
 5禁止写冗余的操作的步骤。常识性的步骤不用写进缺陷操作步骤
 6写明环境数据，如何选择数据，数据如何被破坏
 7一定要交代清楚测试书记，明确处理对那些数据进行操作
 
第十章 测试需求分析
 概念：
 1.什么是需求分析：明确做什么，明确测什么，怎么测
 2.需求分析的目的（针对测试而言）：
 1）对需求进行细化和分解，从而找到所有的测试点
 2）使从测试覆盖所有的需求（方法：先覆盖业务流，然后模块，关联 非功能）
 3）更细致的需求分析有利于提高测试质量（非软件质量）
 3.测试需求分析的特征
 1）所有的需求项要通过需求分析被核实
 2）测试需求分析应明确指出满足需求的前置条件和不满足需求的前置条件
 3）测试需求分析不涉及具体的测试数据，测试数据是在测试用例中产生
 ★如何做测试需求分析
 1.明确系统框架，有多少个业务流程
 2.明确业务流中有多少个功能测试点，细化分解业务流：
 a)明确每个功能模块的输入、输出、逻辑
 b)满足功能需求的条件和不满足功能需求的条件
 3.明确每个功能的独立处理流程关系
 4.明确功能之间的处理、联系
 5.明确非功能需求和隐性需求 如：安全性、性能、界面美观、易用性等…
 6.系统运行环境包括代码 硬件、软件、外设、数据库、网络
 罗老师的答案
 1考虑非功能性需求
 2挖掘规范需求形成规范需求流程
 3仔细阅读需求规格说明书（找出问题所在）形成问题列表
 4明确该系统的子系统，模块，子模块，功能，子功能（可以借助用例图的方法）
 5明确功能，子功能的流程和逻辑（可以使用活动图，状态图或流程图）
 6挖掘隐性功能，形成隐性功能规范需求
 7找出模块与模块，功能与与功能之间的 关系，确定组合测试需求
 ★UML统一建模语言（Unified Modeling Language）
 1.用例图：被称为参与者的外部用户所能观察到的系统功能模型图
 关系：
 1.关联 
 2.泛化 指向父用例 如：
 3.依赖 
 a)扩展 指向被扩展者
 b)包含 大的指向小的 
 2.活动图：描述了一组顺序的或并发的活动
 状态 活动 开始 结束
 状态转移 循环 集 判断
 泳道
 3包含3个因素：参与者（Actor执行者），系统（Use Case用例），关系（Association关联,Dependency依赖,Generalize继承）
 
第十一章 配置管理
 1.什么是配置管理
 a)对所有配置项进行标识，解决了在不同时间周期内，这些文档贯穿整个项目的生命周期并且对配置项进行权限的控制
 b)配置管理的目的（配置管理在解决生命事情，为什么要进行配置管理）：解决了保证了软件产品的完整性，一致性，共享性、权限，变更可控、可追溯性
 c)配置管理管理了什么（配置项都包括哪些）：配置项 版本 状态
 配置项：项目过程中每个阶段文档产物（SRS,HLD,LLD）代码，开发工具，测试工具，环境（应用服务器，数据库服务器）第三方软件、用户手册，方案、用例等等，
 对象的版本：XX.YY.ZZ.PP
 XX 主版本号——内核程序，核心代号
 YY 子版本号——主要功能、添加功能
 ZZ 维护版本号——增加次要功能，功能改进
 PP 补丁号——SP
 对象的状态状态： 未检查 入基线 冲突 锁
 注：BUG单也算配置项，但是一般单独管理 常用管理工具：QC、Jira、Bugfree、Bugzilla
 2.配置管理流程
 
角色：
 项目经理（Project Manger PM）配置管理员（Configuration Mange Officer CMO）开发经理（Development Manger）测试经理 开发工程师 测试工程师
 质量保证人员（Quality Assurance）变更控制委员会（Change Control Board CCB）
 3.SVN实战
 开发可以生成branch 测试经理可以合并branch入trunk 评审可以使trunk入基线并打tag
 启动数据库服务器subversion： 用start svnserve.exe –d –r
 
为每个文档建立trunk 然后再为单独的文档建立branch 测试后合并入trunk生成新版本的该文档
 优点：节省空间 缺点：tag版本不配套
 
为所有文档建立trunk 每次建立branch都包括所有文档
 优点：所有文档版本相同 缺点：浪费空间
 配置管理工具SVN操作过程手册
 一、如何创建“project”项目版本库
 第一步：在D盘根目录下创建文件夹：“SVNROOT”如图所示：
 
第二步：在“SVNROOT”文件夹内创建两个文件夹分别为：“project”，“project1”两个项目。
 
第三步：对“project”创建版本库；
 A．选中“project”文件夹，点击右键；
 
B．点击“在此创建版本库”。
 
C．版本库创建成功后，“project”文件内自动生产以下文件；
 
D．打开“conf”文件夹
 
备注：对上述三个文件进行解释
 “authz”文件设置“project”操作人员的权限“read、write”；
 “passwd”文件设置操作的用户名和密码；
 “svnserve.conf”文件是“系统配置文件”
 E．对上述3个文件分别进行修改；
 修改“svnserve.conf”
 
未修改
 修改处：
 
修改方法：将“#”及空格，去掉即可。
 
修改后
 修改后对文件另存，存储过程中格式选择“UTF-无BOM”然后点击“保存”。
 
点击“保存后”在原文件夹内生产如图文件，这个是ultra edit 的备份文件
 
修改完成。
 
修改“authz”文件
 
未修改前
 添加内容：
 p1_group_a=p1_a1
 p1_group_d=p1_d1,p1_d2
 p1_group_t=p1_t1
 
[/]
 *=r
 root=rw
 
[project:/]
 @p1_group_a=rw
 @p1_group_d=rw
 @p1_group_t=rw
 
修改后
 修改后对文件另存，存储过程中格式选择“UTF-无BOM”然后点击“保存”。
 点击“保存后”在原文件夹内生产如图文件
 
修改完成。
 修改“passwd”文件
 
未修改前
 添加内容为：
 p1_a1=p1_a1
 p1_d1=p1_d1
 p1_d2=p1_d2
 p1_t1=p1_t1
 
修改后对文件另存，存储过程中格式选择“UTF-无BOM”然后点击“保存”。
 点击“保存后”在原文件夹内生产如图文件
 
修改完成。
 二、如何查看创建的“project”项目版本库
 通过“版本库浏览器”进行查看
 任意空白处点击“鼠标右键”
 
点击：“版本库浏览器”
 
输入：“svn://localhost/project”
 
备注：“localhost”本机的IP地址；
 Project为项目工程名；
 点击“确定”
 
问题：为何会出现“无法连接主机“localhost”：由于目前机器积极拒绝，无法连接”
 分析：“Subversion”服务器端“svnserve”服务未启动；
 
如何启动“svnserve”服务，操作步骤：
 A．桌面“开始”----“运行”----输入“cmd”；
 
B．用“DOS”命令打开此服务
 首先找到该文件：cd c:\Program Files\subversion 进入该目录
 
查看该目录里面有哪些文件，用到命令“dir”
 
3启动该项服务
 输入：start svnserve.exe –d –r D:/SVNROOT
 备注：D:/SVNROOT为客户端路径。
 
运行后弹出一个窗口
 
表示此服务已经运行。
 
备注：在SVN运行过程中，此窗口 必须一直打开运行。
 
服务运行后再次查看创建的版本库
 
如图所示，创建版本库成功。
 三、在版本浏览器里面，创建文件，并进行检出
 如何在版本库里面创建文件
 A．在根目录下点击“右键”点击“创建文件夹”
 
C．点击“创建文件夹”
 
输入文件夹名“trunck”
 D．填写“创建日志”
 
E．认证：输入用户名称和密码：
 用户名：p1_a1
 密码：p1_a1
 
F．创建成功
 按照此方法在“trunck”根目录下创建“需求分析、RTM文档、测试报告、代码文档、概设文档、详设文档、用例文档”7个文件夹。
 
在代码文档里面添加5个代码程序
 
A．将5个代码程序 选中后直接拖入“代码文档”中；
 B．点击“复制项到此”
 
添加成功。
 C．同样的方法，添加另外4个文件：min.c；mul.c；div.c；main.c；
 
添加完成。
 检出添加的文件夹及文件
 A．A.在D盘根目录下建立文件夹“worksp”
 
备注：此文件夹为空文件夹
 B．空白处点击“点击右键”
 
C．点击“SVN检出（K）….”
 
D．检出完成
 
备注：检出成功
 E．打开“wroksp”文件夹，出现“trunck”文件夹
 
F．打开“trunckt”文件
 
G．打开“代码文档”
 
备注：版本库浏览器里面的文件全部被检出，检出成功（如图所示）。
 
四、如何对该项目入基线
 第一步：打开D盘文件夹“worksp”找到“trunck”文件夹。
 第二步：选中“trunck”文件夹点击“右键”
 选择“分支/标记”
 
点击“确定”
 
第三步：在D盘根目录中选择“worksp”文件夹，点击“右键”选择“提交更新”
 
第四步：查看入基线是否成功，打开文件“worksp”
 
第五步：通过“版本浏览器”进行查看；
 
入基线成功。
 
五、分支文件进行合并
 第一步：在D盘根目录下创建两个文件夹“group1”、“group2”
 
第二步：用入基线的操作的方式，创建两个分支“branch1”、“branch2”
 
“group1”文件夹
 
“group2”文件夹
 
第二步：
 “group1”–“branch1”中“代码文档”内添加文件：chengfang.c
 “group2”—“branch2”中“代码文档”内添加文件：kaifang.c
 以添加“chengfang.c”为例：
 A．添加文件“chengfang.c”
 
B．选中“chengfang.c”文件点击“增加”
 
C．点击“增加”后
 
D．选中后“右键”点击“SVN提交”：
 
备注：未提交前“代码文档”显示为：
 
E．点击确定、添加成功
 
添加“kaifang.c”
 同样的方法进行添加
 添加成功后：
 
校验是否添加成功
 方法1：点击“worksp”进行更新，检查“branch1”、“branch2”中是否存在添加的两个文件；
 方法2： 版本浏览器查看
 
将“chengfang.c”和“kaifang.c”进行合并；
 A．“合并”前“trunck”里面如图
 
B．“合并”步骤：
 a.点击 “worksp”中的“trunck”点击“右键”
 
将“kaifang.c”合并
 
同样的方法对“branch1”中的“changfang.c”进行合并
 C．对“trunck”文件右键进行“提交”
 
D．查看合并是否成功
 方法1：“worksp”----“trunck”----“代码文档”查看
 
方法二：版本浏览器进行查看
 
六、分支冲突的解决
 在D盘根目录下创建2个文件夹分别为“dev1”、“dev2”
 
分别点击该文件夹的“右键”—“检出”—“trunck”
 
针对“dev1”里面的“代码文档”
 
进行修改添加“除数不能为0”；
 
修改后“保存”
 
“右键”点击“提交”
 
针对“dev2”—“代码文档”里面
 
进行修改添加“除数不能为0”；
 
修改后“保存”
 
“右键”进行提交“提交”
 
提交失败，起冲突。
 解决冲突
 A．对“dev2”中的“div.c”文件进行更新
 
B．更新完成后打开该文件：
 
C．对该程序进行修改，完成后对该文件进行“提交”
 
D．然后对“代码文档” —“右键”进行“更新”
 
E．查看冲突是否解决
 方法1：“worksp”—“trunck”—“代码文档”—“dev.c”
 方法2： 版本浏览器进行查看。
 
第十二章 系统测试
 概念：
 1什么事系统测试
 在对软件，硬件，外设，第三方软件，数据，人员，环境，代码，数据库考虑了的情况下，尽可能的模拟用户的使用环境下所做的测试
 另一答案：将已集成的软件系统，作为整个基于计算机系统的一个元素，与计算机硬件、外设、数据、支撑软件、人员等其他元素结合在一起，在实际运行环境下，对计算机系统进行的一系列测试活动
 注：代码称之为数据流，数据称之为信息流
 2系统测试在做什么工作
 验证系统是否满足需求规格说明书SRS
 验证是都满足隐性需求
 验证系统可以支付用户使用
 3系统测试的工作过程
 系统测试个阶段（计划，设计，实现，执行）的输入，输出，入口准则，出口准则
 4系统测试的对象：对整个产品（整个软件系统）
 5系统测试依据什么：SRS
 6系统：整体性、独立性、功能性、环境适应性
 7软件系统：包括支撑软件、数据、硬件、外设、人员及目标软件
 分类：
 功能测试：（Function testing中国 Feature testing国际）
 根据产品的功能是否满足用户需求
 工作内容 1业务，业务流是否正确实现
 2功能点是否正确实现
 3输入是否正确实现
 4输出是否正确实现
 测试工具：QTP（使用 B/S和C/S软件），LR（C/S软件），RIA TEST(针对Flash，Flex软件，用Flash编写），Selenium(firefox的插件)， IBM Rational Robot
 工作原理：模拟用户操作
 性能测试：（Sercarity testing）
 定义：验证产品是否满足性能需求
 常用测试点：响应时间和资源性能(CPU,I/O,内存，信道，传输速度)
 例：1.先确认记事本的性能需求（加入50万行内正常）
 2.先输入50万行文本（造场景）
 3.监控所占用的系统资源
 4.报告，提出改进意见
 注：1内存和硬盘的区别
 内存临时存储，电脑关机，信息就消失，内存容量速度快
 硬盘是靠执行存储，断电后也能保存数据，硬盘存储量大，速度慢
 2信道与宽带有关，与访问人数有关
 3吞吐量，每个时间单元的处理数据
 4测试方法：压力测试（stres stesting）短时间
 负载测试（load testing）正常负荷下，长时间运行
 容量测试（volume testing）最大访问量
 5高级录制能找到每个按钮的控件名，低级录制只能找到鼠标移动到的位置
 6没有需求的性能测试无法进行
 测试工具：LR，Webload ， Jmeter（开源软件，JAVA编写），Silk Performance
 工作原理：（B或者C端通过传送协议与S进行通信）
 录制协议，模拟多个永和传送协议（可以几句到以点，同时发给S也可以迭代发送给S）通过IP骑在变成不通的IP地址，突显多线程并发操作
 安全性测试：（Security Testing）
 
定义：验证产品在系统的内部的安全保护机制和系统外对入侵的防护能力
 考虑内容：1内部包括身份验证，权限，数据的完整一致，数据的保密性（DB中有些数据加密保存）
 2外部，病毒木马，未授权攻击，传输数据安全（传输过程中密码加密，通过HTTP协议传输）
 注：病毒与木马的区别：病毒主要是针对计算机程序的破坏，木马主要用于盗取计算机内的相关机密
 测试工具：MBSA(Microsoft Basehne Sercurity Analyzer),IBM Rational Appscan,X-scan(某黑客组织开发)
 工作原理：监控服务器或客户端那些端口应该被禁止
 安装测试
 定义：产品的安装过程和结果进行测试
 工作内容：根据软件的测试特性列表，软件安装，配置文档，设计安装过程的测试用例
 包括安装前
 安装后
 安装过程中
 安装时异常终止包括：进程终止（操作系统未关闭）断电模式，断网
 测试对象：安装文件、安装系统、安装文档、配置项
 安装后检查：1件是否产生，是否正确
 2否按人工修改的方式安装
 3装日志是否记录正确
 4否有临时目录，垃圾文件，是否清理掉冷补丁(需要关闭系统的补丁) 热补丁(多数网站补丁属于热补丁)
 GUI测试（Graphical user interface）
 又称为用户界面测试，接口测试
 注：GUI测试无法脱离功能测试而独立存在，否则只能测试外观，布局，无法测试行为
 测试内容：对界面元素进行测试，
 验证产品界面是否与SRS设计一致（包括布局，外观，配色，元素行为，元素功能）
 验证界面元素的交互是否正确
 界面元素包括：整体界面，独立元素组合，独立元素
 思路：先找整体界面，再测独立元素组合和独立元素（据对用户的影响严重程度不同）
 测试步骤：对完整的界面进行测试 （包括布局，功能组合，页面展现的外观）
 组合元素（包括拆分，组合行为，独立行为，展现，外观）
 独立元素（包括外观，为）
 工具：所有做功能测试的工具都可以做GUI的测试
 可用性测试（Usability testing）
 又称易用性测试
 
定义：验证用户管理和使用软件的容易程度
 工作内容：是否符合用户的实际习惯
 是否符合用户的特殊要求
 操作是否合理，简单，容易理解
 是否有明确的提示可以指导下一步操作 
 异常性测试
 系统允许的操作
 健壮性测试，系统不允许的操作
 文档测试
 说明书，与易用性一起做
 备份测试
 主要测试备份策略
 目的：为了解决风险
 备份策略包括：本地备份，异地热备份（实时备份），本地异步备份，异地异步备份
 还原策略：（又称恢复策略）
 配置测试
 又称兼容性测试
 包括软件配置和硬件配置，验证系统都可以使用那些软硬件配置
 网络测试
 
主要测试网络中的协议和数据
 工作内容：1网络协议测试（协议是否正确）
 2网络传输是否正确（不同网络是否正常）
 3网络结果测试
 
第十三章 用例设计
 等价类
 定义：1、等价：如果多个输入在程序中处理方式（路径）相同，则认为这些输入是等价的，测试一个即可。（前提：测试不能穷举）
 2、输入：分为两类，有效输入（可以保存）、无效输入（不可保存）
 3、结合：有效等价类、无效等价类
 满足规则：只需寻找一个全部满足规则的（有效等价类）
 不满足规则：需分开，每条不满足条件的举出一个，方便定位错误（无效等价类）
 规则的几种情况：
 1 若规则是布尔式的
 有效、无效分别取一个 一个真，一个假
 2. 若规则是区
 有效的取一个 无效的，在小于区间的取一个，大于区间的取一个，空或零取一个
 3. 规则是集合：
 有效取一个 无效的在集合外取一个
 4. 规则是必须满足的一个条件：
 对无效，要细分无效（先试试其他有效等价类，再试试全部等价类全都不满足）
 例：邮箱注册，注册名只能以小写字母开头，设计无效等价类时，先试试其他有效等价类，如大写字母、数字等，再试试其他有效全部都不满足的情况
 有效等价类：程序规格说明有意义，合理的输入数据
 无效等价类：程序规格说明无意义，不合理的输入数据
 
ASCII码
 7位 表示27=128个字符 每个字符存储占用1个字节
 分类：不可见字符
 控制字符：LF（换行）、CR（回车）
 通信字符
 NULL（空）
 可见字符
 空格
 数字
 字母（大写、小写）
 符号
 练习
 1.1年龄注册
 注册页面要求输入年龄，限制：1到150期间的正整数
 1、需求分析—找出全部的输入条件
 1）、正整数
 2）、[1,150]
 注意：分解的过程中，条件之间不用组合（完全独立），在设计有效用例输入的时候再考虑组合（一对多）
 2、绘制等价类表格
 条件 有效等价类 有效编号 无效等价类 无效编号
 正整数 >1 A01 数字 小数 B01
 负数 B02
 0 B03
 非数字 空（NULL） B04
 空格 B05
 字母 B06
 符号 B07
 [1,150] [1,150] A02 <1 B08
 >150 B09
 
3、设计测试用例输入
 原则：有效输入—尽可能多去覆盖有效等价类 （一对多）
 无效输入—只能覆盖一个无效等价类 （一对一）
 目的：A、出现问题可以更好的去定位
 B、有可能第一个无效处理后，后续无效值被漏测
 输入序号 有效输入值 覆盖有效等价类 输入序号 无效输入值 覆盖无效等价类
 1 100 A01、A02 2 1.8 B01
 3 -9 B02
 4 0 B03、B08
 5 空（NULL） B04
 6 空格 B05
 7 W B06
 8 @ B07
 9 200 B09
 1.2.年龄注册
 某保险公司注册页面要求输入年龄，限制：1到150期间的正整数，其中：
 [1,10] 适用的费率 10%
 [11,50] 适用的费率 30%
 [51,150] 适用的费率 80%
 
条件 有效等价类 有效编号 无效等价类 无效编号
 正整数 >1 A01 数字 小数 B01
 负数 B02
 0 B03
 非数字 空（NULL） B04
 空格 B05
 字母 B06
 符号 B07
 [1,150] [1,10] A02 <1 B08
 [11,50] A03 >150 
 [51,150] A04
 
输入序号 有效输入值 覆盖有效等价类 输入序号 无效输入值 覆盖无效等价类
 1 5 A01、A02 4 1.8 B01
 2 30 A01、A03 5 -9 B02
 3 100 A01、A04 6 0 B03、B08
 7 空（NULL） B04
 8 空格 B05
 9 W B06
 10 @ B07
 11 200 B09
 1.3.扩充
 考虑全角和半角问题（GB231）
 其中，半角占1个字节
 全角占2个字节
 
字符集
 1、ASCII
 2、GB2312 -> GB18030 一个汉字占2个字节
 BIG5（繁体）
 3、ISO Unicode (UTF-16) -> UTF-8（变长存储） 一个汉字可能占3个字节
 条件 有效等价类 有效编号 无效等价类 无效编号
 正整数 >1(半角) A01
 
			0	B03
>1（全角）	A02	半角字符	空（NULL）	B04
			空格	B05
			字母	B06
			符号	B07
		全角字符	空格	B08
			字母	B09
			符号	B10
		汉字
 
(字符集) GB-2312 B11
 BIG-5 B12
 [1,150] [1,150] A03 <1 B13
 >150 B14
 
分解粒度：根据功能的重要性决定（用例图----执行者角色，考虑用户的关注功能）
 根据成本、时间决定
 取消负数、小数的原因：
 1、前提：在编辑框内输入年龄，程序在接收编辑框的内容时，一般以字符（或字符串）的形式接收，再根据需要进行类型转换，如年龄，需要转换为整型
 2、小数中的“小数点”和负数中的“负号”都认为是符号，不允许保存
 边界值
 取值（5个）：上点、内点、离点
 1、上点、内点取值与区间的开闭无关
 2、离点和上点互为有效
 作用：（有序、有范围）等价类的补充
 补充：考虑数据类型的边界
 如 int 类型 占4个字节 即 32bit 取值范围[-231, 231-1]
 上点：边界上的点
 内点：区间内的点
 离点：离边界值最近且与上点不属于同一等价类的点（对于小数，没有离点，不用取）
 规则的几种情况：
 
规则是区间：
 按上点、内点、离点取
规则是取值的个数：
 取最小、最大、中间个数
 3.规则是a~z序列：
 取a、z
 4.规则是集合：
 取一个集合内的，取一个集合外的
 (0,20)上点是0,20 离点是1,19 [0,20]上点是0,20 离点是-1,21
 若规则是下拉菜单：建议每个下拉值都选择一个
 2.1.年龄
 条件 有效等价类 有效边界值 有效编号 无效等价类 无效边界值 无效编号
 正整数 >=1 上点：1 A01 数字 小数 B01
 内点：100 A02 负数 B02
 离点：0 0 B03
 非数字 空（NULL） B04
 空格 B05
 大写字母 上点：A B06
 上点：Z 
 内点：M 
 符号 离点：@ B07
 离点：[ 
 [1,150] [1,150] 上点：1 A03 离点： 0 B08
 上点：150 A04 离点： 151 B09
 内点：100 A05 
 有效用例输入：1 、100、150
 2.2.用户名注册
 
1、测试需求分析
 1、内容：字母、数字、
 2、长度：[6,18]
 3、约束：字母开头
 字母或数字结尾
 不允许重名
 不允许使用保留字
 自动去除首尾空格
 2、等价类划分
 条件 有效等价类 有效编号 无效等价类 无效编号
 内容 字母 大写字母 A01 符号(除下划线) B01
 小写字母 A02 NULL(空) B02
 数字 [0,9] A03 空格 B03
 下划线 下划线 A04 GB2312 B04
 BIG5 B05
 长度 [6,18] [6,18] A05 <6 B06
 >18 B07
 约束 字母开头 大写字母开头 A06 数字开头 B08
 小写字母开头 A07 下划线开头 B09
 符号(非下划线)开头 B10
 汉字开头 B11
 字母或数字结尾 大写字母结尾 A08 下划线结尾 B12
 小写字母结尾 A09 符号(非下划线)结尾 B13
 数字结尾 A10 汉字结尾 B13
 不允许重名 不重名 A11 重名 B15
 去除首尾空格 A12 
 不允许使用保留字 不使用 A13 使用保留字 B16
 3、用例设计
 序号 有效输入 有效边界值 序号 无效输入 无效边界值
 1 (当前系统无AAb_4)
 AAbb_4 A01、A02、A04、A03
 A05、A06、A10
 A11、A13 5 abc@a B01
 2 (当前系统无AAb_4)
 aAbcvb_A A01、A02、A04、A03
 A05、A07、A08
 A11、A13 ………… 
 3 (当前系统无AAb_4)
 aA555b_b A01、A02、A04、A03
 A05、A07、A09
 A11、A13 (当前系统存在aaf5bc)
 (空格)aaf5bc(空格) B15
 4 (当前系统无aaf5bc)
 (空格)aaf5bc(空格) A12 Administrator B16
 2.3.变量命名
 在某一版的编程语言中对变量名称规格作如下规定：变量名称是由字母开头的，后跟字母或者数字的任意组合构成，并且区分字母大小写。编译器能够区分的有效字符数为8个，并且变量名称必须先声明，后使用，在同一声明语句中，变量名称至少必须有一个。
 1、测试需求分析
 内容：字母、数字
 长度：[1,8]
 约束：字母开头
 大小写敏感
 先声明后使用
 变量的个数[1,?] （需要和需求人员沟通）
 在同一作用域中不允许重名
 不能使用关键字
 2、等价类划分
 3、确定边界值
 4、设计用例输入
 2.4.进销存价格
 
代码实现：
 if (isNumberString(document.form2.tichen.value,“1234567890.”)!=1)
 {
 alert(“价格只能为数字!”);
 return false;
 }
 
根据代码的实现，价格编辑框只接受键盘的“数字键”和“小数点”共11个字符
 
等价类
 条件 有效等价类 无效等价类
 内容 数字 字母
 字母、符号处理方式（路径）相同，认为都是等价的
 小数点 
 约束 小数点最多有1个 >1个小数点
 
2.5.Windows文件命名
 目录 目录长度 文件最大长度 目录+文件最大长度
 C:\ 3 255个 = 258
 C:\ABCD 7 251个 =258
 C:\ABCD\AAAA 12 246个 =258
 
根目录： 255
 非根目录： 254 （文件夹最小长度为1）
 
1、测试需求分析
 内容：非“/😗?"<>|”的字符
 长度： 根目录： 255
 非根目录： 254 （文件夹最小长度为1）
 约束：同目录下不能重名（去除首尾空格）
 不同扩展名使用不同的图标
 不能为空
 总结
 1、适用范围：针对程序的输入
 2、使用步骤
 1）、测试需求分析，找出全部条件（显示、隐士）（条件之间不能交叉或者组合，到设计用例的时候再考虑多条件的组合）
 2）、划分等价类
 划分依据：相同的处理方式（路径）
 分类：有效等价类、无效等价类
 3）、使用边界值补充（有序、有范围的）等价类
 内容：上点、离点、内点
 要求：上点、内点与区间开闭无关，离点和上点互为有效
 分类：将边界值分为有效边界和无效边界，填入等价类表格
 4）、对每个等价类进行唯一的编号
 5）、设计用例的输入
 原则：有效等价类，一对多
 无效等价类，一对一
 3、优点：对输入的考虑充分
 4、缺点：如果不清楚系统的实现方式，造成大量的冗余用例（黑盒方法共有）
 对于多输入的组合不太适宜
 规则的几种情况：
 1 .若规则是布尔式的
 有效、无效分别取一个 一个真，一个假
 2. 若规则是区间
 有效的取一个 无效的，在小于区间的取一个，大于区间的取一个，空或零取一个
 3. 规则是集合：
 有效取一个 无效的在集合外取一个
 4. 规则是必须满足的一个条件：
 对无效，要细分无效（先试试其他有效等价类，再试试全部等价类全都不满足）
 例：邮箱注册，注册名只能以小写字母开头，设计无效等价类时，先试试其他有效等价类，如大写字母、数字等，再试试其他有效全部都不满足的情况
 有效等价类：程序规格说明有意义，合理的输入数据
 无效等价类：程序规格说明无意义，不合理的输入数据
 边界值
 上点：边界上的点
 内点：区间内的点
 离点：离边界值最近且与上点不属于同一等价类的点（对于小数，没有离点，不用取）
 规则的几种情况：
 
规则是区间：
 按上点、内点、离点取
规则是取值的个数：
 取最小、最大、中间个数
 3.规则是a~z序列：
 取a、z
 4.规则是集合：
 取一个集合内的，取一个集合外的
 (0,20)上点是0,20 离点是1,19 [0,20]上点是0,20 离点是-1,21
 若规则是下拉菜单：建议每个下拉值都选择一个
 
第十四章 系统测试执行
 测试用例
 编号组成： 项目名—测试阶段—需求—用例
 测试环境搭建文档：
 1.为日后回归测试等搭建环境做指导
 2.刚开始写完后，评审，防止日后因环境搭建而引起测试时的问题
 3.可为日后上线的文档做参考
 4.可以做自动化步骤的参考
 5.项目留存
 用例执行：
 1.严格按照用例步骤，执行用例
 2.发现结果与预期结果不一致：
 a)重复步骤，重现发现的问题
 b)找同类型的数据，重新执行用例
 c)定位发现问题的步骤 （每执行一步都要做记录）
 3.提交BUG （先确认不是重复BUG）
 填BUG报告：
 (一)若开发返回”不可重现的BUG”，可能原因：
 1.开发步骤不对
 2.测试环境和开发环境不同
 3.出现时有概率的，或者其他原因导致，不是每次重现 （环境、概率）
 (二)合并BUG的原则
 1）同样的原因产生的BUG可以合并
 2）与开发沟通后如果修改一处就可以修改一些BUG可以合并
 3）当BUG之间有制约关系，BUG可以合并
 (三)补充 为什么.TXT文件中报春”联通”重新打开后会有乱码
 文件保存格式默认为ASCII码,但恰好”联通”是以EF开头的,保存时误认为UFT-8格式,导致重新打开时歘先乱码
 (四)书写测试用例应该注意一下几点
 1)测试输入数据必须是唯一的，并且明确的
 2）步骤要完整，按照步骤可以测试测试点和预期结果，建议每个步骤后面都有预期结果，步骤要编号
 3）结果要和需求规格说明书完全一致，如果SRS没有明确结果，需要产品人员补充和定义
 4）无效等价类不能合并
 
第十五章 QC（Quality Center）
 QC (Quality Control)质量控制
 QC（前身TD Test Director与QTP、LoadRunner同是MI公司开发）
 QC是B/S架构的 
 QC 9.0支持JBoss、IIS两款服务器支持SQL Server和Oracle两个数据库
 QC默认端口是8080 数据库连接端口是1433
 Quality Center QC前台
 Site Administration QC后台 
 Add-Ins Page QC插件 
 Qcsiteadmin_db 是保存后台数据的 而前台中项目的数据，是单独保存在另一个数据库中
 QC预置5个用户组，只能查看，不能修改权限
 Developer Project Manger QATester TDAdmin Viewer
 外部测试人员，只有Defects Module权限，只执行测试，报BUG
 组内测试人员，有QC所有模块权限
 QC后台：
 Site Project 设置项目 
 Create Domain 建立区域 
 Create Project 建立项目 
 Create an empty Project 建立一个空项目 
 Create project by copying data from an existing project 
 从已有项目拷贝创建一个新项目
 
Create a project by importing data from an exported Quality Center project file
 从一个已有项目的导出文件创建一个新项目
 
QC前台：
 TOOLS下的Customize…选项
 Customize Project Entities 设置输入项 可添加新选项
 Customize Project Lists 项目列表 可设置下拉列表中的项
 Requirements 需求模块
 菜单栏下Requirements菜单项
 Covert to Tests 将需求转换成测试用例 用于比较系统的测试
 Generate Test…将需求生成测试执行 用于临时的测试
 菜单栏中View菜单项
 Expend 扩展，全部展开
 Collapse 收起
 Numeration 排序
 Full Coverage 完全覆盖（考虑测试覆盖率）
 Requirements Tree 需求树结构 用于项目经理等管理者
 Requirements Grid 需求表结构 用于浏览者(可用Favorites)
 Requirements Coverage 需求覆盖率 用于测试人员
 Coverage Analysis 需求分析视图 用于测试管理者
 菜单栏中Analysis菜单项
 Reports选项下
 Standard Requirements Report 标准需求表 用于评审
 Tabular Requirements 概要表 用于产品经理
 Requirements with Coverage Tests 带覆盖率的表 用于测试经理
 Requirements with Coverage Tests and Steps 带步骤的 用于测试用例评审
 Requirements with Linked Defects 带缺陷的 用于生成测试报告
 Graphs选项下
 Progress 给项目经理
 Requirements Coverage 给测试经理
 Trend 给BOSS
 工具条中Set filter/Sort 过滤器 用*做通配符
 View Order 结果排序 同级才能排序
 双击一条需求 Requirement Details 需求详细信息 
 Coverage 覆盖率 
 Linked Defects 连接缺陷 
 需求的状态:not covered not run not complete passed failed
 Test Plan 测试用例模块 
 点击一条测试用例，右侧在Design Steps标签页下
 Call to Test 调用测试用例 只能调用到一个参数 可用于回归测试
 Generate Script 生成脚本 
 Insert Parameter 添加参数 
 Renumber Steps 重新写序号 （不影响步骤的内容）
 菜单栏中Tests菜单项
 Flag for Follow up 标记一个执行 
 Mark as Template Test 标记成为模板用例 
 菜单栏下View菜单项
 Trace Changes 变更跟踪警告 
 Analysis中所有报表均是测试工程师用
 Test Lab 测试执行模块 
 需要添加一个集，用例才能被添加到集
 菜单栏下Test Sets菜单项
 Reset Test Set 重置测试集 用于测试回归，所有状态均为No Run
 Purge Runs 清理执行的状态 清理执行的状态，上个是全部，此为条件式
 状态优先级：
 Failed > Not Complete或N/A或No Run > Passed
 Trace Changes
 在Test Plan中，跟踪的是需求Requirements
 在Test Lab中，跟踪的是缺陷Defects状态时”Fixed”时
 在Defects中，跟踪的是Test Lab成功运行时
 其中红色! 表示未看过 灰色表示已看过
 QC中，Defects只能连接自己，不能连接其他而 Requirements、Test Plan、Test Lab可以连接其他任何一个，不能连接自己，所以，Defects单独划出一个模块
 权限设置：
 需求人员：写需求
 测试人员：用例、BUG、执行用例
 开发人员：改BUG
 项目经理：所有权限
 当产生纠纷时，在设置中增加一个状态，在Defects中的Description选项中的Comments下添加分歧的描述、原因等等，分配给解决纠纷的人，只有被分配的人可以修改状态，其他人不能更改
 
变更控制：
 能否变更 用Reviewed（评审）字段，将之设置成必填项，默认值是Not Reviewed
 设置权限中，不给需求人员修改Reviewed的权限
 
第十六章 PYTHON
 Python 是面向过程、面向对象，跨平台的高级脚本语言。 是解释性语言，执行源代码，提供丰富的库，支持多线，多进程，网络编程，可以支持C/C++的代码，可以测试C/C++和Python开发的单元产品，Python越来越多的成为开源测试自动化工具的首选语言
 Python的安装
 1.安装之前，先退出杀毒软件
 2.安装 缺省安装
 3.完毕后，配置系统环境变量 path （把解释器pathon.exe所在目录加入path）
 Python的集成环境：
 1.Python文件夹下IDLE
 2.新建文件 New Window
 3.保存（用Save As…后缀.py）
 4.运行方式：
 a)Run Module (若提示”Socket Error”是因为杀毒软件引起的错误)
 b)命令行方式 在DOS下，进入文件目录，输入命令python hello.py
 python可以用#来做注释
 输入中文时在前面加#coding:gbk
 在GUI界面下 若不加保存时会报警告
 
补充知识：
 DOS命令：
 切换盘符 盘符名：
 进入文件夹 cd 文件夹名\文件夹名…
 退到根目录 cd
 退出一层目录 cd…
 数据类型：
 Str字符型字符串（可以用单引号、双引号） Int 整形 long长整形 float浮点型 bool（布尔型）：True真/False假(首字母大写，不用加引号)
 运算符：
 算术运算符： + — * /
 逻辑运算符： and or not
 比较运算符： 相等 = = 不等于 ！= < > <= >=
 缩进：
 在行首用空格或者Tab 缩进相当于C语言中的{ } 表示对应一段完整的逻辑
 一般用TAB 因为一段代码中不能同时使用两种缩进方式，默认是TAB
 控制语句：
 IF条件
 1 if (条件1):
 处理语句1
 处理语句2
 处理语句3
 
语法解释：满足条件1执行语句1,2,3，不满足条件1执行语句
 2 if (条件1):
 处理语句1
 处理语句2
 elif
 处理语句3
 
语法解释：满足条件1执行语句1,2不满足条件1，执行语句3
 3 （1） if (条件1): （2）if (条件1):
 处理语句1 处理语句1
 处理语句2 处理语句2
 elif (条件2): else:
 处理语句3 if（条件2）：
 处理语句4 处理语句3
 … 处理语句4
 else: else:
 处理语句5 处理语句5
 处理语句6 处理语句6
 … 。。。。
 处理语句7 处理语句7
 
语法解释：满足条件1执行语句1,2,7，不满足条件1，满足条件2，执行语句3,4,7，不满足条件1,2，执行语句5,6,7
 注：条件中可以用逻辑运算符 比较运算符
 条件后面要加“；”
 WHILE循环
 while (条件):
 处理语句1
 处理语句2
 …
 处理语句3
 
语法解释:条件为真(满足条件)执行语句1,2,在判断条件,还满足条件的话,还执行1,2直到不满足条件,执行语句3
 
while (条件1):
 if (条件2):
 处理语句1
 处理语句2
 …
 elif (条件3):
 处理语句3
 处理语句4
 …
 else:
 处理语句5
 处理语句6
 …
 处理语句7
 
语法解释：条件1为真，判断条件2，条件2为真，执行语句1,2，在判断条件1，当条件1 为假，执行7
 条件1为真，判断条件2，条件2为假，，在判断条件3，当条件3为真，执行语句3,4，判断条件1，当条件1为假，执行语句7
 条件1为真，判断条件2，条件2为假，，在判断条件3，当条件3为假，执行语句5,6，判断条件1，当条件1为假，执行语句7
 FOR循环
 for 变量 in 集合函数: 注：range是一个集合函数
 处理语句1
 处理语句2
 …
 处理语句3
 
语法解释：变量值在这个集合函数之内执行语句1,2，循环执行1,2，直到变量值不在集合函数范围内，执行语句3
 例题：for I in range(1,7); #循环了6次
 print”sjsddsj”
 BREAK \ CONTINUE
 break \ continue 只能用在循环语句中（for ,while)。
 break:跳出循环，执行循环体外的第一条语句，无论循环体内还有多少语句
 continue:跳过循环体内的语句去执行循环条件的条件判断
 
	while (条件1):
		  处理语句1
        处理语句2
			if (条件2):
    			处理语句3
   			break
		 	else:
    			处理语句4
    			continue
 
处理语句5
 处理语句6
 
语法解释：条件1为真,条件2为真,执行1,2,3,6
 条件1为真,条件2为假,执行语句1,2,4,1,2,4执行到条件1为假后，执行语句6
 条件1为假，执行语句6
 这个程序没有执行过语句5
 
程序举例：
 a=1
 i=1
 while (a<=10):
 a=a+1
 if (a==10):
 break
 else:
 continue
 i=i+1
 print a
 print i
 运行结果：a=10 i=1
 函数
 1 type () 查看变量的数据类型
 
2 Raw-input (“提示信息”) 输入函数（从界面输入的均是字符型）
 
3 isdigit() 判断变量a是否是纯数字
 
4 int() 强制转换类型
 
5 Print输出函数
 6 range 集合函数
 Range(起始值，结束值，步长)求从开始值到小于结束值，并且以步长为某一个值的等差数列
 
定义：
 Def 函数名（形参列表）：
 函数体语句
 Return 返回值 #若没有返回值,不加这句
 程序举例：Def fun(a,b,c):
 Print a,b,c
 Return a+b+c
 调用：
 有返回值
 变量名=函数名（实参列表）
 例：M=fun(‘3’,’4’,’asd’)
 无返回值
 函数名(实参列表)
 
第十七章 单元测试
 单元测试概念：
 1什么是单元测试：对软件的基本组成单元所作的测试（面向过程（一组函数或一个函数）面向对象（类中得方法））
 2语句：真正的处理语句才算是语句（判断框中的语句不算）。
 判定：流程图中的菱形框；
 判定数：流程图中菱形框的个数；
 分支：判定的真或假；
 分支数：判定数2；
 条件：判定中关系（比较）运算符；
 条件数：判定中关系（比较）运算符的个数；
 条件结果数：条件数2（每个条件有真、假两个取值）。
 3单元测试的目的：与LLD是否符合；与SRS是否符合；编程是否存在问题。
 4关注重点包括：单元接口（类型，顺序，长度，参数个数）；局部数据结构；独立路径；边界值；出错处理。
 5单元测试环境包括：被测单元、驱动单元（把被测单元驱动起来，完成被测单元的调用）、桩单元（被测单元的调用的替代品，替代输入与输出），测试用例（测试数据）。
 6驱动单元的四个职责1）接收侧四数据包含测试用例输入好预期输出
 2）吧测试用例输入传送给要测试的单元
 3）将被测单元的实际输出和预期输出进行比较，得到测试结果
 4）将测试结果输出到指定位置
 7辅助技术：评估，框架应用
 8桩单元：通过一组输入和输出模拟被替代单元的行为
 单元测试静态测试：
 1.从详设的评审开始介入
 2.详设评审、编码完成后，作代码的静态检查
 （可以用专门的检查工具 如：PC_lint）
 3.代码的交叉走读 （要制定标准，标准越清晰，任务被分配者越有目标，工作越细）
 单元测试动态测试：
 1写用例之前，先确定覆盖率标准
 2写用例
 3搭建测试环境
 4执行
 5测试报告
 测试评价准则：
 系统测试评价准则：需求覆盖率（=至少被用例覆盖一次的需求项数/测试需求分析列表中的需求项数）。
 单元测试评价准则：逻辑覆盖率（=item至少被评估一次的次数/item总数）【这是一个总公式】。
 逻辑覆盖率
 逻辑覆盖率包括以下几种：语句覆盖率、分支覆盖率、条件覆盖率、分支条件覆盖率、路径覆盖率。【掌握计算公式、每种覆盖率的问题】
 1语句覆盖率=语句至少被执行一次的次数/语句总数。
 问题：有可能语句覆盖率为100%，有可能发现逻辑运算符的问题
 2判定覆盖率=每个分支取值至少被执行一次的次数/分支总数（判定数2）
 问题：当分支覆盖率为100%时，可能不能发现关系运算符的缺陷
 3条件覆盖率=每个条件取值至少被执行一次的次数/条件结果总数（条件数2）
 问题：条件覆盖率为100%时，有可能某个分支没有执行到，若该分支有缺陷，可能会遗漏。
 4分支覆盖率=（每个分支至少被执行一次的次数+每个条件取值至少被执行一次的次数）/（分支总数+条件结果数）
 问题：分支条件覆盖率为100%时，有可能漏路径，若该路径上有缺陷，可能遗漏
 5路径覆盖率=每个路径至少被执行一次的次数/路径总数
 问题：路径覆盖率为100%时，条件覆盖率可能不为100%
 注：独立路径覆盖，若路径覆盖率100%则条件、语句、分支覆盖率均100%
 路径一定要从始点到终点
 可以用软件来计算路径覆盖率 如BullseyeCoverage
 
单元测试策略
 孤立、自顶向下、自底向下。
 ⑴ 孤立测试
 缺点：需要大量的桩和驱动
 优点：改方法是最简单最容易操作的 ，可以达到高的结构覆盖率，该方法是纯粹的单元测试
 方法：不考虑每个模块与其他模块之间的关系，为每个模块设计桩模块和驱动模块，每个模块进行独立的单元测试
 【例1】
 对象 驱动 桩
 A Driver-A Stub-B
 B Driver-B Stub-C
 C Driver-C X
 
【例2】
 对象 驱动 桩
 A Driver-A Stub-B,C
 B Driver-B Stub-D
 C Driver-C Stub-E
 D Driver-D X
 E Driver-E X
 
⑵自顶向下的单元测试策略
 方法：先对最顶层的单元进行测试，把顶层所调用的单元做成桩模块。其次，对第二层进行测试，使用上面已测试的单元做驱动模块。如此类推直到测试完所有模块。
 优点：可以节省驱动函数的开发工作量，测试效率高。
 缺点：随着被测单元一个一个被加入，测试过程将变得越来越复杂，并且开发和维护的成本将增加。
 【例1】
 对象 驱动 桩
 A Driver-A Stub-B
 B Driver-A Stub-C
 C Driver-A Stub-D
 D Driver-A X
 
【例2】
 对象 驱动 桩
 A Driver-A Stub-B,C,D
 B Driver-A Stub-E,C,D
 C Driver-A Stub-E,D
 D Driver-A Stub-F,E
 E Driver-A Stub-F
 F Driver-A X
 
【例3】
 对象 驱动 桩
 A Driver-A Stub-B,C
 B Driver-A Stub-C,D
 C Driver-A Stub-E,D
 D Driver-A Stub-F,E
 E Driver-A Stub-F
 F Driver-A Stub-G,H
 G Driver-A Stub-H
 H Driver-A X
 
a. 看被测函数下边有没有调用，如果被调用则打一个桩
 b. 假如曾经被测过的函数的时候，这些函数下边是否有调用，而那些调用是否也被测过，如果没有被测过，也需要打桩
 c. 只要驱动单元驱动的时候，所依赖的函数要run的时候，相关的调用都需要加入
 ⑶自底向上的单元测试方法
 方法：先对模块调用层次图上最低层的模块进行单元测试，模拟调用该模块的模块做驱动模块。然后再对上面一层做单元测试，用下面已被测试过的模块做桩模块。以此类推，直到测试完所有的模块
 优点：可以节省桩函数的开发工作量，测试效率较高。
 缺点：不是纯粹的单元测试，底层函数的测试质量对上层函数的测试将产生很大的影响。
 对象 驱动 桩
 E Driver-E X
 C Driver-C X
 F Driver-F X
 B Driver-B X
 D Driver-D X
 A Driver-A X
 
如果桩难写，采用自底向上；如果驱动难写，采用自顶向下。
 打桩原则：1被测函数有没有调动，若有调动则打桩
 2加入曾经被测过的函数，这些函数是否有调动，这些调动是否被测过，都没有则打桩
 【例子】
 自底向下
 对象 驱动 桩
 F Driver-F X
 I Driver-I X
 J Driver-J X
 G Driver-G X
 H Driver-H X
 E Driver-E X
 C Driver-C X
 D Driver-D X
 B Driver-B X
 A Driver-A X
 自顶向下
 对象 驱动 桩
 A Driver-A Stub-B
 B Driver-A Stub-C,D
 C Driver-A Stub-E,D
 D Driver-A Stub-E
 E Driver-A Stub-F,G,H
 F Driver-A Stub-G,H
 G Driver-A Stub-I,H
 H Driver-A Stub-I,J
 I Driver-A Stub-J
 J Driver-A
 
单元测试用例设计（基本路径覆盖法）★ （面试）
 步骤：（所有的循环仅执行一次）
 1）画流程图
 2）根据流程图画出流图
 3）根据流图找出独立路径
 4）根据独立路径设计用例
 结点：表示一个或者多个无分支的语句
 边：表示处理流向
 分支：判定真假的语句
 区域：由结点和边构成的，域的个数等于独立路径的条数
 注：路径一定要从始点到终点
 复杂性计算 ：V（G）=E-N+2
 V ( G ) =P+1
 E：边，
 N：结点数量，
 P：条件结点的数量，
 V最好不要大于10
 程序控制流图
 1顺序结构
 2if结构
 3while循环结构
 4until重复结构
 5Case分支结构（swith结构）
 
单元测试执行
 单元测试执行的过程：
 单元计划—单元设计—单元测试用例脚本----单元测试执行
 1.搭建环境 引入googletest
 a)将googletest的include和lib两个文件夹复制到VS的项目文件夹下
 b)在Visual Studio中选择项目，属性，将include和lib导入
 c)引入googletest头文件
 #include “gtest/gtest.h”
 d)在main函数中初始化GTEST
 testing::InitGoogleTest(&argc,argv); 初始化google test
 RUN_ALL_TESTS(); 运行当前工程所有test
 2.加入被测代码
 将被测代码头文件引入
 3.新建测试代码
 新建一个文件，编写测试代码
 调用googletest宏
 TEST(测试套名字，测试用例名字)
 {
 ………
 }
 用断言函数（ASSERT、EXPECT）来判断预期结果与实际结果
 ASSERT：致命断言，若前一个执行失败，则不继续执行
 EXPECT：一般断言，前一个执行失败，继续执行
 系统测试中发现不了在单元测试中比较容易发现的问题，如内存泄露、算法缺陷
 补充：
 C语言中，用malloc申请内存，free释放内存
 C++中，用new申请内存，delete释放内存
 TDD（测试驱动开发）
 内存中的堆、栈
 编译器自动分配的内存是在栈中，栈会自动维护、清理
 手工分配的内存是在堆中，堆不会自动清理，需要手工释放，容易忽略造成内存泄露
 
单元测试框架
 
框架是一组为重用而设计的方法，单元测试框架包括junit\cppunit\phpunit\c#unit\pyunit
pyunit是 d:\py26\unittest.py
单元测试框架概念
 测试固件(test fixture)
 一组测试函数执行前或执行后要执行的语句。
 例如，void insertDB(chr sql[30])
 {
 //执行insert语句
 }
 若现在测试该函数，实际上每次测试之前都要建立数据库连接，测试完成之后都要断开断开数据库连接。
 建立连接和断开连接称之为测试固件。测试固件在框架如何体现：
 setUP(…) —表示测试函数执行之前要执行的语句，比如建立连接
 teardown(…) —表示测试函数执行之后要执行的语句，比如断开连接
 有没有测试固件，取决于被测函数在测试执行需要否
 
测试用例
 主要以测试函数为主，什么是测试函数？就是对被测单元完成测试的函数，类似于原始的驱动单元。
 在框架中一般来说要继承单元测试框架的TestCase。
 
测试套件
 装配测试用例的车间。
 在框架中一般来说使用TestSuite的addTest方法来进行装配，装配的就是测试用例，实际上装配的用例中的测试函数。
 
测试运行器
 加载测试套件，对套件中装配的测试函数的运行。
 在框架中一般来说使用TestRunner中的run方法来进行运行TestSuite。
 4. pyunit框架中有：
 unittest.py
 测试固件 -----》TestCase类中有setUp和tearDown有这两个方法
 测试用例 -----》TestCase类，在该类中写测试函数的方法 ？？？？
 测试套件 -----》通过TestSuite类中的addTest方法将测试用例中的测试函数加载
 测试运行器-----》通过TextTestRunner中的run方法将测试套件运行起来。
 5. 实例：
 见例子
 6. 使用pyunit单元测试步骤：
 1）import unittest
 2)继承unittest.TestCase构建自己的测试类
 3)在自己构建的测试类中，若对于测试函数有测试固件，则在setUp和tearDown中进行代码编写。否则跳到1）
 
第十八章 集成测试
 1什么是集成测试
 依据概要设计说明书，对软件组成的所有函数模块和子模块进行的测试
 2目的：检查软件是否符合概要设计说明书，是否符合需求
 3关注重点
 全局变量 组合功能（集成后的问题）单元接口（1穿越模块的数据是否会丢失，即做输入输出的的形参定义是否正确2全局数据结构是否被异常修改）
 4集成测试环境
 集成后的功能：单个功能都没有问题，组合在一起时否有问题，单个功能之间是否相互影响
 进程：是一个程序在计算机上的一次执行活动，当运行了一个程序就启动了一个进程，进程是操作系统进行资源分配的单位
 线程：是进行中的一个片段
 集成测试没有联系，不存在集成，联系时全局变量，全局变量可能是内存的一片区域，也可能是同一份文件，数组，堆栈，字段，记录，变量，队列，集成也需要考虑到性能匹配问题，网络集成
 5集成测试的依据：LLD
 6集成测试的对象：接口
 7集成测试策略：大爆炸集成测试，自顶向下，自底向上，三明治集成，基于集成，分层集成，基于功能集成，基于消息集成，基于进度的集成，基于风险的集成
 1）大爆炸集成测试
 方法：对每个模块分别进行单元测试，在吧所有单元组装在一起测试
 优点：从未投入模块间，子系统间角度节省时间，减少桩和驱动的开发，节省成本，方法简单
 
使用范围：小型项目，大型项目已经稳定，只有少量修改
 2）自顶向下集成测试
 
深度优先：在系树的根优先，根—左—右
 广度优先：从上到下，从左到右，一层一层的
 注：调用没有加入过的都需要打桩
 优点：减少驱动的开发，测试充分（一个模块一个模块的加入）定位问题容易，效率有所下降，最容易让高层人物建立信心
 缺点：打桩开发成本较高，效率有所下降，下层容易测试不充分
 适用范围：上层稳定，下层相对不稳定的系统
 3）自底向上集成测试
 优点：桩少，定位问题容易，小测试成分，下层测试充分，问题容易暴漏
 缺点：驱动开发成本高，顶层测试不充分
 适用范围：下层稳定，上层变化较多
 4）三明治集成测试方法
 
优点：桩和驱动都减少，测试灵活，问题好隔离，好定位
 缺点：测试中间层可能不充分
 适用范围：大项目
 注：采用哪种方法根据系统本身确定
 8集成测试用例可借用单元测试和系统测试用例设计技术进行用例设计
 9接口覆盖率：每个接口至少被覆盖一次的次数/系统中所有的接口
 10集成测试的层次：子系统间集成测试，模块内集成测试，子系统内集成测试,还要考虑模块间集成测试
 
11集成测试过程：计划（输入HLD测试计划，输出IT计划）——设计（输出IT方案）——实施（输出IT用例，脚本——执行（输出集成测试报告，缺陷报告）
 
第一阶段总结
 基础课程：测试基础、测试过程、测试方法、软件质量
 开发基础：SQL、C语言
 需求分析、需求管理（变更控制、需求跟踪）
 环境搭建
 配置管理、QC
 缺陷管理
 系统测试、集成测试、单元测试、python
 要做好测试还应该学习DB 网络知识 数据结构 算法 语言（C JAVA PYTHON）OS
 所有课程全部基于测试目的：尽量多、尽量的发现BUG，并预防BUG
 在做测试之前，先考虑可以套用哪些软件质量特性，再根据特性考虑测试点
 
Test platform
 管理工具：QC ，RQM
 执行工具：QTP，LR ，WinRunner，BRAT
 数据库：SQL，Oracle，MySQL
 配置管理工具：SVN，CVS，VSS，CC，DB2
 服务器：Tomcat，IIS，JBOSS
 2. 系统测试流程：
 测试流程：需求阶段（产出测试计划）：1）来自客户（用户需求）特点：用户自身根据自己的需要提出来，不考虑技术的实现能力，功能和具体细节的实现不2）来自研发（开发文档）：特点，进一步明确客户的需求3）来自标准协议（手机网络协议：CSM,CDMA,WCDMA,TD_WCDMA,EDEE）
 需求分析（产出测试方案）：分析测试项。罗列功能模块和功能点，产出测试项1）从质量特性的角度对测试项进行分析，包括6大特性，27个子特性2）从功能交互的角度对测试项进行分析，功能是否存在交合，交互过程中有什么影响3）按用户场景进行测试分析
 设计阶段（产出测试用例）设计方法：等价类、边界值、状态迁移图、因果图等
 执行阶段（产出测试报告）提交缺陷报告: 测试结束，研发人员根据提交的bug进行修改，之后release 1.1（新版本），进行回归测试（REG）。
 补充：
 敏捷开发模式 scrum 短小、快。 没有需求、不便于管理。
 User story 功能点。
 3. 与bug相关
 Bug的其他说法
 Defect、CR（change Request）（Moto使用这种说法、submit a CR）、issue。
 缺陷流程：
 缺陷管理工具：QC、Mantis（开源工具）、bugfree（开源）、bugzilla、DDTS（Moto）、DMS（索爱）。
 缺陷状态：New、open、fixed、reopen、assigned、reject、later（postpone）、closed、abandon、duplicate（很常见的一个状态，重复bug，原有的有效，引用时引用原来的bug）。摩托罗拉的缺陷管理系统DDTS
 Postpone原因：有争议的、项目进度紧，优先级低的bug、以后版本就没有这个功能了。
 Retest时可能是不同的测试人员做回归测试：testerA（原）、TesterB（新），测试完后需要测试经理verify
 验证完成后bug没问题tester是否可以直接closed？如果tester没有对bug进行测试，直接closed后可能导致bug遗漏。
 
第二阶段项目笔记
 JXC项目
 扩展名为ASP的文件是微软开发的
 扩展名为JSP的文件是JAVA编写的
 一．建立项目JXC
 1把JXC项目方在d:
 2点JXC右键—共享和安全----WEB共享----编辑别名----执行包括脚本等权限都选上
 3删掉JXC布置：控制面板—管理工具—Internet—网站----默认网站----JXC—右键删除
 4给权限：d:\点上边的文件夹—JXC—data—右键属性----安全与共享----添加—everyone----检查名称----确定----点中everyone—权限都选上—确定
 5登录：控制面板—管理工具—Internet信息服务-----JXC—右边栏里找到index.asp右键—浏览
 6找WEB共享或者安全：工具—文件夹—查看—使用简单文件共享前面的对号去掉
 7客户端需要建TSVN，服务器需要建SVN（必须）/TSVN（可建，可不建）
 二．布置JXC
 1建立仓库：新建文件夹SVN—新建文件夹jxc52-niuxiaoqing和文件夹JXC—在文件夹jxc52-niuxiaoqing里分别新建文件夹trunk branches tags—在文件夹trunk里分别新建文件夹doc code tools—在文件夹doc里分别建立文件夹croup person—在文件person里分别新建文件夹niu wang guo
 2点SVN文件夹—jxc52-niuxiaoqing右键----create repository here
 3创建的文件结构放到仓库：SVN文件夹------tortoisvn----import
 4binary文件时二进制文件（可执行的文件）
 5．Dll动态链接库文件有什么作用
 6 1）开始—运行—CMD—目录—cd空格c:\program files\svbversion\bin(svnserve的路径)—回车
 2）svnserve.exe空格–（2个下划线）help-------回车
 3）svnserve.exe空格-d空格-r空格d:\svn\jxc52-niuxiaoqing----回车
 4）停掉服务ctrl+c
 5）上光标，又出现3）回车，启动服务
 
三．配置SVN
 1、svn搭建的服务环境：svnserve方式
 
2、修改文件：
 
svnserve.conf //修改服务器配置文件
 anon-access = none //去除注释 匿名访问 不允许
 auth-access = write //去除注释 指定用户访问 允许
 
 password-db = passwd //去除注释 启用密码文件passwd
 authz-db = authz     //去除注释 启用用户文件authz
 
passwd //增加用户并设置密码
 zhangsan = 1111 // 用户名 = 密码
 
authz //控制仓库的访问权限
 [groups]
 组名 = 用户名（逗号分隔）
 
 [/] 代表仓库的根目录
 如果使用组：@组名 = rw

 [/trunk/doc/person/lisi] 控制仓库里具体目录的权限

 如果没有特别规定某个目录的权限，则使用根目录[\]权限
 
3、启动服务
 1、进入svn安装目录：cd C:\Program Files\Subversion\bin
 
四．访问SVN
 1 svn checkout
 输入要访问的电脑IP
 File:///仓库建立在之间的计算机上
 SVN://仓库建立在其他机器上，要通过网络方式访问
 Apache为HTTP协议请求提供服务
 Tomcat为JAVA的容器，为JAVA编译的文件解释
 IIS为ASP提供服务
 QC的前身叫testdirector
 9.0之前是mercury公司
 10.0之后是惠普公司
 支持的数据库SQL ,Oracle
 支持的应用服务器JBoss
 支持的WEB服务器JBoss，IIS
 
进销存项目
 上传图片：数据库中保存的是图片名称，实体保存在jxc/upload下。access中没有存储图片的类型。
 
【SqlServer数据库中binary（二进制）类型可以用来保存图片。】
 
为什么改名？ ------有可能重名，同一个windows目录下不能重名
 
为什么是日期时间？------重名的可能性小
 
在哪见过类似的实现方式？----QC生成日志，日志保存名称，年月日秒毫秒（1秒=1000毫秒）
 系统生成的文件，为了解决文件重名的问题，使用日期时间命名，做好精确到毫秒级。
 
日志功能怎么测？
 保存4个内容：日志级别、日志的最大保存行数（边界值）、保存天数（边界值）、日志保存路径。
 
QC非活动状态（选择域后项目下拉列表中没有这个项目了）才能导出（export）----没有人操作
 
离点（10001）：预期结果（有三种实现方式）：保存一个新的日志、覆盖第一条、整个全删了从第一条开始写。
 
保存天数（-1）：不限制。
 保存路径：目录空间是否够，如果不限制保存时间，硬盘保存空间不够时怎么办？tester是否对硬盘空间
 
可操作？
 
安装文件后会有一个bin目录，存有大量二进制文件（编译后），扩展名为.exe，为可运行程序。
 
路径写到上一级，不包括本级
 文字相同
 
001 用户名 用户名和编号
 002 密码
 
新密码 确认新密码合为一个需求 新密码处验证特殊符号等，确认新密码只验证是否与新密码相同。
 
排序 翻页 打印 详细信息
 
所在仓库 有读取数据库的代码
 
测试需求：
 
测试需求的目的：保证测试的完整性。
 将需求导入QC中，能得出什么东西？？-------not covered 应该被用例覆盖但是还没被覆盖。
 细化需求
 每个需求项下边的description：描述该项需求具体的 测试内容，提供测试思路。
 例如：
 产品图片：
 1.浏览功能
 支持的图片格式 jpg、gif（打开文件窗口对该文件类型进行过滤，默认显示过滤类型为jpg、gif）（不区分扩展名的大小写）。
 浏览本地路径、网络路径。
 2.上传功能
 被选文件路径是否合法（选择U盘中的文件，上传前拔掉U盘；存在本地，上传前删除）；
 文件的大小限制（0,1M】
 被上传文件是否被独占打开（需要编写程序来独占打开该图片）。
 图片被上传到服务器的upload目录中，而且被修改图片名称（防止该目录下出现重名文件），名称格式：YYYYMMDDHHMMSS。
 上传成功后相关图片信息（图片的新名称）被保存到buy（photo字段）和produit（photo字段）。
 3.预览功能
 预览模式：平铺、拉伸、居中【一般预览功能就这几种模式】
 使用“居中”的预览模式。
 
Buy表中 shulian（数量）保存时采用四舍五入。（有bug）。如何提bug？？？
 输多个小数点出错 编辑框输入的内容按字符（字符串）处理，放到数据库前需要进行字符转换，多个小数点时不能转换成float型，导致语法错误。
 Bug：
 页面允许输入浮点类型，数据库中为整形。
 页面控制的类型和数据库的类型不一致。
 进销存项目总结
 测试需求分析
 工作思路参考QC需求工作流：
 
1、定义测试范围
 
    依据：ISO9126质量模型
    确定测试范围：被测质量特性
 
2、建立需求项
 参考需求（SRS），明确具体要测试的需求项（测试点、需求点、功能点。。。）
 树形结构，考虑分析的“粒度”（参考QC）
 
    （1）、粗：文件夹级（只分解到模块或者页面层次）
    （2）、中：用例级  （只分解到页面中的具体控件，如“产品名称”、“入库数量”，意味这最底层需求可以直接转换为测试用例）
    （3）、细：步骤级  （分解到用例的操作步骤 Step）
    （4）、默认使用级别：用例级

     考虑后期用例执行，分解出一些特殊的需求（以后会专门对应某些测试类型）

    （1）、页面同名：（作为模板），只考虑该页面中所有控件都输入最正确的值
                   （控件同名的需求，目的从有效、无效两方面反复验证该控件输入的合法性）
    （2）、页面同名 Page： 以后作为“界面测试”使用
    （3）、模块同名：（调用该模块内所有页面同名的用例）作为预测试使用，证明版本的基本功能是否正确
 
3、细化需求项
 描述每个需求项的详细内容
 
详细内容：
 1、页面：（星号）是否允许为空
 2、数据库： 输入类型、长度（边界值）
 3、设计：跑到（所有）的路径----精简测试用例的个数
 
如：入库管理模块–新产品入库页面–入库数量控件：
 1、页面：入库输入量不能为空
 
2、数据库：
 数字类型（整型）
 边界：-231 ~ 231-1
 31：整型类型占用4个字节（4B），每个字节有8位（8bit），每位有两个取值（0、1），考虑符号（正、负）占用1位
 2：代表每位（bit）有两个取值（0、1）
 31：除去符号位，还剩31位
 
3、代码实现：
 1）、当键盘抬起的时候，重置输入
 测试思路：（1）、抬起按键，非法字符的输入被重置
 （2）、绕过该事件，按下字母键不抬起进行鼠标焦点切换
 2）、当粘贴之前，重置输入
 考虑粘贴功能的实现（鼠标右键进行粘贴，快捷键粘贴 Crtl+V）
 3）、小数点个数最多1个（考虑边界值0,1,2个）
 
 具体分析思路：
 
4.需要进行评审
 借助Rose的活动图统一思路
 
4、需求覆盖率分析
 借助工具----QC
 将写好的需求导入到QC中的需求模块
 切换到需求的第四种视图方式：Coverage Analysis (需求覆盖率分析)，看需求的状态（Not Covered 未覆盖状态），得知应该被覆盖到的需求的数量（只统计最底层需求的个数）（被测对象的测试规模），进而预测试出用例的数量
 
当粘贴之前
 课前复习：
 需求名称为必填项，有空行不能导到QC中。
 把相同需求分类
 从需求详细描述从哪几方面去找？（1）页面角度 获取需求（星号—是否允许为空）；（2）数据库 （长度----边界值、类型）；（3）代码 实现方式----【目的：精简用例的个数，路径全部覆盖】
 代码实现讲解：
 onKeyUp="value=value.replace(/[^\d.]/g,’’)
 Onkeyup：当键盘键抬起的时候
 Replace：重新设置
 (/[^\d.]/g,’’)：正则表达式 d----代表数字（0~9） .------代表小数点
 整个句子解释：
 当键盘抬起的时候，判断按键是否属于数组或者小数点，如果不属于这些键，则重置该输入（取消该输入）。
 
这样只要设计2个用例就可（1）输入字母；（2）输入1.5。
 如果没有的代码，只按照等价类边界值的思想设计用例，需要考虑很多情况（此处略）。
 此处总结如下：
 
onbeforepaste=“clipboardData.setData(‘text’,clipboardData.getData(‘text’).replace(/[^\d.]/g,’’))” value=“1”>
 onbeforepaste：当粘贴之前
 入库数量测试（设计）：
 1.输出-------入库输入量不能为空；
 2.代码实现：
 （1）当键盘抬起的时候，重置输入；
 测试思路：绕过该事件，按下字母键不抬起鼠标焦点切换
 （2）当粘贴之前，重置输入
 考虑粘贴功能的实现（鼠标右键进行粘贴，快捷键粘贴Ctrl+V）
 3.小数点个数最多1个
 测试需求分析：
 如何做？？1.工作思路参考QC需求工作流
 2.定义测试范围； 依据：ISO9126质量特性确定测试范围：被测质量特性
 3.建立需求项------参考需求（SRS）明确具体要测试的需求项（又叫测试点、需求点、功能点….）树型结构，考虑分析的“粒度”
 【粗—文件夹级（只分解到模块或者页面层次）；
 中------用例级（只分解到页面中的具体控件，如“产品名称”、“入库数量”）
 细-----步骤级】
 考虑后期用例执行，分解出一些特殊的需求（以后）
 1.页面同名
 2.页面同名page
 3.模块同名
 4.细化需求项
 5.需求覆盖率分析
 
判定表
 解决：多个输入的组合问题
 
方法1：利用数据库的查询命令—笛卡尔积（全排列组合）
 计算最终的组合数量：每个表记录数的乘积
 如：A（a1,a2）
 B（b1,b2,b3,b4）
 C（c1,c2,c3）
 Select * from A、B、C
 
方法2：判定表多个条件，每个条件2个取值
 
3.1.读书选择
 1、如果觉得不疲倦，并且对书中的内容不感兴趣，同时书中的内容让你不糊涂，跳到下一章去读
 2、如果觉得不疲倦，并且对书中的内容不感兴趣，同时书中的内容让你糊涂， 跳到下一章去读
 3、如果觉得不疲倦，并且对书中的内容感兴趣， 同时书中的内容让你不糊涂，继续读下去
 4、如果觉得不疲倦，并且对中书的内容感兴趣， 同时书中的内容让你糊涂， 回到本章重读
 5、如果觉得疲倦， 并且对书中的内容不感兴趣，同时书中的内容让你不糊涂，停止阅读，请休息
 6、如果觉得疲倦， 并且对书中的内容不感兴趣，同时书中的内容让你糊涂， 请停止阅读，休息
 7、如果觉得疲倦， 并且对书中的内容感兴趣， 同时书中的内容让你不糊涂，继续读下去
 8、如果觉得疲倦， 并且对书中的内容感兴趣， 同时书中的内容让你糊涂， 回到本章重读
 
提炼需求：多个条件的组合生成不同的结果
 1、需求分析：
 条件：是否疲倦（是、否）、是否感兴趣（是、否）、是否糊涂（是、否）
 结果：跳到下一章、继续读、本章重读
 2、绘制判定表
 1、分别填入条件和结果，确定表格的“行数”
 2、计算条件组合的数量，规划表格的“列数”
 3、将条件进行排列组合（全排列–笛卡尔积），利用二进制原理（0代表否，1代表是）。
 4、根据每种组合方式（每列），推出其对应的结果
 
	1	2	3	4	5	6	7	8
 
条件 是否疲倦 0 0 0 0 1 1 1 1
 是否感兴趣 0 0 1 1 0 0 1 1
 是否糊涂 0 1 0 1 0 1 0 1
 结果 跳到下一章 X X 
 继续读 X X 
 本章重读 X X
 休息 X X 
 注：虽然1、2的结果是一样的，但是不能使用等价类的思想将其合并，原因：处理路径不同。（时间紧张可以合并）。
 
3、编写测试用例
 原则1：判定表中的每一列生成一个测试用例，多个测试用例
 原则2：判定表中的每一列生成一个测试用例的步骤，一个测试用例
 
我们项目使用：原则2
 两个原则测试的充分程度（覆盖率）相同；
 第二种进行需求跟踪更简单易操作；
 
原则1：----8个测试用例
 用例编号 用例标题 用例输入 操作步骤 预期结果
 ST-001 不疲倦+没兴趣+不糊涂 是否疲倦： 否
 是否感兴趣：否
 是否糊涂： 否 1、启动系统
 2、输入以上内容
 3、点击“提交”按钮 跳到下一章
 ST-002 不疲倦+没兴趣+糊涂 是否疲倦： 否
 是否感兴趣：否
 是否糊涂： 是 1、启动系统
 2、输入以上内容
 3、点击“提交”按钮 跳到下一章
 ST-008 。。。。。。。。 。。。。。。。。 。。。。。。。。 。。。。。。。。
 
原则2：-----1个测试用例，8个步骤
 用例编号 用例标题 步骤名称 步骤输入 操作描述 预期结果
 ST-001 读书选择 启动系统 。。。。。。。。 。。。。。。。。 。。。。。。。。
 准备测试 。。。。。。。。 。。。。。。。。 。。。。。。。。
 Step 1不疲倦+没兴趣+不糊涂 是否疲倦： 否
 是否感兴趣：否
 是否糊涂： 否 1、启动系统
 2、输入以上内容
 3、点击“提交”按钮 跳到下一章
 Step 2不疲倦+没兴趣+糊涂 是否疲倦： 否
 是否感兴趣：否
 是否糊涂： 是 1、启动系统
 2、输入以上内容
 3、点击“提交”按钮 跳到下一章
 Step 8 。。。。。。。。 。。。。。。。。
 3.2.Counter
 
1、测试需求分析
 条件：是否统计代码行、是否统计空行、是否统计注释行、是否统计总行
 结果：统计代码行、统计空行、统计注释行、统计总行
 
2、绘制判定表
 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
 条件 是否统计代码行 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
 是否统计空行 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1
 是否统计注释行 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1
 是否统计总行 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
 结果 统计代码行 X X X X X X X X
 统计空行 X X X X X X X X
 统计注释行 X X X X X X X X
 统计总行 X X X X X X X X
 
3、生成测试用例
 每一列生成一个测试用例，一共16种组合方式
 原则1：----16个用例
 用例编号 用例编号 用例输入 操作步骤 预期结果 编写人 编写时间
 ST-001 1. 
 ST-002 1. 
 ST-003 
 ST-004 
 ST-005
 
原则2：----1个测试用例，16个步骤
 用例编号 用例标题 步骤名称 步骤输入 操作描述 预期结果 编写人 编写时间
 ST-001 Counter统计
 
3.3：word中的判定表举例
 Word中的判定表举例：
 （1）字体和字号
 
输入太多，选择有代表的处理（等价类—减少输入个数）。
 字体：中文、英文（英文又可以分为2类：带横线（serif—如times new roman）、不带横线（sens serif----arial Unicode ））
 （2）
 
组合：4个条件，每个条件2个值。
 （3）
 
这个不能用判定表，因为不能同时选中“左对齐”和“右对齐”，不满足判定表使用条件。
 
3.4.合并判定表
 前提：时间紧张，成本过高；
 原则：结果相同，条件有一个不同（貌似该条件没有作用）；
 风险：被合并的条件可能走不同的“路径”，合并可能会造成漏测。
 对练习1（读书选择）中的判定表进行合并：
 
	1	2	3	4	5	6	7	8
 
条件 是否疲倦 0 0 0 0 1 1 1 1
 是否感兴趣 0 0 1 1 0 0 1 1
 是否糊涂 0 1 0 1 0 1 0 1
 结果 跳到下一章 X X 
 继续读 X X 
 本章重读 X X
 休息 X X
 
判定表合并：
 
	1	2	3	4
	1、2	3、7	4、8	5、6
 
条件 是否疲倦 0 ---- ---- 1
 是否感兴趣 0 1 1 0
 是否糊涂 — 0 1 —
 结果 跳到下一章 X 
 继续读 X 
 本章重读 X 
 休息 X
 
前提：
 合并：时间紧张，成本过高
 原则：结果相同，条件有一个不同（“貌似”该条件没有作用）
 风险：被合并的条件可能走不同的“路径”，合并会造出漏测
 
3.4.密码修改
 若需修改密码，系统验证旧密码正确，两个新密码相同，则更新密码，旧密码即失效，其他修改项也生效，并提示“用户信息修改成功”； 若旧密码不正确，则提示“用户密码错”，系统将不修改个人信息；若两个新密码不同，则提示“新密码与验证新密码不同”，系统将不修改个人信息。
 若只修改密码外其他信息，则不需输入两个新密码，系统只验证旧密码正确，就成功更改个人信息，并提示“用户信息修改成功”；如果系统验证旧密码输入不正确，则提示“用户密码错”。
 流程图如下
 
答案：
 (1)需求分析
 条件：只修改密码外其他信息（是/否）、旧密码（正确/错误）、新密码和验证新密码（相同/不相同）
 结果：提示“用户信息修改成功”、提示“用户密码错”、提示“新密码与验证新密码不同”
 (2)绘制判定表
 1 2 3 4 5 6 7 8
 条件 只修改密码外其他信息 0 0 0 0 1 1 1 1
 旧密码 0 0 1 1 0 0 1 1
 新密码和验证新密码 0 1 0 1 0 1 0 1
 结果 提示“用户信息修改成功” x x x
 提示“用户密码错” x x x 
 提示“新密码与验证新密码不同” x 
 说明 无效 无效
 (3)编写测试用例
 原则2：----1个测试用例，8个步骤
 用例编号 用例标题 步骤名称 步骤输入 操作描述 预期结果
 ST-001 修改信息 启动系统 无 双击 系统正常启动
 Step1：修改密码+旧密码错误+新密码与验证密码一致 是否只修改密码外其他信息：否；
 旧密码是否正确：否；
 新密码和验证新密码是否一致：否 1.启动系统；
 2.输入以上修改信息；
 3.点击“提交”按钮
 无任何提示信息
 Step2：修改密码+旧密码错误+新密码与验证密码一致 是否只修改密码外其他信息：否；
 旧密码是否正确：否；
 新密码和验证新密码是否一致：是 1.启动系统；
 2.输入以上修改信息；
 3.点击“提交”按钮
 提示“用户密码错”，个人信息未修改
 Step3：修改密码+旧密码正确+新密码与验证密码不一致 是否只修改密码外其他信息：否；
 旧密码是否正确：是；
 新密码和验证新密码是否一致：否 1.启动系统；
 2.输入以上修改信息；
 3.点击“提交”按钮
 提示“新密码与验证新密码不同”，个人信息未修改
 Step4：修改密码+旧密码正确+新密码与验证密码一致 是否只修改密码外其他信息：否；
 旧密码是否正确：是；
 新密码和验证新密码是否一致：是 1.启动系统；
 2.输入以上修改信息；
 3.点击“提交”按钮
 提示“用户信息修改成功”，旧密码生效，其他个人信息修改
 Step5：只修改密码外信息+旧密码错误 是否只修改密码外其他信息：是；
 旧密码是否正确：否；
 新密码和验证新密码是否一致：否 1.启动系统；
 2.输入以上修改信息；
 3.点击“提交”按钮
 提示“用户密码错”，个人信息未修改
 Step7：只修改密码外信息+旧密码正确 是否只修改密码外其他信息：是；
 旧密码是否正确：是；
 新密码和验证新密码是否一致：否 1.启动系统；
 2.输入以上修改信息；
 3.点击“提交”按钮
 提示“用户信息修改成功”，其他个人信息修改
 
3.5.进销存
 进销存中的下列选框可以使用判定表的方法设计用例：
 
（1）需求分析
 条件： 仓库（所有仓库/具体仓库）（0表示所有仓库，1表示具体仓库）【“具体”只测试一个即可，处理方式相同，等价类思想】
 类别（包括大类和小类，有三种组合，分别为所有/所有、具体/所有、具体/具体）（分别使用0、1、2表示）
 关键字（填/不填）（0表示不填，1表示填）
 结果：所有仓库所有库存、所有仓库具体库存、具体仓库所有库存、具体仓库具体库存
 （2）绘制判定表
 1 2 3 4 5 6 7 8 9 10 11 12
 条件 仓库 0 0 0 0 0 0 1 1 1 1 1 1
 类别 0 0 1 1 2 2 0 0 1 1 2 2
 关键字 0 1 0 1 0 1 0 1 0 1 0 1
 结果 所有仓库所有库存 X X 
 所有仓库具体库存 X X X X 
 具体仓库所有库存 X X 
 具体仓库具体库存 X X X X
 （3）编写测试用例
 使用原则2：----1个测试用例，12个步骤
 用例编号 用例标题 步骤名称 步骤输入 操作描述 预期结果
 ST-001 库存查询信息组合查询 进入库存查询页面。 无 1.打开进销存网页；2.点击库存管理模块中的库存查询页面。 界面显示库存查询页面。
 Step1：所有仓库+所有大类+所有小类+不填关键字 仓库：所有仓库；
 类别：所有大类和所有小类；
 关键字：不填 1.在页面右上角搜索处选择所有仓库；
 2.在页面右上角搜索处选择所有大类和所有小类；
 3.不填写关键字；
 4.点击“查询”按钮。 页面中显示所有仓库的所有库存信息
 Step2：所有仓库+所有大类+所有小类+填关键字 仓库：所有仓库；
 类别：所有大类和所有小类；
 关键字：填 1.在页面右上角搜索处选择所有仓库；
 2.在页面右上角搜索处选择所有大类和所有小类；
 3.填写关键字；
 4.点击“查询”按钮。 页面中显示所有仓库的所有库存信息
 Step3：所有仓库+具体大类+所有小类+不填关键字 仓库：所有仓库；
 类别：具体大类和所有小类；
 关键字：不填 1.在页面右上角搜索处选择所有仓库；
 2.在页面右上角搜索处选择具体某一个大类和所有小类；
 3.不填写关键字；
 4.点击“查询”按钮。 页面中显示所有仓库的具体库存信息
 Step4：所有仓库+具体大类+所有小类+填关键字 仓库：所有仓库；
 类别：具体大类和所有小类；
 关键字：填 1.在页面右上角搜索处选择所有仓库；
 2.在页面右上角搜索处选择具体某一个大类和所有小类；
 3.填写关键字；
 4.点击“查询”按钮。 页面中显示所有仓库的具体库存信息
 Step5：所有仓库+具体大类+具体小类+不填关键字 仓库：所有仓库；
 类别：具体大类和具体小类；
 关键字：不填 1.在页面右上角搜索处选择所有仓库；
 2.在页面右上角搜索处选择具体某一个大类和具体某一个小类；
 3.不填写关键字；
 4.点击“查询”按钮。 页面中显示所有仓库的具体库存信息
 Step6：所有仓库+具体大类+具体小类+填关键字 仓库：所有仓库；
 类别：具体大类和具体小类；
 关键字：填 1.在页面右上角搜索处选择所有仓库；
 2.在页面右上角搜索处选择具体某一个大类和具体某一个小类；
 3.填写关键字；
 4.点击“查询”按钮。 页面中显示所有仓库的具体库存信息
 Step7：具体仓库+所有大类+所有小类+不填关键字 仓库：具体仓库；
 类别：所有大类和所有小类；
 关键字：不填 1.在页面右上角搜索处选择具体某一个仓库；
 2.在页面右上角搜索处选择所有大类和所有小类；
 3.不填写关键字；
 4.点击“查询”按钮。 页面中显示具体仓库的所有库存信息
 Step8：具体仓库+所有大类+所有小类+填关键字 仓库：具体仓库；
 类别：所有大类和所有小类；
 关键字：填 1.在页面右上角搜索处选择具体某一个仓库；
 2.在页面右上角搜索处选择所有大类和所有小类；
 3.填写关键字；
 4.点击“查询”按钮。 页面中显示具体仓库的所有库存信息
 Step9：具体仓库+具体大类+所有小类+不填关键字 仓库：具体仓库；
 类别：具体大类和所有小类；
 关键字：不填 1.在页面右上角搜索处选择具体某一个仓库；
 2.在页面右上角搜索处选择具体某一个大类和所有小类；
 3.不填写关键字；
 4.点击“查询”按钮。 页面中显示具体仓库的具体库存信息
 Step10：具体仓库+具体大类+所有小类+填关键字 仓库：具体仓库；
 类别：具体大类和所有小类；
 关键字：填 1.在页面右上角搜索处选择具体某一个仓库；
 2.在页面右上角搜索处选择具体某一个大类和所有小类；
 3.填写关键字；
 4.点击“查询”按钮。 页面中显示具体仓库的具体库存信息
 Step11：具体仓库+具体大类+具体小类+不填关键字 仓库：具体仓库；
 类别：具体大类和具体小类；
 关键字：不填 1.在页面右上角搜索处选择具体某一个仓库；
 2.在页面右上角搜索处选择具体某一个大类和具体某一个小类；
 3.不填写关键字；
 4.点击“查询”按钮。 页面中显示具体仓库的具体库存信息
 Step12：具体仓库+具体大类+具体小类+填关键字 仓库：具体仓库；
 类别：具体大类和具体小类；
 关键字：填 1.在页面右上角搜索处选择具体某一个仓库；
 2.在页面右上角搜索处选择具体某一个大类和具体某一个小类；
 3.填写关键字；
 4.点击“查询”按钮。 页面中显示具体仓库的具体库存信息
 
3.6.总结
 1、什么时候用：
 （1）有多个输入需要组合的时候，采用判定表进行用例设计；
 2、怎么用：
 （2）使用判定表进行用例设计，有以下3个步骤：
 a)需求分析，通过对多个条件的组合生成不同的结果进行分析，得出条件和结果。
 b)绘制判定表。
 i.分别填入条件和结果，确定表格的“行数”；
 ii.计算条件的组合数量，规划表格的“列数”；
 iii.将条件进行排列组合，利用二进制原理；
 iv.根据每种组合方式，推出其对应的结果。
 c)编写测试用例
 有2种方式：判定表中的每一列生成一个测试用例，最终生成多个测试用例；
 判定表中的每一列生成一个测试用例的步骤，最终生成一个测试用例。
 3判定表的优点和缺点
 （3）优点：组合充分，没有遗漏；
 缺点：当条件数多的时候（超过5个）用例数量多，成本高。
 
因果图
 
条件和结果之间的关系：
 
恒等：条件成立，结果成立
 非： 条件成立，结果不成立
 或： 只要有一个条件成立，结果成立
 与： 必须所有条件都成立，结果成立
 
条件之间的关系：
 
E：不能同时为“真”
 I：不能同时为“假”
 O：有且仅有一个为“真”
 
第一个举例：呼吸，用鼻子和嘴（异）
 因果图作用：1、条件和结果之间的关系：分析业务逻辑（类似流程图的作用）
 2、条件之间的关系：去除判定表中的无效的列
 使用viso绘制因果图：
 操作步骤：
 （1）：在viso中选择基本流程图，
 （2）按照等价（处理方式相同）条件，添加中间节点（临时结果）。如：A、B处理相同(等价类)，做中间节点（如A or B）。
 （3）分析条件和结果之间的关系（恒等、与、或、非）。
 如果不是一次退出结果，或者连线较多，可以增加中间节点。
 （4）分析条件之间的关系（E、I、O）。
 
4.1.字母判定
 第一列字符必须是A或B，第二列字符必须是一个数字（每列只能输入一个字符），在此情况下（只有这个时候才）进行文件的修改，但如果第一列字符不正确，则给出信息L；如果第二列字符不是数字，则给出信息M。
 不能使用等价类【不是单一条件】
 
1、测试需求分析
 条件：第一列是A、第一列是B、第二列是数字
 结果：修改文件、 提示L、 提示M
 
2、绘制因果图
 
3、绘制判定表
 假设：当判断完是否是AorB条件后，如果取“否”，则退出系统运行。【实际工作中不允许假设】。
 
利用因果图条件之间的关系，去除无效列
 
	1	2	3	4	5	6	7	8
 
条件 第一列是A 0 0 0 0 1 1 1 1
 第一列是B 0 0 1 1 0 0 1 1
 第二列是数字 0 1 0 1 0 1 0 1
 结果 修改文件 X X 
 提示L X X 
 提示M X X 
 实际输入 CC T7 B@ B5 AF A6 无效 无效
 
第一种条件是提示L还是提示L、M，在公司中要找开发人员询问，不能主观猜测。
 
编写测试用例
 原则2：----1个测试用例，8个步骤
 用例编号 用例标题 步骤名称 步骤输入 操作描述 预期结果 编写人 编写时间
 ST-001 修改文件
 
4.2.自动售货机
 有一个处理单价为5角钱的饮料的自动售货机软件测试用例的设计。其规格说明如下：若投入5角钱或1元钱的硬币，押下〖橙汁〗或〖啤酒〗的按钮，则相应的饮料就送出来。若售货机没有零钱找，则一个显示〖零钱找完〗的红灯亮，这时在投入1元硬币并押下按钮后，饮料不送出来而且1元硬币也退出来；若有零钱找，则显示〖零钱找完〗的红灯灭，在送出饮料的同时退还5角硬币。
 
1、测试需求分析：
 条件：有零钱、投1元、投5角、选啤酒、选橙汁
 结果：红灯亮、退1元、找5角、出啤酒、出橙汁
 
2、绘制因果图
 
3、绘制判定表
 
红色列为无效组合
 
4、生成测试用例
 经办人不能为空，程序中通过管理员ID判断当前登陆用户是否为管理员，如果在数据库login表中删除再添加一个管理员后id变了，导致查询错误。
 Admin登陆，下拉列表中显示所有系统的用户，非admin登陆，下拉列表中只显示当前登陆用户。
 关于下拉列表的问题：
 
关于单元测试逻辑覆盖率：
 在只有一个条件时，路径覆盖率为100%时，条件覆盖率也是100%。
 如果条件不是布尔类型，可以使用数据库中的多表关联，计算笛卡尔积。
 如：
 A表（a1、a2）
 B表（b1、b2、b3、b4）
 C表（c1、c2、c3）
 使用select * from A、B、C；查询。
 
状态迁移
 5.1.飞机售票系统
 1、客户向航空公司打电话预定机票—>此时机票信息处于“完成”状态
 2、顾客支付了机票费用后—>机票信息就变为“已支付”状态
 3、旅行当天到达机场后，拿到机票后—>机票信息就变为“已出票”状态
 4、登机检票后—>机票信息就变为“已使用”状态
 5、在登上飞机之前任何时间可以取消自己的订票信息，如果已经支付了机票的费用，则还可以得到退款，取消后—>订票信息处于“已被取消”状态
 
1、测试需求分析
 状态：完成、已支付、已出票、已使用、已被取消
 
2、绘制状态迁移图
 使用rose画状态图：
 方法：
 （1）右键，新建状态图New -----stagechar Diagram。
 
特点：每个状态只出现一次
 
3、生成用例 — 路径覆盖
 绘制状态迁移树-----每个树枝生成一个测试用例
 
特点：
 1、每个状态可以出现多次
 2、箭头方向统一向“右”延伸
 3、状态转换如果出现循环，该路径只遍历一次
 4、编写测试用例
 用例编号 标题 步骤名称 步骤描述 预期结果
 STC-001 售票流程 启动系统 
 准备测试数据和环境 
 Step 1 完成-取消 1、客户向航空公司打电话预定机票
 2、取消该机票 1、此时机票信息处于“完成”状态
 2、订票信息处于“已被取消”状态
 Step 2 完成-支付-取消 。。。。。 。。。。。
 Step 3 。。。。。 。。。。。
 Step 4 。。。。。 。。。。。
 那些软件适合状态迁移
 淘宝买东西、QC需求、配置管理状态（normal、modified.;……）、缺陷状态（new、open……）
 QC需求状态（只考虑一次运行）
 
5.2.缺陷跟踪
 
流程分析
 使用ROSE中的活动图进行分析
 
状态：吃饭中（有一个延续，使用ing）。
 活动：吃饭
 方法：
 （1）右键，新建状态图New -----activity Diagram。
 
6.1.处理流程
 在某嵌入式系统中，将待发送的数据打包成符合CAN协议的帧格式后，便可写入发送缓站区，并自动发送。该发送子程序的流程为：
 1、首先进入发送子程序
 2、系统判断是否有空闲发送缓冲区，如果没有则返回启动发送失败消息。
 3、如果有空闲缓冲区，将数据包写入空闲发送缓冲区
 4、系统判断是否写入成功，如果不成功则返回启动发送失败消息
 5、如果写入成功，则启动发送命令
 6、返回启动发送成功消息
 1、绘制流程（活动）图
 
2、生成测试用例------ 路径覆盖
 1、（A） （B） （C） （D） （E） （F） 基本流
 2、（A） （B） （G） 备选流
 3、（A） （B） （C） （D） （G） 备选流
 
6.2.系统登录
 
C/S程序。
 先判断是否为空，再去判断是否合法，涉及到效率问题。
 把判断时间短的放前边。
 
用例：6个（路径）
 单个测试用户名考虑：空、最大值、特殊符号、匹配、不匹配
 6.3.字母判断
 
用例：
 基本流： （1） （2） （3）
 （1A） （2） （3） 6列
 （1B） （2） （3） 4列
 备选流1：（1） （4） 1、2列
 备选流2：（1） （2） （5）
 （1A） （2） （5） 5列
 （1B） （2） （5） 3列
 
	1	2	3	4	5	6	7	8
 
条件 第一列是A 0 0 0 0 1 1 1 1
 第一列是B 0 0 1 1 0 0 1 1
 第二列是数字 0 1 0 1 0 1 0 1
 结果 修改文件 X X 
 提示L X X 
 提示M X X 
 实际输入 CC T7 B@ B5 AF A6 无效 无效
 
合并判定表
 1 2 3 4 5
 1、2 3 4 5 6
 条件 第一列是A 0 0 0 1 1
 第一列是B 0 1 1 0 0
 第二列是数字 ---- 0 1 0 1
 结果 修改文件 X X
 提示L X 
 提示M X X 
 实际输入 CC B@ B5 AF A6
 使用流程图和判定表
 都可以，使用流程图前提要保证流程图正确
 6.4.组合查询
 库存管理–库存查询代码实现：
 //
 nowkeyword–输入在查询关键字
 nowku-------输入在仓库名对应在id
 nowbigclass—输入的大类对应的id
 nowsmallclass—输入的小类对应的id
 &—+加在之前sql语句后边
 
 
语句覆盖100%：1个用例；
 分支覆盖100%：2个用例；
 路径覆盖100%：16个用例。
 可以使用独立路径（每个路径只走一次）：A-----、AB------、AC------、AD------、AE------（非法用例，不选大类不能选小类，使用ADE）。可以再找一个全选ABCDE。共6个用例。
 
用例：
 1、 （A） （F） 独立路径
 2、 （A） （B） （F） 独立路径
 3、 （A） （C） （F） 独立路径
 4、 （A） （D） （F） 独立路径
 5、 （A） （D） （E） （F） 独立路径
 6、 （A） （B） （C） （D） （E） （F） 补充
 补充1关于where中1=1的问题：
 
两个查询是一样的。为什么要加上1=1呢？？因为每个select查询语句调教中只能加一个where，可以加多个and；如果在这句中不加1=1，之后的sql语句需要判断之前是否加过where，再做处理，影响查询效率。
 查询效率高。
 如果查询的是两个表，两个表查询就不用写了，两个表关联时就把where语句占用了。
 补充2取仓库ID,而不是仓库名称：
 代码实现：
 
下拉列表由2部分组成，分别为value和库名。
 
课前复习
 单个输入------- 等价类边界值
 多条件组合------判定表（全排列组合，组合个数2n（n代表条件个数）条件是布尔类型，如果不是布尔类型，参考数据库笛卡尔积，条件取值个数相乘）。
 ------因果图（帮助描述中间处理过程，去除判定表中的无效组合，3种约束：E、I、O）
 ------正交试验（两两组合）
 每个条件取值不规范，使用allpairs工具。
 处理流程问题------状态迁移（强调状态属性，用状态来描述流程）
 -----流程分析（活动图活流程图）
 生成用例原则：单元测试的路径覆盖。路径太多可以取独立路径或分支覆盖。
 
正交试验
 7.1.环境搭建
 假设一个WEB站点，该站点有大量的服务器和操作系统，并且有许多具有各种插件的浏览器浏览：
 
环境配置 Web浏览器 浏览器插件 操作系统 服务器
 配置选项 Netscape RealPlayer WinXP IIS
 IE Flash Win2000 Tomcat
 Firefox PDF Reader Win2003 Weblogic
 
1、测试需求分析，找出条件和取值
 条件：4个
 取值：每个条件有3个取值
 
2、选择正交表： L9_3_4
 9：代表最终生成用例的个数
 4：因素（因数），代表条件的个数
 3：水平，代表每个条件取值的个数
 
3、生成用例
 因素 Web浏览器 浏览器插件 操作系统 服务器
 实验1 Netscape RealPlayer WinXP IIS
 实验2 Netscape Flash Win2000 Tomcat
 实验3 Netscape PDF Reader Win2003 Weblogic
 实验4 IE RealPlayer Win2000 Weblogic
 实验5 IE Flash Win2003 IIS
 实验6 IE PDF Reader WinXP Tomcat
 实验7 Firefox RealPlayer Win2003 Tomcat
 实验8 Firefox Flash WinXP Weblogic
 实验9 Firefox PDF Reader Win2000 IIS
 
正交表的特点：
    1、任意一列，每个取值出现的次数一致（均匀）（本题出现3次）
    2、任意两列，任何两个值得组合出现的次数一致（均匀）（本题出现1次）
    3、任意一列，该列的每个值都和其他列的所有值成对组合过（均匀）（本题组合1次）
       正交表：充分的两两组合（9个用例）
       判定表：全排列组合（两两组合、三三、四四。。。。组合）（81个用例）
       
使用原则：根据经验，如果充分的两两组合不出问题，那么多次组合出问题的可能性很小，基于成本、时间等因素，可以考虑正交试验方法生成测试用例
 
7.2.Counter
 
因素 代码行 注释行 空行 总行
 实验1 选 选 选 选
 实验2 选 选 选 不选
 实验3 选 不选 不选 选
 实验4 选 不选 不选 不选
 实验5 不选 选 不选 选
 实验6 不选 选 不选 不选
 实验7 不选 不选 选 选
 实验8 不选 不选 选 不选
 补充 不选 不选 不选 选
 补充 不选 不选 不选 不选
 
7.3.组合
 题目：
 土壤的酸碱度：酸性、碱性、中性
 土壤的潮湿度：潮湿、干燥
 土壤的温度： 高温、低温
 提供标准正交表：
 因素 A B C
 实验1 0 0 0
 实验2 0 1 1
 实验3 1 0 1
 实验4 1 1 0
 
答案：
 方法1）、正交试验方法：
 正交表：L4_2_3
 土壤的酸碱度：0（酸性）、1（碱性+中性）
 土壤的潮湿度：0（潮湿）、1（干燥）
 土壤的温度： 0（高温）、1（低温）
 
因素 酸碱度 潮湿度 温度
 实验1 酸性 潮湿 高温
 实验2 酸性 干燥 低温
 实验3 碱性+中性 潮湿 低温
 实验4 碱性+中性 干燥 高温
 
拆分正交表
 
因素 酸碱度 潮湿度 温度
 实验1 酸性 潮湿 高温
 实验2 酸性 干燥 低温
 实验3 碱性 潮湿 低温
 实验4 中性 潮湿 低温
 实验5 碱性 干燥 高温
 实验6 中性 干燥 高温
 
方法2）、判定表方法：
 绘制判定表
 1 2 3 4 5 6 7 8
 条件 酸碱度 0 0 0 0 1 1 1 1
 潮湿度 0 0 1 1 0 0 1 1
 温度 0 1 0 1 0 1 0 1
 
带入判定表
 1 2 3 4 5 6 7 8
 条件 酸碱度 酸性 酸性 酸性 酸性 碱性+中性 碱性+中性 碱性+中性 碱性+中性
 潮湿度 潮湿 潮湿 干燥 干燥 潮湿 潮湿 干燥 干燥
 温度 高温 低温 高温 低温 高温 低温 高温 低温
 
拆分判定表
 1 2 3 4 5 6 7 8 9 10 11 12
 条件 酸碱度 酸性 酸性 酸性 酸性 碱性 中性 碱性 中性 碱性 中性 碱性 中性
 潮湿度 潮湿 潮湿 干燥 干燥 潮湿 潮湿 潮湿 潮湿 干燥 干燥 干燥 干燥
 温度 高温 低温 高温 低温 高温 高温 低温 低温 高温 高温 低温 低温
 
时间不充裕选择正交实验法，否则选择判定法（充分）
 
方法3）、Allpairs工具实现
 使用allpairs工具：
 Cmd-----进入allpairs目录下 cd C:\Documents and Settings\51testing\桌面\allpairs----
 新建空白excl文件，将条件复制到excl中，
 
TEST CASES 
 case 土壤酸碱度 土壤潮湿度 土壤温度
 1 酸性 潮湿 高温
 2 酸性 干燥 低温
 3 碱性 潮湿 低温
 4 碱性 干燥 高温
 5 中性 潮湿 高温
 6 中性 干燥 低温
 
7.4.环境搭建
 假设一个WEB站点，该站点有大量的服务器和操作系统，并且有许多具有各种插件的浏览器浏览：
 
环境配置 Web浏览器 浏览器插件 操作系统 服务器
 配置选项 IE RealPlayer WinXP IIS
 Firefox Flash Win2000 Tomcat
 PDF Reader Win2003 Weblogic
 Baidu Win 7 
 XunLei
 
练习：进销存
 
条件：
 仓库：所有、具体
 大类和小类：所有-所有、具体-所有、具体-具体
 关键词：不填、货号（模糊）、产品名称（模糊）
 
其他
 输入域
 寻找输入中的特殊值
 如：注册页面输入用户名：hujintao、admin、administrator…….
 如：结构化输入（相互制约）要考虑组合：日期（年月日）、国家—城市，进销存权限复选控制（库存查询、删除）
 【上下级关系的选项】
 员工权限
 Bug：不选库存查询可以选择修改和删除。
 输出域
 找输出或者设计的等价类和边界值----根据结果的边界反推出输入
 如：数据库涉及时间的查询（首尾时间参考数据的第一条和最后一条记录的时间）
 如：QC需求，同级最大的需求数量：263
 最多的子集层数：255/3 = 85
 如：QC中的日志最大行数、
 如：QC中添加字段最多可以添加24个字段（可以通过查看数据库中的表得到）。
 
异常分析
 可靠特性：容错、恢复
 如：SQL Server的导入功能（在源数据上构造错误数据，看异常处理功能的代码是否正确）
 如：进销存的数据还原
 
错误猜测
 凭经验
 如：数字输入框（非数字字符的输入控制，小数点的个数）
 数据库的设计（约束关系）
 
作业：
 三角形问题：
 
成立条件：两边之和大于第三边。
 1、等价类
 2、判定表
 3、流程分析。
 密码修改问题：
 1、判定表
 流程分析