Python极速入门基础语法

#字符串输出
print("Hello world"+'!!')
#多行输出
print('''第一行
第二行
第三行
''')

s = "Hello python"
print(len(s)) #求长度
print(len(s)-1) #索引获取单个字符

#变量
a =2023.101
print(a)
b = None #空值类型
print(type(a)) #type函数 查看类型
print(type(b))
print(type(True))
print(type(3.14))

#函数库
import math
cul = math.sin(1)
print(cul)
print(math.log2(8))

#输入
text = int(input("输入数字内容：\n"))
print("文本内容:"+str(text))

#条件分支 逻辑运算
e = 0
x = 1
if e == 1 and x == 1:
    print("e=1 and x=1")
elif e == 0 or x == 1:
    print("e=0 or x=1")
else:
    print("e≠0，x≠1")

#大小写转换
Aa = "Python 3.0"
print(Aa.upper())
#修改实参：Aa=Aa.upper()
print(Aa) #不变

#列表 可变
list=["1号","2号"]
list.append("新号") #添加在末尾
list.remove("2号") #删除
list.append(66.6)
list.append(None)
print(list)
list[len(list)-1]="修改号" #更改
print(len(list)) #个数
print(list[len(list)-1]) #元素

#函数
num=[1,89,-342,0]
print(max(num)) #最大
print(min(num)) #最小
print(sorted(num)) #排序

字典 可变 key：value key不可变
contacts={"p":"1",
          "y":"2",
          "t":"3"}
元组 不可变
tuple=("键1",1)

con={("py",30):"12345",
     ("py",80):"4567",
     ("thon",11):"67890"}
print(con)
py_num=con[("py",30)] #赋值
print(py_num)
con["新加入"]="999" #添加
print(con)
print(("thon",11) in con) #防止覆盖
del con["新加入"] #删除
print(con)
print(len(con)) #个数

for 变量名 in 可迭代对象：
finddict={"001":89,"002":567,"007":214}
finddict.keys() #返回所有键
finddict.values() #返回所有值
finddict.items() #返回全部
for fid,ftext in finddict.items():
     if ftext==89:
          print("找到了"+fid)
for tuple in finddict.items():
     id=tuple[0]
     text=tuple[1]
     if id=="007":
          print("找到了"+str(text))

range（开始[,)结束,步长) 整数数列
for i in range(1,10,2):
     print(i)

while
n=0
while n<5:
    print("ddd")
    n+=1

for<=转换=>while
list1=["p","y","t","h","o","n"]
for char in list1:
    print(char)
for ch in range(len(list1)):
    print(list1[ch])
c=0
while c<len(list1):
    print(list1[c])
    c=c+1



con11=["hello","world","python","!"]
alter = "404"
for cc in con11:
    # \n输出换行 \代码换行
    message=cc+" "+alter+" \
    !! "+cc
    print(message)
    # send(cc,message)

format 参数替换
for cc in con11:
    # \n输出换行 \代码换行
    message="{0} {1}   \
    !! {0}".format(cc,alter) #参数顺序替换
    print(message)
for cc in con11:
    message="{cc} {a1}   \
    !! {cc}".format(cc=cc,a1=alter) #变量赋值替换
    print(message)
for cc in con11:
    message=f"{cc} {alter}   \
    !! {cc}"   #前缀替换写法
    print(message)
#format 不用处理变量类型
gpa={"qq":16.22,
     "wechat":18.10}
for app,num in gpa.items():
    print("{0}:{num:.1f}".format(app,num=num)) #.xf 保留小数

#自定义函数 作用域
def calculate11(num1,num2):
    res=num1+num2**num2 #** 次方
    return res
rr=calculate11(3,7)
print(rr)

#引入模块 pypi.org//pip install 库名
#import
import statistics
print(statistics.median([19,-5,36]))
print(statistics.mean([19,-5,36]))
#from..import .. 使用时不用带模块名字
from statistics import median,mean
print(median([19,-5,36]))
print(mean([19,-5,36]))
#from..import * 引入所有内容 容易命名冲突
from statistics import *
print(median([19,-5,36]))
print(mean([19,-5,36]))

#类 pascal命名:
class CatCat:
    #构造函数 调用时自动运行
    def __init__(self,cat_name,cat_age,cat_color): #self，第一个参数占用表示自身
        self.name=cat_name
        self.age=cat_age
        self.color=cat_color
    #自定义
    def speak(self):
        print("喵"*self.age) #重复字符串
    def think(self,content): #content传参
        print(f"小猫{self.name}在思考{content}...")
