Python教程学习简记1--Python数据类型和变量 字符串和编码 list和tuple 条件判断 循环 dict和set

本文主要是学习Python基础：
Python数据类型和变量 字符串和编码 list和tuple 条件判断 循环 dict和set

本文根据廖雪峰的官方网站-Python教程，认真学习，一步一步实操并且详细记录。

在此，特别感谢廖雪峰老师。

Python2.x与Python3.x

之后补上。。。。。。

升级Ubuntu15.10系统的Python

Ubuntu15.10系统默认安装的Python为2.7.10

安装Python3.5

sudo apt-get install python3.5

注：由于Ubuntu底层采用的是Python2.*，Python3与Python2是互不兼容的，但是不能卸载Python2,只需要将默认的Python指向Python3

之前安装的Python3.5默认是安装在/usr/local/lib/python3.5目录下，需要删除默认python link文件，重新建立连接关系

rm /usr/bin/python

ln -s /usr/bin/python3.5 /usr/bin/python

第一个Python程序

直接在python交互式命令行中输入想要执行的代码，回车就可以立即得到代码的执行结果

python打印指定的文字，使用print()函数；将打印的文字用单引号或者双引号括起来！

800+300
print("hello python")
print('hello world')

Python基础

Python是一种编程语言，所以它也就有自己的一套语法规则。

编译器或者解释器负责把符合语法规则的程序代码转换成CPU能够执行的机器码，然后执行。

Python的语法比较简单，采用缩进的方式，写出来的代码如下所示：

（官网截图）
以#开头的语句为注释，注释是给开发者看的，可以使任意内容，解释器会忽略掉注释。
其他每一行都是一个语句，当语句以冒号“：”结尾时，缩进的语句视为代码块。

缩进能够强迫我们写出格式化的代码，但是没有规定缩进是几个空格还是Tab。按照约定俗成的管理，应该始终坚持使用4个空格的缩进。

特别注意：Python程序是大小写敏感的。

输入和输出

之前有提到print()，那就先从输出开始

用print()将所要输出的字符串作为参数添加在括号里面，并用单引号或者双引号括起来

 print('hello python !')

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

print('I want to speak good english !')

print("I","want","to ","speak","good","english","!")

注：print()函数会依次打印每个字符串，遇到逗号“，”会输出一个空格

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

>>> print(888)
888
>>> print(888+111)
999

人性化打印计算结果：

>>> print("555+111=",555+111)
555+111= 666

下来我们说一说输入：

和其他语言一样，python给我们提供了输入函数input()，可以让用户输入字符串，并且存放到一个变量里面

>>> name=input()
hjr

当输入name=input()并且按下回车之后，python交互式命令终端就等待你的输入了。这时你可以输入任意字符串，然后按回车完成输入。

输入完成后，不会有任何提示，python交互式命令终端又回到>>>状态。

>>> name
'hjr'

刚才将输入的内容存放到变量name里面了，我们可以直接在命令行里面输入变量名name，查看变量的内容。

打印name变量的内容，除了直接在命令行里面输入变量名name回车查看变量内容之外，还可以使用我们之前学到的print()函数：

>>> print(name)
hjr

小例子：

>>> name=input("please enter your name : ") 
please enter your name : hjr

>>> print('hello,',name)
hello, hjr

>>> print(1024*768)
786432

数据类型和变量

整数：

Python可以处理任意大小的整数（包括负整数），在程序中的表示方法和数学上的写法一模一样。例如：

1
200
-8341
0

浮点数：

浮点数，即：小数。之所以称为浮点数，是因为按照科学计数法表示时，一个浮点数的小数点位置是可变的，比如：1.23x109(上标)和12.3x108（上标）是完全相等的。

浮点数可以用数学写法，如：1.23,3.14,-9.01等。

对于很大或者很小的浮点数，就必须使用科学计数法表示，把10用e代替，1.23x109(上标)就是1.23e9或者12.3e8,0.000012可以写成1.2e-5等。

注：整数和浮点数在计算机内部存储的方式是不同的。

整数运算永远是精确的（包括除法），而浮点数运算则可能会有四舍五入的误差。

