"""author = drh"""

"""
0.列表(list)
[元素1, 元素2,...] [元素]
可变，有序
元素可以任意类型的数据，可以重复
元素的增删改查
相关运算和方法

1.元祖(tuple)
(元素1,元素2,...) 元素1,元素2,... (元素,)
不可变,有序
元素可以任意类型的数据，可以重复
获取元素的值
相关运算

2.字典(dict)
{key1:value1, key2:value2,...} {}
可变，无序
元素是键值对;键不可变并且唯一；值可以任意类型的数据，可以重复
元素的增删改查
相关运算和方法

3.集合(set)
{元素1,元素2,...} set()
可变，无序
元素不可变并且唯一
元素的增删查；数学集合运算
相关运算

"""
"""author = drh"""

导入random模块

import random

"""
1.什么是函数
函数就是对实现某一特定功能的代码段的封装

2.函数的分类
系统函数: 系统已经给我们定义好的函数，程序员直接调用函数使用函数的功能
print(), input(), id(), type(), chr(), bin()...sum()

自定义函数: 需要程序员自己去定义的函数

3.函数的定义/声明 -- 造机器
a.语法：
def 函数名(参数列表):
函数体

b.说明
def - python中声明函数的关键字
函数名 - 标识符,不能是关键字;
PEP8命名规范, 见名知义(看到函数名大概知道函数的功能)
() - 固定格式
参数列表 - 参数1,参数2,参数3...; 这儿的参数叫形参,
定义的时候形参就是变量
功能是将函数外面的数据传递到函数里面
: - 固定格式
函数体 - 一个完整的函数体包含：函数说明文档、实现函数功能的代码段、函数返回值

c.初学者声明函数的步骤
第一步：确定函数的功能
第二步: 根据功能确定函数名
第三步：确定形参(确定需不需要参数，确定需要几个参数)
看实现函数的功能需不需要从函数外面传值进来？需要传几个？
第四步：实现函数的功能
第五步：确定函数返回值

(重点!!!!)注意:声明函数的时候不会执行函数体！只有在调用的时候才会执行

4.函数的调用 - 使用机器
a.语法:
函数名(实参列表)
b.说明:
函数名 - 这个函数名对应的函数必须是已经声明过的函数
() - 固定写法
实参列表 - 实参是用来给形参赋值(用实参给形参赋值的过程加传参)
实参和形参要一一对应

c.函数的调用过程(重点！！！！)
第一步: 回到函数声明的位置
第二步: 用实参给形参赋值(传参)
第三步：执行函数体
第四步：执行完函数体就确定并返回返回值
第五步: 再回到函数调用的位置，接着执行后面的其他代码
"""

声明函数

写一个函数，求两个数的和

def yt_sum(num1, num2):
"""
求两个数的和(函数功能说明) :param num1: 求和的第一个数（参数说明）:param num2: 求和的第二个数 :return: 无（返回值说明）
"""
# num1, num2 = 10, 20
print('==============')
print(num1, num2)
print(num1+num2)

调用函数

yt_sum(10, 20)
print('~~~~~~~~~')

练习1：声明一个函数，打印指定数的阶层, n!

def factorial(n):
"""求指定数的阶乘"""
sum1 = 1
for x in range(1, n+1):
sum1 *= x
print('%d的阶乘是:%d' % (n, sum1))

factorial(4)

注意：一个函数可以调用多次

factorial(10)

练习2：声明一个函数，打印指定列表中指定元素对应的下标

def list_index(list1, item):
"""打印指定列表(list1)中指定元素(item)对应的下标"""
count = 0 # 保存指定列表中指定元素的个数
for index in range(len(list1)):
if list1[index] == item:
print(index, end=' ')
count += 1

if count == 0:
    print('列表中没有指定元素!')

list_index([1, 2, 3, 1, 8, 19], 1)

练习3：声明一个函数，函数功能是猜数字游戏：

"""
随机产生一个0-100的数字，用户不断的输入数字，知道输入的数字和产生数字一样游戏就结束
当猜错了，可以给出'大了'/'小了'这样的提示

27
请输入数字(0-100): 50
大了，再小点儿
请输入数字(0-100): 20
小了，再大点儿
请输入数字(0-100): 27
猜对了！
"""

