python笔记

前言，本篇是同学建议，将之前学习python的笔记整理了一下，方便重修的同学参考。记得很清楚，当时python编程基础这门课，不算平时分，只算试卷成绩的话，自己几乎满分，我记得是95还是94来着，因为有一题调用api的，调用的是isdigit（）函数，当时这里属于知识盲区，自己没有掌握，没有做出来，扣了5分。其他都是满分，对于老师的考试套路自己也比较熟悉，所以还是较有参考性的，会把一些重点性的东西总结出来放在下面。想要通过这门考试并不难，只需要理解，学习过程中最重要的是理解，尤其是编程，最好能够培养出编程的思维，也就是逻辑性的理解问题，并用编程的方式实现出来，这样就可以达到一会百会的境界了

有一些必考的知识点

1.首先是python数据结构那一章节的，列表，元组，字典集合。这四种务必掌握清楚，每个的特点，每种数据结构应该怎么创建。

2.程序流程控制语句也是重中之重，是你编程的代码里的灵魂，完美的code，几乎都靠这些来控制，书本上这一章节是利用实现案例的方式来学习的，这一章学习的时候可能会比较难懂一点，可以借助debug来帮助自己理解代码的逻辑，可以百度搜索学习编程的过程中怎么使用debug，

3.函数，这一章怎么说呢，在实际的开发过程中，都是将一个个功能写成方法来调用的，也就是函数。所以本章学习也算重点，但是我记得老师考的还是挺简单的，需要提到的一点是关于匿名函数的，lanmbda和map，我记得当时考到了这个，熟悉用法就可以了，并不需要掌握很高深的东西，如果仅仅是应付这门考试，

4.面向对象，这里可能需要你好好的理解才可以拿到这部分考试的分，当时老师并没有出很难的题目，就是基础的用法，像生成迭代器和返回迭代器这里，可能会比较有区分度，但是这一部分老师并没有出题目，需要掌握的是创建类，以及创建对象的方法。

5.文件这一章，老师并没有怎么考到，所以不是为了高分的话，只学习前面的部分已经足够通过考试了，理解透彻的话，考个八十左右还是可以的。

==注意下面的这些code，以及案例都要参考教材同步理解才可以==

0..列表，元组，字典

这里的笔记可能会比较的乱，时间久远，有的应该是老师上课让实现的案例，有的是自己自主学习中学到的案例。

1.1列表知识点以及用法

# 序列（列表，元组，字典）
#序列的切片
s='helloworld'
print(s[0:5:1])
print(s[0::1])#省略结束位置
print(s[0:5:-1])#步长可以负，是倒着打印的
print(s[:5:1])#省略起始位置
print(s[0:])#省略结束和步长
print(s[0: 5:1])

# 序列的相关操作
s='hello'
s2='world'
print(s+s2)#+号左右的数据类型要相同，序列中元素的数据类型可以不同
lis=[10,20,30,'ljh']#列表，元素类型不同
print('-'*10)

# 列表创建   列表是序列的一种（对序列操作的运算符，操作符，函数均可使用）
# 1.使用[]
lst=['ljh','14','21大数据一班','python',99,True]
# 2.使用内置方法list创建
lst1=list('helloworld')
lst2=list(range(1,10,2))#1开始，10结束，不包含10
print(lst1)
print(lst2)
print(lst+lst1+lst2)
# 列表的删除操作
lst4=[10,20,30]
del  lst4
# 列表元素的遍历
lst=['hello','pyhton','world']
# 1.
for item in lst:
    print(item)
# 2.
for i in  range(len(lst)):
    print(i,'--->',lst[i])

# 列表的相关操作方法
# .append(x)在列表最后增加一个元素(可变序列，增加元素之后，id是一样的，还是那个列表   )
# .extend(lst1能够将另一个列表添加到列表末尾
# .insert(index,x)在列表第index 位置增加一个元素
# .clear()清除列表lst中所有元素
# .pop(index)将lst中第index位置的元素提取，并从列表删除
# .remove(x)将列表中出现的第一个元素x删除
# .reverse(x)将列表中的元素反转
# .copy()拷贝列表中的所有元素，生成一个新的列表 ，id不一样

# 列表排序
# 列表对象的sort()方法
# lst.sort(key=None,reverse=False)为True是降序排序，False是升序排序，不写默认为升序
#  可以对字符串进行排序，中文不可以，根据Unicode码排的，大写大一点
# 如果想要忽略大小写用key=str.lower,降序排
# 内置的sorted()函数
# sorted(iterable,key=None,reverse=False)

# 列表生成式
# 生成指定范围的数值列表


# 元组(不可变序列)
#使用()创建
t=('hello',[10,20,30,],'world','python')
print(t)
# 使用内置函数

1.1.2列表的课堂任务

这部分应该是老师课堂上让你完成的任务（记不太清楚，忘记了，把本篇的所有课堂任务掌握，考个八九十还是没问题的）

#任务一
'''pyhton的数据结构类型分为三种，分别是序列，映射，集合。
其中序列里面包括列表和元组，列表是可变序列，元组不是可变序列'''
# 任务二
# 使用[]建表
lst1=['ljhh',56,'helloworld']
# 使用list函数建表
lst2=list('helloworld')
# 列表索引
lst3=['ljh','大数据1班','21','pyhton']
print(lst3[0])
# 列表元素的提取
print(lst3[1])
# 列表切片
str='helloworld'
print(str[0::2])
# 列表反转
str1=str[::-1]
print(str1)
# print(str.reverse())
# 追加元素
lst3.append('nothing')
print(lst3)
# 插入元素
print(lst3.insert(4,'java'))
# 使用del，pop，remove删除元素
del lst3[2]
print(lst3)
print(lst1.pop(1))
lst3.remove('大数据1班')
print(lst3)
# 修改列表元素
lst3[0]='helloworld'
print(lst3)
# copy方法
lst4=lst3.copy()
print(lst4)
# sort和sorted对列表进行排序
lst5=[51,22,27,99,56,37]
lst5.sort()
print(lst5)#false是升序排序，不写默认为升序，True为降序排序
lst5.sort(reverse=True)
print(lst5)




# 任务三
lst6=[120,'ljh','joel','java',99,'english',99]
#插入一个空列表
lst7=[]#空的列表
lst6.extend(lst7)
print(lst6)
# 删除字符串Joel
lst6.remove('joel')
print(lst6)
# 查找表中的数值并增大1.2倍
lst6[0]*1.2
lst6[3]*1.2
lst6[5]*1.2
print(lst6)

# 任务四（实训）
# 计算给定长度的数列
lstF=[0,1,1,2,3]#通过公式得出数列
# 删除重复项
del lstF[1]
print(lstF)
num=sum(lstF)
print(num)
lstF.append(num)
print(lstF)

2.元组的知识点

学习的过程中也要参考教材，我这里更偏向实际应用一点，一些知识点，概念还是要在书上看一下的，比如下面的range（）函数，他的用法啊之类的，如何使用，range函数前闭区间，后开区间的特点需要记住哦。

#元组的创建
# 使用（）创建
import ast

t1 = ("helloworld",[10,20,30],'python','java')
print(t1)
# 使用函数创建
t2 = tuple([10,20,30,40])
print(t2)
# 使用range创建
t3 = tuple(range(1,10))
print(t3)


# 元组的相关操作
print('10是否在t2中',(10 in t2))
print('10不存在t2中',(10 not in t2))
print('max',max(t2))
print('min',min(t2))
print('元组的长度：',len(t3))
print('index',t3.index(1))
print(t3.count(1))


# 如果元组当中只有一个元素时不能省略逗号，否则就成为int类型了
a=(10,)#若没有逗号就是int数据类型了
print(a,type(a))

# 元组的删除
# del t1


# 元组元素的遍历和访问
# 根据索引去获取，每次只能访问一个元素
t4=('python','java',[10,20,30])
print(t4[2])
# 切片访问
ac=t4[0::2]
print(ac)


# 元组的遍历
# 使用for循环
for it in t4 :
 print(it)

# for+range()+len()组合遍历
for i in range (len(t4)):
    print('遍历为',i,t4[i])

# 使用enumerate遍历
for index , item in enumerate(t4):#(t4)后面不写的话，他就是默认从0开始的)，\
    # (t4,1)改为这样，输出结果就会变为index从1开始，遍历结果不变，只是数字变了
    print(index,'----->',item)



