Python学习日记（三）

1.分支结构
经典if…else…，注意缩进和冒号

age = int(input("输入年龄："))
if age>18:
    print("成年人")
else:
    print("小孩")

mylist = [1,3,5,7,9]
data = int(input('输入要删除的数据：'))
if data in mylist:
    mylist.remove(data)
else:
    pass
print(mylist)

还多了个elif

score = float(input('请输入成绩'))
if score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
elif score >= 70:
    grade = 'C'
elif score >= 60:
    grade = 'D'
else:
    grade = 'E'
print('成绩为',score,'对应的等级是：',grade)

2.循环结构
2.1经典while循环

import random

answer = random.randint(1,100)
counter = 0
while True:
    counter += 1
    number = eval(input('请输入')) #eval，去掉外面的引号
    if number < answer:
        print('大一点')
    elif number > answer:
        print('小一点')
    else:
        print('猜对了')
        break
print("一共猜了%d次"%counter)
if counter>7:
    print('得多练练')

经典计算平均分：

marks = []
data = input("请输入数字（q退出）：")
while data != "q":
    marks.append(int(data))
    data = input("请输入数字（q退出）：")
print(sum(marks)/len(marks))

2.2 for …in…循环

for  变量  in字符串、范围、列表等可迭代对象:
    代码块

range函数：内置函数

# 从0到7（不包含7）
for k in range(7):
    print(k)

# 从1输出到10
for i in range(1,11):
    print(i)

# 从1到15，间隔3
for j in range(1,15,3):
    print(j)

经典杨辉三角：

N = [1]
for i in range(num):  
    print("t".join('%s'%id for id in N),end='tn')
    N.append(0)
    N = [N[k] + N[k-1] for k in range(i+2)]

遍历列表：

marks = [75,88,69,92,85,97,56]
for i in marks:
    print(i)
for index in range(len(marks)):
    if marks[index] >= 80:
        print("第%d位学生成绩大于80" %(index+1))

内置函数enumerate( )：

