4、列表和循环语句

作者: 甜西瓜不太甜 | 来源:发表于2018-03-19 19:31 被阅读27次

Lesson_4

【1】布尔值

布尔类型是特殊的整形，尽管布尔类型用True和False来表示‘真’和‘假’，但是布尔型可以当做整数来对待，这个型内容我们在前面已经体现过了，True相当于整形值1，False相当于整形值0：

print(True + True)  #2
print(True * False) #0

【2】空值

空值None，它是python里的一个特殊的值。None不能理解为0，因为0是有意思的，而None是一个特殊值。


n = None
print(n)


>>>None

【3】list(列表)

有的时候需要把一堆东西暂时储存起来，因为它们的某种直接或间接的关系，需要把他们放在一组或者一个集合中，因为将来可能用的上。很多接触过程序的人都知道数组，数组是把一大堆同种类型的数据挨个放一块儿，然后通过下标去寻找。由于python的变量没有数据类型，也就是说python是没有数组的，所以python加入了更加强大的列表。

python列表有多强大了？如果说数组比作是集装箱，那么python的列表就是仓库。

先看一个例子：


age1 = 18
age2 = 19
age3 = 20
age4 = 21
age5 = 22
print((age1 + age2 + age3 + age4 + age5) / 5)   #20.0

这样一次就声明了5个变量，写起来还非常的麻烦，那么我们用列表来试试：


list2 = [18, 19, 20, 21, 22]
print(sum(list2)/len(list2))   #20.0

使用列表以后代码变得非常的简洁.

创建列表

创建列表和创建普通变量一样，只是把数据用中括号括起来就可以了，数据之间用逗号隔开。

先创建一个空的列表；

list1 =[]

print(list1,'----------',type(list1))

再创建一个带有元素的列表：


list2 = [18, 19, 20, 21, 22]

print(list2)

访问列表中的元素

我们访问元素中的单个值，可以通过元素的索引值（index）

<font color='red'>注意，列表的索引值是从零开始的：</font>

name = ['鸡蛋','鸭蛋','鹅蛋','傻蛋']

print(name[0])
print(name[3])


>>>鸡蛋
>>>傻蛋

我们看到上面的列表一面一共只有4个元素，那么索引值就是0、1、2、3，
如果输入name[4]的话，那就超出范围了，会报错：

name = ['鸡蛋','鸭蛋','鹅蛋','傻蛋']

print(name[4])

>>>IndexError: list index out of range

有的时候，list可能会非常的长，我们不可能去数它，在计算索引值啊，那怎么办了？

现在我要找这个列表中间的元素

name = ['鸡蛋','鸭蛋','鹅蛋','傻蛋','李狗蛋']

print(name[int(len(name)/2)])

>>> 鹅蛋

列表的组合

列表的组合其实和字符串拼接是一样的，都是使用+号相连接。

name = ['鸡蛋','鸭蛋','鹅蛋','傻蛋','鱼蛋']

nameto = ['鸵鸟蛋','恐龙蛋','鳄鱼蛋','王八蛋','李狗蛋']

print(nameto + name )

>>>['鸵鸟蛋', '恐龙蛋', '鳄鱼蛋', '王八蛋', '李狗蛋', '鸡蛋', '鸭蛋', '鹅蛋', '傻蛋', '鱼蛋']


#合并的时候那个数组在前面，那个数组的索引的值就偏小

列表的重复

列表的重复和字符串是一样的，使用 *


name = ['鸡蛋','鸭蛋','鹅蛋','傻蛋','鱼蛋']
print(name * 3 )

>>>['鸡蛋', '鸭蛋', '鹅蛋', '傻蛋', '鱼蛋', '鸡蛋', '鸭蛋', '鹅蛋', '傻蛋', '鱼蛋', '鸡蛋', '鸭蛋', '鹅蛋', '傻蛋', '鱼蛋']

判断元素是不是这个列表中的

我们学过in 和 not in ，返回布尔值


name = ['鸡蛋','鸭蛋','鹅蛋','傻蛋','鱼蛋']

print('驴蛋' in name)
print('驴蛋' not in name)

>>>False
>>>True

列表的分片

依然和字符串一样


name = ['鸡蛋','鸭蛋','鹅蛋','傻蛋','鱼蛋']

print(name[:2])   #从0开始取2个
print(name[::2])  #从0开始，每两个取一次
print(name[::-1])  #返回翻转


>>>['鸡蛋', '鸭蛋']
>>>['鸡蛋', '鹅蛋', '鱼蛋']
>>>['鱼蛋', '傻蛋', '鹅蛋', '鸭蛋', '鸡蛋']

