 功能：
 
 展示面板：
 1.添加学生的信息
 2.删除学生的信息
 3.修改学生的信息
 4.查询学生的信息
 5.遍历所有学生的信息
 6.保存并退出系统
 
 需求:
 1. 可以保存用户数据，下次运行程序时能读取上次保存的数据
 2. 具有添加、查询、删除用户的功能
 
 优化(此版代码未实现)：
 1. 规范用户行为，用户输入错误不能直接报错，而是返回相关提示。
 2. 可以增加项目，比如班主任，成绩等。
 3. 可以实现排序功能
 4. 删除一个用户后，索引值自动-1，保证id的连续
 5. 实现批量增加或者删除？

```
import csv
from pathlib import Path
import pickle
from prettytable import PrettyTable

p_save = Path('/jupyter/tmp/student/StudentDetails.save')  # 可以提取成配置文件
p_csv = Path('/jupyter/tmp/student/StudentDetails.csv')  # 可以提取成配置文件
# StudenDetails = [['StudentID', 'name', 'age']]
StudenDetails_Tmp = [['StudentID', 'name', 'age']]


def showinfo():
    """doc"""
    print('*' * 40)
    '''展示功能面板'''
    print(" 1.添加学生的信息")
    print(" 2.删除学生的信息")
    print(" 3.修改学生的信息")
    print(" 4.查询学生的信息")
    print(" 5.遍历所有学生的信息")
    print(" 6.保存并退出系统")


def save_csv(x):  # 保存为csv文件

    if not p_csv.parent.exists():
        p_csv.parent.mkdir(parents=True)  # 相对危险的操作
        p_csv.touch()
    with open(str(p_csv), 'a+') as f:
        writer_student = csv.writer(f)
        writer_student.writerows(x)


def save(x):
    if not p_save.parent.exists():
        p_save.parent.mkdir(parents=True)  # 相对危险的操作
        p_save.touch()
    with open(str(p_save), 'wb+') as f:
        pickle.dump(x, f)

        
def pick_load():
    with open(str(p_save), 'rb') as f:
        StudenDetails_Tmp = pickle.load(f)
        return StudenDetails_Tmp

        

def generate_counter(lst=[0]):  ##闭包实现自增功能==> 学生学号
    CNT = lst

    def add_one():
        CNT[0] += 1
        return CNT[0]

    return add_one


def show_student_details(lst: list, show_id: int):  # 根据输入的id，打印学生的详情
    for ii in lst:
        for xx in ii:
            if xx == show_id:  #
                details_list = ii

            else:
                continue
    return details_list


def StudentManagement():  # 主体函数

    while True:  # TODO 完成所有操作最后持久化
        print('*' * 40)
        option_tmp = input("请选择您的操作：")
        while True:
            if option_tmp.isdigit():
                break
            else:
                option_tmp = input("请输入正确的操作（1-6）：")
        option = int(option_tmp)

        if option == 1:
            StudentID = counter()  # TODO 自增问题

            name = input("请输入学生的姓名：")
            while True:
                if (u'\u4e00' <= name <= u'\u9fff'):
                    break
                if name.isalpha():
                    break
                else:
                    name = input("请输入正确的年龄（中文或者字母）：")

            age = input("请输入学生的年龄：")
            while True:
                if age.isdigit():
                    break
                else:
                    age = input("请输入正确的年龄（1-99）：")

            StudenDetails_Tmp.extend([[StudentID, name, age]])


        elif option == 2:  # 输入学生的id就可以删除
            DelID = int(input("请输入需要删除的学生id："))
            del_list = show_student_details(StudenDetails_Tmp, DelID)
            StudenDetails_Tmp.remove(del_list)
            print("删除用户成功：", del_list)
         

        elif option == 3:  # 输入学生的id，然后弹出需要修改的选选项，输入值进行修改
            ChgDetil = int(input("请输入需要修改的学生id："))
            show_list = show_student_details(StudenDetails_Tmp, ChgDetil)
            print("该学生目前的信息：", show_list)
            chg_name = input("请输入学生的姓名：")
            chg_age = input("请输入学生的年龄：")
            new_student_details = [ChgDetil, chg_name, chg_age]
            st_index = StudenDetails_Tmp.index(show_list)
            StudenDetails_Tmp[st_index] = new_student_details

        elif option == 4:  # 根据学生id查找学生信息  TODO 可改进为根据任意一个字段查找
            ChgDetil = int(input("请输入需要查询的学生id："))
            show_list = show_student_details(StudenDetails_Tmp, ChgDetil)
            tb4 = PrettyTable()
            tb4.field_names = ['StudentID', 'name', 'age']
            tb4.add_row(show_list)
        
            print(tb4)

        elif option == 5:  # 查询所有的学生信息
            tb5 = PrettyTable()
            for idx,v in enumerate(StudenDetails_Tmp):
                if idx == 0:
                    tb5.field_names = v
                if idx > 0:
                    tb5.add_row(v)
     
            print(tb5)
        
        elif option == 6:
            
            save_csv(StudenDetails_Tmp)  #保存为csv格式便于下载
            save(StudenDetails_Tmp)   #数据序列化保存
            print('保存成功：',StudenDetails_Tmp)
            break

        else:
            print('请输入正确的选项(1-6)')
            continue


if __name__ == "__main__":
    if p_save.exists():
        StudenDetails_Tmp = pick_load()
        index_student = [StudenDetails_Tmp[-1][0]]
    else:
        index_student = [0]
    showinfo()
    counter = generate_counter(index_student)
    StudentManagement()
    pick_load()
    # print(StudenDetails_Tmp)

```

    ****************************************
     1.添加学生的信息
     2.删除学生的信息
     3.修改学生的信息
     4.查询学生的信息
     5.遍历所有学生的信息
     6.保存并退出系统
    ****************************************
    请选择您的操作：1
    请输入学生的姓名：zz
    请输入学生的年龄：32
    ****************************************
    请选择您的操作：1
    请输入学生的姓名：xx
    请输入学生的年龄：12
    ****************************************
    请选择您的操作：1
    请输入学生的姓名：张三
    请输入学生的年龄：12
    ****************************************
    请选择您的操作：1
    请输入学生的姓名：44
    请输入正确的年龄（中文或者字母）：jk
    请输入学生的年龄：55
    ****************************************
    请选择您的操作：5
    +-----------+------+-----+
    | StudentID | name | age |
    +-----------+------+-----+
    |     1     |  gg  |  44 |
    |     2     |  gg  |  55 |
    |     3     |  hh  |  66 |
    |     4     |  zz  |  32 |
    |     5     |  xx  |  12 |
    |     6     | 张三 |  12 |
    |     7     |  jk  |  55 |
    +-----------+------+-----+
    ****************************************
    请选择您的操作：4
    请输入需要查询的学生id：2
    +-----------+------+-----+
    | StudentID | name | age |
    +-----------+------+-----+
    |     2     |  gg  |  55 |
    +-----------+------+-----+
    ****************************************
    请选择您的操作：3
    请输入需要修改的学生id：2
    该学生目前的信息： [2, 'gg', '55']
    请输入学生的姓名：xx
    请输入学生的年龄：66
    ****************************************
    请选择您的操作：2
    请输入需要删除的学生id：1
    删除用户成功： [1, 'gg', '44']
    ****************************************
    请选择您的操作：5
    +-----------+------+-----+
    | StudentID | name | age |
    +-----------+------+-----+
    |     2     |  xx  |  66 |
    |     3     |  hh  |  66 |
    |     4     |  zz  |  32 |
    |     5     |  xx  |  12 |
    |     6     | 张三 |  12 |
    |     7     |  jk  |  55 |
    +-----------+------+-----+
    ****************************************
    请选择您的操作：6
    保存成功： [['StudentID', 'name', 'age'], [2, 'xx', '66'], [3, 'hh', '66'], [4, 'zz', '32'], [5, 'xx', '12'], [6, '张三', '12'], [7, 'jk', '55']]



