Python 学习笔记

发表于 | 更新于 | 评论数： | 阅读次数：

基础事项

变量命名

  • 变量名尽量小写
  • 类名首字母大写

括号与数据类型

括号 数据类型 例子
[] 列表 [123,’abc’,1.23]
() 元组 (1,2,3,4))
{} 字典 {‘name’:’wa’,’age’:20}

其它

  • = 操作符代表赋值，例如：x = 10，执行结果，x 赋值为 10；
  • == 操作符代表等于判断，例如：1 == 2，执行结果为 False。

Python 2 和 3 差异

  • print 在3中不是一个保留字，也不是一条语句，而是一个内置的函数调用。

python交互模式下清屏

在Linux shell中，清屏操作是clear；在Win cmd中，清屏操作是cls。

在交互模式中使用python，如果要清屏，可以import os，通过os.system()来调用系统命令clear或者cls来实现清屏。

1
2
>>> import os
>>> os.system('clear')

但是此时shell中的状态是：

1
2
0
>>>

首行会有一个0。这个0实际上是os.system()的返回值，0是成功，非零即error code（具体os.system()与命令返回值的对应关系可参考这里）。

可以存储这个返回值，不让其打印出来：

1
2
>>> import os
>>> t = os.system('clear')

这样就是真正的清屏了：

1
>>>

python下编译 .py 为 .pyc

生成单个pyc文件：
命令：

1
2
python -m py_compile file.py
python -m py_compile /root/src/{file1,file2}.py

脚本：

1
2
import py_compile
py_compile.compile('path') //path是包括.py文件名的路径

批量生成pyc文件：
命令：

1
python -m compileall /root/src/

脚本：

1
2
import compileall
compileall.compile_dir(r'H:\game')

生成pyc文件后删除原py文件，直接执行pyc文件（方法同py文件）

Python语句和语法

语句

语句 角色 例子
赋值 创建引用值 a,b,c = ‘good’,’bad’,’ugly’
调用 执行函数 log.write(‘hello,world’)
打印调用 打印对象 print(“hello world”)
if/elif/else 选择动作 if ‘print’ in text: print(text)
for/else 序列迭代 for x in mylist: print(x)
while/else 一般循环 while x>y: print(“hello”)
pass 空占位符 while True: pass
break 循环退出 while True:
    if exittest(): break
continue 继续下一次循环 while True:
    if skiptest(): continue
def 函数和方法 def f(a,b,c=1,*d):
    print(a+b+c+d[0])
return 函数返回结果 def f(a,b,c=1,*d):
    return a+b+c+d[0]
yield 生成器表达式 def gen(n):
    for i in n:yield i * 2
global 命名空间，全局变量 x = ‘old’
def function(x):
    global x,y,;x = ‘new’
nonlocal 局部变量（python3.0+） def outer():
    x = ‘old’
    def function():
        nonlocalx;n=’new’
import 模块访问，导入 import sys
from 模块属性访问 from sys import stdin
class 创建对象 class Subclass(Superclass):
    staticData = []
    def method(self): pass
try/except/finally 捕捉异常 try:
    action()
except:
    print(‘action error’)
raise 触发异常 raise EbdSearch(location)
assert 调试检查 assert x>y,’x  too small’
with/as 环境管理器 with open(‘data’) as myfile:
    process(myfile)
del 删除引用 del data[k]
del data[i:j]
del obj.attr
del variable

语法

与其他语言的比较

1
2
3
4
if ( x > y) {
    x = 1;
    y = 2;
}

上面可能是 c、c++、Java 或者其他语言语句。下面是与之等价的 Python 语言语句：

1
2
3
if x > y:       # 可以没有 ()，也可以有
    x = 1
    y = 2

数学操作符

优先级从高到低

操作符 操作 例子 求值为
** 指数 2**3 8
% 取模/取余数 22%8 6
// 整除/商数取整 22//8 2
/ 除法 22/8 2.75
- 减法 5-2 3
+ 加法 2+2 4

增强赋值操作符

针对+、-、*、/和%，都有增强的赋值操作符，如下表：

