第一章 python 基础知识
1.1 数字和数学表达式
1.2 python 2.x 和python 3.x print的区别
1.3 python 2.x 和 python 3.x input 的区别
1.4 数学函数
1.5 input 和 raw_input 区别
第二章 列表和元组
第三章 使用字符串
1.1 数字和表达式
Python 默认的除法：整数/整数，无论是否整除都得到整数，不整除的截取小时部分
1 / 2
0
如果想要Python 执行普通的除法，可以之用浮点数来实现也可以改变Python执行除法的方法
1.0 / 2
0.5
1.0 / 2.0
0.5
1 / 2.0
0.5
1/2.
0.5
from __future__ import division
1 / 2
0.5
__future__ 前后均有两个下划线
Linux下 使用Qnew 参数也可以实现普通除法运算
[[email protected] ~]# python -Qnew
Python 2.7.5 (default, Nov 6 2016, 00:28:07)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-11)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 1 / 2
0.5
注意Python3 默认是执行普通除法运算
[[email protected] ~]# python3
Python 3.6.1 (default, May 31 2017, 18:02:43)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-11)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 1 / 2
0.5
整除使用双斜杠。python 2 和 python 3 使用方式都一样
>>> 4 // 6
0
>>> 6 // 3
2
>>> 6 // 5
In [1]: 5.4 // 1.8
Out[1]: 3.0
In [2]: 5.4 // 1.8
Out[2]: 3.0
In [5]: 5.4 % 1.8
Out[5]: 2.220446049250313e-16
虽然Python中浮点数也支持取模运算，但是对浮点数进行运算的时候要格外注意精度的问题。5.4 / 1.8 =3 正好整除，按理应该是0，可是这里的值不为0，很奇怪？？？
幂运算(乘方) 比一元取反运算优先级要高
In [10]: -2 ** 4
Out[10]: -16
In [11]: (-2) ** 4
Out[11]: 16
In [12]: -(2 ** 4)
Out[12]: -16
-2 ** 4 = -(2 ** 4)
python 2 和 python 3 对于整形数字超出范围的自动转换为长整型，不需要过分的关注整型的取值范围，因为python能够处理很长的数字。可以手动的数字后面加一个大写的L就表示这是一个长整型。当然小写的l也可以只是这里看起来很像数字1，所以建议使用大写的L
注意python 2.2 及以前整型值超出范围会报错。-2147483648 -- 2147483647
python 2
In [15]: 214748364789987
Out[15]: 214748364789987
In [16]: 214748364789987568978945465 * 4654654167897893212313212312313212313132 + 5213
Out[16]: 999579371218972816926339919579932791950025118287985996498731351593L
In [17]: 4654654167897893212313212312313212313132
Out[17]: 4654654167897893212313212312313212313132L
Python 3
In [11]: 214748364789987
Out[11]: 214748364789987
In [12]: 214748364789987568978945465
Out[12]: 214748364789987568978945465
In [13]: 214748364789987568978945465 * 4654654167897893212313212312313212313132 + 5213
Out[13]: 999579371218972816926339919579932791950025118287985996498731351593
1.2 python 2.x 和 python 3.x print 的区别
python print。python 2 直接输出即可，python 3 print 变成了函数
python 2
In [18]: print 3 + 3
6
python 3
In [14]: print (2 + 3)
5
In [15]: print 2 + 3
File "<ipython-input-15-b59db2781faf>", line 1
print 2 + 3
^
SyntaxError: Missing parentheses in call to ‘print‘
1.3 python 2.x 和 python 3.x input 的区别
获取用户的输出 python 2 和 Python 3 有区别。input函数接受用户的输入python 2输入的数字会当成整型，而python 3 输入的数字当成字符型。输入字符串的时候python 2 需要使用引号括起来，而python 3 可以不用引号括起来
python 2
In [20]: s = input("The meaning of life:")
The meaning of life:45
In [21]: s
Out[21]: 45
In [22]: type(s)
Out[22]: int
In [27]: s = input("The meaning of life:")
The meaning of life:abc
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-27-e2b30580ea33> in <module>()
----> 1 s = input("The meaning of life:")
<string> in <module>()
NameError: name ‘abc‘ is not defined
In [31]: x = input("x: ")
x: 34
In [32]: y = input("y: ")
y: 23
In [33]: x * y
Out[33]: 782
python 3
In [17]: s = input("The meaning of life:")
The meaning of life:67
In [18]: s
Out[18]: ‘67‘
In [19]: type(s)
Out[19]: str
In [23]: s = input("The meaning of life:")
The meaning of life:‘980‘
In [24]: type(s)
Out[24]: str
In [25]: s = input("The meaning of life:")
The meaning of life:abc
In [26]: s
Out[26]: ‘abc‘
In [33]: y = int(input("y: "))
y: 23
In [34]: x = int(input("x: "))
x: 34
In [35]: x * y
Out[35]: 782
1.4 基础数学函数
内嵌
pow(x) 求幂函数
abs(x) 求绝对值函数
round(number,ndigits) 对浮点数进行四舍五入
math
floor(x) 向下取整，将小数部分抹掉
ceil(x) 这个函数向上取整，当x为小数的时候去掉小数部分，整数部分+1
sqrt(x) 求平方根
求幂的函数pow()
python 内建函数
pow(x,y[,z]) = x ** y%z
x的y次方所得的值对z取模
In [34]: pow(2,3)
Out[34]: 8
In [35]: 2 ** 3
Out[35]: 8
In [1]: 10 + pow(2,3*5)/3.0
Out[1]: 10932.666666666666
注意python的版本不同精度有所不同，本实验所使用的两个版本的精度一致
内建函数 abs 求绝对值
In [1]: abs(-10)
Out[1]: 10
In [2]: abs(10)
Out[2]: 10
round(number,ndigits)
此内建函数：对浮点数进行四舍五入。对number这个浮点数进行四舍五入，ndigits 这个数是精度，必须是整型。可以是负数
两个版本的区别
python2 输出始终是浮点数
python 3 输出始终是整型
python 2 大于0.49999999999999999这个数输出值位1.0，小于这个输出值为0.0
python 3 大于0.5000000000000001 输出值为1，小于这个数输出值为0
python 2
In [59]: b = "0.49999999999999999"
In [60]: len(b)
Out[60]: 19
In [61]: round(0.49999999999999999)
Out[61]: 1.0
In [62]: round(0.4999999999999999)
Out[62]: 0.0
python 3
In [74]: round(0.50000000000000001)
Out[74]: 0
In [75]: round(0.5000000000000001)
Out[75]: 1
In [72]: b = ‘0.5000000000000001‘
In [73]: len(b)
Out[73]: 18
两个版本相同。注意这里应该是个陷阱，四舍五入是逢五进一
列一
In [76]: round(5.005,2)
Out[76]: 5.0
In [77]: round(5.006,2)
Out[77]: 5.01
列二
In [78]: round(5.32,2)
Out[78]: 5.32
In [79]: round(5.325,2)
Out[79]: 5.33
In [83]: round(5.324,2)
Out[83]: 5.32
列三
In [120]: round(1.675,2)
Out[120]: 1.68
In [121]: round(2.675,2)
Out[121]: 2.67
列四
In [123]: round(-1.436,2)
Out[123]: -1.44
In [124]: round(-1.433,2)
Out[124]: -1.43
这两个例子，第一个例子是逢六进一，第二个例子是逢五进一。还有一个问题需要注意：round(5.001,2) 输出5.0而不是5.00.这个问题也很奇怪这样精度就是1而不是2。第三个列子说明有时候是逢五进一，有时候是逢六进一
math.floor() 这个函数需要导入math模块 import math 才可以使用。
作用：向下取整，将小数部分抹掉，但是注意这里有个精度的问题
python 2 返回的是浮点数，python 3 返回的是整型
python 2
In [67]: math.floor(32.999999999999999)
Out[67]: 33.0
In [68]: math.floor(32.99999999999999)
Out[68]: 32.0
In [70]: a = ‘32.999999999999999‘
In [71]: len(a)
Out[71]: 18
大于 或等于32.999999999999997，小于33 math.floor返回33.0
大于32，小于或等于32.999999999999996 math.floor 返回32.0
python 3
In [103]: math.floor(32.99999999999999)
Out[103]: 32
In [104]: math.floor(32.999999999999997)
Out[104]: 33
In [105]: b = ‘32.999999999999997‘
In [106]: len(b)
Out[106]: 18
大于 或等于32.999999999999997，小于33 math.floor返回33
大于32，小于或等于32.999999999999996 math.floor 返回32
math.ceil(x) 这个函数向上取整，当x为小数的时候去掉小数部分，整数部分+1
python 2 返回的浮点值
In [121]: math.ceil(4.0000000000000004)
Out[121]: 4.0
In [122]: math.ceil(4.0000000000000005)
Out[122]: 5.0
4.0000000000000005 <= x < 5 math.ceil(x) 返回5.0
4 <= x < 4.0000000000000004 math.ceil(x) 返回4.0
python 3 返回的是整型
In [121]: math.ceil(4.0000000000000004)
Out[121]: 4
In [122]: math.ceil(4.0000000000000005)
Out[122]: 5
4.0000000000000005 <= x < 5 math.ceil(x) 返回5
4 <= x < 4.0000000000000004 math.ceil(x) 返回4
sqrt(x) 对x求平方根，x>0，为整数和浮点数。返回的是浮点数
from math import sqrt 这样写可以避免当多个包中有sqrt函数的时候出现混淆的情况，而且这样就可以不用写math.这个前缀
In [141]: from math import sqrt
In [142]: sqrt(9)
Out[142]: 3.0
In [143]: sqrt(15)
Out[143]: 3.872983346207417
In [144]: help(sqrt)
In [145]: sqrt(-9)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-145-4abb6f6b3805> in <module>()
----> 1 sqrt(-9)
ValueError: math domain error
使用变量引用的方式来使用函数，这样的方式更精简，适用。
In [151]: foo = math.sqrt
In [152]: foo(36)
Out[152]: 6.0
math.sqrt() 这个函数只能处理浮点数，而负数的平方根是虚数。而虚数(以及复数，虚数和实数之和)是完全不同的，这里需要使用使用另外一个包中函数。cmath.sqrt()
In [138]: import cmath
In [139]: square_root = cmath.sqrt
In [140]: square_root(-36)
Out[140]: 6j
In [141]: square_root(-49)
Out[141]: 7j
注意这里没有使用from ... import ... 语句，如果使用 from cmanth import sqrt 那么不能直接使用sqrt 因为前面有使用 from math import sqrt。所以一般情况下最好还是使用import语句，不要使用from .. import ...。如果不想写前置，可以使用变量引用的方式简化函数调用
后缀带j表示虚数，python本身也支持虚数
In [142]: (1+3j) * (9+4j)
Out[142]: (-3+31j)
1.5input 与 raw_input 的区别
input 和 raw_input 区别
1、input 接受标准的python表达式，如果是字符串需要使用引号括起来。而raw_input 接受任意类型的输入
2、对于数字来讲，raw_input 将数字当做字符串，而input把输入的数字当做int,float 等类型
列1
In [201]: c = raw_input(3 + 5)
8
In [202]:
In [173]: input(1+3)
4
File "<string>", line unknown
^
SyntaxError: unexpected EOF while parsing
input 直接敲回车会报错，因为没有输入内容
列2
In [205]: raw_input("what number is: ")
what number is: 56
Out[205]: ‘56‘
In [206]: input("what number is: ")
what number is: 56
Out[206]: 56
列3
In [202]: raw_input("what is your name: ")
what is your name: zhangsan
Out[202]: ‘zhangsan‘
In [203]: input("what is your name: ")
what is your name: zhangsan # 要加引号
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-203-aa9bc168e8eb> in <module>()
----> 1 input("what is your name: ")
<string> in <module>()
NameError: name ‘zhangsan‘ is not defined
In [204]: input("what is your name: ")
what is your name: ‘zhangshan‘
Out[204]: ‘zhangshan‘
input() 本质上还是使用 raw_input() 来实现的，只是调用完 raw_input() 之后再调用 eval() 函数，所以，你甚至可以将表达式作为 input() 的参数，并且它会计算表达式的值并返回它。
除非有特殊需要，一般都不使用input() 这个函数，使用raw_input()
python 3 中没有raw_input() 这个内嵌函数，只有input() 这个函数
1.6 python 单引号，双引号，三引号以及单反引号，转义符”\”的使用
输出一个字符串，里面包含一个整型变量
In [208]: temp = 43
In [209]: print ‘The tempreature is ‘ + temp
File "<ipython-input-209-8542dd1140c6>", line 1
print ‘The tempreature is " + temp
^
SyntaxError: EOL while scanning string literal
In [212]: print ‘The tempreature is ‘ + `temp`
The tempreature is 43
In [213]: print ‘The tempreature is ‘ + ‘temp‘
The tempreature is temp
#使用反引号将temp括起来
In [214]: print ‘The tempreature is ‘ + repr(temp)
The tempreature is 43
注意python 3 不支持反引号
print ‘‘‘This is a very long string.
It continues here.
And it‘s not over yet
Hello, world!"
Still here.‘‘‘
字符串中既有双引号也有单引号，可以考虑使用三个单引号或者3个双引号将这个字符串括起来。而且三引号支持字符串跨行。同样也可以用于注释多行代码
如果字符串中既有双引号也有单引号不想使用三引号，那么单双引号需要转义(使用反斜线\)
原始字符串
In [218]: print ‘C:\\Program Files\\fnord\\foo\\bar\\baz\\frozz\\bozz‘
C:\Program Files\fnord\foo\bar\baz\frozz\bozz
In [219]: print r‘C:\\Program Files\\fnord\\foo\\bar\\baz\\frozz\\bozz‘
C:\\Program Files\\fnord\\foo\\bar\\baz\\frozz\\bozz
In [220]: print r‘C:\Program Files\fnord\foo\bar\baz\frozz\bozz‘
C:\Program Files\fnord\foo\bar\baz\frozz\bozz
原始字符串以r开头，输入什么就输出什么，一些python特有的字符串在原始字符串哪里没有特殊意义。最尾部不能以反斜线结尾
pytho 2
In [221]: print r‘C:\Program Files\fnord\foo\bar\baz\frozz\bozz\‘
File "<ipython-input-221-755d0826b88d>", line 1
print r‘C:\Program Files\fnord\foo\bar\baz\frozz\bozz\‘
^
SyntaxError: EOL while scanning string literal
In [222]: print r‘C:\Program Files\fnord\foo\bar\baz\frozz\bozz‘ + ‘\\‘
C:\Program Files\fnord\foo\bar\baz\frozz\bozz\
python 3
In [151]: print (r‘C:\Program Files\fnord\foo\bar\baz\frozz\bozz\‘)
File "<ipython-input-151-4570817c0148>", line 1
print (r‘C:\Program Files\fnord\foo\bar\baz\frozz\bozz\‘)
^
SyntaxError: EOL while scanning string literal
In [152]: print (r‘C:\Program Files\fnord\foo\bar\baz\frozz\bozz‘ + ‘\\‘)
C:\Program Files\fnord\foo\bar\baz\frozz\bozz\
在原始字符串中单引号，双引号和三引号可以输出，注意原始字符串r后面的字符需要用引号括起来，所以开始和结尾处使用的引号中间是不能出现的。如开始和结尾使用单引号扩起来，那么中间的字符串中就不能包含单引号.除非使用反斜线\，虽然这里的反斜线\不是转义，但是可以隔开引号的范围
python 2
In [235]: print r‘‘‘"hello python",‘hi python‘,‘‘‘
"hello python",‘hi python‘,
In [236]: print r"test,‘‘‘python‘‘‘,hello"
test,‘‘‘python‘‘‘,hello
In [239]: print r"test,‘‘‘python‘‘‘,hello,\"kong\""
test,‘‘‘python‘‘‘,hello,\"kong\"
In [240]: print r"test,‘‘‘python‘‘‘,hello,"kong""
File "<ipython-input-240-ce337e291739>", line 1
print r"test,‘‘‘python‘‘‘,hello,"kong""
^
SyntaxError: invalid synta
python 3
In [154]: print (r‘‘‘Hello python,"test",‘hi python‘.‘‘‘)
Hello python,"test",‘hi python‘.
In [155]: print (r‘‘‘Hello python,"test",‘hi python‘‘‘‘)
File "<ipython-input-155-cd93259d7f5d>", line 1
print (r‘‘‘Hello python,"test",‘hi python‘‘‘‘)
^
SyntaxError: EOL while scanning string literal
In [156]: print (r‘‘‘Hello python,"test",‘hi python‘,\‘‘‘kong\‘‘‘‘‘‘)
Hello python,"test",‘hi python‘,\‘‘‘kong\‘
In [157]: print (r‘‘‘Hello python,"test",‘hi python‘,\‘‘‘kong\‘‘‘.‘‘‘)
Hello python,"test",‘hi python‘,\‘‘‘kong\‘‘‘.
python 默认情况下普通字符串在内部以ascII码存储。
Unicode编码前面加u
In [3]: print u‘Hello, world!‘
Hello, world!
In [4]: u‘Hello, world!‘
Out[4]: u‘Hello, world!‘
注意python3 普通字符串在内部已Unicode编码存储