python入门

Posted 2022-04-26 纵拥千晚星

1.下载编译器

https://download.jetbrains.8686c.com/python/pycharm-community-2017.2.3.exe

2.设置编码

3.测试helloWorld

#!/usr/bin/python
print("你好，世界");
1.
2.

运行成功

 4.cmd命令

 5.要声明一个除默认值之外的编码，应该添加一条特殊的注释行作为文件的第一行。语法如下：

＃ -*- 编码：编码 -*-
1.

# -*- coding: UTF-8 -*-
1.

6.python文件运行

7.注意：

1.当我们在Python交互式环境下编写代码时，​​>>>​​是Python解释器的提示符，不是代码的一部分。

2.当我们在文本编辑器中编写代码时，千万不要自己添加 >>>。

print语句也可以跟上多个字符串，用逗号“,”隔开，就可以连成一串输出：

>>> print The quick brown fox, jumps over, the lazy dog
The quick brown fox jumps over the lazy dog
1.
2.

print会依次打印每个字符串，遇到逗号“,”会输出一个空格，因此，输出的字符串是这样拼起来的：

​​

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

>>> print 300
300    #运行结果
>>> print 100 + 200
300    #运行结果
1.
2.
3.
4.

因此，我们可以把计算100 + 200的结果打印得更漂亮一点：

>>> print 100 + 200 =, 100 + 200
100 + 200 = 300     #运行结果
1.
2.

注意: 对于100 + 200，Python解释器自动计算出结果300，但是，100 + 200 =是字符串而非数学公式，Python把它视为字符串。

8.注释

Python的注释以​​ # ​​开头，后面的文字直到行尾都算注释

# 这一行全部都是注释...
print hello # 这也是注释
1.
2.

注释还有一个巧妙的用途，就是一些代码我们不想运行，但又不想删除，就可以用注释暂时屏蔽掉：

# 暂时不想运行下面一行代码:
# print hello, python.
1.
2.

9.变量

当我们写：​​a = ABC​​时，Python解释器干了两件事情：

1. 在内存中创建了一个​​ABC​​​的字符串；2. 在内存中创建了一个名为​​a​​​的变量，并把它指向​​ABC​​。

也可以把一个变量a赋值给另一个变量b，这个操作实际上是把变量b指向变量a所指向的数据，例如下面的代码：

a = ABC
b = a
a = XYZ
print b
1.
2.
3.
4.

最后一行打印出变量b的内容到底是ABC呢还是XYZ？如果从数学意义上理解，就会错误地得出b和a相同，也应该是XYZ，但实际上b的值是ABC，让我们一行一行地执行代码，就可以看到到底发生了什么事：

执行​​a = ABC​​，解释器创建了字符串  ABC和变量 a，并把a指向 ABC：

​​

执行​​b = a​​，解释器创建了变量 b，并把b指向 a 指向的字符串ABC：

​​

执行​​a = XYZ​​，解释器创建了字符串XYZ，并把a的指向改为XYZ，但b并没有更改：

​​

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

10.转义字符

转义字符还有：

\\n 表示换行
\\t 表示一个制表符
\\\\ 表示 \\ 字符本身
1.
2.
3.

11.raw字符串

如果一个字符串包含很多需要转义的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀​​ r ​​，表示这是一个 raw 字符串，里面的字符就不需要转义了。例如：

r\\(~_~)/ \\(~_~)/
1.

但是​​r...​​​表示法不能表示多行字符串，也不能表示包含​​​​​和 ​​"​​​的字符串（为什么？）如果要表示多行字符串，可以用​​...​​表示：

Line 1
Line 2
Line 3
1.
2.
3.

上面这个字符串的表示方法和下面的是完全一样的：

Line 1\\nLine 2\\nLine 3
1.

还可以在多行字符串前面添加​​ r ​​，把这个多行字符串也变成一个raw字符串：

rPython is created by "Guido".
It is free and easy to learn.
Lets start learn Python in imooc!
1.
2.
3.

 12.python的布尔运算True / False

与运算：只有两个布尔值都为 True 时，计算结果才为 True。

True and True   # ==> True
True and False   # ==> False
False and True   # ==> False
False and False   # ==> False
1.
2.
3.
4.

