Python基础学习笔记

胆怯与勇敢

已于 2022-06-23 14:56:58 修改

阅读量755

点赞数 1

文章标签： python

于 2021-11-28 11:46:42 首次发布

本文链接：https://blog.csdn.net/qq_52652401/article/details/121589023

版权

第一部分

#3.1

#3.2

#3.3

#3.4

#3.5

#3.6 计算三角形的面积
import math
a = float(input("请输入三角形的边长a:"))
b = float(input("请输入三角形的边长b:"))
c = float(input("请输入三角形的边长c:"))
h = (a+b+c) / 2
area = math.sqrt(h*(h-a)*(h-b)*(h-c))
print(str.format("三角形三边分别为：a={0},b={1},c={2}",a,b,c))
print(str.format("三角形的面积 = {0}",area))

#3.7 输入两个整数a和b,比较两者大小,使得a大于b
a = int(input("请输入第1个整数："))
b = int(input("请输入第2个整数："))
print(str.format("输入值：{},{}",a,b))
if a<b:
    t = a
    a = b
    b = t
print(str.format("降序值：{},{}",a,b))

#3.8 计算分段函数 P59
    #方法1
import math
x = float(input("请输入x的值："))
if x>=0:
    y = math.sin(x) + 2*math.sqrt(x+math.exp(4)) - math.pow(x+1,3)
if x<0:
    y = math.log(-5*x) - math.fabs(x*x-8*x)/(7*x) + math.e #fabs:取绝对值
print(y)
    #方法2
import math
x = float(input("请输入x的值："))
if x>=0:
    y = math.sin(x) + 2*math.sqrt(x+math.exp(4)) - math.pow(x+1,3)
else:
    y = math.log(-5*x) - math.fabs(x*x-8*x)/(7*x) + math.e #fabs:取绝对值
print(y)
    #方法3
import math
x = float(input("请输入x的值："))
y = (math.sin(x) + 2*math.sqrt(x+math.exp(4)) - math.pow(x+1,3))\
    if (x>=0) else(math.log(-5*x) - math.fabs(x*x-8*x)/(7*x) + math.e) #fabs:取绝对值
print(y)

#3.9 已知某课程的百分制分数mark,将其转换为五级制的评定等级grade
    #方法1
mark = int(input("请输入分数："))
if mark >= 90:
    grade = "优"
elif mark >= 80:
    grade = "良"
elif mark >= 70:
    grade = "中"
elif mark >= 60:
    grade = "及格"
else:
    grade = "不及格"
print(grade)
    #方法2
mark = int(input("请输入分数："))
if mark >= 90:
    grade = "优"
elif mark >= 80 and mark < 90:
    grade = "良"
elif mark >= 70 and mark < 80:
    grade = "中"
elif mark >= 60 and mark < 70:
    grade = "及格"
else:
    grade = "不及格"
print(grade)
    #方法3
mark = int(input("请输入分数："))
if mark >= 90:
    grade = "优"
elif 80 <= mark < 90:
    grade = "良"
elif 70 <= mark < 80:
    grade = "中"
elif 60 <= mark < 70:
    grade = "及格"
else:
    grade = "不及格"
print(grade)
    #方法4(错误)
mark = int(input("请输入分数："))
if mark >= 60:
    grade = "及格"
elif mark >= 70:
    grade = "中"
elif mark >= 80:
    grade = "良"
elif mark >= 90:
    grade = "优"
else:
    grade = "不及格"
print(grade)

#3.10 已知坐标点(x,y),判断其所在的象限
x = int(input("请输入x坐标："))
y = int(input("请输入y坐标："))
if x==0 and y==0: print("位于原点")
elif x==0: print("位于y轴")
elif y==0: print("位于x轴")
elif x>0 and y>0: print("位于第一象限")
elif x<0 and y>0: print("位于第二象限")
elif x<0 and y<0: print("位于第三象限")
else: print("位于第四象限")

#3.11
    #方法1
x = float(input("请输入一个数："))
if x>0: y=1
elif x==0: y=0
else: y=-1
print(y)
    #方法2
x = float(input("请输入一个数："))
if x>=0:
    if x>0:y=1
    else: y=0
else: y=-1
print(y)
    #方法3
x = float(input("请输入一个数："))
y=1
if x!=0:
    if x<0: y=-1
else: y=0
print(y)
    #方法4(错误)
x = float(input("请输入一个数："))
y=1
if x!=0:
    if x<0: y=-1
    else: y=0
print(y)

#3.12
a = int(input("请输入整数a："))
b = int(input("请输入整数b："))
c = int(input("请输入整数c："))
if a<b: a,b = b,a
if a<c: a,c = c,a
if b<c: b,c = c,b
print("排序结果(降序):",a,b,c)

