本文详细介绍了Python的基本语法，包括数据类型如字符串、列表、元组、字典的操作，以及条件语句、循环语句的使用方法。同时涵盖了函数定义与调用、类与对象的概念和实践案例。
中文编码问题
#coding=utf-8打印输出
print "Hello World!";
print "Hello, Python!";
print 'The quick brown fox', 'jumps over', 'the lazy dog';
print 100 + 200;
print '100 + 200 =', 100 + 200;
message = 'Hello World!'
n = 666
print message,n;
print "学习呢!";#这是一个注释
'''
这是多行注释，使用单引号。
这是多行注释，使用单引号。
这是多行注释，使用单引号。
'''
"""
这是多行注释，使用双引号。
这是多行注释，使用双引号。
这是多行注释，使用双引号。
"""
#raw_input("按下 enter 键退出，其他任意键显示...\n");
x="a"
y="b"
# 不换行输出
print x,
print y,
print '---------'
# 换行输出
print x;
print y;
#变量
a, b, c = 1, 0.2, "john";
print a, b, c;
字串
#Python不支持单字符类型，单字符也在Python也是作为一个字符串使用。
str = 'ilovepython';
print str; # 输出完整字符串
print str[0]; # 输出字符串中的第一个字符
print str[1:5]; # 输出字符串中第三个至第五个之间的字符串
print str[2:]; # 输出从第三个字符开始的字符串
print str * 2; # 输出字符串两次
print str + "TEST"; # 输出连接的字符串
Unicode 字符串
strUnicode = u'Hello World !'
print strUnicode列表
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
print list; # 输出完整列表
print list[0]; # 输出列表的第一个元素
print list[1:3]; # 输出第二个至第三个元素
print list[2:]; # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2; # 输出列表两次
print list + tinylist; # 打印组合的列表
元组
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
print tuple; # 输出完整元组
print tuple[0]; # 输出元组的第一个元素
print tuple[1:3]; # 输出第二个至第三个的元素
print tuple[2:]; # 输出从第三个开始至列表末尾的所有元素
print tinytuple * 2; # 输出元组两次
print tuple + tinytuple; # 打印组合的元组
#元组是不允许更新的。而列表是允许更新的
字典
'''
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。
两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
'''
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
print dict['one']; # 输出键为'one' 的值
print dict[2]; # 输出键为 2 的值
print tinydict; # 输出完整的字典
print tinydict.keys(); # 输出所有键
print tinydict.values(); # 输出所有值
运算符
'''
** 幂运算
// 取整数商
<> 不等于
x and y 与
x or y 或
not x 非
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False
is
not is
is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
'''条件语句
if True:
print "True";
elif False:
print "False";
else:
print "Answer End";
循环语句
#Python提供了for循环和while循环（在Python中没有do..while循环）
#for
for letter in 'Python': # 第一个实例
print '当前字母 :', letter
fruits = ['banana', 'apple', 'mango']
for fruit in fruits: # 第二个实例
print '当前水果 :', fruit
#通过序列索引迭代
#数 len() 和 range(),函数 len() 返回列表的长度，即元素的个数。 range返回一个序列的数。
fruits = ['banana', 'apple', 'mango']
for index in range(len(fruits)):
print '--当前水果 :', fruits[index]
#while
count = 0
while (count < 9):
print 'The count is:', count
count = count + 1
print "while Good bye!"
#循环使用 else 语句
'''
在 python 中，for … else 表示这样的意思，for 中的语句和普通的没有区别，else 中的语句会在循环正常执行完（即 for 不是通过 break 跳出而中断的）的情况下执行，while … else 也是一样。
'''
for num in range(10,20): # 迭代 10 到 20 之间的数字
for i in range(2,num): # 根据因子迭代
if num%i == 0: # 确定第一个因子
j=num/i # 计算第二个因子
print '%d 等于 %d * %d' % (num,i,j)
break # 跳出当前循环
else: # 循环的 else 部分
print num, '是一个质数'
#pass
'''
Python pass是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句。
'''
for letter in 'Python':
if letter == 'h':
pass
print '这是 pass 块'
print '--当前字母 :', letterPython三引号（triple quotes）
#所见即所得 格式
errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
print errHTML
# 列表(List)
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
# 1 访问列表中的值
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]
# 2 更新列表
list = [] ## 空列表
list.append('Google') ## 使用 append() 添加元素
list.append('Runoob')
print list
# 3 删除列表元素
print list1
del list1[2]
print "After deleting value at index 2 : "
print list1
# 4 列表截取
L = ['Google', 'Runoob', 'Taobao']
print L[2] #'Taobao' 读取列表中第三个元素
print L[-2] #'Runoob' 读取列表中倒数第二个元素
print L[1:] #['Runoob', 'Taobao'] 从第二个元素开始截取列表
list1 = ['physics', 'chemistry', 1997, 2000]
list2 = [1, 2, 3, 4, 5 ]
list3 = ["a", "b", "c", "d"]
# 1 访问列表中的值
print "list1[0]: ", list1[0]
print "list2[1:5]: ", list2[1:5]
# 2 更新列表
list = [] ## 空列表
list.append('Google') ## 使用 append() 添加元素
list.append('Runoob')
print list
# 3 删除列表元素
print list1
del list1[2]
print "After deleting value at index 2 : "
print list1
# 4 列表截取
L = ['Google', 'Runoob', 'Taobao']
print L[2] #'Taobao' 读取列表中第三个元素
print L[-2] #'Runoob' 读取列表中倒数第二个元素
print L[1:] #['Runoob', 'Taobao'] 从第二个元素开始截取列表
元组
'''
Python的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
'''
#1 基础元组
tuptemp1 = ('physics', 'chemistry', 1997, 2000);
tuptemp2 = (1, 2, 3, 4, 5 );
tuptemp3 = "a", "b", "c", "d";
tup1 = (); #创建空元组
tup2 = (50,);#元组中只包含一个元素时，需要在元素后面添加逗号
tupshow1 = ('physics', 'chemistry', 1997, 2000);
tupshow2 = (1, 2, 3, 4, 5, 6, 7 );
print "tup1[0]: ", tupshow1[0]
print "tup2[1:5]: ", tupshow2[1:5]
#2 修改元组 元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
tupchange1 = (12, 34.56);
tupchange2 = ('abc', 'xyz');
# 以下修改元组元素操作是非法的。
# tupchange1[0] = 100;
# 创建一个新的元组
tupchange3 = tupchange1 + tupchange2;
print tupchange3;
#3 删除元组 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
tupdel = ('physics', 'chemistry', 1997, 2000);
print tupdel;
del tupdel;
print "After deleting tup : "
#print tupdel;
# 4 元组索引，截取 L[2] L[-2] L[1:]
# 5 无关闭分隔符
print 'abc', -4.24e93, 18+6.6j, 'xyz';
x, y = 1, 2;
print "Value of x , y : ", x,y;
字典
'''
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
d = {key1 : value1, key2 : value2 }
'''
# 1 赋值
dictexp = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };
dict3 = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
print "dict['Name']: ", dict3['Name'];
print "dict['Age']: ", dict3['Age'];
# 2 修改
dictchange = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
dictchange['Age'] = 8; # update existing entry
dictchange['School'] = "DPS School"; # Add new entry
print "dict['Age']: ", dictchange['Age'];
print "dict['School']: ", dictchange['School'];
# 3 删除
dictdel = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};
del dictdel['Name']; # 删除键是'Name'的条目
dictdel.clear(); # 清空词典所有条目
del dictdel ; # 删除词典
#print "dict['Age']: ", dictdel['Age'];
#print "dict['School']: ", dictdel['School'];
# 4 字典键的特性 字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行
# 4 - 1 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
dictchar = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'};
print "dict['Name']: ", dictchar['Name'];
# 4 - 2 键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行
'''
错误的例子
dict = {['Name']: 'Zara', 'Age': 7};
print "dict['Name']: ", dict['Name'];
'''
日期和时间
import time; # 引入time模块
# 1 时间戳 单位最适于做日期运算。但是1970年之前的日期就无法以此表示了。太遥远的日期也不行，UNIX和Windows只支持到2038年。
ticks = time.time()
print "当前时间戳为:", ticks
# 2 获取当前时间
localtime = time.localtime(time.time())
print "本地时间为 :", localtime
# 3 获取格式化的时间
localtime = time.asctime( time.localtime(time.time()) )
print "本地时间为 :", localtime
# 4 格式化日期
print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())# 格式化成2016-03-20 11:45:39形式
print time.strftime("%a %b %d %H:%M:%S %Y", time.localtime())# 格式化成Sat Mar 28 22:24:24 2016形式
a = "Sat Mar 28 22:24:24 2016"
print time.mktime(time.strptime(a,"%a %b %d %H:%M:%S %Y"))# 将格式字符串转换为时间戳
# 5 获取某月日历
import calendar
cal = calendar.month(2016, 1)
print "以下输出2016年1月份的日历:"
print cal;
函数
# 1 定义一个函数
'''
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
'''
# 2 语法
'''
def functionname( parameters ):
"函数_文档字符串"
function_suite
return [expression]
'''
# 3 实例
def printme( str ):
"打印传入的字符串到标准显示设备上"
print "[printme mark]"+str
return
# 4 函数调用
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");
# 5 数值
'''
1 可更改(mutable)与不可更改(immutable)对象
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
2 python 函数的参数传递：
不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
'''
# 6 使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
def printinfo( name, age ):
"打印任何传入的字符串"
print "Name: ", name;
print "Age ", age;
return;
printinfo( age=50, name="miki" );
# 7 缺省参数
def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print "Name: ", name;
print "Age ", age;
return;
printinfo( age=50, name="miki" );
printinfo( name="miki" );
# 8 不定长参数
'''
def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
'''
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print "输出: "
print arg1
for var in vartuple:
print var
return;
printinfo( 10 );
printinfo( 70, 60, 50 );
# 9 匿名函数 lambda
'''
python 使用 lambda 来创建匿名函数。
lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率
语法 lambda [arg1 [,arg2,.....argn]]:expression
'''
sum = lambda arg1, arg2: arg1 + arg2;
print "相加后的值为 : ", sum( 10, 20 )
print "相加后的值为 : ", sum( 20, 20 )
#模块
'''
Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句
'''
import support # 导入模块 见 【附1】
support.print_func("Runoob") # 现在可以调用模块里包含的函数了
# 1 From…import 语句
'''
方法 from modname import name1[, name2[, ... nameN]]
例子 from fib import fibonacci
这个声明不会把整个 fib 模块导入到当前的命名空间中，它只会将 fib 里的 fibonacci 单个引入到执行这个声明的模块的全局符号表。
'''
# 2 From…import* 语句
'''
把一个模块的所有内容全都导入到当前的命名空间也是可行的:
方法 from modname import *
'''
#命名空间和作用域
#如果要给函数内的全局变量赋值，必须使用 global 语句
Money = 2000
def AddMoney():
global Money
Money = Money + 1
return
print Money
AddMoney()
print Money
#异常
# 1 try-except-else
'''
try:
正常的操作
......................
except:
发生异常，执行这块代码
......................
else:
如果没有异常执行这块代码
'''
# 2 try-finally
'''
try-finally 语句无论是否发生异常都将执行最后的代码。
try:
<语句>
finally:
<语句> #退出try时总会执行
raise
'''
# 3 异常的参数
def temp_convert(var):
try:
return int(var)
except ValueError, Argument:
print "参数没有包含数字\n", Argument
return
temp_convert("xyz");
# 4 触发异常
'''
raise [Exception [, args [, traceback]]]
语句中Exception是异常的类型（例如，NameError）参数是一个异常参数值。该参数是可选的，如果不提供，异常的参数是"None"。
最后一个参数是可选的（在实践中很少使用），如果存在，是跟踪异常对象。
def functionName( level ):
if level < 1:
raise Exception("Invalid level!", level) # 触发异常后，后面的代码就不会再执行
'''
# 5 用户自定义异常
'''
通过创建一个新的异常类，程序可以命名它们自己的异常。异常应该是典型的继承自Exception类，通过直接或间接的方式。
以下为与RuntimeError相关的实例,实例中创建了一个类，基类为RuntimeError，用于在异常触发时输出更多的信息。
在try语句块中，用户自定义的异常后执行except块语句，变量 e 是用于创建Networkerror类的实例。
class Networkerror(RuntimeError):
def __init__(self, arg):
self.args = arg
try:
raise Networkerror("Bad hostname")
except Networkerror,e:
print e.args
'''
# 类 【搭配 附2 myclass.py】
# 1
import myclass
"创建 Employee 类的第一个对象"
emp1 = myclass.Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = myclass.Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % myclass.Employee.empCount
# 2
emp1.age = 7 # 添加一个 'age' 属性
emp1.age = 8 # 修改 'age' 属性
del emp1.age # 删除 'age' 属性
#del emp1.name #可以删除，会导致displayEmployee出错
# 3 属性
'''
getattr(obj, name[, default]) : 访问对象的属性。
hasattr(obj,name) : 检查是否存在一个属性。
setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
delattr(obj, name) : 删除属性。
'''
if hasattr(emp1, 'age') : # 如果存在 'age' 属性返回 True。
print "1 emp1 age :",getattr(emp1, 'age') # 返回 'age' 属性的值
else:
setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8
print "2 emp1 age :",getattr(emp1, 'age') # 返回 'age' 属性的值
delattr(emp1, 'age') # 删除属性 'age'
# 4 内置类属性
'''
__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
__doc__ :类的文档字符串
__name__: 类名
__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）
'''
print "Employee.__doc__:", myclass.Employee.__doc__
print "Employee.__name__:", myclass.Employee.__name__
print "Employee.__module__:", myclass.Employee.__module__
print "Employee.__bases__:", myclass.Employee.__bases__
print "Employee.__dict__:", myclass.Employee.__dict__
# 5 对象销毁(垃圾回收)
pt1 = myclass.Point()
pt2 = pt1 #引用
pt3 = pt1 #引用
print id(pt1), id(pt2), id(pt3) # 打印对象的id
del pt1
del pt2
del pt3
# 6 继承
'''
面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。
需要注意的地方：继承语法 class 派生类名（基类名）：//... 基类名写在括号里，基本类是在类定义的时候，在元组之中指明的。
在python中继承中的一些特点：
1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。
2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别在于类中调用普通函数时并不需要带上self参数
3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。
如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。
'''
c = myclass.Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法
c.setAttr(200) # 再次调用父类的方法 - 设置属性值
c.getAttr() # 再次调用父类的方法 - 获取属性值
'''
issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)
isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。
'''
# 7 方法重写
c = myclass.ChildChange() # 子类实例
c.myMethod() # 子类调用重写方法
# 8 基础重载方法
'''
1 __init__ ( self [,args...] )
构造函数
简单的调用方法: obj = className(args)
2 __del__( self )
析构方法, 删除一个对象
简单的调用方法 : del obj
3 __repr__( self )
转化为供解释器读取的形式
简单的调用方法 : repr(obj)
4 __str__( self )
用于将值转化为适于人阅读的形式
简单的调用方法 : str(obj)
5 __cmp__ ( self, x )
对象比较
简单的调用方法 : cmp(obj, x)
'''
# 9 运算符重载
v1 = myclass.Vector(2,10)
v2 = myclass.Vector(5,-2)
print v1 + v2
# 10 类属性与方法
'''
类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
类的方法
在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数
类的私有方法
__private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 self.__private_methods
'''
counter = myclass.JustCounter()
counter.add()
counter.add()
print "JustCounter result :",counter.publicCount
#print counter.__secretCount # 报错，实例不能访问私有变量
# 11 单下划线、双下划线、头尾双下划线说明：
'''
__foo__: 定义的是特殊方法，一般是系统定义名字 ，类似 __init__() 之类的。
_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了
'''
附 1 【support.py】:
#coding=utf-8
def print_func( str ):
"打印任何传入的参数"
print "[print_func]"+str
return;附 2【myclass.py】:
#coding=utf-8
#面向对象
'''
面向对象技术简介
-类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
-类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
-数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
-方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
-实例变量：定义在方法中的变量，只作用于当前实例的类。
-继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
-实例化：创建一个类的实例，类的具体对象。
-方法：类中定义的函数。
-对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
'''
# 1 以下是一个简单的 Python 类的例子
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
#end of [Employee]
'''
empCount 变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount 访问。
第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数
'''
class Test:
def prt(self):
print(self)
print(self.__class__)
#end of [Test]
#t = Test()
#t.prt()
class Point:
def __init__( self, x=0, y=0):
self.x = x
self.y = y
def __del__(self):
class_name = self.__class__.__name__
print class_name, "销毁"
#end of [Point]
class Parent: # 定义父类
parentAttr = 100
def __init__(self):
print "调用父类构造函数"
def parentMethod(self):
print '调用父类方法'
def setAttr(self, attr):
print "设置父类属性 :",attr
Parent.parentAttr = attr
def getAttr(self):
print "获取父类属性 :", Parent.parentAttr
#end of [Parent]
class Child(Parent): # 定义子类
def __init__(self):
print "调用子类构造方法"
def childMethod(self):
print '调用子类方法'
#end of [Child]
class ParentChange: # 定义父类
def myMethod(self):
print '调用父类方法'
#end of [ParentChange]
class ChildChange(ParentChange): # 定义子类
def myMethod(self):
print '调用子类方法'
#end of [ChildChange]
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)
def __add__(self,other):
return Vector(self.a + other.a, self.b + other.b)
#end of [Vector]
class JustCounter:
__secretCount = 0 # 私有变量
publicCount = 0 # 公开变量
def __init__(self):
print "JustCounter' Count : 0"
def add(self):
self.__secretCount += 1
self.publicCount += 1
print "JustCounter' Count :",self.__secretCount
#end of [JustCounter]
扫一扫
1840
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
