Python基础学习

第一章Python的介绍

1、python介绍

一种面向对象，面向函数的解释型计算机程序设计语言，由荷兰人Guido van Rossum于1989年发明，第一个公开发行版发行于1991年。Python是纯粹的自由软件， 源代码和解释器CPython遵循 GPL(GNU General Public License)协议[2]. Python语法简洁清晰，特色之一是强制用空白符(white space)作为语句缩进。Python具有丰富和强大的库。它常被昵称为胶水语言，能够把用其他语言制作的各种模块（尤其是C/C++）很轻松地联结在一起。常见的一种应用情形是，使用Python快速生成程序的原型（有时甚至是程序的最终界面），然后对其中[3] 有特别要求的部分，用更合适的语言改写，比如3D游戏中的图形渲染模块，性能要求特别高，就可以用C/C++重写，而后封装为Python可以调用的扩展类库。需要注意的是在您使用扩展类库时可能需要考虑平台问题，某些可能不提供跨平台的实现。

2、Python的历史

自从20世纪90年代初Python语言诞生至今，它已被逐渐广泛应用于系统管理任务的处理和Web编程。
Python的创始人为Guido van Rossum。1989年圣诞节期间，在阿姆斯特丹，Guido为了打发圣诞节的无趣，决心开发一个新的脚本解释程序，做为ABC 语言的一种继承。之所以选中Python（大蟒蛇的意思）作为该编程语言的名字，是因为他是一个叫Monty Python的喜剧团体的爱好者。
ABC是由Guido参加设计的一种教学语言。就Guido本人看来，ABC 这种语言非常优美和强大，是专门为非专业程序员设计的。但是ABC语言并没有成功，究其原因，Guido 认为是其非开放造成的。Guido 决心在Python 中避免这一错误。同时，他还想实现在ABC 中闪现过但未曾实现的东西。
就这样，Python在Guido手中诞生了。可以说，Python是从ABC发展起来，主要受到了Modula-3（另一种相当优美且强大的语言，为小型团体所设计的）的影响。并且结合了Unix shell和C的习惯。
Python[4] 已经成为最受欢迎的程序设计语言之一。2011年1月，它被TIOBE编程语言排行榜评为2010年度语言。自从2004年以后，python的使用率呈线性增长[5] 。
由于Python语言的简洁性、易读性以及可扩展性，在国外用Python做科学计算的研究机构日益增多，一些知名大学已经采用Python来教授程序设计课程。例如卡耐基梅隆大学的编程基础、麻省理工学院的计算机科学及编程导论就使用Python语言讲授。众多开源的科学计算软件包都提供了Python的调用接口，例如著名的计算机视觉库OpenCV、三维可视化库VTK、医学图像处理库ITK。而Python专用的科学计算扩展库就更多了，例如如下3个十分经典的科学计算扩展库：NumPy、SciPy和matplotlib，它们分别为Python提供了快速数组处理、数值运算以及绘图功能。因此Python语言及其众多的扩展库所构成的开发环境十分适合工程技术、科研人员处理实验数据、制作图表，甚至开发科学计算应用程序。
说起科学计算，首先会被提到的可能是MATLAB。然而除了MATLAB的一些专业性很强的工具箱还无法替代之外，MATLAB的大部分常用功能都可以在Python世界中找到相应的扩展库。和MATLAB相比，用Python做科学计算有如下优点：
● 首先，MATLAB是一款商用软件，并且价格不菲。而Python完全免费，众多开源的科学计算库都提供了Python的调用接口。用户可以在任何计算机上免费安装Python及其绝大多数扩展库。
● 其次，与MATLAB相比，Python是一门更易学、更严谨的程序设计语言。它能让用户编写出更易读、易维护的代码。
● 最后，MATLAB主要专注于工程和科学计算。然而即使在计算领域，也经常会遇到文件管理、界面设计、网络通信等各种需求。而Python有着丰富的扩展库，可以轻易完成各种高级任务，开发者可以用Python实现完整应用程序所需的各种功能。

3、Python优缺点

简单————Python是一种代表简单主义思想的语言。阅读一个良好的Python程序就感觉像是在读英语一样，尽管这个英语的要求非常严格！Python的这种伪代码本质是它最大的优点之一。它使你能够专注于解决问题而不是去搞明白语言本身。
易学————就如同你即将看到的一样，Python极其容易上手。前面已经提到了，Python有极其简单的语法。
免费、开源————Python是FLOSS（自由/开放源码软件）之一。简单地说，你可以自由地发布这个软件的拷贝、阅读它的源代码、对它做改动、把它的一部分用于新的自由软件中。FLOSS是基于一个团体分享知识的概念。这是为什么Python如此优秀的原因之一——它是由一群希望看到一个更加优秀的Python的人创造并经常改进着的。
高层语言————当你用Python语言编写程序的时候，你无需考虑诸如如何管理你的程序使用的内存一类的底层细节。
可移植性————由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。如果你小心地避免使用依赖于系统的特性，那么你的所有Python程序无需修改就可以在下述任何平台上面运行。这些平台包括Linux、Windows、FreeBSD、Macintosh、Solaris、OS/2、Amiga、AROS、AS/400、BeOS、OS/390、z/OS、Palm OS、QNX、VMS、Psion、Acom RISC OS、VxWorks、PlayStation、Sharp Zaurus、Windows CE甚至还有PocketPC、Symbian以及Google基于linux开发的Android平台！
解释性————这一点需要一些解释。一个用编译性语言比如C或C++写的程序可以从源文件（即C或C++语言）转换到一个你的计算机使用的语言（二进制代码，即0和1）。这个过程通过编译器和不同的标记、选项完成。当你运行你的程序的时候，连接/转载器软件把你的程序从硬盘复制到内存中并且运行。而Python语言写的程序不需要编译成二进制代码。你可以直接从源代码运行程序。在计算机内部，Python解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。事实上，由于你不再需要担心如何编译程序，如何确保连接转载正确的库等等，所有这一切使得使用Python更加简单。由于你只需要把你的Python程序拷贝到另外一台计算机上，它就可以工作了，这也使得你的Python程序更加易于移植。
面向对象————Python既支持面向过程的编程也支持面向对象的编程。在“面向过程”的语言中，程序是由过程或仅仅是可重用代码的函数构建起来的。在“面向对象”的语言中，程序是由数据和功能组合而成的对象构建起来的。与其他主要的语言如C++和Java相比，Python以一种非常强大又简单的方式实现面向对象编程。
可扩展性————如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分程序用C或C++编写，然后在你的Python程序中使用它们。
丰富的库————Python标准库确实很庞大。它可以帮助你处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。记住，只要安装了Python，所有这些功能都是可用的。这被称作Python的“功能齐全”理念。除了标准库以外，还有许多其他高质量的库，如wxPython、Twisted和Python图像库等等。
规范的代码————Python采用强制缩进的方式使得代码具有极佳的可读性。

4、Python应用场景

Web应用开发
Python经常被用于Web开发。比如，通过mod_wsgi模块，Apache可以运行用Python编写的Web程序。Python定义了WSGI标准应用接口来协调Http服务器与基于Python的Web程序之间的通信。一些Web框架，如Django,TurboGears,web2py,Zope等，可以让程序员轻松地开发和管理复杂的Web程序。
操作系统管理、服务器运维的自动化脚本
在很多操作系统里，Python是标准的系统组件。 大多数Linux发行版以及NetBSD、OpenBSD和Mac OS X都集成了Python，可以在终端下直接运行Python。有一些Linux发行版的安装器使用Python语言编写，比如Ubuntu的Ubiquity安装器,Red Hat Linux和Fedora的Anaconda安装器。Gentoo Linux使用Python来编写它的Portage包管理系统。Python标准库包含了多个调用操作系统功能的库。通过pywin32这个第三方软件 包，Python能够访问Windows的COM服务及其它Windows API。使用IronPython，Python程序能够直接调用.Net Framework。一般说来，Python编写的系统管理脚本在可读性、性能、代码重用度、扩展性几方面都优于普通的shell脚本。
科学计算机器学习
NumPy,SciPy,Matplotlib可以让Python程序员编写科学计算程序。
服务器软件（网络软件）——阿里云
Python对于各种网络协议的支持很完善，因此经常被用于编写服务器软件、网络爬虫。第三方库Twisted支持异步网络编程和多数标准的网络协议(包含客户端和服务器)，并且提供了多种工具，被广泛用于编写高性能的服务器软件。

第二章 python安装下载及基础语法

1、Python的下载

1、python网址：https://www.python.org/
2、anaconda网址：https://www.anaconda.com/

注意：Anaconda指的是一个开源的Python发行版本，其包含了conda、Python等180多个科学包及其依赖项，我直接安的annaconda,就不用再手动去下载某些库了！

2、Python的安装

1、Python安装比较简单，只需要双击安装即可，安装比较快（window）
2、anaconda同样是双击安装，但是安装过程的时间比较长，需要很多依赖项（window）

3、Python IDE的安装

1、eclipse插件安装
	Help—> eclipse marketplace—> pydev(较慢)
	插件包：加压拷贝到eclipse的dropins中，重启即可
2、pycharm安装
	傻瓜式安装，创建新的项目的时候直接选择sdk

4、交互式窗口(命令行编程)

配置环境变量

1、python:在cmd中直接输入python（配置环境变量）
[注]肯定是要配置了环境变量命令才有效！
2、ipython：找到对应的ipython的执行文件，直接执行
Ipython:支持变量自动补全，自动缩进，支持 bash shell 命令，内置了许多很有用的功能和函数
注意：Python中本身不带有这个ipython的交互，需要自行安装。首先查看计算机中是否包含pip，一般安装完之后有，执行python –m pip install –upgrade pip,先将pip进行更新，然后安装ipython：pip install ipython

5、Python的注释及乱码

1、单行注释：以#开头，#右边的所有东西当做说明，而不是真正要执行的程序，起辅助说明作用
2、多行注释：’’’多行注释’’’可以写多行的功能说明
3、Python乱码问题
   由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：
# -*- coding:utf-8 -*-
# coding=utf-8	

6、变量及类型