或运算：只要有一个布尔值为 True，计算结果就是 True。

True or True   # ==> True
True or False   # ==> True
False or True   # ==> True
False or False   # ==> False
1.
2.
3.
4.

非运算：把True变为False，或者把False变为True：

not True   # ==> False
not False   # ==> True
1.
2.

在Python中，布尔类型还可以与其他数据类型做 and、or和not运算，请看下面的代码：

a = True
print a and a=T or a=F
1.
2.

计算结果不是布尔类型，而是字符串 a=T，这是为什么呢？

因为Python把​​0​​​、​​空字符串​​​和​​None​​看成 False，其他数值和非空字符串都看成 True，所以：

True and a=T 计算结果是 a=T
继续计算 a=T or a=F 计算结果还是 a=T
1.
2.

要解释上述结果，又涉及到 and 和 or 运算的一条重要法则：短路计算。

1. 在计算​​ a and b ​​​时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。2. 在计算​​ a or b ​​时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。

所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。

13.列表

Python内置的一种数据类型是列表：​​list​​。list是一种有序的集合，可以随时添加和删除其中的元素。

比如，列出班里所有同学的名字，就可以用一个list表示：

>>> [Michael, Bob, Tracy]
[Michael, Bob, Tracy]
1.
2.

list是数学意义上的有序集合，也就是说，list中的元素是按照顺序排列的。

构造list非常简单，按照上面的代码，直接用​​ [ ] ​​把list的所有元素都括起来，就是一个list对象。通常，我们会把list赋值给一个变量，这样，就可以通过变量来引用list：

>>> classmates = [Michael, Bob, Tracy]
>>> classmates # 打印classmates变量的内容
[Michael, Bob, Tracy]
1.
2.
3.

由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，我们完全可以在list中包含各种数据：

>>> L = [Michael, 100, True]
1.

一个元素也没有的list，就是空list：

>>> empty_list = []
1.

14.如何根据列表顺序访问单个数据？

由于list是一个有序集合，所以，我们可以用一个list按分数从高到低表示出班里的3个同学：

>>> L = [Adam, Lisa, Bart]
1.

那我们如何从list中获取指定第 N 名的同学呢？方法是通过索引来获取list中的指定元素。

需要特别注意的是，索引从 0 开始，也就是说，第一个元素的索引是0，第二个元素的索引是1，以此类推。

因此，要打印第一名同学的名字，用 L[0]:

>>> print L[0]
Adam
1.
2.

要打印第二名同学的名字，用 L[1]:

>>> print L[1]
Lisa
1.
2.

要打印第三名同学的名字，用 L[2]:

>>> print L[2]
Bart
1.
2.

要打印第四名同学的名字，用 L[3]:

>>> print L[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
1.
2.
3.
4.

报错了！IndexError意思就是索引超出了范围，因为上面的list只有3个元素，有效的索引是 0，1，2。

所以，使用索引时，千万注意不要越界。

15.list之倒数排序

我们还是用一个list按分数从高到低表示出班里的3个同学：

>>> L = [Adam, Lisa, Bart]
1.

这时，老师说，请分数最低的同学站出来。

Bart同学是最后一名，俗称倒数第一，所以，我们可以用 -1 这个索引来表示最后一个元素：

>>> print L[-1]
Bart
1.
2.

Bart同学表示躺枪。

类似的，倒数第二用 -2 表示，倒数第三用 -3 表示

16.list添加新元素

现在，班里有3名同学：

>>> L = [Adam, Lisa, Bart]
1.

今天，班里转来一名新同学 Paul，如何把新同学添加到现有的 list 中呢？

第一个办法是用 list 的​​ append() ​​方法，把新同学追加到 list 的末尾：

>>> L = [Adam, Lisa, Bart]
>>> L.append(Paul)
>>> print L
[Adam, Lisa, Bart, Paul]
1.
2.
3.
4.

append()总是把新的元素添加到 list 的尾部。

如果 Paul 同学表示自己总是考满分，要求添加到第一的位置，怎么办？

方法是用list的​​ insert()​​方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素：

>>> L = [Adam, Lisa, Bart]
>>> L.insert(0, Paul)
>>> print L
[Paul, Adam, Lisa, Bart]
1.
2.
3.
4.

L.insert(0, Paul) 的意思是，Paul将被添加到索引为 0 的位置上（也就是第一个），而原来索引为 0 的Adam同学，以及后面的所有同学，都自动向后移动一位。

17.list删除元素

Paul同学刚来几天又要转走了，那么我们怎么把Paul 从现有的list中删除呢？

如果Paul同学排在最后一个，我们可以用list的​​pop()​​方法删除：

>>> L = [Adam, Lisa, Bart, Paul]
>>> L.pop()
Paul
>>> print L
[Adam, Lisa, Bart]
1.
2.
3.
4.
5.

pop()方法总是删掉list的最后一个元素，并且它还返回这个元素，所以我们执行 L.pop() 后，会打印出 Paul。

如果Paul同学不是排在最后一个怎么办？比如Paul同学排在第三：

>>> L = [Adam, Lisa, Paul, Bart]
1.

要把Paul踢出list，我们就必须先定位Paul的位置。由于Paul的索引是2，因此，用​​ pop(2)​​把Paul删掉：

>>> L.pop(2)
Paul
>>> print L
[Adam, Lisa, Bart]
1.
2.
3.
4.

18.list替换元素

假设现在班里仍然是3名同学：

>>> L = [Adam, Lisa, Bart]
1.

现在，Bart同学要转学走了，碰巧来了一个Paul同学，要更新班级成员名单，我们可以先把Bart删掉，再把Paul添加进来。

另一个办法是直接用Paul把Bart给替换掉：

>>> L[2] = Paul
>>> print L
L = [Adam, Lisa, Paul]
1.
2.
3.

对list中的某一个索引赋值，就可以直接用新的元素替换掉原来的元素，list包含的元素个数保持不变。

由于Bart还可以用 -1 做索引，因此，下面的代码也可以完成同样的替换工作：

>>> L[-1] = Paul
1.

19.有序列表tuple

注意：一旦创建完毕，就不能修改了。

同样是表示班里同学的名称，用tuple表示如下：

>>> t = (Adam, Lisa, Bart)
1.

创建tuple和创建list唯一不同之处是用​​( )​​​替代了​​[ ]​​​。现在，这个​​ t ​​就不能改变了，tuple没有 append()方法，也没有insert()和pop()方法。所以，新同学没法直接往 tuple 中添加，老同学想退出 tuple 也不行。

获取 tuple 元素的方式和 list 是一模一样的，我们可以正常使用 t[0]，t[-1]等索引方式访问元素，但是不能赋值成别的元素，不信可以试试：

>>> t[0] = Paul
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: tuple object does not support item assignment
1.
2.
3.
4.

20.tuple之创建单元素

tuple和list一样，可以包含 0 个、1个和任意多个元素。

包含多个元素的 tuple，前面我们已经创建过了。

包含 0 个元素的 tuple，也就是空tuple，直接用 ()表示：

>>> t = ()
>>> print t
()
1.
2.
3.

创建包含1个元素的 tuple 呢？来试试：

>>> t = (1)
>>> print t
1
1.
2.
3.

好像哪里不对！t 不是 tuple ，而是整数1。为什么呢？

因为​​()​​既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。

正是因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义：

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

Python在打印单元素tuple时，也自动添加了一个“,”，为了更明确地告诉你这是一个tuple。

多元素 tuple 加不加这个额外的“,”效果是一样的：

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

21.tuple“可变”

前面我们看到了tuple一旦创建就不能修改。现在，我们来看一个“可变”的tuple：

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

注意到 t 有 3 个元素：a，b和一个list：[A, B]。list作为一个整体是tuple的第3个元素。list对象可以通过 t[2] 拿到：

>>> L = t[2]
1.

然后，我们把list的两个元素改一改：

>>> L[0] = X
>>> L[1] = Y
1.
2.

再看看tuple的内容：

>>> print t
(a, b, [X, Y])
1.
2.

不是说tuple一旦定义后就不可变了吗？怎么现在又变了？

别急，我们先看看定义的时候tuple包含的3个元素：

​​

当我们把list的元素A和B修改为X和Y后，tuple变为：

​​

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

tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向a，就不能改成指向b，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

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