# 元组的生成式
t5=(i for i in range(1,11))#生成的结果是一个生成器对象
#注意！！！生成器遍历之后，在想重新遍历，必须重新创建一个生成器对象，因为遍历之后原生成器对象已经不存在了


# print(t5)#<generator object <genexpr> at 0x0000012C345AF660>，生成的结果是这样的看不懂，可以进行使用内置tuple转换为元组
# t5=tuple(t5)
# print(t5)#此时就可以看到生成器生成的数了
# 使用for循环遍历
# for item in t5:
#     print(item)

# __next__()方法，将里面的元素取出
print(t5.__next__())#默认取第一个，然后依次往下排
print(t5.__next__())
print(t5.__next__())


#

3.字典知识点的应用

#字典
# 字典是没有索引的概念的
# 字典元素的访问的方法(键获取值)
# d[key]或者d.get(key)方法


# 创建字典(可以用字符串作为字典的键)  ，字符串是不可变序列
# 使用{}创建
d={'love':10,'pyhton':20,'java':30}#'str'；字符串是键，冒号后面的是值
print(d['love'])
print(d.get('love'))
# 使用dict函数创建
# 注意使用dict函数创建时，要将字典中的键和值组成双值子序列，或者组成元组
d1=dict((('a',1),('b',2),('c',3)))#就是多一个()或者[],之后再将列表或者元组转换为字典就可以了
print(d1)
# 建字典方法2.
score2=dict(math=99,java=99,pyhton=99)


# 这两个方法之间是有区别的
# 如果key不存在的时候，使用d[key]方法会报错，使用d.get(key)不会报错，会输出None，并且可以指定默认值
# print(d['ggg'])#程序会报错
print(d.get('ggg','不存在'))#会输出“不存在”

# 字典的相关操作方法
# 向字典中添加数据
# 使用键添加
d['easy']=40
print(d)
# 修改
#字典的合并update
# score2
# {'math': 99, 'java': 99, 'pyhton': 99}
# score.update(score2)
# score
# {'java': 99, 'python': 99, 'math': 99, 'pyhton': 99}


# 获取字典中的所有key
d={'love':10,'pyhton':20,'java':30}
keys = d.keys()
print(keys)#结果是dict_keys(['love', 'pyhton', 'java'])，dict_keys是python中的一种内部数据结构，专用于表示字典的key
# 如果希望更好的显示数据，可以使用list或者tuple 转成相应的数据类型
# 例如
print(list(keys))
print(tuple(keys))#['love', 'pyhton', 'java']
                  #('love', 'pyhton', 'java')

# #通过获得键来获取值
# myscoreinfo[keys_l[1]]

# 删除字典元素
# 使用del语句
# del score2[key]
# name.pop(key)
# clear完全删除，全部清除


# 获取字典中所有的值value
values=d.values()
print(values)#dict_values 同样是python中的一种内部数据结构
print(list(values))
print(tuple(values))

# 四舍五入函数round
# round函数也可以进行保留小数点的操作round(值，想要保留的位数)
# 可以将数据进行四舍五入
score2['java']=round(score2['java'])
print(score2)

# 通过值获取键
myscoreinfo={'姓名': 'ljh', '班级': '大数据1班', '学号': '14', 'math': 99, 'pyhton': 97, 'java': 98,'98':"dfsdf"}
keys=myscoreinfo.keys()#获取键
print(keys)
keys_l=list(keys)#将获取到的键转换为列表类型
print(keys_l)
all_values=myscoreinfo.values()#这一步是获取字典的值的操作
print(all_values)
all_values_l=list(myscoreinfo.values())#获取值，并将它转换为列表类型
print(all_values_l)
# 通过获得键来获取值的操作
items=myscoreinfo.items()
print(items)
items_l=list(myscoreinfo.items())
print(items_l)
#通过观察可以发现这里的items相当于java中的二维数组，所以可以再转换为列表之后可以进行索引的操作
i1=items_l[0][0]
print(i1)#观察到在转换为列表之后可以进行列表的索引操作

keys_l=all_values_l.index("14")#通过值来获取键的操作
print(keys_l)
#通过键来获取值的操作
a=myscoreinfo[keys_l[2]]
print(a)

4.集合知识点的应用

#集合
# 集合分为可变集合set和不可变集合frozenset
# 集合与字典中的key都是无序的
# 集合中的元素要求唯一
# 集合中只能存储不可变数据类型（字符串，整数，浮点数，元组）
# 集合使用{}定义，元素之间使用逗号进行分隔


# 集合的创建
# 使用{}创建s={1,2,3,,,,N}
s={10,20,30,40}
print(s)
# s={([5,6]),([1,2])}会报错，原因是有可变的数据类型列表
s={}#创建的是空的字典，并不是空的集合，空的集合用set函数创建
# 创建集合s=set(可迭代的对象)
s=set()#空的集合
print(type(s),bool(s))
# 使用set内置函数创建
s2=set([2,3,5,4,8])
s3=set(range(1,10))
print(s)
print(s2)
print(s3)
print(max(s3))
print(min(s2))
print(len(s3))
print(9 in s3)
print(9 not in s3)

# 集合的删除del 集合名
# del s3


# 集合类型的操作符
a={10,20,30,40,50}
b={30,50,88,75,21}

# 并集
print(a|b)
print(a.union(b))

# 交集
print(a&b)
print(a.intersection(b))

# 差集
print(a-b)
print(a.difference(b))
# 异或集(不一样的并一起)（并减去交）
print(a^b)
print(a.symmetric_difference(b))
a={10,20,30,40,50}
b={30,50,88,75,21}
c={10,20}
d={20,5}
# <=判断子集，<真子集
# >=判断超集，>真超集
print(c<=a)
print(a>=d)

5.第三章的实训

5.1最大公约数和最小公倍数

1.最大公约数和最小公倍数

set24={1,2,3,4,6,8,12,24}
set241={24,48,72,96,120}
set36={1,2,3,4,6,9,12,18,36}
set361={36,72,108,144,180}
set1=set24&set36
print('最大公约数为：',max(set1))
set2=set241&set361
print('最小公倍数:',min(set2))

5.2用户自定义查询菜单

2.用户自定义查询菜单
print("请输入菜单序号：")
print("查询汉堡类菜单输入1\n小食类菜单输入2\n饮料类菜单输入3\n没有找到满意菜品输入0")
caidan=("感谢光临本店，欢迎您下次光临，慢走不送",\
    "香辣鸡腿堡\n劲脆鸡腿堡\n新奥尔良鸡腿堡\n半鸡半虾堡",\
    "薯条\n黄金鸡块\n香甜粟米棒\n",\
    "可口可乐\n九珍果汁\n经典咖啡")
a=input("请输入菜单对应的数字：")
print(caidan[int(a)])
print("欢迎您下次再来") 

5.3简单的好友通讯录管理

print("输入数字1进行好友添加\n"
      "输入数字2进行好友删除\n"
      "输入数字3进行好友信息修改\n"
      "输入数字4进行好友信息查询")
information = {"小明": ['001', '广州'],
             "小红": ['002', '深圳'],
             "小王": ['003', '北京']}
num = input('请输入数字：')
int_num = int(num)  # 将输入的数据强制转换为整数类型
if (int_num == 1):
    str = input("请输入好友信息，姓名电话地址，以空格分开：")
    name = str.split()[0]
    info = str.split()  # 将输入的信息用逗号分割开
    info.pop(0)  # 删除字典中元组里面的名字重复项
    information[name] = info
    print(information)
elif (int_num == 2):
    name = input("请输入要删除好友的姓名:")
    del information[name]
    print(information)
elif (int_num == 3):
    name = input("请输入要修改的好友姓名：")
    print("请输入要进行修改的数字选项")
    reinfo = input("修改电话号码请输入1\n修改地址请输入2\n如都要修改请输入3")
    int_reinfo = int(reinfo)  # 将输入的数据强制转换为整数类型
    if (int_reinfo == 1):
        new_phone = input("请输入新的电话号码")
        lst_info = information.get(name)  # 通过要修改的人的名字，将他的信息赋给一个新的值
        information = {name: [new_phone, lst_info[1]]}  # 有了上一步，因为只修改了电话号码，所以将原来的地址提取出来，重新赋给另一个变量值
        print(information)
    elif (int_reinfo == 2):
        new_ass = input("请输入新的地址：")
        lst_info1 = information.get(name)
        information = {name: [lst_info1[0], new_ass]}
        print(information)
    elif (int_reinfo == 3):
        new_phone = input("请输入新的电话号码")
        new_ass = input("请输入新的地址")
        information={name:[new_phone, new_ass]}
        print(information)
    else:
        print("请输入正确的数字")