1、变量的定义
在程序中，有时我们需要对2个数据进行求和，那么该怎样做呢？
大家类比一下现实生活中，比如去超市买东西，往往咱们需要一个菜篮子，用来进行存储物品，等到所有的物品都购买完成后，在收银台进行结账即可
如果在程序中，需要把2个数据，或者多个数据进行求和的话，那么就需要把这些数据先存储起来，然后把它们累加起来即可
在Python中，存储一个数据，需要一个叫做变量的东西：
例如： num1=100
Num2=87
Result=num1+num2
变量三要素：变量的名称，变量的类型，变量的值
2、变量的类型
整数
Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。
计算机由于使用二进制，所以，有时候用十六进制表示整数比较方便，十六进制用0x前缀和0-9，a-f表示，例如：0xff00，0xa5b4c3d2，等等。
浮点数
浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是完全相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8，0.000012可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的？是的！），而浮点数运算则可能会有四舍五入的误差。
字符串
字符串是以单引号’或双引号"括起来的任意文本，比如’abc’，“xyz"等等。请注意，’'或”“本身只是一种表示方式，不是字符串的一部分，因此，字符串’abc’只有a，b，c这3个字符。如果’本身也是一个字符，那就可以用”"括起来，比如"I’m OK"包含的字符是I，’，m，空格，O，K这6个字符。
如果字符串内部既包含’又包含"怎么办？可以用转义字符\来标识，比如：
‘I’m “OK”!’
表示的字符串内容是：
I’m “OK”!
转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\表示的字符就是\，可以在Python的交互式命令行用print()打印字符串看看：
如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r’‘表示’‘内部的字符串默认不转义，可以自己试试：
如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用’’’…’’‘的格式表示多行内容，
print(’’‘line1
line2
line3’’’)
布尔值
布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来
布尔值可以用and、or和not运算。
and运算是与运算，只有所有都为True，and运算结果才是True：
空值
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型，我们后面会继续讲到。
怎样知道一个变量的类型呢？
在python中，只要定义了一个变量，而且它有数据，那么它的类型就已经确定了，不需要咱们开发者主动的去说明它的类型，系统会自动辨别
可以使用type(变量的名字)，来查看变量的类型
3、常见的数据类型转换

7、标识符和关键字

1、标识符
开发人员在程序中自定义的一些符号和名称，标示符是自己定义的,如变量名 、函数名等
2、标示符的规则
标示符由字母、下划线和数字组成，且数字不能开头。不能有特殊符号：,/,;,#，并且Python区分大小写！
3、关键字
python一些具有特殊功能的标示符，这就是所谓的关键字
关键字，是python已经使用的了，所以不允许开发者自己定义和关键字相同的名字的标示符
查看关键字:(保留字)
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
可以通过以下命令进行查看当前系统中python的关键字：

import keyword##导入这个模块
keyword.kwlist

8、输入与输出

1、普通的输出

打印提示
print(‘hello world’)
用print()在括号中加上字符串，就可以向屏幕上输出指定的文字。比如输出’hello, world’，用代码实现如下：

print(‘hello, world’)

print()函数也可以接受多个字符串，用逗号“,”隔开，就可以连成一串输出：

print(‘The quick brown fox’, ‘jumps over’, ‘the lazy dog’)
The quick brown fox jumps over the lazy dog

print()会依次打印每个字符串，遇到逗号“,”会输出一个空格，因此，输出的字符串是这样拼起来的：

print()也可以打印整数，或者计算结果：

print(300)
300>>> print(100 + 200)
300
因此，我们可以把计算100 + 200的结果打印得更漂亮一点：

print(‘100 + 200 =’, 100 + 200)
100 + 200 = 300
注意，对于100 + 200，Python解释器自动计算出结果300，但是，'100 + 200 ='是字符串而非数学公式，Python把它视为字符串，请自行解释上述打印结果。

2、格式化输出
最后一个常见的问题是如何输出格式化的字符串。我们经常会输出类似’亲爱的xxx你好！你xx月的话费是xx，余额是xx’之类的字符串，而xxx的内容都是根据变量变化的，所以，需要一种简便的格式化字符串的方式。

在Python中，采用的格式化方式和C语言是一致的，用%实现，举例如下：

‘Hello, %s’ % ‘world’
‘Hello, world’

‘Hi, %s, you have $%d.’ % (‘Michael’, 1000000)
‘Hi, Michael, you have $1000000.’
你可能猜到了，%运算符就是用来格式化字符串的。在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个%?占位符，后面就跟几个变量或者值，顺序要对应好。如果只有一个%?，括号可以省略。
常见的占位符有：
%d 整数
%f 浮点数
%s 字符串
%x 十六进制整数
其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：

‘%2d-%02d’ % (3, 1)
’ 3-01’

‘%.2f’ % 3.1415926
‘3.14’
如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串：

‘Age: %s. Gender: %s’ % (25, True)
‘Age: 25. Gender: True’
有些时候，字符串里面的%是一个普通字符怎么办？这个时候就需要转义，用%%来表示一个%：

‘growth rate: %d %%’ % 7
‘growth rate: 7 %’

3、输入
如果要让用户从电脑输入一些字符怎么办？Python提供了一个input()，可以让用户输入字符串，并存放到一个变量里

1. python2版本中
   1.1 raw_input()
   在Python中，获取键盘输入的数据的方法是采用 raw_input 函数。
   看如下示例:
   注意:
   raw_input()的小括号中放入的是，提示信息，用来在获取数据之前给用户的一个简单提示
   raw_input()在从键盘获取了数据以后，会存放到等号右边的变量中
   raw_input()会把用户输入的任何值都作为字符串来对待
   1.2 input()
   input()函数与raw_input()类似，但其接受的输入作为是表达式。
   input()接受表达式输入，并把表达式的结果赋值给等号左边的变量
   raw_input()输入的都当成字符串（和Python3的input功能一样）
2. python3版本中
   没有raw_input()函数，只有input()
   并且 python3中的input与python2中的raw_input()功能一样

9、运算符

print("%d+%d=%d"%(100,200,300))
a=input("请输入字符串")
print(a)
print(10/3)##结果3.333333
print(10//3)##结果3
print(2**3)##结果8，幂
abc=input("请输入数字")
num=int(abc)
if num<20:
    print("青年")
elif num<30:
    print("中年")
else:
    print("老年")
    ##python中没有++.--的操作，但有符合运算符，比如
    ##+=,-=,*=...

逻辑运算符都用单词来表示，比如and,or,not。

第三章 Python的逻辑判断和循环

1、if elif else条件判断

计算机之所以能做很多自动化的任务，因为它可以自己做条件判断。
elif是else if的缩写，完全可以有多个elif，所以if语句的完整形式就是：
if <条件判断1>:
<执行1>
elif <条件判断2>:
<执行2>
elif <条件判断3>:
<执行3>
else:
<执行4>

比如，输入用户年龄，根据年龄打印不同的内容，在Python程序中，用if语句实现：
age = 20
if age >= 18:
print(‘your age is’, age)
print(‘adult’)
根据Python的缩进规则，如果if语句判断是True，就把缩进的两行print语句执行了，否则，什么也不做。
也可以给if添加一个else语句，意思是，如果if判断是False，不要执行if的内容，去把else执行了：
age = 3
if age >= 18:
print(‘your age is’, age)
print(‘adult’)
else:
print(‘your age is’, age)
print(‘teenager’)

注意不要少写了冒号:。
当然上面的判断是很粗略的，完全可以用elif做更细致的判断：
age = 3
if age >= 18:
print(‘adult’)
elif age >= 6:
print(‘teenager’)
else:
print(‘kid’)

if判断条件还可以简写，比如写：
if x:
print(‘True’)

只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False。

2、input陷阱

最后看一个有问题的条件判断。很多同学会用input()读取用户的输入，这样可以自己输入，程序运行得更有意思：
birth = input('birth: ')
if birth < 2000:
print(‘00前’)
else:
print(‘00后’)
输入1982，结果报错：
这是因为input()返回的数据类型是str，str不能直接和整数比较，必须先把str转换成整数。Python提供了int()函数来完成这件事情：
s = input('birth: ')
birth = int(s)
if birth < 2000:
print(‘00前’)
else:
print(‘00后’)

再次运行，就可以得到正确地结果。但是，如果输入abc呢？又会得到一个错误信息：
Traceback (most recent calllast):
File “”, line 1, in
ValueError: invalid literal forint() with base 10: ‘abc’
原来int()函数发现一个字符串并不是合法的数字时就会报错，程序就退出了。
如何检查并捕获程序运行期的错误呢？后面的错误和调试会讲到。

3、if嵌套的格式

if 条件1:
满足条件1 做的事情1
满足条件1 做的事情2
…(省略)…
if 条件2:
满足条件2 做的事情1
满足条件2 做的事情2
…(省略)…
说明：
外层的if判断，也可以是if-else
内层的if判断，也可以是if-else
根据实际开发的情况，进行选择

4、循环结构

1、循环介绍

要计算1+2+3，我们可以直接写表达式：

1 + 2 + 3=6
要计算1+2+3+…+10，勉强也能写出来。
但是，要计算1+2+3+…+10000，直接写表达式就不可能了。
为了让计算机能计算成千上万次的重复运算，我们就需要循环语句。
Python的循环有两种，一种是for…in循环，另外一种是while循环。
2、while循环
while循环的格式
while 条件:
条件满足时，做的事情1
条件满足时，做的事情2
条件满足时，做的事情3
…(省略)…
pass 和while没有关系
while循环应用

1. 计算1~100的累积和（包含1和100）
   参考代码如下:

#encoding=utf-8
i = 1
sum = 0
while i<=100:
    sum = sum + i
    i += 1
print("1~100的累积和为:%d"%sum)

4、for循环

像while循环一样，for可以完成循环的功能。
在Python中 for循环可以遍历任何序列的项目，如一个列表或者一个字符串等。
for循环的格式
for 临时变量 in 列表或者字符串等:
循环满足条件时执行的代码
else:
循环不满足条件时执行的代码

5、break和continue

1、break
在循环中，break语句可以提前退出循环。例如，本来要循环打印1～100的数字：

n = 1
while n <=100:
print(n)
n = n + 1
print('END')

上面的代码可以打印出1~100。
如果要提前结束循环，可以用break语句：

n = 1
while n <= 100:
if n > 10: # 当n = 11时，条件满足，执行break语句
break # break语句会结束当前循环print(n)
n = n + 1
print('END')

执行上面的代码可以看到，打印出1~10后，紧接着打印END，程序结束。
可见break的作用是提前结束循环。
2、continue
在循环过程中，也可以通过continue语句，跳过当前的这次循环，直接开始下一次循环。

n = 0
while n < 10:
n = n + 1
print(n)

上面的程序可以打印出1～10。但是，如果我们想只打印奇数，可以用continue语句跳过某些循环：

n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0: # 如果n是偶数，执行continue语句continue# continue语句会直接继续下一轮循环，后续的print()语句不会执行print(n)

执行上面的代码可以看到，打印的不再是1～10，而是1，3，5，7，9。
可见continue的作用是提前结束本轮循环，并直接开始下一轮循环。

[案例]打印九九乘法表的while和for版本

i=1
while i<10:
    j=1
    while j<=i:
        print("%d*%d=%d"%(j,i,j*i),end="\t")
        if(i==j):
          print()
        j+=1
    i+=1

for k in range(1,10):#k从1取到9,range是左闭右开
    for m in range(1,k+1):
        print("%d*%d=%d" % (m, k, m * k), end="\t")##end=’\t‘是每个输出结果后空一格，行内空格，默认是'\n',这是换行！
        if (m== k):
            print()
size=width,high=300,400
print(size)##这是个元组类型,结果为(300,400)

第四章 集合类型

1、字符串

**1、下标索引**
所谓下标，就是编号，就好比超市中的存储柜的编号，通过这个编号就能找到相应的存储空间
字符串实际上就是字符的数组，所以也支持下标索引。

如果有字符串:name = ‘abcdef’，在内存中的实际存储如下:

如果想取出部分字符，那么可以通过下标的方法，（注意python中下标从 0 开始）

name = 'abcdef'
   print(name[0])
   print(name[1])
   print(name[-2])

*2、切片(分片)

切片是指对操作的对象截取其中一部分的操作。字符串、列表、元组都支持切片操作。
切片的语法：[起始:结束:步长]
步长：表示下标变化的规律。
注意：选取的区间属于左闭右开型，即从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)。
我们以字符串为例讲解。
如果取出一部分，则可以在中括号[]中，使用:

name = 'abcdef'
print(name[0:3]) # 取 下标0~2 的字符
name = 'abcdef'
print(name[0:5]) # 取 下标为0~4 的字符
name = 'abcdef'
print(name[3:5]) # 取 下标为3、4 的字符
name = 'abcdef'
print(name[2:]) # 取 下标为2开始到最后的字符
name = 'abcdef'
print(name[1:-1]) # 取 下标为1开始 到 最后第2个  之间的字符

a = “abcdef”
a[:3]
‘abc’

a[::2]
‘ace’

a[5:1:2]
‘’

a[1:5:2]
‘bd’

a[::-2]
‘fdb’

a[5:1:-2]
‘fd’

3、字符串常见操作
如有字符串mystr = ‘hello world and bjsxt yunshuxueyuan sxt beijing’，以下是常见的操作
<1>find == java Indexof方法
检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1
mystr.find(str, start=0, end=len(mystr))
<2>index
跟find()方法一样，只不过如果str不在 mystr中会报一个异常.
mystr.index(str, start=0, end=len(mystr))
<3>count
返回 str在start和end之间 在 mystr里面出现的次数
mystr.count(str, start=0, end=len(mystr))
<4>replace
把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.
mystr.replace(str1, str2, mystr.count(str1))
<5>split
以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串
mystr.split(str=" ", 2)
<6>capitalize
把字符串的第一个字符大写
mystr.capitalize()
<7>title
把字符串的每个单词首字母大写
<8>startswith
检查字符串是否是以 obj 开头, 是则返回 True，否则返回 False
mystr.startswith(obj)
<9>endswith
检查字符串是否以obj结束，如果是返回True,否则返回 False.
mystr.endswith(obj)
<10>lower
转换 mystr 中所有大写字符为小写
mystr.lower()
<11>upper
转换 mystr 中的小写字母为大写
mystr.upper()
<12>ljust
返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
mystr.ljust(width)
<13>rjust
返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
mystr.rjust(width)
<14>center
返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
mystr.center(width)
<15>lstrip
删除 mystr 左边的空白字符
mystr.lstrip()
<16>rstrip
删除 mystr 字符串末尾的空白字符
mystr.rstrip()
<17>strip —java trim
删除mystr字符串两端的空白字符
<18>rfind
类似于 find()函数，不过是从右边开始查找.
mystr.rfind(str, start=0,end=len(mystr) )
<19>rindex
类似于 index()，不过是从右边开始.
mystr.rindex( str, start=0,end=len(mystr))
<20>partition
把mystr以str分割成三部分,str前，str和str后
mystr.partition(str)
<21>rpartition
类似于 partition()函数,不过是从右边开始.
mystr.rpartition(str)
<22>splitlines
按照换行符分隔，返回一个包含各行作为元素的列表
mystr.splitlines()
<23>isalpha
如果 mystr 所有字符都是字母 则返回 True,否则返回 False
mystr.isalpha()
<24>isdigit
如果 mystr 只包含数字则返回 True 否则返回 False.
mystr.isdigit()
<25>isalnum
如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False
mystr.isalnum()
<26>isspace
如果 mystr 中只包含空格，则返回 True，否则返回 False.
mystr.isspace()
<27>join
mystr 中每个字符后面插入list的每个元素后面,构造出一个新的字符串
mystr.join(list)

2、列表

1、列表介绍
Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。
比如，列出班里所有同学的名字，就可以用一个list表示：

classmates = [‘Michael’, ‘Bob’, ‘Tracy’]
classmates
[‘Michael’, ‘Bob’, ‘Tracy’]

变量classmates就是一个list。用len()函数可以获得list元素的个数：

len(classmates)
3
用索引来访问list中每一个位置的元素，记得索引是从0开始的：

classmates[0]
‘Michael’

classmates[1]
‘Bob’

classmates[2]
‘Tracy’

classmates[3]
Traceback (most recent call last):
File “”, line 1, in
IndexError: list index out of range
当索引超出了范围时，Python会报一个IndexError错误，所以，要确保索引不要越界，记得最后一个元素的索引是len(classmates) -

如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：

classmates[-1]
‘Tracy’
以此类推，可以获取倒数第2个、倒数第3个：

2、列表的相关操作
列表中存放的数据是可以进行修改的，比如"增"、“删”、“改”"
<1>添加元素("增"append, extend, insert)
append
通过append可以向列表添加元素
extend（+）
通过extend可以将另一个集合中的元素逐一添加到列表中

a = [1, 2]
b = [3, 4]
a.append(b)
a
[1, 2, [3, 4]]

a.extend(b)
a
[1, 2, [3, 4], 3, 4]

insert
insert(index, object) 在指定位置index前插入元素object

a = [0, 1, 2]
a.insert(1, 3)
a
[0, 3, 1, 2]

<2>修改元素(“改”)
修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改
<3>查找元素("查"in, not in, index, count)
所谓的查找，就是看看指定的元素是否存在
in, not in
python中查找的常用方法为：
in（存在）,如果存在那么结果为true，否则为false
not in（不存在），如果不存在那么结果为true，否则false
#查找是否存在if findName in nameList:
print(‘在字典中找到了相同的名字’)
else:
print(‘没有找到’)
说明：
in的方法只要会用了，那么not in也是同样的用法，只不过not in判断的是不存在
index, count
index和count与字符串中的用法相同

a = [‘a’, ‘b’, ‘c’, ‘a’, ‘b’]
a.index(‘a’, 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
File “”, line 1, in
ValueError: 'a’isnotin list

a.index(‘a’, 1, 4)
3>>> a.count(‘b’)
2>>> a.count(‘d’)
0
<4>删除元素("删"del, pop, remove)
类比现实生活中，如果某位同学调班了，那么就应该把这个条走后的学生的姓名删除掉；在开发中经常会用到删除这种功能。
列表元素的常用删除方法有：
del：根据下标进行删除，其实可以删除所有变量
pop：默认删除最后一个元素
remove：根据元素的值进行删除第一个

l
[‘abcdef’, [‘aaa’, ‘bb’, ‘ccc’], ‘ddd’, ‘fff’]

del l[0]
l
[[‘aaa’, ‘bb’, ‘ccc’], ‘ddd’, ‘fff’]
<5>排序(sort, reverse)
sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True可改为倒序，由大到小。
reverse方法是将list逆置。

a = [1, 4, 2, 3]
a
[1, 4, 2, 3]

a.reverse()
a
[3, 2, 4, 1]

a.sort()
a
[1, 2, 3, 4]

a.sort(reverse=True)
a
[4, 3, 2, 1]
<6>enumerate()

chars = [‘a’, ‘b’, ‘c’, ‘d’]
for i, chr in enumerate(chars):
… print i, chr
…
0 a
1 b
2 c
3 d

【案例】

a="abcdefg"
b=a[::]
b=a[1:5:2]
b=a[5:1:-1]
print(b)
list1=[123,"abc",True,123.21]
list2=[2,4,6,8,10]
##list1.extend(list2)//合并列表
##list1.append(111)//从末尾添加元素
##list1.insert(1,"bfg")//指定位置添加
##list1.remove(True)
##list1.pop(2)
##del list1
##print(list1)

3、元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

aTuple = (‘et’,77,99.9)
aTuple (‘et’,77,99.9)
如果要定义一个空的tuple，可以写成()：

t = ()
t ()
但是，要定义一个只有1个元素的tuple，如果你这么定义：

t = (1)
t 1
定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

t = (1,)
t (1,)
Python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。
最后来看一个“可变的”tuple：

t = (‘a’, ‘b’, [‘A’, ‘B’])
t[2][0] = ‘X’
t[2][1] = ‘Y’
t (‘a’, ‘b’, [‘X’, ‘Y’])
这个tuple定义的时候有3个元素，分别是’a’，‘b’和一个list。不是说tuple一旦定义后就不可变了吗？怎么后来又变了？
别急，我们先看看定义的时候tuple包含的3个元素：

当我们把list的元素’A’和’B’修改为’X’和’Y’后，tuple变为：

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！
理解了“指向不变”后，要创建一个内容也不变的tuple怎么做？那就必须保证tuple的每一个元素本身也不能变。

<1>访问元组

<2>修改元组

说明： python中不允许修改元组的数据，包括不能删除其中的元素。
<3>元组的内置函数count, index
index和count与字符串和列表中的用法相同

a = (‘a’, ‘b’, ‘c’, ‘a’, ‘b’)
a.index(‘a’, 1, 3) # 注意是左闭右开区间
Traceback (most recent call last): File “”, line 1, in ValueError: tuple.index(x): x notin tuple

a.index(‘a’, 1, 4)
3

a.count(‘b’)
2

a.count(‘d’)
0

4、字典

**1、字典的介绍**

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。
举个例子，假设要根据同学的名字查找对应的成绩，如果用list实现，需要两个list：
names = [‘Michael’, ‘Bob’, ‘Tracy’]
scores = [95, 75, 85]
给定一个名字，要查找对应的成绩，就先要在names中找到对应的位置，再从scores取出对应的成绩，list越长，耗时越长。
如果用dict实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查找成绩，无论这个表有多大，查找速度都不会变慢。用Python写一个dict如下：

d = {‘Michael’: 95, ‘Bob’: 75, ‘Tracy’: 85}
d[‘Michael’]
95
软件开发中的字典
变量info为字典类型：
info = {‘name’:‘班长’, ‘id’:100, ‘sex’:‘f’, ‘address’:‘地球亚洲中国北京’}
说明：
字典和列表一样，也能够存储多个数据
列表中找某个元素时，是根据下标进行的
字典中找某个元素时，是根据’名字’（就是冒号:前面的那个值，例如上面代码中的’name’、‘id’、‘sex’）
字典的每个元素由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值
若访问不存在的键，则会报错：

info[‘age’]
Traceback (most recent call last):
File “”, line 1, in
KeyError: ‘age’
在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值：

age = info.get(‘age’)
age #'age’键不存在，所以age为None>>> type(age)

age = info.get(‘age’, 18) # 若info中不存在’age’这个键，就返回默认值18
age
18

2、字典的常见操作
<1>修改元素
字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改
demo:

info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
newId = input('请输入新的学号')
info['id'] = int(newId)
print('修改之后的id为%d:'%info['id']

<2>添加元素
demo:访问不存在的元素

info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}
print('id为:%d'%info['id'])

结果:

如果在使用 变量名[‘键’] = 数据 时，这个“键”在字典中，不存在，那么就会新增这个元素
demo:添加新的元素

info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}
 print('id为:%d'%info['id'])#程序会终端运行，因为访问了不存在的键