二维列表

什么是二维列表，就是列表的元素也是列表


list1 = [[1,2,3],[4,5,6],[7,8,9]]
print(list1)

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

二维列表获取元素是一样的：


list1 = [[1,2,3],[4,5,6],[7,8,9]]
print(list1[1][2])  #6
print(list1[0][1])  #2
print(list1[2][0])  #7

在列表中末尾添加新的元素

list1 = [1,2,3,4,5]
list1.append(6)
list1.append([7,8,9])
print(list1)

#添加的是列表，那么这个元素也是列表

>>>[1, 2, 3, 4, 5, 6, [7, 8, 9]]

在末尾一次性追加另一个列表中的多个值


list1 = [1,2,3,4,5]
list1.extend([6,7,8])
print(list1)

>>>[1, 2, 3, 4, 5, 6, 7, 8]

#extend()插入的只能是list类型的

在指定下标处添加一个元素，不覆盖原数据，原数据向后顺延

list1 = [1,2,3,4,5]
list1.insert(2, 100)
list1.insert(2, [200,300])
print(list1)

>>>[1, 2, [200, 300], 100, 3, 4, 5]

弹出(移除)列表中指定下标处的元素（默认移除最后一个元素）,并返回删除的数据


list1 = [1,2,3,4,5]
list1.pop()  #不写索引的话默认弹出最后一个元素
#写就是等于是list1.pop(-1)
list1.pop(2)
print(list1.pop(1))
print(list1)


>>>2
>>>[1, 4]

修改指定的值

修改list只需要通过索引重新复制就可以了


list1 = [1,2,3,4,5]
list1[0] = 0
list1[-1] = [1,2,3]
print(list1)


#[0, 2, 3, 4, [1, 2, 3]]

移除列表中的某个元素第一个匹配的结果

remove()在不知道值的下表情况下使用。

list1 = [1,2,3,4,5,4,5,4]
list1.remove(4) #删除第一个4
print(list1)

>>>[1, 2, 3, 5, 4, 5, 4]

删除所有指定的重复值

list1 = [1,2,3,4,5,4,5,4]

while 4 in list1:
    list1.remove(4)
print(list1)

>>>[1, 2, 3, 5, 5]

获取列表值得下标(索引)

index() 函数用于从列表中找出某个值第一个匹配项的索引位置。

该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。

list1 = [1,2,3,4,5,4,5,4]
print(list1.index(3))

>>>2   #返回3的索引是2

index还有两个参数：

index(需要查找的值,start,stop)

list1 = [1,2,3,4,5,4,5,4]

one = list1.index(4)   #这是第一个四的位置

end = len(list1)    #这是list1的含有元素长度,代表结束的位置，list1里面没有下表为8的地方那么默认不会去查找

start_two = one + 1        #第一个4的下表为'3'，那么+1以后就不会从下表为3的位置开始找

two = list1.index(4,start_two,end) #获取第二个two的下标值，把值赋给变量two

start_three = two + 1   #代表第三次查找的开始位置

three = list1.index(4,start_three,end)

print(one,two,three)


>>>3 5 7

语句删除del

注意del 不是list的一个方法，所以后面不用加小括号，它的删除方式和pop有些类似，不过del 必须指定下标,如果不加索引，那就是删除整个列表。

list1 = [1,2,3,4,5,4,5,4]
del list1[0]
del list1[-1]
print(list1)

>>>[2, 3, 4, 5, 4, 5]

清楚列表中的所有数据

del list

list1 = [1,2,3,4,5,4,5,4]
del list1

print(list1)
>>>[]

clear()

list1 = [1,2,3,4,5,4,5,4]
list1.clear()

print(list1)

>>>[]

计算指定值在列表中出现的次数

list1 = [1,2,3,4,5,4,5,4]

print(list1.count(4))

>>>3

获取列表中元素的个数

list1 = [1,2,3,4,5,4,5,4]

print(len(list1))

>>>8

列表的的最大值、最小值、列表中数字的总和


list1 = [1,2,3,4,5,4,5,4]

print(max(list1),min(list1))
print(sum(list1))

>>>5 1
>>>28

翻转列表

我们原来说过list[：：-1]的方法可以返回翻转列表的结果，但是默认是不影响列表的原来的值。

list1 = [1,2,3,4,5,4,5,4]

print(list1[::-1])

print(list1)


#[4, 5, 4, 5, 4, 3, 2, 1]
#[1, 2, 3, 4, 5, 4, 5, 4]  并没有被影响