elif(int_num==4):
    name=input("请输入要查询的好友名称")
    lst_info=information.get(name)
    print(lst_info)
else:
    print("请输入正确的数字")

5.4总结：四种数据结构的特点差异

• 1.列表list
  列表中的每个元素都可变的，意味着可以对每个元素进行修改和删除；
  列表是有序的，每个元素的位置是确定的，可以用索引去访问每个元素；
  列表中的元素可以是Python中的任何对象，这意味着元素可以是字符串、整数、元组、也可以是list等Python中的对象。
  初始化为中括号[]

• 2.元组tuple
  元组Tuple，用法与List类似，但Tuple一经初始化，就不能修改，没有List中的append(), insert(), pop()等修改的方法，只能对元素进行查询,初始化为小括号()

• 3.字典dict
  • 字典中的数据必须以键值对的形式出现，即k,v：
    • key:必须是可哈希的值，比如intmstring,float,tuple,但 是，list,set,dict不行
    • value:任何值
    • 键不可重复，值可重复:
      键若重复字典中只会记该键对应的最后一个值。
      字典中键(key)是不可变的，何为不可变对象，不能进行修改； 而值(value)是可以修改的，可以是任何对象
  • 在dict中是根据key来计算value的存储位置，如果每次计算相 同的key得出的结果不同，那dict内部就完全混乱了。
  • 初始化为大括号{}
  • 可用for k,v in a.items():同时得到key和value，a.keys()为访问key，a.values()为访问value
  • 若直接for i in a:，则输出的是key

-

• 集合set
  • 集合中每个元素都是无序的、不重复的任意对象
  • 集合内数据无序，即无法使用索引和分片
  • 集合内部数据元素具有唯一性，可以用来排除重复数据
  • 可以通过集合去判断数据的从属关系。集合可做集合运算，可添加和删除元素。

6.流程控制

6.1列表元组字典的遍历

print('---------------------------------列表的遍历-----------------------------')
'''
使用遍历循环for
'''
# lst=['hello','world','python','java']
# for item in lst :
#     print(item)
'''
使用遍历循环for与range（）函数和len（）函数，根据索引进行遍历
'''
# for i in  range(len(lst)):
#     print(i,'---->',lst[i])
'''
使用遍历训话for与enumerate（）函数组合遍历元素和索引
for index ,item in enumerate（lst）：
       输出index和item 
       index：用于保存元素的索引，序号（可以进行修改）
       item：用于保存获取到的元素值
'''
# for index ,item in  enumerate(lst):#序号默认从0开始
#     print(index,item)
#
# for index, item in enumerate(lst,1):#序号默认从1开始
#     print(index,item)
print('---------------------------------二维列表-----------------------------')
# lst=[
#     ['城市','环比','同比'],
#     ['北京',111,151],
#     ['上海',101,155],
#     ['广州',555,369]
# ]
# print(lst)
print('---------------------------------二维列表的遍历-----------------------------')
# for row in lst:#遍历行
#     for item in row:#遍历列
#         print(item,end='\t')#输出完成这一列之后不换行
#     print()#换行，注意此时缩进距离，意思是遍历到了下一行之后就该换行了

# 创建四行五列的列表
#     这第一个j的意思是将j的值赋值给这一列了，通过输出结果可以看出来
# lst2=[[j for j in range(5)]for i in range(4)]
# print(lst2)
print('---------------------------------元组的遍历-----------------------------')
'''
元组的遍历跟列表的遍历方法是一样的，只是把元组换为列表就可以了，详情参考上面
'''
print('---------------------------------字典的遍历-----------------------------')
d1={10:'pyhton',20:'java',30:'c++'}
for item in d1.items():
    print(item)#输出结果为键和值组成的元组
#在进行遍历时分别获取键和值
for key,value in d1.items():
    print(key,value)

6.1.2字典，列表的遍历，列表解析式，匿名函数

# 字典的遍历
d1={10:'pyhton',20:'java',30:'c++'}
for item in d1.items():
    print(item)#输出结果为键和值组成的元组
# #在进行遍历时分别获取键和值
for key,value in d1.items():
    print(key,value)


# 列表的遍历
lst=['hello','world','python','java']
for item in lst :
    print(item)
for i in  range(len(lst)):
    print(i,'---->',lst[i])

for index ,item in  enumerate(lst):#序号默认从0开始
    print(index,item)

for index, item in enumerate(lst,1):#序号默认从1开始
    print(index,item)


lst=[
    ['城市','环比','同比'],
    ['北京',111,151],
    ['上海',101,155],
    ['广州',555,369]
]
print(lst)
for row in lst:#遍历行
    for item in row:#遍历列
        print(item,end=' ')#输出完成这一列之后不换行
    print()#换行，注意此时缩进距离，意思是遍历到了下一行之后就该换行了

# 创建四行五列的列表
#     这第一个j的意思是将j的值赋值给这一列了，通过输出结果可以看出来
lst2=[[j for j in range(5)]for i in range(4)]
print(lst2)



# lambda(返回函数的对象)
# 不能用for，print等语句
# 1.单个参数
g=lambda x:x+1
print(g(1))  #相当于方法加一，传入参数x=1
print(g(2))

# 2.多个参数
g= lambda x,y,z:(x+y)**z
print(g(1,2,3))

# 3.可以直接作为list和dict的成员
lst=[lambda a:a**3,lambda b:b**3]
g=lst[0]
print(g(2))


# map
# 函数与lambda配合使用
# map(将每个列表元素和字符串都执行某个函数)
# 求两个数的和
res=map(lambda x,y:x+y,[2,4,6],[3,2,1])#两个列表的元素相加
for i in res:
    print(i)
#  无法处理对应位置操作数类型不一致的情况
res=map(lambda x,y:(x**y,x+y),[2,4,6],[3,2])#两个列表的元素相加,那个6就忽略掉了
for i in res:
    print(i)


# filter
# 用于过滤序列，过滤掉不符合条件的元素，返回由符合条件的元素组成新的列表


# 列表解析式
# 计算x的三次幂
g=map(lambda x:x**3,range(6))
for i in g:
    print(i)#0,1,8,27,64,125
# 列表解析式
g=[x**3 for x in range(6)]
print(g)#[0, 1, 8, 27, 64, 125]

seq=[1,2,3,4,5,6,7,8]
# g=filter(lambda x:x%2,seq)
# for i in g:   #x%2只有为1的时候是真才能进行输出
#     print(i)
g=[x for x in seq if x%2]
print(g)

# 列表解析式，100以内的偶数
a=[x for x in range(1,101) if x % 2==0]
print(a)

#两层循环生成全排列
a=[m+n for m in 'ABCD' for n in 'abcd']
print(a)


#输出九九乘法表
for i in range(1,10):
    for j in range(1,i+1):
        print(str(i)+'*'+str(j)+'='+str(i*j),end=' ')#字符串的拼接要转换成字符串类型
    print()

6.2break和continue的使用

一些概念性的东西需要参考课本

print('--------------------------------break-----------------------------')
# 只能在循环结构中使用，通常与if一起搭配使用
# 累加和大于60打印当前数
# s=0
# i=1
# while True:
#     s+=i
#     if s>60:
#         print('累加和大于60的当前数：',i)
#         break
#     i+=1


# break语句用在登录系统中也可以
# i = 0
# while i < 3 :
#     user_name=eval(input('请输入用户名'))
#     pwd=eval(input('请输入密码'))
#     if user_name=='ljh' and pwd==123456789 :
#         print('密码正确，正在登录系统，请稍等。')
#         break
#     else:
#         if i < 2:
#             print('密码输入错误，您还有',2-i,'次机会')
#         i+=1
# else:
#     print('三次密码均输入错误')
#

# break语句在for循环遍历中也可以使用
# i=0
# for i in range(1,4):
#     user_name = eval(input('请输入用户名'))
#     pwd=eval(input('请输入密码'))
#     if user_name=='ljh' and pwd==123456789 :
#         print('正在登录中，请稍后。')
#         break
#     else:
#         if i <3:
#             print('还有',3-i,'次机会')
#         i+=1
# else:
#     print('三次机会均输入错误')


print('--------------------------------continue-----------------------------')
# 结束这一次循环进入下一次循环
# 用while循环实现1-100之间的累加和
i=1
s=0
while i<=100:
    if i%2==1:
        i+=1
        continue
    s+=i
    i+=1