增强的赋值语句 等价的赋值语句
spam += 1 spam = spam+1
spam -= 1 spam = spam-1
spam /= 1 spam = spam/1
spam %= 1 spam = spam%1

转义操作符

转义字符 描述
\(在行尾时) 续行符
\\ 反斜杠符号
\‘ 单引号
\“ 双引号
\a 响铃
\b 退格(Backspace)
\e 转义
\000 空
\n 换行
\v 纵向制表符
\t 横向制表符
\r 回车
\f 换页
\oyy 八进制数，yy代表的字符，例如：\o12代表换行
\xyy 十六进制数，yy代表的字符，例如：\x0a代表换行
\other 其它的字符以普通格式输出

比较运算符

表达式 描述
x == y x等于y
x !=y x不等于y
x < y x小于y
x >= y x大于或等于y
x is y x和y是同一个对象
x is not y x和y是不同的对象
x in y x是容器（如序列）y的成员
x not in y x不是容器（如序列）y的成员

x not in y 等同于 not x in y,前者更符合常识，与其他语言一致

True 和 False

注意，首字母大写。在Python中任何对象都可判断其布尔值，除了0、0.0、''、None和所有空的序列与集合（列表，字典，集合）布尔值为False之外，其它的都为True，我们可以使用函数bool()进行判别：

1
2
3
4
5
6
7
8
9
10
>>> bool('-1')
True
>>> bool(-1)
True
>>> bool(0)
False
>>> bool('')
False
>>> bool(None)
False

in 和 not in 操作符

1
2
3
4
5
6
7
8
>>> 'bat' in ['cat','bat','rat','elephant']
True
>>> 'dog' in ['cat','bat','rat','elephant']
False
>>> 'dog' not in ['cat','bat','rat','elephant']
True
>>> not 'dog' in ['cat','bat','rat','elephant']
True

条件判断

1
2
3
4
5
6
7
8
9
>>> x = 6
>>> if x > 10:
...     print('>10')
... elif x == 10:
...     print('=10')
... else:
...     print('<10')
...
<10

循环

for 循环

1
2
3
4
5
6
7
>>> for c in 'spam':
...     print(c.upper())
...
S
P
A
M

嵌套循环

1
2
3
4
5
6
7
8
9
>>> for i in range(1,10):
...     for j in range(1,10):
...         print('{} X {} = {}'.format(i,j,i*j))
...
1 X 1 = 1
1 X 2 = 2
1 X 3 = 3
...
9 X 9 = 81

while 循环

1
2
3
4
5
6
7
8
9
>>> x=4
>>> while x>0:
...     print('spam!' * x)
...     x-=1
...
spam!spam!spam!spam!
spam!spam!spam!
spam!spam!
spam!

break 和 continue

1
2
3
4
5
6
7
8
9
10
11
12
>>> x=5
>>> while x > 0:
...     x -= 1
...     if x == 4:
...         continue
...     elif x == 1:
...         break
...     else:
...         print('spam!' * x)
...
spam!spam!spam!
spam!spam!

局部和全局作用域

局部变量不能在全局作用域内使用

1
2
3
4
5
6
def spam():
    eggs = 222


spam()
print(eggs)

输出结果

1
2
3
4
Traceback (most recent call last):
  File "g:/WaProj/PyHello/test.py", line 20, in <module>
    print(eggs)
NameError: name 'eggs' is not defined

局部作用域不能使用其他局部作用域内的变量

例子

1
2
3
4
5
6
7
8
9
10
11
12
def spam():
    eggs = 99
    bacon()
    print(eggs)


def bacon():
    ham = 101
    eggs = 0


spam()

输出结果

1
99

全局变量可以在局部作用域中读取

  • 例子，局部作用域中不赋值变量，则使用全局变量
1
2
3
4
5
6
7
def spam():
    print(eggs)


eggs = 42
spam()
print(eggs)

输出结果

1
2
42
42
  • 例子，局部作用域中赋值变量，则使用局部变量
1
2
3
4
5
6
7
8
def spam():
    eggs = 11
    print(eggs)


eggs = 42
spam()
print(eggs)

输出结果

1
2
11
42
  • 例子，局部作用域中先使用变量，之后定义（赋值）变量，则会出错