python实现学生管理系统v1

#### 1. 函数基本形式
def 函数名：
    函数体
    [return 返回值]
#### 2. 可变参数


```python
def add(*args):
    print(args)  #参数收集为一个元组
    print(*args)  #参数解构
    print(sum(args))
    
add(2,3,45)

def add_dict(**kwargs):
    print(kwargs)
    print(kwargs['x'])
 
    
    
add_dict(x=1,zz=11)
```

    (2, 3, 45)
    2 3 45
    50
    {'x': 1, 'zz': 11}
    1


#### 3. 参数位置
参数定义顺序为：
1. 普通参数
2. 缺省参数
3. 可变位置参数
4. keyword-only参数（可带缺省值）
5. 可变关键字参数

```python
def fn(x,y,z=3,*args,m=4,n,**kwargs):
    print(x,y,z,m,n)
    print(args)
    print(kwargs)
    
fn(1,223,33,44,5,m=22,n=11,xs= 'dsa')
```

    1 223 33 22 11
    (44, 5)
    {'xs': 'dsa'}


#### 4. 参数解构


```python
def add(x,y):
    return x+y

#解构操作,可迭代对象（线性结构）， *可以看做是迷你型的for i in 形式
print(add(*[1,4]))
print(add(*(1,33)))
print(add(*range(1,3)))
print(add(**{'x':1,"y":1111}))  #字典需要**

def add(*iter):
    return sum(iter)
    
print(add(*[1,2,3,4,5]))
```

    5
    34
    3
    1112
    15


#### 5.  函数的返回值(return)
1. 所有函数都必须有返回值，如果没return语句，默认返回return None
2. 一个函数可以存在多个return，但是只能执行一个。
3. 函数执行到return后，函数就会返回，当前被执行的return语句之后的语句不再执行。

作用：结束函数调用，返回函数结果

```python
def show():
    return 1,3,4

print(show()  )
# 默认封装为一个元组返回
x,y,z = show()
print(x,y,z)  #解构
```

    (1, 3, 4)
    1 3 4


#### 6.  函数的作用域（重点）
全局作用域：
整个程序运行环境可见

局部作用域：
在函数、类的内部可见
局部变量使用的范围不能超过其所在的局部作用域

```python
x = 5  #全局变量

def foo():
    print(x) #可以读取
    #x += 1  #重新定义x，UnboundLocalError
foo()

#foo函数内部可以读到x，但是不能修改它。
```

    5



```python
# global 关键字将函数体内的变量提升为全局，，慎用。
x = 5  #全局变量

def foo():
    global x
    print(x) #可以读取
    x += 1  
foo()

```

    5


#### 7.  闭包
自由变量：未在本地作用域中定义的变量
闭包：内层函数引用到了外层函数自由变量的操作

```python
def counter():
    c = [0]
    def inc():
        c[0] += 1
        
        return c[0]
    
    return inc

foo = counter()
print(foo(),foo())
c = 100
print(foo())
```

    1 2
    3


#### 8. nonloacl关键字
nonlocal关键字可以将变量标记为不在本地作用域定义，而在上一级作用域局中定义，但是不能为全局作用域。

```python
def counter():
    count = 0
    def inc():
        nonlocal count
        count += 1
        return count
    return inc

foo= counter()
print(foo(),foo())
```

    1 2


#### 9. 对象的销毁

del 对象

#### 10.  递归函数
1. 函数直接或者间接的调用自己，就是递归；
2. 递归是很危险的一种操作，使用需要谨慎；
3. 递归一定要有边界条件；
4. python默认的递归层数为3000，具体跟环境相关。