list.reverse(),它也是翻转列表，但是它影响原来的结果：

list1 = [1,2,3,4,5,4,5,4]

list1.reverse()

print(list1)

#[4, 5, 4, 5, 4, 3, 2, 1]

列表的排序

list.sort(func,key,reverse)

func和key参数用于设置排序得到方法和关键字，默认使用的是归并排序，reverse的默认值是False，也就是正序排列。

正序：

list1 = [1,2,3,4,5,4,5,4]

list1.sort()  #没有写默认是从小到大

print(list1)

>>>[1, 2, 3, 4, 4, 4, 5, 5]

倒序：

list1 = [1,2,3,4,5,4,5,4]

list1.sort(reverse=True)  #指定了reverse=True就是倒叙排列

print(list1)

>>>[5, 5, 4, 4, 4, 3, 2, 1]

模拟倒序：


list1 = [1,2,3,4,5,4,5,4]

list1.sort()

list1.reverse()

print(list1)

>>>[5, 5, 4, 4, 4, 3, 2, 1]

关于分片“拷贝”概念深拷贝和浅拷贝


list1 = [1,3,2,9,7,8]

list2 = list1[:]  #分片拷贝的并没有受到影响，深拷贝，它在内存中的地址与list1不一样

list3 = list1     #浅拷贝

list4 = list1.copy()  #深拷贝，它在内存中的地址与list1不一样，深拷贝也不会受到影响

list1.sort()

print('list1：',list1,id(list1))
print('list2：',list2,id(list2))
print('list3：',list3,id(list3))
print('list4：',list4,id(list4))

#list1： [1, 2, 3, 7, 8, 9] 4323685000
#list2： [1, 3, 2, 9, 7, 8] 4323686152
#list3： [1, 2, 3, 7, 8, 9] 4323685000
#list4： [1, 3, 2, 9, 7, 8] 4323686536

分片拷贝了就是把原先的list表的值复制到一个新的地址上，所以原来的list发生改变都不会影响到。

将其它类型转换成list


tu = (1,2,3)

list1 = list(tu)

print(tu,type(tu))
print(list1,type(list1))


#(1, 2, 3) <class 'tuple'>
#[1, 2, 3] <class 'list'>

第八章

【1】条件控制语句

if-elif-else

我们在没有学习这一章节之前只有if-else，那么这样可能会写衡多的if语句，我们看一个例子。


#现在做一个100分制的成绩评价，90分以上为A，80-90为B，70-80为C，60-70为D，60以下为E

score = int(input('请输入0到100之间成绩：'))



if 100 >= score >=90:
    print('A')
if 90 >= score >=80:
    print("B")
if 80 >= score >=70:
    print('C')
if 70 >= score >= 60:
    print('D')
if 60 >= score >= 0:
    print("E")
if score > 100 or score < 0:
    print('输入错误，输入0到100之间成绩')
    
#这样的话需要很多的if

但是你也可以这样去写：


score = int(input('请输入0到100之间成绩：'))

if 100 >= score >= 90:
    print('A')
else:
    if 90 >= score >= 80:
        print("B")
    else:
        if 80 >= score >= 70:
            print('C')
        else:
            if 70 >= score >= 60:
                print('D')
            else:
                if 60 >= score >= 0:
                    print("E")
                else:
                    if score > 100 or score < 0:
                        print('输入错误，输入0到100之间成绩')

其实我们可以用一个if去搞定：


score = int(input('请输入0到100之间成绩：'))

if 100 >= score >=90:
    print('A')
elif 90 >= score >=80:
    print("B")
elif 80 >= score >=70:
    print('C')
elif 70 >= score >= 60:
    print('D')
elif 60 >= score >= 0:
    print("E")
else:
    print('输入错误，输入0到100之间成绩')

<font color='red'>注意：elif后面是没有冒号的</font>

这三个是个很简单的例子，但是这里面有一个问题，假设我们第一次输入100,第一种写法会打印除一个A，然后继续向后面的2，3，4，5一次判断，然后条件都不符合，退出程序。

如果现在我们使用第二种或第三种，在第一次判断的时候就会打印出A，而后面的程序将不再执行，直接退出。

假设每一次判读都会耗费一次CPU的时间，那么第一种写法比第二种和第三种要多耗费400%的时间，要成为一个优秀的程序员，必须要养成一个良好的思维逻辑。而python可以锻炼你这方面的能力。

【2】python可以有效避免“悬挂else”（了解）

什么是“悬挂else”？

