python学习笔记一

一、裴波那契数列

a,b=0,1
while b<20:
    print(b)
    a,b=b,a+b

【注】a,b=b,a+b等价于n=b m=a+b a=n b=m 一定要通过n m 实现变量的传递。y一定不能a=b,b=a+b

二、关键字end

a,b=0,1
while b<30:
    print(b,end=',')
    a,b=b,a+b

三、Python 条件控制 ：

If 语句 ：
If condition_1:
    Pass
Elif condition_2:
    Pass
Else:
    Pass

If 嵌套 ：
If condition_1:
    Pass
    If condition_2:
        Pass:
    Elif condition_3:
        Pass
    Else:
        Pass
Elif condition_4:
    Pass
Else:
    Pass

四、python 循环语句

Python 中的循环语句有 for 和 while

在 while … else 在条件语句为 false 时执行 else 的语句块。

类似if语句的语法，如果你的while循环体中只有一条语句，你可以将该语句与while写在同一行中 。

for循环可以遍历任何序列的项目，如一个列表或者一个字符串 。

如果你需要（for）遍历数字序列，可以使用内置range()函数。它会生成数列 。

您可以结合range()和len()函数以遍历一个序列的索引

break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。

continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

循环语句可以有 else 子句，它在穷尽列表(以for循环)或条件变为 false (以while循环)导致循环终止时被执行，但循环被 break 终止时不执行。

Python pass是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句

五、python 迭代器和生成器

迭代是Python最强大的功能之一，是访问集合元素的一种方式。

迭代器是一个可以记住遍历的位置的对象。

迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

迭代器有两个基本的方法：iter() 和 next() 。

字符串，列表或元组对象都可用于创建迭代器 。

迭代器对象可以使用常规for语句进行遍历 。

创建一个迭代器 ：

把一个类作为一个迭代器使用需要在类中实现两个方法 __iter__() 与 __next__() 。

Python 的构造函数为 __init__(), 它会在对象初始化的时候执行。

StopIteration 异常用于标识迭代的完成，防止出现无限循环的情况，在 __next__() 方法中我们可以设置在完成指定循环次数后触发 StopIteration 异常来结束迭代。

在 Python 中，使用了 yield 的函数被称为生成器（generator）。

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

迭代器：
class DieDaiQi:
    def __iter__(self):
        self.a=1
        return self

    def __next__(self):
        x=self.a
        self.a+=1
        return x

deidaiqi=DieDaiQi()
myiter=iter(deidaiqi)

print(next(myiter))
print(next(myiter))

生成器：

import sys

def fibonacci(n):
    a,b,c=0,1,0
    while 1:
        if c>n:
            return
        yield a
        a,b=b,a+b
        c+=1

f=fibonacci(20)

while 1:
    try:
        print(next(f),end=",")
    except StopIteration:
        sys.exit()

六、定义一个函数：

#定义一个函数：
def hello():
    print("hello world")

#调用函数：
hello()

#定义一个函数：
def area(width,height):
    return width*height

#调用函数：
width=10
height=20
print("宽度是",width,"长度是",height,"面积是",area(width,height))

#定义一个函数：
def print_name(name):
    print("welcome",name)

#调用函数 ：
print_name("yuangungun")

#定义一个函数：
def printme(str):
    print(str)
    return

#调用函数：
printme("圆滚滚")
printme("圆滚滚圆滚滚")

#定义一个函数：
def ChangeInt(a):
    a=10

#调用函数;
b=12
ChangeInt(b)
print(b)

#定义一个函数：
def changeme(mylist):
    mylist.append([1,2,3,4])
    print("函数内",mylist)
    return 

#调用函数：
mylist=[50,60,70]
changeme(mylist)
print("函数外",mylist)

#定义一个函数：
def printme(str):
    print(str)
    return

#调用一个函数：
print("圆滚滚")   #print(str="圆滚滚")

#定义一个函数：
def printinfo(name,age):
    print("姓名是：",name)
    print("年龄是：",age)
    return

#调用一个函数：
printinfo(name="圆滚滚" ,age=12)

#定义一个函数：
def printinfo(name,age=350):   #name和age顺序不能变
    print("姓名：",name)
    print("年龄：",age)
    return

#调用函数：
printinfo(name="圆滚滚",age=100)
print("-----------------------------------------")
printinfo(name="圆滚滚")

#定义一个函数：
def printinfo(args,*kwargs):    #加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数
    print("输出：")
    print(args)
    print(kwargs)

#调用函数：
printinfo(70,60,50,40)

#定义一个函数：
def printinfo(args,*kwargs):    #加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
    print("输出：")
    print(args)
    for i in kwargs:
        print(i)
    return

#调用一个函数：
printinfo(70)
printinfo(70,60,50,40)