print('1-100之间的偶数和为：',s)
# 用for循环实现1-100之间的累加和
s=0
for i in range(1,101):
    if i%2==1:
        i+=1
        continue
    s+=i
    i+=1
print('1-100之间的偶数和为',s)


print('--------------------------------pass-----------------------------')
# 不做任何事情，起到占位符的作用 ，是语法结构完整

6.3杨辉三角，数字金字塔，列表解析式

'''
杨辉三角，数字金字塔！！！
'''

# d={'a':1,'b':2}
# for i in d:#只能获取键值
#     print(i,d[i])#获取字典的值
#
# for i in d.items():
#     print(i)

# #
# b=lambda x:x**3
# print(b(2))
# c=lambda x,y:x*y
# print(c(5,2))

# d=lambda x:x%5==0
# print(d(10))



# d=list(map(lambda x,y:x+y,[1,2,3,4],[2,1,5,4]))
# print(d)

# filter函数,根据条件过滤掉不满足条件的某个元素
# c=list(filter(lambda x:x%2==0,range(1,21)))
# print(c)

# 列表解析式
# str=['88','78','99']
# c=[int(x) for  x in  str]
# print(c)

# 如果把条件放到表达式的位置的话，输出结果为布尔类型的值，所以不行
# odd=[x*2 for x in range(1,21) if x%2==0 ]
# print(odd)

# 键盘输入一组数据时要注意不能先转换类型，如果是一个数可以进行直接转换输入之后再转换类型
# score1=input('1').split(',')
# score2=input('2').split(',')
# c=[ int(x)+int(y) for x in score1 for y in score2 ]
# print(c)

# 杨辉三角
# N=[1]  #初始化杨辉三角的第一行数据
# for i in range(10):#行数的定义0-9
#     print(i,N)#i=0,N=1
#     N.append(0)#前面的一行尾部加0，[1,0]
#     N=[N[k]+N[k-1] for k in range(i+2)]#0,1,i+2取两个数，每一行列表的构造
#     print('N=',N)
#


# 杨辉三角
# 1.初始化第一行数据
# N=[1]
# # 2.for 循环定义要输出的三角形行数
# for i in range(10):
#     N.append(0)# 3.在每一行末尾追加数据0
#     N=[N[k]+N[k-1] for k in range(i+2)]#4.用列表解析式构造一个列表，注意取两个数相加
#     print('N=',N)



# 数字金字塔
# 假设一层
# t=4
# nl=[x for x in range(t,0,-1)]
# print(nl)
# nr=nl[-2::-1]#数据提取方式列表名
# print(nr)
# lst=nl+nr
# print(lst)

#1.用户输入数字金字塔的层数
rows=int(input('请输入数字金字塔的层数：'))
#2.显示数字金字塔
#2.1循环的构造显示每一层数据列表的过程
for t in range(1,rows+1):
    # 先构造列表的左边
    n_ll=[x for x in range(t,0,-1)]#列表解析式的方法
    n_rr=n_ll[-2::-1]#把1排除之后，将去顺序倒转过来，然后跟左半部分加起来之后就是一整行的输出了
    # 整行数据
    n_l=n_ll+n_rr
#2.1.0构造每一层列表

# 2.1.1显示前面的空格，迭代的显示列表中的数字
    print('  '*(rows-t),end='')#显示前置空格,通过对图形的观察得到的规律（rows-t），行数减去第几层
    # 将下面的部分转换为列表解析式的格式方法
    [print(x,end=' ') for x in n_l] #这个是用的列表解析式的方法。
    # for x in n_l:
    #     print(x,end=' ')
    print()#一行结束，换行

6.4课堂上的案例

有一个较为重要的讲解，冒泡排序，不过作为初学者不要求掌握，理解老师讲的就可以了，一共有八大排序，这只是其中一个，如果后续学数据结构与算法这门课的时候会接触到，感兴趣的可以自主学习。

6.5嵌套循环的练习

6.5.1 注意这里如果基础不是很好的话，可能不是很好理解，这时候就要借助debug来理解，不理解程序的哪一部，就从那一部开始，自行百度pycharm的debug使用

'''
嵌套循环的练习
'''
print('-------------输出一个三行四列的长方形---------------')
for i in range(1,4):     #外循环代表行
    for j in range(1,5):#内循环代表列
        print('#',end='')
    print()#换行，

print('-------------输出一个直角三角形---------------')
for i in range(1,6):
    for j in range(1,i+1):
        print('#',end='')
    print()

print('-------------输出一个倒直角三角形---------------')
for i in range(1,6):
    for j in range(1,7-i):
        print('#',end='')
    print()

print('-------------输出一个等腰三角形（金字塔）---------------')
for i in range(1,6):             #先定义一下要输出的行数
    for j in range(1,6-i):       #每一行要输出的空白的个数
        print(' ',end='')
    for j in range(1,2*i):       #每一行要输出的图案的个数
        print('#',end='')
    print()

print('-------------输出一个菱形---------------')
#用键盘输入的方式输出一个菱形
''' 因为菱形的图案特殊一定是奇数行，所以需要上半部分和下半部分中的某一部分比另一部分多一行,习惯我们就让上半部分多一行，操作就是让行数+1除2取整数'''
rows=int(input('请输入想要输出图像的行数：'))
top_row=(rows+1)//2                #这里如果没有+1的话，当输入为奇数行时，输出结果就会少一行。
for  i in range(1,top_row+1):
    for j in range(1,top_row+1-i):
        print(' ',end='')
    for j in range(1,2*i):
        print('#',end='')
    print()
bottom_row=rows//2
for i in range(1,bottom_row+1):
    for j in range(1,i+1):#打印空格
        print(' ',end='')
    for k in range (1,2*(bottom_row-(i-1))): #自己画图找到规律，打印图案的行数
        print('#',end='')
    print()

print('-------------输出一个空心的菱形---------------')
'''空心的菱形和菱形的思路是一样的，只是要额外添加几个判断条件'''

rows=int(input('请输入想要输出图像的行数：'))
while rows%2==0:
    print('请重新输入一个奇数的行数')
    rows = int(input('请输入想要输出图像的行数：'))

top_row=(rows+1)//2                #这里如果没有+1的话，当输入为奇数行时，输出结果就会少一行。
for  i in range(1,top_row+1):
    for j in range(1,top_row+1-i):
        print(' ',end='')
    for k in range(1,2*i):
        if k==1 or k==2*i-1:
            print('#',end='')
        else:
            print(' ',end='')
    print()
bottom_row=rows//2
for i in range(1,bottom_row+1):
    for j in range(1,i+1):#打印空格
        print(' ',end='')
    for k in range (1,2*(bottom_row-(i-1))): #自己画图找到规律，打印图案的行数
        if k==1 or k==2*(bottom_row-(i-1))-1:
            print('#',end='')
        else:
            print (' ',end='')
    print()

6.6 一些课堂案例

#等级划分的流程语句
score=int(input('请输入成绩：'))
if score<0 or score>100 :
    print('成绩输入错误')
elif score<60:
    print('等级为E')
elif 60<=score<70:
    print('等级为D')
elif 70<=score<80 :
    print('等级为C')
elif 80<=score<90:
    print('等级为B')
else:
    print('等级为A')

## 加密的

str=''
asd=input('请输入明文：')
if 'a'<=asd<'z':
    #            相对距离       %26取余判断是否超过26
    '''ord（asd）-ord（a)为了获取asd的距离+3之后是加密的,
    %26能够获取A——asd之间的距离，这么做是为了避免超过的情况
    再+ora（a）就能够获得加密后的数字了，在用chr转换为编码就可以了'''
    new_asd=chr(ord('a')+((ord(asd)-ord('a')+3))%26)
elif 'A'<asd<'Z':
    new_asd=chr(ord('A')+((ord(asd)-ord('A')+3))%26)
else:
    new_asd=asd
str=str+new_asd
print('你输入的明文是：',asd)
print('加密后的密文是：',str)




##求一个范围内的连乘和连加
nums=int(input())
lst=range(1,11)
s=0
mul=1
for i in lst:
    s+=i
    mul=mul*i
print('连加为：',s)
print('连乘为：',mul)

##判断奇偶
num1=int(input('请输入一个数'))
if num1%2==1:
    print('这是一个奇数')
else:
    print('这是一个偶数')

#判断闰年
year=int(input('请输入年份：'))
if (year%4==0 and year%100!=0 ) or (year%400==0) :
    print(year,'年是闰年')
else:
    print(year,'年是平年')

