周记录（第二周）

第二周周记
1.递归函数

如果一个函数在内部调用自己本身，这个函数就是递归函数。

Ps.(1) 递归函数必须是自己调用自己
   (2) 递归函数必须有一个明确的递归结束条件，即为递归出口。否则就会一只调用下去，直到调用的层数越来越多，栈溢出递归函数是一层一层的进入，再一层一层的返回。

2.回调函数

如果在一个函数中要求传递的参数是一个函数作为参数，并且在函数中使用了传递进来的函数，那么这个函数我们就可以称为是一个回调函数。

回调的过程就是指将回调函数作为参数传到另一个函数里面，当那个函数执行完后，再执行回调函数。

3.闭包函数

闭包函数是指在函数内返回的一个内函数。同时，这个返回的内函数（闭包函数）还使用了外函数中局部变量。

Ps. （1）在外函数中定义了局部变量，并且在内部函数中使用了这个局部变量，它使外部访问函数内部变量成为可能。
    （2）闭包函数保护了外函数中的局部变量，既可以被使用，又不会被破坏。
    （3）检测一个函数是否为闭包函数，可以使用 函数名.__closure__，如果是闭包函数返回 cell。
    （4）局部变量会常驻在内存中。

4.匿名函数 lambda 表达式

匿名函数就是没有名字的函数，可以不使用def定义。

匿名函数冒号后只能有一个表达式。匿名函数自带return，而return的结果就是表达式的计算后的结果。

在python中可以使用lambda表达式来定义匿名函数。

lambda表达式仅仅是一个表达式，不是一个代码块，所以lambda又称为一行代码的函数。同时，lambda表达式也有行参，并且不能访问除了自己的行参之外的任何数据包括全局变量。

5.迭代器

     能被next()函数调用，并不断返回下一个值的对象称为迭代器（Iterator）。
    
     Python中的迭代器不仅可以遍历序列对象，也可以遍历非序列对象，例如遍历字典的所有键，集合的所有成员等等。它是python中最具特色的功能之一。
     迭代器从前往后一个一个的遍历，不能后退，直到集合中的所有元素被访问完毕。
  
使用方法：iter()函数可以从可迭代对象中获得该对象的迭代器，然后使用迭代器的next()方法获取对象。

取值方案：（1）next() 调用一次获取一次，直到数据被取完。 
         （2）list() 使用list函数直接取出迭代器中的所有数据。 
         （3）for 使用for循环遍历迭代器的数据。 

6.内调函数
6.1数据类型转换相关内置函数

- int() 将其它类型数据转为整型
- float() 转为浮点类型
- bool() 转为布尔类型
- complex() 转为复数
- str() 转为字符串类型
- list 转为列表类型
- tuple 转为元组类型
- dict 转为字典类型
- set 转为集合类型

6.2变量相关函数

- id()    获取当前数据的ID标识
- type()  获取当前数据的类型字符串
- print() 数据的打印
- input() 获取输入的数据
- isinstance() 检测是否为指定的数据类型

6.3数学相关函数

- abs() 获取一个数的绝对值
- sum() 求和 
- max() 获取最大值
- min()获取最小值
- pow() 幂运算:返回 x 的 y 次幂
- round() 四舍五入

6.4进制相关函数

- bin() 将数值类型转为二进制
- int() 将二进制转为整型
- oct() 转为八进制数   
- hex() 转为十六进制数 

6.5range函数

range(start, stop[, step])，它能够生成一个指定的数字序列。
    start: 计数从 start 开始，默认是从 0 开始。
    stop: 计数到 stop 结束，但不包括 stop。
    step：步长，默认为1。

6.6zip函数

zip 函数是可以接受多个可迭代的对象，然后把每个可迭代对象中的第i个元素组合在一起成一个个元组，然后返回由这些元组组成的列表。

7.高阶函数

高阶函数就是一个函数可以用来接收另一个函数作为参数。

常见的高阶函数：

7.1.filter()

filter()用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

语法：filter(function, iterable),其中function为判断函数，iterable为可迭代对象，返回值是返回列表。

