python第二篇

jupyter netbook已经成为数据分析的标准环境，可以将数据分析的代码、图像和文档全部组合到一个web文档中。
在交互式解释执行python程序环境时>>>为提示符（命令行界面cmd）

`python语法糖系列相关文章
语法糖顾名思义就是代码又好看（简洁）又好用

数值类型

布尔类型中 在None、0、空（如空字符串、空列表、空字典）时布尔值都为False，其余情况下均为True，也就是1

浮点类型
也称小数，如前面提到3.14159， 0.2e-5 其中，e计数（数据相关文章）用来表示非常大或者非常小的浮点数，用e代替10，如5.5e3。

不同类型的数值也是可以互相转化的
int()整 bin()二 oct()八 hex()十六 float()浮点 complex()复数

变量的值是可以随时修改的，比如重新赋值给同一变量的话那么后一个的值会覆盖前面所赋予的值

序列封包与序列解包

序列封包是指在多个值赋值给一个变量时，python会自动把多个值封装成元组

a = 1,2,3
print(a)  #结果为(1, 2, 3)

序列解包是指将一个元祖直接赋值给多个变量时，python会把序列中各个元素依次赋值给每个变量

a, b, c = (1, 2, 3)
print(b)  #结果为2

多变量赋同一个值
可以是a = b = c = 10
多变量赋不同值
这种方法被称为序列解包其中元素个数与变量个数必须相等否则就会出错
a,b,c=1,2,3
快速交换变量值（也是序列解包）

a = 1; b = 2
a, b = b, a
print(a, b) #结果是2 1

在python中可以用函数id()函数显示变量所指值的内存地址

成员运算符 in 、not in 返回的值是布尔值

格式化输出

format和%还有f’{}’
相关文章

数据结构之数组和链表

参考文章

序列类型

列表，字典，元组， 集合。所有操作
参考文章

列表

list() 创建: []
使用函数sort() reverse()进行排序时列表就已经发生改变了
如以下生成20个随机数，前十位数正序排列后十位倒序排列

import random
s = []         #创建一个s列表
for i in range(20):
    s.append(random.randint(1, 100))
a = s[0:10]
a.sort()    #此时a列表已经变为了前十位数正序排列
b = s[10:21]
b.sort() 
b.reverse()       #此时b列表已经是后十位倒序排列了
s = a + b         #重新赋值给列表s s列表发生改变
print(s)       #如果不重新赋值给s  print(a , b)的话就会输出两个列表
#[3, 6, 15, 36, 57, 60, 60, 62, 66, 78, 89, 88, 86, 76, 74, 71, 63, 40, 37, 21]

元组

tuple()创建 : ()
元组的数据不可以像列表一样进行修改，但是可以进行切片操作、访问、统计元素长度、排序

b = (1, 312, 123, 12, 3, 123, 12)
s = b[1:5]
print(s)  #(312, 123, 12, 3)      切片操作

字典（映射）

字典类型是python中唯一的映射类型，即根据一个元素可以找到另外一个元素，字典里的“键”可以是python中任意不可变数据，如整数，浮点数，复数，字符串，元组…。但是我们不能使用列表、集合、字典作为“键”因为这些类型是可变的。另外“键”不允许重复，但“值”可以重复，如果“键”重复的话那么后面的“值”会覆盖掉前面的“值”

dict() 创建： {}
使用dict()函数创建的时候要注意先创建一个键的列表，在创建一个值的列表然后使用zip()函数将这两个列表组合
拓展：

zip()函数是Python中的一个内置函数，它可以将多个可迭代对象打包成一个元组序列，返回一个zip对象。其中，表示将可迭代对象解压为单个元素，即将多个可迭代对象作为参数传递给zip函数。使用zip()函数可以方便地进行多个列表或元组的并行迭代，提高代码的可读性和效率。例如，可以使用zip()函数将两个列表中的元素一 一对应，生成一个新的元组序列

keys = ['b', 'a', 'c', 'd']
values = ['nihao', 'shide', 'hhh', 'wozhidao']
newdict = dict(zip(keys, values))  #zip对象<zip object at 0x000002685D00CF00>
print(newdict)

集合

set() 创建 ： {}
集合的操作包括交集，并集，差集运算。

进行交集运算时使用“&”符合
进行并集运算时使用“|”符合
进行差集运算时使用“-”符号

mr = set(['小明', '小红', '小白'])  # 学习数学的人
mr1 = set(['小明', '小红', '小聪'])  # 学习英语的人
print("出输出既学习数学，也学习英语的人有：", mr & mr1)
print("学习的人有：", mr | mr1)
print("只学习数学的人有：", mr - mr1)

程序结构

程序结构包括
顺序结构 循环结构

顺序结构

包含
单分支选择结构
双分支选择结构
多分支选择结构 if …elif…else
选择语句嵌套
条件运算

循环结构

包含
for循环
while循环
循环嵌套结构
无限循环
列表推导器
生成器推导式

while 和 for 在不知道循环几次的时候适合用while 反之使用for

range()返回的是可迭代对象

循环的对象也必须是一个可迭代的对象例如列表、字典…

迭代：是通过重复执行的代码处理相似的数据集的过程，并且本次迭代的处理数据要依赖上一次的结果继续往下做，上一次产生的结果为下一次产生结果的初始状态，如果中途有任何停顿，都不能算是迭代。
例如：

1. 非迭代例子
   loop = 0
   while loop < 3:
   print(“Hello world!”)
   loop += 1
2. 迭代例子
   loop = 0
   while loop < 3:
   print(loop)
   loop += 1
   例1仅是循环3次输出" Hello world!"，输出的数据不依赖上一次的数据，因此不是跌代。

可迭代对象(Iterable)：可迭代对象并不是指某种具体的数据类型，它是指存储了元素的一个容器对象，且容器中的元素可以通过__iter__( )方法或__getitem__( )方法访问。

1. __iter__方法的作用是让对象可以用for … in循环遍历，getitem( )方法是让对象可以通过“实例名[index]”的方式访问实例中的元素。这两个方法的目的是Python实现一个通用的外部可以访问可迭代对象内部数据的接口。
2. 一个可迭代对象是不能独立进行迭代的，Python中，迭代是通过for … in来完成的。凡是可迭代对象都可以直接用for… in…循环访问，这个语句其实做了两件事：第一件事是调用__iter__()获得一个可迭代器，第二件事是循环调用__next__()。
3. 常见的可迭代对象包括：
   a) 集合数据类型，如list、tuple、dict、set、str等；
   b) 生成器(generator)，包括生成器和带yield的生成器函数(generator function)，下节专门介绍。
4. 如何判断一个对象是可迭代对象呢？可以通过collections模块的Iterable类型判断，具体判断方法如下：
   from collections import Iterable
   isinstance(‘’, Iterable) #返回True，表明字符串也是可迭代对象
   关于collections后续再介绍。
5. 在迭代可变对象如列表对象时候，一个序列的迭代器只是记录当前到达了序列中的第几个元素，所以如果在迭代过程中改变了序列的元素。更新会立即反应到所迭代的条目上。比如一个列表 用for…in方法迭代访问时，删除了当前索引n对应的元素，则下一个循环时，访问的数据索引为n+1，但实际访问元素的索引是上一轮循环中列表的索引n+2对应元素。

迭代参考文献

break continue语句

break语句在循环体内，用于立即终止所在循环，即跳出离它最近的内层循环，继续执行循环结构后面的语句
continue语句,同样用在循环体内，用于结束本次循环，即忽略当前循环体中未执行的语句，重新开始下一轮循环

列表推导式

又称列表解析式
可以有快速生成满足特定需要的列表
格式[Expression for variable in List] or [Expression for variable in List if condition satified]
1.语法：[表达式 for 变量 in 序列或迭代对象]
列表推导式在逻辑上相当于一个循环，但形式更加简洁

>>> l = [(x,y) for x in[1,2,3] for y in[3,2,4] if x != y]
>>> print(l)
[(1, 3), (1, 2), (1, 4), (2, 3), (2, 4), (3, 2), (3, 4)]
'''
对于包含多个循环的列表推导式，一定要清楚多个循环的执行顺序或嵌套关系
'''

生成器推导式

1.从形式上看，生成器推导式与列表推导式非常接近，只是生成器推导式使用圆括号而不是列表推导式所使用的方括号。
2.与列表推导式不同的是，生成器推导式的结果是一个生成器对象，而不是列表，也不是元祖。但使用生成器对象的元素时，可以根据需要将其根据需要转化为列表或者元祖。

1.创建生成器推导式

>>> g = ((i+2)**2 for i in range(10))
>>> g
<generator object <genexpr> at 0x000001CA569C5AC8>

2.根据需要将创建好的生成器对象转化为列表或元祖

>>> g = ((i+2)**2 for i in range(10))
>>> g
<generator object <genexpr> at 0x000001CA569C5AC8>
>>> list(g)#将生成器对象转化为列表
[4, 9, 16, 25, 36, 49, 64, 81, 100, 121]
>>> tuple(g)#将生成器对象转化为元祖
()#为什么是空的？？！看下面总结

注：关于惰性求值
1).是什么：惰性求值（Lazy Evaluation），又译为惰性计算、懒惰求值，也称为传需求调用（call-by-need）。
2).为什么：使用惰性求值的目的是要最小化计算机要做的工作。eg：生成器推导式是继列表推导式后的Python推导式，比列表推导式速度快，占内存少。
3).特点：不管用什么方法访问元素，当所有元素访问结束后，立马清空生成器对象。如果需要重新访问其中的元素，必须重新创建该生成器对象。

3.遍历生成器对象中的元素

>>> g = ((i+2)**2 for i in range(10))
>>> print(g.__next__())#使用生成器对象__next__()方法获取元素
4
>>> print(g.__next__())
9
>>> print(next(g))#使用内置函数next()方法获取生成器对象中的元素
16
>>> print(next(g))
25
#-----使用循环直接遍历生成器对象中的元素-------
g = ((i+2)**2 for i in range(10))
for item in g:
    print(item,end = ' ')

4.包含yield语句的函数可用来创建可迭代的生成器对象

def f():
    a,b = 1,1#序列解包，同时为多个元素赋值
    while True:
        yield a#暂停执行，需要时再产生一个新元素
        a,b = b,a+b#序列解包，继续生成新元素
a = f()#创建生成器对象
for i in range(10):#斐波那契数列中前十个元素
    print(a.__next__(),end = ' ')
    #结果：1 1 2 3 5 8 13 21 34 55
for i in f():
    if i > 100:#斐波那契数列中第一个大于100的元素
        print(i)
        #结果：144
        break
a = f()
print(next(a))#使用内置函数next()获取生成器对象中的元素
print(next(a))#每次获取新元素时，由yield语句生成
print(next(a))
#结果：
1
1
2

注：关于yield关键字
1.yield作为Python33个关键字之一，在生成器函数中用来返回值。Python33个关键字
2.可以把yield看做return，只不过return的作用是在程序中返回某个值，返回之后程序就不再往下运行了。而使用yield的函数是一个生成器，不仅仅是一个简单的函数。
3.可以将yield理解为：暂停执行，需要时再产生一个新元素。也就是说，yield扮演的也是返回的角色，但并不意味着yield返回就结束了整个程序，仅仅是暂停，下次需要时再出现。