1
2
3
4
5
6
7
8
def spam():
    print(eggs)
    eggs = 11


eggs = 42
spam()
print(eggs)

输出结果

1
2
3
4
5
6
Traceback (most recent call last):
  File "g:/WaProj/PyHello/test.py", line 7, in <module>
    spam()
  File "g:/WaProj/PyHello/test.py", line 2, in spam
    print(eggs)
UnboundLocalError: local variable 'eggs' referenced before assignment

因为 spam 函数中有针对 eggs 的赋值语句，因此 Python 认为 eggs 是局部变量。但 print(eggs)的执行在 eggs 赋值之前，局部变量 eggs 并不存在，因此出错。

global 语句

例子，在函数内用 global 修饰符指定使用全局变量

1
2
3
4
5
6
7
def spam():
    global eggs
    eggs = 'spam'

eggs = 'global'
spam()
print(eggs)

输出结果

1
spam

异常处理 try

例子1，用 try 和 except 语句处理异常

1
2
3
4
5
6
7
8
9
10
def spam(divideBy):
    return 42 / divideBy

try:
    print(spam(2))
    print(spam(12))
    print(spam(0))
    print(spam(1))
except ZeroDivisionError:
    print('Error: Invalid argument.')

输出结果

1
2
3
21.0
3.5
Error: Invalid argument.

例子2，用 try 和 except 语句处理异常

1
2
3
4
5
6
7
8
9
10
def spam(divideBy):
    try:
        return 42 / divideBy
    except ZeroDivisionError:
        print('Error:无效参数')

print(spam(2))
print(spam(12))
print(spam(0))
print(spam(1))

输出结果

1
2
3
4
5
21.0
3.5
Error:无效参数
None
42.0

字符串

字符串格式化

  • 表达式形式 %
1
2
>>> '%s,bbb,%s' % ('aaa','ccc')			#格式化表达式
'aaa,bbb,ccc'
  • 字符串方法调用 str.format()
1
2
3
4
5
6
7
8
9
10
>>> '{0},bbb,{1}'.format('aaa','ccc')		#格式化方法(2.6，3.0)
'aaa,bbb,bbb'
>>> '{1},bbb,{0}'.format('aaa','ccc')   # 位置变化
'ccc,bbb,aaa'
>>> '{},bbb,{}'.format('aaa','ccc')
'aaa,bbb,ccc'
>>> '{},bbb,{c:.2f}'.format('aaa',c=2)		#:f 小数表示为定点数
'aaa,bbb,2.00'
>>> '{},bbb,{c:b}'.format('aaa',c=55)		#:b 整数表示为二进制数
'aaa,bbb,110111'
  • f 字符串 - 在字符串前加上 f
1
2
3
>>> a='Python'
>>> f'Hello {a}'
'Hello Python'
  • 模板字符串
1
2
3
>>> from string import Template
>>> Template('Hello $who and $terminal').substitute(who='Python',terminal='Cmder')
'Hello Python and Cmder'

联合与拆分

  • 联合 join()
1
2
3
4
>>> '/'.join(['','usr','bin','env'])
'/usr/bin/env'
>>> '/'.join(('','usr','bin','env'))
'/usr/bin/env'
  • 拆分 split
1
2
>>> '/usr/bin/env'.split('/')
['', 'usr', 'bin', 'env']

切片

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
>>> s='12345654321'
>>> s[0:1]
'1'
>>> s[0:2]
'12'
>>> s[1:2]
'2'
>>> s[1:3]
'23'
>>> s[-1]
'1'
>>> s[-5:]
'54321'
>>> s[:-5]
'123456'

列表

创建数值列表 range()

1
2
3
4
>>> range(1,5)
range(1, 5)
>>> list(range(1,5))
[1, 2, 3, 4]

遍历列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> for v in range(1,5):
...     print(v)
...
1
2
3
4

>>> r=[]
>>> for v in range(1,5):
...     r.append(v**2)
...
>>> print(r)
[1, 4, 9, 16]

列表解析

1
2
>>> [v**2 for v in range(1,5)]
[1, 4, 9, 16]

列表简单计算统计

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> r=0
>>> for v in range(1,5):
...     r+=v
...
>>> r
10

