1 中文支持

1
2
#文件开头加入
# -*- coding:utf-8 -*-

2 注释

1
2
3
4
5
#单行注释

'''多行注释
注释内容
'''

3 关键字

1
2
3
4
5
6
#import keyword
#keyword.kwlist
and     as      assert     break     class      continue    def     del
elif    else    except     exec      finally    for         from    global
if      in      import     is        lambda     not         or      pass
print   raise   return     try       while      with        yield

4 输出

1
2
3
4
5
6
7
8
print('**')

name = 'zhangsan'
print("name=%s"%name)

age = 18
print("name=%s,age=%d"%(name, age))

常用的格式符号：

格式符号 转换
%c 字符
%s 通过 str() 字符串转换来格式化
%i 有符号十进制整数
%d 有符号十进制整数
%u 无符号十进制整数
%o 八进制整数
%x 十六进制整数（小写字母）
%X 十六进制整数（大写字母）
%e 索引符号（小写’e’）
%E 索引符号（大写“E”）
%f 浮点实数
%g ％f 和％e 的简写
%G ％f 和％E 的简写

5 输入

1
2
a = input()
b = input("请输入：")

6 运算符

运算符 描述 实例
+ 加 两个对象相加 a + b 输出结果 30
- 减 得到负数或是一个数减去另一个数 a - b 输出结果 -10
* 乘 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/ 除 x 除以 y b / a 输出结果 2
// 取整除 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0
% 取余 返回除法的余数 b % a 输出结果 0
** 幂 返回 x 的 y 次幂 a**b 为 10 的 20 次方， 输出结果 100000000000000000000
= 赋值运算符 把=号右边的结果给左边的变量 num=1+2*3 结果 num 的值为 7
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c _= a 等效于 c = c _ a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符 c %= a 等效于 c = c % a
**= 幂赋值运算符 c **= a 等效于 c = c ** a
//= 取整除赋值运算符 c //= a 等效于 c = c // a

7 关系运算符

运算符 描述 示例
== 检查两个操作数的值是否相等，如果是则条件变为真。 如 a=3,b=3 则（a == b) 为 true.
!= 检查两个操作数的值是否相等，如果值不相等，则条件变为真。 如 a=1,b=3 则(a != b) 为 true.
<> 检查两个操作数的值是否相等，如果值不相等，则条件变为真。 如 a=1,b=3 则(a <> b) 为 true。这个类似于 != 运算符
> 检查左操作数的值是否大于右操作数的值，如果是，则条件成立。 如 a=7,b=3 则(a > b) 为 true.
< 检查左操作数的值是否小于右操作数的值，如果是，则条件成立。 如 a=7,b=3 则(a < b) 为 false.
>= 检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。 如 a=3,b=3 则(a >= b) 为 true.
<= 检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。 如 a=3,b=3 则(a <= b) 为 true.

8 逻辑运算符

运算符 逻辑表达式 描述 示例
and x and y 布尔”与” - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。 (a and b) 返回 20。
or x or y 布尔”或” - 如果 x 是 True，它返回 True，否则它返回 y 的计算值。 (a or b) 返回 10。
not not x 布尔”非” - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 not(a and b) 返回 False

9 常见的数据类型转换

函数 说明
int(x [,base ]) 将 x 转换为一个整数
long(x [,base ]) 将 x 转换为一个长整数
float(x ) 将 x 转换到一个浮点数
complex(real [,imag ]) 创建一个复数
str(x ) 将对象 x 转换为字符串
repr(x ) 将对象 x 转换为表达式字符串
eval(str ) 用来计算在字符串中的有效 Python 表达式,并返回一个对象
tuple(s ) 将序列 s 转换为一个元组
list(s ) 将序列 s 转换为一个列表
chr(x ) 将一个整数转换为一个字符
unichr(x ) 将一个整数转换为 Unicode 字符
ord(x ) 将一个字符转换为它的整数值
hex(x ) 将一个整数转换为一个十六进制字符串
oct(x ) 将一个整数转换为一个八进制字符串

10 判断条件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#if
if 条件:
    pass
else:
    pass

#elif
if 条件:
    pass
elif 条件2:
    pass
elif 条件3:
    pass
...
else:
    pass

11 循环

1
2
3
4
5
6
7
8
9
10
11
12
13
#while
while 条件:
    pass

#for
for 变量 in 列表或者字符串:
    pass
else:
    pass #不满足条件执行的代码

#break和continue
#break:终止循环
#continue:终止本次循环、继续循环

12 字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
a = "asd"
b = 'asd'

#下标
a[0] #输出a

