您现在的位置是：首页 > Python

当前栏目

Python入门学习笔记

Python 笔记对象学习入门代码

2023-03-02 11:11:42 时间

*  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

猜你喜欢

最长无重复子串
写技术博客的一些心得分享
Java 多线程（七）：线程池
Java 多线程（五）：锁（三）
Java 多线程（四）：锁（二）
Java 多线程（三）：锁（一）
Java 多线程（二）：并发编程的三大特性
线性时间非比较类排序
Java 多线程（一）：基础
合并k个已排序的链表
HDFS 高可用分布式环境搭建
合并两个有序数组
连续子数组的最大和
HDFS 分布式环境搭建
容器盛水问题
大数加法
HDFS 伪分布式环境搭建
设计LRU缓存结构
两数之和
使用单调栈来解决的一些问题

zl程序教程

当前栏目

Python入门学习笔记

相关文章