newId = input('请输入新的学号')
info['id'] = newId
print('添加之后的id为:%d'%info['id'])

结果:
请输入新的学号188
添加之后的id为: 188
<3>删除元素
对字典进行删除操作，有一下几种：
del
clear()
demo:del删除指定的元素

info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}
print('删除前,%s'%info['name'])
del info['name']
print('删除后,%s'%info['name'])

demo:del删除整个字典

info = {'name':'monitor', 'sex':'f', 'address':'China'}
print('删除前,%s'%info)
del info
print('删除后,%s'%info)

demo:clear清空整个字典
3、字典的常见函数：
<1>len()
测量字典中，键值对的个数
<2>keys == map.keySet()
返回一个包含字典所有KEY的列表
<3>values
返回一个包含字典所有value的列表
<4>items
返回一个包含所有（键，值）元祖的列表
<5>has_key （python2.7版本） == in 条件表达式
dict.has_key(key)如果key在字典中，返回True，否则返回False
4、字典遍历
<1> 遍历字典的key（键）

<2> 遍历字典的value（值）

<3> 遍历字典的项（元素）

<4> 遍历字典的key-value（键值对）

6、总结：
1、请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。
2、和list比较，dict有以下几个特点：
1）查找和插入的速度极快，不会随着key的增加而变慢；
2）需要占用大量的内存，内存浪费多。
3）而list相反：查找和插入的时间随着元素的增加而增加；占用空间小，浪费内存很少。
所以，dict是用空间来换取时间的一种方法。
3、dict可以用在需要高速查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，需要牢记的第一条就是dict的key必须是不可变对象。这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。这个通过key计算位置的算法称为哈希算法（Hash）。
要保证hash的正确性，作为key的对象就不能变。在Python中，字符串、整数等都是不可变的，因此，可以放心地作为key。而list是可变的，就不能作为key

5、可变类型与不可变类型

上面我们讲了，str是不变对象，而list是可变对象。

对于可变对象，比如list，对list进行操作，list内部的内容是会变化的，比如：

a = [‘c’, ‘b’, ‘a’]
a.sort()
a [‘a’, ‘b’, ‘c’]
而对于不可变对象，比如str，对str进行操作呢：

a = ‘abc’
a.replace(‘a’, ‘A’) ‘Abc’
a ‘abc’
虽然字符串有个replace()方法，也确实变出了’Abc’，但变量a最后仍是’abc’，应该怎么理解呢？
我们先把代码改成下面这样：

a = ‘abc’
b = a.replace(‘a’, ‘A’)
b ‘Abc’>>> a ‘abc’
要始终牢记的是，a是变量，而’abc’才是字符串对象！有些时候，我们经常说，对象a的内容是’abc’，但其实是指，a本身是一个变量，它指向的对象的内容才是’abc’：

当我们调用a.replace(‘a’, ‘A’)时，实际上调用方法replace是作用在字符串对象’abc’上的，而这个方法虽然名字叫replace，但却没有改变字符串’abc’的内容。相反，replace方法创建了一个新字符串’Abc’并返回，如果我们用变量b指向该新字符串，就容易理解了，变量a仍指向原有的字符串’abc’，但变量b却指向新字符串’Abc’了：

所以，对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。
总结：
1、可变类型，值可以改变：
列表 list
字典 dict
set （没有value的字典）
2、不可变类型，值不可以改变：
数值类型 int, long, bool, float
字符串 str
元组 tuple

【案例】

a=(123,"abc",True,[123,456,789])
a[3][0]=456
dict={"name":"张三","age":18,"sex":"男"}
print(dict["name"])
print(dict.get("name"))
dict["email"]="747009798"
set1={1,"name","sex"}
tou=(1,)
set2=set(["name","sex","age"])
print(set2)

结果：张三
张三
{‘name’, ‘sex’, ‘age’}

第五章Python的函数

1、函数介绍

我们知道圆的面积计算公式为：S = πr2。
当我们知道半径r的值时，就可以根据公式计算出面积。假设我们需要计算3个不同大小的圆的面积：
r1 = 12.34 r2 = 9.08 r3 = 73.1
s1 = 3.14 * r1 * r1
s2 = 3.14 * r2 * r2
s3 = 3.14 * r3 * r3
当代码出现有规律的重复的时候，你就需要当心了，每次写3.14 * x * x不仅很麻烦，而且，如果要把3.14改成3.14159265359的时候，得全部替换。
有了函数，我们就不再每次写s = 3.14 * x * x，而是写成更有意义的函数调用s = area_of_circle(x)，而函数area_of_circle本身只需要写一次，就可以多次调用。
基本上所有的高级语言都支持函数，Python也不例外。Python不但能非常灵活地定义函数，而且本身内置了很多有用的函数，可以直接调用。

2、函数的定义与调用

1、定义函数
定义函数的格式如下：
def 函数名(): 代码
demo:
#定义一个函数，能够完成打印信息的功能

def printInfo():
print'------------------------------------'
print' 人生苦短，我用Python'
print'------------------------------------'

2、调用函数
定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它
调用函数很简单的，通过 函数名() 即可完成调用
demo:
#定义完函数后，函数是不会自动执行的，需要调用它才可以
printInfo()
3、函数参数（一）
思考一个问题，如下：
现在需要定义一个函数，这个函数能够完成2个数的加法运算，并且把结果打印出来，该怎样设计？下面的代码可以吗？有什么缺陷吗？

def add_2num(): 
a = 11 
b = 22 
c = a+b 
print c 

为了让一个函数更通用，即想让它计算哪两个数的和，就让它计算哪两个数的和，在定义函数的时候可以让函数接收数据，就解决了这个问题，这就是 函数的参数
<1> 定义带有参数的函数
示例如下：

def add2num(a, b): 
c = a+b 
print c 

<2> 调用带有参数的函数
以调用上面的add2num(a, b)函数为例:

def add2num(a, b): 
c = a+b 
print c 

add2num(11, 22) #调用带有参数的函数时，需要在小括号中，传递数据
<3> 练一练
要求：定义一个函数，完成前2个数完成加法运算，然后对第3个数，进行减法；然后调用这个函数
使用def定义函数，要注意有3个参数
调用的时候，这个函数定义时有几个参数，那么就需要传递几个参数
<4> 小总结
定义时小括号中的参数，用来接收参数用的，称为 “形参”
调用时小括号中的参数，用来传递给函数用的，称为 “实参”
4、函数参数（二）
1. 缺省参数
调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入：

def printinfo( name, age = 35 ):# 打印任何传入的字符串
print"Name: ", name 
print"Age ", age # 调用printinfo函数 
printinfo(name="miki" ) 
printinfo( age=9,name="miki" ) 

以上实例输出结果：
Name: miki Age 35
Name: miki Age 9
注意：带有默认值的参数一定要位于参数列表的最后面。

defprintinfo(name, age=35, sex):
… print name
…
File “”, line 1 SyntaxError: non-default argument follows default argument
2.不定长参数
有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。
基本语法如下：
Def functionname([formal_args,] args, **kwargs):“函数_文档字符串”
function_suite
return [expression]
加了星号（）的变量args会存放所有未命名的变量参数，args为元组；而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典。

def fun(a, b, *args, **kwargs):
… “”“可变参数演示示例”""
… print"a =", a
… print"b =", b
… print"args =", args
… print"kwargs: "
… for key, value in kwargs.items():
… print key, “=”, value
…

fun(1, 2, 3, 4, 5, m=6, n=7, p=8) # 注意传递的参数对应
a = 1
b = 2
args = (3, 4, 5)
kwargs: p = 8 m = 6 n = 7

c = (3, 4, 5)
d = {“m”:6, “n”:7, “p”:8}
fun(1, 2, *c, **d) # 注意元组与字典的传参方式
a = 1
b = 2
args = (3, 4, 5)
kwargs: p = 8 m = 6 n = 7

fun(1, 2, c, d) # 注意不加星号与上面的区别
a = 1
b = 2
args = ((3, 4, 5), {‘p’: 8, ‘m’: 6, ‘n’: 7})
kwargs:

3. 引用传参
   可变类型与不可变类型的变量分别作为函数参数时，会有什么不同吗？
   Python有没有类似C语言中的指针传参呢？

def selfAdd(a):… “”“自增”""… a += a
…

a_int = 1
a_int 1
selfAdd(a_int)
a_int 1
a_list = [1, 2]
a_list [1, 2]
selfAdd(a_list)
a_list [1, 2, 1, 2]
Python中函数参数是引用传递（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量自身；而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。

