2021-02-14 大数据课程笔记 day25

@R星校长

Python教程

第一章Python的介绍

python介绍

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

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 实现完整应用程序所需的各种功能。

关键点常识

1、Python 的发音与拼写
2、Python 的意思是蟒蛇，源于作者喜欢 Monty Python 的喜剧团体
3、Python 的作者是 Guido van Rossum（龟叔）
4、Python 是龟叔在 1989 年圣诞节期间，为了打发无聊的圣诞节而用 C 编写的一个编程语言
5、Python 正式诞生于 1991 年
6、 Python 的解释器如今有多个语言实现，我们常用的是 CPython（官方版本的 C 语言实现），7、其他还有 Jython（可以运行在 Java 平台）、IronPython（可以运行在 .NET 和 Mono 平台）、PyPy（Python 实现的，支持JIT即时编译）
8、Python 目前有两个版本，Python2 和 Python3，最新版分别为 2.7.13 和 3.6.2，现阶段大部分公司用的是 Python2，Life is shot, you need Python. 人生苦短，我用 Python。
9、2021年2月份 编程语言用户量排行榜 ：https://www.tiobe.com/tiobe-index/

1.1.4 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采用强制缩进的方式使得代码具有极佳的可读性。

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 安装下载及基础语法

Python 的下载

1、python网址：https://www.python.org/
2、anaconda网址：https://www.anaconda.com/
注意：Anaconda 指的是一个开源的 Python 发行版本，其包含了 conda、Python 等 180 多个科学包及其依赖项。

Python 的安装

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

环境变量配置：
参考：https://www.cnblogs.com/yuxuefeng/articles/9235431.html

Python IDE 的安装

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

破解步骤：
1.将JetbrainsCrack-release-enc.jar拷贝到安装 pycharm 目录的 bin 文件夹下
2.修改 bin 目录下的两个配置文件：pycharm64.exe.vmoptions和 pycharm.exe.vmoptions
修改：内容

-Xms1024m
-Xmx1024m

添加内容：

-javaagent:D:\devsoft\JetBrains\PyCharm 2018.2.3\bin\JetbrainsCrack-release-enc.jar

3.启动 -> Activation code-> 输入《注册码.txt》文件中的内容即可完成破击

第一个案例程序 Python_helloworld

1、在任意的IDE中创建Python项目
2、创建Python file文件
3、输入代码 print(“hello ,python”)
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

Python 的注释及乱码

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

变量及类型

  1、变量的定义
  在程序中，有时我们需要对 2 个数据进行求和，那么该怎样做呢？
大家类比一下现实生活中，比如去超市买东西，往往咱们需要一个菜篮子，用来进行存储物品，等到所有的物品都购买完成后，在收银台进行结账即可
  如果在程序中，需要把 2 个数据，或者多个数据进行求和的话，那么就需要把这些数据先存储起来，然后把它们累加起来即可
  在 Python 中，存储一个数据，需要一个叫做变量的东西
  变量三要素：变量的名称，变量的类型，变量的值

  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’‘表示’‘内部的字符串默认不转义，可以自己试试：
  >>>print(r’I’m ok’)
  I’m ok
  如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用’’’…’’'的格式表示多行内容，
  布尔值
  布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来
  布尔值可以用and、or和not运算。
  and运算是与运算，只有所有都为True，and运算结果才是True：
  空值
  空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
  此外，Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型，我们后面会继续讲到。
  怎样知道一个变量的类型呢？
  在python中，只要定义了一个变量，而且它有数据，那么它的类型就已经确定了，不需要咱们开发者主动的去说明它的类型，系统会自动辨别
  可以使用type(变量的名字)，来查看变量的类型

  3、常见的数据类型转换