#切片
#对操作的对象截取其中一部分。
#语法：[起始:结束:步长]
#选取的区间属于左闭右开型，[起始，结束)
name = 'abcdef'
print(name[0:3]) #abc
print(name[2:]) #cdef
print(name[1:-1]) #取 下表为1开始 到最后 第2个之间的字符串 bcde
print(name[:3]) #abc
print(name[::2]) #步长每两个取一个 ace
print(name[1:5:2]) #可以理解为name[1:5][::2] bd
print(name[::-2]) #倒叙取值 每两个取一个 fdc

13 字符串常见操作

13.1 find(str, start=0, end=len()) 检测 str 是否包含在 mystr 中，存在则后返回索引值，否则返回-1
1
2
3
str = 'ad'
mystr = 'avcsad'
mystr.find(str, 0, len(mystr)) #输出4
13.2 index(str, start=0, end=len()) 和 find()方法一样。区别是 不存在则抛出异常
1
mystr.index(str, 0, len(mystr))
13.3 count(str) 返回 str 在 start 和 end 之间在字符串中出现的次数
1
mystr.count(str)
13.4 replace(str1, str2, count) #把 str1 替换成 str2。count 可空，替换不超过 count 次
1
2
mystr.replace(str1, str2)
mystr.replace(str1, str2, 2)
13.5 split(str, count) #以 str 字符串分割。count 可空，分割不超过 count 次
1
2
3
4
5
name = 'hello world hello python'
name.split(' ')
['hello', 'world', 'hello', 'python']
name.split(' ', 2)
['hello', 'world', 'hello python']
13.6 capitalize() #把字符串的第一个字符大写
1
2
3
name = 'hello world hello python'
name.capitalize()
'Hello world hello python'
13.7 title() #把字符串的每个单词首字母大写
1
2
3
name = 'hello world hello python'
name.title()
'Hello World Hello Python'
13.8 startswith(str) 检查字符串是否以 str 开头，是返回 True 否则返回 False
1
2
3
name = 'hello world hello python'
name.startwith('world')
Flase
13.9 endswith(str) 检查字符串是否已 str 结尾，是返回 True 否则返回 False
13.10 lower() 将字符串所有大写字符转为小写
13.11 upper() 将字符串所有小写字符转为大写
13.12 ljust(width) 返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
13.13 rjust(width) 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
13.14 center(width) 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
13.15 lstrip() 删除字符串左边的空白字符
13.16 rstrip() 删除字符串末尾的空白字符
13.17 strip() 删除字符串两端的空白字符
13.18 rfind(str, 0, len()) 类似 find().只不过是从右侧开始查找
13.19 rindex(str, 0, len()) 类似 index().只不过是从右侧开始查找
13.20 partition(str) 分割字符串成 str 前 str str 后
1
2
3
4
5
6
name = 'hello world hello python'
name.partition('world')
('hello', 'world', 'hello python')
name.partition('hello')
('', 'hello', ' world hello python')

13.21 类似 partition(str) 从右侧开始
13.22 splitlines() 按行分割、返回列表
13.23 isalpha() 判断字符串中的所有字符是否是字母。是返回 True 否则返回 False
1
2
3
4
5
6
7
8
9
10
11
name = 'zhangsan'
name.isalpha()
True

name = 'zhangsan '
name.isalpha()
False

name = 'zhangsan212'
name.isalpha()
False
13.24 isdigit() 判断字符串中的所有字符是否是数字。是返回 True 否则返回 False
13.25 isalnum() 判断字符串中的所有字符是否是字母或者数字。是返回 True 否则返回 False
13.26 isspace() 判断字符串中的所有字符只包含空格。是返回 True 否则返回 False
13.27 join(str) 字符串中每个字符后面插入 str,返回新字符串
1
2
3
4
5
6
str = '_'
name = 'zhangsan'

str.join(name)
'z_h_a_n_g_s_a_n_'

14 列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#list是一种有序集合。list中包含的元素并不要求都必须是同一种数据类型
#1占内存小
#2访问速度慢
#3有顺序
#4key的元素不可变。list不能作为dict的key

empty_l = [] # l是一个空列表

#列表循环
l = ['zhangsan', 12, True]

##for
for x in l:
    print(x)

##while
length  = len(l)
i = 0

while i < lenth:
    print(l[i])
    i+=1

15 列表相关操作

15.1 添加元素 (append, extend, insert)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#append(object)
stu_l = ['zhangsan', 'lisi', 'wangwu']
stu_l.append('maliu')
['zhangsan', 'lisi', 'wangwu', 'maliu']

