3.python知识总结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TJ2Nu8iD-1600071235214)(…/img/chinahadoop.png)]

Python编程

Python介绍

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v9UCleYI-1600071235218)(…/img/python.png)]
Python 是一种简单易学，功能强大的编程语言，它有高效率的高层数据结构，简单而有效地实现面向对象编程。Python 简洁的语法和对动态输入的支持，再加上解释性语言的本质，使得它在大多数平台上的许多领域都是一个理想的脚本语言，特别适用于快速的应用程序开发。

Python与Java, C, C++并列为全球4大最流行语言. 从C到C++,到Java再到Python, 细节越来越少, 让开发者把更多的精力放在”做什么”, 而不是”怎么做”。

更多python语言介绍和入门可以参考资料《Python简介和入门》

%config ZMQInteractiveShell.ast_node_interactivity='all'
%pprint

Pretty printing has been turned OFF

Python的两种运行方式

解释运行

• 新建py文件，直接运行

%%writefile print_str.py
print("欢迎大家学习课程内容！")

Overwriting print_str.py

!python3 print_str.py

欢迎大家学习课程内容！

交互运行

• ipython, notebook

Python标识符

合法标识符

• 数字，下划线，字母构成
• 避开关键字
• 不能用数字开头

如以下标识符取名错误
for='chinahadoop.cn'
7a=8
str='小象学院'

好的命名习惯让开发更有效率

• 变量，函数或方法:salary,houseworker,booksname
• 常量：INTEREST_RATES
• 类：BankAccount,Employee,Company,OrderedDict #骆峰命名法

名字与对象之间的建立引用与解除引用

我们可以使用=建立名字与对象之间的关联，用del 名字来解除这种关联

标准操作符及优先级

操作符及优先级如下：

第1名 - 函数调用、寻址、下标
第2名 - 幂运算 **
第3名 - 翻转运算符 ~
第4名 - 正负号
第5名 - *、/、%
第6名 - +、-

#算术运算符
a=100;b=3
a+b #加
a-b #减
a*b #乘
a/b #除
a//b #取商
a%b #取余
a**2 #平方
a**0.5 #开方

103






97






300






33.333333333333336






33






1






10000






10.0

#比较运算符  
if a==b:
    print ('a equal b')

if a!=b:
    print ('a not equal b')
    
#逻辑运算符><>=,
if a>=50:
    print('a is grater than 50')
    
#成员运算符in,not in
websiteUrl='chinahadoop.cn'
if '.net' not in websiteUrl:
    print ('.net not in it')

a not equal b
a is grater than 50
.net not in it

#赋值
c = 1000

#多重赋值
#a=100;b=100
a=b=100

#多元赋值
#a=100;b=200
a,b,c=100,200,200

#交换赋值
a,b=b,a
print(a,b)

200 100

# 拓展知识

#unpack解包
l1=[1,2,3,4,5,'6']
a,b,*c,d=l1
print(a,b,c,d)

#*号收集
a,*b,c=l1
print(a,b,c)

#*号展开,针对序列
l1=[1,2,3,4]
s1='chinahadoop.cn'
[*l1,*s1]

#*号展开,针对字典
d1={'name':'machine learning 5th','add':'BJ,SH,*'}
[*d1],{**d1,'date':'2019-3-30'}

# ,号放在最后的解包
l1=[[3,4,5]]
a=l1
b,=l1
print(a,b)

1 2 [3, 4, 5] 6
1 [2, 3, 4, 5] 6





[1, 2, 3, 4, 'c', 'h', 'i', 'n', 'a', 'h', 'a', 'd', 'o', 'o', 'p', '.', 'c', 'n']






(['name', 'add'], {'name': 'machine learning 5th', 'add': 'BJ,SH,*', 'date': '2019-3-30'})



[[3, 4, 5]] [3, 4, 5]

Python基本数据类型与数据结构

基本数据类型：数值型

#数值整型
a=100;b=200

#进制转换
a=0b0101001#bin()
b=0o4#oct()
c=0x28#hex()

#浮点型
pi=3.1415

#科学计算法
c=5e13
print(c)

