Python入门学习笔记

素颜马尾好姑娘i 2022-05-28 07:49 278阅读 0赞

*  1 Python入门教程
 *  2 Hello, world!
 *  3 Python中的数据类型
 *  4 可迭代对象
    
     *   *  4.1 tuple和list
         *  4.2 set和dict
         *  4.3 range()
         *  4.4 切片
 *  5 if-else
    
     *   *  5.1 if后置
         *  5.2 if ‘True’？
 *  6 for
    
     *   *  6.1 列表生成式
         *  6.2 if-for-切片的结合
         *  6.3 遍历dict
 *  7 函数
 *  8 其他
    
     *  join
     *  with … as …

# 1 Python入门教程 #

我是在[慕课网][Link 1]学习的[Python课程][Link 1]。**基于Python 2.7**。这套课程是比较浅显易懂的入门课程，有一点基础的基本上不到一下午就能学完。建议配套[廖雪峰的教程][Link 2]一起食用。  
本文旨在对之前所学的内容（基本语法）做一个**概括性的总结和梳理**，并且如果可以的话帮助后来人的学习。**不适合没有一点编程基础刚入门的小白**。

# 2 Hello, world! #

潜规则，入门的第一件事就是Hello world。Python的hello world是这样的：  
`print 'Hello, world!'`

当然，到了Python 3之后，print函数变成了这样：  
`print('Hello, world!')`  
这样就更像一个“正常”的函数了。

在Python中，不是Java和C这样用花括号来分割代码片段，而是使用**缩进**。例如，在java中定义一个打印hellowolrd的函数，我们会这样写：

public void printHello(boolean shouldPrint){
        if(shouldPrint){
            System.out.println("hello world");
        }
    }

而在Python中，这段代码应写为：

def print_hello(should_print):
        if should_print:
            print 'hello world'

通过缩进来控制代码层级，好处是代码显得非常工整，层次结构清晰；缺点是对于缺乏规范代码意识的新手来说，会掉进缩进错误、空格和tab混用等等的坑，并且在代码嵌套过深（虽然这是应该极力避免的）的情况下，可读性将变得比较差。其实对于一个有代码洁癖，严格按照规范编写代码（包括格式和命名等等）的程序员来讲，Python的缩进基本不存在上手难度，因为即使用C，用Java，写出工整、清晰、易读的代码也是日常操作（虽然IDE有一键格式化），个人认为这也是一个合格程序员的基本素质。

print函数可以接受多个参数。在打印时，每个参数直接会用空格隔开。例如：  
`print 'hello', 'world'`  
会打印出`hello world`

# 3 Python中的数据类型 #

Python是一种动态类型语言。也就是说，变量的类型是运行时确定的。你可以这么写：

a = 1
    print a
    a = 'a'
    print a

这样是完全没问题的。

同时，Python是一种强类型语言，即不支持或很少支持隐式的类型转换。Python有一个内建函数type(a)，可以返回变量a的类型。常见的基本类型有：  
\- 整型int  
\- 浮点型float  
\- 字符串string  
\- 布尔型bool  
有趣的是，bool类其实是int类的子类。bool只包含True和False两种值，True的int值是1，而False是0。可以调用`True == 1`和`False == 0`来进行验证。

**Think & Try**

*  输入`print '123' + 456`会打印出什么？
 *  `True < 3`的结果是什么？`'3' > 2`的结果是什么？

# 4 可迭代对象 #

可迭代对象（iterable），顾名思义，就是可以通过迭代的方式遍历的对象。看一个对象obj是不是可迭代的，可以通过isinstance(obj, Iterable)。不过首先要导入`from collections import Iterable`。

### 4.1 tuple和list ###

元组：`t = (1, 2, 3)`  
列表：`L = [1, 2, 3]`  
元组tuple和列表list类似，都是一种可迭代对象。不同的是，tuple是不可变的，而list是可变的。  
和Java，C中的数组不同的是，tuple和list的元素不需要是相同类型的。例如`L = [1, 2.0, '3', (4, 5)]`这个list既包含了整型，又包含了浮点型，字符串，元组。  
另外，当元组tuple只有一个元素的时候，会返回这个元素本身。例如`t = (5)`，表示t就是5，即与`t = 5`等价。