#extend(object)将元素逐一添加到列表中
stu_l = ['zhangsan', 'lisi', 'wangwu']
stu_another = ['xiaoming', 'xiaohong']
stu_l.append(stu_another)
['zhangsan', 'lisi', 'wangwu', ['xiaoming', 'xiaohong']]
stu_l.extend(stu_another)
['zhangsan', 'lisi', 'wangwu', ['xiaoming', 'xiaohong'], 'xiaoming', 'xiaohong']

#insert(index, object) 将object添加到index索引下
stu_l.insert(0, stu_another)
[['xiaoming', 'xiaohong'], 'zhangsan', 'lisi', 'wangwu', ['xiaoming', 'xiaohong'], 'xiaoming', 'xiaohong']
15.2 修改元素
1
2
3
stu_l = ['zhangsan', 'lisi', 'wangwu']
stu_l[0] = 'xiaoming'
['xiaoming', 'lisi', 'wangwu']
15.3 查找元素(in, not in, index, count)
1
2
3
4
5
6
7
8
9
stu_l = ['zhangsan', 'lisi', 'wangwu']

#in, not in
if 'zhangsan' in stu_l:
    print('在列表中')
else:
    print('不在列表中')

#index, count与字符串用法相同，详见13
15.4 删除元素(del, pop, remove)
1
2
3
4
5
6
7
8
9
10
11
12
13
#del根据下标删除
#pop()删除最后一个元素
#remove(str) 根据元素的值进行删除
stu_l = ['zhangsan', 'lisi', 'wangwu']

del stu_l[0]
stu_l = ['lisi', 'wangwu']

stu_l.pop()
stu_l = ['lisi']

stu_l.remove('lisi')
stu_l = []
15.5 排序(sort, reverse)
1
2
3
4
#sort()方法是将list 默认有小到大重新排序
#sort(reverse=True) 由大到小排序

#reverse()将list逆置
15.6 enumerate()带下标索引的遍历
1
2
3
4
list_a = ['zhangsan', 'lisi', 123, True]
for index, li in enumerate(list_a):
    print('%s:%s'%(index, li))

16 元组

1
2
3
4
5
6
7
8
9
#组与列表类似，不同之处在于元组的元素不能修改。
aTuple = ('asd', 123)
bTuple = (, True) #,号不可省略

#使用下表方式访问元组
aTuple[0]
#元组不可修改元素 不可删除元素

#内置函数index(), count() 与字符串操作类似

17 字典

1
2
3
4
5
6
7
8
9
10
11
#dict特点
#1访问速度快
#2dict的key不能重复
#3dict占内存大
#4key-value序对没有顺序

a = {} #空字典a
stu_a = {'name':'zhangsan', 'id':1, 'address':'beijing'}

#访问，如果key不存在则报错
stu_a['name']

18 字典的常见操作

18.1 添加元素
1
2
3
4
5
#变量名['键'] = 值
stu_a = {'name':'zhangsan', 'id':1, 'address':'beijing'}
stu_a['phone'] = 123456
#如果键存在 则会覆盖原来的直

18.2 修改元素
1
#变量名['键'] = 值
18.3 删除(del, clear())
1
2
3
4
5
6
7
8
9
10
11
stu_a = {'name':'zhangsan', 'id':1, 'address':'beijing'}

#删除单个值
del stu_a['name']
#如果键不存在则会抛出异常

#删除字典对象
del stu_a

#清空字典
stu_a.clear()
18.4 len()测量字典中，键值对的个数
18.5 keys()返回一个包含所有 key 的列表
18.6 values()返回一个包含所有 value 的列表
18.7 items()返回一个包含所有(键， 值)元组的列表
1
2
3
stu_a = {'name':'zhangsan', 'id':1, 'address':'beijing'}
stu_a.items()
[('name':'zhangsan'), ('id':1), ('address':'beijing')]
18.8 has_key(key)如果 key 在字典中，则返回 True 否则返回 False
18.9 字典的遍历
  • 遍历字典的 key
1
2
3
stu_a = {'name':'zhangsan', 'id':1, 'address':'beijing'}
for key in stu_a.keys():
    print(key)
  • 遍历字典的 value
1
2
3
stu_a = {'name':'zhangsan', 'id':1, 'address':'beijing'}
for value in stu_a.values():
    print(value)
  • 遍历字典的项
1
2
3
4
5
6
stu_a = {'name':'zhangsan', 'id':1, 'address':'beijing'}
for item in stu_a.items():
    print(item)
('name', 'zhangsan')
('id', 1)
('address', 'beijing')
  • 遍历字典的键值对
