这里是参考廖雪峰老师python基础教程的一些代码，之前自己已经学过了。所以这次又再次返回回来，再看一篇，加深一下印象。每个列子都分成一块了，然后#%%后面就是一下块的tiltie了。

# -*- coding: utf-8 -*-
"""
Created on Wed Aug 12 08:50:32 2020
"""

#%% 用筛法选出素数
def _odd_iter():
    n = 1
    while True:
        n += 2
        yield n
def _not_divisible(n):
    return lambda x: x%n>0 
#这里的lambda函数可以讲list中国的每一个元素%n从而判断返回值
def primes():
    yield 2
    it = _odd_iter()
    while True:
        n = next(it)
        yield n
        it = filter(_not_divisible(n),it)
        
for n in primes():
    if n < 1000:
        print(n)
    else:
        break
#%% 汉诺塔的案列
def move(n,a,b,c):
    if n == 1:
        print(a,'---->',c)
        return
    else:
        move(n-1,a,c,b) #我们把n-1块从a移到b后
        print(a,'---->',c)  #然后就可以直接从a移到c了，
        move(n-1,b,a,c) # 在将b上的n-1个盘子移到a上，最后一个肯定就是b-c了
    
move(3,'A','B','C')

# move(2,a,c,b)

#%% 去掉前后空格
def trim(s):
    for i in range(len(s)):
        if s[i] != ' ':
            break;
    for j in range(len(s)):
        if s[len(s)-j-1] != ' ':
            break;
    return s[i:len(s)-j]

a = trim('   ABC   ')
print(a)

#%%
def trim(s):
    while s[:1] == ' ':
        s = s[1:]
    while s[-1:] == ' ' :
        s = s[:-1];
    return s
a = trim('   ABC   ')
print(a)

#%%
def trim(s):
    if s[:1] != ' ':
        return s
    return trim(s[1:])
a = trim('    ABC    ')
a = trim(a[::-1])
print(a[::-1])
    
#%% 杨辉三角
def triangles():
    L1 = [1]
    cnt = 0 
    while cnt < 6:
        yield L1
        L2 = [1]
        i = 0  # L2[1,2,]
        while i < len(L1)-1:
            L2.append(L1[i] + L1[i+1])
            i += 1
        L2.append(1);
        L1 = L2
        cnt += 1
g = triangles()
for n in g:
    print(n)
 #%% 杨辉三角第二种写法
def triangles():
    L1 = [1]
    while True:
        yield L1
        L1 = [1] + [L1[i] + L1[i+1] for i in range(len(L1)-1)] + [1]
b = 0
for n in triangles():
    print(n)
    b += 1
    if b == 10:
        break;

 #%% 高阶函数篇 练习1 把用户名首字母转成大写字幕
# 对字符串处理 title()函数， upper() lower()
def normalize(name):
        #对每个字符串进行处理
    tmpf = name[:1].upper()
    tmpr = name[1:].lower()
    return tmpf+tmpr
    #return name
name = ['adam', 'LISA', 'barT']
r = map(normalize,name)
res = list(r) #把iterator变成一个list
print(res)
#%% 练习2 求积
from functools import reduce
def prof(L):
    return reduce(lambda x,y:x*y,L)
res = prof([1,2,3,4,5])
print(res)
#%% 练习3 把字符串'123.123'变成浮点数
# 要求用map和reduce
def str2float(s):
    data = s.split('.')
    number = []
    for item in data:
        # 先用map把每一个字符转成整数，再用reduce求和
        num = reduce(lambda x,y:x*10+y, list(map(int,list(item))))
        number.append(num)
    len2 = len(data[1])
    number[1] *= pow(10,-len2)
    return sum(number)
a = str2float('123.463465')
print(a)
#%% 廖雪峰老师的一个关于map和reduce的应用
from functools import reduce
def fn(x,y):
    return x*10+y
