发表于 | 分类于 |

简介

文本文件的读写主要通过open()所构建的文件对象来实现。

基本格式

f = open(文件名，模式)

最常用的模式有：

  1. “r” # 只读
  2. “w” # 写入 —->如果文件中已经有内容，会把内容抹掉，如果不存在该文件，会新建文件
  3. “a” #追加模式 —–>在已有的文字后添加文字
  4. “b” #二进制模式（还在其他模式中追加使用）—–>一般在处理音频、图像等文件的时候使用
  5. “+” #读/写模式(可在其他模式中追加使用) —–>r+、w+ 可读可写
1
2
3
4
5
6
7
8
9
10
11
12
13
14

f = open('test1.txt', 'w')       #创建一个名为f的类文件对象，对test1.txt进行写操作
f.write("大家好，我是王尼玛")    #像文件中写入字符串
f.close()

f = open('test1.txt')            #如果不写模式，默认为读模式

while True:
    line = f.readline()          #一次读一行
    if len(line) == 0:
        break
    print (line,end="")          #不换行

f.close()

输出

1
大家好，我是王尼玛
1
2
3
4
5
6
7
8
9
10
11
12

f=open("test.txt","w")
f.write("0123456789")
f.seek(4)                     #跳到第4个字节
f.write("Hello")
f.close()

f=open("test.txt","r")
print(f.read())               #把字符串全部输出
f.seek(2)                     #跳回到第2个字符
print(f.read(5))              #输出接下来的5个字节
f.close()

输出

1
2
0123Hello9
23Hel

Tips：

1.
以上所讲的仅仅是Python最基本的文件读写功能。更加丰富的文件读写功能由Python的标准库提供。
2.
read() readline()以及readlines()用法
read() 每次读取整个文件，它通常用于将文件内容放到一个字符串变量中。然而 .read() 生成文件内容最直接的字符串表示，但对于连续的面向行的处理，它却是不必要的，并且如果文件大于可用内存，则不可能实现这种处理。

.readline() 和 .readlines() 非常相似。它们都在类似于以下的结构中使用：

1
2
3
fh = open('c:\\autoexec.bat')
for  line in  fh.readlines():
     print（line）

.readline() 和 .readlines() 之间的差异是后者一次读取整个文件，象 .read() 一样。.readlines() 自动将文件内容分析成一个行的列表，该列表可以由 Python 的for … in …结构进行处理。另一方面，.readline() 每次只读取一行，通常比 .readlines() 慢得多。仅当没有足够内存可以一次读取整个文件时，才应该使用 .readline()。（readlines()的输出格式[“I’ll write this message for you\n”, “hehe,that’s will be ok.\n”]）

发表于 | 分类于 |

简介

虽然Python是解释性语言，但是它是面向对象的，能够进行对象编程。下面就来了解一下如何在Python中进行对象编程。

类是对现实世界中一些事物的封装。在人类认知中，会根据属性相近把东西归类，并且给类别命名。比如说，鸟类的共同属性是有羽毛，通过产卵生育后代。而且，这些鸟还有共同的行为，如飞行、名叫。任何一只特别的鸟都在鸟类的原型基础上的。接下来以鸟为例来介绍类的用法。

1
2
3
4
5
6
7
8
9
10
11
12

class Bird:                                                 #创建类--鸟
    have_feather = True                                     #定义类的属性（have_feather、way_of_reproduction、song均是该类的属性）
    way_of_reproduction  = "egg"
    song="叽叽喳喳"
    def sing(self):                                         #定义类的方法（self必不可少）
        print(self.song)
    def move(self):
        print("飞飞飞飞飞")
mybird=Bird()                                               #实例化类的对象，可以使用这个对象访问类中的方法和属性
mybird.sing()                                               #访问类中的方法（对象名.方法）
print("mybird通过"+mybird.way_of_reproduction+"繁殖")       #访问类中的属性（+号的作用是连接字符串）

输出结果为：

1
2
3

叽叽喳喳
mybird通过egg繁殖

小小的总结一下，我们定义了一个类（class），就是鸟（Bird）。在该类中，我们定义了三个变量，一个是有羽毛（have_feather），一个是生殖方式（way_of_reproduction）,还有一个是叫声（叽叽喳喳），这几个变量就是类的属性（attribute）。我们还定义个两个函数，一个是鸣叫(sing(self))，另一个是移动(move(self)),这两个函数就是类的方法（method）。