1
2
3
4
5
6
7
stu_a = {'name':'zhangsan', 'id':1, 'address':'beijing'}
for key, value in stu_a.items():
    print('key=%s, value=%s'%(key, value))
key=name, value=zhangsan
key=id, value=1
key=address, value=beijing

19 函数

19.1 定义与调用
1
2
3
4
5
6
7
#定义
def 函数名(参数):
    pass

#调用
函数名(参数)

19.2 返回值
1
2
3
4
5
6
#返回值
def 函数2(参数):
    return 0
#返回多个值
def test4(id, name):
    return id, name #本质是返回一个tuple
19.3 局部变量与全局变量
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
#局部变量 -- 在函数内部定义的变量
def name():
  a = 0
  return a

#全局变量 -- 在函数外部定义的变量

name = 'zhangsan'  #全局变量

def test1():
    name = 'lisi'  #局部变量
    print('name=%s'%name)  # lisi

    name = 'wangwu' #局部变量
    print('name=%s'%name)  # wangwu

def test2():
    print('name=%s'%name)  # zhangsan

#如果要修改全局变量，使用global关键字
def test3():
    global name

    name = 'xxx'

19.4 参数
  • 默认参数
1
2
3
4
5
#参数- 默认参数
def name(id , name='lisi'):
    pass
def name(name='lisi', id): #报错，默认参数必须在参数列表后面
    pass
  • 不定长参数
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def name2(*args, **kwargs): #args是元组 kwargs是字典
    pass
#例如
def fun(a, c, *args, **kwargs):
    print('a=%s'%a)
    print('c=%s'%c)
    print('args=%s'%args)
    print('kwargs=%s'%kwargs)

fun(1, 2, 3, 4, 5, a=431, b=122, c=3)
a=1
c=2
args=(3, 4, 5)
kwargs={'a'=431, 'b'=122, 'c'=3}

score = (12, 43, 45)
name = {'age'= 18, 'address':'太阳系'}

fun(1, 2, *score, **kwargs)
19.5 递归

求 N 的阶乘

1
2
3
4
5
6
7
8
9
def factorial(n):
    if n >= 0:
        if n >= 1:
            result = n * factorial(n - 1)
        else:
            result = 1
        return result
    else:
        return 0
19.6 匿名函数

lambda 函数能接受任何数量的参数，但是只能返回一个表达式的值
匿名函数不能直接调用 print,

1
2
#语法
lambda [arg1 [,arg2, ... argn]]:expression
1
2
3
4
#实例
sum = lambda a, b: a + b

sum(1, 2)

20 文件操作

20.1 打开与关闭文件

使用 open()函数，可以打开一个已经存在的文件，或者创建新的文件

1
2
3
open(文件名, 访问模式)

f = open('text.txt', 'w')
访问模式 说明
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
w+ 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

关闭文件

1
2
3
close()

f.close()
20.2 文件读写

写数据

1
2
3
4
5
6
write()函数可以向文件写入数据

#demo
f = open('text', 'w')
f.write('hello python')
f.close()

读数据

1
2
3
read(num) #num表示要从文件中读取的数据长度(单位是字节)，如果没有传入num，那么就表示去读文件中所有的数据
readlines() #可以按照行的方式把整个文件中的内容一次性读取，返回一个列表，其中每一行的数据为一个元素
readline()
20.3 定位读写

在读写过程中，如果想知道当前位置，可以使用 tell()来获取

1
2
f = open('text', 'r')
f.tell()

读写过程中，需要从另一个位置进行操作的话，使用 seek()函数

1
2
3
4
5
seek(offset, from)
#offset偏移量
#from方向：0表示文件开头 1表示当前位置 2文件末尾
seek(5, 0) #从开头开始 偏移5个字节

20.4 文件重命名与删除
1
2
3
4
5
6
7
import os

#文件重命名 rename()
os.rename('test', 'test1')

#删除文件
os.remove('test')
20.5 文件夹相关操作
  • 创建文件夹
1
2
import os
os.mkdir('文件名')
  • 获取当前目录
1
2
import os
os.mkdir('文件名')
  • 改变默认目录
1
2
import os
os.chdir('../')
  • 获取目录列表
1
2
import os
os.listdir('../')
  • 删除文件夹
1
2
import os
os.rmdir('文件夹名')

21 面向对象

21.1 类的定义与创建对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#定义类的格式
class 类名(object): #继承自object
    属性
    方法

#例
class Car(object):
    #方法
    def move(self):
        print('车正在移动...')

