Python的基础语法及使用

悠悠 2021-09-14 04:30 416阅读 0赞

随着时代的日新月异，Python也越来越受人们的重视，鉴于此，我整理了一些关于Python的基础语法及如何使用这些语法的内容，供大家参阅，文中内容如有不妥之处，欢迎大家提出，本文以例子为主，叙述居少。

# 一、Python的简介 #

Python可应用于众多领域，如：数据分析、组件集成、网络服务、图像处理、数值计算和科学计算等。目前业内几乎所有大中型互联网企业都在使用Python，如：Youtube、豆瓣、知乎、Google、Yahoo!、Facebook、NASA、百度、腾讯、汽车之家、美团等。互联网公司广泛使用Python来做的事一般有：自动化运维、自动化测试、大数据分析、爬虫、Web等。

# 二、Python的特点 #

官方Python是由C开发的(也有用其他语言开发的其他非官方版本，如java、C\#等)，Python的运行速度相较与C是慢多了，Python与java、C\#相比稍显逊色。

# 三、Python的基本语法及使用 #

## 3.1 数据类型 ##

\*\* Python 中的变量赋值不需要类型声明

\*\* Python中，所有标识符可以包括英文、数字以及下划线(\_)，但不能以数字开头，区分大小写

\*\* 以下划线开头的标识符有特殊意义。如：\_foo 不能直接访问，需通过类提供的接口进行访问

\*\* 在 python 中，变量是没有类型的，如：  
a=\[1,2,3\]  
a="Runoob"  
\[1,2,3\] 是 List 类型，"Runoob" 是 String 类型，而变量 a 是没有类型，它仅仅是一个对象的引用（一个指针），可以指向 List 类型对象，也可以指向 String 类型对象。

\*\* Python3有六个标准的数据类型：  
Number（数字）  
String（字符串）  
List（列表）  
Tuple（元组）  
Dictionary（字典）  
Set（集合，Python3新加的）

## 3.2 数字 ##

Python3支持三种不同的数字类型：  
int（有符号整型）  
float（浮点型）  
complex（复数：由实数和虚数构成，用a + bj,或complex(a,b)来表示）  
\# long（长整型，注：在Python3里被去除了)  
例如：  
a=100  
print(a)  
b=1.23  
print(b)  
c=10+2j  \#复数(实数+虚数)  
print(c)

## 3.3 字符串 ##

\*\* 使用引号( ' )、双引号( " )、三引号( ''' 或 """ )来表示字符串  
\*\* 其中三引号可以由多行组成  
例1：  
a = 'word'  
b = "这是一个句子"  
c = '''这是一个段落,  
包含了多个语句'''  
print(a,b,'\\n',c)  \# 中间用空格间隔  
例2：  
str = 'Hello World!'  
print(str)  
print(str\[0\])         \# 输出字符串中的第一个字符  
print(str\[2:5\])       \# 输出字符串中第三个至第五个(不包含第5个)之间的字符串  
print(str\[2:\])        \# 输出从第三个字符开始的字符串  
print(str \* 2)        \# 输出字符串两次  
print(str + "TEST")   \# 输出连接的字符串  
\#print(str+1)         \# 错误，不可以是非字符串类型(和java不一样)  
  
\*\* 这种方法效率低  
\# python中字符串是不可变的类型，使用 + 连接两个字符串时会生成一个新的字符串，生成新的字符串  
\# 就需要重新申请内存，当连续相加的字符串很多时(a+b+c+d+e+f+...) ，效率低下就是必然的了  
print('a' + 'b' + 'c')  
  
\# 略复杂，但对多个字符进行连接时效率高，只会有一次内存的申请。  
\# 如果是对list的字符进行连接的时候，这种方法是首选  
listStr = \['a', 'b', 'c'\]   
s = ''.join(listStr)  
print(s)  
  
\# 字符串格式化，这种方法非常常用  
print('%s%s%s' % ('a', 'b', 'c'))  
print( 'Hello: %s %s %s' % ('aaa', 100, 22.3) )  
  
PS:多个变量同时赋值  
a,b,c=1,2.2,"abc"  
print(a,b,c)

## 3.4 列表 ##

List（列表）是Python中使用最频繁的数据类型  
列表支持字符，数字，字符串，还可以包含列表（即嵌套）  
  
list = \[ 'runoob', 786 , 2.23, 'john', 70.2 \]  
tinylist = \[123, 'john'\]  
print(list)               \# 输出完整列表  
list\[0\]='aaa'  
print(list\[0\])            \# 输出列表的第一个元素  
print(list\[1:3\])          \# 输出第二个至第三个的元素，不包括第三个  
print(list\[2:\])           \# 输出从第三个开始至列表末尾的所有元素  
print(tinylist \* 2)       \# 列表元素重复两次  
print(list + tinylist)    \# 将两个列表合并

## 3.5 元组 ##

\*\* 元组是另一种数据类型，类似于List（列表）。  
\*\* 元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。  
  
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )  
tinytuple = (123, 'john')  
print(tuple)               \# 输出完整元组  
\# tuple\[0\]='aaa'           \# 错误  
print(tuple\[0\])            \# 输出元组的第一个元素  
print(tuple\[1:3\])          \# 输出第二个至第三个的元素  
print(tuple\[2:\])           \# 输出从第三个开始至列表末尾的所有元素  
print(tinytuple \* 2)       \# 输出元组两次  
print(tuple + tinytuple)   \# 打印组合的元组

## 3.6 字典 ##

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())    \# 输出所有值

## 3.7 set ##

\*\* Python3新加入的

student = \{'Tom','Jim', 'Mary', 'Tom', 'Jack', 'Rose'\}  
print(student)   \#重复的元素被自动去掉  
  
if('Rose' in student) :  
    print('Rose 在集合中')  
else :  
    print('Rose 不在集合中')  
  
\# set可以进行集合运算  
a = set('abcde')  
b = set('abcfg')  
print(a)  
print(b)  
print(a - b)     \# a和b的差集  
print(a | b)     \# a和b的并集  
print(a & b)     \# a和b的交集  
print(a ^ b)     \# a和b中不同时存在的元素

## 3.8 bytes类型 ##

\*\* Python3新添加的  
  
b = b'china'  
print(b\[0\])     \#打印出的是ascii码  
print(type(b))  \#查看类型  
s = b.decode()  \#转换为字符串  
print(s)  
b1 = s.encode() \#转换为bytes类型  
print(b1)

## 3.9 可变与不变 ##

在 python 中，string, tuple, 和 number 是不可更改的对象，而 list,dict 等则是可以修改的对象。  
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。  
可变类型：变量赋值 list=\[1,2,3,4\] 后再赋值 list\[2\]=5 则是将llist的第三个元素值更改， list本身没有动，只是其内部的一部分值被修改了。

## 3.10 运算符 ##

print(2\*\*3)  \#8 求幂  
print(10//3) \#3 求整数商  
print(1/2)   \#0.5，和其他语言有所不同  
  
a=100  
a+=1  \#没有a++  
print(a)  
  
关系运算符： > < == != (<>在Python3中不支持) >= <=

## 3.11 逻辑运算符 ##

\# 0为假，非0为真  
a = 10  
b = 20

if (a and b):  
    print("1 - 变量 a 和 b 都为 true")  
else:  
    print("1 - 变量 a 和 b 有一个不为 true")  
  
  
if (a or b):  
    print("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")  
else:  
    print("2 - 变量 a 和 b 都不为 true")  
  
  
  
\# 修改变量 a 的值  
a = 0  
if (a and b):  
    print("3 - 变量 a 和 b 都为 true")  
else:  
    print("3 - 变量 a 和 b 有一个不为 true")  
  
  
  
if (a or b):  
    print("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")  
else:  
    print("4 - 变量 a 和 b 都不为 true")  
  
  
  
if not (a and b):  
    print("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")  
else:  
    print("5 - 变量 a 和 b 都为 true")

## 3.12 成员运算符 ##

\#in、not in  
a = 1  
b = 20  
list = \[1, 2, 3, 4, 5\];  
  
  
if (a in list):  
    print("1 - 变量 a 在给定的列表中 list 中")  
else:  
    print("1 - 变量 a 不在给定的列表中 list 中")  
  
  
if (b not in list):  
    print("2 - 变量 b 不在给定的列表中 list 中")  
else:  
    print("2 - 变量 b 在给定的列表中 list 中")

## 3.13 身份运算符 ##

\# is 是判断两个标识符是不是引用自一个对象，x is y 类似 id(x) == id(y)  
\# is 与 == 区别：is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等  
  
  
a = 20  
b = 20  
print(a is b)  
print(a is not b)  
  
  
\# 修改变量 b 的值  
b = 30  
print(a is b)  
print(a is not b)

## 3.14 代码组 ##

\*\* Python与其他语言最大区别是，Python代码块不使用大括号 \{\}   
\*\* Python最具特色的就是用缩进来写模块  
  
  
\*\* 缩进相同的一组语句构成一个代码块，我们称之代码组  
\*\* 像if、while、def和class等首行以关键字开始，以冒号结束，该行之后的一行或多行代码构成"代码组"  
\*\* 我们将首行及后面的代码组称为一个"子句"(clause)  
\*\* 缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行!!!  
例如：  
if expression :   
   suite \#代码组  
elif expression :    
   suite    
else :    
   suite   
例如：(注意：没有严格缩进，在执行时会报错)  
\*\* 通过coding属性支持中文(在不支持中文时，加上该句)  
\*\* 下面代码会报缩进错误IndentationError  
  
\#!/usr/bin/python  
\# -\*- coding: UTF-8 -\*-  
if True:  
    print("aaa")  
    print("True")  
else:  
    print("bbb")  
  print("False")  \#注意缩进，只要对齐就行，至于用空格还是用tab对齐没区别  
  
PS：   
有些环境下，tab和空格不可以混用，有些环境下可以。  
因此建议在每个缩进层统一使用'单个制表符'、'两个空格'或'四个空格'，尽量不要混用，以避免不必要的麻烦。

## 3.15 while、continue、break、for、pass ##

====while====  
  
  
count = 0  
while count < 10 :  
\#while (count < 10) :  \#也可以  
   print('The count is:', count)  
   count = count + 1  
  
====while … else====  
  
\*\* 循环条件为false时，执行else语句块，只执行一次  
  
count = 0  
while count < 5:  
   print(count, " is  less than 5")  
   count = count + 1  
else:  
   print(count, " is not less than 5")  
  
====continue====  
  
i = 1  
while i < 10:  
    i += 1  
    if i%2!=0 :     \# 非双数时跳过输出  
        continue  
    print(i)         \# 输出双数2、4、6、8、10  
  
====break====  
  
i = 1  
while True :  
    print(i)  
    i += 1  
    if i > 10:     \# 当i大于10时跳出循环  
        break  
  
====for====  
  
  
for letter in 'Python' :  
    print('当前字母 :', letter)  
\----------------------------------  
fruits = \['banana', 'apple', 'mango'\]  
for fruit in fruits :  
    print('当前水果 :', fruit)  
\----------------------------------  
\*\* 通过序列索引迭代  
  
fruits = \['banana', 'apple',  'mango'\]  
for index in range(len(fruits)):  
\#for index in range(3): \#效果相同，即(1,2,3)  
   print('当前水果 :', fruits\[index\])  
  
====for...else====  
  
for num in range(2,10):  \# 迭代 2 到 10 之间的数字  
   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====  
  
\*\* pass语句不做任何事情，一般用做占位  
  
for letter in 'Python':  
   if letter == 'h':  
      pass  
      print('这是 pass 块')  
   else:  
      print('当前字母 :', letter)

# 四、函数 #

\*\* 函数代码块以 def 关键词开头  
\*\* 函数内容以冒号起始，并且缩进  
\*\* 函数的第一行语句可以是字符串，用于函数说明  
\*\* return \[表达式\] 结束函数，不带返回值表达式的相当于返回None  
语法：  
def functionname( parameters ):  
   "函数\_文档字符串"  
   function\_suite  
   return \[expression\]

## 4.1 参数传递 ##

### 4.1.1 不可变类型 ###

对于不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值， 没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。  
  
def ChangeInt( a ):  
    a = 10  
  
b = 2  
ChangeInt(b)  
print(b) \# 结果是 2

### 4.1.2 可变类型 ###

对于可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（list），则是将 list 真正的传过去，修改后fun外部的list也会受影响。  
  
def changeme(mylist):  
    mylist.append(50);  
    print(mylist)  
    return  
  
mylist = \[10, 20, 30\];  
changeme(mylist);  
print(mylist)  
  
PS:  
python中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

### 4.1.3 通过参数名赋参 ###

def printinfo(name, age):  
    print("Name: ", name)  
    print("Age ", age)  
    return;  
  
printinfo(age=50, name="miki");

### 4.1.4 默认参数 ###

def printinfo(name, age=35):  
    print("Name: ", name)  
    print("Age ", age)  
    return;  
  
printinfo(age=50, name="miki");  
printinfo("miki");

### 4.1.5 变长参数 ###

def printinfo(arg1, \*vartuple):  
    print("输出: ")  
    print(arg1)  
    for x in vartuple:  
        print(x)  
    return;  
  
printinfo(10);  
printinfo(20,30,40,50);

## 4.2 lambda函数 ##

lambda只是一个表达式，函数体比def简单很多  
lambda主体是一个表达式，而不是一个代码块，仅仅能在lambda表达式中封装有限的逻辑进去  
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数  
Python仅仅将 lambda 定位成一个辅助用的短函数，所以lambda只能写一行，不能赋值，内部也不能定义等  
  
sum = lambda arg1, arg2: arg1 + arg2  
print(sum(10, 20))  
  
def makeSum():  
    sum = lambda arg1, arg2: arg1 + arg2  
    return sum  
  
f = makeSum()  
print(f(10, 20))

## 4.3 返回值 ##

def sum(arg1, arg2):  
    total = arg1 + arg2  
    print("函数内 : ", total)  
    return total  
  
total = sum(10, 20)  
print("函数外 : ", total)

## 4.4 函数类型参数 ##

def add(x, y, f):  
    return f(x) + f(y)  
  
print(abs(-3))  \#绝对值  
print(add(-3, 5, abs)) \#当函数作为参数时，不可以加()

## 4.5 全局变量和局部变量 ##

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。  
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。  
  
total = 0;  \# 这是一个全局变量  
  
def sum(arg1, arg2):  
    \#total = arg1 + arg2; \#注意此处注解取消后的不同，若有同名变量的话，局部变量的优先级高于全局变量  
    print(total)  
    return total;  
  
sum(10, 20);  
print(total)

## 4.6 global ##

\*\* global:将函数内变量定义为全局变量，可以通过定义为全局变量，实现在函数内部改变变量值  
  
\#globvar = 0 \#此处globvar的定义可有可无  
  
def set\_globvar\_to\_one():  
    global globvar    \# 使用 global 声明全局变量  
    globvar = 1  
  
def print\_globvar():  
    print(globvar)     \# 没有使用 global  
  
set\_globvar\_to\_one()  
print(globvar)        \# 输出 1  
print\_globvar()       \# 输出 1，函数内的 globvar 已经是全局变量

## 4.7 模块 ##

Python模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。  
模块让你能够有逻辑地组织你的 Python 代码段。  
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。  
模块能定义函数，类和变量，模块里也能包含可执行的代码。

\----support.py-----------  
  
\#support模块  
  
def print\_func( s ):  
   print("Hello : ", s)  
   return  
  
\----hello.py-------------  
  
\# 方式一  
import support  
support.print\_func("Tom")  
  
\# 方式二  
from support import print\_func  
print\_func("Tom")  
  
\# 方式三  
from support import \*  
print\_func("Tom")

## 4.8 输入与类型转换 ##

import sys  
\# 输入一个字符串  
\#s=sys.stdin.readline()  
\#print(s)  \#输入字符串的末尾会多出一个字符'\\n'，例如，输入的是'abc'，得到的是'abc\\n'，因此长度会加1  
s='100'  
a=int(s)  
b=float(a)  
b+=1  
s=str(b)  
print(s)

## 4.9 命名空间和作用域 ##

变量是拥有匹配对象的名字（标识符）。命名空间是一个包含了变量名称们（键）和它们各自相应的对象们（值）的字典。  
一个Python表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名，则局部变量会覆盖全局变量。  
每个函数都有自己的命名空间。类的方法的作用域和通常函数的一样。

## 4.10 包 ##

包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。  
简单来说，包就是文件夹，该文件夹下必须存在 \_\_init\_\_.py 文件, 其内容可以为空，\_\_int\_\_.py用于标识当前文件夹是一个包  
  
目录结构如下：  
hello.py  
mypackage(文件夹)  
|-- \_\_init\_\_.py  
|-- runoob1.py  
|-- runoob2.py  
  
runoob1.py:  
def f1():  
   print("I'm in runoob1")  
     
runoob2.py  
def f2():  
   print("I'm in runoob2")  
     
hello.py:  
from mypackage.runoob1 import f1  
from mypackage.runoob2 import f2  
f1()  
f2()  
  
import sys  
s = sys.stdin.readline()  
print(s)

## 4.11 异常处理 ##

BaseException: 所有异常的基类  
  
try:  
    print(1/0)  
except IOError:  
    print("IOError")  
except ZeroDivisionError:  
    print("ZeroDivisionError")  
else:  \#无异常时  
    print("esle")  
finally:  
    print("finally")

# 五、类 #

\*\* 类方法必须包含参数self,且为第一个参数  
  
class Employee:  
    '所有员工的基类'  \#第一行可以用字符串来做说明  
  
    \#empCount是一个类变量，在这个类的所有实例之间共享,使用Employee.empCount来访问  
    empCount = 0  
  
    \#构造器  
    \#self代表类的实例，在定义时必须有，在调用时不必传值  
    \#参数为属性  
    def \_\_init\_\_(self, name, salary):  
        self.name = name  
        self.salary = salary  
        Employee.empCount += 1  
  
    def displayCount(self): \#self不可以省略  
        print("Total Employee %d" % Employee.empCount)  
  
    def displayEmployee(self):  
        print("Name : ", self.name, ", Salary: ", self.salary)  
  
a=Employee("zhangsan",5000)  
print(Employee.empCount,a.name,a.salary)  
a.age=26 \#添加属性  
print(a.age)  
del a.age  \#删除属性  
\#print(a.age)  
  
b=Employee("lisi",5000)  
print(Employee.empCount,b.name,b.salary)  
b.displayCount()  
b.salary=6000  
b.displayEmployee()  
print(b)

## 5.1 关于self ##

self 代表的是类的实例，代表当前对象的地址，而 runoob.\_\_class\_\_ 指向类  
self 不是关键字，换成其他也可以，如：runoob  
  
class Test:  
    def myprint(runoob):  
        print(runoob)  
        print(runoob.\_\_class\_\_)  
  
t = Test()  
t.myprint()

## 5.2 内置类属性 ##

\_\_doc\_\_  : 类的文档字符串  
\_\_name\_\_ : 类名  
\_\_module\_\_:  类定义所在的模块 （类的全名是'\_\_main\_\_.className'，如果类位于一个导入模块mymodule中，那么\_\_module\_\_即为 mymodule）  
\_\_bases\_\_ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）  
\_\_dict\_\_  : 类的属性（包含一个字典，由类的数据属性组成）  
  
class Employee:  
    '雇员类'  
    empCount = 0  
  
print("Employee.\_\_doc\_\_:", Employee.\_\_doc\_\_)  
print("Employee.\_\_name\_\_:", Employee.\_\_name\_\_)  
print("Employee.\_\_module\_\_:", Employee.\_\_module\_\_)  
print("Employee.\_\_bases\_\_:", Employee.\_\_bases\_\_)  
print("Employee.\_\_dict\_\_:", Employee.\_\_dict\_\_)

## 5.3 python对象销毁(垃圾回收) ##

Python 使用了引用计数这一简单技术来跟踪和回收垃圾  
在 Python 内部记录着所有使用中的对象各有多少引用  
当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收  
  
如：  
a = 40      \# 创建对象  <40>  
b = a       \# 增加引用， <40> 的计数  
c = \[b\]     \# 增加引用.  <40> 的计数  
  
del a       \# 减少引用 <40> 的计数  
b = 100     \# 减少引用 <40> 的计数  
c\[0\] = -1   \# 减少引用 <40> 的计数

## 5.4 析构函数 ##

\*\* 析构函数\_\_del\_\_在对象销毁的时候被调用  
  
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, "销毁")  
  
pt1 = Point()  
pt2 = pt1  
pt3 = pt1  
print(id(pt1), id(pt2), id(pt3))  \#打印对象的id  
del pt1  
del pt2  
del pt3

## 5.5 继承 ##

基类构造器（\_\_init\_\_()）不会被自动调用  
Python先在本类中查找调用的方法，找不到才去基类中找  
如果在继承元组中列了一个以上的类，那么它就被称作"多重继承"   
  
class Parent:  \#父类  
    parentAttr = 100  
  
    def \_\_init\_\_(self):  
        print("调用父类构造函数")  
  
    def parentMethod(self):  
        print('调用父类方法')  
  
    def setAttr(self, attr):  
        Parent.parentAttr = attr  
  
    def getAttr(self):  
        print("父类属性 :", Parent.parentAttr)  
  
class A:  
    a=0  
  
class Child(Parent,A):  \#子类，多重继承  
    def \_\_init\_\_(self):  
        print("调用子类构造方法")  
  
    def childMethod(self):  
        print('调用子类方法')  
  
c = Child()  \# 实例化子类  
c.childMethod()  \# 调用子类的方法  
c.parentMethod()  \# 调用父类方法  
c.setAttr(200)  \# 再次调用父类的方法 - 设置属性值  
c.getAttr()  \# 再次调用父类的方法 - 获取属性值

## 5.6 方法重写 ##

class Parent:  \# 定义父类  
    def myMethod(self):  
        print('调用父类方法')  
  
class Child(Parent):  \# 定义子类  
    def myMethod(self):  
        print('调用子类方法')  
  
c = Child()   \# 子类实例  
c.myMethod()  \# 子类调用重写方法

## 5.7 运算符重载 ##

\*\* 注：Python不支持函数重载  
  
常见重载方法：  
Method        Overloads        Call for  
\------          ----------          ---------  
\_\_init\_\_        构造函数        X=Class()  
\_\_del\_\_        析构函数        对象销毁  
\_\_add\_\_        \+                X+Y,X+=Y  
\_\_sub\_\_         -                   X-Y,X-=Y  
\_\_or\_\_        |                X|Y,X|=Y  
\_\_repr\_\_        打印转换        print X，repr(X)  
\_\_str\_\_        打印转换        print X，str(X)  
\_\_call\_\_        调用函数        X()  
\_\_getattr\_   限制            X.undefine  
\_\_setattr\_\_    取值            X.any=value  
\_\_getitem\_\_    索引            X\[key\]，               
\_\_len\_\_        长度            len(X)  
\_\_cmp\_\_        比较            X==Y,X<Y  
\_\_lt\_\_        小于            X<Y  
\_\_eq\_\_        等于            X=Y  
\_\_radd\_\_        Right-Side +        \+X  
\_\_iadd\_\_        +=                X+=Y  
\_\_iter\_\_        迭代            For In

## 5.8 加号重载 ##

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)  
  
v1 = Vector(2, 10)  
v2 = Vector(6, 1)  
print(v1 + v2)

## 5.9 减号重载 ##

class Number:  
    def \_\_init\_\_(self, start):  
        self.data = start  \#添加属性  
  
    def \_\_sub\_\_(self, other):  \# minus method  
        return Number(self.data - other)  
  
number = Number(30)  
y = number - 10  
print(y.data) \#20

## 5.10 私有 ##

\*\* 私有属性：两个下划线开头，不能在类的外部使用，类内部使用时用self.\_\_XXX  
   但可以使用 object.\_className\_\_attrName来访问私有属性  
私有方法：两个下划线开头，不能在类的外部调用，类内部调用时用self.\_\_private\_methods  
  
class JustCounter:  
    \_\_secretCount = 0  \# 私有变量  
    publicCount = 0    \# 公有变量  
  
    def count(self):  
        self.\_\_secretCount += 1  
        self.publicCount += 1  
        print(self.\_\_secretCount)  
  
counter = JustCounter()  
counter.count()  
print(counter.publicCount)  
\#print(counter.\_\_secretCount)  \#错误  
print(counter.\_JustCounter\_\_secretCount)

补充：单下划线、双下划线、头尾双下划线说明：  
  
1 \_\_XXX\_\_: 定义的是特殊方法，如 \_\_init\_\_() 之类  
2 \_foo: 以单下划线开头的表示的是 protected 类型的变量，  
        即保护类型只能允许其本身与子类进行访问，不能用于 from module import \*  
3 \_\_foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了