类建好了之后，我将类实例化为一个叫mybird的对象，并利用这个对象对类的属性和方法进行访问。

子类

鸟可以继续细分为鸡、鸭、鹅…..这就是所谓的子类。

1
2
3
4
5
6
7
8
9
10
11
12

class Chicken(Bird):                                           #继承上例中的Bird
    song="喔喔喔喔喔！"                                        #重写父类中的属性
    def move(self):                                            #重写父类中的方法
        print("这种移动方式已经废弃",end="--->")               #end的作用是把字符串末尾的换行符替换为“--->”
        super().move()                                         #调用父类中的方法(对象是没有super()的)
        print("跑跑跑跑跑")


myChicken=Chicken()
myChicken.move()
myChicken.sing()

多重继承

1
2
3
4
5
6
7
8
9
10
11
12
13

class Calculator:
    def calculate(self,expression):
        self.value=eval(expression)                         #计算字符串中的表达式
class Talker:
    def talk(self):
        print("结果为",self.value)
class TalkCalculator(Calculator,Talker):                    #本类不做任何事情，但是同时继承两个子类，这种行为叫做多重继承
    pass                                                    #pass是空语句，是为了保持程序结构的完整性。

myCal=TalkCalculator()
myCal.calculate("4+2")
myCal.talk()

Tips

1.多态、封装与继承

多态：意味着可以对不同类的对象进行相同的操作。

封装：对外部世界隐藏类的细节。

继承：以普通的类为基础建立专门的类的对象。

2.面向对象概念

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。

方法重载：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重载。

实例变量：定义在方法中的变量，只作用于当前实例的类。

继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟”是一个（is-a）”关系（例图，Dog是一个Animal）。

实例化：创建一个类的实例，类的具体对象。

方法：类中定义的函数。

对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

3.子类如何调用父类中的方法

1
2
3
4
5
6

class B(A):
def method(self, arg):
#        A.method(self,arg)                 #1直接写类名调用
#        super(B, self).method(arg)         #2用 super(type, obj).method(arg)方法调用
         super().method(arg)                #3在类定义中调用本类的父类方法，可以直接super().method(arg)

4.方法中的self

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，但是在调用这个方法的时候你不为这个参数赋值，Python会提供这个值。这个特别的变量指对象本身，按照惯例它的名称是self。

面向对象之续

特殊的方法

init方法

init方法在类的一个对象被建立时，马上运行。你可以利用这个方法对对象进行初始化。init方法类似于C++、C#和Java中的 constructor 。（注意：init的两边各有两条下划线）

1
2
3
4
5
6
7
8

class Person:
    def __init__(self, name):                               #在__init__中初始化name
        self.name = name
    def sayHi(self):
        print ("大家好，我是人贱人爱的", self.name)
p = Person("王尼玛")
p.sayHi()

del方法

del在对象消逝的时候被调用。对象消逝即对象不再被使用，它所占用的内存将返回给系统作它用。del方法与 destructor 的概念类似。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

class Person:
    '''Represents a person.'''                       #通过Person.__doc__查看
    population = 0

    def __init__(self, name):
        '''Initializes the person's data.'''
        self.name = name
        print ('(Initializing %s)' % self.name)      #格式化输出字符串.

        # When this person is created, he/she
        # adds to the population
        Person.population += 1                       #类的变量在引用的时候是 类名.类变量

    def __del__(self):
        '''I am dying.'''
        print ('%s says bye.' % self.name)

        Person.population -= 1

        if Person.population == 0:
            print ('I am the last one.')
        else:
            print ('There are still %d people left.' % Person.population)

    def sayHi(self):                                 #可通过Person.sayHi.__doc__查看
        '''Greeting by the person.

        Really, that's all it does.'''
        print ('Hi, my name is %s.' % self.name)

    def howMany(self):
        '''Prints the current population.'''
        if Person.population == 1:
            print ('I am the only person here.')
        else:
            print ('We have %d persons here.' % Person.population)

swaroop = Person('Swaroop')
swaroop.sayHi()
swaroop.howMany()

kalam = Person('Abdul Kalam')
kalam.sayHi()
kalam.howMany()
print(kalam.name)                                    #对象变量

swaroop.sayHi()
swaroop.howMany()
print(swaroop.name)

输出：

1
2
3
4
5
6
7
8
9
10
11

(Initializing Swaroop)
Hi, my name is Swaroop.
I am the only person here.
(Initializing Abdul Kalam)
Hi, my name is Abdul Kalam.
We have 2 persons here.
Abdul Kalam
Hi, my name is Swaroop.
We have 2 persons here.
Swaroop