#课堂的一个实训
Responsiblie_body=['组织','负责的主管','其他直接负责人员']
law_rule=['第27条','第29条','第30条']
law_action=['不履行','不改正','造成大量数据泄露']
punishment=['警告','暂停业务','停业整顿','吊销相关营业许可证','吊销营业执照']
fine={"组织":["五万以上五十万以下","五十万以上两百万以下罚款"],
      "个人":["一万以上十万以下罚款","五万以上二十万以下"]
      }
print("请选择责任主体")
count=0
for i in Responsiblie_body:
    print("%d. %s"%(count,i))
    count+=1
body=int(input('输入数字： '))
zt=Responsiblie_body[body]
print("你选择的责任主体是：",zt)
print("请选择违反的数据安全法条文：")
count=0
for i in law_action:
    print("%d. %s"%(count,i))
    count+=1
la=int(input('输入数字：'))

if  zt is Responsiblie_body[0]:
    punishment_zt=punishment[la]
    fk=[zt][la]
    print(punishment_zt,fk)

count=0
while count<60:
    count+=1
    print(count)
count=0
print("计数归%d"%(count))

6.7实训

6.7.1猜数字

#猜数字游戏
import random
rand=random.randint(1,100)
count=0
num=int(input('请输入你猜的这个数字：'))

6.7.2字符串中类型的个数（

6.7.2.1当时自己就是这里没有印象，导致考试的时候没有做出来，可以着重记一下这两个函数，判断int的是isdigit（），判断字符的是isalpha,格式化的使用自行百度。较为简单

intCount,strCount,otherCount = 0,0,0
string = input("请输入任意字符串:")
for i in string:
    if(i.isdigit()):
        intCount+=1
    elif(i.isalpha()):
        strCount+=1
    else:
        otherCount+=1
print("intCount:%d,strCount:%d,otherCount:%d."%(intCount,strCount,otherCount))

6.8补充

6.9循环结构while和for的介绍

# else语句块通常在程序结束后才执行，通常与continue和break一起使用
#循环结构
print('---------------------遍历循环  for-----------------------')
#遍历循环  for
'''语法结构
           for 循环变量  in 遍历对象 :
                  语句块

————遍历对象
字符串   文件   组合数据类型   range()函数等
'''

# 遍历字符串
# for i in 'hello':
#     print(i)

# range()函数，产生一个[n,m)的整数序列
# for i in range(1,11):
#     if i%2==0:
#         print(i,'是偶数')
print('-------------------计算1-10之间的累加和--------------------')
# s=0
# for i in range(1,11):
#     s+=i
#     # print(s) #这是个错误的结果，没有意识到缩进的问题，因为此时还是在循环体内的，所以结果也是会循环的
# print(s)#这才是正确的结果，此时并没有在循环体内
print('-------------------计算100-999之间的水仙花数--------------------')
'''
举例153
 1*1*1+5*5*5+3*3*3=1+125+27=153
 '''
# for i in range(100,1000):
#     sd=i%10#取个位上的数
#     tens=i//10%10#取十位上的数，先用这个数整除10，取整数，然后在取余数就是十位上的数了
#     hundred=i//100
#     if sd**3+tens**3+hundred**3==i:
#         print(i,'是水仙花数')

print('---------------------无限循环 while-----------------------')
# # 1.初始化变量
# answer=input('要去吃饭吗？y/n:')
# # 2.条件判断
# while answer=='y' :
# #3.语句块
#     print('好好吃饭')
# # 4.改变变量
#     answer=input('要去吃饭吗？')
print('---------------------1-100之间的累加和-----------------------')
s=0
i=1#初始化变量
while i<=100:#判断条件
    s+=i#语句块
    i+=1#改变变量
# print('1-100之间的和为',s)
#也可以使用while，else语句
else:
    print('1-100之间的和为',s)

6.10模拟实现登录系统（不要求掌握，但可以理解一下思想，

#while 循环模拟实现系统登录
#用python写程序要注意缩进，否则可能会导致问题，这是与java不太相同的地方

i=0
while i < 3 :
    use_name=input('请输入您的用户名：')
    pwd = input('请输入您的密码：')
    if use_name=='ljh' and pwd==123456789 :
        print('请稍后，正在登陆中')
        i = 8#给i重新定义，能够让其跳出循环
    else:
        if i<2:
           print('密码输入错误还有',2-i,'次机会')
        i+=1
if i == 3 :
   print('您三次机会全部输入错误')

7.0函数

本章是在前面的基础上学习的，所以前面的内容要掌握牢固

7.1函数的介绍

'''函数
函数：相当于java中的方法，封装一个特定的功能，表示一个行为'''
#固定格式，函数名自己随意起
def attack():#写了一个函数方法
    print('直拳')
    print('摆拳')
    print('勾拳')
    print('肘击')
# attack()#调用这个方法函数


def attack_repeate():#写了一个函数方法
    for i in range(3):   #发现可以用for循环的方式来进行输出，调用该函数输出的是三次
        print('直拳')
        print('摆拳')
        print('勾拳')
        print('肘击')


# attack_repeate()


'''
函数的参数（形式参数，实际参数）
'''
# 有参数的函数        形式参数
def attack_repeate(count):#写了一个函数方法
    for i in range(count):
        print('直拳')
        print('摆拳')
        print('勾拳')
        print('肘击')
# attack_repeate(5)  #这个数字是实际参数




# 练习题
def print_rectangle(row,col,char):
    for i in range(row):
        for j in range(col):
            print(char,end='')
        print()

# print_rectangle(5,8,1)


'''
函数的返回值 （做函数的人可以给用函数的人返回一些信息）
'''

def fun01():
    print('fun01执行喽')
    return  100   #返回100
#          return 后面如果没有数据，相当于返回空值None
# 即使有返回值，但调用时可以不使用
# 返回的值要有一个变量来接收
number = fun01() #这里也算是调用了变量
print(number)  #想要输出返回值要另外打印这个返回值的变量

7.2函数的应用（并不是课堂上的，当时自主学习的）

'''
函数的应用
'''

# 两个数值相加的功能
def sum_total():
    number_one=float(input('请输入第一个参数'))
    number_two=float(input('请输入第二个参数'))
    result=number_one+number_two
    print('结果是',result)
# sum_total()

# 函数的代码小而精,上面的代码优化之后的结果
def sum_total1(num1,num2):
    return num1 + num2
# num1=float(input('请输入第一个参数'))
# num2=float(input('请输入第二个参数'))
# result = sum_total1(num1,num2)
# print('输出的结果为：',str(result))


# 练习题
# 1.从终端获取整数，累加计算每位数字的和
# num=int(input('zhenghsu'))
def sum_en(num):
    """
    计算整数的每位相加和
    :param num:需要操作的数据，int类型，再遍历时要转换为str类型
    :return:相加的结果，int类型
    """
    sum=0
    for i in str(num): #整数不能遍历，要转换为字符串
        sum+=int(i)
    return sum
# re  = sum_en(num)
# print('结果是：',re)

# 2.根据成绩，输出等级
# score=float(input('请输入考试成绩：'))
def level(score):
    if score<0 or score>100:
        return '考试成绩有误，请重新输入'
    elif 0<score<60:
        return 'E'
    elif 60<=score<70:
        return 'D'
    elif 70<=score<80:
        return 'C'
    elif 80<= score <90:
        return 'B'
    else:
        return "A"
# score_level=level(score)
# print('考试等级为；',score_level)

#return可以简化逻辑退出方法。利用这一性能可以优化以上的代码
# 优化后的版本如下
score=float(input('请输入考试成绩：'))
def level(score):
    """
    根据成绩输出等级的方法
    :param score: 参数
    :return: 返回等级
    """
    if score<0 or score>100:
        return '考试成绩有误，请重新输入'
    if 0<score<60:
        return 'E'
    if 60<=score<70:
        return 'D'
    if 70<=score<80:
        return 'C'
    if 80<= score <90:
        return 'B'
    return "A"
#这样利用return的特性就可以提高性能，如果if不符合，直接跳到下一个，都不符合直接返回'A'
score_level = level(score)
print('考试等级为：',score_level)

7.3函数的参数

"""
      函数内存分配
"""

# 将函数的代码，存储到代码区，函数中的代码不执行。
def fun01():
    a=100
    print(a)
# 调用函数时，在内存中开辟空间，存储函数内部定义的变量，该空间叫做栈帧
# 函数执行过后，栈帧释放。
# fun01()