5、函数返回值（一）
<1>带有返回值的函数
想要在函数中把结果返回给调用者，需要在函数中使用return
如下示例:
def add2num(a, b):
c = a+b
return c
或者
def add2num(a, b):
return a+b
<2>保存函数的返回值
在本小节刚开始的时候，说过的“买烟”的例子中，最后儿子给你烟时，你一定是从儿子手中接过来 对么，程序也是如此，如果一个函数返回了一个数据，那么想要用这个数据，那么就需要保存
保存函数的返回值示例如下:

#定义函数
def add2num(a, b):
return a+b #调用函数，顺便保存函数的返回值
result = add2num(100,98) #因为result已经保存了add2num的返回值，所以接下来就可以使用了
print result
6、函数的返回值（二）
在python中我们可不可以返回多个值？

def divid(a, b):
… shang = a//b
… yushu = a%b
… return shang, yushu
…

sh, yu = divid(5, 2)
sh 5
yu 1
本质是利用了元组

7、局部变量和全局变量
1、局部变量
局部变量（Local variables）指在程序中只在特定过程或函数中可以访问的变量。

总结
1、局部变量，就是在函数内部定义的变量
2、不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
3、局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储，这就是它的作用
2、全局变量
<1>什么是全局变量
如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量

<2>全局变量和局部变量名字相同问题
<3>修改全局变量
既然全局变量，就是能够在所有的函数中进行使用，那么可否进行修改呢？：global
<4>可变类型的全局变量

a = 1
deff():
… a += 1
… print a
…

f()
Traceback (most recent call last): File “”, line 1, in File “”, line 2, in f UnboundLocalError: local variable ‘a’ referenced before assignment

li = [1,]
deff2():
… li.append(1)
… print li
…

f2() [1, 1]
li [1, 1]
<5>总结1:
在函数外边定义的变量叫做全局变量
全局变量能够在所有的函数中进行访问

如果在函数中修改全局变量，那么就需要使用global进行声明，否则出错
如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的，小技巧：强龙不压地头蛇
<5>总结2：
在函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向，即不能将全局变量指向新的数据。
对于不可变类型的全局变量来说，因其指向的数据不能修改，所以不使用global时无法修改全局变量。
对于可变类型的全局变量来说，因其指向的数据可以修改，所以不使用global时也可修改全局变量。
可变类型：值可以修改（内存地址不变但是所保存的值变化了），引用可以修改（变量的内存地址变化了）
不可变类型：值不可以修改，可以修改变量的引用（=赋值号）。

在函数里面修改全局变量：
1、如果全局变量是可变类型：所以在函数里面任意修改（值，引用）
2、如果全局变量是不可变类型：在函数里面不能修改值，也不能修改引用，除非加上global才能修改引用。

8、递归函数
<1>什么是递归函数
通过前面的学习知道一个函数可以调用其他函数。
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。
<2>递归函数的作用
举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * … * n
解决办法1:

看阶乘的规律
1! = 1 2! = 2 × 1 = 2 × 1! 3! = 3 × 2 × 1 = 3 × 2! 4! = 4 × 3 × 2 × 1 = 4 × 3! … n! = n × (n-1)!
解决办法2:

递归函数案例：
斐波拉契数列，该数列中有n个数字。
1 1 2 3 5 8
该数列中，从第三个数字开始：数值 =前一个数字 + 前前面一个数字
(n-1) + (n-2)
9、匿名函数
1、匿名函数
用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
lambda函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,…argn]]:
expression
如下实例：
sum = lambda arg1, arg2: arg1 + arg2 #调用sum函数
print"Value of total : ", sum( 10, 20 )
print"Value of total : ", sum( 20, 20 )
以上实例输出结果：
Value of total : 30
Value of total : 40
Lambda函数能接收任何数量的参数但只能返回一个表达式的值
匿名函数不能直接调用print，因为lambda需要一个表达式
2、应用场合
函数作为参数传递
1、自己定义函数

def fun(a, b, opt):
… print"a =", a
… print"b =", b
… print"result =", opt(a, b)
…

fun(1, 2, lambda x,y:x+y)
a = 1
b = 2
result = 3

2、作为内置函数的参数
想一想，下面的数据如何指定按age或name排序？
stus = [ {“name”:“zhangsan”, “age”:18}, {“name”:“lisi”, “age”:19}, {“name”:“wangwu”, “age”:17} ]
按name排序：

stus.sort(key = lambda x:x[‘name’])
stus [{‘age’: 19, ‘name’: ‘lisi’}, {‘age’: 17, ‘name’: ‘wangwu’}, {‘age’: 18, ‘name’: ‘zhangsan’}]

按age排序：

stus.sort(key = lambda x:x[‘age’])
stus [{‘age’: 17, ‘name’: ‘wangwu’}, {‘age’: 18, ‘name’: ‘zhangsan’}, {‘age’: 19, ‘name’: ‘lisi’}]

【案例】

def fun1(a,b,*args,**kwargs):
 c=a+b
 print(args)
 for k,v in kwargs.items():
     print(k,v)
 return c
print(fun1(1,2,3,4,5,6,k=1,v=2))
s=[1,2,3]
def fun2(s):
    s+=s
    return s
print(fun2(s))
def fun3():
    a,b,c=1,2,3
    return a,b,c
print(fun3())
count=0
def fun4():
    ##count=20
    global count##可以将全局的值改掉
    count=30
    print(count)
fun4()
print(count)
def fun5(a,b,opt):
    print(a)
    print(b)
    print(opt(a,b))
fun5(1,2,lambda a,b:a+b)##lambda后相当于参数,冒号后是函数体！也是匿名函数最终的结果

第六章Python的文件操作

1、文件的打开与关闭

想一想：如果想用word编写一份简历，应该有哪些流程呢？

1、打开word软件，新建一个word文件
2、写入个人简历信息
3、保存文件
4、关闭word软件
同样，在操作文件的整体过程与使用word编写一份简历的过程是很相似的 （io操作）
1、打开文件，或者新建立一个文件
2、读/写数据
3、关闭文件
<1>打开文件
在python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件
open(文件名，访问模式)
示例如下：

f = open(r'd:\nata\test.txt', 'w') 

说明:


<2>关闭文件
close( )
示例如下：
#新建一个文件，文件名为:

test.txt f = open('test.txt', 'w') # 关闭这个文件 
f.close()

2、文件的读写
<1>写数据(write)
使用write()可以完成向文件写入数据
demo:

f = open('test.txt', 'w') f.write('hello world, i am here!') f.close() 

注意：如果文件不存在那么创建，如果存在那么就先清空，然后写入数据
<2>读数据(read)
使用read(num)可以从文件中读取数据，num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据
demo:

f = open('test.txt', 'r') 
content = f.read(1024) 
print(content) 
print("-"*30) 
content = f.read() 
print(content) 
f.close() 

注意：如果open是打开一个文件，那么可以不用谢打开的模式，即只写 open(‘test.txt’)，如果使用读了多次，那么后面读取的数据是从上次读完后的位置开始的
<3>读数据（readlines）
就像read没有参数时一样，readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素

#coding=utf-8 
f = open('test.txt', 'r') 
content = f.readlines() 
print(type(content)) 
i=1
for temp in content: 
print("%d:%s"%(i, temp)) 
i+=1 
f.close() 

<4>读数据（readline）

#coding=utf-8 
f = open('test.txt', 'r') 
content = f.readline() 
print("1:%s"%content) 
content = f.readline() 
print("2:%s"%content) 
f.close() 

3、文件的定位读写
<1>获取当前读写的位置tell
在读写文件的过程中，如果想知道当前的位置，可以使用tell()来获取
打开一个已经存在的文件

f = open("test.txt", "r") 
str = f.read(3) 
print"读取的数据是 : ", str 

查找当前位置

position = f.tell() 
print"当前文件位置 : ", position 
str = f.read(3) 
print"读取的数据是 : ", str 

查找当前位置

position = f.tell() 
print"当前文件位置 : ", position 
f.close() 

<2>定位到某个位置
如果在读写文件的过程中，需要从另外一个位置进行操作的话，可以使用seek()
seek(offset, from)有2个参数
offset:偏移量
from:方向
0:表示文件开头
1:表示当前位置
2:表示文件末尾
demo:把位置设置为：从文件开头，偏移5个字节
打开一个已经存在的文件

f = open("test.txt", "r") 
str = f.read(30) 
print"读取的数据是 : ", str 
# 查找当前位置 
position = f.tell() 
print"当前文件位置 : ", position 
# 重新设置位置 
f.seek(5,0) 
# 查找当前位置 
position = f.tell() 
print"当前文件位置 : ", position 
f.close() 
demo:把位置设置为：离文件末尾，3字节处
# 打开一个已经存在的文件 
f = open("test.txt", "r") 
# 查找当前位置 
position = f.tell() 
print"当前文件位置 : ", position 
# 重新设置位置 
f.seek(-3,2) 
# 读取到的数据为：文件最后3个字节数据 
str = f.read() 
print"读取的数据是 : ", 
str f.close()

4、文件的相关操作
有些时候，需要对文件进行重命名、删除等操作，python的os模块中都有这么功能
import os
python编程时，经常和文件、目录打交道，这是就离不了os模块。os模块包含普遍的操作系统功能，与具体的平台无关。以下列举常用的命令

1. os.name()——判断现在正在实用的平台，Windows 返回 ‘nt’; Linux 返回’posix’
   rename(需要修改的文件名, 新的文件名) 也可以做剪切。
2. os.getcwd()——得到当前工作的目录。
3. os.listdir()——指定所有目录下所有的文件和目录名。

以列表的形式全部列举出来，其中没有区分目录和文件。
4. os.remove()——删除指定文件
5. os.rmdir()——删除指定目录 ：该目录不能为空
6. os.mkdir()——创建目录
注意：这样只能建立一层，要想递归建立可用：os.makedirs(x/y/z)
7. os.path.isfile()——判断指定对象是否为文件。是返回True,否则False
8. os.path.isdir()——判断指定对象是否为目录。是True,否则False。例：
9. os.path.exists()——检验指定的对象是否存在。是True,否则False.例：
10. os.path.split()——返回路径的目录和文件名。

第七章 类和对象

1、面向对象编程介绍

面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。面向对象是一种对现实世界理解和抽象的方法。
“面向过程”(Procedure Oriented)是一种以过程为中心的编程思想。“面向过程”也可称之为“面向记录”编程思想，他们不支持丰富的“面向对象”特性（比如继承、多态、封装），并且它们不允许混合持久化状态和域逻辑。
就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
面向过程是一件事“该怎么做“，面向对象是一件事“该让谁来做”，然后那个“谁”就是对象，他要怎么做是他自己的事，反正最后一群对象合力能把事做好就行了。
面向对象三个特性:继承，封装，多态。

