python学习第三篇 列表 元组

continue语句

作用:

     用于循环语句(while,

for)中，不再执行本次循环内cont inue之后的语句，重新开始次 新的循环。            

说明:

1、在while语句中执行continue语句，将会直接跳转到while语句的真值表达式处重新开始次判断循环条件

2、.在for语句中执行continue语句，将会从可迭代对象中取下一个数据绑定变量后再次进行循环

 

列表

   定义：

       列表是一种容器

       列表是可以被改变的序列容器

       列表是由一系列元素组成的，元素与元素之间可能没有任何关联关系，但他们之间会先后顺序关系。

   列表的创建：

       L= []

   列表的构造函数

       list()

       list(iterable)

注意：

   在Python3中range()函数返回的是一个可迭代对象（类型是对象），而不是列表类型，所以打印的时候不会打印成列表

   在Python3中list（）函数是对象迭代器，可以把range()返回的可迭代对象转为一个列表，

返回的变量类型为列表

   但在Python2中range()函数返回的是列表

1.算术运算符

       +

+=  *  *=

       1.+ 加号用于拼接列表

       2. += 用于原列表与右侧可迭代对象进行拼接，用于绑定列表

           列表+=列表

       3.*

生成重复列表

       4.*= 生成重复列表对原来的列表进行赋值

   2.比较运算符

       运算符： < <=

