为了防止博客被爬，本站的所有文章的图片都添加水印。前几天刚刚学习完python，拿来练练手，确实有很多不熟悉的类库和代码，权当试试水了。。

#! /usr/bin/python
# coding:utf-8 
import os
from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
import random

def Watermark(fname, text):
    # 设置字体
    font = ImageFont.truetype("STLITI.TTF", 25)  # 不同的电脑可能不存在这里的字体，导致最后没有输出结果；如果你的电脑上没有这几种字体，请自行修改

    # 实例化图片对象
    imageFile = fname
    img = Image.open(imageFile).convert('RGBA')
    text_overlay=Image.new("RGBA",img.size,(255,255,255,0))
    draw = ImageDraw.Draw(text_overlay)
    
    t=max(text)
    t_len=len(t)
    
    for i in range(0, img.size[0], t_len*20+100):
        for j in range(0, img.size[1], t_len*20):
            draw.text((i, j), random.choice(text), font=font, fill=(0, 0, 0, 50))
 
    text_overlay = text_overlay.rotate(45)
    image_with_text = Image.alpha_composite(img, text_overlay)
    # 另存图片
    image_with_text.save("{}_marked.png".format(fname.split(".")[0]))



def drawText(path,text):
    if not os.path.exists(path):
        print("没有这个路径：",path)
    fileList= [os.path.join(fpathe,f) for fpathe,dirs,fs in os.walk(path) for f in fs if f.split(".")[1] in ["png","jpg"] and not f.split(".")[0][-6:]=="marked"]
    for img in fileList:
        Watermark(img,text)

 
if __name__ == '__main__':
    
    path="root"
    drawText(path,["text1","text2"])

本站的图片加水印对比效果：
{:height=”600px” width=”600px”}
{:height=”600px” width=”600px”}

海龟绘图

海龟绘图画图比较简单，主要使用python的turtle模块， 就是通过编程指挥一个小海龟在屏幕上前进和左转右转。

forward: 向前走,可以指定一个距离
left：左转，指定一个角度
right：右转，指定一个角度
circle:画圆
reset：重置

根据上面的说明我们可以简单的绘制一个五角星：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import turtle
t = turtle.Pen()
for x in range(5):
    t.forward(100)
    t.right(145)
turtle.done()
```  

![海龟绘图](/img/assets/42/01_marked.png)      

绘制螺旋阵：  

``` python
import turtle
import time
turtle.pensize(2)
turtle.bgcolor("black")
turtle.tracer(False)
turtle.color("white")
for x in range(400):
    turtle.forward(2*x)
    turtle.left(60)
turtle.tracer(True)
turtle.done()

更多的方法的说明可以看官方教程

枚举

在python中，枚举使用Enum模块。 具体使用如下：

1
2
3
4
5

from enum import Enum

Week=Enum("Week",('Mon','Tue','Wen','Thu','Fri','Sta','Sun'))

在枚举中可以自动为下面的变量赋值，我们可以使用迭代把数据显示出来：

1
2
3
4
5

from enum import Enum
Week=Enum("Week",('Mon','Tue','Wen','Thu','Fri','Sta','Sun'))

for k, v in Week.__members__.items():
    print(k, ':', v, ',', v.value)

打印结果：

1
2
3
4
5
6
7

Mon : Week.Mon , 1
Tue : Week.Tue , 2
Wen : Week.Wen , 3
Thu : Week.Thu , 4
Fri : Week.Fri , 5
Sta : Week.Sta , 6
Sun : Week.Sun , 7

如果像自定义枚举的值，可以使用继承的方法，自定义一个枚举：

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

from enum import Enum, unique
 
class Week(Enum):
    Sun = 0  
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

for k, v in Week.__members__.items():
    print(k, ':', v, ',', v.value)

打印结果：

1
2
3
4
5
6
7

Sun : Week.Sun , 0
Mon : Week.Mon , 1
Tue : Week.Tue , 2
Wed : Week.Wed , 3
Thu : Week.Thu , 4
Fri : Week.Fri , 5
Sat : Week.Sat , 6

可以使用@unique装饰器来保证值的唯一。

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

from enum import Enum, unique