### 4.2 set和dict ###

和Java中的Set和Map类似，由于都是基于哈希算法的数据结构，所以查找速度很快。

*  set：`set = {1, 2, '3', (4, 5)}`  
    set和list类似，但是他是**无序的**，并且是**无重复的**。例如，当输入`s = {'a', 'b', 'c'}`之后，打印出的结果可能不是`{'a', 'b', 'c'}`而是`{'b', 'c', 'a'}`；又如，`s = {'a', 'a', 'b', 'c'}`，实际上和`s = {'a', 'b', 'c'}`是等价的，因为set不保存重复的值。另外，set还可以通过传入一个list的方式来获得，即：`s = set(['a', 'b', 'c'])`。
 *  dict：`dict = {'hello': 'world', 'foo': 'bar', 'fiz': 3, 4: 'buz'}`  
    dict是通过key-value对来进行数据存储的。每一对key-value通过`key: value`来定义，并用逗号隔开。当需要取值的时候，通过dict\[key\]来获取value的值。dict也是**无序的**。

### 4.3 range() ###

range()函数也返回一个可迭代对象。用法是：`range(from, to)`，其中第一个参数可以省略，默认从0开始，第二个参数**不包含**在范围内。例如：`range(1, 100)`代表1~99的范围，`range(5)`代表0~4的范围。  
range()函数返回的就是一个range对象，既不是tuple，也不是list。

### 4.4 切片 ###

对一个可迭代对象，Python支持对其进行切片。  
简单来说，我有一个list比如：`L = [1, 2, 3, 4, 5]`，想要取其中的一部分，这时候就可以用到切片操作。例如：`L[:3]`就是取这个列表的前三项。  
同时，也可以传入负数，代表倒数的第某项。

> 切片可以传入3个参数：  
> 第一个参数是开始取值的索引，可省略，默认是0。  
> 第二个参数是结束取值的索引，不包含该项；可省略，默认到结束。  
> 第三个是取值的间隔，可省略，默认挨个取。

还是上面那个列表。例子：  
`L[1:5:2]`表示从L的索引1开始，到索引5结束，每隔一项取值。即`[2, 4]`  
`L[:3]`表示取L的前三项。即`[1, 2, 3]`  
`L[::2]`表示取值索引之间差2。即`[1, 2, 3]`  
`L[-3:]`表示从索引倒数第3项开始取值。即`[3, 4, 5]`  
`L[3::]`同`L[3:]`  
`L[::-2]`表示从后往前取整个列表，并且间隔是2。即`[5, 3, 1]`  
`'hello world'[1: 10: 3]`表示从这个字符串的第二个字母开始，每3个字母取一次值，直到第10个字母。即`'eoo'`

**Think & Try**

*  如何打印出1~100范围内的最后20个偶数？（已知list类的构造方法是list(iterable)）
 *  set和dict真的是“无序的”吗？

# 5 if-else #

如果说一个程序是一栋大厦，那么`if`和`for`就是建造这栋大厦的钢筋混凝土。  
在Python中，if语句的用法是这样的：

if cond_1:
        do sth
    elif cond_2:
        do sth
    else:
        do sth

和其他语言如C，Java的if-else一样。

### 5.1 if后置 ###

if-else还可以后置使用。例如：

def foo(x):
        print 'odd' if x % 2 == 0 else 'even'

这里定义了一个函数foo(x)，如果x是偶数则打印’odd’，奇数则打印’even’。  
虽然用法有些不同，但是这跟java和C中的三元运算符是类似的。

public void foo(int x){
        return x % 2 == 0 ? "odd" : "even";
    }

### 5.2 if ‘True’？ ###

if后面不止可以跟bool值。事实上，if后面还可以跟其他值。比如整型，字符串，甚至函数等等。但只有当这个值是False，0，None等极少数情况才会使条件不成立，参见bool的构造函数。例如：

def foo():
        print 'hello'
    
    def bar():
        if foo:
            print 'world'
    
    bar()

最后打印出的结果是`world`

# 6 for #

Python中的for语句适用于所有可迭代对象。如tuple，list，string，range等。  
基本的用法是：