字符串：

字符串是以单引号（‘ ’）或者双引号（“ ”）括起来的任意文本，例如 ‘qaz’，“wsx” 等。

（‘ ’）（“ ”）本身只是一种表示方式，不是字符串的一部分。因此，字符串‘abc’只有a，b，c这三个字符。如果（‘）本身也是一个字符，那就可以用（“ ”）括起来，例如：”I’m OK”包含的字符是（I）（’）（m）（空格）（O）（K）这六个字符。

如果字符里面既包含（’）又包含（“）的话，则可以使用转义字符（\）来标识，如：

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

表示的字符串内容是：

>>> print('I\'m \"OK\"!')
I'm "OK"!

转义字符（\）可以转义很多字符，比如：

\n 表示换行
\t 表示制表符
等。。。
字符（\）本身也要转义，所以（\）表示的字符就是（\）。
在Python的交互式命令终端用print()打印字符串查看：

>>> print('I\'m learning python. \nhjr ')
I'm learning python. 
hjr 
>>> print('\\\n\\')
\
\

如果字符串里面有很多字符需要转义，就需要加很多（\），为了简化，Python还允许用（r’ ‘）或（r“ ”）表示（’ ‘）或（“ ”）内部的字符串默认不转义。

>>> print('\\\t\\')
\   \
>>> print(r'\\\t\\')
\\\t\\
>>> print(r"\\\t\\")
\\\t\\

如果字符串内部有很多换行，用（\n）写在一行里面不好阅读，为了简化，Python允许用（“‘…’”）的格式表示多行内容。

注：三个单引号

>>> print('''yiyou
... hjr
... yizheyouye
... python
... hadoop
... spark''')
yiyou
hjr
yizheyouye
python
hadoop
spark

>>> print("""yiyou
... hjr
... yizheyouye
... python
... hadoop
... spark
... good""")
yiyou
hjr
yizheyouye
python
hadoop
spark
good

布尔值：

布尔值和布尔代数的表示完全一致，一个布尔值只有True和False两种值，也就是说要么True，要么False。在Python中，可以直接使用True或者False表示布尔值（注意大小写），也可以通过布尔运算计算出来：

>>> True
True
>>> False
False
>>> 8>3
True
>>> 2>10
False

布尔运算：and / or / not

and运算：与运算
只有所有都为True，and运算结果才是True：

>>> True and True
True
>>> True and False
False
>>> False and False
False
>>> 4>1 and 8<12
True

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

>>> True or True
True
>>> True or false
True
>>> False or False
False
>>> 8<3 or 9>1
True

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

>>> not True
False
>>> not False
True
>>> not 1>8
True

布尔值经常用在条件判断中，如：

if age >= 18:
    print('adult')
else:
    print('teenager')

空值：

空值是Python里面一个特殊的值，用None表示。

注：None不能理解为0，因为0是有意义的，而None是一个特殊的空值。

变量：

计算机程序中，变量不仅可以是数字，也可以是任意数据类型

变量在程序中就是一个变量名表示，变量名必须是大小写英文/数字/和_下划线的组合，而且不能用数字开头。

a=7

变量a是一个整数

hjr_007="yiyou"

变量hjr_007是一个字符串

Answer=False

变量Answer是一个布尔值False

在Python中，等号（=）是赋值语句，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量，如：

>>> a=8341
>>> print(a)
8341
>>> a='ABC'
>>> print(a)
ABC

这种变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。
静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。比如：Java就是静态语言，赋值语句如下就会报错：

int a=8341； //a是整数类型变量
a='ABC'； //报错：不能把字符串赋值给整形变量

和静态语言相比，动态语言更加灵活，就是这个原因。

注意：不能把赋值语句的等号等同于数学的等号。

X=8
X=X+3

析：X=X+3，在计算机程序中，赋值语句先计算右侧的表达式X+3，得到结果11，在赋值给X。由于X之前的值是8，重新赋值后，X的值变成11。

变量在计算机内存中的表示：

a='ABC'