#定义一个函数：
def printinfo(args,**kwargs):   #加了两个星号 ** 的参数会以字典的形式导入。
    print("输入：")
    print(args)
    print(kwargs)
    return

#调用函数：
printinfo(1,a=2,b=3)

def printinfo(a,b,*,c):    #如果单独出现星号 * 后的参数必须用关键字传入。
    return a+b+c

printinfo(1,2,c=3)

七、匿名函数：

python 使用 lambda 来创建匿名函数。所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。

sum=lambda args1,args2:args1+args2    #冒号前面的两个变量中间一定要加括号

print("相加后的结果：",sum(10,15))
print("相加后的结果：",sum(25,35))

八、RETURN语句

return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。

#定义一个函数：
def sum(args1,args2):
    total=args1+args2
    print("函数内：",total)
    return total

#调用函数：
total=sum(10,25)
print("函数外：",total)

九、

把一个元素添加到列表的结尾 ：list.append(x)

通过添加指定列表的所有元素来扩充列表 ：list.extend(L)

在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引 ：list.insert(I,x)

删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误 ：list.remove(x)

返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误 ：list.index(x)

从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除 ：list.pop([i])

移除列表中的所有项 ：list.clear()

返回 x 在列表中出现的次数 ：list.count(x)

对列表中的元素进行排序 ：list.sort()

倒排列表中的元素 ：list.reverse()

返回列表的浅复制 ：list.copy()

 十、将列表当做堆栈使用

列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放出来。

stock=[3,4,5]
stock.append(6)    #stock
stock.append(7)    #stock
stock.append(8)    #stock

stock.pop()    #stock
stock.pop()    #stock
stock.pop()    #stock
stock.pop()    #stock

十一、将列表当作队列使用

也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个一个地移动）。

from  collections import deque

queue=deque([3,4,5])
queue.append(6)
queue.append(7)
queue.append(8)
queue

queue.popleft()
queue.popleft()
queue.popleft()
queue.popleft()
queue

十二、列表推导式

列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。

每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。

vec=[3,4,5,6]
[i*3 for i in vec]
[[i,i**2] for i in vec]
[i*5 for i in vec if i>4]

vec1=[1,2,3]
vec2=[3,6,9]
[x*y for x in vec1 for y in vec2]
[vec1[i]*vec2[i] for i in range(len(vec1))]

vec=['  round  ','    yuan    ','gungun    ']
[i.strip() for i in vec]    #i.strip()去除前后的空格

#圆周率计算的过程：
[str(round(355/113,i)) for i in range(8)]

十三、嵌套列表解析：

把一个3*4的矩阵列表转换成4*3的矩阵列表的三种方法：

matrix=[
[1,2,3,4],[5,6,7,8],[9,10,11,12]
]

#方法1：
[[row[i] for row in matrix] for i in range(4)]

#方法2：
transposed=[]
for i in range(4):
    transposed.append([row[i] for row in matrix])

transposed


#方法3：
transposed=[]
for i in range(4):
    transposed_row=[]
    for row in matrix:
        transposed_row.append(row[i])
    transposed.append(transposed_row)

transposed

十四、集合

集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。

可以用大括号({})创建集合。如果要创建一个空集合，你必须用 set() 而不是 {} ；后者创建一个空的字典。

a = set('abracadabra')
b = set('alacazam')

a-b    # 在 a 中的字母，但不在 b 中
a|b    # 在 a 或 b 中的字母
a&b   # 在 a 和 b 中都有的字母
a^b    # 在 a 或 b 中的字母，但不同时在 a 和 b 中

#也可以用于推导式

a={x for x in "adfdsgfadgsdfsf" if x not in "abd"}
a

十五、

构造函数 dict() 直接从键值对元组列表中构建字典。

#创建一个字典：
tel={"yuangungun":123456,"panghuhu":456789,"yuanpang":147258}

dict([("yuangungun",123456),("panghuhu",456789),("yuanpang",147258)])

dict(yuangungun=123456,panghuhu=456789,yuanpang=147258)

十六、遍历：

在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：

knights={'yuangungun':123456,'panghuhu':456789,'yuanpang':147258}
for k,v in knights.items():
    print(k,v)

在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：

for k,v in enumerate(['yuangungun','panghuhu','yuanpang']):
    print(k,v)

同时遍历两个或更多的序列，可以使用 zip() 组合：

var1=['name1','name2','name3']
var2=['panghuhu','yuangungun','pangyuan']
for k,v in zip(var1,var2):
    print("What is your {0} ? My {1} is {2}".format(k,k,v))

要反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数：

for i  in reversed(range(1,10,2)):
    print(i)

要按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：

basket=['y','u','a','n','g','u','n']
for i in sorted(basket):
    print(i)