```python
#最大深度获取
import sys
sys.getrecursionlimit()
```




    3000


打印斐波那契数列

```python
def fib(n):
    return 1 if n < 2 else fib(n-1) + fib(n-2)

for i in range(10):
    print(fib(i),end=' ')
```

    1 1 2 3 5 8 13 21 34 55 
字典扁平化，实现效果如下：

源字典  {'a':{'b':1,'c':2},'d':{'e':3,'f':{g:4}}}
目标字典 {'a.b': 1, 'a.c': 2, 'd.e': 3, 'd.f.g': 4}

```python
source = {'a':{'b':1,'c':2},'d':{'e':3,'f':{'g':4}}}

target={}
def flatmap(src,pre=''):
    for k,v in src.items():
 
        if isinstance(v,(list,tuple,set,dict)):
            flatmap(v,pre=pre+k+'.')
        else:
            target[pre+k] = v


flatmap(source)
print(target)
```

    {'a.b': 1, 'a.c': 2, 'd.e': 3, 'd.f.g': 4}

将一个数逆序分别放入列表中，例如1234 => [4,3,2,1]，使用递归。

```python
data = str(1234)

def revert(x):
    if x == -1:
        return ''
    return data[x] + revert(x-1)

print(revert(3))
```

    4321


if 的一行表达式
a if b else c

如果满足b则执行a，否则执行c

```python
a = 6
3 if a> 3 else 4
```




    3




```python
a = 2
3 if a> 3 else 4
```




    4



#### 11. 匿名函数(lambda) 
形式：
(lambda 参数列表：表达式)(传入参数)

匿名函数一般当做其他高阶函数的参数传入，可以实现函数的高级功能。

```python
print((lambda x:x**2)(3))
print((lambda x:x)(33))
```

    9
    33



```python
[x for x in (lambda *args: map(lambda x: (x+1,args), args))(*range(5))]
```




    [(1, (0, 1, 2, 3, 4)),
     (2, (0, 1, 2, 3, 4)),
     (3, (0, 1, 2, 3, 4)),
     (4, (0, 1, 2, 3, 4)),
     (5, (0, 1, 2, 3, 4))]




```python
list(map(lambda x: x + x, [1, 3, 5, 7, 9]))
```




    [2, 6, 10, 14, 18]



#### 12. 生成器 
生成器是可以有生成器表达式得到的一种对象，也可以使用yield关键字生成
生成器表达式？
把列表解析器的[]换成() 就成为了生成器表达式，可以使用next()逐个取值。
或者
使用yield(iterable) 

使用next()关键字取值，超界会报错。

生成器的好处：
延迟计算，惰性求职


```python
def counter():
    i = 0
    while True:
        i += 1
        yield i
def inc(c):
    return next(c)

xx = counter()
print(next(xx))
print(next(xx))
print(next(xx))
print(next(xx))
print(next(xx))
```

    1
    2
    3
    4
    5

yield  from

```python
def inc():
    for x in range(10):
        yield x 
        
foo = inc()
print(next(foo))
print(next(foo))
print(next(foo))

#可以改写为
def inc():
    yield from ['bbq',1,'aax',23]

foo = inc()
print(next(foo))
print(next(foo))
print(next(foo))
```

    0
    1
    2
    bbq
    1
    aax



```python

```

    1



```python

```


```python

```


```python

```


```python

```


python函数1

#### 1. 封装与解构 


```python
a = 4
b = 5
print(a,b)
a,b = b,a
print(a,b)
```


```python
#简单模式
lst = [1,3,(4,4)]
a,b,c = lst
print(a,b,c)

#进阶
a,b,(c,d) = lst
print(a,b,c,d)

tup= (1,2,3)
a,b,c = tup
print(a,b,c)

#_丢弃
#*批量收集
tup= (1,2,3,4,5,6,7,8)
a,b,c,*d,_ = tup
print(*d)
```

#### 2. 线性结构
线性结构：列表、元组、字符串、bytes、bytearray 

线性结构的特点：
1. 可以for... in 
2. 可以len()获取长度
3. 可以通过下标访问
4. 可以切片
5. 查询的时间复杂度为O(n)

非线性结构：
set、dict
元素(dict的key)要求可以hash，查询的时间复杂度为0(1)


```python
# sequence[start:stop:step]
str = 'mykernel'
print(str[1])
print(str[:])
print(str[:-1])
print(str[:-1:2])
print(str[::-1])  #倒序打印
lst =list(str)
print(lst[::-1])
print(bytearray(b'www.mykernel.cn')[-10:-4:2])
```

#### 3. 时间相关操作


```python
import datetime
import time

#格式化
dt1 = datetime.datetime.strptime("21/11/19 14:33",'%d/%m/%y %H:%M')
dt2 = datetime.datetime.strptime("20/11/19 16:30",'%d/%m/%y %H:%M')
print(type(dt1))

#求时间差值
delta = dt1 - dt2
print(type(delta))
print(delta)

#将时间差换算为秒
delta_seconds = delta.total_seconds()
print(delta_seconds)

#sleep
time.sleep(2)
print('sleep 2s')
```

####  4. 列表解析式
[返回值 for 元素 in 可迭代对象 if 条件]

```python
print([i for i in range(10) if i > 3])
print([(x,y) for x in 'asf' for y in range(2)])
```

#### 5. 生成器表达式 
把列表解析器的[]换成() 就成为了生成器表达式，可以使用next()逐个取值。
内存占用少，计算速度“快”

```python
lst = (i for i in range(10) if i > 3)
next(lst)
```
生成器表达式，逐行取值，延迟计算。但是如果取值超出个数则会报错。
#### 6. 集合表达式 
把列表解析器的[]换成{} 就成为了生成器表达式。快速生成一个set。