#3.13
    #方法1
y = int(input("请输入年份："))
if (y%4==0 and y%100!=0) or y%400==0:
    print("是闰年")
else: print("不是闰年")
    #方法2
y = int(input("请输入年份："))
if y%400 == 0: print("是闰年")
else:
    if y%4 == 0:
        if y%100 == 0: print("不是闰年")
        else: print("是闰年")
    else: print("不是闰年")
    #方法3
y = int(input("请输入年份："))
if y%400 == 0: print("是闰年")
elif y%4 != 0: print("不是闰年")
elif y%100 == 0: print("不是闰年")
else: print("是闰年")
    #方法4
import calendar
y = int(input("请输入年份："))
if calendar.isleap(y): print("是闰年")
else: print("不是闰年")

#3.14 利用for循环求1-100中所有奇数的和以及偶数的和
sum_odd = 0; sum_even = 0
for i in range(1,101):
    if i%2 != 0:
        sum_odd += i
    else:
        sum_even += i
print("1-100中所有奇数的和：",sum_odd)
print("1-100中所有偶数的和：",sum_even)

#3.15
i = 1; sum_all = 0; sum_odd = 0; sum_even = 0
while i<=100:
    sum_all += i
    if (i%2 == 0):
        sum_even += i
    else:
        sum_odd += i
    i += 1
print("和=%d、奇数和=%d、偶数和=%d"%(sum_all,sum_odd,sum_even))

#3.16
i = 1; e = 1; t = 1
while 1/t >= pow(10,-6):
    t *= i
    e += 1/t
    i += 1
print("e =",e)

#3.17
    #矩形块
for i in range(1,10):
    s = ""
    for j in range(1,10):
        s += str.format("{0:1}*{1:1}={2:<2} ",i,j,i*j)
    print(s)
    #下三角
for i in range(1,10):
    s = ""
    for j in range(1,i+1):
        s += str.format("{0:1}*{1:1}={2:<2} ",i,j,i*j)
    print(s)
    #上三角(有点问题)
for i in range(1,10):
    s = ""
    for j in range(i,10):
        s += str.format("{0:1}*{1:1}={2:<2} ",i,j,i*j)
    print(s)

#3.18
while True:
    s = input("请输入字符串(按Q或者q结束)：")
    if s.upper() == "Q":
        break
    print("字符串的长度为：",len(s))

#3.19
    #方法一
import math
m = int(input("请输入一个整数(>1):"))
k = int(math.sqrt(m))
for i in range(2,k+2):
    if m%i == 0:
        break
if i == k+1: print(m,"是素数！")
else: print(m,"是合数！")
    #方法二
import math
m = int(input("请输入一个整数(>1):"))
k = int(math.sqrt(m))
flag = True
i = 2
while i<=k and flag==True:
    if m%i == 0:
        flag = False
    else:
        i += 1
if (flag == True): print(m,"是素数！")
else: print(m,"是合数！")

#3.20
num = 0; scores = 0
while True:
    s = input("请输入学生成绩(按Q或q结束)：")
    if s.upper() == "Q":
        break
    if float(s) < 0:
        continue
    num += 1
    scores += float(s)
print("学生的人数为：{0}，平均成绩为{1}".format(num,scores/num))

#3.21
j = 0
print("100-200之间不能被3整除的数为：")
for i in range(100,201):
    if i%3 == 0: continue
    print(str.format("{0:<5}",i),end="")
    j += 1
    if j%10 == 0: print()

#3.22
import math
while True:
    num = float(input("请输入一个整数："))
    print(str(num),"的平方根为：",math.sqrt(num))
print("Good bye!")

#3.23
hobbies = ""
for i in range(1,4):
    s = input("请输入爱好之一(最多三个,按Q或q结束)：")
    if s.upper() == "Q":
        break
    hobbies += s+" "
else:
    print("你输入了三个爱好")
print("你的爱好为：",hobbies)

#3.24
EPSILON =1e-15  #误差
a = float(input("请输入正实数a："))
t = a
while abs(t-a/t) > EPSILON*t:
    t = (a/t+t)/2.0
print(t)

#3.25
f1 = 1; f2 = 1
for i in range(1,11):
    print(str.format("{0:6}{1:6}",f1,f2),end=" ")
    if i%2 ==0: print()
    f1 += f2; f2 +=f1

#3.26(莫名奇妙)
import random
print("Good Luck!")
print("你今天的幸运随机数是：",random.choice(range(10)))

#3.27(未导入包)
print("Good Luck!")
print("你今天的幸运随机数是：",random.choice(range(10)))

#3.28(零除错误)
a = 1
b = 0
c = a/b