def fun02(p1,p2):
    p1= 20  #这个20是传给p1的，存储的地址在p1，并没有传给a，a还是10，
    p2[0] = 20 #这个20传给p2的第一个元素，即传给了b，存储地址为之前的10所占的位置
# 结论1.传入不可变对象，函数体内部不可能修改数据
a=10
# 结论2. 传入可变  对象，函数体内可能修改数据
b=[10]
fun02(a,b)
print(a)   #a输出的结果为10
print(b)   #b的为[20]

'''
可变和不可变类型的传参区别
不可变类型参数有：  
    数值型（整数，浮点数，复数）
     布尔值bool
     None 空值
     字符串str
     元组tuple

可变类型的参数有
    列表 list
    字典 dict
    集合 set 

传参说明：
    不可变类型的数据传参时，函数内部不会改变原数据的值
    可变类型的数据传参时，函数内部可以改变原数据 

小结：
    传入可变对象
    修改可变对象
    无需通过返回值返回结果
'''

'''
函数参数
    实际参数：调用函数时
    形式参数：定义函数时
'''

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

# 1. 位置实参: 根据位置，将实参传递给形参
fun01(1,2,3)

# 2.序列实参：使用星号将序列拆分后，与形参进行对应
list01 = [4,5,6]
fun01(*list01)

# 3.关键字实参 :根据名称，将实参传递给形参
fun01(a=1,c=3,b=2)

# 4.字典实参:
dict01={"c":3,"b":2,"a":1}
fun01(**dict01)

'''
实际参数：
    位置实参
        序列实参，用*进行拆分
    关键字实参
        字典实参，用**进行拆分
'''
'''
形式参数：
    位置形参
    位置形参
        星号元组形参
    命名关键字形参
        双星号字典形参
'''

7.4形式参数

'''
函数参数
    形式参数
'''

'''
形式参数：（使用顺序）
    1.位置形参
        2.星号元组形参
    3.命名关键字形参
        4.双星号字典形参
'''


# 1.位置形参 ：约束实参必须提供
def fun01(a,b,c):
    print(a)
    print(b)
    print(c)

# 2.默认参数：实参可以不提供参数，进行输出不会报错,在python中必须要从右向左依次存在默认参数
def fun02(a=0,b="",c=0.0):
    print(a)
    print(b)
    print(c)

# fun02(1,2)

# 3.*号元组形参：将实参合并为一个元组
# 只能有一个*，建议形参名称为args
def fun03(*args):
    print(args)

# fun03(1,2,3)
# fun03(a=1,b=2)  #关键字实参会报错

# 4.命名关键字形参 :星号后面的位置形参，必须使用关键字实参传递
def fun04(*args,a,b,c):
    print(args)

# fun04(1,2,3,4,5,a=1,b=2,c=3)

def fun05(a,*,b=0,c=0):
    print(a)
    print(b)
    print(c)
# fun05(a=1 ,c=3)

# 5. 双**号字典形参：将关键字实参合并为一个字典
def fun06(**kwargs):
    print(kwargs)

fun06(a=1,b=2)








# 练习1.
# 定义函数，根据小时，分钟，秒计算总秒数
'''
要求：根据小时，分钟，秒。根据小时，分钟。根据分钟，秒。根据分钟
'''
def get_total_second(hour=0,minute=0,second=0):
    return hour * 3600 + minute*60 +second
# print(get_total_second(1,2,3))
# print(get_total_second(1,2))
# print(get_total_second(minute=2,second=3))
# print(get_total_second(minute=2))

# 练习2.定义函数，多个数值累加
def sum(*args):
    sum_t=0
    for i in args:
        sum_t+=i
    return sum_t
# print(sum(1,2,3,45,56))
# 如果没有*号，将输入的设置为列表类型
def sum(args):
    sum_t=0
    for i in args:
        sum_t+=i
    return sum_t
# print(sum([1,2,3,45,56]))

7.5函数的作用域

'''
作用域

local局部作用域：函数内部
Global全局作用域：模块（.py文件）内部
'''

# 全局作用域：整个.py文件都可以调用
# 全局变量
g01 = 100


def fun01():
    # 局部作用域：函数内部
    # 局部变量，出了这个函数就不行了
    a=10
    print(a)
    # 可以在局部作用域中，读取全局变量
    # print(g01)

    # g01=200
    #实际创建了 局部变量，没有改变全局变量
    #若想要修改全局变量,声明全局变量
    global g01
    g01 = 200
# fun01()
# print(g01)



# 练习1.
# 定义函数计数器，统计函数被调用的次数
count=0
def fun02():
    global count
    count+=1

fun02()
fun02()
fun02()
print('执行次数是：',count)

7.6函数求方差和均值

#求均值
def average(*args):
    num_a=0
    def sum_num(x):
        sum=0
        for i in x:
            sum+=i
        return sum
    num_a=sum_num(args)/len(args)
    return num_a
# print(average(1,2,3,4,5,6,7,8,9,10))

def average(*args):
    num=0
    sum=0
    for i in args:
        sum+=i
        num+=1
    ave=sum/num
    return ave
# print(average(1,2,3,4,5,6,7,8,9,10))


# 方差的嵌套函数
def fangc(*args):
    def average(x):#求平均值的
        num_a=0
        def sum1(y):  #求和的
            sum_t=0
            for i in y:
                sum_t+=i
            return sum_t
        ave=sum1(args)/len(args)
        return ave
    def pingfanghe(z):
        sum_t1=0
        for j in z:
            sum_t1+=j**2
        return sum_t1
    fc =pingfanghe(args)/len(args)-average(args)**2
    return fc
print(fangc(8,9,7,2))

7.7求中位数的实训

#求列表的中位数的函数
#需求分析：
# 想要求一组数里面的中位数的话，就要先给这一组数排序，大小都可以没有大小的顺序，然后在计算这组数的个数是奇个还是偶个
#奇数个就是最中间的那个，偶数个就是对称的中间的两个的数的和除以2
# nums=input("请输入一组数据，用空格隔开\n").split(' ') #输入一组数用逗号分开，将其用列表的形式存放起来了。
# def centerNum(numbers):
#     """
# 这是一个求中位数的函数
#     :param numbers:是形式参数，实际参数是通过input传过来的那组数据
#     :return:返回值返回的是输出结果，分为两种情况，利用return的特性直接返回结果，这样可以达到代码的小而精的效果，提升性能。
#     """
#     numbers.sort()
#     length = len(numbers)  #这里定义的变量是输入进来的那组数据的长度，就是数据的个数（后面要用其来判断是奇数个还是偶数个。）
#     if length%2==0:  #当是偶数个的时候。利用规律来计算它的中位数，是中间两个数的均值
#         return   (int(numbers[int(length / 2) - 1]) + int(numbers[int(length / 2)])) / 2
#     if length%2==1:  #当是偶数个的时候。就是位于正中间的那个，将长度//2取整数，得到它的位置，因为列表的起始位置是从0开始的，所以的到的值就是结果
#        return int(numbers[int(length // 2)])
# cen_num=centerNum(nums)
# print(cen_num)

'''
总结
    在做这一题是这里有一个报错自己解决了很久，是当这组数据是偶数的时候，后来发现，自己没有将利用索引搜索出来的那两个数转化为数字类型，他还是字符串类型
    所以在后面求这两个数的均值的时候，它就会一直报错，因为字符串没有办法进行运算。将那两个数据转化为int之后发现就可以了
'''




nums=input("请输入一组数据，用空格隔开1\n").split(' ')
def centerNum(numbers):
    numbers.sort()
    size = len(numbers)
    if size%2==0:
        med = (float(numbers[int(size/2)-1]) + float(numbers[int(size/2)]))/2
    else:
        med = float(numbers[int(size/2)])
    return med
cen_num=centerNum(nums)
print(cen_num)

7.8函数自定义的练习

# 函数定义练习
def myadd(x,y):
    result=x+y
    return result
# num1,num2=input('请输入两个数，用空分离').split(' ')
# print(myadd(float(num1),float(num2)))

def mysum1(nums):  #可能是列表或者元组
    sum1=0
    for i in nums:  #遍历int类型的数据无法遍历，只能用str类型的数据来进行遍历
        sum1+=int(i)
    return sum1
# nums=input('请输入一组数据用逗号隔开：').split(',')
# print(mysum(nums))

# print(mysum([1,2,3,4]))

def mul(nums):
    mult=1
    for i in range(1,nums+1):
        mult*=i
    return mult
# print(mul(5))