#数字的正负无穷
#float('inf')正无穷
#float('-inf')负无穷
if 99999999999999999<float('inf'):
    print('you win!')

#复数
a=4.3+22j
type(a)


#数值类型转换
a=4.48
b=8
int(a)

# 保留n位小数四舍五入
round(pi,3)

50000000000000.0
you win!





<class 'complex'>






4






3.142

基本数据类型：字符串型

##字符串型 单引号 双引号 三引号
#初始化及转义
str1='''AI'''
str2='chinahadoop.cn'

#访问,索引及切片访问
str2[-1]

#str2[start:end:stride]
#切片访问的特点：左闭右开[)
#012345...
str2[0:4] #从index为0取到index为4(不包括4)
str2[1:] #从index为1到结尾
str2[:4] #从开头到index为4(不包括4)
str2[0::2] #从index为0到结尾，每隔2-1=1个字符取一次

#格式化访问1
companyName='chinahadoop'
str3='http://{}.cn'
print(str3.format(companyName))

#格式化访问2
print("Company name is %s" %companyName)

#格式化访问3
_='Python 3.6'#fstring only can be used under version 3.6
str4=f"fstring is new feature of {_}"
str4    
        
#查找与替换
str3.find('o')
str3.replace('.cn','.net')

#统计
str3.count('cn')

'n'






'chin'






'hinahadoop.cn'






'chin'






'ciaaopc'



http://chinahadoop.cn
Company name is chinahadoop





'fstring is new feature of Python 3.6'






-1






'http://{}.net'






1

基本数据类型：布尔型

a=3
b=5
a<3

False

Python数据结构

列表/List

#列表[]:任意元素类型对象的序列
l1=['AI','chinahadoop.cn']
l2=[1,'china',l1,'机器学习集训营']
l2

[1, 'china', ['AI', 'chinahadoop.cn'], '机器学习集训营']

# 列表切片
l2[0] #第1个元素
l2[1] #第2个元素
l2[1:3] #左闭右开
l2[1:] #从index为1开始到结尾
l2[:3] #从index为0开始到index为2
l2[::2] #从最左开始每隔1个

1






'china'






['china', ['AI', 'chinahadoop.cn']]






['china', ['AI', 'chinahadoop.cn'], '机器学习集训营']






[1, 'china', ['AI', 'chinahadoop.cn']]






[1, ['AI', 'chinahadoop.cn']]

# 列表追加
l2.append(['last', 'elem']) #追加1个元素
l2
l2.extend(['new', 'item']) #追加列表
l2
l2 + l1 #追加列表

[1, 'china', ['AI', 'chinahadoop.cn'], '机器学习集训营', ['last', 'elem']]






[1, 'china', ['AI', 'chinahadoop.cn'], '机器学习集训营', ['last', 'elem'], 'new', 'item']






[1, 'china', ['AI', 'chinahadoop.cn'], '机器学习集训营', ['last', 'elem'], 'new', 'item', 'AI', 'chinahadoop.cn']

# 列表删除元素
l2.pop() #返回最尾部元素，并删除该元素
l2.remove('china') #移除列表中的某个值的第一个匹配项，没有返回值

'item'

# 字符串列表的拼接与分割
l3 = ['I', 'love', 'China']
"_".join(l3) #用下划线拼接列表元素(需要是字符串)
a = "#".join(l3)
a
a.split("#") #用井号切分字符串生成列表

'I_love_China'






'I#love#China'






['I', 'love', 'China']

# 列表排序
my_list = [5,1,2,4,3]
my_list.sort() #对my_list排序，直接改变my_list
my_list
new_list = [5,1,2,4,3]
sorted(new_list) #对new_list排序，以返回值返回排序结果，并不改变new_list
new_list

[1, 2, 3, 4, 5]






[1, 2, 3, 4, 5]






[5, 1, 2, 4, 3]

# sorted高级用法
tmp_strs = ['aa', 'BBc', 'CCdd', 'zzmm']
sorted(tmp_strs) #按照字母序排序
sorted(tmp_strs, reverse=True) #按照字母序降序排序
sorted(tmp_strs, key=len) #根据key对元素做处理后的结果对原序列排序，这里的len是函数，返回字符串长度
sorted(tmp_strs, key=str.lower) #根据小写后的结果字母序排序