当我们写a=‘ABC’时，Python解释器做了两件事请：
1）在内存中创建了一个‘ABC’的字符串；
2）在内存中创建了一个名为a的变量，并把它指向‘ABC’。

也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据。

>>> a='ABC'
>>> b=a
>>> a='XYZ'
>>> print(b)
ABC

1）执行a=‘ABC’，解释器创建了字符串‘ABC’和变量a，并把a指向‘ABC’。

2）执行b=a，解释器创建了变量b，并把b指向a指向的字符串’ABC‘。

3）执行a=’XYZ‘，解释器创建了字符串，并把a的指向改为’XYZ‘，但是b并没有更改。

所以，最后打印变量b的结果自然就是’ABC‘了。

常量：

常量就是不能变得变量，特殊的变量。比如常用的数学常数π就是一个常量。

在Python中，通常用全部大写的变量名表示常量：

PI=3.14159265359

但事实上，PI任然是一个变量，Python根本没有任何机制保证PI不会被改变，所以，用全部大写的变量名表示常量只是一个习惯上的用法。

附：整数的除法为什么是精确的

在Python中，有两种除法，一种除法是（/）：

>>> 10/3
3.3333333333333335

（/）除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：

>>> 18/3
6.0

还有一种除法是（//），称为地板除，两个整数的除法任然是整数：

>>> 10//3
3

整数的地板除（//）永远是整数，即使是除不尽的情况。
要做精确的除法，使用（/）就可以。

无论整数做（//）除法还是取余数，结果永远是整数，所以说，整数运算结果永远是精确的。

小例子：

>>> n=123
>>> print(n)
123
>>> f=456.789
>>> print(f)
456.789
>>> s1='Hello World'
>>> print(s1)
Hello World
>>> s2='Hello,\'Adam\''
>>> print(s2)
Hello,'Adam'
>>> s3=r'Hello,"Bart"'
>>> print(s3)
Hello,"Bart"
>>> s4=r'''Hello,
... Lisa!
... Roky!'''
>>> print(s4)
Hello,
Lisa!
Roky!

字符串和编码

字符串是一种数据类型，但是，字符串比较特殊的是还有一个编码问题。

因为计算机只能处理数字，如果要处理文本，就必须先把文本转换为数字才能处理。

最早的计算机在设计时采用8个比特（bit）作为一个字节（byte），所以，一个字节能表示的最大的整数就是255（二进制11111111=十进制255），如果要表示更大的整数，就必须用更多的字节。比如两个字节可以表示的最大整数是65535，4个字节可以表示的最大整数是4294967295。

由于计算机是美国人发明的，因此，最早只有127个字母被编码到计算机里，也就是大小写英文字母/数字和一些符号，这个编码表被称为ACSII编码，比如大写字母A的编码是65，小写字母z的编码是122。

我们要处理中文显然一个字节是不够的，至少得两个字节，而且还不能和ASCII编码冲突，所以，中国制定了GB2312编码，用来把中文编进去。

全世界有上百中语言，日本把日文编到Shift_JIS里，韩国把韩文编到Euc-kr里，各国有各国的标准，所以就会不可避免的出现冲突，结果就是，在多语言混合的文本中，显示出来就会有乱码。

因此，Unicode应运而生。

Unicode把所有的语言都统一到一套编码里面，这样就不会有乱码问题了。

Unicode标准也在不断发展，但是常用的是用两个字节表示一个字符（如果用到非常偏僻的字符，就需要4个字节）。现代操作系统和大多数编程语言都直接支持Unicode。

ASCII编码与Unicode编码的区别：
ASCII编码是一个字节，Unicode编码通常是两个字节。

字母（A）用ASCII编码是十进制的65，二进制的01000001;
字符（0）用ASCII编码是十进制的48，二进制的00110000;
（注意：字符‘0’和整数0是不同的）
汉字（中）已经超出了ASCII编码的范围，用Unicode编码是十进制的20013，二进制的01001110 00101101。

如果把ASCII编码的A用Unicode编码，只需要在前面补0就可以了，故，A的Unicode编码是00000000 01000001。

问题：

