Python3 基础学习

入门知识

脚本文件

#!/usr/bin/env python3
print("Hello World!")

Python文件第一行 #! 称为 Shebang ，告诉 shell 使用 Python 解释器执行其下面的代码。

运行脚本文件，要为文件添加可执行权限（否则会出现权限不足的错误）：

chmod +x fiilename.py

如果程序中没有 #!/usr/bin/env python3 的话，应该使用 python3 fiilename.py 来执行，否则使用 ./fiilename.py 程序会被当作 bash 脚本来执行

代码风格建议

Python 使用缩进来定义语句块，缩进是 Python 语法的一部分，这与其它大多数语言不同。

• 使用 4 个空格来缩进

• 永远不要混用空格和制表符

• 在函数之间空一行

• 在类之间空两行

• 字典，列表，元组以及参数列表中，在 , 后添加一个空格。对于字典，: 后面也添加一个空格

• 在赋值运算符和比较运算符周围要有空格（参数列表中除外），
  但是括号里则不加空格：a = f(1, 2) + g(3, 4)

注释

# 这是一个注释
# 下面这一行是求两数之和
a = 12 + 34
print(a) # 这里也是注释 :)

一般在 # 后跟一个空格，然后再写注释

模块

import math    # 导入math模块
print(math.e) # 2.71828182846

变量和数据类型

关键字和标识符

下列的标识符是 Python3 的关键字，并且不能用于通常的标识符。关键字必须完全按照下面拼写：

False               def                 if                  raise
None                del                 import              return
True                elif                in                  try
and                 else                is                  while
as                  except              lambda              with
assert              finally             nonlocal            yield
break               for                 not                 
class               from                or                  
continue            global              pass

这些内容可以在 Python3 解释器中得到：

python3
>>> help()
>>> keywords

从键盘读取输入

Python 中使用函数 input() 来接受用户输入的字符串。

number = int(input("Enter an integer: "))

单行定义多个变量或赋值

a , b = 45, 54

运算符和表达式

运算符

2 + 3    # 5
23.0 - 3    # 20.0
22 / 12    # 1.8333333333333333

只要有任意一个操作数是浮点数，结果就会是浮点数。

进行除法运算时若是除不尽，结果将会是小数，这很自然，如果要进行整除，使用 // 运算符，它将返回商的整数部分。

% 是求余运算符：

14 % 3    # 2

整数运算示例

#!/usr/bin/env python3
days = int(input("Enter days: "))
months = days // 30
days = days % 30
print("Months = {} Days = {}".format(months, days))

在Enter days:后获得用户输入的天数，然后获得月份数和天数，最后把这些数打印出来。你可以使用更容易的办法：

#!/usr/bin/env python3
days = int(input("Enter days: "))
print("Months = {} Days = {}".format(*divmod(days, 30)))

divmod(days, 30)    # (3, 1)

divmod(num1, num2) 返回一个元组，这个元组包含两个值，第一个是 num1 和 num2 相整除得到的值，第二个是 num1 和 num2 求余得到的值，然后我们用 * 运算符拆封这个元组，得到这两个值。

关系运算符

在终端里输入python3进入交互页面,试一试以下一些例子：

>>> 1 < 2
True
>>> 3 > 34
False
>>> 23 == 45
False
>>> 34 != 323
True

逻辑运算符

对于逻辑 与，或，非，我们使用 and，or，not 这几个关键字。

逻辑运算符 and 和 or 也称作短路运算符：它们的参数从左向右解析，一旦结果可以确定就停止。例如，如果 A 和 C 为真而 B 为假，A and B and C 不会解析 C 。作用于一个普通的非逻辑值时，短路运算符的返回值通常是能够最先确定结果的那个操作数。

关系运算可以通过逻辑运算符 and 和 or 组合，比较的结果可以用 not 来取反意。逻辑运算符的优先级又低于关系运算符，在它们之中，not 具有最高的优先级，or 优先级最低，所以 A and not B or C 等于 (A and (notB)) or C。当然，括号也可以用于比较表达式。