['BBc', 'CCdd', 'aa', 'zzmm']






['zzmm', 'aa', 'CCdd', 'BBc']






['aa', 'BBc', 'CCdd', 'zzmm']






['aa', 'BBc', 'CCdd', 'zzmm']

元组/tuple

#元组()tuple,只读列表
t1=(1,2,3,4)
type(t1)
#只读列表是真的只读吗？
t2=(1,2,3,[4,5,6])
t2[0]=11#报错

<class 'tuple'>




---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-30-5a12797f04b9> in <module>()
      4 #只读列表是真的只读吗？
      5 t2=(1,2,3,[4,5,6])
----> 6 t2[0]=11#报错


TypeError: 'tuple' object does not support item assignment

tup = ('physics', 'chemistry', 1997, 2000)
tup1 = (50,) #元组中只包含一个元素时，需要在元素后面添加逗号
tup[1:] #元组的切片拼接和list一样

(<class 'int'>, <class 'tuple'>)

集合/set

#集合{}set：无序的不重复元素,集合中的对象，通常叫key
s1={1,1,1,2,3,4,5,2,4,234}
l2=[1,1,1,2,3,4,5,2,4,234]
set(l2)

{1, 2, 3, 4, 5, 234}

字典

# 字典是另一种可变容器模型，且可存储任意类型对象。
# 字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中
my_dict = {'HanXiaoyang': 1234, 'Jason': 4567, 'David': 6789} #定义字典
ks = my_dict.keys() #取出所有的key
ks
vs = my_dict.values() #取出所有的values
vs
Hv = my_dict['HanXiaoyang'] #根据key取对应的value
Hv
Dv = my_dict.get('XiaoMing', 2345) #根据key去取value，如果key不存在返回默认值
Dv
my_dict['HanXiaoyang'] = 7890 #改变字典中key对应的value值
my_dict
flag = 'DaDa' in my_dict #判断是否有某个key
flag

# 遍历字典元素
for key in my_dict:
    print(key,my_dict[key])

dict_keys(['HanXiaoyang', 'Jason', 'David'])






dict_values([1234, 4567, 6789])






1234






2345






{'HanXiaoyang': 7890, 'Jason': 4567, 'David': 6789}






False



HanXiaoyang 7890
Jason 4567
David 6789

# 注意，字典是一种键值对数据结构，本身是无序的，如果需要顺序，可以用OrderedDict
od1=OrderedDict()#按主键首次插入顺序进行排序
od1['a']=7
od1['z']=8
od1['b']=9
od1

声明Statement与Expression表达式

statement声明

a='小象学院'#statement通常为赋值语句
b=100
c=a

expression表达式（通常有返回结果 ）

#值、变量和运算符共同组成的整体我们将其称为表达式。通常有值表达式、变量表达式、计算表达式、字符串表达式,
b,b+100,a+' is amazing',__builtins__

exec执行声明语句,eval执行表达式

exec('a=5')
a
b=3
eval('a+b+5')

13

判断，循环与循环控制

判断逻辑

#### 判断：if， if else ,if elif与三元表达式

#单if
age=88
if age<18:
    print('teenage')
    
#if else elif
if age<18:
    print('teenage')
else:
    print('adult')
    
#if elif
if age<18:
    print('teenage')
elif age >18 and age <60:
    print('adult')
elif age>60:
    print('elder')


#三元表达式
'a' if age>50 else 'b'

循环逻辑

#For循环
str1='小象学院机器学习'
for item in str1:
    print(item)
print("")

#While循环
countnum=1
while(countnum<5):
    print(countnum)
    countnum+=1    
print("")

#### break与continue循环控制     
i=0
while True:
    i+=1
    if i==3:
        continue
    if i>5:
        break
    print(i)

小
象
学
院
机
器
学
习

1
2
3
4

1
2
4
5

扩展：列表推导式List Comprehensions，可迭代对象Iterable与迭代器iterator,生成器generator