# 自定义函数求利息： 本钱money，天数days，年利率interest_rate ,return income
def myincome(money,days,interest_rate=0.05):
    income=money*days*interest_rate/365
    # return income
    print(income)
# print(myincome(999999,180))
# myincome(50000000,30)  #位置参数
# myincome(50000000,interest_rate=0.06,days=30)  #关键字参数，位置任意

def printNum(*args):
    # print(x)
    print(args,type(args))

    for i in args:
        print(i)

# printNum(3,456,7,8,9)

def mysum(*args):
    sum_t=0
    for i in args:
        sum_t+=i
    return sum_t
# print(mysum(1,2,3,4,5,6))




def myaverage(*args):
    """

    :param args: *是可以传入多个位置参数的，是元组类型，注意下面如果直接调用mysum会报错
    :return: 返回平均值
    """
    # def mysum(x):
    #     sum_t = 0
    #     for i in x:
    #         sum_t+=i
    #     return sum_t
    ave = mysum1(args)/len(args)  #如果用直接调用的方法，使用的求和函数应该是mysum1函数，如果用mysum的话拿过来直接就是元组的类型，会报错
    return ave

# print(myaverage(1,2,3,4,5,6,7,8,9,10))

def userinfo(username,age,**kwargs):
    """

    :param username: 正常的参数
    :param age: 同上
    :param kwargs:**双星号保存的类型为字典类型
    :return:
    """
    print("用户的姓名，年龄",username,age)
    print("其他信息",kwargs)
    for i in kwargs.items():
        print(i)
userinfo('ljh',22,className='21大数据1班',number='14',bornLand="舞阳")


#嵌套函数的定义和调用
a,b,c=1,2,3  #全局变量
def A(strA):
    print(strA)
    global  a #声明a是全局变量
    a=6 #局部变量,只能在定义它的函数中使用。  #用global 声明a是全局变量
    print("a=",a)
    def C(strC): #定义C函数，是A函数的内建函数,内建函数只能内部调用
        print(strC)
        print("a=", a)
        c=0   #是局部变量
        print("c=",c)
    C("在a中调用C函数并显示")
    print("c=",c)
    # B("在A中调用B函数并显示")
def B(strB):
    print(strB)
    print("b=",b)
    print("a=",a)
    # A("在B中调用函数A")
# A("ljh")
# B('调用b函数')
# A("调用A函数")


def fangcha(*args):
    def average(y): #y是参数
        def mysum(x):#x参数
            sum_t=0
            for  i in x:
                sum_t+=i
            return sum_t
        ave=mysum(args)/len(args)
        return ave
    def pingfanghe(z): #z参数
        sum_2t=0
        for j in z:
            sum_2t+=j**2
        return sum_2t
    fc = pingfanghe(args)/len(args)-average(args)**2
    return fc
print(fangcha(1,2,3,4,5,6,7,8,9,10))

7.9匿名函数和解析式

前面有讲过了，可以看着标题找一下

8.0面向对象

这一部分需要自己多花时间来理解一下，老师讲的时候认真听，如果有不理解的部分及时问，不要傻傻的照着敲老师的代码，动脑子

8.1课堂的案例

# iter函数，迭代器，  可以遍历一个对象
# next函数，与iter一起用 next(it)  ,（it=iter（L）） next ()括号里面的数据必须时迭代器


class Car():
    def __init__(self,brand,turbo,number,wheelNums,color):
        self.__brand=brand
        self.__turbo=turbo
        self.__number=number  #私有属性
        self.__wheelNums=wheelNums
        self.__color=color
        self.__carinfo=[self.__brand,self.__number,self.__turbo,self.__color,self.__wheelNums]
        self.__index=-1
    def __iter__(self):
        print('品牌',self.__brand)
        print('编号',self.__number)
        print('woli',self.__turbo)
        print('dd',self.__color)
        print('ff',self.__wheelNums)
        # print("品牌，编号，涡轮数，颜色，轮子数")
        return self
    def __next__(self):
        if self.__index == len(self.__carinfo)-1:
            raise StopIteration  #抛出异常 ，引发这个异常，后面的代码不会执行  ”StopIteration“ 这个异常在使用next函数时会遇到，是说下面已经没有数据了，无法进行下一个的迭代
        self.__index+=1
        return self.__carinfo[self.__index]
    def getnumber(self):
        return self.__number
    def setnumber(self,number):
        self.__number=number    #改变私有属性的值

car1=Car("红旗","2.0","001","黑色",4)
for i in car1:
    print(i,end=' ')#


class Student():
    def __init__(self,name,age,course):
        self.__name=name
        self.__age=age
        self.__course=course
        self.__index=-1
        self.__stuinfo=[self.__name,self.__age,self.__course]

    def get_name(self):
        return self.__name
    def get_age(self):
        return self.__age
    def get_course(self):
        return max(self.__course)
    def __iter__(self):
        print("姓名，年龄，成绩[语文，数学，英语]")
        return self
    def __next__(self):
        if self.__index == len(self.__stuinfo)-1:
            raise StopIteration
        self.__index+=1
        return self.__stuinfo[self.__index]

zm=Student("张明",20,[69,88,100])
# print(zm.get_name(),zm.get_age(),zm.get_course())
# for i in zm:
#     print(i,end=' ')



# 返回迭代器 yield ，不用return返回， 而是用yield一次返回一个结果。




"""
        生成器与列表解析式之间区别
"""
#生成器表达式，列表解析时相似
l1=[i for i in range(20) if i%2]   #奇数
#不能直接用（next）进行迭代，转换为iter再用next


l2=(i for i in range(20) if i%2)  #生成器表达式，每次可以取一个 ，类型是 generator类型


# Java接口实现多继承，多态

class Dog:
    """
        狗
    """
    #在初始化方法里面用来填一些数据之类的，这里跟java相似
    def __init__(self, breed="", name="", age=0, sex=""):
        self.breed = breed
        self.name = name
        self.age = age
        self.sex = sex

    def eat(self):
        print(self.name+"在吃")

d01=Dog("拉布拉多","小白",4,"母")
d02=Dog("拉布拉多","小黑",3,"公")
# d01.eat()
# d02.eat()

d03=d01                   #可以用画内存的方式分析下面的代码的内存指向
d01.age=5
# print(d03.age)          #结果为5

d04=d02
d02=Dog("哈士奇","二哈",2,"公")
# print(d04.name)                 #结果为 小黑

def fun01(p01):
    p01.name="哈哈哈"

fun01(d02)
# print(d02.name)



list01=[
    d01,
    d02,
    Dog("沙皮","皮皮",3,"公"), 
    Dog("金毛","毛毛",1,"母") ,
]
#练习.3 在狗列表中查找所有的拉布拉多

def find01():
    list_result=[]
    for i in list01:
        if i.breed == "拉布拉多":
            list_result.append(i)
    return list_result

re = find01()
print("---")  #分隔符
for i in re:
    print(i.name)

8.2继承

#继承
class Cat():
    def __init__(self,name,age):
        self.name=name
        self.age=age
        self.__myname="ss"
    # def __del__(self):
    #     print("析构函数正在被调用")
    def __sleep(self):
        print(self.age,"岁的",self.name,"猫正在睡觉")
    def eat(self,food):
        self.food=food
        print(self.__myname,"正在吃",self.food)
    def run(self):
        print()

class BoisCat(Cat):
    def __init__(self,location,brand,name,age):  #子类的构造函数，覆盖父类的构造函数。
        self.__location=location
        self.__brand=brand
        Cat.__init__(self,name,age)       #  调用父类的构造函数初始化其他函数
    def eat (self):
        print("吃的食物是%s"%(self.catchMouse()))

    def catchMouse(self):
        print(self.name,"正在",self.__location,"捉老鼠")
        return "mouse"
b1=BoisCat("Cn","boiss","heibao",4)

class BaliCat(Cat):
    def __init__(self,skills,brand,name,age):
        self.skills=skills
        self.brand=brand
        Cat.__init__(self,name,age)
    def show(self):
        print("这个叫%s的猫会%s"%(self.name,self.skills))

    def eat(self,food):
        print("这只%s猫正在吃%s"%(self.name,food))

b2=BaliCat("捉老鼠","bali","小白",4)
b2.show()
b2.eat("mouse")



b1.catchMouse()
b1.eat()

8.3当时的课后作业