• enumerate( )将个可遍历的数据对象(如列表 元组或字符申)组合为一个索引序列，同时列出数据和数据下标
• enumerate(sequence, [start=0)

basket = [ 'orange','apple','pear','banana']
for i, v in enumerate( basket):
    print(i,v)

内置函数zip( )：

• 同时遍历两个及以上列表时，可以通过zip函数
• zip( )函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组， 然后返回由这些元组组成的列表。

questions = [ 'name', 'sex', 'favorite color']
answers = ['zrx','female', 'blue']
zipped = zip( questions, answers)
print(type(zipped))
for q,a in zip( questions, answers):
    print(q,a)

遍历字典中的键与值：

dict3={"广东":"广州","河南":"郑州","广西":"南宁","河北":"石家庄"}
for k,v in dict3. items( ): #items方法返回键和值，输出两个变量的值
    print(k,v)

for item in dict3.items(): #items方法返回键和值。封装为元组，保存在变量item中
    print(item)

for key in dict3: #判定键是否在字典中，通过键访问值，输出键和值
    print(key, dict3[key])

如果希望能够按照顺序输出，可以对字典进行排序(按照键进行的排序)：

portdict ={"http" : 80, "https" :443,"ftp" :21,"ssh":22}
for key in sorted(portdict):
    print(key, portdict[key])

continue和break：应该都会用吧

3.列表生成式
列表生成式List Comprehensions是python内賈的强大功能，用来生成列表
语法格式：[表达式 for 循环计数器 in 可迭代对象]

• 表达式是要生成的元素
• 循环计数器是记录循环次数的变量
• 可迭代对象
• 如果for循环还有条件判定，可以在后面添加if条件判定

列表生成式与普通for循环的区别

• 列表生成式没有循环体，不需要冒号
• 列表生成式的for关键字前面定义一 个表达式，这个表达式通常会包含循环计数器

举例生成列表[ 11,22,… .1010]：*

L1 = [x*x for x in range(1, 11)]
print(L1)
L2 = [x*x for x in range(1,11) if x%2 == 1]
print(L2)

将列表中的大写字母变成小写：

blist = [ 'Python', 'Java' ,'Perl','Golang']
L = [x.lower() for x in blist]
print(L)

zip( )函数将两个列表压缩成个zip可迭代对象：

# 通过个循环遍历两个列表
alist = [1,2,3]
blist = ['Python', 'Java' ,'PerL' ,'Golang']
L = [x for x in zip(alist, blist)]
print(L)

列表推导式也可以嵌套：

alist = [1,2,3]
Z =[x+1 for x in [pow(x,2) for x in alist]]
print(Z)

4.生成器

• 通过列表生成式，我们可以直接创建一个列表。
• 如果希望生成大量可迭代对象，最好不用列表生成式，因为它会立即实例化一个对象占用内存空间。但由于
  计算机内存有限，当生成一个列表时，由于受到计算机内存容量的限制，我们需要使用合理的方法生成列表。
• 再例如，对于一个包含百万数目的列表，无法直接创建该列表。如果该列表元素可以按照某种算法推算出来，
  那我们是否可以在循环的过程中不断推算出后续的元素呢?答案是肯定的，而这样做的好处是不必创建完整的
  list,可以节省大量的空间。
• 在Python中，这种一边循环一边计算的机制，称为生成器(generator) .
• 与列表生成式相比，列表生成式的是 [ ] ，生成器的是 ( )

L = [x*x for x in range(1,11)]
print(type(L))
print(L)
g = (x*x for x in range(1,11))
print(type(g))
print(g)
#通过next方法输出，每次调用next(g), 就计算出g的下一个元素的值，
#直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。
#使用的时候才进行实例化
print(next(g))
print(next(g))
for i in g:
    print(i)

5.迭代器

• 直接作用于for循环的对象统称为可迭代对象，数据类型有以下几种
• 一类是集合数据类型，如list.、tuple、 dict、 set、 str等;
• 一类是generator, 包括生成器和带yield的generator function.
• 列表这种数据类型有下标，但很多其他数据类型是没有下标的，但是，只要是可迭代对象，无论有无下标，都
  可以迭代。
• 比如字典和集合是无序的，同样可以使用for循环，也是可迭代对象

如何判定是否是可迭代对象呢?
通过collections模块的Iterable类型判断是否是一个可迭代的对象。
通过isinstance0函数来判断一个对象是否是一 个已知的类型

迭代器(terator) 就是具有next方法(这个方法在调用时不需要任何参数)的对象。
在调用next方法时，迭代器会返回它的下一个值。 如果next方法被调用，但迭代器没有值可以返回，就会引
发个Stoplteration异常。
list、dict. str虽然是Iterable, 却不是Iterator
例如: dir(list)没有next方法， dir(g)有next方法

Iterator对象表示的是一个数据流， 可以把这个数据流看作是一个有序序列， 但我们却不能提前知道序列的长
度，只能不断通过next(函数实现按需计算下一个数据，所以Iterator的计算是惰性的， 只有在需要返回下一
个数据时它才会计算。(惰性计算)
Iterator甚至可以表示个无限大的数据流， 例如全体自然数。而使用list是永远不可能存储全体自然数的。

# 通过 iter 函数获得 Interator 对象
it = iter([1,2,3,4,5])
print(type(it))
while True:
    try:
        x = next(it)  # 通过 next 方法获得下一个值
        print(x)
    except StopIteration:  # 到达结尾时引发异常 StopIteration 就会退出循环
        break

iterools 内置模块

itertools中的无限迭代方法

• count(start, [step]) : start, start+step, start+2*step, …
• 例如: count(10)–> 10 11 12 13 14 …
• repeat(elem [n]): elem, elem, elem, …或者重复n次结束如果没有指定n，则无限个elem
• 例如: repeat(5, 4) --> 5 5 5 5
• cycle ( p) : p0, p1, … plast, p0, p1, …
• 例如: cycle("abc’)–> a b c a b c a b c…

itertools中的有限迭代方法

• accumulate(p [func]):p0, p0+p1, p0+p1+p2,
• 例如: accumulate([1,2,3,4,51])–> 1 36 1015
• chain(p, q, …p0.p p1, … plast, q0, q1, …把-组迭代对象串联起来，形成一个更大的迭代器
• 例如: chain(ABC’, 'DEF)–> ABCDEF

itertools中的组合迭代

• product(p, q, … [repeat=1]) 组合，组合个数是repeat
• 例如: product(‘ABCD’; repeat=2)–> AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD
• permutations(‘ABCD’, 2)–> AB AC AD BA BC BD CA CB CD DA DB DC不包括重复的
• combinations(‘ABCD’, 2)–> AB AC AD BC BD CD只保留字典顺序的