小提示

1.类成员的访问权限

Python中所有的类成员都是公共的，所有的方法都是有效的。
只有一个例外：如果你使用的数据成员名称以双下划线前缀比如__privatevar，Python的名称管理体系会有效地把它作为私有变量。
还有这样就有一个惯例，如果某个变量只想在类或对象中使用，就应该以单下划线前缀。而其他的名称都将作为公共的，可以被其他类/对象使用。记住这只是一个惯例，并不是Python所要求的（与双下划线前缀不同）。

2.类的变量与对象的变量

类的变量：由一个类的所有对象（实例）共享使用。当某个对象对类的变量做了改动的时候，这个改动会反映到所有其他的实例上。（ 类名.类变量）
对象的变量：由类的每个对象/实例拥有。因此每个对象有自己对这个域的一份拷贝，即它们不是共享的，在同一个类的不同实例中，虽然对象的变量有相同的名称，但是是互不相关的。（对象名.变量）

3.print的格式化输出

支持参数格式化，与C语言的printf类似。

1
2
3

>>> strHello = "the length of (%s) is %d" %('Hello World',len('Hello World'))
>>> print (strHello)

输出

1
the length of (Hello World) is 11

1
2

>>> print("你好我的名字是%s,我今年%d岁了！" % ("王尼玛",2))                    #注意，字符串与后面变量之间没有逗号！

输出

1
你好我的名字是王尼玛,我今年2岁了！

发表于 | 分类于 |

简介

如果你想要在其他程序中重用很多函数，那么你该如何编写程序呢？答案是使用模块。模块是一个包含了所有你定义的函数和变量以.py结尾的文件。

定义并载入模块

首先来学习如何使用模块。
我在c:\test存放一个文件：Hello.py。存放的代码是：

1
print("Hello")

接着我们执行下面代码

1
2
3
4
import sys                         #import的作用是导入模块，这里我们导入了sys模块
sys.path.append("c:\\test")        #这条语句的作用是告诉解释器从哪里寻找模块。   路径还可以这样写sys.path.append("c:/test")

import Hello                       #这时我们就可以导入自己的模块Hello(模块名为文件名)

输出结果

1
Hello

这是可以在c:/test文件夹下看到多了一个新的文件夹pycache，在这个文件夹中出现了文件Hello.cpython-34.pyc。这个文件是与平台无关，且已经经过编译处理的。

包含函数的模块

我在c:\test存放一个文件：sayHello.py。存放的代码是：

1
2
3
4
5

def say():
    print("hello");
def cry()
    print("55555555")

我们执行下面的代码：

1
2
3
4
5
6

import sys
sys.path.append("c:\\test")         #如果被导入的模块与输入他的程序在同一个目录中，则不需要sys.path.append了
import sayHello

sayHello.say()                      #导入模块之后可以调用模块中的函数，但是需要以 模块名.函数  的格式sayHello.cry()

得到 hello，另一种方式是直接导入模块里的函数

1
2
3
4
5
6
import sys
sys.path.append("c:\\test")
from sayHello import say ,cry       #直接导入模块中具体的函数，缺点是如果想使用模块中的其他函数，需要追加导入

say()                               #可以直接使用函数
cry()

模块的属性

name属性

  1. 如果模块是被导入，name的值为模块名字(文件名)
  2. 如果模块是被直接执行，name的值为’main’
1
2
3
4
5

def say():
    print("hello");
if __name__ == '__main__':         #每个Python模块都有它的__name__，如果它是'__main__'，则输出“你好”
    print("你好")

输出你好

以模块的形式被调用，则什么都不会输出

应用

当我们编写Python库模块的时候，我们往往运行一些测试语句。当这个程序作为库被import的时候，我们并不需要运行这些测试语句。一种解决方法是在import之前，将模块中的测试语句注释掉。而更优美的解决方法，就是使用name。

下面是一个简单的库程序TestLib.py。当直接运行TestLib.py时，name为”main“。如果被import的话，name为”TestLib”。

1
2
3
4
5
6
7
8
9
10

def lib_func(a):
    return a + 10

def lib_func_another(b):
    return b + 20

if __name__ == '__main__':
    test = 101
    print(lib_func(test))

doc属性

介绍模块的功能

1
2
3

>>> math.__doc__
'This module is always available.  It provides access to the\nmathematical functions defined by the C standard.'

模块包