2、类和对象

面向对象编程的2个非常重要的概念：类和对象
对象是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义，提出了另外一个新的概念——类
类就相当于制造飞机时的图纸，用它来进行创建的飞机就相当于对象

1. 类
   人以类聚 物以群分。 具有相似内部状态和运动规律的实体的集合(或统称为抽象)。 具有相同属性和行为事物的统称
   类是抽象的,在使用的时候通常会找到这个类的一个具体的存在,使用这个具体的存在。一个类可以找到多个对象
2. 对象
   某一个具体事物的存在 ,在现实世界中可以是看得见摸得着的。 可以是直接使用的
   
   3. 类和对象之间的关系
      
      小总结：类就是创建对象的模板
3. 类的构成
   类(Class) 由3个部分构成
   类的名称:类名
   类的属性:一组数据
   类的方法:允许对进行操作的方法 (行为)
   <1> 举例：
   1）人类设计,只关心3样东西:
   事物名称(类名):人(Person)
   属性:身高(height)、年龄(age)
   方法(行为/功能):跑(run)、打架(fight)
   2）狗类的设计
   类名:狗(Dog)
   属性:品种 、毛色、性别、名字、 腿儿的数量
   方法(行为/功能):叫 、跑、咬人、吃、摇尾巴

3、定义类与创建对象

1、类的定义
定义一个类，格式如下：
class 类名: 方法列表
demo：定义一个Car类
定义类

classCar:
**#方法**
def getCarInfo(self): 
print('车轮子个数:%d, 颜色%s'%(self.wheelNum, self.color)) 
def move(self): 
print("车正在移动...") 

说明：
1、定义类时有2种：新式类和经典类，上面的Car为经典类，如果是Car(object)则为新式类
2、类名的命名规则按照"大驼峰"

2、创建对象
通过上一节课程，定义了一个Car类；就好比有车一个张图纸，那么接下来就应该把图纸交给生成工人们去生成了。
python中，可以根据已经定义的类去创建出一个个对象
创建对象的格式为:
对象名 = 类名()
创建对象demo:

#定义类
class Car:
#移动
def move(self): 
print('车在奔跑...') 
#鸣笛
def toot(self):#self可以不写self，方法中必须有且一个参数。第一个参数表示当前对象。名字随便取，但是习惯都写self 
print("车在鸣笛...嘟嘟..") 
#创建一个对象，并用变量BMW来保存它的引用 
BMW = Car() 
BMW.color = '黑色' 
BMW.wheelNum = 4#轮子数量 
BMW.move() 
BMW.toot() 
print(BMW.color) 
print(BMW.wheelNum) 

总结：
1、BMW = Car()，这样就产生了一个Car的实例对象，一定在内存中有一块空间存放对象的数据信息。此时也可以通过实例对象BMW来访问属性或者方法
2、第一次使用BMW.color = '黑色’表示给BMW这个对象添加属性，如果后面再次出现BMW.color = xxx表示对属性进行修改
3、BMW是一个对象，它拥有属性（数据）和方法（函数）
4、当创建一个对象时，就是用一个模子，来制造一个实物

4、self

1. 理解self
看如下示例:

#定义一个类 
class Animal: 
#方法 
def __init__(self, name): 
self.name = name 
def printName(self): 
print('名字为:%s'%self.name) 
#定义一个函数 
def myPrint(animal): 
animal.printName() 
dog1 = Animal('西西') 
myPrint(dog1) 
dog2 = Animal('北北')
myPrint(dog2) 

总结
1、所谓的self，可以理解为自己
2、可以把self当做C++中类里面的this指针一样理解，就是对象自身的意思
3、某个对象调用其方法时，python解释器会把这个对象作为第一个参数传递给self，所以开发者只需要传递后面的参数即可
2、init()方法
想一想:
在上一小节的demo中，我们已经给BMW这个对象添加了2个属性，wheelNum（车的轮胎数量）以及color（车的颜色），试想如果再次创建一个对象的话，肯定也需要进行添加属性，显然这样做很费事，那么有没有办法能够在创建对象的时候，就顺便把车这个对象的属性给设置呢？

<1>使用方式
def 类名:
#初始化函数，用来完成一些默认的设定
def__init__():pass
<2>init()方法的调用

#定义汽车类
classCar:
def__init__(self): 
self.wheelNum = 4 
self.color = '蓝色'
defmove(self): 
print('车在跑，目标:夏威夷') 
#创建对象 
BMW = Car() 
print('车的颜色为:%s'%BMW.color) 
print('车轮胎数量为:%d'%BMW.wheelNum) 

总结1
当创建Car对象后，在没有调用__init__()方法的前提下，BMW就默认拥有了2个属性wheelNum和color，原因是__init__()方法是在创建对象后，就立刻被默认调用了
想一想：
既然在创建完对象后__init__()方法已经被默认的执行了，那么能否让对象在调用__init__()方法的时候传递一些参数呢？如果可以，那怎样传递呢？

#定义汽车类
classCar:
def__init__(self, newWheelNum, newColor): 
self.wheelNum = newWheelNum 
self.color = newColor 
def move(self): 
print('车在跑，目标:夏威夷') 
#创建对象 
BMW = Car(4, 'green') 
print('车的颜色为:%s'%BMW.color) 
print('车轮子数量为:%d'%BMW.wheelNum) 

