input()用于输入,其有返回值(即用户输入的值),默认返回字符串。括号里可放提示语句
一行代码若想分为多行来写,需要在每一行的末尾加上“\”
单个“/”表示数学中的除法,不会取整。“//”才会向下取整。
字符串类型可以乘以整数类型,相当于这个字符串被复制了整数倍,若做输出,即会重复输出。
条件语句
if [条件] :
[执行语句]
[执行语句]
elif [条件二]:
[执行语句]
else :
[执行语句]
(要有缩进,[条件]外面不用中括号也不用小括号)
逻辑关键词
(not 非) > (and 与) > (or 或)
方法与函数
方法:对象.方法名()
函数:函数名()
列表(list)
-
与普通数据类型(字符串,整型,浮点型,布尔型)的区别:列表在调用函数或方法对其代表的值进行改变时,其本身值确实会被改变;而普通数据类型调用函数或方法进行改变时,其本身的值不会被改变,相当于是其值被复制了一遍,改变的是复制后的值,然后进行输出或其他操作。
-
常用方法:
.remove(【元素】)
(移除),.append(【元素】)
(添加).min(【列表】)
(返回列表中的最小值).max(【列表】)``.sort(【列表】)
(给列表排序)len(【列表】)
(返回列表长度) -
命名方式:
a = [【元素】,【元素】]
(可以为空,里面可以有任何元素(但必须是同一类型),用逗号分隔) -
赋值:
a[1] = 【另一个元素】
字典(dictionary)
-
命名方式:
a = { 【key】 : 【value】, 【key】 : 【value】 }
(key必须是不可变的数据结构) -
旧键赋新值或新增键值对:
a[【key1】] = 【value2】
-
判断某个键是否已经存在:
【key】 in a
,若存在,则该表达式的值为True,否则为False -
删除键值对:
del a[【key1】]
-
常用方法:
.keys()
(返回里面的所有键).values()
(返回里面的所有值).items()
(返回里面的所有键值对)
元组(tuple)
-
命名方式:
a = (【元素】, 【元素】)
-
不可变,可作为字典的key
-
访问元组中的元素:a[1]、a[0]
循环(for)
-
写法:
for 【变量名】 in 【可迭代的对象】:
(变量名处可以是多个变量,相应的可迭代对象得有同样多数量的值) -
range(a, b):a≤ x<b range(a, b, c) :c为步长
格式化字符串
用format()方法或直接在字符串前加 ‘ f ’,举例
y = 90
a = 90.2
c = "jijin"
str1 = "嘻嘻哈哈{0}红红火火{2}恍恍惚惚{1}是啊{0}".format(y, a, c)
#或者如下
str2 = "嘻嘻哈哈{y2}红红火火{c2}恍恍惚惚{a2}是啊{y2}".format(y2 = y, a2 = a, c2 = c)
#或者如下
str3 = "嘻嘻哈哈{y2}红红火火{c2}恍恍惚惚{a2}是啊{y2}".format(y2 = 90, a2 = 90.2, c2 = "jijin")
#或者如下
str4 = "嘻嘻哈哈{y}红红火火{c}恍恍惚惚{a}是啊{y}".format(y = y, a = a, c = c)
#或者如下
str5 = f"嘻嘻哈哈{y}红红火火{c}恍恍惚惚{a}是啊{y}"
#或者如下
str6 = f"嘻嘻哈哈{90}红红火火{'jijin'}恍恍惚惚{90.2}是啊{90}"
#打印结果皆如下
嘻嘻哈哈90红红火火jijin恍恍惚惚90.2是啊90
若要控制浮点数的小数位数,比如三位小数,则在具体值或者变量的后面加上“:.3f
”
函数
- 写法:
def fun1():
#函数体
#。。。
def fun2(a, b): #无需说明参数类型,也无需说明函数类型
c = a+b
print(c)
return a #若没写 return 语句会有默认的 return None
引入模块
-
import 【模块】
-
from 【模块】 import 【函数】
-
from 【模块】 import *
-
引入第三方库,需要先在互联网上下载,用命令pip install来安装,pypi.org这个网站可以对第三方库进行搜素。
类
#定义一个类
class Cat:
def __init__(self, name, age): #构造函数,必写,名字固定为 __init__() (注意,左右各两个横线) 第一个参数必须是self,代表自己
self.name = name #左侧即为对象拥有的属性,在构造函数里定义,不能在外面定义。
self.age = age
self.color = "white"
def meow(self): #自定义方法,第一个参数也必须是self
print(f"{self.name} is meowing.")
def show_info(self):
print(f"{self.name} is {self.age} years old and {self.color} in color.")
#创建一个对象
cat1 = Cat("Fluffy", 3) #创建对象的时候可以不用传入self的值
cat1.meow() #调用方法的时候也可以不用传入self的值
cat1.show_info()
#输出结果
Fluffy is meowing.
Fluffy is 3 years old and white in color.
继承
class Mammal:
# 定义哺乳动物类,初始化时接受一个名字参数
def __init__(self, name):
self.name = name
self.has_tail = True
def speak(self):
print(f"{self.name} speaks.")
class Dog(Mammal):
# 定义狗类,继承自哺乳动物类,初始化时接受一个名字参数
def __init__(self, name):
super().__init__(name)
# 重写说话方法,打印狗叫的信息
def speak(self):
print(f"{self.name} barks.")
# 定义取物方法,打印狗取物的信息
def fetch(self):
print(f"{self.name} is fetching.")
class Human(Mammal):
# 定义人类,继承自哺乳动物类,初始化时接受一个名字参数
def __init__(self, name):
super().__init__(name)
self.has_tail = Flase #修改父类继承过来的属性
# 重写说话方法,打印人说话的信息
def speak(self):
print(f"{self.name} talks.")
# 打印人是否有尾巴的信息
def show_has_tail(self):
print("Do humen have tails? " + str(self.has_tail))
# 创建一个Dog对象,名字为Rufus
dog = Dog("Rufus")
dog.speak() # 调用Dog对象的speak方法
dog.fetch() # 调用Dog对象的fetch方法
# 创建一个Cat对象,名字为Whiskers
human = Human("Jack")
human.speak() # 调用Human对象的speak方法
human.show_has_tail() # 调用human对象的show_has_tail方法
# 输出结果
Rufus barks.
Rufus is fetching.
Jack talks.
Do humen have tails? False
文件路径常识(对于Windows系统来说)(相对路径)
在同一目录下的文件,如果想要相互找到彼此的话,可以直接使用文件名,不用前面再加一个“./”
读取文件
-
使用函数
open()
,open("【文件路径】", "【模式】", "【encoding=】")
-
【文件路径】:可以写绝对路径,也可以写相对路径。
-
【模式】:传入一个字符串,常用的有"r"(只读),和"w"(只写)两种模式。若不写,则默认为只读模式。读取模式下,如果程序找不到对应的文件名的话,就会报一个
"FileNotFoundError"
的错误。 -
【encoding】:也是可选的参数,可不写
-
open()
函数会返回一个文件对象,可以后续对它进行读取和写入的操作。 -
读取(“r”):
-
例如,把文件对象赋值给一个变量
f
,f.read()
就可以一次性读取文件里的所有内容,并以字符串返回,print(f.read())
即可将其打印出来。 -
一个文件对象的read()方法不可以连续调用,因为每次调用都会读取全部的内容出来,并且它会记录上次读取到哪。所以,第一次调用完之后,第二次调用时只能读取到空的字符串了。
-
若不想全部读取,那就传入一个数字作为参数,表示一次读取多少字节。
-
f.read(10) # 第一次,读1-10字节的文件内容
f.read(10) # 第二次,读11-20字节的文件内容
f.readline() # 每次读一行的文件内容,根据换行付来判断什么时候本行结束
f.readlines() # 会读取全部内容,并把每行作为列表元素返回,常与for循环结合
f.close() # 关闭文件,释放资源
# 若容易忘记调用close()方法,可用如下写法:
with open("./data.txt") as f : # 用with写法
print(f.read()) # 对文件进行操作 要记得缩进
# 这样,当缩进部分的代码执行完后,资源会自动释放
-
写入(“w”):
-
写入模式下,如果找不到文件名,会自动在路径下创建一个新的文件。
-
若文件是存在的,那么会将文件原有内容清空,然后写入新的内容。若不想原有内容被清空,则应该用“a”模式(附加模式)
-
用write()方法来进行写入。如
write("aaaa")
。
-
-
其他模式:
-
“r+”:可读也可写入
-
“a+”:可读也可追加
-
写入和追加是有区别的。追加是在文件末尾进行写入。而写入是看当前指针在哪个位置,最开始指针位置为1,如果之有过read操作,那么指针会后移,这时再调用write()的话,就是从上次read的结束位置开始写入。
-
异常处理
try:
user_weight = float(input("Enter your weight in kilograms: "))
user_height = float(input("Enter your height in meters: "))
bmi = user_weight / (user_height ** 2)
except ValueError: # If user enters non-numeric input
print("Invalid input. Please enter a number.")
except ZeroDivisionError: # If user enters height as zero
print("Invalid input. Height cannot be zero.")
except: # If any other error occurs
print("An error occurred. Please try again.")
else: # If no error occurs
print("Your BMI is:", bmi)
finally: # This block is always executed
print("Thank you for using our BMI calculator.") again.")
测试
调用python自带的库:unittest
# 被测试函数所在文件 add_calculator
def add2(a, b):
return a + b
# 测试文件 test_add_calculator
import unittest
from add_calculator import add2
class TestAdd2(unittest.TestCase): # 写一个子类继承于unittest.TestCase
# 每一个方法就是一个测试用例,命名方式必须以test_开头,只有这样才能被unittest当作测试用例
def test_positive_with_negative(self):
self.assertEqual(add2(100, -100), 0)
def test_positive_with_positive(self):
self.assertEqual(add2(100, 100), 200)
def test_negative_with_negative(self):
self.assertEqual(add2(-100, -100), -200)
def test_negative_with_positive(self):
self.assertEqual(add2(-100, 100), 0)
if __name__ == '__main__':
unittest.main()
# 输出结果
.... # 通过为 . 不通过为 F
----------------------------------------------------------------------
Ran 4 tests in 0.000s
OK
本质上,assertTrue可以代替这些所有的方法。
但推荐使用更有针对性的方法,因为更有针对性的方法会给出更详细具体的原因。
高阶函数
高阶函数可以把函数作为参数。作为参数的函数是直接把函数名作为参数传入,后面不要带括号和参数,因为如果带括号和参数,传入的就是函数的返回值了,而不是函数本身了。
匿名函数
无需名字,即用即扔。关键字:lambda
def calculate_and_print(num1, num2, calc_func):
print(calc_func(num1, num2))
calculate_and_print(7, 5, lambda num1, num2: num1 * num2) # 输出35
# num1、num2为传给匿名函数的参数,匿名函数不需要专门写 return,直接放上要放回的结果即可(即上面冒号后面的 “num1 * num2”
# lambda表达式的语法:lambda 参数1, 参数2, ... : 表达式
# lambda表达式也可以直接作为一个函数来计算,如下:
(lambda num1, num2: num1 * num2)(7, 5) # 输出35
# 但是一般不推荐这么做,因为lambda表达式的可读性不高。
# 匿名函数也有局限,即它的冒号后面不能有复杂的语句,只能是一行表达式。
本文是学习b站up主“林粒粒呀”《三小时python课程》时记的笔记
课程链接:你觉得自己这辈子都学不会编程?超超超基础Python课程,3小时快速入门 【自学Python教程合集】【3小时快速入门Python】