python核心语法

notebook主目录及pip镜像源修改
python基础语法
python核心语法
matplotlib基本操作
python常见统计分析处理函数

一、生成器

1.1 列表生成式

Python 内置的非常简单却强大的，可以⽤来创建 list 的⽣成式。

[x*x for x in range(1,7)]#这个就是列表⽣成式

运⽤列表⽣成式，可以将⽐较复杂的代码变得⽐较简洁

import os
[a for a in os.listdir('.')]

列表推导式的原理可以扩展到集合（set）和字典。
（1）集合

mult_list={i *j for i in range(3) for j in range(3) if i>0}

set中没有重复的值，创建set时会自动消除重复项。
（2）字典
字典推导式稍微复杂一些，需要先使用以下语法创建一个循环来生成键值对：key：value
假设我们有一个要作为数据字典基础的元组列表。

val_list=[('pi','3.14'),('phi','1.618')]

则可以用下面的代码生成字典：

mult_list={i[0]:i[1] for i in val_list}
mult_list #输出{'pi': '3.14', 'phi': '1.618'}
mult_list['pi']

可以使用内置zip函数合并列表来提高代码性能，代码如下：

keys=['bob','cob','ted','alice']
val=[1,2,3,4]
grade={keys:val for keys,val in zip(keys,val)}
grade
#输出：{'bob': 1, 'cob': 2, 'ted': 3, 'alice': 4}

字典推导式一种非常重要的用途就是反转字典。例如，你有一本电话薄，可以通过姓名查找号码，将其反转之后，则可以通过号码查找姓名。

idic={v:t for k,v in phone.items()}

字典的items方法会产生一给（k，v）键值对的列表，其中k是键，v是值，对于每个这样的对，值表达式v：k会在生成新字典idic时反转键值关系

1.2 创建生成器

⼀边循环⼀边计算的机制，称为⽣成器:generator。

#方法一：列表⽣成式的[]改成()，就创建了⼀个 generator
List = [ x*2 for x in range(5)]#range(5)==>0,1,2,3,4
print(List) #0,2,4,6,8
Generator = ( x*2 for x in range(5))
#如果要⼀个⼀个打印出来，可以通过 next() 函数获得⽣成器的下⼀个返回值
Generator = ( x*2 for x in range(5))
temp = next(Generator) #[0, 2, 4, 6, 8]
print(temp) #0
temp = next(Generator)
print(temp) #2
#注意：如果⼀直写next()函数，当超出了元素的个数范围时会直接报错

#方法二：如果推算的算法⽐较复杂，⽤类似列表⽣成式的 for 循环⽆法实现的时候，还可以⽤函数来实现。
def fib():
    a = 0
    b,c = 0,1
    while a < 5:
        yield c
    # print(c)
        b,c = c,b+c
        a += 1
f = fib()
# print(next(f))
# print(next(f))
#⼀般使⽤for循环实现
for x in fib():
    print(x)

⽣成器的特点：

• 节约内存
• 迭代到下⼀次的调⽤时，所使⽤的参数都是第⼀次所保留下的，
• 即是说，在整个所有函数调⽤的参数都是第⼀次所调⽤时保留的，⽽不是新创建的

二、迭代器

可以直接作⽤于 for 循环的对象统称为可迭代对象。
可以被next()函数调⽤并不断返回下⼀个值的对象称为迭代器：Iterator。

2.1 迭代对象

以直接作用于 for 循环的数据类型有以下几种:

• 一类是集合数据类型，如 list、tuple、 dict、 set 、str 等;
• 一类是 generator ，包括生成器和带 yield 的generator function。
  这些可以直接作用于 for 循环的对象统称为可迭代对象: lterable 。

# 注：可以使⽤ isinstance() 判断⼀个对象是否是 Iterable 对象
from collections.abc import Iterable
a = isinstance([], Iterable) 
b = isinstance({}, Iterable) 
c = isinstance("abc", Iterable) 
d = isinstance(100, Iterable) 
e = isinstance((x for x in range(10)), Iterable) 
print(a) #True
print(b) #True
print(c) #True
print(d) #False
print(e) #True

#注：可以使⽤ isinstance() 判断⼀个对象是否是 Iterator 对象
from collections.abc import Iterator
a = isinstance([], Iterator)
b = isinstance({}, Iterator)
c = isinstance("abc", Iterator)
d = isinstance(100, Iterator)
e = isinstance((x for x in range(10)), Iterator)
print(a) #false
print(b) #false
print(c) #false
print(d) #false
print(e) #true

2.2 iter() 函数

为什么 list、dict、str 等数据类型不是 Iterator?

• 1.凡是可作⽤于 for 循环的对象都是 Iterable 类型
• 2.凡是可作⽤于 next() 函数的对象都是 Iterator 类型
• 3.集合数据类型如 list 、 dict 、 str 等是 Iterable 但不是 Iterator
  不过可以通过 iter() 函数获得⼀个 Iterator 对象。