@unique
class Week(Enum):
    Sun = 0  
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6
    Sat = 6

上面的代码会报错：TypeError: Attempted to reuse key: 'Sat'

对于枚举的使用可以用Week.Sun取枚举的值，Week.Sun.value来取对应的整型的值。

模块

随着项目增大，功能越来越复杂，为了提高代码的复用性和降低功能间的耦合，提出了模块的概念。

python中有很多的模块，使用时候直接用import导入对应的包就可以使用。

1

import sys

这样就导入了一个sys模块，我们可以在代码中直接使用：

1
2
3
4
5

import sys
def func():
    print (sys.argv)

func()

打印结果是当前的文件所在的路径。

解释sys的作用：
sys.argv 用list来存储命令行传过来的参数。第一个参数是.py文件名称，例如：

python3 xxx.py 运行结果就是['xxxx.py']

python3 xxxx.py abc 运行结果：['xxxx.py', 'abc']。

在python的模块中，有一个特殊的变量__name__,这个变量的作用就是如果当前运行的是当前文件，这个变量的值就是__main__,所以如果想对一个模块使用测试方法，可以利用这个变量：

1
2

if __name__=="__main__":
    func()

为了防止模块的命名有冲突，python 又引入了包的概念,包其实可以简单的认为就是一个文件的路径，例如有如下目录结构：

1
2
3
4
5
6

A
|- abc.py

B
|- abc.py    

上面的两个abc.py没有冲突。

我们也可以自己定义一个模块，比如：

mymodule文件:

1
2

def func_print():
    print("my module")

对module的使用：

1
2

import mymodule 
mymodule.func_print()

如果模块的名称过长，可以使用as 关键字定义其他的别名。

1
2

import mymodule as m 
m.func_print()

如果在包下面的模块 可以使用包名.模块名，例如，我们可以使用 import modules.moduleA方式导入指定的包。

类

面向对象变成对象中重要的一个组成，在python中是使用关键字class定义类。

比如我们想定义一个动物类：

1
2
3

class Animal:
    name="fantuan"   

我们创建实例的时候，直接使用Animal(),具体使用如下：

1
2

animal=Animal()
print (animal.name)

上面的Animal的类中的name属性可以通过实例和类名都可以调用。因为python在实例上找不到的属性都会沿着实例的类寻找。例如代码：

1
2
3
4
5

animalA=Animal()
animalB=Animal()
print(Animal.name)
print (animalA.name)
print (animalB.name)

都能打印出name属性的值。

python支持动态属性的定义

1
2

animalA.type="哺乳类"
print(animalA.type)

如果创建一个类的对象的时候，如果需要初始化变量，可以使用__init__方法。

1
2
3
4
5
6
7
8
9
10

class Animal:
    def __init__(self,name,type):
        self.name=name
        self.type=type

animal=Animal("dog","犬科")

print(animal.name)
print(animal.type)

__init__方法的第一个参数永远是self(类似Java和C++中的this指针)。

如果定义了__init__方法，在定义实例的时候就不能传递空的参数了。

在类中定义方法的时候，第一个参数的是self,其他与正常的方法相同。

访问限制

在类的成员中，需要控制类的访问，在Java或者C++ 使用private,public等来管理成员的访问权限。

在python中，使用两个下划线__来表示私有变量。

如果我们使用动态赋值给对象赋值了一个__name属性，那python会怎么处理？

1
2
3
4
5
6

class Animal:
    __name="dog"

a=Animal()
a.__name=2
print(a.__name )

打印的结果是 2

python会把这个变量当成一个普通的变量与内部定义的私有变量不同，可以被正常的访问。

在内部定义的私有变量会被转化成其它名称,具体的名称根据python版本而不同。

在通常的代码中，我们能看到一些_name 等一些单个下划线开头的变量，这中变量是可以正常被访问，但一般不要那么做，可以当成私有变量。

继承和多态

我们定义了一个Animal的类：

1
2
3
4
5
6
7
8
9

class Animal:
    def eat(self):
        print("eat") 

class Dog(Animal):
    pass

d=Dog()
d.eat()

d中有了eat方法,是从基类继承而来。