```python
{i for i in range(10) if i > 3}
```

#### 7. 字典解析式 
{返回值 for 元素 in 可迭代对象 if 条件}  
{k:v 生成k 和 v}

```python
{x:y for x in range(10) for y in [0]}
```


```python
{x:0 for x in range(10)}
```


```python
dict(zip(range(10),[0]*10))
```


```python
list(reversed('str'))
```


```python
''.join(list(reversed('str')))

```

#### 8. 内建函数

id函数


```python
a = 'abc'
print(id(a))
b  = 'abc' 
print(id(b))

#数字，字符串这种常量，在python中的位置是不变的，无论被谁引用，其引用的地址是一样的。

def add(a,b):
    return a + b

print('add function:',id(add))

lst = [1,2,3]
lst1 = [1,2,3]
print('list:',id(lst))
print('list1:',id(lst1))

#函数、字典、列表等类型在内存中的位置是变化的。每次定义所分配的内存地址不一样。
```

hash函数


```python
hash(a)

#列表,字典,集合是无法hash的，因为使用id查看内存地址时候是变化的，，
```

类型转换


```python
#1.字符串转列表
str = "acd"
str_list = list(str)
print('str==>list:',str_list)

#2. “字符串列表”转字符串
lst = ['a','v','k']
list_str = ''.join(lst)
print('list==>str:',list_str)

#3. 字符串转元组
lst = 'accd'
str_tup = tuple(lst)
print('str==>tup：',str_tup)

#4. 字符串转字典的k，v取默认值
lst = 'accd'
print(dict)
str_dv = dict(zip(lst,[0]*len(lst)))
print('str==>dict[k]：',str_dv)

#元组转列表
t = ('a', 'c', 'c', 'd')
print(list(t))

#列表转元组
lst = ['a', 'c', 'c', 'd']
print(tuple(lst))

#列表转set，元组转set 去重。。
t = (1,1,1,1)
print(set(t))

#含有二元组的列表转字典
str = 'mykernel'
lst = [i for i in enumerate(str)]
d = {}
for i in  lst:
    d[i[0]] = i[1]

print(d)

# 字典的kv 互换
print('v<==>k:',dict(zip(d.values(),d.keys())))

lst = [1,1,1,2]
print(set(lst))

#typt 查看对象的类型
print('type :',type(type))



```

输入函数input


```python
ipt = input('请输入一个字符或者数字，默认返回一个字符串')
print(type(ipt))
```

打印函数


```python
print('a','b',sep='\n')  

#sep = 改变打印元组之间的格式
```

长度计算


```python
len('acffsd  '*10)
```

类型确定


```python
a = 2
isinstance(a,(str,int,list)) 
```
sorted(iter,[,key][,reverse])

```python
print(sorted({'c':1, 'b':2, 'a':1}))
print([i for i in reversed(sorted({'c': 1, 'b': 2, 'a': 1}.items(), key=lambda x: x[1]))])
print(sorted({'c': 1, 'b': 2, 'a': 1}.items(), key=lambda x: x[1],reverse=True))

```

reversed（seq） 返回一个迭代器

enumerate(seq,start=0) 枚举

iter(iter) next(iterator)  生成一个迭代器和取迭代器里的元素

zip() 拉链函数


```python
dict1 = {'name':'pxr','age':'20'}

ops = {'age':int}

info = {k:ops.get(k,lambda x:x)(v) for k,v in dict1.items()}

#lambda
#字典解析式
#get
info
```


python基础知识2

本文主要是整理python的基本类型，包括列表、元组、字典、字符串、bytes和集合（set）的基本操作和应用。

#### 1. list


```python
### list：可变，可索引，有序（可索引），元素可重复，使用[]表示

lst = [1,3,'a',('a','b'),'mykernel']

#修改
lst[2] = 'good'
print('1.',lst)
#追加
lst.append('end str')
print('2.',lst)
#插入
lst.insert(3,'gogogog')
print('3.',lst)
#扩展新列表
lst2= ["new","list"]
lst.extend(lst2)
print('4.',lst)
tup = ('a','b')
lst.extend(tup)
print('5.',lst)
# + => list
# * => list，重复
new_list = [1,2]
old_list= [1]
new1= new_list+old_list
print('6.',new1)
new2= new_list*3
print('7.',new2)
#移除,移除找到的第一个，移除所有的如何写？
new2.remove(1)
print('8.',new2)
new2.pop(3) #移除索引为3的
print('9.',new2)
#清空
new2.clear()
#反转
lst.reverse()
print('9.',lst)
#排序
l = [1,1,2,-100]
l.sort()
print('10.',l)

### 进阶
#列表复制,浅拷贝
lst = [1,2,3,4,11,'a',[1,2,4]]
lst1 = lst
lst2 = lst.copy()
lst[6][1] = '1'
print('11.',lst1,'\n   ',lst2)  #原引用里的值改变，新列表也会变

#深拷贝
import copy
lst0 = [1,[2,3,4],5]
lst5 = copy.deepcopy(lst0)
lst0[1][1] = 21
print('12.',lst0,'\n   ',lst5) #lst0 != lst5

#随机数
import random
#从[0-9] 中随机挑选一个值
print('13,',random.randint(0,9))
print('14,',random.choice(range(10)))

#打乱列表
lst6 = copy.deepcopy(lst)
random.shuffle(lst6)
print('15.',lst,'\n   ',lst6)
```
求100以内的素数

