python_review

12-5

# -*- coding: utf-8 -*-
"""
1.题目给定一个表达式（数学公式），你写代码
2.17 对 3 求余数 17 % 3 不要求计算结果，但要能编写出代码
            整除 17 // 3
            多个结果放在一个列表里
注意点：写代码，是给别人看的
第一要务：工整

3.for循环
1) 1-N的迭加
2) 偶数的相加
3) 奇数的相加
4) 平方的相加

4.库的使用：skimage,math,sympy,
numpy,matplotlib
题目会将库和函数告诉你：输入和输出要求告诉你
要求：  动态和静态  A.dot(B)  vs  dot(A,B)

5.给定一个算法，里面有各种公式和说明
你写出相应的代码     if-else语句放到算法里考察

6.改错
"""

s = 0
for i in range(10):
    s += i
print("0~10相加结果为%d" % s)

s = 0
for i in range(0, 10, 2):
    s += i
print("0~10偶数相加结果为", s)

s = 0
for i in range(1, 10, 2):
    s += i
print("0~10奇数相加结果为", s)

# PI^2/6
PI_2_6 = 0
for i in range(1, 1000):
    PI_2_6 += 1 / i ** 2
print("PI^2/6结果为：", PI_2_6)
from math import pi

print(pi ** 2 / 6)

# PI^2/8
PI_2_8 = 0
for i in range(1, 1000, 2):
    PI_2_8 += 1 / i ** 2
print("PI^2/6结果为：", PI_2_8)
print(pi ** 2 / 8)


def fsum(start, end, interval, f):  # f是一个函数
    s = 0
    for i in range(start, end, interval):
        s += f(i)
    return s


def f(n):
    return n


def f2(n):
    return 1 / n ** 2


slist = [fsum(0, 10, 1, f),
         fsum(0, 10, 2, f),
         fsum(1, 1000, 2, f2),
         fsum(1, 100, 1, f2)]
print(slist)

d = {"求和": fsum(1, 10, 1, f),
     "偶数和": fsum(0, 10, 2, f),
     "奇数和": fsum(1, 10, 2, f),
     "pi^2/6": fsum(1, 1000, 2, f2) / 6,
     "pi^2/8": fsum(1, 1000, 2, f2) / 8}
print(d)  # d 在这里仅作为临时别名，考试时要使用有实际意义的命名
for (key, value) in d.items():
    print(key, ":", value)

"""
position argument 放在前面
keyword arguments 放在 position org 后面
"""


def GradientDescent(
        data,
        labels,
        theta,
        max_iters=100,
        tol=1e-8,
        fprint=False
):
    """
    This is gradient descent algorithm.
    介绍一下函数的功能，输入和输出分别是什么
    这是一种梯度下降算法，求解参数theta
    Inputs:
        data:数据
        labels:类别标签
        theta:初始化的参数

    可选参数：
    max_iters,tol,fprint
    """
    pass


data = 3;
labels = 0;
theta = 1.0
g1 = GradientDescent(data, labels, theta,
                     tol=1e-10)
g2 = GradientDescent(data, labels, theta,
                     max_iters=200)

'''第一题
f(x)=[exp(x)-sin(x)+x**2-3x^3+sinc(x)
      +x//3] / (x^2+gamma(x)-4x^4)
工整度放在第一位
'''

# 将复杂运算表达式分装到函数，
import numpy as np
import math


def f(x):
    denominator = np.exp(x) - np.sin(x)
    denominator += x ** 2 - 3 * x ** 3 + x // 3
    numerator = x ** 2 + math.gamma(x) - 4 * x ** 4
    return denominator / numerator


'''字符串的拼接'''
'''这次考试共有5道大题，每题4小问'''
N = 5
n = 4
s1 = "这次考试共有"
s2 = "道大题，每题"
s3 = "小问"
s = s1 + str(N) + s2 + str(n) + s3
print(s1 + str(N) + s2 + str(n) + s3)
print( s.count('题'))