>>> sum(range(1,5))
10
>>> min(range(1,5))
1
>>> max(range(1,5))
4

多重赋值

一般方式

1
2
3
4
>>> cat = ['fat','black','looud']
>>> size = cat[0]
>>> color = cat[1]
>>> disposition = cat[2]

多重赋值方式

1
2
>>> cat = ['fat','black','looud']
>>> size,color,disposition = cat

用 del 删除列表值

1
2
3
4
5
6
7
>>> spam=['cat','bat','rat','elephant']
>>> del spam[2]
>>> spam
['cat', 'bat', 'elephant']
>>> del spam[2]
>>> spam
['cat', 'bat']

用 remove 方法删除列表值

1
2
3
4
>>> cat = ['fat','black','looud']
>>> cat.remove('black')
>>> cat
['fat', 'looud']

如果该值在列表中多次出现，只删除第一个。

元组 tuple

元组与列表几乎一样，区别在于：1.元组用 ()，列表用[]。2.元组和字符串一样，不可改变。

1
2
3
4
5
6
7
8
9
>>> eggs=('hello',42,0.5)
>>> eggs
('hello', 42, 0.5)
>>> eggs[0]
'hello'
>>> eggs[1:3]
(42, 0.5)
>>> len(eggs)
3

如果元组中只有一个值，需要在该值后面跟上一个逗号，表明这是一个元组，比如：

1
2
3
4
>>> type(('hello',))
<class 'tuple'>
>>> type(('hello'))
<class 'str'>

用 list() 和 tuple() 函数转换类型

如同 str(12) 将返回 ‘12’ 类似，list() 和 tupel() 返回列表和元组类型。

1
2
3
4
5
6
7
8
>>> list(('hello',42,0.5))
['hello', 42, 0.5]
>>> tuple(['hello',42,0.5])
('hello', 42, 0.5)
>>> list('hello')
['h', 'e', 'l', 'l', 'o']
>>> tuple('hello')
('h', 'e', 'l', 'l', 'o')

引用与 copy() 、 deepcopy()

引用

  • 对字符串和数值进行引用赋值时，直接复制的内容，即在内从中重新分配了内存空间，用来存放新的对象：
1
2
3
4
5
6
7
8
>>> spam='a'
>>> cheese=11
>>> cheese=spam
>>> spam=100
>>> spam
100
>>> cheese
'a'
  • 列表引用赋值时，指向的是对象所在的内存地址，因此指向的内容是一致的，如下所示：
1
2
3
4
5
6
7
8
9
10
11
12
>>> spam=[0,1,2,3,4,5]
>>> cheese=spam
>>> cheese[1]='hi'
>>> spam
[0, 'hi', 2, 3, 4, 5]
>>> cheese
[0, 'hi', 2, 3, 4, 5]
>>> spam[3]='ah'
>>> spam
[0, 'hi', 2, 'ah', 4, 5]
>>> cheese
[0, 'hi', 2, 'ah', 4, 5]

coyp() 和 deepcopy()

  • copy() 不是简单引用，而是分配新的内存地址给新变量并赋值
1
2
3
4
5
6
7
8
9
>>> spam = list('ABCD')
>>> spam
['A', 'B', 'C', 'D']
>>> cheese = copy.copy(spam)
>>> cheese[1] = 22
>>> cheese
['A', 22, 'C', 'D']
>>> spam
['A', 'B', 'C', 'D']
  • deepcopy()深拷贝，相对于copy()的浅拷贝(shallow copy)，如果要复制的列表中包含了列表，就用copy.deepcopy()。

字典

创建字典

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 常见方式
>>> d={'name':'wa','age':20}
>>> d
{'name': 'wa', 'age': 20}

# 另一种创建方式
>>> d={}
>>> d['name']='wa'
>>> d['age']=20
>>> d
{'name': 'wa', 'age': 20}

# dict() 函数
>>> dict([('name','wa'),('age',20)])	# []可以
{'name': 'wa', 'age': 20}
>>> dict({('name','wa'),('age',20)})	# {}也可以
{'age': 20, 'name': 'wa'}

字典使用