"""
randint(M,N) - 产生一个M到N的随机整数
"""
print()
num = random.randint(0, 10)

print(num)

def number_game():
"""猜数字游戏"""
print('===========游戏开始===============')
# 随机数
num = random.randint(0, 100)
# 猜的次数
count = 0
while True:
# 输入数字
input_num = int(input('请输入数字(0-100):'))
count += 1#（数日一次计数一次）
# 判断是否猜对了
if input_num == num:
print('猜对了!')

        if count > 7:
            print('可以考虑换个脑袋!')
        elif count > 4:
            print('正常人!')
        else:
            print('天才！！')

        # 游戏束结
        print('===========游戏结束===============')
        break#(break一定要结束而且不继续下面的循环，而且要和循环开头对齐)
    else:
        if input_num > num:
            print('大了，再小点儿!')
        else:
            print('小了，再大点儿')

number_game()
"""author = drh"""
"""
1.位置参数和关键字参数(根据实参的传递方式对参数进行的分类)
a.位置参数：实参位置和形参保持一致，按形参声明的先后顺序一一赋值
b.关键字参数：调用函数的时候以 形参=实参的方式来传参, 这个时候实参的顺序无所谓
"""

def func1(a, b, c):
print(a, b, c)

通过位置参数传参

func1(10, 20, 30)

通过关键字参数传参

func1(c=30, a=10, b=20)

通过位置参数和关键字参数结合传参(注意关键字参数必须在位置参数的后面)

func1(10, 20, c=30)

"""
2.参数默认值
声明函数的时候，可以给参数赋默认值。
如果一个形参有默认值了，那么调用函数的时候这个参数就可以不用传参
如果有的形参有默认值，有的形参没有默认值，那么有默认值的形参要放在没有默认值的形参的后面

调用函数要保证每个参数都有值！
"""

参数c有默认值，调用函数的时候c可以不用传参

def func2(a, b, c=0):
# a=100, b=200
print(a, b, c)

func2(100, 200, 300)
func2(100, 200)
func2(a=100, c=200, b=150)
func2(b=110, a=220)

def func3(width, color='black', long=10):
print('画一条长度是%d宽度是%s的%s线' % (long, width, color))

func3(1)
func3(1, 'red')
func3(2, long=20)

"""
3.参数的类型说明 - 类型说明只有提示功能，没有约束功能
a.给参数设置默认值， 默认值的类型就是参数的类型
b.在形参后面加 :类型名,来说明参数类型。这种方式调用的时候必须传参
c.函数声明的时候在()后面加 ->类型名, 来说明函数返回值的类型

类型说明的好处：a.对实参的类型进行指导 b.实现函数功能的时候有类型相关的语法提示
"""

def list_item(list1: list, index=0)->int:
print(list1[index])

list_item([2, 34])

def func4(a: list, b):
a.append(b)

"""
4.不定长参数 - 函数的参数个数不确定
a. 声明函数的时候，在参数名前加,可以用来同时获取多个实参的值
-- 实质是将带的参数编程元祖，将多个实参的值作为元祖的元素

注意: a.如果函数中既有不定长参数又有普通参数，那么不定长参数必须放在普通参数的后边
b.两个的参数要放在一个的后边
"""

写一个函数，计算多个数的和

def yt_sum(*nums):
print(nums)

yt_sum()
yt_sum(1)
yt_sum(1, 2)
yt_sum(1, 2, 3)
yt_sum(1, 2, 3, 4, 5)

def func5(name, age, *scores):
print(name, scores)

func5('夏明', 18, 209)
func5('小花', 10, 20, 30)

"""
b.在参数名前加两个*, 会将这个参数变成一个字典来获取关键字参数的值，其他关键字作为key，实参作为value
"""

def func6(**nums):
print(nums)

func6()
func6(a=10)
func6(a=10, b=20)

def func7(*args, **kwargs):
print(args, kwargs)

func7(10, 5, 89)
func7(a=90, b=9, c=90)
func7(90, 89, z=0, v=87)

写一个函数，计算多个数的和(要求可以使用位置参数也可以使用关键字参数)

def yt_sum(*args, **kwargs):
sum1 = 0
# 遍历元祖
for num in args:
sum1 += num

# 遍历字典
for key in kwargs:
    sum1 += kwargs[key]

print(sum1)

