Python学习笔记
声明:B站所看视频链接以及python书籍内容,自己仅作为自己学习笔记记录,不作为其他用途
链接: https://www.bilibili.com/video/BV1rg411G7mp?from=search&seid=3903997370168689438&spm_id_from=333.337.0.0. python结合医学
书籍:《Python编程 从入门到实践》
基础知识
第1章 变量和简单数据类型
1.1 变量
1.1.1 变量的命名和使用
命名规则:
- 字母、数字和下划线,但不能以数字开头;
- 变量不能含空格,可以以下划线间隔;
- 不要将Python关键字和函数名用作变量名;
- global 变量名声明全局变量在函数中的标识符
type(变量名) 查数据类型
message = "Hello world!"
print(message)
message = "变量练习"
print(message)
print(type(message)) #<class 'str'>
1.1.2 输出/输入
- sep = ‘’,end = ‘’
- input() #默认字符串,提示信息,接受的必须是表达式
# -*- codeing = utf-8 -*-
# @Time:2022/5/48:23
# @Author:yugan
# @File:demo1.py
# @Software:PyCharm
#格式化输出
print("我叫%s,来自%s"%("鱼干","中国"))
#我叫鱼干,来自中国
age = 18
print("我今年%d岁"%age)
#我今年18岁
print('aaa','bbb','ccc')
#aaa bbb ccc
print('www','baidu','com',sep='.')#sep分隔
#www.baidu.com
print('helllo',end='')#end=''表示不换行
print('world',end='\t')
print('Python',end='\n')
print('end')
#hellloworld Python
#end
#输入
password = input("请输入密码:")
print("您刚刚输入的密码是:",password)
#请输入密码:123456
#您刚刚输入的密码是: 123456
1.2 字符串
用引号括起得都是字符串,引号可以使单引号也可以是双引号
- 区间索引[A:B:n]
- 从位置A到B的部分字符串,不包含位置B
- A起始位置,B结束位置,n步长
1.2.1 使用方法修改字符串的大小写
方法名 | 作用 |
---|---|
变量名.title() | 以首字母大写的方式显示每个单词 |
变量名.upper() | 字符串全部大写 |
变量名.lower() | 字符串全部小写 |
name = "my name is python"
print(name.title())#My Name Is Python
print(name.upper())#MY NAME IS PYTHON
print(name.lower())#my name is python
1.2.2 合并(拼接)字符串
‘+’连接
name = "Python"
print("Hello" + " " + name + "!")
1.2.3 字符串相关操作
- 字符串分割 :string.split()
- 字符串格式化输出 :使用{}占位string.format()
- 如:‘{}公斤{}厘米’.format(70,175)
符号 | 作用 |
---|---|
\n | 换行 |
\t | 制表符(空格) |
\ | 转义(\后引号正常输出) |
\r | 光标移动到一行的开始 |
|反斜杠 | |
r"字符串内容" | 防止字符转义 |
‘’’ ‘’’ | 允许字符跨多行 |
print("I'm a student")
print('I\'m a student')
print(r"I'm a student")
1.2.4 删除空白
方法名 | 作用 |
---|---|
变量名.rstrip() | 字符串末尾没有空白 |
变量名.lstrip() | 字符串开头没有空白 |
变量名.strip() | 字符串两端没有空白 |
1.2.5 常见操作
名称 | 描述 |
---|---|
isalnum() | 字符串至少有一个字符并且所有字符都是字母或数字则返回True,否则返回False |
isalpha() | 字符串至少有一个字符并且所有字符都是字母则返回True,否则返回False |
isdigit() | 字符串只包含数字则返回True,否则返回False |
isnumeric() | 字符串只包含数字字符则返回True,否则返回False |
join(seq) | 以指定字符串作为分隔符,将seq中所有的元素合并为一个新的字符串 |
len(string) | 返回字符串长度 |
split(str=“”,num=string.count(str))num=string.count(str)) | 以str为分隔符截取字符串,如果num有指定值,则仅截取num+1个字符串 |
1.3 数字
1.3.1 整数、浮点数、布尔值
整数:
浮点数:
布尔值:false相当于0,true相当于1
- 类型转换
- 整数->浮点数 float(4)->4.0
- 浮点数->整数 int(3.14)->3
- 字符串->整数,浮点数 int(‘3’)->3,float(‘3.14’)->3.14
1.3.2 运算符
类别 | 运算符 | 含义 |
---|---|---|
算术 | / | 结果为浮点数 |
… | // | 整除 |
… | % | 取余 |
… | ** | 幂运算/次方运算 |
赋值 | += | |
… | -= | |
… | *= | |
… | /= | |
… | %= | |
… | **= | |
… | //= | |
比较 | == | 相等 |
… | != | |
… | >= | |
… | <= | |
比较运算符返回结果为false或true | ||
位运算符 | & | 与:相同为1不同为0 |
… | 1 | 或:有1为1 |
… | ^ | 异或:不同为1 |
… | ~ | 取反:1为0,0为1 |
… | << | 左移:高位丢弃,低位补0 |
… | >> | 右移: |
第2章 列表
2.1 列表表示与访问
#列表的表示
liebiao = ['alice',23,50.8,120,90,65]
print(liebiao)
#访问列表元素
print(liebiao[0].title())
#访问最后一个元素用索引-1
print(liebiao[-1])
2.2 列表的相关操作
列表操作符 | 含义 |
---|---|
list1+list2 | 合并(连接)两个列表 |
list1*n | 重复n次列表内容 |
len(list1) | 返回列表长度(元素个数) |
x in list1 | 检查元素是否在列表中 |
2.2.1 增、删、改,查操作
方法 | 含义 |
---|---|
列表名[索引号] = 元素 | 修改元素/替换 |
列表名.append(元素) | 列表末尾添加元素 |
列表名.extend(列表名) | 列表的追加(拆散加入) |
列表名.insert(索引号,元素) | 插入元素 |
del 列表名[索引号] | 删除指定位置元素 |
列表名.pop() | 删除列表末尾元素,但是依旧可以使用 |
列表名.pop(索引号) | 弹出列表中任何位置的元素 |
列表名.remove(元素) | 删除指定元素(依旧可以使用,重复内容只删一个) |
in ,not in | 在/不在 |
列表名.index(‘元素’,起始下标,终止下标) | 查找指定下标范围的元素,并返回找到对应元素的下标(区间左闭右开),找不到会报错 |
列表名.count(‘元素’) | 统计指定元素出现几次 |
# append与extend的区别
a = [1,2]
b = [3,4]
c = [5,6]
a.append(b)
print(a) #[1, 2, [3, 4]]
a.extend(c)
print(a) #[1, 2, [3, 4], 5, 6]
#删del、pop、remove
namelist = ['小红','小王','小兰','鱼干']
#del namelist[0] #小王 小兰 鱼干
#namelist.pop() #小红 小王 小兰
namelist.remove("鱼干") #小红 小王 小兰
for name in namelist:
print(name)
#pop
liebiao = ['alice',23,50.8,120,90,65]
popliebiao = liebiao.pop(0)
print(liebiao) #[23, 50.8, 120, 90, 65]
print(popliebiao) #alice
#查 in not in
namelist = ['小红','小王','小兰','鱼干']
findname = input("请输入查找名字:")
if findname in namelist:
print("存在")
else:
print("不存在")
#请输入查找名字:鱼干
#存在
#index()索引查找
list1 = ['a','b','c','a','b']
print(list1.index('a',1,4))#从1-4下标寻找是否存在a
#3
print(list1.count('b')) #2
2.2.2 列表排序、反转、长度获取
方法名 | 含义 |
---|---|
列表名.sort() | 对列表进行永久性排序(升序) |
列表名.sort(reverse = True) | 降序 |
sorted(列表名) | 函数对列表进行临时排序 |
列表名.reverse() | 对列表元素反转操作 |
len(列表名) | 获取列表长度 |
liebiao = ['b','a','c']
#字母顺序
liebiao.sort()
print(liebiao) #['a', 'b', 'c']
#字母相反顺序
liebiao.sort(reverse = True)
print(liebiao)#['c', 'b', 'a']
#使用函数进行临时排序
liebiao = ['b','a','c']
print(sorted(liebiao)) #['a', 'b', 'c']
print(liebiao) #['b', 'a', 'c']
#反转
liebiao = ['b','a','c']
liebiao.reverse()
print(liebiao) #['c', 'a', 'b']
#获取长度
print(len(liebiao))#3
2.3 列表嵌套(遍历、创建)
2.3.1 遍历列表
name = [[],[],[]] #有3个元素的空列表,每个元素都是一个空列表
name = [['小红','小兰'],['鱼干']]
print(name[0]) #['小红', '小兰']
print(name[0][0]) #小红
for循环
liebiao = ['b','a','c']
for lie in liebiao:
print(lie)
2.3.2 创建数值列表
函数名 | 含义 |
---|---|
range(1,5) | 创建 1,2,3,4 |
list(range(1,5)) | 将range结果转为列表 |
range(1,5,步长) | 指定步长 |
for shuzi in range(1,5):
print(shuzi)
liebiao = list(range(1,6))
print(liebiao)
#指定步长
liebiao1 = list(range(1,6,2))
print(liebiao1)
#创建列表包含前10个数的平方
squares = []
for value in range(1,11):
squares.append(value ** 2)
print(squares)
2.3.2 最大值、最小值、总和
digits = [1,2,3,4,5]
print(min(digits))
print(max(digits))
print(sum(digits))
2.3.3 列表解析
squares = [value**2 for value in range(1,11)]
print(squares)
2.4 使用列表的一部分
2.4.1 切片
digits = [1,2,3,4,5]
print(digits[0:3]) #
print(digits[:3]) #从头开始
print(digits[1:]) #终止至末尾
print(digits[-3:])#最后三个元素
2.4.2 遍历切片
digits = [1,2,3,4,5]
for digit in digits[:3]:
print(digit)
2.4.3 复制列表
digits = [1,2,3,4,5]
fuzhi = digits[:]
print(fuzhi)
2.5 练习
8个老师随机放入三个办公室中
#8个老师随机放到3个办公室
import random #随机数生成
offices = [[],[],[]] #三个办公室
names = ['A','B','C','D','E','F','G','H'] #8个老师
for name in names:
index = random.randint(0,2) #老师随机分配三个列表,索引为0,1,2
offices[index].append(name) #将老师名字加入列表中
i = 1
for office in offices:
print("办公室%d的人数为:%d"%(i,len(office))) #输出办公室(1开始),所容纳人数
i += 1
for name in office:
print("%s"%name,end='\t')
print('\n')
print("-"*10)
购物车
根据products列表写一个循环,不断询问用户买什么,用户选择一个商品编号后,就把对应商品添加到购物车中,最终输入q退出,打印购买商品列表
products = [['ipone',6888],['MacPro',14800],['小米6',2499],['coffee',31],['Book',60],['Nike',699]]
#第一问
print('-'*4 + '商品列表' + '-'*4)
index = 0
for shop in products:
print("%d\t%s\t%d"%(index,shop[0],shop[1]))
index += 1
print("================")
for i in range(6):
print("%d\t%s\t%d" % (i, products[i][0], products[i][1]))
i +=1
#第二问
list = [] #购物车列表
money = 0
i = 0
while i < len(products):
num = input("请输入您想购买商品的编号")
if num == 'q':
break
num = int(num)
list.append(products[num])
for shop in list:
money += shop[1]
print("购物车里有:",list,"共花费%d"%money)
第3章 元组
3.1 元组介绍
- 采用()标识,似列表,但不可修改
- 无append(),insert(),用"+"连接
- 有序集合,与列表相同索引方法 calssmates = (‘1’,’2’,’3’)
classmates[0] classmates[0:2],classmates[:2],classmates[1:] - 列表和元组都是有序集合,但是列表可以修改,元组不可以。
禁止修改元组
#元组的定义与输出
yuanzu = (200,50)
print(yuanzu[0]) #200
#元组只含一个元素时,需要用,,否则不任务是元组类型
a = (1)
print(type(a)) #<class 'int'>
a = (1,)
print(type(a)) #<class 'tuple'>
第4章 if语句
cars = ['audi','bmw','subaru']
for car in cars:
if car == 'bmw':
print(car.upper())
else:
print(car.lower())
4.1 条件测试
符号 | 含义 |
---|---|
== | 检查是否相等 |
!= | 检查是否不相等 |
and /or | 检查多个条件 |
in | 检查特定值是否包含在列表中 |
not in | 检查特定值是否不包含在在列表中 |
car = 'ab'
print(car == 'ab') #True
print(car == 'AB')#False
print(car != 'AB')#True
print('ab' in car)#True
4.2 if-elif-else语句
4.4 多个elif语句
4.5 省略else代码块
第5章 字典
字典是一系列键对值
5.1 使用字典
- 字典名.get()
zidian= {'yanse':'red','num':12}
print(zidian['yanse']) #red
print(zidian.get("yanse")) #red
print(zidian.get("age","m")) #没有找到会返回默认值m
new_zidian = zidian['num']
print("my old is" +' ' + str(new_zidian))#my old is 12
5.2 增、删、改
- pop(key)
- del.clear()删除所有元素
zidian= {'yanse':'red','num':12}
#添加键值对
zidian['name'] = '鱼干'
print(zidian)
#{'yanse': 'red', 'num': 12, 'name': '鱼干'}
#修改字典中的值
zidian['yanse' ] = 'blue'
print(zidian)
#{'yanse': 'blue', 'num': 12, 'name': '鱼干'}
#删除键值对,再次访问会报错
del zidian['name']
print(zidian)
#{'yanse': 'blue', 'num': 12}
#清空
zidian.clear()
print(zidian)
#{}
5.3 遍历(查)字典
方法名 | 含义 |
---|---|
字典名.items() | 返回一个键-值对列表,每对 |
字典名.keys() | 返回键,不使用值,列表形式 |
字典名.values() | 遍历字典中所有值 |
sorted(字典名.keys()) | 特定顺序返回元素 |
set(字典名.values()) | 集合,使所有的值输出时没有重复项 |
#遍历字典中的所有键值对
zidian= {'yanse':'red','num':"12",'a':'red'}
for key,value in zidian.items():
print("\nkey:" + key)
print("value:"+value)
#遍历字典中的所有键
for k in zidian.keys():
print("\nkey:" + k)
#按顺序遍历字典中的所有键
for k in sorted(zidian.keys()):
print("\nk:" + k)
#遍历字典中的所有值
for v in zidian.values():
print("\nvalues:" + v)
for v in set(zidian.values()):
print("\nvalues:" + v.title())
5.4 嵌套
5.4.1 字典列表
alien_0 = {'color':'red','points':5}
alien_1 = {'color':'yellow','points':10}
alien_2 = {'color':'red','points':15}
aliens = [alien_0,alien_1,alien_2]
for alien in aliens:
print(alien)
#{'color': 'red', 'points': 5}
#{'color': 'yellow', 'points': 10}
#{'color': 'red', 'points': 15}
#自主创建30个外星人
aliens = []
for alien_number in range(30):
new_alien = {'color':'red','points':5,'speed':'slow'}
aliens.append(new_alien)
#显示前5个外星人
for alien in aliens[:5]:
print(alien)
print("...")
#显示创建了多少个外星人
print("Total number of aliens:"+ str(len(aliens)))
#修改前三个外星人
for alien in aliens[0:3]:
if alien['color'] == 'red':
alien['color'] = 'yellow'
alien['speed'] = 'medium'
alien['points'] = 10
for alien in aliens[:5]:
print(alien)
5.4.2 字典中存储列表
每当需要在字典中将一个键关联到多个值时,都可以在字典中嵌套一个列表
pizza = {'crust':'thick',
'toppings':['mushrooms','extra cheese'],
}
print("你点了一个" + pizza['crust' ]+ " pizza"+ "有下面的属性" )
for topping in pizza['toppings']:
print("\t" + topping)
like_yuyan = {'liu':['python','c'],
'xu':['c'],
'wang':['c','R']}
for name,languages in like_yuyan.items():
if len(languages) == 1:
for lan in languages:
print("\n" + name.title()+"'s like languages is:" + lan.title())
else:
print("\n" + name.title()+"'s like languages are:")
for language in languages:
print("\t" + language.title())
5.4.3 在字典中存储字典
#在字典中存储字典
users = {
'a':{'first':'alert',
'last':'el',
'location':'pri',},
'b':{'first':'as',
'last':'de',
'location':'bcsdbh',},
}
for username,user_info in users.items():
print("\nUsername:" + username)
full_name = user_info['first']+" "+user_info['last']
location = user_info['location']
print("\tFull name:" + full_name.title())
print("\tlocation:" + location.title())
5.4.4 字典枚举
enumerate()枚举函数
- 使用枚举函数,同时获得列表中的下标和元素内容
mylist = ['a','b','c','d']
print(enumerate(mylist))
#<enumerate object at 0x0000024642389A80>
for i,x in enumerate(mylist):
print(i,x)
#0 a
#1 b
#2 c
#3 d
字典、列表、元组、集合
名称 | 是否有序 | 特点 |
---|---|---|
列表 [] | 有序 | 可修改,[]标识,append()替换、insert()插入,pop()删除 |
元组() | 有序 | 不可修改,()标识 |
字典{} | 无序 | key不可变val可变,key-value数据对,{}标识,直接增加修改,pop()删除 |
集合{} | 无序 | 可变,{}或set()创建,in/not in判断是否存在,add添加、remove删除可用作去重 |
第6章 用户输入与循环
6.1用户输入intput()
#input输入内容
information = input("输入内容:")
print(information)
#int()
information = int(information)
print(information > 1)#True
6.2 while循环
循环终止 | 含义 |
---|---|
break | 提前退出循环 |
continue | 跳出当前循环,直接开始下一次循环 |
代码有问题时,程序进入“死循环”,用Ctrl+C退出程序或者强制结束进程 |
#使用while循环
num = 1
while num <= 5:
print(num)
num += 1
#让用户选择什么时候退出
prompt = "\nTell me something,and I will repeat it back to you:"
prompt += "\nEnter 'quit' to end the program."
message = ""
while message != 'quit':
message = input(prompt)
if message != 'quit':
print(message)
#使用标志
prompt = "\nTell me something,and I will repeat it back to you:"
prompt += "\nEnter 'quit' to end the program."
flag = True #标志位
while flag:
message = input(prompt)
if message == 'quit':
active = False
else:
print(message)
while与else
#while与else的组合
i= 0
while i < 5:
print(i,"<5")
i += 1
else:
print(i,'>=5')
6.3 while循环处理列表和字典
- for循环是一种遍历列表的有效方式,但在for循环中不应修改列表
- 要在遍历列表的同时对其进行修改,可使用while循环
6.3.1 在列表间移动数据
#首先,创建一个待验证用户列表和一个用于存储已验证用户的空列表
unconfirmed_users = ['alice','brian','candace']
confirmed_users = []
#验证每个用户,知道没有未验证用户为止
#将每个经过验证的列表都移到已验证用户列表中
while unconfirmed_users:
current_user = unconfirmed_users.pop() #从末尾开始删除
print('Verifying user:' + current_user.title())
confirmed_users.append(current_user)
#显示所有已验证的用户
print("\nThe following users have been confirmed:")
for confirmed_user in confirmed_users:
print(confirmed_user.title())
6.3.2 删除包含特定值的所有列表元素
pets = ['dog','cat','dog']
print(pets)
while 'dog' in pets:
pets.remove('dog')
print(pets)
6.3.3 使用用户输入来填充字典
responses = {}
active = True #标志位
while active:
name = input("请输入名字")
response = input("喜欢哪座山")
responses[name] = response
repeat = input("是否继续(yes/no)")
if repeat == 'no':
active = False
for name,response in responses.items():
print(name + "would like to climb " + response + ".a")
6.4 for…in…
#循环范围
for i in range(5):
print(i)
for i in range(0,10,3): #[0,10),b步长为3
print(i)
for i in range(1,10,3):
print(i)
#循环与字符串
name = 'yugan'
for i in name:
print(i,end = '\t')
#循环与列表
a = ['aa','bb','cc']
for i in a:
print(i,end = '\t')
a = ['aa','bb','cc']
for i in a:
print(i,end = '\t')
print('\n')
for i in range(len(a)):
print(i,a[i])
9*9乘法表
sum = 0
for i in range(1,10):
for j in range(1,i+1,):
sum = i*j
print("%d * %d = %d"%(i,j,sum),end = '\t')
print(' ')
print('==================')
i = 1
sum = 0
while i < 10:
j = 1
while j < i+1:
sum = i * j
print("%d * %d = %d" % (i, j, sum), end='\t')
j += 1
i += 1
print(' ')
第7章 函数
7.1 定义函数
def 函数名(参数): #形参
函数体
函数名(参数) #调用,实参
def greet_user():
print("Hello!")
greet_user() #Hello!
def greet_user(name):
print("Hello,"+name.title())
greet_user('鱼干') #Hello,鱼干
7.2 传递实参
- 位置实参:
- 关键字实参:
- 默认值:先列出无默认值的形参,在列出有默认值的形参,默认值后面必须全是默认值;与默认值不同直接进行赋值即可
#位置实参
def pets(types,name):
print("\nI have a " + types +","+"my "+types+"'s name is "+ name.title())
pets('cat','li')
#I have a cat,my cat's name is Li
#关键字实参
def pets(types,name):
print("\nI have a " + types +","+"my "+types+"'s name is "+ name.title())
pets(types ='cat',name ='li')
#I have a cat,my cat's name is Li
#默认值 先列出无默认值的形参,在列出有默认值的形参
def pets(types,name = 'li'):
print("\nI have a " + types +","+"my "+types+"'s name is "+ name.title())
pets(types ='cat')
#I have a cat,my cat's name is Li
7.3 返回值
*调用返回值的函数时,需要提供一个变量,用于存储返回的值
#返回简单值
def pets(types,name):
full = "I have a " + types +","+"my "+types+"'s name is "+ name.title()
return full.title()
bianlaing = pets('dog','li')
print(bianlaing)
#I Have A Dog,My Dog'S Name Is Li
#返回多个值的函数
def divid(a,b):
yushu = a % b
shang = a // b
return yushu,shang
yu,sh = divid(5,2)
print(yu,sh)
# 1 2
#返回字典
def person(firstname,lastname):
per = {'first':firstname,'last':lastname}
return per
mu = person('li','ih')
print(mu)
#{'first': 'li', 'last': 'ih'}
#添加可选形参
def person(firstname,lastname,age = ''):
per = {'first':firstname,'last':lastname}
if age:
per['age'] = age
return per
mu = person('li','ih',age = 27)
print(mu)
#{'first': 'li', 'last': 'ih', 'age': 27}
7.4 传递列表
def users(names):
for name in names:
msg = "Hello, " + name.title() + "!"
print(msg)
user = ['ha','li','kj']
users(user)
7.5 传递任意数量的实参
- 使用 *形参名 创建一个空元组
- 使用 **形参名 创建一个空字典
def make_pizza(*toppings):
for topping in toppings:
print("- "+toppings)
make_pizza('mu','de','des')
##创建一个空字典,
def build_profile(first,last,**user_info):
profile = {}
profile['first_name' ]= first
profile['last_name'] =last
for key,value in user_info.items():
profile[key] = value
return profile
user_profile = build_profile('al', 'ei',
location = 'pri',
field = 'ph')
print(user_profile)
7.6 将函数存储在模块中
import 模块名
模块名.函数名()
#导入特定的函数
from 模块名 import 函数名
函数名()
#函数名较长时可使用as给函数指定别名
from 模块名 import 函数名 as 别名
别名()
#使用as给模块指定别名
import 模块名 as 别名
别名.函数名()
#导入模块中的所有函数
from 模块名 import *
7.7 lambda函数
- 特殊函数-匿名函数
- 使用方法:<函数名>=lambda<参数列表>:<表达式>
- 用于简单的、能够在一行内表示的函数,计算结果为返回值
定义计算函数
"""
def futures_value(gramvalue,metalounceusd,rate):
output = gramvalue/OUNCE_VS_GRAM * metalounceusd * rate
return output
"""
futures_value = lambda gramvalue,metalounceusd,rate:gramvalue/OUNCE_VS_GRAM * metalounceusd * rate
第8章 类
- 使用类来创建对象被称为实例化
8.1 创建和使用类
- class 类名(): 类名首字母需大写
- __ init__(self,形参,) 方法
- self必不可少
- 以self为前缀的变量都可供类中的所有方法使用
- __ init__()并未显示地包含return语句
- 首字母大写的名称指的是类,小写的名称指的是根据类创建的实例
- 访问属性: 实例名.属性名
- 调用方法:实例名.方法名()
####创建Dog类
class Dog():
#一次模拟小狗的简单尝试
def __init__(self,name,age):
# 初始化属性name和age
self.name = name
self.age = age
def sit(self):
#模拟小狗被命令时蹲下
print(self.name.title() + " is now sitting.")
def roll_over(self):
#模拟小狗并命令时打滚
print(self.name.title() + " rolled over!")
my_dog = Dog('Willlw',6) #my_dog为实例
print("My dog's name is "+my_dog.name.title() + ".")
print("My dog is " +str(my_dog.age) + "years old.")
####访问属性
print(my_dog.name )
####调用方法
my_dog.sit()
my_dog.roll_over()
8.2 使用类和实例
- 给属性指定默认值
- 类中每个属性都必须有初始值,即便是0或空字符串
- 设置默认值时,在方法__init__()内指定初始值可以,指定初始值后,就无须包含它提供的形参
- 直接修改属性的值
- 直接修改属性的值
- 通过实例直接访问 实例名.属性名 = 修改值
- 通过方法修改属性的值
- 通过方法对属性的值进行递增
- 直接修改属性的值
class Car():
def __init__(self,make,model,year):
#初始化描述汽车的属性
self.make = make
self.model = model
self.year = year
####给属性指定默认值
self.odometer_reading = 0
def get_descriptive_name(self):
#返回整洁的描述性信息
long_name = str(self.year) +' '+self.make +' '+self.model
return long_name.title()
def read_odometer(self):
#打印一条指出汽车里程的信息
print("This car has "+str(self.odometer_reading) + " miles on it.")
####通过方法修改属性的值
def update_odometer(self,mileage):
#将里程表读数
self.odometer_reading = mileage
####通过方法对属性的值进行递增
def increment_odometer(self,miles):
#将里程表读数增加指定的量
self.odometer_reading += miles
my_new_car = Car('audi','a4',2016)
print(my_new_car.get_descriptive_name())
my_new_car.read_odometer() #属性指定默认值
####直接修改属性的值
my_new_car.odometer_reading = 23
my_new_car.read_odometer() #属性指定默认值
####通过方法修改属性的值
my_new_car.update_odometer(24)
my_new_car.read_odometer() #属性指定默认值
####通过方法对属性的值进行递增
my_used_car = Car('subaru','outback',2013)
print(my_used_car.get_descriptive_name())
my_used_car.update_odometer(23500)
my_used_car.read_odometer()
my_used_car.increment_odometer(100)
my_used_car.read_odometer()
8.3 继承
- 当要编写的类是另一个现成类的特殊版本时,可使用继承;
- 一个类继承另一个类时,它将自动获得另一个类的所有属性和方法;
- 原有的类成为父类,而新类称为子类;子类继承了其父类的所有属性和方法,同时还可以定义自己的属性和方法
- 定义子类时,必须在括号内指定父类的名称,且父类需要在子类前面
8.3.1 子类的方法__init__()
class Car():
def __init__(self,make,model,year):
#初始化描述汽车的属性
self.make = make
self.model = model
self.year = year
####给属性指定默认值
self.odometer_reading = 0
def get_descriptive_name(self):
#返回整洁的描述性信息
long_name = str(self.year) +' '+self.make +' '+self.model
return long_name.title()
def read_odometer(self):
#打印一条指出汽车里程的信息
print("This car has "+str(self.odometer_reading) + " miles on it.")
####通过方法修改属性的值
def update_odometer(self,mileage):
if mileage >= self.odometer_reading:
#将里程表读数
self.odometer_reading = mileage
else:
print("You can't roll back an odometer!")
####通过方法对属性的值进行递增
def increment_odometer(self,miles):
#将里程表读数增加指定的量
self.odometer_reading += miles
####子类ElectricCar
class ElectricCar(Car):
#电动汽车的独特之处
def __init__(self,make,model,year):
#初始化父类的属性
#super()帮助python将父类和子类关联起来,调用父类的__init__方法,
super().__init__(make,model,year)
my_tesla = ElectricCar('tesla', 'model s',2016)
print(my_tesla.get_descriptive_name())
8.3.2给子类定义属性和方法
class Car():
def __init__(self,make,model,year):
#初始化描述汽车的属性
self.make = make
self.model = model
self.year = year
####给属性指定默认值
self.odometer_reading = 0
def get_descriptive_name(self):
#返回整洁的描述性信息
long_name = str(self.year) +' '+self.make +' '+self.model
return long_name.title()
def read_odometer(self):
#打印一条指出汽车里程的信息
print("This car has "+str(self.odometer_reading) + " miles on it.")
####通过方法修改属性的值
def update_odometer(self,mileage):
if mileage >= self.odometer_reading:
#将里程表读数
self.odometer_reading = mileage
else:
print("You can't roll back an odometer!")
####通过方法对属性的值进行递增
def increment_odometer(self,miles):
#将里程表读数增加指定的量
self.odometer_reading += miles
####子类ElectricCar
class ElectricCar(Car):
#电动汽车的独特之处
def __init__(self,make,model,year):
#初始化父类的属性
#super()帮助python将父类和子类关联起来,调用父类的__init__方法,
#初始化父类的属性,在初始化电动汽车特有的属性
super().__init__(make,model,year)
self.battery_size = 70 #新的属性,子类有父类无
def describe_battery(self):
#打印一条描述电瓶容量的消息
print("This car has a "+str(self.battery_size)+"-kWh battery.")
my_tesla = ElectricCar('tesla', 'model s',2016)
print(my_tesla.get_descriptive_name())
my_tesla.describe_battery()
8.3.3重写父类的方法
- 子类中与要重写的父类方法同名
8.3.4将实例用作属性
class Car():
def __init__(self,make,model,year):
#初始化描述汽车的属性
self.make = make
self.model = model
self.year = year
####给属性指定默认值
self.odometer_reading = 0
def get_descriptive_name(self):
#返回整洁的描述性信息
long_name = str(self.year) +' '+self.make +' '+self.model
return long_name.title()
def read_odometer(self):
#打印一条指出汽车里程的信息
print("This car has "+str(self.odometer_reading) + " miles on it.")
####通过方法修改属性的值
def update_odometer(self,mileage):
if mileage >= self.odometer_reading:
#将里程表读数
self.odometer_reading = mileage
else:
print("You can't roll back an odometer!")
####通过方法对属性的值进行递增
def increment_odometer(self,miles):
#将里程表读数增加指定的量
self.odometer_reading += miles
#新类,没有继承任何类
class Battery():
def __init__(self,battery_size = 70):
#初始化电瓶的属性
self.battery_size = battery_size
def describe_battery(self):
print("Thiscar has a "+str(self.battery_size)+"-kWh battery.")
####子类ElectricCar
class ElectricCar(Car):
#电动汽车的独特之处
def __init__(self,make,model,year):
#初始化父类的属性
#super()帮助python将父类和子类关联起来,调用父类的__init__方法,
#初始化父类的属性,在初始化电动汽车特有的属性
super().__init__(make,model,year)
self.battery = Battery()
my_tesla = ElectricCar('tesla', 'model s',2016)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()
8.4 导入类
- 导入单个类
- 在一个模块中存储多个类
- 从一个模块中导入多个类
- from 别名 import 类名,类名
- 导入整个模块
- 导入模块中的所有类
- from 别名 import*
- 在一个模块中导入另一个模块
第9章 文件和异常
9.1 从文件中读取数据
9.1.1 打开与关闭整个文件
法一
f = open('文件名','w') #文件不存在时,执行‘w’会新建一个
法二
with open('文件名') as 名字:
变量名 = 名字.read()
print(变量名)
#关闭文件
f.close()
#法一
f = open("test.txt",'w')#文件不存在时,执行’w'会写入,新建文件
f.write("hello world") #将字符串写入文件中
f.close()
#读取
f = open("test.txt",'r')
content = f.read(3) #读取3个字符 并不是每都是从开头读取,而是顺次读取
print(content)
f.close()
#hel
#法二
#pi_digits.txt文件:
''' 3.1415926535
8979323846
2643383279
'''
####读取整个文件
with open('pi_digits.txt') as file_object:
contents = file_object.read()
#print(contents)#会出现许多空行
print(contents.rstrip())#删除末尾空白
9.1.2 文件读取
- read方法,读取指定的字符,开始时定位在文件头部,每执行一次向后移动指定字符数
- f.readlines() 读取全部内容,以列表形式展示
- f.readline() 读取一行内容
#法一
#readlines()
f = open("test.txt",'r')
content = f.readlines()
print(content)
i = 1
for temp in content:
print("%d:%s"%(i,temp))
i += 1
f.close()
#1:hello world
#2:hello world
#3:hello world
#4:hello world
#法二
#逐行读取
filename = 'pi_digits.txt'
with open(filename) as file_object:
for line in file_object:
print(line.rstrip())
#readlines()
filename = 'pi_digits.txt'
with open(filename) as file_object:
lines = file_object.readlines()
for line in lines:
print(line.rstrip())
9.1.3 使用文件的内容
filename = 'pi_digits.txt'
with open(filename) as file_object:
lines = file_object.readlines()
pi_string = '' #创建变量用于存储圆周率的值
for line in lines:
pi_string += line.strip()
print(pi_string)
print(len(pi_string))
9.2 写入文件
名称 | 含义 |
---|---|
‘w’ | 写入模式。文件已存在则将其覆盖,反之,创建 |
‘r’ | 读取模式 |
‘a’ | 附加模式,新的内容被写入已有内容之后 |
‘r+’ | 打开一个文件用于读写 |
‘rb’ | 以二进制格式打开一个文件用于只读。文件指针将会放文件的开头。默认模式 |
#写入空文件
filename = 'programming.txt'
with open(filename,'w') as file_object:
file_object.write("I love swimming")
#附加模式打开文件进行写入,不会覆盖原来的内容
filename = 'programming.txt'
with open(filename,'a') as file_object:
file_object.write("\nI love running")
9.3 文件的相关操作
操作 | 说明 | 代码 |
---|---|---|
文件重命名 | os模块,rename(需要修改的文件名,新的文件名) | import os os.rename('1.txt','1.txt') |
删除文件 | remove(待删除的文件名) | import os os.remove('1.txt') |
创建文件夹 | mkdir(文件夹名) | import os os.mkdir('鱼干') |
获取当前目录 | getcwd() | import os os.getcwd() |
改变默认目录 | chdir() | import os os.chdir('../') |
获取目录列表 | listdir(‘./’) | import os os.listdir('./') |
删除文件夹 | rmdir() | import os os.rmdir('鱼干') |
9.4 异常
举例
try:
print(num)
except NameError:#异常类型想要被捕获,需要一致
print("产生错误了")
#产生错误了
#获取错误描述
try:
print(num)
except NameError as result:#异常类型想要被捕获,需要一致
print("产生错误了")
print(result)
#name 'num' is not defined
#捕获所有异常Exception
try:
print(num)
except Exception as result:#异常类型想要被捕获,需要一致
print("产生错误了")
print(result)
- 引入异常处理机制可以用来解决程序运行时的错误。当python遇到try语句,先尝试执行try包含的代码块
- 如果没有错误发生,执行try-except后面的语句
- 如果发生错误,python寻找一个符合该错误的异常语句,然后执行相应的except的处理代码
- finally为不管except都进行执行
- 捕获所有异常:Exception即不用知道具体什么错误
语法(try…finally和嵌套)
try:<body>
except<ErrorType1>:
<handler1>
except<ErrorType2>:
<handler2>
except:
<handler0>
finally:
<Execute>
- 文件与异常结合
import time
try:
f = open('test.txt','r')
try:
while True:
content = f.readline()
if len(content) == 0:
break
time.sleep(2)
print(content)
finally:
f.close()
print("文件关闭")
except Exception as result:
print("发生异常...")
- 处理ZeroDivisionError异常
- try-except代码块处理
- else代码块
- 处理FileNotFoundError异常
- split() 根据字符串创建列表
try:
print(5/0)
except ZeroDivisionError:
print("You can't divide by zero!")
title = "Alice in Wonder"
print(title.split())
9.5 存储数据
名称 | 含义 |
---|---|
json.dump() | 存储数据 |
json.load() | 将数据读取到内存 |
import json #导入json模块
#### json.dump()
numbers = [2,3,5,7,11,13]
filename= 'number.json'
with open(filename,'w') as f_obj:
json.dump(numbers,f_obj)
####json.load()
with open(filename) as f_obj:
numbers = json.load(f_obj)
print(numbers)
9.5.1 重构
- greet_user()
第10章 测试代码
- unittest模块提供了代码测试工具
10.1 测试类
- 断言:检查满足的条件是否满足
方法 | 用途 |
---|---|
assertEqual(a,b) | 核实a == b |
assertNotEqual(a,b) | 核实a != b |
assertTrue(x) | 核实 x为True |
assertFalse(x) | 核实x为False |
assertIn(item,list) | 核实item在list中 |
assertNotIn(item,list) | 核实item不在list中 |
- 方法setUp()