对于python弱类型语言，天生就是多态，也不需要继承关系。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class WorkerA:
    def do(self):
        print("WorkA Working")

class WorkerB:
    def do(self):
        print("WorkB Working")


def doWork(obj):
    obj.do()

workerA=WorkerA()
workerB=WorkerB()
doWork(workerA)
doWork(workerB)

打印结果：

1
2

WorkA Working
WorkB Working

python的函数也属于一个对象，可以有一个变量来代替，例如前面说过的一个例子：

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

f=abs
print(f(-10))
```    

如果我们在不改变原来函数的前提下，想扩展一个函数的功能。可以重新定义一个函数，把要原函数作为参数传递给`增强函数`，在调用函数前执行一些动作。 

```python
def revert(a):
    return abs(a)

def new_func(func):
     print("do something")
     return func

f=new_func(revert)
print(f(-10))

打印结果是：

1
2

do something
10

对于上面的代码，new_func就是装饰器，可以使用@对其进行简化：

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

def new_func(func):
     print("do something")
     return func
     
@new_func
def revert(a):
    return abs(a)

print(revert(-10))

```   

这样可以省去一个变量的定义，也维持了原来的方法名称。


上面的装饰器有点过于简单，因为我们只能在`return` 语句前增加内容，想在方法后面增加一个确不行，为了能够实现更强大的装饰器，我们可以对其做修改，再增加一层函数：

``` python
def new_func(func):
    def inner(a):
        print("do something")
        res=func(a)
        print("something is done")
        return res
    return inner
     
@new_func
def revert(a):
    print ("processing")
    return abs(a)
 
print(revert(-10))

打印结果：

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

do something
processing
something is done
10
```   

上面这个装饰器基本满足了我们的需求，但同样还有一个问题，上面的装饰器，只能传递一个参数，所以还是不够一般性。    

我们可以使用函数的默认值的方法来解决这个问题，官方给的是`*args 和 **kwargs`(tuple和dict类型)，修改如下：

``` python
def new_func(func):
    def inner(*args,**kw):
        print("do something")
        res=func(*args,**kw)
        print("something is done")
        return res
    return inner  
@new_func
def revert(a):
    print ("processing")
    return abs(a)

print(revert(-10))

我们再增加一个方法：

1
2
3
4
5
6

@new_func
def add(x,y):
    print ("processing")
    return x+y;
print(add(1,2))

打印结果是：

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

do something
processing
something is done
3
```   

装饰器也可以传递参数，但是需要更深层次的函数：   

``` python
def new_func(text):
    print ("call method:",text)
    def wapper(func):
        def inner(*args,**kw):
            print("do something")
            res=func(*args,**kw)
            print("something is done")
            return res
        return inner  
    return wapper

@new_func("revert")
def revert(a):
    print ("processing")
    return abs(a)
 
print(revert(-10))

运行结果：

1
2
3
4
5

call method: revert
do something
processing
something is done
10

函数式编程 主要思想是把运算过程尽量写成一系列嵌套的函数调用，不严谨的说：可以把函数的引用传递给变量。例如：

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

>>> abs(-10)
10
>>> f=abs
>>> f(-10)
10
```  
`f`就引用了abs函数的地址。

1. 可以把函数当成参数传递给另一个函数：  

     ```python
     def add(x,y,f):
     return f(x)+f(y)
     print(add(-1,2,abs))

2. 函数也可以当成返回值：

   1 2 3

   def getMethod(): return abs print(getMethod()(-1))

   打印结果是：1

3. python也支持lambda表达式

   1 2	f=lambda x:x+x print(f(10))

   打印结果是：10