#
# # #调用init
# # cat1=CatCat()
# # print(cat1.name)
# # cat2=CatCat("Jojo")
# # print(cat2.name)
# cat3=CatCat("Jojo",2,"橙色")
# print(f"小猫{cat3.name}的年龄是{cat3.age}岁，花色是{cat3.color}")
# cat3.speak()
# cat3.think("thinking") #传入参数

#继承 类名（父类）
class Cat(CatCat):
    def __init__(self,cat_name,cat_age,cat_color):
        super().__init__(cat_name,cat_age,cat_color)
        self.sterilization=False
    def variety(self):
        print(self.name+"是小花猫")

# 子类默认调用父类构造方法 子类有构造函数只调用子类构造方法
cat4=Cat("kawa",3,"白色")
print(cat4.name)
cat4.variety()

读文件
文件过大时使用read非常占用内存
open("文件路径","r",encoding="utf-8") #r，第二个参数，不写默认为读 第三个参数，编码方式

f=open("E:\pythonTest.txt","r",encoding="utf-8")
print(f.read()) #读取全部内容并打印 记录读取位置导致第二次读取时为空
print(f.read()) #读取空字符串，并打印 = 返回结果为空
print(f.read(11)) #非一次性读取全部 读取第1-11个字节的文件内容
print(f.read(13)) #继续读取
print(f.readline()) #只读取一行
print(f.readline()) #根据换行符继续读取 全部读完为空

line = f.readline() #读第一行
while line!="": #判断是否为空
    print(line)
    line=f.readline() #下一行

print(f.readlines()) #读取全部内容，并把每行作为列表元素返回

lines = f.readlines() #把每行内容储存到列表里
for linee in lines:
    print(linee)

关闭文件 释放资源
f.close()
缩进内容完成后自动关闭
with open("E:\pythonTest.txt") as f:
    print(f.read())

写文件
不可读
如果文件不存在则自动创建，如果已存在则清空全部内容
with open("E:\pythonTest.txt","w",encoding="utf-8") as f:
    f.write("HiHi!")
    f.write("Hahaa!") #不会自动换行
原文件内容后面追加内容 a,附加模式，不会清空
with open("E:\pythonTest.txt","a",encoding="utf-8") as f:
    f.write("HiHi!")
    f.write("Hahaa!") #不会自动换行 自动换行加\n
同时读写文件 r+，覆盖写 a+，追加写
with open("E:\pythonTest.txt","r+",encoding="utf-8") as f:
    print(f.read())
    f.write("\n  HiHi!")
    f.write("Hahaa!") #不会自动换行

#捕捉异常
try:
    #代码
except ValueError:
    #数值错误 捕捉后停止执行下面代码
except ZeroDivisionError:
    #除零错误
except:
    #捕捉所有错误类型
else:
    #没有错误产生时需要执行的代码
finally:
    #无论是否出错都需要执行的代码

#测试 应另起一个文件负责测试 不和功能代码混在一起
#assert断言 表达式
#表达式=true 继续执行
#表达式=flase AssertionError 中止

#unittest python常用单元测试库 自带
# 自动找出和运行所有测试用例
#测试单元 对软件中的最小可测试单元进行验证
import unittest #引入库
#测试文件与被测试文件在同一文件下
# from 文件名 import 函数名/类名
class 测试类名(unittest.TestCase):
    #表示unittest.TestCase的子类，继承
    def test_123(self):
        #每一个测试用力都是类下面的一个方法
        #函数名必须以test_开头
        #因为库会自动搜索test_开头的方法，且只把test_开头的当成测试用例
        self.assertEquals(函数名(传参),结果)
        #assertionError中断，改用assertEquals继承自unittest
        #传参=结果 测试通过
#终端输入 python -m unittest表示运行unittest
#自动搜索继承unittest库TestCase的子类，运行test_开头的方法，然后展示测试结果
#测试通过：. 测试未通过：F，FAIL：哪个文件下哪个方法失败

unittest.TestCase常见测试用例
assertEqual(A,B)      assert A==B
assertTrue(A)         assert A is True  **
assertIn(A,B)         assert A in B
assertNotEqual(A,B)   assert A!=B
assertFalse(A)        assert A is False
assertNotion(A,B)     assert A not in B

由于每个实现代码对应一个测试代码，不断生成对象造成代码重复
#unittest,TestCase setUp方法
def setUp(self):
    #把测试对象创建好 作为当前测试类的一个属性
#在各个测试方法里通过测试属性获取已创建好的对象