如果统一成Unicode编码，乱码问题从此消失了。但是，如果我们写的文本全部是英文的话，用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输方面就十分不划算。

所以，本着节约的精神，又出现了把Unicode编码转换为“可变长编码”的UTF-8编码。

UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。如果你要传输的文本包含大量英文字符，用UTF-8编码就能节省空间：

从上面的表格可以发现，UTF-8编码还有一个额外的好处，就是ASCII编码实际上可以被看成UTF-8编码的一部分，所以，大量支持ASCII编码的历史遗留软件可以在UTF-8编码下继续工作。

总结一下，计算机系统通用的字符编码工作方式：

在计算机内存中，统一使用Unicode编码，
当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。

用记事本编辑的时候，从文件读取的UTF-8字符被转换为Unicode字符到内存里，编辑完成后，保存的时候再把Unicode字符转换为UTF-8字符保存到文件。

同理，浏览网页的时候，服务器会把动态生成的Unicode内容转换为UTF-8在传输到浏览器。
所以我们会看到很多网页的源码上会有类似的信息，表示网页使用的是UTF-8编码。

Python的字符串

在最新的Python3中，字符串是以Unicode编码的，所以，Python的字符串支持多国语言，比如：

>>> print('包含中文的string')
包含中文的string

对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：

>>> ord('A')
65
>>> ord('中')
20013
>>> chr(66)
'B'
>>> chr(25991)
'文'

如果知道字符的整数编码，还可以用十六进制写str：

>>> '\u4e2d\u6587'
'中文'

两种写法完全等价。

由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。

Python对bytes类型的数据用带b前缀的单引号或双引号表示：

x=b'ABC'

注意区分‘ABC’和b’ABC’,前者是str，后者虽然内容显示的和前者一样，单bytes的每个字附都占用一个字节。

以Unicode表示的str通过encode()方法可以编码为指定的bytes，如下：

>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
>>> '中文'.encode('ascii')
Traceback (most recent call last):
  File "", line 1, in 
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)

纯英文的str可以用ASCII编码为bytes，内容是一样的，
含有中文的str可以用UTF-8编码为bytes。
含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错奥！

在bytes中，无法显示为ASCII字符的字节，用（\x##）显示。

反过来，如果我们从网络或磁盘上读取了字节流，那么读取到的数据就是bytes。要把bytes变为str，就需要用decode()方法：

>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'

要计算str包含多少个字符，可以用len()函数：

>>> len('ABC')
3
>>> len('中文')
2

len()函数计算的是str的字符数，如果换成bytes，len()函数就计算字节数：

>>> len(b'ABC')
3
>>> len(b'\xe4\xb8\xad\xe6\x96\x87')
6
>>> len('中文'.encode('utf-8'))
6

可见，一个中文字符经过UTF-8编码后通常会占用3个字节，而一个英文字符只占用1个字节。

在操作字符串时，我们经常遇到str和bytes的相互转换。为了避免乱码问题，应当始终坚持使用UTF-8编码对str和bytes进行转换。

由于Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码的时候，就需要务必指定保存为UTF-8编码。当python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

#！/usr/bin/env python3
# _*_ coding: utf-8 _*_

第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释;
第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。

声明了UTF-8编码并不意味着你的(.py)文件就是UTF-8编码的，必须并且要确保文本编辑器正在使用UTF-8 without BOM编码。

格式化

如何输出格式化的字符串？

我们经常会输出类似“亲爱的×××你好！你××月的话费是××，余额是××”之类的字符串，而×××的内容都是根据变量变化的，所以，需要一种简便的格式化字符串的方式。

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

>>> 'Hello,%s' % 'Python'
'Hello,Python'

>>> 'Hi,%s,you have $%d.'%('hjr',999999)
'Hi,hjr,you have $999999.'

(%)运算符就是用来格式化字符串的。
在字符串内部，%s表示用字符串替换，%d表示用整数替换，有几个（%？）占位符，后面就跟几个变量或者值，顺序要对应好。
如果只有一个（%？），括号可以省略。

常见的占位符有：

%d 整数
%f 浮点数
%s 字符串
%x 十六进制整数