4. 可以固定一个函数的默认值,返回一个新函数

   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

   import functools def add(x="2"): print(x) add() add1=functools.partial(add, x="5") add1() ``` 打印结果：`2 5` 我们使用`functools.partial`方法把`add`的默认值修改成一个新的函数`add1` #### 常用的几个函数 - map和reduce使用 `map`函数的格式可以大致的表示为：`map(func,[])`,其功能就是把数组的每一个元素代入到`func`函数中，具体的实现功能如下： `list(map(abs,[-1,3,4,-6]))`,打印结果是：[1,3,4,5] 我们可以根据其定义编写对应的功能： ```python def map1(func,arr): l=[] for x in arr: yield func(x) print(map1(abs,[1,-3,-4,6])) ``` `reduce`是一个累计的函数，把上次计算的结果，当成下次运行的一个参数：`s1=f(x,y);s2=f(s1,z)；` ``` python def add(x,y): return x+y print(reduce(add,[1,-3,-4,6])) ``` 计算结果：`1-3-4+6=0` 用python代码来表示`reduce` ``` python def reduce1(func,arr): s=0 for x in arr: s=func(s,x) return s;

数组的切片

定义一个数组

1

arr=list(range(100))

1. 数组取前3个元素 arr[0:3],0可以省略，arr[:3]，打印结果：[0,1,2]

2. 数组取后面三个元素： arr[-3:0],也可写为：arr[-3:],打印结果：[97,98,99]

3. 数组取后面三个元素： arr[97:],是跳过前97个数字，打印结果：[97,98,99]

4. 可以指定取值的间隔 arr[:10:2],打印结果：[0, 2, 4, 6, 8]
   如果在全部范围内查询，可以省略查询的个数，arr[::2]这样打印出来所有的偶数。

5. 切片的方法同样适用于tuple

6. 字符串可以看成是字符的数组，可以使用，"ABCDEFG"[:3] 输出结果ABC

迭代循环

1. list的循环

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

   arr=list(range(10)) for a in arr: print(a) ``` 2. `dict`循环 ```python dict={"a":1,"b":2,"c":3} for a in dict: print(a) ``` ```python dict={"a":1,"b":2,"c":3} for x,y in dict.items(): print(x,y) ``` ``` cte a 1 b 2 c 3

2. 字符串循环

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

   for a in "ABCD": print(a) ``` 4. 多个变量 ```python for x, y in [(1, 1), (2, 4), (3, 9)]: print(x, y) ``` 打印结果： ``` cte 1 1 2 4 3 9

3. 带索引的循环写法

   1 2 3 4 5 6 7 8 9 10

   for i, value in enumerate(['A', 'B', 'C']): print(i, value) ``` 打印结果： ```cte 0 A 1 B 2 C

4. 判断能否被迭代

   1 2 3

   from collections import Iterable isinstance('abc', Iterable)

列表生成式

列表生成式可以更简单的把生成一个list或者tuple.

定义一个100的数组，arr=list(range(100))

1. 定义一个100偶数的数组

   1 2 3 4

   arr=[2 * x for x in list(range(100))] 或者arr=[x for x in list(range(200)) if x%2==0]

   打印结果：[0,2,4...198]

2. 定义两个循环生成一个组合

   1	str=[a+b for a in "ABC" for b in "XYZ"]

   打印结果：['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']

3. 使用多个变量

   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

   dict = {'a': 'A', 'b': 'B', 'c': 'C' } dic=[k + '=' + v for k, v in dict.items()] print(dic) ``` 打印结果：`['a=A', 'b=B', 'c=C']` 4. 使用函数 ``` python arr=[x.upper() for x in "abc"] print(arr) ``` 打印结果：`['A', 'B', 'C']` 获得当前路径，可以用一句代码 ```python import os fs=[d for d in os.listdir('.')] print(fs) ``` 5. 表达式可以赋值给一个变量，实现延迟加载 ``` python g = (2 * x for x in range(10)) print(next(g)) print(next(g)) print(next(g)) print(next(g)) print(next(g))

   打印结果：0,2,4,6,8

   也可以使用循环打印：

   1 2 3

   g = (2 * x for x in range(10)) for x in g: print(x)

函数的定义

python使用def来定义

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

def print_str(x):
    print (x)
```  
调用`print_str("12")`  打印`12`


#### 默认参数
----------------------------

`python`支持默认参数。   

```python
def print_str(x,y="end"):
    print (x,y)
```  

调用`print_str("12")`,不传递y参数  打印`12  end`       
调用`print_str("12","continue")`  打印`12  continue`        

如果是多个默认参数，可以根据参数的名称来指定参数。

``` python
def print_str(x,y="y",z="z"):
    print ("x:",x)
    print ("y:",y)
    print ("z:",z)