可以将功能相似的模块放在同一个文件夹（比如说this_dir）中，构成一个模块包。通过

1
import this_dir.module     #引入this_dir文件夹中的module模块.

该文件夹中必须包含一个init.py的文件，提醒Python，该文件夹为一个模块包。init.py可以是一个空文件。

Tips

在编译器中可以通过dir()函数来查看模块中的属性和函数。

1
2
3
4

>>> import math
>>> dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

发表于 | 分类于 |

函数的定义和调用

函数通过def关键字定义。def关键字后跟一个函数的标识符名称，然后跟一对圆括号。圆括号之中可以包括一些变量名，该行以冒号结尾。接下来是一块语句，它们是函数体。

1
2
3
def sayHi():                  #无参函数的定义，且没有返回值。函数将自动返回None。None是Python中的一个特别的数据类型，用来表示什么都没有，相当于C中的NULL。  
    print("你好我是王尼玛")   #注意缩进  
sayHi()                       #函数调用

输出为：

1
2
>>>   
你好我是王尼玛

1
2
3
4
def squareSum(a,b):            #带形参的函数定义（a,b即为形参）  
    c = a**2 + b**2            #a**2表示a的平方  
    return c                   #将c的值返回，与java不同的是，Python可以返回多个值，且以元组的形式返回  
print(squareSum(3,2))          #函数调用，将数值3，2带入函数

输出为：

1
13

带默认形参的函数

我们可在定义形参的时候直接给参数加一个默认值。值得注意的是带有默认值的形参要放在右边。比如“def say(message, times = 1):”是正确的而“def say(times=1,message):”是错误的！

1
2
3
4
5
def say(message, times = 1):  
    print ((message+" ") * times)         #字符串可以通过+号连接  
  
say('Hello')  
say('World', 3)

输出结果

1
2
Hello   
World World World

关键参数赋值

再调用函数的时候，我们可以直接通过形参名给形参赋值

1
2
3
4
5
6
def func(a, b=2, c=3):  
    print ("a、b、c的值分别为",a,b,c)      
  
func(1,3)  
func(1, c=24)  
func(c=50, a=100)

输出

1
2
3
a、b、c的值分别为 1 3 3  
a、b、c的值分别为 1 2 24  
a、b、c的值分别为 100 2 50

文档字符串❤

在函数的第一个逻辑行的字符串是这个函数的 文档字符串 。注意，DocStrings也适用于模块和类（虽然还没学到那…..委屈）。文档字符串主要用于给函数示意。

1
2
3
4
5
6
7
8
def sayHi():  
    """ 这个函数的作用是王尼玛勾搭妹子问候语"""    #只能通过三引号的行出，用井号不行  
    """本条语句也是不能作为函数字符串的！"""  
    print("你好我是王尼玛")  
sayHi()  
  
print(sayHi.__doc__)                               #函数名后不需要括号，doc两边的是双下划线  
help(sayHi)                                        #内置的help函数其实就是读取的doc

输出

1
2
3
4
5
6
你好我是王尼玛  
 这个函数的作用是王尼玛勾搭妹子问候语  
Help on function sayHi in module __main__:  
  
sayHi()  
    这个函数的作用是王尼玛勾搭妹子问候语

局部变量

定义在函数内部的变量叫做局部变量，不管局部变量的值在函数内部如何变化，都不会影响到函数外的同名变量。即变量名称对于函数来说是局部 的。这称为变量的作用域 。所有变量的作用域是它们被定义时所在的块。

1
2
3
4
5
6
7
8
a = 1  
  
def changeNum(a):                               #整数变量传递给函数，函数对它进行操作，但原整数变量a不发生变化。  
    a = a + 1  
    return a  
  
print ("函数返回值为",changeNum(a))  
print ("a的值为",a)

输出结果：

1
2
函数返回值为 2  
a的值为 1

4.使用global语句

如果你想要在函数外为一个定义在函数内的变量赋值，那么你就得通过global语句告诉Python这个变量名不是局部的，而是全局的。

1
2
3
4
5
6
7
8
9
10
def func():  
    global x  
  
    print ("函数中x的值为",x)  
    x = 2  
    return x  
  
x = 50                                              #在函数外为一个定义在函数内的变量赋值  
print ('x的值为', x)  
print("函数返回值为",func())

输出结果

1
2
3
x的值为 50  
函数中x的值为 50  
函数返回值为 2

lambda函数

lambda函数也叫匿名函数，即，函数没有具体的名称。先来看一个最简单例子：