其中，格式化整数和浮点数还可以指定是否补0和整数与小数的位数：

>>> '%2d-%02d' % (3,1)
' 3-01'

>>> '%.2f' % 3.14159265359
'3.14'

如果你还不太确定应该用什么，（%s）永远起作用，它会把任何数据类型转化为字符串：

>>> 'Age: %s. Gender: %s' % (25,True)
'Age: 25. Gender: True'

有些时候，字符串里面的%是一个普通字符怎么办？（百分比）这个时候就需要转义，用%%来表示%：

>>> 'growth rate %d %%' % 8
'growth rate 8 %'

小练习：
小明的成绩从去年的72分提升到了今年的85分，请计算小明成绩提升的百分点，并用字符串格式化显示出’xx.x%’，只保留小数点后1位：

>>> s1=72
>>> s2=85
>>> r=(s2-s1)/s1
>>> 'growth rate : %.1f %%' % r
'growth rate : 0.2 %'

使用 list 和 tuple

list

Python内置的一种数据类型是列表：list。

list是一种有序的集合，可以随时添加和删除其中的元素。

>>> classmates = ['yiyou','hjr','lr','hjj','lqq']
>>> classmates
['yiyou', 'hjr', 'lr', 'hjj', 'lqq']

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

>>> len(classmates)
5

用索引来访问list中每一个位置的元素，注意：索引是从0开始的哟：

>>> classmates[0]
'yiyou'
>>> classmates[1]
'hjr'
>>> classmates[2]
'lr'
>>> classmates[3]
'hjj'
>>> classmates[4]
'lqq'

>>> classmates[5]
Traceback (most recent call last):
  File "", line 1, in 
IndexError: list index out of range

当索引超出了范围时，Python会报一个IndexError错误，所以，要确保索引不要越界，记得最后一个元素的索引是len(classmates)-1。

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

>>> classmates[-1]
'lqq'

以此类推，可以获取倒数第二个，倒数第三个等：

>>> classmates[-2]
'hjj'
>>> classmates[-3]
'lr'
>>> classmates[-4]
'hjr'
>>> classmates[-5]
'yiyou'

list是一个可变的有序列表，所以，可以往list中追加元素到末尾：

>>> classmates.append('fyh')
>>> classmates
['yiyou', 'hjr', 'lr', 'hjj', 'lqq', 'fyh']

也可以把元素插入到指定的位置，例如索引号为0的位置：

>>> classmates.insert(0,'yizheyouye')
>>> classmates
['yizheyouye', 'yiyou', 'hjr', 'lr', 'hjj', 'lqq']

要删除list末尾的元素，用pop()方法：

>>> classmates.pop()
'fyh'
>>> classmates
['yiyou', 'hjr', 'lr', 'hjj', 'lqq']

要删除指定位置的元素，用pop(i)方法，其中i是索引位置：

>>> classmates.pop(0)
'yizheyouye'
>>> classmates
['yiyou', 'hjr', 'lr', 'hjj', 'lqq']

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

>>> classmates[4]='fyh'
>>> classmates
['yiyou', 'hjr', 'lr', 'hjj', 'fyh']

list里面的元素的数据类型也可以不同，比如：

>>> L=['Apple',8341,True]
>>> L
['Apple', 8341, True]

list元素也可以是另一个list，例如：

>>> s=['python','scala',['spark','hadoop','flink'],'ruby','go']
>>> s
['python', 'scala', ['spark', 'hadoop', 'flink'], 'ruby', 'go']

>>> len(s)
5

注意：s只有5个元素，其中s[2]又是一个list，如果拆开写就容易理解了：

>>> p=['spark','hadoop','flink']
>>> s=['python','scala',p,'ruby','go']

>>> s
['python', 'scala', ['spark', 'hadoop', 'flink'], 'ruby', 'go']

想要拿到’spark‘，可以写p[0]或者s[2][0],因此，s可以看成一个二位数组，类似的还有三维/四维。。。数组，不过，很少用到。

如果一个list中一个元素都没有，就是一个空的list，它的长度为0：