#3.29(逻辑错误)
import math
a = 1; b = 2; c = 1
x1 = -b + math.sqrt(b*b-4*a*c)/2*a
x2 = -b - math.sqrt(b*b-4*a*c)/2*a
print(x1,x2)

#3.30
    #1

    #2

    #3

    #4

    #5

    #6

    #7

    #8


#3.31
1/0

#3.32
a = float(input("请输入一个数："))
if a<0: raise ValueError("数值不能为负数")

#3.33
i1 = 1; i2 = 0
print(i1/i2)

#3.34


#3.35
import turtle
p = turtle.Turtle()
p.color("red")
p.pensize(3)
turtle.speed(1)
p.goto(0,0)
for i in range(4):
    p.forward(100)
    p.right(90)

#3.36
import turtle
p = turtle.Turtle()
p.speed(0)
colors = ["red","blue","green","yellow"]
for i in range(100):
    p.pencolor(colors[i%4])
    p.circle(i)
    p.left(91)

第二部分关键字用法

#abs() 函数返回数字的绝对值。
print("abs(-45):",abs(-45))

#all() 函数用于判断给定的可迭代参数iterable中的所有元素是否都为TRUE，如果是返回True，否则返回False。
print(all(['a','b','c','d']))

#any() 函数用于判断给定的可迭代参数iterable是否全部为False，则返回False，如果有一个为True，则返回True。
print(any(['a','b','c','d']))

#ascii() 函数返回一个表示对象的字符串。
print(ascii('runoob'))

#bin() 返回一个整数int或者长整数long int的二进制表示。
print(bin(10))

#bool() 函数用于将给定参数转换为布尔类型，如果没有参数，返回False。
print(bool(1))

#breakpoint() 函数调用sys.breakpointhook()函数。默认情况下，sys.breakpointhook（）调用pdb.set_trace()函数。
x = 10
y = 'Hi'
z = 'Hello'
print(y)
breakpoint()
print(z)

#bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的。
print(bytearray([1,2,3]))

#bytes 函数返回一个新的bytes对象。
print(bytes([1,2,3,4]))

#callable() 函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回 False，调用对象object绝对不会成功。
print(callable("runoob"))

#chr() 用一个范围在range(256)内的整数作参数，返回一个对应的字符。
print(chr(0x30),chr(0x31),chr(0x61))

#classmethod 修饰符对应的函数不需要实例化，不需要self参数，但第一个参数需要是表示自身类的cls参数，可以来调用类的属性，类的方法，实例化对象等。
class A(object):
    bar=1
    def func1(self):
        print('foo')
    @classmethod
    def func2(cls):
        print('func2')
        print(cls.bar)
        cls().func1()
A.func2()

#compile() 函数将一个字符串编译为字节代码。
str="for i in range(0,10): print(i)"
c=compile(str,'','exec')
print(exec(c))

#complex() 函数用于创建一个值为real+imag*j的复数或者转化一个字符串或数为复数。
print(complex(1,2))

#delattr 函数用于删除属性。
class Coordinate:
    x=10
point1=Coordinate()
print('x=',point1.x)
delattr(Coordinate,'x')
print('x=',point1.x)

#dict() 函数用于创建一个字典。
print(dict(a='a',b='b',t='t'))

#dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
print(dir([ ]))

#divmod() 函数接收两个数字类型参数，返回一个包含商和余数的元组(a//b,a%b)。
print(divmod(7,2))

#enumerate() 函数用于将一个可遍历的数据对象组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中。
seasons=['Spring','Summer','Fall','Winter']
print(list(enumerate(seasons)))

#eval() 函数用来执行一个字符串表达式，并返回表达式的值。
x=7
print(eval('3*x'))

#exec 执行储存在字符串或文件中的Python语句。
exec('print("Hello World")')

#filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
def is_odd(n):
    return n%2==1
newlist=filter(is_odd,[1,2,3,4,5,6,7,8,9,10])
print(list(newlist))

#float() 函数用于将整数和字符串转换成浮点数。
print(float(1))

#format() 增强了字符串格式化的功能。
print("网站名：{name},地址{url}".format(name="菜鸟教程",url="www.runoob.com"))

#frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
a=frozenset(range(10))
print(list(a))

#getattr() 函数用于返回一个对象属性值。
class A(object):
    bar=1
a=A()
print(getattr(a,'bar'))

#globals() 函数会以字典类型返回当前位置的全部全局变量。
a='runoob'
print(globals())

#hasattr() 函数用于判断对象是否包含对应的属性。
class Coordinate:
    x=10
point1=Coordinate()
print(hasattr(point1,'x'))

#hash() 用于获取一个对象(字符串或者数值等)的哈希值。
print(hash("A"))

#help() 函数用于查看函数或模块用途的详细说明。
help("str")

