Python快速笔记-1-语言基础

最新推荐文章于 2021-03-26 12:06:59 发布

for_sun_read

最新推荐文章于 2021-03-26 12:06:59 发布

阅读量209

点赞数

分类专栏： Python 文章标签： Python

本文链接：https://blog.csdn.net/for_sun_read/article/details/79145849

版权

Python 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

中文编码问题

#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 '--当前字母 :', letter

Python三引号（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]

for_sun_read

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Python快速笔记-1-语言基础

中文编码问题#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;mes
复制链接

扫一扫

专栏目录