>>> L=[]
>>> len(L)
0

tuple

另一种有序列表叫元祖：tuple

tuple和list非常类似，但是，tuple一旦初始化，就不能修改。

例如：同样是列出同学的名字：

>>> classmates=('hjr','lr','hjj','lqq')

现在，classmates这个tuple不能变了，它也没有append(),insert()这样的方法。其他获取元素的方法和list是一样的，我们可以正常使用classmates[0],classmates[-1],当然不能赋值给另外的元素。

不可变得tuple有什么意义呢？因为tuple不可变，代码更安全。如果可变，能用tuple代替list就尽量用tuple。

tuple陷阱：
当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：

>>> t=(1,2,3)

>>> t
(1, 2, 3)

如果要定义一个空tuple，就可以写成（）：

>>> t=()

>>> t
()

但是，要定义一个只有一个元素的tuple，如果我们这么定义：

>>> t=(1)
>>> t
1

这么定义的就不是tuple，是1这个数字！

这是因为括号（）既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，在这种情况下，按小括号进行计算，计算结果自然是1咯。

所以，只有一个元素的tuple 定义 时必须加一个逗号（，），来消除歧义：

>>> t=(1,)
>>> t
(1,)

Python在 显示 只有一个元素的tuple时，也会加一个逗号（，），以免我们误解成数学计算意义上的括号。

最后，我们看一个“可变的”tuple：

>>> t=('a','b',['A','B'])
>>> t
('a', 'b', ['A', 'B'])

>>> t[2][0]='X'
>>> t[2][1]='Y'
>>> t
('a', 'b', ['X', 'Y'])

这个tuple定义的时候有三个元素，分别是’a‘，’b‘和一个list。

表面上看，tuple的元素确实变了，但实际变的不是tuple的元素，而是list的元素。

tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每一个元素，指向定义了以后就永远不变。

即：
指向’a‘，就不能改变成’b‘，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可以改变的！

了解了“指向不变”后，要创建一个内容也不变的tuple怎么做呢？
那就必须保证tuple的每一个元素本身也不能变。

小练习：

>>> L=[['Apple','Google','Microsoft'],['Java','Python','Ruby','PHP'],['Adam','Bart','Lisa']]
>>> L
[['Apple', 'Google', 'Microsoft'], ['Java', 'Python', 'Ruby', 'PHP'], ['Adam', 'Bart', 'Lisa']]

>>> print(L[0][0])
Apple
>>> print(L[1][1])
Python
>>> print(L[2][2])
Lisa

小结：
list和tuple是Python内置的有序集合，一个可变，一个不可变。我们根据需要选择使用。

条件判断

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

例如，输入用户年龄，根据年龄打印不同的内容，在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 = 8
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')

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

if <条件判断1>：
    <执行1>
elif<条件判断2>
    <执行2>
elif<条件判断3>
    <执行3>
else:
    <执行4>

if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就会忽略掉剩下的elif和else语句。

所以，请测试并解释为什么下面的程序打印的是teenager：

age = 20
if age >= 6:
    print('teenager')
elif age >= 18:
    print('adult')
else:
    print('kid')

满足第一个if后，执行完就跳出了判断语句。

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

if x:
    print('True')

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

Input

我们有时候会用input()读取用户的输入，这样可以自己输入，程序运行的很有意思：

birth = input('birth:')

if birth < 2000:
    print('00 qian')
else:
    print('00 hou')

报错了：

这是因为input()返回的数据类型是str，而str不能直接和整数比较，必须先把str转换成整数。
Python提供了int()函数来完成这件事情：

s = input('birth:')
birth = int(s)
if birth < 2000:
    print('00 qian')
else:
    print('00 hou')

再次运行，就可以得到正确的结果。但是，如果输入abc字符串呢？
又会得到一个错误信息：

int()函数发现一个字符串并不是合法的数字时就会报错，程序就退出了。

小练习：

小明身高1.75，体重80.5kg。请根据BMI公式（体重除以身高的平方）帮小明计算他的BMI指数，并根据BMI指数：

    低于18.5：过轻
    18.5-25：正常
    25-28：过重
    28-32：肥胖
    高于32：严重肥胖