#hex() 函数用于将一个指定数字转换为16进制数。
print(hex(255))

#id() 函数返回对象的唯一标识符，标识符是一个整数。
a='runoob'
print(id(a))

#input() 函数接受一个标准输入数据，返回为string类型。
a=input("请输入一个数:")

#int() 函数用于将一个字符串或数字转换为整型。
print(int(7.8))

#isinstance() 函数来判断一个对象是否是一个已知的类型。
a=2
print(isinstance(a,int))

#issubclass() 方法用于判断参数class是否是类型参数classinfo的子类。
class A:
    pass
class B(A):
    pass
print(issubclass(B,A))

#iter() 函数用来生成迭代器。
lst=[1,2,3]
for i in iter(lst):
    print(i)

#len() 方法返回对象(字符、列表、元组等)长度或项目个数。
str="runoob"
print(len(str))

#list() 方法用于将元组或字符串转换为列表。
str="Hello World"
list2=list(str)
print("列表元素:",list2)

#locals() 函数会以字典类型返回当前位置的全部局部变量。
def runoob(arg):
    z=1
    print(locals())
runoob(4)

#map() 函数会根据提供的函数对指定序列做映射。
def square(x):
    return x**2
print(list(map(square,[1,2,3,4,5])))

#max() 方法返回给定参数的最大值，参数可以为序列。
print("max(80,100,1000):",max(80,100,1000))

#memoryview() 函数返回给定参数的内存查看对象(memory view)。
v=memoryview(bytearray("abcefg",'utf-8'))
print(v[1])

#min() 方法返回给定参数的最小值，参数可以为序列。
print("min(80,100,1000):",min(80,100,1000))

#next() 返回迭代器的下一个项目。
it=iter([1,2,3,4,5])
while True:
    try:
        x=next(it)
        print(x)
    except StopIteration:
        break

#object 所有类的父类，默认所有的类都继承至Object类。
class A(object):
    pass

#oct() 函数将一个整数转换成8进制字符串，8进制以0o作为前缀表示。
print(oct(18))

#open() 函数用于打开一个文件，并返回文件对象。
f=open('test.txt')
f.read()

#ord() 函数是以一个字符串作为参数，返回对应的ASCII数值，或者Unicode数值。
print(ord('a'))

#pow() 方法返回xy(x的y次方)的值。
import math
print("math.pow(100,2):",math.pow(100,2))

#print() 方法用于打印输出，最常见的一个函数。
print("Hello World")

#property() 函数的作用是在新式类中返回属性值。
class C(object):
    def __init__(self):
        self._x=None
    def getx(self):
        return self._x
    def setx(self,value):
        self._x=value
    def delx(self):
        del self._x
    x=property(getx,setx,delx,"I'm the 'x' property.")

#range() 函数返回的是一个可迭代对象，而不是列表类型，所以打印的时候不会打印列表。
print(list(range(5)))

#repr() 函数将对象转化为供解释器读取的形式。
s='RUNOOB'
print(repr(s))

#reversed 函数返回一个反转的迭代器。
seqList=[1,2,4,3,5]
print(list(reversed(seqList)))

#round() 方法返回浮点数x的四舍五入值。
print("round(80.23456,2):",round(80.23456,2))

#set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据。
x=set('runoob')
print(x)

#setattr() 函数对应函数getattr()，用于设置属性值，该属性不一定是存在的。
class A(object):
     bar=1
a=A()
print(getattr(a,'bar'))

#slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
myslice=slice(5)
arr=range(10)
print(list(arr[myslice]))

#sorted() 函数对所有可迭代的对象进行排序操作。
a=[5,7,6,3,4,1,2]
print(sorted(a))

#staticmethod 返回函数的静态方法。
class C(object):
    @staticmethod
    def f():
        print('runoob')
C.f()
cobj=C()
cobj.f()

#str() 函数将对象转化为适于人阅读的形式。
s='RUNOOB'
print(str(s))

#sum() 方法对序列进行求和计算。
print(sum([0,1,2]))

#super() 函数是用于调用父类(超类)的一个方法。
class A:
    def add(self,x):
        y=x+1
        print(y)
class B(A):
    def add(self,x):
        super().add(x)
b=B()
b.add(2)

#tuple 函数将可迭代系列（如列表）转换为元组。
list1=['Google','Taobao','Runoob','Baidu']
print(tuple(list1))

#type() 函数如果你只有第一个参数则返回对象的类型，三个参数返回新的类型对象。
print(type(1))

#vars() 函数返回对象object的属性和属性值的字典对象。
print(vars())

#zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
a=[1,2,3]
b=[4,5,6]
zipped=zip(a,b)
print(list(zipped))

#__import__() 函数用于动态加载类和函数。
import sys
__import__('a')