大数据学习第32天

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可以调用的扩展类库。需要注意的是在您使用扩展类库时可能需要考虑平台问题，某些可能不提供跨平台的实现。
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中的标识符命名规则

标识符：用于变量、函数、类、模块等的名称。标识符有如下 特定的规则：

1. 区分大小写。如：sxt 和 SXT 是不同的
2. 第一个字符必须是字母、下划线。其后的字符是：字母、数字、下划线
3. 不能使用关键字。比如：if、or、while 等。
4. 以双下划线开头和结尾的名称通常有特殊含义，尽量避免这种写法。比如：__init__是类的构造函数。

查询标识符：

   import keyword
    print(keyword.kwlist)
    '''
    ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue',
    'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global',
    'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise',
    'return', 'try', 'while', 'with', 'yield']

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

详细说明python中的数据类型

Python提供的基本数据类型主要有：布尔类型、整型、浮点型、字符串、列表、元组、集合、字典等等。

1、空（None）

表示该值是一个空对象，空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

2、布尔类型（Boolean）

在Python中，None、任何数值类型中的0、空字符串“”、空元组()、空列表[]、空字典{}都被当作False，还有自定义类型，如果实现了nonzero()或len()方法且方法返回0或False，则其实例也被当作False，其他对象均为True布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，要么是True，要么是False，在Python中，可以直接用True、False表示布尔值（请注意大小写），也可以通过布尔运算计算出来：

1 >>> True
2 True
3 >>> False
4 False
5 >>> 3 > 2
6 True
7 >>> 3 > 5
8 False

布尔值还可以用and、or和not运算。
1)and运算是与运算，只有所有都为True，and运算结果才是True：

1 >>> True and True
2 True
3 >>> True and False
4 False
5 >>> False and False
6 False

2)or运算是或运算，只要其中有一个为True，or运算结果就是True：

1 >>> True or True
2 True
3 >>> True or False
4 True
5 >>> False or False
6 False

3).not运算是非运算，它是一个单目运算符，把True变成False，False变成True：

1 >>> not True
2 False
3 >>> not False
4 True

4).布尔值经常用在条件判断中，比如：

1 if age >= 18:
2     print('adult')
3 else:
4     print('teenager')

3、整型(Int)

在Python内部对整数的处理分为普通整数和长整数，普通整数长度为机器位长，通常都是32位，超过这个范围的整数就自动当长整数处理，而长整数的范围几乎完全没限制Python可以处理任意大小的整数，当然包括负整数，在程序中的表示方法和数学上的写法一模一样，例如：1，100，-8080，0，等等。

4、浮点型(Float)

Python的浮点数就是数学中的小数，类似C语言中的double。
在运算中，整数与浮点数运算的结果是浮点数，浮点数也就是小数，之所以称为浮点数，是因为按照科学记数法表示时，一个浮点数的小数点位置是可变的，比如，1.23x109和12.3x108是相等的。浮点数可以用数学写法，如1.23，3.14，-9.01，等等。但是对于很大或很小的浮点数，就必须用科学计数法表示，把10用e替代，1.23x109就是1.23e9，或者12.3e8（也可以写成12.3e+8），0.000012可以写成1.2e-5，等等。
整数和浮点数在计算机内部存储的方式是不同的，整数运算永远是精确的（除法难道也是精确的），而浮点数运算则可能会有四舍五入的误差。

5、字符串(String)

Python字符串即可以用单引号（'单引号 '）也可以用双引号括起来（“双引号”），甚至还可以用三引号（""“三引号”""）括起来，字符串是以”或”“括起来的任意文本，比如’abc’，”xyz”等等。请注意，”或”“本身只是一种表示方式，不是字符串的一部分，因此，字符串’abc’只有a，b，c这3个字符。如果’（单引号）本身也是一个字符，那就可以用”“（双引号）括起来，比如”I’m OK”包含的字符是I，’，m，空格，O，K这6个字符。
如果字符串内部既包含’又包含”怎么办？可以用转义字符\来标识，比如：

1 'I\'m \"OK\"!'

表示的字符串内容是：

1 I'm "OK"!

转义字符\可以转义很多字符，比如\n表示换行，\t表示制表符，字符\本身也要转义，所以\表示的字符就是\，可以在Python的交互式命令行用print打印字符串看看：

1 >>> print('I\'m ok.')
2 I'm ok.
3 >>> print('I\'m learning\nPython.')
4 I'm learning
5 Python.
6 >>> print('\\\n\\')
7 \
8 \

如果字符串里面有很多字符都需要转义，就需要加很多\，为了简化，Python还允许用r”表示”内部的字符串默认不转义，可以自己试试：
复制代码 代码如下:

1 >>> print('\\\t\\')
2 \       \
3 >>> print(r'\\\t\\')
4 \\\t\\

如果字符串内部有很多换行，用\n写在一行里不好阅读，为了简化，Python允许用”’…”’的格式表示多行内容，可以自己试试：

1 >>> print('''line1
2 ... line2
3 ... line3''')
4 line1
5 line2
6 line3

6、列表(List)

用符号[]表示列表，中间的元素可以是任何类型，用逗号分隔。list类似C语言中的数组，属于顺序存储结构的内建函数：

 1 append(x)     # 追加到链尾
 2 extend(L)     # 追加一个列表，等价于+=
 3 insert(i,x)     # 在位置i插入x，其余元素向后推，如果i大于列表长度，就在最后添加，如果i小于0，就在最开始添加
 4 remove(x)     # 删除第一个值为x的元素，如果不存在会抛出异常
 5 reverse()     # 反转序列
 6 pop([i])     # 返回并删除位置为i的元素，i默认为最后一个元素
 7 index(x)     # 返回x在列表中第一次出现的位置，不存在则抛出异常
 8 count(x)     # 返回x出现的次数
 9 sort()     # 排序
10 len(List)     # 返回List的长度
11 del list[i]     # 删除列表list中指定的第i+1个变量

切片：切片指的是抽取序列的一部分，其形式为：
$$list[start:end:step]$$
其抽取的规则是：一般默认的步长为1，但也可自定义。

7、元组(Tuple)

元组是和列表相似的数据结构，但它一旦初始化就不能更改，速度比list快，同时tuple不提供动态内存管理的功能，需理解一下规则：
tuple可以用下标返回一个元素或子tuple
表示只含有一个元素的tuple的方法是：(d,)后面有个逗号，用来和单独的变量相区分

8、集合(Set)

集合是无序的，不重复的元素集，类似数学中的集合，基本功能包括关系测试和消除重复元素，集合对象还支持union(联合)，intersection(交)，difference(差)和sysmmetric difference(对称差集)，可进行逻辑运算和算术运算。

下列是一个小实验:

 1 >>> x = set('span')
 2 >>> y = set(['h','a','n'])
 3 >>> x,  y
 4 ({'s', 'a', 'p', 'n'}, {'a', 'h', 'n'})
 5 >>> x & y     # 交集
 6 {'a', 'n'}
 7 >>> x | y     # 并集
 8 {'s', 'h', 'n', 'a', 'p'}
 9 >>> x - y     # 差集
10 {'s', 'p'}
11 >>> x^y     # 对称差集
12 {'h', 's', 'p'

去除海量列表里重复元素，用hash来解决也行，只不过感觉在性能上不是很高，用set解决还是很不错的:

1 >>> a = [11,22,33,44,11,22]
2 >>> b = set(a)
3 >>> b
4 {33, 11, 44, 22}
5 >>> c = [i for i in b]
6 >>> c
7 [33, 11, 44, 22]

9、字典(Dict)

字典是一种无序存储结构，包括关键字（key）和关键字对应的值（value）。字典的格式为：dictionary = {key:value}。关键字为不可变类型，如字符串、整数、只包含不可变对象的元组，列表等不可作为关键字。如果列表中存在关键字对，可以用dict()直接构造字典。

列出python中的运算规则

Python 中运算符的运算规则是，优先级高的运算符先执行，优先级低的运算符后执行，同一优先级的运算符按照从左到右的顺序进行。Python 语言中大部分运算符都是从左向右执行的，只有单目运算符（例如 not 逻辑非运算符）、赋值运算符和三目运算符例外，它们是从右向左执行的。

​ 运算符的优先级

运算符说明	Python运算符	优先级
索引运算符	x[index] 或 x[index:index2[:index3]]	18、19
属性访问	x.attrbute	17
乘方	**	16
按位取反	~	15
符号运算符	+（正号）或 -（负号）	14
乘、除	*、/、//、%	13
加、减	+、-	12
位移	>>、<<	11
按位与	&	10
按位异或	^	9
按位或	|	8
比较运算符	==、!=、>、>=、<、<=	7
is 运算符	is、is not	6
in 运算符	in、not in	5
逻辑非	not	4
逻辑与	and	3
逻辑或	or	2

列出python中的循环和分支

if elif else条件判断

计算机之所以能做很多自动化的任务，因为它可以自己做条件判断。

elif是else if的缩写，完全可以有多个elif，所以if语句的完整形式就是：

if <条件判断1>:

​ <执行1>

elif <条件判断2>:

​ <执行2>

elif <条件判断3>:

​ <执行3>

else:

​ <执行4>

if嵌套的格式

if 条件1:

满足条件1 做的事情1

满足条件1 做的事情2

…(省略)…

if 条件2:

满足条件2 做的事情1

满足条件2 做的事情2

…(省略)…

说明：

外层的if判断，也可以是if-else

内层的if判断，也可以是if-else

根据实际开发的情况，进行选择

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()函数发现一个字符串并不是合法的数字时就会报错，程序就退出了。
如何检查并捕获程序运行期的错误呢？后面的错误和调试会讲到。

循环结构

while循环 #在条件为真的时候执行某一段制定的代码，只要条件为真，while循环就会一直去重复执行那一段代码。这段代码就是一个循环体。

while循环的格式

while 条件:

​ 条件满足时，做的事情1

​ 条件满足时，做的事情2

​ 条件满足时，做的事情3

​ …(省略)…

while循环嵌套

<1>while嵌套的格式

while 条件1:

​ 条件1满足时，做的事情1

​ 条件1满足时，做的事情2

​ 条件1满足时，做的事情3

​ …(省略)…

​ while 条件2:

​ 条件2满足时，做的事情1

​ 条件2满足时，做的事情2

​ 条件2满足时，做的事情3

​ …(省略)…

for循环

像while循环一样，for可以完成循环的功能。

for循环的格式

for 临时变量 in 列表或者字符串等:

​ 循环满足条件时执行的代码

​ else:

​ 循环不满足条件时执行的代码

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的作用是提前结束本轮循环，并直接开始下一轮循环。

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

写一个计算器程序：用循环封装，从控制台输入数据和运算符，能够从控制台退出。

a=0
b=0
operation=''
while True:
    a = input("请输入一个数")
    a=int(a)
    print(a)
    operation=input("请输入：+，—，*，/")
    print(operation)
    b =input("请输入第二个数")
    b=int(b)
    print(b)
    print(operation)
    if operation=="+":
        print(a+b)
    if operation=='-':
        print(a-b)
    if operation=='*':
        print(a*b)
    if operation=='/':
        if a==0 :
            print('输入错误')
        else:
            print(a/b)
    flag = input("是否继续按N结束")
    print(flag)
    if flag=='N':
        print('END')
        break

函数的定义与调用
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> 小总结
定义时小括号中的参数，用来接收参数用的，称为 “形参”
调用时小括号中的参数，用来传递给函数用的，称为 “实参”
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 "<stdin>", line 1 SyntaxError: non-default argument follows default argument

不定长参数
有时可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，声明时不会命名。
基本语法如下：

Def functionname([formal_args,] *args, **kwargs):"函数_文档字符串" 
function_suite 
return [expression] 

加了星号（*）的变量args会存放所有未命名的变量参数，args为元组；而加**的变量kwargs会存放命名参数，即g形如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中函数参数是引用传递（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量自身；而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量。

函数返回值（一）
<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 5
yu 1
本质是利用了元组
7、局部变量和全局变量
1、局部变量
局部变量（Local variables）指在程序中只在特定过程或函数中可以访问的变量。