下面是一些例子：

>>> 5 and 4   # 首先判断5，肯定为true，那么最终的结果就取决于 and 后面那个的布尔值，4 的布尔值为 true，这样就可以确定整个表达式的值为 true 了，所以返回 4
4
>>> 0 and 4   # 首先判断0，因为 0 的布尔值为 false，那么不管 and 后面那个的布尔值是什么，整个表达式的布尔值都应该为 false 了，这个时候就不需要判断 4 了，直接返回最先确定结果的那个数也就是0
0
>>> False or 3 or 0
3
>>> 2 > 1 and not 3 > 5 or 4
True

简写运算符

>>> a = 12
>>> a += 13
>>> a
25
>>> a /= 3
>>> a
8.333333333333334
>>> a += (26 * 32)
>>> a
840.3333333333334

表达式

通常我们书写表达式的时候，会在每一个运算符左右都放一个空格，这样使代码更可读，如：

a = 234 * (45 - 56 / 34)

类型转换

>>> a = 8.126768
>>> str(a)
'8.126768'

控制流 If-else

If 语句

语法如下：

if expression:
    do this

如果表达式 expression 的值为真（不为零的任何值都为真），程序将执行缩进后的内容。务必要使用正确的缩进，在表达式为真的情况将会执行缩进的所有行。

Else 语句

if expression:
    do this
else:
   do this

if expression:
    do this
elif expression:
    do this
else:
    do this

elif 是 else if 的缩写。

循环

while 循环

while 语句的语法如下：

while condition:
    statement1
    statement2

想要多次执行的代码必须以正确的缩进放在 while 语句下面。在表达式 condition 为真的时候它们才会执行。同 if-else 一样，非零值为真。

斐波那契（Fibonacci）数列

让我们来试试打印斐波那契数列。这个数列前两项为 1，之后的每一个项都是前两项之和。所以这个数列看起来就像这样：1,1,2,3,5,8,13 ……

#!/usr/bin/env python3
a, b = 0, 1
while b < 100:
    print(b)
    a, b = b, a + b

第一行代码中我们初始化 a 和 b。当 b 的值小于 100 的时候，循环执行代码。循环里我们首先打印 b 的值，然后在下一行将 a + b 的值赋值给 b，b 的值赋值给 a。

break

if expression:
    break

break，它可以终止最里面的循环。

字符串若是乘上整数 n，将返回由 n 个此字符串拼接起来的新字符串。

>>> 's' * 10
'ssssssssss'
>>> print("*" * 10)
**********
>>> print("#" * 20)
####################
>>> print("--" * 20)
----------------------------------------
>>> print("-" * 40)
----------------------------------------

列表

>>> a = [ 1, 342, 223, 'India', 'Fedora']
>>> a
[1, 342, 223, 'India', 'Fedora']

通过索引来访问列表中的每一个值：

>>> a[0]
1
>>> a[4]
'Fedora'

使用负数的索引，那将会从列表的末尾开始计数：

>>> a[-1]
'Fedora'

切片：

>>> a[0:-1]
[1, 342, 223, 'India']
>>> a[2:-2]
[223]

切片并不会改变正在操作的列表，切片操作返回其子列表，这意味着下面的切片操作返回列表一个新的（栈）拷贝副本：

>>> a[:]
[1, 342, 223, 'India', 'Fedora']

切片的索引有非常有用的默认值；省略的第一个索引默认为零，省略的第二个索引默认为切片的列表大小：

>>> a[:-2]
[1, 342, 223]
>>> a[-2:]
['India', 'Fedora']

有个办法可以很容易地记住切片的工作方式：切片时的索引是在两个元素之间 。左边第一个元素的索引为 0，而长度为 n 的列表其最后一个元素的右界索引为 n。例如：

 +---+-----+-----+---------+----------+
 | 1 | 342 | 223 | 'India' | 'Fedora' |
 +---+-----+-----+---------+----------+
   0    1     2       3        4          5
  -5   -4    -3      -2       -1