#列表推导式：从一个列表中生成一个新的列表，简化了循环的写法
l1= [x+1 for x in range(30) if x%3==0] #新的list中的元素，来源于从0-29这个list中所有整除3的元素+1
l1

[1, 4, 7, 10, 13, 16, 19, 22, 25, 28]

l1=[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
l2=iter(l1)
l2.__next__()

0

#可迭代对象Iterable：可以被for循环的对象统称为可迭代对象Iterable,list,str,dict这些都是可迭代类型
#迭代器Iterator：可以被next调用的迭代器。
#next(l1) #TypeError: 'list' object is not an iterator

#使用iter将一来个可迭代对象变为迭代器
l1=iter(l1)
next(l1),next(l1)


#生成器Generator：首先是一个迭代器，然后其内容是按需生成
#列表是一次性生成，缺点是当内容过大时会占用大量内容，那能不能用到多少生成多少呢？
#Python里一边循环一边计算(惰性计算)的迭代器称为生成器（Generator）

#1.直接从列表表达式生成
g1= (x**2 for x in range(30) if x%2==0)
type(g1)
next(g1),next(g1),next(g1),next(g1),g1.__next__(),g1.__next__()

#2.函数生成，与yield关键字
def g2_func(n):
    for i in range(n):
        yield i**2
    
g2=g2_func(7)
next(g2),next(g2),g2.__next__(),g2.__next__(),g2.__next__(),g2.__next__()

#yield from/子迭代器，后面直接是可迭代对象。
def yield_from_iter(iter_object):
    yield from iter_object
    
y1=yield_from_iter('China')
y1.__next__(),next(y1)

异常与调试

#一个出现异常的例子
a=12
b=0
print(a/b)
print(12/6)

---------------------------------------------------------------------------

ZeroDivisionError                         Traceback (most recent call last)

<ipython-input-49-10dfecf82e87> in <module>()
      2 a=12
      3 b=0
----> 4 print(a/b)
      5 print(12/6)


ZeroDivisionError: division by zero

异常/exception对象

异常同样也是Python对象，表示一个在程序执行过程中发生了影响正常运行时而产生的一个事件(产生一个traceback.)

|常见异常|说明|
|—😐–:--|
|NameError|尝试访问一个没有申明的变量|
|ZeroDivisionError|除数为0|
|SyntaxError|语法错误|
|IndexError|索引超出序列范围|
|KeyError|请求一个不存在的字典关键字|
|IOError|输入输出错误（比如你要读的文件不存在）|
|AttributeError|尝试访问未知的对象属性|
|ValueError|传给函数的参数类型不正确，比如给int()函数传入字符串形|

捕获并处理异常对象

捕捉异常对象要使用try/except,或try/else,try/finally 语句
try语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理

#try except else 
try:
    a=never_named_value
    #a=2
    print(int(a))
except Exception as e:
    print(e)
else:
    print('Everything is fine')

name 'never_named_value' is not defined
end line

#try-finally 无法是否捕获了异常，都会执行finally后的语句
x = 5
#y = 2
y = 0
try:
    result = x / y
except ZeroDivisionError:
    print("division by zero!")
else:
    print("result is", result)
finally:
    print("executing finally clause")

division by zero!
executing finally clause

函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

你可以定义一个由自己想要功能的函数，以下是简单的规则：

• 函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
• 任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
• 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
• 函数内容以冒号起始，并且缩进。
• return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

函数定义

def my_sum(a, b):
    "我是一个求和函数"
    return a+b+1
my_sum(4,5)

10

# 定义斐波那契数列
def fib(n):
    a, b =1, 1
    for i in range(n):
        print(a, end=" ")
        a,b = b,a+b
    print()

fib(10)

1 1 2 3 5 8 13 21 34 55 

默认参数

# 函数默认参数
def printinfo(name, age = 35):
   print("姓名:", name)
   print("年龄:", age)
   return
 
#调用printinfo函数
printinfo(age=50, name="隔壁老王");
printinfo(name="隔壁老王");

姓名: 隔壁老王
年龄: 50
姓名: 隔壁老王
年龄: 35

变长参数函数

def printinfo(arg1, *vartuple):
   "打印任何传入的参数"
   print("输出:")
   print(arg1)
   print(vartuple)
   return
 
# 调用printinfo 函数
printinfo(10)
printinfo(70, 60, 50)

输出:
10
()
输出:
70
(60, 50)

匿名函数

# python 使用 lambda 来创建匿名函数。lambda [arg1,arg2,.....argn]:expression
sum = lambda arg1, arg2: arg1 + arg2;
 
# 调用sum函数
print("相加后的值为:", sum( 10, 20 ))
print("相加后的值为:", sum( 20, 30 ))

相加后的值为: 30
相加后的值为: 50

内置高阶函数

python中有很多非常实用的內建函数和高阶函数

filter

filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

#判断是否为正数
def is_positive(x):
    return x > 0
result = filter(is_positive,[1,3,5,-1,-10,0])
list(result)

[1, 3, 5]

map

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

## 每个元素求平方
def f(x):
    return x * x
result = map(f,[1,3,5,-1,-10,0])
list(result)

[1, 9, 25, 1, 100, 0]

reduce

reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。

from functools import reduce
## 求和
def add(x,y):
    return x + y
result = reduce(add,[1,3,5,-1,-10,0])
result

-2

文件与目录操作

读文件

# 要以读文件的模式打开一个文件对象，使用Python内置的`open()`函数，传入文件名和标示符：
f = open('print_str.py', 'r')
# 如果文件打开成功，接下来，调用read()方法可以一次读取文件的全部内容，Python把内容读到内存，用一个str对象表示：
f.read()
# 最后一步是调用close()方法关闭文件。文件使用完毕后必须关闭，因为文件对象会占用操作系统的资源
f.close()

'print("欢迎大家学习课程内容！")'

# 异常处理模式
try:
    f = open('/path/to/file', 'r')
    print(f.read())
except Exception as e:
    print e
finally:
    if f:
        f.close()

# 逐行读取
with open('test.py', 'r') as f:
    for line in f.readlines():
        print(line.strip())

for item in range(100):
print(item)

写文件

with open('test.txt', 'w') as f:
    f.write('Hello, world!\n')
    f.write('new line')

14






8

lines = ['Hello, python!\n', 'New text!']
with open('new.txt', 'w') as f:
    f.writelines(lines)

目录操作

# 需要用到os内置模块
import os
# 列举当前绝对路径
os.path.abspath('.')
# 新建文件夹
os.mkdir('./testdir')
# 文件重命名
os.rename('test.txt', 'test2.txt')
# 列出当前路径下的所有文件夹
[x for x in os.listdir('.') if os.path.isdir(x)]
# 列出当前路径下的所有python脚本文件
[x for x in os.listdir('.') if os.path.isfile(x) and os.path.splitext(x)[1]=='.py']

'/Users/yaoqiang/Documents/小象/课程/1.python_and_coding_skills'






['.ipynb_checkpoints', 'testdir']






['print_str.py', 'test.py']

面向对象

面向对象编程

• 类class与对象object

• 对属于同一类事物的抽象叫类class
  • 比如汽车，蛋糕，猫。
  • 之前学习使用的都是Python自带的数据类，这节课我们学习自己定义类class
• 某类事物中的一个具体的实例叫对象Object
  • 比如小区门口的那辆黑色的奥迪汽车，好利来里的那种奶油芝士蛋糕，隔壁小花家的那只小花猫。

• 类与对象的关系

• 类定义封装了数据与方法，类就是对象的模板，可以批量生产出许多的对象。
  • 比如a=7,7其实是整形数字int类的一个实例。那int这个类还可以’复刻’出许许多多的整形对象。这些对象共有的特征就是：整数性。
• 类(class)的变量是所有对象共享使用, 只有一个拷贝, 所有对象修改, 都可以被其他对象所见;
• 对象(object)的变量由类的每个对象所拥有, 每个对象都包含自己的一份拷贝, 不会影响其他对象;

# 类的设计与创建
# 使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾，类的主体由类成员，方法，数据属性组成

class Employee:
    "所有员工的基类"
    empCount = 0

    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
        Employee.empCount += 1

    def displayCount(self):
        print("总共雇员数量 %d" % Employee.empCount)

    def displayEmployee(self):
        print("姓名: ", self.name,  ", 工资: ", self.salary)
        
# empCount 变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount 访问。
# 第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
# self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

# 创建对象
"创建 Employee 类的第一个对象"
emp1 = Employee("张三", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("李四", 5000)

# 调用成员函数
emp1.displayEmployee()
emp2.displayEmployee()
print("总共雇员数%d" % Employee.empCount)

姓名:  张三 , 工资:  2000
姓名:  李四 , 工资:  5000
总共雇员数2

#__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
#__doc__ :类的文档字符串
#__name__: 类名
#__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
#__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）
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__)

Employee.__doc__: 所有员工的基类
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: (<class 'object'>,)
Employee.__dict__: {'__module__': '__main__', '__doc__': '所有员工的基类', 'empCount': 2, '__init__': <function Employee.__init__ at 0x10aa75ea0>, 'displayCount': <function Employee.displayCount at 0x10aa75b70>, 'displayEmployee': <function Employee.displayEmployee at 0x10aa75f28>, '__dict__': <attribute '__dict__' of 'Employee' objects>, '__weakref__': <attribute '__weakref__' of 'Employee' objects>}

更多面向对象编程的知识可以参考python面向对象编程

第三方库使用

python比较强大的地方之一，是有着非常活跃的社区和强大的第三方库，很多时候你需要做的事情可以借助标准库或者第三方库快速完成。

第三方库——Python Imaging Library，这是Python下非常强大的处理图像的工具库。一般来说，第三方库都会在Python官方的pypi.python.org网站注册，要安装一个第三方库，必须先知道该库的名称，可以在官网或者pypi上搜索，比如Python Imaging Library的名称叫pillow，因此，安装Python Imaging Library的命令就是：

!pip install pillow

Requirement already satisfied: pillow in /usr/local/lib/python3.6/site-packages (5.2.0)
[33mYou are using pip version 10.0.1, however version 19.0.3 is available.
You should consider upgrading via the 'pip install --upgrade pip' command.[0m

from PIL import Image
im = Image.open('../img/python.png')
print(im.format, im.size, im.mode)
im.show() #本地会跳出一个弹窗显示图片
im.thumbnail((400, 100)) #对图片进行resize
im.save('python.jpg', 'JPEG') #存储图片

JPEG (1870, 434) RGB

c__’: ‘所有员工的基类’, ‘empCount’: 2, ‘init’: <function Employee.init at 0x10aa75ea0>, ‘displayCount’: <function Employee.displayCount at 0x10aa75b70>, ‘displayEmployee’: <function Employee.displayEmployee at 0x10aa75f28>, ‘dict’: <attribute ‘dict’ of ‘Employee’ objects>, ‘weakref’: <attribute ‘weakref’ of ‘Employee’ objects>}

更多面向对象编程的知识可以参考python面向对象编程

第三方库使用

python比较强大的地方之一，是有着非常活跃的社区和强大的第三方库，很多时候你需要做的事情可以借助标准库或者第三方库快速完成。

第三方库——Python Imaging Library，这是Python下非常强大的处理图像的工具库。一般来说，第三方库都会在Python官方的pypi.python.org网站注册，要安装一个第三方库，必须先知道该库的名称，可以在官网或者pypi上搜索，比如Python Imaging Library的名称叫pillow，因此，安装Python Imaging Library的命令就是：

!pip install pillow

Requirement already satisfied: pillow in /usr/local/lib/python3.6/site-packages (5.2.0)
[33mYou are using pip version 10.0.1, however version 19.0.3 is available.
You should consider upgrading via the 'pip install --upgrade pip' command.[0m

from PIL import Image
im = Image.open('../img/python.png')
print(im.format, im.size, im.mode)
im.show() #本地会跳出一个弹窗显示图片
im.thumbnail((400, 100)) #对图片进行resize
im.save('python.jpg', 'JPEG') #存储图片

JPEG (1870, 434) RGB