"""
Created on Tue Dec  5 14:48:06 2023

@author: Cherish

答题：
错误1
错误2

正确的代码
TyperError 2 + 'abc' 字符串和数字不能相加
"""
'''
错误：
    1.Indent
'''
# a = 2 #顶格写，不能有空格
a = 2
b = 'abc'
if b is not int:
    raise TypeError("b is not a number")
print(a + b)

12-3

#1
import math
import skimage
expr=(2**3-math.sin(math.pi/2))/2**2
#expr/=5**2
expr=expr%5
print(expr)

a=[17/3,17//3,17%3,5*3+2,5**2,2**7]
print(a)

#2
"""
unexpected indent 不期望的间距（n前面不能有空格）
工程师眼里：格式是最重要的
考试答题时，注重书写，间距不对要扣分
"""
n=2
m=3

#3
"""
Created on Sat Dec  2 10:17:48 2023
1.单引与双引相通，这是一商业行为，不是计算机的
底层逻辑
2.字符串不好更改
@author: Lenovo
"""
a='python'
b="python"
c='''python'''
print(a==b)
print(hash(a),hash(b),hash(c))

#%%
a[0]='b'
#%%
'''想把python改成bzthon
只有新建一个字符串,字符串可以拼接，但不能更改
'''
d='bz'+a[2:]
print(d)
#%%
'''应试题容易考的'''
b='It\'s a dog.'
print(b)
c=r'It\'s a dog.'
print(c)
d="It's a dog."
print(d)
#%%
a='python'
'''输出 py
0:2  0,1
-n:-n+2     -n,-n+1
range(0,3):    0,1,2'''
a1=a[:2];a2=a[0:2];
n=len(a);a3=a[-n:-n+2]
print(a1,a2,a3)
#%%
b=list(range(0,3))
print(b)
#%%
a='python'
'''偶数位
a[::2]:  a[0:end:2]的缩写
第1到5位之间每隔两位输出'''
b=a[::2]
print(b)
c=a[1:5:2]
print(c)
print(a[0],a[1],a[-1],a[-2])
#%%
a='python'
'''
从第4位开始到最后
从0到4'''
print(a[4:],a[:4])

#4
"""
Created on Sat Dec  2 10:14:29 2023
考试时，老师会给定一个函数说明：
比如round 四舍五入，两个参数
第一个是数，第二个是位数
round（number，nd
@author: Lenovo
"""
a=9.47835
print(round(a,3))

#5
"""
赋值 核心原理： = 右边是值，左边是变量名
"""
a,b=1,2
print(a,b)
'''=右边的 b,a+b 是值，等价于2，1+2'''
a,b=b,a+b
print(a,b)
c=round
'''=右侧round虽然是一函数，本质是值'''
print(c)
import numpy as np
u=np.sin(3)
print(u)
f=np
v=f.sin(3)
print(v)

d=[1,2,np.sin,np]

d1,d2,d3,d4=d
print(d1,d2,d3,d4)

d5,d6,_,_=d
print(d5)
print(d6)

#6
x = 6
if x < 0:
    print("error")
    if x % 2 == 0:
        print("x=", x)
print('---------------------------')
if x < 0:
    print("error")
if x % 2 == 0:
    print("x=", x)

# %%
'''
全局变量 vs 局部变量
global variable vs local variable
正确的概念:global vs local 只看indent
'''
s = 0
for i in range(5):
    s += i
    print(s)
print('----------------------------')
s = 0
for i in range(5):
    s += i
print(s)
# %%
'''返回一个函数'''


def f(n):
    def g(m):
        return m * n

    return g


n = 2
g = f(n)
m = 3
print(g(m))
'''
=右边是值，左边是名字
函数：返回值可以是任意，可以是数，字符，函数，库，图像
         y=f(x):x是输入,y是输出
全局 vs 局部：只看间距
'''

#7
"""
Created on Sat Dec  2 11:07:39 2023
for,双重for
@author: Lenovo
"""
import sympy
a=[2,4,6,round,print,skimage,sympy]
for i in a:
    print(i)
for(i,j)in enumerate(a):
    print(i,j)
'''这是一个字典库'''
products={"num_1":2,
          "num_2":4,
          "num_3":6,
          "func_1":round,
          "func_2":print,
          "Lib_1":skimage,
          "Lib_2":sympy}
for(i,j)in products.items():
   print(i,':',j)

#8
'''
1.从0开始，range(10),0可以缺省
2.从某数开始
3.从某数到某数，间隔

1.0，1，2，3，4，5，6，7，8，9
2.2,3,4,5,6,7,8,9
3.2,5,8
'''
s1 = 0
for i in range(10):
    s1 += i
s2 = 0
for i in range(2, 10):
    s2 += i
s3 = 0
for i in range(2, 10, 3):
    s3 += i
print(s1, s2, s3)
print(list(range(10)))
print(list(range(2, 10)))
print(list(range(2, 10, 3)))


a = [2, 4, 6, round, print, skimage, sympy]
for i in range(len(a)):
    print(a[i])

def func(a, b, c):
    pass

'''自定义global不提倡'''

'''def f(n):
    global n
    return n + 1'''

#9
"""
Created on Sat Dec  2 11:27:06 2023
函数里最提倡，也是最常用的keyword 命名法
position argument 必须放在最前面
@author: Lenovo
"""
def course(lecture="python",
           instructor="Gu",
           banji="计科"):
    print("Lecture is",lecture,
          "instructor is",instructor,
          "banji is",banji)
'''定义变量名字时，尽量一致，就不会出错'''
lec='C++'
instructor='Li'
banji='自便'
date='12.2  三四'
course(date,
       banji=banji,
       instructor=instructor,
       lecture=lec)

practice

"""
Created on Sat Dec  2 10:02:02 2023

@author: Lenovo
"""

import math
expr=(2**3-math.sin(math.pi/2))/2**2
#expr/=5**2
expr=expr%5
print(expr)

a=[17/3,17//3,17%3,5*3+2,5**2,2**7]
print(a)

#字符串书写
text1='我是字符串文本数据'
text2="我也是字符串文本数据"
text3="""在三引号包围圈内\n全部都是字符串哦"""

#print函数
print("abc")
print(123)
print("9277万物可爱")

# python语句不以分号结尾，代码缩进控制着不同函数相互间的嵌套和归属
stu_score_dict={
    "王力宏":{
        "语文":77,
        "数学":88,
    },"周杰伦":{
        "数学":99,
        "语文":100
    }
}
print(f"学生的考试信息是：{stu_score_dict}\n")

# 注释
# 我是单行注释
# 单行注释一般用空格与#隔开

"""
   我是多行注释
   使命召唤
   青龙听令！
"""
print("\n")

"""
   变量名=变量值
   a=10
   string
   float
   int
"""

"""type()语句验证数据类型
   语法:typedef(被查看类型的数据)
   结果直接为变量存储的数据类型
   <class 'str'>
"""
print(type("采蘑菇的大灰狼"))
print(type(112))
print(type(1.5678902))


"""
   int(x)
   float(y)
   string(f)
   
   类型得到转换不是万能的，比如
   v_str=("我要")
   num=int(v_str)
   报错,()内不是数字，无法转换
   1.任何类型都可以转换成字符串
   2.字符串内必须是真的数字，才可以将字符串转换为数字
   浮点数转换成整数会丢失精度
"""

# 算术运算符
# + - * / % //取整除 **指数
print("9//2(9整除2)的结果是:%d"%(9//2))
print("2**3(2的3次方结果是：%d)"%(2**3))

"""
   字符串拼接
   "+"连接字符串变量或字符串字面量
"""
name="蔡徐坤"
print("一个名叫"+name+"的男人\n酷爱篮球"+"+背带裤")

# 格式化精度控制
"""
   辅助符号m.n来控制数据的宽度
   m表示控制的位数，不足用空格在数据前面补齐（很少使用）
   小数和小数点也算如宽度计算（发生在小数位限制之后）
   print("%7.2f"11.345)
   小数位的精度设置为2(四舍五入计算精度)，11.35共5位宽度，前面补齐两个空格为7位，结果:
  11.35
   %.2f表示不限制宽度,只将小数位精度设置为2位
"""
print("%7.2f"%11.345)
print("限制宽度%5d"%11)
print("数据不限制宽度%.2f"%12345.456)

"""
   数据输入input()
"""
"""print('请问你是谁')
name=input()
print("原来你是"+name)
字符串无法与非字符串变量拼接
ame="fanghua"
age=18
print("她的名字："+name+"年龄："+age)# error
"""


# 字符串格式化
name="bilibili"
data=1987
time=1314
message="大学历时：%s %s"%(data,time)# %表示占位，将数据转换成字符串
print(name+message)
print("我今年%d岁，名字%s,价格%f"%(18,"wu",90.789))

"""
   比较运算符表达式的结果是布尔类型
"""
result=10<5
print(f"10>5的结果是:{result},类型是{type(10>5)}")

"""
表达式格式化
"""
print("2**3的结果是：%d"%(2**3))
print("string类型%s"%{type("def")})

"""一定要加:
if(判断条件):
    条件成立时执行语句
"""
age=19
if(age<=10):
    print("young")
if age>=20:
    print("new")
else:
    print("old")

"""
while 条件:
    语句1
    语句2
"""
i=0
while i<5:
    print("dar")
    i+=1

"""
python的for循环与C中for有很大区别
for 临时变量 in 待处理的数据集:
    执行
"""
name="its my precious"
#for循环处理字符串
for x in name:
    print(x)
"""
for循环是将字符串内容依次取出,也就是遍历循环
注意循环内的语句要有空格缩进

for 临时变量 in 待处理数据集(可迭代类型)
可迭代类型指,其内容可被一一取出，包括字符串 列表 元组等
"""

#获取简单数字序列(可迭代类型的一种) range()语句
num=5
for i in range(num):
    print(i)#表示获取从0到num结束的数字序列，取得:[0,1,2,3,4]
num1=3
num2=9
range(num1,num2)#获取num1到num2结束的数字序列,不包括num2
step=2
range(num1,num2,step)#step表示从num1到num2获取数字时跳过的步长:[5,7,9]，从获取num1开始
print("输出7以内的偶数")
for i in range(0,7,2):
    print(i)
"""
嵌套if语句,当第一层if判断条件满足才会执行第二层if语句，否则直接执行第一层的else语句
"""
"""if int(input("输入你的体重："))<120:
    print("还行")
    print("再吃")
    if int(input("输入你的身高："))<175:
        print("哎")
    else:
        print("fairy")
else:
    print("y")
"""
i=1
while(i<=3):
    print(i)
    i+=1
i=1
while i<=10:
    print(f"第{i}天")
    j=1
    while j<=10:
        print(f"第{j}枝blossm")
        j+=1
    print("indugle\n")
    i+=1
print(f"坚持到第{i-1}天")

# continue 中断本次循环不再继续执行continue下面的语句，执行下一次cycle
for i in range(1,3):
    print(f"level {i} day with beating heart")
    for j in range(5,7):
     print("暮色")
     if j==6:
         print(f"time for {j} waiting")
# j==6，没有继续执行time

for i in range(3):
    print("love")
    if i==1:
        break
    else:
        print("miss")
        continue
        print("false")

"""
def 函数名(传入参数)：
     函数体
     return 返回值
     
函数调用：函数名(参数)
参数可省，返回值可省，必须先def再使用
"""
def add(x,y):
    x+=1
    y+=2
    print(f"{x+y}")
add(3,2)

# 局部变量 函数体内部变量
def ins():
    num=100
    print(num)
ins()
#print(num)# error, name 'num' is not defined

# global 关键字声明全局变量
def insB():
    global sql# global关键字先声明全局变量再赋值
    sql=3399
    print(sql)
insB()
print("全局变量%d"%sql)

# 返回一个函数
def fun(m):
    def g(n):
        return m*n
    return g

n=2
g=fun(n) # g作为fun函数的返回值返回一个函数
m=3
print(fun(g(m)))
print(fun(m))
print(g(m))

def crc(x):
    def cr(y):
        def c(z):
            return z**y+x
        return c
    return cr
x1=1
m=crc(x1)
x2=2
n=m(x2)
x3=3
q=n(x3)
print(q)
# 用函数做函数函数返回值，不能添加基本数据类型，这样返回值类型   return 函数+基本数据类型 error ,只能是 return 函数
## 向被嵌套函数传参，从最外层函数开始传入第一个参数...


"""
数据容器  是一种可存放多个同类型数据的数据类型
分为列表(list),元组(tuple),字符串(str),集合(set),字典(dict)
"""
# 列表 list  变量名称=[elem1,elem2,elem3...]
stu_list=[100,99,98]
print(stu_list)
stu_name_list=['蔡徐坤','鸽鸽','啊a~']
print(stu_name_list)
score_col=[['red','blue'],[1,4],stu_name_list,stu_list]# 嵌套列表
print(score_col)
#列表的下标索引  列表名[下标]   第一个元素位置从0开始
print(stu_list[0])
print(score_col[2])
# 反向索引 -1 -2 -3      -1下标为列表内最后一个元素位置
print(stu_list[-1])#98
print(stu_list[-2])#99

# 列表常用操作1:在列表的尾部追加"单个"元素    列表名.append(元素)
mylist=["i",'love']
mylist.append('you')
print(f"列表名.append操作结果{mylist}")
# 列表常用操作2:追加一批元素   列表.extend(另一个数据容器)
mylist2=['w','i','t','h']
mylist.extend(mylist2)
print(f"列表名.extend操作结果：{mylist}")
# 列表常用操作3:在指定下标位置插入元素(0开始) 列表.insert(下标,elem)
mylist.insert(1,'trap')
print(f"列表名.insert(1,'trap')操作结果：{mylist}")
#删除指定下标位置元素
del mylist[1]
print(f"del 列表[下标] 操作结果：{mylist}")
# 统计列表内元素数量 列表.count(elem)
count=mylist.count("i")
print(count)
# 查找某个元素下标索引 列表.index(elem)
'''index=mylist.index('i')
print(f'mylist.index(elem)'%index)'''
# 统计列表中全部元素数量 len(列表)
'''print('列表中全部元素数量为：'%len(mylist))'''




# 列表遍历
print(f"'love'下标为{mylist.index('love')}")# 列表.index(元素)  查看元素下标
for i in mylist2:
    print(i)
    
#len(列表名)   统计列表中元素数量
'''j=0
while j<len(mylist):
    print(mylist(j))
    j+=1'''


'''
元组：

'''
t4=(1,2,['刑天','修罗'])
t4[2][0]='黄粱一梦'
t4[2][1]='大梦初醒'
print(t4)

'''
字符串
'''
name="sizetheday andslive it it to the full"
print(name[0],name[1],name[-1],name[-3]) # -1往前  0往后
print(name.index("to"))# name.index(str) name.index(str返回查找字符串第一个字符的下标)
name2='sql sever'
# 字符串替换  str.replace(要替换的字符串,替换成的str内容)  str本身不变而是得到一个新的str2
name_str=name.replace("and","sql sever")
print(name_str)
# 按照指定的分隔符把str分割成指定字符串 str.split(分隔符字符串)
name_=name.split(" ")
name_s=name.split("s")
print(name_,name_s)# 最终是得到一个按分隔符分割的列表
#str.count(str2)
print(f"字符串'it'在name出现次数为{name.count('it')}")
print(f"name字符个数为:{len(name)}")
N=9
str1="str1";str2="str2"
print(str1+str2+str(N))



'''
字典
'''
my_dict1={"王力宏":99,
          "弼马温":100,
          "JJ林俊杰":90}
for (key,value) in my_dict1.items():
    print(key,":",value)
# 获取字典的全部key    字典名[key] 访问字典key值对应的元素
for key in my_dict1:
    print(key,":",my_dict1[key])


#数据容器转字符串 str(数据容器名)
print(str(name))



# 逆序排列  sorted(数据容器,reverse=True)
print(f"字典对象的反向排列结果：{sorted(my_dict1,reverse=True)}")

# 集合
set1={1,2,3,4,5}
for i in set1:
    print(i)
set1.remove(2)
print(set1)
# 集合.pop()   从集合随机取出一个元素并返回这个元素，原集合中这个元素会被删除
set1_pop=set1.pop()
print(set1_pop)
print(set1)


'''
切片：序列-列表、元组、字符串均支持，就是从一个序列中取出一个子序列
语法：  序列[起始下标:结束下标:步长]
不保函结束下标位置的元素
'''
my_list=[1,2,3,4,5]
new_list=my_list[1:4]# 下标从1开始，下标4结束(不包含4下标元素)
new_list2=my_list[::2]# 下标1开始到最后 步长2
for i in my_list:# 下标0为第一个元素位置，类似数组
    print(i)
print(f"mylist[1:4]操作结果为:{new_list}")
print(f"mylist[::2]操作结果为:{new_list2}")
 

my_tuple=(1,2,3,4,5,['芳华'],3.14)# 元组可容纳不同数据类型
new_tuple=my_tuple[:]# 从头开始到最后结束 步长1
print(new_tuple)

my_str="123456"
new_str=my_str[:4:2]# 从头开始到4结束--获取0下标元素，步长2
print(f"my_str[:4:2]操作结果为{new_str}")
new_str2=my_str[::-1]# 倒序
print(f"my_str[::-1]操作结果为:{new_str2}")

动态、静态、类方法、实例,global

class Myclass:# 定义一个类Myclass
    def fun1(self,s):# 构建类的方法fun1,self表示实例本身
        print("<<<",s,">>>")
        # 构建类方法
        @classmethod
        def fun2(cls,s): # cls表示类本身
            print("+++",s,"+++")


# 实例方法
# 1.通过实例对象调用类型中的方法
# 通过变量赋值方式构建实例对象c,c的类型是Myclass类型
c=Myclass()
c.fun1("ok")
# self表示我们调用的实例对象本身

# 2.通过类调用方法
Myclass.fun1(c,"with you")
# 传入两个参数,实例对象c与字符串参数
# 方法：实例方法，类方法，静态方法

# 2.类方法  类名.方法(传入参数) 不包括类名作为参数
Myclass.fun2("precious")
c.fun2("fu")


"""from datetime import datetime
 # datetime.now()
d=datetime()
print(d.now())

d=datetime(2022,2,3)
print(d.ctime())
print(datetime.ctime(d))"""

class Pop:
    age=20
    @staticmethod
    def pr(s):
        print("调用staticmethod方法："+s)

"""
@staticmethod
def 函数名：
   函数体
静态方法的调用:
"""
m=Pop()
print(m.age,Pop.age)
print(m.pr("static"))
m.age=10
print(m.age) # 类中定义变量是局部变量，可更改

"""
动态方法
def 函数名：
   函数体
"""
class Myclass:
    def dymethod(self,s):
        print(f"dymethod{s}")
# 构建实例对象并通过实例对象调用类方法
# 此时实例对象名会被当作第一个参数self--实例
f=Myclass()
print(f.dymethod("with"))
# 通过类调用方法
print(Myclass.dymethod(f,"method"))



"""
global关键字需要在函数内部声明
则函数内部可对声明的全局变量操作,函数外部对全局变量再次赋值不影响函数外部全局变量的取值
def 函数名：
    global x
    x=8 # 为全局变量x赋值
    函数体
"""

def fun():
    global x
    x=4
    print(f"fun():{x}")

fun()
x=6 # 函数外部再次为x赋值
print(f"函数外部：{x}")
fun()
"""
Inputs:
fun():4
函数外部：6
fun():4
"""