举个例子，初学C的人很容易被一下代码欺骗：

    
    if(a >0)
        if(a > 10)
            print('这真的很大！！！')
    else
        print('你个辣鸡！！')

这个例子里面，else和if都是最外层的，我们在python里面能看出来它是术语最外面一层if的，但是在C语言里面，有个就近原则，那么它就是里面一层if的。

这样一不小心就会导致错误，这就是著名的‘悬挂else’，但是在python里，它是不可能出现的。python只有保证缩进整齐就可以决定else是谁的

【3】不同的if-else（条件表达式或三元运算符）

我们说多少元操作符取决于它有多少个操作数。例如赋值a = 2它是二元操作符，因为它左右各有一个操作数，那么-1它就是一个医院操作符。

想必大家都已经才出来三元操作符了吧。

通过三元运算符你可以简单的完成下面的判断：

a = 1

b = 2

if a<b:
    print('a<b')
else:
    print('a>b')

使用三元运算符：


a = 1

b = 2

c = 'a<b' if a<b else 'a>b'
print(c)


#条件成立执行了左边，左边是if的代码体
#条件不成立执行右边，右边是else的代码体

【4】断言、断点

断言

断言(assert)的语法就像是if条件分支的‘近亲’。

当这个关键字的条件为False的时候，程序会抛出AssertionError这样的异常。

在设么情况下会使用assert了？在我们测试的时候,与其让错误的条件继续运行，不让直接让它毁灭。

我们看下面的例子：

条件为False的结果：


a = 1

b = 2
assert a > b
if a<b:
    print('a<b')
else:
    print('a>b')
    
    
>>>AssertionError

条件为True的结果：


a = 1

b = 2
assert a < b  #结果为真，什么都不会发生
if a<b:
    print('a<b')
else:
    print('a>b')
    
    
>>>a<b

【5】while循环语句

python的while循环和if的条件分支类似，在条件为真的情况下，执行一段代码，不同的是，while循环会一直重复执行那段代码，把这段代码称为循环体。

while 条件啊：
循环体


a = 0;
while  a < 10：
    print(a)
    a += 1

这是一个死循环


while True:
    print(123)

【6】for循环语句

for循环是python的计数器循环，虽然说python是由C语言编写的，但是它的for循环和C语言的for循环不太一样，python的for循环显得更为智能和强大！这主要表现在它会自动调用迭代器 next()，会自动捕获StopIteration异常并结束循环。

string = '1000phone'
for each in string:
    print(each,end='-')

>>>e-a-c-h-

【7】range()、enumerate()

range()

range()我们在前面的几章里面已经见识过了。其实它是for最好的小伙伴。

range(start，stop, scan)

start:计数从start开始。默认是从0开始。例如range（5）等价于range（0， 5）;

end:技术到end结束，但不包括end.例如：range（0， 5）是[0, 1, 2, 3, 4]没有5

scan：每次跳跃的间距，默认为1。例如：range（0， 5）等价于 range(0, 5, 1)


for i in range(0,101,10):
    print(i)

enumerate()

enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

语法：enumerate(sequence, [start=0])

sequence -- 一个序列、迭代器或其他支持迭代对象。
start -- 下标起始位置。

list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1):
    print index, item


>>>0 这
>>>1 是
>>>2 一个
>>>3 测试

使用enumerate()生成键值对元祖


list1 = ["这", "是", "一个", "测试"]

print(list(enumerate(list1)))

>>>[(0, '这'), (1, '是'), (2, '一个'), (3, '测试')]

for循环的魅力不止这一点，还有其它的各式各样的搭档帮助实现各种乱七八糟的功能，后面在讲解元祖的时候在介绍给大家

【8】break、continue

break 语句的作用是终止当前循环，并且跳出循环体。


bingo = '我最帅'
answer = input('请输入我最想听的一句话:')

while True:
    if bingo == answer:
        break
    answer = input('答对了才能出去：')
print('哎哟，不错哦~')

continue 语句的作用是终止本轮循环并直接开始下一轮循环

for i in range(10):
    if i % 2 != 0:
        print('')
        continue
    i += 2
    print(i)

海龟制图

python2.6版本中后引入的一个简单的绘图工具，叫做海龟绘图(Turtle Graphics),turtle库是python的内部库,使用导入即可 import turtle

先说明一下turtle绘图的基础知识:

1、画布(canvas)

画布就是turtle为我们展开用于绘图区域, 我们可以设置它的大小和初始位置

screensize()

设置画布大小:
turtle.screensize(canvwidth=None, canvheight=None, bg=None)
参数分别为画布的宽(单位像素), 高, 背景颜色

例如：

