# 最最基本
## print函数
### 将数据输出文件中
```python
#将数据输出文件中,注意点,1.所指定的盘符存在。2.使用file=fp
fp = open('C:/李林峰/text.txt', 'a+')#如果文件不存在就创建,存在就在文件内容后面继续追加
print('helloworld', file=fp)
fp.close()
#不进行换行输出(输出内容在一行当中)
print('hello','world','Python')
open的方式是输出到文件当中
print的方式是输出到显示器当中+
不进行换行输出(输出的内容在一行中)
print('hello','world','Python')
常用的转义字符
print('hello\nworld') # 换行 n->newline
print('hello\tworld') # 空了三隔
print('helloooo\tworld') # 空了四隔->tab键
print('hello\rworld') # world将hello进行了覆盖->return光标移动到本行的开头
print('hello\bworld') # \是退格back
print('http:\\\\www.bandu.com')
print('老师说:\'大家好\'')
#原字符,不希望字符串中的转义字符起作用,就是用元字串之前加上r或R
print(r'hello\nworld')
#注意事项,最后一个字符不能是反斜杠,可以是两个反斜杠
print(r'hello\nworld\\')
变量的定义和使用
name = '玛利亚'
print(name)
print('标识', id(name))
print('类型', type(name))
print('值', name)
数据类型
·常见的数据类型
·整数类型->int->98
·浮点数类型->float->3.14159
·布尔类型->bool->True,False
·字符串类型->str->人生苦短
整数类型
#整数可以表示二进制,十进制,八进制,十六进制
print('十进制',118)#默认十进制
print('二进制',0b1010111)#二进制以0b开头
print('八进制',0o176)#八进制以0o开头
print('十六进制',0x1EAF)
浮点类型
n1 = 1.1
n2 = 2.2
print(n1+n2)#3.3000000000000003
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))#3.3
布尔类型
f1 = True
f2 = False
print(f1,type(f1))#True <class 'bool'>
print(f2,type(f2))#False <class 'bool'>
#布尔值可以转成整数计算
print(f1+1) #2 1+1的结果为2,True表示1
print(f2+1) #1 0+1的结果为2,False表示0
字符串类型
str1 = '人生苦短,我用python'
str2 = "人生苦短,我用python"
str3 = """人生苦短,
我用python"""
str4 = ‘‘‘人生苦短,
我用python’’’
#单引号和双引号定义的字符串必须在一行
print(str1,type(str1))#人生苦短,我用python<class 'str'>
print(str2,type(str2))
#三引号定义的字符串可以分布在连续的多行
print(str3,type(str3))
print(str4,type(str4))
类型转换_str()函数与int()函数
str()函数
name = '张三'
age = 20
print(type(name),type(age))#说明name与age的数据类型不相同
print('我叫'+name+'今年'+age+'岁')#当将str类型与int类型进行链接时,报错,解决方案,类型转换
print('我叫'+name+'今年'+str(age)+'岁')
int()函数
s1 = 128
f1 = 98.7
s2 = '76.77'
ff = True
s3 = 'hello'
print(type(s1), type(f1), type(s2), type(ff), type(s3))
print(int(s1), type(int(s1))) #将str转成int类型,字符串为数字串
print(int(f1), type(int(f1))) #float转成int类型,截取整数部分,舍掉小数部分
# print(int(s2), type(int(s2))) #将str转成int类型,报错,因为字符串为小数串
print(int(ff), type(int(ff)))
#print(int(s3), type(int(s3))) #将str转成int类型,字符串必须为数字串(整数),非数字串是不允许转换的
float类型转换
#字符串中的数据如果是非数字串,则不允许转换
Python中的注释
#单行注释
"""我是多行注释
"""
Input函数的使用
present = input('大圣想要什么礼物呢')#输入之前程序给你的一个提示语 需要输入回答
input函数的高级使用
a = input('请输入一个加数:')#10
b = input('请输入另一个加数:')#10
print(type(a), type(b))#<class 'str'><class 'str'>
print(a + b)#1020
a = input('请输入一个加数:')#10
b = input('请输入另一个加数:')#10
print(type(a), type(b))#<class 'str'><class 'str'>
print(int(a) + int(b))#30
或者a = int(input('请输入一个加数:'))
运算符
算数运算符
print(1+1)# 加法运算
print(1-1) # 减法运算
print(2*4)# 8 乘法运算
print(1/2)# 除法运算
print(11/2)#5.5 除法运算
print(11//2)# 5 整除运算
print(11%2)# 1 取余运算
print(2**2)# 4 表示的是2的2次方
print(2**3)# 8 表示的是2的3次方
含减号的运算
print(9 // 4) # 2
print(-9 // -4) # 2
print(9 // -4) # -3
print(-9 // 4) # -3 一正一负的整数公式,向下取整
print(9 % -4) # -3 余数=被除数-除数*商 9-(-4)*(-3)
print(-9 % 4) # 3
赋值运算符
#解包赋值
a,b,c=20,30,40
print(a,b,c)
print('-----------交换两个变量的值----------')
a,b=10,20
print('交换之前:',a,b)#交换之前:10 20
#交换
a,b=b,a
print('交换之后:',a,b)#交换之后:20 10
比较运算符
a,b=10,20
print('a>b吗',a>b)#False
print('a<b吗',a<b)#True
print('a<=b吗',a<=b)#True
print('a>=b吗',a>=b)#False
print('a==b吗',a==b)#False
print('a!=b吗',a!=b)#True
a=10
b=10
print(a==b)#True 说明,a与b的value相等
print(a is b)#True 说明, a与b的id标识相等
#以下代码没学过,后面会给大家讲解
llist1=[11,22,33,44]
llist2=[11,22,33,44]
print(lstr1==lstr2)#value -->True
print(lstr1 is lstr2)#id -->False
print(id(lstr1))#267587787
print(id(lstr2))#787897988
print(lstr1 is not lstr2) #True
布尔运算
#and并且
#or或者
#not 对bool类型操作数取反
f=True
f2=False
print(not f)#False
print(not f2)#True
#in与not in
s = 'helloworld'
print('w' in s)#True
print('k' in s)#False
print('w' not in s)#False
print('k' not in s)#True
位运算
print(4 & 8) # 0 按位于&,同为1时结果为1
print(4 | 8) # 12 按位或|,同为0时结果为0
print(4 << 1) # 8 向左移动1位(移动一个位置)相当于乘以2
print(4 << 2) # 16 向左移动2位(移动2个位置)
print(4 >> 1) # 2 向右移动1位,相当于除以2
print(4 >> 2) # 1 向右移动2位,相当于除以4
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mGcjj80O-1643201540460)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220119175339789.png)]
运算符的优先级
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DxA00Btf-1643201540461)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220119180200590.png)]
对象的布尔值
print(bool(False))#False
print(bool(0))#False
print(bool(0.0))#False
print(bool(None))#False
print(bool(''))#False
print(bool(""))#False
print(bool([]))#False空列表
print(bool(list()))#False空列表
print(bool(()))#False空元组
print(bool(tuple))#False空元组
print(bool({}))#空字典
print(bool(dict()))#False空字典
print(bool(set()))#False空集合
其他的bool值为True
print(bool(18))#True
print(bool('helloworld'))#True
选择结构
单分支结构
money = 1000
s = int((input('请输入取款金额')))#取款金额
#判断金额是否充足
if money>=s:
money=money-s
print('取款成功,金额为:',money)
双分支结构
num = int(input('请输入一个整数'))
#条件判断
if num%2==0:
print(num,'是偶数')
else:
print(num,'是奇数')
多分支结构
score = int(input('请输入一个成绩:'))
# 判断
if 90 <= score <= 100:
print('A级')
elif 80 <= score < 90:
print('B级')
elif 70 <= score < 80:
print('C级')
elif 60 <= score < 70:
print('D级')
elif 0 <= score < 59:
print('E级')
else:
print('对不起,您输入的成绩有误,不再成绩的有效范围内')
嵌套if的使用
answer=input('您是会员吗?y/n')
money=float(input('请输入您的购物金额:'))
#外层判断是否是会员
if answer=='y':
if money >= 200:
print('打八折,付款金额为:',money*0.8)
elif money>=100:
print('打九折,付款金额为:',money*0.9)
else:
print('不打折,付款金额为:',money)
else:
if money>=200:
print('打9.5折,付款金额为:',money*0.95
else:
print('不打折,付款金额为:',money)
条件表达式
''''num_a=int(input('请输入第一个整数'))
num_b=int(input('请输入第二个整数'))
#比较大小
if num_a>=num_b
print(num_a,'大于等于',num_b)
else:
print(num_a,'小于',num_b)''''
print('使用条件表达式进行比较')
#条件判断的结果为true,就执行左边的内容,为false,执行右侧的代码
print(str(num_a)+'大于等于'+str(num_b) if num_a>=num_b else str(num_a)+'小于'+str(num_b))
pass语句
#pass语句,什么都不做,只是一个占位符,用到需要些语句的地方
answer=input('您是会员吗?y/n')
#判断是否是会员
if answer == 'y':
pass
else:
pass
range的三种创建方式
#range()的三种创建方式
''''第一种方式,只有一个参数(小括号中只给一个数)''''
r = range(10) #[0,1,2,3,4,5,6,7,8,9],默认从0开始,默认相差1位步长
print(r)#range(0,10)
print(list(r))#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#用于查看range对象中的整数序列-->list是列表的意思
''''第二中创建方式,给了两个数(小括号中给了连个数)''''
r=range(1,10)#指定了起始值,从1开始,到10结束(不包含10),默认步长为1
print(list(r))#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
''''第三种创建方式,给了三个参数(小括号中给了三个数)''''
r=range(1,10,2)
print(list(r))#[1,3,5,7,9]
'''判断指定的整数在序列中是否存在in,not in'''
print(10 in r)#False,10不在当前的r这个整数系列中
print(9 in r)#True,9在当前的r这个序列中
print(10 not in r)#True
while循环结构
sum=0
a=0
while a<5:
sum+=a
a++
print('和为',sum)
while练习题
sum=0
a=1
while a<=100:
if a%2==0:
sum+=a
a+=1
print('1-100之间的偶数和',sum)#因为print和while是对齐的,所以print没有进入while循环
for-in循环
for item in 'Python':#第一次取出来的是P,将P赋值给item,将item的值输出
print(item)
#range() 产生一个整数序列---》也是一个可迭代对象
for i in range(10):
print(i)#1 2 3 4 5 6 7 8 9
#如果在循环体中不需要使用自定义白能量,可将自定义变量写为“_”
for _ in range(5):
print('人生苦短,我用Python')
print('使用for循环,计算1到100的偶数和')
sum=0#用于存储偶数和
for item in range(1,101):
if item % 2==0:
sum+=item
print('1到100之间的偶数和为:',sum)
输出100到999的水仙花数
for item in range(100, 1000):
ge = item % 10
shi = item // 10 % 10
bai = item // 100
if ge ** 3 + shi ** 3 + bai ** 3 == item:
print(item)
循环控制语句break
for item in range(3):
pwd = input('请输入密码:')
if pwd == '8888':
print('密码正确')
break
else:
print('密码不正确')
流程控制语句continue
for item in range(1, 51):
if item % 5 != 0:
continue
print(item)
else语句
没有碰到break时执行else
#for和else搭配使用
for item in range(3):
pwd = input('请输入密码:')
if pwd == '8888':
print('密码正确')
break
else:
print('密码不正确')
else:
print('对不起,三次密码均输入错误')
#while和else搭配使用
a = 0
while a < 3:
pwd = input('请输入密码')
if pwd == '8888':
print('密码正确')
break
else:
print('密码不正确')
a += 1
else:
print('对不起,三次密码均不正确')
嵌套循环
# 输入一个三行四列的举行
for i in range(1, 4):
for j in range(1, 5):
print('*', end='\t')
print() # 换行
#打印九九乘法表
for i in range(1, 10):
for j in range(1, i+1):
print(str(i) + '*' + str(j) + '=' + str(i * j), end='\t')
#print(i,'*',j,'=',i*j,end='\t')
print()
二重循环中的break
二重循环中的break和continue用于控制本层循环
列表
自己的感悟
列表让我想到了Excel表,他的括号是直上直下的,又联系到java里的列表就有list([ ])
·列表对应的英语单词是list—>list([])
列表的创建
"""创建列表的第一种方式,使用[]"""
lst = ['hello', 'world', 98]
'''创建列表的第二种方式,使用内置函数list()'''
lst2 = list(['hello', 'world', 98])
print()
列表的特点
1.列表元素按顺序有序排序
2.索引映射唯一一个数据
3.列表可以存储重复数据
4.任意数据类型混存
5.根据需要动态分配和回收内存
获取指定元素的索引
lst = ['hello', 'world', 98, 'hello']
print(lst.index('hello')) # 如果列表中有相同元素只返回相同元素的第一个元素的索引
# print(lst.index('Python')) # 'Python' is not in list
# print(lst.index('hello', 1, 3))#'hello' is not in list 在1~2的位置上查找
print(lst.index('hello', 1, 4))
获取列表中的单个元素
正向索引从0到N-1,举例list[0]
逆向索引你从-N到-1,举例lst[-N]
指定索引不存,抛出IndexError
lst = ['hello', 'world', 98, 'hello', 'world', 234]
# 获取索引为2的元素
print(lst[2]) # 98
# 获取索引为-3的元素
print(lst[-3]) # hello
# 获取索引为10的元素
print(lst[10]) # IndexError: list index out of range
列表元素的查询操作
# 判断指定元素在列表中是否存在
print('p' in 'python')
print('k' not in 'python')
lst = [10, 20, 'python', 'hello']
print(10 in lst) # True
print(100 in lst) # False
print(10 not in list) # True
# 遍历
for item in lst:
print(item)
列表元素的增加操作
# append() 向列表的末尾添加一个元素
lst = [10, 20, 30]
print('添加元素之前', lst, id(lst)) # 添加元素之前 [10, 20, 30] 2100054273728
lst.append(100)
print('添加元素之后', lst, id(lst)) # 添加元素之后 [10, 20, 30, 100] 2100054273728
print(list) # <class 'list'>
# extend() 在列表的末尾只收添加一个元素
lst2 = ['hello', 'world']
# st.append(lst2)#将lst2作为一个元素添加到列表的末尾
# print(lst) # [10, 20, 30, 100, ['hello', 'world']]
# 向列表的末尾一次性添加多个元素
lst.extend(lst2)
print(lst)
# 在指定位置上添加一个元素
lst.insert(1, 90)
lst3 = [True, False, 'hello']
# 在任意的位置上添加N多个元素
lst[1:] = lst3;
print(lst)
列表元素的删除操作
lst = [10, 20, 30, 40, 50, 60, 30]
lst.remove(30) # 从列表中溢出一个元素,如果有重复元素只移第一个元素
print(lst)
lst.remove(100) # [10, 20, 40, 50, 60, 30]
lst = [10, 20, 30, 40, 50, 60, 30]
# pop()根据索引移除元素
lst.pop(1)
print(lst)
lst.pop(6)
print(lst) # pop index out of range
lst = [10, 20, 30, 40, 50, 60, 30]
# pop()根据索引移除元素
lst.pop(1)
print(lst)
lst.pop(5)
print(lst) # pop index out of range
lst.pop() # 如果不指定参数(索引),将删除列表中的最后一个元素
print(lst)
lst = [10, 20, 30, 40, 50, 60, 30]
print("------切片操作-删除至少一个元素,将产生一个新的列表对象")
new_list = lst[1:3]
print('原列表', lst)#原列表 [10, 20, 30, 40, 50, 60, 30]
print('切片后的列表', new_list)#切片后的列表 [20, 30]
'''不产生新的列表对象,二回删除原列表中的内容'''
lst = [10, 20, 30, 40, 50, 60, 30]
lst[1:3] = []
print(lst) # [10, 40, 50, 60, 30]
"""清楚列表中的所有元素"""
lst = [10, 20, 30, 40, 50, 60, 30]
lst.clear()
print(lst)
"""del语句将列表对象删除"""
lst = [10, 20, 30, 40, 50, 60, 30]
del lst
print(lst)#name 'lst' is not defined
列表元素的修改操作
lst = [10, 20, 30, 40]
# 一次修改一个值
lst[2] = 100
print(lst) # [10, 20, 100, 40]
lst[1:3] = [300, 400, 500, 600] # [10, 300, 400, 500, 600, 40]
print(lst)
列表元素的排序操作
·常见的两种方式
·调用sort()方法,列有中的所有元素默认按照从小到大的顺序进行排序,可以指定reverse=True,进行降序排序
·调用内置函数sorted(),可以指定reverse=True,进行降序排序,原列表不发生改变
lst = [20, 40, 10, 98, 54]
print('排序前的列表', lst, id(lst)) # 排序前的列表 [20, 40, 10, 98, 54] 3245910544000
# 开始排序,调用列表对象的sort方法,升序排序
lst.sort()
print('排序后的列表', lst, id(lst)) # 排序后的列表 [10, 20, 40, 54, 98] 1433208368896
# 通过指定关键字参数,将列表中的元素进行降序排序
lst.sort(reverse=True) # reverse=True 表示降序排序 reverse=False就是降序排序
print(lst)#[98, 54, 40, 20, 10]
lst.sort(reverse=False)
print(lst)#[10, 20, 40, 54, 98]
# 使用内置函数sorted()对列表进行排序,将产生一个新的列表对象
lst = [20, 40, 10, 98, 54]
print('原列表', lst)
# 开始排序
new_list = sorted(lst)
print(lst)
print(new_list)
# 指定关键字参数,实现列表元素的降序排序
desc_list = sorted(lst, reverse=True)
print(desc_list)
列表生成式
简称生成列表的公式
·语法格式:
[i*i for i in range(1,10)]
lst = [i for i in range(1, 10)]
print(lst) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst = [i * i for i in range(1, 10)]
print(lst) # [1, 4, 9, 16, 25, 36, 49, 64, 81]
'''列表元素的值为2,4,6,8,10'''
lst2=[i*2 for i in range(1,6)]
print(lst2)#[2, 4, 6, 8, 10]
字典
自己的感悟
字典嘛,让我想到了老师的棒棒,---->{},
{‘张三’:100}:冒号显得很随意
字典dictionary,dict(name=‘jack’) ,"="像一个字典横着放在那
·字典对应的英语单词是dict---->dict()
什么是字典
·Python内置的数据结构之一,与列表一样时一个可变序列·以键值对的方式存储数据,字典是一个无序的序列
字典的创建
·最常用的方式:使用花括号
scores={‘张三’:100,‘李四’:98}
·使用内置函数dict()
dict(name=‘jack’,age=20)
"""使用{}创建字典"""
scores = {'张三': 100}
print(scores) # {'张三': 100}
print(type(scores)) # <class 'dict'>
'''第二种方式dict()'''
student = dict(name='jack', age=20)
print(student) # {'name': 'jack', 'age': 20}
'''空字典'''
d = {}
print(d) # {}
字典元素的获取
scores = {'张三': 100, '李四': 98, '王五': 45}
'''第一种方式,使用[]'''
print(scores['张三']) # 100
# print(scores['陈六'])#KeyError: '陈六'
'''第二种方式,使用get()方法'''
print(scores.get('张三')) # 100
print(scores.get('陈六')) # None
print(scores.get('马奇', 99)) # 99 99是在查找’马奇‘所对的value不存在时,提供第一个默认值
字典的增删改操作
"""key的判断"""
scores = {'张三': 100, '李四': 98, '王五': 45}
print('张三' in scores) # True
print('张三' not in scores) # False
del scores['张三'] # 删除指定的key-value对
scores.clear() # 清空字典的元素
print(scores) # False
#新增元素
scores = {'张三': 100, '李四': 98, '王五': 45}
scores['陈六'] = 98
print(scores)#{'张三': 100, '李四': 98, '王五': 45, '陈六': 98}
#修改元素
scores = {'张三': 100, '李四': 98, '王五': 45, '陈六': 98}
scores['陈六'] = 100
print(scores)
获取字典视图的三个方法
1、keys()------获取字典中所有key
2、values()------获取字典中所有value
3、items()------获取字典中所有key,values
scores = {'张三': 100, '李四': 98, '王五': 45}
# 获取所有的key
keys = scores.keys()
print(keys) # dict_keys(['张三', '李四', '王五'])
print(type(keys)) # <class 'dict_keys'>
print(list(keys)) # ['张三', '李四', '王五']
# 获取所有的value
values = scores.values()
print(values) # dict_values([100, 98, 45])
print(type(values)) # <class 'dict_values'>
print(list(values)) # [100, 98, 45]
# 获取所有的key-value对
items = scores.items()
print(items) # dict_items([('张三', 100), ('李四', 98), ('王五', 45)])
print(list(items)) # [('张三', 100), ('李四', 98), ('王五', 45)]
# 转换之后的列表元素是由元组组成的
字典元素的遍历
scores = {'张三': 100, '李四': 98, '王五': 45}
# 字典元素的遍历
for item in scores:
print(item, scores[item], scores.get(item))
# 张三 100 100
# 李四 98 98
# 王五 45 45
字典的特点
1、字典中的所有元素都是一个key-value对,key不允许重复,value可以重复
2、字典中的元素是无序的
3、字典中的key必须是不可变对象
4、字典也可以根据需要动态地伸缩
5、字典会浪费较大的内存,是一种使用空间换时间的数据机构
d = {'name': '张三', 'name': '李四'} # key不允许重复
print(d)
d = {'name': '张三', 'nickname': '张三'} # values可以重复的
print(d)
lst = [10, 20, 30]
lst.insert(1, 100)
print(lst) # [10, 100, 20, 30
d = {lst: 100} # unhashable type: 'list'
print(d)
'''不懂,可以再回来看一下'''
字典生成式
items = ['Fruits', 'Books', 'Others']
prices = [96, 78, 85]
d = {item.upper(): price for item, price in zip(items, prices)}
print(d)#{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}
知识点总结
字典的创建
1、使用{}花括号
2、内置函数dict()
3、字典生成式
常用操作
1、获取value
·字典名[key]
·字典名.get(key)
2、删除key-value对
del字典名[key]
3、修改/新增
字典名[key]=value
4、in/not
元组
什么是元组
自己的感悟
·元组很圆 所以用()包住元素,又因为它很圆滑,可以把括号去掉
·元组对应的英语单词是tuple—>tuple(())
·元组
·Python内置的数据结构之一,是一个不可变的序列
·不可变序列与可变序列
·不可变序列与可变序列
·不变序列:字符串、元组
·不可变序列:没有增、删、改的操作
·可变序列:列表、字典
·可变序列:可以对序列执行增、删、改操作,对象地址不发生更改
"""可变序列 列表,字典"""
lst = [10, 20, 45]
print(id(lst)) # 2190449651584
lst.append(300)
print(id(lst)) # 2190449651584
'''不可变序列,字符串,元组'''
s = 'hello'
print(id(s))#3209077469104
s = s + 'world'
print(id(s))#3209077476656
print(s)#helloworld
元组的创建方式
直接小括号
t = (‘Python’,‘hello’,90)
使用内置函数tuple()
t = tuple((‘Python’,‘hello’,90))
只包含一个元组的元素需要使用逗号和小括号
t=(10,)
'''第一种创建方式,使用()'''
t=('Python','world',98)
print(t) # ('Python', 'world', 98)
print(type(t)) # <class 'tuple'>
'''第二种创建方式,使用内置函数tuple()'''
t2 = 'Python', 'world', 98 # 省略了小括号
print(t2) # ('Python', 'world', 98)
print(type(t2)) # <class 'tuple'>
t3 = ('Python',) # 如果元组中只有一个元素,逗号不能省略
print(t3) # ('Python',)
print(type(t3)) # <class 'tuple'>
'''第二种方式,使用内置函数tuple()'''
t1 = tuple(('Python', 'world', 98))
print(t1) # ('Python', 'world', 98)
print(type(t1)) # <class 'tuple'>
'''空元组的创建方式'''
'''空列表的创建方式'''
lst = []
lst1 = list()
d = {}
d2 = dict()
# 空元组
t4 = ()
t5 = tuple()
print('空列表', lst, lst1) # 空列表 [] []
print('空字典', d, d2) # 空字典 {} {}
print('空元组', t4, t5) # 空元组 () ()
为什么要把元组设计成不可变序列
·在多任务环境下,同时操作对象时不需要加锁
·因此,在程序中尽量使用不可变序列
注意事项:
元组中存储的是对象的引用
a)如果元组中对象本身不可对象,则不能再引用其它对象
b)如果元组中的对象是可变对象,则可变对象的引用不允许改变,但数据可以改变
t = [10, [20, 30], 9]
print(t) # (10, [20, 30], 9)
print(type(t)) # <class 'tuple'>
print(type(t[0]), type(t[0]), id(t[0])) # <class 'int'> <class 'int'> 2155089521232
print(type(t[1]), type(t[1]), id(t[1])) # <class 'list'> <class 'list'> 2155091275648
print(type(t[2]), type(t[2]), id(t[2])) # <class 'int'> <class 'int'> 2155089521200
'''尝试将t[1]修改为100'''
print(id(100))
# t[1] = 100 #元组是不允许修改元素的
'''由于[20,30]列表,而列表是可变序列,所以可以向列中添加元素,而列表中的内存地址不变'''
t[1].append(100) # 向列表中添加元素
print(t,id(t[1])) # [10, [20, 30, 100], 9]
元组的遍历
t = ('Python', 'world', 98)
'''第一种获取元组的方式,使用索引'''
print(t[0]) # Python
print(t[1]) # world
print(t[2]) # 98
#print(t[3]) # tuple index out of range
'''遍历元组'''
for item in t:
print(item)
'''
Python
world
98
'''
集合
自己的感悟
集合对应的英语单词是set()
什么是集合
·Python语言提供的内置数据结构
·与列表、字典一样都属于可变类型的序列
·集合是没有value的字典
集合的创建方式
"""第一种创建方式使用{}"""
s = {2, 3, 4, 5, 5, 6, 7, 7} # 集合中的元素不能重复
print(s) # {2, 3, 4, 5, 6, 7}
'''第二种创建方式使用set()'''
s1 = set(range(6))
print(s1, type(s1)) # {0, 1, 2, 3, 4, 5} <class 'set'>
s2 = set([1, 2, 3, 4, 5, 5, 6, 6])
print(s2, type(s2)) # {1, 2, 3, 4, 5, 6} <class 'set'>
s3 = set((1, 2, 4, 4, 5, 65))
print(s3, type(s3)) # {65, 1, 2, 4, 5} <class 'set'>
s4 = set('python')
print(s4, type(s4)) # {'t', 'o', 'n', 'h', 'y', 'p'} <class 'set'>
s5 = set({12, 4, 34, 55, 66, 44})
print(s5, type(s5)) # {34, 66, 4, 55, 12, 44} <class 'set'>
# 定义一个空集合
s6 = {} # dict字典类型
print(type(s6)) # <class 'dict'>
s7 = set()
print(type(s7)) # <class 'set'>
集合的相关操作
·集合元素的判断操作
·in或not in
·集合元素的新增操作
·调用add()方法,一次添中一个元素
·调用update()方法,至少添中一个元素
·集合元素的删除操作
·调用remove()方法,一次删除一个指定元素,如果指定的元素不存在抛出KeyErrot
·调用discard()方法,一次删除一个指定元素,如果指定的元素不存在不抛异常
·调用pop()方法,一次只删除一个任意元素
·调用clear()方法,清空集合
s = {10, 20, 30, 405, 60}
'''集合元素的判断操作'''
print(10 in s) # True
print(100 in s) # False
print(10 not in s) # False
print(100 not in s) # True
'''集合元素的新增操作'''
s.add(80) # add一次添加一个元素
print(s) # {80, 20, 405, 10, 60, 30}
s.update({200, 400, 300}) # 一次至少添加一个元素
print(s) # {200, 10, 300, 80, 400, 20, 405, 60, 30}
s.update([100, 99, 8])
s.update((78, 64, 56))
print(s) # {64, 99, 100, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
'''集合元素的删除操作'''
s.remove(100)
print(s) # {64, 99, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
# s.remove(500)#KeyError: 500
s.discard(500) # {64, 99, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
print(s)
s.pop()
s.pop()
# s.pop(400)#set.pop() takes no arguments (1 given) pop方法不能添加参数
print(s) # {200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
s.clear()
print(s) # set()
集合间的关系
两个集合是否相等
·可以使用运算符==或!=进行判断
一个集合是否是另一个集合的子集
·可以调用方法issubset进行判断
·B是A的子集
一个集合是否是另一个集合的超集
·可以调用方法issuperset进行判断
·A是B的超集
两个集合是否没有交集
·可以调用方法isdisjojoint进行判断
"""两个集合是否相等(元素相同,就相等)"""
s = {10, 20, 30, 40}
s2 = {30, 40, 20, 10}
print(s == s2) # True
print(s != s2) # False
'''一个集合是否是另一个集合的子集'''
s1 = {10, 20, 30, 40, 50, 60}
s2 = {10, 20, 30, 40}
s3 = {10, 20, 90}
print(s2.issubset(s1)) # True
print(s3.issubset(s1)) # False
'''一个集合是否是另一个集合的超集'''
print(s1.issuperset(s2)) # True
print(s1.issuperset(s3)) # False
'''两个集合是否含有交集'''
print(s2.isdisjoint(s3)) # False #有交集为False
s4 = {100, 200, 300}
print(s2.isdisjoint(s4)) # True 没有交集为True
集合的数据操作
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BQh13eTs-1643201540462)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220120181531029.png)]
# (1)交集
s1 = {10, 20, 30, 40}
s2 = {20, 30, 40, 50, 60}
print(s1.intersection(s2)) # {40, 20, 30}
print(s1 & s2) # {40, 20, 30}#intersection与&等价,交集操作
# (2)并集操作
print(s1.union(s2))
print(s1 | s2) # union与|等价,并集操作
print(s1) # {40, 10, 20, 30}
print(s2) # {50, 20, 40, 60, 30}
# (3)差集操作
print(s1.difference(s2)) # {10}
print(s1 - s2) # {10}
print(s1)
print(s2)
# (4)对称差集
print(s1.symmetric_difference(s2))#{50, 10, 60}
print(s1 ^ s2)#{50, 10, 60}
集合生成式
·用于生成集合的公式
{i*i for i in range(1,10)}
·将{}修改为[]j就是列表生成式
·没有元组生成式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ubEqBxLv-1643201540464)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220120221831248.png)]
# 列表生成式
lst = [i * i for i in range(10)]
print(lst) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 集合生成式
s = {i * i for i in range(10)}
print(s) # {0, 1, 64, 4, 36, 9, 16, 49, 81, 25}
列表字典元组集合的比较
创建
列表
1、lst = [‘hello’, ‘world’, 98]
2、lst2 = list([‘hello’, ‘world’, 98])
字典
1、dit = {‘张三’: 100}
2、dit1 = dict(name=‘jack’, age=20)
元组
1、tup=(‘Python’,‘world’,98)
tup2 = (‘Python’,)
tup3 = ‘Python’, ‘world’, 98
2、tup4 = tuple((‘Python’, ‘world’, 98))
集合
1、s = {2, 3, 4, 5, 5, 6, 7, 7}
2、 s1 = set(range(6))
s2 = set([1, 2, 3, 4, 5, 5, 6, 6])
s3 = set((1, 2, 4, 4, 5, 65))
s4 = set({12, 4, 34, 55, 66, 44})
s5 = set(‘python’)# {‘t’, ‘o’, ‘n’, ‘h’, ‘y’, ‘p’}
索引
列表
获取指定元素的索引
lst = [‘hello’, ‘world’, 98, ‘hello’]
1、print(lst.index(‘hello’))
2、print(lst.index(‘hello’, 1, 4))
获取列表中的单个元素
lst = [‘hello’, ‘world’, 98, ‘hello’, ‘world’, 234]
1、print(lst[2]) # 98
print(lst[-3]) # hello
print(lst[10]) # IndexError: list index out of range
字典元素的获取
scores = {‘张三’: 100, ‘李四’: 98, ‘王五’: 45}
‘’‘第一种方式,使用[]’’’
print(scores[‘张三’]) # 100
print(scores[‘陈六’])#KeyError:‘陈六’
‘’‘第二种方式,使用get()方法’’’
print(scores.get(‘张三’)) # 100
print(scores.get(‘陈六’)) # None
print(scores.get(‘马奇’, 99)) # 99 99是在查找’马奇‘所对的value不存在时,提供第一个默认值
字符串
字符串的创建和驻留机制
字符串的驻留机制
·字符串
·在Python中字符串是基本数据类型,是一个不可变的字符序列
注:第一个不可变的序列是元组,第二个不可变的序列是字符串
·什么叫字符串驻留机制呢?
·仅保存一份相同且不可变字符串的方法,不同的值被存放在字符串的驻留池中,Python的驻留机制对相同的字符串只保留一份拷贝,后续创建相同字符串时,不会开辟新空间,而是把该字符串的地址赋给新创建的变量
驻留机制的几种情况(交互模式)
·字符串的长度为0或1时
·符合标识符的字符串
s1=''
s2=''
print(s1 is s2)#True
s1='%'
s2='%'
print(s1 is s2)#True
s1='abc%'
s2='abc%'
print(s1==s2)#True 内容相同
print(s1 is s2)#False 地址不相同
·字符串只在编译时进行驻留,而非运行时
a='abc'
b='ab'+'c'
c=''.join(['ab',c])#join的操作是在程序运行的时候,程序在运行的时候当然会开辟一个新的空间
print(a is b)#True
print(a is c)#False
print(c)#abc
·[-5,256]之间的整数数字
a=-5
b=-5
print(a is b)#True
a=-6
b=-6
print(a is b)#False
sys中的intern方法强制2个字符串指向同一个对象
import sys
a='abc%'
b='abc%'
print(a is b)#False
a=sys.intern(b)
print(a is b)#True
PyCharm对字符串进行优化处理
就是之前为值false的结果在PyCharm编译器中是驻留的,是True的
字符串驻留机制的优缺点
·当需要值相同的字符串时,可以直接从字符串池里拿来使用,避免频繁的创建和销毁,替身效率和节约内存,因此拼接字符串和修改字符串是会比较影响性能的。
·在需要进行字符串拼接时建议使用str类型的join方法,而非+,因为join()方法是先计算出所有字符中的长度,然后再拷贝,只new一次对象,效率要比"+"效率高
字符串的常用操作
字符串的查询操作的方法
查询方法
·index() 查找子串substr第一次出现的位置,如果查找的子串不存在时,则抛出ValueError
·rindex()查找子串substr最后一次出现的位置,如果查找的子串不存在时,则抛出ValueError
·find()查找子串substr第一次出现的位置,如果查找的子串不存在时,则返回-1
·rfind()查找子串substr最后一次出现的位置,如果查找的子串不存在时,则返回-1
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pjoysoFO-1643201540465)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220121115056706.png)]
# 字符串的查询操作
s = 'hello,hello'
print(s.index('lo')) # 3
print(s.find('lo')) # 3
print(s.rindex('lo')) # 9
print(s.rfind('lo')) # 9
# print(s.index('k'))# ValueError: substring not found
print(s.find('k')) # -1
# print(s.rindex('k'))#ValueError: substring not found
print(s.rfind('k')) # -1
字符串的大小写转换操作的方法
upper()
把字符串中所有字符都转成大写字母
lower()
把字符串中所有字符都转成小写字母
swapcase()
把字符串中所有大写字母转成小写字母,把所有小写字母都转成大写字母
capitalize()
把第一个字符转换成大写,把其余字符转换成小写
# 字符串中的大小写转换的方法
s = 'hello,python'
a = s.upper() # 转成大写之后,会产生一个新的字符串对象
print(s) # HELLO,PYTHON
print(a, id(a)) # HELLO,PYTHON 2190073744368
print(s, id(s)) # HELLO,PYTHON 1561669349040
print(s.lower()) # hello,python
print(s.lower(), id(s.lower())) # hello,python 2207706857648
print(s, id(s)) # hello,python 2207706853296
s2 = 'hello,Python'
print(s2.swapcase()) # HELLO,pPYTHON
print(s2.title()) # Hello,Python
字符串内容对齐的方法
方法名称
center()
居中对齐,第一个参数指定宽度,第二个仓鼠指定填充符,第二个参数是可选的,默认是空格,如果设置款难度小于实际宽度则返回字符串
ljust()
左对齐,第1个参数指定宽度,第2个参数指定填充符,第二个参数是可选的,默认是空格如果设置宽度小于实际宽度则返回原字符串
rjust()
右对齐,第1个参数指定宽度,第2个参数指定填充符,第2个参数是可选的,默认是空格如果设置宽度小于实际宽度则返回原字符串、
zfill()
右对齐,左边用0填充,该方法只接收一个参数,用于指定字符串的宽度,如果指定的款难度小于等于字符串的长度,返回字符串本身
s = 'hello,Python'
'''居中对齐'''
print(s.center(20, '*')) # ****hello,Python****
'''左对齐'''
print(s.ljust(20, '*')) # hello,Python********
print(s.ljust(10, )) # hello,Python
print(s.ljust(20)) # hello,Python 默认填充格式空格
'''右对齐'''
print(s.rjust(20, '*')) # ********hello,Python
print(s.rjust(20)) # hello,Python
print(s.rjust(10)) # hello,Python
'''右对齐,使用0进行填充'''
print(s.zfill(20))#00000000hello,Python
print(s.zfill(10))#hello,Python
print('-8910'.zfill(8))#-0008910
字符串的劈分
split()
从字符串的左边开始劈分,默认的劈分字符是空格字符串,返回的值都是一个列表
s='hello world Python'
lst=s.split()
print(lst)#['hello', 'world', 'Python']
以通过参数sep指定劈分字符串是劈分符
通过参数maxsplit指定劈分字符串时的最大劈分次数,在经过最大劈分之后,剩余的子串会单独做成一部分
s1='hello|world|Python'
print(s1.split(sep='|'))#['hello', 'world', 'Python']
print(s1.split(sep='|',maxsplit=1))#['hello', 'world|Python']
rsplit()
从字符串的右边开始劈分,默认的劈分字符是空格字符串,返回的值都是一个列表
以通过参数sep指定劈分字符串是劈分符
通过参数maxsplit指定劈分字符串时的最大劈分次数,在经过最大次劈分之后,剩余的子串单独会做成一部分
s1 = 'hello|world|Python'
print(s1.split(sep='|')) # ['hello', 'world', 'Python']
print(s1.split(sep='|', maxsplit=1)) # ['hello', 'world|Python']
s = 'hello world Python'
print(s.rsplit()) # ['hello', 'world', 'Python']
print(s.rsplit('|')) # ['hello world Python']
print(s1.rsplit(sep='|', maxsplit=1)) # ['hello|world', 'Python']
字符串判断的相关方法
isidentifier()
判断指定的字符串是不是合法的标识符
isspace()
判断指定的字符串是否全部由空白字符组成(回车,换行,水平制表符)
isalpha()
判断指定的字符串是否全部由字母组成
isdecimal()
判断指定字符串是否全部由字母组成
isnumeric()
判断指定的字符串是否全部由数字组成
isalnum()
判断指定字符串是否全部由字母和数字组成
字符串操作的其他方法
字符串替换
replace()
第1个参数指定被替换的子串,第2个参数指定替换子串的字符串,该方法返回替换后得到的字符串,替换前的字符串不发生变化,调用该方法时可以通过第3个参数指定最大替换次数
字符串的合并
join()
将列表或元组中的字符串合并成一个字符串
s = 'hello,Python'
print(s.replace('Python', 'Java')) # hello,Java
s1 = 'hello,Python,Python,Python'
print(s1.replace('Python', 'Java', 2)) # hello,Java,Java,Python
lst = ['hello', 'java', 'Python']
print('|'.join(lst)) # hello|java|Python
print(''.join(lst)) # hellojavaPython
t = ('hello', 'Java', 'Python')
print(''.join(t)) # helloJavaPython
t = ('hello', 'Java', 'Python')
print(''.join(t)) # helloJavaPython
print('*'.join('Python')) # P*y*t*h*o*n
字符串的比较操作
运算符:>,>=,<,<=,==,!=
**比较规则:**首先比较两个字符串中的第一个字符,如果相等则继续比较下一个字符,一次比较下去,指导两个字符串中的字符不相等时,其比较结果就是两个字符串的比较结果,两个字符串中的所有后续字符将不再被比较
**比较原理:**两个以上字符进行比较时,比较的是其ordinal value(原始值),调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr,调用内置函数chr时指定ordinal value可以得到其对应的字符
a = b = 'Python'
c = 'Python'
print(a == b) # True
print(b == c) # True
print(a is b) # True
print(a is c) # True
print(id(a)) # 2592489649456
print(id(b)) # 2592489649456
print(id(c)) # 2592489649456
字符串的切片操作
print(s1) # hello
print(s2) # Python
print(newstr) # hello!Python
print(s1) # hello
print(s2) # Python
print(newstr) # hello!Python
print("-----------")
print(id(s)) # 2474006161840
print(id(s1)) # 2474010624176
print(id(s2)) # 2474010824176
print(id(s3)) # 2474010624048
print(id(newstr)) # 2474010639536
print("--------------切片[start:end:step]-----------------")
print(s[1:5:1]) # 从1开始截到5(不包含5),步长为1 ello
print(s[::2]) # 默认从0开始,没有写结束,默认字符串的最后一个元素,步长为2,两个元素之间的索引间隔为2 hloPto
print(s[::-1]) # 默认从字符串的最后一个元素开始,到字符串的第一个元素结束,因为步长为负数 nohtyP,olleh
print(s[-6::1]) # 从索引为-6开始,到字符串的最后一个元素结束,步长为1 Python
格式化字符串
# (1)%占位符
name = '张三'
age = 20
print('我叫%s,今年%d岁' % (name, age)) # 我叫张三,今年20岁
# (2){}
print("我叫{0},今年{1}岁".format(name, age)) # 我叫张三,今年20岁
# {3}f-string
print(f'我叫{name},今年{age}岁') # 我叫张三,今年20岁
print('%10d' % 99)#10表示的是宽度
print('%.3f' % 3.1415926)#.3表示是小数点后三位
#同时表示宽度和精度
print('%10.3f' % 3.1415926)#一共总宽度为10,小数点后3位
print('%10d' % 99) # 99 10表示的是宽度
print('%.3f' % 3.1415926)#3.142
#同时表示宽度和精度
print('%10.3f' % 3.1415926)# 3.142 一共总宽度为10,小数点后3位
print('hellohello') # hellohello
print('hellohello')
print('{0:.3f}'.format(3.1415926))#.3表示的是一共是3位数
print('{0:.3f}'.format(3.1415926))#.3f表示是3位小数
print('{:10.3f}'.format(3.1415926))#同时设置宽度和精度
字符串的编码与解码
s = '天涯共此时'
# 编码
print(s.encode(encoding='GBK')) # 在GBK这种编码格中 一个中文占两个字节
print(s.encode(encoding='UTF-8')) # 在UTF-8这种编码格式中,一个中文占三个字节
# 解码
# byte代表的就是一个二进制数据(字节类型的数据)
byte = s.encode(encoding='GBK') # 编码
print(byte.decode(encoding='GBK')) # 解码
byte = s.encode(encoding='UTF-8')
print(byte.decode(encoding='UTF-8'))
函数
函数调用的参数传递 _ 位置实参 _ 关键字实参
# 位置实参
# 根据形参对应的位置进行实参传递
def calc(a, b):
c = a + b
return c
result = calc(10, 20)
print(result)
# 关键字实参
# 根据形参名称进行实参传递
res = calc(b=10, a=20) # 等号左侧的变量的名称成为关键字参数
print(res)
函数的返回值
print(bool(0)) # False
print(bool(8)) # 非0的布尔值为True
def fun(num):
odd = [] # 存奇数
even = [] # 存偶数
for i in num:
if i % 2:
odd.append(i)
else:
even.append(i)
return odd,even
# 函数的调用
lst = [10, 29, 34, 23, 44, 53, 55]
print(fun(lst))
'''函数的返回值
(1)如果函数没有返回值【函数执行完毕之后,不需要给调用处提供数据】return可以省略不写
(2)函数的返回值,如果是1个,直接返回类型
(3)函数的返回值,如果是多个,返回的结果为元组
'''
def fun1():
print('hello')
# return脱了裤子放屁
fun1()
def fun2():
return 'hello'
res = fun2()
print(res)
def fun3():
return 'hello', 'world'
print(fun3())
'''False
True
([29, 23, 53, 55], [10, 34, 44])
hello
hello
('hello', 'world')
'''
函数参数定义_默认值参数
def fun(a, b=10):
print(a, b)
# 函数的调用
fun(100) # 100 10
fun(20, 30) # 20 30
print('hello',end='\t')
print('world')#hello world
函数的参数定义
个数可变的位置参数
定义函数,可能无法事先确定传递的位置实参的个数时,使用可变的位置参数
使用*定义个数可变的位置形参
结果为一个元组
个数可变的关键字形参
定义函数时,无法实现确定传递的关键字实参的个数时,使用可变的关键字形参
使用**定义个数可变的关键字形参
结果为一个字典
函数参数定义 _ 个数可变的位置形参 _ 个数可变的关键字形参
def fun(*args): # 函数定义时的可变的位置参数
# 为什么可变,因为传多少都可以
print(args)
print(args[0])
fun(10)
fun(10, 30)
fun(30, 405, 50)
def fun1(**args):
print(args)
fun1(a=10)
fun1(a=20, b=30, c=40)
print('hello', 'world', 'java')
'''def fun2(*args,*a):
pass
以上代码,程序会报错,个数可变的位置参数,只能是1个
def fun2(**args,**args):
pass
以上代码,程序会报错,个数可变的位置参数,只能是1个
'''
def fun2(*args1, **args2):
pass
'''def fun2(**args,**args):
pass
在一个函数的定义过程中,既有个数可变的关键字,也有个数可变的位置形参,要求,个数可变的位置形参,放在个数可变的关键字形参之前
'''
函数的参数总结
def fun(a, b, c): # a,b,c在函数的定义处,所以是形式参数
print('a=', a)
print('b=', b)
print('c=', c)
# 函数的调用
fun(10, 20, 30) # 函数调用时的参数传递,称为位置传参
lst = [11, 22, 33]
fun(*lst)
print('----------------')
fun(a=100, c=300, b=200) # 函数的调用,所以是关键字实参
dic = {'a': 111, 'b': 222, 'c': 333}
fun(**dic) # 在函数调用时,将字典中的键值对都转换为关键字实参传入
'''
a= 10
b= 20
c= 30
a= 11
b= 22
c= 33
----------------
a= 100
b= 200
c= 300
a= 111
b= 222
c= 333
'''
def fun(a, b=10): # b是在函数的定义处,所以b是形参,而且进行了赋值,所以b称为默认值形参
print('a=', a)
print('b=', b)
def fun2(*args): # 个数可变的位置形参
print(args)
def fun3(**args2): # 个数可变的关键字形参
print(args2)
fun2(10, 20, 30, 40) # (10, 20, 30, 40)
fun3(a=11, b=22, c=33, d=44, e=55)
def fun4(a, b, *, c, d): # 从*之后的参数,在函数调用时,只能采用关键字参数传递
print('a=', a)
print('b=', b)
print('c=', c)
print('d=', d)
# 调用fun4函数
fun4(10, 20, 30, 40) # 位置实参传递
fun4(a=10, b=20, c=30, d=40) # 关键字实参传递
fun4(10, 20, c=30, d=40) # 前两个参数,采用的是位置实参传递,而c,d采用的是关键字实参传递
'''需求, c,d只能采用关键字实参传递'''
'''函数定义时的形参的顺序问题'''
def fun5(a, b, *, c, d, **args):
pass
def fun6(*args, **args2):
pass
def fun7(a, b=10, *args, **args2):
pass
变量的作用域
变量的作用域
def fun(a, b):
c = a + b # c,就是全局变量,因为c在函数体内进行定义的变量,a,b为函数的形参,作用范围也是函数内部,相当于局部变量
print(c)
# print(c),因为a、c超出了起作用的范围(超出了作用域)
# print(a)
name = '杨老师'#name的作用范围为函数内部和外部都可以使用-->成为全局变量
print(name)
def fun2():
print(name)
#调用函数
fun2()
def fun3():
global age #函数内部定义的变量,局部变量,局部变量使用global声明,这个变量实际上就变成了全局变量
age=20
print(age)
fun3()
print(age)
# 调用函数
fun2()
'''杨老师
杨老师
20
20
杨老师
'''
递归函数
什么是递归函数
如果在一个函数体内调用了该函数本身,这个函数就称为递归函数
递归的组成部分
递归调用与递归终止条件
递归的调用过程
每递归调用一次函数,都会在栈内存分配一个栈帧
每执行完一次函数,都会释放相应的空间
递归的优缺点
缺点:占用内存多,效率低下
优点:思路和代码简单
def fac(n):
if n == 1:
return 1
else:
res = n * fac(n - 1)
return res
print(fac(6))#720
斐波那契数列
def fib(n):
if n == 1:
return 1
elif n == 2:
return 1
else:
return fib(n - 1) * fib(n - 2)
# 斐波那契数列第六位上的数字
print(fib(6))
# 输出这个数列的前6位上的数字
for i in range(1, 7):
print(fib(i))
'''def fib(n):
if n == 1:
return 1
elif n == 2:
return 1
else:
return fib(n - 1) * fib(n - 2)
# 斐波那契数列第六位上的数字
print(fib(6))
# 输出这个数列的前6位上的数字
for i in range(1, 7):
print(fib(i))'''
Bug
Bug的常见类型
age = input('请输入你的年龄')
print(type(age))
if int(age) >= 18:
print('成年人...')
1、漏了末尾的冒号,如if语句,循环语句,else子句等
2、缩进错误,该缩进的没缩进,不该缩进的瞎缩进
3、把英文符号写成中文符号,比如说:引号,冒号,括号
4、字符串拼接的时候,把字符串和数字拼在一起
5、没有定义变量,比如说while的循环条件的变量
6、“==”比较运算符合“=”赋值运算符的混用
知识不熟练导致的错误
(1)索引越界问题IndexError
lst=[11,22,33,44]
print(lst[4])
lst = [11, 22, 33, 44]
print(lst[3])
(2)append()方法的使用掌握不熟练
lst=[]
lst=append(‘A’,‘B’,‘C’)
print(lst)
lst=[]
lst.append('A')
lst.append('B')
lst.append('C')
print(lst)#['A', 'B', 'C']
思路不清晰导致
lst = [{'rating': [9.7], 'id': '1292052', 'type': ['犯罪'], 'title': '肖申克的救赎',
'actors': ['蒂姆', '摩根']},
{'rating': [9.6], 'id': '1291546', 'type': ['剧情'], 'title': '霸王别姬',
'actors': ['张国荣', '张丰毅']},
{'rating': [9.5], 'id': '1292720', 'type': ['剧情'], 'title': '阿甘正传',
'actors': ['汤姆', '罗宾']}]
name = input('请输入您要查询的演员:')
for item in lst: # 遍历列表 -->{} item是一个又一个的字典
act_lst = item['actors']
for actor in act_lst: # 遍历字典,得到movie是一个字典中的key
if name in actor:
print(name, '出演了', item['title'])
'''actors = movie['actors']
if name in actors:
print(name + '出演了:' + movie)
'''
被动掉坑
被动掉坑:程序代码逻辑没有错,知识因为用户错误操作或者一些“例外情况”而导致的程序崩溃
**题目要求:**输入两个整数并进行除法运算
try:
a = int(input('请输入第一个整数'))
b = int(input('请输入第二个整数'))
result = a / b
print('结果为:', result)
except ZeroDivisionError:
print('对不起,除数不允许为0')
except ValueError:
print('只能输入数字串')
print('程序结束')
try-except-else结构
try:
a = int(input('请输入第一个整数'))
b = int(input('请输入第二个整数'))
result = a / b
except BaseException as e:
print('出错了', e)
else:
print("计算结果为:",result)
try: a = int(input('请输入第一个整数'))
b = int(input('请输入第二个整数'))
result = a / bexcept BaseException as e:
print('出错了', e)
else: print("计算结果为:",result)
finally: print('谢谢您的使用')python
Python中常见的异常类型
ZeroDivisionError除零
IndexError序列中没有此索引
KeyError映射中没有这个键
NameError未声明/初始化对象(没有属性)
SyntaxErrorPython语法错误
ValueError传入无效的参数
# print(10/0)#ZeroDivisionError
lst = [11, 22, 33, 44]
#print(lst[4]) # IndexError
#print(num)#NameError
#int a=20#SyntaxError
a=int('hello')#ValueError
traceback模块的使用
import traceback
try:
print('-------------------------')
print(1 / 0)
except:
traceback.print_exc()
面向对象
类
class Student: # Student为类的名称(类名)由一个或多个单词组成,每个单词的首字母大写,其余小写
native_pace = '吉林' # 直接写在类里的变量,称为类属性
def __init__(self, name, age):
self.name = name # self.name成为实体属性,进行了一个赋值的操作,将局部变量的name的值赋给实体属性
self.age = age
# 实例方法
def eat(self):
print('学生在吃饭。。。')
# 静态方法
@staticmethod
def method():
print('我使用了staticmethod进行修饰,所以我是静态方法')
# 类方法
def cm(cls):
print('我是类方法,因为我使用了classmethod进行修饰')
# 在类之外定义的成为函数,在类之内定义的成为方法
def drink():
print('喝水')
类属性、类方法、静态方法的使用
**类属性:**类中方法外的变量成为类属性,被该类的所有对象多共享
类方法:使用@classmethod修饰的方法,使用类名直接访问的方法
静态方法:使用@staticmethod修饰的主法,使用类名直接访问的方法
class Student: # Student为类的名称(类名)由一个或多个单词组成,每个单词的首字母大写,其余小写
native_pace = '吉林' # 直接写在类里的变量,称为类属性
def __init__(self, name, age):
self.name = name # self.name成为实体属性,进行了一个赋值的操作,将局部变量的name的值赋给实体属性
self.age = age
# 实例方法
def eat(self):
print('学生在吃饭。。。')
# 静态方法
@staticmethod
def method():
print('我使用了staticmethod进行修饰,所以我是静态方法')
# 类方法
def cm(cls):
print('我是类方法,因为我使用了classmethod进行修饰')
# 在类之外定义的成为函数,在类之内定义的成为方法
def drink():
print('喝水')
# 类属性的使用方式
print(Student.native_pace)
stu1 = Student('张三', 20)
stu2 = Student('李四', 30)
print(stu1.native_pace)
print(stu2.native_pace)
Student.native_pace = '天津'
print(stu1.native_pace)
print(stu2.native_pace)
Student.cm()
print('----------------静态方法的使用方式---------------')
Student.method()
动态绑定属性和方法
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self):
print(self.name + '在吃饭')
#动态绑定属性
stu1 = Student('张三', 20)
stu2 = Student('李四', 30)
print(id(stu1))
print(id(stu2))
stu2.gender = '女' # 只为stu2动态绑定了性别
print(stu1.name, stu1.age)
print(stu2.name, stu2.age, stu2.gender)
stu1.eat()
stu2.eat()
#动态绑定方法
def show():
print('定义在类之外的,称函数')
stu1.show=show
stu1.show()
#stu2.show()
'''1997157314512
1997157313120
张三 20
李四 30 女
张三在吃饭
李四在吃饭
定义在类之外的,称函数
'''
面向对象的三大特征_封装的实现方式
class Student:
def __init__(self, name, age):
self.name = name
self.__age = age # 年龄不希望在类的外部被使用,所以加了两个
def show(self):
print(self.name, self.__age)
stu=Student('张三', 20)
stu.show()
#在类的外面使用name与age时
print(stu.name)
#print(stu.__age)
print(dir(stu))
print(stu._Student__age)#在类的外部可以通过 _Student__age 进行访问
继承及其实现方式
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def info(self):
print(self.name, self.age)
class Student(Person):
def __init__(self, name, age, stu_no):
super().__init__(name, age)
self.stu_no = stu_no
class Teacher(Person):
def __init__(self, name, age, teacheryear):
super().__init__(name, age)
self.teacheryear = teacheryear
stu = Student('张三', 20, '1001')
teacher = Teacher('李四', 34, 10)
stu.info()
teacher.info()
'''
张三 20
李四 34'''
# 多继承
class A(object):
pass
class B(object):
pass
class C(A, B):
pass
方法重写
方法重写
·如果子类对继承自父类的某个属性或方法不满意,可以在子类中对其(方法体)进行重新编写
·子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法
Object类
·object类是所有类的父类,因此所有类都有object类的属性和方法。
·内置函数dir()可以查看指定对象所有属性
·Object有一个__str__()方法,用于返回一个’对象的描述’,对应与内置函数str()经常用于print()方法,帮我们查看对象的信息,所以我们经常会对__str__()进行重写
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return '我的名字是{0},今年{1}岁'.format(self.name, self.age)
stu = Student('张三', 20)
print(dir(stu))
print(stu) # 默认调用__str__()这样的方法
print(type(stu))
'''['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name']
我的名字是张三,今年20岁
<class '__main__.Student'>'''
多态的实现
多态就是"具有多种形态",它指的是:几遍不知道一个变量所引用的对象到底是什么类型,任然可以通过这个变量调用方法,在运行过程中根据变量所引用对象的类型,动态决定调用哪个对象中的方法
静态语言和动态语言关于多态的区别
·静态语言实现多态的三个必要条件
·继承
·方法重写
·父类引用指向子类对象
·动态语言的多态崇尚“鸭子类型”当看到一只鸟走起来想鸭子、游泳起来像鸭字、收起来也想鸭子,name这只鸟就可以被称为鸭子。在鸭子类型中,不需要关心对象是什么类型,到底是不是鸭子,只关心对象的行为
特殊属性
class A:
pass
class B:
pass
class C(A, B):
def __init__(self, name, age):
self.name = name
self.age = age
# 创建C类的对象
x = C('Jack', 20) # x是C类型的一个实例对象
print(x.__dict__) #实例对象的属性字典
print(C.__dict__)
print(x.__class__)#输出了对象所属的类
print(C.__bases__)#C类的父类类型的元素
print(C.__base__)
print(A.__subclasses__())
'''
{'name': 'Jack', 'age': 20}
{'__module__': '__main__', '__init__': <function C.__init__ at 0x0000024C5F89DB80>, '__doc__': None}
<class '__main__.C'>
(<class '__main__.A'>, <class '__main__.B'>)
<class '__main__.A'>
'''
特殊方法
a = 20
b = 100
c = a + b # 两个帧数类型的对象的相加操作
d = a.__add__(b)
print(c)
print(d)
class Student:
def __init__(self, name):
self.name = name
def __add__(self, other):
return self.name + other.name
def __len__(self):
return len(self.name)
stu1 = Student('张三')
stu2 = Student('李四')
s = stu1 + stu2 # 实现了两个对象的加法运算(因为在Student类中,编写__add__()特殊的方法)
print(s)
s = stu1.__add__(stu2)
print(s)
lst = [11, 22, 33, 44]
print(len(lst)) # len是内置函数len,可以计算列表的长度
print(lst.__len__())
print(len(stu1))
'''特殊属性
__dict__
获得类对象或实例对象所绑定的所有属性和方法的字典
特殊方法
__len__()
通过重写__len__()方法,让内置函数len()的参数可以自定义类型
__add__()
通过重写__add__()方法,可使用自定义对象具有“+”功能
__new__()
用于创建对象
__init__()
对创建的对象进行初始化
'''
__new__与__init__演示创建对象的过程
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dr1fcSnZ-1643201540467)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220124114008841.png)]
class Person(object):
def __new__(cls, *args, **kwargs):
print('__new__被调用执行了cls的id值为{0}'.format(id(cls)))
obj = super().__new__(cls)
print('创建的对象的id为:{0}'.format(id(obj)))
return obj
def __init__(self, name, age):
print('__init__被调用了,self的id值为:{0}', format(id(self)))
self.name = name
self.age = age
print('object这个类对象的id为:{0}'.format(id(object)))
print('Person这个类对象的id为:{0}'.format(id(Person)))
# 创建Person类的实例对象
p1 = Person('张三', 20)
print('p1这个Person类的实例对象的id:{0}'.format(id(p1)))
类的赋值与浅拷贝
变量的赋值操作
只是形成两个变量,实际上还是只想同一个对象
浅拷贝
Python拷贝一般都是浅拷贝,拷贝时,对象包含的子对象内容不拷贝,因此,源对象与拷贝对象会引用同一个子对象
深拷贝
使用copy模块的deepcopy函数,递归拷贝对象中包含的子对象,源对象和拷贝对象所有的子对象也不相同
class CPU:
pass
class Disk:
pass
class Computer:
def __init__(self, cpu, disk):
self.cpu = cpu
self.disk = disk
# (1)变量的赋值
cpu1 = CPU()
cpu2 = cpu1
print(cpu1)
print(cpu2)
# (2)类有浅拷贝
print('------------------------------')
disk = Disk() # 创建一个硬盘类对象
computer = Computer(cpu1, disk) # 创建一个计算机类的对象
# 浅拷贝
import copy
print(disk)
computer2 = copy.copy(computer)
print(computer, computer.cpu, computer.disk)
print(computer2, computer2.cpu, computer2.disk)
# 深拷贝
computer3 = copy.deepcopy(computer)
print(computer, computer.cpu, computer.disk)
print(computer3, computer3.cpu, computer3.disk)
<__main__.CPU object at 0x0000023E0FC21FD0>
<__main__.CPU object at 0x0000023E0FC21FD0>
------------------------------
<__main__.Computer object at 0x0000023E0FC21F70> <__main__.CPU object at 0x0000023E0FC21FD0> <__main__.Disk object at 0x0000023E0FC21FA0>
<__main__.Computer object at 0x0000023E0FC21190> <__main__.CPU object at 0x0000023E0FC21FD0> <__main__.Disk object at 0x0000023E0FC21FA0>
模块
创建模块
新建一个.py文件,名称尽量不要与Python自带的标准模块名称相同
导入模块
import 模块名称 [as 别名]
from 模块名称 import 函数/变量/类
import math # 关于数学运算
print(id(math))
print(type(math))
print(math)
print(math.pi)
print('----------------------')
print(dir(math))
print(math.pow(2, 3), type(math.pow(2, 3)))
print(math.ceil(9.001))
print(math.floor(9.999))
'''
2855299925232
<class 'module'>
<module 'math' (built-in)>
3.141592653589793
----------------------
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
8.0 <class 'float'>
10
9'''
from math import pi
print(pi)
print(pow(2, 3))
# print(math.pow(2,8))
模块的导入
def add(a, b):
return a + b
def div(a, b):
return a / b
# 这个模块的名称是calc
import calc
print(calc.add(10,20))
print(calc.div(10,4))
from calc import add
print(add(10,20))
以主程序方式运行124
def add(a, b):
return a + b
if __name__ == '__main__':
print(add(10, 20)) # 只有当点击运行calc2时,才会执行运算
Python中的包
sys 与Python解释其及其环境操作相关的标准库
time提供与时间相关的各种函数的标准库
os提供了访问操作系统服务功能的标准库
calendar提供与日期相关的各种函数的标准库
urllib用于读取来自网上(服务器)的数据标准库
json用于使用Json序列化和反序列化对象
re用于在字符串中执行正则表达式匹配和替换
math提供标准算数运算函数的标准库
decimal用于进行精准控制运算精度、有效数位和四舍五入操作的十进制运算
logging提供了灵活的记录时间、错误、警告和调试信息的功能
import sys
import time
import urllib.request
print(sys.getsizeof(24))#28
print(sys.getsizeof(45))#28
print(sys.getsizeof(True))#28
print(sys.getsizeof(False))#24
print(time.time())#1643016733.717006
print(time.localtime(time.time()))#time.struct_time(tm_year=2022, tm_mon=1, tm_mday=24, tm_hour=17, tm_min=32, tm_sec=13, tm_wday=0, tm_yday=24, tm_isdst=0)
print(urllib.request.urlopen('http://www.baidu.com').read())
第三方模块的安装126
文件
编码格式的介绍
常见的字符编码格式
Python的解释器使用的是Unicode(内存)
py文件在磁盘上使用UTF-8存储(外存)
文件读写的原理_读取磁盘文件中的内容
·文件的读写俗称“IO操作”
·文件读写操作流程
·操作原理
file = open('a.txt', 'r')
print(file.readlines())
file.close()
常用的文件打开模式131
文件类型
按文件中数据的组织形式,文件分为以下两大类
**文本文件:**存储的是普通"字符"文本,默认为uincode字符集,可以使用记本事程序打开
**二进制文件:**把数据内容用“字节”进行存储,无法用记事本打开,必须使用专用的软件打开,举例:mp3音频文件,jpg图片,.doc文档等
r以值读模式打开文件,文件的指针将会放在文件的开头
w以只写模式打开文件,如果文件不存在则创建,如果文件存在,则覆盖原有内容,文件指针在文件的开头
a以追加模式打开文件,如果我呢间不存在则创建,文件指针在文件开头,如果文件存在,则在文件末尾住家内容,文件指针在源文件末尾
b以二进制方式打开文件,不能单独使用,需要与供他模式一起视同,rb,或者wb
**+**以读写方式打开文件,不能单独使用,需要与其它模式一起使用,a+
#w
file = open('b.txt', 'w')
file.write('Python')
file.close()
#b
src_file = open('b.txt', 'r')
target_file = open('copylogo.png', 'wb')
print(target_file.write(src_file.read()))
target_file.close()
src_file.close()
**read([size])**从文件中读取size个字节或字符的内容返回。若省略[size],则读取到文件末尾,即一次读取文件所有内容
**readline()**从文本文件中读取一行内容
**readlines()**把文本文件中每一行都作为独立的字符串对象,并将这些对象放入列表返回
**write(str)**将字符串str内容写入文件
**writelines(s_list)**将字符串str内容写入文件
**writelines(s_list)**将字符串列表s_list写入文本文件,不添加换行符
seek把文件指针移动到新的位置,offset表示相对于whence的位置:offset:为正往结束方向移动,为负往开始方向移动 whence不同的值代表不同含义
0:从文件头开始计算默认值(默认值)
1:从当前位置开始计算
2:从文件末开始计算
**tell()**返回文件指针的当前位置
**flush()**把缓冲区的内容写入文件,但不关闭文件
**close()**把缓冲区的内容写入文件,同时关闭文件,释放对象相关资源
file = open('c.txt', 'a')
lst = ['java', 'go', 'python']
file.writelines(lst)
file.close()
#javagopython
file = open('a.txt', 'r')
file.seek(2)
print(file.read())
print(file.tell())
file.close()
with语句(上下文管理器)
·with语句可以自动管理上下文资源,不论什么原因跳出with都能确保文件正确的关闭,以此来大道释放资源的目的
class MyContentMgr(object):
def __enter__(self):
print('enter方法被调用执行了')
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print("exit方法被调用执行了")
def show(self):
print('show()方法被调用执行了')
with MyContentMgr() as file:
file.show()
#另一个文件
with open('a.txt', 'r') as file:
print(file.read())
'''改进
with open('logo.png','rb') as src_file:
with open('copy2logo.png','wb') as target_file:
target_file.write(src_file.read())
'''
os模块的常用函数
import os
os.system('notepad.exe')
os.system('calc.exe')
#直接调用
os.startfile('C:\\Program Files (x86)\\Tencent\\TIM\\Bin\\tim.exe')
os模块是Python内置的与操作系统功能和文件系统相关的模块,该模块中的语句的执行结果通常与操作系统有关,在不同的操作系统上运行,得到的结果可能不一样。
os模块与os.path模块用于对目录或文件进行操作
import os
os.system('notepad.exe')
os.system('calc.exe')
#直接调用
os.startfile('C:\\Program Files (x86)\\Tencent\\TIM\\Bin\\tim.exe')
import os
print(os.getcwd())
**getcwd()**返回当前的工作目录
**listdir(path)**返回指定路径下的文件和目录信息
**mkdir(path[,mode])**创建目录
**makedirs(path1/path2)**创建多级目录
**rmdir(path)**删除目录
**removedirs(path1/path2)**删除多级目录
**chdir(path)**将path设置为当前工作目录
import os
print(os.getcwd())
lst = os.listdir('../chap15')
print(lst)
os.mkdir('newdir2')
#os.makedirs('A/B/C/')
os.rmdir('newdir2')
os.removedirs('A/B/C')
os.path模块的常用方法
path模块操作目录相关函数
**abspath(path)**用于获取文件或目录的绝对路径
**exists(path)**用于判断文件或目录是否存在,如果存在返回True,否则返回False
**join(path,name)**将目录与目录或者文件名拼接起来
**splitext()**将目录与目录或者文件名拼接起来
**basename(path)**从一个目录中提取文件名
**dirname(path)**从一个路径中提取文件路径,不包括文件名
**isdir(path)**用于判断是否为路径
import os.path
print(os.path.abspath('demo10.py'))
print(os.path.exists('demo13py'), os.path.exists('demo10.py'))
剩下的听不懂
实操案例
实操案例一
任务1:向文件输出’奋斗成就更好的你’
"""一、使用print方式进行输出(输出的目的地是文件)"""
fp = open('C:/李林峰/text.txt', 'w')#open是打开创建文件的意思
print('奋斗成就更好的未来',file=fp)
fp.close()
'''二、使用文件的读写操作'''
with open('C:/李林峰/text2.txt', 'w') as file:
file.write('奋斗成就更好的未来')
实操案例二
输出《红楼梦中的金陵十二钗》前5位
'''1 变量的赋值'''
name1='林黛玉'
name2='薛宝钗'
name3='贾元春'
name4='贾探春'
name5='史湘云'
print('1\t'+name1)
print('2\t'+name2)
print('3\t'+name3)
print('4\t'+name4)
print('5\t'+name5)
'''2种方式 列表'''
lst_name=['林黛玉','薛宝钗','贾元春','贾探春','史湘云']
lst_sig=['1','2','3','4','5']
for i in range(5):
print(lst_sig[i],'\t',lst_name[i])
'''3种方式 字典'''
d={'1':'林黛玉','2':'薛宝钗','3':'贾元春','4':'贾探春','5':'史湘云'}
for key in d:
print(key,d[key])
print('zip-----------')
for s,name in zip(lst_sig,lst_name):
print(s,name)
图像音像勋章
print('\033[0:35m\t\t图像音像勋章\033[m')
print('\033[0:35m---------------------\033[m')
输出你的身体指标
height=170
weight=50.5
bmi=weight/(height+weight)
print('您的身高是:'+str(height))
print('您的体重是:'+str(weight))
print('您的BMI的指数是:'+'{:0.2f}'.format(bmi))
实操案例三
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R1zpsXrZ-1643201540468)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220125104315944.png)]
将指定的十进制数转换成二进制、八进制、十六进制
二进制 ------>binary system
八进制 ------>octonary number system 英 /ˈɒktənəri/
十进制 ------>decimalism 英 /ˈdesɪməlɪzəm/
def fun():
num=int(input('请输入一个十进制的整数'))#将str转换成int类型
print(num,'的二进制数是:',bin(num))#第一种写法,使用了个数可变的位置参数
print(str(num)+'的二进制数为:'+bin(num))#第二种写法,使用“+”作为连接符(+的左右均为str类型)
print('%s的二进制位:%s'%(num,bin(num)))#第三种写法,格式化字符串
print('{0}的二进制数为:{1}'.format(num,bin(num)))#第三种写法,格式化字符串
print(f'{num}的二进制数为:'{bin(num)})#第三种方式,格式化字符串
print(f'{num}的八进制数为:'{oct(num)})
print(f'{num}的十六进制数为:'{hex(num)})
if __name__ == '__main__':
while True:
try:
fun()
break#如果程序正常输出结束以后,我们再break
except:
print('只能输入整数!程序出错,请重新输入')
为自己手机充值
print('用户手机账户原有话费金额为:\033[0:35m8元\033[m')
money=int(input('请输入用户充值金额:'))
money+=8
print('当前的金额为:\033[0:35m',money,'元\033[m')
'''
用户手机账户原有话费金额为:8元
请输入用户充值金额:100
当前的金额为: 108 元
'''
计算能量的消耗
num=int(input('请输入您当天行走的步数:'))
calorie=num*28
print(f'今天共消耗了卡路里{calorie},即{calorie/1000}千卡')
'''
请输入您当天行走的步数:10000
今天共消耗了卡路里280000,即280.0千卡
'''
预测未来子女的身高
father_height=float(input('请输入父亲的身高:'))
mother_height=float(input('请输入母亲的身高:'))
son_height=(father_height+mother_height)*0.54
print('预测子女的身高为:{}cm'.format(son_height))
'''
请输入父亲的身高:170
请输入母亲的身高:168
预测子女的身高为:182.52cm'''
实操案例四
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NaiTxVnV-1643201540468)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220125114055615.png)]
支付密码的验证
pwd=input('支付宝支付密码:')
if pwd.isdigit():
print('支付数据合法')
else:
print('支付数字不合法,支付密码只能是数据')
print('-------------------------------------------')
print('支付数据合法' if pwd.isdigit() else '支付数字不合法,支付密码只能是数据')
模拟QQ账号登录
qq=input('请输入qq号:')
pwd=input('请输入密码:')
if qq=='1059630434' and pwd=='123':
print('登陆成功')
else:
print('对不起,账号或密码不正确')
商品价格大竞猜
import random
price=random.randint(1000,1500)
print('今日竞猜的商品为小米草地机器人:价格在[1000-1500]之间:')
guess=int(input())
if guess>price:
print('大了')
elif guess<price:
print('小了')
else:
print('猜对了')
print('真实价格为:',price)
根据星座查看运势
d={
'白羊座':'''1''',
'金牛座':'''2'''
}
star=input('请输入您的星座查看近来运势:')
print(d.get(star))
'''请输入您的星座查看近来运势:白羊座
1'''
实操案例五
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bqgG9JCd-1643201540474)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220125121002601.png)]
循环输出26个字母对应的ASCll码值
x=97#代表的是a的ASCII值
for _ in range(1,27):
print(chr(x),'--->',x)
x+=1
print('-----------')
x=97
while x<123:
print(chr(x),'-->',x)
x+=1
模拟用户登录
for i in range(1,4):
user_name=input('请输入用户名:')
user_pwd=input('请输入密码:')
if user_name=='admin' and user_pwd=='8888':
print('登录成功')
break
else:
print('用户名或密码不正确!!!')
if i<3:
print(f'您还有{3-i}次机会!!!')
else:#这个else的意思是当你的这三个循环都结束后就会执行这个else之后的语句
print('对不起,三次均输入错误,请联系后台管理员')
猜数游戏
import random
rand=random.randint(1,100)
for i in range(1,11):
num=int(input('在我心中有个数1-100,请你猜一猜'))
if num<rand:
print('小了')
elif num>rand:
print('大了')
else:
print('恭喜你猜对了')
break
print(f'您一共猜了{i}次')
if i<3:
print('真聪明')
elif i<=7:
print('还凑合')
else:
print('天哪,找杨老师学习折半算法!!!')
计算100-999之间的水仙花数
import math
for i in range(100,1000):
if math.pow((i%10),3)+math.pow((i//10%10),3)+math.pow(i//100,3)==i:
print(i)
实操案例六
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oFUhxFn2-1643201540474)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220126195422389.png)]
千年虫我来了
year=[82,89,88,86,85,00,99]
print('原列表',year)
for index,value, in enumerate(year):
#print(index,value)
if str(value)!='0':
year[index]=int('19'+str(value))
else:
year[index]=int('200'+str(value))
print('修改之后的列表:',year)
#列表的排序
year.sort()
print('排序之后的列表为:',year)
京东购物流程
lst=[]
for i in range(0,5):
goods=input('请输入商品编号和商品名称进入商品的入库,每次只能输入一件商品:\n')
lst.append(goods)
for item in lst:
print(item)
cart=[]
while True:
num=input('请输入要购买的商品编号:')
for item in lst:
if item.find(num)!=-1:
cart.append(item)
break# 退出for
if num=='q':
break #退出while循环
print('您购物车里已经选好的商品为:')
for i in range(len(cart)-1,-1,-1):
print(cart[i])
实操案例七
根据星座测试性格特点
key=input('请输入您的星座名称')
flag=True
for item in d:
if key==item:
flag=True
print(key,'的性格特点为:',d.get(key))
break
else:
flag=False
if not flag:
print('对不起,您输入的星座有误')
模拟12306货车票订票下单
dict_ticket={'G120':['天津-上海','18:05'],
'G153':['北京-天津','18:15']}
print('车次\t\t出发站-到达站\t\t')
for item in dict_ticket:
print(item,end=' ')
for i in dict_ticket[item]:
print(i,end=' ')
print()#换行
#请输入要购买的车次
train_no=input('请输入要购买的车次:')
persons=input('请输入乘车人,如果是多人请使用逗号分隔')
s=f'您已购买了{train_no}次列表'
s_info=dict_ticket[train_no]#获取车次详细信息
s+=s_info[0]+' '+s_info[1]+' 开'
print(f'{s}请{persons}尽快取走纸质车票.')
实操案例八
我的咖啡馆你做主
print('本店经营的咖啡有:')
for index,item in enumerate(coffee_name):
print(index+1,',',item,end=' ')
index=int(input('\n请输入您喜欢的咖啡编号:'))
if 0<=index<=len(coffee_name):
print(f'您的咖啡[{coffee_name[index-1]}]好了,请您慢用')
Python print输出带颜色 总结
https://mp.weixin.qq.com/s?src=11×tamp=1643077913&ver=3579&signature=Xs5i8fOba3Gvnk6VoReCQEZbFoRsxdHCv78bIkAR83AXabyIBVQXrSpTxpM7XqJrsF1K9JCf8l4erybJS7kfqksl2v6e0J2*SbQzGq-ZSelf-ULL9K3d7u970gXII3nP&new=1
# 最最基本
## print函数
### 将数据输出文件中
```python
#将数据输出文件中,注意点,1.所指定的盘符存在。2.使用file=fp
fp = open('C:/李林峰/text.txt', 'a+')#如果文件不存在就创建,存在就在文件内容后面继续追加
print('helloworld', file=fp)
fp.close()
#不进行换行输出(输出内容在一行当中)
print('hello','world','Python')
open的方式是输出到文件当中
print的方式是输出到显示器当中+
不进行换行输出(输出的内容在一行中)
print('hello','world','Python')
常用的转义字符
print('hello\nworld') # 换行 n->newline
print('hello\tworld') # 空了三隔
print('helloooo\tworld') # 空了四隔->tab键
print('hello\rworld') # world将hello进行了覆盖->return光标移动到本行的开头
print('hello\bworld') # \是退格back
print('http:\\\\www.bandu.com')
print('老师说:\'大家好\'')
#原字符,不希望字符串中的转义字符起作用,就是用元字串之前加上r或R
print(r'hello\nworld')
#注意事项,最后一个字符不能是反斜杠,可以是两个反斜杠
print(r'hello\nworld\\')
变量的定义和使用
name = '玛利亚'
print(name)
print('标识', id(name))
print('类型', type(name))
print('值', name)
数据类型
·常见的数据类型
·整数类型->int->98
·浮点数类型->float->3.14159
·布尔类型->bool->True,False
·字符串类型->str->人生苦短
整数类型
#整数可以表示二进制,十进制,八进制,十六进制
print('十进制',118)#默认十进制
print('二进制',0b1010111)#二进制以0b开头
print('八进制',0o176)#八进制以0o开头
print('十六进制',0x1EAF)
浮点类型
n1 = 1.1
n2 = 2.2
print(n1+n2)#3.3000000000000003
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))#3.3
布尔类型
f1 = True
f2 = False
print(f1,type(f1))#True <class 'bool'>
print(f2,type(f2))#False <class 'bool'>
#布尔值可以转成整数计算
print(f1+1) #2 1+1的结果为2,True表示1
print(f2+1) #1 0+1的结果为2,False表示0
字符串类型
str1 = '人生苦短,我用python'
str2 = "人生苦短,我用python"
str3 = """人生苦短,
我用python"""
str4 = ‘‘‘人生苦短,
我用python’’’
#单引号和双引号定义的字符串必须在一行
print(str1,type(str1))#人生苦短,我用python<class 'str'>
print(str2,type(str2))
#三引号定义的字符串可以分布在连续的多行
print(str3,type(str3))
print(str4,type(str4))
类型转换_str()函数与int()函数
str()函数
name = '张三'
age = 20
print(type(name),type(age))#说明name与age的数据类型不相同
print('我叫'+name+'今年'+age+'岁')#当将str类型与int类型进行链接时,报错,解决方案,类型转换
print('我叫'+name+'今年'+str(age)+'岁')
int()函数
s1 = 128
f1 = 98.7
s2 = '76.77'
ff = True
s3 = 'hello'
print(type(s1), type(f1), type(s2), type(ff), type(s3))
print(int(s1), type(int(s1))) #将str转成int类型,字符串为数字串
print(int(f1), type(int(f1))) #float转成int类型,截取整数部分,舍掉小数部分
# print(int(s2), type(int(s2))) #将str转成int类型,报错,因为字符串为小数串
print(int(ff), type(int(ff)))
#print(int(s3), type(int(s3))) #将str转成int类型,字符串必须为数字串(整数),非数字串是不允许转换的
float类型转换
#字符串中的数据如果是非数字串,则不允许转换
Python中的注释
#单行注释
"""我是多行注释
"""
Input函数的使用
present = input('大圣想要什么礼物呢')#输入之前程序给你的一个提示语 需要输入回答
input函数的高级使用
a = input('请输入一个加数:')#10
b = input('请输入另一个加数:')#10
print(type(a), type(b))#<class 'str'><class 'str'>
print(a + b)#1020
a = input('请输入一个加数:')#10
b = input('请输入另一个加数:')#10
print(type(a), type(b))#<class 'str'><class 'str'>
print(int(a) + int(b))#30
或者a = int(input('请输入一个加数:'))
运算符
算数运算符
print(1+1)# 加法运算
print(1-1) # 减法运算
print(2*4)# 8 乘法运算
print(1/2)# 除法运算
print(11/2)#5.5 除法运算
print(11//2)# 5 整除运算
print(11%2)# 1 取余运算
print(2**2)# 4 表示的是2的2次方
print(2**3)# 8 表示的是2的3次方
含减号的运算
print(9 // 4) # 2
print(-9 // -4) # 2
print(9 // -4) # -3
print(-9 // 4) # -3 一正一负的整数公式,向下取整
print(9 % -4) # -3 余数=被除数-除数*商 9-(-4)*(-3)
print(-9 % 4) # 3
赋值运算符
#解包赋值
a,b,c=20,30,40
print(a,b,c)
print('-----------交换两个变量的值----------')
a,b=10,20
print('交换之前:',a,b)#交换之前:10 20
#交换
a,b=b,a
print('交换之后:',a,b)#交换之后:20 10
比较运算符
a,b=10,20
print('a>b吗',a>b)#False
print('a<b吗',a<b)#True
print('a<=b吗',a<=b)#True
print('a>=b吗',a>=b)#False
print('a==b吗',a==b)#False
print('a!=b吗',a!=b)#True
a=10
b=10
print(a==b)#True 说明,a与b的value相等
print(a is b)#True 说明, a与b的id标识相等
#以下代码没学过,后面会给大家讲解
llist1=[11,22,33,44]
llist2=[11,22,33,44]
print(lstr1==lstr2)#value -->True
print(lstr1 is lstr2)#id -->False
print(id(lstr1))#267587787
print(id(lstr2))#787897988
print(lstr1 is not lstr2) #True
布尔运算
#and并且
#or或者
#not 对bool类型操作数取反
f=True
f2=False
print(not f)#False
print(not f2)#True
#in与not in
s = 'helloworld'
print('w' in s)#True
print('k' in s)#False
print('w' not in s)#False
print('k' not in s)#True
位运算
print(4 & 8) # 0 按位于&,同为1时结果为1
print(4 | 8) # 12 按位或|,同为0时结果为0
print(4 << 1) # 8 向左移动1位(移动一个位置)相当于乘以2
print(4 << 2) # 16 向左移动2位(移动2个位置)
print(4 >> 1) # 2 向右移动1位,相当于除以2
print(4 >> 2) # 1 向右移动2位,相当于除以4
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9Mx3a8gp-1643201542068)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220119175339789.png)]
运算符的优先级
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rY2tN5rZ-1643201542069)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220119180200590.png)]
对象的布尔值
print(bool(False))#False
print(bool(0))#False
print(bool(0.0))#False
print(bool(None))#False
print(bool(''))#False
print(bool(""))#False
print(bool([]))#False空列表
print(bool(list()))#False空列表
print(bool(()))#False空元组
print(bool(tuple))#False空元组
print(bool({}))#空字典
print(bool(dict()))#False空字典
print(bool(set()))#False空集合
其他的bool值为True
print(bool(18))#True
print(bool('helloworld'))#True
选择结构
单分支结构
money = 1000
s = int((input('请输入取款金额')))#取款金额
#判断金额是否充足
if money>=s:
money=money-s
print('取款成功,金额为:',money)
双分支结构
num = int(input('请输入一个整数'))
#条件判断
if num%2==0:
print(num,'是偶数')
else:
print(num,'是奇数')
多分支结构
score = int(input('请输入一个成绩:'))
# 判断
if 90 <= score <= 100:
print('A级')
elif 80 <= score < 90:
print('B级')
elif 70 <= score < 80:
print('C级')
elif 60 <= score < 70:
print('D级')
elif 0 <= score < 59:
print('E级')
else:
print('对不起,您输入的成绩有误,不再成绩的有效范围内')
嵌套if的使用
answer=input('您是会员吗?y/n')
money=float(input('请输入您的购物金额:'))
#外层判断是否是会员
if answer=='y':
if money >= 200:
print('打八折,付款金额为:',money*0.8)
elif money>=100:
print('打九折,付款金额为:',money*0.9)
else:
print('不打折,付款金额为:',money)
else:
if money>=200:
print('打9.5折,付款金额为:',money*0.95
else:
print('不打折,付款金额为:',money)
条件表达式
''''num_a=int(input('请输入第一个整数'))
num_b=int(input('请输入第二个整数'))
#比较大小
if num_a>=num_b
print(num_a,'大于等于',num_b)
else:
print(num_a,'小于',num_b)''''
print('使用条件表达式进行比较')
#条件判断的结果为true,就执行左边的内容,为false,执行右侧的代码
print(str(num_a)+'大于等于'+str(num_b) if num_a>=num_b else str(num_a)+'小于'+str(num_b))
pass语句
#pass语句,什么都不做,只是一个占位符,用到需要些语句的地方
answer=input('您是会员吗?y/n')
#判断是否是会员
if answer == 'y':
pass
else:
pass
range的三种创建方式
#range()的三种创建方式
''''第一种方式,只有一个参数(小括号中只给一个数)''''
r = range(10) #[0,1,2,3,4,5,6,7,8,9],默认从0开始,默认相差1位步长
print(r)#range(0,10)
print(list(r))#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#用于查看range对象中的整数序列-->list是列表的意思
''''第二中创建方式,给了两个数(小括号中给了连个数)''''
r=range(1,10)#指定了起始值,从1开始,到10结束(不包含10),默认步长为1
print(list(r))#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
''''第三种创建方式,给了三个参数(小括号中给了三个数)''''
r=range(1,10,2)
print(list(r))#[1,3,5,7,9]
'''判断指定的整数在序列中是否存在in,not in'''
print(10 in r)#False,10不在当前的r这个整数系列中
print(9 in r)#True,9在当前的r这个序列中
print(10 not in r)#True
while循环结构
sum=0
a=0
while a<5:
sum+=a
a++
print('和为',sum)
while练习题
sum=0
a=1
while a<=100:
if a%2==0:
sum+=a
a+=1
print('1-100之间的偶数和',sum)#因为print和while是对齐的,所以print没有进入while循环
for-in循环
for item in 'Python':#第一次取出来的是P,将P赋值给item,将item的值输出
print(item)
#range() 产生一个整数序列---》也是一个可迭代对象
for i in range(10):
print(i)#1 2 3 4 5 6 7 8 9
#如果在循环体中不需要使用自定义白能量,可将自定义变量写为“_”
for _ in range(5):
print('人生苦短,我用Python')
print('使用for循环,计算1到100的偶数和')
sum=0#用于存储偶数和
for item in range(1,101):
if item % 2==0:
sum+=item
print('1到100之间的偶数和为:',sum)
输出100到999的水仙花数
for item in range(100, 1000):
ge = item % 10
shi = item // 10 % 10
bai = item // 100
if ge ** 3 + shi ** 3 + bai ** 3 == item:
print(item)
循环控制语句break
for item in range(3):
pwd = input('请输入密码:')
if pwd == '8888':
print('密码正确')
break
else:
print('密码不正确')
流程控制语句continue
for item in range(1, 51):
if item % 5 != 0:
continue
print(item)
else语句
没有碰到break时执行else
#for和else搭配使用
for item in range(3):
pwd = input('请输入密码:')
if pwd == '8888':
print('密码正确')
break
else:
print('密码不正确')
else:
print('对不起,三次密码均输入错误')
#while和else搭配使用
a = 0
while a < 3:
pwd = input('请输入密码')
if pwd == '8888':
print('密码正确')
break
else:
print('密码不正确')
a += 1
else:
print('对不起,三次密码均不正确')
嵌套循环
# 输入一个三行四列的举行
for i in range(1, 4):
for j in range(1, 5):
print('*', end='\t')
print() # 换行
#打印九九乘法表
for i in range(1, 10):
for j in range(1, i+1):
print(str(i) + '*' + str(j) + '=' + str(i * j), end='\t')
#print(i,'*',j,'=',i*j,end='\t')
print()
二重循环中的break
二重循环中的break和continue用于控制本层循环
列表
自己的感悟
列表让我想到了Excel表,他的括号是直上直下的,又联系到java里的列表就有list([ ])
·列表对应的英语单词是list—>list([])
列表的创建
"""创建列表的第一种方式,使用[]"""
lst = ['hello', 'world', 98]
'''创建列表的第二种方式,使用内置函数list()'''
lst2 = list(['hello', 'world', 98])
print()
列表的特点
1.列表元素按顺序有序排序
2.索引映射唯一一个数据
3.列表可以存储重复数据
4.任意数据类型混存
5.根据需要动态分配和回收内存
获取指定元素的索引
lst = ['hello', 'world', 98, 'hello']
print(lst.index('hello')) # 如果列表中有相同元素只返回相同元素的第一个元素的索引
# print(lst.index('Python')) # 'Python' is not in list
# print(lst.index('hello', 1, 3))#'hello' is not in list 在1~2的位置上查找
print(lst.index('hello', 1, 4))
获取列表中的单个元素
正向索引从0到N-1,举例list[0]
逆向索引你从-N到-1,举例lst[-N]
指定索引不存,抛出IndexError
lst = ['hello', 'world', 98, 'hello', 'world', 234]
# 获取索引为2的元素
print(lst[2]) # 98
# 获取索引为-3的元素
print(lst[-3]) # hello
# 获取索引为10的元素
print(lst[10]) # IndexError: list index out of range
列表元素的查询操作
# 判断指定元素在列表中是否存在
print('p' in 'python')
print('k' not in 'python')
lst = [10, 20, 'python', 'hello']
print(10 in lst) # True
print(100 in lst) # False
print(10 not in list) # True
# 遍历
for item in lst:
print(item)
列表元素的增加操作
# append() 向列表的末尾添加一个元素
lst = [10, 20, 30]
print('添加元素之前', lst, id(lst)) # 添加元素之前 [10, 20, 30] 2100054273728
lst.append(100)
print('添加元素之后', lst, id(lst)) # 添加元素之后 [10, 20, 30, 100] 2100054273728
print(list) # <class 'list'>
# extend() 在列表的末尾只收添加一个元素
lst2 = ['hello', 'world']
# st.append(lst2)#将lst2作为一个元素添加到列表的末尾
# print(lst) # [10, 20, 30, 100, ['hello', 'world']]
# 向列表的末尾一次性添加多个元素
lst.extend(lst2)
print(lst)
# 在指定位置上添加一个元素
lst.insert(1, 90)
lst3 = [True, False, 'hello']
# 在任意的位置上添加N多个元素
lst[1:] = lst3;
print(lst)
列表元素的删除操作
lst = [10, 20, 30, 40, 50, 60, 30]
lst.remove(30) # 从列表中溢出一个元素,如果有重复元素只移第一个元素
print(lst)
lst.remove(100) # [10, 20, 40, 50, 60, 30]
lst = [10, 20, 30, 40, 50, 60, 30]
# pop()根据索引移除元素
lst.pop(1)
print(lst)
lst.pop(6)
print(lst) # pop index out of range
lst = [10, 20, 30, 40, 50, 60, 30]
# pop()根据索引移除元素
lst.pop(1)
print(lst)
lst.pop(5)
print(lst) # pop index out of range
lst.pop() # 如果不指定参数(索引),将删除列表中的最后一个元素
print(lst)
lst = [10, 20, 30, 40, 50, 60, 30]
print("------切片操作-删除至少一个元素,将产生一个新的列表对象")
new_list = lst[1:3]
print('原列表', lst)#原列表 [10, 20, 30, 40, 50, 60, 30]
print('切片后的列表', new_list)#切片后的列表 [20, 30]
'''不产生新的列表对象,二回删除原列表中的内容'''
lst = [10, 20, 30, 40, 50, 60, 30]
lst[1:3] = []
print(lst) # [10, 40, 50, 60, 30]
"""清楚列表中的所有元素"""
lst = [10, 20, 30, 40, 50, 60, 30]
lst.clear()
print(lst)
"""del语句将列表对象删除"""
lst = [10, 20, 30, 40, 50, 60, 30]
del lst
print(lst)#name 'lst' is not defined
列表元素的修改操作
lst = [10, 20, 30, 40]
# 一次修改一个值
lst[2] = 100
print(lst) # [10, 20, 100, 40]
lst[1:3] = [300, 400, 500, 600] # [10, 300, 400, 500, 600, 40]
print(lst)
列表元素的排序操作
·常见的两种方式
·调用sort()方法,列有中的所有元素默认按照从小到大的顺序进行排序,可以指定reverse=True,进行降序排序
·调用内置函数sorted(),可以指定reverse=True,进行降序排序,原列表不发生改变
lst = [20, 40, 10, 98, 54]
print('排序前的列表', lst, id(lst)) # 排序前的列表 [20, 40, 10, 98, 54] 3245910544000
# 开始排序,调用列表对象的sort方法,升序排序
lst.sort()
print('排序后的列表', lst, id(lst)) # 排序后的列表 [10, 20, 40, 54, 98] 1433208368896
# 通过指定关键字参数,将列表中的元素进行降序排序
lst.sort(reverse=True) # reverse=True 表示降序排序 reverse=False就是降序排序
print(lst)#[98, 54, 40, 20, 10]
lst.sort(reverse=False)
print(lst)#[10, 20, 40, 54, 98]
# 使用内置函数sorted()对列表进行排序,将产生一个新的列表对象
lst = [20, 40, 10, 98, 54]
print('原列表', lst)
# 开始排序
new_list = sorted(lst)
print(lst)
print(new_list)
# 指定关键字参数,实现列表元素的降序排序
desc_list = sorted(lst, reverse=True)
print(desc_list)
列表生成式
简称生成列表的公式
·语法格式:
[i*i for i in range(1,10)]
lst = [i for i in range(1, 10)]
print(lst) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
lst = [i * i for i in range(1, 10)]
print(lst) # [1, 4, 9, 16, 25, 36, 49, 64, 81]
'''列表元素的值为2,4,6,8,10'''
lst2=[i*2 for i in range(1,6)]
print(lst2)#[2, 4, 6, 8, 10]
字典
自己的感悟
字典嘛,让我想到了老师的棒棒,---->{},
{‘张三’:100}:冒号显得很随意
字典dictionary,dict(name=‘jack’) ,"="像一个字典横着放在那
·字典对应的英语单词是dict---->dict()
什么是字典
·Python内置的数据结构之一,与列表一样时一个可变序列·以键值对的方式存储数据,字典是一个无序的序列
字典的创建
·最常用的方式:使用花括号
scores={‘张三’:100,‘李四’:98}
·使用内置函数dict()
dict(name=‘jack’,age=20)
"""使用{}创建字典"""
scores = {'张三': 100}
print(scores) # {'张三': 100}
print(type(scores)) # <class 'dict'>
'''第二种方式dict()'''
student = dict(name='jack', age=20)
print(student) # {'name': 'jack', 'age': 20}
'''空字典'''
d = {}
print(d) # {}
字典元素的获取
scores = {'张三': 100, '李四': 98, '王五': 45}
'''第一种方式,使用[]'''
print(scores['张三']) # 100
# print(scores['陈六'])#KeyError: '陈六'
'''第二种方式,使用get()方法'''
print(scores.get('张三')) # 100
print(scores.get('陈六')) # None
print(scores.get('马奇', 99)) # 99 99是在查找’马奇‘所对的value不存在时,提供第一个默认值
字典的增删改操作
"""key的判断"""
scores = {'张三': 100, '李四': 98, '王五': 45}
print('张三' in scores) # True
print('张三' not in scores) # False
del scores['张三'] # 删除指定的key-value对
scores.clear() # 清空字典的元素
print(scores) # False
#新增元素
scores = {'张三': 100, '李四': 98, '王五': 45}
scores['陈六'] = 98
print(scores)#{'张三': 100, '李四': 98, '王五': 45, '陈六': 98}
#修改元素
scores = {'张三': 100, '李四': 98, '王五': 45, '陈六': 98}
scores['陈六'] = 100
print(scores)
获取字典视图的三个方法
1、keys()------获取字典中所有key
2、values()------获取字典中所有value
3、items()------获取字典中所有key,values
scores = {'张三': 100, '李四': 98, '王五': 45}
# 获取所有的key
keys = scores.keys()
print(keys) # dict_keys(['张三', '李四', '王五'])
print(type(keys)) # <class 'dict_keys'>
print(list(keys)) # ['张三', '李四', '王五']
# 获取所有的value
values = scores.values()
print(values) # dict_values([100, 98, 45])
print(type(values)) # <class 'dict_values'>
print(list(values)) # [100, 98, 45]
# 获取所有的key-value对
items = scores.items()
print(items) # dict_items([('张三', 100), ('李四', 98), ('王五', 45)])
print(list(items)) # [('张三', 100), ('李四', 98), ('王五', 45)]
# 转换之后的列表元素是由元组组成的
字典元素的遍历
scores = {'张三': 100, '李四': 98, '王五': 45}
# 字典元素的遍历
for item in scores:
print(item, scores[item], scores.get(item))
# 张三 100 100
# 李四 98 98
# 王五 45 45
字典的特点
1、字典中的所有元素都是一个key-value对,key不允许重复,value可以重复
2、字典中的元素是无序的
3、字典中的key必须是不可变对象
4、字典也可以根据需要动态地伸缩
5、字典会浪费较大的内存,是一种使用空间换时间的数据机构
d = {'name': '张三', 'name': '李四'} # key不允许重复
print(d)
d = {'name': '张三', 'nickname': '张三'} # values可以重复的
print(d)
lst = [10, 20, 30]
lst.insert(1, 100)
print(lst) # [10, 100, 20, 30
d = {lst: 100} # unhashable type: 'list'
print(d)
'''不懂,可以再回来看一下'''
字典生成式
items = ['Fruits', 'Books', 'Others']
prices = [96, 78, 85]
d = {item.upper(): price for item, price in zip(items, prices)}
print(d)#{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}
知识点总结
字典的创建
1、使用{}花括号
2、内置函数dict()
3、字典生成式
常用操作
1、获取value
·字典名[key]
·字典名.get(key)
2、删除key-value对
del字典名[key]
3、修改/新增
字典名[key]=value
4、in/not
元组
什么是元组
自己的感悟
·元组很圆 所以用()包住元素,又因为它很圆滑,可以把括号去掉
·元组对应的英语单词是tuple—>tuple(())
·元组
·Python内置的数据结构之一,是一个不可变的序列
·不可变序列与可变序列
·不可变序列与可变序列
·不变序列:字符串、元组
·不可变序列:没有增、删、改的操作
·可变序列:列表、字典
·可变序列:可以对序列执行增、删、改操作,对象地址不发生更改
"""可变序列 列表,字典"""
lst = [10, 20, 45]
print(id(lst)) # 2190449651584
lst.append(300)
print(id(lst)) # 2190449651584
'''不可变序列,字符串,元组'''
s = 'hello'
print(id(s))#3209077469104
s = s + 'world'
print(id(s))#3209077476656
print(s)#helloworld
元组的创建方式
直接小括号
t = (‘Python’,‘hello’,90)
使用内置函数tuple()
t = tuple((‘Python’,‘hello’,90))
只包含一个元组的元素需要使用逗号和小括号
t=(10,)
'''第一种创建方式,使用()'''
t=('Python','world',98)
print(t) # ('Python', 'world', 98)
print(type(t)) # <class 'tuple'>
'''第二种创建方式,使用内置函数tuple()'''
t2 = 'Python', 'world', 98 # 省略了小括号
print(t2) # ('Python', 'world', 98)
print(type(t2)) # <class 'tuple'>
t3 = ('Python',) # 如果元组中只有一个元素,逗号不能省略
print(t3) # ('Python',)
print(type(t3)) # <class 'tuple'>
'''第二种方式,使用内置函数tuple()'''
t1 = tuple(('Python', 'world', 98))
print(t1) # ('Python', 'world', 98)
print(type(t1)) # <class 'tuple'>
'''空元组的创建方式'''
'''空列表的创建方式'''
lst = []
lst1 = list()
d = {}
d2 = dict()
# 空元组
t4 = ()
t5 = tuple()
print('空列表', lst, lst1) # 空列表 [] []
print('空字典', d, d2) # 空字典 {} {}
print('空元组', t4, t5) # 空元组 () ()
为什么要把元组设计成不可变序列
·在多任务环境下,同时操作对象时不需要加锁
·因此,在程序中尽量使用不可变序列
注意事项:
元组中存储的是对象的引用
a)如果元组中对象本身不可对象,则不能再引用其它对象
b)如果元组中的对象是可变对象,则可变对象的引用不允许改变,但数据可以改变
t = [10, [20, 30], 9]
print(t) # (10, [20, 30], 9)
print(type(t)) # <class 'tuple'>
print(type(t[0]), type(t[0]), id(t[0])) # <class 'int'> <class 'int'> 2155089521232
print(type(t[1]), type(t[1]), id(t[1])) # <class 'list'> <class 'list'> 2155091275648
print(type(t[2]), type(t[2]), id(t[2])) # <class 'int'> <class 'int'> 2155089521200
'''尝试将t[1]修改为100'''
print(id(100))
# t[1] = 100 #元组是不允许修改元素的
'''由于[20,30]列表,而列表是可变序列,所以可以向列中添加元素,而列表中的内存地址不变'''
t[1].append(100) # 向列表中添加元素
print(t,id(t[1])) # [10, [20, 30, 100], 9]
元组的遍历
t = ('Python', 'world', 98)
'''第一种获取元组的方式,使用索引'''
print(t[0]) # Python
print(t[1]) # world
print(t[2]) # 98
#print(t[3]) # tuple index out of range
'''遍历元组'''
for item in t:
print(item)
'''
Python
world
98
'''
集合
自己的感悟
集合对应的英语单词是set()
什么是集合
·Python语言提供的内置数据结构
·与列表、字典一样都属于可变类型的序列
·集合是没有value的字典
集合的创建方式
"""第一种创建方式使用{}"""
s = {2, 3, 4, 5, 5, 6, 7, 7} # 集合中的元素不能重复
print(s) # {2, 3, 4, 5, 6, 7}
'''第二种创建方式使用set()'''
s1 = set(range(6))
print(s1, type(s1)) # {0, 1, 2, 3, 4, 5} <class 'set'>
s2 = set([1, 2, 3, 4, 5, 5, 6, 6])
print(s2, type(s2)) # {1, 2, 3, 4, 5, 6} <class 'set'>
s3 = set((1, 2, 4, 4, 5, 65))
print(s3, type(s3)) # {65, 1, 2, 4, 5} <class 'set'>
s4 = set('python')
print(s4, type(s4)) # {'t', 'o', 'n', 'h', 'y', 'p'} <class 'set'>
s5 = set({12, 4, 34, 55, 66, 44})
print(s5, type(s5)) # {34, 66, 4, 55, 12, 44} <class 'set'>
# 定义一个空集合
s6 = {} # dict字典类型
print(type(s6)) # <class 'dict'>
s7 = set()
print(type(s7)) # <class 'set'>
集合的相关操作
·集合元素的判断操作
·in或not in
·集合元素的新增操作
·调用add()方法,一次添中一个元素
·调用update()方法,至少添中一个元素
·集合元素的删除操作
·调用remove()方法,一次删除一个指定元素,如果指定的元素不存在抛出KeyErrot
·调用discard()方法,一次删除一个指定元素,如果指定的元素不存在不抛异常
·调用pop()方法,一次只删除一个任意元素
·调用clear()方法,清空集合
s = {10, 20, 30, 405, 60}
'''集合元素的判断操作'''
print(10 in s) # True
print(100 in s) # False
print(10 not in s) # False
print(100 not in s) # True
'''集合元素的新增操作'''
s.add(80) # add一次添加一个元素
print(s) # {80, 20, 405, 10, 60, 30}
s.update({200, 400, 300}) # 一次至少添加一个元素
print(s) # {200, 10, 300, 80, 400, 20, 405, 60, 30}
s.update([100, 99, 8])
s.update((78, 64, 56))
print(s) # {64, 99, 100, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
'''集合元素的删除操作'''
s.remove(100)
print(s) # {64, 99, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
# s.remove(500)#KeyError: 500
s.discard(500) # {64, 99, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
print(s)
s.pop()
s.pop()
# s.pop(400)#set.pop() takes no arguments (1 given) pop方法不能添加参数
print(s) # {200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}
s.clear()
print(s) # set()
集合间的关系
两个集合是否相等
·可以使用运算符==或!=进行判断
一个集合是否是另一个集合的子集
·可以调用方法issubset进行判断
·B是A的子集
一个集合是否是另一个集合的超集
·可以调用方法issuperset进行判断
·A是B的超集
两个集合是否没有交集
·可以调用方法isdisjojoint进行判断
"""两个集合是否相等(元素相同,就相等)"""
s = {10, 20, 30, 40}
s2 = {30, 40, 20, 10}
print(s == s2) # True
print(s != s2) # False
'''一个集合是否是另一个集合的子集'''
s1 = {10, 20, 30, 40, 50, 60}
s2 = {10, 20, 30, 40}
s3 = {10, 20, 90}
print(s2.issubset(s1)) # True
print(s3.issubset(s1)) # False
'''一个集合是否是另一个集合的超集'''
print(s1.issuperset(s2)) # True
print(s1.issuperset(s3)) # False
'''两个集合是否含有交集'''
print(s2.isdisjoint(s3)) # False #有交集为False
s4 = {100, 200, 300}
print(s2.isdisjoint(s4)) # True 没有交集为True
集合的数据操作
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g8xk58OU-1643201542071)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220120181531029.png)]
# (1)交集
s1 = {10, 20, 30, 40}
s2 = {20, 30, 40, 50, 60}
print(s1.intersection(s2)) # {40, 20, 30}
print(s1 & s2) # {40, 20, 30}#intersection与&等价,交集操作
# (2)并集操作
print(s1.union(s2))
print(s1 | s2) # union与|等价,并集操作
print(s1) # {40, 10, 20, 30}
print(s2) # {50, 20, 40, 60, 30}
# (3)差集操作
print(s1.difference(s2)) # {10}
print(s1 - s2) # {10}
print(s1)
print(s2)
# (4)对称差集
print(s1.symmetric_difference(s2))#{50, 10, 60}
print(s1 ^ s2)#{50, 10, 60}
集合生成式
·用于生成集合的公式
{i*i for i in range(1,10)}
·将{}修改为[]j就是列表生成式
·没有元组生成式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2tWoObUM-1643201542071)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220120221831248.png)]
# 列表生成式
lst = [i * i for i in range(10)]
print(lst) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 集合生成式
s = {i * i for i in range(10)}
print(s) # {0, 1, 64, 4, 36, 9, 16, 49, 81, 25}
列表字典元组集合的比较
创建
列表
1、lst = [‘hello’, ‘world’, 98]
2、lst2 = list([‘hello’, ‘world’, 98])
字典
1、dit = {‘张三’: 100}
2、dit1 = dict(name=‘jack’, age=20)
元组
1、tup=(‘Python’,‘world’,98)
tup2 = (‘Python’,)
tup3 = ‘Python’, ‘world’, 98
2、tup4 = tuple((‘Python’, ‘world’, 98))
集合
1、s = {2, 3, 4, 5, 5, 6, 7, 7}
2、 s1 = set(range(6))
s2 = set([1, 2, 3, 4, 5, 5, 6, 6])
s3 = set((1, 2, 4, 4, 5, 65))
s4 = set({12, 4, 34, 55, 66, 44})
s5 = set(‘python’)# {‘t’, ‘o’, ‘n’, ‘h’, ‘y’, ‘p’}
索引
列表
获取指定元素的索引
lst = [‘hello’, ‘world’, 98, ‘hello’]
1、print(lst.index(‘hello’))
2、print(lst.index(‘hello’, 1, 4))
获取列表中的单个元素
lst = [‘hello’, ‘world’, 98, ‘hello’, ‘world’, 234]
1、print(lst[2]) # 98
print(lst[-3]) # hello
print(lst[10]) # IndexError: list index out of range
字典元素的获取
scores = {‘张三’: 100, ‘李四’: 98, ‘王五’: 45}
‘’‘第一种方式,使用[]’’’
print(scores[‘张三’]) # 100
print(scores[‘陈六’])#KeyError:‘陈六’
‘’‘第二种方式,使用get()方法’’’
print(scores.get(‘张三’)) # 100
print(scores.get(‘陈六’)) # None
print(scores.get(‘马奇’, 99)) # 99 99是在查找’马奇‘所对的value不存在时,提供第一个默认值
字符串
字符串的创建和驻留机制
字符串的驻留机制
·字符串
·在Python中字符串是基本数据类型,是一个不可变的字符序列
注:第一个不可变的序列是元组,第二个不可变的序列是字符串
·什么叫字符串驻留机制呢?
·仅保存一份相同且不可变字符串的方法,不同的值被存放在字符串的驻留池中,Python的驻留机制对相同的字符串只保留一份拷贝,后续创建相同字符串时,不会开辟新空间,而是把该字符串的地址赋给新创建的变量
驻留机制的几种情况(交互模式)
·字符串的长度为0或1时
·符合标识符的字符串
s1=''
s2=''
print(s1 is s2)#True
s1='%'
s2='%'
print(s1 is s2)#True
s1='abc%'
s2='abc%'
print(s1==s2)#True 内容相同
print(s1 is s2)#False 地址不相同
·字符串只在编译时进行驻留,而非运行时
a='abc'
b='ab'+'c'
c=''.join(['ab',c])#join的操作是在程序运行的时候,程序在运行的时候当然会开辟一个新的空间
print(a is b)#True
print(a is c)#False
print(c)#abc
·[-5,256]之间的整数数字
a=-5
b=-5
print(a is b)#True
a=-6
b=-6
print(a is b)#False
sys中的intern方法强制2个字符串指向同一个对象
import sys
a='abc%'
b='abc%'
print(a is b)#False
a=sys.intern(b)
print(a is b)#True
PyCharm对字符串进行优化处理
就是之前为值false的结果在PyCharm编译器中是驻留的,是True的
字符串驻留机制的优缺点
·当需要值相同的字符串时,可以直接从字符串池里拿来使用,避免频繁的创建和销毁,替身效率和节约内存,因此拼接字符串和修改字符串是会比较影响性能的。
·在需要进行字符串拼接时建议使用str类型的join方法,而非+,因为join()方法是先计算出所有字符中的长度,然后再拷贝,只new一次对象,效率要比"+"效率高
字符串的常用操作
字符串的查询操作的方法
查询方法
·index() 查找子串substr第一次出现的位置,如果查找的子串不存在时,则抛出ValueError
·rindex()查找子串substr最后一次出现的位置,如果查找的子串不存在时,则抛出ValueError
·find()查找子串substr第一次出现的位置,如果查找的子串不存在时,则返回-1
·rfind()查找子串substr最后一次出现的位置,如果查找的子串不存在时,则返回-1
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3K7jdltf-1643201542072)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220121115056706.png)]
# 字符串的查询操作
s = 'hello,hello'
print(s.index('lo')) # 3
print(s.find('lo')) # 3
print(s.rindex('lo')) # 9
print(s.rfind('lo')) # 9
# print(s.index('k'))# ValueError: substring not found
print(s.find('k')) # -1
# print(s.rindex('k'))#ValueError: substring not found
print(s.rfind('k')) # -1
字符串的大小写转换操作的方法
upper()
把字符串中所有字符都转成大写字母
lower()
把字符串中所有字符都转成小写字母
swapcase()
把字符串中所有大写字母转成小写字母,把所有小写字母都转成大写字母
capitalize()
把第一个字符转换成大写,把其余字符转换成小写
# 字符串中的大小写转换的方法
s = 'hello,python'
a = s.upper() # 转成大写之后,会产生一个新的字符串对象
print(s) # HELLO,PYTHON
print(a, id(a)) # HELLO,PYTHON 2190073744368
print(s, id(s)) # HELLO,PYTHON 1561669349040
print(s.lower()) # hello,python
print(s.lower(), id(s.lower())) # hello,python 2207706857648
print(s, id(s)) # hello,python 2207706853296
s2 = 'hello,Python'
print(s2.swapcase()) # HELLO,pPYTHON
print(s2.title()) # Hello,Python
字符串内容对齐的方法
方法名称
center()
居中对齐,第一个参数指定宽度,第二个仓鼠指定填充符,第二个参数是可选的,默认是空格,如果设置款难度小于实际宽度则返回字符串
ljust()
左对齐,第1个参数指定宽度,第2个参数指定填充符,第二个参数是可选的,默认是空格如果设置宽度小于实际宽度则返回原字符串
rjust()
右对齐,第1个参数指定宽度,第2个参数指定填充符,第2个参数是可选的,默认是空格如果设置宽度小于实际宽度则返回原字符串、
zfill()
右对齐,左边用0填充,该方法只接收一个参数,用于指定字符串的宽度,如果指定的款难度小于等于字符串的长度,返回字符串本身
s = 'hello,Python'
'''居中对齐'''
print(s.center(20, '*')) # ****hello,Python****
'''左对齐'''
print(s.ljust(20, '*')) # hello,Python********
print(s.ljust(10, )) # hello,Python
print(s.ljust(20)) # hello,Python 默认填充格式空格
'''右对齐'''
print(s.rjust(20, '*')) # ********hello,Python
print(s.rjust(20)) # hello,Python
print(s.rjust(10)) # hello,Python
'''右对齐,使用0进行填充'''
print(s.zfill(20))#00000000hello,Python
print(s.zfill(10))#hello,Python
print('-8910'.zfill(8))#-0008910
字符串的劈分
split()
从字符串的左边开始劈分,默认的劈分字符是空格字符串,返回的值都是一个列表
s='hello world Python'
lst=s.split()
print(lst)#['hello', 'world', 'Python']
以通过参数sep指定劈分字符串是劈分符
通过参数maxsplit指定劈分字符串时的最大劈分次数,在经过最大劈分之后,剩余的子串会单独做成一部分
s1='hello|world|Python'
print(s1.split(sep='|'))#['hello', 'world', 'Python']
print(s1.split(sep='|',maxsplit=1))#['hello', 'world|Python']
rsplit()
从字符串的右边开始劈分,默认的劈分字符是空格字符串,返回的值都是一个列表
以通过参数sep指定劈分字符串是劈分符
通过参数maxsplit指定劈分字符串时的最大劈分次数,在经过最大次劈分之后,剩余的子串单独会做成一部分
s1 = 'hello|world|Python'
print(s1.split(sep='|')) # ['hello', 'world', 'Python']
print(s1.split(sep='|', maxsplit=1)) # ['hello', 'world|Python']
s = 'hello world Python'
print(s.rsplit()) # ['hello', 'world', 'Python']
print(s.rsplit('|')) # ['hello world Python']
print(s1.rsplit(sep='|', maxsplit=1)) # ['hello|world', 'Python']
字符串判断的相关方法
isidentifier()
判断指定的字符串是不是合法的标识符
isspace()
判断指定的字符串是否全部由空白字符组成(回车,换行,水平制表符)
isalpha()
判断指定的字符串是否全部由字母组成
isdecimal()
判断指定字符串是否全部由字母组成
isnumeric()
判断指定的字符串是否全部由数字组成
isalnum()
判断指定字符串是否全部由字母和数字组成
字符串操作的其他方法
字符串替换
replace()
第1个参数指定被替换的子串,第2个参数指定替换子串的字符串,该方法返回替换后得到的字符串,替换前的字符串不发生变化,调用该方法时可以通过第3个参数指定最大替换次数
字符串的合并
join()
将列表或元组中的字符串合并成一个字符串
s = 'hello,Python'
print(s.replace('Python', 'Java')) # hello,Java
s1 = 'hello,Python,Python,Python'
print(s1.replace('Python', 'Java', 2)) # hello,Java,Java,Python
lst = ['hello', 'java', 'Python']
print('|'.join(lst)) # hello|java|Python
print(''.join(lst)) # hellojavaPython
t = ('hello', 'Java', 'Python')
print(''.join(t)) # helloJavaPython
t = ('hello', 'Java', 'Python')
print(''.join(t)) # helloJavaPython
print('*'.join('Python')) # P*y*t*h*o*n
字符串的比较操作
运算符:>,>=,<,<=,==,!=
**比较规则:**首先比较两个字符串中的第一个字符,如果相等则继续比较下一个字符,一次比较下去,指导两个字符串中的字符不相等时,其比较结果就是两个字符串的比较结果,两个字符串中的所有后续字符将不再被比较
**比较原理:**两个以上字符进行比较时,比较的是其ordinal value(原始值),调用内置函数ord可以得到指定字符的ordinal value。与内置函数ord对应的是内置函数chr,调用内置函数chr时指定ordinal value可以得到其对应的字符
a = b = 'Python'
c = 'Python'
print(a == b) # True
print(b == c) # True
print(a is b) # True
print(a is c) # True
print(id(a)) # 2592489649456
print(id(b)) # 2592489649456
print(id(c)) # 2592489649456
字符串的切片操作
print(s1) # hello
print(s2) # Python
print(newstr) # hello!Python
print(s1) # hello
print(s2) # Python
print(newstr) # hello!Python
print("-----------")
print(id(s)) # 2474006161840
print(id(s1)) # 2474010624176
print(id(s2)) # 2474010824176
print(id(s3)) # 2474010624048
print(id(newstr)) # 2474010639536
print("--------------切片[start:end:step]-----------------")
print(s[1:5:1]) # 从1开始截到5(不包含5),步长为1 ello
print(s[::2]) # 默认从0开始,没有写结束,默认字符串的最后一个元素,步长为2,两个元素之间的索引间隔为2 hloPto
print(s[::-1]) # 默认从字符串的最后一个元素开始,到字符串的第一个元素结束,因为步长为负数 nohtyP,olleh
print(s[-6::1]) # 从索引为-6开始,到字符串的最后一个元素结束,步长为1 Python
格式化字符串
# (1)%占位符
name = '张三'
age = 20
print('我叫%s,今年%d岁' % (name, age)) # 我叫张三,今年20岁
# (2){}
print("我叫{0},今年{1}岁".format(name, age)) # 我叫张三,今年20岁
# {3}f-string
print(f'我叫{name},今年{age}岁') # 我叫张三,今年20岁
print('%10d' % 99)#10表示的是宽度
print('%.3f' % 3.1415926)#.3表示是小数点后三位
#同时表示宽度和精度
print('%10.3f' % 3.1415926)#一共总宽度为10,小数点后3位
print('%10d' % 99) # 99 10表示的是宽度
print('%.3f' % 3.1415926)#3.142
#同时表示宽度和精度
print('%10.3f' % 3.1415926)# 3.142 一共总宽度为10,小数点后3位
print('hellohello') # hellohello
print('hellohello')
print('{0:.3f}'.format(3.1415926))#.3表示的是一共是3位数
print('{0:.3f}'.format(3.1415926))#.3f表示是3位小数
print('{:10.3f}'.format(3.1415926))#同时设置宽度和精度
字符串的编码与解码
s = '天涯共此时'
# 编码
print(s.encode(encoding='GBK')) # 在GBK这种编码格中 一个中文占两个字节
print(s.encode(encoding='UTF-8')) # 在UTF-8这种编码格式中,一个中文占三个字节
# 解码
# byte代表的就是一个二进制数据(字节类型的数据)
byte = s.encode(encoding='GBK') # 编码
print(byte.decode(encoding='GBK')) # 解码
byte = s.encode(encoding='UTF-8')
print(byte.decode(encoding='UTF-8'))
函数
函数调用的参数传递 _ 位置实参 _ 关键字实参
# 位置实参
# 根据形参对应的位置进行实参传递
def calc(a, b):
c = a + b
return c
result = calc(10, 20)
print(result)
# 关键字实参
# 根据形参名称进行实参传递
res = calc(b=10, a=20) # 等号左侧的变量的名称成为关键字参数
print(res)
函数的返回值
print(bool(0)) # False
print(bool(8)) # 非0的布尔值为True
def fun(num):
odd = [] # 存奇数
even = [] # 存偶数
for i in num:
if i % 2:
odd.append(i)
else:
even.append(i)
return odd,even
# 函数的调用
lst = [10, 29, 34, 23, 44, 53, 55]
print(fun(lst))
'''函数的返回值
(1)如果函数没有返回值【函数执行完毕之后,不需要给调用处提供数据】return可以省略不写
(2)函数的返回值,如果是1个,直接返回类型
(3)函数的返回值,如果是多个,返回的结果为元组
'''
def fun1():
print('hello')
# return脱了裤子放屁
fun1()
def fun2():
return 'hello'
res = fun2()
print(res)
def fun3():
return 'hello', 'world'
print(fun3())
'''False
True
([29, 23, 53, 55], [10, 34, 44])
hello
hello
('hello', 'world')
'''
函数参数定义_默认值参数
def fun(a, b=10):
print(a, b)
# 函数的调用
fun(100) # 100 10
fun(20, 30) # 20 30
print('hello',end='\t')
print('world')#hello world
函数的参数定义
个数可变的位置参数
定义函数,可能无法事先确定传递的位置实参的个数时,使用可变的位置参数
使用*定义个数可变的位置形参
结果为一个元组
个数可变的关键字形参
定义函数时,无法实现确定传递的关键字实参的个数时,使用可变的关键字形参
使用**定义个数可变的关键字形参
结果为一个字典
函数参数定义 _ 个数可变的位置形参 _ 个数可变的关键字形参
def fun(*args): # 函数定义时的可变的位置参数
# 为什么可变,因为传多少都可以
print(args)
print(args[0])
fun(10)
fun(10, 30)
fun(30, 405, 50)
def fun1(**args):
print(args)
fun1(a=10)
fun1(a=20, b=30, c=40)
print('hello', 'world', 'java')
'''def fun2(*args,*a):
pass
以上代码,程序会报错,个数可变的位置参数,只能是1个
def fun2(**args,**args):
pass
以上代码,程序会报错,个数可变的位置参数,只能是1个
'''
def fun2(*args1, **args2):
pass
'''def fun2(**args,**args):
pass
在一个函数的定义过程中,既有个数可变的关键字,也有个数可变的位置形参,要求,个数可变的位置形参,放在个数可变的关键字形参之前
'''
函数的参数总结
def fun(a, b, c): # a,b,c在函数的定义处,所以是形式参数
print('a=', a)
print('b=', b)
print('c=', c)
# 函数的调用
fun(10, 20, 30) # 函数调用时的参数传递,称为位置传参
lst = [11, 22, 33]
fun(*lst)
print('----------------')
fun(a=100, c=300, b=200) # 函数的调用,所以是关键字实参
dic = {'a': 111, 'b': 222, 'c': 333}
fun(**dic) # 在函数调用时,将字典中的键值对都转换为关键字实参传入
'''
a= 10
b= 20
c= 30
a= 11
b= 22
c= 33
----------------
a= 100
b= 200
c= 300
a= 111
b= 222
c= 333
'''
def fun(a, b=10): # b是在函数的定义处,所以b是形参,而且进行了赋值,所以b称为默认值形参
print('a=', a)
print('b=', b)
def fun2(*args): # 个数可变的位置形参
print(args)
def fun3(**args2): # 个数可变的关键字形参
print(args2)
fun2(10, 20, 30, 40) # (10, 20, 30, 40)
fun3(a=11, b=22, c=33, d=44, e=55)
def fun4(a, b, *, c, d): # 从*之后的参数,在函数调用时,只能采用关键字参数传递
print('a=', a)
print('b=', b)
print('c=', c)
print('d=', d)
# 调用fun4函数
fun4(10, 20, 30, 40) # 位置实参传递
fun4(a=10, b=20, c=30, d=40) # 关键字实参传递
fun4(10, 20, c=30, d=40) # 前两个参数,采用的是位置实参传递,而c,d采用的是关键字实参传递
'''需求, c,d只能采用关键字实参传递'''
'''函数定义时的形参的顺序问题'''
def fun5(a, b, *, c, d, **args):
pass
def fun6(*args, **args2):
pass
def fun7(a, b=10, *args, **args2):
pass
变量的作用域
变量的作用域
def fun(a, b):
c = a + b # c,就是全局变量,因为c在函数体内进行定义的变量,a,b为函数的形参,作用范围也是函数内部,相当于局部变量
print(c)
# print(c),因为a、c超出了起作用的范围(超出了作用域)
# print(a)
name = '杨老师'#name的作用范围为函数内部和外部都可以使用-->成为全局变量
print(name)
def fun2():
print(name)
#调用函数
fun2()
def fun3():
global age #函数内部定义的变量,局部变量,局部变量使用global声明,这个变量实际上就变成了全局变量
age=20
print(age)
fun3()
print(age)
# 调用函数
fun2()
'''杨老师
杨老师
20
20
杨老师
'''
递归函数
什么是递归函数
如果在一个函数体内调用了该函数本身,这个函数就称为递归函数
递归的组成部分
递归调用与递归终止条件
递归的调用过程
每递归调用一次函数,都会在栈内存分配一个栈帧
每执行完一次函数,都会释放相应的空间
递归的优缺点
缺点:占用内存多,效率低下
优点:思路和代码简单
def fac(n):
if n == 1:
return 1
else:
res = n * fac(n - 1)
return res
print(fac(6))#720
斐波那契数列
def fib(n):
if n == 1:
return 1
elif n == 2:
return 1
else:
return fib(n - 1) * fib(n - 2)
# 斐波那契数列第六位上的数字
print(fib(6))
# 输出这个数列的前6位上的数字
for i in range(1, 7):
print(fib(i))
'''def fib(n):
if n == 1:
return 1
elif n == 2:
return 1
else:
return fib(n - 1) * fib(n - 2)
# 斐波那契数列第六位上的数字
print(fib(6))
# 输出这个数列的前6位上的数字
for i in range(1, 7):
print(fib(i))'''
Bug
Bug的常见类型
age = input('请输入你的年龄')
print(type(age))
if int(age) >= 18:
print('成年人...')
1、漏了末尾的冒号,如if语句,循环语句,else子句等
2、缩进错误,该缩进的没缩进,不该缩进的瞎缩进
3、把英文符号写成中文符号,比如说:引号,冒号,括号
4、字符串拼接的时候,把字符串和数字拼在一起
5、没有定义变量,比如说while的循环条件的变量
6、“==”比较运算符合“=”赋值运算符的混用
知识不熟练导致的错误
(1)索引越界问题IndexError
lst=[11,22,33,44]
print(lst[4])
lst = [11, 22, 33, 44]
print(lst[3])
(2)append()方法的使用掌握不熟练
lst=[]
lst=append(‘A’,‘B’,‘C’)
print(lst)
lst=[]
lst.append('A')
lst.append('B')
lst.append('C')
print(lst)#['A', 'B', 'C']
思路不清晰导致
lst = [{'rating': [9.7], 'id': '1292052', 'type': ['犯罪'], 'title': '肖申克的救赎',
'actors': ['蒂姆', '摩根']},
{'rating': [9.6], 'id': '1291546', 'type': ['剧情'], 'title': '霸王别姬',
'actors': ['张国荣', '张丰毅']},
{'rating': [9.5], 'id': '1292720', 'type': ['剧情'], 'title': '阿甘正传',
'actors': ['汤姆', '罗宾']}]
name = input('请输入您要查询的演员:')
for item in lst: # 遍历列表 -->{} item是一个又一个的字典
act_lst = item['actors']
for actor in act_lst: # 遍历字典,得到movie是一个字典中的key
if name in actor:
print(name, '出演了', item['title'])
'''actors = movie['actors']
if name in actors:
print(name + '出演了:' + movie)
'''
被动掉坑
被动掉坑:程序代码逻辑没有错,知识因为用户错误操作或者一些“例外情况”而导致的程序崩溃
**题目要求:**输入两个整数并进行除法运算
try:
a = int(input('请输入第一个整数'))
b = int(input('请输入第二个整数'))
result = a / b
print('结果为:', result)
except ZeroDivisionError:
print('对不起,除数不允许为0')
except ValueError:
print('只能输入数字串')
print('程序结束')
try-except-else结构
try:
a = int(input('请输入第一个整数'))
b = int(input('请输入第二个整数'))
result = a / b
except BaseException as e:
print('出错了', e)
else:
print("计算结果为:",result)
try: a = int(input('请输入第一个整数'))
b = int(input('请输入第二个整数'))
result = a / bexcept BaseException as e:
print('出错了', e)
else: print("计算结果为:",result)
finally: print('谢谢您的使用')python
Python中常见的异常类型
ZeroDivisionError除零
IndexError序列中没有此索引
KeyError映射中没有这个键
NameError未声明/初始化对象(没有属性)
SyntaxErrorPython语法错误
ValueError传入无效的参数
# print(10/0)#ZeroDivisionError
lst = [11, 22, 33, 44]
#print(lst[4]) # IndexError
#print(num)#NameError
#int a=20#SyntaxError
a=int('hello')#ValueError
traceback模块的使用
import traceback
try:
print('-------------------------')
print(1 / 0)
except:
traceback.print_exc()
面向对象
类
class Student: # Student为类的名称(类名)由一个或多个单词组成,每个单词的首字母大写,其余小写
native_pace = '吉林' # 直接写在类里的变量,称为类属性
def __init__(self, name, age):
self.name = name # self.name成为实体属性,进行了一个赋值的操作,将局部变量的name的值赋给实体属性
self.age = age
# 实例方法
def eat(self):
print('学生在吃饭。。。')
# 静态方法
@staticmethod
def method():
print('我使用了staticmethod进行修饰,所以我是静态方法')
# 类方法
def cm(cls):
print('我是类方法,因为我使用了classmethod进行修饰')
# 在类之外定义的成为函数,在类之内定义的成为方法
def drink():
print('喝水')
类属性、类方法、静态方法的使用
**类属性:**类中方法外的变量成为类属性,被该类的所有对象多共享
类方法:使用@classmethod修饰的方法,使用类名直接访问的方法
静态方法:使用@staticmethod修饰的主法,使用类名直接访问的方法
class Student: # Student为类的名称(类名)由一个或多个单词组成,每个单词的首字母大写,其余小写
native_pace = '吉林' # 直接写在类里的变量,称为类属性
def __init__(self, name, age):
self.name = name # self.name成为实体属性,进行了一个赋值的操作,将局部变量的name的值赋给实体属性
self.age = age
# 实例方法
def eat(self):
print('学生在吃饭。。。')
# 静态方法
@staticmethod
def method():
print('我使用了staticmethod进行修饰,所以我是静态方法')
# 类方法
def cm(cls):
print('我是类方法,因为我使用了classmethod进行修饰')
# 在类之外定义的成为函数,在类之内定义的成为方法
def drink():
print('喝水')
# 类属性的使用方式
print(Student.native_pace)
stu1 = Student('张三', 20)
stu2 = Student('李四', 30)
print(stu1.native_pace)
print(stu2.native_pace)
Student.native_pace = '天津'
print(stu1.native_pace)
print(stu2.native_pace)
Student.cm()
print('----------------静态方法的使用方式---------------')
Student.method()
动态绑定属性和方法
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self):
print(self.name + '在吃饭')
#动态绑定属性
stu1 = Student('张三', 20)
stu2 = Student('李四', 30)
print(id(stu1))
print(id(stu2))
stu2.gender = '女' # 只为stu2动态绑定了性别
print(stu1.name, stu1.age)
print(stu2.name, stu2.age, stu2.gender)
stu1.eat()
stu2.eat()
#动态绑定方法
def show():
print('定义在类之外的,称函数')
stu1.show=show
stu1.show()
#stu2.show()
'''1997157314512
1997157313120
张三 20
李四 30 女
张三在吃饭
李四在吃饭
定义在类之外的,称函数
'''
面向对象的三大特征_封装的实现方式
class Student:
def __init__(self, name, age):
self.name = name
self.__age = age # 年龄不希望在类的外部被使用,所以加了两个
def show(self):
print(self.name, self.__age)
stu=Student('张三', 20)
stu.show()
#在类的外面使用name与age时
print(stu.name)
#print(stu.__age)
print(dir(stu))
print(stu._Student__age)#在类的外部可以通过 _Student__age 进行访问
继承及其实现方式
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def info(self):
print(self.name, self.age)
class Student(Person):
def __init__(self, name, age, stu_no):
super().__init__(name, age)
self.stu_no = stu_no
class Teacher(Person):
def __init__(self, name, age, teacheryear):
super().__init__(name, age)
self.teacheryear = teacheryear
stu = Student('张三', 20, '1001')
teacher = Teacher('李四', 34, 10)
stu.info()
teacher.info()
'''
张三 20
李四 34'''
# 多继承
class A(object):
pass
class B(object):
pass
class C(A, B):
pass
方法重写
方法重写
·如果子类对继承自父类的某个属性或方法不满意,可以在子类中对其(方法体)进行重新编写
·子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法
Object类
·object类是所有类的父类,因此所有类都有object类的属性和方法。
·内置函数dir()可以查看指定对象所有属性
·Object有一个__str__()方法,用于返回一个’对象的描述’,对应与内置函数str()经常用于print()方法,帮我们查看对象的信息,所以我们经常会对__str__()进行重写
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
return '我的名字是{0},今年{1}岁'.format(self.name, self.age)
stu = Student('张三', 20)
print(dir(stu))
print(stu) # 默认调用__str__()这样的方法
print(type(stu))
'''['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name']
我的名字是张三,今年20岁
<class '__main__.Student'>'''
多态的实现
多态就是"具有多种形态",它指的是:几遍不知道一个变量所引用的对象到底是什么类型,任然可以通过这个变量调用方法,在运行过程中根据变量所引用对象的类型,动态决定调用哪个对象中的方法
静态语言和动态语言关于多态的区别
·静态语言实现多态的三个必要条件
·继承
·方法重写
·父类引用指向子类对象
·动态语言的多态崇尚“鸭子类型”当看到一只鸟走起来想鸭子、游泳起来像鸭字、收起来也想鸭子,name这只鸟就可以被称为鸭子。在鸭子类型中,不需要关心对象是什么类型,到底是不是鸭子,只关心对象的行为
特殊属性
class A:
pass
class B:
pass
class C(A, B):
def __init__(self, name, age):
self.name = name
self.age = age
# 创建C类的对象
x = C('Jack', 20) # x是C类型的一个实例对象
print(x.__dict__) #实例对象的属性字典
print(C.__dict__)
print(x.__class__)#输出了对象所属的类
print(C.__bases__)#C类的父类类型的元素
print(C.__base__)
print(A.__subclasses__())
'''
{'name': 'Jack', 'age': 20}
{'__module__': '__main__', '__init__': <function C.__init__ at 0x0000024C5F89DB80>, '__doc__': None}
<class '__main__.C'>
(<class '__main__.A'>, <class '__main__.B'>)
<class '__main__.A'>
'''
特殊方法
a = 20
b = 100
c = a + b # 两个帧数类型的对象的相加操作
d = a.__add__(b)
print(c)
print(d)
class Student:
def __init__(self, name):
self.name = name
def __add__(self, other):
return self.name + other.name
def __len__(self):
return len(self.name)
stu1 = Student('张三')
stu2 = Student('李四')
s = stu1 + stu2 # 实现了两个对象的加法运算(因为在Student类中,编写__add__()特殊的方法)
print(s)
s = stu1.__add__(stu2)
print(s)
lst = [11, 22, 33, 44]
print(len(lst)) # len是内置函数len,可以计算列表的长度
print(lst.__len__())
print(len(stu1))
'''特殊属性
__dict__
获得类对象或实例对象所绑定的所有属性和方法的字典
特殊方法
__len__()
通过重写__len__()方法,让内置函数len()的参数可以自定义类型
__add__()
通过重写__add__()方法,可使用自定义对象具有“+”功能
__new__()
用于创建对象
__init__()
对创建的对象进行初始化
'''
__new__与__init__演示创建对象的过程
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hh76Ig51-1643201542078)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220124114008841.png)]
class Person(object):
def __new__(cls, *args, **kwargs):
print('__new__被调用执行了cls的id值为{0}'.format(id(cls)))
obj = super().__new__(cls)
print('创建的对象的id为:{0}'.format(id(obj)))
return obj
def __init__(self, name, age):
print('__init__被调用了,self的id值为:{0}', format(id(self)))
self.name = name
self.age = age
print('object这个类对象的id为:{0}'.format(id(object)))
print('Person这个类对象的id为:{0}'.format(id(Person)))
# 创建Person类的实例对象
p1 = Person('张三', 20)
print('p1这个Person类的实例对象的id:{0}'.format(id(p1)))
类的赋值与浅拷贝
变量的赋值操作
只是形成两个变量,实际上还是只想同一个对象
浅拷贝
Python拷贝一般都是浅拷贝,拷贝时,对象包含的子对象内容不拷贝,因此,源对象与拷贝对象会引用同一个子对象
深拷贝
使用copy模块的deepcopy函数,递归拷贝对象中包含的子对象,源对象和拷贝对象所有的子对象也不相同
class CPU:
pass
class Disk:
pass
class Computer:
def __init__(self, cpu, disk):
self.cpu = cpu
self.disk = disk
# (1)变量的赋值
cpu1 = CPU()
cpu2 = cpu1
print(cpu1)
print(cpu2)
# (2)类有浅拷贝
print('------------------------------')
disk = Disk() # 创建一个硬盘类对象
computer = Computer(cpu1, disk) # 创建一个计算机类的对象
# 浅拷贝
import copy
print(disk)
computer2 = copy.copy(computer)
print(computer, computer.cpu, computer.disk)
print(computer2, computer2.cpu, computer2.disk)
# 深拷贝
computer3 = copy.deepcopy(computer)
print(computer, computer.cpu, computer.disk)
print(computer3, computer3.cpu, computer3.disk)
<__main__.CPU object at 0x0000023E0FC21FD0>
<__main__.CPU object at 0x0000023E0FC21FD0>
------------------------------
<__main__.Computer object at 0x0000023E0FC21F70> <__main__.CPU object at 0x0000023E0FC21FD0> <__main__.Disk object at 0x0000023E0FC21FA0>
<__main__.Computer object at 0x0000023E0FC21190> <__main__.CPU object at 0x0000023E0FC21FD0> <__main__.Disk object at 0x0000023E0FC21FA0>
模块
创建模块
新建一个.py文件,名称尽量不要与Python自带的标准模块名称相同
导入模块
import 模块名称 [as 别名]
from 模块名称 import 函数/变量/类
import math # 关于数学运算
print(id(math))
print(type(math))
print(math)
print(math.pi)
print('----------------------')
print(dir(math))
print(math.pow(2, 3), type(math.pow(2, 3)))
print(math.ceil(9.001))
print(math.floor(9.999))
'''
2855299925232
<class 'module'>
<module 'math' (built-in)>
3.141592653589793
----------------------
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
8.0 <class 'float'>
10
9'''
from math import pi
print(pi)
print(pow(2, 3))
# print(math.pow(2,8))
模块的导入
def add(a, b):
return a + b
def div(a, b):
return a / b
# 这个模块的名称是calc
import calc
print(calc.add(10,20))
print(calc.div(10,4))
from calc import add
print(add(10,20))
以主程序方式运行124
def add(a, b):
return a + b
if __name__ == '__main__':
print(add(10, 20)) # 只有当点击运行calc2时,才会执行运算
Python中的包
sys 与Python解释其及其环境操作相关的标准库
time提供与时间相关的各种函数的标准库
os提供了访问操作系统服务功能的标准库
calendar提供与日期相关的各种函数的标准库
urllib用于读取来自网上(服务器)的数据标准库
json用于使用Json序列化和反序列化对象
re用于在字符串中执行正则表达式匹配和替换
math提供标准算数运算函数的标准库
decimal用于进行精准控制运算精度、有效数位和四舍五入操作的十进制运算
logging提供了灵活的记录时间、错误、警告和调试信息的功能
import sys
import time
import urllib.request
print(sys.getsizeof(24))#28
print(sys.getsizeof(45))#28
print(sys.getsizeof(True))#28
print(sys.getsizeof(False))#24
print(time.time())#1643016733.717006
print(time.localtime(time.time()))#time.struct_time(tm_year=2022, tm_mon=1, tm_mday=24, tm_hour=17, tm_min=32, tm_sec=13, tm_wday=0, tm_yday=24, tm_isdst=0)
print(urllib.request.urlopen('http://www.baidu.com').read())
第三方模块的安装126
文件
编码格式的介绍
常见的字符编码格式
Python的解释器使用的是Unicode(内存)
py文件在磁盘上使用UTF-8存储(外存)
文件读写的原理_读取磁盘文件中的内容
·文件的读写俗称“IO操作”
·文件读写操作流程
·操作原理
file = open('a.txt', 'r')
print(file.readlines())
file.close()
常用的文件打开模式131
文件类型
按文件中数据的组织形式,文件分为以下两大类
**文本文件:**存储的是普通"字符"文本,默认为uincode字符集,可以使用记本事程序打开
**二进制文件:**把数据内容用“字节”进行存储,无法用记事本打开,必须使用专用的软件打开,举例:mp3音频文件,jpg图片,.doc文档等
r以值读模式打开文件,文件的指针将会放在文件的开头
w以只写模式打开文件,如果文件不存在则创建,如果文件存在,则覆盖原有内容,文件指针在文件的开头
a以追加模式打开文件,如果我呢间不存在则创建,文件指针在文件开头,如果文件存在,则在文件末尾住家内容,文件指针在源文件末尾
b以二进制方式打开文件,不能单独使用,需要与供他模式一起视同,rb,或者wb
**+**以读写方式打开文件,不能单独使用,需要与其它模式一起使用,a+
#w
file = open('b.txt', 'w')
file.write('Python')
file.close()
#b
src_file = open('b.txt', 'r')
target_file = open('copylogo.png', 'wb')
print(target_file.write(src_file.read()))
target_file.close()
src_file.close()
**read([size])**从文件中读取size个字节或字符的内容返回。若省略[size],则读取到文件末尾,即一次读取文件所有内容
**readline()**从文本文件中读取一行内容
**readlines()**把文本文件中每一行都作为独立的字符串对象,并将这些对象放入列表返回
**write(str)**将字符串str内容写入文件
**writelines(s_list)**将字符串str内容写入文件
**writelines(s_list)**将字符串列表s_list写入文本文件,不添加换行符
seek把文件指针移动到新的位置,offset表示相对于whence的位置:offset:为正往结束方向移动,为负往开始方向移动 whence不同的值代表不同含义
0:从文件头开始计算默认值(默认值)
1:从当前位置开始计算
2:从文件末开始计算
**tell()**返回文件指针的当前位置
**flush()**把缓冲区的内容写入文件,但不关闭文件
**close()**把缓冲区的内容写入文件,同时关闭文件,释放对象相关资源
file = open('c.txt', 'a')
lst = ['java', 'go', 'python']
file.writelines(lst)
file.close()
#javagopython
file = open('a.txt', 'r')
file.seek(2)
print(file.read())
print(file.tell())
file.close()
with语句(上下文管理器)
·with语句可以自动管理上下文资源,不论什么原因跳出with都能确保文件正确的关闭,以此来大道释放资源的目的
class MyContentMgr(object):
def __enter__(self):
print('enter方法被调用执行了')
return self
def __exit__(self, exc_type, exc_val, exc_tb):
print("exit方法被调用执行了")
def show(self):
print('show()方法被调用执行了')
with MyContentMgr() as file:
file.show()
#另一个文件
with open('a.txt', 'r') as file:
print(file.read())
'''改进
with open('logo.png','rb') as src_file:
with open('copy2logo.png','wb') as target_file:
target_file.write(src_file.read())
'''
os模块的常用函数
import os
os.system('notepad.exe')
os.system('calc.exe')
#直接调用
os.startfile('C:\\Program Files (x86)\\Tencent\\TIM\\Bin\\tim.exe')
os模块是Python内置的与操作系统功能和文件系统相关的模块,该模块中的语句的执行结果通常与操作系统有关,在不同的操作系统上运行,得到的结果可能不一样。
os模块与os.path模块用于对目录或文件进行操作
import os
os.system('notepad.exe')
os.system('calc.exe')
#直接调用
os.startfile('C:\\Program Files (x86)\\Tencent\\TIM\\Bin\\tim.exe')
import os
print(os.getcwd())
**getcwd()**返回当前的工作目录
**listdir(path)**返回指定路径下的文件和目录信息
**mkdir(path[,mode])**创建目录
**makedirs(path1/path2)**创建多级目录
**rmdir(path)**删除目录
**removedirs(path1/path2)**删除多级目录
**chdir(path)**将path设置为当前工作目录
import os
print(os.getcwd())
lst = os.listdir('../chap15')
print(lst)
os.mkdir('newdir2')
#os.makedirs('A/B/C/')
os.rmdir('newdir2')
os.removedirs('A/B/C')
os.path模块的常用方法
path模块操作目录相关函数
**abspath(path)**用于获取文件或目录的绝对路径
**exists(path)**用于判断文件或目录是否存在,如果存在返回True,否则返回False
**join(path,name)**将目录与目录或者文件名拼接起来
**splitext()**将目录与目录或者文件名拼接起来
**basename(path)**从一个目录中提取文件名
**dirname(path)**从一个路径中提取文件路径,不包括文件名
**isdir(path)**用于判断是否为路径
import os.path
print(os.path.abspath('demo10.py'))
print(os.path.exists('demo13py'), os.path.exists('demo10.py'))
剩下的听不懂
实操案例
实操案例一
任务1:向文件输出’奋斗成就更好的你’
"""一、使用print方式进行输出(输出的目的地是文件)"""
fp = open('C:/李林峰/text.txt', 'w')#open是打开创建文件的意思
print('奋斗成就更好的未来',file=fp)
fp.close()
'''二、使用文件的读写操作'''
with open('C:/李林峰/text2.txt', 'w') as file:
file.write('奋斗成就更好的未来')
实操案例二
输出《红楼梦中的金陵十二钗》前5位
'''1 变量的赋值'''
name1='林黛玉'
name2='薛宝钗'
name3='贾元春'
name4='贾探春'
name5='史湘云'
print('1\t'+name1)
print('2\t'+name2)
print('3\t'+name3)
print('4\t'+name4)
print('5\t'+name5)
'''2种方式 列表'''
lst_name=['林黛玉','薛宝钗','贾元春','贾探春','史湘云']
lst_sig=['1','2','3','4','5']
for i in range(5):
print(lst_sig[i],'\t',lst_name[i])
'''3种方式 字典'''
d={'1':'林黛玉','2':'薛宝钗','3':'贾元春','4':'贾探春','5':'史湘云'}
for key in d:
print(key,d[key])
print('zip-----------')
for s,name in zip(lst_sig,lst_name):
print(s,name)
图像音像勋章
print('\033[0:35m\t\t图像音像勋章\033[m')
print('\033[0:35m---------------------\033[m')
输出你的身体指标
height=170
weight=50.5
bmi=weight/(height+weight)
print('您的身高是:'+str(height))
print('您的体重是:'+str(weight))
print('您的BMI的指数是:'+'{:0.2f}'.format(bmi))
实操案例三
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0WIDthtU-1643201542079)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220125104315944.png)]
将指定的十进制数转换成二进制、八进制、十六进制
二进制 ------>binary system
八进制 ------>octonary number system 英 /ˈɒktənəri/
十进制 ------>decimalism 英 /ˈdesɪməlɪzəm/
def fun():
num=int(input('请输入一个十进制的整数'))#将str转换成int类型
print(num,'的二进制数是:',bin(num))#第一种写法,使用了个数可变的位置参数
print(str(num)+'的二进制数为:'+bin(num))#第二种写法,使用“+”作为连接符(+的左右均为str类型)
print('%s的二进制位:%s'%(num,bin(num)))#第三种写法,格式化字符串
print('{0}的二进制数为:{1}'.format(num,bin(num)))#第三种写法,格式化字符串
print(f'{num}的二进制数为:'{bin(num)})#第三种方式,格式化字符串
print(f'{num}的八进制数为:'{oct(num)})
print(f'{num}的十六进制数为:'{hex(num)})
if __name__ == '__main__':
while True:
try:
fun()
break#如果程序正常输出结束以后,我们再break
except:
print('只能输入整数!程序出错,请重新输入')
为自己手机充值
print('用户手机账户原有话费金额为:\033[0:35m8元\033[m')
money=int(input('请输入用户充值金额:'))
money+=8
print('当前的金额为:\033[0:35m',money,'元\033[m')
'''
用户手机账户原有话费金额为:8元
请输入用户充值金额:100
当前的金额为: 108 元
'''
计算能量的消耗
num=int(input('请输入您当天行走的步数:'))
calorie=num*28
print(f'今天共消耗了卡路里{calorie},即{calorie/1000}千卡')
'''
请输入您当天行走的步数:10000
今天共消耗了卡路里280000,即280.0千卡
'''
预测未来子女的身高
father_height=float(input('请输入父亲的身高:'))
mother_height=float(input('请输入母亲的身高:'))
son_height=(father_height+mother_height)*0.54
print('预测子女的身高为:{}cm'.format(son_height))
'''
请输入父亲的身高:170
请输入母亲的身高:168
预测子女的身高为:182.52cm'''
实操案例四
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QoNtIT0V-1643201542080)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220125114055615.png)]
支付密码的验证
pwd=input('支付宝支付密码:')
if pwd.isdigit():
print('支付数据合法')
else:
print('支付数字不合法,支付密码只能是数据')
print('-------------------------------------------')
print('支付数据合法' if pwd.isdigit() else '支付数字不合法,支付密码只能是数据')
模拟QQ账号登录
qq=input('请输入qq号:')
pwd=input('请输入密码:')
if qq=='1059630434' and pwd=='123':
print('登陆成功')
else:
print('对不起,账号或密码不正确')
商品价格大竞猜
import random
price=random.randint(1000,1500)
print('今日竞猜的商品为小米草地机器人:价格在[1000-1500]之间:')
guess=int(input())
if guess>price:
print('大了')
elif guess<price:
print('小了')
else:
print('猜对了')
print('真实价格为:',price)
根据星座查看运势
d={
'白羊座':'''1''',
'金牛座':'''2'''
}
star=input('请输入您的星座查看近来运势:')
print(d.get(star))
'''请输入您的星座查看近来运势:白羊座
1'''
实操案例五
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d8g2lFsb-1643201542080)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220125121002601.png)]
循环输出26个字母对应的ASCll码值
x=97#代表的是a的ASCII值
for _ in range(1,27):
print(chr(x),'--->',x)
x+=1
print('-----------')
x=97
while x<123:
print(chr(x),'-->',x)
x+=1
模拟用户登录
for i in range(1,4):
user_name=input('请输入用户名:')
user_pwd=input('请输入密码:')
if user_name=='admin' and user_pwd=='8888':
print('登录成功')
break
else:
print('用户名或密码不正确!!!')
if i<3:
print(f'您还有{3-i}次机会!!!')
else:#这个else的意思是当你的这三个循环都结束后就会执行这个else之后的语句
print('对不起,三次均输入错误,请联系后台管理员')
猜数游戏
import random
rand=random.randint(1,100)
for i in range(1,11):
num=int(input('在我心中有个数1-100,请你猜一猜'))
if num<rand:
print('小了')
elif num>rand:
print('大了')
else:
print('恭喜你猜对了')
break
print(f'您一共猜了{i}次')
if i<3:
print('真聪明')
elif i<=7:
print('还凑合')
else:
print('天哪,找杨老师学习折半算法!!!')
计算100-999之间的水仙花数
import math
for i in range(100,1000):
if math.pow((i%10),3)+math.pow((i//10%10),3)+math.pow(i//100,3)==i:
print(i)
实操案例六
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Tu7ItCUe-1643201542081)(C:\Users\10596\AppData\Roaming\Typora\typora-user-images\image-20220126195422389.png)]
千年虫我来了
year=[82,89,88,86,85,00,99]
print('原列表',year)
for index,value, in enumerate(year):
#print(index,value)
if str(value)!='0':
year[index]=int('19'+str(value))
else:
year[index]=int('200'+str(value))
print('修改之后的列表:',year)
#列表的排序
year.sort()
print('排序之后的列表为:',year)
京东购物流程
lst=[]
for i in range(0,5):
goods=input('请输入商品编号和商品名称进入商品的入库,每次只能输入一件商品:\n')
lst.append(goods)
for item in lst:
print(item)
cart=[]
while True:
num=input('请输入要购买的商品编号:')
for item in lst:
if item.find(num)!=-1:
cart.append(item)
break# 退出for
if num=='q':
break #退出while循环
print('您购物车里已经选好的商品为:')
for i in range(len(cart)-1,-1,-1):
print(cart[i])
实操案例七
根据星座测试性格特点
key=input('请输入您的星座名称')
flag=True
for item in d:
if key==item:
flag=True
print(key,'的性格特点为:',d.get(key))
break
else:
flag=False
if not flag:
print('对不起,您输入的星座有误')
模拟12306货车票订票下单
dict_ticket={'G120':['天津-上海','18:05'],
'G153':['北京-天津','18:15']}
print('车次\t\t出发站-到达站\t\t')
for item in dict_ticket:
print(item,end=' ')
for i in dict_ticket[item]:
print(i,end=' ')
print()#换行
#请输入要购买的车次
train_no=input('请输入要购买的车次:')
persons=input('请输入乘车人,如果是多人请使用逗号分隔')
s=f'您已购买了{train_no}次列表'
s_info=dict_ticket[train_no]#获取车次详细信息
s+=s_info[0]+' '+s_info[1]+' 开'
print(f'{s}请{persons}尽快取走纸质车票.')
实操案例八
我的咖啡馆你做主
print('本店经营的咖啡有:')
for index,item in enumerate(coffee_name):
print(index+1,',',item,end=' ')
index=int(input('\n请输入您喜欢的咖啡编号:'))
if 0<=index<=len(coffee_name):
print(f'您的咖啡[{coffee_name[index-1]}]好了,请您慢用')
Python print输出带颜色 总结
https://mp.weixin.qq.com/s?src=11×tamp=1643077913&ver=3579&signature=Xs5i8fOba3Gvnk6VoReCQEZbFoRsxdHCv78bIkAR83AXabyIBVQXrSpTxpM7XqJrsF1K9JCf8l4erybJS7kfqksl2v6e0J2*SbQzGq-ZSelf-ULL9K3d7u970gXII3nP&new=1