人間って、不自由な生き物ね。

print 'hello world'  #我是注释

'''Line 1
Line 2
Line 3'''

r'\(~_~)/ \(~_~)/'

r'''Python is created by "Guido".
It is free and easy to learn.
Let's start learn Python in imooc!'''

print u'中文'
中文

print 'hello, world'

print 'The quick brown fox', 'jumps over', 'the lazy dog'
The quick brown fox jumps over the lazy dog

>>>print 300
300    #运行结果
>>>print 100 + 200
300    #运行结果

print '100 + 200 =', 100 + 200
100 + 200 = 300     #运行结果

print 'Hello World!'

exit()

<?php
class hashNode{
    public $key;
    public $val;
    public $nextNode;

    /**
     * Description:构造函数
     * @param $key
     * @param $value
     * @param $nextNode
     */
    public function __construct($key,$val,$nextNode=null){
        $this->key = $key;
        $this->val = $val;
        $this->nextNode = $nextNode;
    }
}
class hashTable{
    private $collection;
    public $size = 20;

    /**
     * Description:初始化哈希表
     * @param $size
     */
    public function __construct($size=''){
        if(is_int($size)){
            $bucketsSize = $size;
            $this->size = $size;
        }else{
            $bucketsSize = $this->size;
        }
        $this->collection = new SplFixedArray($bucketsSize);
    }

    /**
     * Description:哈希算法，生成散列值，作为存储数据的下标
     * @param $key
     * @return int
    */
    private function  _hashAlgorithm($key){
        $length = strlen($key);
        $hashValue = 0;
        for($i=0;$i<$length;$i++){
            $hashValue += ord($key[$i]);//ord函数获得字符的ASCII码
        }
        return ($hashValue%($this->size));
    }

    /**
     * Description:在相应的位置存储对应的值
     * @param $key
     * @param $val
     */
    public function set($key,$val){
        $index = $this->_hashAlgorithm($key);
        if(isset($this->collection[$index])){
            $newNode = new hashNode($key,$val,$this->collection[$index]);
        }else{
            $newNode = new hashNode($key,$val,null);
        }
        $this->collection[$index] = $newNode;
    }

    /**
     * Description:根据key生成的散列值，找到对应的值
     * @param $key
     * @return hashNode
     */
    public function get($key){
        $index = $this->_hashAlgorithm($key);
        $current = $this->collection[$index];
        while(!empty($current)){
            if($current->key == $key){
                return $current->val;
            }
            $current = $current->nextNode;
        }
        return null;
    }

    /**
     * Description:设置哈希表的大小
     * @param $size
     */
    public function editSize($size){
        $this->size = $size;
        $this->collection->setSize($size);
    }

    /**
     * Description:删除某个值，成功返回1，失败返回0
     * @param $key
     * @return bool
     */
    public function del($key)
    {
        return 0;
    }

    /**
     * Description:判断某个值是否存在，存在则返回1，不存在返回0
     * @param $key
     * @return bool
     */
    public function exist($key){
        $index = $this->_hashAlgorithm($key);
        $current = $this->collection[$index];
        while(!empty($current)){
            if($current->key == $key){
                return 1;
            }
        }
        return 0;
    }

    /**
     * Description:返回存储元素的个数
     * @return int
     */
    public function size(){
        $size = 0;
        $length = $this->size;
        for($i=0;$i<$length;$i++){
            $current = $this->collection[$i];
            while(!empty($current)){
                $size++;
                $current = $current->nextNode;
            }
        }
        return $size;
    }

    /**
     * Description:列出哈希表内保存的值
     * @return SplFixedArray
     */
    public function getList(){
        return $this->collection;
    }

    /**
     * Description：根据hashTable数组的某一个key进行排序
     * @param $hashArr
     * @param $key
     * @return array：排序后的数组
     */
    public static function qsort($hashArr,$key){
        //先判断是否需要继续进行
        $length = count($hashArr);
        if($length <= 1) {
            return $hashArr;
        }
        $base_num = $hashArr[0]; //选择标尺
        //遍历 除了标尺外的所有元素，按照大小关系放入两个数组内
        $left_array = array();//小于标尺的
        $right_array = array();//大于标尺的
        for($i=1; $i<$length; $i++) {
            if($base_num->get($key) > $hashArr[$i]->get($key)) {
                $left_array[] = $hashArr[$i];//放入左边数组
            } else {
                $right_array[] = $hashArr[$i];//放入右边数组
            }
        }
        /*再分别对左边和右边的数组进行相同的排序处理方式
        递归调用这个函数,并记录结果*/
        $left_array = self::qsort($left_array,$key);
        $right_array = self::qsort($right_array,$key);
        //合并左边 标尺 右边

        return array_merge($left_array, array($base_num), $right_array);
    }
}

package learnCollection;

import java.util.HashSet;
import java.util.Iterator;

public class Main {

    public static void main(String[] args) {
        HashSet<Character> hs = new HashSet<Character>(11);
        hs.add('a');
        hs.add('b');
        hs.add('1');
        hs.add('5');
        hs.add('4');
        hs.add('e');
        System.out.println(hs);//输出hs的元素
        Iterator<Character> it = hs.iterator();
        while(it.hasNext()){
            System.out.print(it.next().hashCode()+" ");//输出各元素的hashCode
        }
        System.out.println();
    }
}

[1, e, b, 5, 4, a]
49 101 98 53 52 97

public boolean add(E e) {
        return map.put(e, PRESENT)==null;//将要存储的元素当作键，一个Object对象当作值存入一个HashMap
    }

public V put(K key, V value) {
       if (table == EMPTY_TABLE) {
           inflateTable(threshold);
       }
       if (key == null)
           return putForNullKey(value);//以上代码是边界判断
       int hash = hash(key);//获得传入值的哈希值
       int i = indexFor(hash, table.length);//获得哈希表中的下标
       for (Entry<K,V> e = table[i]; e != null; e = e.next) {
           Object k;
           if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
               V oldValue = e.value;
               e.value = value;
               e.recordAccess(this);
               return oldValue;
           }
       }//如果键已经存在，则更新对应值
       modCount++;
       addEntry(hash, key, value, i);//添加到表中
       return null;
   }

final int hash(Object k) {
        int h = hashSeed;//此常数默认是零，老版本中没有此定义，老版本此函数直接传入k的hashCode
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }

        h ^= k.hashCode();//0与k.hashCode()进行异或结果还是k.hashCode()

        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);//这两句对h通过移位进行优化，减少哈希值重复
    }

    static int indexFor(int h, int length) {
        // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
        return h & (length-1);//lentgh是HashMap当前的容量，默认为16
    }

def i(h):
  h = h^(h>>20)^(h>>12)
  h = h^(h>>7)^(h>>4)
  h = h&15
  return h

[1, e, b, 5, 4, a]
49 101 98 53 52 97

>>> i(49)
2
>>> i(101)
3
>>> i(98)
4
>>> i(53)
6
>>> i(52)
7
>>> i(97)
7