for i in Iter:
        print i

这句代码打印出可迭代对象的每一个元素。

### 6.1 列表生成式 ###

和if-else相似，for语句也可以后置。例如：  
`print [i for i in range(1, 100)]`  
其中`[i for i in range(1, 100)]`叫做**列表生成式**，表示生成包含1~99的列表。

### 6.2 if-for-切片的结合 ###

if、for、切片三者是可以结合使用的。例如：  
`print [i for i in range(1, 100) if i%3 == 0][1:5:2]`这句代码，表示在1~99的范围中，取出所有3的倍数，并从索引1（第2项，即6）开始，到索引4项为止，每2项取一次，构建一个列表，并将其打印出来。等价于：

L = []
    for i in range(1, 100):
        if i % 3 == 0:
            L.append(i)
    
    print L[1:5:2]

### 6.3 遍历dict ###

直接通过`for i in dict`的方式遍历一个dict，会得到这个dict的key的集合。而dict中有`keys()`和`values()`两个函数，分别返回这个dict的key和value的集合。  
另外，dict中还有`items()`函数，返回这个dict的key-value对集合。每个key-value通过一个两项的元组来保存。例如：

dict = {
       'hello': 'world', 'foo': 'bar', 'fiz': 3, 4: 'buz'}
    for item in dict.items():
        print item

运行结果是

('fiz', 3)
    ('foo', 'bar')
    (4, 'buz')
    ('hello', 'world')

**Think & Try**

*  打印出1000以内的所有质数

# 7 函数 #

Python定义函数的基本语法是：

def foo():
        do sth
        return result

如果没有返回值，return语句可以省略。另外，函数也可以有多个返回值，例如：

def bar():
        return 1, 2
    
    x, y = bar()
    
    print 'x = ' + x + ', y = ' + y

这个函数有两个返回值1和2。打印出的结果是`x = 1, y = 2`。事实上，函数返回的是`(1, 2)`这个元组。即`x, y = bar()`这句等价于`x, y = (1, 2)`。

**Think & Try**

*  用python编写一个对list进行排序的函数

# 8 其他 #

## join ##

使用某个字符串把一个序列的所有元素连接起来。  
例如：  
`'-'.join(('136', '1388', '1772'))`  
运行结果是`'136-1388-1772'`

## with … as … ##

在操作文件的时候，我们会这样写：

with open(filename) as f:
        print f.read()

这段代码类似于

f = None
    try:
        f = open(filename)
        print f.read()
    except Exception as e:
        """handle the exception"""
        print e
    finally:
        if f:
            f.close()

这个`with ... as ...`即是类似于`try... except... finally...`的处理。

事实上，不止是file，对于对于任意一个实现了`__enter__()`和`__exit__()`方法的类，都可以跟在with的后面。换句话说，如果需要`with... as...`来进行处理的类，需要实现`__enter__()`和`__exit__()`方法才能正常工作。例如以下类：

class Sample:
        def __enter__(self):
            # return self is important
            print 'enter'
            return self
    
        def __exit__(self, *args):
            print 'exit'
            for arg in args:
                print 'type:', type(arg), 'arg:', arg
    
        def run(self):
            print 'run'
            print 1 / 0

当我们调用

with Sample() as s:
        s.run()

时，因为Sample类实现了`__enter__()`和`__exit__()`方法，所以流程是：

*  将**`__enter__()`函数的返回值**（这个很重要，并不是`s = Sample()`）赋值给s，即`self`；
 *  然后调用s的`run()`方法；
 *  最后调用s的`__exit__()`方法。

运行一下，查看打印的内容：

enter
    run
    exit
    type: <type 'type'> arg: <type 'exceptions.ZeroDivisionError'>
    type: <type 'exceptions.ZeroDivisionError'> arg: integer division or modulo by zero
    type: <type 'traceback'> arg: <traceback object at 0x05617B70>

可以看到，当捕获到异常时，`__exit__()`中传入的三个参数分别是异常类型，异常对象，异常跟踪。如果没有捕获到异常，那么这三个参数都是None。

[Link 1]: https://www.imooc.com/learn/177
[Link 2]: https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000