7.2Map()

Map()用于接收一个函数 f 和一个或多个序列list，并通过把函数 f 依次作用在 序列list 的每个元素上，得到一个新的 list 并返回。

语法：map(function, iterable, ...)其中iterable 是一个或多个序列，返回值是迭代器。

7.3educe()

educe()函数接收的参数和 map()类似，但是行为不同。reduce() 函数会对参数序列中元素进行累积。reduce()传入的函数 f 必须接收两个参数,用传给 reduce 中的函数 f（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 f 函数运算，最后得到一个结果。

语法：reduce(function, iterable[, initializer])其中initializer可选，是初始参数。

7.4Sorted()

Sorted()函数把可迭代数据里面的元素，一个一个的取出来，放到key这个函数中进行处理，并按照函数中return的结果进行排序，返回一个新的列表

语法：sorted(iterable[, cmp[, key[, reverse]]])其中iterable是可迭代对象。cmp 是比较的函数，它具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。key 则主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。另外，reverse为排序规则，reverse = True 降序 ， reverse = False 升序。返回值是重新排序的列表。

8.经典练习
8.1

8.2

8.3`

# 定义stuinfo函数，显示程序功能界面
def stuinfo():
    print('=' * 18)
    print('  学生管理系统')
    print('1.添加学生的信息')
    print('2.删除学生的信息')
    print('3.修改学生的信息')
    print('4.查询学生的信息')
    print('5.遍历所有学生的信息')
    print('0.退出系统')
    print('=' * 18)


# 定义list1列表来存储学生的信息
list1 =[{'name':'张三','id':'123','age':'25'},{'name':'李四','id':'124','age':'24'}]
# 调用函数，使用户看到函数所规定功能
while True:
    stuinfo()
    break
# 让用户选择要执行的功能
n = int(input(" 请选择功能（序号):   "))
# 选择功能1，执行添加功能
if n == 1:
    name = input('请输入学生姓名: ')
    stuid = input('请输入学生学号(学号不可重复): ')
    age = input('请输入学生年龄: ')
    # 验证学号是否唯一
    i = 0
    leap = 0
    for l in list1:
        if l['id'] == stuid:
            leap = 1
            break
        else:
            i += 1
    if leap == 1:
        print("学号重复，添加失败 ")
    else:
        # 定义一个字典stu来存放学生信息
        stu = {}
        stu['name'] = name
        stu['id'] = id
        stu['age '] = age
        # 将学生信息放入列表
        list1.append(stu)
        print("添加成功! ")

# 选择功能2，执行删除功能
elif n == 2:
    print("您选择了删除学生功能")
    delid = input("请输入要删除的学生学号:")
    # 找到要删除的学号
    i = 0
    leap = 0
    for l in list1:
        if l['id'] == delid:
            leap = 1
            break
        else:
            i += 1
    if leap == 0:
        print('无此学号，删除失败')
    else:
        del list1[i]
        print('删除成功!')

# 选择功能3，执行修改功能
elif n == 3:
    print("您选择了修改学生功能")
    alterid = input("请输入要修改的学生学号:")
    # 找到要修改的学号
    i = 0
    leap = 0
    for l in list1:
        if l['id'] == alterid:
            leap = 1
            break
        else:
            i += 1
    if leap == 1:
        newid = input("输入更改后的学号:")
        # 验证修改后的学号是否唯一
        i = 0
        leap1 = 0
        for l1 in list1:
            if l1['id'] == newid:
                leap1 = 1
                break
            else:
                i += 1
        if leap1 == 1:
            print("输入学号不可重复，修改失败! ")
        else:
            l1['id'] = newid
            print("学号修改成功")
    else:
        print('无此学号')

# 选择功能4，执行查询功能
elif n == 4:
    print("您选择了查询学生功能")
    searchid = input("请输入要查询的学生学号:")
    # 找到要查询的学号
    i = 0
    leap = 0
    for l in list1:
        if l['id'] == searchid:
            leap = 1
            break
        else:
            i += 1
    if leap == 0:
        print("无此学号，查询失败! ")
    else:
        print("找到此学生，信息如下: ")
        print("stuId\t姓名\t年龄")
        print( "%s\t\t%s\t%s "%(l['id'],l['name'],l['age']))

# 选择功能5，执行遍历功能
elif n == 5:
#遍历并输出所有学生的信息
    print('='*18)
    print("接下来进行遍历所有的学生信息...")
    print("stuId\t姓名\t年龄")
    for l in list1:
        print( "%s\t\t%s\t%s "%(l['id'],l['name'],l['age']))
    print("="*18)

# 选择功能0，执行退出功能
elif n == 0:
    print('退出系统')

#未输入0-5的选择
else:
    print('请输入正确序号')

一--------------------个--------------------分----------------------割-------------------线---------------------

数据类型

1.常用字符串函数

str='www.kaikeba.com'

#1.capitalize()将字符串的第一个字符转换为大写。
s = str.capitalize()
print(s)

#2.str.center(width[, fillchar])返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
s = str.center(20,'*')
print(s)

#3.str.count(sub, start= 0,end=len(string))用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
s = str.count('w')
print(s)

#4.str.encode(encoding='UTF-8',errors='strict')以指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案。
s = str.encode('GBK')
print(s)

#5.str.find(str, beg=0, end=len(string))检测字符串中是否包含子字符串 str ，
# 如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，
# 如果指定范围内如果包含指定索引值，返回的是索引值在字符串中的起始位置。如果不包含索引值，返回-1。
s = str.find('kaikeba')
print(s)

#6.str.index(str, beg=0, end=len(string))检测字符串中是否包含子字符串 str ，
# 如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，
# 该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。
s = str.index('w')
print(s)

#7.isalnum()检测字符串是否由字母和数字组成。
s = str.isalnum()
print(s)

#8.isalpha()如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False。
s = str.isalpha()
print(s)

#9.isdigit()如果字符串只包含数字则返回 True 否则返回 False。
s = str.isdigit()
print(s)

#10.islower()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False。
s = str.islower()
print(s)

#11.isnumeric()如果字符串中只包含数字字符，则返回 True，否则返回 False。
s = str.isnumeric()
print(s)

#2.isspace()如果字符串中只包含空白，则返回 True，否则返回 False。
s = str.isspace()
print(s)

#13.isupper()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False。
s = str.isupper()
print(s)

#14.join(seq)以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串。
s1=' '
s2=''
s3='-'
s1 = s1.join(str)
s2 = s2.join(str)
s3 = s3.join(str)
print(s1)
print(s2)
print(s3)

#15.len()返回字符串长度。
s = len(str)
print(s)

#16.lower()转换字符串中所有大写字符为小写。
s = str.lower()
print(s)

#17.lstrip()截掉字符串左边的空格或指定字符。
s = str.lstrip('w')
print(s)

#18.max()返回字符串 str 中最大的字母。
s = max(str)
print(s)

#19.min()返回字符串 str 中最小的字母。
s = min(str)
print(s)

#20.replace()把将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
s = str.replace('ww','cc')
print(s)

#21.split()以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串。
s1='k'
s = str.split(s1)
print(s)

#22.swapcase()将字符串中大写转换为小写，小写转换为大写。
s = str.swapcase()
print(s)

#23.upper()转换字符串中的小写字母为大写。
s = str.upper()
print(s)

2.常用列表函数

list1 = ['开课吧','新职课','师徒制']

#1.len()列表元素个数。
print(len(list1))

#2.max()返回列表元素最大值。
print(max(list1))

#3.min()返回列表元素最小值。
print(min(list1))

#4.list()将元组转换为列表。
print(list(list1))

#5.list.append()在列表末尾添加新的对象。
list1.append('快乐')
print(list1)

#6.list.count()统计某个元素在列表中出现的次数。
print(list1.count('新职课'))

#7.list.extend()在列表末尾一次性追加另一个序列中的多个值。
list1.extend(range(7))
print(list1)

#8.list.index()从列表中找出某个值第一个匹配项的索引位置。
print(list1.index('新职课'))

#9.list.insert()将对象插入列表。
list1.insert(0,'开心')
print(list1)

#10.list.pop()移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
print(list1.pop())

#11.list.remove()移除列表中某个值的第一个匹配项。
list1.remove(1)
print(list1)

#12.list.reverse()反向列表中元素。
list1.reverse()
print(list1)

#13.list.sort()对原列表进行排序。
list2 = [4,2,3,1]
list2.sort()
print(list2)

#14.list.clear()清空列表。
list1.clear()
print(list1)

#15.list.copy()复制列表。
list3=list2.copy()
print(list3)

3.常用元组函数

tuple1 = ('开课吧','新职课','师徒制')

#1.len()计算元组元素个数。
print(len(tuple1))

#2.max()返回元组中元素最大值。
print(max(tuple1))

#3.min()返回元组中元素最小值。
print(min(tuple1))

#4.tuple()将列表转换为元组。
print(tuple(tuple1))

4.常用字典函数

dict = {'name':'开课吧','age':10,'city':'bj'}

#1.len()计算字典元素个数，即键的总数。
print(len(dict))

#2.str()输出字典，以可打印的字符串表示。
print(str(dict))

#3.type()返回输入的变量类型，如果变量是字典就返回字典类型。
print(type(dict))

#4.clear()清空字典。
dict.clear()
print(dict)

#5.copy()拷贝字典。
dict1=dict.copy()
print(dict1)

#6.fromkeys()用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
print(dict.fromkeys([1,2,3],[10,20,30]))

#7.get()提取键中对应值。
print(dict.get('name'))

#8.key in dict如果键在字典dict里返回true，否则返回false。
print('bj' in dict)
print('name' in dict)

#9.items()以列表返回可遍历的(键, 值) 元组数组。
dict1=[(k,v) for k,v in dict.items()]
print(dict1)

#10.keys()以列表返回一个字典所有的键。
dict1=dict.keys()
print(dict1)

#11.update()把字典dict2的键/值对更新到dict里。
dict1={1:2}
dict.update(dict1)
print(dict)

#12.values()取字典中的值。
print(dict.values())

#13.popitem()随机返回并删除字典中的最后一对键和值。
dict1=dict.popitem()
print(dict)
print(dict1)

5.常用集合函数

set1 = {'开课吧','新职课','师徒制'}

#1.add()为集合添加元素。
set1.add('闯关制')
print(set1)

#2.clear()清空集合。
set1.clear()
print(set1)

#3.copy()拷贝一个集合。
set1 = {'开课吧','新职课','师徒制'}
set2 = set1.copy()
print(set2)

#4.difference()返回多个集合的差集。
set3 = {'开课吧','你学到哪里啦'}
set2 = set1.difference(set3)
print(set2)

#5.difference_update()移除集合中的元素，该元素在指定的集合也存在。
set1.difference_update(set3)
print(set1)

#6.discard()指定删除集合中的元素，不存在也不会报错。
set1.discard('新职课')
print(set1)

#7.intersection()返回集合的交集。
set1 = {'开课吧','新职课','师徒制'}
set2 = set1.intersection(set3)
print(set2)

#8.isdisjoint()检测是否不相交， 不相交返回True，相交则返回False。
set2 = set1.isdisjoint(set3)
print(set2)

#9.pop()随机移除元素。
set1.pop()
print(set1)

#10.remove()指定删除集合中的元素 remove() 返回None，不存在则报错。
set1.remove('新职课')
print(set1)

#11.symmetric_difference()返回两个集合中不重复的元素集合。
set2 = set1.symmetric_difference(set3)
print(set2)

#12.union()返回两个集合的并集。
set2 = set1.union(set3)
print(set2)

#13.update()更新集合，添加元素。
set1 = {'开课吧','新职课','师徒制'}
set1.update(set3)
print(set1)

以上内容采用了开课吧提供的学习资料与百度搜索资料。