1
2
3
4
5
6
7
def f(x):  
    return x**2  
print (f(4))  
  
#Python中使用lambda的话，写成这样   
g = lambda x : x**2  
print (g(4))

lambda生成一个函数对象。该函数参数为x,，返回值为x的平方。函数对象赋给g。g的调用与正常函数无异。

函数作为参数传递

函数可以作为一个对象，进行参数传递。函数名(比如func)即该对象。比如说:

1
2
3
4
5
6
7
8
def f(x):  
    return x**2  
  
def test(fx, a):                           #将函数作为参数传递  
    print ('%d的平方为' % a,end="")  
    print (fx(a))  
  
test(f, 4)

上面的程序可以改写为

1
2
3
4
5
def test(fx, a):                             
    print ('%d的平方为' % a,end="")  
    print (fx(a))  
  
test(lambda x:x**2, 4)

map()函数

map函数的定义：

map(function, sequence[, sequence, …]) -> list
通过定义可以看到，这个函数的第一个参数是一个函数，剩下的参数是一个或多个序列，返回值是一个集合。map()将每次从两个表中分别取出一个元素，带入lambda所定义的函数。

1
print(list(map(lambda x: x ** 2, (1, 2, 3, 4, 5))))

输出

1
[1, 4, 9, 16, 25]

1
print(list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])))

输出

1
[3, 7, 11, 15, 19]

filter()函数

filter函数的第一个参数也是一个函数对象。它也是将作为参数的函数对象作用于多个元素。如果函数对象返回的是True，则该次的元素被储存于返回的表中。filter通过读入的函数来筛选数据。同样，在Python 3.X中，filter返回的不是表，而是循环对象。

1
2
3
4
5
6
7
def func(a):  
    if a > 100:  
        return True  
    else:  
        return False  
  
print (list(filter(func,[10,56,101,500])))

小提示：

  1. 指针传递使函数可以改变函数外的值！

    对于基本数据类型的变量，变量传递给函数后，函数会在内存中复制一个新的变量，从而不影响原来的变量。（我们称此为值传递）

    但是对于列表来说，列表传递给函数的是一个指针，指针指向序列在内存中的位置，在函数中对表的操作将在原有内存中进行，从而影响原有变量。 （我们称此为指针传递）

    1
    2
    3
    4
    5
    6
    7
    8
    b = [1,2,3]  
      
    def changeList(b):                              #我们将一个表传递给函数，函数进行操作，原来的表b发生变化。  
       b[0] = b[0] + 1  
       return b  
      
    print ("函数返回值为",changeList(b))  
    print ("b的值为",b)

输出结果：

1
2
函数返回值为 [2, 2, 3]  
b的值为 [2, 2, 3]

  1. Python可以返回多个值，以元组的形式返回

    1
    2
    3
    4
    5
    6
    7
    def idSave():  
     	  	a=input("姓名为：")  
      	 	b=input("年龄为：")  
       	c=input("性别为：")  
       	return a,b,c  
      
    print(idSave())

输出结果：

1
2
3
4
姓名为：王尼玛  
年龄为：12  
性别为：女  
('王尼玛', '12', '女')

  1. 带有默认值的形参

    我们可在定义形参的时候直接给参数加一个默认值。值得注意的是带有默认值的形参要放在右边。

发表于 | 分类于 |

1.if

if主要用于条件判断。

1.1 if结构

1
2
3
4
5
i = 1  
x = 1  
if i > 0:                        #注意后面的冒号必不可少！  
    x = x+1                      #必须输入四个空格的缩进表示隶属关系！  
print x

1.2 if-elif-else 结构

1
2
3
4
5
6
7
8
9
10
11
12
<pre name="code" class="python">a = input("a:")                  #这条语句的作用是在屏幕显示“a:”,并等待用户输值赋给a。  
b = input("b:")  
if(a > b):  
    print (a, " 大于 ", b)  
    print("显示1")  
elif(a==b):                      #elif类似java中的else if，但要注意在末尾的冒号！  
    print(a,"等于",b)  
    print("显示2")  
else:                            #注意末尾的冒号！  
    print(a,"小于",b)  
    print("显示3")  
print("显示4")

这里有三个块，分别属于if, elif, else引领。Python检测条件，如果发现if的条件为假，那么跳过后面紧跟的块，检测下一个elif的条件； 如果还是假，那么执行else块。通过上面的结构将程序分出三个分支。程序根据条件，只执行三个分支中的一个。