```python
# The first solution
import math
p1=[2,3,5,7]
n = 100 
for x in range(10,n):
    for i in range(2,math.ceil(math.sqrt(x))):
        if x % i == 0:
            break
    else:
        p1.append(x)
print(p1)

#The second solution
#合数一定可以分解成几个质数的乘积
import math
n = 100
lst = []
for x in range(2,n): 
    for i in lst: 
        if x % i ==0:
            break
    else:
        lst.append(x)
print(lst)

## optimize code
# 带flag判断，提高程序效率。
import math
lst = [2]
flag = False
for x in range(2,100): #x=13
    for i in p:   #p=[2,3,5,7]
        if x % i ==0:  # x%i != 0 
            flag = True
            break
        if i >= math.ceil(math.sqrt(x)): #i< math.ceil(math.sqrt(x))
            flag = False
            break
    if not flag: #flag = false  ==> true
         lst.append(x)
print(lst)
```
打印杨辉三角（ Pascal's triangle）

```python
# The first solution
# 下一行和上一行的关系

triangle = [[1],[1,1]]
for i in range(2,6):
    cur = [1]
    pre = triangle[i-1]
    for j in range(len(pre)-1):
        cur.append(pre[j]+pre[j+1])
    cur.append(1)
    triangle.append(cur)
print(triangle)

#The second solution
triangle = []
n =6 
for i in range(n):
    row = [1]
    triangle.append(row)
    if i == 0:
        continue
    for j in range(i-1):
        row.append(triangle[i-1][j]+triangle[i-1][j+1])
    row.append(1)
print(triangle)

#Third option ,while
n = 6 
oldline = []
newline = [1]
print(newline)
length = 0 
for i in range(1,n):
    oldline = newline.copy()
    oldline.append(0)
    newline.clear()
    offset = 0 
    while offset <= i:
        newline.append(oldline[offset-1]+ oldline[offset])
        offset +=1
    print(newline)
    
#Third option ,for 
n = 6 
oldline = []
newline = [1]
print(newline)
length = 0 
for i in range(1,n):
    oldline = newline.copy()
    oldline.append(0)
    newline.clear()
    for j in range(i+1):
        newline.append(oldline[j-1]+ oldline[j])
    print(newline)

#Option 4

triangle = []
n = 6

for i in range(n):
    row = [1]*(i+1)
    triangle.append(row)
    if i == 0:
        continue
        
    for j in range(1,i//2+1): #n=3 开始
        val = triangle[i-1][j-1] + triangle[i-1][j]
        row[j] = val
        if i !=2j: #奇数个数的中点跳过
            row[-j-1] = val
print(triangle)
```

#### 2. 元组


```python
# 元组有序（可索引），不可变，小括号()表示，可以重复，只读（不能增删改）
## 对比 list：有序（可索引），可变，使用[]表示，元素可重复
# 定义
print(tuple())
print((2,2))
print(tuple(range(1,7,2)))
```


```python
t = (1,(2,),'a',[1,2],1,2,2,2,1,1,1)
print('1,',(t.index(1))) #返回找到的第一个的索引
print('2,',t.count(1)) #返回value的个数
print('3,',len(t))  #长度

#命名元组
from collections import namedtuple
point = namedtuple('_point',['x','y'])
p = point(21,12)
print('4,',p.x,p.y)

```

冒泡法排序


```python
# 对列表[1,9,8,5,6,7,4,3,2]使用冒泡法进行排序，要求使用封装和解构来交换数据

lst = [1,9,8,5,6,7,4,3,2]
for i in range(len(lst)):
    for j in range(8-i):
        if lst[j]>lst[j+1]: #靠前位置的值大于靠后位置的值，前位置获取小的值。
            lst[j],lst[j+1]=lst[j+1],lst[j]
print(lst)
```

#### 3. 字符串 


```python
# 元组有序（可索引），不可变，小括号()表示，可以重复，只读（不能增删改）
## 对比 list：有序（可索引），可变，使用[]表示，元素可重复
### 字符串是不可变的，有序，使用引号（单双，单双三）
```


```python
str = "my name is mykernel"
lst = []

for i in str:
    lst.append(i)
print(lst)

lst2 = list(str)
print(lst2)
```


```python
#其他相关操作
## split
print('1,','l love python'.split())
# split()的()中指定分隔符
# 默认使用空格作为分隔符

# maxsplit=# 可以指定分隔的次数。
print('2,','my name is  mykernel'.split('m',maxsplit=1))

##rsplit
#分隔符可以是任意字符串。
print('3,','my name is  mykernel'.rsplit('m',maxsplit=1))

#当不用maxsplit= 时候，split和rsplit效果一样，但是split效率更高。

##splitlines
l = """l love python
i am mykernel
"""
print('4,',l.splitlines())

##partition
l = """l love python"""
print('5,',l.partition(' '))

#partition() 不能不传入分隔符，只分隔一次，打印内容，为前半部分、分隔符和后半部分.

print('#'*20,'大小','#'*20) 

#upper
l = """l love python""" #转大写
l2= l.upper()
print('5,',l2)
#lower
l3 = l2.lower()  #转小写
print('6,',l3)

print('#'*20,'替换','#'*20)  
#replace 替换
str = 'i love python'
print('7,',str.replace('love python','am mykernel') ) #前边是旧的字符串，后边是新的字符串。
#控制替换的个数
str = 'i very very very love python '
print('8,',str.replace('very','非常',2))  #替换2个
```