上面的第一行数字给出列表中的索引点 0…5。第二行给出相应的负索引。切片是从 i 到 j 两个数值表示的边界之间的所有元素。

对于非负索引，如果上下都在边界内，切片长度就是两个索引之差。例如 a[2:4] 是 2。

Python 中有关下标的集合都满足左闭右开原则，切片中也是如此，也就是说集合左边界值能取到，右边界值不能取到。

对上面的列表， a[0:5] 用数学表达式可以写为 [0,5) ，其索引取值为 0,1,2,3,4，所以能将a中所有值获取到。 你也可以用a[:5], 效果是一样的。

而a[-5:-1]，因为左闭右开原则，其取值为 -5,-4,-3,-2 是不包含 -1 的。

为了取到最后一个值，你可以使用 a[-5:] ，它代表了取该列表最后5个值。

试图使用太大的索引会导致错误：

>>> a[32]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> a[-10]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

Python 能够优雅地处理那些没有意义的切片索引：一个过大的索引值(即大于列表实际长度)将被列表实际长度所代替，当上边界比下边界大时(即切片左值大于右值)就返回空列表:

>>> a[2:32]
[223, 'India', 'Fedora']
>>> a[32:]
[]

切片操作还可以设置步长，就像下面这样：

>>> a[1::2]
[342, 'India']

它的意思是，从切片索引 1 到列表末尾，每隔两个元素取值。

列表也支持连接这样的操作，它返回一个新的列表：

>>> a + [36, 49, 64, 81, 100]
[1, 342, 223, 'India', 'Fedora', 36, 49, 64, 81, 100]

列表允许修改元素：

>>> cubes = [1, 8, 27, 65, 125]
>>> cubes[3] = 64
>>> cubes
[1, 8, 27, 64, 125]

也可以对切片赋值，此操作可以改变列表的尺寸，或清空它：

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # 替换某些值
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # 现在移除他们
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # 通过替换所有元素为空列表来清空这个列表
>>> letters[:] = []
>>> letters
[]

细心的同学可能发问了，前面不是说过切片操作不改变列表么？严格来说，这里并不算真正的切片操作，只是上面代码中赋值运算符左边的这种操作与切片操作形式一样而已。

要检查某个值是否存在于列表中，你可以这样做：

>>> a = ['ShiYanLou', 'is', 'cool']
>>> 'cool' in a
True
>>> 'Linux' in a
False

这意味着我们可以将上面的语句使用在 if 子句中的表达式。通过内建函数 len() 我们可以获得列表的长度：

>>> len(a)
3

如果你想要检查列表是否为空，请这样做：

if list_name: # 列表不为空
    pass
else: # 列表为空
    pass

列表是允许嵌套的（创建一个包含其它列表的列表），例如：

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

for 循环

通过 for 语句我们可以使用 for 循环。Python 里的 for 循环与 C 语言中的不同。这里的 for 循环遍历任何序列（比如列表和字符串）中的每一个元素。下面给出示例：

>>> a = ['ShiYanLou', 'is', 'powerful']
>>> for x in a:
...     print(x)
...
ShiYanLou
is
powerful

我们也能这样做：

>>> a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> for x in a[::2]:
...     print(x)
1
3
5
7
9

range() 函数

如果你需要一个数值序列，内置函数 range() 会很方便，它生成一个等差数列（并不是列表）：

>>> for i in range(5):
...     print(i)
...
0
1
2
3
4
>>> range(1, 5)      
range(1, 5)
>>> list(range(1, 5))
[1, 2, 3, 4]
>>> list(range(1, 15, 3))
[1, 4, 7, 10, 13]
>>> list(range(4, 15, 2))
[4, 6, 8, 10, 12, 14]