函数	说明
int(x [,base ])	将x转换为一个整数
long(x [,base ])	将x转换为一个长整数(pyhon2.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字符(pyhon2.x)
ord(x )	将一个字符转换为它的整数值 a->97
hex(x )	将一个整数转换为一个十六进制字符串
oct(x )	将一个整数转换为一个八进制字符串

标识符和关键字

  1、标识符
  开发人员在程序中自定义的一些符号和名称，标示符是自己定义的,如变量名 、函数名等

  2、标示符的规则
  标示符由字母、下划线和数字组成，且数字不能开头。不能有特殊符号：,/,;,#
  思考：下面的标示符哪些是正确的，哪些不正确为什么
fromNo12 from#12 my_Boolean my-Boolean Obj2 2ndObj myInt test1 Mike2jack My_tExt test test!32haha(da)ttint jack_rose jack&rose GUI G.U.I
  python中的标识符是区分大小写的

  3、命名规则
  见名知意
  起一个有意义的名字，尽量做到看一眼就知道是什么意思(提高代码可 读性) 比如: 名字 就定义为 name , 定义学生 用 student
  驼峰命名法 ：
  小驼峰式命名法（lower camel case）： 第一个单词以小写字母开始；第二个单词的首字母大写，例如：myName、aDog
  大驼峰式命名法（upper camel case）： 每一个单字的首字母都采用大写字母，例如：FirstName、LastName
  不过在程序员中还有一种命名法比较流行，就是用下划线“”来连接所有的单词，比如 send_buf
  4、关键字
  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的关键字：

输入与输出

1、普通的输出

# 打印提示
    print('hello world') System.out.println
用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和整数与小数的位数：
如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串：
有些时候，字符串里面的%是一个普通字符怎么办？这个时候就需要转义，用%%来表示一个%：
练习：编写程序
小明的成绩从去年的72分提升到了今年的85分，请计算小明成绩提升的百分点，
并用字符串格式化显示出'xx.x%'，只保留小数点后1位：

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()功能一样

运算符

1、算术运算符
下面以 a=10 ,b=20 为例进行计算

运算符	描述	实例
+	加	两个对象相加 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

2、赋值运算符

运算符	描述	实例
=	赋值运算符	把=号右边的结果给左边的变量 num=1+2*3 结果num的值为7

3、复合赋值运算符

运算符	描述	实例
+=	加法赋值运算符	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

注意：Python 中没有 a++ , a-- , ++a , --a 等操作

4、逻辑运算符

运算符	逻辑表达式	描述	实例
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

5、比较（关系）运算符

运算符	描述	示例
==	检查两个操作数的值是否相等，如果是则条件变为真。	如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.

练习：
由用输入一个学生的信息，（姓名，年龄，地址）。然后看看年龄是否是偶数，然后输出。

第三章 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做更细致的判断：

if判断条件还可以简写，比如写：

if x:
    print('True')

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

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 <module>
ValueError: invalid literal forint() with base 10: 'abc'

原来 int() 函数发现一个字符串并不是合法的数字时就会报错，程序就退出了。
如何检查并捕获程序运行期的错误呢？后面的会讲到。

if 嵌套的格式

if 条件1:
	满足条件1 做的事情1 
	满足条件1 做的事情2 
	...(省略)... 
	if 条件2: 
		满足条件2 做的事情1 
		满足条件2 做的事情2 
	...(省略)... 

说明：
外层的 if 判断，也可以是 if-else
内层的 if 判断，也可以是 if-else
根据实际开发的情况，进行选择

课后练习：
1、 要求：从键盘输入刀子的长度，如果刀子长度没有超过 10cm，则允许上火车，否则不允许上火车

2、小明身高 1.75m，体重 80.5kg。请根据 BMI 公式（体重除以身高的平方）帮小明计算他的 BMI 指数，并根据 BMI 指数：
低于 18.5：过轻
18.5-25：正常
25-28：过重
28-32：肥胖
高于 32：严重肥胖
用 if-elif 判断并打印结果：

3、情节描述：上公交车，并且可以有座位坐下
要求：输入公交卡当前的余额，只要超过 2 元，就可以上公交车；如果空座位的数量大于 0，就可以坐下

循环结构

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)

2. 计算1~100之间偶数的累积和（包含1和100）
   1、循环次数（while中循环次数由条件决定）
   2、在循环过程中做什么
   3、变量怎么变化？

3. while循环嵌套
   前面学习过if的嵌套了，想一想if嵌套是什么样子的？
   类似if的嵌套，while嵌套就是：while里面还有while

<1>while嵌套的格式

while 条件1:
        条件1满足时，做的事情1
        条件1满足时，做的事情2
        条件1满足时，做的事情3
        ...(省略)...
        while 条件2:
            条件2满足时，做的事情1
            条件2满足时，做的事情2
            条件2满足时，做的事情3
            ...(省略)...

<2>while嵌套应用一
要求：打印如下图形： m行，每行打印n次，n==m

*
* *
* * * 
* * * * 
* * * * *