class Charmander():
    def __init__(self,name,gender,level,type):
        """
            类的构造方法，构造方法下面用来定义一些这个类的属性，在这里将这个类定义成了私有的属性
        :param name: 名字
        :param gender: 性别
        :param level: 等级
        :param type:属性
        """
        self.__name=name
        self.__gender=gender
        self.__level=level
        self.__status=level+5
        self.__HP=level*2+10
        self.__attack=level+5
        self.__defence=level+5
        self.__tg=level+5
        self.__speed=level+5
        self.__type=type
        self.info_ablitity=[self.__status,self.__HP,self.__attack,self.__defence,self.__tg,self.__speed]
        self.index=-1  #这里设置为-1的原因是因为当迭代的时候，让这个index+1，它就变为了0，
        # 列表的第一个索引位置就是0，所以下面就可以迭代的输出列表里面的信息了，当index=列表长度-1时，停止迭代的输出。
        # 因为已经输出完了


 #下面是定义的一些返回值的方法
    def getName(self):
        return self.__name
    def getGender(self):
        return self.__gender
    def getStatus(self):
        return self.info_ablitity
    def getType(self):
        return self.__type

    def level_up(self):
        """
            这个是迭代升级的函数，每升一级对象的能力属性都会有所变化
        :return: 返回值是迭代升级后的能力属性，跟之前的已经不一样了。
        """
        self.__HP+=2
        self.__status+=1
        self.__attack+=1
        self.__defence+=1
        self.__tg+=1
        self.__speed+=1
        self.info_ablitity=[self.__status,self.__HP,self.__attack,self.__defence,self.__tg,self.__speed]
        return self.info_ablitity



    # iter函数，迭代器，  可以遍历一个对象
    # next函数，与iter一起用 next(it)  ,（it=iter（L）） next ()括号里面的数据必须时迭代器

    def __iter__(self):
        # print("名字  属性  性别  等级  能力") #发现用这样的表达方式会报错，并不是想要的输出形式。
        print("名字： ",self.getName())
        print("属性： ",self.getType())
        print("性别： ",self.getGender())
        print("等级： ",self.__level)
        print("能力： ",self.info_ablitity)  #这里的能力调用的应该是迭代升级之后的能力属性，因为每升一级，它的能力属性都会有所变化
        return self
    def __next__(self):
        if self.index == len(self.info_ablitity)-1:
            raise StopIteration
        else:
            self.index+=1
            self.level_up()
        return self.info_ablitity[self.index]

pokemon1=Charmander("皮卡丘","男",9,"电属性")
for i in pokemon1:
    print(i)

8.4 uml看图写程序

class People():
    def __init__(self,n,a,w):
        self.name=n
        self.age=a
        self.__weight=w
    def speak(self):
        print("你好！我是%s"%(self.name))
class Student(People):
    def __init__(self,n,a,w,g):
        self.grade=g
        self.name=n
        self.grade=g
       # People.__init__(self,n,a,w)#调用父类的构造函数初始化数据
    def speak(self):
        print("我是{}，我是{}学生，我将用英语交流！".format(self.name,self.grade))
class Speaker(People):
    def __init__(self,n,t):
        self.topic=t
        self.name=n
    def speak(self):
        print("我是{}，我今天的演讲主题是{}".format(self.name,self.topic))
class Sample(Student,Speaker):
    def __init__(self,n,a,w,g,t):
        Student.__init__(self,n,a,w,g)
        Speaker.__init__(self,n,t)
    def speak(self):
        Student.speak(self)
        Speaker.speak(self)

p1=People("hhm",12,40)
p1.speak()
People=Student#等于的原因是为了，让下面的一行代码可以直接通过调用父类，来间接的调用子类
s1=People("jole",12,45,"初中一年级")
s1.speak()
People=Speaker
s2=People("John",'向梦想前行！')
s2.speak()
s3=Sample("stone",13,40,"初中二年级","笃行不怠，不负韶华！")
s3.speak()

9.文件

9.1基础

fn="stu.txt"

#r模式：读文件
#w模式:写文件
#a模式：再已有的文件末尾追加文件

with open(fn,"a",encoding='utf-8') as f :
    f.write("学号，姓名，成绩\n")
    while True:
        score_info = input('请输入学号,姓名，成绩')
        if score_info=="0":
            break
        else:
            f.write(score_info)
    f.close()

9.2读取csv文件

 # 读取csv文件
import csv
fn="stu_score.csv"
# 1.
with open (fn,'r') as f :
    file= csv.reader(f)
    score=[x for x in file ]  #如果用索引模式需要列表解析式构建列表
    total_java=0
    total_py=0
    for i in range(1,len(score)):
        total_java+=int(score[i][2])
        total_py+=int(score[i][3])
    print(total_java)
    print(total_py)
    number=int(input('请输入要查询的学生学号'))
    print(score[number])
    for i in file:  #这样不好计算
        print(i)


# 2.
fn="stu_score.csv"
with open (fn,'r') as f :  #字典读
    rd=csv.DictReader(f)   #读取的结果是字典的形式
    score=[x for x in rd]
    # print(score)
    total_java=0
    total_py=0
    for i in score:
#         # print(i["Java"])
        total_java+=int(i["Java"])
        total_py+=int(i["python"])
#     print(total_java)
#     print(total_py)
        # print(i["python"])
    # score=[x for x in file ]  #如果用索引模式需要列表解析式构建列表
    # number=int(input('请输入要查询的学生学号'))
    # print(score[number])
total_score=dict(学号="",姓名="总成绩",Java=total_java,python=total_py)   #构造要写入的总成绩的
# 写入另外一个文件，拷贝
fn = "score_copy.csv"
with open(fn, "w", newline='') as f:  # newline=''解决写入空行的问题
    wd=csv.writer(f)
    # wd.writerows(score)   #s会换行
    keys = score[0].keys()  #得到的数据就是键
    # score_data = score[1:5]
    wd = csv.DictWriter(f, keys)
    # wd.writeheader()  # 表头的写入
    wd.writerow(total_score)

'''
总结
    首先读取csv文件的有两种方法1.用reader读取
                            2.用DictReader读取
    第一种方式读取之后，用普通的for循环将它的具体数值迭代出来，如果想要制定某一行的输出就没有办法
    以为这种方式输出之后没有索引值，用列表解析式，将其构造为列表的方式，然后再迭代一整行的数据，
    注意表头不要都进去，所以最后的值应为这个列的长度
    然后用二维列表就可读取指定的列的数据值进行求和。
'''

9.3文件练习

import csv
fn="iris.csv"
# 先读取数据，然后对其进行操作求均值
# 然后再写入数据，再表的末尾追加均值
with open(fn,'r') as  f :
    rd=csv.DictReader(f)  #字典的方式读取数据
    data=[x for x in rd]
    total_sl,total_sw=0,0 #分别是sepal的长度和宽度的总长度
    total_pl,total_pw=0,0 #分别是petal的长度和宽度的总长度为后面求均值
    for i in data:
        total_sl+=i["Sepal.Length"]
        total_sw+=i["Sepal.Width"]
        total_pl+=i["Petal.Length"]
        total_pw+=i["Petal.Width"]
en_title=dict(编号="",)

9.4文件的路径

#文件

# 1.定义变量用来保存你需要打开的文件名
# try:
#     fn='abc'
#     f=open(fn,'r')
#     a=f.read()
#     print(a)
#     f.close()
# except:
#     print("文件不能打开，读取错误")
# finally: #无论是否有异常都会执行的代码块
#     print("文件处理结束！")



# ..两个点是上一级目录下面的当前目录
# filename= "abc"  #相对路径   。表示当前目录下的这个目录
# with open(filename,'r') as f:
#     print(f.read())

# filename="E:/作业/python考试.txt"  #绝对路径
# with open(filename,'r') as f :
#     txt=f.read()
#     print(txt,type(txt))

# 相对路径
# fn=".\\data\\123.txt"
# with open(fn,'r',encoding="utf-8") as f:
#     txt = f.read()
#     print(txt)



# 绝对路径
# fn="E:/作业/广东省公共数据安全管理办法.txt"
# with open(fn,'r') as f:
#     txt1=f.read()
#     print(txt1)

fn="abc"
with open(fn,'r',encoding="utf-8") as f:
    txt=f.readlines()
    total=0
    for x in txt:
        total+=float(x.rstrip("元\n"))
    print("累计共",total)

到此，就将之前的所有笔记都整理一遍了，一些细的知识点这里并没有列出来，只有一些code来帮助大家理解使用方法，还是要听课或者自学，最后预祝大家这学期Python的学习能够顺利通过，在强调一遍，学习编程最重要的是动手动脑，理解加多练习。