1
2
3
4
5
6
>>> d={'name':'wa','age':20}
>>> d['name']
'wa'
>>> d['name'] + ' ' + str(d['age']) + ' 岁了！'
'wa 20 岁了！'
>>>

遍历键–值

  • 键值对 items()
1
2
3
4
5
6
7
8
9
10
11
12
13
>>> d={'name':'wz','first':'z','last':'w'}
>>> for k,v in d.items():			# items()
...     print('  Key: ' + k)
...     print('Value: ' + v+'\n')
...
  Key: name
Value: wz

  Key: first
Value: z

  Key: last
Value: w
  • 遍历所有 键 keys()
1
2
3
4
5
6
>>> for k in d.keys():				# 遍历所有 键 keys()
...     print('  Key: ' + k.title())
...
  Key: Name
  Key: First
  Key: Last
  • 遍历所有 值 values()
1
2
3
4
5
6
>>> for v in d.values():			# 遍历所有 值 values()
...     print(v.title())
...
Wz
Z
W

检查字典中的键或值

  • 检查键或值
1
2
3
4
5
6
7
8
9
>>> d={'name':'wz','first':'z','last':'w'}
>>> 'name' in d.keys()
True
>>> 'w' in d.values()
True
>>> 'first' in d.values()
False
>>> 'first' not in d.values()
True
  • 嵌套 if 判断
1
2
3
4
5
6
7
8
9
10
>>> n=['first']
>>> for k in d.keys():
...     print(k.title())
...     if k in n:				# 嵌套 if 判断
...         print('        z')
...
Name
First
        z
Last

get() 方法

1
2
3
4
5
6
>>> d={'name':'wz','first':'z','last':'w'}
>>> d.get('last','wang')
'w'
>>> d.get('all','wang')
'wang'
>>>

setdefault() 方法

1
2
3
4
5
6
>>> d={'name':'wz','first':'z','last':'w'}
>>> d.setdefault('all','wazz')
'wazz'
>>> d
{'name': 'wz', 'first': 'z', 'last': 'w', 'all': 'wazz'}
>>>

漂亮打印

如果在程序中导入 pprint 模块，就可以用 pprint() 和 pformat() 函数来用漂亮的格式打印字典内容。下面例子对比了 print() 和 pprint():

  • 普通打印
1
2
3
4
5
6
7
8
9
>>> message = 'It was a bright cold day in April, and the clocks were striking thirteen.'
>>> count = {}
>>>
>>> for character in message:
...     count.setdefault(character, 0)
...     count[character] = count[character] + 1
...
>>> print(count)
{'I': 1, 't': 6, ' ': 13, 'w': 2, 'a': 4, 's': 3, 'b': 1, 'r': 5, 'i': 6, 'g': 2, 'h': 3, 'c': 3, 'o': 2, 'l': 3, 'd': 3, 'y': 1, 'n': 4, 'A': 1, 'p': 1, ',': 1, 'e': 5, 'k': 2, '.': 1}
  • 漂亮打印

pprint() 在屏幕上输出结果，pformat() 得到漂亮打印的文本字符串。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
>>> import pprint
>>> message = 'It was a bright cold day in April, and the clocks were striking thirteen.'
>>> count = {}
>>>
>>> for character in message:
...     count.setdefault(character, 0)
...     count[character] = count[character] + 1
...
>>> pprint.pprint(count)
{' ': 13,
 ',': 1,
 '.': 1,
 'A': 1,
 'I': 1,
 'a': 4,
 'b': 1,
 'c': 3,
 'd': 3,
 'e': 5,
 'g': 2,
 'h': 3,
 'i': 6,
 'k': 2,
 'l': 3,
 'n': 4,
 'o': 2,
 'p': 1,
 'r': 5,
 's': 3,
 't': 6,
 'w': 2,
 'y': 1}

函数

简单函数

1
2
3
4
5
>>> def func():
...     print('简单函数！')
...
>>> func()
简单函数！

位置实参和关键字实参

1
2
3
4
5
6
7
>>> def func(para):
...     print('简单函数！' + para)
...
>>> func('这是参数')                # 位置实参
简单函数！这是参数
>>> func(para='这是参数')           # 关键字实参
简单函数！这是参数