def char2num(s):
    digits =  {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
    return digits[s]
reduce(fn,map(char2num,'1234324')) #把字符串转成整数
    
#%% 排序sorted  内置函数
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
data = dict(L) 
def f(t):
    return t[0]
res = sorted(data,key=f) #这里的key只需要把要比较的参数传到里面去就行
print(res)  

[TOC]

基本数据类型：

• python

1. 整数
2. 浮点数
3. 字符串‘aaa’ “aaa”
4. 布尔
5. 空值 None inf无限大
6. 常量 通常全部大写

• 运算符

1. 非
2. 算术运算符
3. 逻辑运算符 && ||

---

str字符串

s='abcdef'
ord()获取字符的整数表示
chr(unicode)获取编码对应的字符

方法1. 切片 s[::-1] 反转一个字符串

方法2.

l = list(s)  l.reverse() res=''.join(l[::-1])

==方法3. reduce==

res = reduce(lambda x,y:y+x,s)
方法4： 使用递归函数
def fn(s)

---

字符编码

1. unicode&acall码区别：unicode(2 byte) 而acall(1byte)
2. unicode & utf-8:utf-8把unicode设计成可变长度的编码，在内存中同一使用的是unicode编码，保存到磁盘上或传输过程中都用utf-8
3. 使用encode('format'),decode()

ord('')获取字符的整数表示 A65

chr(65) 输出A

bytes类型的数据前面用b修饰
x=b'ABC'
'ABC'.encode('ascii|utf-8|unicode');中文就不能用ascii表示

从磁盘读bytes类型数据，转str用decode。 b'ABC".decode('',errors='ignore')。errors参数对发生解码错误的地方忽略

【note】
字符串与bytes相互转换

str2bytes
sb = bytes(s,encoding='utf8')
sb2 = str.encode(s)

bytes2str
bs = str(b,encoding='utf8')
bs2 = bytes.decode(b)

---

list和tuple

1. list有序集合

     (1) len(name) 获得元素的个数；

     (2) 也是通过下标来访问；超过范围报IndexError错误；

     (3) 最后一个索引是len(name)-1; listNmae[-1]用-1可作为最后一个的索引；-2就是倒数第2个

     (4) insert(index,value),append()；listName.pop(index)弹出第i个元素；

【注】list中数据类型还可以不同,还可以嵌套linst

2. tuple有序列表元组，
   区别：初始化完成不能修改,clsname=('a','b','c')
3. cls=(1,)而不能写成cls=(1)这样会引发歧义，只有一个元素1的tuple
   4.需要说明的是，元素和列表都和课相互嵌套着来使用。list中可以嵌套list，也可以嵌套tuple； tuple中可以还是tuple，也可以是list.

---

控制语句

1. 判断：

一、不用{}而用缩进；

if condition：
    sentence
    setence...
else:
    sentence...

二、else if写法

if <condition>：
    <process>
elif <condition>：
    <process>
elif <condition>:
    ...
else:
    ...

三、
注意x是非零数值、非空字符串、非空list

if x:
    <process>

【注】b = input('输入数据') 这里input接受的都是str类型，如果是整数要int(b)转换一下

循环

1.for

for两种写法，一种是in关键字；另一种是下标

for item in list:
    <process>
    
for i in range(1,len(list)):
    可以遍历list[i]

range(b)+a 可以生成一个[a,b)整数序列

2. while

3. 流程控制

break和continue；
break表示跳出本次循环，continue表示跳过当前这次循环，进入下一次循环

---

dict & set

1. dict key-value存储

关于字典的初始化方法

d = {'a':1,'b':2}
d = dict([('a',1),('b',2)])
d = dict([['a',1],['b',2]])
d = dict(a=1,b=2)

避免key不存在与dict中，可以使用in判断key in d 返回布尔值；

获取dict中元素
d.get(key,returnValue)，如果key不存在,则返回 returnValue，这个returnValue是自己指定的值。

删除key，d.pop(key)
dict是一种散列表，占用的空间会比list多；

【注】dict中key都是不可变的，python中整数，字符串，tuple不可变，但list可变不能作为key;

已知两个list先要生成一个dict

字典操作：

1. 键值查找 d['key']，返回的是value
2. 更新 d['key'] = xx
3. 插入一个元素 d['key'] =
4. 判断key是否再集合中 key in d，返回的是一个bool类型
5. 删除一个元素: del d['key']

2. set

集合无序性、唯一性、有穷性
set(list),提供list作为输入集合，如果list有重复元素，会被自动过滤；
s.add(key)
s.remove(element)删除元素

s1 & s2 做一个交集
s1|s2 做并集运算

数学符号	python符号
(不)属于	（not）in
=(不等于)	=（!=）
包含	<
真子集	<=

【注】set与dict同样不可以放入可变对象

把tuple作为参数放入dict set中看看效果

(1,2,3)

(1,[1,2],3) #同样不能加入set,作为key也不能加入到dict中

---

函数

help(函数名) 查看内置函数
调用函数
数据类型转换 int() float() str() bool()

hex()十进制转十六进制

oct()十进制转8进制

bin()十进制转2

1. 定义

def functionName(parameter1,..):
    函数体/pass占位符

2. 参数检查

isinstance(parameter,(类型))判断形参是否是
返回多个值：就是返回一个tuple

3. 函数的参数

位置参数，默认参数、可变参数（参数的个数不确定）、关键字参数（把传入的参数当作一个dict）、命名关键字（打头，然后跟着参数名称）*

# 默认参数
def my_power(a,b=2):
    # 求a的b次幂，如果没有指定b就默认求平方

【注】必选参数放在前面，默认参数放在后面；

函数有多个参数时候，变化大的参数放在前面，变化小的放在后面（可以当作默认参数）

用默认的参数一定要注意，执行的对象是否发生变化，如果L只想对象变了，就是新的数据，没变就继续在原数据操作

def add_ele(L=[]):
    L.append('end')
    return L
# 这里L在函数定义的时候就已经分配内存了，所以多次调用函数add_ele()时候，其实L指向内容[],默认参数内容发生变化，不是开始的[]

#None不变的对象作为参数
def add_ele(L=None):
    if L is None:
        L = []
    L.append('end')
    return L
# 这里如果多次调用add_ele()

可变参数

写法一

def calc(numbers):
    <sentence
    
# 可以在调用函数的时候传入list或者tuple
calc([1,2,3]) 要自己手动封装一个list和tuple

写法二：

def calc(*numbers)：
    pass

这样可以直接使用calc(1,2,3)

如果已经有了个list或者tuple,可以在list或者tuple前面加上*号，把list或者tuple编程可变参数传入,如下：

nums=[1,2,3]
calc(*nums)

关键字参数：

关键字参数会在函数内部自动组成一个dict

def person(name,age,**kw):

# 此处**kw就是一个dict
# 初始化时可以这样做
ext = {'location':'beijing','nation':'en'}
person('zhangsan',12,**ext)

命名关键字参数

表示函数只接受city和job作为关键字参数

def person(name,age,*,city,job):
    <处理>

当然，命名关键字可以又默认值，但传入参数时候必须加上city=xxx,job=xxx

==参数组合==

参数定义顺序：位置参数、默认参数、可变参数、命名关键字参数和关键字参数

递归函数

随时查的

Python产生随机数：
一.Python自带的random库
1.参生n--m范围内的一个随机数: random.randint(n,m)

   2.产生0到1之间的浮点数:  random.random()

   3.产生n---m之间的浮点数:  random.uniform(1.1,5.4)

   4.产生从n---m间隔为k的整数: random.randrange(n,m,k)

   5.从序列中随机选取一个元素:  random.choice([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])

   6.在一些特殊的情况下可能对序列进行一次打乱操作: random.shuffle([1,3,5,6,7])

二.numpy库
1.产生N维的均匀分布的随机数: np.random.rand(d1,d2,d3,...,dn)

   2.产生n维的正态分布的随机数:   np.random.randn(d1,d2,d3,...,dn)

   3.产生n--m之间的k个整数：np.random.randint(n,m,k)

   4.产生n个0--1之间的随机数: np.random.random(10)

   5.从序列中选择数据: np.random.choice([2,5,7,8,9,11,3])

   6.把序列中的数据打乱：np.random.shuffle(item)