<3>while嵌套应用二：九九乘法表

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# 语句会直接继续下一轮循环，后续的print()语句不会执行
	print(n)

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

6、小结
循环是让计算机做重复任务的有效的方法。
break语句可以在循环过程中直接退出循环，而continue语句可以提前结束本轮循环，并直接开始下一轮循环。这两个语句通常都必须配合if语句使用。
要特别注意，不要滥用break和continue语句。break和continue会造成代码执行逻辑分叉过多，容易出错。大多数循环并不需要用到break和continue语句，上面的两个例子，都可以通过改写循环条件或者修改循环逻辑，去掉break和continue语句。
有些时候，如果代码写得有问题，会让程序陷入“死循环”，也就是永远循环下去。这时可以用 Ctrl+C 退出程序，或者强制结束 Python 进程。

第四章 集合类型

字符串

  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 的字符
print(name[0:5]) # 取 下标为0~4 的字符 
print(name[3:5]) # 取 下标为3、4 的字符
print(name[2:]) # 取下标为2开始到最后的字符
print(name[1:-1]) # 取 下标为1开始 到 最后第2个  之间的字符
其它案例

3、字符串常见操作
如有字符串 mystr = ‘hello world and bjsxt yunshuxueyuan sxt beijing’，以下是常见的操作
<1>find == java Indexof 方法
检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1
mystr.find(str, start=0, end=len(mystr))

print(mystr.find("bjsxt",0,len(mystr)))

<2>index
跟find()方法一样，只不过如果str不在 mystr中会报一个异常.

mystr.index(str, start=0, end=len(mystr)) 
print(mystr.index("sxt"))
print(mystr.index("sxt",0,len(mystr)))
print(mystr.rindex("sxt"))

<3>count
返回 str在start和end之间 在 mystr里面出现的次数

mystr.count(str, start=0, end=len(mystr))
print(mystr.count("sxt"))
print(mystr.count("sxt"),0,28)

<4>replace
把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.

mystr.replace(str1, str2,  mystr.count(str1))

<5>split
以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串

mystr.split(str=" ", 2)    
print(mystr.split(" "))
print(mystr.split(" ",3))

<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)

总结：
    查找字符串：
    find：找不到返回-1   ，都是从左边找，右边查找r
    index：找不到报错

列表！！！

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 <module>
IndexError: list index out of range

当索引超出了范围时，Python 会报一个 IndexError 错误，所以，要确保索引不要越界，记得最后一个元素的索引是 len(classmates) - 1。
如果要取最后一个元素，除了计算索引位置外，还可以用 -1 做索引，直接获取最后一个元素：

>>> classmates[-1]
'Tracy'

以此类推，可以获取倒数第 2 个、倒数第 3 个。

'''
python中通过符号来表示各种数据类型
  使用[]表示列表

'''
list=["abcd",1234,True,3.14]
print(len(list))
print(list[2])
print(list[::-1])
for i in list:
    print(i,end=”,”) 
for i,v in enumerate(list):
    print(i,v)

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>修改元素(“改”)
修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改

#修改元素
list[0]="sxt"

<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 与字符串中的用法相同

>>> a = ['a', 'b', 'c', 'a', 'b']
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
  File "", line 1, in <module>
ValueError: 'a'isnotin list
>>> a.index('a', 1, 4)
3>>> a.count('b')
2>>> a.count('d')
0

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

>>> 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

元组

  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 <module> ValueError: tuple.index(x): x notin tuple 
>>> a.index('a', 1, 4)
 3
>>> a.count('b')
 2
>>> a.count('d') 
0

字典

  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 <module>
KeyError: 'age'

在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值：

>>> age = info.get('age')
>>> age #'age'键不存在，所以age为None>>> type(age)
<type 'NoneType'>
>>> 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
# info.clear()#清空整个字典
print('删除后,%s'%info)#抛错info不存在

demo:clear 清空整个字典
3、字典的常见函数：
<1>len()
测量字典中，键值对的个数
<2>keys == map.keys()
返回一个包含字典所有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

可变类型与不可变类型

上面我们讲了，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

第五章Python的函数

函数介绍

我们知道圆的面积计算公式为：S = πr^2
当我们知道半径 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 不但能非常灵活地定义函数，而且本身内置了很多有用的函数，可以直接调用。

函数的定义与调用