带默认值参数

1
2
3
4
5
>>> def func(para='默认参数值'):    # 默认值
...     print('简单函数！' + para)
...
>>> func()                         # 使用默认值
简单函数！默认参数值

任意数量实参

1
2
3
4
5
6
7
8
9
10
>>> def func(*para):               # 任意数量实参
...     print('任意数量！')
...     print(para)
...
>>> func('1')
任意数量！
('1',)
>>> func('1','2')
任意数量！
('1', '2')

模块导入

模块是扩展名为.py的文件，函数存在于模块中，使用函数之前需要导入。

  • test.py 文件内容

函数与函数之间空两行

1
2
3
4
5
6
def func2(para='默认参数值'):
    print('简单函数！' + para)


def func(*para):
    print(para)

导入整个模块

1
2
3
4
5
6
7
>>> import test
>>> test.func('a')              # 必须指定前缀
('a',)
>>> test.func('a','b','c')      # 必须指定前缀
('a', 'b', 'c')
>>> test.func2()                # 必须指定前缀
简单函数！默认参数值

导入指定函数

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> from test import func
>>> func('a','b')               # 不需要指定前缀
('a', 'b')
>>> func2                       # 没有导入 func2 ,出错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'func2' is not defined

>>> from test import func,func2
>>> func('a','b')               # 可以不指定前缀
('a', 'b')
>>> func2()                     # 可以不指定前缀
简单函数！默认参数值

导入所有函数

1
>>> from test import *

导入类

与导入函数格式一致。

类

  • 类是模块内的属性

创建类

test.py 文件内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Dog():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sleep(self):
        print(self.name.title() + " 正在睡觉...")

    def playgame(self):
        print(self.name.title() + " 游戏中...")

    def getage(self):
        print(self.name.title() + " " + str(self.age) + " 岁了!")

    def setage(self, age):
        self.age = age

创建和操作实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
>>> import test
>>> mydog=test.Dog('huahua',2)      # 创建实例
>>> mydog.name                      # 访问属性
'huahua'
>>> mydog.age
2
>>> mydog.sleep()                   # 调用方法
Huahua 正在睡觉...
>>> mydog.playgame()
Huahua 游戏中...
>>> mydog.getage()
Huahua 2 岁了!
>>> mydog.age=3                     # 直接修改实例的属性值
>>> mydog.age
3
>>> mydog.color="black"             # 在实例内产生全新的属性，之前在类中并没有定义过
>>> mydog.color
'black'
>>> mydog.getage()
Huahua 3 岁了!
>>> mydog.setage(5)                 # 调用方法修改属性值
>>> mydog.age
5
>>> mydog.getage()
Huahua 5 岁了!

类继承

  • 超类列在子类开头的括号中。 含有继承的类成为子类，子类所继承的类就是超类。

子类与超类

test.py 文件增加继承类内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Dog():                        # 超类
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sleep(self):
        print(self.name.title() + " 正在睡觉...")

    def playgame(self):
        print(self.name.title() + " 游戏中...")

    def getage(self):
        print(self.name.title() + " " + str(self.age) + " 岁了!")

    def setage(self, age):
        self.age = age

class LittleDog(Dog):               # 创建继承类（子类：LittleDog，超类：Dog）
    def setage(self, age):          # 重写父类方法
        if 0 < age <= 3:
            self.age = age
        else:
            print('不合适的小狗年龄！')

测试继承类

1
2
3
4
5
6
7
8
9
10
11
12
13
>>> import test
>>> mydog=test.LittleDog('huahua',2)
>>> mydog.name
'huahua'
>>> mydog.age
2
>>> mydog.getage()
Huahua 2 岁了!
>>> mydog.setage(3)
>>> mydog.getage()
Huahua 3 岁了!
>>> mydog.setage(6)
不合适的小狗年龄！

继承在Python 2.7 和 3 之间的差异

  • Python 3中的继承
1
2
3
4
5
6
7
8
class Dog():
    def __init__(self, name, age):
        ...

class LittleDog(Dog):
    def __init__(self, name, age):
        super().__init__(name,age)
        ...
  • Python 2.7中的继承