# BMI值計算公式:   BMI = 體重(公斤) / 身高*身高(公尺*公尺)
# 例如：一個52公斤的人，身高是155公分，則BMI為 :
# 52(公斤)/1.55*1.55 ( 公尺*公尺 )= 21.6
# 體重正常範圍為  BMI=18.5～24
height = 1.75
weight = 80.5
bmi = weight/(height*height)

if bmi < 18.5:
    print('过轻')
elif bmi >= 18.5 and bmi < 25:
    print('正常')
elif bmi >= 25 and bmi < 28:
    print('过重')
elif bmi >= 28 and bmi < 32:
    print('肥胖')
elif bmi > 32:
    print('严重肥胖')
else:
    print('Exception !')

修改一下：

# BMI值計算公式:   BMI = 體重(公斤) / 身高*身高(公尺*公尺)
# 例如：一個52公斤的人，身高是155公分，則BMI為 :
# 52(公斤)/1.55*1.55 ( 公尺*公尺 )= 21.6
# 體重正常範圍為  BMI=18.5～24
height = 1.75
weight = 80.5
bmi = weight/(height*height)

if bmi < 18.5:
    print('过轻')
# elif bmi >= 18.5 and bmi < 25:
elif 18.5 <= bmi < 25:
    print('正常')
# elif bmi >= 25 and bmi < 28:
elif 25 <= bmi < 28:
    print('过重')
# elif bmi >= 28 and bmi < 32:
elif 28 <= bmi < 32:
    print('肥胖')
elif bmi > 32:
    print('严重肥胖')
else:
    print('Exception !')

for 循环

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

>>> 1+2+3
6

要计算1+2+3+4+…+10，勉强也能写出来。
但是，要计算1+2+3+…+10000，直接写表达式是不明智的。
为了让计算机能计算成千上万次的重复运算，我们就需要循环语句。

Python的循环有两种，一种是for…in循环，依次把list或者tuple中的每一个元素迭代出来，如下：

names = ['hjr','lr','hjj','lqq']
for name in names:
    print(name)

执行这段代码，会依次打印names中的每一个元素：

所以，for x in …循环就是把每个元素带入变量x，然后执行行缩进块的语句。

在比如我们想计算1-10的整数之和，我们可以用一个sum变量做累加：

sum = 0
for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    sum = sum + x
#   sum += x       //上面那句可以简写成这样
print(sum)

如果要计算1-100的整数之和，从1写到100有点困难，幸好Python提供一个range()函数，可以生成一个整数序列，再通过list()函数就可以转换为list。
比如，range(5)生成的序列是从0开始小于5的整数：

>>> list(range(5))
[0, 1, 2, 3, 4]

range(101)就可以生成0-100的整数序列，计算如下

sum = 0
for x in range(101):
    sum = sum +x
print(sum)

while 循环

while循环，只要条件满足，就不断循环，条件不满足时退出循环。
比如我们计算100以内所有奇数之和，可以用while循环实现：

sum = 0
n=99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

在循环内部变量n不断自减，知道变为-1时，不再满足while条件，循环退出。

小练习：

利用循环依次对list中的每个名字打印出 Hello, xxx

names=['hjr','lr','hjj','lqq','yiyou']
for name in names:
    print('hello,',name)

使用dict和set

dict

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储。具有极快的查找速度。

举个例子，假设要根据同学的名字查找对应的成绩，如果用list实现，需要两个list：

names = ['hjr','lr','hjj','lqq']
scores = [95,85,75,65]

给定一个名字，在查找对应的成绩，就先要在names中找到对应的位置，再从scores取出对应的成绩，list越长，耗时就越长。

如果用dict实现，只需要一个”名字“-”成绩“的对照表，直接根据名字查找成绩，无论这个表多大，查找速度都不会变慢。

用Python写一个dict如下：

>>> d={'hjr':95,'lr':85,'hjj':75,'lqq':75}

>>> d['lr']
85