1.3 if的嵌套使用

1
2
3
4
5
6
7
8
9
a = input("a:")  
b = input("b:")  
c = input("c:")  
if(a > b):  
    print (a,"大于",b)  
    if(a>c):                    #注意这里的的if需要缩进，因为该if隶属于if（a>b）  
        print(a,"大于",c)  
    else:  
        print(a,"小于",c)       #注意这里的if应该与if(a>c)缩进相同

2.while

给出一个while循环终止条件。 下例循环打印1到100

1
2
3
4
5
6
a=0  
while a<100:  
    a+=1                     #Python没有i++的写法  
    print(a）  
else:
    print("循环结束")

3.for

for循环需要预先设定好循环的次数(n)，然后执行隶属于for的语句n次。

1
2
3
4
5
student2=["王尼玛","男",22,["脑袋大","脖子短","屁股圆"]]  
for a in student2:                                                   
#循环次数为列表student2中元素的个数。  注意末尾的引号  
    print(a)                                                         
   	#循环结构同样需要缩进  因为迭代（也就是循环）某范围的数字非常常见，所以有个内建的范围函数提供使用——range()

1
2
list(range(10))                                                      #建立一个从0到9的列表(range()生成的是iterator对象。list()的作用是转换成列表)  
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

我们可以这样使用range()函数

1
2
for a in range(1,101):                                               #对while中的事例进行改造，打印1到100的数字  
    print(a)
1
2
list(range(1,100,3))                                                #生成从1到100间的数，步长为3  
1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52, 55, 58, 61, 64, 67, 70, 73, 76, 79, 82, 85, 88, 91, 94, 97]
1
2
list(range(99,1,-3))                                                 #1到100间的数字，逆向排列  
[99, 96, 93, 90, 87, 84, 81, 78, 75, 72, 69, 66, 63, 60, 57, 54, 51, 48, 45, 42, 39, 36, 33, 30, 27, 24, 21, 18, 15, 12, 9, 6, 3]

轻量级循环

1
2
[x*x for x in range(10)]                                            #生成一个简单的  
0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

enumerate()函数

利用enumerate()函数，可以在每次循环中同时得到下标和元素：

1
2
3
4
5
S = 'abcdefghijk'  
for (index,char) in enumerate(S):  
    print(index)  
    print(char)  
zip()

如果你多个等长的序列，然后想要每次循环时从各个序列分别取出一个元素，可以利用zip()方便地实现：

1
2
3
4
5
ta = [1,2,3]  
tb = [9,8,7]  
tc = ['a','b','c']  
for (a,b,c) in zip(ta,tb,tc):  
    print(a,b,c)

输出

1
2
3
1 9 a  
2 8 b  
3 7 c

1
2
3
a=["lucy","lily","tom"]  
b=[11,12,13]  
print(list(zip(a,b)))

输出

1
[('lucy', 11), ('lily', 12), ('tom', 13)]

4.中断循环

break——跳出循环
continue——跳出本次命令的之行，继续下一次循环

1
2
3
4
5
6
nameList=["王二小","王小明","小红","小刚","寒梅梅","王尼玛","李磊"]  
for name in nameList:  
    if name=="王尼玛":  
        print("凶手找到啦！")  
        break  
print(name)

输出为王尼玛

1
2
3
4
5
6
nameList=["王二小","王小明","小红","小刚","寒梅梅","王尼玛","李磊"]  
for name in nameList:  
    if name=="王尼玛":  
        print("凶手找到啦！")  
        continue  
print(name)

输出为李磊

5.注意

  • 1.Python的缩进
    空白在Python中是重要的。事实上行首的空白是重要的。它称为缩进。在逻辑行首的空白（空格和制表符）用来决定逻辑行的缩进层次，从而用来决定语句的分组。 这意味着同一层次的语句必须有相同的缩进。每一组这样的语句称为一个块。我们将在后面的章节中看到有关块的用处的例子。 你需要记住的一样东西是错误的缩进会引发错误。

  • 2.if格式

    1
    2
    3
    4
    5
    6
    7
    8
    if  <条件1>:
        	statement
    elif <条件2>:
        	statement
    elif <条件3>：
        	statement
    else:
        	statement

  • 3.while格式

    1
    2
    3
    4
    while<条件>:
    		statement
    else:
    		statement

  • 4.for格式

    for 变量 in <对象集合>：

  • 5.Python与其他语言的不同

    Python的while可以写else！