from collections import Iterator
a = isinstance(iter([]), Iterator)
b =isinstance(iter('abc'), Iterator)
print(a) #true
print(b) #tru

2.3 生成器和迭代器之间的区别

• 1.迭代器⼀定是⼀个可迭代对象，因为既有可迭代对象iter⽅法，也有可迭代对象不具备的next方法。
• 2.但反过来，可迭代对象却不⼀定是⼀个迭代器，但能通过iter函数实现。
• 3.迭代器可以通过next函数访问下⼀个值，也可以和可迭代对象⼀样for循环遍历。
• 4.⽣成器就是⽤来创建迭代器的函数，使⽤yield关键字，返回⼀个⽣成器。
• 5.⽣成器既是⼀个可迭代对象，也是⼀个迭代器。
• 6.for循环就是迭代器调⽤next函数依次访问下⼀个值
  共同点
  生成器是⼀种特殊的迭代器
  不同点
  （1）语法上
  ⽣成器是通过函数的形式中调⽤ yield 或（）的形式创建的
  迭代器可以通过 iter()内置函数创建
  （2）语法上
  ⽣成器在调⽤next()函数或for循环中，所有过程被执⾏，且返回值
  迭代器在调⽤next()函数或for循环中，所有值被返回，没有其他过程或说动作

三、高阶函数

3.1 map函数

map() 会根据提供的函数对指定序列做映射。
map()⽅法的描述：创建⼀个迭代器，使⽤每个迭代项。当最短的迭代被耗尽时停⽌。

map()语法
map(function, iterable, ...)

a=(1,2,3,4,5)
b=[1,2,3,4,5]
c="zhangkang"
la=map(str,a)
lb=map(str,b)
lc=map(str,c)
print(list(la)) #['1', '2', '3', '4', '5']
print(list(lb)) #['1', '2', '3', '4', '5']
print(list(lc)) #['z', 'h', 'a', 'n', 'g', 'k', 'a', 'n', 'g']

def f(x):
    return x*x
md=map(f,[1, 2, 3, 4, 5, 6, 7, 8, 9])
list(md) #[1, 4, 9, 16, 25, 36, 49, 64, 81]

3.2 reduce

reduce() 函数会对参数序列中元素进⾏累积。

#两个数的求和
#⽅式1：
from functools import reduce
def add(x,y):
    return x + y
print (reduce(add, range(1, 101)))#5050
#⽅式2：
from functools import reduce
aa=reduce(lambda x,y:x+y,[1,2,3,4,5])
print(aa) #15

#获取每个词出现的次数（以空格分割）
from functools import reduce
aa="an apple a banana three apple a desk"
aa_split=aa.split(' ')
def fun(x,y):
    if y in x:
        x[y]=x[y]+1
    else:
        x[y]=1
    return x
result=reduce(fun,aa_split,{})
print(result)

3.3 filter

filter() 函数⽤于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

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

def func(num):
    if num % 2 == 0:  # 偶数保留
        return True
    return False  # 奇数剔除

l = filter(func, list1)
print(list(l))   #[2, 4, 6, 8]

3.4 sorted

sorted() 函数对所有可迭代的对象进⾏排序操作。

list1 = [4,7,2,6,3]
list2 = sorted(list1)#默认升序排序

#按绝对值⼤⼩排序
list3 = [4,-7,2,6,-3]
#key接受函数来实现⾃定义排序规则
list4 = sorted(list3, key=abs)

#函数可以⾃⼰写
def myLen(str):
    return len(str)
list7 = ['b333','a1111111','c22','d5554']
list8 = sorted(list7,key=myLen)#默认升序排序
print(list8) #['c22', 'b333', 'd5554', 'a1111111']

3.4.1 选择排序

每⼀次从待排序的数据元素中选出最⼩（或最⼤）的⼀个元素，存放到序列的起始位置，直到全部排完。

def selectionSort(alist):
    for i in range(len(alist) - 1, 0, -1):
        maxone = 0
        for j in range(1, i + 1):
            if alist[j] > alist[maxone]:
                maxone = j
        temp = alist[i]
        alist[i] = alist[maxone]
        alist[maxone] = temp
    return alist
alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
print(selectionSort(alist))

3.4.2 冒泡排序

第⼀趟：相邻的两数相⽐，⼤的往下沉。最后⼀个元素是最⼤的。
第⼆趟：相邻的两数相⽐，⼤的往下沉。最后⼀个元素不⽤⽐。

def bubbleSort(alist):
    for passnum in range(len(alist)-1,0,-1):
        for i in range(passnum):
            if alist[i]>alist[i+1]:
                temp = alist[i]
                alist[i] = alist[i+1]
                alist[i+1] = temp
    return alist
alist = [54, 26, 93, 17, 77, 31, 44, 55, 20]
print(bubbleSort(alist))  #[17, 20, 26, 31, 44, 54, 55, 77, 93]