为什么dict查找速度这么快呢？因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字，我们要查某一个汉字，一个办法就是把字典从第一页往后翻，直到我们想要的字为止，这种方法就是在list中查找元素的方法，list越大，查找越慢。

第二种方法是先在字典的索引表里（比如部首表）查这个字对应的页码，然后直接翻到该页，找到这个字。无论找哪个字，这种查找速度都非常快，不会随着字典的大小的增加而变慢。

dict就是第二种实现方式，给定一个名字，比如‘Michael’，dict在内部就可以直接计算出Michael对应的存放成绩的”页码“，也就是95个数字存放在内存的地址，直接取出来，所以速度非常快。

这种key-value存储方式，在放进去的时候，必须根据key算出value的存放位置，这样，取的时候就能根据key直接拿到value。

把数据放入dict的方法，除了初始化时指定外，还可以通过key放入：

>>> d['Adam']=67
>>> d['Adam']
67

由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：

>>> d['Jack']=90
>>> d['Jack']
90
>>> d['Jack']=88
>>> d['Jack']
88

如果key不存在，dict就会报错：

>>> d['Thomas']
Traceback (most recent call last):
  File "", line 1, in <module>
KeyError: 'Thomas'

要避免key不存在的错误，有两种方法，

一是通过in判断key是否存在：

>>> 'Thomas' in d
False

二是通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定value：

>>> d.get('Thomas')
>>> d.get('Thomas',-1)
-1

注意：返回None的时候，Python的交互式命令行不显示结果。

要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

>>> d
{'hjr': 95, 'Jack': 88, 'lqq': 75, 'lr': 85, 'hjj': 75}

>>> d.pop('Jack')
88

>>> d
{'hjr': 95, 'lqq': 75, 'lr': 85, 'hjj': 75}

注意：dict内部存放的顺序和key放入的顺序是没有关系的。

和list比较，dict有以下几个特点：

1）查找和插入的速度极快，不会随着key的增加而增加;
2）需要占用大量的内存，内存浪费多。

而list相反：

1）查找和插入的时间随着元素的增加而增加;
2）占用空间小，浪费内存少。

故，dict是用空间来换取时间的一种方法。

dict可以用在需要告诉查找的很多地方，在Python代码中几乎无处不在，正确使用dict非常重要，
需要牢记的第一条就是 dict的key必须是不可变对象。

这是因为dict根据key来计算value的存储位置，如果每次计算相同的key得出的结果不同，那dict内部就完全混乱了。

这个通过key计算存储位置的算法称为哈析算法（Hash）。

要保证hash的正确性，作为key的对象就不能变。在Python中，字符串/整数等都是不可变的，因此，可以放心的作为key。

而list是可变的，就不能作为key：

>>> key = [1,2,3]
>>> d[key]='a list'
Traceback (most recent call last):
  File "", line 1, in <module>
TypeError: unhashable type: 'list'

set

set和dict类似，也是一组key的集合，但不存储value。
由于key不能重复，所以，在set中，没有重复的key。

要创建一个set，需要提供一个list作为输入集合：

>>> s = set([1,2,3])
>>> s
{1, 2, 3}

注意：传入参数[1，2，3]是一个list，而显示的{1，2，3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也表示set是有序的。

重复元素在set中自动被过滤：

>>> s = set([1,1,2,2,3,3])
>>> s 
{1, 2, 3}

通过add(key)方法可以添加元素到set中，可以重复添加，但是不会有效果：

>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}

通过remove(key)方法可以删除元素：

>>> s.remove(4)
>>> s
{1, 2, 3}

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集/并集等操作：

>>> s1 = set([1,2,3])
>>> s2 = set([2,3,4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部”不会有重复元素“。

我们把list放入set中，看看是否会报错：

思考：...

不可变对象

上面有说，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’了：

所以，对于不可变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。

相反，这些方法会创建新的对象并且返回，这样，就保证了不可变对象本身永远是不可变的。

小结：

使用key-value存储结构的dict在Python中非常有用，选择不可变对象作为key很重要，最常用的key是字符串。

tuple虽然是不可变对象，但是，试试把（1，2，3）和（1，[2,3]）放入dict或set中。。。