1
2
3
4
5
6
7
8
class Dog(object):
    def __init__(self, name, age):
        ...

class LittleDog(Dog):
    def __init__(self, name, age):
        super(LittleDog,self).__init__(name,age)
        ...

类截获Python运算符

截获Python运算符，即运算符重载，让用类写成的对象，可以截获并相应在内置类型上的运算：加法、切片、打印和点号运算符等。

运算符重载例子

  • 当心的实例构造时，会调用init(self是新的ThirdClass对象)。
  • 当ThirdClass实例出现在 + 表达式中时，则会调用add。
  • 当打印一个对象的时候（从技术上讲，当通过 str 内置函数或者其 Python 内部的等价形式来将其转换为打印字符串的时候），运行str。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
>>> class FirstClass:               # Define a class object
...     def setdata(self, value):   # Define class methods
...         self.data = value       # self is the instance
...     def display(self):
...         print(self.data)        # self.data: per instance
...
>>> class SecondClass(FirstClass):                   # Inherits setdata
...     def display(self):                           # Changes display
...         print('Current value = "%s"' % self.data)
...
>>> class ThirdClass(SecondClass):                     # Inherit from SecondClass
...     def __init__(self, value):                     # On "ThirdClass(value)"
...         self.data = value
...     def __add__(self, other):                      # On "self + other"
...         return ThirdClass(self.data + other)
...     def __str__(self):                             # On "print(self)", "str()"
...         return '[ThirdClass: %s]' % self.data
...     def mul(self, other):                          # In-place change: named 
...         self.data *= other
...
>>> a = ThirdClass('abc')           # __init__ called
>>> a.display()                     # Inherited method called
Current value = "abc"
>>> print(a)                        # __str__: returns display string
[ThirdClass: abc]

>>> b = a + 'xyz'                   # __add__: makes a new instance
>>> b.display()                     # b has all ThirdClass methods 
Current value = "abcxyz"
>>> print(b)                        # __str__: returns display string
[ThirdClass: abcxyz]

>>> a.mul(3)                        # mul: changes instance in-place
>>> print(a)
[ThirdClass: abcabcabc]

self

  • Python 中的 self 相当于 C++ 或 Java 中的 this，在 Python 中 self 必须明确写出来。
  • self 不一定必须写成 self，可以起任何其他名字（比如：a，b，this等），鉴于其总是指向对象本身，因此习惯上将其命名为 self。
  • self 指向创建的实例本身（是实例，而不是类）。参考下面代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
>>> class Test:
...     def prt(self):
...         print(self)
...         print(self.__class__)
...
>>> x = Test()
>>> x.prt()
<__main__.Test object at 0x000001F4E8C8FCF8>        # x 实例地址
<class '__main__.Test'>
>>> y = Test()
>>> y.prt()
<__main__.Test object at 0x000001F4E8C8FC88>        # y 实例地址
<class '__main__.Test'>

Python 正则表达式

内容太多，独立发布，参见 Python 正则表达式。

例子程序

猜数字

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import random
rnum = random.randint(1, 20)
print('猜测1~20之间的一个数。')

for guessNum in range(1, 7):
    print('请输入猜测数字：')
    guess = int(input())

    if guess < rnum:
        print('小了')
    elif guess > rnum:
        print('大了')
    else:
        break

if guess == rnum:
    print('干得好！你用了 ' + str(guessNum) + '次机会猜对了结果。')
else:
    print('很遗憾，正确的数字是' + str(rnum))

Collatz 序列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def collatz(number):
    if number % 2 == 0:
        print(number//2)
        return number//2
    elif number % 2 == 1:
        print(3*number+1)
        return(3*number+1)

iInput = input('请输入一个整数：')
try:
    iReturn = collatz(int(iInput))
    while iReturn != 1:
        iReturn = collatz(int(iReturn))
except:
    print('输入的不是整数！')

打印列表内容

1
2
3
4
5
6
7
8
9
def plst(lst):
    splst = "'"
    for i in range(1, len(lst)):
        splst += lst[i-1]+', '
    splst += 'and ' + lst[i] + "'"
    print(splst)

l = ['dog', 'cat', 'tiger', 'elephant']
plst(l)

结尾

0%