当调用print_str(1,2),打印结果：

1
2
3
4
5
6
7
8
9
10

x: 1
y: 2
z: z
```   

当调用`print_str(1,z=2)`,打印结果：  
``` cte
x: 1
y: y
z: 2

使用默认参数需要注意一个问题：默认定义的时候，默认参数值已近计算出来，如果是一个默认参数是一个引用，则会发生改变。

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

def add_dict(arr=[]):
        arr.append("end")
        print (arr)
add_dict()
add_dict()
add_dict()
```  

打印结果如下：   

```cte
['none']
['none', 'none']
['none', 'none', 'none']

所以，如果使用可变的引用变量，则注意这种形式。可以使用None来代替：

1
2
3
4
5
6

def add_dict(arr=None):
    if arr is None:
        arr=[]

    arr.append("end")
    print (arr)

可变参数

在python支持可变的个数的参数，在原来的参数上面增加一个*

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

def print_str(*x):
    print (x)
print_str(1,2,3,4)
```   
打印结果如下：`(1, 2, 3, 4)`   

> 可变参数在函数调用时自动组装为一个tuple   

如果想把一个数组的元素当成默认参数传到方法里面，该如何操作？

``` python
def print_str(*x):
    print (x)

arr=[1,2,3,4]
print_str(arr)

打印结果：([1, 2, 3, 4],)，这个是把arr当成一个list类型的参数传入到方法中，打印出来是一个tuple([],)类型。

所以在python允许list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

def print_str(*x):
    print (x)

arr=[1,2,3,4]
print_str(*arr)
```  
打印结果：`(1, 2, 3, 4)`    

#### 关键字参数
-----------------------------

关键字参数是把默认参数当成一个`dict`的类型，使用方法是`**`,我们定义一个关键字参数：   

``` python
def print_str(x,**arg):
    print (x,arg)
print_str(1)

打印结果是：1 {}

调用print_str(1,a=1,b=2,c=3)，打印结果：1 {'a': 1, 'b': 2, 'c': 3}

同样如果想把一个dict类型的参数传递进来，也需要使用**

1
2
3
4

def print_str(x,**arg):
    print (x,arg)
dic={'a': 1, 'b': 2, 'c': 3}
print_str(1,**dic)

打印结果：1 {'a': 1, 'b': 2, 'c': 3}

注意: dic这个中参数传递是一种拷贝，在函数内部修改不会影响原来的值。

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

def print_str(x,**arg):
    arg["a"]=10
    print (x,arg)
dic={'a': 1, 'b': 2, 'c': 3}
print_str(1,**dic)
print(dic)
```  

打印结果：   

``` cte
1 {'a': 10, 'b': 2, 'c': 3}
{'a': 1, 'b': 2, 'c': 3}

dict类型的使用

在python有一个dict类型，存储格式是key:value的形式，在其他语言有的成为map和Dictionary.

1
2
3

>>> dict={"a":1,"b":3}
>>> dict["a"]
1

由于dict是根据key查询数据，所以查询的效率比list要高出不少。

取值的时候，key如果不存在则会报异常。所以为了更安全的使用dict可以使用前判断下：

1
2

>>> "a" in dict
True

或者可以使用get函数,如果不存在，则返回None数据，也可以指定默认值：

1
2
3
4

>>> dict.get("c")
>>> dict.get("c",1)
1
>>> 

1. dict的key必须是不可变对象
2. dict的内部顺序和存储的先后顺序没有关系
3. 查找和插入的速度极快，不会随着key的增加而变慢
4. 需要占用大量的内存，内存浪费多。

dict可以使用pop方法对数据进行删除：

1
2
3
4

>>> dict.pop("b")
3
>>> dict
{'a': 1}

set类型

set类型与list相似，是一种不会有重复数据的数组：

1
2
3
4
5
6

>>> list=[1,2,1,2,3,3,4,5,1,1,1,1,5,6]
>>> list
[1, 2, 1, 2, 3, 3, 4, 5, 1, 1, 1, 1, 5, 6]
>>> set(list)
{1, 2, 3, 4, 5, 6}
>>> 

