3. Python 的非正式介绍
通过是否出现 >>> 或 ... 来区分是否是输入和输出, 对于多行输入的结束你需要在多输入一行空行以结束. 其外以 # 开头的注释是不能写在字符串中间, 只能出现在开头或是空白和代码的后面.
3.1 Python 作为计算器使用
启动解释器, 直到出现 >>> .
3.1.1 数字
和我们想要操作的一样, 只要在 >>> 后键入想要计算的数字就可以算出答案.
加法:
>>> 1 + 1
2
减法:
>>> 3 - 2
1
乘法:
>>> 2 * 3
6
>>> 1.2 * 3
3.5999999999999996
1.2 * 3 之所以是这个数是因为浮点数存在计算机中是采用二进制 存储的, 所以看 1.2 这个小数, 将其转换为二进制是 1.0011001100110011 , 这还是没有写完的情况,小数部分之后都是0011无尽的循环, 所以太长了, Python 采用双精度(64bit) 所以后面的会被截掉, 因此存入的时候就是小于 1.2 的, 但是奇怪的是有时候也是不一样的.
>>> 1.2
1.2
>>> 1.2 * 1
1.2
>>> 1.2 * 2
2.4
据说之前版本的Python 输入1.2 之类的数字会显示那种很长的, 现在变成这样是因为调用了repr() 把数字转换成了字符串, 还进行了四舍五入之类的,
乘方:
>>> 2 ** 3
8
意思就是2的三次
除法:
>>> 2 / 2
1
>>> 1 / 3
0.3333333333333333
>>> 1 // 2
0
除法分为二种, 一种就是默认的也就是上面二个例子, 默认采用浮点数进行除, 使用 // 可以采用忽略小数的方式.
余数:
>>> 2 % 3
2
括号:
>>> 3 + (3 * 4)
15
整数和浮点数的混合运算:
>>> 1 * 2.0
2.0
可以看到结果是一个浮点数, python 会把整数转化为浮点数进行计算.
3.1.2 字符串
使用 '...' 或者 "..." 单引号或者双引号包裹字符串, 使用转义字符 \ 来显示其他一些特殊字符.
>>> "test"
test
>>> 'test'
test
>>> 'test\n'
'test\n'
使用 print() 函数会忽略两边的引号, 并且打印出经过转译的字符
>>>print("test")
test
>>> print('test')
test
>>> print("test\n")
test
也可以使用 print（） 函数打印出相同的效果, 在字符串前 + r 就可以使用原始的字符串.
>>> print(r"test\n")
test\n
字符串可以跨行输入 使用 '''...''' 或 """...""" , 字符串中进行的换行, 实际输出也会包含换行, 如果不想换行可以使用 \ 进行连接.(这里实际是运行在sublime Text2)
Test.py:
print("""sssss
sssss""")
print('''sssss
sssss''')
print("""sssss\
sssss""")
运行结果:(最后的换行是软件自带的换行)
sssss
sssss
sssss
sssss
ssssssssss
***Repl Closed***
可以使用 + 将二个字符串进行连接
Test.py:
print("aaa" + "bbb")
运行结果:
aaabbb
***Repl Closed***
python会自动将相邻的多个字符串连接.(中间没有空格也可以使用, 单引号和双引号混合使用也可以, 但是有时候情况复杂的时候就会出错, 最好还是用加号连接)
Test.py:
print("aaa" "bbb")
运行结果:
aaabbb
***Repl Closed***
这样的连接方式只可用于同是用引号包裹的字符串, 不能将变量和引号包裹的进行连接, 想要这样连接可以使用 +
进行, 也可以使用 * 进行重复.
Test.py:
n = "ttt"
print(3 * n)
运行结果:
ttttttttt
***Repl Closed***
索引:
字符串可以被下标访问, 第一个索引是0 .
Test.py:
n = "123"
print(n[0])
运行结果:
1
***Repl Closed***
与别的语言不同的是Python的索引可以使用 负数 , 负数的索引是从右边向左数:
Test.py:
n = "123"
print(n[-1])
运行结果:
3
***Repl Closed***
-0 和 0 是一样的, 所以 -1 是最后一个.
切片:
索引可以得到一个字符, 切片可以获取子字符串.
Test.py:
n = "123"
print(n[0:2])
运行结果:
12
***Repl Closed***
切片的开始是包含的, 结束的不包含的, 类似于数学中的 [,) 左闭右开.
切片是有默认值的, 左边的默认值是 0 , 右边是字符串的结尾, 所以可以如下表示.
Test.py:
n = "123"
print(n[:2])
print(n[0:])
print(n[:2] + n[2:])
运行结果:
12
123
123
***Repl Closed***
同样也可以在切片中使用负数.
Test.py:
n = "123"
print(n[:-1])
print(n[:-1] + n[-1:])
运行结果:
12
123
***Repl Closed***
可以这么理解切片:
+---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1
使用超出长度的索引, 系统会爆出错误:
Test.py:
n = "123"
print(n[3])
运行结果:
Traceback (most recent call last):
File "Test.py", line 2, in <module>
print(n[3])
IndexError: string index out of range
***Repl Closed***
但是在切片中的索引会被其自动处理, 要是长度超过界限, 则会取最后的长度.
Test.py:
n = "123"
print(n[0:100])
print(n[100:])
运行结果:
123
***Repl Closed***
Python中的str是不可以更改的.
Test.py:
n = "1234"
n[0] = '1'
运行结果:
Traceback (most recent call last):
File "Test.py", line 2, in <module>
n[0] = '1'
TypeError: 'str' object does not support item assignment
***Repl Closed***
可以使用 len() 来获取字符串的长度.
Test.py:
n = "123"
print(len(n))
运行结果:
3
***Repl Closed***
3.1.3 列表
列表是用方括号 [] 括起来, 使用逗号 , 分割的一组值, 可以包含多种类型的值. 和字符串一样, 列表同样可以使用好索引和切片.
Test.py:
n = [1, 2, 3, 4, 5, 6]
print(n[0])
print(n[0:2])
运行结果:
1
[1, 2]
***Repl Closed***
所有的切片都返回一个新的列表, 新的列表有点类似于c语言中重新开辟一个数组, 存贮的位置是不一样的, 就像java中new 一个列表, 但是python还有一些区别, python复制分为浅拷贝和深拷贝:
Test.py:
n = [1, 2, 3]
p = n
x = n[:]
n[0] = 4
print(n)
print(p)
print(x)
运行结果:
[4, 2, 3]
[4, 2, 3]
[1, 2, 3]
***Repl Closed***
观察结果: p = n 就像把地址也复制给 p , 其和 n 是一样的存在, 只是变量名字不同, x = n[:] 就是我所说的浅拷贝了, 可以看到它是有自己的存储空间的, 当 n 改变的时候, 它的值是不变的, 那深拷贝呢.
Test.py:
import copy
n = [1, 2, 3, [4, 5]]
p = n
x = copy.copy(n)
y = copy.deepcopy(n)
n[0] = 4
n[3][0] = [100]
print(n)
print(p)
print(x)
print(y)
运行结果:
[4, 2, 3, [[100], 5]]
[4, 2, 3, [[100], 5]]
[1, 2, 3, [[100], 5]]
[1, 2, 3, [4, 5]]
***Repl Closed***
导入 copy 模块, copy.copy 和 x = n[:] 是一样的, 都是浅拷贝, copy.deepcopy() 是深拷贝, 可以看到我们把n的数据换了, 在列表里面加入一个列表, 如何只改变 n[0] 的值可以看出和上次的结果是一样的, 但是如何改变的是列表中的列表的话, 发现其随着n的改变它也变了, 说明二者列表中的列表的地址是一样的, 但是深拷贝的值并没有变, 这就是深拷贝和浅拷贝的区别.
拼接列表, 就像拼接字符串那样拼接即可:
Test.py:
n = [1, 2, 3, 4]
n = n + [5, 6]
print(n)
运行结果:
[1, 2, 3, 4, 5, 6]
***Repl Closed***
与字符串不同的是列表可以随意更改其中的元素.
Test.py:
n = [1, 2, 3, 4, 5]
n[0] = 10
print(n)
运行结果:
[10, 2, 3, 4, 5]
***Repl Closed***
还能减小列表的大小和清空列表.
Test.py:
n = [1, 2, 3]
n[:] = []
print(n)
运行结果:
[]
***Repl Closed***
追加新的元素:
Test.py:
n = [1, 2, 3]
n.append(4)
print(n)
运行结果:
[1, 2, 3, 4]
***Repl Closed***
3.2 走向编程的第一步
要是我们采用以前逻辑方式编写斐波那契数列(c语言):
a = 0
b = 1
while a < 10:
c = a + b
a = b
b = c
print(a)
运行结果:
1
1
2
3
5
8
13
***Repl Closed***
现在我们可以采用:
a = 0
b = 1
while a < 10:
a, b = b, a + b
print(a)
运行结果:
1
1
2
3
5
8
13
***Repl Closed***
这一小节其实说的不是走向编程的第一步, 只是简单的说明了python的便捷之处, 以前需要一个变量去进行数值的交换, 现在需要采用这种方式就可以进行, 这只是python的一部分, 接下来的代码都将采用更长的代码和更为复杂的逻辑进行操作.