1、定义函数
定义函数的格式如下：
def 函数名(): 代码
demo:

# 定义一个函数，能够完成打印信息的功能
def printInfo():
print'------------------------------------'
print' 人生苦短，我用Python'
print'------------------------------------'

2、调用函数
定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它
调用函数很简单的，通过 函数名() 即可完成调用
demo:

# 定义完函数后，函数是不会自动执行的，需要调用它才可以 
printInfo()

函数参数（一）

思考一个问题，如下：
现在需要定义一个函数，这个函数能够完成 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> 小总结
定义时小括号中的参数，用来接收参数用的，称为 “形参”
调用时小括号中的参数，用来传递给函数用的，称为 “实参”

函数参数（二）

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

注意：带有默认值的参数一定要位于参数列表的最后面。

>>> def printinfo(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语言中的指针传参呢？

a=1
b=[1,2]
def fun(a):
    a+=a
    print("fun内a=",a)
fun(a)
print("fun外a=",a)
fun(b)
print("fun外b=",b) 

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

函数返回值（一）

<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

函数的返回值（二）

在python中我们可不可以返回多个值？

>>> def divid(a, b):
... shang = a//b 
... yushu = a%b 
... return shang, yushu 
... 
>>> sh, yu = divid(5, 2) 
>>> sh #2
>>> yu 1

本质是利用了元组

局部变量和全局变量

1、局部变量
局部变量（Local variables）指在程序中只在特定过程或函数中可以访问的变量。
总结
1、局部变量，就是在函数内部定义的变量
2、不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
3、局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储，这就是它的作用
2、全局变量
<1>什么是全局变量
如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量<2>全局变量和局部变量名字相同问题
<3>修改全局变量
既然全局变量，就是能够在所以的函数中进行使用，那么可否进行修改呢？：global
<4>可变类型的全局变量

a=200
def test0():
    #函数内没有定义变量a，则使用全局变量a
    print("test0 a=",a)
test0()
def test1():
    a=30 #函数内定义了局部变量a，则使用局部变量a
    print("test1-1.a=%d"%a)
    a=40
    print("test1-2.a=%d"%a)
test1()
print("test1 after a=",a)  # 200 局部变量修改不影响全局变量

def test2():
    global a
    a+=100 #函数内不能直接修改全局变量，有错误提示，除非使用global
    print("test2-1.a=%d"%a)
test2()
print("test2 after a=",a)

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

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

递归函数

<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)

def fundg(num):
    if(num<=2):
        return 1
    else:
        return fundg(num-1)+fundg(num-2)
print(fundg(10))
for i in range(1,11):
    print(fundg(i),end="\t")

匿名函数

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(x,y,opt):
    print(x,y,"-->",opt(x,y))
fun(1,2,lambda x,y:x+y)
fun(1,2,lambda x,y:x-y)
fun(1,2,lambda x,y:x*y)
fun(1,2,lambda x,y:x/y)

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 
[{
     'name': 'lisi', 'age': 19}, {
     'name': 'wangwu', 'age': 17}, {
     'name': 'zhangsan', 'age': 18}]

按age排序：

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

第六章 Python 的文件操作

文件的打开与关闭

想一想：如果想用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') 

说明:

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

<2>关闭文件
close( )
示例如下：

# 新建一个文件，文件名为:test.txt 
f = open('test.txt', 'w') 
# 关闭这个文件 
f.close()

文件的读写

<1>写数据(write)

使用write()可以完成向文件写入数据
demo:
f = open('test.txt', 'w') #默认放到同级目录  也可以e://test.txt
f.write('hello world, i am here!') 
lines = ["hive sql\n","hbase \n","zookeeper"]
f.writelines(lines)
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() 

文件的定位读写

<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()

文件的相关操作

有些时候，需要对文件进行重命名、删除等操作，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()——返回路径的目录和文件名。例：
    此处只是把前后两部分分开而已。就是找最后一个’/’。看例子：
11. os.getcwd()——获得当前工作的目录（get current work dir)
12. os.system()——执行shell命令。例：
13. os.chdir()——改变目录到指定目录
14. os.path.getsize()——获得文件的大小，如果为目录，返回0
15. os.path.abspath()——获得绝对路径。例：
16. os.path.join(path, name)——连接目录和文件名。例：
17. os.path.basename(path)——返回文件名
18. os.path.dirname(path)——返回文件所在目录