turtle.screensize(800, 600, "green")
turtle.screensize() #返回默认大小(400, 300)

setup()

turtle.setup(width=0.5, height=0.75, startx=None, starty=None)

参数:
width, height: 输入宽和高为整数时, 表示像素; 为小数时, 表示占据电脑屏幕的比例
(startx, starty): 这一坐标表示矩形窗口左上角顶点的位置, 如果为空,则窗口位于屏幕中心

例如：

turtle.setup(width=0.6, height=0.6)
turtle.setup(width=800, height=800, startx=100, starty=100)

2. 画笔

画笔的状态

在画布上,默认有一个坐标原点为画布中心的坐标轴, 坐标原点上有一只面朝x轴正方向小乌龟. 这里我们描述小乌龟时使用了两个词语:坐标原点(位置),面朝x轴正方向(方向), turtle绘图中, 就是使用位置方向描述小乌龟(画笔)的状态

画笔的属性

画笔(画笔的属性，颜色、画线的宽度)

turtle.pensize()：设置画笔的宽度；
turtle.pencolor(); 没有参数传入,返回当前画笔颜色,传入参数设置画笔颜色,可以是字符串如"green", "red",也可以是RGB 3元组,

例如：

import turtle as t
t.pencolor('brown')
tup = (0.2, 0.8, 0.55)
t.pencolor(tup)

turtle.speed(speed): 设置画笔移动速度,画笔绘制的速度范围[0,10]整数, 数字越大越快

绘图命令

操纵海龟绘图有着许多的命令,这些命令可以划分为3种:一种为运动命令，一种为画笔控制命令,还有一种是全局控制命令

(1)画笔运动命令:

命令	说明
turtle.forward(distance)	向当前画笔方向移动distance像素长
turtle.backward(distance)	向当前画笔相反方向移动distance像素长度
turtle.right(degree)	顺时针移动degree°
turtle.left(degree)	逆时针移动degree°
turtle.pendown()	移动时绘制图形,缺省时也会绘制
turtle.goto(x,y)	将画笔移动到坐标为x,y的位置
turtle.penup()	移动时不绘制图形,提起笔，用于另起一个地方绘制时用
turtle.speed(speed)	画笔绘制的速度范围[0,10]整数
turtle.circle()	画圆,半径为正(负),表示圆心在画笔的左边(右边)画圆

(2)画笔控制命令:

命令	说明
turtle.pensize(width)	绘制图形时的宽度
turtle.pencolor()	画笔颜色
turtle.fillcolor(colorstring)	绘制图形的填充颜色
turtle.color(color1, color2)	同时设置pencolor=color1, fillcolor=color2
turtle.filling()	返回当前是否在填充状态
turtle.begin_fill()	准备开始填充图形
turtle.end_fill()	填充完成；
turtle.hideturtle()	隐藏箭头显示；
turtle.showturtle()	与hideturtle()函数对应，显示

(3) 全局控制命令

命令	说明
turtle.clear()	清空turtle窗口，但是turtle的位置和状态不会改变
turtle.reset()	清空窗口，重置turtle状态为起始状态
turtle.undo()	撤销上一个turtle动作
turtle.isvisible()	返回当前turtle是否可见
stamp()	复制当前图形
turtle.write(s[,font=("font-name",font_size,"font_type")])	写文本，s为文本内容，font是字体的参数，里面分别为字体名称，大小和类型；font为可选项, font的参数也是可选项

3. 命令详解

turtle.circle(radius, extent=None, steps=None)
描述: 以给定半径画圆
参数:

radius(半径); 半径为正(负),表示圆心在画笔的左边(右边)画圆
extent(弧度) (optional);
steps (optional) (做半径为radius的圆的内切正多边形,多边形边数为steps)

举例:

circle(50) # 整圆;
circle(50,steps=3) # 三角形;
circle(120, 180) # 半圆

4. 绘图举例

画一个太阳花

import turtle as t
import turtle as t
t.color("red", "yellow")
t.speed(10)
t.begin_fill()
for _ in range(50):
    t.forward(200)
    t.left(170)
t.end_fill()
t.done()

五角星


import turtle
import time

turtle.pensize(5)
turtle.pencolor("yellow")
turtle.fillcolor("red")

turtle.begin_fill()
for _ in range(5):
    turtle.forward(200)
    turtle.right(144)
turtle.end_fill()
time.sleep(1)

turtle.penup()
turtle.goto(70, -50)
turtle.color("black")
turtle.write("千锋", font=('Arial', 30, 'normal'))
turtle.done()

4、 列表和循环语句