zhan2016 / dsa Goto Github PK

class Employee:
   '所有员工的基类'
   empCount = 0 #类对象,类的静态变量
 
   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount
 
   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

a = 40      # 创建对象  <40>
b = a       # 增加引用， <40> 的计数
c = [b]     # 增加引用.  <40> 的计数

del a       # 减少引用 <40> 的计数
b = 100     # 减少引用 <40> 的计数
c[0] = -1   # 减少引用 <40> 的计数

class Parent: #定义父类
    parentAttr=100
    def __init__(self):
        print("调用父类构造函数")
    def parentMethod(self):
        print("调用父类方法")
    def setAttr(self, attr):
        Parent.parentAttr = attr
    def getAttr(self):
        print("父类属性:%s" % Parent.parentAttr)

class Child(Parent):#定义子类
    def  __init__(self):
        print("调用子类的构造函数")
        Parent.__init__(self)    #显示调用父类的构造
    def  childMethod(self):
        print("调用子类方法")
    def parentMethod(self):
        print("override parent")
c = Child()
c.childMethod()
c.parentMethod()
c.setAttr(200)
c.getAttr()

调用子类的构造函数
调用父类构造函数
调用子类方法
override parent
父类属性:200

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量
 
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print self.__secretCount
 
counter = JustCounter()
counter.count()
counter.count()
print counter.publicCount
print counter.__secretCount  # 报错，实例不能访问私有变量

1. 开启一个issue
2.查阅资料
3.截取，理解相关资料
4.键入文字
5.修改，保存

1.叫一辆出租车
2.告诉出租车司机，你的目的地址
3.付款给出租车司机
4.下车到家

排序算法(海量数据查找)
傅里叶边换和快速傅里叶变换
Dijkstra’s algorithm
RSA algorithm(加密算法)
Secure Hash Algorithm
Integer factorization
Link Analysis
Proportional Integral Derivative Algorithm
Data compression algorithms
Random Number Generation

template <class identifier> function_declaration;
template <typename identifier> function_declaration;

// function template
#include <iostream>
using namespace std;

template <class T>
T GetMax (T a, T b) {
  T result;
  result = (a>b)? a : b;
  return (result);
}

int main () {
  int i=5, j=6, k;
  long l=10, m=5, n;
  k=GetMax<int>(i,j);
  n=GetMax<long>(l,m);
  cout << k << endl;
  cout << n << endl;
  return 0;
}

k=GetMax<int>(i,j);  --> k=GetMax(i,j); 
  n=GetMax<long>(l,m); -->k=GetMax(l,m);

template <class T, class U>
T GetMin (T a, U b) {
  return (a<b?a:b);
}

int i,j;
long l;
i = GetMin(j,l)

// class templates
#include <iostream>
using namespace std;

template <class T>
class mypair {
    T a, b;
  public:
    mypair (T first, T second)
      {a=first; b=second;}
    T getmax ();
};

template <class T>
T mypair<T>::getmax ()
{
  T retval;
  retval = a>b? a : b;
  return retval;
}

int main () {
  mypair <int> myobject (100, 75);
  cout << myobject.getmax();
  return 0;
}

template <class T>
T mypair<T>::getmax ()
{
  T retval;
  retval = a>b? a : b;
  return retval;
}

// template specialization
#include <iostream>
using namespace std;

// class template:
template <class T>
class mycontainer {
    T element;
  public:
    mycontainer (T arg) {element=arg;}
    T increase () {return ++element;}
};

// class template specialization:
template <>
class mycontainer <char> {
    char element;
  public:
    mycontainer (char arg) {element=arg;}
    char uppercase ()
    {
      if ((element>='a')&&(element<='z'))
      element+='A'-'a';
      return element;
    }
};

int main () {
  mycontainer<int> myint (7);
  mycontainer<char> mychar ('j');
  cout << myint.increase() << endl;
  cout << mychar.uppercase() << endl;
  return 0;
}

// sequence template
#include <iostream>
using namespace std;

template <class T, int N>
class mysequence {
    T memblock [N];
  public:
    void setmember (int x, T value);
    T getmember (int x);
};

template <class T, int N>
void mysequence<T,N>::setmember (int x, T value) {
  memblock[x]=value;
}

template <class T, int N>
T mysequence<T,N>::getmember (int x) {
  return memblock[x];
}

int main () {
  mysequence <int,5> myints;
  mysequence <double,5> myfloats;
  myints.setmember (0,100);
  myfloats.setmember (3,3.1416);
  cout << myints.getmember(0) << '\n';
  cout << myfloats.getmember(3) << '\n';
  return 0;
}

template <class T=char, int N=10> class mysequence {..};
如果引用:

mysequence<> myseq;  等同于:mysequence<char,10> myseq;