```python
print('#'*20,'去除','#'*20) 
#strip 去掉
str = '   mykernel   love  python   \n'
str2 = str.strip()
#strip 可以加其他字符串，意思就是去掉两端可以匹配到的对应的字符串
print('9,',str2)

#lstrip()只移除左侧部分;
#rstrip()只移除右侧部分。
print('#'*20,'填充','#'*20) 
print('10,','mykernel'.ljust(30))
print('10,','mykernel'.rjust(30))
print('10,','mykernel'.center(30))  #一边15个。。。。

print('11,','mykernel'.ljust(30,'+'))
print('11,','mykernel'.rjust(30,'#'))
print('11,','mykernel'.center(30,'*'))  #一边15个。。。。

print('#'*20,'查找','#'*20) 
#find() 查找返回找到的第一个的索引
str = 'i very very very love python '
print('12,',str.find('very'))
print('12,',str.find('very',5))
print('12,',str.rfind('very',4))
print('12,',str.rfind('very',-20,-1))

#index(sub[, start[, end]])
#在指定的区间，从左到右。找到返回对应的索引值，没找到返回ValueError。

#rindex(sub[, start[, end]])
#在指定的区间，从右到左。找到返回对应的索引值，没找到返回ValueError。

#count 在指定的区间，从左到右，统计子字符串sub出现的次数
str = 'i very very very love python '
print('13,',str.count('very')) 
print('13,',str.count('very',5))
print('13,',str.count('very',5,11))
```


```python
#判断
#startwith()
str = 'i am mykernel,i very very very love python'
print(str.startswith('am'))
print(str.startswith('i'))

## 也可以指定范围进行匹配。
print(str.startswith('am',2,20)) #（2,20]
#endswith()
str = 'i am mykernel,i very very very love python'
print(str.endswith('am'))
print(str.endswith('python'))
```


```python
print('#'*20,'拼接','#'*20) 
# +
print('1,','i'+' love'+' python')
# join
print('2,',' '.join(['i'+' love'+' python']))

print('#'*20,'格式化','#'*20) 
s = 'i love %s' #%s为格式占位符，然后再其他地方可以将参数传入并替换该占位符。
s1 = s%('python',) #将python传入，替换占位符。
print('3,',s1)

##format字符串格式化
#a. format方法可以使用花括号作为占位符，传入的参数将替换花括号。
s = 'i love {}' #{}作为占位符
s1 = s.format('python')
print('4,',s1)
# format方法的参数可以为多个，如果不在括号里指定其位置一一对应引入。
s ='i love {}, i am {}'
s1 = s.format('python','mykernel')  #按照位置传入
print('5,',s1)
# format方法可以在花括号里填入位置数字，其后的参数按照位置引入，从0号位置开始
s ='i love {1}, i am {0}'
s1 = s.format('python','mykernel')
print('6,',s1)
s ='i love {0}, i am {0}'
s1 = s.format('python','mykernel')
print('7,',s1)

#format方法可以用字符作为占位符的标志，方便识别。
s1='i love {language},i am {name}'.format(language='python',name='mykernel')
print('8,',s1)

#format方法的占位符可以混用，但是位置参数必须放在最前。
s1 = 'my name is {0},i love {language},i am {age}'.format('mykernel',language='pyrhon',age=18)
print('9,',s1)

```
说明1：

占位符的个数大于参数个数的时候，会抛出异常IndexError。
占位符的个数小于参数个数的时候，若对应的占位符能匹配到值则不报错，匹配不到值会返回异常。
当占位符出现混用的情况时，位置参数不在最前会返回异常。
说明2：

通常使用2.6或之后的版本使用format方法，2.6之前使用printf style。
在format中，需要注意的是，在2.6版本中是不能省略大括号里面的数字或者关键字。
**字符串对齐**


```python
print('{0}*{1}={2:<4}'.format(3,2,2*3))  #右边4个空格
print('{0}*{1}={2:>4}'.format(3,2,2*3))
print('{0}*{1}={2:<04}'.format(3,2,2*3))
print('{:^30}'.format('centered'))  #左右各30个空格
print('{:*^30}'.format('centered')) 
```


```python
## 演变过程
print('{}'.format(1))
#右对齐
print('{:>8}'.format(1))

print('{:^{}}'.format(1,11))

#格式填充^、<、>分别是居中、左对齐、右对齐，后面带宽度
```

#### 4. bytes和bytearray


```python
# 元组有序（可索引），不可变，小括号()表示，可以重复，只读（不能增删改）
## 对比 list：有序（可索引），可变，使用[]表示，元素可重复
### 字符串是不可变的，有序，使用引号（单双，单双三）
#### bytes是不可变的字节序列，bytearray是可变的字节序列

```


```python
# str -> bytes
str = 'abc'
bys = str.encode()
print(bys)

#bytes -> str
str1 = bys.decode()
print(str1)

#生成bytearray
bar = bytearray(1)
bar1 = bytearray(b'123')
print(bar,bar1)

#bytearray的相关方法

b = bytearray()
b.append(97)
b.append(99)
b.insert(1,98)
b.extend([65,66,67])
b.extend(bytearray(b'aavv'))
print(b)
b.remove(66)
print(b)
b.pop()
print(b)
b.reverse()
print(b)
b.clear()
print(b)
```

字符串转16进制


```python
bytearray('abc'.encode()).hex()
```




    '616263'



#### 5. set


```python
# 元组有序（可索引），不可变，小括号()表示，可以重复，只读（不能增删改）
## 对比 list：有序（可索引），可变，使用[]表示，元素可重复
### 字符串是不可变的，有序，使用引号（单双，单双三）
#### bytes是不可变的字节序列，bytearray是可变的字节序列
##### set叫集合，元素可变（元素需要可hash）、无序（无法索引,可以迭代）、不重复（去重？？）
```


