python安装
idle:python自带的简单的开发环境
输出函数print()
一、print会输出
- 数字
- 字符串(必须加引号)
- 含有运算符的表达式(例如 3+1 其中3,1是操作数,+是运算符)(进行运算)
#输出数字
print (98.5)
#输出字符串
print ("Hello, clovershrub")
print('hello,world')
#输出表达式
print(3+1)
二、print()函数还可以将内容输出的目的地
- 显示器
- 文件:
fp=open(‘D:/text.txt’,”a+”)#文件不存在就创建,存在就在文件内容后面继续追加
print(‘helloworld‘,file=fp)
fp.close()
注意:所指定的盘符存在,使用file=fp
三、print()函数的输出形式
- 换行
- 不换行:使用,分割,
print(‘hello’,’world‘,’Python‘)
转义字符和原字符
+转义功能的首字母
换行:\n(newline)
回车:\r (return)
如print(‘hello\rworld’) 在hello的下一行输出world
水平制表符:\t (tab)
如print(‘hello\tworld’) 输出 hello world
而print(helloooo\tworld) 输出helloooo world
因为hell这四个字母成为一个字表位,o后\t 占用了其余三个
若是无剩余 则会新开一个字表位
退格:\b (backspace)
如print(‘hello\bworld’) 退格输出hellworld
*原字符:不希望字符串中转义字符起作用,就会使用原字符,即在字符串上加上R或者r
如print(r‘hello\nworld’) 输出hello\nworld
二进制与字符编码
8bit(位) — 1 byte (字节)——256种状态——256种符号
1024byte——1KB
1024KB——1MB
1024MB——1GB
1024GB——1TB
标识符和保留字
一、保留字:被赋予了特殊意义,无法在对象起名中使用
- 新建 keyword.demo
- import(导入) keyword
- print(keyword.kwist) 输出关键字列表
二、变量/函数/类/模块和其他对象 所起的名字叫做标识符
三、规则: - 字母、数字、下划线
- 不能以数字开头
- 不能是保留字
- 须严格区分大小写
变量的定义和使用
数据类型
整数类型—int ——98,可以表示正数、负数、0
浮点数类型——float ——3.1415926
布尔类型——bool——True 、False
字符串类型——str——“人生苦短,我用Python”(加上引号就是,不管是单引号、双引号、三引号、都是字符串)
整数类型
一、整数不同进制的表示方式
- 十进制——默认
- 二进制——以0b开头
- 八进制——以0o开头
- 十六进制——以0x开头
浮点类型
布尔类型
字符串
类型转换
str()
与其他语言不同的是,字符串和其他数据类型通过“+”连接时,其他数据类型不会自动转换为字符串,而是报错,解决办法就是进行类型转换
a=10
b=198.8
c=False
print(type(a),type(b),type(c))
# 输出:<class ‘int’><class ‘float’> <class ‘bool’>
print(str(a),str(b),str(c),type(a),type(b),type(c))
# 输出:10 198.8 False <class ‘str’> <class ‘str’> <class ‘str’>
int()
将str转为int类型,str必须是整数串,否则会报错,float转int会截取float的整数部分
s1='128'
f1=98.7
s2="45.6"
ff=True
s3="hello"
print(type(s1),type(f1),type(s2),type(ff),type(s3))
print(int(s1),type(int(s1))) #字符串为数字串
print(int(f1),type(int(f1))) #截取整数部分,小数舍掉
#print(int(s2),type(int(s2))) #字符串为小数串
print(int(ff),type(int(ff)))
#print(int(s3),type(int(s3))) #字符串必须为数字串且为整形
float()
- 非数字串不允许转换
- 布尔值true转1.0,false转0.0
s1='128.98'
s2="76"
ff=True
s3="hello"
i=98
print(type(s1),type(s2),type(ff),type(s3),type(i))
print(float(s1),type(float(s1)))# 128.98
print(float(s2),type(float(s2)))# 76.0
print(float(ff),type(float(ff)))# 1.0
#print(float(s3),type(float(s3))) #非数字串不允许转换
print(float(i),type(float(i))) # 98.0
注释
含有三种类型的注释
- 单行注释——以#开头,直到换行结束
- 多行注释——一对三引号代码 多行注释
'''多行注释
多行哦'''
- 中文编码声明注释——在文件开头 以指定源码文件的编码格式
input函数的使用
input()接收的参数是程序对用户的提问,会将用户的输入赋值给present变量
#输入函数input
prasent=input('大圣想要什么礼物呢?')
print(prasent,type(prasent))# 输出:用户键盘输入的内容,类型为str
# 从键盘录入两个整数,计算两个整数的和
a=int(input('请输入一个加数:'))
b=int(input('请输入一个被加数:'))
print(type(a),type(b))
print(a+b)
#print(int(a)+int(b))
运算符
python中运算符:算术运算符、赋值运算符、比较运算符、布尔运算符、位运算符
算数运算符
标准算术运算符:+、-、*、/、整除//
取余运算符:%
幂运算符:**
print(1+1) #加
print(1-1) #减
print(2*4) #乘
print(11/2) #除
print(11//2) #整除运算
print(11%2) #取余
print(2**3) #幂运算 2的3次方
print(9//4)# 2
print(-9//-4)# 2
#一正一负进行整除时,向下取整
print(9//-4)# -3
print(-9//4)# -3
# 一正一负进行取余时,遵循公式:公式 余数=被除数-除数*商
print(9%-4)# 9-(-4)*(-3) 9-12-->-3
print(-9%4)# -9-4*(-3) -9+12-->3
赋值运算符
a=3+4
print(a)# 7
b=c=d=20
# 以下3个输出都是同一个值
print(d,id(d))# 14645450672
print(b,id(b))# 14645450672
print(c,id(c))# 14645450672
a=20
a+=30
print(a)# 50
a*=2
print(a)# 100
a/=30
print(a)#3.33333333
a%=3
print(a)# 0.11111111
# 支持系列解包赋值,变量个数和值的个数一定要一致,否则会报错
a,b,c=1,2,3
print(a,b,c)# 1,2,3
# 系列解包赋值的用处:交换两个变量
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)
print(a<b)
print(a<=b)
print(a>=b)
print(a==b)# false
print(a!=b)# true
a=10
b=10
print(a==b) #True 说明,a与b的value相等
print(a is b) #True 说明:a与b的id标识相等
print(a is not b)# false
lst1=[11,22,33,44]
lst2=[11,22,33,44]
print(lst1==lst2)# true
print(lst1 is lst2 )# false
print(id(lst1))# 2525441564
print(id(lst2))# 2525665484
print(lst1 is not lst2)# true
布尔运算符
a,b=1,2
print(a==1 and b==2)# true
print(a==1 and b<2)# false
print(a!=1 and b==2)# false
print(a!=1 and b!=2)# false
print(a==1 or b==2)# true
print(a==1 or b<2)# true
print(a!=1 or b==2)# true
print(a!=1 or b!=2)# false
#not 对bool类型操作数取反
f=True
f2=False
print(not f)# false
print(not f2)# true
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位
print(4>>1) # 输出2。向右移动1位,相当于除以二
print(4>>2) # 输出1。除以4
运算符的优先级
总结:()、算术运算、位运算、比较运算、bool运算、赋值运算
- ()
- ** A 赋值运算符:先乘除后加减,有幂运算先幂运算
- *、/、//、%
- +、-
- <<、>> B 位运算符
- &
- |
-
、< 、>=、<=、==、!= C 比较运算符
- and
- or D 布尔运算符
- = E 赋值运算符
程序的组织结构
任何简单或者复杂的算法 可以由顺序结构、选择结构(if语句)和循环结构(while for-in语句)组成
顺序结构
程序开始-代码1-代码2-代码3……代码N——程序结束
对象的布尔值
Python一切为对象 所有对象都有一个布尔值
获取对象的布尔值,使用内置函数bool()
#以下对象bool值均为False
print(bool(False))
print(bool(0))
print(bool(0.0))
print(bool(None))
print(bool(''))
print(bool(""))
print(bool([])) #空列表
print(bool(list())) #空列表
print(bool(())) #空元组
print(bool(tuple())) #空元组
print(bool({})) #空字典
print(bool(dict())) #空字典
print(bool(set())) #空集合
#其他对象bool值均为True
分支结构
if 条件表达式:
如果满足条件执行缩进的代码
else:
如果不满足条件执行else里面缩进的代码
#单分支结构
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=float(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<60:
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(money*0.95)
else:
print(money)
条件表达式和pass语句
条件表达式是if……else(简写),语法结构:x if 判断条件 else y
,如果判断条件的布尔值为True,条件表达式的返回值为x,否则条件表达式的返回值为y
# 从键盘中输入两个整数,判断两个整数的大小
num1=int(input('请输入第一个整数'))
num2=int(input('请输入第二个整数'))
'''if num1>=num2:
print(num1,'大于等于',num2)
else:
print(num1,'小于',num2)'''
print(str(num1)+'大于等于'+str(num2) if num1>=num2 else str(num1)+'小于'+str(num2))
'''
pass语句什么都不做,只是一个占位符,用在需要语句的地方
#使用时间:先搭建语法结构,还没好代码怎么写的时候
配套使用:
1. if 语句的条件执行体
2. for--in语句的循环体
3. 定义函数的函数体
'''
answer=input('您是会员吗?y/n')
if answer=='y':
pass
else:
pass
range()函数的使用
#range()的三种创建方式
# 第一种创建方式
r=range(10) #默认从零开始,默认相差1称为步长
print(r) #range(0,10)
print(list(r)) #用于查看range对象中的整数序列 -->list是列表的意思
# 输出:[0,1,2,3,4,5,6,7,8,9]
# 第二种创建方式
r=range(1,10) #指定起始值,从1开始到10结束(不包含10)
print(list(r))
# 输出:[1,2,3,4,5,6,7,8,9]
#第三种创建方式
r=range(1,10,2) #步长为2
print(list(r))# 输出:[1,3,5,7,9]
# 判断指定的m
print(9 in r)
print(8 not in r)
while循环
sum=0
a=0
while a<5:
sum+=a
a+=1
print(sum)
# 1到100之间
的偶数和
sum=0
a=1
while a<=100:
if not bool(a%2): # if a%2==0:
sum+=a
a+=1
print(sum)
for_in循环
for item in 'python':
print(item)
# range()产生的整数序列,也是一个可迭代对象
for i in range(10):
print(i)
# 如果在循环体中不需要使用到自定义变量,可将自定义变量写为“_“
for _ in range(5):
print('人生苦短')
# 100到999之间的水仙花数
for item in range(100,1000):
ge=item%10
shi=item//10%10
bai=item//100
#print(bai,shi,ge)
if ge**3+shi**3+bai**3==item:
print(item)
流程控制语句break和continue
a=0
while a<3:
pwd=input('请输入密码:')
if pwd=='8888':
print('密码正确')
break
else:
print('密码不正确')
a+=1
for item in range (1,51):
if item%5!=0:
continue
print(item)
else语句
与while和for搭配使用:只要循环正常执行完,就会执行else
for item in range(3):
pwd=input('请输入密码:')
if pwd=='8888':
print('密码正确')
break
else:
print('密码不正确')
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(i,'*',j,'=',i*j,end='\t')
print()
二重循环的break和continue
二重循环中的break和continue用于控制本层循环
for i in range(5):
for j in range(1,11):
if j%2==0:
#break
continue
print(j,end='\t')
print()
列表
列表的创建
# 列表对象
# 创建列表的第一种方式,[]
lst=['hello','world',98,'hello']
print(id(lst))
print(type(lst))
print(lst)
print(lst[0],lst[-4])
# 创建列表的第二种方式,list()
lst2=list(['hello','world',98])
print(id(lst2))
print(type(lst2))
print(lst2)
列表的特点
获取列表中单个元素
lst=['hello','world',98,'hello']
print(lst.index('hello')) #列表中有相同元素只返回列表中相同元素的的第一个元素的索引
# print(lst.index('python')) #ValueError: 'python' is not in list
# print(lst.index('hello',1,3)) #ValueError: 'hello' is not in list 1-'world' 2-98 不包括3
print(lst.index('hello',1,4))
lst=['hello','world',98,'hello','world',234]
# 获取索引为2的
print(lst[2])
# 获取索引为-3的
print(lst[-3])
# 获取索引为10的
print(lst[10]) # IndexError: list index out of range
获取列表中的多个元素——切片操作
lst=[10,20,30,40,50,60,70,80]
print(lst[1:6:1])# [20,30,40,50,60]
print(lst[1:6]) #默认步长为1 [20,30,40,50,60]
print(lst[1:6:])#默认步长为1 [20,30,40,50,60]
print(lst[1:6:2]) #步长为2 [20,40,60]
print(lst[:6:2])# [10,30,50]
print(lst[1::2])# [20,40,60,80]
print(lst[::2])# [10,30,50,70]
print(lst[::])# [10,20,30,40,50,60,70,80]
# 步长为负数
print(lst[::-1])# [80,70,60,50,40,30,20,10]
print(lst[7::-1])# [80,70,60,50,40,30,20,10]
print(lst[6:0:-2])# [70,50,30]
# 新切出来的是一个新的列表对象
print('原列表',id(lst))# 2005509464960
lst2=lst[1:6:1]
print('切的片段',id(lst2))# 2005510479424
列表元素的判断及遍历
lst=[10,20,'python','hello']
print(10 in lst) #判断
print(10 not in lst)
for item in lst: #遍历
print(item)
列表元素的增删改操作
列表元素的增加操作
# 向列表末尾添加元素
lst=[10,20,30]
print(lst,id(lst))# 2181409792960
lst.append(100)
print(lst,id(lst))# 2181409792960
lst2=['hello','world']
# lst.append(lst2) # 将lst2作为一个元素添加到列表末尾 [10,20,30,['hello','world']]
lst.extend(lst2) # 向列表末尾添加多个元素 [10,20,30,'hello','world']
print(lst)
lst.insert(1,90) # 在任意位置上添加一个元素,在索引为1的位置上添加一个90
print(lst)# [10,90,20,30,'hello','world']
lst3=[True,False,'hello']
lst[1:]=lst3 # 在任意位置添加N个元素,从第一个元素开始后面的元素全删除(切掉),然后再添加元素
print(lst)# [10,True,False,'hello']
列表元素的删除操作
lst=[10,20,30,40,50,60,30]
lst.remove(30) #从列表中移除一个元素,如果有重复元素只移除第一个元素
print(lst)# [10,20,40,50,60,30]
# lst.remove(100) #ValueError: list.remove(x): x not in list
#pop()根据索引移除元素
lst.pop(1)
print(lst)# [10,40,50,60,30]
# lst.pop(5) #IndexError: pop index out of range
lst.pop() #如果不指定参数,将删除最后一个参数
print(lst)# [10,40,50,60]
# 切片操作会产生一个新的列表对象,切片相当于从列表中取数
new_lst=lst[1:3]
print('原列表',lst)# [10,40,50,60]
print('切片后列表',new_lst)# [40,50]
# 不产生新的列表对象,而是删除原列表中的内容
lst[1:3]=[]
print(lst)# [10,60]
lst.clear() #清除列表中的所有元素
print(lst)
del lst #将列表对象删除
# print(lst) # NameError: name 'lst' is not defined. Did you mean: 'list'?
列表元素的修改操作
#修改一个值
lst=[10,20,30,40]
lst[2]=100
print(lst)# [10,20,100,40]
# 使用切片修改多个值
lst[1:3]=[300,400,500,600]
print(lst)# [20,300,400,500,600,40]
列表元素的排序操作
lst=[20,40,10,98,54]
print('排序前',lst,id(lst))# [20,40,10,98,54] 1632705897408
lst.sort() #升序
print('排序后',lst,id(lst))# [10,20,40,54,98] 1632705897408
# 指定关键字参数,实现列表元素的降序排序
lst.sort(reverse=True) #降序
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]
new_lst=sorted(lst) #产生一个新列表 升序
print(lst)# [20,40,10,98,54]
print(new_lst)# [10,20,40,54,98]
# 指定关键字参数,实现列表元素的降序排序
desc_lst=sorted(lst,reverse=True) #降序
print(desc_lst)# [98,54,40,20,10]
列表生成式
lst=[i*i for i in range(1,10)]
print(lst)
lst2=[i for i in range(2,11,2)]
print(lst2)
字典
可变序列:能够进行增删改的序列
列表是有序序列
key是不可变序列,如str,不可变序列不可执行增删改操作
字典的创建
使用内置函数dict()是通过赋值的形式创建字典,所以左侧不加‘’,右侧加不加根据右侧的数据类型来定
# 使用花括号
scores={'张三':100,'李四':98,'王五':45}
print(scores)
# 使用内置函数
stu=dict(name='jack',age=20)
print(stu)
字典的常用操作
字典元素的获取
# 获取字典中的值,使用[]
print(scores['张三'])
# print(scores['陈六']) # KeyError: '陈六'
# 使用get()
print(scores.get('张三'))
print(scores.get('陈六')) # None
# 如果查找的key不存在,返回某个默认值
print(scores.get('马七',99)) # 99是在查找‘马七’所对的value不存在时,提供的一个默认值
字典元素的增删改操作
scores={'张三':100,'李四':98,'王五':45}
print("张三" in scores)# true
print("张三" not in scores)# false
del scores['张三'] # 删除指定的key-value对,输出:{'李四':98,'王五':45}
# scores.clear() # 清空字典的元素
print(scores)
scores['陈六']=98 #新增元素
print(scores)# {'李四':98,'王五':45,'陈六':98}
scores['陈六']=100 # 修改元素
print(scores)# {'李四':98,'王五':45,'陈六':100}
获取字典视图
scores={'张三':100,'李四':98,'王五':45}
# 获取所有的key
keys=scores.keys()
print(keys)# dict_keys(['张三','李四','王五'])
print(type(keys))# dict_keys
# scores.keys()得到的数据的类型是dict_keys,我们可以将所有的key组成的视图转成列表
print(list(keys))# ['张三','李四','王五']
# 获取所有的value
values=scores.values()
print(values)# dict_values([100,98,45])
print(type(values))# 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)]
字典元素的遍历
item是遍历出来的键的名称,score是要遍历的字典的名称
scores={'张三':100,'李四':98,'王五':45}
# 字典元素的遍历
for item in scores:
print(item,scores[item],scores.get(item))
字典的特点
d={'name':'张三','name':'李四'} # key不允许重复,重复的key会覆盖原来的值
print(d)# {'name':'李四'}
d={'name':'张三','nikename':'张三'} # value允许重复
print(d)# {'name':'李四','name':'张三','nikename':'张三'}
字典生成式
items=['Fruits','Books','Others']
prices=[96,78,85,100,120]
# 遍历两个list中的值,分别存放在item,price中,item,price是要放在字典中的,所以最外层用了{},里面写作item:price,如果想要items大写,那么使用item.upper()
d={item.upper():price for item,price in zip(items,prices)}
print(d)# 当两个list的个数不一致时,以短的那个为准
lst=zip(items,prices)
print(list(lst))
元组
'''可变序列 列表,字典:可以进行增删改,即列表/字典进行增删改后,列表/字典在内存中的地址不变'''
lst=[10,20,45]
print(id(lst))# 1808459865024
lst.append(200)
print(id(lst))# 1808459865024
'''不可变序列 字符串,元组:不可以进行增删改,
即不可变序列进行增删改并非在原序列上操作,而是在内存中新开辟一个序列,所以不可变序列进行增删改后在内存中的地址会改变'''
s='hello'
print(id(s))# 2753280992112
s=s+'world'
print(id(s))# 2753284295600
print(s)
元组的创建方式
# 第一种,用()
t=('Python','world',98)
print(t)# ('Python','world',98)
print(type(t))# tuple
t2='Python','world',98 # 省略了小括号
print(t2)# ('Python','world',98)
print(type(t2))# tuple
t=('Python',) # 只包含一个元组的元素需要使用逗号和小括号,不然为str类型(此处)
print(t)# ('Python')
print(type(t))# tuple
# 第二种创建方式,内置函数tuple()
t1=tuple(('Python','world',98))
print(t1)# ('Python','world',98)
print(type(t1))# tuple
# 空列表
lst=[]
lst1=list()
# 空字典
d={}
d1=dict()
# 空元组
t=()
t1=tuple()
print('空列表',lst,lst1)
print('空字典',d,d1)
print('空元组',t,t1)
为什么要将元组设计成不可变序列
一旦创建了不可变类型的对象,对象内的所有数据就不能再被修改了,这就避免了由于修改数据而导致的错误。此外对于不可变类型的对象,在多任务环境下,同时操作对象时不需要加锁
元组中保存的数据为(10,[20,30],9),10和9都是不可变对象,不能引用其他值,如果我想把[20,30]位置的数据换成100,这也是不可以的,因为[20,30]是可变对象,可变对象的引用不可以改变,只能在[20,30]后面追加100,元组中原本指向[20,30]的内存地址不变
t=(10,[20,30],9)
print(type(t))# tuple
print(t[0],type(t[0]),id(t[0]))# 10 int 140716189915072
print(t[1],type(t[1]),id(t[1]))# [20,30] list 2223714708224
print(t[2],type(t[2]),id(t[2]))# 9 int 140716189915040
# 尝试将t[1]修改为100
print(id(100))# 140716189917952
#t[1]=100 #元组不允许修改元素
#由于[20,30]列表,而列表是可变序列,所以可以向列中添加元素,而列表的内存地址不变
t[1].append(100) #向列表中添加元素
print(t,id(t[1]))# [20,30,100] 2223714708224
元组的遍历
#元组的遍历
t=('Python','world',98)
#1.索引
print(t[0])
print(t[1])
print(t[2])
# print(t[3]) #IndexError: tuple index out of range
#2.遍历
for item in t:
print(item)
集合
# 集合的创建方式
# 1.{}
s={2,3,4,5,6,7,7} #集合中的元素不允许重复
print(s)# {2,3,4,5,6,7}
#2.set()
s1=set(range(6))
print(s1,type(s1))# {0,1,2,3,4,5} set
# 通过set()将列表中的元素转成集合
s2=set([1,2,4,5,5,5,6,6])
print(s2,type(s2))# {1,2,3,5,6} set
# 通过set()将元组中的元素转成集合
s3=set((1,2,4,4,5,65)) #集合中的元素是无序的
print(s3,type(s3))# {1,2,4,5,65} set
# 通过set()将字符串中的元素转成集合
s4=set('python')
print(s4,type(s4))# {'n','h','p','y','t','y'} set
# 通过set()将字典中的元素转成集合
s5=set({12,4,34,55,66,44,4})
print(s5,type(s5))# {34,66,4,55,12,44} set
# 定义一个空集合
s6={} #dict字典类型
print(type(s6))# dict
s7=set()
print(type(s7))# set
集合的相关操作
#集合的相关操作
#判断操作
s={10,2,0,30,40,50}
print(10 in s)# true
print(100 in s)# false
print(0 not in s)# false
#新增操作
s.add(80) #一次添加一个
print(s)# {10,80,2,30,0,40,50},无序的
s.update({200,300,4000}) #一次至少添加一个元素,把一个集合添加到指定集合中
print(s)# {200,300,10,80,2,30,0,40,50,4000},无序的
# 也可以以列表和元组的形式批量往里添加数据
s.update([100,99,6])
s.update((78,56,48))
print(s)# {78,200,56,300,10,100,80,48,2,6,30,0,40,99,50,4000}
#删除操作
s.remove(10)
print(s)# {78,200,56,300,100,80,48,2,6,30,0,40,99,50,4000}
# s.remove(500) #KeyError: 500
# print(s)
# 如果集合中有500则删除,没有也不报错
# s.discard(500) #没有,不报错
# print(s)
s.pop() #只能删除第一个,且不能添加参数
print(s)# {200,56,300,10,100,80,48,2,6,30,0,40,99,50,4000}
s.clear() #清空集合
print(s)# set()
集合间的关系
# 两个集合是否相等(元素相同,就相等)
s={10,20,30,40}
s2={20,30,40,10}
print(s==s2) #T
print(s!=s2) #F
#子集和超集
s1={10,20,30,40,50,60}
s2={10,20,30,40}
s3={10,20,90}
print(s2.issubset(s1)) #T s2的所有数据都在s1中,所以s2是s1的子集
print(s3.issubset(s1)) #F
print(s1.issuperset(s2)) #T s2的所有数据都在s1中,所以s1是s2的超集
print(s1.issuperset(s3)) #F
#交集
print(s2.isdisjoint(s3)) #F - 有交集
s4={100,200,300}
print(s2.isdisjoint(s4)) #T - 没有交集
集合的数据操作
# 集合的数学操作
#(1)交集
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2))# {40,30,20}
print(s1&s2)# &与intersection等价,都是求交集操作,输出:{40,30,20}
#(2)并集
print(s1.union(s2))# {40,30,20,10,50,60}
print(s1|s2)# |与union等价,都是求并集操作,输出:{40,30,20,10,50,60}
#(3)差集
print(s1.difference(s2)) #s1有s2没有,输出:[10]
print(s1-s2)# -与difference等价,都是求差集操作,输出:[10]
print(s2.difference(s1))# s2有s1没有,输出:[50,60]
#(4)对称差集
print(s1.symmetric_difference(s2)) #集合交集以外的元素,输出:[10,50,60]
print(s1^s2)# ^与symmetric_difference等价,都是求对称差集操作,输出:[10,50,60]
集合生成式
s={i*i for i in range(10)}
print(s)
总结
字符串
字符串的创建和驻留机制
#字符串
#字符串的定义及驻留机制
a='python'
b="python"
c='''python'''
print(a,id(a))# python 1874508798960
print(b,id(b))# python 1874508798960
print(c,id(c))# python 1874508798960
驻留机制:仅保存一份相同且不可变的字符串的方式
交互模式:cmd下执行python即可进入交互模式
符合标识符的字符串:含有字母数字下划线的字符串
b是在程序编译时完成了拼接,c是在程序运行时使用join完成拼接,a is c为false
可以使用sys实现强制驻留
字符串的常用操作
字符串的查询操作
#字符串查询操作
s='hello,hello'
print(s.index('lo')) #第一次出现的位置,输出:3
print(s.find('lo'))#第一次出现的位置,输出:9
print(s.rindex('lo')) #最后一次出现的位置
print(s.rfind('lo'))#第一次出现的位置,输出:9
# print(s.index('k')) #ValueError: substring not found 不存在
print(s.find('k')) #-1 不存在
字符串的大小写转换
#字符串的大小写转换操作
s='HelloWorld,wa'
print(s.upper(),id(s.upper())) #全转成大写会产生一个新的字符串对象,输出:HRLLOWORLD,WA 2133868981488
print(s,id(s))#helloworld,wa 2134125876016
print(s.lower()) #全转成小写,如果原来的字符串就是小写的,在执行了lower()后依旧会产生一个新的字符串对象,二者的id()依旧不一样
print(s.swapcase()) #大转小,小转大
print(s.capitalize()) #第一个字符大写,其余小写
print(s.title()) #每个单词首字母大写,其余小写
字符串内容对齐操作
#字符串内容对齐操作
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
字符串的劈分操作
#字符串的劈分操作
s='hello world Python'
print(s.split())# 默认以空格拆分,输出:['hello','world','Python']
s1='hello|world|Python'
print(s1.split())# ['hello world Python']
print(s1.split(sep='|'))# 指定分隔符,['hello','world','Python']
print(s1.split(sep='|',maxsplit=1))#['hello','world|Python']
#从右侧分
print(s1.rsplit(sep='|',maxsplit=1))# ['hello|world','Python']
字符串的判断操作
#字符串判断的相关方法
#合法标识符
s='hello,python'
print(s.isidentifier()) #F
print('hello'.isidentifier()) #T
print('张三_123'.isidentifier()) #T
#空白字符
print('\t'.isspace()) #T
print(' '.isspace()) #T
#字母
print('abc'.isalpha()) #T
print('张三'.isalpha()) #T
print('张三1'.isalpha()) #F
#十进制数字
print('123'.isdecimal()) #T
print('123四'.isdecimal()) #F
print('ⅡⅢⅣ'.isdecimal()) #F
#数字
print('123'.isnumeric()) #T
print('123四'.isnumeric()) #T
print('ⅡⅢⅣ'.isnumeric()) #T
print('壹贰叁'.isnumeric()) #T
#字母和数字
print('abc1'.isalnum()) #T
print('张三123'.isalnum()) #T
print('abc!'.isalnum()) #F
字符串的其他操作
#字符串的其他操作
#字符串的替换
s='hello,Python'
print(s.replace('Python','Java'))# 用Java替换python,输出: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
# 连接字符串的元素
print('*'.join('python'))# p*y*t*h*o*n
字符串的比较操作
#字符串的比较操作
print('apple'>'app') #T
print('apple'>'banana') #F, 97>98 F
print(ord('a'),ord('b')) #原始值这里是字母的ascll码
print(ord('刘'))
print(chr(97),chr(98))# 获取ascii码为97的值,即a。chr()和ord()互为相反的两个方法
print(chr(21016))
'''==和is的区别
==比较的是value
is 比较的是 id'''
a=b='python'
c='python'
print(a==b) #T
print(b==c) #T
print(a is b) #T
print(a is c) #T
print(id(a)) #2383540093936
print(id(b)) #2383540093936
print(id(c)) #2383540093936
字符串的切片操作
#字符串的切片操作
s='hello,python'
print(s[:5]) #没有指定起始位置,从0开始,输出:hello
print(s[6:]) #没有指定结束位置,所以切到字符串最后一个元素,输出:python
s1='!'
newstr=s[:5]+s1+s[6:]
print(newstr) # hello!python
print(id(s))# 1990114866608
print(id(s[:5]))# 1990110831472
print(id(s[6:]))# 1990110735152
print(id(s1))# 1989860883760
print(id(newstr))# 1990110735216
print(s[1:5:1]) #完整写法 从一切到四,步长为一,输出:ello
print(s[::2]) #从0开始切到最后,输出:hlopto
print(s[::-1]) #从最后一个元素开始往前到第一个元素,步长为1,输出:nohtyp,olleh
print(s[-6::1])#从索引为-6的开始,到字符串的最后一个元素,步长为1,输出:python
格式化字符串
格式化字符串:按一定格式输出的字符串
#格式化字符串
# % 占位符
name='张三'
age=20
print('我叫%s,今年%d岁' % (name,age))
# {},0代表取format的第一个参数,所有用到0的地方都使用这个参数的值
print('我叫{0},今年{1}岁,我真的叫{0}'.format(name,age))
# f-string,前面加f代表格式化字符串
print(f'我叫{name},今年{age}岁')
#宽度和精度
print('%10d' % 99) #10个宽度,输出: 99
print('%.3f' % 3.1415926) #.3表示小数点后三位,输出:3.142
print('%10.3f' % 3.1415926) #宽度为10,保留三位小数,输出: 3.142
print('hellohello')
# 下面的0均指format第一个参数
print('{0:.3}'.format(3.1415926)) #.3表示一共三位数,输出:3.14
print('{0:.3f}'.format(3.1415926)) #.3f表示3位小数,输出:3.142
print('{0:10.3f}'.format(3.1415926)) #宽度是10位,3位是小数,输出
字符串的编码转换
#字符串的编码转换
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): #a,b为形式参数,形参位置是在函数的定义处
c=a+b
return c
result=calc(10,20) #10,20称为实际参数的值,实参的位置是函数的调用处
print(result)
#函数参数的传递
res=calc(b=10,a=20) #=左边的变量名称为 关键字参数
print(res)
#函数参数传递的内存分析
def fun(arg1,arg2):
print('arg1=',arg1)
print('arg2=',arg2)
arg1=100
arg2.append(10)
print('arg1=',arg1)
print('arg2=',arg2)
n1=11
n2=[22,33,44]
print('n1=',n1)
print('n2=',n2)
print('-------')
fun(n1,n2)
print('n1=',n1)
print('n2=',n2)
'''在函数调用过程中,进行参数的传递
如果是不可变对象,在函数体的修改不会形象实参的值 arg1修改为100,不会影响n1的值
如果是可变对象,在函数体的修改会影响到实参的值 arg2的修改,append(10),会影响到n2的值'''
函数的返回值
#函数的返回值
def fun(num):
odd=[]
even=[]
for i in num:
if i % 2: #bool(0)=False
odd.append(i)
else:
even.append(i)
return odd,even
print(fun([10,29,34,23,44,53,55]))
'''
(1)如果函数没有返回值【函数执行完毕后,不需要给调用处提供数据】 return可以省略
(2)如果函数有一个返回值,直接返回原类型
(3)如果函数有多个返回值,返回结果为元组
'''
def fun1():
print('hello')
#return
fun1()
def fun2():
return 'hello'
res=fun2()
print(res)
def fun3():
return 'hello','world'
print(fun3())
'''函数在定义时,是否需要返回值,视情况而定'''
函数参数定义
#默认值参数
def fun(a,b=10): #b为默认值
print(a,b)
#函数的调用
fun(100)# 100,10
fun(20,30)# 20,30
查看print的源码发现:
这个end就是默认值参数,默认换行,如果你不想换行,可以给end传其他值:
print('hello',end='\t')
print('world')
# 输出:hello world
#函数的参数定义
def fun(*args): #函数定义时,个数可变的位置参数
print(args)
fun(10)
fun(10,20,30)
def fun1(**args): #个数可变的关键字参数
print(args)
fun1(a=10)
fun1(a=20,b=20,c=40)
''' def fun2(*args,*a):
pass
报错,个数可变的位置参数,只能是一个
def fun2(*args,*a):
pass
报错,个数可变的关键字参数,只能是一个'''
def fun2(*args1,**args2):
pass
''' def fun3(**args1,*args2):
pass
在一个函数定义的过程中,既有个数可变的关键字参数,也有个数可变的位置形参,要求个数可变的位置形参,放在个数可变的关键字形参之前'''
#函数参数总结
def fun(a,b,c): # a,b,c在函数的定义处,所以是形式参数
print('a=',a)
print('b=',b)
print('c=',c)
#函数的调用
fun(10,20,30) #函数调用时的参数传递,称为位置传参
'''
输出:
a=10
b=20
c=30
'''
lst=[11,22,33]
fun(*lst) #函数调用时,将列表的每个元素都转换为位置实参传入
'''
输出:
a=11
b=22
c=33
'''
print('--------')
fun(a=100,c=300,b=200) #关键字实参
'''
输出:
a=100
b=200
c=300
'''
dic={"a":111,'b':222,'c':333}
fun(**dic) #在函数调用时,将字典的键值对都转换为关键字实参传入
'''
输出:
a=111
b=222
c=333
'''
def fun4(a,b,*,c,d): #从*之后的参数,在函数调用时,只能采用关键字参数传递
print('a=',a)
print('b=',b)
print('c=',c)
print('d=',d)
#fun4(10,20,30,40) #位置实参传递
fun4(a=10,b=20,c=10,d=40) #关键字实参传递
fun4(10,20,c=30,d=40) #前两个位置实参传递,后两个关键字实参传递
'''函数定义时形参的顺序问题'''
def fun5(a,b,*,c,d,**args):
pass
def fun6(*args,**args1):
pass
def fun7(a,b=10,*args,**args1):
pass
变量的作用域
#变量的作用域
def fun(a,b):
c=a+b #c,就称为局部变量,因为c在函数体内进行定义的变量,a,b为函数的形参,作用范围也是函数内部,相当于局部变量
print(c)
name='刘' #全局变量
print(name)
def fun1():
print(name)
fun1()
def fun3():
global age #函数内部定义的变量,局部变量,其用global声明,这个变量变为全局变量
age=20
print(age)
fun3()
print(age)
递归函数
#递归函数
def fac(n):
if n==1:
return 1
else:
return n*fac(n-1)
print(fac(9))
#斐波那契数列
def fib(n):
if n==1:
return 1
elif n==2:
return 1
else:
return fib(n-1)+fib(n-2)
print(fib(6))
for i in range(1,7):
print(fib(i))
bug
#bug的常见类型
#1.
age=input('请输入你的年龄:')
print(type(age))
# if age>=18: #TypeError: '>=' not supported between instances of 'str' and 'int'
if int(age)>=18:
print('你是成年人了')
#2.
# while i<10:
# print(i)
i=0
while i<10:
print(i)
i+=1
#3.
for i in range(3):
uname=input('请输入用户名:')
pwd=input('请输入密码:')
# if uname='admin' and pwd='admin':
if uname=='admin' and pwd=='admin':
print('登陆成功!')
break
# else
else:
print('输入有误')
else:
print('对不起,三次均输入错误')
#4.索引越界问题IndexError
lst=[11,22,33,44]
# print(lst[4]) #list index out of range
print(lst[3])
#5.append()方法的使用不熟练
lst=[]
# lst=append('A','B','C')
lst.append('A')
lst.append('B')
lst.append('C')
print(lst)
#被动掉坑问题
''' n1=int(input('请输入一个整数:'))
n2=int(input('请输入另一个整数:'))
result=n1/n2
print('结果为:',result)'''
python的异常机制:try…exception
当存在多个异常需要捕获时,可以采用多个except结构:
#try...except结构
try:
n1=int(input('请输入一个整数:'))
n2=int(input('请输入另一个整数:'))
result=n1/n2
print('结果为:',result)
except ZeroDivisionError:
print('对不起,除数不允许为零')
except ValueError:
print('不能将字符转换为数字')
print('程序结束')
#try...except...else结构
try:
n1=int(input('请输入一个整数:'))
n2=int(input('请输入另一个整数:'))
result=n1/n2
except BaseException as e:
print('出错了',e)
else:
print('结果为:',result)
#try...except...else...finally结构
try:
n1=int(input('请输入一个整数:'))
n2=int(input('请输入另一个整数:'))
result=n1/n2
except BaseException as e:
print('出错了',e)
else:
print('结果为:',result)
finally:
print('谢谢您的使用')
print('程序结束')
python中常见的异常类型
#常见的异常类型
# print(10/0) #ZeroDivisionError
lst=[11,22,33,44]
# print(lst[4]) #IndexError
dic={'name':'张三','age':20}
# print(dic['gender']) #KeyError
# print(num) #NameError
# int a=20 #SyntaxError
#a=int('hello') #ValueError
traceback模块的使用
#traceback模块的使用
import traceback
try:
print('--------------')
print(1/0)
except:
traceback.print_exc()
对象
python中一切皆对象
类的创建
实例方法写不写self都会有个self在(不写程序白送你一个),静态方法中不允许写self,类方法中需要传入cls
#定义python中的类
class Student: #Student为类的名称(类名)由一个或多个单词组成,每个单词首字母大写,其余小写
native_place='吉林' #直接写在类里的变量,成为类属性
def __init__(self,name,age):
self.name=name #self.name 称为实例属性,进行了一个赋值操作,将局部变量的name的值赋给实体属性/实例变量
self.age=age
#实例方法
def eat(self):
print(self.name+'在吃饭')
#静态方法
@staticmethod
def sm():
print('静态方法')
#类方法
@classmethod
def cm(cls):
print('类方法')
#在类之外定义的称为函数,再类之内定义的称为方法
def drink():
print('喝水')
#创建Student类的对象
stu1=Student('张三',20)
stu2=Student('李四',30)
print(id(stu1))# 1421362237888
print(type(stu1))# <class '__main__.Student'>
print(stu1)# <__main__.Student object at 0x0000014AEFCA91C0>
# 1421362237888的十六进制为0x0000014AEFCA91C0
# 实例对象会有一个类指针指向类对象
print(id(Student))# 2218905389200
print(type(Student))# <class ‘type’>
print(Student)# <class '__main__.Student'>
# 下面两行都可以调用类的实例方法:实例对象.实例方法 或者 类对象.实例方法(实例对象)
stu1.eat() #对象名.方法名()
Student.eat(stu1) #类名.方法名(类的对象)-->实际上就是方法定义处的self
print(stu1.name)
print(stu1.age)
#类属性的使用方式
#print(Student.native_place)
print(stu1.native_place)# 吉林
print(stu2.native_place)# 吉林
Student.native_place='天津'
print(stu1.native_place)# 天津
print(stu2.native_place)# 天津
#类方法的使用方式
Student.cm()
#静态方法的使用方式
Student.sm()
#动态绑定属性和方法
stu2.gender='女' #动态绑定性别属性
# print(stu1.name,stu1.age,stu1.gender) #AttributeError: 'Student' object has no attribute 'gender'
print(stu2.name,stu2.age,stu2.gender)
stu1.eat()
stu2.eat()
def show():
print('定义在类之外的,称为函数')
stu1.show=show #动态绑定方法
stu1.show()
# stu2.show() #AttributeError: 'Student' object has no attribute 'show'
面向对象的三大特征
封装
#封装
class Car:
def __init__(self,brand):
self.brand=brand
def start(self):
print('汽车已启动...')
car=Car('宝马x5')
car.start()
print(car.brand)
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) #AttributeError: 'Student' object has no attribute '__age'
# print(dir(stu)) #获取对象所有的属性和方法
print(stu._Student__age) #在类的外部可以通过 _Student__age 进行访问,输出:20
继承
定义类时,括号里写父类,如上述Person的父类是object,Student的父类是Person。python支持多继承,比如a继承object,b继承object,c可以同时继承a,b:class c(a,b)
#继承
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,score):
super().__init__(name, age)# 在子类的init方法中使用super().__init__调用父类的初始化方法进行赋值
self.score=score# 然后再对自己内部的属性进行初始化
def info(self): #方法的重写,重写父类的info()
super().info()# 如果还想用到父类的info()的方法体,使用super().info()调用
print(self.score)
class Teacher(Person):
def __init__(self, name, age,teachofyear):
super().__init__(name, age)
self.teachofyear=teachofyear
def info(self): #方法的重写
super().info()
print(self.teachofyear)
#测试
stu=Student('Jack',20,'1001')
stu.info()
tea=Teacher('Tom',40,20)
tea.info()
object类
#object类 -- 所有类的父类
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('jack',20)
print(dir(stu))
print(stu)# 默认会调用__str__(self)方法,如果没有覆写,会输出实例对象的内存地址
print(type(stu))
多态
像Java这种静态语言实现多态需要具备三个必要条件:继承、方法重写、父类指向子类对象,但是python是动态语言,他只关心你有没有这个方法,其余都不管
#多态
class Animal(object):
def eat(self):
print('动物会吃')
class Dog(Animal):
def eat(self):
print('狗吃骨头')
class Cat(Animal):
def eat(self):
print('猫吃鱼')
class Person:
def eat(self):
print('人吃五谷杂粮')
#定义一个函数
def fun(obj):
obj.eat()
#调用
fun(Cat())# 动物会吃
fun(Dog())
fun(Animal())
fun(Person())
特殊方法和特殊属性
#特殊属性
class A:
pass
class B:
pass
class C(A,B):
def __init__(self,name,age):
self.name=name
self.age=age
class D(A):
pass
#创建C类对象
x=C('jack',20) #x是C类型的一个实例对象
print(x.__dict__) #查看实例对象的属性字典
print(C.__dict__)# 查看类对象的属性字典
print(x.__class__) #输出对象所属的类型 <class '__main__.C'>
print(C.__bases__) #C类的父类类型的元组:(<class '__main__.A'>,<class '__main__.B'>)
print(C.__base__) #类的基类,C继承A和B,所以输出<class '__main__.A'>,如果C继承B和A,则输出<class '__main__.B'>,C多继承时,谁在前就输出谁
print(C.__mro__) #类的层次结构:(<class '__main__.C'>,<class '__main__.A'>,<class '__main__.B'>,<class 'object'>)
print(A.__subclasses__()) #子类的列表:[<class '__main__.C'>,<class '__main__.D'>]
#类的特殊方法
a=20
b=100
c=a+b #两个整数类型的对象的相加操作
d=a.__add__(b)# 两个整数类型的对象的相加操作,底层调用的是__add__()进行相加
print(c)# 120
print(d)# 120
class Student:
def __init__(self,name):
self.name=name
stu1=Student('张三')
stu2=Student('李四')
s=stu1+stu2 #报错:Student类型不能进行相加,但是我想要相加怎么办呢?给Student类定义一个__add__()方法,如下所示
print(len(stu1))# 同理,如果我想输出长度,也会报错,但是我又想输出怎么办呢?给Student类定义一个__len__()方法,如下所示
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 #实现两个对象的加法运算
print(s)# 张三李四
s=stu1.__add__(stu2)
print(s)# 张三李四
lst=[11,22,33,44]
print(len(lst))# 4,调用len(lst)时底层执行了lst.__len__()
print(lst.__len__())# 4
print(len(stu1))# 2
__new__和__init__创建对象的过程
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)))
'''
程序的执行结果:
object这个类对象的id为:140717796113232
Person这个类对象的id为:2690679899360
__new__被调用执行了,cls的id值为2690679899360
创建的对象的id为:2690436007104
__init__被调用了,self的id值为:2690436007104
p1这个Person类的实例对象的id:2690436007104
'''
类的浅拷贝与深拷贝
#类的浅拷贝与深拷贝
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)# <__main__.CPU object at 0x000002B4D38D8490>
print(cpu2)# <__main__.CPU object at 0x000002B4D38D8490>
#(2)类的浅拷贝
disk=Disk() #创建一个硬盘类的对象
computer=Computer(cpu1,disk) #创建一个计算机类的对象
#浅拷贝
import copy
print(disk)# <__main__.Disk object at 0x000001782E443490>
computer2=copy.copy(computer)
print(computer,computer.cpu,computer.disk)# <__main__.Computer object at 0x000001781F3284C0> <__main__.CPU object at 0x000001781F238490> <__main__.Disk object at 0x000001782E443490>
print(computer2,computer2.cpu,computer2.disk)# <__main__.Computer object at 0x000001781F328190> <__main__.CPU object at 0x000001781F238490> <__main__.Disk object at 0x000001782E443490>
#深拷贝
computer3=copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)# <__main__.Computer object at 0x000001813E8284C0> <__main__.CPU object at 0x000001813E738490> <__main__.Disk object at 0x000001814D913490>
print(computer3,computer3.cpu,computer3.disk)# <__main__.Computer object at 0x000001813E8281F0> <__main__.CPU object at 0x000001814D943A30> <__main__.Disk object at 0x000001814EA626A0>
模块
import math
print(id(math))
print(type(math))
print(math)
print(math.pi)
print(dir(math))
print(math.pow(2,3))
print(math.ceil(9.001))
print(math.floor(9.999))
from math import pi
# from math import pow
print(pi)
print(pow(2,3))
# print(math.pow(2,3))
假如我现在自定义了一个模块calc.py,我想在demo5.py模块中导入他,如果我直接写import calc
会报错,需要将demo5.py所在包设为source root
以主程序方式运行
假如定义了一个calc2.py,内容如下:
def add(a,b):
return a+b
print(add(10,20))
然后在demo7.py中引入了他,并执行了print(calc2.add(100,200))
,会打印输出30 300,因为他先执行了calc2.py的打印,如果我们只想输出300,不让他执行calc2.py的打印输出,可以这样:
def add(a,b):
return a+b
if __name__ == '__main__': #只有在这个模块运行时,才执行下述代码
print(add(10,20))
python中的包
一个python程序中有无数个包,每个包中有无数个模块,每个模块中又有无数的类、方法、语句。python中创建包:
在demo8.py中导入包中的模块
python中常用的内容模块
import sys
import time
import urllib.request
import math
print(sys.getsizeof(24))# 28:24占了28个字节
print(sys.getsizeof(45))# 28
print(sys.getsizeof(True))# 28
print(sys.getsizeof(False))# 24
print(time.time())
print(time.localtime(time.time()))
print(urllib.request.urlopen('http://www.baidu.com').read())
print(math.pi)
第三方模块的安装及使用
#第三方模块的安装 pip install 模块名
import schedule
import time
def job():
print('hh')
schedule.every(3).seconds.do(job)
while True:
schedule.run_pending()
time.sleep(1)
文件
编码格式
在操作中文文本文件时,经常出现乱码情况,
文件的读取原理
解释器调用操作系统的资源读取.py文件操作磁盘上的文件(对文件进行读写操作)
a.txt的内容为:
中国
美丽
#读
file=open('a.txt','r')
print(file.readlines())# ['中国\n','美丽'],输出一个数组
file.close()
向b.txt文件写入hello
# 写
file=open('b.txt','w')# 如果没有b.txt文件则创建,如果有b.txt文件,因为第二个参数传的w,所以会清除文件原有的内容,重新写入新内容
file.write('hello')
file.close()
#追加
file=open('b.txt','a')# 如果没有b.txt文件则创建,如果有b.txt文件,因为第二个参数传的a,所以会在原有内容上追加新内容
file.write('hello')
file.close()
#复制图片
src_file=open('logo.png','rb')
target_file=open('copylogo.png','wb')
target_file.write(src_file.read())# 边读边写
target_file.close()
src_file.close()
文件对象的常用方法
#读
file=open('a.txt','r')
print(file.read(5)) #读取size个字节或字符
print(file.readline()) #读取一行内容,输出:中国
print(file.readlines()) #把文本文件中的每一行都作为独立的字符对象,并将这些对象放入列表返回。输出:['中国\n','美丽']
#写
file=open('c.txt','a')
# file.write('hello')
lst=['java','go','python']
file.writelines(lst)# hellojavagopython
file.close()
#移动文件指针
file=open('c.txt','r')
file.seek(2) #将文件移动到新的位置,一个汉字占2字节,这里写1会报错,写2会从国开始输出
print(file.read())
'''
国
美丽
'''
print(file.tell()) #返回指针当前所处位置。如果文件写完了,file.tell()返回文件长度
file.close()
file=open('d.txt','a')
file.write('hello')
file.flush() #把缓冲区的内容写入文件,但不关闭文件
file.write('world')
file.close()
with语句
#with语句(上下文管理器)
with open('a.txt','r') as file:# 打开a.txt文件,为打开的这个文件起别名:file,file就是上下文管理器
print(file.read())
#不用手动关闭!
将open('a.txt','r')
称为上下文表达式,他的执行结果file是一个上下文管理器
上下文管理器:一个类对象实现了
__enter__()
、__exit__()
,那么该类对象遵守上下文管理协议,该类的实例对象就称为上下文管理器
上述MyContentMgr类就是遵守上下文管理协议,他的实例对象MyContentMgr()就被称为上下文管理器
先执行__enter__()
方法,再执行with语句体,然后退出上下文管理器,执行__exit__()
方法。如果在执行with语句体的时候出现了异常,也会调用__exit__()
方法,说明在上下文管理器中,无论是否有异常都会调用__enter__()
、__exit__()
方法
利用with语句实现前述图片的复制:
with open('logo.png','rb') as src_file
with open('copylogo.png','wb') as target_file
target_file.write(src_file.read())# 边读边写
os模块的常用函数
#os模块与操作系统相关的一个模块
import os
os.system('notepad.exe')# 打开系统中的记事本(应用程序)
os.system('calc.exe')# 打开系统中的计算器(应用程序)
#直接调用可执行文件
os.startfile('C:\\Program Files (x86)\\Tencent\\QQ\\Bin\\QQ.exe')
文章来源:https://www.toymoban.com/news/detail-646998.html
import os
print(os.getcwd()) #返回当前的工作目录(绝对路径)
lst=os.listdir('python') #返回指定路径下的文件和目录信息,这里参数要写相对路径
print(lst)
os.makedirs('TXT/1.txt') #创建多级目录
os.mkdir('TXT/0.txt') #创建目录
os.rmdir('TXT') #删除目录
os.removedirs('TXT/1.txt') #删除多级目录
os.chdir('C:\\') #改变工作路径
print(os.getcwd())
path模块的常用方法
文章来源地址https://www.toymoban.com/news/detail-646998.html
#os.path模块
import os.path
print(os.path.abspath('1.py')) #获取文件的绝对路径
print(os.path.exists('1.py'),os.path.exists('2.py')) #判断文件是否存在T/F
print(os.path.join('C:\\download','1.py')) #目录和文件拼接操作,输出:C:\\download\\1.py
print(os.path.split('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python\\helloworld.py')) #拆分路径和文件,输出:('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python','helloworld.py')
print(os.path.splitext('helloworld.py')) #拆分文件和后缀名,输出:('helloworld','.py')
print(os.path.basename('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python\\helloworld.py')) #提取文件名,输出:helloworld.py
print(os.path.dirname('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python\\helloworld.py')) #提取目录名,输出:C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python
print(os.path.isdir('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python')) #判断是否是路径(目录)
#获取当前目录下的.txt文件
import os
path=os.getcwd()# 获取当前目录
lst=os.listdir(path)# 获取路径下的所有文件
for filename in lst:
if filename.endswith('.txt'):# 如果文件名以.txt结尾
print(filename)
#
import os
path=os.getcwd()
lst_files=os.walk(path) #遍历目录下的所有文件夹及其子文件
for dirpath,dirname,filename in lst_files:
# print(dirpath)# 当前路径
# print(dirname)# 文件夹
# print(filename)# 文件
for dir in dirname:
print(os.path.join(dirpath,dir))
for file in filename:
print(os.path.join(dirpath,file))
到了这里,关于【python】-【】的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!