总结2
1、init()方法，在创建一个对象时默认被调用，不需要手动调用
2、init(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么__init__(self)中出了self作为第一个形参外还需要2个形参，例如__init__(self,x,y)
3、init(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去
3、__new__方法

classA(object):
def__init__(self): 
print("这是 init 方法") 
def__new__(cls): 
print("这是 new 方法") 
return object.__new__(cls) 
A() 

总结
1、__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供
2、__new__必须要有返回值，返回实例化出来的实例，这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例
3、__init__有一个参数self，就是这个__new__返回的实例，init__在__new__的基础上可以完成一些其它初始化的动作，init__不需要返回值
4、我们可以将类比作制造商，new__方法就是前期的原材料购买环节，init__方法就是在有原材料的基础上，加工，初始化商品环节


4、del()方法
创建对象后，python解释器默认调用__init()方法；
当删除一个对象时，python解释器也会默认调用一个方法，这个方法为__del()方法
当内存中构建一个对象数据的时候回调__init()方法，
当内存中销毁（释放）一个对象时回调__del()方法

import time 
classAnimal(object):
#初始化方法
#创建完对象后会自动被调用
def__init__(self, name): 
print('__init__方法被调用') 
self.__name = name 
#析构方法
#当对象被删除时，会自动被调用
def__del__(self): 
print("__del__方法被调用") 
print("%s对象马上被干掉了..."%self.__name) 
#创建对象 
dog = Animal("哈皮狗") 
#删除对象
del dog 
cat = Animal("波斯猫") 
cat2 = cat
cat3 = cat 
print("---马上 删除cat对象") 
del cat 
print("---马上 删除cat2对象") 
del cat2 
print("---马上 删除cat3对象") 
del cat3 
print("程序2秒钟后结束") 
time.sleep(2) 

总结
1、当有1个变量保存了对象的引用时，此对象的引用计数就会加1
2、当使用del删除变量指向的对象时，如果对象的引用计数不是1，比如3，那么此时只会让这个引用计数减1，即变为2，当再次调用del时，变为1，如果再调用1次del，此时会真的把对象进行删除
5、"魔法"方法

1. 打印id()
   如果把BMW使用print进行输出的话，会看到如下的信息
   
   即看到的是创建出来的BMW对象在内存中的地址
   2、定义__str__()方法

classCar:
def__init__(self, newWheelNum, newColor): 
self.wheelNum = newWheelNum 
self.color = newColor 
def__str__(self): 
msg = "嘿，我的颜色是" + self.color + "我有" + str(self.wheelNum) + "个轮胎..."
return msg 
def move(self): 
print('车在跑，目标:夏威夷') 
BMW = Car(4, "白色") 
print(BMW) 

总结
1、在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法
2、当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据
5、保护对象的属性
如果有一个对象，当需要对其进行修改属性时，有2种方法
对象名.属性名 = 数据 ---->直接修改
对象名.方法名() ---->间接修改
为了更好的保存属性安全，即不能随意修改，一般的处理方式为
将属性定义为私有属性
添加一个可以调用的方法，供调用

classPeople(object):
def__init__(self, name): 
self.__name = name 
defgetName(self):
return self.__name 
defsetName(self, newName):
if len(newName) >= 5: 
self.__name = newName 
else: 
print("error:名字长度需要大于或者等于5") 
xiaoming = People("bin") 
print(xiaoming.__name)

5、保护对象的属性

如果有一个对象，当需要对其进行修改属性时，有2种方法
对象名.属性名 = 数据 ---->直接修改
对象名.方法名() ---->间接修改
为了更好的保存属性安全，即不能随意修改，一般的处理方式为
将属性定义为私有属性
添加一个可以调用的方法，供调用

classPeople(object):
def__init__(self, name): 
self.__name = name 
defgetName(self):
return self.__name 
defsetName(self, newName):
if len(newName) >= 5: 
self.__name = newName 
else: 
print("error:名字长度需要大于或者等于5") 
xiaoming = People("bin") 
print(xiaoming.__name) 

classPeople(object):
def__init__(self, name): 
self.__name = name 
defgetName(self):
return self.__name 
defsetName(self, newName):
if len(newName) >= 5: 
self.__name = newName 
else: 
print("error:名字长度需要大于或者等于5") 
xiaoming = People("bin") 
xiaoming.setName("wanger") 
print(xiaoming.getName()) 
xiaoming.setName("lisi") 
print(xiaoming.getName()) 

总结
1、Python中没有像C++中public和private这些关键字来区别公有属性和私有属性
2、它是以属性命名方式来区分，如果在属性名前面加了2个下划线’__’，则表明该属性是私有属性，否则为公有属性（方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）。

6、继承

1. 继承的概念
在现实生活中，继承一般指的是子女继承父辈的财产，如下图

在程序中，继承描述的是事物之间的所属关系，例如猫和狗都属于动物，程序中便可以描述为猫和狗继承自动物；同理，波斯猫和巴厘猫都继承自猫，而沙皮狗和斑点狗都继承足够，如下如所示：

2. 继承示例

#定义一个父类，如下:
class Cat(object):
def __init__(self, name, color="白色"): 
self.name = name 
self.color = color 
def run(self): 
print("%s--在跑"%self.name) 
#定义一个子类，继承Cat类，如下:
classBosi(Cat):
def setNewName(self, newName): 
self.name = newName 
def eat(self): 
print("%s--在吃"%self.name) 
bs = Bosi("印度猫") 
print('bs的名字为:%s'%bs.name) 
print('bs的颜色为:%s'%bs.color) 
bs.eat() 
bs.setNewName('波斯') 
bs.run() 

说明：
虽然子类没有定义__init__方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，所以只要创建Bosi的对象，就默认执行了那个继承过来的__init__方法
总结
1、子类在继承的时候，在定义类时，小括号()中为父类的名字
2、父类的属性、方法，会被继承给子类
3. 注意点

class Animal(object):
def __init__(self, name='动物', color='白色'): 
self.__name = name 
self.color = color
def __test(self): 
print(self.__name) 
print(self.color) 
def test(self): 
print(self.__name) 
print(self.color) 
class Dog(Animal):
def dogTest1(self):
#print(self.__name) 
#不能访问到父类的私有属性 
print(self.color) 
def dogTest2(self):
#self.__test() 
#不能访问父类中的私有方法 
self.test() 
A = Animal() 
#print(A.__name) 
#程序出现异常，不能访问私有属性 
print(A.color) 
#A.__test() 
#程序出现异常，不能访问私有方法 
A.test() 
print("------分割线-----") 
D = Dog(name = "小花狗", color = "黄色") 
D.dogTest1() 
D.dogTest2() 

1、私有的属性，不能通过对象直接访问，但是可以通过方法访问
2、私有的方法，不能通过对象直接访问
3、私有的属性、方法，不会被子类继承，也不能被访问
4、一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起到安全的作用

7、多继承

1. 多继承
   
   从图中能够看出，所谓多继承，即子类有多个父类，并且具有它们的特征
   Python中多继承的格式如下:

#定义一个父类
classA:
def printA(self): 
print('----A----') 
#定义一个父类
classB:
def printB(self): 
print('----B----') 
 定义一个子类，继承自A、B
class C(A,B):
def printC(self): 
print('----C----') 
obj_C = C() 
obj_C.printA() 
obj_C.printB() 
运行结果:
----A---- 
----B---- 

说明：
1、python中是可以多继承的
2、父类中的方法、属性，子类会继承
注意点：
想一想:
如果在上面的多继承例子中，如果父类A和父类B中，有一个同名的方法，那么通过子类去调用的时候，调用哪个？

#coding=utf-8
class base(object): 
def test(self): 
print('----base test----') 
classA(base):
def test(self): 
print('----A test----') 
#定义一个父类
classB(base):
def test(self): 
print('----B test----') 
#定义一个子类，继承自A、B
classC(A,B):
pass 
obj_C = C() 
obj_C.test() 
print(C.__mro__) 
#可以查看C类的对象搜索方法时的先后顺序，C3算法得到一个元组

2、重写
<1>重写父类方法

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

#coding=utf-8 
class Cat(object): 
def sayHello(self): 
print("halou-----1") 
class Bosi(Cat): 
def sayHello(self): 
print("halou-----2") 
bosi = Bosi() bosi.sayHello() 

<2> 调用父类的方法

#coding=utf-8 
class Cat(object): 
def __init__(self,name): 
self.name = name 
self.color = 'yellow' 
class Bosi(Cat): 
def __init__(self,name): 
#调用父类的__init__方法1(python2) 
#Cat.__init__(self,name) 
#调用父类的__init__方法2 
#super(Bosi,self).__init__(name) 
#调用父类的__init__方法3 
super().__init__(name) 
def getName(self): 
return self.name 
bosi = Bosi('xiaohua') 
print(bosi.name) 
print(bosi.color)

8、多态

多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。
所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态
Python伪代码实现Java或C#的多态

classF1(object):
def show(self):
print'F1.show'
classS1(F1): 
def show(self):
print'S1.show'
classS2(F1):
defshow(self):
print'S2.show'

#由于在Java或C#中定义函数参数时，必须指定参数的类型# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类# 而实际传入的参数是：S1对象和S2对象
def Func(F1 obj):
“”“Func函数需要接收一个F1类型或者F1子类的类型”""
print obj.show()
s1_obj = S1()
Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show
s2_obj = S2() Func(s2_obj)

在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show

Python “鸭子类型”

class F1(object):
def show(self):
print'F1.show'
class S1(F1):
def show(self):
print'S1.show'
class S2(F1):
def show(self):
print'S2.show'
def Func(obj):
print obj.show() 
s1_obj = S1() 
Func(s1_obj) 
s2_obj = S2() 
Func(s2_obj)

9、类属性与实例属性

在了解了类基本的东西之后，下面看一下python中这几个概念的区别

先来谈一下类属性和实例属性
在前面的例子中我们接触到的就是实例属性（对象属性），顾名思义，类属性就是类对象所拥有的属性，它被所有类对象的实例对象所共有，在内存中只存在一个副本，这个和C++，java中类的静态成员变量有点类似。对于公有的类属性，在类外可以通过类对象和实例对象访问。

类属性：所属类，这个类下所有的对象都可以共享这个类属性。 相当于java中静态属性。

比如：
Class Person｛
public static String name=“abc”
｝
1、类属性
class People(object):
name = ‘Tom’#公有的类属性
__age = 12#私有的类属性
p = People() print(p.name) #正确
print(People.name) #正确
print(p.__age) #错误，不能在类外通过实例对象访问私有的类属性
print(People.age) #错误，不能在类外通过类对象访问私有的类属性
2、实例属性(对象属性)
classPeople(object):
address = ‘山东’#类属性
def__init(self):
self.name = ‘xiaowang’#实例属性
self.age = 20#实例属性
p = People()
p.age =12#实例属性
print(p.address) #正确
print(p.name) #正确
print(p.age) #正确
print(People.address) #正确
print(People.name) #错误
print(People.age) #错误
3、通过实例(对象)去修改类属性

classPeople(object): 
country = 'china'#类属性 
print(People.country) 
p = People() 
print(p.country) 
p.country = 'japan' 
print(p.country) #实例属性会屏蔽掉同名的类属性 
print(People.country) 
del p.country #删除实例属性 
print(p.country) 

10、类方法和静态方法

1. 类方法
   是类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以’cls’作为第一个参数的名字，就最好用’cls’了），能够通过实例对象和类对象去访问。

classPeople(object): 
country = 'china'#类方法，用classmethod来进行修饰  
@classmethod
def getCountry(cls):
return cls.country 
p = People() print 
p.getCountry() #可以用过实例对象引用
print People.getCountry() #可以通过类对象引用

类方法还有一个用途就是可以对类属性进行修改：

classPeople(object): 
country = 'china'#类方法，用classmethod来进行修饰 @classmethod
def getCountry(cls):
return cls.country 
@classmethod
Def setCountry(cls,country): 
cls.country = country 
p = People() 
print p.getCountry() #可以用过实例对象引用
print People.getCountry() #可以通过类对象引用 
p.setCountry('japan') 
print p.getCountry() 
print People.getCountry() 

结果显示在用类方法对类属性修改之后，通过类对象和实例对象访问都发生了改变
2. 静态方法
需要通过修饰器@staticmethod来进行修饰，静态方法不需要多定义参数

classPeople(object): 
country = 'china' 
@staticmethod#静态方法
Def getCountry():
return People.country 
print People.getCountry() 

总结
从类方法和实例方法以及静态方法的定义形式就可以看出来，类方法的第一个参数是类对象cls，那么通过cls引用的必定是类对象的属性和方法；而实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引用
方法类别 语法 描述
类方法 @classmethod 第一个形参cls。默认传递
静态方法 @staticmethod 没有默认传递的形参
对象方法（成员方法） def 方法名 第一个形参self ，默认传递

第八章 异常

1、异常简介

看如下示例:

print'-----test--1---' 
open('123.txt','r') 
print'-----test--2---'

运行结果:

说明:
打开一个不存在的文件123.txt，当找不到123.txt 文件时，就会抛出给我们一个IOError类型的错误，No such file or directory：123.txt （没有123.txt这样的文件或目录）
异常:
当Python检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的"异常"

2、捕获异常

<1>捕获异常 try...except...

看如下示例:
try:
print(’-----test–1—’)
open(‘123.txt’,‘r’)
print(’-----test–2—’)
except IOError:
pass
说明:
此程序看不到任何错误，因为用except 捕获到了IOError异常，并添加了处理的方法
pass 表示实现了相应的实现，但什么也不做；如果把pass改为print语句，那么就会输出其他信息
小总结:
把可能出现问题的代码，放在try中
把处理异常的代码，放在except中
<2> except捕获多个异常
看如下示例:

try: 
print num 
except IOError: 
print('产生错误了') 

想一想:
上例程序，已经使用except来捕获异常了，为什么还会看到错误的信息提示？
答:
except捕获的错误类型是IOError，而此时程序产生的异常为 NameError ，所以except没有生效
修改后的代码为:
try:
print num
except NameError:
print(‘产生错误了’)
实际开发中，捕获多个异常的方式，如下：
#coding=utf-8
try:
print(’-----test–1—’)
open(‘123.txt’,‘r’) # 如果123.txt文件不存在，那么会产生 IOError 异常 print(’-----test–2—’)
print(num)# 如果num变量没有定义，那么会产生 NameError 异常
except (IOError,NameError): #如果想通过一次except捕获到多个异常可以用一个元组的方式# errorMsg里会保存捕获到的错误信息
print(errorMsg)

注意：
当捕获多个异常时，可以把要捕获的异常的名字，放到except 后，并使用元组的方式仅进行存储
<3>获取异常的信息描述


<4>捕获所有异常


<5> else
咱们应该对else并不陌生，在if中，它的作用是当条件不满足时执行的实行；同样在try…except…中也是如此，即如果没有捕获到异常，那么就执行else中的事情

try: 
num = 100
print num 
except NameError as errorMsg: 
print('产生错误了:%s'%errorMsg) 
else: 
print('没有捕获到异常，真高兴') 

运行结果如下:

<6> try…finally…
try…finally…语句用来表达这样的情况：
在程序中，如果一个段代码必须要执行，即无论异常是否产生都要执行，那么此时就需要使用finally。 比如文件关闭，释放锁，把数据库连接返还给连接池等
demo:

import time 
try: 
f = open('test.txt') 
try: 
whileTrue: 
content = f.readline() 
if len(content) == 0: 
break 
time.sleep(2) 
print(content) 
except TypeError as ex: === catch(NullPointException ex) #如果在读取文件的过程中，产生了异常，那么就会捕获到#比如 按下了 ctrl+c
pass
finally: 
f.close() 
print('关闭文件') 
except: 
print("没有这个文件") 

说明:
test.txt文件中每一行数据打印，但是我有意在每打印一行之前用time.sleep方法暂停2秒钟。这样做的原因是让程序运行得慢一些。在程序运行的时候，按Ctrl+c中断（取消）程序。
我们可以观察到KeyboardInterrupt异常被触发，程序退出。但是在程序退出之前，finally从句仍然被执行，把文件关闭。

3、异常的传递

1. try嵌套中

import time 
try: 
f = open('test.txt') 
try: 
while True: 
content = f.readline() 
if len(content) == 0: 
break 
time.sleep(2) 
print(content) 
finally: 
f.close() 
print('关闭文件') 
except: 
print("没有这个文件") 

2. 函数嵌套调用中

def test1(): 
print("----test1-1----") 
print(num) 
print("----test1-2----") 
def test2(): 
print("----test2-1----") 
test1() 
print("----test2-2----") 
def test3():
try: 
print("----test3-1----") 
test1() 
print("----test3-2----") 
except Exception as result: 
print("捕获到了异常，信息是:%s"%result) 
print("----test3-2----") 
test3() 
print("------华丽的分割线-----") 
test2()

运行结果:

总结：
如果try嵌套，那么如果里面的try没有捕获到这个异常，那么外面的try会接收到这个异常，然后进行处理，如果外边的try依然没有捕获到，那么再进行传递。。。
如果一个异常是在一个函数中产生的，例如函数A---->函数B---->函数C,而异常是在函数C中产生的，那么如果函数C中没有对这个异常进行处理，那么这个异常会传递到函数B中，如果函数B有异常处理那么就会按照函数B的处理方式进行执行；如果函数B也没有异常处理，那么这个异常会继续传递，以此类推。。。如果所有的函数都没有处理，那么此时就会进行异常的默认处理，即通常见到的那样
注意观察上图中，当调用test3函数时，在test1函数内部产生了异常，此异常被传递到test3函数中完成了异常处理，而当异常处理完后，并没有返回到函数test1中进行执行，而是在函数test3中继续执行

4、自定义异常

你可以用raise语句来引发一个异常。异常/错误对象必须有一个名字，且它们应是Error或Exception类的子类
下面是一个引发异常的例子:

class ShortInputException(Exception):'''自定义的异常类'''
def__init__(self, length, atleast):
#super().__init__() 
self.length = length 
self.atleast = atleast 
def main():
try: 
s = input('请输入 --> ') 
if len(s) < 3: # raise引发一个你定义的异常
raise ShortInputException(len(s), 3) 
except ShortInputException as result:#x这个变量被绑定到了错误的实例 print('ShortInputException: 输入的长度是 %d,长度至少应是 %d'% (result.length, result.atleast)) 
else: 
print('没有异常发生.') 
main()

注意
以上程序中，关于代码#super().init()的说明
这一行代码，可以调用也可以不调用，建议调用，因为__init__方法往往是用来对创建完的对象进行初始化工作，如果在子类中重写了父类的__init__方法，即意味着父类中的很多初始化工作没有做，这样就不保证程序的稳定了，所以在以后的开发中，如果重写了父类的__init__方法，最好是先调用父类的这个方法，然后再添加自己的功能

5、异常处理中抛出异常

classTest(object):
def __init__(self, switch): 
self.switch = switch #开关
def calc(self, a, b):
try: 
return a/b 
except Exception as result: 
if self.switch: 
print("捕获开启，已经捕获到了异常，信息如下:") 
print(result) 
else: #重新抛出这个异常，此时就不会被这个异常处理给捕获到，从而触发默认的异常处理
raise 
a = Test(True) 
a.calc(11,0) 
print("----------------------华丽的分割线----------------") 
a.switch = False 
a.calc(11,0)

总结：
try:是异常捕获开始代码，try放在特别关心的那段代码前面
pass:如果这行代码出现了异常，那么后面的代码不会运行
pass2
pass3
except 异常的类型 as ex: 捕获某种类型的异常
except…多个except。按照顺序依次比对类型
else：没有异常时执行
finally：不管有没有异常都会执行

第九章Python模块及安装

1、模块的使用及安装
<1>Python中的模块
在Python中有一个概念叫做模块（module），这个和C语言中的头文件以及Java中的jar包很类似，比如在Python中要调用sqrt函数，必须用import关键字引入math这个模块，下面就来了解一下Python中的模块。
说的通俗点：模块就好比是工具包，要想使用这个工具包中的工具(就好比函数)，就需要导入这个模块
<2>import
在Python中用关键字import来引入某个模块，比如要引用模块math，就可以在文件最开始的地方用import math来引入。
形如:
import module1,mudule2…
当解释器遇到import语句，如果模块在当前的搜索路径就会被导入。
在调用math模块中的函数时，必须这样引用：
　　模块名.函数名

import math 
print sqrt(2)  #这样会报错 
print math.sqrt(2) #这样才能正确输出结果 

有时候我们只需要用到模块中的某个函数，只需要引入该函数即可，此时可以用下面方法实现：
<3>from…import
Python的from语句让你从模块中导入一个指定的部分到当前命名空间中
语法如下：
from modname import name1[, name2[, … nameN]]
例如，要导入模块fib的fibonacci函数，使用如下语句：
from fib import fibonacci
注意：不会把整个fib模块导入到当前的命名空间中，它只会将fib里的fibonacci单个引入
<4>from … import *
把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
from modname import *
注意：这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。
<5>定位模块
当你导入一个模块，Python解析器对模块位置的搜索顺序是：
1、当前目录
2、如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录。
3、如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/
4、模块搜索路径存储在system模块的sys.path变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。
<6>安装模块
conda create -n py2 python=2.7
conda install 模块
pip install 模块
pymysql
numpy
2、模块制作
<1>定义自己的模块
在Python中，每个Python文件都可以作为一个模块，模块的名字就是文件的名字。
比如有这样一个文件test.py，在test.py中定义了函数add
test.py
def add(a,b): return a+b
<2>调用自己定义的模块
那么在其他文件中就可以先import test，然后通过test.add(a,b)来调用了，当然也可以通过from test import add来引入
main.py
import test result = test.add(11,22) print(result)
<3>测试模块
在实际开中，当一个开发人员编写完一个模块后，为了让模块能够在项目中达到想要的效果，这个开发人员会自行在py文件中添加一些测试信息，例如：
test.py
def add(a,b): return a+b # 用来进行测试 ret = add(12,22) print(‘int test.py file,12+22=%d’%ret)
如果此时，在其他py文件中引入了此文件的话，想想看，测试的那段代码是否也会执行呢！
main.py
import test result = test.add(11,22) print(result)

至此，可发现test.py中的测试代码，应该是单独执行test.py文件时才应该执行的，不应该是其他的文件中引用而执行
为了解决这个问题，python在执行一个文件时有个变量__name__
可以根据__name__变量的结果能够判断出，是直接执行的python脚本还是被引入执行的，从而能够有选择性的执行测试代码
3、Python中的模块
1、python中的包

1. 引入包
   1.1 包就是一个目录
   1.2 把多个py文件放到同一个文件夹下
   1.3 使用import 文件夹.模块 的方式导入
   python3可以导入包,python2不行。
   1.4 使用from 文件夹 import 模块 的方式导入
   python3可以导入包,python2不行。
   1.5 在包的文件夹下创建__init__.py文件。
   在python2中：有一个目录，并且目录下有一个__init__.py的文件。才叫包。
   虽然文件内容没有，但是python2可以用了

有__init__.py文件在python3中没有有错。以后我们都在包的目录下新建一个init文件。
1.6 在__init__.py文件中写入
from . import 模块1
from . import 模块2
那么可以使用import 文件夹 导入
1.7 也可以使用from 文件夹 import 模块 的方式导入
总结：
包将有联系的模块组织在一起，即放到同一个文件夹下，并且在这个文件夹创建一个名字为__init__.py 文件，那么这个文件夹就称之为包
有效避免模块名称冲突问题，让应用组织结构更加清晰
2. init.py文件有什么用
init.py 控制着包的导入行为
2.1 init.py为空
仅仅是把这个包导入，不会导入包中的模块
2.2 (了解)可以在__init__.py文件中编写内容
可以在这个文件中编写语句，当导入时，这些语句就会被执行
init.py文件
4、模块的发布
1.mymodule目录结构体如下：
.
├── setup.py
├── suba
│ ├── aa.py
│ ├── bb.py
│ └── init.py
└── subb
├── cc.py
├── dd.py
└── init.py
2.编辑setup.py文件
py_modules需指明所需包含的py文件
from distutils.core import setup
setup(name=“压缩包的名字”, version=“1.0”, description=“描述”, author=“作者”, py_modules=[‘suba.aa’, ‘suba.bb’, ‘subb.cc’, ‘subb.dd’])
3.构建模块
python setup.py build
4.生成发布压缩包
python setup.py sdist
5、模块安装、使用
1.安装的方式
1、找到模块的压缩包（拷贝到其他地方）
2、解压
3、进入文件夹
4、执行命令python setup.py install
注意：如果在install的时候，执行目录安装，可以使用python setup.py install --prefix=安装路径
conda create -n py2 python=2.7
2.模块的引入
在程序中，使用from import 即可完成对安装的模块使用
from 模块名 import 模块名或者*

第十章 列表推导式

1、给程序传参数
import sys print(sys.argv)
2、列表推导式
1、所谓的列表推导式，就是指的轻量级循环创建列表：
a = [i for i in range(1,10)]
b= [11 for i in range(1,10)]
[(1,1),(2,4),(3,9),(4,16)…]
2、在循环的过程中使用if 来确定 列表中元素的条件
a = [i for i in range(1,10) if i%2==0]
3、2个for循环
a=[(i,j) for i in range(1,5) for j in range(6,10)]
4、3个for循环
a= [(x,y,z) for x in range(2) for y in range(2) for z in range(2)]

数据库简单操作

from pymysql import  *

conn = connect("localhost","root","123456","demo",3306)
cur = conn.cursor()
#查询
# count = cur.execute("select * from emp")
# print(count)
# result = cur.fetchall()
# for i in result:
#     print(i)
#添加记录
count = cur.execute("insert into emp(empno,ename) values(%d,%s)"%(2222,"'aaaa'"))
print(count)
conn.commit()
conn.close()

[注]记得导入pymysql模块