```python
#定义
s1 = {(1,),1,'1',b'1'}
print('1,',s1)

#增加元素,元素存在则什么都不做
s1.add('a')
print('2,',s1)

s1.update([1,2,3,4])  #update中为可迭代对象即可
print('3,',s1)
s1.update('str 11')  #注意字符串一个字符算一个元素
print('4,',s1)

#删除
s1.remove(1) #移除的元素不存在 报错
print('5,',s1)  
s1.discard('1') #移除的元素不存在  不报错
print('6,',s1)
print(s1.pop()) # -> item ,任意移除一个元素，s1为空报错
print('7,',s1)

#清除
s1.clear()
print('8,',s1)

#其他
#1. set 不能修改
#2. set 非线性结构不能查询
#3. set 无序，但是可以for in 迭代，无法索引

#可以使用in 或者 not in 判断元素是否存在，效率极高。因为元素为hash存放
```

    1, {1, b'1', '1', (1,)}
    2, {1, (1,), 'a', b'1', '1'}
    3, {1, 2, 3, 4, (1,), 'a', b'1', '1'}
    4, {1, 2, 3, 4, (1,), 'a', 'r', 's', ' ', b'1', '1', 't'}
    5, {2, 3, 4, (1,), 'a', 'r', 's', ' ', b'1', '1', 't'}
    6, {2, 3, 4, (1,), 'a', 'r', 's', ' ', b'1', 't'}
    2
    7, {3, 4, (1,), 'a', 'r', 's', ' ', b'1', 't'}
    8, set()

集合的运算

交差并补
#### 6. dict


```python
# 元组有序（可索引），不可变，小括号()表示，可以重复，只读（不能增删改）
## 对比 list：有序（可索引），可变，使用[]表示，元素可重复
### 字符串是不可变的，有序，使用引号（单双，单双三）
#### bytes是不可变的字节序列，bytearray是可变的字节序列
##### set叫集合，元素可变（元素需要可hash）、无序（无法索引,可以迭代）、不重复（去重？？）
###### dict，k-v组合，可变，无序，key不能重复
```


```python
d = {'k':'v','1':2,'aa':[1,2,3],'bb':(32,2)}
print(d)
#访问
print('1,',d['k'])
print('2,',d.get('ss',6))  #6为设置的默认值（可省），k不存在则返回默认值
print('3,',d.setdefault('k',5))  #5为设置的默认值（可省），如果key不存在则添加kv对

print('1，',d)

#添加
d['new'] = 44  #key存在就修改，不存在就添加
print('2，',d)

d.update({'new1':1,"new2":2})  #添加一个对象，只能是字典
d.update(red=1)
d.update((('red1',1),))
print('3，',d)

#删除
d.pop('k')  #key存在就删除并返回value，不存在返回默认值，无默认值报错
d.popitem() #随机删除一个kv对，dict为空则报错
print('4，',d)

#清空
d.clear()
print('5，',d)
```

    {'k': 'v', '1': 2, 'aa': [1, 2, 3], 'bb': (32, 2)}
    1, v
    2, 6
    3, v
    1， {'k': 'v', '1': 2, 'aa': [1, 2, 3], 'bb': (32, 2)}
    2， {'k': 'v', '1': 2, 'aa': [1, 2, 3], 'bb': (32, 2), 'new': 44}
    3， {'k': 'v', '1': 2, 'aa': [1, 2, 3], 'bb': (32, 2), 'new': 44, 'new1': 1, 'new2': 2, 'red': 1, 'red1': 1}
    4， {'1': 2, 'aa': [1, 2, 3], 'bb': (32, 2), 'new': 44, 'new1': 1, 'new2': 2, 'red': 1}
    5， {}


遍历字典


```python
d = {'1': 2, 'aa': [1, 2, 3], 'bb': (32, 2)}
#打印k
for k in d.keys():
    print(k)
print('='*40)
#打印value
for v in d.values():
    print(v)
print('='*40)   
#遍历items
for it in d.items():
    print(it)
print('='*40)     
for k,v in d.items():
    print(k,v)  #接轨
```

    1
    aa
    bb
    ========================================
    2
    [1, 2, 3]
    (32, 2)
    ========================================
    ('1', 2)
    ('aa', [1, 2, 3])
    ('bb', (32, 2))
    ========================================
    1 2
    aa [1, 2, 3]
    bb (32, 2)


有序字典


```python
from collections import OrderedDict
od = OrderedDict()
od['k'] = 'v'
od
```




    OrderedDict([('k', 'v')])


习题1. 用户输入一个数字，打印每一位数字及其重复的次数

```python
str = "11gghhbsdsa"
d = {}
for i in str:
    d[i] = str.count(i)

print(d)
```

    {'1': 2, 'g': 2, 'h': 2, 'b': 1, 's': 2, 'd': 1, 'a': 1}

习题2.  数字重复统计：
1.随机产生100个整数
2. 数字的范围[-1000,1000]
3. 降序序输出所有不同的数字及其重复的次数

```python
import random
lst = random.choices(range(-50,51),k=100)
d = dict(zip(lst,[0]*10))

for k in d.keys():
    d[k] = lst.count(k)

sorted(d.items(),key = lambda x:x[1],reverse=True)
```




    [(20, 6), (-17, 4), (-30, 3), (41, 3), (-19, 2), (-1, 2), (-47, 2), (-9, 1)]

python基础知识1

#### 1. 函数基本形式
def 函数名：
    函数体
    [return 返回值]
#### 2. 可变参数


```
def add(*args):
    print(args)  #参数收集为一个元组
    print(*args)  #参数解构
    print(sum(args))
    
add(2,3,45)

def add_dict(**kwargs):
    print(kwargs)
    print(kwargs['x'])
 
    
    
add_dict(x=1,zz=11)
```

    (2, 3, 45)
    2 3 45
    50
    {'x': 1, 'zz': 11}
    1


#### 3. 参数位置
参数定义顺序为：
1. 普通参数
2. 缺省参数
3. 可变位置参数
4. keyword-only参数（可带缺省值）
5. 可变关键字参数

```
def fn(x,y,z=3,*args,m=4,n,**kwargs):
    print(x,y,z,m,n)
    print(args)
    print(kwargs)
    
fn(1,223,33,44,5,m=22,n=11,xs= 'dsa')
```

    1 223 33 22 11
    (44, 5)
    {'xs': 'dsa'}


#### 4. 参数解构