bmw = Car() #创建对象
bmw.move() #调用move()方法
bmw.color = '黑色' #给对象添加属性

21.2 init(self)方法
1
2
__init__(self)方法的作用是 初始化函数
__init__(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去
21.3 私有属性
1
在属性名前面加了2个下划线'__'，则表明该属性是私有属性。（方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）。类外部无法直接修改私有属性或者方法。
21.4 del()方法
1
2
创建对象后，python解释器默认调用__init__()方法；
当删除一个对象时，python解释器也会默认调用一个方法，这个方法为__del__()方
21.5 继承
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#单继承
class Animal(object):
    pass

class Dog(Animal):
    pass

#多继承
class A(object):
    pass
class B(object):
    pass
class C(A, B):
    pass

私有属性：不能通过对象直接访问，但是可以通过方法访问
私有方法：不能通过对象直接访问
私有属性、方法不会被子类继承，也不能被访问
一般情况下，私有属性、方法不对外部使用

21.6 重写方法

所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法

21.7 类属性和实例属性

类属性是 类 所拥有的属性，他是被所有 类对象的 实例对象所共有。

1
2
3
4
5
6
7
8
9
10
11
class Zhangsan_People(object):
    name = 'zhangsan'  #类属性
    __age = 18  #私有类属性

zhangsan = Zhangsan_People()

print(zhangsan.name)  #正确
print(zhangsan.__age) #异常
print(Zhangsan_People.name)  #正确
print(Zhangsan_People.__age)  #异常

实例属性是 类创建的对象所拥有的属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Zhangsan_People(object):
    name = 'zhangsan'  #类属性

    def __init__(self):
        self.address = '太阳系'  #实例属性

zhangsan = Zhangsan_People()

zhangsan.age = 18

print(zhangsan.age)  #正确
print(zhangsan.address)  #正确
print(zhangsan.name)  #正确
print(Zhangsan_People.age)  #异常
print(Zhangsan_People.name)  #正确
print(Zhangsan_People.address)  #异常

21.8 类方法与静态方法

类方法：是类对象所拥有的方法，需要用修饰器 @classmethod ,第一个参数必须是类对象，一般以 cls 作为第一个参数(cls 不是必须，可以用其他名)

1
2
3
4
5
6
7
8
9
10
11
12
13
class People(object):
    country = 'China'

    #类方法
    @classmethod
    def getCountry(cls):
        return cls.country

p = People()

print(p.getCountry())  #可以通过实例对象引用
print(People.getCountry())  #可以通过类对象引用

静态方法：通过修饰器 @staticmethod ,静态方法不需要参数

1
2
3
4
5
6
7
class People(object):
    name = 'zhangsan'

    #静态方法
    @staticmethod
    def getCountry():
        return People.name
21.9 单例模式

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，单例模式是一种对象创建型模式。

1
2
3
4
5
6
7
8
class Singleton(object):
    __instance = None

    def __new__(cls):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance

创建类对象时，只初始化一次_ init _()方法

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
36

class Singleton(object):
    __instance = None
    __first_init = False

    def __new__(cls, *args, **kwargs):
        if not cls.__instance:
            cls.__instance = object.__new__(cls)
        return cls.__instance

    def __init__(self, age, name):
        if not self.__first_init:
            self.age = age
            self.name = name
            Singleton.__first_init = True

s = Singleton(12, 'name')
s2 = Singleton(19, 'zhangsan')

print(id(s))
print(id(s2))

print(s.age)
print(s2.age)

s.age = 18
print(s.age)
print(s2.age)

---------------
1754386242416
1754386242416
12
12
18
18

22 异常

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
36
try:
    pass
except IOError:
    pass

#捕获多个异常
try:
    pass
except (IOError, NameError):
    pass

#获取异常信息描述
try:
    pass
except IOError as result:
    print(result)

#获取所有异常
try:
    pass
except Exception as result:
    print(result)

#else
try:
    pass
except:
    pass
else:
    pass #没有异常时 执行else语句

#try...finally...
#finally代码必定执行。适用于文件关闭，释放锁，把数据库连接返还给连接池等

#抛出自定义异常
raise引发一个异常。异常/错误对象必须是 Error或 Exception类的子类

23 模块

1
2
3
4
5
6
7
8
9
10
11
12
13
#导入module1, module2
import module1, module2

#从module1导入 name1, name2
from module1 import name1, name2
#从module1导入全部
from module1 import *

#as 重命名 -- 重命名之后name1失效
from module1 import name1 as xx

#如果一个模块中有__all__ 那么意味着这个变量中的元素不会被 from xx import .. 导入