set可以使用add()方法增加数据，如果增加重复数据，但不会有效果。

1
2
3
4
5
6
7
8
9
10

>>> list=[1,2,1,2,3,3,4,5,1,1,1,1,5,6]
>>> aset=set(list)
>>> aset
{1, 2, 3, 4, 5, 6}
>>> aset.add(7)
>>> aset
{1, 2, 3, 4, 5, 6, 7}
>>> aset.add(7)
>>> aset
{1, 2, 3, 4, 5, 6, 7}

使用remove移除数据：

1
2
3

>>> aset.remove(1)
>>> aset
{2, 3, 4, 5, 6, 7}

set可以看成数学中的集合，可以进行交集和并集的计算：

1
2
3
4
5
6
7

>>> a=set([1,2,3,4,5])
>>> b=set([4,5,6,7,8])
>>> a&b
{4, 5}
>>> a|b
{1, 2, 3, 4, 5, 6, 7, 8}
>>> 

今天学习了python的list和tuple的使用，python中的数组类型的结构比其他语言更为灵活，下面我们说说他们的用法：

list使用

1. 定义一个list

   1 2 3

   >>> arr=[1,2,3,4,5,6] >>> arr [1, 2, 3, 4, 5, 6]

   arr就是定义的数组，使用索引来获得数组里面的数据如：arr[0],arr[1]等等，在python数组有一个特殊的用法，使用-1，-2可以取倒数第一或第二的值。

   1 2 3 4

   >>> arr[0] 1 >>> arr[-1] 6

   如果超出界限，会抛出异常：

   1 2 3

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

   由于python是弱类型的语言，所以数组里面可以存储不同类型的数据：

   1 2 3

   >>> arr=[1,2,"hello",[1,2,34]] >>> arr [1, 2, 'hello', [1, 2, 34]]

   如果想拿到34这个值，可以类似二维数组那样arr[3][2]

   可以使用range函数快速定义个有序的数组：

   1 2 3

   >>> list(range(10)) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>>

   range的具体的使用方法range(start, stop[, step])。
   range(1,10,2)代表的从1-10每次长度的2

2. 数组的相关的函数

   • len 获得数组的长度

     1 2	>>> len(arr) 4

   • append 增加一个元素

     1 2 3 4

     >>> arr.append("1111") >>> arr [1, 2, 'hello', [1, 2, 34], '1111'] >>>

   • insert插入数据

     1 2 3

     >>> arr.insert(1,213) >>> arr [1, 213, 2, 'hello', [1, 2, 34], '1111']

     insert(1,213)代表在1位置，插入一个213的数字

   • pop删除元素

     pop是python中删除元素的方法，arr.pop()默认删除最后一个元素，arr.pop(i)代表可以删除指定位置的元素：

     1 2 3 4 5

     >>> arr.pop() '1111' >>> arr [1, 213, 2, 'hello', [1, 2, 34]] >>>

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

     >>> arr.pop(1) 213 >>> arr [1, 2, 'hello', [1, 2, 34]] ``` #### tuple的使用 `tuple`是一个有序的数组，和`list`类似，`tuple`的特点是定义后不能在被修改，这样可以让代码中的数据更加安全。 定义`tuple`使用`()`，例如定义一个`tuple`如下： ```python >>> tup=(1,2,3) >>> tup (1, 2, 3)

由于tuple不可修改，所以不能使用append,insert等修改元祖的方法。

如果定义一个只有一个元素的tuple:

1
2
3

>>> tup=(1)
>>> tup
1

这样我们发现，tup不是一个元祖，而是一个数字。原来是只用一个元素的时候，tuple中的()与数学运算中的括号冲突了，所以当定义只有一个元素的tuple的时候，需要在最后加一个,,方法如下：

1
2
3

>>> tup=(1,)
>>> tup
(1,)

如果在tuple中定义一个数组，如果改变数组的值，tuple中的值也会发生改变：

1
2
3
4
5

>>> tup=(1,[1,2])
>>> tup[1][0]="a"
>>> tup[1][1]="b"
>>> tup
(1, ['a', 'b'])