```
def add(x,y):
    return x+y

#解构操作,可迭代对象（线性结构）， *可以看做是迷你型的for i in 形式
print(add(*[1,4]))
print(add(*(1,33)))
print(add(*range(1,3)))
print(add(**{'x':1,"y":1111}))  #字典需要**

def add(*iter):
    return sum(iter)
    
print(add(*[1,2,3,4,5]))
```

    5
    34
    3
    1112
    15


#### 5.  函数的返回值(return)
1. 所有函数都必须有返回值，如果没return语句，默认返回return None
2. 一个函数可以存在多个return，但是只能执行一个。
3. 函数执行到return后，函数就会返回，当前被执行的return语句之后的语句不再执行。

作用：结束函数调用，返回函数结果

```
def show():
    return 1,3,4

print(show()  )
# 默认封装为一个元组返回
x,y,z = show()
print(x,y,z)  #解构
```

    (1, 3, 4)
    1 3 4


#### 6.  函数的作用域（重点）
全局作用域：
整个程序运行环境可见

局部作用域：
在函数、类的内部可见
局部变量使用的范围不能超过其所在的局部作用域

```
x = 5  #全局变量

def foo():
    print(x) #可以读取
    #x += 1  #重新定义x，UnboundLocalError
foo()

#foo函数内部可以读到x，但是不能修改它。
```

    5



```
# global 关键字将函数体内的变量提升为全局，，慎用。
x = 5  #全局变量

def foo():
    global x
    print(x) #可以读取
    x += 1  
foo()

```

    5


#### 7.  闭包
自由变量：未在本地作用域中定义的变量
闭包：内层函数引用到了外层函数自由变量的操作

```
def counter():
    c = [0]
    def inc():
        c[0] += 1
        
        return c[0]
    
    return inc

foo = counter()
print(foo(),foo())
c = 100
print(foo())
```

    1 2
    3


#### 8. nonloacl关键字
nonlocal关键字可以将变量标记为不在本地作用域定义，而在上一级作用域局中定义，但是不能为全局作用域。

```
def counter():
    count = 0
    def inc():
        nonlocal count
        count += 1
        return count
    return inc

foo= counter()
print(foo(),foo())
```

    1 2


#### 9. 对象的销毁

del 对象

#### 10.  递归函数
1. 函数直接或者间接的调用自己，就是递归；
2. 递归是很危险的一种操作，使用需要谨慎；
3. 递归一定要有边界条件；
4. python默认的递归层数为3000，具体跟环境相关。

```
#最大深度获取
import sys
sys.getrecursionlimit()
```




    3000


打印斐波那契数列

```
def fib(n):
    return 1 if n < 2 else fib(n-1) + fib(n-2)

for i in range(10):
    print(fib(i),end=' ')
```

    1 1 2 3 5 8 13 21 34 55 
字典扁平化，实现效果如下：

源字典  {'a':{'b':1,'c':2},'d':{'e':3,'f':{g:4}}}
目标字典 {'a.b': 1, 'a.c': 2, 'd.e': 3, 'd.f.g': 4}

```
source = {'a':{'b':1,'c':2},'d':{'e':3,'f':{'g':4}}}

target={}
def flatmap(src,pre=''):
    for k,v in src.items():
 
        if isinstance(v,(list,tuple,set,dict)):
            flatmap(v,pre=pre+k+'.')
        else:
            target[pre+k] = v


flatmap(source)
print(target)
```

    {'a.b': 1, 'a.c': 2, 'd.e': 3, 'd.f.g': 4}

将一个数逆序分别放入列表中，例如1234 => [4,3,2,1]，使用递归。

```
data = str(1234)

def revert(x):
    if x == -1:
        return ''
    return data[x] + revert(x-1)

print(revert(3))
```

    4321


if 的一行表达式
a if b else c

如果满足b则执行a，否则执行c

```
a = 6
3 if a> 3 else 4
```




    3




```
a = 2
3 if a> 3 else 4
```




    4



#### 11. 匿名函数(lambda) 
形式：
(lambda 参数列表：表达式)(传入参数)

匿名函数一般当做其他高阶函数的参数传入，可以实现函数的高级功能。

```
print((lambda x:x**2)(3))
print((lambda x:x)(33))
```

    9
    33



```
[x for x in (lambda *args: map(lambda x: (x+1,args), args))(*range(5))]
```




    [(1, (0, 1, 2, 3, 4)),
     (2, (0, 1, 2, 3, 4)),
     (3, (0, 1, 2, 3, 4)),
     (4, (0, 1, 2, 3, 4)),
     (5, (0, 1, 2, 3, 4))]




```
list(map(lambda x: x + x, [1, 3, 5, 7, 9]))
```




    [2, 6, 10, 14, 18]



#### 12. 生成器 
生成器是可以有生成器表达式得到的一种对象，也可以使用yield关键字生成
生成器表达式？
把列表解析器的[]换成() 就成为了生成器表达式，可以使用next()逐个取值。
或者
使用yield(iterable) 

使用next()关键字取值，超界会报错。

生成器的好处：
延迟计算，惰性求职


```
def counter():
    i = 0
    while True:
        i += 1
        yield i
def inc(c):
    return next(c)

xx = counter()
print(next(xx))
print(next(xx))
print(next(xx))
print(next(xx))
print(next(xx))
```

    1
    2
    3
    4
    5

yield  from

```
def inc():
    for x in range(10):
        yield x 
        
foo = inc()
print(next(foo))
print(next(foo))
print(next(foo))

#可以改写为
def inc():
    yield from ['bbq',1,'aax',23]

foo = inc()
print(next(foo))
print(next(foo))
print(next(foo))
```

    0
    1
    2
    bbq
    1
    aax



```

```

    1



```

```


```

```


```

```


```

```