yt_sum(1, 2)
yt_sum(1, 2, 3, a=4, b=5)

"""author = drh"""

"""
1.什么是返回值 - 返回值就是将函数里面的数据传递到函数外面
a.返回值就是函数调用表达式的值，就是return关键字后面的表达式的值
b.python中每个函数都有返回值，默认是None

函数调用表达式 - 调用函数的语句
return - 关键字，只能写在函数体中。功能：1.确定函数的返回值 2.结束函数
执行函数的时候如果遇到return,函数直接结束，并且将return后面的值作为函数的返回值

函数调用过程：
回到函数声明的位置
传参 - (保证每个参数都有值)
执行函数体
执行完函数确定返回值 - 如果执行过程中没有遇到return，函数的返回值是None
如果执行过程中遇到了return, return后面是什么返回值就是什么
回到函数调用的位置（这个时候函数调用表达式的值就是函数的返回值）

"""

def func1():
print('****')
if 2 == 2:
return 100
print('======')

result = func1() # func1()就是函数调用表达式
print(result)

def func2():
print(200)

print(func2())

练习：读程序

def func2(num):
if num & 1:
print(100)
# return 100
else:
return 200

return 300

print(func2(10)) # num=10 print(200)
print(func2(111)) # num=111 print(100) print(300)

"""
2.多个返回值
return 值1,值2,值3... <==> return (值1,值2,值3...)
"""

def func3():
return 1, 2, 3

print(func3())

x, y, z = func3()
print(x, y, z)

"""
3.怎么确定函数是否需要返回值
实现函数的功能如果会产生新的数据，就将这个数据用return返回
"""

def yt_sum(num1, num2):
# print(num1 + num2)
return num2+num1

result = yt_sum(10 , 2823)
print(result)
print(result+100)
list1 = [result]
print(list1)

"""author = drh"""

2.表达式0x13&0x17的值是（ 0x13 / 19）

010011 & 010111 = 010011

3.若x=-20,y=3则x&y的结果是（ ）

-20 = 110100(原) = 101011(反) = 101100(补码)

3 = 000011(补)

101100 & 000011 = 000000(补) = 0

XXXXXXXX XXXXXXXX

00000000 11111111

使用一个变量all_students保存一个班的学生信息(4个)，每个学生需要保存：姓名、年龄、成绩、电话

all_students = [
{'name': 'stu1', 'age': 19, 'score': 81, 'tel': '192223'},
{'name': 'stu2', 'age': 29, 'score': 90, 'tel': '211222'},
{'name': 'stu3', 'age': 12, 'score': 67, 'tel': '521114'},
{'name': 'stu4', 'age': 30, 'score': 45, 'tel': '900012'},
{'name': 'stu1', 'age': 30, 'score': 99, 'tel': '192226'}
]

1.添加学生：输入学生信息，将输入的学生的信息保存到all_students中

print('=====添加学生信息======')

name = input('姓名:')

age = int(input('年龄:'))

score = float(input('成绩:'))

tel = input('电话:')

student = {'name': name, 'age': age, 'score': score, 'tel': tel}

# 添加学生

all_students.append(student)

print(all_students)

2.按姓名查看学生信息：

例如输入:

姓名: stu1 就打印：'name':'stu1', 'age': 19, 'score':81, 'tel':'192222'

print('=====查看学生信息======')

find_name = input('需要查看的学生的姓名:')

count = 0

for stu in all_students:

if stu['name'] == find_name:

print(str(stu)[1:-1])

count += 1

if count == 0:

print('没有该学生!')

3.求所有学生的平均成绩和平均年龄

all_ages = 0
all_scores = 0
for stu in all_students:
all_ages += stu['age']
all_scores += stu['score']
print('平均成绩:%.2f 平均年龄:%d' % (all_scores/len(all_students), all_ages/len(all_students)))

4.删除班级中年龄小于18岁的学生

for stu in all_students[:]:

if stu['age'] < 18:

all_students.remove(stu)

print(all_students)

5.统计班级中不及格的学生的人数

num = 0
for dict1 in all_students:
if dict1['score'] < 60:
num += 1
print('班级中不及格的学生的人数：%d' % num)

6.打印手机号最后一位是2的学生的姓名

for dict1 in all_students:
char = dict1['tel']
if char[-1] == '2':
print(dict1['name'])