>  >= == !=

       说明

           列表的比较规则与字符串的比较规则相同

           列表要求每两个元素能依次进行比较，否则会出现类型错误

   列表的索引操作

       1.索引取值

           语法：

               x=列表[整书表达式]

           用法:

               等同于字符串的索引(同样分为正向索引和反向索引

       2、索引赋值

           列表是可变的序列，可以通过索引赋值改变列表中的元素

           语法:

           列表[整数表达式] =表达式

       3.列表的切片操作

           1、切片取值

               列表[起始索引:终止索引:步长]

               列表的切片取值是从原来列表中取出想要的元素再次组成一个 新的列表

           2、*切片赋值操作

           作用:

               可以改变原列表的排列，可以插入和修改数据语法:

               列表[切片] =可迭代对象

           说明:

               切片赋值的赋值运算符(=)的右侧必须是” 个可选代对象

           注意事项：

               对于步长不等于1的切片赋值，赋值运算符的右侧的可选代对象提供的元素的个数，定 要等于切片切出的段数

       列表推导式的嵌体

           语法;

               [表达式for变量1]

           [列表的+=运算表达式for 变量1 in可迭代对象1 if真值表达式1

               for变量2 in可迭代对象2 if真值表达式2]

           列表推导式

               列表推导式是用可迭代对象创建列表表达式

           作用:

               创建列表语法:

               [表达式for变量in可迭代对象]

               [表达式for变量in可迭代对象if真值表达式]

       del语句

           可以用于删除列表中的元素

           语法:

               del 列表[整数表达式]

               del 列表[切片]

       练习:

           已经有列表:

               L= [3,5]

           用索引和切片操作，将原列表改变为:

               L =[1,2,3,4,5, 6]

           将列表反转，结果如下:

               L =[6,5,4,3,2, 1]

           然后删除最后一一个元素，结果如下:

               L =[6,5,4,3,2]

           python3 常用的序列函数

           lex（x） 返回序列的长度

           max（x）返回序列的最大值

           min（x）返回序列的最小值

           sum（x）返回序列的所有元素的和

           any（x）真值测试，如果列表中有一个值为真值择返回True

l=[3,5]
l[:0]=[1,2]
l[4:]=[6]
l[3:3]=[4]
print(l)
a=list(reversed(l))
l[:]=l[::-1]
print(l)
print(a)
b=a
del b[5]
print(b)

 

           

     练习：

           写程序，让用户输入很多个正整数，当输入负数时结束输入，将用户输入的数字存储于列表中

1.  打印存有数字的列表

2. 求出这些数字中的平均值

3. 求出这个数字的最大数

如：

   请输入：1

   请输入：2

   请输入：99

   请输入：100

   请输入：-1

   打印如下：

       列表是：[1,3,99,100]

       平均值是：50.5

       最大值是：100

a=1
l=[]
n=0
while a==1:
    b = int(input("请输入正整数"))
    if b>0 :
        l[n:n]=[b]
        n+=1
    else:
        break
print(l)
avg=sum(l)/n
print("平均值：",avg)
max=max(l)
print("最大值：",max)

 

列表中常用的方法：

1. List.append(obj) 在列表的末尾添加新的对象

参数：obj -添加到列表的末尾

返回值：没有返回值，修改了原来的列表

2. list.exten(seq)  在列表的末尾一次性追加另一序列中的多个值（用新列表扩展到原来的列表）

       参数：seq – 元素列表

       返回值： 没有返回值，但会在已存在的列表中添加新的列表内容

3. list.ount(obj) 用于统计某个元素在列表中出现的次数

参数：obj - 列表中统计的对象

返回值： 返回元素在列表中出现的次数

4. lise.index(obj) 从列表中找的某个值第一个匹配项的索引位置

5. list.inset(index,obj) 将对象插入列表

参数：index – 对象obj需要插入的索引位置

             Obj - 要插入列表中的对象返回值:

       该方法没有返回值，但会在列表指定的位置插入对象

6. list. pop(index = 1)移除列表中的一个元 素(默认最后一个元素)，并返回该元素的值

参数:obj - 可选参数，要移除列表元素的素引值，不能超过列表总长度，默认为index = -1

       删除最后一个元素返回值:

       该方法返回重列表中移除的元素对象    

7. list. remove (ob5)移除列表中的某个值的第一个匹配项

       参数:

           Obj - 列表中要移除的对象返回值:

           该方法没有返回值但是会移除列表中的某个值的第一个匹配项

 

8. list. reverse()

       参数: Nall

           反向列表中的元素

       返回值:

           该方法没有返回值，但是会对列表的元素进行反向排序

9. list. sort(cmp= None, reverse = False)对原列表进行排序

       参数:

           Cmp - 可选参数，如果指定了该参数会使用该参数的方法进行排序

           reverse  排序规则，Ireverse= True降序，  reverse

False升序

       返回值:

           该方法没有返回值，但是会队列表的对象进行排列

列表操作的综合练习

   编写一个名字管理系统：

       功能要求：

1. 添加一个新的名字

2. 删除一个名字

3. 修改一个名字

4. 查询一个名字

5. 退出系统

列表与字符串比较：

1. 列表和字符串都是序列，元素之间有先后的顺序关系

2. 字符串是不可改变的序列，列表是可变的序列

3. 字符串的每个元素只能存储字符，而列表可以存储任意类型的元素

4. 列表和字符串都是可迭代对象

 

元组

1. 定义：

元组是不可变的序列，同列表一样，元组是可以存储任意类型的数据的容器

2. 元组的表示方式

用小括号（）括起来，单个元素括起来后加逗号（，）区分单个对象还是元组

3. 创建空元组的字面值

t=() #创建一个空元组用t绑定

4. 创建非空元组的字面值

示例：

    tl=()

              print(type(t1))

           t2=200,

              print (type(t2))

            t3(20,)

            print(type(t3)

            t5=100,

200, 300

            print

(type(t5))

            #错误的案例

           t4 = (20) 绑定整数20，不是元组

            print

(type(t4))

            x,y,z-(100,

200,300) #序列赋值

            print

(type(x), type(y), type(z))

 

5.    元组的构造函数tuple

      tuple()

生成一个空数组，等同于()

      tuple(iterable)

用可迭代对象生成一个新的元组

6.    元组的运算，比较运算，索引和切片与列表完全相同

注：

       元组不支持索引赋值和切片赋值